michael@0: /* This Source Code Form is subject to the terms of the Mozilla Public
michael@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0:  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
michael@0: 
michael@0: #include "CacheLog.h"
michael@0: #include "CacheFileInputStream.h"
michael@0: 
michael@0: #include "CacheFile.h"
michael@0: #include "nsStreamUtils.h"
michael@0: #include "nsThreadUtils.h"
michael@0: #include <algorithm>
michael@0: 
michael@0: namespace mozilla {
michael@0: namespace net {
michael@0: 
michael@0: NS_IMPL_ADDREF(CacheFileInputStream)
michael@0: NS_IMETHODIMP_(MozExternalRefCountType)
michael@0: CacheFileInputStream::Release()
michael@0: {
michael@0:   NS_PRECONDITION(0 != mRefCnt, "dup release");
michael@0:   nsrefcnt count = --mRefCnt;
michael@0:   NS_LOG_RELEASE(this, count, "CacheFileInputStream");
michael@0: 
michael@0:   if (0 == count) {
michael@0:     mRefCnt = 1;
michael@0:     delete (this);
michael@0:     return 0;
michael@0:   }
michael@0: 
michael@0:   if (count == 1) {
michael@0:     mFile->RemoveInput(this);
michael@0:   }
michael@0: 
michael@0:   return count;
michael@0: }
michael@0: 
michael@0: NS_INTERFACE_MAP_BEGIN(CacheFileInputStream)
michael@0:   NS_INTERFACE_MAP_ENTRY(nsIInputStream)
michael@0:   NS_INTERFACE_MAP_ENTRY(nsIAsyncInputStream)
michael@0:   NS_INTERFACE_MAP_ENTRY(nsISeekableStream)
michael@0:   NS_INTERFACE_MAP_ENTRY(mozilla::net::CacheFileChunkListener)
michael@0:   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIInputStream)
michael@0: NS_INTERFACE_MAP_END_THREADSAFE
michael@0: 
michael@0: CacheFileInputStream::CacheFileInputStream(CacheFile *aFile)
michael@0:   : mFile(aFile)
michael@0:   , mPos(0)
michael@0:   , mClosed(false)
michael@0:   , mStatus(NS_OK)
michael@0:   , mWaitingForUpdate(false)
michael@0:   , mListeningForChunk(-1)
michael@0:   , mInReadSegments(false)
michael@0:   , mCallbackFlags(0)
michael@0: {
michael@0:   LOG(("CacheFileInputStream::CacheFileInputStream() [this=%p]", this));
michael@0:   MOZ_COUNT_CTOR(CacheFileInputStream);
michael@0: }
michael@0: 
michael@0: CacheFileInputStream::~CacheFileInputStream()
michael@0: {
michael@0:   LOG(("CacheFileInputStream::~CacheFileInputStream() [this=%p]", this));
michael@0:   MOZ_COUNT_DTOR(CacheFileInputStream);
michael@0: }
michael@0: 
michael@0: // nsIInputStream
michael@0: NS_IMETHODIMP
michael@0: CacheFileInputStream::Close()
michael@0: {
michael@0:   LOG(("CacheFileInputStream::Close() [this=%p]", this));
michael@0:   return CloseWithStatus(NS_OK);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: CacheFileInputStream::Available(uint64_t *_retval)
michael@0: {
michael@0:   CacheFileAutoLock lock(mFile);
michael@0:   MOZ_ASSERT(!mInReadSegments);
michael@0: 
michael@0:   if (mClosed) {
michael@0:     LOG(("CacheFileInputStream::Available() - Stream is closed. [this=%p, "
michael@0:          "status=0x%08x]", this, mStatus));
michael@0:     return NS_FAILED(mStatus) ? mStatus : NS_BASE_STREAM_CLOSED;
michael@0:   }
michael@0: 
michael@0:   EnsureCorrectChunk(false);
michael@0:   if (NS_FAILED(mStatus))
michael@0:     return mStatus;
michael@0: 
michael@0:   *_retval = 0;
michael@0: 
michael@0:   if (mChunk) {
michael@0:     int64_t canRead;
michael@0:     const char *buf;
michael@0:     CanRead(&canRead, &buf);
michael@0: 
michael@0:     if (canRead > 0)
michael@0:       *_retval = canRead;
michael@0:     else if (canRead == 0 && !mFile->mOutput)
michael@0:       return NS_BASE_STREAM_CLOSED;
michael@0:   }
michael@0: 
michael@0:   LOG(("CacheFileInputStream::Available() [this=%p, retval=%lld]",
michael@0:        this, *_retval));
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: CacheFileInputStream::Read(char *aBuf, uint32_t aCount, uint32_t *_retval)
michael@0: {
michael@0:   CacheFileAutoLock lock(mFile);
michael@0:   MOZ_ASSERT(!mInReadSegments);
michael@0: 
michael@0:   LOG(("CacheFileInputStream::Read() [this=%p, count=%d]", this, aCount));
michael@0: 
michael@0:   nsresult rv;
michael@0: 
michael@0:   if (mClosed) {
michael@0:     LOG(("CacheFileInputStream::Read() - Stream is closed. [this=%p, "
michael@0:          "status=0x%08x]", this, mStatus));
michael@0: 
michael@0:     if NS_FAILED(mStatus)
michael@0:       return mStatus;
michael@0: 
michael@0:     *_retval = 0;
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   EnsureCorrectChunk(false);
michael@0:   if (NS_FAILED(mStatus))
michael@0:     return mStatus;
michael@0: 
michael@0:   if (!mChunk) {
michael@0:     if (mListeningForChunk == -1) {
michael@0:       LOG(("  no chunk, returning 0 read and NS_OK"));
michael@0:       *_retval = 0;
michael@0:       return NS_OK;
michael@0:     }
michael@0:     else {
michael@0:       LOG(("  waiting for chuck, returning WOULD_BLOCK"));
michael@0:       return NS_BASE_STREAM_WOULD_BLOCK;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   int64_t canRead;
michael@0:   const char *buf;
michael@0:   CanRead(&canRead, &buf);
michael@0: 
michael@0:   if (canRead < 0) {
michael@0:     // file was truncated ???
michael@0:     MOZ_ASSERT(false, "SetEOF is currenty not implemented?!");
michael@0:     *_retval = 0;
michael@0:     rv = NS_OK;
michael@0:   }
michael@0:   else if (canRead > 0) {
michael@0:     *_retval = std::min(static_cast<uint32_t>(canRead), aCount);
michael@0:     memcpy(aBuf, buf, *_retval);
michael@0:     mPos += *_retval;
michael@0: 
michael@0:     EnsureCorrectChunk(!(canRead < aCount && mPos % kChunkSize == 0));
michael@0: 
michael@0:     rv = NS_OK;
michael@0:   }
michael@0:   else {
michael@0:     if (mFile->mOutput)
michael@0:       rv = NS_BASE_STREAM_WOULD_BLOCK;
michael@0:     else {
michael@0:       *_retval = 0;
michael@0:       rv = NS_OK;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   LOG(("CacheFileInputStream::Read() [this=%p, rv=0x%08x, retval=%d",
michael@0:        this, rv, *_retval));
michael@0: 
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: CacheFileInputStream::ReadSegments(nsWriteSegmentFun aWriter, void *aClosure,
michael@0:                                    uint32_t aCount, uint32_t *_retval)
michael@0: {
michael@0:   CacheFileAutoLock lock(mFile);
michael@0:   MOZ_ASSERT(!mInReadSegments);
michael@0: 
michael@0:   LOG(("CacheFileInputStream::ReadSegments() [this=%p, count=%d]",
michael@0:        this, aCount));
michael@0: 
michael@0:   nsresult rv;
michael@0: 
michael@0:   if (mClosed) {
michael@0:     LOG(("CacheFileInputStream::ReadSegments() - Stream is closed. [this=%p, "
michael@0:          "status=0x%08x]", this, mStatus));
michael@0: 
michael@0:     if NS_FAILED(mStatus)
michael@0:       return mStatus;
michael@0: 
michael@0:     *_retval = 0;
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   EnsureCorrectChunk(false);
michael@0:   if (NS_FAILED(mStatus))
michael@0:     return mStatus;
michael@0: 
michael@0:   if (!mChunk) {
michael@0:     if (mListeningForChunk == -1) {
michael@0:       *_retval = 0;
michael@0:       return NS_OK;
michael@0:     }
michael@0:     else {
michael@0:       return NS_BASE_STREAM_WOULD_BLOCK;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   int64_t canRead;
michael@0:   const char *buf;
michael@0:   CanRead(&canRead, &buf);
michael@0: 
michael@0:   if (canRead < 0) {
michael@0:     // file was truncated ???
michael@0:     MOZ_ASSERT(false, "SetEOF is currenty not implemented?!");
michael@0:     *_retval = 0;
michael@0:     rv = NS_OK;
michael@0:   }
michael@0:   else if (canRead > 0) {
michael@0:     uint32_t toRead = std::min(static_cast<uint32_t>(canRead), aCount);
michael@0: 
michael@0:     // We need to release the lock to avoid lock re-entering
michael@0: #ifdef DEBUG
michael@0:     int64_t oldPos = mPos;
michael@0: #endif
michael@0:     mInReadSegments = true;
michael@0:     lock.Unlock();
michael@0:     rv = aWriter(this, aClosure, buf, 0, toRead, _retval);
michael@0:     lock.Lock();
michael@0:     mInReadSegments = false;
michael@0: #ifdef DEBUG
michael@0:     MOZ_ASSERT(oldPos == mPos);
michael@0: #endif
michael@0: 
michael@0:     if (NS_SUCCEEDED(rv)) {
michael@0:       MOZ_ASSERT(*_retval <= toRead,
michael@0:                  "writer should not write more than we asked it to write");
michael@0:       mPos += *_retval;
michael@0:     }
michael@0: 
michael@0:     EnsureCorrectChunk(!(canRead < aCount && mPos % kChunkSize == 0));
michael@0: 
michael@0:     rv = NS_OK;
michael@0:   }
michael@0:   else {
michael@0:     if (mFile->mOutput)
michael@0:       rv = NS_BASE_STREAM_WOULD_BLOCK;
michael@0:     else {
michael@0:       *_retval = 0;
michael@0:       rv = NS_OK;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   LOG(("CacheFileInputStream::ReadSegments() [this=%p, rv=0x%08x, retval=%d",
michael@0:        this, rv, *_retval));
michael@0: 
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: CacheFileInputStream::IsNonBlocking(bool *_retval)
michael@0: {
michael@0:   *_retval = true;
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: // nsIAsyncInputStream
michael@0: NS_IMETHODIMP
michael@0: CacheFileInputStream::CloseWithStatus(nsresult aStatus)
michael@0: {
michael@0:   CacheFileAutoLock lock(mFile);
michael@0:   MOZ_ASSERT(!mInReadSegments);
michael@0: 
michael@0:   LOG(("CacheFileInputStream::CloseWithStatus() [this=%p, aStatus=0x%08x]",
michael@0:        this, aStatus));
michael@0: 
michael@0:   if (mClosed) {
michael@0:     MOZ_ASSERT(!mCallback);
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   mClosed = true;
michael@0:   mStatus = NS_FAILED(aStatus) ? aStatus : NS_BASE_STREAM_CLOSED;
michael@0: 
michael@0:   if (mChunk)
michael@0:     ReleaseChunk();
michael@0: 
michael@0:   // TODO propagate error from input stream to other streams ???
michael@0: 
michael@0:   MaybeNotifyListener();
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: CacheFileInputStream::AsyncWait(nsIInputStreamCallback *aCallback,
michael@0:                                 uint32_t aFlags,
michael@0:                                 uint32_t aRequestedCount,
michael@0:                                 nsIEventTarget *aEventTarget)
michael@0: {
michael@0:   CacheFileAutoLock lock(mFile);
michael@0:   MOZ_ASSERT(!mInReadSegments);
michael@0: 
michael@0:   LOG(("CacheFileInputStream::AsyncWait() [this=%p, callback=%p, flags=%d, "
michael@0:        "requestedCount=%d, eventTarget=%p]", this, aCallback, aFlags,
michael@0:        aRequestedCount, aEventTarget));
michael@0: 
michael@0:   mCallback = aCallback;
michael@0:   mCallbackFlags = aFlags;
michael@0: 
michael@0:   if (!mCallback) {
michael@0:     if (mWaitingForUpdate) {
michael@0:       mChunk->CancelWait(this);
michael@0:       mWaitingForUpdate = false;
michael@0:     }
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   if (mClosed) {
michael@0:     NotifyListener();
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   EnsureCorrectChunk(false);
michael@0: 
michael@0:   MaybeNotifyListener();
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: // nsISeekableStream
michael@0: NS_IMETHODIMP
michael@0: CacheFileInputStream::Seek(int32_t whence, int64_t offset)
michael@0: {
michael@0:   CacheFileAutoLock lock(mFile);
michael@0:   MOZ_ASSERT(!mInReadSegments);
michael@0: 
michael@0:   LOG(("CacheFileInputStream::Seek() [this=%p, whence=%d, offset=%lld]",
michael@0:        this, whence, offset));
michael@0: 
michael@0:   if (mClosed) {
michael@0:     LOG(("CacheFileInputStream::Seek() - Stream is closed. [this=%p]", this));
michael@0:     return NS_BASE_STREAM_CLOSED;
michael@0:   }
michael@0: 
michael@0:   int64_t newPos = offset;
michael@0:   switch (whence) {
michael@0:     case NS_SEEK_SET:
michael@0:       break;
michael@0:     case NS_SEEK_CUR:
michael@0:       newPos += mPos;
michael@0:       break;
michael@0:     case NS_SEEK_END:
michael@0:       newPos += mFile->mDataSize;
michael@0:       break;
michael@0:     default:
michael@0:       NS_ERROR("invalid whence");
michael@0:       return NS_ERROR_INVALID_ARG;
michael@0:   }
michael@0:   mPos = newPos;
michael@0:   EnsureCorrectChunk(true);
michael@0: 
michael@0:   LOG(("CacheFileInputStream::Seek() [this=%p, pos=%lld]", this, mPos));
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: CacheFileInputStream::Tell(int64_t *_retval)
michael@0: {
michael@0:   CacheFileAutoLock lock(mFile);
michael@0:   MOZ_ASSERT(!mInReadSegments);
michael@0: 
michael@0:   if (mClosed) {
michael@0:     LOG(("CacheFileInputStream::Tell() - Stream is closed. [this=%p]", this));
michael@0:     return NS_BASE_STREAM_CLOSED;
michael@0:   }
michael@0: 
michael@0:   *_retval = mPos;
michael@0: 
michael@0:   LOG(("CacheFileInputStream::Tell() [this=%p, retval=%lld]", this, *_retval));
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: CacheFileInputStream::SetEOF()
michael@0: {
michael@0:   MOZ_ASSERT(false, "Don't call SetEOF on cache input stream");
michael@0:   return NS_ERROR_NOT_IMPLEMENTED;
michael@0: }
michael@0: 
michael@0: // CacheFileChunkListener
michael@0: nsresult
michael@0: CacheFileInputStream::OnChunkRead(nsresult aResult, CacheFileChunk *aChunk)
michael@0: {
michael@0:   MOZ_CRASH("CacheFileInputStream::OnChunkRead should not be called!");
michael@0:   return NS_ERROR_UNEXPECTED;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: CacheFileInputStream::OnChunkWritten(nsresult aResult, CacheFileChunk *aChunk)
michael@0: {
michael@0:   MOZ_CRASH("CacheFileInputStream::OnChunkWritten should not be called!");
michael@0:   return NS_ERROR_UNEXPECTED;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: CacheFileInputStream::OnChunkAvailable(nsresult aResult, uint32_t aChunkIdx,
michael@0:                                        CacheFileChunk *aChunk)
michael@0: {
michael@0:   CacheFileAutoLock lock(mFile);
michael@0:   MOZ_ASSERT(!mInReadSegments);
michael@0: 
michael@0:   LOG(("CacheFileInputStream::OnChunkAvailable() [this=%p, result=0x%08x, "
michael@0:        "idx=%d, chunk=%p]", this, aResult, aChunkIdx, aChunk));
michael@0: 
michael@0:   MOZ_ASSERT(mListeningForChunk != -1);
michael@0: 
michael@0:   if (mListeningForChunk != static_cast<int64_t>(aChunkIdx)) {
michael@0:     // This is not a chunk that we're waiting for
michael@0:     LOG(("CacheFileInputStream::OnChunkAvailable() - Notification is for a "
michael@0:          "different chunk. [this=%p, listeningForChunk=%lld]",
michael@0:          this, mListeningForChunk));
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   MOZ_ASSERT(!mChunk);
michael@0:   MOZ_ASSERT(!mWaitingForUpdate);
michael@0:   mListeningForChunk = -1;
michael@0: 
michael@0:   if (mClosed) {
michael@0:     MOZ_ASSERT(!mCallback);
michael@0: 
michael@0:     LOG(("CacheFileInputStream::OnChunkAvailable() - Stream is closed, "
michael@0:          "ignoring notification. [this=%p]", this));
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   if (NS_SUCCEEDED(aResult)) {
michael@0:     mChunk = aChunk;
michael@0:   } else if (aResult != NS_ERROR_NOT_AVAILABLE) {
michael@0:     // We store the error in mStatus, so we can propagate it later to consumer
michael@0:     // in Read(), Available() etc. We need to handle NS_ERROR_NOT_AVAILABLE
michael@0:     // differently since it is returned when the requested chunk is not
michael@0:     // available and there is no writer that could create it, i.e. it means that
michael@0:     // we've reached the end of the file.
michael@0:     mStatus = aResult;
michael@0:   }
michael@0: 
michael@0:   MaybeNotifyListener();
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: CacheFileInputStream::OnChunkUpdated(CacheFileChunk *aChunk)
michael@0: {
michael@0:   CacheFileAutoLock lock(mFile);
michael@0:   MOZ_ASSERT(!mInReadSegments);
michael@0: 
michael@0:   LOG(("CacheFileInputStream::OnChunkUpdated() [this=%p, idx=%d]",
michael@0:        this, aChunk->Index()));
michael@0: 
michael@0:   if (!mWaitingForUpdate) {
michael@0:     LOG(("CacheFileInputStream::OnChunkUpdated() - Ignoring notification since "
michael@0:          "mWaitingforUpdate == false. [this=%p]", this));
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0:   else {
michael@0:     mWaitingForUpdate = false;
michael@0:   }
michael@0: 
michael@0:   MOZ_ASSERT(mChunk == aChunk);
michael@0: 
michael@0:   MaybeNotifyListener();
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: void
michael@0: CacheFileInputStream::ReleaseChunk()
michael@0: {
michael@0:   mFile->AssertOwnsLock();
michael@0: 
michael@0:   LOG(("CacheFileInputStream::ReleaseChunk() [this=%p, idx=%d]",
michael@0:        this, mChunk->Index()));
michael@0: 
michael@0:   if (mWaitingForUpdate) {
michael@0:     LOG(("CacheFileInputStream::ReleaseChunk() - Canceling waiting for update. "
michael@0:          "[this=%p]", this));
michael@0: 
michael@0:     mChunk->CancelWait(this);
michael@0:     mWaitingForUpdate = false;
michael@0:   }
michael@0: 
michael@0:   mFile->ReleaseOutsideLock(mChunk.forget().take());
michael@0: }
michael@0: 
michael@0: void
michael@0: CacheFileInputStream::EnsureCorrectChunk(bool aReleaseOnly)
michael@0: {
michael@0:   mFile->AssertOwnsLock();
michael@0: 
michael@0:   LOG(("CacheFileInputStream::EnsureCorrectChunk() [this=%p, releaseOnly=%d]",
michael@0:        this, aReleaseOnly));
michael@0: 
michael@0:   nsresult rv;
michael@0: 
michael@0:   uint32_t chunkIdx = mPos / kChunkSize;
michael@0: 
michael@0:   if (mChunk) {
michael@0:     if (mChunk->Index() == chunkIdx) {
michael@0:       // we have a correct chunk
michael@0:       LOG(("CacheFileInputStream::EnsureCorrectChunk() - Have correct chunk "
michael@0:            "[this=%p, idx=%d]", this, chunkIdx));
michael@0: 
michael@0:       return;
michael@0:     }
michael@0:     else {
michael@0:       ReleaseChunk();
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   MOZ_ASSERT(!mWaitingForUpdate);
michael@0: 
michael@0:   if (aReleaseOnly)
michael@0:     return;
michael@0: 
michael@0:   if (mListeningForChunk == static_cast<int64_t>(chunkIdx)) {
michael@0:     // We're already waiting for this chunk
michael@0:     LOG(("CacheFileInputStream::EnsureCorrectChunk() - Already listening for "
michael@0:          "chunk %lld [this=%p]", mListeningForChunk, this));
michael@0: 
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   rv = mFile->GetChunkLocked(chunkIdx, false, this, getter_AddRefs(mChunk));
michael@0:   if (NS_FAILED(rv)) {
michael@0:     LOG(("CacheFileInputStream::EnsureCorrectChunk() - GetChunkLocked failed. "
michael@0:          "[this=%p, idx=%d, rv=0x%08x]", this, chunkIdx, rv));
michael@0:     if (rv != NS_ERROR_NOT_AVAILABLE) {
michael@0:       // We store the error in mStatus, so we can propagate it later to consumer
michael@0:       // in Read(), Available() etc. We need to handle NS_ERROR_NOT_AVAILABLE
michael@0:       // differently since it is returned when the requested chunk is not
michael@0:       // available and there is no writer that could create it, i.e. it means
michael@0:       // that we've reached the end of the file.
michael@0:       mStatus = rv;
michael@0:     }
michael@0:   }
michael@0:   else if (!mChunk) {
michael@0:     mListeningForChunk = static_cast<int64_t>(chunkIdx);
michael@0:   }
michael@0: 
michael@0:   MaybeNotifyListener();
michael@0: }
michael@0: 
michael@0: void
michael@0: CacheFileInputStream::CanRead(int64_t *aCanRead, const char **aBuf)
michael@0: {
michael@0:   mFile->AssertOwnsLock();
michael@0: 
michael@0:   MOZ_ASSERT(mChunk);
michael@0:   MOZ_ASSERT(mPos / kChunkSize == mChunk->Index());
michael@0: 
michael@0:   uint32_t chunkOffset = mPos - (mPos / kChunkSize) * kChunkSize;
michael@0:   *aCanRead = mChunk->DataSize() - chunkOffset;
michael@0:   *aBuf = mChunk->BufForReading() + chunkOffset;
michael@0: 
michael@0:   LOG(("CacheFileInputStream::CanRead() [this=%p, canRead=%lld]",
michael@0:        this, *aCanRead));
michael@0: }
michael@0: 
michael@0: void
michael@0: CacheFileInputStream::NotifyListener()
michael@0: {
michael@0:   mFile->AssertOwnsLock();
michael@0: 
michael@0:   LOG(("CacheFileInputStream::NotifyListener() [this=%p]", this));
michael@0: 
michael@0:   MOZ_ASSERT(mCallback);
michael@0: 
michael@0:   if (!mCallbackTarget)
michael@0:     mCallbackTarget = NS_GetCurrentThread();
michael@0: 
michael@0:   nsCOMPtr<nsIInputStreamCallback> asyncCallback =
michael@0:     NS_NewInputStreamReadyEvent(mCallback, mCallbackTarget);
michael@0: 
michael@0:   mCallback = nullptr;
michael@0:   mCallbackTarget = nullptr;
michael@0: 
michael@0:   asyncCallback->OnInputStreamReady(this);
michael@0: }
michael@0: 
michael@0: void
michael@0: CacheFileInputStream::MaybeNotifyListener()
michael@0: {
michael@0:   mFile->AssertOwnsLock();
michael@0: 
michael@0:   LOG(("CacheFileInputStream::MaybeNotifyListener() [this=%p, mCallback=%p, "
michael@0:        "mClosed=%d, mStatus=0x%08x, mChunk=%p, mListeningForChunk=%lld, "
michael@0:        "mWaitingForUpdate=%d]", this, mCallback.get(), mClosed, mStatus,
michael@0:        mChunk.get(), mListeningForChunk, mWaitingForUpdate));
michael@0: 
michael@0:   if (!mCallback)
michael@0:     return;
michael@0: 
michael@0:   if (mClosed || NS_FAILED(mStatus)) {
michael@0:     NotifyListener();
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   if (!mChunk) {
michael@0:     if (mListeningForChunk == -1) {
michael@0:       // EOF, should we notify even if mCallbackFlags == WAIT_CLOSURE_ONLY ??
michael@0:       NotifyListener();
michael@0:     }
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   MOZ_ASSERT(mPos / kChunkSize == mChunk->Index());
michael@0: 
michael@0:   if (mWaitingForUpdate)
michael@0:     return;
michael@0: 
michael@0:   int64_t canRead;
michael@0:   const char *buf;
michael@0:   CanRead(&canRead, &buf);
michael@0: 
michael@0:   if (canRead > 0) {
michael@0:     if (!(mCallbackFlags & WAIT_CLOSURE_ONLY))
michael@0:       NotifyListener();
michael@0:   }
michael@0:   else if (canRead == 0) {
michael@0:     if (!mFile->mOutput) {
michael@0:       // EOF
michael@0:       NotifyListener();
michael@0:     }
michael@0:     else {
michael@0:       mChunk->WaitForUpdate(this);
michael@0:       mWaitingForUpdate = true;
michael@0:     }
michael@0:   }
michael@0:   else {
michael@0:     // Output have set EOF before mPos?
michael@0:     MOZ_ASSERT(false, "SetEOF is currenty not implemented?!");
michael@0:     NotifyListener();
michael@0:   }
michael@0: }
michael@0: 
michael@0: // Memory reporting
michael@0: 
michael@0: size_t
michael@0: CacheFileInputStream::SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const
michael@0: {
michael@0:   // Everything the stream keeps a reference to is already reported somewhere else.
michael@0:   // mFile reports itself.
michael@0:   // mChunk reported as part of CacheFile.
michael@0:   // mCallback is usually CacheFile or a class that is reported elsewhere.
michael@0:   return mallocSizeOf(this);
michael@0: }
michael@0: 
michael@0: } // net
michael@0: } // mozilla