Add support for subresource request loads in AppCache for the network service.

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 "base/command_line.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_subresource_url_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/public/common/content_features.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 63 matching lines @@
 
   std::unique_ptr<AppCacheJob> job;
   if (is_main_resource())
     job = MaybeLoadMainResource(network_delegate);
   else
     job = MaybeLoadSubResource(network_delegate);
 
   // If its been setup to deliver a network response, we can just delete
   // it now and return NULL instead to achieve that since it couldn't
   // have been started yet.
-  if (job && job->IsDeliveringNetworkResponse()) {
+  if (job && job->IsDeliveringNetworkResponse() && !job->AsURLLoaderJob()) {
     DCHECK(!job->IsStarted());
     job.reset();
   }
 
   return job.release();
 }
 
 AppCacheJob* AppCacheRequestHandler::MaybeLoadFallbackForRedirect(
     net::NetworkDelegate* network_delegate,
     const GURL& location) {
@@ skipping 116 matching lines @@
 // 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->set_network_url_loader_factory_getter(url_loader_factory_getter);
+  handler->network_url_loader_factory_getter_ = url_loader_factory_getter;
+  handler->appcache_host_ = appcache_handle_core->host()->GetWeakPtr();
   return handler;
 }
 
+void AppCacheRequestHandler::SetSubresourceRequestLoadInfo(
+    std::unique_ptr<SubresourceLoadInfo> subresource_load_info) {
+  subresource_load_info_ = std::move(subresource_load_info);
+}
+
 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 60 matching lines @@
   job_.reset();
 }
 
 std::unique_ptr<AppCacheJob> AppCacheRequestHandler::CreateJob(
     net::NetworkDelegate* network_delegate) {
   std::unique_ptr<AppCacheJob> job = AppCacheJob::Create(
       is_main_resource(), host_, storage(), request_.get(), network_delegate,
       base::Bind(&AppCacheRequestHandler::OnPrepareToRestart,
                  base::Unretained(this)));
   job_ = job->GetWeakPtr();
+  if (!is_main_resource() &&
+      base::FeatureList::IsEnabled(features::kNetworkService)) {
+    AppCacheURLLoaderJob* loader_job = job_->AsURLLoaderJob();
+
+    loader_job->SetSubresourceLoadInfo(
+        std::move(subresource_load_info_),
+        network_url_loader_factory_getter_.get());
+  }
+
   return job;
 }
 
 // Main-resource handling ----------------------------------------------
 
 std::unique_ptr<AppCacheJob> AppCacheRequestHandler::MaybeLoadMainResource(
     net::NetworkDelegate* network_delegate) {
   DCHECK(!job_.get());
   DCHECK(host_);
 
@@ skipping 201 matching lines @@
     const ResourceRequest& resource_request,
     ResourceContext* resource_context,
     LoaderCallback callback) {
   // MaybeLoadMainResource will invoke navigation_request_job's methods
   // asynchronously via AppCacheStorage::Delegate.
   navigation_request_job_ = MaybeLoadMainResource(nullptr);
   if (!navigation_request_job_.get()) {
     std::move(callback).Run(StartLoaderCallback());
     return;
   }
-  navigation_request_job_->AsURLLoaderJob()->set_loader_callback(
+  navigation_request_job_->AsURLLoaderJob()->set_main_resource_loader_callback(
       std::move(callback));
 }
 
 mojom::URLLoaderFactoryPtr
 AppCacheRequestHandler::MaybeCreateSubresourceFactory() {
-  return AppCacheSubresourceURLFactory::CreateURLLoaderFactory(
-      network_url_loader_factory_getter_.get());
+  mojom::URLLoaderFactoryPtr factory_ptr = nullptr;
+
+  // The factory is destroyed when the renderer drops the connection.
+  AppCacheSubresourceURLFactory::CreateURLLoaderFactory(
+      network_url_loader_factory_getter_.get(), appcache_host_, &factory_ptr);
+
+  return factory_ptr;
 }
 
 }  // namespace content