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