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

content/browser/loader/navigation_url_loader_network_service.cc

 // Copyright 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/loader/navigation_url_loader_network_service.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 87 matching lines @@
     : public mojom::URLLoaderClient {
  public:
   URLLoaderRequestController(
       std::unique_ptr<ResourceRequest> resource_request,
       ResourceContext* resource_context,
       scoped_refptr<URLLoaderFactoryGetter> default_url_loader_factory_getter,
       const base::WeakPtr<NavigationURLLoaderNetworkService>& owner)
       : 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);
   }
 
   void Start(
       ServiceWorkerNavigationHandleCore* service_worker_navigation_handle_core,
       AppCacheNavigationHandleCore* appcache_handle_core,
       std::unique_ptr<NavigationRequestInfo> request_info,
       mojom::URLLoaderFactoryPtrInfo factory_for_webui,
@@ skipping 51 matching lines @@
       if (appcache_handler)
         handlers_.push_back(std::move(appcache_handler));
     }
 
     Restart();
   }
 
   // This could be called multiple times.
   void Restart() {
     handler_index_ = 0;
+    received_response_ = false;
     MaybeStartLoader(StartLoaderCallback());
   }
 
   void MaybeStartLoader(StartLoaderCallback start_loader_callback) {
     if (start_loader_callback) {
       url_loader_ = ThrottlingURLLoader::CreateLoaderAndStart(
           std::move(start_loader_callback),
           GetContentClient()->browser()->CreateURLLoaderThrottles(
               web_contents_getter_),
           *resource_request_, this, kTrafficAnnotation);
@@ skipping 16 matching lines @@
                          base::Unretained(this)));
       return;
     }
 
     mojom::URLLoaderFactory* factory = nullptr;
     DCHECK_EQ(handlers_.size(), handler_index_);
     if (resource_request_->url.SchemeIs(url::kBlobScheme)) {
       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,
         GetContentClient()->browser()->CreateURLLoaderThrottles(
             web_contents_getter_),
         0 /* routing_id? */, 0 /* request_id? */,
         mojom::kURLLoadOptionSendSSLInfo | mojom::kURLLoadOptionSniffMimeType,
         *resource_request_, this, kTrafficAnnotation);
   }
 
   void FollowRedirect() {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     DCHECK(url_loader_);
 
+    DCHECK(!response_url_loader_);
+
     url_loader_->FollowRedirect();
   }
 
   // Ownership of the URLLoaderFactoryPtrInfo instance is transferred to the
   // caller.
   mojom::URLLoaderFactoryPtrInfo GetSubresourceURLLoaderFactory() {
     return std::move(subresource_url_loader_factory_ptr_info_);
   }
 
  private:
   // mojom::URLLoaderClient implementation:
   void OnReceiveResponse(
       const ResourceResponseHead& head,
       const base::Optional<net::SSLInfo>& ssl_info,
       mojom::DownloadedTempFilePtr downloaded_file) override {
+    received_response_ = true;
+    // 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,
                    owner_, head, ssl_info, base::Passed(&downloaded_file)));
   }
 
   void OnReceiveRedirect(const net::RedirectInfo& redirect_info,
                          const ResourceResponseHead& head) override {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
@@ skipping 15 matching lines @@
       mojo::ScopedDataPipeConsumerHandle body) override {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(
             &NavigationURLLoaderNetworkService::OnStartLoadingResponseBody,
             owner_, base::Passed(&body)));
   }
 
   void OnComplete(
       const ResourceRequestCompletionStatus& completion_status) override {
+    if (completion_status.error_code != net::OK && !received_response_) {
+      // 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(ResourceResponseHead()))
+        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;
+
+    // URLLoaderClient request pointer for response loaders, i.e loaders created
+    // for handing responses received from the network URLLoader.
+    mojom::URLLoaderClientRequest response_client_request;
+
+    for (size_t index = 0; index < handlers_.size(); ++index) {
+      if (handlers_[index]->MaybeCreateLoaderForResponse(
+              response, &response_url_loader_, &response_client_request)) {
+        OnResponseHandlerFound(std::move(response_client_request));
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Called if we find a handler who delivers different content for the URL.
+  void OnResponseHandlerFound(
+      mojom::URLLoaderClientRequest response_client_request) {
+    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;
 
   std::unique_ptr<ResourceRequest> resource_request_;
   ResourceContext* resource_context_;
   base::Callback<WebContents*()> web_contents_getter_;
 
   scoped_refptr<URLLoaderFactoryGetter> default_url_loader_factory_getter_;
 
   mojom::URLLoaderFactoryPtr webui_factory_ptr_;
 
   std::unique_ptr<ThrottlingURLLoader> url_loader_;
 
   BlobHandles blob_handles_;
 
   // Currently used by the AppCache loader to pass its factory to the
   // renderer which enables it to handle subresources.
   mojom::URLLoaderFactoryPtrInfo subresource_url_loader_factory_ptr_info_;
 
   // 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;
+
+  // 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_;
+
+  // Set to true if we receive a valid response from a URLLoader, i.e.
+  // URLLoaderClient::OnReceivedResponse() is called.
+  bool received_response_ = false;
+
   DISALLOW_COPY_AND_ASSIGN(URLLoaderRequestController);
 };
 
 NavigationURLLoaderNetworkService::NavigationURLLoaderNetworkService(
     ResourceContext* resource_context,
     StoragePartition* storage_partition,
     std::unique_ptr<NavigationRequestInfo> request_info,
     std::unique_ptr<NavigationUIData> navigation_ui_data,
     ServiceWorkerNavigationHandle* service_worker_navigation_handle,
     AppCacheNavigationHandle* appcache_handle,
@@ skipping 135 matching lines @@
     TRACE_EVENT_ASYNC_END2("navigation", "Navigation timeToResponseStarted",
                            this, "&NavigationURLLoaderNetworkService", this,
                            "success", false);
 
     delegate_->OnRequestFailed(completion_status.exists_in_cache,
                                completion_status.error_code);
   }
 }
 
 }  // namespace content