Update net/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

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 265 matching lines @@
   context->url_requests()->insert(this);
 
   net_log_.BeginEvent(NetLog::TYPE_REQUEST_ALIVE);
 }
 
 URLRequest::~URLRequest() {
   Cancel();
 
   if (network_delegate_) {
     network_delegate_->NotifyURLRequestDestroyed(this);
-    if (job_)
+    if (job_.get())
       job_->NotifyURLRequestDestroyed();
   }
 
-  if (job_)
+  if (job_.get())
     OrphanJob();
 
   int deleted = context_->url_requests()->erase(this);
   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();
@@ skipping 77 matching lines @@
 
   // NOTE: This method will likely become non-trivial once the other setters
   // for request headers are implemented.
 }
 
 LoadStateWithParam URLRequest::GetLoadState() const {
   if (blocked_on_delegate_) {
     return LoadStateWithParam(LOAD_STATE_WAITING_FOR_DELEGATE,
                               load_state_param_);
   }
-  return LoadStateWithParam(job_ ? job_->GetLoadState() : LOAD_STATE_IDLE,
+  return LoadStateWithParam(job_.get() ? job_->GetLoadState() : LOAD_STATE_IDLE,
                             base::string16());
 }
 
 UploadProgress URLRequest::GetUploadProgress() const {
-  if (!job_) {
+  if (!job_.get()) {
     // We haven't started or the request was cancelled
     return UploadProgress();
   }
   if (final_upload_progress_.position()) {
     // The first job completed and none of the subsequent series of
     // GETs when following redirects will upload anything, so we return the
     // cached results from the initial job, the POST.
     return final_upload_progress_;
   }
   return job_->GetUploadProgress();
 }
 
 void URLRequest::GetResponseHeaderById(int id, string* value) {
-  DCHECK(job_);
+  DCHECK(job_.get());
   NOTREACHED() << "implement me!";
 }
 
 void URLRequest::GetResponseHeaderByName(const string& name, string* value) {
   DCHECK(value);
-  if (response_info_.headers) {
+  if (response_info_.headers.get()) {
     response_info_.headers->GetNormalizedHeader(name, value);
   } else {
     value->clear();
   }
 }
 
 void URLRequest::GetAllResponseHeaders(string* headers) {
   DCHECK(headers);
-  if (response_info_.headers) {
+  if (response_info_.headers.get()) {
     response_info_.headers->GetNormalizedHeaders(headers);
   } else {
     headers->clear();
   }
 }
 
 HostPortPair URLRequest::GetSocketAddress() const {
-  DCHECK(job_);
+  DCHECK(job_.get());
   return job_->GetSocketAddress();
 }
 
 HttpResponseHeaders* URLRequest::response_headers() const {
   return response_info_.headers.get();
 }
 
 void URLRequest::GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const {
   *load_timing_info = load_timing_info_;
 }
 
 bool URLRequest::GetResponseCookies(ResponseCookies* cookies) {
-  DCHECK(job_);
+  DCHECK(job_.get());
   return job_->GetResponseCookies(cookies);
 }
 
 void URLRequest::GetMimeType(string* mime_type) {
-  DCHECK(job_);
+  DCHECK(job_.get());
   job_->GetMimeType(mime_type);
 }
 
 void URLRequest::GetCharset(string* charset) {
-  DCHECK(job_);
+  DCHECK(job_.get());
   job_->GetCharset(charset);
 }
 
 int URLRequest::GetResponseCode() {
-  DCHECK(job_);
+  DCHECK(job_.get());
   return job_->GetResponseCode();
 }
 
 // static
 void URLRequest::SetDefaultCookiePolicyToBlock() {
   CHECK(!g_url_requests_started);
   g_default_can_use_cookies = false;
 }
 
 // static
@@ skipping 72 matching lines @@
     return;
   }
 
   StartJob(URLRequestJobManager::GetInstance()->CreateJob(
       this, network_delegate_));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void URLRequest::BeforeRequestComplete(int error) {
-  DCHECK(!job_);
+  DCHECK(!job_.get());
   DCHECK_NE(ERR_IO_PENDING, error);
   DCHECK_EQ(network_delegate_, context_->network_delegate());
 
   // Check that there are no callbacks to already canceled requests.
   DCHECK_NE(URLRequestStatus::CANCELED, status_.status());
 
   if (blocked_on_delegate_)
     SetUnblockedOnDelegate();
 
   if (error != OK) {
@@ skipping 11 matching lines @@
         URLRequestRedirectJob::REDIRECT_307_TEMPORARY_REDIRECT);
     StartJob(job);
   } else {
     StartJob(URLRequestJobManager::GetInstance()->CreateJob(
         this, network_delegate_));
   }
 }
 
 void URLRequest::StartJob(URLRequestJob* job) {
   DCHECK(!is_pending_);
-  DCHECK(!job_);
+  DCHECK(!job_.get());
 
   net_log_.BeginEvent(
       NetLog::TYPE_URL_REQUEST_START_JOB,
       base::Bind(&NetLogURLRequestStartCallback,
                  &url(), &method_, load_flags_, priority_,
                  upload_data_stream_ ? upload_data_stream_->identifier() : -1));
 
   job_ = job;
   job_->SetExtraRequestHeaders(extra_request_headers_);
   job_->SetPriority(priority_);
 
   if (upload_data_stream_.get())
     job_->SetUpload(upload_data_stream_.get());
 
   is_pending_ = true;
   is_redirecting_ = false;
 
   response_info_.was_cached = false;
 
   // Don't allow errors to be sent from within Start().
   // TODO(brettw) this may cause NotifyDone to be sent synchronously,
   // we probably don't want this: they should be sent asynchronously so
   // the caller does not get reentered.
   job_->Start();
 }
 
 void URLRequest::Restart() {
   // Should only be called if the original job didn't make any progress.
-  DCHECK(job_ && !job_->has_response_started());
-  RestartWithJob(URLRequestJobManager::GetInstance()->CreateJob(
-      this, network_delegate_));
+  DCHECK(job_.get() && !job_->has_response_started());
+  RestartWithJob(
+      URLRequestJobManager::GetInstance()->CreateJob(this, network_delegate_));
 }
 
 void URLRequest::RestartWithJob(URLRequestJob *job) {
   DCHECK(job->request() == this);
   PrepareToRestart();
   StartJob(job);
 }
 
 void URLRequest::Cancel() {
   DoCancel(ERR_ABORTED, SSLInfo());
 }
 
 void URLRequest::CancelWithError(int error) {
   DoCancel(error, SSLInfo());
 }
 
 void URLRequest::CancelWithSSLError(int error, const SSLInfo& ssl_info) {
   // This should only be called on a started request.
-  if (!is_pending_ || !job_ || job_->has_response_started()) {
+  if (!is_pending_ || !job_.get() || job_->has_response_started()) {
     NOTREACHED();
     return;
   }
   DoCancel(error, ssl_info);
 }
 
 void URLRequest::DoCancel(int error, const SSLInfo& ssl_info) {
   DCHECK(error < 0);
 
   // If the URL request already has an error status, then canceling is a no-op.
   // Plus, we don't want to change the error status once it has been set.
   if (status_.is_success()) {
     status_.set_status(URLRequestStatus::CANCELED);
     status_.set_error(error);
     response_info_.ssl_info = ssl_info;
 
     // If the request hasn't already been completed, log a cancellation event.
     if (!has_notified_completion_) {
       // Don't log an error code on ERR_ABORTED, since that's redundant.
       net_log_.AddEventWithNetErrorCode(NetLog::TYPE_CANCELLED,
                                         error == ERR_ABORTED ? OK : error);
     }
   }
 
-  if (is_pending_ && job_)
+  if (is_pending_ && job_.get())
     job_->Kill();
 
   // We need to notify about the end of this job here synchronously. The
   // Job sends an asynchronous notification but by the time this is processed,
   // our |context_| is NULL.
   NotifyRequestCompleted();
 
   // The Job will call our NotifyDone method asynchronously.  This is done so
   // that the Delegate implementation can call Cancel without having to worry
   // about being called recursively.
 }
 
 bool URLRequest::Read(IOBuffer* dest, int dest_size, int* bytes_read) {
-  DCHECK(job_);
+  DCHECK(job_.get());
   DCHECK(bytes_read);
   *bytes_read = 0;
 
   // This handles a cancel that happens while paused.
   // TODO(ahendrickson): DCHECK() that it is not done after
   // http://crbug.com/115705 is fixed.
   if (job_->is_done())
     return false;
 
   if (dest_size == 0) {
     // Caller is not too bright.  I guess we've done what they asked.
     return true;
   }
 
   // Once the request fails or is cancelled, read will just return 0 bytes
   // to indicate end of stream.
   if (!status_.is_success()) {
     return true;
   }
 
   bool rv = job_->Read(dest, dest_size, bytes_read);
   // If rv is false, the status cannot be success.
   DCHECK(rv || status_.status() != URLRequestStatus::SUCCESS);
   if (rv && *bytes_read <= 0 && status_.is_success())
     NotifyRequestCompleted();
   return rv;
 }
 
 void URLRequest::StopCaching() {
-  DCHECK(job_);
+  DCHECK(job_.get());
   job_->StopCaching();
 }
 
 void URLRequest::NotifyReceivedRedirect(const GURL& location,
                                         bool* defer_redirect) {
   is_redirecting_ = true;
 
   URLRequestJob* job =
       URLRequestJobManager::GetInstance()->MaybeInterceptRedirect(
           this, network_delegate_, location);
@@ skipping 31 matching lines @@
         NotifyRequestCompleted();
 
       delegate_->OnResponseStarted(this);
       // Nothing may appear below this line as OnResponseStarted may delete
       // |this|.
     }
   }
 }
 
 void URLRequest::FollowDeferredRedirect() {
-  CHECK(job_);
+  CHECK(job_.get());
   CHECK(status_.is_success());
 
   job_->FollowDeferredRedirect();
 }
 
 void URLRequest::SetAuth(const AuthCredentials& credentials) {
-  DCHECK(job_);
+  DCHECK(job_.get());
   DCHECK(job_->NeedsAuth());
 
   job_->SetAuth(credentials);
 }
 
 void URLRequest::CancelAuth() {
-  DCHECK(job_);
+  DCHECK(job_.get());
   DCHECK(job_->NeedsAuth());
 
   job_->CancelAuth();
 }
 
 void URLRequest::ContinueWithCertificate(X509Certificate* client_cert) {
-  DCHECK(job_);
+  DCHECK(job_.get());
 
   job_->ContinueWithCertificate(client_cert);
 }
 
 void URLRequest::ContinueDespiteLastError() {
-  DCHECK(job_);
+  DCHECK(job_.get());
 
   job_->ContinueDespiteLastError();
 }
 
 void URLRequest::PrepareToRestart() {
-  DCHECK(job_);
+  DCHECK(job_.get());
 
   // Close the current URL_REQUEST_START_JOB, since we will be starting a new
   // one.
   net_log_.EndEvent(NetLog::TYPE_URL_REQUEST_START_JOB);
 
   OrphanJob();
 
   response_info_ = HttpResponseInfo();
   response_info_.request_time = base::Time::Now();
 
@@ skipping 82 matching lines @@
   Start();
   return OK;
 }
 
 const URLRequestContext* URLRequest::context() const {
   return context_;
 }
 
 int64 URLRequest::GetExpectedContentSize() const {
   int64 expected_content_size = -1;
-  if (job_)
+  if (job_.get())
     expected_content_size = job_->expected_content_size();
 
   return expected_content_size;
 }
 
 void URLRequest::SetPriority(RequestPriority priority) {
   DCHECK_GE(priority, MINIMUM_PRIORITY);
   DCHECK_LT(priority, NUM_PRIORITIES);
   if (priority_ == priority)
     return;
 
   priority_ = priority;
-  if (job_) {
+  if (job_.get()) {
     net_log_.AddEvent(NetLog::TYPE_URL_REQUEST_SET_PRIORITY,
                       NetLog::IntegerCallback("priority", priority_));
     job_->SetPriority(priority_);
   }
 }
 
 bool URLRequest::GetHSTSRedirect(GURL* redirect_url) const {
   const GURL& url = this->url();
   if (!url.SchemeIs("http"))
     return false;
@@ skipping 124 matching lines @@
   if (delegate_)
     delegate_->OnReadCompleted(this, bytes_read);
 
   // Nothing below this line as OnReadCompleted may delete |this|.
 }
 
 void URLRequest::OnHeadersComplete() {
   // Cache load timing information now, as information will be lost once the
   // socket is closed and the ClientSocketHandle is Reset, which will happen
   // once the body is complete.  The start times should already be populated.
-  if (job_) {
+  if (job_.get()) {
     // Keep a copy of the two times the URLRequest sets.
     base::TimeTicks request_start = load_timing_info_.request_start;
     base::Time request_start_time = load_timing_info_.request_start_time;
 
     // Clear load times.  Shouldn't be neded, but gives the GetLoadTimingInfo a
     // consistent place to start from.
     load_timing_info_ = LoadTimingInfo();
     job_->GetLoadTimingInfo(&load_timing_info_);
 
     load_timing_info_.request_start = request_start;
     load_timing_info_.request_start_time = request_start_time;
 
     ConvertRealLoadTimesToBlockingTimes(&load_timing_info_);
   }
 }
 
 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;
   is_redirecting_ = false;
   has_notified_completion_ = true;
   if (network_delegate_)
-    network_delegate_->NotifyCompleted(this, job_ != NULL);
+    network_delegate_->NotifyCompleted(this, job_.get() != NULL);
 }
 
 void URLRequest::SetBlockedOnDelegate() {
   blocked_on_delegate_ = true;
   if (!load_state_param_.empty()) {
     net_log_.BeginEvent(NetLog::TYPE_URL_REQUEST_BLOCKED_ON_DELEGATE,
                         NetLog::StringCallback("delegate", &load_state_param_));
   } else {
     net_log_.BeginEvent(NetLog::TYPE_URL_REQUEST_BLOCKED_ON_DELEGATE);
   }
@@ skipping 12 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