/* 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_ISUPPORTS2(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