Move bookmark_utils into bookmarks namespace.

chrome/browser/sync/test/integration/bookmarks_helper.cc

 // Copyright (c) 2012 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 "chrome/browser/sync/test/integration/bookmarks_helper.h"
 
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
@@ skipping 413 matching lines @@
                            const GURL& url) {
   return AddURL(profile, GetBookmarkBarNode(profile), index, title, url);
 }
 
 const BookmarkNode* AddURL(int profile,
                            const BookmarkNode* parent,
                            int index,
                            const std::string& title,
                            const GURL& url) {
   BookmarkModel* model = GetBookmarkModel(profile);
-  if (GetBookmarkNodeByID(model, parent->id()) != parent) {
+  if (bookmarks::GetBookmarkNodeByID(model, parent->id()) != parent) {
     LOG(ERROR) << "Node " << parent->GetTitle() << " does not belong to "
                << "Profile " << profile;
     return NULL;
   }
   const BookmarkNode* result =
       model->AddURL(parent, index, base::UTF8ToUTF16(title), url);
   if (!result) {
     LOG(ERROR) << "Could not add bookmark " << title << " to Profile "
                << profile;
     return NULL;
@@ skipping 21 matching lines @@
                               int index,
                               const std::string& title) {
   return AddFolder(profile, GetBookmarkBarNode(profile), index, title);
 }
 
 const BookmarkNode* AddFolder(int profile,
                               const BookmarkNode* parent,
                               int index,
                               const std::string& title) {
   BookmarkModel* model = GetBookmarkModel(profile);
-  if (GetBookmarkNodeByID(model, parent->id()) != parent) {
+  if (bookmarks::GetBookmarkNodeByID(model, parent->id()) != parent) {
     LOG(ERROR) << "Node " << parent->GetTitle() << " does not belong to "
                << "Profile " << profile;
     return NULL;
   }
   const BookmarkNode* result =
       model->AddFolder(parent, index, base::UTF8ToUTF16(title));
   EXPECT_TRUE(result);
   if (!result) {
     LOG(ERROR) << "Could not add folder " << title << " to Profile "
                << profile;
@@ skipping 10 matching lines @@
     }
     EXPECT_TRUE(NodesMatch(v_node, result));
   }
   return result;
 }
 
 void SetTitle(int profile,
               const BookmarkNode* node,
               const std::string& new_title) {
   BookmarkModel* model = GetBookmarkModel(profile);
-  ASSERT_EQ(GetBookmarkNodeByID(model, node->id()), node)
+  ASSERT_EQ(bookmarks::GetBookmarkNodeByID(model, node->id()), node)
       << "Node " << node->GetTitle() << " does not belong to "
       << "Profile " << profile;
   if (sync_datatype_helper::test()->use_verifier()) {
     const BookmarkNode* v_node = NULL;
     FindNodeInVerifier(model, node, &v_node);
     GetVerifierBookmarkModel()->SetTitle(v_node, base::UTF8ToUTF16(new_title));
   }
   model->SetTitle(node, base::UTF8ToUTF16(new_title));
 }
 
 void SetFavicon(int profile,
                 const BookmarkNode* node,
                 const GURL& icon_url,
                 const gfx::Image& image,
                 FaviconSource favicon_source) {
   BookmarkModel* model = GetBookmarkModel(profile);
-  ASSERT_EQ(GetBookmarkNodeByID(model, node->id()), node)
+  ASSERT_EQ(bookmarks::GetBookmarkNodeByID(model, node->id()), node)
       << "Node " << node->GetTitle() << " does not belong to "
       << "Profile " << profile;
   ASSERT_EQ(BookmarkNode::URL, node->type()) << "Node " << node->GetTitle()
                                              << " must be a url.";
   if (urls_with_favicons_ == NULL)
     urls_with_favicons_ = new std::set<GURL>();
   urls_with_favicons_->insert(node->url());
   if (sync_datatype_helper::test()->use_verifier()) {
     const BookmarkNode* v_node = NULL;
     FindNodeInVerifier(model, node, &v_node);
     SetFaviconImpl(sync_datatype_helper::test()->verifier(),
                    v_node,
                    icon_url,
                    image,
                    favicon_source);
   }
   SetFaviconImpl(sync_datatype_helper::test()->GetProfile(profile),
                  node,
                  icon_url,
                  image,
                  favicon_source);
 }
 
 const BookmarkNode* SetURL(int profile,
                            const BookmarkNode* node,
                            const GURL& new_url) {
   BookmarkModel* model = GetBookmarkModel(profile);
-  if (GetBookmarkNodeByID(model, node->id()) != node) {
+  if (bookmarks::GetBookmarkNodeByID(model, node->id()) != node) {
     LOG(ERROR) << "Node " << node->GetTitle() << " does not belong to "
                << "Profile " << profile;
     return NULL;
   }
   if (sync_datatype_helper::test()->use_verifier()) {
     const BookmarkNode* v_node = NULL;
     FindNodeInVerifier(model, node, &v_node);
     if (v_node->is_url())
       GetVerifierBookmarkModel()->SetURL(v_node, new_url);
   }
   if (node->is_url())
     model->SetURL(node, new_url);
   return node;
 }
 
 void Move(int profile,
           const BookmarkNode* node,
           const BookmarkNode* new_parent,
           int index) {
   BookmarkModel* model = GetBookmarkModel(profile);
-  ASSERT_EQ(GetBookmarkNodeByID(model, node->id()), node)
+  ASSERT_EQ(bookmarks::GetBookmarkNodeByID(model, node->id()), node)
       << "Node " << node->GetTitle() << " does not belong to "
       << "Profile " << profile;
   if (sync_datatype_helper::test()->use_verifier()) {
     const BookmarkNode* v_new_parent = NULL;
     const BookmarkNode* v_node = NULL;
     FindNodeInVerifier(model, new_parent, &v_new_parent);
     FindNodeInVerifier(model, node, &v_node);
     GetVerifierBookmarkModel()->Move(v_node, v_new_parent, index);
   }
   model->Move(node, new_parent, index);
 }
 
 void Remove(int profile, const BookmarkNode* parent, int index) {
   BookmarkModel* model = GetBookmarkModel(profile);
-  ASSERT_EQ(GetBookmarkNodeByID(model, parent->id()), parent)
+  ASSERT_EQ(bookmarks::GetBookmarkNodeByID(model, parent->id()), parent)
       << "Node " << parent->GetTitle() << " does not belong to "
       << "Profile " << profile;
   if (sync_datatype_helper::test()->use_verifier()) {
     const BookmarkNode* v_parent = NULL;
     FindNodeInVerifier(model, parent, &v_parent);
     ASSERT_TRUE(NodesMatch(parent->GetChild(index), v_parent->GetChild(index)));
     GetVerifierBookmarkModel()->Remove(v_parent, index);
   }
   model->Remove(parent, index);
 }
 
 void RemoveAll(int profile) {
   if (sync_datatype_helper::test()->use_verifier()) {
     const BookmarkNode* root_node = GetVerifierBookmarkModel()->root_node();
     for (int i = 0; i < root_node->child_count(); ++i) {
       const BookmarkNode* permanent_node = root_node->GetChild(i);
       for (int j = permanent_node->child_count() - 1; j >= 0; --j) {
         GetVerifierBookmarkModel()->Remove(permanent_node, j);
       }
     }
   }
   GetBookmarkModel(profile)->RemoveAllUserBookmarks();
 }
 
 void SortChildren(int profile, const BookmarkNode* parent) {
   BookmarkModel* model = GetBookmarkModel(profile);
-  ASSERT_EQ(GetBookmarkNodeByID(model, parent->id()), parent)
+  ASSERT_EQ(bookmarks::GetBookmarkNodeByID(model, parent->id()), parent)
       << "Node " << parent->GetTitle() << " does not belong to "
       << "Profile " << profile;
   if (sync_datatype_helper::test()->use_verifier()) {
     const BookmarkNode* v_parent = NULL;
     FindNodeInVerifier(model, parent, &v_parent);
     GetVerifierBookmarkModel()->SortChildren(v_parent);
   }
   model->SortChildren(parent);
 }
 
 void ReverseChildOrder(int profile, const BookmarkNode* parent) {
-  ASSERT_EQ(GetBookmarkNodeByID(GetBookmarkModel(profile), parent->id()),
-            parent)
+  ASSERT_EQ(
+      bookmarks::GetBookmarkNodeByID(GetBookmarkModel(profile), parent->id()),
+      parent)
       << "Node " << parent->GetTitle() << " does not belong to "
       << "Profile " << profile;
   int child_count = parent->child_count();
   if (child_count <= 0)
     return;
   for (int index = 0; index < child_count; ++index) {
     Move(profile, parent->GetChild(index), parent, child_count - index);
   }
 }
 
@@ skipping 173 matching lines @@
 
 std::string IndexedSubfolderName(int i) {
   return base::StringPrintf("Subfolder Name %d", i);
 }
 
 std::string IndexedSubsubfolderName(int i) {
   return base::StringPrintf("Subsubfolder Name %d", i);
 }
 
 }  // namespace bookmarks_helper