Warn user in case extension delays network traffic too much.

chrome/browser/extensions/extension_warning_set.cc

+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/extensions/extension_warning_set.h"
+
+#include "chrome/browser/extensions/extension_global_error.h"
+#include "chrome/browser/ui/global_error_service.h"
+#include "chrome/browser/ui/global_error_service_factory.h"
+#include "chrome/common/chrome_notification_types.h"
+#include "content/common/notification_service.h"
+
+bool operator<(const ExtensionWarning& a, const ExtensionWarning& b) {
+  if (a.warning_type() == b.warning_type())
+    return a.extension_id() < b.extension_id();
+  return a.warning_type() < b.warning_type();
+}
+
+ExtensionWarning::ExtensionWarning() : type_(ExtensionWarning::kInvalid) {
+}
+
+ExtensionWarning::ExtensionWarning(
+    ExtensionWarning::WarningType type,
+    const std::string& extension_id)
+    : type_(type), extension_id_(extension_id) {
+}
+
+ExtensionWarning::~ExtensionWarning() {
+}
+
+ExtensionWarningSet::ExtensionWarningSet(Profile* profile)
+    : extension_global_error_(NULL), profile_(profile) {
+}
+
+ExtensionWarningSet::~ExtensionWarningSet() {
+}
+
+void ExtensionWarningSet::SetWarning(const ExtensionWarning& warning) {
+  bool inserted = warnings_.insert(warning).second;
+  if (inserted) {
+    NotifyWarningsChanged();
+    UpdateWarningBadge();
+  }
+}
+
+void ExtensionWarningSet::ClearWarnings(
+    const std::set<ExtensionWarning::WarningType>& types) {
+  bool deleted_anything = false;
+  for (const_iterator i = warnings_.begin(); i != warnings_.end();) {
+    if (types.find(i->warning_type()) != types.end()) {
+      deleted_anything = true;
+      warnings_.erase(i++);
+    } else {
+      ++i;
+    }
+  }
+
+  if (deleted_anything) {
+    NotifyWarningsChanged();
+    UpdateWarningBadge();
+  }
+}
+
+void ExtensionWarningSet::GetWarningsAffectingExtension(
+    const std::string& extension_id,
+    std::set<ExtensionWarning::WarningType>* result) const {
+  result->clear();
+  for (const_iterator i = warnings_.begin(); i != warnings_.end(); ++i) {
+    if (i->extension_id() == extension_id)
+      result->insert(i->warning_type());
+  }
+}
+
+void ExtensionWarningSet::SuppressBadgeForCurrentWarnings() {
+  badge_suppressions_.insert(warnings_.begin(), warnings_.end());
+  UpdateWarningBadge();
+}
+
+void ExtensionWarningSet::NotifyWarningsChanged() {
+  NotificationService::current()->Notify(
+      chrome::NOTIFICATION_EXTENSION_WARNING_CHANGED,
+      Source<Profile>(profile_),
+      NotificationService::NoDetails());
+}
+
+void ExtensionWarningSet::ActivateBadge() {
+  DCHECK(!extension_global_error_);
+  DCHECK(profile_);
+  extension_global_error_ = new ExtensionGlobalError;
+  GlobalErrorServiceFactory::GetForProfile(profile_)->AddGlobalError(
+      extension_global_error_);
+}
+
+void ExtensionWarningSet::DeactivateBadge() {
+  DCHECK(extension_global_error_);
+  DCHECK(profile_);
+  GlobalErrorServiceFactory::GetForProfile(profile_)->RemoveGlobalError(
+      extension_global_error_);
+  delete extension_global_error_;
+  extension_global_error_ = NULL;
+}
+
+void ExtensionWarningSet::UpdateWarningBadge() {
+  // We need a badge if a warning exists that has not been suppressed.
+  bool need_warning_badge = false;
+  for (const_iterator i = warnings_.begin(); i != warnings_.end(); ++i) {
+    if (badge_suppressions_.find(*i) == badge_suppressions_.end()) {
+      need_warning_badge = true;
+      break;
+    }
+  }
+
+  // Activate or hide the warning badge in case the current state is incorrect.
+  if (extension_global_error_ && !need_warning_badge) {
+    DeactivateBadge();
+  } else if (!extension_global_error_ && need_warning_badge) {
+    ActivateBadge();
+  }

[Finnur, 2011/10/10 09:59:24]

nit: no braces on single-line if-else clauses.

[battre, 2011/10/10 13:16:36]

Done.

+}