[Sync] use base::Time in sync

chrome/browser/sync/engine/syncer_proto_util.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/engine/syncer_proto_util.h"
 
 #include "base/format_macros.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/sync/engine/net/server_connection_manager.h"
 #include "chrome/browser/sync/engine/syncer.h"
 #include "chrome/browser/sync/engine/syncer_types.h"
-#include "chrome/browser/sync/engine/syncer_util.h"
 #include "chrome/browser/sync/protocol/service_constants.h"
 #include "chrome/browser/sync/protocol/sync.pb.h"
 #include "chrome/browser/sync/protocol/sync_protocol_error.h"
 #include "chrome/browser/sync/sessions/sync_session.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/syncable/model_type.h"
 #include "chrome/browser/sync/syncable/syncable-inl.h"
 #include "chrome/browser/sync/syncable/syncable.h"
+#include "chrome/browser/sync/util/time.h"
 
 using browser_sync::SyncProtocolErrorType;
 using std::string;
 using std::stringstream;
 using syncable::BASE_VERSION;
 using syncable::CTIME;
 using syncable::ID;
 using syncable::IS_DEL;
 using syncable::IS_DIR;
 using syncable::IS_UNSYNCED;
@@ skipping 326 matching lines @@
 
   CHECK(local_entry.Get(ID) == server_entry.id()) <<
       " SyncerProtoUtil::Compare precondition not met.";
   CHECK(server_entry.version() == local_entry.Get(BASE_VERSION)) <<
       " SyncerProtoUtil::Compare precondition not met.";
   CHECK(!local_entry.Get(IS_UNSYNCED)) <<
       " SyncerProtoUtil::Compare precondition not met.";
 
   if (local_entry.Get(IS_DEL) && server_entry.deleted())
     return true;
-  if (!ClientAndServerTimeMatch(local_entry.Get(CTIME), server_entry.ctime())) {
+  if (local_entry.Get(CTIME) != ProtoTimeToTime(server_entry.ctime())) {
     LOG(WARNING) << "ctime mismatch";
     return false;
   }
 
   // These checks are somewhat prolix, but they're easier to debug than a big
   // boolean statement.
   string client_name = local_entry.Get(syncable::NON_UNIQUE_NAME);
   if (client_name != name) {
     LOG(WARNING) << "Client name mismatch";
     return false;
   }
   if (local_entry.Get(PARENT_ID) != server_entry.parent_id()) {
     LOG(WARNING) << "Parent ID mismatch";
     return false;
   }
   if (local_entry.Get(IS_DIR) != server_entry.IsFolder()) {
     LOG(WARNING) << "Dir field mismatch";
     return false;
   }
   if (local_entry.Get(IS_DEL) != server_entry.deleted()) {
     LOG(WARNING) << "Deletion mismatch";
     return false;
   }
   if (!local_entry.Get(IS_DIR) &&
-      !ClientAndServerTimeMatch(local_entry.Get(MTIME),
-                                server_entry.mtime())) {
+      (local_entry.Get(MTIME) != ProtoTimeToTime(server_entry.mtime()))) {
     LOG(WARNING) << "mtime mismatch";
     return false;
   }
 
   return true;
 }
 
 // static
 void SyncerProtoUtil::CopyProtoBytesIntoBlob(const std::string& proto_bytes,
                                              syncable::Blob* blob) {
@@ skipping 27 matching lines @@
 // static
 const std::string& SyncerProtoUtil::NameFromCommitEntryResponse(
     const CommitResponse_EntryResponse& entry) {
   if (entry.has_non_unique_name())
     return entry.non_unique_name();
   return entry.name();
 }
 
 std::string SyncerProtoUtil::SyncEntityDebugString(
     const sync_pb::SyncEntity& entry) {
+  const std::string& mtime_str =
+      GetTimeDebugString(ProtoTimeToTime(entry.mtime()));
+  const std::string& ctime_str =
+      GetTimeDebugString(ProtoTimeToTime(entry.ctime()));
   return base::StringPrintf(
       "id: %s, parent_id: %s, "
       "version: %"PRId64"d, "
-      "mtime: %" PRId64"d (client: %" PRId64"d), "
-      "ctime: %" PRId64"d (client: %" PRId64"d), "
+      "mtime: %" PRId64"d (%s), "
+      "ctime: %" PRId64"d (%s), "
       "name: %s, sync_timestamp: %" PRId64"d, "
       "%s ",
       entry.id_string().c_str(),
       entry.parent_id_string().c_str(),
       entry.version(),
-      entry.mtime(), ServerTimeToClientTime(entry.mtime()),
-      entry.ctime(), ServerTimeToClientTime(entry.ctime()),
+      entry.mtime(), mtime_str.c_str(),
+      entry.ctime(), ctime_str.c_str(),
       entry.name().c_str(), entry.sync_timestamp(),
       entry.deleted() ? "deleted, ":"");
 }
 
 namespace {
 std::string GetUpdatesResponseString(
     const sync_pb::GetUpdatesResponse& response) {
   std::string output;
   output.append("GetUpdatesResponse:\n");
   for (int i = 0; i < response.entries_size(); i++) {
     output.append(SyncerProtoUtil::SyncEntityDebugString(response.entries(i)));
     output.append("\n");
   }
   return output;
 }
 }  // namespace
 
 std::string SyncerProtoUtil::ClientToServerResponseDebugString(
     const sync_pb::ClientToServerResponse& response) {
   // Add more handlers as needed.
   std::string output;
   if (response.has_get_updates())
     output.append(GetUpdatesResponseString(response.get_updates()));
   return output;
 }
 
 }  // namespace browser_sync