Move ResourceHandler deferred actions ahead of external protocol handling.

content/browser/loader/resource_loader_unittest.cc

 // Copyright (c) 2013 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/resource_loader.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <deque>
 #include <memory>
 #include <utility>
+#include <vector>
 
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 472 matching lines @@
 
   // ResourceLoaderDelegate:
   ResourceDispatcherHostLoginDelegate* CreateLoginDelegate(
       ResourceLoader* loader,
       net::AuthChallengeInfo* auth_info) override {
     return NULL;
   }
   bool HandleExternalProtocol(ResourceLoader* loader,
                               const GURL& url) override {
     EXPECT_EQ(loader, loader_.get());
-    return false;
+    ++handle_external_protocol_;
+
+    // Check that calls to HandleExternalProtocol always happen after the calls
+    // to the ResourceHandler's OnWillStart and OnRequestRedirected.
+    EXPECT_EQ(handle_external_protocol_,
+              raw_ptr_resource_handler_->on_will_start_called() +
+                  raw_ptr_resource_handler_->on_request_redirected_called());
+
+    bool return_value = handle_external_protocol_results_.front();
+    if (handle_external_protocol_results_.size() > 1)
+      handle_external_protocol_results_.pop_front();
+    return return_value;
   }
   void DidStartRequest(ResourceLoader* loader) override {
     EXPECT_EQ(loader, loader_.get());
     EXPECT_EQ(0, did_finish_loading_);
     EXPECT_EQ(0, did_start_request_);
     ++did_start_request_;
   }
   void DidReceiveRedirect(ResourceLoader* loader,
                           const GURL& new_url,
                           ResourceResponse* response) override {
@@ skipping 26 matching lines @@
   }
 
   TestBrowserThreadBundle thread_bundle_;
   RenderViewHostTestEnabler rvh_test_enabler_;
 
   // Record which ResourceDispatcherHostDelegate methods have been invoked.
   int did_start_request_ = 0;
   int did_received_redirect_ = 0;
   int did_receive_response_ = 0;
   int did_finish_loading_ = 0;
+  int handle_external_protocol_ = 0;
+
+  // Allows controlling the return values of sequential calls to
+  // HandleExternalProtocol. Values are removed by the measure they are used
+  // but the last one which is used for all following calls.
+  std::deque<bool> handle_external_protocol_results_{false};
 
   net::URLRequestJobFactoryImpl job_factory_;
   TestNetworkQualityEstimator network_quality_estimator_;
   net::TestURLRequestContext test_url_request_context_;
   MockResourceContext resource_context_;
   std::unique_ptr<TestBrowserContext> browser_context_;
   std::unique_ptr<TestWebContents> web_contents_;
   std::unique_ptr<net::ClientCertStore> dummy_cert_store_;
 
   // The ResourceLoader owns the URLRequest and the ResourceHandler.
@@ skipping 181 matching lines @@
 }
 
 // Test the case the ResourceHandler defers nothing.
 TEST_F(ResourceLoaderTest, SyncResourceHandler) {
   loader_->StartRequest();
   raw_ptr_resource_handler_->WaitUntilResponseComplete();
   EXPECT_EQ(1, did_start_request_);
   EXPECT_EQ(1, did_received_redirect_);
   EXPECT_EQ(1, did_receive_response_);
   EXPECT_EQ(1, did_finish_loading_);
+  EXPECT_EQ(2, handle_external_protocol_);
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_request_redirected_called());
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_response_completed_called());
   EXPECT_EQ(net::OK, raw_ptr_resource_handler_->final_status().error());
   EXPECT_EQ(test_data(), raw_ptr_resource_handler_->body());
 }
 
 // Same as above, except reads complete asynchronously, and there's no redirect.
 TEST_F(ResourceLoaderTest, SyncResourceHandlerAsyncReads) {
   SetUpResourceLoaderForUrl(test_async_url());
 
   loader_->StartRequest();
   raw_ptr_resource_handler_->WaitUntilResponseComplete();
   EXPECT_EQ(1, did_start_request_);
   EXPECT_EQ(0, did_received_redirect_);
   EXPECT_EQ(1, did_receive_response_);
   EXPECT_EQ(1, did_finish_loading_);
+  EXPECT_EQ(1, handle_external_protocol_);
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_request_redirected_called());
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_response_completed_called());
   EXPECT_EQ(net::OK, raw_ptr_resource_handler_->final_status().error());
   EXPECT_EQ(test_data(), raw_ptr_resource_handler_->body());
 }
 
+// Test the case where ResourceHandler defers nothing and the request is handled
+// as an external protocol on start.
+TEST_F(ResourceLoaderTest, SyncExternalProtocolHandlingOnStart) {
+  handle_external_protocol_results_ = {true};
+
+  loader_->StartRequest();
+  raw_ptr_resource_handler_->WaitUntilResponseComplete();
+  EXPECT_EQ(0, did_start_request_);
+  EXPECT_EQ(0, did_received_redirect_);
+  EXPECT_EQ(0, did_receive_response_);
+  EXPECT_EQ(1, did_finish_loading_);
+  EXPECT_EQ(1, handle_external_protocol_);
+  EXPECT_EQ(1, raw_ptr_resource_handler_->on_will_start_called());
+  EXPECT_EQ(0, raw_ptr_resource_handler_->on_request_redirected_called());
+  EXPECT_EQ(1, raw_ptr_resource_handler_->on_response_completed_called());
+  EXPECT_EQ(net::ERR_ABORTED,
+            raw_ptr_resource_handler_->final_status().error());
+  EXPECT_TRUE(raw_ptr_resource_handler_->body().empty());
+}
+
+// Test the case where ResourceHandler defers nothing and the request is handled
+// as an external protocol on redirect.
+TEST_F(ResourceLoaderTest, SyncExternalProtocolHandlingOnRedirect) {
+  handle_external_protocol_results_ = {false, true};
+
+  loader_->StartRequest();
+  raw_ptr_resource_handler_->WaitUntilResponseComplete();
+  EXPECT_EQ(1, did_start_request_);
+  EXPECT_EQ(1, did_received_redirect_);
+  EXPECT_EQ(0, did_receive_response_);
+  EXPECT_EQ(1, did_finish_loading_);
+  EXPECT_EQ(2, handle_external_protocol_);
+  EXPECT_EQ(1, raw_ptr_resource_handler_->on_will_start_called());
+  EXPECT_EQ(1, raw_ptr_resource_handler_->on_request_redirected_called());
+  EXPECT_EQ(1, raw_ptr_resource_handler_->on_response_completed_called());
+  EXPECT_EQ(net::ERR_ABORTED,
+            raw_ptr_resource_handler_->final_status().error());
+  EXPECT_TRUE(raw_ptr_resource_handler_->body().empty());
+}
+
 // Test the case the ResourceHandler defers everything.
 TEST_F(ResourceLoaderTest, AsyncResourceHandler) {
   raw_ptr_resource_handler_->set_defer_on_will_start(true);
   raw_ptr_resource_handler_->set_defer_on_request_redirected(true);
   raw_ptr_resource_handler_->set_defer_on_response_started(true);
   raw_ptr_resource_handler_->set_defer_on_read_completed(true);
   raw_ptr_resource_handler_->set_defer_on_read_eof(true);
   raw_ptr_resource_handler_->set_defer_on_response_completed(true);
 
   // Start and run until OnWillStart.
   loader_->StartRequest();
   raw_ptr_resource_handler_->WaitUntilDeferred();
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_will_start_called());
 
   // Spinning the message loop should not advance the state further.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, did_start_request_);
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_will_start_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_request_redirected_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_response_completed_called());
+  EXPECT_EQ(0, handle_external_protocol_);
 
   // Resume and run until OnRequestRedirected.
   raw_ptr_resource_handler_->Resume();
   raw_ptr_resource_handler_->WaitUntilDeferred();
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_request_redirected_called());
+  EXPECT_EQ(1, handle_external_protocol_);
 
   // Spinning the message loop should not advance the state further.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, did_received_redirect_);
   EXPECT_EQ(0, did_receive_response_);
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_request_redirected_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_will_read_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_response_completed_called());
+  EXPECT_EQ(1, handle_external_protocol_);
 
   // Resume and run until OnResponseStarted.
   raw_ptr_resource_handler_->Resume();
   raw_ptr_resource_handler_->WaitUntilDeferred();
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_response_started_called());
+  EXPECT_EQ(2, handle_external_protocol_);
 
   // Spinning the message loop should not advance the state further.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, did_receive_response_);
   EXPECT_EQ(0, did_finish_loading_);
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_response_started_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_will_read_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_response_completed_called());
 
   // Resume and run until OnReadCompleted.
   raw_ptr_resource_handler_->Resume();
   raw_ptr_resource_handler_->WaitUntilDeferred();
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_read_completed_called());
 
   // Spinning the message loop should not advance the state further.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_will_read_called());
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_read_completed_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_read_eof());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_response_completed_called());
 
-  // Resume and run until the final 0-byte read, signalling EOF.
+  // Resume and run until the final 0-byte read, signaling EOF.
   raw_ptr_resource_handler_->Resume();
   raw_ptr_resource_handler_->WaitUntilDeferred();
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_read_eof());
 
   // Spinning the message loop should not advance the state further.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_read_eof());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_response_completed_called());
   EXPECT_EQ(test_data(), raw_ptr_resource_handler_->body());
 
   // Resume and run until OnResponseCompleted is called, which again defers the
   // request.
   raw_ptr_resource_handler_->Resume();
   raw_ptr_resource_handler_->WaitUntilResponseComplete();
   EXPECT_EQ(0, did_finish_loading_);
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_response_completed_called());
   EXPECT_EQ(net::OK, raw_ptr_resource_handler_->final_status().error());
   EXPECT_EQ(test_data(), raw_ptr_resource_handler_->body());
 
   // Resume and run until all pending tasks. Note that OnResponseCompleted was
   // invoked in the previous section, so can't use RunUntilCompleted().
   raw_ptr_resource_handler_->Resume();
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_response_completed_called());
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, did_finish_loading_);
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_response_completed_called());
   EXPECT_EQ(net::OK, raw_ptr_resource_handler_->final_status().error());
   EXPECT_EQ(test_data(), raw_ptr_resource_handler_->body());
+  EXPECT_EQ(2, handle_external_protocol_);
 }
 
 // Same as above, except reads complete asynchronously and there's no redirect.
 TEST_F(ResourceLoaderTest, AsyncResourceHandlerAsyncReads) {
   SetUpResourceLoaderForUrl(test_async_url());
 
   raw_ptr_resource_handler_->set_defer_on_will_start(true);
   raw_ptr_resource_handler_->set_defer_on_response_started(true);
   raw_ptr_resource_handler_->set_defer_on_read_completed(true);
   raw_ptr_resource_handler_->set_defer_on_read_eof(true);
   raw_ptr_resource_handler_->set_defer_on_response_completed(true);
 
   // Start and run until OnWillStart.
   loader_->StartRequest();
   raw_ptr_resource_handler_->WaitUntilDeferred();
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_will_start_called());
 
   // Spinning the message loop should not advance the state further.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, did_start_request_);
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_will_start_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_request_redirected_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_response_completed_called());
+  EXPECT_EQ(0, handle_external_protocol_);
 
   // Resume and run until OnResponseStarted.
   raw_ptr_resource_handler_->Resume();
   raw_ptr_resource_handler_->WaitUntilDeferred();
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_response_started_called());
+  EXPECT_EQ(1, handle_external_protocol_);
 
   // Spinning the message loop should not advance the state further.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, did_receive_response_);
   EXPECT_EQ(0, did_finish_loading_);
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_response_started_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_will_read_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_response_completed_called());
 
   // Resume and run until OnReadCompleted.
@@ skipping 31 matching lines @@
   // Resume and run until all pending tasks. Note that OnResponseCompleted was
   // invoked in the previous section, so can't use RunUntilCompleted().
   raw_ptr_resource_handler_->Resume();
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_response_completed_called());
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, did_finish_loading_);
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_response_completed_called());
   EXPECT_EQ(net::OK, raw_ptr_resource_handler_->final_status().error());
   EXPECT_EQ(test_data(), raw_ptr_resource_handler_->body());
+  EXPECT_EQ(1, handle_external_protocol_);
 }
 
 TEST_F(ResourceLoaderTest, SyncCancelOnWillStart) {
   raw_ptr_resource_handler_->set_on_will_start_result(false);
 
   loader_->StartRequest();
   raw_ptr_resource_handler_->WaitUntilResponseComplete();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, did_start_request_);
   EXPECT_EQ(1, did_finish_loading_);
+  EXPECT_EQ(0, handle_external_protocol_);
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_will_start_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_request_redirected_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_response_started_called());
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_response_completed_called());
 
   EXPECT_EQ(net::ERR_ABORTED,
             raw_ptr_resource_handler_->final_status().error());
   EXPECT_EQ("", raw_ptr_resource_handler_->body());
 }
 
 TEST_F(ResourceLoaderTest, SyncCancelOnRequestRedirected) {
   raw_ptr_resource_handler_->set_on_request_redirected_result(false);
 
   loader_->StartRequest();
   raw_ptr_resource_handler_->WaitUntilResponseComplete();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, did_received_redirect_);
   EXPECT_EQ(0, did_receive_response_);
   EXPECT_EQ(1, did_finish_loading_);
+  EXPECT_EQ(1, handle_external_protocol_);
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_request_redirected_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_will_read_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_read_completed_called());
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_response_completed_called());
 
   EXPECT_EQ(net::ERR_ABORTED,
             raw_ptr_resource_handler_->final_status().error());
   EXPECT_EQ("", raw_ptr_resource_handler_->body());
 }
 
@@ skipping 102 matching lines @@
 
 TEST_F(ResourceLoaderTest, AsyncCancelOnWillStart) {
   raw_ptr_resource_handler_->set_defer_on_will_start(true);
 
   loader_->StartRequest();
   raw_ptr_resource_handler_->WaitUntilDeferred();
   raw_ptr_resource_handler_->CancelWithError(net::ERR_FAILED);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, did_start_request_);
   EXPECT_EQ(1, did_finish_loading_);
+  EXPECT_EQ(0, handle_external_protocol_);
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_will_start_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_request_redirected_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_response_started_called());
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_response_completed_called());
 
   EXPECT_EQ(net::ERR_FAILED, raw_ptr_resource_handler_->final_status().error());
   EXPECT_EQ("", raw_ptr_resource_handler_->body());
 }
 
 TEST_F(ResourceLoaderTest, AsyncCancelOnRequestRedirected) {
   raw_ptr_resource_handler_->set_defer_on_request_redirected(true);
 
   loader_->StartRequest();
   raw_ptr_resource_handler_->WaitUntilDeferred();
   raw_ptr_resource_handler_->CancelWithError(net::ERR_FAILED);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, did_received_redirect_);
   EXPECT_EQ(0, did_receive_response_);
   EXPECT_EQ(1, did_finish_loading_);
+  EXPECT_EQ(1, handle_external_protocol_);
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_request_redirected_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_will_read_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_read_completed_called());
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_response_completed_called());
 
   EXPECT_EQ(net::ERR_FAILED, raw_ptr_resource_handler_->final_status().error());
   EXPECT_EQ("", raw_ptr_resource_handler_->body());
 }
 
 TEST_F(ResourceLoaderTest, AsyncCancelOnResponseStarted) {
@@ skipping 75 matching lines @@
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, did_receive_response_);
   EXPECT_EQ(1, did_finish_loading_);
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_read_eof());
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_response_completed_called());
 
   EXPECT_EQ(net::ERR_FAILED, raw_ptr_resource_handler_->final_status().error());
   EXPECT_EQ(test_data(), raw_ptr_resource_handler_->body());
 }
 
+// Tests the request being deferred and then being handled as an external
+// protocol, both on start.
+TEST_F(ResourceLoaderTest, AsyncExternalProtocolHandlingOnStart) {
+  handle_external_protocol_results_ = {true};
+  raw_ptr_resource_handler_->set_defer_on_will_start(true);
+
+  loader_->StartRequest();
+  raw_ptr_resource_handler_->WaitUntilDeferred();
+  EXPECT_EQ(0, did_finish_loading_);
+  EXPECT_EQ(0, handle_external_protocol_);
+  EXPECT_EQ(1, raw_ptr_resource_handler_->on_will_start_called());
+  EXPECT_EQ(0, raw_ptr_resource_handler_->on_response_completed_called());
+
+  raw_ptr_resource_handler_->Resume();
+  raw_ptr_resource_handler_->WaitUntilResponseComplete();
+  EXPECT_EQ(0, did_start_request_);
+  EXPECT_EQ(1, did_finish_loading_);
+  EXPECT_EQ(1, handle_external_protocol_);
+  EXPECT_EQ(1, raw_ptr_resource_handler_->on_will_start_called());
+  EXPECT_EQ(0, raw_ptr_resource_handler_->on_request_redirected_called());
+  EXPECT_EQ(0, raw_ptr_resource_handler_->on_response_started_called());
+  EXPECT_EQ(1, raw_ptr_resource_handler_->on_response_completed_called());
+
+  EXPECT_EQ(net::ERR_ABORTED,
+            raw_ptr_resource_handler_->final_status().error());
+  EXPECT_EQ("", raw_ptr_resource_handler_->body());
+}
+
+// Tests the request being deferred and then being handled as an external
+// protocol, both on redirect.
+TEST_F(ResourceLoaderTest, AsyncExternalProtocolHandlingOnRedirect) {
+  handle_external_protocol_results_ = {false, true};
+  raw_ptr_resource_handler_->set_defer_on_request_redirected(true);
+
+  loader_->StartRequest();
+  raw_ptr_resource_handler_->WaitUntilDeferred();
+  EXPECT_EQ(1, did_start_request_);
+  EXPECT_EQ(1, did_received_redirect_);

[carlosk, 2016/12/20 19:23:31]

In the process I created the async tests I noticed a difference in call order
between the handling of request start and redirects. This might be WAI but I
wanted to bring it up here.

On request start:
  1 handler_->OnWillStart then delegate_->HandleExternalProtocol
  2 delegate_->DidStartRequest 

On redirect:
  1 delegate_->DidReceiveRedirect
  2 handler_->OnRequestRedirected then delegate_->HandleExternalProtocol

WDYT?

[jam, 2016/12/20 20:55:56]

I suspect the order didn't matter and it wasn't intended. Seems orthogonal from
this cl though?

[carlosk, 2016/12/20 22:21:56]

It is orthogonal; I was just curious. Thanks.

+  EXPECT_EQ(0, did_finish_loading_);
+  EXPECT_EQ(1, handle_external_protocol_);
+  EXPECT_EQ(1, raw_ptr_resource_handler_->on_will_start_called());
+  EXPECT_EQ(1, raw_ptr_resource_handler_->on_request_redirected_called());
+  EXPECT_EQ(0, raw_ptr_resource_handler_->on_response_completed_called());
+
+  raw_ptr_resource_handler_->Resume();
+  raw_ptr_resource_handler_->WaitUntilResponseComplete();
+  EXPECT_EQ(1, did_start_request_);
+  EXPECT_EQ(1, did_received_redirect_);
+  EXPECT_EQ(0, did_receive_response_);
+  EXPECT_EQ(1, did_finish_loading_);
+  EXPECT_EQ(2, handle_external_protocol_);
+  EXPECT_EQ(1, raw_ptr_resource_handler_->on_will_start_called());
+  EXPECT_EQ(1, raw_ptr_resource_handler_->on_request_redirected_called());
+  EXPECT_EQ(0, raw_ptr_resource_handler_->on_response_started_called());
+  EXPECT_EQ(1, raw_ptr_resource_handler_->on_response_completed_called());
+
+  EXPECT_EQ(net::ERR_ABORTED,
+            raw_ptr_resource_handler_->final_status().error());
+  EXPECT_EQ("", raw_ptr_resource_handler_->body());
+}
+
 TEST_F(ResourceLoaderTest, RequestFailsOnStart) {
   SetUpResourceLoaderForUrl(
       net::URLRequestFailedJob::GetMockHttpUrlWithFailurePhase(
           net::URLRequestFailedJob::START, net::ERR_FAILED));
 
   loader_->StartRequest();
   raw_ptr_resource_handler_->WaitUntilResponseComplete();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, did_received_redirect_);
   EXPECT_EQ(0, did_receive_response_);
   EXPECT_EQ(1, did_finish_loading_);
+  EXPECT_EQ(1, handle_external_protocol_);
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_will_start_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_request_redirected_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_response_started_called());
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_response_completed_called());
   EXPECT_EQ(net::ERR_FAILED, raw_ptr_resource_handler_->final_status().error());
   EXPECT_EQ("", raw_ptr_resource_handler_->body());
 }
 
 TEST_F(ResourceLoaderTest, RequestFailsOnReadSync) {
   SetUpResourceLoaderForUrl(
@@ skipping 39 matching lines @@
   SetUpResourceLoaderForUrl(
       net::URLRequestFailedJob::GetMockHttpUrlWithFailurePhase(
           net::URLRequestFailedJob::START, net::ERR_IO_PENDING));
 
   loader_->StartRequest();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_will_start_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_request_redirected_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_response_started_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_response_completed_called());
+  EXPECT_EQ(1, handle_external_protocol_);
 
   raw_ptr_resource_handler_->CancelWithError(net::ERR_FAILED);
   raw_ptr_resource_handler_->WaitUntilResponseComplete();
 
   EXPECT_EQ(0, did_received_redirect_);
   EXPECT_EQ(0, did_receive_response_);
   EXPECT_EQ(1, did_finish_loading_);
+  EXPECT_EQ(1, handle_external_protocol_);
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_will_start_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_request_redirected_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_response_started_called());
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_response_completed_called());
   EXPECT_EQ(net::ERR_FAILED, raw_ptr_resource_handler_->final_status().error());
   EXPECT_EQ("", raw_ptr_resource_handler_->body());
 }
 
 TEST_F(ResourceLoaderTest, OutOfBandCancelDuringRead) {
   SetUpResourceLoaderForUrl(
       net::URLRequestFailedJob::GetMockHttpUrlWithFailurePhase(
           net::URLRequestFailedJob::READ_SYNC, net::ERR_IO_PENDING));
 
   loader_->StartRequest();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_will_start_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_request_redirected_called());
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_response_started_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_read_completed_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_response_completed_called());
+  EXPECT_EQ(1, handle_external_protocol_);
 
   raw_ptr_resource_handler_->CancelWithError(net::ERR_FAILED);
   raw_ptr_resource_handler_->WaitUntilResponseComplete();
   EXPECT_EQ(0, did_received_redirect_);
   EXPECT_EQ(1, did_receive_response_);
   EXPECT_EQ(1, did_finish_loading_);
+  EXPECT_EQ(1, handle_external_protocol_);
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_will_start_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_request_redirected_called());
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_response_started_called());
   EXPECT_EQ(0, raw_ptr_resource_handler_->on_read_completed_called());
   EXPECT_EQ(1, raw_ptr_resource_handler_->on_response_completed_called());
   EXPECT_EQ(net::ERR_FAILED, raw_ptr_resource_handler_->final_status().error());
   EXPECT_EQ("", raw_ptr_resource_handler_->body());
 }
 
 TEST_F(ResourceLoaderTest, ResumeCanceledRequest) {
@@ skipping 282 matching lines @@
 
 // Tests that the effective connection type is not set on non-main frame
 // requests.
 TEST_F(EffectiveConnectionTypeResourceLoaderTest, DoesNotBelongToMainFrame) {
   VerifyEffectiveConnectionType(RESOURCE_TYPE_OBJECT, false,
                                 net::EFFECTIVE_CONNECTION_TYPE_3G,
                                 net::EFFECTIVE_CONNECTION_TYPE_UNKNOWN);
 }
 
 }  // namespace content