Make PrefetchURLLoaderFactory per-frame and pass frame_tree_node_id

So that we can set up necessary throttles and resource/request contexts
when Prefetch needs to create additional requests, e.g. for fetching
certificate for Signed HTTP Exchanges.

(The usage example of the throttles, resource_context and request_context_getter
would look like: https://chromium-review.googlesource.com/c/chromium/src/+/920565)

Bug: 803776
Change-Id: I71b1e7e8bb1178ecae89b4d9e37b60df658eba32
Reviewed-on: https://chromium-review.googlesource.com/923467Reviewed-by: Tsuyoshi Horo <horo@chromium.org>
Commit-Queue: Kinuko Yasuda <kinuko@chromium.org>
Cr-Commit-Position: refs/heads/master@{#537738}

content/browser/BUILD.gn

@@ -1004,8 +1004,8 @@ jumbo_source_set("browser") {
     "loader/null_resource_controller.h",
     "loader/prefetch_url_loader.cc",
     "loader/prefetch_url_loader.h",
-    "loader/prefetch_url_loader_factory.cc",
-    "loader/prefetch_url_loader_factory.h",
+    "loader/prefetch_url_loader_service.cc",
+    "loader/prefetch_url_loader_service.h",
     "loader/redirect_to_file_resource_handler.cc",
     "loader/redirect_to_file_resource_handler.h",
     "loader/resource_buffer.cc",

content/browser/frame_host/render_frame_host_impl.cc

@@ -51,7 +51,7 @@
 #include "content/browser/installedapp/installed_app_provider_impl_default.h"
 #include "content/browser/interface_provider_filtering.h"
 #include "content/browser/keyboard_lock/keyboard_lock_service_impl.h"
-#include "content/browser/loader/prefetch_url_loader_factory.h"
+#include "content/browser/loader/prefetch_url_loader_service.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/loader/resource_scheduler_filter.h"
 #include "content/browser/media/capture/audio_mirroring_manager.h"
@@ -3237,9 +3237,17 @@ void RenderFrameHostImpl::RegisterMojoInterfaces() {
     StoragePartitionImpl* storage_partition =
         static_cast<StoragePartitionImpl*>(BrowserContext::GetStoragePartition(
             GetSiteInstance()->GetBrowserContext(), GetSiteInstance()));
-    registry_->AddInterface(base::BindRepeating(
-        &PrefetchURLLoaderFactory::ConnectToService,
-        base::RetainedRef(storage_partition->GetPrefetchURLLoaderFactory())));
+    // TODO(https://crbug.com/813479): Investigate why we need to explicitly
+    // specify task runner for BrowserThread::IO here.
+    // Bind calls to the BindRegistry should come on to the IO thread by
+    // default, but it looks we need this in browser tests (but not in full
+    // chrome build), i.e. in content/browser/loader/prefetch_browsertest.cc.
+    registry_->AddInterface(
+        base::BindRepeating(
+            &PrefetchURLLoaderService::ConnectToService,
+            base::RetainedRef(storage_partition->GetPrefetchURLLoaderService()),
+            frame_tree_node_->frame_tree_node_id()),
+        BrowserThread::GetTaskRunnerForThread(BrowserThread::IO));
   }
 }
 

content/browser/loader/prefetch_browsertest.cc

@@ -11,7 +11,7 @@
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/scoped_feature_list.h"
-#include "content/browser/loader/prefetch_url_loader_factory.h"
+#include "content/browser/loader/prefetch_url_loader_service.h"
 #include "content/browser/storage_partition_impl.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_features.h"
@@ -72,8 +72,8 @@ class PrefetchBrowserTest
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         BindOnce(
-            &PrefetchURLLoaderFactory::RegisterPrefetchLoaderCallbackForTest,
-            base::RetainedRef(partition->GetPrefetchURLLoaderFactory()),
+            &PrefetchURLLoaderService::RegisterPrefetchLoaderCallbackForTest,
+            base::RetainedRef(partition->GetPrefetchURLLoaderService()),
             base::BindRepeating(&PrefetchBrowserTest::OnPrefetchURLLoaderCalled,
                                 base::Unretained(this))));
   }

content/browser/loader/prefetch_url_loader.cc

@@ -4,6 +4,8 @@
 
 #include "content/browser/loader/prefetch_url_loader.h"
 
+#include "net/url_request/url_request_context_getter.h"
+
 namespace content {
 
 PrefetchURLLoader::PrefetchURLLoader(
@@ -13,10 +15,22 @@ PrefetchURLLoader::PrefetchURLLoader(
     const network::ResourceRequest& resource_request,
     network::mojom::URLLoaderClientPtr client,
     const net::MutableNetworkTrafficAnnotationTag& traffic_annotation,
-    network::mojom::URLLoaderFactory* network_loader_factory)
-    : network_client_binding_(this), forwarding_client_(std::move(client)) {
+    network::mojom::URLLoaderFactory* network_loader_factory,
+    URLLoaderThrottlesGetter url_loader_throttles_getter,
+    ResourceContext* resource_context,
+    scoped_refptr<net::URLRequestContextGetter> request_context_getter)
+    : network_client_binding_(this),
+      forwarding_client_(std::move(client)),
+      url_loader_throttles_getter_(url_loader_throttles_getter),
+      resource_context_(resource_context),
+      request_context_getter_(std::move(request_context_getter)) {
   DCHECK(network_loader_factory);
 
+  // TODO(kinuko): Hook up the Web Package code that uses these fields.
+  // (https://crbug.com/803776)
+  DCHECK(resource_context_);
+  DCHECK(request_context_getter_);
+
   network::mojom::URLLoaderClientPtr network_client;
   network_client_binding_.Bind(mojo::MakeRequest(&network_client));
   network_client_binding_.set_connection_error_handler(base::BindOnce(

content/browser/loader/prefetch_url_loader.h

@@ -15,14 +15,28 @@
 #include "services/network/public/mojom/url_loader_factory.mojom.h"
 #include "url/gurl.h"
 
+namespace net {
+class URLRequestContextGetter;
+}
+
 namespace content {
 
+class ResourceContext;
+class URLLoaderThrottle;
+
 // PrefetchURLLoader which basically just keeps draining the data.
 class CONTENT_EXPORT PrefetchURLLoader
     : public network::mojom::URLLoader,
       public network::mojom::URLLoaderClient,
       public mojo::common::DataPipeDrainer::Client {
  public:
+  using URLLoaderThrottlesGetter = base::RepeatingCallback<
+      std::vector<std::unique_ptr<content::URLLoaderThrottle>>()>;
+
+  // |url_loader_throttles_getter|, |resource_context| and
+  // |request_context_getter| may be used when a prefetch handler
+  // needs to additionally create a request (e.g. for fetching certificate
+  // if the prefetch was for a signed exchange).
   PrefetchURLLoader(
       int32_t routing_id,
       int32_t request_id,
@@ -30,7 +44,10 @@ class CONTENT_EXPORT PrefetchURLLoader
       const network::ResourceRequest& resource_request,
       network::mojom::URLLoaderClientPtr client,
       const net::MutableNetworkTrafficAnnotationTag& traffic_annotation,
-      network::mojom::URLLoaderFactory* network_loader_factory);
+      network::mojom::URLLoaderFactory* network_loader_factory,
+      URLLoaderThrottlesGetter url_loader_throttles_getter,
+      ResourceContext* resource_context,
+      scoped_refptr<net::URLRequestContextGetter> request_context_getter);
   ~PrefetchURLLoader() override;
 
  private:
@@ -73,6 +90,12 @@ class CONTENT_EXPORT PrefetchURLLoader
   // To be a URLLoader for the client.
   network::mojom::URLLoaderClientPtr forwarding_client_;
 
+  // |url_loader_throttles_getter_| and |resource_context_| should be
+  // valid as far as |request_context_getter_| returns non-null value.
+  URLLoaderThrottlesGetter url_loader_throttles_getter_;
+  ResourceContext* resource_context_;
+  scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
+
   std::unique_ptr<mojo::common::DataPipeDrainer> pipe_drainer_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefetchURLLoader);

content/browser/loader/prefetch_url_loader_factory.cc

-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "content/browser/loader/prefetch_url_loader_factory.h"
-
-#include "base/feature_list.h"
-#include "content/browser/loader/prefetch_url_loader.h"
-#include "content/browser/url_loader_factory_getter.h"
-#include "content/common/wrapper_shared_url_loader_factory.h"
-#include "content/public/common/resource_type.h"
-#include "content/public/common/shared_url_loader_factory.h"
-#include "mojo/public/cpp/bindings/strong_binding.h"
-#include "services/network/public/cpp/features.h"
-
-namespace content {
-
-PrefetchURLLoaderFactory::PrefetchURLLoaderFactory(
-    scoped_refptr<URLLoaderFactoryGetter> factory_getter)
-    : loader_factory_getter_(std::move(factory_getter)) {}
-
-void PrefetchURLLoaderFactory::ConnectToService(
-    blink::mojom::PrefetchURLLoaderServiceRequest request) {
-  if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
-    // TODO(https://crbug.com/813479): Investigate why we need this branch
-    // and remove it after we found the root cause. Bind calls to the
-    // BindRegistry should come on to the IO thread, but it looks we hit
-    // here in browser tests (but not in full chrome build), i.e.
-    // in content/browser/loader/prefetch_browsertest.cc.
-    BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE,
-        base::BindOnce(&PrefetchURLLoaderFactory::ConnectToService, this,
-                       std::move(request)));
-    return;
-  }
-  service_bindings_.AddBinding(this, std::move(request));
-}
-
-void PrefetchURLLoaderFactory::GetFactory(
-    network::mojom::URLLoaderFactoryRequest request) {
-  Clone(std::move(request));
-}
-
-void PrefetchURLLoaderFactory::CreateLoaderAndStart(
-    network::mojom::URLLoaderRequest request,
-    int32_t routing_id,
-    int32_t request_id,
-    uint32_t options,
-    const network::ResourceRequest& resource_request,
-    network::mojom::URLLoaderClientPtr client,
-    const net::MutableNetworkTrafficAnnotationTag& traffic_annotation,
-    network::mojom::URLLoaderFactory* network_loader_factory) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK_EQ(RESOURCE_TYPE_PREFETCH, resource_request.resource_type);
-
-  if (prefetch_load_callback_for_testing_)
-    prefetch_load_callback_for_testing_.Run();
-
-  // For now we strongly bind the loader to the request, while we can
-  // also possibly make the new loader owned by the factory so that
-  // they can live longer than the client (i.e. run in detached mode).
-  // TODO(kinuko): Revisit this.
-  mojo::MakeStrongBinding(
-      std::make_unique<PrefetchURLLoader>(
-          routing_id, request_id, options, resource_request, std::move(client),
-          traffic_annotation, network_loader_factory),
-      std::move(request));
-}
-
-PrefetchURLLoaderFactory::~PrefetchURLLoaderFactory() = default;
-
-void PrefetchURLLoaderFactory::CreateLoaderAndStart(
-    network::mojom::URLLoaderRequest request,
-    int32_t routing_id,
-    int32_t request_id,
-    uint32_t options,
-    const network::ResourceRequest& resource_request,
-    network::mojom::URLLoaderClientPtr client,
-    const net::MutableNetworkTrafficAnnotationTag& traffic_annotation) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(base::FeatureList::IsEnabled(network::features::kNetworkService));
-  if (!network_loader_factory_ || network_loader_factory_.encountered_error()) {
-    loader_factory_getter_->GetNetworkFactory()->Clone(
-        mojo::MakeRequest(&network_loader_factory_));
-  }
-  CreateLoaderAndStart(std::move(request), routing_id, request_id, options,
-                       resource_request, std::move(client), traffic_annotation,
-                       network_loader_factory_.get());
-}
-
-void PrefetchURLLoaderFactory::Clone(
-    network::mojom::URLLoaderFactoryRequest request) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  bindings_.AddBinding(this, std::move(request));
-}
-
-}  // namespace content

content/browser/loader/prefetch_url_loader_service.cc

+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "content/browser/loader/prefetch_url_loader_service.h"
+
+#include "base/feature_list.h"
+#include "content/browser/loader/prefetch_url_loader.h"
+#include "content/browser/url_loader_factory_getter.h"
+#include "content/common/wrapper_shared_url_loader_factory.h"
+#include "content/public/browser/content_browser_client.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/common/content_client.h"
+#include "content/public/common/resource_type.h"
+#include "content/public/common/shared_url_loader_factory.h"
+#include "content/public/common/url_loader_throttle.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
+#include "net/url_request/url_request_context_getter.h"
+#include "services/network/public/cpp/features.h"
+#include "services/network/public/mojom/url_loader_factory.mojom.h"
+
+namespace content {
+
+namespace {
+
+// Per-frame URLLoaderFactory. Used only when Network Service is enabled.
+class PrefetchURLLoaderFactory : public network::mojom::URLLoaderFactory,
+                                 public blink::mojom::PrefetchURLLoaderService {
+ public:
+  PrefetchURLLoaderFactory(
+      content::PrefetchURLLoaderService* service,
+      scoped_refptr<URLLoaderFactoryGetter> loader_factory_getter,
+      int frame_tree_node_id)
+      : service_(std::move(service)),
+        loader_factory_getter_(std::move(loader_factory_getter)),
+        frame_tree_node_id_(frame_tree_node_id) {}
+  ~PrefetchURLLoaderFactory() override = default;
+
+  // blink::mojom::PrefetchURLLoaderService:
+  void GetFactory(network::mojom::URLLoaderFactoryRequest request) override {
+    Clone(std::move(request));
+  }
+
+ private:
+  // network::mojom::URLLoaderFactory:
+  void CreateLoaderAndStart(network::mojom::URLLoaderRequest request,
+                            int32_t routing_id,
+                            int32_t request_id,
+                            uint32_t options,
+                            const network::ResourceRequest& resource_request,
+                            network::mojom::URLLoaderClientPtr client,
+                            const net::MutableNetworkTrafficAnnotationTag&
+                                traffic_annotation) override {
+    DCHECK_CURRENTLY_ON(BrowserThread::IO);
+    DCHECK(base::FeatureList::IsEnabled(network::features::kNetworkService));
+    if (!network_loader_factory_ ||
+        network_loader_factory_.encountered_error()) {
+      loader_factory_getter_->GetNetworkFactory()->Clone(
+          mojo::MakeRequest(&network_loader_factory_));
+    }
+    service_->CreateLoaderAndStart(
+        std::move(request), routing_id, request_id, options, resource_request,
+        std::move(client), traffic_annotation, network_loader_factory_.get(),
+        frame_tree_node_id_);
+  }
+
+  void Clone(network::mojom::URLLoaderFactoryRequest request) override {
+    DCHECK_CURRENTLY_ON(BrowserThread::IO);
+    bindings_.AddBinding(this, std::move(request));
+  }
+
+  scoped_refptr<content::PrefetchURLLoaderService> service_;
+
+  network::mojom::URLLoaderFactoryPtr network_loader_factory_;
+  scoped_refptr<URLLoaderFactoryGetter> loader_factory_getter_;
+  int frame_tree_node_id_;
+
+  mojo::BindingSet<network::mojom::URLLoaderFactory> bindings_;
+
+  DISALLOW_COPY_AND_ASSIGN(PrefetchURLLoaderFactory);
+};
+
+}  // namespace
+
+PrefetchURLLoaderService::PrefetchURLLoaderService(
+    scoped_refptr<URLLoaderFactoryGetter> factory_getter)
+    : loader_factory_getter_(std::move(factory_getter)) {}
+
+void PrefetchURLLoaderService::InitializeResourceContext(
+    ResourceContext* resource_context,
+    scoped_refptr<net::URLRequestContextGetter> request_context_getter) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(!resource_context_);
+  DCHECK(!request_context_getter_);
+  resource_context_ = resource_context;
+  request_context_getter_ = request_context_getter;
+}
+
+void PrefetchURLLoaderService::ConnectToService(
+    int frame_tree_node_id,
+    blink::mojom::PrefetchURLLoaderServiceRequest request) {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::BindOnce(&PrefetchURLLoaderService::ConnectToService, this,
+                       frame_tree_node_id, std::move(request)));
+    return;
+  }
+  service_bindings_.AddBinding(
+      std::make_unique<PrefetchURLLoaderFactory>(this, loader_factory_getter_,
+                                                 frame_tree_node_id),
+      std::move(request));
+}
+
+void PrefetchURLLoaderService::CreateLoaderAndStart(
+    network::mojom::URLLoaderRequest request,
+    int32_t routing_id,
+    int32_t request_id,
+    uint32_t options,
+    const network::ResourceRequest& resource_request,
+    network::mojom::URLLoaderClientPtr client,
+    const net::MutableNetworkTrafficAnnotationTag& traffic_annotation,
+    network::mojom::URLLoaderFactory* network_loader_factory,
+    int frame_tree_node_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK_EQ(RESOURCE_TYPE_PREFETCH, resource_request.resource_type);
+  DCHECK(resource_context_);
+
+  if (prefetch_load_callback_for_testing_)
+    prefetch_load_callback_for_testing_.Run();
+
+  // For now we strongly bind the loader to the request, while we can
+  // also possibly make the new loader owned by the factory so that
+  // they can live longer than the client (i.e. run in detached mode).
+  // TODO(kinuko): Revisit this.
+  mojo::MakeStrongBinding(
+      std::make_unique<PrefetchURLLoader>(
+          routing_id, request_id, options, resource_request, std::move(client),
+          traffic_annotation, network_loader_factory,
+          base::BindRepeating(
+              &PrefetchURLLoaderService::CreateURLLoaderThrottles, this,
+              resource_request, frame_tree_node_id),
+          resource_context_, request_context_getter_),
+      std::move(request));
+}
+
+PrefetchURLLoaderService::~PrefetchURLLoaderService() = default;
+
+std::vector<std::unique_ptr<content::URLLoaderThrottle>>
+PrefetchURLLoaderService::CreateURLLoaderThrottles(
+    const network::ResourceRequest& request,
+    int frame_tree_node_id) {
+  if (!base::FeatureList::IsEnabled(network::features::kNetworkService) ||
+      !request_context_getter_ ||
+      !request_context_getter_->GetURLRequestContext())
+    return std::vector<std::unique_ptr<content::URLLoaderThrottle>>();
+
+  return GetContentClient()->browser()->CreateURLLoaderThrottles(
+      request, resource_context_,
+      base::BindRepeating(&WebContents::FromFrameTreeNodeId,
+                          frame_tree_node_id),
+      nullptr /* navigation_ui_data */, frame_tree_node_id);
+}
+
+}  // namespace content

content/browser/loader/prefetch_url_loader_factory.h → content/browser/loader/prefetch_url_loader_service.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_BROWSER_LOADER_PREFETCH_URL_LOADER_FACTORY_H_
-#define CONTENT_BROWSER_LOADER_PREFETCH_URL_LOADER_FACTORY_H_
+#ifndef CONTENT_BROWSER_LOADER_PREFETCH_URL_LOADER_SERVICE_H_
+#define CONTENT_BROWSER_LOADER_PREFETCH_URL_LOADER_SERVICE_H_
 
 #include "base/callback.h"
 #include "base/macros.h"
@@ -11,32 +11,42 @@
 #include "content/common/content_export.h"
 #include "content/public/browser/browser_thread.h"
 #include "mojo/public/cpp/bindings/strong_binding_set.h"
-#include "services/network/public/mojom/url_loader_factory.mojom.h"
 #include "third_party/WebKit/common/loader/prefetch_url_loader_service.mojom.h"
 
+namespace net {
+class URLRequestContextGetter;
+}
+
 namespace content {
 
+class ResourceContext;
 class URLLoaderFactoryGetter;
+class URLLoaderThrottle;
 
-class CONTENT_EXPORT PrefetchURLLoaderFactory final
-    : public base::RefCountedThreadSafe<PrefetchURLLoaderFactory,
-                                        BrowserThread::DeleteOnIOThread>,
-      public network::mojom::URLLoaderFactory,
-      public blink::mojom::PrefetchURLLoaderService {
+class CONTENT_EXPORT PrefetchURLLoaderService final
+    : public base::RefCountedThreadSafe<PrefetchURLLoaderService,
+                                        BrowserThread::DeleteOnIOThread> {
  public:
   // |factory_getter| could be null in non-NetworkService case.
-  explicit PrefetchURLLoaderFactory(
+  // Created on the UI thread.
+  PrefetchURLLoaderService(
       scoped_refptr<URLLoaderFactoryGetter> network_loader_factory);
 
-  void ConnectToService(blink::mojom::PrefetchURLLoaderServiceRequest request);
+  // Must be called on the IO thread. The given |resource_context| will
+  // be valid as far as request_context_getter returns non-null context.
+  void InitializeResourceContext(
+      ResourceContext* resource_context,
+      scoped_refptr<net::URLRequestContextGetter> request_context_getter);
 
-  // blink::mojom::PrefetchURLLoaderService:
-  void GetFactory(network::mojom::URLLoaderFactoryRequest request) override;
+  void ConnectToService(int frame_tree_node_id,
+                        blink::mojom::PrefetchURLLoaderServiceRequest request);
 
   // Used only when NetworkService is not enabled (or indirectly via the
   // other CreateLoaderAndStart when NetworkService is enabled).
   // This creates a loader and starts fetching using the given
-  // |network_lader_factory|.
+  // |network_lader_factory|. |frame_tree_node_id| may be given and used to
+  // create necessary throttles when Network Service is enabled when the
+  // created loader internally makes additional requests.
   void CreateLoaderAndStart(
       network::mojom::URLLoaderRequest request,
       int32_t routing_id,
@@ -45,42 +55,38 @@ class CONTENT_EXPORT PrefetchURLLoaderFactory final
       const network::ResourceRequest& resource_request,
       network::mojom::URLLoaderClientPtr client,
       const net::MutableNetworkTrafficAnnotationTag& traffic_annotation,
-      network::mojom::URLLoaderFactory* factory);
+      network::mojom::URLLoaderFactory* factory,
+      int frame_tree_node_id = -1);
 
   // Register a callback that is fired right before a prefetch load is started
-  // by this factory.
+  // by this service.
   void RegisterPrefetchLoaderCallbackForTest(
       const base::RepeatingClosure& prefetch_load_callback) {
     prefetch_load_callback_for_testing_ = prefetch_load_callback;
   }
 
  private:
-  friend class base::DeleteHelper<content::PrefetchURLLoaderFactory>;
+  friend class base::DeleteHelper<content::PrefetchURLLoaderService>;
   friend struct BrowserThread::DeleteOnThread<BrowserThread::IO>;
-  ~PrefetchURLLoaderFactory() override;
-
-  // network::mojom::URLLoaderFactory:
-  void CreateLoaderAndStart(network::mojom::URLLoaderRequest request,
-                            int32_t routing_id,
-                            int32_t request_id,
-                            uint32_t options,
-                            const network::ResourceRequest& resource_request,
-                            network::mojom::URLLoaderClientPtr client,
-                            const net::MutableNetworkTrafficAnnotationTag&
-                                traffic_annotation) override;
-  void Clone(network::mojom::URLLoaderFactoryRequest request) override;
-
-  mojo::BindingSet<network::mojom::URLLoaderFactory> bindings_;
-  mojo::BindingSet<blink::mojom::PrefetchURLLoaderService> service_bindings_;
+  ~PrefetchURLLoaderService();
+
+  // For URLLoaderThrottlesGetter.
+  std::vector<std::unique_ptr<content::URLLoaderThrottle>>
+  CreateURLLoaderThrottles(const network::ResourceRequest& request,
+                           int frame_tree_node_id);
+
+  mojo::StrongBindingSet<blink::mojom::PrefetchURLLoaderService>
+      service_bindings_;
 
   scoped_refptr<URLLoaderFactoryGetter> loader_factory_getter_;
-  network::mojom::URLLoaderFactoryPtr network_loader_factory_;
+  ResourceContext* resource_context_ = nullptr;
+  scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
 
   base::RepeatingClosure prefetch_load_callback_for_testing_;
 
-  DISALLOW_COPY_AND_ASSIGN(PrefetchURLLoaderFactory);
+  DISALLOW_COPY_AND_ASSIGN(PrefetchURLLoaderService);
 };
 
 }  // namespace content
 
-#endif  // CONTENT_BROWSER_LOADER_PREFETCH_URL_LOADER_FACTORY_H_
+#endif  // CONTENT_BROWSER_LOADER_PREFETCH_URL_LOADER_SERVICE_H_

content/browser/loader/resource_message_filter.cc

@@ -8,7 +8,7 @@
 #include "base/logging.h"
 #include "content/browser/appcache/chrome_appcache_service.h"
 #include "content/browser/blob_storage/chrome_blob_storage_context.h"
-#include "content/browser/loader/prefetch_url_loader_factory.h"
+#include "content/browser/loader/prefetch_url_loader_service.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/loader/resource_requester_info.h"
 #include "content/browser/loader/url_loader_factory_impl.h"
@@ -34,7 +34,7 @@ ResourceMessageFilter::ResourceMessageFilter(
     ChromeBlobStorageContext* blob_storage_context,
     storage::FileSystemContext* file_system_context,
     ServiceWorkerContextWrapper* service_worker_context,
-    PrefetchURLLoaderFactory* prefetch_url_loader_factory,
+    PrefetchURLLoaderService* prefetch_url_loader_service,
     const GetContextsCallback& get_contexts_callback,
     const scoped_refptr<base::SingleThreadTaskRunner>& io_thread_runner)
     : BrowserMessageFilter(ResourceMsgStart),
@@ -47,7 +47,7 @@ ResourceMessageFilter::ResourceMessageFilter(
                                                    file_system_context,
                                                    service_worker_context,
                                                    get_contexts_callback)),
-      prefetch_url_loader_factory_(prefetch_url_loader_factory),
+      prefetch_url_loader_service_(prefetch_url_loader_service),
       io_thread_task_runner_(io_thread_runner),
       weak_ptr_factory_(this) {}
 
@@ -65,7 +65,7 @@ void ResourceMessageFilter::OnFilterAdded(IPC::Channel*) {
 void ResourceMessageFilter::OnChannelClosing() {
   DCHECK(io_thread_task_runner_->BelongsToCurrentThread());
 
-  prefetch_url_loader_factory_ = nullptr;
+  prefetch_url_loader_service_ = nullptr;
   url_loader_factory_ = nullptr;
 
   // Unhook us from all pending network requests so they don't get sent to a
@@ -118,8 +118,8 @@ void ResourceMessageFilter::CreateLoaderAndStart(
   // doesn't need to be paired up with SignedExchange feature.
   if (base::FeatureList::IsEnabled(features::kSignedHTTPExchange) &&
       url_request.resource_type == RESOURCE_TYPE_PREFETCH &&
-      prefetch_url_loader_factory_) {
-    prefetch_url_loader_factory_->CreateLoaderAndStart(
+      prefetch_url_loader_service_) {
+    prefetch_url_loader_service_->CreateLoaderAndStart(
         std::move(request), routing_id, request_id, options, url_request,
         std::move(client), traffic_annotation, url_loader_factory_.get());
     return;

content/browser/loader/resource_message_filter.h

@@ -32,7 +32,7 @@ class URLRequestContext;
 namespace content {
 class ChromeAppCacheService;
 class ChromeBlobStorageContext;
-class PrefetchURLLoaderFactory;
+class PrefetchURLLoaderService;
 class ResourceContext;
 class ResourceRequesterInfo;
 class ServiceWorkerContextWrapper;
@@ -61,7 +61,7 @@ class CONTENT_EXPORT ResourceMessageFilter
       ChromeBlobStorageContext* blob_storage_context,
       storage::FileSystemContext* file_system_context,
       ServiceWorkerContextWrapper* service_worker_context,
-      PrefetchURLLoaderFactory* prefetch_url_loader_factory,
+      PrefetchURLLoaderService* prefetch_url_loader_service,
       const GetContextsCallback& get_contexts_callback,
       const scoped_refptr<base::SingleThreadTaskRunner>& io_thread_runner);
 
@@ -117,7 +117,7 @@ class CONTENT_EXPORT ResourceMessageFilter
 
   std::unique_ptr<network::mojom::URLLoaderFactory> url_loader_factory_;
 
-  scoped_refptr<PrefetchURLLoaderFactory> prefetch_url_loader_factory_;
+  scoped_refptr<PrefetchURLLoaderService> prefetch_url_loader_service_;
 
   // Task runner for the IO thead.
   scoped_refptr<base::SingleThreadTaskRunner> io_thread_task_runner_;

content/browser/renderer_host/render_process_host_impl.cc

@@ -1724,7 +1724,7 @@ void RenderProcessHostImpl::CreateMessageFilters() {
       blob_storage_context.get(),
       storage_partition_impl_->GetFileSystemContext(),
       storage_partition_impl_->GetServiceWorkerContext(),
-      storage_partition_impl_->GetPrefetchURLLoaderFactory(),
+      storage_partition_impl_->GetPrefetchURLLoaderService(),
       get_contexts_callback,
       BrowserThread::GetTaskRunnerForThread(BrowserThread::IO));
 

content/browser/storage_partition_impl.cc

@@ -25,7 +25,7 @@
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/fileapi/browser_file_system_helper.h"
 #include "content/browser/gpu/shader_cache_factory.h"
-#include "content/browser/loader/prefetch_url_loader_factory.h"
+#include "content/browser/loader/prefetch_url_loader_service.h"
 #include "content/browser/notifications/platform_notification_context_impl.h"
 #include "content/common/dom_storage/dom_storage_types.h"
 #include "content/public/browser/browser_context.h"
@@ -688,8 +688,8 @@ std::unique_ptr<StoragePartitionImpl> StoragePartitionImpl::Create(
   partition->appcache_service_->set_url_loader_factory_getter(
       partition->url_loader_factory_getter_.get());
 
-  partition->prefetch_url_loader_factory_ =
-      base::MakeRefCounted<PrefetchURLLoaderFactory>(
+  partition->prefetch_url_loader_service_ =
+      base::MakeRefCounted<PrefetchURLLoaderService>(
           partition->url_loader_factory_getter_);
 
   return partition;
@@ -840,8 +840,8 @@ BlobRegistryWrapper* StoragePartitionImpl::GetBlobRegistry() {
   return blob_registry_.get();
 }
 
-PrefetchURLLoaderFactory* StoragePartitionImpl::GetPrefetchURLLoaderFactory() {
-  return prefetch_url_loader_factory_.get();
+PrefetchURLLoaderService* StoragePartitionImpl::GetPrefetchURLLoaderService() {
+  return prefetch_url_loader_service_.get();
 }
 
 void StoragePartitionImpl::OpenLocalStorage(

content/browser/storage_partition_impl.h

@@ -49,7 +49,7 @@ namespace content {
 class BackgroundFetchContext;
 class BlobRegistryWrapper;
 class BlobURLLoaderFactory;
-class PrefetchURLLoaderFactory;
+class PrefetchURLLoaderService;
 
 class CONTENT_EXPORT StoragePartitionImpl
     : public StoragePartition,
@@ -144,7 +144,7 @@ class CONTENT_EXPORT StoragePartitionImpl
   BluetoothAllowedDevicesMap* GetBluetoothAllowedDevicesMap();
   BlobURLLoaderFactory* GetBlobURLLoaderFactory();
   BlobRegistryWrapper* GetBlobRegistry();
-  PrefetchURLLoaderFactory* GetPrefetchURLLoaderFactory();
+  PrefetchURLLoaderService* GetPrefetchURLLoaderService();
 
   // mojom::StoragePartitionService interface.
   void OpenLocalStorage(
@@ -310,7 +310,7 @@ class CONTENT_EXPORT StoragePartitionImpl
   scoped_refptr<BluetoothAllowedDevicesMap> bluetooth_allowed_devices_map_;
   scoped_refptr<BlobURLLoaderFactory> blob_url_loader_factory_;
   scoped_refptr<BlobRegistryWrapper> blob_registry_;
-  scoped_refptr<PrefetchURLLoaderFactory> prefetch_url_loader_factory_;
+  scoped_refptr<PrefetchURLLoaderService> prefetch_url_loader_service_;
 
   // BindingSet for StoragePartitionService, using the process id as the
   // binding context type. The process id can subsequently be used during

content/browser/storage_partition_impl_map.cc

@@ -28,6 +28,7 @@
 #include "content/browser/blob_storage/chrome_blob_storage_context.h"
 #include "content/browser/devtools/devtools_url_request_interceptor.h"
 #include "content/browser/fileapi/browser_file_system_helper.h"
+#include "content/browser/loader/prefetch_url_loader_service.h"
 #include "content/browser/loader/resource_request_info_impl.h"
 #include "content/browser/resource_context_impl.h"
 #include "content/browser/service_worker/service_worker_request_handler.h"
@@ -573,6 +574,13 @@ void StoragePartitionImplMap::PostCreateInitialization(
                        partition->GetServiceWorkerContext(),
                        browser_context_->GetResourceContext()));
 
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::BindOnce(&PrefetchURLLoaderService::InitializeResourceContext,
+                       partition->GetPrefetchURLLoaderService(),
+                       browser_context_->GetResourceContext(),
+                       base::RetainedRef(partition->GetURLRequestContext())));
+
     // We do not call InitializeURLRequestContext() for media contexts because,
     // other than the HTTP cache, the media contexts share the same backing
     // objects as their associated "normal" request context.  Thus, the previous