Use Independent URLLoader

content/browser/service_worker/service_worker_provider_host.cc

 // Copyright 2013 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/service_worker/service_worker_provider_host.h"
 
 #include <utility>
 
 #include "base/feature_list.h"
 #include "base/guid.h"
@@ skipping 13 matching lines @@
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/common/browser_side_navigation_policy.h"
 #include "content/public/common/child_process_host.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_features.h"
 #include "content/public/common/origin_util.h"
 #include "mojo/public/cpp/bindings/strong_associated_binding.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
 #include "net/base/url_util.h"
 #include "storage/browser/blob/blob_storage_context.h"
 
 namespace content {
 
 namespace {
 
 // Provider host for navigation with PlzNavigate or when service worker's
 // context is created on the browser side. This function provides the next
 // ServiceWorkerProviderHost ID for them, starts at -2 and keeps going down.
@@ skipping 139 matching lines @@
   }
   void OnStartLoadingResponseBody(
       mojo::ScopedDataPipeConsumerHandle body) override {
     forwarding_client_->OnStartLoadingResponseBody(std::move(body));
   }
   void OnComplete(const ResourceRequestCompletionStatus& status) override {
     forwarding_client_->OnComplete(status);
   }
 
  private:
-  mojom::URLLoaderAssociatedPtr network_loader_;
+  mojom::URLLoaderPtr network_loader_;
   mojo::Binding<mojom::URLLoaderClient> network_client_binding_;
   mojom::URLLoaderClientPtr forwarding_client_;
   base::WeakPtr<ServiceWorkerProviderHost> provider_host_;
 
   DISALLOW_COPY_AND_ASSIGN(ScriptURLLoader);
 };
 
 // Created per one controller worker for script loading (only during
 // installation, eventually). This is kept alive while
 // ServiceWorkerNetworkProvider in the renderer process is alive.
 // Used only when IsServicificationEnabled is true.
 class ScriptURLLoaderFactory : public mojom::URLLoaderFactory {
  public:
   ScriptURLLoaderFactory(
       base::WeakPtr<ServiceWorkerContextCore> context,
       base::WeakPtr<ServiceWorkerProviderHost> provider_host,
       base::WeakPtr<storage::BlobStorageContext> blob_storage_context,
       scoped_refptr<URLLoaderFactoryGetter> loader_factory_getter)
       : context_(context),
         provider_host_(provider_host),
         blob_storage_context_(blob_storage_context),
         loader_factory_getter_(loader_factory_getter) {}
   ~ScriptURLLoaderFactory() override {}
 
   // mojom::URLLoaderFactory:
-  void CreateLoaderAndStart(mojom::URLLoaderAssociatedRequest request,
+  void CreateLoaderAndStart(mojom::URLLoaderRequest request,
                             int32_t routing_id,
                             int32_t request_id,
                             uint32_t options,
                             const ResourceRequest& resource_request,
                             mojom::URLLoaderClientPtr client,
                             const net::MutableNetworkTrafficAnnotationTag&
                                 traffic_annotation) override {
     if (!ShouldHandleScriptRequest(resource_request)) {
       // If the request should not be handled by ScriptURLLoader, just
       // fallback to the network.
       // TODO(kinuko): Record the reason like what we do with netlog in
       // ServiceWorkerContextRequestHandler.
       loader_factory_getter_->GetNetworkFactory()->get()->CreateLoaderAndStart(
           std::move(request), routing_id, request_id, options, resource_request,
           std::move(client), traffic_annotation);
       return;
     }
-    mojo::MakeStrongAssociatedBinding(
+    mojo::MakeStrongBinding(
         base::MakeUnique<ScriptURLLoader>(
             routing_id, request_id, options, resource_request,
             std::move(client), context_, provider_host_, blob_storage_context_,
             loader_factory_getter_, traffic_annotation),
         std::move(request));
   }
 
   void SyncLoad(int32_t routing_id,
                 int32_t request_id,
                 const ResourceRequest& request,
@@ skipping 864 matching lines @@
           render_thread_id_, provider_id(),
           GetOrCreateServiceWorkerHandle(
               associated_registration_->active_version()),
           false /* shouldNotifyControllerChange */,
           associated_registration_->active_version()->used_features()));
     }
   }
 }
 
 }  // namespace content