Add an API to component_updater that asks to do an update check "now".

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>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/string_piece.h"
@@ skipping 228 matching lines @@
 class CrxUpdateService : public ComponentUpdateService {
  public:
   explicit CrxUpdateService(ComponentUpdateService::Configurator* config);
 
   virtual ~CrxUpdateService();
 
   // Overrides for ComponentUpdateService.
   virtual Status Start() OVERRIDE;
   virtual Status Stop() OVERRIDE;
   virtual Status RegisterComponent(const CrxComponent& component) OVERRIDE;
+  virtual Status CheckForUpdateSoon(const CrxComponent& component) OVERRIDE;
 
   // The only purpose of this class is to forward the
   // UtilityProcessHostClient callbacks so CrxUpdateService does
   // not have to derive from it because that is refcounted.
   class ManifestParserBridge : public UtilityProcessHostClient {
    public:
     explicit ManifestParserBridge(CrxUpdateService* service)
         : service_(service) {}
 
     virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
@@ skipping 69 matching lines @@
   size_t ChangeItemStatus(CrxUpdateItem::Status from,
                           CrxUpdateItem::Status to);
 
   CrxUpdateItem* FindUpdateItemById(const std::string& id);
 
   scoped_ptr<Config> config_;
 
   scoped_ptr<net::URLFetcher> url_fetcher_;
 
   typedef std::vector<CrxUpdateItem*> UpdateItems;
+  // A collection of every work item.
   UpdateItems work_items_;
 
+  // A particular set of items from work_items_, which should be checked ASAP.
+  std::set<CrxUpdateItem*> requested_work_items_;
+
   base::OneShotTimer<CrxUpdateService> timer_;
 
   Version chrome_version_;
 
   bool running_;
 
   DISALLOW_COPY_AND_ASSIGN(CrxUpdateService);
 };
 
 //////////////////////////////////////////////////////////////////////////////
@@ skipping 32 matching lines @@
 }
 
 // Stop the main check + update loop. In flight operations will be
 // completed.
 ComponentUpdateService::Status CrxUpdateService::Stop() {
   running_ = false;
   timer_.Stop();
   return kOk;
 }
 
-// This function sets the timer which will call ProcessPendingItems() there
-// are two kind of waits, the short one (with step_delay = true) and the
-// long one.
+// This function sets the timer which will call ProcessPendingItems() or
+// ProcessRequestedItem() if there is an important requested item.  There
+// are two kinds of waits: a short step_delay (when step_status is
+// kPrevInProgress) and a long one when a full check/update cycle
+// has completed either successfully or with an error.
 void CrxUpdateService::ScheduleNextRun(bool step_delay) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(url_fetcher_.get() == NULL);
   CHECK(!timer_.IsRunning());
   // It could be the case that Stop() had been called while a url request
   // or unpacking was in flight, if so we arrive here but |running_| is
   // false. In that case do not loop again.
   if (!running_)
     return;
 
-  int64 delay = step_delay ? config_->StepDelay() : config_->NextCheckDelay();
+  // Keep the delay short if in the middle of an update (step_delay),
+  // or there are new requested_work_items_ that have not been processed yet.
+  int64 delay = (step_delay || requested_work_items_.size() > 0)
+      ? config_->StepDelay() : config_->NextCheckDelay();
 
   if (!step_delay) {
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_COMPONENT_UPDATER_SLEEPING,
         content::Source<ComponentUpdateService>(this),
         content::NotificationService::NoDetails());
     // Zero is only used for unit tests.
     if (0 == delay)
       return;
   }
@@ skipping 73 matching lines @@
                                             std::string* query) {
   if (!AddQueryString(item->id,
                       item->component.version.GetString(),
                       config_->UrlSizeLimit(), query))
     return false;
   item->status = CrxUpdateItem::kChecking;
   item->last_check = base::Time::Now();
   return true;
 }
 
+// Start the process of checking for an update, for a particular component
+// that was previously registered.
+ComponentUpdateService::Status CrxUpdateService::CheckForUpdateSoon(
+    const CrxComponent& component) {
+  if (component.pk_hash.empty() ||
+      !component.version.IsValid() ||
+      !component.installer)
+    return kError;
+
+  std::string id =
+    HexStringToID(StringToLowerASCII(base::HexEncode(&component.pk_hash[0],
+                                     component.pk_hash.size()/2)));
+
+  CrxUpdateItem* uit;
+  uit = FindUpdateItemById(id);
+  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;
+  }
+
+  switch (uit->status) {
+    // If the item is already in the process of being updated, there is
+    // no point in this call, so return kInProgress.
+    case CrxUpdateItem::kChecking:
+    case CrxUpdateItem::kCanUpdate:
+    case CrxUpdateItem::kDownloading:
+    case CrxUpdateItem::kUpdating:
+      return kInProgress;
+    // 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.
+    case CrxUpdateItem::kNew:
+    case CrxUpdateItem::kUpdated:
+    case CrxUpdateItem::kUpToDate:
+    case CrxUpdateItem::kNoUpdate:
+      uit->status = CrxUpdateItem::kNew;
+      requested_work_items_.insert(uit);
+      break;
+    case CrxUpdateItem::kLastStatus:
+      NOTREACHED() << uit->status;
+  }
+
+  // In case the current delay is long, set the timer to a shorter value
+  // to get the ball rolling.
+  if (timer_.IsRunning()) {
+    timer_.Stop();
+    timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(config_->StepDelay()),
+                 this, &CrxUpdateService::ProcessPendingItems);
+  }
+
+  return kOk;
+}
+
 // Here is where the work gets scheduled. Given that our |work_items_| list
 // is expected to be ten or less items, we simply loop several times.
 void CrxUpdateService::ProcessPendingItems() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // First check for ready upgrades and do one. The first
   // step is to fetch the crx package.
   for (UpdateItems::const_iterator it = work_items_.begin();
        it != work_items_.end(); ++it) {
     CrxUpdateItem* item = *it;
     if (item->status != CrxUpdateItem::kCanUpdate)
@@ skipping 19 matching lines @@
     // checked against the server. We can batch some in a single url request.
     for (UpdateItems::const_iterator it = work_items_.begin();
          it != work_items_.end(); ++it) {
       CrxUpdateItem* item = *it;
       if (item->status != CrxUpdateItem::kNew)
         continue;
       if (item->component.source != manifest_source)
         continue;
       if (!AddItemToUpdateCheck(item, &query))
         break;
+      // Requested work items may speed up the update cycle up until
+      // the point that we start an update check. I.e., transition
+      // from kNew -> kChecking.  Since the service doesn't guarantee that
+      // the requested items make it any further than kChecking,
+      // forget them now.
+      requested_work_items_.erase(item);
     }
 
     // Next we can go back to components we already checked, here
     // we can also batch them in a single url request, as long as
     // we have not checked them recently.
     const base::TimeDelta min_delta_time =
         base::TimeDelta::FromSeconds(config_->MinimumReCheckWait());
 
     for (UpdateItems::const_iterator it = work_items_.begin();
          it != work_items_.end(); ++it) {
@@ skipping 40 matching lines @@
         0, GURL(full_query), net::URLFetcher::GET,
         MakeContextDelegate(this, new UpdateContext())));
     StartFetch(url_fetcher_.get(), config_->RequestContext(), false);
     return;
   }
 
   // No components to update. Next check after the long sleep.
   ScheduleNextRun(false);
 }
 
-// Caled when we got a response from the update server. It consists of an xml
+// Called when we got a response from the update server. It consists of an xml
 // document following the omaha update scheme.
 void CrxUpdateService::OnURLFetchComplete(const net::URLFetcher* source,
                                           UpdateContext* context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (FetchSuccess(*source)) {
     std::string xml;
     source->GetResponseAsString(&xml);
     url_fetcher_.reset();
     ParseManifest(xml);
   } else {
@@ skipping 183 matching lines @@
   ScheduleNextRun(false);
 }
 
 // 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);
 }