Implement initial chrome.browserAction.openPopup API.

chrome/browser/ui/gtk/browser_actions_toolbar_gtk.cc

 // Copyright (c) 2012 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/gtk/browser_actions_toolbar_gtk.h"
 
 #include <gtk/gtk.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 234 matching lines @@
       return NULL;
 
     context_menu_model_ =
         new ExtensionContextMenuModel(extension_, toolbar_->browser(), this);
     context_menu_.reset(
         new MenuGtk(this, context_menu_model_.get()));
     return context_menu_.get();
   }
 
  private:
-  // Activate the browser action.
-  void Activate(GtkWidget* widget) {
+  // Activate the browser action. Returns true if a popup was shown.
+  bool Activate(GtkWidget* widget, bool should_grant) {

[Finnur, 2013/10/18 10:31:01]

I would copy the explanation of should_grant (in the previous comment) to this
location also.

[justinlin, 2013/10/19 06:01:48]

Hmm, this was already done, must be an older patch set.

     ExtensionToolbarModel* model = toolbar_->model();
     const Extension* extension = extension_;
     Browser* browser = toolbar_->browser();
     GURL popup_url;
 
-    switch (model->ExecuteBrowserAction(extension, browser, &popup_url)) {
+    switch (model->ExecuteBrowserAction(
+        extension, browser, &popup_url, should_grant)) {
       case ExtensionToolbarModel::ACTION_NONE:
         break;
       case ExtensionToolbarModel::ACTION_SHOW_POPUP:
         ExtensionPopupGtk::Show(popup_url, browser, widget,
                                 ExtensionPopupGtk::SHOW);
-        break;
+        return true;
     }
+    return false;
   }
 
   // MenuGtk::Delegate implementation.
   virtual void StoppedShowing() OVERRIDE {
     if (enabled_)
       button_->UnsetPaintOverride();
     else
       button_->SetPaintOverride(GTK_STATE_INSENSITIVE);
 
     // If the context menu was showing for the overflow menu, re-assert the
@@ skipping 36 matching lines @@
       return FALSE;
 
     button->button_->SetPaintOverride(GTK_STATE_ACTIVE);
     menu->PopupForWidget(widget, event->button, event->time);
 
     return TRUE;
   }
 
   static void OnClicked(GtkWidget* widget, BrowserActionButton* button) {
     if (button->enabled_)
-      button->Activate(widget);
+      button->Activate(widget, true);
   }
 
   static gboolean OnExposeEvent(GtkWidget* widget,
                                 GdkEventExpose* event,
                                 BrowserActionButton* button) {
     int tab_id = button->toolbar_->GetCurrentTabId();
     if (tab_id < 0)
       return FALSE;
 
     ExtensionAction* action = button->browser_action();
@@ skipping 20 matching lines @@
   static gboolean OnGtkAccelerator(GtkAccelGroup* accel_group,
                                    GObject* acceleratable,
                                    guint keyval,
                                    GdkModifierType modifier,
                                    BrowserActionButton* button) {
     // Open the popup for this extension.
     GtkWidget* anchor = button->widget();
     // The anchor might be in the overflow menu. Then we point to the chevron.
     if (!gtk_widget_get_visible(anchor))
       anchor = button->toolbar_->chevron();
-    button->Activate(anchor);
+    button->Activate(anchor, true);
     return TRUE;
   }
 
   // The handler for when the browser action is realized. |user_data| contains a
   // pointer to the BrowserAction shown.
   static void OnRealize(GtkWidget* widget, void* user_data) {
     BrowserActionButton* button = static_cast<BrowserActionButton*>(user_data);
     button->ConnectBrowserActionPopupAccelerator();
   }
 
@@ skipping 284 matching lines @@
   signals_.Connect(button->widget(), "show",
                    G_CALLBACK(&OnButtonShowOrHideThunk), this);
   signals_.Connect(button->widget(), "hide",
                    G_CALLBACK(&OnButtonShowOrHideThunk), this);
 
   gtk_widget_show(button->widget());
 
   UpdateVisibility();
 }
 
+BrowserActionButton* BrowserActionsToolbarGtk::GetBrowserActionButton(
+    const Extension* extension) {
+  ExtensionButtonMap::iterator it = extension_button_map_.find(
+      extension->id());
+  return it == extension_button_map_.end() ? NULL : it->second.get();
+}
+
 GtkWidget* BrowserActionsToolbarGtk::GetBrowserActionWidget(
     const Extension* extension) {
-  ExtensionButtonMap::iterator it = extension_button_map_.find(
-      extension->id());
-  if (it == extension_button_map_.end())
-    return NULL;
-
-  return it->second.get()->widget();
+  BrowserActionButton* button = GetBrowserActionButton(extension);
+  return button == NULL ? NULL : button->widget();
 }
 
 void BrowserActionsToolbarGtk::RemoveButtonForExtension(
     const Extension* extension) {
   if (extension_button_map_.erase(extension->id()))
     UpdateVisibility();
   UpdateChevronVisibility();
 }
 
 void BrowserActionsToolbarGtk::UpdateVisibility() {
@@ skipping 71 matching lines @@
       NOTREACHED();
     return;
   }
 
   if (profile_->IsOffTheRecord())
     index = model_->OriginalIndexToIncognito(index);
 
   gtk_box_reorder_child(GTK_BOX(button_hbox_.get()), button_widget, index);
 }
 
+bool BrowserActionsToolbarGtk::BrowserActionShowPopup(
+    const Extension* extension) {
+  // Do not override other popups and only show in active window.
+  if (ExtensionPopupGtk::get_current_extension_popup() ||
+      !browser_->window()->IsActive()) {
+    return false;
+  }
+
+  BrowserActionButton* button = GetBrowserActionButton(extension);
+  if (button == NULL || button->widget() == NULL)
+    return false;
+
+  GtkWidget* anchor = button->widget();
+  if (!gtk_widget_get_visible(anchor))
+    anchor = button->toolbar_->chevron();
+  return button->Activate(anchor, false);
+}
+
 void BrowserActionsToolbarGtk::ModelLoaded() {
   SetContainerWidth();
 }
 
 void BrowserActionsToolbarGtk::AnimationProgressed(
     const gfx::Animation* animation) {
   int width = start_width_ + (desired_width_ - start_width_) *
       animation->GetCurrentValue();
   gtk_widget_set_size_request(button_hbox_.get(), width, -1);
 
@@ skipping 19 matching lines @@
 bool BrowserActionsToolbarGtk::GetAcceleratorForCommandId(
     int command_id,
     ui::Accelerator* accelerator) {
   return false;
 }
 
 void BrowserActionsToolbarGtk::ExecuteCommand(int command_id, int event_flags) {
   const Extension* extension = model_->toolbar_items()[command_id].get();
   GURL popup_url;
 
-  switch (model_->ExecuteBrowserAction(extension, browser(), &popup_url)) {
+  switch (model_->ExecuteBrowserAction(
+      extension,browser(), &popup_url, true)) {
     case ExtensionToolbarModel::ACTION_NONE:
       break;
     case ExtensionToolbarModel::ACTION_SHOW_POPUP:
       ExtensionPopupGtk::Show(popup_url, browser(), chevron(),
                               ExtensionPopupGtk::SHOW);
       break;
   }
 }
 
 void BrowserActionsToolbarGtk::StoppedShowing() {
@@ skipping 249 matching lines @@
     NOTREACHED();
     return FALSE;
   }
 
   item_index += gtk_chrome_shrinkable_hbox_get_visible_child_count(
       GTK_CHROME_SHRINKABLE_HBOX(button_hbox_.get()));
   if (profile_->IsOffTheRecord())
     item_index = model_->IncognitoIndexToOriginal(item_index);
 
   const Extension* extension = model_->toolbar_items()[item_index].get();
-  ExtensionButtonMap::iterator it = extension_button_map_.find(extension->id());
-  if (it == extension_button_map_.end()) {
+  BrowserActionButton* button = GetBrowserActionButton(extension);
+  if (button == NULL) {
     NOTREACHED();
     return FALSE;
   }
 
-  MenuGtk* menu = it->second.get()->GetContextMenu();
+  MenuGtk* menu = button->GetContextMenu();
   if (!menu)
     return FALSE;
 
   menu->PopupAsContext(gfx::Point(event->x_root, event->y_root),
                        event->time);
   return TRUE;
 }
 
 void BrowserActionsToolbarGtk::OnButtonShowOrHide(GtkWidget* sender) {
   if (!resize_animation_.is_animating())
     UpdateChevronVisibility();
 }