[Sync] use base::Time in sync

chrome/browser/sync/syncable/syncable.h

 // Copyright (c) 2011 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 CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_
 #define CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_
 #pragma once
 
 #include <algorithm>
 #include <bitset>
@@ skipping 16 matching lines @@
 #include "base/synchronization/lock.h"
 #include "base/time.h"
 #include "chrome/browser/sync/protocol/sync.pb.h"
 #include "chrome/browser/sync/syncable/blob.h"
 #include "chrome/browser/sync/syncable/dir_open_result.h"
 #include "chrome/browser/sync/syncable/directory_event.h"
 #include "chrome/browser/sync/syncable/syncable_id.h"
 #include "chrome/browser/sync/syncable/model_type.h"
 #include "chrome/browser/sync/util/dbgq.h"
 #include "chrome/browser/sync/util/immutable.h"
+#include "chrome/browser/sync/util/time.h"
 
 struct PurgeInfo;
 
 namespace base {
 class DictionaryValue;
 class ListValue;
 }
 
 namespace sync_api {
 class ReadTransaction;
 class WriteNode;
 class ReadNode;
 }  // sync_api
 
 namespace syncable {
 class DirectoryChangeDelegate;
 class TransactionObserver;
 class Entry;
 
 std::ostream& operator<<(std::ostream& s, const Entry& e);
 
 class DirectoryBackingStore;
 
 static const int64 kInvalidMetaHandle = 0;
 
-// Update syncable_enum_conversions{.h,.cc,_unittest.cc} if you change
-// any fields in this file.
+// Things you need to update if you change any of the fields below:
+//  - EntryKernel struct in syncable.h (this file)
+//  - syncable_columns.h
+//  - syncable_enum_conversions{.h,.cc,_unittest.cc}
+//  - EntryKernel::EntryKernel(), EntryKernel::ToValue(), operator<<
+//    for Entry in syncable.cc
+//  - BindFields() and UnpackEntry() in directory_backing_store.cc
+//  - TestSimpleFieldsPreservedDuringSaveChanges in syncable_unittest.cc
 
 enum {
   BEGIN_FIELDS = 0,
   INT64_FIELDS_BEGIN = BEGIN_FIELDS
 };
 
 enum MetahandleField {
   // Primary key into the table.  Keep this as a handle to the meta entry
   // across transactions.
   META_HANDLE = INT64_FIELDS_BEGIN
 };
 
 enum BaseVersion {
   // After initial upload, the version is controlled by the server, and is
   // increased whenever the data or metadata changes on the server.
   BASE_VERSION = META_HANDLE + 1,
 };
 
 enum Int64Field {
   SERVER_VERSION = BASE_VERSION + 1,
-  MTIME,
-  SERVER_MTIME,
-  CTIME,
-  SERVER_CTIME,
 
   // A numeric position value that indicates the relative ordering of
   // this object among its siblings.
   SERVER_POSITION_IN_PARENT,
 
   LOCAL_EXTERNAL_ID,  // ID of an item in the external local storage that this
                       // entry is associated with. (such as bookmarks.js)
 
   INT64_FIELDS_END
 };
 
 enum {
-  INT64_FIELDS_COUNT = INT64_FIELDS_END,
-  ID_FIELDS_BEGIN = INT64_FIELDS_END,
+  INT64_FIELDS_COUNT = INT64_FIELDS_END - INT64_FIELDS_BEGIN,
+  TIME_FIELDS_BEGIN = INT64_FIELDS_END,
+};
+
+enum TimeField {
+  MTIME = TIME_FIELDS_BEGIN,
+  SERVER_MTIME,
+  CTIME,
+  SERVER_CTIME,
+  TIME_FIELDS_END,
+};
+
+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,
@@ skipping 118 matching lines @@
 
 // Why the singular enums?  So the code compile-time dispatches instead of
 // runtime dispatches as it would with a single enum and an if() statement.
 
 // The EntryKernel class contains the actual data for an entry.
 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];
   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,
@@ skipping 21 matching lines @@
     return dirty_;
   }
 
   // Setters.
   inline void put(MetahandleField field, int64 value) {
     int64_fields[field - INT64_FIELDS_BEGIN] = value;
   }
   inline void put(Int64Field field, int64 value) {
     int64_fields[field - INT64_FIELDS_BEGIN] = value;
   }
+  inline void put(TimeField field, const base::Time& value) {
+    // Round-trip to proto time format and back so that we have
+    // consistent time resolutions (ms).
+    time_fields[field - TIME_FIELDS_BEGIN] =
+        browser_sync::ProtoTimeToTime(
+            browser_sync::TimeToProtoTime(value));
+  }
   inline void put(IdField field, const Id& value) {
     id_fields[field - ID_FIELDS_BEGIN] = value;
   }
   inline void put(BaseVersion field, int64 value) {
     int64_fields[field - INT64_FIELDS_BEGIN] = value;
   }
   inline void put(IndexedBitField field, bool value) {
     bit_fields[field - BIT_FIELDS_BEGIN] = value;
   }
   inline void put(IsDelField field, bool value) {
@@ skipping 12 matching lines @@
     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];
   }
+  inline const base::Time& ref(TimeField field) const {
+    return time_fields[field - TIME_FIELDS_BEGIN];
+  }
   inline const Id& ref(IdField field) const {
     return id_fields[field - ID_FIELDS_BEGIN];
   }
   inline int64 ref(BaseVersion field) const {
     return int64_fields[field - INT64_FIELDS_BEGIN];
   }
   inline bool ref(IndexedBitField field) const {
     return bit_fields[field - BIT_FIELDS_BEGIN];
   }
   inline bool ref(IsDelField field) const {
@@ skipping 59 matching lines @@
     return kernel_->ref(field);
   }
   inline Id Get(IdField field) const {
     DCHECK(kernel_);
     return kernel_->ref(field);
   }
   inline int64 Get(Int64Field field) const {
     DCHECK(kernel_);
     return kernel_->ref(field);
   }
+  inline const base::Time& Get(TimeField field) const {
+    DCHECK(kernel_);
+    return kernel_->ref(field);
+  }
   inline int64 Get(BaseVersion field) const {
     DCHECK(kernel_);
     return kernel_->ref(field);
   }
   inline bool Get(IndexedBitField field) const {
     DCHECK(kernel_);
     return kernel_->ref(field);
   }
   inline bool Get(IsDelField field) const {
     DCHECK(kernel_);
@@ skipping 81 matching lines @@
 
   inline WriteTransaction* write_transaction() const {
     return write_transaction_;
   }
 
   // Field Accessors.  Some of them trigger the re-indexing of the entry.
   // Return true on success, return false on failure, which means
   // that putting the value would have caused a duplicate in the index.
   // TODO(chron): Remove some of these unecessary return values.
   bool Put(Int64Field field, const int64& value);
+  bool Put(TimeField field, const base::Time& value);
   bool Put(IdField field, const Id& value);
 
   // Do a simple property-only update if the PARENT_ID field.  Use with caution.
   //
   // The normal Put(IS_PARENT) call will move the item to the front of the
   // sibling order to maintain the linked list invariants when the parent
   // changes.  That's usually what you want to do, but it's inappropriate
   // when the caller is trying to change the parent ID of a the whole set
   // of children (e.g. because the ID changed during a commit).  For those
   // cases, there's this function.  It will corrupt the sibling ordering
@@ skipping 703 matching lines @@
 
   // Only the original fields are filled in until |RecordMutations()|.
   // We use a mutation map instead of a kernel set to avoid copying.
   EntryKernelMutationMap mutations_;
 
   DISALLOW_COPY_AND_ASSIGN(WriteTransaction);
 };
 
 bool IsLegalNewParent(BaseTransaction* trans, const Id& id, const Id& parentid);
 
-int64 Now();
-
 // This function sets only the flags needed to get this entry to sync.
 void MarkForSyncing(syncable::MutableEntry* e);
 
-// This is not a reset.  It just sets the numeric fields which are not
-// initialized by the constructor to zero.
-void ZeroFields(EntryKernel* entry, int first_field);
-
 }  // namespace syncable
 
 std::ostream& operator <<(std::ostream&, const syncable::Blob&);
 
 #endif  // CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_