Refactoring the sync integration tests.

The sync integration tests were written over a 2 year period, and were designed at a time when bookmarks were the only data-type being synced. Since then, they have mushroomed and resulted in significant duplication of code and non-uniformity in coding style.

This changelist is the first step towards reorganizing the integration tests for all sync data types into a levelized class hierarchy, where there is a class containing all the data and functionality required to test each data-type. This should make adding tests for new data-types significantly easier.

BUG=46052,43917
TEST=sync_integration_tests

Review URL: http://codereview.chromium.org/2863008

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@50376 0039d316-1c4b-4281-b951-d872f2087c98

12 files changed, 1766 insertions, 2153 deletions

diff --git a/chrome/test/live_sync/bookmark_model_verifier.cc b/chrome/test/live_sync/bookmark_model_verifier.cc
index f7a943b..365f55b4 100644
--- a/chrome/test/live_sync/bookmark_model_verifier.cc
+++ b/chrome/test/live_sync/bookmark_model_verifier.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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.
 
@@ -11,7 +11,7 @@
 #include "base/rand_util.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
-#include "chrome/test/live_sync/live_sync_test.h"
+#include "chrome/test/live_sync/live_bookmarks_sync_test.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
@@ -28,20 +28,17 @@ void BookmarkModelVerifier::ExpectBookmarkInfoMatch(
             actual->GetParent()->IndexOfChild(actual));
 }
 
-BookmarkModelVerifier::BookmarkModelVerifier() {
-  verifier_profile_.reset(LiveSyncTest::MakeProfile(
-      FILE_PATH_LITERAL("verifier")));
-  verifier_ = verifier_profile_->GetBookmarkModel();
-}
+BookmarkModelVerifier::BookmarkModelVerifier(BookmarkModel* model)
+    : model_(model) {}
 
-BookmarkModelVerifier* BookmarkModelVerifier::Create() {
-  BookmarkModelVerifier* v = new BookmarkModelVerifier();
-  LiveSyncTest::BlockUntilLoaded(v->verifier_);
+BookmarkModelVerifier* BookmarkModelVerifier::Create(BookmarkModel* model) {
+  BookmarkModelVerifier* v = new BookmarkModelVerifier(model);
+  ui_test_utils::WaitForBookmarkModelToLoad(v->model_);
   return v;
 }
 
 void BookmarkModelVerifier::ExpectMatch(BookmarkModel* actual) {
-  ExpectModelsMatch(verifier_, actual);
+  ExpectModelsMatch(model_, actual);
 }
 
 // static
@@ -115,7 +112,7 @@ void BookmarkModelVerifier::FindNodeInVerifier(BookmarkModel* foreign_model,
   }
 
   // Swing over to the other tree.
-  walker = verifier_->root_node();
+  walker = model_->root_node();
 
   // Climb down.
   while (!path.empty()) {
@@ -137,7 +134,7 @@ const BookmarkNode* BookmarkModelVerifier::AddGroup(BookmarkModel* model,
   EXPECT_TRUE(result);
   if (!result)
     return NULL;
-  const BookmarkNode* v_node = verifier_->AddGroup(v_parent, index, title);
+  const BookmarkNode* v_node = model_->AddGroup(v_parent, index, title);
   EXPECT_TRUE(v_node);
   if (!v_node)
     return NULL;
@@ -187,7 +184,7 @@ const BookmarkNode* BookmarkModelVerifier::AddURL(BookmarkModel* model,
   EXPECT_TRUE(result);
   if (!result)
     return NULL;
-  const BookmarkNode* v_node = verifier_->AddURL(v_parent, index, title, url);
+  const BookmarkNode* v_node = model_->AddURL(v_parent, index, title, url);
   EXPECT_TRUE(v_node);
   if (!v_node)
     return NULL;
@@ -201,7 +198,7 @@ void BookmarkModelVerifier::SetTitle(BookmarkModel* model,
   const BookmarkNode* v_node = NULL;
   FindNodeInVerifier(model, node, &v_node);
   model->SetTitle(node, title);
-  verifier_->SetTitle(v_node, title);
+  model_->SetTitle(v_node, title);
 }
 
 void BookmarkModelVerifier::Move(BookmarkModel* model, const BookmarkNode* node,
@@ -211,7 +208,7 @@ void BookmarkModelVerifier::Move(BookmarkModel* model, const BookmarkNode* node,
   FindNodeInVerifier(model, new_parent, &v_new_parent);
   FindNodeInVerifier(model, node, &v_node);
   model->Move(node, new_parent, index);
-  verifier_->Move(v_node, v_new_parent, index);
+  model_->Move(v_node, v_new_parent, index);
 }
 
 void BookmarkModelVerifier::Remove(BookmarkModel* model,
@@ -221,7 +218,7 @@ void BookmarkModelVerifier::Remove(BookmarkModel* model,
   FindNodeInVerifier(model, parent, &v_parent);
   ExpectBookmarkInfoMatch(parent->GetChild(index), v_parent->GetChild(index));
   model->Remove(parent, index);
-  verifier_->Remove(v_parent, index);
+  model_->Remove(v_parent, index);
 }
 
 void BookmarkModelVerifier::SortChildren(BookmarkModel* model,
@@ -229,7 +226,7 @@ void BookmarkModelVerifier::SortChildren(BookmarkModel* model,
   const BookmarkNode* v_parent = NULL;
   FindNodeInVerifier(model, parent, &v_parent);
   model->SortChildren(parent);
-  verifier_->SortChildren(v_parent);
+  model_->SortChildren(v_parent);
 }
 
 void BookmarkModelVerifier::ReverseChildOrder(BookmarkModel* model,
@@ -249,7 +246,7 @@ const BookmarkNode* BookmarkModelVerifier::SetURL(BookmarkModel* model,
   const BookmarkNode* result = bookmark_utils::ApplyEditsWithNoGroupChange(
       model, node->GetParent(), BookmarkEditor::EditDetails(node),
       node->GetTitle(), new_url);
-  bookmark_utils::ApplyEditsWithNoGroupChange(verifier_, v_node->GetParent(),
+  bookmark_utils::ApplyEditsWithNoGroupChange(model_, v_node->GetParent(),
       BookmarkEditor::EditDetails(v_node), v_node->GetTitle(), new_url);
   return result;
 }
diff --git a/chrome/test/live_sync/bookmark_model_verifier.h b/chrome/test/live_sync/bookmark_model_verifier.h
index 7498d01..5baa242 100644
--- a/chrome/test/live_sync/bookmark_model_verifier.h
+++ b/chrome/test/live_sync/bookmark_model_verifier.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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.
 
@@ -15,25 +15,25 @@ class BookmarkNode;
 // A tool to perform bookmark model operations on a model and have
 // the changes echoed in a "verifier" model that can be used as an expected
 // hierarchy to compare against.
-// Note when we refer to the "same" nodes in |model| and |verifier| parameters,
-// we mean same the canonical bookmark entity, because |verifier| is expected
+// Note when we refer to the "same" nodes in |model| and |model_| parameters,
+// we mean same the canonical bookmark entity, because |model_| is expected
 // to be a replica of |model|.
 class BookmarkModelVerifier {
  public:
-  ~BookmarkModelVerifier() { }
+  ~BookmarkModelVerifier() {}
 
-  // Creates a BookmarkModelVerifier and waits until the model has loaded.
-  // Caller takes ownership.
-  static BookmarkModelVerifier* Create();
+  // Creates a BookmarkModelVerifier using a BookmarkModel and waits until the
+  // model has loaded. Caller takes ownership.
+  static BookmarkModelVerifier* Create(BookmarkModel* model);
 
-  // Adds the same folder to |model| and |verifier|.
+  // Adds the same folder to |model| and |model_|.
   // See BookmarkModel::AddGroup for details.
   const BookmarkNode* AddGroup(BookmarkModel* model,
                                const BookmarkNode* parent,
                                int index,
                                const std::wstring& title);
 
-  // Adds the same non-empty folder to |model| and |verifier|.
+  // Adds the same non-empty folder to |model| and |model_|.
   // It also adds specified number of childern (mix of bm and folder).
   const BookmarkNode* AddNonEmptyGroup(BookmarkModel* model,
                                const BookmarkNode* parent,
@@ -41,7 +41,7 @@ class BookmarkModelVerifier {
                                const std::wstring& title,
                                int children_count);
 
-  // Adds the same bookmark to |model| and |verifier|.
+  // Adds the same bookmark to |model| and |model_|.
   // See BookmarkModel::AddURL for details.
   const BookmarkNode* AddURL(BookmarkModel* model,
                              const BookmarkNode* parent,
@@ -49,28 +49,28 @@ class BookmarkModelVerifier {
                              const std::wstring& title,
                              const GURL& url);
 
-  // Sets the title of the same node in |model| and |verifier|.
+  // Sets the title of the same node in |model| and |model_|.
   // See BookmarkModel::SetTitle for details.
   void SetTitle(BookmarkModel* model, const BookmarkNode* node,
                 const std::wstring& title);
 
-  // Moves the same node to the same position in both |model| and |verifier|.
+  // Moves the same node to the same position in both |model| and |model_|.
   // See BookmarkModel::Move for details.
   void Move(BookmarkModel* model,
             const BookmarkNode* node,
             const BookmarkNode* new_parent,
             int index);
 
-  // Removes the same node in |model| and |verifier|.
+  // Removes the same node in |model| and |model_|.
   // See BookmarkModel::Remove for details.
   void Remove(BookmarkModel* model, const BookmarkNode* parent, int index);
 
-  // Sorts children of the same parent node in |model| and |verifier|.
+  // Sorts children of the same parent node in |model| and |model_|.
   // See BookmarkModel::SortChildren for details.
   void SortChildren(BookmarkModel* model, const BookmarkNode* parent);
 
   // Reverses the order of children of the same parent node in |model|
-  // and |verifier|.
+  // and |model_|.
   void ReverseChildOrder(BookmarkModel* model, const BookmarkNode* parent);
 
   const BookmarkNode* SetURL(BookmarkModel* model,
@@ -94,7 +94,7 @@ class BookmarkModelVerifier {
   static void VerifyNoDuplicates(BookmarkModel* model);
 
  private:
-  BookmarkModelVerifier();
+  explicit BookmarkModelVerifier(BookmarkModel* model);
   void FindNodeInVerifier(BookmarkModel* foreign_model,
                           const BookmarkNode* foreign_node,
                           const BookmarkNode** result);
@@ -104,8 +104,10 @@ class BookmarkModelVerifier {
   static void ExpectBookmarkInfoMatch(const BookmarkNode* expected,
                                       const BookmarkNode* actual);
 
-  scoped_ptr<Profile> verifier_profile_;
-  BookmarkModel* verifier_;
+  // A pointer to the BookmarkModel object within the verifier_profile_ object
+  // in class LiveSyncTest. All verifications are done against this object.
+  BookmarkModel* model_;
+
   DISALLOW_COPY_AND_ASSIGN(BookmarkModelVerifier);
 };
 
diff --git a/chrome/test/live_sync/live_autofill_sync_test.h b/chrome/test/live_sync/live_autofill_sync_test.h
new file mode 100755
index 0000000..8bfba22
--- /dev/null
+++ b/chrome/test/live_sync/live_autofill_sync_test.h
@@ -0,0 +1,293 @@
+// Copyright (c) 2010 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.
+
+#ifndef CHROME_TEST_LIVE_SYNC_LIVE_AUTOFILL_SYNC_TEST_H_
+#define CHROME_TEST_LIVE_SYNC_LIVE_AUTOFILL_SYNC_TEST_H_
+
+#include <map>
+#include <set>
+#include <vector>
+
+#include "chrome/browser/autofill/autofill_common_unittest.h"
+#include "chrome/browser/autofill/autofill_profile.h"
+#include "chrome/browser/autofill/autofill_type.h"
+#include "chrome/browser/autofill/field_types.h"
+#include "chrome/browser/autofill/personal_data_manager.h"
+#include "chrome/browser/browser.h"
+#include "chrome/browser/pref_service.h"
+#include "chrome/browser/profile.h"
+#include "chrome/browser/sync/profile_sync_service.h"
+#include "chrome/browser/sync/profile_sync_test_util.h"
+#include "chrome/browser/webdata/autofill_entry.h"
+#include "chrome/common/chrome_switches.h"
+#include "chrome/test/live_sync/live_sync_test.h"
+#include "chrome/test/thread_observer_helper.h"
+
+using base::WaitableEvent;
+using testing::_;
+
+namespace {
+// Define these << operators so we can use EXPECT_EQ with the
+// AutofillKeys type.
+template<class T1, class T2, class T3>
+std::ostream& operator<<(std::ostream& os, const std::set<T1, T2, T3>& seq) {
+  typedef typename std::set<T1, T2, T3>::const_iterator SetConstIterator;
+  for (SetConstIterator i = seq.begin(); i != seq.end(); ++i) {
+    os << *i << ", ";
+  }
+  return os;
+}
+
+std::ostream& operator<<(std::ostream& os, const AutofillKey& key) {
+  return os << UTF16ToUTF8(key.name()) << ", " << UTF16ToUTF8(key.value());
+}
+
+class GetAllAutofillEntries
+    : public base::RefCountedThreadSafe<GetAllAutofillEntries> {
+ public:
+  explicit GetAllAutofillEntries(WebDataService* web_data_service)
+      : web_data_service_(web_data_service),
+        done_event_(false, false) {}
+
+  void Init() {
+    DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+    ChromeThread::PostTask(
+        ChromeThread::DB,
+        FROM_HERE,
+        NewRunnableMethod(this, &GetAllAutofillEntries::Run));
+    done_event_.Wait();
+  }
+
+  const std::vector<AutofillEntry>& entries() const {
+    return entries_;
+  }
+
+ private:
+  friend class base::RefCountedThreadSafe<GetAllAutofillEntries>;
+
+  void Run() {
+    DCHECK(ChromeThread::CurrentlyOn(ChromeThread::DB));
+    web_data_service_->GetDatabase()->GetAllAutofillEntries(&entries_);
+    done_event_.Signal();
+  }
+
+  WebDataService* web_data_service_;
+  base::WaitableEvent done_event_;
+  std::vector<AutofillEntry> entries_;
+};
+
+ACTION_P(SignalEvent, event) {
+  event->Signal();
+}
+
+class AutofillDBThreadObserverHelper : public DBThreadObserverHelper {
+ protected:
+  virtual void RegisterObservers() {
+    registrar_.Add(&observer_,
+                   NotificationType::AUTOFILL_ENTRIES_CHANGED,
+                   NotificationService::AllSources());
+    registrar_.Add(&observer_,
+                   NotificationType::AUTOFILL_PROFILE_CHANGED,
+                   NotificationService::AllSources());
+  }
+};
+
+enum ProfileType {
+  MARION,
+  HOMER
+};
+
+void FillProfile(ProfileType type, AutoFillProfile* profile) {
+  switch (type) {
+    case MARION:
+      autofill_unittest::SetProfileInfo(profile,
+        "Billing", "Marion", "Mitchell", "Morrison",
+        "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA",
+        "91601", "US", "12345678910", "01987654321");
+      break;
+    case HOMER:
+      autofill_unittest::SetProfileInfo(profile,
+        "Shipping", "Homer", "J.", "Simpson",
+        "homer@snpp.com", "SNPP", "1 Main St", "PO Box 1", "Springfield", "MA",
+        "94101", "US", "14155551212", "14155551313");
+      break;
+  }
+}
+
+class MockPersonalDataManagerObserver : public PersonalDataManager::Observer {
+ public:
+  MOCK_METHOD0(OnPersonalDataLoaded, void());
+};
+
+}  // namespace
+
+class LiveAutofillSyncTest : public LiveSyncTest {
+ public:
+  typedef std::set<AutofillKey> AutofillKeys;
+  typedef std::vector<AutoFillProfile*> AutoFillProfiles;
+
+  explicit LiveAutofillSyncTest(TestType test_type)
+      : LiveSyncTest(test_type) {}
+  virtual ~LiveAutofillSyncTest() {}
+
+  // Used to access the web data service within a particular sync profile.
+  WebDataService* GetWebDataService(int index) {
+    return GetProfile(index)->GetWebDataService(Profile::EXPLICIT_ACCESS);
+  }
+
+  // Used to access the personal data manager within a particular sync profile.
+  PersonalDataManager* GetPersonalDataManager(int index) {
+    return GetProfile(index)->GetPersonalDataManager();
+  }
+
+ protected:
+  virtual void SetUpCommandLine(CommandLine* command_line) {
+    command_line->AppendSwitch(switches::kEnableSyncAutofill);
+  }
+
+  void AddFormFieldsToWebData(WebDataService* wds, const AutofillKeys& keys) {
+    std::vector<webkit_glue::FormField> form_fields;
+    for (AutofillKeys::const_iterator i = keys.begin(); i != keys.end(); ++i) {
+      form_fields.push_back(
+          webkit_glue::FormField(string16(),
+                                 (*i).name(),
+                                 (*i).value(),
+                                 string16(),
+                                 0));
+    }
+
+    WaitableEvent done_event(false, false);
+    scoped_refptr<AutofillDBThreadObserverHelper> observer_helper(
+        new AutofillDBThreadObserverHelper());
+    observer_helper->Init();
+
+    EXPECT_CALL(*observer_helper->observer(), Observe(_, _, _)).
+        WillOnce(SignalEvent(&done_event));
+    wds->AddFormFields(form_fields);
+    done_event.Wait();
+  }
+
+  void RemoveKeyFromWebData(WebDataService* wds, const AutofillKey& key) {
+    WaitableEvent done_event(false, false);
+    scoped_refptr<AutofillDBThreadObserverHelper> observer_helper(
+        new AutofillDBThreadObserverHelper());
+    observer_helper->Init();
+
+    EXPECT_CALL(*observer_helper->observer(), Observe(_, _, _)).
+        WillOnce(SignalEvent(&done_event));
+    wds->RemoveFormValueForElementName(key.name(), key.value());
+    done_event.Wait();
+  }
+
+  void SetProfiles(PersonalDataManager* pdm,
+                   std::vector<AutoFillProfile>* profiles) {
+    MockPersonalDataManagerObserver observer;
+    EXPECT_CALL(observer, OnPersonalDataLoaded()).
+        WillOnce(QuitUIMessageLoop());
+    pdm->SetObserver(&observer);
+    pdm->SetProfiles(profiles);
+    MessageLoop::current()->Run();
+    pdm->RemoveObserver(&observer);
+  }
+
+  void AddProfile(PersonalDataManager* pdm, const AutoFillProfile& profile) {
+    const AutoFillProfiles& all_profiles = GetAllAutoFillProfiles(pdm);
+    std::vector<AutoFillProfile> profiles;
+    for (size_t i = 0; i < all_profiles.size(); ++i)
+      profiles.push_back(*all_profiles[i]);
+    profiles.push_back(profile);
+    SetProfiles(pdm, &profiles);
+  }
+
+  void RemoveProfile(PersonalDataManager* pdm, const string16& label) {
+    const AutoFillProfiles& all_profiles = GetAllAutoFillProfiles(pdm);
+    std::vector<AutoFillProfile> profiles;
+    for (size_t i = 0; i < all_profiles.size(); ++i) {
+      if (all_profiles[i]->Label() != label)
+        profiles.push_back(*all_profiles[i]);
+    }
+    SetProfiles(pdm, &profiles);
+  }
+
+  void UpdateProfile(PersonalDataManager* pdm,
+                     const string16& label,
+                     const AutoFillType& type,
+                     const string16& value) {
+    const AutoFillProfiles& all_profiles = GetAllAutoFillProfiles(pdm);
+    std::vector<AutoFillProfile> profiles;
+    for (size_t i = 0; i < all_profiles.size(); ++i) {
+      profiles.push_back(*all_profiles[i]);
+      if (all_profiles[i]->Label() == label)
+        profiles.back().SetInfo(type, value);
+    }
+    SetProfiles(pdm, &profiles);
+  }
+
+  void GetAllAutofillKeys(WebDataService* wds, AutofillKeys* keys) {
+    scoped_refptr<GetAllAutofillEntries> get_all_entries =
+        new GetAllAutofillEntries(wds);
+    get_all_entries->Init();
+    const std::vector<AutofillEntry>& entries = get_all_entries->entries();
+
+    for (size_t i = 0; i < entries.size(); ++i) {
+      keys->insert(entries[i].key());
+    }
+  }
+
+  const AutoFillProfiles& GetAllAutoFillProfiles(PersonalDataManager* pdm) {
+    MockPersonalDataManagerObserver observer;
+    EXPECT_CALL(observer, OnPersonalDataLoaded()).
+        WillOnce(QuitUIMessageLoop());
+    pdm->SetObserver(&observer);
+    pdm->Refresh();
+    MessageLoop::current()->Run();
+    pdm->RemoveObserver(&observer);
+    return pdm->profiles();
+  }
+
+  bool CompareAutoFillProfiles(const AutoFillProfiles& expected_profiles,
+                               const AutoFillProfiles& profiles) {
+    std::map<string16, AutoFillProfile> expected_profiles_map;
+    for (size_t i = 0; i < expected_profiles.size(); ++i) {
+      const AutoFillProfile* p = expected_profiles[i];
+      expected_profiles_map[p->Label()] = *p;
+    }
+
+    for (size_t i = 0; i < profiles.size(); ++i) {
+      const AutoFillProfile* p = profiles[i];
+      if (!expected_profiles_map.count(p->Label())) {
+        LOG(INFO) << "Label " << p->Label() << " not in expected";
+        return false;
+      }
+      AutoFillProfile* expected_profile = &expected_profiles_map[p->Label()];
+      expected_profile->set_unique_id(p->unique_id());
+      if (*expected_profile != *p) {
+        LOG(INFO) << "Profile mismatch";
+        return false;
+      }
+      expected_profiles_map.erase(p->Label());
+    }
+
+    if (expected_profiles_map.size()) {
+      LOG(INFO) << "Labels in expected but not supplied";
+      return false;
+    }
+
+    return true;
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(LiveAutofillSyncTest);
+};
+
+class TwoClientLiveAutofillSyncTest : public LiveAutofillSyncTest {
+ public:
+  TwoClientLiveAutofillSyncTest() : LiveAutofillSyncTest(TWO_CLIENT) {}
+  ~TwoClientLiveAutofillSyncTest() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TwoClientLiveAutofillSyncTest);
+};
+
+#endif  // CHROME_TEST_LIVE_SYNC_LIVE_AUTOFILL_SYNC_TEST_H_
diff --git a/chrome/test/live_sync/live_bookmarks_sync_test.h b/chrome/test/live_sync/live_bookmarks_sync_test.h
new file mode 100755
index 0000000..650bd2f
--- /dev/null
+++ b/chrome/test/live_sync/live_bookmarks_sync_test.h
@@ -0,0 +1,111 @@
+// Copyright (c) 2010 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.
+
+#ifndef CHROME_TEST_LIVE_SYNC_LIVE_BOOKMARKS_SYNC_TEST_H_
+#define CHROME_TEST_LIVE_SYNC_LIVE_BOOKMARKS_SYNC_TEST_H_
+
+#include <vector>
+
+#include "chrome/browser/browser.h"
+#include "chrome/browser/profile.h"
+#include "chrome/browser/sync/profile_sync_service.h"
+#include "chrome/test/bookmark_load_observer.h"
+#include "chrome/test/live_sync/bookmark_model_verifier.h"
+#include "chrome/test/live_sync/live_sync_test.h"
+#include "chrome/test/ui_test_utils.h"
+#include "googleurl/src/gurl.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+class LiveBookmarksSyncTest : public LiveSyncTest {
+ public:
+  explicit LiveBookmarksSyncTest(TestType test_type)
+      : LiveSyncTest(test_type) {}
+  virtual ~LiveBookmarksSyncTest() {}
+
+  // Sets up sync profiles and clients and initializes the verifier bookmark
+  // model.
+  virtual bool SetupClients() {
+    if (!LiveSyncTest::SetupClients())
+      return false;
+    verifier_helper_.reset(BookmarkModelVerifier::Create(
+        GetVerifierBookmarkModel()));
+    return (verifier_helper_.get() != NULL);
+  }
+
+  // Sets up sync profiles and clients, syncs each of them, and initializes the
+  // verifier bookmark model.
+  virtual bool SetupSync() {
+    if (!LiveSyncTest::SetupSync())
+      return false;
+    verifier_helper_.reset(BookmarkModelVerifier::Create(
+        GetVerifierBookmarkModel()));
+    return (verifier_helper_.get() != NULL);
+  }
+
+  // Used to access the bookmarks within a particular sync profile.
+  BookmarkModel* GetBookmarkModel(int index) {
+    return GetProfile(index)->GetBookmarkModel();
+  }
+
+  // Used to access the bookmark bar within a particular sync profile.
+  const BookmarkNode* GetBookmarkBarNode(int index) {
+    return GetBookmarkModel(index)->GetBookmarkBarNode();
+  }
+
+  // Used to access the bookmarks within the verifier sync profile.
+  BookmarkModel* GetVerifierBookmarkModel() {
+    return verifier()->GetBookmarkModel();
+  }
+
+  // Used to access the service object within a particular sync client.
+  ProfileSyncService* GetService(int index) {
+    return GetClient(index)->service();
+  }
+
+  // Used to access the BookmarkModelVerifier helper object.
+  BookmarkModelVerifier* verifier_helper() {
+    return verifier_helper_.get();
+  }
+
+
+  // Helper to get a handle on a bookmark in |m| when the url is known to be
+  // unique.
+  static const BookmarkNode* GetByUniqueURL(BookmarkModel* m, const GURL& url) {
+    std::vector<const BookmarkNode*> nodes;
+    m->GetNodesByURL(url, &nodes);
+    EXPECT_EQ(1U, nodes.size());
+    if (nodes.empty())
+      return NULL;
+    return nodes[0];
+  }
+
+ private:
+  // Helper object that has the functionality to verify changes made to the
+  // bookmarks of individual profiles.
+  scoped_ptr<BookmarkModelVerifier> verifier_helper_;
+
+  DISALLOW_COPY_AND_ASSIGN(LiveBookmarksSyncTest);
+};
+
+class SingleClientLiveBookmarksSyncTest : public LiveBookmarksSyncTest {
+ public:
+  SingleClientLiveBookmarksSyncTest()
+      : LiveBookmarksSyncTest(SINGLE_CLIENT) {}
+  ~SingleClientLiveBookmarksSyncTest() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SingleClientLiveBookmarksSyncTest);
+};
+
+class TwoClientLiveBookmarksSyncTest : public LiveBookmarksSyncTest {
+ public:
+  TwoClientLiveBookmarksSyncTest()
+      : LiveBookmarksSyncTest(TWO_CLIENT) {}
+  ~TwoClientLiveBookmarksSyncTest() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TwoClientLiveBookmarksSyncTest);
+};
+
+#endif  // CHROME_TEST_LIVE_SYNC_LIVE_BOOKMARKS_SYNC_TEST_H_
diff --git a/chrome/test/live_sync/live_preferences_sync_test.h b/chrome/test/live_sync/live_preferences_sync_test.h
new file mode 100755
index 0000000..5ff8cf0
--- /dev/null
+++ b/chrome/test/live_sync/live_preferences_sync_test.h
@@ -0,0 +1,52 @@
+// Copyright (c) 2010 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.
+
+#ifndef CHROME_TEST_LIVE_SYNC_LIVE_PREFERENCES_SYNC_TEST_H_
+#define CHROME_TEST_LIVE_SYNC_LIVE_PREFERENCES_SYNC_TEST_H_
+
+#include "chrome/browser/pref_service.h"
+#include "chrome/browser/profile.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/test/live_sync/live_sync_test.h"
+
+class LivePreferencesSyncTest : public LiveSyncTest {
+ public:
+  explicit LivePreferencesSyncTest(TestType test_type)
+      : LiveSyncTest(test_type) {}
+  virtual ~LivePreferencesSyncTest() {}
+
+  // Used to access the preferences within a particular sync profile.
+  PrefService* GetPrefs(int index) {
+    return GetProfile(index)->GetPrefs();
+  }
+
+  // Used to access the preferences within the verifier sync profile.
+  PrefService* GetVerifierPrefs() {
+    return verifier()->GetPrefs();
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(LivePreferencesSyncTest);
+};
+
+class SingleClientLivePreferencesSyncTest : public LivePreferencesSyncTest {
+ public:
+  SingleClientLivePreferencesSyncTest()
+      : LivePreferencesSyncTest(SINGLE_CLIENT) {}
+  virtual ~SingleClientLivePreferencesSyncTest() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SingleClientLivePreferencesSyncTest);
+};
+
+class TwoClientLivePreferencesSyncTest : public LivePreferencesSyncTest {
+ public:
+  TwoClientLivePreferencesSyncTest() : LivePreferencesSyncTest(TWO_CLIENT) {}
+  virtual ~TwoClientLivePreferencesSyncTest() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TwoClientLivePreferencesSyncTest);
+};
+
+#endif  // CHROME_TEST_LIVE_SYNC_LIVE_PREFERENCES_SYNC_TEST_H_
diff --git a/chrome/test/live_sync/live_sync_test.cc b/chrome/test/live_sync/live_sync_test.cc
index 7cf2e94..997a9b1 100644
--- a/chrome/test/live_sync/live_sync_test.cc
+++ b/chrome/test/live_sync/live_sync_test.cc
@@ -4,89 +4,120 @@
 
 #include "chrome/test/live_sync/live_sync_test.h"
 
-#include <vector>
-
-#include "base/command_line.h"
-#include "base/file_util.h"
-#include "base/path_service.h"
-#include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/profile_manager.h"
-#include "chrome/test/ui_test_utils.h"
-#include "net/base/mock_host_resolver.h"
+#include "chrome/common/chrome_paths.h"
+#include "chrome/common/chrome_switches.h"
 
 namespace switches {
 const wchar_t kSyncUserForTest[] = L"sync-user-for-test";
 const wchar_t kSyncPasswordForTest[] = L"sync-password-for-test";
 }
 
-// BookmarkLoadObserver is used when blocking until the BookmarkModel
-// finishes loading. As soon as the BookmarkModel finishes loading the message
-// loop is quit.
-class BookmarkLoadObserver : public BookmarkModelObserver {
- public:
-  BookmarkLoadObserver() {}
-  virtual void Loaded(BookmarkModel* model) {
-    MessageLoop::current()->Quit();
-  }
+void LiveSyncTest::SetUp() {
+  // At this point, the browser hasn't been launched, and no services are
+  // available.  But we can verify our command line parameters and fail
+  // early.
+  const CommandLine* cl = CommandLine::ForCurrentProcess();
+  username_ = WideToUTF8(cl->GetSwitchValue(switches::kSyncUserForTest));
+  password_ = WideToUTF8(cl->GetSwitchValue(switches::kSyncPasswordForTest));
+  ASSERT_FALSE(username_.empty()) << "Can't run live server test "
+      << "without specifying --" << switches::kSyncUserForTest;
+  ASSERT_FALSE(password_.empty()) << "Can't run live server test "
+      << "without specifying --" << switches::kSyncPasswordForTest;
 
-  virtual void BookmarkNodeMoved(BookmarkModel* model,
-                                 const BookmarkNode* old_parent,
-                                 int old_index,
-                                 const BookmarkNode* new_parent,
-                                 int new_index) {}
-  virtual void BookmarkNodeAdded(BookmarkModel* model,
-                                 const BookmarkNode* parent,
-                                 int index) {}
-  virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   const BookmarkNode* parent,
-                                   int old_index,
-                                   const BookmarkNode* node) {}
-  virtual void BookmarkNodeChanged(BookmarkModel* model,
-                                   const BookmarkNode* node) {}
-  virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                             const BookmarkNode* node) {}
-  virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         const BookmarkNode* node) {}
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(BookmarkLoadObserver);
-};
-
-LiveSyncTest::LiveSyncTest() : started_local_test_server_(false) {
-}
+  // Unless a sync server was explicitly provided, run a test one locally.
+  // TODO(ncarter): It might be better to allow the user to specify a choice
+  // of sync server "providers" -- a script that could locate (or allocate)
+  // a sync server instance, possibly on some remote host.  The provider
+  // would be invoked before each test.
+  if (!cl->HasSwitch(switches::kSyncServiceURL))
+    SetUpLocalTestServer();
 
-LiveSyncTest::~LiveSyncTest() {
+  // Yield control back to the InProcessBrowserTest framework.
+  InProcessBrowserTest::SetUp();
 }
 
-// static
-void LiveSyncTest::BlockUntilLoaded(BookmarkModel* m) {
-  if (m->IsLoaded())
-    return;
-  BookmarkLoadObserver observer;
-  m->AddObserver(&observer);
-  ui_test_utils::RunMessageLoop();
-  m->RemoveObserver(&observer);
-  ASSERT_TRUE(m->IsLoaded());
-}
+void LiveSyncTest::TearDown() {
+  // Allow the InProcessBrowserTest framework to perform its tear down.
+  InProcessBrowserTest::TearDown();
 
-// static
-const BookmarkNode* LiveSyncTest::GetByUniqueURL(BookmarkModel* m,
-                                                 const GURL& url) {
-  std::vector<const BookmarkNode*> nodes;
-  m->GetNodesByURL(url, &nodes);
-  EXPECT_EQ(1U, nodes.size());
-  return nodes[0];
+  // Stop the local test sync server if one was used.
+  if (started_local_test_server_)
+    TearDownLocalTestServer();
 }
 
 // static
-Profile* LiveSyncTest::MakeProfile(const FilePath::CharType* name) {
+Profile* LiveSyncTest::MakeProfile(
+    const FilePath::StringType name) {
   FilePath path;
   PathService::Get(chrome::DIR_USER_DATA, &path);
-
   return ProfileManager::CreateProfile(path.Append(name));
 }
 
+Profile* LiveSyncTest::GetProfile(int index) {
+  EXPECT_FALSE(profiles_.empty()) << "SetupSync() has not yet been called.";
+  EXPECT_TRUE((index >= 0) && (index < static_cast<int>(profiles_.size())))
+      << "GetProfile(): Index is out of bounds.";
+  return profiles_[index];
+}
+
+ProfileSyncServiceTestHarness* LiveSyncTest::GetClient(int index) {
+  EXPECT_FALSE(clients_.empty()) << "SetupClients() has not yet been called.";
+  EXPECT_TRUE((index >= 0) && (index < static_cast<int>(clients_.size())))
+      << "GetClient(): Index is out of bounds.";
+  return clients_[index];
+}
+
+Profile* LiveSyncTest::verifier() {
+  EXPECT_TRUE(verifier_.get() != NULL)
+      << "SetupClients() has not yet been called.";
+  return verifier_.get();
+}
+
+bool LiveSyncTest::SetupClients() {
+  EXPECT_GT(num_clients_, 0) << "num_clients_ incorrectly initialized.";
+  EXPECT_TRUE(profiles_.empty()) << "SetupClients() has already been called.";
+  EXPECT_TRUE(clients_.empty()) << "SetupClients() has already been called.";
+
+  // Create the required number of sync profiles and clients.
+  for (int i = 0; i < num_clients_; ++i) {
+    profiles_.push_back(MakeProfile(
+        StringPrintf(FILE_PATH_LITERAL("Profile%d"), i)));
+    if (GetProfile(i) == NULL)
+      return false;
+    clients_.push_back(new ProfileSyncServiceTestHarness(
+        GetProfile(i), username_, password_));
+    if (GetClient(i) == NULL)
+      return false;
+  }
+
+  // Create the verifier profile.
+  verifier_.reset(MakeProfile(FILE_PATH_LITERAL("Verifier")));
+  return (verifier_.get() != NULL);
+}
+
+bool LiveSyncTest::SetupSync() {
+  // Create sync profiles and clients if they haven't already been created.
+  if (profiles_.empty()) {
+    if (!SetupClients())
+      return false;
+  }
+
+  // Sync each of the profiles.
+  for (int i = 0; i < num_clients_; ++i) {
+    if (!GetClient(i)->SetupSync())
+      return false;
+  }
+  return true;
+}
+
+void LiveSyncTest::CleanUpOnMainThread() {
+  profiles_.reset();
+  clients_.reset();
+  verifier_.reset(NULL);
+}
+
 void LiveSyncTest::SetUpInProcessBrowserTestFixture() {
   // We don't take a reference to |resolver|, but mock_host_resolver_override_
   // does, so effectively assumes ownership.
@@ -105,3 +136,22 @@ void LiveSyncTest::SetUpInProcessBrowserTestFixture() {
 void LiveSyncTest::TearDownInProcessBrowserTestFixture() {
   mock_host_resolver_override_.reset();
 }
+
+void LiveSyncTest::SetUpLocalTestServer() {
+  bool success = server_.Start(net::TestServerLauncher::ProtoHTTP,
+      server_.kHostName, server_.kOKHTTPSPort,
+      FilePath(), FilePath(), std::wstring());
+  ASSERT_TRUE(success);
+
+  started_local_test_server_ = true;
+
+  CommandLine* cl = CommandLine::ForCurrentProcess();
+  cl->AppendSwitchWithValue(switches::kSyncServiceURL,
+      StringPrintf("http://%s:%d/chromiumsync", server_.kHostName,
+          server_.kOKHTTPSPort));
+}
+
+void LiveSyncTest::TearDownLocalTestServer() {
+  bool success = server_.Stop();
+  ASSERT_TRUE(success);
+}
diff --git a/chrome/test/live_sync/live_sync_test.h b/chrome/test/live_sync/live_sync_test.h
index a9366eb..7564c28 100755
--- a/chrome/test/live_sync/live_sync_test.h
+++ b/chrome/test/live_sync/live_sync_test.h
@@ -5,18 +5,16 @@
 #ifndef CHROME_TEST_LIVE_SYNC_LIVE_SYNC_TEST_H_
 #define CHROME_TEST_LIVE_SYNC_LIVE_SYNC_TEST_H_
 
-#include <string>
-
-#include "base/command_line.h"
-#include "chrome/common/chrome_paths.h"
-#include "chrome/common/chrome_switches.h"
 #include "chrome/test/in_process_browser_test.h"
-#include "googleurl/src/gurl.h"
+
+#include "base/scoped_vector.h"
+#include "chrome/test/live_sync/profile_sync_service_test_harness.h"
+#include "net/base/mock_host_resolver.h"
 #include "net/socket/ssl_test_util.h"
 
-class BookmarkModel;
-class BookmarkNode;
 class Profile;
+class CommandLine;
+
 namespace net {
 class ScopedDefaultHostResolverProc;
 }
@@ -26,98 +24,146 @@ extern const wchar_t kSyncUserForTest[];
 extern const wchar_t kSyncPasswordForTest[];
 }
 
-// TODO(timsteele): This should be moved out of personalization_unit_tests into
-// its own project that doesn't get run by default on the standard buildbot
-// without a valid sync server set up.
+// This is the base class for integration tests for all sync data types. Derived
+// classes must be defined for each sync data type. Individual tests are defined
+// using the IN_PROC_BROWSER_TEST_F macro.
 class LiveSyncTest : public InProcessBrowserTest {
  public:
-  LiveSyncTest();
-  ~LiveSyncTest();
-
-  virtual void SetUp() {
-    // At this point, the browser hasn't been launched, and no services are
-    // available.  But we can verify our command line parameters and fail
-    // early.
-    const CommandLine* cl = CommandLine::ForCurrentProcess();
-    username_ = WideToUTF8(cl->GetSwitchValue(switches::kSyncUserForTest));
-    password_ = WideToUTF8(cl->GetSwitchValue(switches::kSyncPasswordForTest));
-    ASSERT_FALSE(username_.empty()) << "Can't run live server test "
-        << "without specifying --" << switches::kSyncUserForTest;
-    ASSERT_FALSE(password_.empty()) << "Can't run live server test "
-        << "without specifying --" << switches::kSyncPasswordForTest;
-
-    // Unless a sync server was explicitly provided, run a test one locally.
-    // TODO(ncarter): It might be better to allow the user to specify a choice
-    // of sync server "providers" -- a script that could locate (or allocate)
-    // a sync server instance, possibly on some remote host.  The provider
-    // would be invoked before each test.
-    if (!cl->HasSwitch(switches::kSyncServiceURL))
-      SetUpLocalTestServer();
-
-    // Yield control back to the InProcessBrowserTest framework.
-    InProcessBrowserTest::SetUp();
+  // The different types of live sync tests that can be implemented.
+  enum TestType {
+    // Tests where only one client profile is synced with the server. Typically
+    // sanity level tests.
+    SINGLE_CLIENT,
+
+    // Tests where two client profiles are synced with the server. Typically
+    // functionality level tests.
+    TWO_CLIENT,
+
+    // Tests where three client profiles are synced with the server. Typically,
+    // these tests create client side races and verify that sync works.
+    MULTIPLE_CLIENT,
+
+    // Tests where several client profiles are synced with the server. Only used
+    // by stress tests.
+    MANY_CLIENT
+  };
+
+  // A LiveSyncTest must be associated with a particular test type.
+  explicit LiveSyncTest(TestType test_type)
+      : test_type_(test_type),
+        num_clients_(-1),
+        started_local_test_server_(false) {
+    InProcessBrowserTest::set_show_window(true);
+    switch (test_type_) {
+      case SINGLE_CLIENT: {
+        num_clients_ = 1;
+        break;
+      }
+      case TWO_CLIENT: {
+        num_clients_ = 2;
+        break;
+      }
+      case MULTIPLE_CLIENT: {
+        num_clients_ = 3;
+        break;
+      }
+      case MANY_CLIENT: {
+        num_clients_ = 10;
+        break;
+      }
+    }
   }
 
-  virtual void TearDown() {
-    // Allow the InProcessBrowserTest framework to perform its tear down.
-    InProcessBrowserTest::TearDown();
+  virtual ~LiveSyncTest() {}
 
-    // Stop the local test sync server if one was used.
-    if (started_local_test_server_)
-      TearDownLocalTestServer();
-  }
+  // Validates command line parameters and creates a local python test server if
+  // specified.
+  virtual void SetUp();
 
-  virtual void SetUpLocalTestServer() {
-    bool success = server_.Start(net::TestServerLauncher::ProtoHTTP,
-        server_.kHostName, server_.kOKHTTPSPort,
-        FilePath(), FilePath(), std::wstring());
-    ASSERT_TRUE(success);
+  // Brings down local python test server if one was created.
+  virtual void TearDown();
 
-    started_local_test_server_ = true;
+  // Append command line flag to enable sync.
+  virtual void SetUpCommandLine(CommandLine* command_line) {}
 
-    CommandLine* cl = CommandLine::ForCurrentProcess();
-    cl->AppendSwitchWithValue(switches::kSyncServiceURL,
-        StringPrintf("http://%s:%d/chromiumsync", server_.kHostName,
-            server_.kOKHTTPSPort));
-  }
+  // Helper to ProfileManager::CreateProfile that handles path creation.
+  static Profile* MakeProfile(const FilePath::StringType name);
 
-  virtual void TearDownLocalTestServer() {
-    bool success = server_.Stop();
-    ASSERT_TRUE(success);
-  }
+  // Used to access a particular sync profile.
+  Profile* GetProfile(int index);
 
-  // Append command line flag to enable sync.
-  virtual void SetUpCommandLine(CommandLine* command_line) {
-  }
+  // Used to access a particular sync client.
+  ProfileSyncServiceTestHarness* GetClient(int index);
 
-  // Helper to get a handle on a bookmark in |m| when the url is known to be
-  // unique.
-  static const BookmarkNode* GetByUniqueURL(BookmarkModel* m, const GURL& url);
+  // Used to verify changes to individual sync profiles.
+  Profile* verifier();
 
-  // Helper to ProfileManager::CreateProfile that handles path creation.
-  static Profile* MakeProfile(const FilePath::CharType* name);
+  // Initializes sync clients and profiles but does not sync any of them.
+  virtual bool SetupClients();
 
-  // Utility to block (by running the current MessageLoop) until the model has
-  // loaded.  Note this is required instead of using m->BlockTillLoaded, as that
-  // cannot be called from the main thread (deadlock will occur).
-  static void BlockUntilLoaded(BookmarkModel* m);
+  // Initializes sync clients and profiles if required and syncs each of them.
+  virtual bool SetupSync();
 
  protected:
-  std::string username_;
-  std::string password_;
+  // InProcessBrowserTest override. Destroys all the sync clients and sync
+  // profiles created by a test.
+  virtual void CleanUpOnMainThread();
 
+  // InProcessBrowserTest override. Changes behavior of the default host
+  // resolver to avoid DNS lookup errors.
   virtual void SetUpInProcessBrowserTestFixture();
+
+  // InProcessBrowserTest override. Resets the host resolver its default
+  // behavior.
   virtual void TearDownInProcessBrowserTestFixture();
 
- private:
-  // LiveBookmarksSyncTests need to make live DNS requests for access to
-  // GAIA and sync server URLs under google.com.  We use a scoped version
-  // to override the default resolver while the test is active.
-  scoped_ptr<net::ScopedDefaultHostResolverProc> mock_host_resolver_override_;
+  // GAIA account used by the test case.
+  std::string username_;
+
+  // GAIA password used by the test case.
+  std::string password_;
+
+private:
+  // Helper method used to create a local python test server.
+  virtual void SetUpLocalTestServer();
+
+  // Helper method used to destroy the local python test server if one was
+  // created.
+  virtual void TearDownLocalTestServer();
+
+  // Used to differentiate between single-client, two-client, multi-client and
+  // many-client tests.
+  TestType test_type_;
+
+  // Number of sync clients that will be created by a test.
+  int num_clients_;
 
+  // Collection of sync profiles used by a test. A sync profile maintains sync
+  // data contained within its own subdirectory under the chrome user data
+  // directory.
+  ScopedVector<Profile> profiles_;
+
+  // Collection of sync clients used by a test. A sync client is associated with
+  // a sync profile, and implements methods that sync the contents of the
+  // profile with the server.
+  ScopedVector<ProfileSyncServiceTestHarness> clients_;
+
+  // Sync profile against which changes to individual profiles are verified. We
+  // don't need a corresponding verifier sync client because the contents of the
+  // verifier profile are strictly local, and are not meant to be synced.
+  scoped_ptr<Profile> verifier_;
+
+  // Local instance of python sync server.
   net::TestServerLauncher server_;
+
+  // Keeps track of whether a local python sync server was used for a test.
   bool started_local_test_server_;
 
+  // Sync integration tests need to make live DNS requests for access to
+  // GAIA and sync server URLs under google.com. We use a scoped version
+  // to override the default resolver while the test is active.
+  scoped_ptr<net::ScopedDefaultHostResolverProc> mock_host_resolver_override_;
+
   DISALLOW_COPY_AND_ASSIGN(LiveSyncTest);
 };
 
diff --git a/chrome/test/live_sync/single_client_live_bookmarks_sync_test.cc b/chrome/test/live_sync/single_client_live_bookmarks_sync_test.cc
index d578ea7..c4cc585 100644
--- a/chrome/test/live_sync/single_client_live_bookmarks_sync_test.cc
+++ b/chrome/test/live_sync/single_client_live_bookmarks_sync_test.cc
@@ -1,40 +1,13 @@
-// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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 "base/command_line.h"
-#include "chrome/browser/bookmarks/bookmark_model.h"
-#include "chrome/browser/browser.h"
-#include "chrome/browser/profile.h"
-#include "chrome/browser/sync/profile_sync_service.h"
-#include "chrome/test/live_sync/bookmark_model_verifier.h"
-#include "chrome/test/live_sync/profile_sync_service_test_harness.h"
-#include "chrome/test/live_sync/live_sync_test.h"
-
-class SingleClientLiveBookmarksSyncTest : public LiveSyncTest {
- public:
-  SingleClientLiveBookmarksSyncTest() { }
-  ~SingleClientLiveBookmarksSyncTest() { }
-
-  bool SetupSync() {
-    client_.reset(new ProfileSyncServiceTestHarness(
-        browser()->profile(), username_, password_));
-    return client_->SetupSync();
-  }
-
-  ProfileSyncServiceTestHarness* client() { return client_.get(); }
-  ProfileSyncService* service() { return client_->service(); }
-
- private:
-  scoped_ptr<ProfileSyncServiceTestHarness> client_;
-
-  DISALLOW_COPY_AND_ASSIGN(SingleClientLiveBookmarksSyncTest);
-};
+#include "chrome/test/live_sync/live_bookmarks_sync_test.h"
 
 IN_PROC_BROWSER_TEST_F(SingleClientLiveBookmarksSyncTest, Sanity) {
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* m = browser()->profile()->GetBookmarkModel();
-  BlockUntilLoaded(m);
+  ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
+  BookmarkModel* bm = GetBookmarkModel(0);
+  BookmarkModelVerifier* v = verifier_helper();
 
   // Starting state:
   // other_node
@@ -45,25 +18,22 @@ IN_PROC_BROWSER_TEST_F(SingleClientLiveBookmarksSyncTest, Sanity) {
   //        -> http://www.facebook.com "tier1_a_url2"
   //      -> tier1_b
   //        -> http://www.nhl.com "tier1_b_url0"
-  const BookmarkNode* top = verifier->AddGroup(m, m->other_node(), 0, L"top");
-  const BookmarkNode* tier1_a = verifier->AddGroup(m, top, 0, L"tier1_a");
-  const BookmarkNode* tier1_b = verifier->AddGroup(m, top, 1, L"tier1_b");
-  const BookmarkNode* t1au0 = verifier->AddURL(m, tier1_a, 0, L"tier1_a_url0",
-                                               GURL("http://mail.google.com"));
-  const BookmarkNode* t1au1 = verifier->AddURL(m, tier1_a, 1, L"tier1_a_url1",
-                                               GURL("http://www.pandora.com"));
-  const BookmarkNode* t1au2 = verifier->AddURL(
-      m, tier1_a, 2, L"tier1_a_url2", GURL("http://www.facebook.com"));
-  const BookmarkNode* t1bu0 = verifier->AddURL(m, tier1_b, 0, L"tier1_b_url0",
-                                               GURL("http://www.nhl.com"));
+  const BookmarkNode* top = v->AddGroup(bm, bm->other_node(), 0, L"top");
+  const BookmarkNode* tier1_a = v->AddGroup(bm, top, 0, L"tier1_a");
+  const BookmarkNode* tier1_b = v->AddGroup(bm, top, 1, L"tier1_b");
+  const BookmarkNode* t1au0 = v->AddURL(bm, tier1_a, 0, L"tier1_a_url0",
+      GURL("http://mail.google.com"));
+  const BookmarkNode* t1au1 = v->AddURL(bm, tier1_a, 1, L"tier1_a_url1",
+      GURL("http://www.pandora.com"));
+  const BookmarkNode* t1au2 = v->AddURL(
+      bm, tier1_a, 2, L"tier1_a_url2", GURL("http://www.facebook.com"));
+  const BookmarkNode* t1bu0 = v->AddURL(bm, tier1_b, 0, L"tier1_b_url0",
+      GURL("http://www.nhl.com"));
 
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  // SetupSync returns after init, which means got_zero_updates, which means
-  // before we merge and associate, so we now have to wait for our above state
-  // to round-trip.
-  ASSERT_TRUE(client()->AwaitSyncCycleCompletion(
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  ASSERT_TRUE(GetClient(0)->AwaitSyncCycleCompletion(
       "Waiting for initial sync completed."));
-  verifier->ExpectMatch(m);
+  v->ExpectMatch(bm);
 
   //  Ultimately we want to end up with the following model; but this test is
   //  more about the journey than the destination.
@@ -86,59 +56,60 @@ IN_PROC_BROWSER_TEST_F(SingleClientLiveBookmarksSyncTest, Sanity) {
   //            -> Toronto Maple Leafs (mapleleafs.nhl.com)
   //            -> Wynn (www.wynnlasvegas.com)
   //      -> tier1_a_url0
-  const BookmarkNode* bar = m->GetBookmarkBarNode();
+  const BookmarkNode* bar = GetBookmarkBarNode(0);
   const BookmarkNode* cnn =
-      verifier->AddURL(m, bar, 0, L"CNN", GURL("http://www.cnn.com"));
+      v->AddURL(bm, bar, 0, L"CNN", GURL("http://www.cnn.com"));
   ASSERT_TRUE(cnn != NULL);
-  verifier->Move(m, tier1_a, bar, 1);  // 1 should be the end at this point.
-  ASSERT_TRUE(client()->AwaitSyncCycleCompletion("Bookmark moved."));
-  verifier->ExpectMatch(m);
+  v->Move(bm, tier1_a, bar, 1);  // 1 should be the end at this point.
+  ASSERT_TRUE(GetClient(0)->AwaitSyncCycleCompletion("Bookmark moved."));
+  v->ExpectMatch(bm);
 
-  const BookmarkNode* porsche = verifier->AddURL(
-      m, bar, 2, L"Porsche", GURL("http://www.porsche.com"));
+  const BookmarkNode* porsche = v->AddURL(
+      bm, bar, 2, L"Porsche", GURL("http://www.porsche.com"));
   // Rearrange stuff in tier1_a.
   EXPECT_EQ(tier1_a, t1au2->GetParent());
   EXPECT_EQ(tier1_a, t1au1->GetParent());
-  verifier->Move(m, t1au2, tier1_a, 0);
-  verifier->Move(m, t1au1, tier1_a, 2);
-  ASSERT_TRUE(client()->AwaitSyncCycleCompletion("Rearrange stuff in tier1_a"));
-  verifier->ExpectMatch(m);
+  v->Move(bm, t1au2, tier1_a, 0);
+  v->Move(bm, t1au1, tier1_a, 2);
+  ASSERT_TRUE(GetClient(0)->AwaitSyncCycleCompletion(
+      "Rearrange stuff in tier1_a"));
+  v->ExpectMatch(bm);
 
   EXPECT_EQ(1, t1au0->GetParent()->IndexOfChild(t1au0));
-  verifier->Move(m, t1au0, bar, bar->GetChildCount());
-  const BookmarkNode* boa = verifier->AddURL(m, bar, bar->GetChildCount(),
+  v->Move(bm, t1au0, bar, bar->GetChildCount());
+  const BookmarkNode* boa = v->AddURL(bm, bar, bar->GetChildCount(),
       L"Bank of America", GURL("https://www.bankofamerica.com"));
   ASSERT_TRUE(boa != NULL);
-  verifier->Move(m, t1au0, top, top->GetChildCount());
-  const BookmarkNode* bubble = verifier->AddURL(m, bar, bar->GetChildCount(),
+  v->Move(bm, t1au0, top, top->GetChildCount());
+  const BookmarkNode* bubble = v->AddURL(bm, bar, bar->GetChildCount(),
       L"Seattle Bubble", GURL("http://seattlebubble.com"));
   ASSERT_TRUE(bubble != NULL);
-  const BookmarkNode* wired = verifier->AddURL(m, bar, 2, L"Wired News",
+  const BookmarkNode* wired = v->AddURL(bm, bar, 2, L"Wired News",
                                          GURL("http://www.wired.com"));
-  const BookmarkNode* tier2_b = verifier->AddGroup(m, tier1_b, 0, L"tier2_b");
-  verifier->Move(m, t1bu0, tier2_b, 0);
-  verifier->Move(m, porsche, bar, 0);
-  verifier->SetTitle(m, wired, L"News Wired");
-  verifier->SetTitle(m, porsche, L"ICanHazPorsche?");
-  ASSERT_TRUE(client()->AwaitSyncCycleCompletion("Change title."));
-  verifier->ExpectMatch(m);
+  const BookmarkNode* tier2_b = v->AddGroup(bm, tier1_b, 0, L"tier2_b");
+  v->Move(bm, t1bu0, tier2_b, 0);
+  v->Move(bm, porsche, bar, 0);
+  v->SetTitle(bm, wired, L"News Wired");
+  v->SetTitle(bm, porsche, L"ICanHazPorsche?");
+  ASSERT_TRUE(GetClient(0)->AwaitSyncCycleCompletion("Change title."));
+  v->ExpectMatch(bm);
 
   EXPECT_EQ(t1au0->id(), top->GetChild(top->GetChildCount() - 1)->id());
-  verifier->Remove(m, top, top->GetChildCount() - 1);
-  verifier->Move(m, wired, tier1_b, 0);
-  verifier->Move(m, porsche, bar, 3);
-  const BookmarkNode* tier3_b = verifier->AddGroup(m, tier2_b, 1, L"tier3_b");
-  const BookmarkNode* leafs = verifier->AddURL(
-      m, tier1_a, 0, L"Toronto Maple Leafs",
+  v->Remove(bm, top, top->GetChildCount() - 1);
+  v->Move(bm, wired, tier1_b, 0);
+  v->Move(bm, porsche, bar, 3);
+  const BookmarkNode* tier3_b = v->AddGroup(bm, tier2_b, 1, L"tier3_b");
+  const BookmarkNode* leafs = v->AddURL(
+      bm, tier1_a, 0, L"Toronto Maple Leafs",
       GURL("http://mapleleafs.nhl.com"));
-  const BookmarkNode* wynn = verifier->AddURL(
-      m, bar, 1, L"Wynn", GURL("http://www.wynnlasvegas.com"));
+  const BookmarkNode* wynn = v->AddURL(
+      bm, bar, 1, L"Wynn", GURL("http://www.wynnlasvegas.com"));
 
-  verifier->Move(m, wynn, tier3_b, 0);
-  verifier->Move(m, leafs, tier3_b, 0);
-  ASSERT_TRUE(client()->AwaitSyncCycleCompletion(
+  v->Move(bm, wynn, tier3_b, 0);
+  v->Move(bm, leafs, tier3_b, 0);
+  ASSERT_TRUE(GetClient(0)->AwaitSyncCycleCompletion(
       "Move after addition of bookmarks."));
-  verifier->ExpectMatch(m);
+  v->ExpectMatch(bm);
 }
 
 // Connects a client with no bookmarks to a cloud account. As a natural
@@ -146,10 +117,10 @@ IN_PROC_BROWSER_TEST_F(SingleClientLiveBookmarksSyncTest, Sanity) {
 // 'Bookmarks' file.  This is mostly useful to verify server state.
 // DISABLED because it should be; we use this as a utility more than a test.
 IN_PROC_BROWSER_TEST_F(SingleClientLiveBookmarksSyncTest, DISABLED_GetUpdates) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  BlockUntilLoaded(browser()->profile()->GetBookmarkModel());
-  EXPECT_TRUE(client()->ServiceIsPushingChanges());
-  ProfileSyncService::Status status(service()->QueryDetailedSyncStatus());
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+
+  EXPECT_TRUE(GetClient(0)->ServiceIsPushingChanges());
+  ProfileSyncService::Status status(GetService(0)->QueryDetailedSyncStatus());
   EXPECT_EQ(status.summary, ProfileSyncService::Status::READY);
   EXPECT_EQ(status.unsynced_count, 0);
 }
diff --git a/chrome/test/live_sync/single_client_live_preferences_sync_test.cc b/chrome/test/live_sync/single_client_live_preferences_sync_test.cc
index 6c3c181..5756d53 100644
--- a/chrome/test/live_sync/single_client_live_preferences_sync_test.cc
+++ b/chrome/test/live_sync/single_client_live_preferences_sync_test.cc
@@ -2,53 +2,18 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "base/command_line.h"
-#include "chrome/browser/browser.h"
-#include "chrome/browser/pref_service.h"
-#include "chrome/browser/profile.h"
-#include "chrome/browser/sync/profile_sync_service.h"
-#include "chrome/common/pref_names.h"
-#include "chrome/test/live_sync/profile_sync_service_test_harness.h"
-#include "chrome/test/live_sync/live_sync_test.h"
-
-class SingleClientLivePreferencesSyncTest : public LiveSyncTest {
- public:
-  SingleClientLivePreferencesSyncTest() {
-    // This makes sure browser is visible and active while running test.
-    InProcessBrowserTest::set_show_window(true);
-    // Set the initial timeout value to 5 min.
-    InProcessBrowserTest::SetInitialTimeoutInMS(300000);
-  }
-  ~SingleClientLivePreferencesSyncTest() {}
-
-  void SetupSync() {
-    client_.reset(new ProfileSyncServiceTestHarness(
-        browser()->profile(), username_, password_));
-    EXPECT_TRUE(client_->SetupSync());
-    EXPECT_TRUE(client()->AwaitSyncCycleCompletion("Initial setup"));
-  }
-
-  ProfileSyncServiceTestHarness* client() { return client_.get(); }
-  ProfileSyncService* service() { return client_->service(); }
-
-  PrefService* prefs() { return browser()->profile()->GetPrefs(); }
-
- private:
-  scoped_ptr<ProfileSyncServiceTestHarness> client_;
-
-  DISALLOW_COPY_AND_ASSIGN(SingleClientLivePreferencesSyncTest);
-};
+#include "chrome/test/live_sync/live_preferences_sync_test.h"
 
 IN_PROC_BROWSER_TEST_F(SingleClientLivePreferencesSyncTest, Sanity) {
-  SetupSync();
-
-  PrefService* expected = LiveSyncTest::MakeProfile(
-      FILE_PATH_LITERAL("verifier"))->GetPrefs();
-  expected->SetBoolean(prefs::kHomePageIsNewTabPage, true);
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 
-  prefs()->SetBoolean(prefs::kHomePageIsNewTabPage, true);
-  ASSERT_TRUE(client()->AwaitSyncCycleCompletion("Pref updated"));
+  bool new_value = !GetVerifierPrefs()->GetBoolean(
+      prefs::kHomePageIsNewTabPage);
+  GetVerifierPrefs()->SetBoolean(prefs::kHomePageIsNewTabPage, new_value);
+  GetPrefs(0)->SetBoolean(prefs::kHomePageIsNewTabPage, new_value);
+  EXPECT_TRUE(GetClient(0)->AwaitSyncCycleCompletion(
+      "Waiting for prefs change."));
 
-  ASSERT_EQ(expected->GetBoolean(prefs::kHomePageIsNewTabPage),
-            prefs()->GetBoolean(prefs::kHomePageIsNewTabPage));
+  EXPECT_EQ(GetVerifierPrefs()->GetBoolean(prefs::kHomePageIsNewTabPage),
+      GetPrefs(0)->GetBoolean(prefs::kHomePageIsNewTabPage));
 }
diff --git a/chrome/test/live_sync/two_client_live_autofill_sync_test.cc b/chrome/test/live_sync/two_client_live_autofill_sync_test.cc
index 764c671..8f344a6 100644
--- a/chrome/test/live_sync/two_client_live_autofill_sync_test.cc
+++ b/chrome/test/live_sync/two_client_live_autofill_sync_test.cc
@@ -2,499 +2,157 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <set>
-#include <vector>
-
-#include "base/command_line.h"
-#include "base/ref_counted.h"
-#include "base/stl_util-inl.h"
-#include "base/string16.h"
-#include "base/string_util.h"
-#include "base/utf_string_conversions.h"
-#include "base/waitable_event.h"
-#include "chrome/browser/autofill/autofill_common_unittest.h"
-#include "chrome/browser/autofill/autofill_profile.h"
-#include "chrome/browser/autofill/autofill_type.h"
-#include "chrome/browser/autofill/field_types.h"
-#include "chrome/browser/autofill/personal_data_manager.h"
-#include "chrome/browser/browser.h"
-#include "chrome/browser/pref_service.h"
-#include "chrome/browser/profile.h"
-#include "chrome/browser/sync/profile_sync_service.h"
-#include "chrome/browser/sync/profile_sync_test_util.h"
-#include "chrome/browser/webdata/autofill_entry.h"
-#include "chrome/browser/webdata/web_database.h"
-#include "chrome/browser/webdata/web_data_service.h"
-#include "chrome/browser/webdata/web_data_service_test_util.h"
-#include "chrome/common/chrome_switches.h"
-#include "chrome/common/notification_observer_mock.h"
-#include "chrome/common/notification_service.h"
-#include "chrome/common/notification_type.h"
-#include "chrome/common/pref_names.h"
-#include "chrome/test/live_sync/profile_sync_service_test_harness.h"
-#include "chrome/test/live_sync/live_sync_test.h"
-#include "chrome/test/thread_observer_helper.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "webkit/glue/form_field.h"
-
-using base::WaitableEvent;
-using testing::_;
-
-namespace {
-
-// Define these << operators so we can use EXPECT_EQ with the
-// AutofillKeys type.
-template<class T1, class T2, class T3>
-std::ostream& operator<<(std::ostream& os, const std::set<T1, T2, T3>& seq) {
-  typedef typename std::set<T1, T2, T3>::const_iterator SetConstIterator;
-  for (SetConstIterator i = seq.begin(); i != seq.end(); ++i) {
-    os << *i << ", ";
-  }
-  return os;
-}
-
-std::ostream& operator<<(std::ostream& os, const AutofillKey& key) {
-  return os << UTF16ToUTF8(key.name()) << ", " << UTF16ToUTF8(key.value());
-}
-
-class GetAllAutofillEntries
-    : public base::RefCountedThreadSafe<GetAllAutofillEntries> {
- public:
-  explicit GetAllAutofillEntries(WebDataService* web_data_service)
-      : web_data_service_(web_data_service),
-        done_event_(false, false) {}
-
-  void Init() {
-    DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
-    ChromeThread::PostTask(
-        ChromeThread::DB,
-        FROM_HERE,
-        NewRunnableMethod(this, &GetAllAutofillEntries::Run));
-    done_event_.Wait();
-  }
-
-  const std::vector<AutofillEntry>& entries() const {
-    return entries_;
-  }
-
- private:
-  friend class base::RefCountedThreadSafe<GetAllAutofillEntries>;
-
-  void Run() {
-    DCHECK(ChromeThread::CurrentlyOn(ChromeThread::DB));
-    web_data_service_->GetDatabase()->GetAllAutofillEntries(&entries_);
-    done_event_.Signal();
-  }
-
-  WebDataService* web_data_service_;
-  base::WaitableEvent done_event_;
-  std::vector<AutofillEntry> entries_;
-};
-
-ACTION_P(SignalEvent, event) {
-  event->Signal();
-}
-
-class AutofillDBThreadObserverHelper : public DBThreadObserverHelper {
- protected:
-  virtual void RegisterObservers() {
-    registrar_.Add(&observer_,
-                   NotificationType::AUTOFILL_ENTRIES_CHANGED,
-                   NotificationService::AllSources());
-    registrar_.Add(&observer_,
-                   NotificationType::AUTOFILL_PROFILE_CHANGED,
-                   NotificationService::AllSources());
-  }
-};
-
-enum ProfileType {
-  MARION,
-  HOMER
-};
-
-void FillProfile(ProfileType type, AutoFillProfile* profile) {
-  switch (type) {
-    case MARION:
-      autofill_unittest::SetProfileInfo(profile,
-        "Billing", "Marion", "Mitchell", "Morrison",
-        "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA",
-        "91601", "US", "12345678910", "01987654321");
-      break;
-    case HOMER:
-      autofill_unittest::SetProfileInfo(profile,
-        "Shipping", "Homer", "J.", "Simpson",
-        "homer@snpp.com", "SNPP", "1 Main St", "PO Box 1", "Springfield", "MA",
-        "94101", "US", "14155551212", "14155551313");
-      break;
-  }
-}
-
-class MockPersonalDataManagerObserver : public PersonalDataManager::Observer {
- public:
-  MOCK_METHOD0(OnPersonalDataLoaded, void());
-};
-
-}  // namespace
-
-class TwoClientLiveAutofillSyncTest : public LiveSyncTest {
- public:
-  typedef std::set<AutofillKey> AutofillKeys;
-  typedef std::vector<AutoFillProfile*> AutoFillProfiles;
-  TwoClientLiveAutofillSyncTest()
-      : name1_(ASCIIToUTF16("name1")),
-        name2_(ASCIIToUTF16("name2")),
-        value1_(ASCIIToUTF16("value1")),
-        value2_(ASCIIToUTF16("value2")),
-        done_event1_(false, false),
-        done_event2_(false, false) {
-    // This makes sure browser is visible and active while running test.
-    InProcessBrowserTest::set_show_window(true);
-    // Set the initial timeout value to 5 min.
-    InProcessBrowserTest::SetInitialTimeoutInMS(300000);
-  }
-  ~TwoClientLiveAutofillSyncTest() {}
-
- protected:
-  void SetupHarness() {
-    client1_.reset(new ProfileSyncServiceTestHarness(
-        browser()->profile(), username_, password_));
-    profile2_.reset(MakeProfile(FILE_PATH_LITERAL("client2")));
-    client2_.reset(new ProfileSyncServiceTestHarness(
-        profile2_.get(), username_, password_));
-    wds1_ = browser()->profile()->GetWebDataService(Profile::EXPLICIT_ACCESS);
-    wds2_ = profile2_->GetWebDataService(Profile::EXPLICIT_ACCESS);
-    pdm1_ = browser()->profile()->GetPersonalDataManager();
-    pdm2_ = profile2_->GetPersonalDataManager();
-  }
-
-  void SetupSync() {
-    EXPECT_TRUE(client1_->SetupSync());
-    EXPECT_TRUE(client1_->AwaitSyncCycleCompletion("Initial setup 1"));
-    EXPECT_TRUE(client2_->SetupSync());
-    EXPECT_TRUE(client2_->AwaitSyncCycleCompletion("Initial setup 2"));
-  }
-
-  void Cleanup() {
-    client2_.reset();
-    profile2_.reset();
-  }
-
-  virtual void SetUpCommandLine(CommandLine* command_line) {
-    command_line->AppendSwitch(switches::kEnableSyncAutofill);
-  }
-
-  void AddFormFieldsToWebData(WebDataService* wds, const AutofillKeys& keys) {
-    std::vector<webkit_glue::FormField> form_fields;
-    for (AutofillKeys::const_iterator i = keys.begin(); i != keys.end(); ++i) {
-      form_fields.push_back(
-          webkit_glue::FormField(string16(),
-                                 (*i).name(),
-                                 (*i).value(),
-                                 string16(),
-                                 0));
-    }
-
-    WaitableEvent done_event(false, false);
-    scoped_refptr<AutofillDBThreadObserverHelper> observer_helper(
-        new AutofillDBThreadObserverHelper());
-    observer_helper->Init();
-
-    EXPECT_CALL(*observer_helper->observer(), Observe(_, _, _)).
-        WillOnce(SignalEvent(&done_event));
-    wds->AddFormFields(form_fields);
-    done_event.Wait();
-  }
-
-  void RemoveKeyFromWebData(WebDataService* wds, const AutofillKey& key) {
-    WaitableEvent done_event(false, false);
-    scoped_refptr<AutofillDBThreadObserverHelper> observer_helper(
-        new AutofillDBThreadObserverHelper());
-    observer_helper->Init();
-
-    EXPECT_CALL(*observer_helper->observer(), Observe(_, _, _)).
-        WillOnce(SignalEvent(&done_event));
-    wds->RemoveFormValueForElementName(key.name(), key.value());
-    done_event.Wait();
-  }
-
-  void SetProfiles(PersonalDataManager* pdm,
-                   std::vector<AutoFillProfile>* profiles) {
-    MockPersonalDataManagerObserver observer;
-    EXPECT_CALL(observer, OnPersonalDataLoaded()).
-        WillOnce(QuitUIMessageLoop());
-    pdm->SetObserver(&observer);
-    pdm->SetProfiles(profiles);
-    MessageLoop::current()->Run();
-    pdm->RemoveObserver(&observer);
-  }
-
-  void AddProfile(PersonalDataManager* pdm, const AutoFillProfile& profile) {
-    const AutoFillProfiles& all_profiles = GetAllAutoFillProfiles(pdm);
-    std::vector<AutoFillProfile> profiles;
-    for (size_t i = 0; i < all_profiles.size(); ++i)
-      profiles.push_back(*all_profiles[i]);
-    profiles.push_back(profile);
-    SetProfiles(pdm, &profiles);
-  }
-
-  void RemoveProfile(PersonalDataManager* pdm, const string16& label) {
-    const AutoFillProfiles& all_profiles = GetAllAutoFillProfiles(pdm);
-    std::vector<AutoFillProfile> profiles;
-    for (size_t i = 0; i < all_profiles.size(); ++i) {
-      if (all_profiles[i]->Label() != label)
-        profiles.push_back(*all_profiles[i]);
-    }
-    SetProfiles(pdm, &profiles);
-  }
-
-  void UpdateProfile(PersonalDataManager* pdm,
-                     const string16& label,
-                     const AutoFillType& type,
-                     const string16& value) {
-    const AutoFillProfiles& all_profiles = GetAllAutoFillProfiles(pdm);
-    std::vector<AutoFillProfile> profiles;
-    for (size_t i = 0; i < all_profiles.size(); ++i) {
-      profiles.push_back(*all_profiles[i]);
-      if (all_profiles[i]->Label() == label)
-        profiles.back().SetInfo(type, value);
-    }
-    SetProfiles(pdm, &profiles);
-  }
-
-  void GetAllAutofillKeys(WebDataService* wds, AutofillKeys* keys) {
-    scoped_refptr<GetAllAutofillEntries> get_all_entries =
-        new GetAllAutofillEntries(wds);
-    get_all_entries->Init();
-    const std::vector<AutofillEntry>& entries = get_all_entries->entries();
-
-    for (size_t i = 0; i < entries.size(); ++i) {
-      keys->insert(entries[i].key());
-    }
-  }
-
-  const AutoFillProfiles& GetAllAutoFillProfiles(PersonalDataManager* pdm) {
-    MockPersonalDataManagerObserver observer;
-    EXPECT_CALL(observer, OnPersonalDataLoaded()).
-        WillOnce(QuitUIMessageLoop());
-    pdm->SetObserver(&observer);
-    pdm->Refresh();
-    MessageLoop::current()->Run();
-    pdm->RemoveObserver(&observer);
-    return pdm->profiles();
-  }
-
-  bool CompareAutoFillProfiles(const AutoFillProfiles& expected_profiles,
-                               const AutoFillProfiles& profiles) {
-    std::map<string16, AutoFillProfile> expected_profiles_map;
-    for (size_t i = 0; i < expected_profiles.size(); ++i) {
-      const AutoFillProfile* p = expected_profiles[i];
-      expected_profiles_map[p->Label()] = *p;
-    }
-
-    for (size_t i = 0; i < profiles.size(); ++i) {
-      const AutoFillProfile* p = profiles[i];
-      if (!expected_profiles_map.count(p->Label())) {
-        LOG(INFO) << "Label " << p->Label() << " not in expected";
-        return false;
-      }
-      AutoFillProfile* expected_profile = &expected_profiles_map[p->Label()];
-      expected_profile->set_unique_id(p->unique_id());
-      if (*expected_profile != *p) {
-        LOG(INFO) << "Profile mismatch";
-        return false;
-      }
-      expected_profiles_map.erase(p->Label());
-    }
-
-    if (expected_profiles_map.size()) {
-      LOG(INFO) << "Labels in expected but not supplied";
-      return false;
-    }
-
-    return true;
-  }
-
-  ProfileSyncServiceTestHarness* client1() { return client1_.get(); }
-  ProfileSyncServiceTestHarness* client2() { return client2_.get(); }
-
-  PrefService* prefs1() { return browser()->profile()->GetPrefs(); }
-  PrefService* prefs2() { return profile2_->GetPrefs(); }
-
-  string16 name1_;
-  string16 name2_;
-  string16 value1_;
-  string16 value2_;
-  base::WaitableEvent done_event1_;
-  base::WaitableEvent done_event2_;
-
-  scoped_ptr<ProfileSyncServiceTestHarness> client1_;
-  scoped_ptr<ProfileSyncServiceTestHarness> client2_;
-  scoped_ptr<Profile> profile2_;
-  WebDataService* wds1_;
-  WebDataService* wds2_;
-  PersonalDataManager* pdm1_;
-  PersonalDataManager* pdm2_;
-
-  DISALLOW_COPY_AND_ASSIGN(TwoClientLiveAutofillSyncTest);
-};
+#include "chrome/test/live_sync/live_autofill_sync_test.h"
 
 IN_PROC_BROWSER_TEST_F(TwoClientLiveAutofillSyncTest, Client1HasData) {
-  SetupHarness();
+  ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
 
   AutofillKeys keys;
-  keys.insert(AutofillKey("name1", "value1"));
+  keys.insert(AutofillKey("name0", "value0"));
+  keys.insert(AutofillKey("name0", "value1"));
   keys.insert(AutofillKey("name1", "value2"));
-  keys.insert(AutofillKey("name2", "value3"));
   keys.insert(AutofillKey(WideToUTF16(L"Sigur R\u00F3s"),
                           WideToUTF16(L"\u00C1g\u00E6tis byrjun")));
-  AddFormFieldsToWebData(wds1_, keys);
-
-  SetupSync();
+  AddFormFieldsToWebData(GetWebDataService(0), keys);
 
-  AutofillKeys wd2_keys;
-  GetAllAutofillKeys(wds2_, &wd2_keys);
-  EXPECT_EQ(keys, wd2_keys);
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 
-  Cleanup();
+  AutofillKeys wd1_keys;
+  GetAllAutofillKeys(GetWebDataService(1), &wd1_keys);
+  EXPECT_EQ(keys, wd1_keys);
 }
 
 IN_PROC_BROWSER_TEST_F(TwoClientLiveAutofillSyncTest, BothHaveData) {
-  SetupHarness();
+  ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
 
   AutofillKeys keys1;
-  keys1.insert(AutofillKey("name1", "value1"));
+  keys1.insert(AutofillKey("name0", "value0"));
+  keys1.insert(AutofillKey("name0", "value1"));
   keys1.insert(AutofillKey("name1", "value2"));
-  keys1.insert(AutofillKey("name2", "value3"));
-  AddFormFieldsToWebData(wds1_, keys1);
+  AddFormFieldsToWebData(GetWebDataService(0), keys1);
 
   AutofillKeys keys2;
+  keys2.insert(AutofillKey("name0", "value1"));
   keys2.insert(AutofillKey("name1", "value2"));
   keys2.insert(AutofillKey("name2", "value3"));
-  keys2.insert(AutofillKey("name3", "value4"));
-  keys2.insert(AutofillKey("name4", "value4"));
-  AddFormFieldsToWebData(wds2_, keys2);
+  keys2.insert(AutofillKey("name3", "value3"));
+  AddFormFieldsToWebData(GetWebDataService(1), keys2);
 
-  SetupSync();
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
   // Wait for client1 to get the new keys from client2.
-  EXPECT_TRUE(client1()->AwaitSyncCycleCompletion("sync cycle"));
+  EXPECT_TRUE(GetClient(0)->AwaitSyncCycleCompletion("sync cycle"));
 
   AutofillKeys expected_keys;
-  expected_keys.insert(AutofillKey("name1", "value1"));
+  expected_keys.insert(AutofillKey("name0", "value0"));
+  expected_keys.insert(AutofillKey("name0", "value1"));
   expected_keys.insert(AutofillKey("name1", "value2"));
   expected_keys.insert(AutofillKey("name2", "value3"));
-  expected_keys.insert(AutofillKey("name3", "value4"));
-  expected_keys.insert(AutofillKey("name4", "value4"));
+  expected_keys.insert(AutofillKey("name3", "value3"));
+
+  AutofillKeys wd0_keys;
+  GetAllAutofillKeys(GetWebDataService(0), &wd0_keys);
+  EXPECT_EQ(expected_keys, wd0_keys);
 
   AutofillKeys wd1_keys;
-  GetAllAutofillKeys(wds1_, &wd1_keys);
+  GetAllAutofillKeys(GetWebDataService(1), &wd1_keys);
   EXPECT_EQ(expected_keys, wd1_keys);
-
-  AutofillKeys wd2_keys;
-  GetAllAutofillKeys(wds2_, &wd2_keys);
-  EXPECT_EQ(expected_keys, wd2_keys);
-
-  Cleanup();
 }
 
 IN_PROC_BROWSER_TEST_F(TwoClientLiveAutofillSyncTest, Steady) {
-  SetupHarness();
-  SetupSync();
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 
-  // Client1 adds a key.
+  // Client0 adds a key.
   AutofillKeys add_one_key;
-  add_one_key.insert(AutofillKey("name1", "value1"));
-  AddFormFieldsToWebData(wds1_, add_one_key);
-  EXPECT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
+  add_one_key.insert(AutofillKey("name0", "value0"));
+  AddFormFieldsToWebData(GetWebDataService(0), add_one_key);
+  EXPECT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 
   AutofillKeys expected_keys;
-  expected_keys.insert(AutofillKey("name1", "value1"));
+  expected_keys.insert(AutofillKey("name0", "value0"));
 
   AutofillKeys keys;
-  GetAllAutofillKeys(wds1_, &keys);
+  GetAllAutofillKeys(GetWebDataService(0), &keys);
   EXPECT_EQ(expected_keys, keys);
   keys.clear();
-  GetAllAutofillKeys(wds2_, &keys);
+  GetAllAutofillKeys(GetWebDataService(1), &keys);
   EXPECT_EQ(expected_keys, keys);
 
-  // Client2 adds a key.
+  // Client1 adds a key.
   add_one_key.clear();
-  add_one_key.insert(AutofillKey("name2", "value2"));
-  AddFormFieldsToWebData(wds2_, add_one_key);
-  EXPECT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
+  add_one_key.insert(AutofillKey("name1", "value1"));
+  AddFormFieldsToWebData(GetWebDataService(1), add_one_key);
+  EXPECT_TRUE(GetClient(1)->AwaitMutualSyncCycleCompletion(GetClient(0)));
 
-  expected_keys.insert(AutofillKey("name2", "value2"));
+  expected_keys.insert(AutofillKey("name1", "value1"));
   keys.clear();
-  GetAllAutofillKeys(wds1_, &keys);
+  GetAllAutofillKeys(GetWebDataService(0), &keys);
   EXPECT_EQ(expected_keys, keys);
   keys.clear();
-  GetAllAutofillKeys(wds2_, &keys);
+  GetAllAutofillKeys(GetWebDataService(1), &keys);
   EXPECT_EQ(expected_keys, keys);
 
-  // Client1 adds a key with the same name.
+  // Client0 adds a key with the same name.
   add_one_key.clear();
-  add_one_key.insert(AutofillKey("name2", "value3"));
-  AddFormFieldsToWebData(wds1_, add_one_key);
-  EXPECT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
+  add_one_key.insert(AutofillKey("name1", "value2"));
+  AddFormFieldsToWebData(GetWebDataService(0), add_one_key);
+  EXPECT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 
-  expected_keys.insert(AutofillKey("name2", "value3"));
+  expected_keys.insert(AutofillKey("name1", "value2"));
   keys.clear();
-  GetAllAutofillKeys(wds1_, &keys);
+  GetAllAutofillKeys(GetWebDataService(0), &keys);
   EXPECT_EQ(expected_keys, keys);
   keys.clear();
-  GetAllAutofillKeys(wds2_, &keys);
+  GetAllAutofillKeys(GetWebDataService(1), &keys);
   EXPECT_EQ(expected_keys, keys);
 
-  // Client2 removes a key.
-  RemoveKeyFromWebData(wds2_, AutofillKey("name2", "value2"));
-  EXPECT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
+  // Client1 removes a key.
+  RemoveKeyFromWebData(GetWebDataService(1), AutofillKey("name1", "value1"));
+  EXPECT_TRUE(GetClient(1)->AwaitMutualSyncCycleCompletion(GetClient(0)));
 
-  expected_keys.erase(AutofillKey("name2", "value2"));
+  expected_keys.erase(AutofillKey("name1", "value1"));
   keys.clear();
-  GetAllAutofillKeys(wds1_, &keys);
+  GetAllAutofillKeys(GetWebDataService(0), &keys);
   EXPECT_EQ(expected_keys, keys);
   keys.clear();
-  GetAllAutofillKeys(wds2_, &keys);
+  GetAllAutofillKeys(GetWebDataService(1), &keys);
   EXPECT_EQ(expected_keys, keys);
 
-  // Client1 removes the rest.
-  RemoveKeyFromWebData(wds1_, AutofillKey("name1", "value1"));
-  RemoveKeyFromWebData(wds1_, AutofillKey("name2", "value3"));
-  EXPECT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
+  // Client0 removes the rest.
+  RemoveKeyFromWebData(GetWebDataService(0), AutofillKey("name0", "value0"));
+  RemoveKeyFromWebData(GetWebDataService(0), AutofillKey("name1", "value2"));
+  EXPECT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 
   keys.clear();
-  GetAllAutofillKeys(wds1_, &keys);
+  GetAllAutofillKeys(GetWebDataService(0), &keys);
   EXPECT_EQ(0U, keys.size());
   keys.clear();
-  GetAllAutofillKeys(wds2_, &keys);
+  GetAllAutofillKeys(GetWebDataService(1), &keys);
   EXPECT_EQ(0U, keys.size());
-
-  Cleanup();
 }
 
 IN_PROC_BROWSER_TEST_F(TwoClientLiveAutofillSyncTest, ProfileClient1HasData) {
-  SetupHarness();
+  ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
 
   AutoFillProfiles expected_profiles;
   expected_profiles.push_back(new AutoFillProfile(string16(), 0));
   FillProfile(MARION, expected_profiles[0]);
   expected_profiles.push_back(new AutoFillProfile(string16(), 0));
   FillProfile(HOMER, expected_profiles[1]);
-  AddProfile(pdm1_, *expected_profiles[0]);
-  AddProfile(pdm1_, *expected_profiles[1]);
+  AddProfile(GetPersonalDataManager(0), *expected_profiles[0]);
+  AddProfile(GetPersonalDataManager(0), *expected_profiles[1]);
 
-  SetupSync();
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 
   EXPECT_TRUE(CompareAutoFillProfiles(expected_profiles,
-                                      GetAllAutoFillProfiles(pdm1_)));
+      GetAllAutoFillProfiles(GetPersonalDataManager(0))));
   EXPECT_TRUE(CompareAutoFillProfiles(expected_profiles,
-                                      GetAllAutoFillProfiles(pdm2_)));
-  Cleanup();
+      GetAllAutoFillProfiles(GetPersonalDataManager(1))));
   STLDeleteElements(&expected_profiles);
 }
 
 IN_PROC_BROWSER_TEST_F(TwoClientLiveAutofillSyncTest,
                        ProfileSameLabelOnDifferentClients) {
-  SetupHarness();
+  ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
 
   AutoFillProfiles profiles1;
   profiles1.push_back(new AutoFillProfile(string16(), 0));
@@ -505,25 +163,24 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveAutofillSyncTest,
   FillProfile(MARION, profiles2[0]);
   profiles2[0]->set_label(ASCIIToUTF16("Shipping"));
 
-  AddProfile(pdm1_, *profiles1[0]);
-  AddProfile(pdm2_, *profiles2[0]);
+  AddProfile(GetPersonalDataManager(0), *profiles1[0]);
+  AddProfile(GetPersonalDataManager(1), *profiles2[0]);
 
-  SetupSync();
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 
   // Since client1 associates first, client2's "Shipping" profile will
   // be overwritten by the one stored in the cloud by profile1.
   EXPECT_TRUE(CompareAutoFillProfiles(profiles1,
-                                      GetAllAutoFillProfiles(pdm1_)));
+      GetAllAutoFillProfiles(GetPersonalDataManager(0))));
   EXPECT_TRUE(CompareAutoFillProfiles(profiles1,
-                                      GetAllAutoFillProfiles(pdm2_)));
-  Cleanup();
+      GetAllAutoFillProfiles(GetPersonalDataManager(1))));
   STLDeleteElements(&profiles1);
   STLDeleteElements(&profiles2);
 }
 
 IN_PROC_BROWSER_TEST_F(TwoClientLiveAutofillSyncTest,
                        ProfileSameLabelOnClient1) {
-  SetupHarness();
+  ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
 
   AutoFillProfiles expected_profiles;
   expected_profiles.push_back(new AutoFillProfile(string16(), 0));
@@ -531,99 +188,95 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveAutofillSyncTest,
   expected_profiles.push_back(new AutoFillProfile(string16(), 0));
   FillProfile(HOMER, expected_profiles[1]);
 
-  AddProfile(pdm1_, *expected_profiles[0]);
-  AddProfile(pdm1_, *expected_profiles[1]);
+  AddProfile(GetPersonalDataManager(0), *expected_profiles[0]);
+  AddProfile(GetPersonalDataManager(0), *expected_profiles[1]);
 
-  SetupSync();
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 
   // One of the duplicate profiles will have its label renamed to
   // "Shipping2".
   expected_profiles[0]->set_label(ASCIIToUTF16("Shipping2"));
 
   EXPECT_TRUE(CompareAutoFillProfiles(expected_profiles,
-                                      GetAllAutoFillProfiles(pdm1_)));
+      GetAllAutoFillProfiles(GetPersonalDataManager(0))));
   EXPECT_TRUE(CompareAutoFillProfiles(expected_profiles,
-                                      GetAllAutoFillProfiles(pdm2_)));
-  Cleanup();
+      GetAllAutoFillProfiles(GetPersonalDataManager(1))));
   STLDeleteElements(&expected_profiles);
 }
 
 
 IN_PROC_BROWSER_TEST_F(TwoClientLiveAutofillSyncTest, ProfileSteady) {
-  SetupHarness();
-  SetupSync();
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 
-  // Client1 adds a profile.
+  // Client0 adds a profile.
   AutoFillProfiles expected_profiles;
   expected_profiles.push_back(new AutoFillProfile(string16(), 0));
   FillProfile(HOMER, expected_profiles[0]);
-  AddProfile(pdm1_, *expected_profiles[0]);
-  EXPECT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
+  AddProfile(GetPersonalDataManager(0), *expected_profiles[0]);
+  EXPECT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 
   EXPECT_TRUE(CompareAutoFillProfiles(expected_profiles,
-                                      GetAllAutoFillProfiles(pdm1_)));
+      GetAllAutoFillProfiles(GetPersonalDataManager(0))));
   EXPECT_TRUE(CompareAutoFillProfiles(expected_profiles,
-                                      GetAllAutoFillProfiles(pdm2_)));
+      GetAllAutoFillProfiles(GetPersonalDataManager(1))));
 
-  // Client2 adds a profile.
+  // Client1 adds a profile.
   expected_profiles.push_back(new AutoFillProfile(string16(), 0));
   FillProfile(MARION, expected_profiles[1]);
-  AddProfile(pdm2_, *expected_profiles[1]);
-  EXPECT_TRUE(client2()->AwaitMutualSyncCycleCompletion(client1()));
+  AddProfile(GetPersonalDataManager(1), *expected_profiles[1]);
+  EXPECT_TRUE(GetClient(1)->AwaitMutualSyncCycleCompletion(GetClient(0)));
 
   EXPECT_TRUE(CompareAutoFillProfiles(expected_profiles,
-                                      GetAllAutoFillProfiles(pdm1_)));
+      GetAllAutoFillProfiles(GetPersonalDataManager(0))));
   EXPECT_TRUE(CompareAutoFillProfiles(expected_profiles,
-                                      GetAllAutoFillProfiles(pdm2_)));
+      GetAllAutoFillProfiles(GetPersonalDataManager(1))));
 
-  // Client1 adds a conflicting profile.
+  // Client0 adds a conflicting profile.
   expected_profiles.push_back(new AutoFillProfile(string16(), 0));
   FillProfile(MARION, expected_profiles[2]);
-  AddProfile(pdm1_, *expected_profiles[2]);
-  EXPECT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
+  AddProfile(GetPersonalDataManager(0), *expected_profiles[2]);
+  EXPECT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 
   // The conflicting profile's label will be made unique.
   expected_profiles[2]->set_label(ASCIIToUTF16("Billing2"));
   EXPECT_TRUE(CompareAutoFillProfiles(expected_profiles,
-                                      GetAllAutoFillProfiles(pdm1_)));
+      GetAllAutoFillProfiles(GetPersonalDataManager(0))));
   EXPECT_TRUE(CompareAutoFillProfiles(expected_profiles,
-                                      GetAllAutoFillProfiles(pdm2_)));
+      GetAllAutoFillProfiles(GetPersonalDataManager(1))));
 
-  // Client2 removes a profile.
+  // Client1 removes a profile.
   delete expected_profiles.front();
   expected_profiles.erase(expected_profiles.begin());
-  RemoveProfile(pdm2_, ASCIIToUTF16("Shipping"));
-  EXPECT_TRUE(client2()->AwaitMutualSyncCycleCompletion(client1()));
+  RemoveProfile(GetPersonalDataManager(1), ASCIIToUTF16("Shipping"));
+  EXPECT_TRUE(GetClient(1)->AwaitMutualSyncCycleCompletion(GetClient(0)));
 
   EXPECT_TRUE(CompareAutoFillProfiles(expected_profiles,
-                                      GetAllAutoFillProfiles(pdm1_)));
+      GetAllAutoFillProfiles(GetPersonalDataManager(0))));
   EXPECT_TRUE(CompareAutoFillProfiles(expected_profiles,
-                                      GetAllAutoFillProfiles(pdm2_)));
+      GetAllAutoFillProfiles(GetPersonalDataManager(1))));
 
-  // Client1 updates a profile.
+  // Client0 updates a profile.
   expected_profiles[0]->SetInfo(AutoFillType(NAME_FIRST),
                                 ASCIIToUTF16("Bart"));
-  UpdateProfile(pdm1_,
+  UpdateProfile(GetPersonalDataManager(0),
                 ASCIIToUTF16("Billing"),
                 AutoFillType(NAME_FIRST),
                 ASCIIToUTF16("Bart"));
-  EXPECT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
+  EXPECT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 
   EXPECT_TRUE(CompareAutoFillProfiles(expected_profiles,
-                                      GetAllAutoFillProfiles(pdm1_)));
+      GetAllAutoFillProfiles(GetPersonalDataManager(0))));
   EXPECT_TRUE(CompareAutoFillProfiles(expected_profiles,
-                                      GetAllAutoFillProfiles(pdm2_)));
+      GetAllAutoFillProfiles(GetPersonalDataManager(1))));
 
-  // Client2 removes everything.
+  // Client1 removes everything.
   STLDeleteElements(&expected_profiles);
-  RemoveProfile(pdm2_, ASCIIToUTF16("Billing"));
-  RemoveProfile(pdm2_, ASCIIToUTF16("Billing2"));
-  EXPECT_TRUE(client2()->AwaitMutualSyncCycleCompletion(client1()));
+  RemoveProfile(GetPersonalDataManager(1), ASCIIToUTF16("Billing"));
+  RemoveProfile(GetPersonalDataManager(1), ASCIIToUTF16("Billing2"));
+  EXPECT_TRUE(GetClient(1)->AwaitMutualSyncCycleCompletion(GetClient(0)));
 
   EXPECT_TRUE(CompareAutoFillProfiles(expected_profiles,
-                                      GetAllAutoFillProfiles(pdm1_)));
+      GetAllAutoFillProfiles(GetPersonalDataManager(0))));
   EXPECT_TRUE(CompareAutoFillProfiles(expected_profiles,
-                                      GetAllAutoFillProfiles(pdm2_)));
-
-  Cleanup();
+      GetAllAutoFillProfiles(GetPersonalDataManager(1))));
 }
diff --git a/chrome/test/live_sync/two_client_live_bookmarks_sync_test.cc b/chrome/test/live_sync/two_client_live_bookmarks_sync_test.cc
index c65e573..abe2ff6 100644
--- a/chrome/test/live_sync/two_client_live_bookmarks_sync_test.cc
+++ b/chrome/test/live_sync/two_client_live_bookmarks_sync_test.cc
@@ -1,360 +1,100 @@
-// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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 <stdlib.h>
-#include <string>
-
-#include "base/file_path.h"
-#include "base/rand_util.h"
-#include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
-#include "chrome/browser/browser.h"
-#include "chrome/browser/profile.h"
-#include "chrome/browser/sync/profile_sync_service.h"
-#include "chrome/test/live_sync/bookmark_model_verifier.h"
-#include "chrome/test/live_sync/profile_sync_service_test_harness.h"
-#include "chrome/test/live_sync/live_sync_test.h"
-#include "testing/gtest/include/gtest/gtest.h"
+#include "chrome/test/live_sync/live_bookmarks_sync_test.h"
+#include "base/rand_util.h"
 
 using std::string;
 using std::wstring;
 
-// TODO(tejasshah): Move single client tests to separate file.
-
 // Some Abbreviations Used:
 // F -- BookmarkFolder
 // BM -- Bookmark
 // L -- Level (Depth of bookmark folder)
-class TwoClientLiveBookmarksSyncTest : public LiveSyncTest {
- public:
-  TwoClientLiveBookmarksSyncTest() {
-    // This makes sure browser is visible and active while running test.
-    InProcessBrowserTest::set_show_window(true);
-    // Set the initial timeout value to 5 min.
-    InProcessBrowserTest::SetInitialTimeoutInMS(300000);
-  }
-  virtual ~TwoClientLiveBookmarksSyncTest() {}
-  bool SetupSync() {
-    profile2_.reset(MakeProfile(FILE_PATH_LITERAL("client2")));
-    client1_.reset(new ProfileSyncServiceTestHarness(
-        browser()->profile(), username_, password_));
-    client2_.reset(new ProfileSyncServiceTestHarness(
-        profile2_.get(), username_, password_));
-    if (ShouldSetupSyncWithRace()) {
-      return client1_->SetupSync() && client2_->SetupSync();
-    } else {
-      bool result_client1 = client1_->SetupSync();
-      client1()->AwaitSyncCycleCompletion("Initial setup");
-      return result_client1 && client2_->SetupSync();
-    }
-  }
-
-  // Overload this method in inherited class and return false to avoid
-  // race condition (two clients trying to sync/commit at the same time).
-  // Race condition may lead to duplicate bookmarks if there is existing
-  // bookmark model on both clients.
-  virtual bool ShouldSetupSyncWithRace() {
-    return true;
-  }
-
-  // Overload this method in your class and return true to pre-populate
-  // bookmark files for client2 also.
-  virtual bool ShouldCopyBookmarksToClient2() {
-    return false;
-  }
-
-  // This is used to pre-populate bookmarks hierarchy file to Client1 and
-  // Verifier Client.
-  void PrePopulateBookmarksHierarchy(const FilePath& bookmarks_file_name) {
-    // Let's create default profile directory.
-    FilePath dest_user_data_dir;
-    PathService::Get(chrome::DIR_USER_DATA, &dest_user_data_dir);
-    FilePath dest_user_data_dir_default = dest_user_data_dir.Append(
-        FILE_PATH_LITERAL("Default"));
-    file_util::CreateDirectory(dest_user_data_dir_default);
-    // Let's create verifier profile directory.
-    FilePath dest_user_data_dir_verifier = dest_user_data_dir.Append(
-        FILE_PATH_LITERAL("verifier"));
-    file_util::CreateDirectory(dest_user_data_dir_verifier);
-
-    // Let's prepare sync data source file path.
-    FilePath sync_data_source;
-    PathService::Get(base::DIR_SOURCE_ROOT, &sync_data_source);
-    sync_data_source = sync_data_source.Append(FILE_PATH_LITERAL("chrome"));
-    sync_data_source = sync_data_source.Append(
-        FILE_PATH_LITERAL("personalization"));
-    sync_data_source = sync_data_source.Append(FILE_PATH_LITERAL("test"));
-    sync_data_source = sync_data_source.Append(
-        FILE_PATH_LITERAL("live_sync_data"));
-    FilePath source_file = sync_data_source.Append(
-        bookmarks_file_name);
-    ASSERT_TRUE(file_util::PathExists(source_file))
-        << "Could not locate test data file: " << source_file.value();
-    // Now copy pre-generated bookmark file to default profile.
-    ASSERT_TRUE(file_util::CopyFile(source_file,
-        dest_user_data_dir_default.Append(FILE_PATH_LITERAL("bookmarks"))));
-    // Now copy pre-generated bookmark file to verifier profile.
-    ASSERT_TRUE(file_util::CopyFile(source_file,
-        dest_user_data_dir_verifier.Append(FILE_PATH_LITERAL("bookmarks"))));
-
-    // Let's pre-populate bookmarks file for client2 also if we need to.
-    if (ShouldCopyBookmarksToClient2()) {
-      // Let's create verifier profile directory.
-      FilePath dest_user_data_dir_client2 = dest_user_data_dir.Append(
-          FILE_PATH_LITERAL("client2"));
-      file_util::CreateDirectory(dest_user_data_dir_client2);
-      // Now copy pre-generated bookmark file to verifier profile.
-      ASSERT_TRUE(file_util::CopyFile(source_file,
-          dest_user_data_dir_client2.Append(FILE_PATH_LITERAL("bookmarks"))));
-    }
-  }
-
-  ProfileSyncServiceTestHarness* client1() { return client1_.get(); }
-  ProfileSyncServiceTestHarness* client2() { return client2_.get(); }
-
-  void set_client1(ProfileSyncServiceTestHarness* p_client1) {
-    client1_.reset(p_client1);
-  }
-
-  void set_client2(ProfileSyncServiceTestHarness* p_client2) {
-    client2_.reset(p_client2);
-  }
-
-  void set_profile2(Profile* p) {
-    profile2_.reset(p);
-  }
-
-  Profile* profile1() { return browser()->profile(); }
-  Profile* profile2() { return profile2_.get(); }
-
-  void Cleanup() {
-    client2_.reset();
-    profile2_.reset();
-  }
-
- private:
-  scoped_ptr<Profile> profile2_;
-  scoped_ptr<ProfileSyncServiceTestHarness> client1_;
-  scoped_ptr<ProfileSyncServiceTestHarness> client2_;
-
-  DISALLOW_COPY_AND_ASSIGN(TwoClientLiveBookmarksSyncTest);
-};
-
-class LiveSyncTestPrePopulatedHistory1K
-    : public TwoClientLiveBookmarksSyncTest {
- public:
-  LiveSyncTestPrePopulatedHistory1K() {}
-  virtual ~LiveSyncTestPrePopulatedHistory1K() {}
-
-  // This is used to pre-populate history data (1K URL Visit) to Client1
-  // and Verifier Client. Invoked by InProcBrowserTest::SetUp before
-  // the browser is started.
-  virtual void SetUpUserDataDirectory() {
-    // Let's copy history files to default profile.
-    FilePath dest_user_data_dir;
-    PathService::Get(chrome::DIR_USER_DATA, &dest_user_data_dir);
-    dest_user_data_dir = dest_user_data_dir.Append(
-        FILE_PATH_LITERAL("Default"));
-    file_util::CreateDirectory(dest_user_data_dir);
-    FilePath sync_data_source;
-    PathService::Get(base::DIR_SOURCE_ROOT, &sync_data_source);
-    sync_data_source = sync_data_source.Append(FILE_PATH_LITERAL("chrome"));
-    sync_data_source = sync_data_source.Append(
-        FILE_PATH_LITERAL("personalization"));
-    sync_data_source = sync_data_source.Append(FILE_PATH_LITERAL("test"));
-    sync_data_source = sync_data_source.Append(
-        FILE_PATH_LITERAL("live_sync_data"));
-    sync_data_source = sync_data_source.Append(
-        FILE_PATH_LITERAL("1K_url_visit_history"));
-    sync_data_source = sync_data_source.Append(FILE_PATH_LITERAL("Default"));
-    ASSERT_TRUE(file_util::PathExists(sync_data_source));
-    file_util::FileEnumerator sync_data(
-        sync_data_source, false, file_util::FileEnumerator::FILES);
-    FilePath source_file = sync_data.Next();
-    while (!source_file.empty()) {
-      FilePath dest_file = dest_user_data_dir.Append(source_file.BaseName());
-      ASSERT_TRUE(file_util::CopyFile(source_file, dest_file));
-      source_file = sync_data.Next();
-    }
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(LiveSyncTestPrePopulatedHistory1K);
-};
-
-class LiveSyncTestBasicHierarchy50BM
-    : public TwoClientLiveBookmarksSyncTest {
- public:
-  LiveSyncTestBasicHierarchy50BM() {}
-  virtual ~LiveSyncTestBasicHierarchy50BM() {}
-
-  // Invoked by InProcBrowserTest::SetUp before the browser is started.
-  virtual void SetUpUserDataDirectory() {
-    FilePath file_name(FILE_PATH_LITERAL("bookmarks_50BM5F3L"));
-    PrePopulateBookmarksHierarchy(file_name);
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(LiveSyncTestBasicHierarchy50BM);
-};
-
-class LiveSyncTestBasicHierarchy50BMBothClients
-    : public LiveSyncTestBasicHierarchy50BM {
- public:
-  LiveSyncTestBasicHierarchy50BMBothClients() {}
-  virtual ~LiveSyncTestBasicHierarchy50BMBothClients() {}
-  // Overloading this method and return true to pre-populate
-  // bookmark files for client2 also.
-  virtual bool ShouldCopyBookmarksToClient2() {
-    return true;
-  }
-
-  // Overloading to ensure there is no race condition between clients
-  // while doing initial set up of sync.
-  virtual bool ShouldSetupSyncWithRace() {
-    return false;
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(LiveSyncTestBasicHierarchy50BMBothClients);
-};
-
-class LiveSyncTestComplexHierarchy800BM
-    : public TwoClientLiveBookmarksSyncTest {
- public:
-  LiveSyncTestComplexHierarchy800BM() {}
-  virtual ~LiveSyncTestComplexHierarchy800BM() {}
-
-  // Invoked by InProcBrowserTest::SetUp before the browser is started.
-  virtual void SetUpUserDataDirectory() {
-    FilePath file_name(FILE_PATH_LITERAL("bookmarks_800BM32F8L"));
-    PrePopulateBookmarksHierarchy(file_name);
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(LiveSyncTestComplexHierarchy800BM);
-};
-
-class LiveSyncTestHugeHierarchy5500BM
-    : public TwoClientLiveBookmarksSyncTest {
- public:
-  LiveSyncTestHugeHierarchy5500BM() {}
-  virtual ~LiveSyncTestHugeHierarchy5500BM() {}
-
-  // Invoked by InProcBrowserTest::SetUp before the browser is started.
-  virtual void SetUpUserDataDirectory() {
-    FilePath file_name(FILE_PATH_LITERAL("bookmarks_5500BM125F25L"));
-    PrePopulateBookmarksHierarchy(file_name);
-  }
-  virtual bool ShouldSetupSyncWithRace() {
-    return false;
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(LiveSyncTestHugeHierarchy5500BM);
-};
-
-class LiveSyncTestDefaultIEFavorites
-    : public TwoClientLiveBookmarksSyncTest {
- public:
-  LiveSyncTestDefaultIEFavorites() {}
-  virtual ~LiveSyncTestDefaultIEFavorites() {}
-
-  // Invoked by InProcBrowserTest::SetUp before the browser is started.
-  virtual void SetUpUserDataDirectory() {
-    const FilePath file_name(
-        FILE_PATH_LITERAL("bookmarks_default_IE_favorites"));
-    TwoClientLiveBookmarksSyncTest::PrePopulateBookmarksHierarchy(file_name);
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(LiveSyncTestDefaultIEFavorites);
-};
-
-
 
 // Test case Naming Convention:
 // SC/MC - SingleClient / MultiClient.
 // Suffix Number - Indicates test scribe testcase ID.
+
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest, Sanity) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-  const BookmarkNode* bbn_two = model_two->GetBookmarkBarNode();
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = GetBookmarkBarNode(0);
+  const BookmarkNode* bm_bar1 = GetBookmarkBarNode(1);
+
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   GURL google_url("http://www.google.com");
   // Start adding some bookmarks to each model.  The scope is to enforce that
   // the BookmarkNode*'s are not used after they may be invalidated by sync
   // operations that alter the models.
   {
-    const BookmarkNode* google_one = verifier->AddURL(model_one, bbn_one, 0,
+    const BookmarkNode* google_one = v->AddURL(bm0, bm_bar0, 0,
         L"Google", google_url);
     ASSERT_TRUE(google_one != NULL);
 
     // To make this test deterministic, we wait here so there is no race to
     // decide which bookmark actually gets position 0.
-    ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-    const BookmarkNode* yahoo_two = verifier->AddURL(model_two, bbn_two, 0,
+    ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+    const BookmarkNode* yahoo_two = v->AddURL(bm1, bm_bar1, 0,
         L"Yahoo", GURL("http://www.yahoo.com"));
     ASSERT_TRUE(yahoo_two != NULL);
   }
-  ASSERT_TRUE(client2()->AwaitMutualSyncCycleCompletion(client1()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(1)->AwaitMutualSyncCycleCompletion(GetClient(0)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   {
     const BookmarkNode* new_folder_one =
-        verifier->AddGroup(model_one, bbn_one, 2, L"New Folder");
-    verifier->Move(model_one, GetByUniqueURL(model_one, google_url),
+        v->AddGroup(bm0, bm_bar0, 2, L"New Folder");
+    v->Move(bm0, GetByUniqueURL(bm0, google_url),
         new_folder_one, 0);
-    verifier->SetTitle(model_one, bbn_one->GetChild(0), L"Yahoo!!");
-    const BookmarkNode* cnn_one = verifier->AddURL(model_one,
-        bbn_one, 1, L"CNN", GURL("http://www.cnn.com"));
+    v->SetTitle(bm0, bm_bar0->GetChild(0), L"Yahoo!!");
+    const BookmarkNode* cnn_one = v->AddURL(bm0,
+        bm_bar0, 1, L"CNN", GURL("http://www.cnn.com"));
     ASSERT_TRUE(cnn_one != NULL);
   }
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   {
-    const BookmarkNode* facebook_two = verifier->AddURL(model_two,
-        bbn_two, 0, L"Facebook", GURL("http://www.facebook.com"));
+    const BookmarkNode* facebook_two = v->AddURL(bm1,
+        bm_bar1, 0, L"Facebook", GURL("http://www.facebook.com"));
     ASSERT_TRUE(facebook_two != NULL);
   }
 
   // AwaitMutualSyncCycleCompletion blocks the calling object before the
   // argument, so because we have made changes from client2 here we need to swap
   // the calling order.
-  ASSERT_TRUE(client2()->AwaitMutualSyncCycleCompletion(client1()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(1)->AwaitMutualSyncCycleCompletion(GetClient(0)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
-  verifier->SortChildren(model_two, bbn_two);
+  v->SortChildren(bm1, bm_bar1);
 
-  ASSERT_TRUE(client2()->AwaitMutualSyncCycleCompletion(client1()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(1)->AwaitMutualSyncCycleCompletion(GetClient(0)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   {
     // Do something crazy and modify the same item from both clients!!
-    const BookmarkNode* google_one = GetByUniqueURL(model_one, google_url);
-    const BookmarkNode* google_two = GetByUniqueURL(model_two, google_url);
-    model_one->SetTitle(google_one, L"Google++");
-    model_two->SetTitle(google_two, L"Google--");
+    const BookmarkNode* google_one = GetByUniqueURL(bm0, google_url);
+    const BookmarkNode* google_two = GetByUniqueURL(bm1, google_url);
+    bm0->SetTitle(google_one, L"Google++");
+    bm1->SetTitle(google_two, L"Google--");
   }
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
   // Make sure that client2 has pushed all of it's changes as well.
-  ASSERT_TRUE(client2()->AwaitMutualSyncCycleCompletion(client1()));
+  ASSERT_TRUE(GetClient(1)->AwaitMutualSyncCycleCompletion(GetClient(0)));
 
-  BookmarkModelVerifier::ExpectModelsMatch(model_one, model_two);
-
-  Cleanup();
+  BookmarkModelVerifier::ExpectModelsMatch(bm0, bm1);
 }
 
 // TODO(timsteele): There are really two tests here, one case where conflict
@@ -365,246 +105,160 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest, Sanity) {
 // tests yet.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SimultaneousURLChanges) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-  const BookmarkNode* bbn_two = model_two->GetBookmarkBarNode();
-
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+  const BookmarkNode* bm_bar1 = bm1->GetBookmarkBarNode();
+
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
   GURL initial_url("http://www.google.com");
   GURL second_url("http://www.google.com/abc");
   GURL third_url("http://www.google.com/def");
   wstring title = L"Google";
   {
-    const BookmarkNode* google = verifier->AddURL(model_one, bbn_one, 0,
+    const BookmarkNode* google = v->AddURL(bm0, bm_bar0, 0,
         title, initial_url);
     ASSERT_TRUE(google != NULL);
   }
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 
   {
-    const BookmarkNode* google_one = GetByUniqueURL(model_one, initial_url);
-    const BookmarkNode* google_two = GetByUniqueURL(model_two, initial_url);
-    bookmark_utils::ApplyEditsWithNoGroupChange(model_one, bbn_one,
+    const BookmarkNode* google_one = GetByUniqueURL(bm0, initial_url);
+    const BookmarkNode* google_two = GetByUniqueURL(bm1, initial_url);
+    bookmark_utils::ApplyEditsWithNoGroupChange(bm0, bm_bar0,
         BookmarkEditor::EditDetails(google_one), title, second_url);
-    bookmark_utils::ApplyEditsWithNoGroupChange(model_two, bbn_two,
+    bookmark_utils::ApplyEditsWithNoGroupChange(bm1, bm_bar1,
         BookmarkEditor::EditDetails(google_two), title, third_url);
   }
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
   // Make sure that client2 has pushed all of it's changes as well.
-  ASSERT_TRUE(client2()->AwaitMutualSyncCycleCompletion(client1()));
-  BookmarkModelVerifier::ExpectModelsMatch(model_one, model_two);
-
-  {
-    const BookmarkNode* google_one = bbn_one->GetChild(0);
-    model_one->SetTitle(google_one, L"Google1");
-  }
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  BookmarkModelVerifier::ExpectModelsMatch(model_one, model_two);
-  Cleanup();
-}
-
-// Test Scribe ID - 370439.
-IN_PROC_BROWSER_TEST_F(LiveSyncTestDefaultIEFavorites,
-    DISABLED_SC_BootStrapWithDefaultIEFavorites) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-
-  // Wait for changes to propagate.
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  // Let's compare and make sure both bookmark models are same after sync.
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  Cleanup();
-}
-
-// Test Scribe ID - 370441.
-IN_PROC_BROWSER_TEST_F(LiveSyncTestComplexHierarchy800BM,
-    DISABLED_SC_BootStrapWithComplexBMHierarchy) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-
-  // Wait for changes to propagate.
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  // Let's compare and make sure both bookmark models are same after sync.
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  Cleanup();
-}
-
-// Test Scribe ID - 370442.
-IN_PROC_BROWSER_TEST_F(LiveSyncTestHugeHierarchy5500BM,
-    DISABLED_SC_BootStrapWithHugeBMs) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-
-  // Wait for changes to propagate.
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  // Let's compare and make sure both bookmark models are same after sync.
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  Cleanup();
-}
-
-// Test Scribe ID - 370489.
-IN_PROC_BROWSER_TEST_F(LiveSyncTestPrePopulatedHistory1K,
-    DISABLED_SC_AddFirstBMWithFavicon) {
+  ASSERT_TRUE(GetClient(1)->AwaitMutualSyncCycleCompletion(GetClient(0)));
+  BookmarkModelVerifier::ExpectModelsMatch(bm0, bm1);
 
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  // Let's add first bookmark(with favicon)
   {
-    const BookmarkNode* nofavicon_bm = verifier->AddURL(model_one, bbn_one, 0,
-        L"Welcome to Facebook! | Facebook", GURL("http://www.facebook.com"));
-    ASSERT_TRUE(nofavicon_bm != NULL);
+    const BookmarkNode* google_one = bm_bar0->GetChild(0);
+    bm0->SetTitle(google_one, L"Google1");
   }
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  BookmarkModelVerifier::ExpectModelsMatchIncludingFavicon(model_one,
-      model_two, true);
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  BookmarkModelVerifier::ExpectModelsMatch(bm0, bm1);
 }
 
 // Test Scribe ID - 370558.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_AddFirstFolder) {
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
 
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   {
     // Let's add first bookmark folder to client1
     const BookmarkNode* new_folder_one =
-        verifier->AddGroup(model_one, bbn_one, 0, L"TestFolder");
+        v->AddGroup(bm0, bm_bar0, 0, L"TestFolder");
     ASSERT_TRUE(new_folder_one != NULL);
   }
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 // Test Scribe ID - 370559.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_AddFirstBMWithoutFavicon) {
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
 
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's add first bookmark(without favicon)
   {
-    const BookmarkNode* nofavicon_bm = verifier->AddURL(model_one, bbn_one, 0,
+    const BookmarkNode* nofavicon_bm = v->AddURL(bm0, bm_bar0, 0,
         L"TestBookmark", GURL("http://www.nofaviconurl.com"));
     ASSERT_TRUE(nofavicon_bm != NULL);
   }
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 // Test Scribe ID - 370560.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_AddNonHTTPBMs) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  // Let's add few non-http bookmarks(without favicon)
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
+
+  // Let's add few non-http GetBookmarkModel(without favicon)
   {
-    const BookmarkNode* ftp_bm = verifier->AddURL(model_one, bbn_one, 0,
+    const BookmarkNode* ftp_bm = v->AddURL(bm0, bm_bar0, 0,
         L"FTPBookmark", GURL("ftp://ftp.testbookmark.com"));
     ASSERT_TRUE(ftp_bm != NULL);
-    const BookmarkNode* file_bm = verifier->AddURL(model_one, bbn_one, 1,
+    const BookmarkNode* file_bm = v->AddURL(bm0, bm_bar0, 1,
         L"FileBookmark", GURL("file:///"));
     ASSERT_TRUE(file_bm != NULL);
   }
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 // Test Scribe ID - 370561.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_AddFirstBMUnderFolder) {
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
 
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   {
     // Let's add first bookmark folder to client1
     const BookmarkNode* new_folder_one =
-        verifier->AddGroup(model_one, bbn_one, 0, L"BM TestFolder");
+        v->AddGroup(bm0, bm_bar0, 0, L"BM TestFolder");
     // Add first bookmark to newly created folder
-    const BookmarkNode* test_bm1 = verifier->AddURL(
-        model_one, new_folder_one, 0,
+    const BookmarkNode* test_bm1 = v->AddURL(
+        bm0, new_folder_one, 0,
         L"BM Test", GURL("http://www.bmtest.com"));
     ASSERT_TRUE(test_bm1 != NULL);
   }
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 // Test Scribe ID - 370562.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_AddSeveralBMsUnderBMBarAndOtherBM) {
-
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-  const BookmarkNode* other_bm_one = model_one->other_node();
-
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-  // Let's add some bookmarks(without favicon)
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+  const BookmarkNode* bm_other0 = bm0->other_node();
+
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
+  // Let's add some GetBookmarkModel(without favicon)
   for (int index = 0; index < 20; index++) {
     wstring title(L"TestBookmark");
         title.append(IntToWString(index));
@@ -612,7 +266,7 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     url.append(IntToString(index));
     url.append(".com");
     const BookmarkNode* nofavicon_bm =
-        verifier->AddURL(model_one, bbn_one, index, title, GURL(url));
+        v->AddURL(bm0, bm_bar0, index, title, GURL(url));
     ASSERT_TRUE(nofavicon_bm != NULL);
   }
   for (int index = 0; index < 10; index++) {
@@ -622,29 +276,27 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     url.append(IntToString(index));
     url.append(".com");
     const BookmarkNode* nofavicon_bm =
-        verifier->AddURL(model_one, other_bm_one, index, title, GURL(url));
+        v->AddURL(bm0, bm_other0, index, title, GURL(url));
     ASSERT_TRUE(nofavicon_bm != NULL);
   }
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 // Test Scribe ID - 370563.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_AddSeveralBMsAndFolders) {
-
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-  const BookmarkNode* other_bm_one = model_one->other_node();
-
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-  // Let's add some bookmarks(without favicon)
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+  const BookmarkNode* bm_other0 = bm0->other_node();
+
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
+  // Let's add some GetBookmarkModel(without favicon)
   for (int index = 0; index < 15; index++) {
     int random_int = base::RandInt(1, 100);
     // To create randomness in order, 40% of time add bookmarks
@@ -655,13 +307,13 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
         url.append(IntToString(index));
         url.append(".com");
         const BookmarkNode* nofavicon_bm =
-            verifier->AddURL(model_one, bbn_one, index, title, GURL(url));
+            v->AddURL(bm0, bm_bar0, index, title, GURL(url));
         ASSERT_TRUE(nofavicon_bm != NULL);
     } else {
         // Remaining % of time - Add Bookmark folders
         wstring title(L"BB - TestBMFolder");
         title.append(IntToWString(index));
-        const BookmarkNode* bm_folder = verifier->AddGroup(model_one, bbn_one,
+        const BookmarkNode* bm_folder = v->AddGroup(bm0, bm_bar0,
             index, title);
         int random_int2 = base::RandInt(1, 100);
         // 60% of time we will add bookmarks to added folder
@@ -673,7 +325,7 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
               string url("http://www.nofaviconurl");
               url.append(IntToString(index));
               url.append(".com");
-              const BookmarkNode* nofavicon_bm = verifier->AddURL(model_one,
+              const BookmarkNode* nofavicon_bm = v->AddURL(bm0,
                     bm_folder, index, child_title, GURL(url));
               ASSERT_TRUE(nofavicon_bm != NULL);
             }
@@ -688,179 +340,167 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     url.append(IntToString(index));
     url.append(".com");
     const BookmarkNode* nofavicon_bm =
-        verifier->AddURL(model_one, other_bm_one, index, title, GURL(url));
+        v->AddURL(bm0, bm_other0, index, title, GURL(url));
     ASSERT_TRUE(nofavicon_bm != NULL);
   }
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 // Test Scribe ID - 370641.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_DuplicateBMWithDifferentURLSameName) {
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
 
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's add two bookmarks with different URL but same name
   {
-    const BookmarkNode* google_bm = verifier->AddURL(model_one, bbn_one, 0,
+    const BookmarkNode* google_bm = v->AddURL(bm0, bm_bar0, 0,
         L"Google", GURL("http://www.google.com"));
     ASSERT_TRUE(google_bm != NULL);
-    const BookmarkNode* google_news_bm = verifier->AddURL(model_one, bbn_one, 1,
+    const BookmarkNode* google_news_bm = v->AddURL(bm0, bm_bar0, 1,
         L"Google", GURL("http://www.google.com/news"));
     ASSERT_TRUE(google_news_bm != NULL);
   }
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 // Test Scribe ID - 371817.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_RenameBMName) {
-
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
     // Add first bookmark
-  const BookmarkNode* test_bm1 = verifier->AddURL(
-      model_one, bbn_one, 0, L"Test BM", GURL("http://www.bmtest.com"));
+  const BookmarkNode* test_bm1 = v->AddURL(
+      bm0, bm_bar0, 0, L"Test BM", GURL("http://www.bmtest.com"));
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   {
     // Rename recently added BM
-    verifier->SetTitle(model_one, test_bm1, L"New Test BM");
+    v->SetTitle(bm0, test_bm1, L"New Test BM");
   }
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 // Test Scribe ID - 371822.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_RenameBMURL) {
-
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
   // Let's add first bookmark(without favicon)
   const BookmarkNode* nofavicon_bm =
-      verifier->AddURL(model_one, bbn_one, 0, L"Google",
+      v->AddURL(bm0, bm_bar0, 0, L"Google",
           GURL("http://www.google.com"));
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's rename/change URL
-  nofavicon_bm = verifier->SetURL(model_one, nofavicon_bm,
+  nofavicon_bm = v->SetURL(bm0, nofavicon_bm,
       GURL("http://www.cnn.com"));
   // Wait for changes to sync and then verify
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 // Test Scribe ID - 371824.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_RenameBMFolder) {
-
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's add first bookmark folder to client1
-  const BookmarkNode* new_folder_one = verifier->AddGroup(model_one, bbn_one, 0,
+  const BookmarkNode* new_folder_one = v->AddGroup(bm0, bm_bar0, 0,
       L"TestBMFolder");
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Rename recently added Bookmark folder
-  verifier->SetTitle(model_one, new_folder_one, L"New TestBMFolder");
+  v->SetTitle(bm0, new_folder_one, L"New TestBMFolder");
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 // Test Scribe ID - 371825.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_RenameEmptyBMFolder) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
 
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's add first bookmark folder to client1
   const BookmarkNode* bm_folder_one =
-      verifier->AddGroup(model_one, bbn_one, 0, L"TestFolder");
+      v->AddGroup(bm0, bm_bar0, 0, L"TestFolder");
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's rename newly added bookmark folder
-  verifier->SetTitle(model_one, bm_folder_one, L"New TestFolder");
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  Cleanup();
+  v->SetTitle(bm0, bm_folder_one, L"New TestFolder");
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 // Test Scribe ID - 371826.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_RenameBMFolderWithLongHierarchy) {
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
 
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's add first bookmark folder to under bookmark_bar.
   const BookmarkNode* test_bm_folder =
-      verifier->AddGroup(model_one, bbn_one, 0, L"Test BMFolder");
+      v->AddGroup(bm0, bm_bar0, 0, L"Test BMFolder");
 
   // Let's add lots of bookmarks and folders underneath test_bm_folder.
   for (int index = 0; index < 120; index++) {
@@ -873,7 +513,7 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
         url.append(IntToString(index));
         url.append(".com");
         const BookmarkNode* nofavicon_bm =
-            verifier->AddURL(model_one, test_bm_folder, index,
+            v->AddURL(bm0, test_bm_folder, index,
             title, GURL(url));
         ASSERT_TRUE(nofavicon_bm != NULL);
     } else {
@@ -881,40 +521,37 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
         wstring title(L"Test BMFolder - ChildTestBMFolder");
         title.append(IntToWString(index));
         const BookmarkNode* bm_folder =
-            verifier->AddGroup(model_one, test_bm_folder, index, title);
+            v->AddGroup(bm0, test_bm_folder, index, title);
         ASSERT_TRUE(bm_folder != NULL);
     }
   }
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's rename test_bm_folder.
-  verifier->SetTitle(model_one, test_bm_folder, L"New TestBMFolder");
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  Cleanup();
+  v->SetTitle(bm0, test_bm_folder, L"New TestBMFolder");
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 // Test Scribe ID - 371827.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_RenameBMFolderThatHasParentAndChildren) {
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
 
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's add first bookmark folder to under bookmark_bar.
   const BookmarkNode* parent_bm_folder =
-      verifier->AddGroup(model_one, bbn_one, 0, L"Parent TestBMFolder");
+      v->AddGroup(bm0, bm_bar0, 0, L"Parent TestBMFolder");
 
   // Let's add few bookmarks under bookmark_bar.
   for (int index = 1; index < 15; index++) {
@@ -924,13 +561,13 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     url.append(IntToString(index));
     url.append(".com");
     const BookmarkNode* nofavicon_bm =
-        verifier->AddURL(model_one, bbn_one, index, title, GURL(url));
+        v->AddURL(bm0, bm_bar0, index, title, GURL(url));
     ASSERT_TRUE(nofavicon_bm != NULL);
   }
 
   // Let's add first bookmark folder under parent_bm_folder.
   const BookmarkNode* test_bm_folder =
-      verifier->AddGroup(model_one, parent_bm_folder, 0, L"Test BMFolder");
+      v->AddGroup(bm0, parent_bm_folder, 0, L"Test BMFolder");
   // Let's add lots of bookmarks and folders underneath test_bm_folder.
   for (int index = 0; index < 120; index++) {
     int random_int = base::RandInt(1, 100);
@@ -942,7 +579,7 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
         url.append(IntToString(index));
         url.append(".com");
         const BookmarkNode* nofavicon_bm =
-            verifier->AddURL(model_one, test_bm_folder, index,
+            v->AddURL(bm0, test_bm_folder, index,
             title, GURL(url));
         ASSERT_TRUE(nofavicon_bm != NULL);
     } else {
@@ -950,146 +587,139 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
         wstring title(L"Test BMFolder - ChildTestBMFolder");
         title.append(IntToWString(index));
         const BookmarkNode* bm_folder =
-            verifier->AddGroup(model_one, test_bm_folder, index, title);
+            v->AddGroup(bm0, test_bm_folder, index, title);
         ASSERT_TRUE(bm_folder != NULL);
     }
   }
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's rename test_bm_folder.
-  verifier->SetTitle(model_one, test_bm_folder, L"New TestBMFolder");
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  Cleanup();
+  v->SetTitle(bm0, test_bm_folder, L"New TestBMFolder");
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 // Test Scribe ID - 371828.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_RenameBMNameAndURL) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
   // Let's add first bookmark(without favicon)
   const BookmarkNode* nofavicon_bm =
-      verifier->AddURL(model_one, bbn_one, 0, L"Google",
+      v->AddURL(bm0, bm_bar0, 0, L"Google",
       GURL("http://www.google.com"));
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's change the URL.
-  nofavicon_bm = verifier->SetURL(model_one, nofavicon_bm,
+  nofavicon_bm = v->SetURL(bm0, nofavicon_bm,
       GURL("http://www.cnn.com"));
   // Let's change the Name.
-  verifier->SetTitle(model_one, nofavicon_bm, L"CNN");
+  v->SetTitle(bm0, nofavicon_bm, L"CNN");
   // Wait for changes to sync and then verify
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 // Test Scribe ID - 371832.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_DeleteBMEmptyAccountAfterwards) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
 
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's add first bookmark(without favicon)
   {
-    const BookmarkNode* nofavicon_bm = verifier->AddURL(model_one, bbn_one, 0,
+    const BookmarkNode* nofavicon_bm = v->AddURL(bm0, bm_bar0, 0,
         L"TestBookmark", GURL("http://www.nofaviconurl.com"));
     ASSERT_TRUE(nofavicon_bm != NULL);
   }
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   {
     // Delete this newly created bookmark
-    verifier->Remove(model_one, bbn_one, 0);
+    v->Remove(bm0, bm_bar0, 0);
   }
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
   // Make sure that client2 has pushed all of it's changes as well.
-  ASSERT_TRUE(client2()->AwaitMutualSyncCycleCompletion(client1()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  Cleanup();
+  ASSERT_TRUE(GetClient(1)->AwaitMutualSyncCycleCompletion(GetClient(0)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 // Test Scribe ID - 371833.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_DelBMNonEmptyAccountAfterwards) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-  // Let's add some bookmarks(without favicon)
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
+  // Let's add some GetBookmarkModel(without favicon)
   for (int index = 0; index < 20; index++) {
     wstring title(L"TestBookmark");
     title.append(IntToWString(index));
     string url("http://www.nofaviconurl");
     url.append(IntToString(index));
     url.append(".com");
-    const BookmarkNode* nofavicon_bm = verifier->AddURL(
-        model_one, bbn_one, index,
+    const BookmarkNode* nofavicon_bm = v->AddURL(
+        bm0, bm_bar0, index,
         title, GURL(url));
     ASSERT_TRUE(nofavicon_bm != NULL);
   }
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   {
     // Delete this newly created bookmark
-    verifier->Remove(model_one, bbn_one, 0);
+    v->Remove(bm0, bm_bar0, 0);
   }
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 
 // Test Scribe ID - 371835.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_DelFirstBMUnderBMFoldNonEmptyFoldAfterwards) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
   // Let's add first bookmark folder to client1
   const BookmarkNode* bm_folder_one =
-      verifier->AddGroup(model_one, bbn_one, 0, L"TestFolder");
-  // Let's add some bookmarks(without favicon) to this folder
+      v->AddGroup(bm0, bm_bar0, 0, L"TestFolder");
+  // Let's add some GetBookmarkModel(without favicon) to this folder
   for (int index = 0; index < 10; index++) {
     wstring title(L"TestBookmark");
     title.append(IntToWString(index));
@@ -1097,83 +727,79 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     url.append(IntToString(index));
     url.append(".com");
     const BookmarkNode* nofavicon_bm =
-        verifier->AddURL(model_one, bm_folder_one, index, title, GURL(url));
+        v->AddURL(bm0, bm_folder_one, index, title, GURL(url));
     ASSERT_TRUE(nofavicon_bm != NULL);
   }
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   {
     // Delete first bookmark under this folder
-    verifier->Remove(model_one, bm_folder_one, 0);
+    v->Remove(bm0, bm_folder_one, 0);
   }
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 
 // Test Scribe ID - 371836.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_DelLastBMUnderBMFoldNonEmptyFoldAfterwards) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
   // Let's add first bookmark folder to client1
-  const BookmarkNode* bm_folder_one = verifier->AddGroup(model_one, bbn_one,
+  const BookmarkNode* bm_folder_one = v->AddGroup(bm0, bm_bar0,
       0, L"TestFolder");
-  // Let's add some bookmarks(without favicon) to this folder
+  // Let's add some GetBookmarkModel(without favicon) to this folder
   for (int index = 0; index < 10; index++) {
     wstring title(L"TestBookmark");
     title.append(IntToWString(index));
     string url("http://www.nofaviconurl");
     url.append(IntToString(index));
     url.append(".com");
-    const BookmarkNode* nofavicon_bm = verifier->AddURL(
-        model_one, bm_folder_one,
+    const BookmarkNode* nofavicon_bm = v->AddURL(
+        bm0, bm_folder_one,
         index, title, GURL(url));
     ASSERT_TRUE(nofavicon_bm != NULL);
   }
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   {
     // Delete last bookmark under this folder
-    verifier->Remove(model_one, bm_folder_one,
+    v->Remove(bm0, bm_folder_one,
         (bm_folder_one->GetChildCount() - 1));
   }
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 
 // Test Scribe ID - 371856.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_DelMiddleBMUnderBMFoldNonEmptyFoldAfterwards) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
   // Let's add first bookmark folder to client1
   const BookmarkNode* bm_folder_one =
-    verifier->AddGroup(model_one, bbn_one, 0, L"TestFolder");
-  // Let's add some bookmarks(without favicon) to this folder
+    v->AddGroup(bm0, bm_bar0, 0, L"TestFolder");
+  // Let's add some GetBookmarkModel(without favicon) to this folder
   for (int index = 0; index < 10; index++) {
     wstring title(L"TestBookmark");
     title.append(IntToWString(index));
@@ -1181,40 +807,38 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     url.append(IntToString(index));
     url.append(".com");
     const BookmarkNode* nofavicon_bm =
-        verifier->AddURL(model_one, bm_folder_one, index, title, GURL(url));
+        v->AddURL(bm0, bm_folder_one, index, title, GURL(url));
     ASSERT_TRUE(nofavicon_bm != NULL);
   }
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   {
     // Delete middle bookmark under this folder
-    verifier->Remove(model_one, bm_folder_one, 4);
+    v->Remove(bm0, bm_folder_one, 4);
   }
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 
 // Test Scribe ID - 371857.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_DelBMsUnderBMFoldEmptyFolderAfterwards) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
   // Let's add first bookmark folder to client1
   const BookmarkNode* bm_folder_one =
-    verifier->AddGroup(model_one, bbn_one, 0, L"TestFolder");
-  // Let's add some bookmarks(without favicon) to this folder
+    v->AddGroup(bm0, bm_bar0, 0, L"TestFolder");
+  // Let's add some GetBookmarkModel(without favicon) to this folder
   for (int index = 0; index < 10; index++) {
     wstring title(L"TestBookmark");
     title.append(IntToWString(index));
@@ -1222,73 +846,70 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     url.append(IntToString(index));
     url.append(".com");
     const BookmarkNode* nofavicon_bm =
-        verifier->AddURL(model_one, bm_folder_one, index, title, GURL(url));
+        v->AddURL(bm0, bm_folder_one, index, title, GURL(url));
     ASSERT_TRUE(nofavicon_bm != NULL);
   }
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
   int child_count = bm_folder_one->GetChildCount();
   // Let's delete all the bookmarks added under this new folder
   for (int index = 0; index < child_count; index++) {
-    verifier->Remove(model_one, bm_folder_one, 0);
-    ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-    verifier->ExpectMatch(model_one);
-    verifier->ExpectMatch(model_two);
+    v->Remove(bm0, bm_folder_one, 0);
+    ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+    v->ExpectMatch(bm0);
+    v->ExpectMatch(bm1);
   }
-  Cleanup();
 }
 
 // Test Scribe ID - 371858.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_DelEmptyBMFoldEmptyAccountAfterwards) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
 
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's add first bookmark folder to client1
   const BookmarkNode* bm_folder_one =
-    verifier->AddGroup(model_one, bbn_one, 0, L"TestFolder");
+    v->AddGroup(bm0, bm_bar0, 0, L"TestFolder");
   ASSERT_TRUE(bm_folder_one != NULL);
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's delete this empty bookmark folder
-  verifier->Remove(model_one, bbn_one, 0);
-
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  v->Remove(bm0, bm_bar0, 0);
 
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 
 // Test Scribe ID - 371869.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_DelEmptyBMFoldNonEmptyAccountAfterwards) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-  const BookmarkNode* other_bm_one = model_one->other_node();
-  ASSERT_TRUE(other_bm_one != NULL);
-
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+  const BookmarkNode* bm_other0 = bm0->other_node();
+  ASSERT_TRUE(bm_other0 != NULL);
+
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
   // Let's add first bookmark folder to client1
   const BookmarkNode* bm_folder_one =
-      verifier->AddGroup(model_one, bbn_one, 0, L"TestFolder");
+      v->AddGroup(bm0, bm_bar0, 0, L"TestFolder");
   ASSERT_TRUE(bm_folder_one != NULL);
-  // Let's add some bookmarks(without favicon)
+  // Let's add some GetBookmarkModel(without favicon)
   for (int index = 1; index < 15; index++) {
     int random_int = base::RandInt(1, 100);
     // To create randomness in order, 40% of time add bookmarks
@@ -1298,53 +919,51 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
       string url("http://www.nofaviconurl");
       url.append(IntToString(index));
       url.append(".com");
-      const BookmarkNode* nofavicon_bm = verifier->AddURL(model_one, bbn_one,
+      const BookmarkNode* nofavicon_bm = v->AddURL(bm0, bm_bar0,
           index, title, GURL(url));
       ASSERT_TRUE(nofavicon_bm != NULL);
     } else {
       // Remaining % of time - Add Bookmark folders
       wstring title(L"BB - TestBMFolder");
       title.append(IntToWString(index));
-      const BookmarkNode* bm_folder = verifier->AddGroup(model_one, bbn_one,
+      const BookmarkNode* bm_folder = v->AddGroup(bm0, bm_bar0,
           index, title);
       ASSERT_TRUE(bm_folder != NULL);
      }
   }
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's delete the first empty bookmark folder
-  verifier->Remove(model_one, bbn_one, 0);
+  v->Remove(bm0, bm_bar0, 0);
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 // Test Scribe ID - 371879.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_DelBMFoldWithBMsNonEmptyAccountAfterwards) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-  ASSERT_TRUE(bbn_one != NULL);
-  const BookmarkNode* other_bm_one = model_one->other_node();
-  ASSERT_TRUE(other_bm_one != NULL);
-
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+  ASSERT_TRUE(bm_bar0 != NULL);
+  const BookmarkNode* bm_other0 = bm0->other_node();
+  ASSERT_TRUE(bm_other0 != NULL);
+
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
   // Let's add bookmark and bookmark folder to client1
-  const BookmarkNode* yahoo = verifier->AddURL(model_one, bbn_one, 0,
+  const BookmarkNode* yahoo = v->AddURL(bm0, bm_bar0, 0,
       L"Yahoo!", GURL("http://www.yahoo.com"));
   ASSERT_TRUE(yahoo != NULL);
   const BookmarkNode* bm_folder_one =
-      verifier->AddGroup(model_one, bbn_one, 1, L"TestFolder");
-  // Let's add some bookmarks(without favicon) and folders to
+      v->AddGroup(bm0, bm_bar0, 1, L"TestFolder");
+  // Let's add some GetBookmarkModel(without favicon) and folders to
   // bookmark bar
   for (int index = 2; index < 10; index++) {
     int random_int = base::RandInt(1, 100);
@@ -1355,14 +974,14 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
         string url("http://www.nofaviconurl");
         url.append(IntToString(index));
         url.append(".com");
-        const BookmarkNode* nofavicon_bm = verifier->AddURL(model_one, bbn_one,
+        const BookmarkNode* nofavicon_bm = v->AddURL(bm0, bm_bar0,
             index, title, GURL(url));
         ASSERT_TRUE(nofavicon_bm != NULL);
     } else {
         // Remaining % of time - Add Bookmark folders
         wstring title(L"BB - TestBMFolder");
         title.append(IntToWString(index));
-        const BookmarkNode* bm_folder = verifier->AddGroup(model_one, bbn_one,
+        const BookmarkNode* bm_folder = v->AddGroup(bm0, bm_bar0,
             index, title);
         ASSERT_TRUE(bm_folder != NULL);
      }
@@ -1375,45 +994,43 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     string url("http://www.nofaviconurl");
     url.append(IntToString(index));
     url.append(".com");
-    const BookmarkNode* nofavicon_bm = verifier->AddURL(model_one,
+    const BookmarkNode* nofavicon_bm = v->AddURL(bm0,
         bm_folder_one, index, title, GURL(url));
     ASSERT_TRUE(nofavicon_bm != NULL);
   }
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's delete the bookmark folder (bm_folder_one)
-  verifier->Remove(model_one, bbn_one, 1);
-
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  v->Remove(bm0, bm_bar0, 1);
 
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 
 // Test Scribe ID - 371880.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_DelBMFoldWithBMsAndBMFoldsNonEmptyACAfterwards) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-  const BookmarkNode* other_bm_one = model_one->other_node();
-  ASSERT_TRUE(other_bm_one != NULL);
-
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+  const BookmarkNode* bm_other0 = bm0->other_node();
+  ASSERT_TRUE(bm_other0 != NULL);
+
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
   // Let's add bookmark and bookmark folder to client1
-  const BookmarkNode* yahoo = verifier->AddURL(model_one, bbn_one, 0,
+  const BookmarkNode* yahoo = v->AddURL(bm0, bm_bar0, 0,
       L"Yahoo", GURL("http://www.yahoo.com"));
   ASSERT_TRUE(yahoo != NULL);
   const BookmarkNode* bm_folder_one =
-      verifier->AddGroup(model_one, bbn_one, 1, L"TestFolder");
-  // Let's add some bookmarks(without favicon) and folders to
+      v->AddGroup(bm0, bm_bar0, 1, L"TestFolder");
+  // Let's add some GetBookmarkModel(without favicon) and folders to
   // bookmark bar
   for (int index = 2; index < 10; index++) {
     int random_int = base::RandInt(1, 100);
@@ -1424,20 +1041,20 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
         string url("http://www.nofaviconurl");
         url.append(IntToString(index));
         url.append(".com");
-        const BookmarkNode* nofavicon_bm = verifier->AddURL(model_one, bbn_one,
+        const BookmarkNode* nofavicon_bm = v->AddURL(bm0, bm_bar0,
             index, title, GURL(url));
         ASSERT_TRUE(nofavicon_bm != NULL);
     } else {
         // Remaining % of time - Add Bookmark folders
         wstring title(L"BB - TestBMFolder");
         title.append(IntToWString(index));
-        const BookmarkNode* bm_folder = verifier->AddGroup(model_one, bbn_one,
+        const BookmarkNode* bm_folder = v->AddGroup(bm0, bm_bar0,
             index, title);
         ASSERT_TRUE(bm_folder != NULL);
      }
   }
 
-  // Let's add some bookmarks(without favicon) and folders to
+  // Let's add some GetBookmarkModel(without favicon) and folders to
   // bm_folder_one ('TestFolder')
   for (int index = 0; index < 10; index++) {
     int random_int = base::RandInt(1, 100);
@@ -1448,14 +1065,14 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
       string url("http://www.nofaviconurl");
       url.append(IntToString(index));
       url.append(".com");
-      const BookmarkNode* nofavicon_bm = verifier->AddURL(model_one,
+      const BookmarkNode* nofavicon_bm = v->AddURL(bm0,
           bm_folder_one, index, title, GURL(url));
       ASSERT_TRUE(nofavicon_bm != NULL);
     } else {
         // Remaining % of time - Add Bookmark folders
         wstring title(L"Level2 - TestBMFolder");
         title.append(IntToWString(index));
-        const BookmarkNode* l2_bm_folder = verifier->AddGroup(model_one,
+        const BookmarkNode* l2_bm_folder = v->AddGroup(bm0,
             bm_folder_one, index, title);
         int random_int2 = base::RandInt(1, 100);
         // 70% of time - Let's add more levels of bookmarks and folders to
@@ -1470,7 +1087,7 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
               string url("http://www.nofaviconurl");
               url.append(IntToString(index));
               url.append(".com");
-              const BookmarkNode* nofavicon_bm = verifier->AddURL(model_one,
+              const BookmarkNode* nofavicon_bm = v->AddURL(bm0,
                   l2_bm_folder, index2, title, GURL(url));
               ASSERT_TRUE(nofavicon_bm != NULL);
             } else {
@@ -1478,43 +1095,41 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
                 wstring title(L"Level3 - TestBMFolder");
                 title.append(IntToWString(index));
                 const BookmarkNode* l3_bm_folder =
-                    verifier->AddGroup(model_one, l2_bm_folder, index2, title);
+                    v->AddGroup(bm0, l2_bm_folder, index2, title);
                 ASSERT_TRUE(l3_bm_folder != NULL);
              }
           }  // end inner for loop
         }
      }
     }
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's delete the bookmark folder (bm_folder_one)
-  verifier->Remove(model_one, bbn_one, 1);
+  v->Remove(bm0, bm_bar0, 1);
 
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 // Test Scribe ID - 371882.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_DelBMFoldWithParentAndChildrenBMsAndBMFolds) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
 
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's add first bookmark folder to under bookmark_bar.
   const BookmarkNode* parent_bm_folder =
-      verifier->AddGroup(model_one, bbn_one, 0, L"Parent TestBMFolder");
+      v->AddGroup(bm0, bm_bar0, 0, L"Parent TestBMFolder");
 
   // Let's add few bookmarks under bookmark_bar.
   for (int index = 1; index < 11; index++) {
@@ -1524,13 +1139,13 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     url.append(IntToString(index));
     url.append(".com");
     const BookmarkNode* nofavicon_bm =
-        verifier->AddURL(model_one, bbn_one, index, title, GURL(url));
+        v->AddURL(bm0, bm_bar0, index, title, GURL(url));
     ASSERT_TRUE(nofavicon_bm != NULL);
   }
 
   // Let's add first bookmark folder under parent_bm_folder.
   const BookmarkNode* test_bm_folder =
-      verifier->AddGroup(model_one, parent_bm_folder, 0, L"Test BMFolder");
+      v->AddGroup(bm0, parent_bm_folder, 0, L"Test BMFolder");
   // Let's add lots of bookmarks and folders underneath test_bm_folder.
   for (int index = 0; index < 30; index++) {
     int random_int = base::RandInt(1, 100);
@@ -1542,7 +1157,7 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
         url.append(IntToString(index));
         url.append(".com");
         const BookmarkNode* nofavicon_bm =
-            verifier->AddURL(model_one, test_bm_folder, index, title,
+            v->AddURL(bm0, test_bm_folder, index, title,
             GURL(url));
         ASSERT_TRUE(nofavicon_bm != NULL);
     } else {
@@ -1550,71 +1165,66 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
         wstring title(L"Test BMFolder - ChildTestBMFolder");
         title.append(IntToWString(index));
         const BookmarkNode* bm_folder =
-            verifier->AddGroup(model_one, test_bm_folder, index, title);
+            v->AddGroup(bm0, test_bm_folder, index, title);
         ASSERT_TRUE(bm_folder != NULL);
     }
   }
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's delete test_bm_folder
-  verifier->Remove(model_one, parent_bm_folder, 0);
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  Cleanup();
+  v->Remove(bm0, parent_bm_folder, 0);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 
 // Test Scribe ID - 371931.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_ReverseTheOrderOfTwoBMs) {
-
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  const BookmarkNode* bm_a = verifier->AddURL(
-      model_one, bbn_one, 0, L"Bookmark A",
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
+
+  const BookmarkNode* bm_a = v->AddURL(
+      bm0, bm_bar0, 0, L"Bookmark A",
       GURL("http://www.nofaviconurla.com"));
   ASSERT_TRUE(bm_a != NULL);
-  const BookmarkNode* bm_b = verifier->AddURL(
-      model_one, bbn_one, 1, L"Bookmark B",
+  const BookmarkNode* bm_b = v->AddURL(
+      bm0, bm_bar0, 1, L"Bookmark B",
       GURL("http://www.nofaviconurlb.com"));
   ASSERT_TRUE(bm_b != NULL);
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   {
     // Move bm_a to new position
-    verifier->Move(model_one, bm_a, bbn_one, 2);
+    v->Move(bm0, bm_a, bm_bar0, 2);
   }
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 // Test Scribe ID - 371933.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_ReverseTheOrderOf10BMs) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's add 10 bookmarks like 0123456789
   for (int index = 0; index < 10; index++) {
@@ -1623,143 +1233,139 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     string url("http://www.nofaviconurl-");
     url.append(IntToString(index));
     url.append(".com");
-    const BookmarkNode* nofavicon_bm = verifier->AddURL(model_one,
-        bbn_one, index, title, GURL(url));
+    const BookmarkNode* nofavicon_bm = v->AddURL(bm0,
+        bm_bar0, index, title, GURL(url));
     ASSERT_TRUE(nofavicon_bm != NULL);
   }
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Shuffle bookmarks to make it look like 9876543210
-  verifier->ReverseChildOrder(model_one, bbn_one);
+  v->ReverseChildOrder(bm0, bm_bar0);
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 // Test Scribe ID - 371954.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_MovingBMsFromBMBarToBMFolder) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-  const BookmarkNode* other_bm_one = model_one->other_node();
-  ASSERT_TRUE(other_bm_one != NULL);
-
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+  const BookmarkNode* bm_other0 = bm0->other_node();
+  ASSERT_TRUE(bm_other0 != NULL);
+
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
   // Let's add bookmark and bookmark folder to client1
-  const BookmarkNode* yahoo = verifier->AddURL(model_one, bbn_one, 0,
+  const BookmarkNode* yahoo = v->AddURL(bm0, bm_bar0, 0,
       L"Yahoo", GURL("http://www.yahoo.com"));
   ASSERT_TRUE(yahoo != NULL);
   const BookmarkNode* bm_folder_one =
-      verifier->AddGroup(model_one, bbn_one, 1, L"TestFolder");
-  // Let's add some bookmarks(without favicon) to bookmark bar
+      v->AddGroup(bm0, bm_bar0, 1, L"TestFolder");
+  // Let's add some GetBookmarkModel(without favicon) to bookmark bar
   for (int index = 2; index < 10; index++) {
     wstring title(L"BB - TestBookmark");
     title.append(IntToWString(index));
     string url("http://www.nofaviconurl");
     url.append(IntToString(index));
     url.append(".com");
-    const BookmarkNode* nofavicon_bm = verifier->AddURL(model_one, bbn_one,
+    const BookmarkNode* nofavicon_bm = v->AddURL(bm0, bm_bar0,
         index, title, GURL(url));
     ASSERT_TRUE(nofavicon_bm != NULL);
   }
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's move bookmarks from bookmark bar to BMfolder (bm_folder_one)
-  int child_count_to_move = bbn_one->GetChildCount() - 2;
+  int child_count_to_move = bm_bar0->GetChildCount() - 2;
   for (int index = 0; index < child_count_to_move; index++) {
-    verifier->Move(model_one, bbn_one->GetChild(2),
+    v->Move(bm0, bm_bar0->GetChild(2),
         bm_folder_one, index);
-    ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-    verifier->ExpectMatch(model_one);
-    verifier->ExpectMatch(model_two);
+    ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+    v->ExpectMatch(bm0);
+    v->ExpectMatch(bm1);
   }
-  Cleanup();
 }
 
 // Test Scribe ID - 371957.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_MovingBMsFromBMFoldToBMBar) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-  const BookmarkNode* other_bm_one = model_one->other_node();
-  ASSERT_TRUE(other_bm_one != NULL);
-
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+  const BookmarkNode* bm_other0 = bm0->other_node();
+  ASSERT_TRUE(bm_other0 != NULL);
+
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
   // Let's add bookmark and bookmark folder to client1
-  const BookmarkNode* yahoo = verifier->AddURL(model_one, bbn_one, 0,
+  const BookmarkNode* yahoo = v->AddURL(bm0, bm_bar0, 0,
       L"Yahoo", GURL("http://www.yahoo.com"));
   ASSERT_TRUE(yahoo != NULL);
   const BookmarkNode* bm_folder_one =
-      verifier->AddGroup(model_one, bbn_one, 1, L"TestFolder");
-  // Let's add some bookmarks(without favicon) to bm_folder_one
+      v->AddGroup(bm0, bm_bar0, 1, L"TestFolder");
+  // Let's add some GetBookmarkModel(without favicon) to bm_folder_one
   for (int index = 0; index < 10; index++) {
     wstring title(L"BB - TestBookmark");
     title.append(IntToWString(index));
     string url("http://www.nofaviconurl");
     url.append(IntToString(index));
     url.append(".com");
-    const BookmarkNode* nofavicon_bm = verifier->AddURL(model_one,
+    const BookmarkNode* nofavicon_bm = v->AddURL(bm0,
         bm_folder_one, index, title, GURL(url));
     ASSERT_TRUE(nofavicon_bm != NULL);
   }
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's move bookmarks from BMfolder(bm_folder_one) to bookmark bar
   int child_count_to_move = bm_folder_one->GetChildCount();
   for (int index = 0; index < child_count_to_move; index++) {
-    verifier->Move(model_one, bm_folder_one->GetChild(0),
-        bbn_one, bbn_one->GetChildCount());
-    ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-    verifier->ExpectMatch(model_one);
-    verifier->ExpectMatch(model_two);
+    v->Move(bm0, bm_folder_one->GetChild(0),
+        bm_bar0, bm_bar0->GetChildCount());
+    ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+    v->ExpectMatch(bm0);
+    v->ExpectMatch(bm1);
   }
-  Cleanup();
 }
 
 // Test Scribe ID - 371961.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_MovingBMsFromParentBMFoldToChildBMFold) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   const BookmarkNode* parent_folder =
-      verifier->AddGroup(model_one, bbn_one, 0, L"Test Parent BMFolder");
+      v->AddGroup(bm0, bm_bar0, 0, L"Test Parent BMFolder");
 
   // Let's add bookmarks a,b,c to parent_folder.
-  const BookmarkNode* bm_a = verifier->AddURL(
-      model_one, parent_folder, 0, L"Bookmark A",
+  const BookmarkNode* bm_a = v->AddURL(
+      bm0, parent_folder, 0, L"Bookmark A",
       GURL("http://www.nofaviconurl-a.com"));
-  const BookmarkNode* bm_b = verifier->AddURL(
-      model_one, parent_folder, 1, L"Bookmark B",
+  const BookmarkNode* bm_b = v->AddURL(
+      bm0, parent_folder, 1, L"Bookmark B",
       GURL("http://www.nofaviconurl-b.com"));
-  const BookmarkNode* bm_c = verifier->AddURL(
-      model_one, parent_folder, 2, L"Bookmark C",
+  const BookmarkNode* bm_c = v->AddURL(
+      bm0, parent_folder, 2, L"Bookmark C",
       GURL("http://www.nofaviconurl-c.com"));
   const BookmarkNode* child_folder =
-      verifier->AddGroup(model_one, parent_folder, 3, L"Test Child BMFolder");
+      v->AddGroup(bm0, parent_folder, 3, L"Test Child BMFolder");
 
   // Let's add few bookmarks under child_folder.
   for (int index = 0; index < 10; index++) {
@@ -1769,112 +1375,108 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     url.append(IntToString(index));
     url.append(".com");
     const BookmarkNode* nofavicon_bm =
-        verifier->AddURL(model_one, child_folder, index, title, GURL(url));
+        v->AddURL(bm0, child_folder, index, title, GURL(url));
     ASSERT_TRUE(nofavicon_bm != NULL);
   }
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's move bookmark a,b,c to child_folder.
-  verifier->Move(model_one, bm_a, child_folder, 10);
-  verifier->Move(model_one, bm_b, child_folder, 11);
-  verifier->Move(model_one, bm_c, child_folder, 12);
-
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  v->Move(bm0, bm_a, child_folder, 10);
+  v->Move(bm0, bm_b, child_folder, 11);
+  v->Move(bm0, bm_c, child_folder, 12);
 
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 
 // Test Scribe ID - 371964.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_MovingBMsFromChildBMFoldToParentBMFold) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   const BookmarkNode* parent_folder =
-      verifier->AddGroup(model_one, bbn_one, 0, L"Test Parent BMFolder");
+      v->AddGroup(bm0, bm_bar0, 0, L"Test Parent BMFolder");
 
   // Let's add bookmarks a,b,c to parent_folder.
-  const BookmarkNode* bm_a = verifier->AddURL(
-      model_one, parent_folder, 0, L"Bookmark A",
+  const BookmarkNode* bm_a = v->AddURL(
+      bm0, parent_folder, 0, L"Bookmark A",
       GURL("http://www.nofaviconurl-a.com"));
   ASSERT_TRUE(bm_a != NULL);
-  const BookmarkNode* bm_b = verifier->AddURL(
-      model_one, parent_folder, 1, L"Bookmark B",
+  const BookmarkNode* bm_b = v->AddURL(
+      bm0, parent_folder, 1, L"Bookmark B",
       GURL("http://www.nofaviconurl-b.com"));
   ASSERT_TRUE(bm_b != NULL);
-  const BookmarkNode* bm_c = verifier->AddURL(
-      model_one, parent_folder, 2, L"Bookmark C",
+  const BookmarkNode* bm_c = v->AddURL(
+      bm0, parent_folder, 2, L"Bookmark C",
       GURL("http://www.nofaviconurl-c.com"));
   ASSERT_TRUE(bm_c != NULL);
   const BookmarkNode* child_folder =
-      verifier->AddGroup(model_one, parent_folder, 3, L"Test Child BMFolder");
+      v->AddGroup(bm0, parent_folder, 3, L"Test Child BMFolder");
 
   // Let's add bookmarks d,e,f,g,h to child_folder.
-  const BookmarkNode* bm_d = verifier->AddURL(
-      model_one, child_folder, 0, L"Bookmark D",
+  const BookmarkNode* bm_d = v->AddURL(
+      bm0, child_folder, 0, L"Bookmark D",
       GURL("http://www.nofaviconurl-d.com"));
   ASSERT_TRUE(bm_d != NULL);
-  const BookmarkNode* bm_e = verifier->AddURL(
-      model_one, child_folder, 1, L"Bookmark E",
+  const BookmarkNode* bm_e = v->AddURL(
+      bm0, child_folder, 1, L"Bookmark E",
       GURL("http://www.nofaviconurl-e.com"));
   ASSERT_TRUE(bm_e != NULL);
-  const BookmarkNode* bm_f = verifier->AddURL(
-      model_one, child_folder, 2, L"Bookmark F",
+  const BookmarkNode* bm_f = v->AddURL(
+      bm0, child_folder, 2, L"Bookmark F",
       GURL("http://www.nofaviconurl-f.com"));
   ASSERT_TRUE(bm_f != NULL);
-  const BookmarkNode* bm_g = verifier->AddURL(
-      model_one, child_folder, 3, L"Bookmark G",
+  const BookmarkNode* bm_g = v->AddURL(
+      bm0, child_folder, 3, L"Bookmark G",
       GURL("http://www.nofaviconurl-g.com"));
   ASSERT_TRUE(bm_g != NULL);
-  const BookmarkNode* bm_h = verifier->AddURL(
-      model_one, child_folder, 4, L"Bookmark H",
+  const BookmarkNode* bm_h = v->AddURL(
+      bm0, child_folder, 4, L"Bookmark H",
       GURL("http://www.nofaviconurl-h.com"));
   ASSERT_TRUE(bm_h != NULL);
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's move bookmark d,e,h to parent_folder.
-  verifier->Move(model_one, bm_d, parent_folder, 4);
-  verifier->Move(model_one, bm_e, parent_folder, 3);
-  verifier->Move(model_one, bm_h, parent_folder, 0);
+  v->Move(bm0, bm_d, parent_folder, 4);
+  v->Move(bm0, bm_e, parent_folder, 3);
+  v->Move(bm0, bm_h, parent_folder, 0);
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 
 // Test Scribe ID - 371967.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_HoistBMs10LevelUp) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-  const BookmarkNode* bm_folder = bbn_one;
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
+  const BookmarkNode* bm_folder = bm_bar0;
   const BookmarkNode* bm_folder_L10 = NULL;
   const BookmarkNode* bm_folder_L0 = NULL;
   for (int level = 0; level < 15; level++) {
-    // Let's add some bookmarks(without favicon) to bm_folder.
+    // Let's add some GetBookmarkModel(without favicon) to bm_folder.
     int child_count = base::RandInt(0, 10);
     for (int index = 0; index < child_count; index++) {
       wstring title(bm_folder->GetTitle());
@@ -1883,14 +1485,14 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
       title.append(IntToWString(index));
       url.append(IntToString(index));
       url.append(".com");
-      const BookmarkNode* nofavicon_bm = verifier->AddURL(model_one,
+      const BookmarkNode* nofavicon_bm = v->AddURL(bm0,
           bm_folder, index, title, GURL(url));
       ASSERT_TRUE(nofavicon_bm != NULL);
     }
     wstring title(L"Test BMFolder-");
     title.append(IntToWString(level));
 
-    bm_folder = verifier->AddGroup(model_one,
+    bm_folder = v->AddGroup(bm0,
         bm_folder, bm_folder->GetChildCount(), title);
     // Let's remember first bm folder for later use.
     if (level == 0) {
@@ -1901,50 +1503,48 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
       bm_folder_L10 = bm_folder;
     }
   }
-  const BookmarkNode* bm_a = verifier->AddURL(model_one,
+  const BookmarkNode* bm_a = v->AddURL(bm0,
       bm_folder_L10, bm_folder_L10->GetChildCount(), L"BM-A",
       GURL("http://www.bm-a.com"));
-  const BookmarkNode* bm_b = verifier->AddURL(model_one,
+  const BookmarkNode* bm_b = v->AddURL(bm0,
       bm_folder_L10, bm_folder_L10->GetChildCount(), L"BM-B",
       GURL("http://www.bm-b.com"));
-  const BookmarkNode* bm_c = verifier->AddURL(model_one,
+  const BookmarkNode* bm_c = v->AddURL(bm0,
       bm_folder_L10, bm_folder_L10->GetChildCount(), L"BM-C",
       GURL("http://www.bm-c.com"));
   // Let's wait till all the changes populate to another client.
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's move bookmark a from bm_folder_L10 to first bookmark folder- at end.
-  verifier->Move(model_one, bm_a, bm_folder_L0, bm_folder_L0->GetChildCount());
+  v->Move(bm0, bm_a, bm_folder_L0, bm_folder_L0->GetChildCount());
   // Let's move bookmark b to first bookmark folder- at the beginning.
-  verifier->Move(model_one, bm_b, bm_folder_L0, 0);
+  v->Move(bm0, bm_b, bm_folder_L0, 0);
   // Let's move bookmark c to first bookmark folder- in the middle.
-  verifier->Move(model_one, bm_c, bm_folder_L0, 1);
-
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  v->Move(bm0, bm_c, bm_folder_L0, 1);
 
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 // Test Scribe ID - 371968.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_SinkBMs10LevelDown) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-  const BookmarkNode* bm_folder = bbn_one;
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
+  const BookmarkNode* bm_folder = bm_bar0;
   const BookmarkNode* bm_folder_L10 = NULL;
   const BookmarkNode* bm_folder_L0 = NULL;
   for (int level = 0; level < 15; level++) {
-    // Let's add some bookmarks(without favicon) to bm_folder.
+    // Let's add some GetBookmarkModel(without favicon) to bm_folder.
     int child_count = base::RandInt(0, 10);
     for (int index = 0; index < child_count; index++) {
       wstring title(bm_folder->GetTitle());
@@ -1953,14 +1553,14 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
       title.append(IntToWString(index));
       url.append(IntToString(index));
       url.append(".com");
-      const BookmarkNode* nofavicon_bm = verifier->AddURL(model_one,
+      const BookmarkNode* nofavicon_bm = v->AddURL(bm0,
           bm_folder, index, title, GURL(url));
       ASSERT_TRUE(nofavicon_bm != NULL);
     }
     wstring title(L"Test BMFolder-");
     title.append(IntToWString(level));
 
-    bm_folder = verifier->AddGroup(model_one,
+    bm_folder = v->AddGroup(bm0,
         bm_folder, bm_folder->GetChildCount(), title);
     // Let's remember first bm folder for later use.
     if (level == 0) {
@@ -1971,53 +1571,51 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
       bm_folder_L10 = bm_folder;
     }
   }
-  const BookmarkNode* bm_a = verifier->AddURL(model_one,
+  const BookmarkNode* bm_a = v->AddURL(bm0,
       bm_folder_L10, bm_folder_L0->GetChildCount(), L"BM-A",
       GURL("http://www.bm-a.com"));
-  const BookmarkNode* bm_b = verifier->AddURL(model_one,
+  const BookmarkNode* bm_b = v->AddURL(bm0,
       bm_folder_L10, bm_folder_L0->GetChildCount(), L"BM-B",
       GURL("http://www.bm-b.com"));
-  const BookmarkNode* bm_c = verifier->AddURL(model_one,
+  const BookmarkNode* bm_c = v->AddURL(bm0,
       bm_folder_L10, bm_folder_L0->GetChildCount(), L"BM-C",
       GURL("http://www.bm-c.com"));
   // Let's wait till all the changes populate to another client.
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's move bookmark a from bm_folder_L10 to first bookmark
   // folder- at end.
-  verifier->Move(model_one, bm_a, bm_folder_L10,
+  v->Move(bm0, bm_a, bm_folder_L10,
       bm_folder_L10->GetChildCount());
   // Let's move bookmark b to first bookmark folder- at the beginning.
-  verifier->Move(model_one, bm_b, bm_folder_L10, 0);
+  v->Move(bm0, bm_b, bm_folder_L10, 0);
   // Let's move bookmark c to first bookmark folder- in the middle.
-  verifier->Move(model_one, bm_c, bm_folder_L10, 1);
+  v->Move(bm0, bm_c, bm_folder_L10, 1);
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 
 // Test Scribe ID - 371980.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_SinkEmptyBMFold5LevelsDown) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
 
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
-  const BookmarkNode* bm_folder = bbn_one;
+  const BookmarkNode* bm_folder = bm_bar0;
   const BookmarkNode* bm_folder_L5 = NULL;
   for (int level = 0; level < 6; level++) {
-    // Let's add some bookmarks(without favicon) to bm_folder.
+    // Let's add some GetBookmarkModel(without favicon) to bm_folder.
     int child_count = base::RandInt(0, 10);
     for (int index = 0; index < child_count; index++) {
       wstring title(bm_folder->GetTitle());
@@ -2026,52 +1624,50 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
       title.append(IntToWString(index));
       url.append(IntToString(index));
       url.append(".com");
-      const BookmarkNode* nofavicon_bm = verifier->AddURL(model_one,
+      const BookmarkNode* nofavicon_bm = v->AddURL(bm0,
           bm_folder, index, title, GURL(url));
       ASSERT_TRUE(nofavicon_bm != NULL);
     }
     wstring title(L"Test BMFolder-");
     title.append(IntToWString(level));
 
-    bm_folder = verifier->AddGroup(model_one,
+    bm_folder = v->AddGroup(bm0,
         bm_folder, bm_folder->GetChildCount(), title);
     // Let's remember 5th level bm folder for later use.
     if (level == 5) {
       bm_folder_L5 = bm_folder;
     }
   }
-  const BookmarkNode* empty_bm_folder = verifier->AddGroup(model_one,
-      bbn_one, bbn_one->GetChildCount(), L"EmptyTest BMFolder");
+  const BookmarkNode* empty_bm_folder = v->AddGroup(bm0,
+      bm_bar0, bm_bar0->GetChildCount(), L"EmptyTest BMFolder");
 
   // Let's wait until all the changes populate to another client.
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's move empty_bm_folder from bookmark bar to bm_folder_L5 (at the end).
-  verifier->Move(model_one, empty_bm_folder, bm_folder_L5,
+  v->Move(bm0, empty_bm_folder, bm_folder_L5,
       bm_folder_L5->GetChildCount());
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 // Test Scribe ID - 371997.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_SinkNonEmptyBMFold5LevelsDown) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
 
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
-  const BookmarkNode* bm_folder = bbn_one;
+  const BookmarkNode* bm_folder = bm_bar0;
   const BookmarkNode* bm_folder_L5 = NULL;
   for (int level = 0; level < 6; level++) {
     // Let's add some bookmarks (without favicon) to bm_folder.
@@ -2083,22 +1679,22 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
       title.append(IntToWString(index));
       url.append(IntToString(index));
       url.append(".com");
-      const BookmarkNode* nofavicon_bm = verifier->AddURL(model_one,
+      const BookmarkNode* nofavicon_bm = v->AddURL(bm0,
           bm_folder, index, title, GURL(url));
       ASSERT_TRUE(nofavicon_bm != NULL);
     }
     wstring title(L"Test BMFolder-");
     title.append(IntToWString(level));
 
-    bm_folder = verifier->AddGroup(model_one,
+    bm_folder = v->AddGroup(bm0,
         bm_folder, bm_folder->GetChildCount(), title);
     // Let's remember 5th level bm folder for later use.
     if (level == 5) {
       bm_folder_L5 = bm_folder;
     }
   }
-  const BookmarkNode* my_bm_folder = verifier->AddGroup(model_one,
-      bbn_one, bbn_one->GetChildCount(), L"MyTest BMFolder");
+  const BookmarkNode* my_bm_folder = v->AddGroup(bm0,
+      bm_bar0, bm_bar0->GetChildCount(), L"MyTest BMFolder");
   // Let's add few bookmarks to my_bm_folder.
   for (int index = 0; index < 10; index++) {
     wstring title(bm_folder->GetTitle());
@@ -2107,43 +1703,41 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     title.append(IntToWString(index));
     url.append(IntToString(index));
     url.append(".com");
-    const BookmarkNode* nofavicon_bm = verifier->AddURL(model_one,
+    const BookmarkNode* nofavicon_bm = v->AddURL(bm0,
         my_bm_folder, index, title, GURL(url));
     ASSERT_TRUE(nofavicon_bm != NULL);
   }
 
   // Let's wait until all the changes populate to another client.
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's move my_bm_folder from bookmark bar to bm_folder_L5 (at the end).
-  verifier->Move(model_one, my_bm_folder, bm_folder_L5,
+  v->Move(bm0, my_bm_folder, bm_folder_L5,
       bm_folder_L5->GetChildCount());
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 // Test Scribe ID - 372006.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_HoistFolder5LevelsUp) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
 
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
-  const BookmarkNode* bm_folder = bbn_one;
+  const BookmarkNode* bm_folder = bm_bar0;
   const BookmarkNode* bm_folder_L5 = NULL;
   for (int level = 0; level < 6; level++) {
-    // Let's add some bookmarks(without favicon) to bm_folder.
+    // Let's add some GetBookmarkModel(without favicon) to bm_folder.
     int child_count = base::RandInt(0, 10);
     for (int index = 0; index < child_count; index++) {
       wstring title(bm_folder->GetTitle());
@@ -2152,21 +1746,21 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
       title.append(IntToWString(index));
       url.append(IntToString(index));
       url.append(".com");
-      const BookmarkNode* nofavicon_bm = verifier->AddURL(model_one,
+      const BookmarkNode* nofavicon_bm = v->AddURL(bm0,
           bm_folder, index, title, GURL(url));
       ASSERT_TRUE(nofavicon_bm != NULL);
     }
     wstring title(L"Test BMFolder-");
     title.append(IntToWString(level));
 
-    bm_folder = verifier->AddGroup(model_one,
+    bm_folder = v->AddGroup(bm0,
         bm_folder, bm_folder->GetChildCount(), title);
     // Let's remember 5th level bm folder for later use.
     if (level == 5) {
       bm_folder_L5 = bm_folder;
     }
   }
-  const BookmarkNode* my_bm_folder = verifier->AddGroup(model_one,
+  const BookmarkNode* my_bm_folder = v->AddGroup(bm0,
       bm_folder_L5, bm_folder_L5->GetChildCount(), L"MyTest BMFolder");
   // Let's add few bookmarks to my_bm_folder.
   for (int index = 0; index < 10; index++) {
@@ -2176,24 +1770,22 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     title.append(IntToWString(index));
     url.append(IntToString(index));
     url.append(".com");
-    const BookmarkNode* nofavicon_bm = verifier->AddURL(model_one,
+    const BookmarkNode* nofavicon_bm = v->AddURL(bm0,
         my_bm_folder, index, title, GURL(url));
     ASSERT_TRUE(nofavicon_bm != NULL);
   }
 
   // Let's wait until all the changes populate to another client.
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's move my_bm_folder from  bm_folder_L5 to bookmark bar- at end.
-  verifier->Move(model_one, my_bm_folder, bbn_one, bbn_one->GetChildCount());
-
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  v->Move(bm0, my_bm_folder, bm_bar0, bm_bar0->GetChildCount());
 
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 
@@ -2201,167 +1793,125 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
 // Test Scribe ID - 372026.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_ReverseTheOrderOfTwoBMFolders) {
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
 
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   const BookmarkNode* bm_folder_a =
-    verifier->AddNonEmptyGroup(model_one, bbn_one, 0, L"TestBMFolderA", 10);
+    v->AddNonEmptyGroup(bm0, bm_bar0, 0, L"TestBMFolderA", 10);
   ASSERT_TRUE(bm_folder_a != NULL);
   const BookmarkNode* bm_folder_b =
-    verifier->AddNonEmptyGroup(model_one, bbn_one, 1, L"TestBMFolderB", 10);
+    v->AddNonEmptyGroup(bm0, bm_bar0, 1, L"TestBMFolderB", 10);
   ASSERT_TRUE(bm_folder_b != NULL);
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's change positions of bookmark folders so it is more like ba.
-  verifier->ReverseChildOrder(model_one, bbn_one);
+  v->ReverseChildOrder(bm0, bm_bar0);
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 // Test Scribe ID - 372028.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     SC_ReverseTheOrderOfTenBMFolders) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Let's add 10 non-empty bookmark folders like 0123456789
   for (int index = 0; index < 10; index++) {
     wstring title(L"BM Folder");
     title.append(IntToWString(index));
-    const BookmarkNode* child_bm_folder = verifier->AddNonEmptyGroup(
-        model_one, bbn_one, index, title, 10);
+    const BookmarkNode* child_bm_folder = v->AddNonEmptyGroup(
+        bm0, bm_bar0, index, title, 10);
     ASSERT_TRUE(child_bm_folder != NULL);
   }
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 
   // Shuffle bookmark folders to make it look like 9876543210
-  verifier->ReverseChildOrder(model_one, bbn_one);
+  v->ReverseChildOrder(bm0, bm_bar0);
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  Cleanup();
-}
-
-// Test Scribe ID - 373378.
-IN_PROC_BROWSER_TEST_F(LiveSyncTestBasicHierarchy50BM,
-    DISABLED_MC_PushExistingBMsToSecondClient) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-
-  // Wait for changes to propagate.
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  // Let's compare and make sure both bookmark models are same after sync.
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  Cleanup();
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 // Test Scribe ID - 373379.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     MC_BiDirectionalPushAddingBM) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-  const BookmarkNode* bbn_two = model_one->GetBookmarkBarNode();
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+  const BookmarkNode* bm_bar1 = bm0->GetBookmarkBarNode();
 
-  BookmarkModelVerifier::ExpectModelsMatch(model_one, model_two);
+  BookmarkModelVerifier::ExpectModelsMatch(bm0, bm1);
 
   // Let's add 2 bookmarks (without favicon) on each client.
   {
-    const BookmarkNode* bm_foo1 = model_one->AddURL(
-        bbn_one, 0, L"Foo1", GURL("http://www.foo1.com"));
+    const BookmarkNode* bm_foo1 = bm0->AddURL(
+        bm_bar0, 0, L"Foo1", GURL("http://www.foo1.com"));
     ASSERT_TRUE(bm_foo1 != NULL);
-    const BookmarkNode* bm_foo3 = model_two->AddURL(
-        bbn_two, 0, L"Foo3", GURL("http://www.foo3.com"));
+    const BookmarkNode* bm_foo3 = bm1->AddURL(
+        bm_bar1, 0, L"Foo3", GURL("http://www.foo3.com"));
     ASSERT_TRUE(bm_foo3 != NULL);
 
-    const BookmarkNode* bm_foo2 = model_one->AddURL(
-        bbn_one, 1, L"Foo2", GURL("http://www.foo2.com"));
+    const BookmarkNode* bm_foo2 = bm0->AddURL(
+        bm_bar0, 1, L"Foo2", GURL("http://www.foo2.com"));
     ASSERT_TRUE(bm_foo2 != NULL);
-    const BookmarkNode* bm_foo4 = model_two->AddURL(
-        bbn_two, 1, L"Foo4", GURL("http://www.foo4.com"));
+    const BookmarkNode* bm_foo4 = bm1->AddURL(
+        bm_bar1, 1, L"Foo4", GURL("http://www.foo4.com"));
     ASSERT_TRUE(bm_foo4 != NULL);
   }
 
 
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
   // Make sure that client2 has pushed all of it's changes as well.
-  ASSERT_TRUE(client2()->AwaitMutualSyncCycleCompletion(client1()));
-  BookmarkModelVerifier::ExpectModelsMatch(model_one, model_two);
-  Cleanup();
+  ASSERT_TRUE(GetClient(1)->AwaitMutualSyncCycleCompletion(GetClient(0)));
+  BookmarkModelVerifier::ExpectModelsMatch(bm0, bm1);
 }
 
 // Test Scribe ID - 373506.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     MC_BootStrapEmptyStateEverywhere) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  BookmarkModelVerifier* v = verifier_helper();
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
 
   // Wait for changes to propagate.
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
+  ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
   // Let's compare and make sure both bookmark models are same after sync.
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  Cleanup();
-}
-
-// Test Scribe ID - 373507.
-IN_PROC_BROWSER_TEST_F(LiveSyncTestBasicHierarchy50BMBothClients,
-    DISABLED_MC_FirstUseExistingSameBMModelBothClients) {
-  ASSERT_TRUE(SetupSync()) << "Failed to SetupSync";
-  scoped_ptr<BookmarkModelVerifier> verifier(BookmarkModelVerifier::Create());
-  BookmarkModel* model_one = profile1()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-
-  // Wait for changes to propagate.
-  ASSERT_TRUE(client1()->AwaitMutualSyncCycleCompletion(client2()));
-  // Let's compare and make sure both bookmark models are same after sync.
-  verifier->ExpectMatch(model_one);
-  verifier->ExpectMatch(model_two);
-
-  Cleanup();
+  v->ExpectMatch(bm0);
+  v->ExpectMatch(bm1);
 }
 
 // Test Scribe ID - 373508.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     MC_SimpleMergeOfDifferentBMModels) {
-  set_profile2(MakeProfile(FILE_PATH_LITERAL("client2")));
-  BookmarkModel* model_one = browser()->profile()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  LiveSyncTest::BlockUntilLoaded(model_two);
+  ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
 
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-  const BookmarkNode* bbn_two = model_two->GetBookmarkBarNode();
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+  const BookmarkNode* bm_bar1 = bm1->GetBookmarkBarNode();
 
   // Let's add same bookmarks (without favicon) to both clients.
   for (int index = 0; index < 3; index++) {
@@ -2370,12 +1920,12 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     string url("http://www.nofaviconurl");
     url.append(IntToString(index));
     url.append(".com");
+    const BookmarkNode* nofavicon_bm_client0 =
+        bm0->AddURL(bm_bar0, index, title, GURL(url));
+    ASSERT_TRUE(nofavicon_bm_client0 != NULL);
     const BookmarkNode* nofavicon_bm_client1 =
-        model_one->AddURL(bbn_one, index, title, GURL(url));
+        bm1->AddURL(bm_bar1, index, title, GURL(url));
     ASSERT_TRUE(nofavicon_bm_client1 != NULL);
-    const BookmarkNode* nofavicon_bm_client2 =
-        model_two->AddURL(bbn_two, index, title, GURL(url));
-    ASSERT_TRUE(nofavicon_bm_client2 != NULL);
   }
 
   // Let's add some different bookmarks (without favicon) to client1.
@@ -2385,9 +1935,9 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     string url("http://www.client1-nofaviconurl");
     url.append(IntToString(index));
     url.append(".com");
-    const BookmarkNode* nofavicon_bm_client1 =
-        model_one->AddURL(bbn_one, index, title, GURL(url));
-    ASSERT_TRUE(nofavicon_bm_client1 != NULL);
+    const BookmarkNode* nofavicon_bm_client0 =
+        bm0->AddURL(bm_bar0, index, title, GURL(url));
+    ASSERT_TRUE(nofavicon_bm_client0 != NULL);
   }
 
    // Let's add some different bookmarks (without favicon) to client2.
@@ -2397,40 +1947,33 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     string url("http://www.Client2-nofaviconurl");
     url.append(IntToString(index));
     url.append(".com");
-    const BookmarkNode* nofavicon_bm_client2 =
-        model_two->AddURL(bbn_two, index, title, GURL(url));
-    ASSERT_TRUE(nofavicon_bm_client2 != NULL);
+    const BookmarkNode* nofavicon_bm_client1 =
+        bm1->AddURL(bm_bar1, index, title, GURL(url));
+    ASSERT_TRUE(nofavicon_bm_client1 != NULL);
   }
 
   // Set up sync on both clients.
-  set_client1(new ProfileSyncServiceTestHarness(
-      browser()->profile(), username_, password_));
-  set_client2(new ProfileSyncServiceTestHarness(
-      profile2(), username_, password_));
-  ASSERT_TRUE(client1()->SetupSync()) << "Failed to SetupSync on Client1";
-  ASSERT_TRUE(client2()->SetupSync()) << "Failed to SetupSync on Client2";
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 
   // Wait for changes to propagate.
-  ASSERT_TRUE(client2()->AwaitMutualSyncCycleCompletion(client1()));
+  ASSERT_TRUE(GetClient(1)->AwaitMutualSyncCycleCompletion(GetClient(0)));
   // Let's make sure there aren't any duplicates after sync.
-  BookmarkModelVerifier::VerifyNoDuplicates(model_one);
+  BookmarkModelVerifier::VerifyNoDuplicates(bm0);
   // Let's compare and make sure both bookmark models are same after sync.
   BookmarkModelVerifier::ExpectModelsMatchIncludingFavicon(
-      model_one, model_two, false);
-
-  Cleanup();
+      bm0, bm1, false);
 }
 
 // Test Scribe ID - 386586.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     MC_MergeSimpleBMHierarchyUnderBMBar) {
-  set_profile2(MakeProfile(FILE_PATH_LITERAL("client2")));
-  BookmarkModel* model_one = browser()->profile()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  LiveSyncTest::BlockUntilLoaded(model_two);
+  ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  ui_test_utils::WaitForBookmarkModelToLoad(bm1);
 
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-  const BookmarkNode* bbn_two = model_two->GetBookmarkBarNode();
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+  const BookmarkNode* bm_bar1 = bm1->GetBookmarkBarNode();
 
   // Let's add same bookmarks (without favicon) to both clients.
   for (int index = 0; index < 3 ; index++) {
@@ -2439,12 +1982,12 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     string url("http://www.nofaviconurl");
     url.append(IntToString(index));
     url.append(".com");
+    const BookmarkNode* nofavicon_bm_client0 =
+        bm0->AddURL(bm_bar0, index, title, GURL(url));
+    ASSERT_TRUE(nofavicon_bm_client0 != NULL);
     const BookmarkNode* nofavicon_bm_client1 =
-        model_one->AddURL(bbn_one, index, title, GURL(url));
+        bm1->AddURL(bm_bar1, index, title, GURL(url));
     ASSERT_TRUE(nofavicon_bm_client1 != NULL);
-    const BookmarkNode* nofavicon_bm_client2 =
-        model_two->AddURL(bbn_two, index, title, GURL(url));
-    ASSERT_TRUE(nofavicon_bm_client2 != NULL);
   }
 
   // Let's add some different bookmarks (without favicon) to client2.
@@ -2454,40 +1997,33 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     string url("http://www.client2-nofaviconurl");
     url.append(IntToString(index));
     url.append(".com");
-    const BookmarkNode* nofavicon_bm_client2 =
-        model_two->AddURL(bbn_two, index, title, GURL(url));
-    ASSERT_TRUE(nofavicon_bm_client2 != NULL);
+    const BookmarkNode* nofavicon_bm_client1 =
+        bm1->AddURL(bm_bar1, index, title, GURL(url));
+    ASSERT_TRUE(nofavicon_bm_client1 != NULL);
   }
 
   // Set up sync on both clients.
-  set_client1(new ProfileSyncServiceTestHarness(
-      browser()->profile(), username_, password_));
-  set_client2(new ProfileSyncServiceTestHarness(
-      profile2(), username_, password_));
-  ASSERT_TRUE(client1()->SetupSync()) << "Failed to SetupSync on Client1";
-  ASSERT_TRUE(client2()->SetupSync()) << "Failed to SetupSync on Client2";
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 
   // Wait for changes to propagate.
-  ASSERT_TRUE(client2()->AwaitMutualSyncCycleCompletion(client1()));
+  ASSERT_TRUE(GetClient(1)->AwaitMutualSyncCycleCompletion(GetClient(0)));
   // Let's make sure there aren't any duplicates after sync.
-  BookmarkModelVerifier::VerifyNoDuplicates(model_one);
+  BookmarkModelVerifier::VerifyNoDuplicates(bm0);
   // Let's compare and make sure both bookmark models are same after sync.
   BookmarkModelVerifier::ExpectModelsMatchIncludingFavicon(
-      model_one, model_two, false);
-
-  Cleanup();
+      bm0, bm1, false);
 }
 
 // Test Scribe ID - 386589.
 IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     MC_MergeSimpleBMHierarchyEqualSetsUnderBMBar) {
-  set_profile2(MakeProfile(FILE_PATH_LITERAL("client2")));
-  BookmarkModel* model_one = browser()->profile()->GetBookmarkModel();
-  BookmarkModel* model_two = profile2()->GetBookmarkModel();
-  LiveSyncTest::BlockUntilLoaded(model_two);
+  ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
+  BookmarkModel* bm0 = GetBookmarkModel(0);
+  BookmarkModel* bm1 = GetBookmarkModel(1);
+  ui_test_utils::WaitForBookmarkModelToLoad(bm1);
 
-  const BookmarkNode* bbn_one = model_one->GetBookmarkBarNode();
-  const BookmarkNode* bbn_two = model_two->GetBookmarkBarNode();
+  const BookmarkNode* bm_bar0 = bm0->GetBookmarkBarNode();
+  const BookmarkNode* bm_bar1 = bm1->GetBookmarkBarNode();
 
   // Let's add same bookmarks (without favicon) to both clients.
   for (int index = 0; index < 3 ; index++) {
@@ -2496,29 +2032,22 @@ IN_PROC_BROWSER_TEST_F(TwoClientLiveBookmarksSyncTest,
     string url("http://www.nofaviconurl");
     url.append(IntToString(index));
     url.append(".com");
+    const BookmarkNode* nofavicon_bm_client0 =
+        bm0->AddURL(bm_bar0, index, title, GURL(url));
+    ASSERT_TRUE(nofavicon_bm_client0 != NULL);
     const BookmarkNode* nofavicon_bm_client1 =
-        model_one->AddURL(bbn_one, index, title, GURL(url));
+        bm1->AddURL(bm_bar1, index, title, GURL(url));
     ASSERT_TRUE(nofavicon_bm_client1 != NULL);
-    const BookmarkNode* nofavicon_bm_client2 =
-        model_two->AddURL(bbn_two, index, title, GURL(url));
-    ASSERT_TRUE(nofavicon_bm_client2 != NULL);
   }
 
   // Set up sync on both clients.
-  set_client1(new ProfileSyncServiceTestHarness(
-      browser()->profile(), username_, password_));
-  set_client2(new ProfileSyncServiceTestHarness(
-      profile2(), username_, password_));
-  ASSERT_TRUE(client1()->SetupSync()) << "Failed to SetupSync on Client1";
-  ASSERT_TRUE(client2()->SetupSync()) << "Failed to SetupSync on Client2";
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 
   // Wait for changes to propagate.
-  ASSERT_TRUE(client2()->AwaitMutualSyncCycleCompletion(client1()));
+  ASSERT_TRUE(GetClient(1)->AwaitMutualSyncCycleCompletion(GetClient(0)));
   // Let's make sure there aren't any duplicates after sync.
-  BookmarkModelVerifier::VerifyNoDuplicates(model_one);
+  BookmarkModelVerifier::VerifyNoDuplicates(bm0);
   // Let's compare and make sure both bookmark models are same after sync.
   BookmarkModelVerifier::ExpectModelsMatchIncludingFavicon(
-      model_one, model_two, false);
-
-  Cleanup();
+      bm0, bm1, false);
 }
diff --git a/chrome/test/live_sync/two_client_live_preferences_sync_test.cc b/chrome/test/live_sync/two_client_live_preferences_sync_test.cc
index 8348896..a522811 100644
--- a/chrome/test/live_sync/two_client_live_preferences_sync_test.cc
+++ b/chrome/test/live_sync/two_client_live_preferences_sync_test.cc
@@ -2,88 +2,32 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "base/command_line.h"
-#include "chrome/browser/browser.h"
-#include "chrome/browser/pref_service.h"
-#include "chrome/browser/profile.h"
-#include "chrome/browser/sync/profile_sync_service.h"
-#include "chrome/common/pref_names.h"
-#include "chrome/test/live_sync/profile_sync_service_test_harness.h"
-#include "chrome/test/live_sync/live_sync_test.h"
-
-class TwoClientLivePreferencesSyncTest : public LiveSyncTest {
- protected:
-  TwoClientLivePreferencesSyncTest() {
-    // This makes sure browser is visible and active while running test.
-    InProcessBrowserTest::set_show_window(true);
-    // Set the initial timeout value to 5 min.
-    InProcessBrowserTest::SetInitialTimeoutInMS(300000);
-  }
-  ~TwoClientLivePreferencesSyncTest() {}
-
-  void SetupSync() {
-    client1_.reset(new ProfileSyncServiceTestHarness(
-        browser()->profile(), username_, password_));
-    profile2_.reset(MakeProfile(FILE_PATH_LITERAL("client2")));
-    client2_.reset(new ProfileSyncServiceTestHarness(
-        profile2_.get(), username_, password_));
-    EXPECT_TRUE(client1_->SetupSync());
-    EXPECT_TRUE(client1_->AwaitSyncCycleCompletion("Initial setup 1"));
-    EXPECT_TRUE(client2_->SetupSync());
-    EXPECT_TRUE(client2_->AwaitSyncCycleCompletion("Initial setup 2"));
-  }
-
-  void Cleanup() {
-    client2_.reset();
-    profile2_.reset();
-  }
-
-  ProfileSyncServiceTestHarness* client1() { return client1_.get(); }
-  ProfileSyncServiceTestHarness* client2() { return client2_.get(); }
-
-  PrefService* prefs1() { return browser()->profile()->GetPrefs(); }
-  PrefService* prefs2() { return profile2_->GetPrefs(); }
-
- private:
-  scoped_ptr<ProfileSyncServiceTestHarness> client1_;
-  scoped_ptr<ProfileSyncServiceTestHarness> client2_;
-  scoped_ptr<Profile> profile2_;
-
-  DISALLOW_COPY_AND_ASSIGN(TwoClientLivePreferencesSyncTest);
-};
+#include "chrome/test/live_sync/live_preferences_sync_test.h"
 
 IN_PROC_BROWSER_TEST_F(TwoClientLivePreferencesSyncTest, Sanity) {
-  SetupSync();
-
-  EXPECT_EQ(prefs1()->GetBoolean(prefs::kHomePageIsNewTabPage),
-            prefs2()->GetBoolean(prefs::kHomePageIsNewTabPage));
-
-  PrefService* expected = LiveSyncTest::MakeProfile(
-      FILE_PATH_LITERAL("verifier"))->GetPrefs();
-  bool value = !expected->GetBoolean(prefs::kHomePageIsNewTabPage);
-  expected->SetBoolean(prefs::kHomePageIsNewTabPage, value);
-
-  prefs1()->SetBoolean(prefs::kHomePageIsNewTabPage, value);
-  EXPECT_TRUE(client2()->AwaitMutualSyncCycleCompletion(client1()));
-
-  EXPECT_EQ(expected->GetBoolean(prefs::kHomePageIsNewTabPage),
-            prefs1()->GetBoolean(prefs::kHomePageIsNewTabPage));
-  EXPECT_EQ(expected->GetBoolean(prefs::kHomePageIsNewTabPage),
-            prefs2()->GetBoolean(prefs::kHomePageIsNewTabPage));
-
-  Cleanup();
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
+  EXPECT_EQ(GetPrefs(0)->GetBoolean(prefs::kHomePageIsNewTabPage),
+            GetPrefs(1)->GetBoolean(prefs::kHomePageIsNewTabPage));
+
+  bool new_value = !GetVerifierPrefs()->GetBoolean(
+      prefs::kHomePageIsNewTabPage);
+  GetVerifierPrefs()->SetBoolean(prefs::kHomePageIsNewTabPage, new_value);
+  GetPrefs(0)->SetBoolean(prefs::kHomePageIsNewTabPage, new_value);
+  EXPECT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
+
+  EXPECT_EQ(GetVerifierPrefs()->GetBoolean(prefs::kHomePageIsNewTabPage),
+            GetPrefs(0)->GetBoolean(prefs::kHomePageIsNewTabPage));
+  EXPECT_EQ(GetVerifierPrefs()->GetBoolean(prefs::kHomePageIsNewTabPage),
+            GetPrefs(1)->GetBoolean(prefs::kHomePageIsNewTabPage));
 }
 
 IN_PROC_BROWSER_TEST_F(TwoClientLivePreferencesSyncTest, Race) {
-  SetupSync();
-
-  prefs1()->SetString(prefs::kHomePage, L"http://www.google.com/1");
-  prefs2()->SetString(prefs::kHomePage, L"http://www.google.com/2");
-
-  EXPECT_TRUE(client2()->AwaitMutualSyncCycleCompletion(client1()));
+  ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 
-  EXPECT_EQ(prefs1()->GetString(prefs::kHomePage),
-            prefs2()->GetString(prefs::kHomePage));
+  GetPrefs(0)->SetString(prefs::kHomePage, L"http://www.google.com/1");
+  GetPrefs(1)->SetString(prefs::kHomePage, L"http://www.google.com/2");
+  EXPECT_TRUE(GetClient(1)->AwaitMutualSyncCycleCompletion(GetClient(0)));
 
-  Cleanup();
+  EXPECT_EQ(GetPrefs(0)->GetString(prefs::kHomePage),
+            GetPrefs(1)->GetString(prefs::kHomePage));
 }