extensions/browser/extension_registry.h

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef EXTENSIONS_BROWSER_EXTENSION_REGISTRY_H_
   6 #define EXTENSIONS_BROWSER_EXTENSION_REGISTRY_H_
   7
   8 #include <string>
   9
  10 #include "base/compiler_specific.h"
  11 #include "base/memory/ref_counted.h"
  12 #include "base/observer_list.h"
  13 #include "components/keyed_service/core/keyed_service.h"
  14 #include "extensions/browser/uninstall_reason.h"
  15 #include "extensions/common/extension_set.h"
  16
  17 namespace content {
  18 class BrowserContext;
  19 }
  20
  21 namespace extensions {
  22 class Extension;
  23 class ExtensionRegistryObserver;
  24
  25 // ExtensionRegistry holds sets of the installed extensions for a given
  26 // BrowserContext. An incognito browser context and its master browser context
  27 // share a single registry.
  28 class ExtensionRegistry : public KeyedService {
  29  public:
  30   // Flags to pass to GetExtensionById() to select which sets to look in.
  31   enum IncludeFlag {
  32     NONE        = 0,
  33     ENABLED     = 1 << 0,
  34     DISABLED    = 1 << 1,
  35     TERMINATED  = 1 << 2,
  36     BLACKLISTED = 1 << 3,
  37     EVERYTHING = (1 << 4) - 1,
  38   };
  39
  40   explicit ExtensionRegistry(content::BrowserContext* browser_context);
  41   virtual ~ExtensionRegistry();
  42
  43   // Returns the instance for the given |browser_context|.
  44   static ExtensionRegistry* Get(content::BrowserContext* browser_context);
  45
  46   content::BrowserContext* browser_context() const { return browser_context_; }
  47
  48   // NOTE: These sets are *eventually* mututally exclusive, but an extension can
  49   // appear in two sets for short periods of time.
  50   const ExtensionSet& enabled_extensions() const {
  51     return enabled_extensions_;
  52   }
  53   const ExtensionSet& disabled_extensions() const {
  54     return disabled_extensions_;
  55   }
  56   const ExtensionSet& terminated_extensions() const {
  57     return terminated_extensions_;
  58   }
  59   const ExtensionSet& blacklisted_extensions() const {
  60     return blacklisted_extensions_;
  61   }
  62
  63   // Returns a set of all installed, disabled, blacklisted, and terminated
  64   // extensions.
  65   scoped_ptr<ExtensionSet> GenerateInstalledExtensionsSet() const;
  66
  67   // The usual observer interface.
  68   void AddObserver(ExtensionRegistryObserver* observer);
  69   void RemoveObserver(ExtensionRegistryObserver* observer);
  70
  71   // Invokes the observer method OnExtensionLoaded(). The extension must be
  72   // enabled at the time of the call.
  73   void TriggerOnLoaded(const Extension* extension);
  74
  75   // Invokes the observer method OnExtensionUnloaded(). The extension must not
  76   // be enabled at the time of the call.
  77   void TriggerOnUnloaded(const Extension* extension,
  78                          UnloadedExtensionInfo::Reason reason);
  79
  80   // If this is a fresh install then |is_update| is false and there must not be
  81   // any installed extension with |extension|'s ID. If this is an update then
  82   // |is_update| is true and must be an installed extension with |extension|'s
  83   // ID, and |old_name| must be non-empty.
  84   // If true, |from_ephemeral| indicates that the extension was previously
  85   // installed ephemerally and has been promoted to a regular installed
  86   // extension. |is_update| should also be true.
  87   void TriggerOnWillBeInstalled(const Extension* extension,
  88                                 bool is_update,
  89                                 bool from_ephemeral,
  90                                 const std::string& old_name);
  91
  92   // Invokes the observer method OnExtensionInstalled(). The extension must be
  93   // contained in one of the registry's extension sets.
  94   void TriggerOnInstalled(const Extension* extension,
  95                           bool is_update);
  96
  97   // Invokes the observer method OnExtensionUninstalled(). The extension must
  98   // not be any installed extension with |extension|'s ID.
  99   void TriggerOnUninstalled(const Extension* extension, UninstallReason reason);
 100
 101   // Find an extension by ID using |include_mask| to pick the sets to search:
 102   //  * enabled_extensions()     --> ExtensionRegistry::ENABLED
 103   //  * disabled_extensions()    --> ExtensionRegistry::DISABLED
 104   //  * terminated_extensions()  --> ExtensionRegistry::TERMINATED
 105   //  * blacklisted_extensions() --> ExtensionRegistry::BLACKLISTED
 106   // Returns NULL if the extension is not found in the selected sets.
 107   const Extension* GetExtensionById(const std::string& id,
 108                                     int include_mask) const;
 109
 110   // Adds the specified extension to the enabled set. The registry becomes an
 111   // owner. Any previous extension with the same ID is removed.
 112   // Returns true if there is no previous extension.
 113   // NOTE: You probably want to use ExtensionService instead of calling this
 114   // method directly.
 115   bool AddEnabled(const scoped_refptr<const Extension>& extension);
 116
 117   // Removes the specified extension from the enabled set.
 118   // Returns true if the set contained the specified extension.
 119   // NOTE: You probably want to use ExtensionService instead of calling this
 120   // method directly.
 121   bool RemoveEnabled(const std::string& id);
 122
 123   // As above, but for the disabled set.
 124   bool AddDisabled(const scoped_refptr<const Extension>& extension);
 125   bool RemoveDisabled(const std::string& id);
 126
 127   // As above, but for the terminated set.
 128   bool AddTerminated(const scoped_refptr<const Extension>& extension);
 129   bool RemoveTerminated(const std::string& id);
 130
 131   // As above, but for the blacklisted set.
 132   bool AddBlacklisted(const scoped_refptr<const Extension>& extension);
 133   bool RemoveBlacklisted(const std::string& id);
 134
 135   // Removes all extensions from all sets.
 136   void ClearAll();
 137
 138   // Sets a callback to run when the disabled extension set is modified.
 139   // TODO(jamescook): This is too specific for a generic registry; find some
 140   // other way to do this.
 141   void SetDisabledModificationCallback(
 142       const ExtensionSet::ModificationCallback& callback);
 143
 144   // KeyedService implementation:
 145   virtual void Shutdown() OVERRIDE;
 146
 147  private:
 148   // Extensions that are installed, enabled and not terminated.
 149   ExtensionSet enabled_extensions_;
 150
 151   // Extensions that are installed and disabled.
 152   ExtensionSet disabled_extensions_;
 153
 154   // Extensions that are installed and terminated.
 155   ExtensionSet terminated_extensions_;
 156
 157   // Extensions that are installed and blacklisted. Generally these shouldn't be
 158   // considered as installed by the extension platform: we only keep them around
 159   // so that if extensions are blacklisted by mistake they can easily be
 160   // un-blacklisted.
 161   ExtensionSet blacklisted_extensions_;
 162
 163   ObserverList<ExtensionRegistryObserver> observers_;
 164
 165   content::BrowserContext* const browser_context_;
 166
 167   DISALLOW_COPY_AND_ASSIGN(ExtensionRegistry);
 168 };
 169
 170 }  // namespace extensions
 171
 172 #endif  // EXTENSIONS_BROWSER_EXTENSION_REGISTRY_H_