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

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

netwerk/cache2/CacheFileIOManager.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 "CacheFileIOManager.h"
 #include "../cache/nsCacheUtils.h"
 #include "CacheHashUtils.h"
 #include "CacheStorageService.h"
 #include "CacheIndex.h"
 #include "CacheFileUtils.h"
 #include "nsThreadUtils.h"
 #include "CacheFile.h"
 #include "CacheObserver.h"
 #include "nsIFile.h"
 #include "CacheFileContextEvictor.h"
 #include "nsITimer.h"
 #include "nsISimpleEnumerator.h"
 #include "nsIDirectoryEnumerator.h"
 #include "nsIObserverService.h"
 #include "nsISizeOf.h"
 #include "mozilla/Telemetry.h"
 #include "mozilla/DebugOnly.h"
 #include "mozilla/Services.h"
 #include "nsDirectoryServiceUtils.h"
 #include "nsAppDirectoryServiceDefs.h"
 #include "private/pprio.h"
 #include "mozilla/VisualEventTracer.h"
 #include "mozilla/Preferences.h"
 // include files for ftruncate (or equivalent)
 #if defined(XP_UNIX)
 #include <unistd.h>
 #elif defined(XP_WIN)
 #include <windows.h>
 #undef CreateFile
 #undef CREATE_NEW
 #else
 // XXX add necessary include file for ftruncate (or equivalent)
 #endif
 namespace mozilla {
 namespace net {
 #define kOpenHandlesLimit        64
 #define kMetadataWriteDelay      5000
 #define kRemoveTrashStartDelay   60000 // in milliseconds
 #define kSmartSizeUpdateInterval 60000 // in milliseconds
 #ifdef ANDROID
 const uint32_t kMaxCacheSizeKB = 200*1024; // 200 MB
 #else
 const uint32_t kMaxCacheSizeKB = 350*1024; // 350 MB
 #endif
 bool
 CacheFileHandle::DispatchRelease()
 {
   if (CacheFileIOManager::IsOnIOThreadOrCeased()) {
     return false;
   }
   nsCOMPtr<nsIEventTarget> ioTarget = CacheFileIOManager::IOTarget();
   if (!ioTarget) {
     return false;
   }
   nsRefPtr<nsRunnableMethod<CacheFileHandle, MozExternalRefCountType, false> > event =
     NS_NewNonOwningRunnableMethod(this, &CacheFileHandle::Release);
   nsresult rv = ioTarget->Dispatch(event, nsIEventTarget::DISPATCH_NORMAL);
   if (NS_FAILED(rv)) {
     return false;
   }
   return true;
 }
 NS_IMPL_ADDREF(CacheFileHandle)
 NS_IMETHODIMP_(MozExternalRefCountType)
 CacheFileHandle::Release()
 {
   nsrefcnt count = mRefCnt - 1;
   if (DispatchRelease()) {
     // Redispatched to the IO thread.
     return count;
   }
   MOZ_ASSERT(CacheFileIOManager::IsOnIOThreadOrCeased());
   LOG(("CacheFileHandle::Release() [this=%p, refcnt=%d]", this, mRefCnt.get()));
   NS_PRECONDITION(0 != mRefCnt, "dup release");
   count = --mRefCnt;
   NS_LOG_RELEASE(this, count, "CacheFileHandle");
   if (0 == count) {
     mRefCnt = 1;
     delete (this);
     return 0;
   }
   return count;
 }
 NS_INTERFACE_MAP_BEGIN(CacheFileHandle)
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END_THREADSAFE
 CacheFileHandle::CacheFileHandle(const SHA1Sum::Hash *aHash, bool aPriority)
   : mHash(aHash)
   , mIsDoomed(false)
   , mPriority(aPriority)
   , mClosed(false)
   , mInvalid(false)
   , mFileExists(false)
   , mFileSize(-1)
   , mFD(nullptr)
 {
   LOG(("CacheFileHandle::CacheFileHandle() [this=%p, hash=%08x%08x%08x%08x%08x]"
        , this, LOGSHA1(aHash)));
 }
 CacheFileHandle::CacheFileHandle(const nsACString &aKey, bool aPriority)
   : mHash(nullptr)
   , mIsDoomed(false)
   , mPriority(aPriority)
   , mClosed(false)
   , mInvalid(false)
   , mFileExists(false)
   , mFileSize(-1)
   , mFD(nullptr)
   , mKey(aKey)
 {
   LOG(("CacheFileHandle::CacheFileHandle() [this=%p, key=%s]", this,
        PromiseFlatCString(aKey).get()));
 }
 CacheFileHandle::~CacheFileHandle()
 {
   LOG(("CacheFileHandle::~CacheFileHandle() [this=%p]", this));
   MOZ_ASSERT(CacheFileIOManager::IsOnIOThreadOrCeased());
   nsRefPtr<CacheFileIOManager> ioMan = CacheFileIOManager::gInstance;
   if (ioMan) {
     ioMan->CloseHandleInternal(this);
   }
 }
 void
 CacheFileHandle::Log()
 {
   nsAutoCString leafName;
   if (mFile) {
     mFile->GetNativeLeafName(leafName);
   }
   if (!mHash) {
     // special file
     LOG(("CacheFileHandle::Log() [this=%p, hash=nullptr, isDoomed=%d, "
          "priority=%d, closed=%d, invalid=%d, "
          "fileExists=%d, fileSize=%lld, leafName=%s, key=%s]",
          this, mIsDoomed, mPriority, mClosed, mInvalid,
          mFileExists, mFileSize, leafName.get(), mKey.get()));
   } else {
     LOG(("CacheFileHandle::Log() [this=%p, hash=%08x%08x%08x%08x%08x, "
          "isDoomed=%d, priority=%d, closed=%d, invalid=%d, "
          "fileExists=%d, fileSize=%lld, leafName=%s, key=%s]",
          this, LOGSHA1(mHash), mIsDoomed, mPriority, mClosed,
          mInvalid, mFileExists, mFileSize, leafName.get(), mKey.get()));
   }
 }
 uint32_t
 CacheFileHandle::FileSizeInK() const
 {
   MOZ_ASSERT(mFileSize != -1);
   uint64_t size64 = mFileSize;
   size64 += 0x3FF;
   size64 >>= 10;
   uint32_t size;
   if (size64 >> 32) {
     NS_WARNING("CacheFileHandle::FileSizeInK() - FileSize is too large, "
                "truncating to PR_UINT32_MAX");
     size = PR_UINT32_MAX;
   } else {
     size = static_cast<uint32_t>(size64);
   }
   return size;
 }
 // Memory reporting
 size_t
 CacheFileHandle::SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const
 {
   size_t n = 0;
   nsCOMPtr<nsISizeOf> sizeOf;
   sizeOf = do_QueryInterface(mFile);
   if (sizeOf) {
     n += sizeOf->SizeOfIncludingThis(mallocSizeOf);
   }
   n += mallocSizeOf(mFD);
   n += mKey.SizeOfExcludingThisIfUnshared(mallocSizeOf);
   return n;
 }
 size_t
 CacheFileHandle::SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const
 {
   return mallocSizeOf(this) + SizeOfExcludingThis(mallocSizeOf);
 }
 /******************************************************************************
  *  CacheFileHandles::HandleHashKey
  *****************************************************************************/
 void
 CacheFileHandles::HandleHashKey::AddHandle(CacheFileHandle* aHandle)
 {
   MOZ_ASSERT(CacheFileIOManager::IsOnIOThreadOrCeased());
   mHandles.InsertElementAt(0, aHandle);
 }
 void
 CacheFileHandles::HandleHashKey::RemoveHandle(CacheFileHandle* aHandle)
 {
   MOZ_ASSERT(CacheFileIOManager::IsOnIOThreadOrCeased());
   DebugOnly<bool> found;
   found = mHandles.RemoveElement(aHandle);
   MOZ_ASSERT(found);
 }
 already_AddRefed<CacheFileHandle>
 CacheFileHandles::HandleHashKey::GetNewestHandle()
 {
   MOZ_ASSERT(CacheFileIOManager::IsOnIOThreadOrCeased());
   nsRefPtr<CacheFileHandle> handle;
   if (mHandles.Length()) {
     handle = mHandles[0];
   }
   return handle.forget();
 }
 void
 CacheFileHandles::HandleHashKey::GetHandles(nsTArray<nsRefPtr<CacheFileHandle> > &aResult)
 {
   MOZ_ASSERT(CacheFileIOManager::IsOnIOThreadOrCeased());
   for (uint32_t i = 0; i < mHandles.Length(); ++i) {
     CacheFileHandle* handle = mHandles[i];
     aResult.AppendElement(handle);
   }
 }
 #ifdef DEBUG
 void
 CacheFileHandles::HandleHashKey::AssertHandlesState()
 {
   for (uint32_t i = 0; i < mHandles.Length(); ++i) {
     CacheFileHandle* handle = mHandles[i];
     MOZ_ASSERT(handle->IsDoomed());
   }
 }
 #endif
 size_t
 CacheFileHandles::HandleHashKey::SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const
 {
   MOZ_ASSERT(CacheFileIOManager::IsOnIOThread());
   size_t n = 0;
   n += mallocSizeOf(mHash);
   for (uint32_t i = 0; i < mHandles.Length(); ++i) {
     n += mHandles[i]->SizeOfIncludingThis(mallocSizeOf);
   }
   return n;
 }
 /******************************************************************************
  *  CacheFileHandles
  *****************************************************************************/
 CacheFileHandles::CacheFileHandles()
 {
   LOG(("CacheFileHandles::CacheFileHandles() [this=%p]", this));
   MOZ_COUNT_CTOR(CacheFileHandles);
 }
 CacheFileHandles::~CacheFileHandles()
 {
   LOG(("CacheFileHandles::~CacheFileHandles() [this=%p]", this));
   MOZ_COUNT_DTOR(CacheFileHandles);
 }
 nsresult
 CacheFileHandles::GetHandle(const SHA1Sum::Hash *aHash,
                             bool aReturnDoomed,
                             CacheFileHandle **_retval)
 {
   MOZ_ASSERT(CacheFileIOManager::IsOnIOThreadOrCeased());
   MOZ_ASSERT(aHash);
 #ifdef DEBUG_HANDLES
   LOG(("CacheFileHandles::GetHandle() [hash=%08x%08x%08x%08x%08x]",
        LOGSHA1(aHash)));
 #endif
   // find hash entry for key
   HandleHashKey *entry = mTable.GetEntry(*aHash);
   if (!entry) {
     LOG(("CacheFileHandles::GetHandle() hash=%08x%08x%08x%08x%08x "
          "no handle entries found", LOGSHA1(aHash)));
     return NS_ERROR_NOT_AVAILABLE;
   }
 #ifdef DEBUG_HANDLES
   Log(entry);
 #endif
   // Check if the entry is doomed
   nsRefPtr<CacheFileHandle> handle = entry->GetNewestHandle();
   if (!handle) {
     LOG(("CacheFileHandles::GetHandle() hash=%08x%08x%08x%08x%08x "
          "no handle found %p, entry %p", LOGSHA1(aHash), handle.get(), entry));
     return NS_ERROR_NOT_AVAILABLE;
   }
   if (handle->IsDoomed()) {
     LOG(("CacheFileHandles::GetHandle() hash=%08x%08x%08x%08x%08x "
          "found doomed handle %p, entry %p", LOGSHA1(aHash), handle.get(), entry));
     // If the consumer doesn't want doomed handles, exit with NOT_AVAIL.
     if (!aReturnDoomed) {
       return NS_ERROR_NOT_AVAILABLE;
     }
   } else {
     LOG(("CacheFileHandles::GetHandle() hash=%08x%08x%08x%08x%08x "
          "found handle %p, entry %p", LOGSHA1(aHash), handle.get(), entry));
   }
   handle.forget(_retval);
   return NS_OK;
 }
 nsresult
 CacheFileHandles::NewHandle(const SHA1Sum::Hash *aHash,
                             bool aPriority,
                             CacheFileHandle **_retval)
 {
   MOZ_ASSERT(CacheFileIOManager::IsOnIOThreadOrCeased());
   MOZ_ASSERT(aHash);
 #ifdef DEBUG_HANDLES
   LOG(("CacheFileHandles::NewHandle() [hash=%08x%08x%08x%08x%08x]", LOGSHA1(aHash)));
 #endif
   // find hash entry for key
   HandleHashKey *entry = mTable.PutEntry(*aHash);
 #ifdef DEBUG_HANDLES
   Log(entry);
 #endif
 #ifdef DEBUG
   entry->AssertHandlesState();
 #endif
   nsRefPtr<CacheFileHandle> handle = new CacheFileHandle(entry->Hash(), aPriority);
   entry->AddHandle(handle);
   LOG(("CacheFileHandles::NewHandle() hash=%08x%08x%08x%08x%08x "
        "created new handle %p, entry=%p", LOGSHA1(aHash), handle.get(), entry));
   handle.forget(_retval);
   return NS_OK;
 }
 void
 CacheFileHandles::RemoveHandle(CacheFileHandle *aHandle)
 {
   MOZ_ASSERT(CacheFileIOManager::IsOnIOThreadOrCeased());
   MOZ_ASSERT(aHandle);
   if (!aHandle) {
     return;
   }
 #ifdef DEBUG_HANDLES
   LOG(("CacheFileHandles::RemoveHandle() [handle=%p, hash=%08x%08x%08x%08x%08x]"
        , aHandle, LOGSHA1(aHandle->Hash())));
 #endif
   // find hash entry for key
   HandleHashKey *entry = mTable.GetEntry(*aHandle->Hash());
   if (!entry) {
     MOZ_ASSERT(CacheFileIOManager::IsShutdown(),
       "Should find entry when removing a handle before shutdown");
     LOG(("CacheFileHandles::RemoveHandle() hash=%08x%08x%08x%08x%08x "
          "no entries found", LOGSHA1(aHandle->Hash())));
     return;
   }
 #ifdef DEBUG_HANDLES
   Log(entry);
 #endif
   LOG(("CacheFileHandles::RemoveHandle() hash=%08x%08x%08x%08x%08x "
        "removing handle %p", LOGSHA1(entry->Hash()), aHandle));
   entry->RemoveHandle(aHandle);
   if (entry->IsEmpty()) {
     LOG(("CacheFileHandles::RemoveHandle() hash=%08x%08x%08x%08x%08x "
          "list is empty, removing entry %p", LOGSHA1(entry->Hash()), entry));
     mTable.RemoveEntry(*entry->Hash());
   }
 }
 static PLDHashOperator
 GetAllHandlesEnum(CacheFileHandles::HandleHashKey* aEntry, void *aClosure)
 {
   nsTArray<nsRefPtr<CacheFileHandle> > *array =
     static_cast<nsTArray<nsRefPtr<CacheFileHandle> > *>(aClosure);
   aEntry->GetHandles(*array);
   return PL_DHASH_NEXT;
 }
 void
 CacheFileHandles::GetAllHandles(nsTArray<nsRefPtr<CacheFileHandle> > *_retval)
 {
   MOZ_ASSERT(CacheFileIOManager::IsOnIOThreadOrCeased());
   mTable.EnumerateEntries(&GetAllHandlesEnum, _retval);
 }
 static PLDHashOperator
 GetActiveHandlesEnum(CacheFileHandles::HandleHashKey* aEntry, void *aClosure)
 {
   nsTArray<nsRefPtr<CacheFileHandle> > *array =
     static_cast<nsTArray<nsRefPtr<CacheFileHandle> > *>(aClosure);
   nsRefPtr<CacheFileHandle> handle = aEntry->GetNewestHandle();
   MOZ_ASSERT(handle);
   if (!handle->IsDoomed()) {
     array->AppendElement(handle);
   }
   return PL_DHASH_NEXT;
 }
 void
 CacheFileHandles::GetActiveHandles(
   nsTArray<nsRefPtr<CacheFileHandle> > *_retval)
 {
   MOZ_ASSERT(CacheFileIOManager::IsOnIOThreadOrCeased());
   mTable.EnumerateEntries(&GetActiveHandlesEnum, _retval);
 }
 void
 CacheFileHandles::ClearAll()
 {
   MOZ_ASSERT(CacheFileIOManager::IsOnIOThreadOrCeased());
   mTable.Clear();
 }
 uint32_t
 CacheFileHandles::HandleCount()
 {
   return mTable.Count();
 }
 #ifdef DEBUG_HANDLES
 void
 CacheFileHandles::Log(CacheFileHandlesEntry *entry)
 {
   LOG(("CacheFileHandles::Log() BEGIN [entry=%p]", entry));
   nsTArray<nsRefPtr<CacheFileHandle> > array;
   aEntry->GetHandles(array);
   for (uint32_t i = 0; i < array.Length(); ++i) {
     CacheFileHandle *handle = array[i];
     handle->Log();
   }
   LOG(("CacheFileHandles::Log() END [entry=%p]", entry));
 }
 #endif
 // Memory reporting
 namespace { // anon
 size_t
 CollectHandlesMemory(CacheFileHandles::HandleHashKey* key,
                      mozilla::MallocSizeOf mallocSizeOf,
                      void *arg)
 {
   return key->SizeOfExcludingThis(mallocSizeOf);
 }
 } // anon
 size_t
 CacheFileHandles::SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const
 {
   MOZ_ASSERT(CacheFileIOManager::IsOnIOThread());
   return mTable.SizeOfExcludingThis(&CollectHandlesMemory, mallocSizeOf);
 }
 // Events
 class ShutdownEvent : public nsRunnable {
 public:
   ShutdownEvent(mozilla::Mutex *aLock, mozilla::CondVar *aCondVar)
     : mLock(aLock)
     , mCondVar(aCondVar)
   {
     MOZ_COUNT_CTOR(ShutdownEvent);
   }
   ~ShutdownEvent()
   {
     MOZ_COUNT_DTOR(ShutdownEvent);
   }
   NS_IMETHOD Run()
   {
     MutexAutoLock lock(*mLock);
     CacheFileIOManager::gInstance->ShutdownInternal();
     mCondVar->Notify();
     return NS_OK;
   }
 protected:
   mozilla::Mutex   *mLock;
   mozilla::CondVar *mCondVar;
 };
 class OpenFileEvent : public nsRunnable {
 public:
   OpenFileEvent(const nsACString &aKey,
                 uint32_t aFlags, bool aResultOnAnyThread,
                 CacheFileIOListener *aCallback)
     : mFlags(aFlags)
     , mResultOnAnyThread(aResultOnAnyThread)
     , mCallback(aCallback)
     , mRV(NS_ERROR_FAILURE)
     , mKey(aKey)
   {
     MOZ_COUNT_CTOR(OpenFileEvent);
     if (!aResultOnAnyThread) {
       mTarget = static_cast<nsIEventTarget*>(NS_GetCurrentThread());
       MOZ_ASSERT(mTarget);
     }
     mIOMan = CacheFileIOManager::gInstance;
     MOZ_EVENT_TRACER_NAME_OBJECT(static_cast<nsIRunnable*>(this), aKey.BeginReading());
     MOZ_EVENT_TRACER_WAIT(static_cast<nsIRunnable*>(this), "net::cache::open-background");
   }
   ~OpenFileEvent()
   {
     MOZ_COUNT_DTOR(OpenFileEvent);
   }
   NS_IMETHOD Run()
   {
     if (mResultOnAnyThread || mTarget) {
       mRV = NS_OK;
       if (!(mFlags & CacheFileIOManager::SPECIAL_FILE)) {
         SHA1Sum sum;
         sum.update(mKey.BeginReading(), mKey.Length());
         sum.finish(mHash);
       }
       MOZ_EVENT_TRACER_EXEC(static_cast<nsIRunnable*>(this),
                             "net::cache::open-background");
       if (NS_SUCCEEDED(mRV)) {
         if (!mIOMan) {
           mRV = NS_ERROR_NOT_INITIALIZED;
         } else {
           if (mFlags & CacheFileIOManager::SPECIAL_FILE) {
             mRV = mIOMan->OpenSpecialFileInternal(mKey, mFlags,
                                                   getter_AddRefs(mHandle));
           } else {
             mRV = mIOMan->OpenFileInternal(&mHash, mKey, mFlags,
                                            getter_AddRefs(mHandle));
           }
           mIOMan = nullptr;
           if (mHandle) {
             MOZ_EVENT_TRACER_NAME_OBJECT(mHandle.get(), mKey.get());
             if (mHandle->Key().IsEmpty()) {
               mHandle->Key() = mKey;
             }
           }
         }
       }
       MOZ_EVENT_TRACER_DONE(static_cast<nsIRunnable*>(this), "net::cache::open-background");
       MOZ_EVENT_TRACER_WAIT(static_cast<nsIRunnable*>(this), "net::cache::open-result");
       if (mTarget) {
         nsCOMPtr<nsIEventTarget> target;
         mTarget.swap(target);
         return target->Dispatch(this, nsIEventTarget::DISPATCH_NORMAL);
       }
     }
     if (!mTarget) {
       MOZ_EVENT_TRACER_EXEC(static_cast<nsIRunnable*>(this), "net::cache::open-result");
       mCallback->OnFileOpened(mHandle, mRV);
       MOZ_EVENT_TRACER_DONE(static_cast<nsIRunnable*>(this), "net::cache::open-result");
     }
     return NS_OK;
   }
 protected:
   SHA1Sum::Hash                 mHash;
   uint32_t                      mFlags;
   bool                          mResultOnAnyThread;
   nsCOMPtr<CacheFileIOListener> mCallback;
   nsCOMPtr<nsIEventTarget>      mTarget;
   nsRefPtr<CacheFileIOManager>  mIOMan;
   nsRefPtr<CacheFileHandle>     mHandle;
   nsresult                      mRV;
   nsCString                     mKey;
 };
 class ReadEvent : public nsRunnable {
 public:
   ReadEvent(CacheFileHandle *aHandle, int64_t aOffset, char *aBuf,
             int32_t aCount, bool aResultOnAnyThread, CacheFileIOListener *aCallback)
     : mHandle(aHandle)
     , mOffset(aOffset)
     , mBuf(aBuf)
     , mCount(aCount)
     , mResultOnAnyThread(aResultOnAnyThread)
     , mCallback(aCallback)
     , mRV(NS_ERROR_FAILURE)
   {
     MOZ_COUNT_CTOR(ReadEvent);
     if (!aResultOnAnyThread) {
       mTarget = static_cast<nsIEventTarget*>(NS_GetCurrentThread());
     }
     MOZ_EVENT_TRACER_NAME_OBJECT(static_cast<nsIRunnable*>(this), aHandle->Key().get());
     MOZ_EVENT_TRACER_WAIT(static_cast<nsIRunnable*>(this), "net::cache::read-background");
   }
   ~ReadEvent()
   {
     MOZ_COUNT_DTOR(ReadEvent);
   }
   NS_IMETHOD Run()
   {
     if (mResultOnAnyThread || mTarget) {
       MOZ_EVENT_TRACER_EXEC(static_cast<nsIRunnable*>(this), "net::cache::read-background");
       if (mHandle->IsClosed()) {
         mRV = NS_ERROR_NOT_INITIALIZED;
       } else {
         mRV = CacheFileIOManager::gInstance->ReadInternal(
           mHandle, mOffset, mBuf, mCount);
       }
       MOZ_EVENT_TRACER_DONE(static_cast<nsIRunnable*>(this), "net::cache::read-background");
       MOZ_EVENT_TRACER_WAIT(static_cast<nsIRunnable*>(this), "net::cache::read-result");
       if (mTarget) {
         nsCOMPtr<nsIEventTarget> target;
         mTarget.swap(target);
         return target->Dispatch(this, nsIEventTarget::DISPATCH_NORMAL);
       }
     }
     if (!mTarget && mCallback) {
       MOZ_EVENT_TRACER_EXEC(static_cast<nsIRunnable*>(this), "net::cache::read-result");
       mCallback->OnDataRead(mHandle, mBuf, mRV);
       MOZ_EVENT_TRACER_DONE(static_cast<nsIRunnable*>(this), "net::cache::read-result");
     }
     return NS_OK;
   }
 protected:
   nsRefPtr<CacheFileHandle>     mHandle;
   int64_t                       mOffset;
   char                         *mBuf;
   int32_t                       mCount;
   bool                          mResultOnAnyThread;
   nsCOMPtr<CacheFileIOListener> mCallback;
   nsCOMPtr<nsIEventTarget>      mTarget;
   nsresult                      mRV;
 };
 class WriteEvent : public nsRunnable {
 public:
   WriteEvent(CacheFileHandle *aHandle, int64_t aOffset, const char *aBuf,
              int32_t aCount, bool aValidate, CacheFileIOListener *aCallback)
     : mHandle(aHandle)
     , mOffset(aOffset)
     , mBuf(aBuf)
     , mCount(aCount)
     , mValidate(aValidate)
     , mCallback(aCallback)
     , mRV(NS_ERROR_FAILURE)
   {
     MOZ_COUNT_CTOR(WriteEvent);
     mTarget = static_cast<nsIEventTarget*>(NS_GetCurrentThread());
     MOZ_EVENT_TRACER_NAME_OBJECT(static_cast<nsIRunnable*>(this), aHandle->Key().get());
     MOZ_EVENT_TRACER_WAIT(static_cast<nsIRunnable*>(this), "net::cache::write-background");
   }
   ~WriteEvent()
   {
     MOZ_COUNT_DTOR(WriteEvent);
     if (!mCallback && mBuf) {
       free(const_cast<char *>(mBuf));
     }
   }
   NS_IMETHOD Run()
   {
     if (mTarget) {
       MOZ_EVENT_TRACER_EXEC(static_cast<nsIRunnable*>(this), "net::cache::write-background");
       if (mHandle->IsClosed()) {
         mRV = NS_ERROR_NOT_INITIALIZED;
       } else {
         mRV = CacheFileIOManager::gInstance->WriteInternal(
           mHandle, mOffset, mBuf, mCount, mValidate);
       }
       MOZ_EVENT_TRACER_DONE(static_cast<nsIRunnable*>(this), "net::cache::write-background");
       MOZ_EVENT_TRACER_WAIT(static_cast<nsIRunnable*>(this), "net::cache::write-result");
       nsCOMPtr<nsIEventTarget> target;
       mTarget.swap(target);
       target->Dispatch(this, nsIEventTarget::DISPATCH_NORMAL);
     } else {
       MOZ_EVENT_TRACER_EXEC(static_cast<nsIRunnable*>(this), "net::cache::write-result");
       if (mCallback) {
         mCallback->OnDataWritten(mHandle, mBuf, mRV);
       } else {
         free(const_cast<char *>(mBuf));
         mBuf = nullptr;
       }
       MOZ_EVENT_TRACER_DONE(static_cast<nsIRunnable*>(this), "net::cache::write-result");
     }
     return NS_OK;
   }
 protected:
   nsRefPtr<CacheFileHandle>     mHandle;
   int64_t                       mOffset;
   const char                   *mBuf;
   int32_t                       mCount;
   bool                          mValidate;
   nsCOMPtr<CacheFileIOListener> mCallback;
   nsCOMPtr<nsIEventTarget>      mTarget;
   nsresult                      mRV;
 };
 class DoomFileEvent : public nsRunnable {
 public:
   DoomFileEvent(CacheFileHandle *aHandle,
                 CacheFileIOListener *aCallback)
     : mCallback(aCallback)
     , mHandle(aHandle)
     , mRV(NS_ERROR_FAILURE)
   {
     MOZ_COUNT_CTOR(DoomFileEvent);
     mTarget = static_cast<nsIEventTarget*>(NS_GetCurrentThread());
     MOZ_EVENT_TRACER_NAME_OBJECT(static_cast<nsIRunnable*>(this), aHandle->Key().get());
     MOZ_EVENT_TRACER_WAIT(static_cast<nsIRunnable*>(this), "net::cache::doom-background");
   }
   ~DoomFileEvent()
   {
     MOZ_COUNT_DTOR(DoomFileEvent);
   }
   NS_IMETHOD Run()
   {
     if (mTarget) {
       MOZ_EVENT_TRACER_EXEC(static_cast<nsIRunnable*>(this), "net::cache::doom-background");
       if (mHandle->IsClosed()) {
         mRV = NS_ERROR_NOT_INITIALIZED;
       } else {
         mRV = CacheFileIOManager::gInstance->DoomFileInternal(mHandle);
       }
       MOZ_EVENT_TRACER_DONE(static_cast<nsIRunnable*>(this), "net::cache::doom-background");
       MOZ_EVENT_TRACER_WAIT(static_cast<nsIRunnable*>(this), "net::cache::doom-result");
       nsCOMPtr<nsIEventTarget> target;
       mTarget.swap(target);
       target->Dispatch(this, nsIEventTarget::DISPATCH_NORMAL);
     } else {
       MOZ_EVENT_TRACER_EXEC(static_cast<nsIRunnable*>(this), "net::cache::doom-result");
       if (mCallback) {
         mCallback->OnFileDoomed(mHandle, mRV);
       }
       MOZ_EVENT_TRACER_DONE(static_cast<nsIRunnable*>(this), "net::cache::doom-result");
     }
     return NS_OK;
   }
 protected:
   nsCOMPtr<CacheFileIOListener> mCallback;
   nsCOMPtr<nsIEventTarget>      mTarget;
   nsRefPtr<CacheFileHandle>     mHandle;
   nsresult                      mRV;
 };
 class DoomFileByKeyEvent : public nsRunnable {
 public:
   DoomFileByKeyEvent(const nsACString &aKey,
                      CacheFileIOListener *aCallback)
     : mCallback(aCallback)
     , mRV(NS_ERROR_FAILURE)
   {
     MOZ_COUNT_CTOR(DoomFileByKeyEvent);
     SHA1Sum sum;
     sum.update(aKey.BeginReading(), aKey.Length());
     sum.finish(mHash);
     mTarget = static_cast<nsIEventTarget*>(NS_GetCurrentThread());
     mIOMan = CacheFileIOManager::gInstance;
     MOZ_ASSERT(mTarget);
   }
   ~DoomFileByKeyEvent()
   {
     MOZ_COUNT_DTOR(DoomFileByKeyEvent);
   }
   NS_IMETHOD Run()
   {
     if (mTarget) {
       if (!mIOMan) {
         mRV = NS_ERROR_NOT_INITIALIZED;
       } else {
         mRV = mIOMan->DoomFileByKeyInternal(&mHash);
         mIOMan = nullptr;
       }
       nsCOMPtr<nsIEventTarget> target;
       mTarget.swap(target);
       target->Dispatch(this, nsIEventTarget::DISPATCH_NORMAL);
     } else {
       if (mCallback) {
         mCallback->OnFileDoomed(nullptr, mRV);
       }
     }
     return NS_OK;
   }
 protected:
   SHA1Sum::Hash                 mHash;
   nsCOMPtr<CacheFileIOListener> mCallback;
   nsCOMPtr<nsIEventTarget>      mTarget;
   nsRefPtr<CacheFileIOManager>  mIOMan;
   nsresult                      mRV;
 };
 class ReleaseNSPRHandleEvent : public nsRunnable {
 public:
   ReleaseNSPRHandleEvent(CacheFileHandle *aHandle)
     : mHandle(aHandle)
   {
     MOZ_COUNT_CTOR(ReleaseNSPRHandleEvent);
   }
   ~ReleaseNSPRHandleEvent()
   {
     MOZ_COUNT_DTOR(ReleaseNSPRHandleEvent);
   }
   NS_IMETHOD Run()
   {
     if (mHandle->mFD && !mHandle->IsClosed()) {
       CacheFileIOManager::gInstance->ReleaseNSPRHandleInternal(mHandle);
     }
     return NS_OK;
   }
 protected:
   nsRefPtr<CacheFileHandle>     mHandle;
 };
 class TruncateSeekSetEOFEvent : public nsRunnable {
 public:
   TruncateSeekSetEOFEvent(CacheFileHandle *aHandle, int64_t aTruncatePos,
                           int64_t aEOFPos, CacheFileIOListener *aCallback)
     : mHandle(aHandle)
     , mTruncatePos(aTruncatePos)
     , mEOFPos(aEOFPos)
     , mCallback(aCallback)
     , mRV(NS_ERROR_FAILURE)
   {
     MOZ_COUNT_CTOR(TruncateSeekSetEOFEvent);
     mTarget = static_cast<nsIEventTarget*>(NS_GetCurrentThread());
   }
   ~TruncateSeekSetEOFEvent()
   {
     MOZ_COUNT_DTOR(TruncateSeekSetEOFEvent);
   }
   NS_IMETHOD Run()
   {
     if (mTarget) {
       if (mHandle->IsClosed()) {
         mRV = NS_ERROR_NOT_INITIALIZED;
       } else {
         mRV = CacheFileIOManager::gInstance->TruncateSeekSetEOFInternal(
           mHandle, mTruncatePos, mEOFPos);
       }
       nsCOMPtr<nsIEventTarget> target;
       mTarget.swap(target);
       target->Dispatch(this, nsIEventTarget::DISPATCH_NORMAL);
     } else {
       if (mCallback) {
         mCallback->OnEOFSet(mHandle, mRV);
       }
     }
     return NS_OK;
   }
 protected:
   nsRefPtr<CacheFileHandle>     mHandle;
   int64_t                       mTruncatePos;
   int64_t                       mEOFPos;
   nsCOMPtr<CacheFileIOListener> mCallback;
   nsCOMPtr<nsIEventTarget>      mTarget;
   nsresult                      mRV;
 };
 class RenameFileEvent : public nsRunnable {
 public:
   RenameFileEvent(CacheFileHandle *aHandle, const nsACString &aNewName,
                   CacheFileIOListener *aCallback)
     : mHandle(aHandle)
     , mNewName(aNewName)
     , mCallback(aCallback)
     , mRV(NS_ERROR_FAILURE)
   {
     MOZ_COUNT_CTOR(RenameFileEvent);
     mTarget = static_cast<nsIEventTarget*>(NS_GetCurrentThread());
   }
   ~RenameFileEvent()
   {
     MOZ_COUNT_DTOR(RenameFileEvent);
   }
   NS_IMETHOD Run()
   {
     if (mTarget) {
       if (mHandle->IsClosed()) {
         mRV = NS_ERROR_NOT_INITIALIZED;
       } else {
         mRV = CacheFileIOManager::gInstance->RenameFileInternal(mHandle,
                                                                 mNewName);
       }
       nsCOMPtr<nsIEventTarget> target;
       mTarget.swap(target);
       target->Dispatch(this, nsIEventTarget::DISPATCH_NORMAL);
     } else {
       if (mCallback) {
         mCallback->OnFileRenamed(mHandle, mRV);
       }
     }
     return NS_OK;
   }
 protected:
   nsRefPtr<CacheFileHandle>     mHandle;
   nsCString                     mNewName;
   nsCOMPtr<CacheFileIOListener> mCallback;
   nsCOMPtr<nsIEventTarget>      mTarget;
   nsresult                      mRV;
 };
 class InitIndexEntryEvent : public nsRunnable {
 public:
   InitIndexEntryEvent(CacheFileHandle *aHandle, uint32_t aAppId,
                       bool aAnonymous, bool aInBrowser)
     : mHandle(aHandle)
     , mAppId(aAppId)
     , mAnonymous(aAnonymous)
     , mInBrowser(aInBrowser)
   {
     MOZ_COUNT_CTOR(InitIndexEntryEvent);
   }
   ~InitIndexEntryEvent()
   {
     MOZ_COUNT_DTOR(InitIndexEntryEvent);
   }
   NS_IMETHOD Run()
   {
     if (mHandle->IsClosed() || mHandle->IsDoomed()) {
       return NS_OK;
     }
     CacheIndex::InitEntry(mHandle->Hash(), mAppId, mAnonymous, mInBrowser);
     // We cannot set the filesize before we init the entry. If we're opening
     // an existing entry file, frecency and expiration time will be set after
     // parsing the entry file, but we must set the filesize here since nobody is
     // going to set it if there is no write to the file.
     uint32_t sizeInK = mHandle->FileSizeInK();
     CacheIndex::UpdateEntry(mHandle->Hash(), nullptr, nullptr, &sizeInK);
     return NS_OK;
   }
 protected:
   nsRefPtr<CacheFileHandle> mHandle;
   uint32_t                  mAppId;
   bool                      mAnonymous;
   bool                      mInBrowser;
 };
 class UpdateIndexEntryEvent : public nsRunnable {
 public:
   UpdateIndexEntryEvent(CacheFileHandle *aHandle, const uint32_t *aFrecency,
                         const uint32_t *aExpirationTime)
     : mHandle(aHandle)
     , mHasFrecency(false)
     , mHasExpirationTime(false)
   {
     MOZ_COUNT_CTOR(UpdateIndexEntryEvent);
     if (aFrecency) {
       mHasFrecency = true;
       mFrecency = *aFrecency;
     }
     if (aExpirationTime) {
       mHasExpirationTime = true;
       mExpirationTime = *aExpirationTime;
     }
   }
   ~UpdateIndexEntryEvent()
   {
     MOZ_COUNT_DTOR(UpdateIndexEntryEvent);
   }
   NS_IMETHOD Run()
   {
     if (mHandle->IsClosed() || mHandle->IsDoomed()) {
       return NS_OK;
     }
     CacheIndex::UpdateEntry(mHandle->Hash(),
                             mHasFrecency ? &mFrecency : nullptr,
                             mHasExpirationTime ? &mExpirationTime : nullptr,
                             nullptr);
     return NS_OK;
   }
 protected:
   nsRefPtr<CacheFileHandle> mHandle;
   bool                      mHasFrecency;
   bool                      mHasExpirationTime;
   uint32_t                  mFrecency;
   uint32_t                  mExpirationTime;
 };
 class MetadataWriteScheduleEvent : public nsRunnable
 {
 public:
   enum EMode {
     SCHEDULE,
     UNSCHEDULE,
     SHUTDOWN
   } mMode;
   nsRefPtr<CacheFile> mFile;
   nsRefPtr<CacheFileIOManager> mIOMan;
   MetadataWriteScheduleEvent(CacheFileIOManager * aManager,
                              CacheFile * aFile,
                              EMode aMode)
     : mMode(aMode)
     , mFile(aFile)
     , mIOMan(aManager)
   { }
   virtual ~MetadataWriteScheduleEvent() { }
   NS_IMETHOD Run()
   {
     nsRefPtr<CacheFileIOManager> ioMan = CacheFileIOManager::gInstance;
     if (!ioMan) {
       NS_WARNING("CacheFileIOManager already gone in MetadataWriteScheduleEvent::Run()");
       return NS_OK;
     }
     switch (mMode)
     {
     case SCHEDULE:
       ioMan->ScheduleMetadataWriteInternal(mFile);
       break;
     case UNSCHEDULE:
       ioMan->UnscheduleMetadataWriteInternal(mFile);
       break;
     case SHUTDOWN:
       ioMan->ShutdownMetadataWriteSchedulingInternal();
       break;
     }
     return NS_OK;
   }
 };
 CacheFileIOManager * CacheFileIOManager::gInstance = nullptr;
 NS_IMPL_ISUPPORTS(CacheFileIOManager, nsITimerCallback)
 CacheFileIOManager::CacheFileIOManager()
   : mShuttingDown(false)
   , mTreeCreated(false)
   , mOverLimitEvicting(false)
   , mRemovingTrashDirs(false)
 {
   LOG(("CacheFileIOManager::CacheFileIOManager [this=%p]", this));
   MOZ_COUNT_CTOR(CacheFileIOManager);
   MOZ_ASSERT(!gInstance, "multiple CacheFileIOManager instances!");
 }
 CacheFileIOManager::~CacheFileIOManager()
 {
   LOG(("CacheFileIOManager::~CacheFileIOManager [this=%p]", this));
   MOZ_COUNT_DTOR(CacheFileIOManager);
 }
 // static
 nsresult
 CacheFileIOManager::Init()
 {
   LOG(("CacheFileIOManager::Init()"));
   MOZ_ASSERT(NS_IsMainThread());
   if (gInstance) {
     return NS_ERROR_ALREADY_INITIALIZED;
   }
   nsRefPtr<CacheFileIOManager> ioMan = new CacheFileIOManager();
   nsresult rv = ioMan->InitInternal();
   NS_ENSURE_SUCCESS(rv, rv);
   ioMan.swap(gInstance);
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::InitInternal()
 {
   nsresult rv;
   mIOThread = new CacheIOThread();
   rv = mIOThread->Init();
   MOZ_ASSERT(NS_SUCCEEDED(rv), "Can't create background thread");
   NS_ENSURE_SUCCESS(rv, rv);
   mStartTime = TimeStamp::NowLoRes();
   return NS_OK;
 }
 // static
 nsresult
 CacheFileIOManager::Shutdown()
 {
   LOG(("CacheFileIOManager::Shutdown() [gInstance=%p]", gInstance));
   MOZ_ASSERT(NS_IsMainThread());
   if (!gInstance) {
     return NS_ERROR_NOT_INITIALIZED;
   }
   Telemetry::AutoTimer<Telemetry::NETWORK_DISK_CACHE_SHUTDOWN_V2> shutdownTimer;
   CacheIndex::PreShutdown();
   ShutdownMetadataWriteScheduling();
   {
     mozilla::Mutex lock("CacheFileIOManager::Shutdown() lock");
     mozilla::CondVar condVar(lock, "CacheFileIOManager::Shutdown() condVar");
     MutexAutoLock autoLock(lock);
     nsRefPtr<ShutdownEvent> ev = new ShutdownEvent(&lock, &condVar);
     DebugOnly<nsresult> rv;
     rv = gInstance->mIOThread->Dispatch(ev, CacheIOThread::CLOSE);
     MOZ_ASSERT(NS_SUCCEEDED(rv));
     condVar.Wait();
   }
   MOZ_ASSERT(gInstance->mHandles.HandleCount() == 0);
   MOZ_ASSERT(gInstance->mHandlesByLastUsed.Length() == 0);
   if (gInstance->mIOThread) {
     gInstance->mIOThread->Shutdown();
   }
   CacheIndex::Shutdown();
   if (CacheObserver::ClearCacheOnShutdown()) {
     gInstance->SyncRemoveAllCacheFiles();
   }
   nsRefPtr<CacheFileIOManager> ioMan;
   ioMan.swap(gInstance);
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::ShutdownInternal()
 {
   LOG(("CacheFileIOManager::ShutdownInternal() [this=%p]", this));
   MOZ_ASSERT(mIOThread->IsCurrentThread());
   // No new handles can be created after this flag is set
   mShuttingDown = true;
   // close all handles and delete all associated files
   nsTArray<nsRefPtr<CacheFileHandle> > handles;
   mHandles.GetAllHandles(&handles);
   handles.AppendElements(mSpecialHandles);
   for (uint32_t i=0 ; i<handles.Length() ; i++) {
     CacheFileHandle *h = handles[i];
     h->mClosed = true;
     h->Log();
     // Close file handle
     if (h->mFD) {
       ReleaseNSPRHandleInternal(h);
     }
     // Remove file if entry is doomed or invalid
     if (h->mFileExists && (h->mIsDoomed || h->mInvalid)) {
       LOG(("CacheFileIOManager::ShutdownInternal() - Removing file from disk"));
       h->mFile->Remove(false);
     }
     if (!h->IsSpecialFile() && !h->mIsDoomed &&
         (h->mInvalid || !h->mFileExists)) {
       CacheIndex::RemoveEntry(h->Hash());
     }
     // Remove the handle from mHandles/mSpecialHandles
     if (h->IsSpecialFile()) {
       mSpecialHandles.RemoveElement(h);
     } else {
       mHandles.RemoveHandle(h);
     }
   }
   // Assert the table is empty. When we are here, no new handles can be added
   // and handles will no longer remove them self from this table and we don't
   // want to keep invalid handles here. Also, there is no lookup after this
   // point to happen.
   MOZ_ASSERT(mHandles.HandleCount() == 0);
   // Release trash directory enumerator
   if (mTrashDirEnumerator) {
     mTrashDirEnumerator->Close();
     mTrashDirEnumerator = nullptr;
   }
   return NS_OK;
 }
 // static
 nsresult
 CacheFileIOManager::OnProfile()
 {
   LOG(("CacheFileIOManager::OnProfile() [gInstance=%p]", gInstance));
   nsRefPtr<CacheFileIOManager> ioMan = gInstance;
   if (!ioMan) {
     // CacheFileIOManager::Init() failed, probably could not create the IO
     // thread, just go with it...
     return NS_ERROR_NOT_INITIALIZED;
   }
   nsresult rv;
   nsCOMPtr<nsIFile> directory;
   CacheObserver::ParentDirOverride(getter_AddRefs(directory));
 #if defined(MOZ_WIDGET_ANDROID)
   char* cachePath = getenv("CACHE_DIRECTORY");
   if (!directory && cachePath && *cachePath) {
     rv = NS_NewNativeLocalFile(nsDependentCString(cachePath),
                                true, getter_AddRefs(directory));
   }
 #endif
   if (!directory) {
     rv = NS_GetSpecialDirectory(NS_APP_CACHE_PARENT_DIR,
                                 getter_AddRefs(directory));
   }
   if (!directory) {
     rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_LOCAL_50_DIR,
                                 getter_AddRefs(directory));
   }
   if (directory) {
     rv = directory->Append(NS_LITERAL_STRING("cache2"));
     NS_ENSURE_SUCCESS(rv, rv);
   }
   // All functions return a clone.
   ioMan->mCacheDirectory.swap(directory);
   if (ioMan->mCacheDirectory) {
     CacheIndex::Init(ioMan->mCacheDirectory);
   }
   return NS_OK;
 }
 // static
 already_AddRefed<nsIEventTarget>
 CacheFileIOManager::IOTarget()
 {
   nsCOMPtr<nsIEventTarget> target;
   if (gInstance && gInstance->mIOThread) {
     target = gInstance->mIOThread->Target();
   }
   return target.forget();
 }
 // static
 already_AddRefed<CacheIOThread>
 CacheFileIOManager::IOThread()
 {
   nsRefPtr<CacheIOThread> thread;
   if (gInstance) {
     thread = gInstance->mIOThread;
   }
   return thread.forget();
 }
 // static
 bool
 CacheFileIOManager::IsOnIOThread()
 {
   nsRefPtr<CacheFileIOManager> ioMan = gInstance;
   if (ioMan && ioMan->mIOThread) {
     return ioMan->mIOThread->IsCurrentThread();
   }
   return false;
 }
 // static
 bool
 CacheFileIOManager::IsOnIOThreadOrCeased()
 {
   nsRefPtr<CacheFileIOManager> ioMan = gInstance;
   if (ioMan && ioMan->mIOThread) {
     return ioMan->mIOThread->IsCurrentThread();
   }
   // Ceased...
   return true;
 }
 // static
 bool
 CacheFileIOManager::IsShutdown()
 {
   if (!gInstance) {
     return true;
   }
   return gInstance->mShuttingDown;
 }
 // static
 nsresult
 CacheFileIOManager::ScheduleMetadataWrite(CacheFile * aFile)
 {
   nsRefPtr<CacheFileIOManager> ioMan = gInstance;
   NS_ENSURE_TRUE(ioMan, NS_ERROR_NOT_INITIALIZED);
   NS_ENSURE_TRUE(!ioMan->mShuttingDown, NS_ERROR_NOT_INITIALIZED);
   nsRefPtr<MetadataWriteScheduleEvent> event = new MetadataWriteScheduleEvent(
     ioMan, aFile, MetadataWriteScheduleEvent::SCHEDULE);
   nsCOMPtr<nsIEventTarget> target = ioMan->IOTarget();
   NS_ENSURE_TRUE(target, NS_ERROR_UNEXPECTED);
   return target->Dispatch(event, nsIEventTarget::DISPATCH_NORMAL);
 }
 nsresult
 CacheFileIOManager::ScheduleMetadataWriteInternal(CacheFile * aFile)
 {
   MOZ_ASSERT(IsOnIOThreadOrCeased());
   nsresult rv;
   if (!mMetadataWritesTimer) {
     mMetadataWritesTimer = do_CreateInstance("@mozilla.org/timer;1", &rv);
     NS_ENSURE_SUCCESS(rv, rv);
     rv = mMetadataWritesTimer->InitWithCallback(
       this, kMetadataWriteDelay, nsITimer::TYPE_ONE_SHOT);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   if (mScheduledMetadataWrites.IndexOf(aFile) !=
       mScheduledMetadataWrites.NoIndex) {
     return NS_OK;
   }
   mScheduledMetadataWrites.AppendElement(aFile);
   return NS_OK;
 }
 // static
 nsresult
 CacheFileIOManager::UnscheduleMetadataWrite(CacheFile * aFile)
 {
   nsRefPtr<CacheFileIOManager> ioMan = gInstance;
   NS_ENSURE_TRUE(ioMan, NS_ERROR_NOT_INITIALIZED);
   NS_ENSURE_TRUE(!ioMan->mShuttingDown, NS_ERROR_NOT_INITIALIZED);
   nsRefPtr<MetadataWriteScheduleEvent> event = new MetadataWriteScheduleEvent(
     ioMan, aFile, MetadataWriteScheduleEvent::UNSCHEDULE);
   nsCOMPtr<nsIEventTarget> target = ioMan->IOTarget();
   NS_ENSURE_TRUE(target, NS_ERROR_UNEXPECTED);
   return target->Dispatch(event, nsIEventTarget::DISPATCH_NORMAL);
 }
 nsresult
 CacheFileIOManager::UnscheduleMetadataWriteInternal(CacheFile * aFile)
 {
   MOZ_ASSERT(IsOnIOThreadOrCeased());
   mScheduledMetadataWrites.RemoveElement(aFile);
   if (mScheduledMetadataWrites.Length() == 0 &&
       mMetadataWritesTimer) {
     mMetadataWritesTimer->Cancel();
     mMetadataWritesTimer = nullptr;
   }
   return NS_OK;
 }
 // static
 nsresult
 CacheFileIOManager::ShutdownMetadataWriteScheduling()
 {
   nsRefPtr<CacheFileIOManager> ioMan = gInstance;
   NS_ENSURE_TRUE(ioMan, NS_ERROR_NOT_INITIALIZED);
   nsRefPtr<MetadataWriteScheduleEvent> event = new MetadataWriteScheduleEvent(
     ioMan, nullptr, MetadataWriteScheduleEvent::SHUTDOWN);
   nsCOMPtr<nsIEventTarget> target = ioMan->IOTarget();
   NS_ENSURE_TRUE(target, NS_ERROR_UNEXPECTED);
   return target->Dispatch(event, nsIEventTarget::DISPATCH_NORMAL);
 }
 nsresult
 CacheFileIOManager::ShutdownMetadataWriteSchedulingInternal()
 {
   MOZ_ASSERT(IsOnIOThreadOrCeased());
   nsTArray<nsRefPtr<CacheFile> > files;
   files.SwapElements(mScheduledMetadataWrites);
   for (uint32_t i = 0; i < files.Length(); ++i) {
     CacheFile * file = files[i];
     file->WriteMetadataIfNeeded();
   }
   if (mMetadataWritesTimer) {
     mMetadataWritesTimer->Cancel();
     mMetadataWritesTimer = nullptr;
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 CacheFileIOManager::Notify(nsITimer * aTimer)
 {
   MOZ_ASSERT(IsOnIOThreadOrCeased());
   MOZ_ASSERT(mMetadataWritesTimer == aTimer);
   mMetadataWritesTimer = nullptr;
   nsTArray<nsRefPtr<CacheFile> > files;
   files.SwapElements(mScheduledMetadataWrites);
   for (uint32_t i = 0; i < files.Length(); ++i) {
     CacheFile * file = files[i];
     file->WriteMetadataIfNeeded();
   }
   return NS_OK;
 }
 // static
 nsresult
 CacheFileIOManager::OpenFile(const nsACString &aKey,
                              uint32_t aFlags, bool aResultOnAnyThread,
                              CacheFileIOListener *aCallback)
 {
   LOG(("CacheFileIOManager::OpenFile() [key=%s, flags=%d, listener=%p]",
        PromiseFlatCString(aKey).get(), aFlags, aCallback));
   nsresult rv;
   nsRefPtr<CacheFileIOManager> ioMan = gInstance;
   if (!ioMan) {
     return NS_ERROR_NOT_INITIALIZED;
   }
   bool priority = aFlags & CacheFileIOManager::PRIORITY;
   nsRefPtr<OpenFileEvent> ev = new OpenFileEvent(aKey, aFlags, aResultOnAnyThread, aCallback);
   rv = ioMan->mIOThread->Dispatch(ev, priority
     ? CacheIOThread::OPEN_PRIORITY
     : CacheIOThread::OPEN);
   NS_ENSURE_SUCCESS(rv, rv);
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::OpenFileInternal(const SHA1Sum::Hash *aHash,
                                      const nsACString &aKey,
                                      uint32_t aFlags,
                                      CacheFileHandle **_retval)
 {
   LOG(("CacheFileIOManager::OpenFileInternal() [hash=%08x%08x%08x%08x%08x, "
        "key=%s, flags=%d]", LOGSHA1(aHash), PromiseFlatCString(aKey).get(),
        aFlags));
   MOZ_ASSERT(CacheFileIOManager::IsOnIOThread());
   nsresult rv;
   if (mShuttingDown) {
     return NS_ERROR_NOT_INITIALIZED;
   }
   if (!mTreeCreated) {
     rv = CreateCacheTree();
     if (NS_FAILED(rv)) return rv;
   }
   nsCOMPtr<nsIFile> file;
   rv = GetFile(aHash, getter_AddRefs(file));
   NS_ENSURE_SUCCESS(rv, rv);
   nsRefPtr<CacheFileHandle> handle;
   mHandles.GetHandle(aHash, false, getter_AddRefs(handle));
   if ((aFlags & (OPEN | CREATE | CREATE_NEW)) == CREATE_NEW) {
     if (handle) {
       rv = DoomFileInternal(handle);
       NS_ENSURE_SUCCESS(rv, rv);
       handle = nullptr;
     }
     rv = mHandles.NewHandle(aHash, aFlags & PRIORITY, getter_AddRefs(handle));
     NS_ENSURE_SUCCESS(rv, rv);
     bool exists;
     rv = file->Exists(&exists);
     NS_ENSURE_SUCCESS(rv, rv);
     if (exists) {
       CacheIndex::RemoveEntry(aHash);
       LOG(("CacheFileIOManager::OpenFileInternal() - Removing old file from "
            "disk"));
       rv = file->Remove(false);
       if (NS_FAILED(rv)) {
         NS_WARNING("Cannot remove old entry from the disk");
         LOG(("CacheFileIOManager::OpenFileInternal() - Removing old file failed"
              ". [rv=0x%08x]", rv));
       }
     }
     CacheIndex::AddEntry(aHash);
     handle->mFile.swap(file);
     handle->mFileSize = 0;
   }
   if (handle) {
     handle.swap(*_retval);
     return NS_OK;
   }
   bool exists;
   rv = file->Exists(&exists);
   NS_ENSURE_SUCCESS(rv, rv);
   if (exists && mContextEvictor) {
     if (mContextEvictor->ContextsCount() == 0) {
       mContextEvictor = nullptr;
     } else {
       bool wasEvicted = false;
       mContextEvictor->WasEvicted(aKey, file, &wasEvicted);
       if (wasEvicted) {
         LOG(("CacheFileIOManager::OpenFileInternal() - Removing file since the "
              "entry was evicted by EvictByContext()"));
         exists = false;
         file->Remove(false);
         CacheIndex::RemoveEntry(aHash);
       }
     }
   }
   if (!exists && (aFlags & (OPEN | CREATE | CREATE_NEW)) == OPEN) {
     return NS_ERROR_NOT_AVAILABLE;
   }
   rv = mHandles.NewHandle(aHash, aFlags & PRIORITY, getter_AddRefs(handle));
   NS_ENSURE_SUCCESS(rv, rv);
   if (exists) {
     rv = file->GetFileSize(&handle->mFileSize);
     NS_ENSURE_SUCCESS(rv, rv);
     handle->mFileExists = true;
     CacheIndex::EnsureEntryExists(aHash);
   } else {
     handle->mFileSize = 0;
     CacheIndex::AddEntry(aHash);
   }
   handle->mFile.swap(file);
   handle.swap(*_retval);
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::OpenSpecialFileInternal(const nsACString &aKey,
                                             uint32_t aFlags,
                                             CacheFileHandle **_retval)
 {
   LOG(("CacheFileIOManager::OpenSpecialFileInternal() [key=%s, flags=%d]",
        PromiseFlatCString(aKey).get(), aFlags));
   MOZ_ASSERT(CacheFileIOManager::IsOnIOThread());
   nsresult rv;
   if (mShuttingDown) {
     return NS_ERROR_NOT_INITIALIZED;
   }
   if (!mTreeCreated) {
     rv = CreateCacheTree();
     if (NS_FAILED(rv)) return rv;
   }
   nsCOMPtr<nsIFile> file;
   rv = GetSpecialFile(aKey, getter_AddRefs(file));
   NS_ENSURE_SUCCESS(rv, rv);
   nsRefPtr<CacheFileHandle> handle;
   for (uint32_t i = 0 ; i < mSpecialHandles.Length() ; i++) {
     if (!mSpecialHandles[i]->IsDoomed() && mSpecialHandles[i]->Key() == aKey) {
       handle = mSpecialHandles[i];
       break;
     }
   }
   if ((aFlags & (OPEN | CREATE | CREATE_NEW)) == CREATE_NEW) {
     if (handle) {
       rv = DoomFileInternal(handle);
       NS_ENSURE_SUCCESS(rv, rv);
       handle = nullptr;
     }
     handle = new CacheFileHandle(aKey, aFlags & PRIORITY);
     mSpecialHandles.AppendElement(handle);
     bool exists;
     rv = file->Exists(&exists);
     NS_ENSURE_SUCCESS(rv, rv);
     if (exists) {
       LOG(("CacheFileIOManager::OpenSpecialFileInternal() - Removing file from "
            "disk"));
       rv = file->Remove(false);
       if (NS_FAILED(rv)) {
         NS_WARNING("Cannot remove old entry from the disk");
         LOG(("CacheFileIOManager::OpenSpecialFileInternal() - Removing file "
              "failed. [rv=0x%08x]", rv));
       }
     }
     handle->mFile.swap(file);
     handle->mFileSize = 0;
   }
   if (handle) {
     handle.swap(*_retval);
     return NS_OK;
   }
   bool exists;
   rv = file->Exists(&exists);
   NS_ENSURE_SUCCESS(rv, rv);
   if (!exists && (aFlags & (OPEN | CREATE | CREATE_NEW)) == OPEN) {
     return NS_ERROR_NOT_AVAILABLE;
   }
   handle = new CacheFileHandle(aKey, aFlags & PRIORITY);
   mSpecialHandles.AppendElement(handle);
   if (exists) {
     rv = file->GetFileSize(&handle->mFileSize);
     NS_ENSURE_SUCCESS(rv, rv);
     handle->mFileExists = true;
   } else {
     handle->mFileSize = 0;
   }
   handle->mFile.swap(file);
   handle.swap(*_retval);
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::CloseHandleInternal(CacheFileHandle *aHandle)
 {
   LOG(("CacheFileIOManager::CloseHandleInternal() [handle=%p]", aHandle));
   aHandle->Log();
   MOZ_ASSERT(CacheFileIOManager::IsOnIOThreadOrCeased());
   // Close file handle
   if (aHandle->mFD) {
     ReleaseNSPRHandleInternal(aHandle);
   }
   // Delete the file if the entry was doomed or invalid
   if (aHandle->mIsDoomed || aHandle->mInvalid) {
     LOG(("CacheFileIOManager::CloseHandleInternal() - Removing file from "
          "disk"));
     aHandle->mFile->Remove(false);
   }
   if (!aHandle->IsSpecialFile() && !aHandle->mIsDoomed &&
       (aHandle->mInvalid || !aHandle->mFileExists)) {
     CacheIndex::RemoveEntry(aHandle->Hash());
   }
   // Don't remove handles after shutdown
   if (!mShuttingDown) {
     if (aHandle->IsSpecialFile()) {
       mSpecialHandles.RemoveElement(aHandle);
     } else {
       mHandles.RemoveHandle(aHandle);
     }
   }
   return NS_OK;
 }
 // static
 nsresult
 CacheFileIOManager::Read(CacheFileHandle *aHandle, int64_t aOffset,
                          char *aBuf, int32_t aCount, bool aResultOnAnyThread,
                          CacheFileIOListener *aCallback)
 {
   LOG(("CacheFileIOManager::Read() [handle=%p, offset=%lld, count=%d, "
        "listener=%p]", aHandle, aOffset, aCount, aCallback));
   nsresult rv;
   nsRefPtr<CacheFileIOManager> ioMan = gInstance;
   if (aHandle->IsClosed() || !ioMan) {
     return NS_ERROR_NOT_INITIALIZED;
   }
   nsRefPtr<ReadEvent> ev = new ReadEvent(aHandle, aOffset, aBuf, aCount,
                                          aResultOnAnyThread, aCallback);
   rv = ioMan->mIOThread->Dispatch(ev, aHandle->IsPriority()
     ? CacheIOThread::READ_PRIORITY
     : CacheIOThread::READ);
   NS_ENSURE_SUCCESS(rv, rv);
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::ReadInternal(CacheFileHandle *aHandle, int64_t aOffset,
                                  char *aBuf, int32_t aCount)
 {
   LOG(("CacheFileIOManager::ReadInternal() [handle=%p, offset=%lld, count=%d]",
        aHandle, aOffset, aCount));
   nsresult rv;
   if (!aHandle->mFileExists) {
     NS_WARNING("Trying to read from non-existent file");
     return NS_ERROR_NOT_AVAILABLE;
   }
   if (!aHandle->mFD) {
     rv = OpenNSPRHandle(aHandle);
     NS_ENSURE_SUCCESS(rv, rv);
   } else {
     NSPRHandleUsed(aHandle);
   }
   // Check again, OpenNSPRHandle could figure out the file was gone.
   if (!aHandle->mFileExists) {
     NS_WARNING("Trying to read from non-existent file");
     return NS_ERROR_NOT_AVAILABLE;
   }
   int64_t offset = PR_Seek64(aHandle->mFD, aOffset, PR_SEEK_SET);
   if (offset == -1) {
     return NS_ERROR_FAILURE;
   }
   int32_t bytesRead = PR_Read(aHandle->mFD, aBuf, aCount);
   if (bytesRead != aCount) {
     return NS_ERROR_FAILURE;
   }
   return NS_OK;
 }
 // static
 nsresult
 CacheFileIOManager::Write(CacheFileHandle *aHandle, int64_t aOffset,
                           const char *aBuf, int32_t aCount, bool aValidate,
                           CacheFileIOListener *aCallback)
 {
   LOG(("CacheFileIOManager::Write() [handle=%p, offset=%lld, count=%d, "
        "validate=%d, listener=%p]", aHandle, aOffset, aCount, aValidate,
        aCallback));
   nsresult rv;
   nsRefPtr<CacheFileIOManager> ioMan = gInstance;
   if (aHandle->IsClosed() || !ioMan) {
     return NS_ERROR_NOT_INITIALIZED;
   }
   nsRefPtr<WriteEvent> ev = new WriteEvent(aHandle, aOffset, aBuf, aCount,
                                            aValidate, aCallback);
   rv = ioMan->mIOThread->Dispatch(ev, CacheIOThread::WRITE);
   NS_ENSURE_SUCCESS(rv, rv);
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::WriteInternal(CacheFileHandle *aHandle, int64_t aOffset,
                                   const char *aBuf, int32_t aCount,
                                   bool aValidate)
 {
   LOG(("CacheFileIOManager::WriteInternal() [handle=%p, offset=%lld, count=%d, "
        "validate=%d]", aHandle, aOffset, aCount, aValidate));
   nsresult rv;
   if (!aHandle->mFileExists) {
     rv = CreateFile(aHandle);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   if (!aHandle->mFD) {
     rv = OpenNSPRHandle(aHandle);
     NS_ENSURE_SUCCESS(rv, rv);
   } else {
     NSPRHandleUsed(aHandle);
   }
   // Check again, OpenNSPRHandle could figure out the file was gone.
   if (!aHandle->mFileExists) {
     return NS_ERROR_NOT_AVAILABLE;
   }
   // Write invalidates the entry by default
   aHandle->mInvalid = true;
   int64_t offset = PR_Seek64(aHandle->mFD, aOffset, PR_SEEK_SET);
   if (offset == -1) {
     return NS_ERROR_FAILURE;
   }
   int32_t bytesWritten = PR_Write(aHandle->mFD, aBuf, aCount);
   if (bytesWritten != -1 && aHandle->mFileSize < aOffset+bytesWritten) {
     aHandle->mFileSize = aOffset+bytesWritten;
     if (!aHandle->IsDoomed() && !aHandle->IsSpecialFile()) {
       uint32_t size = aHandle->FileSizeInK();
       CacheIndex::UpdateEntry(aHandle->Hash(), nullptr, nullptr, &size);
       EvictIfOverLimitInternal();
     }
   }
   if (bytesWritten != aCount) {
     return NS_ERROR_FAILURE;
   }
   // Write was successful and this write validates the entry (i.e. metadata)
   if (aValidate) {
     aHandle->mInvalid = false;
   }
   return NS_OK;
 }
 // static
 nsresult
 CacheFileIOManager::DoomFile(CacheFileHandle *aHandle,
                              CacheFileIOListener *aCallback)
 {
   LOG(("CacheFileIOManager::DoomFile() [handle=%p, listener=%p]",
        aHandle, aCallback));
   nsresult rv;
   nsRefPtr<CacheFileIOManager> ioMan = gInstance;
   if (aHandle->IsClosed() || !ioMan) {
     return NS_ERROR_NOT_INITIALIZED;
   }
   nsRefPtr<DoomFileEvent> ev = new DoomFileEvent(aHandle, aCallback);
   rv = ioMan->mIOThread->Dispatch(ev, aHandle->IsPriority()
     ? CacheIOThread::OPEN_PRIORITY
     : CacheIOThread::OPEN);
   NS_ENSURE_SUCCESS(rv, rv);
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::DoomFileInternal(CacheFileHandle *aHandle)
 {
   LOG(("CacheFileIOManager::DoomFileInternal() [handle=%p]", aHandle));
   aHandle->Log();
   nsresult rv;
   if (aHandle->IsDoomed()) {
     return NS_OK;
   }
   if (aHandle->mFileExists) {
     // we need to move the current file to the doomed directory
     if (aHandle->mFD) {
       ReleaseNSPRHandleInternal(aHandle);
     }
     // find unused filename
     nsCOMPtr<nsIFile> file;
     rv = GetDoomedFile(getter_AddRefs(file));
     NS_ENSURE_SUCCESS(rv, rv);
     nsCOMPtr<nsIFile> parentDir;
     rv = file->GetParent(getter_AddRefs(parentDir));
     NS_ENSURE_SUCCESS(rv, rv);
     nsAutoCString leafName;
     rv = file->GetNativeLeafName(leafName);
     NS_ENSURE_SUCCESS(rv, rv);
     rv = aHandle->mFile->MoveToNative(parentDir, leafName);
     if (NS_ERROR_FILE_NOT_FOUND == rv || NS_ERROR_FILE_TARGET_DOES_NOT_EXIST == rv) {
       LOG(("  file already removed under our hands"));
       aHandle->mFileExists = false;
       rv = NS_OK;
     } else {
       NS_ENSURE_SUCCESS(rv, rv);
       aHandle->mFile.swap(file);
     }
   }
   if (!aHandle->IsSpecialFile()) {
     CacheIndex::RemoveEntry(aHandle->Hash());
   }
   aHandle->mIsDoomed = true;
   if (!aHandle->IsSpecialFile()) {
     nsRefPtr<CacheStorageService> storageService = CacheStorageService::Self();
     if (storageService) {
       nsAutoCString idExtension, url;
       nsCOMPtr<nsILoadContextInfo> info =
         CacheFileUtils::ParseKey(aHandle->Key(), &idExtension, &url);
       MOZ_ASSERT(info);
       if (info) {
         storageService->CacheFileDoomed(info, idExtension, url);
       }
     }
   }
   return NS_OK;
 }
 // static
 nsresult
 CacheFileIOManager::DoomFileByKey(const nsACString &aKey,
                                   CacheFileIOListener *aCallback)
 {
   LOG(("CacheFileIOManager::DoomFileByKey() [key=%s, listener=%p]",
        PromiseFlatCString(aKey).get(), aCallback));
   nsresult rv;
   nsRefPtr<CacheFileIOManager> ioMan = gInstance;
   if (!ioMan) {
     return NS_ERROR_NOT_INITIALIZED;
   }
   nsRefPtr<DoomFileByKeyEvent> ev = new DoomFileByKeyEvent(aKey, aCallback);
   rv = ioMan->mIOThread->DispatchAfterPendingOpens(ev);
   NS_ENSURE_SUCCESS(rv, rv);
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::DoomFileByKeyInternal(const SHA1Sum::Hash *aHash)
 {
   LOG(("CacheFileIOManager::DoomFileByKeyInternal() [hash=%08x%08x%08x%08x%08x]"
        , LOGSHA1(aHash)));
   MOZ_ASSERT(CacheFileIOManager::IsOnIOThreadOrCeased());
   nsresult rv;
   if (mShuttingDown) {
     return NS_ERROR_NOT_INITIALIZED;
   }
   if (!mCacheDirectory) {
     return NS_ERROR_FILE_INVALID_PATH;
   }
   // Find active handle
   nsRefPtr<CacheFileHandle> handle;
   mHandles.GetHandle(aHash, true, getter_AddRefs(handle));
   if (handle) {
     handle->Log();
     if (handle->IsDoomed()) {
       return NS_OK;
     }
     return DoomFileInternal(handle);
   }
   // There is no handle for this file, delete the file if exists
   nsCOMPtr<nsIFile> file;
   rv = GetFile(aHash, getter_AddRefs(file));
   NS_ENSURE_SUCCESS(rv, rv);
   bool exists;
   rv = file->Exists(&exists);
   NS_ENSURE_SUCCESS(rv, rv);
   if (!exists) {
     return NS_ERROR_NOT_AVAILABLE;
   }
   LOG(("CacheFileIOManager::DoomFileByKeyInternal() - Removing file from "
        "disk"));
   rv = file->Remove(false);
   if (NS_FAILED(rv)) {
     NS_WARNING("Cannot remove old entry from the disk");
     LOG(("CacheFileIOManager::DoomFileByKeyInternal() - Removing file failed. "
          "[rv=0x%08x]", rv));
   }
   CacheIndex::RemoveEntry(aHash);
   return NS_OK;
 }
 // static
 nsresult
 CacheFileIOManager::ReleaseNSPRHandle(CacheFileHandle *aHandle)
 {
   LOG(("CacheFileIOManager::ReleaseNSPRHandle() [handle=%p]", aHandle));
   nsresult rv;
   nsRefPtr<CacheFileIOManager> ioMan = gInstance;
   if (aHandle->IsClosed() || !ioMan) {
     return NS_ERROR_NOT_INITIALIZED;
   }
   nsRefPtr<ReleaseNSPRHandleEvent> ev = new ReleaseNSPRHandleEvent(aHandle);
   rv = ioMan->mIOThread->Dispatch(ev, CacheIOThread::CLOSE);
   NS_ENSURE_SUCCESS(rv, rv);
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::ReleaseNSPRHandleInternal(CacheFileHandle *aHandle)
 {
   LOG(("CacheFileIOManager::ReleaseNSPRHandleInternal() [handle=%p]", aHandle));
   MOZ_ASSERT(CacheFileIOManager::IsOnIOThreadOrCeased());
   MOZ_ASSERT(aHandle->mFD);
   DebugOnly<bool> found;
   found = mHandlesByLastUsed.RemoveElement(aHandle);
   MOZ_ASSERT(found);
   PR_Close(aHandle->mFD);
   aHandle->mFD = nullptr;
   return NS_OK;
 }
 // static
 nsresult
 CacheFileIOManager::TruncateSeekSetEOF(CacheFileHandle *aHandle,
                                        int64_t aTruncatePos, int64_t aEOFPos,
                                        CacheFileIOListener *aCallback)
 {
   LOG(("CacheFileIOManager::TruncateSeekSetEOF() [handle=%p, truncatePos=%lld, "
        "EOFPos=%lld, listener=%p]", aHandle, aTruncatePos, aEOFPos, aCallback));
   nsresult rv;
   nsRefPtr<CacheFileIOManager> ioMan = gInstance;
   if (aHandle->IsClosed() || !ioMan) {
     return NS_ERROR_NOT_INITIALIZED;
   }
   nsRefPtr<TruncateSeekSetEOFEvent> ev = new TruncateSeekSetEOFEvent(
                                            aHandle, aTruncatePos, aEOFPos,
                                            aCallback);
   rv = ioMan->mIOThread->Dispatch(ev, CacheIOThread::WRITE);
   NS_ENSURE_SUCCESS(rv, rv);
   return NS_OK;
 }
 // static
 void CacheFileIOManager::GetCacheDirectory(nsIFile** result)
 {
   *result = nullptr;
   nsRefPtr<CacheFileIOManager> ioMan = gInstance;
   if (!ioMan) {
     return;
   }
   nsCOMPtr<nsIFile> file = ioMan->mCacheDirectory;
   file.forget(result);
 }
 static nsresult
 TruncFile(PRFileDesc *aFD, uint32_t aEOF)
 {
 #if defined(XP_UNIX)
   if (ftruncate(PR_FileDesc2NativeHandle(aFD), aEOF) != 0) {
     NS_ERROR("ftruncate failed");
     return NS_ERROR_FAILURE;
   }
 #elif defined(XP_WIN)
   int32_t cnt = PR_Seek(aFD, aEOF, PR_SEEK_SET);
   if (cnt == -1) {
     return NS_ERROR_FAILURE;
   }
   if (!SetEndOfFile((HANDLE) PR_FileDesc2NativeHandle(aFD))) {
     NS_ERROR("SetEndOfFile failed");
     return NS_ERROR_FAILURE;
   }
 #else
   MOZ_ASSERT(false, "Not implemented!");
 #endif
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::TruncateSeekSetEOFInternal(CacheFileHandle *aHandle,
                                                int64_t aTruncatePos,
                                                int64_t aEOFPos)
 {
   LOG(("CacheFileIOManager::TruncateSeekSetEOFInternal() [handle=%p, "
        "truncatePos=%lld, EOFPos=%lld]", aHandle, aTruncatePos, aEOFPos));
   nsresult rv;
   if (!aHandle->mFileExists) {
     rv = CreateFile(aHandle);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   if (!aHandle->mFD) {
     rv = OpenNSPRHandle(aHandle);
     NS_ENSURE_SUCCESS(rv, rv);
   } else {
     NSPRHandleUsed(aHandle);
   }
   // Check again, OpenNSPRHandle could figure out the file was gone.
   if (!aHandle->mFileExists) {
     return NS_ERROR_NOT_AVAILABLE;
   }
   // This operation always invalidates the entry
   aHandle->mInvalid = true;
   rv = TruncFile(aHandle->mFD, static_cast<uint32_t>(aTruncatePos));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = TruncFile(aHandle->mFD, static_cast<uint32_t>(aEOFPos));
   NS_ENSURE_SUCCESS(rv, rv);
   return NS_OK;
 }
 // static
 nsresult
 CacheFileIOManager::RenameFile(CacheFileHandle *aHandle,
                                const nsACString &aNewName,
                                CacheFileIOListener *aCallback)
 {
   LOG(("CacheFileIOManager::RenameFile() [handle=%p, newName=%s, listener=%p]",
        aHandle, PromiseFlatCString(aNewName).get(), aCallback));
   nsresult rv;
   nsRefPtr<CacheFileIOManager> ioMan = gInstance;
   if (aHandle->IsClosed() || !ioMan) {
     return NS_ERROR_NOT_INITIALIZED;
   }
   if (!aHandle->IsSpecialFile()) {
     return NS_ERROR_UNEXPECTED;
   }
   nsRefPtr<RenameFileEvent> ev = new RenameFileEvent(aHandle, aNewName,
                                                      aCallback);
   rv = ioMan->mIOThread->Dispatch(ev, CacheIOThread::WRITE);
   NS_ENSURE_SUCCESS(rv, rv);
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::RenameFileInternal(CacheFileHandle *aHandle,
                                        const nsACString &aNewName)
 {
   LOG(("CacheFileIOManager::RenameFileInternal() [handle=%p, newName=%s]",
        aHandle, PromiseFlatCString(aNewName).get()));
   nsresult rv;
   MOZ_ASSERT(aHandle->IsSpecialFile());
   if (aHandle->IsDoomed()) {
     return NS_ERROR_NOT_AVAILABLE;
   }
   // Doom old handle if it exists and is not doomed
   for (uint32_t i = 0 ; i < mSpecialHandles.Length() ; i++) {
     if (!mSpecialHandles[i]->IsDoomed() &&
         mSpecialHandles[i]->Key() == aNewName) {
       MOZ_ASSERT(aHandle != mSpecialHandles[i]);
       rv = DoomFileInternal(mSpecialHandles[i]);
       NS_ENSURE_SUCCESS(rv, rv);
       break;
     }
   }
   nsCOMPtr<nsIFile> file;
   rv = GetSpecialFile(aNewName, getter_AddRefs(file));
   NS_ENSURE_SUCCESS(rv, rv);
   bool exists;
   rv = file->Exists(&exists);
   NS_ENSURE_SUCCESS(rv, rv);
   if (exists) {
     LOG(("CacheFileIOManager::RenameFileInternal() - Removing old file from "
          "disk"));
     rv = file->Remove(false);
     if (NS_FAILED(rv)) {
       NS_WARNING("Cannot remove file from the disk");
       LOG(("CacheFileIOManager::RenameFileInternal() - Removing old file failed"
            ". [rv=0x%08x]", rv));
     }
   }
   if (!aHandle->FileExists()) {
     aHandle->mKey = aNewName;
     return NS_OK;
   }
   if (aHandle->mFD) {
     ReleaseNSPRHandleInternal(aHandle);
   }
   rv = aHandle->mFile->MoveToNative(nullptr, aNewName);
   NS_ENSURE_SUCCESS(rv, rv);
   aHandle->mKey = aNewName;
   return NS_OK;
 }
 // static
 nsresult
 CacheFileIOManager::EvictIfOverLimit()
 {
   LOG(("CacheFileIOManager::EvictIfOverLimit()"));
   nsresult rv;
   nsRefPtr<CacheFileIOManager> ioMan = gInstance;
   if (!ioMan) {
     return NS_ERROR_NOT_INITIALIZED;
   }
   nsCOMPtr<nsIRunnable> ev;
   ev = NS_NewRunnableMethod(ioMan,
                             &CacheFileIOManager::EvictIfOverLimitInternal);
   rv = ioMan->mIOThread->Dispatch(ev, CacheIOThread::EVICT);
   NS_ENSURE_SUCCESS(rv, rv);
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::EvictIfOverLimitInternal()
 {
   LOG(("CacheFileIOManager::EvictIfOverLimitInternal()"));
   nsresult rv;
   MOZ_ASSERT(mIOThread->IsCurrentThread());
   if (mShuttingDown) {
     return NS_ERROR_NOT_INITIALIZED;
   }
   if (mOverLimitEvicting) {
     LOG(("CacheFileIOManager::EvictIfOverLimitInternal() - Eviction already "
          "running."));
     return NS_OK;
   }
   UpdateSmartCacheSize();
   uint32_t cacheUsage;
   rv = CacheIndex::GetCacheSize(&cacheUsage);
   NS_ENSURE_SUCCESS(rv, rv);
   uint32_t cacheLimit = CacheObserver::DiskCacheCapacity() >> 10;
   if (cacheUsage <= cacheLimit) {
     LOG(("CacheFileIOManager::EvictIfOverLimitInternal() - Cache size under "
          "limit. [cacheSize=%u, limit=%u]", cacheUsage, cacheLimit));
     return NS_OK;
   }
   LOG(("CacheFileIOManager::EvictIfOverLimitInternal() - Cache size exceeded "
        "limit. Starting overlimit eviction. [cacheSize=%u, limit=%u]",
        cacheUsage, cacheLimit));
   nsCOMPtr<nsIRunnable> ev;
   ev = NS_NewRunnableMethod(this,
                             &CacheFileIOManager::OverLimitEvictionInternal);
   rv = mIOThread->Dispatch(ev, CacheIOThread::EVICT);
   NS_ENSURE_SUCCESS(rv, rv);
   mOverLimitEvicting = true;
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::OverLimitEvictionInternal()
 {
   LOG(("CacheFileIOManager::OverLimitEvictionInternal()"));
   nsresult rv;
   MOZ_ASSERT(mIOThread->IsCurrentThread());
   // mOverLimitEvicting is accessed only on IO thread, so we can set it to false
   // here and set it to true again once we dispatch another event that will
   // continue with the eviction. The reason why we do so is that we can fail
   // early anywhere in this method and the variable will contain a correct
   // value. Otherwise we would need to set it to false on every failing place.
   mOverLimitEvicting = false;
   if (mShuttingDown) {
     return NS_ERROR_NOT_INITIALIZED;
   }
   UpdateSmartCacheSize();
   while (true) {
     uint32_t cacheUsage;
     rv = CacheIndex::GetCacheSize(&cacheUsage);
     NS_ENSURE_SUCCESS(rv, rv);
     uint32_t cacheLimit = CacheObserver::DiskCacheCapacity() >> 10;
     if (cacheUsage <= cacheLimit) {
       LOG(("CacheFileIOManager::OverLimitEvictionInternal() - Cache size under "
            "limit. [cacheSize=%u, limit=%u]", cacheUsage, cacheLimit));
       return NS_OK;
     }
     LOG(("CacheFileIOManager::OverLimitEvictionInternal() - Cache size over "
          "limit. [cacheSize=%u, limit=%u]", cacheUsage, cacheLimit));
     if (CacheIOThread::YieldAndRerun()) {
       LOG(("CacheFileIOManager::OverLimitEvictionInternal() - Breaking loop "
            "for higher level events."));
       mOverLimitEvicting = true;
       return NS_OK;
     }
     SHA1Sum::Hash hash;
     uint32_t cnt;
     static uint32_t consecutiveFailures = 0;
     rv = CacheIndex::GetEntryForEviction(&hash, &cnt);
     NS_ENSURE_SUCCESS(rv, rv);
     rv = DoomFileByKeyInternal(&hash);
     if (NS_SUCCEEDED(rv)) {
       consecutiveFailures = 0;
     } else if (rv == NS_ERROR_NOT_AVAILABLE) {
       LOG(("CacheFileIOManager::OverLimitEvictionInternal() - "
            "DoomFileByKeyInternal() failed. [rv=0x%08x]", rv));
       // TODO index is outdated, start update
       // Make sure index won't return the same entry again
       CacheIndex::RemoveEntry(&hash);
       consecutiveFailures = 0;
     } else {
       // This shouldn't normally happen, but the eviction must not fail
       // completely if we ever encounter this problem.
       NS_WARNING("CacheFileIOManager::OverLimitEvictionInternal() - Unexpected "
                  "failure of DoomFileByKeyInternal()");
       LOG(("CacheFileIOManager::OverLimitEvictionInternal() - "
            "DoomFileByKeyInternal() failed. [rv=0x%08x]", rv));
       // Normally, CacheIndex::UpdateEntry() is called only to update newly
       // created/opened entries which are always fresh and UpdateEntry() expects
       // and checks this flag. The way we use UpdateEntry() here is a kind of
       // hack and we must make sure the flag is set by calling
       // EnsureEntryExists().
       rv = CacheIndex::EnsureEntryExists(&hash);
       NS_ENSURE_SUCCESS(rv, rv);
       // Move the entry at the end of both lists to make sure we won't end up
       // failing on one entry forever.
       uint32_t frecency = 0;
       uint32_t expTime = nsICacheEntry::NO_EXPIRATION_TIME;
       rv = CacheIndex::UpdateEntry(&hash, &frecency, &expTime, nullptr);
       NS_ENSURE_SUCCESS(rv, rv);
       consecutiveFailures++;
       if (consecutiveFailures >= cnt) {
         // This doesn't necessarily mean that we've tried to doom every entry
         // but we've reached a sane number of tries. It is likely that another
         // eviction will start soon. And as said earlier, this normally doesn't
         // happen at all.
         return NS_OK;
       }
     }
   }
   NS_NOTREACHED("We should never get here");
   return NS_OK;
 }
 // static
 nsresult
 CacheFileIOManager::EvictAll()
 {
   LOG(("CacheFileIOManager::EvictAll()"));
   nsresult rv;
   nsRefPtr<CacheFileIOManager> ioMan = gInstance;
   if (!ioMan) {
     return NS_ERROR_NOT_INITIALIZED;
   }
   nsCOMPtr<nsIRunnable> ev;
   ev = NS_NewRunnableMethod(ioMan, &CacheFileIOManager::EvictAllInternal);
   rv = ioMan->mIOThread->DispatchAfterPendingOpens(ev);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
   return NS_OK;
 }
 namespace {
 class EvictionNotifierRunnable : public nsRunnable
 {
 public:
   NS_DECL_NSIRUNNABLE
 };
 NS_IMETHODIMP
 EvictionNotifierRunnable::Run()
 {
   nsCOMPtr<nsIObserverService> obsSvc = mozilla::services::GetObserverService();
   if (obsSvc) {
     obsSvc->NotifyObservers(nullptr, "cacheservice:empty-cache", nullptr);
   }
   return NS_OK;
 }
 } // anonymous namespace
 nsresult
 CacheFileIOManager::EvictAllInternal()
 {
   LOG(("CacheFileIOManager::EvictAllInternal()"));
   nsresult rv;
   MOZ_ASSERT(mIOThread->IsCurrentThread());
   nsRefPtr<EvictionNotifierRunnable> r = new EvictionNotifierRunnable();
   if (!mCacheDirectory) {
     // This is a kind of hack. Somebody called EvictAll() without a profile.
     // This happens in xpcshell tests that use cache without profile. We need
     // to notify observers in this case since the tests are waiting for it.
     NS_DispatchToMainThread(r);
     return NS_ERROR_FILE_INVALID_PATH;
   }
   if (mShuttingDown) {
     return NS_ERROR_NOT_INITIALIZED;
   }
   if (!mTreeCreated) {
     rv = CreateCacheTree();
     if (NS_FAILED(rv)) {
       return rv;
     }
   }
   // Doom all active handles
   nsTArray<nsRefPtr<CacheFileHandle> > handles;
   mHandles.GetActiveHandles(&handles);
   for (uint32_t i = 0; i < handles.Length(); ++i) {
     rv = DoomFileInternal(handles[i]);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       LOG(("CacheFileIOManager::EvictAllInternal() - Cannot doom handle "
            "[handle=%p]", handles[i].get()));
     }
   }
   nsCOMPtr<nsIFile> file;
   rv = mCacheDirectory->Clone(getter_AddRefs(file));
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
   rv = file->AppendNative(NS_LITERAL_CSTRING(kEntriesDir));
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
   // Trash current entries directory
   rv = TrashDirectory(file);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
   // Files are now inaccessible in entries directory, notify observers.
   NS_DispatchToMainThread(r);
   // Create a new empty entries directory
   rv = CheckAndCreateDir(mCacheDirectory, kEntriesDir, false);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
   CacheIndex::RemoveAll();
   return NS_OK;
 }
 // static
 nsresult
 CacheFileIOManager::EvictByContext(nsILoadContextInfo *aLoadContextInfo)
 {
   LOG(("CacheFileIOManager::EvictByContext() [loadContextInfo=%p]",
        aLoadContextInfo));
   nsresult rv;
   nsRefPtr<CacheFileIOManager> ioMan = gInstance;
   if (!ioMan) {
     return NS_ERROR_NOT_INITIALIZED;
   }
   nsCOMPtr<nsIRunnable> ev;
   ev = NS_NewRunnableMethodWithArg<nsCOMPtr<nsILoadContextInfo> >
          (ioMan, &CacheFileIOManager::EvictByContextInternal, aLoadContextInfo);
   rv = ioMan->mIOThread->DispatchAfterPendingOpens(ev);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::EvictByContextInternal(nsILoadContextInfo *aLoadContextInfo)
 {
   LOG(("CacheFileIOManager::EvictByContextInternal() [loadContextInfo=%p, "
        "anonymous=%u, inBrowser=%u, appId=%u]", aLoadContextInfo,
        aLoadContextInfo->IsAnonymous(), aLoadContextInfo->IsInBrowserElement(),
        aLoadContextInfo->AppId()));
   nsresult rv;
   MOZ_ASSERT(mIOThread->IsCurrentThread());
   MOZ_ASSERT(!aLoadContextInfo->IsPrivate());
   if (aLoadContextInfo->IsPrivate()) {
     return NS_ERROR_INVALID_ARG;
   }
   if (!mCacheDirectory) {
     return NS_ERROR_FILE_INVALID_PATH;
   }
   if (mShuttingDown) {
     return NS_ERROR_NOT_INITIALIZED;
   }
   if (!mTreeCreated) {
     rv = CreateCacheTree();
     if (NS_FAILED(rv)) {
       return rv;
     }
   }
   // Doom all active handles that matches the load context
   nsTArray<nsRefPtr<CacheFileHandle> > handles;
   mHandles.GetActiveHandles(&handles);
   for (uint32_t i = 0; i < handles.Length(); ++i) {
     bool equals;
     rv = CacheFileUtils::KeyMatchesLoadContextInfo(handles[i]->Key(),
                                                    aLoadContextInfo,
                                                    &equals);
     if (NS_FAILED(rv)) {
       LOG(("CacheFileIOManager::EvictByContextInternal() - Cannot parse key in "
            "handle! [handle=%p, key=%s]", handles[i].get(),
            handles[i]->Key().get()));
       MOZ_CRASH("Unexpected error!");
     }
     if (equals) {
       rv = DoomFileInternal(handles[i]);
       if (NS_WARN_IF(NS_FAILED(rv))) {
         LOG(("CacheFileIOManager::EvictByContextInternal() - Cannot doom handle"
              " [handle=%p]", handles[i].get()));
       }
     }
   }
   if (!mContextEvictor) {
     mContextEvictor = new CacheFileContextEvictor();
     mContextEvictor->Init(mCacheDirectory);
   }
   mContextEvictor->AddContext(aLoadContextInfo);
   return NS_OK;
 }
 // static
 nsresult
 CacheFileIOManager::CacheIndexStateChanged()
 {
   LOG(("CacheFileIOManager::CacheIndexStateChanged()"));
   nsresult rv;
   // CacheFileIOManager lives longer than CacheIndex so gInstance must be
   // non-null here.
   MOZ_ASSERT(gInstance);
   // We have to re-distatch even if we are on IO thread to prevent reentering
   // the lock in CacheIndex
   nsCOMPtr<nsIRunnable> ev;
   ev = NS_NewRunnableMethod(
     gInstance, &CacheFileIOManager::CacheIndexStateChangedInternal);
   nsCOMPtr<nsIEventTarget> ioTarget = IOTarget();
   MOZ_ASSERT(ioTarget);
   rv = ioTarget->Dispatch(ev, nsIEventTarget::DISPATCH_NORMAL);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::CacheIndexStateChangedInternal()
 {
   if (mShuttingDown) {
     // ignore notification during shutdown
     return NS_OK;
   }
   if (!mContextEvictor) {
     return NS_OK;
   }
   mContextEvictor->CacheIndexStateChanged();
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::TrashDirectory(nsIFile *aFile)
 {
 #ifdef PR_LOGGING
   nsAutoCString path;
   aFile->GetNativePath(path);
 #endif
   LOG(("CacheFileIOManager::TrashDirectory() [file=%s]", path.get()));
   nsresult rv;
   MOZ_ASSERT(mIOThread->IsCurrentThread());
   MOZ_ASSERT(mCacheDirectory);
   // When the directory is empty, it is cheaper to remove it directly instead of
   // using the trash mechanism.
   bool isEmpty;
   rv = IsEmptyDirectory(aFile, &isEmpty);
   NS_ENSURE_SUCCESS(rv, rv);
   if (isEmpty) {
     rv = aFile->Remove(false);
     LOG(("CacheFileIOManager::TrashDirectory() - Directory removed [rv=0x%08x]",
          rv));
     return rv;
   }
 #ifdef DEBUG
   nsCOMPtr<nsIFile> dirCheck;
   rv = aFile->GetParent(getter_AddRefs(dirCheck));
   NS_ENSURE_SUCCESS(rv, rv);
   bool equals = false;
   rv = dirCheck->Equals(mCacheDirectory, &equals);
   NS_ENSURE_SUCCESS(rv, rv);
   MOZ_ASSERT(equals);
 #endif
   nsCOMPtr<nsIFile> dir, trash;
   nsAutoCString leaf;
   rv = aFile->Clone(getter_AddRefs(dir));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = aFile->Clone(getter_AddRefs(trash));
   NS_ENSURE_SUCCESS(rv, rv);
   srand(static_cast<unsigned>(PR_Now()));
   while (true) {
     leaf = kTrashDir;
     leaf.AppendInt(rand());
     rv = trash->SetNativeLeafName(leaf);
     NS_ENSURE_SUCCESS(rv, rv);
     bool exists;
     if (NS_SUCCEEDED(trash->Exists(&exists)) && !exists) {
       break;
     }
   }
   LOG(("CacheFileIOManager::TrashDirectory() - Renaming directory [leaf=%s]",
        leaf.get()));
   rv = dir->MoveToNative(nullptr, leaf);
   NS_ENSURE_SUCCESS(rv, rv);
   StartRemovingTrash();
   return NS_OK;
 }
 // static
 void
 CacheFileIOManager::OnTrashTimer(nsITimer *aTimer, void *aClosure)
 {
   LOG(("CacheFileIOManager::OnTrashTimer() [timer=%p, closure=%p]", aTimer,
        aClosure));
   nsRefPtr<CacheFileIOManager> ioMan = gInstance;
   if (!ioMan) {
     return;
   }
   ioMan->mTrashTimer = nullptr;
   ioMan->StartRemovingTrash();
 }
 nsresult
 CacheFileIOManager::StartRemovingTrash()
 {
   LOG(("CacheFileIOManager::StartRemovingTrash()"));
   nsresult rv;
   MOZ_ASSERT(mIOThread->IsCurrentThread());
   if (mShuttingDown) {
     return NS_ERROR_NOT_INITIALIZED;
   }
   if (!mCacheDirectory) {
     return NS_ERROR_FILE_INVALID_PATH;
   }
   if (mTrashTimer) {
     LOG(("CacheFileIOManager::StartRemovingTrash() - Trash timer exists."));
     return NS_OK;
   }
   if (mRemovingTrashDirs) {
     LOG(("CacheFileIOManager::StartRemovingTrash() - Trash removing in "
          "progress."));
     return NS_OK;
   }
   uint32_t elapsed = (TimeStamp::NowLoRes() - mStartTime).ToMilliseconds();
   if (elapsed < kRemoveTrashStartDelay) {
     nsCOMPtr<nsITimer> timer = do_CreateInstance("@mozilla.org/timer;1", &rv);
     NS_ENSURE_SUCCESS(rv, rv);
     nsCOMPtr<nsIEventTarget> ioTarget = IOTarget();
     MOZ_ASSERT(ioTarget);
     rv = timer->SetTarget(ioTarget);
     NS_ENSURE_SUCCESS(rv, rv);
     rv = timer->InitWithFuncCallback(CacheFileIOManager::OnTrashTimer, nullptr,
                                      kRemoveTrashStartDelay - elapsed,
                                      nsITimer::TYPE_ONE_SHOT);
     NS_ENSURE_SUCCESS(rv, rv);
     mTrashTimer.swap(timer);
     return NS_OK;
   }
   nsCOMPtr<nsIRunnable> ev;
   ev = NS_NewRunnableMethod(this,
                             &CacheFileIOManager::RemoveTrashInternal);
   rv = mIOThread->Dispatch(ev, CacheIOThread::EVICT);
   NS_ENSURE_SUCCESS(rv, rv);
   mRemovingTrashDirs = true;
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::RemoveTrashInternal()
 {
   LOG(("CacheFileIOManager::RemoveTrashInternal()"));
   nsresult rv;
   MOZ_ASSERT(mIOThread->IsCurrentThread());
   if (mShuttingDown) {
     return NS_ERROR_NOT_INITIALIZED;
   }
   MOZ_ASSERT(!mTrashTimer);
   MOZ_ASSERT(mRemovingTrashDirs);
   if (!mTreeCreated) {
     rv = CreateCacheTree();
     if (NS_FAILED(rv)) {
       return rv;
     }
   }
   // mRemovingTrashDirs is accessed only on IO thread, so we can drop the flag
   // here and set it again once we dispatch a continuation event. By doing so,
   // we don't have to drop the flag on any possible early return.
   mRemovingTrashDirs = false;
   while (true) {
     if (CacheIOThread::YieldAndRerun()) {
       LOG(("CacheFileIOManager::RemoveTrashInternal() - Breaking loop for "
            "higher level events."));
       mRemovingTrashDirs = true;
       return NS_OK;
     }
     // Find some trash directory
     if (!mTrashDir) {
       MOZ_ASSERT(!mTrashDirEnumerator);
       rv = FindTrashDirToRemove();
       if (rv == NS_ERROR_NOT_AVAILABLE) {
         LOG(("CacheFileIOManager::RemoveTrashInternal() - No trash directory "
              "found."));
         return NS_OK;
       }
       NS_ENSURE_SUCCESS(rv, rv);
       nsCOMPtr<nsISimpleEnumerator> enumerator;
       rv = mTrashDir->GetDirectoryEntries(getter_AddRefs(enumerator));
       if (NS_SUCCEEDED(rv)) {
         mTrashDirEnumerator = do_QueryInterface(enumerator, &rv);
         NS_ENSURE_SUCCESS(rv, rv);
       }
       continue; // check elapsed time
     }
     // We null out mTrashDirEnumerator once we remove all files in the
     // directory, so remove the trash directory if we don't have enumerator.
     if (!mTrashDirEnumerator) {
       rv = mTrashDir->Remove(false);
       if (NS_FAILED(rv)) {
         // There is no reason why removing an empty directory should fail, but
         // if it does, we should continue and try to remove all other trash
         // directories.
         nsAutoCString leafName;
         mTrashDir->GetNativeLeafName(leafName);
         mFailedTrashDirs.AppendElement(leafName);
         LOG(("CacheFileIOManager::RemoveTrashInternal() - Cannot remove "
              "trashdir. [name=%s]", leafName.get()));
       }
       mTrashDir = nullptr;
       continue; // check elapsed time
     }
     nsCOMPtr<nsIFile> file;
     rv = mTrashDirEnumerator->GetNextFile(getter_AddRefs(file));
     if (!file) {
       mTrashDirEnumerator->Close();
       mTrashDirEnumerator = nullptr;
       continue; // check elapsed time
     } else {
       bool isDir = false;
       file->IsDirectory(&isDir);
       if (isDir) {
         NS_WARNING("Found a directory in a trash directory! It will be removed "
                    "recursively, but this can block IO thread for a while!");
 #ifdef PR_LOGGING
         nsAutoCString path;
         file->GetNativePath(path);
 #endif
         LOG(("CacheFileIOManager::RemoveTrashInternal() - Found a directory in a trash "
             "directory! It will be removed recursively, but this can block IO "
             "thread for a while! [file=%s]", path.get()));
       }
       file->Remove(isDir);
     }
   }
   NS_NOTREACHED("We should never get here");
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::FindTrashDirToRemove()
 {
   LOG(("CacheFileIOManager::FindTrashDirToRemove()"));
   nsresult rv;
   // We call this method on the main thread during shutdown when user wants to
   // remove all cache files.
   MOZ_ASSERT(mIOThread->IsCurrentThread() || mShuttingDown);
   nsCOMPtr<nsISimpleEnumerator> iter;
   rv = mCacheDirectory->GetDirectoryEntries(getter_AddRefs(iter));
   NS_ENSURE_SUCCESS(rv, rv);
   bool more;
   nsCOMPtr<nsISupports> elem;
   while (NS_SUCCEEDED(iter->HasMoreElements(&more)) && more) {
     rv = iter->GetNext(getter_AddRefs(elem));
     if (NS_FAILED(rv)) {
       continue;
     }
     nsCOMPtr<nsIFile> file = do_QueryInterface(elem);
     if (!file) {
       continue;
     }
     bool isDir = false;
     file->IsDirectory(&isDir);
     if (!isDir) {
       continue;
     }
     nsAutoCString leafName;
     rv = file->GetNativeLeafName(leafName);
     if (NS_FAILED(rv)) {
       continue;
     }
     if (leafName.Length() < strlen(kTrashDir)) {
       continue;
     }
     if (!StringBeginsWith(leafName, NS_LITERAL_CSTRING(kTrashDir))) {
       continue;
     }
     if (mFailedTrashDirs.Contains(leafName)) {
       continue;
     }
     LOG(("CacheFileIOManager::FindTrashDirToRemove() - Returning directory %s",
          leafName.get()));
     mTrashDir = file;
     return NS_OK;
   }
   // When we're here we've tried to delete all trash directories. Clear
   // mFailedTrashDirs so we will try to delete them again when we start removing
   // trash directories next time.
   mFailedTrashDirs.Clear();
   return NS_ERROR_NOT_AVAILABLE;
 }
 // static
 nsresult
 CacheFileIOManager::InitIndexEntry(CacheFileHandle *aHandle,
                                    uint32_t         aAppId,
                                    bool             aAnonymous,
                                    bool             aInBrowser)
 {
   LOG(("CacheFileIOManager::InitIndexEntry() [handle=%p, appId=%u, anonymous=%d"
        ", inBrowser=%d]", aHandle, aAppId, aAnonymous, aInBrowser));
   nsresult rv;
   nsRefPtr<CacheFileIOManager> ioMan = gInstance;
   if (aHandle->IsClosed() || !ioMan) {
     return NS_ERROR_NOT_INITIALIZED;
   }
   if (aHandle->IsSpecialFile()) {
     return NS_ERROR_UNEXPECTED;
   }
   nsRefPtr<InitIndexEntryEvent> ev =
     new InitIndexEntryEvent(aHandle, aAppId, aAnonymous, aInBrowser);
   rv = ioMan->mIOThread->Dispatch(ev, CacheIOThread::WRITE);
   NS_ENSURE_SUCCESS(rv, rv);
   return NS_OK;
 }
 // static
 nsresult
 CacheFileIOManager::UpdateIndexEntry(CacheFileHandle *aHandle,
                                      const uint32_t  *aFrecency,
                                      const uint32_t  *aExpirationTime)
 {
   LOG(("CacheFileIOManager::UpdateIndexEntry() [handle=%p, frecency=%s, "
        "expirationTime=%s]", aHandle,
        aFrecency ? nsPrintfCString("%u", *aFrecency).get() : "",
        aExpirationTime ? nsPrintfCString("%u", *aExpirationTime).get() : ""));
   nsresult rv;
   nsRefPtr<CacheFileIOManager> ioMan = gInstance;
   if (aHandle->IsClosed() || !ioMan) {
     return NS_ERROR_NOT_INITIALIZED;
   }
   if (aHandle->IsSpecialFile()) {
     return NS_ERROR_UNEXPECTED;
   }
   nsRefPtr<UpdateIndexEntryEvent> ev =
     new UpdateIndexEntryEvent(aHandle, aFrecency, aExpirationTime);
   rv = ioMan->mIOThread->Dispatch(ev, CacheIOThread::WRITE);
   NS_ENSURE_SUCCESS(rv, rv);
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::CreateFile(CacheFileHandle *aHandle)
 {
   MOZ_ASSERT(!aHandle->mFD);
   MOZ_ASSERT(aHandle->mFile);
   nsresult rv;
   if (aHandle->IsDoomed()) {
     nsCOMPtr<nsIFile> file;
     rv = GetDoomedFile(getter_AddRefs(file));
     NS_ENSURE_SUCCESS(rv, rv);
     aHandle->mFile.swap(file);
   } else {
     bool exists;
     if (NS_SUCCEEDED(aHandle->mFile->Exists(&exists)) && exists) {
       NS_WARNING("Found a file that should not exist!");
     }
   }
   rv = OpenNSPRHandle(aHandle, true);
   NS_ENSURE_SUCCESS(rv, rv);
   aHandle->mFileSize = 0;
   return NS_OK;
 }
 // static
 void
 CacheFileIOManager::HashToStr(const SHA1Sum::Hash *aHash, nsACString &_retval)
 {
   _retval.Assign("");
   const char hexChars[] = {'0', '1', '2', '3', '4', '5', '6', '7',
                            '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
   for (uint32_t i=0 ; i<sizeof(SHA1Sum::Hash) ; i++) {
     _retval.Append(hexChars[(*aHash)[i] >> 4]);
     _retval.Append(hexChars[(*aHash)[i] & 0xF]);
   }
 }
 // static
 nsresult
 CacheFileIOManager::StrToHash(const nsACString &aHash, SHA1Sum::Hash *_retval)
 {
   if (aHash.Length() != 2*sizeof(SHA1Sum::Hash)) {
     return NS_ERROR_INVALID_ARG;
   }
   for (uint32_t i=0 ; i<aHash.Length() ; i++) {
     uint8_t value;
     if (aHash[i] >= '0' && aHash[i] <= '9') {
       value = aHash[i] - '0';
     } else if (aHash[i] >= 'A' && aHash[i] <= 'F') {
       value = aHash[i] - 'A' + 10;
     } else if (aHash[i] >= 'a' && aHash[i] <= 'f') {
       value = aHash[i] - 'a' + 10;
     } else {
       return NS_ERROR_INVALID_ARG;
     }
     if (i%2 == 0) {
       (reinterpret_cast<uint8_t *>(_retval))[i/2] = value << 4;
     } else {
       (reinterpret_cast<uint8_t *>(_retval))[i/2] += value;
     }
   }
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::GetFile(const SHA1Sum::Hash *aHash, nsIFile **_retval)
 {
   nsresult rv;
   nsCOMPtr<nsIFile> file;
   rv = mCacheDirectory->Clone(getter_AddRefs(file));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = file->AppendNative(NS_LITERAL_CSTRING(kEntriesDir));
   NS_ENSURE_SUCCESS(rv, rv);
   nsAutoCString leafName;
   HashToStr(aHash, leafName);
   rv = file->AppendNative(leafName);
   NS_ENSURE_SUCCESS(rv, rv);
   file.swap(*_retval);
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::GetSpecialFile(const nsACString &aKey, nsIFile **_retval)
 {
   nsresult rv;
   nsCOMPtr<nsIFile> file;
   rv = mCacheDirectory->Clone(getter_AddRefs(file));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = file->AppendNative(aKey);
   NS_ENSURE_SUCCESS(rv, rv);
   file.swap(*_retval);
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::GetDoomedFile(nsIFile **_retval)
 {
   nsresult rv;
   nsCOMPtr<nsIFile> file;
   rv = mCacheDirectory->Clone(getter_AddRefs(file));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = file->AppendNative(NS_LITERAL_CSTRING(kDoomedDir));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = file->AppendNative(NS_LITERAL_CSTRING("dummyleaf"));
   NS_ENSURE_SUCCESS(rv, rv);
   srand(static_cast<unsigned>(PR_Now()));
   nsAutoCString leafName;
   uint32_t iter=0;
   while (true) {
     iter++;
     leafName.AppendInt(rand());
     rv = file->SetNativeLeafName(leafName);
     NS_ENSURE_SUCCESS(rv, rv);
     bool exists;
     if (NS_SUCCEEDED(file->Exists(&exists)) && !exists) {
       break;
     }
     leafName.Truncate();
   }
 //  Telemetry::Accumulate(Telemetry::DISK_CACHE_GETDOOMEDFILE_ITERATIONS, iter);
   file.swap(*_retval);
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::IsEmptyDirectory(nsIFile *aFile, bool *_retval)
 {
   MOZ_ASSERT(mIOThread->IsCurrentThread());
   nsresult rv;
   nsCOMPtr<nsISimpleEnumerator> enumerator;
   rv = aFile->GetDirectoryEntries(getter_AddRefs(enumerator));
   NS_ENSURE_SUCCESS(rv, rv);
   bool hasMoreElements = false;
   rv = enumerator->HasMoreElements(&hasMoreElements);
   NS_ENSURE_SUCCESS(rv, rv);
   *_retval = !hasMoreElements;
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::CheckAndCreateDir(nsIFile *aFile, const char *aDir,
                                       bool aEnsureEmptyDir)
 {
   nsresult rv;
   nsCOMPtr<nsIFile> file;
   if (!aDir) {
     file = aFile;
   } else {
     nsAutoCString dir(aDir);
     rv = aFile->Clone(getter_AddRefs(file));
     NS_ENSURE_SUCCESS(rv, rv);
     rv = file->AppendNative(dir);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   bool exists = false;
   rv = file->Exists(&exists);
   if (NS_SUCCEEDED(rv) && exists) {
     bool isDirectory = false;
     rv = file->IsDirectory(&isDirectory);
     if (NS_FAILED(rv) || !isDirectory) {
       // Try to remove the file
       rv = file->Remove(false);
       if (NS_SUCCEEDED(rv)) {
         exists = false;
       }
     }
     NS_ENSURE_SUCCESS(rv, rv);
   }
   if (aEnsureEmptyDir && NS_SUCCEEDED(rv) && exists) {
     bool isEmpty;
     rv = IsEmptyDirectory(file, &isEmpty);
     NS_ENSURE_SUCCESS(rv, rv);
     if (!isEmpty) {
       rv = TrashDirectory(file);
       NS_ENSURE_SUCCESS(rv, rv);
       exists = false;
     }
   }
   if (NS_SUCCEEDED(rv) && !exists) {
     rv = file->Create(nsIFile::DIRECTORY_TYPE, 0700);
   }
   if (NS_FAILED(rv)) {
     NS_WARNING("Cannot create directory");
     return NS_ERROR_FAILURE;
   }
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::CreateCacheTree()
 {
   MOZ_ASSERT(mIOThread->IsCurrentThread());
   MOZ_ASSERT(!mTreeCreated);
   if (!mCacheDirectory) {
     return NS_ERROR_FILE_INVALID_PATH;
   }
   nsresult rv;
   // ensure parent directory exists
   nsCOMPtr<nsIFile> parentDir;
   rv = mCacheDirectory->GetParent(getter_AddRefs(parentDir));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = CheckAndCreateDir(parentDir, nullptr, false);
   NS_ENSURE_SUCCESS(rv, rv);
   // ensure cache directory exists
   rv = CheckAndCreateDir(mCacheDirectory, nullptr, false);
   NS_ENSURE_SUCCESS(rv, rv);
   // ensure entries directory exists
   rv = CheckAndCreateDir(mCacheDirectory, kEntriesDir, false);
   NS_ENSURE_SUCCESS(rv, rv);
   // ensure doomed directory exists
   rv = CheckAndCreateDir(mCacheDirectory, kDoomedDir, true);
   NS_ENSURE_SUCCESS(rv, rv);
   mTreeCreated = true;
   if (!mContextEvictor) {
     nsRefPtr<CacheFileContextEvictor> contextEvictor;
     contextEvictor = new CacheFileContextEvictor();
     // Init() method will try to load unfinished contexts from the disk. Store
     // the evictor as a member only when there is some unfinished job.
     contextEvictor->Init(mCacheDirectory);
     if (contextEvictor->ContextsCount()) {
       contextEvictor.swap(mContextEvictor);
     }
   }
   StartRemovingTrash();
   return NS_OK;
 }
 nsresult
 CacheFileIOManager::OpenNSPRHandle(CacheFileHandle *aHandle, bool aCreate)
 {
   MOZ_ASSERT(CacheFileIOManager::IsOnIOThreadOrCeased());
   MOZ_ASSERT(!aHandle->mFD);
   MOZ_ASSERT(mHandlesByLastUsed.IndexOf(aHandle) == mHandlesByLastUsed.NoIndex);
   MOZ_ASSERT(mHandlesByLastUsed.Length() <= kOpenHandlesLimit);
   MOZ_ASSERT((aCreate && !aHandle->mFileExists) ||
              (!aCreate && aHandle->mFileExists));
   nsresult rv;
   if (mHandlesByLastUsed.Length() == kOpenHandlesLimit) {
     // close handle that hasn't been used for the longest time
     rv = ReleaseNSPRHandleInternal(mHandlesByLastUsed[0]);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   if (aCreate) {
     rv = aHandle->mFile->OpenNSPRFileDesc(
            PR_RDWR | PR_CREATE_FILE | PR_TRUNCATE, 0600, &aHandle->mFD);
     NS_ENSURE_SUCCESS(rv, rv);
     aHandle->mFileExists = true;
   } else {
     rv = aHandle->mFile->OpenNSPRFileDesc(PR_RDWR, 0600, &aHandle->mFD);
     if (NS_ERROR_FILE_NOT_FOUND == rv) {
       LOG(("  file doesn't exists"));
       aHandle->mFileExists = false;
       return DoomFileInternal(aHandle);
     }
     NS_ENSURE_SUCCESS(rv, rv);
   }
   mHandlesByLastUsed.AppendElement(aHandle);
   return NS_OK;
 }
 void
 CacheFileIOManager::NSPRHandleUsed(CacheFileHandle *aHandle)
 {
   MOZ_ASSERT(CacheFileIOManager::IsOnIOThreadOrCeased());
   MOZ_ASSERT(aHandle->mFD);
   DebugOnly<bool> found;
   found = mHandlesByLastUsed.RemoveElement(aHandle);
   MOZ_ASSERT(found);
   mHandlesByLastUsed.AppendElement(aHandle);
 }
 nsresult
 CacheFileIOManager::SyncRemoveDir(nsIFile *aFile, const char *aDir)
 {
   nsresult rv;
   nsCOMPtr<nsIFile> file;
   if (!aDir) {
     file = aFile;
   } else {
     rv = aFile->Clone(getter_AddRefs(file));
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
     rv = file->AppendNative(nsDependentCString(aDir));
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
   }
 #ifdef PR_LOGGING
   nsAutoCString path;
   file->GetNativePath(path);
 #endif
   LOG(("CacheFileIOManager::SyncRemoveDir() - Removing directory %s",
        path.get()));
   rv = file->Remove(true);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     LOG(("CacheFileIOManager::SyncRemoveDir() - Removing failed! [rv=0x%08x]",
          rv));
   }
   return rv;
 }
 void
 CacheFileIOManager::SyncRemoveAllCacheFiles()
 {
   LOG(("CacheFileIOManager::SyncRemoveAllCacheFiles()"));
   nsresult rv;
   SyncRemoveDir(mCacheDirectory, kEntriesDir);
   SyncRemoveDir(mCacheDirectory, kDoomedDir);
   // Clear any intermediate state of trash dir enumeration.
   mFailedTrashDirs.Clear();
   mTrashDir = nullptr;
   while (true) {
     // FindTrashDirToRemove() fills mTrashDir if there is any trash directory.
     rv = FindTrashDirToRemove();
     if (rv == NS_ERROR_NOT_AVAILABLE) {
       LOG(("CacheFileIOManager::SyncRemoveAllCacheFiles() - No trash directory "
            "found."));
       break;
     }
     if (NS_WARN_IF(NS_FAILED(rv))) {
       LOG(("CacheFileIOManager::SyncRemoveAllCacheFiles() - "
            "FindTrashDirToRemove() returned an unexpected error. [rv=0x%08x]",
            rv));
       break;
     }
     rv = SyncRemoveDir(mTrashDir, nullptr);
     if (NS_FAILED(rv)) {
       nsAutoCString leafName;
       mTrashDir->GetNativeLeafName(leafName);
       mFailedTrashDirs.AppendElement(leafName);
     }
   }
 }
 // Returns default ("smart") size (in KB) of cache, given available disk space
 // (also in KB)
 static uint32_t
 SmartCacheSize(const uint32_t availKB)
 {
   uint32_t maxSize = kMaxCacheSizeKB;
   if (availKB > 100 * 1024 * 1024) {
     return maxSize;  // skip computing if we're over 100 GB
   }
   // Grow/shrink in 10 MB units, deliberately, so that in the common case we
   // don't shrink cache and evict items every time we startup (it's important
   // that we don't slow down startup benchmarks).
   uint32_t sz10MBs = 0;
   uint32_t avail10MBs = availKB / (1024*10);
   // .5% of space above 25 GB
   if (avail10MBs > 2500) {
     sz10MBs += static_cast<uint32_t>((avail10MBs - 2500)*.005);
     avail10MBs = 2500;
   }
   // 1% of space between 7GB -> 25 GB
   if (avail10MBs > 700) {
     sz10MBs += static_cast<uint32_t>((avail10MBs - 700)*.01);
     avail10MBs = 700;
   }
   // 5% of space between 500 MB -> 7 GB
   if (avail10MBs > 50) {
     sz10MBs += static_cast<uint32_t>((avail10MBs - 50)*.05);
     avail10MBs = 50;
   }
 #ifdef ANDROID
   // On Android, smaller/older devices may have very little storage and
   // device owners may be sensitive to storage footprint: Use a smaller
   // percentage of available space and a smaller minimum.
   // 20% of space up to 500 MB (10 MB min)
   sz10MBs += std::max<uint32_t>(1, static_cast<uint32_t>(avail10MBs * .2));
 #else
   // 40% of space up to 500 MB (50 MB min)
   sz10MBs += std::max<uint32_t>(5, static_cast<uint32_t>(avail10MBs * .4));
 #endif
   return std::min<uint32_t>(maxSize, sz10MBs * 10 * 1024);
 }
 nsresult
 CacheFileIOManager::UpdateSmartCacheSize()
 {
   MOZ_ASSERT(mIOThread->IsCurrentThread());
   nsresult rv;
   if (!CacheObserver::UseNewCache()) {
     return NS_ERROR_NOT_AVAILABLE;
   }
   if (!CacheObserver::SmartCacheSizeEnabled()) {
     return NS_ERROR_NOT_AVAILABLE;
   }
   // Wait at least kSmartSizeUpdateInterval before recomputing smart size.
   static const TimeDuration kUpdateLimit =
     TimeDuration::FromMilliseconds(kSmartSizeUpdateInterval);
   if (!mLastSmartSizeTime.IsNull() &&
       (TimeStamp::NowLoRes() - mLastSmartSizeTime) < kUpdateLimit) {
     return NS_OK;
   }
   // Do not compute smart size when cache size is not reliable.
   bool isUpToDate = false;
   CacheIndex::IsUpToDate(&isUpToDate);
   if (!isUpToDate) {
     return NS_ERROR_NOT_AVAILABLE;
   }
   uint32_t cacheUsage;
   rv = CacheIndex::GetCacheSize(&cacheUsage);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     LOG(("CacheFileIOManager::UpdateSmartCacheSize() - Cannot get cacheUsage! "
          "[rv=0x%08x]", rv));
     return rv;
   }
   int64_t avail;
   rv = mCacheDirectory->GetDiskSpaceAvailable(&avail);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     // Do not change smart size.
     LOG(("CacheFileIOManager::UpdateSmartCacheSize() - GetDiskSpaceAvailable() "
          "failed! [rv=0x%08x]", rv));
     return rv;
   }
   mLastSmartSizeTime = TimeStamp::NowLoRes();
   uint32_t smartSize = SmartCacheSize(static_cast<uint32_t>(avail / 1024) +
                                       cacheUsage);
   if (smartSize == (CacheObserver::DiskCacheCapacity() >> 10)) {
     // Smart size has not changed.
     return NS_OK;
   }
   CacheObserver::SetDiskCacheCapacity(smartSize << 10);
   return NS_OK;
 }
 // Memory reporting
 namespace { // anon
 // A helper class that dispatches and waits for an event that gets result of
 // CacheFileIOManager->mHandles.SizeOfExcludingThis() on the I/O thread
 // to safely get handles memory report.
 // We must do this, since the handle list is only accessed and managed w/o
 // locking on the I/O thread.  That is by design.
 class SizeOfHandlesRunnable : public nsRunnable
 {
 public:
   SizeOfHandlesRunnable(mozilla::MallocSizeOf mallocSizeOf,
                         CacheFileHandles const &handles,
                         nsTArray<CacheFileHandle *> const &specialHandles)
     : mMonitor("SizeOfHandlesRunnable.mMonitor")
     , mMallocSizeOf(mallocSizeOf)
     , mHandles(handles)
     , mSpecialHandles(specialHandles)
   {
   }
   size_t Get(CacheIOThread* thread)
   {
     nsCOMPtr<nsIEventTarget> target = thread->Target();
     if (!target) {
       NS_ERROR("If we have the I/O thread we also must have the I/O target");
       return 0;
     }
     mozilla::MonitorAutoLock mon(mMonitor);
     nsresult rv = target->Dispatch(this, nsIEventTarget::DISPATCH_NORMAL);
     if (NS_FAILED(rv)) {
       NS_ERROR("Dispatch failed, cannot do memory report of CacheFileHandles");
       return 0;
     }
     mon.Wait();
     return mSize;
   }
   NS_IMETHOD Run()
   {
     mozilla::MonitorAutoLock mon(mMonitor);
     // Excluding this since the object itself is a member of CacheFileIOManager
     // reported in CacheFileIOManager::SizeOfIncludingThis as part of |this|.
     mSize = mHandles.SizeOfExcludingThis(mMallocSizeOf);
     for (uint32_t i = 0; i < mSpecialHandles.Length(); ++i) {
       mSize += mSpecialHandles[i]->SizeOfIncludingThis(mMallocSizeOf);
     }
     mon.Notify();
     return NS_OK;
   }
 private:
   mozilla::Monitor mMonitor;
   mozilla::MallocSizeOf mMallocSizeOf;
   CacheFileHandles const &mHandles;
   nsTArray<CacheFileHandle *> const &mSpecialHandles;
   size_t mSize;
 };
 } // anon
 size_t
 CacheFileIOManager::SizeOfExcludingThisInternal(mozilla::MallocSizeOf mallocSizeOf) const
 {
   size_t n = 0;
   nsCOMPtr<nsISizeOf> sizeOf;
   if (mIOThread) {
     n += mIOThread->SizeOfIncludingThis(mallocSizeOf);
     // mHandles and mSpecialHandles must be accessed only on the I/O thread,
     // must sync dispatch.
     nsRefPtr<SizeOfHandlesRunnable> sizeOfHandlesRunnable =
       new SizeOfHandlesRunnable(mallocSizeOf, mHandles, mSpecialHandles);
     n += sizeOfHandlesRunnable->Get(mIOThread);
   }
   // mHandlesByLastUsed just refers handles reported by mHandles.
   sizeOf = do_QueryInterface(mCacheDirectory);
   if (sizeOf)
     n += sizeOf->SizeOfIncludingThis(mallocSizeOf);
   sizeOf = do_QueryInterface(mMetadataWritesTimer);
   if (sizeOf)
     n += sizeOf->SizeOfIncludingThis(mallocSizeOf);
   sizeOf = do_QueryInterface(mTrashTimer);
   if (sizeOf)
     n += sizeOf->SizeOfIncludingThis(mallocSizeOf);
   sizeOf = do_QueryInterface(mTrashDir);
   if (sizeOf)
     n += sizeOf->SizeOfIncludingThis(mallocSizeOf);
   for (uint32_t i = 0; i < mFailedTrashDirs.Length(); ++i) {
     n += mFailedTrashDirs[i].SizeOfExcludingThisIfUnshared(mallocSizeOf);
   }
   return n;
 }
 // static
 size_t
 CacheFileIOManager::SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf)
 {
   if (!gInstance)
     return 0;
   return gInstance->SizeOfExcludingThisInternal(mallocSizeOf);
 }
 // static
 size_t
 CacheFileIOManager::SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf)
 {
   return mallocSizeOf(gInstance) + SizeOfExcludingThis(mallocSizeOf);
 }
 } // net
 } // mozilla

The Tor Browser / annotate

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

netwerk/cache2/CacheFileIOManager.cpp