The Tor Browser: netwerk/cache/nsCacheService.cpp@a63d609f5ebe (annotated)

netwerk/cache/nsCacheService.cpp@a63d609f5ebe (annotated)

netwerk/cache/nsCacheService.cpp

Thu, 15 Jan 2015 15:55:04 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 15 Jan 2015 15:55:04 +0100
branch: TOR_BUG_9701
changeset 9: a63d609f5ebe
permissions: -rw-r--r--

Back out 97036ab72558 which inappropriately compared turds to third parties.

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /* vim: set ts=8 sts=4 et sw=4 tw=80: */
 /* 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 "mozilla/ArrayUtils.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/Assertions.h"
 #include "mozilla/DebugOnly.h"
 #include "necko-config.h"
 #include "nsCache.h"
 #include "nsCacheService.h"
 #include "nsCacheRequest.h"
 #include "nsCacheEntry.h"
 #include "nsCacheEntryDescriptor.h"
 #include "nsCacheDevice.h"
 #include "nsMemoryCacheDevice.h"
 #include "nsICacheVisitor.h"
 #include "nsDiskCacheDevice.h"
 #include "nsDiskCacheDeviceSQL.h"
 #include "nsCacheUtils.h"
 #include "../cache2/CacheObserver.h"
 #include "nsIObserverService.h"
 #include "nsIPrefService.h"
 #include "nsIPrefBranch.h"
 #include "nsIFile.h"
 #include "nsIOService.h"
 #include "nsDirectoryServiceDefs.h"
 #include "nsAppDirectoryServiceDefs.h"
 #include "nsThreadUtils.h"
 #include "nsProxyRelease.h"
 #include "nsVoidArray.h"
 #include "nsDeleteDir.h"
 #include "nsNetCID.h"
 #include <math.h>  // for log()
 #include "mozilla/Services.h"
 #include "nsITimer.h"
 #include "mozIStorageService.h"
 #include "mozilla/net/NeckoCommon.h"
 #include "mozilla/VisualEventTracer.h"
 #include <algorithm>
 using namespace mozilla;
 /******************************************************************************
  * nsCacheProfilePrefObserver
  *****************************************************************************/
 #define DISK_CACHE_ENABLE_PREF      "browser.cache.disk.enable"
 #define DISK_CACHE_DIR_PREF         "browser.cache.disk.parent_directory"
 #define DISK_CACHE_SMART_SIZE_FIRST_RUN_PREF\
     "browser.cache.disk.smart_size.first_run"
 #define DISK_CACHE_SMART_SIZE_ENABLED_PREF \
     "browser.cache.disk.smart_size.enabled"
 #define DISK_CACHE_SMART_SIZE_PREF "browser.cache.disk.smart_size_cached_value"
 #define DISK_CACHE_CAPACITY_PREF    "browser.cache.disk.capacity"
 #define DISK_CACHE_MAX_ENTRY_SIZE_PREF "browser.cache.disk.max_entry_size"
 #define DISK_CACHE_CAPACITY         256000
 #define DISK_CACHE_USE_OLD_MAX_SMART_SIZE_PREF \
     "browser.cache.disk.smart_size.use_old_max"
 #define OFFLINE_CACHE_ENABLE_PREF   "browser.cache.offline.enable"
 #define OFFLINE_CACHE_DIR_PREF      "browser.cache.offline.parent_directory"
 #define OFFLINE_CACHE_CAPACITY_PREF "browser.cache.offline.capacity"
 #define OFFLINE_CACHE_CAPACITY      512000
 #define MEMORY_CACHE_ENABLE_PREF    "browser.cache.memory.enable"
 #define MEMORY_CACHE_CAPACITY_PREF  "browser.cache.memory.capacity"
 #define MEMORY_CACHE_MAX_ENTRY_SIZE_PREF "browser.cache.memory.max_entry_size"
 #define CACHE_COMPRESSION_LEVEL_PREF "browser.cache.compression_level"
 #define CACHE_COMPRESSION_LEVEL     1
 #define SANITIZE_ON_SHUTDOWN_PREF   "privacy.sanitize.sanitizeOnShutdown"
 #define CLEAR_ON_SHUTDOWN_PREF      "privacy.clearOnShutdown.cache"
 static const char * observerList[] = {
     "profile-before-change",
     "profile-do-change",
     NS_XPCOM_SHUTDOWN_OBSERVER_ID,
     "last-pb-context-exited",
     "suspend_process_notification",
     "resume_process_notification"
 };
 static const char * prefList[] = {
     DISK_CACHE_ENABLE_PREF,
     DISK_CACHE_SMART_SIZE_ENABLED_PREF,
     DISK_CACHE_CAPACITY_PREF,
     DISK_CACHE_DIR_PREF,
     DISK_CACHE_MAX_ENTRY_SIZE_PREF,
     DISK_CACHE_USE_OLD_MAX_SMART_SIZE_PREF,
     OFFLINE_CACHE_ENABLE_PREF,
     OFFLINE_CACHE_CAPACITY_PREF,
     OFFLINE_CACHE_DIR_PREF,
     MEMORY_CACHE_ENABLE_PREF,
     MEMORY_CACHE_CAPACITY_PREF,
     MEMORY_CACHE_MAX_ENTRY_SIZE_PREF,
     CACHE_COMPRESSION_LEVEL_PREF,
     SANITIZE_ON_SHUTDOWN_PREF,
     CLEAR_ON_SHUTDOWN_PREF
 };
 // Cache sizes, in KB
 const int32_t DEFAULT_CACHE_SIZE = 250 * 1024;  // 250 MB
 #ifdef ANDROID
 const int32_t MAX_CACHE_SIZE = 200 * 1024;      // 200 MB
 const int32_t OLD_MAX_CACHE_SIZE = 200 * 1024;  // 200 MB
 #else
 const int32_t MAX_CACHE_SIZE = 350 * 1024;      // 350 MB
 const int32_t OLD_MAX_CACHE_SIZE = 1024 * 1024; //   1 GB
 #endif
 // Default cache size was 50 MB for many years until FF 4:
 const int32_t PRE_GECKO_2_0_DEFAULT_CACHE_SIZE = 50 * 1024;
 class nsCacheProfilePrefObserver : public nsIObserver
 {
 public:
     NS_DECL_THREADSAFE_ISUPPORTS
     NS_DECL_NSIOBSERVER
     nsCacheProfilePrefObserver()
         : mHaveProfile(false)
         , mDiskCacheEnabled(false)
         , mDiskCacheCapacity(0)
         , mDiskCacheMaxEntrySize(-1) // -1 means "no limit"
         , mSmartSizeEnabled(false)
         , mShouldUseOldMaxSmartSize(false)
         , mOfflineCacheEnabled(false)
         , mOfflineCacheCapacity(0)
         , mMemoryCacheEnabled(true)
         , mMemoryCacheCapacity(-1)
         , mMemoryCacheMaxEntrySize(-1) // -1 means "no limit"
         , mCacheCompressionLevel(CACHE_COMPRESSION_LEVEL)
         , mSanitizeOnShutdown(false)
         , mClearCacheOnShutdown(false)
     {
     }
     virtual ~nsCacheProfilePrefObserver() {}
     nsresult        Install();
     void            Remove();
     nsresult        ReadPrefs(nsIPrefBranch* branch);
     bool            DiskCacheEnabled();
     int32_t         DiskCacheCapacity()         { return mDiskCacheCapacity; }
     void            SetDiskCacheCapacity(int32_t);
     int32_t         DiskCacheMaxEntrySize()     { return mDiskCacheMaxEntrySize; }
     nsIFile *       DiskCacheParentDirectory()  { return mDiskCacheParentDirectory; }
     bool            SmartSizeEnabled()          { return mSmartSizeEnabled; }
     bool            ShouldUseOldMaxSmartSize()        { return mShouldUseOldMaxSmartSize; }
     void            SetUseNewMaxSmartSize(bool useNew)     { mShouldUseOldMaxSmartSize = !useNew; }
     bool            OfflineCacheEnabled();
     int32_t         OfflineCacheCapacity()         { return mOfflineCacheCapacity; }
     nsIFile *       OfflineCacheParentDirectory()  { return mOfflineCacheParentDirectory; }
     bool            MemoryCacheEnabled();
     int32_t         MemoryCacheCapacity();
     int32_t         MemoryCacheMaxEntrySize()     { return mMemoryCacheMaxEntrySize; }
     int32_t         CacheCompressionLevel();
     bool            SanitizeAtShutdown() { return mSanitizeOnShutdown && mClearCacheOnShutdown; }
     static uint32_t GetSmartCacheSize(const nsAString& cachePath,
                                       uint32_t currentSize,
                                       bool shouldUseOldMaxSmartSize);
     bool                    PermittedToSmartSize(nsIPrefBranch*, bool firstRun);
 private:
     bool                    mHaveProfile;
     bool                    mDiskCacheEnabled;
     int32_t                 mDiskCacheCapacity; // in kilobytes
     int32_t                 mDiskCacheMaxEntrySize; // in kilobytes
     nsCOMPtr<nsIFile>       mDiskCacheParentDirectory;
     bool                    mSmartSizeEnabled;
     bool                    mShouldUseOldMaxSmartSize;
     bool                    mOfflineCacheEnabled;
     int32_t                 mOfflineCacheCapacity; // in kilobytes
     nsCOMPtr<nsIFile>       mOfflineCacheParentDirectory;
     bool                    mMemoryCacheEnabled;
     int32_t                 mMemoryCacheCapacity; // in kilobytes
     int32_t                 mMemoryCacheMaxEntrySize; // in kilobytes
     int32_t                 mCacheCompressionLevel;
     bool                    mSanitizeOnShutdown;
     bool                    mClearCacheOnShutdown;
 };
 NS_IMPL_ISUPPORTS(nsCacheProfilePrefObserver, nsIObserver)
 class nsSetDiskSmartSizeCallback MOZ_FINAL : public nsITimerCallback
 {
 public:
     NS_DECL_THREADSAFE_ISUPPORTS
     NS_IMETHOD Notify(nsITimer* aTimer) {
         if (nsCacheService::gService) {
             nsCacheServiceAutoLock autoLock(LOCK_TELEM(NSSETDISKSMARTSIZECALLBACK_NOTIFY));
             nsCacheService::gService->SetDiskSmartSize_Locked();
             nsCacheService::gService->mSmartSizeTimer = nullptr;
         }
         return NS_OK;
     }
 };
 NS_IMPL_ISUPPORTS(nsSetDiskSmartSizeCallback, nsITimerCallback)
 // Runnable sent to main thread after the cache IO thread calculates available
 // disk space, so that there is no race in setting mDiskCacheCapacity.
 class nsSetSmartSizeEvent: public nsRunnable
 {
 public:
     nsSetSmartSizeEvent(int32_t smartSize)
         : mSmartSize(smartSize) {}
     NS_IMETHOD Run()
     {
         NS_ASSERTION(NS_IsMainThread(),
                      "Setting smart size data off the main thread");
         // Main thread may have already called nsCacheService::Shutdown
         if (!nsCacheService::IsInitialized())
             return NS_ERROR_NOT_AVAILABLE;
         // Ensure smart sizing wasn't switched off while event was pending.
         // It is safe to access the observer without the lock since we are
         // on the main thread and the value changes only on the main thread.
         if (!nsCacheService::gService->mObserver->SmartSizeEnabled())
             return NS_OK;
         nsCacheService::SetDiskCacheCapacity(mSmartSize);
         nsCOMPtr<nsIPrefBranch> ps = do_GetService(NS_PREFSERVICE_CONTRACTID);
         if (!ps ||
             NS_FAILED(ps->SetIntPref(DISK_CACHE_SMART_SIZE_PREF, mSmartSize)))
             NS_WARNING("Failed to set smart size pref");
         return NS_OK;
     }
 private:
     int32_t mSmartSize;
 };
 // Runnable sent from main thread to cacheIO thread
 class nsGetSmartSizeEvent: public nsRunnable
 {
 public:
     nsGetSmartSizeEvent(const nsAString& cachePath, uint32_t currentSize,
                         bool shouldUseOldMaxSmartSize)
       : mCachePath(cachePath)
       , mCurrentSize(currentSize)
       , mShouldUseOldMaxSmartSize(shouldUseOldMaxSmartSize)
     {}
     // Calculates user's disk space available on a background thread and
     // dispatches this value back to the main thread.
     NS_IMETHOD Run()
     {
         uint32_t size;
         size = nsCacheProfilePrefObserver::GetSmartCacheSize(mCachePath,
                                                              mCurrentSize,
                                                              mShouldUseOldMaxSmartSize);
         NS_DispatchToMainThread(new nsSetSmartSizeEvent(size));
         return NS_OK;
     }
 private:
     nsString mCachePath;
     uint32_t mCurrentSize;
     bool     mShouldUseOldMaxSmartSize;
 };
 class nsBlockOnCacheThreadEvent : public nsRunnable {
 public:
     nsBlockOnCacheThreadEvent()
     {
     }
     NS_IMETHOD Run()
     {
         nsCacheServiceAutoLock autoLock(LOCK_TELEM(NSBLOCKONCACHETHREADEVENT_RUN));
 #ifdef PR_LOGGING
         CACHE_LOG_DEBUG(("nsBlockOnCacheThreadEvent [%p]\n", this));
 #endif
         nsCacheService::gService->mCondVar.Notify();
         return NS_OK;
     }
 };
 nsresult
 nsCacheProfilePrefObserver::Install()
 {
     // install profile-change observer
     nsCOMPtr<nsIObserverService> observerService =
         mozilla::services::GetObserverService();
     if (!observerService)
         return NS_ERROR_FAILURE;
     nsresult rv, rv2 = NS_OK;
     for (unsigned int i=0; i<ArrayLength(observerList); i++) {
         rv = observerService->AddObserver(this, observerList[i], false);
         if (NS_FAILED(rv))
             rv2 = rv;
     }
     // install preferences observer
     nsCOMPtr<nsIPrefBranch> branch = do_GetService(NS_PREFSERVICE_CONTRACTID);
     if (!branch) return NS_ERROR_FAILURE;
     for (unsigned int i=0; i<ArrayLength(prefList); i++) {
         rv = branch->AddObserver(prefList[i], this, false);
         if (NS_FAILED(rv))
             rv2 = rv;
     }
     // Determine if we have a profile already
     //     Install() is called *after* the profile-after-change notification
     //     when there is only a single profile, or it is specified on the
     //     commandline at startup.
     //     In that case, we detect the presence of a profile by the existence
     //     of the NS_APP_USER_PROFILE_50_DIR directory.
     nsCOMPtr<nsIFile> directory;
     rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR,
                                 getter_AddRefs(directory));
     if (NS_SUCCEEDED(rv))
         mHaveProfile = true;
     rv = ReadPrefs(branch);
     NS_ENSURE_SUCCESS(rv, rv);
     return rv2;
 }
 void
 nsCacheProfilePrefObserver::Remove()
 {
     // remove Observer Service observers
     nsCOMPtr<nsIObserverService> obs =
         mozilla::services::GetObserverService();
     if (obs) {
         for (unsigned int i=0; i<ArrayLength(observerList); i++) {
             obs->RemoveObserver(this, observerList[i]);
         }
     }
     // remove Pref Service observers
     nsCOMPtr<nsIPrefBranch> prefs =
         do_GetService(NS_PREFSERVICE_CONTRACTID);
     if (!prefs)
         return;
     for (unsigned int i=0; i<ArrayLength(prefList); i++)
         prefs->RemoveObserver(prefList[i], this); // remove cache pref observers
 }
 void
 nsCacheProfilePrefObserver::SetDiskCacheCapacity(int32_t capacity)
 {
     mDiskCacheCapacity = std::max(0, capacity);
 }
 NS_IMETHODIMP
 nsCacheProfilePrefObserver::Observe(nsISupports *     subject,
                                     const char *      topic,
                                     const char16_t * data_unicode)
 {
     nsresult rv;
     NS_ConvertUTF16toUTF8 data(data_unicode);
     CACHE_LOG_ALWAYS(("Observe [topic=%s data=%s]\n", topic, data.get()));
     if (!nsCacheService::IsInitialized()) {
         if (!strcmp("resume_process_notification", topic)) {
             // A suspended process has a closed cache, so re-open it here.
             nsCacheService::GlobalInstance()->Init();
         }
         return NS_OK;
     }
     if (!strcmp(NS_XPCOM_SHUTDOWN_OBSERVER_ID, topic)) {
         // xpcom going away, shutdown cache service
         nsCacheService::GlobalInstance()->Shutdown();
     } else if (!strcmp("profile-before-change", topic)) {
         // profile before change
         mHaveProfile = false;
         // XXX shutdown devices
         nsCacheService::OnProfileShutdown(!strcmp("shutdown-cleanse",
                                                   data.get()));
     } else if (!strcmp("suspend_process_notification", topic)) {
         // A suspended process may never return, so shutdown the cache to reduce
         // cache corruption.
         nsCacheService::GlobalInstance()->Shutdown();
     } else if (!strcmp("profile-do-change", topic)) {
         // profile after change
         mHaveProfile = true;
         nsCOMPtr<nsIPrefBranch> branch = do_GetService(NS_PREFSERVICE_CONTRACTID);
         ReadPrefs(branch);
         nsCacheService::OnProfileChanged();
     } else if (!strcmp(NS_PREFBRANCH_PREFCHANGE_TOPIC_ID, topic)) {
         // ignore pref changes until we're done switch profiles
         if (!mHaveProfile)
             return NS_OK;
         nsCOMPtr<nsIPrefBranch> branch = do_QueryInterface(subject, &rv);
         if (NS_FAILED(rv))
             return rv;
         // which preference changed?
         if (!strcmp(DISK_CACHE_ENABLE_PREF, data.get())) {
             rv = branch->GetBoolPref(DISK_CACHE_ENABLE_PREF,
                                      &mDiskCacheEnabled);
             if (NS_FAILED(rv))
                 return rv;
             nsCacheService::SetDiskCacheEnabled(DiskCacheEnabled());
         } else if (!strcmp(DISK_CACHE_CAPACITY_PREF, data.get())) {
             int32_t capacity = 0;
             rv = branch->GetIntPref(DISK_CACHE_CAPACITY_PREF, &capacity);
             if (NS_FAILED(rv))
                 return rv;
             mDiskCacheCapacity = std::max(0, capacity);
             nsCacheService::SetDiskCacheCapacity(mDiskCacheCapacity);
         // Update the cache capacity when smart sizing is turned on/off
         } else if (!strcmp(DISK_CACHE_SMART_SIZE_ENABLED_PREF, data.get())) {
             // Is the update because smartsizing was turned on, or off?
             rv = branch->GetBoolPref(DISK_CACHE_SMART_SIZE_ENABLED_PREF,
                                      &mSmartSizeEnabled);
             if (NS_FAILED(rv))
                 return rv;
             int32_t newCapacity = 0;
             if (mSmartSizeEnabled) {
                 nsCacheService::SetDiskSmartSize();
             } else {
                 // Smart sizing switched off: use user specified size
                 rv = branch->GetIntPref(DISK_CACHE_CAPACITY_PREF, &newCapacity);
                 if (NS_FAILED(rv))
                     return rv;
                 mDiskCacheCapacity = std::max(0, newCapacity);
                 nsCacheService::SetDiskCacheCapacity(mDiskCacheCapacity);
             }
         } else if (!strcmp(DISK_CACHE_USE_OLD_MAX_SMART_SIZE_PREF, data.get())) {
             rv = branch->GetBoolPref(DISK_CACHE_USE_OLD_MAX_SMART_SIZE_PREF,
                                      &mShouldUseOldMaxSmartSize);
             if (NS_FAILED(rv))
                 return rv;
         } else if (!strcmp(DISK_CACHE_MAX_ENTRY_SIZE_PREF, data.get())) {
             int32_t newMaxSize;
             rv = branch->GetIntPref(DISK_CACHE_MAX_ENTRY_SIZE_PREF,
                                     &newMaxSize);
             if (NS_FAILED(rv))
                 return rv;
             mDiskCacheMaxEntrySize = std::max(-1, newMaxSize);
             nsCacheService::SetDiskCacheMaxEntrySize(mDiskCacheMaxEntrySize);
 #if 0
         } else if (!strcmp(DISK_CACHE_DIR_PREF, data.get())) {
             // XXX We probaby don't want to respond to this pref except after
             // XXX profile changes.  Ideally, there should be somekind of user
             // XXX notification that the pref change won't take effect until
             // XXX the next time the profile changes (browser launch)
 #endif
         } else
         // which preference changed?
         if (!strcmp(OFFLINE_CACHE_ENABLE_PREF, data.get())) {
             rv = branch->GetBoolPref(OFFLINE_CACHE_ENABLE_PREF,
                                      &mOfflineCacheEnabled);
             if (NS_FAILED(rv))  return rv;
             nsCacheService::SetOfflineCacheEnabled(OfflineCacheEnabled());
         } else if (!strcmp(OFFLINE_CACHE_CAPACITY_PREF, data.get())) {
             int32_t capacity = 0;
             rv = branch->GetIntPref(OFFLINE_CACHE_CAPACITY_PREF, &capacity);
             if (NS_FAILED(rv))  return rv;
             mOfflineCacheCapacity = std::max(0, capacity);
             nsCacheService::SetOfflineCacheCapacity(mOfflineCacheCapacity);
 #if 0
         } else if (!strcmp(OFFLINE_CACHE_DIR_PREF, data.get())) {
             // XXX We probaby don't want to respond to this pref except after
             // XXX profile changes.  Ideally, there should be some kind of user
             // XXX notification that the pref change won't take effect until
             // XXX the next time the profile changes (browser launch)
 #endif
         } else
         if (!strcmp(MEMORY_CACHE_ENABLE_PREF, data.get())) {
             rv = branch->GetBoolPref(MEMORY_CACHE_ENABLE_PREF,
                                      &mMemoryCacheEnabled);
             if (NS_FAILED(rv))
                 return rv;
             nsCacheService::SetMemoryCache();
         } else if (!strcmp(MEMORY_CACHE_CAPACITY_PREF, data.get())) {
             mMemoryCacheCapacity = -1;
             (void) branch->GetIntPref(MEMORY_CACHE_CAPACITY_PREF,
                                       &mMemoryCacheCapacity);
             nsCacheService::SetMemoryCache();
         } else if (!strcmp(MEMORY_CACHE_MAX_ENTRY_SIZE_PREF, data.get())) {
             int32_t newMaxSize;
             rv = branch->GetIntPref(MEMORY_CACHE_MAX_ENTRY_SIZE_PREF,
                                      &newMaxSize);
             if (NS_FAILED(rv))
                 return rv;
             mMemoryCacheMaxEntrySize = std::max(-1, newMaxSize);
             nsCacheService::SetMemoryCacheMaxEntrySize(mMemoryCacheMaxEntrySize);
         } else if (!strcmp(CACHE_COMPRESSION_LEVEL_PREF, data.get())) {
             mCacheCompressionLevel = CACHE_COMPRESSION_LEVEL;
             (void)branch->GetIntPref(CACHE_COMPRESSION_LEVEL_PREF,
                                      &mCacheCompressionLevel);
             mCacheCompressionLevel = std::max(0, mCacheCompressionLevel);
             mCacheCompressionLevel = std::min(9, mCacheCompressionLevel);
         } else if (!strcmp(SANITIZE_ON_SHUTDOWN_PREF, data.get())) {
             rv = branch->GetBoolPref(SANITIZE_ON_SHUTDOWN_PREF,
                                      &mSanitizeOnShutdown);
             if (NS_FAILED(rv))
                 return rv;
             nsCacheService::SetDiskCacheEnabled(DiskCacheEnabled());
         } else if (!strcmp(CLEAR_ON_SHUTDOWN_PREF, data.get())) {
             rv = branch->GetBoolPref(CLEAR_ON_SHUTDOWN_PREF,
                                      &mClearCacheOnShutdown);
             if (NS_FAILED(rv))
                 return rv;
             nsCacheService::SetDiskCacheEnabled(DiskCacheEnabled());
         }
     } else if (!strcmp("last-pb-context-exited", topic)) {
         nsCacheService::LeavePrivateBrowsing();
     }
     return NS_OK;
 }
 // Returns default ("smart") size (in KB) of cache, given available disk space
 // (also in KB)
 static uint32_t
 SmartCacheSize(const uint32_t availKB, bool shouldUseOldMaxSmartSize)
 {
     uint32_t maxSize = shouldUseOldMaxSmartSize ? OLD_MAX_CACHE_SIZE : MAX_CACHE_SIZE;
     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);
 }
  /* Computes our best guess for the default size of the user's disk cache,
   * based on the amount of space they have free on their hard drive.
   * We use a tiered scheme: the more space available,
   * the larger the disk cache will be. However, we do not want
   * to enable the disk cache to grow to an unbounded size, so the larger the
   * user's available space is, the smaller of a percentage we take. We set a
   * lower bound of 50MB and an upper bound of 1GB.
   *
   *@param:  None.
   *@return: The size that the user's disk cache should default to, in kBytes.
   */
 uint32_t
 nsCacheProfilePrefObserver::GetSmartCacheSize(const nsAString& cachePath,
                                               uint32_t currentSize,
                                               bool shouldUseOldMaxSmartSize)
 {
     // Check for free space on device where cache directory lives
     nsresult rv;
     nsCOMPtr<nsIFile>
         cacheDirectory (do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv));
     if (NS_FAILED(rv) || !cacheDirectory)
         return DEFAULT_CACHE_SIZE;
     rv = cacheDirectory->InitWithPath(cachePath);
     if (NS_FAILED(rv))
         return DEFAULT_CACHE_SIZE;
     int64_t bytesAvailable;
     rv = cacheDirectory->GetDiskSpaceAvailable(&bytesAvailable);
     if (NS_FAILED(rv))
         return DEFAULT_CACHE_SIZE;
     return SmartCacheSize(static_cast<uint32_t>((bytesAvailable / 1024) +
                                                 currentSize),
                           shouldUseOldMaxSmartSize);
 }
 /* Determine if we are permitted to dynamically size the user's disk cache based
  * on their disk space available. We may do this so long as the pref
  * smart_size.enabled is true.
  */
 bool
 nsCacheProfilePrefObserver::PermittedToSmartSize(nsIPrefBranch* branch, bool
                                                  firstRun)
 {
     nsresult rv;
     if (firstRun) {
         // check if user has set cache size in the past
         bool userSet;
         rv = branch->PrefHasUserValue(DISK_CACHE_CAPACITY_PREF, &userSet);
         if (NS_FAILED(rv)) userSet = true;
         if (userSet) {
             int32_t oldCapacity;
             // If user explicitly set cache size to be smaller than old default
             // of 50 MB, then keep user's value. Otherwise use smart sizing.
             rv = branch->GetIntPref(DISK_CACHE_CAPACITY_PREF, &oldCapacity);
             if (oldCapacity < PRE_GECKO_2_0_DEFAULT_CACHE_SIZE) {
                 mSmartSizeEnabled = false;
                 branch->SetBoolPref(DISK_CACHE_SMART_SIZE_ENABLED_PREF,
                                     mSmartSizeEnabled);
                 return mSmartSizeEnabled;
             }
         }
         // Set manual setting to MAX cache size as starting val for any
         // adjustment by user: (bug 559942 comment 65)
         int32_t maxSize = mShouldUseOldMaxSmartSize ? OLD_MAX_CACHE_SIZE : MAX_CACHE_SIZE;
         branch->SetIntPref(DISK_CACHE_CAPACITY_PREF, maxSize);
     }
     rv = branch->GetBoolPref(DISK_CACHE_SMART_SIZE_ENABLED_PREF,
                              &mSmartSizeEnabled);
     if (NS_FAILED(rv))
         mSmartSizeEnabled = false;
     return mSmartSizeEnabled;
 }
 nsresult
 nsCacheProfilePrefObserver::ReadPrefs(nsIPrefBranch* branch)
 {
     nsresult rv = NS_OK;
     // read disk cache device prefs
     mDiskCacheEnabled = true;  // presume disk cache is enabled
     (void) branch->GetBoolPref(DISK_CACHE_ENABLE_PREF, &mDiskCacheEnabled);
     mDiskCacheCapacity = DISK_CACHE_CAPACITY;
     (void)branch->GetIntPref(DISK_CACHE_CAPACITY_PREF, &mDiskCacheCapacity);
     mDiskCacheCapacity = std::max(0, mDiskCacheCapacity);
     (void) branch->GetIntPref(DISK_CACHE_MAX_ENTRY_SIZE_PREF,
                               &mDiskCacheMaxEntrySize);
     mDiskCacheMaxEntrySize = std::max(-1, mDiskCacheMaxEntrySize);
     (void) branch->GetComplexValue(DISK_CACHE_DIR_PREF,     // ignore error
                                    NS_GET_IID(nsIFile),
                                    getter_AddRefs(mDiskCacheParentDirectory));
     (void) branch->GetBoolPref(DISK_CACHE_USE_OLD_MAX_SMART_SIZE_PREF,
                                &mShouldUseOldMaxSmartSize);
     if (!mDiskCacheParentDirectory) {
         nsCOMPtr<nsIFile>  directory;
         // try to get the disk cache parent directory
         rv = NS_GetSpecialDirectory(NS_APP_CACHE_PARENT_DIR,
                                     getter_AddRefs(directory));
         if (NS_FAILED(rv)) {
             // try to get the profile directory (there may not be a profile yet)
             nsCOMPtr<nsIFile> profDir;
             NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR,
                                    getter_AddRefs(profDir));
             NS_GetSpecialDirectory(NS_APP_USER_PROFILE_LOCAL_50_DIR,
                                    getter_AddRefs(directory));
             if (!directory)
                 directory = profDir;
             else if (profDir) {
                 nsCacheService::MoveOrRemoveDiskCache(profDir, directory,
                                                       "Cache");
             }
         }
         // use file cache in build tree only if asked, to avoid cache dir litter
         if (!directory && PR_GetEnv("NECKO_DEV_ENABLE_DISK_CACHE")) {
             rv = NS_GetSpecialDirectory(NS_XPCOM_CURRENT_PROCESS_DIR,
                                         getter_AddRefs(directory));
         }
         if (directory)
             mDiskCacheParentDirectory = do_QueryInterface(directory, &rv);
     }
     if (mDiskCacheParentDirectory) {
         bool firstSmartSizeRun;
         rv = branch->GetBoolPref(DISK_CACHE_SMART_SIZE_FIRST_RUN_PREF,
                                  &firstSmartSizeRun);
         if (NS_FAILED(rv))
             firstSmartSizeRun = false;
         if (PermittedToSmartSize(branch, firstSmartSizeRun)) {
             // Avoid evictions: use previous cache size until smart size event
             // updates mDiskCacheCapacity
             rv = branch->GetIntPref(firstSmartSizeRun ?
                                     DISK_CACHE_CAPACITY_PREF :
                                     DISK_CACHE_SMART_SIZE_PREF,
                                     &mDiskCacheCapacity);
             if (NS_FAILED(rv))
                 mDiskCacheCapacity = DEFAULT_CACHE_SIZE;
         }
         if (firstSmartSizeRun) {
             // It is no longer our first run
             rv = branch->SetBoolPref(DISK_CACHE_SMART_SIZE_FIRST_RUN_PREF,
                                      false);
             if (NS_FAILED(rv))
                 NS_WARNING("Failed setting first_run pref in ReadPrefs.");
         }
     }
     // read offline cache device prefs
     mOfflineCacheEnabled = true;  // presume offline cache is enabled
     (void) branch->GetBoolPref(OFFLINE_CACHE_ENABLE_PREF,
                               &mOfflineCacheEnabled);
     mOfflineCacheCapacity = OFFLINE_CACHE_CAPACITY;
     (void)branch->GetIntPref(OFFLINE_CACHE_CAPACITY_PREF,
                              &mOfflineCacheCapacity);
     mOfflineCacheCapacity = std::max(0, mOfflineCacheCapacity);
     (void) branch->GetComplexValue(OFFLINE_CACHE_DIR_PREF,     // ignore error
                                    NS_GET_IID(nsIFile),
                                    getter_AddRefs(mOfflineCacheParentDirectory));
     if (!mOfflineCacheParentDirectory) {
         nsCOMPtr<nsIFile>  directory;
         // try to get the offline cache parent directory
         rv = NS_GetSpecialDirectory(NS_APP_CACHE_PARENT_DIR,
                                     getter_AddRefs(directory));
         if (NS_FAILED(rv)) {
             // try to get the profile directory (there may not be a profile yet)
             nsCOMPtr<nsIFile> profDir;
             NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR,
                                    getter_AddRefs(profDir));
             NS_GetSpecialDirectory(NS_APP_USER_PROFILE_LOCAL_50_DIR,
                                    getter_AddRefs(directory));
             if (!directory)
                 directory = profDir;
             else if (profDir) {
                 nsCacheService::MoveOrRemoveDiskCache(profDir, directory,
                                                       "OfflineCache");
             }
         }
 #if DEBUG
         if (!directory) {
             // use current process directory during development
             rv = NS_GetSpecialDirectory(NS_XPCOM_CURRENT_PROCESS_DIR,
                                         getter_AddRefs(directory));
         }
 #endif
         if (directory)
             mOfflineCacheParentDirectory = do_QueryInterface(directory, &rv);
     }
     // read memory cache device prefs
     (void) branch->GetBoolPref(MEMORY_CACHE_ENABLE_PREF, &mMemoryCacheEnabled);
     mMemoryCacheCapacity = -1;
     (void) branch->GetIntPref(MEMORY_CACHE_CAPACITY_PREF,
                               &mMemoryCacheCapacity);
     (void) branch->GetIntPref(MEMORY_CACHE_MAX_ENTRY_SIZE_PREF,
                               &mMemoryCacheMaxEntrySize);
     mMemoryCacheMaxEntrySize = std::max(-1, mMemoryCacheMaxEntrySize);
     // read cache compression level pref
     mCacheCompressionLevel = CACHE_COMPRESSION_LEVEL;
     (void)branch->GetIntPref(CACHE_COMPRESSION_LEVEL_PREF,
                              &mCacheCompressionLevel);
     mCacheCompressionLevel = std::max(0, mCacheCompressionLevel);
     mCacheCompressionLevel = std::min(9, mCacheCompressionLevel);
     // read cache shutdown sanitization prefs
     (void) branch->GetBoolPref(SANITIZE_ON_SHUTDOWN_PREF,
                                &mSanitizeOnShutdown);
     (void) branch->GetBoolPref(CLEAR_ON_SHUTDOWN_PREF,
                                &mClearCacheOnShutdown);
     return rv;
 }
 nsresult
 nsCacheService::DispatchToCacheIOThread(nsIRunnable* event)
 {
     if (!gService->mCacheIOThread) return NS_ERROR_NOT_AVAILABLE;
     return gService->mCacheIOThread->Dispatch(event, NS_DISPATCH_NORMAL);
 }
 nsresult
 nsCacheService::SyncWithCacheIOThread()
 {
     gService->mLock.AssertCurrentThreadOwns();
     if (!gService->mCacheIOThread) return NS_ERROR_NOT_AVAILABLE;
     nsCOMPtr<nsIRunnable> event = new nsBlockOnCacheThreadEvent();
     // dispatch event - it will notify the monitor when it's done
     nsresult rv =
         gService->mCacheIOThread->Dispatch(event, NS_DISPATCH_NORMAL);
     if (NS_FAILED(rv)) {
         NS_WARNING("Failed dispatching block-event");
         return NS_ERROR_UNEXPECTED;
     }
     // wait until notified, then return
     rv = gService->mCondVar.Wait();
     return rv;
 }
 bool
 nsCacheProfilePrefObserver::DiskCacheEnabled()
 {
     if ((mDiskCacheCapacity == 0) || (!mDiskCacheParentDirectory))  return false;
     return mDiskCacheEnabled && (!mSanitizeOnShutdown || !mClearCacheOnShutdown);
 }
 bool
 nsCacheProfilePrefObserver::OfflineCacheEnabled()
 {
     if ((mOfflineCacheCapacity == 0) || (!mOfflineCacheParentDirectory))
         return false;
     return mOfflineCacheEnabled;
 }
 bool
 nsCacheProfilePrefObserver::MemoryCacheEnabled()
 {
     if (mMemoryCacheCapacity == 0)  return false;
     return mMemoryCacheEnabled;
 }
 /**
  * MemoryCacheCapacity
  *
  * If the browser.cache.memory.capacity preference is positive, we use that
  * value for the amount of memory available for the cache.
  *
  * If browser.cache.memory.capacity is zero, the memory cache is disabled.
  *
  * If browser.cache.memory.capacity is negative or not present, we use a
  * formula that grows less than linearly with the amount of system memory,
  * with an upper limit on the cache size. No matter how much physical RAM is
  * present, the default cache size would not exceed 32 MB. This maximum would
  * apply only to systems with more than 4 GB of RAM (e.g. terminal servers)
  *
  *   RAM   Cache
  *   ---   -----
  *   32 Mb   2 Mb
  *   64 Mb   4 Mb
  *  128 Mb   6 Mb
  *  256 Mb  10 Mb
  *  512 Mb  14 Mb
  * 1024 Mb  18 Mb
  * 2048 Mb  24 Mb
  * 4096 Mb  30 Mb
  *
  * The equation for this is (for cache size C and memory size K (kbytes)):
  *  x = log2(K) - 14
  *  C = x^2/3 + x + 2/3 + 0.1 (0.1 for rounding)
  *  if (C > 32) C = 32
  */
 int32_t
 nsCacheProfilePrefObserver::MemoryCacheCapacity()
 {
     int32_t capacity = mMemoryCacheCapacity;
     if (capacity >= 0) {
         CACHE_LOG_DEBUG(("Memory cache capacity forced to %d\n", capacity));
         return capacity;
     }
     static uint64_t bytes = PR_GetPhysicalMemorySize();
     CACHE_LOG_DEBUG(("Physical Memory size is %llu\n", bytes));
     // If getting the physical memory failed, arbitrarily assume
     // 32 MB of RAM. We use a low default to have a reasonable
     // size on all the devices we support.
     if (bytes == 0)
         bytes = 32 * 1024 * 1024;
     // Conversion from unsigned int64_t to double doesn't work on all platforms.
     // We need to truncate the value at INT64_MAX to make sure we don't
     // overflow.
     if (bytes > INT64_MAX)
         bytes = INT64_MAX;
     uint64_t kbytes = bytes >> 10;
     double kBytesD = double(kbytes);
     double x = log(kBytesD)/log(2.0) - 14;
     if (x > 0) {
         capacity = (int32_t)(x * x / 3.0 + x + 2.0 / 3 + 0.1); // 0.1 for rounding
         if (capacity > 32)
             capacity = 32;
         capacity   *= 1024;
     } else {
         capacity    = 0;
     }
     return capacity;
 }
 int32_t
 nsCacheProfilePrefObserver::CacheCompressionLevel()
 {
     return mCacheCompressionLevel;
 }
 /******************************************************************************
  * nsProcessRequestEvent
  *****************************************************************************/
 class nsProcessRequestEvent : public nsRunnable {
 public:
     nsProcessRequestEvent(nsCacheRequest *aRequest)
     {
         MOZ_EVENT_TRACER_NAME_OBJECT(aRequest, aRequest->mKey.get());
         MOZ_EVENT_TRACER_WAIT(aRequest, "net::cache::ProcessRequest");
         mRequest = aRequest;
     }
     NS_IMETHOD Run()
     {
         nsresult rv;
         NS_ASSERTION(mRequest->mListener,
                      "Sync OpenCacheEntry() posted to background thread!");
         nsCacheServiceAutoLock lock(LOCK_TELEM(NSPROCESSREQUESTEVENT_RUN));
         rv = nsCacheService::gService->ProcessRequest(mRequest,
                                                       false,
                                                       nullptr);
         // Don't delete the request if it was queued
         if (!(mRequest->IsBlocking() &&
             rv == NS_ERROR_CACHE_WAIT_FOR_VALIDATION))
             delete mRequest;
         return NS_OK;
     }
 protected:
     virtual ~nsProcessRequestEvent() {}
 private:
     nsCacheRequest *mRequest;
 };
 /******************************************************************************
  * nsDoomEvent
  *****************************************************************************/
 class nsDoomEvent : public nsRunnable {
 public:
     nsDoomEvent(nsCacheSession *session,
                 const nsACString &key,
                 nsICacheListener *listener)
     {
         mKey = *session->ClientID();
         mKey.Append(':');
         mKey.Append(key);
         mStoragePolicy = session->StoragePolicy();
         mListener = listener;
         mThread = do_GetCurrentThread();
         // We addref the listener here and release it in nsNotifyDoomListener
         // on the callers thread. If posting of nsNotifyDoomListener event fails
         // we leak the listener which is better than releasing it on a wrong
         // thread.
         NS_IF_ADDREF(mListener);
     }
     NS_IMETHOD Run()
     {
         nsCacheServiceAutoLock lock(LOCK_TELEM(NSDOOMEVENT_RUN));
         bool foundActive = true;
         nsresult status = NS_ERROR_NOT_AVAILABLE;
         nsCacheEntry *entry;
         entry = nsCacheService::gService->mActiveEntries.GetEntry(&mKey);
         if (!entry) {
             bool collision = false;
             foundActive = false;
             entry = nsCacheService::gService->SearchCacheDevices(&mKey,
                                                                  mStoragePolicy,
                                                                  &collision);
         }
         if (entry) {
             status = NS_OK;
             nsCacheService::gService->DoomEntry_Internal(entry, foundActive);
         }
         if (mListener) {
             mThread->Dispatch(new nsNotifyDoomListener(mListener, status),
                               NS_DISPATCH_NORMAL);
             // posted event will release the reference on the correct thread
             mListener = nullptr;
         }
         return NS_OK;
     }
 private:
     nsCString             mKey;
     nsCacheStoragePolicy  mStoragePolicy;
     nsICacheListener     *mListener;
     nsCOMPtr<nsIThread>   mThread;
 };
 /******************************************************************************
  * nsCacheService
  *****************************************************************************/
 nsCacheService *   nsCacheService::gService = nullptr;
 NS_IMPL_ISUPPORTS(nsCacheService, nsICacheService, nsICacheServiceInternal,
                   nsIMemoryReporter)
 nsCacheService::nsCacheService()
     : mObserver(nullptr),
       mLock("nsCacheService.mLock"),
       mCondVar(mLock, "nsCacheService.mCondVar"),
       mTimeStampLock("nsCacheService.mTimeStampLock"),
       mInitialized(false),
       mClearingEntries(false),
       mEnableMemoryDevice(true),
       mEnableDiskDevice(true),
       mMemoryDevice(nullptr),
       mDiskDevice(nullptr),
       mOfflineDevice(nullptr),
       mTotalEntries(0),
       mCacheHits(0),
       mCacheMisses(0),
       mMaxKeyLength(0),
       mMaxDataSize(0),
       mMaxMetaSize(0),
       mDeactivateFailures(0),
       mDeactivatedUnboundEntries(0)
 {
     NS_ASSERTION(gService==nullptr, "multiple nsCacheService instances!");
     gService = this;
     // create list of cache devices
     PR_INIT_CLIST(&mDoomedEntries);
 }
 nsCacheService::~nsCacheService()
 {
     if (mInitialized) // Shutdown hasn't been called yet.
         (void) Shutdown();
     if (mObserver) {
         mObserver->Remove();
         NS_RELEASE(mObserver);
     }
     gService = nullptr;
 }
 nsresult
 nsCacheService::Init()
 {
     // Thie method must be called on the main thread because mCacheIOThread must
     // only be modified on the main thread.
     if (!NS_IsMainThread()) {
         NS_ERROR("nsCacheService::Init called off the main thread");
         return NS_ERROR_NOT_SAME_THREAD;
     }
     NS_ASSERTION(!mInitialized, "nsCacheService already initialized.");
     if (mInitialized)
         return NS_ERROR_ALREADY_INITIALIZED;
     if (mozilla::net::IsNeckoChild()) {
         return NS_ERROR_UNEXPECTED;
     }
     CACHE_LOG_INIT();
     nsresult rv;
     mStorageService = do_GetService("@mozilla.org/storage/service;1", &rv);
     NS_ENSURE_SUCCESS(rv, rv);
     MOZ_EVENT_TRACER_NAME_OBJECT(nsCacheService::gService, "nsCacheService");
     rv = NS_NewNamedThread("Cache I/O",
                            getter_AddRefs(mCacheIOThread));
     if (NS_FAILED(rv)) {
         NS_RUNTIMEABORT("Can't create cache IO thread");
     }
     rv = nsDeleteDir::Init();
     if (NS_FAILED(rv)) {
         NS_WARNING("Can't initialize nsDeleteDir");
     }
     // initialize hashtable for active cache entries
     rv = mActiveEntries.Init();
     if (NS_FAILED(rv)) return rv;
     // create profile/preference observer
     if (!mObserver) {
       mObserver = new nsCacheProfilePrefObserver();
       NS_ADDREF(mObserver);
       mObserver->Install();
     }
     mEnableDiskDevice    = mObserver->DiskCacheEnabled();
     mEnableOfflineDevice = mObserver->OfflineCacheEnabled();
     mEnableMemoryDevice  = mObserver->MemoryCacheEnabled();
     RegisterWeakMemoryReporter(this);
     mInitialized = true;
     return NS_OK;
 }
 // static
 PLDHashOperator
 nsCacheService::ShutdownCustomCacheDeviceEnum(const nsAString& aProfileDir,
                                               nsRefPtr<nsOfflineCacheDevice>& aDevice,
                                               void* aUserArg)
 {
     aDevice->Shutdown();
     return PL_DHASH_REMOVE;
 }
 void
 nsCacheService::Shutdown()
 {
     // This method must be called on the main thread because mCacheIOThread must
     // only be modified on the main thread.
     if (!NS_IsMainThread()) {
         NS_RUNTIMEABORT("nsCacheService::Shutdown called off the main thread");
     }
     nsCOMPtr<nsIThread> cacheIOThread;
     Telemetry::AutoTimer<Telemetry::NETWORK_DISK_CACHE_SHUTDOWN> totalTimer;
     bool shouldSanitize = false;
     nsCOMPtr<nsIFile> parentDir;
     {
         nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_SHUTDOWN));
         NS_ASSERTION(mInitialized,
             "can't shutdown nsCacheService unless it has been initialized.");
         if (!mInitialized)
             return;
         mClearingEntries = true;
         DoomActiveEntries(nullptr);
     }
     CloseAllStreams();
     UnregisterWeakMemoryReporter(this);
     {
         nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_SHUTDOWN));
         NS_ASSERTION(mInitialized, "Bad state");
         mInitialized = false;
         // Clear entries
         ClearDoomList();
         if (mSmartSizeTimer) {
             mSmartSizeTimer->Cancel();
             mSmartSizeTimer = nullptr;
         }
         // Make sure to wait for any pending cache-operations before
         // proceeding with destructive actions (bug #620660)
         (void) SyncWithCacheIOThread();
         // obtain the disk cache directory in case we need to sanitize it
         parentDir = mObserver->DiskCacheParentDirectory();
         shouldSanitize = mObserver->SanitizeAtShutdown();
         // deallocate memory and disk caches
         delete mMemoryDevice;
         mMemoryDevice = nullptr;
         delete mDiskDevice;
         mDiskDevice = nullptr;
         if (mOfflineDevice)
             mOfflineDevice->Shutdown();
         NS_IF_RELEASE(mOfflineDevice);
         mCustomOfflineDevices.Enumerate(&nsCacheService::ShutdownCustomCacheDeviceEnum, nullptr);
 #ifdef PR_LOGGING
         LogCacheStatistics();
 #endif
         mClearingEntries = false;
         mCacheIOThread.swap(cacheIOThread);
     }
     if (cacheIOThread)
         nsShutdownThread::BlockingShutdown(cacheIOThread);
     if (shouldSanitize) {
         nsresult rv = parentDir->AppendNative(NS_LITERAL_CSTRING("Cache"));
         if (NS_SUCCEEDED(rv)) {
             bool exists;
             if (NS_SUCCEEDED(parentDir->Exists(&exists)) && exists)
                 nsDeleteDir::DeleteDir(parentDir, false);
         }
         Telemetry::AutoTimer<Telemetry::NETWORK_DISK_CACHE_SHUTDOWN_CLEAR_PRIVATE> timer;
         nsDeleteDir::Shutdown(shouldSanitize);
     } else {
         Telemetry::AutoTimer<Telemetry::NETWORK_DISK_CACHE_DELETEDIR_SHUTDOWN> timer;
         nsDeleteDir::Shutdown(shouldSanitize);
     }
 }
 nsresult
 nsCacheService::Create(nsISupports* aOuter, const nsIID& aIID, void* *aResult)
 {
     nsresult  rv;
     if (aOuter != nullptr)
         return NS_ERROR_NO_AGGREGATION;
     nsCacheService * cacheService = new nsCacheService();
     if (cacheService == nullptr)
         return NS_ERROR_OUT_OF_MEMORY;
     NS_ADDREF(cacheService);
     rv = cacheService->Init();
     if (NS_SUCCEEDED(rv)) {
         rv = cacheService->QueryInterface(aIID, aResult);
     }
     NS_RELEASE(cacheService);
     return rv;
 }
 NS_IMETHODIMP
 nsCacheService::CreateSession(const char *          clientID,
                               nsCacheStoragePolicy  storagePolicy,
                               bool                  streamBased,
                               nsICacheSession     **result)
 {
     *result = nullptr;
     if (this == nullptr)  return NS_ERROR_NOT_AVAILABLE;
     nsCacheSession * session = new nsCacheSession(clientID, storagePolicy, streamBased);
     if (!session)  return NS_ERROR_OUT_OF_MEMORY;
     NS_ADDREF(*result = session);
     return NS_OK;
 }
 nsresult
 nsCacheService::EvictEntriesForSession(nsCacheSession * session)
 {
     NS_ASSERTION(gService, "nsCacheService::gService is null.");
     return gService->EvictEntriesForClient(session->ClientID()->get(),
                                  session->StoragePolicy());
 }
 namespace {
 class EvictionNotifierRunnable : public nsRunnable
 {
 public:
     EvictionNotifierRunnable(nsISupports* aSubject)
         : mSubject(aSubject)
     { }
     NS_DECL_NSIRUNNABLE
 private:
     nsCOMPtr<nsISupports> mSubject;
 };
 NS_IMETHODIMP
 EvictionNotifierRunnable::Run()
 {
     nsCOMPtr<nsIObserverService> obsSvc =
         mozilla::services::GetObserverService();
     if (obsSvc) {
         obsSvc->NotifyObservers(mSubject,
                                 NS_CACHESERVICE_EMPTYCACHE_TOPIC_ID,
                                 nullptr);
     }
     return NS_OK;
 }
 } // anonymous namespace
 nsresult
 nsCacheService::EvictEntriesForClient(const char *          clientID,
                                       nsCacheStoragePolicy  storagePolicy)
 {
     nsRefPtr<EvictionNotifierRunnable> r =
         new EvictionNotifierRunnable(NS_ISUPPORTS_CAST(nsICacheService*, this));
     NS_DispatchToMainThread(r);
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_EVICTENTRIESFORCLIENT));
     nsresult res = NS_OK;
     if (storagePolicy == nsICache::STORE_ANYWHERE ||
         storagePolicy == nsICache::STORE_ON_DISK) {
         if (mEnableDiskDevice) {
             nsresult rv = NS_OK;
             if (!mDiskDevice)
                 rv = CreateDiskDevice();
             if (mDiskDevice)
                 rv = mDiskDevice->EvictEntries(clientID);
             if (NS_FAILED(rv))
                 res = rv;
         }
     }
     // Only clear the offline cache if it has been specifically asked for.
     if (storagePolicy == nsICache::STORE_OFFLINE) {
         if (mEnableOfflineDevice) {
             nsresult rv = NS_OK;
             if (!mOfflineDevice)
                 rv = CreateOfflineDevice();
             if (mOfflineDevice)
                 rv = mOfflineDevice->EvictEntries(clientID);
             if (NS_FAILED(rv))
                 res = rv;
         }
     }
     if (storagePolicy == nsICache::STORE_ANYWHERE ||
         storagePolicy == nsICache::STORE_IN_MEMORY) {
         // If there is no memory device, there is no need to evict it...
         if (mMemoryDevice) {
             nsresult rv = mMemoryDevice->EvictEntries(clientID);
             if (NS_FAILED(rv))
                 res = rv;
         }
     }
     return res;
 }
 nsresult
 nsCacheService::IsStorageEnabledForPolicy(nsCacheStoragePolicy  storagePolicy,
                                           bool *              result)
 {
     if (gService == nullptr) return NS_ERROR_NOT_AVAILABLE;
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_ISSTORAGEENABLEDFORPOLICY));
     *result = gService->IsStorageEnabledForPolicy_Locked(storagePolicy);
     return NS_OK;
 }
 nsresult
 nsCacheService::DoomEntry(nsCacheSession   *session,
                           const nsACString &key,
                           nsICacheListener *listener)
 {
     CACHE_LOG_DEBUG(("Dooming entry for session %p, key %s\n",
                      session, PromiseFlatCString(key).get()));
     NS_ASSERTION(gService, "nsCacheService::gService is null.");
     if (!gService->mInitialized)
         return NS_ERROR_NOT_INITIALIZED;
     return DispatchToCacheIOThread(new nsDoomEvent(session, key, listener));
 }
 bool
 nsCacheService::IsStorageEnabledForPolicy_Locked(nsCacheStoragePolicy  storagePolicy)
 {
     if (gService->mEnableMemoryDevice &&
         (storagePolicy == nsICache::STORE_ANYWHERE ||
          storagePolicy == nsICache::STORE_IN_MEMORY)) {
         return true;
     }
     if (gService->mEnableDiskDevice &&
         (storagePolicy == nsICache::STORE_ANYWHERE ||
          storagePolicy == nsICache::STORE_ON_DISK)) {
         return true;
     }
     if (gService->mEnableOfflineDevice &&
         storagePolicy == nsICache::STORE_OFFLINE) {
         return true;
     }
     return false;
 }
 NS_IMETHODIMP nsCacheService::VisitEntries(nsICacheVisitor *visitor)
 {
     NS_ENSURE_ARG_POINTER(visitor);
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_VISITENTRIES));
     if (!(mEnableDiskDevice || mEnableMemoryDevice))
         return NS_ERROR_NOT_AVAILABLE;
     // XXX record the fact that a visitation is in progress,
     // XXX i.e. keep list of visitors in progress.
     nsresult rv = NS_OK;
     // If there is no memory device, there are then also no entries to visit...
     if (mMemoryDevice) {
         rv = mMemoryDevice->Visit(visitor);
         if (NS_FAILED(rv)) return rv;
     }
     if (mEnableDiskDevice) {
         if (!mDiskDevice) {
             rv = CreateDiskDevice();
             if (NS_FAILED(rv)) return rv;
         }
         rv = mDiskDevice->Visit(visitor);
         if (NS_FAILED(rv)) return rv;
     }
     if (mEnableOfflineDevice) {
         if (!mOfflineDevice) {
             rv = CreateOfflineDevice();
             if (NS_FAILED(rv)) return rv;
         }
         rv = mOfflineDevice->Visit(visitor);
         if (NS_FAILED(rv)) return rv;
     }
     // XXX notify any shutdown process that visitation is complete for THIS visitor.
     // XXX keep queue of visitors
     return NS_OK;
 }
 void nsCacheService::FireClearNetworkCacheStoredAnywhereNotification()
 {
     MOZ_ASSERT(NS_IsMainThread());
     nsCOMPtr<nsIObserverService> obsvc = mozilla::services::GetObserverService();
     if (obsvc) {
         obsvc->NotifyObservers(nullptr,
                                "network-clear-cache-stored-anywhere",
                                nullptr);
     }
 }
 NS_IMETHODIMP nsCacheService::EvictEntries(nsCacheStoragePolicy storagePolicy)
 {
     if (storagePolicy == nsICache::STORE_ANYWHERE) {
         // if not called on main thread, dispatch the notification to the main thread to notify observers
         if (!NS_IsMainThread()) {
             nsCOMPtr<nsIRunnable> event = NS_NewRunnableMethod(this,
                                                                &nsCacheService::FireClearNetworkCacheStoredAnywhereNotification);
             NS_DispatchToMainThread(event, NS_DISPATCH_NORMAL);
         } else {
             // else you're already on main thread - notify observers
             FireClearNetworkCacheStoredAnywhereNotification();
         }
     }
     NS_IMETHODIMP r;
     r = EvictEntriesForClient(nullptr, storagePolicy);
     // XXX: Bloody hack until we get this notifier in FF14.0:
     // https://developer.mozilla.org/en/XPCOM_Interface_Reference/nsICacheListener#onCacheEntryDoomed%28%29
     if (storagePolicy == nsICache::STORE_ANYWHERE &&
             NS_IsMainThread() && gService && gService->mInitialized) {
         nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_EVICTENTRIESFORCLIENT));
         gService->mClearingEntries = true;
         gService->DoomActiveEntries(nullptr);
         gService->ClearDoomList();
         (void) SyncWithCacheIOThread();
         gService->mClearingEntries = false;
     }
     return r;
 }
 NS_IMETHODIMP nsCacheService::GetCacheIOTarget(nsIEventTarget * *aCacheIOTarget)
 {
     NS_ENSURE_ARG_POINTER(aCacheIOTarget);
     // Because mCacheIOThread can only be changed on the main thread, it can be
     // read from the main thread without the lock. This is useful to prevent
     // blocking the main thread on other cache operations.
     if (!NS_IsMainThread()) {
         Lock(LOCK_TELEM(NSCACHESERVICE_GETCACHEIOTARGET));
     }
     nsresult rv;
     if (mCacheIOThread) {
         NS_ADDREF(*aCacheIOTarget = mCacheIOThread);
         rv = NS_OK;
     } else {
         *aCacheIOTarget = nullptr;
         rv = NS_ERROR_NOT_AVAILABLE;
     }
     if (!NS_IsMainThread()) {
         Unlock();
     }
     return rv;
 }
 /* nsICacheServiceInternal
  * readonly attribute double lockHeldTime;
 */
 NS_IMETHODIMP nsCacheService::GetLockHeldTime(double *aLockHeldTime)
 {
     MutexAutoLock lock(mTimeStampLock);
     if (mLockAcquiredTimeStamp.IsNull()) {
         *aLockHeldTime = 0.0;
     }
     else {
         *aLockHeldTime =
             (TimeStamp::Now() - mLockAcquiredTimeStamp).ToMilliseconds();
     }
     return NS_OK;
 }
 /**
  * Internal Methods
  */
 nsresult
 nsCacheService::CreateDiskDevice()
 {
     if (!mInitialized)      return NS_ERROR_NOT_AVAILABLE;
     if (!mEnableDiskDevice) return NS_ERROR_NOT_AVAILABLE;
     if (mDiskDevice)        return NS_OK;
     mDiskDevice = new nsDiskCacheDevice;
     if (!mDiskDevice)       return NS_ERROR_OUT_OF_MEMORY;
     // set the preferences
     mDiskDevice->SetCacheParentDirectory(mObserver->DiskCacheParentDirectory());
     mDiskDevice->SetCapacity(mObserver->DiskCacheCapacity());
     mDiskDevice->SetMaxEntrySize(mObserver->DiskCacheMaxEntrySize());
     nsresult rv = mDiskDevice->Init();
     if (NS_FAILED(rv)) {
 #if DEBUG
         printf("###\n");
         printf("### mDiskDevice->Init() failed (0x%.8x)\n",
                static_cast<uint32_t>(rv));
         printf("###    - disabling disk cache for this session.\n");
         printf("###\n");
 #endif
         mEnableDiskDevice = false;
         delete mDiskDevice;
         mDiskDevice = nullptr;
         return rv;
     }
     Telemetry::Accumulate(Telemetry::DISK_CACHE_SMART_SIZE_USING_OLD_MAX,
                           mObserver->ShouldUseOldMaxSmartSize());
     NS_ASSERTION(!mSmartSizeTimer, "Smartsize timer was already fired!");
     // Disk device is usually created during the startup. Delay smart size
     // calculation to avoid possible massive IO caused by eviction of entries
     // in case the new smart size is smaller than current cache usage.
     mSmartSizeTimer = do_CreateInstance("@mozilla.org/timer;1", &rv);
     if (NS_SUCCEEDED(rv)) {
         rv = mSmartSizeTimer->InitWithCallback(new nsSetDiskSmartSizeCallback(),
 *60*3,
                                                nsITimer::TYPE_ONE_SHOT);
         if (NS_FAILED(rv)) {
             NS_WARNING("Failed to post smart size timer");
             mSmartSizeTimer = nullptr;
         }
     } else {
         NS_WARNING("Can't create smart size timer");
     }
     // Ignore state of the timer and return success since the purpose of the
     // method (create the disk-device) has been fulfilled
     return NS_OK;
 }
 // Runnable sent from cache thread to main thread
 class nsDisableOldMaxSmartSizePrefEvent: public nsRunnable
 {
 public:
     nsDisableOldMaxSmartSizePrefEvent() {}
     NS_IMETHOD Run()
     {
         // Main thread may have already called nsCacheService::Shutdown
         if (!nsCacheService::IsInitialized())
             return NS_ERROR_NOT_AVAILABLE;
         nsCOMPtr<nsIPrefBranch> branch = do_GetService(NS_PREFSERVICE_CONTRACTID);
         if (!branch) {
             return NS_ERROR_NOT_AVAILABLE;
         }
         nsresult rv = branch->SetBoolPref(DISK_CACHE_USE_OLD_MAX_SMART_SIZE_PREF, false);
         if (NS_FAILED(rv)) {
             NS_WARNING("Failed to disable old max smart size");
             return rv;
         }
         // It is safe to call SetDiskSmartSize_Locked() without holding the lock
         // when we are on main thread and nsCacheService is initialized.
         nsCacheService::gService->SetDiskSmartSize_Locked();
         if (nsCacheService::gService->mObserver->PermittedToSmartSize(branch, false)) {
             rv = branch->SetIntPref(DISK_CACHE_CAPACITY_PREF, MAX_CACHE_SIZE);
             if (NS_FAILED(rv)) {
                 NS_WARNING("Failed to set cache capacity pref");
             }
         }
         return NS_OK;
     }
 };
 void
 nsCacheService::MarkStartingFresh()
 {
     if (!gService->mObserver->ShouldUseOldMaxSmartSize()) {
         // Already using new max, nothing to do here
         return;
     }
     gService->mObserver->SetUseNewMaxSmartSize(true);
     // We always dispatch an event here because we don't want to deal with lock
     // reentrance issues.
     NS_DispatchToMainThread(new nsDisableOldMaxSmartSizePrefEvent());
 }
 nsresult
 nsCacheService::GetOfflineDevice(nsOfflineCacheDevice **aDevice)
 {
     if (!mOfflineDevice) {
         nsresult rv = CreateOfflineDevice();
         NS_ENSURE_SUCCESS(rv, rv);
     }
     NS_ADDREF(*aDevice = mOfflineDevice);
     return NS_OK;
 }
 nsresult
 nsCacheService::GetCustomOfflineDevice(nsIFile *aProfileDir,
                                        int32_t aQuota,
                                        nsOfflineCacheDevice **aDevice)
 {
     nsresult rv;
     nsAutoString profilePath;
     rv = aProfileDir->GetPath(profilePath);
     NS_ENSURE_SUCCESS(rv, rv);
     if (!mCustomOfflineDevices.Get(profilePath, aDevice)) {
         rv = CreateCustomOfflineDevice(aProfileDir, aQuota, aDevice);
         NS_ENSURE_SUCCESS(rv, rv);
         (*aDevice)->SetAutoShutdown();
         mCustomOfflineDevices.Put(profilePath, *aDevice);
     }
     return NS_OK;
 }
 nsresult
 nsCacheService::CreateOfflineDevice()
 {
     CACHE_LOG_ALWAYS(("Creating default offline device"));
     if (mOfflineDevice)        return NS_OK;
     if (!nsCacheService::IsInitialized()) {
         return NS_ERROR_NOT_AVAILABLE;
     }
     nsresult rv = CreateCustomOfflineDevice(
         mObserver->OfflineCacheParentDirectory(),
         mObserver->OfflineCacheCapacity(),
         &mOfflineDevice);
     NS_ENSURE_SUCCESS(rv, rv);
     return NS_OK;
 }
 nsresult
 nsCacheService::CreateCustomOfflineDevice(nsIFile *aProfileDir,
                                           int32_t aQuota,
                                           nsOfflineCacheDevice **aDevice)
 {
     NS_ENSURE_ARG(aProfileDir);
 #if defined(PR_LOGGING)
     nsAutoCString profilePath;
     aProfileDir->GetNativePath(profilePath);
     CACHE_LOG_ALWAYS(("Creating custom offline device, %s, %d",
                       profilePath.BeginReading(), aQuota));
 #endif
     if (!mInitialized)         return NS_ERROR_NOT_AVAILABLE;
     if (!mEnableOfflineDevice) return NS_ERROR_NOT_AVAILABLE;
     *aDevice = new nsOfflineCacheDevice;
     NS_ADDREF(*aDevice);
     // set the preferences
     (*aDevice)->SetCacheParentDirectory(aProfileDir);
     (*aDevice)->SetCapacity(aQuota);
     nsresult rv = (*aDevice)->InitWithSqlite(mStorageService);
     if (NS_FAILED(rv)) {
         CACHE_LOG_DEBUG(("OfflineDevice->InitWithSqlite() failed (0x%.8x)\n", rv));
         CACHE_LOG_DEBUG(("    - disabling offline cache for this session.\n"));
         NS_RELEASE(*aDevice);
     }
     return rv;
 }
 nsresult
 nsCacheService::CreateMemoryDevice()
 {
     if (!mInitialized)        return NS_ERROR_NOT_AVAILABLE;
     if (!mEnableMemoryDevice) return NS_ERROR_NOT_AVAILABLE;
     if (mMemoryDevice)        return NS_OK;
     mMemoryDevice = new nsMemoryCacheDevice;
     if (!mMemoryDevice)       return NS_ERROR_OUT_OF_MEMORY;
     // set preference
     int32_t capacity = mObserver->MemoryCacheCapacity();
     CACHE_LOG_DEBUG(("Creating memory device with capacity %d\n", capacity));
     mMemoryDevice->SetCapacity(capacity);
     mMemoryDevice->SetMaxEntrySize(mObserver->MemoryCacheMaxEntrySize());
     nsresult rv = mMemoryDevice->Init();
     if (NS_FAILED(rv)) {
         NS_WARNING("Initialization of Memory Cache failed.");
         delete mMemoryDevice;
         mMemoryDevice = nullptr;
     }
     return rv;
 }
 nsresult
 nsCacheService::RemoveCustomOfflineDevice(nsOfflineCacheDevice *aDevice)
 {
     nsCOMPtr<nsIFile> profileDir = aDevice->BaseDirectory();
     if (!profileDir)
         return NS_ERROR_UNEXPECTED;
     nsAutoString profilePath;
     nsresult rv = profileDir->GetPath(profilePath);
     NS_ENSURE_SUCCESS(rv, rv);
     mCustomOfflineDevices.Remove(profilePath);
     return NS_OK;
 }
 nsresult
 nsCacheService::CreateRequest(nsCacheSession *   session,
                               const nsACString & clientKey,
                               nsCacheAccessMode  accessRequested,
                               bool               blockingMode,
                               nsICacheListener * listener,
                               nsCacheRequest **  request)
 {
     NS_ASSERTION(request, "CreateRequest: request is null");
     nsAutoCString key(*session->ClientID());
     key.Append(':');
     key.Append(clientKey);
     if (mMaxKeyLength < key.Length()) mMaxKeyLength = key.Length();
     // create request
     *request = new nsCacheRequest(key, listener, accessRequested,
                                   blockingMode, session);
     if (!listener)  return NS_OK;  // we're sync, we're done.
     // get the request's thread
     (*request)->mThread = do_GetCurrentThread();
     return NS_OK;
 }
 class nsCacheListenerEvent : public nsRunnable
 {
 public:
     nsCacheListenerEvent(nsICacheListener *listener,
                          nsICacheEntryDescriptor *descriptor,
                          nsCacheAccessMode accessGranted,
                          nsresult status)
         : mListener(listener)      // transfers reference
         , mDescriptor(descriptor)  // transfers reference (may be null)
         , mAccessGranted(accessGranted)
         , mStatus(status)
     {}
     NS_IMETHOD Run()
     {
         mozilla::eventtracer::AutoEventTracer tracer(
             static_cast<nsIRunnable*>(this),
             eventtracer::eExec,
             eventtracer::eDone,
             "net::cache::OnCacheEntryAvailable");
         mListener->OnCacheEntryAvailable(mDescriptor, mAccessGranted, mStatus);
         NS_RELEASE(mListener);
         NS_IF_RELEASE(mDescriptor);
         return NS_OK;
     }
 private:
     // We explicitly leak mListener or mDescriptor if Run is not called
     // because otherwise we cannot guarantee that they are destroyed on
     // the right thread.
     nsICacheListener        *mListener;
     nsICacheEntryDescriptor *mDescriptor;
     nsCacheAccessMode        mAccessGranted;
     nsresult                 mStatus;
 };
 nsresult
 nsCacheService::NotifyListener(nsCacheRequest *          request,
                                nsICacheEntryDescriptor * descriptor,
                                nsCacheAccessMode         accessGranted,
                                nsresult                  status)
 {
     NS_ASSERTION(request->mThread, "no thread set in async request!");
     // Swap ownership, and release listener on target thread...
     nsICacheListener *listener = request->mListener;
     request->mListener = nullptr;
     nsCOMPtr<nsIRunnable> ev =
             new nsCacheListenerEvent(listener, descriptor,
                                      accessGranted, status);
     if (!ev) {
         // Better to leak listener and descriptor if we fail because we don't
         // want to destroy them inside the cache service lock or on potentially
         // the wrong thread.
         return NS_ERROR_OUT_OF_MEMORY;
     }
     MOZ_EVENT_TRACER_NAME_OBJECT(ev.get(), request->mKey.get());
     MOZ_EVENT_TRACER_WAIT(ev.get(), "net::cache::OnCacheEntryAvailable");
     return request->mThread->Dispatch(ev, NS_DISPATCH_NORMAL);
 }
 nsresult
 nsCacheService::ProcessRequest(nsCacheRequest *           request,
                                bool                       calledFromOpenCacheEntry,
                                nsICacheEntryDescriptor ** result)
 {
     mozilla::eventtracer::AutoEventTracer tracer(
         request,
         eventtracer::eExec,
         eventtracer::eDone,
         "net::cache::ProcessRequest");
     // !!! must be called with mLock held !!!
     nsresult           rv;
     nsCacheEntry *     entry = nullptr;
     nsCacheEntry *     doomedEntry = nullptr;
     nsCacheAccessMode  accessGranted = nsICache::ACCESS_NONE;
     if (result) *result = nullptr;
     while(1) {  // Activate entry loop
         rv = ActivateEntry(request, &entry, &doomedEntry);  // get the entry for this request
         if (NS_FAILED(rv))  break;
         while(1) { // Request Access loop
             NS_ASSERTION(entry, "no entry in Request Access loop!");
             // entry->RequestAccess queues request on entry
             rv = entry->RequestAccess(request, &accessGranted);
             if (rv != NS_ERROR_CACHE_WAIT_FOR_VALIDATION) break;
             if (request->IsBlocking()) {
                 if (request->mListener) {
                     // async exits - validate, doom, or close will resume
                     return rv;
                 }
                 // XXX this is probably wrong...
                 Unlock();
                 rv = request->WaitForValidation();
                 Lock(LOCK_TELEM(NSCACHESERVICE_PROCESSREQUEST));
             }
             PR_REMOVE_AND_INIT_LINK(request);
             if (NS_FAILED(rv)) break;   // non-blocking mode returns WAIT_FOR_VALIDATION error
             // okay, we're ready to process this request, request access again
         }
         if (rv != NS_ERROR_CACHE_ENTRY_DOOMED)  break;
         if (entry->IsNotInUse()) {
             // this request was the last one keeping it around, so get rid of it
             DeactivateEntry(entry);
         }
         // loop back around to look for another entry
     }
     if (NS_SUCCEEDED(rv) && request->mProfileDir) {
         // Custom cache directory has been demanded.  Preset the cache device.
         if (entry->StoragePolicy() != nsICache::STORE_OFFLINE) {
             // Failsafe check: this is implemented only for offline cache atm.
             rv = NS_ERROR_FAILURE;
         } else {
             nsRefPtr<nsOfflineCacheDevice> customCacheDevice;
             rv = GetCustomOfflineDevice(request->mProfileDir, -1,
                                         getter_AddRefs(customCacheDevice));
             if (NS_SUCCEEDED(rv))
                 entry->SetCustomCacheDevice(customCacheDevice);
         }
     }
     nsICacheEntryDescriptor *descriptor = nullptr;
     if (NS_SUCCEEDED(rv))
         rv = entry->CreateDescriptor(request, accessGranted, &descriptor);
     // If doomedEntry is set, ActivatEntry() doomed an existing entry and
     // created a new one for that cache-key. However, any pending requests
     // on the doomed entry were not processed and we need to do that here.
     // This must be done after adding the created entry to list of active
     // entries (which is done in ActivateEntry()) otherwise the hashkeys crash
     // (see bug ##561313). It is also important to do this after creating a
     // descriptor for this request, or some other request may end up being
     // executed first for the newly created entry.
     // Finally, it is worth to emphasize that if doomedEntry is set,
     // ActivateEntry() created a new entry for the request, which will be
     // initialized by RequestAccess() and they both should have returned NS_OK.
     if (doomedEntry) {
         (void) ProcessPendingRequests(doomedEntry);
         if (doomedEntry->IsNotInUse())
             DeactivateEntry(doomedEntry);
         doomedEntry = nullptr;
     }
     if (request->mListener) {  // Asynchronous
         if (NS_FAILED(rv) && calledFromOpenCacheEntry && request->IsBlocking())
             return rv;  // skip notifying listener, just return rv to caller
         // call listener to report error or descriptor
         nsresult rv2 = NotifyListener(request, descriptor, accessGranted, rv);
         if (NS_FAILED(rv2) && NS_SUCCEEDED(rv)) {
             rv = rv2;  // trigger delete request
         }
     } else {        // Synchronous
         *result = descriptor;
     }
     return rv;
 }
 nsresult
 nsCacheService::OpenCacheEntry(nsCacheSession *           session,
                                const nsACString &         key,
                                nsCacheAccessMode          accessRequested,
                                bool                       blockingMode,
                                nsICacheListener *         listener,
                                nsICacheEntryDescriptor ** result)
 {
     CACHE_LOG_DEBUG(("Opening entry for session %p, key %s, mode %d, blocking %d\n",
                      session, PromiseFlatCString(key).get(), accessRequested,
                      blockingMode));
     NS_ASSERTION(gService, "nsCacheService::gService is null.");
     if (result)
         *result = nullptr;
     if (!gService->mInitialized)
         return NS_ERROR_NOT_INITIALIZED;
     nsCacheRequest * request = nullptr;
     nsresult rv = gService->CreateRequest(session,
                                           key,
                                           accessRequested,
                                           blockingMode,
                                           listener,
                                           &request);
     if (NS_FAILED(rv))  return rv;
     CACHE_LOG_DEBUG(("Created request %p\n", request));
     // Process the request on the background thread if we are on the main thread
     // and the the request is asynchronous
     if (NS_IsMainThread() && listener && gService->mCacheIOThread) {
         nsCOMPtr<nsIRunnable> ev =
             new nsProcessRequestEvent(request);
         rv = DispatchToCacheIOThread(ev);
         // delete request if we didn't post the event
         if (NS_FAILED(rv))
             delete request;
     }
     else {
         nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_OPENCACHEENTRY));
         rv = gService->ProcessRequest(request, true, result);
         // delete requests that have completed
         if (!(listener && blockingMode &&
             (rv == NS_ERROR_CACHE_WAIT_FOR_VALIDATION)))
             delete request;
     }
     return rv;
 }
 nsresult
 nsCacheService::ActivateEntry(nsCacheRequest * request,
                               nsCacheEntry ** result,
                               nsCacheEntry ** doomedEntry)
 {
     CACHE_LOG_DEBUG(("Activate entry for request %p\n", request));
     if (!mInitialized || mClearingEntries)
         return NS_ERROR_NOT_AVAILABLE;
     mozilla::eventtracer::AutoEventTracer tracer(
         request,
         eventtracer::eExec,
         eventtracer::eDone,
         "net::cache::ActivateEntry");
     nsresult        rv = NS_OK;
     NS_ASSERTION(request != nullptr, "ActivateEntry called with no request");
     if (result) *result = nullptr;
     if (doomedEntry) *doomedEntry = nullptr;
     if ((!request) || (!result) || (!doomedEntry))
         return NS_ERROR_NULL_POINTER;
     // check if the request can be satisfied
     if (!mEnableMemoryDevice && !request->IsStreamBased())
         return NS_ERROR_FAILURE;
     if (!IsStorageEnabledForPolicy_Locked(request->StoragePolicy()))
         return NS_ERROR_FAILURE;
     // search active entries (including those not bound to device)
     nsCacheEntry *entry = mActiveEntries.GetEntry(&(request->mKey));
     CACHE_LOG_DEBUG(("Active entry for request %p is %p\n", request, entry));
     if (!entry) {
         // search cache devices for entry
         bool collision = false;
         entry = SearchCacheDevices(&(request->mKey), request->StoragePolicy(), &collision);
         CACHE_LOG_DEBUG(("Device search for request %p returned %p\n",
                          request, entry));
         // When there is a hashkey collision just refuse to cache it...
         if (collision) return NS_ERROR_CACHE_IN_USE;
         if (entry)  entry->MarkInitialized();
     } else {
         NS_ASSERTION(entry->IsActive(), "Inactive entry found in mActiveEntries!");
     }
     if (entry) {
         ++mCacheHits;
         entry->Fetched();
     } else {
         ++mCacheMisses;
     }
     if (entry &&
         ((request->AccessRequested() == nsICache::ACCESS_WRITE) ||
          ((request->StoragePolicy() != nsICache::STORE_OFFLINE) &&
           (entry->mExpirationTime <= SecondsFromPRTime(PR_Now()) &&
            request->WillDoomEntriesIfExpired()))))
     {
         // this is FORCE-WRITE request or the entry has expired
         // we doom entry without processing pending requests, but store it in
         // doomedEntry which causes pending requests to be processed below
         rv = DoomEntry_Internal(entry, false);
         *doomedEntry = entry;
         if (NS_FAILED(rv)) {
             // XXX what to do?  Increment FailedDooms counter?
         }
         entry = nullptr;
     }
     if (!entry) {
         if (! (request->AccessRequested() & nsICache::ACCESS_WRITE)) {
             // this is a READ-ONLY request
             rv = NS_ERROR_CACHE_KEY_NOT_FOUND;
             goto error;
         }
         entry = new nsCacheEntry(request->mKey,
                                  request->IsStreamBased(),
                                  request->StoragePolicy());
         if (!entry)
             return NS_ERROR_OUT_OF_MEMORY;
         if (request->IsPrivate())
             entry->MarkPrivate();
         entry->Fetched();
         ++mTotalEntries;
         // XXX  we could perform an early bind in some cases based on storage policy
     }
     if (!entry->IsActive()) {
         rv = mActiveEntries.AddEntry(entry);
         if (NS_FAILED(rv)) goto error;
         CACHE_LOG_DEBUG(("Added entry %p to mActiveEntries\n", entry));
         entry->MarkActive();  // mark entry active, because it's now in mActiveEntries
     }
     *result = entry;
     return NS_OK;
  error:
     *result = nullptr;
     delete entry;
     return rv;
 }
 nsCacheEntry *
 nsCacheService::SearchCacheDevices(nsCString * key, nsCacheStoragePolicy policy, bool *collision)
 {
     Telemetry::AutoTimer<Telemetry::CACHE_DEVICE_SEARCH_2> timer;
     nsCacheEntry * entry = nullptr;
     MOZ_EVENT_TRACER_NAME_OBJECT(key, key->BeginReading());
     eventtracer::AutoEventTracer searchCacheDevices(
         key,
         eventtracer::eExec,
         eventtracer::eDone,
         "net::cache::SearchCacheDevices");
     CACHE_LOG_DEBUG(("mMemoryDevice: 0x%p\n", mMemoryDevice));
     *collision = false;
     if ((policy == nsICache::STORE_ANYWHERE) || (policy == nsICache::STORE_IN_MEMORY)) {
         // If there is no memory device, then there is nothing to search...
         if (mMemoryDevice) {
             entry = mMemoryDevice->FindEntry(key, collision);
             CACHE_LOG_DEBUG(("Searching mMemoryDevice for key %s found: 0x%p, "
                              "collision: %d\n", key->get(), entry, collision));
         }
     }
     if (!entry &&
         ((policy == nsICache::STORE_ANYWHERE) || (policy == nsICache::STORE_ON_DISK))) {
         if (mEnableDiskDevice) {
             if (!mDiskDevice) {
                 nsresult rv = CreateDiskDevice();
                 if (NS_FAILED(rv))
                     return nullptr;
             }
             entry = mDiskDevice->FindEntry(key, collision);
         }
     }
     if (!entry && (policy == nsICache::STORE_OFFLINE ||
                    (policy == nsICache::STORE_ANYWHERE &&
                     gIOService->IsOffline()))) {
         if (mEnableOfflineDevice) {
             if (!mOfflineDevice) {
                 nsresult rv = CreateOfflineDevice();
                 if (NS_FAILED(rv))
                     return nullptr;
             }
             entry = mOfflineDevice->FindEntry(key, collision);
         }
     }
     return entry;
 }
 nsCacheDevice *
 nsCacheService::EnsureEntryHasDevice(nsCacheEntry * entry)
 {
     nsCacheDevice * device = entry->CacheDevice();
     // return device if found, possibly null if the entry is doomed i.e prevent
     // doomed entries to bind to a device (see e.g. bugs #548406 and #596443)
     if (device || entry->IsDoomed())  return device;
     int64_t predictedDataSize = entry->PredictedDataSize();
     if (entry->IsStreamData() && entry->IsAllowedOnDisk() && mEnableDiskDevice) {
         // this is the default
         if (!mDiskDevice) {
             (void)CreateDiskDevice();  // ignore the error (check for mDiskDevice instead)
         }
         if (mDiskDevice) {
             // Bypass the cache if Content-Length says the entry will be too big
             if (predictedDataSize != -1 &&
                 mDiskDevice->EntryIsTooBig(predictedDataSize)) {
                 DebugOnly<nsresult> rv = nsCacheService::DoomEntry(entry);
                 NS_ASSERTION(NS_SUCCEEDED(rv),"DoomEntry() failed.");
                 return nullptr;
             }
             entry->MarkBinding();  // enter state of binding
             nsresult rv = mDiskDevice->BindEntry(entry);
             entry->ClearBinding(); // exit state of binding
             if (NS_SUCCEEDED(rv))
                 device = mDiskDevice;
         }
     }
     // if we can't use mDiskDevice, try mMemoryDevice
     if (!device && mEnableMemoryDevice && entry->IsAllowedInMemory()) {
         if (!mMemoryDevice) {
             (void)CreateMemoryDevice();  // ignore the error (check for mMemoryDevice instead)
         }
         if (mMemoryDevice) {
             // Bypass the cache if Content-Length says entry will be too big
             if (predictedDataSize != -1 &&
                 mMemoryDevice->EntryIsTooBig(predictedDataSize)) {
                 DebugOnly<nsresult> rv = nsCacheService::DoomEntry(entry);
                 NS_ASSERTION(NS_SUCCEEDED(rv),"DoomEntry() failed.");
                 return nullptr;
             }
             entry->MarkBinding();  // enter state of binding
             nsresult rv = mMemoryDevice->BindEntry(entry);
             entry->ClearBinding(); // exit state of binding
             if (NS_SUCCEEDED(rv))
                 device = mMemoryDevice;
         }
     }
     if (!device && entry->IsStreamData() &&
         entry->IsAllowedOffline() && mEnableOfflineDevice) {
         if (!mOfflineDevice) {
             (void)CreateOfflineDevice(); // ignore the error (check for mOfflineDevice instead)
         }
         device = entry->CustomCacheDevice()
                ? entry->CustomCacheDevice()
                : mOfflineDevice;
         if (device) {
             entry->MarkBinding();
             nsresult rv = device->BindEntry(entry);
             entry->ClearBinding();
             if (NS_FAILED(rv))
                 device = nullptr;
         }
     }
     if (device)
         entry->SetCacheDevice(device);
     return device;
 }
 nsresult
 nsCacheService::DoomEntry(nsCacheEntry * entry)
 {
     return gService->DoomEntry_Internal(entry, true);
 }
 nsresult
 nsCacheService::DoomEntry_Internal(nsCacheEntry * entry,
                                    bool doProcessPendingRequests)
 {
     if (entry->IsDoomed())  return NS_OK;
     CACHE_LOG_DEBUG(("Dooming entry %p\n", entry));
     nsresult  rv = NS_OK;
     entry->MarkDoomed();
     NS_ASSERTION(!entry->IsBinding(), "Dooming entry while binding device.");
     nsCacheDevice * device = entry->CacheDevice();
     if (device)  device->DoomEntry(entry);
     if (entry->IsActive()) {
         // remove from active entries
         mActiveEntries.RemoveEntry(entry);
         CACHE_LOG_DEBUG(("Removed entry %p from mActiveEntries\n", entry));
         entry->MarkInactive();
      }
     // put on doom list to wait for descriptors to close
     NS_ASSERTION(PR_CLIST_IS_EMPTY(entry), "doomed entry still on device list");
     PR_APPEND_LINK(entry, &mDoomedEntries);
     // handle pending requests only if we're supposed to
     if (doProcessPendingRequests) {
         // tell pending requests to get on with their lives...
         rv = ProcessPendingRequests(entry);
         // All requests have been removed, but there may still be open descriptors
         if (entry->IsNotInUse()) {
             DeactivateEntry(entry); // tell device to get rid of it
         }
     }
     return rv;
 }
 void
 nsCacheService::OnProfileShutdown(bool cleanse)
 {
     if (!gService)  return;
     if (!gService->mInitialized) {
         // The cache service has been shut down, but someone is still holding
         // a reference to it. Ignore this call.
         return;
     }
     {
         nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_ONPROFILESHUTDOWN));
         gService->mClearingEntries = true;
         gService->DoomActiveEntries(nullptr);
     }
     gService->CloseAllStreams();
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_ONPROFILESHUTDOWN));
     gService->ClearDoomList();
     // Make sure to wait for any pending cache-operations before
     // proceeding with destructive actions (bug #620660)
     (void) SyncWithCacheIOThread();
     if (gService->mDiskDevice && gService->mEnableDiskDevice) {
         if (cleanse)
             gService->mDiskDevice->EvictEntries(nullptr);
         gService->mDiskDevice->Shutdown();
     }
     gService->mEnableDiskDevice = false;
     if (gService->mOfflineDevice && gService->mEnableOfflineDevice) {
         if (cleanse)
             gService->mOfflineDevice->EvictEntries(nullptr);
         gService->mOfflineDevice->Shutdown();
     }
     gService->mCustomOfflineDevices.Enumerate(
         &nsCacheService::ShutdownCustomCacheDeviceEnum, nullptr);
     gService->mEnableOfflineDevice = false;
     if (gService->mMemoryDevice) {
         // clear memory cache
         gService->mMemoryDevice->EvictEntries(nullptr);
     }
     gService->mClearingEntries = false;
 }
 void
 nsCacheService::OnProfileChanged()
 {
     if (!gService)  return;
     CACHE_LOG_DEBUG(("nsCacheService::OnProfileChanged"));
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_ONPROFILECHANGED));
     gService->mEnableDiskDevice    = gService->mObserver->DiskCacheEnabled();
     gService->mEnableOfflineDevice = gService->mObserver->OfflineCacheEnabled();
     gService->mEnableMemoryDevice  = gService->mObserver->MemoryCacheEnabled();
     if (gService->mDiskDevice) {
         gService->mDiskDevice->SetCacheParentDirectory(gService->mObserver->DiskCacheParentDirectory());
         gService->mDiskDevice->SetCapacity(gService->mObserver->DiskCacheCapacity());
         // XXX initialization of mDiskDevice could be made lazily, if mEnableDiskDevice is false
         nsresult rv = gService->mDiskDevice->Init();
         if (NS_FAILED(rv)) {
             NS_ERROR("nsCacheService::OnProfileChanged: Re-initializing disk device failed");
             gService->mEnableDiskDevice = false;
             // XXX delete mDiskDevice?
         }
     }
     if (gService->mOfflineDevice) {
         gService->mOfflineDevice->SetCacheParentDirectory(gService->mObserver->OfflineCacheParentDirectory());
         gService->mOfflineDevice->SetCapacity(gService->mObserver->OfflineCacheCapacity());
         // XXX initialization of mOfflineDevice could be made lazily, if mEnableOfflineDevice is false
         nsresult rv = gService->mOfflineDevice->InitWithSqlite(gService->mStorageService);
         if (NS_FAILED(rv)) {
             NS_ERROR("nsCacheService::OnProfileChanged: Re-initializing offline device failed");
             gService->mEnableOfflineDevice = false;
             // XXX delete mOfflineDevice?
         }
     }
     // If memoryDevice exists, reset its size to the new profile
     if (gService->mMemoryDevice) {
         if (gService->mEnableMemoryDevice) {
             // make sure that capacity is reset to the right value
             int32_t capacity = gService->mObserver->MemoryCacheCapacity();
             CACHE_LOG_DEBUG(("Resetting memory device capacity to %d\n",
                              capacity));
             gService->mMemoryDevice->SetCapacity(capacity);
         } else {
             // tell memory device to evict everything
             CACHE_LOG_DEBUG(("memory device disabled\n"));
             gService->mMemoryDevice->SetCapacity(0);
             // Don't delete memory device, because some entries may be active still...
         }
     }
 }
 void
 nsCacheService::SetDiskCacheEnabled(bool    enabled)
 {
     if (!gService)  return;
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_SETDISKCACHEENABLED));
     gService->mEnableDiskDevice = enabled;
 }
 void
 nsCacheService::SetDiskCacheCapacity(int32_t  capacity)
 {
     if (!gService)  return;
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_SETDISKCACHECAPACITY));
     if (gService->mDiskDevice) {
         gService->mDiskDevice->SetCapacity(capacity);
     }
     gService->mEnableDiskDevice = gService->mObserver->DiskCacheEnabled();
 }
 void
 nsCacheService::SetDiskCacheMaxEntrySize(int32_t  maxSize)
 {
     if (!gService)  return;
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_SETDISKCACHEMAXENTRYSIZE));
     if (gService->mDiskDevice) {
         gService->mDiskDevice->SetMaxEntrySize(maxSize);
     }
 }
 void
 nsCacheService::SetMemoryCacheMaxEntrySize(int32_t  maxSize)
 {
     if (!gService)  return;
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_SETMEMORYCACHEMAXENTRYSIZE));
     if (gService->mMemoryDevice) {
         gService->mMemoryDevice->SetMaxEntrySize(maxSize);
     }
 }
 void
 nsCacheService::SetOfflineCacheEnabled(bool    enabled)
 {
     if (!gService)  return;
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_SETOFFLINECACHEENABLED));
     gService->mEnableOfflineDevice = enabled;
 }
 void
 nsCacheService::SetOfflineCacheCapacity(int32_t  capacity)
 {
     if (!gService)  return;
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_SETOFFLINECACHECAPACITY));
     if (gService->mOfflineDevice) {
         gService->mOfflineDevice->SetCapacity(capacity);
     }
     gService->mEnableOfflineDevice = gService->mObserver->OfflineCacheEnabled();
 }
 void
 nsCacheService::SetMemoryCache()
 {
     if (!gService)  return;
     CACHE_LOG_DEBUG(("nsCacheService::SetMemoryCache"));
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_SETMEMORYCACHE));
     gService->mEnableMemoryDevice = gService->mObserver->MemoryCacheEnabled();
     if (gService->mEnableMemoryDevice) {
         if (gService->mMemoryDevice) {
             int32_t capacity = gService->mObserver->MemoryCacheCapacity();
             // make sure that capacity is reset to the right value
             CACHE_LOG_DEBUG(("Resetting memory device capacity to %d\n",
                              capacity));
             gService->mMemoryDevice->SetCapacity(capacity);
         }
     } else {
         if (gService->mMemoryDevice) {
             // tell memory device to evict everything
             CACHE_LOG_DEBUG(("memory device disabled\n"));
             gService->mMemoryDevice->SetCapacity(0);
             // Don't delete memory device, because some entries may be active still...
         }
     }
 }
 /******************************************************************************
  * static methods for nsCacheEntryDescriptor
  *****************************************************************************/
 void
 nsCacheService::CloseDescriptor(nsCacheEntryDescriptor * descriptor)
 {
     // ask entry to remove descriptor
     nsCacheEntry * entry = descriptor->CacheEntry();
     bool doomEntry;
     bool stillActive = entry->RemoveDescriptor(descriptor, &doomEntry);
     if (!entry->IsValid()) {
         gService->ProcessPendingRequests(entry);
     }
     if (doomEntry) {
         gService->DoomEntry_Internal(entry, true);
         return;
     }
     if (!stillActive) {
         gService->DeactivateEntry(entry);
     }
 }
 nsresult
 nsCacheService::GetFileForEntry(nsCacheEntry *         entry,
                                 nsIFile **             result)
 {
     nsCacheDevice * device = gService->EnsureEntryHasDevice(entry);
     if (!device)  return  NS_ERROR_UNEXPECTED;
     return device->GetFileForEntry(entry, result);
 }
 nsresult
 nsCacheService::OpenInputStreamForEntry(nsCacheEntry *     entry,
                                         nsCacheAccessMode  mode,
                                         uint32_t           offset,
                                         nsIInputStream  ** result)
 {
     nsCacheDevice * device = gService->EnsureEntryHasDevice(entry);
     if (!device)  return  NS_ERROR_UNEXPECTED;
     return device->OpenInputStreamForEntry(entry, mode, offset, result);
 }
 nsresult
 nsCacheService::OpenOutputStreamForEntry(nsCacheEntry *     entry,
                                          nsCacheAccessMode  mode,
                                          uint32_t           offset,
                                          nsIOutputStream ** result)
 {
     nsCacheDevice * device = gService->EnsureEntryHasDevice(entry);
     if (!device)  return  NS_ERROR_UNEXPECTED;
     return device->OpenOutputStreamForEntry(entry, mode, offset, result);
 }
 nsresult
 nsCacheService::OnDataSizeChange(nsCacheEntry * entry, int32_t deltaSize)
 {
     nsCacheDevice * device = gService->EnsureEntryHasDevice(entry);
     if (!device)  return  NS_ERROR_UNEXPECTED;
     return device->OnDataSizeChange(entry, deltaSize);
 }
 void
 nsCacheService::LockAcquired()
 {
     MutexAutoLock lock(mTimeStampLock);
     mLockAcquiredTimeStamp = TimeStamp::Now();
 }
 void
 nsCacheService::LockReleased()
 {
     MutexAutoLock lock(mTimeStampLock);
     mLockAcquiredTimeStamp = TimeStamp();
 }
 void
 nsCacheService::Lock(mozilla::Telemetry::ID mainThreadLockerID)
 {
     mozilla::Telemetry::ID lockerID;
     mozilla::Telemetry::ID generalID;
     if (NS_IsMainThread()) {
         lockerID = mainThreadLockerID;
         generalID = mozilla::Telemetry::CACHE_SERVICE_LOCK_WAIT_MAINTHREAD_2;
     } else {
         lockerID = mozilla::Telemetry::HistogramCount;
         generalID = mozilla::Telemetry::CACHE_SERVICE_LOCK_WAIT_2;
     }
     TimeStamp start(TimeStamp::Now());
     MOZ_EVENT_TRACER_WAIT(nsCacheService::gService, "net::cache::lock");
     gService->mLock.Lock();
     gService->LockAcquired();
     TimeStamp stop(TimeStamp::Now());
     MOZ_EVENT_TRACER_EXEC(nsCacheService::gService, "net::cache::lock");
     // Telemetry isn't thread safe on its own, but this is OK because we're
     // protecting it with the cache lock.
     if (lockerID != mozilla::Telemetry::HistogramCount) {
         mozilla::Telemetry::AccumulateTimeDelta(lockerID, start, stop);
     }
     mozilla::Telemetry::AccumulateTimeDelta(generalID, start, stop);
 }
 void
 nsCacheService::Unlock()
 {
     gService->mLock.AssertCurrentThreadOwns();
     nsTArray<nsISupports*> doomed;
     doomed.SwapElements(gService->mDoomedObjects);
     gService->LockReleased();
     gService->mLock.Unlock();
     MOZ_EVENT_TRACER_DONE(nsCacheService::gService, "net::cache::lock");
     for (uint32_t i = 0; i < doomed.Length(); ++i)
         doomed[i]->Release();
 }
 void
 nsCacheService::ReleaseObject_Locked(nsISupports * obj,
                                      nsIEventTarget * target)
 {
     gService->mLock.AssertCurrentThreadOwns();
     bool isCur;
     if (!target || (NS_SUCCEEDED(target->IsOnCurrentThread(&isCur)) && isCur)) {
         gService->mDoomedObjects.AppendElement(obj);
     } else {
         NS_ProxyRelease(target, obj);
     }
 }
 nsresult
 nsCacheService::SetCacheElement(nsCacheEntry * entry, nsISupports * element)
 {
     entry->SetData(element);
     entry->TouchData();
     return NS_OK;
 }
 nsresult
 nsCacheService::ValidateEntry(nsCacheEntry * entry)
 {
     nsCacheDevice * device = gService->EnsureEntryHasDevice(entry);
     if (!device)  return  NS_ERROR_UNEXPECTED;
     entry->MarkValid();
     nsresult rv = gService->ProcessPendingRequests(entry);
     NS_ASSERTION(rv == NS_OK, "ProcessPendingRequests failed.");
     // XXX what else should be done?
     return rv;
 }
 int32_t
 nsCacheService::CacheCompressionLevel()
 {
     int32_t level = gService->mObserver->CacheCompressionLevel();
     return level;
 }
 void
 nsCacheService::DeactivateEntry(nsCacheEntry * entry)
 {
     CACHE_LOG_DEBUG(("Deactivating entry %p\n", entry));
     nsresult  rv = NS_OK;
     NS_ASSERTION(entry->IsNotInUse(), "### deactivating an entry while in use!");
     nsCacheDevice * device = nullptr;
     if (mMaxDataSize < entry->DataSize() )     mMaxDataSize = entry->DataSize();
     if (mMaxMetaSize < entry->MetaDataSize() ) mMaxMetaSize = entry->MetaDataSize();
     if (entry->IsDoomed()) {
         // remove from Doomed list
         PR_REMOVE_AND_INIT_LINK(entry);
     } else if (entry->IsActive()) {
         // remove from active entries
         mActiveEntries.RemoveEntry(entry);
         CACHE_LOG_DEBUG(("Removed deactivated entry %p from mActiveEntries\n",
                          entry));
         entry->MarkInactive();
         // bind entry if necessary to store meta-data
         device = EnsureEntryHasDevice(entry);
         if (!device) {
             CACHE_LOG_DEBUG(("DeactivateEntry: unable to bind active "
                              "entry %p\n",
                              entry));
             NS_WARNING("DeactivateEntry: unable to bind active entry\n");
             return;
         }
     } else {
         // if mInitialized == false,
         // then we're shutting down and this state is okay.
         NS_ASSERTION(!mInitialized, "DeactivateEntry: bad cache entry state.");
     }
     device = entry->CacheDevice();
     if (device) {
         rv = device->DeactivateEntry(entry);
         if (NS_FAILED(rv)) {
             // increment deactivate failure count
             ++mDeactivateFailures;
         }
     } else {
         // increment deactivating unbound entry statistic
         ++mDeactivatedUnboundEntries;
         delete entry; // because no one else will
     }
 }
 nsresult
 nsCacheService::ProcessPendingRequests(nsCacheEntry * entry)
 {
     mozilla::eventtracer::AutoEventTracer tracer(
         entry,
         eventtracer::eExec,
         eventtracer::eDone,
         "net::cache::ProcessPendingRequests");
     nsresult            rv = NS_OK;
     nsCacheRequest *    request = (nsCacheRequest *)PR_LIST_HEAD(&entry->mRequestQ);
     nsCacheRequest *    nextRequest;
     bool                newWriter = false;
     CACHE_LOG_DEBUG(("ProcessPendingRequests for %sinitialized %s %salid entry %p\n",
                     (entry->IsInitialized()?"" : "Un"),
                     (entry->IsDoomed()?"DOOMED" : ""),
                     (entry->IsValid()? "V":"Inv"), entry));
     if (request == &entry->mRequestQ)  return NS_OK;    // no queued requests
     if (!entry->IsDoomed() && entry->IsInvalid()) {
         // 1st descriptor closed w/o MarkValid()
         NS_ASSERTION(PR_CLIST_IS_EMPTY(&entry->mDescriptorQ), "shouldn't be here with open descriptors");
 #if DEBUG
         // verify no ACCESS_WRITE requests(shouldn't have any of these)
         while (request != &entry->mRequestQ) {
             NS_ASSERTION(request->AccessRequested() != nsICache::ACCESS_WRITE,
                          "ACCESS_WRITE request should have been given a new entry");
             request = (nsCacheRequest *)PR_NEXT_LINK(request);
         }
         request = (nsCacheRequest *)PR_LIST_HEAD(&entry->mRequestQ);
 #endif
         // find first request with ACCESS_READ_WRITE (if any) and promote it to 1st writer
         while (request != &entry->mRequestQ) {
             if (request->AccessRequested() == nsICache::ACCESS_READ_WRITE) {
                 newWriter = true;
                 CACHE_LOG_DEBUG(("  promoting request %p to 1st writer\n", request));
                 break;
             }
             request = (nsCacheRequest *)PR_NEXT_LINK(request);
         }
         if (request == &entry->mRequestQ)   // no requests asked for ACCESS_READ_WRITE, back to top
             request = (nsCacheRequest *)PR_LIST_HEAD(&entry->mRequestQ);
         // XXX what should we do if there are only READ requests in queue?
         // XXX serialize their accesses, give them only read access, but force them to check validate flag?
         // XXX or do readers simply presume the entry is valid
         // See fix for bug #467392 below
     }
     nsCacheAccessMode  accessGranted = nsICache::ACCESS_NONE;
     while (request != &entry->mRequestQ) {
         nextRequest = (nsCacheRequest *)PR_NEXT_LINK(request);
         CACHE_LOG_DEBUG(("  %sync request %p for %p\n",
                         (request->mListener?"As":"S"), request, entry));
         if (request->mListener) {
             // Async request
             PR_REMOVE_AND_INIT_LINK(request);
             if (entry->IsDoomed()) {
                 rv = ProcessRequest(request, false, nullptr);
                 if (rv == NS_ERROR_CACHE_WAIT_FOR_VALIDATION)
                     rv = NS_OK;
                 else
                     delete request;
                 if (NS_FAILED(rv)) {
                     // XXX what to do?
                 }
             } else if (entry->IsValid() || newWriter) {
                 rv = entry->RequestAccess(request, &accessGranted);
                 NS_ASSERTION(NS_SUCCEEDED(rv),
                              "if entry is valid, RequestAccess must succeed.");
                 // XXX if (newWriter)  NS_ASSERTION( accessGranted == request->AccessRequested(), "why not?");
                 // entry->CreateDescriptor dequeues request, and queues descriptor
                 nsICacheEntryDescriptor *descriptor = nullptr;
                 rv = entry->CreateDescriptor(request,
                                              accessGranted,
                                              &descriptor);
                 // post call to listener to report error or descriptor
                 rv = NotifyListener(request, descriptor, accessGranted, rv);
                 delete request;
                 if (NS_FAILED(rv)) {
                     // XXX what to do?
                 }
             } else {
                 // read-only request to an invalid entry - need to wait for
                 // the entry to become valid so we post an event to process
                 // the request again later (bug #467392)
                 nsCOMPtr<nsIRunnable> ev =
                     new nsProcessRequestEvent(request);
                 rv = DispatchToCacheIOThread(ev);
                 if (NS_FAILED(rv)) {
                     delete request; // avoid leak
                 }
             }
         } else {
             // Synchronous request
             request->WakeUp();
         }
         if (newWriter)  break;  // process remaining requests after validation
         request = nextRequest;
     }
     return NS_OK;
 }
 bool
 nsCacheService::IsDoomListEmpty()
 {
     nsCacheEntry * entry = (nsCacheEntry *)PR_LIST_HEAD(&mDoomedEntries);
     return &mDoomedEntries == entry;
 }
 void
 nsCacheService::ClearDoomList()
 {
     nsCacheEntry * entry = (nsCacheEntry *)PR_LIST_HEAD(&mDoomedEntries);
     while (entry != &mDoomedEntries) {
         nsCacheEntry * next = (nsCacheEntry *)PR_NEXT_LINK(entry);
         entry->DetachDescriptors();
         DeactivateEntry(entry);
         entry = next;
     }
 }
 PLDHashOperator
 nsCacheService::GetActiveEntries(PLDHashTable *    table,
                                  PLDHashEntryHdr * hdr,
                                  uint32_t          number,
                                  void *            arg)
 {
     static_cast<nsVoidArray *>(arg)->AppendElement(
         ((nsCacheEntryHashTableEntry *)hdr)->cacheEntry);
     return PL_DHASH_NEXT;
 }
 struct ActiveEntryArgs
 {
     nsTArray<nsCacheEntry*>* mActiveArray;
     nsCacheService::DoomCheckFn mCheckFn;
 };
 void
 nsCacheService::DoomActiveEntries(DoomCheckFn check)
 {
     nsAutoTArray<nsCacheEntry*, 8> array;
     ActiveEntryArgs args = { &array, check };
     mActiveEntries.VisitEntries(RemoveActiveEntry, &args);
     uint32_t count = array.Length();
     for (uint32_t i=0; i < count; ++i)
         DoomEntry_Internal(array[i], true);
 }
 PLDHashOperator
 nsCacheService::RemoveActiveEntry(PLDHashTable *    table,
                                   PLDHashEntryHdr * hdr,
                                   uint32_t          number,
                                   void *            arg)
 {
     nsCacheEntry * entry = ((nsCacheEntryHashTableEntry *)hdr)->cacheEntry;
     NS_ASSERTION(entry, "### active entry = nullptr!");
     ActiveEntryArgs* args = static_cast<ActiveEntryArgs*>(arg);
     if (args->mCheckFn && !args->mCheckFn(entry))
         return PL_DHASH_NEXT;
     NS_ASSERTION(args->mActiveArray, "### array = nullptr!");
     args->mActiveArray->AppendElement(entry);
     // entry is being removed from the active entry list
     entry->MarkInactive();
     return PL_DHASH_REMOVE; // and continue enumerating
 }
 void
 nsCacheService::CloseAllStreams()
 {
     nsTArray<nsRefPtr<nsCacheEntryDescriptor::nsInputStreamWrapper> > inputs;
     nsTArray<nsRefPtr<nsCacheEntryDescriptor::nsOutputStreamWrapper> > outputs;
     {
         nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_CLOSEALLSTREAMS));
         nsVoidArray entries;
 #if DEBUG
         // make sure there is no active entry
         mActiveEntries.VisitEntries(GetActiveEntries, &entries);
         NS_ASSERTION(entries.Count() == 0, "Bad state");
 #endif
         // Get doomed entries
         nsCacheEntry * entry = (nsCacheEntry *)PR_LIST_HEAD(&mDoomedEntries);
         while (entry != &mDoomedEntries) {
             nsCacheEntry * next = (nsCacheEntry *)PR_NEXT_LINK(entry);
             entries.AppendElement(entry);
             entry = next;
         }
         // Iterate through all entries and collect input and output streams
         for (int32_t i = 0 ; i < entries.Count() ; i++) {
             entry = static_cast<nsCacheEntry *>(entries.ElementAt(i));
             nsTArray<nsRefPtr<nsCacheEntryDescriptor> > descs;
             entry->GetDescriptors(descs);
             for (uint32_t j = 0 ; j < descs.Length() ; j++) {
                 if (descs[j]->mOutputWrapper)
                     outputs.AppendElement(descs[j]->mOutputWrapper);
                 for (int32_t k = 0 ; k < descs[j]->mInputWrappers.Count() ; k++)
                     inputs.AppendElement(static_cast<
                         nsCacheEntryDescriptor::nsInputStreamWrapper *>(
                         descs[j]->mInputWrappers[k]));
             }
         }
     }
     uint32_t i;
     for (i = 0 ; i < inputs.Length() ; i++)
         inputs[i]->Close();
     for (i = 0 ; i < outputs.Length() ; i++)
         outputs[i]->Close();
 }
 bool
 nsCacheService::GetClearingEntries()
 {
     AssertOwnsLock();
     return gService->mClearingEntries;
 }
 // static
 void nsCacheService::GetCacheBaseDirectoty(nsIFile ** result)
 {
     *result = nullptr;
     if (!gService || !gService->mObserver)
         return;
     nsCOMPtr<nsIFile> directory =
         gService->mObserver->DiskCacheParentDirectory();
     if (!directory)
         return;
     directory->Clone(result);
 }
 // static
 void nsCacheService::GetDiskCacheDirectory(nsIFile ** result)
 {
     nsCOMPtr<nsIFile> directory;
     GetCacheBaseDirectoty(getter_AddRefs(directory));
     if (!directory)
         return;
     nsresult rv = directory->AppendNative(NS_LITERAL_CSTRING("Cache"));
     if (NS_FAILED(rv))
         return;
     directory.forget(result);
 }
 // static
 void nsCacheService::GetAppCacheDirectory(nsIFile ** result)
 {
     nsCOMPtr<nsIFile> directory;
     GetCacheBaseDirectoty(getter_AddRefs(directory));
     if (!directory)
         return;
     nsresult rv = directory->AppendNative(NS_LITERAL_CSTRING("OfflineCache"));
     if (NS_FAILED(rv))
         return;
     directory.forget(result);
 }
 #if defined(PR_LOGGING)
 void
 nsCacheService::LogCacheStatistics()
 {
     uint32_t hitPercentage = (uint32_t)((((double)mCacheHits) /
         ((double)(mCacheHits + mCacheMisses))) * 100);
     CACHE_LOG_ALWAYS(("\nCache Service Statistics:\n\n"));
     CACHE_LOG_ALWAYS(("    TotalEntries   = %d\n", mTotalEntries));
     CACHE_LOG_ALWAYS(("    Cache Hits     = %d\n", mCacheHits));
     CACHE_LOG_ALWAYS(("    Cache Misses   = %d\n", mCacheMisses));
     CACHE_LOG_ALWAYS(("    Cache Hit %%    = %d%%\n", hitPercentage));
     CACHE_LOG_ALWAYS(("    Max Key Length = %d\n", mMaxKeyLength));
     CACHE_LOG_ALWAYS(("    Max Meta Size  = %d\n", mMaxMetaSize));
     CACHE_LOG_ALWAYS(("    Max Data Size  = %d\n", mMaxDataSize));
     CACHE_LOG_ALWAYS(("\n"));
     CACHE_LOG_ALWAYS(("    Deactivate Failures         = %d\n",
                       mDeactivateFailures));
     CACHE_LOG_ALWAYS(("    Deactivated Unbound Entries = %d\n",
                       mDeactivatedUnboundEntries));
 }
 #endif
 nsresult
 nsCacheService::SetDiskSmartSize()
 {
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_SETDISKSMARTSIZE));
     if (!gService) return NS_ERROR_NOT_AVAILABLE;
     return gService->SetDiskSmartSize_Locked();
 }
 nsresult
 nsCacheService::SetDiskSmartSize_Locked()
 {
     nsresult rv;
     if (mozilla::net::CacheObserver::UseNewCache()) {
         return NS_ERROR_NOT_AVAILABLE;
     }
     if (!mObserver->DiskCacheParentDirectory())
         return NS_ERROR_NOT_AVAILABLE;
     if (!mDiskDevice)
         return NS_ERROR_NOT_AVAILABLE;
     if (!mObserver->SmartSizeEnabled())
         return NS_ERROR_NOT_AVAILABLE;
     nsAutoString cachePath;
     rv = mObserver->DiskCacheParentDirectory()->GetPath(cachePath);
     if (NS_SUCCEEDED(rv)) {
         nsCOMPtr<nsIRunnable> event =
             new nsGetSmartSizeEvent(cachePath, mDiskDevice->getCacheSize(),
                                     mObserver->ShouldUseOldMaxSmartSize());
         DispatchToCacheIOThread(event);
     } else {
         return NS_ERROR_FAILURE;
     }
     return NS_OK;
 }
 void
 nsCacheService::MoveOrRemoveDiskCache(nsIFile *aOldCacheDir,
                                       nsIFile *aNewCacheDir,
                                       const char *aCacheSubdir)
 {
     bool same;
     if (NS_FAILED(aOldCacheDir->Equals(aNewCacheDir, &same)) || same)
         return;
     nsCOMPtr<nsIFile> aOldCacheSubdir;
     aOldCacheDir->Clone(getter_AddRefs(aOldCacheSubdir));
     nsresult rv = aOldCacheSubdir->AppendNative(
         nsDependentCString(aCacheSubdir));
     if (NS_FAILED(rv))
         return;
     bool exists;
     if (NS_FAILED(aOldCacheSubdir->Exists(&exists)) || !exists)
         return;
     nsCOMPtr<nsIFile> aNewCacheSubdir;
     aNewCacheDir->Clone(getter_AddRefs(aNewCacheSubdir));
     rv = aNewCacheSubdir->AppendNative(nsDependentCString(aCacheSubdir));
     if (NS_FAILED(rv))
         return;
     nsAutoCString newPath;
     rv = aNewCacheSubdir->GetNativePath(newPath);
     if (NS_FAILED(rv))
         return;
     if (NS_SUCCEEDED(aNewCacheSubdir->Exists(&exists)) && !exists) {
         // New cache directory does not exist, try to move the old one here
         // rename needs an empty target directory
         // Make sure the parent of the target sub-dir exists
         rv = aNewCacheDir->Create(nsIFile::DIRECTORY_TYPE, 0777);
         if (NS_SUCCEEDED(rv) || NS_ERROR_FILE_ALREADY_EXISTS == rv) {
             nsAutoCString oldPath;
             rv = aOldCacheSubdir->GetNativePath(oldPath);
             if (NS_FAILED(rv))
                 return;
             if (rename(oldPath.get(), newPath.get()) == 0)
                 return;
         }
     }
     // Delay delete by 1 minute to avoid IO thrash on startup.
     nsDeleteDir::DeleteDir(aOldCacheSubdir, false, 60000);
 }
 static bool
 IsEntryPrivate(nsCacheEntry* entry)
 {
     return entry->IsPrivate();
 }
 void
 nsCacheService::LeavePrivateBrowsing()
 {
     nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_LEAVEPRIVATEBROWSING));
     gService->DoomActiveEntries(IsEntryPrivate);
     if (gService->mMemoryDevice) {
         // clear memory cache
         gService->mMemoryDevice->EvictPrivateEntries();
     }
 }
 MOZ_DEFINE_MALLOC_SIZE_OF(DiskCacheDeviceMallocSizeOf)
 NS_IMETHODIMP
 nsCacheService::CollectReports(nsIHandleReportCallback* aHandleReport,
                                nsISupports* aData)
 {
     size_t disk = 0;
     if (mDiskDevice) {
         nsCacheServiceAutoLock
             lock(LOCK_TELEM(NSCACHESERVICE_DISKDEVICEHEAPSIZE));
         disk = mDiskDevice->SizeOfIncludingThis(DiskCacheDeviceMallocSizeOf);
     }
     size_t memory = mMemoryDevice ? mMemoryDevice->TotalSize() : 0;
 #define REPORT(_path, _amount, _desc)                                         \
     do {                                                                      \
         nsresult rv;                                                          \
         rv = aHandleReport->Callback(EmptyCString(),                          \
                                      NS_LITERAL_CSTRING(_path),               \
                                      KIND_HEAP, UNITS_BYTES, _amount,         \
                                      NS_LITERAL_CSTRING(_desc), aData);       \
         NS_ENSURE_SUCCESS(rv, rv);                                            \
     } while (0)
     REPORT("explicit/network/disk-cache", disk,
            "Memory used by the network disk cache.");
     REPORT("explicit/network/memory-cache", memory,
            "Memory used by the network memory cache.");
     return NS_OK;
 }

The Tor Browser / annotate

netwerk/cache/nsCacheService.cpp@a63d609f5ebe (annotated)

netwerk/cache/nsCacheService.cpp