Add a stub implementation of the URLLoaderFactory for AppCache.

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"
 #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/resource_context_impl.h"
 #include "content/browser/service_worker/service_worker_navigation_handle.h"
 #include "content/browser/service_worker/service_worker_navigation_handle_core.h"
 #include "content/browser/service_worker/service_worker_request_handler.h"
@@ skipping 62 matching lines @@
     url_loader_factory_ptr =
         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);
   }
 
-  // TODO(scottmg): We need to rework AppCache to have it return a
-  // URLLoaderFactoryPtr[Info] here. We should also try to have it return
-  // synchronously in as many cases as possible (especially when there's no
-  // AppCache) to simplify and speed the common case.
-  if (false /*appcache_handle_core*/) {
-    AppCacheRequestHandler::InitializeForNavigationNetworkService(
-        std::move(resource_request), resource_context, appcache_handle_core,
-        resource_type,
-        base::Callback<void(
-            mojom::URLLoaderFactoryPtrInfo,
-            std::unique_ptr<ResourceRequest>)>() /* TODO(ananta) */);
-    return;
-  }
-
   // If we haven't gotten one from the above, then use the one the UI thread
   // gave us, or otherwise fallback to the default.
   mojom::URLLoaderFactory* factory;
   if (url_loader_factory_ptr) {
     factory = url_loader_factory_ptr.get();
   } else {
     if (factory_from_ui.is_valid()) {
       url_loader_factory_ptr.Bind(std::move(factory_from_ui));
       factory = url_loader_factory_ptr.get();
     } else {
-      factory = url_loader_factory_getter->GetNetworkFactory()->get();
+      if (appcache_handle_core) {
+        factory = url_loader_factory_getter->GetAppCacheFactory()->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_to_pass));
 }
 
 }  // 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_navigation_handle,
     AppCacheNavigationHandle* appcache_handle,
     NavigationURLLoaderDelegate* delegate)
     : delegate_(delegate),
       binding_(this),
-      request_info_(std::move(request_info)) {
+      request_info_(std::move(request_info)),
+      request_id_(-1) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   TRACE_EVENT_ASYNC_BEGIN_WITH_TIMESTAMP1(
       "navigation", "Navigation timeToResponseStarted", this,
       request_info_->common_params.navigation_start, "FrameTreeNode id",
       request_info_->frame_tree_node_id);
 
   // TODO(scottmg): Port over stuff from RDHI::BeginNavigationRequest() here.
   auto new_request = base::MakeUnique<ResourceRequest>();
 
@@ skipping 33 matching lines @@
   mojom::URLLoaderFactoryPtrInfo factory_ptr_info;
 
   const auto& schemes = URLDataManagerBackend::GetWebUISchemes();
   if (std::find(schemes.begin(), schemes.end(), new_request->url.scheme()) !=
       schemes.end()) {
     FrameTreeNode* frame_tree_node =
         FrameTreeNode::GloballyFindByID(request_info_->frame_tree_node_id);
     factory_ptr_info = GetWebUIURLLoader(frame_tree_node).PassInterface();
   }
 
+  request_id_--;

[jam, 2017/05/19 00:03:50]

this class is created for each navigation request, so all of them would have the
same ID (RDH is global, so it ends up creating different ones). So either hard
code -2 below, as that what is effectively happening, or move this to be a
global.

[ananta, 2017/05/19 00:23:13]

Thanks. I made it a global

+
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&PrepareNavigationStartOnIO,
                  base::Passed(std::move(new_request)), resource_context,
                  service_worker_navigation_handle
                      ? service_worker_navigation_handle->core()
                      : nullptr,
                  appcache_handle ? appcache_handle->core() : nullptr,
                  request_info_.get(), base::Passed(std::move(factory_ptr_info)),
                  static_cast<StoragePartitionImpl*>(storage_partition)
@@ skipping 58 matching lines @@
 
   TRACE_EVENT_ASYNC_END2("navigation", "Navigation timeToResponseStarted", this,
                          "&NavigationURLLoaderNetworkService", this, "success",
                          true);
 
   // Temporarily, we pass both a stream (null) and the data pipe to the
   // delegate until PlzNavigate has shipped and we can be comfortable fully
   // switching to the data pipe.
   delegate_->OnResponseStarted(response_, nullptr, std::move(body), ssl_status_,
                                std::unique_ptr<NavigationData>(),
-                               GlobalRequestID() /* request_id? */,
+                               GlobalRequestID(-1, request_id_),
                                false /* is_download? */, false /* is_stream */);
 }
 
 void NavigationURLLoaderNetworkService::OnComplete(
     const ResourceRequestCompletionStatus& completion_status) {
   if (completion_status.error_code != net::OK) {
     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