Refactoring: ProtocolHandler::MaybeCreateJob takes NetworkDelegate as argument

net/url_request/url_request_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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shlobj.h>
 #endif
@@ skipping 3620 matching lines @@
       simulate_main_network_error_ = false;
       did_simulate_error_main_ = true;
       // will error since the requeted url is not one of its canned urls
       return new URLRequestTestJob(request, true);
     }
     if (!intercept_main_request_)
       return NULL;
     intercept_main_request_ = false;
     did_intercept_main_ = true;
     return new URLRequestTestJob(request,
-                                      main_headers_,
-                                      main_data_,
-                                      true);
+                                 request->context()->network_delegate(),
+                                 main_headers_,
+                                 main_data_,
+                                 true);
   }
 
   virtual URLRequestJob* MaybeInterceptRedirect(URLRequest* request,
                                                      const GURL& location) {
     if (cancel_redirect_request_) {
       cancel_redirect_request_ = false;
       did_cancel_redirect_ = true;
       return new CancelTestJob(request);
     }
     if (!intercept_redirect_)
       return NULL;
     intercept_redirect_ = false;
     did_intercept_redirect_ = true;
     return new URLRequestTestJob(request,
-                                      redirect_headers_,
-                                      redirect_data_,
-                                      true);
+                                 request->context()->network_delegate(),
+                                 redirect_headers_,
+                                 redirect_data_,
+                                 true);
   }
 
   virtual URLRequestJob* MaybeInterceptResponse(URLRequest* request) {
     if (cancel_final_request_) {
       cancel_final_request_ = false;
       did_cancel_final_ = true;
       return new CancelTestJob(request);
     }
     if (!intercept_final_response_)
       return NULL;
     intercept_final_response_ = false;
     did_intercept_final_ = true;
     return new URLRequestTestJob(request,
-                                      final_headers_,
-                                      final_data_,
-                                      true);
+                                 request->context()->network_delegate(),
+                                 final_headers_,
+                                 final_data_,
+                                 true);
   }
 
   // Whether to intercept the main request, and if so the response to return.
   bool intercept_main_request_;
   std::string main_headers_;
   std::string main_data_;
 
   // Other actions we take at MaybeIntercept time
   bool restart_main_request_;
   bool cancel_main_request_;
@@ skipping 423 matching lines @@
 };
 
 // Make sure an FTP request using an unsafe ports fails.
 TEST_F(URLRequestTestFTP, UnsafePort) {
   ASSERT_TRUE(test_server_.Start());
 
   URLRequestJobFactory job_factory;
 
   GURL url("ftp://127.0.0.1:7");
   FtpProtocolHandler ftp_protocol_handler(
-      default_context_.network_delegate(),
       default_context_.ftp_transaction_factory(),
       default_context_.ftp_auth_cache());
   job_factory.SetProtocolHandler(
       "ftp",
-      new FtpProtocolHandler(default_context_.network_delegate(),
-                             default_context_.ftp_transaction_factory(),
+      new FtpProtocolHandler(default_context_.ftp_transaction_factory(),
                              default_context_.ftp_auth_cache()));
   default_context_.set_job_factory(&job_factory);
 
   TestDelegate d;
   {
     URLRequest r(url, &d, &default_context_);
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
@@ skipping 491 matching lines @@
   req.SetExtraRequestHeaders(headers);
   req.Start();
   MessageLoop::current()->Run();
   // If the net tests are being run with ChromeFrame then we need to allow for
   // the 'chromeframe' suffix which is added to the user agent before the
   // closing parentheses.
   EXPECT_TRUE(StartsWithASCII(d.data_received(), "Lynx (textmode", true));
 }
 
 }  // namespace net