Use Associated interfaces for mojo-loading

content/browser/service_worker/service_worker_fetch_dispatcher.cc

 // Copyright 2014 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_fetch_dispatcher.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/feature_list.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/loader/resource_request_info_impl.h"
 #include "content/browser/service_worker/embedded_worker_status.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/common/service_worker/fetch_event_dispatcher.mojom.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/common/service_worker/service_worker_status_code.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "content/common/service_worker/service_worker_utils.h"
-#include "content/common/url_loader.mojom.h"
-#include "content/common/url_loader_factory.mojom.h"
 #include "content/public/common/browser_side_navigation_policy.h"
 #include "content/public/common/content_features.h"
+#include "mojo/public/cpp/bindings/associated_binding.h"
+#include "mojo/public/cpp/bindings/binding.h"
 #include "net/log/net_log.h"
 #include "net/log/net_log_capture_mode.h"
 #include "net/log/net_log_event_type.h"
 #include "net/url_request/url_request.h"
+#include "services/service_manager/public/cpp/identity.h"
+#include "services/service_manager/public/cpp/interface_provider_spec.h"
 
 namespace content {
 
 namespace {
 
+class DelegatingURLLoader final : public mojom::URLLoader {
+ public:
+  explicit DelegatingURLLoader(mojom::URLLoaderAssociatedPtr loader)
+      : binding_(this), loader_(std::move(loader)) {}
+  ~DelegatingURLLoader() override {}
+
+  void FollowRedirect() override { loader_->FollowRedirect(); }
+  void Cancel() override { loader_->Cancel(); }
+
+  mojom::URLLoaderPtr CreateInterfacePtrAndBind() {
+    return binding_.CreateInterfacePtrAndBind();
+  }
+
+ private:
+  mojo::Binding<mojom::URLLoader> binding_;
+  mojom::URLLoaderAssociatedPtr loader_;
+
+  DISALLOW_COPY_AND_ASSIGN(DelegatingURLLoader);
+};
+
+class DelegatingURLLoaderClient final : public mojom::URLLoaderClient {
+ public:
+  explicit DelegatingURLLoaderClient(mojom::URLLoaderClientPtr client)
+      : binding_(this), client_(std::move(client)) {}
+  ~DelegatingURLLoaderClient() override {}
+
+  void OnReceiveResponse(const ResourceResponseHead& head) override {
+    client_->OnReceiveResponse(head);
+  }
+  void OnStartLoadingResponseBody(
+      mojo::ScopedDataPipeConsumerHandle body) override {
+    client_->OnStartLoadingResponseBody(std::move(body));
+  }
+  void OnComplete(
+      const ResourceRequestCompletionStatus& completion_status) override {
+    client_->OnComplete(completion_status);
+  }
+
+  void Bind(mojom::URLLoaderClientAssociatedPtrInfo* ptr_info,
+            mojo::AssociatedGroup* associated_group) {
+    binding_.Bind(ptr_info, associated_group);
+  }
+
+ private:
+  mojo::AssociatedBinding<mojom::URLLoaderClient> binding_;
+  mojom::URLLoaderClientPtr client_;
+
+  DISALLOW_COPY_AND_ASSIGN(DelegatingURLLoaderClient);
+};
+
 using EventType = ServiceWorkerMetrics::EventType;
 EventType ResourceTypeToEventType(ResourceType resource_type) {
   switch (resource_type) {
     case RESOURCE_TYPE_MAIN_FRAME:
       return EventType::FETCH_MAIN_FRAME;
     case RESOURCE_TYPE_SUB_FRAME:
       return EventType::FETCH_SUB_FRAME;
     case RESOURCE_TYPE_SHARED_WORKER:
       return EventType::FETCH_SHARED_WORKER;
     case RESOURCE_TYPE_SERVICE_WORKER:
@@ skipping 85 matching lines @@
     const net::NetLogWithSource& net_log,
     const base::Closure& prepare_callback,
     const FetchCallback& fetch_callback)
     : version_(version),
       net_log_(net_log),
       prepare_callback_(prepare_callback),
       fetch_callback_(fetch_callback),
       request_(std::move(request)),
       resource_type_(resource_type),
       did_complete_(false),
+      interface_registry_(service_manager::Identity(),
+                          service_manager::InterfaceProviderSpec()),
       weak_factory_(this) {
   net_log_.BeginEvent(net::NetLogEventType::SERVICE_WORKER_DISPATCH_FETCH_EVENT,
                       net::NetLog::StringCallback(
                           "event_type", ServiceWorkerMetrics::EventTypeToString(
                                             GetEventType())));
 }
 
 ServiceWorkerFetchDispatcher::~ServiceWorkerFetchDispatcher() {
   if (!did_complete_)
     net_log_.EndEvent(
@@ skipping 143 matching lines @@
           features::kServiceWorkerNavigationPreload)) {
     // TODO(horo): Check |version_|'s origin_trial_tokens() here if we use
     // Origin-Trial for NavigationPreload.
     return;
   }
   if (IsBrowserSideNavigationEnabled()) {
     // TODO(horo): Support NavigationPreload with PlzNavigate.
     NOTIMPLEMENTED();
     return;
   }
+
+  DCHECK(!url_loader_factory_);
+  service_manager::mojom::InterfaceProviderPtr provider_proxy;
+  interface_registry_.Bind(mojo::GetProxy(&provider_proxy),
+                           service_manager::Identity(),
+                           service_manager::InterfaceProviderSpec());
+  interface_provider_.Bind(std::move(provider_proxy));
+  interface_registry_.AddInterface(url_loader_factory_getter);
+  interface_provider_.GetInterface(&url_loader_factory_);
+
   DCHECK(!url_loader_factory_getter.is_null());
-  mojom::URLLoaderFactoryPtr factory;
-  url_loader_factory_getter.Run(mojo::GetProxy(&factory));
-  if (url_loader_factory_getter.IsCancelled())
-    return;
+  url_loader_factory_getter.Run(mojo::GetProxy(&url_loader_factory_));
 
-  preload_handle_ = mojom::FetchEventPreloadHandle::New();
   const ResourceRequestInfoImpl* original_info =
       ResourceRequestInfoImpl::ForRequest(original_request);
 
-  mojom::URLLoaderClientPtr url_loader_client;
-  preload_handle_->url_loader_client_request = GetProxy(&url_loader_client);
-
   ResourceRequest request;
   request.method = original_request->method();
   request.url = original_request->url();
   request.referrer = GURL(original_request->referrer());
   request.referrer_policy = original_info->GetReferrerPolicy();
   request.visibility_state = original_info->GetVisibilityState();
   request.load_flags = original_request->load_flags();
   // Set to SUB_RESOURCE because we shouldn't trigger NavigationResourceThrottle
   // for the service worker navigation preload request.
   request.resource_type = RESOURCE_TYPE_SUB_RESOURCE;
   request.priority = original_request->priority();
   request.skip_service_worker = SkipServiceWorker::ALL;
   request.do_not_prompt_for_login = true;
   request.render_frame_id = original_info->GetRenderFrameID();
   request.is_main_frame = original_info->IsMainFrame();
   request.parent_is_main_frame = original_info->ParentIsMainFrame();
   const int request_id = ResourceDispatcherHostImpl::Get()->MakeRequestID();
   DCHECK_LT(request_id, -1);
-  // TODO(horo): Add "Service-Worker-Navigation-Preload" header.
-  // See: https://github.com/w3c/ServiceWorker/issues/920#issuecomment-251150270
-  factory->CreateLoaderAndStart(GetProxy(&preload_handle_->url_loader),
-                                original_info->GetRouteID(), request_id,
-                                request, std::move(url_loader_client));
+
+  preload_handle_ = mojom::FetchEventPreloadHandle::New();
+  mojom::URLLoaderClientPtr url_loader_client_ptr;
+  preload_handle_->url_loader_client_request =
+      mojo::GetProxy(&url_loader_client_ptr);
+  std::unique_ptr<DelegatingURLLoaderClient> url_loader_client(
+      new DelegatingURLLoaderClient(std::move(url_loader_client_ptr)));
+  mojom::URLLoaderClientAssociatedPtrInfo url_loader_client_associated_ptr_info;
+  url_loader_client->Bind(&url_loader_client_associated_ptr_info,
+                          url_loader_factory_.associated_group());
+  mojom::URLLoaderAssociatedPtr url_loader_associated_ptr;
+
+  // TODO(horo): Add "Service-Worker-Navigation-Preload" header. See
+  // https://getithub.com/w3c/ServiceWorker/issues/920#issuecomment-251150270
+  url_loader_factory_->CreateLoaderAndStart(
+      mojo::GetProxy(&url_loader_associated_ptr,
+                     url_loader_factory_.associated_group()),
+      original_info->GetRouteID(), request_id, request,
+      std::move(url_loader_client_associated_ptr_info));
+
+  std::unique_ptr<DelegatingURLLoader> url_loader(
+      new DelegatingURLLoader(std::move(url_loader_associated_ptr)));
+  preload_handle_->url_loader = url_loader->CreateInterfacePtrAndBind();
+  url_loader_ = std::move(url_loader);
+  url_loader_client_ = std::move(url_loader_client);
 }
 
 ServiceWorkerMetrics::EventType ServiceWorkerFetchDispatcher::GetEventType()
     const {
   if (request_->fetch_type == ServiceWorkerFetchType::FOREIGN_FETCH)
     return ServiceWorkerMetrics::EventType::FOREIGN_FETCH;
   return ResourceTypeToEventType(resource_type_);
 }
 
 }  // namespace content