Revert 289115 "Revert 288464 "[Sync] Cleanup datatype configurat..."

trunk/src/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/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 27 matching lines @@
 using browser_sync::SyncBackendHostMock;
 using content::BrowserThread;
 using sync_driver::DataTypeManager;
 using sync_driver::DataTypeManagerMock;
 using testing::_;
 using testing::AnyNumber;
 using testing::DoAll;
 using testing::InvokeArgument;
 using testing::Mock;
 using testing::Return;
+using testing::SaveArg;
 
 ACTION_P(InvokeOnConfigureStart, pss) {
   ProfileSyncService* service =
       static_cast<ProfileSyncService*>(pss);
   service->OnConfigureStart();
 }
 
-ACTION_P2(InvokeOnConfigureDone, pss, result) {
+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();
   service->OnConfigureDone(configure_result);
 }
 
 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) {}
+        sync_(NULL),
+        failed_data_types_handler_(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() {
+    sync_driver::FailedDataTypesHandler::TypeErrorMap errors;
+    errors[syncer::BOOKMARKS] =
+        syncer::SyncError(FROM_HERE,
+                          syncer::SyncError::UNRECOVERABLE_ERROR,
+                          "Error",
+                          syncer::BOOKMARKS);
+    failed_data_types_handler_->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", "");
 #endif
   }
 
   DataTypeManagerMock* SetUpDataTypeManager() {
     DataTypeManagerMock* data_type_manager = new DataTypeManagerMock();
     EXPECT_CALL(*components_factory_mock(),
                 CreateDataTypeManager(_, _, _, _, _, _)).
-        WillOnce(Return(data_type_manager));
+        WillOnce(DoAll(SaveArg<5>(&failed_data_types_handler_),
+                       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::FailedDataTypesHandler* failed_data_types_handler_;
 };
 
 class ProfileSyncServiceStartupCrosTest : public ProfileSyncServiceStartupTest {
  public:
   virtual void SetUp() {
     ProfileSyncServiceStartupTest::SetUp();
     sync_ = static_cast<ProfileSyncService*>(
         ProfileSyncServiceFactory::GetInstance()->SetTestingFactoryAndUse(
             profile_, BuildCrosService));
     sync_->AddObserver(&observer_);
@@ skipping 327 matching lines @@
 TEST_F(ProfileSyncServiceStartupTest, StartFailure) {
   profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername,
                                   "test_user@gmail.com");
   SigninManagerFactory::GetForProfile(profile_)
       ->SetAuthenticatedUsername("test_user@gmail.com");
   CreateSyncService();
   sync_->SetSyncSetupCompleted();
   SetUpSyncBackendHost();
   DataTypeManagerMock* data_type_manager = SetUpDataTypeManager();
   DataTypeManager::ConfigureStatus status = DataTypeManager::ABORTED;
-  syncer::SyncError error(
-      FROM_HERE,
-      syncer::SyncError::DATATYPE_ERROR,
-      "Association failed.",
-      syncer::BOOKMARKS);
-  std::map<syncer::ModelType, syncer::SyncError> errors;
-  errors[syncer::BOOKMARKS] = error;
   DataTypeManager::ConfigureResult result(
       status,
-      syncer::ModelTypeSet(),
-      errors,
-      syncer::ModelTypeSet(),
       syncer::ModelTypeSet());
-  EXPECT_CALL(*data_type_manager, Configure(_, _)).
-      WillRepeatedly(
-          DoAll(InvokeOnConfigureStart(sync_),
-                InvokeOnConfigureDone(sync_, result)));
+  EXPECT_CALL(*data_type_manager, Configure(_, _)).WillRepeatedly(
+      DoAll(InvokeOnConfigureStart(sync_),
+            InvokeOnConfigureDone(
+                sync_,
+                base::Bind(&ProfileSyncServiceStartupTest::SetError,
+                           base::Unretained(this)),
+                result)));
   EXPECT_CALL(*data_type_manager, state()).
       WillOnce(Return(DataTypeManager::STOPPED));
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
   IssueTestTokens();
   sync_->Initialize();
   EXPECT_TRUE(sync_->HasUnrecoverableError());
 }
 
 TEST_F(ProfileSyncServiceStartupTest, StartDownloadFailed) {
   // Pre load the tokens
   profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername,
                                   "test_user@gmail.com");
   SigninManagerFactory::GetForProfile(profile_)
       ->SetAuthenticatedUsername("test_user@gmail.com");
   CreateSyncService();
   SyncBackendHostMock* mock_sbh = SetUpSyncBackendHost();
   mock_sbh->set_fail_initial_download(true);
 
   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());
 }