This is the third CL of several that will eventually replace TokenService with

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/prefs/pref_service.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/signin/fake_signin_manager.h"
@@ skipping 40 matching lines @@
 }
 
 ACTION_P2(InvokeOnConfigureDone, pss, result) {
   ProfileSyncService* service =
       static_cast<ProfileSyncService*>(pss);
   DataTypeManager::ConfigureResult configure_result =
       static_cast<DataTypeManager::ConfigureResult>(result);
   service->OnConfigureDone(configure_result);
 }
 
-class FakeTokenService : public TokenService {
- public:
-  FakeTokenService() {}
-  virtual ~FakeTokenService() {}
-
-  virtual void LoadTokensFromDB() OVERRIDE {
-    set_tokens_loaded(true);
-    content::NotificationService::current()->Notify(
-        chrome::NOTIFICATION_TOKEN_LOADING_FINISHED,
-        content::Source<TokenService>(this),
-        content::NotificationService::NoDetails());
-  }
-
-  static BrowserContextKeyedService* BuildFakeTokenService(
-      content::BrowserContext* profile) {
-    return new FakeTokenService();
-  }
-};
-
 class ProfileSyncServiceStartupTest : public testing::Test {
  public:
   ProfileSyncServiceStartupTest()
       : thread_bundle_(content::TestBrowserThreadBundle::REAL_DB_THREAD |
                        content::TestBrowserThreadBundle::REAL_FILE_THREAD |
                        content::TestBrowserThreadBundle::REAL_IO_THREAD),
         sync_(NULL) {}
 
   virtual ~ProfileSyncServiceStartupTest() {
   }
 
   virtual void SetUp() {
     profile_ = CreateProfile();
   }
 
   virtual scoped_ptr<TestingProfile> CreateProfile() {
     TestingProfile::Builder builder;
 #if defined(OS_CHROMEOS)
     builder.AddTestingFactory(SigninManagerFactory::GetInstance(),
                               FakeSigninManagerBase::Build);
 #else
     builder.AddTestingFactory(SigninManagerFactory::GetInstance(),
                               FakeSigninManager::Build);
 #endif
     builder.AddTestingFactory(ProfileOAuth2TokenServiceFactory::GetInstance(),
                               FakeOAuth2TokenService::BuildTokenService);
     builder.AddTestingFactory(ProfileSyncServiceFactory::GetInstance(),
-                              ProfileSyncServiceStartupTest::BuildService);
-    builder.AddTestingFactory(TokenServiceFactory::GetInstance(),
-                              FakeTokenService::BuildFakeTokenService);
+                              BuildService);
     return builder.Build();
   }
 
   virtual void TearDown() {
     sync_->RemoveObserver(&observer_);
     profile_.reset();
   }
 
   static BrowserContextKeyedService* BuildService(
       content::BrowserContext* browser_context) {
@@ skipping 123 matching lines @@
   sync_->SetSetupInProgress(false);
   EXPECT_TRUE(sync_->ShouldPushChanges());
 }
 
 // TODO(pavely): Reenable test once android is switched to oauth2.
 TEST_F(ProfileSyncServiceStartupTest, DISABLED_StartNoCredentials) {
   // We've never completed startup.
   profile_->GetPrefs()->ClearPref(prefs::kSyncHasSetupCompleted);
   SigninManagerFactory::GetForProfile(
       profile_.get())->Initialize(profile_.get(), NULL);
-  TokenService* token_service = static_cast<TokenService*>(
-      TokenServiceFactory::GetForProfile(profile_.get()));
   CreateSyncService();
 
   // Should not actually start, rather just clean things up and wait
   // to be enabled.
   EXPECT_CALL(*components_factory_mock(),
               CreateDataTypeManager(_, _, _, _, _, _)).Times(0);
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
   sync_->Initialize();
 
   // Preferences should be back to defaults.
   EXPECT_EQ(0, profile_->GetPrefs()->GetInt64(prefs::kSyncLastSyncedTime));
   EXPECT_FALSE(profile_->GetPrefs()->GetBoolean(prefs::kSyncHasSetupCompleted));
 
   // Then start things up.
   sync_->SetSetupInProgress(true);
 
   // Simulate successful signin as test_user.
   profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername,
                                   "test_user@gmail.com");
   sync_->signin()->SetAuthenticatedUsername("test_user@gmail.com");
   GoogleServiceSigninSuccessDetails details("test_user@gmail.com", "");
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_GOOGLE_SIGNIN_SUCCESSFUL,
       content::Source<Profile>(profile_.get()),
       content::Details<const GoogleServiceSigninSuccessDetails>(&details));
-  // NOTE: Unlike StartFirstTime, this test does not issue any auth tokens.
-  token_service->LoadTokensFromDB();
+  ProfileOAuth2TokenService* token_service =
+    ProfileOAuth2TokenServiceFactory::GetForProfile(profile_.get());
+  token_service->LoadCredentials();
 
   sync_->SetSetupInProgress(false);
   // ProfileSyncService should try to start by requesting access token.
-  // This request should fail as login token was not issued to TokenService.
+  // This request should fail as login token was not issued.
   EXPECT_FALSE(sync_->ShouldPushChanges());
   EXPECT_EQ(GoogleServiceAuthError::USER_NOT_SIGNED_UP,
       sync_->GetAuthError().state());
 }
 
 // TODO(pavely): Reenable test once android is switched to oauth2.
 TEST_F(ProfileSyncServiceStartupTest, DISABLED_StartInvalidCredentials) {
   profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername,
                                   "test_user@gmail.com");
   SigninManagerFactory::GetForProfile(
       profile_.get())->Initialize(profile_.get(), NULL);
   CreateSyncService();
   SyncBackendHostMock* mock_sbh = SetUpSyncBackendHost();
 
   // Tell the backend to stall while downloading control types (simulating an
   // auth error).
   mock_sbh->set_fail_initial_download(true);
 
   DataTypeManagerMock* data_type_manager = SetUpDataTypeManager();
   EXPECT_CALL(*data_type_manager, Configure(_, _)).Times(0);
-  // Issue login token so that ProfileSyncServer tries to initialize backend.
-  TokenServiceFactory::GetForProfile(profile_.get())->IssueAuthTokenForTest(
-      GaiaConstants::kGaiaOAuth2LoginRefreshToken, "oauth2_login_token");
 
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
   sync_->Initialize();
   EXPECT_FALSE(sync_->sync_initialized());
   Mock::VerifyAndClearExpectations(data_type_manager);
 
   // Update the credentials, unstalling the backend.
   EXPECT_CALL(*data_type_manager, Configure(_, _));
   EXPECT_CALL(*data_type_manager, state()).
       WillRepeatedly(Return(DataTypeManager::CONFIGURED));
   EXPECT_CALL(*data_type_manager, Stop()).Times(1);
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
   sync_->SetSetupInProgress(true);
 
   // Simulate successful signin.
   GoogleServiceSigninSuccessDetails details("test_user@gmail.com",
                                             std::string());
   content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_GOOGLE_SIGNIN_SUCCESSFUL,
         content::Source<Profile>(profile_.get()),
         content::Details<const GoogleServiceSigninSuccessDetails>(&details));
 
-  TokenServiceFactory::GetForProfile(profile_.get())->IssueAuthTokenForTest(
-      GaiaConstants::kGaiaOAuth2LoginRefreshToken, "oauth2_login_token");
   sync_->SetSetupInProgress(false);
 
   // Verify we successfully finish startup and configuration.
   EXPECT_TRUE(sync_->ShouldPushChanges());
 }
 
 TEST_F(ProfileSyncServiceStartupCrosTest, StartCrosNoCredentials) {
   EXPECT_CALL(*components_factory_mock(),
               CreateDataTypeManager(_, _, _, _, _, _)).Times(0);
   EXPECT_CALL(*components_factory_mock(),
               CreateSyncBackendHost(_, _, _)).Times(0);
   profile_->GetPrefs()->ClearPref(prefs::kSyncHasSetupCompleted);
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
-  TokenService* token_service = static_cast<TokenService*>(
-      TokenServiceFactory::GetForProfile(profile_.get()));
+  ProfileOAuth2TokenService* token_service =
+    ProfileOAuth2TokenServiceFactory::GetForProfile(profile_.get());
 
   sync_->Initialize();
   // Sync should not start because there are no tokens yet.
   EXPECT_FALSE(sync_->ShouldPushChanges());
-  token_service->LoadTokensFromDB();
+  token_service->LoadCredentials();
   sync_->SetSetupInProgress(false);
 
   // Sync should not start because there are still no tokens.
   EXPECT_FALSE(sync_->ShouldPushChanges());
 }
 
 TEST_F(ProfileSyncServiceStartupCrosTest, StartFirstTime) {
   SetUpSyncBackendHost();
   DataTypeManagerMock* data_type_manager = SetUpDataTypeManager();
   profile_->GetPrefs()->ClearPref(prefs::kSyncHasSetupCompleted);
@@ skipping 99 matching lines @@
   SigninManagerFactory::GetForProfile(profile_.get())->Initialize(
       profile_.get(), NULL);
   CreateSyncService();
 
   // Disable sync through policy.
   profile_->GetPrefs()->SetBoolean(prefs::kSyncManaged, true);
   EXPECT_CALL(*components_factory_mock(),
               CreateDataTypeManager(_, _, _, _, _, _)).Times(0);
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
 
-  TokenServiceFactory::GetForProfile(profile_.get())->IssueAuthTokenForTest(
-      GaiaConstants::kGaiaOAuth2LoginRefreshToken, "oauth2_login_token");
   sync_->Initialize();
 }
 
 TEST_F(ProfileSyncServiceStartupTest, SwitchManaged) {
   profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername,
                                   "test_user@gmail.com");
   SigninManagerFactory::GetForProfile(profile_.get())->Initialize(
       profile_.get(), NULL);
   CreateSyncService();
   sync_->SetSyncSetupCompleted();
@@ skipping 69 matching lines @@
   profile_->GetPrefs()->ClearPref(prefs::kSyncHasSetupCompleted);
 
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
   IssueTestTokens();
 
   sync_->SetSetupInProgress(true);
   sync_->Initialize();
   sync_->SetSetupInProgress(false);
   EXPECT_FALSE(sync_->sync_initialized());
 }