Home | History | Annotate | Download | only in sync 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "base/basictypes.h"
      6 #include "base/command_line.h"
      7 #include "base/compiler_specific.h"
      8 #include "base/memory/scoped_ptr.h"
      9 #include "base/run_loop.h"
     10 #include "base/strings/string_number_conversions.h"
     11 #include "base/strings/utf_string_conversions.h"
     12 #include "base/values.h"
     13 #include "chrome/browser/invalidation/fake_invalidation_service.h"
     14 #include "chrome/browser/invalidation/profile_invalidation_provider_factory.h"
     15 #include "chrome/browser/signin/fake_profile_oauth2_token_service.h"
     16 #include "chrome/browser/signin/fake_profile_oauth2_token_service_builder.h"
     17 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
     18 #include "chrome/browser/signin/signin_manager_factory.h"
     19 #include "chrome/browser/sync/glue/sync_backend_host_mock.h"
     20 #include "chrome/browser/sync/managed_user_signin_manager_wrapper.h"
     21 #include "chrome/browser/sync/profile_sync_components_factory_mock.h"
     22 #include "chrome/common/chrome_switches.h"
     23 #include "chrome/common/pref_names.h"
     24 #include "chrome/test/base/testing_browser_process.h"
     25 #include "chrome/test/base/testing_pref_service_syncable.h"
     26 #include "chrome/test/base/testing_profile.h"
     27 #include "chrome/test/base/testing_profile_manager.h"
     28 #include "components/invalidation/invalidation_service.h"
     29 #include "components/invalidation/profile_invalidation_provider.h"
     30 #include "components/signin/core/browser/signin_manager.h"
     31 #include "components/sync_driver/data_type_manager_impl.h"
     32 #include "components/sync_driver/pref_names.h"
     33 #include "components/sync_driver/sync_prefs.h"
     34 #include "content/public/test/test_browser_thread_bundle.h"
     35 #include "google_apis/gaia/gaia_constants.h"
     36 #include "testing/gmock/include/gmock/gmock.h"
     37 #include "testing/gtest/include/gtest/gtest.h"
     38 
     39 namespace content {
     40 class BrowserContext;
     41 }
     42 
     43 namespace browser_sync {
     44 
     45 namespace {
     46 
     47 ACTION(ReturnNewDataTypeManager) {
     48   return new browser_sync::DataTypeManagerImpl(base::Closure(),
     49                                                arg0,
     50                                                arg1,
     51                                                arg2,
     52                                                arg3,
     53                                                arg4,
     54                                                arg5);
     55 }
     56 
     57 using testing::Return;
     58 using testing::StrictMock;
     59 using testing::_;
     60 
     61 class TestProfileSyncServiceObserver : public ProfileSyncServiceObserver {
     62  public:
     63   explicit TestProfileSyncServiceObserver(ProfileSyncService* service)
     64       : service_(service), first_setup_in_progress_(false) {}
     65   virtual void OnStateChanged() OVERRIDE {
     66     first_setup_in_progress_ = service_->FirstSetupInProgress();
     67   }
     68   bool first_setup_in_progress() const { return first_setup_in_progress_; }
     69  private:
     70   ProfileSyncService* service_;
     71   bool first_setup_in_progress_;
     72 };
     73 
     74 // A variant of the SyncBackendHostMock that won't automatically
     75 // call back when asked to initialized.  Allows us to test things
     76 // that could happen while backend init is in progress.
     77 class SyncBackendHostNoReturn : public SyncBackendHostMock {
     78   virtual void Initialize(
     79       SyncFrontend* frontend,
     80       scoped_ptr<base::Thread> sync_thread,
     81       const syncer::WeakHandle<syncer::JsEventHandler>& event_handler,
     82       const GURL& service_url,
     83       const syncer::SyncCredentials& credentials,
     84       bool delete_sync_data_folder,
     85       scoped_ptr<syncer::SyncManagerFactory> sync_manager_factory,
     86       scoped_ptr<syncer::UnrecoverableErrorHandler> unrecoverable_error_handler,
     87       syncer::ReportUnrecoverableErrorFunction
     88           report_unrecoverable_error_function,
     89       syncer::NetworkResources* network_resources) OVERRIDE {}
     90 };
     91 
     92 class SyncBackendHostMockCollectDeleteDirParam : public SyncBackendHostMock {
     93  public:
     94   explicit SyncBackendHostMockCollectDeleteDirParam(
     95       std::vector<bool>* delete_dir_param)
     96      : delete_dir_param_(delete_dir_param) {}
     97 
     98   virtual void Initialize(
     99       SyncFrontend* frontend,
    100       scoped_ptr<base::Thread> sync_thread,
    101       const syncer::WeakHandle<syncer::JsEventHandler>& event_handler,
    102       const GURL& service_url,
    103       const syncer::SyncCredentials& credentials,
    104       bool delete_sync_data_folder,
    105       scoped_ptr<syncer::SyncManagerFactory> sync_manager_factory,
    106       scoped_ptr<syncer::UnrecoverableErrorHandler> unrecoverable_error_handler,
    107       syncer::ReportUnrecoverableErrorFunction
    108           report_unrecoverable_error_function,
    109       syncer::NetworkResources* network_resources) OVERRIDE {
    110     delete_dir_param_->push_back(delete_sync_data_folder);
    111     SyncBackendHostMock::Initialize(frontend, sync_thread.Pass(),
    112                                     event_handler, service_url, credentials,
    113                                     delete_sync_data_folder,
    114                                     sync_manager_factory.Pass(),
    115                                     unrecoverable_error_handler.Pass(),
    116                                     report_unrecoverable_error_function,
    117                                     network_resources);
    118   }
    119 
    120  private:
    121   std::vector<bool>* delete_dir_param_;
    122 };
    123 
    124 ACTION(ReturnNewSyncBackendHostMock) {
    125   return new browser_sync::SyncBackendHostMock();
    126 }
    127 
    128 ACTION(ReturnNewSyncBackendHostNoReturn) {
    129   return new browser_sync::SyncBackendHostNoReturn();
    130 }
    131 
    132 ACTION_P(ReturnNewMockHostCollectDeleteDirParam, delete_dir_param) {
    133   return new browser_sync::SyncBackendHostMockCollectDeleteDirParam(
    134       delete_dir_param);
    135 }
    136 
    137 KeyedService* BuildFakeProfileInvalidationProvider(
    138     content::BrowserContext* context) {
    139   return new invalidation::ProfileInvalidationProvider(
    140       scoped_ptr<invalidation::InvalidationService>(
    141           new invalidation::FakeInvalidationService));
    142 }
    143 
    144 // A test harness that uses a real ProfileSyncService and in most cases a
    145 // MockSyncBackendHost.
    146 //
    147 // This is useful if we want to test the ProfileSyncService and don't care about
    148 // testing the SyncBackendHost.
    149 class ProfileSyncServiceTest : public ::testing::Test {
    150  protected:
    151   ProfileSyncServiceTest()
    152       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
    153         profile_manager_(TestingBrowserProcess::GetGlobal()) {}
    154   virtual ~ProfileSyncServiceTest() {}
    155 
    156   virtual void SetUp() OVERRIDE {
    157     CommandLine::ForCurrentProcess()->AppendSwitchASCII(
    158         switches::kSyncDeferredStartupTimeoutSeconds, "0");
    159 
    160     CHECK(profile_manager_.SetUp());
    161 
    162     TestingProfile::TestingFactories testing_facotries;
    163     testing_facotries.push_back(
    164             std::make_pair(ProfileOAuth2TokenServiceFactory::GetInstance(),
    165                            BuildAutoIssuingFakeProfileOAuth2TokenService));
    166     testing_facotries.push_back(
    167             std::make_pair(
    168                 invalidation::ProfileInvalidationProviderFactory::GetInstance(),
    169                 BuildFakeProfileInvalidationProvider));
    170 
    171     profile_ = profile_manager_.CreateTestingProfile(
    172         "sync-service-test", scoped_ptr<PrefServiceSyncable>(),
    173         base::UTF8ToUTF16("sync-service-test"), 0, std::string(),
    174         testing_facotries);
    175   }
    176 
    177   virtual void TearDown() OVERRIDE {
    178     // Kill the service before the profile.
    179     if (service_)
    180       service_->Shutdown();
    181 
    182     service_.reset();
    183   }
    184 
    185   void IssueTestTokens() {
    186     ProfileOAuth2TokenServiceFactory::GetForProfile(profile_)
    187         ->UpdateCredentials("test", "oauth2_login_token");
    188   }
    189 
    190   void CreateService(ProfileSyncServiceStartBehavior behavior) {
    191     SigninManagerBase* signin =
    192         SigninManagerFactory::GetForProfile(profile_);
    193     signin->SetAuthenticatedUsername("test");
    194     ProfileOAuth2TokenService* oauth2_token_service =
    195         ProfileOAuth2TokenServiceFactory::GetForProfile(profile_);
    196     components_factory_ = new StrictMock<ProfileSyncComponentsFactoryMock>();
    197     service_.reset(new ProfileSyncService(
    198         components_factory_,
    199         profile_,
    200         make_scoped_ptr(new ManagedUserSigninManagerWrapper(profile_, signin)),
    201         oauth2_token_service,
    202         behavior));
    203     service_->SetClearingBrowseringDataForTesting(
    204         base::Bind(&ProfileSyncServiceTest::ClearBrowsingDataCallback,
    205                    base::Unretained(this)));
    206   }
    207 
    208 #if defined(OS_WIN) || defined(OS_MACOSX) || (defined(OS_LINUX) && !defined(OS_CHROMEOS))
    209   void CreateServiceWithoutSignIn() {
    210     CreateService(browser_sync::MANUAL_START);
    211     SigninManagerFactory::GetForProfile(profile())->SignOut(
    212         signin_metrics::SIGNOUT_TEST);
    213     service()->SetBackupStartDelayForTest(
    214         base::TimeDelta::FromMilliseconds(100));
    215   }
    216 #endif
    217 
    218   void ShutdownAndDeleteService() {
    219     if (service_)
    220       service_->Shutdown();
    221     service_.reset();
    222   }
    223 
    224   void Initialize() {
    225     service_->Initialize();
    226   }
    227 
    228   void ExpectDataTypeManagerCreation(int times) {
    229     EXPECT_CALL(*components_factory_, CreateDataTypeManager(_, _, _, _, _, _))
    230         .Times(times)
    231         .WillRepeatedly(ReturnNewDataTypeManager());
    232   }
    233 
    234   void ExpectSyncBackendHostCreation(int times) {
    235     EXPECT_CALL(*components_factory_, CreateSyncBackendHost(_, _, _, _, _))
    236         .Times(times)
    237         .WillRepeatedly(ReturnNewSyncBackendHostMock());
    238   }
    239 
    240   void ExpectSyncBackendHostCreationCollectDeleteDir(
    241       int times, std::vector<bool> *delete_dir_param) {
    242     EXPECT_CALL(*components_factory_, CreateSyncBackendHost(_, _, _, _, _))
    243         .Times(times)
    244         .WillRepeatedly(ReturnNewMockHostCollectDeleteDirParam(
    245             delete_dir_param));
    246   }
    247 
    248   void PrepareDelayedInitSyncBackendHost() {
    249     EXPECT_CALL(*components_factory_, CreateSyncBackendHost(_, _, _, _, _)).
    250         WillOnce(ReturnNewSyncBackendHostNoReturn());
    251   }
    252 
    253   TestingProfile* profile() {
    254     return profile_;
    255   }
    256 
    257   ProfileSyncService* service() {
    258     return service_.get();
    259   }
    260 
    261   ProfileSyncComponentsFactoryMock* components_factory() {
    262     return components_factory_;
    263   }
    264 
    265   void ClearBrowsingDataCallback(Profile* profile, base::Time start,
    266                                  base::Time end) {
    267     EXPECT_EQ(profile_, profile);
    268     clear_browsing_data_start_ = start;
    269   }
    270 
    271  protected:
    272   // The requested start time when ClearBrowsingDataCallback is called.
    273   base::Time clear_browsing_data_start_;
    274 
    275  private:
    276   content::TestBrowserThreadBundle thread_bundle_;
    277   TestingProfileManager profile_manager_;
    278   TestingProfile* profile_;
    279   scoped_ptr<ProfileSyncService> service_;
    280 
    281   // Pointer to the components factory.  Not owned.  May be null.
    282   ProfileSyncComponentsFactoryMock* components_factory_;
    283 };
    284 
    285 // Verify that the server URLs are sane.
    286 TEST_F(ProfileSyncServiceTest, InitialState) {
    287   CreateService(browser_sync::AUTO_START);
    288   Initialize();
    289   const std::string& url = service()->sync_service_url().spec();
    290   EXPECT_TRUE(url == ProfileSyncService::kSyncServerUrl ||
    291               url == ProfileSyncService::kDevServerUrl);
    292 }
    293 
    294 // Verify a successful initialization.
    295 TEST_F(ProfileSyncServiceTest, SuccessfulInitialization) {
    296   profile()->GetTestingPrefService()->SetManagedPref(
    297       sync_driver::prefs::kSyncManaged, base::Value::CreateBooleanValue(false));
    298   IssueTestTokens();
    299   CreateService(browser_sync::AUTO_START);
    300   ExpectDataTypeManagerCreation(1);
    301   ExpectSyncBackendHostCreation(1);
    302   Initialize();
    303   EXPECT_FALSE(service()->IsManaged());
    304   EXPECT_TRUE(service()->sync_initialized());
    305   EXPECT_EQ(ProfileSyncService::SYNC, service()->backend_mode());
    306 }
    307 
    308 
    309 // Verify that the SetSetupInProgress function call updates state
    310 // and notifies observers.
    311 TEST_F(ProfileSyncServiceTest, SetupInProgress) {
    312   CreateService(browser_sync::AUTO_START);
    313   Initialize();
    314 
    315   TestProfileSyncServiceObserver observer(service());
    316   service()->AddObserver(&observer);
    317 
    318   service()->SetSetupInProgress(true);
    319   EXPECT_TRUE(observer.first_setup_in_progress());
    320   service()->SetSetupInProgress(false);
    321   EXPECT_FALSE(observer.first_setup_in_progress());
    322 
    323   service()->RemoveObserver(&observer);
    324 }
    325 
    326 // Verify that disable by enterprise policy works.
    327 TEST_F(ProfileSyncServiceTest, DisabledByPolicyBeforeInit) {
    328   profile()->GetTestingPrefService()->SetManagedPref(
    329       sync_driver::prefs::kSyncManaged, base::Value::CreateBooleanValue(true));
    330   IssueTestTokens();
    331   CreateService(browser_sync::AUTO_START);
    332   Initialize();
    333   EXPECT_TRUE(service()->IsManaged());
    334   EXPECT_FALSE(service()->sync_initialized());
    335 }
    336 
    337 // Verify that disable by enterprise policy works even after the backend has
    338 // been initialized.
    339 TEST_F(ProfileSyncServiceTest, DisabledByPolicyAfterInit) {
    340   IssueTestTokens();
    341   CreateService(browser_sync::AUTO_START);
    342   ExpectDataTypeManagerCreation(1);
    343   ExpectSyncBackendHostCreation(1);
    344   Initialize();
    345 
    346   EXPECT_FALSE(service()->IsManaged());
    347   EXPECT_TRUE(service()->sync_initialized());
    348 
    349   profile()->GetTestingPrefService()->SetManagedPref(
    350       sync_driver::prefs::kSyncManaged, base::Value::CreateBooleanValue(true));
    351 
    352   EXPECT_TRUE(service()->IsManaged());
    353   EXPECT_FALSE(service()->sync_initialized());
    354 }
    355 
    356 // Exercies the ProfileSyncService's code paths related to getting shut down
    357 // before the backend initialize call returns.
    358 TEST_F(ProfileSyncServiceTest, AbortedByShutdown) {
    359   CreateService(browser_sync::AUTO_START);
    360   PrepareDelayedInitSyncBackendHost();
    361 
    362   IssueTestTokens();
    363   Initialize();
    364   EXPECT_FALSE(service()->sync_initialized());
    365 
    366   ShutdownAndDeleteService();
    367 }
    368 
    369 // Test StopAndSuppress() before we've initialized the backend.
    370 TEST_F(ProfileSyncServiceTest, EarlyStopAndSuppress) {
    371   CreateService(browser_sync::AUTO_START);
    372   IssueTestTokens();
    373 
    374   service()->StopAndSuppress();
    375   EXPECT_TRUE(profile()->GetPrefs()->GetBoolean(
    376       sync_driver::prefs::kSyncSuppressStart));
    377 
    378   // Because of supression, this should fail.
    379   Initialize();
    380   EXPECT_FALSE(service()->sync_initialized());
    381 
    382   // Remove suppression.  This should be enough to allow init to happen.
    383   ExpectDataTypeManagerCreation(1);
    384   ExpectSyncBackendHostCreation(1);
    385   service()->UnsuppressAndStart();
    386   EXPECT_TRUE(service()->sync_initialized());
    387   EXPECT_FALSE(profile()->GetPrefs()->GetBoolean(
    388       sync_driver::prefs::kSyncSuppressStart));
    389 }
    390 
    391 // Test StopAndSuppress() after we've initialized the backend.
    392 TEST_F(ProfileSyncServiceTest, DisableAndEnableSyncTemporarily) {
    393   CreateService(browser_sync::AUTO_START);
    394   IssueTestTokens();
    395   ExpectDataTypeManagerCreation(1);
    396   ExpectSyncBackendHostCreation(1);
    397   Initialize();
    398 
    399   EXPECT_TRUE(service()->sync_initialized());
    400   EXPECT_FALSE(profile()->GetPrefs()->GetBoolean(
    401       sync_driver::prefs::kSyncSuppressStart));
    402 
    403   testing::Mock::VerifyAndClearExpectations(components_factory());
    404 
    405   service()->StopAndSuppress();
    406   EXPECT_FALSE(service()->sync_initialized());
    407   EXPECT_TRUE(profile()->GetPrefs()->GetBoolean(
    408       sync_driver::prefs::kSyncSuppressStart));
    409 
    410   ExpectDataTypeManagerCreation(1);
    411   ExpectSyncBackendHostCreation(1);
    412 
    413   service()->UnsuppressAndStart();
    414   EXPECT_TRUE(service()->sync_initialized());
    415   EXPECT_FALSE(profile()->GetPrefs()->GetBoolean(
    416       sync_driver::prefs::kSyncSuppressStart));
    417 }
    418 
    419 // Certain ProfileSyncService tests don't apply to Chrome OS, for example
    420 // things that deal with concepts like "signing out" and policy.
    421 #if defined(OS_WIN) || defined(OS_MACOSX) || (defined(OS_LINUX) && !defined(OS_CHROMEOS))
    422 TEST_F(ProfileSyncServiceTest, EnableSyncAndSignOutDesktop) {
    423   CreateService(browser_sync::AUTO_START);
    424   ExpectDataTypeManagerCreation(2);
    425   ExpectSyncBackendHostCreation(2);
    426   IssueTestTokens();
    427   Initialize();
    428 
    429   EXPECT_TRUE(service()->sync_initialized());
    430   EXPECT_FALSE(profile()->GetPrefs()->GetBoolean(
    431       sync_driver::prefs::kSyncSuppressStart));
    432   EXPECT_EQ(ProfileSyncService::SYNC, service()->backend_mode());
    433 
    434   SigninManagerFactory::GetForProfile(profile())->SignOut(
    435       signin_metrics::SIGNOUT_TEST);
    436   EXPECT_TRUE(service()->sync_initialized());
    437   EXPECT_EQ(ProfileSyncService::BACKUP, service()->backend_mode());
    438 }
    439 #elif !defined (OS_CHROMEOS)
    440 TEST_F(ProfileSyncServiceTest, EnableSyncAndSignOut) {
    441   CreateService(browser_sync::AUTO_START);
    442   ExpectDataTypeManagerCreation(1);
    443   ExpectSyncBackendHostCreation(1);
    444   IssueTestTokens();
    445   Initialize();
    446 
    447   EXPECT_TRUE(service()->sync_initialized());
    448   EXPECT_FALSE(profile()->GetPrefs()->GetBoolean(
    449       sync_driver::prefs::kSyncSuppressStart));
    450 
    451   SigninManagerFactory::GetForProfile(profile())->SignOut(
    452       signin_metrics::SIGNOUT_TEST);
    453   EXPECT_FALSE(service()->sync_initialized());
    454 }
    455 #endif  // !defined(OS_CHROMEOS)
    456 
    457 TEST_F(ProfileSyncServiceTest, GetSyncTokenStatus) {
    458   CreateService(browser_sync::AUTO_START);
    459   IssueTestTokens();
    460   ExpectDataTypeManagerCreation(1);
    461   ExpectSyncBackendHostCreation(1);
    462   Initialize();
    463 
    464   // Initial status.
    465   ProfileSyncService::SyncTokenStatus token_status =
    466       service()->GetSyncTokenStatus();
    467   EXPECT_EQ(syncer::CONNECTION_NOT_ATTEMPTED, token_status.connection_status);
    468   EXPECT_TRUE(token_status.connection_status_update_time.is_null());
    469   EXPECT_TRUE(token_status.token_request_time.is_null());
    470   EXPECT_TRUE(token_status.token_receive_time.is_null());
    471 
    472   // Simulate an auth error.
    473   service()->OnConnectionStatusChange(syncer::CONNECTION_AUTH_ERROR);
    474 
    475   // The token request will take the form of a posted task.  Run it.
    476   base::RunLoop loop;
    477   loop.RunUntilIdle();
    478 
    479   token_status = service()->GetSyncTokenStatus();
    480   EXPECT_EQ(syncer::CONNECTION_AUTH_ERROR, token_status.connection_status);
    481   EXPECT_FALSE(token_status.connection_status_update_time.is_null());
    482   EXPECT_FALSE(token_status.token_request_time.is_null());
    483   EXPECT_FALSE(token_status.token_receive_time.is_null());
    484   EXPECT_EQ(GoogleServiceAuthError::AuthErrorNone(),
    485             token_status.last_get_token_error);
    486   EXPECT_TRUE(token_status.next_token_request_time.is_null());
    487 
    488   // Simulate successful connection.
    489   service()->OnConnectionStatusChange(syncer::CONNECTION_OK);
    490   token_status = service()->GetSyncTokenStatus();
    491   EXPECT_EQ(syncer::CONNECTION_OK, token_status.connection_status);
    492 }
    493 
    494 #if defined(ENABLE_PRE_SYNC_BACKUP)
    495 TEST_F(ProfileSyncServiceTest, StartBackup) {
    496   CreateServiceWithoutSignIn();
    497   ExpectDataTypeManagerCreation(1);
    498   std::vector<bool> delete_dir_param;
    499   ExpectSyncBackendHostCreationCollectDeleteDir(1, &delete_dir_param);
    500   Initialize();
    501   EXPECT_EQ(ProfileSyncService::IDLE, service()->backend_mode());
    502   base::RunLoop run_loop;
    503   base::MessageLoop::current()->PostDelayedTask(
    504       FROM_HERE, run_loop.QuitClosure(),
    505       base::TimeDelta::FromMilliseconds(100));
    506   run_loop.Run();
    507   EXPECT_EQ(ProfileSyncService::BACKUP, service()->backend_mode());
    508 
    509   EXPECT_EQ(1u, delete_dir_param.size());
    510   EXPECT_FALSE(delete_dir_param[0]);
    511 }
    512 
    513 TEST_F(ProfileSyncServiceTest, BackupAfterSyncDisabled) {
    514   CreateService(browser_sync::MANUAL_START);
    515   service()->SetSyncSetupCompleted();
    516   ExpectDataTypeManagerCreation(2);
    517   std::vector<bool> delete_dir_param;
    518   ExpectSyncBackendHostCreationCollectDeleteDir(2, &delete_dir_param);
    519   IssueTestTokens();
    520   Initialize();
    521   EXPECT_TRUE(service()->sync_initialized());
    522   EXPECT_EQ(ProfileSyncService::SYNC, service()->backend_mode());
    523 
    524   // First sync time should be recorded.
    525   sync_driver::SyncPrefs sync_prefs(service()->profile()->GetPrefs());
    526   EXPECT_FALSE(sync_prefs.GetFirstSyncTime().is_null());
    527 
    528   syncer::SyncProtocolError client_cmd;
    529   client_cmd.action = syncer::DISABLE_SYNC_ON_CLIENT;
    530   service()->OnActionableError(client_cmd);
    531   EXPECT_EQ(ProfileSyncService::BACKUP, service()->backend_mode());
    532 
    533   // Browsing data is not cleared because rollback is skipped.
    534   EXPECT_TRUE(clear_browsing_data_start_.is_null());
    535 
    536   // First sync time is erased once backup starts.
    537   EXPECT_TRUE(sync_prefs.GetFirstSyncTime().is_null());
    538 
    539   EXPECT_EQ(2u, delete_dir_param.size());
    540   EXPECT_FALSE(delete_dir_param[0]);
    541   EXPECT_TRUE(delete_dir_param[1]);
    542 }
    543 
    544 TEST_F(ProfileSyncServiceTest, RollbackThenBackup) {
    545   CommandLine::ForCurrentProcess()->AppendSwitch(
    546       switches::kSyncEnableRollback);
    547 
    548   CreateService(browser_sync::MANUAL_START);
    549   service()->SetSyncSetupCompleted();
    550   ExpectDataTypeManagerCreation(3);
    551   std::vector<bool> delete_dir_param;
    552   ExpectSyncBackendHostCreationCollectDeleteDir(3, &delete_dir_param);
    553   IssueTestTokens();
    554   Initialize();
    555   EXPECT_TRUE(service()->sync_initialized());
    556   EXPECT_EQ(ProfileSyncService::SYNC, service()->backend_mode());
    557 
    558   // First sync time should be recorded.
    559   sync_driver::SyncPrefs sync_prefs(service()->profile()->GetPrefs());
    560   base::Time first_sync_time = sync_prefs.GetFirstSyncTime();
    561   EXPECT_FALSE(first_sync_time.is_null());
    562 
    563   syncer::SyncProtocolError client_cmd;
    564   client_cmd.action = syncer::DISABLE_SYNC_AND_ROLLBACK;
    565   service()->OnActionableError(client_cmd);
    566   EXPECT_TRUE(service()->sync_initialized());
    567   EXPECT_EQ(ProfileSyncService::ROLLBACK, service()->backend_mode());
    568 
    569   // Browser data should be cleared during rollback.
    570   EXPECT_EQ(first_sync_time, clear_browsing_data_start_);
    571 
    572   client_cmd.action = syncer::ROLLBACK_DONE;
    573   service()->OnActionableError(client_cmd);
    574   EXPECT_TRUE(service()->sync_initialized());
    575   EXPECT_EQ(ProfileSyncService::BACKUP, service()->backend_mode());
    576 
    577   // First sync time is erased once backup starts.
    578   EXPECT_TRUE(sync_prefs.GetFirstSyncTime().is_null());
    579 
    580   EXPECT_EQ(3u, delete_dir_param.size());
    581   EXPECT_FALSE(delete_dir_param[0]);
    582   EXPECT_FALSE(delete_dir_param[1]);
    583   EXPECT_TRUE(delete_dir_param[2]);
    584 }
    585 
    586 TEST_F(ProfileSyncServiceTest, StartNewBackupDbOnSettingsReset) {
    587   CreateServiceWithoutSignIn();
    588   ExpectDataTypeManagerCreation(1);
    589   std::vector<bool> delete_dir_param;
    590   ExpectSyncBackendHostCreationCollectDeleteDir(1, &delete_dir_param);
    591   Initialize();
    592   EXPECT_EQ(ProfileSyncService::IDLE, service()->backend_mode());
    593 
    594   // Set reset time to pretend settings reset happened.
    595   profile()->GetPrefs()->SetString(
    596       prefs::kPreferenceResetTime,
    597       base::Int64ToString(base::Time::Now().ToInternalValue()));
    598 
    599   base::RunLoop run_loop;
    600   base::MessageLoop::current()->PostDelayedTask(
    601       FROM_HERE, run_loop.QuitClosure(),
    602       base::TimeDelta::FromMilliseconds(100));
    603   run_loop.Run();
    604 
    605   EXPECT_EQ(ProfileSyncService::BACKUP, service()->backend_mode());
    606 
    607   EXPECT_EQ(1u, delete_dir_param.size());
    608   EXPECT_TRUE(delete_dir_param[0]);
    609 }
    610 
    611 #endif
    612 
    613 TEST_F(ProfileSyncServiceTest, GetSyncServiceURL) {
    614   // See that we can override the URL with a flag.
    615   CommandLine command_line(
    616       base::FilePath(base::FilePath(FILE_PATH_LITERAL("chrome.exe"))));
    617   command_line.AppendSwitchASCII(switches::kSyncServiceURL, "https://foo/bar");
    618   EXPECT_EQ("https://foo/bar",
    619             ProfileSyncService::GetSyncServiceURL(command_line).spec());
    620 }
    621 
    622 }  // namespace
    623 }  // namespace browser_sync
    624