Move most of the component updater artifacts to update_client.

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/component_updater/background_downloader_win.h"
+#include "components/update_client/background_downloader_win.h"
 
 #include <atlbase.h>
 #include <atlcom.h>
 
 #include <stdint.h>
 #include <functional>
 #include <iomanip>
 #include <limits>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/win/scoped_co_mem.h"
-#include "components/component_updater/component_updater_utils.h"
+#include "components/update_client/utils.h"
 #include "ui/base/win/atl_module.h"
 #include "url/gurl.h"
 
 using base::win::ScopedCoMem;
 using base::win::ScopedComPtr;
 
 // The class BackgroundDownloader in this module is an adapter between
 // the CrxDownloader interface and the BITS service interfaces.
 // The interface exposed on the CrxDownloader code runs on the main thread,
 // while the BITS specific code runs on a separate thread passed in by the
@@ skipping 52 matching lines @@
 //
 // In addition to how BITS is managing the life time of the job, there are a
 // couple of special cases defined by the BackgroundDownloader.
 // First, if the job encounters any of the 5xx HTTP responses, the job is
 // not retried, in order to avoid DDOS-ing the servers.
 // Second, there is a simple mechanism to detect stuck jobs, and allow the rest
 // of the code to move on to trying other urls or trying other components.
 // Last, after completing a job, irrespective of the outcome, the jobs older
 // than a week are proactively cleaned up.
 
-namespace component_updater {
+namespace update_client {
 
 namespace {
 
 // All jobs created by this module have a specific description so they can
 // be found at run-time or by using system administration tools.
 const base::char16 kJobDescription[] = L"Chrome Component Updater";
 
 // How often the code looks for changes in the BITS job state.
 const int kJobPollingIntervalSec = 4;
 
@@ skipping 27 matching lines @@
   const int kHttpStatusFirst = 100;  // Continue.
   const int kHttpStatusLast = 505;   // Version not supported.
   bool is_valid = HIWORD(error) == 0x8019 &&
                   LOWORD(error) >= kHttpStatusFirst &&
                   LOWORD(error) <= kHttpStatusLast;
   return is_valid ? LOWORD(error) : 0;
 }
 
 // Returns the files in a BITS job.
 HRESULT GetFilesInJob(IBackgroundCopyJob* job,
-                      std::vector<ScopedComPtr<IBackgroundCopyFile> >* files) {
+                      std::vector<ScopedComPtr<IBackgroundCopyFile>>* files) {
   ScopedComPtr<IEnumBackgroundCopyFiles> enum_files;
   HRESULT hr = job->EnumFiles(enum_files.Receive());
   if (FAILED(hr))
     return hr;
 
   ULONG num_files = 0;
   hr = enum_files->GetCount(&num_files);
   if (FAILED(hr))
     return hr;
 
@@ skipping 97 matching lines @@
   *error_code_out = FAILED(error_code) ? error_code : E_FAIL;
   return S_OK;
 }
 
 // Finds the component updater jobs matching the given predicate.
 // Returns S_OK if the function has found at least one job, returns S_FALSE if
 // no job was found, and it returns an error otherwise.
 template <class Predicate>
 HRESULT FindBitsJobIf(Predicate pred,
                       IBackgroundCopyManager* bits_manager,
-                      std::vector<ScopedComPtr<IBackgroundCopyJob> >* jobs) {
+                      std::vector<ScopedComPtr<IBackgroundCopyJob>>* jobs) {
   ScopedComPtr<IEnumBackgroundCopyJobs> enum_jobs;
   HRESULT hr = bits_manager->EnumJobs(0, enum_jobs.Receive());
   if (FAILED(hr))
     return hr;
 
   ULONG job_count = 0;
   hr = enum_jobs->GetCount(&job_count);
   if (FAILED(hr))
     return hr;
 
@@ skipping 37 matching lines @@
 // of any file in a job matches the argument.
 struct JobFileUrlEqual : public std::binary_function<IBackgroundCopyJob*,
                                                      const base::string16&,
                                                      bool> {
   bool operator()(IBackgroundCopyJob* job,
                   const base::string16& remote_name) const;
 };
 
 bool JobFileUrlEqual::operator()(IBackgroundCopyJob* job,
                                  const base::string16& remote_name) const {
-  std::vector<ScopedComPtr<IBackgroundCopyFile> > files;
+  std::vector<ScopedComPtr<IBackgroundCopyFile>> files;
   HRESULT hr = GetFilesInJob(job, &files);
   if (FAILED(hr))
     return false;
 
   for (size_t i = 0; i != files.size(); ++i) {
     ScopedCoMem<base::char16> name;
     if (SUCCEEDED(files[i]->GetRemoteName(&name)) &&
         remote_name.compare(name) == 0)
       return true;
   }
 
   return false;
 }
 
 // Creates an instance of the BITS manager.
 HRESULT GetBitsManager(IBackgroundCopyManager** bits_manager) {
   ScopedComPtr<IBackgroundCopyManager> object;
   HRESULT hr = object.CreateInstance(__uuidof(BackgroundCopyManager));
   if (FAILED(hr)) {
     return hr;
   }
   *bits_manager = object.Detach();
   return S_OK;
 }
 
 void CleanupJobFiles(IBackgroundCopyJob* job) {
-  std::vector<ScopedComPtr<IBackgroundCopyFile> > files;
+  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));
     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.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;
+  std::vector<ScopedComPtr<IBackgroundCopyJob>> jobs;
   HRESULT hr = FindBitsJobIf(
       std::bind2nd(JobCreationOlderThanDays(), kPurgeStaleJobsAfterDays),
       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());
   }
@@ skipping 26 matching lines @@
   // the interface pointers are valid. Releasing the ownership means leaking
   // these objects and their associated resources.
   timer_.release();
   bits_manager_.Detach();
   job_.Detach();
 }
 
 void BackgroundDownloader::DoStartDownload(const GURL& url) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(
-          &BackgroundDownloader::BeginDownload, base::Unretained(this), url));
+  task_runner_->PostTask(FROM_HERE,
+                         base::Bind(&BackgroundDownloader::BeginDownload,
+                                    base::Unretained(this), url));
 }
 
 // Called once when this class is asked to do a download. Creates or opens
 // an existing bits job, hooks up the notifications, and starts the timer.
 void BackgroundDownloader::BeginDownload(const GURL& url) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   DCHECK(!timer_);
 
   is_completed_ = false;
   download_start_time_ = base::Time::Now();
   job_stuck_begin_time_ = download_start_time_;
 
   HRESULT hr = QueueBitsJob(url);
   if (FAILED(hr)) {
     EndDownload(hr);
     return;
   }
 
   // A repeating timer retains the user task. This timer can be stopped and
   // reset multiple times.
   timer_.reset(new base::RepeatingTimer<BackgroundDownloader>);
-  timer_->Start(FROM_HERE,
-                base::TimeDelta::FromSeconds(kJobPollingIntervalSec),
-                this,
-                &BackgroundDownloader::OnDownloading);
+  timer_->Start(FROM_HERE, base::TimeDelta::FromSeconds(kJobPollingIntervalSec),
+                this, &BackgroundDownloader::OnDownloading);

[waffles, 2015/01/20 21:49:07]

Did git cl format do this? I liked the old format better.

(Same comment elsewhere.)

 }
 
 // Called any time the timer fires.
 void BackgroundDownloader::OnDownloading() {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   DCHECK(job_.get());
 
   DCHECK(!is_completed_);
   if (is_completed_)
@@ skipping 90 matching lines @@
   download_metrics.download_time_ms = download_time.InMilliseconds();
 
   Result result;
   result.error = error_to_report;
   result.response = response_;
   result.downloaded_bytes = downloaded_bytes;
   result.total_bytes = total_bytes;
   main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&BackgroundDownloader::OnDownloadComplete,
-                 base::Unretained(this),
-                 is_handled,
-                 result,
-                 download_metrics));
+                 base::Unretained(this), is_handled, result, download_metrics));
 
   // Once the task is posted to the the main thread, this object may be deleted
   // by its owner. It is not safe to access members of this object on the
   // task runner from this point on. The timer is stopped and all BITS
   // interface pointers have been released.
 }
 
 // Called when the BITS job has been transferred successfully. Completes the
 // BITS job by removing it from the BITS queue and making the download
 // available to the caller.
@@ skipping 47 matching lines @@
   int64_t total_bytes = -1;
   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,
-                 base::Unretained(this),
-                 result));
+      FROM_HERE, base::Bind(&BackgroundDownloader::OnDownloadProgress,
+                            base::Unretained(this), result));
 }
 
 // Called when the download was cancelled. Since the observer should have
 // been disconnected by now, this notification must not be seen.
 void BackgroundDownloader::OnStateCancelled() {
   EndDownload(E_UNEXPECTED);
 }
 
 // Called when the download was completed. Same as above.
 void BackgroundDownloader::OnStateAcknowledged() {
@@ skipping 19 matching lines @@
   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;
+  std::vector<ScopedComPtr<IBackgroundCopyJob>> jobs;
   HRESULT hr = FindBitsJobIf(
       std::bind2nd(JobFileUrlEqual(), base::SysUTF8ToWide(url.spec())),
       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(
-      kJobDescription, BG_JOB_TYPE_DOWNLOAD, &guid, job.Receive());
+  hr = bits_manager_->CreateJob(kJobDescription, BG_JOB_TYPE_DOWNLOAD, &guid,
+                                job.Receive());
   if (FAILED(hr))
     return hr;
 
   job_ = job;
   return S_OK;
 }
 
 HRESULT BackgroundDownloader::InitializeNewJob(const GURL& url) {
   const base::string16 filename(base::SysUTF8ToWide(url.ExtractFileName()));
 
@@ skipping 35 matching lines @@
   const base::TimeDelta job_stuck_timeout(
       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;
+  std::vector<ScopedComPtr<IBackgroundCopyFile>> 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);
   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
+}  // namespace update_client