No protected data members in ProfileSyncService tests

components/browser_sync/browser/abstract_profile_sync_service_test.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/browser_sync/browser/abstract_profile_sync_service_test.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 115 matching lines @@
   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));
 }
 
+// Helper function for return-type-upcasting of the callback.
+sync_driver::SyncService* GetSyncService(
+    base::Callback<TestProfileSyncService*(void)> get_sync_service_callback) {
+  return get_sync_service_callback.Run();
+}
+
 }  // namespace
 
 /* static */
 syncer::ImmutableChangeRecordList
 ProfileSyncServiceTestHelper::MakeSingletonChangeRecordList(
     int64_t node_id,
     syncer::ChangeRecord::Action action) {
   syncer::ChangeRecord record;
   record.action = action;
   record.id = node_id;
@@ skipping 21 matching lines @@
 
 AbstractProfileSyncServiceTest::~AbstractProfileSyncServiceTest() {
   sync_service_->Shutdown();
 }
 
 bool AbstractProfileSyncServiceTest::CreateRoot(ModelType model_type) {
   return syncer::TestUserShare::CreateRoot(model_type,
                                            sync_service_->GetUserShare());
 }
 
-scoped_ptr<TestProfileSyncService>
-AbstractProfileSyncServiceTest::CreateSyncService(
+void 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 =
+  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(),
+          temp_dir_.path(), sync_service_->GetSyncClient(),
           base::ThreadTaskRunnerHandle::Get(),
           profile_sync_service_bundle_.fake_invalidation_service(),
-          sync_service->sync_prefs()->AsWeakPtr(),
+          sync_service_->sync_prefs()->AsWeakPtr(),
           initialization_success_callback)));
 
-  sync_service->SetFirstSetupComplete();
-  return sync_service;
+  sync_service_->SetFirstSetupComplete();
+}
+
+base::Callback<sync_driver::SyncService*(void)>
+AbstractProfileSyncServiceTest::GetSyncServiceCallback() {
+  return base::Bind(GetSyncService,
+                    base::Bind(&AbstractProfileSyncServiceTest::sync_service,
+                               base::Unretained(this)));
 }
 
 CreateRootHelper::CreateRootHelper(AbstractProfileSyncServiceTest* test,
                                    ModelType model_type)
     : callback_(base::Bind(&CreateRootHelper::CreateRootCallback,
                            base::Unretained(this))),
       test_(test),
       model_type_(model_type),
       success_(false) {
 }
 
 CreateRootHelper::~CreateRootHelper() {
 }
 
 const base::Closure& CreateRootHelper::callback() const {
   return callback_;
 }
 
 bool CreateRootHelper::success() {
   return success_;
 }
 
 void CreateRootHelper::CreateRootCallback() {
   success_ = test_->CreateRoot(model_type_);
 }