src/components/component_updater/background_downloader_win.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/component_updater/background_downloader_win.h"
   6
   7 #include <atlbase.h>
   8 #include <atlcom.h>
   9
  10 #include <stdint.h>
  11 #include <functional>
  12 #include <iomanip>
  13 #include <limits>
  14 #include <vector>
  15
  16 #include "base/bind.h"
  17 #include "base/bind_helpers.h"
  18 #include "base/files/file_util.h"
  19 #include "base/message_loop/message_loop_proxy.h"
  20 #include "base/single_thread_task_runner.h"
  21 #include "base/strings/sys_string_conversions.h"
  22 #include "base/win/scoped_co_mem.h"
  23 #include "components/component_updater/component_updater_utils.h"
  24 #include "ui/base/win/atl_module.h"
  25 #include "url/gurl.h"
  26
  27 using base::win::ScopedCoMem;
  28 using base::win::ScopedComPtr;
  29
  30 // The class BackgroundDownloader in this module is an adapter between
  31 // the CrxDownloader interface and the BITS service interfaces.
  32 // The interface exposed on the CrxDownloader code runs on the main thread,
  33 // while the BITS specific code runs on a separate thread passed in by the
  34 // client. For every url to download, a BITS job is created, unless there is
  35 // already an existing job for that url, in which case, the downloader
  36 // connects to it. Once a job is associated with the url, the code looks for
  37 // changes in the BITS job state. The checks are triggered by a timer.
  38 // The BITS job contains just one file to download. There could only be one
  39 // download in progress at a time. If Chrome closes down before the download is
  40 // complete, the BITS job remains active and finishes in the background, without
  41 // any intervention. The job can be completed next time the code runs, if the
  42 // file is still needed, otherwise it will be cleaned up on a periodic basis.
  43 //
  44 // To list the BITS jobs for a user, use the |bitsadmin| tool. The command line
  45 // to do that is: "bitsadmin /list /verbose". Another useful command is
  46 // "bitsadmin /info" and provide the job id returned by the previous /list
  47 // command.
  48 //
  49 // Ignoring the suspend/resume issues since this code is not using them, the
  50 // job state machine implemented by BITS is something like this:
  51 //
  52 //  Suspended--->Queued--->Connecting---->Transferring--->Transferred
  53 //       |          ^         |                 |               |
  54 //       |          |         V                 V               | (complete)
  55 //       +----------|---------+-----------------+-----+         V
  56 //                  |         |                 |     |    Acknowledged
  57 //                  |         V                 V     |
  58 //                  |  Transient Error------->Error   |
  59 //                  |         |                 |     |(cancel)
  60 //                  |         +-------+---------+--->-+
  61 //                  |                 V               |
  62 //                  |   (resume)      |               |
  63 //                  +------<----------+               +---->Cancelled
  64 //
  65 // The job is created in the "suspended" state. Once |Resume| is called,
  66 // BITS queues up the job, then tries to connect, begins transferring the
  67 // job bytes, and moves the job to the "transferred state, after the job files
  68 // have been transferred. When calling |Complete| for a job, the job files are
  69 // made available to the caller, and the job is moved to the "acknowledged"
  70 // state.
  71 // At any point, the job can be cancelled, in which case, the job is moved
  72 // to the "cancelled state" and the job object is removed from the BITS queue.
  73 // Along the way, the job can encounter recoverable and non-recoverable errors.
  74 // BITS moves the job to "transient error" or "error", depending on which kind
  75 // of error has occured.
  76 // If  the job has reached the "transient error" state, BITS retries the
  77 // job after a certain programmable delay. If the job can't be completed in a
  78 // certain time interval, BITS stops retrying and errors the job out. This time
  79 // interval is also programmable.
  80 // If the job is in either of the error states, the job parameters can be
  81 // adjusted to handle the error, after which the job can be resumed, and the
  82 // whole cycle starts again.
  83 // Jobs that are not touched in 90 days (or a value set by group policy) are
  84 // automatically disposed off by BITS. This concludes the brief description of
  85 // a job lifetime, according to BITS.
  86 //
  87 // In addition to how BITS is managing the life time of the job, there are a
  88 // couple of special cases defined by the BackgroundDownloader.
  89 // First, if the job encounters any of the 5xx HTTP responses, the job is
  90 // not retried, in order to avoid DDOS-ing the servers.
  91 // Second, there is a simple mechanism to detect stuck jobs, and allow the rest
  92 // of the code to move on to trying other urls or trying other components.
  93 // Last, after completing a job, irrespective of the outcome, the jobs older
  94 // than a week are proactively cleaned up.
  95
  96 namespace component_updater {
  97
  98 namespace {
  99
 100 // All jobs created by this module have a specific description so they can
 101 // be found at run-time or by using system administration tools.
 102 const base::char16 kJobDescription[] = L"Chrome Component Updater";
 103
 104 // How often the code looks for changes in the BITS job state.
 105 const int kJobPollingIntervalSec = 4;
 106
 107 // How long BITS waits before retrying a job after the job encountered
 108 // a transient error. If this value is not set, the BITS default is 10 minutes.
 109 const int kMinimumRetryDelayMin = 1;
 110
 111 // How long to wait for stuck jobs. Stuck jobs could be queued for too long,
 112 // have trouble connecting, could be suspended for any reason, or they have
 113 // encountered some transient error.
 114 const int kJobStuckTimeoutMin = 15;
 115
 116 // How long BITS waits before giving up on a job that could not be completed
 117 // since the job has encountered its first transient error. If this value is
 118 // not set, the BITS default is 14 days.
 119 const int kSetNoProgressTimeoutDays = 1;
 120
 121 // How often the jobs which were started but not completed for any reason
 122 // are cleaned up. Reasons for jobs to be left behind include browser restarts,
 123 // system restarts, etc. Also, the check to purge stale jobs only happens
 124 // at most once a day. If the job clean up code is not running, the BITS
 125 // default policy is to cancel jobs after 90 days of inactivity.
 126 const int kPurgeStaleJobsAfterDays = 7;
 127 const int kPurgeStaleJobsIntervalBetweenChecksDays = 1;
 128
 129 // Returns the status code from a given BITS error.
 130 int GetHttpStatusFromBitsError(HRESULT error) {
 131   // BITS errors are defined in bitsmsg.h. Although not documented, it is
 132   // clear that all errors corresponding to http status code have the high
 133   // word equal to 0x8019 and the low word equal to the http status code.
 134   const int kHttpStatusFirst = 100;  // Continue.
 135   const int kHttpStatusLast = 505;   // Version not supported.
 136   bool is_valid = HIWORD(error) == 0x8019 &&
 137                   LOWORD(error) >= kHttpStatusFirst &&
 138                   LOWORD(error) <= kHttpStatusLast;
 139   return is_valid ? LOWORD(error) : 0;
 140 }
 141
 142 // Returns the files in a BITS job.
 143 HRESULT GetFilesInJob(IBackgroundCopyJob* job,
 144                       std::vector<ScopedComPtr<IBackgroundCopyFile> >* files) {
 145   ScopedComPtr<IEnumBackgroundCopyFiles> enum_files;
 146   HRESULT hr = job->EnumFiles(enum_files.Receive());
 147   if (FAILED(hr))
 148     return hr;
 149
 150   ULONG num_files = 0;
 151   hr = enum_files->GetCount(&num_files);
 152   if (FAILED(hr))
 153     return hr;
 154
 155   for (ULONG i = 0; i != num_files; ++i) {
 156     ScopedComPtr<IBackgroundCopyFile> file;
 157     if (enum_files->Next(1, file.Receive(), NULL) == S_OK && file)
 158       files->push_back(file);
 159   }
 160
 161   return S_OK;
 162 }
 163
 164 // Returns the file name, the url, and some per-file progress information.
 165 // The function out parameters can be NULL if that data is not requested.
 166 HRESULT GetJobFileProperties(IBackgroundCopyFile* file,
 167                              base::string16* local_name,
 168                              base::string16* remote_name,
 169                              BG_FILE_PROGRESS* progress) {
 170   if (!file)
 171     return E_FAIL;
 172
 173   HRESULT hr = S_OK;
 174
 175   if (local_name) {
 176     ScopedCoMem<base::char16> name;
 177     hr = file->GetLocalName(&name);
 178     if (FAILED(hr))
 179       return hr;
 180     local_name->assign(name);
 181   }
 182
 183   if (remote_name) {
 184     ScopedCoMem<base::char16> name;
 185     hr = file->GetRemoteName(&name);
 186     if (FAILED(hr))
 187       return hr;
 188     remote_name->assign(name);
 189   }
 190
 191   if (progress) {
 192     BG_FILE_PROGRESS bg_file_progress = {};
 193     hr = file->GetProgress(&bg_file_progress);
 194     if (FAILED(hr))
 195       return hr;
 196     *progress = bg_file_progress;
 197   }
 198
 199   return hr;
 200 }
 201
 202 // Returns the number of bytes downloaded and bytes to download for all files
 203 // in the job. If the values are not known or if an error has occurred,
 204 // a value of -1 is reported.
 205 HRESULT GetJobByteCount(IBackgroundCopyJob* job,
 206                         int64_t* downloaded_bytes,
 207                         int64_t* total_bytes) {
 208   *downloaded_bytes = -1;
 209   *total_bytes = -1;
 210
 211   if (!job)
 212     return E_FAIL;
 213
 214   BG_JOB_PROGRESS job_progress = {0};
 215   HRESULT hr = job->GetProgress(&job_progress);
 216   if (FAILED(hr))
 217     return hr;
 218
 219   const uint64_t kMaxNumBytes =
 220       static_cast<uint64_t>(std::numeric_limits<int64_t>::max());
 221   if (job_progress.BytesTransferred <= kMaxNumBytes)
 222     *downloaded_bytes = job_progress.BytesTransferred;
 223
 224   if (job_progress.BytesTotal <= kMaxNumBytes &&
 225       job_progress.BytesTotal != BG_SIZE_UNKNOWN)
 226     *total_bytes = job_progress.BytesTotal;
 227
 228   return S_OK;
 229 }
 230
 231 HRESULT GetJobDescription(IBackgroundCopyJob* job, const base::string16* name) {
 232   ScopedCoMem<base::char16> description;
 233   return job->GetDescription(&description);
 234 }
 235
 236 // Returns the job error code in |error_code| if the job is in the transient
 237 // or the final error state. Otherwise, the job error is not available and
 238 // the function fails.
 239 HRESULT GetJobError(IBackgroundCopyJob* job, HRESULT* error_code_out) {
 240   *error_code_out = S_OK;
 241   ScopedComPtr<IBackgroundCopyError> copy_error;
 242   HRESULT hr = job->GetError(copy_error.Receive());
 243   if (FAILED(hr))
 244     return hr;
 245
 246   BG_ERROR_CONTEXT error_context = BG_ERROR_CONTEXT_NONE;
 247   HRESULT error_code = S_OK;
 248   hr = copy_error->GetError(&error_context, &error_code);
 249   if (FAILED(hr))
 250     return hr;
 251
 252   *error_code_out = FAILED(error_code) ? error_code : E_FAIL;
 253   return S_OK;
 254 }
 255
 256 // Finds the component updater jobs matching the given predicate.
 257 // Returns S_OK if the function has found at least one job, returns S_FALSE if
 258 // no job was found, and it returns an error otherwise.
 259 template <class Predicate>
 260 HRESULT FindBitsJobIf(Predicate pred,
 261                       IBackgroundCopyManager* bits_manager,
 262                       std::vector<ScopedComPtr<IBackgroundCopyJob> >* jobs) {
 263   ScopedComPtr<IEnumBackgroundCopyJobs> enum_jobs;
 264   HRESULT hr = bits_manager->EnumJobs(0, enum_jobs.Receive());
 265   if (FAILED(hr))
 266     return hr;
 267
 268   ULONG job_count = 0;
 269   hr = enum_jobs->GetCount(&job_count);
 270   if (FAILED(hr))
 271     return hr;
 272
 273   // Iterate over jobs, run the predicate, and select the job only if
 274   // the job description matches the component updater jobs.
 275   for (ULONG i = 0; i != job_count; ++i) {
 276     ScopedComPtr<IBackgroundCopyJob> current_job;
 277     if (enum_jobs->Next(1, current_job.Receive(), NULL) == S_OK &&
 278         pred(current_job)) {
 279       base::string16 job_description;
 280       hr = GetJobDescription(current_job, &job_description);
 281       if (job_description.compare(kJobDescription) == 0)
 282         jobs->push_back(current_job);
 283     }
 284   }
 285
 286   return jobs->empty() ? S_FALSE : S_OK;
 287 }
 288
 289 // Compares the job creation time and returns true if the job creation time
 290 // is older than |num_days|.
 291 struct JobCreationOlderThanDays
 292     : public std::binary_function<IBackgroundCopyJob*, int, bool> {
 293   bool operator()(IBackgroundCopyJob* job, int num_days) const;
 294 };
 295
 296 bool JobCreationOlderThanDays::operator()(IBackgroundCopyJob* job,
 297                                           int num_days) const {
 298   BG_JOB_TIMES times = {0};
 299   HRESULT hr = job->GetTimes(&times);
 300   if (FAILED(hr))
 301     return false;
 302
 303   const base::TimeDelta time_delta(base::TimeDelta::FromDays(num_days));
 304   const base::Time creation_time(base::Time::FromFileTime(times.CreationTime));
 305
 306   return creation_time + time_delta < base::Time::Now();
 307 }
 308
 309 // Compares the url of a file in a job and returns true if the remote name
 310 // of any file in a job matches the argument.
 311 struct JobFileUrlEqual : public std::binary_function<IBackgroundCopyJob*,
 312                                                      const base::string16&,
 313                                                      bool> {
 314   bool operator()(IBackgroundCopyJob* job,
 315                   const base::string16& remote_name) const;
 316 };
 317
 318 bool JobFileUrlEqual::operator()(IBackgroundCopyJob* job,
 319                                  const base::string16& remote_name) const {
 320   std::vector<ScopedComPtr<IBackgroundCopyFile> > files;
 321   HRESULT hr = GetFilesInJob(job, &files);
 322   if (FAILED(hr))
 323     return false;
 324
 325   for (size_t i = 0; i != files.size(); ++i) {
 326     ScopedCoMem<base::char16> name;
 327     if (SUCCEEDED(files[i]->GetRemoteName(&name)) &&
 328         remote_name.compare(name) == 0)
 329       return true;
 330   }
 331
 332   return false;
 333 }
 334
 335 // Creates an instance of the BITS manager.
 336 HRESULT GetBitsManager(IBackgroundCopyManager** bits_manager) {
 337   ScopedComPtr<IBackgroundCopyManager> object;
 338   HRESULT hr = object.CreateInstance(__uuidof(BackgroundCopyManager));
 339   if (FAILED(hr)) {
 340     return hr;
 341   }
 342   *bits_manager = object.Detach();
 343   return S_OK;
 344 }
 345
 346 void CleanupJobFiles(IBackgroundCopyJob* job) {
 347   std::vector<ScopedComPtr<IBackgroundCopyFile> > files;
 348   if (FAILED(GetFilesInJob(job, &files)))
 349     return;
 350   for (size_t i = 0; i != files.size(); ++i) {
 351     base::string16 local_name;
 352     HRESULT hr(GetJobFileProperties(files[i], &local_name, NULL, NULL));
 353     if (SUCCEEDED(hr))
 354       DeleteFileAndEmptyParentDirectory(base::FilePath(local_name));
 355   }
 356 }
 357
 358 // Cleans up incompleted jobs that are too old.
 359 HRESULT CleanupStaleJobs(
 360     base::win::ScopedComPtr<IBackgroundCopyManager> bits_manager) {
 361   if (!bits_manager)
 362     return E_FAIL;
 363
 364   static base::Time last_sweep;
 365
 366   const base::TimeDelta time_delta(
 367       base::TimeDelta::FromDays(kPurgeStaleJobsIntervalBetweenChecksDays));
 368   const base::Time current_time(base::Time::Now());
 369   if (last_sweep + time_delta > current_time)
 370     return S_OK;
 371
 372   last_sweep = current_time;
 373
 374   std::vector<ScopedComPtr<IBackgroundCopyJob> > jobs;
 375   HRESULT hr = FindBitsJobIf(
 376       std::bind2nd(JobCreationOlderThanDays(), kPurgeStaleJobsAfterDays),
 377       bits_manager,
 378       &jobs);
 379   if (FAILED(hr))
 380     return hr;
 381
 382   for (size_t i = 0; i != jobs.size(); ++i) {
 383     jobs[i]->Cancel();
 384     CleanupJobFiles(jobs[i]);
 385   }
 386
 387   return S_OK;
 388 }
 389
 390 }  // namespace
 391
 392 BackgroundDownloader::BackgroundDownloader(
 393     scoped_ptr<CrxDownloader> successor,
 394     net::URLRequestContextGetter* context_getter,
 395     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
 396     : CrxDownloader(successor.Pass()),
 397       main_task_runner_(base::MessageLoopProxy::current()),
 398       context_getter_(context_getter),
 399       task_runner_(task_runner),
 400       is_completed_(false) {
 401 }
 402
 403 BackgroundDownloader::~BackgroundDownloader() {
 404   DCHECK(thread_checker_.CalledOnValidThread());
 405
 406   // The following objects have thread affinity and can't be destroyed on the
 407   // main thread. The resources managed by these objects are acquired at the
 408   // beginning of a download and released at the end of the download. Most of
 409   // the time, when this destructor is called, these resources have been already
 410   // disposed by. Releasing the ownership here is a NOP. However, if the browser
 411   // is shutting down while a download is in progress, the timer is active and
 412   // the interface pointers are valid. Releasing the ownership means leaking
 413   // these objects and their associated resources.
 414   timer_.release();
 415   bits_manager_.Detach();
 416   job_.Detach();
 417 }
 418
 419 void BackgroundDownloader::DoStartDownload(const GURL& url) {
 420   DCHECK(thread_checker_.CalledOnValidThread());
 421
 422   task_runner_->PostTask(
 423       FROM_HERE,
 424       base::Bind(
 425           &BackgroundDownloader::BeginDownload, base::Unretained(this), url));
 426 }
 427
 428 // Called once when this class is asked to do a download. Creates or opens
 429 // an existing bits job, hooks up the notifications, and starts the timer.
 430 void BackgroundDownloader::BeginDownload(const GURL& url) {
 431   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 432
 433   DCHECK(!timer_);
 434
 435   is_completed_ = false;
 436   download_start_time_ = base::Time::Now();
 437   job_stuck_begin_time_ = download_start_time_;
 438
 439   HRESULT hr = QueueBitsJob(url);
 440   if (FAILED(hr)) {
 441     EndDownload(hr);
 442     return;
 443   }
 444
 445   // A repeating timer retains the user task. This timer can be stopped and
 446   // reset multiple times.
 447   timer_.reset(new base::RepeatingTimer<BackgroundDownloader>);
 448   timer_->Start(FROM_HERE,
 449                 base::TimeDelta::FromSeconds(kJobPollingIntervalSec),
 450                 this,
 451                 &BackgroundDownloader::OnDownloading);
 452 }
 453
 454 // Called any time the timer fires.
 455 void BackgroundDownloader::OnDownloading() {
 456   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 457
 458   DCHECK(job_);
 459
 460   DCHECK(!is_completed_);
 461   if (is_completed_)
 462     return;
 463
 464   BG_JOB_STATE job_state = BG_JOB_STATE_ERROR;
 465   HRESULT hr = job_->GetState(&job_state);
 466   if (FAILED(hr)) {
 467     EndDownload(hr);
 468     return;
 469   }
 470
 471   switch (job_state) {
 472     case BG_JOB_STATE_TRANSFERRED:
 473       OnStateTransferred();
 474       return;
 475
 476     case BG_JOB_STATE_ERROR:
 477       OnStateError();
 478       return;
 479
 480     case BG_JOB_STATE_CANCELLED:
 481       OnStateCancelled();
 482       return;
 483
 484     case BG_JOB_STATE_ACKNOWLEDGED:
 485       OnStateAcknowledged();
 486       return;
 487
 488     case BG_JOB_STATE_QUEUED:
 489     // Fall through.
 490     case BG_JOB_STATE_CONNECTING:
 491     // Fall through.
 492     case BG_JOB_STATE_SUSPENDED:
 493       OnStateQueued();
 494       break;
 495
 496     case BG_JOB_STATE_TRANSIENT_ERROR:
 497       OnStateTransientError();
 498       break;
 499
 500     case BG_JOB_STATE_TRANSFERRING:
 501       OnStateTransferring();
 502       break;
 503
 504     default:
 505       break;
 506   }
 507 }
 508
 509 // Completes the BITS download, picks up the file path of the response, and
 510 // notifies the CrxDownloader. The function should be called only once.
 511 void BackgroundDownloader::EndDownload(HRESULT error) {
 512   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 513
 514   DCHECK(!is_completed_);
 515   is_completed_ = true;
 516
 517   timer_.reset();
 518
 519   const base::Time download_end_time(base::Time::Now());
 520   const base::TimeDelta download_time =
 521       download_end_time >= download_start_time_
 522           ? download_end_time - download_start_time_
 523           : base::TimeDelta();
 524
 525   int64_t downloaded_bytes = -1;
 526   int64_t total_bytes = -1;
 527   GetJobByteCount(job_, &downloaded_bytes, &total_bytes);
 528
 529   if (FAILED(error) && job_) {
 530     job_->Cancel();
 531     CleanupJobFiles(job_);
 532   }
 533
 534   job_ = NULL;
 535
 536   CleanupStaleJobs(bits_manager_);
 537   bits_manager_ = NULL;
 538
 539   // Consider the url handled if it has been successfully downloaded or a
 540   // 5xx has been received.
 541   const bool is_handled =
 542       SUCCEEDED(error) || IsHttpServerError(GetHttpStatusFromBitsError(error));
 543
 544   const int error_to_report = SUCCEEDED(error) ? 0 : error;
 545
 546   DownloadMetrics download_metrics;
 547   download_metrics.url = url();
 548   download_metrics.downloader = DownloadMetrics::kBits;
 549   download_metrics.error = error_to_report;
 550   download_metrics.downloaded_bytes = downloaded_bytes;
 551   download_metrics.total_bytes = total_bytes;
 552   download_metrics.download_time_ms = download_time.InMilliseconds();
 553
 554   Result result;
 555   result.error = error_to_report;
 556   result.response = response_;
 557   result.downloaded_bytes = downloaded_bytes;
 558   result.total_bytes = total_bytes;
 559   main_task_runner_->PostTask(
 560       FROM_HERE,
 561       base::Bind(&BackgroundDownloader::OnDownloadComplete,
 562                  base::Unretained(this),
 563                  is_handled,
 564                  result,
 565                  download_metrics));
 566
 567   // Once the task is posted to the the main thread, this object may be deleted
 568   // by its owner. It is not safe to access members of this object on the
 569   // task runner from this point on. The timer is stopped and all BITS
 570   // interface pointers have been released.
 571 }
 572
 573 // Called when the BITS job has been transferred successfully. Completes the
 574 // BITS job by removing it from the BITS queue and making the download
 575 // available to the caller.
 576 void BackgroundDownloader::OnStateTransferred() {
 577   EndDownload(CompleteJob());
 578 }
 579
 580 // Called when the job has encountered an error and no further progress can
 581 // be made. Cancels this job and removes it from the BITS queue.
 582 void BackgroundDownloader::OnStateError() {
 583   HRESULT error_code = S_OK;
 584   HRESULT hr = GetJobError(job_, &error_code);
 585   if (FAILED(hr))
 586     error_code = hr;
 587   DCHECK(FAILED(error_code));
 588   EndDownload(error_code);
 589 }
 590
 591 // Called when the job has encountered a transient error, such as a
 592 // network disconnect, a server error, or some other recoverable error.
 593 void BackgroundDownloader::OnStateTransientError() {
 594   // If the job appears to be stuck, handle the transient error as if
 595   // it were a final error. This causes the job to be cancelled and a specific
 596   // error be returned, if the error was available.
 597   if (IsStuck()) {
 598     OnStateError();
 599     return;
 600   }
 601
 602   // Don't retry at all if the transient error was a 5xx.
 603   HRESULT error_code = S_OK;
 604   HRESULT hr = GetJobError(job_, &error_code);
 605   if (SUCCEEDED(hr) &&
 606       IsHttpServerError(GetHttpStatusFromBitsError(error_code))) {
 607     OnStateError();
 608     return;
 609   }
 610 }
 611
 612 void BackgroundDownloader::OnStateQueued() {
 613   if (IsStuck())
 614     EndDownload(E_ABORT);  // Return a generic error for now.
 615 }
 616
 617 void BackgroundDownloader::OnStateTransferring() {
 618   // Resets the baseline for detecting a stuck job since the job is transferring
 619   // data and it is making progress.
 620   job_stuck_begin_time_ = base::Time::Now();
 621
 622   int64_t downloaded_bytes = -1;
 623   int64_t total_bytes = -1;
 624   HRESULT hr = GetJobByteCount(job_, &downloaded_bytes, &total_bytes);
 625   if (FAILED(hr))
 626     return;
 627
 628   Result result;
 629   result.downloaded_bytes = downloaded_bytes;
 630   result.total_bytes = total_bytes;
 631
 632   main_task_runner_->PostTask(
 633       FROM_HERE,
 634       base::Bind(&BackgroundDownloader::OnDownloadProgress,
 635                  base::Unretained(this),
 636                  result));
 637 }
 638
 639 // Called when the download was cancelled. Since the observer should have
 640 // been disconnected by now, this notification must not be seen.
 641 void BackgroundDownloader::OnStateCancelled() {
 642   EndDownload(E_UNEXPECTED);
 643 }
 644
 645 // Called when the download was completed. Same as above.
 646 void BackgroundDownloader::OnStateAcknowledged() {
 647   EndDownload(E_UNEXPECTED);
 648 }
 649
 650 // Creates or opens a job for the given url and queues it up. Tries to
 651 // install a job observer but continues on if an observer can't be set up.
 652 HRESULT BackgroundDownloader::QueueBitsJob(const GURL& url) {
 653   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 654
 655   HRESULT hr = S_OK;
 656   if (bits_manager_ == NULL) {
 657     hr = GetBitsManager(bits_manager_.Receive());
 658     if (FAILED(hr))
 659       return hr;
 660   }
 661
 662   hr = CreateOrOpenJob(url);
 663   if (FAILED(hr))
 664     return hr;
 665
 666   if (hr == S_OK) {
 667     hr = InitializeNewJob(url);
 668     if (FAILED(hr))
 669       return hr;
 670   }
 671
 672   return job_->Resume();
 673 }
 674
 675 HRESULT BackgroundDownloader::CreateOrOpenJob(const GURL& url) {
 676   std::vector<ScopedComPtr<IBackgroundCopyJob> > jobs;
 677   HRESULT hr = FindBitsJobIf(
 678       std::bind2nd(JobFileUrlEqual(), base::SysUTF8ToWide(url.spec())),
 679       bits_manager_,
 680       &jobs);
 681   if (SUCCEEDED(hr) && !jobs.empty()) {
 682     job_ = jobs.front();
 683     return S_FALSE;
 684   }
 685
 686   // Use kJobDescription as a temporary job display name until the proper
 687   // display name is initialized later on.
 688   GUID guid = {0};
 689   ScopedComPtr<IBackgroundCopyJob> job;
 690   hr = bits_manager_->CreateJob(
 691       kJobDescription, BG_JOB_TYPE_DOWNLOAD, &guid, job.Receive());
 692   if (FAILED(hr))
 693     return hr;
 694
 695   job_ = job;
 696   return S_OK;
 697 }
 698
 699 HRESULT BackgroundDownloader::InitializeNewJob(const GURL& url) {
 700   const base::string16 filename(base::SysUTF8ToWide(url.ExtractFileName()));
 701
 702   base::FilePath tempdir;
 703   if (!base::CreateNewTempDirectory(FILE_PATH_LITERAL("chrome_BITS_"),
 704                                     &tempdir))
 705     return E_FAIL;
 706
 707   HRESULT hr = job_->AddFile(base::SysUTF8ToWide(url.spec()).c_str(),
 708                              tempdir.Append(filename).AsUTF16Unsafe().c_str());
 709   if (FAILED(hr))
 710     return hr;
 711
 712   hr = job_->SetDisplayName(filename.c_str());
 713   if (FAILED(hr))
 714     return hr;
 715
 716   hr = job_->SetDescription(kJobDescription);
 717   if (FAILED(hr))
 718     return hr;
 719
 720   hr = job_->SetPriority(BG_JOB_PRIORITY_NORMAL);
 721   if (FAILED(hr))
 722     return hr;
 723
 724   hr = job_->SetMinimumRetryDelay(60 * kMinimumRetryDelayMin);
 725   if (FAILED(hr))
 726     return hr;
 727
 728   const int kSecondsDay = 60 * 60 * 24;
 729   hr = job_->SetNoProgressTimeout(kSecondsDay * kSetNoProgressTimeoutDays);
 730   if (FAILED(hr))
 731     return hr;
 732
 733   return S_OK;
 734 }
 735
 736 bool BackgroundDownloader::IsStuck() {
 737   const base::TimeDelta job_stuck_timeout(
 738       base::TimeDelta::FromMinutes(kJobStuckTimeoutMin));
 739   return job_stuck_begin_time_ + job_stuck_timeout < base::Time::Now();
 740 }
 741
 742 HRESULT BackgroundDownloader::CompleteJob() {
 743   HRESULT hr = job_->Complete();
 744   if (FAILED(hr) && hr != BG_S_UNABLE_TO_DELETE_FILES)
 745     return hr;
 746
 747   std::vector<ScopedComPtr<IBackgroundCopyFile> > files;
 748   hr = GetFilesInJob(job_, &files);
 749   if (FAILED(hr))
 750     return hr;
 751
 752   if (files.empty())
 753     return E_UNEXPECTED;
 754
 755   base::string16 local_name;
 756   BG_FILE_PROGRESS progress = {0};
 757   hr = GetJobFileProperties(files.front(), &local_name, NULL, &progress);
 758   if (FAILED(hr))
 759     return hr;
 760
 761   // Sanity check the post-conditions of a successful download, including
 762   // the file and job invariants. The byte counts for a job and its file
 763   // must match as a job only contains one file.
 764   DCHECK(progress.Completed);
 765   DCHECK_EQ(progress.BytesTotal, progress.BytesTransferred);
 766
 767   response_ = base::FilePath(local_name);
 768
 769   return S_OK;
 770 }
 771
 772 }  // namespace component_updater