chrome/browser/extensions/extension_warning_badge_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 "chrome/browser/extensions/extension_warning_badge_service.h"
   6
   7 #include "base/stl_util.h"
   8 #include "chrome/app/chrome_command_ids.h"
   9 #include "chrome/browser/extensions/extension_system.h"
  10 #include "chrome/browser/ui/global_error/global_error.h"
  11 #include "chrome/browser/ui/global_error/global_error_service.h"
  12 #include "chrome/browser/ui/global_error/global_error_service_factory.h"
  13 #include "chrome/browser/ui/browser_commands.h"
  14 #include "grit/generated_resources.h"
  15 #include "ui/base/l10n/l10n_util.h"
  16
  17 namespace extensions {
  18
  19 namespace {
  20 // Non-modal GlobalError implementation that warns the user if extensions
  21 // created warnings or errors. If the user clicks on the wrench menu, the user
  22 // is redirected to chrome://extensions to inspect the errors.
  23 class ErrorBadge : public GlobalError {
  24  public:
  25   explicit ErrorBadge(ExtensionWarningBadgeService* badge_service);
  26   virtual ~ErrorBadge();
  27
  28   // Implementation for GlobalError:
  29   virtual bool HasMenuItem() OVERRIDE;
  30   virtual int MenuItemCommandID() OVERRIDE;
  31   virtual base::string16 MenuItemLabel() OVERRIDE;
  32   virtual void ExecuteMenuItem(Browser* browser) OVERRIDE;
  33
  34   virtual bool HasBubbleView() OVERRIDE;
  35   virtual bool HasShownBubbleView() OVERRIDE;
  36   virtual void ShowBubbleView(Browser* browser) OVERRIDE;
  37   virtual GlobalErrorBubbleViewBase* GetBubbleView() OVERRIDE;
  38
  39   static int GetMenuItemCommandID();
  40
  41  private:
  42   ExtensionWarningBadgeService* badge_service_;
  43
  44   DISALLOW_COPY_AND_ASSIGN(ErrorBadge);
  45 };
  46
  47 ErrorBadge::ErrorBadge(ExtensionWarningBadgeService* badge_service)
  48     : badge_service_(badge_service) {}
  49
  50 ErrorBadge::~ErrorBadge() {}
  51
  52 bool ErrorBadge::HasMenuItem() {
  53   return true;
  54 }
  55
  56 int ErrorBadge::MenuItemCommandID() {
  57   return GetMenuItemCommandID();
  58 }
  59
  60 base::string16 ErrorBadge::MenuItemLabel() {
  61   return l10n_util::GetStringUTF16(IDS_EXTENSION_WARNINGS_WRENCH_MENU_ITEM);
  62 }
  63
  64 void ErrorBadge::ExecuteMenuItem(Browser* browser) {
  65   // Suppress all current warnings in the extension service from triggering
  66   // a badge on the wrench menu in the future of this session.
  67   badge_service_->SuppressCurrentWarnings();
  68
  69   chrome::ExecuteCommand(browser, IDC_MANAGE_EXTENSIONS);
  70 }
  71
  72 bool ErrorBadge::HasBubbleView() { return false; }
  73
  74 bool ErrorBadge::HasShownBubbleView() { return false; }
  75
  76 void ErrorBadge::ShowBubbleView(Browser* browser) { NOTREACHED(); }
  77
  78 GlobalErrorBubbleViewBase* ErrorBadge::GetBubbleView() {
  79   return NULL;
  80 }
  81
  82 // static
  83 int ErrorBadge::GetMenuItemCommandID() {
  84   return IDC_EXTENSION_ERRORS;
  85 }
  86
  87 }  // namespace
  88
  89
  90 ExtensionWarningBadgeService::ExtensionWarningBadgeService(Profile* profile)
  91     : profile_(profile) {
  92   DCHECK(CalledOnValidThread());
  93 }
  94
  95 ExtensionWarningBadgeService::~ExtensionWarningBadgeService() {}
  96
  97 void ExtensionWarningBadgeService::SuppressCurrentWarnings() {
  98   DCHECK(CalledOnValidThread());
  99   size_t old_size = suppressed_warnings_.size();
 100
 101   const ExtensionWarningSet& warnings = GetCurrentWarnings();
 102   suppressed_warnings_.insert(warnings.begin(), warnings.end());
 103
 104   if (old_size != suppressed_warnings_.size())
 105     UpdateBadgeStatus();
 106 }
 107
 108 const ExtensionWarningSet&
 109 ExtensionWarningBadgeService::GetCurrentWarnings() const {
 110   return ExtensionSystem::Get(profile_)->warning_service()->warnings();
 111 }
 112
 113 void ExtensionWarningBadgeService::ExtensionWarningsChanged() {
 114   DCHECK(CalledOnValidThread());
 115   UpdateBadgeStatus();
 116 }
 117
 118 void ExtensionWarningBadgeService::UpdateBadgeStatus() {
 119   const std::set<ExtensionWarning>& warnings = GetCurrentWarnings();
 120   bool non_suppressed_warnings_exist = false;
 121   for (std::set<ExtensionWarning>::const_iterator i = warnings.begin();
 122        i != warnings.end(); ++i) {
 123     if (!ContainsKey(suppressed_warnings_, *i)) {
 124       non_suppressed_warnings_exist = true;
 125       break;
 126     }
 127   }
 128   ShowBadge(non_suppressed_warnings_exist);
 129 }
 130
 131 void ExtensionWarningBadgeService::ShowBadge(bool show) {
 132   GlobalErrorService* service =
 133       GlobalErrorServiceFactory::GetForProfile(profile_);
 134   GlobalError* error = service->GetGlobalErrorByMenuItemCommandID(
 135       ErrorBadge::GetMenuItemCommandID());
 136
 137   // Activate or hide the warning badge in case the current state is incorrect.
 138   if (error && !show) {
 139     service->RemoveGlobalError(error);
 140     delete error;
 141   } else if (!error && show) {
 142     service->AddGlobalError(new ErrorBadge(this));
 143   }
 144 }
 145
 146 }  // namespace extensions