WIP: The Bookmark Position Megapatch

sync/syncable/entry_kernel.h

 // 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.
 
 #ifndef SYNC_SYNCABLE_ENTRY_KERNEL_H_
 #define SYNC_SYNCABLE_ENTRY_KERNEL_H_
 
 #include "base/time.h"
 #include "base/values.h"
 #include "sync/internal_api/public/base/model_type.h"
-#include "sync/internal_api/public/base/node_ordinal.h"
+#include "sync/internal_api/public/base/unique_position.h"
 #include "sync/internal_api/public/util/immutable.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/syncable/metahandle_set.h"
 #include "sync/syncable/syncable_id.h"
 #include "sync/util/time.h"
 
 namespace syncer {
 
 class Cryptographer;
 
@@ skipping 51 matching lines @@
 enum {
   TIME_FIELDS_COUNT = TIME_FIELDS_END - TIME_FIELDS_BEGIN,
   ID_FIELDS_BEGIN = TIME_FIELDS_END,
 };
 
 enum IdField {
   // Code in InitializeTables relies on ID being the first IdField value.
   ID = ID_FIELDS_BEGIN,
   PARENT_ID,
   SERVER_PARENT_ID,
-
-  PREV_ID,
-  NEXT_ID,
   ID_FIELDS_END
 };
 
 enum {
   ID_FIELDS_COUNT = ID_FIELDS_END - ID_FIELDS_BEGIN,
   BIT_FIELDS_BEGIN = ID_FIELDS_END
 };
 
 enum IndexedBitField {
   IS_UNSYNCED = BIT_FIELDS_BEGIN,
@@ skipping 40 matching lines @@
 // seems the overhead for storing a NULL blob is very small.
 enum ProtoField {
   SPECIFICS = PROTO_FIELDS_BEGIN,
   SERVER_SPECIFICS,
   BASE_SERVER_SPECIFICS,
   PROTO_FIELDS_END,
 };
 
 enum {
   PROTO_FIELDS_COUNT = PROTO_FIELDS_END - PROTO_FIELDS_BEGIN,
-  ORDINAL_FIELDS_BEGIN = PROTO_FIELDS_END
+  UNIQUE_POSITION_FIELDS_BEGIN = PROTO_FIELDS_END
 };
 
-enum OrdinalField {
-  // An Ordinal that identifies the relative ordering of this object
-  // among its siblings.
-  SERVER_ORDINAL_IN_PARENT = ORDINAL_FIELDS_BEGIN,
-  ORDINAL_FIELDS_END
+enum UniquePositionField {
+  SERVER_UNIQUE_POSITION = UNIQUE_POSITION_FIELDS_BEGIN,
+  UNIQUE_POSITION,
+  UNIQUE_POSITION_FIELDS_END
 };
 
 enum {
-  ORDINAL_FIELDS_COUNT = ORDINAL_FIELDS_END - ORDINAL_FIELDS_BEGIN,
-  FIELD_COUNT = ORDINAL_FIELDS_END - BEGIN_FIELDS,
+  UNIQUE_POSITION_FIELDS_COUNT =
+      UNIQUE_POSITION_FIELDS_END - UNIQUE_POSITION_FIELDS_BEGIN,
+  BYTES_FIELDS_BEGIN = UNIQUE_POSITION_FIELDS_END
+};
+
+enum BytesField {
+  // A unique tag for bookmarks.
+  UNIQUE_BOOKMARK_TAG = BYTES_FIELDS_BEGIN,
+  BYTES_FIELDS_END
+};
+
+enum {
+  BYTES_FIELDS_COUNT = BYTES_FIELDS_END - BYTES_FIELDS_BEGIN,
+  FIELD_COUNT = BYTES_FIELDS_END - BEGIN_FIELDS,
   // Past this point we have temporaries, stored in memory only.
-  BEGIN_TEMPS = ORDINAL_FIELDS_END,
+  BEGIN_TEMPS = BYTES_FIELDS_END,
   BIT_TEMPS_BEGIN = BEGIN_TEMPS,
 };
 
 enum BitTemp {
   // Not to be confused with IS_UNSYNCED, this bit is used to detect local
   // changes to items that happen during the server Commit operation.
   SYNCING = BIT_TEMPS_BEGIN,
   BIT_TEMPS_END,
 };
 
 enum {
   BIT_TEMPS_COUNT = BIT_TEMPS_END - BIT_TEMPS_BEGIN
 };
 
 
 
 struct EntryKernel {
  private:
   std::string string_fields[STRING_FIELDS_COUNT];
   sync_pb::EntitySpecifics specifics_fields[PROTO_FIELDS_COUNT];
   int64 int64_fields[INT64_FIELDS_COUNT];
   base::Time time_fields[TIME_FIELDS_COUNT];
   Id id_fields[ID_FIELDS_COUNT];
-  NodeOrdinal ordinal_fields[ORDINAL_FIELDS_COUNT];
+  std::string bytes_fields[BYTES_FIELDS_COUNT];
+  UniquePosition unique_position_fields[UNIQUE_POSITION_FIELDS_COUNT];
   std::bitset<BIT_FIELDS_COUNT> bit_fields;
   std::bitset<BIT_TEMPS_COUNT> bit_temps;
 
  public:
   EntryKernel();
   ~EntryKernel();
 
   // Set the dirty bit, and optionally add this entry's metahandle to
   // a provided index on dirty bits in |dirty_index|. Parameter may be null,
   // and will result only in setting the dirty bit of this entry.
@@ skipping 47 matching lines @@
   }
   inline void put(BitField field, bool value) {
     bit_fields[field - BIT_FIELDS_BEGIN] = value;
   }
   inline void put(StringField field, const std::string& value) {
     string_fields[field - STRING_FIELDS_BEGIN] = value;
   }
   inline void put(ProtoField field, const sync_pb::EntitySpecifics& value) {
     specifics_fields[field - PROTO_FIELDS_BEGIN].CopyFrom(value);
   }
-  inline void put(OrdinalField field, const NodeOrdinal& value) {
-    ordinal_fields[field - ORDINAL_FIELDS_BEGIN] = value;
+  inline void put(UniquePositionField field, const UniquePosition& value) {
+    unique_position_fields[field - UNIQUE_POSITION_FIELDS_BEGIN] = value;
+  }
+  inline void put(BytesField field, const std::string& value) {
+    bytes_fields[field - BYTES_FIELDS_BEGIN] = value;
   }
   inline void put(BitTemp field, bool value) {
     bit_temps[field - BIT_TEMPS_BEGIN] = value;
   }
 
   // Const ref getters.
   inline int64 ref(MetahandleField field) const {
     return int64_fields[field - INT64_FIELDS_BEGIN];
   }
   inline int64 ref(Int64Field field) const {
@@ skipping 16 matching lines @@
   }
   inline bool ref(BitField field) const {
     return bit_fields[field - BIT_FIELDS_BEGIN];
   }
   inline const std::string& ref(StringField field) const {
     return string_fields[field - STRING_FIELDS_BEGIN];
   }
   inline const sync_pb::EntitySpecifics& ref(ProtoField field) const {
     return specifics_fields[field - PROTO_FIELDS_BEGIN];
   }
-  inline const NodeOrdinal& ref(OrdinalField field) const {
-    return ordinal_fields[field - ORDINAL_FIELDS_BEGIN];
+  inline const UniquePosition& ref(UniquePositionField field) const {
+    return unique_position_fields[field - UNIQUE_POSITION_FIELDS_BEGIN];
+  }
+  inline const std::string& ref(BytesField field) const {
+    return bytes_fields[field - BYTES_FIELDS_BEGIN];
   }
   inline bool ref(BitTemp field) const {
     return bit_temps[field - BIT_TEMPS_BEGIN];
   }
 
   // Non-const, mutable ref getters for object types only.
   inline std::string& mutable_ref(StringField field) {
     return string_fields[field - STRING_FIELDS_BEGIN];
   }
   inline sync_pb::EntitySpecifics& mutable_ref(ProtoField field) {
     return specifics_fields[field - PROTO_FIELDS_BEGIN];
   }
   inline Id& mutable_ref(IdField field) {
     return id_fields[field - ID_FIELDS_BEGIN];
   }
-  inline NodeOrdinal& mutable_ref(OrdinalField field) {
-    return ordinal_fields[field - ORDINAL_FIELDS_BEGIN];
+  inline UniquePosition& mutable_ref(UniquePositionField field) {
+    return unique_position_fields[field - UNIQUE_POSITION_FIELDS_BEGIN];
   }
 
+  ModelType GetModelType() const;
   ModelType GetServerModelType() const;
 
   // Dumps all kernel info into a DictionaryValue and returns it.
   // Transfers ownership of the DictionaryValue to the caller.
   // Note: |cryptographer| is an optional parameter for use in decrypting
   // encrypted specifics. If it is NULL or the specifics are not decryptsble,
   // they will be serialized as empty proto's.
   base::DictionaryValue* ToValue(Cryptographer* cryptographer) const;
 
  private:
@@ skipping 14 matching lines @@
     const EntryKernelMutation& mutation);
 
 // Caller owns the return value.
 base::ListValue* EntryKernelMutationMapToValue(
     const EntryKernelMutationMap& mutations);
 
 }  // namespace syncable
 }  // namespace syncer
 
 #endif // SYNC_SYNCABLE_ENTRY_KERNEL_H_