extensions/browser/extension_registry.cc

   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 #include "extensions/browser/extension_registry.h"
   6
   7 #include "base/strings/string_util.h"
   8 #include "extensions/browser/extension_registry_factory.h"
   9 #include "extensions/browser/extension_registry_observer.h"
  10
  11 namespace extensions {
  12
  13 ExtensionRegistry::ExtensionRegistry(content::BrowserContext* browser_context)
  14     : browser_context_(browser_context) {}
  15 ExtensionRegistry::~ExtensionRegistry() {}
  16
  17 // static
  18 ExtensionRegistry* ExtensionRegistry::Get(content::BrowserContext* context) {
  19   return ExtensionRegistryFactory::GetForBrowserContext(context);
  20 }
  21
  22 scoped_ptr<ExtensionSet> ExtensionRegistry::GenerateInstalledExtensionsSet()
  23     const {
  24   return GenerateInstalledExtensionsSet(EVERYTHING).Pass();
  25 }
  26
  27 scoped_ptr<ExtensionSet> ExtensionRegistry::GenerateInstalledExtensionsSet(
  28     int include_mask) const {
  29   scoped_ptr<ExtensionSet> installed_extensions(new ExtensionSet);
  30   if (include_mask & IncludeFlag::ENABLED)
  31     installed_extensions->InsertAll(enabled_extensions_);
  32   if (include_mask & IncludeFlag::DISABLED)
  33     installed_extensions->InsertAll(disabled_extensions_);
  34   if (include_mask & IncludeFlag::TERMINATED)
  35     installed_extensions->InsertAll(terminated_extensions_);
  36   if (include_mask & IncludeFlag::BLACKLISTED)
  37     installed_extensions->InsertAll(blacklisted_extensions_);
  38   if (include_mask & IncludeFlag::BLOCKED)
  39     installed_extensions->InsertAll(blocked_extensions_);
  40   return installed_extensions.Pass();
  41 }
  42
  43 void ExtensionRegistry::AddObserver(ExtensionRegistryObserver* observer) {
  44   observers_.AddObserver(observer);
  45 }
  46
  47 void ExtensionRegistry::RemoveObserver(ExtensionRegistryObserver* observer) {
  48   observers_.RemoveObserver(observer);
  49 }
  50
  51 void ExtensionRegistry::TriggerOnLoaded(const Extension* extension) {
  52   CHECK(extension);
  53   DCHECK(enabled_extensions_.Contains(extension->id()));
  54   FOR_EACH_OBSERVER(ExtensionRegistryObserver,
  55                     observers_,
  56                     OnExtensionLoaded(browser_context_, extension));
  57 }
  58
  59 void ExtensionRegistry::TriggerOnReady(const Extension* extension) {
  60   CHECK(extension);
  61   DCHECK(enabled_extensions_.Contains(extension->id()));
  62   FOR_EACH_OBSERVER(ExtensionRegistryObserver, observers_,
  63                     OnExtensionReady(browser_context_, extension));
  64 }
  65
  66 void ExtensionRegistry::TriggerOnUnloaded(
  67     const Extension* extension,
  68     UnloadedExtensionInfo::Reason reason) {
  69   CHECK(extension);
  70   DCHECK(!enabled_extensions_.Contains(extension->id()));
  71   FOR_EACH_OBSERVER(ExtensionRegistryObserver,
  72                     observers_,
  73                     OnExtensionUnloaded(browser_context_, extension, reason));
  74 }
  75
  76 void ExtensionRegistry::TriggerOnWillBeInstalled(const Extension* extension,
  77                                                  bool is_update,
  78                                                  bool from_ephemeral,
  79                                                  const std::string& old_name) {
  80   CHECK(extension);
  81   DCHECK_EQ(is_update,
  82             GenerateInstalledExtensionsSet()->Contains(extension->id()));
  83   DCHECK_EQ(is_update, !old_name.empty());
  84   FOR_EACH_OBSERVER(
  85       ExtensionRegistryObserver,
  86       observers_,
  87       OnExtensionWillBeInstalled(
  88           browser_context_, extension, is_update, from_ephemeral, old_name));
  89 }
  90
  91 void ExtensionRegistry::TriggerOnInstalled(const Extension* extension,
  92                                            bool is_update) {
  93   CHECK(extension);
  94   DCHECK(GenerateInstalledExtensionsSet()->Contains(extension->id()));
  95   FOR_EACH_OBSERVER(ExtensionRegistryObserver,
  96                     observers_,
  97                     OnExtensionInstalled(
  98                         browser_context_, extension, is_update));
  99 }
 100
 101 void ExtensionRegistry::TriggerOnUninstalled(const Extension* extension,
 102                                              UninstallReason reason) {
 103   CHECK(extension);
 104   DCHECK(!GenerateInstalledExtensionsSet()->Contains(extension->id()));
 105   FOR_EACH_OBSERVER(
 106       ExtensionRegistryObserver,
 107       observers_,
 108       OnExtensionUninstalled(browser_context_, extension, reason));
 109 }
 110
 111 const Extension* ExtensionRegistry::GetExtensionById(const std::string& id,
 112                                                      int include_mask) const {
 113   std::string lowercase_id = base::ToLowerASCII(id);
 114   if (include_mask & ENABLED) {
 115     const Extension* extension = enabled_extensions_.GetByID(lowercase_id);
 116     if (extension)
 117       return extension;
 118   }
 119   if (include_mask & DISABLED) {
 120     const Extension* extension = disabled_extensions_.GetByID(lowercase_id);
 121     if (extension)
 122       return extension;
 123   }
 124   if (include_mask & TERMINATED) {
 125     const Extension* extension = terminated_extensions_.GetByID(lowercase_id);
 126     if (extension)
 127       return extension;
 128   }
 129   if (include_mask & BLACKLISTED) {
 130     const Extension* extension = blacklisted_extensions_.GetByID(lowercase_id);
 131     if (extension)
 132       return extension;
 133   }
 134   if (include_mask & BLOCKED) {
 135     const Extension* extension = blocked_extensions_.GetByID(lowercase_id);
 136     if (extension)
 137       return extension;
 138   }
 139   return NULL;
 140 }
 141
 142 const Extension* ExtensionRegistry::GetInstalledExtension(
 143     const std::string& id) const {
 144   return GetExtensionById(id, ExtensionRegistry::EVERYTHING);
 145 }
 146
 147 bool ExtensionRegistry::AddEnabled(
 148     const scoped_refptr<const Extension>& extension) {
 149   return enabled_extensions_.Insert(extension);
 150 }
 151
 152 bool ExtensionRegistry::RemoveEnabled(const std::string& id) {
 153   // Only enabled extensions can be ready, so removing an enabled extension
 154   // should also remove from the ready set if possible.
 155   if (ready_extensions_.Contains(id))
 156     RemoveReady(id);
 157   return enabled_extensions_.Remove(id);
 158 }
 159
 160 bool ExtensionRegistry::AddDisabled(
 161     const scoped_refptr<const Extension>& extension) {
 162   return disabled_extensions_.Insert(extension);
 163 }
 164
 165 bool ExtensionRegistry::RemoveDisabled(const std::string& id) {
 166   return disabled_extensions_.Remove(id);
 167 }
 168
 169 bool ExtensionRegistry::AddTerminated(
 170     const scoped_refptr<const Extension>& extension) {
 171   return terminated_extensions_.Insert(extension);
 172 }
 173
 174 bool ExtensionRegistry::RemoveTerminated(const std::string& id) {
 175   return terminated_extensions_.Remove(id);
 176 }
 177
 178 bool ExtensionRegistry::AddBlacklisted(
 179     const scoped_refptr<const Extension>& extension) {
 180   return blacklisted_extensions_.Insert(extension);
 181 }
 182
 183 bool ExtensionRegistry::RemoveBlacklisted(const std::string& id) {
 184   return blacklisted_extensions_.Remove(id);
 185 }
 186
 187 bool ExtensionRegistry::AddBlocked(
 188     const scoped_refptr<const Extension>& extension) {
 189   return blocked_extensions_.Insert(extension);
 190 }
 191
 192 bool ExtensionRegistry::RemoveBlocked(const std::string& id) {
 193   return blocked_extensions_.Remove(id);
 194 }
 195
 196 bool ExtensionRegistry::AddReady(
 197     const scoped_refptr<const Extension>& extension) {
 198   return ready_extensions_.Insert(extension);
 199 }
 200
 201 bool ExtensionRegistry::RemoveReady(const std::string& id) {
 202   return ready_extensions_.Remove(id);
 203 }
 204
 205 void ExtensionRegistry::ClearAll() {
 206   enabled_extensions_.Clear();
 207   disabled_extensions_.Clear();
 208   terminated_extensions_.Clear();
 209   blacklisted_extensions_.Clear();
 210   blocked_extensions_.Clear();
 211   ready_extensions_.Clear();
 212 }
 213
 214 void ExtensionRegistry::SetDisabledModificationCallback(
 215     const ExtensionSet::ModificationCallback& callback) {
 216   disabled_extensions_.set_modification_callback(callback);
 217 }
 218
 219 void ExtensionRegistry::Shutdown() {
 220   // Release references to all Extension objects in the sets.
 221   ClearAll();
 222   FOR_EACH_OBSERVER(ExtensionRegistryObserver, observers_, OnShutdown(this));
 223 }
 224
 225 }  // namespace extensions