Add MaybeInterceptRedirect/Response to URLRequestInterceptor

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"
@@ skipping 147 matching lines @@
 
 class TestRequestInterceptor::Delegate : public net::URLRequestInterceptor {
  public:
   Delegate(const std::string& hostname,
            scoped_refptr<base::SequencedTaskRunner> io_task_runner);
   ~Delegate() override;
 
   // net::URLRequestInterceptor implementation:
   net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const override;
+      net::NetworkDelegate* network_delegate) override;
+
+  net::URLRequestJob* MaybeInterceptRedirect(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate,
+      const GURL& location) override;
+
+  net::URLRequestJob* MaybeInterceptResponse(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) 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::MaybeInterceptRequest(
     net::URLRequest* request,
-    net::NetworkDelegate* network_delegate) const {
+    net::NetworkDelegate* network_delegate) {
   CHECK(io_task_runner_->RunsTasksOnCurrentThread());
 
   if (request->url().host() != hostname_) {
     // Reject requests to other servers.
     return ErrorJobCallback(
         net::ERR_CONNECTION_REFUSED, request, network_delegate);
   }
 
   if (pending_job_callbacks_.empty()) {
     // Reject dmserver requests by default.
     return BadRequestJobCallback(request, network_delegate);
   }
 
   JobCallback callback = pending_job_callbacks_.front();
   pending_job_callbacks_.pop();
   return callback.Run(request, network_delegate);
 }
 
+net::URLRequestJob* TestRequestInterceptor::Delegate::MaybeInterceptRedirect(
+    net::URLRequest* request,
+    net::NetworkDelegate* network_delegate,
+    const GURL& location) {
+  return NULL;
+}
+
+net::URLRequestJob* TestRequestInterceptor::Delegate::MaybeInterceptResponse(
+    net::URLRequest* request,
+    net::NetworkDelegate* network_delegate) {
+  return NULL;
+}
+
 void TestRequestInterceptor::Delegate::GetPendingSize(
     size_t* pending_size) const {
   CHECK(io_task_runner_->RunsTasksOnCurrentThread());
   *pending_size = pending_job_callbacks_.size();
 }
 
 void TestRequestInterceptor::Delegate::PushJobCallback(
     const JobCallback& callback) {
   CHECK(io_task_runner_->RunsTasksOnCurrentThread());
   pending_job_callbacks_.push(callback);
@@ skipping 65 matching lines @@
       FROM_HERE,
       base::Bind(
           base::IgnoreResult(&base::MessageLoopProxy::PostTask),
           base::MessageLoopProxy::current(),
           FROM_HERE,
           run_loop.QuitClosure()));
   run_loop.Run();
 }
 
 }  // namespace policy