Make URLRequestFilter use URLRequestInterceptors.

chrome/browser/net/load_timing_browsertest.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 <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/browser_test_utils.h"
 #include "net/base/load_timing_info.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
 #include "net/url_request/url_request_file_job.h"
 #include "net/url_request/url_request_filter.h"
-#include "net/url_request/url_request_job_factory.h"
+#include "net/url_request/url_request_interceptor.h"
 #include "url/gurl.h"
 
 // This file tests that net::LoadTimingInfo is correctly hooked up to the
 // NavigationTiming API.  It depends on behavior in a large number of files
 // spread across multiple projects, so is somewhat arbitrarily put in
 // chrome/browser/net.
 
 using content::BrowserThread;
 
 namespace {
@@ skipping 168 matching lines @@
 
   // Load times to use, relative to |start_time_|.
   const TimingDeltas load_timing_deltas_;
   base::TimeTicks start_time_;
 
   base::WeakPtrFactory<MockUrlRequestJobWithTiming> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MockUrlRequestJobWithTiming);
 };
 
-// A protocol handler that returns mock URLRequestJobs that return the specified
-// file with the given timings.  Constructed on the UI thread, but after that,
-// lives and is destroyed on the IO thread.
-class TestProtocolHandler : public net::URLRequestJobFactory::ProtocolHandler {
+// AURLRequestInterceptor that returns mock URLRequestJobs that return the
+// specified file with the given timings.  Constructed on the UI thread, but
+// after that, lives and is destroyed on the IO thread.
+class TestInterceptor : public net::URLRequestInterceptor {
  public:
-  TestProtocolHandler(const base::FilePath& path,
-                      const TimingDeltas& load_timing_deltas)
+  TestInterceptor(const base::FilePath& path,
+                  const TimingDeltas& load_timing_deltas)
       : path_(path), load_timing_deltas_(load_timing_deltas) {
     EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::UI));
   }
 
-  virtual ~TestProtocolHandler() {
+  virtual ~TestInterceptor() {
     EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
   }
 
   // Registers |this| with the URLRequestFilter, which takes ownership of it.
   void Register() {
     EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
-    net::URLRequestFilter::GetInstance()->AddHostnameProtocolHandler(
-        "http", kTestDomain,
-        scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>(this));
+    net::URLRequestFilter::GetInstance()->AddHostnameInterceptor(
+        "http", kTestDomain, scoped_ptr<net::URLRequestInterceptor>(this));
   }
 
   // Unregisters |this| with the URLRequestFilter, which should then delete
   // |this|.
   void Unregister() {
     EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     net::URLRequestFilter::GetInstance()->RemoveHostnameHandler(
         "http", kTestDomain);
   }
 
   // net::URLRequestJobFactory::ProtocolHandler implementation:
-  virtual net::URLRequestJob* MaybeCreateJob(
+  virtual net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE {
     EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
     return new MockUrlRequestJobWithTiming(request, network_delegate, path_,
                                            load_timing_deltas_);
   }
 
  private:
   // Path of the file to use as the response body.
   const base::FilePath path_;
 
   // Load times for each request to use, relative to when the Job starts.
   const TimingDeltas load_timing_deltas_;
 
-  DISALLOW_COPY_AND_ASSIGN(TestProtocolHandler);
+  DISALLOW_COPY_AND_ASSIGN(TestInterceptor);
 };
 
 class LoadTimingBrowserTest : public InProcessBrowserTest {
  public:
   LoadTimingBrowserTest() {
   }
 
   virtual ~LoadTimingBrowserTest() {
   }
 
   // Navigates to |url| and writes the resulting navigation timings to
   // |navigation_deltas|.
   void RunTestWithUrl(const GURL& url, TimingDeltas* navigation_deltas) {
     ui_test_utils::NavigateToURL(browser(), url);
     GetResultDeltas(navigation_deltas);
   }
 
   // Navigates to a url that returns the timings indicated by
   // |load_timing_deltas| and writes the resulting navigation timings to
   // |navigation_deltas|.  Uses a generic test page.
   void RunTest(const TimingDeltas& load_timing_deltas,
                TimingDeltas* navigation_deltas) {
     // None of the tests care about the contents of the test page.  Just do
     // this here because PathService has thread restrictions on some platforms.
     base::FilePath path;
     PathService::Get(chrome::DIR_TEST_DATA, &path);
     path = path.AppendASCII("title1.html");
 
-    // Create and register protocol handler.
-    TestProtocolHandler* protocol_handler =
-        new TestProtocolHandler(path, load_timing_deltas);
+    // Create and register request interceptor.
+    TestInterceptor* test_interceptor =
+        new TestInterceptor(path, load_timing_deltas);
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                            base::Bind(&TestProtocolHandler::Register,
-                                       base::Unretained(protocol_handler)));
+                            base::Bind(&TestInterceptor::Register,
+                                       base::Unretained(test_interceptor)));
 
     // Navigate to the page.
     RunTestWithUrl(GURL(kTestUrl), navigation_deltas);
 
     // Once navigation is complete, unregister the protocol handler.
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                            base::Bind(&TestProtocolHandler::Unregister,
-                                        base::Unretained(protocol_handler)));
+                            base::Bind(&TestInterceptor::Unregister,
+                                        base::Unretained(test_interceptor)));
   }
 
  private:
   // Reads applicable times from performance.timing and writes them to
   // |navigation_deltas|.  Proxy times and send end cannot be read from the
   // Navigation Timing API, so those are all left as null.
   void GetResultDeltas(TimingDeltas* navigation_deltas) {
     *navigation_deltas = TimingDeltas();
 
     navigation_deltas->dns_start = GetResultDelta("domainLookupStart");
@@ skipping 272 matching lines @@
             navigation_deltas.send_start.GetDelta());
   // The only times that are guaranteed to be distinct are send_start and
   // received_headers_end.
   EXPECT_LT(navigation_deltas.send_start.GetDelta(),
             navigation_deltas.receive_headers_end.GetDelta());
 
   EXPECT_TRUE(navigation_deltas.ssl_start.is_null());
 }
 
 }  // namespace