Add support for reading blobs when using the network service.

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 48 matching lines @@
 
 // Kept around during the lifetime of the navigation request, and is
 // responsible for dispatching a ResourceRequest to the appropriate
 // URLLoaderFactory.  In order to get the right URLLoaderFactory it
 // builds a vector of URLLoaderRequestHandler's and successively calls
 // MaybeCreateLoaderFactory 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)
+  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),
-        network_factory_(nullptr) {}
+        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,
-      scoped_refptr<URLLoaderFactoryGetter> url_loader_factory_getter,
       const base::Callback<WebContents*(void)>& web_contents_getter,
       mojom::URLLoaderAssociatedRequest url_loader_request,
       mojom::URLLoaderClientPtr url_loader_client_ptr,
       std::unique_ptr<service_manager::Connector> connector) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     const ResourceType resource_type = request_info->is_main_frame
                                            ? RESOURCE_TYPE_MAIN_FRAME
                                            : RESOURCE_TYPE_SUB_FRAME;
 
     if (resource_request_->request_body) {
@@ skipping 30 matching lines @@
               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.
     }
 
-    DCHECK(!network_factory_);
-    network_factory_ = url_loader_factory_getter->GetNetworkFactory()->get();
-
     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 12 matching lines @@
 
     if (handler_index_ < handlers_.size()) {
       handlers_[handler_index_++]->MaybeCreateLoaderFactory(
           *resource_request_, resource_context_,
           base::BindOnce(&URLLoaderRequestController::MaybeStartLoader,
                          base::Unretained(this)));
       return;
     }
 
     DCHECK_EQ(handlers_.size(), handler_index_);
-    DCHECK(network_factory_ != nullptr);
-    MaybeStartLoader(network_factory_);
+    if (resource_request_->url.SchemeIs(url::kBlobScheme)) {
+      factory = url_loader_factory_getter_->GetBlobFactory()->get();
+    } else {
+      factory = url_loader_factory_getter_->GetNetworkFactory()->get();
+    }
+    MaybeStartLoader(factory);
   }
 
  private:
   std::vector<std::unique_ptr<URLLoaderRequestHandler>> handlers_;
   size_t handler_index_ = 0;
 
   std::unique_ptr<ResourceRequest> resource_request_;
   ResourceContext* resource_context_;
 
-  // The factory for doing a vanilla network request, called when
-  // any of other request handlers handle the given request.
-  mojom::URLLoaderFactory* network_factory_;
+  scoped_refptr<URLLoaderFactoryGetter> url_loader_factory_getter_;
 
   // Kept around until we create a loader.
   mojom::URLLoaderAssociatedRequest url_loader_request_;
   mojom::URLLoaderClientPtr url_loader_client_ptr_;
 
   DISALLOW_COPY_AND_ASSIGN(URLLoaderRequestController);
 };
 
 NavigationURLLoaderNetworkService::NavigationURLLoaderNetworkService(
     ResourceContext* resource_context,
@@ skipping 48 matching lines @@
   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);
-    factory_for_webui = GetWebUIURLLoader(frame_tree_node).PassInterface();
+    factory_for_webui = CreateWebUIURLLoader(frame_tree_node).PassInterface();
   }
 
   g_next_request_id--;
 
   DCHECK(!request_controller_);
   request_controller_ = base::MakeUnique<URLLoaderRequestController>(
-      std::move(new_request), resource_context);
+      std::move(new_request), resource_context,
+      static_cast<StoragePartitionImpl*>(storage_partition)
+          ->url_loader_factory_getter());
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       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)),
-          static_cast<StoragePartitionImpl*>(storage_partition)
-              ->url_loader_factory_getter(),
           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(ServiceManagerConnection::GetForProcess()
                            ->GetConnector()
                            ->Clone())));
 }
 
 NavigationURLLoaderNetworkService::~NavigationURLLoaderNetworkService() {
   BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE,
@@ skipping 68 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