Add infrastructure for Chrome Actions

chrome/browser/ui/views/toolbar/browser_actions_container.cc

 // Copyright 2013 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.
 
 #include "chrome/browser/ui/views/toolbar/browser_actions_container.h"
 
 #include "base/compiler_specific.h"
 #include "base/stl_util.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/view_ids.h"
 #include "chrome/browser/ui/views/extensions/browser_action_drag_data.h"
 #include "chrome/browser/ui/views/extensions/extension_popup.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/toolbar/browser_actions_container_observer.h"
+#include "chrome/browser/ui/views/toolbar/chrome_actions_registry.h"
 #include "chrome/browser/ui/views/toolbar/toolbar_view.h"
 #include "chrome/common/extensions/command.h"
 #include "chrome/grit/generated_resources.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/runtime_data.h"
 #include "extensions/common/feature_switch.h"
 #include "grit/theme_resources.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/base/dragdrop/drag_utils.h"
@@ skipping 93 matching lines @@
 }
 
 BrowserActionsContainer::~BrowserActionsContainer() {
   FOR_EACH_OBSERVER(BrowserActionsContainerObserver,
                     observers_,
                     OnBrowserActionsContainerDestroyed());
 
   if (model_)
     model_->RemoveObserver(this);
   HideActivePopup();
-  DeleteBrowserActionViews();
+  DeleteActionViews();
 }
 
 void BrowserActionsContainer::Init() {
   LoadImages();
 
   // We wait to set the container width until now so that the chevron images
   // will be loaded.  The width calculation needs to know the chevron size.
   if (model_ && model_->extensions_initialized()) {
     container_width_ = GetPreferredWidth();
     SetChevronVisibility();
   }
 
   initialized_ = true;
 }
 
 BrowserActionView* BrowserActionsContainer::GetViewForExtension(
     const Extension* extension) {
   for (BrowserActionView* view : browser_action_views_) {
-    if (view->extension() == extension)
+    if (view->GetExtensionActionViewController()->extension() == extension)
       return view;
   }
   return NULL;
 }
 
-void BrowserActionsContainer::RefreshBrowserActionViews() {
+const Extension* BrowserActionsContainer::GetExtensionAt(size_t index) const {
+  return browser_action_views_[index]->GetExtensionActionViewController()->
+      extension();
+}
+
+void BrowserActionsContainer::RefreshActionViews() {
   for (BrowserActionView* view : browser_action_views_)
     view->UpdateState();
+  for (BrowserActionView* view : chrome_action_views_)
+    view->UpdateState();
 }
 
-void BrowserActionsContainer::CreateBrowserActionViews() {
+void BrowserActionsContainer::CreateActionViews() {
   DCHECK(browser_action_views_.empty());
   if (!model_)
     return;
 
   extensions::ExtensionActionManager* action_manager =
       extensions::ExtensionActionManager::Get(profile_);
   const extensions::ExtensionList& toolbar_items = model_->toolbar_items();

[sky, 2014/10/15 23:52:30]

Seems like there should be one unified presentation of all the actions to be
shown and it seems like this code shouldn't need any extension specific bits.
That's an implementation of the specific action, right?

[Devlin, 2014/10/16 16:46:38]

In a perfect world, yes.  But that will lead to a much larger change - this
class interfaces with the ExtensionToolbarModel, which currently only manages
extensions.  We could potentially move most of the chrome action vs extension
action logic into there (maybe then we also need to move it out of
c/b/extensions), but it'll be a lot more code in an already-big patch.  Would
you like me to see what it'll take?  Or is there a simpler way to go about it?

[sky, 2014/10/16 18:13:39]

I think it's possible to do this incrementally. No doubt going down the route
I'm outlying is more patches than what you have here, but in the end it'll be a
cleaner API and not an API burdened by how things were initially. Strive for a
clean architecture.

[Devlin, 2014/10/16 22:05:27]

I'm curious what you think of Patch Set 3's approach.  I don't want to drag the
component actions into the extension toolbar model yet, because I think that
*would* result in a much larger and more confusing patch, but with Patch Set 3,
we're back to only having one set of views, and not treating them quite as
specially.

   for (const scoped_refptr<const Extension>& extension : toolbar_items) {
-    BrowserActionView* view =
-        new BrowserActionView(extension.get(),
-                              action_manager->GetExtensionAction(*extension),
-                              browser_,
-                              this);
+    BrowserActionView* view = new BrowserActionView(
+        make_scoped_ptr(new ExtensionActionViewController(
+            extension.get(),
+            browser_,
+            action_manager->GetExtensionAction(*extension),
+            NULL)),
+        BrowserActionView::TYPE_EXTENSION_ACTION,
+        browser_,
+        this);
     browser_action_views_.push_back(view);
     AddChildView(view);
   }
+
+  ScopedVector<ToolbarActionViewController> chrome_actions =
+      ChromeActionsRegistry::GetChromeActions();
+  DCHECK(extensions::FeatureSwitch::extension_action_redesign()->IsEnabled() ||
+         chrome_actions.empty());
+  for (ToolbarActionViewController* controller : chrome_actions) {
+    BrowserActionView* view = new BrowserActionView(
+        make_scoped_ptr(controller),
+        BrowserActionView::TYPE_CHROME_ACTION,
+        browser_,
+        this);
+    chrome_action_views_.push_back(view);
+    AddChildView(view);
+  }
+  chrome_actions.weak_clear();
 }
 
-void BrowserActionsContainer::DeleteBrowserActionViews() {
+void BrowserActionsContainer::DeleteActionViews() {
   HideActivePopup();
   STLDeleteElements(&browser_action_views_);
+  STLDeleteElements(&chrome_action_views_);
 }
 
 size_t BrowserActionsContainer::VisibleBrowserActions() const {
   size_t visible_actions = 0;
   for (const BrowserActionView* view : browser_action_views_) {
     if (view->visible())
       ++visible_actions;
   }
   return visible_actions;
 }
@@ skipping 52 matching lines @@
   DCHECK((!popup_owner_ && popup_owner) ||
          (popup_owner_ && !popup_owner));
   popup_owner_ = popup_owner;
 }
 
 void BrowserActionsContainer::HideActivePopup() {
   if (popup_owner_)
     popup_owner_->view_controller()->HidePopup();
 }
 
-BrowserActionView* BrowserActionsContainer::GetMainViewForExtension(
-    const Extension* extension) {
-  return in_overflow_mode() ?
-      main_container_->GetViewForExtension(extension) :
-      GetViewForExtension(extension);
+BrowserActionView* BrowserActionsContainer::GetMainViewForAction(
+    BrowserActionView* view) {
+  if (!in_overflow_mode())
+    return view;  // This is the main view.
+
+  // The overflow container and main container each have the same views and
+  // view indices, so we can return the view of the index that |view| has in
+  // this container.
+  bool is_extension_action =
+      view->type() == BrowserActionView::TYPE_EXTENSION_ACTION;
+  const BrowserActionViews& views =
+      is_extension_action ? browser_action_views_ : chrome_action_views_;
+  BrowserActionViews::const_iterator iter =
+      std::find(views.begin(), views.end(), view);
+  DCHECK(iter != views.end());
+  size_t index = iter - views.begin();
+  return is_extension_action ?
+      main_container_->browser_action_views_[index] :
+      main_container_->chrome_action_views_[index];
 }
 
 void BrowserActionsContainer::AddObserver(
     BrowserActionsContainerObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void BrowserActionsContainer::RemoveObserver(
     BrowserActionsContainerObserver* observer) {
   observers_.RemoveObserver(observer);
@@ skipping 33 matching lines @@
     icons_per_overflow_menu_row_ = (width - kItemSpacing) / IconWidth(true);
   return GetPreferredSize().height();
 }
 
 gfx::Size BrowserActionsContainer::GetMinimumSize() const {
   int min_width = std::min(MinimumNonemptyWidth(), IconCountToWidth(-1));
   return gfx::Size(min_width, IconHeight());
 }
 
 void BrowserActionsContainer::Layout() {
-  if (browser_action_views_.empty()) {
+  if (browser_action_views_.empty() && chrome_action_views_.empty()) {
     SetVisible(false);
     return;
   }
 
   SetVisible(true);
   if (resize_area_)
     resize_area_->SetBounds(0, 0, kItemSpacing, height());
 
   // If the icons don't all fit, show the chevron (unless suppressed).
   int max_x = GetPreferredSize().width();
   if (IconCountToWidth(-1) > max_x && !suppress_chevron_ && chevron_) {
     chevron_->SetVisible(true);
     gfx::Size chevron_size(chevron_->GetPreferredSize());
     max_x -= chevron_size.width() + kChevronSpacing;
     chevron_->SetBounds(
         width() - ToolbarView::kStandardSpacing - chevron_size.width(),
         0,
         chevron_size.width(),
         chevron_size.height());
   } else if (chevron_) {
     chevron_->SetVisible(false);
   }
 
+  // Construct a single vector of all views to draw to ease calculation (since
+  // this only copies pointers, it's cheap).
+  BrowserActionViews views(browser_action_views_.begin(),
+                           browser_action_views_.end());
+  views.insert(views.end(),
+               chrome_action_views_.begin(),
+               chrome_action_views_.end());
+
   // The padding before the first icon and after the last icon in the container.
   int container_padding =
       in_overflow_mode() ? kItemSpacing : ToolbarView::kStandardSpacing;
   // The range of visible icons, from start_index (inclusive) to end_index
   // (exclusive).
   size_t start_index = in_overflow_mode() ?
       main_container_->VisibleBrowserActionsAfterAnimation() : 0u;
   // For the main container's last visible icon, we calculate how many icons we
   // can display with the given width. We add an extra kItemSpacing because the
   // last icon doesn't need padding, but we want it to divide easily.
   size_t end_index = in_overflow_mode() ?
-      browser_action_views_.size() :
+      views.size() :
       (max_x - 2 * container_padding + kItemSpacing) / IconWidth(true);
   // The maximum length for one row of icons.
   size_t row_length =
       in_overflow_mode() ? icons_per_overflow_menu_row_ : end_index;
 
   // Now draw the icons for the browser actions in the available space. Once
   // all the variables are in place, the layout works equally well for the main
   // and overflow container.
-  for (size_t i = 0u; i < browser_action_views_.size(); ++i) {
-    BrowserActionView* view = browser_action_views_[i];
+  for (size_t i = 0u; i < views.size(); ++i) {
+    BrowserActionView* view = views[i];
     if (i < start_index || i >= end_index) {
       view->SetVisible(false);
     } else {
       size_t relative_index = i - start_index;
       size_t index_in_row = relative_index % row_length;
       size_t row_index = relative_index / row_length;
       view->SetBounds(container_padding + index_in_row * IconWidth(true),
                       row_index * IconHeight(),
                       IconWidth(false),
                       IconHeight());
@@ skipping 101 matching lines @@
   SchedulePaint();
 }
 
 int BrowserActionsContainer::OnPerformDrop(
     const ui::DropTargetEvent& event) {
   BrowserActionDragData data;
   if (!data.Read(event.data()))
     return ui::DragDropTypes::DRAG_NONE;
 
   // Make sure we have the same view as we started with.
-  DCHECK_EQ(browser_action_views_[data.index()]->extension()->id(),
-            data.id());
+  DCHECK_EQ(GetExtensionAt(data.index())->id(), data.id());
   DCHECK(model_);
 
   size_t i = drop_position_->row * icons_per_overflow_menu_row_ +
              drop_position_->icon_in_row;
   if (in_overflow_mode())
     i += main_container_->VisibleBrowserActionsAfterAnimation();
   // |i| now points to the item to the right of the drop indicator*, which is
   // correct when dragging an icon to the left. When dragging to the right,
   // however, we want the icon being dragged to get the index of the item to
   // the left of the drop indicator, so we subtract one.
   // * Well, it can also point to the end, but not when dragging to the left. :)
   if (i > data.index())
     --i;
 
   // If this was a drag between containers, we will have to adjust the number of
   // visible icons.
   bool drag_between_containers =
       !browser_action_views_[data.index()]->visible();
-  model_->MoveExtensionIcon(
-      browser_action_views_[data.index()]->extension(), i);
+  model_->MoveExtensionIcon(GetExtensionAt(data.index()), i);
 
   if (drag_between_containers) {
     // Let the main container update the model.
     if (in_overflow_mode())
       main_container_->NotifyActionMovedToOverflow();
     else  // This is the main container.
       model_->SetVisibleIconCount(model_->GetVisibleIconCount() + 1);
   }
 
   OnDragExited();  // Perform clean up after dragging.
   return ui::DragDropTypes::DRAG_MOVE;
 }
 
 void BrowserActionsContainer::GetAccessibleState(
     ui::AXViewState* state) {
   state->role = ui::AX_ROLE_GROUP;
   state->name = l10n_util::GetStringUTF16(IDS_ACCNAME_EXTENSIONS);
 }
 
 void BrowserActionsContainer::WriteDragDataForView(View* sender,
                                                    const gfx::Point& press_pt,
                                                    OSExchangeData* data) {
   DCHECK(data);
 
   BrowserActionViews::iterator iter = std::find(browser_action_views_.begin(),
                                                 browser_action_views_.end(),
                                                 sender);
   DCHECK(iter != browser_action_views_.end());
-  drag_utils::SetDragImageOnDataObject((*iter)->GetIconWithBadge(),
+  ExtensionActionViewController* view_controller =
+      (*iter)->GetExtensionActionViewController();
+  drag_utils::SetDragImageOnDataObject(view_controller->GetIconWithBadge(),
                                        press_pt.OffsetFromOrigin(),
                                        data);
   // Fill in the remaining info.
-  BrowserActionDragData drag_data((*iter)->extension()->id(),
+  BrowserActionDragData drag_data(view_controller->extension()->id(),
                                   iter - browser_action_views_.begin());
   drag_data.Write(profile_, data);
 }
 
 int BrowserActionsContainer::GetDragOperationsForView(View* sender,
                                                       const gfx::Point& p) {
   return ui::DragDropTypes::DRAG_MOVE;
 }
 
 bool BrowserActionsContainer::CanStartDragForView(View* sender,
@@ skipping 52 matching lines @@
 extensions::ActiveTabPermissionGranter*
     BrowserActionsContainer::GetActiveTabPermissionGranter() {
   content::WebContents* web_contents = GetCurrentWebContents();
   if (!web_contents)
     return NULL;
   return extensions::TabHelper::FromWebContents(web_contents)->
       active_tab_permission_granter();
 }
 
 ExtensionPopup* BrowserActionsContainer::TestGetPopup() {
-  return popup_owner_ ? popup_owner_->view_controller()->popup() : NULL;
+  return popup_owner_ ?
+      popup_owner_->GetExtensionActionViewController()->popup() :
+      NULL;
 }
 
 void BrowserActionsContainer::OnPaint(gfx::Canvas* canvas) {
   // If the views haven't been initialized yet, wait for the next call to
   // paint (one will be triggered by entering highlight mode).
   if (model_->is_highlighting() && !browser_action_views_.empty() &&
       !in_overflow_mode()) {
     views::Painter::PaintPainterAt(
         canvas, highlight_painter_.get(), GetLocalBounds());
   }
@@ skipping 52 matching lines @@
           browser_->profile(),
           parent()->GetFocusManager(),
           extensions::ExtensionKeybindingRegistry::ALL_EXTENSIONS,
           this));
     }
 
     // Initial toolbar button creation and placement in the widget hierarchy.
     // We do this here instead of in the constructor because AddBrowserAction
     // calls Layout on the Toolbar, which needs this object to be constructed
     // before its Layout function is called.
-    CreateBrowserActionViews();
+    CreateActionViews();
   }
 }
 
 // static
 int BrowserActionsContainer::IconWidth(bool include_padding) {
   static bool initialized = false;
   static int icon_width = 0;
   if (!initialized) {
     initialized = true;
     icon_width = ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
@@ skipping 20 matching lines @@
   for (size_t i = 0; i < browser_action_views_.size(); ++i) {
     DCHECK(browser_action_views_[i]->extension() != extension) <<
            "Asked to add a browser action view for an extension that already "
            "exists.";
   }
 #endif
   if (chevron_)
     chevron_->CloseMenu();
 
   // Add the new browser action to the vector and the view hierarchy.
-  BrowserActionView* view =
-      new BrowserActionView(extension,
-                            extensions::ExtensionActionManager::Get(profile_)->
-                                GetExtensionAction(*extension),
-                            browser_,
-                            this);
+  BrowserActionView* view = new BrowserActionView(
+      make_scoped_ptr(new ExtensionActionViewController(
+          extension,
+          browser_,
+          extensions::ExtensionActionManager::Get(profile_)->
+              GetExtensionAction(*extension),
+          NULL)),
+      BrowserActionView::TYPE_EXTENSION_ACTION,
+      browser_,
+      this);
   browser_action_views_.insert(browser_action_views_.begin() + index, view);
   AddChildViewAt(view, index);
 
   // If we are still initializing the container, don't bother animating.
   if (!model_->extensions_initialized())
     return;
 
   // If this is just an upgrade, then don't worry about resizing.
   if (!extensions::ExtensionSystem::Get(profile_)->runtime_data()->
           IsBeingUpgraded(extension)) {
@@ skipping 19 matching lines @@
 }
 
 void BrowserActionsContainer::ToolbarExtensionRemoved(
     const Extension* extension) {
   if (chevron_)
     chevron_->CloseMenu();
 
   size_t visible_actions = VisibleBrowserActionsAfterAnimation();
   for (BrowserActionViews::iterator i(browser_action_views_.begin());
        i != browser_action_views_.end(); ++i) {
-    if ((*i)->extension() == extension) {
+    if ((*i)->GetExtensionActionViewController()->extension() == extension) {
       delete *i;
       browser_action_views_.erase(i);
 
       // If the extension is being upgraded we don't want the bar to shrink
       // because the icon is just going to get re-added to the same location.
       if (extensions::ExtensionSystem::Get(profile_)->runtime_data()->
               IsBeingUpgraded(extension))
         return;
 
       if (browser_action_views_.size() > visible_actions) {
@@ skipping 13 matching lines @@
     }
   }
 }
 
 void BrowserActionsContainer::ToolbarExtensionMoved(const Extension* extension,
                                                     int index) {
   DCHECK(index >= 0 && index < static_cast<int>(browser_action_views_.size()));
 
   BrowserActionViews::iterator iter = browser_action_views_.begin();
   while (iter != browser_action_views_.end() &&
-         (*iter)->extension() != extension) {
+         (*iter)->GetExtensionActionViewController()->extension() != extension)
     ++iter;
-  }
 
   DCHECK(iter != browser_action_views_.end());
   if (iter - browser_action_views_.begin() == index)
     return;  // Already in place.
 
   BrowserActionView* moved_view = *iter;
   browser_action_views_.erase(iter);
   browser_action_views_.insert(
       browser_action_views_.begin() + index, moved_view);
 
   Layout();
   SchedulePaint();
 }
 
 void BrowserActionsContainer::ToolbarExtensionUpdated(
     const Extension* extension) {
   BrowserActionView* view = GetViewForExtension(extension);
   DCHECK(view);
   view->UpdateState();
 }
 
 bool BrowserActionsContainer::ShowExtensionActionPopup(
     const Extension* extension,
     bool grant_active_tab) {
   // Don't override another popup, and only show in the active window.
   if (popup_owner_ || !browser_->window()->IsActive())
     return false;
 
   BrowserActionView* view = GetViewForExtension(extension);
-  return view && view->view_controller()->ExecuteAction(ExtensionPopup::SHOW,
-                                                        grant_active_tab);
+  return view && view->GetExtensionActionViewController()->ExecuteAction(
+      ExtensionPopup::SHOW, grant_active_tab);
 }
 
 void BrowserActionsContainer::ToolbarVisibleCountChanged() {
   if (GetPreferredWidth() != container_width_)
     Animate(gfx::Tween::EASE_OUT, GetIconCount());
 }
 
 void BrowserActionsContainer::ToolbarHighlightModeChanged(
     bool is_highlighting) {
   // The visual highlighting is done in OnPaint(). It's a bit of a pain that
   // we delete and recreate everything here, but given everything else going on
   // (the lack of highlight, n more extensions appearing, etc), it's not worth
   // the extra complexity to create and insert only the new extensions.
-  DeleteBrowserActionViews();
-  CreateBrowserActionViews();
+  DeleteActionViews();
+  CreateActionViews();
   Animate(gfx::Tween::LINEAR, GetIconCount());
 }
 
 Browser* BrowserActionsContainer::GetBrowser() {
   return browser_;
 }
 
 void BrowserActionsContainer::LoadImages() {
   if (in_overflow_mode())
     return;  // Overflow mode has neither a chevron nor highlighting.
@@ skipping 100 matching lines @@
   // Good time for some sanity checks: We should never try to display more
   // icons than we have, and we should always have a view per item in the model.
   // (The only exception is if this is in initialization.)
   if (initialized_) {
     DCHECK_LE(absolute_model_visible_size, browser_action_views_.size());
     DCHECK_EQ(model_->toolbar_items().size(), browser_action_views_.size());
   }
 
   // The overflow displays any icons not shown by the main bar.
   return in_overflow_mode() ?
-      model_->toolbar_items().size() - absolute_model_visible_size :
+      model_->toolbar_items().size() - absolute_model_visible_size +
+          chrome_action_views_.size() :
       absolute_model_visible_size;
 }