[Sync] use base::Time in sync

chrome/browser/sync/syncable/directory_backing_store.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/directory_backing_store.h"
 
 #include "build/build_config.h"
 
-#if defined(OS_MACOSX)
-#include <CoreFoundation/CoreFoundation.h>
-#endif
-
 #include <limits>
 
 #include "base/file_util.h"
 #include "base/hash_tables.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
+#include "base/time.h"
 #include "chrome/browser/sync/protocol/bookmark_specifics.pb.h"
 #include "chrome/browser/sync/protocol/service_constants.h"
 #include "chrome/browser/sync/protocol/sync.pb.h"
 #include "chrome/browser/sync/syncable/syncable-inl.h"
 #include "chrome/browser/sync/syncable/syncable_columns.h"
 #include "chrome/browser/sync/util/sqlite_utils.h"
+#include "chrome/browser/sync/util/time.h"
 #include "chrome/common/random.h"
 #include "third_party/sqlite/sqlite3.h"
 
 // Sometimes threads contend on the DB lock itself, especially when one thread
 // is calling SaveChanges.  In the worst case scenario, the user can put his
 // laptop to sleep during db contention, and wake up the laptop days later, so
 // infinity seems like the best choice here.
 const int kDirectoryBackingStoreBusyTimeoutMs = std::numeric_limits<int>::max();
 
 using std::string;
 
 namespace syncable {
 
 // This just has to be big enough to hold an UPDATE or INSERT statement that
 // modifies all the columns in the entry table.
 static const string::size_type kUpdateStatementBufferSize = 2048;
 
 // Increment this version whenever updating DB tables.
 extern const int32 kCurrentDBVersion;  // Global visibility for our unittest.
-const int32 kCurrentDBVersion = 76;
+const int32 kCurrentDBVersion = 77;
 
 namespace {
 
 int ExecQuery(sqlite3* dbhandle, const char* query) {
   sqlite_utils::SQLStatement statement;
   int result = statement.prepare(dbhandle, query);
   if (SQLITE_OK != result)
     return result;
   do {
     result = statement.step();
@@ skipping 11 matching lines @@
 
 // Iterate over the fields of |entry| and bind each to |statement| for
 // updating.  Returns the number of args bound.
 int BindFields(const EntryKernel& entry,
                sqlite_utils::SQLStatement* statement) {
   int index = 0;
   int i = 0;
   for (i = BEGIN_FIELDS; i < INT64_FIELDS_END; ++i) {
     statement->bind_int64(index++, entry.ref(static_cast<Int64Field>(i)));
   }
+  for ( ; i < TIME_FIELDS_END; ++i) {
+    statement->bind_int64(index++,
+                          browser_sync::TimeToProtoTime(
+                              entry.ref(static_cast<TimeField>(i))));
+  }
   for ( ; i < ID_FIELDS_END; ++i) {
     statement->bind_string(index++, entry.ref(static_cast<IdField>(i)).s_);
   }
   for ( ; i < BIT_FIELDS_END; ++i) {
     statement->bind_int(index++, entry.ref(static_cast<BitField>(i)));
   }
   for ( ; i < STRING_FIELDS_END; ++i) {
     statement->bind_string(index++, entry.ref(static_cast<StringField>(i)));
   }
   std::string temp;
   for ( ; i < PROTO_FIELDS_END; ++i) {
     entry.ref(static_cast<ProtoField>(i)).SerializeToString(&temp);
     statement->bind_blob(index++, temp.data(), temp.length());
   }
   return index;
 }
 
 // The caller owns the returned EntryKernel*.
 int UnpackEntry(sqlite_utils::SQLStatement* statement, EntryKernel** kernel) {
   *kernel = NULL;
   int query_result = statement->step();
-  if (SQLITE_ROW == query_result) {
-    *kernel = new EntryKernel;
-    (*kernel)->clear_dirty(NULL);
-    DCHECK(statement->column_count() == static_cast<int>(FIELD_COUNT));
+  if (query_result == SQLITE_ROW) {
+    *kernel = new EntryKernel();
+    DCHECK_EQ(statement->column_count(), static_cast<int>(FIELD_COUNT));
     int i = 0;
     for (i = BEGIN_FIELDS; i < INT64_FIELDS_END; ++i) {
       (*kernel)->put(static_cast<Int64Field>(i), statement->column_int64(i));
     }
+    for ( ; i < TIME_FIELDS_END; ++i) {
+      (*kernel)->put(static_cast<TimeField>(i),
+                     browser_sync::ProtoTimeToTime(
+                         statement->column_int64(i)));
+    }
     for ( ; i < ID_FIELDS_END; ++i) {
       (*kernel)->mutable_ref(static_cast<IdField>(i)).s_ =
           statement->column_string(i);
     }
     for ( ; i < BIT_FIELDS_END; ++i) {
       (*kernel)->put(static_cast<BitField>(i), (0 != statement->column_int(i)));
     }
     for ( ; i < STRING_FIELDS_END; ++i) {
       (*kernel)->put(static_cast<StringField>(i),
           statement->column_string(i));
     }
     for ( ; i < PROTO_FIELDS_END; ++i) {
       (*kernel)->mutable_ref(static_cast<ProtoField>(i)).ParseFromArray(
           statement->column_blob(i), statement->column_bytes(i));
     }
-    ZeroFields((*kernel), i);
   } else {
-    DCHECK(SQLITE_DONE == query_result);
+    DCHECK_EQ(query_result, SQLITE_DONE);
     (*kernel) = NULL;
   }
   return query_result;
 }
 
 namespace {
 
 string ComposeCreateTableColumnSpecs() {
   const ColumnSpec* begin = g_metas_columns;
   const ColumnSpec* end = g_metas_columns + arraysize(g_metas_columns);
@@ skipping 335 matching lines @@
     if (MigrateVersion74To75())
       version_on_disk = 75;
   }
 
   // Version 76 removed all (5) autofill migration related columns.
   if (version_on_disk == 75) {
     if (MigrateVersion75To76())
       version_on_disk = 76;
   }
 
+  // Version 77 standardized all time fields to ms since the Unix
+  // epoch.
+  if (version_on_disk == 76) {
+    if (MigrateVersion76To77())
+      version_on_disk = 77;
+  }
+
   // If one of the migrations requested it, drop columns that aren't current.
   // It's only safe to do this after migrating all the way to the current
   // version.
   if (version_on_disk == kCurrentDBVersion && needs_column_refresh_) {
     if (!RefreshColumns())
       version_on_disk = 0;
   }
 
   // A final, alternative catch-all migration to simply re-sync everything.
   if (version_on_disk != kCurrentDBVersion) {
@@ skipping 591 matching lines @@
   //   bookmarks_added_during_autofill_migration
   //   autofill_migration_time
   //   autofill_entries_added_during_migration
   //   autofill_profiles_added_during_migration
   // No data migration is necessary, but we should do a column refresh.
   SetVersion(76);
   needs_column_refresh_ = true;
   return true;
 }
 
+bool DirectoryBackingStore::MigrateVersion76To77() {
+  sqlite_utils::SQLStatement update_timestamps;
+  // This change changes the format of stored timestamps to ms since
+  // the Unix epoch.
+#if defined(OS_WIN)
+// On Windows, we used to store timestamps in FILETIME format (100s of
+// ns since Jan 1, 1601).  Magic numbers taken from
+// http://stackoverflow.com/questions/5398557/java-library-for-dealing-with-win32-filetime
+// .
+#define TO_UNIX_TIME_MS(x) #x " = " #x " / 10000 - 11644473600000"
+#else
+// On other platforms, we used to store timestamps in time_t format (s
+// since the Unix epoch).
+#define TO_UNIX_TIME_MS(x) #x " = " #x " * 1000"
+#endif
+  update_timestamps.prepare(
+      load_dbhandle_,
+      "UPDATE metas SET "
+      TO_UNIX_TIME_MS(mtime) ", "
+      TO_UNIX_TIME_MS(server_mtime) ", "
+      TO_UNIX_TIME_MS(ctime) ", "
+      TO_UNIX_TIME_MS(server_ctime));
+#undef TO_UNIX_TIME_MS
+  if (update_timestamps.step() != SQLITE_DONE)
+    return false;
+  SetVersion(77);
+  return true;
+}
+
 int DirectoryBackingStore::CreateTables() {
   VLOG(1) << "First run, creating tables";
   // Create two little tables share_version and share_info
   int result = ExecQuery(load_dbhandle_,
                          "CREATE TABLE share_version ("
                          "id VARCHAR(128) primary key, data INT)");
   if (result != SQLITE_DONE)
     return result;
   {
     sqlite_utils::SQLStatement statement;
@@ skipping 34 matching lines @@
 
   result = CreateModelsTable();
   if (result != SQLITE_DONE)
     return result;
   // Create the big metas table.
   result = CreateMetasTable(false);
   if (result != SQLITE_DONE)
     return result;
   {
     // Insert the entry for the root into the metas table.
-    const int64 now = Now();
+    const int64 now = browser_sync::TimeToProtoTime(base::Time::Now());
     sqlite_utils::SQLStatement statement;
     statement.prepare(load_dbhandle_,
                       "INSERT INTO metas "
                       "( id, metahandle, is_dir, ctime, mtime) "
                       "VALUES ( \"r\", 1, 1, ?, ?)");
     statement.bind_int64(0, now);
     statement.bind_int64(1, now);
     result = statement.step();
   }
   return result;
@@ skipping 71 matching lines @@
       "id TEXT primary key, "
       "name TEXT, "
       "store_birthday TEXT, "
       "db_create_version TEXT, "
       "db_create_time INT, "
       "next_id INT default -2, "
       "cache_guid TEXT )");
   return ExecQuery(load_dbhandle_, query.c_str());
 }
 }  // namespace syncable