Allow autoupdate to update disabled extensions.

chrome/browser/extensions/updater/extension_updater.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/extensions/updater/extension_updater.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/pending_extension_manager.h"
 #include "chrome/browser/extensions/updater/extension_downloader.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
-#include "chrome/common/extensions/extension_set.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "crypto/sha2.h"
 
 using base::RandDouble;
 using base::RandInt;
 using base::Time;
@@ skipping 218 matching lines @@
 bool ExtensionUpdater::WillCheckSoon() const {
   return will_check_soon_;
 }
 
 void ExtensionUpdater::DoCheckSoon() {
   DCHECK(will_check_soon_);
   CheckNow();
   will_check_soon_ = false;
 }
 
+void ExtensionUpdater::AddToDownloader(const ExtensionSet* extensions,
+    const std::set<std::string>& pending_ids) {
+  for (ExtensionSet::const_iterator iter = extensions->begin();
+       iter != extensions->end(); ++iter) {
+    const Extension& extension = **iter;
+    if (!Extension::IsAutoUpdateableLocation(extension.location())) {
+      VLOG(2) << "Extension " << extension.id() << " is not auto updateable";
+      continue;
+    }
+    // An extension might be overwritten by policy, and have its update url
+    // changed. Make sure existing extensions aren't fetched again, if a
+    // pending fetch for an extension with the same id already exists.
+    if (!ContainsKey(pending_ids, extension.id())) {
+      if (downloader_->AddExtension(extension))
+        in_progress_ids_.insert(extension.id());
+    }
+  }
+}
+
 void ExtensionUpdater::CheckNow() {
   VLOG(2) << "Starting update check";
   DCHECK(alive_);
   NotifyStarted();
 
   if (!downloader_.get()) {
     downloader_.reset(
         new ExtensionDownloader(this, profile_->GetRequestContext()));
   }
 
@@ skipping 14 matching lines @@
     if (!found_id)
       continue;
     if (!Extension::IsAutoUpdateableLocation(info.install_source())) {
       VLOG(2) << "Extension " << *iter << " is not auto updateable";
       continue;
     }
     if (downloader_->AddPendingExtension(*iter, info.update_url()))
       in_progress_ids_.insert(*iter);
   }
 
-  // Add fetch records for extensions that are installed and have an
-  // update URL.
-  const ExtensionSet* extensions = service_->extensions();
-  for (ExtensionSet::const_iterator iter = extensions->begin();
-       iter != extensions->end(); ++iter) {
-    const Extension& extension = **iter;
-    if (!Extension::IsAutoUpdateableLocation(extension.location())) {
-      VLOG(2) << "Extension " << extension.id() << " is not auto updateable";
-      continue;
-    }
-    // An extension might be overwritten by policy, and have its update url
-    // changed. Make sure existing extensions aren't fetched again, if a
-    // pending fetch for an extension with the same id already exists.
-    if (!ContainsKey(pending_ids, extension.id())) {
-      if (downloader_->AddExtension(extension))
-        in_progress_ids_.insert(extension.id());
-    }
-  }
+  AddToDownloader(service_->extensions(), pending_ids);
+  AddToDownloader(service_->disabled_extensions(), pending_ids);
 
   // Start a fetch of the blacklist if needed.
   if (blacklist_checks_enabled_) {
     ManifestFetchData::PingData ping_data;
     ping_data.rollcall_days =
         CalculatePingDays(extension_prefs_->BlacklistLastPingDay());
     downloader_->StartBlacklistUpdate(
         prefs_->GetString(kExtensionBlacklistUpdateVersion), ping_data);
   }
 
@@ skipping 83 matching lines @@
   return service_->pending_extension_manager()->IsIdPending(id);
 }
 
 bool ExtensionUpdater::GetExtensionExistingVersion(const std::string& id,
                                                    std::string* version) {
   DCHECK(alive_);
   if (id == ExtensionDownloader::kBlacklistAppID) {
     *version = prefs_->GetString(kExtensionBlacklistUpdateVersion);
     return true;
   }
-  const Extension* extension = service_->GetExtensionById(id, false);
+  const Extension* extension = service_->GetExtensionById(id, true);
   if (!extension)
     return false;
   *version = extension->version()->GetString();
   return true;
 }
 
 void ExtensionUpdater::UpdatePingData(const std::string& id,
                                       const PingResult& ping_result) {
   DCHECK(alive_);
   if (ping_result.did_ping) {
@@ skipping 65 matching lines @@
   if (in_progress_ids_.empty()) {
     VLOG(1) << "Sending EXTENSION_UPDATING_FINISHED";
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_UPDATING_FINISHED,
         content::Source<Profile>(profile_),
         content::NotificationService::NoDetails());
   }
 }
 
 }  // namespace extensions