WebProcessSoup.cpp [plain text]
#include "config.h"
#include "WebProcess.h"
#if PLATFORM(EFL)
#include "SeccompFiltersWebProcessEfl.h"
#endif
#include "CertificateInfo.h"
#include "WebCookieManager.h"
#include "WebProcessCreationParameters.h"
#include <WebCore/FileSystem.h>
#include <WebCore/Language.h>
#include <WebCore/MemoryCache.h>
#include <WebCore/PageCache.h>
#include <WebCore/ResourceHandle.h>
#include <WebCore/SoupNetworkSession.h>
#include <libsoup/soup.h>
#include <wtf/RAMSize.h>
#include <wtf/glib/GRefPtr.h>
#include <wtf/glib/GUniquePtr.h>
namespace WebKit {
static uint64_t getCacheDiskFreeSize(SoupCache* cache)
{
ASSERT(cache);
GUniqueOutPtr<char> cacheDir;
g_object_get(G_OBJECT(cache), "cache-dir", &cacheDir.outPtr(), NULL);
if (!cacheDir)
return 0;
return WebCore::getVolumeFreeSizeForPath(cacheDir.get());
}
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);
}
}
void WebProcess::platformClearResourceCaches(ResourceCachesToClear cachesToClear)
{
if (cachesToClear == InMemoryResourceCachesOnly)
return;
if (usesNetworkProcess())
return;
soup_cache_clear(WebCore::SoupNetworkSession::defaultSession().cache());
}
static void setSoupSessionAcceptLanguage(const Vector<String>& languages)
{
WebCore::SoupNetworkSession::defaultSession().setAcceptLanguages(languages);
}
static void languageChanged(void*)
{
setSoupSessionAcceptLanguage(WebCore::userPreferredLanguages());
}
void WebProcess::platformInitializeWebProcess(WebProcessCreationParameters&& parameters)
{
#if ENABLE(SECCOMP_FILTERS)
{
#if PLATFORM(EFL)
SeccompFiltersWebProcessEfl seccompFilters(parameters);
#endif
seccompFilters.initialize();
}
#endif
if (usesNetworkProcess())
return;
ASSERT(!parameters.diskCacheDirectory.isEmpty());
WebCore::SoupNetworkSession::defaultSession().clearCache(WebCore::directoryName(parameters.diskCacheDirectory));
#if ENABLE(NETWORK_CACHE)
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());
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);
}
void WebProcess::platformTerminate()
{
if (!usesNetworkProcess())
WebCore::removeLanguageChangeObserver(this);
}
void WebProcess::setIgnoreTLSErrors(bool ignoreTLSErrors)
{
ASSERT(!usesNetworkProcess());
WebCore::ResourceHandle::setIgnoreSSLErrors(ignoreTLSErrors);
}
void WebProcess::allowSpecificHTTPSCertificateForHost(const WebCore::CertificateInfo& certificateInfo, const String& host)
{
ASSERT(!usesNetworkProcess());
WebCore::ResourceHandle::setClientCertificate(host, certificateInfo.certificate());
}
}