| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include <string> | |
| 6 | |
| 7 #include "base/memory/scoped_ptr.h" | |
| 8 #include "base/utf_string_conversions.h" | |
| 9 #include "chrome/app/chrome_command_ids.h" | |
| 10 #include "chrome/browser/bookmarks/bookmark_context_menu_controller.h" | |
| 11 #include "chrome/browser/bookmarks/bookmark_model.h" | |
| 12 #include "chrome/browser/bookmarks/bookmark_model_factory.h" | |
| 13 #include "chrome/browser/bookmarks/bookmark_utils.h" | |
| 14 #include "chrome/browser/profiles/profile.h" | |
| 15 #include "chrome/test/base/testing_profile.h" | |
| 16 #include "content/public/browser/page_navigator.h" | |
| 17 #include "content/public/test/test_browser_thread.h" | |
| 18 #include "grit/generated_resources.h" | |
| 19 #include "testing/gtest/include/gtest/gtest.h" | |
| 20 #include "ui/base/clipboard/clipboard.h" | |
| 21 | |
| 22 using content::BrowserThread; | |
| 23 using content::OpenURLParams; | |
| 24 using content::PageNavigator; | |
| 25 using content::WebContents; | |
| 26 | |
| 27 // PageNavigator implementation that records the URL. | |
| 28 class TestingPageNavigator : public PageNavigator { | |
| 29 public: | |
| 30 virtual WebContents* OpenURL(const OpenURLParams& params) OVERRIDE { | |
| 31 urls_.push_back(params.url); | |
| 32 return NULL; | |
| 33 } | |
| 34 | |
| 35 std::vector<GURL> urls_; | |
| 36 }; | |
| 37 | |
| 38 class BookmarkContextMenuControllerTest : public testing::Test { | |
| 39 public: | |
| 40 BookmarkContextMenuControllerTest() | |
| 41 : ui_thread_(BrowserThread::UI, &message_loop_), | |
| 42 file_thread_(BrowserThread::FILE, &message_loop_), | |
| 43 model_(NULL) { | |
| 44 } | |
| 45 | |
| 46 virtual void SetUp() { | |
| 47 #if defined(OS_WIN) | |
| 48 bookmark_utils::DisableBookmarkBarViewAnimationsForTesting(true); | |
| 49 #endif | |
| 50 | |
| 51 profile_.reset(new TestingProfile()); | |
| 52 profile_->CreateBookmarkModel(true); | |
| 53 profile_->BlockUntilBookmarkModelLoaded(); | |
| 54 | |
| 55 model_ = BookmarkModelFactory::GetForProfile(profile_.get()); | |
| 56 | |
| 57 AddTestData(); | |
| 58 } | |
| 59 | |
| 60 virtual void TearDown() { | |
| 61 #if defined(OS_WIN) | |
| 62 bookmark_utils::DisableBookmarkBarViewAnimationsForTesting(false); | |
| 63 #endif | |
| 64 | |
| 65 ui::Clipboard::DestroyClipboardForCurrentThread(); | |
| 66 | |
| 67 // Flush the message loop to make application verifiers happy. | |
| 68 message_loop_.RunAllPending(); | |
| 69 } | |
| 70 | |
| 71 protected: | |
| 72 MessageLoopForUI message_loop_; | |
| 73 content::TestBrowserThread ui_thread_; | |
| 74 content::TestBrowserThread file_thread_; | |
| 75 scoped_ptr<TestingProfile> profile_; | |
| 76 BookmarkModel* model_; | |
| 77 TestingPageNavigator navigator_; | |
| 78 | |
| 79 private: | |
| 80 // Creates the following structure: | |
| 81 // a | |
| 82 // F1 | |
| 83 // f1a | |
| 84 // F11 | |
| 85 // f11a | |
| 86 // F2 | |
| 87 // F3 | |
| 88 // F4 | |
| 89 // f4a | |
| 90 void AddTestData() { | |
| 91 const BookmarkNode* bb_node = model_->bookmark_bar_node(); | |
| 92 std::string test_base = "file:///c:/tmp/"; | |
| 93 model_->AddURL(bb_node, 0, ASCIIToUTF16("a"), GURL(test_base + "a")); | |
| 94 const BookmarkNode* f1 = model_->AddFolder(bb_node, 1, ASCIIToUTF16("F1")); | |
| 95 model_->AddURL(f1, 0, ASCIIToUTF16("f1a"), GURL(test_base + "f1a")); | |
| 96 const BookmarkNode* f11 = model_->AddFolder(f1, 1, ASCIIToUTF16("F11")); | |
| 97 model_->AddURL(f11, 0, ASCIIToUTF16("f11a"), GURL(test_base + "f11a")); | |
| 98 model_->AddFolder(bb_node, 2, ASCIIToUTF16("F2")); | |
| 99 model_->AddFolder(bb_node, 3, ASCIIToUTF16("F3")); | |
| 100 const BookmarkNode* f4 = model_->AddFolder(bb_node, 4, ASCIIToUTF16("F4")); | |
| 101 model_->AddURL(f4, 0, ASCIIToUTF16("f4a"), GURL(test_base + "f4a")); | |
| 102 } | |
| 103 }; | |
| 104 | |
| 105 // Tests Deleting from the menu. | |
| 106 TEST_F(BookmarkContextMenuControllerTest, DeleteURL) { | |
| 107 std::vector<const BookmarkNode*> nodes; | |
| 108 nodes.push_back(model_->bookmark_bar_node()->GetChild(0)); | |
| 109 BookmarkContextMenuController controller( | |
| 110 NULL, NULL, NULL, profile_.get(), NULL, nodes[0]->parent(), nodes); | |
| 111 GURL url = model_->bookmark_bar_node()->GetChild(0)->url(); | |
| 112 ASSERT_TRUE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_REMOVE)); | |
| 113 // Delete the URL. | |
| 114 controller.ExecuteCommand(IDC_BOOKMARK_BAR_REMOVE); | |
| 115 // Model shouldn't have URL anymore. | |
| 116 ASSERT_FALSE(model_->IsBookmarked(url)); | |
| 117 } | |
| 118 | |
| 119 // Tests open all on a folder with a couple of bookmarks. | |
| 120 TEST_F(BookmarkContextMenuControllerTest, OpenAll) { | |
| 121 const BookmarkNode* folder = model_->bookmark_bar_node()->GetChild(1); | |
| 122 bookmark_utils::OpenAll(NULL, &navigator_, folder, NEW_FOREGROUND_TAB); | |
| 123 | |
| 124 // Should have navigated to F1's child, but not F11's child. | |
| 125 ASSERT_EQ(static_cast<size_t>(1), navigator_.urls_.size()); | |
| 126 ASSERT_TRUE(folder->GetChild(0)->url() == navigator_.urls_[0]); | |
| 127 } | |
| 128 | |
| 129 // Tests the enabled state of the menus when supplied an empty vector. | |
| 130 TEST_F(BookmarkContextMenuControllerTest, EmptyNodes) { | |
| 131 BookmarkContextMenuController controller( | |
| 132 NULL, NULL, NULL, profile_.get(), NULL, model_->other_node(), | |
| 133 std::vector<const BookmarkNode*>()); | |
| 134 EXPECT_FALSE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL)); | |
| 135 EXPECT_FALSE( | |
| 136 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_NEW_WINDOW)); | |
| 137 EXPECT_FALSE( | |
| 138 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_INCOGNITO)); | |
| 139 EXPECT_FALSE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_REMOVE)); | |
| 140 EXPECT_TRUE( | |
| 141 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_ADD_NEW_BOOKMARK)); | |
| 142 EXPECT_TRUE( | |
| 143 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_NEW_FOLDER)); | |
| 144 } | |
| 145 | |
| 146 // Tests the enabled state of the menus when supplied a vector with a single | |
| 147 // url. | |
| 148 TEST_F(BookmarkContextMenuControllerTest, SingleURL) { | |
| 149 std::vector<const BookmarkNode*> nodes; | |
| 150 nodes.push_back(model_->bookmark_bar_node()->GetChild(0)); | |
| 151 BookmarkContextMenuController controller( | |
| 152 NULL, NULL, NULL, profile_.get(), NULL, nodes[0]->parent(), nodes); | |
| 153 EXPECT_TRUE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL)); | |
| 154 EXPECT_TRUE( | |
| 155 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_NEW_WINDOW)); | |
| 156 EXPECT_TRUE( | |
| 157 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_INCOGNITO)); | |
| 158 EXPECT_TRUE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_REMOVE)); | |
| 159 EXPECT_TRUE( | |
| 160 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_ADD_NEW_BOOKMARK)); | |
| 161 EXPECT_TRUE( | |
| 162 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_NEW_FOLDER)); | |
| 163 } | |
| 164 | |
| 165 // Tests the enabled state of the menus when supplied a vector with multiple | |
| 166 // urls. | |
| 167 TEST_F(BookmarkContextMenuControllerTest, MultipleURLs) { | |
| 168 std::vector<const BookmarkNode*> nodes; | |
| 169 nodes.push_back(model_->bookmark_bar_node()->GetChild(0)); | |
| 170 nodes.push_back(model_->bookmark_bar_node()->GetChild(1)->GetChild(0)); | |
| 171 BookmarkContextMenuController controller( | |
| 172 NULL, NULL, NULL, profile_.get(), NULL, nodes[0]->parent(), nodes); | |
| 173 EXPECT_TRUE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL)); | |
| 174 EXPECT_TRUE( | |
| 175 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_NEW_WINDOW)); | |
| 176 EXPECT_TRUE( | |
| 177 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_INCOGNITO)); | |
| 178 EXPECT_TRUE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_REMOVE)); | |
| 179 EXPECT_TRUE( | |
| 180 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_ADD_NEW_BOOKMARK)); | |
| 181 EXPECT_TRUE( | |
| 182 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_NEW_FOLDER)); | |
| 183 } | |
| 184 | |
| 185 // Tests the enabled state of the menus when supplied an vector with a single | |
| 186 // folder. | |
| 187 TEST_F(BookmarkContextMenuControllerTest, SingleFolder) { | |
| 188 std::vector<const BookmarkNode*> nodes; | |
| 189 nodes.push_back(model_->bookmark_bar_node()->GetChild(2)); | |
| 190 BookmarkContextMenuController controller( | |
| 191 NULL, NULL, NULL, profile_.get(), NULL, nodes[0]->parent(), nodes); | |
| 192 EXPECT_FALSE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL)); | |
| 193 EXPECT_FALSE( | |
| 194 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_NEW_WINDOW)); | |
| 195 EXPECT_FALSE( | |
| 196 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_INCOGNITO)); | |
| 197 EXPECT_TRUE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_REMOVE)); | |
| 198 EXPECT_TRUE( | |
| 199 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_ADD_NEW_BOOKMARK)); | |
| 200 EXPECT_TRUE( | |
| 201 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_NEW_FOLDER)); | |
| 202 } | |
| 203 | |
| 204 // Tests the enabled state of the menus when supplied a vector with multiple | |
| 205 // folders, all of which are empty. | |
| 206 TEST_F(BookmarkContextMenuControllerTest, MultipleEmptyFolders) { | |
| 207 std::vector<const BookmarkNode*> nodes; | |
| 208 nodes.push_back(model_->bookmark_bar_node()->GetChild(2)); | |
| 209 nodes.push_back(model_->bookmark_bar_node()->GetChild(3)); | |
| 210 BookmarkContextMenuController controller( | |
| 211 NULL, NULL, NULL, profile_.get(), NULL, nodes[0]->parent(), nodes); | |
| 212 EXPECT_FALSE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL)); | |
| 213 EXPECT_FALSE( | |
| 214 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_NEW_WINDOW)); | |
| 215 EXPECT_FALSE( | |
| 216 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_INCOGNITO)); | |
| 217 EXPECT_TRUE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_REMOVE)); | |
| 218 EXPECT_TRUE( | |
| 219 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_ADD_NEW_BOOKMARK)); | |
| 220 EXPECT_TRUE( | |
| 221 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_NEW_FOLDER)); | |
| 222 } | |
| 223 | |
| 224 // Tests the enabled state of the menus when supplied a vector with multiple | |
| 225 // folders, some of which contain URLs. | |
| 226 TEST_F(BookmarkContextMenuControllerTest, MultipleFoldersWithURLs) { | |
| 227 std::vector<const BookmarkNode*> nodes; | |
| 228 nodes.push_back(model_->bookmark_bar_node()->GetChild(3)); | |
| 229 nodes.push_back(model_->bookmark_bar_node()->GetChild(4)); | |
| 230 BookmarkContextMenuController controller( | |
| 231 NULL, NULL, NULL, profile_.get(), NULL, nodes[0]->parent(), nodes); | |
| 232 EXPECT_TRUE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL)); | |
| 233 EXPECT_TRUE( | |
| 234 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_NEW_WINDOW)); | |
| 235 EXPECT_TRUE( | |
| 236 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_INCOGNITO)); | |
| 237 EXPECT_TRUE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_REMOVE)); | |
| 238 EXPECT_TRUE( | |
| 239 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_ADD_NEW_BOOKMARK)); | |
| 240 EXPECT_TRUE( | |
| 241 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_NEW_FOLDER)); | |
| 242 } | |
| 243 | |
| 244 // Tests the enabled state of open incognito. | |
| 245 TEST_F(BookmarkContextMenuControllerTest, DisableIncognito) { | |
| 246 std::vector<const BookmarkNode*> nodes; | |
| 247 nodes.push_back(model_->bookmark_bar_node()->GetChild(0)); | |
| 248 BookmarkContextMenuController controller( | |
| 249 NULL, NULL, NULL, profile_.get(), NULL, nodes[0]->parent(), nodes); | |
| 250 profile_->set_incognito(true); | |
| 251 EXPECT_FALSE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_INCOGNITO)); | |
| 252 EXPECT_FALSE( | |
| 253 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_INCOGNITO)); | |
| 254 } | |
| 255 | |
| 256 // Tests that you can't remove/edit when showing the other node. | |
| 257 TEST_F(BookmarkContextMenuControllerTest, DisabledItemsWithOtherNode) { | |
| 258 std::vector<const BookmarkNode*> nodes; | |
| 259 nodes.push_back(model_->other_node()); | |
| 260 BookmarkContextMenuController controller( | |
| 261 NULL, NULL, NULL, profile_.get(), NULL, nodes[0], nodes); | |
| 262 EXPECT_FALSE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_EDIT)); | |
| 263 EXPECT_FALSE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_REMOVE)); | |
| 264 } | |
| 265 | |
| 266 // Tests the enabled state of the menus when supplied an empty vector and null | |
| 267 // parent. | |
| 268 TEST_F(BookmarkContextMenuControllerTest, EmptyNodesNullParent) { | |
| 269 BookmarkContextMenuController controller( | |
| 270 NULL, NULL, NULL, profile_.get(), NULL, NULL, | |
| 271 std::vector<const BookmarkNode*>()); | |
| 272 EXPECT_FALSE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL)); | |
| 273 EXPECT_FALSE( | |
| 274 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_NEW_WINDOW)); | |
| 275 EXPECT_FALSE( | |
| 276 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_INCOGNITO)); | |
| 277 EXPECT_FALSE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_REMOVE)); | |
| 278 EXPECT_FALSE( | |
| 279 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_ADD_NEW_BOOKMARK)); | |
| 280 EXPECT_FALSE( | |
| 281 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_NEW_FOLDER)); | |
| 282 } | |
| 283 | |
| 284 // Tests the enabled state of the menus when supplied a vector containing just | |
| 285 // the top-level bookmark bar node. | |
| 286 TEST_F(BookmarkContextMenuControllerTest, BookmarkBar) { | |
| 287 std::vector<const BookmarkNode*> nodes; | |
| 288 nodes.push_back(model_->bookmark_bar_node()); | |
| 289 BookmarkContextMenuController controller( | |
| 290 NULL, NULL, NULL, profile_.get(), NULL, nodes[0]->parent(), nodes); | |
| 291 EXPECT_TRUE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL)); | |
| 292 EXPECT_TRUE( | |
| 293 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_NEW_WINDOW)); | |
| 294 EXPECT_TRUE( | |
| 295 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_OPEN_ALL_INCOGNITO)); | |
| 296 EXPECT_FALSE(controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_REMOVE)); | |
| 297 EXPECT_TRUE( | |
| 298 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_ADD_NEW_BOOKMARK)); | |
| 299 EXPECT_TRUE( | |
| 300 controller.IsCommandIdEnabled(IDC_BOOKMARK_BAR_NEW_FOLDER)); | |
| 301 } | |
| 302 | |
| 303 TEST_F(BookmarkContextMenuControllerTest, CutCopyPasteNode) { | |
| 304 const BookmarkNode* bb_node = model_->bookmark_bar_node(); | |
| 305 std::vector<const BookmarkNode*> nodes; | |
| 306 nodes.push_back(bb_node->GetChild(0)); | |
| 307 scoped_ptr<BookmarkContextMenuController> controller( | |
| 308 new BookmarkContextMenuController( | |
| 309 NULL, NULL, NULL, profile_.get(), NULL, nodes[0]->parent(), nodes)); | |
| 310 EXPECT_TRUE(controller->IsCommandIdEnabled(IDC_COPY)); | |
| 311 EXPECT_TRUE(controller->IsCommandIdEnabled(IDC_CUT)); | |
| 312 | |
| 313 // Copy the URL. | |
| 314 controller->ExecuteCommand(IDC_COPY); | |
| 315 | |
| 316 controller.reset(new BookmarkContextMenuController( | |
| 317 NULL, NULL, NULL, profile_.get(), NULL, nodes[0]->parent(), nodes)); | |
| 318 int old_count = bb_node->child_count(); | |
| 319 controller->ExecuteCommand(IDC_PASTE); | |
| 320 | |
| 321 ASSERT_TRUE(bb_node->GetChild(1)->is_url()); | |
| 322 ASSERT_EQ(old_count + 1, bb_node->child_count()); | |
| 323 ASSERT_EQ(bb_node->GetChild(0)->url(), bb_node->GetChild(1)->url()); | |
| 324 | |
| 325 controller.reset(new BookmarkContextMenuController( | |
| 326 NULL, NULL, NULL, profile_.get(), NULL, nodes[0]->parent(), nodes)); | |
| 327 // Cut the URL. | |
| 328 controller->ExecuteCommand(IDC_CUT); | |
| 329 ASSERT_TRUE(bb_node->GetChild(0)->is_url()); | |
| 330 ASSERT_TRUE(bb_node->GetChild(1)->is_folder()); | |
| 331 ASSERT_EQ(old_count, bb_node->child_count()); | |
| 332 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 10977060:
bookmarks: Move context menu controller into ui/bookmarks directory. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src