Add support for subresource request fallback 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"
@@ skipping 109 matching lines @@
     return NULL;
   if (is_main_resource())
     return NULL;
   // TODO(vabr) This is a temporary fix (see crbug/141114). We should get rid of
   // it once a more general solution to crbug/121325 is in place.
   if (!maybe_load_resource_executed_)
     return NULL;
   if (request_->GetURL().GetOrigin() == location.GetOrigin())
     return NULL;
 
-  DCHECK(!job_.get());  // our jobs never generate redirects
+  // In network service land, the existing job initiates a fallback request.
+  if (!base::FeatureList::IsEnabled(features::kNetworkService)) {
+    DCHECK(!job_.get());  // our jobs never generate redirects
+  } else {
+    DCHECK(job_.get());
+  }
 
   std::unique_ptr<AppCacheJob> job;
   if (found_fallback_entry_.has_response_id()) {
+    job = MaybeCreateJobForFallback(network_delegate);
     // 6.9.6, step 4: If this results in a redirect to another origin,
     // get the resource of the fallback entry.
-    job = CreateJob(network_delegate);
     DeliverAppCachedResponse(found_fallback_entry_, found_cache_id_,
                              found_manifest_url_, true,
                              found_namespace_entry_url_);
   } else if (!found_network_namespace_) {
     // 6.9.6, step 6: Fail the resource load.
-    job = CreateJob(network_delegate);
+    job = MaybeCreateJobForFallback(network_delegate);
     DeliverErrorResponse();
   } else {
     // 6.9.6 step 3 and 5: Fetch the resource normally.
   }
 
   return job.release();
 }
 
 AppCacheJob* AppCacheRequestHandler::MaybeLoadFallbackForResponse(
     net::NetworkDelegate* network_delegate) {
   if (!host_ ||
       !AppCacheRequest::IsSchemeAndMethodSupportedForAppCache(request_.get()) ||
       cache_entry_not_found_)
     return NULL;
   if (!found_fallback_entry_.has_response_id())
     return NULL;
 
   if (request_->IsCancelled()) {
     // 6.9.6, step 4: But not if the user canceled the download.
     return NULL;
   }
 
   // We don't fallback for responses that we delivered.
-  if (job_.get()) {
+  if (job_.get() && !base::FeatureList::IsEnabled(features::kNetworkService)) {
     DCHECK(!job_->IsDeliveringNetworkResponse());
     return NULL;
   }
 
   if (request_->IsSuccess()) {
     int code_major = request_->GetResponseCode() / 100;
     if (code_major !=4 && code_major != 5)
       return NULL;
 
     // Servers can override the fallback behavior with a response header.
     const std::string kFallbackOverrideHeader(
         "x-chromium-appcache-fallback-override");
     const std::string kFallbackOverrideValue(
         "disallow-fallback");
     std::string header_value;
     header_value = request_->GetResponseHeaderByName(kFallbackOverrideHeader);
     if (header_value == kFallbackOverrideValue)
       return NULL;
   }
 
   // 6.9.6, step 4: If this results in a 4xx or 5xx status code
   // or there were network errors, get the resource of the fallback entry.
-  std::unique_ptr<AppCacheJob> job = CreateJob(network_delegate);
+
+  // In network service land, the job initiates a fallback request. We reuse
+  // the existing job to deliver the fallback response.
+  std::unique_ptr<AppCacheJob> job =
+      MaybeCreateJobForFallback(network_delegate);
+
   DeliverAppCachedResponse(found_fallback_entry_, found_cache_id_,
                            found_manifest_url_, true,
                            found_namespace_entry_url_);
   return job.release();
 }
 
 void AppCacheRequestHandler::GetExtraResponseInfo(int64_t* cache_id,
                                                   GURL* manifest_url) {
   *cache_id = cache_id_;
   *manifest_url = manifest_url_;
@@ skipping 135 matching lines @@
     AppCacheURLLoaderJob* loader_job = job_->AsURLLoaderJob();
 
     loader_job->SetSubresourceLoadInfo(
         std::move(subresource_load_info_),
         network_url_loader_factory_getter_.get());
   }
 
   return job;
 }
 
+std::unique_ptr<AppCacheJob> AppCacheRequestHandler::MaybeCreateJobForFallback(
+    net::NetworkDelegate* network_delegate) {
+  if (!base::FeatureList::IsEnabled(features::kNetworkService))
+    return CreateJob(network_delegate);
+  // In network service land, the job initiates a fallback request. We reuse
+  // the existing job to deliver the fallback response.
+  DCHECK(job_.get());
+  return std::unique_ptr<AppCacheJob>(job_.get());
+}
+
 // 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.
@@ skipping 214 matching lines @@
   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