Decouple killbit testing from external extension providers

chrome/browser/extensions/extensions_service.cc

 // Copyright (c) 2010 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/extensions_service.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
@@ skipping 190 matching lines @@
   // Errors are reported through ExtensionErrorReporter. On success,
   // OnExtensionLoaded() is called.
   // TODO(erikkay): It might be useful to be able to load a packed extension
   // (presumably into memory) without installing it.
   void LoadSingleExtension(const FilePath &path,
                            scoped_refptr<ExtensionsService> frontend);
 
   // Check externally updated extensions for updates and install if necessary.
   // Errors are reported through ExtensionErrorReporter. Succcess is not
   // reported.
-  void CheckForExternalUpdates(const std::set<std::string>& ids_to_ignore,
-                               scoped_refptr<ExtensionsService> frontend);
+  void CheckForExternalUpdates(scoped_refptr<ExtensionsService> frontend);
 
   // For the extension in |version_path| with |id|, check to see if it's an
   // externally managed extension.  If so, tell the frontend to uninstall it.
   void CheckExternalUninstall(scoped_refptr<ExtensionsService> frontend,
                               const std::string& id);
 
   // Clear all ExternalExtensionProviders.
   void ClearProvidersForTesting();
 
   // Adds an ExternalExtensionProvider for the service to use during testing.
@@ skipping 140 matching lines @@
           error, NotificationType::EXTENSION_INSTALL_ERROR, alert_on_error_));
 }
 
 // Some extensions will autoupdate themselves externally from Chrome.  These
 // are typically part of some larger client application package.  To support
 // these, the extension will register its location in the the preferences file
 // (and also, on Windows, in the registry) and this code will periodically
 // check that location for a .crx file, which it will then install locally if
 // a new version is available.
 void ExtensionsServiceBackend::CheckForExternalUpdates(
-    const std::set<std::string>& ids_to_ignore,
     scoped_refptr<ExtensionsService> frontend) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   // Note that this installation is intentionally silent (since it didn't
   // go through the front-end).  Extensions that are registered in this
   // way are effectively considered 'pre-bundled', and so implicitly
   // trusted.  In general, if something has HKLM or filesystem access,
   // they could install an extension manually themselves anyway.
   alert_on_error_ = false;
   frontend_ = frontend;
   external_extension_added_ = false;
 
   // Ask each external extension provider to give us a call back for each
   // extension they know about. See OnExternalExtension(File|UpdateUrl)Found.
   ProviderCollection::const_iterator i;
   for (i = external_extension_providers_.begin();
        i != external_extension_providers_.end(); ++i) {
     ExternalExtensionProvider* provider = i->get();
-    provider->VisitRegisteredExtension(this, ids_to_ignore);
+    provider->VisitRegisteredExtension(this);
   }
 
   if (external_extension_added_ && frontend->updater()) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
             NewRunnableMethod(
                 frontend->updater(), &ExtensionUpdater::CheckNow));
   }
 }
 
@@ skipping 313 matching lines @@
 void ExtensionsService::AddPendingExtensionFromExternalUpdateUrl(
     const std::string& id, const GURL& update_url,
     Extension::Location location) {
   // Add the extension to this list of extensions to update.
   const PendingExtensionInfo::ExpectedCrxType kExpectedCrxType =
       PendingExtensionInfo::UNKNOWN;
   const bool kIsFromSync = false;
   const bool kInstallSilently = true;
   const bool kEnableOnInstall = true;
   const bool kEnableIncognitoOnInstall = false;
+  if (extension_prefs_->IsExtensionKilled(id))
+    return;
 
   if (GetExtensionByIdInternal(id, true, true)) {
     LOG(DFATAL) << "Trying to add extension " << id
                 << " by external update, but it is already installed.";
     return;
   }
 
   AddPendingExtensionInternal(id, update_url, kExpectedCrxType, kIsFromSync,
                               kInstallSilently, kEnableOnInstall,
                               kEnableIncognitoOnInstall,
@@ skipping 679 matching lines @@
 bool ExtensionsService::GetBrowserActionVisibility(const Extension* extension) {
   return extension_prefs_->GetBrowserActionVisibility(extension);
 }
 
 void ExtensionsService::SetBrowserActionVisibility(const Extension* extension,
                                                    bool visible) {
   extension_prefs_->SetBrowserActionVisibility(extension, visible);
 }
 
 void ExtensionsService::CheckForExternalUpdates() {
-  // This installs or updates externally provided extensions.
-  // TODO(aa): Why pass this list into the provider, why not just filter it
-  // later?
-  std::set<std::string> killed_extensions;
-  extension_prefs_->GetKilledExtensionIds(&killed_extensions);
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(
           backend_.get(), &ExtensionsServiceBackend::CheckForExternalUpdates,
-          killed_extensions, scoped_refptr<ExtensionsService>(this)));
+          scoped_refptr<ExtensionsService>(this)));
 }
 
 void ExtensionsService::UpdateExternalPolicyExtensionProvider() {
   const ListValue* list_pref =
       profile_->GetPrefs()->GetList(prefs::kExtensionInstallForceList);
   ListValue* list_copy = NULL;
   if (list_pref)
     list_copy = static_cast<ListValue*>(list_pref->DeepCopy());
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
@@ skipping 469 matching lines @@
           backend_.get(), &ExtensionsServiceBackend::AddProviderForTesting,
           test_provider));
 }
 
 void ExtensionsService::OnExternalExtensionFileFound(
          const std::string& id,
          const std::string& version,
          const FilePath& path,
          Extension::Location location) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (extension_prefs_->IsExtensionKilled(id))
+    return;
 
   // Before even bothering to unpack, check and see if we already have this
   // version. This is important because these extensions are going to get
   // installed on every startup.
   const Extension* existing = GetExtensionById(id, true);
   scoped_ptr<Version> other(Version::GetVersionFromString(version));
   if (existing) {
     switch (existing->version()->CompareTo(*other)) {
       case -1:  // existing version is older, we should upgrade
         break;
@@ skipping 122 matching lines @@
 }
 
 void ExtensionsService::SetBeingUpgraded(const Extension* extension,
                                          bool value) {
   extension_runtime_data_[extension->id()].being_upgraded = value;
 }
 
 PropertyBag* ExtensionsService::GetPropertyBag(const Extension* extension) {
   return &extension_runtime_data_[extension->id()].property_bag;
 }