[Sync] Implements the loopback sync server.

components/sync/engine_impl/loopback_server/loopback_server_entity.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/engine_impl/loopback_server/loopback_server_entity.h"
+
+#include <stdint.h>
+
+#include <limits>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "base/guid.h"
+#include "base/logging.h"
+#include "base/memory/ptr_util.h"
+#include "base/memory/ref_counted.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
+#include "components/sync/base/model_type.h"
+#include "components/sync/engine_impl/loopback_server/persistent_bookmark_entity.h"
+#include "components/sync/engine_impl/loopback_server/persistent_permanent_entity.h"
+#include "components/sync/engine_impl/loopback_server/persistent_tombstone_entity.h"
+#include "components/sync/engine_impl/loopback_server/persistent_unique_client_entity.h"
+#include "components/sync/protocol/sync.pb.h"
+#include "net/base/net_errors.h"
+#include "net/http/http_status_code.h"
+
+using std::string;
+using std::vector;
+
+using syncer::ModelType;
+
+namespace {
+// The separator used when formatting IDs.
+//
+// We chose the underscore character because it doesn't conflict with the
+// special characters used by base/base64.h's encoding, which is also used in
+// the construction of some IDs.
+const char kIdSeparator[] = "_";
+}  // namespace
+
+namespace syncer {
+
+LoopbackServerEntity::~LoopbackServerEntity() {}
+
+// static
+std::unique_ptr<LoopbackServerEntity>
+LoopbackServerEntity::CreateEntityFromProto(
+    const sync_pb::LoopbackServerEntity& entity) {
+  switch (entity.type()) {
+    case sync_pb::LoopbackServerEntity_Type_TOMBSTONE:
+      return PersistentTombstoneEntity::Create(entity.entity());
+    case sync_pb::LoopbackServerEntity_Type_PERMANENT:
+      return base::MakeUnique<PersistentPermanentEntity>(
+          entity.entity().id_string(), entity.entity().version(),
+          syncer::GetModelType(entity.entity()), entity.entity().name(),
+          entity.entity().parent_id_string(),
+          entity.entity().server_defined_unique_tag(),
+          entity.entity().specifics());
+    case sync_pb::LoopbackServerEntity_Type_BOOKMARK:
+      return PersistentBookmarkEntity::CreateFromEntity(entity.entity());
+    case sync_pb::LoopbackServerEntity_Type_UNIQUE:
+      return PersistentUniqueClientEntity::Create(entity.entity());
+    default:

[pavely, 2016/10/19 18:21:29]

You can handle UNKNOWN case with CHECK(false) and omit "default:" completely.
This way when you forget to handle new enum value here compiler will complain
about it.

+      CHECK(false) << "Unknown type encountered";
+      return std::unique_ptr<LoopbackServerEntity>(nullptr);
+  }
+}
+
+const std::string& LoopbackServerEntity::GetId() const {
+  return id_;
+}
+
+ModelType LoopbackServerEntity::GetModelType() const {
+  return model_type_;
+}
+
+int64_t LoopbackServerEntity::GetVersion() const {
+  return version_;
+}
+
+void LoopbackServerEntity::SetVersion(int64_t version) {
+  version_ = version;
+}
+
+const std::string& LoopbackServerEntity::GetName() const {
+  return name_;
+}
+
+void LoopbackServerEntity::SetName(const std::string& name) {
+  name_ = name;
+}
+
+void LoopbackServerEntity::SetSpecifics(
+    const sync_pb::EntitySpecifics& updated_specifics) {
+  specifics_ = updated_specifics;
+}
+
+sync_pb::EntitySpecifics LoopbackServerEntity::GetSpecifics() const {
+  return specifics_;
+}
+
+bool LoopbackServerEntity::IsDeleted() const {
+  return false;
+}
+
+bool LoopbackServerEntity::IsFolder() const {
+  return false;
+}
+
+bool LoopbackServerEntity::IsPermanent() const {
+  return false;
+}
+
+sync_pb::LoopbackServerEntity_Type
+LoopbackServerEntity::GetLoopbackServerEntityType() const {
+  NOTREACHED();
+  return sync_pb::LoopbackServerEntity_Type_UNKNOWN;
+}
+
+// static
+string LoopbackServerEntity::CreateId(const ModelType& model_type,
+                                      const string& inner_id) {
+  int field_number = GetSpecificsFieldNumberFromModelType(model_type);
+  return base::StringPrintf("%d%s%s", field_number, kIdSeparator,
+                            inner_id.c_str());
+}
+
+// static
+std::string LoopbackServerEntity::GetTopLevelId(const ModelType& model_type) {
+  return LoopbackServerEntity::CreateId(model_type,
+                                        syncer::ModelTypeToRootTag(model_type));
+}
+
+// static
+ModelType LoopbackServerEntity::GetModelTypeFromId(const string& id) {
+  vector<base::StringPiece> tokens = base::SplitStringPiece(
+      id, kIdSeparator, base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
+
+  int field_number;
+  if (tokens.size() != 2 || !base::StringToInt(tokens[0], &field_number)) {
+    return syncer::UNSPECIFIED;
+  }
+
+  return syncer::GetModelTypeFromSpecificsFieldNumber(field_number);
+}
+
+LoopbackServerEntity::LoopbackServerEntity(const string& id,
+                                           const ModelType& model_type,
+                                           int64_t version,
+                                           const string& name)
+    : id_(id), model_type_(model_type), version_(version), name_(name) {}
+
+void LoopbackServerEntity::SerializeBaseProtoFields(
+    sync_pb::SyncEntity* sync_entity) const {
+  sync_pb::EntitySpecifics* specifics = sync_entity->mutable_specifics();
+  specifics->CopyFrom(specifics_);
+
+  // LoopbackServerEntity fields
+  sync_entity->set_id_string(id_);
+  sync_entity->set_version(version_);
+  sync_entity->set_name(name_);
+
+  // Data via accessors
+  sync_entity->set_deleted(IsDeleted());
+  sync_entity->set_folder(IsFolder());
+
+  if (RequiresParentId())
+    sync_entity->set_parent_id_string(GetParentId());
+}
+
+void LoopbackServerEntity::SerializeAsLoopbackServerEntity(
+    sync_pb::LoopbackServerEntity* entity) const {
+  entity->set_type(GetLoopbackServerEntityType());
+  entity->set_model_type(static_cast<int64_t>(GetModelType()));
+  SerializeAsProto(entity->mutable_entity());
+}
+
+}  // namespace syncer