Implement coarse "on demand" functionality for update checks.

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>
 
@@ skipping 45 matching lines @@
   CrxComponent::BANDAID,
   CrxComponent::CWS_PUBLIC,
   CrxComponent::CWS_SANDBOX,
 };
 
 // Extends an omaha compatible update check url |query| string. Does
 // not mutate the string if it would be longer than |limit| chars.
 bool AddQueryString(const std::string& id,
                     const std::string& version,
                     const std::string& fingerprint,
+                    bool ondemand,
                     size_t limit,
                     std::string* query) {
   std::string additional =
-      base::StringPrintf("id=%s&v=%s&fp=%s&uc",
-                         id.c_str(), version.c_str(), fingerprint.c_str());
+      base::StringPrintf("id=%s&v=%s&fp=%s&uc%s",
+                         id.c_str(),
+                         version.c_str(),
+                         fingerprint.c_str(),
+                         ondemand ? "&installsource=ondemand" : "");
   additional = "x=" + net::EscapeQueryParamValue(additional, true);
   if ((additional.size() + query->size() + 1) > limit)
     return false;
   if (!query->empty())
     query->append(1, '&');
   query->append(additional);
   return true;
 }
 
 // Create the final omaha compatible query. The |extra| is optional and can
@@ skipping 293 matching lines @@
                           CRXContext* context);
 
  private:
   // See ManifestParserBridge.
   void OnParseUpdateManifestSucceeded(
       const UpdateManifest::Results& results);
 
   // See ManifestParserBridge.
   void OnParseUpdateManifestFailed(const std::string& error_message);
 
-  bool AddItemToUpdateCheck(CrxUpdateItem* item, std::string* query);
+  bool AddItemToUpdateCheck(CrxUpdateItem* item,
+                            bool ondemand,
+                            std::string* query);
 
   void ProcessPendingItems();
 
   void ScheduleNextRun(bool step_delay);
 
   void ParseManifest(const std::string& xml);
 
   void Install(const CRXContext* context, const base::FilePath& crx_path);
 
   void DoneInstalling(const std::string& component_id,
@@ skipping 169 matching lines @@
     Start();
 
   return kOk;
 }
 
 // Sets a component to be checked for updates.
 // The component to add is |crxit| and the |query| string is modified with the
 // required omaha compatible query. Returns false when the query strings
 // is longer than specified by UrlSizeLimit().
 bool CrxUpdateService::AddItemToUpdateCheck(CrxUpdateItem* item,
+                                            bool ondemand,
                                             std::string* query) {
   if (!AddQueryString(item->id,
                       item->component.version.GetString(),
                       item->component.fingerprint,
-                      config_->UrlSizeLimit(), query))
+                      ondemand,
+                      config_->UrlSizeLimit(),
+                      query))
     return false;
 
   item->status = CrxUpdateItem::kChecking;
   item->last_check = base::Time::Now();
   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;
   return true;
 }
 
 // Start the process of checking for an update, for a particular component
 // that was previously registered.
+// If the component is still at version "0" (representing not-yet-installed),
+// the update check will be an "on-demand" updatecheck, which the server may
+// choose to handle differently.
 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)));
@@ skipping 80 matching lines @@
     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) {
       CrxUpdateItem* item = *it;
       if (item->status != CrxUpdateItem::kNew)
         continue;
       if (item->component.source != manifest_source)
         continue;
-      if (!AddItemToUpdateCheck(item, &query))
+      bool ondemand = requested_work_items_.count(item) &&
+          item->component.version.Equals(Version("0"));

[cpu_(ooo_6.6-7.5), 2013/06/21 00:22:56]

I don't think so. This is hacky and the on-demand is not just at v0 but in all
cases where the current component is incompatible with the action that the user
needs to do.

How about we check if the item is on the requested_work_items_ and set the flag
if so?

[waffles, 2013/06/21 01:52:08]

Done.

I had the Version==0 check in response to mevissen@'s concerns about components
calling CheckForUpdateSoon too aggressively and triggering constant "on demand"
updatechecks that aren't on demand. Indeed, PNaCl calls CheckForUpdateSoon every
browser boot.

Closer inspection shows that there is a CL in the CQ that changes that, and
additionally only calls CheckForUpdateSoon if the version == 0; so I've removed
the version check here.

+      if (!AddItemToUpdateCheck(item, ondemand, &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) {
       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))
+      if (!AddItemToUpdateCheck(item, false, &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) {
       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))
+      if (!AddItemToUpdateCheck(item, false, &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(),
@@ skipping 247 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);
 }