[Mojo-Loading] Use independent URLLoaderClient

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/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/devtools/service_worker_devtools_agent_host.h"
 #include "content/browser/devtools/service_worker_devtools_manager.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/loader/resource_request_info_impl.h"
 #include "content/browser/loader/resource_requester_info.h"
 #include "content/browser/loader/url_loader_factory_impl.h"
 #include "content/browser/service_worker/embedded_worker_status.h"
 #include "content/browser/service_worker/service_worker_metrics.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/common/service_worker/service_worker_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/public/browser/browser_thread.h"
 #include "content/public/common/browser_side_navigation_policy.h"
-#include "mojo/public/cpp/bindings/associated_binding.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_util.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"
 
 namespace content {
 
@@ skipping 110 matching lines @@
     client_->OnUploadProgress(current_position, total_size, ack_callback);
   }
   void OnReceiveCachedMetadata(const std::vector<uint8_t>& data) override {
     client_->OnReceiveCachedMetadata(data);
   }
   void OnTransferSizeUpdated(int32_t transfer_size_diff) override {
     client_->OnTransferSizeUpdated(transfer_size_diff);
   }
   void OnReceiveResponse(
       const ResourceResponseHead& head,
-      mojom::DownloadedTempFileAssociatedPtrInfo downloaded_file) override {
+      mojom::DownloadedTempFilePtr downloaded_file) override {
     client_->OnReceiveResponse(head, std::move(downloaded_file));
     DCHECK(on_response_);
     std::move(on_response_).Run();
     AddDevToolsCallback(
         base::Bind(&NotifyNavigationPreloadResponseReceivedOnUI, url_, head));
   }
   void OnReceiveRedirect(const net::RedirectInfo& redirect_info,
                          const ResourceResponseHead& head) override {
     client_->OnReceiveRedirect(redirect_info, head);
   }
   void OnStartLoadingResponseBody(
       mojo::ScopedDataPipeConsumerHandle body) override {
     client_->OnStartLoadingResponseBody(std::move(body));
   }
   void OnComplete(
       const ResourceRequestCompletionStatus& completion_status) override {
     client_->OnComplete(completion_status);
     completed_ = true;
     AddDevToolsCallback(
         base::Bind(&NotifyNavigationPreloadCompletedOnUI, completion_status));
   }
 
-  void Bind(mojom::URLLoaderClientAssociatedPtrInfo* ptr_info) {
-    binding_.Bind(ptr_info);
-  }
+  void Bind(mojom::URLLoaderClientPtr* ptr_info) { binding_.Bind(ptr_info); }
 
  private:
   void MayBeRunDevToolsCallbacks() {
     if (!worker_id_)
       return;
     while (!devtools_callbacks.empty()) {
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                               base::Bind(std::move(devtools_callbacks.front()),
                                          *worker_id_, devtools_request_id_));
       devtools_callbacks.pop();
     }
   }
   void AddDevToolsCallback(
       base::Callback<void(const WorkerId&, const std::string&)> callback) {
     devtools_callbacks.push(callback);
     MayBeRunDevToolsCallbacks();
   }
 
-  mojo::AssociatedBinding<mojom::URLLoaderClient> binding_;
+  mojo::Binding<mojom::URLLoaderClient> binding_;
   mojom::URLLoaderClientPtr client_;
   base::OnceClosure on_response_;
   bool completed_ = false;
   const GURL url_;
 
   base::Optional<std::pair<int, int>> worker_id_;
   std::string devtools_request_id_;
   std::queue<base::Callback<void(const WorkerId&, const std::string&)>>
       devtools_callbacks;
   DISALLOW_COPY_AND_ASSIGN(DelegatingURLLoaderClient);
@@ skipping 359 matching lines @@
 
   const int request_id = ResourceDispatcherHostImpl::Get()->MakeRequestID();
   DCHECK_LT(request_id, -1);
 
   preload_handle_ = mojom::FetchEventPreloadHandle::New();
   mojom::URLLoaderClientPtr url_loader_client_ptr;
   preload_handle_->url_loader_client_request =
       mojo::MakeRequest(&url_loader_client_ptr);
   auto url_loader_client = base::MakeUnique<DelegatingURLLoaderClient>(
       std::move(url_loader_client_ptr), std::move(on_response), request);
-  mojom::URLLoaderClientAssociatedPtrInfo url_loader_client_associated_ptr_info;
-  url_loader_client->Bind(&url_loader_client_associated_ptr_info);
+  mojom::URLLoaderClientPtr url_loader_client_ptr_to_pass;
+  url_loader_client->Bind(&url_loader_client_ptr_to_pass);
   mojom::URLLoaderAssociatedPtr url_loader_associated_ptr;
 
   url_loader_factory->CreateLoaderAndStart(
       mojo::MakeRequest(&url_loader_associated_ptr),
       original_info->GetRouteID(), request_id, request,
-      std::move(url_loader_client_associated_ptr_info));
+      std::move(url_loader_client_ptr_to_pass));
 
   std::unique_ptr<DelegatingURLLoader> url_loader(
       base::MakeUnique<DelegatingURLLoader>(
           std::move(url_loader_associated_ptr)));
   preload_handle_->url_loader = url_loader->CreateInterfacePtrAndBind();
   url_loader_assets_ =
       new URLLoaderAssets(std::move(url_loader_factory), std::move(url_loader),
                           std::move(url_loader_client));
   return true;
 }
@@ skipping 10 matching lines @@
     ServiceWorkerVersion* version,
     int event_finish_id,
     scoped_refptr<URLLoaderAssets> url_loader_assets,
     ServiceWorkerStatusCode status,
     base::Time dispatch_event_time) {
   version->FinishRequest(event_finish_id, status != SERVICE_WORKER_ERROR_ABORT,
                          dispatch_event_time);
 }
 
 }  // namespace content