[network service][SW] Rework browser-side SW on top of URL loader chaining

content/browser/loader/navigation_url_loader_network_service.cc

 // Copyright 2017 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/navigation_url_loader_network_service.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 67 matching lines @@
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
   }
 
   void Start(
       ServiceWorkerNavigationHandleCore* service_worker_navigation_handle_core,
       AppCacheNavigationHandleCore* appcache_handle_core,
       std::unique_ptr<NavigationRequestInfo> request_info,
       mojom::URLLoaderFactoryPtrInfo factory_for_webui,
       const base::Callback<WebContents*(void)>& web_contents_getter,
       mojom::URLLoaderAssociatedRequest url_loader_request,
-      mojom::URLLoaderClientPtr url_loader_client_ptr,
+      mojom::URLLoaderClientPtrInfo url_loader_client_ptr_info,
       std::unique_ptr<service_manager::Connector> connector) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
+    url_loader_client_ptr_.Bind(std::move(url_loader_client_ptr_info));
     const ResourceType resource_type = request_info->is_main_frame
                                            ? RESOURCE_TYPE_MAIN_FRAME
                                            : RESOURCE_TYPE_SUB_FRAME;
 
     if (resource_request_->request_body) {
       AttachRequestBodyBlobDataHandles(resource_request_->request_body.get(),
                                        resource_context_);
     }
 
     // Requests to WebUI scheme won't get redirected to/from other schemes
     // or be intercepted, so we just let it go here.
     if (factory_for_webui.is_valid()) {
       mojom::URLLoaderFactoryPtr factory_ptr;
       factory_ptr.Bind(std::move(factory_for_webui));
       factory_ptr->CreateLoaderAndStart(
           std::move(url_loader_request), 0 /* routing_id? */,
           0 /* request_id? */, mojom::kURLLoadOptionSendSSLInfo,
-          *resource_request_, std::move(url_loader_client_ptr));
+          *resource_request_, std::move(url_loader_client_ptr_));
       return;
     }
 
     DCHECK(handlers_.empty());
     if (service_worker_navigation_handle_core) {
       RequestContextFrameType frame_type =
           request_info->is_main_frame ? REQUEST_CONTEXT_FRAME_TYPE_TOP_LEVEL
                                       : REQUEST_CONTEXT_FRAME_TYPE_NESTED;
 
       storage::BlobStorageContext* blob_storage_context = GetBlobStorageContext(
           GetChromeBlobStorageContextForResourceContext(resource_context_));
       std::unique_ptr<URLLoaderRequestHandler> service_worker_handler =
           ServiceWorkerRequestHandler::InitializeForNavigationNetworkService(
               *resource_request_, resource_context_,
               service_worker_navigation_handle_core, blob_storage_context,
               request_info->begin_params.skip_service_worker, resource_type,
               request_info->begin_params.request_context_type, frame_type,
               request_info->are_ancestors_secure,
               request_info->common_params.post_data, web_contents_getter);
       if (service_worker_handler)
         handlers_.push_back(std::move(service_worker_handler));
     }
 
     if (appcache_handle_core) {
       // TODO: add appcache code here.
     }
 
-    Restart(std::move(url_loader_request), std::move(url_loader_client_ptr));
+    Restart(std::move(url_loader_request), std::move(url_loader_client_ptr_));
   }
 
   // This could be called multiple times.
   void Restart(mojom::URLLoaderAssociatedRequest url_loader_request,
                mojom::URLLoaderClientPtr url_loader_client_ptr) {
     url_loader_request_ = std::move(url_loader_request);
     url_loader_client_ptr_ = std::move(url_loader_client_ptr);
     handler_index_ = 0;
     MaybeStartLoader(nullptr);
   }
@@ skipping 118 matching lines @@
           &URLLoaderRequestController::Start,
           base::Unretained(request_controller_.get()),
           service_worker_navigation_handle
               ? service_worker_navigation_handle->core()
               : nullptr,
           appcache_handle ? appcache_handle->core() : nullptr,
           base::Passed(std::move(request_info)),
           base::Passed(std::move(factory_for_webui)),
           base::Bind(&GetWebContentsFromFrameTreeNodeID, frame_tree_node_id),
           base::Passed(std::move(loader_associated_request)),
-          base::Passed(std::move(url_loader_client_ptr_to_pass)),
+          base::Passed(url_loader_client_ptr_to_pass.PassInterface()),
           base::Passed(ServiceManagerConnection::GetForProcess()
                            ->GetConnector()
                            ->Clone())));
 }
 
 NavigationURLLoaderNetworkService::~NavigationURLLoaderNetworkService() {
   BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE,
                             request_controller_.release());
 }
 
@@ skipping 65 matching lines @@
     TRACE_EVENT_ASYNC_END2("navigation", "Navigation timeToResponseStarted",
                            this, "&NavigationURLLoaderNetworkService", this,
                            "success", false);
 
     delegate_->OnRequestFailed(completion_status.exists_in_cache,
                                completion_status.error_code);
   }
 }
 
 }  // namespace content