Title: [234288] trunk/Source
Revision
234288
Author
[email protected]
Date
2018-07-26 18:24:33 -0700 (Thu, 26 Jul 2018)

Log Message

It should be possible to use WTF::CallbackAggregator from a background thread
https://bugs.webkit.org/show_bug.cgi?id=188084

Reviewed by Alex Christensen.

Source/WebKit:

This code was passing CallbackAggregator objects for background thread and not being
careful on which thread the CallbackAggregator gets destroyed. This patch fixes this
since the CallbackAggregator destructor no longer takes care of dispatching to the
main thread.

* NetworkProcess/cache/CacheStorageEngine.cpp:
(WebKit::CacheStorage::Engine::clearAllCaches):
(WebKit::CacheStorage::Engine::clearCachesForOrigin):

Source/WTF:

Make WTF::CallbackAggregator usable on background threads by updating its destructor to call the
completion handler on whatever thread it is destroyed on, instead of always dispatching to the
main thread before calling the completion handler.

Existing CallbackAggregator users that deal with threads have been updated to make sure they
destroy the CallbackAggregator on the expected thread.

This will allow us to use CallbackAggregator in the ResourceLoadStatisticsMemoryStore, which lives
on a background WorkQueue.

* wtf/CallbackAggregator.h:
(WTF::CallbackAggregator::~CallbackAggregator):
(WTF::CallbackAggregator::CallbackAggregator):

Modified Paths

Diff

Modified: trunk/Source/WTF/ChangeLog (234287 => 234288)


--- trunk/Source/WTF/ChangeLog	2018-07-27 01:11:39 UTC (rev 234287)
+++ trunk/Source/WTF/ChangeLog	2018-07-27 01:24:33 UTC (rev 234288)
@@ -1,3 +1,24 @@
+2018-07-26  Chris Dumez  <[email protected]>
+
+        It should be possible to use WTF::CallbackAggregator from a background thread
+        https://bugs.webkit.org/show_bug.cgi?id=188084
+
+        Reviewed by Alex Christensen.
+
+        Make WTF::CallbackAggregator usable on background threads by updating its destructor to call the
+        completion handler on whatever thread it is destroyed on, instead of always dispatching to the
+        main thread before calling the completion handler.
+
+        Existing CallbackAggregator users that deal with threads have been updated to make sure they
+        destroy the CallbackAggregator on the expected thread.
+
+        This will allow us to use CallbackAggregator in the ResourceLoadStatisticsMemoryStore, which lives
+        on a background WorkQueue.
+
+        * wtf/CallbackAggregator.h:
+        (WTF::CallbackAggregator::~CallbackAggregator):
+        (WTF::CallbackAggregator::CallbackAggregator):
+
 2018-07-26  Ross Kirsling  <[email protected]>
 
         String(View) should have a splitAllowingEmptyEntries function instead of a flag parameter

Modified: trunk/Source/WTF/wtf/CallbackAggregator.h (234287 => 234288)


--- trunk/Source/WTF/wtf/CallbackAggregator.h	2018-07-27 01:11:39 UTC (rev 234287)
+++ trunk/Source/WTF/wtf/CallbackAggregator.h	2018-07-27 01:24:33 UTC (rev 234288)
@@ -37,24 +37,24 @@
 
     ~CallbackAggregator()
     {
-        if (!m_callback)
-            return;
-        if (isMainThread()) {
+        ASSERT(m_wasConstructedOnMainThread == isMainThread());
+        if (m_callback)
             m_callback();
-            return;
-        }
-        callOnMainThread([callback = WTFMove(m_callback)] () mutable {
-            callback();
-        });
     }
 
 private:
     explicit CallbackAggregator(CompletionHandler<void()>&& callback)
         : m_callback(WTFMove(callback))
+#if !ASSERT_DISABLED
+        , m_wasConstructedOnMainThread(isMainThread())
+#endif
     {
     }
 
     CompletionHandler<void()> m_callback;
+#if !ASSERT_DISABLED
+    bool m_wasConstructedOnMainThread;
+#endif
 };
 
 } // namespace WTF

Modified: trunk/Source/WebKit/ChangeLog (234287 => 234288)


--- trunk/Source/WebKit/ChangeLog	2018-07-27 01:11:39 UTC (rev 234287)
+++ trunk/Source/WebKit/ChangeLog	2018-07-27 01:24:33 UTC (rev 234288)
@@ -1,3 +1,19 @@
+2018-07-26  Chris Dumez  <[email protected]>
+
+        It should be possible to use WTF::CallbackAggregator from a background thread
+        https://bugs.webkit.org/show_bug.cgi?id=188084
+
+        Reviewed by Alex Christensen.
+
+        This code was passing CallbackAggregator objects for background thread and not being
+        careful on which thread the CallbackAggregator gets destroyed. This patch fixes this
+        since the CallbackAggregator destructor no longer takes care of dispatching to the
+        main thread.
+
+        * NetworkProcess/cache/CacheStorageEngine.cpp:
+        (WebKit::CacheStorage::Engine::clearAllCaches):
+        (WebKit::CacheStorage::Engine::clearCachesForOrigin):
+
 2018-07-26  Ross Kirsling  <[email protected]>
 
         String(View) should have a splitAllowingEmptyEntries function instead of a flag parameter

Modified: trunk/Source/WebKit/NetworkProcess/NetworkProcess.cpp (234287 => 234288)


--- trunk/Source/WebKit/NetworkProcess/NetworkProcess.cpp	2018-07-27 01:11:39 UTC (rev 234287)
+++ trunk/Source/WebKit/NetworkProcess/NetworkProcess.cpp	2018-07-27 01:24:33 UTC (rev 234288)
@@ -578,7 +578,7 @@
     });
 
     if (websiteDataTypes.contains(WebsiteDataType::DOMCache))
-        CacheStorage::Engine::clearAllCaches(sessionID, clearTasksHandler.copyRef());
+        CacheStorage::Engine::clearAllCaches(sessionID, [clearTasksHandler = clearTasksHandler.copyRef()] { });
 
     if (websiteDataTypes.contains(WebsiteDataType::DiskCache) && !sessionID.isEphemeral())
         clearDiskCache(modifiedSince, [clearTasksHandler = WTFMove(clearTasksHandler)] { });
@@ -622,7 +622,7 @@
 
     if (websiteDataTypes.contains(WebsiteDataType::DOMCache)) {
         for (auto& originData : originDatas)
-            CacheStorage::Engine::clearCachesForOrigin(sessionID, SecurityOriginData { originData }, clearTasksHandler.copyRef());
+            CacheStorage::Engine::clearCachesForOrigin(sessionID, SecurityOriginData { originData }, [clearTasksHandler = clearTasksHandler.copyRef()] { });
     }
 
     if (websiteDataTypes.contains(WebsiteDataType::DiskCache) && !sessionID.isEphemeral())

Modified: trunk/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.cpp (234287 => 234288)


--- trunk/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.cpp	2018-07-27 01:11:39 UTC (rev 234287)
+++ trunk/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.cpp	2018-07-27 01:24:33 UTC (rev 234288)
@@ -183,17 +183,17 @@
     });
 }
 
-void Engine::clearAllCaches(PAL::SessionID sessionID, Ref<WTF::CallbackAggregator>&& aggregator)
+void Engine::clearAllCaches(PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)
 {
-    from(sessionID, [aggregator = WTFMove(aggregator)](auto& engine) mutable {
-        engine.clearAllCaches(aggregator);
+    from(sessionID, [completionHandler = WTFMove(completionHandler)](auto& engine) mutable {
+        engine.clearAllCaches(WTFMove(completionHandler));
     });
 }
 
-void Engine::clearCachesForOrigin(PAL::SessionID sessionID, WebCore::SecurityOriginData&& originData, Ref<WTF::CallbackAggregator>&& aggregator)
+void Engine::clearCachesForOrigin(PAL::SessionID sessionID, WebCore::SecurityOriginData&& originData, CompletionHandler<void()>&& completionHandler)
 {
-    from(sessionID, [originData = WTFMove(originData), aggregator = WTFMove(aggregator)](auto& engine) mutable {
-        engine.clearCachesForOrigin(originData, aggregator);
+    from(sessionID, [originData = WTFMove(originData), completionHandler = WTFMove(completionHandler)](auto& engine) mutable {
+        engine.clearCachesForOrigin(originData, WTFMove(completionHandler));
     });
 }
 
@@ -516,36 +516,63 @@
     }
 }
 
-void Engine::clearAllCaches(CallbackAggregator& taskHandler)
+void Engine::clearAllCaches(CompletionHandler<void()>&& completionHandler)
 {
+    ASSERT(RunLoop::isMain());
+
+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
+
     for (auto& caches : m_caches.values())
-        caches->clear([taskHandler = makeRef(taskHandler)] { });
+        caches->clear([callbackAggregator = callbackAggregator.copyRef()] { });
 
     if (!shouldPersist())
         return;
 
-    m_ioQueue->dispatch([path = m_rootPath.isolatedCopy(), taskHandler = makeRef(taskHandler)] {
+    clearAllCachesFromDisk([callbackAggregator = WTFMove(callbackAggregator)] { });
+}
+
+void Engine::clearAllCachesFromDisk(CompletionHandler<void()>&& completionHandler)
+{
+    ASSERT(RunLoop::isMain());
+
+    m_ioQueue->dispatch([path = m_rootPath.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
         for (auto& filename : WebCore::FileSystem::listDirectory(path, "*")) {
             if (WebCore::FileSystem::fileIsDirectory(filename, WebCore::FileSystem::ShouldFollowSymbolicLinks::No))
                 deleteDirectoryRecursively(filename);
         }
+        RunLoop::main().dispatch([completionHandler = WTFMove(completionHandler)] {
+            completionHandler();
+        });
     });
 }
 
-void Engine::clearCachesForOrigin(const WebCore::SecurityOriginData& origin, CallbackAggregator& taskHandler)
+void Engine::clearCachesForOrigin(const WebCore::SecurityOriginData& origin, CompletionHandler<void()>&& completionHandler)
 {
+    ASSERT(RunLoop::isMain());
+
+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
+
     for (auto& keyValue : m_caches) {
         if (keyValue.key.topOrigin == origin || keyValue.key.clientOrigin == origin)
-            keyValue.value->clear([taskHandler = makeRef(taskHandler)] { });
+            keyValue.value->clear([callbackAggregator = callbackAggregator.copyRef()] { });
     }
 
     if (!shouldPersist())
         return;
 
+    clearCachesForOriginFromDisk(origin, [callbackAggregator = WTFMove(callbackAggregator)] { });
+}
+
+void Engine::clearCachesForOriginFromDisk(const WebCore::SecurityOriginData& origin, CompletionHandler<void()>&& completionHandler)
+{
+    ASSERT(RunLoop::isMain());
+
+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
+
     for (auto& folderPath : WebCore::FileSystem::listDirectory(m_rootPath, "*")) {
         if (!WebCore::FileSystem::fileIsDirectory(folderPath, WebCore::FileSystem::ShouldFollowSymbolicLinks::No))
             continue;
-        Caches::retrieveOriginFromDirectory(folderPath, *m_ioQueue, [this, protectedThis = makeRef(*this), origin, taskHandler = makeRef(taskHandler), folderPath] (std::optional<WebCore::ClientOrigin>&& folderOrigin) mutable {
+        Caches::retrieveOriginFromDirectory(folderPath, *m_ioQueue, [this, protectedThis = makeRef(*this), origin, callbackAggregator = callbackAggregator.copyRef(), folderPath] (std::optional<WebCore::ClientOrigin>&& folderOrigin) mutable {
             if (!folderOrigin)
                 return;
             if (folderOrigin->topOrigin != origin && folderOrigin->clientOrigin != origin)
@@ -552,13 +579,24 @@
                 return;
 
             ASSERT(folderPath == cachesRootPath(*folderOrigin));
-            m_ioQueue->dispatch([path = folderPath.isolatedCopy(), taskHandler = WTFMove(taskHandler)] {
-                deleteDirectoryRecursively(path);
-            });
+            deleteDirectoryRecursivelyOnBackgroundThread(folderPath, [callbackAggregator = WTFMove(callbackAggregator)] { });
         });
     }
 }
 
+void Engine::deleteDirectoryRecursivelyOnBackgroundThread(const String& path, CompletionHandler<void()>&& completionHandler)
+{
+    ASSERT(RunLoop::isMain());
+
+    m_ioQueue->dispatch([path = path.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
+        deleteDirectoryRecursively(path);
+
+        RunLoop::main().dispatch([completionHandler = WTFMove(completionHandler)] {
+            completionHandler();
+        });
+    });
+}
+
 void Engine::clearMemoryRepresentation(const WebCore::ClientOrigin& origin, WebCore::DOMCacheEngine::CompletionCallback&& callback)
 {
     readCachesFromDisk(origin, [callback = WTFMove(callback)](CachesOrError&& result) {

Modified: trunk/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.h (234287 => 234288)


--- trunk/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.h	2018-07-27 01:11:39 UTC (rev 234287)
+++ trunk/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.h	2018-07-27 01:24:33 UTC (rev 234288)
@@ -75,8 +75,8 @@
     static void clearMemoryRepresentation(PAL::SessionID, WebCore::ClientOrigin&&, WebCore::DOMCacheEngine::CompletionCallback&&);
     static void representation(PAL::SessionID, CompletionHandler<void(String&&)>&&);
 
-    static void clearAllCaches(PAL::SessionID, Ref<WTF::CallbackAggregator>&&);
-    static void clearCachesForOrigin(PAL::SessionID, WebCore::SecurityOriginData&&, Ref<WTF::CallbackAggregator>&&);
+    static void clearAllCaches(PAL::SessionID, CompletionHandler<void()>&&);
+    static void clearCachesForOrigin(PAL::SessionID, WebCore::SecurityOriginData&&, CompletionHandler<void()>&&);
 
     bool shouldPersist() const { return !!m_ioQueue;}
 
@@ -95,8 +95,11 @@
     void remove(uint64_t cacheIdentifier, WebCore::DOMCacheEngine::CacheIdentifierCallback&&);
     void retrieveCaches(const WebCore::ClientOrigin&, uint64_t updateCounter, WebCore::DOMCacheEngine::CacheInfosCallback&&);
 
-    void clearAllCaches(WTF::CallbackAggregator&);
-    void clearCachesForOrigin(const WebCore::SecurityOriginData&, WTF::CallbackAggregator&);
+    void clearAllCaches(CompletionHandler<void()>&&);
+    void clearAllCachesFromDisk(CompletionHandler<void()>&&);
+    void clearCachesForOrigin(const WebCore::SecurityOriginData&, CompletionHandler<void()>&&);
+    void clearCachesForOriginFromDisk(const WebCore::SecurityOriginData&, CompletionHandler<void()>&&);
+    void deleteDirectoryRecursivelyOnBackgroundThread(const String& path, CompletionHandler<void()>&&);
 
     void clearMemoryRepresentation(const WebCore::ClientOrigin&, WebCore::DOMCacheEngine::CompletionCallback&&);
     String representation();
_______________________________________________
webkit-changes mailing list
[email protected]
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to