GTK: More transitions to thunk definition macros.

chrome/browser/gtk/bookmark_manager_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/bookmark_manager_gtk.h"
 
 #include <gdk/gdkkeysyms.h>
 #include <vector>
 
 #include "app/gtk_dnd_util.h"
@@ skipping 363 matching lines @@
   window_bounds_.SetRect(x, y, width, height);
 
   // Build the organize and tools menus.
   organize_ = gtk_menu_item_new_with_label(
       l10n_util::GetStringUTF8(IDS_BOOKMARK_MANAGER_ORGANIZE_MENU).c_str());
 
   GtkWidget* import_item = gtk_menu_item_new_with_mnemonic(
       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);
   gtk_menu_shell_append(GTK_MENU_SHELL(tools_menu), export_item);
 
   GtkWidget* tools = gtk_menu_item_new_with_label(
       l10n_util::GetStringUTF8(IDS_BOOKMARK_MANAGER_TOOLS_MENU).c_str());
   gtk_menu_item_set_submenu(GTK_MENU_ITEM(tools), tools_menu);
 
   // 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_);
   gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), tools);
   gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), sync_status_menu_);
   SetMenuBarStyle();
   gtk_widget_set_name(menu_bar, "chrome-bm-menubar");
 
   GtkWidget* search_label = gtk_label_new(
       l10n_util::GetStringUTF8(IDS_BOOKMARK_MANAGER_SEARCH_TITLE).c_str());
@@ skipping 42 matching lines @@
                                          this, NULL));
 }
 
 GtkWidget* BookmarkManagerGtk::MakeLeftPane() {
   left_store_ = bookmark_utils::MakeFolderTreeStore();
   left_tree_view_ = bookmark_utils::MakeTreeViewForStore(left_store_);
 
   // 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_));
   g_signal_connect(cell_renderer_text, "edited",
                    G_CALLBACK(OnFolderNameEdited), this);
 
   // The left side is only a drag destination (not a source).
   gtk_drag_dest_set(left_tree_view_, GTK_DEST_DEFAULT_DROP,
                     NULL, 0, GDK_ACTION_MOVE);
   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),
                                  GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
   gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled),
                                       GTK_SHADOW_ETCHED_IN);
   gtk_container_add(GTK_CONTAINER(scrolled), left_tree_view_);
 
   return scrolled;
 }
@@ skipping 28 matching lines @@
 
   right_tree_view_ = gtk_tree_view_new_with_model(GTK_TREE_MODEL(right_store_));
   // Let |tree_view| own the store.
   g_object_unref(right_store_);
   gtk_tree_view_append_column(GTK_TREE_VIEW(right_tree_view_), title_column_);
   gtk_tree_view_append_column(GTK_TREE_VIEW(right_tree_view_), url_column_);
   gtk_tree_view_append_column(GTK_TREE_VIEW(right_tree_view_), path_column_);
   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
   // Gnome desktop (nautilus).
   gtk_drag_source_set(right_tree_view_, GDK_BUTTON1_MASK, NULL, 0,
       static_cast<GdkDragAction>(GDK_ACTION_MOVE | GDK_ACTION_COPY |
                                  GDK_ACTION_LINK));
   gtk_dnd_util::SetSourceTargetListFromCodeMask(
       right_tree_view_, kSourceTargetMask);
 
   // We connect to drag dest signals, but we don't actually enable the widget
   // 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),
                                  GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
   gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled),
                                       GTK_SHADOW_ETCHED_IN);
   gtk_container_add(GTK_CONTAINER(scrolled), right_tree_view_);
 
   return scrolled;
 }
@@ skipping 311 matching lines @@
         gtk_tree_model_iter_n_children(GTK_TREE_MODEL(left_store_), NULL) - 1;
     GtkTreeIter iter;
     gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(left_store_), &iter, NULL,
                                   index);
     gtk_tree_selection_select_iter(left_selection(), &iter);
   } else {
     BuildRightStore();
   }
 }
 
-void BookmarkManagerGtk::OnSearchTextChanged() {
+void BookmarkManagerGtk::OnSearchTextChanged(GtkWidget* widget) {
   search_factory_.RevokeAll();
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
       search_factory_.NewRunnableMethod(&BookmarkManagerGtk::PerformSearch),
       kSearchDelayMS);
 }
 
 // static
 void BookmarkManagerGtk::OnLeftSelectionChanged(GtkTreeSelection* selection,
                                                 BookmarkManagerGtk* bm) {
   // If the selection is (newly) empty, then make the right tree view take
@@ skipping 13 matching lines @@
   // If the selection is (newly) empty, then make the left tree view take
   // over the organize menu.
   if (gtk_tree_selection_count_selected_rows(selection) == 0) {
     bm->ResetOrganizeMenu(true);
     return;
   }
 
   bm->ResetOrganizeMenu(false);
 }
 
-// static
 void BookmarkManagerGtk::OnLeftTreeViewDragReceived(
     GtkWidget* tree_view,
     GdkDragContext* context,
     gint x,
     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);
 
   if (nodes.empty() || !get_nodes_success) {
     gtk_drag_finish(context, FALSE, delete_selection_data, time);
     return;
   }
 
   GtkTreePath* path;
   GtkTreeViewDropPosition pos;
   gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(tree_view), x, y,
                                     &path, &pos);
   if (!path) {
     gtk_drag_finish(context, FALSE, delete_selection_data, time);
     return;
   }
 
   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) {
     for (std::vector<const BookmarkNode*>::iterator it = nodes.begin();
          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;
       }
     }
   }
 
   gtk_tree_path_free(path);
   gtk_drag_finish(context, dnd_success, delete_selection_data && dnd_success,
                   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,
                                     &path, &pos);
 
   if (path) {
     // Don't accept drops over the "Search" or "Recently added" folders.
     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.
     if (pos == GTK_TREE_VIEW_DROP_BEFORE)
       pos = GTK_TREE_VIEW_DROP_INTO_OR_BEFORE;
     else if (pos == GTK_TREE_VIEW_DROP_AFTER)
       pos = GTK_TREE_VIEW_DROP_INTO_OR_AFTER;
     gtk_tree_view_set_drag_dest_row(GTK_TREE_VIEW(tree_view), path, pos);
   } else {
     return FALSE;
   }
 
   gdk_drag_status(context, GDK_ACTION_MOVE, time);
   gtk_tree_path_free(path);
   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,
     gint x,
     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);
 
   if (nodes.empty()) {
     gtk_drag_finish(context, dnd_success, delete_selection_data, time);
     return;
   }
 
   GtkTreePath* path;
   GtkTreeViewDropPosition pos;
   gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(tree_view), x, y,
                                     &path, &pos);
 
   bool drop_before = pos == GTK_TREE_VIEW_DROP_BEFORE;
   bool drop_after = pos == GTK_TREE_VIEW_DROP_AFTER;
 
   // The parent folder and index therein to drop the nodes.
   const BookmarkNode* parent = NULL;
   int idx = -1;
 
   // |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();
     } else {
       drop_before = pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE;
       drop_after = pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER;
     }
   }
 
   if (drop_before || drop_after || !path) {
     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];
   }
 
   for (std::vector<const BookmarkNode*>::iterator it = nodes.begin();
        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;
     }
   }
 
   gtk_tree_path_free(path);
   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];
     // Only allow INTO if the node is a folder.
     if (parent->GetChild(idx)->is_url()) {
       if (pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE)
         pos = GTK_TREE_VIEW_DROP_BEFORE;
       else if (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER)
         pos = GTK_TREE_VIEW_DROP_AFTER;
     }
     gtk_tree_view_set_drag_dest_row(GTK_TREE_VIEW(tree_view), path, pos);
   } else {
     // We allow a drop if the drag is over the bottom of the tree view,
     // but we don't draw any indication.
   }
 
   gdk_drag_status(context, GDK_ACTION_MOVE, time);
   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.
 //
 // 1. On left clicks that occur below the lowest row, unselect all selected
 // rows. This is not a native GtkTreeView behavior, but it is added by libegg
 // and is thus present in Nautilus. This is the path == NULL path.
 // 2. Cache left clicks that occur on an already active selection. If the user
 // begins a drag, then we will throw away this event and initiate a drag on the
 // tree view manually. If the user doesn't begin a drag (e.g. just releases the
 // button), send both events to the tree view. This is a workaround for
 // http://crbug.com/15240. If we don't do this, when the user tries to drag
 // a group of selected rows, the click at the start of the drag will deselect
 // all rows except the one the cursor is over.
 //
 // 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)
     return FALSE;
 
   // 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;
   }
 
   if (event->window != gtk_tree_view_get_bin_window(GTK_TREE_VIEW(tree_view)))
     return FALSE;
 
   gint tree_x, tree_y;
   gtk_tree_view_convert_bin_window_to_widget_coords(
       GTK_TREE_VIEW(tree_view),
       static_cast<gint>(event->x),
       static_cast<gint>(event->y),
       &tree_x, &tree_y);
 
   GtkTreePath* path;
   gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(tree_view),
                                 tree_x, tree_y,
                                 &path, NULL, NULL, NULL);
 
   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;
   }
 
   gtk_tree_path_free(path);
   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(
         kSourceTargetMask);
     gtk_drag_begin(tree_view, targets, GDK_ACTION_MOVE,
                    1, reinterpret_cast<GdkEvent*>(event));
     // The drag adds a ref; let it own the list.
     gtk_target_list_unref(targets);
   }
 
   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()) ==
       GDK_SHIFT_MASK) {
     if (key->keyval == GDK_Delete)
       command = IDS_CUT;
     else if (key->keyval == GDK_Insert)
       command = IDS_PASTE;
   } else if ((key->state & gtk_accelerator_get_default_mod_mask()) ==
              GDK_CONTROL_MASK) {
@@ skipping 11 matching lines @@
       default:
         break;
     }
   } else if (key->keyval == GDK_Delete) {
     command = IDS_BOOKMARK_BAR_REMOVE;
   }
 
   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;
   }
 
   return FALSE;
 }
 
 // static
 void BookmarkManagerGtk::OnFolderNameEdited(GtkCellRendererText* render,
     gchar* path, gchar* new_folder_name, BookmarkManagerGtk* bm) {
   // A folder named was edited in place.  Sync the change to the bookmark
   // model.
   GtkTreeIter iter;
   GtkTreePath* tree_path = gtk_tree_path_new_from_string(path);
   gboolean rv = gtk_tree_model_get_iter(GTK_TREE_MODEL(bm->left_store_),
                                         &iter, tree_path);
   DCHECK(rv);
   bm->model_->SetTitle(bm->GetNodeAt(GTK_TREE_MODEL(bm->left_store_), &iter),
                        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"));
   file_type_info.include_all_files = true;
   // TODO(estade): If a user exports a bookmark file then we will remember the
   // download location. If the user subsequently downloads a file, we will
   // suggest this cached download location. This is bad! We ought to remember
   // 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);
   }
 }
 
 gboolean BookmarkManagerGtk::OnWindowDestroyed(GtkWidget* window) {
   DCHECK_EQ(this, manager);
 
   if (g_browser_process->local_state()) {
     DictionaryValue* placement_pref =
         g_browser_process->local_state()->GetMutableDictionary(
             prefs::kBookmarkManagerPlacement);
@@ skipping 100 matching lines @@
                                                 username);
   } else if (sync_service_->SetupInProgress()) {
     status_label = l10n_util::GetStringUTF16(IDS_SYNC_NTP_SETUP_IN_PROGRESS);
   } else {
     status_label = l10n_util::GetStringUTF16(IDS_SYNC_START_SYNC_BUTTON_LABEL);
   }
   GtkWidget* sync_status_label = gtk_bin_get_child(GTK_BIN(sync_status_menu_));
   gtk_label_set_label(GTK_LABEL(sync_status_label),
                       UTF16ToUTF8(status_label).c_str());
 }