Get main frame and subframe AppCache loads to work.

content/browser/appcache/appcache_request_handler.cc

 // Copyright (c) 2011 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/appcache/appcache_request_handler.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "content/browser/appcache/appcache.h"
 #include "content/browser/appcache/appcache_backend_impl.h"
+#include "content/browser/appcache/appcache_host.h"
+#include "content/browser/appcache/appcache_navigation_handle_core.h"
 #include "content/browser/appcache/appcache_policy.h"
 #include "content/browser/appcache/appcache_request.h"
+#include "content/browser/appcache/appcache_url_loader_factory.h"
+#include "content/browser/appcache/appcache_url_loader_job.h"
+#include "content/browser/appcache/appcache_url_loader_request.h"
 #include "content/browser/appcache/appcache_url_request_job.h"
 #include "content/browser/service_worker/service_worker_request_handler.h"
+#include "content/browser/url_loader_factory_getter.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_job.h"
 
 namespace content {
 
 AppCacheRequestHandler::AppCacheRequestHandler(
     AppCacheHost* host,
     ResourceType resource_type,
     bool should_reset_appcache,
     std::unique_ptr<AppCacheRequest> request)
@@ skipping 190 matching lines @@
 
 void AppCacheRequestHandler::MaybeCompleteCrossSiteTransferInOldProcess(
     int old_process_id) {
   if (!host_ || !host_for_cross_site_transfer_.get() ||
       old_process_id != old_process_id_) {
     return;
   }
   CompleteCrossSiteTransfer(old_process_id_, old_host_id_);
 }
 
+// static
+std::unique_ptr<AppCacheRequestHandler>
+AppCacheRequestHandler::InitializeForNavigationNetworkService(
+    const ResourceRequest& request,
+    AppCacheNavigationHandleCore* appcache_handle_core,
+    URLLoaderFactoryGetter* url_loader_factory_getter) {
+  std::unique_ptr<AppCacheRequestHandler> handler =
+      appcache_handle_core->host()->CreateRequestHandler(
+          AppCacheURLLoaderRequest::Create(request), request.resource_type,
+          request.should_reset_appcache);
+  handler->url_loader_factory_getter_ = url_loader_factory_getter;
+  return handler;
+}
+
 void AppCacheRequestHandler::OnDestructionImminent(AppCacheHost* host) {
   storage()->CancelDelegateCallbacks(this);
   host_ = NULL;  // no need to RemoveObserver, the host is being deleted
 
   // Since the host is being deleted, we don't have to complete any job
   // that is current running. It's destined for the bit bucket anyway.
   if (job_.get()) {
     job_->Kill();
     job_.reset();
   }
@@ skipping 21 matching lines @@
   DCHECK(host_ && job_.get() && job_->IsWaiting());
   DCHECK(entry.has_response_id());
 
   // Cache information about the response, for use by GetExtraResponseInfo.
   cache_id_ = cache_id;
   manifest_url_ = manifest_url;
 
   if (IsResourceTypeFrame(resource_type_) && !namespace_entry_url.is_empty())
     host_->NotifyMainResourceIsNamespaceEntry(namespace_entry_url);
 
+  if (navigation_request_job_.get()) {
+    AppCacheURLLoaderFactory::CreateURLLoaderFactory(
+        mojo::MakeRequest(&appcache_factory_),
+        url_loader_factory_getter_.get(),
+        navigation_request_job_.release());
+    std::move(loader_factory_callback_).Run(appcache_factory_.get());
+  }
   job_->DeliverAppCachedResponse(manifest_url, cache_id, entry, is_fallback);
 }
 
 void AppCacheRequestHandler::DeliverErrorResponse() {
   DCHECK(job_.get() && job_->IsWaiting());
   DCHECK_EQ(kAppCacheNoCacheId, cache_id_);
   DCHECK(manifest_url_.is_empty());
   job_->DeliverErrorResponse();
 }
 
 void AppCacheRequestHandler::DeliverNetworkResponse() {
   DCHECK(job_.get() && job_->IsWaiting());
   DCHECK_EQ(kAppCacheNoCacheId, cache_id_);
   DCHECK(manifest_url_.is_empty());
+
+  // In network service land, if we are processing a navigation request, we
+  // need to inform the loader callback that we are not going to handle this
+  // request.
+  if (navigation_request_job_.get()) {
+    std::move(loader_factory_callback_).Run(nullptr);
+    navigation_request_job_.reset(nullptr);
+    return;
+  }
+
   job_->DeliverNetworkResponse();
 }
 
 void AppCacheRequestHandler::OnPrepareToRestart() {
   DCHECK(job_->IsDeliveringNetworkResponse() || job_->IsCacheEntryNotFound());
 
   // Any information about the source of the response is no longer relevant.
   cache_id_ = kAppCacheNoCacheId;
   manifest_url_ = GURL();
 
@@ skipping 18 matching lines @@
 // Main-resource handling ----------------------------------------------
 
 std::unique_ptr<AppCacheJob> AppCacheRequestHandler::MaybeLoadMainResource(
     net::NetworkDelegate* network_delegate) {
   DCHECK(!job_.get());
   DCHECK(host_);
 
   // If a page falls into the scope of a ServiceWorker, any matching AppCaches
   // should be ignored. This depends on the ServiceWorker handler being invoked
   // prior to the AppCache handler.
-  if (ServiceWorkerRequestHandler::IsControlledByServiceWorker(
+  // TODO(ananta)
+  // We need to handle this for AppCache requests initiated for the network
+  // service
+  if (request_->GetURLRequest() &&
+      ServiceWorkerRequestHandler::IsControlledByServiceWorker(
           request_->GetURLRequest())) {
     host_->enable_cache_selection(false);
     return nullptr;
   }
 
+  if (storage()->IsInitialized() &&
+      service_->storage()->usage_map()->find(request_->GetURL().GetOrigin()) ==
+          service_->storage()->usage_map()->end()) {
+    return nullptr;
+  }
+
   host_->enable_cache_selection(true);
 
   const AppCacheHost* spawning_host =
       (resource_type_ == RESOURCE_TYPE_SHARED_WORKER) ?
       host_ : host_->GetSpawningHost();
   GURL preferred_manifest_url = spawning_host ?
       spawning_host->preferred_manifest_url() : GURL();
 
   // We may have to wait for our storage query to complete, but
   // this query can also complete syncrhonously.
@@ skipping 161 matching lines @@
 
   if (!host_->associated_cache() ||
       !host_->associated_cache()->is_complete()) {
     DeliverNetworkResponse();
     return;
   }
 
   ContinueMaybeLoadSubResource();
 }
 
+void AppCacheRequestHandler::MaybeCreateLoaderFactory(
+    const ResourceRequest& resource_request,
+    ResourceContext* resource_context,
+    LoaderFactoryCallback callback) {

[kinuko, 2017/06/06 08:07:30]

(As michael wrote we're likely changing this part, but feel free to land this
first if this one gets ready first)

[ananta, 2017/06/06 20:49:15]

Will keep an eye out :)

+  navigation_request_job_ = MaybeLoadMainResource(nullptr);
+  if (!navigation_request_job_.get()) {
+    std::move(callback).Run(nullptr);
+    return;
+  }
+  navigation_request_job_->AsURLLoaderJob()->SetURLLoaderFactoryGetter(
+      url_loader_factory_getter_.get());
+  loader_factory_callback_ = std::move(callback);
+}
+
 }  // namespace content