Refactoring: ProtocolHandler::MaybeCreateJob takes NetworkDelegate as argument

net/url_request/url_request.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 "net/url_request/url_request.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
@@ skipping 78 matching lines @@
 void URLRequest::Deprecated::UnregisterRequestInterceptor(
     Interceptor* interceptor) {
   URLRequest::UnregisterRequestInterceptor(interceptor);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // URLRequest::Interceptor
 
 URLRequestJob* URLRequest::Interceptor::MaybeInterceptRedirect(
     URLRequest* request,
+    NetworkDelegate* network_delegate,
     const GURL& location) {
   return NULL;
 }
 
 URLRequestJob* URLRequest::Interceptor::MaybeInterceptResponse(
-    URLRequest* request) {
+    URLRequest* request, NetworkDelegate* network_delegate) {
   return NULL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // URLRequest::Delegate
 
 void URLRequest::Delegate::OnReceivedRedirect(URLRequest* request,
                                               const GURL& new_url,
                                               bool* defer_redirect) {
 }
@@ skipping 306 matching lines @@
         this, before_request_callback_, &delegate_redirect_url_);
     if (error == net::ERR_IO_PENDING) {
       // Paused on the delegate, will invoke |before_request_callback_| later.
       SetBlockedOnDelegate();
     } else {
       BeforeRequestComplete(error);
     }
     return;
   }
 
-  StartJob(URLRequestJobManager::GetInstance()->CreateJob(this));
+  StartJob(URLRequestJobManager::GetInstance()->CreateJob(
+      this, context_->network_delegate()));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void URLRequest::BeforeRequestComplete(int error) {
   DCHECK(!job_);
   DCHECK_NE(ERR_IO_PENDING, error);
 
   // Check that there are no callbacks to already canceled requests.
   DCHECK_NE(URLRequestStatus::CANCELED, status_.status());
 
   if (blocked_on_delegate_)
     SetUnblockedOnDelegate();
 
   if (error != OK) {
     std::string source("delegate");
     net_log_.AddEvent(NetLog::TYPE_CANCELLED,
                       NetLog::StringCallback("source", &source));
-    StartJob(new URLRequestErrorJob(this, error));
+    StartJob(new URLRequestErrorJob(this, context_->network_delegate(), error));
   } else if (!delegate_redirect_url_.is_empty()) {
     GURL new_url;
     new_url.Swap(&delegate_redirect_url_);
 
-    URLRequestRedirectJob* job = new URLRequestRedirectJob(this, new_url);
+    URLRequestRedirectJob* job = new URLRequestRedirectJob(
+        this, context_->network_delegate(), new_url);
     // Use status code 307 to preserve the method, so POST requests work.
     job->set_redirect_code(
         URLRequestRedirectJob::REDIRECT_307_TEMPORARY_REDIRECT);
     StartJob(job);
   } else {
-    StartJob(URLRequestJobManager::GetInstance()->CreateJob(this));
+    StartJob(URLRequestJobManager::GetInstance()->CreateJob(
+        this, context_->network_delegate()));
   }
 }
 
 void URLRequest::StartJob(URLRequestJob* job) {
   DCHECK(!is_pending_);
   DCHECK(!job_);
 
   net_log_.BeginEvent(
       NetLog::TYPE_URL_REQUEST_START_JOB,
       base::Bind(&NetLogURLRequestStartCallback,
@@ skipping 12 matching lines @@
   // Don't allow errors to be sent from within Start().
   // TODO(brettw) this may cause NotifyDone to be sent synchronously,
   // we probably don't want this: they should be sent asynchronously so
   // the caller does not get reentered.
   job_->Start();
 }
 
 void URLRequest::Restart() {
   // Should only be called if the original job didn't make any progress.
   DCHECK(job_ && !job_->has_response_started());
-  RestartWithJob(URLRequestJobManager::GetInstance()->CreateJob(this));
+  RestartWithJob(URLRequestJobManager::GetInstance()->CreateJob(
+      this, context_->network_delegate()));
 }
 
 void URLRequest::RestartWithJob(URLRequestJob *job) {
   DCHECK(job->request() == this);
   PrepareToRestart();
   StartJob(job);
 }
 
 void URLRequest::Cancel() {
   DoCancel(ERR_ABORTED, SSLInfo());
@@ skipping 74 matching lines @@
 }
 
 void URLRequest::StopCaching() {
   DCHECK(job_);
   job_->StopCaching();
 }
 
 void URLRequest::NotifyReceivedRedirect(const GURL& location,
                                         bool* defer_redirect) {
   URLRequestJob* job =
-      URLRequestJobManager::GetInstance()->MaybeInterceptRedirect(this,
-                                                                  location);
+      URLRequestJobManager::GetInstance()->MaybeInterceptRedirect(
+          this, context_->network_delegate(), location);
   if (job) {
     RestartWithJob(job);
   } else if (delegate_) {
     delegate_->OnReceivedRedirect(this, location, defer_redirect);
   }
 }
 
 void URLRequest::NotifyResponseStarted() {
   int net_error = OK;
   if (!status_.is_success())
     net_error = status_.error();
   net_log_.EndEventWithNetErrorCode(NetLog::TYPE_URL_REQUEST_START_JOB,
                                     net_error);
 
   URLRequestJob* job =
-      URLRequestJobManager::GetInstance()->MaybeInterceptResponse(this);
+      URLRequestJobManager::GetInstance()->MaybeInterceptResponse(
+          this, context_->network_delegate());
   if (job) {
     RestartWithJob(job);
   } else {
     if (delegate_) {
       // In some cases (e.g. an event was canceled), we might have sent the
       // completion event and receive a NotifyResponseStarted() later.
       if (!has_notified_completion_ && status_.is_success()) {
         if (context_->network_delegate())
           context_->network_delegate()->NotifyResponseStarted(this);
       }
@@ skipping 305 matching lines @@
       new base::debug::StackTrace(NULL, 0);
   *stack_trace_copy = stack_trace;
   stack_trace_.reset(stack_trace_copy);
 }
 
 const base::debug::StackTrace* URLRequest::stack_trace() const {
   return stack_trace_.get();
 }
 
 }  // namespace net