Reworked ExtensionsService::AddPendingExtension().

chrome/browser/extensions/extension_updater.cc

 // Copyright (c) 2009 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/extensions/extension_updater.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/logging.h"
@@ skipping 151 matching lines @@
                    extension.id(),
                    *extension.version(),
                    extension.converted_from_user_script(),
                    extension.is_theme(),
                    extension.update_url());
 }
 
 void ManifestFetchesBuilder::AddPendingExtension(
     const std::string& id,
     const PendingExtensionInfo& info) {
-  AddExtensionData(Extension::INTERNAL, id, info.version,
+  // Use a zero version to ensure that a pending extension will always
+  // be updated, and thus installed (assuming all extensions have
+  // non-zero versions).
+  scoped_ptr<Version> version(
+      Version::GetVersionFromString("0.0.0.0"));
+  AddExtensionData(Extension::INTERNAL, id, *version,
                    false, info.is_theme, info.update_url);
 }
 
 void ManifestFetchesBuilder::ReportStats() const {
   UMA_HISTOGRAM_COUNTS_100("Extensions.UpdateCheckExtensions",
                            url_stats_.google_url_count +
                            url_stats_.other_url_count -
                            url_stats_.theme_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.UpdateCheckTheme",
                            url_stats_.theme_count);
@@ skipping 526 matching lines @@
   fetches.clear();
 }
 
 bool ExtensionUpdater::GetExistingVersion(const std::string& id,
                                           std::string* version) {
   if (id == kBlacklistAppID) {
     *version =
       WideToASCII(prefs_->GetString(kExtensionBlacklistUpdateVersion));
     return true;
   }
-  PendingExtensionMap::const_iterator it =
-      service_->pending_extensions().find(id);
-  if (it != service_->pending_extensions().end()) {
-    *version = it->second.version.GetString();
-    return true;
-  }
   Extension* extension = service_->GetExtensionById(id, false);
   if (!extension) {
     return false;
   }
   *version = extension->version()->GetString();
   return true;
 }
 
 std::vector<int> ExtensionUpdater::DetermineUpdates(
     const ManifestFetchData& fetch_data,
     const UpdateManifest::Results& possible_updates) {
   std::vector<int> result;
 
   // This will only get set if one of possible_updates specifies
   // browser_min_version.
   scoped_ptr<Version> browser_version;
 
   for (size_t i = 0; i < possible_updates.list.size(); i++) {
     const UpdateManifest::Result* update = &possible_updates.list[i];
 
     if (!fetch_data.Includes(update->extension_id))
       continue;
 
-    std::string version;
-    if (!GetExistingVersion(update->extension_id, &version))
-      continue;
+    if (service_->pending_extensions().find(update->extension_id) ==
+        service_->pending_extensions().end()) {
+      // If we're not installing pending extension, and the update
+      // version is the same or older than what's already installed,
+      // we don't want it.
+      std::string version;
+      if (!GetExistingVersion(update->extension_id, &version))
+        continue;
 
-    // If the update version is the same or older than what's already installed,
-    // we don't want it.
-    scoped_ptr<Version> existing_version(
-        Version::GetVersionFromString(version));
-    scoped_ptr<Version> update_version(
-        Version::GetVersionFromString(update->version));
+      scoped_ptr<Version> existing_version(
+          Version::GetVersionFromString(version));
+      scoped_ptr<Version> update_version(
+          Version::GetVersionFromString(update->version));
 
-    if (!update_version.get() ||
-        update_version->CompareTo(*(existing_version.get())) <= 0) {
-      continue;
+      if (!update_version.get() ||
+          update_version->CompareTo(*(existing_version.get())) <= 0) {
+        continue;
+      }
     }
 
     // If the update specifies a browser minimum version, do we qualify?
     if (update->browser_min_version.length() > 0) {
       // First determine the browser version if we haven't already.
       if (!browser_version.get()) {
         scoped_ptr<FileVersionInfo> version_info(
             chrome_app::GetChromeVersionInfo());
         if (version_info.get()) {
           browser_version.reset(Version::GetVersionFromString(
@@ skipping 67 matching lines @@
     extension_fetcher_.reset(
         URLFetcher::Create(kExtensionFetcherId, url, URLFetcher::GET, this));
     extension_fetcher_->set_request_context(
         Profile::GetDefaultRequestContext());
     extension_fetcher_->set_load_flags(net::LOAD_DO_NOT_SEND_COOKIES |
                                        net::LOAD_DO_NOT_SAVE_COOKIES);
     extension_fetcher_->Start();
     current_extension_fetch_ = ExtensionFetch(id, url, hash, version);
   }
 }