[Sync] Merge //components/browser_sync into one directory.

components/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 <memory>
 #include <utility>
 
 #include "base/files/file_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
-#include "components/browser_sync/browser/profile_sync_service.h"
-#include "components/browser_sync/browser/profile_sync_test_util.h"
+#include "components/browser_sync/profile_sync_service.h"
+#include "components/browser_sync/profile_sync_test_util.h"
 #include "components/prefs/pref_service.h"
 #include "components/signin/core/browser/account_tracker_service.h"
 #include "components/signin/core/browser/fake_profile_oauth2_token_service.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/signin/core/common/signin_pref_names.h"
 #include "components/sync/driver/data_type_manager.h"
 #include "components/sync/driver/data_type_manager_mock.h"
 #include "components/sync/driver/fake_data_type_controller.h"
 #include "components/sync/driver/glue/sync_backend_host_mock.h"
@@ skipping 55 matching lines @@
   ProfileSyncServiceStartupTest() {
     profile_sync_service_bundle_.auth_service()
         ->set_auto_post_fetch_response_on_message_loop(true);
   }
 
   ~ProfileSyncServiceStartupTest() override {
     sync_service_->RemoveObserver(&observer_);
     sync_service_->Shutdown();
   }
 
-  void CreateSyncService(
-      ProfileSyncService::StartBehavior start_behavior) {
+  void CreateSyncService(ProfileSyncService::StartBehavior start_behavior) {
     component_factory_ = profile_sync_service_bundle_.component_factory();
     browser_sync::ProfileSyncServiceBundle::SyncClientBuilder builder(
         &profile_sync_service_bundle_);
     ProfileSyncService::InitParams init_params =
         profile_sync_service_bundle_.CreateBasicInitParams(start_behavior,
                                                            builder.Build());
 
     sync_service_.reset(new ProfileSyncService(std::move(init_params)));
     sync_service_->RegisterDataTypeController(
         base::MakeUnique<sync_driver::FakeDataTypeController>(
             syncer::BOOKMARKS));
     sync_service_->AddObserver(&observer_);
   }
 
   void IssueTestTokens(const std::string& account_id) {
     profile_sync_service_bundle_.auth_service()->UpdateCredentials(
         account_id, "oauth2_login_token");
   }
 
   void SetError(DataTypeManager::ConfigureResult* result) {
     sync_driver::DataTypeStatusTable::TypeErrorMap errors;
     errors[syncer::BOOKMARKS] =
-        syncer::SyncError(FROM_HERE,
-                          syncer::SyncError::UNRECOVERABLE_ERROR,
-                          "Error",
-                          syncer::BOOKMARKS);
+        syncer::SyncError(FROM_HERE, syncer::SyncError::UNRECOVERABLE_ERROR,
+                          "Error", syncer::BOOKMARKS);
     result->data_type_status_table.UpdateFailedDataTypes(errors);
   }
 
  protected:
   std::string SimulateTestUserSignin(ProfileSyncService* sync_service) {
     std::string account_id =
         profile_sync_service_bundle_.account_tracker()->SeedAccountInfo(kGaiaId,
                                                                         kEmail);
     pref_service()->SetString(prefs::kGoogleServicesAccountId, account_id);
 #if !defined(OS_CHROMEOS)
@@ skipping 60 matching lines @@
 
   // Preferences should be back to defaults.
   EXPECT_EQ(0,
             pref_service()->GetInt64(sync_driver::prefs::kSyncLastSyncedTime));
   EXPECT_FALSE(
       pref_service()->GetBoolean(sync_driver::prefs::kSyncFirstSetupComplete));
   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, state())
+      .WillOnce(Return(DataTypeManager::CONFIGURED))
+      .WillOnce(Return(DataTypeManager::CONFIGURED));
   EXPECT_CALL(*data_type_manager, Stop()).Times(1);
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
 
   auto sync_blocker = sync_service_->GetSetupInProgressHandle();
 
   // Simulate successful signin as test_user.
   std::string account_id = SimulateTestUserSignin(sync_service_.get());
   // Create some tokens in the token service.
   IssueTestTokens(account_id);
 
@@ skipping 51 matching lines @@
   DataTypeManagerMock* data_type_manager = SetUpDataTypeManager();
   EXPECT_CALL(*data_type_manager, Configure(_, _)).Times(0);
 
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
   sync_service_->Initialize();
   EXPECT_FALSE(sync_service_->IsSyncActive());
   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, state())
+      .WillRepeatedly(Return(DataTypeManager::CONFIGURED));
   EXPECT_CALL(*data_type_manager, Stop()).Times(1);
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
   auto sync_blocker = sync_service_->GetSetupInProgressHandle();
 
   // Simulate successful signin.
   SimulateTestUserSignin(sync_service_.get());
 
   sync_blocker.reset();
 
   // Verify we successfully finish startup and configuration.
@@ skipping 14 matching lines @@
 
   // Sync should not start because there are still no tokens.
   EXPECT_FALSE(sync_service_->IsSyncActive());
 }
 
 TEST_F(ProfileSyncServiceStartupCrosTest, StartFirstTime) {
   SetUpSyncBackendHost();
   DataTypeManagerMock* data_type_manager = SetUpDataTypeManager();
   pref_service()->ClearPref(sync_driver::prefs::kSyncFirstSetupComplete);
   EXPECT_CALL(*data_type_manager, Configure(_, _));
-  EXPECT_CALL(*data_type_manager, state()).
-      WillRepeatedly(Return(DataTypeManager::CONFIGURED));
+  EXPECT_CALL(*data_type_manager, state())
+      .WillRepeatedly(Return(DataTypeManager::CONFIGURED));
   EXPECT_CALL(*data_type_manager, Stop());
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
 
   IssueTestTokens(
       profile_sync_service_bundle_.account_tracker()->PickAccountIdForAccount(
           "12345", kEmail));
   sync_service_->Initialize();
   EXPECT_TRUE(sync_service_->IsSyncActive());
 }
 
 TEST_F(ProfileSyncServiceStartupTest, StartNormal) {
   // Pre load the tokens
   CreateSyncService(ProfileSyncService::MANUAL_START);
   std::string account_id = SimulateTestUserSignin(sync_service_.get());
   sync_service_->SetFirstSetupComplete();
   SetUpSyncBackendHost();
   DataTypeManagerMock* data_type_manager = SetUpDataTypeManager();
   EXPECT_CALL(*data_type_manager, Configure(_, _));
-  EXPECT_CALL(*data_type_manager, state()).
-      WillRepeatedly(Return(DataTypeManager::CONFIGURED));
+  EXPECT_CALL(*data_type_manager, state())
+      .WillRepeatedly(Return(DataTypeManager::CONFIGURED));
   EXPECT_CALL(*data_type_manager, Stop()).Times(1);
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
 
   IssueTestTokens(account_id);
 
   sync_service_->Initialize();
 }
 
 // Test that we can recover from a case where a bug in the code resulted in
 // OnUserChoseDatatypes not being properly called and datatype preferences
 // therefore being left unset.
 TEST_F(ProfileSyncServiceStartupTest, StartRecoverDatatypePrefs) {
   // Clear the datatype preference fields (simulating bug 154940).
   pref_service()->ClearPref(sync_driver::prefs::kSyncKeepEverythingSynced);
   syncer::ModelTypeSet user_types = syncer::UserTypes();
-  for (syncer::ModelTypeSet::Iterator iter = user_types.First();
-       iter.Good(); iter.Inc()) {
+  for (syncer::ModelTypeSet::Iterator iter = user_types.First(); iter.Good();
+       iter.Inc()) {
     pref_service()->ClearPref(
         sync_driver::SyncPrefs::GetPrefNameForDataType(iter.Get()));
   }
 
   // Pre load the tokens
   CreateSyncService(ProfileSyncService::MANUAL_START);
   std::string account_id = SimulateTestUserSignin(sync_service_.get());
   sync_service_->SetFirstSetupComplete();
   SetUpSyncBackendHost();
   DataTypeManagerMock* data_type_manager = SetUpDataTypeManager();
   EXPECT_CALL(*data_type_manager, Configure(_, _));
-  EXPECT_CALL(*data_type_manager, state()).
-      WillRepeatedly(Return(DataTypeManager::CONFIGURED));
+  EXPECT_CALL(*data_type_manager, state())
+      .WillRepeatedly(Return(DataTypeManager::CONFIGURED));
   EXPECT_CALL(*data_type_manager, Stop()).Times(1);
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
 
   IssueTestTokens(account_id);
   sync_service_->Initialize();
 
   EXPECT_TRUE(pref_service()->GetBoolean(
       sync_driver::prefs::kSyncKeepEverythingSynced));
 }
 
 // Verify that the recovery of datatype preferences doesn't overwrite a valid
 // case where only bookmarks are enabled.
 TEST_F(ProfileSyncServiceStartupTest, StartDontRecoverDatatypePrefs) {
   // Explicitly set Keep Everything Synced to false and have only bookmarks
   // enabled.
   pref_service()->SetBoolean(sync_driver::prefs::kSyncKeepEverythingSynced,
                              false);
 
   // Pre load the tokens
   CreateSyncService(ProfileSyncService::MANUAL_START);
   std::string account_id = SimulateTestUserSignin(sync_service_.get());
   sync_service_->SetFirstSetupComplete();
   SetUpSyncBackendHost();
   DataTypeManagerMock* data_type_manager = SetUpDataTypeManager();
   EXPECT_CALL(*data_type_manager, Configure(_, _));
-  EXPECT_CALL(*data_type_manager, state()).
-      WillRepeatedly(Return(DataTypeManager::CONFIGURED));
+  EXPECT_CALL(*data_type_manager, state())
+      .WillRepeatedly(Return(DataTypeManager::CONFIGURED));
   EXPECT_CALL(*data_type_manager, Stop()).Times(1);
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
   IssueTestTokens(account_id);
   sync_service_->Initialize();
 
   EXPECT_FALSE(pref_service()->GetBoolean(
       sync_driver::prefs::kSyncKeepEverythingSynced));
 }
 
 TEST_F(ProfileSyncServiceStartupTest, ManagedStartup) {
@@ skipping 20 matching lines @@
   EXPECT_CALL(*data_type_manager, state())
       .WillRepeatedly(Return(DataTypeManager::CONFIGURED));
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
   IssueTestTokens(account_id);
   sync_service_->Initialize();
   EXPECT_TRUE(sync_service_->IsBackendInitialized());
   EXPECT_TRUE(sync_service_->IsSyncActive());
 
   // The service should stop when switching to managed mode.
   Mock::VerifyAndClearExpectations(data_type_manager);
-  EXPECT_CALL(*data_type_manager, state()).
-      WillOnce(Return(DataTypeManager::CONFIGURED));
+  EXPECT_CALL(*data_type_manager, state())
+      .WillOnce(Return(DataTypeManager::CONFIGURED));
   EXPECT_CALL(*data_type_manager, Stop()).Times(1);
   pref_service()->SetBoolean(sync_driver::prefs::kSyncManaged, true);
   EXPECT_FALSE(sync_service_->IsBackendInitialized());
   // Note that PSS no longer references |data_type_manager| after stopping.
 
   // When switching back to unmanaged, the state should change but sync should
   // not start automatically because IsFirstSetupComplete() will be false.
   // A new DataTypeManager should not be created.
   Mock::VerifyAndClearExpectations(data_type_manager);
   EXPECT_CALL(*component_factory_, CreateDataTypeManager(_, _, _, _, _))
       .Times(0);
   pref_service()->ClearPref(sync_driver::prefs::kSyncManaged);
   EXPECT_FALSE(sync_service_->IsBackendInitialized());
   EXPECT_FALSE(sync_service_->IsSyncActive());
 }
 
 TEST_F(ProfileSyncServiceStartupTest, StartFailure) {
   CreateSyncService(ProfileSyncService::MANUAL_START);
   std::string account_id = SimulateTestUserSignin(sync_service_.get());
   sync_service_->SetFirstSetupComplete();
   SetUpSyncBackendHost();
   DataTypeManagerMock* data_type_manager = SetUpDataTypeManager();
   DataTypeManager::ConfigureStatus status = DataTypeManager::ABORTED;
-  DataTypeManager::ConfigureResult result(
-      status,
-      syncer::ModelTypeSet());
+  DataTypeManager::ConfigureResult result(status, syncer::ModelTypeSet());
   EXPECT_CALL(*data_type_manager, Configure(_, _))
       .WillRepeatedly(
           DoAll(InvokeOnConfigureStart(sync_service_.get()),
                 InvokeOnConfigureDone(
                     sync_service_.get(),
                     base::Bind(&ProfileSyncServiceStartupTest::SetError,
                                base::Unretained(this)),
                     result)));
-  EXPECT_CALL(*data_type_manager, state()).
-      WillOnce(Return(DataTypeManager::STOPPED));
+  EXPECT_CALL(*data_type_manager, state())
+      .WillOnce(Return(DataTypeManager::STOPPED));
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
   IssueTestTokens(account_id);
   sync_service_->Initialize();
   EXPECT_TRUE(sync_service_->HasUnrecoverableError());
 }
 
 TEST_F(ProfileSyncServiceStartupTest, StartDownloadFailed) {
   // Pre load the tokens
   CreateSyncService(ProfileSyncService::MANUAL_START);
   std::string account_id = SimulateTestUserSignin(sync_service_.get());
   SyncBackendHostMock* mock_sbh = SetUpSyncBackendHost();
   mock_sbh->set_fail_initial_download(true);
 
   pref_service()->ClearPref(sync_driver::prefs::kSyncFirstSetupComplete);
 
   EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber());
   sync_service_->Initialize();
 
   auto sync_blocker = sync_service_->GetSetupInProgressHandle();
   IssueTestTokens(account_id);
   sync_blocker.reset();
   EXPECT_FALSE(sync_service_->IsSyncActive());
 }