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

content/browser/loader/navigation_url_loader_network_service.cc

Index: content/browser/loader/navigation_url_loader_network_service.cc
diff --git a/content/browser/loader/navigation_url_loader_network_service.cc b/content/browser/loader/navigation_url_loader_network_service.cc
index b821082ae37eb74b98d72706a042a7e8d621aaab..f5d43615aa91984bdcb4ae2b08adb7f1023398e3 100644
--- a/content/browser/loader/navigation_url_loader_network_service.cc
+++ b/content/browser/loader/navigation_url_loader_network_service.cc
@@ -105,7 +105,8 @@ class NavigationURLLoaderNetworkService::URLLoaderRequestController
       : resource_request_(std::move(resource_request)),
         resource_context_(resource_context),
         default_url_loader_factory_getter_(default_url_loader_factory_getter),
-        owner_(owner) {}
+        owner_(owner),
+        response_loader_binding_(this) {}
 
   ~URLLoaderRequestController() override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ -213,6 +214,7 @@ class NavigationURLLoaderNetworkService::URLLoaderRequestController
       factory = default_url_loader_factory_getter_->GetBlobFactory()->get();
     } else {
       factory = default_url_loader_factory_getter_->GetNetworkFactory()->get();
+      default_loader_used_ = true;
     }
     url_loader_ = ThrottlingURLLoader::CreateLoaderAndStart(
         factory,
@@ -242,6 +244,13 @@ class NavigationURLLoaderNetworkService::URLLoaderRequestController
       const ResourceResponseHead& head,
       const base::Optional<net::SSLInfo>& ssl_info,
       mojom::DownloadedTempFilePtr downloaded_file) override {
+    response_ = head;
+    // If the default loader (network) was used to handle the URL load request
+    // we need to see if the handlers want to potentially create a new loader
+    // for the response. e.g. AppCache.
+    if (MaybeCreateLoaderForResponse(head))
+      return;
+
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&NavigationURLLoaderNetworkService::OnReceiveResponse,
@@ -250,6 +259,8 @@ class NavigationURLLoaderNetworkService::URLLoaderRequestController
 
   void OnReceiveRedirect(const net::RedirectInfo& redirect_info,
                          const ResourceResponseHead& head) override {
+    response_ = head;
+
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&NavigationURLLoaderNetworkService::OnReceiveRedirect,
@@ -277,12 +288,45 @@ class NavigationURLLoaderNetworkService::URLLoaderRequestController
 
   void OnComplete(
       const ResourceRequestCompletionStatus& completion_status) override {
+    // If the default loader (network) was used to handle the URL load request
+    // we need to see if the handlers want to potentially create a new loader
+    // for the response. e.g. AppCache.
+    if (MaybeCreateLoaderForResponse(response_))

[michaeln, 2017/07/28 19:11:02]

I think we should only call MaybeCreateLoaderForResponse() once for each
MaybeCreateLoader() call, but it looks like we can/will call it twice in most
cases: first from OnReceivedResponse and again from OnComplete. If i understand
properly, we're calling MaybeCreateLoaderForResponse() to cover the case where
we did not receive a response at all. If that's right, I think we could make it
more clear somehow...

 if (!recieved_response_)
    MaybeCreateLoaderForResposne(NORESPONSE);

We'd have to reset recieved_response_ in Restart() for this to work.

Also, I think the only case this applied to is when completion_status is !OK.

 if (completion_status != OK && !recieved_response_)
    MaybeCreateLoaderForResposne(NORESPONSE);

... at least i think?

[ananta, 2017/07/28 22:59:22]

Thanks. I added a received_response_ flag which defaults to false and is set to
true in OnReceiveResponse(). It resets to false in Restart().

+      return;
+
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&NavigationURLLoaderNetworkService::OnComplete, owner_,
                    completion_status));
   }
 
+  // Returns true if a handler wants to handle the response, i.e. return a
+  // different response. For e.g. AppCache may have fallback content to be
+  // returned for a TLD.
+  bool MaybeCreateLoaderForResponse(const ResourceResponseHead& response) {
+    if (!default_loader_used_)
+      return false;
+
+    for (size_t index = 0; index < handlers_.size(); ++index) {
+      if (handlers_[index]->MaybeCreateLoaderForResponse(
+              response, &response_url_loader_, &response_client_request_)) {
+        OnResponseHandlerFound();
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Called if we find a handler who delivers different content for the URL.
+  void OnResponseHandlerFound() {
+    response_loader_binding_.Bind(std::move(response_client_request_));
+    // We reset this flag as we expect a new response from the handler.
+    default_loader_used_ = false;
+    // Disconnect from the network loader to stop receiving further data
+    // or notifications for the URL.
+    url_loader_->DisconnectClient();
+  }
+
   std::vector<std::unique_ptr<URLLoaderRequestHandler>> handlers_;
   size_t handler_index_ = 0;
 
@@ -305,6 +349,25 @@ class NavigationURLLoaderNetworkService::URLLoaderRequestController
   // This is referenced only on the UI thread.
   base::WeakPtr<NavigationURLLoaderNetworkService> owner_;
 
+  // Set to true if the default URLLoader (network service) was used for the
+  // current navigation.
+  bool default_loader_used_ = false;
+
+  // Contains a copy of the response.
+  ResourceResponseHead response_;
+
+  // URLLoaderClient binding for loaders created for responses received from the
+  // network loader.
+  mojo::Binding<mojom::URLLoaderClient> response_loader_binding_;
+
+  // URLLoader instance for response loaders, i.e loaders created for handing
+  // responses received from the network URLLoader.
+  mojom::URLLoaderPtr response_url_loader_;
+
+  // URLLoaderClient request pointer for response loaders, i.e loaders created
+  // for handing responses received from the network URLLoader.
+  mojom::URLLoaderClientRequest response_client_request_;

[kinuko, 2017/07/28 09:50:29]

Does this need to be kept in this field?  Can we just stack-allocate this before
calling MaybeCreateLoaderForResponse and pass it in OnResponseHandlerFound()?

[ananta, 2017/07/28 22:59:22]

Done.

+
   DISALLOW_COPY_AND_ASSIGN(URLLoaderRequestController);
 };