Introduce ThreadableLoadingContext: make threaded loading code one step away from Document

third_party/WebKit/Source/core/loader/DocumentThreadableLoader.cpp

 /*
  * Copyright (C) 2011, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2013, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 23 matching lines @@
 #include <memory>
 #include "core/dom/Document.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/frame/FrameConsole.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/LocalFrameClient.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/inspector/InspectorTraceEvents.h"
 #include "core/loader/DocumentThreadableLoaderClient.h"
 #include "core/loader/FrameLoader.h"
+#include "core/loader/LoadingContext.h"
 #include "core/loader/ThreadableLoaderClient.h"
 #include "core/loader/private/CrossOriginPreflightResultCache.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "platform/SharedBuffer.h"
 #include "platform/loader/fetch/CrossOriginAccessControl.h"
 #include "platform/loader/fetch/FetchRequest.h"
 #include "platform/loader/fetch/FetchUtils.h"
 #include "platform/loader/fetch/Resource.h"
 #include "platform/loader/fetch/ResourceFetcher.h"
@@ skipping 77 matching lines @@
 // FIXME: currently the number of redirects is counted and limited here and in
 // net/url_request/url_request.cc separately.
 static const int kMaxCORSRedirects = 20;
 
 void DocumentThreadableLoader::loadResourceSynchronously(
     Document& document,
     const ResourceRequest& request,
     ThreadableLoaderClient& client,
     const ThreadableLoaderOptions& options,
     const ResourceLoaderOptions& resourceLoaderOptions) {
-  (new DocumentThreadableLoader(document, &client, LoadSynchronously, options,
+  (new DocumentThreadableLoader(*LoadingContext::create(document), &client,
+                                LoadSynchronously, options,
                                 resourceLoaderOptions))
       ->start(request);
 }
 
 DocumentThreadableLoader* DocumentThreadableLoader::create(

[Nate Chapin, 2017/02/28 20:47:18]

It's a bit confusing that this create() version and loadResourceSynchronusly()
take a Document&, instead of all creators taking a LoadingContext&. Would it be
too much of a pain to change them all?

[kinuko, 2017/03/01 15:08:28]

Agreed, done.

     Document& document,
     ThreadableLoaderClient* client,
     const ThreadableLoaderOptions& options,
     const ResourceLoaderOptions& resourceLoaderOptions) {
-  return new DocumentThreadableLoader(document, client, LoadAsynchronously,
-                                      options, resourceLoaderOptions);
+  return new DocumentThreadableLoader(*LoadingContext::create(document), client,
+                                      LoadAsynchronously, options,
+                                      resourceLoaderOptions);
+}
+
+DocumentThreadableLoader* DocumentThreadableLoader::create(
+    LoadingContext& loadingContext,
+    ThreadableLoaderClient* client,
+    const ThreadableLoaderOptions& options,
+    const ResourceLoaderOptions& resourceLoaderOptions) {
+  return new DocumentThreadableLoader(loadingContext, client,
+                                      LoadAsynchronously, options,
+                                      resourceLoaderOptions);
 }
 
 DocumentThreadableLoader::DocumentThreadableLoader(
-    Document& document,
+    LoadingContext& loadingContext,
     ThreadableLoaderClient* client,
     BlockingBehavior blockingBehavior,
     const ThreadableLoaderOptions& options,
     const ResourceLoaderOptions& resourceLoaderOptions)
     : m_client(client),
-      m_document(&document),
+      m_loadingContext(&loadingContext),
       m_options(options),
       m_resourceLoaderOptions(resourceLoaderOptions),
       m_forceDoNotAllowStoredCredentials(false),
       m_securityOrigin(m_resourceLoaderOptions.securityOrigin),
       m_sameOriginRequest(false),
       m_isUsingDataConsumerHandle(false),
       m_async(blockingBehavior == LoadAsynchronously),
       m_requestContext(WebURLRequest::RequestContextUnspecified),
-      m_timeoutTimer(TaskRunnerHelper::get(TaskType::Networking, &document),
+      m_timeoutTimer(m_loadingContext->getTaskRunner(TaskType::Networking),
                      this,
                      &DocumentThreadableLoader::didTimeout),
       m_requestStartedSeconds(0.0),
       m_corsRedirectLimit(m_options.crossOriginRequestPolicy == UseAccessControl
                               ? kMaxCORSRedirects
                               : 0),
       m_redirectMode(WebURLRequest::FetchRedirectModeFollow),
       m_overrideReferrer(false) {
   DCHECK(client);
 }
 
 void DocumentThreadableLoader::start(const ResourceRequest& request) {
   // Setting an outgoing referer is only supported in the async code path.
   DCHECK(m_async || request.httpReferrer().isEmpty());
 
   m_sameOriginRequest =
       getSecurityOrigin()->canRequestNoSuborigin(request.url());
   m_requestContext = request.requestContext();
   m_redirectMode = request.fetchRedirectMode();
 
   if (!m_sameOriginRequest &&
       m_options.crossOriginRequestPolicy == DenyCrossOriginRequests) {
     InspectorInstrumentation::
-        documentThreadableLoaderFailedToStartLoadingForClient(m_document,
+        documentThreadableLoaderFailedToStartLoadingForClient(document(),
                                                               m_client);
     ThreadableLoaderClient* client = m_client;
     clear();
     client->didFail(ResourceError(errorDomainBlinkInternal, 0,
                                   request.url().getString(),
                                   "Cross origin requests are not supported."));
     return;
   }
 
   m_requestStartedSeconds = monotonicallyIncreasingTime();
 
   // Save any headers on the request here. If this request redirects
   // cross-origin, we cancel the old request create a new one, and copy these
   // headers.
   m_requestHeaders = request.httpHeaderFields();
 
   // DocumentThreadableLoader is used by all javascript initiated fetch, so we
   // use this chance to record non-GET fetch script requests. However, this is
   // based on the following assumptions, so please be careful when adding
   // similar logic:
   // - ThreadableLoader is used as backend for all javascript initiated network
   //   fetches.
   // - Note that ThreadableLoader is also used for non-network fetch such as
   //   FileReaderLoader. However it emulates GET method so signal is not
   //   recorded here.
   // - ThreadableLoader w/ non-GET request is only created from javascript
   //   initiated fetch.
   // - Some non-script initiated fetches such as WorkerScriptLoader also use
   //   ThreadableLoader, but they are guaranteed to use GET method.
-  if (request.httpMethod() != HTTPNames::GET) {
-    if (Page* page = m_document->page())
+  if (request.httpMethod() != HTTPNames::GET && document()) {
+    if (Page* page = document()->page())
       page->chromeClient().didObserveNonGetFetchFromScript();
   }
 
   ResourceRequest newRequest(request);
   if (m_requestContext != WebURLRequest::RequestContextFetch) {
     // When the request context is not "fetch", |crossOriginRequestPolicy|
     // represents the fetch request mode, and |credentialsRequested| represents
     // the fetch credentials mode. So we set those flags here so that we can see
     // the correct request mode and credentials mode in the service worker's
     // fetch event handler.
@@ skipping 24 matching lines @@
           WebURLRequest::FetchCredentialsModeSameOrigin);
     }
   }
 
   // We assume that ServiceWorker is skipped for sync requests and unsupported
   // protocol requests by content/ code.
   if (m_async &&
       request.getServiceWorkerMode() == WebURLRequest::ServiceWorkerMode::All &&
       SchemeRegistry::shouldTreatURLSchemeAsAllowingServiceWorkers(
           request.url().protocol()) &&
-      m_document->fetcher()->isControlledByServiceWorker()) {
+      m_loadingContext->getResourceFetcher()->isControlledByServiceWorker()) {
     if (newRequest.fetchRequestMode() == WebURLRequest::FetchRequestModeCORS ||
         newRequest.fetchRequestMode() ==
             WebURLRequest::FetchRequestModeCORSWithForcedPreflight) {
       m_fallbackRequestForServiceWorker = ResourceRequest(request);
       // m_fallbackRequestForServiceWorker is used when a regular controlling
       // service worker doesn't handle a cross origin request. When this happens
       // we still want to give foreign fetch a chance to handle the request, so
       // only skip the controlling service worker for the fallback request. This
       // is currently safe because of http://crbug.com/604084 the
       // wasFallbackRequiredByServiceWorker flag is never set when foreign fetch
@@ skipping 37 matching lines @@
          request.isExternalRequest());
   DCHECK(m_client);
   DCHECK(!resource());
 
   // Cross-origin requests are only allowed certain registered schemes. We would
   // catch this when checking response headers later, but there is no reason to
   // send a request, preflighted or not, that's guaranteed to be denied.
   if (!SchemeRegistry::shouldTreatURLSchemeAsCORSEnabled(
           request.url().protocol())) {
     InspectorInstrumentation::
-        documentThreadableLoaderFailedToStartLoadingForClient(m_document,
+        documentThreadableLoaderFailedToStartLoadingForClient(document(),
                                                               m_client);
     dispatchDidFailAccessControlCheck(ResourceError(
         errorDomainBlinkInternal, 0, request.url().getString(),
         "Cross origin requests are only supported for protocol schemes: " +
             SchemeRegistry::listOfCORSEnabledURLSchemes() + "."));
     return;
   }
 
   // Non-secure origins may not make "external requests":
   // https://mikewest.github.io/cors-rfc1918/#integration-fetch
-  if (!document().isSecureContext() && request.isExternalRequest()) {
+  if (!m_loadingContext->isSecureContext() && request.isExternalRequest()) {
     dispatchDidFailAccessControlCheck(
         ResourceError(errorDomainBlinkInternal, 0, request.url().getString(),
                       "Requests to internal network resources are not allowed "
                       "from non-secure contexts (see https://goo.gl/Y0ZkNV). "
                       "This is an experimental restriction which is part of "
                       "'https://mikewest.github.io/cors-rfc1918/'."));
     return;
   }
 
   ResourceRequest crossOriginRequest(request);
@@ skipping 29 matching lines @@
     // page when this request gets sent later. We should not send the actual
     // request to the SW. https://crbug.com/604583
     // Similarly we don't want any requests that could involve a CORS preflight
     // to get intercepted by a foreign fetch service worker, even if we have the
     // result of the preflight cached already. https://crbug.com/674370
     crossOriginRequest.setServiceWorkerMode(
         WebURLRequest::ServiceWorkerMode::None);
 
     bool shouldForcePreflight =
         request.isExternalRequest() ||
-        InspectorInstrumentation::shouldForceCORSPreflight(m_document);
+        InspectorInstrumentation::shouldForceCORSPreflight(document());
     bool canSkipPreflight =
         CrossOriginPreflightResultCache::shared().canSkipPreflight(
             getSecurityOrigin()->toString(), crossOriginRequest.url(),
             effectiveAllowCredentials(), crossOriginRequest.httpMethod(),
             crossOriginRequest.httpHeaderFields());
     if (canSkipPreflight && !shouldForcePreflight) {
       prepareCrossOriginRequest(crossOriginRequest);
       loadRequest(crossOriginRequest, crossOriginOptions);
     } else {
       ResourceRequest preflightRequest =
@@ skipping 144 matching lines @@
 
   if (m_corsRedirectLimit <= 0) {
     ThreadableLoaderClient* client = m_client;
     clear();
     client->didFailRedirectCheck();
     return false;
   }
 
   --m_corsRedirectLimit;
 
-  InspectorInstrumentation::didReceiveCORSRedirectResponse(
-      document().frame(), resource->identifier(),
-      document().frame()->loader().documentLoader(), redirectResponse,
-      resource);
+  if (document() && document()->frame()) {
+    InspectorInstrumentation::didReceiveCORSRedirectResponse(
+        document()->frame(), resource->identifier(),
+        document()->frame()->loader().documentLoader(), redirectResponse,
+        resource);
+  }
 
   String accessControlErrorDescription;
 
   CrossOriginAccessControl::RedirectStatus redirectStatus =
       CrossOriginAccessControl::checkRedirectLocation(request.url());
   bool allowRedirect =
       redirectStatus == CrossOriginAccessControl::kRedirectSuccess;
   if (!allowRedirect) {
     StringBuilder builder;
     builder.append("Redirect from '");
@@ skipping 191 matching lines @@
   }
 
   CrossOriginPreflightResultCache::shared().appendEntry(
       getSecurityOrigin()->toString(), m_actualRequest.url(),
       std::move(preflightResult));
 }
 
 void DocumentThreadableLoader::reportResponseReceived(
     unsigned long identifier,
     const ResourceResponse& response) {
-  LocalFrame* frame = document().frame();
-  // We are seeing crashes caused by nullptr (crbug.com/578849). But the frame
-  // must be set here. TODO(horo): Find the root cause of the unset frame.
-  DCHECK(frame);
+  LocalFrame* frame = document() ? document()->frame() : nullptr;
   if (!frame)
     return;
   TRACE_EVENT1(
       "devtools.timeline", "ResourceReceiveResponse", "data",
       InspectorReceiveResponseEvent::data(identifier, frame, response));
   DocumentLoader* loader = frame->loader().documentLoader();
   InspectorInstrumentation::didReceiveResourceResponse(
       frame, identifier, loader, response, resource());
   frame->console().reportResourceResponseReceived(loader, identifier, response);
 }
 
 void DocumentThreadableLoader::handleResponse(
     unsigned long identifier,
     const ResourceResponse& response,
     std::unique_ptr<WebDataConsumerHandle> handle) {
   DCHECK(m_client);
 
   if (!m_actualRequest.isNull()) {
     reportResponseReceived(identifier, response);
     handlePreflightResponse(response);
     return;
   }
 
   if (response.wasFetchedViaServiceWorker()) {
     if (response.wasFetchedViaForeignFetch())
-      UseCounter::count(m_document, UseCounter::ForeignFetchInterception);
+      m_loadingContext->recordUseCount(UseCounter::ForeignFetchInterception);
     if (response.wasFallbackRequiredByServiceWorker()) {
       // At this point we must have m_fallbackRequestForServiceWorker. (For
       // SharedWorker the request won't be CORS or CORS-with-preflight,
       // therefore fallback-to-network is handled in the browser process when
       // the ServiceWorker does not call respondWith().)
       DCHECK(!m_fallbackRequestForServiceWorker.isNull());
       reportResponseReceived(identifier, response);
       loadFallbackRequestForServiceWorker();
       return;
     }
@@ skipping 185 matching lines @@
   if (m_options.timeoutMilliseconds > 0) {
     m_timeoutTimer.startOneShot(m_options.timeoutMilliseconds / 1000.0,
                                 BLINK_FROM_HERE);
   }
 
   FetchRequest newRequest(request, m_options.initiator, resourceLoaderOptions);
   if (m_options.crossOriginRequestPolicy == AllowCrossOriginRequests)
     newRequest.setOriginRestriction(FetchRequest::NoOriginRestriction);
   DCHECK(!resource());
 
+  ResourceFetcher* fetcher = m_loadingContext->getResourceFetcher();
   if (request.requestContext() == WebURLRequest::RequestContextVideo ||
       request.requestContext() == WebURLRequest::RequestContextAudio)
-    setResource(RawResource::fetchMedia(newRequest, document().fetcher()));
+    setResource(RawResource::fetchMedia(newRequest, fetcher));
   else if (request.requestContext() == WebURLRequest::RequestContextManifest)
-    setResource(RawResource::fetchManifest(newRequest, document().fetcher()));
+    setResource(RawResource::fetchManifest(newRequest, fetcher));
   else
-    setResource(RawResource::fetch(newRequest, document().fetcher()));
+    setResource(RawResource::fetch(newRequest, fetcher));
 
   if (!resource()) {
     InspectorInstrumentation::
-        documentThreadableLoaderFailedToStartLoadingForClient(m_document,
+        documentThreadableLoaderFailedToStartLoadingForClient(document(),
                                                               m_client);
     ThreadableLoaderClient* client = m_client;
     clear();
     // setResource() might call notifyFinished() and thus clear()
     // synchronously, and in such cases ThreadableLoaderClient is already
     // notified and |client| is null.
     if (!client)
       return;
     client->didFail(ResourceError(errorDomainBlinkInternal, 0,
                                   request.url().getString(),
                                   "Failed to start loading."));
     return;
   }
 
   if (resource()->isLoading()) {
     unsigned long identifier = resource()->identifier();
     InspectorInstrumentation::documentThreadableLoaderStartedLoadingForClient(
-        m_document, identifier, m_client);
+        document(), identifier, m_client);
   } else {
     InspectorInstrumentation::
-        documentThreadableLoaderFailedToStartLoadingForClient(m_document,
+        documentThreadableLoaderFailedToStartLoadingForClient(document(),
                                                               m_client);
   }
 }
 
 void DocumentThreadableLoader::loadRequestSync(
     const ResourceRequest& request,
     ResourceLoaderOptions resourceLoaderOptions) {
   FetchRequest fetchRequest(request, m_options.initiator,
                             resourceLoaderOptions);
   if (m_options.crossOriginRequestPolicy == AllowCrossOriginRequests)
     fetchRequest.setOriginRestriction(FetchRequest::NoOriginRestriction);
-  Resource* resource =
-      RawResource::fetchSynchronously(fetchRequest, document().fetcher());
+  Resource* resource = RawResource::fetchSynchronously(
+      fetchRequest, m_loadingContext->getResourceFetcher());
   ResourceResponse response =
       resource ? resource->response() : ResourceResponse();
   unsigned long identifier = resource
                                  ? resource->identifier()
                                  : std::numeric_limits<unsigned long>::max();
   ResourceError error = resource ? resource->resourceError() : ResourceError();
 
   InspectorInstrumentation::documentThreadableLoaderStartedLoadingForClient(
-      m_document, identifier, m_client);
+      document(), identifier, m_client);
   ThreadableLoaderClient* client = m_client;
 
   if (!resource) {
     m_client = nullptr;
     client->didFail(error);
     return;
   }
 
   const KURL& requestURL = request.url();
 
@@ skipping 65 matching lines @@
 }
 
 StoredCredentials DocumentThreadableLoader::effectiveAllowCredentials() const {
   if (m_forceDoNotAllowStoredCredentials)
     return DoNotAllowStoredCredentials;
   return m_resourceLoaderOptions.allowCredentials;
 }
 
 const SecurityOrigin* DocumentThreadableLoader::getSecurityOrigin() const {
   return m_securityOrigin ? m_securityOrigin.get()
-                          : document().getSecurityOrigin();
+                          : m_loadingContext->getSecurityOrigin();
 }
 
-Document& DocumentThreadableLoader::document() const {
-  DCHECK(m_document);
-  return *m_document;
+Document* DocumentThreadableLoader::document() const {
+  DCHECK(m_loadingContext);
+  return m_loadingContext->getLoadingDocument();
 }
 
 DEFINE_TRACE(DocumentThreadableLoader) {
   visitor->trace(m_resource);
-  visitor->trace(m_document);
+  visitor->trace(m_loadingContext);
   ThreadableLoader::trace(visitor);
   RawResourceClient::trace(visitor);
 }
 
 }  // namespace blink