/*

* Copyright (C) 2012-2026 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 "NetworkResourceLoader.h"

#include "ArgumentCoders.h"

#include "EarlyHintsResourceLoader.h"

#include "FormDataReference.h"

#include "LoadedWebArchive.h"

#include "Logging.h"

#include "MessageSenderInlines.h"

#include "NetworkCache.h"

#include "NetworkCacheSpeculativeLoadManager.h"

#include "NetworkConnectionToWebProcess.h"

#include "NetworkConnectionToWebProcessMessages.h"

#include "NetworkLoad.h"

#include "NetworkLoadChecker.h"

#include "NetworkOriginAccessPatterns.h"

#include "NetworkProcess.h"

#include "NetworkProcessConnectionMessages.h"

#include "NetworkProcessProxyMessages.h"

#include "NetworkSchemeRegistry.h"

#include "NetworkSession.h"

#include "NetworkStorageManager.h"

#include "PrivateRelayed.h"

#include "ResourceLoadInfo.h"

#include "ServiceWorkerFetchTask.h"

#include "SharedBufferReference.h"

#include "WebErrors.h"

#include "WebLoaderStrategy.h"

#include "WebPageMessages.h"

#include "WebResourceLoaderMessages.h"

#include "WebSWServerConnection.h"

#include "WebSharedWorkerServer.h"

#include "WebsiteDataStore.h"

#include "WebsiteDataStoreParameters.h"

#include <WebCore/BlobDataFileReference.h>

#include <WebCore/COEPInheritenceViolationReportBody.h>

#include <WebCore/CORPViolationReportBody.h>

#include <WebCore/CertificateInfo.h>

#include <WebCore/ClientOrigin.h>

#include <WebCore/ContentSecurityPolicy.h>

#include <WebCore/CrossOriginEmbedderPolicy.h>

#include <WebCore/DiagnosticLoggingKeys.h>

#include <WebCore/HTTPParsers.h>

#include <WebCore/HTTPStatusCodes.h>

#include <WebCore/LegacySchemeRegistry.h>

#include <WebCore/LinkHeader.h>

#include <WebCore/NetworkLoadMetrics.h>

#include <WebCore/NetworkStorageSession.h>

#include <WebCore/OriginAccessPatterns.h>

#include <WebCore/RegistrableDomain.h>

#include <WebCore/ReportingScope.h>

#include <WebCore/SameSiteInfo.h>

#include <WebCore/SecurityOrigin.h>

#include <WebCore/SecurityPolicy.h>

#include <WebCore/ShareableResource.h>

#include <WebCore/SharedBuffer.h>

#include <WebCore/ViolationReportType.h>

#include <wtf/CallbackAggregator.h>

#include <wtf/CheckedArithmetic.h>

#include <wtf/Expected.h>

#include <wtf/RunLoop.h>

#include <wtf/text/MakeString.h>

#if USE(QUICK_LOOK)

#include <WebCore/PreviewConverter.h>

#endif

#if ENABLE(CONTENT_FILTERING)

#include <WebCore/ContentFilter.h>

#include <WebCore/ContentFilterUnblockHandler.h>

#endif

#if HAVE(BROWSERENGINEKIT_WEBCONTENTFILTER)

#include "WebParentalControlsURLFilter.h"

#endif

#define LOADER_RELEASE_LOG_WITH_THIS(thisPtr, fmt, ...) RELEASE_LOG(Network, "%p - [pageProxyID=%" PRIu64 ", webPageID=%" PRIu64 ", frameID=%" PRIu64 ", resourceID=%" PRIu64 ", isMainResource=%d, destination=%u, isSynchronous=%d] NetworkResourceLoader::" fmt, WTF::getPtr(thisPtr), thisPtr->webPageProxyID().toUInt64(), thisPtr->pageID().toUInt64(), thisPtr->frameID().toUInt64(), thisPtr->coreIdentifier().toUInt64(), thisPtr->isMainResource(), static_cast<unsigned>(thisPtr->m_parameters.options.destination), thisPtr->isSynchronous(), ##__VA_ARGS__)

#define LOADER_RELEASE_LOG(fmt, ...) RELEASE_LOG(Network, "%p - [pageProxyID=%" PRIu64 ", webPageID=%" PRIu64 ", frameID=%" PRIu64 ", resourceID=%" PRIu64 ", isMainResource=%d, destination=%u, isSynchronous=%d] NetworkResourceLoader::" fmt, this, webPageProxyID().toUInt64(), pageID().toUInt64(), frameID().toUInt64(), coreIdentifier().toUInt64(), isMainResource(), static_cast<unsigned>(m_parameters.options.destination), isSynchronous(), ##__VA_ARGS__)

#define LOADER_RELEASE_LOG_DEBUG(fmt, ...) RELEASE_LOG_DEBUG(Network, "%p - [pageProxyID=%" PRIu64 ", webPageID=%" PRIu64 ", frameID=%" PRIu64 ", resourceID=%" PRIu64 ", isMainResource=%d, destination=%u, isSynchronous=%d] NetworkResourceLoader::" fmt, this, webPageProxyID().toUInt64(), pageID().toUInt64(), frameID().toUInt64(), coreIdentifier().toUInt64(), isMainResource(), static_cast<unsigned>(m_parameters.options.destination), isSynchronous(), ##__VA_ARGS__)

#define LOADER_RELEASE_LOG_ERROR(fmt, ...) RELEASE_LOG_ERROR(Network, "%p - [pageProxyID=%" PRIu64 ", webPageID=%" PRIu64 ", frameID=%" PRIu64 ", resourceID=%" PRIu64 ", isMainResource=%d, destination=%u, isSynchronous=%d] NetworkResourceLoader::" fmt, this, webPageProxyID().toUInt64(), pageID().toUInt64(), frameID().toUInt64(), coreIdentifier().toUInt64(), isMainResource(), static_cast<unsigned>(m_parameters.options.destination), isSynchronous(), ##__VA_ARGS__)

#define LOADER_RELEASE_LOG_FAULT(fmt, ...) RELEASE_LOG_FAULT(Network, "%p - [pageProxyID=%" PRIu64 ", webPageID=%" PRIu64 ", frameID=%" PRIu64 ", resourceID=%" PRIu64 ", isMainResource=%d, destination=%u, isSynchronous=%d] NetworkResourceLoader::" fmt, this, webPageProxyID().toUInt64(), pageID().toUInt64(), frameID().toUInt64(), coreIdentifier().toUInt64(), isMainResource(), static_cast<unsigned>(m_parameters.options.destination), isSynchronous(), ##__VA_ARGS__)

namespace WebKit {

using namespace WebCore;

struct NetworkResourceLoader::SynchronousLoadData {

WTF_DEPRECATED_MAKE_STRUCT_FAST_ALLOCATED(NetworkResourceLoader);

SynchronousLoadData(CompletionHandler<void(const ResourceError&, const ResourceResponse, Vector<uint8_t>&&)>&& reply)

: delayedReply(WTF::move(reply))

{

ASSERT(delayedReply);

}

ResourceRequest currentRequest;

CompletionHandler<void(const ResourceError&, const ResourceResponse, Vector<uint8_t>&&)> delayedReply;

ResourceResponse response;

ResourceError error;

};

static void sendReplyToSynchronousRequest(NetworkResourceLoader::SynchronousLoadData& data, const FragmentedSharedBuffer* buffer, const NetworkLoadMetrics& metrics)

{

ASSERT(data.delayedReply);

ASSERT(!data.response.isNull() || !data.error.isNull());

if (!data.delayedReply)

return;

Vector<uint8_t> responseBuffer;

if (buffer && buffer->size())

responseBuffer.append(buffer->makeContiguous()->span());

data.response.setDeprecatedNetworkLoadMetrics(Box<NetworkLoadMetrics>::create(metrics));

data.delayedReply(data.error, data.response, WTF::move(responseBuffer));

data.delayedReply = nullptr;

}

NetworkResourceLoader::NetworkResourceLoader(NetworkResourceLoadParameters&& parameters, NetworkConnectionToWebProcess& connection, CompletionHandler<void(const ResourceError&, const ResourceResponse, Vector<uint8_t>&&)>&& synchronousReply)

: m_parameters { WTF::move(parameters) }

, m_connection { connection }

, m_fileReferences(connection.resolveBlobReferences(m_parameters))

, m_isAllowedToAskUserForCredentials { m_parameters.clientCredentialPolicy == ClientCredentialPolicy::MayAskClientForCredentials }

, m_bufferingTimer { *this, &NetworkResourceLoader::bufferingTimerFired }

, m_shouldCaptureExtraNetworkLoadMetrics(m_connection->captureExtraNetworkLoadMetricsEnabled())

, m_resourceLoadID { NetworkResourceLoadIdentifier::generate() }

{

ASSERT(RunLoop::isMain());

if (CheckedPtr session = connection.networkProcess().networkSession(sessionID()))

m_cache = session->cache();

if (synchronousReply || m_parameters.shouldRestrictHTTPResponseAccess || m_parameters.options.keepAlive) {

NetworkLoadChecker::LoadType requestLoadType = isMainFrameLoad() ? NetworkLoadChecker::LoadType::MainFrame : NetworkLoadChecker::LoadType::Other;

m_networkLoadChecker = NetworkLoadChecker::create(Ref { connection.networkProcess() }.get(), this, &connection.schemeRegistry(), FetchOptions { m_parameters.options },

sessionID(), webPageProxyID(), HTTPHeaderMap { m_parameters.originalRequestHeaders }, URL { m_parameters.request.url() },

URL { m_parameters.documentURL }, m_parameters.sourceOrigin.copyRef(), m_parameters.topOrigin.copyRef(), m_parameters.parentOrigin(),

m_parameters.preflightPolicy, originalRequest().httpReferrer(), m_parameters.allowPrivacyProxy, m_parameters.advancedPrivacyProtections,

shouldCaptureExtraNetworkLoadMetrics(), requestLoadType);

RefPtr networkLoadChecker = m_networkLoadChecker;

if (m_parameters.cspResponseHeaders)

networkLoadChecker->setCSPResponseHeaders(ContentSecurityPolicyResponseHeaders { m_parameters.cspResponseHeaders.value() });

networkLoadChecker->setParentCrossOriginEmbedderPolicy(m_parameters.parentCrossOriginEmbedderPolicy);

networkLoadChecker->setCrossOriginEmbedderPolicy(m_parameters.crossOriginEmbedderPolicy);

#if ENABLE(CONTENT_EXTENSIONS)

networkLoadChecker->setContentExtensionController(URL { m_parameters.mainDocumentURL }, URL { m_parameters.frameURL }, m_parameters.userContentControllerIdentifier);

#endif

}

if (synchronousReply)

m_synchronousLoadData = makeUnique<SynchronousLoadData>(WTF::move(synchronousReply));

}

NetworkResourceLoader::~NetworkResourceLoader()

{

ASSERT(RunLoop::isMain());

ASSERT(!m_networkLoad);

ASSERT(!isSynchronous() || !m_synchronousLoadData->delayedReply);

ASSERT(m_fileReferences.isEmpty());

if (m_responseCompletionHandler)

m_responseCompletionHandler(PolicyAction::Ignore);

}

bool NetworkResourceLoader::canUseCache(const ResourceRequest& request) const

{

if (!m_cache)

return false;

ASSERT(!sessionID().isEphemeral());

if (!request.url().protocolIsInHTTPFamily())

return false;

if (originalRequest().cachePolicy() == WebCore::ResourceRequestCachePolicy::DoNotUseAnyCache)

return false;

return true;

}

bool NetworkResourceLoader::canUseCachedRedirect(const ResourceRequest& request) const

{

if (!canUseCache(request) || m_cacheEntryForMaxAgeCapValidation)

return false;

// Limit cached redirects to avoid cycles and other trouble.

// Networking layer follows over 30 redirects but caching that many seems unnecessary.

static const unsigned maximumCachedRedirectCount { 5 };

if (m_redirectCount > maximumCachedRedirectCount)

return false;

return true;

}

bool NetworkResourceLoader::isSynchronous() const

{

return !!m_synchronousLoadData;

}

void NetworkResourceLoader::start()

{

startRequest(originalRequest());

}

void NetworkResourceLoader::startRequest(const ResourceRequest& newRequest)

{

ASSERT(RunLoop::isMain());

RefPtr networkLoadChecker = m_networkLoadChecker;

LOADER_RELEASE_LOG("startRequest: hasNetworkLoadChecker=%d", !!networkLoadChecker);

m_networkActivityTracker = protect(connectionToWebProcess())->startTrackingResourceLoad(pageID(), coreIdentifier(), isMainFrameLoad());

ASSERT(!m_wasStarted);

m_wasStarted = true;

if (networkLoadChecker) {

networkLoadChecker->check(ResourceRequest { newRequest }, this, [weakThis = WeakPtr { *this }] (auto&& result) {

RefPtr protectedThis = weakThis.get();

if (!protectedThis)

return;

WTF::switchOn(result,

[protectedThis] (ResourceError& error) {

LOADER_RELEASE_LOG_WITH_THIS(protectedThis, "start: NetworkLoadChecker::check returned an error (error.domain=%" PUBLIC_LOG_STRING ", error.code=%d, isCancellation=%d)", error.domain().utf8().data(), error.errorCode(), error.isCancellation());

if (!error.isCancellation())

protectedThis->didFailLoading(error);

},

[protectedThis] (NetworkLoadChecker::RedirectionTriplet& triplet) {

LOADER_RELEASE_LOG_WITH_THIS(protectedThis, "start: NetworkLoadChecker::check returned a synthetic redirect");

protectedThis->m_isWaitingContinueWillSendRequestForCachedRedirect = true;

protectedThis->willSendRedirectedRequest(WTF::move(triplet.request), WTF::move(triplet.redirectRequest), WTF::move(triplet.redirectResponse), [](auto) { });

},

[protectedThis] (ResourceRequest& request) {

LOADER_RELEASE_LOG_WITH_THIS(protectedThis, "start: NetworkLoadChecker::check is done");

if (protectedThis->canUseCache(request)) {

protectedThis->retrieveCacheEntry(request);

return;

}

protectedThis->startNetworkLoad(WTF::move(request), FirstLoad::Yes);

}

);

});

return;

}

// FIXME: Remove that code path once m_networkLoadChecker is used for all network loads.

if (canUseCache(newRequest)) {

retrieveCacheEntry(originalRequest());

return;

}

startNetworkLoad(ResourceRequest { newRequest }, FirstLoad::Yes);

}

#if ENABLE(CONTENT_FILTERING)

void NetworkResourceLoader::startContentFiltering(ResourceRequest&& request, CompletionHandler<void(ResourceRequest)>&& completionHandler)

{

if (!isMainResource()) {

completionHandler(WTF::move(request));

return;

}

#if HAVE(BROWSERENGINEKIT_WEBCONTENTFILTER) && !HAVE(WEBCONTENTRESTRICTIONS_PATH_SPI)

WebParentalControlsURLFilter::setSharedParentalControlsURLFilterIfNecessary();

#endif

m_contentFilter = ContentFilter::create(*this);

RefPtr contentFilter = m_contentFilter;

#if HAVE(AUDIT_TOKEN)

contentFilter->setHostProcessAuditToken(protect(connectionToWebProcess())->networkProcess().sourceApplicationAuditToken());

#endif

contentFilter->startFilteringMainResource(request.url());

CompletionHandler<void(ResourceRequest)> completion = [contentFilter, completionHandler = WTF::move(completionHandler)](ResourceRequest&& request) mutable {

ASSERT(isMainRunLoop());

if (contentFilter && request.isNull())

contentFilter->stopFilteringMainResource();

completionHandler(WTF::move(request));

};

contentFilter->continueAfterWillSendRequest(WTF::move(request), ResourceResponse(), WTF::move(completion));

}

#endif

void NetworkResourceLoader::retrieveCacheEntry(const ResourceRequest& request)

{

LOADER_RELEASE_LOG("retrieveCacheEntry: isMainFrameLoad=%d", isMainFrameLoad());

ASSERT(canUseCache(request));

Ref protectedThis { *this };

RefPtr cache = m_cache;

if (isMainFrameLoad()) {

ASSERT(m_parameters.options.mode == FetchOptions::Mode::Navigate);

if (CheckedPtr session = protect(connectionToWebProcess())->networkProcess().networkSession(sessionID())) {

if (auto entry = protect(session->prefetchCache())->take(request.url())) {

LOADER_RELEASE_LOG("retrieveCacheEntry: retrieved an entry from the prefetch cache (isRedirect=%d)", !entry->redirectRequest.isNull());

if (!entry->redirectRequest.isNull()) {

auto cacheEntry = cache->makeRedirectEntry(request, entry->response, entry->redirectRequest);

retrieveCacheEntryInternal(WTF::move(cacheEntry), ResourceRequest { request });

auto maxAgeCap = validateCacheEntryForMaxAgeCapValidation(request, entry->redirectRequest, entry->response);

cache->storeRedirect(request, entry->response, entry->redirectRequest, maxAgeCap);

return;

}

auto buffer = entry->releaseBuffer();

auto cacheEntry = cache->makeEntry(request, entry->response, entry->privateRelayed, buffer.copyRef());

retrieveCacheEntryInternal(WTF::move(cacheEntry), ResourceRequest { request });

cache->store(request, entry->response, entry->privateRelayed, WTF::move(buffer));

return;

}

}

}

LOADER_RELEASE_LOG("retrieveCacheEntry: Checking the HTTP disk cache");

cache->retrieve(request, globalFrameID(), m_parameters.isNavigatingToAppBoundDomain, m_parameters.allowPrivacyProxy, m_parameters.advancedPrivacyProtections, [weakThis = WeakPtr { *this }, request = ResourceRequest { request }](auto entry, auto info) mutable {

RefPtr protectedThis = weakThis.get();

if (!protectedThis)

return;

LOADER_RELEASE_LOG_WITH_THIS(protectedThis, "retrieveCacheEntry: Done checking the HTTP disk cache (foundCachedEntry=%d)", !!entry);

protectedThis->logSlowCacheRetrieveIfNeeded(info);

if (!entry) {

protectedThis->startNetworkLoad(WTF::move(request), FirstLoad::Yes);

return;

}

protectedThis->retrieveCacheEntryInternal(WTF::move(entry), WTF::move(request));

});

}

void NetworkResourceLoader::retrieveCacheEntryInternal(std::unique_ptr<NetworkCache::Entry>&& entry, WebCore::ResourceRequest&& request)

{

LOADER_RELEASE_LOG("retrieveCacheEntryInternal:");

if (entry->hasReachedPrevalentResourceAgeCap()) {

LOADER_RELEASE_LOG("retrieveCacheEntryInternal: Revalidating cached entry because it reached the prevalent resource age cap");

m_cacheEntryForMaxAgeCapValidation = WTF::move(entry);

ResourceRequest revalidationRequest = originalRequest();

startNetworkLoad(WTF::move(revalidationRequest), FirstLoad::Yes);

return;

}

if (entry->redirectRequest()) {

LOADER_RELEASE_LOG("retrieveCacheEntryInternal: Cached entry is a redirect");

dispatchWillSendRequestForCacheEntry(WTF::move(request), WTF::move(entry));

return;

}

if (m_parameters.needsCertificateInfo && !entry->response().certificateInfo()) {

LOADER_RELEASE_LOG("retrieveCacheEntryInternal: Cached entry is missing certificate information so we are not using it");

startNetworkLoad(WTF::move(request), FirstLoad::Yes);

return;

}

if (entry->needsValidation() || request.cachePolicy() == WebCore::ResourceRequestCachePolicy::RefreshAnyCacheData) {

LOADER_RELEASE_LOG("retrieveCacheEntryInternal: Cached entry needs revalidation");

validateCacheEntry(WTF::move(entry));

return;

}

LOADER_RELEASE_LOG("retrieveCacheEntryInternal: Cached entry is directly usable");

didRetrieveCacheEntry(WTF::move(entry));

}

bool NetworkResourceLoader::shouldSendResourceLoadMessages() const

{

if (m_parameters.pageHasResourceLoadClient)

return true;

#if ENABLE(WK_WEB_EXTENSIONS)

if (m_parameters.pageHasLoadedWebExtensions)

return true;

#endif

return false;

}

void NetworkResourceLoader::startNetworkLoad(ResourceRequest&& request, FirstLoad load)

{

if (load == FirstLoad::Yes) {

consumeSandboxExtensions();

if (isSynchronous() || m_parameters.maximumBufferingTime > 0_s)

m_bufferedData.empty();

if (canUseCache(request))

m_bufferedDataForCache.empty();

}

NetworkLoadParameters parameters = m_parameters.networkLoadParameters();

parameters.networkActivityTracker = m_networkActivityTracker;

if (parameters.storedCredentialsPolicy == WebCore::StoredCredentialsPolicy::Use && m_networkLoadChecker)

parameters.storedCredentialsPolicy = m_networkLoadChecker->storedCredentialsPolicy();

CheckedPtr networkSession = protect(connectionToWebProcess())->networkSession();

if (!networkSession) {

WTFLogAlways("Attempted to create a NetworkLoad with a session (id=%" PRIu64 ") that does not exist.", sessionID().toUInt64());

LOADER_RELEASE_LOG_ERROR("startNetworkLoad: Attempted to create a NetworkLoad for a session that does not exist (sessionID=%" PRIu64 ")", sessionID().toUInt64());

protect(connectionToWebProcess())->networkProcess().logDiagnosticMessage(webPageProxyID(), WebCore::DiagnosticLoggingKeys::internalErrorKey(), WebCore::DiagnosticLoggingKeys::invalidSessionIDKey(), WebCore::ShouldSample::No);

didFailLoading(internalError(request.url()));

return;

}

if (request.wasSchemeOptimisticallyUpgraded()) {

double optimisticUpgradeTimeout { 3 };

if (double average = networkSession->currentHTTPSConnectionAverageTiming())

optimisticUpgradeTimeout = average;

request.setTimeoutInterval(optimisticUpgradeTimeout);

}

LOADER_RELEASE_LOG("startNetworkLoad: (isFirstLoad=%d, timeout=%f)", load == FirstLoad::Yes, request.timeoutInterval());

if (request.url().protocolIsBlob()) {

ASSERT(parameters.topOrigin);

parameters.blobFileReferences = networkSession->blobRegistry().filesInBlob(originalRequest().url(), parameters.topOrigin ? std::optional { parameters.topOrigin->data() } : std::nullopt);

}

if (shouldSendResourceLoadMessages()) {

std::optional<IPC::FormDataReference> httpBody;

if (auto formData = request.httpBody()) {

static constexpr auto maxSerializedRequestSize = 1024 * 1024;

if (formData->lengthInBytes() <= maxSerializedRequestSize)

httpBody = IPC::FormDataReference { WTF::move(formData) };

}

protect(protect(connectionToWebProcess())->networkProcess().parentProcessConnection())->send(Messages::NetworkProcessProxy::ResourceLoadDidSendRequest(webPageProxyID(), resourceLoadInfo(), request, httpBody), 0);

}

if (networkSession->shouldSendPrivateTokenIPCForTesting())

protect(protect(connectionToWebProcess())->networkProcess().parentProcessConnection())->send(Messages::NetworkProcessProxy::DidAllowPrivateTokenUsageByThirdPartyForTesting(sessionID(), request.isPrivateTokenUsageByThirdPartyAllowed(), request.url()), 0);

parameters.request = WTF::move(request);

parameters.isNavigatingToAppBoundDomain = m_parameters.isNavigatingToAppBoundDomain;

m_networkLoad = NetworkLoad::create(*this, WTF::move(parameters), *networkSession);

WeakPtr weakThis { *this };

RefPtr networkLoad = m_networkLoad;

if (isSynchronous())

networkLoad->start(); // May delete this object

else

networkLoad->startWithScheduling();

if (weakThis && networkLoad)

LOADER_RELEASE_LOG("startNetworkLoad: Going to the network (description=%" PUBLIC_LOG_STRING ")", networkLoad->description().utf8().data());

}

ResourceLoadInfo NetworkResourceLoader::resourceLoadInfo()

{

auto loadedFromCache = [] (const ResourceResponse& response) {

switch (response.source()) {

case ResourceResponse::Source::DiskCache:

case ResourceResponse::Source::DiskCacheAfterValidation:

case ResourceResponse::Source::MemoryCache:

case ResourceResponse::Source::MemoryCacheAfterValidation:

case ResourceResponse::Source::LegacyApplicationCachePlaceholder:

case ResourceResponse::Source::DOMCache:

return true;

case ResourceResponse::Source::Unknown:

case ResourceResponse::Source::Network:

case ResourceResponse::Source::ServiceWorker:

case ResourceResponse::Source::InspectorOverride:

break;

}

return false;

};

auto resourceType = [] (WebCore::ResourceRequestRequester requester, WebCore::FetchOptions::Destination destination) {

switch (requester) {

case WebCore::ResourceRequestRequester::XHR:

return ResourceLoadInfo::Type::XMLHTTPRequest;

case WebCore::ResourceRequestRequester::Fetch:

return ResourceLoadInfo::Type::Fetch;

case WebCore::ResourceRequestRequester::Ping:

return ResourceLoadInfo::Type::Ping;

case WebCore::ResourceRequestRequester::Beacon:

return ResourceLoadInfo::Type::Beacon;

default:

break;

}

switch (destination) {

case WebCore::FetchOptions::Destination::EmptyString:

return ResourceLoadInfo::Type::Other;

case WebCore::FetchOptions::Destination::Audio:

return ResourceLoadInfo::Type::Media;

case WebCore::FetchOptions::Destination::Audioworklet:

return ResourceLoadInfo::Type::Other;

case WebCore::FetchOptions::Destination::Document:

case WebCore::FetchOptions::Destination::Iframe:

return ResourceLoadInfo::Type::Document;

case WebCore::FetchOptions::Destination::Json:

return ResourceLoadInfo::Type::Script;

case WebCore::FetchOptions::Destination::Embed:

return ResourceLoadInfo::Type::Object;

case WebCore::FetchOptions::Destination::Environmentmap:

return ResourceLoadInfo::Type::Media;

case WebCore::FetchOptions::Destination::Font:

return ResourceLoadInfo::Type::Font;

case WebCore::FetchOptions::Destination::Image:

return ResourceLoadInfo::Type::Image;

case WebCore::FetchOptions::Destination::Manifest:

return ResourceLoadInfo::Type::ApplicationManifest;

case WebCore::FetchOptions::Destination::Model:

return ResourceLoadInfo::Type::Media;

case WebCore::FetchOptions::Destination::Object:

return ResourceLoadInfo::Type::Object;

case WebCore::FetchOptions::Destination::Paintworklet:

return ResourceLoadInfo::Type::Other;

case WebCore::FetchOptions::Destination::Report:

return ResourceLoadInfo::Type::CSPReport;

case WebCore::FetchOptions::Destination::Script:

return ResourceLoadInfo::Type::Script;

case WebCore::FetchOptions::Destination::Serviceworker:

return ResourceLoadInfo::Type::Other;

case WebCore::FetchOptions::Destination::Sharedworker:

return ResourceLoadInfo::Type::Other;

case WebCore::FetchOptions::Destination::Speculationrules:

return ResourceLoadInfo::Type::Other;

case WebCore::FetchOptions::Destination::Style:

return ResourceLoadInfo::Type::Stylesheet;

case WebCore::FetchOptions::Destination::Track:

return ResourceLoadInfo::Type::Media;

case WebCore::FetchOptions::Destination::Video:

return ResourceLoadInfo::Type::Media;

case WebCore::FetchOptions::Destination::Worker:

return ResourceLoadInfo::Type::Other;

case WebCore::FetchOptions::Destination::Xslt:

return ResourceLoadInfo::Type::XSLT;

}

ASSERT_NOT_REACHED();

return ResourceLoadInfo::Type::Other;

};

return {

m_resourceLoadID,

m_parameters.webFrameID,

m_parameters.parentFrameID,

m_parameters.options.resultingClientIdentifier ?: m_parameters.options.clientIdentifier,

originalRequest().url(),

originalRequest().httpMethod(),

WallTime::now(),

loadedFromCache(m_response),

resourceType(originalRequest().requester(), m_parameters.options.destination)

};

}

void NetworkResourceLoader::cleanup(LoadResult result)

{

ASSERT(RunLoop::isMain());

LOADER_RELEASE_LOG("cleanup: (result=%u)", static_cast<unsigned>(result));

NetworkActivityTracker::CompletionCode code { };

switch (result) {

case LoadResult::Unknown:

code = NetworkActivityTracker::CompletionCode::Undefined;

break;

case LoadResult::Success:

code = NetworkActivityTracker::CompletionCode::Success;

break;

case LoadResult::Failure:

code = NetworkActivityTracker::CompletionCode::Failure;

break;

case LoadResult::Cancel:

code = NetworkActivityTracker::CompletionCode::Cancel;

break;

}

Ref connection = m_connection;

connection->stopTrackingResourceLoad(coreIdentifier(), code);

m_bufferingTimer.stop();

invalidateSandboxExtensions();

if (RefPtr networkLoad = std::exchange(m_networkLoad, nullptr))

networkLoad->clearClient();

// This will cause NetworkResourceLoader to be destroyed and therefore we do it last.

connection->didCleanupResourceLoader(*this);

}

void NetworkResourceLoader::convertToDownload(DownloadID downloadID, const ResourceRequest& request, const ResourceResponse& response)

{

LOADER_RELEASE_LOG("convertToDownload: (downloadID=%" PRIu64 ", hasNetworkLoad=%d, hasResponseCompletionHandler=%d)", downloadID.toUInt64(), !!m_networkLoad, !!m_responseCompletionHandler);

RefPtr task = m_serviceWorkerFetchTask;

if (task && task->convertToDownload(protect(protect(connectionToWebProcess())->networkProcess().downloadManager()), downloadID, request, response))

return;

// This can happen if the resource came from the disk cache.

if (!m_networkLoad) {

protect(protect(connectionToWebProcess())->networkProcess().downloadManager())->startDownload(sessionID(), downloadID, request, m_parameters.topOrigin ? std::optional { m_parameters.topOrigin->data() } : std::nullopt, m_parameters.isNavigatingToAppBoundDomain);

abort();

return;

}

auto networkLoad = std::exchange(m_networkLoad, nullptr);

if (m_responseCompletionHandler)

protect(protect(connectionToWebProcess())->networkProcess().downloadManager())->convertNetworkLoadToDownload(downloadID, networkLoad.releaseNonNull(), WTF::move(m_responseCompletionHandler), WTF::move(m_fileReferences), request, response);

}

void NetworkResourceLoader::abort()

{

LOADER_RELEASE_LOG("abort: (hasNetworkLoad=%d)", !!m_networkLoad);

ASSERT(RunLoop::isMain());

if (m_parameters.options.keepAlive && m_response.isNull() && !m_isKeptAlive) {

m_isKeptAlive = true;

LOADER_RELEASE_LOG("abort: Keeping network load alive due to keepalive option");

protect(connectionToWebProcess())->transferKeptAliveLoad(*this);

return;

}

if (auto task = WTF::move(m_serviceWorkerFetchTask)) {

LOADER_RELEASE_LOG("abort: Cancelling pending service worker fetch task (fetchIdentifier=%" PRIu64 ")", task->fetchIdentifier().toUInt64());

task->cancelFromClient();

}

if (RefPtr networkLoad = m_networkLoad) {

if (canUseCache(networkLoad->currentRequest())) {

// We might already have used data from this incomplete load. Ensure older versions don't remain in the cache after cancel.

if (!m_response.isNull())

protect(m_cache)->remove(networkLoad->currentRequest());

}

LOADER_RELEASE_LOG("abort: Cancelling network load");

networkLoad->cancel();

}

if (isSynchronous()) {

m_synchronousLoadData->error = ResourceError { ResourceError::Type::Cancellation };

sendReplyToSynchronousRequest(*m_synchronousLoadData, nullptr, { });

}

cleanup(LoadResult::Cancel);

}

std::optional<NetworkLoadMetrics> NetworkResourceLoader::computeResponseMetrics(const ResourceResponse& response) const

{

if (parameters().options.mode != FetchOptions::Mode::Navigate)

return { };

NetworkLoadMetrics networkLoadMetrics;

if (auto* metrics = response.deprecatedNetworkLoadMetricsOrNull())

networkLoadMetrics = *metrics;

networkLoadMetrics.redirectCount = m_redirectCount;

return networkLoadMetrics;

}

void NetworkResourceLoader::transferToNewWebProcess(NetworkConnectionToWebProcess& newConnection, const NetworkResourceLoadParameters& parameters)

{

m_connection = newConnection;

m_parameters.identifier = parameters.identifier;

m_parameters.webPageProxyID = parameters.webPageProxyID;

m_parameters.webPageID = parameters.webPageID;

m_parameters.webFrameID = parameters.webFrameID;

m_parameters.options.clientIdentifier = parameters.options.clientIdentifier;

if (parameters.options.resultingClientIdentifier && m_parameters.options.resultingClientIdentifier)

send(Messages::WebResourceLoader::UpdateResultingClientIdentifier { *parameters.options.resultingClientIdentifier, *m_parameters.options.resultingClientIdentifier });

ASSERT(m_responseCompletionHandler || m_cacheEntryWaitingForContinueDidReceiveResponse || m_serviceWorkerFetchTask);

if (RefPtr serviceWorkerRegistration = m_serviceWorkerRegistration.get()) {

if (RefPtr swConnection = newConnection.swConnection())

swConnection->transferServiceWorkerLoadToNewWebProcess(*this, *serviceWorkerRegistration, parameters.request);

}

if (m_serviceWorkerTimingInfo)

send(Messages::WebResourceLoader::SetServiceWorkerTimingInfo { *m_serviceWorkerTimingInfo }, coreIdentifier());

bool willWaitForContinueDidReceiveResponse = true;

send(Messages::WebResourceLoader::DidReceiveResponse { m_response, m_privateRelayed, willWaitForContinueDidReceiveResponse, computeResponseMetrics(m_response) });

}

bool NetworkResourceLoader::shouldInterruptLoadForXFrameOptions(const String& xFrameOptions, const URL& url)

{

if (isMainFrameLoad())

return false;

switch (parseXFrameOptionsHeader(xFrameOptions)) {

case XFrameOptionsDisposition::None:

case XFrameOptionsDisposition::AllowAll:

return false;

case XFrameOptionsDisposition::Deny:

return true;

case XFrameOptionsDisposition::SameOrigin: {

auto origin = SecurityOrigin::create(url);

auto topFrameOrigin = m_parameters.frameAncestorOrigins.last();

if (!origin->isSameSchemeHostPort(topFrameOrigin))

return true;

for (auto& ancestorOrigin : m_parameters.frameAncestorOrigins) {

if (!origin->isSameSchemeHostPort(ancestorOrigin))

return true;

}

return false;

}

case XFrameOptionsDisposition::Conflict: {

auto errorMessage = makeString("Multiple 'X-Frame-Options' headers with conflicting values ('"_s, xFrameOptions, "') encountered when loading '"_s, url.stringCenterEllipsizedToLength(), "'. Falling back to 'DENY'."_s);

send(Messages::WebPage::AddConsoleMessage { frameID(), MessageSource::JS, MessageLevel::Error, errorMessage, coreIdentifier() }, pageID());

return true;

}

case XFrameOptionsDisposition::Invalid: {

auto errorMessage = makeString("Invalid 'X-Frame-Options' header encountered when loading '"_s, url.stringCenterEllipsizedToLength(), "': '"_s, xFrameOptions, "' is not a recognized directive. The header will be ignored."_s);

send(Messages::WebPage::AddConsoleMessage { frameID(), MessageSource::JS, MessageLevel::Error, errorMessage, coreIdentifier() }, pageID());

return false;

}

}

ASSERT_NOT_REACHED();

return false;

}

bool NetworkResourceLoader::shouldInterruptLoadForCSPFrameAncestorsOrXFrameOptions(const ResourceResponse& response)

{

ASSERT(isMainResource());

auto sharedPreferences = connectionToWebProcess().sharedPreferencesForWebProcess();

if (!sharedPreferences || sharedPreferences->ignoreIframeEmbeddingProtectionsEnabled)

return false;

#if USE(QUICK_LOOK)

if (PreviewConverter::supportsMIMEType(response.mimeType()))

return false;

#endif

auto url = response.url();

ContentSecurityPolicy contentSecurityPolicy { URL { url }, this, this };

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

if (!contentSecurityPolicy.allowFrameAncestors(m_parameters.frameAncestorOrigins, url))

return true;

if (shouldInterruptNavigationForCrossOriginEmbedderPolicy(response))

return true;

if (!contentSecurityPolicy.overridesXFrameOptions()) {

String xFrameOptions = response.httpHeaderField(HTTPHeaderName::XFrameOptions);

if (!xFrameOptions.isNull() && shouldInterruptLoadForXFrameOptions(xFrameOptions, response.url())) {

String errorMessage = makeString("Refused to display '"_s, response.url().stringCenterEllipsizedToLength(), "' in a frame because it set 'X-Frame-Options' to '"_s, xFrameOptions, "'."_s);

send(Messages::WebPage::AddConsoleMessage { frameID(), MessageSource::Security, MessageLevel::Error, errorMessage, coreIdentifier() }, pageID());

return true;

}

}

return false;

}

bool NetworkResourceLoader::shouldInterruptNavigationForCrossOriginEmbedderPolicy(const ResourceResponse& response)

{

ASSERT(isMainResource());

// https://html.spec.whatwg.org/multipage/origin.html#check-a-navigation-response's-adherence-to-its-embedder-policy

if (m_parameters.parentCrossOriginEmbedderPolicy.value == WebCore::CrossOriginEmbedderPolicyValue::RequireCORP || m_parameters.parentCrossOriginEmbedderPolicy.reportOnlyValue == WebCore::CrossOriginEmbedderPolicyValue::RequireCORP) {

auto responseCOEP = WebCore::obtainCrossOriginEmbedderPolicy(response, nullptr);

if (m_parameters.parentCrossOriginEmbedderPolicy.reportOnlyValue == WebCore::CrossOriginEmbedderPolicyValue::RequireCORP && responseCOEP.value != WebCore::CrossOriginEmbedderPolicyValue::RequireCORP)

sendCOEPInheritenceViolation(*this, m_parameters.parentFrameURL.isValid() ? m_parameters.parentFrameURL : aboutBlankURL(), m_parameters.parentCrossOriginEmbedderPolicy.reportOnlyReportingEndpoint, COEPDisposition::Reporting, "navigation"_s, m_firstResponseURL);

if (m_parameters.parentCrossOriginEmbedderPolicy.value != WebCore::CrossOriginEmbedderPolicyValue::UnsafeNone && responseCOEP.value != WebCore::CrossOriginEmbedderPolicyValue::RequireCORP) {

String errorMessage = makeString("Refused to display '"_s, response.url().stringCenterEllipsizedToLength(), "' in a frame because of Cross-Origin-Embedder-Policy."_s);

send(Messages::WebPage::AddConsoleMessage { frameID(), MessageSource::Security, MessageLevel::Error, errorMessage, coreIdentifier() }, pageID());

sendCOEPInheritenceViolation(*this, m_parameters.parentFrameURL.isValid() ? m_parameters.parentFrameURL : aboutBlankURL(), m_parameters.parentCrossOriginEmbedderPolicy.reportingEndpoint, COEPDisposition::Enforce, "navigation"_s, m_firstResponseURL);

return true;

}

}

return false;

}

// https://html.spec.whatwg.org/multipage/origin.html#check-a-global-object's-embedder-policy

bool NetworkResourceLoader::shouldInterruptWorkerLoadForCrossOriginEmbedderPolicy(const ResourceResponse& response)

{

if (m_parameters.options.destination != FetchOptions::Destination::Worker)

return false;

if (m_parameters.crossOriginEmbedderPolicy.value == WebCore::CrossOriginEmbedderPolicyValue::RequireCORP || m_parameters.crossOriginEmbedderPolicy.reportOnlyValue == WebCore::CrossOriginEmbedderPolicyValue::RequireCORP) {

auto responseCOEP = WebCore::obtainCrossOriginEmbedderPolicy(response, nullptr);

if (m_parameters.crossOriginEmbedderPolicy.reportOnlyValue == WebCore::CrossOriginEmbedderPolicyValue::RequireCORP && responseCOEP.value == WebCore::CrossOriginEmbedderPolicyValue::UnsafeNone)

sendCOEPInheritenceViolation(*this, m_parameters.frameURL.isValid() ? m_parameters.frameURL : aboutBlankURL(), m_parameters.crossOriginEmbedderPolicy.reportOnlyReportingEndpoint, COEPDisposition::Reporting, "worker initialization"_s, m_firstResponseURL);

if (m_parameters.crossOriginEmbedderPolicy.value == WebCore::CrossOriginEmbedderPolicyValue::RequireCORP && responseCOEP.value == WebCore::CrossOriginEmbedderPolicyValue::UnsafeNone) {

String errorMessage = makeString("Refused to load '"_s, response.url().stringCenterEllipsizedToLength(), "' worker because of Cross-Origin-Embedder-Policy."_s);

send(Messages::WebPage::AddConsoleMessage { frameID(), MessageSource::Security, MessageLevel::Error, errorMessage, coreIdentifier() }, pageID());

sendCOEPInheritenceViolation(*this, m_parameters.frameURL.isValid() ? m_parameters.frameURL : aboutBlankURL(), m_parameters.crossOriginEmbedderPolicy.reportingEndpoint, COEPDisposition::Enforce, "worker initialization"_s, m_firstResponseURL);

return true;

}

}

return false;

}

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

std::optional<ResourceError> NetworkResourceLoader::doCrossOriginOpenerHandlingOfResponse(const ResourceResponse& response)

{

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

if (!isMainFrameLoad())

return std::nullopt;

if (!m_parameters.isCrossOriginOpenerPolicyEnabled)

return std::nullopt;

std::unique_ptr<ContentSecurityPolicy> contentSecurityPolicy;

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

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

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

}

if (!m_currentCoopEnforcementResult) {

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

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

}

m_currentCoopEnforcementResult = WebCore::doCrossOriginOpenerHandlingOfResponse(*this, response, m_parameters.navigationRequester, CheckedPtr { contentSecurityPolicy.get() }, m_parameters.effectiveSandboxFlags, originalRequest().httpReferrer(), m_parameters.isDisplayingInitialEmptyDocument, *m_currentCoopEnforcementResult);

if (!m_currentCoopEnforcementResult)

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

return std::nullopt;

}

void NetworkResourceLoader::processClearSiteDataHeader(const WebCore::ResourceResponse& response, CompletionHandler<void()>&& completionHandler)

{

if (!m_parameters.isClearSiteDataHeaderEnabled)

return completionHandler();

auto clearSiteDataValues = parseClearSiteDataHeader(response);

OptionSet<WebsiteDataType> typesToRemove;

if (clearSiteDataValues.contains(ClearSiteDataValue::Cache))

typesToRemove.add({ WebsiteDataType::DiskCache, WebsiteDataType::MemoryCache });

if (clearSiteDataValues.contains(ClearSiteDataValue::Cookies))

typesToRemove.add(WebsiteDataType::Cookies);

if (clearSiteDataValues.contains(ClearSiteDataValue::Storage)) {

typesToRemove.add({ WebsiteDataType::LocalStorage, WebsiteDataType::SessionStorage, WebsiteDataType::IndexedDBDatabases, WebsiteDataType::DOMCache, WebsiteDataType::FileSystem, WebsiteDataType::WebSQLDatabases });

typesToRemove.add(WebsiteDataType::ServiceWorkerRegistrations);

}

bool shouldReloadExecutionContexts = m_parameters.isClearSiteDataExecutionContextEnabled && clearSiteDataValues.contains(ClearSiteDataValue::ExecutionContexts);

if (!typesToRemove && !shouldReloadExecutionContexts)

return completionHandler();

LOADER_RELEASE_LOG("processClearSiteDataHeader: BEGIN");

auto origin = SecurityOrigin::create(response.url())->data();

ClientOrigin clientOrigin {

m_parameters.topOrigin ? m_parameters.topOrigin->data() : origin,

origin

};

auto callbackAggregator = CallbackAggregator::create([weakThis = WeakPtr { *this }, completionHandler = WTF::move(completionHandler)]() mutable {

RefPtr protectedThis = weakThis.get();

if (!protectedThis)

return completionHandler();

LOADER_RELEASE_LOG_WITH_THIS(protectedThis, "processClearSiteDataHeader: END");

completionHandler();

});

if (typesToRemove)

protect(connectionToWebProcess())->networkProcess().deleteWebsiteDataForOrigin(sessionID(), typesToRemove, clientOrigin, [callbackAggregator] { });

if (WebsiteDataStore::computeWebProcessAccessTypeForDataRemoval(typesToRemove, sessionID().isEphemeral()) != WebsiteDataStore::ProcessAccessType::None)

protect(protect(connectionToWebProcess())->networkProcess().parentProcessConnection())->sendWithAsyncReply(Messages::NetworkProcessProxy::DeleteWebsiteDataInWebProcessesForOrigin(typesToRemove, clientOrigin, sessionID(), webPageProxyID()), [callbackAggregator] { });

if (shouldReloadExecutionContexts) {

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

if (isMainResource())

triggeringFrame = frameID();

protect(protect(connectionToWebProcess())->networkProcess().parentProcessConnection())->sendWithAsyncReply(Messages::NetworkProcessProxy::ReloadExecutionContextsForOrigin(clientOrigin, sessionID(), triggeringFrame), [callbackAggregator] { });

}

}

static BrowsingContextGroupSwitchDecision NODELETE 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::didReceiveInformationalResponse(ResourceResponse&& response)

{

if (response.httpStatusCode() != httpStatus103EarlyHints)

return;

if (!m_earlyHintsResourceLoader)

m_earlyHintsResourceLoader = WTF::makeUnique<EarlyHintsResourceLoader>(*this);

m_earlyHintsResourceLoader->handleEarlyHintsResponse(WTF::move(response));

}

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

{

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

#if ENABLE(CONTENT_FILTERING)

if (m_contentFilter && !protect(m_contentFilter)->continueAfterResponseReceived(receivedResponse))

return completionHandler(PolicyAction::Ignore);

#endif

if (isMainResource())

didReceiveMainResourceResponse(receivedResponse);

m_response = WTF::move(receivedResponse);

m_privateRelayed = privateRelayed;

if (!m_firstResponseURL.isValid())

m_firstResponseURL = m_response.url();

Ref connection = m_connection;

RefPtr networkLoadChecker = m_networkLoadChecker;

if (shouldCaptureExtraNetworkLoadMetrics() && networkLoadChecker) {

auto information = networkLoadChecker->takeNetworkLoadInformation();

information.response = m_response;

connection->addNetworkLoadInformation(coreIdentifier(), WTF::move(information));

}

if (CheckedPtr networkSession = m_response.url().protocolIs("https"_s) ? connection->networkSession() : nullptr) {

if (auto metrics = computeResponseMetrics(m_response))

networkSession->recordHTTPSConnectionTiming(*metrics);

}

auto resourceLoadInfo = this->resourceLoadInfo();

auto isFetchOrXHR = [] (const ResourceLoadInfo& info) {

return info.type == ResourceLoadInfo::Type::Fetch

|| info.type == ResourceLoadInfo::Type::XMLHTTPRequest;

};

auto isMediaMIMEType = [] (const String& mimeType) {

return startsWithLettersIgnoringASCIICase(mimeType, "audio/"_s)

|| startsWithLettersIgnoringASCIICase(mimeType, "video/"_s)

|| equalLettersIgnoringASCIICase(mimeType, "application/octet-stream"_s);

};

if (!m_bufferedData

&& m_response.expectedContentLength() > static_cast<long long>(1 * MB)

&& isFetchOrXHR(resourceLoadInfo)

&& isMediaMIMEType(m_response.mimeType())) {

m_bufferedData.empty();

m_parameters.maximumBufferingTime = WebLoaderStrategy::mediaMaximumBufferingTime;

}

// For multipart/x-mixed-replace didReceiveResponseAsync gets called multiple times and buffering would require special handling.

if (!isSynchronous() && m_response.isMultipart())

m_bufferedData.reset();

if (m_response.isMultipart())

m_bufferedDataForCache.reset();

if (m_cacheEntryForValidation) {

bool validationSucceeded = m_response.httpStatusCode() == httpStatus304NotModified;

LOADER_RELEASE_LOG("didReceiveResponse: Received revalidation response (validationSucceeded=%d, wasOriginalRequestConditional=%d)", validationSucceeded, originalRequest().isConditional());

if (validationSucceeded) {

m_cacheEntryForValidation = protect(m_cache)->update(originalRequest(), *m_cacheEntryForValidation, m_response, m_privateRelayed);

// If the request was conditional then this revalidation was not triggered by the network cache and we pass the 304 response to WebCore.

if (originalRequest().isConditional()) {

// Add CORP header to the 304 response if previously set to avoid being blocked by load checker due to COEP.

auto crossOriginResourcePolicy = m_cacheEntryForValidation->response().httpHeaderField(HTTPHeaderName::CrossOriginResourcePolicy);

if (!crossOriginResourcePolicy.isEmpty())

m_response.setHTTPHeaderField(HTTPHeaderName::CrossOriginResourcePolicy, crossOriginResourcePolicy);

auto crossOriginEmbedderPolicy = m_cacheEntryForValidation->response().httpHeaderField(HTTPHeaderName::CrossOriginEmbedderPolicy);

if (!crossOriginEmbedderPolicy.isEmpty())

m_response.setHTTPHeaderField(HTTPHeaderName::CrossOriginEmbedderPolicy, crossOriginEmbedderPolicy);

m_cacheEntryForValidation = nullptr;

}

} else

m_cacheEntryForValidation = nullptr;

}

if (m_cacheEntryForValidation)

return completionHandler(PolicyAction::Use);

if (networkLoadChecker) {

auto error = networkLoadChecker->validateResponse(m_networkLoad ? m_networkLoad->currentRequest() : originalRequest(), m_response);

if (!error.isNull()) {

LOADER_RELEASE_LOG_ERROR("didReceiveResponse: NetworkLoadChecker::validateResponse returned an error (error.domain=%" PUBLIC_LOG_STRING ", error.code=%d)", error.domain().utf8().data(), error.errorCode());

RunLoop::mainSingleton().dispatch([protectedThis = Ref { *this }, error = WTF::move(error)] {

if (protectedThis->m_networkLoad)

protectedThis->didFailLoading(error);

});

return completionHandler(PolicyAction::Ignore);

}

if (RefPtr networkLoad = m_networkLoad; networkLoad && networkLoadChecker->timingAllowFailedFlag())

networkLoad->setTimingAllowFailedFlag();

}

initializeReportingEndpoints(m_response);

if (isMainResource() && shouldInterruptLoadForCSPFrameAncestorsOrXFrameOptions(m_response)) {

LOADER_RELEASE_LOG_ERROR("didReceiveResponse: Interrupting main resource load due to CSP frame-ancestors or X-Frame-Options");

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

send(Messages::WebResourceLoader::StopLoadingAfterXFrameOptionsOrContentSecurityPolicyDenied { response });

return completionHandler(PolicyAction::Ignore);

}