Remove implicit scoped_refptr 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/file_util_proxy.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 55 matching lines @@
 
 URLFetcherCore::FileWriter::~FileWriter() {
   CloseAndDeleteFile();
 }
 
 void URLFetcherCore::FileWriter::CreateFileAtPath(
     const FilePath& file_path) {
   DCHECK(core_->network_task_runner_->BelongsToCurrentThread());
   DCHECK(file_task_runner_.get());
   base::FileUtilProxy::CreateOrOpen(
-      file_task_runner_,
+      file_task_runner_.get(),
       file_path,
       base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_WRITE,
       base::Bind(&URLFetcherCore::FileWriter::DidCreateFile,
                  weak_factory_.GetWeakPtr(),
                  file_path));
 }
 
 void URLFetcherCore::FileWriter::CreateTempFile() {
   DCHECK(core_->network_task_runner_->BelongsToCurrentThread());
   DCHECK(file_task_runner_.get());
   base::FileUtilProxy::CreateTemporary(
-      file_task_runner_,
+      file_task_runner_.get(),
       0,  // No additional file flags.
       base::Bind(&URLFetcherCore::FileWriter::DidCreateTempFile,
                  weak_factory_.GetWeakPtr()));
 }
 
 void URLFetcherCore::FileWriter::WriteBuffer(int num_bytes) {
   DCHECK(core_->network_task_runner_->BelongsToCurrentThread());
 
   // Start writing to the file by setting the initial state
   // of |pending_bytes_| and |buffer_offset_| to indicate that the
@@ skipping 31 matching lines @@
         base::Bind(&URLFetcherCore::InformDelegateFetchIsComplete, core_));
     return;
   }
 
   total_bytes_written_ += bytes_written;
   buffer_offset_ += bytes_written;
   pending_bytes_ -= bytes_written;
 
   if (pending_bytes_ > 0) {
     base::FileUtilProxy::Write(
-        file_task_runner_, file_handle_,
+        file_task_runner_.get(), file_handle_,
         total_bytes_written_,  // Append to the end
         (core_->buffer_->data() + buffer_offset_), pending_bytes_,
         base::Bind(&URLFetcherCore::FileWriter::ContinueWrite,
                    weak_factory_.GetWeakPtr()));
   } else {
     // Finished writing core_->buffer_ to the file. Read some more.
     core_->ReadResponse();
   }
 }
 
 void URLFetcherCore::FileWriter::DisownFile() {
   DCHECK(core_->network_task_runner_->BelongsToCurrentThread());
 
   // Disowning is done by the delegate's OnURLFetchComplete method.
   // The file should be closed by the time that method is called.
   DCHECK(file_handle_ == base::kInvalidPlatformFileValue);
 
   // Forget about any file by reseting the path.
   file_path_.clear();
 }
 
 void URLFetcherCore::FileWriter::CloseFileAndCompleteRequest() {
   DCHECK(core_->network_task_runner_->BelongsToCurrentThread());
 
   if (file_handle_ != base::kInvalidPlatformFileValue) {
     base::FileUtilProxy::Close(
-        file_task_runner_, file_handle_,
+        file_task_runner_.get(), file_handle_,
         base::Bind(&URLFetcherCore::FileWriter::DidCloseFile,
                    weak_factory_.GetWeakPtr()));
     file_handle_ = base::kInvalidPlatformFileValue;
   }
 }
 
 void URLFetcherCore::FileWriter::CloseAndDeleteFile() {
   DCHECK(core_->network_task_runner_->BelongsToCurrentThread());
 
   if (file_handle_ == base::kInvalidPlatformFileValue) {
     DeleteFile(base::PLATFORM_FILE_OK);
     return;
   }
   // Close the file if it is open.
   base::FileUtilProxy::Close(
-      file_task_runner_, file_handle_,
+      file_task_runner_.get(), file_handle_,
       base::Bind(&URLFetcherCore::FileWriter::DeleteFile,
                  weak_factory_.GetWeakPtr()));
   file_handle_ = base::kInvalidPlatformFileValue;
 }
 
 void URLFetcherCore::FileWriter::DeleteFile(
     base::PlatformFileError error_code) {
   DCHECK(core_->network_task_runner_->BelongsToCurrentThread());
   if (file_path_.empty())
     return;
 
   base::FileUtilProxy::Delete(
-      file_task_runner_, file_path_,
+      file_task_runner_.get(), file_path_,
       false,  // No need to recurse, as the path is to a file.
       base::FileUtilProxy::StatusCallback());
   DisownFile();
 }
 
 void URLFetcherCore::FileWriter::DidCreateFile(
     const FilePath& file_path,
     base::PlatformFileError error_code,
     base::PassPlatformFile file_handle,
     bool created) {
@@ skipping 81 matching lines @@
       max_retries_(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_) {
+  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 @@
   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 36 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 124 matching lines @@
     current_response_bytes_ += bytes_read;
     InformDelegateDownloadProgress();
     InformDelegateDownloadDataIfNecessary(bytes_read);
 
     if (!WriteBuffer(bytes_read)) {
       // If WriteBuffer() returns false, we have a pending write to
       // wait on before reading further.
       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 151 matching lines @@
 
 void URLFetcherCore::StartURLRequestWhenAppropriate() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   if (was_cancelled_)
     return;
 
   DCHECK(request_context_getter_);
 
   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 31 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 43 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();
   }
 }
@@ skipping 39 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() {
   file_writer_->DisownFile();
 }
 
 void URLFetcherCore::InformDelegateUploadProgress() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   if (request_.get()) {
@@ skipping 49 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