NS_IMETHODIMP
npAPInsIInputStreamShim::AsyncWait(nsIInputStreamCallback *aCallback,
PRUint32 aFlags, PRUint32 aRequestedCount,
nsIEventTarget *aEventTarget)
{
this->doLock();
mCallback = nsnull;
mCallbackFlags = nsnull;
nsCOMPtr<nsIInputStreamCallback> proxy;
if (aEventTarget) {
nsresult rv = NS_NewInputStreamReadyEvent(getter_AddRefs(proxy),
aCallback, aEventTarget);
if (NS_FAILED(rv)) return rv;
aCallback = proxy;
}
if (NS_FAILED(mCloseStatus) ||
(mAvailableForPluglet && !(aFlags & WAIT_CLOSURE_ONLY))) {
// stream is already closed or readable; post event.
aCallback->OnInputStreamReady(this);
}
else {
// queue up callback object to be notified when data becomes available
mCallback = aCallback;
mCallbackFlags = aFlags;
}
this->doUnlock();
return NS_OK;
}
void
CacheFileInputStream::NotifyListener()
{
mFile->AssertOwnsLock();
LOG(("CacheFileInputStream::NotifyListener() [this=%p]", this));
MOZ_ASSERT(mCallback);
if (!mCallbackTarget) {
mCallbackTarget = CacheFileIOManager::IOTarget();
if (!mCallbackTarget) {
LOG(("CacheFileInputStream::NotifyListener() - Cannot get Cache I/O "
"thread! Using main thread for callback."));
mCallbackTarget = do_GetMainThread();
}
}
nsCOMPtr<nsIInputStreamCallback> asyncCallback =
NS_NewInputStreamReadyEvent(mCallback, mCallbackTarget);
mCallback = nullptr;
mCallbackTarget = nullptr;
asyncCallback->OnInputStreamReady(this);
}
void
MediaSourceInputAdapter::NotifyListener()
{
if (!mCallback) {
return;
}
// Don't notify unless more data is available than the threshold, except
// in the case that there's no more data coming.
if (Available() < mNotifyThreshold && !mClosed && !mMediaSource->AppendDone()) {
return;
}
nsCOMPtr<nsIInputStreamCallback> callback;
if (mCallbackTarget) {
callback = NS_NewInputStreamReadyEvent(mCallback, mCallbackTarget);
} else {
callback = mCallback;
}
MOZ_ASSERT(callback);
mCallback = nullptr;
mCallbackTarget = nullptr;
mNotifyThreshold = 0;
LOG(PR_LOG_DEBUG, ("%p IA::NotifyListener", this));
callback->OnInputStreamReady(this);
}
void
CacheFileInputStream::NotifyListener()
{
mFile->AssertOwnsLock();
LOG(("CacheFileInputStream::NotifyListener() [this=%p]", this));
MOZ_ASSERT(mCallback);
if (!mCallbackTarget)
mCallbackTarget = NS_GetCurrentThread();
nsCOMPtr<nsIInputStreamCallback> asyncCallback =
NS_NewInputStreamReadyEvent(mCallback, mCallbackTarget);
mCallback = nullptr;
mCallbackTarget = nullptr;
asyncCallback->OnInputStreamReady(this);
}
NS_IMETHODIMP
nsPipeInputStream::AsyncWait(nsIInputStreamCallback *callback,
PRUint32 flags,
PRUint32 requestedCount,
nsIEventTarget *target)
{
LOG(("III AsyncWait [this=%x]\n", this));
nsPipeEvents pipeEvents;
{
nsAutoMonitor mon(mPipe->mMonitor);
// replace a pending callback
mCallback = 0;
mCallbackFlags = 0;
if (!callback)
return NS_OK;
nsCOMPtr<nsIInputStreamCallback> proxy;
if (target) {
nsresult rv = NS_NewInputStreamReadyEvent(getter_AddRefs(proxy),
callback, target);
if (NS_FAILED(rv)) return rv;
callback = proxy;
}
if (NS_FAILED(mPipe->mStatus) ||
(mAvailable && !(flags & WAIT_CLOSURE_ONLY))) {
// stream is already closed or readable; post event.
pipeEvents.NotifyInputReady(this, callback);
}
else {
// queue up callback object to be notified when data becomes available
mCallback = callback;
mCallbackFlags = flags;
}
}
return NS_OK;
}
void
nsBaseContentStream::DispatchCallback(PRBool async)
{
if (!mCallback)
return;
// It's important to clear mCallback and mCallbackTarget up-front because the
// OnInputStreamReady implementation may call our AsyncWait method.
nsCOMPtr<nsIInputStreamCallback> callback;
if (async) {
NS_NewInputStreamReadyEvent(getter_AddRefs(callback), mCallback,
mCallbackTarget);
if (!callback)
return; // out of memory!
mCallback = nsnull;
} else {
callback.swap(mCallback);
}
mCallbackTarget = nsnull;
callback->OnInputStreamReady(this);
}
