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::URLLoaderRequest 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) {
       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));
       return;
     }

[kinuko, 2017/05/30 06:27:32]

Should we have blob url handling case here? ...hm, but given that there's the
observation that in rare extension cases redirects to blob from other scheme
could happen having it down there might be still safer. (Thinking out loud)

[jam, 2017/05/30 15:54:18]

yep, that's why I didn't put it here

 
     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.
     }
 
-    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::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(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::URLLoaderRequest url_loader_request_;
   mojom::URLLoaderClientPtr url_loader_client_ptr_;
 
   DISALLOW_COPY_AND_ASSIGN(URLLoaderRequestController);
 };
 
 NavigationURLLoaderNetworkService::NavigationURLLoaderNetworkService(
     ResourceContext* resource_context,
@@ skipping 47 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_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