chrome/browser/ui/views/bookmarks/bookmark_context_menu_test.cc

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