Attachment 358541 Details for Bug 193220 – Patch

[patch] Patch

bug-193220-20190107152607.patch (text/plain), 38.43 KB, created by Alex Christensen on 2019-01-07 15:26:07 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Alex Christensen

Created: 2019-01-07 15:26:07 PST

Size: 38.43 KB

patch

obsolete

>Index: Source/WebKit/ChangeLog
>===================================================================
>--- Source/WebKit/ChangeLog	(revision 239705)
>+++ Source/WebKit/ChangeLog	(working copy)
>@@ -1,3 +1,60 @@
>+2019-01-07  Alex Christensen  <achristensen@webkit.org>
>+
>+        Remove use of NetworkProcess::singleton from CacheStorage::Engine::from
>+        https://bugs.webkit.org/show_bug.cgi?id=193220
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        This required passing the NetworkProcess& in from all its callers.
>+        While I was at it, I made them use CompletionHandlers where appropriate.
>+
>+        * NetworkProcess/NetworkProcess.cpp:
>+        (WebKit::NetworkProcess::destroySession):
>+        (WebKit::NetworkProcess::fetchWebsiteData):
>+        (WebKit::NetworkProcess::deleteWebsiteData):
>+        (WebKit::NetworkProcess::deleteWebsiteDataForOrigins):
>+        (WebKit::NetworkProcess::findCacheEngine):
>+        (WebKit::NetworkProcess::ensureCacheEngine):
>+        (WebKit::NetworkProcess::removeCacheEngine):
>+        * NetworkProcess/NetworkProcess.h:
>+        * NetworkProcess/cache/CacheStorageEngine.cpp:
>+        (WebKit::CacheStorage::Engine::from):
>+        (WebKit::CacheStorage::Engine::destroyEngine):
>+        (WebKit::CacheStorage::Engine::fetchEntries):
>+        (WebKit::CacheStorage::Engine::open):
>+        (WebKit::CacheStorage::Engine::remove):
>+        (WebKit::CacheStorage::Engine::retrieveCaches):
>+        (WebKit::CacheStorage::Engine::retrieveRecords):
>+        (WebKit::CacheStorage::Engine::putRecords):
>+        (WebKit::CacheStorage::Engine::deleteMatchingRecords):
>+        (WebKit::CacheStorage::Engine::lock):
>+        (WebKit::CacheStorage::Engine::unlock):
>+        (WebKit::CacheStorage::Engine::clearMemoryRepresentation):
>+        (WebKit::CacheStorage::Engine::representation):
>+        (WebKit::CacheStorage::Engine::clearAllCaches):
>+        (WebKit::CacheStorage::Engine::clearCachesForOrigin):
>+        (WebKit::CacheStorage::globalEngineMap): Deleted.
>+        * NetworkProcess/cache/CacheStorageEngine.h:
>+        * NetworkProcess/cache/CacheStorageEngineConnection.cpp:
>+        (WebKit::CacheStorageEngineConnection::~CacheStorageEngineConnection):
>+        (WebKit::CacheStorageEngineConnection::open):
>+        (WebKit::CacheStorageEngineConnection::remove):
>+        (WebKit::CacheStorageEngineConnection::caches):
>+        (WebKit::CacheStorageEngineConnection::retrieveRecords):
>+        (WebKit::CacheStorageEngineConnection::deleteMatchingRecords):
>+        (WebKit::CacheStorageEngineConnection::putRecords):
>+        (WebKit::CacheStorageEngineConnection::reference):
>+        (WebKit::CacheStorageEngineConnection::dereference):
>+        (WebKit::CacheStorageEngineConnection::clearMemoryRepresentation):
>+        (WebKit::CacheStorageEngineConnection::engineRepresentation):
>+        * NetworkProcess/cache/NetworkCache.cpp:
>+        (WebKit::NetworkCache::Cache::store):
>+        (WebKit::NetworkCache::Cache::remove):
>+        (WebKit::NetworkCache::Cache::traverse):
>+        (WebKit::NetworkCache::Cache::clear):
>+        (WebKit::NetworkCache::Cache::retrieveData):
>+        * NetworkProcess/cache/NetworkCache.h:
>+
> 2019-01-07  Dean Jackson  <dino@apple.com>
> 
>         Turn on Pointer Events by default for iOS
>Index: Source/WebKit/NetworkProcess/NetworkProcess.cpp
>===================================================================
>--- Source/WebKit/NetworkProcess/NetworkProcess.cpp	(revision 239699)
>+++ Source/WebKit/NetworkProcess/NetworkProcess.cpp	(working copy)
>@@ -453,7 +453,7 @@ void NetworkProcess::destroySession(PAL:
> {
>     SessionTracker::destroySession(sessionID);
>     m_sessionsControlledByAutomation.remove(sessionID);
>-    CacheStorage::Engine::destroyEngine(sessionID);
>+    CacheStorage::Engine::destroyEngine(*this, sessionID);
> 
> #if ENABLE(SERVICE_WORKER)
>     m_swServers.remove(sessionID);
>@@ -635,7 +635,7 @@ void NetworkProcess::fetchWebsiteData(PA
>     }
> 
>     if (websiteDataTypes.contains(WebsiteDataType::DOMCache)) {
>-        CacheStorage::Engine::fetchEntries(sessionID, fetchOptions.contains(WebsiteDataFetchOption::ComputeSizes), [callbackAggregator = callbackAggregator.copyRef()](auto entries) mutable {
>+        CacheStorage::Engine::fetchEntries(*this, sessionID, fetchOptions.contains(WebsiteDataFetchOption::ComputeSizes), [callbackAggregator = callbackAggregator.copyRef()](auto entries) mutable {
>             callbackAggregator->m_websiteData.entries.appendVector(entries);
>         });
>     }
>@@ -701,7 +701,7 @@ void NetworkProcess::deleteWebsiteData(P
>     });
> 
>     if (websiteDataTypes.contains(WebsiteDataType::DOMCache))
>-        CacheStorage::Engine::clearAllCaches(sessionID, [clearTasksHandler = clearTasksHandler.copyRef()] { });
>+        CacheStorage::Engine::clearAllCaches(*this, sessionID, [clearTasksHandler = clearTasksHandler.copyRef()] { });
> 
> #if ENABLE(INDEXED_DATABASE)
>     if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases) && !sessionID.isEphemeral())
>@@ -761,7 +761,7 @@ void NetworkProcess::deleteWebsiteDataFo
> 
>     if (websiteDataTypes.contains(WebsiteDataType::DOMCache)) {
>         for (auto& originData : originDatas)
>-            CacheStorage::Engine::clearCachesForOrigin(sessionID, SecurityOriginData { originData }, [clearTasksHandler = clearTasksHandler.copyRef()] { });
>+            CacheStorage::Engine::clearCachesForOrigin(*this, sessionID, SecurityOriginData { originData }, [clearTasksHandler = clearTasksHandler.copyRef()] { });
>     }
> 
> #if ENABLE(INDEXED_DATABASE)
>@@ -781,6 +781,21 @@ void NetworkProcess::deleteWebsiteDataFo
>         clearDiskCacheEntries(cache(), originDatas, [clearTasksHandler = WTFMove(clearTasksHandler)] { });
> }
> 
>+CacheStorage::Engine* NetworkProcess::findCacheEngine(const PAL::SessionID& sessionID)
>+{
>+    return m_cacheEngines.get(sessionID);
>+}
>+
>+CacheStorage::Engine& NetworkProcess::ensureCacheEngine(const PAL::SessionID& sessionID, Function<Ref<CacheStorage::Engine>()>&& functor)
>+{
>+    return m_cacheEngines.ensure(sessionID, WTFMove(functor)).iterator->value;
>+}
>+
>+void NetworkProcess::removeCacheEngine(const PAL::SessionID& sessionID)
>+{
>+    m_cacheEngines.remove(sessionID);
>+}
>+
> void NetworkProcess::downloadRequest(PAL::SessionID sessionID, DownloadID downloadID, const ResourceRequest& request, const String& suggestedFilename)
> {
>     downloadManager().startDownload(nullptr, sessionID, downloadID, request, suggestedFilename);
>Index: Source/WebKit/NetworkProcess/NetworkProcess.h
>===================================================================
>--- Source/WebKit/NetworkProcess/NetworkProcess.h	(revision 239699)
>+++ Source/WebKit/NetworkProcess/NetworkProcess.h	(working copy)
>@@ -84,6 +84,10 @@ struct WebsiteDataStoreParameters;
> class WebSWOriginStore;
> #endif
> 
>+namespace CacheStorage {
>+class Engine;
>+}
>+
> namespace NetworkCache {
> class Cache;
> }
>@@ -213,6 +217,10 @@ public:
>     void ref() const override { ThreadSafeRefCounted<NetworkProcess>::ref(); }
>     void deref() const override { ThreadSafeRefCounted<NetworkProcess>::deref(); }
>     
>+    CacheStorage::Engine* findCacheEngine(const PAL::SessionID&);
>+    CacheStorage::Engine& ensureCacheEngine(const PAL::SessionID&, Function<Ref<CacheStorage::Engine>()>&&);
>+    void removeCacheEngine(const PAL::SessionID&);
>+    
> private:
>     NetworkProcess();
> 
>@@ -359,6 +367,8 @@ private:
>     String m_uiProcessBundleIdentifier;
>     DownloadManager m_downloadManager;
> 
>+    HashMap<PAL::SessionID, Ref<CacheStorage::Engine>> m_cacheEngines;
>+
>     RefPtr<NetworkCache::Cache> m_cache;
> 
>     typedef HashMap<const char*, std::unique_ptr<NetworkProcessSupplement>, PtrHash<const char*>> NetworkProcessSupplementMap;
>Index: Source/WebKit/NetworkProcess/cache/CacheStorageEngine.cpp
>===================================================================
>--- Source/WebKit/NetworkProcess/cache/CacheStorageEngine.cpp	(revision 239670)
>+++ Source/WebKit/NetworkProcess/cache/CacheStorageEngine.cpp	(working copy)
>@@ -46,13 +46,6 @@ namespace CacheStorage {
> using namespace WebCore::DOMCacheEngine;
> using namespace NetworkCache;
> 
>-static HashMap<PAL::SessionID, RefPtr<Engine>>& globalEngineMap()
>-{
>-    static NeverDestroyed<HashMap<PAL::SessionID, RefPtr<Engine>>> map;
>-
>-    return map;
>-}
>-
> String Engine::cachesRootPath(const WebCore::ClientOrigin& origin)
> {
>     if (!shouldPersist())
>@@ -80,119 +73,117 @@ Engine::~Engine()
>         callback(Data { }, 1);
> }
> 
>-void Engine::from(PAL::SessionID sessionID, Function<void(Engine&)>&& callback)
>+void Engine::from(NetworkProcess& networkProcess, PAL::SessionID sessionID, CompletionHandler<void(Engine&)>&& callback)
> {
>-    auto iterator = globalEngineMap().find(sessionID);
>-    if (iterator != globalEngineMap().end()) {
>-        callback(*iterator->value);
>+    if (auto* engine = networkProcess.findCacheEngine(sessionID)) {
>+        callback(*engine);
>         return;
>     }
> 
>     if (sessionID.isEphemeral())
>         sessionID = PAL::SessionID::legacyPrivateSessionID();
> 
>-    NetworkProcess::singleton().cacheStorageParameters(sessionID, [sessionID, callback = WTFMove(callback)](auto&& rootPath, auto quota) {
>-        auto addResult = globalEngineMap().add(sessionID, nullptr);
>-        if (addResult.isNewEntry)
>-            addResult.iterator->value = adoptRef(*new Engine { String { rootPath }, quota });
>-        callback(*addResult.iterator->value);
>+    networkProcess.cacheStorageParameters(sessionID, [networkProcess = makeRef(networkProcess), sessionID, callback = WTFMove(callback)] (auto&& rootPath, auto quota) mutable {
>+        callback(networkProcess->ensureCacheEngine(sessionID, [&] {
>+            return adoptRef(*new Engine { String { rootPath }, quota });
>+        }));
>     });
> }
> 
>-void Engine::destroyEngine(PAL::SessionID sessionID)
>+void Engine::destroyEngine(NetworkProcess& networkProcess, PAL::SessionID sessionID)
> {
>     ASSERT(sessionID != PAL::SessionID::defaultSessionID());
>-    globalEngineMap().remove(sessionID);
>+    networkProcess.removeCacheEngine(sessionID);
> }
> 
>-void Engine::fetchEntries(PAL::SessionID sessionID, bool shouldComputeSize, CompletionHandler<void(Vector<WebsiteData::Entry>)>&& completionHandler)
>+void Engine::fetchEntries(NetworkProcess& networkProcess, PAL::SessionID sessionID, bool shouldComputeSize, CompletionHandler<void(Vector<WebsiteData::Entry>)>&& completionHandler)
> {
>-    from(sessionID, [shouldComputeSize, completionHandler = WTFMove(completionHandler)] (auto& engine) mutable {
>+    from(networkProcess, sessionID, [shouldComputeSize, completionHandler = WTFMove(completionHandler)] (auto& engine) mutable {
>         engine.fetchEntries(shouldComputeSize, WTFMove(completionHandler));
>     });
> }
> 
>-void Engine::open(PAL::SessionID sessionID, WebCore::ClientOrigin&& origin, String&& cacheName, WebCore::DOMCacheEngine::CacheIdentifierCallback&& callback)
>+void Engine::open(NetworkProcess& networkProcess, PAL::SessionID sessionID, WebCore::ClientOrigin&& origin, String&& cacheName, WebCore::DOMCacheEngine::CacheIdentifierCallback&& callback)
> {
>-    from(sessionID, [origin = WTFMove(origin), cacheName = WTFMove(cacheName), callback = WTFMove(callback)](auto& engine) mutable {
>+    from(networkProcess, sessionID, [origin = WTFMove(origin), cacheName = WTFMove(cacheName), callback = WTFMove(callback)](auto& engine) mutable {
>         engine.open(origin, cacheName, WTFMove(callback));
>     });
> }
> 
>-void Engine::remove(PAL::SessionID sessionID, uint64_t cacheIdentifier, WebCore::DOMCacheEngine::CacheIdentifierCallback&& callback)
>+void Engine::remove(NetworkProcess& networkProcess, PAL::SessionID sessionID, uint64_t cacheIdentifier, WebCore::DOMCacheEngine::CacheIdentifierCallback&& callback)
> {
>-    from(sessionID, [cacheIdentifier, callback = WTFMove(callback)](auto& engine) mutable {
>+    from(networkProcess, sessionID, [cacheIdentifier, callback = WTFMove(callback)](auto& engine) mutable {
>         engine.remove(cacheIdentifier, WTFMove(callback));
>     });
> }
> 
>-void Engine::retrieveCaches(PAL::SessionID sessionID, WebCore::ClientOrigin&& origin, uint64_t updateCounter, WebCore::DOMCacheEngine::CacheInfosCallback&& callback)
>+void Engine::retrieveCaches(NetworkProcess& networkProcess, PAL::SessionID sessionID, WebCore::ClientOrigin&& origin, uint64_t updateCounter, WebCore::DOMCacheEngine::CacheInfosCallback&& callback)
> {
>-    from(sessionID, [origin = WTFMove(origin), updateCounter, callback = WTFMove(callback)](auto& engine) mutable {
>+    from(networkProcess, sessionID, [origin = WTFMove(origin), updateCounter, callback = WTFMove(callback)](auto& engine) mutable {
>         engine.retrieveCaches(origin, updateCounter, WTFMove(callback));
>     });
> }
> 
> 
>-void Engine::retrieveRecords(PAL::SessionID sessionID, uint64_t cacheIdentifier, URL&& url, WebCore::DOMCacheEngine::RecordsCallback&& callback)
>+void Engine::retrieveRecords(NetworkProcess& networkProcess, PAL::SessionID sessionID, uint64_t cacheIdentifier, URL&& url, WebCore::DOMCacheEngine::RecordsCallback&& callback)
> {
>-    from(sessionID, [cacheIdentifier, url = WTFMove(url), callback = WTFMove(callback)](auto& engine) mutable {
>+    from(networkProcess, sessionID, [cacheIdentifier, url = WTFMove(url), callback = WTFMove(callback)](auto& engine) mutable {
>         engine.retrieveRecords(cacheIdentifier, WTFMove(url), WTFMove(callback));
>     });
> }
> 
>-void Engine::putRecords(PAL::SessionID sessionID, uint64_t cacheIdentifier, Vector<WebCore::DOMCacheEngine::Record>&& records, WebCore::DOMCacheEngine::RecordIdentifiersCallback&& callback)
>+void Engine::putRecords(NetworkProcess& networkProcess, PAL::SessionID sessionID, uint64_t cacheIdentifier, Vector<WebCore::DOMCacheEngine::Record>&& records, WebCore::DOMCacheEngine::RecordIdentifiersCallback&& callback)
> {
>-    from(sessionID, [cacheIdentifier, records = WTFMove(records), callback = WTFMove(callback)](auto& engine) mutable {
>+    from(networkProcess, sessionID, [cacheIdentifier, records = WTFMove(records), callback = WTFMove(callback)](auto& engine) mutable {
>         engine.putRecords(cacheIdentifier, WTFMove(records), WTFMove(callback));
>     });
> }
> 
>-void Engine::deleteMatchingRecords(PAL::SessionID sessionID, uint64_t cacheIdentifier, WebCore::ResourceRequest&& request, WebCore::CacheQueryOptions&& options, WebCore::DOMCacheEngine::RecordIdentifiersCallback&& callback)
>+void Engine::deleteMatchingRecords(NetworkProcess& networkProcess, PAL::SessionID sessionID, uint64_t cacheIdentifier, WebCore::ResourceRequest&& request, WebCore::CacheQueryOptions&& options, WebCore::DOMCacheEngine::RecordIdentifiersCallback&& callback)
> {
>-    from(sessionID, [cacheIdentifier, request = WTFMove(request), options = WTFMove(options), callback = WTFMove(callback)](auto& engine) mutable {
>+    from(networkProcess, sessionID, [cacheIdentifier, request = WTFMove(request), options = WTFMove(options), callback = WTFMove(callback)](auto& engine) mutable {
>         engine.deleteMatchingRecords(cacheIdentifier, WTFMove(request), WTFMove(options), WTFMove(callback));
>     });
> }
> 
>-void Engine::lock(PAL::SessionID sessionID, uint64_t cacheIdentifier)
>+void Engine::lock(NetworkProcess& networkProcess, PAL::SessionID sessionID, uint64_t cacheIdentifier)
> {
>-    from(sessionID, [cacheIdentifier](auto& engine) mutable {
>+    from(networkProcess, sessionID, [cacheIdentifier](auto& engine) mutable {
>         engine.lock(cacheIdentifier);
>     });
> }
> 
>-void Engine::unlock(PAL::SessionID sessionID, uint64_t cacheIdentifier)
>+void Engine::unlock(NetworkProcess& networkProcess, PAL::SessionID sessionID, uint64_t cacheIdentifier)
> {
>-    from(sessionID, [cacheIdentifier](auto& engine) mutable {
>+    from(networkProcess, sessionID, [cacheIdentifier](auto& engine) mutable {
>         engine.unlock(cacheIdentifier);
>     });
> }
> 
>-void Engine::clearMemoryRepresentation(PAL::SessionID sessionID, WebCore::ClientOrigin&& origin, WebCore::DOMCacheEngine::CompletionCallback&& callback)
>+void Engine::clearMemoryRepresentation(NetworkProcess& networkProcess, PAL::SessionID sessionID, WebCore::ClientOrigin&& origin, WebCore::DOMCacheEngine::CompletionCallback&& callback)
> {
>-    from(sessionID, [origin = WTFMove(origin), callback = WTFMove(callback)](auto& engine) mutable {
>+    from(networkProcess, sessionID, [origin = WTFMove(origin), callback = WTFMove(callback)](auto& engine) mutable {
>         engine.clearMemoryRepresentation(origin, WTFMove(callback));
>     });
> }
> 
>-void Engine::representation(PAL::SessionID sessionID, CompletionHandler<void(String&&)>&& callback)
>+void Engine::representation(NetworkProcess& networkProcess, PAL::SessionID sessionID, CompletionHandler<void(String&&)>&& callback)
> {
>-    from(sessionID, [callback = WTFMove(callback)](auto& engine) mutable {
>+    from(networkProcess, sessionID, [callback = WTFMove(callback)](auto& engine) mutable {
>         callback(engine.representation());
>     });
> }
> 
>-void Engine::clearAllCaches(PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)
>+void Engine::clearAllCaches(NetworkProcess& networkProcess, PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)
> {
>-    from(sessionID, [completionHandler = WTFMove(completionHandler)](auto& engine) mutable {
>+    from(networkProcess, sessionID, [completionHandler = WTFMove(completionHandler)](auto& engine) mutable {
>         engine.clearAllCaches(WTFMove(completionHandler));
>     });
> }
> 
>-void Engine::clearCachesForOrigin(PAL::SessionID sessionID, WebCore::SecurityOriginData&& originData, CompletionHandler<void()>&& completionHandler)
>+void Engine::clearCachesForOrigin(NetworkProcess& networkProcess, PAL::SessionID sessionID, WebCore::SecurityOriginData&& originData, CompletionHandler<void()>&& completionHandler)
> {
>-    from(sessionID, [originData = WTFMove(originData), completionHandler = WTFMove(completionHandler)](auto& engine) mutable {
>+    from(networkProcess, sessionID, [originData = WTFMove(originData), completionHandler = WTFMove(completionHandler)](auto& engine) mutable {
>         engine.clearCachesForOrigin(originData, WTFMove(completionHandler));
>     });
> }
>Index: Source/WebKit/NetworkProcess/cache/CacheStorageEngine.h
>===================================================================
>--- Source/WebKit/NetworkProcess/cache/CacheStorageEngine.h	(revision 239670)
>+++ Source/WebKit/NetworkProcess/cache/CacheStorageEngine.h	(working copy)
>@@ -48,6 +48,8 @@ class CallbackAggregator;
> 
> namespace WebKit {
> 
>+class NetworkProcess;
>+
> namespace CacheStorage {
> 
> using CacheIdentifier = uint64_t;
>@@ -57,26 +59,26 @@ class Engine : public RefCounted<Engine>
> public:
>     ~Engine();
> 
>-    static void from(PAL::SessionID, Function<void(Engine&)>&&);
>-    static void destroyEngine(PAL::SessionID);
>-    static void fetchEntries(PAL::SessionID, bool shouldComputeSize, WTF::CompletionHandler<void(Vector<WebsiteData::Entry>)>&&);
>-
>-    static void open(PAL::SessionID, WebCore::ClientOrigin&&, String&& cacheName, WebCore::DOMCacheEngine::CacheIdentifierCallback&&);
>-    static void remove(PAL::SessionID, uint64_t cacheIdentifier, WebCore::DOMCacheEngine::CacheIdentifierCallback&&);
>-    static void retrieveCaches(PAL::SessionID, WebCore::ClientOrigin&&, uint64_t updateCounter, WebCore::DOMCacheEngine::CacheInfosCallback&&);
>-
>-    static void retrieveRecords(PAL::SessionID, uint64_t cacheIdentifier, URL&&, WebCore::DOMCacheEngine::RecordsCallback&&);
>-    static void putRecords(PAL::SessionID, uint64_t cacheIdentifier, Vector<WebCore::DOMCacheEngine::Record>&&, WebCore::DOMCacheEngine::RecordIdentifiersCallback&&);
>-    static void deleteMatchingRecords(PAL::SessionID, uint64_t cacheIdentifier, WebCore::ResourceRequest&&, WebCore::CacheQueryOptions&&, WebCore::DOMCacheEngine::RecordIdentifiersCallback&&);
>+    static void from(NetworkProcess&, PAL::SessionID, CompletionHandler<void(Engine&)>&&);
>+    static void destroyEngine(NetworkProcess&, PAL::SessionID);
>+    static void fetchEntries(NetworkProcess&, PAL::SessionID, bool shouldComputeSize, CompletionHandler<void(Vector<WebsiteData::Entry>)>&&);
>+
>+    static void open(NetworkProcess&, PAL::SessionID, WebCore::ClientOrigin&&, String&& cacheName, WebCore::DOMCacheEngine::CacheIdentifierCallback&&);
>+    static void remove(NetworkProcess&, PAL::SessionID, uint64_t cacheIdentifier, WebCore::DOMCacheEngine::CacheIdentifierCallback&&);
>+    static void retrieveCaches(NetworkProcess&, PAL::SessionID, WebCore::ClientOrigin&&, uint64_t updateCounter, WebCore::DOMCacheEngine::CacheInfosCallback&&);
>+
>+    static void retrieveRecords(NetworkProcess&, PAL::SessionID, uint64_t cacheIdentifier, URL&&, WebCore::DOMCacheEngine::RecordsCallback&&);
>+    static void putRecords(NetworkProcess&, PAL::SessionID, uint64_t cacheIdentifier, Vector<WebCore::DOMCacheEngine::Record>&&, WebCore::DOMCacheEngine::RecordIdentifiersCallback&&);
>+    static void deleteMatchingRecords(NetworkProcess&, PAL::SessionID, uint64_t cacheIdentifier, WebCore::ResourceRequest&&, WebCore::CacheQueryOptions&&, WebCore::DOMCacheEngine::RecordIdentifiersCallback&&);
> 
>-    static void lock(PAL::SessionID, uint64_t cacheIdentifier);
>-    static void unlock(PAL::SessionID, uint64_t cacheIdentifier);
>+    static void lock(NetworkProcess&, PAL::SessionID, uint64_t cacheIdentifier);
>+    static void unlock(NetworkProcess&, PAL::SessionID, uint64_t cacheIdentifier);
> 
>-    static void clearMemoryRepresentation(PAL::SessionID, WebCore::ClientOrigin&&, WebCore::DOMCacheEngine::CompletionCallback&&);
>-    static void representation(PAL::SessionID, CompletionHandler<void(String&&)>&&);
>+    static void clearMemoryRepresentation(NetworkProcess&, PAL::SessionID, WebCore::ClientOrigin&&, WebCore::DOMCacheEngine::CompletionCallback&&);
>+    static void representation(NetworkProcess&, PAL::SessionID, CompletionHandler<void(String&&)>&&);
> 
>-    static void clearAllCaches(PAL::SessionID, CompletionHandler<void()>&&);
>-    static void clearCachesForOrigin(PAL::SessionID, WebCore::SecurityOriginData&&, CompletionHandler<void()>&&);
>+    static void clearAllCaches(NetworkProcess&, PAL::SessionID, CompletionHandler<void()>&&);
>+    static void clearCachesForOrigin(NetworkProcess&, PAL::SessionID, WebCore::SecurityOriginData&&, CompletionHandler<void()>&&);
> 
>     bool shouldPersist() const { return !!m_ioQueue;}
> 
>@@ -113,16 +115,16 @@ private:
> 
>     String cachesRootPath(const WebCore::ClientOrigin&);
> 
>-    void fetchEntries(bool /* shouldComputeSize */, WTF::CompletionHandler<void(Vector<WebsiteData::Entry>)>&&);
>+    void fetchEntries(bool /* shouldComputeSize */, CompletionHandler<void(Vector<WebsiteData::Entry>)>&&);
> 
>     void initialize(WebCore::DOMCacheEngine::CompletionCallback&&);
> 
>     using CachesOrError = Expected<std::reference_wrapper<Caches>, WebCore::DOMCacheEngine::Error>;
>-    using CachesCallback = WTF::Function<void(CachesOrError&&)>;
>+    using CachesCallback = CompletionHandler<void(CachesOrError&&)>;
>     void readCachesFromDisk(const WebCore::ClientOrigin&, CachesCallback&&);
> 
>     using CacheOrError = Expected<std::reference_wrapper<Cache>, WebCore::DOMCacheEngine::Error>;
>-    using CacheCallback = WTF::Function<void(CacheOrError&&)>;
>+    using CacheCallback = CompletionHandler<void(CacheOrError&&)>;
>     void readCache(uint64_t cacheIdentifier, CacheCallback&&);
> 
>     Cache* cache(uint64_t cacheIdentifier);
>Index: Source/WebKit/NetworkProcess/cache/CacheStorageEngineConnection.cpp
>===================================================================
>--- Source/WebKit/NetworkProcess/cache/CacheStorageEngineConnection.cpp	(revision 239670)
>+++ Source/WebKit/NetworkProcess/cache/CacheStorageEngineConnection.cpp	(working copy)
>@@ -57,7 +57,7 @@ CacheStorageEngineConnection::~CacheStor
>         auto& sessionID = keyValue.key;
>         for (auto& references : keyValue.value) {
>             ASSERT(references.value);
>-            Engine::unlock(sessionID, references.key);
>+            Engine::unlock(m_connection.networkProcess(), sessionID, references.key);
>         }
>     }
> }
>@@ -65,7 +65,7 @@ CacheStorageEngineConnection::~CacheStor
> void CacheStorageEngineConnection::open(PAL::SessionID sessionID, uint64_t requestIdentifier, WebCore::ClientOrigin&& origin, String&& cacheName)
> {
>     RELEASE_LOG_IF_ALLOWED("open (%" PRIu64 ")", requestIdentifier);
>-    Engine::open(sessionID, WTFMove(origin), WTFMove(cacheName), [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](const CacheIdentifierOrError& result) {
>+    Engine::open(m_connection.networkProcess(), sessionID, WTFMove(origin), WTFMove(cacheName), [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](const CacheIdentifierOrError& result) {
>         RELEASE_LOG_FUNCTION_IF_ALLOWED_IN_CALLBACK("open", "cache identifier is %" PRIu64, [](const auto& value) { return value.identifier; });
>         connection->send(Messages::WebCacheStorageConnection::OpenCompleted(requestIdentifier, result), sessionID.sessionID());
>     });
>@@ -74,7 +74,7 @@ void CacheStorageEngineConnection::open(
> void CacheStorageEngineConnection::remove(PAL::SessionID sessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier)
> {
>     RELEASE_LOG_IF_ALLOWED("remove (%" PRIu64 ") cache %" PRIu64, requestIdentifier, cacheIdentifier);
>-    Engine::remove(sessionID, cacheIdentifier, [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](const CacheIdentifierOrError& result) {
>+    Engine::remove(m_connection.networkProcess(), sessionID, cacheIdentifier, [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](const CacheIdentifierOrError& result) {
>         RELEASE_LOG_FUNCTION_IF_ALLOWED_IN_CALLBACK("remove", "removed cache %" PRIu64, [](const auto& value) { return value.identifier; });
>         connection->send(Messages::WebCacheStorageConnection::RemoveCompleted(requestIdentifier, result), sessionID.sessionID());
>     });
>@@ -83,7 +83,7 @@ void CacheStorageEngineConnection::remov
> void CacheStorageEngineConnection::caches(PAL::SessionID sessionID, uint64_t requestIdentifier, WebCore::ClientOrigin&& origin, uint64_t updateCounter)
> {
>     RELEASE_LOG_IF_ALLOWED("caches (%" PRIu64 ")", requestIdentifier);
>-    Engine::retrieveCaches(sessionID, WTFMove(origin), updateCounter, [connection = makeRef(m_connection.connection()), sessionID, origin, requestIdentifier](CacheInfosOrError&& result) {
>+    Engine::retrieveCaches(m_connection.networkProcess(), sessionID, WTFMove(origin), updateCounter, [connection = makeRef(m_connection.connection()), sessionID, origin, requestIdentifier](CacheInfosOrError&& result) {
>         RELEASE_LOG_FUNCTION_IF_ALLOWED_IN_CALLBACK("caches", "caches size is %lu", [](const auto& value) { return value.infos.size(); });
>         connection->send(Messages::WebCacheStorageConnection::UpdateCaches(requestIdentifier, result), sessionID.sessionID());
>     });
>@@ -92,7 +92,7 @@ void CacheStorageEngineConnection::cache
> void CacheStorageEngineConnection::retrieveRecords(PAL::SessionID sessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier, URL&& url)
> {
>     RELEASE_LOG_IF_ALLOWED("retrieveRecords (%" PRIu64 ") in cache %" PRIu64, requestIdentifier, cacheIdentifier);
>-    Engine::retrieveRecords(sessionID, cacheIdentifier, WTFMove(url), [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](RecordsOrError&& result) {
>+    Engine::retrieveRecords(m_connection.networkProcess(), sessionID, cacheIdentifier, WTFMove(url), [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](RecordsOrError&& result) {
>         RELEASE_LOG_FUNCTION_IF_ALLOWED_IN_CALLBACK("retrieveRecords", "records size is %lu", [](const auto& value) { return value.size(); });
>         connection->send(Messages::WebCacheStorageConnection::UpdateRecords(requestIdentifier, result), sessionID.sessionID());
>     });
>@@ -101,7 +101,7 @@ void CacheStorageEngineConnection::retri
> void CacheStorageEngineConnection::deleteMatchingRecords(PAL::SessionID sessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier, WebCore::ResourceRequest&& request, WebCore::CacheQueryOptions&& options)
> {
>     RELEASE_LOG_IF_ALLOWED("deleteMatchingRecords (%" PRIu64 ") in cache %" PRIu64, requestIdentifier, cacheIdentifier);
>-    Engine::deleteMatchingRecords(sessionID, cacheIdentifier, WTFMove(request), WTFMove(options), [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](RecordIdentifiersOrError&& result) {
>+    Engine::deleteMatchingRecords(m_connection.networkProcess(), sessionID, cacheIdentifier, WTFMove(request), WTFMove(options), [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](RecordIdentifiersOrError&& result) {
>         RELEASE_LOG_FUNCTION_IF_ALLOWED_IN_CALLBACK("deleteMatchingRecords", "deleted %lu records",  [](const auto& value) { return value.size(); });
>         connection->send(Messages::WebCacheStorageConnection::DeleteRecordsCompleted(requestIdentifier, result), sessionID.sessionID());
>     });
>@@ -110,7 +110,7 @@ void CacheStorageEngineConnection::delet
> void CacheStorageEngineConnection::putRecords(PAL::SessionID sessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier, Vector<Record>&& records)
> {
>     RELEASE_LOG_IF_ALLOWED("putRecords (%" PRIu64 ") in cache %" PRIu64 ", %lu records", requestIdentifier, cacheIdentifier, records.size());
>-    Engine::putRecords(sessionID, cacheIdentifier, WTFMove(records), [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](RecordIdentifiersOrError&& result) {
>+    Engine::putRecords(m_connection.networkProcess(), sessionID, cacheIdentifier, WTFMove(records), [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](RecordIdentifiersOrError&& result) {
>         RELEASE_LOG_FUNCTION_IF_ALLOWED_IN_CALLBACK("putRecords", "put %lu records",  [](const auto& value) { return value.size(); });
>         connection->send(Messages::WebCacheStorageConnection::PutRecordsCompleted(requestIdentifier, result), sessionID.sessionID());
>     });
>@@ -126,7 +126,7 @@ void CacheStorageEngineConnection::refer
>         return 0;
>     }).iterator->value;
>     if (!counter++)
>-        Engine::lock(sessionID, cacheIdentifier);
>+        Engine::lock(m_connection.networkProcess(), sessionID, cacheIdentifier);
> }
> 
> void CacheStorageEngineConnection::dereference(PAL::SessionID sessionID, uint64_t cacheIdentifier)
>@@ -145,20 +145,20 @@ void CacheStorageEngineConnection::deref
>     if (--referenceResult->value)
>         return;
> 
>-    Engine::unlock(sessionID, cacheIdentifier);
>+    Engine::unlock(m_connection.networkProcess(), sessionID, cacheIdentifier);
>     references.remove(referenceResult);
> }
> 
> void CacheStorageEngineConnection::clearMemoryRepresentation(PAL::SessionID sessionID, uint64_t requestIdentifier, WebCore::ClientOrigin&& origin)
> {
>-    Engine::clearMemoryRepresentation(sessionID, WTFMove(origin), [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier] (Optional<Error>&& error) {
>+    Engine::clearMemoryRepresentation(m_connection.networkProcess(), sessionID, WTFMove(origin), [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier] (Optional<Error>&& error) {
>         connection->send(Messages::WebCacheStorageConnection::ClearMemoryRepresentationCompleted(requestIdentifier, error), sessionID.sessionID());
>     });
> }
> 
> void CacheStorageEngineConnection::engineRepresentation(PAL::SessionID sessionID, uint64_t requestIdentifier)
> {
>-    Engine::representation(sessionID, [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier] (auto&& representation) {
>+    Engine::representation(m_connection.networkProcess(), sessionID, [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier] (auto&& representation) {
>         connection->send(Messages::WebCacheStorageConnection::EngineRepresentationCompleted { requestIdentifier, representation }, sessionID.sessionID());
>     });
> }
>Index: Source/WebKit/NetworkProcess/cache/NetworkCache.cpp
>===================================================================
>--- Source/WebKit/NetworkProcess/cache/NetworkCache.cpp	(revision 239670)
>+++ Source/WebKit/NetworkProcess/cache/NetworkCache.cpp	(working copy)
>@@ -371,7 +371,7 @@ std::unique_ptr<Entry> Cache::makeRedire
>     return std::make_unique<Entry>(makeCacheKey(request), response, redirectRequest, WebCore::collectVaryingRequestHeaders(request, response));
> }
> 
>-std::unique_ptr<Entry> Cache::store(const WebCore::ResourceRequest& request, const WebCore::ResourceResponse& response, RefPtr<WebCore::SharedBuffer>&& responseData, Function<void (MappedBody&)>&& completionHandler)
>+std::unique_ptr<Entry> Cache::store(const WebCore::ResourceRequest& request, const WebCore::ResourceResponse& response, RefPtr<WebCore::SharedBuffer>&& responseData, CompletionHandler<void(MappedBody&)>&& completionHandler)
> {
>     ASSERT(responseData);
> 
>@@ -397,7 +397,7 @@ std::unique_ptr<Entry> Cache::store(cons
>     auto cacheEntry = makeEntry(request, response, WTFMove(responseData));
>     auto record = cacheEntry->encodeAsStorageRecord();
> 
>-    m_storage->store(record, [protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](const Data& bodyData) {
>+    m_storage->store(record, [protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](const Data& bodyData) mutable {
>         MappedBody mappedBody;
> #if ENABLE(SHAREABLE_RESOURCE)
>         if (auto sharedMemory = bodyData.tryCreateSharedMemory()) {
>@@ -473,19 +473,19 @@ void Cache::remove(const WebCore::Resour
>     remove(makeCacheKey(request));
> }
> 
>-void Cache::remove(const Vector<Key>& keys, Function<void ()>&& completionHandler)
>+void Cache::remove(const Vector<Key>& keys, CompletionHandler<void()>&& completionHandler)
> {
>     m_storage->remove(keys, WTFMove(completionHandler));
> }
> 
>-void Cache::traverse(Function<void (const TraversalEntry*)>&& traverseHandler)
>+void Cache::traverse(CompletionHandler<void(const TraversalEntry*)>&& traverseHandler)
> {
>     // Protect against clients making excessive traversal requests.
>     const unsigned maximumTraverseCount = 3;
>     if (m_traverseCount >= maximumTraverseCount) {
>         WTFLogAlways("Maximum parallel cache traverse count exceeded. Ignoring traversal request.");
> 
>-        RunLoop::main().dispatch([traverseHandler = WTFMove(traverseHandler)] {
>+        RunLoop::main().dispatch([traverseHandler = WTFMove(traverseHandler)] () mutable {
>             traverseHandler(nullptr);
>         });
>         return;
>@@ -493,7 +493,7 @@ void Cache::traverse(Function<void (cons
> 
>     ++m_traverseCount;
> 
>-    m_storage->traverse(resourceType(), { }, [this, protectedThis = makeRef(*this), traverseHandler = WTFMove(traverseHandler)](const Storage::Record* record, const Storage::RecordInfo& recordInfo) {
>+    m_storage->traverse(resourceType(), { }, [this, protectedThis = makeRef(*this), traverseHandler = WTFMove(traverseHandler)] (const Storage::Record* record, const Storage::RecordInfo& recordInfo) mutable {
>         if (!record) {
>             --m_traverseCount;
>             traverseHandler(nullptr);
>@@ -501,8 +501,10 @@ void Cache::traverse(Function<void (cons
>         }
> 
>         auto entry = Entry::decodeStorageRecord(*record);
>-        if (!entry)
>+        if (!entry) {
>+            traverseHandler(nullptr);
>             return;
>+        }
> 
>         TraversalEntry traversalEntry { *entry, recordInfo };
>         traverseHandler(&traversalEntry);
>@@ -575,7 +577,7 @@ void Cache::deleteDumpFile()
>     });
> }
> 
>-void Cache::clear(WallTime modifiedSince, Function<void ()>&& completionHandler)
>+void Cache::clear(WallTime modifiedSince, CompletionHandler<void()>&& completionHandler)
> {
>     LOG(NetworkCache, "(NetworkProcess) clearing cache");
> 
>@@ -598,10 +600,10 @@ String Cache::recordsPath() const
>     return m_storage->recordsPath();
> }
> 
>-void Cache::retrieveData(const DataKey& dataKey, Function<void (const uint8_t* data, size_t size)> completionHandler)
>+void Cache::retrieveData(const DataKey& dataKey, CompletionHandler<void(const uint8_t*, size_t)> completionHandler)
> {
>     Key key { dataKey, m_storage->salt() };
>-    m_storage->retrieve(key, 4, [completionHandler = WTFMove(completionHandler)] (auto record, auto) {
>+    m_storage->retrieve(key, 4, [completionHandler = WTFMove(completionHandler)] (auto record, auto) mutable {
>         if (!record || !record->body.size()) {
>             completionHandler(nullptr, 0);
>             return true;
>Index: Source/WebKit/NetworkProcess/cache/NetworkCache.h
>===================================================================
>--- Source/WebKit/NetworkProcess/cache/NetworkCache.h	(revision 239670)
>+++ Source/WebKit/NetworkProcess/cache/NetworkCache.h	(working copy)
>@@ -29,7 +29,7 @@
> #include "NetworkCacheStorage.h"
> #include "ShareableResource.h"
> #include <WebCore/ResourceResponse.h>
>-#include <wtf/Function.h>
>+#include <wtf/CompletionHandler.h>
> #include <wtf/OptionSet.h>
> #include <wtf/Seconds.h>
> #include <wtf/text/WTFString.h>
>@@ -111,9 +111,9 @@ public:
> 
>         WTF_MAKE_FAST_ALLOCATED;
>     };
>-    using RetrieveCompletionHandler = Function<void (std::unique_ptr<Entry>, const RetrieveInfo&)>;
>+    using RetrieveCompletionHandler = CompletionHandler<void(std::unique_ptr<Entry>, const RetrieveInfo&)>;
>     void retrieve(const WebCore::ResourceRequest&, const GlobalFrameID&, RetrieveCompletionHandler&&);
>-    std::unique_ptr<Entry> store(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, RefPtr<WebCore::SharedBuffer>&&, Function<void (MappedBody&)>&&);
>+    std::unique_ptr<Entry> store(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, RefPtr<WebCore::SharedBuffer>&&, CompletionHandler<void(MappedBody&)>&&);
>     std::unique_ptr<Entry> storeRedirect(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, const WebCore::ResourceRequest& redirectRequest, Optional<Seconds> maxAgeCap);
>     std::unique_ptr<Entry> update(const WebCore::ResourceRequest&, const GlobalFrameID&, const Entry&, const WebCore::ResourceResponse& validatingResponse);
> 
>@@ -121,15 +121,15 @@ public:
>         const Entry& entry;
>         const Storage::RecordInfo& recordInfo;
>     };
>-    void traverse(Function<void (const TraversalEntry*)>&&);
>+    void traverse(CompletionHandler<void(const TraversalEntry*)>&&);
>     void remove(const Key&);
>     void remove(const WebCore::ResourceRequest&);
>-    void remove(const Vector<Key>&, Function<void ()>&&);
>+    void remove(const Vector<Key>&, CompletionHandler<void()>&&);
> 
>     void clear();
>-    void clear(WallTime modifiedSince, Function<void ()>&& completionHandler);
>+    void clear(WallTime modifiedSince, CompletionHandler<void()>&&);
> 
>-    void retrieveData(const DataKey&, Function<void (const uint8_t* data, size_t size)>);
>+    void retrieveData(const DataKey&, CompletionHandler<void(const uint8_t*, size_t)>);
>     void storeData(const DataKey&,  const uint8_t* data, size_t);
>     
>     std::unique_ptr<Entry> makeEntry(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, RefPtr<WebCore::SharedBuffer>&&);

Flags:

aestes: review+

Actions: View | Formatted Diff | Diff

Attachments on bug 193220: 358541