Revert 102184 - [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"
@@ skipping 104 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 64 matching lines @@
 bool ParentIdAndHandleIndexer::ShouldInclude(const EntryKernel* a) {
   // This index excludes deleted items and the root item.  The root
   // item is excluded so that it doesn't show up as a child of itself.
   return !a->ref(IS_DEL) && !a->ref(ID).IsRoot();
 }
 
 ///////////////////////////////////////////////////////////////////////////
 // EntryKernel
 
 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;
-  }
+  memset(int64_fields, 0, sizeof(int64_fields));
 }
 
 EntryKernel::~EntryKernel() {}
 
 bool EntryKernel::ContainsString(const std::string& lowercase_query) const {
   // TODO(lipalani) - figure out what to do if the node is encrypted.
   const sync_pb::EntitySpecifics& specifics = ref(SPECIFICS);
   std::string temp;
   // The protobuf serialized string contains the original strings. So
   // we will just serialize it and search it.
@@ skipping 41 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 262 matching lines @@
   if (!kernel)
     return;
 
   AppendChildHandles(lock, kernel->ref(ID), result);
 }
 
 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);
+  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) {
   ScopedKernelLock lock(this);
   InsertEntry(entry, &lock);
 }
 
 void Directory::InsertEntry(EntryKernel* entry, ScopedKernelLock* lock) {
   DCHECK(NULL != lock);
   CHECK(NULL != entry);
   static const char error[] = "Entry already in memory index.";
   CHECK(kernel_->metahandles_index->insert(entry).second) << error;
@@ skipping 794 matching lines @@
 MutableEntry::MutableEntry(WriteTransaction* trans, Create,
                            const Id& parent_id, const string& name)
     : Entry(trans),
       write_transaction_(trans) {
   Init(trans, parent_id, name);
 }
 
 
 void MutableEntry::Init(WriteTransaction* trans, const Id& parent_id,
                         const string& name) {
-  kernel_ = new EntryKernel();
+  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 base::Time& now = base::Time::Now();
+  const int64 now = 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);
 }
 
 MutableEntry::MutableEntry(WriteTransaction* trans, CreateNewUpdateItem,
                            const Id& id)
     : Entry(trans), write_transaction_(trans) {
   Entry same_id(trans, GET_BY_ID, id);
   if (same_id.good()) {
     kernel_ = NULL;  // already have an item with this ID.
     return;
   }
-  kernel_ = new EntryKernel();
+  kernel_ = new EntryKernel;
+  ZeroFields(kernel_, BEGIN_FIELDS);
   kernel_->put(ID, id);
   kernel_->put(META_HANDLE, trans->directory_->NextMetahandle());
   kernel_->mark_dirty(trans->directory_->kernel_->dirty_metahandles);
   kernel_->put(IS_DEL, true);
   // We match the database defaults here
   kernel_->put(BASE_VERSION, CHANGES_VERSION);
   trans->directory()->InsertEntry(kernel_);
   trans->SaveOriginal(kernel_);
 }
 
@@ skipping 54 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