Remove some calls to URLRequestContext::network_delegate().

net/url_request/url_request_http_job.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_http_job.h"
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
@@ skipping 62 matching lines @@
 
  private:
   URLRequestHttpJob* job_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpFilterContext);
 };
 
 class URLRequestHttpJob::HttpTransactionDelegateImpl
     : public HttpTransactionDelegate {
  public:
-  explicit HttpTransactionDelegateImpl(URLRequest* request)
+  explicit HttpTransactionDelegateImpl(

[mmenke, 2013/03/07 15:45:39]

nit:  Explicit no longer needed.

+      URLRequest* request, NetworkDelegate* network_delegate)
       : request_(request),
-        network_delegate_(request->context()->network_delegate()),
+        network_delegate_(network_delegate),
         cache_active_(false),
         network_active_(false) {
   }
   virtual ~HttpTransactionDelegateImpl() {
     OnDetachRequest();
   }
   void OnDetachRequest() {
     if (request_ == NULL || network_delegate_ == NULL)
       return;
     network_delegate_->NotifyRequestWaitStateChange(
@@ skipping 154 matching lines @@
       bytes_observed_in_packets_(0),
       request_time_snapshot_(),
       final_packet_time_(),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           filter_context_(new HttpFilterContext(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(on_headers_received_callback_(
           base::Bind(&URLRequestHttpJob::OnHeadersReceivedCallback,
                      base::Unretained(this)))),
       awaiting_callback_(false),
-      http_transaction_delegate_(new HttpTransactionDelegateImpl(request)),
+      http_transaction_delegate_(new HttpTransactionDelegateImpl(
+          request, network_delegate)),
       http_user_agent_settings_(http_user_agent_settings) {
   URLRequestThrottlerManager* manager = request->context()->throttler_manager();
   if (manager)
     throttling_entry_ = manager->RegisterRequestUrl(request->url());
 
   ResetTimer();
 }
 
 void URLRequestHttpJob::NotifyHeadersComplete() {
   DCHECK(!response_info_);
@@ skipping 57 matching lines @@
 
 void URLRequestHttpJob::DestroyTransaction() {
   DCHECK(transaction_.get());
 
   DoneWithRequest(ABORTED);
   transaction_.reset();
   response_info_ = NULL;
 }
 
 void URLRequestHttpJob::StartTransaction() {
-  if (request_->context()->network_delegate()) {
-    int rv = request_->context()->network_delegate()->NotifyBeforeSendHeaders(
+  if (network_delegate_) {
+    int rv = network_delegate_->NotifyBeforeSendHeaders(
         request_, notify_before_headers_sent_callback_,
         &request_info_.extra_headers);
     // If an extension blocks the request, we rely on the callback to
     // MaybeStartTransactionInternal().
     if (rv == ERR_IO_PENDING) {
       SetBlockedOnDelegate();
       return;
     }
     MaybeStartTransactionInternal(rv);
     return;
@@ skipping 23 matching lines @@
 }
 
 void URLRequestHttpJob::StartTransactionInternal() {
   // NOTE: This method assumes that request_info_ is already setup properly.
 
   // If we already have a transaction, then we should restart the transaction
   // with auth provided by auth_credentials_.
 
   int rv;
 
-  if (request_->context()->network_delegate()) {
-    request_->context()->network_delegate()->NotifySendHeaders(
-        request_, request_info_.extra_headers);
-  }
+  if (network_delegate_)
+    network_delegate_->NotifySendHeaders(request_, request_info_.extra_headers);
 
   if (transaction_.get()) {
     rv = transaction_->RestartWithAuth(auth_credentials_, start_callback_);
     auth_credentials_ = AuthCredentials();
   } else {
     DCHECK(request_->context()->http_transaction_factory());
 
     rv = request_->context()->http_transaction_factory()->CreateTransaction(
         &transaction_, http_transaction_delegate_.get());
     if (rv == OK) {
@@ skipping 358 matching lines @@
       bool sni_available = SSLConfigService::IsSNIAvailable(
           context->ssl_config_service());
       const std::string& host = request_->url().host();
 
       reporter->SendReport(host, ssl_info, sni_available);
     }
   }
 
   if (result == OK) {
     scoped_refptr<HttpResponseHeaders> headers = GetResponseHeaders();
-    if (context->network_delegate()) {
+    if (network_delegate_) {
       // Note that |this| may not be deleted until
       // |on_headers_received_callback_| or
       // |NetworkDelegate::URLRequestDestroyed()| has been called.
-      int error = context->network_delegate()->
-          NotifyHeadersReceived(request_, on_headers_received_callback_,
-                                headers, &override_response_headers_);
+      int error = network_delegate_->NotifyHeadersReceived(
+          request_, on_headers_received_callback_,
+          headers, &override_response_headers_);
       if (error != net::OK) {
         if (error == net::ERR_IO_PENDING) {
           awaiting_callback_ = true;
           SetBlockedOnDelegate();
         } else {
           std::string source("delegate");
           request_->net_log().AddEvent(NetLog::TYPE_CANCELLED,
                                        NetLog::StringCallback("source",
                                                               &source));
           NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, error));
@@ skipping 792 matching lines @@
 
 void URLRequestHttpJob::NotifyURLRequestDestroyed() {
   awaiting_callback_ = false;
 }
 
 void URLRequestHttpJob::OnDetachRequest() {
   http_transaction_delegate_->OnDetachRequest();
 }
 
 }  // namespace net