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/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/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
+// client. For every url to download, a BITS job is created, unless there is
+// already an existing job for that url, in which case, the downloader
+// connects to it. Once a job is associated with the url, the code looks for
+// changes in the BITS job state. The checks are triggered by a timer.
+// The BITS job contains just one file to download. There could only be one
+// download in progress at a time. If Chrome closes down before the download is
+// complete, the BITS job remains active and finishes in the background, without
+// any intervention. The job can be completed next time the code runs, if the
+// file is still needed, otherwise it will be cleaned up on a periodic basis.
+//
+// To list the BITS jobs for a user, use the |bitsadmin| tool. The command line
+// to do that is: "bitsadmin /list /verbose". Another useful command is
+// "bitsadmin /info" and provide the job id returned by the previous /list
+// command.
+//
+// Ignoring the suspend/resume issues since this code is not using them, the
+// job state machine implemented by BITS is something like this:
+//
+//  Suspended--->Queued--->Connecting---->Transferring--->Transferred
+//       |          ^         |                 |               |
+//       |          |         V                 V               | (complete)
+//       +----------|---------+-----------------+-----+         V
+//                  |         |                 |     |    Acknowledged
+//                  |         V                 V     |
+//                  |  Transient Error------->Error   |
+//                  |         |                 |     |(cancel)
+//                  |         +-------+---------+--->-+
+//                  |                 V               |
+//                  |   (resume)      |               |
+//                  +------<----------+               +---->Cancelled
+//
+// The job is created in the "suspended" state. Once |Resume| is called,
+// BITS queues up the job, then tries to connect, begins transferring the
+// job bytes, and moves the job to the "transferred state, after the job files
+// have been transferred. When calling |Complete| for a job, the job files are
+// made available to the caller, and the job is moved to the "acknowledged"
+// state.
+// At any point, the job can be cancelled, in which case, the job is moved
+// to the "cancelled state" and the job object is removed from the BITS queue.
+// Along the way, the job can encounter recoverable and non-recoverable errors.
+// BITS moves the job to "transient error" or "error", depending on which kind
+// of error has occured.
+// If  the job has reached the "transient error" state, BITS retries the
+// job after a certain programmable delay. If the job can't be completed in a
+// certain time interval, BITS stops retrying and errors the job out. This time
+// interval is also programmable.
+// If the job is in either of the error states, the job parameters can be
+// adjusted to handle the error, after which the job can be resumed, and the
+// whole cycle starts again.
+// Jobs that are not touched in 90 days (or a value set by group policy) are
+// automatically disposed off by BITS. This concludes the brief description of
+// a job lifetime, according to BITS.
+//
+// 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 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;
+
+// How long BITS waits before retrying a job after the job encountered
+// a transient error. If this value is not set, the BITS default is 10 minutes.
+const int kMinimumRetryDelayMin = 1;
+
+// How long to wait for stuck jobs. Stuck jobs could be queued for too long,
+// have trouble connecting, could be suspended for any reason, or they have
+// encountered some transient error.
+const int kJobStuckTimeoutMin = 15;
+
+// How long BITS waits before giving up on a job that could not be completed
+// since the job has encountered its first transient error. If this value is
+// not set, the BITS default is 14 days.
+const int kSetNoProgressTimeoutDays = 1;
+
+// How often the jobs which were started but not completed for any reason
+// are cleaned up. Reasons for jobs to be left behind include browser restarts,
+// system restarts, etc. Also, the check to purge stale jobs only happens
+// at most once a day. If the job clean up code is not running, the BITS
+// default policy is to cancel jobs after 90 days of inactivity.
+const int kPurgeStaleJobsAfterDays = 7;
+const int kPurgeStaleJobsIntervalBetweenChecksDays = 1;
+
+// 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 &&
+                  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) {
+  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;
+
+  for (ULONG i = 0; i != num_files; ++i) {
+    ScopedComPtr<IBackgroundCopyFile> 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,
+                             base::string16* remote_name,
+                             BG_FILE_PROGRESS* progress) {
+  if (!file)
+    return E_FAIL;
+
+  HRESULT hr = S_OK;
+
+  if (local_name) {
+    ScopedCoMem<base::char16> name;
+    hr = file->GetLocalName(&name);
+    if (FAILED(hr))
+      return hr;
+    local_name->assign(name);
+  }
+
+  if (remote_name) {
+    ScopedCoMem<base::char16> name;
+    hr = file->GetRemoteName(&name);
+    if (FAILED(hr))
+      return hr;
+    remote_name->assign(name);
+  }
+
+  if (progress) {
+    BG_FILE_PROGRESS bg_file_progress = {};
+    hr = file->GetProgress(&bg_file_progress);
+    if (FAILED(hr))
+      return hr;
+    *progress = bg_file_progress;
+  }
+
+  return hr;
+}
+
+// Returns the number of bytes downloaded and bytes to download for all files
+// in the job. If the values are not known or if an error has occurred,
+// a value of -1 is reported.
+HRESULT GetJobByteCount(IBackgroundCopyJob* job,
+                        int64_t* downloaded_bytes,
+                        int64_t* total_bytes) {
+  *downloaded_bytes = -1;
+  *total_bytes = -1;
+
+  if (!job)
+    return E_FAIL;
+
+  BG_JOB_PROGRESS job_progress = {0};
+  HRESULT hr = job->GetProgress(&job_progress);
+  if (FAILED(hr))
+    return hr;
+
+  const uint64_t kMaxNumBytes =
+      static_cast<uint64_t>(std::numeric_limits<int64_t>::max());
+  if (job_progress.BytesTransferred <= kMaxNumBytes)
+    *downloaded_bytes = job_progress.BytesTransferred;
+
+  if (job_progress.BytesTotal <= kMaxNumBytes &&
+      job_progress.BytesTotal != BG_SIZE_UNKNOWN)
+    *total_bytes = job_progress.BytesTotal;
+
+  return S_OK;
+}
+
+HRESULT GetJobDescription(IBackgroundCopyJob* job, const base::string16* name) {
+  ScopedCoMem<base::char16> description;
+  return job->GetDescription(&description);
+}
+
+// Returns the job error code in |error_code| if the job is in the transient
+// or the final error state. Otherwise, the job error is not available and
+// the function fails.
+HRESULT GetJobError(IBackgroundCopyJob* job, HRESULT* error_code_out) {
+  *error_code_out = S_OK;
+  ScopedComPtr<IBackgroundCopyError> copy_error;
+  HRESULT hr = job->GetError(copy_error.Receive());
+  if (FAILED(hr))
+    return hr;
+
+  BG_ERROR_CONTEXT error_context = BG_ERROR_CONTEXT_NONE;
+  HRESULT error_code = S_OK;
+  hr = copy_error->GetError(&error_context, &error_code);
+  if (FAILED(hr))
+    return hr;
+
+  *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) {
+  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;
+
+  // 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())) {
+      base::string16 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|.
+struct JobCreationOlderThanDays
+    : public std::binary_function<IBackgroundCopyJob*, int, bool> {
+  bool operator()(IBackgroundCopyJob* job, int num_days) const;
+};
+
+bool JobCreationOlderThanDays::operator()(IBackgroundCopyJob* job,
+                                          int num_days) const {
+  BG_JOB_TIMES times = {0};
+  HRESULT hr = job->GetTimes(&times);
+  if (FAILED(hr))
+    return false;
+
+  const base::TimeDelta time_delta(base::TimeDelta::FromDays(num_days));
+  const base::Time creation_time(base::Time::FromFileTime(times.CreationTime));
+
+  return creation_time + time_delta < base::Time::Now();
+}
+
+// Compares the url of a file in a job and returns true if the remote name
+// 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;
+  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;
+  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;
+  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());
+  }
+
+  return S_OK;
+}
+
+}  // namespace
+
+BackgroundDownloader::BackgroundDownloader(
+    scoped_ptr<CrxDownloader> successor,
+    net::URLRequestContextGetter* context_getter,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
+    : CrxDownloader(successor.Pass()),
+      main_task_runner_(base::MessageLoopProxy::current()),
+      context_getter_(context_getter),
+      task_runner_(task_runner),
+      is_completed_(false) {
+}
+
+BackgroundDownloader::~BackgroundDownloader() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  // The following objects have thread affinity and can't be destroyed on the
+  // main thread. The resources managed by these objects are acquired at the
+  // beginning of a download and released at the end of the download. Most of
+  // the time, when this destructor is called, these resources have been already
+  // disposed by. Releasing the ownership here is a NOP. However, if the browser
+  // is shutting down while a download is in progress, the timer is active and
+  // 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));
+}
+
+// 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);
+}
+
+// Called any time the timer fires.
+void BackgroundDownloader::OnDownloading() {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
+  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;
+  }
+
+  switch (job_state) {
+    case BG_JOB_STATE_TRANSFERRED:
+      OnStateTransferred();
+      return;
+
+    case BG_JOB_STATE_ERROR:
+      OnStateError();
+      return;
+
+    case BG_JOB_STATE_CANCELLED:
+      OnStateCancelled();
+      return;
+
+    case BG_JOB_STATE_ACKNOWLEDGED:
+      OnStateAcknowledged();
+      return;
+
+    case BG_JOB_STATE_QUEUED:
+    // Fall through.
+    case BG_JOB_STATE_CONNECTING:
+    // Fall through.
+    case BG_JOB_STATE_SUSPENDED:
+      OnStateQueued();
+      break;
+
+    case BG_JOB_STATE_TRANSIENT_ERROR:
+      OnStateTransientError();
+      break;
+
+    case BG_JOB_STATE_TRANSFERRING:
+      OnStateTransferring();
+      break;
+
+    default:
+      break;
+  }
+}
+
+// Completes the BITS download, picks up the file path of the response, and
+// notifies the CrxDownloader. The function should be called only once.
+void BackgroundDownloader::EndDownload(HRESULT error) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
+  DCHECK(!is_completed_);
+  is_completed_ = true;
+
+  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_.get(), &downloaded_bytes, &total_bytes);
+
+  if (FAILED(error) && job_.get()) {
+    job_->Cancel();
+    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 =
+      SUCCEEDED(error) || IsHttpServerError(GetHttpStatusFromBitsError(error));
+
+  const int error_to_report = SUCCEEDED(error) ? 0 : error;
+
+  DownloadMetrics download_metrics;
+  download_metrics.url = url();
+  download_metrics.downloader = DownloadMetrics::kBits;
+  download_metrics.error = error_to_report;
+  download_metrics.downloaded_bytes = downloaded_bytes;
+  download_metrics.total_bytes = total_bytes;
+  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));
+
+  // 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.
+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_.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_.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_.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));
+}
+
+// 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() {
+  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_.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_.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());
+  if (FAILED(hr))
+    return hr;
+
+  job_ = job;
+  return S_OK;
+}
+
+HRESULT BackgroundDownloader::InitializeNewJob(const GURL& url) {
+  const base::string16 filename(base::SysUTF8ToWide(url.ExtractFileName()));
+
+  base::FilePath tempdir;
+  if (!base::CreateNewTempDirectory(FILE_PATH_LITERAL("chrome_BITS_"),
+                                    &tempdir))
+    return E_FAIL;
+
+  HRESULT hr = job_->AddFile(base::SysUTF8ToWide(url.spec()).c_str(),
+                             tempdir.Append(filename).AsUTF16Unsafe().c_str());
+  if (FAILED(hr))
+    return hr;
+
+  hr = job_->SetDisplayName(filename.c_str());
+  if (FAILED(hr))
+    return hr;
+
+  hr = job_->SetDescription(kJobDescription);
+  if (FAILED(hr))
+    return hr;
+
+  hr = job_->SetPriority(BG_JOB_PRIORITY_NORMAL);
+  if (FAILED(hr))
+    return hr;
+
+  hr = job_->SetMinimumRetryDelay(60 * kMinimumRetryDelayMin);
+  if (FAILED(hr))
+    return hr;
+
+  const int kSecondsDay = 60 * 60 * 24;
+  hr = job_->SetNoProgressTimeout(kSecondsDay * kSetNoProgressTimeoutDays);
+  if (FAILED(hr))
+    return hr;
+
+  return S_OK;
+}
+
+bool BackgroundDownloader::IsStuck() {
+  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;
+  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 update_client