Removed checks that verify URLRequest has a Context

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 592 matching lines @@
 
   URLRequestJob* job =
       URLRequestJobManager::GetInstance()->MaybeInterceptResponse(this);
   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_ && context_->network_delegate())
+        if (context_->network_delegate())
           context_->network_delegate()->NotifyResponseStarted(this);
       }
 
       // Notify in case the entire URL Request has been finished.
       if (!has_notified_completion_ && !status_.is_success())
         NotifyRequestCompleted();
 
       delegate_->OnResponseStarted(this);
       // Nothing may appear below this line as OnResponseStarted may delete
       // |this|.
@@ skipping 63 matching lines @@
   job_ = NULL;
 }
 
 int URLRequest::Redirect(const GURL& location, int http_status_code) {
   if (net_log_.IsLoggingAllEvents()) {
     net_log_.AddEvent(
         NetLog::TYPE_URL_REQUEST_REDIRECTED,
         NetLog::StringCallback("location", &location.possibly_invalid_spec()));
   }
 
-  if (context_ && context_->network_delegate())
+  if (context_->network_delegate())
     context_->network_delegate()->NotifyBeforeRedirect(this, location);
 
   if (redirect_limit_ <= 0) {
     DVLOG(1) << "disallowing redirect: exceeds limit";
     return ERR_TOO_MANY_REDIRECTS;
   }
 
   if (!location.is_valid())
     return ERR_INVALID_URL;
 
@@ skipping 73 matching lines @@
     *redirect_url = url.ReplaceComponents(replacements);
     return true;
   }
   return false;
 }
 
 void URLRequest::NotifyAuthRequired(AuthChallengeInfo* auth_info) {
   NetworkDelegate::AuthRequiredResponse rv =
       NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
   auth_info_ = auth_info;
-  if (context_ && context_->network_delegate()) {
+  if (context_->network_delegate()) {
     rv = context_->network_delegate()->NotifyAuthRequired(
         this,
         *auth_info,
         base::Bind(&URLRequest::NotifyAuthRequiredComplete,
                    base::Unretained(this)),
         &auth_credentials_);
   }
 
   if (rv == NetworkDelegate::AUTH_REQUIRED_RESPONSE_IO_PENDING) {
     SetBlockedOnDelegate();
@@ skipping 46 matching lines @@
 }
 
 void URLRequest::NotifySSLCertificateError(const SSLInfo& ssl_info,
                                            bool fatal) {
   if (delegate_)
     delegate_->OnSSLCertificateError(this, ssl_info, fatal);
 }
 
 bool URLRequest::CanGetCookies(const CookieList& cookie_list) const {
   DCHECK(!(load_flags_ & LOAD_DO_NOT_SEND_COOKIES));
-  if (context_ && context_->network_delegate()) {
+  if (context_->network_delegate()) {
     return context_->network_delegate()->CanGetCookies(*this,
                                                               cookie_list);
   }
   return g_default_can_use_cookies;
 }
 
 bool URLRequest::CanSetCookie(const std::string& cookie_line,
                               CookieOptions* options) const {
   DCHECK(!(load_flags_ & LOAD_DO_NOT_SAVE_COOKIES));
-  if (context_ && context_->network_delegate()) {
+  if (context_->network_delegate()) {
     return context_->network_delegate()->CanSetCookie(*this,
                                                              cookie_line,
                                                              options);
   }
   return g_default_can_use_cookies;
 }
 
 
 void URLRequest::NotifyReadCompleted(int bytes_read) {
   // Notify in case the entire URL Request has been finished.
   if (bytes_read <= 0)
     NotifyRequestCompleted();
 
   if (delegate_)
     delegate_->OnReadCompleted(this, bytes_read);
 
   // Nothing below this line as OnReadCompleted may delete |this|.
 }
 
 void URLRequest::NotifyRequestCompleted() {
   // TODO(battre): Get rid of this check, according to willchan it should
   // not be needed.
   if (has_notified_completion_)
     return;
 
   is_pending_ = false;
   has_notified_completion_ = true;
-  if (context_ && context_->network_delegate())
+  if (context_->network_delegate())
     context_->network_delegate()->NotifyCompleted(this, job_ != NULL);
 }
 
 void URLRequest::SetBlockedOnDelegate() {
   blocked_on_delegate_ = true;
   net_log_.BeginEvent(NetLog::TYPE_URL_REQUEST_BLOCKED_ON_DELEGATE);
 }
 
 void URLRequest::SetUnblockedOnDelegate() {
   if (!blocked_on_delegate_)
     return;
   blocked_on_delegate_ = false;
   load_state_param_.clear();
   net_log_.EndEvent(NetLog::TYPE_URL_REQUEST_BLOCKED_ON_DELEGATE);
 }
 
 void URLRequest::set_stack_trace(const base::debug::StackTrace& stack_trace) {
   base::debug::StackTrace* stack_trace_copy =
       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