diff -r 000000000000 -r 6474c204b198 netwerk/cache2/CacheObserver.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/netwerk/cache2/CacheObserver.cpp Wed Dec 31 06:09:35 2014 +0100 @@ -0,0 +1,498 @@ +/* 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 "CacheObserver.h" + +#include "CacheStorageService.h" +#include "CacheFileIOManager.h" +#include "LoadContextInfo.h" +#include "nsICacheStorage.h" +#include "nsIObserverService.h" +#include "mozIApplicationClearPrivateDataParams.h" +#include "mozilla/Services.h" +#include "mozilla/Preferences.h" +#include "nsServiceManagerUtils.h" +#include "prsystem.h" +#include +#include + +namespace mozilla { +namespace net { + +CacheObserver* CacheObserver::sSelf = nullptr; + +static uint32_t const kDefaultUseNewCache = 0; // Don't use the new cache by default +uint32_t CacheObserver::sUseNewCache = kDefaultUseNewCache; + +static bool sUseNewCacheTemp = false; // Temp trigger to not lose early adopters + +static int32_t const kAutoDeleteCacheVersion = -1; // Auto-delete off by default +static int32_t sAutoDeleteCacheVersion = kAutoDeleteCacheVersion; + +static int32_t const kDefaultHalfLifeExperiment = -1; // Disabled +int32_t CacheObserver::sHalfLifeExperiment = kDefaultHalfLifeExperiment; + +static uint32_t const kDefaultHalfLifeHours = 6; // 6 hours +uint32_t CacheObserver::sHalfLifeHours = kDefaultHalfLifeHours; + +static bool const kDefaultUseDiskCache = true; +bool CacheObserver::sUseDiskCache = kDefaultUseDiskCache; + +static bool const kDefaultUseMemoryCache = true; +bool CacheObserver::sUseMemoryCache = kDefaultUseMemoryCache; + +static uint32_t const kDefaultMetadataMemoryLimit = 250; // 0.25 MB +uint32_t CacheObserver::sMetadataMemoryLimit = kDefaultMetadataMemoryLimit; + +static int32_t const kDefaultMemoryCacheCapacity = -1; // autodetect +int32_t CacheObserver::sMemoryCacheCapacity = kDefaultMemoryCacheCapacity; +// Cache of the calculated memory capacity based on the system memory size +int32_t CacheObserver::sAutoMemoryCacheCapacity = -1; + +static uint32_t const kDefaultDiskCacheCapacity = 250 * 1024; // 250 MB +uint32_t CacheObserver::sDiskCacheCapacity = kDefaultDiskCacheCapacity; + +static bool const kDefaultSmartCacheSizeEnabled = false; +bool CacheObserver::sSmartCacheSizeEnabled = kDefaultSmartCacheSizeEnabled; + +static uint32_t const kDefaultMaxMemoryEntrySize = 4 * 1024; // 4 MB +uint32_t CacheObserver::sMaxMemoryEntrySize = kDefaultMaxMemoryEntrySize; + +static uint32_t const kDefaultMaxDiskEntrySize = 50 * 1024; // 50 MB +uint32_t CacheObserver::sMaxDiskEntrySize = kDefaultMaxDiskEntrySize; + +static uint32_t const kDefaultCompressionLevel = 1; +uint32_t CacheObserver::sCompressionLevel = kDefaultCompressionLevel; + +static bool kDefaultSanitizeOnShutdown = false; +bool CacheObserver::sSanitizeOnShutdown = kDefaultSanitizeOnShutdown; + +static bool kDefaultClearCacheOnShutdown = false; +bool CacheObserver::sClearCacheOnShutdown = kDefaultClearCacheOnShutdown; + +NS_IMPL_ISUPPORTS(CacheObserver, + nsIObserver, + nsISupportsWeakReference) + +// static +nsresult +CacheObserver::Init() +{ + if (sSelf) { + return NS_OK; + } + + nsCOMPtr obs = mozilla::services::GetObserverService(); + if (!obs) { + return NS_ERROR_UNEXPECTED; + } + + sSelf = new CacheObserver(); + NS_ADDREF(sSelf); + + obs->AddObserver(sSelf, "prefservice:after-app-defaults", true); + obs->AddObserver(sSelf, "profile-do-change", true); + obs->AddObserver(sSelf, "sessionstore-windows-restored", true); + obs->AddObserver(sSelf, "profile-before-change", true); + obs->AddObserver(sSelf, "xpcom-shutdown", true); + obs->AddObserver(sSelf, "last-pb-context-exited", true); + obs->AddObserver(sSelf, "webapps-clear-data", true); + obs->AddObserver(sSelf, "memory-pressure", true); + + return NS_OK; +} + +// static +nsresult +CacheObserver::Shutdown() +{ + if (!sSelf) { + return NS_ERROR_NOT_INITIALIZED; + } + + NS_RELEASE(sSelf); + return NS_OK; +} + +void +CacheObserver::AttachToPreferences() +{ + sAutoDeleteCacheVersion = mozilla::Preferences::GetInt( + "browser.cache.auto_delete_cache_version", kAutoDeleteCacheVersion); + + mozilla::Preferences::AddUintVarCache( + &sUseNewCache, "browser.cache.use_new_backend", kDefaultUseNewCache); + mozilla::Preferences::AddBoolVarCache( + &sUseNewCacheTemp, "browser.cache.use_new_backend_temp", false); + + mozilla::Preferences::AddBoolVarCache( + &sUseDiskCache, "browser.cache.disk.enable", kDefaultUseDiskCache); + mozilla::Preferences::AddBoolVarCache( + &sUseMemoryCache, "browser.cache.memory.enable", kDefaultUseMemoryCache); + + mozilla::Preferences::AddUintVarCache( + &sMetadataMemoryLimit, "browser.cache.disk.metadata_memory_limit", kDefaultMetadataMemoryLimit); + + mozilla::Preferences::AddUintVarCache( + &sDiskCacheCapacity, "browser.cache.disk.capacity", kDefaultDiskCacheCapacity); + mozilla::Preferences::AddBoolVarCache( + &sSmartCacheSizeEnabled, "browser.cache.disk.smart_size.enabled", kDefaultSmartCacheSizeEnabled); + mozilla::Preferences::AddIntVarCache( + &sMemoryCacheCapacity, "browser.cache.memory.capacity", kDefaultMemoryCacheCapacity); + + mozilla::Preferences::AddUintVarCache( + &sMaxDiskEntrySize, "browser.cache.disk.max_entry_size", kDefaultMaxDiskEntrySize); + mozilla::Preferences::AddUintVarCache( + &sMaxMemoryEntrySize, "browser.cache.memory.max_entry_size", kDefaultMaxMemoryEntrySize); + + // http://mxr.mozilla.org/mozilla-central/source/netwerk/cache/nsCacheEntryDescriptor.cpp#367 + mozilla::Preferences::AddUintVarCache( + &sCompressionLevel, "browser.cache.compression_level", kDefaultCompressionLevel); + + mozilla::Preferences::GetComplex( + "browser.cache.disk.parent_directory", NS_GET_IID(nsIFile), + getter_AddRefs(mCacheParentDirectoryOverride)); + + // First check the default value. If it is at -1, the experient + // is turned off. If it is at 0, then use the user pref value + // instead. + sHalfLifeExperiment = mozilla::Preferences::GetDefaultInt( + "browser.cache.frecency_experiment", kDefaultHalfLifeExperiment); + + if (sHalfLifeExperiment == 0) { + // Default preferences indicate we want to run the experiment, + // hence read the user value. + sHalfLifeExperiment = mozilla::Preferences::GetInt( + "browser.cache.frecency_experiment", sHalfLifeExperiment); + } + + if (sHalfLifeExperiment == 0) { + // The experiment has not yet been initialized but is engaged, do + // the initialization now. + srand(time(NULL)); + sHalfLifeExperiment = (rand() % 4) + 1; + // Store the experiemnt value, since we need it not to change between + // browser sessions. + mozilla::Preferences::SetInt( + "browser.cache.frecency_experiment", sHalfLifeExperiment); + } + + switch (sHalfLifeExperiment) { + case 1: // The experiment is engaged + sHalfLifeHours = 6; + break; + case 2: + sHalfLifeHours = 24; + break; + case 3: + sHalfLifeHours = 7 * 24; + break; + case 4: + sHalfLifeHours = 50 * 24; + break; + + case -1: + default: // The experiment is off or broken + sHalfLifeExperiment = -1; + sHalfLifeHours = std::max(1U, std::min(1440U, mozilla::Preferences::GetUint( + "browser.cache.frecency_half_life_hours", kDefaultHalfLifeHours))); + break; + } + + mozilla::Preferences::AddBoolVarCache( + &sSanitizeOnShutdown, "privacy.sanitize.sanitizeOnShutdown", kDefaultSanitizeOnShutdown); + mozilla::Preferences::AddBoolVarCache( + &sClearCacheOnShutdown, "privacy.clearOnShutdown.cache", kDefaultClearCacheOnShutdown); +} + +// static +uint32_t const CacheObserver::MemoryCacheCapacity() +{ + if (sMemoryCacheCapacity >= 0) + return sMemoryCacheCapacity << 10; + + if (sAutoMemoryCacheCapacity != -1) + return sAutoMemoryCacheCapacity; + + static uint64_t bytes = PR_GetPhysicalMemorySize(); + // 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; + + int32_t capacity = 0; + 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 <<= 20; + } + + // Result is in bytes. + return sAutoMemoryCacheCapacity = capacity; +} + +void CacheObserver::SchduleAutoDelete() +{ + // Auto-delete not set + if (sAutoDeleteCacheVersion == -1) + return; + + // Don't autodelete the same version of the cache user has setup + // to use. + int32_t activeVersion = UseNewCache() ? 1 : 0; + if (sAutoDeleteCacheVersion == activeVersion) + return; + + CacheStorageService::WipeCacheDirectory(sAutoDeleteCacheVersion); +} + +// static +bool const CacheObserver::UseNewCache() +{ + uint32_t useNewCache = sUseNewCache; + + if (sUseNewCacheTemp) + useNewCache = 1; + + switch (useNewCache) { + case 0: // use the old cache backend + return false; + + case 1: // use the new cache backend + return true; + } + + return true; +} + +// static +void +CacheObserver::SetDiskCacheCapacity(uint32_t aCapacity) +{ + sDiskCacheCapacity = aCapacity >> 10; + + if (!sSelf) { + return; + } + + if (NS_IsMainThread()) { + sSelf->StoreDiskCacheCapacity(); + } else { + nsCOMPtr event = + NS_NewRunnableMethod(sSelf, &CacheObserver::StoreDiskCacheCapacity); + NS_DispatchToMainThread(event); + } +} + +void +CacheObserver::StoreDiskCacheCapacity() +{ + mozilla::Preferences::SetInt("browser.cache.disk.capacity", + sDiskCacheCapacity); +} + +// static +void CacheObserver::ParentDirOverride(nsIFile** aDir) +{ + if (NS_WARN_IF(!aDir)) + return; + + *aDir = nullptr; + + if (!sSelf) + return; + if (!sSelf->mCacheParentDirectoryOverride) + return; + + sSelf->mCacheParentDirectoryOverride->Clone(aDir); +} + +namespace { // anon + +class CacheStorageEvictHelper +{ +public: + nsresult Run(mozIApplicationClearPrivateDataParams* aParams); + +private: + uint32_t mAppId; + nsresult ClearStorage(bool const aPrivate, + bool const aInBrowser, + bool const aAnonymous); +}; + +nsresult +CacheStorageEvictHelper::Run(mozIApplicationClearPrivateDataParams* aParams) +{ + nsresult rv; + + rv = aParams->GetAppId(&mAppId); + NS_ENSURE_SUCCESS(rv, rv); + + bool aBrowserOnly; + rv = aParams->GetBrowserOnly(&aBrowserOnly); + NS_ENSURE_SUCCESS(rv, rv); + + MOZ_ASSERT(mAppId != nsILoadContextInfo::UNKNOWN_APP_ID); + + // Clear all [private X anonymous] combinations + rv = ClearStorage(false, aBrowserOnly, false); + NS_ENSURE_SUCCESS(rv, rv); + rv = ClearStorage(false, aBrowserOnly, true); + NS_ENSURE_SUCCESS(rv, rv); + rv = ClearStorage(true, aBrowserOnly, false); + NS_ENSURE_SUCCESS(rv, rv); + rv = ClearStorage(true, aBrowserOnly, true); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult +CacheStorageEvictHelper::ClearStorage(bool const aPrivate, + bool const aInBrowser, + bool const aAnonymous) +{ + nsresult rv; + + nsRefPtr info = GetLoadContextInfo( + aPrivate, mAppId, aInBrowser, aAnonymous); + + nsCOMPtr storage; + nsRefPtr service = CacheStorageService::Self(); + NS_ENSURE_TRUE(service, NS_ERROR_FAILURE); + + // Clear disk storage + rv = service->DiskCacheStorage(info, false, getter_AddRefs(storage)); + NS_ENSURE_SUCCESS(rv, rv); + rv = storage->AsyncEvictStorage(nullptr); + NS_ENSURE_SUCCESS(rv, rv); + + // Clear memory storage + rv = service->MemoryCacheStorage(info, getter_AddRefs(storage)); + NS_ENSURE_SUCCESS(rv, rv); + rv = storage->AsyncEvictStorage(nullptr); + NS_ENSURE_SUCCESS(rv, rv); + + if (!aInBrowser) { + rv = ClearStorage(aPrivate, true, aAnonymous); + NS_ENSURE_SUCCESS(rv, rv); + } + + return NS_OK; +} + +} // anon + +// static +bool const CacheObserver::EntryIsTooBig(int64_t aSize, bool aUsingDisk) +{ + // If custom limit is set, check it. + int64_t preferredLimit = aUsingDisk + ? static_cast(sMaxDiskEntrySize) << 10 + : static_cast(sMaxMemoryEntrySize) << 10; + + if (preferredLimit != -1 && aSize > preferredLimit) + return true; + + // Otherwise (or when in the custom limit), check limit based on the global + // limit. It's 1/8 (>> 3) of the respective capacity. + int64_t derivedLimit = aUsingDisk + ? (static_cast(DiskCacheCapacity() >> 3)) + : (static_cast(MemoryCacheCapacity() >> 3)); + + if (aSize > derivedLimit) + return true; + + return false; +} + +NS_IMETHODIMP +CacheObserver::Observe(nsISupports* aSubject, + const char* aTopic, + const char16_t* aData) +{ + if (!strcmp(aTopic, "prefservice:after-app-defaults")) { + CacheFileIOManager::Init(); + return NS_OK; + } + + if (!strcmp(aTopic, "profile-do-change")) { + AttachToPreferences(); + CacheFileIOManager::Init(); + CacheFileIOManager::OnProfile(); + return NS_OK; + } + + if (!strcmp(aTopic, "sessionstore-windows-restored")) { + SchduleAutoDelete(); + return NS_OK; + } + + if (!strcmp(aTopic, "profile-before-change")) { + nsRefPtr service = CacheStorageService::Self(); + if (service) + service->Shutdown(); + + return NS_OK; + } + + if (!strcmp(aTopic, "xpcom-shutdown")) { + nsRefPtr service = CacheStorageService::Self(); + if (service) + service->Shutdown(); + + CacheFileIOManager::Shutdown(); + return NS_OK; + } + + if (!strcmp(aTopic, "last-pb-context-exited")) { + nsRefPtr service = CacheStorageService::Self(); + if (service) + service->DropPrivateBrowsingEntries(); + + return NS_OK; + } + + if (!strcmp(aTopic, "webapps-clear-data")) { + nsCOMPtr params = + do_QueryInterface(aSubject); + if (!params) { + NS_ERROR("'webapps-clear-data' notification's subject should be a mozIApplicationClearPrivateDataParams"); + return NS_ERROR_UNEXPECTED; + } + + CacheStorageEvictHelper helper; + nsresult rv = helper.Run(params); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; + } + + if (!strcmp(aTopic, "memory-pressure")) { + nsRefPtr service = CacheStorageService::Self(); + if (service) + service->PurgeFromMemory(nsICacheStorageService::PURGE_EVERYTHING); + + return NS_OK; + } + + MOZ_ASSERT(false, "Missing observer handler"); + return NS_OK; +} + +} // net +} // mozilla