[sync] Divorce DataTypeManager from NotificationService notifications by creating a new DataTypeMa…

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 "testing/gtest/include/gtest/gtest.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/signin/signin_manager.h"
@@ skipping 17 matching lines @@
 using browser_sync::DataTypeManager;
 using browser_sync::DataTypeManagerMock;
 using content::BrowserThread;
 using testing::_;
 using testing::AnyNumber;
 using testing::DoAll;
 using testing::InvokeArgument;
 using testing::Mock;
 using testing::Return;
 
+ACTION_P(InvokeOnConfigureStart, pss) {
+  TestProfileSyncService* service = static_cast<TestProfileSyncService*>(pss);
+  service->OnConfigureStart();
+}
+
+ACTION_P2(InvokeOnConfigureDone, pss, result) {
+  TestProfileSyncService* service = static_cast<TestProfileSyncService*>(pss);
+  DataTypeManager::ConfigureResult configure_result =
+      static_cast<DataTypeManager::ConfigureResult>(result);
+  service->OnConfigureDone(configure_result);
+}
+
 // TODO(chron): Test not using cros_user flag and use signin_
 class ProfileSyncServiceStartupTest : public testing::Test {
  public:
   ProfileSyncServiceStartupTest()
       : ui_thread_(BrowserThread::UI, &ui_loop_),
         db_thread_(BrowserThread::DB),
         file_thread_(BrowserThread::FILE),
         io_thread_(BrowserThread::IO),
         profile_(new TestingProfile) {}
 
@@ skipping 33 matching lines @@
         new ProfileSyncComponentsFactoryMock(),
         profile_.get(),
         signin,
         ProfileSyncService::MANUAL_START,
         true,
         base::Closure()));
   }
 
   DataTypeManagerMock* SetUpDataTypeManager() {
     DataTypeManagerMock* data_type_manager = new DataTypeManagerMock();
-    EXPECT_CALL(*factory_mock(), CreateDataTypeManager(_, _)).
+    EXPECT_CALL(*factory_mock(), CreateDataTypeManager(_, _, _)).
         WillOnce(Return(data_type_manager));
     return data_type_manager;
   }
 
   ProfileSyncComponentsFactoryMock* factory_mock() {
    return static_cast<ProfileSyncComponentsFactoryMock*>(service_->factory());
   }
 
   MessageLoop ui_loop_;
   content::TestBrowserThread ui_thread_;
@@ skipping 96 matching lines @@
       chrome::NOTIFICATION_TOKEN_LOADING_FINISHED,
       content::Source<TokenService>(
           TokenServiceFactory::GetForProfile(profile_.get())),
       content::NotificationService::NoDetails());
   service_->SetSetupInProgress(false);
   // Backend should initialize using a bogus GAIA token for credentials.
   EXPECT_TRUE(service_->ShouldPushChanges());
 }
 
 TEST_F(ProfileSyncServiceStartupCrosTest, StartCrosNoCredentials) {
-  EXPECT_CALL(*factory_mock(), CreateDataTypeManager(_, _)).Times(0);
+  EXPECT_CALL(*factory_mock(), CreateDataTypeManager(_, _, _)).Times(0);
   profile_->GetPrefs()->ClearPref(prefs::kSyncHasSetupCompleted);
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
 
   service_->Initialize();
   // Sync should not start because there are no tokens yet.
   EXPECT_FALSE(service_->ShouldPushChanges());
   EXPECT_FALSE(service_->GetBackendForTest());
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_TOKEN_LOADING_FINISHED,
       content::Source<TokenService>(
@@ skipping 33 matching lines @@
   TokenServiceFactory::GetForProfile(profile_.get())->IssueAuthTokenForTest(
       GaiaConstants::kSyncService, "sync_token");
   profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername, "test_user");
   service_->Initialize();
 }
 
 TEST_F(ProfileSyncServiceStartupTest, ManagedStartup) {
   // Disable sync through policy.
   profile_->GetPrefs()->SetBoolean(prefs::kSyncManaged, true);
 
-  EXPECT_CALL(*factory_mock(), CreateDataTypeManager(_, _)).Times(0);
+  EXPECT_CALL(*factory_mock(), CreateDataTypeManager(_, _, _)).Times(0);
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
 
   // Service should not be started by Initialize() since it's managed.
   TokenServiceFactory::GetForProfile(profile_.get())->IssueAuthTokenForTest(
       GaiaConstants::kSyncService, "sync_token");
   profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername, "test_user");
   service_->Initialize();
 }
 
 TEST_F(ProfileSyncServiceStartupTest, SwitchManaged) {
@@ skipping 10 matching lines @@
   Mock::VerifyAndClearExpectations(data_type_manager);
   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(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(*factory_mock(), CreateDataTypeManager(_, _)).Times(0);
+  EXPECT_CALL(*factory_mock(), CreateDataTypeManager(_, _, _)).Times(0);
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
   profile_->GetPrefs()->ClearPref(prefs::kSyncManaged);
 }
 
 TEST_F(ProfileSyncServiceStartupTest, StartFailure) {
   DataTypeManagerMock* data_type_manager = SetUpDataTypeManager();
   DataTypeManager::ConfigureStatus status = DataTypeManager::ABORTED;
   syncer::SyncError error(
       FROM_HERE, "Association failed.", syncer::BOOKMARKS);
   std::list<syncer::SyncError> errors;
   errors.push_back(error);
-  browser_sync::DataTypeManager::ConfigureResult result(
+  DataTypeManager::ConfigureResult result(
       status,
       syncer::ModelTypeSet(),
       errors,
       syncer::ModelTypeSet());
   EXPECT_CALL(*data_type_manager, Configure(_, _)).
       WillRepeatedly(
-          DoAll(
-              NotifyFromDataTypeManager(data_type_manager,
-                  static_cast<int>(chrome::NOTIFICATION_SYNC_CONFIGURE_START)),
-              NotifyFromDataTypeManagerWithResult(data_type_manager,
-                  static_cast<int>(chrome::NOTIFICATION_SYNC_CONFIGURE_DONE),
-                  &result)));
+          DoAll(InvokeOnConfigureStart(service_.get()),
+                InvokeOnConfigureDone(service_.get(), result)));
   EXPECT_CALL(*data_type_manager, state()).
       WillOnce(Return(DataTypeManager::STOPPED));
 
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
 
   TokenServiceFactory::GetForProfile(profile_.get())->IssueAuthTokenForTest(
       GaiaConstants::kSyncService, "sync_token");
   profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername, "test_user");
   service_->Initialize();
   EXPECT_TRUE(service_->HasUnrecoverableError());
 }
 
 TEST_F(ProfileSyncServiceStartupTest, StartDownloadFailed) {
   profile_->GetPrefs()->ClearPref(prefs::kSyncHasSetupCompleted);
 
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
 
   // Preload the tokens.
   TokenServiceFactory::GetForProfile(profile_.get())->IssueAuthTokenForTest(
       GaiaConstants::kSyncService, "sync_token");
   service_->fail_initial_download();
 
   service_->Initialize();
   EXPECT_FALSE(service_->sync_initialized());
   EXPECT_FALSE(service_->GetBackendForTest());
 }