Attachment 370509 Details for Bug 195757 – Patch for landing

[patch] Patch for landing

bug-195757-20190523105830.patch (text/plain), 81.83 KB, created by youenn fablet on 2019-05-23 10:58:30 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: youenn fablet

Created: 2019-05-23 10:58:30 PDT

Size: 81.83 KB

patch

obsolete

>Subversion Revision: 245568
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 3bd5d4a494c038a72f33f4a196ec20790ce81e67..614802412978cd9dc3218dddf25ebfe81721feb4 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,45 @@
>+2019-05-22  Youenn Fablet  <youenn@apple.com>
>+
>+        CacheStorageConnection callbacks should be completed on network connection close
>+        https://bugs.webkit.org/show_bug.cgi?id=195757
>+
>+        Reviewed by Alex Christensen.
>+
>+        Move HashMap-based callbacks to WorkerCacheStorageConnection.
>+        Make CacheStorageConnection default API to implement use callbacks.
>+        This is used by WebKit layer to do AsyncReply IPC.
>+
>+        Move DOMCacheEngine callbacks to CompletionHandler.
>+
>+        Test: http/wpt/cache-storage/cache-storage-networkprocess-crash.html
>+
>+        * Modules/cache/CacheStorageConnection.cpp:
>+        * Modules/cache/CacheStorageConnection.h:
>+        (WebCore::CacheStorageConnection::engineRepresentation):
>+        * Modules/cache/DOMCacheEngine.h:
>+        * Modules/cache/WorkerCacheStorageConnection.cpp:
>+        (WebCore::recordsDataFromRecords):
>+        (WebCore::recordsDataOrErrorFromRecords):
>+        (WebCore::recordsFromRecordsData):
>+        (WebCore::recordsOrErrorFromRecordsData):
>+        (WebCore::WorkerCacheStorageConnection::open):
>+        (WebCore::WorkerCacheStorageConnection::openOrRemoveCompleted):
>+        (WebCore::WorkerCacheStorageConnection::remove):
>+        (WebCore::WorkerCacheStorageConnection::retrieveCaches):
>+        (WebCore::WorkerCacheStorageConnection::retrieveCachesCompleted):
>+        (WebCore::WorkerCacheStorageConnection::retrieveRecords):
>+        (WebCore::WorkerCacheStorageConnection::retrieveRecordsCompleted):
>+        (WebCore::WorkerCacheStorageConnection::batchDeleteOperation):
>+        (WebCore::WorkerCacheStorageConnection::deleteRecordsCompleted):
>+        (WebCore::WorkerCacheStorageConnection::batchPutOperation):
>+        (WebCore::WorkerCacheStorageConnection::putRecordsCompleted):
>+        (WebCore::WorkerCacheStorageConnection::reference):
>+        (WebCore::WorkerCacheStorageConnection::dereference):
>+        (WebCore::WorkerCacheStorageConnection::clearPendingRequests):
>+        * Modules/cache/WorkerCacheStorageConnection.h:
>+        * page/CacheStorageProvider.h:
>+        (WebCore::CacheStorageProvider::createCacheStorageConnection):
>+
> 2019-05-22  Youenn Fablet  <youenn@apple.com>
> 
>         Multiple videos (with audios) with autoplay & playinline not working. Only one video play at a time.
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index 1e7bb92a6773c644965d123379279822c75c7f47..4aa433e0d1bcf16045385936a2feec79459c6018 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,55 @@
>+2019-05-22  Youenn Fablet  <youenn@apple.com>
>+
>+        CacheStorageConnection callbacks should be completed on network connection close
>+        https://bugs.webkit.org/show_bug.cgi?id=195757
>+
>+        Reviewed by Alex Christensen.
>+
>+        Update according new WebCore CacheStorageConnection interface.
>+        Use Async IPC replies so that the completion handlers are called on network crash.
>+
>+        Allow to have specific error handling in case of cancelled reply or badly decoded message.
>+        This allows to reject the corresponding JS promise.
>+
>+        * CMakeLists.txt:
>+        * DerivedSources-output.xcfilelist:
>+        * DerivedSources.make:
>+        * NetworkProcess/cache/CacheStorageEngine.cpp:
>+        (WebKit::CacheStorage::Engine::clearMemoryRepresentation):
>+        * NetworkProcess/cache/CacheStorageEngineCaches.cpp:
>+        (WebKit::CacheStorage::Caches::requestSpace):
>+        (WebKit::CacheStorage::Caches::writeRecord):
>+        * NetworkProcess/cache/CacheStorageEngineConnection.cpp:
>+        (WebKit::CacheStorageEngineConnection::open):
>+        (WebKit::CacheStorageEngineConnection::remove):
>+        (WebKit::CacheStorageEngineConnection::caches):
>+        (WebKit::CacheStorageEngineConnection::retrieveRecords):
>+        (WebKit::CacheStorageEngineConnection::deleteMatchingRecords):
>+        (WebKit::CacheStorageEngineConnection::putRecords):
>+        * NetworkProcess/cache/CacheStorageEngineConnection.h:
>+        (IPC::AsyncReplyError<WebCore::DOMCacheEngine::CacheIdentifierOrError>::create):
>+        (IPC::AsyncReplyError<WebCore::DOMCacheEngine::RecordIdentifiersOrError>::create):
>+        (IPC::AsyncReplyError<WebCore::DOMCacheEngine::CacheInfosOrError>::create):
>+        (IPC::AsyncReplyError<WebCore::DOMCacheEngine::RecordsOrError>::create):
>+        * NetworkProcess/cache/CacheStorageEngineConnection.messages.in:
>+        * Platform/IPC/ArgumentCoders.h:
>+        * Platform/IPC/Connection.h:
>+        (IPC::AsyncReplyError::create):
>+        * Scripts/webkit/messages.py:
>+        * WebKit.xcodeproj/project.pbxproj:
>+        * WebProcess/Cache/WebCacheStorageConnection.cpp:
>+        (WebKit::WebCacheStorageConnection::open):
>+        (WebKit::WebCacheStorageConnection::remove):
>+        (WebKit::WebCacheStorageConnection::retrieveCaches):
>+        (WebKit::WebCacheStorageConnection::retrieveRecords):
>+        (WebKit::WebCacheStorageConnection::batchDeleteOperation):
>+        (WebKit::WebCacheStorageConnection::batchPutOperation):
>+        (WebKit::WebCacheStorageConnection::engineRepresentation):
>+        * WebProcess/Cache/WebCacheStorageConnection.h:
>+        * WebProcess/Cache/WebCacheStorageConnection.messages.in: Removed.
>+        * WebProcess/Network/NetworkProcessConnection.cpp:
>+        (WebKit::NetworkProcessConnection::didReceiveMessage):
>+
> 2019-05-22  Youenn Fablet  <youenn@apple.com>
> 
>         Use modern async IPC for EngineRepresentationCompleted and ClearMemoryRepresentationCompleted
>diff --git a/Source/WebCore/Modules/cache/CacheStorageConnection.cpp b/Source/WebCore/Modules/cache/CacheStorageConnection.cpp
>index e394e56a8f8c38afcd8c96d914271632f8a2a600..4acb8aabd867d8de2209379b260c61ffffeb4900 100644
>--- a/Source/WebCore/Modules/cache/CacheStorageConnection.cpp
>+++ b/Source/WebCore/Modules/cache/CacheStorageConnection.cpp
>@@ -33,65 +33,6 @@
> namespace WebCore {
> using namespace WebCore::DOMCacheEngine;
> 
>-void CacheStorageConnection::clearPendingRequests()
>-{
>-    auto openAndRemoveCachePendingRequests = WTFMove(m_openAndRemoveCachePendingRequests);
>-    for (auto& callback : openAndRemoveCachePendingRequests.values())
>-        callback(makeUnexpected(DOMCacheEngine::Error::Stopped));
>-
>-    auto retrieveCachesPendingRequests = WTFMove(m_retrieveCachesPendingRequests);
>-    for (auto& callback : retrieveCachesPendingRequests.values())
>-        callback(makeUnexpected(DOMCacheEngine::Error::Stopped));
>-
>-    auto retrieveRecordsPendingRequests = WTFMove(m_retrieveRecordsPendingRequests);
>-    for (auto& callback : retrieveRecordsPendingRequests.values())
>-        callback(makeUnexpected(DOMCacheEngine::Error::Stopped));
>-
>-    auto batchDeleteAndPutPendingRequests = WTFMove(m_batchDeleteAndPutPendingRequests);
>-    for (auto& callback : batchDeleteAndPutPendingRequests.values())
>-        callback(makeUnexpected(DOMCacheEngine::Error::Stopped));
>-}
>-
>-void CacheStorageConnection::open(const ClientOrigin& origin, const String& cacheName, CacheIdentifierCallback&& callback)
>-{
>-    uint64_t requestIdentifier = ++m_lastRequestIdentifier;
>-    m_openAndRemoveCachePendingRequests.add(requestIdentifier, WTFMove(callback));
>-
>-    doOpen(requestIdentifier, origin, cacheName);
>-}
>-
>-void CacheStorageConnection::remove(uint64_t cacheIdentifier, CacheIdentifierCallback&& callback)
>-{
>-    uint64_t requestIdentifier = ++m_lastRequestIdentifier;
>-    m_openAndRemoveCachePendingRequests.add(requestIdentifier, WTFMove(callback));
>-
>-    doRemove(requestIdentifier, cacheIdentifier);
>-}
>-
>-void CacheStorageConnection::retrieveCaches(const ClientOrigin& origin, uint64_t updateCounter, CacheInfosCallback&& callback)
>-{
>-    uint64_t requestIdentifier = ++m_lastRequestIdentifier;
>-    m_retrieveCachesPendingRequests.add(requestIdentifier, WTFMove(callback));
>-
>-    doRetrieveCaches(requestIdentifier, origin, updateCounter);
>-}
>-
>-void CacheStorageConnection::retrieveRecords(uint64_t cacheIdentifier, const URL& url, RecordsCallback&& callback)
>-{
>-    uint64_t requestIdentifier = ++m_lastRequestIdentifier;
>-    m_retrieveRecordsPendingRequests.add(requestIdentifier, WTFMove(callback));
>-
>-    doRetrieveRecords(requestIdentifier, cacheIdentifier, url);
>-}
>-
>-void CacheStorageConnection::batchDeleteOperation(uint64_t cacheIdentifier, const ResourceRequest& request, CacheQueryOptions&& options, RecordIdentifiersCallback&& callback)
>-{
>-    uint64_t requestIdentifier = ++m_lastRequestIdentifier;
>-    m_batchDeleteAndPutPendingRequests.add(requestIdentifier, WTFMove(callback));
>-
>-    doBatchDeleteOperation(requestIdentifier, cacheIdentifier, request, WTFMove(options));
>-}
>-
> static inline uint64_t computeRealBodySize(const DOMCacheEngine::ResponseBody& body)
> {
>     uint64_t result = 0;
>@@ -123,42 +64,4 @@ uint64_t CacheStorageConnection::computeRecordBodySize(const FetchResponse& resp
>     }).iterator->value;
> }
> 
>-void CacheStorageConnection::batchPutOperation(uint64_t cacheIdentifier, Vector<Record>&& records, RecordIdentifiersCallback&& callback)
>-{
>-    uint64_t requestIdentifier = ++m_lastRequestIdentifier;
>-    m_batchDeleteAndPutPendingRequests.add(requestIdentifier, WTFMove(callback));
>-
>-    doBatchPutOperation(requestIdentifier, cacheIdentifier, WTFMove(records));
>-}
>-
>-void CacheStorageConnection::openOrRemoveCompleted(uint64_t requestIdentifier, const CacheIdentifierOrError& result)
>-{
>-    if (auto callback = m_openAndRemoveCachePendingRequests.take(requestIdentifier))
>-        callback(result);
>-}
>-
>-void CacheStorageConnection::updateCaches(uint64_t requestIdentifier, CacheInfosOrError&& result)
>-{
>-    if (auto callback = m_retrieveCachesPendingRequests.take(requestIdentifier))
>-        callback(WTFMove(result));
>-}
>-
>-void CacheStorageConnection::updateRecords(uint64_t requestIdentifier, RecordsOrError&& result)
>-{
>-    if (auto callback = m_retrieveRecordsPendingRequests.take(requestIdentifier))
>-        callback(WTFMove(result));
>-}
>-
>-void CacheStorageConnection::deleteRecordsCompleted(uint64_t requestIdentifier, Expected<Vector<uint64_t>, Error>&& result)
>-{
>-    if (auto callback = m_batchDeleteAndPutPendingRequests.take(requestIdentifier))
>-        callback(WTFMove(result));
>-}
>-
>-void CacheStorageConnection::putRecordsCompleted(uint64_t requestIdentifier, Expected<Vector<uint64_t>, Error>&& result)
>-{
>-    if (auto callback = m_batchDeleteAndPutPendingRequests.take(requestIdentifier))
>-        callback(WTFMove(result));
>-}
>-
> } // namespace WebCore
>diff --git a/Source/WebCore/Modules/cache/CacheStorageConnection.h b/Source/WebCore/Modules/cache/CacheStorageConnection.h
>index 9aa408d35a4e0e25faa716af203f66034a0a3351..87eab718626c602741489dbc2bfa77e86565ac7c 100644
>--- a/Source/WebCore/Modules/cache/CacheStorageConnection.h
>+++ b/Source/WebCore/Modules/cache/CacheStorageConnection.h
>@@ -37,56 +37,27 @@ class FetchResponse;
> 
> class CacheStorageConnection : public ThreadSafeRefCounted<CacheStorageConnection> {
> public:
>-    static Ref<CacheStorageConnection> create() { return adoptRef(*new CacheStorageConnection()); }
>     virtual ~CacheStorageConnection() = default;
> 
>-    void open(const ClientOrigin&, const String& cacheName, DOMCacheEngine::CacheIdentifierCallback&&);
>-    void remove(uint64_t cacheIdentifier, DOMCacheEngine::CacheIdentifierCallback&&);
>-    void retrieveCaches(const ClientOrigin&, uint64_t updateCounter, DOMCacheEngine::CacheInfosCallback&&);
>+    virtual void open(const ClientOrigin&, const String& cacheName, DOMCacheEngine::CacheIdentifierCallback&&) = 0;
>+    virtual void remove(uint64_t cacheIdentifier, DOMCacheEngine::CacheIdentifierCallback&&) = 0;
>+    virtual void retrieveCaches(const ClientOrigin&, uint64_t updateCounter, DOMCacheEngine::CacheInfosCallback&&) = 0;
> 
>-    void retrieveRecords(uint64_t cacheIdentifier, const URL&, DOMCacheEngine::RecordsCallback&&);
>-    void batchDeleteOperation(uint64_t cacheIdentifier, const ResourceRequest&, CacheQueryOptions&&, DOMCacheEngine::RecordIdentifiersCallback&&);
>-    void batchPutOperation(uint64_t cacheIdentifier, Vector<DOMCacheEngine::Record>&&, DOMCacheEngine::RecordIdentifiersCallback&&);
>-    uint64_t computeRecordBodySize(const FetchResponse&, const DOMCacheEngine::ResponseBody&);
>+    virtual void retrieveRecords(uint64_t cacheIdentifier, const URL&, DOMCacheEngine::RecordsCallback&&) = 0;
>+    virtual void batchDeleteOperation(uint64_t cacheIdentifier, const ResourceRequest&, CacheQueryOptions&&, DOMCacheEngine::RecordIdentifiersCallback&&) = 0;
>+    virtual void batchPutOperation(uint64_t cacheIdentifier, Vector<DOMCacheEngine::Record>&&, DOMCacheEngine::RecordIdentifiersCallback&&) = 0;
>+
>+    virtual void reference(uint64_t /* cacheIdentifier */) = 0;
>+    virtual void dereference(uint64_t /* cacheIdentifier */) = 0;
> 
>-    virtual void reference(uint64_t /* cacheIdentifier */) { }
>-    virtual void dereference(uint64_t /* cacheIdentifier */) { }
>+    uint64_t computeRecordBodySize(const FetchResponse&, const DOMCacheEngine::ResponseBody&);
> 
>     // Used only for testing purposes.
>     virtual void clearMemoryRepresentation(const ClientOrigin&, DOMCacheEngine::CompletionCallback&& callback) { callback(DOMCacheEngine::Error::NotImplemented); }
>-    virtual void engineRepresentation(WTF::Function<void(const String&)>&& callback) { callback(String { }); }
>+    virtual void engineRepresentation(CompletionHandler<void(const String&)>&& callback) { callback(String { }); }
>     virtual void updateQuotaBasedOnSpaceUsage(const ClientOrigin&) { }
> 
>-    void clearPendingRequests();
>-
> protected:
>-    CacheStorageConnection() =  default;
>-
>-    void openCompleted(uint64_t identifier, const DOMCacheEngine::CacheIdentifierOrError& result) { openOrRemoveCompleted(identifier, result); }
>-    void removeCompleted(uint64_t identifier, const DOMCacheEngine::CacheIdentifierOrError& result) { openOrRemoveCompleted(identifier, result); }
>-    WEBCORE_EXPORT void updateCaches(uint64_t requestIdentifier, DOMCacheEngine::CacheInfosOrError&&);
>-
>-    WEBCORE_EXPORT void updateRecords(uint64_t requestIdentifier, DOMCacheEngine::RecordsOrError&&);
>-    WEBCORE_EXPORT void deleteRecordsCompleted(uint64_t requestIdentifier, DOMCacheEngine::RecordIdentifiersOrError&&);
>-    WEBCORE_EXPORT void putRecordsCompleted(uint64_t requestIdentifier, DOMCacheEngine::RecordIdentifiersOrError&&);
>-
>-private:
>-    virtual void doOpen(uint64_t requestIdentifier, const ClientOrigin&, const String& /* cacheName */) { openCompleted(requestIdentifier, makeUnexpected(DOMCacheEngine::Error::NotImplemented)); }
>-    virtual void doRemove(uint64_t requestIdentifier, uint64_t /* cacheIdentifier */) { removeCompleted(requestIdentifier, makeUnexpected(DOMCacheEngine::Error::NotImplemented)); }
>-    virtual void doRetrieveCaches(uint64_t requestIdentifier, const ClientOrigin&, uint64_t /* updateCounter */) { updateCaches(requestIdentifier, { }); }
>-
>-    virtual void doRetrieveRecords(uint64_t requestIdentifier, uint64_t /* cacheIdentifier */, const URL& /* url */) { updateRecords(requestIdentifier, { }); }
>-    virtual void doBatchDeleteOperation(uint64_t requestIdentifier, uint64_t /* cacheIdentifier */, const ResourceRequest&, CacheQueryOptions&&) { deleteRecordsCompleted(requestIdentifier, makeUnexpected(DOMCacheEngine::Error::NotImplemented)); }
>-    virtual void doBatchPutOperation(uint64_t requestIdentifier, uint64_t /* cacheIdentifier */, Vector<DOMCacheEngine::Record>&&) { putRecordsCompleted(requestIdentifier, makeUnexpected(DOMCacheEngine::Error::NotImplemented)); }
>-
>-    WEBCORE_EXPORT void openOrRemoveCompleted(uint64_t requestIdentifier, const DOMCacheEngine::CacheIdentifierOrError&);
>-
>-    HashMap<uint64_t, DOMCacheEngine::CacheIdentifierCallback> m_openAndRemoveCachePendingRequests;
>-    HashMap<uint64_t, DOMCacheEngine::CacheInfosCallback> m_retrieveCachesPendingRequests;
>-    HashMap<uint64_t, DOMCacheEngine::RecordsCallback> m_retrieveRecordsPendingRequests;
>-    HashMap<uint64_t, DOMCacheEngine::RecordIdentifiersCallback> m_batchDeleteAndPutPendingRequests;
>     HashMap<uint64_t, uint64_t> m_opaqueResponseToSizeWithPaddingMap;
>-
>-    uint64_t m_lastRequestIdentifier { 0 };
> };
> } // namespace WebCore
>diff --git a/Source/WebCore/Modules/cache/DOMCacheEngine.h b/Source/WebCore/Modules/cache/DOMCacheEngine.h
>index b79dd12f6e5d45d191396134aefaee9f5933a6ed..efb04299b90ee855133b7c14c1d9b86457213d64 100644
>--- a/Source/WebCore/Modules/cache/DOMCacheEngine.h
>+++ b/Source/WebCore/Modules/cache/DOMCacheEngine.h
>@@ -32,6 +32,7 @@
> #include "ResourceResponse.h"
> #include "ScriptExecutionContext.h"
> #include "SharedBuffer.h"
>+#include <wtf/CompletionHandler.h>
> 
> namespace WebCore {
> 
>@@ -99,19 +100,19 @@ struct CacheIdentifierOperationResult {
> };
> 
> using CacheIdentifierOrError = Expected<CacheIdentifierOperationResult, Error>;
>-using CacheIdentifierCallback = WTF::Function<void(const CacheIdentifierOrError&)>;
>+using CacheIdentifierCallback = CompletionHandler<void(const CacheIdentifierOrError&)>;
> 
> using RecordIdentifiersOrError = Expected<Vector<uint64_t>, Error>;
>-using RecordIdentifiersCallback = WTF::Function<void(RecordIdentifiersOrError&&)>;
>+using RecordIdentifiersCallback = CompletionHandler<void(RecordIdentifiersOrError&&)>;
> 
> 
> using CacheInfosOrError = Expected<CacheInfos, Error>;
>-using CacheInfosCallback = WTF::Function<void(CacheInfosOrError&&)>;
>+using CacheInfosCallback = CompletionHandler<void(CacheInfosOrError&&)>;
> 
> using RecordsOrError = Expected<Vector<Record>, Error>;
>-using RecordsCallback = WTF::Function<void(RecordsOrError&&)>;
>+using RecordsCallback = CompletionHandler<void(RecordsOrError&&)>;
> 
>-using CompletionCallback = WTF::Function<void(Optional<Error>&&)>;
>+using CompletionCallback = CompletionHandler<void(Optional<Error>&&)>;
> 
> template<class Encoder> inline void CacheInfos::encode(Encoder& encoder) const
> {
>diff --git a/Source/WebCore/Modules/cache/WorkerCacheStorageConnection.cpp b/Source/WebCore/Modules/cache/WorkerCacheStorageConnection.cpp
>index 1ebdd5de48a7e7e1c96a01c78fed7da5bc4fb888..206c2418e987fedfda2101e6eba5f5a5ba0af3ef 100644
>--- a/Source/WebCore/Modules/cache/WorkerCacheStorageConnection.cpp
>+++ b/Source/WebCore/Modules/cache/WorkerCacheStorageConnection.cpp
>@@ -88,6 +88,31 @@ static Record fromCrossThreadRecordData(CrossThreadRecordData&& data)
>     };
> }
> 
>+static inline Vector<CrossThreadRecordData> recordsDataFromRecords(const Vector<Record>& records)
>+{
>+    return WTF::map(records, toCrossThreadRecordData);
>+}
>+
>+static inline Expected<Vector<CrossThreadRecordData>, Error> recordsDataOrErrorFromRecords(const RecordsOrError& result)
>+{
>+    if (!result.has_value())
>+        return makeUnexpected(result.error());
>+
>+    return recordsDataFromRecords(result.value());
>+}
>+
>+static inline Vector<Record> recordsFromRecordsData(Vector<CrossThreadRecordData>&& recordsData)
>+{
>+    return WTF::map(WTFMove(recordsData), fromCrossThreadRecordData);
>+}
>+
>+static inline RecordsOrError recordsOrErrorFromRecordsData(Expected<Vector<CrossThreadRecordData>, Error>&& recordsData)
>+{
>+    if (!recordsData.has_value())
>+        return makeUnexpected(recordsData.error());
>+    return recordsFromRecordsData(WTFMove(recordsData.value()));
>+}
>+
> Ref<WorkerCacheStorageConnection> WorkerCacheStorageConnection::create(WorkerGlobalScope& scope)
> {
>     auto connection = adoptRef(*new WorkerCacheStorageConnection(scope));
>@@ -109,31 +134,46 @@ WorkerCacheStorageConnection::~WorkerCacheStorageConnection()
>         callOnMainThread([mainThreadConnection = WTFMove(m_mainThreadConnection)]() mutable { });
> }
> 
>-void WorkerCacheStorageConnection::doOpen(uint64_t requestIdentifier, const ClientOrigin& origin, const String& cacheName)
>+void WorkerCacheStorageConnection::open(const ClientOrigin& origin, const String& cacheName, CacheIdentifierCallback&& callback)
> {
>+    uint64_t requestIdentifier = ++m_lastRequestIdentifier;
>+    m_openAndRemoveCachePendingRequests.add(requestIdentifier, WTFMove(callback));
>+
>     callOnMainThread([workerThread = makeRef(m_scope.thread()), mainThreadConnection = m_mainThreadConnection, requestIdentifier, origin = origin.isolatedCopy(), cacheName = cacheName.isolatedCopy()] () mutable {
>         mainThreadConnection->open(origin, cacheName, [workerThread = WTFMove(workerThread), requestIdentifier] (const CacheIdentifierOrError& result) mutable {
>             workerThread->runLoop().postTaskForMode([requestIdentifier, result] (auto& scope) mutable {
>-                downcast<WorkerGlobalScope>(scope).cacheStorageConnection().openCompleted(requestIdentifier, result);
>+                downcast<WorkerGlobalScope>(scope).cacheStorageConnection().openOrRemoveCompleted(requestIdentifier, result);
>             }, WorkerRunLoop::defaultMode());
>         });
>     });
> }
> 
>-void WorkerCacheStorageConnection::doRemove(uint64_t requestIdentifier, uint64_t cacheIdentifier)
>+void WorkerCacheStorageConnection::openOrRemoveCompleted(uint64_t requestIdentifier, const CacheIdentifierOrError& result)
>+{
>+    if (auto callback = m_openAndRemoveCachePendingRequests.take(requestIdentifier))
>+        callback(result);
>+}
>+
>+void WorkerCacheStorageConnection::remove(uint64_t cacheIdentifier, CacheIdentifierCallback&& callback)
> {
>+    uint64_t requestIdentifier = ++m_lastRequestIdentifier;
>+    m_openAndRemoveCachePendingRequests.add(requestIdentifier, WTFMove(callback));
>+
>     callOnMainThread([workerThread = makeRef(m_scope.thread()), mainThreadConnection = m_mainThreadConnection, requestIdentifier, cacheIdentifier] () mutable {
>         mainThreadConnection->remove(cacheIdentifier, [workerThread = WTFMove(workerThread), requestIdentifier, cacheIdentifier] (const CacheIdentifierOrError& result) mutable {
>             ASSERT_UNUSED(cacheIdentifier, !result.has_value() || !result.value().identifier || result.value().identifier == cacheIdentifier);
>             workerThread->runLoop().postTaskForMode([requestIdentifier, result] (auto& scope) mutable {
>-                downcast<WorkerGlobalScope>(scope).cacheStorageConnection().removeCompleted(requestIdentifier, result);
>+                downcast<WorkerGlobalScope>(scope).cacheStorageConnection().openOrRemoveCompleted(requestIdentifier, result);
>             }, WorkerRunLoop::defaultMode());
>         });
>     });
> }
> 
>-void WorkerCacheStorageConnection::doRetrieveCaches(uint64_t requestIdentifier, const ClientOrigin& origin, uint64_t updateCounter)
>+void WorkerCacheStorageConnection::retrieveCaches(const ClientOrigin& origin, uint64_t updateCounter, CacheInfosCallback&& callback)
> {
>+    uint64_t requestIdentifier = ++m_lastRequestIdentifier;
>+    m_retrieveCachesPendingRequests.add(requestIdentifier, WTFMove(callback));
>+
>     callOnMainThread([workerThread = makeRef(m_scope.thread()), mainThreadConnection = m_mainThreadConnection, requestIdentifier, origin = origin.isolatedCopy(), updateCounter] () mutable {
>         mainThreadConnection->retrieveCaches(origin, updateCounter, [workerThread = WTFMove(workerThread), requestIdentifier] (CacheInfosOrError&& result) mutable {
>             CacheInfosOrError isolatedResult;
>@@ -143,64 +183,43 @@ void WorkerCacheStorageConnection::doRetrieveCaches(uint64_t requestIdentifier,
>                 isolatedResult = result.value().isolatedCopy();
> 
>             workerThread->runLoop().postTaskForMode([requestIdentifier, result = WTFMove(isolatedResult)] (auto& scope) mutable {
>-                downcast<WorkerGlobalScope>(scope).cacheStorageConnection().updateCaches(requestIdentifier, WTFMove(result));
>+                downcast<WorkerGlobalScope>(scope).cacheStorageConnection().retrieveCachesCompleted(requestIdentifier, WTFMove(result));
>             }, WorkerRunLoop::defaultMode());
>         });
>     });
> }
> 
>-void WorkerCacheStorageConnection::reference(uint64_t cacheIdentifier)
>-{
>-    callOnMainThread([mainThreadConnection = m_mainThreadConnection, cacheIdentifier]() {
>-        mainThreadConnection->reference(cacheIdentifier);
>-    });
>-}
>-
>-void WorkerCacheStorageConnection::dereference(uint64_t cacheIdentifier)
>+void WorkerCacheStorageConnection::retrieveCachesCompleted(uint64_t requestIdentifier, CacheInfosOrError&& result)
> {
>-    callOnMainThread([mainThreadConnection = m_mainThreadConnection, cacheIdentifier]() {
>-        mainThreadConnection->dereference(cacheIdentifier);
>-    });
>+    if (auto callback = m_retrieveCachesPendingRequests.take(requestIdentifier))
>+        callback(WTFMove(result));
> }
> 
>-static inline Vector<CrossThreadRecordData> recordsDataFromRecords(const Vector<Record>& records)
>+void WorkerCacheStorageConnection::retrieveRecords(uint64_t cacheIdentifier, const URL& url, RecordsCallback&& callback)
> {
>-    return WTF::map(records, toCrossThreadRecordData);
>-}
>+    uint64_t requestIdentifier = ++m_lastRequestIdentifier;
>+    m_retrieveRecordsPendingRequests.add(requestIdentifier, WTFMove(callback));
> 
>-static inline Expected<Vector<CrossThreadRecordData>, Error> recordsDataOrErrorFromRecords(const RecordsOrError& result)
>-{
>-    if (!result.has_value())
>-        return makeUnexpected(result.error());
>-
>-    return recordsDataFromRecords(result.value());
>-}
>-
>-static inline Vector<Record> recordsFromRecordsData(Vector<CrossThreadRecordData>&& recordsData)
>-{
>-    return WTF::map(WTFMove(recordsData), fromCrossThreadRecordData);
>-}
>-
>-static inline RecordsOrError recordsOrErrorFromRecordsData(Expected<Vector<CrossThreadRecordData>, Error>&& recordsData)
>-{
>-    if (!recordsData.has_value())
>-        return makeUnexpected(recordsData.error());
>-    return recordsFromRecordsData(WTFMove(recordsData.value()));
>-}
>-
>-void WorkerCacheStorageConnection::doRetrieveRecords(uint64_t requestIdentifier, uint64_t cacheIdentifier, const URL& url)
>-{
>     callOnMainThread([workerThread = makeRef(m_scope.thread()), mainThreadConnection = m_mainThreadConnection, requestIdentifier, cacheIdentifier, url = url.isolatedCopy()]() mutable {
>         mainThreadConnection->retrieveRecords(cacheIdentifier, url, [workerThread = WTFMove(workerThread), requestIdentifier](RecordsOrError&& result) mutable {
>             workerThread->runLoop().postTaskForMode([result = recordsDataOrErrorFromRecords(result), requestIdentifier] (auto& scope) mutable {
>-                downcast<WorkerGlobalScope>(scope).cacheStorageConnection().updateRecords(requestIdentifier, recordsOrErrorFromRecordsData(WTFMove(result)));
>+                downcast<WorkerGlobalScope>(scope).cacheStorageConnection().retrieveRecordsCompleted(requestIdentifier, recordsOrErrorFromRecordsData(WTFMove(result)));
>             }, WorkerRunLoop::defaultMode());
>         });
>     });
> }
> 
>-void WorkerCacheStorageConnection::doBatchDeleteOperation(uint64_t requestIdentifier, uint64_t cacheIdentifier, const ResourceRequest& request, CacheQueryOptions&& options)
>+void WorkerCacheStorageConnection::retrieveRecordsCompleted(uint64_t requestIdentifier, RecordsOrError&& result)
>+{
>+    if (auto callback = m_retrieveRecordsPendingRequests.take(requestIdentifier))
>+        callback(WTFMove(result));
>+}
>+
>+void WorkerCacheStorageConnection::batchDeleteOperation(uint64_t cacheIdentifier, const ResourceRequest& request, CacheQueryOptions&& options, RecordIdentifiersCallback&& callback)
> {
>+    uint64_t requestIdentifier = ++m_lastRequestIdentifier;
>+    m_batchDeleteAndPutPendingRequests.add(requestIdentifier, WTFMove(callback));
>+
>     callOnMainThread([workerThread = makeRef(m_scope.thread()), mainThreadConnection = m_mainThreadConnection, requestIdentifier, cacheIdentifier, request = request.isolatedCopy(), options = options.isolatedCopy()]() mutable {
>         mainThreadConnection->batchDeleteOperation(cacheIdentifier, request, WTFMove(options), [workerThread = WTFMove(workerThread), requestIdentifier](RecordIdentifiersOrError&& result) mutable {
>             workerThread->runLoop().postTaskForMode([requestIdentifier, result = WTFMove(result)] (auto& scope) mutable {
>@@ -210,8 +229,17 @@ void WorkerCacheStorageConnection::doBatchDeleteOperation(uint64_t requestIdenti
>     });
> }
> 
>-void WorkerCacheStorageConnection::doBatchPutOperation(uint64_t requestIdentifier, uint64_t cacheIdentifier, Vector<Record>&& records)
>+void WorkerCacheStorageConnection::deleteRecordsCompleted(uint64_t requestIdentifier, Expected<Vector<uint64_t>, Error>&& result)
>+{
>+    if (auto callback = m_batchDeleteAndPutPendingRequests.take(requestIdentifier))
>+        callback(WTFMove(result));
>+}
>+
>+void WorkerCacheStorageConnection::batchPutOperation(uint64_t cacheIdentifier, Vector<DOMCacheEngine::Record>&& records, DOMCacheEngine::RecordIdentifiersCallback&& callback)
> {
>+    uint64_t requestIdentifier = ++m_lastRequestIdentifier;
>+    m_batchDeleteAndPutPendingRequests.add(requestIdentifier, WTFMove(callback));
>+
>     callOnMainThread([workerThread = makeRef(m_scope.thread()), mainThreadConnection = m_mainThreadConnection, requestIdentifier, cacheIdentifier, recordsData = recordsDataFromRecords(records)]() mutable {
>         mainThreadConnection->batchPutOperation(cacheIdentifier, recordsFromRecordsData(WTFMove(recordsData)), [workerThread = WTFMove(workerThread), requestIdentifier] (RecordIdentifiersOrError&& result) mutable {
>             workerThread->runLoop().postTaskForMode([requestIdentifier, result = WTFMove(result)] (auto& scope) mutable {
>@@ -221,4 +249,43 @@ void WorkerCacheStorageConnection::doBatchPutOperation(uint64_t requestIdentifie
>     });
> }
> 
>+void WorkerCacheStorageConnection::putRecordsCompleted(uint64_t requestIdentifier, Expected<Vector<uint64_t>, Error>&& result)
>+{
>+    if (auto callback = m_batchDeleteAndPutPendingRequests.take(requestIdentifier))
>+        callback(WTFMove(result));
>+}
>+
>+void WorkerCacheStorageConnection::reference(uint64_t cacheIdentifier)
>+{
>+    callOnMainThread([mainThreadConnection = m_mainThreadConnection, cacheIdentifier]() {
>+        mainThreadConnection->reference(cacheIdentifier);
>+    });
>+}
>+
>+void WorkerCacheStorageConnection::dereference(uint64_t cacheIdentifier)
>+{
>+    callOnMainThread([mainThreadConnection = m_mainThreadConnection, cacheIdentifier]() {
>+        mainThreadConnection->dereference(cacheIdentifier);
>+    });
>+}
>+
>+void WorkerCacheStorageConnection::clearPendingRequests()
>+{
>+    auto openAndRemoveCachePendingRequests = WTFMove(m_openAndRemoveCachePendingRequests);
>+    for (auto& callback : openAndRemoveCachePendingRequests.values())
>+        callback(makeUnexpected(DOMCacheEngine::Error::Stopped));
>+
>+    auto retrieveCachesPendingRequests = WTFMove(m_retrieveCachesPendingRequests);
>+    for (auto& callback : retrieveCachesPendingRequests.values())
>+        callback(makeUnexpected(DOMCacheEngine::Error::Stopped));
>+
>+    auto retrieveRecordsPendingRequests = WTFMove(m_retrieveRecordsPendingRequests);
>+    for (auto& callback : retrieveRecordsPendingRequests.values())
>+        callback(makeUnexpected(DOMCacheEngine::Error::Stopped));
>+
>+    auto batchDeleteAndPutPendingRequests = WTFMove(m_batchDeleteAndPutPendingRequests);
>+    for (auto& callback : batchDeleteAndPutPendingRequests.values())
>+        callback(makeUnexpected(DOMCacheEngine::Error::Stopped));
>+}
>+
> } // namespace WebCore
>diff --git a/Source/WebCore/Modules/cache/WorkerCacheStorageConnection.h b/Source/WebCore/Modules/cache/WorkerCacheStorageConnection.h
>index 7aa05adbcbd0b3a45783529c4fdcd966dcf698ba..119d4cc612083da7285f4f79c22de59c9b0c4bfb 100644
>--- a/Source/WebCore/Modules/cache/WorkerCacheStorageConnection.h
>+++ b/Source/WebCore/Modules/cache/WorkerCacheStorageConnection.h
>@@ -38,25 +38,46 @@ public:
>     static Ref<WorkerCacheStorageConnection> create(WorkerGlobalScope&);
>     ~WorkerCacheStorageConnection();
> 
>+    void clearPendingRequests();
>+
> private:
>     explicit WorkerCacheStorageConnection(WorkerGlobalScope&);
> 
>     // WebCore::CacheStorageConnection.
>-    void doOpen(uint64_t requestIdentifier, const ClientOrigin&, const String& cacheName) final;
>-    void doRemove(uint64_t requestIdentifier, uint64_t cacheIdentifier) final;
>-    void doRetrieveCaches(uint64_t requestIdentifier, const ClientOrigin&, uint64_t updateCounter) final;
>+    void open(const ClientOrigin&, const String& cacheName, DOMCacheEngine::CacheIdentifierCallback&&) final;
>+    void remove(uint64_t cacheIdentifier, DOMCacheEngine::CacheIdentifierCallback&&) final;
>+    void retrieveCaches(const ClientOrigin&, uint64_t updateCounter, DOMCacheEngine::CacheInfosCallback&&) final;
> 
>-    void doRetrieveRecords(uint64_t requestIdentifier, uint64_t cacheIdentifier, const URL&) final;
>+    void retrieveRecords(uint64_t cacheIdentifier, const URL&, DOMCacheEngine::RecordsCallback&&) final;
>+    void batchDeleteOperation(uint64_t cacheIdentifier, const ResourceRequest&, CacheQueryOptions&&, DOMCacheEngine::RecordIdentifiersCallback&&) final;
>+    void batchPutOperation(uint64_t cacheIdentifier, Vector<DOMCacheEngine::Record>&&, DOMCacheEngine::RecordIdentifiersCallback&&) final;
> 
>     void reference(uint64_t cacheIdentifier) final;
>     void dereference(uint64_t cacheIdentifier) final;
> 
>-    void doBatchDeleteOperation(uint64_t requestIdentifier, uint64_t cacheIdentifier, const WebCore::ResourceRequest&, WebCore::CacheQueryOptions&&) final;
>-    void doBatchPutOperation(uint64_t requestIdentifier, uint64_t cacheIdentifier, Vector<DOMCacheEngine::Record>&&) final;
>+    void doOpen(uint64_t requestIdentifier, const ClientOrigin&, const String& cacheName);
>+    void doRemove(uint64_t requestIdentifier, uint64_t cacheIdentifier);
>+    void doRetrieveCaches(uint64_t requestIdentifier, const ClientOrigin&, uint64_t updateCounter);
>+    void doRetrieveRecords(uint64_t requestIdentifier, uint64_t cacheIdentifier, const URL&);
>+    void doBatchDeleteOperation(uint64_t requestIdentifier, uint64_t cacheIdentifier, const WebCore::ResourceRequest&, WebCore::CacheQueryOptions&&);
>+    void doBatchPutOperation(uint64_t requestIdentifier, uint64_t cacheIdentifier, Vector<DOMCacheEngine::Record>&&);
>+
>+    void openOrRemoveCompleted(uint64_t requestIdentifier, const DOMCacheEngine::CacheIdentifierOrError&);
>+    void retrieveCachesCompleted(uint64_t requestIdentifier, DOMCacheEngine::CacheInfosOrError&&);
>+    void retrieveRecordsCompleted(uint64_t requestIdentifier, DOMCacheEngine::RecordsOrError&&);
>+    void deleteRecordsCompleted(uint64_t requestIdentifier, DOMCacheEngine::RecordIdentifiersOrError&&);
>+    void putRecordsCompleted(uint64_t requestIdentifier, DOMCacheEngine::RecordIdentifiersOrError&&);
> 
>     WorkerGlobalScope& m_scope;
> 
>     RefPtr<CacheStorageConnection> m_mainThreadConnection;
>+
>+    HashMap<uint64_t, DOMCacheEngine::CacheIdentifierCallback> m_openAndRemoveCachePendingRequests;
>+    HashMap<uint64_t, DOMCacheEngine::CacheInfosCallback> m_retrieveCachesPendingRequests;
>+    HashMap<uint64_t, DOMCacheEngine::RecordsCallback> m_retrieveRecordsPendingRequests;
>+    HashMap<uint64_t, DOMCacheEngine::RecordIdentifiersCallback> m_batchDeleteAndPutPendingRequests;
>+
>+    uint64_t m_lastRequestIdentifier { 0 };
> };
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/page/CacheStorageProvider.h b/Source/WebCore/page/CacheStorageProvider.h
>index e1fcc2b9c286055ff528c609dd2938ec25325f90..636f3d0a119b7c67fbbde7f61f1f7d0f0c59bf1b 100644
>--- a/Source/WebCore/page/CacheStorageProvider.h
>+++ b/Source/WebCore/page/CacheStorageProvider.h
>@@ -33,8 +33,23 @@ namespace WebCore {
> 
> class CacheStorageProvider : public RefCounted<CacheStorageProvider> {
> public:
>+    class DummyCacheStorageConnection final : public WebCore::CacheStorageConnection {
>+    public:
>+        static Ref<DummyCacheStorageConnection> create() { return adoptRef(*new DummyCacheStorageConnection); }
>+
>+    private:
>+        void open(const ClientOrigin&, const String&, DOMCacheEngine::CacheIdentifierCallback&&) final { }
>+        void remove(uint64_t, DOMCacheEngine::CacheIdentifierCallback&&) final { }
>+        void retrieveCaches(const ClientOrigin&, uint64_t, DOMCacheEngine::CacheInfosCallback&&) final { }
>+        void retrieveRecords(uint64_t, const URL&, DOMCacheEngine::RecordsCallback&&) final { }
>+        void batchDeleteOperation(uint64_t, const ResourceRequest&, CacheQueryOptions&&, DOMCacheEngine::RecordIdentifiersCallback&&) final { }
>+        void batchPutOperation(uint64_t, Vector<DOMCacheEngine::Record>&&, DOMCacheEngine::RecordIdentifiersCallback&&) final { }
>+        void reference(uint64_t) final { }
>+        void dereference(uint64_t) final { }
>+    };
>+
>     static Ref<CacheStorageProvider> create() { return adoptRef(*new CacheStorageProvider); }
>-    virtual Ref<CacheStorageConnection> createCacheStorageConnection(PAL::SessionID) { return CacheStorageConnection::create(); }
>+    virtual Ref<CacheStorageConnection> createCacheStorageConnection(PAL::SessionID) { return DummyCacheStorageConnection::create(); }
>     virtual ~CacheStorageProvider() { };
> 
> protected:
>diff --git a/Source/WebKit/CMakeLists.txt b/Source/WebKit/CMakeLists.txt
>index 93401385859d7908d94b37df668a69db2712f570..b8e08c1fb42b17b46792fdbb96b81720121759f0 100644
>--- a/Source/WebKit/CMakeLists.txt
>+++ b/Source/WebKit/CMakeLists.txt
>@@ -163,8 +163,6 @@ set(WebKit_MESSAGES_IN_FILES
> 
>     WebProcess/Automation/WebAutomationSessionProxy.messages.in
> 
>-    WebProcess/Cache/WebCacheStorageConnection.messages.in
>-
>     WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.messages.in
> 
>     WebProcess/FullScreen/WebFullScreenManager.messages.in
>diff --git a/Source/WebKit/DerivedSources-output.xcfilelist b/Source/WebKit/DerivedSources-output.xcfilelist
>index 7d0be319eb135c6a161c6a22252cdd6c4d3c67c8..426b8675df4b430b4f3cea6f8570e4a20c6b12b3 100644
>--- a/Source/WebKit/DerivedSources-output.xcfilelist
>+++ b/Source/WebKit/DerivedSources-output.xcfilelist
>@@ -117,7 +117,6 @@ $(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/WebAutomationSessionMessages.h
> $(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/WebAutomationSessionProxyMessageReceiver.cpp
> $(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/WebAutomationSessionProxyMessages.h
> $(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/WebAutomationSessionProxyScriptSource.h
>-$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/WebCacheStorageConnectionMessageReceiver.cpp
> $(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/WebCacheStorageConnectionMessages.h
> $(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/WebConnectionMessageReceiver.cpp
> $(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/WebConnectionMessages.h
>diff --git a/Source/WebKit/DerivedSources.make b/Source/WebKit/DerivedSources.make
>index 6ba0c9fd9a5a1ba7a8f17f666615be0386de43d5..c11b3f8ebeed42de041b3dd4c9d512afd4ed67b0 100644
>--- a/Source/WebKit/DerivedSources.make
>+++ b/Source/WebKit/DerivedSources.make
>@@ -150,7 +150,6 @@ MESSAGE_RECEIVERS = \
>     WebAuthenticatorCoordinatorProxy \
>     WebAutomationSession \
>     WebAutomationSessionProxy \
>-    WebCacheStorageConnection \
>     WebConnection \
>     WebCookieManager \
>     WebCookieManagerProxy \
>diff --git a/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.cpp b/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.cpp
>index 4cc67f82ca84e32eed88b22de18569fe2c58afa7..80aab68d36c468a4b0cb908f6cff650c2af531a6 100644
>--- a/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.cpp
>+++ b/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.cpp
>@@ -600,7 +600,7 @@ void Engine::deleteDirectoryRecursivelyOnBackgroundThread(const String& path, Co
> 
> void Engine::clearMemoryRepresentation(const WebCore::ClientOrigin& origin, WebCore::DOMCacheEngine::CompletionCallback&& callback)
> {
>-    readCachesFromDisk(origin, [callback = WTFMove(callback)](CachesOrError&& result) {
>+    readCachesFromDisk(origin, [callback = WTFMove(callback)](CachesOrError&& result) mutable {
>         if (!result.has_value()) {
>             callback(result.error());
>             return;
>diff --git a/Source/WebKit/NetworkProcess/cache/CacheStorageEngineCaches.cpp b/Source/WebKit/NetworkProcess/cache/CacheStorageEngineCaches.cpp
>index 08b94b47e6404aa6d98d1b04cc8310c8a01f8573..5a7be27fa4a035fab3ecea2b6662ec84f50ce175 100644
>--- a/Source/WebKit/NetworkProcess/cache/CacheStorageEngineCaches.cpp
>+++ b/Source/WebKit/NetworkProcess/cache/CacheStorageEngineCaches.cpp
>@@ -515,7 +515,7 @@ void Caches::requestSpace(uint64_t spaceRequired, WebCore::DOMCacheEngine::Compl
>         return;
>     }
> 
>-    m_quotaManager->requestSpace(spaceRequired, [callback = WTFMove(callback)](auto decision) {
>+    m_quotaManager->requestSpace(spaceRequired, [callback = WTFMove(callback)](auto decision) mutable {
>         switch (decision) {
>         case WebCore::StorageQuotaManager::Decision::Deny:
>             callback(Error::QuotaExceeded);
>@@ -540,7 +540,7 @@ void Caches::writeRecord(const Cache& cache, const RecordInformation& recordInfo
>         return;
>     }
> 
>-    m_storage->store(Cache::encode(recordInformation, record), { }, [protectedStorage = makeRef(*m_storage), callback = WTFMove(callback)](int error) {
>+    m_storage->store(Cache::encode(recordInformation, record), { }, [protectedStorage = makeRef(*m_storage), callback = WTFMove(callback)](int error) mutable {
>         if (error) {
>             RELEASE_LOG_ERROR(CacheStorage, "Caches::writeRecord failed with error %d", error);
>             callback(Error::WriteDisk);
>diff --git a/Source/WebKit/NetworkProcess/cache/CacheStorageEngineConnection.cpp b/Source/WebKit/NetworkProcess/cache/CacheStorageEngineConnection.cpp
>index dd2b12ebe24dc6357c5c8c9c44dad957f056b458..628098e14c1d05cc9fa257dd8a102e726ff27939 100644
>--- a/Source/WebKit/NetworkProcess/cache/CacheStorageEngineConnection.cpp
>+++ b/Source/WebKit/NetworkProcess/cache/CacheStorageEngineConnection.cpp
>@@ -29,7 +29,6 @@
> 
> #include "Logging.h"
> #include "NetworkConnectionToWebProcess.h"
>-#include "WebCacheStorageConnectionMessages.h"
> #include "WebCoreArgumentCoders.h"
> #include <WebCore/CacheQueryOptions.h>
> 
>@@ -41,11 +40,11 @@ using namespace CacheStorage;
> #define RELEASE_LOG_IF_ALLOWED(fmt, ...) RELEASE_LOG_IF(sessionID.isAlwaysOnLoggingAllowed(), CacheStorage, "%p - CacheStorageEngineConnection::" fmt, &m_connection.connection(), ##__VA_ARGS__)
> #define RELEASE_LOG_FUNCTION_IF_ALLOWED_IN_CALLBACK(functionName, fmt, resultGetter) \
>     if (!result.has_value())\
>-        RELEASE_LOG_ERROR_IF(sessionID.isAlwaysOnLoggingAllowed(), CacheStorage, "%p - CacheStorageEngineConnection::%s (%" PRIu64 ") - failed - error %d", connection.ptr(), functionName, requestIdentifier, (int)result.error()); \
>+        RELEASE_LOG_ERROR_IF(sessionID.isAlwaysOnLoggingAllowed(), CacheStorage, "CacheStorageEngineConnection::%s - failed - error %d", functionName, (int)result.error()); \
>     else {\
>         auto value = resultGetter(result.value()); \
>         UNUSED_PARAM(value); \
>-        RELEASE_LOG_IF(sessionID.isAlwaysOnLoggingAllowed(), CacheStorage, "%p - CacheStorageEngineConnection::%s (%" PRIu64 ") - succeeded - " fmt, connection.ptr(), functionName, requestIdentifier, value); \
>+        RELEASE_LOG_IF(sessionID.isAlwaysOnLoggingAllowed(), CacheStorage, "CacheStorageEngineConnection::%s - succeeded - " fmt, functionName, value); \
>     }
> CacheStorageEngineConnection::CacheStorageEngineConnection(NetworkConnectionToWebProcess& connection)
>     : m_connection(connection)
>@@ -63,57 +62,57 @@ CacheStorageEngineConnection::~CacheStorageEngineConnection()
>     }
> }
> 
>-void CacheStorageEngineConnection::open(PAL::SessionID sessionID, uint64_t requestIdentifier, WebCore::ClientOrigin&& origin, String&& cacheName)
>+void CacheStorageEngineConnection::open(PAL::SessionID sessionID, WebCore::ClientOrigin&& origin, String&& cacheName, CacheIdentifierCallback&& callback)
> {
>-    RELEASE_LOG_IF_ALLOWED("open (%" PRIu64 ")", requestIdentifier);
>-    Engine::open(m_connection.networkProcess(), sessionID, WTFMove(origin), WTFMove(cacheName), [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](const CacheIdentifierOrError& result) {
>+    RELEASE_LOG_IF_ALLOWED("open cache");
>+    Engine::open(m_connection.networkProcess(), sessionID, WTFMove(origin), WTFMove(cacheName), [callback = WTFMove(callback), sessionID](auto& result) mutable {
>         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());
>+        callback(result);
>     });
> }
> 
>-void CacheStorageEngineConnection::remove(PAL::SessionID sessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier)
>+void CacheStorageEngineConnection::remove(PAL::SessionID sessionID, uint64_t cacheIdentifier, CacheIdentifierCallback&& callback)
> {
>-    RELEASE_LOG_IF_ALLOWED("remove (%" PRIu64 ") cache %" PRIu64, requestIdentifier, cacheIdentifier);
>-    Engine::remove(m_connection.networkProcess(), sessionID, cacheIdentifier, [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](const CacheIdentifierOrError& result) {
>+    RELEASE_LOG_IF_ALLOWED("remove cache %" PRIu64, cacheIdentifier);
>+    Engine::remove(m_connection.networkProcess(), sessionID, cacheIdentifier, [callback = WTFMove(callback), sessionID](auto& result) mutable {
>         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());
>+        callback(result);
>     });
> }
> 
>-void CacheStorageEngineConnection::caches(PAL::SessionID sessionID, uint64_t requestIdentifier, WebCore::ClientOrigin&& origin, uint64_t updateCounter)
>+void CacheStorageEngineConnection::caches(PAL::SessionID sessionID, WebCore::ClientOrigin&& origin, uint64_t updateCounter, CacheInfosCallback&& callback)
> {
>-    RELEASE_LOG_IF_ALLOWED("caches (%" PRIu64 ")", requestIdentifier);
>-    Engine::retrieveCaches(m_connection.networkProcess(), sessionID, WTFMove(origin), updateCounter, [connection = makeRef(m_connection.connection()), sessionID, origin, requestIdentifier](CacheInfosOrError&& result) {
>+    RELEASE_LOG_IF_ALLOWED("caches");
>+    Engine::retrieveCaches(m_connection.networkProcess(), sessionID, WTFMove(origin), updateCounter, [callback = WTFMove(callback), sessionID, origin](auto&& result) mutable {
>         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());
>+        callback(WTFMove(result));
>     });
> }
> 
>-void CacheStorageEngineConnection::retrieveRecords(PAL::SessionID sessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier, URL&& url)
>+void CacheStorageEngineConnection::retrieveRecords(PAL::SessionID sessionID, uint64_t cacheIdentifier, URL&& url, RecordsCallback&& callback)
> {
>-    RELEASE_LOG_IF_ALLOWED("retrieveRecords (%" PRIu64 ") in cache %" PRIu64, requestIdentifier, cacheIdentifier);
>-    Engine::retrieveRecords(m_connection.networkProcess(), sessionID, cacheIdentifier, WTFMove(url), [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](RecordsOrError&& result) {
>+    RELEASE_LOG_IF_ALLOWED("retrieveRecords in cache %" PRIu64, cacheIdentifier);
>+    Engine::retrieveRecords(m_connection.networkProcess(), sessionID, cacheIdentifier, WTFMove(url), [callback = WTFMove(callback), sessionID](auto&& result) mutable {
>         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());
>+        callback(WTFMove(result));
>     });
> }
> 
>-void CacheStorageEngineConnection::deleteMatchingRecords(PAL::SessionID sessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier, WebCore::ResourceRequest&& request, WebCore::CacheQueryOptions&& options)
>+void CacheStorageEngineConnection::deleteMatchingRecords(PAL::SessionID sessionID, uint64_t cacheIdentifier, WebCore::ResourceRequest&& request, WebCore::CacheQueryOptions&& options, RecordIdentifiersCallback&& callback)
> {
>-    RELEASE_LOG_IF_ALLOWED("deleteMatchingRecords (%" PRIu64 ") in cache %" PRIu64, requestIdentifier, cacheIdentifier);
>-    Engine::deleteMatchingRecords(m_connection.networkProcess(), sessionID, cacheIdentifier, WTFMove(request), WTFMove(options), [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](RecordIdentifiersOrError&& result) {
>+    RELEASE_LOG_IF_ALLOWED("deleteMatchingRecords in cache %" PRIu64, cacheIdentifier);
>+    Engine::deleteMatchingRecords(m_connection.networkProcess(), sessionID, cacheIdentifier, WTFMove(request), WTFMove(options), [callback = WTFMove(callback), sessionID](auto&& result) mutable {
>         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());
>+        callback(WTFMove(result));
>     });
> }
> 
>-void CacheStorageEngineConnection::putRecords(PAL::SessionID sessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier, Vector<Record>&& records)
>+void CacheStorageEngineConnection::putRecords(PAL::SessionID sessionID, uint64_t cacheIdentifier, Vector<Record>&& records, RecordIdentifiersCallback&& callback)
> {
>-    RELEASE_LOG_IF_ALLOWED("putRecords (%" PRIu64 ") in cache %" PRIu64 ", %lu records", requestIdentifier, cacheIdentifier, records.size());
>-    Engine::putRecords(m_connection.networkProcess(), sessionID, cacheIdentifier, WTFMove(records), [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](RecordIdentifiersOrError&& result) {
>+    RELEASE_LOG_IF_ALLOWED("putRecords in cache %" PRIu64 ", %lu records", cacheIdentifier, records.size());
>+    Engine::putRecords(m_connection.networkProcess(), sessionID, cacheIdentifier, WTFMove(records), [callback = WTFMove(callback), sessionID](auto&& result) mutable {
>         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());
>+        callback(WTFMove(result));
>     });
> }
> 
>diff --git a/Source/WebKit/NetworkProcess/cache/CacheStorageEngineConnection.h b/Source/WebKit/NetworkProcess/cache/CacheStorageEngineConnection.h
>index 79a5371b806e0ecbcb557127a9b0b40dd3683232..d94ec6f76d721378de6c74082999485bdc4cf262 100644
>--- a/Source/WebKit/NetworkProcess/cache/CacheStorageEngineConnection.h
>+++ b/Source/WebKit/NetworkProcess/cache/CacheStorageEngineConnection.h
>@@ -27,14 +27,27 @@
> 
> #include "ArgumentCoders.h"
> #include "CacheStorageEngine.h"
>+#include "Connection.h"
> #include <WebCore/CacheStorageConnection.h>
> #include <pal/SessionID.h>
> #include <wtf/Forward.h>
> #include <wtf/RefCounted.h>
> 
> namespace IPC {
>-class Connection;
>-class Decoder;
>+
>+template<> struct AsyncReplyError<WebCore::DOMCacheEngine::CacheIdentifierOrError> {
>+    static WebCore::DOMCacheEngine::CacheIdentifierOrError create() { return makeUnexpected(WebCore::DOMCacheEngine::Error::Internal); };
>+};
>+template<> struct AsyncReplyError<WebCore::DOMCacheEngine::RecordIdentifiersOrError> {
>+    static WebCore::DOMCacheEngine::RecordIdentifiersOrError create() { return makeUnexpected(WebCore::DOMCacheEngine::Error::Internal); };
>+};
>+template<> struct AsyncReplyError<WebCore::DOMCacheEngine::CacheInfosOrError> {
>+    static WebCore::DOMCacheEngine::CacheInfosOrError create() { return makeUnexpected(WebCore::DOMCacheEngine::Error::Internal); };
>+};
>+template<> struct AsyncReplyError<WebCore::DOMCacheEngine::RecordsOrError> {
>+    static WebCore::DOMCacheEngine::RecordsOrError create() { return makeUnexpected(WebCore::DOMCacheEngine::Error::Internal); };
>+};
>+
> }
> 
> namespace WebKit {
>@@ -50,13 +63,13 @@ public:
> private:
>     explicit CacheStorageEngineConnection(NetworkConnectionToWebProcess&);
> 
>-    void open(PAL::SessionID, uint64_t openRequestIdentifier, WebCore::ClientOrigin&&, String&& cacheName);
>-    void remove(PAL::SessionID, uint64_t removeRequestIdentifier, uint64_t cacheIdentifier);
>-    void caches(PAL::SessionID, uint64_t retrieveCachesIdentifier, WebCore::ClientOrigin&&, uint64_t updateCounter);
>+    void open(PAL::SessionID, WebCore::ClientOrigin&&, String&& cacheName, WebCore::DOMCacheEngine::CacheIdentifierCallback&&);
>+    void remove(PAL::SessionID, uint64_t cacheIdentifier, WebCore::DOMCacheEngine::CacheIdentifierCallback&&);
>+    void caches(PAL::SessionID, WebCore::ClientOrigin&&, uint64_t updateCounter, WebCore::DOMCacheEngine::CacheInfosCallback&&);
> 
>-    void retrieveRecords(PAL::SessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier, URL&&);
>-    void deleteMatchingRecords(PAL::SessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier, WebCore::ResourceRequest&&, WebCore::CacheQueryOptions&&);
>-    void putRecords(PAL::SessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier, Vector<WebCore::DOMCacheEngine::Record>&&);
>+    void retrieveRecords(PAL::SessionID, uint64_t cacheIdentifier, URL&&, WebCore::DOMCacheEngine::RecordsCallback&&);
>+    void deleteMatchingRecords(PAL::SessionID, uint64_t cacheIdentifier, WebCore::ResourceRequest&&, WebCore::CacheQueryOptions&&, WebCore::DOMCacheEngine::RecordIdentifiersCallback&&);
>+    void putRecords(PAL::SessionID, uint64_t cacheIdentifier, Vector<WebCore::DOMCacheEngine::Record>&&, WebCore::DOMCacheEngine::RecordIdentifiersCallback&&);
> 
>     void reference(PAL::SessionID, uint64_t cacheIdentifier);
>     void dereference(PAL::SessionID, uint64_t cacheIdentifier);
>diff --git a/Source/WebKit/NetworkProcess/cache/CacheStorageEngineConnection.messages.in b/Source/WebKit/NetworkProcess/cache/CacheStorageEngineConnection.messages.in
>index d9975d4cd837252d4828c9a206066eda614dbad6..f8ff76e4a2d4c9eeddab51e8e87b7fdc7a1a00fd 100644
>--- a/Source/WebKit/NetworkProcess/cache/CacheStorageEngineConnection.messages.in
>+++ b/Source/WebKit/NetworkProcess/cache/CacheStorageEngineConnection.messages.in
>@@ -21,17 +21,17 @@
> # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> 
> messages -> CacheStorageEngineConnection {
>-    Reference(PAL::SessionID sessionID, uint64_t cacheIdentifier);
>-    Dereference(PAL::SessionID sessionID, uint64_t cacheIdentifier);
>+    Reference(PAL::SessionID sessionID, uint64_t cacheIdentifier)
>+    Dereference(PAL::SessionID sessionID, uint64_t cacheIdentifier)
> 
>-    Open(PAL::SessionID sessionID, uint64_t requestIdentifier, struct WebCore::ClientOrigin origin, String cacheName);
>-    Remove(PAL::SessionID sessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier);
>-    Caches(PAL::SessionID sessionID, uint64_t requestIdentifier, struct WebCore::ClientOrigin origin, uint64_t updateCounter);
>+    Open(PAL::SessionID sessionID, struct WebCore::ClientOrigin origin, String cacheName) -> (WebCore::DOMCacheEngine::CacheIdentifierOrError result) Async
>+    Remove(PAL::SessionID sessionID, uint64_t cacheIdentifier) -> (WebCore::DOMCacheEngine::CacheIdentifierOrError result) Async
>+    Caches(PAL::SessionID sessionID, struct WebCore::ClientOrigin origin, uint64_t updateCounter) -> (WebCore::DOMCacheEngine::CacheInfosOrError result) Async
>+
>+    RetrieveRecords(PAL::SessionID sessionID, uint64_t cacheIdentifier, URL url) -> (WebCore::DOMCacheEngine::RecordsOrError result) Async
>+    DeleteMatchingRecords(PAL::SessionID sessionID, uint64_t cacheIdentifier, WebCore::ResourceRequest request, struct WebCore::CacheQueryOptions options) -> (WebCore::DOMCacheEngine::RecordIdentifiersOrError result) Async
>+    PutRecords(PAL::SessionID sessionID, uint64_t cacheIdentifier, Vector<WebCore::DOMCacheEngine::Record> record) -> (WebCore::DOMCacheEngine::RecordIdentifiersOrError result) Async
> 
>     ClearMemoryRepresentation(PAL::SessionID sessionID, struct WebCore::ClientOrigin origin) -> (Optional<WebCore::DOMCacheEngine::Error> error) Async
>     EngineRepresentation(PAL::SessionID sessionID) -> (String representation) Async
>-
>-    RetrieveRecords(PAL::SessionID sessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier, URL url);
>-    DeleteMatchingRecords(PAL::SessionID sessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier, WebCore::ResourceRequest request, struct WebCore::CacheQueryOptions options);
>-    PutRecords(PAL::SessionID sessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier, Vector<WebCore::DOMCacheEngine::Record> record);
> }
>diff --git a/Source/WebKit/Platform/IPC/ArgumentCoders.h b/Source/WebKit/Platform/IPC/ArgumentCoders.h
>index e0671e76676cd9379c65f71c1245864435cfed23..efa2db54b10c5abe6b8f77877aacad82b48356b4 100644
>--- a/Source/WebKit/Platform/IPC/ArgumentCoders.h
>+++ b/Source/WebKit/Platform/IPC/ArgumentCoders.h
>@@ -31,6 +31,7 @@
> #include <wtf/Forward.h>
> #include <wtf/MonotonicTime.h>
> #include <wtf/SHA1.h>
>+#include <wtf/Unexpected.h>
> #include <wtf/WallTime.h>
> 
> namespace IPC {
>diff --git a/Source/WebKit/Platform/IPC/Connection.h b/Source/WebKit/Platform/IPC/Connection.h
>index 36bd912e0bce4aa8cb18ad901bbb3fe90a73c803..c4fb00b083c4112a22c81ec45f088da09cb869e8 100644
>--- a/Source/WebKit/Platform/IPC/Connection.h
>+++ b/Source/WebKit/Platform/IPC/Connection.h
>@@ -83,6 +83,10 @@ enum class WaitForOption {
>     } \
> while (0)
> 
>+template<typename AsyncReplyResult> struct AsyncReplyError {
>+    static AsyncReplyResult create() { return { }; };
>+};
>+
> class MachMessage;
> class UnixMessage;
> 
>diff --git a/Source/WebKit/Scripts/webkit/messages.py b/Source/WebKit/Scripts/webkit/messages.py
>index a3773b1412fe365a4a127e86aca9ca66ce6f207c..52514902abbe1cc7146b43be7cd8c46bab490588 100644
>--- a/Source/WebKit/Scripts/webkit/messages.py
>+++ b/Source/WebKit/Scripts/webkit/messages.py
>@@ -594,13 +594,15 @@ def generate_message_handler(file):
>                 for x in message.reply_parameters:
>                     result.append('    Optional<%s> %s;\n' % (x.type, x.name))
>                     result.append('    decoder >> %s;\n' % x.name)
>-                    result.append('    if (!%s) {\n        ASSERT_NOT_REACHED();\n        return;\n    }\n' % x.name)
>+                    result.append('    if (!%s) {\n        ASSERT_NOT_REACHED();\n        completionHandler(' % x.name)
>+                    result.append(', '.join(['IPC::AsyncReplyError<' + x.type + '>::create()' for x in message.reply_parameters]))
>+                    result.append(');\n        return;\n    }\n')
>                 result.append('    completionHandler(')
>                 if len(message.reply_parameters):
>                     result.append('WTFMove(*%s)' % ('), WTFMove(*'.join(x.name for x in message.reply_parameters)))
>                 result.append(');\n}\n\n')
>                 result.append('void %s::cancelReply(CompletionHandler<void(%s)>&& completionHandler)\n{\n    completionHandler(' % move_parameters)
>-                result.append(', '.join(['{ }' for x in message.reply_parameters]))
>+                result.append(', '.join(['IPC::AsyncReplyError<' + x.type + '>::create()' for x in message.reply_parameters]))
>                 result.append(');\n}\n\n')
> 
>             result.append('void %s::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection' % (message.name))
>diff --git a/Source/WebKit/WebKit.xcodeproj/project.pbxproj b/Source/WebKit/WebKit.xcodeproj/project.pbxproj
>index 7624564daf198d04fc84af286412667b3e58e28c..ddb3a3000caef7235c2646cd0f4048cbceb560a2 100644
>--- a/Source/WebKit/WebKit.xcodeproj/project.pbxproj
>+++ b/Source/WebKit/WebKit.xcodeproj/project.pbxproj
>@@ -969,7 +969,6 @@
> 		517A52D91F43A9DA00DCDC0A /* WebSWServerConnectionMessages.h in Headers */ = {isa = PBXBuildFile; fileRef = 517A52D61F43A9B600DCDC0A /* WebSWServerConnectionMessages.h */; };
> 		517A530F1F47A86200DCDC0A /* WebSWClientConnectionMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 517A530E1F47A84300DCDC0A /* WebSWClientConnectionMessageReceiver.cpp */; };
> 		517A53101F47A86200DCDC0A /* WebSWClientConnectionMessages.h in Headers */ = {isa = PBXBuildFile; fileRef = 517A530D1F47A84300DCDC0A /* WebSWClientConnectionMessages.h */; };
>-		517CF0E3163A486C00C2950D /* WebCacheStorageConnectionMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 517CF0E1163A486C00C2950D /* WebCacheStorageConnectionMessageReceiver.cpp */; };
> 		517CF0E3163A486C00C2950E /* NetworkProcessConnectionMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 517CF0E1163A486C00C2950E /* NetworkProcessConnectionMessageReceiver.cpp */; };
> 		517CF0E3163A486C00C2950F /* CacheStorageEngineConnectionMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 517CF0E1163A486C00C2950F /* CacheStorageEngineConnectionMessageReceiver.cpp */; };
> 		517CF0E4163A486C00C2950E /* NetworkProcessConnectionMessages.h in Headers */ = {isa = PBXBuildFile; fileRef = 517CF0E2163A486C00C2950E /* NetworkProcessConnectionMessages.h */; };
>@@ -3099,7 +3098,6 @@
> 		4151E5C31FBB90A900E47E2D /* FormDataReference.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FormDataReference.h; sourceTree = "<group>"; };
> 		4157853021276B6F00DD3800 /* copy-webcontent-resources-to-private-headers.sh */ = {isa = PBXFileReference; lastKnownFileType = text.script.sh; path = "copy-webcontent-resources-to-private-headers.sh"; sourceTree = "<group>"; };
> 		4157E4AF20E2EC9800A6C0D7 /* com.google.o1dbrowserplugin.sb */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = com.google.o1dbrowserplugin.sb; sourceTree = "<group>"; };
>-		41897ECB1F415D5C0016FA42 /* WebCacheStorageConnection.messages.in */ = {isa = PBXFileReference; lastKnownFileType = text; path = WebCacheStorageConnection.messages.in; sourceTree = "<group>"; };
> 		41897ECC1F415D5C0016FA42 /* WebCacheStorageProvider.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WebCacheStorageProvider.cpp; sourceTree = "<group>"; };
> 		41897ECD1F415D5C0016FA42 /* WebCacheStorageConnection.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebCacheStorageConnection.h; sourceTree = "<group>"; };
> 		41897ECE1F415D5C0016FA42 /* WebCacheStorageConnection.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WebCacheStorageConnection.cpp; sourceTree = "<group>"; };
>@@ -3289,7 +3287,6 @@
> 		517A530C1F479E9700DCDC0A /* WebSWClientConnection.messages.in */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = WebSWClientConnection.messages.in; sourceTree = "<group>"; };
> 		517A530D1F47A84300DCDC0A /* WebSWClientConnectionMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = WebSWClientConnectionMessages.h; path = DerivedSources/WebKit2/WebSWClientConnectionMessages.h; sourceTree = BUILT_PRODUCTS_DIR; };
> 		517A530E1F47A84300DCDC0A /* WebSWClientConnectionMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = WebSWClientConnectionMessageReceiver.cpp; path = DerivedSources/WebKit2/WebSWClientConnectionMessageReceiver.cpp; sourceTree = BUILT_PRODUCTS_DIR; };
>-		517CF0E1163A486C00C2950D /* WebCacheStorageConnectionMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = WebCacheStorageConnectionMessageReceiver.cpp; path = DerivedSources/WebKit2/WebCacheStorageConnectionMessageReceiver.cpp; sourceTree = BUILT_PRODUCTS_DIR; };
> 		517CF0E1163A486C00C2950E /* NetworkProcessConnectionMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = NetworkProcessConnectionMessageReceiver.cpp; path = DerivedSources/WebKit2/NetworkProcessConnectionMessageReceiver.cpp; sourceTree = BUILT_PRODUCTS_DIR; };
> 		517CF0E1163A486C00C2950F /* CacheStorageEngineConnectionMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = CacheStorageEngineConnectionMessageReceiver.cpp; path = DerivedSources/WebKit2/CacheStorageEngineConnectionMessageReceiver.cpp; sourceTree = BUILT_PRODUCTS_DIR; };
> 		517CF0E2163A486C00C2950E /* NetworkProcessConnectionMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = NetworkProcessConnectionMessages.h; path = DerivedSources/WebKit2/NetworkProcessConnectionMessages.h; sourceTree = BUILT_PRODUCTS_DIR; };
>@@ -6516,7 +6513,6 @@
> 			children = (
> 				41897ECE1F415D5C0016FA42 /* WebCacheStorageConnection.cpp */,
> 				41897ECD1F415D5C0016FA42 /* WebCacheStorageConnection.h */,
>-				41897ECB1F415D5C0016FA42 /* WebCacheStorageConnection.messages.in */,
> 				41897ECC1F415D5C0016FA42 /* WebCacheStorageProvider.cpp */,
> 				41D129D91F3D101400D15E47 /* WebCacheStorageProvider.h */,
> 			);
>@@ -8676,7 +8672,6 @@
> 				1C0A19511C8FFDFB00FE0EBB /* WebAutomationSessionProxyMessageReceiver.cpp */,
> 				1C0A19521C8FFDFB00FE0EBB /* WebAutomationSessionProxyMessages.h */,
> 				1C0A195B1C916E1B00FE0EBB /* WebAutomationSessionProxyScriptSource.h */,
>-				517CF0E1163A486C00C2950D /* WebCacheStorageConnectionMessageReceiver.cpp */,
> 				1A1FEC1A1627B45600700F6D /* WebConnectionMessageReceiver.cpp */,
> 				1A1FEC1B1627B45700700F6D /* WebConnectionMessages.h */,
> 				330934431315B9220097A7BC /* WebCookieManagerMessageReceiver.cpp */,
>@@ -11258,7 +11253,6 @@
> 				57DCED702142EE680016B847 /* WebAuthenticatorCoordinatorProxyMessageReceiver.cpp in Sources */,
> 				1C0A19571C90068F00FE0EBB /* WebAutomationSessionMessageReceiver.cpp in Sources */,
> 				1C0A19531C8FFDFB00FE0EBB /* WebAutomationSessionProxyMessageReceiver.cpp in Sources */,
>-				517CF0E3163A486C00C2950D /* WebCacheStorageConnectionMessageReceiver.cpp in Sources */,
> 				1A1FEC1C1627B45700700F6D /* WebConnectionMessageReceiver.cpp in Sources */,
> 				330934471315B9220097A7BC /* WebCookieManagerMessageReceiver.cpp in Sources */,
> 				330934491315B9220097A7BC /* WebCookieManagerProxyMessageReceiver.cpp in Sources */,
>diff --git a/Source/WebKit/WebProcess/Cache/WebCacheStorageConnection.cpp b/Source/WebKit/WebProcess/Cache/WebCacheStorageConnection.cpp
>index 1bd2060cd61aeab3fda71314105ed815dc938a0c..213ec86ced4ab656d1340b2a798edb0c35b21b86 100644
>--- a/Source/WebKit/WebProcess/Cache/WebCacheStorageConnection.cpp
>+++ b/Source/WebKit/WebProcess/Cache/WebCacheStorageConnection.cpp
>@@ -56,34 +56,34 @@ IPC::Connection& WebCacheStorageConnection::connection()
>     return WebProcess::singleton().ensureNetworkProcessConnection().connection();
> }
> 
>-void WebCacheStorageConnection::doOpen(uint64_t requestIdentifier, const WebCore::ClientOrigin& origin, const String& cacheName)
>+void WebCacheStorageConnection::open(const WebCore::ClientOrigin& origin, const String& cacheName, DOMCacheEngine::CacheIdentifierCallback&& callback)
> {
>-    connection().send(Messages::CacheStorageEngineConnection::Open(m_sessionID, requestIdentifier, origin, cacheName), 0);
>+    connection().sendWithAsyncReply(Messages::CacheStorageEngineConnection::Open(m_sessionID, origin, cacheName), WTFMove(callback));
> }
> 
>-void WebCacheStorageConnection::doRemove(uint64_t requestIdentifier, uint64_t cacheIdentifier)
>+void WebCacheStorageConnection::remove(uint64_t cacheIdentifier, DOMCacheEngine::CacheIdentifierCallback&& callback)
> {
>-    connection().send(Messages::CacheStorageEngineConnection::Remove(m_sessionID, requestIdentifier, cacheIdentifier), 0);
>+    connection().sendWithAsyncReply(Messages::CacheStorageEngineConnection::Remove(m_sessionID, cacheIdentifier), WTFMove(callback));
> }
> 
>-void WebCacheStorageConnection::doRetrieveCaches(uint64_t requestIdentifier, const WebCore::ClientOrigin& origin, uint64_t updateCounter)
>+void WebCacheStorageConnection::retrieveCaches(const WebCore::ClientOrigin& origin, uint64_t updateCounter, DOMCacheEngine::CacheInfosCallback&& callback)
> {
>-    connection().send(Messages::CacheStorageEngineConnection::Caches(m_sessionID, requestIdentifier, origin, updateCounter), 0);
>+    connection().sendWithAsyncReply(Messages::CacheStorageEngineConnection::Caches(m_sessionID, origin, updateCounter), WTFMove(callback));
> }
> 
>-void WebCacheStorageConnection::doRetrieveRecords(uint64_t requestIdentifier, uint64_t cacheIdentifier, const URL& url)
>+void WebCacheStorageConnection::retrieveRecords(uint64_t cacheIdentifier, const URL& url, DOMCacheEngine::RecordsCallback&& callback)
> {
>-    connection().send(Messages::CacheStorageEngineConnection::RetrieveRecords(m_sessionID, requestIdentifier, cacheIdentifier, url), 0);
>+    connection().sendWithAsyncReply(Messages::CacheStorageEngineConnection::RetrieveRecords(m_sessionID, cacheIdentifier, url), WTFMove(callback));
> }
> 
>-void WebCacheStorageConnection::doBatchDeleteOperation(uint64_t requestIdentifier, uint64_t cacheIdentifier, const WebCore::ResourceRequest& request, WebCore::CacheQueryOptions&& options)
>+void WebCacheStorageConnection::batchDeleteOperation(uint64_t cacheIdentifier, const WebCore::ResourceRequest& request, WebCore::CacheQueryOptions&& options, DOMCacheEngine::RecordIdentifiersCallback&& callback)
> {
>-    connection().send(Messages::CacheStorageEngineConnection::DeleteMatchingRecords(m_sessionID, requestIdentifier, cacheIdentifier, request, options), 0);
>+    connection().sendWithAsyncReply(Messages::CacheStorageEngineConnection::DeleteMatchingRecords(m_sessionID, cacheIdentifier, request, options), WTFMove(callback));
> }
> 
>-void WebCacheStorageConnection::doBatchPutOperation(uint64_t requestIdentifier, uint64_t cacheIdentifier, Vector<Record>&& records)
>+void WebCacheStorageConnection::batchPutOperation(uint64_t cacheIdentifier, Vector<Record>&& records, DOMCacheEngine::RecordIdentifiersCallback&& callback)
> {
>-    connection().send(Messages::CacheStorageEngineConnection::PutRecords(m_sessionID, requestIdentifier, cacheIdentifier, records), 0);
>+    connection().sendWithAsyncReply(Messages::CacheStorageEngineConnection::PutRecords(m_sessionID, cacheIdentifier, records), WTFMove(callback));
> }
> 
> void WebCacheStorageConnection::reference(uint64_t cacheIdentifier)
>@@ -96,42 +96,12 @@ void WebCacheStorageConnection::dereference(uint64_t cacheIdentifier)
>     connection().send(Messages::CacheStorageEngineConnection::Dereference(m_sessionID, cacheIdentifier), 0);
> }
> 
>-void WebCacheStorageConnection::openCompleted(uint64_t requestIdentifier, const CacheIdentifierOrError& result)
>-{
>-    CacheStorageConnection::openCompleted(requestIdentifier, result);
>-}
>-
>-void WebCacheStorageConnection::removeCompleted(uint64_t requestIdentifier, const CacheIdentifierOrError& result)
>-{
>-    CacheStorageConnection::removeCompleted(requestIdentifier, result);
>-}
>-
>-void WebCacheStorageConnection::updateCaches(uint64_t requestIdentifier, CacheInfosOrError&& result)
>-{
>-    CacheStorageConnection::updateCaches(requestIdentifier, WTFMove(result));
>-}
>-
>-void WebCacheStorageConnection::updateRecords(uint64_t requestIdentifier, RecordsOrError&& result)
>-{
>-    CacheStorageConnection::updateRecords(requestIdentifier, WTFMove(result));
>-}
>-
>-void WebCacheStorageConnection::deleteRecordsCompleted(uint64_t requestIdentifier, RecordIdentifiersOrError&& result)
>-{
>-    CacheStorageConnection::deleteRecordsCompleted(requestIdentifier, WTFMove(result));
>-}
>-
>-void WebCacheStorageConnection::putRecordsCompleted(uint64_t requestIdentifier, RecordIdentifiersOrError&& result)
>-{
>-    CacheStorageConnection::putRecordsCompleted(requestIdentifier, WTFMove(result));
>-}
>-
> void WebCacheStorageConnection::clearMemoryRepresentation(const WebCore::ClientOrigin& origin, CompletionCallback&& callback)
> {
>     connection().sendWithAsyncReply(Messages::CacheStorageEngineConnection::ClearMemoryRepresentation { m_sessionID, origin }, WTFMove(callback));
> }
> 
>-void WebCacheStorageConnection::engineRepresentation(WTF::Function<void(const String&)>&& callback)
>+void WebCacheStorageConnection::engineRepresentation(CompletionHandler<void(const String&)>&& callback)
> {
>     connection().sendWithAsyncReply(Messages::CacheStorageEngineConnection::EngineRepresentation { m_sessionID }, WTFMove(callback));
> }
>diff --git a/Source/WebKit/WebProcess/Cache/WebCacheStorageConnection.h b/Source/WebKit/WebProcess/Cache/WebCacheStorageConnection.h
>index c16f310edf3802351c8731d7266982ed8e33b518..4e58afc18319c5538b8c54b19bd8d4f17d87ce56 100644
>--- a/Source/WebKit/WebProcess/Cache/WebCacheStorageConnection.h
>+++ b/Source/WebKit/WebProcess/Cache/WebCacheStorageConnection.h
>@@ -52,29 +52,21 @@ private:
>     IPC::Connection& connection();
> 
>     // WebCore::CacheStorageConnection
>-    void doOpen(uint64_t requestIdentifier, const WebCore::ClientOrigin&, const String& cacheName) final;
>-    void doRemove(uint64_t requestIdentifier, uint64_t cacheIdentifier) final;
>-    void doRetrieveCaches(uint64_t requestIdentifier, const WebCore::ClientOrigin&, uint64_t updateCounter) final;
>+    void open(const WebCore::ClientOrigin&, const String& cacheName, WebCore::DOMCacheEngine::CacheIdentifierCallback&&) final;
>+    void remove(uint64_t cacheIdentifier, WebCore::DOMCacheEngine::CacheIdentifierCallback&&) final;
>+    void retrieveCaches(const WebCore::ClientOrigin&, uint64_t updateCounter, WebCore::DOMCacheEngine::CacheInfosCallback&&) final;
> 
>-    void doRetrieveRecords(uint64_t requestIdentifier, uint64_t cacheIdentifier, const URL&) final;
>-    void doBatchDeleteOperation(uint64_t requestIdentifier, uint64_t cacheIdentifier, const WebCore::ResourceRequest&, WebCore::CacheQueryOptions&&) final;
>-    void doBatchPutOperation(uint64_t requestIdentifier, uint64_t cacheIdentifier, Vector<WebCore::DOMCacheEngine::Record>&&) final;
>+    void retrieveRecords(uint64_t cacheIdentifier, const URL&, WebCore::DOMCacheEngine::RecordsCallback&&) final;
>+    void batchDeleteOperation(uint64_t cacheIdentifier, const WebCore::ResourceRequest&, WebCore::CacheQueryOptions&&, WebCore::DOMCacheEngine::RecordIdentifiersCallback&&) final;
>+    void batchPutOperation(uint64_t cacheIdentifier, Vector<WebCore::DOMCacheEngine::Record>&&, WebCore::DOMCacheEngine::RecordIdentifiersCallback&&) final;
> 
>     void reference(uint64_t cacheIdentifier) final;
>     void dereference(uint64_t cacheIdentifier) final;
> 
>     void clearMemoryRepresentation(const WebCore::ClientOrigin&, WebCore::DOMCacheEngine::CompletionCallback&&) final;
>-    void engineRepresentation(WTF::Function<void(const String&)>&&) final;
>+    void engineRepresentation(CompletionHandler<void(const String&)>&&) final;
>     void updateQuotaBasedOnSpaceUsage(const WebCore::ClientOrigin&) final;
> 
>-    void openCompleted(uint64_t requestIdentifier, const WebCore::DOMCacheEngine::CacheIdentifierOrError&);
>-    void removeCompleted(uint64_t requestIdentifier, const WebCore::DOMCacheEngine::CacheIdentifierOrError&);
>-    void updateCaches(uint64_t requestIdentifier, WebCore::DOMCacheEngine::CacheInfosOrError&&);
>-
>-    void updateRecords(uint64_t requestIdentifier, WebCore::DOMCacheEngine::RecordsOrError&&);
>-    void deleteRecordsCompleted(uint64_t requestIdentifier, WebCore::DOMCacheEngine::RecordIdentifiersOrError&&);
>-    void putRecordsCompleted(uint64_t requestIdentifier, WebCore::DOMCacheEngine::RecordIdentifiersOrError&&);
>-
>     WebCacheStorageProvider& m_provider;
>     PAL::SessionID m_sessionID;
> };
>diff --git a/Source/WebKit/WebProcess/Cache/WebCacheStorageConnection.messages.in b/Source/WebKit/WebProcess/Cache/WebCacheStorageConnection.messages.in
>deleted file mode 100644
>index 5e67ec914753deff01fb927cf1c8a85b6c4a442d..0000000000000000000000000000000000000000
>--- a/Source/WebKit/WebProcess/Cache/WebCacheStorageConnection.messages.in
>+++ /dev/null
>@@ -1,31 +0,0 @@
>-# Copyright (C) 2017 Apple Inc. All rights reserved.
>-#
>-# Redistribution and use in source and binary forms, with or without
>-# modification, are permitted provided that the following conditions
>-# are met:
>-# 1.  Redistributions of source code must retain the above copyright
>-#     notice, this list of conditions and the following disclaimer.
>-# 2.  Redistributions in binary form must reproduce the above copyright
>-#     notice, this list of conditions and the following disclaimer in the
>-#     documentation and/or other materials provided with the distribution.
>-#
>-# THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND
>-# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
>-# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
>-# DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR
>-# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
>-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
>-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
>-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
>-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>-
>-messages -> WebCacheStorageConnection {
>-    OpenCompleted(uint64_t requestIdentifier, WebCore::DOMCacheEngine::CacheIdentifierOrError result);
>-    RemoveCompleted(uint64_t requestIdentifier, WebCore::DOMCacheEngine::CacheIdentifierOrError result);
>-    UpdateCaches(uint64_t requestIdentifier, WebCore::DOMCacheEngine::CacheInfosOrError result);
>-
>-    UpdateRecords(uint64_t requestIdentifier, WebCore::DOMCacheEngine::RecordsOrError result);
>-    DeleteRecordsCompleted(uint64_t requestIdentifier, WebCore::DOMCacheEngine::RecordIdentifiersOrError result);
>-    PutRecordsCompleted(uint64_t requestIdentifier, WebCore::DOMCacheEngine::RecordIdentifiersOrError result);
>-}
>diff --git a/Source/WebKit/WebProcess/Cache/WebCacheStorageProvider.cpp b/Source/WebKit/WebProcess/Cache/WebCacheStorageProvider.cpp
>index b0ab5dffd80e357145231f61ffb7464cff1bc846..9ab0e0f6a53f4ef0ba4ff83dbcc5d9d17925a505 100644
>--- a/Source/WebKit/WebProcess/Cache/WebCacheStorageProvider.cpp
>+++ b/Source/WebKit/WebProcess/Cache/WebCacheStorageProvider.cpp
>@@ -49,10 +49,4 @@ Ref<WebCore::CacheStorageConnection> WebCacheStorageProvider::createCacheStorage
>     return *m_defaultConnection;
> }
> 
>-void WebCacheStorageProvider::process(IPC::Connection& connection, IPC::Decoder& decoder)
>-{
>-    if (auto* cacheConnection = m_connections.get(decoder.destinationID()))
>-        cacheConnection->didReceiveMessage(connection, decoder);
>-}
>-
> }
>diff --git a/Source/WebKit/WebProcess/Cache/WebCacheStorageProvider.h b/Source/WebKit/WebProcess/Cache/WebCacheStorageProvider.h
>index 5da8503ecb562d40e45bfc3af16860bae029a00e..cb16d32e7796276f6c9e5e0867fcbd006e5cf949 100644
>--- a/Source/WebKit/WebProcess/Cache/WebCacheStorageProvider.h
>+++ b/Source/WebKit/WebProcess/Cache/WebCacheStorageProvider.h
>@@ -43,8 +43,6 @@ public:
> 
>     Ref<WebCore::CacheStorageConnection> createCacheStorageConnection(PAL::SessionID) final;
> 
>-    void process(IPC::Connection&, IPC::Decoder&);
>-
> private:
>     WebCacheStorageProvider() = default;
> 
>diff --git a/Source/WebKit/WebProcess/Network/NetworkProcessConnection.cpp b/Source/WebKit/WebProcess/Network/NetworkProcessConnection.cpp
>index 57edd9275bd60596044874f40101e4e840fa1883..ae3883d86b689e666f16acef90167294e5d2787c 100644
>--- a/Source/WebKit/WebProcess/Network/NetworkProcessConnection.cpp
>+++ b/Source/WebKit/WebProcess/Network/NetworkProcessConnection.cpp
>@@ -32,8 +32,6 @@
> #include "ServiceWorkerClientFetchMessages.h"
> #include "StorageAreaMap.h"
> #include "StorageAreaMapMessages.h"
>-#include "WebCacheStorageConnection.h"
>-#include "WebCacheStorageConnectionMessages.h"
> #include "WebCacheStorageProvider.h"
> #include "WebCoreArgumentCoders.h"
> #include "WebIDBConnectionToServerMessages.h"
>@@ -121,10 +119,6 @@ void NetworkProcessConnection::didReceiveMessage(IPC::Connection& connection, IP
>         return;
>     }
> #endif
>-    if (decoder.messageReceiverName() == Messages::WebCacheStorageConnection::messageReceiverName()) {
>-        WebProcess::singleton().cacheStorageProvider().process(connection, decoder);
>-        return;
>-    }
> 
> #if ENABLE(INDEXED_DATABASE)
>     if (decoder.messageReceiverName() == Messages::WebIDBConnectionToServer::messageReceiverName()) {
>diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog
>index 3a35d9ac19b578046242ff68a91f7f841e198607..62278a566d1d8f2a1c5fcf570047f65895e98da6 100644
>--- a/LayoutTests/ChangeLog
>+++ b/LayoutTests/ChangeLog
>@@ -1,3 +1,13 @@
>+2019-05-22  Youenn Fablet  <youenn@apple.com>
>+
>+        CacheStorageConnection callbacks should be completed on network connection close
>+        https://bugs.webkit.org/show_bug.cgi?id=195757
>+
>+        Reviewed by Alex Christensen.
>+
>+        * http/wpt/cache-storage/cache-storage-networkprocess-crash-expected.txt: Added.
>+        * http/wpt/cache-storage/cache-storage-networkprocess-crash.html: Added.
>+
> 2019-05-22  Youenn Fablet  <youenn@apple.com>
> 
>         Multiple videos (with audios) with autoplay & playinline not working. Only one video play at a time.
>diff --git a/LayoutTests/http/wpt/cache-storage/cache-storage-networkprocess-crash-expected.txt b/LayoutTests/http/wpt/cache-storage/cache-storage-networkprocess-crash-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..35d9632cc06574267eaa0e7f63c9ca9867001f3c
>--- /dev/null
>+++ b/LayoutTests/http/wpt/cache-storage/cache-storage-networkprocess-crash-expected.txt
>@@ -0,0 +1,8 @@
>+CONSOLE MESSAGE: Cache API operation failed: Internal error
>+CONSOLE MESSAGE: Cache API operation failed: Internal error
>+CONSOLE MESSAGE: Cache API operation failed: Internal error
>+CONSOLE MESSAGE: Cache API operation failed: Internal error
>+CONSOLE MESSAGE: Cache API operation failed: Internal error
>+
>+PASS Pending cache operation on network process crash 
>+
>diff --git a/LayoutTests/http/wpt/cache-storage/cache-storage-networkprocess-crash.html b/LayoutTests/http/wpt/cache-storage/cache-storage-networkprocess-crash.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..4d74dd14344d7da5ee67374d35536bb97c32cd42
>--- /dev/null
>+++ b/LayoutTests/http/wpt/cache-storage/cache-storage-networkprocess-crash.html
>@@ -0,0 +1,27 @@
>+<!DOCTYPE html>
>+<html>
>+<head>
>+<title>Cache Storage: network process crash</title>
>+<script src="/resources/testharness.js"></script>
>+<script src="/resources/testharnessreport.js"></script>
>+</head>
>+<body>
>+<script>
>+promise_test(async test => {
>+    const cache = await self.caches.open("test1");
>+    const response1Mo = new Response(new ArrayBuffer(1024 * 1024));
>+    if (!window.testRunner)
>+        return Promise.reject("Requires internals API");
>+    testRunner.terminateNetworkProcess();
>+    return promise_rejects(test, new TypeError, Promise.all([
>+        cache.put("1Mo1", response1Mo.clone()),
>+        cache.put("1Mo2", response1Mo.clone()),
>+        cache.put("1Mo3", response1Mo.clone()),
>+        cache.put("1Mo4", response1Mo.clone()),
>+        cache.put("1Mo5", response1Mo.clone()),
>+    ]));
>+}, "Pending cache operation on network process crash");
>+</script>
>+</body>
>+</html>
>+

Actions: View | Formatted Diff | Diff

Attachments on bug 195757: 370455 | 370480 | 370509