Unfork BookmarkMenuGtk and BookmarkMenuController.

This is step 2 of 3. bookmark_context_menu_controller_gtk will eventually replace bookmark_context_menu_controller; for now it is separate because getting Windows to use it is another huge hassle.

BUG=32830
TEST=manual + trybots
Review URL: http://codereview.chromium.org/563017

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

9 files changed, 248 insertions, 219 deletions

diff --git a/chrome/browser/gtk/bookmark_context_menu_gtk.cc b/chrome/browser/bookmarks/bookmark_context_menu_controller_gtk.cc
index 4c20ff3..857630e 100644
--- a/chrome/browser/gtk/bookmark_context_menu_gtk.cc
+++ b/chrome/browser/bookmarks/bookmark_context_menu_controller_gtk.cc
@@ -2,7 +2,7 @@
 // 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_context_menu_gtk.h"
+#include "chrome/browser/bookmarks/bookmark_context_menu_controller_gtk.h"
 
 #include "app/l10n_util.h"
 #include "base/compiler_specific.h"
@@ -10,13 +10,10 @@
 #include "chrome/browser/bookmarks/bookmark_manager.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
-#include "chrome/browser/browser.h"
-#include "chrome/browser/browser_list.h"
 #include "chrome/browser/input_window_dialog.h"
 #include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents/page_navigator.h"
-#include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "grit/generated_resources.h"
@@ -81,7 +78,7 @@ class EditFolderController : public InputWindowDialog::Delegate,
         l10n_util::GetString(IDS_BOOMARK_BAR_EDIT_FOLDER_LABEL);
     std::wstring contents = is_new_ ?
         l10n_util::GetString(IDS_BOOMARK_EDITOR_NEW_FOLDER_NAME) :
-        node_->GetTitle();
+        UTF16ToWide(node_->GetTitleAsString16());
 
     dialog_ = InputWindowDialog::Create(wnd, title, label, contents, this);
     model_->AddObserver(this);
@@ -195,101 +192,112 @@ class SelectOnCreationHandler : public BookmarkEditor::Handler {
 
 }  // namespace
 
-// BookmarkContextMenuGtk -------------------------------------------
-
-BookmarkContextMenuGtk::BookmarkContextMenuGtk(
-    gfx::NativeWindow wnd,
+BookmarkContextMenuController::BookmarkContextMenuController(
+    gfx::NativeWindow parent_window,
+    BookmarkContextMenuControllerDelegate* delegate,
     Profile* profile,
-    Browser* browser,
     PageNavigator* navigator,
     const BookmarkNode* parent,
     const std::vector<const BookmarkNode*>& selection,
-    ConfigurationType configuration,
-    Delegate* delegate)
-    : wnd_(wnd),
+    ConfigurationType configuration)
+    : parent_window_(parent_window),
+      delegate_(delegate),
       profile_(profile),
-      browser_(browser),
       navigator_(navigator),
       parent_(parent),
       selection_(selection),
-      model_(profile->GetBookmarkModel()),
       configuration_(configuration),
-      delegate_(delegate),
-      model_changed_(false) {
+      model_(profile->GetBookmarkModel()) {
   DCHECK(profile_);
   DCHECK(model_->IsLoaded());
   menu_model_.reset(new menus::SimpleMenuModel(this));
+  model_->AddObserver(this);
+
+  BuildMenu();
+}
 
-  if (configuration != BOOKMARK_MANAGER_ORGANIZE_MENU) {
-    if (selection.size() == 1 && selection[0]->is_url()) {
-      AppendItem(IDS_BOOMARK_BAR_OPEN_ALL, IDS_BOOMARK_BAR_OPEN_IN_NEW_TAB);
-      AppendItem(IDS_BOOMARK_BAR_OPEN_ALL_NEW_WINDOW,
-                 IDS_BOOMARK_BAR_OPEN_IN_NEW_WINDOW);
-      AppendItem(IDS_BOOMARK_BAR_OPEN_ALL_INCOGNITO,
-                 IDS_BOOMARK_BAR_OPEN_INCOGNITO);
+BookmarkContextMenuController::~BookmarkContextMenuController() {
+  if (model_)
+    model_->RemoveObserver(this);
+}
+
+void BookmarkContextMenuController::BuildMenu() {
+  if (configuration_ != BOOKMARK_MANAGER_ORGANIZE_MENU) {
+    if (selection_.size() == 1 && selection_[0]->is_url()) {
+      AddItem(IDS_BOOMARK_BAR_OPEN_ALL,
+              IDS_BOOMARK_BAR_OPEN_IN_NEW_TAB);
+      AddItem(IDS_BOOMARK_BAR_OPEN_ALL_NEW_WINDOW,
+              IDS_BOOMARK_BAR_OPEN_IN_NEW_WINDOW);
+      AddItem(IDS_BOOMARK_BAR_OPEN_ALL_INCOGNITO,
+              IDS_BOOMARK_BAR_OPEN_INCOGNITO);
     } else {
-      AppendItem(IDS_BOOMARK_BAR_OPEN_ALL, IDS_BOOMARK_BAR_OPEN_ALL);
-      AppendItem(IDS_BOOMARK_BAR_OPEN_ALL_NEW_WINDOW,
-                 IDS_BOOMARK_BAR_OPEN_ALL_NEW_WINDOW);
-      AppendItem(IDS_BOOMARK_BAR_OPEN_ALL_INCOGNITO,
-                 IDS_BOOMARK_BAR_OPEN_ALL_INCOGNITO);
+      AddItem(IDS_BOOMARK_BAR_OPEN_ALL);
+      AddItem(IDS_BOOMARK_BAR_OPEN_ALL_NEW_WINDOW);
+      AddItem(IDS_BOOMARK_BAR_OPEN_ALL_INCOGNITO);
     }
-    AppendSeparator();
+    AddSeparator();
   }
 
-  if (selection.size() == 1 && selection[0]->is_folder()) {
-    AppendItem(IDS_BOOKMARK_BAR_RENAME_FOLDER);
+  if (selection_.size() == 1 && selection_[0]->is_folder()) {
+    AddItem(IDS_BOOKMARK_BAR_RENAME_FOLDER);
   } else {
-    AppendItem(IDS_BOOKMARK_BAR_EDIT);
+    AddItem(IDS_BOOKMARK_BAR_EDIT);
   }
+  AddItem(IDS_BOOKMARK_BAR_REMOVE);
 
-  if (configuration == BOOKMARK_MANAGER_TABLE ||
-      configuration == BOOKMARK_MANAGER_TABLE_OTHER ||
-      configuration == BOOKMARK_MANAGER_ORGANIZE_MENU ||
-      configuration == BOOKMARK_MANAGER_ORGANIZE_MENU_OTHER) {
-    AppendItem(IDS_BOOKMARK_MANAGER_SHOW_IN_FOLDER);
+  if (configuration_ == BOOKMARK_MANAGER_TABLE ||
+      configuration_ == BOOKMARK_MANAGER_TABLE_OTHER ||
+      configuration_ == BOOKMARK_MANAGER_ORGANIZE_MENU ||
+      configuration_ == BOOKMARK_MANAGER_ORGANIZE_MENU_OTHER) {
+    AddItem(IDS_BOOKMARK_MANAGER_SHOW_IN_FOLDER);
   }
 
-  AppendSeparator();
-  AppendItem(IDS_CUT);
-  AppendItem(IDS_COPY);
-  AppendItem(IDS_PASTE);
-
-  AppendSeparator();
-  AppendItem(IDS_BOOKMARK_BAR_REMOVE);
+  if (configuration_ == BOOKMARK_MANAGER_TABLE ||
+      configuration_ == BOOKMARK_MANAGER_TABLE_OTHER ||
+      configuration_ == BOOKMARK_MANAGER_TREE ||
+      configuration_ == BOOKMARK_MANAGER_ORGANIZE_MENU ||
+      configuration_ == BOOKMARK_MANAGER_ORGANIZE_MENU_OTHER) {
+    AddSeparator();
+    AddItem(IDS_CUT);
+    AddItem(IDS_COPY);
+    AddItem(IDS_PASTE);
+  }
 
-  if (configuration == BOOKMARK_MANAGER_ORGANIZE_MENU) {
-    AppendSeparator();
-    AppendItem(IDS_BOOKMARK_MANAGER_SORT);
+  if (configuration_ == BOOKMARK_MANAGER_ORGANIZE_MENU) {
+    AddSeparator();
+    AddItem(IDS_BOOKMARK_MANAGER_SORT);
   }
 
-  AppendSeparator();
+  AddSeparator();
 
-  AppendItem(IDS_BOOMARK_BAR_ADD_NEW_BOOKMARK);
-  AppendItem(IDS_BOOMARK_BAR_NEW_FOLDER);
+  AddItem(IDS_BOOMARK_BAR_ADD_NEW_BOOKMARK);
+  AddItem(IDS_BOOMARK_BAR_NEW_FOLDER);
 
-  if (configuration == BOOKMARK_BAR) {
-    AppendSeparator();
-    AppendItem(IDS_BOOKMARK_MANAGER);
-    AppendCheckboxItem(IDS_BOOMARK_BAR_ALWAYS_SHOW);
+  if (configuration_ == BOOKMARK_BAR) {
+    AddSeparator();
+    AddItem(IDS_BOOKMARK_MANAGER);
+    AddCheckboxItem(IDS_BOOMARK_BAR_ALWAYS_SHOW);
   }
+}
 
-  model_->AddObserver(this);
+void BookmarkContextMenuController::AddItem(int id) {
+  menu_model_->AddItem(id, l10n_util::GetStringUTF16(id));
 }
 
-BookmarkContextMenuGtk::~BookmarkContextMenuGtk() {
-  if (model_)
-    model_->RemoveObserver(this);
+void BookmarkContextMenuController::AddItem(int id, int localization_id) {
+  menu_model_->AddItemWithStringId(id, localization_id);
 }
 
-void BookmarkContextMenuGtk::DelegateDestroyed() {
-  delegate_ = NULL;
+void BookmarkContextMenuController::AddSeparator() {
+  menu_model_->AddSeparator();
 }
 
-void BookmarkContextMenuGtk::ExecuteCommand(int id) {
-  if (model_changed_)
-    return;
+void BookmarkContextMenuController::AddCheckboxItem(int id) {
+  menu_model_->AddCheckItemWithStringId(id, id);
+}
 
+void BookmarkContextMenuController::ExecuteCommand(int id) {
+  BookmarkModel* model = RemoveModelObserver();
   if (delegate_)
     delegate_->WillExecuteCommand();
 
@@ -297,8 +305,6 @@ void BookmarkContextMenuGtk::ExecuteCommand(int id) {
     case IDS_BOOMARK_BAR_OPEN_ALL:
     case IDS_BOOMARK_BAR_OPEN_ALL_INCOGNITO:
     case IDS_BOOMARK_BAR_OPEN_ALL_NEW_WINDOW: {
-      PageNavigator* navigator = browser_ ?
-          browser_->GetSelectedTabContents() : navigator_;
       WindowOpenDisposition initial_disposition;
       if (id == IDS_BOOMARK_BAR_OPEN_ALL) {
         initial_disposition = NEW_FOREGROUND_TAB;
@@ -313,8 +319,7 @@ void BookmarkContextMenuGtk::ExecuteCommand(int id) {
         UserMetrics::RecordAction("BookmarkBar_ContextMenu_OpenAllIncognito",
                                   profile_);
       }
-
-      bookmark_utils::OpenAll(wnd_, profile_, navigator, selection_,
+      bookmark_utils::OpenAll(parent_window_, profile_, navigator_, selection_,
                               initial_disposition);
       break;
     }
@@ -334,23 +339,24 @@ void BookmarkContextMenuGtk::ExecuteCommand(int id) {
           editor_config = BookmarkEditor::SHOW_TREE;
         else
           editor_config = BookmarkEditor::NO_TREE;
-        BookmarkEditor::Show(wnd_, profile_, parent_,
+        BookmarkEditor::Show(parent_window_, profile_, parent_,
                              BookmarkEditor::EditDetails(selection_[0]),
                              editor_config, NULL);
       } else {
-        EditFolderController::Show(profile_, wnd_, selection_[0], false,
-                                   false);
+        EditFolderController::Show(profile_, parent_window_, selection_[0],
+                                   false, false);
       }
       break;
 
     case IDS_BOOKMARK_BAR_REMOVE: {
       UserMetrics::RecordAction("BookmarkBar_ContextMenu_Remove", profile_);
-      BookmarkModel* model = RemoveModelObserver();
 
+      delegate_->WillRemoveBookmarks(selection_);
       for (size_t i = 0; i < selection_.size(); ++i) {
         model->Remove(selection_[i]->GetParent(),
                       selection_[i]->GetParent()->IndexOfChild(selection_[i]));
       }
+      delegate_->DidRemoveBookmarks();
       selection_.clear();
       break;
     }
@@ -367,7 +373,7 @@ void BookmarkContextMenuGtk::ExecuteCommand(int id) {
         // This is owned by the BookmarkEditorView.
         handler = new SelectOnCreationHandler(profile_);
       }
-      BookmarkEditor::Show(wnd_, profile_, GetParentForNewNodes(),
+      BookmarkEditor::Show(parent_window_, profile_, GetParentForNewNodes(),
                            BookmarkEditor::EditDetails(), editor_config,
                            handler);
       break;
@@ -376,8 +382,9 @@ void BookmarkContextMenuGtk::ExecuteCommand(int id) {
     case IDS_BOOMARK_BAR_NEW_FOLDER: {
       UserMetrics::RecordAction("BookmarkBar_ContextMenu_NewFolder",
                                 profile_);
-      EditFolderController::Show(profile_, wnd_, GetParentForNewNodes(),
-                                 true, (configuration_ != BOOKMARK_BAR));
+      EditFolderController::Show(profile_, parent_window_,
+                                 GetParentForNewNodes(), true,
+                                 configuration_ != BOOKMARK_BAR);
       break;
     }
 
@@ -404,27 +411,29 @@ void BookmarkContextMenuGtk::ExecuteCommand(int id) {
 
     case IDS_BOOKMARK_MANAGER_SORT:
       UserMetrics::RecordAction("BookmarkManager_Sort", profile_);
-      model_->SortChildren(parent_);
+      model->SortChildren(parent_);
       break;
 
-    case IDS_COPY:
     case IDS_CUT:
-      bookmark_utils::CopyToClipboard(profile_->GetBookmarkModel(),
-                                      selection_, id == IDS_CUT);
+      delegate_->WillRemoveBookmarks(selection_);
+      bookmark_utils::CopyToClipboard(model, selection_, false);
+      delegate_->DidRemoveBookmarks();
+      break;
+
+    case IDS_COPY:
+      bookmark_utils::CopyToClipboard(model, selection_, false);
       break;
 
     case IDS_PASTE: {
-      const BookmarkNode* paste_target = GetParentForNewNodes();
-      if (!paste_target)
+      // Always paste to parent.
+      if (!parent_)
         return;
 
-      int index = -1;
-      if (selection_.size() == 1 && selection_[0]->is_url()) {
-        index = paste_target->IndexOfChild(selection_[0]) + 1;
-      }
-
-      bookmark_utils::PasteFromClipboard(profile_->GetBookmarkModel(),
-                                         paste_target, index);
+      int index = (selection_.size() == 1) ?
+          parent_->IndexOfChild(selection_[0]) : -1;
+      if (index != -1)
+        index++;
+      bookmark_utils::PasteFromClipboard(model, parent_, index);
       break;
     }
 
@@ -433,16 +442,16 @@ void BookmarkContextMenuGtk::ExecuteCommand(int id) {
   }
 }
 
-bool BookmarkContextMenuGtk::IsCommandIdChecked(int id) const {
-  DCHECK(id == IDS_BOOMARK_BAR_ALWAYS_SHOW);
+bool BookmarkContextMenuController::IsCommandIdChecked(int command_id) const {
+  DCHECK(command_id == IDS_BOOMARK_BAR_ALWAYS_SHOW);
   return profile_->GetPrefs()->GetBoolean(prefs::kShowBookmarkBar);
 }
 
-bool BookmarkContextMenuGtk::IsCommandIdEnabled(int id) const {
+bool BookmarkContextMenuController::IsCommandIdEnabled(int command_id) const {
   bool is_root_node =
       (selection_.size() == 1 &&
        selection_[0]->GetParent() == model_->root_node());
-  switch (id) {
+  switch (command_id) {
     case IDS_BOOMARK_BAR_OPEN_INCOGNITO:
       return !profile_->IsOffTheRecord();
 
@@ -477,84 +486,65 @@ bool BookmarkContextMenuGtk::IsCommandIdEnabled(int id) const {
       return selection_.size() > 0 && !is_root_node;
 
     case IDS_PASTE:
-      // Paste to selection from the Bookmark Bar, to parent_ everywhere else
-      return (configuration_ == BOOKMARK_BAR &&
-              !selection_.empty() &&
-              bookmark_utils::CanPasteFromClipboard(selection_[0])) ||
-             bookmark_utils::CanPasteFromClipboard(parent_);
+      // Always paste to parent.
+      return bookmark_utils::CanPasteFromClipboard(parent_);
   }
   return true;
 }
 
-bool BookmarkContextMenuGtk::GetAcceleratorForCommandId(
-    int command_id,
-    menus::Accelerator* accelerator) {
-  return false;
-}
-
-void BookmarkContextMenuGtk::BookmarkModelBeingDeleted(BookmarkModel* model) {
+void BookmarkContextMenuController::BookmarkModelBeingDeleted(
+    BookmarkModel* model) {
   ModelChanged();
 }
 
-void BookmarkContextMenuGtk::BookmarkNodeMoved(BookmarkModel* model,
-                                               const BookmarkNode* old_parent,
-                                               int old_index,
-                                               const BookmarkNode* new_parent,
-                                               int new_index) {
+void BookmarkContextMenuController::BookmarkNodeMoved(
+    BookmarkModel* model,
+    const BookmarkNode* old_parent,
+    int old_index,
+    const BookmarkNode* new_parent,
+    int new_index) {
   ModelChanged();
 }
 
-void BookmarkContextMenuGtk::BookmarkNodeAdded(BookmarkModel* model,
-                                               const BookmarkNode* parent,
-                                               int index) {
+void BookmarkContextMenuController::BookmarkNodeAdded(
+    BookmarkModel* model,
+    const BookmarkNode* parent,
+    int index) {
   ModelChanged();
 }
 
-void BookmarkContextMenuGtk::BookmarkNodeRemoved(BookmarkModel* model,
-                                                 const BookmarkNode* parent,
-                                                 int index,
-                                                 const BookmarkNode* node) {
+void BookmarkContextMenuController::BookmarkNodeRemoved(
+    BookmarkModel* model,
+    const BookmarkNode* parent,
+    int index,
+    const BookmarkNode* node) {
   ModelChanged();
 }
 
-void BookmarkContextMenuGtk::BookmarkNodeChanged(BookmarkModel* model,
-                                                 const BookmarkNode* node) {
+void BookmarkContextMenuController::BookmarkNodeChanged(
+    BookmarkModel* model,
+    const BookmarkNode* node) {
   ModelChanged();
 }
 
-void BookmarkContextMenuGtk::BookmarkNodeChildrenReordered(
-    BookmarkModel* model, const BookmarkNode* node) {
+void BookmarkContextMenuController::BookmarkNodeChildrenReordered(
+    BookmarkModel* model,
+    const BookmarkNode* node) {
   ModelChanged();
 }
 
-void BookmarkContextMenuGtk::ModelChanged() {
-  model_changed_ = true;
-}
-
-void BookmarkContextMenuGtk::AppendItem(int id) {
-  menu_model_->AddItem(id, l10n_util::GetStringUTF16(id));
-}
-
-void BookmarkContextMenuGtk::AppendItem(int id, int localization_id) {
-  menu_model_->AddItemWithStringId(id, localization_id);
-}
-
-void BookmarkContextMenuGtk::AppendSeparator() {
-  menu_model_->AddSeparator();
-}
-
-void BookmarkContextMenuGtk::AppendCheckboxItem(int id) {
-  menu_model_->AddCheckItemWithStringId(id, id);
+void BookmarkContextMenuController::ModelChanged() {
+  delegate_->CloseMenu();
 }
 
-BookmarkModel* BookmarkContextMenuGtk::RemoveModelObserver() {
+BookmarkModel* BookmarkContextMenuController::RemoveModelObserver() {
   BookmarkModel* model = model_;
   model_->RemoveObserver(this);
   model_ = NULL;
   return model;
 }
 
-bool BookmarkContextMenuGtk::HasURLs() const {
+bool BookmarkContextMenuController::HasURLs() const {
   for (size_t i = 0; i < selection_.size(); ++i) {
     if (NodeHasURLs(selection_[i]))
       return true;
@@ -562,7 +552,8 @@ bool BookmarkContextMenuGtk::HasURLs() const {
   return false;
 }
 
-const BookmarkNode* BookmarkContextMenuGtk::GetParentForNewNodes() const {
+const BookmarkNode*
+    BookmarkContextMenuController::GetParentForNewNodes() const {
   return (selection_.size() == 1 && selection_[0]->is_folder()) ?
       selection_[0] : parent_;
 }
diff --git a/chrome/browser/gtk/bookmark_context_menu_gtk.h b/chrome/browser/bookmarks/bookmark_context_menu_controller_gtk.h
index a625611..9b55996 100644
--- a/chrome/browser/gtk/bookmark_context_menu_gtk.h
+++ b/chrome/browser/bookmarks/bookmark_context_menu_controller_gtk.h
@@ -2,26 +2,44 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROME_BROWSER_GTK_BOOKMARK_CONTEXT_MENU_GTK_H_
-#define CHROME_BROWSER_GTK_BOOKMARK_CONTEXT_MENU_GTK_H_
+#ifndef CHROME_BROWSER_BOOKMARKS_BOOKMARK_CONTEXT_MENU_CONTROLLER_GTK_H_
+#define CHROME_BROWSER_BOOKMARKS_BOOKMARK_CONTEXT_MENU_CONTROLLER_GTK_H_
 
 #include <vector>
 
 #include "app/gfx/native_widget_types.h"
 #include "app/menus/simple_menu_model.h"
 #include "base/basictypes.h"
-#include "base/scoped_ptr.h"
 #include "chrome/browser/bookmarks/bookmark_model_observer.h"
 
 class Browser;
 class PageNavigator;
 class Profile;
 
-// BookmarkContextMenu manages the context menu shown for the
-// bookmark bar, items on the bookmark bar, submenus of the bookmark bar and
-// the bookmark manager.
-class BookmarkContextMenuGtk : public BookmarkModelObserver,
-                               public menus::SimpleMenuModel::Delegate {
+// An interface implemented by an object that performs actions on the actual
+// menu for the controller.
+class BookmarkContextMenuControllerDelegate {
+ public:
+  virtual ~BookmarkContextMenuControllerDelegate() {}
+
+  // Closes the bookmark context menu.
+  virtual void CloseMenu() = 0;
+
+  // Sent before bookmarks are removed.
+  virtual void WillRemoveBookmarks(
+      const std::vector<const BookmarkNode*>& bookmarks) {}
+
+  // Sent after bookmarks have been removed.
+  virtual void DidRemoveBookmarks() {}
+
+  // Sent before any command from the menu is executed.
+  virtual void WillExecuteCommand() {}
+};
+
+// BookmarkContextMenuController creates and manages state for the context menu
+// shown for any bookmark item.
+class BookmarkContextMenuController : public BookmarkModelObserver,
+                                      public menus::SimpleMenuModel::Delegate {
  public:
   // Used to configure what the context menu shows.
   enum ConfigurationType {
@@ -37,12 +55,6 @@ class BookmarkContextMenuGtk : public BookmarkModelObserver,
     BOOKMARK_MANAGER_ORGANIZE_MENU_OTHER
   };
 
-  class Delegate {
-   public:
-    // Called when one of the menu items is selected and executed.
-    virtual void WillExecuteCommand() = 0;
-  };
-
   // Creates the bookmark context menu.
   // |profile| is used for opening urls as well as enabling 'open incognito'.
   // |browser| is used to determine the PageNavigator and may be null.
@@ -50,31 +62,47 @@ class BookmarkContextMenuGtk : public BookmarkModelObserver,
   // |parent| is the parent for newly created nodes if |selection| is empty.
   // |selection| is the nodes the context menu operates on and may be empty.
   // |configuration| determines which items to show.
-  BookmarkContextMenuGtk(gfx::NativeWindow hwnd,
-                         Profile* profile,
-                         Browser* browser,
-                         PageNavigator* navigator,
-                         const BookmarkNode* parent,
-                         const std::vector<const BookmarkNode*>& selection,
-                         ConfigurationType configuration,
-                         Delegate* delegate);
-  virtual ~BookmarkContextMenuGtk();
-
-  menus::MenuModel* menu_model() const { return menu_model_.get(); }
-
-  // Should be called by the delegate when it is no longer valid.
-  void DelegateDestroyed();
-
-  // Menu::Delegate methods.
+  BookmarkContextMenuController(
+      gfx::NativeWindow parent_window,
+      BookmarkContextMenuControllerDelegate* delegate,
+      Profile* profile,
+      PageNavigator* navigator,
+      const BookmarkNode* parent,
+      const std::vector<const BookmarkNode*>& selection,
+      ConfigurationType configuration);
+  virtual ~BookmarkContextMenuController();
+
+  void BuildMenu();
+
+  menus::SimpleMenuModel* menu_model() {
+    return menu_model_.get();
+  }
+
+  // Adds a IDS_* style command to the menu.
+  void AddItem(int id);
+  // Adds a IDS_* style command to the menu with a different localized string.
+  void AddItem(int id, int localization_id);
+  // Adds a separator to the menu.
+  void AddSeparator();
+  // Adds a checkable item to the menu.
+  void AddCheckboxItem(int id);
+
+  // menus::SimpleMenuModel::Delegate implementation:
   virtual bool IsCommandIdChecked(int command_id) const;
   virtual bool IsCommandIdEnabled(int command_id) const;
   virtual bool GetAcceleratorForCommandId(
       int command_id,
-      menus::Accelerator* accelerator);
+      menus::Accelerator* accelerator) {
+    return false;
+  }
   virtual void ExecuteCommand(int command_id);
 
+  // Accessors:
+  Profile* profile() const { return profile_; }
+  PageNavigator* navigator() const { return navigator_; }
+
  private:
-  // BookmarkModelObserver method. Any change to the model results in closing
+  // BookmarkModelObserver methods. Any change to the model results in closing
   // the menu.
   virtual void Loaded(BookmarkModel* model) {}
   virtual void BookmarkModelBeingDeleted(BookmarkModel* model);
@@ -100,15 +128,6 @@ class BookmarkContextMenuGtk : public BookmarkModelObserver,
   // Invoked from the various bookmark model observer methods. Closes the menu.
   void ModelChanged();
 
-  // Adds a IDS_* style command to the menu.
-  void AppendItem(int id);
-  // Adds a IDS_* style command to the menu with a different localized string.
-  void AppendItem(int id, int localization_id);
-  // Adds a separator to the menu.
-  void AppendSeparator();
-  // Adds a checkable item to the menu.
-  void AppendCheckboxItem(int id);
-
   // Removes the observer from the model and NULLs out model_.
   BookmarkModel* RemoveModelObserver();
 
@@ -120,23 +139,17 @@ class BookmarkContextMenuGtk : public BookmarkModelObserver,
   // parent_ is returned.
   const BookmarkNode* GetParentForNewNodes() const;
 
-  gfx::NativeWindow wnd_;
+  gfx::NativeWindow parent_window_;
+  BookmarkContextMenuControllerDelegate* delegate_;
   Profile* profile_;
-  Browser* browser_;
   PageNavigator* navigator_;
   const BookmarkNode* parent_;
   std::vector<const BookmarkNode*> selection_;
-  BookmarkModel* model_;
   ConfigurationType configuration_;
-  Delegate* delegate_;
+  BookmarkModel* model_;
   scoped_ptr<menus::SimpleMenuModel> menu_model_;
 
-  // Tracks whether the model has changed. For the most part the model won't
-  // change while a context menu is showing, but if it does, we'd better not
-  // try to execute any commands.
-  bool model_changed_;
-
-  DISALLOW_COPY_AND_ASSIGN(BookmarkContextMenuGtk);
+  DISALLOW_COPY_AND_ASSIGN(BookmarkContextMenuController);
 };
 
-#endif  // CHROME_BROWSER_GTK_BOOKMARK_CONTEXT_MENU_GTK_H_
+#endif  // CHROME_BROWSER_BOOKMARKS_BOOKMARK_CONTEXT_MENU_CONTROLLER_GTK_H_
diff --git a/chrome/browser/gtk/bookmark_bar_gtk.cc b/chrome/browser/gtk/bookmark_bar_gtk.cc
index f5a0b8c..62bac3d 100644
--- a/chrome/browser/gtk/bookmark_bar_gtk.cc
+++ b/chrome/browser/gtk/bookmark_bar_gtk.cc
@@ -17,7 +17,6 @@
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
 #include "chrome/browser/browser.h"
-#include "chrome/browser/gtk/bookmark_context_menu_gtk.h"
 #include "chrome/browser/gtk/bookmark_menu_controller_gtk.h"
 #include "chrome/browser/gtk/bookmark_tree_model.h"
 #include "chrome/browser/gtk/bookmark_utils_gtk.h"
@@ -923,9 +922,9 @@ void BookmarkBarGtk::PopupMenuForNode(GtkWidget* sender,
 
   GtkWindow* window = GTK_WINDOW(gtk_widget_get_toplevel(sender));
   current_context_menu_controller_.reset(
-      new BookmarkContextMenuGtk(
-          window, profile_, browser_, page_navigator_, parent, nodes,
-          BookmarkContextMenuGtk::BOOKMARK_BAR, NULL));
+      new BookmarkContextMenuController(
+          window, this, profile_, page_navigator_, parent, nodes,
+          BookmarkContextMenuController::BOOKMARK_BAR));
   current_context_menu_.reset(
       new MenuGtk(NULL, current_context_menu_controller_->menu_model()));
   current_context_menu_->PopupAsContext(event->time);
@@ -1373,3 +1372,7 @@ void BookmarkBarGtk::PopupForButtonNextTo(GtkWidget* button,
   button_idx = (button_idx + shift + folder_list.size()) % folder_list.size();
   PopupForButton(folder_list[button_idx]);
 }
+
+void BookmarkBarGtk::CloseMenu() {
+  current_context_menu_->Cancel();
+}
diff --git a/chrome/browser/gtk/bookmark_bar_gtk.h b/chrome/browser/gtk/bookmark_bar_gtk.h
index 2770fc5..0c6813e 100644
--- a/chrome/browser/gtk/bookmark_bar_gtk.h
+++ b/chrome/browser/gtk/bookmark_bar_gtk.h
@@ -13,6 +13,7 @@
 #include "app/slide_animation.h"
 #include "base/gfx/size.h"
 #include "base/scoped_ptr.h"
+#include "chrome/browser/bookmarks/bookmark_context_menu_controller_gtk.h"
 #include "chrome/browser/bookmarks/bookmark_model_observer.h"
 #include "chrome/browser/gtk/bookmark_bar_instructions_gtk.h"
 #include "chrome/browser/gtk/menu_bar_helper.h"
@@ -23,7 +24,6 @@
 #include "chrome/common/owned_widget_gtk.h"
 #include "testing/gtest/include/gtest/gtest_prod.h"
 
-class BookmarkContextMenuGtk;
 class BookmarkMenuController;
 class Browser;
 class BrowserWindowGtk;
@@ -39,7 +39,8 @@ class BookmarkBarGtk : public AnimationDelegate,
                        public BookmarkModelObserver,
                        public MenuBarHelper::Delegate,
                        public NotificationObserver,
-                       public BookmarkBarInstructionsGtk::Delegate {
+                       public BookmarkBarInstructionsGtk::Delegate,
+                       public BookmarkContextMenuControllerDelegate {
   FRIEND_TEST(BookmarkBarGtkUnittest, DisplaysHelpMessageOnEmpty);
   FRIEND_TEST(BookmarkBarGtkUnittest, HidesHelpMessageWithBookmark);
   FRIEND_TEST(BookmarkBarGtkUnittest, BuildsButtons);
@@ -106,6 +107,9 @@ class BookmarkBarGtk : public AnimationDelegate,
   // The NTP needs to have access to this.
   static const int kBookmarkBarNTPHeight;
 
+  // BookmarkContextMenuController::Delegate implementation --------------------
+  virtual void CloseMenu();
+
  private:
   // Helper function which generates GtkToolItems for |bookmark_toolbar_|.
   void CreateAllBookmarkButtons();
@@ -352,7 +356,7 @@ class BookmarkBarGtk : public AnimationDelegate,
   // The last displayed right click menu, or NULL if no menus have been
   // displayed yet.
   // The controller.
-  scoped_ptr<BookmarkContextMenuGtk> current_context_menu_controller_;
+  scoped_ptr<BookmarkContextMenuController> current_context_menu_controller_;
   // The view.
   scoped_ptr<MenuGtk> current_context_menu_;
 
diff --git a/chrome/browser/gtk/bookmark_manager_gtk.cc b/chrome/browser/gtk/bookmark_manager_gtk.cc
index 554a867..53de4d2 100644
--- a/chrome/browser/gtk/bookmark_manager_gtk.cc
+++ b/chrome/browser/gtk/bookmark_manager_gtk.cc
@@ -632,10 +632,15 @@ void BookmarkManagerGtk::ResetOrganizeMenu(bool left) {
   if (old_menu)
     MessageLoop::current()->DeleteSoon(FROM_HERE, old_menu);
 
+  BookmarkContextMenuController* old_controller =
+      organize_menu_controller_.release();
+  if (old_controller)
+    MessageLoop::current()->DeleteSoon(FROM_HERE, old_controller);
+
   organize_menu_controller_.reset(
-      new BookmarkContextMenuGtk(GTK_WINDOW(window_), profile_,
-        NULL, NULL, parent, nodes,
-        BookmarkContextMenuGtk::BOOKMARK_MANAGER_ORGANIZE_MENU, NULL));
+      new BookmarkContextMenuController(GTK_WINDOW(window_), this, profile_,
+        NULL, parent, nodes,
+        BookmarkContextMenuController::BOOKMARK_MANAGER_ORGANIZE_MENU));
   organize_menu_.reset(
       new MenuGtk(NULL, organize_menu_controller_->menu_model()));
   gtk_menu_item_set_submenu(GTK_MENU_ITEM(organize_),
@@ -1483,6 +1488,10 @@ void BookmarkManagerGtk::OnStateChanged() {
   UpdateSyncStatus();
 }
 
+void BookmarkManagerGtk::CloseMenu() {
+  organize_menu_->Cancel();
+}
+
 // static
 gboolean BookmarkManagerGtk::OnGtkAccelerator(GtkAccelGroup* accel_group,
     GObject* acceleratable,
diff --git a/chrome/browser/gtk/bookmark_manager_gtk.h b/chrome/browser/gtk/bookmark_manager_gtk.h
index 24db624..903a5ba 100644
--- a/chrome/browser/gtk/bookmark_manager_gtk.h
+++ b/chrome/browser/gtk/bookmark_manager_gtk.h
@@ -12,8 +12,8 @@
 #include "base/gfx/rect.h"
 #include "base/ref_counted.h"
 #include "base/task.h"
+#include "chrome/browser/bookmarks/bookmark_context_menu_controller_gtk.h"
 #include "chrome/browser/bookmarks/bookmark_model_observer.h"
-#include "chrome/browser/gtk/bookmark_context_menu_gtk.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/shell_dialogs.h"
 #include "chrome/common/gtk_tree.h"
@@ -27,7 +27,8 @@ class Profile;
 class BookmarkManagerGtk : public BookmarkModelObserver,
                            public ProfileSyncServiceObserver,
                            public gtk_tree::TableAdapter::Delegate,
-                           public SelectFileDialog::Listener {
+                           public SelectFileDialog::Listener,
+                           public BookmarkContextMenuControllerDelegate {
  public:
   virtual ~BookmarkManagerGtk();
 
@@ -74,6 +75,9 @@ class BookmarkManagerGtk : public BookmarkModelObserver,
   // ProfileSyncServiceObserver implementation.
   virtual void OnStateChanged();
 
+  // BookmarkContextMenuController::Delegate implementation.
+  virtual void CloseMenu();
+
  private:
   friend class BookmarkManagerTest;
   FRIEND_TEST(BookmarkManagerTest, Crash);
@@ -340,7 +344,7 @@ class BookmarkManagerGtk : public BookmarkModelObserver,
   GtkWidget* organize_;
   // The submenu the item pops up.
   // The controller.
-  scoped_ptr<BookmarkContextMenuGtk> organize_menu_controller_;
+  scoped_ptr<BookmarkContextMenuController> organize_menu_controller_;
   // The view.
   scoped_ptr<MenuGtk> organize_menu_;
   // Whether the menu refers to the left selection.
diff --git a/chrome/browser/gtk/bookmark_menu_controller_gtk.cc b/chrome/browser/gtk/bookmark_menu_controller_gtk.cc
index e3bdcb3..a6232ac 100644
--- a/chrome/browser/gtk/bookmark_menu_controller_gtk.cc
+++ b/chrome/browser/gtk/bookmark_menu_controller_gtk.cc
@@ -12,7 +12,6 @@
 #include "app/resource_bundle.h"
 #include "base/string_util.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
-#include "chrome/browser/gtk/bookmark_context_menu_gtk.h"
 #include "chrome/browser/gtk/bookmark_utils_gtk.h"
 #include "chrome/browser/gtk/gtk_chrome_button.h"
 #include "chrome/browser/gtk/gtk_theme_provider.h"
@@ -106,8 +105,6 @@ BookmarkMenuController::BookmarkMenuController(Browser* browser,
 }
 
 BookmarkMenuController::~BookmarkMenuController() {
-  if (context_menu_controller_.get())
-    context_menu_controller_->DelegateDestroyed();
   profile_->GetBookmarkModel()->RemoveObserver(this);
   gtk_menu_popdown(GTK_MENU(menu_));
 }
@@ -140,6 +137,10 @@ void BookmarkMenuController::WillExecuteCommand() {
   gtk_menu_popdown(GTK_MENU(menu_));
 }
 
+void BookmarkMenuController::CloseMenu() {
+  context_menu_->Cancel();
+}
+
 void BookmarkMenuController::NavigateToMenuItem(
     GtkWidget* menu_item,
     WindowOpenDisposition disposition) {
@@ -251,10 +252,10 @@ gboolean BookmarkMenuController::OnButtonPressed(
     if (node)
       nodes.push_back(node);
     controller->context_menu_controller_.reset(
-        new BookmarkContextMenuGtk(
-            controller->parent_window_, controller->profile_,
-            controller->browser_, controller->page_navigator_, parent, nodes,
-            BookmarkContextMenuGtk::BOOKMARK_BAR, controller));
+        new BookmarkContextMenuController(
+            controller->parent_window_, controller, controller->profile_,
+            controller->page_navigator_, parent, nodes,
+            BookmarkContextMenuController::BOOKMARK_BAR));
     controller->context_menu_.reset(
         new MenuGtk(NULL, controller->context_menu_controller_->menu_model()));
 
diff --git a/chrome/browser/gtk/bookmark_menu_controller_gtk.h b/chrome/browser/gtk/bookmark_menu_controller_gtk.h
index fdf098a..f8f6008 100644
--- a/chrome/browser/gtk/bookmark_menu_controller_gtk.h
+++ b/chrome/browser/gtk/bookmark_menu_controller_gtk.h
@@ -11,7 +11,7 @@
 
 #include "base/scoped_ptr.h"
 #include "chrome/browser/bookmarks/base_bookmark_model_observer.h"
-#include "chrome/browser/gtk/bookmark_context_menu_gtk.h"
+#include "chrome/browser/bookmarks/bookmark_context_menu_controller_gtk.h"
 #include "chrome/common/owned_widget_gtk.h"
 #include "webkit/glue/window_open_disposition.h"
 
@@ -24,7 +24,7 @@ class BookmarkNode;
 class MenuGtk;
 
 class BookmarkMenuController : public BaseBookmarkModelObserver,
-                               public BookmarkContextMenuGtk::Delegate {
+                               public BookmarkContextMenuControllerDelegate {
  public:
   // Creates a BookmarkMenuController showing the children of |node| starting
   // at index |start_child_index|.
@@ -47,8 +47,9 @@ class BookmarkMenuController : public BaseBookmarkModelObserver,
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
                                          const BookmarkNode* node);
 
-  // Overridden from BookmarkContextMenuGtk::Delegate:
+  // Overridden from BookmarkContextMenuController::Delegate:
   virtual void WillExecuteCommand();
+  virtual void CloseMenu();
 
  private:
   // Recursively change the bookmark hierarchy rooted in |parent| into a set of
@@ -125,7 +126,7 @@ class BookmarkMenuController : public BaseBookmarkModelObserver,
   std::map<const BookmarkNode*, GtkWidget*> node_to_menu_widget_map_;
 
   // The controller and view for the right click context menu.
-  scoped_ptr<BookmarkContextMenuGtk> context_menu_controller_;
+  scoped_ptr<BookmarkContextMenuController> context_menu_controller_;
   scoped_ptr<MenuGtk> context_menu_;
 
   DISALLOW_COPY_AND_ASSIGN(BookmarkMenuController);
diff --git a/chrome/chrome_browser.gypi b/chrome/chrome_browser.gypi
index 8ced6dc..748874d 100755
--- a/chrome/chrome_browser.gypi
+++ b/chrome/chrome_browser.gypi
@@ -167,6 +167,8 @@
         'browser/bookmarks/bookmark_codec.h',
         'browser/bookmarks/bookmark_context_menu_controller.cc',
         'browser/bookmarks/bookmark_context_menu_controller.h',
+        'browser/bookmarks/bookmark_context_menu_controller_gtk.cc',
+        'browser/bookmarks/bookmark_context_menu_controller_gtk.h',
         'browser/bookmarks/bookmark_drag_data.cc',
         'browser/bookmarks/bookmark_drag_data.h',
         'browser/bookmarks/bookmark_drop_info.cc',
@@ -908,8 +910,6 @@
         'browser/gtk/bookmark_bar_instructions_gtk.h',
         'browser/gtk/bookmark_bubble_gtk.cc',
         'browser/gtk/bookmark_bubble_gtk.h',
-        'browser/gtk/bookmark_context_menu_gtk.cc',
-        'browser/gtk/bookmark_context_menu_gtk.h',
         'browser/gtk/bookmark_editor_gtk.cc',
         'browser/gtk/bookmark_editor_gtk.h',
         'browser/gtk/bookmark_manager_gtk.cc',
@@ -2072,6 +2072,9 @@
              # Windows-specific files.
             'browser/password_manager/password_store_win.cc',
             'browser/password_manager/password_store_win.h',
+             # Disabled while bookmark context menus are unforked.
+            'browser/bookmarks/bookmark_context_menu_controller.cc',
+            'browser/bookmarks/bookmark_context_menu_controller.h',
           ],
           'sources': [
             'browser/crash_handler_host_linux.h',