NetworkProcessSoup.cpp [plain text]
#include "config.h"
#if ENABLE(NETWORK_PROCESS)
#include "NetworkProcess.h"
#include "NetworkProcessCreationParameters.h"
#include "ResourceCachesToClear.h"
#include "WebCookieManager.h"
#include <WebCore/CertificateInfo.h>
#include <WebCore/FileSystem.h>
#include <WebCore/NotImplemented.h>
#include <WebCore/ResourceHandle.h>
#include <WebCore/SoupNetworkSession.h>
#include <libsoup/soup.h>
#include <wtf/gobject/GRefPtr.h>
#include <wtf/gobject/GUniquePtr.h>
using namespace WebCore;
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());
}
static uint64_t getMemorySize()
{
static uint64_t kDefaultMemorySize = 512;
#if !OS(WINDOWS)
long pageSize = sysconf(_SC_PAGESIZE);
if (pageSize == -1)
return kDefaultMemorySize;
long physPages = sysconf(_SC_PHYS_PAGES);
if (physPages == -1)
return kDefaultMemorySize;
return ((pageSize / 1024) * physPages) / 1024;
#else
return kDefaultMemorySize;
#endif
}
void NetworkProcess::userPreferredLanguagesChanged(const Vector<String>& languages)
{
SoupNetworkSession::defaultSession().setAcceptLanguages(languages);
}
void NetworkProcess::platformInitializeNetworkProcess(const NetworkProcessCreationParameters& parameters)
{
ASSERT(!parameters.diskCacheDirectory.isEmpty());
GRefPtr<SoupCache> soupCache = adoptGRef(soup_cache_new(parameters.diskCacheDirectory.utf8().data(), SOUP_CACHE_SINGLE_USER));
SoupNetworkSession::defaultSession().setCache(soupCache.get());
soup_cache_load(soupCache.get());
if (!parameters.cookiePersistentStoragePath.isEmpty()) {
supplement<WebCookieManager>()->setCookiePersistentStorage(parameters.cookiePersistentStoragePath,
parameters.cookiePersistentStorageType);
}
supplement<WebCookieManager>()->setHTTPCookieAcceptPolicy(parameters.cookieAcceptPolicy);
if (!parameters.languages.isEmpty())
userPreferredLanguagesChanged(parameters.languages);
setIgnoreTLSErrors(parameters.ignoreTLSErrors);
}
void NetworkProcess::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;
SoupCache* cache = SoupNetworkSession::defaultSession().cache();
uint64_t diskFreeSize = getCacheDiskFreeSize(cache) / 1024 / 1024;
uint64_t memSize = getMemorySize();
calculateCacheSizes(cacheModel, memSize, diskFreeSize,
cacheTotalCapacity, cacheMinDeadCapacity, cacheMaxDeadCapacity, deadDecodedDataDeletionInterval,
pageCacheCapacity, urlCacheMemoryCapacity, urlCacheDiskCapacity);
if (urlCacheDiskCapacity > soup_cache_get_max_size(cache))
soup_cache_set_max_size(cache, urlCacheDiskCapacity);
}
void NetworkProcess::setIgnoreTLSErrors(bool ignoreTLSErrors)
{
ResourceHandle::setIgnoreSSLErrors(ignoreTLSErrors);
}
void NetworkProcess::allowSpecificHTTPSCertificateForHost(const CertificateInfo& certificateInfo, const String& host)
{
ResourceHandle::setClientCertificate(host, certificateInfo.certificate());
}
void NetworkProcess::clearCacheForAllOrigins(uint32_t cachesToClear)
{
if (cachesToClear == InMemoryResourceCachesOnly)
return;
soup_cache_clear(SoupNetworkSession::defaultSession().cache());
}
void NetworkProcess::platformTerminate()
{
notImplemented();
}
}
#endif