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

components/sync/core/shared_model_type_processor_unittest.cc

Index: components/sync/core/shared_model_type_processor_unittest.cc
diff --git a/components/sync/core/shared_model_type_processor_unittest.cc b/components/sync/core/shared_model_type_processor_unittest.cc
index 1667a499710b3c187e943596b20f9acd15bb4bd7..4a558df361263904ebfeda98a34cf7543c9e08e6 100644
--- a/components/sync/core/shared_model_type_processor_unittest.cc
+++ b/components/sync/core/shared_model_type_processor_unittest.cc
@@ -32,7 +32,7 @@ using sync_pb::EntitySpecifics;
 using sync_pb::EntityMetadata;
 using sync_pb::DataTypeState;
 
-namespace syncer_v2 {
+namespace syncer {
 
 namespace {
 
@@ -54,9 +54,8 @@ const std::string kHash5(FakeModelTypeService::TagHashFromKey(kKey5));
 // worker/processor will not have been initialized and thus empty.
 const EntitySpecifics kEmptySpecifics;
 
-syncer::SyncError CreateSyncError(syncer::SyncError::ErrorType error_type) {
-  return syncer::SyncError(FROM_HERE, error_type, "TestError",
-                           syncer::PREFERENCES);
+SyncError CreateSyncError(SyncError::ErrorType error_type) {
+  return SyncError(FROM_HERE, error_type, "TestError", PREFERENCES);
 }
 
 }  // namespace
@@ -101,8 +100,7 @@ class SharedModelTypeProcessorTest : public ::testing::Test,
   }
 
   void OnMetadataLoaded() {
-    type_processor()->OnMetadataLoaded(syncer::SyncError(),
-                                       db_.CreateMetadataBatch());
+    type_processor()->OnMetadataLoaded(SyncError(), db_.CreateMetadataBatch());
   }
 
   void OnPendingCommitDataLoaded() {
@@ -112,8 +110,8 @@ class SharedModelTypeProcessorTest : public ::testing::Test,
   }
 
   void OnSyncStarting() {
-    std::unique_ptr<syncer::DataTypeErrorHandlerMock> error_handler =
-        base::MakeUnique<syncer::DataTypeErrorHandlerMock>();
+    std::unique_ptr<DataTypeErrorHandlerMock> error_handler =
+        base::MakeUnique<DataTypeErrorHandlerMock>();
     error_handler_ = error_handler.get();
     type_processor()->OnSyncStarting(
         std::move(error_handler),
@@ -178,8 +176,8 @@ class SharedModelTypeProcessorTest : public ::testing::Test,
 
   // Sets the error type that OnReadyToConnect (our StartCallback) expects to
   // receive.
-  void ExpectStartError(syncer::SyncError::ErrorType error_type) {
-    DCHECK(expected_start_error_ == syncer::SyncError::UNSET);
+  void ExpectStartError(SyncError::ErrorType error_type) {
+    DCHECK(expected_start_error_ == SyncError::UNSET);
     expected_start_error_ = error_type;
   }
 
@@ -189,7 +187,7 @@ class SharedModelTypeProcessorTest : public ::testing::Test,
     return static_cast<SharedModelTypeProcessor*>(change_processor());
   }
 
-  syncer::DataTypeErrorHandlerMock* error_handler() {
+  DataTypeErrorHandlerMock* error_handler() {
     DCHECK(error_handler_);
     return error_handler_;
   }
@@ -200,16 +198,16 @@ class SharedModelTypeProcessorTest : public ::testing::Test,
   void CheckPostConditions() override {
     FakeModelTypeService::CheckPostConditions();
     DCHECK(data_callback_.is_null());
-    DCHECK_EQ(syncer::SyncError::UNSET, expected_start_error_);
+    DCHECK_EQ(SyncError::UNSET, expected_start_error_);
   }
 
-  void OnReadyToConnect(syncer::SyncError error,
+  void OnReadyToConnect(SyncError error,
                         std::unique_ptr<ActivationContext> context) {
-    if (expected_start_error_ != syncer::SyncError::UNSET) {
+    if (expected_start_error_ != SyncError::UNSET) {
       EXPECT_TRUE(error.IsSet());
       EXPECT_EQ(expected_start_error_, error.error_type());
       EXPECT_EQ(nullptr, context);
-      expected_start_error_ = syncer::SyncError::UNSET;
+      expected_start_error_ = SyncError::UNSET;
       return;
     }
 
@@ -225,14 +223,14 @@ class SharedModelTypeProcessorTest : public ::testing::Test,
 
   // FakeModelTypeService overrides.
 
-  syncer::SyncError MergeSyncData(std::unique_ptr<MetadataChangeList> mcl,
-                                  EntityDataMap entity_data_map) override {
+  SyncError MergeSyncData(std::unique_ptr<MetadataChangeList> mcl,
+                          EntityDataMap entity_data_map) override {
     merge_call_count_++;
     return FakeModelTypeService::MergeSyncData(std::move(mcl), entity_data_map);
   }
 
   void CaptureDataCallback(DataCallback callback,
-                           syncer::SyncError error,
+                           SyncError error,
                            std::unique_ptr<DataBatch> data) {
     data_callback_ = base::Bind(callback, error, base::Passed(std::move(data)));
   }
@@ -254,10 +252,10 @@ class SharedModelTypeProcessorTest : public ::testing::Test,
   base::Closure data_callback_;
 
   // The processor's error handler.
-  syncer::DataTypeErrorHandlerMock* error_handler_;
+  DataTypeErrorHandlerMock* error_handler_;
 
   // The error to expect in OnReadyToConnect().
-  syncer::SyncError::ErrorType expected_start_error_ = syncer::SyncError::UNSET;
+  SyncError::ErrorType expected_start_error_ = SyncError::UNSET;
 
   // The number of times MergeSyncData has been called.
   int merge_call_count_ = 0;
@@ -317,33 +315,33 @@ TEST_F(SharedModelTypeProcessorTest, InitialSyncError) {
   OnMetadataLoaded();
   OnSyncStarting();
 
-  SetServiceError(syncer::SyncError::DATATYPE_ERROR);
-  error_handler()->ExpectError(syncer::SyncError::DATATYPE_ERROR);
+  SetServiceError(SyncError::DATATYPE_ERROR);
+  error_handler()->ExpectError(SyncError::DATATYPE_ERROR);
   worker()->UpdateFromServer();
 }
 
 // Test that errors before it's called are passed to |start_callback| correctly.
 TEST_F(SharedModelTypeProcessorTest, StartErrors) {
   CreateChangeProcessor();
-  type_processor()->OnMetadataLoaded(
-      CreateSyncError(syncer::SyncError::DATATYPE_ERROR), nullptr);
-  ExpectStartError(syncer::SyncError::DATATYPE_ERROR);
+  type_processor()->OnMetadataLoaded(CreateSyncError(SyncError::DATATYPE_ERROR),
+                                     nullptr);
+  ExpectStartError(SyncError::DATATYPE_ERROR);
   OnSyncStarting();
 
   // Test OnSyncStarting happening first.
   ResetState();
   CreateChangeProcessor();
   OnSyncStarting();
-  ExpectStartError(syncer::SyncError::DATATYPE_ERROR);
-  type_processor()->OnMetadataLoaded(
-      CreateSyncError(syncer::SyncError::DATATYPE_ERROR), nullptr);
+  ExpectStartError(SyncError::DATATYPE_ERROR);
+  type_processor()->OnMetadataLoaded(CreateSyncError(SyncError::DATATYPE_ERROR),
+                                     nullptr);
 
   // Test an error loading pending data.
   ResetStateWriteItem(kKey1, kValue1);
-  SetServiceError(syncer::SyncError::DATATYPE_ERROR);
+  SetServiceError(SyncError::DATATYPE_ERROR);
   InitializeToMetadataLoaded();
   OnPendingCommitDataLoaded();
-  ExpectStartError(syncer::SyncError::DATATYPE_ERROR);
+  ExpectStartError(SyncError::DATATYPE_ERROR);
   OnSyncStarting();
 }
 
@@ -608,8 +606,8 @@ TEST_F(SharedModelTypeProcessorTest, LocalCreateItem) {
 TEST_F(SharedModelTypeProcessorTest, ErrorApplyingAck) {
   InitializeToReadyState();
   WriteItem(kKey1, kValue1);
-  SetServiceError(syncer::SyncError::DATATYPE_ERROR);
-  error_handler()->ExpectError(syncer::SyncError::DATATYPE_ERROR);
+  SetServiceError(SyncError::DATATYPE_ERROR);
+  error_handler()->ExpectError(SyncError::DATATYPE_ERROR);
   worker()->AckOnePendingCommit();
 }
 
@@ -773,8 +771,8 @@ TEST_F(SharedModelTypeProcessorTest, ServerCreateItem) {
 // propagated to the error handler.
 TEST_F(SharedModelTypeProcessorTest, ErrorApplyingUpdate) {
   InitializeToReadyState();
-  SetServiceError(syncer::SyncError::DATATYPE_ERROR);
-  error_handler()->ExpectError(syncer::SyncError::DATATYPE_ERROR);
+  SetServiceError(SyncError::DATATYPE_ERROR);
+  error_handler()->ExpectError(SyncError::DATATYPE_ERROR);
   worker()->UpdateFromServer(kHash1, GenerateSpecifics(kKey1, kValue1));
 }
 
@@ -1114,9 +1112,9 @@ TEST_F(SharedModelTypeProcessorTest, ReEncryptCommitsWithNewKey) {
 TEST_F(SharedModelTypeProcessorTest, ReEncryptErrorLoadingData) {
   InitializeToReadyState();
   WriteItemAndAck(kKey1, kValue1);
-  SetServiceError(syncer::SyncError::DATATYPE_ERROR);
+  SetServiceError(SyncError::DATATYPE_ERROR);
   worker()->UpdateWithEncryptionKey("k1");
-  error_handler()->ExpectError(syncer::SyncError::DATATYPE_ERROR);
+  error_handler()->ExpectError(SyncError::DATATYPE_ERROR);
   OnPendingCommitDataLoaded();
 }
 
@@ -1276,4 +1274,4 @@ TEST_F(SharedModelTypeProcessorTest, IgnoreRemoteEncryptionInterleaved) {
   worker()->ExpectNthPendingCommit(1, kHash1, specifics2);
 }
 
-}  // namespace syncer_v2
+}  // namespace syncer