GTK: More transitions to thunk definition macros.

BUG=none
TEST=none

Review URL: http://codereview.chromium.org/1118005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@42191 0039d316-1c4b-4281-b951-d872f2087c98

8 files changed, 229 insertions, 371 deletions

diff --git a/chrome/browser/gtk/bookmark_manager_gtk.cc b/chrome/browser/gtk/bookmark_manager_gtk.cc
index 848b306..bfa168b 100644
--- a/chrome/browser/gtk/bookmark_manager_gtk.cc
+++ b/chrome/browser/gtk/bookmark_manager_gtk.cc
@@ -375,13 +375,13 @@ void BookmarkManagerGtk::InitWidgets() {
       gtk_util::ConvertAcceleratorsFromWindowsStyle(
           l10n_util::GetStringUTF8(IDS_BOOKMARK_MANAGER_IMPORT_MENU)).c_str());
   g_signal_connect(import_item, "activate",
-                   G_CALLBACK(OnImportItemActivated), this);
+                   G_CALLBACK(OnImportItemActivatedThunk), this);
 
   GtkWidget* export_item = gtk_menu_item_new_with_mnemonic(
       gtk_util::ConvertAcceleratorsFromWindowsStyle(
           l10n_util::GetStringUTF8(IDS_BOOKMARK_MANAGER_EXPORT_MENU)).c_str());
   g_signal_connect(export_item, "activate",
-                   G_CALLBACK(OnExportItemActivated), this);
+                   G_CALLBACK(OnExportItemActivatedThunk), this);
 
   GtkWidget* tools_menu = gtk_menu_new();
   gtk_menu_shell_append(GTK_MENU_SHELL(tools_menu), import_item);
@@ -394,7 +394,7 @@ void BookmarkManagerGtk::InitWidgets() {
   // Build the sync status menu item.
   sync_status_menu_ = gtk_menu_item_new_with_label("");
   g_signal_connect(sync_status_menu_, "activate",
-                   G_CALLBACK(OnSyncStatusMenuActivated), this);
+                   G_CALLBACK(OnSyncStatusMenuActivatedThunk), this);
 
   GtkWidget* menu_bar = gtk_menu_bar_new();
   gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), organize_);
@@ -457,15 +457,15 @@ GtkWidget* BookmarkManagerGtk::MakeLeftPane() {
   // When a row is collapsed that contained the selected node, we want to select
   // it.
   g_signal_connect(left_tree_view_, "row-collapsed",
-                   G_CALLBACK(OnLeftTreeViewRowCollapsed), this);
+                   G_CALLBACK(OnLeftTreeViewRowCollapsedThunk), this);
   g_signal_connect(left_tree_view_, "focus-in-event",
-                   G_CALLBACK(OnLeftTreeViewFocusIn), this);
+                   G_CALLBACK(OnLeftTreeViewFocusInThunk), this);
   g_signal_connect(left_tree_view_, "button-press-event",
-                   G_CALLBACK(OnTreeViewButtonPress), this);
+                   G_CALLBACK(OnTreeViewButtonPressThunk), this);
   g_signal_connect(left_tree_view_, "button-release-event",
-                   G_CALLBACK(OnTreeViewButtonRelease), this);
+                   G_CALLBACK(OnTreeViewButtonReleaseThunk), this);
   g_signal_connect(left_tree_view_, "key-press-event",
-                   G_CALLBACK(OnTreeViewKeyPress), this);
+                   G_CALLBACK(OnTreeViewKeyPressThunk), this);
 
   GtkCellRenderer* cell_renderer_text = bookmark_utils::GetCellRendererText(
       GTK_TREE_VIEW(left_tree_view_));
@@ -478,9 +478,9 @@ GtkWidget* BookmarkManagerGtk::MakeLeftPane() {
   gtk_dnd_util::SetDestTargetList(left_tree_view_, kDestTargetList);
 
   g_signal_connect(left_tree_view_, "drag-data-received",
-                   G_CALLBACK(&OnLeftTreeViewDragReceived), this);
+                   G_CALLBACK(OnLeftTreeViewDragReceivedThunk), this);
   g_signal_connect(left_tree_view_, "drag-motion",
-                   G_CALLBACK(&OnLeftTreeViewDragMotion), this);
+                   G_CALLBACK(OnLeftTreeViewDragMotionThunk), this);
 
   GtkWidget* scrolled = gtk_scrolled_window_new(NULL, NULL);
   gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
@@ -529,22 +529,22 @@ GtkWidget* BookmarkManagerGtk::MakeRightPane() {
   gtk_tree_selection_set_mode(right_selection(), GTK_SELECTION_MULTIPLE);
 
   g_signal_connect(right_tree_view_, "row-activated",
-                   G_CALLBACK(OnRightTreeViewRowActivated), this);
+                   G_CALLBACK(OnRightTreeViewRowActivatedThunk), this);
   g_signal_connect(right_selection(), "changed",
                    G_CALLBACK(OnRightSelectionChanged), this);
   g_signal_connect(right_tree_view_, "focus-in-event",
-                   G_CALLBACK(OnRightTreeViewFocusIn), this);
+                   G_CALLBACK(OnRightTreeViewFocusInThunk), this);
   g_signal_connect(right_tree_view_, "button-press-event",
-                   G_CALLBACK(OnRightTreeViewButtonPress), this);
+                   G_CALLBACK(OnRightTreeViewButtonPressThunk), this);
   g_signal_connect(right_tree_view_, "motion-notify-event",
-                   G_CALLBACK(OnRightTreeViewMotion), this);
+                   G_CALLBACK(OnRightTreeViewMotionThunk), this);
   // This handler just controls showing the context menu.
   g_signal_connect(right_tree_view_, "button-press-event",
-                   G_CALLBACK(OnTreeViewButtonPress), this);
+                   G_CALLBACK(OnTreeViewButtonPressThunk), this);
   g_signal_connect(right_tree_view_, "button-release-event",
-                   G_CALLBACK(OnTreeViewButtonRelease), this);
+                   G_CALLBACK(OnTreeViewButtonReleaseThunk), this);
   g_signal_connect(right_tree_view_, "key-press-event",
-                   G_CALLBACK(OnTreeViewKeyPress), this);
+                   G_CALLBACK(OnTreeViewKeyPressThunk), this);
 
   // GDK_ACTION_MOVE is necessary to reorder bookmarks within the
   // right tree.  COPY and LINK are necessary for drags to the
@@ -559,13 +559,13 @@ GtkWidget* BookmarkManagerGtk::MakeRightPane() {
   // as a drag destination unless it corresponds to the contents of a folder.
   // See BuildRightStore().
   g_signal_connect(right_tree_view_, "drag-data-get",
-                   G_CALLBACK(&OnRightTreeViewDragGet), this);
+                   G_CALLBACK(OnRightTreeViewDragGetThunk), this);
   g_signal_connect(right_tree_view_, "drag-data-received",
-                   G_CALLBACK(&OnRightTreeViewDragReceived), this);
+                   G_CALLBACK(OnRightTreeViewDragReceivedThunk), this);
   g_signal_connect(right_tree_view_, "drag-motion",
-                   G_CALLBACK(&OnRightTreeViewDragMotion), this);
+                   G_CALLBACK(OnRightTreeViewDragMotionThunk), this);
   g_signal_connect(right_tree_view_, "drag-begin",
-                   G_CALLBACK(&OnRightTreeViewDragBegin), this);
+                   G_CALLBACK(OnRightTreeViewDragBeginThunk), this);
 
   GtkWidget* scrolled = gtk_scrolled_window_new(NULL, NULL);
   gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
@@ -897,7 +897,7 @@ void BookmarkManagerGtk::PerformSearch() {
   }
 }
 
-void BookmarkManagerGtk::OnSearchTextChanged() {
+void BookmarkManagerGtk::OnSearchTextChanged(GtkWidget* widget) {
   search_factory_.RevokeAll();
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
       search_factory_.NewRunnableMethod(&BookmarkManagerGtk::PerformSearch),
@@ -931,7 +931,6 @@ void BookmarkManagerGtk::OnRightSelectionChanged(GtkTreeSelection* selection,
   bm->ResetOrganizeMenu(false);
 }
 
-// static
 void BookmarkManagerGtk::OnLeftTreeViewDragReceived(
     GtkWidget* tree_view,
     GdkDragContext* context,
@@ -939,15 +938,14 @@ void BookmarkManagerGtk::OnLeftTreeViewDragReceived(
     gint y,
     GtkSelectionData* selection_data,
     guint target_type,
-    guint time,
-    BookmarkManagerGtk* bm) {
+    guint time) {
   gboolean get_nodes_success = FALSE;
   gboolean delete_selection_data = FALSE;
 
   std::vector<const BookmarkNode*> nodes =
       bookmark_utils::GetNodesFromSelection(context, selection_data,
                                             target_type,
-                                            bm->profile_,
+                                            profile_,
                                             &delete_selection_data,
                                             &get_nodes_success);
 
@@ -966,9 +964,8 @@ void BookmarkManagerGtk::OnLeftTreeViewDragReceived(
   }
 
   GtkTreeIter iter;
-  gtk_tree_model_get_iter(GTK_TREE_MODEL(bm->left_store_), &iter, path);
-  const BookmarkNode* folder =
-      bm->GetNodeAt(GTK_TREE_MODEL(bm->left_store_), &iter);
+  gtk_tree_model_get_iter(GTK_TREE_MODEL(left_store_), &iter, path);
+  const BookmarkNode* folder = GetNodeAt(GTK_TREE_MODEL(left_store_), &iter);
   gboolean dnd_success = FALSE;
 
   if (folder) {
@@ -976,7 +973,7 @@ void BookmarkManagerGtk::OnLeftTreeViewDragReceived(
          it != nodes.end(); ++it) {
       // Don't try to drop a node into one of its descendants.
       if (!folder->HasAncestor(*it)) {
-        bm->model_->Move(*it, folder, folder->GetChildCount());
+        model_->Move(*it, folder, folder->GetChildCount());
         dnd_success = TRUE;
       }
     }
@@ -987,14 +984,12 @@ void BookmarkManagerGtk::OnLeftTreeViewDragReceived(
                   time);
 }
 
-// static
 gboolean BookmarkManagerGtk::OnLeftTreeViewDragMotion(
     GtkWidget* tree_view,
     GdkDragContext* context,
     gint x,
     gint y,
-    guint time,
-    BookmarkManagerGtk* bm) {
+    guint time) {
   GtkTreePath* path;
   GtkTreeViewDropPosition pos;
   gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(tree_view), x, y,
@@ -1005,7 +1000,7 @@ gboolean BookmarkManagerGtk::OnLeftTreeViewDragMotion(
     GtkTreeIter iter;
     GtkTreeModel* model = gtk_tree_view_get_model(GTK_TREE_VIEW(tree_view));
     gtk_tree_model_get_iter(model, &iter, path);
-    if (bm->GetNodeAt(model, &iter) == NULL)
+    if (GetNodeAt(model, &iter) == NULL)
       return FALSE;
 
     // Only allow INTO.
@@ -1023,41 +1018,36 @@ gboolean BookmarkManagerGtk::OnLeftTreeViewDragMotion(
   return TRUE;
 }
 
-// static
 void BookmarkManagerGtk::OnLeftTreeViewRowCollapsed(
-    GtkTreeView *tree_view,
+    GtkWidget* tree_view,
     GtkTreeIter* iter,
-    GtkTreePath* path,
-    BookmarkManagerGtk* bm) {
+    GtkTreePath* path) {
   // If a selection still exists, do nothing.
-  if (gtk_tree_selection_get_selected(bm->left_selection(), NULL, NULL))
+  if (gtk_tree_selection_get_selected(left_selection(), NULL, NULL))
     return;
 
-  gtk_tree_selection_select_path(bm->left_selection(), path);
+  gtk_tree_selection_select_path(left_selection(), path);
 }
 
-// static
 void BookmarkManagerGtk::OnRightTreeViewDragGet(
     GtkWidget* tree_view,
     GdkDragContext* context,
     GtkSelectionData* selection_data,
     guint target_type,
-    guint time,
-    BookmarkManagerGtk* bm) {
+    guint time) {
   // No selection, do nothing. This shouldn't get hit, but if it does an early
   // return avoids a crash.
-  if (gtk_tree_selection_count_selected_rows(bm->right_selection()) == 0) {
+  if (gtk_tree_selection_count_selected_rows(right_selection()) == 0) {
     NOTREACHED();
     return;
   }
 
-  bookmark_utils::WriteBookmarksToSelection(bm->GetRightSelection(),
+  bookmark_utils::WriteBookmarksToSelection(GetRightSelection(),
                                             selection_data,
                                             target_type,
-                                            bm->profile_);
+                                            profile_);
 }
 
-// static
 void BookmarkManagerGtk::OnRightTreeViewDragReceived(
     GtkWidget* tree_view,
     GdkDragContext* context,
@@ -1065,15 +1055,14 @@ void BookmarkManagerGtk::OnRightTreeViewDragReceived(
     gint y,
     GtkSelectionData* selection_data,
     guint target_type,
-    guint time,
-    BookmarkManagerGtk* bm) {
+    guint time) {
   gboolean dnd_success = FALSE;
   gboolean delete_selection_data = FALSE;
 
   std::vector<const BookmarkNode*> nodes =
       bookmark_utils::GetNodesFromSelection(context, selection_data,
                                             target_type,
-                                            bm->profile_,
+                                            profile_,
                                             &delete_selection_data,
                                             &dnd_success);
 
@@ -1097,9 +1086,9 @@ void BookmarkManagerGtk::OnRightTreeViewDragReceived(
   // |path| will be null when we are looking at an empty folder.
   if (!drop_before && !drop_after && path) {
     GtkTreeIter iter;
-    GtkTreeModel* model = GTK_TREE_MODEL(bm->right_store_);
+    GtkTreeModel* model = GTK_TREE_MODEL(right_store_);
     gtk_tree_model_get_iter(model, &iter, path);
-    const BookmarkNode* node = bm->GetNodeAt(model, &iter);
+    const BookmarkNode* node = GetNodeAt(model, &iter);
     if (node && node->is_folder()) {
       parent = node;
       idx = parent->GetChildCount();
@@ -1113,7 +1102,7 @@ void BookmarkManagerGtk::OnRightTreeViewDragReceived(
     if (path && drop_after)
       gtk_tree_path_next(path);
     // We will get a null path when the drop is below the lowest row.
-    parent = bm->GetFolder();
+    parent = GetFolder();
     idx = !path ? parent->GetChildCount() : gtk_tree_path_get_indices(path)[0];
   }
 
@@ -1121,7 +1110,7 @@ void BookmarkManagerGtk::OnRightTreeViewDragReceived(
        it != nodes.end(); ++it) {
     // Don't try to drop a node into one of its descendants.
     if (!parent->HasAncestor(*it)) {
-      bm->model_->Move(*it, parent, idx);
+      model_->Move(*it, parent, idx);
       idx = parent->IndexOfChild(*it) + 1;
     }
   }
@@ -1130,28 +1119,24 @@ void BookmarkManagerGtk::OnRightTreeViewDragReceived(
   gtk_drag_finish(context, dnd_success, delete_selection_data, time);
 }
 
-// static
 void BookmarkManagerGtk::OnRightTreeViewDragBegin(
     GtkWidget* tree_view,
-    GdkDragContext* drag_context,
-    BookmarkManagerGtk* bm) {
+    GdkDragContext* drag_context) {
   gtk_drag_set_icon_stock(drag_context, GTK_STOCK_DND, 0, 0);
 }
 
-// static
 gboolean BookmarkManagerGtk::OnRightTreeViewDragMotion(
     GtkWidget* tree_view,
     GdkDragContext* context,
     gint x,
     gint y,
-    guint time,
-    BookmarkManagerGtk* bm) {
+    guint time) {
   GtkTreePath* path;
   GtkTreeViewDropPosition pos;
   gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(tree_view), x, y,
                                     &path, &pos);
 
-  const BookmarkNode* parent = bm->GetFolder();
+  const BookmarkNode* parent = GetFolder();
   if (path) {
     int idx =
         gtk_tree_path_get_indices(path)[gtk_tree_path_get_depth(path) - 1];
@@ -1172,40 +1157,32 @@ gboolean BookmarkManagerGtk::OnRightTreeViewDragMotion(
   return TRUE;
 }
 
-// static
 void BookmarkManagerGtk::OnRightTreeViewRowActivated(
-    GtkTreeView* tree_view,
+    GtkWidget* tree_view,
     GtkTreePath* path,
-    GtkTreeViewColumn* column,
-    BookmarkManagerGtk* bm) {
-  std::vector<const BookmarkNode*> nodes = bm->GetRightSelection();
+    GtkTreeViewColumn* column) {
+  std::vector<const BookmarkNode*> nodes = GetRightSelection();
   if (nodes.empty())
     return;
   if (nodes.size() == 1 && nodes[0]->is_folder()) {
     // Double click on a folder descends into the folder.
-    bm->SelectInTree(nodes[0], false);
+    SelectInTree(nodes[0], false);
     return;
   }
-  bookmark_utils::OpenAll(GTK_WINDOW(bm->window_), bm->profile_, NULL, nodes,
+  bookmark_utils::OpenAll(GTK_WINDOW(window_), profile_, NULL, nodes,
                           CURRENT_TAB);
 }
 
-// static
-void BookmarkManagerGtk::OnLeftTreeViewFocusIn(
-    GtkTreeView* tree_view,
-    GdkEventFocus* event,
-    BookmarkManagerGtk* bm) {
-  if (!bm->organize_is_for_left_)
-    bm->ResetOrganizeMenu(true);
+void BookmarkManagerGtk::OnLeftTreeViewFocusIn(GtkWidget* tree_view,
+                                               GdkEventFocus* event) {
+  if (!organize_is_for_left_)
+    ResetOrganizeMenu(true);
 }
 
-// static
-void BookmarkManagerGtk::OnRightTreeViewFocusIn(
-    GtkTreeView* tree_view,
-    GdkEventFocus* event,
-    BookmarkManagerGtk* bm) {
-  if (bm->organize_is_for_left_)
-    bm->ResetOrganizeMenu(false);
+void BookmarkManagerGtk::OnRightTreeViewFocusIn(GtkWidget* tree_view,
+                                                GdkEventFocus* event) {
+  if (organize_is_for_left_)
+    ResetOrganizeMenu(false);
 }
 
 // We do a couple things in this handler.
@@ -1224,12 +1201,10 @@ void BookmarkManagerGtk::OnRightTreeViewFocusIn(
 // We return TRUE for when we want to ignore events (i.e., stop the default
 // handler from handling them), and FALSE for when we want to continue
 // propagation.
-//
-// static
 gboolean BookmarkManagerGtk::OnRightTreeViewButtonPress(
-    GtkWidget* tree_view, GdkEventButton* event, BookmarkManagerGtk* bm) {
+    GtkWidget* tree_view, GdkEventButton* event) {
   // Always let cached mousedown events through.
-  if (bm->sending_delayed_mousedown_)
+  if (sending_delayed_mousedown_)
     return FALSE;
 
   if (event->button != 1)
@@ -1238,8 +1213,8 @@ gboolean BookmarkManagerGtk::OnRightTreeViewButtonPress(
   // If a user double clicks, we will get two button presses in a row without
   // any intervening mouse up, hence we must flush delayed mousedowns here as
   // well as in the button release handler.
-  if (bm->delaying_mousedown_) {
-    bm->SendDelayedMousedown();
+  if (delaying_mousedown_) {
+    SendDelayedMousedown();
     return FALSE;
   }
 
@@ -1261,13 +1236,13 @@ gboolean BookmarkManagerGtk::OnRightTreeViewButtonPress(
   if (path == NULL) {
     // Checking that the widget already has focus matches libegg behavior.
     if (GTK_WIDGET_HAS_FOCUS(tree_view))
-      gtk_tree_selection_unselect_all(bm->right_selection());
+      gtk_tree_selection_unselect_all(right_selection());
     return FALSE;
   }
 
-  if (gtk_tree_selection_path_is_selected(bm->right_selection(), path)) {
-    bm->mousedown_event_ = *event;
-    bm->delaying_mousedown_ = true;
+  if (gtk_tree_selection_path_is_selected(right_selection(), path)) {
+    mousedown_event_ = *event;
+    delaying_mousedown_ = true;
     gtk_tree_path_free(path);
     return TRUE;
   }
@@ -1276,24 +1251,23 @@ gboolean BookmarkManagerGtk::OnRightTreeViewButtonPress(
   return FALSE;
 }
 
-// static
 gboolean BookmarkManagerGtk::OnRightTreeViewMotion(
-    GtkWidget* tree_view, GdkEventMotion* event, BookmarkManagerGtk* bm) {
+    GtkWidget* tree_view, GdkEventMotion* event) {
   // Swallow motion events when no row is selected. This prevents the initiation
   // of empty drags.
-  if (gtk_tree_selection_count_selected_rows(bm->right_selection()) == 0)
+  if (gtk_tree_selection_count_selected_rows(right_selection()) == 0)
     return TRUE;
 
   // Otherwise this handler is only used for the multi-drag workaround.
-  if (!bm->delaying_mousedown_)
+  if (!delaying_mousedown_)
     return FALSE;
 
   if (gtk_drag_check_threshold(tree_view,
-                               static_cast<gint>(bm->mousedown_event_.x),
-                               static_cast<gint>(bm->mousedown_event_.y),
+                               static_cast<gint>(mousedown_event_.x),
+                               static_cast<gint>(mousedown_event_.y),
                                static_cast<gint>(event->x),
                                static_cast<gint>(event->y))) {
-    bm->delaying_mousedown_ = false;
+    delaying_mousedown_ = false;
     GtkTargetList* targets = gtk_dnd_util::GetTargetListFromCodeMask(
         bookmark_utils::GetCodeMask(false));
     gtk_drag_begin(tree_view, targets, GDK_ACTION_MOVE,
@@ -1305,39 +1279,36 @@ gboolean BookmarkManagerGtk::OnRightTreeViewMotion(
   return FALSE;
 }
 
-// static
 gboolean BookmarkManagerGtk::OnTreeViewButtonPress(
-    GtkWidget* tree_view, GdkEventButton* button, BookmarkManagerGtk* bm) {
+    GtkWidget* tree_view, GdkEventButton* button) {
   if (button->button != 3)
     return FALSE;
 
-  if (bm->ignore_rightclicks_)
+  if (ignore_rightclicks_)
     return FALSE;
 
   // If the cursor is not hovering over a selected row, let it propagate
   // to the default handler so that a selection change may occur.
   if (!CursorIsOverSelection(GTK_TREE_VIEW(tree_view))) {
-    bm->ignore_rightclicks_ = true;
+    ignore_rightclicks_ = true;
     gtk_propagate_event(tree_view, reinterpret_cast<GdkEvent*>(button));
-    bm->ignore_rightclicks_ = false;
+    ignore_rightclicks_ = false;
   }
 
-  bm->context_menu_->PopupAsContext(button->time);
+  context_menu_->PopupAsContext(button->time);
   return TRUE;
 }
 
-// static
 gboolean BookmarkManagerGtk::OnTreeViewButtonRelease(
-    GtkWidget* tree_view, GdkEventButton* button, BookmarkManagerGtk* bm) {
-  if (bm->delaying_mousedown_ && (tree_view == bm->right_tree_view_))
-    bm->SendDelayedMousedown();
+    GtkWidget* tree_view, GdkEventButton* button) {
+  if (delaying_mousedown_ && (tree_view == right_tree_view_))
+    SendDelayedMousedown();
 
   return FALSE;
 }
 
-// static
-gboolean BookmarkManagerGtk::OnTreeViewKeyPress(
-    GtkWidget* tree_view, GdkEventKey* key, BookmarkManagerGtk* bm) {
+gboolean BookmarkManagerGtk::OnTreeViewKeyPress(GtkWidget* tree_view,
+                                                GdkEventKey* key) {
   int command = -1;
 
   if ((key->state & gtk_accelerator_get_default_mod_mask()) ==
@@ -1369,9 +1340,9 @@ gboolean BookmarkManagerGtk::OnTreeViewKeyPress(
   if (command == -1)
     return FALSE;
 
-  if (bm->organize_menu_controller_.get() &&
-      bm->organize_menu_controller_->IsCommandIdEnabled(command)) {
-    bm->organize_menu_controller_->ExecuteCommand(command);
+  if (organize_menu_controller_.get() &&
+      organize_menu_controller_->IsCommandIdEnabled(command)) {
+    organize_menu_controller_->ExecuteCommand(command);
     return TRUE;
   }
 
@@ -1392,24 +1363,20 @@ void BookmarkManagerGtk::OnFolderNameEdited(GtkCellRendererText* render,
                        UTF8ToWide(new_folder_name));
 }
 
-// static
-void BookmarkManagerGtk::OnImportItemActivated(
-    GtkMenuItem* menuitem, BookmarkManagerGtk* bm) {
+void BookmarkManagerGtk::OnImportItemActivated(GtkWidget* menuitem) {
   SelectFileDialog::FileTypeInfo file_type_info;
   file_type_info.extensions.resize(1);
   file_type_info.extensions[0].push_back(FILE_PATH_LITERAL("html"));
   file_type_info.extensions[0].push_back(FILE_PATH_LITERAL("htm"));
   file_type_info.include_all_files = true;
-  bm->select_file_dialog_->SelectFile(
+  select_file_dialog_->SelectFile(
       SelectFileDialog::SELECT_OPEN_FILE, string16(),
       FilePath(""), &file_type_info, 0,
-      std::string(), GTK_WINDOW(bm->window_),
+      std::string(), GTK_WINDOW(window_),
       reinterpret_cast<void*>(IDS_BOOKMARK_MANAGER_IMPORT_MENU));
 }
 
-// static
-void BookmarkManagerGtk::OnExportItemActivated(
-    GtkMenuItem* menuitem, BookmarkManagerGtk* bm) {
+void BookmarkManagerGtk::OnExportItemActivated(GtkWidget* menuitem) {
   SelectFileDialog::FileTypeInfo file_type_info;
   file_type_info.extensions.resize(1);
   file_type_info.extensions[0].push_back(FILE_PATH_LITERAL("html"));
@@ -1420,22 +1387,20 @@ void BookmarkManagerGtk::OnExportItemActivated(
   // save locations differently for different user tasks.
   FilePath suggested_path;
   PathService::Get(chrome::DIR_USER_DATA, &suggested_path);
-  bm->select_file_dialog_->SelectFile(
+  select_file_dialog_->SelectFile(
       SelectFileDialog::SELECT_SAVEAS_FILE, string16(),
       suggested_path.Append("bookmarks.html"), &file_type_info, 0,
-      "html", GTK_WINDOW(bm->window_),
+      "html", GTK_WINDOW(window_),
       reinterpret_cast<void*>(IDS_BOOKMARK_MANAGER_EXPORT_MENU));
 }
 
-// static
-void BookmarkManagerGtk::OnSyncStatusMenuActivated(GtkMenuItem* menu_item,
-                                                   BookmarkManagerGtk* bm) {
-  if (bm->sync_relogin_required_) {
-    DCHECK(bm->sync_service_);
-    bm->sync_service_->ShowLoginDialog();
+void BookmarkManagerGtk::OnSyncStatusMenuActivated(GtkWidget* menu_item) {
+  if (sync_relogin_required_) {
+    DCHECK(sync_service_);
+    sync_service_->ShowLoginDialog();
   } else {
     sync_ui_util::OpenSyncMyBookmarksDialog(
-        bm->profile_, ProfileSyncService::START_FROM_BOOKMARK_MANAGER);
+        profile_, ProfileSyncService::START_FROM_BOOKMARK_MANAGER);
   }
 }
 
diff --git a/chrome/browser/gtk/bookmark_manager_gtk.h b/chrome/browser/gtk/bookmark_manager_gtk.h
index 8ade7f5..0349ceb 100644
--- a/chrome/browser/gtk/bookmark_manager_gtk.h
+++ b/chrome/browser/gtk/bookmark_manager_gtk.h
@@ -8,6 +8,7 @@
 #include <gtk/gtk.h>
 #include <vector>
 
+#include "app/gtk_signal.h"
 #include "base/basictypes.h"
 #include "base/ref_counted.h"
 #include "base/task.h"
@@ -166,12 +167,7 @@ class BookmarkManagerGtk : public BookmarkModelObserver,
   // Search helpers.
   void PerformSearch();
 
-  void OnSearchTextChanged();
-
-  static void OnSearchTextChangedThunk(GtkWidget* search_entry,
-                                       BookmarkManagerGtk* bookmark_manager) {
-    bookmark_manager->OnSearchTextChanged();
-  }
+  CHROMEGTK_CALLBACK_0(BookmarkManagerGtk, void, OnSearchTextChanged);
 
   // TreeView signal handlers.
   static void OnLeftSelectionChanged(GtkTreeSelection* selection,
@@ -180,86 +176,42 @@ class BookmarkManagerGtk : public BookmarkModelObserver,
   static void OnRightSelectionChanged(GtkTreeSelection* selection,
                                       BookmarkManagerGtk* bm);
 
-  static void OnLeftTreeViewDragReceived(GtkWidget* tree_view,
-                                         GdkDragContext* context,
-                                         gint x,
-                                         gint y,
-                                         GtkSelectionData* selection_data,
-                                         guint target_type,
-                                         guint time,
-                                         BookmarkManagerGtk* bm);
-
-  static gboolean OnLeftTreeViewDragMotion(GtkWidget* tree_view,
-                                           GdkDragContext* context,
-                                           gint x,
-                                           gint y,
-                                           guint time,
-                                           BookmarkManagerGtk* bm);
-
-  static void OnLeftTreeViewRowCollapsed(GtkTreeView* tree_view,
-                                         GtkTreeIter* iter,
-                                         GtkTreePath* path,
-                                         BookmarkManagerGtk* bm);
-
-  static void OnRightTreeViewDragGet(GtkWidget* tree_view,
-                                     GdkDragContext* context,
-                                     GtkSelectionData* selection_data,
-                                     guint target_type,
-                                     guint time,
-                                     BookmarkManagerGtk* bm);
-
-  static void OnRightTreeViewDragReceived(GtkWidget* tree_view,
-                                          GdkDragContext* context,
-                                          gint x,
-                                          gint y,
-                                          GtkSelectionData* selection_data,
-                                          guint target_type,
-                                          guint time,
-                                          BookmarkManagerGtk* bm);
-
-  static void OnRightTreeViewDragBegin(GtkWidget* tree_view,
-                                       GdkDragContext* drag_context,
-                                       BookmarkManagerGtk* bm);
-
-  static gboolean OnRightTreeViewDragMotion(GtkWidget* tree_view,
-                                            GdkDragContext* context,
-                                            gint x,
-                                            gint y,
-                                            guint time,
-                                            BookmarkManagerGtk* bm);
-
-  static void OnRightTreeViewRowActivated(GtkTreeView* tree_view,
-                                          GtkTreePath* path,
-                                          GtkTreeViewColumn* column,
-                                          BookmarkManagerGtk* bm);
-
-  static void OnRightTreeViewFocusIn(GtkTreeView* tree_view,
-                                     GdkEventFocus* event,
-                                     BookmarkManagerGtk* bm);
-
-  static void OnLeftTreeViewFocusIn(GtkTreeView* tree_view,
-                                    GdkEventFocus* event,
-                                    BookmarkManagerGtk* bm);
-
-  static gboolean OnRightTreeViewButtonPress(GtkWidget* tree_view,
-                                             GdkEventButton* event,
-                                             BookmarkManagerGtk* bm);
-
-  static gboolean OnRightTreeViewMotion(GtkWidget* tree_view,
-                                        GdkEventMotion* event,
-                                        BookmarkManagerGtk* bm);
-
-  static gboolean OnTreeViewButtonPress(GtkWidget* tree_view,
-                                        GdkEventButton* button,
-                                        BookmarkManagerGtk* bm);
-
-  static gboolean OnTreeViewButtonRelease(GtkWidget* tree_view,
-                                          GdkEventButton* button,
-                                          BookmarkManagerGtk* bm);
-
-  static gboolean OnTreeViewKeyPress(GtkWidget* tree_view,
-                                     GdkEventKey* key,
-                                     BookmarkManagerGtk* bm);
+  CHROMEGTK_CALLBACK_6(BookmarkManagerGtk, void, OnLeftTreeViewDragReceived,
+                       GdkDragContext*, gint, gint, GtkSelectionData*,
+                       guint, guint);
+  CHROMEGTK_CALLBACK_4(BookmarkManagerGtk, gboolean, OnLeftTreeViewDragMotion,
+                       GdkDragContext*, gint, gint, guint);
+
+  CHROMEGTK_CALLBACK_2(BookmarkManagerGtk, void, OnLeftTreeViewRowCollapsed,
+                       GtkTreeIter*, GtkTreePath*);
+  CHROMEGTK_CALLBACK_4(BookmarkManagerGtk, void, OnRightTreeViewDragGet,
+                       GdkDragContext*, GtkSelectionData*, guint, guint);
+
+  CHROMEGTK_CALLBACK_6(BookmarkManagerGtk, void, OnRightTreeViewDragReceived,
+                       GdkDragContext*, gint, gint, GtkSelectionData*,
+                       guint, guint);
+  CHROMEGTK_CALLBACK_1(BookmarkManagerGtk, void, OnRightTreeViewDragBegin,
+                       GdkDragContext*);
+  CHROMEGTK_CALLBACK_4(BookmarkManagerGtk, gboolean, OnRightTreeViewDragMotion,
+                       GdkDragContext*, gint, gint, guint);
+
+  CHROMEGTK_CALLBACK_2(BookmarkManagerGtk, void, OnRightTreeViewRowActivated,
+                       GtkTreePath*, GtkTreeViewColumn*);
+  CHROMEGTK_CALLBACK_1(BookmarkManagerGtk, void, OnRightTreeViewFocusIn,
+                       GdkEventFocus*);
+  CHROMEGTK_CALLBACK_1(BookmarkManagerGtk, void, OnLeftTreeViewFocusIn,
+                       GdkEventFocus*);
+  CHROMEGTK_CALLBACK_1(BookmarkManagerGtk, gboolean, OnRightTreeViewButtonPress,
+                       GdkEventButton*);
+
+  CHROMEGTK_CALLBACK_1(BookmarkManagerGtk, gboolean, OnRightTreeViewMotion,
+                       GdkEventMotion*);
+  CHROMEGTK_CALLBACK_1(BookmarkManagerGtk, gboolean, OnTreeViewButtonPress,
+                       GdkEventButton*);
+  CHROMEGTK_CALLBACK_1(BookmarkManagerGtk, gboolean, OnTreeViewButtonRelease,
+                       GdkEventButton*);
+  CHROMEGTK_CALLBACK_1(BookmarkManagerGtk, gboolean, OnTreeViewKeyPress,
+                       GdkEventKey*);
 
   // Callback from inline edits to folder names.  This changes the name in the
   // model.
@@ -269,37 +221,18 @@ class BookmarkManagerGtk : public BookmarkModelObserver,
                                  BookmarkManagerGtk* bm);
 
   // Tools menu item callbacks.
-  static void OnImportItemActivated(GtkMenuItem* menuitem,
-                                    BookmarkManagerGtk* bm);
-  static void OnExportItemActivated(GtkMenuItem* menuitem,
-                                    BookmarkManagerGtk* bm);
+  CHROMEGTK_CALLBACK_0(BookmarkManagerGtk, void, OnImportItemActivated);
+  CHROMEGTK_CALLBACK_0(BookmarkManagerGtk, void, OnExportItemActivated);
 
   // Sync status menu item callback.
-  static void OnSyncStatusMenuActivated(GtkMenuItem* menu_item,
-                                        BookmarkManagerGtk* bm);
+  CHROMEGTK_CALLBACK_0(BookmarkManagerGtk, void, OnSyncStatusMenuActivated);
 
   // Window callbacks.
-  static gboolean OnWindowDestroyedThunk(GtkWidget* window, gpointer self) {
-    return reinterpret_cast<BookmarkManagerGtk*>(self)->
-        OnWindowDestroyed(window);
-  }
-  gboolean OnWindowDestroyed(GtkWidget* window);
-
-  static gboolean OnWindowStateChangedThunk(GtkWidget* window,
-                                            GdkEventWindowState* event,
-                                            gpointer self) {
-    return reinterpret_cast<BookmarkManagerGtk*>(self)->
-        OnWindowStateChanged(window, event);
-  }
-  gboolean OnWindowStateChanged(GtkWidget* window, GdkEventWindowState* event);
-
-  static gboolean OnWindowConfiguredThunk(GtkWidget* window,
-                                          GdkEventConfigure* event,
-                                          gpointer self) {
-    return reinterpret_cast<BookmarkManagerGtk*>(self)->
-        OnWindowConfigured(window, event);
-  }
-  gboolean OnWindowConfigured(GtkWidget* window, GdkEventConfigure* event);
+  CHROMEGTK_CALLBACK_0(BookmarkManagerGtk, gboolean, OnWindowDestroyed);
+  CHROMEGTK_CALLBACK_1(BookmarkManagerGtk, gboolean, OnWindowStateChanged,
+                       GdkEventWindowState*);
+  CHROMEGTK_CALLBACK_1(BookmarkManagerGtk, gboolean, OnWindowConfigured,
+                       GdkEventConfigure*);
 
   // Handles an accelerator being pressed.
   static gboolean OnGtkAccelerator(GtkAccelGroup* accel_group,
diff --git a/chrome/browser/gtk/bookmark_menu_controller_gtk.cc b/chrome/browser/gtk/bookmark_menu_controller_gtk.cc
index 52eba7f..4f5c76f 100644
--- a/chrome/browser/gtk/bookmark_menu_controller_gtk.cc
+++ b/chrome/browser/gtk/bookmark_menu_controller_gtk.cc
@@ -100,7 +100,7 @@ BookmarkMenuController::BookmarkMenuController(Browser* browser,
   menu_ = gtk_menu_new();
   BuildMenu(node, start_child_index, menu_);
   g_signal_connect(menu_, "hide",
-                   G_CALLBACK(OnMenuHidden), this);
+                   G_CALLBACK(OnMenuHiddenThunk), this);
   gtk_widget_show_all(menu_);
 }
 
@@ -158,7 +158,7 @@ void BookmarkMenuController::BuildMenu(const BookmarkNode* parent,
          start_child_index < parent->GetChildCount());
 
   g_signal_connect(menu, "button-press-event",
-                   G_CALLBACK(OnButtonPressed), this);
+                   G_CALLBACK(OnButtonPressedThunk), this);
 
   for (int i = start_child_index; i < parent->GetChildCount(); ++i) {
     const BookmarkNode* node = parent->GetChild(i);
@@ -174,10 +174,10 @@ void BookmarkMenuController::BuildMenu(const BookmarkNode* parent,
     gtk_util::SetAlwaysShowImage(menu_item);
 
     g_signal_connect(menu_item, "button-release-event",
-                     G_CALLBACK(OnButtonReleased), this);
+                     G_CALLBACK(OnButtonReleasedThunk), this);
     if (node->is_url()) {
       g_signal_connect(menu_item, "activate",
-                       G_CALLBACK(OnMenuItemActivated), this);
+                       G_CALLBACK(OnMenuItemActivatedThunk), this);
     } else if (node->is_folder()) {
       GtkWidget* submenu = gtk_menu_new();
       BuildMenu(node, 0, submenu);
@@ -193,18 +193,18 @@ void BookmarkMenuController::BuildMenu(const BookmarkNode* parent,
       target_mask |= gtk_dnd_util::TEXT_URI_LIST | gtk_dnd_util::NETSCAPE_URL;
     gtk_dnd_util::SetSourceTargetListFromCodeMask(menu_item, target_mask);
     g_signal_connect(menu_item, "drag-begin",
-                     G_CALLBACK(&OnMenuItemDragBegin), this);
+                     G_CALLBACK(OnMenuItemDragBeginThunk), this);
     g_signal_connect(menu_item, "drag-end",
-                     G_CALLBACK(&OnMenuItemDragEnd), this);
+                     G_CALLBACK(OnMenuItemDragEndThunk), this);
     g_signal_connect(menu_item, "drag-data-get",
-                     G_CALLBACK(&OnMenuItemDragGet), this);
+                     G_CALLBACK(OnMenuItemDragGetThunk), this);
 
     // It is important to connect to this signal after setting up the drag
     // source because we only want to stifle the menu's default handler and
     // not the handler that the drag source uses.
     if (node->is_folder()) {
       g_signal_connect(menu_item, "button-press-event",
-                       G_CALLBACK(OnFolderButtonPressed), this);
+                       G_CALLBACK(OnFolderButtonPressedThunk), this);
     }
 
     gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
@@ -220,20 +220,17 @@ void BookmarkMenuController::BuildMenu(const BookmarkNode* parent,
   }
 }
 
-// static
 gboolean BookmarkMenuController::OnButtonPressed(
     GtkWidget* sender,
-    GdkEventButton* event,
-    BookmarkMenuController* controller) {
-  controller->ignore_button_release_ = false;
+    GdkEventButton* event) {
+  ignore_button_release_ = false;
   GtkMenuShell* menu_shell = GTK_MENU_SHELL(sender);
 
   if (event->button == 3) {
     // If the cursor is outside our bounds, pass this event up to the parent.
     if (!gtk_util::WidgetContainsCursor(sender)) {
       if (menu_shell->parent_menu_shell) {
-        return OnButtonPressed(menu_shell->parent_menu_shell, event,
-                               controller);
+        return OnButtonPressed(menu_shell->parent_menu_shell, event);
       } else {
         // We are the top level menu; we can propagate no further.
         return FALSE;
@@ -259,36 +256,34 @@ gboolean BookmarkMenuController::OnButtonPressed(
     std::vector<const BookmarkNode*> nodes;
     if (node)
       nodes.push_back(node);
-    controller->context_menu_controller_.reset(
+    context_menu_controller_.reset(
         new BookmarkContextMenuController(
-            controller->parent_window_, controller, controller->profile_,
-            controller->page_navigator_, parent, nodes,
+            parent_window_, this, profile_,
+            page_navigator_, parent, nodes,
             BookmarkContextMenuController::BOOKMARK_BAR));
-    controller->context_menu_.reset(
-        new MenuGtk(NULL, controller->context_menu_controller_->menu_model()));
+    context_menu_.reset(
+        new MenuGtk(NULL, context_menu_controller_->menu_model()));
 
     // Our bookmark folder menu loses the grab to the context menu. When the
     // context menu is hidden, re-assert our grab.
     GtkWidget* grabbing_menu = gtk_grab_get_current();
     g_object_ref(grabbing_menu);
-    g_signal_connect(controller->context_menu_->widget(), "hide",
+    g_signal_connect(context_menu_->widget(), "hide",
                      G_CALLBACK(OnContextMenuHide), grabbing_menu);
 
-    controller->context_menu_->PopupAsContext(event->time);
+    context_menu_->PopupAsContext(event->time);
     return TRUE;
   }
 
   return FALSE;
 }
 
-// static
 gboolean BookmarkMenuController::OnButtonReleased(
     GtkWidget* sender,
-    GdkEventButton* event,
-    BookmarkMenuController* controller) {
-  if (controller->ignore_button_release_) {
+    GdkEventButton* event) {
+  if (ignore_button_release_) {
     // Don't handle this message; it was a drag.
-    controller->ignore_button_release_ = false;
+    ignore_button_release_ = false;
     return FALSE;
   }
 
@@ -298,11 +293,11 @@ gboolean BookmarkMenuController::OnButtonReleased(
     if (event->button == 1 || event->button == 2) {
       WindowOpenDisposition disposition =
           event_utils::DispositionFromEventFlags(event->state);
-      controller->NavigateToMenuItem(sender, disposition);
+      NavigateToMenuItem(sender, disposition);
 
       // We need to manually dismiss the popup menu because we're overriding
       // button-release-event.
-      gtk_menu_popdown(GTK_MENU(controller->menu_));
+      gtk_menu_popdown(GTK_MENU(menu_));
       return TRUE;
     }
   } else {
@@ -317,49 +312,36 @@ gboolean BookmarkMenuController::OnButtonReleased(
   return FALSE;
 }
 
-// static
 gboolean BookmarkMenuController::OnFolderButtonPressed(
-    GtkWidget* sender,
-    GdkEventButton* event,
-    BookmarkMenuController* controller) {
+    GtkWidget* sender, GdkEventButton* event) {
   // The button press may start a drag; don't let the default handler run.
   if (event->button == 1)
     return TRUE;
   return FALSE;
 }
 
-// static
-void BookmarkMenuController::OnMenuHidden(GtkWidget* menu,
-    BookmarkMenuController* controller) {
-  if (controller->triggering_widget_) {
-    gtk_chrome_button_unset_paint_state(
-        GTK_CHROME_BUTTON(controller->triggering_widget_));
-  }
+void BookmarkMenuController::OnMenuHidden(GtkWidget* menu) {
+  if (triggering_widget_)
+    gtk_chrome_button_unset_paint_state(GTK_CHROME_BUTTON(triggering_widget_));
 }
 
-// static
-void BookmarkMenuController::OnMenuItemActivated(
-    GtkMenuItem* menu_item, BookmarkMenuController* controller) {
-  controller->NavigateToMenuItem(GTK_WIDGET(menu_item), CURRENT_TAB);
+void BookmarkMenuController::OnMenuItemActivated(GtkWidget* menu_item) {
+  NavigateToMenuItem(menu_item, CURRENT_TAB);
 }
 
-// static
-void BookmarkMenuController::OnMenuItemDragBegin(
-    GtkWidget* menu_item,
-    GdkDragContext* drag_context,
-    BookmarkMenuController* controller) {
+void BookmarkMenuController::OnMenuItemDragBegin(GtkWidget* menu_item,
+                                                 GdkDragContext* drag_context) {
   // The parent menu item might be removed during the drag. Ref it so |button|
   // won't get destroyed.
   g_object_ref(menu_item->parent);
 
   // Signal to any future OnButtonReleased calls that we're dragging instead of
   // pressing.
-  controller->ignore_button_release_ = true;
+  ignore_button_release_ = true;
 
   const BookmarkNode* node = bookmark_utils::BookmarkNodeForWidget(menu_item);
   GtkWidget* window = bookmark_utils::GetDragRepresentation(
-      node, controller->model_,
-      GtkThemeProvider::GetFrom(controller->profile_));
+      node, model_, GtkThemeProvider::GetFrom(profile_));
   gint x, y;
   gtk_widget_get_pointer(menu_item, &x, &y);
   gtk_drag_set_icon_widget(drag_context, window, x, y);
@@ -368,22 +350,17 @@ void BookmarkMenuController::OnMenuItemDragBegin(
   gtk_widget_hide(menu_item);
 }
 
-// static
-void BookmarkMenuController::OnMenuItemDragEnd(
-    GtkWidget* menu_item,
-    GdkDragContext* drag_context,
-    BookmarkMenuController* controller) {
+void BookmarkMenuController::OnMenuItemDragEnd(GtkWidget* menu_item,
+                                               GdkDragContext* drag_context) {
   gtk_widget_show(menu_item);
   g_object_unref(menu_item->parent);
 }
 
-// static
 void BookmarkMenuController::OnMenuItemDragGet(
     GtkWidget* widget, GdkDragContext* context,
     GtkSelectionData* selection_data,
-    guint target_type, guint time,
-    BookmarkMenuController* controller) {
+    guint target_type, guint time) {
   const BookmarkNode* node = bookmark_utils::BookmarkNodeForWidget(widget);
   bookmark_utils::WriteBookmarkToSelection(node, selection_data, target_type,
-                                           controller->profile_);
+                                           profile_);
 }
diff --git a/chrome/browser/gtk/bookmark_menu_controller_gtk.h b/chrome/browser/gtk/bookmark_menu_controller_gtk.h
index ea68a78..843f556 100644
--- a/chrome/browser/gtk/bookmark_menu_controller_gtk.h
+++ b/chrome/browser/gtk/bookmark_menu_controller_gtk.h
@@ -9,6 +9,7 @@
 
 #include <map>
 
+#include "app/gtk_signal.h"
 #include "base/scoped_ptr.h"
 #include "chrome/browser/bookmarks/base_bookmark_model_observer.h"
 #include "chrome/browser/bookmarks/bookmark_context_menu_controller.h"
@@ -67,41 +68,33 @@ class BookmarkMenuController : public BaseBookmarkModelObserver,
   // respectively. We have to override these separate from OnMenuItemActivated
   // because we need to handle right clicks and opening bookmarks with
   // different dispositions.
-  static gboolean OnButtonPressed(GtkWidget* sender,
-                                  GdkEventButton* event,
-                                  BookmarkMenuController* controller);
-  static gboolean OnButtonReleased(GtkWidget* sender,
-                                   GdkEventButton* event,
-                                   BookmarkMenuController* controller);
+  CHROMEGTK_CALLBACK_1(BookmarkMenuController, gboolean, OnButtonPressed,
+                       GdkEventButton*);
+  CHROMEGTK_CALLBACK_1(BookmarkMenuController, gboolean, OnButtonReleased,
+                       GdkEventButton*);
+
   // We connect this handler to the button-press-event signal for folder nodes.
   // It suppresses the normal behavior (popping up the submenu) to allow these
   // nodes to be draggable. The submenu is instead popped up on a
   // button-release-event.
-  static gboolean OnFolderButtonPressed(GtkWidget* sender,
-                                        GdkEventButton* event,
-                                        BookmarkMenuController* controller);
+  CHROMEGTK_CALLBACK_1(BookmarkMenuController, gboolean, OnFolderButtonPressed,
+                       GdkEventButton*);
 
   // We have to stop drawing |triggering_widget_| as active when the menu
   // closes.
-  static void OnMenuHidden(GtkWidget* menu, BookmarkMenuController* controller);
+  CHROMEGTK_CALLBACK_0(BookmarkMenuController, void, OnMenuHidden)
 
   // We respond to the activate signal because things other than mouse button
   // events can trigger it.
-  static void OnMenuItemActivated(GtkMenuItem* menuitem,
-                                  BookmarkMenuController* controller);
+  CHROMEGTK_CALLBACK_0(BookmarkMenuController, void, OnMenuItemActivated);
 
   // The individual GtkMenuItems in the BookmarkMenu are all drag sources.
-  static void OnMenuItemDragBegin(GtkWidget* menu_item,
-                                  GdkDragContext* drag_context,
-                                  BookmarkMenuController* bar);
-  static void OnMenuItemDragEnd(GtkWidget* menu_item,
-                                GdkDragContext* drag_context,
-                                BookmarkMenuController* controller);
-  static void OnMenuItemDragGet(
-      GtkWidget* widget, GdkDragContext* context,
-      GtkSelectionData* selection_data,
-      guint target_type, guint time,
-      BookmarkMenuController* controller);
+  CHROMEGTK_CALLBACK_1(BookmarkMenuController, void, OnMenuItemDragBegin,
+                       GdkDragContext*);
+  CHROMEGTK_CALLBACK_1(BookmarkMenuController, void, OnMenuItemDragEnd,
+                       GdkDragContext*);
+  CHROMEGTK_CALLBACK_4(BookmarkMenuController, void, OnMenuItemDragGet,
+                       GdkDragContext*, GtkSelectionData*, guint, guint);
 
   Browser* browser_;
   Profile* profile_;
diff --git a/chrome/browser/gtk/external_protocol_dialog_gtk.cc b/chrome/browser/gtk/external_protocol_dialog_gtk.cc
index 6be7e1a..cee608f 100644
--- a/chrome/browser/gtk/external_protocol_dialog_gtk.cc
+++ b/chrome/browser/gtk/external_protocol_dialog_gtk.cc
@@ -98,7 +98,8 @@ ExternalProtocolDialogGtk::ExternalProtocolDialogGtk(const GURL& url)
   gtk_widget_show_all(dialog_);
 }
 
-void ExternalProtocolDialogGtk::OnDialogResponse(int response) {
+void ExternalProtocolDialogGtk::OnDialogResponse(GtkWidget* widget,
+                                                 int response) {
   if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbox_))) {
     if (response == GTK_RESPONSE_ACCEPT) {
       ExternalProtocolHandler::SetBlockState(
diff --git a/chrome/browser/gtk/external_protocol_dialog_gtk.h b/chrome/browser/gtk/external_protocol_dialog_gtk.h
index 748739a..c77b284 100644
--- a/chrome/browser/gtk/external_protocol_dialog_gtk.h
+++ b/chrome/browser/gtk/external_protocol_dialog_gtk.h
@@ -5,6 +5,7 @@
 #ifndef CHROME_BROWSER_GTK_EXTERNAL_PROTOCOL_DIALOG_GTK_H_
 #define CHROME_BROWSER_GTK_EXTERNAL_PROTOCOL_DIALOG_GTK_H_
 
+#include "app/gtk_signal.h"
 #include "base/time.h"
 #include "googleurl/src/gurl.h"
 
@@ -17,12 +18,7 @@ class ExternalProtocolDialogGtk {
   explicit ExternalProtocolDialogGtk(const GURL& url);
 
  private:
-  static void OnDialogResponseThunk(GtkWidget* widget,
-                                    int response,
-                                    ExternalProtocolDialogGtk* dialog) {
-    dialog->OnDialogResponse(response);
-  }
-  void OnDialogResponse(int response);
+  CHROMEGTK_CALLBACK_1(ExternalProtocolDialogGtk, void, OnDialogResponse, int);
 
   GtkWidget* dialog_;
   GtkWidget* checkbox_;
diff --git a/chrome/browser/tab_contents/tab_contents_view_gtk.cc b/chrome/browser/tab_contents/tab_contents_view_gtk.cc
index b636757..b549ada 100644
--- a/chrome/browser/tab_contents/tab_contents_view_gtk.cc
+++ b/chrome/browser/tab_contents/tab_contents_view_gtk.cc
@@ -114,11 +114,11 @@ TabContentsViewGtk::TabContentsViewGtk(TabContents* tab_contents)
       constrained_window_(NULL) {
   gtk_widget_set_name(expanded_, "chrome-tab-contents-view");
   g_signal_connect(expanded_, "size-allocate",
-                   G_CALLBACK(OnSizeAllocate), this);
+                   G_CALLBACK(OnSizeAllocateThunk), this);
   g_signal_connect(expanded_, "child-size-request",
-                   G_CALLBACK(OnChildSizeRequest), this);
+                   G_CALLBACK(OnChildSizeRequestThunk), this);
   g_signal_connect(floating_.get(), "set-floating-position",
-                   G_CALLBACK(OnSetFloatingPosition), this);
+                   G_CALLBACK(OnSetFloatingPositionThunk), this);
 
   gtk_container_add(GTK_CONTAINER(floating_.get()), expanded_);
   gtk_widget_show(expanded_);
@@ -181,7 +181,7 @@ RenderWidgetHostView* TabContentsViewGtk::CreateViewForWidget(
   gtk_widget_add_events(content_view, GDK_LEAVE_NOTIFY_MASK |
                         GDK_POINTER_MOTION_MASK);
   g_signal_connect(content_view, "button-press-event",
-                   G_CALLBACK(OnMouseDown), this);
+                   G_CALLBACK(OnMouseDownThunk), this);
   InsertIntoContentArea(content_view);
 
   // Renderer target DnD.
@@ -340,51 +340,47 @@ void TabContentsViewGtk::InsertIntoContentArea(GtkWidget* widget) {
 }
 
 gboolean TabContentsViewGtk::OnMouseDown(GtkWidget* widget,
-    GdkEventButton* event, TabContentsViewGtk* view) {
-  view->last_mouse_down_ = *event;
+                                         GdkEventButton* event) {
+  last_mouse_down_ = *event;
   return FALSE;
 }
 
 void TabContentsViewGtk::OnChildSizeRequest(GtkWidget* widget,
                                             GtkWidget* child,
-                                            GtkRequisition* requisition,
-                                            TabContentsViewGtk* view) {
-  if (view->tab_contents()->delegate()) {
+                                            GtkRequisition* requisition) {
+  if (tab_contents()->delegate()) {
     requisition->height +=
-        view->tab_contents()->delegate()->GetExtraRenderViewHeight();
+        tab_contents()->delegate()->GetExtraRenderViewHeight();
   }
 }
 
 void TabContentsViewGtk::OnSizeAllocate(GtkWidget* widget,
-                                        GtkAllocation* allocation,
-                                        TabContentsViewGtk* view) {
+                                        GtkAllocation* allocation) {
   int width = allocation->width;
   int height = allocation->height;
   // |delegate()| can be NULL here during browser teardown.
-  if (view->tab_contents()->delegate())
-    height += view->tab_contents()->delegate()->GetExtraRenderViewHeight();
+  if (tab_contents()->delegate())
+    height += tab_contents()->delegate()->GetExtraRenderViewHeight();
   gfx::Size size(width, height);
-  view->requested_size_ = size;
+  requested_size_ = size;
 
   // We manually tell our RWHV to resize the renderer content.  This avoids
   // spurious resizes from GTK+.
-  RenderWidgetHostView* rwhv = view->tab_contents()->GetRenderWidgetHostView();
+  RenderWidgetHostView* rwhv = tab_contents()->GetRenderWidgetHostView();
   if (rwhv)
     rwhv->SetSize(size);
-  if (view->tab_contents()->interstitial_page())
-    view->tab_contents()->interstitial_page()->SetSize(size);
+  if (tab_contents()->interstitial_page())
+    tab_contents()->interstitial_page()->SetSize(size);
 }
 
-// static
 void TabContentsViewGtk::OnSetFloatingPosition(
-    GtkFloatingContainer* floating_container, GtkAllocation* allocation,
-    TabContentsViewGtk* tab_contents_view) {
+    GtkWidget* floating_container, GtkAllocation* allocation) {
   // Place each ConstrainedWindow in the center of the view.
   int half_view_width = std::max((allocation->x + allocation->width) / 2, 0);
   int half_view_height = std::max((allocation->y + allocation->height) / 2, 0);
-  if (tab_contents_view->constrained_window_) {
-    GtkWidget* widget = tab_contents_view->constrained_window_->widget();
-    DCHECK(widget->parent == tab_contents_view->floating_.get());
+  if (constrained_window_) {
+    GtkWidget* widget = constrained_window_->widget();
+    DCHECK(widget->parent == floating_.get());
 
     GtkRequisition requisition;
     gtk_widget_size_request(widget, &requisition);
diff --git a/chrome/browser/tab_contents/tab_contents_view_gtk.h b/chrome/browser/tab_contents/tab_contents_view_gtk.h
index 1bded49b..4329165 100644
--- a/chrome/browser/tab_contents/tab_contents_view_gtk.h
+++ b/chrome/browser/tab_contents/tab_contents_view_gtk.h
@@ -7,6 +7,7 @@
 
 #include <gtk/gtk.h>
 
+#include "app/gtk_signal.h"
 #include "base/scoped_ptr.h"
 #include "chrome/browser/gtk/focus_store_gtk.h"
 #include "chrome/browser/tab_contents/tab_contents_view.h"
@@ -80,25 +81,21 @@ class TabContentsViewGtk : public TabContentsView,
   void CancelDragIfAny();
 
   // We keep track of the timestamp of the latest mousedown event.
-  static gboolean OnMouseDown(GtkWidget* widget,
-                              GdkEventButton* event, TabContentsViewGtk* view);
+  CHROMEGTK_CALLBACK_1(TabContentsViewGtk, gboolean, OnMouseDown,
+                       GdkEventButton*);
 
   // Used to adjust the size of its children when the size of |expanded_| is
   // changed.
-  static void OnChildSizeRequest(GtkWidget* widget,
-                                 GtkWidget* child,
-                                 GtkRequisition* requisition,
-                                 TabContentsViewGtk* view);
+  CHROMEGTK_CALLBACK_2(TabContentsViewGtk, void, OnChildSizeRequest,
+                       GtkWidget*, GtkRequisition*);
 
   // Used to propagate the size change of |expanded_| to our RWHV to resize the
   // renderer content.
-  static void OnSizeAllocate(GtkWidget* widget,
-                             GtkAllocation* allocation,
-                             TabContentsViewGtk* view);
+  CHROMEGTK_CALLBACK_1(TabContentsViewGtk, void, OnSizeAllocate,
+                       GtkAllocation*);
 
-  static void OnSetFloatingPosition(
-      GtkFloatingContainer* floating_container, GtkAllocation* allocation,
-      TabContentsViewGtk* tab_contents_view);
+  CHROMEGTK_CALLBACK_1(TabContentsViewGtk, void, OnSetFloatingPosition,
+                       GtkAllocation*);
 
   // Contains |expanded_| as its GtkBin member.
   OwnedWidgetGtk floating_;