ChangeLog

2021-09-27  Chris Dumez  <cdumez@apple.com>

        Move Cross-Origin-Opener-Policy handling to the NetworkProcess

        https://bugs.webkit.org/show_bug.cgi?id=230812

        <rdar://83504842>

        Reviewed by NOBODY (OOPS!).

        Previous, COOP handling was fully implemented in the WebContent process. This meant that a

        WebProcess for origin A could get a network response with COOP header from origin B, decide

        that cross-origin isolation is needed and ask the UIProcess to process-swap. This was not a

        good design given that the WebContent process is not a trusted process. We should not trust

        the WebProcess for origin A to make the swap on behavior of origin B. Also, the network

        response from origin B may contain sensitive headers that we don't want origin A's WebProcess

        to see.

        To address these issues, I have moved COOP handling from the WebContent process to the

        NetworkProcess. As soon as the NetworkProcess gets the network response, it makes the decision

        whether or not cross-origin isolation is needed. If isolation is needed, the network process

        asks the UIProcess directly to continue the load in a new WebProcess instead of sending the

        network response to the currently associated WebProcess. When the new WebProcess resumes the

        load, the network process sends it the network response it already has.

        I moved most of the COOP specification implementation from DocumentLoader.cpp/h to

        CrossOriginOpenerPolicy.cpp/h so that we can leverage it from the NetworkResourceLoader in

        the network process. We still have to do *some* COOP handling at DocumentLoader level

        currently for non-initial navigations to about:blank given that those can trigger a browsing

        context group switch but currently do not involved the network process. I also had to add

        more information to NetworkResourceLoadParameters so that we are able to make appropriate

        COOP decisions in the NetworkProcess.

        No new tests, covered by existing COOP tests that are still passing.

        * Headers.cmake:

        * Sources.txt:

        * WebCore.xcodeproj/project.pbxproj:

        * dom/Document.h:

        * loader/CrossOriginOpenerPolicy.cpp:

        (WebCore::checkIfCOOPValuesRequireBrowsingContextGroupSwitch):

        (WebCore::checkIfEnforcingReportOnlyCOOPWouldRequireBrowsingContextGroupSwitch):

        (WebCore::computeResponseOriginAndCOOP):

        (WebCore::enforceResponseCrossOriginOpenerPolicy):

        (WebCore::obtainCrossOriginOpenerPolicy):

        (WebCore::sendViolationReportWhenNavigatingToCOOPResponse):

        (WebCore::sendViolationReportWhenNavigatingAwayFromCOOPResponse):

        (WebCore::doCrossOriginOpenerHandlingOfResponse):

        (WebCore::CrossOriginOpenerPolicyEnforcementResult::from):

        * loader/CrossOriginOpenerPolicy.h:

        (WebCore::CrossOriginOpenerPolicy::reportingEndpointForDisposition const):

        (WebCore::CrossOriginOpenerPolicy::hasReportingEndpoint const):

        * loader/DocumentLoader.cpp:

        (WebCore::DocumentLoader::willSendRequest):

        (WebCore::DocumentLoader::doCrossOriginOpenerHandlingOfResponse):

        (WebCore::DocumentLoader::responseReceived):

        (WebCore::DocumentLoader::maybeLoadEmpty):

        (WebCore::DocumentLoader::clearMainResource):

        * loader/DocumentLoader.h:

        (WebCore::DocumentLoader::crossOriginOpenerPolicy const):

        (WebCore::DocumentLoader::isContinuingLoadAfterProvisionalLoadStarted const):

        (WebCore::DocumentLoader::setIsContinuingLoadAfterProvisionalLoadStarted):

        Move most of the COOP logic from DocumentLoader.cpp to CrossOriginOpenerPolicy.cpp, so that

        it can be reused by NetworkResourceLoader in the network process.

        * loader/EmptyClients.cpp:

        (WebCore::EmptyFrameLoaderClient::dispatchDecidePolicyForResponse):

        * loader/EmptyFrameLoaderClient.h:

        * loader/FrameLoader.cpp:

        (WebCore::FrameLoader::checkContentPolicy):

        (WebCore::FrameLoader::load):

        * loader/FrameLoader.h:

        * loader/FrameLoaderClient.h:

        * loader/NavigationAction.cpp:

        (WebCore::NavigationAction::NavigationAction):

        * loader/NavigationAction.h:

        (WebCore::NavigationAction::requester const):

        (WebCore::NavigationAction::isEmpty const):

        * loader/NavigationRequester.cpp: Added.

        * loader/NavigationRequester.h: Added.

        Extracted NavigationAction::Requester to its own header and rename it to NavigationRequester,

        so that its implementation can be shared between NavigationAction, NetworkResourceLoadParameters

        and COOP.

        * loader/ReportingEndpointsCache.cpp:

        (WebCore::ReportingEndpointsCache::addEndPointsFromResponse):

        (WebCore::ReportingEndpointsCache::addEndPointsFromReportToHeader):

        * loader/ReportingEndpointsCache.h:

        * loader/ShouldTreatAsContinuingLoad.h:

        * page/Page.h:

2021-09-24  Alan Bujtas  <zalan@apple.com>

        [LFC][IFC] Line::Run only needs a handful of style properties

Source/WebKit/ChangeLog

2021-09-27  Chris Dumez  <cdumez@apple.com>

        Move Cross-Origin-Opener-Policy handling to the NetworkProcess

        https://bugs.webkit.org/show_bug.cgi?id=230812

        <rdar://83504842>

        Reviewed by NOBODY (OOPS!).

        Implement COOP handling in the NetworkProcess, inside the NetworkResourceLoader class.

        This was logic that was currently implemented at DocumentLoader-level, in the WebProcess.

        * NetworkProcess/NetworkProcess.cpp:

        * NetworkProcess/NetworkProcess.h:

        * NetworkProcess/NetworkProcess.messages.in:

        * NetworkProcess/NetworkResourceLoadParameters.cpp:

        (WebKit::NetworkResourceLoadParameters::encode const):

        (WebKit::NetworkResourceLoadParameters::decode):

        * NetworkProcess/NetworkResourceLoadParameters.h:

        * NetworkProcess/NetworkResourceLoader.cpp:

        (WebKit::NetworkResourceLoader::doCrossOriginOpenerHandlingOfResponse):

        (WebKit::toBrowsingContextGroupSwitchDecision):

        (WebKit::NetworkResourceLoader::didReceiveResponse):

        (WebKit::NetworkResourceLoader::sendDidReceiveResponsePotentiallyInNewBrowsingContextGroup):

        (WebKit::NetworkResourceLoader::willSendRedirectedRequest):

        (WebKit::NetworkResourceLoader::didRetrieveCacheEntry):

        * NetworkProcess/NetworkResourceLoader.h:

        * NetworkProcess/ServiceWorker/ServiceWorkerFetchTask.cpp:

        (WebKit::ServiceWorkerFetchTask::didReceiveResponse):

        * Scripts/webkit/messages.py:

        (types_that_cannot_be_forward_declared):

        (headers_for_type):

        * UIProcess/Network/NetworkProcessProxy.cpp:

        (WebKit::NetworkProcessProxy::triggerBrowsingContextGroupSwitchForNavigation):

        * UIProcess/Network/NetworkProcessProxy.h:

        * UIProcess/Network/NetworkProcessProxy.messages.in:

        * UIProcess/ProvisionalPageProxy.cpp:

        (WebKit::ProvisionalPageProxy::decidePolicyForResponse):

        * UIProcess/ProvisionalPageProxy.h:

        * UIProcess/WebPageProxy.cpp:

        (WebKit::WebPageProxy::continueNavigationInNewProcess):

        (WebKit::WebPageProxy::decidePolicyForResponse):

        (WebKit::WebPageProxy::decidePolicyForResponseShared):

        (WebKit::WebPageProxy::triggerBrowsingContextGroupSwitchForNavigation):

        * UIProcess/WebPageProxy.h:

        * UIProcess/WebPageProxy.messages.in:

        * WebProcess/Network/WebLoaderStrategy.cpp:

        (WebKit::WebLoaderStrategy::scheduleLoadFromNetworkProcess):

        * WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:

        (WebKit::WebFrameLoaderClient::dispatchDidStartProvisionalLoad):

        (WebKit::WebFrameLoaderClient::dispatchDecidePolicyForResponse):

        (WebKit::WebFrameLoaderClient::dispatchDecidePolicyForNavigationAction):

        * WebProcess/WebCoreSupport/WebFrameLoaderClient.h:

        * WebProcess/WebPage/WebPage.cpp:

        (WebKit::WebPage::sendViolationReportWhenNavigatingToCOOPResponse):

        (WebKit::WebPage::sendViolationReportWhenNavigatingAwayFromCOOPResponse):

        * WebProcess/WebPage/WebPage.h:

        * WebProcess/WebPage/WebPage.messages.in:

2021-09-24  Per Arne Vollan  <pvollan@apple.com>

        Remove directory rule from sandboxes

Source/WebKitLegacy/mac/ChangeLog

2021-09-27  Chris Dumez  <cdumez@apple.com>

        Move Cross-Origin-Opener-Policy handling to the NetworkProcess

        https://bugs.webkit.org/show_bug.cgi?id=230812

        <rdar://83504842>

        Reviewed by NOBODY (OOPS!).

        * WebCoreSupport/WebFrameLoaderClient.h:

        * WebCoreSupport/WebFrameLoaderClient.mm:

        (WebFrameLoaderClient::dispatchDecidePolicyForResponse):

2021-09-23  Tim Horton  <timothy_horton@apple.com>

        Move more linked-on-or-after checks to WebCore::linkedOnOrAfter()

Source/WebKitLegacy/win/ChangeLog

2021-09-27  Chris Dumez  <cdumez@apple.com>

        Move Cross-Origin-Opener-Policy handling to the NetworkProcess

        https://bugs.webkit.org/show_bug.cgi?id=230812

        <rdar://83504842>

        Reviewed by NOBODY (OOPS!).

        * WebCoreSupport/WebFrameLoaderClient.cpp:

        (WebFrameLoaderClient::dispatchDecidePolicyForResponse):

        * WebCoreSupport/WebFrameLoaderClient.h:

2021-09-17  Alex Christensen  <achristensen@webkit.org>

        Use ObjectIdentifier for ResourceLoader

Source/WebCore/Headers.cmake

@@set(WebCore_PRIVATE_FRAMEWORK_HEADERS

    loader/MediaResourceLoader.h

    loader/MixedContentChecker.h

    loader/NavigationAction.h

834 loader/NavigationRequester.h

    loader/NetscapePlugInStreamLoader.h

    loader/PingLoader.h

    loader/PolicyChecker.h

Source/WebCore/Sources.txt

@@loader/LoaderStrategy.cpp

loader/MediaResourceLoader.cpp

loader/MixedContentChecker.cpp

loader/NavigationAction.cpp

1563loader/NavigationRequester.cpp

loader/NavigationScheduler.cpp

loader/NetscapePlugInStreamLoader.cpp

loader/PingLoader.cpp

Source/WebCore/WebCore.xcodeproj/project.pbxproj

		468344E01EDDFAAA00B7795B /* DOMRectList.h in Headers */ = {isa = PBXBuildFile; fileRef = 468344DE1EDDFA5F00B7795B /* DOMRectList.h */; settings = {ATTRIBUTES = (Private, ); }; };

		4688EE3C26DD2610002AF5C4 /* CrossOriginMode.h in Headers */ = {isa = PBXBuildFile; fileRef = 4688EE3A26DD260C002AF5C4 /* CrossOriginMode.h */; settings = {ATTRIBUTES = (Private, ); }; };

		469CCCFE269D021C006E0314 /* BroadcastChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 469CCCFC269D0202006E0314 /* BroadcastChannel.h */; settings = {ATTRIBUTES = (Private, ); }; };

1326 469D77B82701625100142FA6 /* NavigationRequester.h in Headers */ = {isa = PBXBuildFile; fileRef = 469D77B62701625000142FA6 /* NavigationRequester.h */; settings = {ATTRIBUTES = (Private, ); }; };

		46AAAA3D25D3632000BAF42F /* AudioFileReaderCocoa.h in Headers */ = {isa = PBXBuildFile; fileRef = 46AAAA3A25D3631400BAF42F /* AudioFileReaderCocoa.h */; };

		46B63F6C1C6E8D19002E914B /* JSEventTargetCustom.h in Headers */ = {isa = PBXBuildFile; fileRef = 46B63F6B1C6E8CDF002E914B /* JSEventTargetCustom.h */; settings = {ATTRIBUTES = (Private, ); }; };

		46B650DD2296262700FD8AA4 /* PageIdentifier.h in Headers */ = {isa = PBXBuildFile; fileRef = 46B650DB2296262700FD8AA4 /* PageIdentifier.h */; settings = {ATTRIBUTES = (Private, ); }; };

		469CCCFA269D0202006E0314 /* BroadcastChannel.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = BroadcastChannel.cpp; sourceTree = "<group>"; };

		469CCCFC269D0202006E0314 /* BroadcastChannel.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = BroadcastChannel.h; sourceTree = "<group>"; };

		469CCCFD269D0203006E0314 /* BroadcastChannel.idl */ = {isa = PBXFileReference; lastKnownFileType = text; path = BroadcastChannel.idl; sourceTree = "<group>"; };

8467 469D77B62701625000142FA6 /* NavigationRequester.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NavigationRequester.h; sourceTree = "<group>"; };

84668468 46AAAA3A25D3631400BAF42F /* AudioFileReaderCocoa.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AudioFileReaderCocoa.h; sourceTree = "<group>"; };

84678469 46AAAA3C25D3631400BAF42F /* AudioFileReaderCocoa.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AudioFileReaderCocoa.cpp; sourceTree = "<group>"; };

8470 46ACD8112701656A00EF8CED /* NavigationRequester.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = NavigationRequester.cpp; sourceTree = "<group>"; };

		46B63F6B1C6E8CDF002E914B /* JSEventTargetCustom.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSEventTargetCustom.h; sourceTree = "<group>"; };

		46B650DB2296262700FD8AA4 /* PageIdentifier.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PageIdentifier.h; sourceTree = "<group>"; };

		46B8593A2616720C0019EDC6 /* ScriptBufferSourceProvider.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ScriptBufferSourceProvider.h; sourceTree = "<group>"; };

				93CCF05F0AF6CA7600018E89 /* NavigationAction.cpp */,

				93CCF0260AF6C52900018E89 /* NavigationAction.h */,

				9BA827781F06156500F71E75 /* NavigationDisabler.h */,

27795 46ACD8112701656A00EF8CED /* NavigationRequester.cpp */,

27796 469D77B62701625000142FA6 /* NavigationRequester.h */,

				979F43D11075E44A0000F83B /* NavigationScheduler.cpp */,

				979F43D21075E44A0000F83B /* NavigationScheduler.h */,

				93E227DD0AF589AD00D48324 /* NetscapePlugInStreamLoader.cpp */,

				83B2D1751B8BCD6A00A02E47 /* NativeNodeFilter.h in Headers */,

				E10B9B6C0B747599003ED890 /* NativeXPathNSResolver.h in Headers */,

				93CCF0270AF6C52900018E89 /* NavigationAction.h in Headers */,

34225 469D77B82701625100142FA6 /* NavigationRequester.h in Headers */,

				979F43D41075E44A0000F83B /* NavigationScheduler.h in Headers */,

				A9C6E5A60D746458006442E9 /* Navigator.h in Headers */,

				E12719C70EEEC16800F61213 /* NavigatorBase.h in Headers */,

Source/WebCore/dom/Document.h

@@public:

    bool isSameOriginAsTopDocument() const { return securityOrigin().isSameOriginAs(topOrigin()); }

    bool shouldForceNoOpenerBasedOnCOOP() const;

1370 const CrossOriginOpenerPolicy& crossOriginOpenerPolicy() const final;

1370 WEBCORE_EXPORT const CrossOriginOpenerPolicy& crossOriginOpenerPolicy() const final;

    void setCrossOriginOpenerPolicy(const CrossOriginOpenerPolicy&);

    void willLoadScriptElement(const URL&);

Source/WebCore/loader/CrossOriginOpenerPolicy.cpp

#include "config.h"

#include "CrossOriginOpenerPolicy.h"

29#include "ContentSecurityPolicy.h"

#include "CrossOriginEmbedderPolicy.h"

#include "FormData.h"

#include "Frame.h"

#include "HTTPHeaderNames.h"

#include "HTTPParsers.h"

35#include "NavigationRequester.h"

#include "Page.h"

#include "PingLoader.h"

#include "ResourceResponse.h"

@@static ASCIILiteral crossOriginOpenerPolicyValueToEffectivePolicyString(CrossOri

    return "unsafe-none"_s;

}

// https://html.spec.whatwg.org/multipage/origin.html#check-browsing-context-group-switch-coop-value

static bool checkIfCOOPValuesRequireBrowsingContextGroupSwitch(bool isInitialAboutBlank, CrossOriginOpenerPolicyValue activeDocumentCOOPValue, const SecurityOrigin& activeDocumentNavigationOrigin, CrossOriginOpenerPolicyValue responseCOOPValue, const SecurityOrigin& responseOrigin)

{

    // If the result of matching activeDocumentCOOPValue, activeDocumentNavigationOrigin, responseCOOPValue, and responseOrigin is true, return false.

    // https://html.spec.whatwg.org/multipage/origin.html#matching-coop

    if (activeDocumentCOOPValue == CrossOriginOpenerPolicyValue::UnsafeNone && responseCOOPValue == CrossOriginOpenerPolicyValue::UnsafeNone)

        return false;

    if (activeDocumentCOOPValue == responseCOOPValue && activeDocumentNavigationOrigin.isSameOriginAs(responseOrigin))

        return false;

    // If all of the following are true:

    // - isInitialAboutBlank,

    // - activeDocumentCOOPValue's value is "same-origin-allow-popups".

    // - responseCOOPValue is "unsafe-none",

    // then return false.

    if (isInitialAboutBlank && activeDocumentCOOPValue == CrossOriginOpenerPolicyValue::SameOriginAllowPopups && responseCOOPValue == CrossOriginOpenerPolicyValue::UnsafeNone)

        return false;

    return true;

}

// https://html.spec.whatwg.org/multipage/origin.html#check-bcg-switch-navigation-report-only

static bool checkIfEnforcingReportOnlyCOOPWouldRequireBrowsingContextGroupSwitch(bool isInitialAboutBlank, const CrossOriginOpenerPolicy& activeDocumentCOOP, const SecurityOrigin& activeDocumentNavigationOrigin, const CrossOriginOpenerPolicy& responseCOOP, const SecurityOrigin& responseOrigin)

{

    if (!checkIfCOOPValuesRequireBrowsingContextGroupSwitch(isInitialAboutBlank, activeDocumentCOOP.reportOnlyValue, activeDocumentNavigationOrigin, responseCOOP.reportOnlyValue, responseOrigin))

        return false;

    if (checkIfCOOPValuesRequireBrowsingContextGroupSwitch(isInitialAboutBlank, activeDocumentCOOP.reportOnlyValue, activeDocumentNavigationOrigin, responseCOOP.value, responseOrigin))

        return true;

    if (checkIfCOOPValuesRequireBrowsingContextGroupSwitch(isInitialAboutBlank, activeDocumentCOOP.value, activeDocumentNavigationOrigin, responseCOOP.reportOnlyValue, responseOrigin))

        return true;

    return false;

}

static std::tuple<Ref<SecurityOrigin>, CrossOriginOpenerPolicy> computeResponseOriginAndCOOP(const ResourceResponse& response, const std::optional<NavigationRequester>& requester, ContentSecurityPolicy* responseCSP)

{

    // Non-initial empty documents (about:blank) should inherit their cross-origin-opener-policy from the navigation's initiator top level document,

    // if the initiator and its top level document are same-origin, or default (unsafe-none) otherwise.

    // https://github.com/whatwg/html/issues/6913

    if (SecurityPolicy::shouldInheritSecurityOriginFromOwner(response.url()) && requester)

        return std::make_tuple(requester->securityOrigin, requester->securityOrigin->isSameOriginAs(requester->topOrigin) ? requester->crossOriginOpenerPolicy : CrossOriginOpenerPolicy { });

    // If the HTTP response contains a CSP header, it may set sandbox flags, which would cause the origin to become unique.

    auto responseOrigin = responseCSP && responseCSP->sandboxFlags() != SandboxNone ? SecurityOrigin::createUnique() : SecurityOrigin::create(response.url());

    return std::make_tuple(WTFMove(responseOrigin), obtainCrossOriginOpenerPolicy(response));

}

// https://html.spec.whatwg.org/multipage/origin.html#coop-enforce

static CrossOriginOpenerPolicyEnforcementResult enforceResponseCrossOriginOpenerPolicy(const CrossOriginOpenerPolicyEnforcementResult& currentCoopEnforcementResult, const URL& responseURL, SecurityOrigin& responseOrigin, const CrossOriginOpenerPolicy& responseCOOP, bool isDisplayingInitialEmptyDocument, const Function<void(COOPDisposition)>& sendViolationReports)

{

    CrossOriginOpenerPolicyEnforcementResult newCOOPEnforcementResult = {

        responseURL,

        responseOrigin,

        responseCOOP,

        true /* isCurrentContextNavigationSource */,

        currentCoopEnforcementResult.needsBrowsingContextGroupSwitch,

        currentCoopEnforcementResult.needsBrowsingContextGroupSwitchDueToReportOnly

    };

    if (checkIfCOOPValuesRequireBrowsingContextGroupSwitch(isDisplayingInitialEmptyDocument, currentCoopEnforcementResult.crossOriginOpenerPolicy.value, currentCoopEnforcementResult.currentOrigin, responseCOOP.value, responseOrigin)) {

        newCOOPEnforcementResult.needsBrowsingContextGroupSwitch = true;

        sendViolationReports(COOPDisposition::Enforce);

    }

    if (checkIfEnforcingReportOnlyCOOPWouldRequireBrowsingContextGroupSwitch(isDisplayingInitialEmptyDocument, currentCoopEnforcementResult.crossOriginOpenerPolicy, currentCoopEnforcementResult.currentOrigin, responseCOOP, responseOrigin)) {

        newCOOPEnforcementResult.needsBrowsingContextGroupSwitchDueToReportOnly = true;

        sendViolationReports(COOPDisposition::Reporting);

    }

    return newCOOPEnforcementResult;

}

71147// https://html.spec.whatwg.org/multipage/origin.html#obtain-coop

72 CrossOriginOpenerPolicy obtainCrossOriginOpenerPolicy(const ResourceResponse& response~~, const ScriptExecutionContext& context~~)

148CrossOriginOpenerPolicy obtainCrossOriginOpenerPolicy(const ResourceResponse& response)

73149{

74150 std::optional<CrossOriginEmbedderPolicy> coep;

75 auto ensureCOEP = [&coep, &response~~, &context~~]() -> CrossOriginEmbedderPolicy& {

151 auto ensureCOEP = [&coep, &response]() -> CrossOriginEmbedderPolicy& {

76152 if (!coep)

77 coep = obtainCrossOriginEmbedderPolicy(response, ~~&co~~n~~text~~);

153 coep = obtainCrossOriginEmbedderPolicy(response, nullptr);

        return *coep;

    };

    auto parseCOOP = [&response, &ensureCOEP](HTTPHeaderName headerName, auto& value, auto& reportingEndpoint) {

@@CrossOriginOpenerPolicy obtainCrossOriginOpenerPolicy(const ResourceResponse& re

    };

    CrossOriginOpenerPolicy policy;

98 if (~~!context.settingsValues().crossOriginOpenerPolicyEnabled ||~~ !SecurityOrigin::create(response.url())->isPotentiallyTrustworthy())

174 if (!SecurityOrigin::create(response.url())->isPotentiallyTrustworthy())

        return policy;

    parseCOOP(HTTPHeaderName::CrossOriginOpenerPolicy, policy.value, policy.reportingEndpoint);

@@void addCrossOriginOpenerPolicyHeaders(ResourceResponse& response, const CrossOr

// https://html.spec.whatwg.org/multipage/origin.html#coop-violation-navigation-to

void sendViolationReportWhenNavigatingToCOOPResponse(Frame& frame, CrossOriginOpenerPolicy coop, COOPDisposition disposition, const URL& coopURL, const URL& previousResponseURL, const SecurityOrigin& coopOrigin, const SecurityOrigin& previousResponseOrigin, const String& referrer, const String& userAgent)

{

135 auto& endpoint = ~~disposition == COOPDisposition::Reporting ? coop.reportOnlyReportingEndpoint :~~ coop.reportingEndpoint;

211 auto& endpoint = coop.reportingEndpointForDisposition(disposition);

    if (endpoint.isEmpty())

        return;

@@void sendViolationReportWhenNavigatingToCOOPResponse(Frame& frame, CrossOriginOp

// https://html.spec.whatwg.org/multipage/origin.html#coop-violation-navigation-from

void sendViolationReportWhenNavigatingAwayFromCOOPResponse(Frame& frame, CrossOriginOpenerPolicy coop, COOPDisposition disposition, const URL& coopURL, const URL& nextResponseURL, const SecurityOrigin& coopOrigin, const SecurityOrigin& nextResponseOrigin, bool isCOOPResponseNavigationSource, const String& userAgent)

{

151 auto& endpoint = ~~disposition == COOPDisposition::Reporting ? coop.reportOnlyReportingEndpoint :~~ coop.reportingEndpoint;

227 auto& endpoint = coop.reportingEndpointForDisposition(disposition);

    if (endpoint.isEmpty())

        return;

@@void sendViolationReportWhenNavigatingAwayFromCOOPResponse(Frame& frame, CrossOr

    });

}

// https://html.spec.whatwg.org/multipage/browsing-the-web.html#process-a-navigate-fetch (Step 12.5.6)

std::optional<CrossOriginOpenerPolicyEnforcementResult> doCrossOriginOpenerHandlingOfResponse(const ResourceResponse& response, const std::optional<NavigationRequester>& requester, ContentSecurityPolicy* responseCSP, SandboxFlags effectiveSandboxFlags, bool isDisplayingInitialEmptyDocument, const CrossOriginOpenerPolicyEnforcementResult& currentCoopEnforcementResult, const Function<void(COOPDisposition disposition, const CrossOriginOpenerPolicy& responseCOOP, const SecurityOrigin& responseOrigin)>& sendViolationReports)

{

    auto [responseOrigin, responseCOOP] = computeResponseOriginAndCOOP(response, requester, responseCSP);

    // https://html.spec.whatwg.org/multipage/browsing-the-web.html#process-a-navigate-fetch (Step 12.5.6.2)

    // If sandboxFlags is not empty and responseCOOP's value is not "unsafe-none", then set response to an appropriate network error and break.

    if (responseCOOP.value != CrossOriginOpenerPolicyValue::UnsafeNone && effectiveSandboxFlags != SandboxNone)

        return std::nullopt;

    return enforceResponseCrossOriginOpenerPolicy(currentCoopEnforcementResult, response.url(), responseOrigin, responseCOOP, isDisplayingInitialEmptyDocument, [&, responseOrigin = responseOrigin, responseCOOP = responseCOOP](COOPDisposition disposition) {

        sendViolationReports(disposition, responseCOOP, responseOrigin);

    });

}

CrossOriginOpenerPolicyEnforcementResult CrossOriginOpenerPolicyEnforcementResult::from(const URL& currentURL, Ref<SecurityOrigin>&& currentOrigin, const CrossOriginOpenerPolicy& crossOriginOpenerPolicy, std::optional<NavigationRequester> requester, const URL& openerURL)

{

    CrossOriginOpenerPolicyEnforcementResult result { currentURL, WTFMove(currentOrigin), crossOriginOpenerPolicy };

    result.isCurrentContextNavigationSource = requester && result.currentOrigin->isSameOriginAs(requester->securityOrigin);

    if (SecurityPolicy::shouldInheritSecurityOriginFromOwner(currentURL) && openerURL.isValid())

        result.url = openerURL;

    return result;

}

163263} // namespace WebCore

Source/WebCore/loader/CrossOriginOpenerPolicy.h

namespace WebCore {

34class ContentSecurityPolicy;

class ResourceResponse;

class ScriptExecutionContext;

struct NavigationRequester;

typedef int SandboxFlags;

// https://html.spec.whatwg.org/multipage/origin.html#cross-origin-opener-policy-value

enum class CrossOriginOpenerPolicyValue : uint8_t {

    UnsafeNone,

@@enum class CrossOriginOpenerPolicyValue : uint8_t {

    SameOriginAllowPopups

};

50enum class COOPDisposition : bool { Reporting , Enforce };

51

// https://html.spec.whatwg.org/multipage/origin.html#cross-origin-opener-policy

struct CrossOriginOpenerPolicy {

    CrossOriginOpenerPolicyValue value { CrossOriginOpenerPolicyValue::UnsafeNone };

@@struct CrossOriginOpenerPolicy {

    CrossOriginOpenerPolicyValue reportOnlyValue { CrossOriginOpenerPolicyValue::UnsafeNone };

    String reportOnlyReportingEndpoint;

    const String& reportingEndpointForDisposition(COOPDisposition) const;

    bool hasReportingEndpoint(COOPDisposition) const;

    CrossOriginOpenerPolicy isolatedCopy() const;

    template<class Encoder> void encode(Encoder&) const;

    template<class Decoder> static std::optional<CrossOriginOpenerPolicy> decode(Decoder&);

};

inline const String& CrossOriginOpenerPolicy::reportingEndpointForDisposition(COOPDisposition disposition) const

{

    return disposition == COOPDisposition::Enforce ? reportingEndpoint : reportOnlyReportingEndpoint;

}

inline bool CrossOriginOpenerPolicy::hasReportingEndpoint(COOPDisposition disposition) const

{

    return !reportingEndpointForDisposition(disposition).isEmpty();

}

inline bool operator==(const CrossOriginOpenerPolicy& a, const CrossOriginOpenerPolicy& b)

{

    return a.value == b.value && a.reportingEndpoint == b.reportingEndpoint && a.reportOnlyValue == b.reportOnlyValue && a.reportOnlyReportingEndpoint == b.reportOnlyReportingEndpoint;

@@std::optional<CrossOriginOpenerPolicy> CrossOriginOpenerPolicy::decode(Decoder&

// https://html.spec.whatwg.org/multipage/origin.html#coop-enforcement-result

struct CrossOriginOpenerPolicyEnforcementResult {

101 bool ~~needsBrowsingC~~on~~tex~~tG~~roupSwitch { false }~~;

102 ~~bool needsBrowsingContextGroupSwitchDueToReportOnly { false };~~

121 WEBCORE_EXPORT static CrossOriginOpenerPolicyEnforcementResult from(const URL& currentURL, Ref<SecurityOrigin>&& currentOrigin, const CrossOriginOpenerPolicy&, std::optional<NavigationRequester>, const URL& openerURL);

122

    URL url;

    Ref<SecurityOrigin> currentOrigin;

    CrossOriginOpenerPolicy crossOriginOpenerPolicy;

    bool isCurrentContextNavigationSource { true };

127 bool needsBrowsingContextGroupSwitch { false };

128 bool needsBrowsingContextGroupSwitchDueToReportOnly { false };

107129};

108130

enum class COOPDisposition : bool { Reporting , Enforce };

CrossOriginOpenerPolicy obtainCrossOriginOpenerPolicy(const ResourceResponse&, const ScriptExecutionContext&);

131CrossOriginOpenerPolicy obtainCrossOriginOpenerPolicy(const ResourceResponse&);

112132WEBCORE_EXPORT void addCrossOriginOpenerPolicyHeaders(ResourceResponse&, const CrossOriginOpenerPolicy&);

113 void sendViolationReportWhenNavigatingToCOOPResponse(Frame&, CrossOriginOpenerPolicy, COOPDisposition, const URL& coopURL, const URL& previousResponseURL, const SecurityOrigin& coopOrigin, const SecurityOrigin& previousResponseOrigin, const String& referrer, const String& userAgent);

114 void sendViolationReportWhenNavigatingAwayFromCOOPResponse(Frame&, CrossOriginOpenerPolicy, COOPDisposition, const URL& coopURL, const URL& nextResponseURL, const SecurityOrigin& coopOrigin, const SecurityOrigin& nextResponseOrigin, bool isCOOPResponseNavigationSource, const String& userAgent);

WEBCORE_EXPORT void sendViolationReportWhenNavigatingToCOOPResponse(Frame&, CrossOriginOpenerPolicy, COOPDisposition, const URL& coopURL, const URL& previousResponseURL, const SecurityOrigin& coopOrigin, const SecurityOrigin& previousResponseOrigin, const String& referrer, const String& userAgent);

WEBCORE_EXPORT void sendViolationReportWhenNavigatingAwayFromCOOPResponse(Frame&, CrossOriginOpenerPolicy, COOPDisposition, const URL& coopURL, const URL& nextResponseURL, const SecurityOrigin& coopOrigin, const SecurityOrigin& nextResponseOrigin, bool isCOOPResponseNavigationSource, const String& userAgent);

WEBCORE_EXPORT std::optional<CrossOriginOpenerPolicyEnforcementResult> doCrossOriginOpenerHandlingOfResponse(const ResourceResponse&, const std::optional<NavigationRequester>&, ContentSecurityPolicy* responseCSP, SandboxFlags effectiveSandboxFlags, bool isDisplayingInitialEmptyDocument, const CrossOriginOpenerPolicyEnforcementResult& currentCoopEnforcementResult, const Function<void(COOPDisposition disposition, const CrossOriginOpenerPolicy& responseCOOP, const SecurityOrigin& responseOrigin)>& sendViolationReports);

} // namespace WebCore

Source/WebCore/loader/DocumentLoader.cpp

#include "Logging.h"

#include "MemoryCache.h"

#include "MixedContentChecker.h"

72#include "NavigationRequester.h"

#include "NavigationScheduler.h"

#include "NetworkLoadMetrics.h"

#include "NetworkStorageSession.h"

@@void DocumentLoader::willSendRequest(ResourceRequest&& newRequest, const Resourc

        }

    }

    if (didReceiveRedirectResponse && !doCrossOriginOpenerHandlingOfResponse(redirectResponse))

        return;

    if (!newRequest.url().host().isEmpty() && SecurityOrigin::shouldIgnoreHost(newRequest.url())) {

        auto url = newRequest.url();

        url.setHostAndPort({ });

@@void DocumentLoader::willSendRequest(ResourceRequest&& newRequest, const Resourc

    policyChecker.checkNavigationPolicy(WTFMove(newRequest), redirectResponse, WTFMove(navigationPolicyCompletionHandler));

}

// https://html.spec.whatwg.org/multipage/origin.html#check-browsing-context-group-switch-coop-value

static bool checkIfCOOPValuesRequireBrowsingContextGroupSwitch(bool isInitialAboutBlank, CrossOriginOpenerPolicyValue activeDocumentCOOPValue, const SecurityOrigin& activeDocumentNavigationOrigin, CrossOriginOpenerPolicyValue responseCOOPValue, const SecurityOrigin& responseOrigin)

{

    // If the result of matching activeDocumentCOOPValue, activeDocumentNavigationOrigin, responseCOOPValue, and responseOrigin is true, return false.

    // https://html.spec.whatwg.org/multipage/origin.html#matching-coop

    if (activeDocumentCOOPValue == CrossOriginOpenerPolicyValue::UnsafeNone && responseCOOPValue == CrossOriginOpenerPolicyValue::UnsafeNone)

        return false;

    if (activeDocumentCOOPValue == responseCOOPValue && activeDocumentNavigationOrigin.isSameOriginAs(responseOrigin))

        return false;

    // If all of the following are true:

    // - isInitialAboutBlank,

    // - activeDocumentCOOPValue's value is "same-origin-allow-popups".

    // - responseCOOPValue is "unsafe-none",

    // then return false.

    if (isInitialAboutBlank && activeDocumentCOOPValue == CrossOriginOpenerPolicyValue::SameOriginAllowPopups && responseCOOPValue == CrossOriginOpenerPolicyValue::UnsafeNone)

        return false;

    return true;

}

// https://html.spec.whatwg.org/multipage/origin.html#check-bcg-switch-navigation-report-only

static bool checkIfEnforcingReportOnlyCOOPWouldRequireBrowsingContextGroupSwitch(bool isInitialAboutBlank, const CrossOriginOpenerPolicy& activeDocumentCOOP, const SecurityOrigin& activeDocumentNavigationOrigin, const CrossOriginOpenerPolicy& responseCOOP, const SecurityOrigin& responseOrigin)

{

    if (!checkIfCOOPValuesRequireBrowsingContextGroupSwitch(isInitialAboutBlank, activeDocumentCOOP.reportOnlyValue, activeDocumentNavigationOrigin, responseCOOP.reportOnlyValue, responseOrigin))

        return false;

    if (checkIfCOOPValuesRequireBrowsingContextGroupSwitch(isInitialAboutBlank, activeDocumentCOOP.reportOnlyValue, activeDocumentNavigationOrigin, responseCOOP.value, responseOrigin))

        return true;

    if (checkIfCOOPValuesRequireBrowsingContextGroupSwitch(isInitialAboutBlank, activeDocumentCOOP.value, activeDocumentNavigationOrigin, responseCOOP.reportOnlyValue, responseOrigin))

        return true;

    return false;

}

static std::tuple<Ref<SecurityOrigin>, CrossOriginOpenerPolicy> computeResponseOriginAndCOOP(const ResourceResponse& response, const Document& document, const std::optional<NavigationAction::Requester>& requester, ContentSecurityPolicy* responseCSP)

{

    // Non-initial empty documents (about:blank) should inherit their cross-origin-opener-policy from the navigation's initiator top level document,

    // if the initiator and its top level document are same-origin, or default (unsafe-none) otherwise.

    // https://github.com/whatwg/html/issues/6913

    if (SecurityPolicy::shouldInheritSecurityOriginFromOwner(response.url()) && requester)

        return std::make_tuple(Ref { requester->securityOrigin() }, requester->securityOrigin().isSameOriginAs(requester->topOrigin()) ? requester->crossOriginOpenerPolicy() : CrossOriginOpenerPolicy { });

    // If the HTTP response contains a CSP header, it may set sandbox flags, which would cause the origin to become unique.

    auto responseOrigin = responseCSP && responseCSP->sandboxFlags() != SandboxNone ? SecurityOrigin::createUnique() : SecurityOrigin::create(response.url());

    return std::make_tuple(WTFMove(responseOrigin), obtainCrossOriginOpenerPolicy(response, document));

}

796745// https://html.spec.whatwg.org/multipage/browsing-the-web.html#process-a-navigate-fetch (Step 12.5.6)

797 bool DocumentLoader::doCrossOriginOpenerHandlingOfResponse(const ResourceResponse& response)

746std::optional<CrossOriginOpenerPolicyEnforcementResult> DocumentLoader::doCrossOriginOpenerHandlingOfResponse(const ResourceResponse& response)

{

    // COOP only applies to top-level browsing contexts.

    if (!m_frame->isMainFrame())

801 return true;

750 return std::nullopt;

802751

803752 if (!m_frame->document() || !m_frame->document()->settings().crossOriginOpenerPolicyEnabled())

        return true;

    auto [responseOrigin, responseCOOP] = computeResponseOriginAndCOOP(response, *m_frame->document(), m_triggeringAction.requester(), m_contentSecurityPolicy.get());

    // https://html.spec.whatwg.org/multipage/browsing-the-web.html#process-a-navigate-fetch (Step 12.5.6.2)

    // If sandboxFlags is not empty and responseCOOP's value is not "unsafe-none", then set response to an appropriate network error and break.

    if (responseCOOP.value != CrossOriginOpenerPolicyValue::UnsafeNone && frameLoader()->effectiveSandboxFlags() != SandboxNone) {

        cancelMainResourceLoad(frameLoader()->cancelledError(m_request));

        return false;

    }

    m_currentCoopEnforcementResult = enforceResponseCrossOriginOpenerPolicy(response.url(), responseOrigin, responseCOOP);

    return true;

}

// https://html.spec.whatwg.org/multipage/origin.html#coop-enforce

CrossOriginOpenerPolicyEnforcementResult DocumentLoader::enforceResponseCrossOriginOpenerPolicy(const URL& responseURL, SecurityOrigin& responseOrigin, const CrossOriginOpenerPolicy& responseCOOP)

{

    ASSERT(m_frame->isMainFrame());

    ASSERT(m_frame->document());

    ASSERT(m_frame->document()->settings().crossOriginOpenerPolicyEnabled());

    if (!m_currentCoopEnforcementResult) {

        auto requester = m_triggeringAction.requester();

        bool currentContextIsSource = requester && m_frame->document()->securityOrigin().isSameOriginAs(requester->securityOrigin());

        m_currentCoopEnforcementResult = CrossOriginOpenerPolicyEnforcementResult {

            false,

            false,

            m_frame->document()->url(),

            m_frame->document()->securityOrigin(),

            m_frame->document()->crossOriginOpenerPolicy(),

            currentContextIsSource,

        };

        if (SecurityPolicy::shouldInheritSecurityOriginFromOwner(m_frame->document()->url())) {

            if (auto openerFrame = m_frame->loader().opener()) {

                if (auto openerDocument = openerFrame->document())

                    m_currentCoopEnforcementResult->url = openerDocument->url();

            }

        }

    }

753 return std::nullopt;

844754

    CrossOriginOpenerPolicyEnforcementResult newCOOPEnforcementResult = {

        m_currentCoopEnforcementResult->needsBrowsingContextGroupSwitch,

        m_currentCoopEnforcementResult->needsBrowsingContextGroupSwitchDueToReportOnly,

        responseURL,

        responseOrigin,

        responseCOOP,

        true

    };

    URL openerURL;

    if (auto openerFrame = m_frame->loader().opener())

        openerURL = openerFrame->document() ? openerFrame->document()->url() : URL();

853758

854 if (checkIfCOOPValuesRequireBrowsingContextGroupSwitch(frameLoader()->stateMachine().isDisplayingInitialEmptyDocument(), m_currentCoopEnforcementResult->crossOriginOpenerPolicy.value, m_currentCoopEnforcementResult->currentOrigin, responseCOOP.value, responseOrigin)) {

855 newCOOPEnforcementResult.needsBrowsingContextGroupSwitch = true;

759 auto currentCoopEnforcementResult = CrossOriginOpenerPolicyEnforcementResult::from(m_frame->document()->url(), m_frame->document()->securityOrigin(), m_frame->document()->crossOriginOpenerPolicy(), m_triggeringAction.requester(), openerURL);

856760

761 auto newCoopEnforcementResult = WebCore::doCrossOriginOpenerHandlingOfResponse(response, m_triggeringAction.requester(), m_contentSecurityPolicy.get(), frameLoader()->effectiveSandboxFlags(), frameLoader()->stateMachine().isDisplayingInitialEmptyDocument(), currentCoopEnforcementResult, [&](COOPDisposition disposition, const CrossOriginOpenerPolicy& responseCOOP, const SecurityOrigin& responseOrigin) {

857762 // FIXME: Add the concept of browsing context group like in the specification instead of treating the whole process as a group.

858763 if (Page::nonUtilityPageCount() > 1) {

            sendViolationReportWhenNavigatingToCOOPResponse(*m_frame, responseCOOP, COOPDisposition::Enforce, responseURL, m_currentCoopEnforcementResult->url, responseOrigin, m_currentCoopEnforcementResult->currentOrigin, m_request.httpReferrer(), m_request.httpUserAgent());

            sendViolationReportWhenNavigatingAwayFromCOOPResponse(*m_frame, m_currentCoopEnforcementResult->crossOriginOpenerPolicy, COOPDisposition::Enforce, m_currentCoopEnforcementResult->url, responseURL, m_currentCoopEnforcementResult->currentOrigin, responseOrigin, m_currentCoopEnforcementResult->isCurrentContextNavigationSource, m_request.httpUserAgent());

        }

    }

    if (checkIfEnforcingReportOnlyCOOPWouldRequireBrowsingContextGroupSwitch(frameLoader()->stateMachine().isDisplayingInitialEmptyDocument(), m_currentCoopEnforcementResult->crossOriginOpenerPolicy, m_currentCoopEnforcementResult->currentOrigin, responseCOOP, responseOrigin)) {

        newCOOPEnforcementResult.needsBrowsingContextGroupSwitchDueToReportOnly = true;

        // FIXME: Add the concept of browsing context group like in the specification instead of treating the whole process as a group.

        if (Page::nonUtilityPageCount() > 1) {

            sendViolationReportWhenNavigatingToCOOPResponse(*m_frame, responseCOOP, COOPDisposition::Reporting, responseURL, m_currentCoopEnforcementResult->url, responseOrigin, m_currentCoopEnforcementResult->currentOrigin, m_request.httpReferrer(), m_request.httpUserAgent());

            sendViolationReportWhenNavigatingAwayFromCOOPResponse(*m_frame, m_currentCoopEnforcementResult->crossOriginOpenerPolicy, COOPDisposition::Reporting, m_currentCoopEnforcementResult->url, responseURL, m_currentCoopEnforcementResult->currentOrigin, responseOrigin, m_currentCoopEnforcementResult->isCurrentContextNavigationSource, m_request.httpUserAgent());

764 sendViolationReportWhenNavigatingToCOOPResponse(*m_frame, responseCOOP, disposition, response.url(), currentCoopEnforcementResult.url, responseOrigin, currentCoopEnforcementResult.currentOrigin, m_request.httpReferrer(), m_request.httpUserAgent());

765 sendViolationReportWhenNavigatingAwayFromCOOPResponse(*m_frame, currentCoopEnforcementResult.crossOriginOpenerPolicy, disposition, currentCoopEnforcementResult.url, response.url(), currentCoopEnforcementResult.currentOrigin, responseOrigin, currentCoopEnforcementResult.isCurrentContextNavigationSource, m_request.httpUserAgent());

871766 }

    });

    if (!newCoopEnforcementResult) {

        cancelMainResourceLoad(frameLoader()->cancelledError(m_request));

        return std::nullopt;

872771 }

873772

874 return newC~~OOP~~EnforcementResult;

773 return newCoopEnforcementResult;

}

bool DocumentLoader::tryLoadingRequestFromApplicationCache()

@@void DocumentLoader::responseReceived(CachedResource& resource, const ResourceRe

        m_contentSecurityPolicy->didReceiveHeaders(ContentSecurityPolicyResponseHeaders { response }, m_request.httpReferrer(), ContentSecurityPolicy::ReportParsingErrors::No);

    } else

        m_contentSecurityPolicy = nullptr;

870 if (m_frame && m_frame->document() && m_frame->document()->settings().crossOriginOpenerPolicyEnabled())

871 m_responseCOOP = obtainCrossOriginOpenerPolicy(response);

#if ENABLE(INTELLIGENT_TRACKING_PREVENTION)

    // FIXME(218779): Remove this quirk once microsoft.com completes their login flow redesign.

@@void DocumentLoader::responseReceived(CachedResource& resource, const ResourceRe

    responseReceived(response, WTFMove(completionHandler));

}

static BrowsingContextGroupSwitchDecision toBrowsingContextGroupSwitchDecision(const std::optional<CrossOriginOpenerPolicyEnforcementResult>& currentCoopEnforcementResult)

{

    if (!currentCoopEnforcementResult || !currentCoopEnforcementResult->needsBrowsingContextGroupSwitch)

        return BrowsingContextGroupSwitchDecision::StayInGroup;

    if (currentCoopEnforcementResult->crossOriginOpenerPolicy.value == CrossOriginOpenerPolicyValue::SameOriginPlusCOEP)

        return BrowsingContextGroupSwitchDecision::NewIsolatedGroup;

    return BrowsingContextGroupSwitchDecision::NewSharedGroup;

}

void DocumentLoader::responseReceived(const ResourceResponse& response, CompletionHandler<void()>&& completionHandler)

{

    ASSERT(response.certificateInfo());

@@void DocumentLoader::responseReceived(const ResourceResponse& response, Completi

    }

#endif

    if (!doCrossOriginOpenerHandlingOfResponse(response))

        return;

    if (std::exchange(m_isContinuingLoadAfterResponsePolicyCheck, false)) {

        continueAfterContentPolicy(PolicyAction::Use);

        return;

    }

    RefPtr<SubresourceLoader> mainResourceLoader = this->mainResourceLoader();

    if (mainResourceLoader)

        mainResourceLoader->markInAsyncResponsePolicyCheck();

    auto requestIdentifier = PolicyCheckIdentifier::create();

1118 auto browsingContextGroupSwitchDecision = toBrowsingContextGroupSwitchDecision(m_currentCoopEnforcementResult);

1119 frameLoader()->checkContentPolicy(m_response, requestIdentifier, browsingContextGroupSwitchDecision, [this, protectedThis = Ref { *this }, mainResourceLoader = WTFMove(mainResourceLoader),

1002 frameLoader()->checkContentPolicy(m_response, requestIdentifier, [this, protectedThis = Ref { *this }, mainResourceLoader = WTFMove(mainResourceLoader),

        completionHandler = completionHandlerCaller.release(), requestIdentifier] (PolicyAction policy, PolicyCheckIdentifier responseIdentifier) mutable {

        RELEASE_ASSERT(responseIdentifier.isValidFor(requestIdentifier));

        continueAfterContentPolicy(policy);

@@bool DocumentLoader::maybeLoadEmpty()

    m_response = ResourceResponse(m_request.url(), mimeType, 0, "UTF-8"_s);

    if (!frameLoader()->stateMachine().isDisplayingInitialEmptyDocument()) {

        doCrossOriginOpenerHandlingOfResponse(m_response);

        // FIXME: Non-initial about:blank loads may cause a browsing context group switch. However, such load is synchronous and doesn't

        // involve a response policy decision. As a result, we simulate a browsing context group switch without actually swapping process.

        if (m_currentCoopEnforcementResult && m_currentCoopEnforcementResult->needsBrowsingContextGroupSwitch)

            frameLoader()->switchBrowsingContextsGroup();

        if (auto coopEnforcementResult = doCrossOriginOpenerHandlingOfResponse(m_response)) {

            m_responseCOOP = coopEnforcementResult->crossOriginOpenerPolicy;

            if (coopEnforcementResult->needsBrowsingContextGroupSwitch)

                frameLoader()->switchBrowsingContextsGroup();

        }

    }

    finishedLoading();

@@void DocumentLoader::clearMainResource()

#endif

    m_mainResource = nullptr;

2342 m_isContinuingLoadAfterResp~~onsePolicyCheck~~ = false;

2224 m_isContinuingLoadAfterProvisionalLoadStarted = false;

    unregisterTemporaryServiceWorkerClient();

}

Source/WebCore/loader/DocumentLoader.h

@@public:

    void setLastNavigationWasAppInitiated(bool lastNavigationWasAppInitiated) { m_lastNavigationWasAppInitiated = lastNavigationWasAppInitiated; }

    ContentSecurityPolicy* contentSecurityPolicy() const { return m_contentSecurityPolicy.get(); }

428 std::optional<CrossOriginOpenerPolicy> crossOriginOpenerPolicy() const { return m_~~currentCoopEnforcementResult ? std::make_optional(m_currentCoopEnforcementResult->crossOriginOpenerPolicy) : std::nullopt~~; }

428 const std::optional<CrossOriginOpenerPolicy>& crossOriginOpenerPolicy() const { return m_responseCOOP; }

429429

430 bool isContinuingLoadAfterResp~~onsePolicyCheck~~() const { return m_isContinuingLoadAfterResp~~onsePolicyCheck~~; }

431 void setIsContinuingLoadAfterResp~~onsePolicyCheck~~(bool isContinuingLoadAfterResp~~onsePolicyCheck~~) { m_isContinuingLoadAfterResp~~onsePolicyCheck~~ = isContinuingLoadAfterResp~~onsePolicyCheck~~; }

430 bool isContinuingLoadAfterProvisionalLoadStarted() const { return m_isContinuingLoadAfterProvisionalLoadStarted; }

431 void setIsContinuingLoadAfterProvisionalLoadStarted(bool isContinuingLoadAfterProvisionalLoadStarted) { m_isContinuingLoadAfterProvisionalLoadStarted = isContinuingLoadAfterProvisionalLoadStarted; }

protected:

    WEBCORE_EXPORT DocumentLoader(const ResourceRequest&, const SubstituteData&);

@@private:

#endif

    void unregisterTemporaryServiceWorkerClient();

453 bool doCrossOriginOpenerHandlingOfResponse(const ResourceResponse&);

454 CrossOriginOpenerPolicyEnforcementResult enforceResponseCrossOriginOpenerPolicy(const URL& responseURL, SecurityOrigin& responseOrigin, const CrossOriginOpenerPolicy& responseCOOP);

453 std::optional<CrossOriginOpenerPolicyEnforcementResult> doCrossOriginOpenerHandlingOfResponse(const ResourceResponse&);

    void loadMainResource(ResourceRequest&&);

@@private:

    bool m_gotFirstByte { false };

    bool m_isClientRedirect { false };

    bool m_isLoadingMultipartContent { false };

569 bool m_isContinuingLoadAfterResp~~onsePolicyCheck~~ { false };

568 bool m_isContinuingLoadAfterProvisionalLoadStarted { false };

    // FIXME: Document::m_processingLoadEvent and DocumentLoader::m_wasOnloadDispatched are roughly the same

    // and should be merged.

@@private:

    Vector<ResourceResponse> m_responses;

    bool m_stopRecordingResponses { false };

593 std::optional<CrossOriginOpenerPolicy~~EnforcementResult~~> m_~~cur~~rent~~CoopEnforcementResult~~;

592 std::optional<CrossOriginOpenerPolicy> m_responseCOOP;

    
    typedef HashMap<RefPtr<ResourceLoader>, RefPtr<SubstituteResource>> SubstituteResourceMap;

    SubstituteResourceMap m_pendingSubstituteResources;

Source/WebCore/loader/EmptyClients.cpp

@@void EmptyFrameLoaderClient::dispatchShow()

{

}

821 void EmptyFrameLoaderClient::dispatchDecidePolicyForResponse(const ResourceResponse&, const ResourceRequest&, PolicyCheckIdentifier, const String&, ~~BrowsingContextGroupSwitchDecision,~~ FramePolicyFunction&&)

821void EmptyFrameLoaderClient::dispatchDecidePolicyForResponse(const ResourceResponse&, const ResourceRequest&, PolicyCheckIdentifier, const String&, FramePolicyFunction&&)

{

}

Source/WebCore/loader/EmptyFrameLoaderClient.h

@@private:

    Frame* dispatchCreatePage(const NavigationAction&, NewFrameOpenerPolicy) final;

    void dispatchShow() final;

99 void dispatchDecidePolicyForResponse(const ResourceResponse&, const ResourceRequest&, PolicyCheckIdentifier, const String&, ~~BrowsingContextGroupSwitchDecision,~~ FramePolicyFunction&&) final;

99 void dispatchDecidePolicyForResponse(const ResourceResponse&, const ResourceRequest&, PolicyCheckIdentifier, const String&, FramePolicyFunction&&) final;

    void dispatchDecidePolicyForNewWindowAction(const NavigationAction&, const ResourceRequest&, FormState*, const String&, PolicyCheckIdentifier, FramePolicyFunction&&) final;

    void dispatchDecidePolicyForNavigationAction(const NavigationAction&, const ResourceRequest&, const ResourceResponse& redirectResponse, FormState*, PolicyDecisionMode, PolicyCheckIdentifier, FramePolicyFunction&&) final;

    void cancelPolicyCheck() final;

Source/WebCore/loader/FrameLoader.cpp

@@void FrameLoader::setDefersLoading(bool defers)

    }

}

416 void FrameLoader::checkContentPolicy(const ResourceResponse& response, PolicyCheckIdentifier identifier, ~~BrowsingContextGroupSwitchDecision browsingContextGroupSwitchDecision,~~ ContentPolicyDecisionFunction&& function)

416void FrameLoader::checkContentPolicy(const ResourceResponse& response, PolicyCheckIdentifier identifier, ContentPolicyDecisionFunction&& function)

{

    if (!activeDocumentLoader()) {

        // Load was cancelled

@@void FrameLoader::checkContentPolicy(const ResourceResponse& response, PolicyChe

    }

    // FIXME: Validate the policy check identifier.

425 client().dispatchDecidePolicyForResponse(response, activeDocumentLoader()->request(), identifier, activeDocumentLoader()->downloadAttribute(), ~~browsingContextGroupSwitchDecision,~~ WTFMove(function));

425 client().dispatchDecidePolicyForResponse(response, activeDocumentLoader()->request(), identifier, activeDocumentLoader()->downloadAttribute(), WTFMove(function));

}

void FrameLoader::changeLocation(const URL& url, const String& passedTarget, Event* triggeringEvent, const ReferrerPolicy& referrerPolicy, ShouldOpenExternalURLsPolicy shouldOpenExternalURLsPolicy, std::optional<NewFrameOpenerPolicy> openerPolicy, const AtomString& downloadAttribute, const SystemPreviewInfo& systemPreviewInfo, std::optional<PrivateClickMeasurement>&& privateClickMeasurement)

@@void FrameLoader::load(FrameLoadRequest&& request)

    Ref<DocumentLoader> loader = m_client->createDocumentLoader(request.resourceRequest(), request.substituteData());

    loader->setAllowsWebArchiveForMainFrame(request.isRequestFromClientOrUserInput());

    loader->setAllowsDataURLsForMainFrame(request.isRequestFromClientOrUserInput());

1479 loader->setIsContinuingLoadAfterResp~~onsePolicyCheck~~(request.shouldTreatAsContinuingLoad() == ShouldTreatAsContinuingLoad::YesAfter~~ResponsePolicyDec~~ision);

1479 loader->setIsContinuingLoadAfterProvisionalLoadStarted(request.shouldTreatAsContinuingLoad() == ShouldTreatAsContinuingLoad::YesAfterProvisionalLoadStarted);

    addSameSiteInfoToRequestIfNeeded(loader->request());

    applyShouldOpenExternalURLsPolicyToNewDocumentLoader(m_frame, loader, request);

Source/WebCore/loader/FrameLoader.h

@@public:

    void setDefersLoading(bool);

223 void checkContentPolicy(const ResourceResponse&, PolicyCheckIdentifier, ~~BrowsingContextGroupSwitchDecision,~~ ContentPolicyDecisionFunction&&);

223 void checkContentPolicy(const ResourceResponse&, PolicyCheckIdentifier, ContentPolicyDecisionFunction&&);

    void didExplicitOpen();

@@public:

    // The following sandbox flags will be forced, regardless of changes to

    // the sandbox attribute of any parent frames.

    void forceSandboxFlags(SandboxFlags flags) { m_forcedSandboxFlags |= flags; }

242 SandboxFlags effectiveSandboxFlags() const;

242 WEBCORE_EXPORT SandboxFlags effectiveSandboxFlags() const;

    bool checkIfFormActionAllowedByCSP(const URL&, bool didReceiveRedirectResponse) const;

@@public:

    bool loadsSynchronously() const { return m_loadsSynchronously; }

    FrameLoaderStateMachine& stateMachine() { return m_stateMachine; }

272 const FrameLoaderStateMachine& stateMachine() const { return m_stateMachine; }

    // FIXME: should return RefPtr.

    WEBCORE_EXPORT Frame* findFrameForNavigation(const AtomString& name, Document* activeDocument = nullptr);

Source/WebCore/loader/FrameLoaderClient.h

@@public:

    virtual Frame* dispatchCreatePage(const NavigationAction&, NewFrameOpenerPolicy) = 0;

    virtual void dispatchShow() = 0;

194 virtual void dispatchDecidePolicyForResponse(const ResourceResponse&, const ResourceRequest&, PolicyCheckIdentifier, const String& downloadAttribute, ~~BrowsingContextGroupSwitchDecision,~~ FramePolicyFunction&&) = 0;

194 virtual void dispatchDecidePolicyForResponse(const ResourceResponse&, const ResourceRequest&, PolicyCheckIdentifier, const String& downloadAttribute, FramePolicyFunction&&) = 0;

    virtual void dispatchDecidePolicyForNewWindowAction(const NavigationAction&, const ResourceRequest&, FormState*, const String& frameName, PolicyCheckIdentifier, FramePolicyFunction&&) = 0;

    virtual void dispatchDecidePolicyForNavigationAction(const NavigationAction&, const ResourceRequest&, const ResourceResponse& redirectResponse, FormState*, PolicyDecisionMode, PolicyCheckIdentifier, FramePolicyFunction&&) = 0;

    virtual void cancelPolicyCheck() = 0;

Source/WebCore/loader/NavigationAction.cpp

namespace WebCore {

static GlobalFrameIdentifier createGlobalFrameIdentifier(const Document& document)

{

    if (document.frame())

        return { document.frame()->loader().pageID().value_or(PageIdentifier { }), document.frame()->loader().frameID().value_or(FrameIdentifier { }) };

    return GlobalFrameIdentifier();

}

NavigationAction::Requester::Requester(const Document& document)

    : m_url { URL { document.url() } }

    , m_origin { &document.securityOrigin() }

    , m_topOrigin { &document.topOrigin() }

    , m_crossOriginOpenerPolicy { document.crossOriginOpenerPolicy() }

    , m_globalFrameIdentifier(createGlobalFrameIdentifier(document))

{

}

NavigationAction::UIEventWithKeyStateData::UIEventWithKeyStateData(const UIEventWithKeyState& uiEvent)

    : isTrusted { uiEvent.isTrusted() }

    , shiftKey { uiEvent.shiftKey() }

@@static std::optional<NavigationAction::MouseEventData> mouseEventDataForFirstMou

}

NavigationAction::NavigationAction(Document& requester, const ResourceRequest& resourceRequest, InitiatedByMainFrame initiatedByMainFrame, NavigationType type, ShouldOpenExternalURLsPolicy shouldOpenExternalURLsPolicy, Event* event, const AtomString& downloadAttribute)

106 : m_requester { requester }

90 : m_requester { NavigationRequester::from(requester) }

    , m_resourceRequest { resourceRequest }

    , m_type { type }

    , m_shouldOpenExternalURLsPolicy { shouldOpenExternalURLsPolicy }

@@static NavigationType navigationType(FrameLoadType frameLoadType, bool isFormSub

}

NavigationAction::NavigationAction(Document& requester, const ResourceRequest& resourceRequest, InitiatedByMainFrame initiatedByMainFrame, FrameLoadType frameLoadType, bool isFormSubmission, Event* event, ShouldOpenExternalURLsPolicy shouldOpenExternalURLsPolicy, const AtomString& downloadAttribute)

132 : m_requester { requester }

116 : m_requester { NavigationRequester::from(requester) }

    , m_resourceRequest { resourceRequest }

    , m_type { navigationType(frameLoadType, isFormSubmission, !!event) }

    , m_shouldOpenExternalURLsPolicy { shouldOpenExternalURLsPolicy }

Source/WebCore/loader/NavigationAction.h

#include "FrameLoaderTypes.h"

#include "GlobalFrameIdentifier.h"

#include "LayoutPoint.h"

36#include "NavigationRequester.h"

#include "PrivateClickMeasurement.h"

#include "ResourceRequest.h"

#include "SecurityOrigin.h"

@@public:

    NavigationAction(NavigationAction&&);

    NavigationAction& operator=(NavigationAction&&);

    class Requester {

    public:

        Requester(const Document&);

        const URL& url() const { return m_url; }

        SecurityOrigin& securityOrigin() const { return *m_origin; }

        SecurityOrigin& topOrigin() const { return *m_topOrigin; }

        CrossOriginOpenerPolicy crossOriginOpenerPolicy() const { return m_crossOriginOpenerPolicy; }

        const GlobalFrameIdentifier& globalFrameIdentifier() const { return m_globalFrameIdentifier; }

    private:

        URL m_url;

        RefPtr<SecurityOrigin> m_origin;

        RefPtr<SecurityOrigin> m_topOrigin;

        CrossOriginOpenerPolicy m_crossOriginOpenerPolicy;

        GlobalFrameIdentifier m_globalFrameIdentifier;

    };

    const std::optional<Requester>& requester() const { return m_requester; }

68 const std::optional<NavigationRequester>& requester() const { return m_requester; }

    struct UIEventWithKeyStateData {

        UIEventWithKeyStateData(const UIEventWithKeyState&);

@@public:

    NavigationAction copyWithShouldOpenExternalURLsPolicy(ShouldOpenExternalURLsPolicy) const;

108 bool isEmpty() const { return !m_requester || m_requester->url().isEmpty() || m_resourceRequest.url().isEmpty(); }

93 bool isEmpty() const { return !m_requester || m_requester->url.isEmpty() || m_resourceRequest.url().isEmpty(); }

    URL url() const { return m_resourceRequest.url(); }

    const ResourceRequest& resourceRequest() const { return m_resourceRequest; }

@@public:

private:

    // Do not add a strong reference to the originating document or a subobject that holds the

    // originating document. See comment above the class for more details.

150 std::optional<Requester> m_requester;

135 std::optional<NavigationRequester> m_requester;

    ResourceRequest m_resourceRequest;

    NavigationType m_type;

    ShouldOpenExternalURLsPolicy m_shouldOpenExternalURLsPolicy;

Source/WebCore/loader/NavigationRequester.cpp

/*

 * Copyright (C) 2021 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.

 */

#include "config.h"

#include "NavigationRequester.h"

#include "Document.h"

#include "Frame.h"

#include "FrameLoader.h"

namespace WebCore {

static std::optional<GlobalFrameIdentifier> createGlobalFrameIdentifier(const Document& document)

{

    if (!document.frame())

        return std::nullopt;

    auto pageID = document.frame()->loader().pageID();

    auto frameID = document.frame()->loader().frameID();

    if (!pageID || !frameID)

        return std::nullopt;

    return GlobalFrameIdentifier { *pageID, *frameID };

}

NavigationRequester NavigationRequester::from(Document& document)

{

    return {

        document.url(),

        document.securityOrigin(),

        document.topOrigin(),

        document.crossOriginOpenerPolicy(),

        createGlobalFrameIdentifier(document)

    };

}

} // namespace WebCore

Source/WebCore/loader/NavigationRequester.h

/*

 * Copyright (C) 2021 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 "CrossOriginOpenerPolicy.h"

#include "GlobalFrameIdentifier.h"

#include "SecurityOrigin.h"

namespace WebCore {

class Document;

struct NavigationRequester {

    static NavigationRequester from(Document&);

    URL url;

    Ref<SecurityOrigin> securityOrigin;

    Ref<SecurityOrigin> topOrigin;

    CrossOriginOpenerPolicy crossOriginOpenerPolicy;

    std::optional<GlobalFrameIdentifier> globalFrameIdentifier;

    template<class Encoder> void encode(Encoder&) const;

    template<class Decoder> static std::optional<NavigationRequester> decode(Decoder&);

};

template<class Encoder>

void NavigationRequester::encode(Encoder& encoder) const

{

    encoder << url << securityOrigin.get() << topOrigin.get() << crossOriginOpenerPolicy << globalFrameIdentifier;

}

template<class Decoder>

std::optional<NavigationRequester> NavigationRequester::decode(Decoder& decoder)

{

    std::optional<URL> url;

    decoder >> url;

    if (!url)

        return std::nullopt;

    auto securityOrigin = SecurityOrigin::decode(decoder);

    if (!securityOrigin)

        return std::nullopt;

    auto topOrigin = SecurityOrigin::decode(decoder);

    if (!topOrigin)

        return std::nullopt;

    std::optional<CrossOriginOpenerPolicy> crossOriginOpenerPolicy;

    decoder >> crossOriginOpenerPolicy;

    if (!crossOriginOpenerPolicy)

        return std::nullopt;

    std::optional<std::optional<GlobalFrameIdentifier>> globalFrameIdentifier;

    decoder >> globalFrameIdentifier;

    if (!globalFrameIdentifier)

        return std::nullopt;

    return NavigationRequester { WTFMove(*url), securityOrigin.releaseNonNull(), topOrigin.releaseNonNull(), WTFMove(*crossOriginOpenerPolicy), WTFMove(*globalFrameIdentifier) };

}

} // namespace WebCore

Source/WebCore/loader/ReportingEndpointsCache.cpp

@@ReportingEndpointsCache::~ReportingEndpointsCache() = default;

// https://www.w3.org/TR/reporting/#process-header

void ReportingEndpointsCache::addEndPointsFromResponse(const ResourceResponse& response)

{

70 auto reportToHeaderValue = response.httpHeaderField(HTTPHeaderName::ReportTo);

    return addEndPointsFromReportToHeader(response.url(), response.httpHeaderField(HTTPHeaderName::ReportTo));

}

void ReportingEndpointsCache::addEndPointsFromReportToHeader(const URL& responseURL, const String& reportToHeaderValue)

{

    if (reportToHeaderValue.isEmpty())

        return;

74 auto securityOrigin = SecurityOrigin::create(response~~.url()~~);

78 auto securityOrigin = SecurityOrigin::create(responseURL);

    if (securityOrigin->isUnique() || !securityOrigin->isPotentiallyTrustworthy())

        return;

@@void ReportingEndpointsCache::addEndPointsFromResponse(const ResourceResponse& r

    while (dictionaryStart < reportToHeaderValue.length()) {

        auto indexOfNextTopLevelComma = findNextTopLevelComma(dictionaryStart);

        if (indexOfNextTopLevelComma == notFound) {

97 addEndpointFromDictionary(securityOrigin->data(), response~~.url()~~, reportToHeaderValue.substring(dictionaryStart));

101 addEndpointFromDictionary(securityOrigin->data(), responseURL, reportToHeaderValue.substring(dictionaryStart));

98102 break;

99103 }

100 addEndpointFromDictionary(securityOrigin->data(), response~~.url()~~, reportToHeaderValue.substring(dictionaryStart, indexOfNextTopLevelComma - dictionaryStart));

104 addEndpointFromDictionary(securityOrigin->data(), responseURL, reportToHeaderValue.substring(dictionaryStart, indexOfNextTopLevelComma - dictionaryStart));

        dictionaryStart = indexOfNextTopLevelComma + 1;

    }

}

Source/WebCore/loader/ReportingEndpointsCache.h

@@public:

    WEBCORE_EXPORT static Ref<ReportingEndpointsCache> create();

    WEBCORE_EXPORT ~ReportingEndpointsCache();

45 WEBCORE_EXPORT void addEndPointsFromReportToHeader(const URL&, const String&);

    void addEndPointsFromResponse(const ResourceResponse&);

    URL endpointURL(const SecurityOriginData&, const String& group) const;

Source/WebCore/loader/ShouldTreatAsContinuingLoad.h

namespace WebCore {

32 enum class ShouldTreatAsContinuingLoad : uint8_t { No, YesAfterNavigationPolicyDecision, YesAfter~~ResponsePolicyDec~~ision };

32enum class ShouldTreatAsContinuingLoad : uint8_t { No, YesAfterNavigationPolicyDecision, YesAfterProvisionalLoadStarted };

} // namespace WebCore

@@template<> struct EnumTraits<WebCore::ShouldTreatAsContinuingLoad> {

        WebCore::ShouldTreatAsContinuingLoad,

        WebCore::ShouldTreatAsContinuingLoad::No,

        WebCore::ShouldTreatAsContinuingLoad::YesAfterNavigationPolicyDecision,

43 WebCore::ShouldTreatAsContinuingLoad::YesAfter~~ResponsePolicyDec~~ision

43 WebCore::ShouldTreatAsContinuingLoad::YesAfterProvisionalLoadStarted

    >;

};

Source/WebCore/page/Page.h

@@public:

    WEBCORE_EXPORT void setBroadcastChannelRegistry(Ref<BroadcastChannelRegistry>&&); // Only used by WebKitLegacy.

    WEBCORE_EXPORT static void forEachPage(const WTF::Function<void(Page&)>&);

288 static unsigned nonUtilityPageCount();

288 WEBCORE_EXPORT static unsigned nonUtilityPageCount();

    unsigned subframeCount() const;

Source/WebKit/NetworkProcess/NetworkProcess.cpp

@@RTCDataChannelRemoteManagerProxy& NetworkProcess::rtcDataChannelProxy()

}

#endif

void NetworkProcess::prepareLoadForWebProcessTransfer(WebCore::ProcessIdentifier sourceProcessIdentifier, std::optional<WebCore::ResourceLoaderIdentifier> resourceLoadIdentifier, CompletionHandler<void(std::optional<NetworkResourceLoadIdentifier>)>&& completionHandler)

{

    if (!resourceLoadIdentifier) {

        ASSERT_NOT_REACHED();

        return completionHandler(std::nullopt);

    }

    auto* connection = webProcessConnection(sourceProcessIdentifier);

    if (!connection)

        return completionHandler(std::nullopt);

    auto session = connection->networkSession();

    if (!session)

        return completionHandler(std::nullopt);

    auto loader = connection->takeNetworkResourceLoader(*resourceLoadIdentifier);

    if (!loader)

        return completionHandler(std::nullopt);

    auto identifier = loader->identifier();

    session->addLoaderAwaitingWebProcessTransfer(loader.releaseNonNull());

    completionHandler(identifier);

}

void NetworkProcess::addWebPageNetworkParameters(PAL::SessionID sessionID, WebPageProxyIdentifier pageID, WebPageNetworkParameters&& parameters)

{

    auto session = networkSession(sessionID);

Source/WebKit/NetworkProcess/NetworkProcess.h

@@private:

    bool didReceiveSyncNetworkProcessMessage(IPC::Connection&, IPC::Decoder&, UniqueRef<IPC::Encoder>&);

    void initializeNetworkProcess(NetworkProcessCreationParameters&&);

    void createNetworkConnectionToWebProcess(WebCore::ProcessIdentifier, PAL::SessionID, CompletionHandler<void(std::optional<IPC::Attachment>&&, WebCore::HTTPCookieAcceptPolicy)>&&);

428 void prepareLoadForWebProcessTransfer(WebCore::ProcessIdentifier sourceProcessIdentifier, std::optional<WebCore::ResourceLoaderIdentifier> resourceLoadIdentifier, CompletionHandler<void(std::optional<NetworkResourceLoadIdentifier>)>&&);

    void fetchWebsiteData(PAL::SessionID, OptionSet<WebsiteDataType>, OptionSet<WebsiteDataFetchOption>, CompletionHandler<void(WebsiteData&&)>&&);

    void deleteWebsiteData(PAL::SessionID, OptionSet<WebsiteDataType>, WallTime modifiedSince, CompletionHandler<void()>&&);

Source/WebKit/NetworkProcess/NetworkProcess.messages.in

@@messages -> NetworkProcess LegacyReceiver {

    ClearAppPrivacyReportTestingData(PAL::SessionID sessionID) -> () Async

#endif

199 PrepareLoadForWebProcessTransfer(WebCore::ProcessIdentifier sourceProcessIdentifier, std::optional<WebCore::ResourceLoaderIdentifier> resourceLoadIdentifier) -> (std::optional<WebKit::NetworkResourceLoadIdentifier> networkResourceLoadIdentifier) Async

200

    AddWebPageNetworkParameters(PAL::SessionID sessionID, WebKit::WebPageProxyIdentifier pageID, WebKit::WebPageNetworkParameters parameters)

    RemoveWebPageNetworkParameters(PAL::SessionID sessionID, WebKit::WebPageProxyIdentifier pageID)

    CountNonDefaultSessionSets(PAL::SessionID sessionID) -> (size_t count) Async

Source/WebKit/NetworkProcess/NetworkResourceLoadParameters.cpp

@@void NetworkResourceLoadParameters::encode(IPC::Encoder& encoder) const

    encoder << crossOriginAccessControlCheckEnabled;

    encoder << documentURL;

117

    encoder << isCrossOriginOpenerPolicyEnabled;

    encoder << isDisplayingInitialEmptyDocument;

    encoder << effectiveSandboxFlags;

    encoder << openerURL;

    encoder << sourceCrossOriginOpenerPolicy;

    encoder << navigationID;

    encoder << navigationRequester;

#if ENABLE(SERVICE_WORKER)

    encoder << serviceWorkersMode;

    encoder << serviceWorkerRegistrationIdentifier;

@@std::optional<NetworkResourceLoadParameters> NetworkResourceLoadParameters::deco

        return std::nullopt;

    result.documentURL = *documentURL;

    std::optional<bool> isCrossOriginOpenerPolicyEnabled;

    decoder >> isCrossOriginOpenerPolicyEnabled;

    if (!isCrossOriginOpenerPolicyEnabled)

        return std::nullopt;

    result.isCrossOriginOpenerPolicyEnabled = *isCrossOriginOpenerPolicyEnabled;

    std::optional<bool> isDisplayingInitialEmptyDocument;

    decoder >> isDisplayingInitialEmptyDocument;

    if (!isDisplayingInitialEmptyDocument)

        return std::nullopt;

    result.isDisplayingInitialEmptyDocument = *isDisplayingInitialEmptyDocument;

    std::optional<SandboxFlags> effectiveSandboxFlags;

    decoder >> effectiveSandboxFlags;

    if (!effectiveSandboxFlags)

        return std::nullopt;

    result.effectiveSandboxFlags = *effectiveSandboxFlags;

    std::optional<URL> openerURL;

    decoder >> openerURL;

    if (!openerURL)

        return std::nullopt;

    result.openerURL = *openerURL;

    std::optional<CrossOriginOpenerPolicy> sourceCrossOriginOpenerPolicy;

    decoder >> sourceCrossOriginOpenerPolicy;

    if (!sourceCrossOriginOpenerPolicy)

        return std::nullopt;

    result.sourceCrossOriginOpenerPolicy = WTFMove(*sourceCrossOriginOpenerPolicy);

    std::optional<uint64_t> navigationID;

    decoder >> navigationID;

    if (!navigationID)

        return std::nullopt;

    result.navigationID = *navigationID;

    std::optional<std::optional<NavigationRequester>> navigationRequester;

    decoder >> navigationRequester;

    if (!navigationRequester)

        return std::nullopt;

    result.navigationRequester = WTFMove(*navigationRequester);

#if ENABLE(SERVICE_WORKER)

    std::optional<ServiceWorkersMode> serviceWorkersMode;

    decoder >> serviceWorkersMode;

Source/WebKit/NetworkProcess/NetworkResourceLoadParameters.h

#include <WebCore/CrossOriginAccessControl.h>

#include <WebCore/CrossOriginEmbedderPolicy.h>

#include <WebCore/FetchOptions.h>

36#include <WebCore/NavigationRequester.h>

#include <WebCore/ResourceLoaderIdentifier.h>

#include <wtf/Seconds.h>

@@public:

    std::optional<WebCore::FrameIdentifier> parentFrameID;

    bool crossOriginAccessControlCheckEnabled { true };

    URL documentURL;

    bool isCrossOriginOpenerPolicyEnabled { false };

    bool isDisplayingInitialEmptyDocument { false };

    WebCore::SandboxFlags effectiveSandboxFlags { WebCore::SandboxNone };

    URL openerURL;

    WebCore::CrossOriginOpenerPolicy sourceCrossOriginOpenerPolicy;

    uint64_t navigationID { 0 };

    std::optional<WebCore::NavigationRequester> navigationRequester;

    
#if ENABLE(SERVICE_WORKER)

    WebCore::ServiceWorkersMode serviceWorkersMode { WebCore::ServiceWorkersMode::None };

Source/WebKit/NetworkProcess/NetworkResourceLoader.cpp

#include <WebCore/RegistrableDomain.h>

#include <WebCore/SameSiteInfo.h>

#include <WebCore/SecurityOrigin.h>

61#include <WebCore/SecurityPolicy.h>

#include <WebCore/SharedBuffer.h>

#include <wtf/Expected.h>

#include <wtf/RunLoop.h>

@@bool NetworkResourceLoader::shouldInterruptWorkerLoadForCrossOriginEmbedderPolic

    return false;

}

// https://html.spec.whatwg.org/multipage/browsing-the-web.html#process-a-navigate-fetch (Step 12.5.6)

bool NetworkResourceLoader::doCrossOriginOpenerHandlingOfResponse(const ResourceResponse& response)

{

    // COOP only applies to top-level browsing contexts.

    if (!isMainFrameLoad())

        return true;

    if (!m_parameters.isCrossOriginOpenerPolicyEnabled)

        return true;

    std::unique_ptr<ContentSecurityPolicy> contentSecurityPolicy;

    if (!response.httpHeaderField(HTTPHeaderName::ContentSecurityPolicy).isNull()) {

        contentSecurityPolicy = makeUnique<ContentSecurityPolicy>(URL { response.url() }, nullptr);

        contentSecurityPolicy->didReceiveHeaders(ContentSecurityPolicyResponseHeaders { response }, originalRequest().httpReferrer(), ContentSecurityPolicy::ReportParsingErrors::No);

    }

    if (!m_currentCoopEnforcementResult) {

        auto sourceOrigin = m_parameters.sourceOrigin ? Ref { *m_parameters.sourceOrigin } : SecurityOrigin::createUnique();

        m_currentCoopEnforcementResult = CrossOriginOpenerPolicyEnforcementResult::from(m_parameters.documentURL, WTFMove(sourceOrigin), m_parameters.sourceCrossOriginOpenerPolicy, m_parameters.navigationRequester, m_parameters.openerURL);

    }

    m_currentCoopEnforcementResult = WebCore::doCrossOriginOpenerHandlingOfResponse(response, m_parameters.navigationRequester, contentSecurityPolicy.get(), m_parameters.effectiveSandboxFlags, m_parameters.isDisplayingInitialEmptyDocument, *m_currentCoopEnforcementResult, [&](COOPDisposition disposition, const CrossOriginOpenerPolicy& responseCOOP, const SecurityOrigin& responseOrigin) {

        if (responseCOOP.hasReportingEndpoint(disposition))

            send(Messages::WebPage::SendViolationReportWhenNavigatingToCOOPResponse { m_parameters.webFrameID, responseCOOP, disposition, response.url(), m_currentCoopEnforcementResult->url, responseOrigin.data(), m_currentCoopEnforcementResult->currentOrigin->data(), originalRequest().httpReferrer(), originalRequest().httpUserAgent(), response.httpHeaderField(HTTPHeaderName::ReportTo) }, m_parameters.webPageID);

        if (m_currentCoopEnforcementResult->crossOriginOpenerPolicy.hasReportingEndpoint(disposition))

            send(Messages::WebPage::SendViolationReportWhenNavigatingAwayFromCOOPResponse { m_parameters.webFrameID, m_currentCoopEnforcementResult->crossOriginOpenerPolicy, disposition, m_currentCoopEnforcementResult->url, response.url(), m_currentCoopEnforcementResult->currentOrigin->data(), responseOrigin.data(), m_currentCoopEnforcementResult->isCurrentContextNavigationSource, originalRequest().httpUserAgent() }, m_parameters.webPageID);

    });

    return !!m_currentCoopEnforcementResult;

}

static BrowsingContextGroupSwitchDecision toBrowsingContextGroupSwitchDecision(const std::optional<CrossOriginOpenerPolicyEnforcementResult>& currentCoopEnforcementResult)

{

    if (!currentCoopEnforcementResult || !currentCoopEnforcementResult->needsBrowsingContextGroupSwitch)

        return BrowsingContextGroupSwitchDecision::StayInGroup;

    if (currentCoopEnforcementResult->crossOriginOpenerPolicy.value == CrossOriginOpenerPolicyValue::SameOriginPlusCOEP)

        return BrowsingContextGroupSwitchDecision::NewIsolatedGroup;

    return BrowsingContextGroupSwitchDecision::NewSharedGroup;

}

void NetworkResourceLoader::didReceiveResponse(ResourceResponse&& receivedResponse, ResponseCompletionHandler&& completionHandler)

{

    LOADER_RELEASE_LOG("didReceiveResponse: (httpStatusCode=%d, MIMEType=%" PUBLIC_LOG_STRING ", expectedContentLength=%" PRId64 ", hasCachedEntryForValidation=%d, hasNetworkLoadChecker=%d)", receivedResponse.httpStatusCode(), receivedResponse.mimeType().utf8().data(), receivedResponse.expectedContentLength(), !!m_cacheEntryForValidation, !!m_networkLoadChecker);

@@void NetworkResourceLoader::didReceiveResponse(ResourceResponse&& receivedRespon

        return completionHandler(PolicyAction::Ignore);

    }

    if (!doCrossOriginOpenerHandlingOfResponse(m_response)) {

        LOADER_RELEASE_LOG_ERROR("didReceiveResponse: Interrupting load due to Cross-Origin-Opener-Policy");

        RunLoop::main().dispatch([protectedThis = Ref { *this }, url = m_response.url()] {

            if (protectedThis->m_networkLoad)

                protectedThis->didFailLoading(ResourceError { errorDomainWebKitInternal, 0, url, "Navigation was blocked by Cross-Origin-Opener-Policy"_s, ResourceError::Type::AccessControl });

        });

        return completionHandler(PolicyAction::Ignore);

    }

    auto response = sanitizeResponseIfPossible(ResourceResponse { m_response }, ResourceResponse::SanitizationType::CrossOriginSafe);

    if (isSynchronous()) {

        LOADER_RELEASE_LOG("didReceiveResponse: Using response for synchronous load");

@@void NetworkResourceLoader::didReceiveResponse(ResourceResponse&& receivedRespon

    // a main resource because the embedding client must decide whether to allow the load.

    bool willWaitForContinueDidReceiveResponse = isMainResource();

    LOADER_RELEASE_LOG("didReceiveResponse: Sending WebResourceLoader::DidReceiveResponse IPC (willWaitForContinueDidReceiveResponse=%d)", willWaitForContinueDidReceiveResponse);

764 send~~(Messages::WebResourceLoader::~~DidReceiveResponse { response, willWaitForContinueDidReceiveResponse });

813 sendDidReceiveResponsePotentiallyInNewBrowsingContextGroup(response, willWaitForContinueDidReceiveResponse);

    if (m_parameters.pageHasResourceLoadClient)

        m_connection->networkProcess().parentProcessConnection()->send(Messages::NetworkProcessProxy::ResourceLoadDidReceiveResponse(m_parameters.webPageProxyID, resourceLoadInfo, response), 0);

@@void NetworkResourceLoader::didReceiveResponse(ResourceResponse&& receivedRespon

    completionHandler(PolicyAction::Use);

}

void NetworkResourceLoader::sendDidReceiveResponsePotentiallyInNewBrowsingContextGroup(const WebCore::ResourceResponse& response, bool needsContinueDidReceiveResponseMessage)

{

    auto browsingContextGroupSwitchDecision = toBrowsingContextGroupSwitchDecision(m_currentCoopEnforcementResult);

    if (browsingContextGroupSwitchDecision == BrowsingContextGroupSwitchDecision::StayInGroup) {

        send(Messages::WebResourceLoader::DidReceiveResponse { response, needsContinueDidReceiveResponseMessage });

        return;

    }

    auto loader = m_connection->takeNetworkResourceLoader(coreIdentifier());

    ASSERT(loader == this);

    auto existingNetworkResourceLoadIdentifierToResume = loader->identifier();

    m_connection->networkSession()->addLoaderAwaitingWebProcessTransfer(loader.releaseNonNull());

    RegistrableDomain responseDomain { response.url() };

    m_connection->networkProcess().parentProcessConnection()->send(Messages::NetworkProcessProxy::TriggerBrowsingContextGroupSwitchForNavigation(m_parameters.webPageProxyID, m_parameters.navigationID, browsingContextGroupSwitchDecision, responseDomain, existingNetworkResourceLoadIdentifierToResume), 0);

}

void NetworkResourceLoader::didReceiveBuffer(Ref<SharedBuffer>&& buffer, int reportedEncodedDataLength)

{

    if (!m_numBytesReceived)

@@void NetworkResourceLoader::willSendRedirectedRequest(ResourceRequest&& request,

        return;

    }

    if (!doCrossOriginOpenerHandlingOfResponse(redirectResponse)) {

        didFailLoading(ResourceError { errorDomainWebKitInternal, 0, redirectRequest.url(), "Redirection was blocked by Cross-Origin-Opener-Policy"_s, ResourceError::Type::AccessControl });

        return;

    }

    if (m_networkLoadChecker) {

        if (privateClickMeasurementAttributionTriggerData)

            m_networkLoadChecker->enableContentExtensionsCheck();

@@void NetworkResourceLoader::didRetrieveCacheEntry(std::unique_ptr<NetworkCache::

        }

    }

    if (!doCrossOriginOpenerHandlingOfResponse(response)) {

        LOADER_RELEASE_LOG_ERROR("didRetrieveCacheEntry: Interrupting load due to Cross-Origin-Opener-Policy");

        didFailLoading(ResourceError { errorDomainWebKitInternal, 0, response.url(), "Navigation was blocked by Cross-Origin-Opener-Policy"_s, ResourceError::Type::AccessControl });

    }

    response = sanitizeResponseIfPossible(WTFMove(response), ResourceResponse::SanitizationType::CrossOriginSafe);

    if (isSynchronous()) {

        m_synchronousLoadData->response = WTFMove(response);

@@void NetworkResourceLoader::didRetrieveCacheEntry(std::unique_ptr<NetworkCache::

    bool needsContinueDidReceiveResponseMessage = isMainResource();

    LOADER_RELEASE_LOG("didRetrieveCacheEntry: Sending WebResourceLoader::DidReceiveResponse IPC (needsContinueDidReceiveResponseMessage=%d)", needsContinueDidReceiveResponseMessage);

1262 send~~(Messages::WebResourceLoader::~~DidReceiveResponse { response, needsContinueDidReceiveResponseMessage });

1337 sendDidReceiveResponsePotentiallyInNewBrowsingContextGroup(response, needsContinueDidReceiveResponseMessage);

    if (needsContinueDidReceiveResponseMessage) {

        m_response = WTFMove(response);

Source/WebKit/NetworkProcess/NetworkResourceLoader.h

@@public:

    void serviceWorkerDidNotHandle(ServiceWorkerFetchTask*);

#endif

    bool doCrossOriginOpenerHandlingOfResponse(const WebCore::ResourceResponse&);

    void sendDidReceiveResponsePotentiallyInNewBrowsingContextGroup(const WebCore::ResourceResponse&, bool needsContinueDidReceiveResponseMessage);

    bool isAppInitiated();

private:

@@private:

    NetworkResourceLoadIdentifier m_resourceLoadID;

    WebCore::ResourceResponse m_redirectResponse;

    URL m_firstResponseURL; // First URL in response's URL list (https://fetch.spec.whatwg.org/#concept-response-url-list).

263 std::optional<WebCore::CrossOriginOpenerPolicyEnforcementResult> m_currentCoopEnforcementResult;

};

} // namespace WebKit

Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerFetchTask.cpp

@@void ServiceWorkerFetchTask::didReceiveResponse(ResourceResponse&& response, boo

        }

    }

    if (!m_loader.doCrossOriginOpenerHandlingOfResponse(response)) {

        didFail(ResourceError { errorDomainWebKitInternal, 0, response.url(), "Navigation was blocked by Cross-Origin-Opener-Policy"_s, ResourceError::Type::AccessControl });

        return;

    }

163168 response.setSource(ResourceResponse::Source::ServiceWorker);

164 ~~sendToClient(Messages::WebResourceL~~oader::DidReceiveResponse { response, needsContinueDidReceiveResponseMessage });

169 m_loader.sendDidReceiveResponsePotentiallyInNewBrowsingContextGroup(response, needsContinueDidReceiveResponseMessage);

    if (needsContinueDidReceiveResponseMessage)

        m_loader.setResponse(WTFMove(response));

}

Source/WebKit/Scripts/webkit/messages.py

@@def types_that_cannot_be_forward_declared():

        'WebKit::LibWebRTCResolverIdentifier',

        'WebKit::MDNSRegisterIdentifier',

        'WebKit::MediaRecorderIdentifier',

330 'WebKit::NetworkResourceLoadIdentifier',

        'WebKit::PDFPluginIdentifier',

        'WebKit::PageGroupIdentifier',

        'WebKit::PlaybackSessionContextIdentifier',

@@def headers_for_type(type):

        'WebCore::AutoplayEventFlags': ['<WebCore/AutoplayEvent.h>'],

        'WebCore::BrowsingContextGroupSwitchDecision': ['<WebCore/FrameLoaderTypes.h>'],

        'WebCore::COEPDisposition': ['<WebCore/CrossOriginEmbedderPolicy.h>'],

697 'WebCore::COOPDisposition': ['<WebCore/CrossOriginOpenerPolicy.h>'],

        'WebCore::CreateNewGroupForHighlight': ['<WebCore/AppHighlight.h>'],

        'WebCore::DOMPasteAccessResponse': ['<WebCore/DOMPasteAccess.h>'],

        'WebCore::DestinationColorSpace': ['<WebCore/ColorSpace.h>'],

Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp

@@void NetworkProcessProxy::didNegotiateModernTLS(WebPageProxyIdentifier pageID, c

        page->didNegotiateModernTLS(url);

}

void NetworkProcessProxy::triggerBrowsingContextGroupSwitchForNavigation(WebPageProxyIdentifier pageID, uint64_t navigationID, BrowsingContextGroupSwitchDecision browsingContextGroupSwitchDecision, WebCore::RegistrableDomain responseDomain, NetworkResourceLoadIdentifier existingNetworkResourceLoadIdentifierToResume)

{

    RELEASE_LOG(ProcessSwapping, "%p - NetworkProcessProxy::triggerBrowsingContextGroupSwitchForNavigation: pageID=%" PRIu64 ", navigationID=%" PRIu64 ", browsingContextGroupSwitchDecision=%u, existingNetworkResourceLoadIdentifierToResume=%" PRIu64, this, pageID.toUInt64(), navigationID, (unsigned)browsingContextGroupSwitchDecision, existingNetworkResourceLoadIdentifierToResume.toUInt64());

    if (auto* page = pageID ? WebProcessProxy::webPage(pageID) : nullptr)

        page->triggerBrowsingContextGroupSwitchForNavigation(navigationID, browsingContextGroupSwitchDecision, responseDomain, existingNetworkResourceLoadIdentifierToResume);

}

void NetworkProcessProxy::didFinishLaunching(ProcessLauncher* launcher, IPC::Connection::Identifier connectionIdentifier)

{

    AuxiliaryProcessProxy::didFinishLaunching(launcher, connectionIdentifier);

@@void NetworkProcessProxy::terminateUnresponsiveServiceWorkerProcesses(WebCore::P

    }

}

void NetworkProcessProxy::prepareLoadForWebProcessTransfer(WebCore::ProcessIdentifier sourceProcessIdentifier, std::optional<WebCore::ResourceLoaderIdentifier> resourceLoadIdentifier, CompletionHandler<void(std::optional<NetworkResourceLoadIdentifier>)>&& completionHandler)

{

    RELEASE_LOG(ProcessSwapping, "%p - NetworkProcessProxy::prepareLoadForWebProcessTransfer: sourceProcessIdentifier: %" PRIu64 ", resourceLoadIdentifier: %" PRIu64, this, sourceProcessIdentifier.toUInt64(), resourceLoadIdentifier ? resourceLoadIdentifier->toUInt64() : 0);

    if (!resourceLoadIdentifier) {

        completionHandler({ });

        return;

    }

    sendWithAsyncReply(Messages::NetworkProcess::PrepareLoadForWebProcessTransfer(sourceProcessIdentifier, resourceLoadIdentifier), WTFMove(completionHandler));

}

void NetworkProcessProxy::logDiagnosticMessageWithResult(WebPageProxyIdentifier pageID, const String& message, const String& description, uint32_t result, WebCore::ShouldSample shouldSample)

{

    WebPageProxy* page = WebProcessProxy::webPage(pageID);

Source/WebKit/UIProcess/Network/NetworkProcessProxy.h

@@public:

    void testProcessIncomingSyncMessagesWhenWaitingForSyncReply(WebPageProxyIdentifier, Messages::NetworkProcessProxy::TestProcessIncomingSyncMessagesWhenWaitingForSyncReplyDelayedReply&&);

    void terminateUnresponsiveServiceWorkerProcesses(WebCore::ProcessIdentifier);

217 void prepareLoadForWebProcessTransfer(WebCore::ProcessIdentifier sourceProcessIdentifier, std::optional<WebCore::ResourceLoaderIdentifier>, CompletionHandler<void(std::optional<NetworkResourceLoadIdentifier>)>&&);

218

    ProcessThrottler& throttler() final { return m_throttler; }

    void updateProcessAssertion();

@@private:

    void terminateWebProcess(WebCore::ProcessIdentifier);

323 void triggerBrowsingContextGroupSwitchForNavigation(WebPageProxyIdentifier, uint64_t navigationID, WebCore::BrowsingContextGroupSwitchDecision, WebCore::RegistrableDomain responseDomain, NetworkResourceLoadIdentifier existingNetworkResourceLoadIdentifierToResume);

324

    void requestStorageSpace(PAL::SessionID, const WebCore::ClientOrigin&, uint64_t quota, uint64_t currentSize, uint64_t spaceRequired, CompletionHandler<void(std::optional<uint64_t> quota)>&&);

    WebsiteDataStore* websiteDataStoreFromSessionID(PAL::SessionID);

Source/WebKit/UIProcess/Network/NetworkProcessProxy.messages.in

@@messages -> NetworkProcessProxy LegacyReceiver {

    ResourceLoadDidReceiveResponse(WebKit::WebPageProxyIdentifier pageIdentifier, struct WebKit::ResourceLoadInfo resourceLoadInfo, WebCore::ResourceResponse response)

    ResourceLoadDidCompleteWithError(WebKit::WebPageProxyIdentifier pageIdentifier, struct WebKit::ResourceLoadInfo resourceLoadInfo, WebCore::ResourceResponse response, WebCore::ResourceError error)

76 TriggerBrowsingContextGroupSwitchForNavigation(WebKit::WebPageProxyIdentifier pageIdentifier, uint64_t navigationID, enum:uint8_t WebCore::BrowsingContextGroupSwitchDecision browsingContextGroupSwitchDecision, WebCore::RegistrableDomain responseDomain, WebKit::NetworkResourceLoadIdentifier existingNetworkResourceLoadIdentifierToResume)

77

#if USE(SOUP)

    DidExceedMemoryLimit()

#endif

Source/WebKit/UIProcess/ProvisionalPageProxy.cpp

@@void ProvisionalPageProxy::decidePolicyForNavigationActionAsync(FrameIdentifier

    m_page.decidePolicyForNavigationActionAsyncShared(m_process.copyRef(), m_webPageID, frameID, WTFMove(frameInfo), identifier, navigationID, WTFMove(navigationActionData), WTFMove(originatingFrameInfo), originatingPageID, originalRequest, WTFMove(request), WTFMove(requestBody), WTFMove(redirectResponse), userData, listenerID);

}

336 void ProvisionalPageProxy::decidePolicyForResponse(FrameIdentifier frameID, FrameInfoData&& frameInfo, WebCore::PolicyCheckIdentifier identifier, uint64_t navigationID, const WebCore::ResourceResponse& response, const WebCore::ResourceRequest& request, bool canShowMIMEType, const String& downloadAttribute, bool wasAllowedByInjectedBundle, ~~BrowsingContextGroupSwitchDecision browsingContextGroupSwitchDecision, std::optional<WebCore::ResourceLoaderIdentifier> mainResourceLoadIdentifier,~~ uint64_t listenerID, const UserData& userData)

336void ProvisionalPageProxy::decidePolicyForResponse(FrameIdentifier frameID, FrameInfoData&& frameInfo, WebCore::PolicyCheckIdentifier identifier, uint64_t navigationID, const WebCore::ResourceResponse& response, const WebCore::ResourceRequest& request, bool canShowMIMEType, const String& downloadAttribute, bool wasAllowedByInjectedBundle, uint64_t listenerID, const UserData& userData)

{

    if (!validateInput(frameID, navigationID))

        return;

341 m_page.decidePolicyForResponseShared(m_process.copyRef(), m_webPageID, frameID, WTFMove(frameInfo), identifier, navigationID, response, request, canShowMIMEType, downloadAttribute, wasAllowedByInjectedBundle, ~~browsingContextGroupSwitchDecision, mainResourceLoadIdentifier,~~ listenerID, userData);

341 m_page.decidePolicyForResponseShared(m_process.copyRef(), m_webPageID, frameID, WTFMove(frameInfo), identifier, navigationID, response, request, canShowMIMEType, downloadAttribute, wasAllowedByInjectedBundle, listenerID, userData);

}

void ProvisionalPageProxy::didPerformServerRedirect(const String& sourceURLString, const String& destinationURLString, FrameIdentifier frameID)

Source/WebKit/UIProcess/ProvisionalPageProxy.h

@@private:

    bool sendMessage(UniqueRef<IPC::Encoder>&&, OptionSet<IPC::SendOption>, std::optional<std::pair<CompletionHandler<void(IPC::Decoder*)>, uint64_t>>&&) final;

    void decidePolicyForNavigationActionAsync(WebCore::FrameIdentifier, FrameInfoData&&, WebCore::PolicyCheckIdentifier, uint64_t navigationID, NavigationActionData&&, FrameInfoData&& originatingFrameInfo, std::optional<WebPageProxyIdentifier> originatingPageID, const WebCore::ResourceRequest& originalRequest, WebCore::ResourceRequest&&, IPC::FormDataReference&& requestBody, WebCore::ResourceResponse&& redirectResponse, const UserData&, uint64_t listenerID);

128 void decidePolicyForResponse(WebCore::FrameIdentifier, FrameInfoData&&, WebCore::PolicyCheckIdentifier, uint64_t navigationID, const WebCore::ResourceResponse&, const WebCore::ResourceRequest&, bool canShowMIMEType, const String& downloadAttribute, bool wasAllowedByInjectedBundle, ~~WebCore::BrowsingContextGroupSwitchDecision, std::optional<WebCore::ResourceLoaderIdentifier> mainResourceLoadIdentifier,~~ uint64_t listenerID, const UserData&);

128 void decidePolicyForResponse(WebCore::FrameIdentifier, FrameInfoData&&, WebCore::PolicyCheckIdentifier, uint64_t navigationID, const WebCore::ResourceResponse&, const WebCore::ResourceRequest&, bool canShowMIMEType, const String& downloadAttribute, bool wasAllowedByInjectedBundle, uint64_t listenerID, const UserData&);

    void didChangeProvisionalURLForFrame(WebCore::FrameIdentifier, uint64_t navigationID, URL&&);

    void didPerformServerRedirect(const String& sourceURLString, const String& destinationURLString, WebCore::FrameIdentifier);

    void didReceiveServerRedirectForProvisionalLoadForFrame(WebCore::FrameIdentifier, uint64_t navigationID, WebCore::ResourceRequest&&, const UserData&);

Source/WebKit/UIProcess/WebPageProxy.cpp

@@void WebPageProxy::continueNavigationInNewProcess(API::Navigation& navigation, s

    }

    bool isServerSideRedirect = shouldTreatAsContinuingLoad == ShouldTreatAsContinuingLoad::YesAfterNavigationPolicyDecision && navigation.currentRequestIsRedirect();

3649 bool shouldClosePreviousPageAfterCommit = shouldTreatAsContinuingLoad == ShouldTreatAsContinuingLoad::YesAfter~~ResponsePolicyDec~~ision;

3649 bool shouldClosePreviousPageAfterCommit = shouldTreatAsContinuingLoad == ShouldTreatAsContinuingLoad::YesAfterProvisionalLoadStarted;

    m_provisionalPage = makeUnique<ProvisionalPageProxy>(*this, WTFMove(newProcess), WTFMove(suspendedPage), navigation.navigationID(), isServerSideRedirect, navigation.currentRequest(), processSwapRequestedByClient, shouldClosePreviousPageAfterCommit, websitePolicies.get());

    auto continuation = [this, protectedThis = Ref { *this }, navigation = Ref { navigation }, shouldTreatAsContinuingLoad, websitePolicies = WTFMove(websitePolicies), existingNetworkResourceLoadIdentifierToResume]() mutable {

        if (auto* item = navigation->targetItem()) {

@@void WebPageProxy::decidePolicyForNewWindowAction(FrameIdentifier frameID, Frame

void WebPageProxy::decidePolicyForResponse(FrameIdentifier frameID, FrameInfoData&& frameInfo, PolicyCheckIdentifier identifier,

    uint64_t navigationID, const ResourceResponse& response, const ResourceRequest& request, bool canShowMIMEType, const String& downloadAttribute,

5634 bool wasAllowedByInjectedBundle~~, BrowsingContextGroupSwitchDecision browsingContextGroupSwitchDecision, std::optional<WebCore::ResourceLoaderIdentifier> mainResourceLoadIdentifier~~, uint64_t listenerID, const UserData& userData)

5634 bool wasAllowedByInjectedBundle, uint64_t listenerID, const UserData& userData)

56355635{

5636 decidePolicyForResponseShared(m_process.copyRef(), m_webPageID, frameID, WTFMove(frameInfo), identifier, navigationID, response, request, canShowMIMEType, downloadAttribute, wasAllowedByInjectedBundle, ~~browsingContextGroupSwitchDecision, mainResourceLoadIdentifier,~~ listenerID, userData);

5636 decidePolicyForResponseShared(m_process.copyRef(), m_webPageID, frameID, WTFMove(frameInfo), identifier, navigationID, response, request, canShowMIMEType, downloadAttribute, wasAllowedByInjectedBundle, listenerID, userData);

56375637}

56385638

5639 void WebPageProxy::decidePolicyForResponseShared(Ref<WebProcessProxy>&& process, PageIdentifier webPageID, FrameIdentifier frameID, FrameInfoData&& frameInfo, PolicyCheckIdentifier identifier, uint64_t navigationID, const ResourceResponse& response, const ResourceRequest& request, bool canShowMIMEType, const String& downloadAttribute, bool wasAllowedByInjectedBundle, ~~BrowsingContextGroupSwitchDecision browsingContextGroupSwitchDecision, std::optional<WebCore::ResourceLoaderIdentifier> mainResourceLoadIdentifier,~~ uint64_t listenerID, const UserData& userData)

5639void WebPageProxy::decidePolicyForResponseShared(Ref<WebProcessProxy>&& process, PageIdentifier webPageID, FrameIdentifier frameID, FrameInfoData&& frameInfo, PolicyCheckIdentifier identifier, uint64_t navigationID, const ResourceResponse& response, const ResourceRequest& request, bool canShowMIMEType, const String& downloadAttribute, bool wasAllowedByInjectedBundle, uint64_t listenerID, const UserData& userData)

{

    PageClientProtector protector(pageClient());

@@void WebPageProxy::decidePolicyForResponseShared(Ref<WebProcessProxy>&& process,

    RefPtr<API::Navigation> navigation = navigationID ? m_navigationState->navigation(navigationID) : nullptr;

    auto navigationResponse = API::NavigationResponse::create(API::FrameInfo::create(WTFMove(frameInfo), this).get(), request, response, canShowMIMEType, downloadAttribute);

5652 Ref listener = frame->setUpPolicyListenerProxy([this, protectedThis = Ref { *this }, webPageID, frameID, ~~browsingContextGroupSwitchDecision, mainResourceLoadIdentifier,~~ identifier, listenerID, navigation = WTFMove(navigation),

5652 Ref listener = frame->setUpPolicyListenerProxy([this, protectedThis = Ref { *this }, webPageID, frameID, identifier, listenerID, navigation = WTFMove(navigation),

        process, navigationResponse] (PolicyAction policyAction, API::WebsitePolicies*, ProcessSwapRequestedByClient processSwapRequestedByClient, RefPtr<SafeBrowsingWarning>&& safeBrowsingWarning, std::optional<NavigatingToAppBoundDomain> isNavigatingToAppBoundDomain) mutable {

        // FIXME: Assert the API::WebsitePolicies* is nullptr here once clients of WKFramePolicyListenerUseWithPolicies go away.

        RELEASE_ASSERT(processSwapRequestedByClient == ProcessSwapRequestedByClient::No);

@@void WebPageProxy::decidePolicyForResponseShared(Ref<WebProcessProxy>&& process,

        auto sender = PolicyDecisionSender::create(identifier, [webPageID, frameID, listenerID, process] (const auto& policyDecision) {

            process->send(Messages::WebPage::DidReceivePolicyDecision(frameID, listenerID, policyDecision, createNetworkExtensionsSandboxExtensions(process)), webPageID);

        });

        auto willContinueLoadInNewProcess = WillContinueLoadInNewProcess::No;

        if (policyAction == PolicyAction::Use && browsingContextGroupSwitchDecision != BrowsingContextGroupSwitchDecision::StayInGroup && navigation) {

            WEBPAGEPROXY_RELEASE_LOG(ProcessSwapping, "decidePolicyForResponseShared: Process-swapping due to Cross-Origin-Opener-Policy, newProcessIsCrossOriginIsolated=%d", browsingContextGroupSwitchDecision == BrowsingContextGroupSwitchDecision::NewIsolatedGroup);

            RefPtr<WebProcessProxy> processForNavigation;

            if (browsingContextGroupSwitchDecision == BrowsingContextGroupSwitchDecision::NewIsolatedGroup)

                processForNavigation = m_process->processPool().createNewWebProcess(&websiteDataStore(), WebProcessProxy::IsPrewarmed::No, CrossOriginMode::Isolated);

            else {

                RegistrableDomain responseDomain { navigationResponse->response().url() };

                processForNavigation = m_process->processPool().processForRegistrableDomain(websiteDataStore(), this, responseDomain);

            }

            websiteDataStore().networkProcess().prepareLoadForWebProcessTransfer(process->coreProcessIdentifier(), mainResourceLoadIdentifier, [this, protectedThis = WTFMove(protectedThis), navigation, navigationResponse = WTFMove(navigationResponse), sender = WTFMove(sender), processForNavigation = processForNavigation.releaseNonNull()](auto existingNetworkResourceLoadIdentifierToResume) mutable {

                continueNavigationInNewProcess(*navigation, nullptr, WTFMove(processForNavigation), ProcessSwapRequestedByClient::No, ShouldTreatAsContinuingLoad::YesAfterResponsePolicyDecision, nullptr, existingNetworkResourceLoadIdentifierToResume);

                receivedPolicyDecision(PolicyAction::Ignore, navigation.get(), nullptr, WTFMove(navigationResponse), WTFMove(sender), { }, WillContinueLoadInNewProcess::Yes);

            });

            return;

        }

56795661

5680 receivedPolicyDecision(policyAction, navigation.get(), nullptr, WTFMove(navigationResponse), WTFMove(sender)~~, { }, willContinueLoadInNewProcess~~);

5662 receivedPolicyDecision(policyAction, navigation.get(), nullptr, WTFMove(navigationResponse), WTFMove(sender));

    }, ShouldExpectSafeBrowsingResult::No, ShouldExpectAppBoundDomainResult::No);

    if (wasAllowedByInjectedBundle) {

@@void WebPageProxy::decidePolicyForResponseShared(Ref<WebProcessProxy>&& process,

        m_navigationClient->decidePolicyForNavigationResponse(*this, WTFMove(navigationResponse), WTFMove(listener), process->transformHandlesToObjects(userData.object()).get());

}

void WebPageProxy::triggerBrowsingContextGroupSwitchForNavigation(uint64_t navigationID, BrowsingContextGroupSwitchDecision browsingContextGroupSwitchDecision, WebCore::RegistrableDomain responseDomain, NetworkResourceLoadIdentifier existingNetworkResourceLoadIdentifierToResume)

{

    ASSERT(browsingContextGroupSwitchDecision != BrowsingContextGroupSwitchDecision::StayInGroup);

    RefPtr<API::Navigation> navigation = navigationID ? m_navigationState->navigation(navigationID) : nullptr;

    WEBPAGEPROXY_RELEASE_LOG(ProcessSwapping, "triggerBrowsingContextGroupSwitchForNavigation: Process-swapping due to Cross-Origin-Opener-Policy, newProcessIsCrossOriginIsolated=%d, navigation=%p", browsingContextGroupSwitchDecision == BrowsingContextGroupSwitchDecision::NewIsolatedGroup, navigation.get());

    if (!navigation)

        return;

    RefPtr<WebProcessProxy> processForNavigation;

    if (browsingContextGroupSwitchDecision == BrowsingContextGroupSwitchDecision::NewIsolatedGroup)

        processForNavigation = m_process->processPool().createNewWebProcess(&websiteDataStore(), WebProcessProxy::IsPrewarmed::No, CrossOriginMode::Isolated);

    else

        processForNavigation = m_process->processPool().processForRegistrableDomain(websiteDataStore(), this, responseDomain);

    continueNavigationInNewProcess(*navigation, nullptr, processForNavigation.releaseNonNull(), ProcessSwapRequestedByClient::No, ShouldTreatAsContinuingLoad::YesAfterProvisionalLoadStarted, nullptr, existingNetworkResourceLoadIdentifierToResume);

}

void WebPageProxy::unableToImplementPolicy(FrameIdentifier frameID, const ResourceError& error, const UserData& userData)

{

    PageClientProtector protector(pageClient());

Source/WebKit/UIProcess/WebPageProxy.h

@@public:

    WebCore::Color underlayColor() const { return m_underlayColor; }

    void setUnderlayColor(const WebCore::Color&);

688 void triggerBrowsingContextGroupSwitchForNavigation(uint64_t navigationID, WebCore::BrowsingContextGroupSwitchDecision, WebCore::RegistrableDomain responseDomain, NetworkResourceLoadIdentifier existingNetworkResourceLoadIdentifierToResume);

689

    // At this time, m_pageExtendedBackgroundColor can be set via pageExtendedBackgroundColorDidChange() which is a message

    // from the UIProcess, or by didCommitLayerTree(). When PLATFORM(MAC) adopts UI side compositing, we should get rid of

    // the message entirely.

@@public:

    void didNavigateWithNavigationDataShared(Ref<WebProcessProxy>&&, const WebNavigationDataStore&, WebCore::FrameIdentifier);

    void didChangeProvisionalURLForFrameShared(Ref<WebProcessProxy>&&, WebCore::FrameIdentifier, uint64_t navigationID, URL&&);

    void decidePolicyForNavigationActionAsyncShared(Ref<WebProcessProxy>&&, WebCore::PageIdentifier, WebCore::FrameIdentifier, FrameInfoData&&, WebCore::PolicyCheckIdentifier, uint64_t navigationID, NavigationActionData&&, FrameInfoData&& originatingFrameInfo, std::optional<WebPageProxyIdentifier> originatingPageID, const WebCore::ResourceRequest& originalRequest, WebCore::ResourceRequest&&, IPC::FormDataReference&& requestBody, WebCore::ResourceResponse&& redirectResponse, const UserData&, uint64_t listenerID);

1749 void decidePolicyForResponseShared(Ref<WebProcessProxy>&&, WebCore::PageIdentifier, WebCore::FrameIdentifier, FrameInfoData&&, WebCore::PolicyCheckIdentifier, uint64_t navigationID, const WebCore::ResourceResponse&, const WebCore::ResourceRequest&, bool canShowMIMEType, const String& downloadAttribute, bool wasAllowedByInjectedBundle, ~~WebCore::BrowsingContextGroupSwitchDecision, std::optional<WebCore::ResourceLoaderIdentifier> mainResourceLoadIdentifier,~~ uint64_t listenerID, const UserData&);

1751 void decidePolicyForResponseShared(Ref<WebProcessProxy>&&, WebCore::PageIdentifier, WebCore::FrameIdentifier, FrameInfoData&&, WebCore::PolicyCheckIdentifier, uint64_t navigationID, const WebCore::ResourceResponse&, const WebCore::ResourceRequest&, bool canShowMIMEType, const String& downloadAttribute, bool wasAllowedByInjectedBundle, uint64_t listenerID, const UserData&);

    void startURLSchemeTaskShared(Ref<WebProcessProxy>&&, WebCore::PageIdentifier, URLSchemeTaskParameters&&);

    void loadDataWithNavigationShared(Ref<WebProcessProxy>&&, WebCore::PageIdentifier, API::Navigation&, const IPC::DataReference&, const String& MIMEType, const String& encoding, const String& baseURL, API::Object* userData, WebCore::ShouldTreatAsContinuingLoad, std::optional<NavigatingToAppBoundDomain>, std::optional<WebsitePoliciesData>&&, WebCore::ShouldOpenExternalURLsPolicy, WebCore::SubstituteData::SessionHistoryVisibility);

    void loadRequestWithNavigationShared(Ref<WebProcessProxy>&&, WebCore::PageIdentifier, API::Navigation&, WebCore::ResourceRequest&&, WebCore::ShouldOpenExternalURLsPolicy, API::Object* userData, WebCore::ShouldTreatAsContinuingLoad, std::optional<NavigatingToAppBoundDomain>, std::optional<WebsitePoliciesData>&& = std::nullopt, std::optional<NetworkResourceLoadIdentifier> existingNetworkResourceLoadIdentifierToResume = std::nullopt);

@@private:

    void decidePolicyForNewWindowAction(WebCore::FrameIdentifier, FrameInfoData&&, WebCore::PolicyCheckIdentifier, NavigationActionData&&,

        WebCore::ResourceRequest&&, const String& frameName, uint64_t listenerID, const UserData&);

    void decidePolicyForResponse(WebCore::FrameIdentifier, FrameInfoData&&, WebCore::PolicyCheckIdentifier, uint64_t navigationID,

2067 const WebCore::ResourceResponse&, const WebCore::ResourceRequest&, bool canShowMIMEType, const String& downloadAttribute, bool wasAllowedByInjectedBundle, ~~WebCore::BrowsingContextGroupSwitchDecision, std::optional<WebCore::ResourceLoaderIdentifier> mainResourceLoadIdentifier,~~ uint64_t listenerID, const UserData&);

2069 const WebCore::ResourceResponse&, const WebCore::ResourceRequest&, bool canShowMIMEType, const String& downloadAttribute, bool wasAllowedByInjectedBundle, uint64_t listenerID, const UserData&);

    void unableToImplementPolicy(WebCore::FrameIdentifier, const WebCore::ResourceError&, const UserData&);

    void beginSafeBrowsingCheck(const URL&, bool, WebFramePolicyListenerProxy&);

Source/WebKit/UIProcess/WebPageProxy.messages.in

@@messages -> WebPageProxy {

#endif

    # Policy messages

110 DecidePolicyForResponse(WebCore::FrameIdentifier frameID, struct WebKit::FrameInfoData frameInfo, WebCore::PolicyCheckIdentifier policyCheckIdentifier, uint64_t navigationID, WebCore::ResourceResponse response, WebCore::ResourceRequest request, bool canShowMIMEType, String downloadAttribute, bool wasAllowedByInjectedBundle, ~~enum:uint8_t WebCore::BrowsingContextGroupSwitchDecision browsingContextGroupSwitchDecision, std::optional<WebCore::ResourceLoaderIdentifier> mainResourceLoadIdentifier,~~ uint64_t listenerID, WebKit::UserData userData)

110 DecidePolicyForResponse(WebCore::FrameIdentifier frameID, struct WebKit::FrameInfoData frameInfo, WebCore::PolicyCheckIdentifier policyCheckIdentifier, uint64_t navigationID, WebCore::ResourceResponse response, WebCore::ResourceRequest request, bool canShowMIMEType, String downloadAttribute, bool wasAllowedByInjectedBundle, uint64_t listenerID, WebKit::UserData userData)

    DecidePolicyForNavigationActionAsync(WebCore::FrameIdentifier frameID, struct WebKit::FrameInfoData frameInfo, WebCore::PolicyCheckIdentifier policyCheckIdentifier, uint64_t navigationID, struct WebKit::NavigationActionData navigationActionData, struct WebKit::FrameInfoData originatingFrameInfoData, std::optional<WebKit::WebPageProxyIdentifier> originatingPageID, WebCore::ResourceRequest originalRequest, WebCore::ResourceRequest request, IPC::FormDataReference requestBody, WebCore::ResourceResponse redirectResponse, WebKit::UserData userData, uint64_t listenerID)

    DecidePolicyForNavigationActionSync(WebCore::FrameIdentifier frameID, bool isMainFrame, struct WebKit::FrameInfoData frameInfo, WebCore::PolicyCheckIdentifier policyCheckIdentifier, uint64_t navigationID, struct WebKit::NavigationActionData navigationActionData, struct WebKit::FrameInfoData originatingFrameInfoData, std::optional<WebKit::WebPageProxyIdentifier> originatingPageID, WebCore::ResourceRequest originalRequest, WebCore::ResourceRequest request, IPC::FormDataReference requestBody, WebCore::ResourceResponse redirectResponse, WebKit::UserData userData) -> (struct WebKit::PolicyDecision PolicyDecision) Synchronous

    DecidePolicyForNewWindowAction(WebCore::FrameIdentifier frameID, struct WebKit::FrameInfoData frameInfo, WebCore::PolicyCheckIdentifier policyCheckIdentifier, struct WebKit::NavigationActionData navigationActionData, WebCore::ResourceRequest request, String frameName, uint64_t listenerID, WebKit::UserData userData)

Source/WebKit/WebProcess/Network/WebLoaderStrategy.cpp

#include "NetworkResourceLoadParameters.h"

#include "WebCompiledContentRuleList.h"

#include "WebCoreArgumentCoders.h"

36#include "WebDocumentLoader.h"

#include "WebErrors.h"

#include "WebFrame.h"

#include "WebFrameLoaderClient.h"

@@void WebLoaderStrategy::scheduleLoadFromNetworkProcess(ResourceLoader& resourceL

    loadParameters.shouldRestrictHTTPResponseAccess = shouldPerformSecurityChecks();

    loadParameters.isMainFrameNavigation = resourceLoader.frame() && resourceLoader.frame()->isMainFrame() && resourceLoader.options().mode == FetchOptions::Mode::Navigate;

402 if (loadParameters.isMainFrameNavigation && document)

403 loadParameters.sourceCrossOriginOpenerPolicy = document->crossOriginOpenerPolicy();

401404

402405 loadParameters.isMainResourceNavigationForAnyFrame = resourceLoader.frame() && resourceLoader.options().mode == FetchOptions::Mode::Navigate;

    if (loadParameters.isMainResourceNavigationForAnyFrame) {

        if (auto documentLoader = resourceLoader.documentLoader()) {

            loadParameters.navigationID = static_cast<WebDocumentLoader&>(*documentLoader).navigationID();

            loadParameters.navigationRequester = documentLoader->triggeringAction().requester();

        }

    }

    loadParameters.isCrossOriginOpenerPolicyEnabled = document && document->settings().crossOriginOpenerPolicyEnabled();

    loadParameters.isDisplayingInitialEmptyDocument = frame && frame->loader().stateMachine().isDisplayingInitialEmptyDocument();

    if (frame)

        loadParameters.effectiveSandboxFlags = frame->loader().effectiveSandboxFlags();

    if (auto openerFrame = frame ? frame->loader().opener() : nullptr) {

        if (auto openerDocument = openerFrame->document())

            loadParameters.openerURL = openerDocument->url();

    }

    loadParameters.shouldEnableCrossOriginResourcePolicy = !loadParameters.isMainFrameNavigation;

Source/WebKit/WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp

@@void WebFrameLoaderClient::dispatchDidStartProvisionalLoad()

    webPage->injectedBundleLoaderClient().didStartProvisionalLoadForFrame(*webPage, m_frame, userData);

    RefPtr provisionalLoader = static_cast<WebDocumentLoader*>(m_frame->coreFrame()->loader().provisionalDocumentLoader());

533 if (!provisionalLoader || provisionalLoader->isContinuingLoadAfterResp~~onsePolicyCheck~~())

533 if (!provisionalLoader || provisionalLoader->isContinuingLoadAfterProvisionalLoadStarted())

        return;

    auto& url = provisionalLoader->url();

@@void WebFrameLoaderClient::dispatchShow()

    webPage->show();

}

820 void WebFrameLoaderClient::dispatchDecidePolicyForResponse(const ResourceResponse& response, const ResourceRequest& request, WebCore::PolicyCheckIdentifier identifier, const String& downloadAttribute, ~~BrowsingContextGroupSwitchDecision browsingContextGroupSwitchDecision,~~ FramePolicyFunction&& function)

820void WebFrameLoaderClient::dispatchDecidePolicyForResponse(const ResourceResponse& response, const ResourceRequest& request, WebCore::PolicyCheckIdentifier identifier, const String& downloadAttribute, FramePolicyFunction&& function)

{

    auto* webPage = m_frame->page();

    if (!webPage) {

@@void WebFrameLoaderClient::dispatchDecidePolicyForResponse(const ResourceRespons

    WKBundlePagePolicyAction policy = webPage->injectedBundlePolicyClient().decidePolicyForResponse(webPage, m_frame.ptr(), response, request, userData);

    // If a browsing context switch is requested, we still need to send the IPC to the UIProcess in order to process-swap if necessary, even though the

    // injected bundle has already handled the policy decision.

841 if (policy == WKBundlePagePolicyActionUse ~~&& browsingContextGroupSwitchDecision == BrowsingContextGroupSwitchDecision::StayInGroup~~) {

841 if (policy == WKBundlePagePolicyActionUse) {

        WEBFRAMELOADERCLIENT_RELEASE_LOG(Network, "dispatchDecidePolicyForResponse: continuing because injected bundle says so");

        function(PolicyAction::Use, identifier);

        return;

@@void WebFrameLoaderClient::dispatchDecidePolicyForResponse(const ResourceRespons

    auto* coreFrame = m_frame->coreFrame();

    auto* policyDocumentLoader = coreFrame ? coreFrame->loader().provisionalDocumentLoader() : nullptr;

    auto navigationID = policyDocumentLoader ? static_cast<WebDocumentLoader&>(*policyDocumentLoader).navigationID() : 0;

    std::optional<WebCore::ResourceLoaderIdentifier> mainResourceLoadIdentifier;

    if (auto mainResourceLoader = policyDocumentLoader ? policyDocumentLoader->mainResourceLoader() : nullptr)

        mainResourceLoadIdentifier = mainResourceLoader->identifier();

    bool wasAllowedByInjectedBundle = policy == WKBundlePagePolicyActionUse;

    auto protector = m_frame.copyRef();

    uint64_t listenerID = m_frame->setUpPolicyListener(identifier, WTFMove(function), WebFrame::ForNavigationAction::No);

859 if (!webPage->send(Messages::WebPageProxy::DecidePolicyForResponse(m_frame->frameID(), m_frame->info(), identifier, navigationID, response, request, canShowResponse, downloadAttribute, wasAllowedByInjectedBundle, ~~browsingContextGroupSwitchDecision, mainResourceLoadIdentifier,~~ listenerID, UserData(WebProcess::singleton().transformObjectsToHandles(userData.get()).get())))) {

856 if (!webPage->send(Messages::WebPageProxy::DecidePolicyForResponse(m_frame->frameID(), m_frame->info(), identifier, navigationID, response, request, canShowResponse, downloadAttribute, wasAllowedByInjectedBundle, listenerID, UserData(WebProcess::singleton().transformObjectsToHandles(userData.get()).get())))) {

        WEBFRAMELOADERCLIENT_RELEASE_LOG(Network, "dispatchDecidePolicyForResponse: ignoring because WebPageProxy::DecidePolicyForResponse failed");

        m_frame->didReceivePolicyDecision(listenerID, PolicyDecision { identifier, std::nullopt, PolicyAction::Ignore, 0, { }, { } });

    }

@@void WebFrameLoaderClient::dispatchDecidePolicyForNavigationAction(const Navigat

    uint64_t listenerID = m_frame->setUpPolicyListener(requestIdentifier, WTFMove(function), WebFrame::ForNavigationAction::Yes);

    ASSERT(navigationAction.requester());

959 auto requester = navigationAction.requester().value();

956 auto& requester = navigationAction.requester().value();

960957

961 auto* requestingFrame = requester.globalFrameIdentifier().frameID ? WebProcess::singleton().webFrame(requester.globalFrameIdentifier~~().~~frameID) : nullptr;

958 auto* requestingFrame = requester.globalFrameIdentifier && requester.globalFrameIdentifier->frameID ? WebProcess::singleton().webFrame(requester.globalFrameIdentifier->frameID) : nullptr;

    std::optional<WebCore::FrameIdentifier> originatingFrameID;

    std::optional<WebCore::FrameIdentifier> parentFrameID;

    if (requestingFrame) {

@@void WebFrameLoaderClient::dispatchDecidePolicyForNavigationAction(const Navigat

    FrameInfoData originatingFrameInfoData {

        navigationAction.initiatedByMainFrame() == InitiatedByMainFrame::Yes,

972 ResourceRequest { requester.url() },

973 requester.securityOrigin~~().~~data(),

969 ResourceRequest { requester.url },

970 requester.securityOrigin->data(),

        WTFMove(originatingFrameID),

        WTFMove(parentFrameID),

    };

    std::optional<WebPageProxyIdentifier> originatingPageID;

979 if (~~auto& p~~ag~~eID~~ = requester.globalFrameIdentifier~~().~~pageID) {

980 if (auto* webPage = WebProcess::singleton().webPage(pageID))

976 if (requester.globalFrameIdentifier && requester.globalFrameIdentifier->pageID) {

977 if (auto* webPage = WebProcess::singleton().webPage(requester.globalFrameIdentifier->pageID))

            originatingPageID = webPage->webPageProxyIdentifier();

    }

@@void WebFrameLoaderClient::dispatchDecidePolicyForNavigationAction(const Navigat

    navigationActionData.treatAsSameOriginNavigation = navigationAction.treatAsSameOriginNavigation();

    navigationActionData.hasOpenedFrames = navigationAction.hasOpenedFrames();

    navigationActionData.openedByDOMWithOpener = navigationAction.openedByDOMWithOpener();

998 if (auto& requester = navigationAction.requester())

999 navigationActionData.requesterOrigin = requester->securityOrigin().data();

995 navigationActionData.requesterOrigin = requester.securityOrigin->data();

    navigationActionData.targetBackForwardItemIdentifier = navigationAction.targetBackForwardItemIdentifier();

    navigationActionData.sourceBackForwardItemIdentifier = navigationAction.sourceBackForwardItemIdentifier();

    navigationActionData.lockHistory = navigationAction.lockHistory();

Source/WebKit/WebProcess/WebCoreSupport/WebFrameLoaderClient.h

@@private:

    WebCore::Frame* dispatchCreatePage(const WebCore::NavigationAction&, WebCore::NewFrameOpenerPolicy) final;

    void dispatchShow() final;

132 void dispatchDecidePolicyForResponse(const WebCore::ResourceResponse&, const WebCore::ResourceRequest&, WebCore::PolicyCheckIdentifier, const String&, WebCore::~~BrowsingContextGroupSwitchDecision, WebCore::~~FramePolicyFunction&&) final;

132 void dispatchDecidePolicyForResponse(const WebCore::ResourceResponse&, const WebCore::ResourceRequest&, WebCore::PolicyCheckIdentifier, const String&, WebCore::FramePolicyFunction&&) final;

    void dispatchDecidePolicyForNewWindowAction(const WebCore::NavigationAction&, const WebCore::ResourceRequest&, WebCore::FormState*, const String& frameName, WebCore::PolicyCheckIdentifier, WebCore::FramePolicyFunction&&) final;

    void dispatchDecidePolicyForNavigationAction(const WebCore::NavigationAction&, const WebCore::ResourceRequest&, const WebCore::ResourceResponse& redirectResponse, WebCore::FormState*, WebCore::PolicyDecisionMode, WebCore::PolicyCheckIdentifier, WebCore::FramePolicyFunction&&) final;

    void cancelPolicyCheck() final;

Source/WebKit/WebProcess/WebPage/WebPage.cpp

#include <WebCore/ContactsRequestData.h>

#include <WebCore/ContextMenuController.h>

#include <WebCore/CrossOriginEmbedderPolicy.h>

165#include <WebCore/CrossOriginOpenerPolicy.h>

#include <WebCore/DOMPasteAccess.h>

#include <WebCore/DataTransfer.h>

#include <WebCore/DatabaseManager.h>

@@void WebPage::sendCOEPCORPViolation(FrameIdentifier frameID, const SecurityOrigi

        WebCore::sendCOEPCORPViolation(*frame->coreFrame(), embedderOrigin, endpoint, disposition, destination, blockedURL);

}

void WebPage::sendViolationReportWhenNavigatingToCOOPResponse(FrameIdentifier frameID, const CrossOriginOpenerPolicy& coop, COOPDisposition disposition, const URL& coopURL, const URL& previousResponseURL, const SecurityOriginData& coopOrigin, const SecurityOriginData& previousResponseOrigin, const String& referrer, const String& userAgent, const String& reportToHeaderValue)

{

    if (!reportToHeaderValue.isEmpty())

        WebProcess::singleton().reportingEndpointsCache().addEndPointsFromReportToHeader(coopURL, reportToHeaderValue);

    // FIXME: Add the concept of browsing context group like in the specification instead of treating the whole process as a group.

    if (Page::nonUtilityPageCount() <= 1)

        return;

    if (auto* frame = WebProcess::singleton().webFrame(frameID); frame->coreFrame())

        WebCore::sendViolationReportWhenNavigatingToCOOPResponse(*frame->coreFrame(), coop, disposition, coopURL, previousResponseURL, coopOrigin.securityOrigin(), previousResponseOrigin.securityOrigin(), referrer, userAgent);

}

void WebPage::sendViolationReportWhenNavigatingAwayFromCOOPResponse(FrameIdentifier frameID, const CrossOriginOpenerPolicy& coop, COOPDisposition disposition, const URL& coopURL, const URL& nextResponseURL, const SecurityOriginData& coopOrigin, const SecurityOriginData& nextResponseOrigin, bool isCOOPResponseNavigationSource, const String& userAgent)

{

    // FIXME: Add the concept of browsing context group like in the specification instead of treating the whole process as a group.

    if (Page::nonUtilityPageCount() <= 1)

        return;

    if (auto* frame = WebProcess::singleton().webFrame(frameID); frame->coreFrame())

        WebCore::sendViolationReportWhenNavigatingAwayFromCOOPResponse(*frame->coreFrame(), coop, disposition, coopURL, nextResponseURL, coopOrigin.securityOrigin(), nextResponseOrigin.securityOrigin(), isCOOPResponseNavigationSource, userAgent);

}

void WebPage::enqueueSecurityPolicyViolationEvent(FrameIdentifier frameID, SecurityPolicyViolationEvent::Init&& eventInit)

{

    auto* frame = WebProcess::singleton().webFrame(frameID);

Source/WebKit/WebProcess/WebPage/WebPage.h

@@public:

    void sendCSPViolationReport(WebCore::FrameIdentifier, const URL& reportURL, IPC::FormDataReference&&);

    void sendCOEPPolicyInheritenceViolation(WebCore::FrameIdentifier, const WebCore::SecurityOriginData& embedderOrigin, const String& endpoint, WebCore::COEPDisposition, const String& type, const URL& blockedURL);

    void sendCOEPCORPViolation(WebCore::FrameIdentifier, const WebCore::SecurityOriginData& embedderOrigin, const String& endpoint, WebCore::COEPDisposition, WebCore::FetchOptions::Destination, const URL& blockedURL);

444 void sendViolationReportWhenNavigatingToCOOPResponse(WebCore::FrameIdentifier, const WebCore::CrossOriginOpenerPolicy&, WebCore::COOPDisposition, const URL& coopURL, const URL& previousResponseURL, const WebCore::SecurityOriginData& coopOrigin, const WebCore::SecurityOriginData& previousResponseOrigin, const String& referrer, const String& userAgent, const String& reportToHeaderValue);

445 void sendViolationReportWhenNavigatingAwayFromCOOPResponse(WebCore::FrameIdentifier, const WebCore::CrossOriginOpenerPolicy&, WebCore::COOPDisposition, const URL& coopURL, const URL& nextResponseURL, const WebCore::SecurityOriginData& coopOrigin, const WebCore::SecurityOriginData& nextResponseOrigin, bool isCOOPResponseNavigationSource, const String& userAgent);

    void enqueueSecurityPolicyViolationEvent(WebCore::FrameIdentifier, WebCore::SecurityPolicyViolationEvent::Init&&);

    // -- Called by the DrawingArea.

Source/WebKit/WebProcess/WebPage/WebPage.messages.in

@@messages -> WebPage LegacyReceiver {

    SendCSPViolationReport(WebCore::FrameIdentifier frameID, URL reportURL, IPC::FormDataReference reportData)

    SendCOEPPolicyInheritenceViolation(WebCore::FrameIdentifier frameID, struct WebCore::SecurityOriginData embedderOrigin, String endpoint, enum:bool WebCore::COEPDisposition disposition, String type, URL blockedURL)

    SendCOEPCORPViolation(WebCore::FrameIdentifier frameID, struct WebCore::SecurityOriginData embedderOrigin, String endpoint, enum:bool WebCore::COEPDisposition disposition, enum:uint8_t WebCore::FetchOptions::Destination destination, URL blockedURL)

34 SendViolationReportWhenNavigatingToCOOPResponse(WebCore::FrameIdentifier frameID, struct WebCore::CrossOriginOpenerPolicy coop, enum:bool WebCore::COOPDisposition disposition, URL coopURL, URL previousResponseURL, struct WebCore::SecurityOriginData coopOrigin, struct WebCore::SecurityOriginData previousResponseOrigin, String referrer, String userAgent, String reportToHeaderValue)

35 SendViolationReportWhenNavigatingAwayFromCOOPResponse(WebCore::FrameIdentifier frameID, struct WebCore::CrossOriginOpenerPolicy coop, enum:bool WebCore::COOPDisposition disposition, URL coopURL, URL nextResponseURL, struct WebCore::SecurityOriginData coopOrigin, struct WebCore::SecurityOriginData nextResponseOrigin, bool isCOOPResponseNavigationSource, String userAgent)

    EnqueueSecurityPolicyViolationEvent(WebCore::FrameIdentifier frameID, WebCore::SecurityPolicyViolationEvent::Init eventInit)

    TestProcessIncomingSyncMessagesWhenWaitingForSyncReply() -> (bool handled) Synchronous

Source/WebKitLegacy/mac/WebCoreSupport/WebFrameLoaderClient.h

@@private:

    WebCore::Frame* dispatchCreatePage(const WebCore::NavigationAction&, WebCore::NewFrameOpenerPolicy) final;

    void dispatchShow() final;

130 void dispatchDecidePolicyForResponse(const WebCore::ResourceResponse&, const WebCore::ResourceRequest&, WebCore::PolicyCheckIdentifier, const String&, WebCore::~~BrowsingContextGroupSwitchDecision, WebCore::~~FramePolicyFunction&&) final;

130 void dispatchDecidePolicyForResponse(const WebCore::ResourceResponse&, const WebCore::ResourceRequest&, WebCore::PolicyCheckIdentifier, const String&, WebCore::FramePolicyFunction&&) final;

    void dispatchDecidePolicyForNewWindowAction(const WebCore::NavigationAction&, const WebCore::ResourceRequest&, WebCore::FormState*, const WTF::String& frameName, WebCore::PolicyCheckIdentifier, WebCore::FramePolicyFunction&&) final;

    void dispatchDecidePolicyForNavigationAction(const WebCore::NavigationAction&, const WebCore::ResourceRequest&, const WebCore::ResourceResponse& redirectResponse, WebCore::FormState*, WebCore::PolicyDecisionMode, WebCore::PolicyCheckIdentifier, WebCore::FramePolicyFunction&&) final;

    void cancelPolicyCheck() final;

Source/WebKitLegacy/mac/WebCoreSupport/WebFrameLoaderClient.mm

@@void WebFrameLoaderClient::dispatchShow()

    [[webView _UIDelegateForwarder] webViewShow:webView];

}

858 void WebFrameLoaderClient::dispatchDecidePolicyForResponse(const WebCore::ResourceResponse& response, const WebCore::ResourceRequest& request, WebCore::PolicyCheckIdentifier identifier, const String&, WebCore::~~BrowsingContextGroupSwitchDecision, WebCore::~~FramePolicyFunction&& function)

858void WebFrameLoaderClient::dispatchDecidePolicyForResponse(const WebCore::ResourceResponse& response, const WebCore::ResourceRequest& request, WebCore::PolicyCheckIdentifier identifier, const String&, WebCore::FramePolicyFunction&& function)

{

    WebView *webView = getWebView(m_webFrame.get());

Source/WebKitLegacy/win/WebCoreSupport/WebFrameLoaderClient.cpp

@@void WebFrameLoaderClient::dispatchShow()

        ui->webViewShow(webView);

}

522 void WebFrameLoaderClient::dispatchDecidePolicyForResponse(const ResourceResponse& response, const ResourceRequest& request, WebCore::PolicyCheckIdentifier identifier, const String&, ~~BrowsingContextGroupSwitchDecision,~~ FramePolicyFunction&& function)

522void WebFrameLoaderClient::dispatchDecidePolicyForResponse(const ResourceResponse& response, const ResourceRequest& request, WebCore::PolicyCheckIdentifier identifier, const String&, FramePolicyFunction&& function)

{

    WebView* webView = m_webFrame->webView();

    Frame* coreFrame = core(m_webFrame);

Source/WebKitLegacy/win/WebCoreSupport/WebFrameLoaderClient.h

@@public:

    void dispatchDidFinishLoad() override;

    void dispatchDidReachLayoutMilestone(OptionSet<WebCore::LayoutMilestone>) override;

94 void dispatchDecidePolicyForResponse(const WebCore::ResourceResponse&, const WebCore::ResourceRequest&, WebCore::PolicyCheckIdentifier, const String&, WebCore::~~BrowsingContextGroupSwitchDecision, WebCore::~~FramePolicyFunction&&) override;

94 void dispatchDecidePolicyForResponse(const WebCore::ResourceResponse&, const WebCore::ResourceRequest&, WebCore::PolicyCheckIdentifier, const String&, WebCore::FramePolicyFunction&&) override;

    void dispatchDecidePolicyForNewWindowAction(const WebCore::NavigationAction&, const WebCore::ResourceRequest&, WebCore::FormState*, const WTF::String& frameName, WebCore::PolicyCheckIdentifier, WebCore::FramePolicyFunction&&) override;

    void dispatchDecidePolicyForNavigationAction(const WebCore::NavigationAction&, const WebCore::ResourceRequest&, const WebCore::ResourceResponse& redirectResponse, WebCore::FormState*, WebCore::PolicyDecisionMode, WebCore::PolicyCheckIdentifier, WebCore::FramePolicyFunction&&) override;

    void cancelPolicyCheck() override;

Tools/ChangeLog

2021-09-27  Chris Dumez  <cdumez@apple.com>

        Move Cross-Origin-Opener-Policy handling to the NetworkProcess

        https://bugs.webkit.org/show_bug.cgi?id=230812

        <rdar://83504842>

        Reviewed by NOBODY (OOPS!).

        Port COOP API tests from PSONSchemeHandler to HTTPServer. This was necessary since custom scheme handler

        loads do not go via the networkProcess (Where COOP handling is now implemented).

        * TestWebKitAPI/Tests/WebKitCocoa/ProcessSwapOnNavigation.mm:

        (-[PSONNavigationDelegate webView:didReceiveAuthenticationChallenge:completionHandler:]):

        (-[PSONScheme webView:startURLSchemeTask:]):

        * TestWebKitAPI/cocoa/HTTPServer.h:

2021-09-24  Sam Sneddon  <gsnedders@apple.com>

        LayoutTestFinder should return tests in order

Tools/TestWebKitAPI/Tests/WebKitCocoa/ProcessSwapOnNavigation.mm

#import "config.h"

28#import "HTTPServer.h"

#import "PlatformUtilities.h"

#import "Test.h"

#import "TestNavigationDelegate.h"

@@- (void)_webView:(WKWebView *)webView navigation:(WKNavigation *)navigation didS

    done = true;

}

- (void)webView:(WKWebView *)webView didReceiveAuthenticationChallenge:(NSURLAuthenticationChallenge *)challenge completionHandler:(void (^)(NSURLSessionAuthChallengeDisposition disposition, NSURLCredential * _Nullable credential))completionHandler

{

    EXPECT_WK_STREQ(challenge.protectionSpace.authenticationMethod, NSURLAuthenticationMethodServerTrust);

    completionHandler(NSURLSessionAuthChallengeUseCredential, [NSURLCredential credentialForTrust:challenge.protectionSpace.serverTrust]);

}

- (void)webView:(WKWebView *)webView didStartProvisionalNavigation:(null_unspecified WKNavigation *)navigation

{

    didStartProvisionalLoad = true;

@@@interface PSONScheme : NSObject <WKURLSchemeHandler> {

    const char* _bytes;

    HashMap<String, String> _redirects;

    HashMap<String, RetainPtr<NSData>> _dataMappings;

253 HashMap<String, String> _coopValues;

254 HashMap<String, String> _coepValues;

    HashSet<id <WKURLSchemeTask>> _runningTasks;

    bool _shouldRespondAsynchronously;

}

- (instancetype)initWithBytes:(const char*)bytes;

- (void)addRedirectFromURLString:(NSString *)sourceURLString toURLString:(NSString *)destinationURLString;

- (void)addMappingFromURLString:(NSString *)urlString toData:(const char*)data;

261 - (void)addMappingFromURLString:(NSString *)urlString toData:(const char*)data withCOOPValue:(const char*)coopValue withCOEPValue:(const char*)coepValue;

@end

@implementation PSONScheme

@@- (void)addMappingFromURLString:(NSString *)urlString toData:(const char*)data

    _dataMappings.set(urlString, [NSData dataWithBytesNoCopy:(void*)data length:strlen(data) freeWhenDone:NO]);

}

- (void)addMappingFromURLString:(NSString *)urlString toData:(const char*)data withCOOPValue:(const char*)coopValue withCOEPValue:(const char*)coepValue

{

    [self addMappingFromURLString:urlString toData:data];

    if (coopValue)

        _coopValues.add(urlString, coopValue);

    if (coepValue)

        _coepValues.add(urlString, coepValue);

}

- (void)setShouldRespondAsynchronously:(BOOL)value

{

    _shouldRespondAsynchronously = value;

@@- (void)webView:(WKWebView *)webView startURLSchemeTask:(id <WKURLSchemeTask>)ta

        [(id<WKURLSchemeTaskPrivate>)task _didPerformRedirection:redirectResponse.get() newRequest:request.get()];

    }

326 doAsynchronouslyIfNecessary([~~self,~~ finalURL = retainPtr(finalURL)](id <WKURLSchemeTask> task) {

321 doAsynchronouslyIfNecessary([finalURL = retainPtr(finalURL)](id <WKURLSchemeTask> task) {

        NSMutableDictionary* headerDictionary = [NSMutableDictionary dictionary];

        [headerDictionary setObject:@"text/html" forKey:@"Content-Type"];

        [headerDictionary setObject:@"1" forKey:@"Content-Length"];

        auto coopValue = _coopValues.get([finalURL absoluteString]);

        if (!coopValue.isEmpty())

            [headerDictionary setObject:(NSString *)coopValue forKey:@"Cross-Origin-Opener-Policy"];

        auto coepValue = _coepValues.get([finalURL absoluteString]);

        if (!coepValue.isEmpty())

            [headerDictionary setObject:(NSString *)coepValue forKey:@"Cross-Origin-Embedder-Policy"];

        auto response = adoptNS([[NSHTTPURLResponse alloc] initWithURL:finalURL.get() statusCode:200 HTTPVersion:@"HTTP/1.1" headerFields:headerDictionary]);

        [task didReceiveResponse:response.get()];

@@TEST(WebProcessCache, ClearWhenEnteringCache)

static const char* windowOpenCrossOriginCOOPTestBytes = R"PSONRESOURCE(

<script>

window.onload = function() {

7185 w = window.open("~~pson~~://~~www.apple.c~~om/popup.html", "foo");

7174 w = window.open("https://localhost:8181/popup.html", "foo");

}

</script>

)PSONRESOURCE";

@@enum class IsSameOrigin : bool { No, Yes };

enum class DoServerSideRedirect : bool { No, Yes };

static void runCOOPProcessSwapTest(const char* sourceCOOP, const char* sourceCOEP, const char* destinationCOOP, const char* destinationCOEP, IsSameOrigin isSameOrigin, DoServerSideRedirect doServerSideRedirect, ExpectSwap expectSwap)

{

    using namespace TestWebKitAPI;

    HashMap<String, String> sourceHeaders;

    sourceHeaders.add("Content-Type"_s, "text/html"_s);

    if (sourceCOOP)

        sourceHeaders.add("Cross-Origin-Opener-Policy"_s, String(sourceCOOP));

    if (sourceCOEP)

        sourceHeaders.add("Cross-Origin-Embedder-Policy"_s, String(sourceCOEP));

    HTTPResponse sourceResponse(WTFMove(sourceHeaders), isSameOrigin == IsSameOrigin::Yes ? windowOpenSameOriginCOOPTestBytes : windowOpenCrossOriginCOOPTestBytes);

    HashMap<String, String> destinationHeaders;

    destinationHeaders.add("Content-Type"_s, "text/html"_s);

    if (destinationCOOP)

        destinationHeaders.add("Cross-Origin-Opener-Policy"_s, String(destinationCOOP));

    if (destinationCOEP)

        destinationHeaders.add("Cross-Origin-Embedder-Policy"_s, String(destinationCOEP));

    HTTPResponse destinationResponse(WTFMove(destinationHeaders), "popup"_s);

    std::unique_ptr<HTTPServer> server;

    if (doServerSideRedirect == DoServerSideRedirect::Yes) {

        HashMap<String, String> redirectHeaders;

        redirectHeaders.add("location"_s, isSameOrigin == IsSameOrigin::Yes ? "https://127.0.0.1:8181/popup-after-redirection.html"_s : "https://localhost:8181/popup-after-redirection.html"_s);

        HTTPResponse redirectResponse(301, WTFMove(redirectHeaders));

        server = makeUnique<HTTPServer>(std::initializer_list<std::pair<String, HTTPResponse>> {

            { "/main.html", WTFMove(sourceResponse) },

            { "/popup.html", WTFMove(redirectResponse) },

            { "/popup-after-redirection.html", WTFMove(destinationResponse) }

        }, HTTPServer::Protocol::Https, nullptr, nullptr, 8181);

    } else {

        server = makeUnique<HTTPServer>(std::initializer_list<std::pair<String, HTTPResponse>> {

            { "/main.html", WTFMove(sourceResponse) },

            { "/popup.html", WTFMove(destinationResponse) }

        }, HTTPServer::Protocol::Https, nullptr, nullptr, 8181);

    }

    auto processPoolConfiguration = psonProcessPoolConfiguration();

    auto processPool = adoptNS([[WKProcessPool alloc] _initWithConfiguration:processPoolConfiguration.get()]);

    bool sourceShouldBeCrossOriginIsolated = sourceCOOP && !strcmp(sourceCOOP, "same-origin") && sourceCOEP && !strcmp(sourceCOEP, "require-corp");

@@static void runCOOPProcessSwapTest(const char* sourceCOOP, const char* sourceCOE

            [[webViewConfiguration preferences] _setEnabled:YES forExperimentalFeature:feature];

    }

    auto handler = adoptNS([[PSONScheme alloc] init]);

    if (isSameOrigin == IsSameOrigin::Yes) {

        [handler addMappingFromURLString:@"pson://www.webkit.org/main.html" toData:windowOpenSameOriginCOOPTestBytes withCOOPValue:sourceCOOP withCOEPValue:sourceCOEP];

        if (doServerSideRedirect == DoServerSideRedirect::Yes) {

            [handler addRedirectFromURLString:@"pson://www.webkit.org/popup.html" toURLString:@"pson://www.webkit.org/popup-after-redirect.html"];

            [handler addMappingFromURLString:@"pson://www.webkit.org/popup-after-redirect.html" toData:"popup" withCOOPValue:destinationCOOP withCOEPValue:destinationCOEP];

        } else

            [handler addMappingFromURLString:@"pson://www.webkit.org/popup.html" toData:"popup" withCOOPValue:destinationCOOP withCOEPValue:destinationCOEP];

    } else {

        [handler addMappingFromURLString:@"pson://www.webkit.org/main.html" toData:windowOpenCrossOriginCOOPTestBytes withCOOPValue:sourceCOOP withCOEPValue:sourceCOEP];

        if (doServerSideRedirect == DoServerSideRedirect::Yes) {

            [handler addRedirectFromURLString:@"pson://www.apple.com/popup.html" toURLString:@"pson://www.apple.com/popup-after-redirect.html"];

            [handler addMappingFromURLString:@"pson://www.apple.com/popup-after-redirect.html" toData:"popup" withCOOPValue:destinationCOOP withCOEPValue:destinationCOEP];

        } else

            [handler addMappingFromURLString:@"pson://www.apple.com/popup.html" toData:"popup" withCOOPValue:destinationCOOP withCOEPValue:destinationCOEP];

    }

    [webViewConfiguration setURLSchemeHandler:handler.get() forURLScheme:@"PSON"];

    auto webView = adoptNS([[WKWebView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600) configuration:webViewConfiguration.get()]);

    auto navigationDelegate = adoptNS([[PSONNavigationDelegate alloc] init]);

@@static void runCOOPProcessSwapTest(const char* sourceCOOP, const char* sourceCOE

    failed = false;

    serverRedirected = false;

    numberOfDecidePolicyCalls = 0;

7251 NSURLRequest *request = [NSURLRequest requestWithURL:[NSURL URLWithString:@"~~pson~~://~~www.webkit.org~~/main.html"]];

7258 NSURLRequest *request = [NSURLRequest requestWithURL:[NSURL URLWithString:@"https://127.0.0.1:8181/main.html"]];

    [webView loadRequest:request];

    TestWebKitAPI::Util::run(&done);

Tools/TestWebKitAPI/cocoa/HTTPServer.h

@@class Connection;

struct HTTPResponse;

class HTTPServer {

41 WTF_MAKE_FAST_ALLOCATED;

public:

    struct RequestData;

    enum class Protocol : uint8_t { Http, Https, HttpsWithLegacyTLS, Http2 };

LayoutTests/imported/w3c/ChangeLog

2021-09-27  Chris Dumez  <cdumez@apple.com>

        Move Cross-Origin-Opener-Policy handling to the NetworkProcess

        https://bugs.webkit.org/show_bug.cgi?id=230812

        <rdar://83504842>

        Reviewed by NOBODY (OOPS!).

        Rebaseline a couple of WPT tests due to some extra logging.

        * web-platform-tests/html/cross-origin-opener-policy/coop-coep-sandbox.https-expected.txt:

        * web-platform-tests/html/cross-origin-opener-policy/coop-sandbox.https-expected.txt:

2021-09-24  Sergio Villar Senin  <svillar@igalia.com>

        [css-flexbox] Import latest changes from css-flexbox WPT repo

LayoutTests/imported/w3c/web-platform-tests/html/cross-origin-opener-policy/coop-coep-sandbox.https-expected.txt

1CONSOLE MESSAGE: Navigation was blocked by Cross-Origin-Opener-Policy

2CONSOLE MESSAGE: Navigation was blocked by Cross-Origin-Opener-Policy

PASS <iframe sandbox="allow-popups allow-scripts allow-same-origin"> Sandboxed Cross-Origin-Opener-Policy popup should result in a network error

PASS <iframe sandbox="allow-popups allow-scripts"> Sandboxed Cross-Origin-Opener-Policy popup should result in a network error

LayoutTests/imported/w3c/web-platform-tests/html/cross-origin-opener-policy/coop-sandbox.https-expected.txt

1CONSOLE MESSAGE: Navigation was blocked by Cross-Origin-Opener-Policy

2CONSOLE MESSAGE: Navigation was blocked by Cross-Origin-Opener-Policy

PASS <iframe sandbox="allow-popups allow-scripts allow-same-origin"> Sandboxed Cross-Origin-Opener-Policy popup should result in a network error

PASS <iframe sandbox="allow-popups allow-scripts"> Sandboxed Cross-Origin-Opener-Policy popup should result in a network error