Changeset 231532 in webkit


Ignore:
Timestamp:
May 8, 2018, 5:40:29 PM (7 years ago)
Author:
Ryan Haddad
Message:

Unreviewed, rolling out r231486.

Caused service worker LayoutTest failures on macOS Debug WK2.

Reverted changeset:

"Allow WebResourceLoader to cancel a load served from a
service worker"
​https://bugs.webkit.org/show_bug.cgi?id=185274
​https://trac.webkit.org/changeset/231486

Location:
trunk/Source
Files:
1 deleted
25 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r231531 r231532  
     12018-05-08  Ryan Haddad  <ryanhaddad@apple.com>
     2
     3        Unreviewed, rolling out r231486.
     4
     5        Caused service worker LayoutTest failures on macOS Debug WK2.
     6
     7        Reverted changeset:
     8
     9        "Allow WebResourceLoader to cancel a load served from a
     10        service worker"
     11        https://bugs.webkit.org/show_bug.cgi?id=185274
     12        https://trac.webkit.org/changeset/231486
     13
    1142018-05-08  Wenson Hsieh  <wenson_hsieh@apple.com>
    215

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

    r231531 r231532  
    10731073                4162A451101145AE00DFF3ED /* DedicatedWorkerGlobalScope.h in Headers */ = {isa = PBXBuildFile; fileRef = 4162A44E101145AE00DFF3ED /* DedicatedWorkerGlobalScope.h */; };
    10741074                4162A4581011464700DFF3ED /* JSDedicatedWorkerGlobalScope.h in Headers */ = {isa = PBXBuildFile; fileRef = 4162A4561011464700DFF3ED /* JSDedicatedWorkerGlobalScope.h */; };
    1075                 416E0B3A209BC3CB004A95D9 /* FetchIdentifier.h in Headers */ = {isa = PBXBuildFile; fileRef = 416E0B37209BC3C2004A95D9 /* FetchIdentifier.h */; settings = {ATTRIBUTES = (Private, ); }; };
    10761075                416E29A6102FA962007FC14E /* WorkerReportingProxy.h in Headers */ = {isa = PBXBuildFile; fileRef = 416E29A5102FA962007FC14E /* WorkerReportingProxy.h */; };
    10771076                416E6FE81BBD12DF000A3F64 /* ReadableStreamInternalsBuiltins.h in Headers */ = {isa = PBXBuildFile; fileRef = 9B03D8061BB3110D00B764D9 /* ReadableStreamInternalsBuiltins.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    72027201                4162A4551011464700DFF3ED /* JSDedicatedWorkerGlobalScope.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSDedicatedWorkerGlobalScope.cpp; sourceTree = "<group>"; };
    72037202                4162A4561011464700DFF3ED /* JSDedicatedWorkerGlobalScope.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSDedicatedWorkerGlobalScope.h; sourceTree = "<group>"; };
    7204                 416E0B37209BC3C2004A95D9 /* FetchIdentifier.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FetchIdentifier.h; sourceTree = "<group>"; };
    72057203                416E29A5102FA962007FC14E /* WorkerReportingProxy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WorkerReportingProxy.h; sourceTree = "<group>"; };
    72067204                4170A2E91D8C0CC000318452 /* JSDOMWrapper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSDOMWrapper.cpp; sourceTree = "<group>"; };
    … …  
    1699316991                                41F54F831C50C4F600338488 /* FetchHeaders.h */,
    1699416992                                41F54F841C50C4F600338488 /* FetchHeaders.idl */,
    16995                                 416E0B37209BC3C2004A95D9 /* FetchIdentifier.h */,
    1699616993                                4147E2B41C89912600A7E715 /* FetchLoader.cpp */,
    1699716994                                4147E2B51C89912600A7E715 /* FetchLoader.h */,
    … …  
    2776327760                                4129C9971F59B963009D7403 /* FetchBodySource.h in Headers */,
    2776427761                                41D129DB1F3D143800D15E47 /* FetchHeaders.h in Headers */,
    27765                                 416E0B3A209BC3CB004A95D9 /* FetchIdentifier.h in Headers */,
    2776627762                                CEBB8C3320786DCB00039547 /* FetchIdioms.h in Headers */,
    2776727763                                4161E2D51FE48DC500EC2E96 /* FetchLoader.h in Headers */,

  • trunk/Source/WebCore/workers/service/context/ServiceWorkerFetch.h

    r231486 r231532  
    5454    virtual void didFinish() = 0;
    5555    virtual void didNotHandle() = 0;
    56     virtual void cancel() = 0;
    5756};
    5857

  • trunk/Source/WebCore/workers/service/context/ServiceWorkerThreadProxy.cpp

    r231486 r231532  
    186186}
    187187
    188 void ServiceWorkerThreadProxy::startFetch(SWServerConnectionIdentifier connectionIdentifier, FetchIdentifier fetchIdentifier, Ref<ServiceWorkerFetch::Client>&& client, std::optional<ServiceWorkerClientIdentifier>&& clientId, ResourceRequest&& request, String&& referrer, FetchOptions&& options)
    189 {
    190     auto key = std::make_pair(connectionIdentifier, fetchIdentifier);
    191 
    192     ASSERT(!m_ongoingFetchTasks.contains(key));
    193     m_ongoingFetchTasks.add(key, client.copyRef());
    194     thread().postFetchTask(WTFMove(client), WTFMove(clientId), WTFMove(request), WTFMove(referrer), WTFMove(options));
    195 }
    196 
    197 void ServiceWorkerThreadProxy::cancelFetch(SWServerConnectionIdentifier connectionIdentifier, FetchIdentifier fetchIdentifier)
    198 {
    199     if (auto client = m_ongoingFetchTasks.take(std::make_pair(connectionIdentifier, fetchIdentifier)))
    200         client.value()->cancel();
    201 }
    202 
    203 void ServiceWorkerThreadProxy::removeFetch(SWServerConnectionIdentifier connectionIdentifier, FetchIdentifier fetchIdentifier)
    204 {
    205     m_ongoingFetchTasks.remove(std::make_pair(connectionIdentifier, fetchIdentifier));
    206 }
    207 
    208188} // namespace WebCore
    209189

  • trunk/Source/WebCore/workers/service/context/ServiceWorkerThreadProxy.h

    r231486 r231532  
    3030#include "CacheStorageConnection.h"
    3131#include "Document.h"
    32 #include "FetchIdentifier.h"
    3332#include "Page.h"
    3433#include "SecurityOrigin.h"
    … …  
    7271    WEBCORE_TESTSUPPORT_EXPORT void notifyNetworkStateChange(bool isOnline);
    7372
    74     WEBCORE_EXPORT void startFetch(SWServerConnectionIdentifier, FetchIdentifier, Ref<ServiceWorkerFetch::Client>&&, std::optional<ServiceWorkerClientIdentifier>&&, ResourceRequest&&, String&& referrer, FetchOptions&&);
    75     WEBCORE_EXPORT void cancelFetch(SWServerConnectionIdentifier, FetchIdentifier);
    76     WEBCORE_EXPORT void removeFetch(SWServerConnectionIdentifier, FetchIdentifier);
    77 
    7873private:
    7974    WEBCORE_EXPORT ServiceWorkerThreadProxy(PageConfiguration&&, const ServiceWorkerContextData&, PAL::SessionID, String&& userAgent, CacheStorageProvider&, SecurityOrigin::StorageBlockingPolicy);
    … …  
    10297    std::unique_ptr<ServiceWorkerDebuggable> m_remoteDebuggable;
    10398#endif
    104     HashMap<std::pair<SWServerConnectionIdentifier, FetchIdentifier>, Ref<ServiceWorkerFetch::Client>> m_ongoingFetchTasks;
    10599};
    106100

  • trunk/Source/WebKit/ChangeLog

    r231530 r231532  
     12018-05-08  Ryan Haddad  <ryanhaddad@apple.com>
     2
     3        Unreviewed, rolling out r231486.
     4
     5        Caused service worker LayoutTest failures on macOS Debug WK2.
     6
     7        Reverted changeset:
     8
     9        "Allow WebResourceLoader to cancel a load served from a
     10        service worker"
     11        https://bugs.webkit.org/show_bug.cgi?id=185274
     12        https://trac.webkit.org/changeset/231486
     13
    1142018-05-08  Andy Estes  <aestes@apple.com>
    215

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

    r231486 r231532  
    192192        'String',
    193193        'WebCore::DocumentIdentifier',
    194         'WebCore::FetchIdentifier',
    195194        'WebCore::ServiceWorkerIdentifier',
    196195        'WebCore::ServiceWorkerJobIdentifier',

  • trunk/Source/WebKit/StorageProcess/ServiceWorker/WebSWServerConnection.cpp

    r231486 r231532  
    132132}
    133133
    134 void WebSWServerConnection::cancelFetch(ServiceWorkerRegistrationIdentifier serviceWorkerRegistrationIdentifier, FetchIdentifier fetchIdentifier)
    135 {
    136     auto* worker = server().activeWorkerFromRegistrationID(serviceWorkerRegistrationIdentifier);
    137     if (!worker || !worker->isRunning())
    138         return;
    139 
    140     auto serviceWorkerIdentifier = worker->identifier();
    141     server().runServiceWorkerIfNecessary(serviceWorkerIdentifier, [weakThis = makeWeakPtr(this), this, serviceWorkerIdentifier, fetchIdentifier](auto* contextConnection) mutable {
    142         if (weakThis && contextConnection)
    143             sendToContextProcess(*contextConnection, Messages::WebSWContextManagerConnection::CancelFetch { this->identifier(), serviceWorkerIdentifier, fetchIdentifier });
    144     });
    145 }
    146 
    147 void WebSWServerConnection::startFetch(ServiceWorkerRegistrationIdentifier serviceWorkerRegistrationIdentifier, FetchIdentifier fetchIdentifier, ResourceRequest&& request, FetchOptions&& options, IPC::FormDataReference&& formData, String&& referrer)
     134void WebSWServerConnection::startFetch(uint64_t fetchIdentifier, ServiceWorkerRegistrationIdentifier serviceWorkerRegistrationIdentifier, ResourceRequest&& request, FetchOptions&& options, IPC::FormDataReference&& formData, String&& referrer)
    148135{
    149136    auto* worker = server().activeWorkerFromRegistrationID(serviceWorkerRegistrationIdentifier);
    150137    if (!worker) {
    151         SWSERVERCONNECTION_RELEASE_LOG_ERROR_IF_ALLOWED("startFetch: fetchIdentifier: %s -> DidNotHandle because no active worker", fetchIdentifier.loggingString().utf8().data());
    152         m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidNotHandle { }, fetchIdentifier.toUInt64());
     138        SWSERVERCONNECTION_RELEASE_LOG_ERROR_IF_ALLOWED("startFetch: fetchIdentifier: %" PRIu64 " -> DidNotHandle because no active worker", fetchIdentifier);
     139        m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidNotHandle { }, fetchIdentifier);
    153140        return;
    154141    }
    … …  
    160147
    161148        if (!success) {
    162             SWSERVERCONNECTION_RELEASE_LOG_ERROR_IF_ALLOWED("startFetch: fetchIdentifier: %s DidNotHandle because worker did not become activated", fetchIdentifier.loggingString().utf8().data());
    163             m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidNotHandle { }, fetchIdentifier.toUInt64());
     149            SWSERVERCONNECTION_RELEASE_LOG_ERROR_IF_ALLOWED("startFetch: fetchIdentifier: %" PRIu64 " -> DidNotHandle because worker did not become activated", fetchIdentifier);
     150            m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidNotHandle { }, fetchIdentifier);
    164151            return;
    165152        }
    … …  
    167154        auto* worker = server().workerByID(serviceWorkerIdentifier);
    168155        if (!worker) {
    169             m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidNotHandle { }, fetchIdentifier.toUInt64());
     156            m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidNotHandle { }, fetchIdentifier);
    170157            return;
    171158        }
    … …  
    179166
    180167            if (contextConnection) {
    181                 SWSERVERCONNECTION_RELEASE_LOG_IF_ALLOWED("startFetch: Starting fetch %s via service worker %s", fetchIdentifier.loggingString().utf8().data(), serviceWorkerIdentifier.loggingString().utf8().data());
    182                 sendToContextProcess(*contextConnection, Messages::WebSWContextManagerConnection::StartFetch { this->identifier(), serviceWorkerIdentifier, fetchIdentifier, request, options, formData, referrer });
     168                SWSERVERCONNECTION_RELEASE_LOG_IF_ALLOWED("startFetch: Starting fetch %" PRIu64 " via service worker %" PRIu64, fetchIdentifier, serviceWorkerIdentifier.toUInt64());
     169                sendToContextProcess(*contextConnection, Messages::WebSWContextManagerConnection::StartFetch { this->identifier(), fetchIdentifier, serviceWorkerIdentifier, request, options, formData, referrer });
    183170            } else {
    184                 SWSERVERCONNECTION_RELEASE_LOG_ERROR_IF_ALLOWED("startFetch: fetchIdentifier: %s DidNotHandle because failed to run service worker", fetchIdentifier.loggingString().utf8().data());
    185                 m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidNotHandle { }, fetchIdentifier.toUInt64());
     171                SWSERVERCONNECTION_RELEASE_LOG_ERROR_IF_ALLOWED("startFetch: fetchIdentifier: %" PRIu64 " -> DidNotHandle because failed to run service worker", fetchIdentifier);
     172                m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidNotHandle { }, fetchIdentifier);
    186173            }
    187174        });
    … …  
    236223}
    237224
    238 void WebSWServerConnection::didReceiveFetchResponse(FetchIdentifier fetchIdentifier, const ResourceResponse& response)
    239 {
    240     m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidReceiveResponse { response }, fetchIdentifier.toUInt64());
    241 }
    242 
    243 void WebSWServerConnection::didReceiveFetchData(FetchIdentifier fetchIdentifier, const IPC::DataReference& data, int64_t encodedDataLength)
    244 {
    245     m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidReceiveData { data, encodedDataLength }, fetchIdentifier.toUInt64());
    246 }
    247 
    248 void WebSWServerConnection::didReceiveFetchFormData(FetchIdentifier fetchIdentifier, const IPC::FormDataReference& formData)
    249 {
    250     m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidReceiveFormData { formData }, fetchIdentifier.toUInt64());
    251 }
    252 
    253 void WebSWServerConnection::didFinishFetch(FetchIdentifier fetchIdentifier)
    254 {
    255     SWSERVERCONNECTION_RELEASE_LOG_IF_ALLOWED("didFinishFetch: fetchIdentifier: %s", fetchIdentifier.loggingString().utf8().data());
    256     m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidFinish { }, fetchIdentifier.toUInt64());
    257 }
    258 
    259 void WebSWServerConnection::didFailFetch(FetchIdentifier fetchIdentifier)
    260 {
    261     SWSERVERCONNECTION_RELEASE_LOG_ERROR_IF_ALLOWED("didFailFetch: fetchIdentifier: %s", fetchIdentifier.loggingString().utf8().data());
    262     m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidFail { }, fetchIdentifier.toUInt64());
    263 }
    264 
    265 void WebSWServerConnection::didNotHandleFetch(FetchIdentifier fetchIdentifier)
    266 {
    267     SWSERVERCONNECTION_RELEASE_LOG_IF_ALLOWED("didNotHandleFetch: fetchIdentifier: %s", fetchIdentifier.loggingString().utf8().data());
    268     m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidNotHandle { }, fetchIdentifier.toUInt64());
     225
     226void WebSWServerConnection::didReceiveFetchResponse(uint64_t fetchIdentifier, const ResourceResponse& response)
     227{
     228    m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidReceiveResponse { response }, fetchIdentifier);
     229}
     230
     231void WebSWServerConnection::didReceiveFetchData(uint64_t fetchIdentifier, const IPC::DataReference& data, int64_t encodedDataLength)
     232{
     233    m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidReceiveData { data, encodedDataLength }, fetchIdentifier);
     234}
     235
     236void WebSWServerConnection::didReceiveFetchFormData(uint64_t fetchIdentifier, const IPC::FormDataReference& formData)
     237{
     238    m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidReceiveFormData { formData }, fetchIdentifier);
     239}
     240
     241void WebSWServerConnection::didFinishFetch(uint64_t fetchIdentifier)
     242{
     243    SWSERVERCONNECTION_RELEASE_LOG_IF_ALLOWED("didFinishFetch: fetchIdentifier: %" PRIu64, fetchIdentifier);
     244    m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidFinish { }, fetchIdentifier);
     245}
     246
     247void WebSWServerConnection::didFailFetch(uint64_t fetchIdentifier)
     248{
     249    SWSERVERCONNECTION_RELEASE_LOG_ERROR_IF_ALLOWED("didFailFetch: fetchIdentifier: %" PRIu64, fetchIdentifier);
     250    m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidFail { }, fetchIdentifier);
     251}
     252
     253void WebSWServerConnection::didNotHandleFetch(uint64_t fetchIdentifier)
     254{
     255    SWSERVERCONNECTION_RELEASE_LOG_IF_ALLOWED("didNotHandleFetch: fetchIdentifier: %" PRIu64, fetchIdentifier);
     256    m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidNotHandle { }, fetchIdentifier);
    269257}
    270258

  • trunk/Source/WebKit/StorageProcess/ServiceWorker/WebSWServerConnection.h

    r231486 r231532  
    3030#include "MessageReceiver.h"
    3131#include "MessageSender.h"
    32 #include <WebCore/FetchIdentifier.h>
    3332#include <WebCore/SWServer.h>
    3433#include <pal/SessionID.h>
    … …  
    6362    PAL::SessionID sessionID() const { return m_sessionID; }
    6463
    65     void didReceiveFetchResponse(WebCore::FetchIdentifier, const WebCore::ResourceResponse&);
    66     void didReceiveFetchData(WebCore::FetchIdentifier, const IPC::DataReference&, int64_t encodedDataLength);
    67     void didReceiveFetchFormData(WebCore::FetchIdentifier, const IPC::FormDataReference&);
    68     void didFinishFetch(WebCore::FetchIdentifier);
    69     void didFailFetch(WebCore::FetchIdentifier);
    70     void didNotHandleFetch(WebCore::FetchIdentifier);
     64    void didReceiveFetchResponse(uint64_t fetchIdentifier, const WebCore::ResourceResponse&);
     65    void didReceiveFetchData(uint64_t fetchIdentifier, const IPC::DataReference&, int64_t encodedDataLength);
     66    void didReceiveFetchFormData(uint64_t fetchIdentifier, const IPC::FormDataReference&);
     67    void didFinishFetch(uint64_t fetchIdentifier);
     68    void didFailFetch(uint64_t fetchIdentifier);
     69    void didNotHandleFetch(uint64_t fetchIdentifier);
    7170
    7271    void postMessageToServiceWorkerClient(WebCore::DocumentIdentifier destinationContextIdentifier, WebCore::MessageWithMessagePorts&&, WebCore::ServiceWorkerIdentifier sourceServiceWorkerIdentifier, const String& sourceOrigin);
    … …  
    8988    void scheduleJobInServer(WebCore::ServiceWorkerJobData&&);
    9089
    91     void startFetch(WebCore::ServiceWorkerRegistrationIdentifier, WebCore::FetchIdentifier, WebCore::ResourceRequest&&, WebCore::FetchOptions&&, IPC::FormDataReference&&, String&& referrer);
    92     void cancelFetch(WebCore::ServiceWorkerRegistrationIdentifier, WebCore::FetchIdentifier);
     90    void startFetch(uint64_t fetchIdentifier, WebCore::ServiceWorkerRegistrationIdentifier, WebCore::ResourceRequest&&, WebCore::FetchOptions&&, IPC::FormDataReference&&, String&& referrer);
    9391
    9492    void matchRegistration(uint64_t registrationMatchRequestIdentifier, const WebCore::SecurityOriginData& topOrigin, const WebCore::URL& clientURL);

  • trunk/Source/WebKit/StorageProcess/ServiceWorker/WebSWServerConnection.messages.in

    r231486 r231532  
    3030    RemoveServiceWorkerRegistrationInServer(WebCore::ServiceWorkerRegistrationIdentifier identifier)
    3131
    32     StartFetch(WebCore::ServiceWorkerRegistrationIdentifier serviceWorkerRegistrationIdentifier, WebCore::FetchIdentifier fetchIdentifier, WebCore::ResourceRequest request, struct WebCore::FetchOptions options, IPC::FormDataReference requestBody, String referrer)
    33     CancelFetch(WebCore::ServiceWorkerRegistrationIdentifier serviceWorkerRegistrationIdentifier, WebCore::FetchIdentifier fetchIdentifier)
     32    StartFetch(uint64_t identifier, WebCore::ServiceWorkerRegistrationIdentifier serviceWorkerRegistrationIdentifier, WebCore::ResourceRequest request, struct WebCore::FetchOptions options, IPC::FormDataReference requestBody, String referrer)
    3433
    3534    PostMessageToServiceWorker(WebCore::ServiceWorkerIdentifier destination, struct WebCore::MessageWithMessagePorts message, WebCore::ServiceWorkerOrClientIdentifier source)

  • trunk/Source/WebKit/StorageProcess/StorageProcess.cpp

    r231486 r231532  
    466466}
    467467
    468 void StorageProcess::didFailFetch(SWServerConnectionIdentifier serverConnectionIdentifier, FetchIdentifier fetchIdentifier)
     468void StorageProcess::didFailFetch(SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier)
    469469{
    470470    if (auto* connection = m_swServerConnections.get(serverConnectionIdentifier))
    … …  
    472472}
    473473
    474 void StorageProcess::didNotHandleFetch(SWServerConnectionIdentifier serverConnectionIdentifier, FetchIdentifier fetchIdentifier)
     474void StorageProcess::didNotHandleFetch(SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier)
    475475{
    476476    if (auto* connection = m_swServerConnections.get(serverConnectionIdentifier))
    … …  
    478478}
    479479
    480 void StorageProcess::didReceiveFetchResponse(SWServerConnectionIdentifier serverConnectionIdentifier, FetchIdentifier fetchIdentifier, const WebCore::ResourceResponse& response)
     480void StorageProcess::didReceiveFetchResponse(SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier, const WebCore::ResourceResponse& response)
    481481{
    482482    if (auto* connection = m_swServerConnections.get(serverConnectionIdentifier))
    … …  
    484484}
    485485
    486 void StorageProcess::didReceiveFetchData(SWServerConnectionIdentifier serverConnectionIdentifier, FetchIdentifier fetchIdentifier, const IPC::DataReference& data, int64_t encodedDataLength)
     486void StorageProcess::didReceiveFetchData(SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier, const IPC::DataReference& data, int64_t encodedDataLength)
    487487{
    488488    if (auto* connection = m_swServerConnections.get(serverConnectionIdentifier))
    … …  
    490490}
    491491
    492 void StorageProcess::didReceiveFetchFormData(SWServerConnectionIdentifier serverConnectionIdentifier, FetchIdentifier fetchIdentifier, const IPC::FormDataReference& formData)
     492void StorageProcess::didReceiveFetchFormData(SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier, const IPC::FormDataReference& formData)
    493493{
    494494    if (auto* connection = m_swServerConnections.get(serverConnectionIdentifier))
    … …  
    496496}
    497497
    498 void StorageProcess::didFinishFetch(SWServerConnectionIdentifier serverConnectionIdentifier, FetchIdentifier fetchIdentifier)
     498void StorageProcess::didFinishFetch(SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier)
    499499{
    500500    if (auto* connection = m_swServerConnections.get(serverConnectionIdentifier))

  • trunk/Source/WebKit/StorageProcess/StorageProcess.h

    r231486 r231532  
    2828#include "ChildProcess.h"
    2929#include "SandboxExtension.h"
    30 #include <WebCore/FetchIdentifier.h>
    3130#include <WebCore/IDBBackingStore.h>
    3231#include <WebCore/IDBServer.h>
    … …  
    137136#endif
    138137#if ENABLE(SERVICE_WORKER)
    139     void didReceiveFetchResponse(WebCore::SWServerConnectionIdentifier, WebCore::FetchIdentifier, const WebCore::ResourceResponse&);
    140     void didReceiveFetchData(WebCore::SWServerConnectionIdentifier, WebCore::FetchIdentifier, const IPC::DataReference&, int64_t encodedDataLength);
    141     void didReceiveFetchFormData(WebCore::SWServerConnectionIdentifier, WebCore::FetchIdentifier, const IPC::FormDataReference&);
    142     void didFinishFetch(WebCore::SWServerConnectionIdentifier, WebCore::FetchIdentifier);
    143     void didFailFetch(WebCore::SWServerConnectionIdentifier, WebCore::FetchIdentifier);
    144     void didNotHandleFetch(WebCore::SWServerConnectionIdentifier, WebCore::FetchIdentifier);
     138    void didReceiveFetchResponse(WebCore::SWServerConnectionIdentifier, uint64_t fetchIdentifier, const WebCore::ResourceResponse&);
     139    void didReceiveFetchData(WebCore::SWServerConnectionIdentifier, uint64_t fetchIdentifier, const IPC::DataReference&, int64_t encodedDataLength);
     140    void didReceiveFetchFormData(WebCore::SWServerConnectionIdentifier, uint64_t fetchIdentifier, const IPC::FormDataReference&);
     141    void didFinishFetch(WebCore::SWServerConnectionIdentifier, uint64_t fetchIdentifier);
     142    void didFailFetch(WebCore::SWServerConnectionIdentifier, uint64_t fetchIdentifier);
     143    void didNotHandleFetch(WebCore::SWServerConnectionIdentifier, uint64_t fetchIdentifier);
    145144
    146145    void postMessageToServiceWorkerClient(const WebCore::ServiceWorkerClientIdentifier& destinationIdentifier, WebCore::MessageWithMessagePorts&&, WebCore::ServiceWorkerIdentifier sourceIdentifier, const String& sourceOrigin);

  • trunk/Source/WebKit/StorageProcess/StorageProcess.messages.in

    r231486 r231532  
    3737
    3838#if ENABLE(SERVICE_WORKER)
    39     DidNotHandleFetch(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, WebCore::FetchIdentifier fetchIdentifier)
    40     DidFailFetch(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, WebCore::FetchIdentifier fetchIdentifier)
    41     DidReceiveFetchResponse(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, WebCore::FetchIdentifier fetchIdentifier, WebCore::ResourceResponse response)
    42     DidReceiveFetchData(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, WebCore::FetchIdentifier fetchIdentifier, IPC::DataReference data, int64_t encodedDataLength)
    43     DidReceiveFetchFormData(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, WebCore::FetchIdentifier fetchIdentifier, IPC::FormDataReference data)
    44     DidFinishFetch(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, WebCore::FetchIdentifier fetchIdentifier)
     39    DidNotHandleFetch(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier)
     40    DidFailFetch(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier)
     41    DidReceiveFetchResponse(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier, WebCore::ResourceResponse response)
     42    DidReceiveFetchData(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier, IPC::DataReference data, int64_t encodedDataLength)
     43    DidReceiveFetchFormData(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier, IPC::FormDataReference data)
     44    DidFinishFetch(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier)
    4545    PostMessageToServiceWorkerClient(struct WebCore::ServiceWorkerClientIdentifier destinationIdentifier, struct WebCore::MessageWithMessagePorts message, WebCore::ServiceWorkerIdentifier sourceIdentifier, String sourceOrigin)
    4646

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

    r231486 r231532  
    400400
    401401#if ENABLE(SERVICE_WORKER)
    402     if (WebServiceWorkerProvider::singleton().cancelFetch(makeObjectIdentifier<FetchIdentifierType>(identifier)))
     402    if (WebServiceWorkerProvider::singleton().cancelFetch(identifier))
    403403        return;
    404404#endif

  • trunk/Source/WebKit/WebProcess/Storage/ServiceWorkerClientFetch.cpp

    r231486 r231532  
    4141namespace WebKit {
    4242
    43 Ref<ServiceWorkerClientFetch> ServiceWorkerClientFetch::create(WebServiceWorkerProvider& serviceWorkerProvider, Ref<WebCore::ResourceLoader>&& loader, FetchIdentifier identifier, Ref<WebSWClientConnection>&& connection, bool shouldClearReferrerOnHTTPSToHTTPRedirect, Callback&& callback)
     43Ref<ServiceWorkerClientFetch> ServiceWorkerClientFetch::create(WebServiceWorkerProvider& serviceWorkerProvider, Ref<WebCore::ResourceLoader>&& loader, uint64_t identifier, Ref<WebSWClientConnection>&& connection, bool shouldClearReferrerOnHTTPSToHTTPRedirect, Callback&& callback)
    4444{
    4545    auto fetch = adoptRef(*new ServiceWorkerClientFetch { serviceWorkerProvider, WTFMove(loader), identifier, WTFMove(connection), shouldClearReferrerOnHTTPSToHTTPRedirect, WTFMove(callback) });
    … …  
    5252}
    5353
    54 ServiceWorkerClientFetch::ServiceWorkerClientFetch(WebServiceWorkerProvider& serviceWorkerProvider, Ref<WebCore::ResourceLoader>&& loader, FetchIdentifier identifier, Ref<WebSWClientConnection>&& connection, bool shouldClearReferrerOnHTTPSToHTTPRedirect, Callback&& callback)
     54ServiceWorkerClientFetch::ServiceWorkerClientFetch(WebServiceWorkerProvider& serviceWorkerProvider, Ref<WebCore::ResourceLoader>&& loader, uint64_t identifier, Ref<WebSWClientConnection>&& connection, bool shouldClearReferrerOnHTTPSToHTTPRedirect, Callback&& callback)
    5555    : m_serviceWorkerProvider(serviceWorkerProvider)
    5656    , m_loader(WTFMove(loader))
    … …  
    7676
    7777    ASSERT(options.serviceWorkersMode != ServiceWorkersMode::None);
    78     m_serviceWorkerRegistrationIdentifier = options.serviceWorkerRegistrationIdentifier.value();
    79     m_connection->startFetch(m_identifier, m_serviceWorkerRegistrationIdentifier, request, options, referrer);
     78    m_connection->startFetch(m_loader->identifier(), options.serviceWorkerRegistrationIdentifier.value(), request, options, referrer);
    8079
    8180    m_redirectionStatus = RedirectionStatus::None;
    … …  
    261260    if (auto callback = WTFMove(m_callback))
    262261        callback(Result::Cancelled);
    263 
    264     if (!m_didFinish && !m_didFail) {
    265         m_connection->cancelFetch(m_identifier, m_serviceWorkerRegistrationIdentifier);
    266 
    267     }
    268262    m_loader = nullptr;
    269263    m_buffer = nullptr;

  • trunk/Source/WebKit/WebProcess/Storage/ServiceWorkerClientFetch.h

    r231486 r231532  
    3232#include "MessageReceiver.h"
    3333#include "MessageSender.h"
    34 #include <WebCore/FetchIdentifier.h>
    3534#include <WebCore/ResourceLoader.h>
    3635#include <wtf/CompletionHandler.h>
    … …  
    4645    using Callback = WTF::CompletionHandler<void(Result)>;
    4746
    48     static Ref<ServiceWorkerClientFetch> create(WebServiceWorkerProvider&, Ref<WebCore::ResourceLoader>&&, WebCore::FetchIdentifier, Ref<WebSWClientConnection>&&, bool shouldClearReferrerOnHTTPSToHTTPRedirect, Callback&&);
     47    static Ref<ServiceWorkerClientFetch> create(WebServiceWorkerProvider&, Ref<WebCore::ResourceLoader>&&, uint64_t identifier, Ref<WebSWClientConnection>&&, bool shouldClearReferrerOnHTTPSToHTTPRedirect, Callback&&);
    4948    ~ServiceWorkerClientFetch();
    5049
    … …  
    5756
    5857private:
    59     ServiceWorkerClientFetch(WebServiceWorkerProvider&, Ref<WebCore::ResourceLoader>&&, WebCore::FetchIdentifier, Ref<WebSWClientConnection>&&, bool shouldClearReferrerOnHTTPSToHTTPRedirect, Callback&&);
     58    ServiceWorkerClientFetch(WebServiceWorkerProvider&, Ref<WebCore::ResourceLoader>&&, uint64_t identifier, Ref<WebSWClientConnection>&&, bool shouldClearReferrerOnHTTPSToHTTPRedirect, Callback&&);
    6059
    6160    std::optional<WebCore::ResourceError> validateResponse(const WebCore::ResourceResponse&);
    … …  
    7271    WebServiceWorkerProvider& m_serviceWorkerProvider;
    7372    RefPtr<WebCore::ResourceLoader> m_loader;
    74     WebCore::FetchIdentifier m_identifier;
     73    uint64_t m_identifier { 0 };
    7574    Ref<WebSWClientConnection> m_connection;
    7675    Callback m_callback;
    … …  
    8382    bool m_didFinish { false };
    8483    bool m_didFail { false };
    85 
    86     WebCore::ServiceWorkerRegistrationIdentifier m_serviceWorkerRegistrationIdentifier;
    8784};
    8885

  • trunk/Source/WebKit/WebProcess/Storage/WebSWClientConnection.cpp

    r231486 r231532  
    200200}
    201201
    202 void WebSWClientConnection::startFetch(WebCore::FetchIdentifier fetchIdentifier, WebCore::ServiceWorkerRegistrationIdentifier serviceWorkerRegistrationIdentifier, const WebCore::ResourceRequest& request, const WebCore::FetchOptions& options, const String& referrer)
    203 {
    204     send(Messages::WebSWServerConnection::StartFetch { serviceWorkerRegistrationIdentifier, fetchIdentifier, request, options, IPC::FormDataReference { request.httpBody() }, referrer });
    205 }
    206 
    207 void WebSWClientConnection::cancelFetch(WebCore::FetchIdentifier fetchIdentifier, WebCore::ServiceWorkerRegistrationIdentifier serviceWorkerRegistrationIdentifier)
    208 {
    209     send(Messages::WebSWServerConnection::CancelFetch { serviceWorkerRegistrationIdentifier, fetchIdentifier });
     202void WebSWClientConnection::startFetch(uint64_t fetchIdentifier, WebCore::ServiceWorkerRegistrationIdentifier serviceWorkerRegistrationIdentifier, const WebCore::ResourceRequest& request, const WebCore::FetchOptions& options, const String& referrer)
     203{
     204    send(Messages::WebSWServerConnection::StartFetch { fetchIdentifier, serviceWorkerRegistrationIdentifier, request, options, IPC::FormDataReference { request.httpBody() }, referrer });
    210205}
    211206

  • trunk/Source/WebKit/WebProcess/Storage/WebSWClientConnection.h

    r231486 r231532  
    6262
    6363    bool mayHaveServiceWorkerRegisteredForOrigin(const WebCore::SecurityOriginData&) const final;
    64     void startFetch(WebCore::FetchIdentifier, WebCore::ServiceWorkerRegistrationIdentifier, const WebCore::ResourceRequest&, const WebCore::FetchOptions&, const String& referrer);
    65     void cancelFetch(WebCore::FetchIdentifier, WebCore::ServiceWorkerRegistrationIdentifier);
     64    void startFetch(uint64_t fetchIdentifier, WebCore::ServiceWorkerRegistrationIdentifier, const WebCore::ResourceRequest&, const WebCore::FetchOptions&, const String& referrer);
    6665
    6766    void postMessageToServiceWorkerClient(WebCore::DocumentIdentifier destinationContextIdentifier, WebCore::MessageWithMessagePorts&&, WebCore::ServiceWorkerData&& source, const String& sourceOrigin);

  • trunk/Source/WebKit/WebProcess/Storage/WebSWContextManagerConnection.cpp

    r231486 r231532  
    199199}
    200200
    201 void WebSWContextManagerConnection::cancelFetch(SWServerConnectionIdentifier serverConnectionIdentifier, ServiceWorkerIdentifier serviceWorkerIdentifier, FetchIdentifier fetchIdentifier)
    202 {
    203     if (auto* serviceWorkerThreadProxy = SWContextManager::singleton().serviceWorkerThreadProxy(serviceWorkerIdentifier))
    204         serviceWorkerThreadProxy->cancelFetch(serverConnectionIdentifier, fetchIdentifier);
    205 }
    206 
    207 void WebSWContextManagerConnection::startFetch(SWServerConnectionIdentifier serverConnectionIdentifier, ServiceWorkerIdentifier serviceWorkerIdentifier, FetchIdentifier fetchIdentifier, ResourceRequest&& request, FetchOptions&& options, IPC::FormDataReference&& formData, String&& referrer)
     201void WebSWContextManagerConnection::startFetch(SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier, ServiceWorkerIdentifier serviceWorkerIdentifier, ResourceRequest&& request, FetchOptions&& options, IPC::FormDataReference&& formData, String&& referrer)
    208202{
    209203    auto* serviceWorkerThreadProxy = SWContextManager::singleton().serviceWorkerThreadProxy(serviceWorkerIdentifier);
    210204    if (!serviceWorkerThreadProxy) {
    211         m_connectionToStorageProcess->send(Messages::StorageProcess::DidNotHandleFetch { serverConnectionIdentifier, fetchIdentifier }, 0);
     205        m_connectionToStorageProcess->send(Messages::StorageProcess::DidNotHandleFetch(serverConnectionIdentifier, fetchIdentifier), 0);
    212206        return;
    213207    }
    … …  
    221215
    222216    request.setHTTPBody(formData.takeData());
    223     serviceWorkerThreadProxy->startFetch(serverConnectionIdentifier, fetchIdentifier, WTFMove(client), WTFMove(clientId), WTFMove(request), WTFMove(referrer), WTFMove(options));
     217    serviceWorkerThreadProxy->thread().postFetchTask(WTFMove(client), WTFMove(clientId), WTFMove(request), WTFMove(referrer), WTFMove(options));
    224218}
    225219

  • trunk/Source/WebKit/WebProcess/Storage/WebSWContextManagerConnection.h

    r231486 r231532  
    7777    void serviceWorkerStartedWithMessage(std::optional<WebCore::ServiceWorkerJobDataIdentifier>, WebCore::ServiceWorkerIdentifier, const String& exceptionMessage) final;
    7878    void installServiceWorker(const WebCore::ServiceWorkerContextData&, PAL::SessionID);
    79     void startFetch(WebCore::SWServerConnectionIdentifier, WebCore::ServiceWorkerIdentifier, WebCore::FetchIdentifier, WebCore::ResourceRequest&&, WebCore::FetchOptions&&, IPC::FormDataReference&&, String&& referrer);
    80     void cancelFetch(WebCore::SWServerConnectionIdentifier, WebCore::ServiceWorkerIdentifier, WebCore::FetchIdentifier);
     79    void startFetch(WebCore::SWServerConnectionIdentifier, uint64_t fetchIdentifier, WebCore::ServiceWorkerIdentifier, WebCore::ResourceRequest&&, WebCore::FetchOptions&&, IPC::FormDataReference&&, String&& referrer);
    8180    void postMessageToServiceWorker(WebCore::ServiceWorkerIdentifier destinationIdentifier, WebCore::MessageWithMessagePorts&&, WebCore::ServiceWorkerOrClientData&& sourceData);
    8281    void fireInstallEvent(WebCore::ServiceWorkerIdentifier);

  • trunk/Source/WebKit/WebProcess/Storage/WebSWContextManagerConnection.messages.in

    r231486 r231532  
    2525messages -> WebSWContextManagerConnection {
    2626    InstallServiceWorker(struct WebCore::ServiceWorkerContextData contextData, PAL::SessionID sessionID)
    27     StartFetch(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, WebCore::ServiceWorkerIdentifier serviceWorkerIdentifier, WebCore::FetchIdentifier fetchIdentifier, WebCore::ResourceRequest request, struct WebCore::FetchOptions options, IPC::FormDataReference requestBody, String referrer)
    28     CancelFetch(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, WebCore::ServiceWorkerIdentifier serviceWorkerIdentifier, WebCore::FetchIdentifier fetchIdentifier)
     27    StartFetch(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier, WebCore::ServiceWorkerIdentifier serviceWorkerIdentifier, WebCore::ResourceRequest request, struct WebCore::FetchOptions options, IPC::FormDataReference requestBody, String referrer)
    2928    PostMessageToServiceWorker(WebCore::ServiceWorkerIdentifier destinationIdentifier, struct WebCore::MessageWithMessagePorts message, WebCore::ServiceWorkerOrClientData sourceData)
    3029    FireInstallEvent(WebCore::ServiceWorkerIdentifier identifier)

  • trunk/Source/WebKit/WebProcess/Storage/WebServiceWorkerFetchTaskClient.cpp

    r231486 r231532  
    4747}
    4848
    49 WebServiceWorkerFetchTaskClient::WebServiceWorkerFetchTaskClient(Ref<IPC::Connection>&& connection, WebCore::ServiceWorkerIdentifier serviceWorkerIdentifier, WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, FetchIdentifier fetchIdentifier)
     49WebServiceWorkerFetchTaskClient::WebServiceWorkerFetchTaskClient(Ref<IPC::Connection>&& connection, WebCore::ServiceWorkerIdentifier serviceWorkerIdentifier, WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchTaskIdentifier)
    5050    : m_connection(WTFMove(connection))
    5151    , m_serverConnectionIdentifier(serverConnectionIdentifier)
    5252    , m_serviceWorkerIdentifier(serviceWorkerIdentifier)
    53     , m_fetchIdentifier(fetchIdentifier)
     53    , m_fetchTaskIdentifier(fetchTaskIdentifier)
    5454{
    5555}
    … …  
    5959    if (!m_connection)
    6060        return;
    61     m_connection->send(Messages::StorageProcess::DidReceiveFetchResponse { m_serverConnectionIdentifier, m_fetchIdentifier, response }, 0);
     61    m_connection->send(Messages::StorageProcess::DidReceiveFetchResponse { m_serverConnectionIdentifier, m_fetchTaskIdentifier, response }, 0);
    6262}
    6363
    … …  
    6767        return;
    6868    IPC::SharedBufferDataReference dataReference { buffer.ptr() };
    69     m_connection->send(Messages::StorageProcess::DidReceiveFetchData { m_serverConnectionIdentifier, m_fetchIdentifier, dataReference, static_cast<int64_t>(buffer->size()) }, 0);
     69    m_connection->send(Messages::StorageProcess::DidReceiveFetchData { m_serverConnectionIdentifier, m_fetchTaskIdentifier, dataReference, static_cast<int64_t>(buffer->size()) }, 0);
    7070}
    7171
    … …  
    7979    URL blobURL = formData->asBlobURL();
    8080    if (blobURL.isNull()) {
    81         m_connection->send(Messages::StorageProcess::DidReceiveFetchFormData { m_serverConnectionIdentifier, m_fetchIdentifier, IPC::FormDataReference { WTFMove(formData) } }, 0);
     81        m_connection->send(Messages::StorageProcess::DidReceiveFetchFormData { m_serverConnectionIdentifier, m_fetchTaskIdentifier, IPC::FormDataReference { WTFMove(formData) } }, 0);
    8282        return;
    8383    }
    … …  
    108108
    109109    IPC::DataReference dataReference { reinterpret_cast<const uint8_t*>(data), size };
    110     m_connection->send(Messages::StorageProcess::DidReceiveFetchData { m_serverConnectionIdentifier, m_fetchIdentifier, dataReference, static_cast<int64_t>(size) }, 0);
     110    m_connection->send(Messages::StorageProcess::DidReceiveFetchData { m_serverConnectionIdentifier, m_fetchTaskIdentifier, dataReference, static_cast<int64_t>(size) }, 0);
    111111}
    112112
    … …  
    122122    if (!m_connection)
    123123        return;
    124 
    125     m_connection->send(Messages::StorageProcess::DidFailFetch { m_serverConnectionIdentifier, m_fetchIdentifier }, 0);
    126 
    127     cleanup();
     124    m_connection->send(Messages::StorageProcess::DidFailFetch { m_serverConnectionIdentifier, m_fetchTaskIdentifier }, 0);
     125    m_connection = nullptr;
    128126}
    129127
    … …  
    133131        return;
    134132
    135     m_connection->send(Messages::StorageProcess::DidFinishFetch { m_serverConnectionIdentifier, m_fetchIdentifier }, 0);
    136 
    137     cleanup();
     133    m_connection->send(Messages::StorageProcess::DidFinishFetch { m_serverConnectionIdentifier, m_fetchTaskIdentifier }, 0);
     134    m_connection = nullptr;
    138135}
    139136
    … …  
    142139    if (!m_connection)
    143140        return;
    144 
    145     m_connection->send(Messages::StorageProcess::DidNotHandleFetch { m_serverConnectionIdentifier, m_fetchIdentifier }, 0);
    146 
    147     cleanup();
    148 }
    149 
    150 void WebServiceWorkerFetchTaskClient::cancel()
    151 {
     141    m_connection->send(Messages::StorageProcess::DidNotHandleFetch { m_serverConnectionIdentifier, m_fetchTaskIdentifier }, 0);
    152142    m_connection = nullptr;
    153 }
    154 
    155 void WebServiceWorkerFetchTaskClient::cleanup()
    156 {
    157     ASSERT(m_connection);
    158     m_connection = nullptr;
    159 
    160     if (!isMainThread()) {
    161         callOnMainThread([protectedThis = makeRef(*this)] () {
    162             protectedThis->cleanup();
    163         });
    164         return;
    165     }
    166     if (auto* serviceWorkerThreadProxy = SWContextManager::singleton().serviceWorkerThreadProxy(m_serviceWorkerIdentifier))
    167         serviceWorkerThreadProxy->removeFetch(m_serverConnectionIdentifier, m_fetchIdentifier);
    168143}
    169144

  • trunk/Source/WebKit/WebProcess/Storage/WebServiceWorkerFetchTaskClient.h

    r231486 r231532  
    2929
    3030#include "Connection.h"
    31 #include <WebCore/FetchIdentifier.h>
    3231#include <WebCore/FetchLoader.h>
    3332#include <WebCore/FetchLoaderClient.h>
    … …  
    3938class WebServiceWorkerFetchTaskClient final : public WebCore::ServiceWorkerFetch::Client {
    4039public:
    41     static Ref<WebServiceWorkerFetchTaskClient> create(Ref<IPC::Connection>&& connection, WebCore::ServiceWorkerIdentifier serviceWorkerIdentifier,  WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, WebCore::FetchIdentifier fetchTaskIdentifier)
     40    static Ref<WebServiceWorkerFetchTaskClient> create(Ref<IPC::Connection>&& connection, WebCore::ServiceWorkerIdentifier serviceWorkerIdentifier,  WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchTaskIdentifier)
    4241    {
    4342        return adoptRef(*new WebServiceWorkerFetchTaskClient(WTFMove(connection), serviceWorkerIdentifier, serverConnectionIdentifier, fetchTaskIdentifier));
    … …  
    4746
    4847private:
    49     WebServiceWorkerFetchTaskClient(Ref<IPC::Connection>&&, WebCore::ServiceWorkerIdentifier, WebCore::SWServerConnectionIdentifier, WebCore::FetchIdentifier);
     48    WebServiceWorkerFetchTaskClient(Ref<IPC::Connection>&&, WebCore::ServiceWorkerIdentifier, WebCore::SWServerConnectionIdentifier, uint64_t fetchTaskIdentifier);
    5049
    5150    void didReceiveResponse(const WebCore::ResourceResponse&) final;
    … …  
    5554    void didFinish() final;
    5655    void didNotHandle() final;
    57     void cancel() final;
    5856
    59     void cleanup();
    60    
    6157    void didReceiveBlobChunk(const char* data, size_t size);
    6258    void didFinishBlobLoading();
    … …  
    7874    WebCore::SWServerConnectionIdentifier m_serverConnectionIdentifier;
    7975    WebCore::ServiceWorkerIdentifier m_serviceWorkerIdentifier;
    80     WebCore::FetchIdentifier m_fetchIdentifier;
     76    uint64_t m_fetchTaskIdentifier { 0 };
    8177    std::optional<BlobLoader> m_blobLoader;
    8278};

  • trunk/Source/WebKit/WebProcess/Storage/WebServiceWorkerProvider.cpp

    r231486 r231532  
    8989
    9090    auto& connection = WebProcess::singleton().ensureWebToStorageProcessConnection(sessionID).serviceWorkerConnectionForSession(sessionID);
    91     auto fetchIdentifier = makeObjectIdentifier<FetchIdentifierType>(loader.identifier());
    92     m_ongoingFetchTasks.add(fetchIdentifier, ServiceWorkerClientFetch::create(*this, loader, fetchIdentifier, connection, shouldClearReferrerOnHTTPSToHTTPRedirect, WTFMove(callback)));
     91    m_ongoingFetchTasks.add(loader.identifier(), ServiceWorkerClientFetch::create(*this, loader, loader.identifier(), connection, shouldClearReferrerOnHTTPSToHTTPRedirect, WTFMove(callback)));
    9392}
    9493
    95 bool WebServiceWorkerProvider::cancelFetch(FetchIdentifier fetchIdentifier)
     94bool WebServiceWorkerProvider::cancelFetch(uint64_t fetchIdentifier)
    9695{
    9796    auto fetch = m_ongoingFetchTasks.take(fetchIdentifier);
    … …  
    101100}
    102101
    103 void WebServiceWorkerProvider::fetchFinished(FetchIdentifier fetchIdentifier)
     102void WebServiceWorkerProvider::fetchFinished(uint64_t fetchIdentifier)
    104103{
    105104    m_ongoingFetchTasks.take(fetchIdentifier);
    … …  
    108107void WebServiceWorkerProvider::didReceiveServiceWorkerClientFetchMessage(IPC::Connection& connection, IPC::Decoder& decoder)
    109108{
    110     if (auto fetch = m_ongoingFetchTasks.get(makeObjectIdentifier<FetchIdentifierType>(decoder.destinationID())))
     109    if (auto fetch = m_ongoingFetchTasks.get(decoder.destinationID()))
    111110        fetch->didReceiveMessage(connection, decoder);
    112111}

  • trunk/Source/WebKit/WebProcess/Storage/WebServiceWorkerProvider.h

    r231486 r231532  
    4343
    4444    void handleFetch(WebCore::ResourceLoader&, WebCore::CachedResource*, PAL::SessionID, bool shouldClearReferrerOnHTTPSToHTTPRedirect, ServiceWorkerClientFetch::Callback&&);
    45     bool cancelFetch(WebCore::FetchIdentifier);
    46     void fetchFinished(WebCore::FetchIdentifier);
     45    bool cancelFetch(uint64_t fetchIdentifier);
     46    void fetchFinished(uint64_t fetchIdentifier);
    4747
    4848    void didReceiveServiceWorkerClientFetchMessage(IPC::Connection&, IPC::Decoder&);
    … …  
    5656    WebCore::SWClientConnection& serviceWorkerConnectionForSession(PAL::SessionID) final;
    5757
    58     HashMap<WebCore::FetchIdentifier, Ref<ServiceWorkerClientFetch>> m_ongoingFetchTasks;
     58    HashMap<uint64_t, Ref<ServiceWorkerClientFetch>> m_ongoingFetchTasks;
    5959}; // class WebServiceWorkerProvider
    6060
Note: See TracChangeset for help on using the changeset viewer.