[Sync] Move //components/sync to the syncer namespace, take 2.

components/browser_sync/profile_sync_service_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 "components/browser_sync/profile_sync_service.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 29 matching lines @@
 #include "components/sync/driver/sync_service_observer.h"
 #include "components/sync/driver/sync_util.h"
 #include "components/syncable_prefs/testing_pref_service_syncable.h"
 #include "components/version_info/version_info.h"
 #include "components/version_info/version_info_values.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 
+using syncer::SyncBackendHostMock;
 using testing::Return;
 
 namespace browser_sync {
 
 namespace {
 
 const char kGaiaId[] = "12345";
 const char kEmail[] = "test_user@gmail.com";
 
-class FakeDataTypeManager : public sync_driver::DataTypeManager {
+class FakeDataTypeManager : public syncer::DataTypeManager {
  public:
   typedef base::Callback<void(syncer::ConfigureReason)> ConfigureCalled;
 
   explicit FakeDataTypeManager(const ConfigureCalled& configure_called)
       : configure_called_(configure_called) {}
 
   ~FakeDataTypeManager() override{};
 
   void Configure(syncer::ModelTypeSet desired_types,
                  syncer::ConfigureReason reason) override {
     DCHECK(!configure_called_.is_null());
     configure_called_.Run(reason);
   }
 
   void ReenableType(syncer::ModelType type) override {}
   void ResetDataTypeErrors() override {}
   void PurgeForMigration(syncer::ModelTypeSet undesired_types,
                          syncer::ConfigureReason reason) override {}
   void Stop() override{};
-  State state() const override {
-    return sync_driver::DataTypeManager::CONFIGURED;
-  };
+  State state() const override { return syncer::DataTypeManager::CONFIGURED; };
 
  private:
   ConfigureCalled configure_called_;
 };
 
 ACTION_P(ReturnNewDataTypeManager, configure_called) {
   return new FakeDataTypeManager(configure_called);
 }
 
 using testing::Return;
 using testing::StrictMock;
 using testing::_;
 
-class TestSyncServiceObserver : public sync_driver::SyncServiceObserver {
+class TestSyncServiceObserver : public syncer::SyncServiceObserver {
  public:
   explicit TestSyncServiceObserver(ProfileSyncService* service)
       : service_(service), setup_in_progress_(false) {}
   void OnStateChanged() override {
     setup_in_progress_ = service_->IsSetupInProgress();
   }
   bool setup_in_progress() const { return setup_in_progress_; }
 
  private:
   ProfileSyncService* service_;
   bool setup_in_progress_;
 };
 
 // A variant of the SyncBackendHostMock that won't automatically
 // call back when asked to initialized.  Allows us to test things
 // that could happen while backend init is in progress.
 class SyncBackendHostNoReturn : public SyncBackendHostMock {
   void Initialize(
-      sync_driver::SyncFrontend* frontend,
+      syncer::SyncFrontend* frontend,
       std::unique_ptr<base::Thread> sync_thread,
       const scoped_refptr<base::SingleThreadTaskRunner>& db_thread,
       const scoped_refptr<base::SingleThreadTaskRunner>& file_thread,
       const syncer::WeakHandle<syncer::JsEventHandler>& event_handler,
       const GURL& service_url,
       const std::string& sync_user_agent,
       const syncer::SyncCredentials& credentials,
       bool delete_sync_data_folder,
       std::unique_ptr<syncer::SyncManagerFactory> sync_manager_factory,
       const syncer::WeakHandle<syncer::UnrecoverableErrorHandler>&
           unrecoverable_error_handler,
       const base::Closure& report_unrecoverable_error_function,
       const HttpPostProviderFactoryGetter& http_post_provider_factory_getter,
       std::unique_ptr<syncer::SyncEncryptionHandler::NigoriState>
           saved_nigori_state) override {}
 };
 
 class SyncBackendHostMockCollectDeleteDirParam : public SyncBackendHostMock {
  public:
   explicit SyncBackendHostMockCollectDeleteDirParam(
       std::vector<bool>* delete_dir_param)
       : delete_dir_param_(delete_dir_param) {}
 
   void Initialize(
-      sync_driver::SyncFrontend* frontend,
+      syncer::SyncFrontend* frontend,
       std::unique_ptr<base::Thread> sync_thread,
       const scoped_refptr<base::SingleThreadTaskRunner>& db_thread,
       const scoped_refptr<base::SingleThreadTaskRunner>& file_thread,
       const syncer::WeakHandle<syncer::JsEventHandler>& event_handler,
       const GURL& service_url,
       const std::string& sync_user_agent,
       const syncer::SyncCredentials& credentials,
       bool delete_sync_data_folder,
       std::unique_ptr<syncer::SyncManagerFactory> sync_manager_factory,
       const syncer::WeakHandle<syncer::UnrecoverableErrorHandler>&
@@ skipping 91 matching lines @@
     signin_manager()->SetAuthenticatedAccountInfo(kGaiaId, kEmail);
     component_factory_ = profile_sync_service_bundle_.component_factory();
     ProfileSyncServiceBundle::SyncClientBuilder builder(
         &profile_sync_service_bundle_);
     ProfileSyncService::InitParams init_params =
         profile_sync_service_bundle_.CreateBasicInitParams(behavior,
                                                            builder.Build());
 
     service_.reset(new ProfileSyncService(std::move(init_params)));
     service_->RegisterDataTypeController(
-        base::MakeUnique<sync_driver::FakeDataTypeController>(
-            syncer::BOOKMARKS));
+        base::MakeUnique<syncer::FakeDataTypeController>(syncer::BOOKMARKS));
   }
 
 #if defined(OS_WIN) || defined(OS_MACOSX) || \
     (defined(OS_LINUX) && !defined(OS_CHROMEOS))
   void CreateServiceWithoutSignIn() {
     CreateService(ProfileSyncService::AUTO_START);
     signin_manager()->SignOut(signin_metrics::SIGNOUT_TEST,
                               signin_metrics::SignoutDelete::IGNORE_METRIC);
   }
 #endif
 
   void ShutdownAndDeleteService() {
     if (service_)
       service_->Shutdown();
     service_.reset();
   }
 
   void InitializeForNthSync() {
     // Set first sync time before initialize to simulate a complete sync setup.
-    sync_driver::SyncPrefs sync_prefs(prefs());
+    syncer::SyncPrefs sync_prefs(prefs());
     sync_prefs.SetFirstSyncTime(base::Time::Now());
     sync_prefs.SetFirstSetupComplete();
     sync_prefs.SetKeepEverythingSynced(true);
     service_->Initialize();
   }
 
   void InitializeForFirstSync() { service_->Initialize(); }
 
   void TriggerPassphraseRequired() {
     service_->OnPassphraseRequired(syncer::REASON_DECRYPTION,
                                    sync_pb::EncryptedData());
   }
 
   void TriggerDataTypeStartRequest() {
     service_->OnDataTypeRequestsSyncStartup(syncer::BOOKMARKS);
   }
 
   void OnConfigureCalled(syncer::ConfigureReason configure_reason) {
-    sync_driver::DataTypeManager::ConfigureResult result;
-    result.status = sync_driver::DataTypeManager::OK;
+    syncer::DataTypeManager::ConfigureResult result;
+    result.status = syncer::DataTypeManager::OK;
     service()->OnConfigureDone(result);
   }
 
   FakeDataTypeManager::ConfigureCalled GetDefaultConfigureCalledCallback() {
     return base::Bind(&ProfileSyncServiceTest::OnConfigureCalled,
                       base::Unretained(this));
   }
 
   void OnConfigureCalledRecordReason(syncer::ConfigureReason* reason_dest,
                                      syncer::ConfigureReason reason) {
@@ skipping 59 matching lines @@
   ProfileOAuth2TokenService* auth_service() {
     return profile_sync_service_bundle_.auth_service();
   }
 
   ProfileSyncService* service() { return service_.get(); }
 
   syncable_prefs::TestingPrefServiceSyncable* prefs() {
     return profile_sync_service_bundle_.pref_service();
   }
 
-  SyncApiComponentFactoryMock* component_factory() {
+  syncer::SyncApiComponentFactoryMock* component_factory() {
     return component_factory_;
   }
 
  protected:
   void PumpLoop() {
     base::RunLoop run_loop;
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   run_loop.QuitClosure());
     run_loop.Run();
   }
 
  private:
   base::MessageLoop message_loop_;
   ProfileSyncServiceBundle profile_sync_service_bundle_;
   std::unique_ptr<ProfileSyncService> service_;
 
   // The current component factory used by sync. May be null if the server
   // hasn't been created yet.
-  SyncApiComponentFactoryMock* component_factory_;
+  syncer::SyncApiComponentFactoryMock* component_factory_;
 };
 
 // Verify that the server URLs are sane.
 TEST_F(ProfileSyncServiceTest, InitialState) {
   CreateService(ProfileSyncService::AUTO_START);
   InitializeForNthSync();
   const std::string& url = service()->sync_service_url().spec();
-  EXPECT_TRUE(url == internal::kSyncServerUrl ||
-              url == internal::kSyncDevServerUrl);
+  EXPECT_TRUE(url == syncer::internal::kSyncServerUrl ||
+              url == syncer::internal::kSyncDevServerUrl);
 }
 
 // Verify a successful initialization.
 TEST_F(ProfileSyncServiceTest, SuccessfulInitialization) {
-  prefs()->SetManagedPref(sync_driver::prefs::kSyncManaged,
+  prefs()->SetManagedPref(syncer::prefs::kSyncManaged,
                           new base::FundamentalValue(false));
   IssueTestTokens();
   CreateService(ProfileSyncService::AUTO_START);
   ExpectDataTypeManagerCreation(1, GetDefaultConfigureCalledCallback());
   ExpectSyncBackendHostCreation(1);
   InitializeForNthSync();
   EXPECT_FALSE(service()->IsManaged());
   EXPECT_TRUE(service()->IsSyncActive());
 }
 
 // Verify that an initialization where first setup is not complete does not
 // start up the backend.
 TEST_F(ProfileSyncServiceTest, NeedsConfirmation) {
-  prefs()->SetManagedPref(sync_driver::prefs::kSyncManaged,
+  prefs()->SetManagedPref(syncer::prefs::kSyncManaged,
                           new base::FundamentalValue(false));
   IssueTestTokens();
   CreateService(ProfileSyncService::MANUAL_START);
-  sync_driver::SyncPrefs sync_prefs(prefs());
+  syncer::SyncPrefs sync_prefs(prefs());
   base::Time now = base::Time::Now();
   sync_prefs.SetLastSyncedTime(now);
   sync_prefs.SetKeepEverythingSynced(true);
   service()->Initialize();
   EXPECT_FALSE(service()->IsSyncActive());
 
   // The last sync time shouldn't be cleared.
   // TODO(zea): figure out a way to check that the directory itself wasn't
   // cleared.
   EXPECT_EQ(now, sync_prefs.GetLastSyncedTime());
@@ skipping 11 matching lines @@
   auto sync_blocker = service()->GetSetupInProgressHandle();
   EXPECT_TRUE(observer.setup_in_progress());
   sync_blocker.reset();
   EXPECT_FALSE(observer.setup_in_progress());
 
   service()->RemoveObserver(&observer);
 }
 
 // Verify that disable by enterprise policy works.
 TEST_F(ProfileSyncServiceTest, DisabledByPolicyBeforeInit) {
-  prefs()->SetManagedPref(sync_driver::prefs::kSyncManaged,
+  prefs()->SetManagedPref(syncer::prefs::kSyncManaged,
                           new base::FundamentalValue(true));
   IssueTestTokens();
   CreateService(ProfileSyncService::AUTO_START);
   InitializeForNthSync();
   EXPECT_TRUE(service()->IsManaged());
   EXPECT_FALSE(service()->IsSyncActive());
 }
 
 // Verify that disable by enterprise policy works even after the backend has
 // been initialized.
 TEST_F(ProfileSyncServiceTest, DisabledByPolicyAfterInit) {
   IssueTestTokens();
   CreateService(ProfileSyncService::AUTO_START);
   ExpectDataTypeManagerCreation(1, GetDefaultConfigureCalledCallback());
   ExpectSyncBackendHostCreation(1);
   InitializeForNthSync();
 
   EXPECT_FALSE(service()->IsManaged());
   EXPECT_TRUE(service()->IsSyncActive());
 
-  prefs()->SetManagedPref(sync_driver::prefs::kSyncManaged,
+  prefs()->SetManagedPref(syncer::prefs::kSyncManaged,
                           new base::FundamentalValue(true));
 
   EXPECT_TRUE(service()->IsManaged());
   EXPECT_FALSE(service()->IsSyncActive());
 }
 
 // Exercies the ProfileSyncService's code paths related to getting shut down
 // before the backend initialize call returns.
 TEST_F(ProfileSyncServiceTest, AbortedByShutdown) {
   CreateService(ProfileSyncService::AUTO_START);
@@ skipping 29 matching lines @@
 
 // Test RequestStop() after we've initialized the backend.
 TEST_F(ProfileSyncServiceTest, DisableAndEnableSyncTemporarily) {
   CreateService(ProfileSyncService::AUTO_START);
   IssueTestTokens();
   ExpectDataTypeManagerCreation(1, GetDefaultConfigureCalledCallback());
   ExpectSyncBackendHostCreation(1);
   InitializeForNthSync();
 
   EXPECT_TRUE(service()->IsSyncActive());
-  EXPECT_FALSE(prefs()->GetBoolean(sync_driver::prefs::kSyncSuppressStart));
+  EXPECT_FALSE(prefs()->GetBoolean(syncer::prefs::kSyncSuppressStart));
 
   testing::Mock::VerifyAndClearExpectations(component_factory());
 
   service()->RequestStop(ProfileSyncService::KEEP_DATA);
   EXPECT_FALSE(service()->IsSyncActive());
-  EXPECT_TRUE(prefs()->GetBoolean(sync_driver::prefs::kSyncSuppressStart));
+  EXPECT_TRUE(prefs()->GetBoolean(syncer::prefs::kSyncSuppressStart));
 
   ExpectDataTypeManagerCreation(1, GetDefaultConfigureCalledCallback());
   ExpectSyncBackendHostCreation(1);
 
   service()->RequestStart();
   EXPECT_TRUE(service()->IsSyncActive());
-  EXPECT_FALSE(prefs()->GetBoolean(sync_driver::prefs::kSyncSuppressStart));
+  EXPECT_FALSE(prefs()->GetBoolean(syncer::prefs::kSyncSuppressStart));
 }
 
 // Certain ProfileSyncService tests don't apply to Chrome OS, for example
 // things that deal with concepts like "signing out" and policy.
 #if !defined(OS_CHROMEOS)
 TEST_F(ProfileSyncServiceTest, EnableSyncAndSignOut) {
   CreateService(ProfileSyncService::AUTO_START);
   ExpectDataTypeManagerCreation(1, GetDefaultConfigureCalledCallback());
   ExpectSyncBackendHostCreation(1);
   IssueTestTokens();
   InitializeForNthSync();
 
   EXPECT_TRUE(service()->IsSyncActive());
-  EXPECT_FALSE(prefs()->GetBoolean(sync_driver::prefs::kSyncSuppressStart));
+  EXPECT_FALSE(prefs()->GetBoolean(syncer::prefs::kSyncSuppressStart));
 
   signin_manager()->SignOut(signin_metrics::SIGNOUT_TEST,
                             signin_metrics::SignoutDelete::IGNORE_METRIC);
   EXPECT_FALSE(service()->IsSyncActive());
 }
 #endif  // !defined(OS_CHROMEOS)
 
 TEST_F(ProfileSyncServiceTest, GetSyncTokenStatus) {
   CreateService(ProfileSyncService::AUTO_START);
   IssueTestTokens();
@@ skipping 114 matching lines @@
 
 // Test Sync will stop after receive memory pressure
 TEST_F(ProfileSyncServiceTest, MemoryPressureRecording) {
   CreateService(ProfileSyncService::AUTO_START);
   IssueTestTokens();
   ExpectDataTypeManagerCreation(1, GetDefaultConfigureCalledCallback());
   ExpectSyncBackendHostCreation(1);
   InitializeForNthSync();
 
   EXPECT_TRUE(service()->IsSyncActive());
-  EXPECT_FALSE(prefs()->GetBoolean(sync_driver::prefs::kSyncSuppressStart));
+  EXPECT_FALSE(prefs()->GetBoolean(syncer::prefs::kSyncSuppressStart));
 
   testing::Mock::VerifyAndClearExpectations(component_factory());
 
-  sync_driver::SyncPrefs sync_prefs(
-      service()->GetSyncClient()->GetPrefService());
+  syncer::SyncPrefs sync_prefs(service()->GetSyncClient()->GetPrefService());
 
-  EXPECT_EQ(
-      prefs()->GetInteger(sync_driver::prefs::kSyncMemoryPressureWarningCount),
-      0);
+  EXPECT_EQ(prefs()->GetInteger(syncer::prefs::kSyncMemoryPressureWarningCount),
+            0);
   EXPECT_FALSE(sync_prefs.DidSyncShutdownCleanly());
 
   // Simulate memory pressure notification.
   base::MemoryPressureListener::NotifyMemoryPressure(
       base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL);
   base::RunLoop().RunUntilIdle();
 
   // Verify memory pressure recorded.
-  EXPECT_EQ(
-      prefs()->GetInteger(sync_driver::prefs::kSyncMemoryPressureWarningCount),
-      1);
+  EXPECT_EQ(prefs()->GetInteger(syncer::prefs::kSyncMemoryPressureWarningCount),
+            1);
   EXPECT_FALSE(sync_prefs.DidSyncShutdownCleanly());
 
   // Simulate memory pressure notification.
   base::MemoryPressureListener::NotifyMemoryPressure(
       base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL);
   base::RunLoop().RunUntilIdle();
   ShutdownAndDeleteService();
 
   // Verify memory pressure and shutdown recorded.
-  EXPECT_EQ(
-      prefs()->GetInteger(sync_driver::prefs::kSyncMemoryPressureWarningCount),
-      2);
+  EXPECT_EQ(prefs()->GetInteger(syncer::prefs::kSyncMemoryPressureWarningCount),
+            2);
   EXPECT_TRUE(sync_prefs.DidSyncShutdownCleanly());
 }
 
 // Verify that OnLocalSetPassphraseEncryption triggers catch up configure sync
 // cycle, calls ClearServerData, shuts down and restarts sync.
 TEST_F(ProfileSyncServiceTest, OnLocalSetPassphraseEncryption) {
   base::test::ScopedFeatureList scoped_feature_list;
   scoped_feature_list.InitAndEnableFeature(
       switches::kSyncClearDataOnPassphraseEncryption);
   IssueTestTokens();
   CreateService(ProfileSyncService::AUTO_START);
 
   syncer::SyncManager::ClearServerDataCallback captured_callback;
   syncer::ConfigureReason configure_reason = syncer::CONFIGURE_REASON_UNKNOWN;
 
   // Initialize sync, ensure that both DataTypeManager and SyncBackendHost are
   // initialized and DTM::Configure is called with
   // CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE.
   ExpectSyncBackendHostCreationCaptureClearServerData(&captured_callback);
   ExpectDataTypeManagerCreation(
       1, GetRecordingConfigureCalledCallback(&configure_reason));
   InitializeForNthSync();
   EXPECT_TRUE(service()->IsSyncActive());
   testing::Mock::VerifyAndClearExpectations(component_factory());
   EXPECT_EQ(syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE, configure_reason);
-  sync_driver::DataTypeManager::ConfigureResult result;
-  result.status = sync_driver::DataTypeManager::OK;
+  syncer::DataTypeManager::ConfigureResult result;
+  result.status = syncer::DataTypeManager::OK;
   service()->OnConfigureDone(result);
 
   // Simulate user entering encryption passphrase. Ensure that catch up
   // configure cycle is started (DTM::Configure is called with
   // CONFIGURE_REASON_CATCH_UP).
   const syncer::SyncEncryptionHandler::NigoriState nigori_state;
   service()->OnLocalSetPassphraseEncryption(nigori_state);
   EXPECT_EQ(syncer::CONFIGURE_REASON_CATCH_UP, configure_reason);
   EXPECT_TRUE(captured_callback.is_null());
 
@@ skipping 22 matching lines @@
   scoped_feature_list.InitAndEnableFeature(
       switches::kSyncClearDataOnPassphraseEncryption);
   IssueTestTokens();
   CreateService(ProfileSyncService::AUTO_START);
   ExpectSyncBackendHostCreation(1);
   ExpectDataTypeManagerCreation(
       1, GetRecordingConfigureCalledCallback(&configure_reason));
   InitializeForNthSync();
   testing::Mock::VerifyAndClearExpectations(component_factory());
   EXPECT_EQ(syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE, configure_reason);
-  sync_driver::DataTypeManager::ConfigureResult result;
-  result.status = sync_driver::DataTypeManager::OK;
+  syncer::DataTypeManager::ConfigureResult result;
+  result.status = syncer::DataTypeManager::OK;
   service()->OnConfigureDone(result);
 
   // Simulate user entering encryption passphrase. Ensure Configure was called
   // but don't let it continue.
   const syncer::SyncEncryptionHandler::NigoriState nigori_state;
   service()->OnLocalSetPassphraseEncryption(nigori_state);
   EXPECT_EQ(syncer::CONFIGURE_REASON_CATCH_UP, configure_reason);
 
   // Simulate browser restart. First configuration is a regular one.
   service()->Shutdown();
@@ skipping 50 matching lines @@
   service()->Shutdown();
   ExpectSyncBackendHostCreationCaptureClearServerData(&captured_callback);
   ExpectDataTypeManagerCreation(
       1, GetRecordingConfigureCalledCallback(&configure_reason));
   service()->RequestStart();
   testing::Mock::VerifyAndClearExpectations(component_factory());
   EXPECT_EQ(syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE, configure_reason);
   EXPECT_TRUE(captured_callback.is_null());
 
   // Simulate configure successful. This time it should be catch up.
-  sync_driver::DataTypeManager::ConfigureResult result;
-  result.status = sync_driver::DataTypeManager::OK;
+  syncer::DataTypeManager::ConfigureResult result;
+  result.status = syncer::DataTypeManager::OK;
   service()->OnConfigureDone(result);
   EXPECT_EQ(syncer::CONFIGURE_REASON_CATCH_UP, configure_reason);
   EXPECT_TRUE(captured_callback.is_null());
 
   // Simulate catch up configure successful. Ensure that SBH::ClearServerData is
   // called.
   service()->OnConfigureDone(result);
   EXPECT_FALSE(captured_callback.is_null());
 
   ExpectSyncBackendHostCreation(1);
   ExpectDataTypeManagerCreation(
       1, GetRecordingConfigureCalledCallback(&configure_reason));
   captured_callback.Run();
   testing::Mock::VerifyAndClearExpectations(component_factory());
   EXPECT_EQ(syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE, configure_reason);
 }
 
 // Test that the passphrase prompt due to version change logic gets triggered
 // on a datatype type requesting startup, but only happens once.
 TEST_F(ProfileSyncServiceTest, PassphrasePromptDueToVersion) {
   IssueTestTokens();
   CreateService(ProfileSyncService::AUTO_START);
   ExpectDataTypeManagerCreation(1, GetDefaultConfigureCalledCallback());
   ExpectSyncBackendHostCreation(1);
   InitializeForNthSync();
 
-  sync_driver::SyncPrefs sync_prefs(
-      service()->GetSyncClient()->GetPrefService());
+  syncer::SyncPrefs sync_prefs(service()->GetSyncClient()->GetPrefService());
   EXPECT_EQ(PRODUCT_VERSION, sync_prefs.GetLastRunVersion());
 
   sync_prefs.SetPassphrasePrompted(true);
 
   // Until a datatype requests startup while a passphrase is required the
   // passphrase prompt bit should remain set.
   EXPECT_TRUE(sync_prefs.IsPassphrasePrompted());
   TriggerPassphraseRequired();
   EXPECT_TRUE(sync_prefs.IsPassphrasePrompted());
 
@@ skipping 60 matching lines @@
 // dereferenced in OnSyncCycleCompleted. The fix is to use find() to check if
 // entry for sessions exists in map.
 TEST_F(ProfileSyncServiceTest, ValidPointersInDTCMap) {
   CreateService(ProfileSyncService::AUTO_START);
   service()->OnSessionRestoreComplete();
   service()->OnSyncCycleCompleted();
 }
 
 }  // namespace
 }  // namespace browser_sync