Reapply r50859 with chromeos fixes.

chrome/browser/gtk/menu_gtk.cc

 // Copyright (c) 2010 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/gtk/menu_gtk.h"
 
 #include <map>
 
 #include "app/l10n_util.h"
 #include "app/menus/accelerator_gtk.h"
+#include "app/menus/button_menu_item_model.h"
 #include "app/menus/menu_model.h"
+#include "app/resource_bundle.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stl_util-inl.h"
 #include "base/utf_string_conversions.h"
+#include "chrome/browser/gtk/gtk_custom_menu.h"
+#include "chrome/browser/gtk/gtk_custom_menu_item.h"
 #include "chrome/browser/gtk/gtk_util.h"
 #include "gfx/gtk_util.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 using gtk_util::ConvertAcceleratorsFromWindowsStyle;
+using gtk_util::RemoveWindowsStyleAccelerators;
 
 bool MenuGtk::block_activation_ = false;
 
 namespace {
 
 // Sets the ID of a menu item.
 void SetMenuItemID(GtkWidget* menu_item, int menu_id) {
   DCHECK_GE(menu_id, 0);
 
   // Add 1 to the menu_id to avoid setting zero (null) to "menu-id".
@@ skipping 60 matching lines @@
   return y;
 }
 
 }  // namespace
 
 MenuGtk::MenuGtk(MenuGtk::Delegate* delegate,
                  menus::MenuModel* model)
     : delegate_(delegate),
       model_(model),
       dummy_accel_group_(gtk_accel_group_new()),
-      menu_(gtk_menu_new()),
+      menu_(gtk_custom_menu_new()),
       factory_(this) {
   DCHECK(model);
   g_object_ref_sink(menu_);
   ConnectSignalHandlers();
   BuildMenuFromModel();
 }
 
 MenuGtk::~MenuGtk() {
   Cancel();
 
@@ skipping 36 matching lines @@
 }
 
 GtkWidget* MenuGtk::AppendSeparator() {
   GtkWidget* menu_item = gtk_separator_menu_item_new();
   gtk_widget_show(menu_item);
   gtk_menu_shell_append(GTK_MENU_SHELL(menu_), menu_item);
   return menu_item;
 }
 
 GtkWidget* MenuGtk::AppendMenuItem(int command_id, GtkWidget* menu_item) {
-  return AppendMenuItemToMenu(command_id, menu_item, menu_);
+  return AppendMenuItemToMenu(command_id, menu_item, menu_, true);
 }
 
 GtkWidget* MenuGtk::AppendMenuItemToMenu(int command_id,
                                          GtkWidget* menu_item,
-                                         GtkWidget* menu) {
-  SetMenuItemID(menu_item, command_id);
-  g_signal_connect(menu_item, "activate",
-                   G_CALLBACK(OnMenuItemActivated), this);
+                                         GtkWidget* menu,
+                                         bool connect_to_activate) {
+  // Native menu items do their own thing, so only selectively listen for the
+  // activate signal.
+  if (connect_to_activate) {
+    SetMenuItemID(menu_item, command_id);
+    g_signal_connect(menu_item, "activate",
+                     G_CALLBACK(OnMenuItemActivated), this);
+  }
 
   gtk_widget_show(menu_item);
   gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
   return menu_item;
 }
 
 void MenuGtk::Popup(GtkWidget* widget, GdkEvent* event) {
   DCHECK(event->type == GDK_BUTTON_PRESS)
       << "Non-button press event sent to RunMenuAt";
 
@@ skipping 46 matching lines @@
   BuildSubmenuFromModel(model_, menu_);
 }
 
 void MenuGtk::BuildSubmenuFromModel(menus::MenuModel* model, GtkWidget* menu) {
   std::map<int, GtkWidget*> radio_groups;
   GtkWidget* menu_item = NULL;
   for (int i = 0; i < model->GetItemCount(); ++i) {
     SkBitmap icon;
     std::string label =
         ConvertAcceleratorsFromWindowsStyle(UTF16ToUTF8(model->GetLabelAt(i)));
+    bool connect_to_activate = true;
 
     switch (model->GetTypeAt(i)) {
       case menus::MenuModel::TYPE_SEPARATOR:
         menu_item = gtk_separator_menu_item_new();
         break;
 
       case menus::MenuModel::TYPE_CHECK:
         menu_item = gtk_check_menu_item_new_with_mnemonic(label.c_str());
         break;
 
       case menus::MenuModel::TYPE_RADIO: {
         std::map<int, GtkWidget*>::iterator iter =
             radio_groups.find(model->GetGroupIdAt(i));
 
         if (iter == radio_groups.end()) {
           menu_item = gtk_radio_menu_item_new_with_mnemonic(
               NULL, label.c_str());
           radio_groups[model->GetGroupIdAt(i)] = menu_item;
         } else {
           menu_item = gtk_radio_menu_item_new_with_mnemonic_from_widget(
               GTK_RADIO_MENU_ITEM(iter->second), label.c_str());
         }
         break;
       }
+      case menus::MenuModel::TYPE_BUTTON_ITEM: {
+        menus::ButtonMenuItemModel* button_menu_item_model =
+            model->GetButtonMenuItemAt(i);
+
+        menu_item = BuildButtomMenuItem(button_menu_item_model);
+
+        connect_to_activate = false;
+        break;
+      }
       case menus::MenuModel::TYPE_SUBMENU:
       case menus::MenuModel::TYPE_COMMAND:
         if (model->GetIconAt(i, &icon))
           menu_item = BuildMenuItemWithImage(label, icon);
         else
           menu_item = gtk_menu_item_new_with_mnemonic(label.c_str());
         break;
 
       default:
         NOTREACHED();
@@ skipping 10 matching lines @@
       gtk_widget_add_accelerator(menu_item,
                                  "activate",
                                  dummy_accel_group_,
                                  accelerator.GetGdkKeyCode(),
                                  accelerator.gdk_modifier_type(),
                                  GTK_ACCEL_VISIBLE);
     }
 
     g_object_set_data(G_OBJECT(menu_item), "model",
                       reinterpret_cast<void*>(model));
-    AppendMenuItemToMenu(i, menu_item, menu);
+    AppendMenuItemToMenu(i, menu_item, menu, connect_to_activate);
 
     if (model->IsLabelDynamicAt(i)) {
       g_signal_connect(menu, "show", G_CALLBACK(OnSubmenuShow),
                        GINT_TO_POINTER(i));
     }
 
     menu_item = NULL;
   }
 }
 
+GtkWidget* MenuGtk::BuildButtomMenuItem(menus::ButtonMenuItemModel* model) {
+  GtkWidget* menu_item = gtk_custom_menu_item_new(
+      RemoveWindowsStyleAccelerators(UTF16ToUTF8(model->label())).c_str());
+  for (int i = 0; i < model->GetItemCount(); ++i) {
+    switch (model->GetTypeAt(i)) {
+      case menus::ButtonMenuItemModel::TYPE_SPACE: {
+        gtk_custom_menu_item_add_space(GTK_CUSTOM_MENU_ITEM(menu_item));
+        break;
+      }
+      case menus::ButtonMenuItemModel::TYPE_BUTTON: {
+        GtkWidget* button = gtk_custom_menu_item_add_button(
+            GTK_CUSTOM_MENU_ITEM(menu_item),
+            model->GetCommandIdAt(i));
+
+        int icon_idr;
+        if (model->GetIconAt(i, &icon_idr)) {
+          // TODO(erg): This should go through the GtkThemeProvider so we can
+          // get a version tinted to label color.
+          gtk_button_set_image(
+              GTK_BUTTON(button),
+              gtk_image_new_from_pixbuf(
+                  ResourceBundle::GetSharedInstance().
+                  GetPixbufNamed(icon_idr)));
+        } else {
+          gtk_button_set_label(
+              GTK_BUTTON(button),
+              RemoveWindowsStyleAccelerators(
+                  UTF16ToUTF8(model->GetLabelAt(i))).c_str());
+        }
+
+        // TODO(erg): Set up dynamic labels here.
+        break;
+      }
+    }
+  }
+
+  // Set up the callback to the model for when it is clicked.
+  g_object_set_data(G_OBJECT(menu_item), "button-model",
+                    reinterpret_cast<void*>(model));
+  g_signal_connect(menu_item, "button-pushed",
+                   G_CALLBACK(OnMenuButtonPressed), this);
+  return menu_item;
+}
+
 // static
 void MenuGtk::OnMenuItemActivated(GtkMenuItem* menuitem, MenuGtk* menu) {
   if (block_activation_)
     return;
 
   // We receive activation messages when highlighting a menu that has a
   // submenu. Ignore them.
   if (gtk_menu_item_get_submenu(menuitem))
     return;
 
   // The activate signal is sent to radio items as they get deselected;
   // ignore it in this case.
   if (GTK_IS_RADIO_MENU_ITEM(menuitem) &&
       !gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) {
     return;
   }
 
   int id;
   if (!GetMenuItemID(GTK_WIDGET(menuitem), &id))
     return;
 
   menus::MenuModel* model = ModelForMenuItem(menuitem);
 
   // The menu item can still be activated by hotkeys even if it is disabled.
   if (model->IsEnabledAt(id))
     menu->ExecuteCommand(model, id);
 }
 
+void MenuGtk::OnMenuButtonPressed(GtkMenuItem* menu_item, int command_id,
+                                  MenuGtk* menu) {
+  menus::ButtonMenuItemModel* model =
+      reinterpret_cast<menus::ButtonMenuItemModel*>(
+          g_object_get_data(G_OBJECT(menu_item), "button-model"));
+  if (model) {
+    if (menu->delegate_)
+      menu->delegate_->CommandWillBeExecuted();
+
+    model->ActivatedCommand(command_id);
+  }
+}
+
 // static
 void MenuGtk::WidgetMenuPositionFunc(GtkMenu* menu,
                                      int* x,
                                      int* y,
                                      gboolean* push_in,
                                      void* void_widget) {
   GtkWidget* widget = GTK_WIDGET(void_widget);
   GtkRequisition menu_req;
 
   gtk_widget_size_request(GTK_WIDGET(menu), &menu_req);
@@ skipping 112 matching lines @@
   if (GTK_IS_MENU_ITEM(widget)) {
     gtk_widget_set_sensitive(widget, model->IsEnabledAt(id));
 
     GtkWidget* submenu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(widget));
     if (submenu) {
       gtk_container_foreach(GTK_CONTAINER(submenu), &SetMenuItemInfo,
                             userdata);
     }
   }
 }