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

content/browser/appcache/appcache_url_loader_job.cc

 // Copyright (c) 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/appcache/appcache_url_loader_job.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "content/browser/appcache/appcache_histograms.h"
 #include "content/browser/appcache/appcache_subresource_url_factory.h"
 #include "content/browser/appcache/appcache_url_loader_request.h"
@@ skipping 57 matching lines @@
   delivery_type_ = NETWORK_DELIVERY;
 
   AppCacheHistograms::AddNetworkJobStartDelaySample(base::TimeTicks::Now() -
                                                     start_time_tick_);
 
   if (IsResourceTypeFrame(request_.resource_type)) {
     DCHECK(!main_resource_loader_callback_.is_null());
     // 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. The loader callback is valid only for navigation requests.
-    std::move(main_resource_loader_callback_).Run(StartLoaderCallback());
+    std::move(main_resource_loader_callback_)
+        .Run(StartLoaderCallback(), std::move(main_resource_fallback_handler_));
   } else {
     mojom::URLLoaderClientPtr client_ptr;
     network_loader_client_binding_.Bind(mojo::MakeRequest(&client_ptr));
 
     default_url_loader_factory_getter_->GetNetworkFactory()
         ->get()
         ->CreateLoaderAndStart(
             mojo::MakeRequest(&network_loader_),
             subresource_load_info_->routing_id,
             subresource_load_info_->request_id, subresource_load_info_->options,
@@ skipping 127 matching lines @@
   subresource_load_info_ = std::move(subresource_load_info);
 
   binding_.Bind(std::move(subresource_load_info_->url_loader_request));
   binding_.set_connection_error_handler(base::Bind(
       &AppCacheURLLoaderJob::OnConnectionError, StaticAsWeakPtr(this)));
 
   client_ = std::move(subresource_load_info_->client);
   default_url_loader_factory_getter_ = default_url_loader;
 }
 
+void AppCacheURLLoaderJob::BindRequest(mojom::URLLoaderClientPtr client,
+                                       mojom::URLLoaderRequest request) {
+  DCHECK(!binding_.is_bound());
+  binding_.Bind(std::move(request));
+
+  client_ = std::move(client);
+
+  binding_.set_connection_error_handler(base::Bind(
+      &AppCacheURLLoaderJob::OnConnectionError, StaticAsWeakPtr(this)));
+}
+
 void AppCacheURLLoaderJob::Start(mojom::URLLoaderRequest request,
                                  mojom::URLLoaderClientPtr client) {
-  DCHECK(!binding_.is_bound());
-  binding_.Bind(std::move(request));
-
-  binding_.set_connection_error_handler(base::Bind(
-      &AppCacheURLLoaderJob::OnConnectionError, StaticAsWeakPtr(this)));
-
-  client_ = std::move(client);
-
+  BindRequest(std::move(client), std::move(request));
   // Send the cached AppCacheResponse if any.
   if (info_.get())
     SendResponseInfo();
 }
 
 AppCacheURLLoaderJob::AppCacheURLLoaderJob(
     const ResourceRequest& request,
     AppCacheURLLoaderRequest* appcache_request,
     AppCacheStorage* storage)
     : request_(request),
@@ skipping 18 matching lines @@
   }
 
   if (response_info) {
     info_ = response_info;
     reader_.reset(
         storage_->CreateResponseReader(manifest_url_, entry_.response_id()));
 
     if (is_range_request())
       SetupRangeResponse();
 
-    if (IsResourceTypeFrame(request_.resource_type)) {
+    if (IsResourceTypeFrame(request_.resource_type) &&
+        main_resource_loader_callback_) {
       DCHECK(!main_resource_loader_callback_.is_null());
       std::move(main_resource_loader_callback_)
-          .Run(base::Bind(&AppCacheURLLoaderJob::Start, StaticAsWeakPtr(this)));
+          .Run(base::Bind(&AppCacheURLLoaderJob::Start, StaticAsWeakPtr(this)),
+               ResponseFallback());
     }
 
     response_body_stream_ = std::move(data_pipe_.producer_handle);
 
     // TODO(ananta)
     // Move the asynchronous reading and mojo pipe handling code to a helper
     // class. That would also need a change to BlobURLLoader.
 
     // Wait for the data pipe to be ready to accept data.
     writable_handle_watcher_.Watch(
@@ skipping 163 matching lines @@
 }
 
 void AppCacheURLLoaderJob::DisconnectFromNetworkLoader() {
   // Close the pipe to the network loader as we are delivering a fallback
   // response to the client.
   network_loader_client_binding_.Close();
   network_loader_ = nullptr;
 }
 
 }  // namespace content