Stop refcounting URLRequestContext.

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 234 matching lines @@
   DoneWithRequest(FINISHED);
   URLRequestJob::NotifyDone(status);
 }
 
 void URLRequestHttpJob::DestroyTransaction() {
   DCHECK(transaction_.get());
 
   DoneWithRequest(ABORTED);
   transaction_.reset();
   response_info_ = NULL;
-  context_ = NULL;
 }
 
 void URLRequestHttpJob::StartTransaction() {
   if (request_->context() && request_->context()->network_delegate()) {
     int rv = request_->context()->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
     // StartTransactionInternal().
     if (rv == ERR_IO_PENDING) {
@@ skipping 54 matching lines @@
           !manager->enforce_throttling() ||
           request_->first_party_for_cookies().scheme() != "chrome-extension" ||
           !throttling_entry_->ShouldRejectRequest(request_info_.load_flags)) {
         rv = transaction_->Start(
             &request_info_, start_callback_, request_->net_log());
         start_time_ = base::TimeTicks::Now();
       } else {
         // Special error code for the exponential back-off module.
         rv = ERR_TEMPORARILY_THROTTLED;
       }
-      // Make sure the context is alive for the duration of the
-      // transaction.
-      context_ = request_->context();
     }
   }
 
   if (rv == ERR_IO_PENDING)
     return;
 
   // The transaction started synchronously, but we need to notify the
   // URLRequest delegate via the message loop.
   MessageLoop::current()->PostTask(
       FROM_HERE,
@@ skipping 313 matching lines @@
     return;
 
   // If the transaction was destroyed, then the job was cancelled, and
   // we can just ignore this notification.
   if (!transaction_.get())
     return;
 
   // Clear the IO_PENDING status
   SetStatus(URLRequestStatus());
 
+  const URLRequestContext* context = request_->context();
+
   if (result == ERR_SSL_PINNED_KEY_NOT_IN_CERT_CHAIN &&
       transaction_->GetResponseInfo() != NULL) {
     FraudulentCertificateReporter* reporter =
-      context_->fraudulent_certificate_reporter();
+      context->fraudulent_certificate_reporter();
     if (reporter != NULL) {
       const SSLInfo& ssl_info = transaction_->GetResponseInfo()->ssl_info;
       bool sni_available = SSLConfigService::IsSNIAvailable(
-          context_->ssl_config_service());
+          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 (request_->context() && request_->context()->network_delegate()) {
+    if (context && context->network_delegate()) {
       // Note that |this| may not be deleted until
       // |on_headers_received_callback_| or
       // |NetworkDelegate::URLRequestDestroyed()| has been called.
-      int error = request_->context()->network_delegate()->
+      int error = context->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;
           request_->net_log().BeginEvent(
               NetLog::TYPE_URL_REQUEST_BLOCKED_ON_DELEGATE, NULL);
         } else {
           request_->net_log().AddEvent(NetLog::TYPE_CANCELLED,
               make_scoped_refptr(
                   new NetLogStringParameter("source", "delegate")));
           NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, error));
         }
         return;
       }
     }
 
     SaveCookiesAndNotifyHeadersComplete(net::OK);
   } else if (IsCertificateError(result)) {
     // We encountered an SSL certificate error.  Ask our delegate to decide
     // what we should do.
 
     TransportSecurityState::DomainState domain_state;
+    const URLRequestContext* context = request_->context();
     const bool fatal =
-        context_->transport_security_state() &&
-        context_->transport_security_state()->GetDomainState(
+        context->transport_security_state() &&
+        context->transport_security_state()->GetDomainState(
             request_info_.url.host(),
-            SSLConfigService::IsSNIAvailable(context_->ssl_config_service()),
+            SSLConfigService::IsSNIAvailable(context->ssl_config_service()),
             &domain_state);
     NotifySSLCertificateError(transaction_->GetResponseInfo()->ssl_info, fatal);
   } else if (result == ERR_SSL_CLIENT_AUTH_CERT_NEEDED) {
     NotifyCertificateRequested(
         transaction_->GetResponseInfo()->cert_request_info);
   } else {
     NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, result));
   }
 }
 
@@ skipping 673 matching lines @@
   return override_response_headers_.get() ?
       override_response_headers_ :
       transaction_->GetResponseInfo()->headers;
 }
 
 void URLRequestHttpJob::NotifyURLRequestDestroyed() {
   awaiting_callback_ = false;
 }
 
 }  // namespace net