Extract GetNodeByID() method from BookmarkModel.

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"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/bookmarks/bookmark_model_observer.h"
+#include "chrome/browser/bookmarks/bookmark_utils.h"
 #include "chrome/browser/favicon/favicon_service_factory.h"
 #include "chrome/browser/favicon/favicon_util.h"
 #include "chrome/browser/history/history_db_task.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/history/history_types.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/glue/bookmark_change_processor.h"
 #include "chrome/browser/sync/test/integration/multi_client_status_change_checker.h"
 #include "chrome/browser/sync/test/integration/profile_sync_service_harness.h"
 #include "chrome/browser/sync/test/integration/sync_datatype_helper.h"
@@ skipping 385 matching lines @@
                            const std::wstring& title,
                            const GURL& url) {
   return AddURL(profile, GetBookmarkBarNode(profile), index, title, url);
 }
 
 const BookmarkNode* AddURL(int profile,
                            const BookmarkNode* parent,
                            int index,
                            const std::wstring& title,
                            const GURL& url) {
-  if (GetBookmarkModel(profile)->GetNodeByID(parent->id()) != parent) {
+  BookmarkModel* model = GetBookmarkModel(profile);
+  if (bookmark_utils::GetNodeByID(model, parent->id()) != parent) {
     LOG(ERROR) << "Node " << parent->GetTitle() << " does not belong to "
                << "Profile " << profile;
     return NULL;
   }
-  const BookmarkNode* result = GetBookmarkModel(profile)->
-      AddURL(parent, index, base::WideToUTF16(title), url);
+  const BookmarkNode* result =
+      model->AddURL(parent, index, base::WideToUTF16(title), url);
   if (!result) {
     LOG(ERROR) << "Could not add bookmark " << title << " to Profile "
                << profile;
     return NULL;
   }
   if (test()->use_verifier()) {
     const BookmarkNode* v_parent = NULL;
-    FindNodeInVerifier(GetBookmarkModel(profile), parent, &v_parent);
-    const BookmarkNode* v_node = GetVerifierBookmarkModel()->
-        AddURL(v_parent, index, base::WideToUTF16(title), url);
+    FindNodeInVerifier(model, parent, &v_parent);
+    const BookmarkNode* v_node = GetVerifierBookmarkModel()->AddURL(
+        v_parent, index, base::WideToUTF16(title), url);
     if (!v_node) {
       LOG(ERROR) << "Could not add bookmark " << title << " to the verifier";
       return NULL;
     }
     EXPECT_TRUE(NodesMatch(v_node, result));
   }
   return result;
 }
 
-const BookmarkNode* AddFolder(int profile,
-                              const std::wstring& title) {
+const BookmarkNode* AddFolder(int profile, const std::wstring& title) {
   return AddFolder(profile, GetBookmarkBarNode(profile), 0, title);
 }
 
 const BookmarkNode* AddFolder(int profile,
                               int index,
                               const std::wstring& title) {
   return AddFolder(profile, GetBookmarkBarNode(profile), index, title);
 }
 
 const BookmarkNode* AddFolder(int profile,
                               const BookmarkNode* parent,
                               int index,
                               const std::wstring& title) {
-  if (GetBookmarkModel(profile)->GetNodeByID(parent->id()) != parent) {
+  BookmarkModel* model = GetBookmarkModel(profile);
+  if (bookmark_utils::GetNodeByID(model, parent->id()) != parent) {
     LOG(ERROR) << "Node " << parent->GetTitle() << " does not belong to "
                << "Profile " << profile;
     return NULL;
   }
-  const BookmarkNode* result = GetBookmarkModel(profile)->AddFolder(
-      parent, index, base::WideToUTF16(title));
+  const BookmarkNode* result =
+      model->AddFolder(parent, index, base::WideToUTF16(title));
   EXPECT_TRUE(result);
   if (!result) {
     LOG(ERROR) << "Could not add folder " << title << " to Profile "
                << profile;
     return NULL;
   }
   if (test()->use_verifier()) {
     const BookmarkNode* v_parent = NULL;
-    FindNodeInVerifier(GetBookmarkModel(profile), parent, &v_parent);
+    FindNodeInVerifier(model, parent, &v_parent);
     const BookmarkNode* v_node = GetVerifierBookmarkModel()->AddFolder(
         v_parent, index, base::WideToUTF16(title));
     if (!v_node) {
       LOG(ERROR) << "Could not add folder " << title << " to the verifier";
       return NULL;
     }
     EXPECT_TRUE(NodesMatch(v_node, result));
   }
   return result;
 }
 
 void SetTitle(int profile,
               const BookmarkNode* node,
               const std::wstring& new_title) {
-  ASSERT_EQ(GetBookmarkModel(profile)->GetNodeByID(node->id()), node)
+  BookmarkModel* model = GetBookmarkModel(profile);
+  ASSERT_EQ(bookmark_utils::GetNodeByID(model, node->id()), node)
       << "Node " << node->GetTitle() << " does not belong to "
       << "Profile " << profile;
   if (test()->use_verifier()) {
     const BookmarkNode* v_node = NULL;
-    FindNodeInVerifier(GetBookmarkModel(profile), node, &v_node);
+    FindNodeInVerifier(model, node, &v_node);
     GetVerifierBookmarkModel()->SetTitle(v_node, base::WideToUTF16(new_title));
   }
-  GetBookmarkModel(profile)->SetTitle(node, base::WideToUTF16(new_title));
+  model->SetTitle(node, base::WideToUTF16(new_title));
 }
 
 void SetFavicon(int profile,
                 const BookmarkNode* node,
                 const GURL& icon_url,
                 const gfx::Image& image,
                 FaviconSource favicon_source) {
-  ASSERT_EQ(GetBookmarkModel(profile)->GetNodeByID(node->id()), node)
+  BookmarkModel* model = GetBookmarkModel(profile);
+  ASSERT_EQ(bookmark_utils::GetNodeByID(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.";
+  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 (test()->use_verifier()) {
     const BookmarkNode* v_node = NULL;
-    FindNodeInVerifier(GetBookmarkModel(profile), node, &v_node);
+    FindNodeInVerifier(model, node, &v_node);
     SetFaviconImpl(test()->verifier(), v_node, icon_url, image, favicon_source);
   }
   SetFaviconImpl(test()->GetProfile(profile), node, icon_url, image,
                  favicon_source);
 }
 
 const BookmarkNode* SetURL(int profile,
                            const BookmarkNode* node,
                            const GURL& new_url) {
-  if (GetBookmarkModel(profile)->GetNodeByID(node->id()) != node) {
+  BookmarkModel* model = GetBookmarkModel(profile);
+  if (bookmark_utils::GetNodeByID(model, node->id()) != node) {
     LOG(ERROR) << "Node " << node->GetTitle() << " does not belong to "
                << "Profile " << profile;
     return NULL;
   }
   if (test()->use_verifier()) {
     const BookmarkNode* v_node = NULL;
-    FindNodeInVerifier(GetBookmarkModel(profile), node, &v_node);
+    FindNodeInVerifier(model, node, &v_node);
     if (v_node->is_url())
       GetVerifierBookmarkModel()->SetURL(v_node, new_url);
   }
   if (node->is_url())
-    GetBookmarkModel(profile)->SetURL(node, new_url);
+    model->SetURL(node, new_url);
   return node;
 }
 
 void Move(int profile,
           const BookmarkNode* node,
           const BookmarkNode* new_parent,
           int index) {
-  ASSERT_EQ(GetBookmarkModel(profile)->GetNodeByID(node->id()), node)
+  BookmarkModel* model = GetBookmarkModel(profile);
+  ASSERT_EQ(bookmark_utils::GetNodeByID(model, node->id()), node)
       << "Node " << node->GetTitle() << " does not belong to "
       << "Profile " << profile;
   if (test()->use_verifier()) {
     const BookmarkNode* v_new_parent = NULL;
     const BookmarkNode* v_node = NULL;
-    FindNodeInVerifier(GetBookmarkModel(profile), new_parent, &v_new_parent);
-    FindNodeInVerifier(GetBookmarkModel(profile), node, &v_node);
+    FindNodeInVerifier(model, new_parent, &v_new_parent);
+    FindNodeInVerifier(model, node, &v_node);
     GetVerifierBookmarkModel()->Move(v_node, v_new_parent, index);
   }
-  GetBookmarkModel(profile)->Move(node, new_parent, index);
+  model->Move(node, new_parent, index);
 }
 
-void Remove(int profile,
-            const BookmarkNode* parent,
-            int index) {
-  ASSERT_EQ(GetBookmarkModel(profile)->GetNodeByID(parent->id()), parent)
+void Remove(int profile, const BookmarkNode* parent, int index) {
+  BookmarkModel* model = GetBookmarkModel(profile);
+  ASSERT_EQ(bookmark_utils::GetNodeByID(model, parent->id()), parent)
       << "Node " << parent->GetTitle() << " does not belong to "
       << "Profile " << profile;
   if (test()->use_verifier()) {
     const BookmarkNode* v_parent = NULL;
-    FindNodeInVerifier(GetBookmarkModel(profile), parent, &v_parent);
+    FindNodeInVerifier(model, parent, &v_parent);
     ASSERT_TRUE(NodesMatch(parent->GetChild(index), v_parent->GetChild(index)));
     GetVerifierBookmarkModel()->Remove(v_parent, index);
   }
-  GetBookmarkModel(profile)->Remove(parent, index);
+  model->Remove(parent, index);
 }
 
 void RemoveAll(int profile) {
   if (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)->RemoveAll();
 }
 
 void SortChildren(int profile, const BookmarkNode* parent) {
-  ASSERT_EQ(GetBookmarkModel(profile)->GetNodeByID(parent->id()), parent)
+  BookmarkModel* model = GetBookmarkModel(profile);
+  ASSERT_EQ(bookmark_utils::GetNodeByID(model, parent->id()), parent)
       << "Node " << parent->GetTitle() << " does not belong to "
       << "Profile " << profile;
   if (test()->use_verifier()) {
     const BookmarkNode* v_parent = NULL;
-    FindNodeInVerifier(GetBookmarkModel(profile), parent, &v_parent);
+    FindNodeInVerifier(model, parent, &v_parent);
     GetVerifierBookmarkModel()->SortChildren(v_parent);
   }
-  GetBookmarkModel(profile)->SortChildren(parent);
+  model->SortChildren(parent);
 }
 
 void ReverseChildOrder(int profile, const BookmarkNode* parent) {
-  ASSERT_EQ(GetBookmarkModel(profile)->GetNodeByID(parent->id()), parent)
+  ASSERT_EQ(
+      bookmark_utils::GetNodeByID(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 177 matching lines @@
 
 std::wstring IndexedSubfolderName(int i) {
   return base::StringPrintf(L"Subfolder Name %d", i);
 }
 
 std::wstring IndexedSubsubfolderName(int i) {
   return base::StringPrintf(L"Subsubfolder Name %d", i);
 }
 
 }  // namespace bookmarks_helper