Implement a background downloader using BITS in Windows Chrome.

chrome/browser/component_updater/component_updater_service.cc

 // Copyright (c) 2012 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 "chrome/browser/component_updater/component_updater_service.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 244 matching lines @@
   enum StepDelayInterval {
     kStepDelayShort = 0,
     kStepDelayMedium,
     kStepDelayLong,
   };
 
   void OnParseUpdateResponseSucceeded(
       const component_updater::UpdateResponse::Results& results);
   void OnParseUpdateResponseFailed(const std::string& error_message);
 
-  void DownloadComplete(scoped_ptr<CRXContext> crx_context,
-                        int error,
-                        const base::FilePath& response);
+  void DownloadComplete(
+      scoped_ptr<CRXContext> crx_context,
+      const component_updater::CrxDownloader::Result& download_result);
 
   Status OnDemandUpdateInternal(CrxUpdateItem* item);
 
   void ProcessPendingItems();
 
   CrxUpdateItem* FindReadyComponent();
 
   void UpdateComponent(CrxUpdateItem* workitem);
 
   void AddItemToUpdateCheck(CrxUpdateItem* item,
@@ skipping 387 matching lines @@
   crx_context->installer = workitem->component.installer;
   crx_context->fingerprint = workitem->next_fp;
   GURL package_url;
   if (CanTryDiffUpdate(workitem, *config_)) {
     package_url = workitem->diff_crx_url;
     ChangeItemState(workitem, CrxUpdateItem::kDownloadingDiff);
   } else {
     package_url = workitem->crx_url;
     ChangeItemState(workitem, CrxUpdateItem::kDownloading);
   }
+
+  // On demand component updates are always downloaded in foreground.
+  const bool is_background_download = !workitem->on_demand &&
+                                       config_->UseBackgroundDownloader();
+
   crx_downloader_.reset(component_updater::CrxDownloader::Create(
+      is_background_download,
       config_->RequestContext(),
       blocking_task_runner_,
       base::Bind(&CrxUpdateService::DownloadComplete,
                  base::Unretained(this),
                  base::Passed(&crx_context))));
   crx_downloader_->StartDownloadFromUrl(package_url);
 }
 
 // Sets the state of the component to be checked for updates. After the
 // function is called, the <app> element corresponding to the |item| parameter
@@ skipping 213 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   size_t count = ChangeItemStatus(CrxUpdateItem::kChecking,
                                   CrxUpdateItem::kNoUpdate);
   DCHECK_GT(count, 0ul);
   ScheduleNextRun(kStepDelayLong);
 }
 
 // Called when the CRX package has been downloaded to a temporary location.
 // Here we fire the notifications and schedule the component-specific installer
 // to be called in the file thread.
-void CrxUpdateService::DownloadComplete(scoped_ptr<CRXContext> crx_context,
-                                        int error,
-                                        const base::FilePath& temp_crx_path) {
+void CrxUpdateService::DownloadComplete(
+    scoped_ptr<CRXContext> crx_context,
+    const component_updater::CrxDownloader::Result& download_result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   CrxUpdateItem* crx = FindUpdateItemById(crx_context->id);
   DCHECK(crx->status == CrxUpdateItem::kDownloadingDiff ||
          crx->status == CrxUpdateItem::kDownloading);
 
-  if (error) {
+  if (download_result.error) {
     if (crx->status == CrxUpdateItem::kDownloadingDiff) {
       crx->diff_error_category = kNetworkError;
-      crx->diff_error_code = error;
+      crx->diff_error_code = download_result.error;
       crx->diff_update_failed = true;
       size_t count = ChangeItemStatus(CrxUpdateItem::kDownloadingDiff,
                                       CrxUpdateItem::kCanUpdate);
       DCHECK_EQ(count, 1ul);
       crx_downloader_.reset();
 
       ScheduleNextRun(kStepDelayShort);
       return;
     }
     crx->error_category = kNetworkError;
-    crx->error_code = error;
+    crx->error_code = download_result.error;
     size_t count = ChangeItemStatus(CrxUpdateItem::kDownloading,
                                     CrxUpdateItem::kNoUpdate);
     DCHECK_EQ(count, 1ul);
     crx_downloader_.reset();
 
     // At this point, since both the differential and the full downloads failed,
     // the update for this component has finished with an error.
     ping_manager_->OnUpdateComplete(crx);
 
     // Move on to the next update, if there is one available.
@@ skipping 10 matching lines @@
     DCHECK_EQ(count, 1ul);
 
     crx_downloader_.reset();
 
     // Why unretained? See comment at top of file.
     blocking_task_runner_->PostDelayedTask(
         FROM_HERE,
         base::Bind(&CrxUpdateService::Install,
                    base::Unretained(this),
                    base::Passed(&crx_context),
-                   temp_crx_path),
+                   download_result.response),
         base::TimeDelta::FromMilliseconds(config_->StepDelay()));
   }
 }
 
 // Install consists of digital signature verification, unpacking and then
 // calling the component specific installer. All that is handled by the
 // |unpacker|. If there is an error this function is in charge of deleting
 // the files created.
 void CrxUpdateService::Install(scoped_ptr<CRXContext> context,
                                const base::FilePath& crx_path) {
@@ skipping 137 matching lines @@
 }
 
 // The component update factory. Using the component updater as a singleton
 // is the job of the browser process.
 ComponentUpdateService* ComponentUpdateServiceFactory(
     ComponentUpdateService::Configurator* config) {
   DCHECK(config);
   return new CrxUpdateService(config);
 }