Consider the last_check time when doing update checks for components.

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 577 matching lines @@
       work_items_.begin(), work_items_.end(), Helper::IsReadyOnDemand);
   if (it != work_items_.end())
     return *it;
   it = std::find_if(work_items_.begin(), work_items_.end(), Helper::IsReady);
   if (it != work_items_.end())
     return *it;
   return NULL;
 }
 
 // Prepares the components for an update check and initiates the request.
+// On demand components are always included in the update check request.
+// Otherwise, only include components that have not been checked recently.
 bool CrxUpdateService::CheckForUpdates() {
-  // All components are selected for the update check, regardless of when they
-  // were last checked. More selective algorithms could be implemented in the
-  // future.
+  const base::TimeDelta minimum_recheck_wait_time =
+      base::TimeDelta::FromSeconds(config_->MinimumReCheckWait());
+  const base::Time now(base::Time::Now());
+
   std::vector<CrxUpdateItem*> items_to_check;
   for (size_t i = 0; i != work_items_.size(); ++i) {
     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) {
+      continue;
+    }
+
     ChangeItemState(item, CrxUpdateItem::kChecking);
 
-    item->last_check = base::Time::Now();
+    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;
     item->error_category = 0;
     item->error_code = 0;
     item->extra_code1 = 0;
@@ skipping 131 matching lines @@
     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
   // a longer delay until we check the components again.
-  ScheduleNextRun(num_updates_pending > 0 ? kStepDelayShort : kStepDelayMedium);
+  ScheduleNextRun(num_updates_pending > 0 ? kStepDelayShort : kStepDelayLong);
 }
 
 // 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);
@@ skipping 226 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