Added URLRequestContext to constructor for URLRequest.

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 114 matching lines @@
 
 void URLRequest::Delegate::OnSSLCertificateError(URLRequest* request,
                                                  const SSLInfo& ssl_info,
                                                  bool is_hsts_ok) {
   request->Cancel();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // URLRequest
 
-URLRequest::URLRequest(const GURL& url, Delegate* delegate)
-    : context_(NULL),
+URLRequest::URLRequest(const GURL& url,
+                       Delegate* delegate,
+                       const URLRequestContext* context)
+    : context_(context),
+      net_log_(BoundNetLog::Make(context->net_log(),
+                                 NetLog::SOURCE_URL_REQUEST)),
       url_chain_(1, url),
       method_("GET"),
       referrer_policy_(CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE),
       load_flags_(LOAD_NORMAL),
       delegate_(delegate),
       is_pending_(false),
       redirect_limit_(kMaxRedirects),
       final_upload_progress_(0),
       priority_(LOWEST),
       identifier_(GenerateURLRequestIdentifier()),
       blocked_on_delegate_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(before_request_callback_(
           base::Bind(&URLRequest::BeforeRequestComplete,
                      base::Unretained(this)))),
       has_notified_completion_(false),
       creation_time_(base::TimeTicks::Now()) {
   SIMPLE_STATS_COUNTER("URLRequestCount");
 
   // Sanity check out environment.
   DCHECK(MessageLoop::current()) <<
       "The current MessageLoop must exist";
   DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type()) <<
       "The current MessageLoop must be TYPE_IO";
+
+  CHECK(context);
+  context->url_requests()->insert(this);
+
+  net_log_.BeginEvent(NetLog::TYPE_REQUEST_ALIVE);
 }
 
 URLRequest::~URLRequest() {
   Cancel();
 
   if (context_ && context_->network_delegate()) {
     context_->network_delegate()->NotifyURLRequestDestroyed(this);
     if (job_)
       job_->NotifyURLRequestDestroyed();
   }
 
   if (job_)
     OrphanJob();
 
-  set_context(NULL);
+  int deleted = context_->url_requests()->erase(this);

[James Hawkins, 2012/06/25 16:28:02]

This line introduces a forward null defect, i.e., dereference after NULL check
(line 174).  Either a NULL check should be added here as well or the NULL check
on line 174 should be removed.

+  CHECK_EQ(1, deleted);
+
+  int net_error = OK;
+  // Log error only on failure, not cancellation, as even successful requests
+  // are "cancelled" on destruction.
+  if (status_.status() == URLRequestStatus::FAILED)
+    net_error = status_.error();
+  net_log_.EndEventWithNetErrorCode(NetLog::TYPE_REQUEST_ALIVE, net_error);
 }
 
 // static
 URLRequest::ProtocolFactory* URLRequest::RegisterProtocolFactory(
     const string& scheme, ProtocolFactory* factory) {
   return URLRequestJobManager::GetInstance()->RegisterProtocolFactory(scheme,
                                                                       factory);
 }
 
 // static
@@ skipping 535 matching lines @@
 
   PrepareToRestart();
   Start();
   return OK;
 }
 
 const URLRequestContext* URLRequest::context() const {
   return context_;
 }
 
-void URLRequest::set_context(const URLRequestContext* context) {
-  // Update the URLRequest lists in the URLRequestContext.
-  if (context_) {
-    std::set<const URLRequest*>* url_requests = context_->url_requests();
-    CHECK(ContainsKey(*url_requests, this));
-    url_requests->erase(this);
-  }
-
-  if (context) {
-    std::set<const URLRequest*>* url_requests = context->url_requests();
-    CHECK(!ContainsKey(*url_requests, this));
-    url_requests->insert(this);
-  }
-
-  const URLRequestContext* prev_context = context_;
-
-  context_ = context;
-
-  // If the context this request belongs to has changed, update the tracker.
-  if (prev_context != context) {
-    int net_error = OK;
-    // Log error only on failure, not cancellation, as even successful requests
-    // are "cancelled" on destruction.
-    if (status_.status() == URLRequestStatus::FAILED)
-      net_error = status_.error();
-    net_log_.EndEventWithNetErrorCode(NetLog::TYPE_REQUEST_ALIVE, net_error);
-    net_log_ = BoundNetLog();
-
-    if (context) {
-      net_log_ = BoundNetLog::Make(context->net_log(),
-                                   NetLog::SOURCE_URL_REQUEST);
-      net_log_.BeginEvent(NetLog::TYPE_REQUEST_ALIVE);
-    }
-  }
-}
-
 int64 URLRequest::GetExpectedContentSize() const {
   int64 expected_content_size = -1;
   if (job_)
     expected_content_size = job_->expected_content_size();
 
   return expected_content_size;
 }
 
 bool URLRequest::GetHSTSRedirect(GURL* redirect_url) const {
   const GURL& url = this->url();
@@ skipping 147 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