chrome/browser/extensions/extension_toolbar_model.h

   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 #ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_TOOLBAR_MODEL_H_
   6 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_TOOLBAR_MODEL_H_
   7
   8 #include "base/compiler_specific.h"
   9 #include "base/observer_list.h"
  10 #include "base/prefs/pref_change_registrar.h"
  11 #include "base/scoped_observer.h"
  12 #include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
  13 #include "chrome/browser/extensions/extension_action.h"
  14 #include "components/keyed_service/core/keyed_service.h"
  15 #include "extensions/browser/extension_prefs.h"
  16 #include "extensions/browser/extension_registry_observer.h"
  17 #include "extensions/common/extension.h"
  18
  19 class Browser;
  20 class PrefService;
  21 class Profile;
  22
  23 namespace extensions {
  24 class ExtensionRegistry;
  25 class ExtensionSet;
  26
  27 // Model for the browser actions toolbar.
  28 class ExtensionToolbarModel : public ExtensionActionAPI::Observer,
  29                               public ExtensionRegistryObserver,
  30                               public KeyedService {
  31  public:
  32   // The different options for highlighting.
  33   enum HighlightType {
  34     HIGHLIGHT_NONE,
  35     HIGHLIGHT_INFO,
  36     HIGHLIGHT_WARNING,
  37   };
  38
  39   ExtensionToolbarModel(Profile* profile, ExtensionPrefs* extension_prefs);
  40   ~ExtensionToolbarModel() override;
  41
  42   // A class which is informed of changes to the model; represents the view of
  43   // MVC. Also used for signaling view changes such as showing extension popups.
  44   // TODO(devlin): Should this really be an observer? It acts more like a
  45   // delegate.
  46   class Observer {
  47    public:
  48     // Signals that an |extension| has been added to the toolbar at |index|.
  49     // This will *only* be called after the toolbar model has been initialized.
  50     virtual void OnToolbarExtensionAdded(const Extension* extension,
  51                                          int index) = 0;
  52
  53     // Signals that the given |extension| has been removed from the toolbar.
  54     virtual void OnToolbarExtensionRemoved(const Extension* extension) = 0;
  55
  56     // Signals that the given |extension| has been moved to |index|. |index| is
  57     // the desired *final* index of the extension (that is, in the adjusted
  58     // order, extension should be at |index|).
  59     virtual void OnToolbarExtensionMoved(const Extension* extension,
  60                                          int index) = 0;
  61
  62     // Signals that the browser action for the given |extension| has been
  63     // updated.
  64     virtual void OnToolbarExtensionUpdated(const Extension* extension) = 0;
  65
  66     // Signals the |extension| to show the popup now in the active window.
  67     // If |grant_active_tab| is true, then active tab permissions should be
  68     // given to the extension (only do this if this is through a user action).
  69     // Returns true if a popup was slated to be shown.
  70     virtual bool ShowExtensionActionPopup(const Extension* extension,
  71                                           bool grant_active_tab) = 0;
  72
  73     // Signals when the container needs to be redrawn because of a size change,
  74     // and when the model has finished loading.
  75     virtual void OnToolbarVisibleCountChanged() = 0;
  76
  77     // Signals that the model has entered or exited highlighting mode, or that
  78     // the extensions being highlighted have (probably*) changed. Highlighting
  79     // mode indicates that only a subset of the extensions are actively
  80     // displayed, and those extensions should be highlighted for extra emphasis.
  81     // * probably, because if we are in highlight mode and receive a call to
  82     //   highlight a new set of extensions, we do not compare the current set
  83     //   with the new set (and just assume the new set is different).
  84     virtual void OnToolbarHighlightModeChanged(bool is_highlighting) = 0;
  85
  86     // Signals that the toolbar model has been initialized, so that if any
  87     // observers were postponing animation during the initialization stage, they
  88     // can catch up.
  89     virtual void OnToolbarModelInitialized() = 0;
  90
  91     // Returns the browser associated with the Observer.
  92     virtual Browser* GetBrowser() = 0;
  93
  94    protected:
  95     virtual ~Observer() {}
  96   };
  97
  98   // Convenience function to get the ExtensionToolbarModel for a Profile.
  99   static ExtensionToolbarModel* Get(Profile* profile);
 100
 101   // Adds or removes an observer.
 102   void AddObserver(Observer* observer);
 103   void RemoveObserver(Observer* observer);
 104
 105   // Moves the given |extension|'s icon to the given |index|.
 106   void MoveExtensionIcon(const std::string& id, size_t index);
 107
 108   // Sets the number of extension icons that should be visible.
 109   // If count == size(), this will set the visible icon count to -1, meaning
 110   // "show all actions".
 111   void SetVisibleIconCount(size_t count);
 112
 113   size_t visible_icon_count() const {
 114     // We have guards around this because |visible_icon_count_| can be set by
 115     // prefs/sync, and we want to ensure that the icon count returned is within
 116     // bounds.
 117     return visible_icon_count_ == -1 ?
 118         toolbar_items().size() :
 119         std::min(static_cast<size_t>(visible_icon_count_),
 120                  toolbar_items().size());
 121   }
 122
 123   bool all_icons_visible() const { return visible_icon_count_ == -1; }
 124
 125   bool extensions_initialized() const { return extensions_initialized_; }
 126
 127   const ExtensionList& toolbar_items() const {
 128     return is_highlighting() ? highlighted_items_ : toolbar_items_;
 129   }
 130
 131   bool is_highlighting() const { return highlight_type_ != HIGHLIGHT_NONE; }
 132   HighlightType highlight_type() const { return highlight_type_; }
 133
 134   void OnExtensionToolbarPrefChange();
 135
 136   // Returns the index of the given |id|, or -1 if the id wasn't found.
 137   int GetIndexForId(const std::string& id) const;
 138
 139   // Finds the Observer associated with |browser| and tells it to display a
 140   // popup for the given |extension|. If |grant_active_tab| is true, this
 141   // grants active tab permissions to the |extension|; only do this because of
 142   // a direct user action.
 143   bool ShowExtensionActionPopup(const Extension* extension,
 144                                 Browser* browser,
 145                                 bool grant_active_tab);
 146
 147   // Ensures that the extensions in the |extension_ids| list are visible on the
 148   // toolbar. This might mean they need to be moved to the front (if they are in
 149   // the overflow bucket).
 150   void EnsureVisibility(const ExtensionIdList& extension_ids);
 151
 152   // Highlights the extensions specified by |extension_ids|. This will cause
 153   // the ToolbarModel to only display those extensions.
 154   // Highlighting mode is only entered if there is at least one extension to
 155   // be shown.
 156   // Returns true if highlighting mode is entered, false otherwise.
 157   bool HighlightExtensions(const ExtensionIdList& extension_ids,
 158                            HighlightType type);
 159
 160   // Stop highlighting extensions. All extensions can be shown again, and the
 161   // number of visible icons will be reset to what it was before highlighting.
 162   void StopHighlighting();
 163
 164   // Returns true if the toolbar model is running with the redesign and is
 165   // showing new icons as a result.
 166   bool RedesignIsShowingNewIcons() const;
 167
 168  private:
 169   // Callback when extensions are ready.
 170   void OnReady();
 171
 172   // ExtensionRegistryObserver:
 173   void OnExtensionLoaded(content::BrowserContext* browser_context,
 174                          const Extension* extension) override;
 175   void OnExtensionUnloaded(content::BrowserContext* browser_context,
 176                            const Extension* extension,
 177                            UnloadedExtensionInfo::Reason reason) override;
 178   void OnExtensionUninstalled(content::BrowserContext* browser_context,
 179                               const Extension* extension,
 180                               extensions::UninstallReason reason) override;
 181
 182   // ExtensionActionAPI::Observer:
 183   void OnExtensionActionUpdated(
 184       ExtensionAction* extension_action,
 185       content::WebContents* web_contents,
 186       content::BrowserContext* browser_context) override;
 187   void OnExtensionActionVisibilityChanged(const std::string& extension_id,
 188                                           bool is_now_visible) override;
 189
 190   // To be called after the extension service is ready; gets loaded extensions
 191   // from the ExtensionRegistry and their saved order from the pref service
 192   // and constructs |toolbar_items_| from these data. IncognitoPopulate()
 193   // takes the shortcut - looking at the regular model's content and modifying
 194   // it.
 195   void InitializeExtensionList();
 196   void Populate(ExtensionIdList* positions);
 197   void IncognitoPopulate();
 198
 199   // Save the model to prefs.
 200   void UpdatePrefs();
 201
 202   // Updates |extension|'s browser action visibility pref if the browser action
 203   // is in the overflow menu and should be considered hidden.
 204   void MaybeUpdateVisibilityPref(const Extension* extension, size_t index);
 205
 206   // Calls MaybeUpdateVisibilityPref() for each extension in |toolbar_items|.
 207   void MaybeUpdateVisibilityPrefs();
 208
 209   // Finds the last known visible position of the icon for an |extension|. The
 210   // value returned is a zero-based index into the vector of visible items.
 211   size_t FindNewPositionFromLastKnownGood(const Extension* extension);
 212
 213   // Returns true if the given |extension| should be added to the toolbar.
 214   bool ShouldAddExtension(const Extension* extension);
 215
 216   // Adds or removes the given |extension| from the toolbar model.
 217   void AddExtension(const Extension* extension);
 218   void RemoveExtension(const Extension* extension);
 219
 220   // Our observers.
 221   base::ObserverList<Observer> observers_;
 222
 223   // The Profile this toolbar model is for.
 224   Profile* profile_;
 225
 226   ExtensionPrefs* extension_prefs_;
 227   PrefService* prefs_;
 228
 229   // The ExtensionActionAPI object, cached for convenience.
 230   ExtensionActionAPI* extension_action_api_;
 231
 232   // True if we've handled the initial EXTENSIONS_READY notification.
 233   bool extensions_initialized_;
 234
 235   // If true, we include all extensions in the toolbar model. If false, we only
 236   // include browser actions.
 237   bool include_all_extensions_;
 238
 239   // Ordered list of browser action buttons.
 240   ExtensionList toolbar_items_;
 241
 242   // List of browser action buttons which should be highlighted.
 243   ExtensionList highlighted_items_;
 244
 245   // The current type of highlight (with HIGHLIGHT_NONE indicating no current
 246   // highlight).
 247   HighlightType highlight_type_;
 248
 249   ExtensionIdList last_known_positions_;
 250
 251   // The number of icons visible (the rest should be hidden in the overflow
 252   // chevron). A value of -1 indicates that all icons should be visible.
 253   // Instead of using this variable directly, use visible_icon_count() if
 254   // possible.
 255   // TODO(devlin): Make a new variable to indicate that all icons should be
 256   // visible, instead of overloading this one.
 257   int visible_icon_count_;
 258
 259   ScopedObserver<ExtensionActionAPI, ExtensionActionAPI::Observer>
 260       extension_action_observer_;
 261
 262   // Listen to extension load, unloaded notifications.
 263   ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver>
 264       extension_registry_observer_;
 265
 266   // For observing change of toolbar order preference by external entity (sync).
 267   PrefChangeRegistrar pref_change_registrar_;
 268   base::Closure pref_change_callback_;
 269
 270   base::WeakPtrFactory<ExtensionToolbarModel> weak_ptr_factory_;
 271
 272   DISALLOW_COPY_AND_ASSIGN(ExtensionToolbarModel);
 273 };
 274
 275 }  // namespace extensions
 276
 277 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_TOOLBAR_MODEL_H_