Added BookmarkClient::CanBeEditedByUser.

components/bookmarks/browser/bookmark_model_unittest.cc

 // Copyright 2014 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 "components/bookmarks/browser/bookmark_model.h"
 
 #include <set>
 #include <string>
 
 #include "base/base_paths.h"
@@ skipping 249 matching lines @@
   void AssertExtensiveChangesObserverCount(
       int extensive_changes_beginning_count,
       int extensive_changes_ended_count) {
     EXPECT_EQ(extensive_changes_beginning_count_,
               extensive_changes_beginning_count);
     EXPECT_EQ(extensive_changes_ended_count_, extensive_changes_ended_count);
   }
 
   int AllNodesRemovedObserverCount() const { return all_bookmarks_removed_; }
 
+  BookmarkPermanentNode* ReloadModelWithExtraNode() {
+    BookmarkPermanentNode* extra_node = new BookmarkPermanentNode(100);
+    bookmarks::BookmarkPermanentNodeList extra_nodes;
+    extra_nodes.push_back(extra_node);
+    client_.SetExtraNodesToLoad(extra_nodes.Pass());
+
+    model_->RemoveObserver(this);
+    model_ = client_.CreateModel(false);
+    model_->AddObserver(this);
+    ClearCounts();
+
+    if (model_->root_node()->GetIndexOf(extra_node) == -1)
+      ADD_FAILURE();
+
+    return extra_node;
+  }
+
  protected:
   test::TestBookmarkClient client_;
   scoped_ptr<BookmarkModel> model_;
   ObserverDetails observer_details_;
 
  private:
   int added_count_;
   int moved_count_;
   int removed_count_;
   int changed_count_;
@@ skipping 36 matching lines @@
   const GURL url("http://foo.com");
 
   const BookmarkNode* new_node = model_->AddURL(root, 0, title, url);
   AssertObserverCount(1, 0, 0, 0, 0, 0, 0, 0, 0);
   observer_details_.ExpectEquals(root, NULL, 0, -1);
 
   ASSERT_EQ(1, root->child_count());
   ASSERT_EQ(title, new_node->GetTitle());
   ASSERT_TRUE(url == new_node->url());
   ASSERT_EQ(BookmarkNode::URL, new_node->type());
-  ASSERT_TRUE(new_node == model_->GetMostRecentlyAddedNodeForURL(url));
+  ASSERT_TRUE(new_node == model_->GetMostRecentlyAddedUserNodeForURL(url));
 
   EXPECT_TRUE(new_node->id() != root->id() &&
               new_node->id() != model_->other_node()->id() &&
               new_node->id() != model_->mobile_node()->id());
 }
 
 TEST_F(BookmarkModelTest, AddURLWithUnicodeTitle) {
   const BookmarkNode* root = model_->bookmark_bar_node();
   const base::string16 title(base::WideToUTF16(
       L"\u767e\u5ea6\u4e00\u4e0b\uff0c\u4f60\u5c31\u77e5\u9053"));
   const GURL url("https://www.baidu.com/");
 
   const BookmarkNode* new_node = model_->AddURL(root, 0, title, url);
   AssertObserverCount(1, 0, 0, 0, 0, 0, 0, 0, 0);
   observer_details_.ExpectEquals(root, NULL, 0, -1);
 
   ASSERT_EQ(1, root->child_count());
   ASSERT_EQ(title, new_node->GetTitle());
   ASSERT_TRUE(url == new_node->url());
   ASSERT_EQ(BookmarkNode::URL, new_node->type());
-  ASSERT_TRUE(new_node == model_->GetMostRecentlyAddedNodeForURL(url));
+  ASSERT_TRUE(new_node == model_->GetMostRecentlyAddedUserNodeForURL(url));
 
   EXPECT_TRUE(new_node->id() != root->id() &&
               new_node->id() != model_->other_node()->id() &&
               new_node->id() != model_->mobile_node()->id());
 }
 
 TEST_F(BookmarkModelTest, AddURLWithWhitespaceTitle) {
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(url_whitespace_test_cases); ++i) {
     const BookmarkNode* root = model_->bookmark_bar_node();
     const base::string16 title(
@@ skipping 23 matching lines @@
   AssertObserverCount(1, 0, 0, 0, 0, 0, 0, 0, 0);
   observer_details_.ExpectEquals(root, NULL, 0, -1);
 
   ASSERT_EQ(1, root->child_count());
   ASSERT_EQ(title, new_node->GetTitle());
   ASSERT_TRUE(url == new_node->url());
   ASSERT_EQ(BookmarkNode::URL, new_node->type());
   ASSERT_EQ(time, new_node->date_added());
   ASSERT_TRUE(new_node->GetMetaInfoMap());
   ASSERT_EQ(meta_info, *new_node->GetMetaInfoMap());
-  ASSERT_TRUE(new_node == model_->GetMostRecentlyAddedNodeForURL(url));
+  ASSERT_TRUE(new_node == model_->GetMostRecentlyAddedUserNodeForURL(url));
 
   EXPECT_TRUE(new_node->id() != root->id() &&
               new_node->id() != model_->other_node()->id() &&
               new_node->id() != model_->mobile_node()->id());
 }
 
 TEST_F(BookmarkModelTest, AddURLToMobileBookmarks) {
   const BookmarkNode* root = model_->mobile_node();
   const base::string16 title(ASCIIToUTF16("foo"));
   const GURL url("http://foo.com");
 
   const BookmarkNode* new_node = model_->AddURL(root, 0, title, url);
   AssertObserverCount(1, 0, 0, 0, 0, 0, 0, 0, 0);
   observer_details_.ExpectEquals(root, NULL, 0, -1);
 
   ASSERT_EQ(1, root->child_count());
   ASSERT_EQ(title, new_node->GetTitle());
   ASSERT_TRUE(url == new_node->url());
   ASSERT_EQ(BookmarkNode::URL, new_node->type());
-  ASSERT_TRUE(new_node == model_->GetMostRecentlyAddedNodeForURL(url));
+  ASSERT_TRUE(new_node == model_->GetMostRecentlyAddedUserNodeForURL(url));
 
   EXPECT_TRUE(new_node->id() != root->id() &&
               new_node->id() != model_->other_node()->id() &&
               new_node->id() != model_->mobile_node()->id());
 }
 
 TEST_F(BookmarkModelTest, AddFolder) {
   const BookmarkNode* root = model_->bookmark_bar_node();
   const base::string16 title(ASCIIToUTF16("foo"));
 
@@ skipping 38 matching lines @@
   const GURL url("http://foo.com");
   model_->AddURL(root, 0, title, url);
   ClearCounts();
 
   model_->Remove(root, 0);
   ASSERT_EQ(0, root->child_count());
   AssertObserverCount(0, 0, 1, 0, 0, 1, 0, 0, 0);
   observer_details_.ExpectEquals(root, NULL, 0, -1);
 
   // Make sure there is no mapping for the URL.
-  ASSERT_TRUE(model_->GetMostRecentlyAddedNodeForURL(url) == NULL);
+  ASSERT_TRUE(model_->GetMostRecentlyAddedUserNodeForURL(url) == NULL);
 }
 
 TEST_F(BookmarkModelTest, RemoveFolder) {
   const BookmarkNode* root = model_->bookmark_bar_node();
   const BookmarkNode* folder = model_->AddFolder(root, 0, ASCIIToUTF16("foo"));
 
   ClearCounts();
 
   // Add a URL as a child.
   const base::string16 title(ASCIIToUTF16("foo"));
   const GURL url("http://foo.com");
   model_->AddURL(folder, 0, title, url);
 
   ClearCounts();
 
   // Now remove the folder.
   model_->Remove(root, 0);
   ASSERT_EQ(0, root->child_count());
   AssertObserverCount(0, 0, 1, 0, 0, 1, 0, 0, 0);
   observer_details_.ExpectEquals(root, NULL, 0, -1);
 
   // Make sure there is no mapping for the URL.
-  ASSERT_TRUE(model_->GetMostRecentlyAddedNodeForURL(url) == NULL);
+  ASSERT_TRUE(model_->GetMostRecentlyAddedUserNodeForURL(url) == NULL);
 }
 
 TEST_F(BookmarkModelTest, RemoveAll) {
   const BookmarkNode* bookmark_bar_node = model_->bookmark_bar_node();
 
   ClearCounts();
 
   // Add a url to bookmark bar.
   base::string16 title(ASCIIToUTF16("foo"));
   GURL url("http://foo.com");
@@ skipping 91 matching lines @@
   EXPECT_EQ(1, root->child_count());
   EXPECT_EQ(folder1, root->GetChild(0));
   EXPECT_EQ(1, folder1->child_count());
   EXPECT_EQ(node, folder1->GetChild(0));
 
   // And remove the folder.
   ClearCounts();
   model_->Remove(root, 0);
   AssertObserverCount(0, 0, 1, 0, 0, 1, 0, 0, 0);
   observer_details_.ExpectEquals(root, NULL, 0, -1);
-  EXPECT_TRUE(model_->GetMostRecentlyAddedNodeForURL(url) == NULL);
+  EXPECT_TRUE(model_->GetMostRecentlyAddedUserNodeForURL(url) == NULL);
   EXPECT_EQ(0, root->child_count());
 }
 
 TEST_F(BookmarkModelTest, NonMovingMoveCall) {
   const BookmarkNode* root = model_->bookmark_bar_node();
   const base::string16 title(ASCIIToUTF16("foo"));
   const GURL url("http://foo.com");
   const base::Time old_date(base::Time::Now() - base::TimeDelta::FromDays(1));
 
   const BookmarkNode* node = model_->AddURL(root, 0, title, url);
@@ skipping 86 matching lines @@
 // Make sure recently modified stays in sync when adding a URL.
 TEST_F(BookmarkModelTest, MostRecentlyModifiedFolders) {
   // Add a folder.
   const BookmarkNode* folder =
       model_->AddFolder(model_->other_node(), 0, ASCIIToUTF16("foo"));
   // Add a URL to it.
   model_->AddURL(folder, 0, ASCIIToUTF16("blah"), GURL("http://foo.com"));
 
   // Make sure folder is in the most recently modified.
   std::vector<const BookmarkNode*> most_recent_folders =
-      bookmark_utils::GetMostRecentlyModifiedFolders(model_.get(), 1);
+      bookmark_utils::GetMostRecentlyModifiedUserFolders(model_.get(), 1);
   ASSERT_EQ(1U, most_recent_folders.size());
   ASSERT_EQ(folder, most_recent_folders[0]);
 
   // Nuke the folder and do another fetch, making sure folder isn't in the
   // returned list.
   model_->Remove(folder->parent(), 0);
   most_recent_folders =
-      bookmark_utils::GetMostRecentlyModifiedFolders(model_.get(), 1);
+      bookmark_utils::GetMostRecentlyModifiedUserFolders(model_.get(), 1);
   ASSERT_EQ(1U, most_recent_folders.size());
   ASSERT_TRUE(most_recent_folders[0] != folder);
 }
 
 // Make sure MostRecentlyAddedEntries stays in sync.
 TEST_F(BookmarkModelTest, MostRecentlyAddedEntries) {
   // Add a couple of nodes such that the following holds for the time of the
   // nodes: n1 > n2 > n3 > n4.
   Time base_time = Time::Now();
   BookmarkNode* n1 = AsMutable(model_->AddURL(model_->bookmark_bar_node(),
@@ skipping 28 matching lines @@
   recently_added.clear();
   SwapDateAdded(n1, n2);
   bookmark_utils::GetMostRecentlyAddedEntries(model_.get(), 4, &recently_added);
   ASSERT_EQ(4U, recently_added.size());
   ASSERT_TRUE(n2 == recently_added[0]);
   ASSERT_TRUE(n1 == recently_added[1]);
   ASSERT_TRUE(n3 == recently_added[2]);
   ASSERT_TRUE(n4 == recently_added[3]);
 }
 
-// Makes sure GetMostRecentlyAddedNodeForURL stays in sync.
-TEST_F(BookmarkModelTest, GetMostRecentlyAddedNodeForURL) {
+// Makes sure GetMostRecentlyAddedUserNodeForURL stays in sync.
+TEST_F(BookmarkModelTest, GetMostRecentlyAddedUserNodeForURL) {
   // Add a couple of nodes such that the following holds for the time of the
   // nodes: n1 > n2
   Time base_time = Time::Now();
   const GURL url("http://foo.com/0");
   BookmarkNode* n1 = AsMutable(model_->AddURL(
       model_->bookmark_bar_node(), 0, ASCIIToUTF16("blah"), url));
   BookmarkNode* n2 = AsMutable(model_->AddURL(
       model_->bookmark_bar_node(), 1, ASCIIToUTF16("blah"), url));
   n1->set_date_added(base_time + TimeDelta::FromDays(4));
   n2->set_date_added(base_time + TimeDelta::FromDays(3));
 
   // Make sure order is honored.
-  ASSERT_EQ(n1, model_->GetMostRecentlyAddedNodeForURL(url));
+  ASSERT_EQ(n1, model_->GetMostRecentlyAddedUserNodeForURL(url));
 
   // swap 1 and 2, then check again.
   SwapDateAdded(n1, n2);
-  ASSERT_EQ(n2, model_->GetMostRecentlyAddedNodeForURL(url));
+  ASSERT_EQ(n2, model_->GetMostRecentlyAddedUserNodeForURL(url));
 }
 
 // Makes sure GetBookmarks removes duplicates.
 TEST_F(BookmarkModelTest, GetBookmarksWithDups) {
   const GURL url("http://foo.com/0");
   const base::string16 title(ASCIIToUTF16("blah"));
   model_->AddURL(model_->bookmark_bar_node(), 0, title, url);
   model_->AddURL(model_->bookmark_bar_node(), 1, title, url);
 
   std::vector<BookmarkModel::URLAndTitle> bookmarks;
@@ skipping 292 matching lines @@
   EXPECT_TRUE(model_->IsDoingExtensiveChanges());
   AssertExtensiveChangesObserverCount(1, 0);
   model_->EndExtensiveChanges();
   EXPECT_TRUE(model_->IsDoingExtensiveChanges());
   AssertExtensiveChangesObserverCount(1, 0);
   model_->EndExtensiveChanges();
   EXPECT_FALSE(model_->IsDoingExtensiveChanges());
   AssertExtensiveChangesObserverCount(1, 1);
 }
 
+// Verifies that IsBookmarked is true if any bookmark matches the given URL,
+// and that IsBookmarkedByUser is true only if at least one of the matching
+// bookmarks can be edited by the user.
+TEST_F(BookmarkModelTest, IsBookmarked) {
+  // Reload the model with an extra node that is not editable by the user.
+  BookmarkPermanentNode* extra_node = ReloadModelWithExtraNode();
+
+  // "google.com" is a "user" bookmark.
+  model_->AddURL(model_->other_node(), 0, base::ASCIIToUTF16("User"),
+                 GURL("http://google.com"));
+  // "youtube.com" is not.
+  model_->AddURL(extra_node, 0, base::ASCIIToUTF16("Extra"),
+                 GURL("http://youtube.com"));
+
+  EXPECT_TRUE(model_->IsBookmarked(GURL("http://google.com")));
+  EXPECT_TRUE(model_->IsBookmarked(GURL("http://youtube.com")));
+  EXPECT_FALSE(model_->IsBookmarked(GURL("http://reddit.com")));
+
+  EXPECT_TRUE(bookmark_utils::IsBookmarkedByUser(model_.get(),
+                                                 GURL("http://google.com")));
+  EXPECT_FALSE(bookmark_utils::IsBookmarkedByUser(model_.get(),
+                                                  GURL("http://youtube.com")));
+  EXPECT_FALSE(bookmark_utils::IsBookmarkedByUser(model_.get(),
+                                                  GURL("http://reddit.com")));
+}
+
+// Verifies that GetMostRecentlyAddedUserNodeForURL skips bookmarks that
+// are not owned by the user.
+TEST_F(BookmarkModelTest, GetMostRecentlyAddedUserNodeForURLSkipsManagedNodes) {
+  // Reload the model with an extra node that is not editable by the user.
+  BookmarkPermanentNode* extra_node = ReloadModelWithExtraNode();
+
+  const base::string16 title = base::ASCIIToUTF16("Title");
+  const BookmarkNode* user_parent = model_->other_node();
+  const BookmarkNode* managed_parent = extra_node;
+  const GURL url("http://google.com");
+
+  // |url| is not bookmarked yet.
+  EXPECT_TRUE(model_->GetMostRecentlyAddedUserNodeForURL(url) == NULL);
+
+  // Having a managed node doesn't count.
+  model_->AddURL(managed_parent, 0, title, url);
+  EXPECT_TRUE(model_->GetMostRecentlyAddedUserNodeForURL(url) == NULL);
+
+  // Now add a user node.
+  const BookmarkNode* user = model_->AddURL(user_parent, 0, title, url);
+  EXPECT_EQ(user, model_->GetMostRecentlyAddedUserNodeForURL(url));
+
+  // Having a more recent managed node doesn't count either.
+  const BookmarkNode* managed = model_->AddURL(managed_parent, 0, title, url);
+  EXPECT_GT(managed->date_added(), user->date_added());
+  EXPECT_EQ(user, model_->GetMostRecentlyAddedUserNodeForURL(url));
+}
+
 TEST(BookmarkNodeTest, NodeMetaInfo) {
   GURL url;
   BookmarkNode node(url);
   EXPECT_FALSE(node.GetMetaInfoMap());
 
   EXPECT_TRUE(node.SetMetaInfo("key1", "value1"));
   std::string out_value;
   EXPECT_TRUE(node.GetMetaInfo("key1", &out_value));
   EXPECT_EQ("value1", out_value);
   EXPECT_FALSE(node.SetMetaInfo("key1", "value1"));
@@ skipping 13 matching lines @@
   EXPECT_TRUE(node.DeleteMetaInfo("key2.subkey2.leaf"));
   EXPECT_FALSE(node.DeleteMetaInfo("key3"));
   EXPECT_FALSE(node.GetMetaInfo("key1", &out_value));
   EXPECT_FALSE(node.GetMetaInfo("key2.subkey1", &out_value));
   EXPECT_FALSE(node.GetMetaInfo("key2.subkey2", &out_value));
   EXPECT_FALSE(node.GetMetaInfo("key2.subkey2.leaf", &out_value));
   EXPECT_FALSE(node.GetMetaInfoMap());
 }
 
 }  // namespace