Make URLRequestFilter use URLRequestInterceptors.

chrome/browser/net/dns_probe_browsertest.cc

 // Copyright 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 <set>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
@@ skipping 17 matching lines @@
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_navigation_observer.h"
 #include "content/test/net/url_request_failed_job.h"
 #include "content/test/net/url_request_mock_http_job.h"
 #include "net/base/net_errors.h"
 #include "net/dns/dns_test_util.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"
 
 using base::Bind;
 using base::Callback;
 using base::Closure;
 using base::ConstRef;
 using base::FilePath;
 using base::MessageLoop;
 using base::Unretained;
 using chrome_common_net::DnsProbeStatus;
 using content::BrowserThread;
 using content::URLRequestFailedJob;
 using content::URLRequestMockHTTPJob;
 using content::WebContents;
 using google_util::LinkDoctorBaseURL;
 using net::MockDnsClientRule;
 using net::NetworkDelegate;
 using net::URLRequest;
 using net::URLRequestFilter;
+using net::URLRequestInterceptor;
 using net::URLRequestJob;
-using net::URLRequestJobFactory;
 using ui_test_utils::NavigateToURL;
 using ui_test_utils::NavigateToURLBlockUntilNavigationsComplete;
 
 namespace chrome_browser_net {
 
 namespace {
 
 // Postable function to run a Closure on the UI thread.  Since
 // BrowserThread::PostTask returns a bool, it can't directly be posted to
 // another thread.
@@ skipping 138 matching lines @@
   virtual ~DelayableURLRequestMockHTTPJob() {
     if (should_delay_)
       destruction_callback_.Run(this);
   }
 
   bool should_delay_;
   bool start_delayed_;
   const DestructionCallback destruction_callback_;
 };
 
-// ProtocolHandler for navigation correction requests.  Can cause requests to
+// Interceptor for navigation correction requests.  Can cause requests to
 // fail with an error, and/or delay a request until a test allows to continue.
 // Also can run a callback when a delayed request is cancelled.
-class BreakableCorrectionProtocolHandler
-    : public URLRequestJobFactory::ProtocolHandler {
+class BreakableCorrectionInterceptor : public URLRequestInterceptor {
  public:
-  explicit BreakableCorrectionProtocolHandler(
+  explicit BreakableCorrectionInterceptor(
       const FilePath& mock_corrections_file_path)
       : mock_corrections_file_path_(mock_corrections_file_path),
         net_error_(net::OK),
         delay_requests_(false),
         on_request_destroyed_callback_(
-            base::Bind(&BreakableCorrectionProtocolHandler::OnRequestDestroyed,
+            base::Bind(&BreakableCorrectionInterceptor::OnRequestDestroyed,
                        base::Unretained(this))) {
   }
 
-  virtual ~BreakableCorrectionProtocolHandler() {
+  virtual ~BreakableCorrectionInterceptor() {
     // All delayed requests should have been resumed or cancelled by this point.
     EXPECT_TRUE(delayed_requests_.empty());
   }
 
-  virtual URLRequestJob* MaybeCreateJob(
+  virtual URLRequestJob* MaybeInterceptRequest(
       URLRequest* request,
       NetworkDelegate* network_delegate) const OVERRIDE {
     if (net_error_ != net::OK) {
       DelayableURLRequestFailedJob* job =
           new DelayableURLRequestFailedJob(
               request, network_delegate, net_error_, delay_requests_,
               on_request_destroyed_callback_);
       if (delay_requests_)
         delayed_requests_.insert(job);
       return job;
@@ skipping 71 matching lines @@
                              MockDnsClientRule::Result public_good_result);
   void SetCorrectionServiceNetError(int net_error);
   void SetCorrectionServiceDelayRequests(bool delay_requests);
   void SetRequestDestructionCallback(const base::Closure& callback);
   void StartDelayedProbes(int expected_delayed_probe_count);
 
  private:
   IOThread* io_thread_;
   DnsProbeService* original_dns_probe_service_;
   DelayingDnsProbeService* delaying_dns_probe_service_;
-  BreakableCorrectionProtocolHandler* protocol_handler_;
+  BreakableCorrectionInterceptor* interceptor_;
   FilePath mock_corrections_file_path_;
 };
 
 DnsProbeBrowserTestIOThreadHelper::DnsProbeBrowserTestIOThreadHelper()
     : io_thread_(NULL),
       original_dns_probe_service_(NULL),
       delaying_dns_probe_service_(NULL),
-      protocol_handler_(NULL),
+      interceptor_(NULL),
       mock_corrections_file_path_(GetMockLinkDoctorFilePath()) {}
 
 void DnsProbeBrowserTestIOThreadHelper::SetUpOnIOThread(IOThread* io_thread) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   CHECK(io_thread);
   CHECK(!io_thread_);
   CHECK(!original_dns_probe_service_);
   CHECK(!delaying_dns_probe_service_);
-  CHECK(!protocol_handler_);
+  CHECK(!interceptor_);
 
   io_thread_ = io_thread;
 
   delaying_dns_probe_service_ = new DelayingDnsProbeService();
 
   IOThread::Globals* globals = io_thread_->globals();
   original_dns_probe_service_ = globals->dns_probe_service.release();
   globals->dns_probe_service.reset(delaying_dns_probe_service_);
 
   URLRequestFailedJob::AddUrlHandler();
 
-  scoped_ptr<URLRequestJobFactory::ProtocolHandler> protocol_handler(
-      new BreakableCorrectionProtocolHandler(mock_corrections_file_path_));
-  protocol_handler_ =
-      static_cast<BreakableCorrectionProtocolHandler*>(protocol_handler.get());
-  URLRequestFilter::GetInstance()->AddUrlProtocolHandler(
-      LinkDoctorBaseURL(), protocol_handler.Pass());
+  interceptor_ =
+      new BreakableCorrectionInterceptor(mock_corrections_file_path_);
+  URLRequestFilter::GetInstance()->AddUrlInterceptor(
+      LinkDoctorBaseURL(), scoped_ptr<URLRequestInterceptor>(interceptor_));
 }
 
 void DnsProbeBrowserTestIOThreadHelper::CleanUpOnIOThreadAndDeleteHelper() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   URLRequestFilter::GetInstance()->ClearHandlers();
 
   IOThread::Globals* globals = io_thread_->globals();
   scoped_ptr<DnsProbeService> delaying_dns_probe_service(
       globals->dns_probe_service.release());
@@ skipping 13 matching lines @@
   service->SetSystemClientForTesting(
       CreateMockDnsClientForProbes(system_result));
   service->SetPublicClientForTesting(
       CreateMockDnsClientForProbes(public_result));
 }
 
 void DnsProbeBrowserTestIOThreadHelper::SetCorrectionServiceNetError(
     int net_error) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  protocol_handler_->set_net_error(net_error);
+  interceptor_->set_net_error(net_error);
 }
 
 void DnsProbeBrowserTestIOThreadHelper::SetCorrectionServiceDelayRequests(
     bool delay_requests) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  protocol_handler_->SetDelayRequests(delay_requests);
+  interceptor_->SetDelayRequests(delay_requests);
 }
 
 void DnsProbeBrowserTestIOThreadHelper::SetRequestDestructionCallback(
     const base::Closure& callback) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  protocol_handler_->SetRequestDestructionCallback(callback);
+  interceptor_->SetRequestDestructionCallback(callback);
 }
 
 void DnsProbeBrowserTestIOThreadHelper::StartDelayedProbes(
     int expected_delayed_probe_count) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   CHECK(delaying_dns_probe_service_);
 
   int actual_delayed_probe_count =
       delaying_dns_probe_service_->delayed_probe_count();
@@ skipping 565 matching lines @@
 
   EXPECT_EQ(chrome_common_net::DNS_PROBE_FINISHED_INCONCLUSIVE,
             WaitForSentStatus());
   EXPECT_EQ(0, pending_status_count());
   ExpectDisplayingLocalErrorPage("ERR_NAME_NOT_RESOLVED");
 }
 
 }  // namespace
 
 }  // namespace chrome_browser_net