{

for (auto& loader : copyToVector(loaders))

loader->cancel();

{

for (auto& loader : copyToVector(loaders))

loader->setDefersLoading(defers);

: FrameDestructionObserver(nullptr)

, m_cachedResourceLoader(CachedResourceLoader::create(this))

, m_originalRequest(originalRequest.isNull() ? request : originalRequest)

, m_substituteData(WTF::move(substituteData))

, m_originalRequestCopy(originalRequest.isNull() ? request : WTF::move(originalRequest))

, m_request(WTF::move(request))

, m_substituteResourceDeliveryTimer(*this, &DocumentLoader::substituteResourceDeliveryTimerFired)

, m_originalSubstituteDataWasValid(substituteData.isValid())

{

{

if (m_substituteData.isValid())

return protect(m_substituteData.content())->copy();

if (m_mainResource)

return m_mainResource->resourceBuffer();

return nullptr;

{

m_originalRequestCopy.setURL(URL { url });

m_request.setURL(URL { url });

{

// Replacing an unreachable URL with alternate content looks like a server-side

// redirect at this point, but we can replace a committed dataSource.

bool handlingUnreachableURL = false;

handlingUnreachableURL = m_substituteData.isValid() && !m_substituteData.failingURL().isEmpty();

bool shouldNotifyAboutProvisionalURLChange = false;

if (handlingUnreachableURL)

m_committed = false;

else if (isLoadingMainResource() && req.url() != m_request.url())

shouldNotifyAboutProvisionalURLChange = true;

// We should never be getting a redirect callback after the data

// source is committed, except in the unreachable URL case. It

// would be a WebFoundation bug if it sent a redirect callback after commit.

ASSERT(!m_committed);

m_request = WTF::move(req);

if (shouldNotifyAboutProvisionalURLChange)

protect(frameLoader()->client())->dispatchDidChangeProvisionalURL();

{

if (!error.isNull())

DOCUMENTLOADER_RELEASE_LOG("setMainDocumentError: (type=%d, code=%d)", static_cast<int>(error.type()), error.errorCode());

m_mainDocumentError = error;

protect(frameLoader()->client())->setMainDocumentError(this, error);

{

ASSERT(!error.isNull());

if (auto createdCallback = std::exchange(m_whenDocumentIsCreatedCallback, { }))

createdCallback(nullptr);

if (!frameLoader())

return;

if (!error.isNull())

DOCUMENTLOADER_RELEASE_LOG("mainReceivedError: (type=%d, code=%d)", static_cast<int>(error.type()), error.errorCode());

if (m_identifierForLoadWithoutResourceLoader) {

ASSERT(!mainResourceLoader());

protect(frameLoader()->client())->dispatchDidFailLoading(this, *m_identifierForLoadWithoutResourceLoader, error);

}

// There is a bug in CFNetwork where callbacks can be dispatched even when loads are deferred.

// See <rdar://problem/6304600> for more details.

#if !USE(CF)

ASSERT(!mainResourceLoader() || !mainResourceLoader()->defersLoading());

#endif

setMainDocumentError(error);

clearMainResourceLoader();

protect(frameLoader())->receivedMainResourceError(error, loadWillContinueInAnotherProcess);

{

DOCUMENTLOADER_RELEASE_LOG("DocumentLoader::frameDestroyed: m_frame=%p", m_frame.get());

FrameDestructionObserver::frameDestroyed();

{

DOCUMENTLOADER_RELEASE_LOG_FORWARDABLE(DocumentLoaderStopLoading);

RefPtr frame = m_frame.get();

ASSERT(frame);

if (!frame)

return;

Ref<DocumentLoader> protectedThis(*this);

// In some rare cases, calling FrameLoader::stopLoading could cause isLoading() to return false.

// (This can happen when there's a single XMLHttpRequest currently loading and stopLoading causes it

// to stop loading. Because of this, we need to save it so we don't return early.

bool loading = isLoading();

if (m_committed) {

// Attempt to stop the frame if the document loader is loading, or if it is done loading but

// still parsing. Failure to do so can cause a world leak.

RefPtr document = frame->document();

if (loading || document->parsing())

frame->loader().stopLoading(UnloadEventPolicy::None);

}

for (auto& callback : m_iconLoaders.values())

callback(nullptr);

m_iconLoaders.clear();

m_iconsPendingLoadDecision.clear();

#if ENABLE(APPLICATION_MANIFEST)

m_applicationManifestLoader = nullptr;

m_finishedLoadingApplicationManifest = false;

notifyFinishedLoadingApplicationManifest();

#endif

// Always cancel multipart loaders

cancelAll(m_multipartSubresourceLoaders);

if (RefPtr document = this->document())

document->suspendFontLoading();

#if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)

clearArchiveResources();

#endif

if (!loading) {

// If something above restarted loading we might run into mysterious crashes like

// https://bugs.webkit.org/show_bug.cgi?id=62764 and <rdar://problem/9328684>

ASSERT(!isLoading());

return;

}

// We might run in to infinite recursion if we're stopping loading as the result of

// detaching from the frame, so break out of that recursion here.

// See <rdar://problem/9673866> for more details.

if (m_isStopping)

return;

m_isStopping = true;

// The frame may have been detached from this document by the onunload handler

if (RefPtr frameLoader = this->frameLoader()) {

DOCUMENTLOADER_RELEASE_LOG("stopLoading: canceling load");

if (isLoadingMainResource()) {

// Stop the main resource loader and let it send the cancelled message.

cancelMainResourceLoad(frameLoader->cancelledError(m_request));

} else if (!m_subresourceLoaders.isEmpty() || !m_plugInStreamLoaders.isEmpty()) {

// The main resource loader already finished loading. Set the cancelled error on the

// document and let the subresourceLoaders and pluginLoaders send individual cancelled messages below.

setMainDocumentError(frameLoader->cancelledError(m_request));

} else {

// If there are no resource loaders, we need to manufacture a cancelled message.

// (A back/forward navigation has no resource loaders because its resources are cached.)

mainReceivedError(frameLoader->cancelledError(m_request));

}

}

// We always need to explicitly cancel the Document's parser when stopping the load.

// Otherwise cancelling the parser while starting the next page load might result

// in unexpected side effects such as erroneous event dispatch. ( http://webkit.org/b/117112 )

if (RefPtr document = this->document())

document->cancelParsing();

stopLoadingSubresources();

stopLoadingPlugIns();

m_isStopping = false;

{

if (!m_committed) {

m_committed = true;

RefPtr protectedFrame { m_frame.get() };

protect(frameLoader())->commitProvisionalLoad();

}

{

// if (document() && document()->hasActiveParser())

// return true;

// FIXME: The above code should be enabled, but it seems to cause

// http/tests/security/feed-urls-from-remote.html to timeout on Mac WK1

// see http://webkit.org/b/110554 and http://webkit.org/b/110401

return isLoadingMainResource() || !m_subresourceLoaders.isEmpty() || !m_plugInStreamLoaders.isEmpty();

{

ASSERT(isMainThread());

#if ENABLE(CONTENT_FILTERING)

if (RefPtr contentFilter = m_contentFilter; contentFilter && !contentFilter->continueAfterNotifyFinished(resource))

return;

#endif

Box<NetworkLoadMetrics> metrics;

if (RefPtr frameLoader = this->frameLoader()) {

if (auto prefetchedMetrics = frameLoader->documentPrefetcher().takePrefetchedResourceMetrics(url())) {

metrics = WTF::move(prefetchedMetrics);

metrics->fromPrefetch = true;

}

}

if (!metrics)

metrics = Box<NetworkLoadMetrics>::create(fetchMetrics);

if (RefPtr document = this->document()) {

if (RefPtr window = document->window())

protect(window->performance())->documentLoadFinished(*metrics);

}

ASSERT_UNUSED(resource, m_mainResource == &resource);

ASSERT(m_mainResource);

if (!m_mainResource->errorOccurred() && !m_mainResource->wasCanceled()) {

finishedLoading();

return;

}

if (m_request.cachePolicy() == ResourceRequestCachePolicy::ReturnCacheDataDontLoad && !m_mainResource->wasCanceled()) {

protect(frameLoader())->retryAfterFailedCacheOnlyMainResourceLoad();

return;

}

if (!m_mainResource->resourceError().isNull())

DOCUMENTLOADER_RELEASE_LOG("notifyFinished: canceling load (type=%d, code=%d)", static_cast<int>(m_mainResource->resourceError().type()), m_mainResource->resourceError().errorCode());

mainReceivedError(m_mainResource->resourceError(), loadWillContinueInAnotherProcess);

{

// There is a bug in CFNetwork where callbacks can be dispatched even when loads are deferred.

// See <rdar://problem/6304600> for more details.

#if !USE(CF)

ASSERT(!m_frame->page()->defersLoading() || protect(frameLoader())->stateMachine().creatingInitialEmptyDocument() || InspectorInstrumentation::isDebuggerPaused(m_frame.get()));

#endif

Ref<DocumentLoader> protectedThis(*this);

if (m_identifierForLoadWithoutResourceLoader) {

// A didFinishLoading delegate might try to cancel the load (despite it

// being finished). Clear m_identifierForLoadWithoutResourceLoader

// before calling dispatchDidFinishLoading so that we don't later try to

// cancel the already-finished substitute load.

NetworkLoadMetrics emptyMetrics;

ResourceLoaderIdentifier identifier = *std::exchange(m_identifierForLoadWithoutResourceLoader, std::nullopt);

frameLoader()->notifier().dispatchDidFinishLoading(this, identifier, emptyMetrics, nullptr);

}

maybeFinishLoadingMultipartContent();

timing().markEndTime();

commitIfReady();

RefPtr frameLoader = this->frameLoader();

if (!frameLoader)

return;

if (!maybeCreateArchive()) {

// If this is an empty document, it will not have actually been created yet. Commit dummy data so that

// DocumentWriter::begin() gets called and creates the Document.

if (!m_gotFirstByte)

commitData(SharedBuffer::create());

frameLoader = this->frameLoader();

if (!frameLoader)

return;

Ref frameLoaderClient = frameLoader->client();

frameLoaderClient->finishedLoading(this);

frameLoaderClient->loadStorageAccessQuirksIfNeeded();

}

m_writer.end();

if (!m_mainDocumentError.isNull())

return;

clearMainResourceLoader();

frameLoader = this->frameLoader();

if (!frameLoader)

return;

if (!frameLoader->stateMachine().creatingInitialEmptyDocument())

frameLoader->checkLoadComplete();

{

if (newRequest.httpMethod() == "POST"_s)

return true;

int status = redirectResponse.httpStatusCode();

if (((status >= 301 && status <= 303) || status == 307)

&& m_originalRequest.httpMethod() == "POST"_s)

return true;

return false;

{

Ref protectedThis { *this };

if (m_substituteData.response().isRedirection()) {

auto newRequest = m_request.redirectedRequest(m_substituteData.response(), true);

auto substituteData = std::exchange(m_substituteData, { });

auto callback = [protectedThis, newRequest] (auto&& request) mutable {

if (request.isNull())

return;

protectedThis->loadMainResource(WTF::move(newRequest));

};

redirectReceived(WTF::move(newRequest), substituteData.response(), WTF::move(callback));

return;

}

ResourceResponse response = m_substituteData.response();

if (response.url().isEmpty())

response = ResourceResponse(URL { m_request.url() }, String { m_substituteData.mimeType() }, m_substituteData.content()->size(), String { m_substituteData.textEncoding() });

#if ENABLE(CONTENT_EXTENSIONS)

RefPtr frame = m_frame.get();

RefPtr page = frame ? frame->page() : nullptr;

RefPtr userContentProvider = frame ? frame->userContentProvider() : nullptr;

if (page && userContentProvider) {

// We intentionally do nothing with the results of this call.

// We want the CSS to be loaded for us, but we ignore any attempt to block or upgrade the connection since there is no connection.

userContentProvider->processContentRuleListsForLoad(*page, response.url(), frame->isMainFrame() ? ContentExtensions::ResourceType::TopDocument : ContentExtensions::ResourceType::ChildDocument, *this);

}

#endif

responseReceived(WTF::move(response), nullptr);

{

if (!m_loadingMainResource)

return false;

ASSERT(!m_gotFirstByte);

m_serviceWorkerRegistrationData = makeUnique<ServiceWorkerRegistrationData>(WTF::move(data));

return true;

{

bool shouldTryLoadingThroughServiceWorker = m_canUseServiceWorkers && !frameLoader()->isReloadingFromOrigin() && m_frame->page() && url.protocolIsInHTTPFamily();

if (!shouldTryLoadingThroughServiceWorker) {

callback(std::nullopt);

return;

}

RefPtr frame = m_frame.get();

auto origin = (!frame->isMainFrame() && frame->document()) ? protect(frame->document())->topOrigin().data() : SecurityOriginData::fromURL(url);

if (!protect(ServiceWorkerProvider::singleton().serviceWorkerConnection())->mayHaveServiceWorkerRegisteredForOrigin(origin)) {

callback(std::nullopt);

return;

}

Ref connection = ServiceWorkerProvider::singleton().serviceWorkerConnection();

connection->matchRegistration(WTF::move(origin), url, WTF::move(callback));

{

ASSERT_UNUSED(resource, &resource == m_mainResource);

redirectReceived(WTF::move(request), redirectResponse, WTF::move(completionHandler));

{

if (m_serviceWorkerRegistrationData) {

m_serviceWorkerRegistrationData = { };

unregisterReservedServiceWorkerClient();

}

willSendRequest(WTF::move(request), redirectResponse, [completionHandler = WTF::move(completionHandler), protectedThis = Ref { *this }, this] (ResourceRequest&& request) mutable {

ASSERT(!m_substituteData.isValid());

if (request.isNull() || !m_mainDocumentError.isNull() || !m_frame) {

completionHandler({ });

return;

}

completionHandler(WTF::move(request));

});

{

// Note that there are no asserts here as there are for the other callbacks. This is due to the

// fact that this "callback" is sent when starting every load, and the state of callback

// deferrals plays less of a part in this function in preventing the bad behavior deferring

// callbacks is meant to prevent.

ASSERT(!newRequest.isNull());

// Logging for <rdar://problem/54830233>.

if (!frameLoader() || !frameLoader()->provisionalDocumentLoader())

DOCUMENTLOADER_RELEASE_LOG("willSendRequest: With no provisional document loader");

bool didReceiveRedirectResponse = !redirectResponse.isNull();

if (!protect(frameLoader())->checkIfFormActionAllowedByCSP(newRequest.url(), didReceiveRedirectResponse, redirectResponse.url())) {

DOCUMENTLOADER_RELEASE_LOG("willSendRequest: canceling - form action not allowed by CSP");

cancelMainResourceLoad(protect(frameLoader())->cancelledError(newRequest));

return completionHandler(WTF::move(newRequest));

}

RefPtr frame = m_frame.get();

if (auto requester = m_triggeringAction.requester(); requester && requester->documentIdentifier) {

if (RefPtr requestingDocument = Document::allDocumentsMap().get(requester->documentIdentifier); requestingDocument && requestingDocument->frame()) {

if (frame && requestingDocument->isNavigationBlockedByThirdPartyIFrameRedirectBlocking(*frame, newRequest.url())) {

DOCUMENTLOADER_RELEASE_LOG("willSendRequest: canceling - cross-site redirect of top frame triggered by third-party iframe");

if (RefPtr document = frame->document()) {

auto message = makeString("Unsafe JavaScript attempt to initiate navigation for frame with URL '"_s

, document->url().string()

, "' from frame with URL '"_s

, requestingDocument->url().string()

, "'. The frame attempting navigation of the top-level window is cross-origin or untrusted and the user has never interacted with the frame."_s);

document->addConsoleMessage(MessageSource::Security, MessageLevel::Error, message);

}

cancelMainResourceLoad(protect(frameLoader())->cancelledError(newRequest));

return completionHandler(WTF::move(newRequest));

}

}

}

ASSERT(timing().startTime());

if (didReceiveRedirectResponse) {

if (newRequest.url().protocolIsAbout() || newRequest.url().protocolIsData()) {

DOCUMENTLOADER_RELEASE_LOG("willSendRequest: canceling - redirecting URL scheme is not allowed");

loadErrorDocument();

if (frame && frame->document())

protect(frame->document())->addConsoleMessage(MessageSource::Security, MessageLevel::Error, makeString("Not allowed to redirect to "_s, newRequest.url().stringCenterEllipsizedToLength(), " due to its scheme"_s));

if (RefPtr frameLoader = this->frameLoader())

cancelMainResourceLoad(frameLoader->blockedError(newRequest));

return completionHandler(WTF::move(newRequest));

}

// If the redirecting url is not allowed to display content from the target origin,

// then block the redirect.

Ref<SecurityOrigin> redirectingOrigin(SecurityOrigin::create(redirectResponse.url()));

if (!redirectingOrigin.get().canDisplay(newRequest.url(), OriginAccessPatternsForWebProcess::singleton())) {

DOCUMENTLOADER_RELEASE_LOG("willSendRequest: canceling - redirecting URL not allowed to display content from target");

FrameLoader::reportLocalLoadFailed(frame.get(), newRequest.url().string());

cancelMainResourceLoad(protect(frameLoader())->cancelledError(newRequest));

return completionHandler(WTF::move(newRequest));

}

if (!ResourceLoader::isPortAllowed(newRequest.url())) {

DOCUMENTLOADER_RELEASE_LOG("willSendRequest: canceling - redirecting to a URL with a blocked port");

if (frame)

FrameLoader::reportBlockedLoadFailed(*frame, newRequest.url());

cancelMainResourceLoad(protect(frameLoader())->blockedError(newRequest));

return completionHandler(WTF::move(newRequest));

}

if (isIPAddressDisallowed(newRequest.url())) {

DOCUMENTLOADER_RELEASE_LOG("willSendRequest: canceling - redirecting to a URL with a disallowed IP address");

if (frame)

FrameLoader::reportBlockedLoadFailed(*frame, newRequest.url());

cancelMainResourceLoad(protect(frameLoader())->blockedError(newRequest));

return completionHandler(WTF::move(newRequest));

}

}

ASSERT(frame);

RefPtr topFrame = frame->tree().top();

RefPtr document = frame->document();

ASSERT(document);

// Update cookie policy base URL as URL changes, except for subframes, which use the

// URL of the main frame which doesn't change when we redirect.

if (frame->isMainFrame())

newRequest.setFirstPartyForCookies(newRequest.url());

FrameLoader::addSameSiteInfoToRequestIfNeeded(newRequest, document.get());

if (!didReceiveRedirectResponse)

protect(frameLoader()->client())->dispatchWillChangeDocument(document->url(), newRequest.url());

// If we're fielding a redirect in response to a POST, force a load from origin, since

// this is a common site technique to return to a page viewing some data that the POST

// just modified.

// Also, POST requests always load from origin, but this does not affect subresources.

if (newRequest.cachePolicy() == ResourceRequestCachePolicy::UseProtocolCachePolicy && isPostOrRedirectAfterPost(newRequest, redirectResponse))

newRequest.setCachePolicy(ResourceRequestCachePolicy::ReloadIgnoringCacheData);

if (isRedirectToGetAfterPost(m_request, newRequest))

newRequest.clearHTTPOrigin();

if (topFrame && topFrame != frame.get()) {

// We shouldn't check for mixed content against the current frame when navigating; we only need to be concerned with the ancestor frames.

RefPtr parentFrame = frame->tree().parent();

if (!parentFrame)

parentFrame = frameLoader()->client().provisionalParentFrame();

if (!parentFrame)

return completionHandler(WTF::move(newRequest));

if (MixedContentChecker::shouldBlockRequest(*parentFrame, newRequest.url())) {

cancelMainResourceLoad(protect(frameLoader())->cancelledError(newRequest));

return completionHandler(WTF::move(newRequest));

}

}

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

auto url = newRequest.url();

url.removeHostAndPort();

newRequest.setURL(WTF::move(url));

}

#if ENABLE(CONTENT_FILTERING)

if (RefPtr contentFilter = m_contentFilter; contentFilter && !contentFilter->continueAfterWillSendRequest(newRequest, redirectResponse))

return completionHandler(WTF::move(newRequest));

#endif

setRequest(ResourceRequest { newRequest });

if (!didReceiveRedirectResponse)

return completionHandler(WTF::move(newRequest));

auto navigationPolicyCompletionHandler = [this, protectedThis = Ref { *this }, frame, completionHandler = WTF::move(completionHandler)] (ResourceRequest&& request, WeakPtr<FormSubmission>&&, NavigationPolicyDecision navigationPolicyDecision) mutable {

m_waitingForNavigationPolicy = false;

switch (navigationPolicyDecision) {

case NavigationPolicyDecision::IgnoreLoad:

case NavigationPolicyDecision::LoadWillContinueInAnotherProcess:

stopLoadingForPolicyChange(navigationPolicyDecision == NavigationPolicyDecision::LoadWillContinueInAnotherProcess ? LoadWillContinueInAnotherProcess::Yes : LoadWillContinueInAnotherProcess::No);

break;

case NavigationPolicyDecision::ContinueLoad:

break;

}

completionHandler(WTF::move(request));

};

ASSERT(!m_waitingForNavigationPolicy);

m_waitingForNavigationPolicy = true;

// FIXME: Add a load type check.

auto& policyChecker = frameLoader()->policyChecker();

RELEASE_ASSERT(!isBackForwardLoadType(policyChecker.loadType()) || frame->loader().history().provisionalItem());

policyChecker.checkNavigationPolicy(WTF::move(newRequest), redirectResponse, WTF::move(navigationPolicyCompletionHandler));

{

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

RefPtr frame = m_frame.get();

if (!frame->isMainFrame())

return std::nullopt;

RefPtr document = frame->document();

if (!document || !frame->document()->settings().crossOriginOpenerPolicyEnabled())

return std::nullopt;

URL openerURL;

if (RefPtr openerFrame = dynamicDowncast<LocalFrame>(frame->opener()))

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

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

auto newCoopEnforcementResult = WebCore::doCrossOriginOpenerHandlingOfResponse(*document, response, m_triggeringAction.requester(), protect(contentSecurityPolicy()).get(), frame->effectiveSandboxFlags(), m_request.httpReferrer(), frameLoader()->stateMachine().isDisplayingInitialEmptyDocument(), currentCoopEnforcementResult);

if (!newCoopEnforcementResult) {

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

return std::nullopt;

}

return newCoopEnforcementResult;

{

ASSERT(response.isRedirection());

m_substituteData = { SharedBuffer::create(), { }, WTF::move(response), SubstituteData::SessionHistoryVisibility::Visible };

{

if (!m_substituteData.isValid() || !m_frame->page())

return false;

DOCUMENTLOADER_RELEASE_LOG("startLoadingMainResource: Returning substitute data");

m_identifierForLoadWithoutResourceLoader = ResourceLoaderIdentifier::generate();

frameLoader()->notifier().assignIdentifierToInitialRequest(*m_identifierForLoadWithoutResourceLoader, this, m_request);

frameLoader()->notifier().dispatchWillSendRequest(this, *m_identifierForLoadWithoutResourceLoader, m_request, ResourceResponse(), nullptr);

if (!m_deferMainResourceDataLoad || frameLoader()->loadsSynchronously())

handleSubstituteDataLoadNow();

else {

auto loadData = [weakThis = WeakPtr { *this }] {

if (RefPtr protectedThis = weakThis.get())

protectedThis->handleSubstituteDataLoadNow();

};

#if USE(COCOA_EVENT_LOOP)

RunLoop::dispatch(*m_frame->page()->scheduledRunLoopPairs(), WTF::move(loadData));

#else

RunLoop::currentSingleton().dispatch(WTF::move(loadData));

#endif

}

return true;

{

Ref<DocumentLoader> protectedThis { *this };

InspectorInstrumentation::continueAfterXFrameOptionsDenied(*protect(frame()), identifier, *this, response);

loadErrorDocument();

// The load event might have detached this frame. In that case, the load will already have been cancelled during detach.

if (RefPtr frameLoader = this->frameLoader())

cancelMainResourceLoad(frameLoader->cancelledError(m_request));

{

ASSERT_UNUSED(resource, m_mainResource == &resource);

RefPtr frame = m_frame.get();

if (shouldClearContentSecurityPolicyForResponse(response))

m_contentSecurityPolicy = nullptr;

else {

// FIXME(294912): Clean up use of bare pointers for ReportingClient

ReportingClient* reportingClient = nullptr;

if (frame && frame->document())

reportingClient = frame->document();

if (!m_contentSecurityPolicy)

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

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

}

if (frame && frame->document() && frame->document()->settings().crossOriginOpenerPolicyEnabled())

m_responseCOOP = obtainCrossOriginOpenerPolicy(response);

// https://w3c.github.io/webappsec-subresource-integrity/#parse-integrity-policy-headers

m_integrityPolicy = processIntegrityPolicy(response, HTTPHeaderName::IntegrityPolicy);

m_integrityPolicyReportOnly = processIntegrityPolicy(response, HTTPHeaderName::IntegrityPolicyReportOnly);

if (frame && frame->settings().clearSiteDataHTTPHeaderEnabled()) {

m_responseClearSiteDataValues = parseClearSiteDataHeader(response);

// https://wicg.github.io/nav-speculation/prefetch.html#clear-prefetch-cache

if (m_responseClearSiteDataValues.containsAny({ ClearSiteDataValue::Cache, ClearSiteDataValue::PrefetchCache })) {

Ref origin = SecurityOrigin::create(response.url());

frame->loader().documentPrefetcher().clearPrefetchedResourcesForOrigin(origin);

}

}

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

if (frame && frame->document()) {

Ref document = *frame->document();

if (Quirks::isMicrosoftTeamsRedirectURL(response.url())) {

auto firstPartyDomain = RegistrableDomain(response.url());

if (auto loginDomains = NetworkStorageSession::subResourceDomainsInNeedOfStorageAccessForFirstParty(firstPartyDomain)) {

if (!Quirks::hasStorageAccessForAllLoginDomains(*loginDomains, firstPartyDomain)) {

protect(frame->navigationScheduler())->scheduleRedirect(document, 0, microsoftTeamsRedirectURL(), IsMetaRefresh::No);

completionHandler();

return;

}

}

}

}

if (m_canUseServiceWorkers && response.source() == ResourceResponse::Source::MemoryCache) {

matchRegistration(response.url(), [this, protectedThis = Ref { *this }, response = ResourceResponse { response }, completionHandler = WTF::move(completionHandler)](auto&& registrationData) mutable {

if (!m_mainDocumentError.isNull() || !m_frame) {

completionHandler();

return;

}

if (registrationData)

m_serviceWorkerRegistrationData = makeUnique<ServiceWorkerRegistrationData>(WTF::move(*registrationData));

responseReceived(WTF::move(response), WTF::move(completionHandler));

});

return;

}

responseReceived(ResourceResponse { response }, WTF::move(completionHandler));

{

ASSERT(response.certificateInfo());

CompletionHandlerCallingScope completionHandlerCaller(WTF::move(completionHandler));

#if ENABLE(CONTENT_FILTERING)

if (RefPtr contentFilter = m_contentFilter; contentFilter && !contentFilter->continueAfterResponseReceived(response))

return;

#endif

Ref<DocumentLoader> protectedThis(*this);

ASSERT(m_identifierForLoadWithoutResourceLoader || m_mainResource);

ResourceLoaderIdentifier identifier = m_identifierForLoadWithoutResourceLoader ? *m_identifierForLoadWithoutResourceLoader : *m_mainResource->resourceLoaderIdentifier();

if (m_substituteData.isValid() || !platformStrategies()->loaderStrategy()->havePerformedSecurityChecks(response)) {

auto url = response.url();

RefPtr frame = m_frame.get();

// FIXME(294912): Clean up use of bare pointers for ReportingClient

ReportingClient* reportingClient = nullptr;

if (frame && frame->document())

reportingClient = frame->document();

ContentSecurityPolicy contentSecurityPolicy(URL { url }, this, reportingClient);

contentSecurityPolicy.didReceiveHeaders(ContentSecurityPolicyResponseHeaders { response }, m_request.httpReferrer());

if (frame && !contentSecurityPolicy.allowFrameAncestors(*frame, url)) {

stopLoadingAfterXFrameOptionsOrContentSecurityPolicyDenied(identifier, response);

return;

}

if (frame && !contentSecurityPolicy.overridesXFrameOptions()) {

String frameOptions = response.httpHeaderFields().get(HTTPHeaderName::XFrameOptions);

if (!frameOptions.isNull()) {

if (protect(frameLoader())->shouldInterruptLoadForXFrameOptions(frameOptions, url, identifier)) {

auto message = makeString("Refused to display '"_s, url.stringCenterEllipsizedToLength(), "' in a frame because it set 'X-Frame-Options' to '"_s, frameOptions, "'."_s);

protect(frame->document())->addConsoleMessage(MessageSource::Security, MessageLevel::Error, message, identifier.toUInt64());

stopLoadingAfterXFrameOptionsOrContentSecurityPolicyDenied(identifier, response);

return;

}

}

}

}

// There is a bug in CFNetwork where callbacks can be dispatched even when loads are deferred.

// See <rdar://problem/6304600> for more details.

#if !USE(CF)

ASSERT(!mainResourceLoader() || !mainResourceLoader()->defersLoading());

#endif

if (m_isLoadingMultipartContent) {

setupForMultipartReplace();

m_mainResource->clear();

} else if (response.isMultipart())

m_isLoadingMultipartContent = true;

m_response = WTF::move(response);

if (m_identifierForLoadWithoutResourceLoader) {

RefPtr frameLoader = this->frameLoader();

if (m_mainResource && m_mainResource->wasRedirected()) {

ASSERT(m_mainResource->status() == CachedResource::Status::Cached);

if (frameLoader)

protect(frameLoader->client())->dispatchDidReceiveServerRedirectForProvisionalLoad();

}

addResponse(m_response);