Make URLRequestFilter use URLRequestInterceptors.

chrome/browser/policy/cloud/test_request_interceptor.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 "chrome/browser/policy/cloud/test_request_interceptor.h"
 
 #include <limits>
 #include <queue>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "content/test/net/url_request_mock_http_job.h"
 #include "net/base/net_errors.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_data_stream.h"
 #include "net/base/upload_element_reader.h"
 #include "net/url_request/url_request_error_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 "net/url_request/url_request_test_job.h"
 #include "url/gurl.h"
 
 namespace em = enterprise_management;
 
 namespace policy {
 
 namespace {
 
 // Helper callback for jobs that should fail with a network |error|.
@@ skipping 103 matching lines @@
 
   static const char kGoodHeaders[] =
       "HTTP/1.1 200 OK\0"
       "Content-type: application/protobuf\0"
       "\0";
   std::string headers(kGoodHeaders, arraysize(kGoodHeaders));
   return new net::URLRequestTestJob(
       request, network_delegate, headers, data, true);
 }
 
+void RegisterHttpInterceptor(
+    const std::string& hostname,
+    scoped_ptr<net::URLRequestInterceptor> interceptor) {
+  net::URLRequestFilter::GetInstance()->AddHostnameInterceptor(
+      "http", hostname, interceptor.Pass());
+}
+
 }  // namespace
 
-class TestRequestInterceptor::Delegate
-    : public net::URLRequestJobFactory::ProtocolHandler {
+class TestRequestInterceptor::Delegate : public net::URLRequestInterceptor {
  public:
   Delegate(const std::string& hostname,
            scoped_refptr<base::SequencedTaskRunner> io_task_runner);
   virtual ~Delegate();
 
-  // ProtocolHandler implementation:
-  virtual net::URLRequestJob* MaybeCreateJob(
+  // net::URLRequestInterceptor implementation:
+  virtual net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE;
 
   void GetPendingSize(size_t* pending_size) const;
   void PushJobCallback(const JobCallback& callback);
 
  private:
   const std::string hostname_;
   scoped_refptr<base::SequencedTaskRunner> io_task_runner_;
 
   // The queue of pending callbacks. 'mutable' because MaybeCreateJob() is a
   // const method; it can't reenter though, because it runs exclusively on
   // the IO thread.
   mutable std::queue<JobCallback> pending_job_callbacks_;
 };
 
 TestRequestInterceptor::Delegate::Delegate(
     const std::string& hostname,
     scoped_refptr<base::SequencedTaskRunner> io_task_runner)
     : hostname_(hostname), io_task_runner_(io_task_runner) {}
 
 TestRequestInterceptor::Delegate::~Delegate() {}
 
-net::URLRequestJob* TestRequestInterceptor::Delegate::MaybeCreateJob(
+net::URLRequestJob* TestRequestInterceptor::Delegate::MaybeInterceptRequest(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate) const {
   CHECK(io_task_runner_->RunsTasksOnCurrentThread());
 
   if (request->url().host() != hostname_) {
     // Reject requests to other servers.
     return ErrorJobCallback(
         net::ERR_CONNECTION_REFUSED, request, network_delegate);
   }
 
@@ skipping 17 matching lines @@
     const JobCallback& callback) {
   CHECK(io_task_runner_->RunsTasksOnCurrentThread());
   pending_job_callbacks_.push(callback);
 }
 
 TestRequestInterceptor::TestRequestInterceptor(const std::string& hostname,
     scoped_refptr<base::SequencedTaskRunner> io_task_runner)
     : hostname_(hostname),
       io_task_runner_(io_task_runner) {
   delegate_ = new Delegate(hostname_, io_task_runner_);
-  scoped_ptr<net::URLRequestJobFactory::ProtocolHandler> handler(delegate_);
+  scoped_ptr<net::URLRequestInterceptor> interceptor(delegate_);
   PostToIOAndWait(
-      base::Bind(&net::URLRequestFilter::AddHostnameProtocolHandler,
-                 base::Unretained(net::URLRequestFilter::GetInstance()),
-                 "http", hostname_, base::Passed(&handler)));
+      base::Bind(&RegisterHttpInterceptor, hostname_,
+                 base::Passed(&interceptor)));
 }
 
 TestRequestInterceptor::~TestRequestInterceptor() {
   // RemoveHostnameHandler() destroys the |delegate_|, which is owned by
   // the URLRequestFilter.
   delegate_ = NULL;
   PostToIOAndWait(
       base::Bind(&net::URLRequestFilter::RemoveHostnameHandler,
                  base::Unretained(net::URLRequestFilter::GetInstance()),
                  "http", hostname_));
@@ skipping 44 matching lines @@
       FROM_HERE,
       base::Bind(
           base::IgnoreResult(&base::MessageLoopProxy::PostTask),
           base::MessageLoopProxy::current(),
           FROM_HERE,
           run_loop.QuitClosure()));
   run_loop.Run();
 }
 
 }  // namespace policy