Add AttachmentMetadata to Sync's EntryKernel.

sync/syncable/entry_kernel.h

 // Copyright 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 <set>
 
 #include "base/time/time.h"
@@ skipping 13 matching lines @@
 
 namespace syncable {
 
 // Things you need to update if you change any of the fields below:
 //  - EntryKernel struct in this file
 //  - syncable_columns.h
 //  - syncable_enum_conversions{.h,.cc,_unittest.cc}
 //  - EntryKernel::EntryKernel(), EntryKernel::ToValue() in entry_kernel.cc
 //  - operator<< in Entry.cc
 //  - BindFields() and UnpackEntry() in directory_backing_store.cc
+//  - kCurrentDBVersion, DirectoryBackingStore::InitializeTables in
+//    directory_backing_store.cc
 //  - TestSimpleFieldsPreservedDuringSaveChanges in syncable_unittest.cc
 
 static const int64 kInvalidMetaHandle = 0;
 
 enum {
   BEGIN_FIELDS = 0,
   INT64_FIELDS_BEGIN = BEGIN_FIELDS
 };
 
 enum MetahandleField {
@@ skipping 105 matching lines @@
 
 enum UniquePositionField {
   SERVER_UNIQUE_POSITION = UNIQUE_POSITION_FIELDS_BEGIN,
   UNIQUE_POSITION,
   UNIQUE_POSITION_FIELDS_END
 };
 
 enum {
   UNIQUE_POSITION_FIELDS_COUNT =
       UNIQUE_POSITION_FIELDS_END - UNIQUE_POSITION_FIELDS_BEGIN,
-  FIELD_COUNT = UNIQUE_POSITION_FIELDS_END - BEGIN_FIELDS,
+  ATTACHMENT_METADATA_FIELDS_BEGIN = UNIQUE_POSITION_FIELDS_END
+};
+
+enum AttachmentMetadataField {
+  ATTACHMENT_METADATA = ATTACHMENT_METADATA_FIELDS_BEGIN,
+  ATTACHMENT_METADATA_FIELDS_END
+};
+
+enum {
+  ATTACHMENT_METADATA_FIELDS_COUNT =
+      ATTACHMENT_METADATA_FIELDS_END - ATTACHMENT_METADATA_FIELDS_BEGIN,
+  FIELD_COUNT = ATTACHMENT_METADATA_FIELDS_END - BEGIN_FIELDS,
   // Past this point we have temporaries, stored in memory only.
-  BEGIN_TEMPS = UNIQUE_POSITION_FIELDS_END,
+  BEGIN_TEMPS = ATTACHMENT_METADATA_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 SYNC_EXPORT_PRIVATE 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];
   UniquePosition unique_position_fields[UNIQUE_POSITION_FIELDS_COUNT];
+  sync_pb::AttachmentMetadata
+      attachment_metadata_fields[ATTACHMENT_METADATA_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 50 matching lines @@
   }
   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(UniquePositionField field, const UniquePosition& value) {
     unique_position_fields[field - UNIQUE_POSITION_FIELDS_BEGIN] = value;
   }
+  inline void put(AttachmentMetadataField field,
+                  const sync_pb::AttachmentMetadata& value) {
+    attachment_metadata_fields[field - ATTACHMENT_METADATA_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 {
     return int64_fields[field - INT64_FIELDS_BEGIN];
@@ skipping 18 matching lines @@
   }
   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 UniquePosition& ref(UniquePositionField field) const {
     return unique_position_fields[field - UNIQUE_POSITION_FIELDS_BEGIN];
   }
+  inline const sync_pb::AttachmentMetadata& ref(
+      AttachmentMetadataField field) const {
+    return attachment_metadata_fields[field - ATTACHMENT_METADATA_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];
@@ skipping 45 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_