Switch to standard integer types in sync/.

sync/engine/process_updates_util.cc

 // Copyright 2013 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 "sync/engine/process_updates_util.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <string>
 
 #include "base/location.h"
 #include "base/metrics/sparse_histogram.h"
 #include "sync/engine/syncer_proto_util.h"
 #include "sync/engine/syncer_types.h"
 #include "sync/engine/syncer_util.h"
 #include "sync/internal_api/public/sessions/update_counters.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/model_neutral_mutable_entry.h"
@@ skipping 27 matching lines @@
 // updates its local ID.
 // - When two attempts to create an item with identical UNIQUE_CLIENT_TAG values
 // collide at the server.  I have seen this in testing.  When it happens, the
 // test server will send one of the clients a response to upate its local ID so
 // that both clients will refer to the item using the same ID going forward.  In
 // this case, we're right to assume that the update is not a reflection.
 //
 // For more information, see FindLocalIdToUpdate().
 bool UpdateContainsNewVersion(syncable::BaseTransaction *trans,
                               const sync_pb::SyncEntity &update) {
-  int64 existing_version = -1;  // The server always sends positive versions.
+  int64_t existing_version = -1;  // The server always sends positive versions.
   syncable::Entry existing_entry(trans, GET_BY_ID,
                                  SyncableIdFromProto(update.id_string()));
   if (existing_entry.good())
     existing_version = existing_entry.GetBaseVersion();
 
   if (!existing_entry.good() && update.deleted()) {
     // There are several possible explanations for this.  The most common cases
     // will be first time sync and the redelivery of deletions we've already
     // synced, accepted, and purged from our database.  In either case, the
     // update is useless to us.  Let's count them all as "not new", even though
@@ skipping 247 matching lines @@
                             (*update_it)->ByteSize());
     }
     UMA_HISTOGRAM_SPARSE_SLOWLY("DataUse.Sync.Download.Count",
                                 ModelTypeToHistogramInt(type));
   }
 }
 
 void ExpireEntriesByVersion(syncable::Directory* dir,
                             syncable::ModelNeutralWriteTransaction* trans,
                             ModelType type,
-                            int64 version_watermark) {
+                            int64_t version_watermark) {
   syncable::Directory::Metahandles handles;
   dir->GetMetaHandlesOfType(trans, type, &handles);
   for (size_t i = 0; i < handles.size(); ++i) {
     syncable::ModelNeutralMutableEntry entry(trans, syncable::GET_BY_HANDLE,
                                              handles[i]);
     if (!entry.good() || !entry.GetId().ServerKnows() ||
         entry.GetUniqueServerTag() == ModelTypeToRootTag(type) ||
         entry.GetIsUnappliedUpdate() || entry.GetIsUnsynced() ||
         entry.GetIsDel() || entry.GetServerIsDel() ||
         entry.GetBaseVersion() >= version_watermark) {
       continue;
     }
 
     // Mark entry as unapplied update first to ensure journaling the deletion.
     entry.PutIsUnappliedUpdate(true);
     // Mark entry as deleted by server.
     entry.PutServerIsDel(true);
     entry.PutServerVersion(version_watermark);
   }
 }
 
 }  // namespace syncer