CacheFile.cpp

/* 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 "CacheFile.h"

#include <algorithm>
#include <utility>

#include "CacheFileChunk.h"
#include "CacheFileInputStream.h"
#include "CacheFileOutputStream.h"
#include "CacheFileUtils.h"
#include "CacheIndex.h"
#include "CacheLog.h"
#include "mozilla/DebugOnly.h"
#include "mozilla/Telemetry.h"
#include "mozilla/TelemetryHistogramEnums.h"
#include "nsComponentManagerUtils.h"
#include "nsICacheEntry.h"
#include "nsProxyRelease.h"
#include "nsThreadUtils.h"

// When CACHE_CHUNKS is defined we always cache unused chunks in mCacheChunks.
// When it is not defined, we always release the chunks ASAP, i.e. we cache
// unused chunks only when:
//  - CacheFile is memory-only
//  - CacheFile is still waiting for the handle
//  - the chunk is preloaded

// #define CACHE_CHUNKS

namespace mozilla::net {

using CacheFileUtils::CacheFileLock;

class NotifyCacheFileListenerEvent : public Runnable {
 public:
  NotifyCacheFileListenerEvent(CacheFileListener* aCallback, nsresult aResult,
                               bool aIsNew)
      : Runnable("net::NotifyCacheFileListenerEvent"),
        mCallback(aCallback),
        mRV(aResult),
        mIsNew(aIsNew) {
    LOG(
        ("NotifyCacheFileListenerEvent::NotifyCacheFileListenerEvent() "
         "[this=%p]",
         this));
  }

 protected:
  ~NotifyCacheFileListenerEvent() {
    LOG(
        ("NotifyCacheFileListenerEvent::~NotifyCacheFileListenerEvent() "
         "[this=%p]",
         this));
  }

 public:
  NS_IMETHOD Run() override {
    LOG(("NotifyCacheFileListenerEvent::Run() [this=%p]", this));

    mCallback->OnFileReady(mRV, mIsNew);
    return NS_OK;
  }

 protected:
  nsCOMPtr<CacheFileListener> mCallback;
  nsresult mRV;
  bool mIsNew;
};

class NotifyChunkListenerEvent : public Runnable {
 public:
  NotifyChunkListenerEvent(CacheFileChunkListener* aCallback, nsresult aResult,
                           uint32_t aChunkIdx, CacheFileChunk* aChunk)
      : Runnable("net::NotifyChunkListenerEvent"),
        mCallback(aCallback),
        mRV(aResult),
        mChunkIdx(aChunkIdx),
        mChunk(aChunk) {
    LOG(("NotifyChunkListenerEvent::NotifyChunkListenerEvent() [this=%p]",
         this));
  }

 protected:
  ~NotifyChunkListenerEvent() {
    LOG(("NotifyChunkListenerEvent::~NotifyChunkListenerEvent() [this=%p]",
         this));
  }

 public:
  NS_IMETHOD Run() override {
    LOG(("NotifyChunkListenerEvent::Run() [this=%p]", this));

    mCallback->OnChunkAvailable(mRV, mChunkIdx, mChunk);
    return NS_OK;
  }

 protected:
  nsCOMPtr<CacheFileChunkListener> mCallback;
  nsresult mRV;
  uint32_t mChunkIdx;
  RefPtr<CacheFileChunk> mChunk;
};

class DoomFileHelper : public CacheFileIOListener {
 public:
  NS_DECL_THREADSAFE_ISUPPORTS

  explicit DoomFileHelper(CacheFileListener* aListener)
      : mListener(aListener) {}

  NS_IMETHOD OnFileOpened(CacheFileHandle* aHandle, nsresult aResult) override {
    MOZ_CRASH("DoomFileHelper::OnFileOpened should not be called!");
    return NS_ERROR_UNEXPECTED;
  }

  NS_IMETHOD OnDataWritten(CacheFileHandle* aHandle, const char* aBuf,
                           nsresult aResult) override {
    MOZ_CRASH("DoomFileHelper::OnDataWritten should not be called!");
    return NS_ERROR_UNEXPECTED;
  }

  NS_IMETHOD OnDataRead(CacheFileHandle* aHandle, char* aBuf,
                        nsresult aResult) override {
    MOZ_CRASH("DoomFileHelper::OnDataRead should not be called!");
    return NS_ERROR_UNEXPECTED;
  }

  NS_IMETHOD OnFileDoomed(CacheFileHandle* aHandle, nsresult aResult) override {
    if (mListener) mListener->OnFileDoomed(aResult);
    return NS_OK;
  }

  NS_IMETHOD OnEOFSet(CacheFileHandle* aHandle, nsresult aResult) override {
    MOZ_CRASH("DoomFileHelper::OnEOFSet should not be called!");
    return NS_ERROR_UNEXPECTED;
  }

  NS_IMETHOD OnFileRenamed(CacheFileHandle* aHandle,
                           nsresult aResult) override {
    MOZ_CRASH("DoomFileHelper::OnFileRenamed should not be called!");
    return NS_ERROR_UNEXPECTED;
  }

 private:
  virtual ~DoomFileHelper() = default;

  nsCOMPtr<CacheFileListener> mListener;
};

NS_IMPL_ISUPPORTS(DoomFileHelper, CacheFileIOListener)

NS_IMPL_ADDREF(CacheFile)
NS_IMPL_RELEASE(CacheFile)
NS_INTERFACE_MAP_BEGIN(CacheFile)
  NS_INTERFACE_MAP_ENTRY(mozilla::net::CacheFileChunkListener)
  NS_INTERFACE_MAP_ENTRY(mozilla::net::CacheFileIOListener)
  NS_INTERFACE_MAP_ENTRY(mozilla::net::CacheFileMetadataListener)
  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports,
                                   mozilla::net::CacheFileChunkListener)
NS_INTERFACE_MAP_END

CacheFile::CacheFile() : mLock(new CacheFileLock()) {
  LOG(("CacheFile::CacheFile() [this=%p]", this));
}

CacheFile::~CacheFile() {
  LOG(("CacheFile::~CacheFile() [this=%p]", this));

  MutexAutoLock lock(mLock->Lock());
  if (!mMemoryOnly && mReady && !mKill) {
    // mReady flag indicates we have metadata plus in a valid state.
    WriteMetadataIfNeededLocked(true);
  }
}

nsresult CacheFile::Init(const nsACString& aKey, bool aCreateNew,
                         bool aMemoryOnly, bool aSkipSizeCheck, bool aPriority,
                         bool aPinned, CacheFileListener* aCallback)
    MOZ_NO_THREAD_SAFETY_ANALYSIS {
  MOZ_ASSERT(!mListener);
  MOZ_ASSERT(!mHandle);

  MOZ_ASSERT(!(aMemoryOnly && aPinned));

  nsresult rv;

  mKey = aKey;
  mOpenAsMemoryOnly = mMemoryOnly = aMemoryOnly;
  mSkipSizeCheck = aSkipSizeCheck;
  mPriority = aPriority;
  mPinned = aPinned;

  // Some consumers (at least nsHTTPCompressConv) assume that Read() can read
  // such amount of data that was announced by Available().
  // CacheFileInputStream::Available() uses also preloaded chunks to compute
  // number of available bytes in the input stream, so we have to make sure the
  // preloadChunkCount won't change during CacheFile's lifetime since otherwise
  // we could potentially release some cached chunks that was used to calculate
  // available bytes but would not be available later during call to
  // CacheFileInputStream::Read().
  mPreloadChunkCount = CacheObserver::PreloadChunkCount();

  LOG(
      ("CacheFile::Init() [this=%p, key=%s, createNew=%d, memoryOnly=%d, "
       "priority=%d, listener=%p]",
       this, mKey.get(), aCreateNew, aMemoryOnly, aPriority, aCallback));

  if (mMemoryOnly) {
    MOZ_ASSERT(!aCallback);

    mMetadata = new CacheFileMetadata(mOpenAsMemoryOnly, false, mKey,
                                      WrapNotNull(mLock));
    mReady = true;
    mDataSize = mMetadata->Offset();
    return NS_OK;
  }
  uint32_t flags;
  if (aCreateNew) {
    MOZ_ASSERT(!aCallback);
    flags = CacheFileIOManager::CREATE_NEW;

    // make sure we can use this entry immediately
    mMetadata = new CacheFileMetadata(mOpenAsMemoryOnly, mPinned, mKey,
                                      WrapNotNull(mLock));
    mReady = true;
    mDataSize = mMetadata->Offset();
  } else {
    flags = CacheFileIOManager::CREATE;
  }

  if (mPriority) {
    flags |= CacheFileIOManager::PRIORITY;
  }

  if (mPinned) {
    flags |= CacheFileIOManager::PINNED;
  }

  mOpeningFile = true;
  mListener = aCallback;
  rv = CacheFileIOManager::OpenFile(mKey, flags, this);
  if (NS_FAILED(rv)) {
    mListener = nullptr;
    mOpeningFile = false;

    if (mPinned) {
      LOG(
          ("CacheFile::Init() - CacheFileIOManager::OpenFile() failed "
           "but we want to pin, fail the file opening. [this=%p]",
           this));
      return NS_ERROR_NOT_AVAILABLE;
    }

    if (aCreateNew) {
      NS_WARNING("Forcing memory-only entry since OpenFile failed");
      LOG(
          ("CacheFile::Init() - CacheFileIOManager::OpenFile() failed "
           "synchronously. We can continue in memory-only mode since "
           "aCreateNew == true. [this=%p]",
           this));

      mMemoryOnly = true;
    } else if (rv == NS_ERROR_NOT_INITIALIZED) {
      NS_WARNING(
          "Forcing memory-only entry since CacheIOManager isn't "
          "initialized.");
      LOG(
          ("CacheFile::Init() - CacheFileIOManager isn't initialized, "
           "initializing entry as memory-only. [this=%p]",
           this));

      mMemoryOnly = true;
      mMetadata = new CacheFileMetadata(mOpenAsMemoryOnly, mPinned, mKey,
                                        WrapNotNull(mLock));
      mReady = true;
      mDataSize = mMetadata->Offset();

      RefPtr<NotifyCacheFileListenerEvent> ev;
      ev = new NotifyCacheFileListenerEvent(aCallback, NS_OK, true);
      rv = NS_DispatchToCurrentThread(ev);
      NS_ENSURE_SUCCESS(rv, rv);
    } else {
      NS_ENSURE_SUCCESS(rv, rv);
    }
  }

  return NS_OK;
}

void CacheFile::Key(nsACString& aKey) {
  CacheFileAutoLock lock(this);
  aKey = mKey;
}

bool CacheFile::IsPinned() {
  CacheFileAutoLock lock(this);
  return mPinned;
}

nsresult CacheFile::OnChunkRead(nsresult aResult, CacheFileChunk* aChunk) {
  CacheFileAutoLock lock(this);

  nsresult rv;

  uint32_t index = aChunk->Index();

  LOG(("CacheFile::OnChunkRead() [this=%p, rv=0x%08" PRIx32
       ", chunk=%p, idx=%u]",
       this, static_cast<uint32_t>(aResult), aChunk, index));

  if (aChunk->mDiscardedChunk) {
    // We discard only unused chunks, so it must be still unused when reading
    // data finishes.
    MOZ_ASSERT(aChunk->mRefCnt == 2);
    aChunk->mActiveChunk = false;
    ReleaseOutsideLock(
        RefPtr<CacheFileChunkListener>(std::move(aChunk->mFile)));

    DebugOnly<bool> removed = mDiscardedChunks.RemoveElement(aChunk);
    MOZ_ASSERT(removed);
    return NS_OK;
  }

  if (NS_FAILED(aResult)) {
    SetError(aResult);
  }

  if (HaveChunkListeners(index)) {
    rv = NotifyChunkListeners(index, aResult, aChunk);
    NS_ENSURE_SUCCESS(rv, rv);
  }

  return NS_OK;
}

nsresult CacheFile::OnChunkWritten(nsresult aResult, CacheFileChunk* aChunk) {
  // In case the chunk was reused, made dirty and released between calls to
  // CacheFileChunk::Write() and CacheFile::OnChunkWritten(), we must write
  // the chunk to the disk again. When the chunk is unused and is dirty simply
  // addref and release (outside the lock) the chunk which ensures that
  // CacheFile::DeactivateChunk() will be called again.
  RefPtr<CacheFileChunk> deactivateChunkAgain;

  CacheFileAutoLock lock(this);

  nsresult rv;

  LOG(("CacheFile::OnChunkWritten() [this=%p, rv=0x%08" PRIx32
       ", chunk=%p, idx=%u]",
       this, static_cast<uint32_t>(aResult), aChunk, aChunk->Index()));

  MOZ_ASSERT(!mMemoryOnly);
  MOZ_ASSERT(!mOpeningFile);
  MOZ_ASSERT(mHandle);

  if (aChunk->mDiscardedChunk) {
    // We discard only unused chunks, so it must be still unused when writing
    // data finishes.
    MOZ_ASSERT(aChunk->mRefCnt == 2);
    aChunk->mActiveChunk = false;
    ReleaseOutsideLock(
        RefPtr<CacheFileChunkListener>(std::move(aChunk->mFile)));

    DebugOnly<bool> removed = mDiscardedChunks.RemoveElement(aChunk);
    MOZ_ASSERT(removed);
    return NS_OK;
  }

  if (NS_FAILED(aResult)) {
    SetError(aResult);
  }

  if (NS_SUCCEEDED(aResult) && !aChunk->IsDirty()) {
    // update hash value in metadata
    mMetadata->SetHash(aChunk->Index(), aChunk->Hash());
  }

  // notify listeners if there is any
  if (HaveChunkListeners(aChunk->Index())) {
    // don't release the chunk since there are some listeners queued
    rv = NotifyChunkListeners(aChunk->Index(), aResult, aChunk);
    if (NS_SUCCEEDED(rv)) {
      MOZ_ASSERT(aChunk->mRefCnt != 2);
      return NS_OK;
    }
  }

  if (aChunk->mRefCnt != 2) {
    LOG(
        ("CacheFile::OnChunkWritten() - Chunk is still used [this=%p, chunk=%p,"
         " refcnt=%" PRIuPTR "]",
         this, aChunk, aChunk->mRefCnt.get()));

    return NS_OK;
  }

  if (aChunk->IsDirty()) {
    LOG(
        ("CacheFile::OnChunkWritten() - Unused chunk is dirty. We must go "
         "through deactivation again. [this=%p, chunk=%p]",
         this, aChunk));

    deactivateChunkAgain = aChunk;
    return NS_OK;
  }

  bool keepChunk = false;
  if (NS_SUCCEEDED(aResult)) {
    keepChunk = ShouldCacheChunk(aChunk->Index());
    LOG(("CacheFile::OnChunkWritten() - %s unused chunk [this=%p, chunk=%p]",
         keepChunk ? "Caching" : "Releasing", this, aChunk));
  } else {
    LOG(
        ("CacheFile::OnChunkWritten() - Releasing failed chunk [this=%p, "
         "chunk=%p]",
         this, aChunk));
  }

  RemoveChunkInternal(aChunk, keepChunk);

  WriteMetadataIfNeededLocked();

  return NS_OK;
}

nsresult CacheFile::OnChunkAvailable(nsresult aResult, uint32_t aChunkIdx,
                                     CacheFileChunk* aChunk) {
  MOZ_CRASH("CacheFile::OnChunkAvailable should not be called!");
  return NS_ERROR_UNEXPECTED;
}

nsresult CacheFile::OnChunkUpdated(CacheFileChunk* aChunk) {
  MOZ_CRASH("CacheFile::OnChunkUpdated should not be called!");
  return NS_ERROR_UNEXPECTED;
}

nsresult CacheFile::OnFileOpened(CacheFileHandle* aHandle, nsresult aResult) {
  // Using an 'auto' class to perform doom or fail the listener
  // outside the CacheFile's lock.
  class AutoFailDoomListener {
   public:
    explicit AutoFailDoomListener(CacheFileHandle* aHandle)
        : mHandle(aHandle), mAlreadyDoomed(false) {}
    ~AutoFailDoomListener() {
      if (!mListener) return;

      if (mHandle) {
        if (mAlreadyDoomed) {
          mListener->OnFileDoomed(mHandle, NS_OK);
        } else {
          CacheFileIOManager::DoomFile(mHandle, mListener);
        }
      } else {
        mListener->OnFileDoomed(nullptr, NS_ERROR_NOT_AVAILABLE);
      }
    }

    CacheFileHandle* mHandle;
    nsCOMPtr<CacheFileIOListener> mListener;
    bool mAlreadyDoomed;
  } autoDoom(aHandle);

  RefPtr<CacheFileMetadata> metadata;
  nsCOMPtr<CacheFileListener> listener;
  bool isNew = false;
  nsresult retval = NS_OK;

  {
    CacheFileAutoLock lock(this);

    MOZ_ASSERT(mOpeningFile);
    MOZ_ASSERT((NS_SUCCEEDED(aResult) && aHandle) ||
               (NS_FAILED(aResult) && !aHandle));
    MOZ_ASSERT((mListener && !mMetadata) ||  // !createNew
               (!mListener && mMetadata));   // createNew
    MOZ_ASSERT(!mMemoryOnly || mMetadata);   // memory-only was set on new entry

    LOG(("CacheFile::OnFileOpened() [this=%p, rv=0x%08" PRIx32 ", handle=%p]",
         this, static_cast<uint32_t>(aResult), aHandle));

    mOpeningFile = false;

    autoDoom.mListener.swap(mDoomAfterOpenListener);

    if (mMemoryOnly) {
      // We can be here only in case the entry was initilized as createNew and
      // SetMemoryOnly() was called.

      // Just don't store the handle into mHandle and exit
      autoDoom.mAlreadyDoomed = true;
      return NS_OK;
    }

    if (NS_FAILED(aResult)) {
      if (mMetadata) {
        // This entry was initialized as createNew, just switch to memory-only
        // mode.
        NS_WARNING("Forcing memory-only entry since OpenFile failed");
        LOG(
            ("CacheFile::OnFileOpened() - CacheFileIOManager::OpenFile() "
             "failed asynchronously. We can continue in memory-only mode since "
             "aCreateNew == true. [this=%p]",
             this));

        mMemoryOnly = true;
        return NS_OK;
      }

      if (aResult == NS_ERROR_FILE_INVALID_PATH) {
        // CacheFileIOManager doesn't have mCacheDirectory, switch to
        // memory-only mode.
        NS_WARNING(
            "Forcing memory-only entry since CacheFileIOManager doesn't "
            "have mCacheDirectory.");
        LOG(
            ("CacheFile::OnFileOpened() - CacheFileIOManager doesn't have "
             "mCacheDirectory, initializing entry as memory-only. [this=%p]",
             this));

        mMemoryOnly = true;
        mMetadata = new CacheFileMetadata(mOpenAsMemoryOnly, mPinned, mKey,
                                          WrapNotNull(mLock));
        mReady = true;
        mDataSize = mMetadata->Offset();

        isNew = true;
        retval = NS_OK;
      } else {
        // CacheFileIOManager::OpenFile() failed for another reason.
        isNew = false;
        retval = aResult;
      }

      mListener.swap(listener);
    } else {
      mHandle = aHandle;
      if (NS_FAILED(mStatus)) {
        CacheFileIOManager::DoomFile(mHandle, nullptr);
      }

      if (mMetadata) {
        InitIndexEntry();

        // The entry was initialized as createNew, don't try to read metadata.
        mMetadata->SetHandle(mHandle);

        // Write all cached chunks, otherwise they may stay unwritten.
        for (auto iter = mCachedChunks.Iter(); !iter.Done(); iter.Next()) {
          uint32_t idx = iter.Key();
          RefPtr<CacheFileChunk>& chunk = iter.Data();

          LOG(("CacheFile::OnFileOpened() - write [this=%p, idx=%u, chunk=%p]",
               this, idx, chunk.get()));

          mChunks.InsertOrUpdate(idx, RefPtr{chunk});
          chunk->mFile = this;
          chunk->mActiveChunk = true;

          MOZ_ASSERT(chunk->IsReady());

          // This would be cleaner if we had an nsRefPtr constructor that took
          // a RefPtr<Derived>.
          ReleaseOutsideLock(std::move(chunk));

          iter.Remove();
        }

        return NS_OK;
      }
    }
    if (listener) {
      lock.Unlock();
      listener->OnFileReady(retval, isNew);
      return NS_OK;
    }

    MOZ_ASSERT(NS_SUCCEEDED(aResult));
    MOZ_ASSERT(!mMetadata);
    MOZ_ASSERT(mListener);

    // mMetaData is protected by a lock, but ReadMetaData has to be called
    // without the lock.  Alternatively we could make a
    // "ReadMetaDataLocked", and temporarily unlock to call OnFileReady
    metadata = mMetadata =
        new CacheFileMetadata(mHandle, mKey, WrapNotNull(mLock));
  }
  metadata->ReadMetadata(this);
  return NS_OK;
}

nsresult CacheFile::OnDataWritten(CacheFileHandle* aHandle, const char* aBuf,
                                  nsresult aResult) {
  MOZ_CRASH("CacheFile::OnDataWritten should not be called!");
  return NS_ERROR_UNEXPECTED;
}

nsresult CacheFile::OnDataRead(CacheFileHandle* aHandle, char* aBuf,
                               nsresult aResult) {
  MOZ_CRASH("CacheFile::OnDataRead should not be called!");
  return NS_ERROR_UNEXPECTED;
}

nsresult CacheFile::OnMetadataRead(nsresult aResult) {
  nsCOMPtr<CacheFileListener> listener;
  bool isNew = false;
  {
    CacheFileAutoLock lock(this);
    MOZ_ASSERT(mListener);

    LOG(("CacheFile::OnMetadataRead() [this=%p, rv=0x%08" PRIx32 "]", this,
         static_cast<uint32_t>(aResult)));

    if (NS_SUCCEEDED(aResult)) {
      mPinned = mMetadata->Pinned();
      mReady = true;
      mDataSize = mMetadata->Offset();
      if (mDataSize == 0 && mMetadata->ElementsSize() == 0) {
        isNew = true;
        mMetadata->MarkDirty();
      } else {
        const char* altData =
            mMetadata->GetElement(CacheFileUtils::kAltDataKey);
        if (altData && (NS_FAILED(CacheFileUtils::ParseAlternativeDataInfo(
                            altData, &mAltDataOffset, &mAltDataType)) ||
                        (mAltDataOffset > mDataSize))) {
          // alt-metadata cannot be parsed or alt-data offset is invalid
          mMetadata->InitEmptyMetadata();
          isNew = true;
          mAltDataOffset = -1;
          mAltDataType.Truncate();
          mDataSize = 0;
        } else {
          PreloadChunks(0);
        }
      }

      InitIndexEntry();
    }

    mListener.swap(listener);
  }
  listener->OnFileReady(aResult, isNew);
  return NS_OK;
}

nsresult CacheFile::OnMetadataWritten(nsresult aResult) {
  CacheFileAutoLock lock(this);

  LOG(("CacheFile::OnMetadataWritten() [this=%p, rv=0x%08" PRIx32 "]", this,
       static_cast<uint32_t>(aResult)));

  MOZ_ASSERT(mWritingMetadata);
  mWritingMetadata = false;

  MOZ_ASSERT(!mMemoryOnly);
  MOZ_ASSERT(!mOpeningFile);

  if (NS_WARN_IF(NS_FAILED(aResult))) {
    // TODO close streams with an error ???
    SetError(aResult);
  }

  if (mOutput || mInputs.Length() || mChunks.Count()) return NS_OK;

  if (IsDirty()) WriteMetadataIfNeededLocked();

  if (!mWritingMetadata) {
    LOG(("CacheFile::OnMetadataWritten() - Releasing file handle [this=%p]",
         this));
    CacheFileIOManager::ReleaseNSPRHandle(mHandle);
  }

  return NS_OK;
}

nsresult CacheFile::OnFileDoomed(CacheFileHandle* aHandle, nsresult aResult) {
  nsCOMPtr<CacheFileListener> listener;

  {
    CacheFileAutoLock lock(this);

    MOZ_ASSERT(mListener);

    LOG(("CacheFile::OnFileDoomed() [this=%p, rv=0x%08" PRIx32 ", handle=%p]",
         this, static_cast<uint32_t>(aResult), aHandle));

    mListener.swap(listener);
  }

  listener->OnFileDoomed(aResult);
  return NS_OK;
}

nsresult CacheFile::OnEOFSet(CacheFileHandle* aHandle, nsresult aResult) {
  MOZ_CRASH("CacheFile::OnEOFSet should not be called!");
  return NS_ERROR_UNEXPECTED;
}

nsresult CacheFile::OnFileRenamed(CacheFileHandle* aHandle, nsresult aResult) {
  MOZ_CRASH("CacheFile::OnFileRenamed should not be called!");
  return NS_ERROR_UNEXPECTED;
}

bool CacheFile::IsKilled() {
  bool killed = mKill;
  if (killed) {
    LOG(("CacheFile is killed, this=%p", this));
  }

  return killed;
}

nsresult CacheFile::OpenInputStream(nsICacheEntry* aEntryHandle,
                                    nsIInputStream** _retval) {
  CacheFileAutoLock lock(this);

  MOZ_ASSERT(mHandle || mMemoryOnly || mOpeningFile);

  if (!mReady) {
    LOG(("CacheFile::OpenInputStream() - CacheFile is not ready [this=%p]",
         this));

    return NS_ERROR_NOT_AVAILABLE;
  }

  if (NS_FAILED(mStatus)) {
    LOG(
        ("CacheFile::OpenInputStream() - CacheFile is in a failure state "
         "[this=%p, status=0x%08" PRIx32 "]",
         this, static_cast<uint32_t>(mStatus)));

    // Don't allow opening the input stream when this CacheFile is in
    // a failed state.  This is the only way to protect consumers correctly
    // from reading a broken entry.  When the file is in the failed state,
    // it's also doomed, so reopening the entry won't make any difference -
    // data will still be inaccessible anymore.  Note that for just doomed
    // files, we must allow reading the data.
    return mStatus;
  }

  // Once we open input stream we no longer allow preloading of chunks without
  // input stream, i.e. we will no longer keep first few chunks preloaded when
  // the last input stream is closed.
  mPreloadWithoutInputStreams = false;

  CacheFileInputStream* input =
      new CacheFileInputStream(this, aEntryHandle, false);
  LOG(("CacheFile::OpenInputStream() - Creating new input stream %p [this=%p]",
       input, this));

  mInputs.AppendElement(input);
  NS_ADDREF(input);

  mDataAccessed = true;
  *_retval = do_AddRef(input).take();
  return NS_OK;
}

nsresult CacheFile::OpenAlternativeInputStream(nsICacheEntry* aEntryHandle,
                                               const char* aAltDataType,
                                               nsIInputStream** _retval) {
  CacheFileAutoLock lock(this);

  MOZ_ASSERT(mHandle || mMemoryOnly || mOpeningFile);

  if (NS_WARN_IF(!mReady)) {
    LOG(
        ("CacheFile::OpenAlternativeInputStream() - CacheFile is not ready "
         "[this=%p]",
         this));
    return NS_ERROR_NOT_AVAILABLE;
  }

  if (mAltDataOffset == -1) {
    LOG(
        ("CacheFile::OpenAlternativeInputStream() - Alternative data is not "
         "available [this=%p]",
         this));
    return NS_ERROR_NOT_AVAILABLE;
  }

  if (NS_FAILED(mStatus)) {
    LOG(
        ("CacheFile::OpenAlternativeInputStream() - CacheFile is in a failure "
         "state [this=%p, status=0x%08" PRIx32 "]",
         this, static_cast<uint32_t>(mStatus)));

    // Don't allow opening the input stream when this CacheFile is in
    // a failed state.  This is the only way to protect consumers correctly
    // from reading a broken entry.  When the file is in the failed state,
    // it's also doomed, so reopening the entry won't make any difference -
    // data will still be inaccessible anymore.  Note that for just doomed
    // files, we must allow reading the data.
    return mStatus;
  }

  if (mAltDataType != aAltDataType) {
    LOG(
        ("CacheFile::OpenAlternativeInputStream() - Alternative data is of a "
         "different type than requested [this=%p, availableType=%s, "
         "requestedType=%s]",
         this, mAltDataType.get(), aAltDataType));
    return NS_ERROR_NOT_AVAILABLE;
  }

  // Once we open input stream we no longer allow preloading of chunks without
  // input stream, i.e. we will no longer keep first few chunks preloaded when
  // the last input stream is closed.
  mPreloadWithoutInputStreams = false;

  CacheFileInputStream* input =
      new CacheFileInputStream(this, aEntryHandle, true);

  LOG(
      ("CacheFile::OpenAlternativeInputStream() - Creating new input stream %p "
       "[this=%p]",
       input, this));

  mInputs.AppendElement(input);
  NS_ADDREF(input);

  mDataAccessed = true;
  *_retval = do_AddRef(input).take();

  return NS_OK;
}

nsresult CacheFile::OpenOutputStream(CacheOutputCloseListener* aCloseListener,
                                     nsIOutputStream** _retval) {
  CacheFileAutoLock lock(this);

  MOZ_ASSERT(mHandle || mMemoryOnly || mOpeningFile);

  nsresult rv;

  if (!mReady) {
    LOG(("CacheFile::OpenOutputStream() - CacheFile is not ready [this=%p]",
         this));

    return NS_ERROR_NOT_AVAILABLE;
  }

  if (mOutput) {
    LOG(
        ("CacheFile::OpenOutputStream() - We already have output stream %p "
         "[this=%p]",
         mOutput, this));

    return NS_ERROR_NOT_AVAILABLE;
  }

  if (NS_FAILED(mStatus)) {
    LOG(
        ("CacheFile::OpenOutputStream() - CacheFile is in a failure state "
         "[this=%p, status=0x%08" PRIx32 "]",
         this, static_cast<uint32_t>(mStatus)));

    // The CacheFile is already doomed. It make no sense to allow to write any
    // data to such entry.
    return mStatus;
  }

  // Fail if there is any input stream opened for alternative data
  for (uint32_t i = 0; i < mInputs.Length(); ++i) {
    if (mInputs[i]->IsAlternativeData()) {
      return NS_ERROR_NOT_AVAILABLE;
    }
  }

  if (mAltDataOffset != -1) {
    // Remove alt-data
    rv = Truncate(mAltDataOffset);
    if (NS_FAILED(rv)) {
      LOG(
          ("CacheFile::OpenOutputStream() - Truncating alt-data failed "
           "[rv=0x%08" PRIx32 "]",
           static_cast<uint32_t>(rv)));
      return rv;
    }
    SetAltMetadata(nullptr);
    mAltDataOffset = -1;
    mAltDataType.Truncate();
  }

  // Once we open output stream we no longer allow preloading of chunks without
  // input stream. There is no reason to believe that some input stream will be
  // opened soon. Otherwise we would cache unused chunks of all newly created
  // entries until the CacheFile is destroyed.
  mPreloadWithoutInputStreams = false;

  mOutput = new CacheFileOutputStream(this, aCloseListener, false);

  LOG(
      ("CacheFile::OpenOutputStream() - Creating new output stream %p "
       "[this=%p]",
       mOutput, this));

  mDataAccessed = true;
  *_retval = do_AddRef(mOutput).take();
  return NS_OK;
}

nsresult CacheFile::OpenAlternativeOutputStream(
    CacheOutputCloseListener* aCloseListener, const char* aAltDataType,
    nsIAsyncOutputStream** _retval) {
  CacheFileAutoLock lock(this);

  MOZ_ASSERT(mHandle || mMemoryOnly || mOpeningFile);

  if (!mReady) {
    LOG(
        ("CacheFile::OpenAlternativeOutputStream() - CacheFile is not ready "
         "[this=%p]",
         this));

    return NS_ERROR_NOT_AVAILABLE;
  }

  if (mOutput) {
    LOG(
        ("CacheFile::OpenAlternativeOutputStream() - We already have output "
         "stream %p [this=%p]",
         mOutput, this));

    return NS_ERROR_NOT_AVAILABLE;
  }

  if (NS_FAILED(mStatus)) {
    LOG(
        ("CacheFile::OpenAlternativeOutputStream() - CacheFile is in a failure "
         "state [this=%p, status=0x%08" PRIx32 "]",
         this, static_cast<uint32_t>(mStatus)));

    // The CacheFile is already doomed. It make no sense to allow to write any
    // data to such entry.
    return mStatus;
  }

  // Fail if there is any input stream opened for alternative data
  for (uint32_t i = 0; i < mInputs.Length(); ++i) {
    if (mInputs[i]->IsAlternativeData()) {
      return NS_ERROR_NOT_AVAILABLE;
    }
  }

  nsresult rv;

  if (mAltDataOffset != -1) {
    // Truncate old alt-data
    rv = Truncate(mAltDataOffset);
    if (NS_FAILED(rv)) {
      LOG(
          ("CacheFile::OpenAlternativeOutputStream() - Truncating old alt-data "
           "failed [rv=0x%08" PRIx32 "]",
           static_cast<uint32_t>(rv)));
      return rv;
    }
  } else {
    mAltDataOffset = mDataSize;
  }

  nsAutoCString altMetadata;
  CacheFileUtils::BuildAlternativeDataInfo(aAltDataType, mAltDataOffset,
                                           altMetadata);
  rv = SetAltMetadata(altMetadata.get());
  if (NS_FAILED(rv)) {
    LOG(
        ("CacheFile::OpenAlternativeOutputStream() - Set Metadata for alt-data"
         "failed [rv=0x%08" PRIx32 "]",
         static_cast<uint32_t>(rv)));
    return rv;
  }

  // Once we open output stream we no longer allow preloading of chunks without
  // input stream. There is no reason to believe that some input stream will be
  // opened soon. Otherwise we would cache unused chunks of all newly created
  // entries until the CacheFile is destroyed.
  mPreloadWithoutInputStreams = false;

  mOutput = new CacheFileOutputStream(this, aCloseListener, true);

  LOG(
      ("CacheFile::OpenAlternativeOutputStream() - Creating new output stream "
       "%p [this=%p]",
       mOutput, this));

  mDataAccessed = true;
  mAltDataType = aAltDataType;
  *_retval = do_AddRef(mOutput).take();
  return NS_OK;
}

nsresult CacheFile::SetMemoryOnly() {
  CacheFileAutoLock lock(this);

  LOG(("CacheFile::SetMemoryOnly() mMemoryOnly=%d [this=%p]", mMemoryOnly,
       this));

  if (mMemoryOnly) return NS_OK;

  MOZ_ASSERT(mReady);

  if (!mReady) {
    LOG(("CacheFile::SetMemoryOnly() - CacheFile is not ready [this=%p]",
         this));

    return NS_ERROR_NOT_AVAILABLE;
  }

  if (mDataAccessed) {
    LOG(("CacheFile::SetMemoryOnly() - Data was already accessed [this=%p]",
         this));
    return NS_ERROR_NOT_AVAILABLE;
  }

  // TODO what to do when this isn't a new entry and has an existing metadata???
  mMemoryOnly = true;
  return NS_OK;
}

nsresult CacheFile::Doom(CacheFileListener* aCallback) {
  LOG(("CacheFile::Doom() [this=%p, listener=%p]", this, aCallback));

  CacheFileAutoLock lock(this);

  return DoomLocked(aCallback);
}

nsresult CacheFile::DoomLocked(CacheFileListener* aCallback) {
  AssertOwnsLock();
  MOZ_ASSERT(mHandle || mMemoryOnly || mOpeningFile);

  LOG(("CacheFile::DoomLocked() [this=%p, listener=%p]", this, aCallback));

  nsresult rv = NS_OK;

  if (mMemoryOnly) {
    return NS_ERROR_FILE_NOT_FOUND;
  }

  if (mHandle && mHandle->IsDoomed()) {
    return NS_ERROR_FILE_NOT_FOUND;
  }

  nsCOMPtr<CacheFileIOListener> listener;
  if (aCallback || !mHandle) {
    listener = new DoomFileHelper(aCallback);
  }
  if (mHandle) {
    rv = CacheFileIOManager::DoomFile(mHandle, listener);
  } else if (mOpeningFile) {
    mDoomAfterOpenListener = listener;
  }

  return rv;
}

nsresult CacheFile::ThrowMemoryCachedData() {
  CacheFileAutoLock lock(this);

  LOG(("CacheFile::ThrowMemoryCachedData() [this=%p]", this));

  if (mMemoryOnly) {
    // This method should not be called when the CacheFile was initialized as
    // memory-only, but it can be called when CacheFile end up as memory-only
    // due to e.g. IO failure since CacheEntry doesn't know it.
    LOG(
        ("CacheFile::ThrowMemoryCachedData() - Ignoring request because the "
         "entry is memory-only. [this=%p]",
         this));

    return NS_ERROR_NOT_AVAILABLE;
  }

  if (mOpeningFile) {
    // mayhemer, note: we shouldn't get here, since CacheEntry prevents loading
    // entries from being purged.

    LOG(
        ("CacheFile::ThrowMemoryCachedData() - Ignoring request because the "
         "entry is still opening the file [this=%p]",
         this));

    return NS_ERROR_ABORT;
  }

  // We cannot release all cached chunks since we need to keep preloaded chunks
  // in memory. See initialization of mPreloadChunkCount for explanation.
  CleanUpCachedChunks();

  return NS_OK;
}

nsresult CacheFile::GetElement(const char* aKey, char** _retval) {
  CacheFileAutoLock lock(this);
  MOZ_ASSERT(mMetadata);
  NS_ENSURE_TRUE(mMetadata, NS_ERROR_UNEXPECTED);

  const char* value;
  value = mMetadata->GetElement(aKey);
  if (!value) return NS_ERROR_NOT_AVAILABLE;

  *_retval = NS_xstrdup(value);
  return NS_OK;
}

nsresult CacheFile::SetElement(const char* aKey, const char* aValue) {
  CacheFileAutoLock lock(this);

  LOG(("CacheFile::SetElement() this=%p", this));

  MOZ_ASSERT(mMetadata);
  NS_ENSURE_TRUE(mMetadata, NS_ERROR_UNEXPECTED);

  if (!strcmp(aKey, CacheFileUtils::kAltDataKey)) {
    NS_ERROR(
        "alt-data element is reserved for internal use and must not be "
        "changed via CacheFile::SetElement()");
    return NS_ERROR_FAILURE;
  }

  PostWriteTimer();
  return mMetadata->SetElement(aKey, aValue);
}

nsresult CacheFile::VisitMetaData(nsICacheEntryMetaDataVisitor* aVisitor) {
  CacheFileAutoLock lock(this);
  MOZ_ASSERT(mMetadata);
  MOZ_ASSERT(mReady);
  NS_ENSURE_TRUE(mMetadata, NS_ERROR_UNEXPECTED);

  mMetadata->Visit(aVisitor);
  return NS_OK;
}

nsresult CacheFile::ElementsSize(uint32_t* _retval) {
  CacheFileAutoLock lock(this);

  if (!mMetadata) return NS_ERROR_NOT_AVAILABLE;

  *_retval = mMetadata->ElementsSize();
  return NS_OK;
}

nsresult CacheFile::SetExpirationTime(uint32_t aExpirationTime) {
  CacheFileAutoLock lock(this);

  LOG(("CacheFile::SetExpirationTime() this=%p, expiration=%u", this,
       aExpirationTime));

  MOZ_ASSERT(mMetadata);
  NS_ENSURE_TRUE(mMetadata, NS_ERROR_UNEXPECTED);

  PostWriteTimer();
  mMetadata->SetExpirationTime(aExpirationTime);
  return NS_OK;
}

nsresult CacheFile::GetExpirationTime(uint32_t* _retval) {
  CacheFileAutoLock lock(this);
  MOZ_ASSERT(mMetadata);
  NS_ENSURE_TRUE(mMetadata, NS_ERROR_UNEXPECTED);

  *_retval = mMetadata->GetExpirationTime();
  return NS_OK;
}

nsresult CacheFile::SetFrecency(uint32_t aFrecency) {
  CacheFileAutoLock lock(this);

  LOG(("CacheFile::SetFrecency() this=%p, frecency=%u", this, aFrecency));

  MOZ_ASSERT(mMetadata);
  NS_ENSURE_TRUE(mMetadata, NS_ERROR_UNEXPECTED);

  PostWriteTimer();

  if (mHandle && !mHandle->IsDoomed()) {
    CacheFileIOManager::UpdateIndexEntry(mHandle, &aFrecency, nullptr, nullptr,
                                         nullptr, nullptr);
  }

  mMetadata->SetFrecency(aFrecency);
  return NS_OK;
}

nsresult CacheFile::GetFrecency(uint32_t* _retval) {
  CacheFileAutoLock lock(this);
  MOZ_ASSERT(mMetadata);
  NS_ENSURE_TRUE(mMetadata, NS_ERROR_UNEXPECTED);
  *_retval = mMetadata->GetFrecency();
  return NS_OK;
}

nsresult CacheFile::SetNetworkTimes(uint64_t aOnStartTime,
                                    uint64_t aOnStopTime) {
  CacheFileAutoLock lock(this);

  LOG(("CacheFile::SetNetworkTimes() this=%p, aOnStartTime=%" PRIu64
       ", aOnStopTime=%" PRIu64 "",
       this, aOnStartTime, aOnStopTime));

  MOZ_ASSERT(mMetadata);
  NS_ENSURE_TRUE(mMetadata, NS_ERROR_UNEXPECTED);

  PostWriteTimer();

  nsAutoCString onStartTime;
  onStartTime.AppendInt(aOnStartTime);
  nsresult rv =
      mMetadata->SetElement("net-response-time-onstart", onStartTime.get());
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return rv;
  }

  nsAutoCString onStopTime;
  onStopTime.AppendInt(aOnStopTime);
  rv = mMetadata->SetElement("net-response-time-onstop", onStopTime.get());
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return rv;
  }

  uint16_t onStartTime16 = aOnStartTime <= kIndexTimeOutOfBound
                               ? aOnStartTime
                               : kIndexTimeOutOfBound;
  uint16_t onStopTime16 =
      aOnStopTime <= kIndexTimeOutOfBound ? aOnStopTime : kIndexTimeOutOfBound;

  if (mHandle && !mHandle->IsDoomed()) {
    CacheFileIOManager::UpdateIndexEntry(
        mHandle, nullptr, nullptr, &onStartTime16, &onStopTime16, nullptr);
  }
  return NS_OK;
}

nsresult CacheFile::GetOnStartTime(uint64_t* _retval) {
  CacheFileAutoLock lock(this);

  MOZ_ASSERT(mMetadata);
  const char* onStartTimeStr =
      mMetadata->GetElement("net-response-time-onstart");
  if (!onStartTimeStr) {
    return NS_ERROR_NOT_AVAILABLE;
  }
  nsresult rv;
  *_retval = nsDependentCString(onStartTimeStr).ToInteger64(&rv);
  MOZ_ASSERT(NS_SUCCEEDED(rv));
  return NS_OK;
}

nsresult CacheFile::GetOnStopTime(uint64_t* _retval) {
  CacheFileAutoLock lock(this);

  MOZ_ASSERT(mMetadata);
  const char* onStopTimeStr = mMetadata->GetElement("net-response-time-onstop");
  if (!onStopTimeStr) {
    return NS_ERROR_NOT_AVAILABLE;
  }
  nsresult rv;
  *_retval = nsDependentCString(onStopTimeStr).ToInteger64(&rv);
  MOZ_ASSERT(NS_SUCCEEDED(rv));
  return NS_OK;
}

nsresult CacheFile::SetContentType(uint8_t aContentType) {
  CacheFileAutoLock lock(this);

  LOG(("CacheFile::SetContentType() this=%p, contentType=%u", this,
       aContentType));

  MOZ_ASSERT(mMetadata);
  NS_ENSURE_TRUE(mMetadata, NS_ERROR_UNEXPECTED);

  PostWriteTimer();

  // Save the content type to metadata for case we need to rebuild the index.
  nsAutoCString contentType;
  contentType.AppendInt(aContentType);
  nsresult rv = mMetadata->SetElement("ctid", contentType.get());
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return rv;
  }

  if (mHandle && !mHandle->IsDoomed()) {
    CacheFileIOManager::UpdateIndexEntry(mHandle, nullptr, nullptr, nullptr,
                                         nullptr, &aContentType);
  }
  return NS_OK;
}

nsresult CacheFile::SetAltMetadata(const char* aAltMetadata) {
  AssertOwnsLock();
  LOG(("CacheFile::SetAltMetadata() this=%p, aAltMetadata=%s", this,
       aAltMetadata ? aAltMetadata : ""));

  MOZ_ASSERT(mMetadata);
  NS_ENSURE_TRUE(mMetadata, NS_ERROR_UNEXPECTED);

  PostWriteTimer();

  nsresult rv =
      mMetadata->SetElement(CacheFileUtils::kAltDataKey, aAltMetadata);

  bool hasAltData = !!aAltMetadata;

  if (NS_FAILED(rv)) {
    // Removing element shouldn't fail because it doesn't allocate memory.
    mMetadata->SetElement(CacheFileUtils::kAltDataKey, nullptr);

    mAltDataOffset = -1;
    mAltDataType.Truncate();
    hasAltData = false;
  }

  if (mHandle && !mHandle->IsDoomed()) {
    CacheFileIOManager::UpdateIndexEntry(mHandle, nullptr, &hasAltData, nullptr,
                                         nullptr, nullptr);
  }
  return rv;
}

nsresult CacheFile::GetLastModified(uint32_t* _retval) {
  CacheFileAutoLock lock(this);
  MOZ_ASSERT(mMetadata);
  NS_ENSURE_TRUE(mMetadata, NS_ERROR_UNEXPECTED);

  *_retval = mMetadata->GetLastModified();
  return NS_OK;
}

nsresult CacheFile::GetLastFetched(uint32_t* _retval) {
  CacheFileAutoLock lock(this);
  MOZ_ASSERT(mMetadata);
  NS_ENSURE_TRUE(mMetadata, NS_ERROR_UNEXPECTED);

  *_retval = mMetadata->GetLastFetched();
  return NS_OK;
}

nsresult CacheFile::GetFetchCount(uint32_t* _retval) {
  CacheFileAutoLock lock(this);
  MOZ_ASSERT(mMetadata);
  NS_ENSURE_TRUE(mMetadata, NS_ERROR_UNEXPECTED);
  *_retval = mMetadata->GetFetchCount();
  return NS_OK;
}

nsresult CacheFile::GetDiskStorageSizeInKB(uint32_t* aDiskStorageSize) {
  CacheFileAutoLock lock(this);
  if (!mHandle) {
    return NS_ERROR_NOT_AVAILABLE;
  }

  *aDiskStorageSize = mHandle->FileSizeInK();
  return NS_OK;
}

nsresult CacheFile::OnFetched() {
  CacheFileAutoLock lock(this);

  LOG(("CacheFile::OnFetched() this=%p", this));

  MOZ_ASSERT(mMetadata);
  NS_ENSURE_TRUE(mMetadata, NS_ERROR_UNEXPECTED);

  PostWriteTimer();

  mMetadata->OnFetched();
  return NS_OK;
}

void CacheFile::ReleaseOutsideLock(RefPtr<nsISupports> aObject) {
  AssertOwnsLock();

  mObjsToRelease.AppendElement(std::move(aObject));
}

nsresult CacheFile::GetChunkLocked(uint32_t aIndex, ECallerType aCaller,
                                   CacheFileChunkListener* aCallback,
                                   CacheFileChunk** _retval) {
  AssertOwnsLock();

  LOG(("CacheFile::GetChunkLocked() [this=%p, idx=%u, caller=%d, listener=%p]",
       this, aIndex, aCaller, aCallback));

  MOZ_ASSERT(mReady);
  MOZ_ASSERT(mHandle || mMemoryOnly || mOpeningFile);
  MOZ_ASSERT((aCaller == READER && aCallback) ||
             (aCaller == WRITER && !aCallback) ||
             (aCaller == PRELOADER && !aCallback));

  // Preload chunks from disk when this is disk backed entry and the listener
  // is reader.
  bool preload = !mMemoryOnly && (aCaller == READER);

  nsresult rv;

  RefPtr<CacheFileChunk> chunk;
  if (mChunks.Get(aIndex, getter_AddRefs(chunk))) {
    LOG(("CacheFile::GetChunkLocked() - Found chunk %p in mChunks [this=%p]",
         chunk.get(), this));

    // Preloader calls this method to preload only non-loaded chunks.
    MOZ_ASSERT(aCaller != PRELOADER, "Unexpected!");

    // We might get failed chunk between releasing the lock in
    // CacheFileChunk::OnDataWritten/Read and CacheFile::OnChunkWritten/Read
    rv = chunk->GetStatus();
    if (NS_FAILED(rv)) {
      SetError(rv);
      LOG(
          ("CacheFile::GetChunkLocked() - Found failed chunk in mChunks "
           "[this=%p]",
           this));
      return rv;
    }

    if (chunk->IsReady() || aCaller == WRITER) {
      chunk.swap(*_retval);
    } else {
      QueueChunkListener(aIndex, aCallback);
    }

    if (preload) {
      PreloadChunks(aIndex + 1);
    }

    return NS_OK;
  }

  if (mCachedChunks.Get(aIndex, getter_AddRefs(chunk))) {
    LOG(("CacheFile::GetChunkLocked() - Reusing cached chunk %p [this=%p]",
         chunk.get(), this));

    // Preloader calls this method to preload only non-loaded chunks.
    MOZ_ASSERT(aCaller != PRELOADER, "Unexpected!");

    mChunks.InsertOrUpdate(aIndex, RefPtr{chunk});
    mCachedChunks.Remove(aIndex);
    chunk->mFile = this;
    chunk->mActiveChunk = true;

    MOZ_ASSERT(chunk->IsReady());

    chunk.swap(*_retval);

    if (preload) {
      PreloadChunks(aIndex + 1);
    }

    return NS_OK;
  }

  int64_t off = aIndex * static_cast<int64_t>(kChunkSize);

  if (off < mDataSize) {
    // We cannot be here if this is memory only entry since the chunk must exist
    MOZ_ASSERT(!mMemoryOnly);
    if (mMemoryOnly) {
      // If this ever really happen it is better to fail rather than crashing on
      // a null handle.
      LOG(
          ("CacheFile::GetChunkLocked() - Unexpected state! Offset < mDataSize "
           "for memory-only entry. [this=%p, off=%" PRId64
           ", mDataSize=%" PRId64 "]",
           this, off, mDataSize));

      return NS_ERROR_UNEXPECTED;
    }

    chunk = new CacheFileChunk(this, aIndex, aCaller == WRITER);
    mChunks.InsertOrUpdate(aIndex, RefPtr{chunk});
    chunk->mActiveChunk = true;

    LOG(
        ("CacheFile::GetChunkLocked() - Reading newly created chunk %p from "
         "the disk [this=%p]",
         chunk.get(), this));

    // Read the chunk from the disk
    rv = chunk->Read(mHandle,
                     std::min(static_cast<uint32_t>(mDataSize - off),
                              static_cast<uint32_t>(kChunkSize)),
                     mMetadata->GetHash(aIndex), this);
    if (NS_WARN_IF(NS_FAILED(rv))) {
      RemoveChunkInternal(chunk, false);
      return rv;
    }

    if (aCaller == WRITER) {
      chunk.swap(*_retval);
    } else if (aCaller != PRELOADER) {
      QueueChunkListener(aIndex, aCallback);
    }

    if (preload) {
      PreloadChunks(aIndex + 1);
    }

    return NS_OK;
  }
  if (off == mDataSize) {
    if (aCaller == WRITER) {
      // this listener is going to write to the chunk
      chunk = new CacheFileChunk(this, aIndex, true);
      mChunks.InsertOrUpdate(aIndex, RefPtr{chunk});
      chunk->mActiveChunk = true;

      LOG(("CacheFile::GetChunkLocked() - Created new empty chunk %p [this=%p]",
           chunk.get(), this));

      chunk->InitNew();
      mMetadata->SetHash(aIndex, chunk->Hash());

      if (HaveChunkListeners(aIndex)) {
        rv = NotifyChunkListeners(aIndex, NS_OK, chunk);
        NS_ENSURE_SUCCESS(rv, rv);
      }

      chunk.swap(*_retval);
      return NS_OK;
    }
  } else {
    if (aCaller == WRITER) {
      // this chunk was requested by writer, but we need to fill the gap first

      // Fill with zero the last chunk if it is incomplete
      if (mDataSize % kChunkSize) {
        rv = PadChunkWithZeroes(mDataSize / kChunkSize);
        NS_ENSURE_SUCCESS(rv, rv);

        MOZ_ASSERT(!(mDataSize % kChunkSize));
      }

      uint32_t startChunk = mDataSize / kChunkSize;

      if (mMemoryOnly) {
        // We need to create all missing CacheFileChunks if this is memory-only
        // entry
        for (uint32_t i = startChunk; i < aIndex; i++) {
          rv = PadChunkWithZeroes(i);
          NS_ENSURE_SUCCESS(rv, rv);
        }
      } else {
        // We don't need to create CacheFileChunk for other empty chunks unless
        // there is some input stream waiting for this chunk.

        if (startChunk != aIndex) {
          // Make sure the file contains zeroes at the end of the file
          rv = CacheFileIOManager::TruncateSeekSetEOF(
              mHandle, startChunk * kChunkSize, aIndex * kChunkSize, nullptr);
          NS_ENSURE_SUCCESS(rv, rv);
        }

        for (uint32_t i = startChunk; i < aIndex; i++) {
          if (HaveChunkListeners(i)) {
            rv = PadChunkWithZeroes(i);
            NS_ENSURE_SUCCESS(rv, rv);
          } else {
            mMetadata->SetHash(i, kEmptyChunkHash);
            mDataSize = (i + 1) * kChunkSize;
          }
        }
      }

      MOZ_ASSERT(mDataSize == off);
      rv = GetChunkLocked(aIndex, WRITER, nullptr, getter_AddRefs(chunk));
      NS_ENSURE_SUCCESS(rv, rv);

      chunk.swap(*_retval);
      return NS_OK;
    }
  }

  // We can be here only if the caller is reader since writer always create a
  // new chunk above and preloader calls this method to preload only chunks that
  // are not loaded but that do exist.
  MOZ_ASSERT(aCaller == READER, "Unexpected!");

  if (mOutput) {
    // the chunk doesn't exist but mOutput may create it
    QueueChunkListener(aIndex, aCallback);
  } else {
    return NS_ERROR_NOT_AVAILABLE;
  }

  return NS_OK;
}

void CacheFile::PreloadChunks(uint32_t aIndex) {
  AssertOwnsLock();

  uint32_t limit = aIndex + mPreloadChunkCount;

  for (uint32_t i = aIndex; i < limit; ++i) {
    int64_t off = i * static_cast<int64_t>(kChunkSize);

    if (off >= mDataSize) {
      // This chunk is beyond EOF.
      return;
    }

    if (mChunks.GetWeak(i) || mCachedChunks.GetWeak(i)) {
      // This chunk is already in memory or is being read right now.
      continue;
    }

    LOG(("CacheFile::PreloadChunks() - Preloading chunk [this=%p, idx=%u]",
         this, i));

    RefPtr<CacheFileChunk> chunk;
    GetChunkLocked(i, PRELOADER, nullptr, getter_AddRefs(chunk));
    // We've checked that we don't have this chunk, so no chunk must be
    // returned.
    MOZ_ASSERT(!chunk);
  }
}

bool CacheFile::ShouldCacheChunk(uint32_t aIndex) {
  AssertOwnsLock();

#ifdef CACHE_CHUNKS
  // We cache all chunks.
  return true;
#else

  if (mPreloadChunkCount != 0 && mInputs.Length() == 0 &&
      mPreloadWithoutInputStreams && aIndex < mPreloadChunkCount) {
    // We don't have any input stream yet, but it is likely that some will be
    // opened soon. Keep first mPreloadChunkCount chunks in memory. The
    // condition is here instead of in MustKeepCachedChunk() since these
    // chunks should be preloaded and can be kept in memory as an optimization,
    // but they can be released at any time until they are considered as
    // preloaded chunks for any input stream.
    return true;
  }

  // Cache only chunks that we really need to keep.
  return MustKeepCachedChunk(aIndex);
#endif
}

bool CacheFile::MustKeepCachedChunk(uint32_t aIndex) {
  AssertOwnsLock();

  // We must keep the chunk when this is memory only entry or we don't have
  // a handle yet.
  if (mMemoryOnly || mOpeningFile) {
    return true;
  }

  if (mPreloadChunkCount == 0) {
    // Preloading of chunks is disabled
    return false;
  }

  // Check whether this chunk should be considered as preloaded chunk for any
  // existing input stream.

  // maxPos is the position of the last byte in the given chunk
  int64_t maxPos = static_cast<int64_t>(aIndex + 1) * kChunkSize - 1;

  // minPos is the position of the first byte in a chunk that precedes the given
  // chunk by mPreloadChunkCount chunks
  int64_t minPos;
  if (mPreloadChunkCount >= aIndex) {
    minPos = 0;
  } else {
    minPos = static_cast<int64_t>(aIndex - mPreloadChunkCount) * kChunkSize;
  }

  for (uint32_t i = 0; i < mInputs.Length(); ++i) {
    int64_t inputPos = mInputs[i]->GetPosition();
    if (inputPos >= minPos && inputPos <= maxPos) {
      return true;
    }
  }

  return false;
}

nsresult CacheFile::DeactivateChunk(CacheFileChunk* aChunk) {
  nsresult rv;

  // Avoid lock reentrancy by increasing the RefCnt
  RefPtr<CacheFileChunk> chunk = aChunk;

  {
    CacheFileAutoLock lock(this);

    LOG(("CacheFile::DeactivateChunk() [this=%p, chunk=%p, idx=%u]", this,
         aChunk, aChunk->Index()));

    MOZ_ASSERT(mReady);
    MOZ_ASSERT((mHandle && !mMemoryOnly && !mOpeningFile) ||
               (!mHandle && mMemoryOnly && !mOpeningFile) ||
               (!mHandle && !mMemoryOnly && mOpeningFile));

    if (aChunk->mRefCnt != 2) {
      LOG(
          ("CacheFile::DeactivateChunk() - Chunk is still used [this=%p, "
           "chunk=%p, refcnt=%" PRIuPTR "]",
           this, aChunk, aChunk->mRefCnt.get()));

      // somebody got the reference before the lock was acquired
      return NS_OK;
    }

    if (aChunk->mDiscardedChunk) {
      aChunk->mActiveChunk = false;
      ReleaseOutsideLock(
          RefPtr<CacheFileChunkListener>(std::move(aChunk->mFile)));

      DebugOnly<bool> removed = mDiscardedChunks.RemoveElement(aChunk);
      MOZ_ASSERT(removed);
      return NS_OK;
    }

#ifdef DEBUG
    {
      // We can be here iff the chunk is in the hash table
      RefPtr<CacheFileChunk> chunkCheck;
      mChunks.Get(chunk->Index(), getter_AddRefs(chunkCheck));
      MOZ_ASSERT(chunkCheck == chunk);

      // We also shouldn't have any queued listener for this chunk
      ChunkListeners* listeners;
      mChunkListeners.Get(chunk->Index(), &listeners);
      MOZ_ASSERT(!listeners);
    }
#endif

    if (NS_FAILED(chunk->GetStatus())) {
      SetError(chunk->GetStatus());
    }

    if (NS_FAILED(mStatus)) {
      // Don't write any chunk to disk since this entry will be doomed
      LOG(
          ("CacheFile::DeactivateChunk() - Releasing chunk because of status "
           "[this=%p, chunk=%p, mStatus=0x%08" PRIx32 "]",
           this, chunk.get(), static_cast<uint32_t>(mStatus)));

      RemoveChunkInternal(chunk, false);
      return mStatus;
    }

    if (chunk->IsDirty() && !mMemoryOnly && !mOpeningFile) {
      LOG(
          ("CacheFile::DeactivateChunk() - Writing dirty chunk to the disk "
           "[this=%p]",
           this));

      mDataIsDirty = true;

      rv = chunk->Write(mHandle, this);
      if (NS_FAILED(rv)) {
        LOG(
            ("CacheFile::DeactivateChunk() - CacheFileChunk::Write() failed "
             "synchronously. Removing it. [this=%p, chunk=%p, rv=0x%08" PRIx32
             "]",
             this, chunk.get(), static_cast<uint32_t>(rv)));

        RemoveChunkInternal(chunk, false);

        SetError(rv);
        return rv;
      }

      // Chunk will be removed in OnChunkWritten if it is still unused

      // chunk needs to be released under the lock to be able to rely on
      // CacheFileChunk::mRefCnt in CacheFile::OnChunkWritten()
      chunk = nullptr;
      return NS_OK;
    }

    bool keepChunk = ShouldCacheChunk(aChunk->Index());
    LOG(("CacheFile::DeactivateChunk() - %s unused chunk [this=%p, chunk=%p]",
         keepChunk ? "Caching" : "Releasing", this, chunk.get()));

    RemoveChunkInternal(chunk, keepChunk);

    if (!mMemoryOnly) WriteMetadataIfNeededLocked();
  }

  return NS_OK;
}

void CacheFile::RemoveChunkInternal(CacheFileChunk* aChunk, bool aCacheChunk) {
  AssertOwnsLock();

  aChunk->mActiveChunk = false;
  ReleaseOutsideLock(RefPtr<CacheFileChunkListener>(std::move(aChunk->mFile)));

  if (aCacheChunk) {
    mCachedChunks.InsertOrUpdate(aChunk->Index(), RefPtr{aChunk});
  }

  mChunks.Remove(aChunk->Index());
}

bool CacheFile::OutputStreamExists(bool aAlternativeData) {
  AssertOwnsLock();

  if (!mOutput) {
    return false;
  }

  return mOutput->IsAlternativeData() == aAlternativeData;
}

int64_t CacheFile::BytesFromChunk(uint32_t aIndex, bool aAlternativeData) {
  AssertOwnsLock();

  int64_t dataSize;

  if (mAltDataOffset != -1) {
    if (aAlternativeData) {
      dataSize = mDataSize;
    } else {
      dataSize = mAltDataOffset;
    }
  } else {
    MOZ_ASSERT(!aAlternativeData);
    dataSize = mDataSize;
  }

  if (!dataSize) {
    return 0;
  }

  // Index of the last existing chunk.
  uint32_t lastChunk = (dataSize - 1) / kChunkSize;
  if (aIndex > lastChunk) {
    return 0;
  }

  // We can use only preloaded chunks for the given stream to calculate
  // available bytes if this is an entry stored on disk, since only those
  // chunks are guaranteed not to be released.
  uint32_t maxPreloadedChunk;
  if (mMemoryOnly) {
    maxPreloadedChunk = lastChunk;
  } else {
    maxPreloadedChunk = std::min(aIndex + mPreloadChunkCount, lastChunk);
  }

  uint32_t i;
  for (i = aIndex; i <= maxPreloadedChunk; ++i) {
    CacheFileChunk* chunk;

    chunk = mChunks.GetWeak(i);
    if (chunk) {
      MOZ_ASSERT(i == lastChunk || chunk->DataSize() == kChunkSize);
      if (chunk->IsReady()) {
        continue;
      }

      // don't search this chunk in cached
      break;
    }

    chunk = mCachedChunks.GetWeak(i);
    if (chunk) {
      MOZ_ASSERT(i == lastChunk || chunk->DataSize() == kChunkSize);
      continue;
    }

    break;
  }

  // theoretic bytes in advance
  int64_t advance = int64_t(i - aIndex) * kChunkSize;
  // real bytes till the end of the file
  int64_t tail = dataSize - (aIndex * kChunkSize);

  return std::min(advance, tail);
}

nsresult CacheFile::Truncate(int64_t aOffset) {
  AssertOwnsLock();

  LOG(("CacheFile::Truncate() [this=%p, offset=%" PRId64 "]", this, aOffset));

  nsresult rv;

  // If we ever need to truncate on non alt-data boundary, we need to handle
  // existing input streams.
  MOZ_ASSERT(aOffset == mAltDataOffset,
             "Truncating normal data not implemented");
  MOZ_ASSERT(mReady);
  MOZ_ASSERT(!mOutput);

  uint32_t lastChunk = 0;
  if (mDataSize > 0) {
    lastChunk = (mDataSize - 1) / kChunkSize;
  }

  uint32_t newLastChunk = 0;
  if (aOffset > 0) {
    newLastChunk = (aOffset - 1) / kChunkSize;
  }

  uint32_t bytesInNewLastChunk = aOffset - newLastChunk * kChunkSize;

  LOG(
      ("CacheFileTruncate() - lastChunk=%u, newLastChunk=%u, "
       "bytesInNewLastChunk=%u",
       lastChunk, newLastChunk, bytesInNewLastChunk));

  // Remove all truncated chunks from mCachedChunks
  for (auto iter = mCachedChunks.Iter(); !iter.Done(); iter.Next()) {
    uint32_t idx = iter.Key();

    if (idx > newLastChunk) {
      // This is unused chunk, simply remove it.
      LOG(("CacheFile::Truncate() - removing cached chunk [idx=%u]", idx));
      iter.Remove();
    }
  }

  // We need to make sure no input stream holds a reference to a chunk we're
  // going to discard. In theory, if alt-data begins at chunk boundary, input
  // stream for normal data can get the chunk containing only alt-data via
  // EnsureCorrectChunk() call. The input stream won't read the data from such
  // chunk, but it will keep the reference until the stream is closed and we
  // cannot simply discard this chunk.
  int64_t maxInputChunk = -1;
  for (uint32_t i = 0; i < mInputs.Length(); ++i) {
    int64_t inputChunk = mInputs[i]->GetChunkIdx();

    if (maxInputChunk < inputChunk) {
      maxInputChunk = inputChunk;
    }

    MOZ_RELEASE_ASSERT(mInputs[i]->GetPosition() <= aOffset);
  }

  MOZ_RELEASE_ASSERT(maxInputChunk <= newLastChunk + 1);
  if (maxInputChunk == newLastChunk + 1) {
    // Truncating must be done at chunk boundary
    MOZ_RELEASE_ASSERT(bytesInNewLastChunk == kChunkSize);
    newLastChunk++;
    bytesInNewLastChunk = 0;
    LOG(
        ("CacheFile::Truncate() - chunk %p is still in use, using "
         "newLastChunk=%u and bytesInNewLastChunk=%u",
         mChunks.GetWeak(newLastChunk), newLastChunk, bytesInNewLastChunk));
  }

  // Discard all truncated chunks in mChunks
  for (auto iter = mChunks.Iter(); !iter.Done(); iter.Next()) {
    uint32_t idx = iter.Key();

    if (idx > newLastChunk) {
      RefPtr<CacheFileChunk>& chunk = iter.Data();
      LOG(("CacheFile::Truncate() - discarding chunk [idx=%u, chunk=%p]", idx,
           chunk.get()));

      if (HaveChunkListeners(idx)) {
        NotifyChunkListeners(idx, NS_ERROR_NOT_AVAILABLE, chunk);
      }

      chunk->mDiscardedChunk = true;
      mDiscardedChunks.AppendElement(chunk);
      iter.Remove();
    }
  }

  // Remove hashes of all removed chunks from the metadata
  for (uint32_t i = lastChunk; i > newLastChunk; --i) {
    mMetadata->RemoveHash(i);
  }

  // Truncate new last chunk
  if (bytesInNewLastChunk == kChunkSize) {
    LOG(("CacheFile::Truncate() - not truncating last chunk."));
  } else {
    RefPtr<CacheFileChunk> chunk;
    if (mChunks.Get(newLastChunk, getter_AddRefs(chunk))) {
      LOG(("CacheFile::Truncate() - New last chunk %p got from mChunks.",
           chunk.get()));
    } else if (mCachedChunks.Get(newLastChunk, getter_AddRefs(chunk))) {
      LOG(("CacheFile::Truncate() - New last chunk %p got from mCachedChunks.",
           chunk.get()));
    } else {
      // New last chunk isn't loaded but we need to update the hash.
      MOZ_ASSERT(!mMemoryOnly);
      MOZ_ASSERT(mHandle);

      rv = GetChunkLocked(newLastChunk, PRELOADER, nullptr,
                          getter_AddRefs(chunk));
      if (NS_FAILED(rv)) {
        return rv;
      }
      // We've checked that we don't have this chunk, so no chunk must be
      // returned.
      MOZ_ASSERT(!chunk);

      if (!mChunks.Get(newLastChunk, getter_AddRefs(chunk))) {
        return NS_ERROR_UNEXPECTED;
      }

      LOG(("CacheFile::Truncate() - New last chunk %p got from preloader.",
           chunk.get()));
    }

    rv = chunk->GetStatus();
    if (NS_FAILED(rv)) {
      LOG(
          ("CacheFile::Truncate() - New last chunk is failed "
           "[status=0x%08" PRIx32 "]",
           static_cast<uint32_t>(rv)));
      return rv;
    }

    chunk->Truncate(bytesInNewLastChunk);

    // If the chunk is ready set the new hash now. If it's still being loaded
    // CacheChunk::Truncate() made the chunk dirty and the hash will be updated
    // in OnChunkWritten().
    if (chunk->IsReady()) {
      mMetadata->SetHash(newLastChunk, chunk->Hash());
    }
  }

  if (mHandle) {
    rv = CacheFileIOManager::TruncateSeekSetEOF(mHandle, aOffset, aOffset,
                                                nullptr);
    if (NS_FAILED(rv)) {
      return rv;
    }
  }

  mDataSize = aOffset;

  return NS_OK;
}

static uint32_t StatusToTelemetryEnum(nsresult aStatus) {
  if (NS_SUCCEEDED(aStatus)) {
    return 0;
  }

  switch (aStatus) {
    case NS_BASE_STREAM_CLOSED:
      return 0;  // Log this as a success
    case NS_ERROR_OUT_OF_MEMORY:
      return 2;
    case NS_ERROR_FILE_NO_DEVICE_SPACE:
      return 3;
    case NS_ERROR_FILE_CORRUPTED:
      return 4;
    case NS_ERROR_FILE_NOT_FOUND:
      return 5;
    case NS_BINDING_ABORTED:
      return 6;
    default:
      return 1;  // other error
  }

  MOZ_ASSERT_UNREACHABLE("We should never get here");
}

void CacheFile::RemoveInput(CacheFileInputStream* aInput, nsresult aStatus) {
  AssertOwnsLock();

  LOG(("CacheFile::RemoveInput() [this=%p, input=%p, status=0x%08" PRIx32 "]",
       this, aInput, static_cast<uint32_t>(aStatus)));

  DebugOnly<bool> found{};
  found = mInputs.RemoveElement(aInput);
  MOZ_ASSERT(found);

  ReleaseOutsideLock(
      already_AddRefed<nsIInputStream>(static_cast<nsIInputStream*>(aInput)));

  if (!mMemoryOnly) WriteMetadataIfNeededLocked();

  // If the input didn't read all data, there might be left some preloaded
  // chunks that won't be used anymore.
  CleanUpCachedChunks();

  Telemetry::Accumulate(Telemetry::NETWORK_CACHE_V2_INPUT_STREAM_STATUS,
                        StatusToTelemetryEnum(aStatus));
}

void CacheFile::RemoveOutput(CacheFileOutputStream* aOutput, nsresult aStatus) {
  AssertOwnsLock();

  nsresult rv;

  LOG(("CacheFile::RemoveOutput() [this=%p, output=%p, status=0x%08" PRIx32 "]",
       this, aOutput, static_cast<uint32_t>(aStatus)));

  if (mOutput != aOutput) {
    LOG(
        ("CacheFile::RemoveOutput() - This output was already removed, ignoring"
         " call [this=%p]",
         this));
    return;
  }

  mOutput = nullptr;

  // Cancel all queued chunk and update listeners that cannot be satisfied
  NotifyListenersAboutOutputRemoval();

  if (!mMemoryOnly) WriteMetadataIfNeededLocked();

  // Make sure the CacheFile status is set to a failure when the output stream
  // is closed with a fatal error.  This way we propagate correctly and w/o any
  // windows the failure state of this entry to end consumers.
  if (NS_SUCCEEDED(mStatus) && NS_FAILED(aStatus) &&
      aStatus != NS_BASE_STREAM_CLOSED) {
    if (aOutput->IsAlternativeData()) {
      MOZ_ASSERT(mAltDataOffset != -1);
      // If there is no alt-data input stream truncate only alt-data, otherwise
      // doom the entry.
      bool altDataInputExists = false;
      for (uint32_t i = 0; i < mInputs.Length(); ++i) {
        if (mInputs[i]->IsAlternativeData()) {
          altDataInputExists = true;
          break;
        }
      }
      if (altDataInputExists) {
        SetError(aStatus);
      } else {
        rv = Truncate(mAltDataOffset);
        if (NS_FAILED(rv)) {
          LOG(
              ("CacheFile::RemoveOutput() - Truncating alt-data failed "
               "[rv=0x%08" PRIx32 "]",
               static_cast<uint32_t>(rv)));
          SetError(aStatus);
        } else {
          SetAltMetadata(nullptr);
          mAltDataOffset = -1;
          mAltDataType.Truncate();
        }
      }
    } else {
      SetError(aStatus);
    }
  }

  // Notify close listener as the last action
  aOutput->NotifyCloseListener();

  Telemetry::Accumulate(Telemetry::NETWORK_CACHE_V2_OUTPUT_STREAM_STATUS,
                        StatusToTelemetryEnum(aStatus));
}

nsresult CacheFile::NotifyChunkListener(CacheFileChunkListener* aCallback,
                                        nsIEventTarget* aTarget,
                                        nsresult aResult, uint32_t aChunkIdx,
                                        CacheFileChunk* aChunk) {
  LOG(
      ("CacheFile::NotifyChunkListener() [this=%p, listener=%p, target=%p, "
       "rv=0x%08" PRIx32 ", idx=%u, chunk=%p]",
       this, aCallback, aTarget, static_cast<uint32_t>(aResult), aChunkIdx,
       aChunk));

  RefPtr<NotifyChunkListenerEvent> ev;
  ev = new NotifyChunkListenerEvent(aCallback, aResult, aChunkIdx, aChunk);
  if (aTarget) {
    return aTarget->Dispatch(ev, NS_DISPATCH_NORMAL);
  }
  return NS_DispatchToCurrentThread(ev);
}

void CacheFile::QueueChunkListener(uint32_t aIndex,
                                   CacheFileChunkListener* aCallback) {
  LOG(("CacheFile::QueueChunkListener() [this=%p, idx=%u, listener=%p]", this,
       aIndex, aCallback));

  AssertOwnsLock();

  MOZ_ASSERT(aCallback);

  ChunkListenerItem* item = new ChunkListenerItem();
  item->mTarget = CacheFileIOManager::IOTarget();
  if (!item->mTarget) {
    LOG(
        ("CacheFile::QueueChunkListener() - Cannot get Cache I/O thread! Using "
         "main thread for callback."));
    item->mTarget = GetMainThreadSerialEventTarget();
  }
  item->mCallback = aCallback;

  mChunkListeners.GetOrInsertNew(aIndex)->mItems.AppendElement(item);
}

nsresult CacheFile::NotifyChunkListeners(uint32_t aIndex, nsresult aResult,
                                         CacheFileChunk* aChunk) {
  LOG(("CacheFile::NotifyChunkListeners() [this=%p, idx=%u, rv=0x%08" PRIx32
       ", "
       "chunk=%p]",
       this, aIndex, static_cast<uint32_t>(aResult), aChunk));

  AssertOwnsLock();

  nsresult rv, rv2;

  ChunkListeners* listeners;
  mChunkListeners.Get(aIndex, &listeners);
  MOZ_ASSERT(listeners);

  rv = NS_OK;
  for (uint32_t i = 0; i < listeners->mItems.Length(); i++) {
    ChunkListenerItem* item = listeners->mItems[i];
    rv2 = NotifyChunkListener(item->mCallback, item->mTarget, aResult, aIndex,
                              aChunk);
    if (NS_FAILED(rv2) && NS_SUCCEEDED(rv)) rv = rv2;
    delete item;
  }

  mChunkListeners.Remove(aIndex);

  return rv;
}

bool CacheFile::HaveChunkListeners(uint32_t aIndex) {
  AssertOwnsLock();
  ChunkListeners* listeners;
  mChunkListeners.Get(aIndex, &listeners);
  return !!listeners;
}

void CacheFile::NotifyListenersAboutOutputRemoval() {
  LOG(("CacheFile::NotifyListenersAboutOutputRemoval() [this=%p]", this));

  AssertOwnsLock();

  // First fail all chunk listeners that wait for non-existent chunk
  for (auto iter = mChunkListeners.Iter(); !iter.Done(); iter.Next()) {
    uint32_t idx = iter.Key();
    auto* listeners = iter.UserData();

    LOG(
        ("CacheFile::NotifyListenersAboutOutputRemoval() - fail "
         "[this=%p, idx=%u]",
         this, idx));

    RefPtr<CacheFileChunk> chunk;
    mChunks.Get(idx, getter_AddRefs(chunk));
    if (chunk) {
      // Skip these listeners because the chunk is being read. We don't have
      // assertion here to check its state because it might be already in READY
      // state while CacheFile::OnChunkRead() is waiting on Cache I/O thread for
      // a lock so the listeners hasn't been notified yet. In any case, the
      // listeners will be notified from CacheFile::OnChunkRead().
      continue;
    }

    for (uint32_t i = 0; i < listeners->mItems.Length(); i++) {
      ChunkListenerItem* item = listeners->mItems[i];
      NotifyChunkListener(item->mCallback, item->mTarget,
                          NS_ERROR_NOT_AVAILABLE, idx, nullptr);
      delete item;
    }

    iter.Remove();
  }

  // Fail all update listeners
  for (const auto& entry : mChunks) {
    const RefPtr<CacheFileChunk>& chunk = entry.GetData();
    LOG(
        ("CacheFile::NotifyListenersAboutOutputRemoval() - fail2 "
         "[this=%p, idx=%u]",
         this, entry.GetKey()));

    if (chunk->IsReady()) {
      chunk->NotifyUpdateListeners();
    }
  }
}

bool CacheFile::DataSize(int64_t* aSize) {
  CacheFileAutoLock lock(this);

  if (OutputStreamExists(false)) {
    return false;
  }

  if (mAltDataOffset == -1) {
    *aSize = mDataSize;
  } else {
    *aSize = mAltDataOffset;
  }

  return true;
}

nsresult CacheFile::GetAltDataSize(int64_t* aSize) {
  CacheFileAutoLock lock(this);
  if (mOutput) {
    return NS_ERROR_IN_PROGRESS;
  }

  if (mAltDataOffset == -1) {
    return NS_ERROR_NOT_AVAILABLE;
  }

  *aSize = mDataSize - mAltDataOffset;
  return NS_OK;
}

nsresult CacheFile::GetAltDataType(nsACString& aType) {
  CacheFileAutoLock lock(this);

  if (mAltDataOffset == -1) {
    return NS_ERROR_NOT_AVAILABLE;
  }

  aType = mAltDataType;
  return NS_OK;
}

bool CacheFile::IsDoomed() {
  CacheFileAutoLock lock(this);

  if (!mHandle) return false;

  return mHandle->IsDoomed();
}

bool CacheFile::IsWriteInProgress() {
  CacheFileAutoLock lock(this);

  bool result = false;

  if (!mMemoryOnly) {
    result =
        mDataIsDirty || (mMetadata && mMetadata->IsDirty()) || mWritingMetadata;
  }

  result = result || mOpeningFile || mOutput || mChunks.Count();

  return result;
}

bool CacheFile::EntryWouldExceedLimit(int64_t aOffset, int64_t aSize,
                                      bool aIsAltData) {
  CacheFileAutoLock lock(this);

  if (mSkipSizeCheck || aSize < 0) {
    return false;
  }

  int64_t totalSize = aOffset + aSize;
  if (aIsAltData) {
    totalSize += (mAltDataOffset == -1) ? mDataSize : mAltDataOffset;
  }

  return CacheObserver::EntryIsTooBig(totalSize, !mMemoryOnly);
}

bool CacheFile::IsDirty() { return mDataIsDirty || mMetadata->IsDirty(); }

void CacheFile::WriteMetadataIfNeeded() {
  LOG(("CacheFile::WriteMetadataIfNeeded() [this=%p]", this));

  CacheFileAutoLock lock(this);

  if (!mMemoryOnly) WriteMetadataIfNeededLocked();
}

void CacheFile::WriteMetadataIfNeededLocked(bool aFireAndForget) {
  // When aFireAndForget is set to true, we are called from dtor.
  // |this| must not be referenced after this method returns!

  LOG(("CacheFile::WriteMetadataIfNeededLocked() [this=%p]", this));

  nsresult rv;

  AssertOwnsLock();
  MOZ_ASSERT(!mMemoryOnly);

  if (!mMetadata) {
    MOZ_CRASH("Must have metadata here");
    return;
  }

  if (NS_FAILED(mStatus)) return;

  if (!IsDirty() || mOutput || mInputs.Length() || mChunks.Count() ||
      mWritingMetadata || mOpeningFile || mKill) {
    return;
  }

  if (!aFireAndForget) {
    // if aFireAndForget is set, we are called from dtor. Write
    // scheduler hard-refers CacheFile otherwise, so we cannot be here.
    CacheFileIOManager::UnscheduleMetadataWrite(this);
  }

  LOG(("CacheFile::WriteMetadataIfNeededLocked() - Writing metadata [this=%p]",
       this));

  rv = mMetadata->WriteMetadata(mDataSize, aFireAndForget ? nullptr : this);
  if (NS_SUCCEEDED(rv)) {
    mWritingMetadata = true;
    mDataIsDirty = false;
  } else {
    LOG(
        ("CacheFile::WriteMetadataIfNeededLocked() - Writing synchronously "
         "failed [this=%p]",
         this));
    // TODO: close streams with error
    SetError(rv);
  }
}

void CacheFile::PostWriteTimer() {
  if (mMemoryOnly) return;
  LOG(("CacheFile::PostWriteTimer() [this=%p]", this));

  CacheFileIOManager::ScheduleMetadataWrite(this);
}

void CacheFile::CleanUpCachedChunks() {
  for (auto iter = mCachedChunks.Iter(); !iter.Done(); iter.Next()) {
    uint32_t idx = iter.Key();
    const RefPtr<CacheFileChunk>& chunk = iter.Data();

    LOG(("CacheFile::CleanUpCachedChunks() [this=%p, idx=%u, chunk=%p]", this,
         idx, chunk.get()));

    if (MustKeepCachedChunk(idx)) {
      LOG(("CacheFile::CleanUpCachedChunks() - Keeping chunk"));
      continue;
    }

    LOG(("CacheFile::CleanUpCachedChunks() - Removing chunk"));
    iter.Remove();
  }
}

nsresult CacheFile::PadChunkWithZeroes(uint32_t aChunkIdx) {
  AssertOwnsLock();

  // This method is used to pad last incomplete chunk with zeroes or create
  // a new chunk full of zeroes
  MOZ_ASSERT(mDataSize / kChunkSize == aChunkIdx);

  nsresult rv;
  RefPtr<CacheFileChunk> chunk;
  rv = GetChunkLocked(aChunkIdx, WRITER, nullptr, getter_AddRefs(chunk));
  NS_ENSURE_SUCCESS(rv, rv);

  LOG(
      ("CacheFile::PadChunkWithZeroes() - Zeroing hole in chunk %d, range %d-%d"
       " [this=%p]",
       aChunkIdx, chunk->DataSize(), kChunkSize - 1, this));

  CacheFileChunkWriteHandle hnd = chunk->GetWriteHandle(kChunkSize);
  if (!hnd.Buf()) {
    ReleaseOutsideLock(std::move(chunk));
    SetError(NS_ERROR_OUT_OF_MEMORY);
    return NS_ERROR_OUT_OF_MEMORY;
  }

  uint32_t offset = hnd.DataSize();
  memset(hnd.Buf() + offset, 0, kChunkSize - offset);
  hnd.UpdateDataSize(offset, kChunkSize - offset);

  ReleaseOutsideLock(std::move(chunk));

  return NS_OK;
}

void CacheFile::SetError(nsresult aStatus) {
  AssertOwnsLock();

  if (NS_SUCCEEDED(mStatus)) {
    mStatus = aStatus;
    if (mHandle) {
      CacheFileIOManager::DoomFile(mHandle, nullptr);
    }
  }
}

nsresult CacheFile::InitIndexEntry() {
  AssertOwnsLock();
  MOZ_ASSERT(mHandle);

  if (mHandle->IsDoomed()) return NS_OK;

  nsresult rv;

  rv = CacheFileIOManager::InitIndexEntry(
      mHandle, GetOriginAttrsHash(mMetadata->OriginAttributes()),
      mMetadata->IsAnonymous(), mPinned);
  NS_ENSURE_SUCCESS(rv, rv);

  uint32_t frecency = mMetadata->GetFrecency();

  bool hasAltData =
      mMetadata->GetElement(CacheFileUtils::kAltDataKey) != nullptr;

  static auto toUint16 = [](const char* s) -> uint16_t {
    if (s) {
      nsresult rv;
      uint64_t n64 = nsDependentCString(s).ToInteger64(&rv);
      MOZ_ASSERT(NS_SUCCEEDED(rv));
      return n64 <= kIndexTimeOutOfBound ? n64 : kIndexTimeOutOfBound;
    }
    return kIndexTimeNotAvailable;
  };

  const char* onStartTimeStr =
      mMetadata->GetElement("net-response-time-onstart");
  uint16_t onStartTime = toUint16(onStartTimeStr);

  const char* onStopTimeStr = mMetadata->GetElement("net-response-time-onstop");
  uint16_t onStopTime = toUint16(onStopTimeStr);

  const char* contentTypeStr = mMetadata->GetElement("ctid");
  uint8_t contentType = nsICacheEntry::CONTENT_TYPE_UNKNOWN;
  if (contentTypeStr) {
    int64_t n64 = nsDependentCString(contentTypeStr).ToInteger64(&rv);
    if (NS_FAILED(rv) || n64 < nsICacheEntry::CONTENT_TYPE_UNKNOWN ||
        n64 >= nsICacheEntry::CONTENT_TYPE_LAST) {
      n64 = nsICacheEntry::CONTENT_TYPE_UNKNOWN;
    }
    contentType = n64;
  }

  rv = CacheFileIOManager::UpdateIndexEntry(
      mHandle, &frecency, &hasAltData, &onStartTime, &onStopTime, &contentType);
  NS_ENSURE_SUCCESS(rv, rv);

  return NS_OK;
}

size_t CacheFile::SizeOfExcludingThis(
    mozilla::MallocSizeOf mallocSizeOf) const {
  CacheFileAutoLock lock(const_cast<CacheFile*>(this));

  size_t n = 0;
  n += mKey.SizeOfExcludingThisIfUnshared(mallocSizeOf);
  n += mChunks.ShallowSizeOfExcludingThis(mallocSizeOf);
  for (const auto& chunk : mChunks.Values()) {
    n += chunk->SizeOfIncludingThis(mallocSizeOf);
  }
  n += mCachedChunks.ShallowSizeOfExcludingThis(mallocSizeOf);
  for (const auto& chunk : mCachedChunks.Values()) {
    n += chunk->SizeOfIncludingThis(mallocSizeOf);
  }
  // Ignore metadata if it's still being read. It's not safe to access buffers
  // in CacheFileMetadata because they might be reallocated on another thread
  // outside CacheFile's lock.
  if (mMetadata && mReady) {
    n += mMetadata->SizeOfIncludingThis(mallocSizeOf);
  }

  // Input streams are not elsewhere reported.
  n += mInputs.ShallowSizeOfExcludingThis(mallocSizeOf);
  for (uint32_t i = 0; i < mInputs.Length(); ++i) {
    n += mInputs[i]->SizeOfIncludingThis(mallocSizeOf);
  }

  // Output streams are not elsewhere reported.
  if (mOutput) {
    n += mOutput->SizeOfIncludingThis(mallocSizeOf);
  }

  // The listeners are usually classes reported just above.
  n += mChunkListeners.ShallowSizeOfExcludingThis(mallocSizeOf);
  n += mObjsToRelease.ShallowSizeOfExcludingThis(mallocSizeOf);

  // mHandle reported directly from CacheFileIOManager.

  return n;
}

size_t CacheFile::SizeOfIncludingThis(
    mozilla::MallocSizeOf mallocSizeOf) const {
  return mallocSizeOf(this) + SizeOfExcludingThis(mallocSizeOf);
}

}  // namespace mozilla::net