| // Copyright 2014 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 "chrome/browser/sync/startup_controller.h" |
| |
| #include "base/command_line.h" |
| #include "base/message_loop/message_loop.h" |
| #include "base/run_loop.h" |
| #include "base/time/time.h" |
| #include "chrome/browser/defaults.h" |
| #include "chrome/browser/signin/fake_profile_oauth2_token_service.h" |
| #include "chrome/browser/signin/fake_profile_oauth2_token_service_builder.h" |
| #include "chrome/browser/signin/profile_oauth2_token_service_factory.h" |
| #include "chrome/browser/sync/managed_user_signin_manager_wrapper.h" |
| #include "chrome/common/chrome_switches.h" |
| #include "chrome/test/base/testing_profile.h" |
| #include "components/sync_driver/sync_prefs.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace browser_sync { |
| |
| static const char kTestUser[] = "test@gmail.com"; |
| static const char kTestToken[] = "testToken"; |
| |
| // These are coupled to the implementation of StartupController's |
| // GetBackendInitializationStateString which is used by about:sync. We use it |
| // as a convenient way to verify internal state and that the class is |
| // outputting the correct values for the debug string. |
| static const char kStateStringStarted[] = "Started"; |
| static const char kStateStringDeferred[] = "Deferred"; |
| static const char kStateStringNotStarted[] = "Not started"; |
| |
| class FakeManagedUserSigninManagerWrapper |
| : public ManagedUserSigninManagerWrapper { |
| public: |
| FakeManagedUserSigninManagerWrapper() |
| : ManagedUserSigninManagerWrapper(NULL, NULL) {} |
| virtual std::string GetEffectiveUsername() const OVERRIDE { |
| return account_; |
| } |
| |
| virtual std::string GetAccountIdToUse() const OVERRIDE { |
| return account_; |
| } |
| |
| void set_account(const std::string& account) { account_ = account; } |
| |
| private: |
| std::string account_; |
| }; |
| |
| class StartupControllerTest : public testing::Test { |
| public: |
| StartupControllerTest() : started_(false) {} |
| |
| virtual void SetUp() OVERRIDE { |
| profile_.reset(new TestingProfile()); |
| sync_prefs_.reset(new sync_driver::SyncPrefs(profile_->GetPrefs())); |
| token_service_.reset(static_cast<FakeProfileOAuth2TokenService*>( |
| BuildFakeProfileOAuth2TokenService(profile_.get()))); |
| signin_.reset(new FakeManagedUserSigninManagerWrapper()); |
| |
| ProfileSyncServiceStartBehavior behavior = |
| browser_defaults::kSyncAutoStarts ? AUTO_START : MANUAL_START; |
| base::Closure fake_start_backend = base::Bind( |
| &StartupControllerTest::FakeStartBackend, base::Unretained(this)); |
| controller_.reset(new StartupController(behavior, token_service(), |
| sync_prefs_.get(), signin_.get(), |
| fake_start_backend)); |
| controller_->Reset(syncer::UserTypes()); |
| controller_->OverrideFallbackTimeoutForTest( |
| base::TimeDelta::FromSeconds(0)); |
| } |
| |
| virtual void TearDown() OVERRIDE { |
| controller_.reset(); |
| signin_.reset(); |
| token_service_->Shutdown(); |
| token_service_.reset(); |
| sync_prefs_.reset(); |
| started_ = false; |
| } |
| |
| void FakeStartBackend() { |
| started_ = true; |
| } |
| |
| bool started() const { return started_; } |
| void clear_started() { started_ = false; } |
| StartupController* controller() { return controller_.get(); } |
| FakeManagedUserSigninManagerWrapper* signin() { return signin_.get(); } |
| FakeProfileOAuth2TokenService* token_service() { |
| return token_service_.get(); |
| } |
| sync_driver::SyncPrefs* sync_prefs() { return sync_prefs_.get(); } |
| Profile* profile() { return profile_.get(); } |
| |
| private: |
| bool started_; |
| base::MessageLoop message_loop_; |
| scoped_ptr<StartupController> controller_; |
| scoped_ptr<FakeManagedUserSigninManagerWrapper> signin_; |
| scoped_ptr<FakeProfileOAuth2TokenService> token_service_; |
| scoped_ptr<sync_driver::SyncPrefs> sync_prefs_; |
| scoped_ptr<TestingProfile> profile_; |
| }; |
| |
| // Test that sync doesn't start until all conditions are met. |
| TEST_F(StartupControllerTest, Basic) { |
| controller()->TryStart(); |
| EXPECT_FALSE(started()); |
| sync_prefs()->SetSyncSetupCompleted(); |
| controller()->TryStart(); |
| EXPECT_FALSE(started()); |
| signin()->set_account(kTestUser); |
| controller()->TryStart(); |
| EXPECT_FALSE(started()); |
| token_service()->IssueRefreshTokenForUser(kTestUser, kTestToken); |
| const bool deferred_start = !CommandLine::ForCurrentProcess()-> |
| HasSwitch(switches::kSyncDisableDeferredStartup); |
| controller()->TryStart(); |
| EXPECT_EQ(!deferred_start, started()); |
| std::string state(controller()->GetBackendInitializationStateString()); |
| EXPECT_TRUE(deferred_start ? state == kStateStringDeferred : |
| state == kStateStringStarted); |
| } |
| |
| // Test that sync doesn't when suppressed even if all other conditons are met. |
| TEST_F(StartupControllerTest, Suppressed) { |
| sync_prefs()->SetSyncSetupCompleted(); |
| sync_prefs()->SetStartSuppressed(true); |
| signin()->set_account(kTestUser); |
| token_service()->IssueRefreshTokenForUser(kTestUser, kTestToken); |
| controller()->TryStart(); |
| EXPECT_FALSE(started()); |
| EXPECT_EQ(kStateStringNotStarted, |
| controller()->GetBackendInitializationStateString()); |
| } |
| |
| // Test that sync doesn't when managed even if all other conditons are met. |
| TEST_F(StartupControllerTest, Managed) { |
| sync_prefs()->SetSyncSetupCompleted(); |
| sync_prefs()->SetManagedForTest(true); |
| signin()->set_account(kTestUser); |
| token_service()->IssueRefreshTokenForUser(kTestUser, kTestToken); |
| controller()->TryStart(); |
| EXPECT_FALSE(started()); |
| EXPECT_EQ(kStateStringNotStarted, |
| controller()->GetBackendInitializationStateString()); |
| } |
| |
| // Test that sync doesn't start until all conditions are met and a |
| // data type triggers sync startup. |
| TEST_F(StartupControllerTest, DataTypeTriggered) { |
| sync_prefs()->SetSyncSetupCompleted(); |
| signin()->set_account(kTestUser); |
| token_service()->IssueRefreshTokenForUser(kTestUser, kTestToken); |
| controller()->TryStart(); |
| EXPECT_FALSE(started()); |
| EXPECT_EQ(kStateStringDeferred, |
| controller()->GetBackendInitializationStateString()); |
| controller()->OnDataTypeRequestsSyncStartup(syncer::SESSIONS); |
| EXPECT_TRUE(started()); |
| EXPECT_EQ(kStateStringStarted, |
| controller()->GetBackendInitializationStateString()); |
| |
| // The fallback timer shouldn't result in another invocation of the closure |
| // we passed to the StartupController. |
| clear_started(); |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_FALSE(started()); |
| } |
| |
| // Test that the fallback timer starts sync in the event all |
| // conditions are met and no data type requests sync. |
| TEST_F(StartupControllerTest, FallbackTimer) { |
| sync_prefs()->SetSyncSetupCompleted(); |
| signin()->set_account(kTestUser); |
| token_service()->IssueRefreshTokenForUser(kTestUser, kTestToken); |
| controller()->TryStart(); |
| EXPECT_FALSE(started()); |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_TRUE(started()); |
| } |
| |
| // Test that we start immediately if sessions is disabled. |
| TEST_F(StartupControllerTest, NoDeferralWithoutSessionsSync) { |
| syncer::ModelTypeSet types(syncer::UserTypes()); |
| // Disabling sessions means disabling 4 types due to groupings. |
| types.Remove(syncer::SESSIONS); |
| types.Remove(syncer::PROXY_TABS); |
| types.Remove(syncer::TYPED_URLS); |
| types.Remove(syncer::SUPERVISED_USER_SETTINGS); |
| sync_prefs()->SetKeepEverythingSynced(false); |
| sync_prefs()->SetPreferredDataTypes(syncer::UserTypes(), types); |
| controller()->Reset(syncer::UserTypes()); |
| sync_prefs()->SetSyncSetupCompleted(); |
| signin()->set_account(kTestUser); |
| token_service()->IssueRefreshTokenForUser(kTestUser, kTestToken); |
| controller()->TryStart(); |
| EXPECT_TRUE(started()); |
| } |
| |
| // Sanity check that the fallback timer doesn't fire before startup |
| // conditions are met. |
| TEST_F(StartupControllerTest, FallbackTimerWaits) { |
| controller()->TryStart(); |
| EXPECT_FALSE(started()); |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_FALSE(started()); |
| } |
| |
| // Test that sync starts when the user first asks to setup sync (which |
| // may be implicit due to the platform). |
| TEST_F(StartupControllerTest, FirstSetup) { |
| signin()->set_account(kTestUser); |
| token_service()->IssueRefreshTokenForUser(kTestUser, kTestToken); |
| controller()->TryStart(); |
| |
| if (browser_defaults::kSyncAutoStarts) { |
| EXPECT_TRUE(started()); |
| } else { |
| controller()->set_setup_in_progress(true); |
| controller()->TryStart(); |
| EXPECT_TRUE(started()); |
| } |
| } |
| |
| // Test that the controller "forgets" that preconditions were met on reset. |
| TEST_F(StartupControllerTest, Reset) { |
| sync_prefs()->SetSyncSetupCompleted(); |
| signin()->set_account(kTestUser); |
| token_service()->IssueRefreshTokenForUser(kTestUser, kTestToken); |
| controller()->TryStart(); |
| controller()->OnDataTypeRequestsSyncStartup(syncer::SESSIONS); |
| EXPECT_TRUE(started()); |
| clear_started(); |
| controller()->Reset(syncer::UserTypes()); |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_FALSE(started()); |
| const bool deferred_start = !CommandLine::ForCurrentProcess()-> |
| HasSwitch(switches::kSyncDisableDeferredStartup); |
| controller()->TryStart(); |
| EXPECT_EQ(!deferred_start, started()); |
| controller()->OnDataTypeRequestsSyncStartup(syncer::SESSIONS); |
| EXPECT_TRUE(started()); |
| } |
| |
| // Test that setup-in-progress tracking is persistent across a Reset. |
| TEST_F(StartupControllerTest, ResetDuringSetup) { |
| signin()->set_account(kTestUser); |
| token_service()->IssueRefreshTokenForUser(kTestUser, kTestToken); |
| |
| // Simulate UI telling us setup is in progress. |
| controller()->set_setup_in_progress(true); |
| |
| // This could happen if the UI triggers a stop-syncing permanently call. |
| controller()->Reset(syncer::UserTypes()); |
| |
| // From the UI's point of view, setup is still in progress. |
| EXPECT_TRUE(controller()->setup_in_progress()); |
| } |
| |
| } // namespace browser_sync |