Revert of [Sync] Stop accessing BrowserContextKeyedServiceFactory on non-UI thread.

components/sync/driver/generic_change_processor_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/sync/driver/generic_change_processor.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 106 matching lines @@
 };
 
 class SyncGenericChangeProcessorTest : public testing::Test {
  public:
   // Most test cases will use this type.  For those that need a
   // GenericChangeProcessor for a different type, use |InitializeForType|.
   static const ModelType kType = PREFERENCES;
 
   SyncGenericChangeProcessorTest()
       : syncable_service_ptr_factory_(&fake_syncable_service_),
-        mock_attachment_service_(nullptr) {}
+        mock_attachment_service_(nullptr),
+        sync_client_(&sync_factory_) {}
 
   void SetUp() override {
     // Use kType by default, but allow test cases to re-initialize with whatever
     // type they choose.  Therefore, it's important that all type dependent
     // initialization occurs in InitializeForType.
     InitializeForType(kType);
   }
 
   void TearDown() override {
     mock_attachment_service_ = nullptr;
@@ skipping 21 matching lines @@
     ConstructGenericChangeProcessor(type);
   }
 
   void ConstructGenericChangeProcessor(ModelType type) {
     std::unique_ptr<AttachmentStore> attachment_store =
         AttachmentStore::CreateInMemoryStore();
     change_processor_ = base::MakeUnique<GenericChangeProcessor>(
         type, base::MakeUnique<DataTypeErrorHandlerMock>(),
         syncable_service_ptr_factory_.GetWeakPtr(),
         merge_result_ptr_factory_->GetWeakPtr(), test_user_share_->user_share(),
-        &sync_factory_, attachment_store->CreateAttachmentStoreForSync());
+        &sync_client_, attachment_store->CreateAttachmentStoreForSync());
     mock_attachment_service_ = sync_factory_.GetMockAttachmentService();
   }
 
   void BuildChildNodes(ModelType type, int n) {
     WriteTransaction trans(FROM_HERE, user_share());
     for (int i = 0; i < n; ++i) {
       WriteNode node(&trans);
       node.InitUniqueByCreation(type, base::StringPrintf("node%05d", i));
     }
   }
@@ skipping 16 matching lines @@
 
   std::unique_ptr<SyncMergeResult> sync_merge_result_;
   std::unique_ptr<base::WeakPtrFactory<SyncMergeResult>>
       merge_result_ptr_factory_;
 
   FakeSyncableService fake_syncable_service_;
   base::WeakPtrFactory<FakeSyncableService> syncable_service_ptr_factory_;
 
   std::unique_ptr<TestUserShare> test_user_share_;
   MockAttachmentService* mock_attachment_service_;
+  FakeSyncClient sync_client_;
   MockSyncApiComponentFactory sync_factory_;
 
   std::unique_ptr<GenericChangeProcessor> change_processor_;
 };
 
 // Similar to above, but focused on the method that implements sync/api
 // interfaces and is hence exposed to datatypes directly.
 TEST_F(SyncGenericChangeProcessorTest, StressGetAllSyncData) {
   const int kNumChildNodes = 1000;
   const int kRepeatCount = 1;
@@ skipping 283 matching lines @@
   SyncDataList sync_data = change_processor()->GetAllSyncData(SESSIONS);
   ASSERT_EQ(sync_data.size(), 1U);
   ASSERT_EQ("session tag 2",
             sync_data[0].GetSpecifics().session().session_tag());
   EXPECT_FALSE(SyncDataRemote(sync_data[0]).GetClientTagHash().empty());
 }
 
 }  // namespace
 
 }  // namespace syncer