Refactoring: ProtocolHandler::MaybeCreateJob takes NetworkDelegate as argument

content/browser/renderer_host/resource_dispatcher_host_unittest.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 "content/browser/renderer_host/resource_dispatcher_host_impl.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_path.h"
@@ skipping 191 matching lines @@
  private:
   IPC::Sender* dest_;
 
   DISALLOW_COPY_AND_ASSIGN(ForwardingFilter);
 };
 
 // This class is a variation on URLRequestTestJob in that it does
 // not complete start upon entry, only when specifically told to.
 class URLRequestTestDelayedStartJob : public net::URLRequestTestJob {
  public:
-  URLRequestTestDelayedStartJob(net::URLRequest* request)
-      : net::URLRequestTestJob(request) {
-    Init();
-  }
-  URLRequestTestDelayedStartJob(net::URLRequest* request, bool auto_advance)
-      : net::URLRequestTestJob(request, auto_advance) {
+  URLRequestTestDelayedStartJob(net::URLRequest* request,
+                                net::NetworkDelegate* network_delegate)
+      : net::URLRequestTestJob(request, network_delegate) {
     Init();
   }
   URLRequestTestDelayedStartJob(net::URLRequest* request,
+                                net::NetworkDelegate* network_delegate,
+                                bool auto_advance)
+      : net::URLRequestTestJob(request, network_delegate, auto_advance) {
+    Init();
+  }
+  URLRequestTestDelayedStartJob(net::URLRequest* request,
+                                net::NetworkDelegate* network_delegate,
                                 const std::string& response_headers,
                                 const std::string& response_data,
                                 bool auto_advance)
-      : net::URLRequestTestJob(
-          request, response_headers, response_data, auto_advance) {
+      : net::URLRequestTestJob(request,
+                               network_delegate,
+                               response_headers,
+                               response_data,
+                               auto_advance) {
     Init();
   }
 
   // Do nothing until you're told to.
   virtual void Start() {}
 
   // Finish starting a URL request whose job is an instance of
   // URLRequestTestDelayedStartJob.  It is illegal to call this routine
   // with a URLRequest that does not use URLRequestTestDelayedStartJob.
   static void CompleteStart(net::URLRequest* request) {
@@ skipping 43 matching lines @@
   URLRequestTestDelayedStartJob* next_;
 };
 
 URLRequestTestDelayedStartJob*
 URLRequestTestDelayedStartJob::list_head_ = NULL;
 
 // This class is a variation on URLRequestTestJob in that it
 // returns IO_pending errors before every read, not just the first one.
 class URLRequestTestDelayedCompletionJob : public net::URLRequestTestJob {
  public:
-  explicit URLRequestTestDelayedCompletionJob(net::URLRequest* request)
-      : net::URLRequestTestJob(request) {}
   URLRequestTestDelayedCompletionJob(net::URLRequest* request,
+                                     net::NetworkDelegate* network_delegate)
+      : net::URLRequestTestJob(request, network_delegate) {}
+  URLRequestTestDelayedCompletionJob(net::URLRequest* request,
+                                     net::NetworkDelegate* network_delegate,
                                      bool auto_advance)
-      : net::URLRequestTestJob(request, auto_advance) {}
+      : net::URLRequestTestJob(request, network_delegate, auto_advance) {}
   URLRequestTestDelayedCompletionJob(net::URLRequest* request,
+                                     net::NetworkDelegate* network_delegate,
                                      const std::string& response_headers,
                                      const std::string& response_data,
                                      bool auto_advance)
-      : net::URLRequestTestJob(request, response_headers,
-                               response_data, auto_advance) {}
+      : net::URLRequestTestJob(request,
+                               network_delegate,
+                               response_headers,
+                               response_data,
+                               auto_advance) {}
 
  protected:
   ~URLRequestTestDelayedCompletionJob() {}
 
  private:
   virtual bool NextReadAsync() OVERRIDE { return true; }
 };
 
 class URLRequestBigJob : public net::URLRequestSimpleJob {
  public:
-  URLRequestBigJob(net::URLRequest* request)
-      : net::URLRequestSimpleJob(request) {
+  URLRequestBigJob(net::URLRequest* request,
+                   net::NetworkDelegate* network_delegate)
+      : net::URLRequestSimpleJob(request, network_delegate) {
   }
 
   virtual int GetData(std::string* mime_type,
                       std::string* charset,
                       std::string* data,
                       const net::CompletionCallback& callback) const OVERRIDE {
     *mime_type = "text/plain";
     *charset = "UTF-8";
 
     std::string text;
@@ skipping 235 matching lines @@
     DCHECK(scheme_.empty());
     DCHECK(!old_factory_);
     scheme_ = scheme;
     old_factory_ = net::URLRequest::Deprecated::RegisterProtocolFactory(
         scheme_, &ResourceDispatcherHostTest::Factory);
     EnsureSchemeIsAllowed(scheme);
   }
 
   // Our own net::URLRequestJob factory.
   static net::URLRequestJob* Factory(net::URLRequest* request,
+                                     net::NetworkDelegate* network_delegate,
                                      const std::string& scheme) {
     if (test_fixture_->response_headers_.empty()) {
       if (delay_start_) {
-        return new URLRequestTestDelayedStartJob(request);
+        return new URLRequestTestDelayedStartJob(request, network_delegate);
       } else if (delay_complete_) {
-        return new URLRequestTestDelayedCompletionJob(request);
+        return new URLRequestTestDelayedCompletionJob(request,
+                                                      network_delegate);
       } else if (scheme == "big-job") {
-        return new URLRequestBigJob(request);
+        return new URLRequestBigJob(request, network_delegate);
       } else {
-        return new net::URLRequestTestJob(request);
+        return new net::URLRequestTestJob(request, network_delegate);
       }
     } else {
       if (delay_start_) {
         return new URLRequestTestDelayedStartJob(
-            request, test_fixture_->response_headers_,
-            test_fixture_->response_data_, false);
+            request, network_delegate,
+            test_fixture_->response_headers_, test_fixture_->response_data_,
+            false);
       } else if (delay_complete_) {
         return new URLRequestTestDelayedCompletionJob(
-            request, test_fixture_->response_headers_,
-            test_fixture_->response_data_, false);
+            request, network_delegate,
+            test_fixture_->response_headers_, test_fixture_->response_data_,
+            false);
       } else {
-        return new net::URLRequestTestJob(request,
-                                          test_fixture_->response_headers_,
-                                          test_fixture_->response_data_,
-                                          false);
+        return new net::URLRequestTestJob(
+            request, network_delegate,
+            test_fixture_->response_headers_, test_fixture_->response_data_,
+            false);
       }
     }
   }
 
   void SetDelayedStartJobGeneration(bool delay_job_start) {
     delay_start_ = delay_job_start;
   }
 
   void SetDelayedCompleteJobGeneration(bool delay_job_complete) {
     delay_complete_ = delay_job_complete;
@@ skipping 1145 matching lines @@
     }
 
     MessageLoop::current()->RunAllPending();
 
     msgs.clear();
     accum_.GetClassifiedMessages(&msgs);
   }
 }
 
 }  // namespace content