Introduce BookmarkClient interface to abstract embedder

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 17 matching lines @@
 #include "chrome/browser/sync/test/integration/profile_sync_service_harness.h"
 #include "chrome/browser/sync/test/integration/sync_datatype_helper.h"
 #include "chrome/browser/sync/test/integration/sync_test.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/models/tree_node_iterator.h"
 #include "ui/gfx/image/image_skia.h"
 
-using sync_datatype_helper::test;
-
 namespace {
 
 // History task which runs all pending tasks on the history thread and
 // signals when the tasks have completed.
 class HistoryEmptyTask : public history::HistoryDBTask {
  public:
   explicit HistoryEmptyTask(base::WaitableEvent* done) : done_(done) {}
 
   virtual bool RunOnDBThread(history::HistoryBackend* backend,
                              history::HistoryDatabase* db) OVERRIDE {
@@ skipping 193 matching lines @@
 
 // Wait for all currently scheduled tasks on the history thread for all
 // profiles to complete and any notifications sent to the UI thread to have
 // finished processing.
 void WaitForHistoryToProcessPendingTasks() {
   // Skip waiting for history to complete for tests without favicons.
   if (!urls_with_favicons_)
     return;
 
   std::vector<Profile*> profiles_which_need_to_wait;
-  if (test()->use_verifier())
-    profiles_which_need_to_wait.push_back(test()->verifier());
-  for (int i = 0; i < test()->num_clients(); ++i)
-    profiles_which_need_to_wait.push_back(test()->GetProfile(i));
+  if (sync_datatype_helper::test()->use_verifier())
+    profiles_which_need_to_wait.push_back(
+        sync_datatype_helper::test()->verifier());
+  for (int i = 0; i < sync_datatype_helper::test()->num_clients(); ++i)
+    profiles_which_need_to_wait.push_back(
+        sync_datatype_helper::test()->GetProfile(i));
 
   for (size_t i = 0; i < profiles_which_need_to_wait.size(); ++i) {
     Profile* profile = profiles_which_need_to_wait[i];
     HistoryService* history_service =
         HistoryServiceFactory::GetForProfileWithoutCreating(profile);
     base::WaitableEvent done(false, false);
     CancelableRequestConsumer request_consumer;
     history_service->ScheduleDBTask(new HistoryEmptyTask(&done),
         &request_consumer);
     done.Wait();
@@ skipping 111 matching lines @@
   ASSERT_TRUE(NodesMatch(foreign_node, walker));
   *result = walker;
 }
 
 }  // namespace
 
 
 namespace bookmarks_helper {
 
 BookmarkModel* GetBookmarkModel(int index) {
-  return BookmarkModelFactory::GetForProfile(test()->GetProfile(index));
+  return BookmarkModelFactory::GetForProfile(
+      sync_datatype_helper::test()->GetProfile(index));
 }
 
 const BookmarkNode* GetBookmarkBarNode(int index) {
   return GetBookmarkModel(index)->bookmark_bar_node();
 }
 
 const BookmarkNode* GetOtherNode(int index) {
   return GetBookmarkModel(index)->other_node();
 }
 
 const BookmarkNode* GetSyncedBookmarksNode(int index) {
   return GetBookmarkModel(index)->mobile_node();
 }
 
 BookmarkModel* GetVerifierBookmarkModel() {
-  return BookmarkModelFactory::GetForProfile(test()->verifier());
+  return BookmarkModelFactory::GetForProfile(
+      sync_datatype_helper::test()->verifier());
 }
 
 const BookmarkNode* AddURL(int profile,
                            const std::wstring& title,
                            const GURL& url) {
   return AddURL(profile, GetBookmarkBarNode(profile), 0, title,  url);
 }
 
 const BookmarkNode* AddURL(int profile,
                            int index,
@@ skipping 13 matching lines @@
                << "Profile " << profile;
     return NULL;
   }
   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()) {
+  if (sync_datatype_helper::test()->use_verifier()) {
     const BookmarkNode* v_parent = NULL;
     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));
   }
@@ skipping 22 matching lines @@
     return NULL;
   }
   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()) {
+  if (sync_datatype_helper::test()->use_verifier()) {
     const BookmarkNode* v_parent = NULL;
     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) {
   BookmarkModel* model = GetBookmarkModel(profile);
   ASSERT_EQ(GetBookmarkNodeByID(model, node->id()), node)
       << "Node " << node->GetTitle() << " does not belong to "
       << "Profile " << profile;
-  if (test()->use_verifier()) {
+  if (sync_datatype_helper::test()->use_verifier()) {
     const BookmarkNode* v_node = NULL;
     FindNodeInVerifier(model, node, &v_node);
     GetVerifierBookmarkModel()->SetTitle(v_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) {
   BookmarkModel* model = GetBookmarkModel(profile);
   ASSERT_EQ(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 (test()->use_verifier()) {
+  if (sync_datatype_helper::test()->use_verifier()) {
     const BookmarkNode* v_node = NULL;
     FindNodeInVerifier(model, node, &v_node);
-    SetFaviconImpl(test()->verifier(), v_node, icon_url, image, favicon_source);
+    SetFaviconImpl(sync_datatype_helper::test()->verifier(),
+                   v_node,
+                   icon_url,
+                   image,
+                   favicon_source);
   }
-  SetFaviconImpl(test()->GetProfile(profile), node, icon_url, image,
+  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) {
     LOG(ERROR) << "Node " << node->GetTitle() << " does not belong to "
                << "Profile " << profile;
     return NULL;
   }
-  if (test()->use_verifier()) {
+  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)
       << "Node " << node->GetTitle() << " does not belong to "
       << "Profile " << profile;
-  if (test()->use_verifier()) {
+  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)
       << "Node " << parent->GetTitle() << " does not belong to "
       << "Profile " << profile;
-  if (test()->use_verifier()) {
+  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 (test()->use_verifier()) {
+  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)->RemoveAll();
 }
 
 void SortChildren(int profile, const BookmarkNode* parent) {
   BookmarkModel* model = GetBookmarkModel(profile);
   ASSERT_EQ(GetBookmarkNodeByID(model, parent->id()), parent)
       << "Node " << parent->GetTitle() << " does not belong to "
       << "Profile " << profile;
-  if (test()->use_verifier()) {
+  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)
       << "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);
   }
 }
 
 bool ModelMatchesVerifier(int profile) {
-  if (!test()->use_verifier()) {
+  if (!sync_datatype_helper::test()->use_verifier()) {
     LOG(ERROR) << "Illegal to call ModelMatchesVerifier() after "
                << "DisableVerifier(). Use ModelsMatch() instead.";
     return false;
   }
   return BookmarkModelsMatch(GetVerifierBookmarkModel(),
                              GetBookmarkModel(profile));
 }
 
 bool AllModelsMatchVerifier() {
   // Ensure that all tasks have finished processing on the history thread
   // and that any notifications the history thread may have sent have been
   // processed before comparing models.
   WaitForHistoryToProcessPendingTasks();
 
-  for (int i = 0; i < test()->num_clients(); ++i) {
+  for (int i = 0; i < sync_datatype_helper::test()->num_clients(); ++i) {
     if (!ModelMatchesVerifier(i)) {
       LOG(ERROR) << "Model " << i << " does not match the verifier.";
       return false;
     }
   }
   return true;
 }
 
 bool ModelsMatch(int profile_a, int profile_b) {
   return BookmarkModelsMatch(GetBookmarkModel(profile_a),
                              GetBookmarkModel(profile_b));
 }
 
 bool AllModelsMatch() {
   // Ensure that all tasks have finished processing on the history thread
   // and that any notifications the history thread may have sent have been
   // processed before comparing models.
   WaitForHistoryToProcessPendingTasks();
 
-  for (int i = 1; i < test()->num_clients(); ++i) {
+  for (int i = 1; i < sync_datatype_helper::test()->num_clients(); ++i) {
     if (!ModelsMatch(0, i)) {
       LOG(ERROR) << "Model " << i << " does not match Model 0.";
       return false;
     }
   }
   return true;
 }
 
 namespace {
 
@@ skipping 130 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