Ensure that MenuGtks are destroyed before their accelerator group.

chrome/browser/gtk/menu_gtk.cc

 // Copyright (c) 2009 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 "base/gfx/gtk_util.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "chrome/common/l10n_util.h"
@@ skipping 20 matching lines @@
 
   return ret;
 }
 
 }  // namespace
 
 MenuGtk::MenuGtk(MenuGtk::Delegate* delegate,
                  const MenuCreateMaterial* menu_data,
                  GtkAccelGroup* accel_group)
     : delegate_(delegate),
-      accel_group_(accel_group),
       menu_(gtk_menu_new()) {
-  BuildMenuIn(menu_.get(), menu_data);
+  BuildMenuIn(menu_.get(), menu_data, accel_group);
 }
 
 MenuGtk::MenuGtk(MenuGtk::Delegate* delegate)
     : delegate_(delegate),
       menu_(gtk_menu_new()) {
   BuildMenuFromDelegate();
 }
 
 MenuGtk::~MenuGtk() {
   menu_.Destroy();
@@ skipping 19 matching lines @@
 void MenuGtk::PopupAsContext() {
   gtk_container_foreach(GTK_CONTAINER(menu_.get()), SetMenuItemInfo, this);
 
   // TODO(estade): |button| value of 0 (6th argument) is not strictly true,
   // but does it matter?
   gtk_menu_popup(GTK_MENU(menu_.get()), NULL, NULL, NULL, NULL, 0,
                  gtk_get_current_event_time());
 }
 
 void MenuGtk::BuildMenuIn(GtkWidget* menu,
-                          const MenuCreateMaterial* menu_data) {
+                          const MenuCreateMaterial* menu_data,
+                          GtkAccelGroup* accel_group) {
   // We keep track of the last menu item in order to group radio items.
   GtkWidget* last_menu_item = NULL;
   for (; menu_data->type != MENU_END; ++menu_data) {
     GtkWidget* menu_item = NULL;
 
     std::string label;
     if (menu_data->label_argument) {
       label = WideToUTF8(l10n_util::GetStringF(
           menu_data->label_id,
           l10n_util::GetString(menu_data->label_argument)));
@@ skipping 23 matching lines @@
         menu_item = gtk_separator_menu_item_new();
         break;
       case MENU_NORMAL:
       default:
         menu_item = gtk_menu_item_new_with_mnemonic(label.c_str());
         break;
     }
 
     if (menu_data->submenu) {
       GtkWidget* submenu = gtk_menu_new();
-      BuildMenuIn(submenu, menu_data->submenu);
+      BuildMenuIn(submenu, menu_data->submenu, accel_group);
       gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), submenu);
     }
 
-    if (accel_group_ && menu_data->accel_key) {
+    if (accel_group && menu_data->accel_key) {
       // If we ever want to let the user do any key remaping, we'll need to
       // change the following so we make a gtk_accel_map which keeps the actual
       // keys.
       gtk_widget_add_accelerator(menu_item,
                                  "activate",
-                                 accel_group_,
+                                 accel_group,
                                  menu_data->accel_key,
                                  GdkModifierType(menu_data->accel_modifiers),
                                  GTK_ACCEL_VISIBLE);
     }
 
     g_object_set_data(G_OBJECT(menu_item), "menu-data",
                       const_cast<MenuCreateMaterial*>(menu_data));
 
     g_signal_connect(G_OBJECT(menu_item), "activate",
                      G_CALLBACK(OnMenuItemActivated), this);
@@ skipping 23 matching lines @@
       menu_item = gtk_menu_item_new_with_label(delegate_->GetLabel(i).c_str());
     }
 
     g_object_set_data(G_OBJECT(menu_item), "menu-id",
                       reinterpret_cast<void*>(i));
 
     g_signal_connect(G_OBJECT(menu_item), "activate",
                      G_CALLBACK(OnMenuItemActivatedById), this);
 
     gtk_widget_show(menu_item);
-    // TODO(estade): gtk_menu_append is deprecated.
-    gtk_menu_append(menu_.get(), menu_item);
+    gtk_menu_shell_append(GTK_MENU_SHELL(menu_.get()), menu_item);
   }
 }
 
 // static
 void MenuGtk::OnMenuItemActivated(GtkMenuItem* menuitem, MenuGtk* menu) {
   // We receive activation messages when highlighting a menu that has a
   // submenu. Ignore them.
   if (!gtk_menu_item_get_submenu(menuitem)) {
     const MenuCreateMaterial* data =
         reinterpret_cast<const MenuCreateMaterial*>(
@@ skipping 14 matching lines @@
 }
 
 // static
 void MenuGtk::MenuPositionFunc(GtkMenu* menu,
                                int* x,
                                int* y,
                                gboolean* push_in,
                                void* void_widget) {
   GtkWidget* widget = GTK_WIDGET(void_widget);
   GtkRequisition menu_req;
-  GdkRectangle monitor;
 
   gtk_widget_size_request(GTK_WIDGET(menu), &menu_req);
 
-  GdkScreen* screen = gtk_widget_get_screen(GTK_WIDGET(menu));
-  gint monitor_num = gdk_screen_get_monitor_at_window(screen, widget->window);
-  if (monitor_num < 0)
-    monitor_num = 0;
-  gdk_screen_get_monitor_geometry(screen, monitor_num, &monitor);
-
   gdk_window_get_origin(widget->window, x, y);
   *x += widget->allocation.x;
   *y += widget->allocation.y + widget->allocation.height;
 
   // g_object_get_data() returns NULL if no such object is found. |left_align|
   // acts as a boolean, but we can't actually cast it to bool because gcc
   // complains about losing precision.
-  void* left_align =
-      g_object_get_data(G_OBJECT(widget), "left-align-popup");
-
-  if (!left_align)
+  if (!g_object_get_data(G_OBJECT(widget), "left-align-popup"))
     *x += widget->allocation.width - menu_req.width;
 
   // TODO(erg): Deal with this scrolling off the bottom of the screen.
 
   // Regretfully, we can't rely on push_in to alter the coordinates above to
   // always make the menu fit on screen. It'd make the above calculations just
   // work though...
   *push_in = FALSE;
 }
 
 // static
-void MenuGtk::SetMenuItemInfo(GtkWidget* widget, void* raw_menu) {
-  MenuGtk* menu = static_cast<MenuGtk*>(raw_menu);
+void MenuGtk::SetMenuItemInfo(GtkWidget* widget, gpointer userdata) {
+  MenuGtk* menu = reinterpret_cast<MenuGtk*>(userdata);
   const MenuCreateMaterial* data =
       reinterpret_cast<const MenuCreateMaterial*>(
           g_object_get_data(G_OBJECT(widget), "menu-data"));
 
   if (data) {
     if (GTK_IS_CHECK_MENU_ITEM(widget)) {
       GtkCheckMenuItem* item = GTK_CHECK_MENU_ITEM(widget);
       gtk_check_menu_item_set_active(
           item, menu->delegate_->IsItemChecked(data->id));
     }
 
     if (GTK_IS_MENU_ITEM(widget)) {
       gtk_widget_set_sensitive(
           widget, menu->delegate_->IsCommandEnabled(data->id));
 
       GtkWidget* submenu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(widget));
       if (submenu) {
-        gtk_container_foreach(GTK_CONTAINER(submenu), &MenuGtk::SetMenuItemInfo,
-                              raw_menu);
+        gtk_container_foreach(GTK_CONTAINER(submenu), &SetMenuItemInfo,
+                              userdata);
       }
     }
   }
 }