[Sync] Move DataTypeStatusTable ownership into DataTypeManager.

chrome/browser/sync/profile_sync_service_startup_unittest.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 "base/files/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/prefs/pref_service_syncable.h"
 #include "chrome/browser/signin/fake_profile_oauth2_token_service.h"
@@ skipping 41 matching lines @@
       static_cast<ProfileSyncService*>(pss);
   service->OnConfigureStart();
 }
 
 ACTION_P3(InvokeOnConfigureDone, pss, error_callback, result) {
   ProfileSyncService* service =
       static_cast<ProfileSyncService*>(pss);
   DataTypeManager::ConfigureResult configure_result =
       static_cast<DataTypeManager::ConfigureResult>(result);
   if (result.status == sync_driver::DataTypeManager::ABORTED)
-    error_callback.Run();
+    error_callback.Run(&configure_result);
   service->OnConfigureDone(configure_result);
 }
 
 class TestProfileSyncServiceNoBackup : public ProfileSyncService {
  public:
   TestProfileSyncServiceNoBackup(
       scoped_ptr<ProfileSyncComponentsFactory> factory,
       Profile* profile,
       scoped_ptr<SupervisedUserSigninManagerWrapper> signin_wrapper,
       ProfileOAuth2TokenService* oauth2_token_service,
       browser_sync::ProfileSyncServiceStartBehavior start_behavior)
      : ProfileSyncService(factory.Pass(), profile, signin_wrapper.Pass(),
                           oauth2_token_service, start_behavior) {}
 
  protected:
   virtual bool NeedBackup() const OVERRIDE {
     return false;
   }
 };
 
 class ProfileSyncServiceStartupTest : public testing::Test {
  public:
   ProfileSyncServiceStartupTest()
       : thread_bundle_(content::TestBrowserThreadBundle::REAL_DB_THREAD |
                        content::TestBrowserThreadBundle::REAL_FILE_THREAD |
                        content::TestBrowserThreadBundle::REAL_IO_THREAD),
         profile_manager_(TestingBrowserProcess::GetGlobal()),
-        sync_(NULL),
-        data_type_status_table_(NULL) {}
+        sync_(NULL) {}
 
   virtual ~ProfileSyncServiceStartupTest() {
   }
 
   virtual void SetUp() {
     CHECK(profile_manager_.SetUp());
 
     TestingProfile::TestingFactories testing_facotries;
     testing_facotries.push_back(
         std::make_pair(SigninManagerFactory::GetInstance(),
@@ skipping 39 matching lines @@
   }
 
   ProfileSyncComponentsFactoryMock* components_factory_mock() {
     return static_cast<ProfileSyncComponentsFactoryMock*>(sync_->factory());
   }
 
   FakeSigninManagerForTesting* fake_signin() {
     return static_cast<FakeSigninManagerForTesting*>(sync_->signin());
   }
 
-  void SetError() {
+  void SetError(DataTypeManager::ConfigureResult* result) {
     sync_driver::DataTypeStatusTable::TypeErrorMap errors;
     errors[syncer::BOOKMARKS] =
         syncer::SyncError(FROM_HERE,
                           syncer::SyncError::UNRECOVERABLE_ERROR,
                           "Error",
                           syncer::BOOKMARKS);
-    data_type_status_table_->UpdateFailedDataTypes(errors);
+    result->data_type_status_table.UpdateFailedDataTypes(errors);
   }
 
  protected:
   void SimulateTestUserSignin() {
     profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername,
                                     "test_user@gmail.com");
 #if !defined(OS_CHROMEOS)
     fake_signin()->SignIn("test_user@gmail.com", "");
 #else
     fake_signin()->SetAuthenticatedUsername("test_user@gmail.com");
     sync_->GoogleSigninSucceeded("test_user@gmail.com",
                                  "test_user@gmail.com",
                                  "");
 #endif
   }
 
   DataTypeManagerMock* SetUpDataTypeManager() {
     DataTypeManagerMock* data_type_manager = new DataTypeManagerMock();
     EXPECT_CALL(*components_factory_mock(),
-                CreateDataTypeManager(_, _, _, _, _, _)).
-        WillOnce(DoAll(SaveArg<5>(&data_type_status_table_),
-                       Return(data_type_manager)));
+                CreateDataTypeManager(_, _, _, _, _)).
+        WillOnce(Return(data_type_manager));
     return data_type_manager;
   }
 
   browser_sync::SyncBackendHostMock* SetUpSyncBackendHost() {
     browser_sync::SyncBackendHostMock* sync_backend_host =
         new browser_sync::SyncBackendHostMock();
     EXPECT_CALL(*components_factory_mock(),
                 CreateSyncBackendHost(_, _, _, _, _)).
         WillOnce(Return(sync_backend_host));
     return sync_backend_host;
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
   TestingProfileManager profile_manager_;
   TestingProfile* profile_;
   ProfileSyncService* sync_;
   ProfileSyncServiceObserverMock observer_;
-  sync_driver::DataTypeStatusTable* data_type_status_table_;
+  sync_driver::DataTypeStatusTable data_type_status_table_;
 };
 
 class ProfileSyncServiceStartupCrosTest : public ProfileSyncServiceStartupTest {
  public:
   virtual void SetUp() {
     ProfileSyncServiceStartupTest::SetUp();
     sync_ = static_cast<ProfileSyncService*>(
         ProfileSyncServiceFactory::GetInstance()->SetTestingFactoryAndUse(
             profile_, BuildCrosService));
     sync_->AddObserver(&observer_);
@@ skipping 63 matching lines @@
 
 // TODO(pavely): Reenable test once android is switched to oauth2.
 TEST_F(ProfileSyncServiceStartupTest, DISABLED_StartNoCredentials) {
   // We've never completed startup.
   profile_->GetPrefs()->ClearPref(sync_driver::prefs::kSyncHasSetupCompleted);
   CreateSyncService();
 
   // Should not actually start, rather just clean things up and wait
   // to be enabled.
   EXPECT_CALL(*components_factory_mock(),
-              CreateDataTypeManager(_, _, _, _, _, _)).Times(0);
+              CreateDataTypeManager(_, _, _, _, _)).Times(0);
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
   sync_->Initialize();
 
   // Preferences should be back to defaults.
   EXPECT_EQ(
       0,
       profile_->GetPrefs()->GetInt64(sync_driver::prefs::kSyncLastSyncedTime));
   EXPECT_FALSE(profile_->GetPrefs()->GetBoolean(
       sync_driver::prefs::kSyncHasSetupCompleted));
 
@@ skipping 53 matching lines @@
 }
 
 #if defined(OS_WIN)
 // http://crbug.com/396402
 #define MAYBE_StartCrosNoCredentials DISABLED_StartCrosNoCredentials
 #else
 #define MAYBE_StartCrosNoCredentials StartCrosNoCredentials
 #endif
 TEST_F(ProfileSyncServiceStartupCrosTest, MAYBE_StartCrosNoCredentials) {
   EXPECT_CALL(*components_factory_mock(),
-              CreateDataTypeManager(_, _, _, _, _, _)).Times(0);
+              CreateDataTypeManager(_, _, _, _, _)).Times(0);
   EXPECT_CALL(*components_factory_mock(),
               CreateSyncBackendHost(_, _, _, _, _)).Times(0);
   profile_->GetPrefs()->ClearPref(sync_driver::prefs::kSyncHasSetupCompleted);
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
 
   sync_->Initialize();
   // Sync should not start because there are no tokens yet.
   EXPECT_FALSE(sync_->ShouldPushChanges());
   sync_->SetSetupInProgress(false);
 
@@ skipping 122 matching lines @@
 #endif
 TEST_F(ProfileSyncServiceStartupTest, MAYBE_ManagedStartup) {
   // Service should not be started by Initialize() since it's managed.
   profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername,
                                   "test_user@gmail.com");
   CreateSyncService();
 
   // Disable sync through policy.
   profile_->GetPrefs()->SetBoolean(sync_driver::prefs::kSyncManaged, true);
   EXPECT_CALL(*components_factory_mock(),
-              CreateDataTypeManager(_, _, _, _, _, _)).Times(0);
+              CreateDataTypeManager(_, _, _, _, _)).Times(0);
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
 
   sync_->Initialize();
 }
 
 TEST_F(ProfileSyncServiceStartupTest, SwitchManaged) {
   profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername,
                                   "test_user@gmail.com");
   SigninManagerFactory::GetForProfile(profile_)
       ->SetAuthenticatedUsername("test_user@gmail.com");
@@ skipping 11 matching lines @@
   EXPECT_CALL(*data_type_manager, state()).
       WillOnce(Return(DataTypeManager::CONFIGURED));
   EXPECT_CALL(*data_type_manager, Stop()).Times(1);
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
   profile_->GetPrefs()->SetBoolean(sync_driver::prefs::kSyncManaged, true);
 
   // When switching back to unmanaged, the state should change, but the service
   // should not start up automatically (kSyncSetupCompleted will be false).
   Mock::VerifyAndClearExpectations(data_type_manager);
   EXPECT_CALL(*components_factory_mock(),
-              CreateDataTypeManager(_, _, _, _, _, _)).Times(0);
+              CreateDataTypeManager(_, _, _, _, _)).Times(0);
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
   profile_->GetPrefs()->ClearPref(sync_driver::prefs::kSyncManaged);
 }
 
 TEST_F(ProfileSyncServiceStartupTest, StartFailure) {
   profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername,
                                   "test_user@gmail.com");
   SigninManagerFactory::GetForProfile(profile_)
       ->SetAuthenticatedUsername("test_user@gmail.com");
   CreateSyncService();
@@ skipping 32 matching lines @@
   profile_->GetPrefs()->ClearPref(sync_driver::prefs::kSyncHasSetupCompleted);
 
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
   sync_->Initialize();
 
   sync_->SetSetupInProgress(true);
   IssueTestTokens();
   sync_->SetSetupInProgress(false);
   EXPECT_FALSE(sync_->sync_initialized());
 }