Eliminate the cooldown for direct calls to on-demand updates in CUS.

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 183 matching lines @@
   void OnUpdateCheckSucceeded(const UpdateResponse::Results& results);
   void OnUpdateCheckFailed(int error, const std::string& error_message);
 
   void DownloadProgress(const std::string& component_id,
                         const CrxDownloader::Result& download_result);
 
   void DownloadComplete(scoped_ptr<CRXContext> crx_context,
                         const CrxDownloader::Result& download_result);
 
   Status OnDemandUpdateInternal(CrxUpdateItem* item);
+  Status OnDemandUpdateWithCooldown(CrxUpdateItem* item);
 
   void ProcessPendingItems();
 
   // Find a component that is ready to update.
   CrxUpdateItem* FindReadyComponent() const;
 
   // Prepares the components for an update check and initiates the request.
   // Returns true if an update check request has been made. Returns false if
   // no update check was needed or an error occured.
   bool CheckForUpdates();
@@ skipping 735 matching lines @@
                                      crx_id));
   return rt;
 }
 
 void CrxUpdateService::OnNewResourceThrottle(
     base::WeakPtr<CUResourceThrottle> rt,
     const std::string& crx_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Check if we can on-demand update, else unblock the request anyway.
   CrxUpdateItem* item = FindUpdateItemById(crx_id);
-  Status status = OnDemandUpdateInternal(item);
+  Status status = OnDemandUpdateWithCooldown(item);
   if (status == kOk || status == kInProgress) {
     item->throttles.push_back(rt);
     return;
   }
   UnblockResourceThrottle(rt);
 }
 
 // Start the process of checking for an update, for a particular component
 // that was previously registered.
 // |component_id| is a value returned from GetCrxComponentID().
 ComponentUpdateService::Status CrxUpdateService::OnDemandUpdate(
     const std::string& component_id) {
   return OnDemandUpdateInternal(FindUpdateItemById(component_id));
 }
 
-ComponentUpdateService::Status CrxUpdateService::OnDemandUpdateInternal(
+ComponentUpdateService::Status CrxUpdateService::OnDemandUpdateWithCooldown(
     CrxUpdateItem* uit) {
   if (!uit)
     return kError;
 
   // Check if the request is too soon.
   base::TimeDelta delta = base::Time::Now() - uit->last_check;
   if (delta < base::TimeDelta::FromSeconds(config_->OnDemandDelay()))
     return kError;
 
+  return OnDemandUpdateInternal(uit);
+}
+
+ComponentUpdateService::Status CrxUpdateService::OnDemandUpdateInternal(
+    CrxUpdateItem* uit) {
+  if (!uit)
+    return kError;
+
   Status service_status = GetServiceStatus(uit->status);
   // If the item is already in the process of being updated, there is
   // no point in this call, so return kInProgress.
   if (service_status == kInProgress)
     return service_status;
 
   // Otherwise the item was already checked a while back (or it is new),
   // set its status to kNew to give it a slightly higher priority.
   ChangeItemState(uit, CrxUpdateItem::kNew);
   uit->on_demand = true;
@@ skipping 69 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