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   scoped_ptr<ExtensionSet> installed_extensions(new ExtensionSet);
  25   installed_extensions->InsertAll(enabled_extensions_);
  26   installed_extensions->InsertAll(disabled_extensions_);
  27   installed_extensions->InsertAll(terminated_extensions_);
  28   installed_extensions->InsertAll(blacklisted_extensions_);
  29   return installed_extensions.Pass();
  30 }
  31
  32 void ExtensionRegistry::AddObserver(ExtensionRegistryObserver* observer) {
  33   observers_.AddObserver(observer);
  34 }
  35
  36 void ExtensionRegistry::RemoveObserver(ExtensionRegistryObserver* observer) {
  37   observers_.RemoveObserver(observer);
  38 }
  39
  40 void ExtensionRegistry::TriggerOnLoaded(const Extension* extension) {
  41   DCHECK(enabled_extensions_.Contains(extension->id()));
  42   FOR_EACH_OBSERVER(ExtensionRegistryObserver,
  43                     observers_,
  44                     OnExtensionLoaded(browser_context_, extension));
  45 }
  46
  47 void ExtensionRegistry::TriggerOnUnloaded(const Extension* extension) {
  48   DCHECK(!enabled_extensions_.Contains(extension->id()));
  49   FOR_EACH_OBSERVER(ExtensionRegistryObserver,
  50                     observers_,
  51                     OnExtensionUnloaded(browser_context_, extension));
  52 }
  53
  54 const Extension* ExtensionRegistry::GetExtensionById(const std::string& id,
  55                                                      int include_mask) const {
  56   std::string lowercase_id = StringToLowerASCII(id);
  57   if (include_mask & ENABLED) {
  58     const Extension* extension = enabled_extensions_.GetByID(lowercase_id);
  59     if (extension)
  60       return extension;
  61   }
  62   if (include_mask & DISABLED) {
  63     const Extension* extension = disabled_extensions_.GetByID(lowercase_id);
  64     if (extension)
  65       return extension;
  66   }
  67   if (include_mask & TERMINATED) {
  68     const Extension* extension = terminated_extensions_.GetByID(lowercase_id);
  69     if (extension)
  70       return extension;
  71   }
  72   if (include_mask & BLACKLISTED) {
  73     const Extension* extension = blacklisted_extensions_.GetByID(lowercase_id);
  74     if (extension)
  75       return extension;
  76   }
  77   return NULL;
  78 }
  79
  80 bool ExtensionRegistry::AddEnabled(
  81     const scoped_refptr<const Extension>& extension) {
  82   return enabled_extensions_.Insert(extension);
  83 }
  84
  85 bool ExtensionRegistry::RemoveEnabled(const std::string& id) {
  86   return enabled_extensions_.Remove(id);
  87 }
  88
  89 bool ExtensionRegistry::AddDisabled(
  90     const scoped_refptr<const Extension>& extension) {
  91   return disabled_extensions_.Insert(extension);
  92 }
  93
  94 bool ExtensionRegistry::RemoveDisabled(const std::string& id) {
  95   return disabled_extensions_.Remove(id);
  96 }
  97
  98 bool ExtensionRegistry::AddTerminated(
  99     const scoped_refptr<const Extension>& extension) {
 100   return terminated_extensions_.Insert(extension);
 101 }
 102
 103 bool ExtensionRegistry::RemoveTerminated(const std::string& id) {
 104   return terminated_extensions_.Remove(id);
 105 }
 106
 107 bool ExtensionRegistry::AddBlacklisted(
 108     const scoped_refptr<const Extension>& extension) {
 109   return blacklisted_extensions_.Insert(extension);
 110 }
 111
 112 bool ExtensionRegistry::RemoveBlacklisted(const std::string& id) {
 113   return blacklisted_extensions_.Remove(id);
 114 }
 115
 116 void ExtensionRegistry::ClearAll() {
 117   enabled_extensions_.Clear();
 118   disabled_extensions_.Clear();
 119   terminated_extensions_.Clear();
 120   blacklisted_extensions_.Clear();
 121 }
 122
 123 void ExtensionRegistry::SetDisabledModificationCallback(
 124     const ExtensionSet::ModificationCallback& callback) {
 125   disabled_extensions_.set_modification_callback(callback);
 126 }
 127
 128 void ExtensionRegistry::Shutdown() {
 129   // Release references to all Extension objects in the sets.
 130   ClearAll();
 131 }
 132
 133 }  // namespace extensions