Make URLRequestFilter use URLRequestInterceptors.

chrome/browser/errorpage_browsertest.cc

 // Copyright (c) 2012 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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 29 matching lines @@
 #include "content/test/net/url_request_mock_http_job.h"
 #include "grit/generated_resources.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/http/failing_http_transaction_factory.h"
 #include "net/http/http_cache.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_filter.h"
+#include "net/url_request/url_request_interceptor.h"
 #include "net/url_request/url_request_job.h"
-#include "net/url_request/url_request_job_factory.h"
 #include "net/url_request/url_request_test_job.h"
 #include "net/url_request/url_request_test_util.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using content::BrowserThread;
 using content::NavigationController;
 using content::URLRequestFailedJob;
-using net::URLRequestJobFactory;
 using net::URLRequestTestJob;
 
 namespace {
 
 // Returns true if |text| is displayed on the page |browser| is currently
 // displaying.  Uses "innerText", so will miss hidden text, and whitespace
 // space handling may be weird.
 bool WARN_UNUSED_RESULT IsDisplayingText(Browser* browser,
                                          const std::string& text) {
   std::string command = base::StringPrintf(
@@ skipping 70 matching lines @@
       "var searchText = document.getElementById('search-box').value;"
           "domAutomationController.send(searchText == 'search query');",
       &search_box_populated));
   EXPECT_TRUE(search_box_populated);
 }
 
 std::string GetLoadStaleButtonLabel() {
   return l10n_util::GetStringUTF8(IDS_ERRORPAGES_BUTTON_LOAD_STALE);
 }
 
-void AddProtocolHandlerForURL(
+void AddInterceptorForURL(
     const GURL& url,
-    scoped_ptr<URLRequestJobFactory::ProtocolHandler> handler) {
+    scoped_ptr<net::URLRequestInterceptor> handler) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  net::URLRequestFilter::GetInstance()->AddUrlProtocolHandler(
+  net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
       url, handler.Pass());
 }
 
-// A protocol handler that fails a configurable number of requests, then
-// succeeds all requests after that, keeping count of failures and successes.
-class FailFirstNRequestsProtocolHandler
-    : public URLRequestJobFactory::ProtocolHandler {
+// An interceptor that fails a configurable number of requests, then succeeds
+// all requests after that, keeping count of failures and successes.
+class FailFirstNRequestsInterceptor : public net::URLRequestInterceptor {
  public:
-  explicit FailFirstNRequestsProtocolHandler(int requests_to_fail)
+  explicit FailFirstNRequestsInterceptor(int requests_to_fail)
       : requests_(0), failures_(0), requests_to_fail_(requests_to_fail) {}
-  virtual ~FailFirstNRequestsProtocolHandler() {}
+  virtual ~FailFirstNRequestsInterceptor() {}
 
-  // net::URLRequestJobFactory::ProtocolHandler implementation
-  virtual net::URLRequestJob* MaybeCreateJob(
+  // net::URLRequestInterceptor implementation
+  virtual net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     requests_++;
     if (failures_ < requests_to_fail_) {
       failures_++;
       // Note: net::ERR_CONNECTION_RESET does not summon the Link Doctor; see
       // NetErrorHelperCore::GetErrorPageURL.
       return new URLRequestFailedJob(request,
                                      network_delegate,
                                      net::ERR_CONNECTION_RESET);
     } else {
       return new URLRequestTestJob(request, network_delegate,
                                    URLRequestTestJob::test_headers(),
                                    URLRequestTestJob::test_data_1(),
                                    true);
     }
   }
 
   int requests() const { return requests_; }
   int failures() const { return failures_; }
 
  private:
   // These are mutable because MaybeCreateJob is const but we want this state
   // for testing.
   mutable int requests_;
   mutable int failures_;
   int requests_to_fail_;
+
+  DISALLOW_COPY_AND_ASSIGN(FailFirstNRequestsInterceptor);
 };
 
-// A protocol handler that serves LinkDoctor responses.  It also allows waiting
+// An interceptor that serves LinkDoctor responses.  It also allows waiting
 // until a certain number of requests have been sent.
 // TODO(mmenke):  Wait until responses have been received instead.
-class LinkDoctorProtocolHandler
-    : public URLRequestJobFactory::ProtocolHandler {
+class LinkDoctorInterceptor : public net::URLRequestInterceptor {
  public:
-  LinkDoctorProtocolHandler()
-      : num_requests_(0),
-        requests_to_wait_for_(-1),
-        weak_factory_(this) {
+  LinkDoctorInterceptor() : num_requests_(0),
+                            requests_to_wait_for_(-1),
+                            weak_factory_(this) {
   }
 
-  virtual ~LinkDoctorProtocolHandler() {}
+  virtual ~LinkDoctorInterceptor() {}
 
-  // net::URLRequestJobFactory::ProtocolHandler implementation
-  virtual net::URLRequestJob* MaybeCreateJob(
+  // net::URLRequestInterceptor implementation
+  virtual net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
-        base::Bind(&LinkDoctorProtocolHandler::RequestCreated,
+        base::Bind(&LinkDoctorInterceptor::RequestCreated,
                    weak_factory_.GetWeakPtr()));
 
     base::FilePath root_http;
     PathService::Get(chrome::DIR_TEST_DATA, &root_http);
     return new content::URLRequestMockHTTPJob(
         request, network_delegate,
         root_http.AppendASCII("mock-link-doctor.json"));
   }
 
   void WaitForRequests(int requests_to_wait_for) {
@@ skipping 29 matching lines @@
       run_loop_->Quit();
   }
 
   // These are only used on the UI thread.
   int num_requests_;
   int requests_to_wait_for_;
   scoped_ptr<base::RunLoop> run_loop_;
 
   // This prevents any risk of flake if any test doesn't wait for a request
   // it sent.  Mutable so it can be accessed from a const function.
-  mutable base::WeakPtrFactory<LinkDoctorProtocolHandler> weak_factory_;
+  mutable base::WeakPtrFactory<LinkDoctorInterceptor> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(LinkDoctorInterceptor);
 };
 
-void InstallMockProtocolHandlers(
+void InstallMockInterceptors(
     const GURL& search_url,
-    scoped_ptr<URLRequestJobFactory::ProtocolHandler> link_doctor_handler) {
+    scoped_ptr<net::URLRequestInterceptor> link_doctor_interceptor) {
   chrome_browser_net::SetUrlRequestMocksEnabled(true);
 
-  AddProtocolHandlerForURL(google_util::LinkDoctorBaseURL(),
-                            link_doctor_handler.Pass());
+  AddInterceptorForURL(google_util::LinkDoctorBaseURL(),
+                       link_doctor_interceptor.Pass());
 
   // Add a mock for the search engine the error page will use.
   base::FilePath root_http;
   PathService::Get(chrome::DIR_TEST_DATA, &root_http);
   content::URLRequestMockHTTPJob::AddHostnameToFileHandler(
       search_url.host(), root_http.AppendASCII("title3.html"));
 }
 
 class ErrorPageTest : public InProcessBrowserTest {
  public:
   enum HistoryNavigationDirection {
     HISTORY_NAVIGATE_BACK,
     HISTORY_NAVIGATE_FORWARD,
   };
 
-  ErrorPageTest() : link_doctor_handler_(NULL) {}
+  ErrorPageTest() : link_doctor_interceptor_(NULL) {}
   virtual ~ErrorPageTest() {}
 
   // Navigates the active tab to a mock url created for the file at |file_path|.
   // Needed for StaleCacheStatus and StaleCacheStatusFailedCorrections tests.
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     command_line->AppendSwitch(switches::kEnableOfflineLoadStaleCache);
   }
 
   // Navigates the active tab to a mock url created for the file at |file_path|.
   void NavigateToFileURL(const base::FilePath::StringType& file_path) {
@@ skipping 87 matching lines @@
         browser()->tab_strip_model()->GetActiveWebContents(),
         js_reload_script,
         &result);
     EXPECT_TRUE(ret);
     if (!ret)
       return testing::AssertionFailure();
     return ("success" == result ? testing::AssertionSuccess() :
             (testing::AssertionFailure() << "Exception message is " << result));
   }
 
-  LinkDoctorProtocolHandler* link_doctor_handler() {
-    return link_doctor_handler_;
+  LinkDoctorInterceptor* link_doctor_interceptor() {
+    return link_doctor_interceptor_;
   }
 
  protected:
   virtual void SetUpOnMainThread() OVERRIDE {
-    link_doctor_handler_ = new LinkDoctorProtocolHandler();
-    scoped_ptr<URLRequestJobFactory::ProtocolHandler> owned_handler(
-        link_doctor_handler_);
-    // Ownership of the |protocol_handler_| is passed to an object the IO
-    // thread, but a pointer is kept in the test fixture.  As soon as anything
-    // calls URLRequestFilter::ClearHandlers(), |protocol_handler_| can become
-    // invalid.
+    link_doctor_interceptor_ = new LinkDoctorInterceptor();
+    scoped_ptr<net::URLRequestInterceptor> owned_interceptor(
+        link_doctor_interceptor_);
+    // Ownership of the |interceptor_| is passed to an object the IO thread, but
+    // a pointer is kept in the test fixture.  As soon as anything calls
+    // URLRequestFilter::ClearHandlers(), |interceptor_| can become invalid.
     BrowserThread::PostTask(
-        BrowserThread::IO,
-        FROM_HERE,
-        base::Bind(&InstallMockProtocolHandlers,
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&InstallMockInterceptors,
                    google_util::GetGoogleSearchURL(
                        google_profile_helper::GetGoogleHomePageURL(
                            browser()->profile())),
-                   base::Passed(&owned_handler)));
+                   base::Passed(&owned_interceptor)));
   }
 
   // Returns a GURL that results in a DNS error.
   GURL GetDnsErrorURL() const {
     return URLRequestFailedJob::GetMockHttpUrl(net::ERR_NAME_NOT_RESOLVED);
   }
 
  private:
   // Navigates the browser the indicated direction in the history and waits for
   // |num_navigations| to occur and the title to change to |expected_title|.
@@ skipping 18 matching lines @@
     if (direction == HISTORY_NAVIGATE_BACK) {
       chrome::GoBack(browser(), CURRENT_TAB);
     } else if (direction == HISTORY_NAVIGATE_FORWARD) {
       chrome::GoForward(browser(), CURRENT_TAB);
     } else {
       FAIL();
     }
     test_navigation_observer.Wait();
   }
 
-  LinkDoctorProtocolHandler* link_doctor_handler_;
+  LinkDoctorInterceptor* link_doctor_interceptor_;
 };
 
 class TestFailProvisionalLoadObserver : public content::WebContentsObserver {
  public:
   explicit TestFailProvisionalLoadObserver(content::WebContents* contents)
       : content::WebContentsObserver(contents) {}
   virtual ~TestFailProvisionalLoadObserver() {}
 
   // This method is invoked when the provisional load failed.
   virtual void DidFailProvisionalLoad(
@@ skipping 28 matching lines @@
   cache->SetHttpNetworkTransactionFactoryForTesting(factory.Pass());
 }
 
 // Test that a DNS error occuring in the main frame redirects to an error page.
 IN_PROC_BROWSER_TEST_F(ErrorPageTest, DNSError_Basic) {
   // The first navigation should fail, and the second one should be the error
   // page.
   ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
        browser(), GetDnsErrorURL(), 2);
   ExpectDisplayingNavigationCorrections(browser(), net::ERR_NAME_NOT_RESOLVED);
-  EXPECT_EQ(1, link_doctor_handler()->num_requests());
+  EXPECT_EQ(1, link_doctor_interceptor()->num_requests());
 }
 
 // Test that a DNS error occuring in the main frame does not result in an
 // additional session history entry.
 IN_PROC_BROWSER_TEST_F(ErrorPageTest, DNSError_GoBack1) {
   NavigateToFileURL(FILE_PATH_LITERAL("title2.html"));
   ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
        browser(), GetDnsErrorURL(), 2);
   ExpectDisplayingNavigationCorrections(browser(), net::ERR_NAME_NOT_RESOLVED);
   GoBackAndWaitForTitle("Title Of Awesomeness", 1);
-  EXPECT_EQ(1, link_doctor_handler()->num_requests());
+  EXPECT_EQ(1, link_doctor_interceptor()->num_requests());
 }
 
 // Test that a DNS error occuring in the main frame does not result in an
 // additional session history entry.
 IN_PROC_BROWSER_TEST_F(ErrorPageTest, DNSError_GoBack2) {
   NavigateToFileURL(FILE_PATH_LITERAL("title2.html"));
 
   ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
        browser(), GetDnsErrorURL(), 2);
   ExpectDisplayingNavigationCorrections(browser(), net::ERR_NAME_NOT_RESOLVED);
-  EXPECT_EQ(1, link_doctor_handler()->num_requests());
+  EXPECT_EQ(1, link_doctor_interceptor()->num_requests());
 
   NavigateToFileURL(FILE_PATH_LITERAL("title3.html"));
 
   GoBackAndWaitForNavigations(2);
   ExpectDisplayingNavigationCorrections(browser(), net::ERR_NAME_NOT_RESOLVED);
-  EXPECT_EQ(2, link_doctor_handler()->num_requests());
+  EXPECT_EQ(2, link_doctor_interceptor()->num_requests());
 
   GoBackAndWaitForTitle("Title Of Awesomeness", 1);
-  EXPECT_EQ(2, link_doctor_handler()->num_requests());
+  EXPECT_EQ(2, link_doctor_interceptor()->num_requests());
 }
 
 // Test that a DNS error occuring in the main frame does not result in an
 // additional session history entry.
 IN_PROC_BROWSER_TEST_F(ErrorPageTest, DNSError_GoBack2AndForward) {
   NavigateToFileURL(FILE_PATH_LITERAL("title2.html"));
 
   ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
        browser(), GetDnsErrorURL(), 2);
   ExpectDisplayingNavigationCorrections(browser(), net::ERR_NAME_NOT_RESOLVED);
-  EXPECT_EQ(1, link_doctor_handler()->num_requests());
+  EXPECT_EQ(1, link_doctor_interceptor()->num_requests());
 
   NavigateToFileURL(FILE_PATH_LITERAL("title3.html"));
 
   GoBackAndWaitForNavigations(2);
   ExpectDisplayingNavigationCorrections(browser(), net::ERR_NAME_NOT_RESOLVED);
-  EXPECT_EQ(2, link_doctor_handler()->num_requests());
+  EXPECT_EQ(2, link_doctor_interceptor()->num_requests());
 
   GoBackAndWaitForTitle("Title Of Awesomeness", 1);
 
   GoForwardAndWaitForNavigations(2);
   ExpectDisplayingNavigationCorrections(browser(), net::ERR_NAME_NOT_RESOLVED);
-  EXPECT_EQ(3, link_doctor_handler()->num_requests());
+  EXPECT_EQ(3, link_doctor_interceptor()->num_requests());
 }
 
 // Test that a DNS error occuring in the main frame does not result in an
 // additional session history entry.
 IN_PROC_BROWSER_TEST_F(ErrorPageTest, DNSError_GoBack2Forward2) {
   NavigateToFileURL(FILE_PATH_LITERAL("title3.html"));
 
   ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
        browser(), GetDnsErrorURL(), 2);
   ExpectDisplayingNavigationCorrections(browser(), net::ERR_NAME_NOT_RESOLVED);
-  EXPECT_EQ(1, link_doctor_handler()->num_requests());
+  EXPECT_EQ(1, link_doctor_interceptor()->num_requests());
 
   NavigateToFileURL(FILE_PATH_LITERAL("title2.html"));
 
   GoBackAndWaitForNavigations(2);
   ExpectDisplayingNavigationCorrections(browser(), net::ERR_NAME_NOT_RESOLVED);
-  EXPECT_EQ(2, link_doctor_handler()->num_requests());
+  EXPECT_EQ(2, link_doctor_interceptor()->num_requests());
 
   GoBackAndWaitForTitle("Title Of More Awesomeness", 1);
 
   GoForwardAndWaitForNavigations(2);
   ExpectDisplayingNavigationCorrections(browser(), net::ERR_NAME_NOT_RESOLVED);
-  EXPECT_EQ(3, link_doctor_handler()->num_requests());
+  EXPECT_EQ(3, link_doctor_interceptor()->num_requests());
 
   GoForwardAndWaitForTitle("Title Of Awesomeness", 1);
-  EXPECT_EQ(3, link_doctor_handler()->num_requests());
+  EXPECT_EQ(3, link_doctor_interceptor()->num_requests());
 }
 
 // Test that the search button on a DNS error page works.
 IN_PROC_BROWSER_TEST_F(ErrorPageTest, DNSError_DoSearch) {
   // The first navigation should fail, and the second one should be the error
   // page.
   ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
        browser(), GetDnsErrorURL(), 2);
   ExpectDisplayingNavigationCorrections(browser(), net::ERR_NAME_NOT_RESOLVED);
-  EXPECT_EQ(1, link_doctor_handler()->num_requests());
+  EXPECT_EQ(1, link_doctor_interceptor()->num_requests());
 
   content::WebContents* web_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
 
   // Do a search and make sure the browser ends up at the right page.
   content::TestNavigationObserver nav_observer(web_contents, 1);
   content::TitleWatcher title_watcher(
       web_contents,
       base::ASCIIToUTF16("Title Of More Awesomeness"));
   // Can't use content::ExecuteScript because it waits for scripts to send
   // notification that they've run, and scripts that trigger a navigation may
   // not send that notification.
   web_contents->GetMainFrame()->ExecuteJavaScript(
       base::ASCIIToUTF16("document.getElementById('search-button').click();"));
   nav_observer.Wait();
   EXPECT_EQ(base::ASCIIToUTF16("Title Of More Awesomeness"),
             title_watcher.WaitAndGetTitle());
 
   // There should have been another Link Doctor request, for tracking purposes.
   // Have to wait for it, since the search page does not depend on having
   // sent the tracking request.
-  link_doctor_handler()->WaitForRequests(2);
-  EXPECT_EQ(2, link_doctor_handler()->num_requests());
+  link_doctor_interceptor()->WaitForRequests(2);
+  EXPECT_EQ(2, link_doctor_interceptor()->num_requests());
 
   // Check the path and query string.
   std::string url;
   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
                   browser()->tab_strip_model()->GetActiveWebContents(),
                   "domAutomationController.send(window.location.href);",
                   &url));
   EXPECT_EQ("/search", GURL(url).path());
   EXPECT_EQ("q=search%20query", GURL(url).query());
 
   // Go back to the error page, to make sure the history is correct.
   GoBackAndWaitForNavigations(2);
   ExpectDisplayingNavigationCorrections(browser(), net::ERR_NAME_NOT_RESOLVED);
-  EXPECT_EQ(3, link_doctor_handler()->num_requests());
+  EXPECT_EQ(3, link_doctor_interceptor()->num_requests());
 }
 
 // Test that the reload button on a DNS error page works.
 IN_PROC_BROWSER_TEST_F(ErrorPageTest, DNSError_DoReload) {
   // The first navigation should fail, and the second one should be the error
   // page.
   ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
        browser(), GetDnsErrorURL(), 2);
   ExpectDisplayingNavigationCorrections(browser(), net::ERR_NAME_NOT_RESOLVED);
-  EXPECT_EQ(1, link_doctor_handler()->num_requests());
+  EXPECT_EQ(1, link_doctor_interceptor()->num_requests());
 
   content::WebContents* web_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
 
   // Clicking the reload button should load the error page again, and there
   // should be two commits, as before.
   content::TestNavigationObserver nav_observer(web_contents, 2);
   // Can't use content::ExecuteScript because it waits for scripts to send
   // notification that they've run, and scripts that trigger a navigation may
   // not send that notification.
   web_contents->GetMainFrame()->ExecuteJavaScript(
       base::ASCIIToUTF16("document.getElementById('reload-button').click();"));
   nav_observer.Wait();
   ExpectDisplayingNavigationCorrections(browser(), net::ERR_NAME_NOT_RESOLVED);
 
   // There should have two more requests to the correction service:  One for the
   // new error page, and one for tracking purposes.  Have to make sure to wait
   // for the tracking request, since the new error page does not depend on it.
-  link_doctor_handler()->WaitForRequests(3);
-  EXPECT_EQ(3, link_doctor_handler()->num_requests());
+  link_doctor_interceptor()->WaitForRequests(3);
+  EXPECT_EQ(3, link_doctor_interceptor()->num_requests());
 }
 
 // Test that clicking links on a DNS error page works.
 IN_PROC_BROWSER_TEST_F(ErrorPageTest, DNSError_DoClickLink) {
   // The first navigation should fail, and the second one should be the error
   // page.
   ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
        browser(), GetDnsErrorURL(), 2);
   ExpectDisplayingNavigationCorrections(browser(), net::ERR_NAME_NOT_RESOLVED);
-  EXPECT_EQ(1, link_doctor_handler()->num_requests());
+  EXPECT_EQ(1, link_doctor_interceptor()->num_requests());
 
   content::WebContents* web_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
 
   // Simulate a click on a link.
 
   content::TitleWatcher title_watcher(
       web_contents,
       base::ASCIIToUTF16("Title Of Awesomeness"));
   std::string link_selector =
       "document.querySelector('a[href=\"http://mock.http/title2.html\"]')";
   // The tracking request is triggered by onmousedown, so it catches middle
   // mouse button clicks, as well as left clicks.
   web_contents->GetMainFrame()->ExecuteJavaScript(
       base::ASCIIToUTF16(link_selector + ".onmousedown();"));
   // Can't use content::ExecuteScript because it waits for scripts to send
   // notification that they've run, and scripts that trigger a navigation may
   // not send that notification.
   web_contents->GetMainFrame()->ExecuteJavaScript(
       base::ASCIIToUTF16(link_selector + ".click();"));
   EXPECT_EQ(base::ASCIIToUTF16("Title Of Awesomeness"),
             title_watcher.WaitAndGetTitle());
 
   // There should have been a tracking request to the correction service.  Have
   // to make sure to wait the tracking request, since the new page does not
   // depend on it.
-  link_doctor_handler()->WaitForRequests(2);
-  EXPECT_EQ(2, link_doctor_handler()->num_requests());
+  link_doctor_interceptor()->WaitForRequests(2);
+  EXPECT_EQ(2, link_doctor_interceptor()->num_requests());
 }
 
 // Test that a DNS error occuring in an iframe does not result in showing
 // navigation corrections.
 IN_PROC_BROWSER_TEST_F(ErrorPageTest, IFrameDNSError_Basic) {
   NavigateToURLAndWaitForTitle(
       content::URLRequestMockHTTPJob::GetMockUrl(
           base::FilePath(FILE_PATH_LITERAL("iframe_dns_error.html"))),
       "Blah",
       1);
   // We expect to have two history entries, since we started off with navigation
   // to "about:blank" and then navigated to "iframe_dns_error.html".
   EXPECT_EQ(2,
       browser()->tab_strip_model()->GetActiveWebContents()->
           GetController().GetEntryCount());
-  EXPECT_EQ(0, link_doctor_handler()->num_requests());
+  EXPECT_EQ(0, link_doctor_interceptor()->num_requests());
 }
 
 // This test fails regularly on win_rel trybots. See crbug.com/121540
 #if defined(OS_WIN)
 #define MAYBE_IFrameDNSError_GoBack DISABLED_IFrameDNSError_GoBack
 #else
 #define MAYBE_IFrameDNSError_GoBack IFrameDNSError_GoBack
 #endif
 // Test that a DNS error occuring in an iframe does not result in an
 // additional session history entry.
 IN_PROC_BROWSER_TEST_F(ErrorPageTest, MAYBE_IFrameDNSError_GoBack) {
   NavigateToFileURL(FILE_PATH_LITERAL("title2.html"));
   NavigateToFileURL(FILE_PATH_LITERAL("iframe_dns_error.html"));
   GoBackAndWaitForTitle("Title Of Awesomeness", 1);
-  EXPECT_EQ(0, link_doctor_handler()->num_requests());
+  EXPECT_EQ(0, link_doctor_interceptor()->num_requests());
 }
 
 // This test fails regularly on win_rel trybots. See crbug.com/121540
 //
 // This fails on linux_aura bringup: http://crbug.com/163931
 #if defined(OS_WIN) || (defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(USE_AURA))
 #define MAYBE_IFrameDNSError_GoBackAndForward DISABLED_IFrameDNSError_GoBackAndForward
 #else
 #define MAYBE_IFrameDNSError_GoBackAndForward IFrameDNSError_GoBackAndForward
 #endif
 // Test that a DNS error occuring in an iframe does not result in an
 // additional session history entry.
 IN_PROC_BROWSER_TEST_F(ErrorPageTest, MAYBE_IFrameDNSError_GoBackAndForward) {
   NavigateToFileURL(FILE_PATH_LITERAL("title2.html"));
   NavigateToFileURL(FILE_PATH_LITERAL("iframe_dns_error.html"));
   GoBackAndWaitForTitle("Title Of Awesomeness", 1);
   GoForwardAndWaitForTitle("Blah", 1);
-  EXPECT_EQ(0, link_doctor_handler()->num_requests());
+  EXPECT_EQ(0, link_doctor_interceptor()->num_requests());
 }
 
 // Test that a DNS error occuring in an iframe, once the main document is
 // completed loading, does not result in an additional session history entry.
 // To ensure that the main document has completed loading, JavaScript is used to
 // inject an iframe after loading is done.
 IN_PROC_BROWSER_TEST_F(ErrorPageTest, IFrameDNSError_JavaScript) {
   content::WebContents* wc =
       browser()->tab_strip_model()->GetActiveWebContents();
   GURL fail_url =
@@ skipping 44 matching lines @@
     TestFailProvisionalLoadObserver fail_observer(wc);
     content::WindowedNotificationObserver load_observer(
         content::NOTIFICATION_LOAD_STOP,
         content::Source<NavigationController>(&wc->GetController()));
     wc->GetMainFrame()->ExecuteJavaScript(base::ASCIIToUTF16(script));
     load_observer.Wait();
 
     EXPECT_EQ(fail_url, fail_observer.fail_url());
     EXPECT_EQ(2, wc->GetController().GetEntryCount());
   }
-  EXPECT_EQ(0, link_doctor_handler()->num_requests());
+  EXPECT_EQ(0, link_doctor_interceptor()->num_requests());
 }
 
 // Checks that navigation corrections are not loaded when we receive an actual
 // 404 page.
 IN_PROC_BROWSER_TEST_F(ErrorPageTest, Page404) {
   NavigateToURLAndWaitForTitle(
       content::URLRequestMockHTTPJob::GetMockUrl(
           base::FilePath(FILE_PATH_LITERAL("page404.html"))),
       "SUCCESS",
       1);
-  EXPECT_EQ(0, link_doctor_handler()->num_requests());
+  EXPECT_EQ(0, link_doctor_interceptor()->num_requests());
 }
 
 // Checks that when an error occurs, the stale cache status of the page
 // is correctly transferred, and that stale cached copied can be loaded
 // from the javascript.
 IN_PROC_BROWSER_TEST_F(ErrorPageTest, StaleCacheStatus) {
   ASSERT_TRUE(test_server()->Start());
   // Load cache with entry with "nocache" set, to create stale
   // cache.
   GURL test_url(test_server()->GetURL("files/nocache.html"));
@@ skipping 27 matching lines @@
   // Clear the cache and reload the same URL; confirm the error page is told
   // that there is no cached copy.
   BrowsingDataRemover* remover =
       BrowsingDataRemover::CreateForUnboundedRange(browser()->profile());
   remover->Remove(BrowsingDataRemover::REMOVE_CACHE,
                   BrowsingDataHelper::UNPROTECTED_WEB);
   ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
       browser(), test_url, 1);
   EXPECT_TRUE(ProbeStaleCopyValue(false));
   EXPECT_FALSE(IsDisplayingText(browser(), GetLoadStaleButtonLabel()));
-  EXPECT_EQ(0, link_doctor_handler()->num_requests());
+  EXPECT_EQ(0, link_doctor_interceptor()->num_requests());
 }
 
 class ErrorPageAutoReloadTest : public InProcessBrowserTest {
  public:
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     command_line->AppendSwitch(switches::kEnableOfflineAutoReload);
   }
 
-  void InstallProtocolHandler(const GURL& url, int requests_to_fail) {
-    protocol_handler_ = new FailFirstNRequestsProtocolHandler(requests_to_fail);
-    scoped_ptr<URLRequestJobFactory::ProtocolHandler> owned_handler(
-        protocol_handler_);
+  void InstallInterceptor(const GURL& url, int requests_to_fail) {
+    interceptor_ = new FailFirstNRequestsInterceptor(requests_to_fail);
+    scoped_ptr<net::URLRequestInterceptor> owned_interceptor(interceptor_);
 
     // Tests don't need to wait for this task to complete before using the
     // filter; any requests that might be affected by it will end up in the IO
     // thread's message loop after this posted task anyway.
     //
-    // Ownership of the |protocol_handler_| is passed to an object the IO
-    // thread, but a pointer is kept in the test fixture.  As soon as anything
-    // calls URLRequestFilter::ClearHandlers(), |protocol_handler_| can become
-    // invalid.
+    // Ownership of the interceptor is passed to an object the IO thread, but a
+    // pointer is kept in the test fixture.  As soon as anything calls
+    // URLRequestFilter::ClearHandlers(), |interceptor_| can become invalid.
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        base::Bind(&AddProtocolHandlerForURL, url,
-                   base::Passed(&owned_handler)));
+        base::Bind(&AddInterceptorForURL, url,
+                   base::Passed(&owned_interceptor)));
   }
 
   void NavigateToURLAndWaitForTitle(const GURL& url,
                                     const std::string& expected_title,
                                     int num_navigations) {
     content::TitleWatcher title_watcher(
         browser()->tab_strip_model()->GetActiveWebContents(),
         base::ASCIIToUTF16(expected_title));
 
     ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
         browser(), url, num_navigations);
 
     EXPECT_EQ(base::ASCIIToUTF16(expected_title),
               title_watcher.WaitAndGetTitle());
   }
 
-  FailFirstNRequestsProtocolHandler* protocol_handler() {
-    return protocol_handler_;
+  FailFirstNRequestsInterceptor* interceptor() {
+    return interceptor_;
   }
 
  private:
-  FailFirstNRequestsProtocolHandler* protocol_handler_;
+  FailFirstNRequestsInterceptor* interceptor_;
 };
 
 IN_PROC_BROWSER_TEST_F(ErrorPageAutoReloadTest, AutoReload) {
   GURL test_url("http://error.page.auto.reload");
   const int kRequestsToFail = 2;
-  InstallProtocolHandler(test_url, kRequestsToFail);
+  InstallInterceptor(test_url, kRequestsToFail);
   NavigateToURLAndWaitForTitle(test_url, "Test One", kRequestsToFail + 1);
-  // Note that the protocol handler updates these variables on the IO thread,
+  // Note that the interceptor updates these variables on the IO thread,
   // but this function reads them on the main thread. The requests have to be
   // created (on the IO thread) before NavigateToURLAndWaitForTitle returns or
   // this becomes racey.
-  EXPECT_EQ(kRequestsToFail, protocol_handler()->failures());
-  EXPECT_EQ(kRequestsToFail + 1, protocol_handler()->requests());
+  EXPECT_EQ(kRequestsToFail, interceptor()->failures());
+  EXPECT_EQ(kRequestsToFail + 1, interceptor()->requests());
 }
 
-// Protocol handler that fails all requests with net::ERR_ADDRESS_UNREACHABLE.
-class AddressUnreachableProtocolHandler
-    : public net::URLRequestJobFactory::ProtocolHandler {
+// Interceptor that fails all requests with net::ERR_ADDRESS_UNREACHABLE.
+class AddressUnreachableInterceptor : public net::URLRequestInterceptor {
  public:
-  AddressUnreachableProtocolHandler() {}
-  virtual ~AddressUnreachableProtocolHandler() {}
+  AddressUnreachableInterceptor() {}
+  virtual ~AddressUnreachableInterceptor() {}
 
-  // net::URLRequestJobFactory::ProtocolHandler:
-  virtual net::URLRequestJob* MaybeCreateJob(
+  // net::URLRequestInterceptor:
+  virtual net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE {
     return new URLRequestFailedJob(request,
                                    network_delegate,
                                    net::ERR_ADDRESS_UNREACHABLE);
   }
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(AddressUnreachableProtocolHandler);
+  DISALLOW_COPY_AND_ASSIGN(AddressUnreachableInterceptor);
 };
 
 // A test fixture that returns ERR_ADDRESS_UNREACHABLE for all navigation
 // correction requests.  ERR_NAME_NOT_RESOLVED is more typical, but need to use
 // a different error for the correction service and the original page to
 // validate the right page is being displayed.
 class ErrorPageNavigationCorrectionsFailTest : public ErrorPageTest {
  public:
   // InProcessBrowserTest:
   virtual void SetUpOnMainThread() OVERRIDE {
@@ skipping 10 matching lines @@
 
  private:
   // Adds a filter that causes all correction service requests to fail with
   // ERR_ADDRESS_UNREACHABLE.
   //
   // Also adds the content::URLRequestFailedJob filter.
   static void AddFilters() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     content::URLRequestFailedJob::AddUrlHandler();
 
-    net::URLRequestFilter::GetInstance()->AddUrlProtocolHandler(
+    net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
         google_util::LinkDoctorBaseURL(),
-        scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>(
-            new AddressUnreachableProtocolHandler()));
+        scoped_ptr<net::URLRequestInterceptor>(
+            new AddressUnreachableInterceptor()));
   }
 
   static void RemoveFilters() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     net::URLRequestFilter::GetInstance()->ClearHandlers();
   }
 };
 
 // Make sure that when corrections fail to load, the network error page is
 // successfully loaded.
@@ skipping 102 matching lines @@
       browser(),
       URLRequestFailedJob::GetMockHttpUrlForHostname(net::ERR_UNSAFE_PORT,
                                                      kHostname),
       1);
 
   ToggleHelpBox(browser());
   EXPECT_TRUE(IsDisplayingText(browser(), kHostnameJSUnicode));
 }
 
 }  // namespace