Support Component Actions in the toolbar.

chrome/browser/ui/toolbar/toolbar_actions_bar.cc

 // 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.
 
 #include "chrome/browser/ui/toolbar/toolbar_actions_bar.h"
 
 #include "base/auto_reset.h"
 #include "base/location.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/extension_message_bubble_controller.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/extensions/extension_action_view_controller.h"
 #include "chrome/browser/ui/extensions/extension_message_bubble_factory.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/toolbar/component_toolbar_actions_factory.h"
 #include "chrome/browser/ui/toolbar/toolbar_action_view_controller.h"
 #include "chrome/browser/ui/toolbar/toolbar_actions_bar_delegate.h"
 #include "chrome/common/pref_names.h"
 #include "components/crx_file/id_util.h"
 #include "components/pref_registry/pref_registry_syncable.h"
+#include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/runtime_data.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/feature_switch.h"
 #include "grit/theme_resources.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/image/image_skia.h"
 
 namespace {
 
@@ skipping 74 matching lines @@
       icons_per_overflow_menu_row(1),
       chevron_enabled(!extensions::FeatureSwitch::extension_action_redesign()->
                           IsEnabled()) {
 }
 
 ToolbarActionsBar::ToolbarActionsBar(ToolbarActionsBarDelegate* delegate,
                                      Browser* browser,
                                      ToolbarActionsBar* main_bar)
     : delegate_(delegate),
       browser_(browser),
-      model_(extensions::ExtensionToolbarModel::Get(browser_->profile())),
+      model_(ToolbarActionsModel::Get(browser_->profile())),
       main_bar_(main_bar),
       platform_settings_(main_bar != nullptr),
       popup_owner_(nullptr),
       model_observer_(this),
       suppress_layout_(false),
       suppress_animation_(true),
       overflowed_action_wants_to_run_(false),
       checked_extension_bubble_(false),
       popped_out_action_(nullptr),
       weak_ptr_factory_(this) {
@@ skipping 118 matching lines @@
   // want to "slide" the action back in.
   size_t visible_icons = in_overflow_mode() ?
       toolbar_actions_.size() - model_->visible_icon_count() :
       model_->visible_icon_count() + pop_out_modifier;
 
 #if DCHECK_IS_ON()
   // 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 (!toolbar_actions_.empty() && !suppress_layout_ &&
-      model_->extensions_initialized()) {
+      model_->actions_initialized()) {
     size_t num_extension_actions = 0u;
     for (ToolbarActionViewController* action : toolbar_actions_) {
       // No component action should ever have a valid extension id, so we can
       // use this to check the extension amount.
       if (crx_file::id_util::IdIsValid(action->GetId()))
         ++num_extension_actions;
     }
 
     int num_component_actions =
         ComponentToolbarActionsFactory::GetInstance()->
             GetNumComponentActions(browser_);
     size_t num_total_actions = num_extension_actions + num_component_actions;
 
     DCHECK_LE(visible_icons, num_total_actions);
-    DCHECK_EQ(model_->toolbar_items().size(), num_extension_actions);
+    DCHECK_EQ(model_->toolbar_items().size(), num_total_actions);
   }
 #endif
 
   return visible_icons;
 }
 
 std::vector<ToolbarActionViewController*>
 ToolbarActionsBar::GetActions() const {
   std::vector<ToolbarActionViewController*> actions = toolbar_actions_.get();
 
@@ skipping 13 matching lines @@
     }
   }
 
   return actions;
 }
 
 void ToolbarActionsBar::CreateActions() {
   DCHECK(toolbar_actions_.empty());
   // We wait for the extension system to be initialized before we add any
   // actions, as they rely on the extension system to function.
-  if (!model_ || !model_->extensions_initialized())
+  if (!model_ || !model_->actions_initialized())
     return;
 
   {
     // TODO(robliao): Remove ScopedTracker below once https://crbug.com/463337
     // is fixed.
     tracked_objects::ScopedTracker tracking_profile1(
         FROM_HERE_WITH_EXPLICIT_FUNCTION("ToolbarActionsBar::CreateActions1"));
     // We don't redraw the view while creating actions.
     base::AutoReset<bool> layout_resetter(&suppress_layout_, true);
 
-    // 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 extensions::Extension>& extension :
-             toolbar_items) {
-      toolbar_actions_.push_back(new ExtensionActionViewController(
-          extension.get(),
-          browser_,
-          action_manager->GetExtensionAction(*extension),
-          this));
-    }
+    // Get the toolbar actions.
+    toolbar_actions_ = model_->GetActions(browser_, this);
 
-    // Component actions come second, and are suppressed if the extension
-    // actions are being highlighted.
     if (!model_->is_highlighting()) {
       // TODO(robliao): Remove ScopedTracker below once https://crbug.com/463337
       // is fixed.
       tracked_objects::ScopedTracker tracking_profile2(
           FROM_HERE_WITH_EXPLICIT_FUNCTION(
               "ToolbarActionsBar::CreateActions2"));
-
-      ScopedVector<ToolbarActionViewController> component_actions =
-          ComponentToolbarActionsFactory::GetInstance()->
-              GetComponentToolbarActions(browser_);
-      DCHECK(component_actions.empty() ||
-          extensions::FeatureSwitch::extension_action_redesign()->IsEnabled());
-      toolbar_actions_.insert(toolbar_actions_.end(),
-                              component_actions.begin(),
-                              component_actions.end());
-      component_actions.weak_clear();
     }
 
     if (!toolbar_actions_.empty()) {
       // TODO(robliao): Remove ScopedTracker below once https://crbug.com/463337
       // is fixed.
       tracked_objects::ScopedTracker tracking_profile3(
           FROM_HERE_WITH_EXPLICIT_FUNCTION(
               "ToolbarActionsBar::CreateActions3"));
       ReorderActions();
     }
@@ skipping 69 matching lines @@
   if (in_overflow_mode()) {
     main_bar_->OnDragDrop(dragged_index, dropped_index, drag_type);
     return;
   }
 
   int delta = 0;
   if (drag_type == DRAG_TO_OVERFLOW)
     delta = -1;
   else if (drag_type == DRAG_TO_MAIN)
     delta = 1;
-  model_->MoveExtensionIcon(toolbar_actions_[dragged_index]->GetId(),
+  model_->MoveActionIcon(toolbar_actions_[dragged_index]->GetId(),
                             dropped_index);
   if (delta)
     model_->SetVisibleIconCount(model_->visible_icon_count() + delta);
 }
 
 void ToolbarActionsBar::OnAnimationEnded() {
   // Check if we were waiting for animation to complete to either show a
   // message bubble, or to show a popup.
   if (pending_extension_bubble_controller_) {
     MaybeShowExtensionBubble(pending_extension_bubble_controller_.Pass());
@@ skipping 64 matching lines @@
 }
 
 void ToolbarActionsBar::MaybeShowExtensionBubble(
     scoped_ptr<extensions::ExtensionMessageBubbleController> controller) {
   controller->HighlightExtensionsIfNecessary();  // Safe to call multiple times.
   if (delegate_->IsAnimating()) {
     // If the toolbar is animating, we can't effectively anchor the bubble,
     // so wait until animation stops.
     pending_extension_bubble_controller_ = controller.Pass();
   } else {
-    const extensions::ExtensionIdList& affected_extensions =
-        controller->GetExtensionIdList();
+    const ActionIdList& affected_extensions = controller->GetExtensionIdList();
     ToolbarActionViewController* anchor_action = nullptr;
     for (const std::string& id : affected_extensions) {
       anchor_action = GetActionForId(id);
       if (anchor_action)
         break;
     }
     delegate_->ShowExtensionMessageBubble(controller.Pass(), anchor_action);
   }
 }
 
-void ToolbarActionsBar::OnToolbarExtensionAdded(
-    const extensions::Extension* extension,
-    int index) {
-  DCHECK(GetActionForId(extension->id()) == nullptr) <<
+void ToolbarActionsBar::OnToolbarActionAdded(const std::string& action_id,
+                                             int index) {
+  DCHECK(GetActionForId(action_id) == nullptr) <<
       "Asked to add a toolbar action view for an extension that already exists";
 
+  // Check that |action_id| is not a component action since
+  // OnToolbarActionAdded is only called after the toolbar model has been
+  // initialized.
+  if (model_->IsKnownActionWithType(action_id,
+      ToolbarActionsModel::ACTION_COMPONENT))
+    return;
+
+  const extensions::Extension* extension =
+      extensions::ExtensionRegistry::Get(browser_->profile())->
+          enabled_extensions().GetByID(action_id);
+
   toolbar_actions_.insert(
       toolbar_actions_.begin() + index,
       new ExtensionActionViewController(
           extension,
           browser_,
           extensions::ExtensionActionManager::Get(browser_->profile())->
               GetExtensionAction(*extension),
           this));
 
   delegate_->AddViewForAction(toolbar_actions_[index], index);
 
   // If we are still initializing the container, don't bother animating.
-  if (!model_->extensions_initialized())
+  if (!model_->actions_initialized())
     return;
 
   // We may need to resize (e.g. to show the new icon, or the chevron). We don't
   // need to check if the extension is upgrading here, because ResizeDelegate()
   // checks to see if the container is already the proper size, and because
   // if the action is newly incognito enabled, even though it's a reload, it's
   // a new extension to this toolbar.
   // We suppress the chevron during animation because, if we're expanding to
   // show a new icon, we don't want to have the chevron visible only for the
   // duration of the animation.
   ResizeDelegate(gfx::Tween::LINEAR, true);
 }
 
-void ToolbarActionsBar::OnToolbarExtensionRemoved(
-    const extensions::Extension* extension) {
+void ToolbarActionsBar::OnToolbarActionRemoved(const std::string& action_id) {
   ToolbarActions::iterator iter = toolbar_actions_.begin();
-  while (iter != toolbar_actions_.end() && (*iter)->GetId() != extension->id())
+  while (iter != toolbar_actions_.end() && (*iter)->GetId() != action_id)
     ++iter;
 
   if (iter == toolbar_actions_.end())
     return;
 
+  // Component actions cannot be removed.
+  if (model_->IsKnownActionWithType(action_id,
+      ToolbarActionsModel::ACTION_COMPONENT))
+    return;
+
   // The action should outlive the UI element (which is owned by the delegate),
   // so we can't delete it just yet. But we should remove it from the list of
   // actions so that any width calculations are correct.
   scoped_ptr<ToolbarActionViewController> removed_action(*iter);
   toolbar_actions_.weak_erase(iter);
   delegate_->RemoveViewForAction(removed_action.get());
   removed_action.reset();
 
   // 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.
   // There is an exception if this is an off-the-record profile, and the
   // extension is no longer incognito-enabled.
   if (!extensions::ExtensionSystem::Get(browser_->profile())->runtime_data()->
-            IsBeingUpgraded(extension->id()) ||
+            IsBeingUpgraded(action_id) ||
       (browser_->profile()->IsOffTheRecord() &&
-       !extensions::util::IsIncognitoEnabled(extension->id(),
+       !extensions::util::IsIncognitoEnabled(action_id,
                                              browser_->profile()))) {
     if (toolbar_actions_.size() > model_->visible_icon_count()) {
       // If we have more icons than we can show, then we must not be changing
       // the container size (since we either removed an icon from the main
       // area and one from the overflow list will have shifted in, or we
       // removed an entry directly from the overflow list).
       delegate_->Redraw(false);
     } else {
       delegate_->SetChevronVisibility(false);
       // Either we went from overflow to no-overflow, or we shrunk the no-
       // overflow container by 1.  Either way the size changed, so animate.
       ResizeDelegate(gfx::Tween::EASE_OUT, false);
     }
   }
 
   SetOverflowedActionWantsToRun();
 }
 
-void ToolbarActionsBar::OnToolbarExtensionMoved(
-    const extensions::Extension* extension,
-    int index) {
+void ToolbarActionsBar::OnToolbarActionMoved(const std::string& action_id,
+                                             int index) {
   DCHECK(index >= 0 && index < static_cast<int>(toolbar_actions_.size()));
   // Unfortunately, |index| doesn't really mean a lot to us, because this
   // window's toolbar could be different (if actions are popped out). Just
   // do a full reorder.
   ReorderActions();
 }
 
-void ToolbarActionsBar::OnToolbarExtensionUpdated(
-    const extensions::Extension* extension) {
-  ToolbarActionViewController* action = GetActionForId(extension->id());
+void ToolbarActionsBar::OnToolbarActionUpdated(const std::string& action_id) {
+  ToolbarActionViewController* action = GetActionForId(action_id);
   // There might not be a view in cases where we are highlighting or if we
   // haven't fully initialized the actions.
   if (action) {
     action->UpdateState();
     SetOverflowedActionWantsToRun();
   }
 }
 
-bool ToolbarActionsBar::ShowExtensionActionPopup(
-    const extensions::Extension* extension,
-    bool grant_active_tab) {
+bool ToolbarActionsBar::ShowToolbarActionPopup(const std::string& action_id,
+                                               bool grant_active_tab) {
   // Don't override another popup, and only show in the active window.
   if (popup_owner() || !browser_->window()->IsActive())
     return false;
 
-  ToolbarActionViewController* action = GetActionForId(extension->id());
+  ToolbarActionViewController* action = GetActionForId(action_id);
   return action && action->ExecuteAction(grant_active_tab);
 }
 
 void ToolbarActionsBar::OnToolbarVisibleCountChanged() {
   ResizeDelegate(gfx::Tween::EASE_OUT, false);
   SetOverflowedActionWantsToRun();
 }
 
 void ToolbarActionsBar::ResizeDelegate(gfx::Tween::Type tween_type,
                                        bool suppress_chevron) {
   int desired_width = GetPreferredSize().width();
   if (desired_width != delegate_->GetWidth()) {
     delegate_->ResizeAndAnimate(tween_type, desired_width, suppress_chevron);
   } else if (delegate_->IsAnimating()) {
     // It's possible that we're right where we're supposed to be in terms of
     // width, but that we're also currently resizing. If this is the case, end
     // the current animation with the current width.
     delegate_->StopAnimating();
   } else {
     // We may already be at the right size (this can happen frequently with
     // overflow, where we have a fixed width, and in tests, where we skip
     // animations). If this is the case, we still need to Redraw(), because the
     // icons within the toolbar may have changed (e.g. if we removed one
     // action and added a different one in quick succession).
     delegate_->Redraw(false);
   }
 }
 
 void ToolbarActionsBar::OnToolbarHighlightModeChanged(bool is_highlighting) {
-  if (!model_->extensions_initialized())
+  if (!model_->actions_initialized())
     return;
   // 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 actions.
   DeleteActions();
   CreateActions();
   // Resize the delegate. We suppress the chevron so that we don't risk showing
   // it only for the duration of the animation.
   ResizeDelegate(gfx::Tween::LINEAR, true);
@@ skipping 15 matching lines @@
 Browser* ToolbarActionsBar::GetBrowser() {
   return browser_;
 }
 
 void ToolbarActionsBar::ReorderActions() {
   if (toolbar_actions_.empty())
     return;
 
   // First, reset the order to that of the model.
   auto compare = [](ToolbarActionViewController* const& action,
-                    const scoped_refptr<const extensions::Extension>& ext) {
-    return action->GetId() == ext->id();
+                    const std::string ext) {
+    return action->GetId() == ext;
   };
   SortContainer(&toolbar_actions_.get(), model_->toolbar_items(), compare);
 
   // Our visible browser actions may have changed - re-Layout() and check the
   // size (if we aren't suppressing the layout).
   if (!suppress_layout_) {
     ResizeDelegate(gfx::Tween::EASE_OUT, false);
     delegate_->Redraw(true);
   }
 
@@ skipping 14 matching lines @@
 
   if (overflowed_action_wants_to_run_ != overflowed_action_wants_to_run) {
     overflowed_action_wants_to_run_ = overflowed_action_wants_to_run;
     if (send_overflowed_action_changes_)
       delegate_->OnOverflowedActionWantsToRunChanged(
           overflowed_action_wants_to_run_);
   }
 }
 
 ToolbarActionViewController* ToolbarActionsBar::GetActionForId(
-    const std::string& id) {
+    const std::string& action_id) {
   for (ToolbarActionViewController* action : toolbar_actions_) {
-    if (action->GetId() == id)
+    if (action->GetId() == action_id)
       return action;
   }
   return nullptr;
 }
 
 content::WebContents* ToolbarActionsBar::GetCurrentWebContents() {
   return browser_->tab_strip_model()->GetActiveWebContents();
 }