[Sync] use base::Time in sync

chrome/browser/sync/syncable/syncable.cc

 // 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.
 
 #include "chrome/browser/sync/syncable/syncable.h"
 
-#include "build/build_config.h"
-
-#include <sys/stat.h>
-#if defined(OS_POSIX)
-#include <sys/time.h>
-#endif
-#include <sys/types.h>
-#include <time.h>
-#if defined(OS_MACOSX)
-#include <CoreFoundation/CoreFoundation.h>
-#elif defined(OS_WIN)
-#include <shlwapi.h>  // for PathMatchSpec
-#endif
-
 #include <algorithm>
 #include <cstring>
 #include <functional>
 #include <iomanip>
 #include <iterator>
 #include <limits>
 #include <set>
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/hash_tables.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/perftimer.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
-#include "base/time.h"
 #include "base/tracked.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/sync/protocol/proto_value_conversions.h"
 #include "chrome/browser/sync/protocol/service_constants.h"
 #include "chrome/browser/sync/syncable/directory_backing_store.h"
 #include "chrome/browser/sync/syncable/directory_change_delegate.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/syncable/model_type.h"
 #include "chrome/browser/sync/syncable/syncable_changes_version.h"
@@ skipping 55 matching lines @@
 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;
 }
 
-int64 Now() {
-#if defined(OS_WIN)
-  FILETIME filetime;
-  SYSTEMTIME systime;
-  GetSystemTime(&systime);
-  SystemTimeToFileTime(&systime, &filetime);
-  // MSDN recommends converting via memcpy like this.
-  LARGE_INTEGER n;
-  memcpy(&n, &filetime, sizeof(filetime));
-  return n.QuadPart;
-#elif defined(OS_POSIX)
-  struct timeval tv;
-  gettimeofday(&tv, NULL);
-  return static_cast<int64>(tv.tv_sec);
-#else
-#error NEED OS SPECIFIC Now() implementation
-#endif
-}
-
 namespace {
 
 // A ScopedIndexUpdater temporarily removes an entry from an index,
 // and restores it to the index when the scope exits.  This simplifies
 // the common pattern where items need to be removed from an index
 // before updating the field.
 //
 // This class is parameterized on the Indexer traits type, which
 // must define a Comparator and a static bool ShouldInclude
 // function for testing whether the item ought to be included
@@ skipping 126 matching lines @@
     dictionary_value->Set(key, value);
   }
 }
 
 // Helper functions for SetFieldValues().
 
 StringValue* Int64ToValue(int64 i) {
   return Value::CreateStringValue(base::Int64ToString(i));
 }
 
+StringValue* TimeToValue(const base::Time& t) {
+  return Value::CreateStringValue(browser_sync::GetTimeDebugString(t));
+}
+
 StringValue* IdToValue(const Id& id) {
   return id.ToValue();
 }
 
 }  // namespace
 
 DictionaryValue* EntryKernel::ToValue() const {
   DictionaryValue* kernel_info = new DictionaryValue();
   kernel_info->SetBoolean("isDirty", is_dirty());
 
   // Int64 fields.
   SetFieldValues(*this, kernel_info,
                  &GetMetahandleFieldString, &Int64ToValue,
                  INT64_FIELDS_BEGIN, META_HANDLE);
   SetFieldValues(*this, kernel_info,
                  &GetBaseVersionString, &Int64ToValue,
                  META_HANDLE + 1, BASE_VERSION);
   SetFieldValues(*this, kernel_info,
                  &GetInt64FieldString, &Int64ToValue,
                  BASE_VERSION + 1, INT64_FIELDS_END - 1);
 
+  // Time fields.
+  SetFieldValues(*this, kernel_info,
+                 &GetTimeFieldString, &TimeToValue,
+                 TIME_FIELDS_BEGIN, TIME_FIELDS_END - 1);
+
   // ID fields.
   SetFieldValues(*this, kernel_info,
                  &GetIdFieldString, &IdToValue,
                  ID_FIELDS_BEGIN, ID_FIELDS_END - 1);
 
   // Bit fields.
   SetFieldValues(*this, kernel_info,
                  &GetIndexedBitFieldString, &Value::CreateBooleanValue,
                  BIT_FIELDS_BEGIN, INDEXED_BIT_FIELDS_END - 1);
   SetFieldValues(*this, kernel_info,
@@ skipping 267 matching lines @@
 EntryKernel* Directory::GetRootEntry() {
   return GetEntryById(Id());
 }
 
 void ZeroFields(EntryKernel* entry, int first_field) {
   int i = first_field;
   // Note that bitset<> constructor sets all bits to zero, and strings
   // initialize to empty.
   for ( ; i < INT64_FIELDS_END; ++i)
     entry->put(static_cast<Int64Field>(i), 0);
+  if (i < TIME_FIELDS_END)

[Nicolas Zea, 2011/09/21 18:09:12]

Any reason you don't zero out the time fields?

[akalin, 2011/09/21 19:37:35]

ZeroFields is called immediately shortly construction to zero-initialize
non-filled-in fields (an unneeded micro-optimization, IMO).  Time fields are
already default-initialized to 0.  In fact, only the int64 fields need to be
zero-initialized.  Removed ZeroFields and move the zero-initialization to
EntryKernel::EntryKernel().

+    i = TIME_FIELDS_END;
   for ( ; i < ID_FIELDS_END; ++i)
     entry->mutable_ref(static_cast<IdField>(i)).Clear();
   for ( ; i < BIT_FIELDS_END; ++i)
     entry->put(static_cast<BitField>(i), false);
   if (i < PROTO_FIELDS_END)
     i = PROTO_FIELDS_END;
   entry->clear_dirty(NULL);
 }
 
 void Directory::InsertEntry(EntryKernel* entry) {
@@ skipping 803 matching lines @@
 
 void MutableEntry::Init(WriteTransaction* trans, const Id& parent_id,
                         const string& name) {
   kernel_ = new EntryKernel;
   ZeroFields(kernel_, BEGIN_FIELDS);
   kernel_->put(ID, trans->directory_->NextId());
   kernel_->put(META_HANDLE, trans->directory_->NextMetahandle());
   kernel_->mark_dirty(trans->directory_->kernel_->dirty_metahandles);
   kernel_->put(PARENT_ID, parent_id);
   kernel_->put(NON_UNIQUE_NAME, name);
-  const int64 now = Now();
+  const base::Time& now = base::Time::Now();
   kernel_->put(CTIME, now);
   kernel_->put(MTIME, now);
   // We match the database defaults here
   kernel_->put(BASE_VERSION, CHANGES_VERSION);
   trans->directory()->InsertEntry(kernel_);
   // Because this entry is new, it was originally deleted.
   kernel_->put(IS_DEL, true);
   trans->SaveOriginal(kernel_);
   kernel_->put(IS_DEL, false);
 }
@@ skipping 75 matching lines @@
           dir()->kernel_->parent_id_child_index);
       kernel_->put(field, value);
     } else {
       kernel_->put(field, value);
     }
     kernel_->mark_dirty(dir()->kernel_->dirty_metahandles);
   }
   return true;
 }
 
+bool MutableEntry::Put(TimeField field, const base::Time& value) {
+  DCHECK(kernel_);
+  if (kernel_->ref(field) != value) {
+    kernel_->put(field, value);
+    kernel_->mark_dirty(dir()->kernel_->dirty_metahandles);
+  }
+  return true;
+}
+
 bool MutableEntry::Put(IdField field, const Id& value) {
   DCHECK(kernel_);
   if (kernel_->ref(field) != value) {
     if (ID == field) {
       if (!dir()->ReindexId(kernel_, value))
         return false;
     } else if (PARENT_ID == field) {
       PutParentIdPropertyOnly(value);  // Makes sibling order inconsistent.
       PutPredecessor(Id());  // Fixes up the sibling order inconsistency.
     } else {
@@ skipping 352 matching lines @@
   e->Put(SYNCING, false);
 }
 
 std::ostream& operator<<(std::ostream& os, const Entry& entry) {
   int i;
   EntryKernel* const kernel = entry.kernel_;
   for (i = BEGIN_FIELDS; i < INT64_FIELDS_END; ++i) {
     os << g_metas_columns[i].name << ": "
        << kernel->ref(static_cast<Int64Field>(i)) << ", ";
   }
+  for ( ; i < TIME_FIELDS_END; ++i) {
+    os << g_metas_columns[i].name << ": "
+       << browser_sync::GetTimeDebugString(
+           kernel->ref(static_cast<TimeField>(i))) << ", ";
+  }
   for ( ; i < ID_FIELDS_END; ++i) {
     os << g_metas_columns[i].name << ": "
        << kernel->ref(static_cast<IdField>(i)) << ", ";
   }
   os << "Flags: ";
   for ( ; i < BIT_FIELDS_END; ++i) {
     if (kernel->ref(static_cast<BitField>(i)))
       os << g_metas_columns[i].name << ", ";
   }
   for ( ; i < STRING_FIELDS_END; ++i) {
@@ skipping 59 matching lines @@
   CHECK(result);
   for (iterator i = GetParentChildIndexLowerBound(lock, parent_id),
            end = GetParentChildIndexUpperBound(lock, parent_id);
        i != end; ++i) {
     DCHECK_EQ(parent_id, (*i)->ref(PARENT_ID));
     result->push_back((*i)->ref(META_HANDLE));
   }
 }
 
 }  // namespace syncable