зеркало из https://github.com/mozilla/gecko-dev.git
491 строка
14 KiB
C++
491 строка
14 KiB
C++
/* 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 <time.h>
|
|
#include <math.h>
|
|
|
|
namespace mozilla {
|
|
namespace net {
|
|
|
|
CacheObserver* CacheObserver::sSelf = nullptr;
|
|
|
|
static uint32_t const kDefaultUseNewCache = 1; // 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 kDefaultPreloadChunkCount = 4;
|
|
uint32_t CacheObserver::sPreloadChunkCount = kDefaultPreloadChunkCount;
|
|
|
|
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<nsIObserverService> 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(
|
|
&sPreloadChunkCount, "browser.cache.disk.preload_chunk_count", kDefaultPreloadChunkCount);
|
|
|
|
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;
|
|
}
|
|
|
|
// 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<nsIRunnable> 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<LoadContextInfo> info = GetLoadContextInfo(
|
|
aPrivate, mAppId, aInBrowser, aAnonymous);
|
|
|
|
nsCOMPtr<nsICacheStorage> storage;
|
|
nsRefPtr<CacheStorageService> 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<int64_t>(sMaxDiskEntrySize) << 10
|
|
: static_cast<int64_t>(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<int64_t>(DiskCacheCapacity() >> 3))
|
|
: (static_cast<int64_t>(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")) {
|
|
uint32_t activeVersion = UseNewCache() ? 1 : 0;
|
|
CacheStorageService::CleaupCacheDirectories(sAutoDeleteCacheVersion, activeVersion);
|
|
return NS_OK;
|
|
}
|
|
|
|
if (!strcmp(aTopic, "profile-before-change")) {
|
|
nsRefPtr<CacheStorageService> service = CacheStorageService::Self();
|
|
if (service)
|
|
service->Shutdown();
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
if (!strcmp(aTopic, "xpcom-shutdown")) {
|
|
nsRefPtr<CacheStorageService> service = CacheStorageService::Self();
|
|
if (service)
|
|
service->Shutdown();
|
|
|
|
CacheFileIOManager::Shutdown();
|
|
return NS_OK;
|
|
}
|
|
|
|
if (!strcmp(aTopic, "last-pb-context-exited")) {
|
|
nsRefPtr<CacheStorageService> service = CacheStorageService::Self();
|
|
if (service)
|
|
service->DropPrivateBrowsingEntries();
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
if (!strcmp(aTopic, "webapps-clear-data")) {
|
|
nsCOMPtr<mozIApplicationClearPrivateDataParams> 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<CacheStorageService> service = CacheStorageService::Self();
|
|
if (service)
|
|
service->PurgeFromMemory(nsICacheStorageService::PURGE_EVERYTHING);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
MOZ_ASSERT(false, "Missing observer handler");
|
|
return NS_OK;
|
|
}
|
|
|
|
} // net
|
|
} // mozilla
|