linux: fix regression where opening the page menu would cause a reload

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 "app/l10n_util.h"
 #include "base/gfx/gtk_util.h"
 #include "base/logging.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "chrome/browser/gtk/standard_menus.h"
 #include "chrome/common/gtk_util.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 using gtk_util::ConvertAcceleratorsFromWindowsStyle;
 
+bool MenuGtk::block_activation_ = false;
+
 MenuGtk::MenuGtk(MenuGtk::Delegate* delegate,
                  const MenuCreateMaterial* menu_data,
                  GtkAccelGroup* accel_group)
     : delegate_(delegate),
       dummy_accel_group_(gtk_accel_group_new()),
       menu_(gtk_menu_new()) {
   ConnectSignalHandlers();
   BuildMenuIn(menu_.get(), menu_data, accel_group);
 }
 
@@ skipping 192 matching lines @@
     } else {
       menu_item = gtk_menu_item_new_with_label(delegate_->GetLabel(i).c_str());
     }
 
     AppendMenuItem(i, 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)) {
-    const MenuCreateMaterial* data =
-        reinterpret_cast<const MenuCreateMaterial*>(
-            g_object_get_data(G_OBJECT(menuitem), "menu-data"));
+  if (gtk_menu_item_get_submenu(menuitem))
+    return;

[Elliot Glaysher, 2009/08/03 22:46:34]

You may be able to pull this check out; I think this case is handled with
|lbock_activate_|.

[Evan Martin, 2009/08/03 22:58:41]

Nope, you get it when mousing through the menu.  :\

 
-    int id;
-    if (data) {
-      id = data->id;
-    } else {
-      id = reinterpret_cast<intptr_t>(g_object_get_data(G_OBJECT(menuitem),
-                                                        "menu-id"));
-    }
+  const MenuCreateMaterial* data =
+      reinterpret_cast<const MenuCreateMaterial*>(
+          g_object_get_data(G_OBJECT(menuitem), "menu-data"));
 
-    // The menu item can still be activated by hotkeys even if it is disabled.
-    if (menu->delegate_->IsCommandEnabled(id))
-      menu->delegate_->ExecuteCommand(id);
+  int id;
+  if (data) {
+    id = data->id;
+  } else {
+    id = reinterpret_cast<intptr_t>(g_object_get_data(G_OBJECT(menuitem),
+                                                      "menu-id"));
   }
+
+  // The menu item can still be activated by hotkeys even if it is disabled.
+  if (menu->delegate_->IsCommandEnabled(id))
+    menu->delegate_->ExecuteCommand(id);
 }
 
 // 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;
@@ skipping 59 matching lines @@
                                     "menu-id"));
   }
 
   if (GTK_IS_CHECK_MENU_ITEM(widget)) {
     GtkCheckMenuItem* item = GTK_CHECK_MENU_ITEM(widget);
 
     // gtk_check_menu_item_set_active() will send the activate signal. Touching
     // the underlying "active" property will also call the "activate" handler
     // for this menu item. So we prevent the "activate" handler from
     // being called while we set the checkbox.
-    g_signal_handlers_block_matched(
-        item, G_SIGNAL_MATCH_FUNC,
-        0, 0, NULL,
-        reinterpret_cast<void*>(OnMenuItemActivated),
-        NULL);
-
-    gtk_check_menu_item_set_active(
-        item, menu->delegate_->IsItemChecked(id));
-
-    g_signal_handlers_unblock_matched(
-        item, G_SIGNAL_MATCH_FUNC,
-        0, 0, NULL,
-        reinterpret_cast<void*>(OnMenuItemActivated),
-        NULL);
+    // Why not use one of the glib signal-blocking functions?  Because when we
+    // toggle a radio button, it will deactivate one of the other radio buttons,
+    // which we don't have a pointer to.
+    // Wny not make this a member variable?  Because "menu" is a pointer to the
+    // root of the MenuGtk and we want to disable *all* MenuGtks, including
+    // submenus.
+    block_activation_ = true;
+    gtk_check_menu_item_set_active(item, menu->delegate_->IsItemChecked(id));
+    block_activation_ = false;
   }
 
   if (GTK_IS_MENU_ITEM(widget)) {
     gtk_widget_set_sensitive(
         widget, menu->delegate_->IsCommandEnabled(id));
 
     GtkWidget* submenu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(widget));
     if (submenu) {
       gtk_container_foreach(GTK_CONTAINER(submenu), &SetMenuItemInfo,
                             userdata);
     }
   }
 }