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 <vector>
 
 #include "base/at_exit.h"
@@ skipping 235 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 PingUpdateCheck(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 50 matching lines @@
       const UpdateManifest::Results& results);
 
   // See ManifestParserBridge.
   void OnParseUpdateManifestFailed(
       const std::string& error_message);
 
   bool AddItemToUpdateCheck(CrxUpdateItem* item, std::string* query);
 
   void ProcessPendingItems();
 
+  typedef std::vector<CrxUpdateItem*> UpdateItems;
+  bool ProcessWorkItems(const UpdateItems& work_items);
+
   void ScheduleNextRun(bool step_delay);
 
   void ParseManifest(const std::string& xml);
 
   void Install(const CRXContext* context, const FilePath& crx_path);
 
   void DoneInstalling(const std::string& component_id,
                       ComponentUnpacker::Error error);
 
   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;
   UpdateItems work_items_;
 
   base::OneShotTimer<CrxUpdateService> timer_;
 
   Version chrome_version_;
 
   bool running_;
 
   DISALLOW_COPY_AND_ASSIGN(CrxUpdateService);
 };
@@ skipping 141 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;
 }
 
-// Here is where the work gets scheduled. Given that our |work_items_| list
+// Here is where the work gets scheduled.
+void CrxUpdateService::ProcessPendingItems() {
+  if (!ProcessWorkItems(work_items_)) {
+    // No components to update. Next check after the long sleep.
+    ScheduleNextRun(false);
+  }
+}
+
+// Start the process of checking for an update, for a particular component
+// that was previously registered.  If the component does not exist return
+// kError, otherwise kOk.
+ComponentUpdateService::Status CrxUpdateService::PingUpdateCheck(
+    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;
+
+  UpdateItems one_item;
+  one_item.push_back(uit);
+
+  // The timer is may already be running when we do this ping.
+  // If the timer is running, cancel the currently scheduled timer,
+  // but remember the remaining time delta so that we can reset the timer
+  // to something comparable if there is nothing to do.
+  base::TimeDelta remaining_delay;
+  bool remaining_delay_set = false;
+  if (timer_.IsRunning()) {
+    remaining_delay = timer_.desired_run_time() - base::TimeTicks::Now();
+    remaining_delay_set = true;
+    timer_.Stop();
+  }

[jvoung (off chromium), 2013/01/30 02:20:21]

Good point about having fetches or installs in flight.  This ping could end with
scheduling a timer, and the in flight step will also schedule one when it is
completed, so that would be bad.


Hmm, if it's in the process of fetching a manifest or installing, then the timer
isn't running, right?  Can we detect that here, and instead of doing
ProcessWorkItems (which could end with scheduling a timer), queue up something
so that when the in-flight step finishes and calls "ScheduleNextRun", it
schedules with a step_delay instead of a long one?  That gets something going
"quickly" without actually scheduling a timer.

+
+  if (!ProcessWorkItems(one_item)) {
+    // If there is work to do, the timer is re-scheduled by a work step.
+    // However, if there is nothing to actually do, we must schedule the
+    // timer here.
+    bool use_step_delay;
+    if (remaining_delay_set) {
+      use_step_delay =
+          remaining_delay < base::TimeDelta::FromSeconds(config_->StepDelay());
+    } else {
+      // Guess that it is not a step_delay.
+      use_step_delay = false;
+    }
+    ScheduleNextRun(use_step_delay);
+  }
+  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() {
+// Returns |true| if there is work to be done.
+bool CrxUpdateService::ProcessWorkItems(const UpdateItems& work_items) {
   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) {
+  for (UpdateItems::const_iterator it = work_items.begin();
+       it != work_items.end(); ++it) {
     CrxUpdateItem* item = *it;
     if (item->status != CrxUpdateItem::kCanUpdate)
       continue;
     // Found component to update, start the process.
     item->status = CrxUpdateItem::kDownloading;
     CRXContext* context = new CRXContext;
     context->pk_hash = item->component.pk_hash;
     context->id = item->id;
     context->installer = item->component.installer;
     url_fetcher_.reset(net::URLFetcher::Create(
         0, item->crx_url, net::URLFetcher::GET,
         MakeContextDelegate(this, context)));
     StartFetch(url_fetcher_.get(), config_->RequestContext(), true);
-    return;
+    return true;
   }
 
   for (size_t ix = 0; ix != arraysize(kManifestSources); ++ix) {
     const CrxComponent::UrlSource manifest_source = kManifestSources[ix];
 
     std::string query;
     // If no pending upgrades, we check if there are new components we have not
     // 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) {
+    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;
     }
 
     // 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) {
+    for (UpdateItems::const_iterator it = work_items.begin();
+         it != work_items.end(); ++it) {
       CrxUpdateItem* item = *it;
       if ((item->status != CrxUpdateItem::kNoUpdate) &&
           (item->status != CrxUpdateItem::kUpToDate))
         continue;
       if (item->component.source != manifest_source)
         continue;
       base::TimeDelta delta = base::Time::Now() - item->last_check;
       if (delta < min_delta_time)
         continue;
       if (!AddItemToUpdateCheck(item, &query))
         break;
     }
 
     // Finally, we check components that we already updated as long as
     // we have not checked them recently.
-    for (UpdateItems::const_iterator it = work_items_.begin();
-         it != work_items_.end(); ++it) {
+    for (UpdateItems::const_iterator it = work_items.begin();
+         it != work_items.end(); ++it) {
       CrxUpdateItem* item = *it;
       if (item->status != CrxUpdateItem::kUpdated)
         continue;
       if (item->component.source != manifest_source)
         continue;
       base::TimeDelta delta = base::Time::Now() - item->last_check;
       if (delta < min_delta_time)
         continue;
       if (!AddItemToUpdateCheck(item, &query))
         break;
     }
 
     // If no components to update we move down to the next source.
     if (query.empty())
       continue;
 
     // We got components to check. Start the url request and exit.
     const std::string full_query =
         MakeFinalQuery(config_->UpdateUrl(manifest_source).spec(),
                        query,
                        config_->ExtraRequestParams());
 
     url_fetcher_.reset(net::URLFetcher::Create(
         0, GURL(full_query), net::URLFetcher::GET,
         MakeContextDelegate(this, new UpdateContext())));
     StartFetch(url_fetcher_.get(), config_->RequestContext(), false);
-    return;
+    return true;
   }
 
-  // No components to update. Next check after the long sleep.
-  ScheduleNextRun(false);
+  return 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);
 }