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),
+        fallback_response_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;
-    MaybeStartLoader(StartLoaderCallback());
+    MaybeStartLoader(StartLoaderCallback(), ResponseFallback());
   }
 
-  void MaybeStartLoader(StartLoaderCallback start_loader_callback) {
+  void MaybeStartLoader(StartLoaderCallback start_loader_callback,
+                        ResponseFallback fallback) {
     if (start_loader_callback) {
+      DCHECK(!fallback);
       url_loader_ = ThrottlingURLLoader::CreateLoaderAndStart(
           std::move(start_loader_callback),
           GetContentClient()->browser()->CreateURLLoaderThrottles(
               web_contents_getter_),
           *resource_request_, this, kTrafficAnnotation);
 
       DCHECK_GT(handler_index_, 0U);
 
       mojom::URLLoaderFactoryPtr subresource_loader_factory =
           handlers_[handler_index_ - 1]->MaybeCreateSubresourceFactory();
       if (subresource_loader_factory.get()) {
         subresource_url_loader_factory_ptr_info_ =
             subresource_loader_factory.PassInterface();
       }
       return;
+    } else {
+      // We only support one fallback handler at any given point. AppCache is
+      // the only handler which supports fallback responses.
+      DCHECK(!fallback_handler_);
+      fallback_handler_ = std::move(fallback);
     }
 
     if (handler_index_ < handlers_.size()) {
       handlers_[handler_index_++]->MaybeCreateLoader(
           *resource_request_, resource_context_,
           base::BindOnce(&URLLoaderRequestController::MaybeStartLoader,
                          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_);
 
     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 {
+    response_ = head;
+    // If the default loader (network) was used to handle the URL load request
+    // we need to see if the handlers want to load a fallback for the response.
+    if (MaybeLoadFallbackForResponse(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 {
+    response_ = head;
+
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&NavigationURLLoaderNetworkService::OnReceiveRedirect,
                    owner_, redirect_info, head));
   }
 
   void OnDataDownloaded(int64_t data_length, int64_t encoded_length) override {}
 
   void OnUploadProgress(int64_t current_position,
                         int64_t total_size,
                         OnUploadProgressCallback callback) override {}
 
   void OnReceiveCachedMetadata(const std::vector<uint8_t>& data) override {}
 
   void OnTransferSizeUpdated(int32_t transfer_size_diff) override {}
 
   void OnStartLoadingResponseBody(
       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 the default loader (network) was used to handle the URL load request
+    // we need to see if the handlers want to load a fallback for the response.
+    if (MaybeLoadFallbackForResponse(response_))
+      return;
+
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&NavigationURLLoaderNetworkService::OnComplete, owner_,
                    completion_status));
   }
 
+  // Returns true if a handler returns a fallback response.
+  bool MaybeLoadFallbackForResponse(const ResourceResponseHead& response) {
+    mojom::URLLoaderClientPtr fallback_client;
+    mojom::URLLoaderRequest fallback_request;
+    if (!CreateFallbackClientAndRequest(&fallback_client, &fallback_request))
+      return false;
+
+    // We reset this flag as we expect a response from the fallback handler.
+    default_loader_used_ = false;
+    // Disconnect from the network loader to stop receiving further data
+    // or notifications for the URL.
+    url_loader_->DisconnectClient();
+
+    return std::move(fallback_handler_)
+        .Run(response, std::move(fallback_client), std::move(fallback_request));

[kinuko, 2017/07/27 13:46:26]

This fallback code works in a very specific way, which might be ok within this
scope but it wouldn't be usable for other use cases.  I wonder if something like
following API would work...

 if (MaybeInterceptResponse(response, url_loader_))
   return true;

The implementation can internally call url_loader->DisconnectClient() if
necessary.  DisconnectClient() can possibly return its previous
forwarding_client_ pointer (i.e. this) so that the implementation take the
client over and call its OnFoo methods to provide response data.  The
implementation does not really need to use mojo binding for the fallback then.

In this way handler implementation needs to know about ThrottlingURLLoader which
is a little ugly, but I hope we can possibly fix it by introducing an additional
wrapper layer later (something like what Yuzhu suggested in
https://chromium-review.googlesource.com/c/567610/10/content/renderer/rendere...)

Wdyt?

[ananta, 2017/07/27 22:07:14]

It seems like the method name you suggested in an earlier iteration
MaybeCreateLoaderForResponse is better. I changed the patch to reflect that. 

I left the other parts as is at the moment. I am not sure whether passing the
ThrottlingURLLoader is better, because at the point where we are invoking the
new method, the ThrottlingURLLoader has already done its job, i.e. it has
verified the safe browsing database for the URL, etc.

Perhaps we go with this approach for now and revisit in a future patchset.

+  }
+
+  // Creates an instance of the URLLoaderClient interface which can be bound
+  // to a handler for receiving fallback responses.
+  // Returns true on success.
+  bool CreateFallbackClientAndRequest(mojom::URLLoaderClientPtr* client,
+                                      mojom::URLLoaderRequest* request) {
+    // Ignore if we don't have a fallback handler or if the request never went
+    // to the network loader.
+    if (!default_loader_used_ || !fallback_handler_)
+      return false;
+    fallback_response_binding_.Bind(mojo::MakeRequest(client));
+    *request = mojo::MakeRequest(&fallback_url_loader_);
+    return true;
+  }
+
   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;
+
+  // Contains a copy of the response.
+  ResourceResponseHead response_;
+
+  // URLLoaderClient binding for handling fallback responses.
+  mojo::Binding<mojom::URLLoaderClient> fallback_response_binding_;
+
+  // URLLoader instance for fallback responses.
+  mojom::URLLoaderPtr fallback_url_loader_;
+
+  // Fallback response handler.
+  ResponseFallback fallback_handler_;
+
   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