Bookmark context menu unforking:

- create cross-platform BookmarkContextMenuController
- use the new class on GTK (replacing BookmarkContextMenuControllerGtk)
- keep using the old class on views (now named BookmarkContextMenuControllerViews)
- add tests for the new BookmarkContextMenuController

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

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

3 files changed, 445 insertions, 58 deletions

diff --git a/chrome/browser/bookmarks/bookmark_context_menu_controller.cc b/chrome/browser/bookmarks/bookmark_context_menu_controller.cc
index 1c6e8b4..325f341 100644
--- a/chrome/browser/bookmarks/bookmark_context_menu_controller.cc
+++ b/chrome/browser/bookmarks/bookmark_context_menu_controller.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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.
 
@@ -210,7 +210,10 @@ BookmarkContextMenuController::BookmarkContextMenuController(
       model_(profile->GetBookmarkModel()) {
   DCHECK(profile_);
   DCHECK(model_->IsLoaded());
+  menu_model_.reset(new menus::SimpleMenuModel(this));
   model_->AddObserver(this);
+
+  BuildMenu();
 }
 
 BookmarkContextMenuController::~BookmarkContextMenuController() {
@@ -221,60 +224,82 @@ BookmarkContextMenuController::~BookmarkContextMenuController() {
 void BookmarkContextMenuController::BuildMenu() {
   if (configuration_ != BOOKMARK_MANAGER_ORGANIZE_MENU) {
     if (selection_.size() == 1 && selection_[0]->is_url()) {
-      delegate_->AddItemWithStringId(IDS_BOOMARK_BAR_OPEN_ALL,
-                                     IDS_BOOMARK_BAR_OPEN_IN_NEW_TAB);
-      delegate_->AddItemWithStringId(IDS_BOOMARK_BAR_OPEN_ALL_NEW_WINDOW,
-                                     IDS_BOOMARK_BAR_OPEN_IN_NEW_WINDOW);
-      delegate_->AddItemWithStringId(IDS_BOOMARK_BAR_OPEN_ALL_INCOGNITO,
-                                     IDS_BOOMARK_BAR_OPEN_INCOGNITO);
+      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 {
-      delegate_->AddItem(IDS_BOOMARK_BAR_OPEN_ALL);
-      delegate_->AddItem(IDS_BOOMARK_BAR_OPEN_ALL_NEW_WINDOW);
-      delegate_->AddItem(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);
     }
-    delegate_->AddSeparator();
+    AddSeparator();
   }
 
   if (selection_.size() == 1 && selection_[0]->is_folder()) {
-    delegate_->AddItem(IDS_BOOKMARK_BAR_RENAME_FOLDER);
+    AddItem(IDS_BOOKMARK_BAR_RENAME_FOLDER);
   } else {
-    delegate_->AddItem(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) {
-    delegate_->AddItem(IDS_BOOKMARK_MANAGER_SHOW_IN_FOLDER);
+    AddItem(IDS_BOOKMARK_MANAGER_SHOW_IN_FOLDER);
   }
 
-  delegate_->AddSeparator();
-  delegate_->AddItem(IDS_CUT);
-  delegate_->AddItem(IDS_COPY);
-  delegate_->AddItem(IDS_PASTE);
-
-  delegate_->AddSeparator();
-  delegate_->AddItem(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) {
-    delegate_->AddSeparator();
-    delegate_->AddItem(IDS_BOOKMARK_MANAGER_SORT);
+    AddSeparator();
+    AddItem(IDS_BOOKMARK_MANAGER_SORT);
   }
 
-  delegate_->AddSeparator();
+  AddSeparator();
 
-  delegate_->AddItem(IDS_BOOMARK_BAR_ADD_NEW_BOOKMARK);
-  delegate_->AddItem(IDS_BOOMARK_BAR_NEW_FOLDER);
+  AddItem(IDS_BOOMARK_BAR_ADD_NEW_BOOKMARK);
+  AddItem(IDS_BOOMARK_BAR_NEW_FOLDER);
 
   if (configuration_ == BOOKMARK_BAR) {
-    delegate_->AddSeparator();
-    delegate_->AddItem(IDS_BOOKMARK_MANAGER);
-    delegate_->AddCheckboxItem(IDS_BOOMARK_BAR_ALWAYS_SHOW);
+    AddSeparator();
+    AddItem(IDS_BOOKMARK_MANAGER);
+    AddCheckboxItem(IDS_BOOMARK_BAR_ALWAYS_SHOW);
   }
 }
 
+void BookmarkContextMenuController::AddItem(int id) {
+  menu_model_->AddItem(id, l10n_util::GetStringUTF16(id));
+}
+
+void BookmarkContextMenuController::AddItem(int id, int localization_id) {
+  menu_model_->AddItemWithStringId(id, localization_id);
+}
+
+void BookmarkContextMenuController::AddSeparator() {
+  menu_model_->AddSeparator();
+}
+
+void BookmarkContextMenuController::AddCheckboxItem(int id) {
+  menu_model_->AddCheckItemWithStringId(id, id);
+}
+
 void BookmarkContextMenuController::ExecuteCommand(int id) {
   BookmarkModel* model = RemoveModelObserver();
+  if (delegate_)
+    delegate_->WillExecuteCommand();
 
   switch (id) {
     case IDS_BOOMARK_BAR_OPEN_ALL:
@@ -305,7 +330,7 @@ void BookmarkContextMenuController::ExecuteCommand(int id) {
 
       if (selection_.size() != 1) {
         NOTREACHED();
-        return;
+        break;
       }
 
       if (selection_[0]->is_url()) {
@@ -326,12 +351,10 @@ void BookmarkContextMenuController::ExecuteCommand(int id) {
     case IDS_BOOKMARK_BAR_REMOVE: {
       UserMetrics::RecordAction("BookmarkBar_ContextMenu_Remove", profile_);
 
-      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;
     }
@@ -373,7 +396,7 @@ void BookmarkContextMenuController::ExecuteCommand(int id) {
 
       if (selection_.size() != 1) {
         NOTREACHED();
-        return;
+        break;
       }
 
       BookmarkManager::SelectInTree(profile_, selection_[0]);
@@ -390,9 +413,7 @@ void BookmarkContextMenuController::ExecuteCommand(int id) {
       break;
 
     case IDS_CUT:
-      delegate_->WillRemoveBookmarks(selection_);
       bookmark_utils::CopyToClipboard(model, selection_, true);
-      delegate_->DidRemoveBookmarks();
       break;
 
     case IDS_COPY:
@@ -415,18 +436,21 @@ void BookmarkContextMenuController::ExecuteCommand(int id) {
     default:
       NOTREACHED();
   }
+
+  if (delegate_)
+    delegate_->DidExecuteCommand();
 }
 
-bool BookmarkContextMenuController::IsItemChecked(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 BookmarkContextMenuController::IsCommandEnabled(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();
 
@@ -463,8 +487,8 @@ bool BookmarkContextMenuController::IsCommandEnabled(int id) const {
     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_);
+             bookmark_utils::CanPasteFromClipboard(selection_[0])) ||
+             bookmark_utils::CanPasteFromClipboard(parent_);
   }
   return true;
 }
@@ -511,7 +535,8 @@ void BookmarkContextMenuController::BookmarkNodeChildrenReordered(
 }
 
 void BookmarkContextMenuController::ModelChanged() {
-  delegate_->CloseMenu();
+  if (delegate_)
+    delegate_->CloseMenu();
 }
 
 BookmarkModel* BookmarkContextMenuController::RemoveModelObserver() {
diff --git a/chrome/browser/bookmarks/bookmark_context_menu_controller.h b/chrome/browser/bookmarks/bookmark_context_menu_controller.h
index 3812e28..e2e2194 100644
--- a/chrome/browser/bookmarks/bookmark_context_menu_controller.h
+++ b/chrome/browser/bookmarks/bookmark_context_menu_controller.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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.
 
@@ -8,6 +8,7 @@
 #include <vector>
 
 #include "app/gfx/native_widget_types.h"
+#include "app/menus/simple_menu_model.h"
 #include "base/basictypes.h"
 #include "chrome/browser/bookmarks/bookmark_model_observer.h"
 
@@ -24,23 +25,17 @@ class BookmarkContextMenuControllerDelegate {
   // Closes the bookmark context menu.
   virtual void CloseMenu() = 0;
 
-  // Methods that add items to the underlying menu.
-  virtual void AddItem(int command_id) = 0;
-  virtual void AddItemWithStringId(int command_id, int string_id) = 0;
-  virtual void AddSeparator() = 0;
-  virtual void AddCheckboxItem(int command_id) = 0;
+  // Sent before any command from the menu is executed.
+  virtual void WillExecuteCommand() {}
 
-  // Sent before bookmarks are removed.
-  virtual void WillRemoveBookmarks(
-      const std::vector<const BookmarkNode*>& bookmarks) {}
-
-  // Sent after bookmarks have been removed.
-  virtual void DidRemoveBookmarks() {}
+  // Sent after any command from the menu is executed.
+  virtual void DidExecuteCommand() {}
 };
 
 // BookmarkContextMenuController creates and manages state for the context menu
 // shown for any bookmark item.
-class BookmarkContextMenuController : public BookmarkModelObserver {
+class BookmarkContextMenuController : public BookmarkModelObserver,
+                                      public menus::SimpleMenuModel::Delegate {
  public:
   // Used to configure what the context menu shows.
   enum ConfigurationType {
@@ -75,15 +70,35 @@ class BookmarkContextMenuController : public BookmarkModelObserver {
 
   void BuildMenu();
 
-  void ExecuteCommand(int id);
-  bool IsItemChecked(int id) const;
-  bool IsCommandEnabled(int id) const;
+  menus::SimpleMenuModel* menu_model() {
+    return menu_model_.get();
+  }
+
+
+  // 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) {
+    return false;
+  }
+  virtual void ExecuteCommand(int command_id);
 
   // Accessors:
   Profile* profile() const { return profile_; }
   PageNavigator* navigator() const { return navigator_; }
 
  private:
+  // 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);
+
   // BookmarkModelObserver methods. Any change to the model results in closing
   // the menu.
   virtual void Loaded(BookmarkModel* model) {}
@@ -129,6 +144,7 @@ class BookmarkContextMenuController : public BookmarkModelObserver {
   std::vector<const BookmarkNode*> selection_;
   ConfigurationType configuration_;
   BookmarkModel* model_;
+  scoped_ptr<menus::SimpleMenuModel> menu_model_;
 
   DISALLOW_COPY_AND_ASSIGN(BookmarkContextMenuController);
 };
diff --git a/chrome/browser/bookmarks/bookmark_context_menu_controller_unittest.cc b/chrome/browser/bookmarks/bookmark_context_menu_controller_unittest.cc
new file mode 100755
index 0000000..96907f8
--- /dev/null
+++ b/chrome/browser/bookmarks/bookmark_context_menu_controller_unittest.cc
@@ -0,0 +1,346 @@
+// Copyright (c) 2010 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 "base/scoped_ptr.h"
+#include "chrome/browser/bookmarks/bookmark_context_menu_controller.h"
+#include "chrome/browser/bookmarks/bookmark_model.h"
+#include "chrome/browser/bookmarks/bookmark_utils.h"
+#include "chrome/browser/chrome_thread.h"
+#include "chrome/browser/profile.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/common/pref_service.h"
+#include "chrome/browser/tab_contents/page_navigator.h"
+#include "chrome/test/testing_profile.h"
+#include "grit/generated_resources.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+#if defined(OS_WIN)
+#include "chrome/browser/views/bookmark_bar_view.h"
+#endif
+
+namespace {
+
+// PageNavigator implementation that records the URL.
+class TestingPageNavigator : public PageNavigator {
+ public:
+  virtual void OpenURL(const GURL& url,
+                       const GURL& referrer,
+                       WindowOpenDisposition disposition,
+                       PageTransition::Type transition) {
+    urls_.push_back(url);
+  }
+
+  std::vector<GURL> urls_;
+};
+
+}  // namespace
+
+class BookmarkContextMenuTest : public testing::Test {
+ public:
+  BookmarkContextMenuTest()
+      : ui_thread_(ChromeThread::UI, &message_loop_),
+        file_thread_(ChromeThread::FILE, &message_loop_),
+        model_(NULL) {
+  }
+
+  virtual void SetUp() {
+#if defined(OS_WIN)
+    BookmarkBarView::testing_ = true;
+#endif
+
+    profile_.reset(new TestingProfile());
+    profile_->set_has_history_service(true);
+    profile_->CreateBookmarkModel(true);
+    profile_->BlockUntilBookmarkModelLoaded();
+
+    model_ = profile_->GetBookmarkModel();
+
+    AddTestData();
+  }
+
+  virtual void TearDown() {
+#if defined(OS_WIN)
+    BookmarkBarView::testing_ = false;
+#endif
+
+    // Flush the message loop to make Purify happy.
+    message_loop_.RunAllPending();
+  }
+
+ protected:
+  MessageLoopForUI message_loop_;
+  ChromeThread ui_thread_;
+  ChromeThread file_thread_;
+  scoped_ptr<TestingProfile> profile_;
+  BookmarkModel* model_;
+  TestingPageNavigator navigator_;
+
+ private:
+  // Creates the following structure:
+  // a
+  // F1
+  //  f1a
+  //  F11
+  //   f11a
+  // F2
+  // F3
+  // F4
+  //   f4a
+  void AddTestData() {
+    std::string test_base = "file:///c:/tmp/";
+
+    model_->AddURL(model_->GetBookmarkBarNode(), 0, L"a",
+                   GURL(test_base + "a"));
+    const BookmarkNode* f1 =
+        model_->AddGroup(model_->GetBookmarkBarNode(), 1, L"F1");
+    model_->AddURL(f1, 0, L"f1a", GURL(test_base + "f1a"));
+    const BookmarkNode* f11 = model_->AddGroup(f1, 1, L"F11");
+    model_->AddURL(f11, 0, L"f11a", GURL(test_base + "f11a"));
+    model_->AddGroup(model_->GetBookmarkBarNode(), 2, L"F2");
+    model_->AddGroup(model_->GetBookmarkBarNode(), 3, L"F3");
+    const BookmarkNode* f4 =
+        model_->AddGroup(model_->GetBookmarkBarNode(), 4, L"F4");
+    model_->AddURL(f4, 0, L"f4a", GURL(test_base + "f4a"));
+  }
+};
+
+// Tests Deleting from the menu.
+TEST_F(BookmarkContextMenuTest, DeleteURL) {
+  std::vector<const BookmarkNode*> nodes;
+  nodes.push_back(model_->GetBookmarkBarNode()->GetChild(0));
+  BookmarkContextMenuController controller(
+      NULL, NULL, profile_.get(), NULL, nodes[0]->GetParent(), nodes,
+      BookmarkContextMenuController::BOOKMARK_BAR);
+  GURL url = model_->GetBookmarkBarNode()->GetChild(0)->GetURL();
+  ASSERT_TRUE(controller.IsCommandIdEnabled(IDS_BOOKMARK_BAR_REMOVE));
+  // Delete the URL.
+  controller.ExecuteCommand(IDS_BOOKMARK_BAR_REMOVE);
+  // Model shouldn't have URL anymore.
+  ASSERT_FALSE(model_->IsBookmarked(url));
+}
+
+// Tests open all on a folder with a couple of bookmarks.
+TEST_F(BookmarkContextMenuTest, OpenAll) {
+  const BookmarkNode* folder = model_->GetBookmarkBarNode()->GetChild(1);
+  bookmark_utils::OpenAll(
+      NULL, profile_.get(), &navigator_, folder, NEW_FOREGROUND_TAB);
+
+  // Should have navigated to F1's children.
+  ASSERT_EQ(static_cast<size_t>(2), navigator_.urls_.size());
+  ASSERT_TRUE(folder->GetChild(0)->GetURL() == navigator_.urls_[0]);
+  ASSERT_TRUE(folder->GetChild(1)->GetChild(0)->GetURL() ==
+              navigator_.urls_[1]);
+}
+
+// Tests the enabled state of the menus when supplied an empty vector.
+TEST_F(BookmarkContextMenuTest, EmptyNodes) {
+  BookmarkContextMenuController controller(
+      NULL, NULL, profile_.get(), NULL, model_->other_node(),
+      std::vector<const BookmarkNode*>(),
+      BookmarkContextMenuController::BOOKMARK_BAR);
+  EXPECT_FALSE(controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_OPEN_ALL));
+  EXPECT_FALSE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_OPEN_ALL_NEW_WINDOW));
+  EXPECT_FALSE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_OPEN_ALL_INCOGNITO));
+  EXPECT_FALSE(controller.IsCommandIdEnabled(IDS_BOOKMARK_BAR_REMOVE));
+  EXPECT_FALSE(
+      controller.IsCommandIdEnabled(IDS_BOOKMARK_MANAGER_SHOW_IN_FOLDER));
+  EXPECT_TRUE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_ADD_NEW_BOOKMARK));
+  EXPECT_TRUE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_NEW_FOLDER));
+}
+
+// Tests the enabled state of the menus when supplied a vector with a single
+// url.
+TEST_F(BookmarkContextMenuTest, SingleURL) {
+  std::vector<const BookmarkNode*> nodes;
+  nodes.push_back(model_->GetBookmarkBarNode()->GetChild(0));
+  BookmarkContextMenuController controller(
+      NULL, NULL, profile_.get(), NULL, nodes[0]->GetParent(),
+      nodes, BookmarkContextMenuController::BOOKMARK_BAR);
+  EXPECT_TRUE(controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_OPEN_ALL));
+  EXPECT_TRUE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_OPEN_ALL_NEW_WINDOW));
+  EXPECT_TRUE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_OPEN_ALL_INCOGNITO));
+  EXPECT_TRUE(controller.IsCommandIdEnabled(IDS_BOOKMARK_BAR_REMOVE));
+  EXPECT_FALSE(
+      controller.IsCommandIdEnabled(IDS_BOOKMARK_MANAGER_SHOW_IN_FOLDER));
+  EXPECT_TRUE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_ADD_NEW_BOOKMARK));
+  EXPECT_TRUE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_NEW_FOLDER));
+}
+
+// Tests the enabled state of the menus when supplied a vector with multiple
+// urls.
+TEST_F(BookmarkContextMenuTest, MultipleURLs) {
+  std::vector<const BookmarkNode*> nodes;
+  nodes.push_back(model_->GetBookmarkBarNode()->GetChild(0));
+  nodes.push_back(model_->GetBookmarkBarNode()->GetChild(1)->GetChild(0));
+  BookmarkContextMenuController controller(
+      NULL, NULL, profile_.get(), NULL, nodes[0]->GetParent(),
+      nodes, BookmarkContextMenuController::BOOKMARK_BAR);
+  EXPECT_TRUE(controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_OPEN_ALL));
+  EXPECT_TRUE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_OPEN_ALL_NEW_WINDOW));
+  EXPECT_TRUE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_OPEN_ALL_INCOGNITO));
+  EXPECT_TRUE(controller.IsCommandIdEnabled(IDS_BOOKMARK_BAR_REMOVE));
+  EXPECT_FALSE(
+      controller.IsCommandIdEnabled(IDS_BOOKMARK_MANAGER_SHOW_IN_FOLDER));
+  EXPECT_TRUE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_ADD_NEW_BOOKMARK));
+  EXPECT_TRUE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_NEW_FOLDER));
+}
+
+// Tests the enabled state of the menus when supplied an vector with a single
+// folder.
+TEST_F(BookmarkContextMenuTest, SingleFolder) {
+  std::vector<const BookmarkNode*> nodes;
+  nodes.push_back(model_->GetBookmarkBarNode()->GetChild(2));
+  BookmarkContextMenuController controller(
+      NULL, NULL, profile_.get(), NULL, nodes[0]->GetParent(),
+      nodes, BookmarkContextMenuController::BOOKMARK_BAR);
+  EXPECT_FALSE(controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_OPEN_ALL));
+  EXPECT_FALSE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_OPEN_ALL_NEW_WINDOW));
+  EXPECT_FALSE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_OPEN_ALL_INCOGNITO));
+  EXPECT_TRUE(controller.IsCommandIdEnabled(IDS_BOOKMARK_BAR_REMOVE));
+  EXPECT_FALSE(
+      controller.IsCommandIdEnabled(IDS_BOOKMARK_MANAGER_SHOW_IN_FOLDER));
+  EXPECT_TRUE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_ADD_NEW_BOOKMARK));
+  EXPECT_TRUE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_NEW_FOLDER));
+}
+
+// Tests the enabled state of the menus when supplied a vector with multiple
+// folders, all of which are empty.
+TEST_F(BookmarkContextMenuTest, MultipleEmptyFolders) {
+  std::vector<const BookmarkNode*> nodes;
+  nodes.push_back(model_->GetBookmarkBarNode()->GetChild(2));
+  nodes.push_back(model_->GetBookmarkBarNode()->GetChild(3));
+  BookmarkContextMenuController controller(
+      NULL, NULL, profile_.get(), NULL, nodes[0]->GetParent(),
+      nodes, BookmarkContextMenuController::BOOKMARK_BAR);
+  EXPECT_FALSE(controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_OPEN_ALL));
+  EXPECT_FALSE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_OPEN_ALL_NEW_WINDOW));
+  EXPECT_FALSE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_OPEN_ALL_INCOGNITO));
+  EXPECT_TRUE(controller.IsCommandIdEnabled(IDS_BOOKMARK_BAR_REMOVE));
+  EXPECT_FALSE(
+      controller.IsCommandIdEnabled(IDS_BOOKMARK_MANAGER_SHOW_IN_FOLDER));
+  EXPECT_TRUE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_ADD_NEW_BOOKMARK));
+  EXPECT_TRUE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_NEW_FOLDER));
+}
+
+// Tests the enabled state of the menus when supplied a vector with multiple
+// folders, some of which contain URLs.
+TEST_F(BookmarkContextMenuTest, MultipleFoldersWithURLs) {
+  std::vector<const BookmarkNode*> nodes;
+  nodes.push_back(model_->GetBookmarkBarNode()->GetChild(3));
+  nodes.push_back(model_->GetBookmarkBarNode()->GetChild(4));
+  BookmarkContextMenuController controller(
+      NULL, NULL, profile_.get(), NULL, nodes[0]->GetParent(),
+      nodes, BookmarkContextMenuController::BOOKMARK_BAR);
+  EXPECT_TRUE(controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_OPEN_ALL));
+  EXPECT_TRUE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_OPEN_ALL_NEW_WINDOW));
+  EXPECT_TRUE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_OPEN_ALL_INCOGNITO));
+  EXPECT_TRUE(controller.IsCommandIdEnabled(IDS_BOOKMARK_BAR_REMOVE));
+  EXPECT_FALSE(
+      controller.IsCommandIdEnabled(IDS_BOOKMARK_MANAGER_SHOW_IN_FOLDER));
+  EXPECT_TRUE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_ADD_NEW_BOOKMARK));
+  EXPECT_TRUE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_NEW_FOLDER));
+}
+
+// Tests the enabled state of open incognito.
+TEST_F(BookmarkContextMenuTest, DisableIncognito) {
+  std::vector<const BookmarkNode*> nodes;
+  nodes.push_back(model_->GetBookmarkBarNode()->GetChild(0));
+  BookmarkContextMenuController controller(
+      NULL, NULL, profile_.get(), NULL, nodes[0]->GetParent(),
+      nodes, BookmarkContextMenuController::BOOKMARK_BAR);
+  profile_->set_off_the_record(true);
+  EXPECT_FALSE(controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_OPEN_INCOGNITO));
+  EXPECT_FALSE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_OPEN_ALL_INCOGNITO));
+}
+
+// Tests that you can't remove/edit when showing the other node.
+TEST_F(BookmarkContextMenuTest, DisabledItemsWithOtherNode) {
+  std::vector<const BookmarkNode*> nodes;
+  nodes.push_back(model_->other_node());
+  BookmarkContextMenuController controller(
+      NULL, NULL, profile_.get(), NULL, nodes[0], nodes,
+      BookmarkContextMenuController::BOOKMARK_BAR);
+  EXPECT_FALSE(controller.IsCommandIdEnabled(IDS_BOOKMARK_BAR_EDIT));
+  EXPECT_FALSE(controller.IsCommandIdEnabled(IDS_BOOKMARK_BAR_REMOVE));
+}
+
+// Tests the enabled state of the menus when supplied an empty vector and null
+// parent.
+TEST_F(BookmarkContextMenuTest, EmptyNodesNullParent) {
+  BookmarkContextMenuController controller(
+      NULL, NULL, profile_.get(), NULL, NULL,
+      std::vector<const BookmarkNode*>(),
+      BookmarkContextMenuController::BOOKMARK_MANAGER_ORGANIZE_MENU);
+  EXPECT_FALSE(controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_OPEN_ALL));
+  EXPECT_FALSE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_OPEN_ALL_NEW_WINDOW));
+  EXPECT_FALSE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_OPEN_ALL_INCOGNITO));
+  EXPECT_FALSE(controller.IsCommandIdEnabled(IDS_BOOKMARK_BAR_REMOVE));
+  EXPECT_FALSE(
+      controller.IsCommandIdEnabled(IDS_BOOKMARK_MANAGER_SHOW_IN_FOLDER));
+  EXPECT_FALSE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_ADD_NEW_BOOKMARK));
+  EXPECT_FALSE(
+      controller.IsCommandIdEnabled(IDS_BOOMARK_BAR_NEW_FOLDER));
+}
+
+TEST_F(BookmarkContextMenuTest, CutCopyPasteNode) {
+  std::vector<const BookmarkNode*> nodes;
+  nodes.push_back(model_->GetBookmarkBarNode()->GetChild(0));
+  scoped_ptr<BookmarkContextMenuController> controller(
+      new BookmarkContextMenuController(
+          NULL, NULL, profile_.get(), NULL, nodes[0]->GetParent(), nodes,
+          BookmarkContextMenuController::BOOKMARK_BAR));
+  EXPECT_TRUE(controller->IsCommandIdEnabled(IDS_COPY));
+  EXPECT_TRUE(controller->IsCommandIdEnabled(IDS_CUT));
+
+  // Copy the URL.
+  controller->ExecuteCommand(IDS_COPY);
+
+  controller.reset(new BookmarkContextMenuController(
+      NULL, NULL, profile_.get(), NULL, nodes[0]->GetParent(), nodes,
+      BookmarkContextMenuController::BOOKMARK_BAR));
+  int old_count = model_->GetBookmarkBarNode()->GetChildCount();
+  controller->ExecuteCommand(IDS_PASTE);
+
+  ASSERT_TRUE(model_->GetBookmarkBarNode()->GetChild(1)->is_url());
+  ASSERT_EQ(old_count + 1, model_->GetBookmarkBarNode()->GetChildCount());
+  ASSERT_EQ(model_->GetBookmarkBarNode()->GetChild(0)->GetURL(),
+            model_->GetBookmarkBarNode()->GetChild(1)->GetURL());
+
+  controller.reset(new BookmarkContextMenuController(
+      NULL, NULL, profile_.get(), NULL, nodes[0]->GetParent(), nodes,
+      BookmarkContextMenuController::BOOKMARK_BAR));
+  // Cut the URL.
+  controller->ExecuteCommand(IDS_CUT);
+  ASSERT_TRUE(model_->GetBookmarkBarNode()->GetChild(0)->is_url());
+  ASSERT_TRUE(model_->GetBookmarkBarNode()->GetChild(1)->is_folder());
+  ASSERT_EQ(old_count, model_->GetBookmarkBarNode()->GetChildCount());
+}