void WebProcess::platformInitializeWebProcess(WebProcessCreationParameters&& parameters) { #if ENABLE(SECCOMP_FILTERS) { #if PLATFORM(EFL) SeccompFiltersWebProcessEfl seccompFilters(parameters); #elif PLATFORM(GTK) SeccompFiltersWebProcessGtk seccompFilters(parameters); #endif seccompFilters.initialize(); } #endif if (usesNetworkProcess()) return; ASSERT(!parameters.diskCacheDirectory.isEmpty()); // We used to use the given cache directory for the soup cache, but now we use a subdirectory to avoid // conflicts with other cache files in the same directory. Remove the old cache files if they still exist. WebCore::SoupNetworkSession::defaultSession().clearCache(WebCore::directoryName(parameters.diskCacheDirectory)); #if ENABLE(NETWORK_CACHE) // When network cache is enabled, the disk cache directory is the network process one. CString diskCachePath = WebCore::pathByAppendingComponent(WebCore::directoryName(parameters.diskCacheDirectory), "webkit").utf8(); #else CString diskCachePath = parameters.diskCacheDirectory.utf8(); #endif GRefPtr<SoupCache> soupCache = adoptGRef(soup_cache_new(diskCachePath.data(), SOUP_CACHE_SINGLE_USER)); WebCore::SoupNetworkSession::defaultSession().setCache(soupCache.get()); // Set an initial huge max_size for the SoupCache so the call to soup_cache_load() won't evict any cached // resource. The final size of the cache will be set by NetworkProcess::platformSetCacheModel(). unsigned initialMaxSize = soup_cache_get_max_size(soupCache.get()); soup_cache_set_max_size(soupCache.get(), G_MAXUINT); soup_cache_load(soupCache.get()); soup_cache_set_max_size(soupCache.get(), initialMaxSize); if (!parameters.cookiePersistentStoragePath.isEmpty()) { supplement<WebCookieManager>()->setCookiePersistentStorage(parameters.cookiePersistentStoragePath, parameters.cookiePersistentStorageType); } supplement<WebCookieManager>()->setHTTPCookieAcceptPolicy(parameters.cookieAcceptPolicy); if (!parameters.languages.isEmpty()) setSoupSessionAcceptLanguage(parameters.languages); setIgnoreTLSErrors(parameters.ignoreTLSErrors); WebCore::addLanguageChangeObserver(this, languageChanged); }
static void cache_up (GrlNetWc *self) { SoupCache *cache; GrlNetWcPrivate *priv = self->priv; gchar *dir; GRL_DEBUG ("cache up"); dir = g_dir_make_tmp ("grilo-plugin-cache-XXXXXX", NULL); if (!dir) return; cache = soup_cache_new (dir, SOUP_CACHE_SINGLE_USER); g_free (dir); soup_session_add_feature (priv->session, SOUP_SESSION_FEATURE (cache)); if (priv->cache_size) { soup_cache_set_max_size (cache, priv->cache_size * 1024 * 1024); } g_object_unref (cache); }
void WebProcess::platformSetCacheModel(CacheModel cacheModel) { unsigned cacheTotalCapacity = 0; unsigned cacheMinDeadCapacity = 0; unsigned cacheMaxDeadCapacity = 0; double deadDecodedDataDeletionInterval = 0; unsigned pageCacheCapacity = 0; unsigned long urlCacheMemoryCapacity = 0; unsigned long urlCacheDiskCapacity = 0; SoupSession* session = WebCore::ResourceHandle::defaultSession(); SoupCache* cache = SOUP_CACHE(soup_session_get_feature(session, SOUP_TYPE_CACHE)); uint64_t diskFreeSize = getCacheDiskFreeSize(cache) / 1024 / 1024; uint64_t memSize = getMemorySize(); calculateCacheSizes(cacheModel, memSize, diskFreeSize, cacheTotalCapacity, cacheMinDeadCapacity, cacheMaxDeadCapacity, deadDecodedDataDeletionInterval, pageCacheCapacity, urlCacheMemoryCapacity, urlCacheDiskCapacity); WebCore::memoryCache()->setCapacities(cacheMinDeadCapacity, cacheMaxDeadCapacity, cacheTotalCapacity); WebCore::memoryCache()->setDeadDecodedDataDeletionInterval(deadDecodedDataDeletionInterval); WebCore::pageCache()->setCapacity(pageCacheCapacity); if (urlCacheDiskCapacity > soup_cache_get_max_size(cache)) soup_cache_set_max_size(cache, urlCacheDiskCapacity); }
void WebProcess::platformSetCacheModel(CacheModel cacheModel) { unsigned cacheTotalCapacity = 0; unsigned cacheMinDeadCapacity = 0; unsigned cacheMaxDeadCapacity = 0; auto deadDecodedDataDeletionInterval = std::chrono::seconds { 0 }; unsigned pageCacheCapacity = 0; unsigned long urlCacheMemoryCapacity = 0; unsigned long urlCacheDiskCapacity = 0; uint64_t diskFreeSize = 0; SoupCache* cache = nullptr; if (!usesNetworkProcess()) { cache = WebCore::SoupNetworkSession::defaultSession().cache(); diskFreeSize = getCacheDiskFreeSize(cache) / 1024 / 1024; } uint64_t memSize = getMemorySize(); calculateCacheSizes(cacheModel, memSize, diskFreeSize, cacheTotalCapacity, cacheMinDeadCapacity, cacheMaxDeadCapacity, deadDecodedDataDeletionInterval, pageCacheCapacity, urlCacheMemoryCapacity, urlCacheDiskCapacity); WebCore::memoryCache()->setDisabled(cacheModel == CacheModelDocumentViewer); WebCore::memoryCache()->setCapacities(cacheMinDeadCapacity, cacheMaxDeadCapacity, cacheTotalCapacity); WebCore::memoryCache()->setDeadDecodedDataDeletionInterval(deadDecodedDataDeletionInterval); WebCore::pageCache()->setCapacity(pageCacheCapacity); if (!usesNetworkProcess()) { if (urlCacheDiskCapacity > soup_cache_get_max_size(cache)) soup_cache_set_max_size(cache, urlCacheDiskCapacity); } }
/** * grl_net_wc_set_cache_size: * @self: a #GrlNetWc instance * @cache_size: size of cache (in Mb) * * Sets the new maximum size of cache, in Megabytes. Default value is 10. Using * 0 means no cache will be done. * * Since: 0.1.12 **/ void grl_net_wc_set_cache_size (GrlNetWc *self, guint size) { g_return_if_fail (GRL_IS_NET_WC (self)); if (self->priv->cache_size == size) return; self->priv->cache_size = size; SoupSessionFeature *cache = soup_session_get_feature (self->priv->session, SOUP_TYPE_CACHE); if (!cache) return; soup_cache_set_max_size (SOUP_CACHE (cache), size * 1024 * 1024); }
void WebProcess::platformSetCacheModel(CacheModel cacheModel) { unsigned cacheTotalCapacity = 0; unsigned cacheMinDeadCapacity = 0; unsigned cacheMaxDeadCapacity = 0; auto deadDecodedDataDeletionInterval = std::chrono::seconds { 0 }; unsigned pageCacheSize = 0; unsigned long urlCacheMemoryCapacity = 0; unsigned long urlCacheDiskCapacity = 0; uint64_t diskFreeSize = 0; SoupCache* cache = nullptr; if (!usesNetworkProcess()) { cache = WebCore::SoupNetworkSession::defaultSession().cache(); diskFreeSize = getCacheDiskFreeSize(cache) / WTF::MB; } uint64_t memSize = WTF::ramSize() / WTF::MB; calculateCacheSizes(cacheModel, memSize, diskFreeSize, cacheTotalCapacity, cacheMinDeadCapacity, cacheMaxDeadCapacity, deadDecodedDataDeletionInterval, pageCacheSize, urlCacheMemoryCapacity, urlCacheDiskCapacity); auto& memoryCache = WebCore::MemoryCache::singleton(); memoryCache.setDisabled(cacheModel == CacheModelDocumentViewer); memoryCache.setCapacities(cacheMinDeadCapacity, cacheMaxDeadCapacity, cacheTotalCapacity); memoryCache.setDeadDecodedDataDeletionInterval(deadDecodedDataDeletionInterval); WebCore::PageCache::singleton().setMaxSize(pageCacheSize); #if PLATFORM(GTK) WebCore::PageCache::singleton().setShouldClearBackingStores(true); #endif if (!usesNetworkProcess()) { if (urlCacheDiskCapacity > soup_cache_get_max_size(cache)) soup_cache_set_max_size(cache, urlCacheDiskCapacity); } }