Provide skeleton functionality for AppCache handling in 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/lazy_instance.h"
 #include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
+#include "content/browser/appcache/appcache_navigation_handle.h"
+#include "content/browser/appcache/appcache_navigation_handle_core.h"
+#include "content/browser/appcache/appcache_request_handler.h"
 #include "content/browser/blob_storage/chrome_blob_storage_context.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/navigation_request_info.h"
 #include "content/browser/loader/navigation_resource_handler.h"
 #include "content/browser/loader/navigation_resource_throttle.h"
 #include "content/browser/loader/navigation_url_loader_delegate.h"
 #include "content/browser/webui/url_data_manager_backend.h"
 #include "content/browser/webui/web_ui_url_loader_factory.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/service_manager_connection.h"
 #include "content/public/common/service_names.mojom.h"
 #include "content/public/common/url_constants.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_request_context.h"
 #include "services/service_manager/public/cpp/connector.h"
 
 namespace content {
 
 namespace {
 
 static base::LazyInstance<mojom::URLLoaderFactoryPtr>::Leaky
     g_url_loader_factory = LAZY_INSTANCE_INITIALIZER;
 
-// This function is called on the IO thread for POST/PUT requests for
-// attaching blob information to the request body.
-void HandleRequestsWithBody(
-    std::unique_ptr<ResourceRequest> request,
+using CompleteNavigationStartCallback =
+    base::Callback<void(mojom::URLLoaderFactoryPtrInfo,
+                        std::unique_ptr<ResourceRequest>)>;
+
+void PrepareNavigationOnIOThread(
+    std::unique_ptr<ResourceRequest> resource_request,
     ResourceContext* resource_context,
-    base::WeakPtr<NavigationURLLoaderNetworkService> url_loader) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(request->request_body.get());
+    ResourceType resource_type,
+    AppCacheNavigationHandleCore* appcache_handle_core,
+    CompleteNavigationStartCallback complete_request) {
+  if (resource_request->request_body.get()) {
+    AttachRequestBodyBlobDataHandles(resource_request->request_body.get(),
+                                     resource_context);
+  }
 
-  AttachRequestBodyBlobDataHandles(request->request_body.get(),
-                                    resource_context);
+  mojom::URLLoaderFactoryPtrInfo url_loader_factory_ptr_info;
+
+  if (appcache_handle_core) {

[jam, 2017/05/11 01:42:13]

to make sure i understand: is this only true if the origin has an appcache
installed? and the other check will confirm if that particular url does?

[ananta, 2017/05/11 02:12:31]

Sadly no. For HTTP/HTTPs with PlzNavigate we will always have an
AppCacheNavigateHandleCore pointer as the host is precreated. The other code
will check both the origin and then whether the response can be served.

[kinuko, 2017/05/11 02:14:14]

No if appcache_handle is non-null appcache_handle_core is always non-null as
well.  Existence of appcache is lazily discovered on IO thread (as well as in SW
cases)

[jam, 2017/05/11 14:50:43]

ah, I misunderstood that the appcache code would return synchronously if the
origin doesn't have an appcache.

orthogonal to this work, it would be nice to in the future lower the number of
thread hops needed by appcache checking. i.e. why is this a callback that's
posted on a thread, instead of a method that returns a value? maybe it had to be
this way for URLRequestJob, but for network service path we can just return
synchronously.

+    AppCacheRequestHandler::InitializeForNavigationNetworkService(
+        std::move(resource_request), resource_context, appcache_handle_core,
+        resource_type, complete_request);
+    return;
+  }
+
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&NavigationURLLoaderNetworkService::StartURLRequest,
-                  url_loader, base::Passed(&request)));
+      base::Bind(complete_request,
+                 base::Passed(std::move(url_loader_factory_ptr_info)),
+                 base::Passed(std::move(resource_request))));
 }
 
 }  // namespace
 
 NavigationURLLoaderNetworkService::NavigationURLLoaderNetworkService(
     ResourceContext* resource_context,
     StoragePartition* storage_partition,
     std::unique_ptr<NavigationRequestInfo> request_info,
     std::unique_ptr<NavigationUIData> navigation_ui_data,
     ServiceWorkerNavigationHandle* service_worker_handle,
@@ skipping 32 matching lines @@
   if (request_info_->is_main_frame)
     load_flags |= net::LOAD_MAIN_FRAME_DEPRECATED;
 
   // 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();
-  if (new_request->request_body.get()) {
-    // The request body may need blob handles to be added to it. This
-    // functionality has to be invoked on the IO thread.
+
+  // AppCache or post data needs some handling on the IO thread.
+  // The request body may need blob handles to be added to it. This
+  // functionality has to be invoked on the IO thread.
+  if (appcache_handle || new_request->request_body.get()) {
+    ResourceType resource_type = request_info_->is_main_frame
+                                     ? RESOURCE_TYPE_MAIN_FRAME
+                                     : RESOURCE_TYPE_SUB_FRAME;
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        base::Bind(&HandleRequestsWithBody,
-                   base::Passed(&new_request),
-                   resource_context,
-                   weak_factory_.GetWeakPtr()));
+        base::Bind(
+            &PrepareNavigationOnIOThread, base::Passed(std::move(new_request)),
+            resource_context, resource_type, appcache_handle->core(),
+            base::Bind(&NavigationURLLoaderNetworkService::StartURLRequest,
+                       weak_factory_.GetWeakPtr())));
     return;
   }
-
-  StartURLRequest(std::move(new_request));
+  StartURLRequest(mojom::URLLoaderFactoryPtrInfo(), std::move(new_request));
 }
 
 NavigationURLLoaderNetworkService::~NavigationURLLoaderNetworkService() {}
 
 void NavigationURLLoaderNetworkService::OverrideURLLoaderFactoryForTesting(
     mojom::URLLoaderFactoryPtr url_loader_factory) {
   g_url_loader_factory.Get() = std::move(url_loader_factory);
 }
 
 void NavigationURLLoaderNetworkService::FollowRedirect() {
@@ skipping 62 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);
   }
 }
 
 void NavigationURLLoaderNetworkService::StartURLRequest(
+    mojom::URLLoaderFactoryPtrInfo url_loader_factory_info,
     std::unique_ptr<ResourceRequest> request) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
+  // Bind the URLClient implementation to this object to pass to the URLLoader.
+  if (binding_.is_bound())
+    binding_.Unbind();
+
   mojom::URLLoaderClientPtr url_loader_client_ptr_to_pass;
   binding_.Bind(&url_loader_client_ptr_to_pass);
 
   mojom::URLLoaderFactory* factory = nullptr;
   // This |factory_ptr| will be destroyed when it goes out of scope. Because
   // |url_loader_associated_ptr_| is associated with it, it will be disconnected
   // as well. That means NavigationURLLoaderNetworkService::FollowRedirect()
   // won't work as expected, the |url_loader_associated_ptr_| will silently drop
   // calls.
   // This is fine for now since the only user of this is WebUI which doesn't
   // need this, but we'll have to fix this when other consumers come up.
   mojom::URLLoaderFactoryPtr factory_ptr;
   const auto& schemes = URLDataManagerBackend::GetWebUISchemes();
   if (std::find(schemes.begin(), schemes.end(), request->url.scheme()) !=
       schemes.end()) {
     FrameTreeNode* frame_tree_node =
         FrameTreeNode::GloballyFindByID(request_info_->frame_tree_node_id);
     factory_ptr = GetWebUIURLLoader(frame_tree_node);
     factory = factory_ptr.get();
   }
 
-  if (!factory)
-    factory = GetURLLoaderFactory();
+  if (!factory) {
+    // If a URLLoaderFactory was provided, then we use that one, otherwise
+    // fall back to connecting directly to the network service.
+    if (url_loader_factory_info.is_valid()) {
+      url_loader_factory_.Bind(std::move(url_loader_factory_info));
+      factory = url_loader_factory_.get();
+    } else {
+      factory = GetURLLoaderFactory();
+    }
+  }
 
   factory->CreateLoaderAndStart(mojo::MakeRequest(&url_loader_associated_ptr_),
                                 0 /* routing_id? */, 0 /* request_id? */,
                                 mojom::kURLLoadOptionSendSSLInfo, *request,
                                 std::move(url_loader_client_ptr_to_pass));
 }
 
 mojom::URLLoaderFactory*
 NavigationURLLoaderNetworkService::GetURLLoaderFactory() {
   // TODO(yzshen): We will need the ability to customize the factory per frame
   // e.g., for appcache or service worker.
   if (!g_url_loader_factory.Get()) {
     ServiceManagerConnection::GetForProcess()->GetConnector()->BindInterface(
         mojom::kNetworkServiceName, &g_url_loader_factory.Get());
   }
 
   return g_url_loader_factory.Get().get();
 }
 
 }  // namespace content