Revert of [Sync] Move //components/sync to the syncer namespace. (patchset #5 id:40001 of https://co

components/sync/api/fake_model_type_service.cc

 // Copyright 2015 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/api/fake_model_type_service.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "components/sync/core/data_batch_impl.h"
 #include "components/sync/core/simple_metadata_change_list.h"
 #include "components/sync/syncable/syncable_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using sync_pb::EntitySpecifics;
 using sync_pb::EntityMetadata;
 using sync_pb::DataTypeState;
 
-namespace syncer {
+namespace syncer_v2 {
 
 namespace {
 
 // It is intentionally very difficult to copy an EntityData, as in normal code
 // we never want to. However, since we store the data as an EntityData for the
 // test code here, this function is needed to manually copy it.
 std::unique_ptr<EntityData> CopyEntityData(const EntityData& old_data) {
   std::unique_ptr<EntityData> new_data(new EntityData());
   new_data->id = old_data.id;
   new_data->client_tag_hash = old_data.client_tag_hash;
   new_data->non_unique_name = old_data.non_unique_name;
   new_data->specifics = old_data.specifics;
   new_data->creation_time = old_data.creation_time;
   new_data->modification_time = old_data.modification_time;
   return new_data;
 }
 
 }  // namespace
 
 // static
 std::string FakeModelTypeService::ClientTagFromKey(const std::string& key) {
   return "ClientTag_" + key;
 }
 
 // static
 std::string FakeModelTypeService::TagHashFromKey(const std::string& key) {
-  return syncable::GenerateSyncableHash(
-      PREFERENCES, FakeModelTypeService::ClientTagFromKey(key));
+  return syncer::syncable::GenerateSyncableHash(
+      syncer::PREFERENCES, FakeModelTypeService::ClientTagFromKey(key));
 }
 
 // static
 EntitySpecifics FakeModelTypeService::GenerateSpecifics(
     const std::string& key,
     const std::string& value) {
   EntitySpecifics specifics;
   specifics.mutable_preference()->set_name(key);
   specifics.mutable_preference()->set_value(value);
   return specifics;
@@ skipping 71 matching lines @@
 void FakeModelTypeService::Store::Reset() {
   data_change_count_ = 0;
   metadata_change_count_ = 0;
   data_store_.clear();
   metadata_store_.clear();
   data_type_state_.Clear();
 }
 
 FakeModelTypeService::FakeModelTypeService(
     const ChangeProcessorFactory& change_processor_factory)
-    : ModelTypeService(change_processor_factory, PREFERENCES) {}
+    : ModelTypeService(change_processor_factory, syncer::PREFERENCES) {}
 
 FakeModelTypeService::~FakeModelTypeService() {
   CheckPostConditions();
 }
 
 EntitySpecifics FakeModelTypeService::WriteItem(const std::string& key,
                                                 const std::string& value) {
   std::unique_ptr<EntityData> entity_data = GenerateEntityData(key, value);
   EntitySpecifics specifics_copy = entity_data->specifics;
   WriteItem(key, std::move(entity_data));
@@ skipping 20 matching lines @@
     change_processor()->Delete(key, change_list.get());
     ApplyMetadataChangeList(std::move(change_list));
   }
 }
 
 std::unique_ptr<MetadataChangeList>
 FakeModelTypeService::CreateMetadataChangeList() {
   return std::unique_ptr<MetadataChangeList>(new SimpleMetadataChangeList());
 }
 
-SyncError FakeModelTypeService::MergeSyncData(
+syncer::SyncError FakeModelTypeService::MergeSyncData(
     std::unique_ptr<MetadataChangeList> metadata_changes,
     EntityDataMap data_map) {
   if (service_error_.IsSet()) {
-    SyncError error = service_error_;
-    service_error_ = SyncError();
+    syncer::SyncError error = service_error_;
+    service_error_ = syncer::SyncError();
     return error;
   }
   // Commit any local entities that aren't being overwritten by the server.
   for (const auto& kv : db_.all_data()) {
     if (data_map.find(kv.first) == data_map.end()) {
       change_processor()->Put(kv.first, CopyEntityData(*kv.second),
                               metadata_changes.get());
     }
   }
   // Store any new remote entities.
   for (const auto& kv : data_map) {
     db_.PutData(kv.first, kv.second.value());
   }
   ApplyMetadataChangeList(std::move(metadata_changes));
-  return SyncError();
+  return syncer::SyncError();
 }
 
-SyncError FakeModelTypeService::ApplySyncChanges(
+syncer::SyncError FakeModelTypeService::ApplySyncChanges(
     std::unique_ptr<MetadataChangeList> metadata_changes,
     EntityChangeList entity_changes) {
   if (service_error_.IsSet()) {
-    SyncError error = service_error_;
-    service_error_ = SyncError();
+    syncer::SyncError error = service_error_;
+    service_error_ = syncer::SyncError();
     return error;
   }
   for (const EntityChange& change : entity_changes) {
     switch (change.type()) {
       case EntityChange::ACTION_ADD:
         EXPECT_FALSE(db_.HasData(change.storage_key()));
         db_.PutData(change.storage_key(), change.data());
         break;
       case EntityChange::ACTION_UPDATE:
         EXPECT_TRUE(db_.HasData(change.storage_key()));
         db_.PutData(change.storage_key(), change.data());
         break;
       case EntityChange::ACTION_DELETE:
         EXPECT_TRUE(db_.HasData(change.storage_key()));
         db_.RemoveData(change.storage_key());
         break;
     }
   }
   ApplyMetadataChangeList(std::move(metadata_changes));
-  return SyncError();
+  return syncer::SyncError();
 }
 
 void FakeModelTypeService::ApplyMetadataChangeList(
     std::unique_ptr<MetadataChangeList> change_list) {
   DCHECK(change_list);
   SimpleMetadataChangeList* changes =
       static_cast<SimpleMetadataChangeList*>(change_list.get());
   const auto& metadata_changes = changes->GetMetadataChanges();
   for (const auto& kv : metadata_changes) {
     switch (kv.second.type) {
@@ skipping 16 matching lines @@
       case SimpleMetadataChangeList::CLEAR:
         db_.set_data_type_state(DataTypeState());
         break;
     }
   }
 }
 
 void FakeModelTypeService::GetData(StorageKeyList keys, DataCallback callback) {
   if (service_error_.IsSet()) {
     callback.Run(service_error_, nullptr);
-    service_error_ = SyncError();
+    service_error_ = syncer::SyncError();
     return;
   }
   std::unique_ptr<DataBatchImpl> batch(new DataBatchImpl());
   for (const std::string& key : keys) {
     DCHECK(db_.HasData(key)) << "No data for " << key;
     batch->Put(key, CopyEntityData(db_.GetData(key)));
   }
-  callback.Run(SyncError(), std::move(batch));
+  callback.Run(syncer::SyncError(), std::move(batch));
 }
 
 void FakeModelTypeService::GetAllData(DataCallback callback) {
   if (service_error_.IsSet()) {
     callback.Run(service_error_, nullptr);
-    service_error_ = SyncError();
+    service_error_ = syncer::SyncError();
     return;
   }
   std::unique_ptr<DataBatchImpl> batch(new DataBatchImpl());
   for (const auto& kv : db_.all_data()) {
     batch->Put(kv.first, CopyEntityData(*kv.second));
   }
-  callback.Run(SyncError(), std::move(batch));
+  callback.Run(syncer::SyncError(), std::move(batch));
 }
 
 std::string FakeModelTypeService::GetClientTag(const EntityData& entity_data) {
   return ClientTagFromKey(entity_data.specifics.preference().name());
 }
 
 std::string FakeModelTypeService::GetStorageKey(const EntityData& entity_data) {
   return entity_data.specifics.preference().name();
 }
 
 void FakeModelTypeService::OnChangeProcessorSet() {}
 
-void FakeModelTypeService::SetServiceError(SyncError::ErrorType error_type) {
+void FakeModelTypeService::SetServiceError(
+    syncer::SyncError::ErrorType error_type) {
   DCHECK(!service_error_.IsSet());
-  service_error_ = SyncError(FROM_HERE, error_type, "TestError", PREFERENCES);
+  service_error_ = syncer::SyncError(FROM_HERE, error_type, "TestError",
+                                     syncer::PREFERENCES);
 }
 
 ConflictResolution FakeModelTypeService::ResolveConflict(
     const EntityData& local_data,
     const EntityData& remote_data) const {
   DCHECK(conflict_resolution_);
   return std::move(*conflict_resolution_);
 }
 
 void FakeModelTypeService::SetConflictResolution(
     ConflictResolution resolution) {
   conflict_resolution_.reset(new ConflictResolution(std::move(resolution)));
 }
 
 void FakeModelTypeService::CheckPostConditions() {
   DCHECK(!service_error_.IsSet());
 }
 
-}  // namespace syncer
+}  // namespace syncer_v2