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/toolbar/component_toolbar_actions_factory.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_action_view_controller.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/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"
@@ skipping 12 matching lines @@
 #include "ui/views/painter.h"
 #include "ui/views/widget/widget.h"
 
 using extensions::Extension;
 
 namespace {
 
 // Horizontal spacing before the chevron (if visible).
 const int kChevronSpacing = ToolbarView::kStandardSpacing - 2;
 
+// Returns the set of controllers for all actions.
+// TODO(devlin): We should move this to the model, once it supports component
+// actions.
+ScopedVector<ToolbarActionViewController> GetToolbarActions(
+    extensions::ExtensionToolbarModel* model,
+    Browser* browser) {
+  ScopedVector<ToolbarActionViewController> actions;
+
+  // Extension actions come first.
+  extensions::ExtensionActionManager* action_manager =
+      extensions::ExtensionActionManager::Get(browser->profile());
+  const extensions::ExtensionList& toolbar_items = model->toolbar_items();
+  for (const scoped_refptr<const Extension>& extension : toolbar_items) {
+    actions.push_back(new ExtensionActionViewController(
+        extension.get(),
+        browser,
+        action_manager->GetExtensionAction(*extension)));
+  }
+
+  // Component actions come second.
+  ScopedVector<ToolbarActionViewController> component_actions =
+      ComponentToolbarActionsFactory::GetInstance()->
+          GetComponentToolbarActions();
+  DCHECK(extensions::FeatureSwitch::extension_action_redesign()->IsEnabled() ||
+         component_actions.empty());
+  actions.insert(
+      actions.end(), component_actions.begin(), component_actions.end());
+  component_actions.weak_clear();
+  return actions.Pass();
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // BrowserActionsContainer::DropPosition
 
 struct BrowserActionsContainer::DropPosition {
   DropPosition(size_t row, size_t icon_in_row);
 
   // The (0-indexed) row into which the action will be dropped.
   size_t row;
@@ skipping 83 matching lines @@
     container_width_ = GetPreferredWidth();
     SetChevronVisibility();
   }
 
   initialized_ = true;
 }
 
 BrowserActionView* BrowserActionsContainer::GetViewForExtension(
     const Extension* extension) {
   for (BrowserActionView* view : browser_action_views_) {
-    if (view->extension() == extension)
+    if (view->view_controller()->GetType() ==
+            ToolbarActionViewController::TYPE_EXTENSION_ACTION &&
+        view->GetExtensionActionViewController()->extension() == extension)
       return view;
   }
   return NULL;
 }
 
+const Extension* BrowserActionsContainer::GetExtensionAt(size_t index) const {
+  DCHECK_EQ(ToolbarActionViewController::TYPE_EXTENSION_ACTION,
+            browser_action_views_[index]->view_controller()->GetType());
+  return browser_action_views_[index]->GetExtensionActionViewController()->
+      extension();
+}
+
 void BrowserActionsContainer::RefreshBrowserActionViews() {
   for (BrowserActionView* view : browser_action_views_)
     view->UpdateState();
 }
 
 void BrowserActionsContainer::CreateBrowserActionViews() {
   DCHECK(browser_action_views_.empty());
   if (!model_)
     return;
 
-  extensions::ExtensionActionManager* action_manager =
-      extensions::ExtensionActionManager::Get(profile_);
-  const extensions::ExtensionList& toolbar_items = model_->toolbar_items();
-  for (const scoped_refptr<const Extension>& extension : toolbar_items) {
+  ScopedVector<ToolbarActionViewController> actions =
+      GetToolbarActions(model_, browser_);
+  for (ToolbarActionViewController* controller : actions) {
     BrowserActionView* view =
-        new BrowserActionView(extension.get(),
-                              action_manager->GetExtensionAction(*extension),
-                              browser_,
-                              this);
+        new BrowserActionView(make_scoped_ptr(controller), browser_, this);
     browser_action_views_.push_back(view);
     AddChildView(view);
   }
+  actions.weak_clear();
 }
 
 void BrowserActionsContainer::DeleteBrowserActionViews() {
   HideActivePopup();
   STLDeleteElements(&browser_action_views_);
 }
 
 size_t BrowserActionsContainer::VisibleBrowserActions() const {
   size_t visible_actions = 0;
   for (const BrowserActionView* view : browser_action_views_) {
@@ skipping 57 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.
+  BrowserActionViews::const_iterator iter =
+      std::find(browser_action_views_.begin(),
+                browser_action_views_.end(),
+                view);
+  DCHECK(iter != browser_action_views_.end());
+  size_t index = iter - browser_action_views_.begin();
+  return main_container_->browser_action_views_[index];
 }
 
 void BrowserActionsContainer::AddObserver(
     BrowserActionsContainerObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void BrowserActionsContainer::RemoveObserver(
     BrowserActionsContainerObserver* observer) {
   observers_.RemoveObserver(observer);
@@ skipping 200 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 93 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))),
+      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
@@ skipping 105 matching lines @@
 
 size_t BrowserActionsContainer::GetIconCount() const {
   if (!model_)
     return 0u;
 
   // Find the absolute value for the model's visible count.
   int model_visible_size = model_->GetVisibleIconCount();
   size_t absolute_model_visible_size = model_visible_size == -1 ?
       model_->toolbar_items().size() : model_visible_size;
 
+#if defined(DEBUG)
   // 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_) {
+    size_t num_extension_actions = 0u;
+    for (const BrowserActionView* view : browser_action_views_) {
+      num_extension_actions +=
+          view->view_controller()->GetType() ==
+              ToolbarActionViewController::TYPE_EXTENSION_ACTION ? 1 : 0;
+    }
     DCHECK_LE(absolute_model_visible_size, browser_action_views_.size());
     DCHECK_EQ(model_->toolbar_items().size(), browser_action_views_.size());
   }
+#endif
 
   // The overflow displays any icons not shown by the main bar.
   return in_overflow_mode() ?
       model_->toolbar_items().size() - absolute_model_visible_size :
       absolute_model_visible_size;
 }