Changeset 226126 in webkit


Ignore:
Timestamp:
Dec 19, 2017 10:37:44 AM (6 years ago)
Author:
commit-queue@webkit.org
Message:

Service Worker should not clean HTTP headers added by the application or by fetch specification before service worker interception
​https://bugs.webkit.org/show_bug.cgi?id=180939

Patch by Youenn Fablet <​youenn@apple.com> on 2017-12-19
Reviewed by Chris Dumez.

LayoutTests/imported/w3c:

  • web-platform-tests/service-workers/service-worker/fetch-request-xhr.https-expected.txt:
  • web-platform-tests/service-workers/service-worker/resources/fetch-request-xhr-iframe.https.html:
  • web-platform-tests/service-workers/service-worker/fetch-header-visibility.https-expected.txt:

Source/WebCore:

Covered by modified WPT test.

Add support to clean only specific headers in cleanHTTPRequestHeadersForAccessControl,
renamed from cleanRedirectedRequestForAccessControl.
Compute the list of headers to keep in DocumentThreadableLoader.
Add a specific rule for Accept header which is set prior service worker interception and for
HTTP headers set by DocumentThreadableLoader clients.

  • loader/CrossOriginAccessControl.cpp:

(WebCore::httpHeadersToKeepFromCleaning):
(WebCore::cleanRedirectedRequestForAccessControl):

  • loader/CrossOriginAccessControl.h:

(WebCore::cleanRedirectedRequestForAccessControl):

  • loader/DocumentThreadableLoader.cpp:

(WebCore::DocumentThreadableLoader::DocumentThreadableLoader):

  • loader/ResourceLoaderOptions.h:
  • workers/service/context/ServiceWorkerFetch.cpp:

(WebCore::ServiceWorkerFetch::dispatchFetchEvent):

  • workers/service/context/ServiceWorkerFetch.h:
  • workers/service/context/ServiceWorkerThread.cpp:

(WebCore::ServiceWorkerThread::postFetchTask):

  • workers/service/context/ServiceWorkerThread.h:

Source/WebKit:

Passing referrer as an explicit parameter of StartFetch.

Cleaning request headers based on ResourceLoaderOptions.httpHeadersToKeep.

  • StorageProcess/ServiceWorker/WebSWServerConnection.cpp:

(WebKit::WebSWServerConnection::startFetch):

  • StorageProcess/ServiceWorker/WebSWServerConnection.h:
  • StorageProcess/ServiceWorker/WebSWServerConnection.messages.in:
  • WebProcess/Storage/ServiceWorkerClientFetch.cpp:

(WebKit::ServiceWorkerClientFetch::start):

  • WebProcess/Storage/WebSWClientConnection.cpp:

(WebKit::WebSWClientConnection::startFetch):

  • WebProcess/Storage/WebSWClientConnection.h:
  • WebProcess/Storage/WebSWContextManagerConnection.cpp:

(WebKit::WebSWContextManagerConnection::startFetch):

  • WebProcess/Storage/WebSWContextManagerConnection.h:
  • WebProcess/Storage/WebSWContextManagerConnection.messages.in:

LayoutTests:

Location:
trunk
Files:
26 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r226125 r226126  
     12017-12-19  Youenn Fablet  <youenn@apple.com>
     2
     3        Service Worker should not clean HTTP headers added by the application or by fetch specification before service worker interception
     4        https://bugs.webkit.org/show_bug.cgi?id=180939
     5
     6        Reviewed by Chris Dumez.
     7
     8        * TestExpectations:
     9
    1102017-12-19  Chris Dumez  <cdumez@apple.com>
    211

  • trunk/LayoutTests/TestExpectations

    r226125 r226126  
    176176imported/w3c/web-platform-tests/service-workers/service-worker/fetch-event-respond-with-response-body-with-invalid-chunk.https.html [ Pass Failure ]
    177177imported/w3c/web-platform-tests/service-workers/service-worker/fetch-request-redirect.https.html [ Pass Failure Timeout ]
    178 imported/w3c/web-platform-tests/service-workers/service-worker/fetch-request-xhr.https.html [ Pass Failure ]
    179178imported/w3c/web-platform-tests/service-workers/service-worker/multiple-update.https.html [ Pass Failure ]
    180179imported/w3c/web-platform-tests/service-workers/service-worker/performance-timeline.https.html [ Pass Failure ]

  • trunk/LayoutTests/imported/w3c/ChangeLog

    r226125 r226126  
     12017-12-19  Youenn Fablet  <youenn@apple.com>
     2
     3        Service Worker should not clean HTTP headers added by the application or by fetch specification before service worker interception
     4        https://bugs.webkit.org/show_bug.cgi?id=180939
     5
     6        Reviewed by Chris Dumez.
     7
     8        * web-platform-tests/service-workers/service-worker/fetch-request-xhr.https-expected.txt:
     9        * web-platform-tests/service-workers/service-worker/resources/fetch-request-xhr-iframe.https.html:
     10        * web-platform-tests/service-workers/service-worker/fetch-header-visibility.https-expected.txt:
     11
    1122017-12-19  Chris Dumez  <cdumez@apple.com>
    213

  • trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/fetch-header-visibility.https-expected.txt

    r226066 r226126  
    11
     2PASS Visibility of defaulted headers during interception
    23
    3 FAIL Visibility of defaulted headers during interception assert_unreached: unexpected rejection: withUA FAIL - expected "custom_ua", got "NO_UA" Reached unreachable code
    4 

  • trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/fetch-request-xhr.https-expected.txt

    r225978 r226126  
    22PASS initialize global state
    33PASS event.request has the expected headers for same-origin GET.
    4 FAIL event.request has the expected headers for same-origin POST. promise_test: Unhandled rejection with value: object "Error: assert_array_equals: event.request has the expected headers for same-origin POST. lengths differ, expected 2 got 1"
     4PASS event.request has the expected headers for same-origin POST.
    55PASS event.request has the expected headers for cross-origin GET.
    6 FAIL event.request has the expected headers for cross-origin POST. promise_test: Unhandled rejection with value: object "Error: assert_array_equals: event.request has the expected headers for cross-origin POST. lengths differ, expected 2 got 1"
     6PASS event.request has the expected headers for cross-origin POST.
    77PASS FetchEvent#request.body contains XHR request data (string)
    88FAIL FetchEvent#request.body contains XHR request data (blob) promise_test: Unhandled rejection with value: object "Error: assert_equals: expected "test blob" but got """
    99PASS FetchEvent#request.method is set to XHR method
    1010PASS XHR using OPTIONS method
    11 FAIL XHR with form data promise_test: Unhandled rejection with value: object "Error: assert_equals: expected "--\r\nContent-Disposition: form-data; name=\"sample string\"\r\n\r\n1234567890\r\n--\r\nContent-Disposition: form-data; name=\"sample blob\"; filename=\"blob\"\r\nContent-Type: application/octet-stream\r\n\r\nblob content\r\n--\r\nContent-Disposition: form-data; name=\"sample file\"; filename=\"file.dat\"\r\nContent-Type: application/octet-stream\r\n\r\nfile content\r\n----\r\n" but got """
     11FAIL XHR with form data promise_test: Unhandled rejection with value: object "Error: assert_true: form data response content is as expected expected true got false"
    1212FAIL XHR with mode/credentials set promise_test: Unhandled rejection with value: object "Error: assert_equals: expected "include" but got "same-origin""
    1313PASS XHR to data URL

  • trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/resources/fetch-request-xhr-iframe.https.html

    r223327 r226126  
    180180          'file content\r\n' +
    181181          '--' + boundary + '--\r\n';
    182         assert_equals(response.body, expected_body);
     182        assert_true(response.body === expected_body, "form data response content is as expected");
    183183      });
    184184}

  • trunk/Source/WebCore/ChangeLog

    r226123 r226126  
     12017-12-19  Youenn Fablet  <youenn@apple.com>
     2
     3        Service Worker should not clean HTTP headers added by the application or by fetch specification before service worker interception
     4        https://bugs.webkit.org/show_bug.cgi?id=180939
     5
     6        Reviewed by Chris Dumez.
     7
     8        Covered by modified WPT test.
     9
     10        Add support to clean only specific headers in cleanHTTPRequestHeadersForAccessControl,
     11        renamed from cleanRedirectedRequestForAccessControl.
     12        Compute the list of headers to keep in DocumentThreadableLoader.
     13        Add a specific rule for Accept header which is set prior service worker interception and for
     14        HTTP headers set by DocumentThreadableLoader clients.
     15
     16        * loader/CrossOriginAccessControl.cpp:
     17        (WebCore::httpHeadersToKeepFromCleaning):
     18        (WebCore::cleanRedirectedRequestForAccessControl):
     19        * loader/CrossOriginAccessControl.h:
     20        (WebCore::cleanRedirectedRequestForAccessControl):
     21        * loader/DocumentThreadableLoader.cpp:
     22        (WebCore::DocumentThreadableLoader::DocumentThreadableLoader):
     23        * loader/ResourceLoaderOptions.h:
     24        * workers/service/context/ServiceWorkerFetch.cpp:
     25        (WebCore::ServiceWorkerFetch::dispatchFetchEvent):
     26        * workers/service/context/ServiceWorkerFetch.h:
     27        * workers/service/context/ServiceWorkerThread.cpp:
     28        (WebCore::ServiceWorkerThread::postFetchTask):
     29        * workers/service/context/ServiceWorkerThread.h:
     30
    1312017-12-19  Andy Estes  <aestes@apple.com>
    232

  • trunk/Source/WebCore/loader/CrossOriginAccessControl.cpp

    r225574 r226126  
    117117}
    118118
    119 void cleanRedirectedRequestForAccessControl(ResourceRequest& request)
     119HTTPHeaderNameSet httpHeadersToKeepFromCleaning(const HTTPHeaderMap& headers)
     120{
     121    HTTPHeaderNameSet headersToKeep;
     122    if (headers.contains(HTTPHeaderName::ContentType))
     123        headersToKeep.add(HTTPHeaderName::ContentType);
     124    if (headers.contains(HTTPHeaderName::Referer))
     125        headersToKeep.add(HTTPHeaderName::Referer);
     126    if (headers.contains(HTTPHeaderName::Origin))
     127        headersToKeep.add(HTTPHeaderName::Origin);
     128    if (headers.contains(HTTPHeaderName::UserAgent))
     129        headersToKeep.add(HTTPHeaderName::UserAgent);
     130    if (headers.contains(HTTPHeaderName::AcceptEncoding))
     131        headersToKeep.add(HTTPHeaderName::AcceptEncoding);
     132    return headersToKeep;
     133}
     134
     135void cleanHTTPRequestHeadersForAccessControl(ResourceRequest& request, const HashSet<HTTPHeaderName, WTF::IntHash<HTTPHeaderName>, WTF::StrongEnumHashTraits<HTTPHeaderName>>& headersToKeep)
    120136{
    121137    // Remove headers that may have been added by the network layer that cause access control to fail.
    122     request.clearHTTPContentType();
    123     request.clearHTTPReferrer();
    124     request.clearHTTPOrigin();
    125     request.clearHTTPUserAgent();
    126     request.clearHTTPAcceptEncoding();
     138    if (!headersToKeep.contains(HTTPHeaderName::ContentType))
     139        request.clearHTTPContentType();
     140    if (!headersToKeep.contains(HTTPHeaderName::Referer))
     141        request.clearHTTPReferrer();
     142    if (!headersToKeep.contains(HTTPHeaderName::Origin))
     143        request.clearHTTPOrigin();
     144    if (!headersToKeep.contains(HTTPHeaderName::UserAgent))
     145        request.clearHTTPUserAgent();
     146    if (!headersToKeep.contains(HTTPHeaderName::AcceptEncoding))
     147        request.clearHTTPAcceptEncoding();
    127148}
    128149

  • trunk/Source/WebCore/loader/CrossOriginAccessControl.h

    r222467 r226126  
    2727#pragma once
    2828
     29#include "HTTPHeaderNames.h"
    2930#include "StoredCredentialsPolicy.h"
    3031#include <wtf/Forward.h>
     32#include <wtf/HashSet.h>
    3133
    3234namespace WebCore {
    … …  
    4547
    4648bool isValidCrossOriginRedirectionURL(const URL&);
    47 void cleanRedirectedRequestForAccessControl(ResourceRequest&);
     49
     50using HTTPHeaderNameSet = HashSet<HTTPHeaderName, WTF::IntHash<HTTPHeaderName>, WTF::StrongEnumHashTraits<HTTPHeaderName>>;
     51HTTPHeaderNameSet httpHeadersToKeepFromCleaning(const HTTPHeaderMap&);
     52WEBCORE_EXPORT void cleanHTTPRequestHeadersForAccessControl(ResourceRequest&, const HTTPHeaderNameSet& = { });
    4853
    4954WEBCORE_EXPORT bool passesAccessControlCheck(const ResourceResponse&, StoredCredentialsPolicy, SecurityOrigin&, String& errorDescription);

  • trunk/Source/WebCore/loader/DocumentThreadableLoader.cpp

    r225796 r226126  
    120120        m_originalHeaders = request.httpHeaderFields();
    121121
     122#if ENABLE(SERVICE_WORKER)
     123    if (m_options.serviceWorkersMode == ServiceWorkersMode::All && m_async && (m_options.serviceWorkerIdentifier || document.activeServiceWorker()))
     124        m_options.httpHeadersToKeep = httpHeadersToKeepFromCleaning(request.httpHeaderFields());
     125#endif
     126
    122127    if (document.page() && document.page()->isRunningUserScripts() && SchemeRegistry::isUserExtensionScheme(request.url().protocol().toStringWithoutCopying())) {
    123128        m_options.mode = FetchOptions::Mode::NoCors;

  • trunk/Source/WebCore/loader/ResourceLoaderOptions.h

    r224439 r226126  
    3232
    3333#include "FetchOptions.h"
     34#include "HTTPHeaderNames.h"
    3435#include "ServiceWorkerIdentifier.h"
    3536#include "StoredCredentialsPolicy.h"
     37#include <wtf/HashSet.h>
    3638#include <wtf/Vector.h>
    3739#include <wtf/text/WTFString.h>
    … …  
    141143#if ENABLE(SERVICE_WORKER)
    142144    std::optional<ServiceWorkerIdentifier> serviceWorkerIdentifier;
     145    // WebKit loading code is adding some HTTP headers between the application and the time service worker intercepts the fetch.
     146    // We keep a list of these headers so that we only remove the ones that are set by the loading code and not by the application.
     147    // FIXME: Remove this when service worker fetch interception happens before the setting of these headers in the loading code.
     148    HashSet<HTTPHeaderName, WTF::IntHash<HTTPHeaderName>, WTF::StrongEnumHashTraits<HTTPHeaderName>> httpHeadersToKeep;
    143149#endif
    144150

  • trunk/Source/WebCore/loader/SubresourceLoader.cpp

    r226087 r226126  
    543543
    544544    if (redirectingToNewOrigin) {
    545         cleanRedirectedRequestForAccessControl(newRequest);
     545        cleanHTTPRequestHeadersForAccessControl(newRequest);
    546546        updateRequestForAccessControl(newRequest, *m_origin, options().storedCredentialsPolicy);
    547547    }

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

    r226066 r226126  
    9292}
    9393
    94 Ref<FetchEvent> dispatchFetchEvent(Ref<Client>&& client, WorkerGlobalScope& globalScope, std::optional<ServiceWorkerClientIdentifier> clientId, ResourceRequest&& request, FetchOptions&& options)
     94Ref<FetchEvent> dispatchFetchEvent(Ref<Client>&& client, WorkerGlobalScope& globalScope, std::optional<ServiceWorkerClientIdentifier> clientId, ResourceRequest&& request, String&& referrer, FetchOptions&& options)
    9595{
    9696    ASSERT(globalScope.isServiceWorkerGlobalScope());
    9797
    98     auto httpReferrer = request.httpReferrer();
    99     // We are intercepting fetch calls after going through the HTTP layer, which adds some specific headers.
    100     // Let's clean them so that cross origin checks do not fail.
    101     if (options.mode == FetchOptions::Mode::Cors)
    102         cleanRedirectedRequestForAccessControl(request);
    103 
    10498    auto requestHeaders = FetchHeaders::create(FetchHeaders::Guard::Immutable, HTTPHeaderMap { request.httpHeaderFields() });
    105     auto fetchRequest = FetchRequest::create(globalScope, FetchBody::fromFormData(request.httpBody()), WTFMove(requestHeaders),  WTFMove(request), WTFMove(options), WTFMove(httpReferrer));
     99    auto fetchRequest = FetchRequest::create(globalScope, FetchBody::fromFormData(request.httpBody()), WTFMove(requestHeaders),  WTFMove(request), WTFMove(options), WTFMove(referrer));
    106100
    107101    FetchEvent::Init init;

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

    r226066 r226126  
    5555};
    5656
    57 Ref<FetchEvent> dispatchFetchEvent(Ref<Client>&&, WorkerGlobalScope&, std::optional<ServiceWorkerClientIdentifier>, ResourceRequest&&, FetchOptions&&);
     57Ref<FetchEvent> dispatchFetchEvent(Ref<Client>&&, WorkerGlobalScope&, std::optional<ServiceWorkerClientIdentifier>, ResourceRequest&&, String&& referrer, FetchOptions&&);
    5858};
    5959

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

    r225760 r226126  
    9292}
    9393
    94 void ServiceWorkerThread::postFetchTask(Ref<ServiceWorkerFetch::Client>&& client, std::optional<ServiceWorkerClientIdentifier>&& clientId, ResourceRequest&& request, FetchOptions&& options)
     94void ServiceWorkerThread::postFetchTask(Ref<ServiceWorkerFetch::Client>&& client, std::optional<ServiceWorkerClientIdentifier>&& clientId, ResourceRequest&& request, String&& referrer, FetchOptions&& options)
    9595{
    9696    // FIXME: instead of directly using runLoop(), we should be using something like WorkerGlobalScopeProxy.
    9797    // FIXME: request and options come straigth from IPC so are already isolated. We should be able to take benefit of that.
    98     runLoop().postTaskForMode([client = WTFMove(client), clientId, request = request.isolatedCopy(), options = options.isolatedCopy()] (ScriptExecutionContext& context) mutable {
     98    runLoop().postTaskForMode([client = WTFMove(client), clientId, request = request.isolatedCopy(), referrer = referrer.isolatedCopy(), options = options.isolatedCopy()] (ScriptExecutionContext& context) mutable {
    9999        auto& serviceWorkerGlobalScope = downcast<ServiceWorkerGlobalScope>(context);
    100         auto fetchEvent = ServiceWorkerFetch::dispatchFetchEvent(WTFMove(client), serviceWorkerGlobalScope, clientId, WTFMove(request), WTFMove(options));
     100        auto fetchEvent = ServiceWorkerFetch::dispatchFetchEvent(WTFMove(client), serviceWorkerGlobalScope, clientId, WTFMove(request), WTFMove(referrer), WTFMove(options));
    101101        serviceWorkerGlobalScope.updateExtendedEventsSet(fetchEvent.ptr());
    102102    }, WorkerRunLoop::defaultMode());

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

    r225760 r226126  
    5757    WorkerObjectProxy& workerObjectProxy() const { return m_workerObjectProxy; }
    5858
    59     WEBCORE_EXPORT void postFetchTask(Ref<ServiceWorkerFetch::Client>&&, ResourceRequest&&, FetchOptions&&);
    60     WEBCORE_EXPORT void postFetchTask(Ref<ServiceWorkerFetch::Client>&&, std::optional<ServiceWorkerClientIdentifier>&&, ResourceRequest&&, FetchOptions&&);
     59    WEBCORE_EXPORT void postFetchTask(Ref<ServiceWorkerFetch::Client>&&, std::optional<ServiceWorkerClientIdentifier>&&, ResourceRequest&&, String&& referrer, FetchOptions&&);
    6160    WEBCORE_EXPORT void postMessageToServiceWorker(Ref<SerializedScriptValue>&&, std::unique_ptr<MessagePortChannelArray>&&, ServiceWorkerOrClientData&& sourceData);
    6261

  • trunk/Source/WebKit/ChangeLog

    r226123 r226126  
     12017-12-19  Youenn Fablet  <youenn@apple.com>
     2
     3        Service Worker should not clean HTTP headers added by the application or by fetch specification before service worker interception
     4        https://bugs.webkit.org/show_bug.cgi?id=180939
     5
     6        Reviewed by Chris Dumez.
     7
     8        Passing referrer as an explicit parameter of StartFetch.
     9
     10        Cleaning request headers based on ResourceLoaderOptions.httpHeadersToKeep.
     11
     12        * StorageProcess/ServiceWorker/WebSWServerConnection.cpp:
     13        (WebKit::WebSWServerConnection::startFetch):
     14        * StorageProcess/ServiceWorker/WebSWServerConnection.h:
     15        * StorageProcess/ServiceWorker/WebSWServerConnection.messages.in:
     16        * WebProcess/Storage/ServiceWorkerClientFetch.cpp:
     17        (WebKit::ServiceWorkerClientFetch::start):
     18        * WebProcess/Storage/WebSWClientConnection.cpp:
     19        (WebKit::WebSWClientConnection::startFetch):
     20        * WebProcess/Storage/WebSWClientConnection.h:
     21        * WebProcess/Storage/WebSWContextManagerConnection.cpp:
     22        (WebKit::WebSWContextManagerConnection::startFetch):
     23        * WebProcess/Storage/WebSWContextManagerConnection.h:
     24        * WebProcess/Storage/WebSWContextManagerConnection.messages.in:
     25
    1262017-12-19  Andy Estes  <aestes@apple.com>
    227

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

    r225992 r226126  
    127127}
    128128
    129 void WebSWServerConnection::startFetch(uint64_t fetchIdentifier, ServiceWorkerIdentifier serviceWorkerIdentifier, ResourceRequest&& request, FetchOptions&& options, IPC::FormDataReference&& formData)
     129void WebSWServerConnection::startFetch(uint64_t fetchIdentifier, ServiceWorkerIdentifier serviceWorkerIdentifier, ResourceRequest&& request, FetchOptions&& options, IPC::FormDataReference&& formData, String&& referrer)
    130130{
    131131    // It's possible this specific worker cannot be re-run (e.g. its registration has been removed)
    132     server().runServiceWorkerIfNecessary(serviceWorkerIdentifier, [contentConnection = m_contentConnection.copyRef(), connectionIdentifier = identifier(), fetchIdentifier, serviceWorkerIdentifier = serviceWorkerIdentifier, request = WTFMove(request), options = WTFMove(options), formData = WTFMove(formData)](bool success, auto& contextConnection) {
     132    server().runServiceWorkerIfNecessary(serviceWorkerIdentifier, [contentConnection = m_contentConnection.copyRef(), connectionIdentifier = identifier(), fetchIdentifier, serviceWorkerIdentifier = serviceWorkerIdentifier, request = WTFMove(request), options = WTFMove(options), formData = WTFMove(formData), referrer = WTFMove(referrer)](bool success, auto& contextConnection) {
    133133        if (success)
    134             sendToContextProcess(contextConnection, Messages::WebSWContextManagerConnection::StartFetch { connectionIdentifier, fetchIdentifier, serviceWorkerIdentifier, request, options, formData });
     134            sendToContextProcess(contextConnection, Messages::WebSWContextManagerConnection::StartFetch { connectionIdentifier, fetchIdentifier, serviceWorkerIdentifier, request, options, formData, referrer });
    135135        else
    136136            contentConnection->send(Messages::ServiceWorkerClientFetch::DidNotHandle { }, fetchIdentifier);

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

    r225992 r226126  
    8484    void registrationReady(uint64_t registrationReadyRequestIdentifier, WebCore::ServiceWorkerRegistrationData&&) final;
    8585
    86     void startFetch(uint64_t fetchIdentifier, WebCore::ServiceWorkerIdentifier, WebCore::ResourceRequest&&, WebCore::FetchOptions&&, IPC::FormDataReference&&);
     86    void startFetch(uint64_t fetchIdentifier, WebCore::ServiceWorkerIdentifier, WebCore::ResourceRequest&&, WebCore::FetchOptions&&, IPC::FormDataReference&&, String&& referrer);
    8787
    8888    void postMessageToServiceWorker(WebCore::ServiceWorkerIdentifier destination, IPC::DataReference&& message, const WebCore::ServiceWorkerOrClientIdentifier& source);

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

    r225787 r226126  
    3030    RemoveServiceWorkerRegistrationInServer(WebCore::ServiceWorkerRegistrationIdentifier identifier)
    3131
    32     StartFetch(uint64_t identifier, WebCore::ServiceWorkerIdentifier serviceWorkerIdentifier, WebCore::ResourceRequest request, struct WebCore::FetchOptions options, IPC::FormDataReference requestBody)
     32    StartFetch(uint64_t identifier, WebCore::ServiceWorkerIdentifier serviceWorkerIdentifier, WebCore::ResourceRequest request, struct WebCore::FetchOptions options, IPC::FormDataReference requestBody, String referrer)
    3333
    3434    PostMessageToServiceWorker(WebCore::ServiceWorkerIdentifier destination, IPC::DataReference message, WebCore::ServiceWorkerOrClientIdentifier source)

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

    r226084 r226126  
    3232#include "WebSWClientConnection.h"
    3333#include "WebServiceWorkerProvider.h"
     34#include <WebCore/CrossOriginAccessControl.h>
    3435#include <WebCore/MIMETypeRegistry.h>
    3536#include <WebCore/NotImplemented.h>
    … …  
    6364void ServiceWorkerClientFetch::start()
    6465{
    65     m_connection->startFetch(m_loader, m_loader->identifier());
     66    auto request = m_loader->request();
     67    auto& options = m_loader->options();
     68
     69    auto referrer = request.httpReferrer();
     70
     71    // We are intercepting fetch calls after going through the HTTP layer, which may add some specific headers.
     72    if (options.mode == FetchOptions::Mode::Cors)
     73        cleanHTTPRequestHeadersForAccessControl(request, options.httpHeadersToKeep);
     74
     75    ASSERT(options.serviceWorkersMode != ServiceWorkersMode::None);
     76    m_connection->startFetch(m_loader->identifier(), options.serviceWorkerIdentifier.value(), request, options, referrer);
    6677}
    6778

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

    r225787 r226126  
    193193}
    194194
    195 void WebSWClientConnection::startFetch(const ResourceLoader& loader, uint64_t identifier)
    196 {
    197     ASSERT(loader.options().serviceWorkersMode != ServiceWorkersMode::None && loader.options().serviceWorkerIdentifier);
    198     send(Messages::WebSWServerConnection::StartFetch { identifier, loader.options().serviceWorkerIdentifier.value(), loader.request(), loader.options(), IPC::FormDataReference { loader.request().httpBody() } });
     195void WebSWClientConnection::startFetch(uint64_t fetchIdentifier, WebCore::ServiceWorkerIdentifier serviceWorkerIdentifier, const WebCore::ResourceRequest& request, const WebCore::FetchOptions& options, const String& referrer)
     196{
     197    send(Messages::WebSWServerConnection::StartFetch { fetchIdentifier, serviceWorkerIdentifier, request, options, IPC::FormDataReference { request.httpBody() }, referrer });
    199198}
    200199

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

    r225787 r226126  
    6161
    6262    bool mayHaveServiceWorkerRegisteredForOrigin(const WebCore::SecurityOrigin&) const final;
    63     void startFetch(const WebCore::ResourceLoader&, uint64_t identifier);
     63    void startFetch(uint64_t fetchIdentifier, WebCore::ServiceWorkerIdentifier, const WebCore::ResourceRequest&, const WebCore::FetchOptions&, const String& referrer);
    6464
    6565    void postMessageToServiceWorkerClient(WebCore::DocumentIdentifier destinationContextIdentifier, const IPC::DataReference& message, WebCore::ServiceWorkerData&& source, const String& sourceOrigin);

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

    r226066 r226126  
    156156}
    157157
    158 void WebSWContextManagerConnection::startFetch(SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier, ServiceWorkerIdentifier serviceWorkerIdentifier, ResourceRequest&& request, FetchOptions&& options, IPC::FormDataReference&& formData)
     158void WebSWContextManagerConnection::startFetch(SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier, ServiceWorkerIdentifier serviceWorkerIdentifier, ResourceRequest&& request, FetchOptions&& options, IPC::FormDataReference&& formData, String&& referrer)
    159159{
    160160    auto* serviceWorkerThreadProxy = SWContextManager::singleton().serviceWorkerThreadProxy(serviceWorkerIdentifier);
    … …  
    170170
    171171    request.setHTTPBody(formData.takeData());
    172     serviceWorkerThreadProxy->thread().postFetchTask(WTFMove(client), WTFMove(clientId), WTFMove(request), WTFMove(options));
     172    serviceWorkerThreadProxy->thread().postFetchTask(WTFMove(client), WTFMove(clientId), WTFMove(request), WTFMove(referrer), WTFMove(options));
    173173}
    174174

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

    r225760 r226126  
    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, uint64_t fetchIdentifier, WebCore::ServiceWorkerIdentifier, WebCore::ResourceRequest&&, WebCore::FetchOptions&&, IPC::FormDataReference&&);
     79    void startFetch(WebCore::SWServerConnectionIdentifier, uint64_t fetchIdentifier, WebCore::ServiceWorkerIdentifier, WebCore::ResourceRequest&&, WebCore::FetchOptions&&, IPC::FormDataReference&&, String&& referrer);
    8080    void postMessageToServiceWorker(WebCore::ServiceWorkerIdentifier destinationIdentifier, const IPC::DataReference& message, WebCore::ServiceWorkerOrClientData&& sourceData);
    8181    void fireInstallEvent(WebCore::ServiceWorkerIdentifier);

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

    r225760 r226126  
    2525messages -> WebSWContextManagerConnection {
    2626    InstallServiceWorker(struct WebCore::ServiceWorkerContextData contextData, PAL::SessionID sessionID)
    27     StartFetch(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier, WebCore::ServiceWorkerIdentifier serviceWorkerIdentifier, WebCore::ResourceRequest request, struct WebCore::FetchOptions options, IPC::FormDataReference requestBody)
     27    StartFetch(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier, WebCore::ServiceWorkerIdentifier serviceWorkerIdentifier, WebCore::ResourceRequest request, struct WebCore::FetchOptions options, IPC::FormDataReference requestBody, String referrer)
    2828    PostMessageToServiceWorker(WebCore::ServiceWorkerIdentifier destinationIdentifier, IPC::DataReference message, WebCore::ServiceWorkerOrClientData sourceData)
    2929    FireInstallEvent(WebCore::ServiceWorkerIdentifier identifier)
Note: See TracChangeset for help on using the changeset viewer.