WIP: The Bookmark Position Megapatch

sync/syncable/entry_kernel.cc

 // Copyright (c) 2012 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 "sync/syncable/entry_kernel.h"
 
 #include "base/string_number_conversions.h"
 #include "sync/protocol/proto_value_conversions.h"
 #include "sync/syncable/syncable_enum_conversions.h"
 #include "sync/util/cryptographer.h"
 
 namespace syncer {
 namespace syncable {
 
 EntryKernel::EntryKernel() : dirty_(false) {
   // Everything else should already be default-initialized.
   for (int i = INT64_FIELDS_BEGIN; i < INT64_FIELDS_END; ++i) {
     int64_fields[i] = 0;
   }
 }
 
 EntryKernel::~EntryKernel() {}
 
+ModelType EntryKernel::GetModelType() const {
+  ModelType specifics_type = GetModelTypeFromSpecifics(ref(SPECIFICS));
+  if (specifics_type != UNSPECIFIED)
+    return specifics_type;
+  if (ref(ID).IsRoot())
+    return TOP_LEVEL_FOLDER;
+  // Loose check for server-created top-level folders that aren't
+  // bound to a particular model type.
+  if (!ref(UNIQUE_SERVER_TAG).empty() && ref(SERVER_IS_DIR))
+    return TOP_LEVEL_FOLDER;
+
+  return UNSPECIFIED;
+}
+
 ModelType EntryKernel::GetServerModelType() const {
   ModelType specifics_type = GetModelTypeFromSpecifics(ref(SERVER_SPECIFICS));
   if (specifics_type != UNSPECIFIED)
     return specifics_type;
   if (ref(ID).IsRoot())
     return TOP_LEVEL_FOLDER;
   // Loose check for server-created top-level folders that aren't
   // bound to a particular model type.
   if (!ref(UNIQUE_SERVER_TAG).empty() && ref(SERVER_IS_DIR))
     return TOP_LEVEL_FOLDER;
@@ skipping 55 matching lines @@
 }
 
 StringValue* TimeToValue(const base::Time& t) {
   return Value::CreateStringValue(GetTimeDebugString(t));
 }
 
 StringValue* IdToValue(const Id& id) {
   return id.ToValue();
 }
 
-StringValue* OrdinalToValue(const NodeOrdinal& ord) {
-  return Value::CreateStringValue(ord.ToDebugString());
+StringValue* UniquePositionToValue(const UniquePosition& pos) {
+  return Value::CreateStringValue(pos.ToDebugString());
+}
+
+StringValue* BytesToValue(const std::string& bytes) {
+  return Value::CreateStringValue(
+      base::HexEncode(bytes.data(), bytes.length()));
 }
 
 }  // namespace
 
 DictionaryValue* EntryKernel::ToValue(Cryptographer* cryptographer) const {
   DictionaryValue* kernel_info = new DictionaryValue();
   kernel_info->SetBoolean("isDirty", is_dirty());
   kernel_info->Set("serverModelType", ModelTypeToValue(GetServerModelType()));
 
   // Int64 fields.
@@ skipping 35 matching lines @@
         &Value::CreateStringValue;
     SetFieldValues(*this, kernel_info,
                    &GetStringFieldString, string_to_value,
                    STRING_FIELDS_BEGIN, STRING_FIELDS_END - 1);
   }
 
   // Proto fields.
   SetEncryptableProtoValues(*this, cryptographer, kernel_info,
                             PROTO_FIELDS_BEGIN, PROTO_FIELDS_END - 1);
 
-  // Ordinal fields
+  // UniquePosition fields
   SetFieldValues(*this, kernel_info,
-                 &GetOrdinalFieldString, &OrdinalToValue,
-                 ORDINAL_FIELDS_BEGIN, ORDINAL_FIELDS_END - 1);
+                 &GetUniquePositionFieldString, &UniquePositionToValue,
+                 UNIQUE_POSITION_FIELDS_BEGIN, UNIQUE_POSITION_FIELDS_END - 1);
+
+  // Bytes fields
+  SetFieldValues(*this, kernel_info,
+                 &GetBytesFieldString, &BytesToValue,
+                 BYTES_FIELDS_BEGIN, BYTES_FIELDS_END - 1);
 
   // Bit temps.
   SetFieldValues(*this, kernel_info,
                  &GetBitTempString, &Value::CreateBooleanValue,
                  BIT_TEMPS_BEGIN, BIT_TEMPS_END - 1);
 
   return kernel_info;
 }
 
 ListValue* EntryKernelMutationMapToValue(
     const EntryKernelMutationMap& mutations) {
   ListValue* list = new ListValue();
   for (EntryKernelMutationMap::const_iterator it = mutations.begin();
        it != mutations.end(); ++it) {
     list->Append(EntryKernelMutationToValue(it->second));
   }
   return list;
 }
 
 DictionaryValue* EntryKernelMutationToValue(
     const EntryKernelMutation& mutation) {
   DictionaryValue* dict = new DictionaryValue();
   dict->Set("original", mutation.original.ToValue(NULL));
   dict->Set("mutated", mutation.mutated.ToValue(NULL));
   return dict;
 }
 
 }  // namespace syncer
 }  // namespace syncable