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 64 matching lines @@
   URLRequestHttpJob* job_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpFilterContext);
 };
 
 class URLRequestHttpJob::HttpTransactionDelegateImpl
     : public HttpTransactionDelegate {
  public:
   explicit HttpTransactionDelegateImpl(URLRequest* request)
       : request_(request),
-        network_delegate_(request->context()->network_delegate()),
+        network_delegate_(request->network_delegate()),

[erikwright (departed), 2013/02/25 15:07:23]

In the various job implementations, the change should be adapted as follows:

1) The protocol handler should take a NetworkDelegate* as a parameter, and store
it as a member.
2) The URLRequestJob subclass should take a NetworkDelegate* as a parameter, and
store it as a member.
3) If there is still a static Factory function, it should fetch the
NetworkDelegate from the context (or request) and pass it to the Job subclass's
constructor.
4) Any objects created by the job (such as the HTTPTransactionDelegateImpl)
should accept the NetworkDelegate as a constructor parameter and receive it from
the job

         cache_active_(false),
         network_active_(false) {
   }
   virtual ~HttpTransactionDelegateImpl() {
     OnDetachRequest();
   }
   void OnDetachRequest() {
     if (request_ == NULL || network_delegate_ == NULL)
       return;
     network_delegate_->NotifyRequestWaitStateChange(
@@ skipping 232 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 (request_->network_delegate()) {
+    int rv = request_->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(
+  if (request_->network_delegate()) {
+    request_->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(
@@ skipping 362 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 (request_->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()->
+      int error = request_->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",
@@ skipping 794 matching lines @@
 
 void URLRequestHttpJob::NotifyURLRequestDestroyed() {
   awaiting_callback_ = false;
 }
 
 void URLRequestHttpJob::OnDetachRequest() {
   http_transaction_delegate_->OnDetachRequest();
 }
 
 }  // namespace net