bookmarks: Move BookmarkNode into 'bookmarks' namespace.

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 247 matching lines @@
       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;
+    BookmarkPermanentNodeList extra_nodes;
     extra_nodes.push_back(extra_node);
     client_.SetExtraNodesToLoad(extra_nodes.Pass());
 
     model_->RemoveObserver(this);
     model_ = client_.CreateModel();
     model_->AddObserver(this);
     ClearCounts();
 
     if (model_->root_node()->GetIndexOf(extra_node) == -1)
       ADD_FAILURE();
@@ skipping 436 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 =
-      bookmarks::GetMostRecentlyModifiedUserFolders(model_.get(), 1);
+      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 =
-      bookmarks::GetMostRecentlyModifiedUserFolders(model_.get(), 1);
+  most_recent_folders = 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 12 matching lines @@
                                               3,
                                               ASCIIToUTF16("blah"),
                                               GURL("http://foo.com/3")));
   n1->set_date_added(base_time + TimeDelta::FromDays(4));
   n2->set_date_added(base_time + TimeDelta::FromDays(3));
   n3->set_date_added(base_time + TimeDelta::FromDays(2));
   n4->set_date_added(base_time + TimeDelta::FromDays(1));
 
   // Make sure order is honored.
   std::vector<const BookmarkNode*> recently_added;
-  bookmarks::GetMostRecentlyAddedEntries(model_.get(), 2, &recently_added);
+  GetMostRecentlyAddedEntries(model_.get(), 2, &recently_added);
   ASSERT_EQ(2U, recently_added.size());
   ASSERT_TRUE(n1 == recently_added[0]);
   ASSERT_TRUE(n2 == recently_added[1]);
 
   // swap 1 and 2, then check again.
   recently_added.clear();
   SwapDateAdded(n1, n2);
-  bookmarks::GetMostRecentlyAddedEntries(model_.get(), 4, &recently_added);
+  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 GetMostRecentlyAddedUserNodeForURL stays in sync.
 TEST_F(BookmarkModelTest, GetMostRecentlyAddedUserNodeForURL) {
   // Add a couple of nodes such that the following holds for the time of the
@@ skipping 337 matching lines @@
   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(
-      bookmarks::IsBookmarkedByUser(model_.get(), GURL("http://google.com")));
-  EXPECT_FALSE(
-      bookmarks::IsBookmarkedByUser(model_.get(), GURL("http://youtube.com")));
-  EXPECT_FALSE(
-      bookmarks::IsBookmarkedByUser(model_.get(), GURL("http://reddit.com")));
+  EXPECT_TRUE(IsBookmarkedByUser(model_.get(), GURL("http://google.com")));
+  EXPECT_FALSE(IsBookmarkedByUser(model_.get(), GURL("http://youtube.com")));
+  EXPECT_FALSE(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();
@@ skipping 44 matching lines @@
   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
 }  // namespace bookmarks