Diff
Modified: trunk/Source/WebCore/ChangeLog (231587 => 231588)
--- trunk/Source/WebCore/ChangeLog 2018-05-09 19:56:35 UTC (rev 231587)
+++ trunk/Source/WebCore/ChangeLog 2018-05-09 19:59:46 UTC (rev 231588)
@@ -1,3 +1,21 @@
+2018-05-09 Youenn Fablet <[email protected]>
+
+ Allow WebResourceLoader to cancel a load served from a service worker
+ https://bugs.webkit.org/show_bug.cgi?id=185274
+
+ Reviewed by Chris Dumez.
+
+ Add support for cancelling a fetch from WebProcess to service worker process.
+ Use FetchIdentifier instead of uint64_t.
+
+ * Modules/fetch/FetchIdentifier.h: Added.
+ * WebCore.xcodeproj/project.pbxproj:
+ * workers/service/context/ServiceWorkerFetch.h:
+ * workers/service/context/ServiceWorkerThreadProxy.cpp:
+ (WebCore::ServiceWorkerThreadProxy::startFetch):
+ (WebCore::ServiceWorkerThreadProxy::cancelFetch):
+ * workers/service/context/ServiceWorkerThreadProxy.h:
+
2018-05-09 Thibault Saunier <[email protected]>
[GStreamer] Fix style issue in MediaPlayerPrivateGStreamer
Copied: trunk/Source/WebCore/Modules/fetch/FetchIdentifier.h (from rev 231584, trunk/Source/WebCore/workers/service/context/ServiceWorkerFetch.h) (0 => 231588)
--- trunk/Source/WebCore/Modules/fetch/FetchIdentifier.h (rev 0)
+++ trunk/Source/WebCore/Modules/fetch/FetchIdentifier.h 2018-05-09 19:59:46 UTC (rev 231588)
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2017 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <wtf/ObjectIdentifier.h>
+
+namespace WebCore {
+
+enum FetchIdentifierType { };
+using FetchIdentifier = ObjectIdentifier<FetchIdentifierType>;
+
+}
Modified: trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj (231587 => 231588)
--- trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj 2018-05-09 19:56:35 UTC (rev 231587)
+++ trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj 2018-05-09 19:59:46 UTC (rev 231588)
@@ -1072,6 +1072,7 @@
4161E2D51FE48DC500EC2E96 /* FetchLoader.h in Headers */ = {isa = PBXBuildFile; fileRef = 4147E2B51C89912600A7E715 /* FetchLoader.h */; settings = {ATTRIBUTES = (Private, ); }; };
4162A451101145AE00DFF3ED /* DedicatedWorkerGlobalScope.h in Headers */ = {isa = PBXBuildFile; fileRef = 4162A44E101145AE00DFF3ED /* DedicatedWorkerGlobalScope.h */; };
4162A4581011464700DFF3ED /* JSDedicatedWorkerGlobalScope.h in Headers */ = {isa = PBXBuildFile; fileRef = 4162A4561011464700DFF3ED /* JSDedicatedWorkerGlobalScope.h */; };
+ 416E0B3A209BC3CB004A95D9 /* FetchIdentifier.h in Headers */ = {isa = PBXBuildFile; fileRef = 416E0B37209BC3C2004A95D9 /* FetchIdentifier.h */; settings = {ATTRIBUTES = (Private, ); }; };
416E29A6102FA962007FC14E /* WorkerReportingProxy.h in Headers */ = {isa = PBXBuildFile; fileRef = 416E29A5102FA962007FC14E /* WorkerReportingProxy.h */; };
416E6FE81BBD12DF000A3F64 /* ReadableStreamInternalsBuiltins.h in Headers */ = {isa = PBXBuildFile; fileRef = 9B03D8061BB3110D00B764D9 /* ReadableStreamInternalsBuiltins.h */; settings = {ATTRIBUTES = (Private, ); }; };
416E6FE81BBD12DF000A3F65 /* JSDOMBindingInternalsBuiltins.h in Headers */ = {isa = PBXBuildFile; fileRef = 9B03D8061BB3110D00B764DA /* JSDOMBindingInternalsBuiltins.h */; settings = {ATTRIBUTES = (Private, ); }; };
@@ -7200,6 +7201,7 @@
4162A44F101145AE00DFF3ED /* DedicatedWorkerGlobalScope.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = DedicatedWorkerGlobalScope.idl; sourceTree = "<group>"; };
4162A4551011464700DFF3ED /* JSDedicatedWorkerGlobalScope.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSDedicatedWorkerGlobalScope.cpp; sourceTree = "<group>"; };
4162A4561011464700DFF3ED /* JSDedicatedWorkerGlobalScope.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSDedicatedWorkerGlobalScope.h; sourceTree = "<group>"; };
+ 416E0B37209BC3C2004A95D9 /* FetchIdentifier.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FetchIdentifier.h; sourceTree = "<group>"; };
416E29A5102FA962007FC14E /* WorkerReportingProxy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WorkerReportingProxy.h; sourceTree = "<group>"; };
4170A2E91D8C0CC000318452 /* JSDOMWrapper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSDOMWrapper.cpp; sourceTree = "<group>"; };
417253A81354BBBC00360F2A /* MediaControlElements.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MediaControlElements.cpp; sourceTree = "<group>"; };
@@ -16990,6 +16992,7 @@
41F54F821C50C4F600338488 /* FetchHeaders.cpp */,
41F54F831C50C4F600338488 /* FetchHeaders.h */,
41F54F841C50C4F600338488 /* FetchHeaders.idl */,
+ 416E0B37209BC3C2004A95D9 /* FetchIdentifier.h */,
4147E2B41C89912600A7E715 /* FetchLoader.cpp */,
4147E2B51C89912600A7E715 /* FetchLoader.h */,
4147E2B61C89912600A7E715 /* FetchLoaderClient.h */,
@@ -27759,6 +27762,7 @@
517A535B1F588A4C00DCDC0A /* FetchBodyConsumer.h in Headers */,
4129C9971F59B963009D7403 /* FetchBodySource.h in Headers */,
41D129DB1F3D143800D15E47 /* FetchHeaders.h in Headers */,
+ 416E0B3A209BC3CB004A95D9 /* FetchIdentifier.h in Headers */,
CEBB8C3320786DCB00039547 /* FetchIdioms.h in Headers */,
4161E2D51FE48DC500EC2E96 /* FetchLoader.h in Headers */,
517A53581F5889E800DCDC0A /* FetchLoaderClient.h in Headers */,
Modified: trunk/Source/WebCore/workers/service/context/ServiceWorkerFetch.h (231587 => 231588)
--- trunk/Source/WebCore/workers/service/context/ServiceWorkerFetch.h 2018-05-09 19:56:35 UTC (rev 231587)
+++ trunk/Source/WebCore/workers/service/context/ServiceWorkerFetch.h 2018-05-09 19:59:46 UTC (rev 231588)
@@ -53,6 +53,7 @@
virtual void didFail() = 0;
virtual void didFinish() = 0;
virtual void didNotHandle() = 0;
+ virtual void cancel() = 0;
};
void dispatchFetchEvent(Ref<Client>&&, ServiceWorkerGlobalScope&, std::optional<ServiceWorkerClientIdentifier>, ResourceRequest&&, String&& referrer, FetchOptions&&);
Modified: trunk/Source/WebCore/workers/service/context/ServiceWorkerThreadProxy.cpp (231587 => 231588)
--- trunk/Source/WebCore/workers/service/context/ServiceWorkerThreadProxy.cpp 2018-05-09 19:56:35 UTC (rev 231587)
+++ trunk/Source/WebCore/workers/service/context/ServiceWorkerThreadProxy.cpp 2018-05-09 19:59:46 UTC (rev 231588)
@@ -185,6 +185,26 @@
}, WorkerRunLoop::defaultMode());
}
+void ServiceWorkerThreadProxy::startFetch(SWServerConnectionIdentifier connectionIdentifier, FetchIdentifier fetchIdentifier, Ref<ServiceWorkerFetch::Client>&& client, std::optional<ServiceWorkerClientIdentifier>&& clientId, ResourceRequest&& request, String&& referrer, FetchOptions&& options)
+{
+ auto key = std::make_pair(connectionIdentifier, fetchIdentifier);
+
+ ASSERT(!m_ongoingFetchTasks.contains(key));
+ m_ongoingFetchTasks.add(key, client.copyRef());
+ thread().postFetchTask(WTFMove(client), WTFMove(clientId), WTFMove(request), WTFMove(referrer), WTFMove(options));
+}
+
+void ServiceWorkerThreadProxy::cancelFetch(SWServerConnectionIdentifier connectionIdentifier, FetchIdentifier fetchIdentifier)
+{
+ if (auto client = m_ongoingFetchTasks.take(std::make_pair(connectionIdentifier, fetchIdentifier)))
+ client.value()->cancel();
+}
+
+void ServiceWorkerThreadProxy::removeFetch(SWServerConnectionIdentifier connectionIdentifier, FetchIdentifier fetchIdentifier)
+{
+ m_ongoingFetchTasks.remove(std::make_pair(connectionIdentifier, fetchIdentifier));
+}
+
} // namespace WebCore
#endif // ENABLE(SERVICE_WORKER)
Modified: trunk/Source/WebCore/workers/service/context/ServiceWorkerThreadProxy.h (231587 => 231588)
--- trunk/Source/WebCore/workers/service/context/ServiceWorkerThreadProxy.h 2018-05-09 19:56:35 UTC (rev 231587)
+++ trunk/Source/WebCore/workers/service/context/ServiceWorkerThreadProxy.h 2018-05-09 19:59:46 UTC (rev 231588)
@@ -29,6 +29,7 @@
#include "CacheStorageConnection.h"
#include "Document.h"
+#include "FetchIdentifier.h"
#include "Page.h"
#include "SecurityOrigin.h"
#include "ServiceWorkerDebuggable.h"
@@ -70,6 +71,10 @@
// Public only for testing purposes.
WEBCORE_TESTSUPPORT_EXPORT void notifyNetworkStateChange(bool isOnline);
+ WEBCORE_EXPORT void startFetch(SWServerConnectionIdentifier, FetchIdentifier, Ref<ServiceWorkerFetch::Client>&&, std::optional<ServiceWorkerClientIdentifier>&&, ResourceRequest&&, String&& referrer, FetchOptions&&);
+ WEBCORE_EXPORT void cancelFetch(SWServerConnectionIdentifier, FetchIdentifier);
+ WEBCORE_EXPORT void removeFetch(SWServerConnectionIdentifier, FetchIdentifier);
+
private:
WEBCORE_EXPORT ServiceWorkerThreadProxy(PageConfiguration&&, const ServiceWorkerContextData&, PAL::SessionID, String&& userAgent, CacheStorageProvider&, SecurityOrigin::StorageBlockingPolicy);
@@ -96,6 +101,7 @@
#if ENABLE(REMOTE_INSPECTOR)
std::unique_ptr<ServiceWorkerDebuggable> m_remoteDebuggable;
#endif
+ HashMap<std::pair<SWServerConnectionIdentifier, FetchIdentifier>, Ref<ServiceWorkerFetch::Client>> m_ongoingFetchTasks;
};
} // namespace WebKit
Modified: trunk/Source/WebKit/ChangeLog (231587 => 231588)
--- trunk/Source/WebKit/ChangeLog 2018-05-09 19:56:35 UTC (rev 231587)
+++ trunk/Source/WebKit/ChangeLog 2018-05-09 19:59:46 UTC (rev 231588)
@@ -1,3 +1,65 @@
+2018-05-09 Youenn Fablet <[email protected]>
+
+ Allow WebResourceLoader to cancel a load served from a service worker
+ https://bugs.webkit.org/show_bug.cgi?id=185274
+
+ Reviewed by Chris Dumez.
+
+ Use FetchIdentifier instead of uint64_t.
+ Add IPC support for cancelling a fetch from WebProcess to service worker process.
+ Ask service worker process to cancel the fetch when its corresponding WebResourceLoader is cancelled.
+ No change of behavior as once a WebResourceLoader is cancelled, any related IPC is not processed.
+ A follow-up patch should try to cancel the FetchResponse load, meaning to either cancel the network load
+ or to abort reading the readable stream.
+
+ * Scripts/webkit/messages.py:
+ * StorageProcess/ServiceWorker/WebSWServerConnection.cpp:
+ (WebKit::WebSWServerConnection::cancelFetch):
+ (WebKit::WebSWServerConnection::startFetch):
+ (WebKit::WebSWServerConnection::didReceiveFetchResponse):
+ (WebKit::WebSWServerConnection::didReceiveFetchData):
+ (WebKit::WebSWServerConnection::didReceiveFetchFormData):
+ (WebKit::WebSWServerConnection::didFinishFetch):
+ (WebKit::WebSWServerConnection::didFailFetch):
+ (WebKit::WebSWServerConnection::didNotHandleFetch):
+ * StorageProcess/ServiceWorker/WebSWServerConnection.h:
+ * StorageProcess/ServiceWorker/WebSWServerConnection.messages.in:
+ * StorageProcess/StorageProcess.cpp:
+ (WebKit::StorageProcess::didFailFetch):
+ (WebKit::StorageProcess::didNotHandleFetch):
+ (WebKit::StorageProcess::didReceiveFetchResponse):
+ (WebKit::StorageProcess::didReceiveFetchData):
+ (WebKit::StorageProcess::didReceiveFetchFormData):
+ (WebKit::StorageProcess::didFinishFetch):
+ * StorageProcess/StorageProcess.h:
+ * StorageProcess/StorageProcess.messages.in:
+ * WebProcess/Network/WebLoaderStrategy.cpp:
+ (WebKit::WebLoaderStrategy::remove):
+ * WebProcess/Storage/ServiceWorkerClientFetch.cpp:
+ (WebKit::ServiceWorkerClientFetch::create):
+ (WebKit::ServiceWorkerClientFetch::ServiceWorkerClientFetch):
+ (WebKit::ServiceWorkerClientFetch::start):
+ (WebKit::ServiceWorkerClientFetch::cancel):
+ * WebProcess/Storage/ServiceWorkerClientFetch.h:
+ * WebProcess/Storage/WebSWClientConnection.cpp:
+ (WebKit::WebSWClientConnection::startFetch):
+ (WebKit::WebSWClientConnection::cancelFetch):
+ * WebProcess/Storage/WebSWClientConnection.h:
+ * WebProcess/Storage/WebSWContextManagerConnection.cpp:
+ (WebKit::WebSWContextManagerConnection::cancelFetch):
+ (WebKit::WebSWContextManagerConnection::startFetch):
+ * WebProcess/Storage/WebSWContextManagerConnection.h:
+ * WebProcess/Storage/WebSWContextManagerConnection.messages.in:
+ * WebProcess/Storage/WebServiceWorkerFetchTaskClient.cpp:
+ (WebKit::WebServiceWorkerFetchTaskClient::WebServiceWorkerFetchTaskClient):
+ (WebKit::WebServiceWorkerFetchTaskClient::cancel):
+ * WebProcess/Storage/WebServiceWorkerFetchTaskClient.h:
+ * WebProcess/Storage/WebServiceWorkerProvider.cpp:
+ (WebKit::WebServiceWorkerProvider::handleFetch):
+ (WebKit::WebServiceWorkerProvider::cancelFetch):
+ (WebKit::WebServiceWorkerProvider::fetchFinished):
+ * WebProcess/Storage/WebServiceWorkerProvider.h:
+
2018-05-09 Andy Estes <[email protected]>
[iOS] Consider the annotation bounds when positioning action sheets near long-pressed PDF links
Modified: trunk/Source/WebKit/Scripts/webkit/messages.py (231587 => 231588)
--- trunk/Source/WebKit/Scripts/webkit/messages.py 2018-05-09 19:56:35 UTC (rev 231587)
+++ trunk/Source/WebKit/Scripts/webkit/messages.py 2018-05-09 19:59:46 UTC (rev 231588)
@@ -191,6 +191,7 @@
'MessageSource',
'String',
'WebCore::DocumentIdentifier',
+ 'WebCore::FetchIdentifier',
'WebCore::ServiceWorkerIdentifier',
'WebCore::ServiceWorkerJobIdentifier',
'WebCore::ServiceWorkerOrClientData',
Modified: trunk/Source/WebKit/StorageProcess/ServiceWorker/WebSWServerConnection.cpp (231587 => 231588)
--- trunk/Source/WebKit/StorageProcess/ServiceWorker/WebSWServerConnection.cpp 2018-05-09 19:56:35 UTC (rev 231587)
+++ trunk/Source/WebKit/StorageProcess/ServiceWorker/WebSWServerConnection.cpp 2018-05-09 19:59:46 UTC (rev 231588)
@@ -131,12 +131,25 @@
send(Messages::WebSWClientConnection::UpdateWorkerState(worker, state));
}
-void WebSWServerConnection::startFetch(uint64_t fetchIdentifier, ServiceWorkerRegistrationIdentifier serviceWorkerRegistrationIdentifier, ResourceRequest&& request, FetchOptions&& options, IPC::FormDataReference&& formData, String&& referrer)
+void WebSWServerConnection::cancelFetch(ServiceWorkerRegistrationIdentifier serviceWorkerRegistrationIdentifier, FetchIdentifier fetchIdentifier)
{
auto* worker = server().activeWorkerFromRegistrationID(serviceWorkerRegistrationIdentifier);
+ if (!worker || !worker->isRunning())
+ return;
+
+ auto serviceWorkerIdentifier = worker->identifier();
+ server().runServiceWorkerIfNecessary(serviceWorkerIdentifier, [weakThis = makeWeakPtr(this), this, serviceWorkerIdentifier, fetchIdentifier](auto* contextConnection) mutable {
+ if (weakThis && contextConnection)
+ sendToContextProcess(*contextConnection, Messages::WebSWContextManagerConnection::CancelFetch { this->identifier(), serviceWorkerIdentifier, fetchIdentifier });
+ });
+}
+
+void WebSWServerConnection::startFetch(ServiceWorkerRegistrationIdentifier serviceWorkerRegistrationIdentifier, FetchIdentifier fetchIdentifier, ResourceRequest&& request, FetchOptions&& options, IPC::FormDataReference&& formData, String&& referrer)
+{
+ auto* worker = server().activeWorkerFromRegistrationID(serviceWorkerRegistrationIdentifier);
if (!worker) {
- SWSERVERCONNECTION_RELEASE_LOG_ERROR_IF_ALLOWED("startFetch: fetchIdentifier: %" PRIu64 " -> DidNotHandle because no active worker", fetchIdentifier);
- m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidNotHandle { }, fetchIdentifier);
+ SWSERVERCONNECTION_RELEASE_LOG_ERROR_IF_ALLOWED("startFetch: fetchIdentifier: %s -> DidNotHandle because no active worker", fetchIdentifier.loggingString().utf8().data());
+ m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidNotHandle { }, fetchIdentifier.toUInt64());
return;
}
auto serviceWorkerIdentifier = worker->identifier();
@@ -146,14 +159,14 @@
return;
if (!success) {
- SWSERVERCONNECTION_RELEASE_LOG_ERROR_IF_ALLOWED("startFetch: fetchIdentifier: %" PRIu64 " -> DidNotHandle because worker did not become activated", fetchIdentifier);
- m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidNotHandle { }, fetchIdentifier);
+ SWSERVERCONNECTION_RELEASE_LOG_ERROR_IF_ALLOWED("startFetch: fetchIdentifier: %s DidNotHandle because worker did not become activated", fetchIdentifier.loggingString().utf8().data());
+ m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidNotHandle { }, fetchIdentifier.toUInt64());
return;
}
auto* worker = server().workerByID(serviceWorkerIdentifier);
if (!worker) {
- m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidNotHandle { }, fetchIdentifier);
+ m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidNotHandle { }, fetchIdentifier.toUInt64());
return;
}
@@ -165,11 +178,11 @@
return;
if (contextConnection) {
- SWSERVERCONNECTION_RELEASE_LOG_IF_ALLOWED("startFetch: Starting fetch %" PRIu64 " via service worker %" PRIu64, fetchIdentifier, serviceWorkerIdentifier.toUInt64());
- sendToContextProcess(*contextConnection, Messages::WebSWContextManagerConnection::StartFetch { this->identifier(), fetchIdentifier, serviceWorkerIdentifier, request, options, formData, referrer });
+ SWSERVERCONNECTION_RELEASE_LOG_IF_ALLOWED("startFetch: Starting fetch %s via service worker %s", fetchIdentifier.loggingString().utf8().data(), serviceWorkerIdentifier.loggingString().utf8().data());
+ sendToContextProcess(*contextConnection, Messages::WebSWContextManagerConnection::StartFetch { this->identifier(), serviceWorkerIdentifier, fetchIdentifier, request, options, formData, referrer });
} else {
- SWSERVERCONNECTION_RELEASE_LOG_ERROR_IF_ALLOWED("startFetch: fetchIdentifier: %" PRIu64 " -> DidNotHandle because failed to run service worker", fetchIdentifier);
- m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidNotHandle { }, fetchIdentifier);
+ SWSERVERCONNECTION_RELEASE_LOG_ERROR_IF_ALLOWED("startFetch: fetchIdentifier: %s DidNotHandle because failed to run service worker", fetchIdentifier.loggingString().utf8().data());
+ m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidNotHandle { }, fetchIdentifier.toUInt64());
}
});
};
@@ -222,38 +235,37 @@
server().scheduleJob(WTFMove(jobData));
}
-
-void WebSWServerConnection::didReceiveFetchResponse(uint64_t fetchIdentifier, const ResourceResponse& response)
+void WebSWServerConnection::didReceiveFetchResponse(FetchIdentifier fetchIdentifier, const ResourceResponse& response)
{
- m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidReceiveResponse { response }, fetchIdentifier);
+ m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidReceiveResponse { response }, fetchIdentifier.toUInt64());
}
-void WebSWServerConnection::didReceiveFetchData(uint64_t fetchIdentifier, const IPC::DataReference& data, int64_t encodedDataLength)
+void WebSWServerConnection::didReceiveFetchData(FetchIdentifier fetchIdentifier, const IPC::DataReference& data, int64_t encodedDataLength)
{
- m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidReceiveData { data, encodedDataLength }, fetchIdentifier);
+ m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidReceiveData { data, encodedDataLength }, fetchIdentifier.toUInt64());
}
-void WebSWServerConnection::didReceiveFetchFormData(uint64_t fetchIdentifier, const IPC::FormDataReference& formData)
+void WebSWServerConnection::didReceiveFetchFormData(FetchIdentifier fetchIdentifier, const IPC::FormDataReference& formData)
{
- m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidReceiveFormData { formData }, fetchIdentifier);
+ m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidReceiveFormData { formData }, fetchIdentifier.toUInt64());
}
-void WebSWServerConnection::didFinishFetch(uint64_t fetchIdentifier)
+void WebSWServerConnection::didFinishFetch(FetchIdentifier fetchIdentifier)
{
- SWSERVERCONNECTION_RELEASE_LOG_IF_ALLOWED("didFinishFetch: fetchIdentifier: %" PRIu64, fetchIdentifier);
- m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidFinish { }, fetchIdentifier);
+ SWSERVERCONNECTION_RELEASE_LOG_IF_ALLOWED("didFinishFetch: fetchIdentifier: %s", fetchIdentifier.loggingString().utf8().data());
+ m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidFinish { }, fetchIdentifier.toUInt64());
}
-void WebSWServerConnection::didFailFetch(uint64_t fetchIdentifier)
+void WebSWServerConnection::didFailFetch(FetchIdentifier fetchIdentifier)
{
- SWSERVERCONNECTION_RELEASE_LOG_ERROR_IF_ALLOWED("didFailFetch: fetchIdentifier: %" PRIu64, fetchIdentifier);
- m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidFail { }, fetchIdentifier);
+ SWSERVERCONNECTION_RELEASE_LOG_ERROR_IF_ALLOWED("didFailFetch: fetchIdentifier: %s", fetchIdentifier.loggingString().utf8().data());
+ m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidFail { }, fetchIdentifier.toUInt64());
}
-void WebSWServerConnection::didNotHandleFetch(uint64_t fetchIdentifier)
+void WebSWServerConnection::didNotHandleFetch(FetchIdentifier fetchIdentifier)
{
- SWSERVERCONNECTION_RELEASE_LOG_IF_ALLOWED("didNotHandleFetch: fetchIdentifier: %" PRIu64, fetchIdentifier);
- m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidNotHandle { }, fetchIdentifier);
+ SWSERVERCONNECTION_RELEASE_LOG_IF_ALLOWED("didNotHandleFetch: fetchIdentifier: %s", fetchIdentifier.loggingString().utf8().data());
+ m_contentConnection->send(Messages::ServiceWorkerClientFetch::DidNotHandle { }, fetchIdentifier.toUInt64());
}
void WebSWServerConnection::postMessageToServiceWorkerClient(DocumentIdentifier destinationContextIdentifier, MessageWithMessagePorts&& message, ServiceWorkerIdentifier sourceIdentifier, const String& sourceOrigin)
Modified: trunk/Source/WebKit/StorageProcess/ServiceWorker/WebSWServerConnection.h (231587 => 231588)
--- trunk/Source/WebKit/StorageProcess/ServiceWorker/WebSWServerConnection.h 2018-05-09 19:56:35 UTC (rev 231587)
+++ trunk/Source/WebKit/StorageProcess/ServiceWorker/WebSWServerConnection.h 2018-05-09 19:59:46 UTC (rev 231588)
@@ -29,6 +29,7 @@
#include "MessageReceiver.h"
#include "MessageSender.h"
+#include <WebCore/FetchIdentifier.h>
#include <WebCore/SWServer.h>
#include <pal/SessionID.h>
#include <wtf/HashMap.h>
@@ -61,12 +62,12 @@
PAL::SessionID sessionID() const { return m_sessionID; }
- void didReceiveFetchResponse(uint64_t fetchIdentifier, const WebCore::ResourceResponse&);
- void didReceiveFetchData(uint64_t fetchIdentifier, const IPC::DataReference&, int64_t encodedDataLength);
- void didReceiveFetchFormData(uint64_t fetchIdentifier, const IPC::FormDataReference&);
- void didFinishFetch(uint64_t fetchIdentifier);
- void didFailFetch(uint64_t fetchIdentifier);
- void didNotHandleFetch(uint64_t fetchIdentifier);
+ void didReceiveFetchResponse(WebCore::FetchIdentifier, const WebCore::ResourceResponse&);
+ void didReceiveFetchData(WebCore::FetchIdentifier, const IPC::DataReference&, int64_t encodedDataLength);
+ void didReceiveFetchFormData(WebCore::FetchIdentifier, const IPC::FormDataReference&);
+ void didFinishFetch(WebCore::FetchIdentifier);
+ void didFailFetch(WebCore::FetchIdentifier);
+ void didNotHandleFetch(WebCore::FetchIdentifier);
void postMessageToServiceWorkerClient(WebCore::DocumentIdentifier destinationContextIdentifier, WebCore::MessageWithMessagePorts&&, WebCore::ServiceWorkerIdentifier sourceServiceWorkerIdentifier, const String& sourceOrigin);
void postMessageToServiceWorker(WebCore::ServiceWorkerIdentifier destination, WebCore::MessageWithMessagePorts&&, const WebCore::ServiceWorkerOrClientIdentifier& source);
@@ -87,7 +88,8 @@
void scheduleJobInServer(WebCore::ServiceWorkerJobData&&);
- void startFetch(uint64_t fetchIdentifier, WebCore::ServiceWorkerRegistrationIdentifier, WebCore::ResourceRequest&&, WebCore::FetchOptions&&, IPC::FormDataReference&&, String&& referrer);
+ void startFetch(WebCore::ServiceWorkerRegistrationIdentifier, WebCore::FetchIdentifier, WebCore::ResourceRequest&&, WebCore::FetchOptions&&, IPC::FormDataReference&&, String&& referrer);
+ void cancelFetch(WebCore::ServiceWorkerRegistrationIdentifier, WebCore::FetchIdentifier);
void matchRegistration(uint64_t registrationMatchRequestIdentifier, const WebCore::SecurityOriginData& topOrigin, const WebCore::URL& clientURL);
void getRegistrations(uint64_t registrationMatchRequestIdentifier, const WebCore::SecurityOriginData& topOrigin, const WebCore::URL& clientURL);
Modified: trunk/Source/WebKit/StorageProcess/ServiceWorker/WebSWServerConnection.messages.in (231587 => 231588)
--- trunk/Source/WebKit/StorageProcess/ServiceWorker/WebSWServerConnection.messages.in 2018-05-09 19:56:35 UTC (rev 231587)
+++ trunk/Source/WebKit/StorageProcess/ServiceWorker/WebSWServerConnection.messages.in 2018-05-09 19:59:46 UTC (rev 231588)
@@ -29,7 +29,8 @@
AddServiceWorkerRegistrationInServer(WebCore::ServiceWorkerRegistrationIdentifier identifier)
RemoveServiceWorkerRegistrationInServer(WebCore::ServiceWorkerRegistrationIdentifier identifier)
- StartFetch(uint64_t identifier, WebCore::ServiceWorkerRegistrationIdentifier serviceWorkerRegistrationIdentifier, WebCore::ResourceRequest request, struct WebCore::FetchOptions options, IPC::FormDataReference requestBody, String referrer)
+ StartFetch(WebCore::ServiceWorkerRegistrationIdentifier serviceWorkerRegistrationIdentifier, WebCore::FetchIdentifier fetchIdentifier, WebCore::ResourceRequest request, struct WebCore::FetchOptions options, IPC::FormDataReference requestBody, String referrer)
+ CancelFetch(WebCore::ServiceWorkerRegistrationIdentifier serviceWorkerRegistrationIdentifier, WebCore::FetchIdentifier fetchIdentifier)
PostMessageToServiceWorker(WebCore::ServiceWorkerIdentifier destination, struct WebCore::MessageWithMessagePorts message, WebCore::ServiceWorkerOrClientIdentifier source)
Modified: trunk/Source/WebKit/StorageProcess/StorageProcess.cpp (231587 => 231588)
--- trunk/Source/WebKit/StorageProcess/StorageProcess.cpp 2018-05-09 19:56:35 UTC (rev 231587)
+++ trunk/Source/WebKit/StorageProcess/StorageProcess.cpp 2018-05-09 19:59:46 UTC (rev 231588)
@@ -465,37 +465,37 @@
parentProcessConnection()->send(Messages::StorageProcessProxy::EstablishWorkerContextConnectionToStorageProcess(securityOrigin), 0);
}
-void StorageProcess::didFailFetch(SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier)
+void StorageProcess::didFailFetch(SWServerConnectionIdentifier serverConnectionIdentifier, FetchIdentifier fetchIdentifier)
{
if (auto* connection = m_swServerConnections.get(serverConnectionIdentifier))
connection->didFailFetch(fetchIdentifier);
}
-void StorageProcess::didNotHandleFetch(SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier)
+void StorageProcess::didNotHandleFetch(SWServerConnectionIdentifier serverConnectionIdentifier, FetchIdentifier fetchIdentifier)
{
if (auto* connection = m_swServerConnections.get(serverConnectionIdentifier))
connection->didNotHandleFetch(fetchIdentifier);
}
-void StorageProcess::didReceiveFetchResponse(SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier, const WebCore::ResourceResponse& response)
+void StorageProcess::didReceiveFetchResponse(SWServerConnectionIdentifier serverConnectionIdentifier, FetchIdentifier fetchIdentifier, const WebCore::ResourceResponse& response)
{
if (auto* connection = m_swServerConnections.get(serverConnectionIdentifier))
connection->didReceiveFetchResponse(fetchIdentifier, response);
}
-void StorageProcess::didReceiveFetchData(SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier, const IPC::DataReference& data, int64_t encodedDataLength)
+void StorageProcess::didReceiveFetchData(SWServerConnectionIdentifier serverConnectionIdentifier, FetchIdentifier fetchIdentifier, const IPC::DataReference& data, int64_t encodedDataLength)
{
if (auto* connection = m_swServerConnections.get(serverConnectionIdentifier))
connection->didReceiveFetchData(fetchIdentifier, data, encodedDataLength);
}
-void StorageProcess::didReceiveFetchFormData(SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier, const IPC::FormDataReference& formData)
+void StorageProcess::didReceiveFetchFormData(SWServerConnectionIdentifier serverConnectionIdentifier, FetchIdentifier fetchIdentifier, const IPC::FormDataReference& formData)
{
if (auto* connection = m_swServerConnections.get(serverConnectionIdentifier))
connection->didReceiveFetchFormData(fetchIdentifier, formData);
}
-void StorageProcess::didFinishFetch(SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier)
+void StorageProcess::didFinishFetch(SWServerConnectionIdentifier serverConnectionIdentifier, FetchIdentifier fetchIdentifier)
{
if (auto* connection = m_swServerConnections.get(serverConnectionIdentifier))
connection->didFinishFetch(fetchIdentifier);
Modified: trunk/Source/WebKit/StorageProcess/StorageProcess.h (231587 => 231588)
--- trunk/Source/WebKit/StorageProcess/StorageProcess.h 2018-05-09 19:56:35 UTC (rev 231587)
+++ trunk/Source/WebKit/StorageProcess/StorageProcess.h 2018-05-09 19:59:46 UTC (rev 231588)
@@ -27,6 +27,7 @@
#include "ChildProcess.h"
#include "SandboxExtension.h"
+#include <WebCore/FetchIdentifier.h>
#include <WebCore/IDBBackingStore.h>
#include <WebCore/IDBServer.h>
#include <WebCore/SecurityOriginData.h>
@@ -135,12 +136,12 @@
void didGetSandboxExtensionsForBlobFiles(uint64_t requestID, SandboxExtension::HandleArray&&);
#endif
#if ENABLE(SERVICE_WORKER)
- void didReceiveFetchResponse(WebCore::SWServerConnectionIdentifier, uint64_t fetchIdentifier, const WebCore::ResourceResponse&);
- void didReceiveFetchData(WebCore::SWServerConnectionIdentifier, uint64_t fetchIdentifier, const IPC::DataReference&, int64_t encodedDataLength);
- void didReceiveFetchFormData(WebCore::SWServerConnectionIdentifier, uint64_t fetchIdentifier, const IPC::FormDataReference&);
- void didFinishFetch(WebCore::SWServerConnectionIdentifier, uint64_t fetchIdentifier);
- void didFailFetch(WebCore::SWServerConnectionIdentifier, uint64_t fetchIdentifier);
- void didNotHandleFetch(WebCore::SWServerConnectionIdentifier, uint64_t fetchIdentifier);
+ void didReceiveFetchResponse(WebCore::SWServerConnectionIdentifier, WebCore::FetchIdentifier, const WebCore::ResourceResponse&);
+ void didReceiveFetchData(WebCore::SWServerConnectionIdentifier, WebCore::FetchIdentifier, const IPC::DataReference&, int64_t encodedDataLength);
+ void didReceiveFetchFormData(WebCore::SWServerConnectionIdentifier, WebCore::FetchIdentifier, const IPC::FormDataReference&);
+ void didFinishFetch(WebCore::SWServerConnectionIdentifier, WebCore::FetchIdentifier);
+ void didFailFetch(WebCore::SWServerConnectionIdentifier, WebCore::FetchIdentifier);
+ void didNotHandleFetch(WebCore::SWServerConnectionIdentifier, WebCore::FetchIdentifier);
void postMessageToServiceWorkerClient(const WebCore::ServiceWorkerClientIdentifier& destinationIdentifier, WebCore::MessageWithMessagePorts&&, WebCore::ServiceWorkerIdentifier sourceIdentifier, const String& sourceOrigin);
void postMessageToServiceWorker(WebCore::ServiceWorkerIdentifier destination, WebCore::MessageWithMessagePorts&&, const WebCore::ServiceWorkerOrClientIdentifier& source, WebCore::SWServerConnectionIdentifier);
Modified: trunk/Source/WebKit/StorageProcess/StorageProcess.messages.in (231587 => 231588)
--- trunk/Source/WebKit/StorageProcess/StorageProcess.messages.in 2018-05-09 19:56:35 UTC (rev 231587)
+++ trunk/Source/WebKit/StorageProcess/StorageProcess.messages.in 2018-05-09 19:59:46 UTC (rev 231588)
@@ -36,12 +36,12 @@
#endif
#if ENABLE(SERVICE_WORKER)
- DidNotHandleFetch(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier)
- DidFailFetch(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier)
- DidReceiveFetchResponse(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier, WebCore::ResourceResponse response)
- DidReceiveFetchData(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier, IPC::DataReference data, int64_t encodedDataLength)
- DidReceiveFetchFormData(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier, IPC::FormDataReference data)
- DidFinishFetch(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier)
+ DidNotHandleFetch(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, WebCore::FetchIdentifier fetchIdentifier)
+ DidFailFetch(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, WebCore::FetchIdentifier fetchIdentifier)
+ DidReceiveFetchResponse(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, WebCore::FetchIdentifier fetchIdentifier, WebCore::ResourceResponse response)
+ DidReceiveFetchData(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, WebCore::FetchIdentifier fetchIdentifier, IPC::DataReference data, int64_t encodedDataLength)
+ DidReceiveFetchFormData(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, WebCore::FetchIdentifier fetchIdentifier, IPC::FormDataReference data)
+ DidFinishFetch(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, WebCore::FetchIdentifier fetchIdentifier)
PostMessageToServiceWorkerClient(struct WebCore::ServiceWorkerClientIdentifier destinationIdentifier, struct WebCore::MessageWithMessagePorts message, WebCore::ServiceWorkerIdentifier sourceIdentifier, String sourceOrigin)
PostMessageToServiceWorker(WebCore::ServiceWorkerIdentifier destination, struct WebCore::MessageWithMessagePorts message, WebCore::ServiceWorkerOrClientIdentifier source, WebCore::SWServerConnectionIdentifier connectionIdentifier)
Modified: trunk/Source/WebKit/WebProcess/Network/WebLoaderStrategy.cpp (231587 => 231588)
--- trunk/Source/WebKit/WebProcess/Network/WebLoaderStrategy.cpp 2018-05-09 19:56:35 UTC (rev 231587)
+++ trunk/Source/WebKit/WebProcess/Network/WebLoaderStrategy.cpp 2018-05-09 19:59:46 UTC (rev 231588)
@@ -399,7 +399,7 @@
}
#if ENABLE(SERVICE_WORKER)
- if (WebServiceWorkerProvider::singleton().cancelFetch(identifier))
+ if (WebServiceWorkerProvider::singleton().cancelFetch(makeObjectIdentifier<FetchIdentifierType>(identifier)))
return;
#endif
Modified: trunk/Source/WebKit/WebProcess/Storage/ServiceWorkerClientFetch.cpp (231587 => 231588)
--- trunk/Source/WebKit/WebProcess/Storage/ServiceWorkerClientFetch.cpp 2018-05-09 19:56:35 UTC (rev 231587)
+++ trunk/Source/WebKit/WebProcess/Storage/ServiceWorkerClientFetch.cpp 2018-05-09 19:59:46 UTC (rev 231588)
@@ -40,7 +40,7 @@
namespace WebKit {
-Ref<ServiceWorkerClientFetch> ServiceWorkerClientFetch::create(WebServiceWorkerProvider& serviceWorkerProvider, Ref<WebCore::ResourceLoader>&& loader, uint64_t identifier, Ref<WebSWClientConnection>&& connection, bool shouldClearReferrerOnHTTPSToHTTPRedirect, Callback&& callback)
+Ref<ServiceWorkerClientFetch> ServiceWorkerClientFetch::create(WebServiceWorkerProvider& serviceWorkerProvider, Ref<WebCore::ResourceLoader>&& loader, FetchIdentifier identifier, Ref<WebSWClientConnection>&& connection, bool shouldClearReferrerOnHTTPSToHTTPRedirect, Callback&& callback)
{
auto fetch = adoptRef(*new ServiceWorkerClientFetch { serviceWorkerProvider, WTFMove(loader), identifier, WTFMove(connection), shouldClearReferrerOnHTTPSToHTTPRedirect, WTFMove(callback) });
fetch->start();
@@ -51,7 +51,7 @@
{
}
-ServiceWorkerClientFetch::ServiceWorkerClientFetch(WebServiceWorkerProvider& serviceWorkerProvider, Ref<WebCore::ResourceLoader>&& loader, uint64_t identifier, Ref<WebSWClientConnection>&& connection, bool shouldClearReferrerOnHTTPSToHTTPRedirect, Callback&& callback)
+ServiceWorkerClientFetch::ServiceWorkerClientFetch(WebServiceWorkerProvider& serviceWorkerProvider, Ref<WebCore::ResourceLoader>&& loader, FetchIdentifier identifier, Ref<WebSWClientConnection>&& connection, bool shouldClearReferrerOnHTTPSToHTTPRedirect, Callback&& callback)
: m_serviceWorkerProvider(serviceWorkerProvider)
, m_loader(WTFMove(loader))
, m_identifier(identifier)
@@ -75,7 +75,8 @@
cleanHTTPRequestHeadersForAccessControl(request, options.httpHeadersToKeep);
ASSERT(options.serviceWorkersMode != ServiceWorkersMode::None);
- m_connection->startFetch(m_loader->identifier(), options.serviceWorkerRegistrationIdentifier.value(), request, options, referrer);
+ m_serviceWorkerRegistrationIdentifier = options.serviceWorkerRegistrationIdentifier.value();
+ m_connection->startFetch(m_identifier, m_serviceWorkerRegistrationIdentifier, request, options, referrer);
m_redirectionStatus = RedirectionStatus::None;
}
@@ -259,6 +260,11 @@
{
if (auto callback = WTFMove(m_callback))
callback(Result::Cancelled);
+
+ if (!m_didFinish && !m_didFail) {
+ m_connection->cancelFetch(m_identifier, m_serviceWorkerRegistrationIdentifier);
+
+ }
m_loader = nullptr;
m_buffer = nullptr;
}
Modified: trunk/Source/WebKit/WebProcess/Storage/ServiceWorkerClientFetch.h (231587 => 231588)
--- trunk/Source/WebKit/WebProcess/Storage/ServiceWorkerClientFetch.h 2018-05-09 19:56:35 UTC (rev 231587)
+++ trunk/Source/WebKit/WebProcess/Storage/ServiceWorkerClientFetch.h 2018-05-09 19:59:46 UTC (rev 231588)
@@ -31,6 +31,7 @@
#include "FormDataReference.h"
#include "MessageReceiver.h"
#include "MessageSender.h"
+#include <WebCore/FetchIdentifier.h>
#include <WebCore/ResourceLoader.h>
#include <wtf/CompletionHandler.h>
@@ -44,7 +45,7 @@
enum class Result { Succeeded, Cancelled, Unhandled };
using Callback = WTF::CompletionHandler<void(Result)>;
- static Ref<ServiceWorkerClientFetch> create(WebServiceWorkerProvider&, Ref<WebCore::ResourceLoader>&&, uint64_t identifier, Ref<WebSWClientConnection>&&, bool shouldClearReferrerOnHTTPSToHTTPRedirect, Callback&&);
+ static Ref<ServiceWorkerClientFetch> create(WebServiceWorkerProvider&, Ref<WebCore::ResourceLoader>&&, WebCore::FetchIdentifier, Ref<WebSWClientConnection>&&, bool shouldClearReferrerOnHTTPSToHTTPRedirect, Callback&&);
~ServiceWorkerClientFetch();
void start();
@@ -55,7 +56,7 @@
bool isOngoing() const { return !!m_callback; }
private:
- ServiceWorkerClientFetch(WebServiceWorkerProvider&, Ref<WebCore::ResourceLoader>&&, uint64_t identifier, Ref<WebSWClientConnection>&&, bool shouldClearReferrerOnHTTPSToHTTPRedirect, Callback&&);
+ ServiceWorkerClientFetch(WebServiceWorkerProvider&, Ref<WebCore::ResourceLoader>&&, WebCore::FetchIdentifier, Ref<WebSWClientConnection>&&, bool shouldClearReferrerOnHTTPSToHTTPRedirect, Callback&&);
std::optional<WebCore::ResourceError> validateResponse(const WebCore::ResourceResponse&);
@@ -70,7 +71,7 @@
WebServiceWorkerProvider& m_serviceWorkerProvider;
RefPtr<WebCore::ResourceLoader> m_loader;
- uint64_t m_identifier { 0 };
+ WebCore::FetchIdentifier m_identifier;
Ref<WebSWClientConnection> m_connection;
Callback m_callback;
enum class RedirectionStatus { None, Receiving, Following, Received };
@@ -81,6 +82,8 @@
bool m_isCheckingResponse { false };
bool m_didFinish { false };
bool m_didFail { false };
+
+ WebCore::ServiceWorkerRegistrationIdentifier m_serviceWorkerRegistrationIdentifier;
};
} // namespace WebKit
Modified: trunk/Source/WebKit/WebProcess/Storage/WebSWClientConnection.cpp (231587 => 231588)
--- trunk/Source/WebKit/WebProcess/Storage/WebSWClientConnection.cpp 2018-05-09 19:56:35 UTC (rev 231587)
+++ trunk/Source/WebKit/WebProcess/Storage/WebSWClientConnection.cpp 2018-05-09 19:59:46 UTC (rev 231588)
@@ -199,11 +199,16 @@
});
}
-void WebSWClientConnection::startFetch(uint64_t fetchIdentifier, WebCore::ServiceWorkerRegistrationIdentifier serviceWorkerRegistrationIdentifier, const WebCore::ResourceRequest& request, const WebCore::FetchOptions& options, const String& referrer)
+void WebSWClientConnection::startFetch(WebCore::FetchIdentifier fetchIdentifier, WebCore::ServiceWorkerRegistrationIdentifier serviceWorkerRegistrationIdentifier, const WebCore::ResourceRequest& request, const WebCore::FetchOptions& options, const String& referrer)
{
- send(Messages::WebSWServerConnection::StartFetch { fetchIdentifier, serviceWorkerRegistrationIdentifier, request, options, IPC::FormDataReference { request.httpBody() }, referrer });
+ send(Messages::WebSWServerConnection::StartFetch { serviceWorkerRegistrationIdentifier, fetchIdentifier, request, options, IPC::FormDataReference { request.httpBody() }, referrer });
}
+void WebSWClientConnection::cancelFetch(WebCore::FetchIdentifier fetchIdentifier, WebCore::ServiceWorkerRegistrationIdentifier serviceWorkerRegistrationIdentifier)
+{
+ send(Messages::WebSWServerConnection::CancelFetch { serviceWorkerRegistrationIdentifier, fetchIdentifier });
+}
+
void WebSWClientConnection::postMessageToServiceWorkerClient(DocumentIdentifier destinationContextIdentifier, MessageWithMessagePorts&& message, ServiceWorkerData&& source, const String& sourceOrigin)
{
SWClientConnection::postMessageToServiceWorkerClient(destinationContextIdentifier, WTFMove(message), WTFMove(source), sourceOrigin);
Modified: trunk/Source/WebKit/WebProcess/Storage/WebSWClientConnection.h (231587 => 231588)
--- trunk/Source/WebKit/WebProcess/Storage/WebSWClientConnection.h 2018-05-09 19:56:35 UTC (rev 231587)
+++ trunk/Source/WebKit/WebProcess/Storage/WebSWClientConnection.h 2018-05-09 19:59:46 UTC (rev 231588)
@@ -61,7 +61,8 @@
void didReceiveMessage(IPC::Connection&, IPC::Decoder&) final;
bool mayHaveServiceWorkerRegisteredForOrigin(const WebCore::SecurityOriginData&) const final;
- void startFetch(uint64_t fetchIdentifier, WebCore::ServiceWorkerRegistrationIdentifier, const WebCore::ResourceRequest&, const WebCore::FetchOptions&, const String& referrer);
+ void startFetch(WebCore::FetchIdentifier, WebCore::ServiceWorkerRegistrationIdentifier, const WebCore::ResourceRequest&, const WebCore::FetchOptions&, const String& referrer);
+ void cancelFetch(WebCore::FetchIdentifier, WebCore::ServiceWorkerRegistrationIdentifier);
void postMessageToServiceWorkerClient(WebCore::DocumentIdentifier destinationContextIdentifier, WebCore::MessageWithMessagePorts&&, WebCore::ServiceWorkerData&& source, const String& sourceOrigin);
Modified: trunk/Source/WebKit/WebProcess/Storage/WebSWContextManagerConnection.cpp (231587 => 231588)
--- trunk/Source/WebKit/WebProcess/Storage/WebSWContextManagerConnection.cpp 2018-05-09 19:56:35 UTC (rev 231587)
+++ trunk/Source/WebKit/WebProcess/Storage/WebSWContextManagerConnection.cpp 2018-05-09 19:59:46 UTC (rev 231588)
@@ -198,11 +198,17 @@
return protocolHostAndPortAreEqual(url, serviceWorkerURL);
}
-void WebSWContextManagerConnection::startFetch(SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier, ServiceWorkerIdentifier serviceWorkerIdentifier, ResourceRequest&& request, FetchOptions&& options, IPC::FormDataReference&& formData, String&& referrer)
+void WebSWContextManagerConnection::cancelFetch(SWServerConnectionIdentifier serverConnectionIdentifier, ServiceWorkerIdentifier serviceWorkerIdentifier, FetchIdentifier fetchIdentifier)
{
+ if (auto* serviceWorkerThreadProxy = SWContextManager::singleton().serviceWorkerThreadProxy(serviceWorkerIdentifier))
+ serviceWorkerThreadProxy->cancelFetch(serverConnectionIdentifier, fetchIdentifier);
+}
+
+void WebSWContextManagerConnection::startFetch(SWServerConnectionIdentifier serverConnectionIdentifier, ServiceWorkerIdentifier serviceWorkerIdentifier, FetchIdentifier fetchIdentifier, ResourceRequest&& request, FetchOptions&& options, IPC::FormDataReference&& formData, String&& referrer)
+{
auto* serviceWorkerThreadProxy = SWContextManager::singleton().serviceWorkerThreadProxy(serviceWorkerIdentifier);
if (!serviceWorkerThreadProxy) {
- m_connectionToStorageProcess->send(Messages::StorageProcess::DidNotHandleFetch(serverConnectionIdentifier, fetchIdentifier), 0);
+ m_connectionToStorageProcess->send(Messages::StorageProcess::DidNotHandleFetch { serverConnectionIdentifier, fetchIdentifier }, 0);
return;
}
@@ -214,7 +220,7 @@
clientId = ServiceWorkerClientIdentifier { serverConnectionIdentifier, options.clientIdentifier.value() };
request.setHTTPBody(formData.takeData());
- serviceWorkerThreadProxy->thread().postFetchTask(WTFMove(client), WTFMove(clientId), WTFMove(request), WTFMove(referrer), WTFMove(options));
+ serviceWorkerThreadProxy->startFetch(serverConnectionIdentifier, fetchIdentifier, WTFMove(client), WTFMove(clientId), WTFMove(request), WTFMove(referrer), WTFMove(options));
}
void WebSWContextManagerConnection::postMessageToServiceWorker(ServiceWorkerIdentifier destinationIdentifier, MessageWithMessagePorts&& message, ServiceWorkerOrClientData&& sourceData)
Modified: trunk/Source/WebKit/WebProcess/Storage/WebSWContextManagerConnection.h (231587 => 231588)
--- trunk/Source/WebKit/WebProcess/Storage/WebSWContextManagerConnection.h 2018-05-09 19:56:35 UTC (rev 231587)
+++ trunk/Source/WebKit/WebProcess/Storage/WebSWContextManagerConnection.h 2018-05-09 19:59:46 UTC (rev 231588)
@@ -76,7 +76,8 @@
// IPC messages.
void serviceWorkerStartedWithMessage(std::optional<WebCore::ServiceWorkerJobDataIdentifier>, WebCore::ServiceWorkerIdentifier, const String& exceptionMessage) final;
void installServiceWorker(const WebCore::ServiceWorkerContextData&, PAL::SessionID);
- void startFetch(WebCore::SWServerConnectionIdentifier, uint64_t fetchIdentifier, WebCore::ServiceWorkerIdentifier, WebCore::ResourceRequest&&, WebCore::FetchOptions&&, IPC::FormDataReference&&, String&& referrer);
+ void startFetch(WebCore::SWServerConnectionIdentifier, WebCore::ServiceWorkerIdentifier, WebCore::FetchIdentifier, WebCore::ResourceRequest&&, WebCore::FetchOptions&&, IPC::FormDataReference&&, String&& referrer);
+ void cancelFetch(WebCore::SWServerConnectionIdentifier, WebCore::ServiceWorkerIdentifier, WebCore::FetchIdentifier);
void postMessageToServiceWorker(WebCore::ServiceWorkerIdentifier destinationIdentifier, WebCore::MessageWithMessagePorts&&, WebCore::ServiceWorkerOrClientData&& sourceData);
void fireInstallEvent(WebCore::ServiceWorkerIdentifier);
void fireActivateEvent(WebCore::ServiceWorkerIdentifier);
Modified: trunk/Source/WebKit/WebProcess/Storage/WebSWContextManagerConnection.messages.in (231587 => 231588)
--- trunk/Source/WebKit/WebProcess/Storage/WebSWContextManagerConnection.messages.in 2018-05-09 19:56:35 UTC (rev 231587)
+++ trunk/Source/WebKit/WebProcess/Storage/WebSWContextManagerConnection.messages.in 2018-05-09 19:59:46 UTC (rev 231588)
@@ -24,7 +24,8 @@
messages -> WebSWContextManagerConnection {
InstallServiceWorker(struct WebCore::ServiceWorkerContextData contextData, PAL::SessionID sessionID)
- StartFetch(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier, WebCore::ServiceWorkerIdentifier serviceWorkerIdentifier, WebCore::ResourceRequest request, struct WebCore::FetchOptions options, IPC::FormDataReference requestBody, String referrer)
+ StartFetch(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, WebCore::ServiceWorkerIdentifier serviceWorkerIdentifier, WebCore::FetchIdentifier fetchIdentifier, WebCore::ResourceRequest request, struct WebCore::FetchOptions options, IPC::FormDataReference requestBody, String referrer)
+ CancelFetch(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, WebCore::ServiceWorkerIdentifier serviceWorkerIdentifier, WebCore::FetchIdentifier fetchIdentifier)
PostMessageToServiceWorker(WebCore::ServiceWorkerIdentifier destinationIdentifier, struct WebCore::MessageWithMessagePorts message, WebCore::ServiceWorkerOrClientData sourceData)
FireInstallEvent(WebCore::ServiceWorkerIdentifier identifier)
FireActivateEvent(WebCore::ServiceWorkerIdentifier identifier)
Modified: trunk/Source/WebKit/WebProcess/Storage/WebServiceWorkerFetchTaskClient.cpp (231587 => 231588)
--- trunk/Source/WebKit/WebProcess/Storage/WebServiceWorkerFetchTaskClient.cpp 2018-05-09 19:56:35 UTC (rev 231587)
+++ trunk/Source/WebKit/WebProcess/Storage/WebServiceWorkerFetchTaskClient.cpp 2018-05-09 19:59:46 UTC (rev 231588)
@@ -46,11 +46,11 @@
RunLoop::main().dispatch([connection = WTFMove(m_connection)] { });
}
-WebServiceWorkerFetchTaskClient::WebServiceWorkerFetchTaskClient(Ref<IPC::Connection>&& connection, WebCore::ServiceWorkerIdentifier serviceWorkerIdentifier, WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchTaskIdentifier)
+WebServiceWorkerFetchTaskClient::WebServiceWorkerFetchTaskClient(Ref<IPC::Connection>&& connection, WebCore::ServiceWorkerIdentifier serviceWorkerIdentifier, WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, FetchIdentifier fetchIdentifier)
: m_connection(WTFMove(connection))
, m_serverConnectionIdentifier(serverConnectionIdentifier)
, m_serviceWorkerIdentifier(serviceWorkerIdentifier)
- , m_fetchTaskIdentifier(fetchTaskIdentifier)
+ , m_fetchIdentifier(fetchIdentifier)
{
}
@@ -58,7 +58,7 @@
{
if (!m_connection)
return;
- m_connection->send(Messages::StorageProcess::DidReceiveFetchResponse { m_serverConnectionIdentifier, m_fetchTaskIdentifier, response }, 0);
+ m_connection->send(Messages::StorageProcess::DidReceiveFetchResponse { m_serverConnectionIdentifier, m_fetchIdentifier, response }, 0);
}
void WebServiceWorkerFetchTaskClient::didReceiveData(Ref<SharedBuffer>&& buffer)
@@ -66,7 +66,7 @@
if (!m_connection)
return;
IPC::SharedBufferDataReference dataReference { buffer.ptr() };
- m_connection->send(Messages::StorageProcess::DidReceiveFetchData { m_serverConnectionIdentifier, m_fetchTaskIdentifier, dataReference, static_cast<int64_t>(buffer->size()) }, 0);
+ m_connection->send(Messages::StorageProcess::DidReceiveFetchData { m_serverConnectionIdentifier, m_fetchIdentifier, dataReference, static_cast<int64_t>(buffer->size()) }, 0);
}
void WebServiceWorkerFetchTaskClient::didReceiveFormDataAndFinish(Ref<FormData>&& formData)
@@ -78,7 +78,7 @@
// For now and for the case of blobs, we read it there and send the data through IPC.
URL blobURL = formData->asBlobURL();
if (blobURL.isNull()) {
- m_connection->send(Messages::StorageProcess::DidReceiveFetchFormData { m_serverConnectionIdentifier, m_fetchTaskIdentifier, IPC::FormDataReference { WTFMove(formData) } }, 0);
+ m_connection->send(Messages::StorageProcess::DidReceiveFetchFormData { m_serverConnectionIdentifier, m_fetchIdentifier, IPC::FormDataReference { WTFMove(formData) } }, 0);
return;
}
@@ -107,7 +107,7 @@
return;
IPC::DataReference dataReference { reinterpret_cast<const uint8_t*>(data), size };
- m_connection->send(Messages::StorageProcess::DidReceiveFetchData { m_serverConnectionIdentifier, m_fetchTaskIdentifier, dataReference, static_cast<int64_t>(size) }, 0);
+ m_connection->send(Messages::StorageProcess::DidReceiveFetchData { m_serverConnectionIdentifier, m_fetchIdentifier, dataReference, static_cast<int64_t>(size) }, 0);
}
void WebServiceWorkerFetchTaskClient::didFinishBlobLoading()
@@ -121,8 +121,10 @@
{
if (!m_connection)
return;
- m_connection->send(Messages::StorageProcess::DidFailFetch { m_serverConnectionIdentifier, m_fetchTaskIdentifier }, 0);
- m_connection = nullptr;
+
+ m_connection->send(Messages::StorageProcess::DidFailFetch { m_serverConnectionIdentifier, m_fetchIdentifier }, 0);
+
+ cleanup();
}
void WebServiceWorkerFetchTaskClient::didFinish()
@@ -130,8 +132,9 @@
if (!m_connection)
return;
- m_connection->send(Messages::StorageProcess::DidFinishFetch { m_serverConnectionIdentifier, m_fetchTaskIdentifier }, 0);
- m_connection = nullptr;
+ m_connection->send(Messages::StorageProcess::DidFinishFetch { m_serverConnectionIdentifier, m_fetchIdentifier }, 0);
+
+ cleanup();
}
void WebServiceWorkerFetchTaskClient::didNotHandle()
@@ -138,10 +141,31 @@
{
if (!m_connection)
return;
- m_connection->send(Messages::StorageProcess::DidNotHandleFetch { m_serverConnectionIdentifier, m_fetchTaskIdentifier }, 0);
+
+ m_connection->send(Messages::StorageProcess::DidNotHandleFetch { m_serverConnectionIdentifier, m_fetchIdentifier }, 0);
+
+ cleanup();
+}
+
+void WebServiceWorkerFetchTaskClient::cancel()
+{
m_connection = nullptr;
}
+void WebServiceWorkerFetchTaskClient::cleanup()
+{
+ m_connection = nullptr;
+
+ if (!isMainThread()) {
+ callOnMainThread([protectedThis = makeRef(*this)] () {
+ protectedThis->cleanup();
+ });
+ return;
+ }
+ if (auto* serviceWorkerThreadProxy = SWContextManager::singleton().serviceWorkerThreadProxy(m_serviceWorkerIdentifier))
+ serviceWorkerThreadProxy->removeFetch(m_serverConnectionIdentifier, m_fetchIdentifier);
+}
+
} // namespace WebKit
#endif // ENABLE(SERVICE_WORKER)
Modified: trunk/Source/WebKit/WebProcess/Storage/WebServiceWorkerFetchTaskClient.h (231587 => 231588)
--- trunk/Source/WebKit/WebProcess/Storage/WebServiceWorkerFetchTaskClient.h 2018-05-09 19:56:35 UTC (rev 231587)
+++ trunk/Source/WebKit/WebProcess/Storage/WebServiceWorkerFetchTaskClient.h 2018-05-09 19:59:46 UTC (rev 231588)
@@ -28,6 +28,7 @@
#if ENABLE(SERVICE_WORKER)
#include "Connection.h"
+#include <WebCore/FetchIdentifier.h>
#include <WebCore/FetchLoader.h>
#include <WebCore/FetchLoaderClient.h>
#include <WebCore/ServiceWorkerFetch.h>
@@ -37,7 +38,7 @@
class WebServiceWorkerFetchTaskClient final : public WebCore::ServiceWorkerFetch::Client {
public:
- static Ref<WebServiceWorkerFetchTaskClient> create(Ref<IPC::Connection>&& connection, WebCore::ServiceWorkerIdentifier serviceWorkerIdentifier, WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchTaskIdentifier)
+ static Ref<WebServiceWorkerFetchTaskClient> create(Ref<IPC::Connection>&& connection, WebCore::ServiceWorkerIdentifier serviceWorkerIdentifier, WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, WebCore::FetchIdentifier fetchTaskIdentifier)
{
return adoptRef(*new WebServiceWorkerFetchTaskClient(WTFMove(connection), serviceWorkerIdentifier, serverConnectionIdentifier, fetchTaskIdentifier));
}
@@ -45,7 +46,7 @@
~WebServiceWorkerFetchTaskClient();
private:
- WebServiceWorkerFetchTaskClient(Ref<IPC::Connection>&&, WebCore::ServiceWorkerIdentifier, WebCore::SWServerConnectionIdentifier, uint64_t fetchTaskIdentifier);
+ WebServiceWorkerFetchTaskClient(Ref<IPC::Connection>&&, WebCore::ServiceWorkerIdentifier, WebCore::SWServerConnectionIdentifier, WebCore::FetchIdentifier);
void didReceiveResponse(const WebCore::ResourceResponse&) final;
void didReceiveData(Ref<WebCore::SharedBuffer>&&) final;
@@ -53,7 +54,10 @@
void didFail() final;
void didFinish() final;
void didNotHandle() final;
+ void cancel() final;
+ void cleanup();
+
void didReceiveBlobChunk(const char* data, size_t size);
void didFinishBlobLoading();
@@ -73,7 +77,7 @@
RefPtr<IPC::Connection> m_connection;
WebCore::SWServerConnectionIdentifier m_serverConnectionIdentifier;
WebCore::ServiceWorkerIdentifier m_serviceWorkerIdentifier;
- uint64_t m_fetchTaskIdentifier { 0 };
+ WebCore::FetchIdentifier m_fetchIdentifier;
std::optional<BlobLoader> m_blobLoader;
};
Modified: trunk/Source/WebKit/WebProcess/Storage/WebServiceWorkerProvider.cpp (231587 => 231588)
--- trunk/Source/WebKit/WebProcess/Storage/WebServiceWorkerProvider.cpp 2018-05-09 19:56:35 UTC (rev 231587)
+++ trunk/Source/WebKit/WebProcess/Storage/WebServiceWorkerProvider.cpp 2018-05-09 19:59:46 UTC (rev 231588)
@@ -88,10 +88,11 @@
}
auto& connection = WebProcess::singleton().ensureWebToStorageProcessConnection(sessionID).serviceWorkerConnectionForSession(sessionID);
- m_ongoingFetchTasks.add(loader.identifier(), ServiceWorkerClientFetch::create(*this, loader, loader.identifier(), connection, shouldClearReferrerOnHTTPSToHTTPRedirect, WTFMove(callback)));
+ auto fetchIdentifier = makeObjectIdentifier<FetchIdentifierType>(loader.identifier());
+ m_ongoingFetchTasks.add(fetchIdentifier, ServiceWorkerClientFetch::create(*this, loader, fetchIdentifier, connection, shouldClearReferrerOnHTTPSToHTTPRedirect, WTFMove(callback)));
}
-bool WebServiceWorkerProvider::cancelFetch(uint64_t fetchIdentifier)
+bool WebServiceWorkerProvider::cancelFetch(FetchIdentifier fetchIdentifier)
{
auto fetch = m_ongoingFetchTasks.take(fetchIdentifier);
if (fetch)
@@ -99,7 +100,7 @@
return !!fetch;
}
-void WebServiceWorkerProvider::fetchFinished(uint64_t fetchIdentifier)
+void WebServiceWorkerProvider::fetchFinished(FetchIdentifier fetchIdentifier)
{
m_ongoingFetchTasks.take(fetchIdentifier);
}
@@ -106,7 +107,7 @@
void WebServiceWorkerProvider::didReceiveServiceWorkerClientFetchMessage(IPC::Connection& connection, IPC::Decoder& decoder)
{
- if (auto fetch = m_ongoingFetchTasks.get(decoder.destinationID()))
+ if (auto fetch = m_ongoingFetchTasks.get(makeObjectIdentifier<FetchIdentifierType>(decoder.destinationID())))
fetch->didReceiveMessage(connection, decoder);
}
Modified: trunk/Source/WebKit/WebProcess/Storage/WebServiceWorkerProvider.h (231587 => 231588)
--- trunk/Source/WebKit/WebProcess/Storage/WebServiceWorkerProvider.h 2018-05-09 19:56:35 UTC (rev 231587)
+++ trunk/Source/WebKit/WebProcess/Storage/WebServiceWorkerProvider.h 2018-05-09 19:59:46 UTC (rev 231588)
@@ -42,8 +42,8 @@
static WebServiceWorkerProvider& singleton();
void handleFetch(WebCore::ResourceLoader&, WebCore::CachedResource*, PAL::SessionID, bool shouldClearReferrerOnHTTPSToHTTPRedirect, ServiceWorkerClientFetch::Callback&&);
- bool cancelFetch(uint64_t fetchIdentifier);
- void fetchFinished(uint64_t fetchIdentifier);
+ bool cancelFetch(WebCore::FetchIdentifier);
+ void fetchFinished(WebCore::FetchIdentifier);
void didReceiveServiceWorkerClientFetchMessage(IPC::Connection&, IPC::Decoder&);
void didReceiveServiceWorkerClientRegistrationMatch(IPC::Connection&, IPC::Decoder&);
@@ -55,7 +55,7 @@
WebCore::SWClientConnection* existingServiceWorkerConnectionForSession(PAL::SessionID) final;
WebCore::SWClientConnection& serviceWorkerConnectionForSession(PAL::SessionID) final;
- HashMap<uint64_t, Ref<ServiceWorkerClientFetch>> m_ongoingFetchTasks;
+ HashMap<WebCore::FetchIdentifier, Ref<ServiceWorkerClientFetch>> m_ongoingFetchTasks;
}; // class WebServiceWorkerProvider
} // namespace WebKit
