Don't crash when reusing a bookmark context menu.

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 <vector>
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
@@ skipping 245 matching lines @@
     }
     gtk_list_store_remove(right_store_, &iter);
   }
 }
 
 // BookmarkManagerGtk, private -------------------------------------------------
 
 BookmarkManagerGtk::BookmarkManagerGtk(Profile* profile)
     : profile_(profile),
       model_(profile->GetBookmarkModel()),
+      organize_is_for_left_(true),
       search_factory_(this),
       select_file_dialog_(SelectFileDialog::Create(this)) {
   InitWidgets();
   g_signal_connect(window_, "destroy",
                    G_CALLBACK(OnWindowDestroy), this);
 
   model_->AddObserver(this);
   if (model_->IsLoaded())
     Loaded(model_);
 
   gtk_widget_show_all(window_);
 }
 
 BookmarkManagerGtk::~BookmarkManagerGtk() {
   model_->RemoveObserver(this);
 }
 
 void BookmarkManagerGtk::InitWidgets() {
   window_ = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   gtk_window_set_title(GTK_WINDOW(window_),
       l10n_util::GetStringUTF8(IDS_BOOKMARK_MANAGER_TITLE).c_str());
   // TODO(estade): use dimensions based on
   // IDS_BOOKMARK_MANAGER_DIALOG_WIDTH_CHARS and
   // IDS_BOOKMARK_MANAGER_DIALOG_HEIGHT_LINES.
   gtk_window_set_default_size(GTK_WINDOW(window_), 640, 480);
 
-  std::vector<BookmarkNode*> nodes;
-  organize_menu_.reset(new BookmarkContextMenu(window_, profile_, NULL, NULL,
-      NULL, nodes, BookmarkContextMenu::BOOKMARK_MANAGER_ORGANIZE_MENU));
-
   // Build the organize and tools menus.
-  GtkWidget* organize = gtk_menu_item_new_with_label(
+  organize_ = gtk_menu_item_new_with_label(
       l10n_util::GetStringUTF8(IDS_BOOKMARK_MANAGER_ORGANIZE_MENU).c_str());
-  gtk_menu_item_set_submenu(GTK_MENU_ITEM(organize), organize_menu_->menu());
 
   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);
 
   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);
 
   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);
 
   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), organize_);
   gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), tools);
   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());
   search_entry_ = gtk_entry_new();
   g_signal_connect(search_entry_, "changed",
                    G_CALLBACK(OnSearchTextChangedThunk), this);
 
@@ skipping 11 matching lines @@
   // when it first shows (depending on the WM, this may or may not be the value
   // we set below in gtk_window_set_size()).
   gtk_paned_set_position(GTK_PANED(paned), 200);
   gtk_paned_pack1(GTK_PANED(paned), left_pane, FALSE, FALSE);
   gtk_paned_pack2(GTK_PANED(paned), right_pane, TRUE, FALSE);
 
   GtkWidget* vbox = gtk_vbox_new(FALSE, 0);
   gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
   gtk_box_pack_start(GTK_BOX(vbox), paned, TRUE, TRUE, 0);
   gtk_container_add(GTK_CONTAINER(window_), vbox);
+
+  ResetOrganizeMenu(true);
 }
 
 GtkWidget* BookmarkManagerGtk::MakeLeftPane() {
   left_store_ = bookmark_utils::MakeFolderTreeStore();
 
   GtkTreeViewColumn* icon_column = gtk_tree_view_column_new_with_attributes(
       "", gtk_cell_renderer_pixbuf_new(), "pixbuf", bookmark_utils::FOLDER_ICON,
        NULL);
   GtkTreeViewColumn* name_column = gtk_tree_view_column_new_with_attributes(
       "", gtk_cell_renderer_text_new(), "text", bookmark_utils::FOLDER_NAME,
        NULL);
 
   left_tree_view_ = gtk_tree_view_new_with_model(GTK_TREE_MODEL(left_store_));
   // Let |tree_view| own the store.
   g_object_unref(left_store_);
   gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(left_tree_view_), FALSE);
   gtk_tree_view_append_column(GTK_TREE_VIEW(left_tree_view_), icon_column);
   gtk_tree_view_append_column(GTK_TREE_VIEW(left_tree_view_), name_column);
   // 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_signal_connect(left_tree_view_, "focus-in-event",
+                   G_CALLBACK(OnLeftTreeViewFocusIn), this);
 
   // The left side is only a drag destination (not a source).
   gtk_drag_dest_set(left_tree_view_, GTK_DEST_DEFAULT_DROP,
                     bookmark_utils::kTargetTable,
                     bookmark_utils::kTargetTableSize,
                     GDK_ACTION_MOVE);
 
   g_signal_connect(left_tree_view_, "drag-data-received",
                    G_CALLBACK(&OnLeftTreeViewDragReceived), this);
   g_signal_connect(left_tree_view_, "drag-motion",
@@ skipping 34 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_);
   g_signal_connect(right_tree_view_, "row-activated",
                    G_CALLBACK(OnRightTreeViewRowActivated), this);
   g_signal_connect(right_selection(), "changed",
                    G_CALLBACK(OnRightSelectionChanged), this);
+  g_signal_connect(right_tree_view_, "focus-in-event",
+                   G_CALLBACK(OnRightTreeViewFocusIn), this);
 
   // We don't advertise GDK_ACTION_COPY, but since we don't explicitly do
   // any deleting following a succesful move, this should work.
   gtk_drag_source_set(right_tree_view_,
                       GDK_BUTTON1_MASK,
                       bookmark_utils::kTargetTable,
                       bookmark_utils::kTargetTableSize,
                       GDK_ACTION_MOVE);
 
   // We connect to drag dest signals, but we don't actually enable the widget
@@ skipping 11 matching lines @@
   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;
 }
 
+void BookmarkManagerGtk::ResetOrganizeMenu(bool left) {
+  organize_is_for_left_ = left;
+  BookmarkNode* parent = GetFolder();
+  std::vector<BookmarkNode*> nodes;
+  if (!left)
+    nodes = GetRightSelection();
+  else if (parent)
+    nodes.push_back(parent);
+
+  organize_menu_.reset(new BookmarkContextMenu(window_, profile_, NULL, NULL,
+      parent, nodes, BookmarkContextMenu::BOOKMARK_MANAGER_ORGANIZE_MENU));
+  gtk_menu_item_set_submenu(GTK_MENU_ITEM(organize_), organize_menu_->menu());
+}
+
 void BookmarkManagerGtk::BuildLeftStore() {
   GtkTreeIter select_iter;
   bookmark_utils::AddToTreeStore(model_,
       model_->GetBookmarkBarNode()->id(), left_store_, &select_iter);
   gtk_tree_selection_select_iter(left_selection(), &select_iter);
 
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   gtk_tree_store_append(left_store_, &select_iter, NULL);
   gtk_tree_store_set(left_store_, &select_iter,
       bookmark_utils::FOLDER_ICON,
@@ skipping 207 matching lines @@
       kSearchDelayMS);
 }
 
 // static
 void BookmarkManagerGtk::OnLeftSelectionChanged(GtkTreeSelection* selection,
     BookmarkManagerGtk* bm) {
   // Sometimes we won't have a selection for a short period of time
   // (specifically, when the user collapses an ancestor of the selected row).
   // The context menu and right store will momentarily be stale, but we should
   // presently receive another selection changed event that will refresh them.
-  if (gtk_tree_selection_count_selected_rows(bm->left_selection()) == 0)
+  if (gtk_tree_selection_count_selected_rows(selection) == 0)
     return;
 
-  BookmarkNode* parent = bm->GetFolder();
-
-  // Update the context menu.
-  bm->organize_menu_->set_parent(parent);
-  std::vector<BookmarkNode*> nodes;
-  if (parent)
-    nodes.push_back(parent);
-  bm->organize_menu_->set_selection(nodes);
-
+  bm->ResetOrganizeMenu(true);
   bm->BuildRightStore();
 }
 
 // static
 void BookmarkManagerGtk::OnRightSelectionChanged(GtkTreeSelection* selection,
     BookmarkManagerGtk* bookmark_manager) {
-  // Update the context menu.
-  bookmark_manager->organize_menu_->set_selection(
-      bookmark_manager->GetRightSelection());
+  if (gtk_tree_selection_count_selected_rows(selection) == 0)
+    return;
+
+  bookmark_manager->ResetOrganizeMenu(false);
 }
 
 // statuc
 void BookmarkManagerGtk::OnLeftTreeViewDragReceived(
     GtkWidget* tree_view, GdkDragContext* context, gint x, gint y,
     GtkSelectionData* selection_data, guint target_type, guint time,
     BookmarkManagerGtk* bm) {
   gboolean dnd_success = FALSE;
   gboolean delete_selection_data = FALSE;
 
@@ skipping 195 matching lines @@
     return;
   if (nodes.size() == 1 && nodes[0]->is_folder()) {
     // Double click on a folder descends into the folder.
     bm->SelectInTree(nodes[0], false);
     return;
   }
   bookmark_utils::OpenAll(bm->window_, bm->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);
+}
+
+// static
+void BookmarkManagerGtk::OnRightTreeViewFocusIn(GtkTreeView* tree_view,
+    GdkEventFocus* event, BookmarkManagerGtk* bm) {
+  if (bm->organize_is_for_left_)
+    bm->ResetOrganizeMenu(false);
+}
+
+// static
 void BookmarkManagerGtk::OnImportItemActivated(GtkMenuItem* menuitem,
                                                BookmarkManagerGtk* bm) {
   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(
       SelectFileDialog::SELECT_OPEN_FILE, string16(),
       FilePath(""), &file_type_info, 0,
@@ skipping 36 matching lines @@
   } else if (id == IDS_BOOKMARK_MANAGER_EXPORT_MENU) {
     if (g_browser_process->io_thread()) {
       bookmark_html_writer::WriteBookmarks(
           g_browser_process->io_thread()->message_loop(), model_,
           path.ToWStringHack());
     }
   } else {
     NOTREACHED();
   }
 }