Source/WebKit/WebProcess/Network/WebResourceLoader.cpp - WebKit - Git at Google

 /*
  * Copyright (C) 2012-2018 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 "WebResourceLoader.h"

 #include "DataReference.h"
 #include "Logging.h"
 #include "NetworkProcessConnection.h"
 #include "NetworkResourceLoaderMessages.h"
 #include "WebCoreArgumentCoders.h"
 #include "WebErrors.h"
 #include "WebFrame.h"
 #include "WebFrameLoaderClient.h"
 #include "WebLoaderStrategy.h"
 #include "WebPage.h"
 #include "WebProcess.h"
 #include "WebURLSchemeHandlerProxy.h"
 #include <WebCore/ApplicationCacheHost.h>
 #include <WebCore/CertificateInfo.h>
 #include <WebCore/DiagnosticLoggingClient.h>
 #include <WebCore/DiagnosticLoggingKeys.h>
 #include <WebCore/DocumentLoader.h>
 #include <WebCore/Frame.h>
 #include <WebCore/FrameLoader.h>
 #include <WebCore/FrameLoaderClient.h>
 #include <WebCore/InspectorInstrumentationWebKit.h>
 #include <WebCore/NetworkLoadMetrics.h>
 #include <WebCore/Page.h>
 #include <WebCore/ResourceError.h>
 #include <WebCore/ResourceLoader.h>
 #include <WebCore/SubresourceLoader.h>
 #include <wtf/CompletionHandler.h>

 #define RELEASE_LOG_IF_ALLOWED(fmt, ...) RELEASE_LOG_IF(isAlwaysOnLoggingAllowed(), Network, "%p - WebResourceLoader::" fmt, this, ##__VA_ARGS__)

 namespace WebKit {
 using namespace WebCore;

 Ref<WebResourceLoader> WebResourceLoader::create(Ref<ResourceLoader>&& coreLoader, const TrackingParameters& trackingParameters)
 {
     return adoptRef(*new WebResourceLoader(WTFMove(coreLoader), trackingParameters));
 }

 WebResourceLoader::WebResourceLoader(Ref<WebCore::ResourceLoader>&& coreLoader, const TrackingParameters& trackingParameters)
     : m_coreLoader(WTFMove(coreLoader))
     , m_trackingParameters(trackingParameters)
 {
 }

 WebResourceLoader::~WebResourceLoader()
 {
 }

 IPC::Connection* WebResourceLoader::messageSenderConnection() const
 {
     return &WebProcess::singleton().ensureNetworkProcessConnection().connection();
 }

 uint64_t WebResourceLoader::messageSenderDestinationID() const
 {
     RELEASE_ASSERT(RunLoop::isMain());
     RELEASE_ASSERT(m_coreLoader->identifier());
     return m_coreLoader->identifier();
 }

 void WebResourceLoader::detachFromCoreLoader()
 {
     RELEASE_ASSERT(RunLoop::isMain());
     m_coreLoader = nullptr;
 }

 void WebResourceLoader::willSendRequest(ResourceRequest&& proposedRequest, ResourceResponse&& redirectResponse)
 {
     Ref<WebResourceLoader> protectedThis(*this);

     LOG(Network, "(WebProcess) WebResourceLoader::willSendRequest to '%s'", proposedRequest.url().string().latin1().data());
     RELEASE_LOG_IF_ALLOWED("willSendRequest: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);

     if (m_coreLoader->documentLoader()->applicationCacheHost().maybeLoadFallbackForRedirect(m_coreLoader.get(), proposedRequest, redirectResponse)) {
         RELEASE_LOG_IF_ALLOWED("willSendRequest: exiting early because maybeLoadFallbackForRedirect returned false (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);
         return;
     }

     m_coreLoader->willSendRequest(WTFMove(proposedRequest), redirectResponse, [this, protectedThis = WTFMove(protectedThis)](ResourceRequest&& request) {
         if (!m_coreLoader || !m_coreLoader->identifier()) {
             RELEASE_LOG_IF_ALLOWED("willSendRequest: exiting early because no coreloader or identifier (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);
             return;
         }

         send(Messages::NetworkResourceLoader::ContinueWillSendRequest(request, m_coreLoader->isAllowedToAskUserForCredentials()));
     });
 }

 void WebResourceLoader::didSendData(uint64_t bytesSent, uint64_t totalBytesToBeSent)
 {
     m_coreLoader->didSendData(bytesSent, totalBytesToBeSent);
 }

 void WebResourceLoader::didReceiveResponse(const ResourceResponse& response, bool needsContinueDidReceiveResponseMessage)
 {
     LOG(Network, "(WebProcess) WebResourceLoader::didReceiveResponse for '%s'. Status %d.", m_coreLoader->url().string().latin1().data(), response.httpStatusCode());
     RELEASE_LOG_IF_ALLOWED("didReceiveResponse: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", status = %d)", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID, response.httpStatusCode());

     Ref<WebResourceLoader> protectedThis(*this);

     if (m_coreLoader->documentLoader()->applicationCacheHost().maybeLoadFallbackForResponse(m_coreLoader.get(), response)) {
         RELEASE_LOG_IF_ALLOWED("didReceiveResponse: not continuing load because the content is already cached (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);
         return;
     }

     CompletionHandler<void()> policyDecisionCompletionHandler;
     if (needsContinueDidReceiveResponseMessage) {
 #if !ASSERT_DISABLED
         m_isProcessingNetworkResponse = true;
 #endif
         policyDecisionCompletionHandler = [this, protectedThis = WTFMove(protectedThis)] {
 #if !ASSERT_DISABLED
             m_isProcessingNetworkResponse = false;
 #endif
             // If m_coreLoader becomes null as a result of the didReceiveResponse callback, we can't use the send function().
             if (m_coreLoader && m_coreLoader->identifier())
                 send(Messages::NetworkResourceLoader::ContinueDidReceiveResponse());
             else
                 RELEASE_LOG_IF_ALLOWED("didReceiveResponse: not continuing load because no coreLoader or no ID (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);
         };
     }

     if (InspectorInstrumentationWebKit::shouldInterceptResponse(m_coreLoader->frame(), response)) {
         unsigned long interceptedRequestIdentifier = m_coreLoader->identifier();
         m_interceptController.beginInterceptingResponse(interceptedRequestIdentifier);
         InspectorInstrumentationWebKit::interceptResponse(m_coreLoader->frame(), response, interceptedRequestIdentifier, [this, protectedThis = makeRef(*this), interceptedRequestIdentifier, policyDecisionCompletionHandler = WTFMove(policyDecisionCompletionHandler)](const ResourceResponse& inspectorResponse, RefPtr<SharedBuffer> overrideData) mutable {
             if (!m_coreLoader || !m_coreLoader->identifier()) {
                 RELEASE_LOG_IF_ALLOWED("didReceiveResponse: not continuing intercept load because no coreLoader or no ID (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);
                 m_interceptController.continueResponse(interceptedRequestIdentifier);
                 return;
             }

             m_coreLoader->didReceiveResponse(inspectorResponse, [this, protectedThis = WTFMove(protectedThis), interceptedRequestIdentifier, policyDecisionCompletionHandler = WTFMove(policyDecisionCompletionHandler), overrideData = WTFMove(overrideData)]() mutable {
                 if (policyDecisionCompletionHandler)
                     policyDecisionCompletionHandler();

                 if (!m_coreLoader || !m_coreLoader->identifier()) {
                     m_interceptController.continueResponse(interceptedRequestIdentifier);
                     return;
                 }

                 RefPtr<WebCore::ResourceLoader> protectedCoreLoader = m_coreLoader;
                 if (!overrideData)
                     m_interceptController.continueResponse(interceptedRequestIdentifier);
                 else {
                     m_interceptController.interceptedResponse(interceptedRequestIdentifier);
                     if (unsigned bufferSize = overrideData->size())
                         protectedCoreLoader->didReceiveBuffer(overrideData.releaseNonNull(), bufferSize, DataPayloadWholeResource);
                     WebCore::NetworkLoadMetrics emptyMetrics;
                     protectedCoreLoader->didFinishLoading(emptyMetrics);
                 }
             });
         });
         return;
     }

     m_coreLoader->didReceiveResponse(response, WTFMove(policyDecisionCompletionHandler));
 }

 void WebResourceLoader::didReceiveData(const IPC::DataReference& data, int64_t encodedDataLength)
 {
     LOG(Network, "(WebProcess) WebResourceLoader::didReceiveData of size %lu for '%s'", data.size(), m_coreLoader->url().string().latin1().data());
     ASSERT_WITH_MESSAGE(!m_isProcessingNetworkResponse, "Network process should not send data until we've validated the response");

     if (UNLIKELY(m_interceptController.isIntercepting(m_coreLoader->identifier()))) {
         auto buffer = WebCore::SharedBuffer::create(data.data(), data.size());
         m_interceptController.defer(m_coreLoader->identifier(), [this, protectedThis = makeRef(*this), buffer = WTFMove(buffer), encodedDataLength]() mutable {
             IPC::DataReference data(reinterpret_cast<const uint8_t*>(buffer->data()), buffer->size());
             if (m_coreLoader)
                 didReceiveData(data, encodedDataLength);
         });
         return;
     }

     if (!m_numBytesReceived) {
         RELEASE_LOG_IF_ALLOWED("didReceiveData: Started receiving data (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);
     }
     m_numBytesReceived += data.size();

     m_coreLoader->didReceiveData(reinterpret_cast<const char*>(data.data()), data.size(), encodedDataLength, DataPayloadBytes);
 }

 void WebResourceLoader::didFinishResourceLoad(const NetworkLoadMetrics& networkLoadMetrics)
 {
     LOG(Network, "(WebProcess) WebResourceLoader::didFinishResourceLoad for '%s'", m_coreLoader->url().string().latin1().data());
     RELEASE_LOG_IF_ALLOWED("didFinishResourceLoad: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", length = %zd)", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID, m_numBytesReceived);

     if (UNLIKELY(m_interceptController.isIntercepting(m_coreLoader->identifier()))) {
         m_interceptController.defer(m_coreLoader->identifier(), [this, protectedThis = makeRef(*this), networkLoadMetrics]() mutable {
             if (m_coreLoader)
                 didFinishResourceLoad(networkLoadMetrics);
         });
         return;
     }

     ASSERT_WITH_MESSAGE(!m_isProcessingNetworkResponse, "Load should not be able to finish before we've validated the response");
     m_coreLoader->didFinishLoading(networkLoadMetrics);
 }

 void WebResourceLoader::didFailServiceWorkerLoad(const ResourceError& error)
 {
     if (auto* document = m_coreLoader->frame() ? m_coreLoader->frame()->document() : nullptr) {
         if (m_coreLoader->options().destination != FetchOptions::Destination::EmptyString || error.isGeneral())
             document->addConsoleMessage(MessageSource::JS, MessageLevel::Error, error.localizedDescription());
         if (m_coreLoader->options().destination != FetchOptions::Destination::EmptyString)
             document->addConsoleMessage(MessageSource::JS, MessageLevel::Error, makeString("Cannot load ", error.failingURL().string(), "."));
     }

     didFailResourceLoad(error);
 }

 void WebResourceLoader::serviceWorkerDidNotHandle()
 {
 #if ENABLE(SERVICE_WORKER)
     RELEASE_LOG_IF_ALLOWED("serviceWorkerDidNotHandle: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);

     if (m_coreLoader->options().serviceWorkersMode != ServiceWorkersMode::Only) {
         auto* webFrameLoaderClient = toWebFrameLoaderClient(m_coreLoader->frameLoader()->client());
         auto* webFrame = webFrameLoaderClient ? webFrameLoaderClient->webFrame() : nullptr;
         auto* webPage = webFrame ? webFrame->page() : nullptr;

         if (auto* handler = webPage->urlSchemeHandlerForScheme(m_coreLoader->request().url().protocol().toStringWithoutCopying())) {
             RELEASE_LOG_IF_ALLOWED("resource loaded by URL scheme handler: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);

             auto loader = m_coreLoader;
             WebProcess::singleton().webLoaderStrategy().remove(m_coreLoader.get());

             handler->startNewTask(*loader);
             return;
         }
     }

     auto error = internalError(m_coreLoader->request().url());
     error.setType(ResourceError::Type::Cancellation);
     m_coreLoader->didFail(error);
 #else
     ASSERT_NOT_REACHED();
 #endif
 }

 void WebResourceLoader::didFailResourceLoad(const ResourceError& error)
 {
     LOG(Network, "(WebProcess) WebResourceLoader::didFailResourceLoad for '%s'", m_coreLoader->url().string().latin1().data());
     RELEASE_LOG_IF_ALLOWED("didFailResourceLoad: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);

     if (UNLIKELY(m_interceptController.isIntercepting(m_coreLoader->identifier()))) {
         m_interceptController.defer(m_coreLoader->identifier(), [this, protectedThis = makeRef(*this), error]() mutable {
             if (m_coreLoader)
                 didFailResourceLoad(error);
         });
         return;
     }

     ASSERT_WITH_MESSAGE(!m_isProcessingNetworkResponse, "Load should not be able to finish before we've validated the response");

     if (m_coreLoader->documentLoader()->applicationCacheHost().maybeLoadFallbackForError(m_coreLoader.get(), error))
         return;
     m_coreLoader->didFail(error);
 }

 void WebResourceLoader::didBlockAuthenticationChallenge()
 {
     LOG(Network, "(WebProcess) WebResourceLoader::didBlockAuthenticationChallenge for '%s'", m_coreLoader->url().string().latin1().data());
     RELEASE_LOG_IF_ALLOWED("didBlockAuthenticationChallenge: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);

     m_coreLoader->didBlockAuthenticationChallenge();
 }

 void WebResourceLoader::stopLoadingAfterXFrameOptionsOrContentSecurityPolicyDenied(const ResourceResponse& response)
 {
     LOG(Network, "(WebProcess) WebResourceLoader::stopLoadingAfterXFrameOptionsOrContentSecurityPolicyDenied for '%s'", m_coreLoader->url().string().latin1().data());
     RELEASE_LOG_IF_ALLOWED("stopLoadingAfterXFrameOptionsOrContentSecurityPolicyDenied: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);

     m_coreLoader->documentLoader()->stopLoadingAfterXFrameOptionsOrContentSecurityPolicyDenied(m_coreLoader->identifier(), response);
 }

 #if ENABLE(SHAREABLE_RESOURCE)
 void WebResourceLoader::didReceiveResource(const ShareableResource::Handle& handle)
 {
     LOG(Network, "(WebProcess) WebResourceLoader::didReceiveResource for '%s'", m_coreLoader->url().string().latin1().data());
     RELEASE_LOG_IF_ALLOWED("didReceiveResource: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);

     RefPtr<SharedBuffer> buffer = handle.tryWrapInSharedBuffer();

     if (!buffer) {
         LOG_ERROR("Unable to create buffer from ShareableResource sent from the network process.");
         RELEASE_LOG_IF_ALLOWED("didReceiveResource: Unable to create SharedBuffer (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);
         if (auto* frame = m_coreLoader->frame()) {
             if (auto* page = frame->page())
                 page->diagnosticLoggingClient().logDiagnosticMessage(WebCore::DiagnosticLoggingKeys::internalErrorKey(), WebCore::DiagnosticLoggingKeys::createSharedBufferFailedKey(), WebCore::ShouldSample::No);
         }
         m_coreLoader->didFail(internalError(m_coreLoader->request().url()));
         return;
     }

     Ref<WebResourceLoader> protect(*this);

     // Only send data to the didReceiveData callback if it exists.
     if (unsigned bufferSize = buffer->size())
         m_coreLoader->didReceiveBuffer(buffer.releaseNonNull(), bufferSize, DataPayloadWholeResource);

     if (!m_coreLoader)
         return;

     NetworkLoadMetrics emptyMetrics;
     m_coreLoader->didFinishLoading(emptyMetrics);
 }
 #endif

 bool WebResourceLoader::isAlwaysOnLoggingAllowed() const
 {
     return resourceLoader() && resourceLoader()->isAlwaysOnLoggingAllowed();
 }

 } // namespace WebKit

 #undef RELEASE_LOG_IF_ALLOWED
	/*
	* Copyright (C) 2012-2018 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 "WebResourceLoader.h"

	#include "DataReference.h"
	#include "Logging.h"
	#include "NetworkProcessConnection.h"
	#include "NetworkResourceLoaderMessages.h"
	#include "WebCoreArgumentCoders.h"
	#include "WebErrors.h"
	#include "WebFrame.h"
	#include "WebFrameLoaderClient.h"
	#include "WebLoaderStrategy.h"
	#include "WebPage.h"
	#include "WebProcess.h"
	#include "WebURLSchemeHandlerProxy.h"
	#include <WebCore/ApplicationCacheHost.h>
	#include <WebCore/CertificateInfo.h>
	#include <WebCore/DiagnosticLoggingClient.h>
	#include <WebCore/DiagnosticLoggingKeys.h>
	#include <WebCore/DocumentLoader.h>
	#include <WebCore/Frame.h>
	#include <WebCore/FrameLoader.h>
	#include <WebCore/FrameLoaderClient.h>
	#include <WebCore/InspectorInstrumentationWebKit.h>
	#include <WebCore/NetworkLoadMetrics.h>
	#include <WebCore/Page.h>
	#include <WebCore/ResourceError.h>
	#include <WebCore/ResourceLoader.h>
	#include <WebCore/SubresourceLoader.h>
	#include <wtf/CompletionHandler.h>

	#define RELEASE_LOG_IF_ALLOWED(fmt, ...) RELEASE_LOG_IF(isAlwaysOnLoggingAllowed(), Network, "%p - WebResourceLoader::" fmt, this, ##__VA_ARGS__)

	namespace WebKit {
	using namespace WebCore;

	Ref<WebResourceLoader> WebResourceLoader::create(Ref<ResourceLoader>&& coreLoader, const TrackingParameters& trackingParameters)
	{
	return adoptRef(*new WebResourceLoader(WTFMove(coreLoader), trackingParameters));
	}

	WebResourceLoader::WebResourceLoader(Ref<WebCore::ResourceLoader>&& coreLoader, const TrackingParameters& trackingParameters)
	: m_coreLoader(WTFMove(coreLoader))
	, m_trackingParameters(trackingParameters)
	{
	}

	WebResourceLoader::~WebResourceLoader()
	{
	}

	IPC::Connection* WebResourceLoader::messageSenderConnection() const
	{
	return &WebProcess::singleton().ensureNetworkProcessConnection().connection();
	}

	uint64_t WebResourceLoader::messageSenderDestinationID() const
	{
	RELEASE_ASSERT(RunLoop::isMain());
	RELEASE_ASSERT(m_coreLoader->identifier());
	return m_coreLoader->identifier();
	}

	void WebResourceLoader::detachFromCoreLoader()
	{
	RELEASE_ASSERT(RunLoop::isMain());
	m_coreLoader = nullptr;
	}

	void WebResourceLoader::willSendRequest(ResourceRequest&& proposedRequest, ResourceResponse&& redirectResponse)
	{
	Ref<WebResourceLoader> protectedThis(*this);

	LOG(Network, "(WebProcess) WebResourceLoader::willSendRequest to '%s'", proposedRequest.url().string().latin1().data());
	RELEASE_LOG_IF_ALLOWED("willSendRequest: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);

	if (m_coreLoader->documentLoader()->applicationCacheHost().maybeLoadFallbackForRedirect(m_coreLoader.get(), proposedRequest, redirectResponse)) {
	RELEASE_LOG_IF_ALLOWED("willSendRequest: exiting early because maybeLoadFallbackForRedirect returned false (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);
	return;
	}

	m_coreLoader->willSendRequest(WTFMove(proposedRequest), redirectResponse, [this, protectedThis = WTFMove(protectedThis)](ResourceRequest&& request) {
	if (!m_coreLoader \|\| !m_coreLoader->identifier()) {
	RELEASE_LOG_IF_ALLOWED("willSendRequest: exiting early because no coreloader or identifier (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);
	return;
	}

	send(Messages::NetworkResourceLoader::ContinueWillSendRequest(request, m_coreLoader->isAllowedToAskUserForCredentials()));
	});
	}

	void WebResourceLoader::didSendData(uint64_t bytesSent, uint64_t totalBytesToBeSent)
	{
	m_coreLoader->didSendData(bytesSent, totalBytesToBeSent);
	}

	void WebResourceLoader::didReceiveResponse(const ResourceResponse& response, bool needsContinueDidReceiveResponseMessage)
	{
	LOG(Network, "(WebProcess) WebResourceLoader::didReceiveResponse for '%s'. Status %d.", m_coreLoader->url().string().latin1().data(), response.httpStatusCode());
	RELEASE_LOG_IF_ALLOWED("didReceiveResponse: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", status = %d)", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID, response.httpStatusCode());

	Ref<WebResourceLoader> protectedThis(*this);

	if (m_coreLoader->documentLoader()->applicationCacheHost().maybeLoadFallbackForResponse(m_coreLoader.get(), response)) {
	RELEASE_LOG_IF_ALLOWED("didReceiveResponse: not continuing load because the content is already cached (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);
	return;
	}

	CompletionHandler<void()> policyDecisionCompletionHandler;
	if (needsContinueDidReceiveResponseMessage) {
	#if !ASSERT_DISABLED
	m_isProcessingNetworkResponse = true;
	#endif
	policyDecisionCompletionHandler = [this, protectedThis = WTFMove(protectedThis)] {
	#if !ASSERT_DISABLED
	m_isProcessingNetworkResponse = false;
	#endif
	// If m_coreLoader becomes null as a result of the didReceiveResponse callback, we can't use the send function().
	if (m_coreLoader && m_coreLoader->identifier())
	send(Messages::NetworkResourceLoader::ContinueDidReceiveResponse());
	else
	RELEASE_LOG_IF_ALLOWED("didReceiveResponse: not continuing load because no coreLoader or no ID (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);
	};
	}

	if (InspectorInstrumentationWebKit::shouldInterceptResponse(m_coreLoader->frame(), response)) {
	unsigned long interceptedRequestIdentifier = m_coreLoader->identifier();
	m_interceptController.beginInterceptingResponse(interceptedRequestIdentifier);
	InspectorInstrumentationWebKit::interceptResponse(m_coreLoader->frame(), response, interceptedRequestIdentifier, [this, protectedThis = makeRef(*this), interceptedRequestIdentifier, policyDecisionCompletionHandler = WTFMove(policyDecisionCompletionHandler)](const ResourceResponse& inspectorResponse, RefPtr<SharedBuffer> overrideData) mutable {
	if (!m_coreLoader \|\| !m_coreLoader->identifier()) {
	RELEASE_LOG_IF_ALLOWED("didReceiveResponse: not continuing intercept load because no coreLoader or no ID (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);
	m_interceptController.continueResponse(interceptedRequestIdentifier);
	return;
	}

	m_coreLoader->didReceiveResponse(inspectorResponse, [this, protectedThis = WTFMove(protectedThis), interceptedRequestIdentifier, policyDecisionCompletionHandler = WTFMove(policyDecisionCompletionHandler), overrideData = WTFMove(overrideData)]() mutable {
	if (policyDecisionCompletionHandler)
	policyDecisionCompletionHandler();

	if (!m_coreLoader \|\| !m_coreLoader->identifier()) {
	m_interceptController.continueResponse(interceptedRequestIdentifier);
	return;
	}

	RefPtr<WebCore::ResourceLoader> protectedCoreLoader = m_coreLoader;
	if (!overrideData)
	m_interceptController.continueResponse(interceptedRequestIdentifier);
	else {
	m_interceptController.interceptedResponse(interceptedRequestIdentifier);
	if (unsigned bufferSize = overrideData->size())
	protectedCoreLoader->didReceiveBuffer(overrideData.releaseNonNull(), bufferSize, DataPayloadWholeResource);
	WebCore::NetworkLoadMetrics emptyMetrics;
	protectedCoreLoader->didFinishLoading(emptyMetrics);
	}
	});
	});
	return;
	}

	m_coreLoader->didReceiveResponse(response, WTFMove(policyDecisionCompletionHandler));
	}

	void WebResourceLoader::didReceiveData(const IPC::DataReference& data, int64_t encodedDataLength)
	{
	LOG(Network, "(WebProcess) WebResourceLoader::didReceiveData of size %lu for '%s'", data.size(), m_coreLoader->url().string().latin1().data());
	ASSERT_WITH_MESSAGE(!m_isProcessingNetworkResponse, "Network process should not send data until we've validated the response");

	if (UNLIKELY(m_interceptController.isIntercepting(m_coreLoader->identifier()))) {
	auto buffer = WebCore::SharedBuffer::create(data.data(), data.size());
	m_interceptController.defer(m_coreLoader->identifier(), [this, protectedThis = makeRef(*this), buffer = WTFMove(buffer), encodedDataLength]() mutable {
	IPC::DataReference data(reinterpret_cast<const uint8_t*>(buffer->data()), buffer->size());
	if (m_coreLoader)
	didReceiveData(data, encodedDataLength);
	});
	return;
	}

	if (!m_numBytesReceived) {
	RELEASE_LOG_IF_ALLOWED("didReceiveData: Started receiving data (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);
	}
	m_numBytesReceived += data.size();

	m_coreLoader->didReceiveData(reinterpret_cast<const char*>(data.data()), data.size(), encodedDataLength, DataPayloadBytes);
	}

	void WebResourceLoader::didFinishResourceLoad(const NetworkLoadMetrics& networkLoadMetrics)
	{
	LOG(Network, "(WebProcess) WebResourceLoader::didFinishResourceLoad for '%s'", m_coreLoader->url().string().latin1().data());
	RELEASE_LOG_IF_ALLOWED("didFinishResourceLoad: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", length = %zd)", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID, m_numBytesReceived);

	if (UNLIKELY(m_interceptController.isIntercepting(m_coreLoader->identifier()))) {
	m_interceptController.defer(m_coreLoader->identifier(), [this, protectedThis = makeRef(*this), networkLoadMetrics]() mutable {
	if (m_coreLoader)
	didFinishResourceLoad(networkLoadMetrics);
	});
	return;
	}

	ASSERT_WITH_MESSAGE(!m_isProcessingNetworkResponse, "Load should not be able to finish before we've validated the response");
	m_coreLoader->didFinishLoading(networkLoadMetrics);
	}

	void WebResourceLoader::didFailServiceWorkerLoad(const ResourceError& error)
	{
	if (auto* document = m_coreLoader->frame() ? m_coreLoader->frame()->document() : nullptr) {
	if (m_coreLoader->options().destination != FetchOptions::Destination::EmptyString \|\| error.isGeneral())
	document->addConsoleMessage(MessageSource::JS, MessageLevel::Error, error.localizedDescription());
	if (m_coreLoader->options().destination != FetchOptions::Destination::EmptyString)
	document->addConsoleMessage(MessageSource::JS, MessageLevel::Error, makeString("Cannot load ", error.failingURL().string(), "."));
	}

	didFailResourceLoad(error);
	}

	void WebResourceLoader::serviceWorkerDidNotHandle()
	{
	#if ENABLE(SERVICE_WORKER)
	RELEASE_LOG_IF_ALLOWED("serviceWorkerDidNotHandle: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);

	if (m_coreLoader->options().serviceWorkersMode != ServiceWorkersMode::Only) {
	auto* webFrameLoaderClient = toWebFrameLoaderClient(m_coreLoader->frameLoader()->client());
	auto* webFrame = webFrameLoaderClient ? webFrameLoaderClient->webFrame() : nullptr;
	auto* webPage = webFrame ? webFrame->page() : nullptr;

	if (auto* handler = webPage->urlSchemeHandlerForScheme(m_coreLoader->request().url().protocol().toStringWithoutCopying())) {
	RELEASE_LOG_IF_ALLOWED("resource loaded by URL scheme handler: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);

	auto loader = m_coreLoader;
	WebProcess::singleton().webLoaderStrategy().remove(m_coreLoader.get());

	handler->startNewTask(*loader);
	return;
	}
	}

	auto error = internalError(m_coreLoader->request().url());
	error.setType(ResourceError::Type::Cancellation);
	m_coreLoader->didFail(error);
	#else
	ASSERT_NOT_REACHED();
	#endif
	}

	void WebResourceLoader::didFailResourceLoad(const ResourceError& error)
	{
	LOG(Network, "(WebProcess) WebResourceLoader::didFailResourceLoad for '%s'", m_coreLoader->url().string().latin1().data());
	RELEASE_LOG_IF_ALLOWED("didFailResourceLoad: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);

	if (UNLIKELY(m_interceptController.isIntercepting(m_coreLoader->identifier()))) {
	m_interceptController.defer(m_coreLoader->identifier(), [this, protectedThis = makeRef(*this), error]() mutable {
	if (m_coreLoader)
	didFailResourceLoad(error);
	});
	return;
	}

	ASSERT_WITH_MESSAGE(!m_isProcessingNetworkResponse, "Load should not be able to finish before we've validated the response");

	if (m_coreLoader->documentLoader()->applicationCacheHost().maybeLoadFallbackForError(m_coreLoader.get(), error))
	return;
	m_coreLoader->didFail(error);
	}

	void WebResourceLoader::didBlockAuthenticationChallenge()
	{
	LOG(Network, "(WebProcess) WebResourceLoader::didBlockAuthenticationChallenge for '%s'", m_coreLoader->url().string().latin1().data());
	RELEASE_LOG_IF_ALLOWED("didBlockAuthenticationChallenge: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);

	m_coreLoader->didBlockAuthenticationChallenge();
	}

	void WebResourceLoader::stopLoadingAfterXFrameOptionsOrContentSecurityPolicyDenied(const ResourceResponse& response)
	{
	LOG(Network, "(WebProcess) WebResourceLoader::stopLoadingAfterXFrameOptionsOrContentSecurityPolicyDenied for '%s'", m_coreLoader->url().string().latin1().data());
	RELEASE_LOG_IF_ALLOWED("stopLoadingAfterXFrameOptionsOrContentSecurityPolicyDenied: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);

	m_coreLoader->documentLoader()->stopLoadingAfterXFrameOptionsOrContentSecurityPolicyDenied(m_coreLoader->identifier(), response);
	}

	#if ENABLE(SHAREABLE_RESOURCE)
	void WebResourceLoader::didReceiveResource(const ShareableResource::Handle& handle)
	{
	LOG(Network, "(WebProcess) WebResourceLoader::didReceiveResource for '%s'", m_coreLoader->url().string().latin1().data());
	RELEASE_LOG_IF_ALLOWED("didReceiveResource: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);

	RefPtr<SharedBuffer> buffer = handle.tryWrapInSharedBuffer();

	if (!buffer) {
	LOG_ERROR("Unable to create buffer from ShareableResource sent from the network process.");
	RELEASE_LOG_IF_ALLOWED("didReceiveResource: Unable to create SharedBuffer (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_trackingParameters.pageID.toUInt64(), m_trackingParameters.frameID.toUInt64(), m_trackingParameters.resourceID);
	if (auto* frame = m_coreLoader->frame()) {
	if (auto* page = frame->page())
	page->diagnosticLoggingClient().logDiagnosticMessage(WebCore::DiagnosticLoggingKeys::internalErrorKey(), WebCore::DiagnosticLoggingKeys::createSharedBufferFailedKey(), WebCore::ShouldSample::No);
	}
	m_coreLoader->didFail(internalError(m_coreLoader->request().url()));
	return;
	}

	Ref<WebResourceLoader> protect(*this);

	// Only send data to the didReceiveData callback if it exists.
	if (unsigned bufferSize = buffer->size())
	m_coreLoader->didReceiveBuffer(buffer.releaseNonNull(), bufferSize, DataPayloadWholeResource);

	if (!m_coreLoader)
	return;

	NetworkLoadMetrics emptyMetrics;
	m_coreLoader->didFinishLoading(emptyMetrics);
	}
	#endif

	bool WebResourceLoader::isAlwaysOnLoggingAllowed() const
	{
	return resourceLoader() && resourceLoader()->isAlwaysOnLoggingAllowed();
	}

	} // namespace WebKit

	#undef RELEASE_LOG_IF_ALLOWED