Changeset 106920 in webkit

Timestamp:

Feb 7, 2012 3:42:39 AM (12 years ago)

Author:

commit-queue@webkit.org

Message:

[Qt][WK2] Compute and set cache capacities using the current CacheModel
​https://bugs.webkit.org/show_bug.cgi?id=73918

Patch by Michael Brüning <​michael.bruning@nokia.com> on 2012-02-07
Reviewed by Kenneth Rohde Christiansen.

Source/WebCore:

No new tests. (Not applicable)

Added OS-specific implementation for retrieving the free disk space.

• platform/FileSystem.h:

(WebCore):

• platform/qt/FileSystemQt.cpp:

(WebCore::getVolumeFreeSizeForPath):
(WebCore):

Source/WebKit2:

First part of the implementation. The next steps are the implementation
of the API for the Qt WebKit 2 port and the hybrid memory and disk cache.

• Shared/WebProcessCreationParameters.cpp:

(WebKit::WebProcessCreationParameters::encode):
(WebKit::WebProcessCreationParameters::decode):

• Shared/WebProcessCreationParameters.h:

(WebProcessCreationParameters):

• UIProcess/qt/WebContextQt.cpp:

(WebKit::defaultDiskCacheDirectory):
(WebKit):
(WebKit::WebContext::platformInitializeWebProcess):

• WebProcess/qt/WebProcessQt.cpp:

(WebKit::physicalMemorySizeInBytes):
(WebKit):
(WebKit::WebProcess::platformSetCacheModel):
(WebKit::WebProcess::platformInitializeWebProcess):

Location:

trunk/Source

Files:

• WebCore/ChangeLog (modified) (1 diff)
• WebCore/platform/FileSystem.h (modified) (1 diff)
• WebCore/platform/qt/FileSystemQt.cpp (modified) (2 diffs)
• WebKit2/ChangeLog (modified) (1 diff)
• WebKit2/Shared/WebProcessCreationParameters.cpp (modified) (2 diffs)
• WebKit2/Shared/WebProcessCreationParameters.h (modified) (1 diff)
• WebKit2/UIProcess/qt/WebContextQt.cpp (modified) (2 diffs)
• WebKit2/WebProcess/qt/WebProcessQt.cpp (modified) (5 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2012-02-07  Michael Brüning  <michael.bruning@nokia.com>
+
+        [Qt][WK2] Compute and set cache capacities using the current CacheModel
+        https://bugs.webkit.org/show_bug.cgi?id=73918
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        No new tests. (Not applicable)
+
+        Added OS-specific implementation for retrieving the free disk space.
+
+        * platform/FileSystem.h:
+        (WebCore):
+        * platform/qt/FileSystemQt.cpp:
+        (WebCore::getVolumeFreeSizeForPath):
+        (WebCore):
+
 2012-02-07  Kenneth Rohde Christiansen  <kenneth@webkit.org>
 

trunk/Source/WebCore/platform/FileSystem.h

@@ -199 +199 @@
 String filenameForDisplay(const String&);
 CString applicationDirectoryPath();
+#endif
+#if PLATFORM(GTK) || PLATFORM(QT)
 uint64_t getVolumeFreeSizeForPath(const char*);
 #endif

trunk/Source/WebCore/platform/qt/FileSystemQt.cpp

@@ -40 +40 @@
 #include <QFileInfo>
 #include <QTemporaryFile>
+#include <sys/statvfs.h>
 #include <wtf/text/CString.h>
 
@@ -191 +192 @@
 }
 
+uint64_t getVolumeFreeSizeForPath(const char* path)
+{
+#if defined(Q_OS_WIN)
+    ULARGE_INTEGER freeBytesToCaller;
+    BOOL result = GetDiskFreeSpaceExW((LPCWSTR)path, &freeBytesToCaller, 0, 0);
+    if (!result)
+        return 0;
+    return static_cast<uint64_t>freeBytesToCaller.QuadPart;
+#else
+    struct statvfs volumeInfo;
+    if (statvfs(path, &volumeInfo))
+        return 0;
+
+    return static_cast<uint64_t>(volumeInfo.f_bavail) * static_cast<uint64_t>(volumeInfo.f_frsize);
+#endif
+}
+
 int writeToFile(PlatformFileHandle handle, const char* data, int length)
 {

trunk/Source/WebKit2/ChangeLog

@@ +1 @@
+2012-02-07  Michael Brüning  <michael.bruning@nokia.com>
+
+        [Qt][WK2] Compute and set cache capacities using the current CacheModel
+        https://bugs.webkit.org/show_bug.cgi?id=73918
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        First part of the implementation. The next steps are the implementation
+        of the API for the Qt WebKit 2 port and the hybrid memory and disk cache.
+
+        * Shared/WebProcessCreationParameters.cpp:
+        (WebKit::WebProcessCreationParameters::encode):
+        (WebKit::WebProcessCreationParameters::decode):
+        * Shared/WebProcessCreationParameters.h:
+        (WebProcessCreationParameters):
+        * UIProcess/qt/WebContextQt.cpp:
+        (WebKit::defaultDiskCacheDirectory):
+        (WebKit):
+        (WebKit::WebContext::platformInitializeWebProcess):
+        * WebProcess/qt/WebProcessQt.cpp:
+        (WebKit::physicalMemorySizeInBytes):
+        (WebKit):
+        (WebKit::WebProcess::platformSetCacheModel):
+        (WebKit::WebProcess::platformInitializeWebProcess):
+
 2012-02-06  Shinya Kawanaka  <shinyak@google.com>
 

trunk/Source/WebKit2/Shared/WebProcessCreationParameters.cpp

@@ -99 +99 @@
 #if PLATFORM(QT)
     encoder->encode(cookieStorageDirectory);
+    encoder->encode(diskCacheDirectory);
 #endif
 
@@ -196 +197 @@
     if (!decoder->decode(parameters.cookieStorageDirectory))
         return false;
+    if (!decoder->decode(parameters.diskCacheDirectory))
+        return false;
 #endif
 

trunk/Source/WebKit2/Shared/WebProcessCreationParameters.h

@@ -122 +122 @@
 #if PLATFORM(QT)
     String cookieStorageDirectory;
+    String diskCacheDirectory;
 #endif
 

trunk/Source/WebKit2/UIProcess/qt/WebContextQt.cpp

@@ -58 +58 @@
 }
 
+static String defaultDiskCacheDirectory()
+{
+    static String s_defaultDiskCacheDirectory;
+
+    if (!s_defaultDiskCacheDirectory.isEmpty())
+        return s_defaultDiskCacheDirectory;
+
+    s_defaultDiskCacheDirectory = WebCore::pathByAppendingComponent(defaultDataLocation(), "cache/");
+    WebCore::makeAllDirectories(s_defaultDiskCacheDirectory);
+    return s_defaultDiskCacheDirectory;
+}
+
 static QString s_defaultDatabaseDirectory;
 static QString s_defaultLocalStorageDirectory;
@@ -70 +82 @@
     qRegisterMetaType<QProcess::ExitStatus>("QProcess::ExitStatus");
     parameters.cookieStorageDirectory = defaultDataLocation();
+    parameters.diskCacheDirectory = defaultDiskCacheDirectory();
+
 #if ENABLE(GEOLOCATION)
     static WebGeolocationProviderQt* location = WebGeolocationProviderQt::create(toAPI(geolocationManagerProxy()));

trunk/Source/WebKit2/WebProcess/qt/WebProcessQt.cpp

@@ -1 +1 @@
 /*
  * Copyright (C) 2010 Apple Inc. All rights reserved.
+ * Copyright (C) 2011, 2012 Nokia Corporation and/or its subsidiary(-ies)
  *
  * Redistribution and use in source and binary forms, with or without
@@ -36 +37 @@
 #include <QNetworkAccessManager>
 #include <QNetworkCookieJar>
+#include <QNetworkDiskCache>
 #include <WebCore/CookieJarQt.h>
+#include <WebCore/FileSystem.h>
+#include <WebCore/MemoryCache.h>
 #include <WebCore/PageCache.h>
 #include <WebCore/RuntimeEnabledFeatures.h>
@@ -42 +46 @@
 #if defined(Q_OS_MACX)
 #include <dispatch/dispatch.h>
+#include <mach/host_info.h>
+#include <mach/mach.h>
+#include <mach/mach_error.h>
+#elif defined(Q_OS_WIN)
+
+#else
+#include <unistd.h>
 #endif
 
@@ -48 +59 @@
 namespace WebKit {
 
-static const int DefaultPageCacheCapacity = 20;
+static uint64_t physicalMemorySizeInBytes()
+{
+    static uint64_t physicalMemorySize = 0;
 
-void WebProcess::platformSetCacheModel(CacheModel)
+    if (!physicalMemorySize) {
+#if defined(Q_OS_MACX)
+        host_basic_info_data_t hostInfo;
+        mach_port_t host = mach_host_self();
+        mach_msg_type_number_t count = HOST_BASIC_INFO_COUNT;
+        kern_return_t r = host_info(host, HOST_BASIC_INFO, (host_info_t)&hostInfo, &count);
+        mach_port_deallocate(mach_task_self(), host);
+
+        if (r == KERN_SUCCESS)
+            physicalMemorySize = hostInfo.max_mem;
+
+#elif defined(Q_OS_WIN)
+        MEMORYSTATUSEX statex;
+        statex.dwLength = sizeof(statex);
+        GlobalMemoryStatusEx(&statex);
+        physicalMemorySize = static_cast<uint64_t>(statex.ullTotalPhys);
+
+#else
+        long pageSize = sysconf(_SC_PAGESIZE);
+        long numberOfPages = sysconf(_SC_PHYS_PAGES);
+
+        if (pageSize > 0 && numberOfPages > 0)
+            physicalMemorySize = static_cast<uint64_t>(pageSize) * static_cast<uint64_t>(numberOfPages);
+
+#endif
+    }
+    return physicalMemorySize;
+}
+
+void WebProcess::platformSetCacheModel(CacheModel cacheModel)
 {
-    // FIXME: see bug 73918
-    pageCache()->setCapacity(DefaultPageCacheCapacity);
+    QNetworkDiskCache* diskCache = qobject_cast<QNetworkDiskCache*>(m_networkAccessManager->cache());
+    ASSERT(diskCache);
+
+    ASSERT(WebCore::platformInfo());
+    uint64_t physicalMemorySizeInMegabytes = physicalMemorySizeInBytes() / 1024 / 1024;
+
+    // The Mac port of WebKit2 uses a fudge factor of 1000 here to account for misalignment, however,
+    // that tends to overestimate the memory quite a bit (1 byte misalignment ~ 48 MiB misestimation).
+    // We use 1024 * 1023 for now to keep the estimation error down to +/- ~1 MiB.
+    uint64_t freeVolumeSpace = WebCore::getVolumeFreeSizeForPath(diskCache->cacheDirectory().toAscii().constData()) / 1024 / 1023;
+
+    // The following variables are initialised to 0 because WebProcess::calculateCacheSizes might not
+    // set them in some rare cases.
+    unsigned cacheTotalCapacity = 0;
+    unsigned cacheMinDeadCapacity = 0;
+    unsigned cacheMaxDeadCapacity = 0;
+    double deadDecodedDataDeletionInterval = 0;
+    unsigned pageCacheCapacity = 0;
+    unsigned long urlCacheMemoryCapacity = 0;
+    unsigned long urlCacheDiskCapacity = 0;
+
+    calculateCacheSizes(cacheModel, physicalMemorySizeInMegabytes, freeVolumeSpace,
+        cacheTotalCapacity, cacheMinDeadCapacity, cacheMaxDeadCapacity, deadDecodedDataDeletionInterval,
+        pageCacheCapacity, urlCacheMemoryCapacity, urlCacheDiskCapacity);
+
+    memoryCache()->setCapacities(cacheMinDeadCapacity, cacheMaxDeadCapacity, cacheTotalCapacity);
+    memoryCache()->setDeadDecodedDataDeletionInterval(deadDecodedDataDeletionInterval);
+    pageCache()->setCapacity(pageCacheCapacity);
+
+    // FIXME: Implement hybrid in-memory- and disk-caching as e.g. the Mac port does.
+    diskCache->setMaximumCacheSize(static_cast<qint64>(urlCacheDiskCapacity));
 }
 
@@ -70 +141 @@
 {
     m_networkAccessManager = new QtNetworkAccessManager(this);
+
+    ASSERT(!parameters.diskCacheDirectory.isEmpty() && !parameters.diskCacheDirectory.isNull());
+    QNetworkDiskCache* diskCache = new QNetworkDiskCache();
+    diskCache->setCacheDirectory(parameters.diskCacheDirectory);
+    // The m_networkAccessManager takes ownership of the diskCache object upon the following call.
+    m_networkAccessManager->setCache(diskCache);
+
     ASSERT(!parameters.cookieStorageDirectory.isEmpty() && !parameters.cookieStorageDirectory.isNull());
     WebCore::SharedCookieJarQt* jar = WebCore::SharedCookieJarQt::create(parameters.cookieStorageDirectory);