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

content/common/throttling_url_loader.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/common/throttling_url_loader.h"
 
 #include "base/single_thread_task_runner.h"
 
 namespace content {
 
@@ skipping 75 matching lines @@
 
 ThrottlingURLLoader::~ThrottlingURLLoader() {}
 
 void ThrottlingURLLoader::FollowRedirect() {
   if (url_loader_)
     url_loader_->FollowRedirect();
 }
 
 void ThrottlingURLLoader::SetPriority(net::RequestPriority priority,
                                       int32_t intra_priority_value) {
-  if (!url_loader_ && !cancelled_by_throttle_) {
+  if (!url_loader_ && !loader_cancelled_) {
     DCHECK_EQ(DEFERRED_START, deferred_stage_);
     priority_info_ =
         base::MakeUnique<PriorityInfo>(priority, intra_priority_value);
     return;
   }
 
   url_loader_->SetPriority(priority, intra_priority_value);
 }
 
+void ThrottlingURLLoader::DisconnectClient() {
+  client_binding_.Close();
+  url_loader_ = nullptr;
+  loader_cancelled_ = true;
+}
+
 ThrottlingURLLoader::ThrottlingURLLoader(
     std::vector<std::unique_ptr<URLLoaderThrottle>> throttles,
     mojom::URLLoaderClient* client,
     const net::NetworkTrafficAnnotationTag& traffic_annotation)
     : forwarding_client_(client),
       client_binding_(this),
       traffic_annotation_(traffic_annotation) {
   if (throttles.size() > 0) {
     // TODO(yzshen): Implement a URLLoaderThrottle subclass which handles a list
     // of URLLoaderThrottles.
     CHECK_EQ(1u, throttles.size());
     throttle_ = std::move(throttles[0]);
     throttle_->set_delegate(this);
   }
 }
 
 void ThrottlingURLLoader::Start(
     mojom::URLLoaderFactory* factory,
     int32_t routing_id,
     int32_t request_id,
     uint32_t options,
     StartLoaderCallback start_loader_callback,
     const ResourceRequest& url_request,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
   DCHECK_EQ(DEFERRED_NONE, deferred_stage_);
-  DCHECK(!cancelled_by_throttle_);
+  DCHECK(!loader_cancelled_);
 
   if (throttle_) {
     bool deferred = false;
     throttle_->WillStartRequest(url_request, &deferred);
-    if (cancelled_by_throttle_)
+    if (loader_cancelled_)
       return;
 
     if (deferred) {
       deferred_stage_ = DEFERRED_START;
       start_info_ =
           base::MakeUnique<StartInfo>(factory, routing_id, request_id, options,
                                       std::move(start_loader_callback),
                                       url_request, std::move(task_runner));
       return;
     }
@@ skipping 32 matching lines @@
     std::move(start_loader_callback)
         .Run(std::move(url_loader_request), std::move(client));
   }
 }
 
 void ThrottlingURLLoader::OnReceiveResponse(
     const ResourceResponseHead& response_head,
     const base::Optional<net::SSLInfo>& ssl_info,
     mojom::DownloadedTempFilePtr downloaded_file) {
   DCHECK_EQ(DEFERRED_NONE, deferred_stage_);
-  DCHECK(!cancelled_by_throttle_);
+  DCHECK(!loader_cancelled_);
 
   if (throttle_) {
     bool deferred = false;
     throttle_->WillProcessResponse(&deferred);
-    if (cancelled_by_throttle_)
+    if (loader_cancelled_)
       return;
 
     if (deferred) {
       deferred_stage_ = DEFERRED_RESPONSE;
       response_info_ = base::MakeUnique<ResponseInfo>(
           response_head, ssl_info, std::move(downloaded_file));
       client_binding_.PauseIncomingMethodCallProcessing();
       return;
     }
   }
 
   forwarding_client_->OnReceiveResponse(response_head, ssl_info,
                                         std::move(downloaded_file));
 }
 
 void ThrottlingURLLoader::OnReceiveRedirect(
     const net::RedirectInfo& redirect_info,
     const ResourceResponseHead& response_head) {
   DCHECK_EQ(DEFERRED_NONE, deferred_stage_);
-  DCHECK(!cancelled_by_throttle_);
+  DCHECK(!loader_cancelled_);
 
   if (throttle_) {
     bool deferred = false;
     throttle_->WillRedirectRequest(redirect_info, &deferred);
-    if (cancelled_by_throttle_)
+    if (loader_cancelled_)
       return;
 
     if (deferred) {
       deferred_stage_ = DEFERRED_REDIRECT;
       redirect_info_ =
           base::MakeUnique<RedirectInfo>(redirect_info, response_head);
       client_binding_.PauseIncomingMethodCallProcessing();
       return;
     }
   }
 
   forwarding_client_->OnReceiveRedirect(redirect_info, response_head);
 }
 
 void ThrottlingURLLoader::OnDataDownloaded(int64_t data_len,
                                            int64_t encoded_data_len) {
   DCHECK_EQ(DEFERRED_NONE, deferred_stage_);
-  DCHECK(!cancelled_by_throttle_);
+  DCHECK(!loader_cancelled_);
 
   forwarding_client_->OnDataDownloaded(data_len, encoded_data_len);
 }
 
 void ThrottlingURLLoader::OnUploadProgress(
     int64_t current_position,
     int64_t total_size,
     OnUploadProgressCallback ack_callback) {
   DCHECK_EQ(DEFERRED_NONE, deferred_stage_);
-  DCHECK(!cancelled_by_throttle_);
+  DCHECK(!loader_cancelled_);
 
   forwarding_client_->OnUploadProgress(current_position, total_size,
                                        std::move(ack_callback));
 }
 
 void ThrottlingURLLoader::OnReceiveCachedMetadata(
     const std::vector<uint8_t>& data) {
   DCHECK_EQ(DEFERRED_NONE, deferred_stage_);
-  DCHECK(!cancelled_by_throttle_);
+  DCHECK(!loader_cancelled_);
 
   forwarding_client_->OnReceiveCachedMetadata(data);
 }
 
 void ThrottlingURLLoader::OnTransferSizeUpdated(int32_t transfer_size_diff) {
   DCHECK_EQ(DEFERRED_NONE, deferred_stage_);
-  DCHECK(!cancelled_by_throttle_);
+  DCHECK(!loader_cancelled_);
 
   forwarding_client_->OnTransferSizeUpdated(transfer_size_diff);
 }
 
 void ThrottlingURLLoader::OnStartLoadingResponseBody(
     mojo::ScopedDataPipeConsumerHandle body) {
   DCHECK_EQ(DEFERRED_NONE, deferred_stage_);
-  DCHECK(!cancelled_by_throttle_);
+  DCHECK(!loader_cancelled_);
 
   forwarding_client_->OnStartLoadingResponseBody(std::move(body));
 }
 
 void ThrottlingURLLoader::OnComplete(
     const ResourceRequestCompletionStatus& status) {
   DCHECK_EQ(DEFERRED_NONE, deferred_stage_);
-  DCHECK(!cancelled_by_throttle_);
+  DCHECK(!loader_cancelled_);
 
   forwarding_client_->OnComplete(status);
 }
 
 void ThrottlingURLLoader::CancelWithError(int error_code) {
   // TODO(yzshen): Support a mode that cancellation also deletes the disk cache
   // entry.
-  if (cancelled_by_throttle_)
+  if (loader_cancelled_)
     return;
 
-  cancelled_by_throttle_ = true;
-
   ResourceRequestCompletionStatus request_complete_data;
   request_complete_data.error_code = error_code;
   request_complete_data.completion_time = base::TimeTicks::Now();
 
   deferred_stage_ = DEFERRED_NONE;
-  client_binding_.Close();
-  url_loader_ = nullptr;
-
+  DisconnectClient();
   forwarding_client_->OnComplete(request_complete_data);
 }
 
 void ThrottlingURLLoader::Resume() {
-  if (cancelled_by_throttle_ || deferred_stage_ == DEFERRED_NONE)
+  if (loader_cancelled_ || deferred_stage_ == DEFERRED_NONE)
     return;
 
   switch (deferred_stage_) {
     case DEFERRED_START: {
       StartNow(start_info_->url_loader_factory, start_info_->routing_id,
                start_info_->request_id, start_info_->options,
                std::move(start_info_->start_loader_callback),
                start_info_->url_request, std::move(start_info_->task_runner));
 
       if (priority_info_) {
@@ skipping 17 matching lines @@
       break;
     }
     default:
       NOTREACHED();
       break;
   }
   deferred_stage_ = DEFERRED_NONE;
 }
 
 }  // namespace content