Make a ShowExtensionActionPopup function

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/extension_util.h"
@@ skipping 48 matching lines @@
 // The maximum number of icons to show per row when in overflow mode (showing
 // icons in the application menu).
 // TODO(devlin): Compute the right number of icons to show, depending on the
 //               menu width.
 #if defined(OS_LINUX)
 const int kIconsPerMenuRow = 8;  // The menu on Linux is wider.
 #else
 const int kIconsPerMenuRow = 7;
 #endif
 
-// Returns the ExtensionAction for the given |extension|.
-ExtensionAction* GetExtensionAction(const Extension& extension,
-                                    Profile* profile) {
-  extensions::ExtensionActionManager* action_manager =
-      extensions::ExtensionActionManager::Get(profile);
-  ExtensionAction* action = action_manager->GetBrowserAction(extension);
-  return action ? action : action_manager->GetPageAction(extension);
-}
-
 // A version of MenuButton with almost empty insets to fit properly on the
 // toolbar.
 class ChevronMenuButton : public views::MenuButton {
  public:
   ChevronMenuButton(views::ButtonListener* listener,
                     const base::string16& text,
                     views::MenuButtonListener* menu_button_listener,
                     bool show_menu_marker)
       : views::MenuButton(listener,
                           text,
@@ skipping 131 matching lines @@
 void BrowserActionsContainer::RefreshBrowserActionViews() {
   for (size_t i = 0; i < browser_action_views_.size(); ++i)
     browser_action_views_[i]->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 (extensions::ExtensionList::const_iterator i(toolbar_items.begin());
        i != toolbar_items.end(); ++i) {
     if (!ShouldDisplayBrowserAction(i->get()))
       continue;
 
     BrowserActionView* view =
         new BrowserActionView(i->get(),
-                              GetExtensionAction(*i->get(), profile_),
+                              action_manager->GetExtensionAction(**i),
                               browser_,
                               this);
     browser_action_views_.push_back(view);
     AddChildView(view);
   }
 }
 
 void BrowserActionsContainer::DeleteBrowserActionViews() {
   HideActivePopup();
   if (overflow_menu_)
@@ skipping 557 matching lines @@
   CloseOverflowMenu();
 
   if (!ShouldDisplayBrowserAction(extension))
     return;
 
   // Add the new browser action to the vector and the view hierarchy.
   if (profile_->IsOffTheRecord())
     index = model_->OriginalIndexToIncognito(index);
   BrowserActionView* view =
       new BrowserActionView(extension,
-                            GetExtensionAction(*extension, profile_),
+                            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;
 
   // Enlarge the container if it was already at maximum size and we're not in
@@ skipping 76 matching lines @@
 }
 
 void BrowserActionsContainer::ToolbarExtensionUpdated(
     const Extension* extension) {
   BrowserActionView* view = GetViewForExtension(extension);
   if (view)
     view->UpdateState();
 }
 
 bool BrowserActionsContainer::ShowExtensionActionPopup(
-    const Extension* extension) {
-  return ShowPopupForExtension(extension, false, false);
+    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);
 }
 
 void BrowserActionsContainer::ToolbarVisibleCountChanged() {
   int old_container_width = container_width_;
   SetContainerWidth();
   if (old_container_width != 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();
   Animate(gfx::Tween::LINEAR, browser_action_views_.size());
 }
 
+Browser* BrowserActionsContainer::GetBrowser() {
+  return browser_;
+}
+
 void BrowserActionsContainer::LoadImages() {
   ui::ThemeProvider* tp = GetThemeProvider();
   if (!tp || !chevron_)
     return;
 
   chevron_->SetImage(views::Button::STATE_NORMAL,
                      *tp->GetImageSkiaNamed(IDR_BROWSER_ACTIONS_OVERFLOW));
 
   const int kImages[] = IMAGE_GRID(IDR_DEVELOPER_MODE_HIGHLIGHT);
   highlight_painter_.reset(views::Painter::CreateImageGridPainter(kImages));
@@ skipping 102 matching lines @@
   }
 }
 
 bool BrowserActionsContainer::ShouldDisplayBrowserAction(
     const Extension* extension) const {
   // Only display incognito-enabled extensions while in incognito mode.
   return !profile_->IsOffTheRecord() ||
       extensions::util::IsIncognitoEnabled(extension->id(), profile_);
 }
 
-bool BrowserActionsContainer::ShowPopupForExtension(
-    const extensions::Extension* extension,
-    bool grant_tab_permissions,
-    bool can_override) {
-  // If the popup cannot override other views, then no other popups can be
-  // showing, and it must be shown in the active widow with a visible toolbar.
-  // TODO(justinlin): Remove toolbar check when http://crbug.com/308645 is
-  // fixed.
-  if (!can_override &&
-      (popup_owner_ ||
-       !browser_->window()->IsActive() ||
-       !browser_->window()->IsToolbarVisible())) {
-    return false;
-  }
-
-  BrowserActionView* view = GetViewForExtension(extension);
-  return view ? view->view_controller()->ExecuteAction(
-                    ExtensionPopup::SHOW, grant_tab_permissions) : false;
-}
-
 BrowserActionView* BrowserActionsContainer::GetViewForExtension(
     const Extension* extension) {
   for (BrowserActionViews::iterator view = browser_action_views_.begin();
        view != browser_action_views_.end(); ++view) {
     if ((*view)->extension() == extension)
       return *view;
   }
 
   return NULL;
 }
@@ skipping 13 matching lines @@
   size_t absolute_model_size =
       model_size == -1 ? extensions.size() : model_size;
 
   // The main container will try to show |model_size| icons, but reduce if there
   // aren't enough displayable icons to do so.
   size_t main_displayed = std::min(displayable_icon_count, absolute_model_size);
   // The overflow will display the extras, if any.
   return in_overflow_mode() ?
       displayable_icon_count - main_displayed : main_displayed;
 }