Rename ScopedComPtr::get() to ScopedComPtr::Get()

components/update_client/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/update_client/background_downloader_win.h"
 
 #include <atlbase.h>
 #include <atlcom.h>
 #include <stddef.h>
 
@@ skipping 130 matching lines @@
                             DWORD cookie,
                             ScopedComPtr<T>* p) {
   return git->GetInterfaceFromGlobal(cookie, __uuidof(T), p->ReceiveVoid());
 }
 
 // Registers an interface pointer in GIT and returns its corresponding |cookie|.
 template <typename T>
 HRESULT RegisterInterfaceInGit(const ScopedComPtr<IGlobalInterfaceTable>& git,
                                const ScopedComPtr<T>& p,
                                DWORD* cookie) {
-  return git->RegisterInterfaceInGlobal(p.get(), __uuidof(T), cookie);
+  return git->RegisterInterfaceInGlobal(p.Get(), __uuidof(T), cookie);
 }
 
 // Returns the status code from a given BITS error.
 int GetHttpStatusFromBitsError(HRESULT error) {
   // BITS errors are defined in bitsmsg.h. Although not documented, it is
   // clear that all errors corresponding to http status code have the high
   // word equal to 0x8019 and the low word equal to the http status code.
   const int kHttpStatusFirst = 100;  // Continue.
   const int kHttpStatusLast = 505;   // Version not supported.
   bool is_valid = HIWORD(error) == 0x8019 &&
@@ skipping 10 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.get())
+    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.get())) {
+        pred(current_job.Get())) {
       base::string16 job_description;
-      hr = GetJobDescription(current_job.get(), &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 56 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].get(), &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(
     const ScopedComPtr<IBackgroundCopyManager>& bits_manager) {
-  if (!bits_manager.get())
+  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(
       JobCreationOlderThanDays(kPurgeStaleJobsAfterDays),
-      bits_manager.get(), &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].get());
+    CleanupJobFiles(jobs[i].Get());
   }
 
   return S_OK;
 }
 
 }  // namespace
 
 BackgroundDownloader::BackgroundDownloader(
     std::unique_ptr<CrxDownloader> successor,
     net::URLRequestContextGetter* context_getter,
@@ skipping 150 matching lines @@
   DCHECK(!TimerIsRunning());
 
   const base::TimeTicks download_end_time(base::TimeTicks::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_.get(), &downloaded_bytes, &total_bytes);
+  GetJobByteCount(job_.Get(), &downloaded_bytes, &total_bytes);
 
-  if (FAILED(error) && job_.get()) {
+  if (FAILED(error) && job_.Get()) {
     job_->Cancel();
-    CleanupJobFiles(job_.get());
+    CleanupJobFiles(job_.Get());
   }
 
   CleanupStaleJobs(bits_manager_);
 
   ClearGit();
 
   // Consider the url handled if it has been successfully downloaded or a
   // 5xx has been received.
   const bool is_handled =
       SUCCEEDED(error) || IsHttpServerError(GetHttpStatusFromBitsError(error));
@@ skipping 29 matching lines @@
 // available to the caller.
 bool BackgroundDownloader::OnStateTransferred() {
   EndDownload(CompleteJob());
   return true;
 }
 
 // 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.
 bool BackgroundDownloader::OnStateError() {
   HRESULT error_code = S_OK;
-  HRESULT hr = GetJobError(job_.get(), &error_code);
+  HRESULT hr = GetJobError(job_.Get(), &error_code);
   if (FAILED(hr))
     error_code = hr;
 
   DCHECK(FAILED(error_code));
   EndDownload(error_code);
   return true;
 }
 
 // Called when the download was completed. This notification is not seen
 // in the current implementation but provided here as a defensive programming
@@ skipping 14 matching lines @@
 bool 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()) {
     return OnStateError();
   }
 
   // Don't retry at all if the transient error was a 5xx.
   HRESULT error_code = S_OK;
-  HRESULT hr = GetJobError(job_.get(), &error_code);
+  HRESULT hr = GetJobError(job_.Get(), &error_code);
   if (SUCCEEDED(hr) &&
       IsHttpServerError(GetHttpStatusFromBitsError(error_code))) {
     return OnStateError();
   }
 
   return false;
 }
 
 bool BackgroundDownloader::OnStateQueued() {
   if (!IsStuck())
     return false;
 
   // Terminate the download if the job has not made progress in a while.
   EndDownload(E_ABORT);
   return true;
 }
 
 bool 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::TimeTicks::Now();
 
   int64_t downloaded_bytes = -1;
   int64_t total_bytes = -1;
-  HRESULT hr = GetJobByteCount(job_.get(), &downloaded_bytes, &total_bytes);
+  HRESULT hr = GetJobByteCount(job_.Get(), &downloaded_bytes, &total_bytes);
   if (FAILED(hr))
     return false;
 
   Result result;
   result.downloaded_bytes = downloaded_bytes;
   result.total_bytes = total_bytes;
 
   main_task_runner()->PostTask(
       FROM_HERE, base::Bind(&BackgroundDownloader::OnDownloadProgress,
                             base::Unretained(this), result));
@@ skipping 25 matching lines @@
   *job = p.Detach();
 
   return S_OK;
 }
 
 HRESULT BackgroundDownloader::CreateOrOpenJob(const GURL& url,
                                               IBackgroundCopyJob** job) {
   std::vector<ScopedComPtr<IBackgroundCopyJob>> jobs;
   HRESULT hr = FindBitsJobIf(
       JobFileUrlEqual(base::SysUTF8ToWide(url.spec())),
-      bits_manager_.get(), &jobs);
+      bits_manager_.Get(), &jobs);
   if (SUCCEEDED(hr) && !jobs.empty()) {
     *job = jobs.front().Detach();
     return S_FALSE;
   }
 
   // Use kJobDescription as a temporary job display name until the proper
   // display name is initialized later on.
   GUID guid = {0};
   hr = bits_manager_->CreateJob(kJobDescription, BG_JOB_TYPE_DOWNLOAD, &guid,
                                 job);
@@ skipping 47 matching lines @@
       base::TimeDelta::FromMinutes(kJobStuckTimeoutMin));
   return job_stuck_begin_time_ + job_stuck_timeout < base::TimeTicks::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_.get(), &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().get(), &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);
@@ skipping 43 matching lines @@
 
   for (auto cookie : cookies) {
     // TODO(sorin): check the result of the call, see crbug.com/644857.
     git->RevokeInterfaceFromGlobal(cookie);
   }
 
   return S_OK;
 }
 
 }  // namespace update_client