The Tor Browser: netwerk/cache2/CacheFileInputStream.cpp@7e26c7da4463 (annotated)

netwerk/cache2/CacheFileInputStream.cpp@7e26c7da4463 (annotated)

netwerk/cache2/CacheFileInputStream.cpp

Wed, 31 Dec 2014 06:55:50 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:55:50 +0100
changeset 2: 7e26c7da4463
permissions: -rw-r--r--

Added tag UPSTREAM_283F7C6 for changeset ca08bd8f51b2

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

The Tor Browser / annotate

netwerk/cache2/CacheFileInputStream.cpp@7e26c7da4463 (annotated)

netwerk/cache2/CacheFileInputStream.cpp