Add a component updater for the CLD2 data file.

chrome/browser/component_updater/component_updater_service.cc

 // Copyright 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 282 matching lines @@
   // alive, this simplifies the management of the work that could be in
   // flight in other threads.
   Stop();
   STLDeleteElements(&work_items_);
 }
 
 ComponentUpdateService::Status CrxUpdateService::Start() {
   // Note that RegisterComponent will call Start() when the first
   // component is registered, so it can be called twice. This way
   // we avoid scheduling the timer if there is no work to do.
+  VLOG(1) << "CrxUpdateService starting up";
   running_ = true;
   if (work_items_.empty())
     return kOk;
 
   NotifyComponentObservers(ComponentObserver::COMPONENT_UPDATER_STARTED, 0);
 
+  VLOG(1) << "First update attempt will take place in "
+      << config_->InitialDelay() << " seconds";

[Sorin Jianu, 2014/04/25 16:39:41]

style guide here and throughout the CL.

"subsequent lines should start with the << operator and should be aligned based
on the first << from the original "

   timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(config_->InitialDelay()),
                this, &CrxUpdateService::ProcessPendingItems);
   return kOk;
 }
 
 // Stop the main check + update loop. In flight operations will be
 // completed.
 ComponentUpdateService::Status CrxUpdateService::Stop() {
+  VLOG(1) << "CrxUpdateService stopping";
   running_ = false;
   timer_.Stop();
   return kOk;
 }
 
 bool CrxUpdateService::HasOnDemandItems() const {
   class Helper {
    public:
     static bool IsOnDemand(CrxUpdateItem* item) {
       return item->on_demand;
@@ skipping 42 matching lines @@
   }
 
   if (step_delay != kStepDelayShort) {
     NotifyComponentObservers(ComponentObserver::COMPONENT_UPDATER_SLEEPING, 0);
 
     // Zero is only used for unit tests.
     if (0 == delay_seconds)
       return;
   }
 
+  VLOG(1) << "Scheduling next run to occur in " << delay_seconds << " seconds";
   timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(delay_seconds),
                this, &CrxUpdateService::ProcessPendingItems);
 }
 
 // Given a extension-like component id, find the associated component.
 CrxUpdateItem* CrxUpdateService::FindUpdateItemById(const std::string& id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CrxUpdateItem::FindById finder(id);
   UpdateItems::iterator it = std::find_if(work_items_.begin(),
                                           work_items_.end(),
@@ skipping 214 matching lines @@
     CrxUpdateItem* item = work_items_[i];
     DCHECK(item->status == CrxUpdateItem::kNew ||
            item->status == CrxUpdateItem::kNoUpdate ||
            item->status == CrxUpdateItem::kUpToDate ||
            item->status == CrxUpdateItem::kUpdated);
 
     const base::TimeDelta time_since_last_checked(now - item->last_check);
 
     if (!item->on_demand &&
         time_since_last_checked < minimum_recheck_wait_time) {
+      VLOG(1) << "Skipping check for component update: id=" << item->id
+          << ", time_since_last_checked=" << time_since_last_checked.InSeconds()
+          << " seconds: too soon to check for an update";
       continue;
     }
 
+    VLOG(1) << "Scheduling update check for component id=" << item->id
+        << ", time_since_last_checked=" << time_since_last_checked.InSeconds()
+        << " seconds";
+
     ChangeItemState(item, CrxUpdateItem::kChecking);
 
     item->last_check = now;
     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;
@@ skipping 68 matching lines @@
 
 // Handles a valid Omaha update check response by matching the results with
 // the registered components which were checked for updates.
 // If updates are found, prepare the components for the actual version upgrade.
 // One of these components will be drafted for the upgrade next time
 // ProcessPendingItems is called.
 void CrxUpdateService::OnUpdateCheckSucceeded(
     const UpdateResponse::Results& results) {
   size_t num_updates_pending = 0;
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  VLOG(1) << "Update check succeeded.";
   std::vector<UpdateResponse::Result>::const_iterator it;
   for (it = results.list.begin(); it != results.list.end(); ++it) {
     CrxUpdateItem* crx = FindUpdateItemById(it->extension_id);
     if (!crx)
       continue;
 
     if (crx->status != CrxUpdateItem::kChecking) {
       NOTREACHED();
       continue;  // Not updating this component now.
     }
 
     if (it->manifest.version.empty()) {
       // No version means no update available.
       ChangeItemState(crx, CrxUpdateItem::kNoUpdate);
+      VLOG(1) << "No update available for component: " << crx->id;
       continue;
     }
 
     if (!IsVersionNewer(crx->component.version, it->manifest.version)) {
       // The component is up to date.
       ChangeItemState(crx, CrxUpdateItem::kUpToDate);
+      VLOG(1) << "Component already up-to-date: " << crx->id;
       continue;
     }
 
     if (!it->manifest.browser_min_version.empty()) {
       if (IsVersionNewer(chrome_version_, it->manifest.browser_min_version)) {
         // The component is not compatible with this Chrome version.
+        VLOG(1) << "Ignoring incompatible component: " << crx->id;
         ChangeItemState(crx, CrxUpdateItem::kNoUpdate);
         continue;
       }
     }
 
     if (it->manifest.packages.size() != 1) {
       // Assume one and only one package per component.
+      VLOG(1) << "Ignoring multiple packages for component: " << crx->id;
       ChangeItemState(crx, CrxUpdateItem::kNoUpdate);
       continue;
     }
 
     // Parse the members of the result and queue an upgrade for this component.
     crx->next_version = Version(it->manifest.version);
 
+    VLOG(1) << "Update found for component: " << crx->id;
+
     typedef UpdateResponse::Result::Manifest::Package Package;
     const Package& package(it->manifest.packages[0]);
     crx->next_fp = package.fingerprint;
 
     // 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);
     }
@@ skipping 17 matching lines @@
 }
 
 // TODO: record UMA stats.
 void CrxUpdateService::OnUpdateCheckFailed(int error,
                                            const std::string& error_message) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(error);
   size_t count = ChangeItemStatus(CrxUpdateItem::kChecking,
                                   CrxUpdateItem::kNoUpdate);
   DCHECK_GT(count, 0ul);
+  VLOG(1) << "Update check failed.";
   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,
     const CrxDownloader::Result& download_result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 218 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);
 }
 
 }  // namespace component_updater