Warn user in case extension delays network traffic too much.

chrome/browser/extensions/extension_service.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_
 #pragma once
 
 #include <map>
 #include <set>
@@ skipping 34 matching lines @@
 #include "content/common/property_bag.h"
 
 class AppNotificationManager;
 class CrxInstaller;
 class ExtensionBookmarkEventRouter;
 class ExtensionBrowserEventRouter;
 class ExtensionContentSettingsStore;
 class ExtensionCookiesEventRouter;
 class ExtensionDownloadsEventRouter;
 class ExtensionFileBrowserEventRouter;
+class ExtensionGlobalError;
 class ExtensionHistoryEventRouter;
 class ExtensionInstallUI;
 class ExtensionManagementEventRouter;
 class ExtensionPreferenceEventRouter;
 class ExtensionServiceBackend;
 class ExtensionSyncData;
 class ExtensionToolbarModel;
 class ExtensionUpdater;
 class ExtensionWebNavigationEventRouter;
 class GURL;
 class PendingExtensionManager;
 class Profile;
 class SyncData;
 class Version;
 
 namespace chromeos {
 class ExtensionInputMethodEventRouter;
 }  // namespace chromeos
 
+// This class is used to represent warnings if extensions misbehave.
+class ExtensionServiceWarning {

[Matt Perry, 2011/10/06 22:55:54]

The warning stuff isn't really related to the ExtensionService. Can you move it
to a different class, like an ExtensionWarningsSet that ExtensionService owns?

Also, the grouping of warnings by types seems confusing to me. How about just
flat list of (extension_id, warning_type) pairs?

[battre, 2011/10/07 14:09:24]

Done.

+ public:
+  enum WarningType {
+    // Don't use!
+    kInvalid = 0,
+    // An extension caused excessive network delays.
+    kNetworkDelay,
+    kMaxWarningType
+  };
+
+  // Default constructor for storing ExtensionServiceWarning in STL containers
+  // do not use.
+  ExtensionServiceWarning();
+
+  // Constructs and indication that a warning of type |type| is active for
+  // all extensions listed in |extension_ids|. This list could comprise
+  // for example all extensions that conflict with each other.
+  ExtensionServiceWarning(WarningType type,
+                          const std::set<std::string>& extension_ids);
+
+  ~ExtensionServiceWarning();
+
+  // Returns the specific warning type.
+  WarningType warning_type() const;
+
+  // Returns the ids of all extensions for which this warning is valid.
+  const std::set<std::string> extension_ids() const;

[Matt Perry, 2011/10/06 22:55:54]

underscore_style methods must be inline. also, when returning a complex type,
return it by ref: const std::set&

[battre, 2011/10/07 14:09:24]

Done.

+
+  // Returns whether the warning affects the extension |id|.
+  bool AffectsExtension(const std::string& id) const;
+
+ private:
+  WarningType type_;
+  std::set<std::string> extension_ids_;
+
+  // Allow implicit copy and assign operator.
+};
+
 // This is an interface class to encapsulate the dependencies that
 // various classes have on ExtensionService. This allows easy mocking.
 class ExtensionServiceInterface : public SyncableService {
  public:
   // A function that returns true if the given extension should be
   // included and false if it should be filtered out.  Identical to
   // PendingExtensionInfo::ShouldAllowInstallPredicate.
   typedef bool (*ExtensionFilter)(const Extension&);
 
   virtual ~ExtensionServiceInterface() {}
@@ skipping 44 matching lines @@
     bool Equals(const ComponentExtensionInfo& other) const;
 
     // The extension's manifest. This is required for component extensions so
     // that ExtensionService doesn't need to go to disk to load them.
     std::string manifest;
 
     // Directory where the extension is stored.
     FilePath root_directory;
   };
 
+  typedef std::map<ExtensionServiceWarning::WarningType,
+                   ExtensionServiceWarning> ExtensionWarningsType;
+
   // The name of the directory inside the profile where extensions are
   // installed to.
   static const char* kInstallDirectoryName;
 
   // If auto-updates are turned on, default to running every 5 hours.
   static const int kDefaultUpdateFrequencySeconds = 60 * 60 * 5;
 
   // The name of the directory inside the profile where per-extension settings
   // are stored.
   static const char* kSettingsDirectoryName;
@@ skipping 386 matching lines @@
 
   // |client| can be NULL for a silent install.
   scoped_refptr<CrxInstaller> MakeCrxInstaller(ExtensionInstallUI* client);
 
 #if defined(UNIT_TEST)
   void TrackTerminatedExtensionForTest(const Extension* extension) {
     TrackTerminatedExtension(extension);
   }
 #endif
 
+  // Overrides previous warnings of type |warning.warning_type()| and
+  // triggers a chrome::NOTIFICATION_EXTENSION_WARING message.

[Matt Perry, 2011/10/06 22:55:54]

typo: WARING (and below)

[battre, 2011/10/07 14:09:24]

Done.

+  void SetWarning(const ExtensionServiceWarning& warning);
+
+  // Clears a warning of |type| and triggers a
+  // chrome::NOTIFICATION_EXTENSION_WARING message if such a warning existed.
+  void ClearWarning(ExtensionServiceWarning::WarningType type);
+
+  // Clears all warnings that affected extension |extension_id| and trigger
+  // chrome::NOTIFICATION_EXTENSION_WARING messages in case the warning state
+  // changed.
+  void ClearWarningsAffectingExtension(const std::string& extension_id);
+
+  // Returns all current warnings.
+  ExtensionWarningsType GetWarnings() const;
+
+  // Returns whether a warning of |type| exists.
+  bool HasWarning(ExtensionServiceWarning::WarningType type) const;
+
+  // Suppresses showing a warning in the future.
+  void SuppressWarning(ExtensionServiceWarning::WarningType type);
+
+  // Shows or hides the warning badge on the wrench menu depending on whether
+  // any non-suppressed warnings exist.
+  void UpdateWarningBadge();
+
  private:
   // Bundle of type (app or extension)-specific sync stuff.
   struct SyncBundle {
     SyncBundle();
     ~SyncBundle();
 
     bool HasExtensionId(const std::string& id) const;
     bool HasPendingExtensionId(const std::string& id) const;
 
     ExtensionFilter filter;
@@ skipping 243 matching lines @@
   // Set to true by OnExternalExtensionUpdateUrlFound() when an external
   // extension URL is found.  Used in CheckForExternalUpdates() to see
   // if an update check is needed to install pending extensions.
   bool external_extension_url_added_;
 
   NaClModuleInfoList nacl_module_list_;
 
   SyncBundle app_sync_bundle_;
   SyncBundle extension_sync_bundle_;
 
+  // Contains an entry for each warning that shall be currently shown.
+  ExtensionWarningsType extension_warnings_;
+  std::set<ExtensionServiceWarning::WarningType> suppressed_warnings_;
+
+  // Track the currently existing ExtensionGlobalError that indicates in the
+  // UI that there are |extension_warnings_|. Weak pointer as the object
+  // is owned by the GlobalErrorService. NULL if there is no warning to be
+  // displayed on the wrench menu currently.
+  ExtensionGlobalError* extension_global_error_;
+
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            InstallAppsWithUnlimtedStorage);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            InstallAppsAndCheckStorageProtection);
   DISALLOW_COPY_AND_ASSIGN(ExtensionService);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_