sync: centralize sync startup decisions in TryStart.

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 30 matching lines @@
   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);
 }
 
+class FakeTokenService : public TokenService {
+ public:
+  FakeTokenService() {}
+  virtual ~FakeTokenService() {}
+
+  virtual void LoadTokensFromDB() OVERRIDE {
+    TokenService::set_tokens_loaded(true);
+    content::NotificationService::current()->Notify(
+        chrome::NOTIFICATION_TOKEN_LOADING_FINISHED,
+        content::Source<TokenService>(this),
+        content::NotificationService::NoDetails());
+  }
+};
+
 // 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 108 matching lines @@
   service_->SetSetupInProgress(true);
   service_->signin()->StartSignIn("test_user", "", "", "");
   TokenServiceFactory::GetForProfile(profile_.get())->IssueAuthTokenForTest(
       GaiaConstants::kSyncService, "sync_token");
   TokenServiceFactory::GetForProfile(profile_.get())->IssueAuthTokenForTest(
       GaiaConstants::kGaiaOAuth2LoginRefreshToken, "oauth2_login_token");
   service_->SetSetupInProgress(false);
   EXPECT_TRUE(service_->ShouldPushChanges());
 }
 
+ProfileKeyedService* BuildFakeTokenService(Profile* profile) {
+  return new FakeTokenService();
+}
+
 TEST_F(ProfileSyncServiceStartupTest, StartNoCredentials) {
   DataTypeManagerMock* data_type_manager = SetUpDataTypeManager();
   EXPECT_CALL(*data_type_manager, Configure(_, _)).Times(0);
+  TokenService* token_service = static_cast<TokenService*>(
+      TokenServiceFactory::GetInstance()->SetTestingFactoryAndUse(
+          profile_.get(), BuildFakeTokenService));
 
   // We've never completed startup.
   profile_->GetPrefs()->ClearPref(prefs::kSyncHasSetupCompleted);
   // Make sure SigninManager doesn't think we're signed in (undoes the call to
   // SetAuthenticatedUsername() in CreateSyncService()).
   SigninManagerFactory::GetForProfile(profile_.get())->SignOut();
 
   // Should not actually start, rather just clean things up and wait
   // to be enabled.
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
   service_->Initialize();
   EXPECT_FALSE(service_->GetBackendForTest());
 
   // Preferences should be back to defaults.
   EXPECT_EQ(0, profile_->GetPrefs()->GetInt64(prefs::kSyncLastSyncedTime));
   EXPECT_FALSE(profile_->GetPrefs()->GetBoolean(prefs::kSyncHasSetupCompleted));
   Mock::VerifyAndClearExpectations(data_type_manager);
 
   // Then start things up.
   EXPECT_CALL(*data_type_manager, Configure(_, _)).Times(1);
   EXPECT_CALL(*data_type_manager, state()).
       WillOnce(Return(DataTypeManager::CONFIGURED)).
       WillOnce(Return(DataTypeManager::CONFIGURED));
   EXPECT_CALL(*data_type_manager, Stop()).Times(1);
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
 
   service_->SetSetupInProgress(true);
   service_->signin()->StartSignIn("test_user", "", "", "");
   // NOTE: Unlike StartFirstTime, this test does not issue any auth tokens.
-  content::NotificationService::current()->Notify(
-      chrome::NOTIFICATION_TOKEN_LOADING_FINISHED,
-      content::Source<TokenService>(
-          TokenServiceFactory::GetForProfile(profile_.get())),
-      content::NotificationService::NoDetails());
+  token_service->LoadTokensFromDB();
   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);
   profile_->GetPrefs()->ClearPref(prefs::kSyncHasSetupCompleted);
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
+  TokenService* token_service = static_cast<TokenService*>(
+      TokenServiceFactory::GetInstance()->SetTestingFactoryAndUse(
+          profile_.get(), BuildFakeTokenService));
 
   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>(
-          TokenServiceFactory::GetForProfile(profile_.get())),
-      content::NotificationService::NoDetails());
+  token_service->LoadTokensFromDB();
   service_->SetSetupInProgress(false);
   // Sync should not start because there are still no tokens.
   EXPECT_FALSE(service_->ShouldPushChanges());
   EXPECT_FALSE(service_->GetBackendForTest());
 }
 
 TEST_F(ProfileSyncServiceStartupCrosTest, StartFirstTime) {
   DataTypeManagerMock* data_type_manager = SetUpDataTypeManager();
   profile_->GetPrefs()->ClearPref(prefs::kSyncHasSetupCompleted);
   EXPECT_CALL(*data_type_manager, Configure(_, _));
@@ skipping 155 matching lines @@
 
   // 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());
 }