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 88 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, *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;
+
+    // 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 (MaybeLoadFallbackForRedirect(head, redirect_info))
+      return;

[kinuko, 2017/07/25 07:12:05]

In my understanding we don't need this code at least for appcache, as we don't
seem to intercept cross-origin redirects for main resource?

[ananta, 2017/07/25 22:33:00]

I think we need this code for same origin redirects?

[kinuko, 2017/07/25 23:23:14]

I was looking into this code where it seems we're returning nullptr if it's main
resource:
https://cs.chromium.org/chromium/src/content/browser/appcache/appcache_reques...

but I could be reading the code wrongly.

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

Right! We don't need redirect fallback handling for the main resource.

+
     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;
+
+    for (size_t index = 0; index < handlers_.size(); ++index) {
+      if (handlers_[index]->MaybeGetFallbackForResponse(
+              response, &fallback_client, &fallback_request)) {

[kinuko, 2017/07/25 07:12:05]

Hmm. Sorry I think I'm repeating the same comment but I do like to avoid this
plumbing if possible as well.

One thing I heard from michael is that we should be able to tell whether we have
fallback handler for a request or not by the time MaybeCreateLoader completes. 
Would that mean that we could still intercept the request handling if it has a
fallback handler for the URL, just proxy it to the network and supply the
fallback whenever necessary?

[kinuko, 2017/07/25 07:28:42]

Or we could probably make MaybeCreateLoader take an additional LoaderCallback
parameter, like response_loader_callback... but if we can just do this within
appcache request handler I that'd feel much better imo.

[jam, 2017/07/25 18:14:15]

Yep this is what I meant :) it's a change from the old code works, but that's
irrelevant IMO. The appcache URLLoader would intercept all origins for which it
could possibly serve fallback content.

[ananta, 2017/07/25 22:33:00]

I am not sure if transparently proxying to the n/w from the appcache handler is
a good idea. Perhaps we can return a signal from the handler that it has
fallback potentially so the service can call out to it. That also means that the
NavigationURLLoaderNetworkService has to have code to specifically request
fallback. I am unsure if that is cleaner than adding the methods to the handler
interface.

[ananta, 2017/07/25 22:33:00]

Perhaps I am missing something here. Seems like it is desirable that the
handlers don't directly call out to the network. We always want the other
handlers later in the list to get control?

[kinuko, 2017/07/25 23:23:13]

Hm, it sounds like a good point.

[jam, 2017/07/26 01:40:51]

Can you expand on why it's desirable that the appcache handler doesn't call out
to the network? Is that in case it redirects to service worker?

[kinuko, 2017/07/26 01:59:14]

One of the cases that come to my mind is like:
- appcache has a fallback handler for a URL, but doesn't handle the request
- SW is registered there, so that SW needs to serve the response whenever
possible
- While SW is not activated the appcache should still be able to give its
fallback response

I think some sites use this trick...

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

I think its easier to reason about too if the appcache loader just loads
appcached resources. Also having fewer ways in which the network loader is used
reduces code paths and the potential for different behavior depending on which
one is used.

+        OnFallbackHandlerFound();
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Returns true if a handler returns a fallback response for the redirect.
+  bool MaybeLoadFallbackForRedirect(const ResourceResponseHead& response,
+                                    const net::RedirectInfo& redirect_info) {
+    mojom::URLLoaderClientPtr fallback_client;
+    mojom::URLLoaderRequest fallback_request;
+    if (!CreateFallbackClientAndRequest(&fallback_client, &fallback_request))
+      return false;
+
+    for (size_t index = 0; index < handlers_.size(); ++index) {
+      if (handlers_[index]->MaybeGetFallbackForRedirect(
+              response, redirect_info, &fallback_client, &fallback_request)) {
+        OnFallbackHandlerFound();
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // 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 requests which were not sent to the network loader.
+    if (!default_loader_used_)
+      return false;
+    fallback_response_binding_.Bind(mojo::MakeRequest(client));
+    *request = mojo::MakeRequest(&fallback_url_loader_);
+    return true;
+  }
+
+  // Called if we find a handler who delivers fallback content for the URL.
+  void OnFallbackHandlerFound() {
+    // 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();
+  }
+
   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_;
+
   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