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 206 matching lines @@
 
   associated_binding_.reset(new mojo::AssociatedBinding<mojom::URLLoader>(
       this, std::move(subresource_load_info_->url_loader_request)));
   associated_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) && !client_) {

[michaeln, 2017/07/26 23:08:41]

i don't understand the purpose of the !client_ check and why that affects
whether we could invoke the loader_callback?

[ananta, 2017/07/27 02:40:25]

For fallback responses the callback would be null. I changed the check to
validate
if the callback is valid.

       DCHECK(!main_resource_loader_callback_.is_null());
       std::move(main_resource_loader_callback_)
           .Run(base::Bind(&AppCacheURLLoaderJob::Start, StaticAsWeakPtr(this)));
     }
 
     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.
@@ skipping 136 matching lines @@
     DCHECK(false);
     NotifyCompleted(net::ERR_FAILED);
   }
   ReadMore();
 }
 
 void AppCacheURLLoaderJob::NotifyCompleted(int error_code) {
   if (storage_.get())
     storage_->CancelDelegateCallbacks(this);
 
-  const net::HttpResponseInfo* http_info = is_range_request()
-                                               ? range_response_info_.get()
-                                               : info_->http_response_info();
+  const net::HttpResponseInfo* http_info =
+      is_range_request() ? range_response_info_.get()
+                         : (info_ ? info_->http_response_info() : nullptr);
 
   ResourceRequestCompletionStatus request_complete_data;
   request_complete_data.error_code = error_code;
 
   // TODO(ananta)
   // Fill other details in the ResourceRequestCompletionStatus structure in
   // case of an error.
   if (!request_complete_data.error_code) {
     request_complete_data.exists_in_cache = http_info->was_cached;
     request_complete_data.completion_time = base::TimeTicks::Now();
     request_complete_data.encoded_body_length =
         is_range_request() ? range_response_info_->headers->GetContentLength()
-                           : info_->response_data_size();
+                           : (info_ ? info_->response_data_size() : 0);
     request_complete_data.decoded_body_length =
         request_complete_data.encoded_body_length;
   }
   client_->OnComplete(request_complete_data);
 }
 
 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