Make extensions that desire to act pop out if in overflow

chrome/browser/extensions/extension_toolbar_model.h

 // Copyright (c) 2012 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_TOOLBAR_MODEL_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_TOOLBAR_MODEL_H_
 
 #include "base/compiler_specific.h"
 #include "base/observer_list.h"
 #include "base/prefs/pref_change_registrar.h"
@@ skipping 23 matching lines @@
  public:
   ExtensionToolbarModel(Profile* profile, ExtensionPrefs* extension_prefs);
   ~ExtensionToolbarModel() override;
 
   // A class which is informed of changes to the model; represents the view of
   // MVC. Also used for signaling view changes such as showing extension popups.
   // TODO(devlin): Should this really be an observer? It acts more like a
   // delegate.
   class Observer {
    public:
-    // An extension has been added to the toolbar and should go at |index|.
+    // TODO(devlin): Rename these methods to be OnFoo.
+    // Signals that an |extension| has been added to the toolbar at |index|.
     virtual void ToolbarExtensionAdded(const Extension* extension,
                                        int index) = 0;
 
-    // The given |extension| should be removed from the toolbar.
+    // Signals that the given |extension| has been removed from the toolbar.
     virtual void ToolbarExtensionRemoved(const Extension* extension) = 0;
 
-    // The given |extension| has been moved to |index|. |index| is the desired
-    // *final* index of the extension (that is, in the adjusted order, extension
-    // should be at |index|).
+    // Signals that the given |extension| has been moved to |index|. |index| is
+    // the desired *final* index of the extension (that is, in the adjusted
+    // order, extension should be at |index|).
     virtual void ToolbarExtensionMoved(const Extension* extension,
                                        int index) = 0;
 
     // Signals that the browser action for the given |extension| has been
     // updated.
     virtual void ToolbarExtensionUpdated(const Extension* extension) = 0;
 
-    // Signal the |extension| to show the popup now in the active window.
+    // Signals the |extension| to show the popup now in the active window.
     // If |grant_active_tab| is true, then active tab permissions should be
     // given to the extension (only do this if this is through a user action).
     // Returns true if a popup was slated to be shown.
     virtual bool ShowExtensionActionPopup(const Extension* extension,
                                           bool grant_active_tab) = 0;
 
-    // Signal when the container needs to be redrawn because of a size change,
+    // Signals when the container needs to be redrawn because of a size change,
     // and when the model has finished loading.
     virtual void ToolbarVisibleCountChanged() = 0;
 
-    // Signal that the model has entered or exited highlighting mode, or that
+    // Signals that the model has entered or exited highlighting mode, or that
     // the extensions being highlighted have (probably*) changed. Highlighting
     // mode indicates that only a subset of the extensions are actively
     // displayed, and those extensions should be highlighted for extra emphasis.
     // * probably, because if we are in highlight mode and receive a call to
     //   highlight a new set of extensions, we do not compare the current set
     //   with the new set (and just assume the new set is different).
     virtual void ToolbarHighlightModeChanged(bool is_highlighting) = 0;
 
+    // Signals that the toolbar needs to be reordered for the given
+    // |web_contents|. This is caused by an overflowed action wanting to run,
+    // and needing to "pop itself out".
+    virtual void OnToolbarReorderNecessary(
+        content::WebContents* web_contents) = 0;
+
     // Returns the browser associated with the Observer.
     virtual Browser* GetBrowser() = 0;
 
    protected:
     virtual ~Observer() {}
   };
 
   // Convenience function to get the ExtensionToolbarModel for a Profile.
   static ExtensionToolbarModel* Get(Profile* profile);
 
-  // Add or remove an observer.
+  // Adds or removes an observer.
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
 
   // Moves the given |extension|'s icon to the given |index|.
   void MoveExtensionIcon(const std::string& id, size_t index);
 
   // Sets the number of extension icons that should be visible.
   // If count == size(), this will set the visible icon count to -1, meaning
   // "show all actions".
-  void SetVisibleIconCount(int count);
+  void SetVisibleIconCount(size_t count);
 
-  // As above, a return value of -1 represents "show all actions".
-  int GetVisibleIconCount() const { return visible_icon_count_; }
+  // Returns the number of visible icons.
+  size_t visible_icon_count() const {
+    return visible_icon_count_ == -1 ?
+        toolbar_items().size() : static_cast<size_t>(visible_icon_count_);

[Peter Kasting, 2014/10/31 19:01:08]

Nit: So... now that we have both these accessors, would it make sense to just
have two members as well?  That eliminates the casting here, and my hope is that
it would make the usage within the class more consistent and less confusing (but
maybe not).

[Devlin, 2014/10/31 20:49:30]

Yeah, I was thinking the same thing, but I'll postpone that for another patch
(hopefully Monday).  It'll need a little more work, and we'll need to be careful
since we also use the visible icon count in saved preferences.

Added a TODO.

+  }
+
+  bool all_icons_visible() const { return visible_icon_count_ == -1; }
 
   bool extensions_initialized() const { return extensions_initialized_; }
 
   const ExtensionList& toolbar_items() const {
     return is_highlighting_ ? highlighted_items_ : toolbar_items_;
   }
 
   bool is_highlighting() const { return is_highlighting_; }
 
   void OnExtensionToolbarPrefChange();
 
+  // Returns the item order for a given tab. This can be different from the
+  // base item order if the action wants to run on the given page, and needs to
+  // be popped out of overflow.
+  ExtensionList GetItemOrderForTab(content::WebContents* web_contents) const;
+
+  // Returns the visible icon count for a given tab. This can be different from
+  // the base item order if the action wants to run on the given page and needs
+  // to be popped out of overflow.
+  size_t GetVisibleIconCountForTab(content::WebContents* web_contents) const;
+
   // Finds the Observer associated with |browser| and tells it to display a
   // popup for the given |extension|. If |grant_active_tab| is true, this
   // grants active tab permissions to the |extension|; only do this because of
   // a direct user action.
   bool ShowExtensionActionPopup(const Extension* extension,
                                 Browser* browser,
                                 bool grant_active_tab);
 
   // Ensures that the extensions in the |extension_ids| list are visible on the
   // toolbar. This might mean they need to be moved to the front (if they are in
   // the overflow bucket).
   void EnsureVisibility(const ExtensionIdList& extension_ids);
 
-  // Highlight the extensions specified by |extension_ids|. This will cause
+  // Highlights the extensions specified by |extension_ids|. This will cause
   // the ToolbarModel to only display those extensions.
   // Highlighting mode is only entered if there is at least one extension to
   // be shown.
   // Returns true if highlighting mode is entered, false otherwise.
   bool HighlightExtensions(const ExtensionIdList& extension_ids);
 
   // Stop highlighting extensions. All extensions can be shown again, and the
   // number of visible icons will be reset to what it was before highlighting.
   void StopHighlighting();
 
@@ skipping 82 matching lines @@
   // if we are exiting highlight mode due to no longer having highlighted items.
   bool is_highlighting_;
 
   // The number of icons which were visible before highlighting a subset, in
   // order to restore the count when finished.
   int old_visible_icon_count_;
 
   ExtensionIdList last_known_positions_;
 
   // The number of icons visible (the rest should be hidden in the overflow
-  // chevron).
+  // chevron). A value of -1 indicates that all icons should be visible.
   int visible_icon_count_;
 
   content::NotificationRegistrar registrar_;
 
   ScopedObserver<ExtensionActionAPI, ExtensionActionAPI::Observer>
       extension_action_observer_;
 
   // Listen to extension load, unloaded notifications.
   ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver>
       extension_registry_observer_;
 
   // For observing change of toolbar order preference by external entity (sync).
   PrefChangeRegistrar pref_change_registrar_;
   base::Closure pref_change_callback_;
 
   base::WeakPtrFactory<ExtensionToolbarModel> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionToolbarModel);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_TOOLBAR_MODEL_H_