Add support for fallback content for the frame. This includes main and subframes.

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 297 matching lines @@
   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());
+  if (IsMainResourceType(resource_type_) &&
+      found_fallback_entry_.has_response_id() &&
+      base::FeatureList::IsEnabled(features::kNetworkService)) {
+    job_->AsURLLoaderJob()->set_main_resource_fallback_handler(
+        base::Bind(&AppCacheRequestHandler::MaybeGetFallbackForResponse,
+                   base::Unretained(this)));
+  }
   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 19 matching lines @@
     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))
+  if (!base::FeatureList::IsEnabled(features::kNetworkService) ||
+      IsMainResourceType(resource_type_)) {
     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) {
@@ skipping 199 matching lines @@
 
   ContinueMaybeLoadSubResource();
 }
 
 void AppCacheRequestHandler::MaybeCreateLoader(
     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());
+  std::unique_ptr<AppCacheJob> navigation_request_job =
+      MaybeLoadMainResource(nullptr);
+  if (!navigation_request_job.get()) {
+    std::move(callback).Run(StartLoaderCallback(), ResponseFallback());
     return;
   }
-  navigation_request_job_->AsURLLoaderJob()->set_main_resource_loader_callback(
-      std::move(callback));
+  // The AppCacheJob for the navigation request will get destroyed when the
+  // client connection is dropped.
+  navigation_request_job.release()
+      ->AsURLLoaderJob()
+      ->set_main_resource_loader_callback(std::move(callback));
 }
 
 mojom::URLLoaderFactoryPtr
 AppCacheRequestHandler::MaybeCreateSubresourceFactory() {
   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;
 }
 
+bool AppCacheRequestHandler::MaybeGetFallbackForResponse(
+    const ResourceResponseHead& response,
+    mojom::URLLoaderClientPtr client,
+    mojom::URLLoaderRequest request) {
+  request_->AsURLLoaderRequest()->set_response(response);
+  // The AppCacheJob will get destroyed when the client connection is
+  // dropped.
+  AppCacheJob* job = MaybeLoadFallbackForResponse(nullptr);
+  if (job) {
+    job->AsURLLoaderJob()->BindRequest(std::move(client), std::move(request));
+    return true;
+  }
+  return false;
+}
+
 }  // namespace content