[Extensions UI] Use the ExtensionMessageBubbleBridge for Views platforms

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 <utility>
 
 #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_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_bridge.h"
 #include "chrome/browser/ui/extensions/extension_message_bubble_factory.h"
 #include "chrome/browser/ui/layout_constants.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/browser/ui/toolbar/toolbar_actions_bar_observer.h"
 #include "chrome/common/pref_names.h"
 #include "components/crx_file/id_util.h"
 #include "components/pref_registry/pref_registry_syncable.h"
@@ skipping 87 matching lines @@
       main_bar_(main_bar),
       platform_settings_(),
       popup_owner_(nullptr),
       model_observer_(this),
       suppress_layout_(false),
       suppress_animation_(true),
       checked_extension_bubble_(false),
       is_drag_in_progress_(false),
       popped_out_action_(nullptr),
       is_popped_out_sticky_(false),
+      is_showing_bubble_(false),
       weak_ptr_factory_(this) {
   if (model_)  // |model_| can be null in unittests.
     model_observer_.Add(model_);
 }
 
 ToolbarActionsBar::~ToolbarActionsBar() {
   // We don't just call DeleteActions() here because it makes assumptions about
   // the order of deletion between the views and the ToolbarActionsBar.
   DCHECK(toolbar_actions_.empty()) <<
       "Must call DeleteActions() before destruction.";
@@ skipping 344 matching lines @@
   else if (drag_type == DRAG_TO_MAIN &&
            dragged_index >= static_cast<int>(model_->visible_icon_count()))
     delta = 1;
   model_->MoveActionIcon(toolbar_actions_[dragged_index]->GetId(),
                          dropped_index);
   if (delta)
     model_->SetVisibleIconCount(model_->visible_icon_count() + delta);
 }
 
 void ToolbarActionsBar::OnAnimationEnded() {
+  // Notify the observers now, since showing a bubble or popup could potentially
+  // cause another animation to start.
+  FOR_EACH_OBSERVER(ToolbarActionsBarObserver, observers_,
+                    OnToolbarActionsBarAnimationEnded());
+
   // 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(std::move(pending_extension_bubble_controller_));
-  } else if (pending_toolbar_bubble_controller_) {
-    ShowToolbarActionBubble(std::move(pending_toolbar_bubble_controller_));
+  if (pending_bubble_controller_) {
+    ShowToolbarActionBubble(std::move(pending_bubble_controller_));
   } else if (!popped_out_closure_.is_null()) {
     popped_out_closure_.Run();
     popped_out_closure_.Reset();
   }
-  FOR_EACH_OBSERVER(ToolbarActionsBarObserver, observers_,
-                    OnToolbarActionsBarAnimationEnded());
+}
+
+void ToolbarActionsBar::OnBubbleClosed() {
+  is_showing_bubble_ = false;
 }
 
 bool ToolbarActionsBar::IsActionVisibleOnMainBar(
     const ToolbarActionViewController* action) const {
   if (in_overflow_mode())
     return main_bar_->IsActionVisibleOnMainBar(action);
 
   size_t index = std::find(toolbar_actions_.begin(),
                            toolbar_actions_.end(),
                            action) - toolbar_actions_.begin();
@@ skipping 60 matching lines @@
 void ToolbarActionsBar::AddObserver(ToolbarActionsBarObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void ToolbarActionsBar::RemoveObserver(ToolbarActionsBarObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void ToolbarActionsBar::ShowToolbarActionBubble(
     std::unique_ptr<ToolbarActionsBarBubbleDelegate> bubble) {
-  DCHECK(bubble->GetAnchorActionId().empty() ||
-         GetActionForId(bubble->GetAnchorActionId()));
-  if (delegate_->IsAnimating())
-    pending_toolbar_bubble_controller_ = std::move(bubble);
-  else
+  if (delegate_->IsAnimating()) {
+    // If the toolbar is animating, we can't effectively anchor the bubble,
+    // so wait until animation stops.
+    pending_bubble_controller_ = std::move(bubble);
+  } else if (bubble->ShouldShow()) {
+    // We check ShouldShow() above since we show the bubble asynchronously, and
+    // it might no longer have been valid.
+    is_showing_bubble_ = true;
     delegate_->ShowToolbarActionBubble(std::move(bubble));
+  }
 }
 
 void ToolbarActionsBar::MaybeShowExtensionBubble(
     std::unique_ptr<extensions::ExtensionMessageBubbleController> controller) {
+  if (!controller->ShouldShow())
+    return;
+
   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_ = std::move(controller);
-  } else if (controller->ShouldShow()) {
-    // We check ShouldShow() above because the affected extensions may have been
-    // removed since the controller was initialized.
-    const std::vector<std::string>& 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(std::move(controller), anchor_action);
-  }
+  ShowToolbarActionBubble(scoped_ptr<ToolbarActionsBarBubbleDelegate>(
+      new ExtensionMessageBubbleBridge(std::move(controller))));
 }
 
 void ToolbarActionsBar::OnToolbarActionAdded(
     const ToolbarActionsModel::ToolbarItem& item,
     int index) {
   DCHECK(GetActionForId(item.id) == nullptr)
       << "Asked to add a toolbar action view for an action that already "
          "exists";
 
   toolbar_actions_.insert(toolbar_actions_.begin() + index,
@@ skipping 175 matching lines @@
   for (ToolbarActionViewController* action : toolbar_actions_) {
     if (action->GetId() == action_id)
       return action;
   }
   return nullptr;
 }
 
 content::WebContents* ToolbarActionsBar::GetCurrentWebContents() {
   return browser_->tab_strip_model()->GetActiveWebContents();
 }