extensions/browser/warning_service.cc

   1 // Copyright (c) 2012 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/warning_service.h"
   6
   7 #include "content/public/browser/browser_thread.h"
   8 #include "extensions/browser/extension_registry.h"
   9 #include "extensions/browser/extension_system.h"
  10 #include "extensions/browser/extensions_browser_client.h"
  11 #include "extensions/common/extension_set.h"
  12
  13 using content::BrowserThread;
  14
  15 namespace extensions {
  16
  17 WarningService::WarningService(content::BrowserContext* browser_context)
  18     : browser_context_(browser_context), extension_registry_observer_(this) {
  19   DCHECK(CalledOnValidThread());
  20   if (browser_context_) {
  21     extension_registry_observer_.Add(ExtensionRegistry::Get(
  22         ExtensionsBrowserClient::Get()->GetOriginalContext(browser_context_)));
  23   }
  24 }
  25
  26 WarningService::~WarningService() {}
  27
  28 void WarningService::ClearWarnings(
  29     const std::set<Warning::WarningType>& types) {
  30   DCHECK(CalledOnValidThread());
  31   bool deleted_anything = false;
  32   for (WarningSet::iterator i = warnings_.begin();
  33        i != warnings_.end();) {
  34     if (types.find(i->warning_type()) != types.end()) {
  35       deleted_anything = true;
  36       warnings_.erase(i++);
  37     } else {
  38       ++i;
  39     }
  40   }
  41
  42   if (deleted_anything)
  43     NotifyWarningsChanged();
  44 }
  45
  46 std::set<Warning::WarningType> WarningService::
  47     GetWarningTypesAffectingExtension(const std::string& extension_id) const {
  48   DCHECK(CalledOnValidThread());
  49   std::set<Warning::WarningType> result;
  50   for (WarningSet::const_iterator i = warnings_.begin();
  51        i != warnings_.end(); ++i) {
  52     if (i->extension_id() == extension_id)
  53       result.insert(i->warning_type());
  54   }
  55   return result;
  56 }
  57
  58 std::vector<std::string> WarningService::GetWarningMessagesForExtension(
  59     const std::string& extension_id) const {
  60   DCHECK(CalledOnValidThread());
  61   std::vector<std::string> result;
  62
  63   const ExtensionSet& extension_set =
  64       ExtensionRegistry::Get(browser_context_)->enabled_extensions();
  65
  66   for (WarningSet::const_iterator i = warnings_.begin();
  67        i != warnings_.end(); ++i) {
  68     if (i->extension_id() == extension_id)
  69       result.push_back(i->GetLocalizedMessage(&extension_set));
  70   }
  71   return result;
  72 }
  73
  74 void WarningService::AddWarnings(const WarningSet& warnings) {
  75   DCHECK(CalledOnValidThread());
  76   size_t old_size = warnings_.size();
  77
  78   warnings_.insert(warnings.begin(), warnings.end());
  79
  80   if (old_size != warnings_.size())
  81     NotifyWarningsChanged();
  82 }
  83
  84 // static
  85 void WarningService::NotifyWarningsOnUI(
  86     void* profile_id,
  87     const WarningSet& warnings) {
  88   DCHECK_CURRENTLY_ON(BrowserThread::UI);
  89   content::BrowserContext* browser_context =
  90       reinterpret_cast<content::BrowserContext*>(profile_id);
  91
  92   if (!browser_context ||
  93       !ExtensionsBrowserClient::Get() ||
  94       !ExtensionsBrowserClient::Get()->IsValidContext(browser_context)) {
  95     return;
  96   }
  97
  98   WarningService* warning_service =
  99       ExtensionSystem::Get(browser_context)->warning_service();
 100
 101   warning_service->AddWarnings(warnings);
 102 }
 103
 104 void WarningService::AddObserver(Observer* observer) {
 105   observer_list_.AddObserver(observer);
 106 }
 107
 108 void WarningService::RemoveObserver(Observer* observer) {
 109   observer_list_.RemoveObserver(observer);
 110 }
 111
 112 void WarningService::NotifyWarningsChanged() {
 113   FOR_EACH_OBSERVER(Observer, observer_list_, ExtensionWarningsChanged());
 114 }
 115
 116 void WarningService::OnExtensionUnloaded(
 117     content::BrowserContext* browser_context,
 118     const Extension* extension,
 119     UnloadedExtensionInfo::Reason reason) {
 120   // Unloading one extension might have solved the problems of others.
 121   // Therefore, we clear warnings of this type for all extensions.
 122   std::set<Warning::WarningType> warning_types =
 123       GetWarningTypesAffectingExtension(extension->id());
 124   ClearWarnings(warning_types);
 125 }
 126
 127 }  // namespace extensions