Added support for multiple urls in the component updater.

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 86 matching lines @@
 
   Del* delegate_;
   Ctx* context_;
 };
 // This function creates the right DelegateWithContext using template inference.
 template <typename Del, typename Ctx>
 net::URLFetcherDelegate* MakeContextDelegate(Del* delegate, Ctx* context) {
   return new DelegateWithContext<Del, Ctx>(delegate, context);
 }
 
-// Returns true if a differential update is available for the update item.
-bool IsDiffUpdateAvailable(const CrxUpdateItem* update_item) {
-  return update_item->diff_crx_url.is_valid();
-}
-
 // Returns true if a differential update is available, it has not failed yet,
 // and the configuration allows it.
 bool CanTryDiffUpdate(const CrxUpdateItem* update_item,
                       const ComponentUpdateService::Configurator& config) {
-  return IsDiffUpdateAvailable(update_item) &&
+  return component_updater::HasDiffUpdate(update_item) &&
          !update_item->diff_update_failed &&
          config.DeltasEnabled();
 }
 
 void AppendDownloadMetrics(
     const std::vector<CrxDownloader::DownloadMetrics>& source,
     std::vector<CrxDownloader::DownloadMetrics>* destination) {
   destination->insert(destination->end(), source.begin(), source.end());
 }
 
@@ skipping 540 matching lines @@
     return *it;
   return NULL;
 }
 
 void CrxUpdateService::UpdateComponent(CrxUpdateItem* workitem) {
   scoped_ptr<CRXContext> crx_context(new CRXContext);
   crx_context->pk_hash = workitem->component.pk_hash;
   crx_context->id = workitem->id;
   crx_context->installer = workitem->component.installer;
   crx_context->fingerprint = workitem->next_fp;
-  GURL package_url;
+  const std::vector<GURL>* urls = NULL;
   if (CanTryDiffUpdate(workitem, *config_)) {
-    package_url = workitem->diff_crx_url;
+    urls = &workitem->crx_diffurls;
     ChangeItemState(workitem, CrxUpdateItem::kDownloadingDiff);
   } else {
-    package_url = workitem->crx_url;
+    urls = &workitem->crx_urls;
     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(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);
+  crx_downloader_->StartDownload(*urls);
 }
 
 // Sets the state of the component to be checked for updates. After the
 // function is called, the <app> element corresponding to the |item| parameter
 // is appended to the |update_check_items|.
 void CrxUpdateService::AddItemToUpdateCheck(CrxUpdateItem* item,
                                             std::string* update_check_items) {
   // The app element corresponding to an update items looks like this:
   //    <app appid="hnimpnehoodheedghdeeijklkeaacbdc"
   //         version="0.1.2.3" installsource="ondemand">
@@ skipping 25 matching lines @@
                         "<package fp=\"%s\"/>"
                         "</packages>"
                         "</app>",
                         app_attributes.c_str(),
                         item->component.fingerprint.c_str());
 
   update_check_items->append(app);
 
   ChangeItemState(item, CrxUpdateItem::kChecking);
   item->last_check = base::Time::Now();
-  item->crx_url = GURL();
-  item->diff_crx_url = GURL();
+  item->crx_urls.clear();
+  item->crx_diffurls.clear();
   item->previous_version = item->component.version;
   item->next_version = Version();
   item->previous_fp = item->component.fingerprint;
   item->next_fp.clear();
   item->diff_update_failed = false;
   item->error_category = 0;
   item->error_code = 0;
   item->extra_code1 = 0;
   item->diff_error_category = 0;
   item->diff_error_code = 0;
@@ skipping 99 matching lines @@
     }
 
     // Parse the members of the result and queue an upgrade for this component.
     crx->next_version = Version(it->manifest.version);
 
     typedef component_updater::
         UpdateResponse::Result::Manifest::Package Package;
     const Package& package(it->manifest.packages[0]);
     crx->next_fp = package.fingerprint;
 
-    // Select the first url from the list of urls until support for
-    // fall back urls is implemented.
-    if (!it->crx_urls.empty())
-      crx->crx_url = it->crx_urls[0].Resolve(package.name);
-    if (!it->crx_diffurls.empty())
-      crx->diff_crx_url = it->crx_diffurls[0].Resolve(package.namediff);
+    // Resolve the urls by combining the base urls with the package names.
+    for (size_t i = 0; i != it->crx_urls.size(); ++i) {
+      const GURL url(it->crx_urls[i].Resolve(package.name));
+      if (url.is_valid())
+         crx->crx_urls.push_back(url);
+    }
+    for (size_t i = 0; i != it->crx_diffurls.size(); ++i) {
+      const GURL url(it->crx_diffurls[i].Resolve(package.namediff));
+      if (url.is_valid())
+         crx->crx_diffurls.push_back(url);
+    }
 
     ChangeItemState(crx, CrxUpdateItem::kCanUpdate);
     ++num_updates_pending;
   }
 
   // All components that are not included in the update response are
   // considered up to date.
   ChangeItemStatus(CrxUpdateItem::kChecking, CrxUpdateItem::kUpToDate);
 
   // If there are updates pending we do a short wait, otherwise we take
@@ skipping 225 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);
 }