⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 245715 in webkit


Ignore:
Timestamp:
May 23, 2019, 2:15:33 PM (7 years ago)
Author:
youenn@apple.com
Message:

CacheStorageConnection callbacks should be completed on network connection close
​https://bugs.webkit.org/show_bug.cgi?id=195757

Reviewed by Alex Christensen.

Source/WebCore:

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):

Source/WebKit:

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):

LayoutTests:

  • http/wpt/cache-storage/cache-storage-networkprocess-crash-expected.txt: Added.
  • http/wpt/cache-storage/cache-storage-networkprocess-crash.html: Added.
Location:
trunk
Files:
2 added
1 deleted
26 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r245712 r245715  
     12019-05-23  Youenn Fablet  <youenn@apple.com>
     2
     3        CacheStorageConnection callbacks should be completed on network connection close
     4        https://bugs.webkit.org/show_bug.cgi?id=195757
     5
     6        Reviewed by Alex Christensen.
     7
     8        * http/wpt/cache-storage/cache-storage-networkprocess-crash-expected.txt: Added.
     9        * http/wpt/cache-storage/cache-storage-networkprocess-crash.html: Added.
     10
    1112019-05-23  Youenn Fablet  <youenn@apple.com>
    212

  • trunk/Source/WebCore/ChangeLog

    r245712 r245715  
     12019-05-23  Youenn Fablet  <youenn@apple.com>
     2
     3        CacheStorageConnection callbacks should be completed on network connection close
     4        https://bugs.webkit.org/show_bug.cgi?id=195757
     5
     6        Reviewed by Alex Christensen.
     7
     8        Move HashMap-based callbacks to WorkerCacheStorageConnection.
     9        Make CacheStorageConnection default API to implement use callbacks.
     10        This is used by WebKit layer to do AsyncReply IPC.
     11
     12        Move DOMCacheEngine callbacks to CompletionHandler.
     13
     14        Test: http/wpt/cache-storage/cache-storage-networkprocess-crash.html
     15
     16        * Modules/cache/CacheStorageConnection.cpp:
     17        * Modules/cache/CacheStorageConnection.h:
     18        (WebCore::CacheStorageConnection::engineRepresentation):
     19        * Modules/cache/DOMCacheEngine.h:
     20        * Modules/cache/WorkerCacheStorageConnection.cpp:
     21        (WebCore::recordsDataFromRecords):
     22        (WebCore::recordsDataOrErrorFromRecords):
     23        (WebCore::recordsFromRecordsData):
     24        (WebCore::recordsOrErrorFromRecordsData):
     25        (WebCore::WorkerCacheStorageConnection::open):
     26        (WebCore::WorkerCacheStorageConnection::openOrRemoveCompleted):
     27        (WebCore::WorkerCacheStorageConnection::remove):
     28        (WebCore::WorkerCacheStorageConnection::retrieveCaches):
     29        (WebCore::WorkerCacheStorageConnection::retrieveCachesCompleted):
     30        (WebCore::WorkerCacheStorageConnection::retrieveRecords):
     31        (WebCore::WorkerCacheStorageConnection::retrieveRecordsCompleted):
     32        (WebCore::WorkerCacheStorageConnection::batchDeleteOperation):
     33        (WebCore::WorkerCacheStorageConnection::deleteRecordsCompleted):
     34        (WebCore::WorkerCacheStorageConnection::batchPutOperation):
     35        (WebCore::WorkerCacheStorageConnection::putRecordsCompleted):
     36        (WebCore::WorkerCacheStorageConnection::reference):
     37        (WebCore::WorkerCacheStorageConnection::dereference):
     38        (WebCore::WorkerCacheStorageConnection::clearPendingRequests):
     39        * Modules/cache/WorkerCacheStorageConnection.h:
     40        * page/CacheStorageProvider.h:
     41        (WebCore::CacheStorageProvider::createCacheStorageConnection):
     42
    1432019-05-23  Youenn Fablet  <youenn@apple.com>
    244

  • trunk/Source/WebCore/Modules/cache/CacheStorageConnection.cpp

    r244918 r245715  
    3434using namespace WebCore::DOMCacheEngine;
    3535
    36 void CacheStorageConnection::clearPendingRequests()
    37 {
    38     auto openAndRemoveCachePendingRequests = WTFMove(m_openAndRemoveCachePendingRequests);
    39     for (auto& callback : openAndRemoveCachePendingRequests.values())
    40         callback(makeUnexpected(DOMCacheEngine::Error::Stopped));
    41 
    42     auto retrieveCachesPendingRequests = WTFMove(m_retrieveCachesPendingRequests);
    43     for (auto& callback : retrieveCachesPendingRequests.values())
    44         callback(makeUnexpected(DOMCacheEngine::Error::Stopped));
    45 
    46     auto retrieveRecordsPendingRequests = WTFMove(m_retrieveRecordsPendingRequests);
    47     for (auto& callback : retrieveRecordsPendingRequests.values())
    48         callback(makeUnexpected(DOMCacheEngine::Error::Stopped));
    49 
    50     auto batchDeleteAndPutPendingRequests = WTFMove(m_batchDeleteAndPutPendingRequests);
    51     for (auto& callback : batchDeleteAndPutPendingRequests.values())
    52         callback(makeUnexpected(DOMCacheEngine::Error::Stopped));
    53 }
    54 
    55 void CacheStorageConnection::open(const ClientOrigin& origin, const String& cacheName, CacheIdentifierCallback&& callback)
    56 {
    57     uint64_t requestIdentifier = ++m_lastRequestIdentifier;
    58     m_openAndRemoveCachePendingRequests.add(requestIdentifier, WTFMove(callback));
    59 
    60     doOpen(requestIdentifier, origin, cacheName);
    61 }
    62 
    63 void CacheStorageConnection::remove(uint64_t cacheIdentifier, CacheIdentifierCallback&& callback)
    64 {
    65     uint64_t requestIdentifier = ++m_lastRequestIdentifier;
    66     m_openAndRemoveCachePendingRequests.add(requestIdentifier, WTFMove(callback));
    67 
    68     doRemove(requestIdentifier, cacheIdentifier);
    69 }
    70 
    71 void CacheStorageConnection::retrieveCaches(const ClientOrigin& origin, uint64_t updateCounter, CacheInfosCallback&& callback)
    72 {
    73     uint64_t requestIdentifier = ++m_lastRequestIdentifier;
    74     m_retrieveCachesPendingRequests.add(requestIdentifier, WTFMove(callback));
    75 
    76     doRetrieveCaches(requestIdentifier, origin, updateCounter);
    77 }
    78 
    79 void CacheStorageConnection::retrieveRecords(uint64_t cacheIdentifier, const URL& url, RecordsCallback&& callback)
    80 {
    81     uint64_t requestIdentifier = ++m_lastRequestIdentifier;
    82     m_retrieveRecordsPendingRequests.add(requestIdentifier, WTFMove(callback));
    83 
    84     doRetrieveRecords(requestIdentifier, cacheIdentifier, url);
    85 }
    86 
    87 void CacheStorageConnection::batchDeleteOperation(uint64_t cacheIdentifier, const ResourceRequest& request, CacheQueryOptions&& options, RecordIdentifiersCallback&& callback)
    88 {
    89     uint64_t requestIdentifier = ++m_lastRequestIdentifier;
    90     m_batchDeleteAndPutPendingRequests.add(requestIdentifier, WTFMove(callback));
    91 
    92     doBatchDeleteOperation(requestIdentifier, cacheIdentifier, request, WTFMove(options));
    93 }
    94 
    9536static inline uint64_t computeRealBodySize(const DOMCacheEngine::ResponseBody& body)
    9637{
    … …  
    12465}
    12566
    126 void CacheStorageConnection::batchPutOperation(uint64_t cacheIdentifier, Vector<Record>&& records, RecordIdentifiersCallback&& callback)
    127 {
    128     uint64_t requestIdentifier = ++m_lastRequestIdentifier;
    129     m_batchDeleteAndPutPendingRequests.add(requestIdentifier, WTFMove(callback));
    130 
    131     doBatchPutOperation(requestIdentifier, cacheIdentifier, WTFMove(records));
    132 }
    133 
    134 void CacheStorageConnection::openOrRemoveCompleted(uint64_t requestIdentifier, const CacheIdentifierOrError& result)
    135 {
    136     if (auto callback = m_openAndRemoveCachePendingRequests.take(requestIdentifier))
    137         callback(result);
    138 }
    139 
    140 void CacheStorageConnection::updateCaches(uint64_t requestIdentifier, CacheInfosOrError&& result)
    141 {
    142     if (auto callback = m_retrieveCachesPendingRequests.take(requestIdentifier))
    143         callback(WTFMove(result));
    144 }
    145 
    146 void CacheStorageConnection::updateRecords(uint64_t requestIdentifier, RecordsOrError&& result)
    147 {
    148     if (auto callback = m_retrieveRecordsPendingRequests.take(requestIdentifier))
    149         callback(WTFMove(result));
    150 }
    151 
    152 void CacheStorageConnection::deleteRecordsCompleted(uint64_t requestIdentifier, Expected<Vector<uint64_t>, Error>&& result)
    153 {
    154     if (auto callback = m_batchDeleteAndPutPendingRequests.take(requestIdentifier))
    155         callback(WTFMove(result));
    156 }
    157 
    158 void CacheStorageConnection::putRecordsCompleted(uint64_t requestIdentifier, Expected<Vector<uint64_t>, Error>&& result)
    159 {
    160     if (auto callback = m_batchDeleteAndPutPendingRequests.take(requestIdentifier))
    161         callback(WTFMove(result));
    162 }
    163 
    16467} // namespace WebCore

  • trunk/Source/WebCore/Modules/cache/CacheStorageConnection.h

    r244918 r245715  
    3838class CacheStorageConnection : public ThreadSafeRefCounted<CacheStorageConnection> {
    3939public:
    40     static Ref<CacheStorageConnection> create() { return adoptRef(*new CacheStorageConnection()); }
    4140    virtual ~CacheStorageConnection() = default;
    4241
    43     void open(const ClientOrigin&, const String& cacheName, DOMCacheEngine::CacheIdentifierCallback&&);
    44     void remove(uint64_t cacheIdentifier, DOMCacheEngine::CacheIdentifierCallback&&);
    45     void retrieveCaches(const ClientOrigin&, uint64_t updateCounter, DOMCacheEngine::CacheInfosCallback&&);
     42    virtual void open(const ClientOrigin&, const String& cacheName, DOMCacheEngine::CacheIdentifierCallback&&) = 0;
     43    virtual void remove(uint64_t cacheIdentifier, DOMCacheEngine::CacheIdentifierCallback&&) = 0;
     44    virtual void retrieveCaches(const ClientOrigin&, uint64_t updateCounter, DOMCacheEngine::CacheInfosCallback&&) = 0;
    4645
    47     void retrieveRecords(uint64_t cacheIdentifier, const URL&, DOMCacheEngine::RecordsCallback&&);
    48     void batchDeleteOperation(uint64_t cacheIdentifier, const ResourceRequest&, CacheQueryOptions&&, DOMCacheEngine::RecordIdentifiersCallback&&);
    49     void batchPutOperation(uint64_t cacheIdentifier, Vector<DOMCacheEngine::Record>&&, DOMCacheEngine::RecordIdentifiersCallback&&);
     46    virtual void retrieveRecords(uint64_t cacheIdentifier, const URL&, DOMCacheEngine::RecordsCallback&&) = 0;
     47    virtual void batchDeleteOperation(uint64_t cacheIdentifier, const ResourceRequest&, CacheQueryOptions&&, DOMCacheEngine::RecordIdentifiersCallback&&) = 0;
     48    virtual void batchPutOperation(uint64_t cacheIdentifier, Vector<DOMCacheEngine::Record>&&, DOMCacheEngine::RecordIdentifiersCallback&&) = 0;
     49
     50    virtual void reference(uint64_t /* cacheIdentifier */) = 0;
     51    virtual void dereference(uint64_t /* cacheIdentifier */) = 0;
     52
    5053    uint64_t computeRecordBodySize(const FetchResponse&, const DOMCacheEngine::ResponseBody&);
    51 
    52     virtual void reference(uint64_t /* cacheIdentifier */) { }
    53     virtual void dereference(uint64_t /* cacheIdentifier */) { }
    5454
    5555    // Used only for testing purposes.
    5656    virtual void clearMemoryRepresentation(const ClientOrigin&, DOMCacheEngine::CompletionCallback&& callback) { callback(DOMCacheEngine::Error::NotImplemented); }
    57     virtual void engineRepresentation(WTF::Function<void(const String&)>&& callback) { callback(String { }); }
     57    virtual void engineRepresentation(CompletionHandler<void(const String&)>&& callback) { callback(String { }); }
    5858    virtual void updateQuotaBasedOnSpaceUsage(const ClientOrigin&) { }
    5959
    60     void clearPendingRequests();
    61 
    6260protected:
    63     CacheStorageConnection() =  default;
    64 
    65     void openCompleted(uint64_t identifier, const DOMCacheEngine::CacheIdentifierOrError& result) { openOrRemoveCompleted(identifier, result); }
    66     void removeCompleted(uint64_t identifier, const DOMCacheEngine::CacheIdentifierOrError& result) { openOrRemoveCompleted(identifier, result); }
    67     WEBCORE_EXPORT void updateCaches(uint64_t requestIdentifier, DOMCacheEngine::CacheInfosOrError&&);
    68 
    69     WEBCORE_EXPORT void updateRecords(uint64_t requestIdentifier, DOMCacheEngine::RecordsOrError&&);
    70     WEBCORE_EXPORT void deleteRecordsCompleted(uint64_t requestIdentifier, DOMCacheEngine::RecordIdentifiersOrError&&);
    71     WEBCORE_EXPORT void putRecordsCompleted(uint64_t requestIdentifier, DOMCacheEngine::RecordIdentifiersOrError&&);
    72 
    73 private:
    74     virtual void doOpen(uint64_t requestIdentifier, const ClientOrigin&, const String& /* cacheName */) { openCompleted(requestIdentifier, makeUnexpected(DOMCacheEngine::Error::NotImplemented)); }
    75     virtual void doRemove(uint64_t requestIdentifier, uint64_t /* cacheIdentifier */) { removeCompleted(requestIdentifier, makeUnexpected(DOMCacheEngine::Error::NotImplemented)); }
    76     virtual void doRetrieveCaches(uint64_t requestIdentifier, const ClientOrigin&, uint64_t /* updateCounter */) { updateCaches(requestIdentifier, { }); }
    77 
    78     virtual void doRetrieveRecords(uint64_t requestIdentifier, uint64_t /* cacheIdentifier */, const URL& /* url */) { updateRecords(requestIdentifier, { }); }
    79     virtual void doBatchDeleteOperation(uint64_t requestIdentifier, uint64_t /* cacheIdentifier */, const ResourceRequest&, CacheQueryOptions&&) { deleteRecordsCompleted(requestIdentifier, makeUnexpected(DOMCacheEngine::Error::NotImplemented)); }
    80     virtual void doBatchPutOperation(uint64_t requestIdentifier, uint64_t /* cacheIdentifier */, Vector<DOMCacheEngine::Record>&&) { putRecordsCompleted(requestIdentifier, makeUnexpected(DOMCacheEngine::Error::NotImplemented)); }
    81 
    82     WEBCORE_EXPORT void openOrRemoveCompleted(uint64_t requestIdentifier, const DOMCacheEngine::CacheIdentifierOrError&);
    83 
    84     HashMap<uint64_t, DOMCacheEngine::CacheIdentifierCallback> m_openAndRemoveCachePendingRequests;
    85     HashMap<uint64_t, DOMCacheEngine::CacheInfosCallback> m_retrieveCachesPendingRequests;
    86     HashMap<uint64_t, DOMCacheEngine::RecordsCallback> m_retrieveRecordsPendingRequests;
    87     HashMap<uint64_t, DOMCacheEngine::RecordIdentifiersCallback> m_batchDeleteAndPutPendingRequests;
    8861    HashMap<uint64_t, uint64_t> m_opaqueResponseToSizeWithPaddingMap;
    89 
    90     uint64_t m_lastRequestIdentifier { 0 };
    9162};
    9263} // namespace WebCore

  • trunk/Source/WebCore/Modules/cache/DOMCacheEngine.h

    r243812 r245715  
    3333#include "ScriptExecutionContext.h"
    3434#include "SharedBuffer.h"
     35#include <wtf/CompletionHandler.h>
    3536
    3637namespace WebCore {
    … …  
    100101
    101102using CacheIdentifierOrError = Expected<CacheIdentifierOperationResult, Error>;
    102 using CacheIdentifierCallback = WTF::Function<void(const CacheIdentifierOrError&)>;
     103using CacheIdentifierCallback = CompletionHandler<void(const CacheIdentifierOrError&)>;
    103104
    104105using RecordIdentifiersOrError = Expected<Vector<uint64_t>, Error>;
    105 using RecordIdentifiersCallback = WTF::Function<void(RecordIdentifiersOrError&&)>;
     106using RecordIdentifiersCallback = CompletionHandler<void(RecordIdentifiersOrError&&)>;
    106107
    107108
    108109using CacheInfosOrError = Expected<CacheInfos, Error>;
    109 using CacheInfosCallback = WTF::Function<void(CacheInfosOrError&&)>;
     110using CacheInfosCallback = CompletionHandler<void(CacheInfosOrError&&)>;
    110111
    111112using RecordsOrError = Expected<Vector<Record>, Error>;
    112 using RecordsCallback = WTF::Function<void(RecordsOrError&&)>;
     113using RecordsCallback = CompletionHandler<void(RecordsOrError&&)>;
    113114
    114 using CompletionCallback = WTF::Function<void(Optional<Error>&&)>;
     115using CompletionCallback = CompletionHandler<void(Optional<Error>&&)>;
    115116
    116117template<class Encoder> inline void CacheInfos::encode(Encoder& encoder) const

  • trunk/Source/WebCore/Modules/cache/WorkerCacheStorageConnection.cpp

    r235521 r245715  
    8989}
    9090
     91static inline Vector<CrossThreadRecordData> recordsDataFromRecords(const Vector<Record>& records)
     92{
     93    return WTF::map(records, toCrossThreadRecordData);
     94}
     95
     96static inline Expected<Vector<CrossThreadRecordData>, Error> recordsDataOrErrorFromRecords(const RecordsOrError& result)
     97{
     98    if (!result.has_value())
     99        return makeUnexpected(result.error());
     100
     101    return recordsDataFromRecords(result.value());
     102}
     103
     104static inline Vector<Record> recordsFromRecordsData(Vector<CrossThreadRecordData>&& recordsData)
     105{
     106    return WTF::map(WTFMove(recordsData), fromCrossThreadRecordData);
     107}
     108
     109static inline RecordsOrError recordsOrErrorFromRecordsData(Expected<Vector<CrossThreadRecordData>, Error>&& recordsData)
     110{
     111    if (!recordsData.has_value())
     112        return makeUnexpected(recordsData.error());
     113    return recordsFromRecordsData(WTFMove(recordsData.value()));
     114}
     115
    91116Ref<WorkerCacheStorageConnection> WorkerCacheStorageConnection::create(WorkerGlobalScope& scope)
    92117{
    … …  
    110135}
    111136
    112 void WorkerCacheStorageConnection::doOpen(uint64_t requestIdentifier, const ClientOrigin& origin, const String& cacheName)
    113 {
     137void WorkerCacheStorageConnection::open(const ClientOrigin& origin, const String& cacheName, CacheIdentifierCallback&& callback)
     138{
     139    uint64_t requestIdentifier = ++m_lastRequestIdentifier;
     140    m_openAndRemoveCachePendingRequests.add(requestIdentifier, WTFMove(callback));
     141
    114142    callOnMainThread([workerThread = makeRef(m_scope.thread()), mainThreadConnection = m_mainThreadConnection, requestIdentifier, origin = origin.isolatedCopy(), cacheName = cacheName.isolatedCopy()] () mutable {
    115143        mainThreadConnection->open(origin, cacheName, [workerThread = WTFMove(workerThread), requestIdentifier] (const CacheIdentifierOrError& result) mutable {
    116144            workerThread->runLoop().postTaskForMode([requestIdentifier, result] (auto& scope) mutable {
    117                 downcast<WorkerGlobalScope>(scope).cacheStorageConnection().openCompleted(requestIdentifier, result);
    118             }, WorkerRunLoop::defaultMode());
    119         });
    120     });
    121 }
    122 
    123 void WorkerCacheStorageConnection::doRemove(uint64_t requestIdentifier, uint64_t cacheIdentifier)
    124 {
     145                downcast<WorkerGlobalScope>(scope).cacheStorageConnection().openOrRemoveCompleted(requestIdentifier, result);
     146            }, WorkerRunLoop::defaultMode());
     147        });
     148    });
     149}
     150
     151void WorkerCacheStorageConnection::openOrRemoveCompleted(uint64_t requestIdentifier, const CacheIdentifierOrError& result)
     152{
     153    if (auto callback = m_openAndRemoveCachePendingRequests.take(requestIdentifier))
     154        callback(result);
     155}
     156
     157void WorkerCacheStorageConnection::remove(uint64_t cacheIdentifier, CacheIdentifierCallback&& callback)
     158{
     159    uint64_t requestIdentifier = ++m_lastRequestIdentifier;
     160    m_openAndRemoveCachePendingRequests.add(requestIdentifier, WTFMove(callback));
     161
    125162    callOnMainThread([workerThread = makeRef(m_scope.thread()), mainThreadConnection = m_mainThreadConnection, requestIdentifier, cacheIdentifier] () mutable {
    126163        mainThreadConnection->remove(cacheIdentifier, [workerThread = WTFMove(workerThread), requestIdentifier, cacheIdentifier] (const CacheIdentifierOrError& result) mutable {
    127164            ASSERT_UNUSED(cacheIdentifier, !result.has_value() || !result.value().identifier || result.value().identifier == cacheIdentifier);
    128165            workerThread->runLoop().postTaskForMode([requestIdentifier, result] (auto& scope) mutable {
    129                 downcast<WorkerGlobalScope>(scope).cacheStorageConnection().removeCompleted(requestIdentifier, result);
    130             }, WorkerRunLoop::defaultMode());
    131         });
    132     });
    133 }
    134 
    135 void WorkerCacheStorageConnection::doRetrieveCaches(uint64_t requestIdentifier, const ClientOrigin& origin, uint64_t updateCounter)
    136 {
     166                downcast<WorkerGlobalScope>(scope).cacheStorageConnection().openOrRemoveCompleted(requestIdentifier, result);
     167            }, WorkerRunLoop::defaultMode());
     168        });
     169    });
     170}
     171
     172void WorkerCacheStorageConnection::retrieveCaches(const ClientOrigin& origin, uint64_t updateCounter, CacheInfosCallback&& callback)
     173{
     174    uint64_t requestIdentifier = ++m_lastRequestIdentifier;
     175    m_retrieveCachesPendingRequests.add(requestIdentifier, WTFMove(callback));
     176
    137177    callOnMainThread([workerThread = makeRef(m_scope.thread()), mainThreadConnection = m_mainThreadConnection, requestIdentifier, origin = origin.isolatedCopy(), updateCounter] () mutable {
    138178        mainThreadConnection->retrieveCaches(origin, updateCounter, [workerThread = WTFMove(workerThread), requestIdentifier] (CacheInfosOrError&& result) mutable {
    … …  
    144184
    145185            workerThread->runLoop().postTaskForMode([requestIdentifier, result = WTFMove(isolatedResult)] (auto& scope) mutable {
    146                 downcast<WorkerGlobalScope>(scope).cacheStorageConnection().updateCaches(requestIdentifier, WTFMove(result));
    147             }, WorkerRunLoop::defaultMode());
    148         });
    149     });
    150 }
    151 
    152 void WorkerCacheStorageConnection::reference(uint64_t cacheIdentifier)
    153 {
    154     callOnMainThread([mainThreadConnection = m_mainThreadConnection, cacheIdentifier]() {
    155         mainThreadConnection->reference(cacheIdentifier);
    156     });
    157 }
    158 
    159 void WorkerCacheStorageConnection::dereference(uint64_t cacheIdentifier)
    160 {
    161     callOnMainThread([mainThreadConnection = m_mainThreadConnection, cacheIdentifier]() {
    162         mainThreadConnection->dereference(cacheIdentifier);
    163     });
    164 }
    165 
    166 static inline Vector<CrossThreadRecordData> recordsDataFromRecords(const Vector<Record>& records)
    167 {
    168     return WTF::map(records, toCrossThreadRecordData);
    169 }
    170 
    171 static inline Expected<Vector<CrossThreadRecordData>, Error> recordsDataOrErrorFromRecords(const RecordsOrError& result)
    172 {
    173     if (!result.has_value())
    174         return makeUnexpected(result.error());
    175 
    176     return recordsDataFromRecords(result.value());
    177 }
    178 
    179 static inline Vector<Record> recordsFromRecordsData(Vector<CrossThreadRecordData>&& recordsData)
    180 {
    181     return WTF::map(WTFMove(recordsData), fromCrossThreadRecordData);
    182 }
    183 
    184 static inline RecordsOrError recordsOrErrorFromRecordsData(Expected<Vector<CrossThreadRecordData>, Error>&& recordsData)
    185 {
    186     if (!recordsData.has_value())
    187         return makeUnexpected(recordsData.error());
    188     return recordsFromRecordsData(WTFMove(recordsData.value()));
    189 }
    190 
    191 void WorkerCacheStorageConnection::doRetrieveRecords(uint64_t requestIdentifier, uint64_t cacheIdentifier, const URL& url)
    192 {
     186                downcast<WorkerGlobalScope>(scope).cacheStorageConnection().retrieveCachesCompleted(requestIdentifier, WTFMove(result));
     187            }, WorkerRunLoop::defaultMode());
     188        });
     189    });
     190}
     191
     192void WorkerCacheStorageConnection::retrieveCachesCompleted(uint64_t requestIdentifier, CacheInfosOrError&& result)
     193{
     194    if (auto callback = m_retrieveCachesPendingRequests.take(requestIdentifier))
     195        callback(WTFMove(result));
     196}
     197
     198void WorkerCacheStorageConnection::retrieveRecords(uint64_t cacheIdentifier, const URL& url, RecordsCallback&& callback)
     199{
     200    uint64_t requestIdentifier = ++m_lastRequestIdentifier;
     201    m_retrieveRecordsPendingRequests.add(requestIdentifier, WTFMove(callback));
     202
    193203    callOnMainThread([workerThread = makeRef(m_scope.thread()), mainThreadConnection = m_mainThreadConnection, requestIdentifier, cacheIdentifier, url = url.isolatedCopy()]() mutable {
    194204        mainThreadConnection->retrieveRecords(cacheIdentifier, url, [workerThread = WTFMove(workerThread), requestIdentifier](RecordsOrError&& result) mutable {
    195205            workerThread->runLoop().postTaskForMode([result = recordsDataOrErrorFromRecords(result), requestIdentifier] (auto& scope) mutable {
    196                 downcast<WorkerGlobalScope>(scope).cacheStorageConnection().updateRecords(requestIdentifier, recordsOrErrorFromRecordsData(WTFMove(result)));
    197             }, WorkerRunLoop::defaultMode());
    198         });
    199     });
    200 }
    201 
    202 void WorkerCacheStorageConnection::doBatchDeleteOperation(uint64_t requestIdentifier, uint64_t cacheIdentifier, const ResourceRequest& request, CacheQueryOptions&& options)
    203 {
     206                downcast<WorkerGlobalScope>(scope).cacheStorageConnection().retrieveRecordsCompleted(requestIdentifier, recordsOrErrorFromRecordsData(WTFMove(result)));
     207            }, WorkerRunLoop::defaultMode());
     208        });
     209    });
     210}
     211
     212void WorkerCacheStorageConnection::retrieveRecordsCompleted(uint64_t requestIdentifier, RecordsOrError&& result)
     213{
     214    if (auto callback = m_retrieveRecordsPendingRequests.take(requestIdentifier))
     215        callback(WTFMove(result));
     216}
     217
     218void WorkerCacheStorageConnection::batchDeleteOperation(uint64_t cacheIdentifier, const ResourceRequest& request, CacheQueryOptions&& options, RecordIdentifiersCallback&& callback)
     219{
     220    uint64_t requestIdentifier = ++m_lastRequestIdentifier;
     221    m_batchDeleteAndPutPendingRequests.add(requestIdentifier, WTFMove(callback));
     222
    204223    callOnMainThread([workerThread = makeRef(m_scope.thread()), mainThreadConnection = m_mainThreadConnection, requestIdentifier, cacheIdentifier, request = request.isolatedCopy(), options = options.isolatedCopy()]() mutable {
    205224        mainThreadConnection->batchDeleteOperation(cacheIdentifier, request, WTFMove(options), [workerThread = WTFMove(workerThread), requestIdentifier](RecordIdentifiersOrError&& result) mutable {
    … …  
    211230}
    212231
    213 void WorkerCacheStorageConnection::doBatchPutOperation(uint64_t requestIdentifier, uint64_t cacheIdentifier, Vector<Record>&& records)
    214 {
     232void WorkerCacheStorageConnection::deleteRecordsCompleted(uint64_t requestIdentifier, Expected<Vector<uint64_t>, Error>&& result)
     233{
     234    if (auto callback = m_batchDeleteAndPutPendingRequests.take(requestIdentifier))
     235        callback(WTFMove(result));
     236}
     237
     238void WorkerCacheStorageConnection::batchPutOperation(uint64_t cacheIdentifier, Vector<DOMCacheEngine::Record>&& records, DOMCacheEngine::RecordIdentifiersCallback&& callback)
     239{
     240    uint64_t requestIdentifier = ++m_lastRequestIdentifier;
     241    m_batchDeleteAndPutPendingRequests.add(requestIdentifier, WTFMove(callback));
     242
    215243    callOnMainThread([workerThread = makeRef(m_scope.thread()), mainThreadConnection = m_mainThreadConnection, requestIdentifier, cacheIdentifier, recordsData = recordsDataFromRecords(records)]() mutable {
    216244        mainThreadConnection->batchPutOperation(cacheIdentifier, recordsFromRecordsData(WTFMove(recordsData)), [workerThread = WTFMove(workerThread), requestIdentifier] (RecordIdentifiersOrError&& result) mutable {
    … …  
    222250}
    223251
     252void WorkerCacheStorageConnection::putRecordsCompleted(uint64_t requestIdentifier, Expected<Vector<uint64_t>, Error>&& result)
     253{
     254    if (auto callback = m_batchDeleteAndPutPendingRequests.take(requestIdentifier))
     255        callback(WTFMove(result));
     256}
     257
     258void WorkerCacheStorageConnection::reference(uint64_t cacheIdentifier)
     259{
     260    callOnMainThread([mainThreadConnection = m_mainThreadConnection, cacheIdentifier]() {
     261        mainThreadConnection->reference(cacheIdentifier);
     262    });
     263}
     264
     265void WorkerCacheStorageConnection::dereference(uint64_t cacheIdentifier)
     266{
     267    callOnMainThread([mainThreadConnection = m_mainThreadConnection, cacheIdentifier]() {
     268        mainThreadConnection->dereference(cacheIdentifier);
     269    });
     270}
     271
     272void WorkerCacheStorageConnection::clearPendingRequests()
     273{
     274    auto openAndRemoveCachePendingRequests = WTFMove(m_openAndRemoveCachePendingRequests);
     275    for (auto& callback : openAndRemoveCachePendingRequests.values())
     276        callback(makeUnexpected(DOMCacheEngine::Error::Stopped));
     277
     278    auto retrieveCachesPendingRequests = WTFMove(m_retrieveCachesPendingRequests);
     279    for (auto& callback : retrieveCachesPendingRequests.values())
     280        callback(makeUnexpected(DOMCacheEngine::Error::Stopped));
     281
     282    auto retrieveRecordsPendingRequests = WTFMove(m_retrieveRecordsPendingRequests);
     283    for (auto& callback : retrieveRecordsPendingRequests.values())
     284        callback(makeUnexpected(DOMCacheEngine::Error::Stopped));
     285
     286    auto batchDeleteAndPutPendingRequests = WTFMove(m_batchDeleteAndPutPendingRequests);
     287    for (auto& callback : batchDeleteAndPutPendingRequests.values())
     288        callback(makeUnexpected(DOMCacheEngine::Error::Stopped));
     289}
     290
    224291} // namespace WebCore

  • trunk/Source/WebCore/Modules/cache/WorkerCacheStorageConnection.h

    r226481 r245715  
    3939    ~WorkerCacheStorageConnection();
    4040
     41    void clearPendingRequests();
     42
    4143private:
    4244    explicit WorkerCacheStorageConnection(WorkerGlobalScope&);
    4345
    4446    // WebCore::CacheStorageConnection.
    45     void doOpen(uint64_t requestIdentifier, const ClientOrigin&, const String& cacheName) final;
    46     void doRemove(uint64_t requestIdentifier, uint64_t cacheIdentifier) final;
    47     void doRetrieveCaches(uint64_t requestIdentifier, const ClientOrigin&, uint64_t updateCounter) final;
     47    void open(const ClientOrigin&, const String& cacheName, DOMCacheEngine::CacheIdentifierCallback&&) final;
     48    void remove(uint64_t cacheIdentifier, DOMCacheEngine::CacheIdentifierCallback&&) final;
     49    void retrieveCaches(const ClientOrigin&, uint64_t updateCounter, DOMCacheEngine::CacheInfosCallback&&) final;
    4850
    49     void doRetrieveRecords(uint64_t requestIdentifier, uint64_t cacheIdentifier, const URL&) final;
     51    void retrieveRecords(uint64_t cacheIdentifier, const URL&, DOMCacheEngine::RecordsCallback&&) final;
     52    void batchDeleteOperation(uint64_t cacheIdentifier, const ResourceRequest&, CacheQueryOptions&&, DOMCacheEngine::RecordIdentifiersCallback&&) final;
     53    void batchPutOperation(uint64_t cacheIdentifier, Vector<DOMCacheEngine::Record>&&, DOMCacheEngine::RecordIdentifiersCallback&&) final;
    5054
    5155    void reference(uint64_t cacheIdentifier) final;
    5256    void dereference(uint64_t cacheIdentifier) final;
    5357
    54     void doBatchDeleteOperation(uint64_t requestIdentifier, uint64_t cacheIdentifier, const WebCore::ResourceRequest&, WebCore::CacheQueryOptions&&) final;
    55     void doBatchPutOperation(uint64_t requestIdentifier, uint64_t cacheIdentifier, Vector<DOMCacheEngine::Record>&&) final;
     58    void doOpen(uint64_t requestIdentifier, const ClientOrigin&, const String& cacheName);
     59    void doRemove(uint64_t requestIdentifier, uint64_t cacheIdentifier);
     60    void doRetrieveCaches(uint64_t requestIdentifier, const ClientOrigin&, uint64_t updateCounter);
     61    void doRetrieveRecords(uint64_t requestIdentifier, uint64_t cacheIdentifier, const URL&);
     62    void doBatchDeleteOperation(uint64_t requestIdentifier, uint64_t cacheIdentifier, const WebCore::ResourceRequest&, WebCore::CacheQueryOptions&&);
     63    void doBatchPutOperation(uint64_t requestIdentifier, uint64_t cacheIdentifier, Vector<DOMCacheEngine::Record>&&);
     64
     65    void openOrRemoveCompleted(uint64_t requestIdentifier, const DOMCacheEngine::CacheIdentifierOrError&);
     66    void retrieveCachesCompleted(uint64_t requestIdentifier, DOMCacheEngine::CacheInfosOrError&&);
     67    void retrieveRecordsCompleted(uint64_t requestIdentifier, DOMCacheEngine::RecordsOrError&&);
     68    void deleteRecordsCompleted(uint64_t requestIdentifier, DOMCacheEngine::RecordIdentifiersOrError&&);
     69    void putRecordsCompleted(uint64_t requestIdentifier, DOMCacheEngine::RecordIdentifiersOrError&&);
    5670
    5771    WorkerGlobalScope& m_scope;
    5872
    5973    RefPtr<CacheStorageConnection> m_mainThreadConnection;
     74
     75    HashMap<uint64_t, DOMCacheEngine::CacheIdentifierCallback> m_openAndRemoveCachePendingRequests;
     76    HashMap<uint64_t, DOMCacheEngine::CacheInfosCallback> m_retrieveCachesPendingRequests;
     77    HashMap<uint64_t, DOMCacheEngine::RecordsCallback> m_retrieveRecordsPendingRequests;
     78    HashMap<uint64_t, DOMCacheEngine::RecordIdentifiersCallback> m_batchDeleteAndPutPendingRequests;
     79
     80    uint64_t m_lastRequestIdentifier { 0 };
    6081};
    6182

  • trunk/Source/WebCore/page/CacheStorageProvider.h

    r233189 r245715  
    3434class CacheStorageProvider : public RefCounted<CacheStorageProvider> {
    3535public:
     36    class DummyCacheStorageConnection final : public WebCore::CacheStorageConnection {
     37    public:
     38        static Ref<DummyCacheStorageConnection> create() { return adoptRef(*new DummyCacheStorageConnection); }
     39
     40    private:
     41        void open(const ClientOrigin&, const String&, DOMCacheEngine::CacheIdentifierCallback&&) final { }
     42        void remove(uint64_t, DOMCacheEngine::CacheIdentifierCallback&&) final { }
     43        void retrieveCaches(const ClientOrigin&, uint64_t, DOMCacheEngine::CacheInfosCallback&&) final { }
     44        void retrieveRecords(uint64_t, const URL&, DOMCacheEngine::RecordsCallback&&) final { }
     45        void batchDeleteOperation(uint64_t, const ResourceRequest&, CacheQueryOptions&&, DOMCacheEngine::RecordIdentifiersCallback&&) final { }
     46        void batchPutOperation(uint64_t, Vector<DOMCacheEngine::Record>&&, DOMCacheEngine::RecordIdentifiersCallback&&) final { }
     47        void reference(uint64_t) final { }
     48        void dereference(uint64_t) final { }
     49    };
     50
    3651    static Ref<CacheStorageProvider> create() { return adoptRef(*new CacheStorageProvider); }
    37     virtual Ref<CacheStorageConnection> createCacheStorageConnection(PAL::SessionID) { return CacheStorageConnection::create(); }
     52    virtual Ref<CacheStorageConnection> createCacheStorageConnection(PAL::SessionID) { return DummyCacheStorageConnection::create(); }
    3853    virtual ~CacheStorageProvider() { };
    3954

  • trunk/Source/WebKit/CMakeLists.txt

    r245540 r245715  
    164164    WebProcess/Automation/WebAutomationSessionProxy.messages.in
    165165
    166     WebProcess/Cache/WebCacheStorageConnection.messages.in
    167 
    168166    WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.messages.in
    169167

  • trunk/Source/WebKit/ChangeLog

    r245709 r245715  
     12019-05-23  Youenn Fablet  <youenn@apple.com>
     2
     3        CacheStorageConnection callbacks should be completed on network connection close
     4        https://bugs.webkit.org/show_bug.cgi?id=195757
     5
     6        Reviewed by Alex Christensen.
     7
     8        Update according new WebCore CacheStorageConnection interface.
     9        Use Async IPC replies so that the completion handlers are called on network crash.
     10
     11        Allow to have specific error handling in case of cancelled reply or badly decoded message.
     12        This allows to reject the corresponding JS promise.
     13
     14        * CMakeLists.txt:
     15        * DerivedSources-output.xcfilelist:
     16        * DerivedSources.make:
     17        * NetworkProcess/cache/CacheStorageEngine.cpp:
     18        (WebKit::CacheStorage::Engine::clearMemoryRepresentation):
     19        * NetworkProcess/cache/CacheStorageEngineCaches.cpp:
     20        (WebKit::CacheStorage::Caches::requestSpace):
     21        (WebKit::CacheStorage::Caches::writeRecord):
     22        * NetworkProcess/cache/CacheStorageEngineConnection.cpp:
     23        (WebKit::CacheStorageEngineConnection::open):
     24        (WebKit::CacheStorageEngineConnection::remove):
     25        (WebKit::CacheStorageEngineConnection::caches):
     26        (WebKit::CacheStorageEngineConnection::retrieveRecords):
     27        (WebKit::CacheStorageEngineConnection::deleteMatchingRecords):
     28        (WebKit::CacheStorageEngineConnection::putRecords):
     29        * NetworkProcess/cache/CacheStorageEngineConnection.h:
     30        (IPC::AsyncReplyError<WebCore::DOMCacheEngine::CacheIdentifierOrError>::create):
     31        (IPC::AsyncReplyError<WebCore::DOMCacheEngine::RecordIdentifiersOrError>::create):
     32        (IPC::AsyncReplyError<WebCore::DOMCacheEngine::CacheInfosOrError>::create):
     33        (IPC::AsyncReplyError<WebCore::DOMCacheEngine::RecordsOrError>::create):
     34        * NetworkProcess/cache/CacheStorageEngineConnection.messages.in:
     35        * Platform/IPC/ArgumentCoders.h:
     36        * Platform/IPC/Connection.h:
     37        (IPC::AsyncReplyError::create):
     38        * Scripts/webkit/messages.py:
     39        * WebKit.xcodeproj/project.pbxproj:
     40        * WebProcess/Cache/WebCacheStorageConnection.cpp:
     41        (WebKit::WebCacheStorageConnection::open):
     42        (WebKit::WebCacheStorageConnection::remove):
     43        (WebKit::WebCacheStorageConnection::retrieveCaches):
     44        (WebKit::WebCacheStorageConnection::retrieveRecords):
     45        (WebKit::WebCacheStorageConnection::batchDeleteOperation):
     46        (WebKit::WebCacheStorageConnection::batchPutOperation):
     47        (WebKit::WebCacheStorageConnection::engineRepresentation):
     48        * WebProcess/Cache/WebCacheStorageConnection.h:
     49        * WebProcess/Cache/WebCacheStorageConnection.messages.in: Removed.
     50        * WebProcess/Network/NetworkProcessConnection.cpp:
     51        (WebKit::NetworkProcessConnection::didReceiveMessage):
     52
    1532019-05-23  Sihui Liu  <sihui_liu@apple.com>
    254

  • trunk/Source/WebKit/DerivedSources-output.xcfilelist

    r244100 r245715  
    118118$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/WebAutomationSessionProxyMessages.h
    119119$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/WebAutomationSessionProxyScriptSource.h
    120 $(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/WebCacheStorageConnectionMessageReceiver.cpp
    121120$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/WebCacheStorageConnectionMessages.h
    122121$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/WebConnectionMessageReceiver.cpp

  • trunk/Source/WebKit/DerivedSources.make

    r245540 r245715  
    151151    WebAutomationSession \
    152152    WebAutomationSessionProxy \
    153     WebCacheStorageConnection \
    154153    WebConnection \
    155154    WebCookieManager \

  • trunk/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.cpp

    r245186 r245715  
    601601void Engine::clearMemoryRepresentation(const WebCore::ClientOrigin& origin, WebCore::DOMCacheEngine::CompletionCallback&& callback)
    602602{
    603     readCachesFromDisk(origin, [callback = WTFMove(callback)](CachesOrError&& result) {
     603    readCachesFromDisk(origin, [callback = WTFMove(callback)](CachesOrError&& result) mutable {
    604604        if (!result.has_value()) {
    605605            callback(result.error());

  • trunk/Source/WebKit/NetworkProcess/cache/CacheStorageEngineCaches.cpp

    r243339 r245715  
    516516    }
    517517
    518     m_quotaManager->requestSpace(spaceRequired, [callback = WTFMove(callback)](auto decision) {
     518    m_quotaManager->requestSpace(spaceRequired, [callback = WTFMove(callback)](auto decision) mutable {
    519519        switch (decision) {
    520520        case WebCore::StorageQuotaManager::Decision::Deny:
    … …  
    541541    }
    542542
    543     m_storage->store(Cache::encode(recordInformation, record), { }, [protectedStorage = makeRef(*m_storage), callback = WTFMove(callback)](int error) {
     543    m_storage->store(Cache::encode(recordInformation, record), { }, [protectedStorage = makeRef(*m_storage), callback = WTFMove(callback)](int error) mutable {
    544544        if (error) {
    545545            RELEASE_LOG_ERROR(CacheStorage, "Caches::writeRecord failed with error %d", error);

  • trunk/Source/WebKit/NetworkProcess/cache/CacheStorageEngineConnection.cpp

    r245670 r245715  
    3030#include "Logging.h"
    3131#include "NetworkConnectionToWebProcess.h"
    32 #include "WebCacheStorageConnectionMessages.h"
    3332#include "WebCoreArgumentCoders.h"
    3433#include <WebCore/CacheQueryOptions.h>
    … …  
    4241#define RELEASE_LOG_FUNCTION_IF_ALLOWED_IN_CALLBACK(functionName, fmt, resultGetter) \
    4342    if (!result.has_value())\
    44         RELEASE_LOG_ERROR_IF(sessionID.isAlwaysOnLoggingAllowed(), CacheStorage, "%p - CacheStorageEngineConnection::%s (%" PRIu64 ") - failed - error %d", connection.ptr(), functionName, requestIdentifier, (int)result.error()); \
     43        RELEASE_LOG_ERROR_IF(sessionID.isAlwaysOnLoggingAllowed(), CacheStorage, "CacheStorageEngineConnection::%s - failed - error %d", functionName, (int)result.error()); \
    4544    else {\
    4645        auto value = resultGetter(result.value()); \
    4746        UNUSED_PARAM(value); \
    48         RELEASE_LOG_IF(sessionID.isAlwaysOnLoggingAllowed(), CacheStorage, "%p - CacheStorageEngineConnection::%s (%" PRIu64 ") - succeeded - " fmt, connection.ptr(), functionName, requestIdentifier, value); \
     47        RELEASE_LOG_IF(sessionID.isAlwaysOnLoggingAllowed(), CacheStorage, "CacheStorageEngineConnection::%s - succeeded - " fmt, functionName, value); \
    4948    }
    5049CacheStorageEngineConnection::CacheStorageEngineConnection(NetworkConnectionToWebProcess& connection)
    … …  
    6463}
    6564
    66 void CacheStorageEngineConnection::open(PAL::SessionID sessionID, uint64_t requestIdentifier, WebCore::ClientOrigin&& origin, String&& cacheName)
     65void CacheStorageEngineConnection::open(PAL::SessionID sessionID, WebCore::ClientOrigin&& origin, String&& cacheName, CacheIdentifierCallback&& callback)
    6766{
    68     RELEASE_LOG_IF_ALLOWED("open (%" PRIu64 ")", requestIdentifier);
    69     Engine::open(m_connection.networkProcess(), sessionID, WTFMove(origin), WTFMove(cacheName), [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](const CacheIdentifierOrError& result) {
     67    RELEASE_LOG_IF_ALLOWED("open cache");
     68    Engine::open(m_connection.networkProcess(), sessionID, WTFMove(origin), WTFMove(cacheName), [callback = WTFMove(callback), sessionID](auto& result) mutable {
    7069        RELEASE_LOG_FUNCTION_IF_ALLOWED_IN_CALLBACK("open", "cache identifier is %" PRIu64, [](const auto& value) { return value.identifier; });
    71         connection->send(Messages::WebCacheStorageConnection::OpenCompleted(requestIdentifier, result), sessionID.sessionID());
     70        callback(result);
    7271    });
    7372}
    7473
    75 void CacheStorageEngineConnection::remove(PAL::SessionID sessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier)
     74void CacheStorageEngineConnection::remove(PAL::SessionID sessionID, uint64_t cacheIdentifier, CacheIdentifierCallback&& callback)
    7675{
    77     RELEASE_LOG_IF_ALLOWED("remove (%" PRIu64 ") cache %" PRIu64, requestIdentifier, cacheIdentifier);
    78     Engine::remove(m_connection.networkProcess(), sessionID, cacheIdentifier, [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](const CacheIdentifierOrError& result) {
     76    RELEASE_LOG_IF_ALLOWED("remove cache %" PRIu64, cacheIdentifier);
     77    Engine::remove(m_connection.networkProcess(), sessionID, cacheIdentifier, [callback = WTFMove(callback), sessionID](auto& result) mutable {
    7978        RELEASE_LOG_FUNCTION_IF_ALLOWED_IN_CALLBACK("remove", "removed cache %" PRIu64, [](const auto& value) { return value.identifier; });
    80         connection->send(Messages::WebCacheStorageConnection::RemoveCompleted(requestIdentifier, result), sessionID.sessionID());
     79        callback(result);
    8180    });
    8281}
    8382
    84 void CacheStorageEngineConnection::caches(PAL::SessionID sessionID, uint64_t requestIdentifier, WebCore::ClientOrigin&& origin, uint64_t updateCounter)
     83void CacheStorageEngineConnection::caches(PAL::SessionID sessionID, WebCore::ClientOrigin&& origin, uint64_t updateCounter, CacheInfosCallback&& callback)
    8584{
    86     RELEASE_LOG_IF_ALLOWED("caches (%" PRIu64 ")", requestIdentifier);
    87     Engine::retrieveCaches(m_connection.networkProcess(), sessionID, WTFMove(origin), updateCounter, [connection = makeRef(m_connection.connection()), sessionID, origin, requestIdentifier](CacheInfosOrError&& result) {
     85    RELEASE_LOG_IF_ALLOWED("caches");
     86    Engine::retrieveCaches(m_connection.networkProcess(), sessionID, WTFMove(origin), updateCounter, [callback = WTFMove(callback), sessionID, origin](auto&& result) mutable {
    8887        RELEASE_LOG_FUNCTION_IF_ALLOWED_IN_CALLBACK("caches", "caches size is %lu", [](const auto& value) { return value.infos.size(); });
    89         connection->send(Messages::WebCacheStorageConnection::UpdateCaches(requestIdentifier, result), sessionID.sessionID());
     88        callback(WTFMove(result));
    9089    });
    9190}
    9291
    93 void CacheStorageEngineConnection::retrieveRecords(PAL::SessionID sessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier, URL&& url)
     92void CacheStorageEngineConnection::retrieveRecords(PAL::SessionID sessionID, uint64_t cacheIdentifier, URL&& url, RecordsCallback&& callback)
    9493{
    95     RELEASE_LOG_IF_ALLOWED("retrieveRecords (%" PRIu64 ") in cache %" PRIu64, requestIdentifier, cacheIdentifier);
    96     Engine::retrieveRecords(m_connection.networkProcess(), sessionID, cacheIdentifier, WTFMove(url), [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](RecordsOrError&& result) {
     94    RELEASE_LOG_IF_ALLOWED("retrieveRecords in cache %" PRIu64, cacheIdentifier);
     95    Engine::retrieveRecords(m_connection.networkProcess(), sessionID, cacheIdentifier, WTFMove(url), [callback = WTFMove(callback), sessionID](auto&& result) mutable {
    9796        RELEASE_LOG_FUNCTION_IF_ALLOWED_IN_CALLBACK("retrieveRecords", "records size is %lu", [](const auto& value) { return value.size(); });
    98         connection->send(Messages::WebCacheStorageConnection::UpdateRecords(requestIdentifier, result), sessionID.sessionID());
     97        callback(WTFMove(result));
    9998    });
    10099}
    101100
    102 void CacheStorageEngineConnection::deleteMatchingRecords(PAL::SessionID sessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier, WebCore::ResourceRequest&& request, WebCore::CacheQueryOptions&& options)
     101void CacheStorageEngineConnection::deleteMatchingRecords(PAL::SessionID sessionID, uint64_t cacheIdentifier, WebCore::ResourceRequest&& request, WebCore::CacheQueryOptions&& options, RecordIdentifiersCallback&& callback)
    103102{
    104     RELEASE_LOG_IF_ALLOWED("deleteMatchingRecords (%" PRIu64 ") in cache %" PRIu64, requestIdentifier, cacheIdentifier);
    105     Engine::deleteMatchingRecords(m_connection.networkProcess(), sessionID, cacheIdentifier, WTFMove(request), WTFMove(options), [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](RecordIdentifiersOrError&& result) {
     103    RELEASE_LOG_IF_ALLOWED("deleteMatchingRecords in cache %" PRIu64, cacheIdentifier);
     104    Engine::deleteMatchingRecords(m_connection.networkProcess(), sessionID, cacheIdentifier, WTFMove(request), WTFMove(options), [callback = WTFMove(callback), sessionID](auto&& result) mutable {
    106105        RELEASE_LOG_FUNCTION_IF_ALLOWED_IN_CALLBACK("deleteMatchingRecords", "deleted %lu records",  [](const auto& value) { return value.size(); });
    107         connection->send(Messages::WebCacheStorageConnection::DeleteRecordsCompleted(requestIdentifier, result), sessionID.sessionID());
     106        callback(WTFMove(result));
    108107    });
    109108}
    110109
    111 void CacheStorageEngineConnection::putRecords(PAL::SessionID sessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier, Vector<Record>&& records)
     110void CacheStorageEngineConnection::putRecords(PAL::SessionID sessionID, uint64_t cacheIdentifier, Vector<Record>&& records, RecordIdentifiersCallback&& callback)
    112111{
    113     RELEASE_LOG_IF_ALLOWED("putRecords (%" PRIu64 ") in cache %" PRIu64 ", %lu records", requestIdentifier, cacheIdentifier, records.size());
    114     Engine::putRecords(m_connection.networkProcess(), sessionID, cacheIdentifier, WTFMove(records), [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](RecordIdentifiersOrError&& result) {
     112    RELEASE_LOG_IF_ALLOWED("putRecords in cache %" PRIu64 ", %lu records", cacheIdentifier, records.size());
     113    Engine::putRecords(m_connection.networkProcess(), sessionID, cacheIdentifier, WTFMove(records), [callback = WTFMove(callback), sessionID](auto&& result) mutable {
    115114        RELEASE_LOG_FUNCTION_IF_ALLOWED_IN_CALLBACK("putRecords", "put %lu records",  [](const auto& value) { return value.size(); });
    116         connection->send(Messages::WebCacheStorageConnection::PutRecordsCompleted(requestIdentifier, result), sessionID.sessionID());
     115        callback(WTFMove(result));
    117116    });
    118117}

  • trunk/Source/WebKit/NetworkProcess/cache/CacheStorageEngineConnection.h

    r245670 r245715  
    2828#include "ArgumentCoders.h"
    2929#include "CacheStorageEngine.h"
     30#include "Connection.h"
    3031#include <WebCore/CacheStorageConnection.h>
    3132#include <pal/SessionID.h>
    … …  
    3435
    3536namespace IPC {
    36 class Connection;
    37 class Decoder;
     37
     38template<> struct AsyncReplyError<WebCore::DOMCacheEngine::CacheIdentifierOrError> {
     39    static WebCore::DOMCacheEngine::CacheIdentifierOrError create() { return makeUnexpected(WebCore::DOMCacheEngine::Error::Internal); };
     40};
     41template<> struct AsyncReplyError<WebCore::DOMCacheEngine::RecordIdentifiersOrError> {
     42    static WebCore::DOMCacheEngine::RecordIdentifiersOrError create() { return makeUnexpected(WebCore::DOMCacheEngine::Error::Internal); };
     43};
     44template<> struct AsyncReplyError<WebCore::DOMCacheEngine::CacheInfosOrError> {
     45    static WebCore::DOMCacheEngine::CacheInfosOrError create() { return makeUnexpected(WebCore::DOMCacheEngine::Error::Internal); };
     46};
     47template<> struct AsyncReplyError<WebCore::DOMCacheEngine::RecordsOrError> {
     48    static WebCore::DOMCacheEngine::RecordsOrError create() { return makeUnexpected(WebCore::DOMCacheEngine::Error::Internal); };
     49};
     50
    3851}
    3952
    … …  
    5164    explicit CacheStorageEngineConnection(NetworkConnectionToWebProcess&);
    5265
    53     void open(PAL::SessionID, uint64_t openRequestIdentifier, WebCore::ClientOrigin&&, String&& cacheName);
    54     void remove(PAL::SessionID, uint64_t removeRequestIdentifier, uint64_t cacheIdentifier);
    55     void caches(PAL::SessionID, uint64_t retrieveCachesIdentifier, WebCore::ClientOrigin&&, uint64_t updateCounter);
     66    void open(PAL::SessionID, WebCore::ClientOrigin&&, String&& cacheName, WebCore::DOMCacheEngine::CacheIdentifierCallback&&);
     67    void remove(PAL::SessionID, uint64_t cacheIdentifier, WebCore::DOMCacheEngine::CacheIdentifierCallback&&);
     68    void caches(PAL::SessionID, WebCore::ClientOrigin&&, uint64_t updateCounter, WebCore::DOMCacheEngine::CacheInfosCallback&&);
    5669
    57     void retrieveRecords(PAL::SessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier, URL&&);
    58     void deleteMatchingRecords(PAL::SessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier, WebCore::ResourceRequest&&, WebCore::CacheQueryOptions&&);
    59     void putRecords(PAL::SessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier, Vector<WebCore::DOMCacheEngine::Record>&&);
     70    void retrieveRecords(PAL::SessionID, uint64_t cacheIdentifier, URL&&, WebCore::DOMCacheEngine::RecordsCallback&&);
     71    void deleteMatchingRecords(PAL::SessionID, uint64_t cacheIdentifier, WebCore::ResourceRequest&&, WebCore::CacheQueryOptions&&, WebCore::DOMCacheEngine::RecordIdentifiersCallback&&);
     72    void putRecords(PAL::SessionID, uint64_t cacheIdentifier, Vector<WebCore::DOMCacheEngine::Record>&&, WebCore::DOMCacheEngine::RecordIdentifiersCallback&&);
    6073
    6174    void reference(PAL::SessionID, uint64_t cacheIdentifier);

  • trunk/Source/WebKit/NetworkProcess/cache/CacheStorageEngineConnection.messages.in

    r245670 r245715  
    2222
    2323messages -> CacheStorageEngineConnection {
    24     Reference(PAL::SessionID sessionID, uint64_t cacheIdentifier);
    25     Dereference(PAL::SessionID sessionID, uint64_t cacheIdentifier);
     24    Reference(PAL::SessionID sessionID, uint64_t cacheIdentifier)
     25    Dereference(PAL::SessionID sessionID, uint64_t cacheIdentifier)
    2626
    27     Open(PAL::SessionID sessionID, uint64_t requestIdentifier, struct WebCore::ClientOrigin origin, String cacheName);
    28     Remove(PAL::SessionID sessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier);
    29     Caches(PAL::SessionID sessionID, uint64_t requestIdentifier, struct WebCore::ClientOrigin origin, uint64_t updateCounter);
     27    Open(PAL::SessionID sessionID, struct WebCore::ClientOrigin origin, String cacheName) -> (WebCore::DOMCacheEngine::CacheIdentifierOrError result) Async
     28    Remove(PAL::SessionID sessionID, uint64_t cacheIdentifier) -> (WebCore::DOMCacheEngine::CacheIdentifierOrError result) Async
     29    Caches(PAL::SessionID sessionID, struct WebCore::ClientOrigin origin, uint64_t updateCounter) -> (WebCore::DOMCacheEngine::CacheInfosOrError result) Async
     30
     31    RetrieveRecords(PAL::SessionID sessionID, uint64_t cacheIdentifier, URL url) -> (WebCore::DOMCacheEngine::RecordsOrError result) Async
     32    DeleteMatchingRecords(PAL::SessionID sessionID, uint64_t cacheIdentifier, WebCore::ResourceRequest request, struct WebCore::CacheQueryOptions options) -> (WebCore::DOMCacheEngine::RecordIdentifiersOrError result) Async
     33    PutRecords(PAL::SessionID sessionID, uint64_t cacheIdentifier, Vector<WebCore::DOMCacheEngine::Record> record) -> (WebCore::DOMCacheEngine::RecordIdentifiersOrError result) Async
    3034
    3135    ClearMemoryRepresentation(PAL::SessionID sessionID, struct WebCore::ClientOrigin origin) -> (Optional<WebCore::DOMCacheEngine::Error> error) Async
    3236    EngineRepresentation(PAL::SessionID sessionID) -> (String representation) Async
    33 
    34     RetrieveRecords(PAL::SessionID sessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier, URL url);
    35     DeleteMatchingRecords(PAL::SessionID sessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier, WebCore::ResourceRequest request, struct WebCore::CacheQueryOptions options);
    36     PutRecords(PAL::SessionID sessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier, Vector<WebCore::DOMCacheEngine::Record> record);
    3737}

  • trunk/Source/WebKit/Platform/IPC/ArgumentCoders.h

    r243460 r245715  
    3232#include <wtf/MonotonicTime.h>
    3333#include <wtf/SHA1.h>
     34#include <wtf/Unexpected.h>
    3435#include <wtf/WallTime.h>
    3536

  • trunk/Source/WebKit/Platform/IPC/Connection.h

    r245164 r245715  
    8484while (0)
    8585
     86template<typename AsyncReplyResult> struct AsyncReplyError {
     87    static AsyncReplyResult create() { return { }; };
     88};
     89
    8690class MachMessage;
    8791class UnixMessage;

  • trunk/Source/WebKit/Scripts/webkit/messages.py

    r245025 r245715  
    595595                    result.append('    Optional<%s> %s;\n' % (x.type, x.name))
    596596                    result.append('    decoder >> %s;\n' % x.name)
    597                     result.append('    if (!%s) {\n        ASSERT_NOT_REACHED();\n        return;\n    }\n' % x.name)
     597                    result.append('    if (!%s) {\n        ASSERT_NOT_REACHED();\n        completionHandler(' % x.name)
     598                    result.append(', '.join(['IPC::AsyncReplyError<' + x.type + '>::create()' for x in message.reply_parameters]))
     599                    result.append(');\n        return;\n    }\n')
    598600                result.append('    completionHandler(')
    599601                if len(message.reply_parameters):
    … …  
    601603                result.append(');\n}\n\n')
    602604                result.append('void %s::cancelReply(CompletionHandler<void(%s)>&& completionHandler)\n{\n    completionHandler(' % move_parameters)
    603                 result.append(', '.join(['{ }' for x in message.reply_parameters]))
     605                result.append(', '.join(['IPC::AsyncReplyError<' + x.type + '>::create()' for x in message.reply_parameters]))
    604606                result.append(');\n}\n\n')
    605607

  • trunk/Source/WebKit/WebKit.xcodeproj/project.pbxproj

    r245562 r245715  
    970970                517A530F1F47A86200DCDC0A /* WebSWClientConnectionMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 517A530E1F47A84300DCDC0A /* WebSWClientConnectionMessageReceiver.cpp */; };
    971971                517A53101F47A86200DCDC0A /* WebSWClientConnectionMessages.h in Headers */ = {isa = PBXBuildFile; fileRef = 517A530D1F47A84300DCDC0A /* WebSWClientConnectionMessages.h */; };
    972                 517CF0E3163A486C00C2950D /* WebCacheStorageConnectionMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 517CF0E1163A486C00C2950D /* WebCacheStorageConnectionMessageReceiver.cpp */; };
    973972                517CF0E3163A486C00C2950E /* NetworkProcessConnectionMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 517CF0E1163A486C00C2950E /* NetworkProcessConnectionMessageReceiver.cpp */; };
    974973                517CF0E3163A486C00C2950F /* CacheStorageEngineConnectionMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 517CF0E1163A486C00C2950F /* CacheStorageEngineConnectionMessageReceiver.cpp */; };
    … …  
    31003099                4157853021276B6F00DD3800 /* copy-webcontent-resources-to-private-headers.sh */ = {isa = PBXFileReference; lastKnownFileType = text.script.sh; path = "copy-webcontent-resources-to-private-headers.sh"; sourceTree = "<group>"; };
    31013100                4157E4AF20E2EC9800A6C0D7 /* com.google.o1dbrowserplugin.sb */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = com.google.o1dbrowserplugin.sb; sourceTree = "<group>"; };
    3102                 41897ECB1F415D5C0016FA42 /* WebCacheStorageConnection.messages.in */ = {isa = PBXFileReference; lastKnownFileType = text; path = WebCacheStorageConnection.messages.in; sourceTree = "<group>"; };
    31033101                41897ECC1F415D5C0016FA42 /* WebCacheStorageProvider.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WebCacheStorageProvider.cpp; sourceTree = "<group>"; };
    31043102                41897ECD1F415D5C0016FA42 /* WebCacheStorageConnection.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebCacheStorageConnection.h; sourceTree = "<group>"; };
    … …  
    32903288                517A530D1F47A84300DCDC0A /* WebSWClientConnectionMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = WebSWClientConnectionMessages.h; path = DerivedSources/WebKit2/WebSWClientConnectionMessages.h; sourceTree = BUILT_PRODUCTS_DIR; };
    32913289                517A530E1F47A84300DCDC0A /* WebSWClientConnectionMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = WebSWClientConnectionMessageReceiver.cpp; path = DerivedSources/WebKit2/WebSWClientConnectionMessageReceiver.cpp; sourceTree = BUILT_PRODUCTS_DIR; };
    3292                 517CF0E1163A486C00C2950D /* WebCacheStorageConnectionMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = WebCacheStorageConnectionMessageReceiver.cpp; path = DerivedSources/WebKit2/WebCacheStorageConnectionMessageReceiver.cpp; sourceTree = BUILT_PRODUCTS_DIR; };
    32933290                517CF0E1163A486C00C2950E /* NetworkProcessConnectionMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = NetworkProcessConnectionMessageReceiver.cpp; path = DerivedSources/WebKit2/NetworkProcessConnectionMessageReceiver.cpp; sourceTree = BUILT_PRODUCTS_DIR; };
    32943291                517CF0E1163A486C00C2950F /* CacheStorageEngineConnectionMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = CacheStorageEngineConnectionMessageReceiver.cpp; path = DerivedSources/WebKit2/CacheStorageEngineConnectionMessageReceiver.cpp; sourceTree = BUILT_PRODUCTS_DIR; };
    … …  
    65176514                                41897ECE1F415D5C0016FA42 /* WebCacheStorageConnection.cpp */,
    65186515                                41897ECD1F415D5C0016FA42 /* WebCacheStorageConnection.h */,
    6519                                 41897ECB1F415D5C0016FA42 /* WebCacheStorageConnection.messages.in */,
    65206516                                41897ECC1F415D5C0016FA42 /* WebCacheStorageProvider.cpp */,
    65216517                                41D129D91F3D101400D15E47 /* WebCacheStorageProvider.h */,
    … …  
    86778673                                1C0A19521C8FFDFB00FE0EBB /* WebAutomationSessionProxyMessages.h */,
    86788674                                1C0A195B1C916E1B00FE0EBB /* WebAutomationSessionProxyScriptSource.h */,
    8679                                 517CF0E1163A486C00C2950D /* WebCacheStorageConnectionMessageReceiver.cpp */,
    86808675                                1A1FEC1A1627B45600700F6D /* WebConnectionMessageReceiver.cpp */,
    86818676                                1A1FEC1B1627B45700700F6D /* WebConnectionMessages.h */,
    … …  
    1125911254                                1C0A19571C90068F00FE0EBB /* WebAutomationSessionMessageReceiver.cpp in Sources */,
    1126011255                                1C0A19531C8FFDFB00FE0EBB /* WebAutomationSessionProxyMessageReceiver.cpp in Sources */,
    11261                                 517CF0E3163A486C00C2950D /* WebCacheStorageConnectionMessageReceiver.cpp in Sources */,
    1126211256                                1A1FEC1C1627B45700700F6D /* WebConnectionMessageReceiver.cpp in Sources */,
    1126311257                                330934471315B9220097A7BC /* WebCookieManagerMessageReceiver.cpp in Sources */,

  • trunk/Source/WebKit/WebProcess/Cache/WebCacheStorageConnection.cpp

    r245670 r245715  
    5757}
    5858
    59 void WebCacheStorageConnection::doOpen(uint64_t requestIdentifier, const WebCore::ClientOrigin& origin, const String& cacheName)
     59void WebCacheStorageConnection::open(const WebCore::ClientOrigin& origin, const String& cacheName, DOMCacheEngine::CacheIdentifierCallback&& callback)
    6060{
    61     connection().send(Messages::CacheStorageEngineConnection::Open(m_sessionID, requestIdentifier, origin, cacheName), 0);
     61    connection().sendWithAsyncReply(Messages::CacheStorageEngineConnection::Open(m_sessionID, origin, cacheName), WTFMove(callback));
    6262}
    6363
    64 void WebCacheStorageConnection::doRemove(uint64_t requestIdentifier, uint64_t cacheIdentifier)
     64void WebCacheStorageConnection::remove(uint64_t cacheIdentifier, DOMCacheEngine::CacheIdentifierCallback&& callback)
    6565{
    66     connection().send(Messages::CacheStorageEngineConnection::Remove(m_sessionID, requestIdentifier, cacheIdentifier), 0);
     66    connection().sendWithAsyncReply(Messages::CacheStorageEngineConnection::Remove(m_sessionID, cacheIdentifier), WTFMove(callback));
    6767}
    6868
    69 void WebCacheStorageConnection::doRetrieveCaches(uint64_t requestIdentifier, const WebCore::ClientOrigin& origin, uint64_t updateCounter)
     69void WebCacheStorageConnection::retrieveCaches(const WebCore::ClientOrigin& origin, uint64_t updateCounter, DOMCacheEngine::CacheInfosCallback&& callback)
    7070{
    71     connection().send(Messages::CacheStorageEngineConnection::Caches(m_sessionID, requestIdentifier, origin, updateCounter), 0);
     71    connection().sendWithAsyncReply(Messages::CacheStorageEngineConnection::Caches(m_sessionID, origin, updateCounter), WTFMove(callback));
    7272}
    7373
    74 void WebCacheStorageConnection::doRetrieveRecords(uint64_t requestIdentifier, uint64_t cacheIdentifier, const URL& url)
     74void WebCacheStorageConnection::retrieveRecords(uint64_t cacheIdentifier, const URL& url, DOMCacheEngine::RecordsCallback&& callback)
    7575{
    76     connection().send(Messages::CacheStorageEngineConnection::RetrieveRecords(m_sessionID, requestIdentifier, cacheIdentifier, url), 0);
     76    connection().sendWithAsyncReply(Messages::CacheStorageEngineConnection::RetrieveRecords(m_sessionID, cacheIdentifier, url), WTFMove(callback));
    7777}
    7878
    79 void WebCacheStorageConnection::doBatchDeleteOperation(uint64_t requestIdentifier, uint64_t cacheIdentifier, const WebCore::ResourceRequest& request, WebCore::CacheQueryOptions&& options)
     79void WebCacheStorageConnection::batchDeleteOperation(uint64_t cacheIdentifier, const WebCore::ResourceRequest& request, WebCore::CacheQueryOptions&& options, DOMCacheEngine::RecordIdentifiersCallback&& callback)
    8080{
    81     connection().send(Messages::CacheStorageEngineConnection::DeleteMatchingRecords(m_sessionID, requestIdentifier, cacheIdentifier, request, options), 0);
     81    connection().sendWithAsyncReply(Messages::CacheStorageEngineConnection::DeleteMatchingRecords(m_sessionID, cacheIdentifier, request, options), WTFMove(callback));
    8282}
    8383
    84 void WebCacheStorageConnection::doBatchPutOperation(uint64_t requestIdentifier, uint64_t cacheIdentifier, Vector<Record>&& records)
     84void WebCacheStorageConnection::batchPutOperation(uint64_t cacheIdentifier, Vector<Record>&& records, DOMCacheEngine::RecordIdentifiersCallback&& callback)
    8585{
    86     connection().send(Messages::CacheStorageEngineConnection::PutRecords(m_sessionID, requestIdentifier, cacheIdentifier, records), 0);
     86    connection().sendWithAsyncReply(Messages::CacheStorageEngineConnection::PutRecords(m_sessionID, cacheIdentifier, records), WTFMove(callback));
    8787}
    8888
    … …  
    9797}
    9898
    99 void WebCacheStorageConnection::openCompleted(uint64_t requestIdentifier, const CacheIdentifierOrError& result)
    100 {
    101     CacheStorageConnection::openCompleted(requestIdentifier, result);
    102 }
    103 
    104 void WebCacheStorageConnection::removeCompleted(uint64_t requestIdentifier, const CacheIdentifierOrError& result)
    105 {
    106     CacheStorageConnection::removeCompleted(requestIdentifier, result);
    107 }
    108 
    109 void WebCacheStorageConnection::updateCaches(uint64_t requestIdentifier, CacheInfosOrError&& result)
    110 {
    111     CacheStorageConnection::updateCaches(requestIdentifier, WTFMove(result));
    112 }
    113 
    114 void WebCacheStorageConnection::updateRecords(uint64_t requestIdentifier, RecordsOrError&& result)
    115 {
    116     CacheStorageConnection::updateRecords(requestIdentifier, WTFMove(result));
    117 }
    118 
    119 void WebCacheStorageConnection::deleteRecordsCompleted(uint64_t requestIdentifier, RecordIdentifiersOrError&& result)
    120 {
    121     CacheStorageConnection::deleteRecordsCompleted(requestIdentifier, WTFMove(result));
    122 }
    123 
    124 void WebCacheStorageConnection::putRecordsCompleted(uint64_t requestIdentifier, RecordIdentifiersOrError&& result)
    125 {
    126     CacheStorageConnection::putRecordsCompleted(requestIdentifier, WTFMove(result));
    127 }
    128 
    12999void WebCacheStorageConnection::clearMemoryRepresentation(const WebCore::ClientOrigin& origin, CompletionCallback&& callback)
    130100{
    … …  
    132102}
    133103
    134 void WebCacheStorageConnection::engineRepresentation(WTF::Function<void(const String&)>&& callback)
     104void WebCacheStorageConnection::engineRepresentation(CompletionHandler<void(const String&)>&& callback)
    135105{
    136106    connection().sendWithAsyncReply(Messages::CacheStorageEngineConnection::EngineRepresentation { m_sessionID }, WTFMove(callback));

  • trunk/Source/WebKit/WebProcess/Cache/WebCacheStorageConnection.h

    r245670 r245715  
    5353
    5454    // WebCore::CacheStorageConnection
    55     void doOpen(uint64_t requestIdentifier, const WebCore::ClientOrigin&, const String& cacheName) final;
    56     void doRemove(uint64_t requestIdentifier, uint64_t cacheIdentifier) final;
    57     void doRetrieveCaches(uint64_t requestIdentifier, const WebCore::ClientOrigin&, uint64_t updateCounter) final;
     55    void open(const WebCore::ClientOrigin&, const String& cacheName, WebCore::DOMCacheEngine::CacheIdentifierCallback&&) final;
     56    void remove(uint64_t cacheIdentifier, WebCore::DOMCacheEngine::CacheIdentifierCallback&&) final;
     57    void retrieveCaches(const WebCore::ClientOrigin&, uint64_t updateCounter, WebCore::DOMCacheEngine::CacheInfosCallback&&) final;
    5858
    59     void doRetrieveRecords(uint64_t requestIdentifier, uint64_t cacheIdentifier, const URL&) final;
    60     void doBatchDeleteOperation(uint64_t requestIdentifier, uint64_t cacheIdentifier, const WebCore::ResourceRequest&, WebCore::CacheQueryOptions&&) final;
    61     void doBatchPutOperation(uint64_t requestIdentifier, uint64_t cacheIdentifier, Vector<WebCore::DOMCacheEngine::Record>&&) final;
     59    void retrieveRecords(uint64_t cacheIdentifier, const URL&, WebCore::DOMCacheEngine::RecordsCallback&&) final;
     60    void batchDeleteOperation(uint64_t cacheIdentifier, const WebCore::ResourceRequest&, WebCore::CacheQueryOptions&&, WebCore::DOMCacheEngine::RecordIdentifiersCallback&&) final;
     61    void batchPutOperation(uint64_t cacheIdentifier, Vector<WebCore::DOMCacheEngine::Record>&&, WebCore::DOMCacheEngine::RecordIdentifiersCallback&&) final;
    6262
    6363    void reference(uint64_t cacheIdentifier) final;
    … …  
    6565
    6666    void clearMemoryRepresentation(const WebCore::ClientOrigin&, WebCore::DOMCacheEngine::CompletionCallback&&) final;
    67     void engineRepresentation(WTF::Function<void(const String&)>&&) final;
     67    void engineRepresentation(CompletionHandler<void(const String&)>&&) final;
    6868    void updateQuotaBasedOnSpaceUsage(const WebCore::ClientOrigin&) final;
    69 
    70     void openCompleted(uint64_t requestIdentifier, const WebCore::DOMCacheEngine::CacheIdentifierOrError&);
    71     void removeCompleted(uint64_t requestIdentifier, const WebCore::DOMCacheEngine::CacheIdentifierOrError&);
    72     void updateCaches(uint64_t requestIdentifier, WebCore::DOMCacheEngine::CacheInfosOrError&&);
    73 
    74     void updateRecords(uint64_t requestIdentifier, WebCore::DOMCacheEngine::RecordsOrError&&);
    75     void deleteRecordsCompleted(uint64_t requestIdentifier, WebCore::DOMCacheEngine::RecordIdentifiersOrError&&);
    76     void putRecordsCompleted(uint64_t requestIdentifier, WebCore::DOMCacheEngine::RecordIdentifiersOrError&&);
    7769
    7870    WebCacheStorageProvider& m_provider;

  • trunk/Source/WebKit/WebProcess/Cache/WebCacheStorageProvider.cpp

    r220917 r245715  
    5050}
    5151
    52 void WebCacheStorageProvider::process(IPC::Connection& connection, IPC::Decoder& decoder)
    53 {
    54     if (auto* cacheConnection = m_connections.get(decoder.destinationID()))
    55         cacheConnection->didReceiveMessage(connection, decoder);
    5652}
    57 
    58 }

  • trunk/Source/WebKit/WebProcess/Cache/WebCacheStorageProvider.h

    r220917 r245715  
    4444    Ref<WebCore::CacheStorageConnection> createCacheStorageConnection(PAL::SessionID) final;
    4545
    46     void process(IPC::Connection&, IPC::Decoder&);
    47 
    4846private:
    4947    WebCacheStorageProvider() = default;

  • trunk/Source/WebKit/WebProcess/Network/NetworkProcessConnection.cpp

    r245540 r245715  
    3333#include "StorageAreaMap.h"
    3434#include "StorageAreaMapMessages.h"
    35 #include "WebCacheStorageConnection.h"
    36 #include "WebCacheStorageConnectionMessages.h"
    3735#include "WebCacheStorageProvider.h"
    3836#include "WebCoreArgumentCoders.h"
    … …  
    122120    }
    123121#endif
    124     if (decoder.messageReceiverName() == Messages::WebCacheStorageConnection::messageReceiverName()) {
    125         WebProcess::singleton().cacheStorageProvider().process(connection, decoder);
    126         return;
    127     }
    128122
    129123#if ENABLE(INDEXED_DATABASE)
Note: See TracChangeset for help on using the changeset viewer.