Revert of [sync] Replace FakeServer's implementation with LoopbackServer invocations.

components/sync/engine_impl/loopback_server/loopback_server.cc

 // Copyright 2016 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/engine_impl/loopback_server/loopback_server.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <utility>
@@ skipping 116 matching lines @@
   const ModelTypeToVersionMap request_version_map_;
 
   // The largest versions seen between client and server, ultimately used to
   // send progress markers back to the client.
   ModelTypeToVersionMap response_version_map_;
 };
 
 }  // namespace
 
 LoopbackServer::LoopbackServer(const base::FilePath& persistent_file)
-    : version_(0),
-      store_birthday_(0),
-      persistent_file_(persistent_file),
-      observer_for_tests_(NULL) {
+    : version_(0), store_birthday_(0), persistent_file_(persistent_file) {
   Init();
 }
 
 LoopbackServer::~LoopbackServer() {}
 
 void LoopbackServer::Init() {
   if (LoadStateFromFile(persistent_file_))
     return;
 
   keystore_keys_.push_back(GenerateNewKeystoreKey());
 
   const bool create_result = CreateDefaultPermanentItems();
   DCHECK(create_result) << "Permanent items were not created successfully.";
 }
 
 std::string LoopbackServer::GenerateNewKeystoreKey() const {
   // TODO(pastarmovj): Check if true random bytes is ok or alpha-nums is needed?
   return base::RandBytesAsString(kKeystoreKeyLenght);
 }
 
 bool LoopbackServer::CreatePermanentBookmarkFolder(
     const std::string& server_tag,
     const std::string& name) {
   DCHECK(thread_checker_.CalledOnValidThread());
   std::unique_ptr<LoopbackServerEntity> entity =
-      PersistentPermanentEntity::CreateNew(
-          syncer::BOOKMARKS, server_tag, name,
-          ModelTypeToRootTag(syncer::BOOKMARKS));
+      PersistentPermanentEntity::Create(syncer::BOOKMARKS, server_tag, name,
+                                        ModelTypeToRootTag(syncer::BOOKMARKS));
   if (!entity)
     return false;
 
   SaveEntity(std::move(entity));
   return true;
 }
 
 bool LoopbackServer::CreateDefaultPermanentItems() {
   // Permanent folders are always required for Bookmarks (hierarchical
   // structure) and Nigori (data stored in permanent root folder).
@@ skipping 142 matching lines @@
     const sync_pb::SyncEntity& client_entity,
     sync_pb::CommitResponse_EntryResponse* entry_response,
     const string& client_guid,
     const string& parent_id) {
   if (client_entity.version() == 0 && client_entity.deleted()) {
     return string();
   }
 
   std::unique_ptr<LoopbackServerEntity> entity;
   if (client_entity.deleted()) {
-    entity = PersistentTombstoneEntity::CreateFromEntity(client_entity);
+    entity = PersistentTombstoneEntity::Create(client_entity);
     DeleteChildren(client_entity.id_string());
   } else if (GetModelType(client_entity) == syncer::NIGORI) {
     // NIGORI is the only permanent item type that should be updated by the
     // client.
     EntityMap::const_iterator iter = entities_.find(client_entity.id_string());
     CHECK(iter != entities_.end());
     entity = PersistentPermanentEntity::CreateUpdatedNigoriEntity(
         client_entity, *iter->second);
   } else if (client_entity.has_client_defined_unique_tag()) {
-    entity = PersistentUniqueClientEntity::CreateFromEntity(client_entity);
+    entity = PersistentUniqueClientEntity::Create(client_entity);
   } else {
     // TODO(pvalenzuela): Validate entity's parent ID.
     EntityMap::const_iterator iter = entities_.find(client_entity.id_string());
     if (iter != entities_.end()) {
       entity = PersistentBookmarkEntity::CreateUpdatedVersion(
           client_entity, *iter->second, parent_id);
     } else {
       entity = PersistentBookmarkEntity::CreateNew(client_entity, parent_id,
                                                    client_guid);
     }
@@ skipping 51 matching lines @@
   // Find all the children of id.
   for (auto& entity : entities_) {
     if (IsChild(entity.first, id)) {
       sync_pb::SyncEntity proto;
       entity.second->SerializeAsProto(&proto);
       tombstones.emplace_back(proto);
     }
   }
 
   for (auto& tombstone : tombstones) {
-    SaveEntity(PersistentTombstoneEntity::CreateFromEntity(tombstone));
+    SaveEntity(PersistentTombstoneEntity::Create(tombstone));
   }
 }
 
 bool LoopbackServer::HandleCommitRequest(
     const sync_pb::CommitMessage& commit,
     const std::string& invalidator_client_id,
     sync_pb::CommitResponse* response) {
   std::map<string, string> client_to_server_ids;
   string guid = commit.cache_guid();
   ModelTypeSet committed_model_types;
@@ skipping 19 matching lines @@
     // Record the ID if it was renamed.
     if (entity_id != client_entity.id_string()) {
       client_to_server_ids[client_entity.id_string()] = entity_id;
     }
 
     EntityMap::const_iterator iter = entities_.find(entity_id);
     CHECK(iter != entities_.end());
     committed_model_types.Put(iter->second->GetModelType());
   }
 
-  if (observer_for_tests_)
-    observer_for_tests_->OnCommit(invalidator_client_id, committed_model_types);
-
   return true;
 }
 
 void LoopbackServer::ClearServerData() {
   DCHECK(thread_checker_.CalledOnValidThread());
   entities_.clear();
   keystore_keys_.clear();
   ++store_birthday_;
-  base::DeleteFile(persistent_file_, false);
   Init();
 }
 
 std::string LoopbackServer::GetStoreBirthday() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return base::Int64ToString(store_birthday_);
 }
 
-std::vector<sync_pb::SyncEntity> LoopbackServer::GetSyncEntitiesByModelType(
-    ModelType model_type) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  std::vector<sync_pb::SyncEntity> sync_entities;
-  for (EntityMap::const_iterator it = entities_.begin(); it != entities_.end();
-       ++it) {
-    const LoopbackServerEntity& entity = *it->second;
-    if (!(entity.IsDeleted() || entity.IsPermanent()) &&
-        entity.GetModelType() == model_type) {
-      sync_pb::SyncEntity sync_entity;
-      entity.SerializeAsProto(&sync_entity);
-      sync_entities.push_back(sync_entity);
-    }
-  }
-  return sync_entities;
-}
-
-std::unique_ptr<base::DictionaryValue>
-LoopbackServer::GetEntitiesAsDictionaryValue() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  std::unique_ptr<base::DictionaryValue> dictionary(
-      new base::DictionaryValue());
-
-  // Initialize an empty ListValue for all ModelTypes.
-  ModelTypeSet all_types = ModelTypeSet::All();
-  for (ModelTypeSet::Iterator it = all_types.First(); it.Good(); it.Inc()) {
-    dictionary->Set(ModelTypeToString(it.Get()),
-                    base::MakeUnique<base::ListValue>());
-  }
-
-  for (EntityMap::const_iterator it = entities_.begin(); it != entities_.end();
-       ++it) {
-    const LoopbackServerEntity& entity = *it->second;
-    if (entity.IsDeleted() || entity.IsPermanent()) {
-      // Tombstones are ignored as they don't represent current data. Folders
-      // are also ignored as current verification infrastructure does not
-      // consider them.
-      continue;
-    }
-    base::ListValue* list_value;
-    if (!dictionary->GetList(ModelTypeToString(entity.GetModelType()),
-                             &list_value)) {
-      return std::unique_ptr<base::DictionaryValue>();
-    }
-    // TODO(pvalenzuela): Store more data for each entity so additional
-    // verification can be performed. One example of additional verification
-    // is checking the correctness of the bookmark hierarchy.
-    list_value->AppendString(entity.GetName());
-  }
-
-  return dictionary;
-}
-
-bool LoopbackServer::ModifyEntitySpecifics(
-    const std::string& id,
-    const sync_pb::EntitySpecifics& updated_specifics) {
-  EntityMap::const_iterator iter = entities_.find(id);
-  if (iter == entities_.end() ||
-      iter->second->GetModelType() !=
-          GetModelTypeFromSpecifics(updated_specifics)) {
-    return false;
-  }
-
-  LoopbackServerEntity* entity = iter->second.get();
-  entity->SetSpecifics(updated_specifics);
-  UpdateEntityVersion(entity);
-  return true;
-}
-
-bool LoopbackServer::ModifyBookmarkEntity(
-    const std::string& id,
-    const std::string& parent_id,
-    const sync_pb::EntitySpecifics& updated_specifics) {
-  EntityMap::const_iterator iter = entities_.find(id);
-  if (iter == entities_.end() ||
-      iter->second->GetModelType() != syncer::BOOKMARKS ||
-      GetModelTypeFromSpecifics(updated_specifics) != syncer::BOOKMARKS) {
-    return false;
-  }
-
-  PersistentBookmarkEntity* entity =
-      static_cast<PersistentBookmarkEntity*>(iter->second.get());
-
-  entity->SetParentId(parent_id);
-  entity->SetSpecifics(updated_specifics);
-  if (updated_specifics.has_bookmark()) {
-    entity->SetName(updated_specifics.bookmark().title());
-  }
-  UpdateEntityVersion(entity);
-  return true;
-}
-
 void LoopbackServer::SerializeState(sync_pb::LoopbackServerProto* proto) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   proto->set_version(kCurrentLoopbackServerProtoVersion);
   proto->set_store_birthday(store_birthday_);
   proto->set_last_version_assigned(version_);
   for (const auto& key : keystore_keys_)
     proto->add_keystore_keys(key);
   for (const auto& entity : entities_) {
     auto* new_entity = proto->mutable_entities()->Add();
@@ skipping 53 matching lines @@
       // write.
       LOG(ERROR) << "Loopback sync can not read the persistent state file.";
       return false;
     }
   }
   LOG(WARNING) << "Loopback sync persistent state file does not exist.";
   return false;
 }
 
 }  // namespace syncer