Changeset 230541 in webkit


Ignore:
Timestamp:
Apr 11, 2018 12:05:08 PM (6 years ago)
Author:
youenn@apple.com
Message:

Pass FetchOptions and SecurityOrigin as load parameters from WebProcess to NetworkProcess
​https://bugs.webkit.org/show_bug.cgi?id=184374

Reviewed by Chris Dumez.

Source/WebCore:

Add support for SecurityOrigin encode/decode routines.

  • page/SecurityOrigin.h:

Source/WebKit:

Pass full FetchOptions parameters as part of NetworkResourceLoadParameters.
This will allow handling redirection mode as well as credentials in case of cross origin redirections.
In case of SameOrigin credentials and there is a redirection from same-origin to cross-origin,
we will be able to stop using credentials without going to WebProcess.

To handle properly cross-origin checks, we have to be able to use SecurityOrigin as in WebProcess.
We make WebProcess sends Origin Access White list information to NetworkProcess.
This allows supporting the white list when doing loading in NetworkProcess.
This only works consistently if all WebProcesses share the same whitelist.

  • NetworkProcess/NetworkConnectionToWebProcess.cpp:

(WebKit::NetworkConnectionToWebProcess::loadPing):
(WebKit::NetworkConnectionToWebProcess::addOriginAccessWhitelistEntry):
(WebKit::NetworkConnectionToWebProcess::removeOriginAccessWhitelistEntry):
(WebKit::NetworkConnectionToWebProcess::resetOriginAccessWhitelists):

  • NetworkProcess/NetworkConnectionToWebProcess.h:
  • NetworkProcess/NetworkConnectionToWebProcess.messages.in:
  • NetworkProcess/NetworkLoadChecker.cpp:

(WebKit::NetworkLoadChecker::NetworkLoadChecker):
(WebKit::NetworkLoadChecker::checkRedirection):
(WebKit::NetworkLoadChecker::continueCheckingRequest):
(WebKit::NetworkLoadChecker::checkCORSRequest):
(WebKit::NetworkLoadChecker::checkCORSRedirectedRequest):
(WebKit::NetworkLoadChecker::checkCORSRequestWithPreflight):
(WebKit::NetworkLoadChecker::doesNotNeedCORSCheck const):

  • NetworkProcess/NetworkLoadChecker.h:

(WebKit::NetworkLoadChecker::create):

  • NetworkProcess/NetworkResourceLoadParameters.cpp:

(WebKit::NetworkResourceLoadParameters::encode const):
(WebKit::NetworkResourceLoadParameters::decode):

  • NetworkProcess/NetworkResourceLoadParameters.h:
  • NetworkProcess/PingLoad.cpp:

(WebKit::PingLoad::PingLoad):
(WebKit::PingLoad::willPerformHTTPRedirection):

  • NetworkProcess/PingLoad.h:
  • WebProcess/InjectedBundle/InjectedBundle.cpp:

(WebKit::InjectedBundle::addOriginAccessWhitelistEntry):
(WebKit::InjectedBundle::removeOriginAccessWhitelistEntry):
(WebKit::InjectedBundle::resetOriginAccessWhitelists):

  • WebProcess/Network/WebLoaderStrategy.cpp:

(WebKit::WebLoaderStrategy::startPingLoad):

Location:
trunk/Source
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r230540 r230541  
     12018-04-11  Youenn Fablet  <youenn@apple.com>
     2
     3        Pass FetchOptions and SecurityOrigin as load parameters from WebProcess to NetworkProcess
     4        https://bugs.webkit.org/show_bug.cgi?id=184374
     5
     6        Reviewed by Chris Dumez.
     7
     8        Add support for SecurityOrigin encode/decode routines.
     9
     10        * page/SecurityOrigin.h:
     11
    1122018-04-11  Thibault Saunier  <tsaunier@igalia.com>
    213

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

    r230205 r230541  
    207207    const SecurityOriginData& data() const { return m_data; }
    208208
     209    template<class Encoder> void encode(Encoder&) const;
     210    template<class Decoder> static RefPtr<SecurityOrigin> decode(Decoder&);
     211
    209212private:
    210213    SecurityOrigin();
    … …  
    242245bool originsMatch(const SecurityOrigin*, const SecurityOrigin*);
    243246
     247template<class Encoder> inline void SecurityOrigin::encode(Encoder& encoder) const
     248{
     249    encoder << m_data;
     250    encoder << m_domain;
     251    encoder << m_filePath;
     252    encoder << m_isUnique;
     253    encoder << m_universalAccess;
     254    encoder << m_domainWasSetInDOM;
     255    encoder << m_canLoadLocalResources;
     256    encoder.encodeEnum(m_storageBlockingPolicy);
     257    encoder << m_enforcesFilePathSeparation;
     258    encoder << m_needsStorageAccessFromFileURLsQuirk;
     259    encoder << m_isPotentiallyTrustworthy;
     260    encoder << m_isLocal;
     261}
     262
     263template<class Decoder> inline RefPtr<SecurityOrigin> SecurityOrigin::decode(Decoder& decoder)
     264{
     265    std::optional<SecurityOriginData> data;
     266    decoder >> data;
     267    if (!data)
     268        return nullptr;
     269
     270    auto origin = SecurityOrigin::create(data->protocol, data->host, data->port);
     271
     272    if (!decoder.decode(origin->m_domain))
     273        return nullptr;
     274    if (!decoder.decode(origin->m_filePath))
     275        return nullptr;
     276    if (!decoder.decode(origin->m_isUnique))
     277        return nullptr;
     278    if (!decoder.decode(origin->m_universalAccess))
     279        return nullptr;
     280    if (!decoder.decode(origin->m_domainWasSetInDOM))
     281        return nullptr;
     282    if (!decoder.decode(origin->m_canLoadLocalResources))
     283        return nullptr;
     284    if (!decoder.decodeEnum(origin->m_storageBlockingPolicy))
     285        return nullptr;
     286    if (!decoder.decode(origin->m_enforcesFilePathSeparation))
     287        return nullptr;
     288    if (!decoder.decode(origin->m_needsStorageAccessFromFileURLsQuirk))
     289        return nullptr;
     290    if (!decoder.decode(origin->m_isPotentiallyTrustworthy))
     291        return nullptr;
     292    if (!decoder.decode(origin->m_isLocal))
     293        return nullptr;
     294
     295    return WTFMove(origin);
     296}
     297
    244298} // namespace WebCore

  • trunk/Source/WebKit/ChangeLog

    r230529 r230541  
     12018-04-11  Youenn Fablet  <youenn@apple.com>
     2
     3        Pass FetchOptions and SecurityOrigin as load parameters from WebProcess to NetworkProcess
     4        https://bugs.webkit.org/show_bug.cgi?id=184374
     5
     6        Reviewed by Chris Dumez.
     7
     8        Pass full FetchOptions parameters as part of NetworkResourceLoadParameters.
     9        This will allow handling redirection mode as well as credentials in case of cross origin redirections.
     10        In case of SameOrigin credentials and there is a redirection from same-origin to cross-origin,
     11        we will be able to stop using credentials without going to WebProcess.
     12
     13        To handle properly cross-origin checks, we have to be able to use SecurityOrigin as in WebProcess.
     14        We make WebProcess sends Origin Access White list information to NetworkProcess.
     15        This allows supporting the white list when doing loading in NetworkProcess.
     16        This only works consistently if all WebProcesses share the same whitelist.
     17
     18        * NetworkProcess/NetworkConnectionToWebProcess.cpp:
     19        (WebKit::NetworkConnectionToWebProcess::loadPing):
     20        (WebKit::NetworkConnectionToWebProcess::addOriginAccessWhitelistEntry):
     21        (WebKit::NetworkConnectionToWebProcess::removeOriginAccessWhitelistEntry):
     22        (WebKit::NetworkConnectionToWebProcess::resetOriginAccessWhitelists):
     23        * NetworkProcess/NetworkConnectionToWebProcess.h:
     24        * NetworkProcess/NetworkConnectionToWebProcess.messages.in:
     25        * NetworkProcess/NetworkLoadChecker.cpp:
     26        (WebKit::NetworkLoadChecker::NetworkLoadChecker):
     27        (WebKit::NetworkLoadChecker::checkRedirection):
     28        (WebKit::NetworkLoadChecker::continueCheckingRequest):
     29        (WebKit::NetworkLoadChecker::checkCORSRequest):
     30        (WebKit::NetworkLoadChecker::checkCORSRedirectedRequest):
     31        (WebKit::NetworkLoadChecker::checkCORSRequestWithPreflight):
     32        (WebKit::NetworkLoadChecker::doesNotNeedCORSCheck const):
     33        * NetworkProcess/NetworkLoadChecker.h:
     34        (WebKit::NetworkLoadChecker::create):
     35        * NetworkProcess/NetworkResourceLoadParameters.cpp:
     36        (WebKit::NetworkResourceLoadParameters::encode const):
     37        (WebKit::NetworkResourceLoadParameters::decode):
     38        * NetworkProcess/NetworkResourceLoadParameters.h:
     39        * NetworkProcess/PingLoad.cpp:
     40        (WebKit::PingLoad::PingLoad):
     41        (WebKit::PingLoad::willPerformHTTPRedirection):
     42        * NetworkProcess/PingLoad.h:
     43        * WebProcess/InjectedBundle/InjectedBundle.cpp:
     44        (WebKit::InjectedBundle::addOriginAccessWhitelistEntry):
     45        (WebKit::InjectedBundle::removeOriginAccessWhitelistEntry):
     46        (WebKit::InjectedBundle::resetOriginAccessWhitelists):
     47        * WebProcess/Network/WebLoaderStrategy.cpp:
     48        (WebKit::WebLoaderStrategy::startPingLoad):
     49
    1502018-04-11  Michael Catanzaro  <mcatanzaro@igalia.com>
    251

  • trunk/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp

    r230528 r230541  
    5656#include <WebCore/ResourceLoaderOptions.h>
    5757#include <WebCore/ResourceRequest.h>
     58#include <WebCore/SecurityPolicy.h>
    5859#include <pal/SessionID.h>
    5960
    … …  
    249250}
    250251
    251 void NetworkConnectionToWebProcess::loadPing(NetworkResourceLoadParameters&& loadParameters, HTTPHeaderMap&& originalRequestHeaders)
     252void NetworkConnectionToWebProcess::loadPing(NetworkResourceLoadParameters&& loadParameters)
    252253{
    253254    auto completionHandler = [this, protectedThis = makeRef(*this), identifier = loadParameters.identifier] (const ResourceError& error, const ResourceResponse& response) {
    … …  
    256257
    257258    // PingLoad manages its own lifetime, deleting itself when its purpose has been fulfilled.
    258     new PingLoad(WTFMove(loadParameters), WTFMove(originalRequestHeaders), WTFMove(completionHandler));
     259    new PingLoad(WTFMove(loadParameters), WTFMove(completionHandler));
    259260}
    260261
    … …  
    514515}
    515516
     517void NetworkConnectionToWebProcess::addOriginAccessWhitelistEntry(const String& sourceOrigin, const String& destinationProtocol, const String& destinationHost, bool allowDestinationSubdomains)
     518{
     519    SecurityPolicy::addOriginAccessWhitelistEntry(SecurityOrigin::createFromString(sourceOrigin).get(), destinationProtocol, destinationHost, allowDestinationSubdomains);
     520}
     521
     522void NetworkConnectionToWebProcess::removeOriginAccessWhitelistEntry(const String& sourceOrigin, const String& destinationProtocol, const String& destinationHost, bool allowDestinationSubdomains)
     523{
     524    SecurityPolicy::removeOriginAccessWhitelistEntry(SecurityOrigin::createFromString(sourceOrigin).get(), destinationProtocol, destinationHost, allowDestinationSubdomains);
     525}
     526
     527void NetworkConnectionToWebProcess::resetOriginAccessWhitelists()
     528{
     529    SecurityPolicy::resetOriginAccessWhitelists();
     530}
     531
    516532} // namespace WebKit

  • trunk/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h

    r230528 r230541  
    9393    void scheduleResourceLoad(NetworkResourceLoadParameters&&);
    9494    void performSynchronousLoad(NetworkResourceLoadParameters&&, Ref<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply>&&);
    95     void loadPing(NetworkResourceLoadParameters&&, WebCore::HTTPHeaderMap&& originalRequestHeaders);
     95    void loadPing(NetworkResourceLoadParameters&&);
    9696    void prefetchDNS(const String&);
    9797    void preconnectTo(uint64_t preconnectionIdentifier, NetworkLoadParameters&&);
    … …  
    141141    void removeStorageAccessForAllFramesOnPage(PAL::SessionID, uint64_t pageID);
    142142
     143    void addOriginAccessWhitelistEntry(const String& sourceOrigin, const String& destinationProtocol, const String& destinationHost, bool allowDestinationSubdomains);
     144    void removeOriginAccessWhitelistEntry(const String& sourceOrigin, const String& destinationProtocol, const String& destinationHost, bool allowDestinationSubdomains);
     145    void resetOriginAccessWhitelists();
     146
    143147    Ref<IPC::Connection> m_connection;
    144148

  • trunk/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in

    r226542 r230541  
    2525    ScheduleResourceLoad(WebKit::NetworkResourceLoadParameters resourceLoadParameters)
    2626    PerformSynchronousLoad(WebKit::NetworkResourceLoadParameters resourceLoadParameters) -> (WebCore::ResourceError error, WebCore::ResourceResponse response, Vector<char> data) Delayed
    27     LoadPing(WebKit::NetworkResourceLoadParameters resourceLoadParameters, WebCore::HTTPHeaderMap originalRequestHeaders)
     27    LoadPing(WebKit::NetworkResourceLoadParameters resourceLoadParameters)
    2828    RemoveLoadIdentifier(uint64_t resourceLoadIdentifier)
    2929    SetDefersLoading(uint64_t resourceLoadIdentifier, bool defers)
    … …  
    6161    RemoveStorageAccessForFrame(PAL::SessionID sessionID, uint64_t frameID, uint64_t pageID);
    6262    RemoveStorageAccessForAllFramesOnPage(PAL::SessionID sessionID, uint64_t pageID);
     63
     64    AddOriginAccessWhitelistEntry(String sourceOrigin, String destinationProtocol, String destinationHost, bool allowDestinationSubdomains);
     65    RemoveOriginAccessWhitelistEntry(String sourceOrigin, String destinationProtocol, String destinationHost, bool allowDestinationSubdomains);
     66    ResetOriginAccessWhitelists();
    6367}

  • trunk/Source/WebKit/NetworkProcess/NetworkLoadChecker.cpp

    r230495 r230541  
    4242using namespace WebCore;
    4343
    44 NetworkLoadChecker::NetworkLoadChecker(WebCore::FetchOptions::Mode mode, bool shouldFollowRedirects, WebCore::StoredCredentialsPolicy storedCredentialsPolicy, PAL::SessionID sessionID, WebCore::HTTPHeaderMap&& originalRequestHeaders, URL&& url, RefPtr<SecurityOrigin>&& sourceOrigin)
    45     : m_mode(mode)
    46     , m_shouldFollowRedirects(shouldFollowRedirects)
    47     , m_storedCredentialsPolicy(storedCredentialsPolicy)
     44NetworkLoadChecker::NetworkLoadChecker(WebCore::FetchOptions&& options, PAL::SessionID sessionID, WebCore::HTTPHeaderMap&& originalRequestHeaders, URL&& url, RefPtr<SecurityOrigin>&& sourceOrigin)
     45    : m_options(WTFMove(options))
    4846    , m_sessionID(sessionID)
    4947    , m_originalRequestHeaders(WTFMove(originalRequestHeaders))
    … …  
    5149    , m_origin(WTFMove(sourceOrigin))
    5250{
    53     if (m_mode == FetchOptions::Mode::Cors || m_mode == FetchOptions::Mode::SameOrigin)
    54         m_isSameOriginRequest = m_origin->canRequest(m_url);
     51    if (m_options.mode == FetchOptions::Mode::Cors || m_options.mode == FetchOptions::Mode::SameOrigin)
     52        m_isSameOriginRequest = m_url.protocolIsData() || m_url.protocolIsBlob() || m_origin->canRequest(m_url);
     53    switch (options.credentials) {
     54    case FetchOptions::Credentials::Include:
     55        m_storedCredentialsPolicy = StoredCredentialsPolicy::Use;
     56        break;
     57    case FetchOptions::Credentials::SameOrigin:
     58        m_storedCredentialsPolicy = m_isSameOriginRequest ? StoredCredentialsPolicy::Use : StoredCredentialsPolicy::DoNotUse;
     59        break;
     60    case FetchOptions::Credentials::Omit:
     61        m_storedCredentialsPolicy = StoredCredentialsPolicy::DoNotUse;
     62        break;
     63    }
    5564}
    5665
    … …  
    7887    m_url = request.url();
    7988
    80     if (!m_shouldFollowRedirects) {
     89    if (m_options.redirect != FetchOptions::Redirect::Follow) {
    8190        handler(returnError(ASCIILiteral("Load parameters do not allow following redirections")));
    8291        return;
    … …  
    106115    }
    107116
    108     if (m_mode == FetchOptions::Mode::NoCors) {
     117    if (m_options.mode == FetchOptions::Mode::NoCors) {
    109118        response.setTainting(ResourceResponse::Tainting::Opaque);
    110119        return { };
    111120    }
    112121
    113     ASSERT(m_mode == FetchOptions::Mode::Cors);
     122    ASSERT(m_options.mode == FetchOptions::Mode::Cors);
    114123
    115124    String errorMessage;
    … …  
    146155        if (isRedirected()) {
    147156            URL url = request.url();
    148             auto type = m_mode == FetchOptions::Mode::Navigate ? ContentSecurityPolicy::InsecureRequestType::Navigation : ContentSecurityPolicy::InsecureRequestType::Load;
     157            auto type = m_options.mode == FetchOptions::Mode::Navigate ? ContentSecurityPolicy::InsecureRequestType::Navigation : ContentSecurityPolicy::InsecureRequestType::Load;
    149158            contentSecurityPolicy->upgradeInsecureRequestIfNeeded(url, type);
    150159            if (url != request.url())
    … …  
    157166    }
    158167
     168    if (m_options.credentials == FetchOptions::Credentials::SameOrigin)
     169        m_storedCredentialsPolicy =  (m_isSameOriginRequest && m_origin->canRequest(request.url())) ? StoredCredentialsPolicy::Use : StoredCredentialsPolicy::DoNotUse;
     170
    159171    if (doesNotNeedCORSCheck(request.url())) {
    160172        handler(WTFMove(request));
    … …  
    162174    }
    163175
    164     if (m_mode == FetchOptions::Mode::SameOrigin) {
     176    if (m_options.mode == FetchOptions::Mode::SameOrigin) {
    165177        handler(returnError(ASCIILiteral("SameOrigin mode does not allow cross origin requests")));
    166178        return;
    … …  
    178190void NetworkLoadChecker::checkCORSRequest(ResourceRequest&& request, ValidationHandler&& handler)
    179191{
    180     ASSERT(m_mode == FetchOptions::Mode::Cors);
     192    ASSERT(m_options.mode == FetchOptions::Mode::Cors);
    181193
    182194    // Except in case where preflight is needed, loading should be able to continue on its own.
    … …  
    191203void NetworkLoadChecker::checkCORSRedirectedRequest(ResourceRequest&& request, ValidationHandler&& handler)
    192204{
    193     ASSERT(m_mode == FetchOptions::Mode::Cors);
     205    ASSERT(m_options.mode == FetchOptions::Mode::Cors);
    194206    ASSERT(isRedirected());
    195207
    … …  
    216228void NetworkLoadChecker::checkCORSRequestWithPreflight(ResourceRequest&& request, ValidationHandler&& handler)
    217229{
    218     ASSERT(m_mode == FetchOptions::Mode::Cors);
     230    ASSERT(m_options.mode == FetchOptions::Mode::Cors);
    219231
    220232    m_isSimpleRequest = false;
    … …  
    255267bool NetworkLoadChecker::doesNotNeedCORSCheck(const URL& url) const
    256268{
    257     if (m_mode == FetchOptions::Mode::NoCors || m_mode == FetchOptions::Mode::Navigate)
     269    if (m_options.mode == FetchOptions::Mode::NoCors || m_options.mode == FetchOptions::Mode::Navigate)
    258270        return true;
    259271

  • trunk/Source/WebKit/NetworkProcess/NetworkLoadChecker.h

    r230495 r230541  
    4343class NetworkLoadChecker : public RefCounted<NetworkLoadChecker> {
    4444public:
    45     static Ref<NetworkLoadChecker> create(WebCore::FetchOptions::Mode mode, bool shouldFollowRedirects, WebCore::StoredCredentialsPolicy storedCredentialsPolicy, PAL::SessionID sessionID, WebCore::HTTPHeaderMap&& originalHeaders, WebCore::URL&& url, RefPtr<WebCore::SecurityOrigin>&& sourceOrigin)
     45    static Ref<NetworkLoadChecker> create(WebCore::FetchOptions&& options, PAL::SessionID sessionID, WebCore::HTTPHeaderMap&& originalHeaders, WebCore::URL&& url, RefPtr<WebCore::SecurityOrigin>&& sourceOrigin)
    4646    {
    47         return adoptRef(*new NetworkLoadChecker { mode, shouldFollowRedirects, storedCredentialsPolicy, sessionID, WTFMove(originalHeaders), WTFMove(url), WTFMove(sourceOrigin) });
     47        return adoptRef(*new NetworkLoadChecker { WTFMove(options), sessionID, WTFMove(originalHeaders), WTFMove(url), WTFMove(sourceOrigin) });
    4848    }
    4949    ~NetworkLoadChecker();
    … …  
    6969
    7070private:
    71     NetworkLoadChecker(WebCore::FetchOptions::Mode, bool shouldFollowRedirects, WebCore::StoredCredentialsPolicy, PAL::SessionID, WebCore::HTTPHeaderMap&&, WebCore::URL&&, RefPtr<WebCore::SecurityOrigin>&&);
     71    NetworkLoadChecker(WebCore::FetchOptions&&, PAL::SessionID, WebCore::HTTPHeaderMap&&, WebCore::URL&&, RefPtr<WebCore::SecurityOrigin>&&);
    7272
    7373    WebCore::ContentSecurityPolicy* contentSecurityPolicy() const;
    … …  
    9090#endif
    9191
    92     WebCore::FetchOptions::Mode m_mode;
    93     bool m_shouldFollowRedirects;
     92    WebCore::FetchOptions m_options;
    9493    WebCore::StoredCredentialsPolicy m_storedCredentialsPolicy;
    9594    PAL::SessionID m_sessionID;

  • trunk/Source/WebKit/NetworkProcess/NetworkResourceLoadParameters.cpp

    r230365 r230541  
    8888    encoder << static_cast<bool>(sourceOrigin);
    8989    if (sourceOrigin)
    90         encoder << sourceOrigin->data();
    91     encoder.encodeEnum(mode);
    92     encoder.encodeEnum(destination);
     90        encoder << *sourceOrigin;
     91    encoder << options;
    9392    encoder << cspResponseHeaders;
     93    encoder << originalRequestHeaders;
    9494
    9595#if ENABLE(CONTENT_EXTENSIONS)
    … …  
    172172        return false;
    173173    if (hasSourceOrigin) {
    174         std::optional<SecurityOriginData> sourceOriginData;
    175         decoder >> sourceOriginData;
    176         if (!sourceOriginData)
    177             return false;
    178         ASSERT(!sourceOriginData->isEmpty());
    179         result.sourceOrigin = sourceOriginData->securityOrigin();
    180     }
    181     if (!decoder.decodeEnum(result.mode))
    182         return false;
    183     if (!decoder.decodeEnum(result.destination))
    184         return false;
     174        result.sourceOrigin = SecurityOrigin::decode(decoder);
     175        if (!result.sourceOrigin)
     176            return false;
     177    }
     178
     179    std::optional<FetchOptions> options;
     180    decoder >> options;
     181    if (!options)
     182        return false;
     183    result.options = *options;
     184
    185185    if (!decoder.decode(result.cspResponseHeaders))
     186        return false;
     187    if (!decoder.decode(result.originalRequestHeaders))
    186188        return false;
    187189

  • trunk/Source/WebKit/NetworkProcess/NetworkResourceLoadParameters.h

    r230365 r230541  
    5757    Vector<String> derivedCachedDataTypesToRetrieve;
    5858    RefPtr<WebCore::SecurityOrigin> sourceOrigin;
    59     WebCore::FetchOptions::Mode mode;
    60     WebCore::FetchOptions::Destination destination;
     59    WebCore::FetchOptions options;
    6160    std::optional<WebCore::ContentSecurityPolicyResponseHeaders> cspResponseHeaders;
     61    WebCore::HTTPHeaderMap originalRequestHeaders;
    6262    bool shouldRestrictHTTPResponseAccess { false };
    6363

  • trunk/Source/WebKit/NetworkProcess/NetworkResourceLoader.cpp

    r230528 r230541  
    473473            // FIXME: We should use response tainting once computed in Network Process.
    474474            bool isSameOrigin = m_parameters.sourceOrigin ? m_parameters.sourceOrigin->canRequest(response.url()) : protocolHostAndPortAreEqual(response.url(), m_parameters.request.url());
    475             if (isSameOrigin && m_parameters.destination == FetchOptions::Destination::EmptyString)
     475            if (isSameOrigin && m_parameters.options.destination == FetchOptions::Destination::EmptyString)
    476476                type = ResourceResponse::SanitizationType::RemoveCookies;
    477477        }

  • trunk/Source/WebKit/NetworkProcess/PingLoad.cpp

    r230495 r230541  
    3939using namespace WebCore;
    4040
    41 PingLoad::PingLoad(NetworkResourceLoadParameters&& parameters, HTTPHeaderMap&& originalRequestHeaders, WTF::CompletionHandler<void(const ResourceError&, const ResourceResponse&)>&& completionHandler)
     41PingLoad::PingLoad(NetworkResourceLoadParameters&& parameters, WTF::CompletionHandler<void(const ResourceError&, const ResourceResponse&)>&& completionHandler)
    4242    : m_parameters(WTFMove(parameters))
    4343    , m_completionHandler(WTFMove(completionHandler))
    4444    , m_timeoutTimer(*this, &PingLoad::timeoutTimerFired)
    45     , m_networkLoadChecker(NetworkLoadChecker::create(m_parameters.mode, m_parameters.shouldFollowRedirects, m_parameters.storedCredentialsPolicy, m_parameters.sessionID, WTFMove(originalRequestHeaders), URL { m_parameters.request.url() }, m_parameters.sourceOrigin.copyRef()))
     45    , m_networkLoadChecker(NetworkLoadChecker::create(FetchOptions { m_parameters.options}, m_parameters.sessionID, WTFMove(m_parameters.originalRequestHeaders), URL { m_parameters.request.url() }, m_parameters.sourceOrigin.copyRef()))
    4646{
    4747

  • trunk/Source/WebKit/NetworkProcess/PingLoad.h

    r230223 r230541  
    4545class PingLoad final : private NetworkDataTaskClient {
    4646public:
    47     PingLoad(NetworkResourceLoadParameters&&, WebCore::HTTPHeaderMap&& originalRequestHeaders, WTF::CompletionHandler<void(const WebCore::ResourceError&, const WebCore::ResourceResponse&)>&&);
     47    PingLoad(NetworkResourceLoadParameters&&, WTF::CompletionHandler<void(const WebCore::ResourceError&, const WebCore::ResourceResponse&)>&&);
    4848   
    4949private:

  • trunk/Source/WebKit/WebProcess/InjectedBundle/InjectedBundle.cpp

    r230290 r230541  
    3030#include "APIData.h"
    3131#include "InjectedBundleScriptWorld.h"
     32#include "NetworkConnectionToWebProcessMessages.h"
     33#include "NetworkProcessConnection.h"
    3234#include "NetworkSessionCreationParameters.h"
    3335#include "NotificationPermissionRequestManager.h"
    … …  
    376378{
    377379    SecurityPolicy::addOriginAccessWhitelistEntry(SecurityOrigin::createFromString(sourceOrigin).get(), destinationProtocol, destinationHost, allowDestinationSubdomains);
     380    WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::AddOriginAccessWhitelistEntry { sourceOrigin, destinationProtocol, destinationHost, allowDestinationSubdomains }, 0);
     381
    378382}
    379383
    … …  
    381385{
    382386    SecurityPolicy::removeOriginAccessWhitelistEntry(SecurityOrigin::createFromString(sourceOrigin).get(), destinationProtocol, destinationHost, allowDestinationSubdomains);
     387    WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::RemoveOriginAccessWhitelistEntry { sourceOrigin, destinationProtocol, destinationHost, allowDestinationSubdomains }, 0);
    383388}
    384389
    … …  
    386391{
    387392    SecurityPolicy::resetOriginAccessWhitelists();
     393    WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::ResetOriginAccessWhitelists { }, 0);
    388394}
    389395

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

    r230365 r230541  
    274274    loadParameters.maximumBufferingTime = maximumBufferingTime;
    275275    loadParameters.derivedCachedDataTypesToRetrieve = resourceLoader.options().derivedCachedDataTypesToRetrieve;
    276     loadParameters.destination = resourceLoader.options().destination;
     276    loadParameters.options = resourceLoader.options();
    277277
    278278    // FIXME: We should also sanitize redirect response for navigations.
    … …  
    435435    loadParameters.shouldRestrictHTTPResponseAccess = RuntimeEnabledFeatures::sharedFeatures().restrictedHTTPResponseAccess();
    436436    // FIXME: Use the proper destination once all fetch options are passed.
    437     loadParameters.destination = FetchOptions::Destination::EmptyString;
     437    loadParameters.options.destination = FetchOptions::Destination::EmptyString;
    438438
    439439    data.shrink(0);
    … …  
    471471    loadParameters.sessionID = frame.page() ? frame.page()->sessionID() : PAL::SessionID::defaultSessionID();
    472472    loadParameters.storedCredentialsPolicy = options.credentials == FetchOptions::Credentials::Omit ? StoredCredentialsPolicy::DoNotUse : StoredCredentialsPolicy::Use;
    473     loadParameters.mode = options.mode;
    474     loadParameters.shouldFollowRedirects = options.redirect == FetchOptions::Redirect::Follow;
     473    loadParameters.options = options;
     474    loadParameters.originalRequestHeaders = originalRequestHeaders;
    475475    loadParameters.shouldClearReferrerOnHTTPSToHTTPRedirect = shouldClearReferrerOnHTTPSToHTTPRedirect(&frame);
    476476    loadParameters.shouldRestrictHTTPResponseAccess = RuntimeEnabledFeatures::sharedFeatures().restrictedHTTPResponseAccess();
    … …  
    493493        m_pingLoadCompletionHandlers.add(loadParameters.identifier, WTFMove(completionHandler));
    494494
    495     WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::LoadPing(WTFMove(loadParameters), originalRequestHeaders), 0);
     495    WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::LoadPing { loadParameters }, 0);
    496496}
    497497
    … …  
    533533    parameters.shouldRestrictHTTPResponseAccess = RuntimeEnabledFeatures::sharedFeatures().restrictedHTTPResponseAccess();
    534534    // FIXME: Use the proper destination once all fetch options are passed.
    535     parameters.destination = FetchOptions::Destination::EmptyString;
     535    parameters.options.destination = FetchOptions::Destination::EmptyString;
    536536
    537537    WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::PreconnectTo(preconnectionIdentifier, WTFMove(parameters)), 0);
Note: See TracChangeset for help on using the changeset viewer.