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);
}
}
