Support Component Actions in the toolbar.

chrome/browser/ui/toolbar/toolbar_actions_bar.h

 // Copyright 2014 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_UI_TOOLBAR_TOOLBAR_ACTIONS_BAR_H_
 #define CHROME_BROWSER_UI_TOOLBAR_TOOLBAR_ACTIONS_BAR_H_
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/scoped_observer.h"
-#include "chrome/browser/extensions/extension_toolbar_model.h"
 #include "chrome/browser/ui/toolbar/toolbar_actions_bar_bubble_delegate.h"
+#include "chrome/browser/ui/toolbar/toolbar_actions_model.h"
 #include "ui/gfx/animation/tween.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace extensions {
 class Extension;
 class ExtensionMessageBubbleController;
 }
 
 namespace user_prefs {
 class PrefRegistrySyncable;
 }
 
 class ToolbarActionsBarDelegate;
 class ToolbarActionViewController;
 
 // A platform-independent version of the container for toolbar actions,
 // including extension actions and component actions.
 // This class manages the order of the actions, the actions' state, and owns the
-// action controllers, in addition to (for extensions) interfacing with the
-// extension toolbar model. Further, it manages dimensions for the bar,
-// excluding animations.
+// action controllers, in addition to interfacing with the toolbar actions
+// model. Further, it manages dimensions for the bar, excluding animations.
 // This can come in two flavors, main and "overflow". The main bar is visible
 // next to the omnibox, and the overflow bar is visible inside the chrome
-// (fka wrench) menu. The main bar can have only a single row of icons with
+// (aka wrench) menu. The main bar can have only a single row of icons with

[mark a. foltz, 2015/08/04 21:57:21]

Side comment: It's confusing that it's still called a wrench menu in the code. 
I prefer the name "hamburger" (versus "hotdog"), since most hot dogs the bun is
not the exact same length as the 'dog.  But I digress.

[Devlin, 2015/08/04 22:12:59]

The official name for the menu is now the "Chrome" menu, which is what the
comment says.  The fka wasn't a typo, it was "Formerly-known-as", because, well,
frankly, a bunch of us still call it the wrench menu, and don't know what the
"Chrome" menu is. ;)

[apacible, 2015/08/05 01:03:41]

Switched back to "fka".

 // flexible width, whereas the overflow bar has multiple rows of icons with a
 // fixed width (the width of the menu).
-class ToolbarActionsBar : public extensions::ExtensionToolbarModel::Observer {
+class ToolbarActionsBar : public ToolbarActionsModel::Observer {
  public:
   // A struct to contain the platform settings.
   struct PlatformSettings {
     explicit PlatformSettings(bool in_overflow_mode);
 
     // The padding that comes before the first icon in the container.
     int left_padding;
     // The padding following the final icon in the container.
     int right_padding;
     // The spacing between each of the icons.
@@ skipping 112 matching lines @@
   const std::vector<ToolbarActionViewController*>& toolbar_actions_unordered()
       const {
     return toolbar_actions_.get();
   }
   bool enabled() const { return model_ != nullptr; }
   bool suppress_layout() const { return suppress_layout_; }
   bool suppress_animation() const {
     return suppress_animation_ || disable_animations_for_testing_;
   }
   bool is_highlighting() const { return model_ && model_->is_highlighting(); }
-  extensions::ExtensionToolbarModel::HighlightType highlight_type() const {
+  ToolbarActionsModel::HighlightType highlight_type() const {
     return model_ ? model_->highlight_type()
-                  : extensions::ExtensionToolbarModel::HIGHLIGHT_NONE;
+                  : ToolbarActionsModel::HIGHLIGHT_NONE;
   }
   const PlatformSettings& platform_settings() const {
     return platform_settings_;
   }
   ToolbarActionViewController* popup_owner() { return popup_owner_; }
   ToolbarActionViewController* popped_out_action() {
     return popped_out_action_;
   }
   bool in_overflow_mode() const { return main_bar_ != nullptr; }
 
   ToolbarActionsBarDelegate* delegate_for_test() { return delegate_; }
 
   static void set_send_overflowed_action_changes_for_testing(
       bool send_overflowed_action_changes) {
     send_overflowed_action_changes_ = send_overflowed_action_changes;
   }
 
   // During testing we can disable animations by setting this flag to true,
   // so that the bar resizes instantly, instead of having to poll it while it
   // animates to open/closed status.
   static bool disable_animations_for_testing_;
 
  private:
   using ToolbarActions = ScopedVector<ToolbarActionViewController>;
 
-  // ExtensionToolbarModel::Observer:
-  void OnToolbarExtensionAdded(const extensions::Extension* extension,
-                               int index) override;
-  void OnToolbarExtensionRemoved(
-      const extensions::Extension* extension) override;
-  void OnToolbarExtensionMoved(const extensions::Extension* extension,
-                               int index) override;
-  void OnToolbarExtensionUpdated(
-      const extensions::Extension* extension) override;
-  bool ShowExtensionActionPopup(const extensions::Extension* extension,
-                                bool grant_active_tab) override;
+  // ToolbarActionsModel::Observer:
+  void OnToolbarActionAdded(const std::string& action_id, int index) override;
+  void OnToolbarActionRemoved(const std::string& action_id) override;
+  void OnToolbarActionMoved(const std::string& action_id, int index) override;
+  void OnToolbarActionUpdated(const std::string& action_id) override;
+  bool ShowToolbarActionPopup(const std::string& action_id,
+                              bool grant_active_tab) override;
   void OnToolbarVisibleCountChanged() override;
   void OnToolbarHighlightModeChanged(bool is_highlighting) override;
   void OnToolbarModelInitialized() override;
   Browser* GetBrowser() override;
 
   // Resizes the delegate (if necessary) to the preferred size using the given
   // |tween_type| and optionally suppressing the chevron.
   void ResizeDelegate(gfx::Tween::Type tween_type, bool suppress_chevron);
 
   // Returns the action for the given |id|, if one exists.
-  ToolbarActionViewController* GetActionForId(const std::string& id);
+  ToolbarActionViewController* GetActionForId(const std::string& action_id);
 
   // Returns the current web contents.
   content::WebContents* GetCurrentWebContents();
 
   // Reorders the toolbar actions to reflect the model and, optionally, to
   // "pop out" any overflowed actions that want to run (depending on the
   // value of |pop_out_actions_to_run|.
   void ReorderActions();
 
   // Sets |overflowed_action_wants_to_run_| to the proper value.
   void SetOverflowedActionWantsToRun();
 
   // Shows an extension message bubble, if any should be shown.
   void MaybeShowExtensionBubble(
       scoped_ptr<extensions::ExtensionMessageBubbleController> controller);
 
   // The delegate for this object (in a real build, this is the view).
   ToolbarActionsBarDelegate* delegate_;
 
   // The associated browser.
   Browser* browser_;
 
   // The observed toolbar model.
-  extensions::ExtensionToolbarModel* model_;
+  ToolbarActionsModel* model_;
 
   // The controller for the main toolbar actions bar. This will be null if this
   // is the main bar.
   ToolbarActionsBar* main_bar_;
 
   // Platform-specific settings for dimensions and the overflow chevron.
   PlatformSettings platform_settings_;
 
   // The toolbar actions.
   ToolbarActions toolbar_actions_;
 
+  // List of component action ids.
+  ActionIdList component_ids_;
+
   // The action that triggered the current popup (just a reference to an action
   // from toolbar_actions_).
   ToolbarActionViewController* popup_owner_;
 
-  ScopedObserver<extensions::ExtensionToolbarModel,
-                 extensions::ExtensionToolbarModel::Observer> model_observer_;
+  ScopedObserver<ToolbarActionsModel,
+                 ToolbarActionsModel::Observer> model_observer_;
 
   // True if we should suppress layout, such as when we are creating or
   // adjusting a lot of actions at once.
   bool suppress_layout_;
 
   // True if we should suppress animation; we do this when first creating the
   // toolbar, and also when switching tabs changes the state of the icons.
   bool suppress_animation_;
 
   // If this is true, actions that want to run (e.g., an extension's page
@@ skipping 24 matching lines @@
   // The controller of the bubble to show once animation finishes, if any.
   scoped_ptr<extensions::ExtensionMessageBubbleController>
       pending_extension_bubble_controller_;
 
   base::WeakPtrFactory<ToolbarActionsBar> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ToolbarActionsBar);
 };
 
 #endif  // CHROME_BROWSER_UI_TOOLBAR_TOOLBAR_ACTIONS_BAR_H_