Make URLRequestFilter use URLRequestInterceptors.

chrome/browser/prerender/prerender_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 <deque>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 75 matching lines @@
 #include "extensions/common/switches.h"
 #include "grit/generated_resources.h"
 #include "net/base/escape.h"
 #include "net/cert/x509_certificate.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/ssl/client_cert_store.h"
 #include "net/ssl/ssl_cert_request_info.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 "ui/base/l10n/l10n_util.h"
 #include "url/gurl.h"
 
 using content::BrowserThread;
 using content::DevToolsAgentHost;
 using content::DevToolsClientHost;
 using content::DevToolsManager;
 using content::NavigationController;
 using content::OpenURLParams;
@@ skipping 665 matching lines @@
                           net::NetworkDelegate* network_delegate)
       : net::URLRequestJob(request, network_delegate) {
   }
 
   virtual void Start() OVERRIDE {}
 
  private:
   virtual ~HangingURLRequestJob() {}
 };
 
-class HangingFirstRequestProtocolHandler
-    : public net::URLRequestJobFactory::ProtocolHandler {
+class HangingFirstRequestInterceptor : public net::URLRequestInterceptor {
  public:
-  HangingFirstRequestProtocolHandler(const base::FilePath& file,
-                                     base::Closure callback)
+  HangingFirstRequestInterceptor(const base::FilePath& file,
+                                 base::Closure callback)
       : file_(file),
         callback_(callback),
         first_run_(true) {
   }
-  virtual ~HangingFirstRequestProtocolHandler() {}
+  virtual ~HangingFirstRequestInterceptor() {}
 
-  virtual net::URLRequestJob* MaybeCreateJob(
+  virtual net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE {
     if (first_run_) {
       first_run_ = false;
       if (!callback_.is_null()) {
         BrowserThread::PostTask(
             BrowserThread::UI, FROM_HERE, callback_);
       }
       return new HangingURLRequestJob(request, network_delegate);
     }
     return new content::URLRequestMockHTTPJob(request, network_delegate, file_);
   }
 
  private:
   base::FilePath file_;
   base::Closure callback_;
   mutable bool first_run_;
 };
 
 // Makes |url| never respond on the first load, and then with the contents of
 // |file| afterwards. When the first load has been scheduled, runs |callback| on
 // the UI thread.
-void CreateHangingFirstRequestProtocolHandlerOnIO(const GURL& url,
-                                                  const base::FilePath& file,
-                                                  base::Closure callback) {
+void CreateHangingFirstRequestInterceptorOnIO(
+    const GURL& url, const base::FilePath& file, base::Closure callback) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  scoped_ptr<net::URLRequestJobFactory::ProtocolHandler> never_respond_handler(
-      new HangingFirstRequestProtocolHandler(file, callback));
-  net::URLRequestFilter::GetInstance()->AddUrlProtocolHandler(
+  scoped_ptr<net::URLRequestInterceptor> never_respond_handler(
+      new HangingFirstRequestInterceptor(file, callback));
+  net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
       url, never_respond_handler.Pass());
 }
 
 // Wrapper over URLRequestMockHTTPJob that exposes extra callbacks.
 class MockHTTPJob : public content::URLRequestMockHTTPJob {
  public:
   MockHTTPJob(net::URLRequest* request,
               net::NetworkDelegate* delegate,
               const base::FilePath& file)
       : content::URLRequestMockHTTPJob(request, delegate, file) {
@@ skipping 40 matching lines @@
 
     EXPECT_EQ(expected_count, count_);
   }
  private:
   int count_;
   int expected_count_;
   scoped_ptr<base::RunLoop> loop_;
 };
 
 // Protocol handler which counts the number of requests that start.
-class CountingProtocolHandler
-    : public net::URLRequestJobFactory::ProtocolHandler {
+class CountingInterceptor : public net::URLRequestInterceptor {
  public:
-  CountingProtocolHandler(const base::FilePath& file,
-                          const base::WeakPtr<RequestCounter>& counter)
+  CountingInterceptor(const base::FilePath& file,
+                      const base::WeakPtr<RequestCounter>& counter)
       : file_(file),
         counter_(counter),
         weak_factory_(this) {
   }
-  virtual ~CountingProtocolHandler() {}
+  virtual ~CountingInterceptor() {}
 
-  virtual net::URLRequestJob* MaybeCreateJob(
+  virtual net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE {
     MockHTTPJob* job = new MockHTTPJob(request, network_delegate, file_);
-    job->set_start_callback(base::Bind(&CountingProtocolHandler::RequestStarted,
+    job->set_start_callback(base::Bind(&CountingInterceptor::RequestStarted,
                                        weak_factory_.GetWeakPtr()));
     return job;
   }
 
   void RequestStarted() {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&RequestCounter::RequestStarted, counter_));
   }
 
  private:
   base::FilePath file_;
   base::WeakPtr<RequestCounter> counter_;
-  mutable base::WeakPtrFactory<CountingProtocolHandler> weak_factory_;
+  mutable base::WeakPtrFactory<CountingInterceptor> weak_factory_;
 };
 
 // Makes |url| respond to requests with the contents of |file|, counting the
 // number that start in |counter|.
-void CreateCountingProtocolHandlerOnIO(
+void CreateCountingInterceptorOnIO(
     const GURL& url,
     const base::FilePath& file,
     const base::WeakPtr<RequestCounter>& counter) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  scoped_ptr<net::URLRequestJobFactory::ProtocolHandler> protocol_handler(
-      new CountingProtocolHandler(file, counter));
-  net::URLRequestFilter::GetInstance()->AddUrlProtocolHandler(
-      url, protocol_handler.Pass());
+  scoped_ptr<net::URLRequestInterceptor> request_interceptor(
+      new CountingInterceptor(file, counter));
+  net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
+      url, request_interceptor.Pass());
 }
 
 // Makes |url| respond to requests with the contents of |file|.
-void CreateMockProtocolHandlerOnIO(const GURL& url,
-                                   const base::FilePath& file) {
+void CreateMockInterceptorOnIO(const GURL& url, const base::FilePath& file) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  net::URLRequestFilter::GetInstance()->AddUrlProtocolHandler(
-      url, content::URLRequestMockHTTPJob::CreateProtocolHandlerForSingleFile(
-          file));
+  net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
+      url,
+      content::URLRequestMockHTTPJob::CreateInterceptorForSingleFile(file));
 }
 
 // A ContentBrowserClient that cancels all prerenderers on OpenURL.
 class TestContentBrowserClient : public chrome::ChromeContentBrowserClient {
  public:
   TestContentBrowserClient() {}
   virtual ~TestContentBrowserClient() {}
 
   // chrome::ChromeContentBrowserClient implementation.
   virtual bool ShouldAllowOpenURL(content::SiteInstance* site_instance,
@@ skipping 946 matching lines @@
 // Checks that the prerendering of a page is canceled correctly if we try to
 // swap it in before it commits.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderNoCommitNoSwap) {
   // Navigate to a page that triggers a prerender for a URL that never commits.
   const GURL kNoCommitUrl("http://never-respond.example.com");
   base::FilePath file(GetTestPath("prerender_page.html"));
 
   base::RunLoop prerender_start_loop;
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&CreateHangingFirstRequestProtocolHandlerOnIO,
-                 kNoCommitUrl, file, prerender_start_loop.QuitClosure()));
+      base::Bind(&CreateHangingFirstRequestInterceptorOnIO, kNoCommitUrl, file,
+                 prerender_start_loop.QuitClosure()));
   DisableJavascriptCalls();
   PrerenderTestURL(kNoCommitUrl,
                    FINAL_STATUS_NAVIGATION_UNCOMMITTED,
                    0);
   // Wait for the hanging request to be scheduled.
   prerender_start_loop.Run();
 
   // Navigate to the URL, but assume the contents won't be swapped in.
   NavigateToDestURLWithDisposition(CURRENT_TAB, false);
 }
 
 // Checks that client redirects don't add alias URLs until after they commit.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderNoCommitNoSwap2) {
   // Navigate to a page that then navigates to a URL that never commits.
   const GURL kNoCommitUrl("http://never-respond.example.com");
   base::FilePath file(GetTestPath("prerender_page.html"));
 
   base::RunLoop prerender_start_loop;
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&CreateHangingFirstRequestProtocolHandlerOnIO,
-                 kNoCommitUrl, file, prerender_start_loop.QuitClosure()));
+      base::Bind(&CreateHangingFirstRequestInterceptorOnIO, kNoCommitUrl, file,
+                 prerender_start_loop.QuitClosure()));
   DisableJavascriptCalls();
   PrerenderTestURL(CreateClientRedirect(kNoCommitUrl.spec()),
                    FINAL_STATUS_APP_TERMINATING, 1);
   // Wait for the hanging request to be scheduled.
   prerender_start_loop.Run();
 
   // Navigating to the second URL should not swap.
   NavigateToURLWithDisposition(kNoCommitUrl, CURRENT_TAB, false);
 }
 
@@ skipping 1182 matching lines @@
 // Checks that when a prerendered page is swapped in to a referring page, the
 // unload handlers on the referring page are executed.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderUnload) {
   // Matches URL in prerender_loader_with_unload.html.
   const GURL unload_url("http://unload-url.test");
   base::FilePath empty_file = ui_test_utils::GetTestFilePath(
       base::FilePath(), base::FilePath(FILE_PATH_LITERAL("empty.html")));
   RequestCounter unload_counter;
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&CreateCountingProtocolHandlerOnIO,
+      base::Bind(&CreateCountingInterceptorOnIO,
                  unload_url, empty_file, unload_counter.AsWeakPtr()));
 
   set_loader_path("files/prerender/prerender_loader_with_unload.html");
   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
   unload_counter.WaitForCount(1);
 }
 
 // Checks that a hanging unload on the referring page of a prerender swap does
 // not crash the browser on exit.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHangingUnload) {
   // Matches URL in prerender_loader_with_unload.html.
   const GURL hang_url("http://unload-url.test");
   base::FilePath empty_file = ui_test_utils::GetTestFilePath(
       base::FilePath(), base::FilePath(FILE_PATH_LITERAL("empty.html")));
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&CreateHangingFirstRequestProtocolHandlerOnIO,
+      base::Bind(&CreateHangingFirstRequestInterceptorOnIO,
                  hang_url, empty_file,
                  base::Closure()));
 
   set_loader_path("files/prerender/prerender_loader_with_unload.html");
   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 
 // Checks that when the history is cleared, prerendering is cancelled and
@@ skipping 223 matching lines @@
                        MatchCompleteDummyCancelNavigation) {
   UMAHistogramHelper histograms;
 
   // Arrange for a URL to hang.
   const GURL kNoCommitUrl("http://never-respond.example.com");
   base::FilePath file(FILE_PATH_LITERAL(
       "chrome/test/data/prerender/prerender_page.html"));
   base::RunLoop hang_loop;
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&CreateHangingFirstRequestProtocolHandlerOnIO,
-                 kNoCommitUrl, file, hang_loop.QuitClosure()));
+      base::Bind(&CreateHangingFirstRequestInterceptorOnIO, kNoCommitUrl,
+                 file, hang_loop.QuitClosure()));
 
   // First, fire a prerender that aborts after it completes its load.
   std::vector<FinalStatus> expected_final_status_queue;
   expected_final_status_queue.push_back(FINAL_STATUS_INVALID_HTTP_METHOD);
   expected_final_status_queue.push_back(FINAL_STATUS_WOULD_HAVE_BEEN_USED);
   PrerenderTestURL("files/prerender/prerender_xhr_put.html",
                    expected_final_status_queue, 1);
   histograms.Fetch();
   histograms.ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
   histograms.ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
@@ skipping 365 matching lines @@
   // Cross-process navigation logic for renderer-initiated navigations
   // is partially controlled by the renderer, namely
   // ChromeContentRendererClient. This test instead relies on the Web
   // Store triggering such navigations.
   std::string webstore_url = extension_urls::GetWebstoreLaunchURL();
 
   // Mock out requests to the Web Store.
   base::FilePath file(GetTestPath("prerender_page.html"));
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&CreateMockProtocolHandlerOnIO,
-                 GURL(webstore_url), file));
+      base::Bind(&CreateMockInterceptorOnIO, GURL(webstore_url), file));
 
   PrerenderTestURL(CreateClientRedirect(webstore_url),
                    FINAL_STATUS_OPEN_URL, 1);
 }
 
 // Checks that canceling a MatchComplete dummy doesn't result in two
 // stop events.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, CancelMatchCompleteDummy) {
   std::vector<FinalStatus> expected_final_status_queue;
   expected_final_status_queue.push_back(FINAL_STATUS_JAVASCRIPT_ALERT);
@@ skipping 151 matching lines @@
 // Attempt a swap-in in a new tab, verifying that session storage namespace
 // merging works.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPageNewTab) {
   // Mock out some URLs and count the number of requests to one of them. Both
   // prerender_session_storage.html and init_session_storage.html need to be
   // mocked so they are same-origin.
   const GURL kInitURL("http://prerender.test/init_session_storage.html");
   base::FilePath init_file = GetTestPath("init_session_storage.html");
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&CreateMockProtocolHandlerOnIO, kInitURL, init_file));
+      base::Bind(&CreateMockInterceptorOnIO, kInitURL, init_file));
 
   const GURL kTestURL("http://prerender.test/prerender_session_storage.html");
   base::FilePath test_file = GetTestPath("prerender_session_storage.html");
   RequestCounter counter;
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&CreateCountingProtocolHandlerOnIO,
+      base::Bind(&CreateCountingInterceptorOnIO,
                  kTestURL, test_file, counter.AsWeakPtr()));
 
   PrerenderTestURL(kTestURL, FINAL_STATUS_USED, 1);
 
   // Open a new tab to navigate in.
   ui_test_utils::NavigateToURLWithDisposition(
       current_browser(), kInitURL, NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   // Now navigate in the new tab. Set expect_swap_to_succeed to false because
@@ skipping 22 matching lines @@
   base::FilePath test_data_dir;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir));
 
   // Mock out some URLs and count the number of requests to one of them. Both
   // prerender_session_storage.html and init_session_storage.html need to be
   // mocked so they are same-origin.
   const GURL kInitURL("http://prerender.test/init_session_storage.html");
   base::FilePath init_file = GetTestPath("init_session_storage.html");
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&CreateMockProtocolHandlerOnIO, kInitURL, init_file));
+      base::Bind(&CreateMockInterceptorOnIO, kInitURL, init_file));
 
   const GURL kTestURL("http://prerender.test/prerender_session_storage.html");
   base::FilePath test_file = GetTestPath("prerender_session_storage.html");
   RequestCounter counter;
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&CreateCountingProtocolHandlerOnIO,
+      base::Bind(&CreateCountingInterceptorOnIO,
                  kTestURL, test_file, counter.AsWeakPtr()));
 
   PrerenderTestURL(kTestURL, FINAL_STATUS_USED, 1);
 
   // Open a new tab to navigate in.
   ui_test_utils::NavigateToURLWithDisposition(
       current_browser(), kInitURL, NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   // Navigate to about:blank so the next navigation is cross-process.
@@ skipping 146 matching lines @@
 
 // Checks that <a ping> requests are not dropped in prerender.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPing) {
   // Count hits to a certain URL.
   const GURL kPingURL("http://prerender.test/ping");
   base::FilePath empty_file = ui_test_utils::GetTestFilePath(
       base::FilePath(), base::FilePath(FILE_PATH_LITERAL("empty.html")));
   RequestCounter ping_counter;
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&CreateCountingProtocolHandlerOnIO,
+      base::Bind(&CreateCountingInterceptorOnIO,
                  kPingURL, empty_file, ping_counter.AsWeakPtr()));
 
   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
   OpenDestURLViaClickPing(kPingURL);
 
   ping_counter.WaitForCount(1);
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPPLTNormalNavigation) {
   UMAHistogramHelper histograms;
@@ skipping 228 matching lines @@
 
   // Navigate to the URL entered.
   omnibox_view->model()->AcceptInput(CURRENT_TAB, false);
 
   // Prerender should be running, but abandoned.
   EXPECT_TRUE(
       GetAutocompleteActionPredictor()->IsPrerenderAbandonedForTesting());
 }
 
 }  // namespace prerender