[WK2] Prune more resources from the MemoryCache before process suspension
authorcdumez@apple.com <cdumez@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 4 Jun 2015 18:23:42 +0000 (18:23 +0000)
committercdumez@apple.com <cdumez@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 4 Jun 2015 18:23:42 +0000 (18:23 +0000)
https://bugs.webkit.org/show_bug.cgi?id=145633

Reviewed by Andreas Kling.

Source/JavaScriptCore:

No longer move protect IncrementalSweeper::fullSweep() behind
USE(CF) so we don't need #ifdefs at call sites, similarly to what is
done for the rest of the IncrementalSweeper API.

* heap/IncrementalSweeper.cpp:
(JSC::IncrementalSweeper::fullSweep):
* heap/IncrementalSweeper.h:

Source/WebCore:

Prune more resources from the MemoryCache before process suspension or
on simulated memory warning by doing a synchronous JS garbage collection
and sweep *before* pruning dead resources from the memory cache.
Previously, we would do the garbage collection after pruning the
MemoryCache which meant that a lot of resources became dead after we
tried to prune them.

At the end a basic browsing on apple.com, we are able to remove ~17%
more resources from the MemoryCache on simulated memory warning with this
change.

Pruning as much as we can from the memory cache on critical memory
pressure or before process suspension is not only useful to free up
memory but also to make room in the vnode table as a lot of
CachedResources are mmmap'd from the network disk cache.

* platform/MemoryPressureHandler.cpp:
(WebCore::MemoryPressureHandler::MemoryPressureHandler):
(WebCore::MemoryPressureHandler::releaseCriticalMemory):

- Pass 'synchronous' argument so that we know if we need to do a
  synchronous JS garbage collection.
- Move here code from in the Cocoa handler that is doing a JS garbage
  collection as well as a sweep, and make this code cross-platform.
  This code used to be iOS specific but I see no reason we shouldn't
  do this on Mac.

(WebCore::MemoryPressureHandler::releaseMemory):
* platform/MemoryPressureHandler.h:

Use enum class arguments for critical / synchronous. The 'synchronous'
argument is new so that the call site can let us know if memory needs
to be freed synchronously (e.g. in case of imminent process suspension).

* platform/cocoa/MemoryPressureHandlerCocoa.mm:
(WebCore::MemoryPressureHandler::platformReleaseMemory):

Remove iOS-specific code that was doing a JS garbage collection and
sweep as this code is now in the generic memory pressure handler.

(WebCore::MemoryPressureHandler::install):

On simulated memory pressure, set 'synchronous' argument to Yes so that
a synchronous GC is done by the generic memory pressure handler. This
way, we no longer need to do a sync GC after calling the memory pressure
handler. This avoids code duplication and makes sure the GC is done
before pruning the memory cache.

Source/WebKit2:

* NetworkProcess/NetworkProcess.cpp:
(WebKit::NetworkProcess::lowMemoryHandler):
(WebKit::NetworkProcess::initializeNetworkProcess):
(WebKit::NetworkProcess::processWillSuspendImminently):
(WebKit::NetworkProcess::prepareToSuspend):
* NetworkProcess/NetworkProcess.h:
* NetworkProcess/cocoa/NetworkProcessCocoa.mm:
(WebKit::NetworkProcess::platformLowMemoryHandler):
* PluginProcess/PluginProcess.cpp:
(WebKit::PluginProcess::initializeProcess):

Update low memory handler prototype to match WebCore changes.

* WebProcess/WebProcess.cpp:
(WebKit::WebProcess::actualPrepareToSuspend):

Pass Synchronous::Yes argument to MemoryPressureHandler::releaseMemory()
to request that the memory is free up synchronously (e.g. synchronous
JS garbage collection) as the process is about to be suspended.
Previously, the memory pressure handler was trying to detect this case
by checking if the system was really under memory pressure but this was
a bit hackish and it wouldn't work if the process happened to get
suspended while the system was under memory pressure.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@185206 268f45cc-cd09-0410-ab3c-d52691b4dbfc

14 files changed:
Source/JavaScriptCore/ChangeLog
Source/JavaScriptCore/heap/IncrementalSweeper.cpp
Source/JavaScriptCore/heap/IncrementalSweeper.h
Source/WebCore/ChangeLog
Source/WebCore/platform/MemoryPressureHandler.cpp
Source/WebCore/platform/MemoryPressureHandler.h
Source/WebCore/platform/cocoa/MemoryPressureHandlerCocoa.mm
Source/WebCore/platform/linux/MemoryPressureHandlerLinux.cpp
Source/WebKit2/ChangeLog
Source/WebKit2/NetworkProcess/NetworkProcess.cpp
Source/WebKit2/NetworkProcess/NetworkProcess.h
Source/WebKit2/NetworkProcess/cocoa/NetworkProcessCocoa.mm
Source/WebKit2/PluginProcess/PluginProcess.cpp
Source/WebKit2/WebProcess/WebProcess.cpp

index a09bb13..036fbd2 100644 (file)
@@ -1,3 +1,18 @@
+2015-06-04  Chris Dumez  <cdumez@apple.com>
+
+        [WK2] Prune more resources from the MemoryCache before process suspension
+        https://bugs.webkit.org/show_bug.cgi?id=145633
+
+        Reviewed by Andreas Kling.
+
+        No longer move protect IncrementalSweeper::fullSweep() behind
+        USE(CF) so we don't need #ifdefs at call sites, similarly to what is
+        done for the rest of the IncrementalSweeper API.
+
+        * heap/IncrementalSweeper.cpp:
+        (JSC::IncrementalSweeper::fullSweep):
+        * heap/IncrementalSweeper.h:
+
 2015-06-01  Filip Pizlo  <fpizlo@apple.com>
 
         CallLinkStatus should return takesSlowPath if the GC often cleared the IC
index 3ff4d8c..1e1957e 100644 (file)
@@ -132,6 +132,10 @@ void IncrementalSweeper::willFinishSweeping()
 {
 }
 
+void IncrementalSweeper::fullSweep()
+{
+}
+
 bool IncrementalSweeper::sweepNextBlock()
 {
     return false;
index f813a36..59620a0 100644 (file)
@@ -39,11 +39,11 @@ class IncrementalSweeper : public HeapTimer {
 public:
 #if USE(CF)
     JS_EXPORT_PRIVATE IncrementalSweeper(Heap*, CFRunLoopRef);
-    JS_EXPORT_PRIVATE void fullSweep();
 #else
     explicit IncrementalSweeper(VM*);
 #endif
 
+    JS_EXPORT_PRIVATE void fullSweep();
     void startSweeping();
 
     JS_EXPORT_PRIVATE virtual void doWork() override;
index deeb9df..629e3f3 100644 (file)
@@ -1,3 +1,59 @@
+2015-06-04  Chris Dumez  <cdumez@apple.com>
+
+        [WK2] Prune more resources from the MemoryCache before process suspension
+        https://bugs.webkit.org/show_bug.cgi?id=145633
+
+        Reviewed by Andreas Kling.
+
+        Prune more resources from the MemoryCache before process suspension or
+        on simulated memory warning by doing a synchronous JS garbage collection
+        and sweep *before* pruning dead resources from the memory cache.
+        Previously, we would do the garbage collection after pruning the
+        MemoryCache which meant that a lot of resources became dead after we
+        tried to prune them.
+
+        At the end a basic browsing on apple.com, we are able to remove ~17%
+        more resources from the MemoryCache on simulated memory warning with this
+        change.
+
+        Pruning as much as we can from the memory cache on critical memory
+        pressure or before process suspension is not only useful to free up
+        memory but also to make room in the vnode table as a lot of
+        CachedResources are mmmap'd from the network disk cache.
+
+        * platform/MemoryPressureHandler.cpp:
+        (WebCore::MemoryPressureHandler::MemoryPressureHandler):
+        (WebCore::MemoryPressureHandler::releaseCriticalMemory):
+
+        - Pass 'synchronous' argument so that we know if we need to do a
+          synchronous JS garbage collection.
+        - Move here code from in the Cocoa handler that is doing a JS garbage
+          collection as well as a sweep, and make this code cross-platform.
+          This code used to be iOS specific but I see no reason we shouldn't
+          do this on Mac.
+
+        (WebCore::MemoryPressureHandler::releaseMemory):
+        * platform/MemoryPressureHandler.h:
+
+        Use enum class arguments for critical / synchronous. The 'synchronous'
+        argument is new so that the call site can let us know if memory needs
+        to be freed synchronously (e.g. in case of imminent process suspension).
+
+        * platform/cocoa/MemoryPressureHandlerCocoa.mm:
+        (WebCore::MemoryPressureHandler::platformReleaseMemory):
+
+        Remove iOS-specific code that was doing a JS garbage collection and
+        sweep as this code is now in the generic memory pressure handler.
+
+        (WebCore::MemoryPressureHandler::install):
+
+        On simulated memory pressure, set 'synchronous' argument to Yes so that
+        a synchronous GC is done by the generic memory pressure handler. This
+        way, we no longer need to do a sync GC after calling the memory pressure
+        handler. This avoids code duplication and makes sure the GC is done
+        before pruning the memory cache.
+
+
 2015-06-04  Myles C. Maxfield  <mmaxfield@apple.com>
 
         [Cocoa] Clean up m_isEmoji in FontPlatformData
index 7f3a21d..647cd03 100644 (file)
@@ -37,6 +37,7 @@
 #include "PageCache.h"
 #include "ScrollingThread.h"
 #include "WorkerThread.h"
+#include <JavaScriptCore/IncrementalSweeper.h>
 #include <wtf/CurrentTime.h>
 #include <wtf/FastMalloc.h>
 #include <wtf/StdLibExtras.h>
@@ -54,7 +55,7 @@ MemoryPressureHandler& MemoryPressureHandler::singleton()
 MemoryPressureHandler::MemoryPressureHandler() 
     : m_installed(false)
     , m_lastRespondTime(0)
-    , m_lowMemoryHandler([this] (bool critical) { releaseMemory(critical); })
+    , m_lowMemoryHandler([this] (Critical critical, Synchronous synchronous) { releaseMemory(critical, synchronous); })
     , m_underMemoryPressure(false)
 #if PLATFORM(IOS)
     // FIXME: Can we share more of this with OpenSource?
@@ -100,7 +101,7 @@ void MemoryPressureHandler::releaseNoncriticalMemory()
     }
 }
 
-void MemoryPressureHandler::releaseCriticalMemory()
+void MemoryPressureHandler::releaseCriticalMemory(Synchronous synchronous)
 {
     {
         ReliefLogger log("Empty the PageCache");
@@ -134,12 +135,29 @@ void MemoryPressureHandler::releaseCriticalMemory()
         ReliefLogger log("Invalidate font cache");
         FontCache::singleton().invalidate();
     }
+
+    if (synchronous == Synchronous::Yes) {
+        ReliefLogger log("Collecting JavaScript garbage");
+        gcController().garbageCollectNow();
+    } else {
+        // FIXME: We should do a garbage sweep and prune dead resources from the MemoryCache
+        // after the garbage collection has completed to free up more memory.
+        gcController().garbageCollectSoon();
+
+        // Do a full sweep of collected objects. garbageCollectNow() already does this so we only
+        // need to do this if it isn't called.
+        {
+            ReliefLogger log("Full JavaScript garbage sweep");
+            JSC::JSLockHolder lock(JSDOMWindow::commonVM());
+            JSDOMWindow::commonVM().heap.sweeper()->fullSweep();
+        }
+    }
 }
 
-void MemoryPressureHandler::releaseMemory(bool critical)
+void MemoryPressureHandler::releaseMemory(Critical critical, Synchronous synchronous)
 {
-    if (critical)
-        releaseCriticalMemory();
+    if (critical == Critical::Yes)
+        releaseCriticalMemory(synchronous);
 
     releaseNoncriticalMemory();
 
@@ -160,8 +178,8 @@ void MemoryPressureHandler::releaseMemory(bool critical)
 void MemoryPressureHandler::install() { }
 void MemoryPressureHandler::uninstall() { }
 void MemoryPressureHandler::holdOff(unsigned) { }
-void MemoryPressureHandler::respondToMemoryPressure(bool) { }
-void MemoryPressureHandler::platformReleaseMemory(bool) { }
+void MemoryPressureHandler::respondToMemoryPressure(Critical, Synchronous) { }
+void MemoryPressureHandler::platformReleaseMemory(Critical) { }
 void MemoryPressureHandler::ReliefLogger::platformLog() { }
 size_t MemoryPressureHandler::ReliefLogger::platformMemoryUsage() { return 0; }
 #endif
index b9c8cec..5571058 100644 (file)
@@ -49,7 +49,10 @@ enum MemoryPressureReason {
 };
 #endif
 
-typedef std::function<void(bool critical)> LowMemoryHandler;
+enum class Critical { No, Yes };
+enum class Synchronous { No, Yes };
+
+typedef std::function<void(Critical, Synchronous)> LowMemoryHandler;
 
 class MemoryPressureHandler {
     WTF_MAKE_FAST_ALLOCATED;
@@ -107,11 +110,11 @@ public:
         WEBCORE_EXPORT static bool s_loggingEnabled;
     };
 
-    WEBCORE_EXPORT void releaseMemory(bool critical);
+    WEBCORE_EXPORT void releaseMemory(Critical, Synchronous = Synchronous::No);
 
 private:
     void releaseNoncriticalMemory();
-    void releaseCriticalMemory();
+    void releaseCriticalMemory(Synchronous);
 
     void uninstall();
 
@@ -120,8 +123,8 @@ private:
     MemoryPressureHandler();
     ~MemoryPressureHandler() = delete;
 
-    void respondToMemoryPressure(bool critical);
-    void platformReleaseMemory(bool critical);
+    void respondToMemoryPressure(Critical, Synchronous = Synchronous::No);
+    void platformReleaseMemory(Critical);
 
     bool m_installed;
     time_t m_lastRespondTime;
index 1ee3b8f..a73b41a 100644 (file)
@@ -34,7 +34,6 @@
 #import "LayerPool.h"
 #import "Logging.h"
 #import "WebCoreSystemInterface.h"
-#import <JavaScriptCore/IncrementalSweeper.h>
 #import <mach/mach.h>
 #import <mach/task_info.h>
 #import <malloc/malloc.h>
@@ -51,7 +50,7 @@ extern "C" void _sqlite3_purgeEligiblePagerCacheMemory(void);
 
 namespace WebCore {
 
-void MemoryPressureHandler::platformReleaseMemory(bool critical)
+void MemoryPressureHandler::platformReleaseMemory(Critical critical)
 {
     {
         ReliefLogger log("Purging SQLite caches");
@@ -71,7 +70,7 @@ void MemoryPressureHandler::platformReleaseMemory(bool critical)
 #endif
 
 #if PLATFORM(IOS) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101000
-    if (critical && !isUnderMemoryPressure()) {
+    if (critical == Critical::Yes && !isUnderMemoryPressure()) {
         // libcache listens to OS memory notifications, but for process suspension
         // or memory pressure simulation, we need to prod it manually:
         ReliefLogger log("Purging libcache caches");
@@ -80,24 +79,6 @@ void MemoryPressureHandler::platformReleaseMemory(bool critical)
 #else
     UNUSED_PARAM(critical);
 #endif
-
-#if PLATFORM(IOS)
-    if (isUnderMemoryPressure()) {
-        gcController().garbageCollectSoon();
-    } else {
-        // If we're not under memory pressure, that means we're here due to impending process suspension.
-        // Do a full GC since this is our last chance to run any code.
-        ReliefLogger log("Collecting JavaScript garbage");
-        gcController().garbageCollectNow();
-    }
-
-    // Do a full sweep of collected objects.
-    {
-        ReliefLogger log("Full JavaScript garbage sweep");
-        JSC::JSLockHolder lock(JSDOMWindow::commonVM());
-        JSDOMWindow::commonVM().heap.sweeper()->fullSweep();
-    }
-#endif
 }
 
 static dispatch_source_t _cache_event_source = 0;
@@ -147,7 +128,7 @@ void MemoryPressureHandler::install()
                 if (ReliefLogger::loggingEnabled())
                     NSLog(@"Got memory pressure notification (%s)", critical ? "critical" : "non-critical");
 #endif
-                MemoryPressureHandler::singleton().respondToMemoryPressure(critical);
+                MemoryPressureHandler::singleton().respondToMemoryPressure(critical ? Critical::Yes : Critical::No);
             });
             dispatch_resume(_cache_event_source);
         }
@@ -155,11 +136,7 @@ void MemoryPressureHandler::install()
 
     // Allow simulation of memory pressure with "notifyutil -p org.WebKit.lowMemory"
     notify_register_dispatch("org.WebKit.lowMemory", &_notifyToken, dispatch_get_main_queue(), ^(int) {
-        MemoryPressureHandler::singleton().respondToMemoryPressure(true);
-
-        // We only do a synchronous GC when *simulating* memory pressure.
-        // This gives us a more consistent picture of live objects at the end of testing.
-        gcController().garbageCollectNow();
+        MemoryPressureHandler::singleton().respondToMemoryPressure(Critical::Yes, Synchronous::Yes);
 
         WTF::releaseFastMallocFreeMemory();
 
@@ -213,14 +190,14 @@ void MemoryPressureHandler::holdOff(unsigned seconds)
     });
 }
 
-void MemoryPressureHandler::respondToMemoryPressure(bool critical)
+void MemoryPressureHandler::respondToMemoryPressure(Critical critical, Synchronous synchronous)
 {
 #if !PLATFORM(IOS)
     uninstall();
     double startTime = monotonicallyIncreasingTime();
 #endif
 
-    m_lowMemoryHandler(critical);
+    m_lowMemoryHandler(critical, synchronous);
 
 #if !PLATFORM(IOS)
     unsigned holdOffTime = (monotonicallyIncreasingTime() - startTime) * s_holdOffMultiplier;
index 2a1ebe7..ea61909 100644 (file)
@@ -101,7 +101,7 @@ void MemoryPressureHandler::waitForMemoryPressureEvent(void*)
 
     MemoryPressureHandler::singleton().setUnderMemoryPressure(critical);
     callOnMainThread([critical] {
-        MemoryPressureHandler::singleton().respondToMemoryPressure(critical);
+        MemoryPressureHandler::singleton().respondToMemoryPressure(critical ? Critical::Yes : Critical::No);
     });
 }
 
@@ -189,17 +189,17 @@ void MemoryPressureHandler::holdOff(unsigned seconds)
     m_holdOffTimer.startOneShot(seconds);
 }
 
-void MemoryPressureHandler::respondToMemoryPressure(bool critical)
+void MemoryPressureHandler::respondToMemoryPressure(Critical critical, Synchronous synchronous)
 {
     uninstall();
 
     double startTime = monotonicallyIncreasingTime();
-    m_lowMemoryHandler(critical);
+    m_lowMemoryHandler(critical, synchronous);
     unsigned holdOffTime = (monotonicallyIncreasingTime() - startTime) * s_holdOffMultiplier;
     holdOff(std::max(holdOffTime, s_minimumHoldOffTime));
 }
 
-void MemoryPressureHandler::platformReleaseMemory(bool)
+void MemoryPressureHandler::platformReleaseMemory(Critical)
 {
     ReliefLogger log("Run malloc_trim");
     malloc_trim(0);
index 97ca38b..2243421 100644 (file)
@@ -1,3 +1,34 @@
+2015-06-04  Chris Dumez  <cdumez@apple.com>
+
+        [WK2] Prune more resources from the MemoryCache before process suspension
+        https://bugs.webkit.org/show_bug.cgi?id=145633
+
+        Reviewed by Andreas Kling.
+
+        * NetworkProcess/NetworkProcess.cpp:
+        (WebKit::NetworkProcess::lowMemoryHandler):
+        (WebKit::NetworkProcess::initializeNetworkProcess):
+        (WebKit::NetworkProcess::processWillSuspendImminently):
+        (WebKit::NetworkProcess::prepareToSuspend):
+        * NetworkProcess/NetworkProcess.h:
+        * NetworkProcess/cocoa/NetworkProcessCocoa.mm:
+        (WebKit::NetworkProcess::platformLowMemoryHandler):
+        * PluginProcess/PluginProcess.cpp:
+        (WebKit::PluginProcess::initializeProcess):
+
+        Update low memory handler prototype to match WebCore changes.
+
+        * WebProcess/WebProcess.cpp:
+        (WebKit::WebProcess::actualPrepareToSuspend):
+
+        Pass Synchronous::Yes argument to MemoryPressureHandler::releaseMemory()
+        to request that the memory is free up synchronously (e.g. synchronous
+        JS garbage collection) as the process is about to be suspended.
+        Previously, the memory pressure handler was trying to detect this case
+        by checking if the system was really under memory pressure but this was
+        a bit hackish and it wouldn't work if the process happened to get
+        suspended while the system was under memory pressure.
+
 2015-06-03  Carlos Alberto Lopez Perez  <clopez@igalia.com>
 
         [GTK] [Wayland] Build is broken on trunk
index 8f9bc76..3379e02 100644 (file)
@@ -48,7 +48,6 @@
 #include "WebResourceCacheManager.h"
 #include "WebsiteData.h"
 #include <WebCore/Logging.h>
-#include <WebCore/MemoryPressureHandler.h>
 #include <WebCore/PlatformCookieJar.h>
 #include <WebCore/ResourceRequest.h>
 #include <WebCore/SecurityOriginHash.h>
@@ -175,7 +174,7 @@ AuthenticationManager& NetworkProcess::downloadsAuthenticationManager()
     return authenticationManager();
 }
 
-void NetworkProcess::lowMemoryHandler(bool critical)
+void NetworkProcess::lowMemoryHandler(Critical critical)
 {
     platformLowMemoryHandler(critical);
     WTF::releaseFastMallocFreeMemory();
@@ -188,7 +187,7 @@ void NetworkProcess::initializeNetworkProcess(const NetworkProcessCreationParame
     WTF::setCurrentThreadIsUserInitiated();
 
     auto& memoryPressureHandler = MemoryPressureHandler::singleton();
-    memoryPressureHandler.setLowMemoryHandler([this] (bool critical) {
+    memoryPressureHandler.setLowMemoryHandler([this] (Critical critical, Synchronous) {
         lowMemoryHandler(critical);
     });
     memoryPressureHandler.install();
@@ -516,13 +515,13 @@ void NetworkProcess::terminate()
 
 void NetworkProcess::processWillSuspendImminently(bool& handled)
 {
-    lowMemoryHandler(true);
+    lowMemoryHandler(Critical::Yes);
     handled = true;
 }
 
 void NetworkProcess::prepareToSuspend()
 {
-    lowMemoryHandler(true);
+    lowMemoryHandler(Critical::Yes);
     parentProcessConnection()->send(Messages::NetworkProcessProxy::ProcessReadyToSuspend(), 0);
 }
 
@@ -548,7 +547,7 @@ void NetworkProcess::initializeSandbox(const ChildProcessInitializationParameter
 {
 }
 
-void NetworkProcess::platformLowMemoryHandler(bool)
+void NetworkProcess::platformLowMemoryHandler(Critical)
 {
 }
 #endif
index 7adbe12..b9d6ed9 100644 (file)
@@ -33,6 +33,7 @@
 #include "DownloadManager.h"
 #include "MessageReceiverMap.h"
 #include <WebCore/DiagnosticLoggingClient.h>
+#include <WebCore/MemoryPressureHandler.h>
 #include <WebCore/SessionID.h>
 #include <memory>
 #include <wtf/Forward.h>
@@ -97,8 +98,8 @@ private:
     virtual void terminate() override;
     void platformTerminate();
 
-    void lowMemoryHandler(bool critical);
-    void platformLowMemoryHandler(bool critical);
+    void lowMemoryHandler(WebCore::Critical);
+    void platformLowMemoryHandler(WebCore::Critical);
 
     // ChildProcess
     virtual void initializeProcess(const ChildProcessInitializationParameters&) override;
index 5b63d12..f4ecde3 100644 (file)
@@ -39,7 +39,7 @@
 
 namespace WebKit {
 
-void NetworkProcess::platformLowMemoryHandler(bool)
+void NetworkProcess::platformLowMemoryHandler(WebCore::Critical)
 {
     CFURLConnectionInvalidateConnectionCache();
     _CFURLCachePurgeMemoryCache(adoptCF(CFURLCacheCopySharedURLCache()).get());
index 220cc0d..e33de00 100644 (file)
@@ -73,7 +73,7 @@ void PluginProcess::initializeProcess(const ChildProcessInitializationParameters
     platformInitializeProcess(parameters);
 
     auto& memoryPressureHandler = MemoryPressureHandler::singleton();
-    memoryPressureHandler.setLowMemoryHandler([this] (bool) {
+    memoryPressureHandler.setLowMemoryHandler([this] (Critical, Synchronous) {
         if (shouldTerminate())
             terminate();
     });
index a610ce5..069eb1f 100644 (file)
@@ -1226,7 +1226,7 @@ void WebProcess::resetAllGeolocationPermissions()
 
 void WebProcess::actualPrepareToSuspend(ShouldAcknowledgeWhenReadyToSuspend shouldAcknowledgeWhenReadyToSuspend)
 {
-    MemoryPressureHandler::singleton().releaseMemory(true);
+    MemoryPressureHandler::singleton().releaseMemory(Critical::Yes, Synchronous::Yes);
     setAllLayerTreeStatesFrozen(true);
 
     if (markAllLayersVolatileIfPossible()) {