Remove Profile dependency from some ProfileSyncService unittests

More precisely, this removes the //chrome dependencies from TestProfileSyncService, AbstractProfileSyncServiceTest, ProfileSyncServiceTypedUrlTest and ProfileSyncServiceAutofillTest.

BUG=581640

Review URL: https://codereview.chromium.org/1646553002

Cr-Commit-Position: refs/heads/master@{#376446}

11 files changed, 689 insertions, 628 deletions

diff --git a/chrome/browser/sync/abstract_profile_sync_service_test.cc b/chrome/browser/sync/abstract_profile_sync_service_test.cc
index 3089b52..28d6396 100644
--- a/chrome/browser/sync/abstract_profile_sync_service_test.cc
+++ b/chrome/browser/sync/abstract_profile_sync_service_test.cc
@@ -4,19 +4,138 @@
 
 #include "chrome/browser/sync/abstract_profile_sync_service_test.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/run_loop.h"
+#include "chrome/browser/sync/test/test_http_bridge_factory.h"
 #include "chrome/browser/sync/test_profile_sync_service.h"
+#include "components/sync_driver/glue/sync_backend_host_core.h"
+#include "components/sync_driver/sync_api_component_factory_mock.h"
 #include "content/public/test/test_utils.h"
+#include "google_apis/gaia/gaia_constants.h"
+#include "sync/internal_api/public/test/sync_manager_factory_for_profile_sync_test.h"
+#include "sync/internal_api/public/test/test_internal_components_factory.h"
 #include "sync/internal_api/public/test/test_user_share.h"
-#include "sync/internal_api/public/write_transaction.h"
 #include "sync/protocol/sync.pb.h"
-#include "sync/util/cryptographer.h"
 
+using content::BrowserThread;
 using syncer::ModelType;
-using syncer::UserShare;
+using testing::_;
+using testing::Return;
+
+namespace {
+
+class SyncBackendHostForProfileSyncTest
+    : public browser_sync::SyncBackendHostImpl {
+ public:
+  SyncBackendHostForProfileSyncTest(
+      const base::FilePath& temp_dir,
+      sync_driver::SyncClient* sync_client,
+      const scoped_refptr<base::SingleThreadTaskRunner>& ui_thread,
+      invalidation::InvalidationService* invalidator,
+      const base::WeakPtr<sync_driver::SyncPrefs>& sync_prefs,
+      const base::Closure& callback);
+  ~SyncBackendHostForProfileSyncTest() override;
+
+  void RequestConfigureSyncer(
+      syncer::ConfigureReason reason,
+      syncer::ModelTypeSet to_download,
+      syncer::ModelTypeSet to_purge,
+      syncer::ModelTypeSet to_journal,
+      syncer::ModelTypeSet to_unapply,
+      syncer::ModelTypeSet to_ignore,
+      const syncer::ModelSafeRoutingInfo& routing_info,
+      const base::Callback<void(syncer::ModelTypeSet, syncer::ModelTypeSet)>&
+          ready_task,
+      const base::Closure& retry_callback) override;
+
+ protected:
+  void InitCore(scoped_ptr<browser_sync::DoInitializeOptions> options) override;
+
+ private:
+  // Invoked at the start of HandleSyncManagerInitializationOnFrontendLoop.
+  // Allows extra initialization work to be performed before the backend comes
+  // up.
+  base::Closure callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(SyncBackendHostForProfileSyncTest);
+};
+
+SyncBackendHostForProfileSyncTest::SyncBackendHostForProfileSyncTest(
+    const base::FilePath& temp_dir,
+    sync_driver::SyncClient* sync_client,
+    const scoped_refptr<base::SingleThreadTaskRunner>& ui_thread,
+    invalidation::InvalidationService* invalidator,
+    const base::WeakPtr<sync_driver::SyncPrefs>& sync_prefs,
+    const base::Closure& callback)
+    : browser_sync::SyncBackendHostImpl(
+          "dummy_debug_name",
+          sync_client,
+          ui_thread,
+          invalidator,
+          sync_prefs,
+          temp_dir.Append(base::FilePath(FILE_PATH_LITERAL("test")))),
+      callback_(callback) {}
+
+SyncBackendHostForProfileSyncTest::~SyncBackendHostForProfileSyncTest() {}
+
+void SyncBackendHostForProfileSyncTest::InitCore(
+    scoped_ptr<browser_sync::DoInitializeOptions> options) {
+  options->http_bridge_factory = scoped_ptr<syncer::HttpPostProviderFactory>(
+      new browser_sync::TestHttpBridgeFactory());
+  options->sync_manager_factory.reset(
+      new syncer::SyncManagerFactoryForProfileSyncTest(callback_));
+  options->credentials.email = "testuser@gmail.com";
+  options->credentials.sync_token = "token";
+  options->credentials.scope_set.insert(GaiaConstants::kChromeSyncOAuth2Scope);
+  options->restored_key_for_bootstrapping.clear();
+
+  // It'd be nice if we avoided creating the InternalComponentsFactory in the
+  // first place, but SyncBackendHost will have created one by now so we must
+  // free it. Grab the switches to pass on first.
+  syncer::InternalComponentsFactory::Switches factory_switches =
+      options->internal_components_factory->GetSwitches();
+  options->internal_components_factory.reset(
+      new syncer::TestInternalComponentsFactory(
+          factory_switches,
+          syncer::InternalComponentsFactory::STORAGE_IN_MEMORY, nullptr));
+
+  browser_sync::SyncBackendHostImpl::InitCore(std::move(options));
+}
+
+void SyncBackendHostForProfileSyncTest::RequestConfigureSyncer(
+    syncer::ConfigureReason reason,
+    syncer::ModelTypeSet to_download,
+    syncer::ModelTypeSet to_purge,
+    syncer::ModelTypeSet to_journal,
+    syncer::ModelTypeSet to_unapply,
+    syncer::ModelTypeSet to_ignore,
+    const syncer::ModelSafeRoutingInfo& routing_info,
+    const base::Callback<void(syncer::ModelTypeSet, syncer::ModelTypeSet)>&
+        ready_task,
+    const base::Closure& retry_callback) {
+  syncer::ModelTypeSet failed_configuration_types;
+
+  // The first parameter there should be the set of enabled types.  That's not
+  // something we have access to from this strange test harness.  We'll just
+  // send back the list of newly configured types instead and hope it doesn't
+  // break anything.
+  // Posted to avoid re-entrancy issues.
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::Bind(&SyncBackendHostForProfileSyncTest::
+                     FinishConfigureDataTypesOnFrontendLoop,
+                 base::Unretained(this),
+                 syncer::Difference(to_download, failed_configuration_types),
+                 syncer::Difference(to_download, failed_configuration_types),
+                 failed_configuration_types, ready_task));
+}
+
+}  // namespace
 
 /* static */
 syncer::ImmutableChangeRecordList
@@ -47,14 +166,14 @@ AbstractProfileSyncServiceTest::AbstractProfileSyncServiceTest()
     // Purposefully do not use a real FILE thread, see crbug/550013.
     : thread_bundle_(content::TestBrowserThreadBundle::REAL_DB_THREAD |
                      content::TestBrowserThreadBundle::REAL_IO_THREAD),
-      sync_service_(NULL) {}
-
-AbstractProfileSyncServiceTest::~AbstractProfileSyncServiceTest() {}
-
-void AbstractProfileSyncServiceTest::SetUp() {
+      profile_sync_service_bundle_(
+          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB),
+          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
+          BrowserThread::GetBlockingPool()) {
+  CHECK(temp_dir_.CreateUniqueTempDir());
 }
 
-void AbstractProfileSyncServiceTest::TearDown() {
+AbstractProfileSyncServiceTest::~AbstractProfileSyncServiceTest() {
   // Pump messages posted by the sync core thread (which may end up
   // posting on the IO thread).
   base::RunLoop().RunUntilIdle();
@@ -67,6 +186,31 @@ bool AbstractProfileSyncServiceTest::CreateRoot(ModelType model_type) {
                                            sync_service_->GetUserShare());
 }
 
+scoped_ptr<TestProfileSyncService>
+AbstractProfileSyncServiceTest::CreateSyncService(
+    scoped_ptr<sync_driver::SyncClient> sync_client,
+    const base::Closure& initialization_success_callback) {
+  DCHECK(sync_client);
+  ProfileSyncService::InitParams init_params =
+      profile_sync_service_bundle_.CreateBasicInitParams(
+          browser_sync::AUTO_START, std::move(sync_client));
+  auto sync_service =
+      make_scoped_ptr(new TestProfileSyncService(std::move(init_params)));
+
+  SyncApiComponentFactoryMock* components =
+      profile_sync_service_bundle_.component_factory();
+  EXPECT_CALL(*components, CreateSyncBackendHost(_, _, _, _))
+      .WillOnce(Return(new SyncBackendHostForProfileSyncTest(
+          temp_dir_.path(), sync_service->GetSyncClient(),
+          base::ThreadTaskRunnerHandle::Get(),
+          profile_sync_service_bundle_.fake_invalidation_service(),
+          sync_service->sync_prefs()->AsWeakPtr(),
+          initialization_success_callback)));
+
+  sync_service->SetFirstSetupComplete();
+  return sync_service;
+}
+
 CreateRootHelper::CreateRootHelper(AbstractProfileSyncServiceTest* test,
                                    ModelType model_type)
     : callback_(base::Bind(&CreateRootHelper::CreateRootCallback,
diff --git a/chrome/browser/sync/abstract_profile_sync_service_test.h b/chrome/browser/sync/abstract_profile_sync_service_test.h
index d6131b7..b539e98 100644
--- a/chrome/browser/sync/abstract_profile_sync_service_test.h
+++ b/chrome/browser/sync/abstract_profile_sync_service_test.h
@@ -10,16 +10,15 @@
 #include <string>
 
 #include "base/callback.h"
-#include "base/compiler_specific.h"
+#include "base/files/scoped_temp_dir.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/message_loop/message_loop.h"
-#include "components/sync_driver/sync_api_component_factory_mock.h"
+#include "components/browser_sync/browser/profile_sync_test_util.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/change_record.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-class ProfileSyncService;
 class TestProfileSyncService;
 
 namespace syncer {
@@ -37,6 +36,9 @@ class ProfileSyncServiceTestHelper {
   MakeSingletonDeletionChangeRecordList(
       int64_t node_id,
       const sync_pb::EntitySpecifics& specifics);
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ProfileSyncServiceTestHelper);
 };
 
 class AbstractProfileSyncServiceTest : public testing::Test {
@@ -44,15 +46,26 @@ class AbstractProfileSyncServiceTest : public testing::Test {
   AbstractProfileSyncServiceTest();
   ~AbstractProfileSyncServiceTest() override;
 
-  void SetUp() override;
-
-  void TearDown() override;
-
   bool CreateRoot(syncer::ModelType model_type);
 
  protected:
+  // Creates a TestProfileSyncService instance based on
+  // |profile_sync_service_bundle_|, with start behavior
+  // browser_sync::AUTO_START. Passes |callback| down to
+  // SyncManagerForProfileSyncTest to be used by NotifyInitializationSuccess.
+  // |sync_client| is passed to the service.
+  scoped_ptr<TestProfileSyncService> CreateSyncService(
+      scoped_ptr<sync_driver::SyncClient> sync_client,
+      const base::Closure& initialization_success_callback);
+
   content::TestBrowserThreadBundle thread_bundle_;
-  TestProfileSyncService* sync_service_;
+  browser_sync::ProfileSyncServiceBundle profile_sync_service_bundle_;
+  scoped_ptr<TestProfileSyncService> sync_service_;
+
+ private:
+  base::ScopedTempDir temp_dir_;  // To pass to the backend host.
+
+  DISALLOW_COPY_AND_ASSIGN(AbstractProfileSyncServiceTest);
 };
 
 class CreateRootHelper {
@@ -71,6 +84,8 @@ class CreateRootHelper {
   AbstractProfileSyncServiceTest* test_;
   syncer::ModelType model_type_;
   bool success_;
+
+  DISALLOW_COPY_AND_ASSIGN(CreateRootHelper);
 };
 
 #endif  // CHROME_BROWSER_SYNC_ABSTRACT_PROFILE_SYNC_SERVICE_TEST_H_
diff --git a/chrome/browser/sync/profile_sync_service_autofill_unittest.cc b/chrome/browser/sync/profile_sync_service_autofill_unittest.cc
index ccd554d..889a745 100644
--- a/chrome/browser/sync/profile_sync_service_autofill_unittest.cc
+++ b/chrome/browser/sync/profile_sync_service_autofill_unittest.cc
@@ -15,7 +15,6 @@
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
-#include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
@@ -24,20 +23,10 @@
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
-#include "chrome/browser/autofill/personal_data_manager_factory.h"
-#include "chrome/browser/signin/account_tracker_service_factory.h"
-#include "chrome/browser/signin/fake_profile_oauth2_token_service_builder.h"
-#include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
-#include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/sync/abstract_profile_sync_service_test.h"
-#include "chrome/browser/sync/profile_sync_service_factory.h"
-#include "chrome/browser/sync/profile_sync_test_util.h"
 #include "chrome/browser/sync/test_profile_sync_service.h"
-#include "chrome/browser/web_data_service_factory.h"
-#include "chrome/test/base/testing_browser_process.h"
-#include "chrome/test/base/testing_profile.h"
-#include "chrome/test/base/testing_profile_manager.h"
 #include "components/autofill/core/browser/autofill_test_utils.h"
 #include "components/autofill/core/browser/country_names.h"
 #include "components/autofill/core/browser/personal_data_manager.h"
@@ -49,18 +38,15 @@
 #include "components/autofill/core/browser/webdata/autofill_profile_syncable_service.h"
 #include "components/autofill/core/browser/webdata/autofill_table.h"
 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
+#include "components/autofill/core/common/autofill_pref_names.h"
 #include "components/browser_sync/browser/profile_sync_service.h"
-#include "components/signin/core/browser/account_tracker_service.h"
-#include "components/signin/core/browser/fake_profile_oauth2_token_service.h"
-#include "components/signin/core/browser/signin_manager.h"
 #include "components/sync_driver/data_type_controller.h"
-#include "components/sync_driver/fake_sync_client.h"
+#include "components/sync_driver/data_type_manager_impl.h"
 #include "components/sync_driver/sync_api_component_factory_mock.h"
 #include "components/syncable_prefs/pref_service_syncable.h"
 #include "components/webdata/common/web_database.h"
 #include "components/webdata_services/web_data_service_test_util.h"
 #include "content/public/test/test_browser_thread.h"
-#include "google_apis/gaia/gaia_constants.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/data_type_debug_info_listener.h"
 #include "sync/internal_api/public/read_node.h"
@@ -70,14 +56,12 @@
 #include "sync/protocol/autofill_specifics.pb.h"
 #include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/syncable_write_transaction.h"
-#include "sync/test/engine/test_id_factory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using autofill::AutocompleteSyncableService;
 using autofill::AutofillChange;
 using autofill::AutofillChangeList;
 using autofill::AutofillEntry;
-using autofill::ServerFieldType;
 using autofill::AutofillKey;
 using autofill::AutofillProfile;
 using autofill::AutofillProfileChange;
@@ -94,16 +78,12 @@ using content::BrowserThread;
 using syncer::AUTOFILL;
 using syncer::AUTOFILL_PROFILE;
 using syncer::BaseNode;
-using syncer::syncable::BASE_VERSION;
 using syncer::syncable::CREATE;
 using syncer::syncable::GET_TYPE_ROOT;
 using syncer::syncable::MutableEntry;
-using syncer::syncable::SERVER_SPECIFICS;
-using syncer::syncable::SPECIFICS;
 using syncer::syncable::UNITTEST;
 using syncer::syncable::WriterTag;
 using syncer::syncable::WriteTransaction;
-using sync_driver::DataTypeController;
 using testing::_;
 using testing::DoAll;
 using testing::ElementsAre;
@@ -113,7 +93,11 @@ using testing::Return;
 
 namespace {
 
-const char kTestProfileName[] = "test-profile";
+void RegisterAutofillPrefs(user_prefs::PrefRegistrySyncable* registry) {
+  registry->RegisterBooleanPref(autofill::prefs::kAutofillEnabled, true);
+  registry->RegisterBooleanPref(autofill::prefs::kAutofillWalletImportEnabled,
+                                true);
+}
 
 void RunAndSignal(const base::Closure& cb, WaitableEvent* event) {
   cb.Run();
@@ -133,8 +117,8 @@ class AutofillTableMock : public AutofillTable {
   MOCK_METHOD4(GetAutofillTimestamps,
                bool(const base::string16& name,  // NOLINT
                     const base::string16& value,
-                    base::Time* date_created,
-                    base::Time* date_last_used));
+                    Time* date_created,
+                    Time* date_last_used));
   MOCK_METHOD1(UpdateAutofillEntries,
                bool(const std::vector<AutofillEntry>&));  // NOLINT
   MOCK_METHOD1(GetAutofillProfiles,
@@ -151,45 +135,6 @@ MATCHER_P(MatchProfiles, profile, "") {
   return (profile.Compare(arg) == 0);
 }
 
-class TestSyncClient : public sync_driver::FakeSyncClient {
- public:
-  TestSyncClient(PersonalDataManager* pdm,
-                 const scoped_refptr<AutofillWebDataService>& web_data_service)
-      : pdm_(pdm),
-        sync_service_(nullptr),
-        web_data_service_(web_data_service) {}
-  ~TestSyncClient() override {}
-
-  // FakeSyncClient overrides.
-  autofill::PersonalDataManager* GetPersonalDataManager() override {
-    return pdm_;
-  }
-  sync_driver::SyncService* GetSyncService() override {
-    DCHECK(sync_service_);
-    return sync_service_;
-  }
-  base::WeakPtr<syncer::SyncableService> GetSyncableServiceForType(
-      syncer::ModelType type) override {
-    DCHECK(type == AUTOFILL || type == AUTOFILL_PROFILE);
-    if (type == AUTOFILL) {
-      return AutocompleteSyncableService::FromWebDataService(
-          web_data_service_.get())->AsWeakPtr();
-    } else {
-      return AutofillProfileSyncableService::FromWebDataService(
-          web_data_service_.get())->AsWeakPtr();
-    }
-  }
-
-  void SetSyncService(sync_driver::SyncService* sync_service) {
-    sync_service_ = sync_service;
-  }
-
- private:
-  PersonalDataManager* pdm_;
-  sync_driver::SyncService* sync_service_;
-  scoped_refptr<AutofillWebDataService> web_data_service_;
-};
-
 class WebDatabaseFake : public WebDatabase {
  public:
   explicit WebDatabaseFake(AutofillTable* autofill_table) {
@@ -232,12 +177,12 @@ syncer::ModelType GetModelType() {
 
 template<>
 syncer::ModelType GetModelType<AutofillEntry>() {
-  return syncer::AUTOFILL;
+  return AUTOFILL;
 }
 
 template<>
 syncer::ModelType GetModelType<AutofillProfile>() {
-  return syncer::AUTOFILL_PROFILE;
+  return AUTOFILL_PROFILE;
 }
 
 class TokenWebDataServiceFake : public TokenWebData {
@@ -378,12 +323,6 @@ class WebDataServiceFake : public AutofillWebDataService {
   DISALLOW_COPY_AND_ASSIGN(WebDataServiceFake);
 };
 
-scoped_ptr<KeyedService> BuildMockWebDataServiceWrapper(
-    content::BrowserContext* profile) {
-  return make_scoped_ptr(new MockWebDataServiceWrapper(
-      new WebDataServiceFake(), new TokenWebDataServiceFake()));
-}
-
 ACTION_P(MakeAutocompleteSyncComponents, wds) {
   EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::DB));
   if (!BrowserThread::CurrentlyOn(BrowserThread::DB))
@@ -407,10 +346,6 @@ class MockPersonalDataManager : public PersonalDataManager {
   MOCK_METHOD0(LoadProfiles, void());
   MOCK_METHOD0(LoadCreditCards, void());
   MOCK_METHOD0(Refresh, void());
-
-  static scoped_ptr<KeyedService> Build(content::BrowserContext* profile) {
-    return make_scoped_ptr(new MockPersonalDataManager());
-  }
 };
 
 template <class T> class AddAutofillHelper;
@@ -427,57 +362,42 @@ class ProfileSyncServiceAutofillTest
   }
 
  protected:
-  ProfileSyncServiceAutofillTest()
-      : profile_manager_(TestingBrowserProcess::GetGlobal()),
-        debug_ptr_factory_(this) {
+  ProfileSyncServiceAutofillTest() : debug_ptr_factory_(this) {
     autofill::CountryNames::SetLocaleString("en-US");
-  }
+    RegisterAutofillPrefs(
+        profile_sync_service_bundle_.pref_service()->registry());
 
-  ~ProfileSyncServiceAutofillTest() override {}
-
-  void SetUp() override {
-    AbstractProfileSyncServiceTest::SetUp();
-    ASSERT_TRUE(profile_manager_.SetUp());
-    TestingProfile::TestingFactories testing_factories;
-    testing_factories.push_back(std::make_pair(
-        ProfileOAuth2TokenServiceFactory::GetInstance(),
-        BuildAutoIssuingFakeProfileOAuth2TokenService));
-    profile_ = profile_manager_.CreateTestingProfile(
-        kTestProfileName,
-        scoped_ptr<syncable_prefs::PrefServiceSyncable>(),
-        base::UTF8ToUTF16(kTestProfileName),
-        0,
-        std::string(),
-        testing_factories);
     web_database_.reset(new WebDatabaseFake(&autofill_table_));
-    MockWebDataServiceWrapper* wrapper =
-        static_cast<MockWebDataServiceWrapper*>(
-            WebDataServiceFactory::GetInstance()->SetTestingFactoryAndUse(
-                profile_, BuildMockWebDataServiceWrapper));
-    web_data_service_ =
-        static_cast<WebDataServiceFake*>(wrapper->GetAutofillWebData().get());
+    web_data_wrapper_ = make_scoped_ptr(new MockWebDataServiceWrapper(
+        new WebDataServiceFake(), new TokenWebDataServiceFake()));
+    web_data_service_ = static_cast<WebDataServiceFake*>(
+        web_data_wrapper_->GetAutofillWebData().get());
     web_data_service_->SetDatabase(web_database_.get());
 
-    personal_data_manager_ = static_cast<MockPersonalDataManager*>(
-        autofill::PersonalDataManagerFactory::GetInstance()
-            ->SetTestingFactoryAndUse(profile_,
-                                      MockPersonalDataManager::Build));
+    personal_data_manager_ = make_scoped_ptr(new MockPersonalDataManager());
 
-    EXPECT_CALL(*personal_data_manager_, LoadProfiles()).Times(1);
-    EXPECT_CALL(*personal_data_manager_, LoadCreditCards()).Times(1);
+    EXPECT_CALL(*personal_data_manager_, LoadProfiles());
+    EXPECT_CALL(*personal_data_manager_, LoadCreditCards());
 
     personal_data_manager_->Init(
-        WebDataServiceFactory::GetAutofillWebDataForProfile(
-            profile_, ServiceAccessType::EXPLICIT_ACCESS),
-        profile_->GetPrefs(),
-        AccountTrackerServiceFactory::GetForProfile(profile_),
-        SigninManagerFactory::GetForProfile(profile_),
-        profile_->IsOffTheRecord());
+        web_data_service_, profile_sync_service_bundle_.pref_service(),
+        profile_sync_service_bundle_.account_tracker(),
+        profile_sync_service_bundle_.signin_manager(), false);
 
     web_data_service_->StartSyncableService();
 
-    sync_client_.reset(new TestSyncClient(personal_data_manager_,
-                                          web_data_service_));
+    browser_sync::ProfileSyncServiceBundle::SyncClientBuilder builder(
+        &profile_sync_service_bundle_);
+    builder.SetPersonalDataManager(personal_data_manager_.get());
+    builder.SetSyncServiceCallback(
+        base::Bind(&ProfileSyncServiceAutofillTest::GetSyncService,
+                   base::Unretained(this)));
+    builder.SetSyncableServiceCallback(
+        base::Bind(&ProfileSyncServiceAutofillTest::GetSyncableServiceForType,
+                   base::Unretained(this)));
+    builder.set_activate_model_creation();
+    sync_client_owned_ = builder.Build();
+    sync_client_ = sync_client_owned_.get();
 
     // When UpdateAutofillEntries() is called with an empty list, the return
     // value should be |true|, rather than the default of |false|.
@@ -486,23 +406,17 @@ class ProfileSyncServiceAutofillTest
         .WillRepeatedly(Return(true));
   }
 
-  void TearDown() override {
+  ~ProfileSyncServiceAutofillTest() override {
     // Note: The tear down order is important.
-    ProfileSyncServiceFactory::GetInstance()->SetTestingFactory(profile_, NULL);
+    sync_service_->Shutdown();
     web_data_service_->ShutdownOnUIThread();
     web_data_service_->ShutdownSyncableService();
-    web_data_service_ = NULL;
-    // To prevent a leak, fully release TestURLRequestContext to ensure its
-    // destruction on the IO message loop.
-    profile_ = NULL;
-    profile_manager_.DeleteTestingProfile(kTestProfileName);
-    AbstractProfileSyncServiceTest::TearDown();
   }
 
   int GetSyncCount(syncer::ModelType type) {
     syncer::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
     syncer::ReadNode node(&trans);
-    if (node.InitTypeRoot(type) != syncer::BaseNode::INIT_OK)
+    if (node.InitTypeRoot(type) != BaseNode::INIT_OK)
       return 0;
     return node.GetTotalNodeCount() - 1;
   }
@@ -510,26 +424,21 @@ class ProfileSyncServiceAutofillTest
   void StartSyncService(const base::Closure& callback,
                         bool will_fail_association,
                         syncer::ModelType type) {
-    SigninManagerBase* signin = SigninManagerFactory::GetForProfile(profile_);
+    SigninManagerBase* signin = profile_sync_service_bundle_.signin_manager();
     signin->SetAuthenticatedAccountInfo("12345", "test_user@gmail.com");
-    sync_service_ = TestProfileSyncService::BuildAutoStartAsyncInit(profile_,
-                                                                    callback);
-    sync_client_->SetSyncService(sync_service_);
-
-    SyncApiComponentFactoryMock* components =
-        sync_service_->GetSyncApiComponentFactoryMock();
+    sync_service_ = CreateSyncService(std::move(sync_client_owned_), callback);
 
-    EXPECT_CALL(*components, CreateDataTypeManager(_, _, _, _, _)).
-        WillOnce(ReturnNewDataTypeManagerWithDebugListener(
-                     syncer::MakeWeakHandle(debug_ptr_factory_.GetWeakPtr())));
+    EXPECT_CALL(*profile_sync_service_bundle_.component_factory(),
+                CreateDataTypeManager(_, _, _, _, _))
+        .WillOnce(ReturnNewDataTypeManagerWithDebugListener(
+            syncer::MakeWeakHandle(debug_ptr_factory_.GetWeakPtr())));
 
     EXPECT_CALL(*personal_data_manager_, IsDataLoaded()).
         WillRepeatedly(Return(true));
 
     // We need tokens to get the tests going
-    ProfileOAuth2TokenServiceFactory::GetForProfile(profile_)
-        ->UpdateCredentials(signin->GetAuthenticatedAccountId(),
-                            "oauth2_login_token");
+    profile_sync_service_bundle_.auth_service()->UpdateCredentials(
+        signin->GetAuthenticatedAccountId(), "oauth2_login_token");
 
     sync_service_->RegisterDataTypeController(CreateDataTypeController(type));
     sync_service_->Initialize();
@@ -554,7 +463,7 @@ class ProfileSyncServiceAutofillTest
         base::UTF16ToUTF8(entry.key().name()),
         base::UTF16ToUTF8(entry.key().value()));
     syncer::WriteNode::InitUniqueByCreationResult result =
-        node.InitUniqueByCreation(syncer::AUTOFILL, tag);
+        node.InitUniqueByCreation(AUTOFILL, tag);
     if (result != syncer::WriteNode::INIT_SUCCESS)
       return false;
 
@@ -569,7 +478,7 @@ class ProfileSyncServiceAutofillTest
     syncer::WriteNode node(&trans);
     std::string tag = profile.guid();
     syncer::WriteNode::InitUniqueByCreationResult result =
-        node.InitUniqueByCreation(syncer::AUTOFILL_PROFILE, tag);
+        node.InitUniqueByCreation(AUTOFILL_PROFILE, tag);
     if (result != syncer::WriteNode::INIT_SUCCESS)
       return false;
 
@@ -583,7 +492,7 @@ class ProfileSyncServiceAutofillTest
                                     std::vector<AutofillProfile>* profiles) {
     syncer::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
     syncer::ReadNode autofill_root(&trans);
-    if (autofill_root.InitTypeRoot(syncer::AUTOFILL) != BaseNode::INIT_OK) {
+    if (autofill_root.InitTypeRoot(AUTOFILL) != BaseNode::INIT_OK) {
       return false;
     }
 
@@ -598,7 +507,7 @@ class ProfileSyncServiceAutofillTest
       if (autofill.has_value()) {
         AutofillKey key(base::UTF8ToUTF16(autofill.name()),
                         base::UTF8ToUTF16(autofill.value()));
-        std::vector<base::Time> timestamps;
+        std::vector<Time> timestamps;
         int timestamps_count = autofill.usage_timestamp_size();
         for (int i = 0; i < timestamps_count; ++i) {
           timestamps.push_back(Time::FromInternalValue(
@@ -661,8 +570,8 @@ class ProfileSyncServiceAutofillTest
     // entries.
     static Time base_time = Time::Now().LocalMidnight();
 
-    base::Time date_created = base_time + TimeDelta::FromSeconds(time_shift0);
-    base::Time date_last_used = date_created;
+    Time date_created = base_time + TimeDelta::FromSeconds(time_shift0);
+    Time date_last_used = date_created;
     if (time_shift1 >= 0)
       date_last_used = base_time + TimeDelta::FromSeconds(time_shift1);
     return AutofillEntry(
@@ -676,18 +585,19 @@ class ProfileSyncServiceAutofillTest
     return MakeAutofillEntry(name, value, time_shift, -1);
   }
 
-  DataTypeController* CreateDataTypeController(syncer::ModelType type) {
+  sync_driver::DataTypeController* CreateDataTypeController(
+      syncer::ModelType type) {
     DCHECK(type == AUTOFILL || type == AUTOFILL_PROFILE);
     if (type == AUTOFILL) {
       return new AutofillDataTypeController(
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB),
-          base::Bind(&base::DoNothing), sync_client_.get(), web_data_service_);
+          base::Bind(&base::DoNothing), sync_client_, web_data_service_);
     } else {
       return new AutofillProfileDataTypeController(
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB),
-          base::Bind(&base::DoNothing), sync_client_.get(), web_data_service_);
+          base::Bind(&base::DoNothing), sync_client_, web_data_service_);
     }
   }
 
@@ -695,15 +605,37 @@ class ProfileSyncServiceAutofillTest
   friend class AddAutofillHelper<AutofillProfile>;
   friend class FakeServerUpdater;
 
-  TestingProfileManager profile_manager_;
-  TestingProfile* profile_;
   AutofillTableMock autofill_table_;
   scoped_ptr<WebDatabaseFake> web_database_;
+  scoped_ptr<MockWebDataServiceWrapper> web_data_wrapper_;
   scoped_refptr<WebDataServiceFake> web_data_service_;
-  MockPersonalDataManager* personal_data_manager_;
+  scoped_ptr<MockPersonalDataManager> personal_data_manager_;
   syncer::DataTypeAssociationStats association_stats_;
   base::WeakPtrFactory<DataTypeDebugInfoListener> debug_ptr_factory_;
-  scoped_ptr<TestSyncClient> sync_client_;
+  // |sync_client_owned_| keeps the created client until it is passed to the
+  // created ProfileSyncService. |sync_client_| just keeps a weak reference to
+  // the client the whole time.
+  scoped_ptr<sync_driver::FakeSyncClient> sync_client_owned_;
+  sync_driver::FakeSyncClient* sync_client_;
+
+ private:
+  sync_driver::SyncService* GetSyncService() { return sync_service_.get(); }
+
+  base::WeakPtr<syncer::SyncableService> GetSyncableServiceForType(
+      syncer::ModelType type) {
+    DCHECK(type == AUTOFILL || type == AUTOFILL_PROFILE);
+    if (type == AUTOFILL) {
+      return AutocompleteSyncableService::FromWebDataService(
+                 web_data_service_.get())
+          ->AsWeakPtr();
+    } else {
+      return AutofillProfileSyncableService::FromWebDataService(
+                 web_data_service_.get())
+          ->AsWeakPtr();
+    }
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(ProfileSyncServiceAutofillTest);
 };
 
 template <class T>
@@ -804,8 +736,8 @@ class FakeServerUpdater : public base::RefCountedThreadSafe<FakeServerUpdater> {
 
       // Create actual entry based on autofill protobuf information.
       // Simulates effects of UpdateLocalDataFromServerData
-      MutableEntry parent(&trans, GET_TYPE_ROOT, syncer::AUTOFILL);
-      MutableEntry item(&trans, CREATE, syncer::AUTOFILL, parent.GetId(), tag);
+      MutableEntry parent(&trans, GET_TYPE_ROOT, AUTOFILL);
+      MutableEntry item(&trans, CREATE, AUTOFILL, parent.GetId(), tag);
       ASSERT_TRUE(item.good());
       item.PutSpecifics(entity_specifics);
       item.PutServerSpecifics(entity_specifics);
@@ -853,16 +785,16 @@ class FakeServerUpdater : public base::RefCountedThreadSafe<FakeServerUpdater> {
 //            waiting for the PersonalDataManager.
 TEST_F(ProfileSyncServiceAutofillTest, FailModelAssociation) {
   // Don't create the root autofill node so startup fails.
-  StartSyncService(base::Closure(), true, syncer::AUTOFILL);
+  StartSyncService(base::Closure(), true, AUTOFILL);
   EXPECT_TRUE(sync_service_->HasUnrecoverableError());
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, EmptyNativeEmptySync) {
   EXPECT_CALL(autofill_table_, GetAllAutofillEntries(_)).WillOnce(Return(true));
   SetIdleChangeProcessorExpectations();
-  CreateRootHelper create_root(this, syncer::AUTOFILL);
+  CreateRootHelper create_root(this, AUTOFILL);
   EXPECT_CALL(*personal_data_manager_, Refresh());
-  StartSyncService(create_root.callback(), false, syncer::AUTOFILL);
+  StartSyncService(create_root.callback(), false, AUTOFILL);
   EXPECT_TRUE(create_root.success());
   std::vector<AutofillEntry> sync_entries;
   std::vector<AutofillProfile> sync_profiles;
@@ -877,9 +809,9 @@ TEST_F(ProfileSyncServiceAutofillTest, HasNativeEntriesEmptySync) {
   EXPECT_CALL(autofill_table_, GetAllAutofillEntries(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(entries), Return(true)));
   SetIdleChangeProcessorExpectations();
-  CreateRootHelper create_root(this, syncer::AUTOFILL);
+  CreateRootHelper create_root(this, AUTOFILL);
   EXPECT_CALL(*personal_data_manager_, Refresh());
-  StartSyncService(create_root.callback(), false, syncer::AUTOFILL);
+  StartSyncService(create_root.callback(), false, AUTOFILL);
   ASSERT_TRUE(create_root.success());
   std::vector<AutofillEntry> sync_entries;
   std::vector<AutofillProfile> sync_profiles;
@@ -905,8 +837,8 @@ TEST_F(ProfileSyncServiceAutofillTest, HasProfileEmptySync) {
       WillOnce(DoAll(SetArgumentPointee<0>(profiles), Return(true)));
   EXPECT_CALL(*personal_data_manager_, Refresh());
   SetIdleChangeProcessorExpectations();
-  CreateRootHelper create_root(this, syncer::AUTOFILL_PROFILE);
-  StartSyncService(create_root.callback(), false, syncer::AUTOFILL_PROFILE);
+  CreateRootHelper create_root(this, AUTOFILL_PROFILE);
+  StartSyncService(create_root.callback(), false, AUTOFILL_PROFILE);
   ASSERT_TRUE(create_root.success());
   std::vector<AutofillProfile> sync_profiles;
   ASSERT_TRUE(GetAutofillProfilesFromSyncDBUnderProfileNode(&sync_profiles));
@@ -924,9 +856,9 @@ TEST_F(ProfileSyncServiceAutofillTest, HasNativeWithDuplicatesEmptySync) {
   EXPECT_CALL(autofill_table_, GetAllAutofillEntries(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(entries), Return(true)));
   SetIdleChangeProcessorExpectations();
-  CreateRootHelper create_root(this, syncer::AUTOFILL);
+  CreateRootHelper create_root(this, AUTOFILL);
   EXPECT_CALL(*personal_data_manager_, Refresh());
-  StartSyncService(create_root.callback(), false, syncer::AUTOFILL);
+  StartSyncService(create_root.callback(), false, AUTOFILL);
   ASSERT_TRUE(create_root.success());
   std::vector<AutofillEntry> sync_entries;
   std::vector<AutofillProfile> sync_profiles;
@@ -953,7 +885,7 @@ TEST_F(ProfileSyncServiceAutofillTest, HasNativeHasSyncNoMerge) {
       WillOnce(Return(true));
 
   EXPECT_CALL(*personal_data_manager_, Refresh());
-  StartSyncService(add_autofill.callback(), false, syncer::AUTOFILL);
+  StartSyncService(add_autofill.callback(), false, AUTOFILL);
   ASSERT_TRUE(add_autofill.success());
 
   std::set<AutofillEntry> expected_entries;
@@ -987,7 +919,7 @@ TEST_F(ProfileSyncServiceAutofillTest, HasNativeHasSyncMergeEntry) {
   EXPECT_CALL(autofill_table_,
       UpdateAutofillEntries(ElementsAre(merged_entry))).WillOnce(Return(true));
   EXPECT_CALL(*personal_data_manager_, Refresh());
-  StartSyncService(add_autofill.callback(), false, syncer::AUTOFILL);
+  StartSyncService(add_autofill.callback(), false, AUTOFILL);
   ASSERT_TRUE(add_autofill.success());
 
   std::vector<AutofillEntry> new_sync_entries;
@@ -1025,7 +957,7 @@ TEST_F(ProfileSyncServiceAutofillTest, HasNativeHasSyncMergeProfile) {
               UpdateAutofillProfile(MatchProfiles(sync_profile))).
       WillOnce(Return(true));
   EXPECT_CALL(*personal_data_manager_, Refresh());
-  StartSyncService(add_autofill.callback(), false, syncer::AUTOFILL_PROFILE);
+  StartSyncService(add_autofill.callback(), false, AUTOFILL_PROFILE);
   ASSERT_TRUE(add_autofill.success());
 
   std::vector<AutofillProfile> new_sync_profiles;
@@ -1068,7 +1000,7 @@ TEST_F(ProfileSyncServiceAutofillTest, HasNativeHasSyncMergeProfileCombine) {
   AddAutofillHelper<AutofillProfile> add_autofill(this, sync_profiles);
 
   EXPECT_CALL(*personal_data_manager_, Refresh());
-  StartSyncService(add_autofill.callback(), false, syncer::AUTOFILL_PROFILE);
+  StartSyncService(add_autofill.callback(), false, AUTOFILL_PROFILE);
   ASSERT_TRUE(add_autofill.success());
 
   std::vector<AutofillProfile> new_sync_profiles;
@@ -1110,7 +1042,7 @@ TEST_F(ProfileSyncServiceAutofillTest, MergeProfileWithDifferentGuid) {
   EXPECT_CALL(autofill_table_, RemoveAutofillProfile(native_guid)).
       WillOnce(Return(true));
   EXPECT_CALL(*personal_data_manager_, Refresh());
-  StartSyncService(add_autofill.callback(), false, syncer::AUTOFILL_PROFILE);
+  StartSyncService(add_autofill.callback(), false, AUTOFILL_PROFILE);
   ASSERT_TRUE(add_autofill.success());
 
   std::vector<AutofillProfile> new_sync_profiles;
@@ -1125,8 +1057,8 @@ TEST_F(ProfileSyncServiceAutofillTest, ProcessUserChangeAddEntry) {
   EXPECT_CALL(autofill_table_, GetAllAutofillEntries(_)).WillOnce(Return(true));
   EXPECT_CALL(*personal_data_manager_, Refresh());
   SetIdleChangeProcessorExpectations();
-  CreateRootHelper create_root(this, syncer::AUTOFILL);
-  StartSyncService(create_root.callback(), false, syncer::AUTOFILL);
+  CreateRootHelper create_root(this, AUTOFILL);
+  StartSyncService(create_root.callback(), false, AUTOFILL);
   ASSERT_TRUE(create_root.success());
 
   AutofillEntry added_entry(MakeAutofillEntry("added", "entry", 1));
@@ -1153,8 +1085,8 @@ TEST_F(ProfileSyncServiceAutofillTest, ProcessUserChangeAddProfile) {
   EXPECT_CALL(autofill_table_, GetAutofillProfiles(_)).WillOnce(Return(true));
   EXPECT_CALL(*personal_data_manager_, Refresh());
   SetIdleChangeProcessorExpectations();
-  CreateRootHelper create_root(this, syncer::AUTOFILL_PROFILE);
-  StartSyncService(create_root.callback(), false, syncer::AUTOFILL_PROFILE);
+  CreateRootHelper create_root(this, AUTOFILL_PROFILE);
+  StartSyncService(create_root.callback(), false, AUTOFILL_PROFILE);
   ASSERT_TRUE(create_root.success());
 
   AutofillProfile added_profile;
@@ -1182,8 +1114,8 @@ TEST_F(ProfileSyncServiceAutofillTest, ProcessUserChangeUpdateEntry) {
   EXPECT_CALL(autofill_table_, GetAllAutofillEntries(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(original_entries), Return(true)));
   EXPECT_CALL(*personal_data_manager_, Refresh());
-  CreateRootHelper create_root(this, syncer::AUTOFILL);
-  StartSyncService(create_root.callback(), false, syncer::AUTOFILL);
+  CreateRootHelper create_root(this, AUTOFILL);
+  StartSyncService(create_root.callback(), false, AUTOFILL);
   ASSERT_TRUE(create_root.success());
 
   AutofillEntry updated_entry(MakeAutofillEntry("my", "entry", 1, 2));
@@ -1215,8 +1147,8 @@ TEST_F(ProfileSyncServiceAutofillTest, ProcessUserChangeRemoveEntry) {
   EXPECT_CALL(autofill_table_, GetAllAutofillEntries(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(original_entries), Return(true)));
   EXPECT_CALL(*personal_data_manager_, Refresh());
-  CreateRootHelper create_root(this, syncer::AUTOFILL);
-  StartSyncService(create_root.callback(), false, syncer::AUTOFILL);
+  CreateRootHelper create_root(this, AUTOFILL);
+  StartSyncService(create_root.callback(), false, AUTOFILL);
   ASSERT_TRUE(create_root.success());
 
   AutofillChangeList changes;
@@ -1252,7 +1184,7 @@ TEST_F(ProfileSyncServiceAutofillTest, ProcessUserChangeRemoveProfile) {
   sync_profiles.push_back(sync_profile);
   AddAutofillHelper<AutofillProfile> add_autofill(this, sync_profiles);
   EXPECT_CALL(*personal_data_manager_, Refresh());
-  StartSyncService(add_autofill.callback(), false, syncer::AUTOFILL_PROFILE);
+  StartSyncService(add_autofill.callback(), false, AUTOFILL_PROFILE);
   ASSERT_TRUE(add_autofill.success());
 
   AutofillProfileChange change(
@@ -1276,15 +1208,15 @@ TEST_F(ProfileSyncServiceAutofillTest, ServerChangeRace) {
   EXPECT_CALL(autofill_table_, UpdateAutofillEntries(_)).
       WillRepeatedly(Return(true));
   EXPECT_CALL(*personal_data_manager_, Refresh()).Times(3);
-  CreateRootHelper create_root(this, syncer::AUTOFILL);
-  StartSyncService(create_root.callback(), false, syncer::AUTOFILL);
+  CreateRootHelper create_root(this, AUTOFILL);
+  StartSyncService(create_root.callback(), false, AUTOFILL);
   ASSERT_TRUE(create_root.success());
 
   // (true, false) means we have to reset after |Signal|, init to unsignaled.
   scoped_ptr<WaitableEvent> wait_for_start(new WaitableEvent(true, false));
   scoped_ptr<WaitableEvent> wait_for_syncapi(new WaitableEvent(true, false));
   scoped_refptr<FakeServerUpdater> updater(new FakeServerUpdater(
-      sync_service_, &wait_for_start, &wait_for_syncapi));
+      sync_service_.get(), &wait_for_start, &wait_for_syncapi));
 
   // This server side update will stall waiting for CommitWaiter.
   updater->CreateNewEntry(MakeAutofillEntry("server", "entry", 1));
diff --git a/chrome/browser/sync/profile_sync_service_typed_url_unittest.cc b/chrome/browser/sync/profile_sync_service_typed_url_unittest.cc
index fdcf6b1..9838574 100644
--- a/chrome/browser/sync/profile_sync_service_typed_url_unittest.cc
+++ b/chrome/browser/sync/profile_sync_service_typed_url_unittest.cc
@@ -15,6 +15,7 @@
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string16.h"
@@ -22,41 +23,17 @@
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
-#include "chrome/browser/history/history_service_factory.h"
-#include "chrome/browser/invalidation/profile_invalidation_provider_factory.h"
-#include "chrome/browser/signin/account_tracker_service_factory.h"
-#include "chrome/browser/signin/fake_profile_oauth2_token_service_builder.h"
-#include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
-#include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/sync/abstract_profile_sync_service_test.h"
-#include "chrome/browser/sync/chrome_sync_client.h"
-#include "chrome/browser/sync/profile_sync_service_factory.h"
-#include "chrome/browser/sync/profile_sync_test_util.h"
 #include "chrome/browser/sync/test_profile_sync_service.h"
-#include "chrome/common/pref_names.h"
-#include "chrome/test/base/testing_browser_process.h"
-#include "chrome/test/base/testing_profile.h"
-#include "chrome/test/base/testing_profile_manager.h"
-#include "components/browser_sync/browser/profile_sync_service.h"
 #include "components/history/core/browser/history_backend.h"
 #include "components/history/core/browser/history_backend_client.h"
 #include "components/history/core/browser/history_backend_notifier.h"
 #include "components/history/core/browser/history_db_task.h"
 #include "components/history/core/browser/history_service.h"
-#include "components/history/core/browser/history_types.h"
 #include "components/history/core/browser/typed_url_data_type_controller.h"
-#include "components/invalidation/impl/fake_invalidation_service.h"
-#include "components/invalidation/impl/profile_invalidation_provider.h"
-#include "components/invalidation/public/invalidation_service.h"
-#include "components/keyed_service/core/refcounted_keyed_service.h"
-#include "components/signin/core/browser/account_tracker_service.h"
-#include "components/signin/core/browser/fake_profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/sync_driver/data_type_error_handler_mock.h"
-#include "components/sync_driver/sync_api_component_factory_mock.h"
-#include "components/syncable_prefs/pref_service_syncable.h"
-#include "content/public/browser/notification_service.h"
-#include "google_apis/gaia/gaia_constants.h"
+#include "components/sync_driver/data_type_manager_impl.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/read_transaction.h"
 #include "sync/internal_api/public/write_node.h"
@@ -65,31 +42,26 @@
 #include "testing/gmock/include/gmock/gmock.h"
 #include "url/gurl.h"
 
-using base::Thread;
-using base::Time;
 using browser_sync::TypedUrlDataTypeController;
 using history::HistoryBackend;
 using history::HistoryBackendNotifier;
 using history::TypedUrlSyncableService;
-using history::URLID;
-using history::URLRow;
-using syncer::syncable::WriteTransaction;
 using testing::DoAll;
 using testing::Return;
 using testing::SetArgumentPointee;
 using testing::_;
 
-namespace content {
-class BrowserContext;
-}
-
 namespace {
 
-const char kTestProfileName[] = "test-profile";
+const char kDummySavingBrowserHistoryDisabled[] = "dummyPref";
 
 // Visits with this timestamp are treated as expired.
 static const int EXPIRED_VISIT = -1;
 
+ACTION(ReturnNewDataTypeManager) {
+  return new sync_driver::DataTypeManagerImpl(arg0, arg1, arg2, arg3, arg4);
+}
+
 class HistoryBackendMock : public HistoryBackend {
  public:
   HistoryBackendMock()
@@ -105,7 +77,6 @@ class HistoryBackendMock : public HistoryBackend {
   MOCK_METHOD3(AddVisits, bool(const GURL& url,
                                const std::vector<history::VisitInfo>& visits,
                                history::VisitSource visit_source));
-  MOCK_METHOD1(RemoveVisits, bool(const history::VisitVector& visits));
   MOCK_METHOD2(GetURL, bool(const GURL& url_id, history::URLRow* url_row));
   MOCK_METHOD2(SetPageTitle, void(const GURL& url,
                                   const base::string16& title));
@@ -124,6 +95,8 @@ class HistoryServiceMock : public history::HistoryService {
   base::CancelableTaskTracker::TaskId ScheduleDBTask(
       scoped_ptr<history::HistoryDBTask> task,
       base::CancelableTaskTracker* tracker) override {
+    // Explicitly copy out the raw pointer -- compilers might decide to
+    // evaluate task.release() before the arguments for the first Bind().
     history::HistoryDBTask* task_raw = task.get();
     task_runner_->PostTaskAndReply(
         FROM_HERE,
@@ -134,11 +107,7 @@ class HistoryServiceMock : public history::HistoryService {
     return base::CancelableTaskTracker::kBadTaskId;  // unused
   }
 
-  MOCK_METHOD0(Shutdown, void());
-
-  MOCK_CONST_METHOD0(GetTypedUrlSyncableService, TypedUrlSyncableService*());
-
-  void ShutdownBaseService() { history::HistoryService::Shutdown(); }
+  ~HistoryServiceMock() override {}
 
   void set_task_runner(
       scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
@@ -151,8 +120,6 @@ class HistoryServiceMock : public history::HistoryService {
   }
 
  private:
-  ~HistoryServiceMock() override {}
-
   void RunTaskOnDBThread(history::HistoryDBTask* task) {
     EXPECT_TRUE(task->RunOnDBThread(backend_.get(), NULL));
   }
@@ -161,17 +128,6 @@ class HistoryServiceMock : public history::HistoryService {
   scoped_refptr<history::HistoryBackend> backend_;
 };
 
-scoped_ptr<KeyedService> BuildFakeProfileInvalidationProvider(
-    content::BrowserContext* context) {
-  return make_scoped_ptr(new invalidation::ProfileInvalidationProvider(
-      scoped_ptr<invalidation::InvalidationService>(
-          new invalidation::FakeInvalidationService)));
-}
-
-scoped_ptr<KeyedService> BuildHistoryService(content::BrowserContext* profile) {
-  return scoped_ptr<KeyedService>(new HistoryServiceMock);
-}
-
 class TestTypedUrlSyncableService : public TypedUrlSyncableService {
   // TODO(gangwu): remove TestProfileSyncService or even remove whole test
   // suite, and make sure typed_url_syncable_service_unittest.cc and the various
@@ -194,16 +150,6 @@ class TestTypedUrlSyncableService : public TypedUrlSyncableService {
   void ClearErrorStats() override {}
 };
 
-ACTION_P2(ShutdownHistoryService, thread, service) {
-  service->ShutdownBaseService();
-  delete thread;
-}
-
-ACTION_P2(ReturnTypedUrlSyncableService, hb, syncable_service) {
-  syncable_service->reset(new TestTypedUrlSyncableService(hb));
-  return syncable_service->get();
-}
-
 class ProfileSyncServiceTypedUrlTest : public AbstractProfileSyncServiceTest {
  public:
   void AddTypedUrlSyncNode(const history::URLRow& url,
@@ -219,75 +165,96 @@ class ProfileSyncServiceTypedUrlTest : public AbstractProfileSyncServiceTest {
   }
 
  protected:
-  ProfileSyncServiceTypedUrlTest()
-      : profile_manager_(TestingBrowserProcess::GetGlobal()) {
-    history_thread_.reset(new Thread("history"));
+  ProfileSyncServiceTypedUrlTest() : history_thread_("history") {
+    profile_sync_service_bundle_.pref_service()
+        ->registry()
+        ->RegisterBooleanPref(kDummySavingBrowserHistoryDisabled, false);
+
+    history_thread_.Start();
+    base::RunLoop run_loop;
+    history_thread_.task_runner()->PostTaskAndReply(
+        FROM_HERE,
+        base::Bind(&ProfileSyncServiceTypedUrlTest::CreateHistoryService,
+                   base::Unretained(this)),
+        run_loop.QuitClosure());
+    run_loop.Run();
+    history_service_ = make_scoped_ptr(new HistoryServiceMock);
+    history_service_->set_task_runner(history_thread_.task_runner());
+    history_service_->set_backend(history_backend_);
+
+    browser_sync::ProfileSyncServiceBundle::SyncClientBuilder builder(
+        &profile_sync_service_bundle_);
+    builder.SetHistoryService(history_service_.get());
+    builder.SetSyncServiceCallback(
+        base::Bind(&ProfileSyncServiceTypedUrlTest::GetSyncService,
+                   base::Unretained(this)));
+    builder.SetSyncableServiceCallback(
+        base::Bind(&ProfileSyncServiceTypedUrlTest::GetSyncableServiceForType,
+                   base::Unretained(this)));
+    builder.set_activate_model_creation();
+    sync_client_ = builder.Build();
   }
 
-  void SetUp() override {
-    AbstractProfileSyncServiceTest::SetUp();
-    ASSERT_TRUE(profile_manager_.SetUp());
-    TestingProfile::TestingFactories testing_factories;
-    testing_factories.push_back(std::make_pair(
-        ProfileOAuth2TokenServiceFactory::GetInstance(),
-        BuildAutoIssuingFakeProfileOAuth2TokenService));
-    profile_ = profile_manager_.CreateTestingProfile(
-        kTestProfileName,
-        scoped_ptr<syncable_prefs::PrefServiceSyncable>(),
-        base::UTF8ToUTF16(kTestProfileName),
-        0,
-        std::string(),
-        testing_factories);
-    invalidation::ProfileInvalidationProviderFactory::GetInstance()->
-        SetTestingFactory(profile_, BuildFakeProfileInvalidationProvider);
-    history_thread_->Start();
+  void CreateHistoryService() {
     history_backend_ = new HistoryBackendMock();
-    history_service_ = static_cast<HistoryServiceMock*>(
-        HistoryServiceFactory::GetInstance()->SetTestingFactoryAndUse(
-            profile_, BuildHistoryService));
-    history_service_->set_task_runner(history_thread_->task_runner());
-    history_service_->set_backend(history_backend_);
+    syncable_service_ = make_scoped_ptr(
+        new TestTypedUrlSyncableService(history_backend_.get()));
   }
 
-  void TearDown() override {
-    EXPECT_CALL((*history_service_), Shutdown())
-        .WillOnce(ShutdownHistoryService(history_thread_.release(),
-                                         history_service_));
-    profile_ = NULL;
-    profile_manager_.DeleteTestingProfile(kTestProfileName);
-    AbstractProfileSyncServiceTest::TearDown();
+  void DeleteSyncableService() { syncable_service_.reset(); }
+
+  ~ProfileSyncServiceTypedUrlTest() override {
+    history_service_->Shutdown();
+
+    // Request stop to get deletion tasks related to the HistoryService posted
+    // on the Sync thread. It is important to not Shutdown at this moment,
+    // because after shutdown the Sync thread is not returned to the sync
+    // service, so we could not get the thread's message loop to wait for the
+    // deletions to be finished.
+    sync_service_->RequestStop(sync_driver::SyncService::CLEAR_DATA);
+    // Spin the sync thread.
+    {
+      base::RunLoop run_loop;
+      sync_service_->GetSyncLoopForTest()->task_runner()->PostTaskAndReply(
+          FROM_HERE, base::Bind(&base::DoNothing), run_loop.QuitClosure());
+      run_loop.Run();
+    }
+
+    sync_service_->Shutdown();
+
+    {
+      base::RunLoop run_loop;
+      history_thread_.task_runner()->PostTaskAndReply(
+          FROM_HERE,
+          base::Bind(&ProfileSyncServiceTypedUrlTest::DeleteSyncableService,
+                     base::Unretained(this)),
+          run_loop.QuitClosure());
+      run_loop.Run();
+    }
   }
 
   TypedUrlSyncableService* StartSyncService(const base::Closure& callback) {
     if (!sync_service_) {
       std::string account_id =
-            AccountTrackerServiceFactory::GetForProfile(profile_)
-                ->SeedAccountInfo("gaia_id", "test");
-      SigninManagerBase* signin = SigninManagerFactory::GetForProfile(profile_);
+          profile_sync_service_bundle_.account_tracker()->SeedAccountInfo(
+              "gaia_id", "test");
+      SigninManagerBase* signin = profile_sync_service_bundle_.signin_manager();
       signin->SetAuthenticatedAccountInfo("gaia_id", "test");
-      sync_service_ = TestProfileSyncService::BuildAutoStartAsyncInit(profile_,
-                                                                      callback);
+      sync_service_ = CreateSyncService(std::move(sync_client_), callback);
       data_type_controller = new TypedUrlDataTypeController(
           base::ThreadTaskRunnerHandle::Get(), base::Bind(&base::DoNothing),
-          sync_service_->GetSyncClient(), prefs::kSavingBrowserHistoryDisabled);
-      SyncApiComponentFactoryMock* components =
-          sync_service_->GetSyncApiComponentFactoryMock();
+          sync_service_->GetSyncClient(), kDummySavingBrowserHistoryDisabled);
+      EXPECT_CALL(*profile_sync_service_bundle_.component_factory(),
+                  CreateDataTypeManager(_, _, _, _, _))
+          .WillOnce(ReturnNewDataTypeManager());
 
-      EXPECT_CALL(*components, CreateDataTypeManager(_, _, _, _, _)).
-          WillOnce(ReturnNewDataTypeManager());
-
-      EXPECT_CALL(*history_service_, GetTypedUrlSyncableService())
-          .WillOnce(ReturnTypedUrlSyncableService(history_backend_.get(),
-                                                  &syncable_service_));
-
-      ProfileOAuth2TokenService* oauth2_token_service =
-          ProfileOAuth2TokenServiceFactory::GetForProfile(profile_);
-      oauth2_token_service->UpdateCredentials(account_id, "oauth2_login_token");
+      profile_sync_service_bundle_.auth_service()->UpdateCredentials(
+          account_id, "oauth2_login_token");
 
       sync_service_->RegisterDataTypeController(data_type_controller);
 
       sync_service_->Initialize();
-      base::MessageLoop::current()->Run();
+      base::RunLoop().Run();
     }
     return syncable_service_.get();
   }
@@ -330,9 +297,8 @@ class ProfileSyncServiceTypedUrlTest : public AbstractProfileSyncServiceTest {
   }
 
   void SendNotification(const base::Closure& task) {
-    history_thread_->task_runner()->PostTaskAndReply(
-        FROM_HERE,
-        task,
+    history_thread_.task_runner()->PostTaskAndReply(
+        FROM_HERE, task,
         base::Bind(&base::MessageLoop::QuitNow,
                    base::Unretained(base::MessageLoop::current())));
     base::MessageLoop::current()->Run();
@@ -387,7 +353,7 @@ class ProfileSyncServiceTypedUrlTest : public AbstractProfileSyncServiceTest {
     // Give each URL a unique ID, to mimic the behavior of the real database.
     static int unique_url_id = 0;
     GURL gurl(url);
-    URLRow history_url(gurl, ++unique_url_id);
+    history::URLRow history_url(gurl, ++unique_url_id);
     history_url.set_title(base::UTF8ToUTF16(title));
     history_url.set_typed_count(typed_count);
     history_url.set_last_visit(
@@ -400,14 +366,26 @@ class ProfileSyncServiceTypedUrlTest : public AbstractProfileSyncServiceTest {
     return history_url;
   }
 
-  scoped_ptr<Thread> history_thread_;
-  TestingProfileManager profile_manager_;
-  TestingProfile* profile_;
+  sync_driver::SyncService* GetSyncService() { return sync_service_.get(); }
+
+  base::WeakPtr<syncer::SyncableService> GetSyncableServiceForType(
+      syncer::ModelType type) {
+    DCHECK_EQ(syncer::TYPED_URLS, type);
+    return syncable_service_->AsWeakPtr();
+  }
+
+  // The separate thread is needed, because TypedUrlDataTypeController
+  // requires to run on another thread than the UI thread.
+  base::Thread history_thread_;
   scoped_refptr<HistoryBackendMock> history_backend_;
-  HistoryServiceMock* history_service_;
+  scoped_ptr<HistoryServiceMock> history_service_;
   sync_driver::DataTypeErrorHandlerMock error_handler_;
   TypedUrlDataTypeController* data_type_controller;
   scoped_ptr<TestTypedUrlSyncableService> syncable_service_;
+  scoped_ptr<sync_driver::FakeSyncClient> sync_client_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ProfileSyncServiceTypedUrlTest);
 };
 
 void AddTypedUrlEntries(ProfileSyncServiceTypedUrlTest* test,
diff --git a/chrome/browser/sync/test_profile_sync_service.cc b/chrome/browser/sync/test_profile_sync_service.cc
index 6c3b9d4..9909e33 100644
--- a/chrome/browser/sync/test_profile_sync_service.cc
+++ b/chrome/browser/sync/test_profile_sync_service.cc
@@ -6,147 +6,6 @@
 
 #include <utility>
 
-#include "base/location.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/single_thread_task_runner.h"
-#include "base/thread_task_runner_handle.h"
-#include "chrome/browser/chrome_notification_types.h"
-#include "chrome/browser/invalidation/profile_invalidation_provider_factory.h"
-#include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
-#include "chrome/browser/signin/signin_manager_factory.h"
-#include "chrome/browser/sync/chrome_sync_client.h"
-#include "chrome/browser/sync/profile_sync_service_factory.h"
-#include "chrome/browser/sync/test/test_http_bridge_factory.h"
-#include "chrome/common/channel_info.h"
-#include "components/browser_sync/browser/profile_sync_test_util.h"
-#include "components/invalidation/impl/profile_invalidation_provider.h"
-#include "components/signin/core/browser/signin_manager.h"
-#include "components/sync_driver/glue/sync_backend_host.h"
-#include "components/sync_driver/glue/sync_backend_host_core.h"
-#include "components/sync_driver/signin_manager_wrapper.h"
-#include "components/sync_driver/sync_api_component_factory_mock.h"
-#include "content/public/browser/browser_thread.h"
-#include "google_apis/gaia/gaia_constants.h"
-#include "sync/internal_api/public/test/sync_manager_factory_for_profile_sync_test.h"
-#include "sync/internal_api/public/test/test_internal_components_factory.h"
-#include "sync/internal_api/public/user_share.h"
-#include "sync/protocol/encryption.pb.h"
-#include "testing/gmock/include/gmock/gmock.h"
-
-using content::BrowserThread;
-using syncer::InternalComponentsFactory;
-using syncer::TestInternalComponentsFactory;
-using syncer::UserShare;
-
-namespace {
-
-ProfileSyncService::InitParams GetInitParams(
-    Profile* profile,
-    SigninManagerBase* signin,
-    ProfileOAuth2TokenService* oauth2_token_service,
-    browser_sync::ProfileSyncServiceStartBehavior behavior) {
-  ProfileSyncService::InitParams init_params;
-
-  init_params.signin_wrapper =
-      make_scoped_ptr(new SigninManagerWrapper(signin));
-  init_params.oauth2_token_service = oauth2_token_service;
-  init_params.start_behavior = behavior;
-  init_params.sync_client =
-      make_scoped_ptr(new browser_sync::ChromeSyncClient(profile));
-  init_params.network_time_update_callback =
-      base::Bind(&browser_sync::EmptyNetworkTimeUpdate);
-  init_params.base_directory = profile->GetPath();
-  init_params.url_request_context = profile->GetRequestContext();
-  init_params.debug_identifier = profile->GetDebugName();
-  init_params.channel = chrome::GetChannel();
-  init_params.db_thread = content::BrowserThread::GetMessageLoopProxyForThread(
-      content::BrowserThread::DB);
-  init_params.file_thread =
-      content::BrowserThread::GetMessageLoopProxyForThread(
-          content::BrowserThread::FILE);
-  init_params.blocking_pool = content::BrowserThread::GetBlockingPool();
-
-  return init_params;
-}
-
-}  // namespace
-
-namespace browser_sync {
-
-SyncBackendHostForProfileSyncTest::SyncBackendHostForProfileSyncTest(
-    Profile* profile,
-    sync_driver::SyncClient* sync_client,
-    const scoped_refptr<base::SingleThreadTaskRunner>& ui_thread,
-    invalidation::InvalidationService* invalidator,
-    const base::WeakPtr<sync_driver::SyncPrefs>& sync_prefs,
-    base::Closure callback)
-    : browser_sync::SyncBackendHostImpl(
-          profile->GetDebugName(),
-          sync_client,
-          ui_thread,
-          invalidator,
-          sync_prefs,
-          profile->GetPath().Append(base::FilePath(FILE_PATH_LITERAL("test")))),
-      callback_(callback) {}
-
-SyncBackendHostForProfileSyncTest::~SyncBackendHostForProfileSyncTest() {}
-
-void SyncBackendHostForProfileSyncTest::InitCore(
-    scoped_ptr<DoInitializeOptions> options) {
-  options->http_bridge_factory =
-      scoped_ptr<syncer::HttpPostProviderFactory>(
-          new browser_sync::TestHttpBridgeFactory());
-  options->sync_manager_factory.reset(
-      new syncer::SyncManagerFactoryForProfileSyncTest(callback_));
-  options->credentials.email = "testuser@gmail.com";
-  options->credentials.sync_token = "token";
-  options->credentials.scope_set.insert(GaiaConstants::kChromeSyncOAuth2Scope);
-  options->restored_key_for_bootstrapping = "";
-
-  // It'd be nice if we avoided creating the InternalComponentsFactory in the
-  // first place, but SyncBackendHost will have created one by now so we must
-  // free it. Grab the switches to pass on first.
-  InternalComponentsFactory::Switches factory_switches =
-      options->internal_components_factory->GetSwitches();
-  options->internal_components_factory.reset(
-      new TestInternalComponentsFactory(
-          factory_switches, InternalComponentsFactory::STORAGE_IN_MEMORY,
-          NULL));
-
-  SyncBackendHostImpl::InitCore(std::move(options));
-}
-
-void SyncBackendHostForProfileSyncTest::RequestConfigureSyncer(
-    syncer::ConfigureReason reason,
-    syncer::ModelTypeSet to_download,
-    syncer::ModelTypeSet to_purge,
-    syncer::ModelTypeSet to_journal,
-    syncer::ModelTypeSet to_unapply,
-    syncer::ModelTypeSet to_ignore,
-    const syncer::ModelSafeRoutingInfo& routing_info,
-    const base::Callback<void(syncer::ModelTypeSet,
-                              syncer::ModelTypeSet)>& ready_task,
-    const base::Closure& retry_callback) {
-  syncer::ModelTypeSet failed_configuration_types;
-
-  // The first parameter there should be the set of enabled types.  That's not
-  // something we have access to from this strange test harness.  We'll just
-  // send back the list of newly configured types instead and hope it doesn't
-  // break anything.
-  // Posted to avoid re-entrancy issues.
-  base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE,
-      base::Bind(&SyncBackendHostForProfileSyncTest::
-                     FinishConfigureDataTypesOnFrontendLoop,
-                 base::Unretained(this),
-                 syncer::Difference(to_download, failed_configuration_types),
-                 syncer::Difference(to_download, failed_configuration_types),
-                 failed_configuration_types, ready_task));
-}
-
-}  // namespace browser_sync
-
 syncer::TestIdFactory* TestProfileSyncService::id_factory() {
   return &id_factory_;
 }
@@ -157,61 +16,10 @@ TestProfileSyncService::GetJsEventHandler() {
 }
 
 TestProfileSyncService::TestProfileSyncService(
-    Profile* profile,
-    SigninManagerBase* signin,
-    ProfileOAuth2TokenService* oauth2_token_service,
-    browser_sync::ProfileSyncServiceStartBehavior behavior)
-    : ProfileSyncService(
-          GetInitParams(profile, signin, oauth2_token_service, behavior)) {
-  static_cast<browser_sync::ChromeSyncClient*>(GetSyncClient())
-      ->SetSyncApiComponentFactoryForTesting(
-          make_scoped_ptr(new SyncApiComponentFactoryMock));
-  SetFirstSetupComplete();
-}
+    ProfileSyncService::InitParams init_params)
+    : ProfileSyncService(std::move(init_params)) {}
 
-TestProfileSyncService::~TestProfileSyncService() {
-}
-
-// static
-scoped_ptr<KeyedService> TestProfileSyncService::TestFactoryFunction(
-    content::BrowserContext* context) {
-  Profile* profile = static_cast<Profile*>(context);
-  SigninManagerBase* signin =
-      SigninManagerFactory::GetForProfile(profile);
-  ProfileOAuth2TokenService* oauth2_token_service =
-      ProfileOAuth2TokenServiceFactory::GetForProfile(profile);
-  return make_scoped_ptr(new TestProfileSyncService(
-      profile, signin, oauth2_token_service, browser_sync::AUTO_START));
-}
-
-// static
-TestProfileSyncService* TestProfileSyncService::BuildAutoStartAsyncInit(
-    Profile* profile, base::Closure callback) {
-  TestProfileSyncService* sync_service = static_cast<TestProfileSyncService*>(
-        ProfileSyncServiceFactory::GetInstance()->SetTestingFactoryAndUse(
-            profile, &TestProfileSyncService::TestFactoryFunction));
-  SyncApiComponentFactoryMock* components =
-      sync_service->GetSyncApiComponentFactoryMock();
-  // TODO(tim): Convert to a fake instead of mock.
-  EXPECT_CALL(*components, CreateSyncBackendHost(testing::_, testing::_,
-                                                 testing::_, testing::_))
-      .WillOnce(
-          testing::Return(new browser_sync::SyncBackendHostForProfileSyncTest(
-              profile, sync_service->GetSyncClient(),
-              BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
-              invalidation::ProfileInvalidationProviderFactory::GetForProfile(
-                  profile)
-                  ->GetInvalidationService(),
-              sync_service->sync_prefs_.AsWeakPtr(), callback)));
-  return sync_service;
-}
-
-SyncApiComponentFactoryMock*
-TestProfileSyncService::GetSyncApiComponentFactoryMock() {
-  // We always create a mock factory, see Build* routines.
-  return static_cast<SyncApiComponentFactoryMock*>(
-      GetSyncClient()->GetSyncApiComponentFactory());
-}
+TestProfileSyncService::~TestProfileSyncService() {}
 
 void TestProfileSyncService::OnConfigureDone(
     const sync_driver::DataTypeManager::ConfigureResult& result) {
@@ -219,7 +27,7 @@ void TestProfileSyncService::OnConfigureDone(
   base::MessageLoop::current()->QuitWhenIdle();
 }
 
-UserShare* TestProfileSyncService::GetUserShare() const {
+syncer::UserShare* TestProfileSyncService::GetUserShare() const {
   return backend_->GetUserShare();
 }
 
diff --git a/chrome/browser/sync/test_profile_sync_service.h b/chrome/browser/sync/test_profile_sync_service.h
index 8eafbd6..9aefbb1 100644
--- a/chrome/browser/sync/test_profile_sync_service.h
+++ b/chrome/browser/sync/test_profile_sync_service.h
@@ -5,75 +5,20 @@
 #ifndef CHROME_BROWSER_SYNC_TEST_PROFILE_SYNC_SERVICE_H_
 #define CHROME_BROWSER_SYNC_TEST_PROFILE_SYNC_SERVICE_H_
 
-#include <string>
-
-#include "base/callback.h"
-#include "base/compiler_specific.h"
-#include "base/memory/weak_ptr.h"
+#include "base/macros.h"
 #include "components/browser_sync/browser/profile_sync_service.h"
-#include "components/signin/core/browser/profile_oauth2_token_service.h"
-#include "components/sync_driver/data_type_manager_impl.h"
-#include "components/sync_driver/glue/sync_backend_host_impl.h"
-#include "components/sync_driver/sync_client.h"
-#include "components/sync_driver/sync_prefs.h"
-#include "content/public/browser/browser_context.h"
+#include "components/sync_driver/data_type_manager.h"
+#include "sync/internal_api/public/util/weak_handle.h"
+#include "sync/js/js_event_handler.h"
 #include "sync/test/engine/test_id_factory.h"
-#include "testing/gmock/include/gmock/gmock.h"
-
-class Profile;
-class ProfileOAuth2TokenService;
-class SyncApiComponentFactoryMock;
-
-ACTION(ReturnNewDataTypeManager) {
-  return new sync_driver::DataTypeManagerImpl(arg0, arg1, arg2, arg3, arg4);
-}
 
-namespace browser_sync {
-
-class SyncBackendHostForProfileSyncTest : public SyncBackendHostImpl {
- public:
-  SyncBackendHostForProfileSyncTest(
-      Profile* profile,
-      sync_driver::SyncClient* sync_client,
-      const scoped_refptr<base::SingleThreadTaskRunner>& ui_thread,
-      invalidation::InvalidationService* invalidator,
-      const base::WeakPtr<sync_driver::SyncPrefs>& sync_prefs,
-      base::Closure callback);
-  ~SyncBackendHostForProfileSyncTest() override;
-
-  void RequestConfigureSyncer(
-      syncer::ConfigureReason reason,
-      syncer::ModelTypeSet to_download,
-      syncer::ModelTypeSet to_purge,
-      syncer::ModelTypeSet to_journal,
-      syncer::ModelTypeSet to_unapply,
-      syncer::ModelTypeSet to_ignore,
-      const syncer::ModelSafeRoutingInfo& routing_info,
-      const base::Callback<void(syncer::ModelTypeSet, syncer::ModelTypeSet)>&
-          ready_task,
-      const base::Closure& retry_callback) override;
-
- protected:
-  void InitCore(scoped_ptr<DoInitializeOptions> options) override;
-
- private:
-  // Invoked at the start of HandleSyncManagerInitializationOnFrontendLoop.
-  // Allows extra initialization work to be performed before the backend comes
-  // up.
-  base::Closure callback_;
-};
-
-}  // namespace browser_sync
+namespace sync_driver {
+class SyncPrefs;
+}  // namespace sync_driver
 
 class TestProfileSyncService : public ProfileSyncService {
  public:
-  // TODO(tim): Add ability to inject TokenService alongside SigninManager.
-  // TODO(rogerta): what does above comment mean?
-  TestProfileSyncService(
-      Profile* profile,
-      SigninManagerBase* signin,
-      ProfileOAuth2TokenService* oauth2_token_service,
-      browser_sync::ProfileSyncServiceStartBehavior behavior);
+  explicit TestProfileSyncService(ProfileSyncService::InitParams init_params);
 
   ~TestProfileSyncService() override;
 
@@ -83,20 +28,14 @@ class TestProfileSyncService : public ProfileSyncService {
   // We implement our own version to avoid some DCHECKs.
   syncer::UserShare* GetUserShare() const override;
 
-  static TestProfileSyncService* BuildAutoStartAsyncInit(
-      Profile* profile, base::Closure callback);
-
-  SyncApiComponentFactoryMock* GetSyncApiComponentFactoryMock();
-
   syncer::TestIdFactory* id_factory();
 
   // Raise visibility to ease testing.
   using ProfileSyncService::NotifyObservers;
 
- protected:
-  static scoped_ptr<KeyedService> TestFactoryFunction(
-      content::BrowserContext* profile);
+  sync_driver::SyncPrefs* sync_prefs() { return &sync_prefs_; }
 
+ protected:
   // Return NULL handle to use in backend initialization to avoid receiving
   // js messages on UI loop when it's being destroyed, which are not deleted
   // and cause memory leak in test.
@@ -106,6 +45,8 @@ class TestProfileSyncService : public ProfileSyncService {
 
  private:
   syncer::TestIdFactory id_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestProfileSyncService);
 };
 
 #endif  // CHROME_BROWSER_SYNC_TEST_PROFILE_SYNC_SERVICE_H_
diff --git a/chrome/browser/ui/sync/one_click_signin_sync_observer_unittest.cc b/chrome/browser/ui/sync/one_click_signin_sync_observer_unittest.cc
index b5edd31..efe9874 100644
--- a/chrome/browser/ui/sync/one_click_signin_sync_observer_unittest.cc
+++ b/chrome/browser/ui/sync/one_click_signin_sync_observer_unittest.cc
@@ -4,6 +4,9 @@
 
 #include "chrome/browser/ui/sync/one_click_signin_sync_observer.h"
 
+#include <string>
+#include <utility>
+
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/macros.h"
@@ -12,6 +15,7 @@
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/signin/signin_promo.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
+#include "chrome/browser/sync/profile_sync_test_util.h"
 #include "chrome/browser/sync/test_profile_sync_service.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.h"
@@ -50,8 +54,9 @@ class OneClickTestProfileSyncService : public TestProfileSyncService {
   // Helper routine to be used in conjunction with
   // BrowserContextKeyedServiceFactory::SetTestingFactory().
   static scoped_ptr<KeyedService> Build(content::BrowserContext* profile) {
-    return make_scoped_ptr(
-        new OneClickTestProfileSyncService(static_cast<Profile*>(profile)));
+    return make_scoped_ptr(new OneClickTestProfileSyncService(
+        CreateProfileSyncServiceParamsForTest(
+            Profile::FromBrowserContext(profile))));
   }
 
   bool IsFirstSetupInProgress() const override {
@@ -69,17 +74,16 @@ class OneClickTestProfileSyncService : public TestProfileSyncService {
   }
 
  private:
-  explicit OneClickTestProfileSyncService(Profile* profile)
-      : TestProfileSyncService(
-          profile,
-          SigninManagerFactory::GetForProfile(profile),
-          ProfileOAuth2TokenServiceFactory::GetForProfile(profile),
-          browser_sync::MANUAL_START),
+  explicit OneClickTestProfileSyncService(
+      ProfileSyncService::InitParams init_params)
+      : TestProfileSyncService(std::move(init_params)),
         first_setup_in_progress_(false),
         sync_active_(false) {}
 
   bool first_setup_in_progress_;
   bool sync_active_;
+
+  DISALLOW_COPY_AND_ASSIGN(OneClickTestProfileSyncService);
 };
 
 class TestOneClickSigninSyncObserver : public OneClickSigninSyncObserver {
@@ -158,6 +162,8 @@ class OneClickSigninSyncObserverTest : public ChromeRenderViewHostTestHarness {
 
   TestOneClickSigninSyncObserver* sync_observer_;
   bool sync_observer_destroyed_;
+
+  DISALLOW_COPY_AND_ASSIGN(OneClickSigninSyncObserverTest);
 };
 
 // Verify that if no Sync service is present, e.g. because Sync is disabled, the
diff --git a/components/browser_sync/browser/BUILD.gn b/components/browser_sync/browser/BUILD.gn
index 683b1fc..d77b676 100644
--- a/components/browser_sync/browser/BUILD.gn
+++ b/components/browser_sync/browser/BUILD.gn
@@ -95,6 +95,9 @@ source_set("test_support") {
     ":browser",
     "//base",
     "//base/test:test_support",
+    "//components/history/core/browser:browser",
+    "//components/invalidation/impl",
+    "//components/invalidation/impl:test_support",
     "//components/pref_registry",
     "//components/signin/core/browser:browser",
     "//components/signin/core/browser:test_support",
diff --git a/components/browser_sync/browser/profile_sync_test_util.cc b/components/browser_sync/browser/profile_sync_test_util.cc
index c8c02d5..fd6d916 100644
--- a/components/browser_sync/browser/profile_sync_test_util.cc
+++ b/components/browser_sync/browser/profile_sync_test_util.cc
@@ -4,11 +4,15 @@
 
 #include "components/browser_sync/browser/profile_sync_test_util.h"
 
+#include "components/history/core/browser/history_model_worker.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/signin/core/browser/signin_manager_base.h"
+#include "components/sync_driver/glue/browser_thread_model_worker.h"
+#include "components/sync_driver/glue/ui_model_worker.h"
 #include "components/sync_driver/signin_manager_wrapper.h"
 #include "components/sync_driver/sync_prefs.h"
 #include "net/url_request/url_request_test_util.h"
+#include "sync/internal_api/public/engine/passive_model_worker.h"
 
 using sync_driver::ClearBrowsingDataCallback;
 
@@ -18,32 +22,75 @@ namespace {
 
 class BundleSyncClient : public sync_driver::FakeSyncClient {
  public:
-  BundleSyncClient(sync_driver::SyncApiComponentFactory* factory,
-                   PrefService* pref_service,
-                   ClearBrowsingDataCallback clear_browsing_data_callback,
-                   sync_sessions::SyncSessionsClient* sync_sessions_client);
+  BundleSyncClient(
+      sync_driver::SyncApiComponentFactory* factory,
+      PrefService* pref_service,
+      const ClearBrowsingDataCallback& clear_browsing_data_callback,
+      sync_sessions::SyncSessionsClient* sync_sessions_client,
+      autofill::PersonalDataManager* personal_data_manager,
+      const base::Callback<base::WeakPtr<syncer::SyncableService>(
+          syncer::ModelType type)>& get_syncable_service_callback,
+      const base::Callback<sync_driver::SyncService*(void)>&
+          get_sync_service_callback,
+      scoped_refptr<base::SingleThreadTaskRunner> db_thread,
+      scoped_refptr<base::SingleThreadTaskRunner> file_thread,
+      history::HistoryService* history_service);
 
   ~BundleSyncClient() override;
 
   PrefService* GetPrefService() override;
   ClearBrowsingDataCallback GetClearBrowsingDataCallback() override;
   sync_sessions::SyncSessionsClient* GetSyncSessionsClient() override;
+  autofill::PersonalDataManager* GetPersonalDataManager() override;
+  base::WeakPtr<syncer::SyncableService> GetSyncableServiceForType(
+      syncer::ModelType type) override;
+  sync_driver::SyncService* GetSyncService() override;
+  scoped_refptr<syncer::ModelSafeWorker> CreateModelWorkerForGroup(
+      syncer::ModelSafeGroup group,
+      syncer::WorkerLoopDestructionObserver* observer) override;
+  history::HistoryService* GetHistoryService() override;
 
  private:
   PrefService* const pref_service_;
   const ClearBrowsingDataCallback clear_browsing_data_callback_;
   sync_sessions::SyncSessionsClient* const sync_sessions_client_;
+  autofill::PersonalDataManager* const personal_data_manager_;
+  const base::Callback<base::WeakPtr<syncer::SyncableService>(
+      syncer::ModelType type)>
+      get_syncable_service_callback_;
+  const base::Callback<sync_driver::SyncService*(void)>
+      get_sync_service_callback_;
+  // These task runners, if not null, are used in CreateModelWorkerForGroup.
+  const scoped_refptr<base::SingleThreadTaskRunner> db_thread_;
+  const scoped_refptr<base::SingleThreadTaskRunner> file_thread_;
+  history::HistoryService* history_service_;
 };
 
 BundleSyncClient::BundleSyncClient(
     sync_driver::SyncApiComponentFactory* factory,
     PrefService* pref_service,
-    ClearBrowsingDataCallback clear_browsing_data_callback,
-    sync_sessions::SyncSessionsClient* sync_sessions_client)
+    const ClearBrowsingDataCallback& clear_browsing_data_callback,
+    sync_sessions::SyncSessionsClient* sync_sessions_client,
+    autofill::PersonalDataManager* personal_data_manager,
+    const base::Callback<base::WeakPtr<syncer::SyncableService>(
+        syncer::ModelType type)>& get_syncable_service_callback,
+    const base::Callback<sync_driver::SyncService*(void)>&
+        get_sync_service_callback,
+    scoped_refptr<base::SingleThreadTaskRunner> db_thread,
+    scoped_refptr<base::SingleThreadTaskRunner> file_thread,
+    history::HistoryService* history_service)
     : sync_driver::FakeSyncClient(factory),
       pref_service_(pref_service),
       clear_browsing_data_callback_(clear_browsing_data_callback),
-      sync_sessions_client_(sync_sessions_client) {}
+      sync_sessions_client_(sync_sessions_client),
+      personal_data_manager_(personal_data_manager),
+      get_syncable_service_callback_(get_syncable_service_callback),
+      get_sync_service_callback_(get_sync_service_callback),
+      db_thread_(db_thread),
+      file_thread_(file_thread),
+      history_service_(history_service) {
+  DCHECK_EQ(!!db_thread_, !!file_thread_);
+}
 
 BundleSyncClient::~BundleSyncClient() = default;
 
@@ -59,6 +106,60 @@ sync_sessions::SyncSessionsClient* BundleSyncClient::GetSyncSessionsClient() {
   return sync_sessions_client_;
 }
 
+autofill::PersonalDataManager* BundleSyncClient::GetPersonalDataManager() {
+  return personal_data_manager_;
+}
+
+base::WeakPtr<syncer::SyncableService>
+BundleSyncClient::GetSyncableServiceForType(syncer::ModelType type) {
+  if (get_syncable_service_callback_.is_null())
+    return sync_driver::FakeSyncClient::GetSyncableServiceForType(type);
+  return get_syncable_service_callback_.Run(type);
+}
+
+sync_driver::SyncService* BundleSyncClient::GetSyncService() {
+  if (get_sync_service_callback_.is_null())
+    return sync_driver::FakeSyncClient::GetSyncService();
+  return get_sync_service_callback_.Run();
+}
+
+scoped_refptr<syncer::ModelSafeWorker>
+BundleSyncClient::CreateModelWorkerForGroup(
+    syncer::ModelSafeGroup group,
+    syncer::WorkerLoopDestructionObserver* observer) {
+  if (!db_thread_)
+    return FakeSyncClient::CreateModelWorkerForGroup(group, observer);
+  DCHECK(file_thread_) << "DB thread was specified but FILE thread was not.";
+  switch (group) {
+    case syncer::GROUP_DB:
+      return new BrowserThreadModelWorker(db_thread_, syncer::GROUP_DB,
+                                          observer);
+    case syncer::GROUP_FILE:
+      return new BrowserThreadModelWorker(file_thread_, syncer::GROUP_FILE,
+                                          observer);
+    case syncer::GROUP_UI:
+      return new UIModelWorker(base::ThreadTaskRunnerHandle::Get(), observer);
+    case syncer::GROUP_PASSIVE:
+      return new syncer::PassiveModelWorker(observer);
+    case syncer::GROUP_HISTORY: {
+      history::HistoryService* history_service = GetHistoryService();
+      if (!history_service)
+        return nullptr;
+      return new HistoryModelWorker(history_service->AsWeakPtr(),
+                                    base::ThreadTaskRunnerHandle::Get(),
+                                    observer);
+    }
+    default:
+      return nullptr;
+  }
+}
+
+history::HistoryService* BundleSyncClient::GetHistoryService() {
+  if (history_service_)
+    return history_service_;
+  return FakeSyncClient::GetHistoryService();
+}
+
 }  // namespace
 
 void EmptyNetworkTimeUpdate(const base::Time&,
@@ -84,37 +185,75 @@ void ProfileSyncServiceBundle::SyncClientBuilder::SetClearBrowsingDataCallback(
   clear_browsing_data_callback_ = clear_browsing_data_callback;
 }
 
+void ProfileSyncServiceBundle::SyncClientBuilder::SetPersonalDataManager(
+    autofill::PersonalDataManager* personal_data_manager) {
+  personal_data_manager_ = personal_data_manager;
+}
+
+// The client will call this callback to produce the service.
+void ProfileSyncServiceBundle::SyncClientBuilder::SetSyncableServiceCallback(
+    const base::Callback<base::WeakPtr<syncer::SyncableService>(
+        syncer::ModelType type)>& get_syncable_service_callback) {
+  get_syncable_service_callback_ = get_syncable_service_callback;
+}
+
+// The client will call this callback to produce the service.
+void ProfileSyncServiceBundle::SyncClientBuilder::SetSyncServiceCallback(
+    const base::Callback<sync_driver::SyncService*(void)>&
+        get_sync_service_callback) {
+  get_sync_service_callback_ = get_sync_service_callback;
+}
+
+void ProfileSyncServiceBundle::SyncClientBuilder::SetHistoryService(
+    history::HistoryService* history_service) {
+  history_service_ = history_service;
+}
+
 scoped_ptr<sync_driver::FakeSyncClient>
 ProfileSyncServiceBundle::SyncClientBuilder::Build() {
   return make_scoped_ptr(new BundleSyncClient(
       bundle_->component_factory(), bundle_->pref_service(),
-      clear_browsing_data_callback_, bundle_->sync_sessions_client()));
+      clear_browsing_data_callback_, bundle_->sync_sessions_client(),
+      personal_data_manager_, get_syncable_service_callback_,
+      get_sync_service_callback_,
+      activate_model_creation_ ? bundle_->db_thread() : nullptr,
+      activate_model_creation_ ? bundle_->file_thread() : nullptr,
+      history_service_));
 }
 
+struct ProfileSyncServiceBundle::ThreadProvider {
+ public:
+  ThreadProvider() : worker_pool_owner_(2, "sync test worker pool") {
+    DCHECK(base::MessageLoop::current())
+        << "The test including the bundle also needs to include a MessageLoop";
+  }
+  ~ThreadProvider() = default;
+
+  base::SequencedWorkerPoolOwner worker_pool_owner_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ThreadProvider);
+};
+
 ProfileSyncServiceBundle::ProfileSyncServiceBundle()
-    : worker_pool_owner_(2, "sync test worker pool"),
-      signin_client_(&pref_service_),
-#if defined(OS_CHROMEOS)
-      signin_manager_(&signin_client_, &account_tracker_),
-#else
-      signin_manager_(&signin_client_,
-                      &auth_service_,
-                      &account_tracker_,
-                      nullptr),
-#endif
-      url_request_context_(new net::TestURLRequestContextGetter(
-          base::ThreadTaskRunnerHandle::Get())) {
-  browser_sync::RegisterPrefsForProfileSyncService(pref_service_.registry());
-  auth_service_.set_auto_post_fetch_response_on_message_loop(true);
-  account_tracker_.Initialize(&signin_client_);
-  signin_manager_.Initialize(&pref_service_);
-}
+    : ProfileSyncServiceBundle(make_scoped_ptr(new ThreadProvider),
+                               nullptr,
+                               nullptr,
+                               nullptr) {}
+
+ProfileSyncServiceBundle::ProfileSyncServiceBundle(
+    const scoped_refptr<base::SingleThreadTaskRunner>& db_thread,
+    const scoped_refptr<base::SingleThreadTaskRunner>& file_thread,
+    base::SequencedWorkerPool* worker_pool)
+    : ProfileSyncServiceBundle(nullptr, db_thread, file_thread, worker_pool) {}
 
 ProfileSyncServiceBundle::~ProfileSyncServiceBundle() {}
 
 ProfileSyncService::InitParams ProfileSyncServiceBundle::CreateBasicInitParams(
     browser_sync::ProfileSyncServiceStartBehavior start_behavior,
     scoped_ptr<sync_driver::SyncClient> sync_client) {
+  DCHECK(worker_pool_);
+
   ProfileSyncService::InitParams init_params;
 
   init_params.start_behavior = start_behavior;
@@ -128,11 +267,41 @@ ProfileSyncService::InitParams ProfileSyncServiceBundle::CreateBasicInitParams(
   init_params.url_request_context = url_request_context();
   init_params.debug_identifier = "dummyDebugName";
   init_params.channel = version_info::Channel::UNKNOWN;
-  init_params.db_thread = base::ThreadTaskRunnerHandle::Get();
-  init_params.file_thread = base::ThreadTaskRunnerHandle::Get();
-  init_params.blocking_pool = worker_pool_owner_.pool().get();
+  init_params.db_thread = db_thread_;
+  init_params.file_thread = file_thread_;
+  init_params.blocking_pool = worker_pool_;
 
   return init_params;
 }
 
+ProfileSyncServiceBundle::ProfileSyncServiceBundle(
+    scoped_ptr<ThreadProvider> thread_provider,
+    scoped_refptr<base::SingleThreadTaskRunner> db_thread,
+    scoped_refptr<base::SingleThreadTaskRunner> file_thread,
+    base::SequencedWorkerPool* worker_pool)
+    : thread_provider_(std::move(thread_provider)),
+      db_thread_(thread_provider_ ? base::ThreadTaskRunnerHandle::Get()
+                                  : db_thread),
+      file_thread_(thread_provider_ ? base::ThreadTaskRunnerHandle::Get()
+                                    : file_thread),
+      worker_pool_(thread_provider_
+                       ? thread_provider_->worker_pool_owner_.pool().get()
+                       : worker_pool),
+      signin_client_(&pref_service_),
+#if defined(OS_CHROMEOS)
+      signin_manager_(&signin_client_, &account_tracker_),
+#else
+      signin_manager_(&signin_client_,
+                      &auth_service_,
+                      &account_tracker_,
+                      nullptr),
+#endif
+      url_request_context_(new net::TestURLRequestContextGetter(
+          base::ThreadTaskRunnerHandle::Get())) {
+  browser_sync::RegisterPrefsForProfileSyncService(pref_service_.registry());
+  auth_service_.set_auto_post_fetch_response_on_message_loop(true);
+  account_tracker_.Initialize(&signin_client_);
+  signin_manager_.Initialize(&pref_service_);
+}
+
 }  // namespace browser_sync
diff --git a/components/browser_sync/browser/profile_sync_test_util.h b/components/browser_sync/browser/profile_sync_test_util.h
index b6bf4e7..485e7dd 100644
--- a/components/browser_sync/browser/profile_sync_test_util.h
+++ b/components/browser_sync/browser/profile_sync_test_util.h
@@ -5,12 +5,15 @@
 #ifndef COMPONENTS_BROWSER_SYNC_BROWSER_PROFILE_SYNC_TEST_UTIL_H_
 #define COMPONENTS_BROWSER_SYNC_BROWSER_PROFILE_SYNC_TEST_UTIL_H_
 
+#include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/message_loop/message_loop.h"
 #include "base/test/sequenced_worker_pool_owner.h"
 #include "base/time/time.h"
 #include "components/browser_sync/browser/profile_sync_service.h"
+#include "components/invalidation/impl/fake_invalidation_service.h"
 #include "components/signin/core/browser/account_tracker_service.h"
 #include "components/signin/core/browser/fake_profile_oauth2_token_service.h"
 #include "components/signin/core/browser/fake_signin_manager.h"
@@ -25,6 +28,10 @@ class Time;
 class TimeDelta;
 }
 
+namespace history {
+class HistoryService;
+}
+
 namespace net {
 class URLRequestContextGetter;
 }
@@ -46,7 +53,8 @@ void RegisterPrefsForProfileSyncService(
     user_prefs::PrefRegistrySyncable* registry);
 
 // Aggregate this class to get all necessary support for creating a
-// ProfileSyncService in tests.
+// ProfileSyncService in tests. The test still needs to have its own
+// MessageLoop, though.
 class ProfileSyncServiceBundle {
  public:
 #if defined(OS_CHROMEOS)
@@ -55,7 +63,15 @@ class ProfileSyncServiceBundle {
   typedef FakeSigninManager FakeSigninManagerType;
 #endif
 
+  // Use this if you don't care about threads.
   ProfileSyncServiceBundle();
+
+  // Use this to inject threads directly.
+  ProfileSyncServiceBundle(
+      const scoped_refptr<base::SingleThreadTaskRunner>& db_thread,
+      const scoped_refptr<base::SingleThreadTaskRunner>& file_thread,
+      base::SequencedWorkerPool* worker_pool);
+
   ~ProfileSyncServiceBundle();
 
   // Builders
@@ -70,10 +86,28 @@ class ProfileSyncServiceBundle {
 
     ~SyncClientBuilder();
 
-    // Set the clear browsing data callback for the client to return.
+    // Setters for the various additional data for the client to return.
     void SetClearBrowsingDataCallback(
         sync_driver::ClearBrowsingDataCallback clear_browsing_data_callback);
 
+    void SetPersonalDataManager(
+        autofill::PersonalDataManager* personal_data_manager);
+
+    // The client will call this callback to produce the SyncableService
+    // specific to |type|.
+    void SetSyncableServiceCallback(
+        const base::Callback<base::WeakPtr<syncer::SyncableService>(
+            syncer::ModelType type)>& get_syncable_service_callback);
+
+    // The client will call this callback to produce the SyncService for the
+    // current Profile.
+    void SetSyncServiceCallback(const base::Callback<sync_driver::SyncService*(
+                                    void)>& get_sync_service_callback);
+
+    void SetHistoryService(history::HistoryService* history_service);
+
+    void set_activate_model_creation() { activate_model_creation_ = true; }
+
     scoped_ptr<sync_driver::FakeSyncClient> Build();
 
    private:
@@ -81,6 +115,15 @@ class ProfileSyncServiceBundle {
     ProfileSyncServiceBundle* const bundle_;
 
     sync_driver::ClearBrowsingDataCallback clear_browsing_data_callback_;
+    autofill::PersonalDataManager* personal_data_manager_;
+    base::Callback<base::WeakPtr<syncer::SyncableService>(
+        syncer::ModelType type)>
+        get_syncable_service_callback_;
+    base::Callback<sync_driver::SyncService*(void)> get_sync_service_callback_;
+    history::HistoryService* history_service_ = nullptr;
+    // If set, the built client will be able to build some ModelSafeWorker
+    // instances.
+    bool activate_model_creation_ = false;
 
     DISALLOW_COPY_AND_ASSIGN(SyncClientBuilder);
   };
@@ -116,8 +159,29 @@ class ProfileSyncServiceBundle {
     return &sync_sessions_client_;
   }
 
+  invalidation::FakeInvalidationService* fake_invalidation_service() {
+    return &fake_invalidation_service_;
+  }
+
+  base::SingleThreadTaskRunner* db_thread() { return db_thread_.get(); }
+
+  base::SingleThreadTaskRunner* file_thread() { return file_thread_.get(); }
+
  private:
-  base::SequencedWorkerPoolOwner worker_pool_owner_;
+  struct ThreadProvider;  // Helper to create threads and worker pool.
+
+  // Either |thread_provider| must be null and or the other arguments non-null,
+  // or vice versa.
+  ProfileSyncServiceBundle(
+      scoped_ptr<ThreadProvider> thread_provider,
+      scoped_refptr<base::SingleThreadTaskRunner> db_thread,
+      scoped_refptr<base::SingleThreadTaskRunner> file_thread,
+      base::SequencedWorkerPool* worker_pool);
+
+  scoped_ptr<ThreadProvider> thread_provider_;
+  const scoped_refptr<base::SingleThreadTaskRunner> db_thread_;
+  const scoped_refptr<base::SingleThreadTaskRunner> file_thread_;
+  base::SequencedWorkerPool* const worker_pool_;
   syncable_prefs::TestingPrefServiceSyncable pref_service_;
   TestSigninClient signin_client_;
   AccountTrackerService account_tracker_;
@@ -125,6 +189,7 @@ class ProfileSyncServiceBundle {
   FakeProfileOAuth2TokenService auth_service_;
   SyncApiComponentFactoryMock component_factory_;
   sync_sessions::FakeSyncSessionsClient sync_sessions_client_;
+  invalidation::FakeInvalidationService fake_invalidation_service_;
   scoped_refptr<net::URLRequestContextGetter> url_request_context_;
 
   DISALLOW_COPY_AND_ASSIGN(ProfileSyncServiceBundle);
diff --git a/components/history/core/browser/history_service.h b/components/history/core/browser/history_service.h
index 9c8af63..d1b066a 100644
--- a/components/history/core/browser/history_service.h
+++ b/components/history/core/browser/history_service.h
@@ -150,7 +150,7 @@ class HistoryService : public syncer::SyncableService, public KeyedService {
   // Returns a pointer to the TypedUrlSyncableService owned by HistoryBackend.
   // This method should only be called from the history thread, because the
   // returned service is intended to be accessed only via the history thread.
-  virtual TypedUrlSyncableService* GetTypedUrlSyncableService() const;
+  TypedUrlSyncableService* GetTypedUrlSyncableService() const;
 
   // KeyedService:
   void Shutdown() override;