Use independent URLLoader in browser-side code

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 16 matching lines @@
 #include "content/browser/webui/web_ui_url_loader_factory.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/global_request_id.h"
 #include "content/public/browser/navigation_data.h"
 #include "content/public/browser/navigation_ui_data.h"
 #include "content/public/browser/ssl_status.h"
 #include "content/public/browser/stream_handle.h"
 #include "content/public/common/referrer.h"
 #include "content/public/common/url_constants.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_request_context.h"
 
 namespace content {
 
 namespace {
 
 // Request ID for browser initiated requests. We start at -2 on the same lines
 // as ResourceDispatcherHostImpl.
 int g_next_request_id = -2;
 
 WebContents* GetWebContentsFromFrameTreeNodeID(int frame_tree_node_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   FrameTreeNode* frame_tree_node =
       FrameTreeNode::GloballyFindByID(frame_tree_node_id);
   if (!frame_tree_node)
     return nullptr;
 
   return WebContentsImpl::FromFrameTreeNode(frame_tree_node);
 }
 
+class AssociatedURLLoaderWrapper final : public mojom::URLLoader {
+ public:
+  static void CreateLoaderAndStart(mojom::URLLoaderFactory* factory,
+                                   mojom::URLLoaderRequest request,
+                                   uint32_t options,
+                                   const ResourceRequest& resource_request,
+                                   mojom::URLLoaderClientPtr client) {
+    mojom::URLLoaderAssociatedPtr associated_ptr;
+    mojom::URLLoaderAssociatedRequest associated_request =
+        mojo::MakeRequest(&associated_ptr);
+    factory->CreateLoaderAndStart(std::move(associated_request),
+                                  0 /* routing_id */, 0 /* request_id */,
+                                  options, resource_request, std::move(client));
+    mojo::MakeStrongBinding(
+        base::MakeUnique<AssociatedURLLoaderWrapper>(std::move(associated_ptr)),
+        std::move(request));
+  }
+
+  explicit AssociatedURLLoaderWrapper(
+      mojom::URLLoaderAssociatedPtr associated_ptr)
+      : associated_ptr_(std::move(associated_ptr)) {}
+  ~AssociatedURLLoaderWrapper() override {}
+
+  void FollowRedirect() override { associated_ptr_->FollowRedirect(); }
+
+  void SetPriority(net::RequestPriority priority,
+                   int intra_priority_value) override {
+    associated_ptr_->SetPriority(priority, intra_priority_value);
+  }
+
+ private:
+  mojom::URLLoaderAssociatedPtr associated_ptr_;
+  DISALLOW_COPY_AND_ASSIGN(AssociatedURLLoaderWrapper);
+};
+
 }  // namespace
 
 // Kept around during the lifetime of the navigation request, and is
 // responsible for dispatching a ResourceRequest to the appropriate
 // URLLoader.  In order to get the right URLLoader it builds a vector
 // of URLLoaderRequestHandler's and successively calls MaybeCreateLoader
 // on each until the request is successfully handled. The same sequence
 // may be performed multiple times when redirects happen.
 class NavigationURLLoaderNetworkService::URLLoaderRequestController {
  public:
   URLLoaderRequestController(
       std::unique_ptr<ResourceRequest> resource_request,
       ResourceContext* resource_context,
       scoped_refptr<URLLoaderFactoryGetter> url_loader_factory_getter)
       : resource_request_(std::move(resource_request)),
         resource_context_(resource_context),
         url_loader_factory_getter_(url_loader_factory_getter) {}
 
   virtual ~URLLoaderRequestController() {
     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::URLLoaderRequest url_loader_request,
       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_));
+      AssociatedURLLoaderWrapper::CreateLoaderAndStart(
+          factory_ptr.get(), std::move(url_loader_request),
+          mojom::kURLLoadOptionSendSSLInfo, *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(
@@ skipping 11 matching lines @@
     }
 
     if (appcache_handle_core) {
       // TODO: add appcache code here.
     }
 
     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,
+  void Restart(mojom::URLLoaderRequest 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(StartLoaderCallback());
   }
 
   void MaybeStartLoader(StartLoaderCallback start_loader_callback) {
     DCHECK(url_loader_client_ptr_.is_bound());
 
@@ skipping 12 matching lines @@
       return;
     }
 
     mojom::URLLoaderFactory* factory = nullptr;
     DCHECK_EQ(handlers_.size(), handler_index_);
     if (resource_request_->url.SchemeIs(url::kBlobScheme)) {
       factory = url_loader_factory_getter_->GetBlobFactory()->get();
     } else {
       factory = url_loader_factory_getter_->GetNetworkFactory()->get();
     }
-    factory->CreateLoaderAndStart(
-        std::move(url_loader_request_), 0 /* routing_id? */,
-        0 /* request_id? */, mojom::kURLLoadOptionSendSSLInfo,
-        *resource_request_, std::move(url_loader_client_ptr_));
+    AssociatedURLLoaderWrapper::CreateLoaderAndStart(
+        factory, std::move(url_loader_request_),
+        mojom::kURLLoadOptionSendSSLInfo, *resource_request_,
+        std::move(url_loader_client_ptr_));
   }
 
  private:
   std::vector<std::unique_ptr<URLLoaderRequestHandler>> handlers_;
   size_t handler_index_ = 0;
 
   std::unique_ptr<ResourceRequest> resource_request_;
   ResourceContext* resource_context_;
 
   scoped_refptr<URLLoaderFactoryGetter> url_loader_factory_getter_;
 
   // Kept around until we create a loader.
-  mojom::URLLoaderAssociatedRequest url_loader_request_;
+  mojom::URLLoaderRequest url_loader_request_;
   mojom::URLLoaderClientPtr url_loader_client_ptr_;
 
   DISALLOW_COPY_AND_ASSIGN(URLLoaderRequestController);
 };
 
 NavigationURLLoaderNetworkService::NavigationURLLoaderNetworkService(
     ResourceContext* resource_context,
     StoragePartition* storage_partition,
     std::unique_ptr<NavigationRequestInfo> request_info,
     std::unique_ptr<NavigationUIData> navigation_ui_data,
@@ skipping 33 matching lines @@
   // Sync loads should have maximum priority and should be the only
   // requests that have the ignore limits flag set.
   DCHECK(!(load_flags & net::LOAD_IGNORE_LIMITS));
 
   new_request->load_flags = load_flags;
 
   new_request->request_body = request_info->common_params.post_data.get();
 
   int frame_tree_node_id = request_info->frame_tree_node_id;
 
-  mojom::URLLoaderAssociatedRequest loader_associated_request =
-      mojo::MakeRequest(&url_loader_associated_ptr_);
+  mojom::URLLoaderRequest loader_request = mojo::MakeRequest(&url_loader_ptr_);
   mojom::URLLoaderClientPtr url_loader_client_ptr_to_pass;
   binding_.Bind(mojo::MakeRequest(&url_loader_client_ptr_to_pass));
 
   // Check if a web UI scheme wants to handle this request.
   mojom::URLLoaderFactoryPtrInfo factory_for_webui;
   const auto& schemes = URLDataManagerBackend::GetWebUISchemes();
   if (std::find(schemes.begin(), schemes.end(), new_request->url.scheme()) !=
       schemes.end()) {
     FrameTreeNode* frame_tree_node =
         FrameTreeNode::GloballyFindByID(frame_tree_node_id);
@@ skipping 12 matching lines @@
       base::Bind(
           &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(loader_request)),
           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());
 }
 
 void NavigationURLLoaderNetworkService::FollowRedirect() {
-  url_loader_associated_ptr_->FollowRedirect();
+  url_loader_ptr_->FollowRedirect();
 }
 
 void NavigationURLLoaderNetworkService::ProceedWithResponse() {}
 
 void NavigationURLLoaderNetworkService::OnReceiveResponse(
     const ResourceResponseHead& head,
     const base::Optional<net::SSLInfo>& ssl_info,
     mojom::DownloadedTempFilePtr downloaded_file) {
   // TODO(scottmg): This needs to do more of what
   // NavigationResourceHandler::OnReponseStarted() does. Or maybe in
@@ skipping 53 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