Remove implicit conversions from scoped_refptr to T* in components/

components/component_updater/background_downloader_win.cc

 // Copyright 2014 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 "components/component_updater/background_downloader_win.h"
 
 #include <atlbase.h>
 #include <atlcom.h>
 
 #include <stdint.h>
@@ skipping 136 matching lines @@
   if (FAILED(hr))
     return hr;
 
   ULONG num_files = 0;
   hr = enum_files->GetCount(&num_files);
   if (FAILED(hr))
     return hr;
 
   for (ULONG i = 0; i != num_files; ++i) {
     ScopedComPtr<IBackgroundCopyFile> file;
-    if (enum_files->Next(1, file.Receive(), NULL) == S_OK && file)
+    if (enum_files->Next(1, file.Receive(), NULL) == S_OK && file.get())
       files->push_back(file);
   }
 
   return S_OK;
 }
 
 // Returns the file name, the url, and some per-file progress information.
 // The function out parameters can be NULL if that data is not requested.
 HRESULT GetJobFileProperties(IBackgroundCopyFile* file,
                              base::string16* local_name,
@@ skipping 100 matching lines @@
   ULONG job_count = 0;
   hr = enum_jobs->GetCount(&job_count);
   if (FAILED(hr))
     return hr;
 
   // Iterate over jobs, run the predicate, and select the job only if
   // the job description matches the component updater jobs.
   for (ULONG i = 0; i != job_count; ++i) {
     ScopedComPtr<IBackgroundCopyJob> current_job;
     if (enum_jobs->Next(1, current_job.Receive(), NULL) == S_OK &&
-        pred(current_job)) {
+        pred(current_job.get())) {
       base::string16 job_description;
-      hr = GetJobDescription(current_job, &job_description);
+      hr = GetJobDescription(current_job.get(), &job_description);
       if (job_description.compare(kJobDescription) == 0)
         jobs->push_back(current_job);
     }
   }
 
   return jobs->empty() ? S_FALSE : S_OK;
 }
 
 // Compares the job creation time and returns true if the job creation time
 // is older than |num_days|.
@@ skipping 51 matching lines @@
   *bits_manager = object.Detach();
   return S_OK;
 }
 
 void CleanupJobFiles(IBackgroundCopyJob* job) {
   std::vector<ScopedComPtr<IBackgroundCopyFile> > files;
   if (FAILED(GetFilesInJob(job, &files)))
     return;
   for (size_t i = 0; i != files.size(); ++i) {
     base::string16 local_name;
-    HRESULT hr(GetJobFileProperties(files[i], &local_name, NULL, NULL));
+    HRESULT hr(GetJobFileProperties(files[i].get(), &local_name, NULL, NULL));
     if (SUCCEEDED(hr))
       DeleteFileAndEmptyParentDirectory(base::FilePath(local_name));
   }
 }
 
 // Cleans up incompleted jobs that are too old.
 HRESULT CleanupStaleJobs(
     base::win::ScopedComPtr<IBackgroundCopyManager> bits_manager) {
-  if (!bits_manager)
+  if (!bits_manager.get())
     return E_FAIL;
 
   static base::Time last_sweep;
 
   const base::TimeDelta time_delta(
       base::TimeDelta::FromDays(kPurgeStaleJobsIntervalBetweenChecksDays));
   const base::Time current_time(base::Time::Now());
   if (last_sweep + time_delta > current_time)
     return S_OK;
 
   last_sweep = current_time;
 
   std::vector<ScopedComPtr<IBackgroundCopyJob> > jobs;
   HRESULT hr = FindBitsJobIf(
       std::bind2nd(JobCreationOlderThanDays(), kPurgeStaleJobsAfterDays),
-      bits_manager,
-      &jobs);
+      bits_manager.get(), &jobs);
   if (FAILED(hr))
     return hr;
 
   for (size_t i = 0; i != jobs.size(); ++i) {
     jobs[i]->Cancel();
-    CleanupJobFiles(jobs[i]);
+    CleanupJobFiles(jobs[i].get());
   }
 
   return S_OK;
 }
 
 }  // namespace
 
 BackgroundDownloader::BackgroundDownloader(
     scoped_ptr<CrxDownloader> successor,
     net::URLRequestContextGetter* context_getter,
@@ skipping 53 matching lines @@
   timer_->Start(FROM_HERE,
                 base::TimeDelta::FromSeconds(kJobPollingIntervalSec),
                 this,
                 &BackgroundDownloader::OnDownloading);
 }
 
 // Called any time the timer fires.
 void BackgroundDownloader::OnDownloading() {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
-  DCHECK(job_);
+  DCHECK(job_.get());
 
   DCHECK(!is_completed_);
   if (is_completed_)
     return;
 
   BG_JOB_STATE job_state = BG_JOB_STATE_ERROR;
   HRESULT hr = job_->GetState(&job_state);
   if (FAILED(hr)) {
     EndDownload(hr);
     return;
@@ skipping 48 matching lines @@
   timer_.reset();
 
   const base::Time download_end_time(base::Time::Now());
   const base::TimeDelta download_time =
       download_end_time >= download_start_time_
           ? download_end_time - download_start_time_
           : base::TimeDelta();
 
   int64_t downloaded_bytes = -1;
   int64_t total_bytes = -1;
-  GetJobByteCount(job_, &downloaded_bytes, &total_bytes);
+  GetJobByteCount(job_.get(), &downloaded_bytes, &total_bytes);
 
-  if (FAILED(error) && job_) {
+  if (FAILED(error) && job_.get()) {
     job_->Cancel();
-    CleanupJobFiles(job_);
+    CleanupJobFiles(job_.get());
   }
 
   job_ = NULL;
 
   CleanupStaleJobs(bits_manager_);
   bits_manager_ = NULL;
 
   // Consider the url handled if it has been successfully downloaded or a
   // 5xx has been received.
   const bool is_handled =
@@ skipping 32 matching lines @@
 // BITS job by removing it from the BITS queue and making the download
 // available to the caller.
 void BackgroundDownloader::OnStateTransferred() {
   EndDownload(CompleteJob());
 }
 
 // Called when the job has encountered an error and no further progress can
 // be made. Cancels this job and removes it from the BITS queue.
 void BackgroundDownloader::OnStateError() {
   HRESULT error_code = S_OK;
-  HRESULT hr = GetJobError(job_, &error_code);
+  HRESULT hr = GetJobError(job_.get(), &error_code);
   if (FAILED(hr))
     error_code = hr;
   DCHECK(FAILED(error_code));
   EndDownload(error_code);
 }
 
 // Called when the job has encountered a transient error, such as a
 // network disconnect, a server error, or some other recoverable error.
 void BackgroundDownloader::OnStateTransientError() {
   // If the job appears to be stuck, handle the transient error as if
   // it were a final error. This causes the job to be cancelled and a specific
   // error be returned, if the error was available.
   if (IsStuck()) {
     OnStateError();
     return;
   }
 
   // Don't retry at all if the transient error was a 5xx.
   HRESULT error_code = S_OK;
-  HRESULT hr = GetJobError(job_, &error_code);
+  HRESULT hr = GetJobError(job_.get(), &error_code);
   if (SUCCEEDED(hr) &&
       IsHttpServerError(GetHttpStatusFromBitsError(error_code))) {
     OnStateError();
     return;
   }
 }
 
 void BackgroundDownloader::OnStateQueued() {
   if (IsStuck())
     EndDownload(E_ABORT);  // Return a generic error for now.
 }
 
 void BackgroundDownloader::OnStateTransferring() {
   // Resets the baseline for detecting a stuck job since the job is transferring
   // data and it is making progress.
   job_stuck_begin_time_ = base::Time::Now();
 
   int64_t downloaded_bytes = -1;
   int64_t total_bytes = -1;
-  HRESULT hr = GetJobByteCount(job_, &downloaded_bytes, &total_bytes);
+  HRESULT hr = GetJobByteCount(job_.get(), &downloaded_bytes, &total_bytes);
   if (FAILED(hr))
     return;
 
   Result result;
   result.downloaded_bytes = downloaded_bytes;
   result.total_bytes = total_bytes;
 
   main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&BackgroundDownloader::OnDownloadProgress,
@@ skipping 11 matching lines @@
 void BackgroundDownloader::OnStateAcknowledged() {
   EndDownload(E_UNEXPECTED);
 }
 
 // Creates or opens a job for the given url and queues it up. Tries to
 // install a job observer but continues on if an observer can't be set up.
 HRESULT BackgroundDownloader::QueueBitsJob(const GURL& url) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   HRESULT hr = S_OK;
-  if (bits_manager_ == NULL) {
+  if (bits_manager_.get() == NULL) {
     hr = GetBitsManager(bits_manager_.Receive());
     if (FAILED(hr))
       return hr;
   }
 
   hr = CreateOrOpenJob(url);
   if (FAILED(hr))
     return hr;
 
   if (hr == S_OK) {
     hr = InitializeNewJob(url);
     if (FAILED(hr))
       return hr;
   }
 
   return job_->Resume();
 }
 
 HRESULT BackgroundDownloader::CreateOrOpenJob(const GURL& url) {
   std::vector<ScopedComPtr<IBackgroundCopyJob> > jobs;
   HRESULT hr = FindBitsJobIf(
       std::bind2nd(JobFileUrlEqual(), base::SysUTF8ToWide(url.spec())),
-      bits_manager_,
-      &jobs);
+      bits_manager_.get(), &jobs);
   if (SUCCEEDED(hr) && !jobs.empty()) {
     job_ = jobs.front();
     return S_FALSE;
   }
 
   // Use kJobDescription as a temporary job display name until the proper
   // display name is initialized later on.
   GUID guid = {0};
   ScopedComPtr<IBackgroundCopyJob> job;
   hr = bits_manager_->CreateJob(
@@ skipping 47 matching lines @@
       base::TimeDelta::FromMinutes(kJobStuckTimeoutMin));
   return job_stuck_begin_time_ + job_stuck_timeout < base::Time::Now();
 }
 
 HRESULT BackgroundDownloader::CompleteJob() {
   HRESULT hr = job_->Complete();
   if (FAILED(hr) && hr != BG_S_UNABLE_TO_DELETE_FILES)
     return hr;
 
   std::vector<ScopedComPtr<IBackgroundCopyFile> > files;
-  hr = GetFilesInJob(job_, &files);
+  hr = GetFilesInJob(job_.get(), &files);
   if (FAILED(hr))
     return hr;
 
   if (files.empty())
     return E_UNEXPECTED;
 
   base::string16 local_name;
   BG_FILE_PROGRESS progress = {0};
-  hr = GetJobFileProperties(files.front(), &local_name, NULL, &progress);
+  hr = GetJobFileProperties(files.front().get(), &local_name, NULL, &progress);
   if (FAILED(hr))
     return hr;
 
   // Sanity check the post-conditions of a successful download, including
   // the file and job invariants. The byte counts for a job and its file
   // must match as a job only contains one file.
   DCHECK(progress.Completed);
   DCHECK_EQ(progress.BytesTotal, progress.BytesTransferred);
 
   response_ = base::FilePath(local_name);
 
   return S_OK;
 }
 
 }  // namespace component_updater