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

components/sync/driver/data_type_manager_impl_unittest.cc

 // 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 "components/sync/driver/data_type_manager_impl.h"
 
 #include <memory>
 
 #include "base/compiler_specific.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "components/sync/base/model_type.h"
 #include "components/sync/core/activation_context.h"
 #include "components/sync/core/configure_reason.h"
 #include "components/sync/driver/backend_data_type_configurer.h"
 #include "components/sync/driver/data_type_encryption_handler.h"
 #include "components/sync/driver/data_type_manager_observer.h"
 #include "components/sync/driver/data_type_status_table.h"
 #include "components/sync/driver/fake_data_type_controller.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace sync_driver {
-
-using syncer::SyncError;
-using syncer::ModelType;
-using syncer::ModelTypeSet;
-using syncer::ModelTypeToString;
-using syncer::BOOKMARKS;
-using syncer::APPS;
-using syncer::PASSWORDS;
-using syncer::PREFERENCES;
-using syncer::NIGORI;
+namespace syncer {
 
 namespace {
 
 // Helper for unioning with control types.
 ModelTypeSet AddControlTypesTo(ModelTypeSet types) {
-  ModelTypeSet result = syncer::ControlTypes();
+  ModelTypeSet result = ControlTypes();
   result.PutAll(types);
   return result;
 }
 
 DataTypeStatusTable BuildStatusTable(ModelTypeSet crypto_errors,
                                      ModelTypeSet association_errors,
                                      ModelTypeSet unready_errors,
                                      ModelTypeSet unrecoverable_errors) {
   DataTypeStatusTable::TypeErrorMap error_map;
   for (ModelTypeSet::Iterator iter = crypto_errors.First(); iter.Good();
@@ skipping 22 matching lines @@
   return status_table;
 }
 
 // Fake BackendDataTypeConfigurer implementation that simply stores away the
 // callback passed into ConfigureDataTypes.
 class FakeBackendDataTypeConfigurer : public BackendDataTypeConfigurer {
  public:
   FakeBackendDataTypeConfigurer() : configure_call_count_(0) {}
   ~FakeBackendDataTypeConfigurer() override {}
 
-  syncer::ModelTypeSet ConfigureDataTypes(
-      syncer::ConfigureReason reason,
+  ModelTypeSet ConfigureDataTypes(
+      ConfigureReason reason,
       const DataTypeConfigStateMap& config_state_map,
       const base::Callback<void(ModelTypeSet, ModelTypeSet)>& ready_task,
       const base::Callback<void()>& retry_callback) override {
     configure_call_count_++;
     last_ready_task_ = ready_task;
 
     for (auto iter = expected_configure_types_.begin();
          iter != expected_configure_types_.end(); ++iter) {
       if (!iter->second.Empty()) {
         EXPECT_TRUE(iter->second ==
                     GetDataTypesInState(iter->first, config_state_map))
             << "State " << iter->first << " : "
             << ModelTypeSetToString(iter->second) << " v.s. "
             << ModelTypeSetToString(
                    GetDataTypesInState(iter->first, config_state_map));
       }
     }
     return ready_types_;
   }
 
-  void ActivateDirectoryDataType(syncer::ModelType type,
-                                 syncer::ModelSafeGroup group,
+  void ActivateDirectoryDataType(ModelType type,
+                                 ModelSafeGroup group,
                                  ChangeProcessor* change_processor) override {
     activated_types_.Put(type);
   }
-  void DeactivateDirectoryDataType(syncer::ModelType type) override {
+  void DeactivateDirectoryDataType(ModelType type) override {
     activated_types_.Remove(type);
   }
 
-  void ActivateNonBlockingDataType(syncer::ModelType type,
-                                   std::unique_ptr<syncer_v2::ActivationContext>
-                                       activation_context) override {
+  void ActivateNonBlockingDataType(
+      ModelType type,
+      std::unique_ptr<ActivationContext> activation_context) override {
     // TODO(stanisc): crbug.com/515962: Add test coverage.
   }
 
-  void DeactivateNonBlockingDataType(syncer::ModelType type) override {
+  void DeactivateNonBlockingDataType(ModelType type) override {
     // TODO(stanisc): crbug.com/515962: Add test coverage.
   }
 
   base::Callback<void(ModelTypeSet, ModelTypeSet)> last_ready_task() const {
     return last_ready_task_;
   }
 
   void set_expected_configure_types(DataTypeConfigState config_state,
                                     ModelTypeSet types) {
     expected_configure_types_[config_state] = types;
@@ skipping 92 matching lines @@
 
 ModelTypeSet FakeDataTypeEncryptionHandler::GetEncryptedDataTypes() const {
   return encrypted_types_;
 }
 
 }  // namespace
 
 class TestDataTypeManager : public DataTypeManagerImpl {
  public:
   TestDataTypeManager(
-      const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
-          debug_info_listener,
+      const WeakHandle<DataTypeDebugInfoListener>& debug_info_listener,
       BackendDataTypeConfigurer* configurer,
       const DataTypeController::TypeMap* controllers,
       const DataTypeEncryptionHandler* encryption_handler,
       DataTypeManagerObserver* observer)
       : DataTypeManagerImpl(debug_info_listener,
                             controllers,
                             encryption_handler,
                             configurer,
                             observer),
-        custom_priority_types_(syncer::ControlTypes()) {}
+        custom_priority_types_(ControlTypes()) {}
 
   void set_priority_types(const ModelTypeSet& priority_types) {
     custom_priority_types_ = priority_types;
   }
 
   DataTypeManager::ConfigureResult configure_result() const {
     return configure_result_;
   }
 
   void OnModelAssociationDone(
@@ skipping 14 matching lines @@
 // The actual test harness class, parametrized on nigori state (i.e., tests are
 // run both configuring with nigori, and configuring without).
 class SyncDataTypeManagerImplTest : public testing::Test {
  public:
   SyncDataTypeManagerImplTest() {}
 
   ~SyncDataTypeManagerImplTest() override {}
 
  protected:
   void SetUp() override {
-    dtm_.reset(new TestDataTypeManager(
-        syncer::WeakHandle<syncer::DataTypeDebugInfoListener>(), &configurer_,
-        &controllers_, &encryption_handler_, &observer_));
+    dtm_.reset(new TestDataTypeManager(WeakHandle<DataTypeDebugInfoListener>(),
+                                       &configurer_, &controllers_,
+                                       &encryption_handler_, &observer_));
   }
 
   void SetConfigureStartExpectation() { observer_.ExpectStart(); }
 
   void SetConfigureDoneExpectation(DataTypeManager::ConfigureStatus status,
                                    const DataTypeStatusTable& status_table) {
     DataTypeManager::ConfigureResult result;
     result.status = status;
     result.data_type_status_table = status_table;
     observer_.ExpectDone(result);
   }
 
   // Configure the given DTM with the given desired types.
   void Configure(DataTypeManagerImpl* dtm, const ModelTypeSet& desired_types) {
-    dtm->Configure(desired_types, syncer::CONFIGURE_REASON_RECONFIGURATION);
+    dtm->Configure(desired_types, CONFIGURE_REASON_RECONFIGURATION);
   }
 
   // Finish downloading for the given DTM. Should be done only after
   // a call to Configure().
   void FinishDownload(const DataTypeManager& dtm,
                       ModelTypeSet types_to_configure,
                       ModelTypeSet failed_download_types) {
     EXPECT_EQ(DataTypeManager::CONFIGURING, dtm.state());
     ASSERT_FALSE(configurer_.last_ready_task().is_null());
     configurer_.last_ready_task().Run(
-        syncer::Difference(types_to_configure, failed_download_types),
+        Difference(types_to_configure, failed_download_types),
         failed_download_types);
   }
 
   // Adds a fake controller for the given type to |controllers_|.
   // Should be called only before setting up the DTM.
   void AddController(ModelType model_type) {
     controllers_[model_type] =
         base::MakeUnique<FakeDataTypeController>(model_type);
   }
 
@@ skipping 569 matching lines @@
   FinishDownload(*dtm_, ModelTypeSet(BOOKMARKS), ModelTypeSet());
   GetController(BOOKMARKS)->FinishStart(DataTypeController::OK);
 
   // We've now configured bookmarks and (implicitly) the control types.
   EXPECT_EQ(DataTypeManager::CONFIGURED, dtm_->state());
   observer_.ResetExpectations();
 
   // Pretend we were told to migrate all types.
   ModelTypeSet to_migrate;
   to_migrate.Put(BOOKMARKS);
-  to_migrate.PutAll(syncer::ControlTypes());
+  to_migrate.PutAll(ControlTypes());
 
   SetConfigureStartExpectation();
   SetConfigureDoneExpectation(DataTypeManager::OK, DataTypeStatusTable());
-  dtm_->PurgeForMigration(to_migrate, syncer::CONFIGURE_REASON_MIGRATION);
+  dtm_->PurgeForMigration(to_migrate, CONFIGURE_REASON_MIGRATION);
   EXPECT_EQ(DataTypeManager::CONFIGURING, dtm_->state());
 
   // The DTM will call ConfigureDataTypes(), even though it is unnecessary.
   FinishDownload(*dtm_, ModelTypeSet(), ModelTypeSet());
   EXPECT_EQ(DataTypeManager::CONFIGURED, dtm_->state());
   observer_.ResetExpectations();
 
   // Re-enable the migrated types.
   SetConfigureStartExpectation();
   SetConfigureDoneExpectation(DataTypeManager::OK, DataTypeStatusTable());
@@ skipping 13 matching lines @@
   SetConfigureDoneExpectation(DataTypeManager::OK, DataTypeStatusTable());
   Configure(dtm_.get(), ModelTypeSet(BOOKMARKS));
   FinishDownload(*dtm_, ModelTypeSet(), ModelTypeSet());
   FinishDownload(*dtm_, ModelTypeSet(BOOKMARKS), ModelTypeSet());
   GetController(BOOKMARKS)->FinishStart(DataTypeController::OK);
   EXPECT_EQ(DataTypeManager::CONFIGURED, dtm_->state());
   observer_.ResetExpectations();
 
   // Purge the Nigori type.
   SetConfigureStartExpectation();
-  dtm_->PurgeForMigration(ModelTypeSet(NIGORI),
-                          syncer::CONFIGURE_REASON_MIGRATION);
+  dtm_->PurgeForMigration(ModelTypeSet(NIGORI), CONFIGURE_REASON_MIGRATION);
   EXPECT_EQ(DataTypeManager::CONFIGURING, dtm_->state());
   observer_.ResetExpectations();
 
   // Before the backend configuration completes, ask for a different
   // set of types.  This request asks for
   // - BOOKMARKS: which is redundant because it was already enabled,
   // - PREFERENCES: which is new and will need to be downloaded, and
   // - NIGORI: (added implicitly because it is a control type) which
   //   the DTM is part-way through purging.
   Configure(dtm_.get(), ModelTypeSet(BOOKMARKS, PREFERENCES));
@@ skipping 221 matching lines @@
             GetController(BOOKMARKS)->state());
 
   // Make PREFERENCES association fail.
   GetController(PREFERENCES)
       ->FinishStart(DataTypeController::ASSOCIATION_FAILED);
   EXPECT_EQ(DataTypeManager::CONFIGURING, dtm_->state());
 
   // Reconfigure without PREFERENCES after the BOOKMARKS download completes,
   // then reconfigure with BOOKMARKS.
   configurer_.set_expected_configure_types(
-      BackendDataTypeConfigurer::CONFIGURE_ACTIVE, syncer::ControlTypes());
+      BackendDataTypeConfigurer::CONFIGURE_ACTIVE, ControlTypes());
   FinishDownload(*dtm_, ModelTypeSet(BOOKMARKS), ModelTypeSet());
   configurer_.set_expected_configure_types(
       BackendDataTypeConfigurer::CONFIGURE_ACTIVE, ModelTypeSet(BOOKMARKS));
   FinishDownload(*dtm_, ModelTypeSet(), ModelTypeSet());
 
   // Reconfigure with BOOKMARKS.
   FinishDownload(*dtm_, ModelTypeSet(BOOKMARKS), ModelTypeSet());
   EXPECT_EQ(DataTypeController::ASSOCIATING, GetController(BOOKMARKS)->state());
   GetController(BOOKMARKS)->FinishStart(DataTypeController::OK);
 
@@ skipping 60 matching lines @@
 
 TEST_F(SyncDataTypeManagerImplTest, FilterDesiredTypes) {
   AddController(BOOKMARKS);
 
   ModelTypeSet types(BOOKMARKS, APPS);
   dtm_->set_priority_types(AddControlTypesTo(types));
 
   SetConfigureStartExpectation();
   SetConfigureDoneExpectation(DataTypeManager::OK, DataTypeStatusTable());
 
-  ModelTypeSet expected_types = syncer::ControlTypes();
+  ModelTypeSet expected_types = ControlTypes();
   expected_types.Put(BOOKMARKS);
   // APPS is filtered out because there's no controller for it.
   configurer_.set_expected_configure_types(
       BackendDataTypeConfigurer::CONFIGURE_ACTIVE, expected_types);
   Configure(dtm_.get(), types);
   FinishDownload(*dtm_, ModelTypeSet(BOOKMARKS), ModelTypeSet());
   GetController(BOOKMARKS)->FinishStart(DataTypeController::OK);
 
   dtm_->Stop();
   EXPECT_EQ(DataTypeManager::STOPPED, dtm_->state());
@@ skipping 17 matching lines @@
   FinishDownload(*dtm_, ModelTypeSet(), ModelTypeSet());  // Reconfig for error.
   FinishDownload(*dtm_, ModelTypeSet(), ModelTypeSet());  // Reconfig for error.
   EXPECT_EQ(DataTypeManager::CONFIGURED, dtm_->state());
   EXPECT_EQ(DataTypeController::RUNNING, GetController(PREFERENCES)->state());
   EXPECT_EQ(DataTypeController::NOT_RUNNING, GetController(BOOKMARKS)->state());
 
   observer_.ResetExpectations();
 
   // Re-enable bookmarks.
   SetConfigureDoneExpectation(DataTypeManager::OK, DataTypeStatusTable());
-  dtm_->ReenableType(syncer::BOOKMARKS);
+  dtm_->ReenableType(BOOKMARKS);
 
   EXPECT_EQ(DataTypeManager::CONFIGURING, dtm_->state());
   FinishDownload(*dtm_, ModelTypeSet(), ModelTypeSet());
   FinishDownload(*dtm_, ModelTypeSet(BOOKMARKS), ModelTypeSet());
   EXPECT_EQ(DataTypeManager::CONFIGURING, dtm_->state());
   GetController(BOOKMARKS)->FinishStart(DataTypeController::OK);
   EXPECT_EQ(DataTypeManager::CONFIGURED, dtm_->state());
   EXPECT_EQ(DataTypeController::RUNNING, GetController(PREFERENCES)->state());
   EXPECT_EQ(DataTypeController::RUNNING, GetController(BOOKMARKS)->state());
 
   // Should do nothing.
-  dtm_->ReenableType(syncer::BOOKMARKS);
+  dtm_->ReenableType(BOOKMARKS);
 }
 
 TEST_F(SyncDataTypeManagerImplTest, UnreadyType) {
   AddController(BOOKMARKS);
   GetController(BOOKMARKS)->SetReadyForStart(false);
 
   // Bookmarks is never started due to being unready.
   SetConfigureStartExpectation();
   SetConfigureDoneExpectation(
       DataTypeManager::OK,
@@ skipping 24 matching lines @@
   observer_.ResetExpectations();
   dtm_->ReenableType(BOOKMARKS);
 
   dtm_->Stop();
   EXPECT_EQ(DataTypeManager::STOPPED, dtm_->state());
   EXPECT_TRUE(configurer_.activated_types().Empty());
 }
 
 TEST_F(SyncDataTypeManagerImplTest, ModelLoadError) {
   AddController(BOOKMARKS);
-  GetController(BOOKMARKS)->SetModelLoadError(syncer::SyncError(
-      FROM_HERE, SyncError::DATATYPE_ERROR, "load error", BOOKMARKS));
+  GetController(BOOKMARKS)->SetModelLoadError(
+      SyncError(FROM_HERE, SyncError::DATATYPE_ERROR, "load error", BOOKMARKS));
 
   // Bookmarks is never started due to hitting a model load error.
   SetConfigureStartExpectation();
   SetConfigureDoneExpectation(
       DataTypeManager::OK,
       BuildStatusTable(ModelTypeSet(), ModelTypeSet(BOOKMARKS), ModelTypeSet(),
                        ModelTypeSet()));
   Configure(dtm_.get(), ModelTypeSet(BOOKMARKS));
   FinishDownload(*dtm_, ModelTypeSet(), ModelTypeSet());
   FinishDownload(*dtm_, ModelTypeSet(BOOKMARKS), ModelTypeSet());
   EXPECT_EQ(DataTypeManager::CONFIGURED, dtm_->state());
   EXPECT_EQ(DataTypeController::NOT_RUNNING, GetController(BOOKMARKS)->state());
 
   EXPECT_EQ(0U, configurer_.activated_types().Size());
 }
 
 TEST_F(SyncDataTypeManagerImplTest, ErrorBeforeAssociation) {
   AddController(BOOKMARKS);
 
   // Bookmarks is never started due to hitting a datatype error while the DTM
   // is still downloading types.
   SetConfigureStartExpectation();
   SetConfigureDoneExpectation(
       DataTypeManager::OK,
       BuildStatusTable(ModelTypeSet(), ModelTypeSet(BOOKMARKS), ModelTypeSet(),
                        ModelTypeSet()));
   Configure(dtm_.get(), ModelTypeSet(BOOKMARKS));
   FinishDownload(*dtm_, ModelTypeSet(), ModelTypeSet());
   GetController(BOOKMARKS)->CreateErrorHandler()->OnUnrecoverableError(
-      syncer::SyncError(FROM_HERE, SyncError::DATATYPE_ERROR, "bookmarks error",
-                        BOOKMARKS));
+      SyncError(FROM_HERE, SyncError::DATATYPE_ERROR, "bookmarks error",
+                BOOKMARKS));
   base::RunLoop().RunUntilIdle();
   FinishDownload(*dtm_, ModelTypeSet(BOOKMARKS), ModelTypeSet());
   FinishDownload(*dtm_, ModelTypeSet(), ModelTypeSet());  // Reconfig for error.
   EXPECT_EQ(DataTypeManager::CONFIGURED, dtm_->state());
   EXPECT_EQ(DataTypeController::NOT_RUNNING, GetController(BOOKMARKS)->state());
 
   EXPECT_EQ(0U, configurer_.activated_types().Size());
 }
 
 TEST_F(SyncDataTypeManagerImplTest, AssociationNeverCompletes) {
@@ skipping 177 matching lines @@
   AddController(BOOKMARKS);
   AddController(PASSWORDS);
 
   SetConfigureStartExpectation();
   SetConfigureDoneExpectation(DataTypeManager::OK, DataTypeStatusTable());
   configurer_.set_expected_configure_types(
       BackendDataTypeConfigurer::CONFIGURE_CLEAN,
       AddControlTypesTo(ModelTypeSet(BOOKMARKS, PASSWORDS)));
 
   dtm_->Configure(ModelTypeSet(BOOKMARKS, PASSWORDS),
-                  syncer::CONFIGURE_REASON_CATCH_UP);
+                  CONFIGURE_REASON_CATCH_UP);
   EXPECT_EQ(DataTypeManager::CONFIGURING, dtm_->state());
 
   FinishDownload(*dtm_, ModelTypeSet(), ModelTypeSet());
   FinishDownload(*dtm_, ModelTypeSet(BOOKMARKS, PASSWORDS), ModelTypeSet());
   EXPECT_EQ(DataTypeManager::CONFIGURING, dtm_->state());
 
   GetController(BOOKMARKS)->FinishStart(DataTypeController::OK);
   EXPECT_EQ(DataTypeManager::CONFIGURING, dtm_->state());
   EXPECT_EQ(1U, configurer_.activated_types().Size());
   GetController(PASSWORDS)->FinishStart(DataTypeController::OK);
@@ skipping 12 matching lines @@
   AddController(BOOKMARKS);
   AddController(PASSWORDS);
 
   SetConfigureStartExpectation();
   SetConfigureDoneExpectation(DataTypeManager::OK, DataTypeStatusTable());
 
   // Configure (catch up) with one type.
   configurer_.set_expected_configure_types(
       BackendDataTypeConfigurer::CONFIGURE_CLEAN,
       AddControlTypesTo(ModelTypeSet(BOOKMARKS)));
-  dtm_->Configure(ModelTypeSet(BOOKMARKS), syncer::CONFIGURE_REASON_CATCH_UP);
+  dtm_->Configure(ModelTypeSet(BOOKMARKS), CONFIGURE_REASON_CATCH_UP);
   EXPECT_EQ(DataTypeManager::CONFIGURING, dtm_->state());
 
   // Configure with both types before the first one completes. Both types should
   // end up in CONFIGURE_CLEAN.
   configurer_.set_expected_configure_types(
       BackendDataTypeConfigurer::CONFIGURE_CLEAN,
       AddControlTypesTo(ModelTypeSet(BOOKMARKS, PASSWORDS)));
   dtm_->Configure(ModelTypeSet(BOOKMARKS, PASSWORDS),
-                  syncer::CONFIGURE_REASON_RECONFIGURATION);
+                  CONFIGURE_REASON_RECONFIGURATION);
   EXPECT_EQ(DataTypeManager::CONFIGURING, dtm_->state());
 
   FinishDownload(*dtm_, ModelTypeSet(), ModelTypeSet());
   EXPECT_EQ(DataTypeManager::CONFIGURING, dtm_->state());
   FinishDownload(*dtm_, ModelTypeSet(), ModelTypeSet());
   FinishDownload(*dtm_, ModelTypeSet(BOOKMARKS, PASSWORDS), ModelTypeSet());
   EXPECT_EQ(DataTypeManager::CONFIGURING, dtm_->state());
 
   GetController(BOOKMARKS)->FinishStart(DataTypeController::OK);
   EXPECT_EQ(DataTypeManager::CONFIGURING, dtm_->state());
@@ skipping 47 matching lines @@
   EXPECT_EQ(DataTypeController::MODEL_STARTING,
             GetController(PASSWORDS)->state());
   EXPECT_EQ(0, GetController(BOOKMARKS)->register_with_backend_call_count());
   EXPECT_EQ(0, GetController(PASSWORDS)->register_with_backend_call_count());
 
   dtm_->OnAllDataTypesReadyForConfigure();
   EXPECT_EQ(0, GetController(BOOKMARKS)->register_with_backend_call_count());
   EXPECT_EQ(1, GetController(PASSWORDS)->register_with_backend_call_count());
 }
 
-}  // namespace sync_driver
+}  // namespace syncer