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 203 matching lines @@
     Init();
   }
   URLRequestTestDelayedStartJob(net::URLRequest* request, bool auto_advance)
       : net::URLRequestTestJob(request, auto_advance) {
     Init();
   }
   URLRequestTestDelayedStartJob(net::URLRequest* request,
                                 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,
+                               request->context()->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 52 matching lines @@
  public:
   explicit URLRequestTestDelayedCompletionJob(net::URLRequest* request)
       : net::URLRequestTestJob(request) {}
   URLRequestTestDelayedCompletionJob(net::URLRequest* request,
                                      bool auto_advance)
       : net::URLRequestTestJob(request, auto_advance) {}
   URLRequestTestDelayedCompletionJob(net::URLRequest* request,
                                      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,
+                               request->context()->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 242 matching lines @@
 
   // Our own net::URLRequestJob factory.
   static net::URLRequestJob* Factory(net::URLRequest* request,
                                      const std::string& scheme) {
     if (test_fixture_->response_headers_.empty()) {
       if (delay_start_) {
         return new URLRequestTestDelayedStartJob(request);
       } else if (delay_complete_) {
         return new URLRequestTestDelayedCompletionJob(request);
       } else if (scheme == "big-job") {
-        return new URLRequestBigJob(request);
+        return new URLRequestBigJob(request,
+                                    request->context()->network_delegate());
       } else {
         return new net::URLRequestTestJob(request);
       }
     } else {
       if (delay_start_) {
         return new URLRequestTestDelayedStartJob(
             request, 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);
       } else {
-        return new net::URLRequestTestJob(request,
-                                          test_fixture_->response_headers_,
-                                          test_fixture_->response_data_,
-                                          false);
+        return new net::URLRequestTestJob(
+            request,
+            request->context()->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