Revert of 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());
-    ++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;
+    return false;
   }
   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, signaling EOF.
+  // Resume and run until the final 0-byte read, signalling 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_);
-  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