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

net/url_request/url_fetcher_core.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_fetcher_core.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 80 matching lines @@
       max_retries_on_5xx_(0),
       num_retries_on_network_changes_(0),
       max_retries_on_network_changes_(0),
       current_upload_bytes_(-1),
       current_response_bytes_(0),
       total_response_bytes_(-1) {
   CHECK(original_url_.is_valid());
 }
 
 void URLFetcherCore::Start() {
-  DCHECK(delegate_task_runner_);
-  DCHECK(request_context_getter_) << "We need an URLRequestContext!";
-  if (network_task_runner_) {
+  DCHECK(delegate_task_runner_.get());
+  DCHECK(request_context_getter_.get()) << "We need an URLRequestContext!";
+  if (network_task_runner_.get()) {
     DCHECK_EQ(network_task_runner_,
               request_context_getter_->GetNetworkTaskRunner());
   } else {
     network_task_runner_ = request_context_getter_->GetNetworkTaskRunner();
   }
   DCHECK(network_task_runner_.get()) << "We need an IO task runner";
 
   network_task_runner_->PostTask(
       FROM_HERE, base::Bind(&URLFetcherCore::StartOnIOThread, this));
 }
 
 void URLFetcherCore::Stop() {
-  if (delegate_task_runner_)  // May be NULL in tests.
+  if (delegate_task_runner_.get())  // May be NULL in tests.
     DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 
   delegate_ = NULL;
   fetcher_ = NULL;
   if (!network_task_runner_.get())
     return;
   if (network_task_runner_->RunsTasksOnCurrentThread()) {
     CancelURLRequest();
   } else {
     network_task_runner_->PostTask(
@@ skipping 49 matching lines @@
   // to ensure non-empty upload content as it is not yet supplied.
   DCHECK(!content_type.empty());
 
   upload_content_type_ = content_type;
   upload_content_.clear();
   is_chunked_upload_ = true;
 }
 
 void URLFetcherCore::AppendChunkToUpload(const std::string& content,
                                          bool is_last_chunk) {
-  DCHECK(delegate_task_runner_);
+  DCHECK(delegate_task_runner_.get());
   DCHECK(network_task_runner_.get());
   network_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&URLFetcherCore::CompleteAddingUploadDataChunk, this, content,
                  is_last_chunk));
 }
 
 void URLFetcherCore::SetLoadFlags(int load_flags) {
   load_flags_ = load_flags;
 }
@@ skipping 16 matching lines @@
   extra_request_headers_.AddHeaderFromString(header_line);
 }
 
 void URLFetcherCore::GetExtraRequestHeaders(
     HttpRequestHeaders* headers) const {
   headers->CopyFrom(extra_request_headers_);
 }
 
 void URLFetcherCore::SetRequestContext(
     URLRequestContextGetter* request_context_getter) {
-  DCHECK(!request_context_getter_);
+  DCHECK(!request_context_getter_.get());
   DCHECK(request_context_getter);
   request_context_getter_ = request_context_getter;
 }
 
 void URLFetcherCore::SetFirstPartyForCookies(
     const GURL& first_party_for_cookies) {
   DCHECK(first_party_for_cookies_.is_empty());
   first_party_for_cookies_ = first_party_for_cookies;
 }
 
@@ skipping 40 matching lines @@
 }
 
 void URLFetcherCore::SaveResponseToTemporaryFile(
     scoped_refptr<base::TaskRunner> file_task_runner) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
   file_task_runner_ = file_task_runner;
   response_destination_ = URLFetcherCore::TEMP_FILE;
 }
 
 HttpResponseHeaders* URLFetcherCore::GetResponseHeaders() const {
-  return response_headers_;
+  return response_headers_.get();
 }
 
 // TODO(panayiotis): socket_address_ is written in the IO thread,
 // if this is accessed in the UI thread, this could result in a race.
 // Same for response_headers_ above and was_fetched_via_proxy_ below.
 HostPortPair URLFetcherCore::GetSocketAddress() const {
   return socket_address_;
 }
 
 bool URLFetcherCore::WasFetchedViaProxy() const {
@@ skipping 129 matching lines @@
 
   bool waiting_on_write = false;
   do {
     if (!request_->status().is_success() || bytes_read <= 0)
       break;
 
     current_response_bytes_ += bytes_read;
     InformDelegateDownloadProgress();
     InformDelegateDownloadDataIfNecessary(bytes_read);
 
-    const int result = WriteBuffer(new DrainableIOBuffer(buffer_, bytes_read));
+    const int result =
+        WriteBuffer(new DrainableIOBuffer(buffer_.get(), bytes_read));
     if (result < 0) {
       // Write failed or waiting for write completion.
       if (result == ERR_IO_PENDING)
         waiting_on_write = true;
       break;
     }
-  } while (request_->Read(buffer_, kBufferSize, &bytes_read));
+  } while (request_->Read(buffer_.get(), kBufferSize, &bytes_read));
 
   const URLRequestStatus status = request_->status();
 
   if (status.is_success())
     request_->GetResponseCookies(&cookies_);
 
   // See comments re: HEAD requests in ReadResponse().
   if ((!status.is_io_pending() && !waiting_on_write) ||
       (request_type_ == URLFetcher::HEAD)) {
     status_ = status;
@@ skipping 65 matching lines @@
 
 void URLFetcherCore::StartURLRequest() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   if (was_cancelled_) {
     // Since StartURLRequest() is posted as a *delayed* task, it may
     // run after the URLFetcher was already stopped.
     return;
   }
 
-  DCHECK(request_context_getter_);
+  DCHECK(request_context_getter_.get());
   DCHECK(!request_.get());
 
   g_registry.Get().AddURLFetcherCore(this);
   current_response_bytes_ = 0;
   request_.reset(request_context_getter_->GetURLRequestContext()->CreateRequest(
       original_url_, this));
   request_->set_stack_trace(stack_trace_);
   int flags = request_->load_flags() | load_flags_;
   if (!g_interception_enabled)
     flags = flags | LOAD_DISABLE_INTERCEPT;
@@ skipping 27 matching lines @@
       if (!upload_content_type_.empty()) {
         extra_request_headers_.SetHeader(HttpRequestHeaders::kContentType,
                                          upload_content_type_);
       }
       if (!upload_content_.empty()) {
         scoped_ptr<UploadElementReader> reader(new UploadBytesElementReader(
             upload_content_.data(), upload_content_.size()));
         request_->set_upload(make_scoped_ptr(
             UploadDataStream::CreateWithReader(reader.Pass(), 0)));
       } else if (!upload_file_path_.empty()) {
-        scoped_ptr<UploadElementReader> reader(new UploadFileElementReader(
-            upload_file_task_runner_,
-            upload_file_path_,
-            upload_range_offset_,
-            upload_range_length_,
-            base::Time()));
+        scoped_ptr<UploadElementReader> reader(
+            new UploadFileElementReader(upload_file_task_runner_.get(),
+                                        upload_file_path_,
+                                        upload_range_offset_,
+                                        upload_range_length_,
+                                        base::Time()));
         request_->set_upload(make_scoped_ptr(
             UploadDataStream::CreateWithReader(reader.Pass(), 0)));
       }
 
       current_upload_bytes_ = -1;
       // TODO(kinaba): http://crbug.com/118103. Implement upload callback in the
       //  layer and avoid using timer here.
       upload_progress_checker_timer_.reset(
           new base::RepeatingTimer<URLFetcherCore>());
       upload_progress_checker_timer_->Start(
@@ skipping 37 matching lines @@
   }
   StartURLRequestWhenAppropriate();
 }
 
 void URLFetcherCore::StartURLRequestWhenAppropriate() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   if (was_cancelled_)
     return;
 
-  DCHECK(request_context_getter_);
+  DCHECK(request_context_getter_.get());
 
   int64 delay = 0LL;
-  if (original_url_throttler_entry_ == NULL) {
+  if (original_url_throttler_entry_.get() == NULL) {
     URLRequestThrottlerManager* manager =
         request_context_getter_->GetURLRequestContext()->throttler_manager();
     if (manager) {
       original_url_throttler_entry_ =
           manager->RegisterRequestUrl(original_url_);
     }
   }
-  if (original_url_throttler_entry_ != NULL) {
+  if (original_url_throttler_entry_.get() != NULL) {
     delay = original_url_throttler_entry_->ReserveSendingTimeForNextRequest(
         GetBackoffReleaseTime());
   }
 
   if (delay == 0) {
     StartURLRequest();
   } else {
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, base::Bind(&URLFetcherCore::StartURLRequest, this),
         base::TimeDelta::FromMilliseconds(delay));
@@ skipping 32 matching lines @@
 }
 
 void URLFetcherCore::InformDelegateFetchIsComplete() {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
   if (delegate_)
     delegate_->OnURLFetchComplete(fetcher_);
 }
 
 void URLFetcherCore::NotifyMalformedContent() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
-  if (url_throttler_entry_ != NULL) {
+  if (url_throttler_entry_.get() != NULL) {
     int status_code = response_code_;
     if (status_code == URLFetcher::RESPONSE_CODE_INVALID) {
       // The status code will generally be known by the time clients
       // call the |ReceivedContentWasMalformed()| function (which ends up
       // calling the current function) but if it's not, we need to assume
       // the response was successful so that the total failure count
       // used to calculate exponential back-off goes up.
       status_code = 200;
     }
     url_throttler_entry_->ReceivedContentWasMalformed(status_code);
@@ skipping 68 matching lines @@
 
 void URLFetcherCore::ReleaseRequest() {
   upload_progress_checker_timer_.reset();
   request_.reset();
   g_registry.Get().RemoveURLFetcherCore(this);
 }
 
 base::TimeTicks URLFetcherCore::GetBackoffReleaseTime() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
-  if (original_url_throttler_entry_) {
+  if (original_url_throttler_entry_.get()) {
     base::TimeTicks original_url_backoff =
         original_url_throttler_entry_->GetExponentialBackoffReleaseTime();
     base::TimeTicks destination_url_backoff;
-    if (url_throttler_entry_ != NULL &&
-        original_url_throttler_entry_ != url_throttler_entry_) {
+    if (url_throttler_entry_.get() != NULL &&
+        original_url_throttler_entry_.get() != url_throttler_entry_.get()) {
       destination_url_backoff =
           url_throttler_entry_->GetExponentialBackoffReleaseTime();
     }
 
     return original_url_backoff > destination_url_backoff ?
         original_url_backoff : destination_url_backoff;
   } else {
     return base::TimeTicks();
   }
 }
 
 void URLFetcherCore::CompleteAddingUploadDataChunk(
     const std::string& content, bool is_last_chunk) {
   if (was_cancelled_) {
     // Since CompleteAddingUploadDataChunk() is posted as a *delayed* task, it
     // may run after the URLFetcher was already stopped.
     return;
   }
   DCHECK(is_chunked_upload_);
   DCHECK(request_.get());
   DCHECK(!content.empty());
   request_->AppendChunkToUpload(content.data(),
                                 static_cast<int>(content.length()),
                                 is_last_chunk);
 }
 
 int URLFetcherCore::WriteBuffer(scoped_refptr<DrainableIOBuffer> data) {
   while (data->BytesRemaining() > 0) {
     const int result = response_writer_->Write(
-        data, data->BytesRemaining(),
+        data.get(),
+        data->BytesRemaining(),
         base::Bind(&URLFetcherCore::DidWriteBuffer, this, data));
     if (result < 0)
       return result;
     data->DidConsume(result);
   }
   return OK;
 }
 
 void URLFetcherCore::DidWriteBuffer(scoped_refptr<DrainableIOBuffer> data,
                                     int result) {
@@ skipping 16 matching lines @@
 }
 
 void URLFetcherCore::ReadResponse() {
   // Some servers may treat HEAD requests as GET requests.  To free up the
   // network connection as soon as possible, signal that the request has
   // completed immediately, without trying to read any data back (all we care
   // about is the response code and headers, which we already have).
   int bytes_read = 0;
   if (request_->status().is_success() &&
       (request_type_ != URLFetcher::HEAD))
-    request_->Read(buffer_, kBufferSize, &bytes_read);
+    request_->Read(buffer_.get(), kBufferSize, &bytes_read);
   OnReadCompleted(request_.get(), bytes_read);
 }
 
 void URLFetcherCore::DisownFile() {
   DCHECK(file_writer_);
   file_writer_->DisownFile();
 }
 
 void URLFetcherCore::InformDelegateUploadProgress() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
@@ skipping 55 matching lines @@
 }
 
 void URLFetcherCore::InformDelegateDownloadDataInDelegateThread(
     scoped_ptr<std::string> download_data) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
   if (delegate_)
     delegate_->OnURLFetchDownloadData(fetcher_, download_data.Pass());
 }
 
 }  // namespace net