Disable an extension when it is upgraded to a version that requires more

chrome/browser/extensions/extensions_service.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_EXTENSIONS_SERVICE_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSIONS_SERVICE_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 69 matching lines @@
   ExtensionsService(Profile* profile,
                     const CommandLine* command_line,
                     PrefService* prefs,
                     const FilePath& install_directory,
                     MessageLoop* frontend_loop,
                     MessageLoop* backend_loop,
                     bool autoupdate_enabled);
   virtual ~ExtensionsService();
 
   // Gets the list of currently installed extensions.
-  virtual const ExtensionList* extensions() const {
-    return &extensions_;
+  virtual const ExtensionList* extensions() const { return &extensions_; }
+  virtual const ExtensionList* disabled_extensions() const {
+    return &disabled_extensions_;
   }
 
   const FilePath& install_directory() const { return install_directory_; }
 
   // Initialize and start all installed extensions.
   void Init();
 
+  // Look up an extension by ID.
+  Extension* GetExtensionById(const std::string& id) {
+    return GetExtensionByIdInternal(id, true, false);
+  }
+
   // Install the extension file at |extension_path|.  Will install as an
   // update if an older version is already installed.
   // For fresh installs, this method also causes the extension to be
   // immediately loaded.
   // TODO(aa): This method can be removed. It is only used by the unit tests,
   // and they could use CrxInstaller directly instead.
   void InstallExtension(const FilePath& extension_path);
 
   // Updates a currently-installed extension with the contents from
   // |extension_path|.
   // TODO(aa): This method can be removed. ExtensionUpdater could use
   // CrxInstaller directly instead.
   virtual void UpdateExtension(const std::string& id,
                                const FilePath& extension_path);
 
   // Reloads the specified extension.
   void ReloadExtension(const std::string& extension_id);
 
   // Uninstalls the specified extension. Callers should only call this method
   // with extensions that exist. |external_uninstall| is a magical parameter
   // that is only used to send information to ExtensionPrefs, which external
   // callers should never set to true.
   // TODO(aa): Remove |external_uninstall| -- this information should be passed
   // to ExtensionPrefs some other way.
   void UninstallExtension(const std::string& extension_id,
                           bool external_uninstall);
 
+  // Enable a previously disabled extension and reload it. The extension should
+  // already exist in the extension prefs.
+  // TODO(mpcomplete): add DisableExtension.
+  void EnableExtension(const std::string& extension_id);
+
   // Load the extension from the directory |extension_path|.
   void LoadExtension(const FilePath& extension_path);
 
   // Load all known extensions (used by startup and testing code).
   void LoadAllExtensions();
 
   // Check for updates (or potentially new extensions from external providers)
   void CheckForExternalUpdates();
 
   // Unload the specified extension.
   void UnloadExtension(const std::string& extension_id);
 
   // Unload all extensions.
   void UnloadAllExtensions();
 
   // Called only by testing.
   void ReloadExtensions();
 
   // Scan the extension directory and clean up the cruft.
   void GarbageCollectExtensions();
 
-  // Lookup an extension by |id|.
-  virtual Extension* GetExtensionById(const std::string& id);
-
   // Lookup an extension by |url|.  This uses the host of the URL as the id.
   Extension* GetExtensionByURL(const GURL& url);
 
   // Clear all ExternalExtensionProviders.
   void ClearProvidersForTesting();
 
   // Sets an ExternalExtensionProvider for the service to use during testing.
   // |location| specifies what type of provider should be added.
   void SetProviderForTesting(Extension::Location location,
                              ExternalExtensionProvider* test_provider);
@@ skipping 35 matching lines @@
 
   // Profile calls this when it is destroyed so that we know not to call it.
   void ProfileDestroyed() { profile_ = NULL; }
 
   ExtensionPrefs* extension_prefs() { return extension_prefs_.get(); }
 
   // Whether the extension service is ready.
   bool is_ready() { return ready_; }
 
  private:
+  // Look up an extension by ID, optionally including either or both of enabled
+  // and disabled extensions.
+  Extension* GetExtensionByIdInternal(const std::string& id,
+                                      bool include_enabled,
+                                      bool include_disabled);
+
   // The profile this ExtensionsService is part of.
   Profile* profile_;
 
   // Preferences for the owning profile.
   scoped_ptr<ExtensionPrefs> extension_prefs_;
 
   // The message loop to use with the backend.
   MessageLoop* backend_loop_;
 
   // The current list of installed extensions.
   ExtensionList extensions_;
 
+  // The list of installed extensions that have been disabled.
+  ExtensionList disabled_extensions_;
+
   // The full path to the directory where extensions are installed.
   FilePath install_directory_;
 
   // Whether or not extensions are enabled.
   bool extensions_enabled_;
 
   // Whether to notify users when they attempt to install an extension.
   bool show_extensions_prompts_;
 
   // The backend that will do IO on behalf of this instance.
@@ skipping 117 matching lines @@
 
   // A map of all external extension providers.
   typedef std::map<Extension::Location,
                    linked_ptr<ExternalExtensionProvider> > ProviderMap;
   ProviderMap external_extension_providers_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionsServiceBackend);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSIONS_SERVICE_H_