Revert 102184 - [Sync] use base::Time in sync

chrome/browser/sync/engine/syncer_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_util.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/location.h"
 #include "chrome/browser/sync/engine/conflict_resolver.h"
 #include "chrome/browser/sync/engine/nigori_util.h"
 #include "chrome/browser/sync/engine/syncer_proto_util.h"
 #include "chrome/browser/sync/engine/syncer_types.h"
 #include "chrome/browser/sync/engine/syncproto.h"
 #include "chrome/browser/sync/protocol/bookmark_specifics.pb.h"
 #include "chrome/browser/sync/protocol/nigori_specifics.pb.h"
 #include "chrome/browser/sync/protocol/password_specifics.pb.h"
 #include "chrome/browser/sync/protocol/sync.pb.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/syncable/model_type.h"
 #include "chrome/browser/sync/syncable/syncable.h"
 #include "chrome/browser/sync/syncable/syncable_changes_version.h"
-#include "chrome/browser/sync/util/time.h"
 
 using syncable::BASE_VERSION;
 using syncable::Blob;
 using syncable::CHANGES_VERSION;
 using syncable::CREATE;
 using syncable::CREATE_NEW_UPDATE_ITEM;
 using syncable::CTIME;
 using syncable::Directory;
 using syncable::Entry;
 using syncable::GET_BY_HANDLE;
@@ skipping 382 matching lines @@
     }
     target->Put(IS_UNAPPLIED_UPDATE, true);
     return;
   }
 
   DCHECK(target->Get(ID) == update.id())
       << "ID Changing not supported here";
   target->Put(SERVER_PARENT_ID, update.parent_id());
   target->Put(SERVER_NON_UNIQUE_NAME, name);
   target->Put(SERVER_VERSION, update.version());
-  target->Put(SERVER_CTIME, ProtoTimeToTime(update.ctime()));
-  target->Put(SERVER_MTIME, ProtoTimeToTime(update.mtime()));
+  target->Put(SERVER_CTIME,
+      ServerTimeToClientTime(update.ctime()));
+  target->Put(SERVER_MTIME,
+      ServerTimeToClientTime(update.mtime()));
   target->Put(SERVER_IS_DIR, update.IsFolder());
   if (update.has_server_defined_unique_tag()) {
     const std::string& tag = update.server_defined_unique_tag();
     target->Put(UNIQUE_SERVER_TAG, tag);
   }
   if (update.has_client_defined_unique_tag()) {
     const std::string& tag = update.client_defined_unique_tag();
     target->Put(UNIQUE_CLIENT_TAG, tag);
   }
   // Store the datatype-specific part as a protobuf.
@@ skipping 46 matching lines @@
   }
 
   // Now find the closest up-to-date sibling in the server order.
   syncable::Id server_up_to_date_predecessor =
       entry->ComputePrevIdFromServerPosition(entry->Get(SERVER_PARENT_ID));
   return server_up_to_date_predecessor == local_up_to_date_predecessor;
 }
 
 // static
 bool SyncerUtil::ServerAndLocalEntriesMatch(syncable::Entry* entry) {
-  if (entry->Get(CTIME) != entry->Get(SERVER_CTIME)) {
+  if (!ClientAndServerTimeMatch(
+        entry->Get(CTIME), ClientTimeToServerTime(entry->Get(SERVER_CTIME)))) {
     LOG(WARNING) << "Client and server time mismatch";
     return false;
   }
   if (entry->Get(IS_DEL) && entry->Get(SERVER_IS_DEL))
     return true;
   // Name should exactly match here.
   if (!(entry->Get(NON_UNIQUE_NAME) == entry->Get(SERVER_NON_UNIQUE_NAME))) {
     LOG(WARNING) << "Unsanitized name mismatch";
     return false;
   }
@@ skipping 13 matching lines @@
   // TODO(ncarter): This is unfortunately heavyweight.  Can we do better?
   if (entry->Get(SPECIFICS).SerializeAsString() !=
       entry->Get(SERVER_SPECIFICS).SerializeAsString()) {
     LOG(WARNING) << "Specifics mismatch";
     return false;
   }
   if (entry->Get(IS_DIR))
     return true;
   // For historical reasons, a folder's MTIME changes when its contents change.
   // TODO(ncarter): Remove the special casing of MTIME.
-  if (entry->Get(MTIME) != entry->Get(SERVER_MTIME)) {
+  bool time_match = ClientAndServerTimeMatch(entry->Get(MTIME),
+      ClientTimeToServerTime(entry->Get(SERVER_MTIME)));
+  if (!time_match) {
     LOG(WARNING) << "Time mismatch";
-    return false;
   }
-  return true;
+  return time_match;
 }
 
 // static
 void SyncerUtil::SplitServerInformationIntoNewEntry(
     syncable::WriteTransaction* trans,
     syncable::MutableEntry* entry) {
   syncable::Id id = entry->Get(ID);
   ChangeEntryIDAndUpdateChildren(trans, entry, trans->directory()->NextId());
   entry->Put(BASE_VERSION, 0);
 
@@ skipping 280 matching lines @@
   if (update.version() < target->Get(SERVER_VERSION)) {
     LOG(WARNING) << "Update older than current server version for "
                  << *target << " Update:"
                  << SyncerProtoUtil::SyncEntityDebugString(update);
     return VERIFY_SUCCESS;  // Expected in new sync protocol.
   }
   return VERIFY_UNDECIDED;
 }
 
 }  // namespace browser_sync