Switch to standard integer types in sync/.

sync/internal_api/sync_manager_impl.cc

 // Copyright (c) 2012 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/internal_api/sync_manager_impl.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
 #include "base/observer_list.h"
@@ skipping 656 matching lines @@
         type, write_transaction_info.Get().id, it->second);
     models_with_changes.Put(type);
   }
   change_records_.clear();
   return models_with_changes;
 }
 
 void SyncManagerImpl::HandleCalculateChangesChangeEventFromSyncApi(
     const ImmutableWriteTransactionInfo& write_transaction_info,
     syncable::BaseTransaction* trans,
-    std::vector<int64>* entries_changed) {
+    std::vector<int64_t>* entries_changed) {
   // We have been notified about a user action changing a sync model.
   LOG_IF(WARNING, !change_records_.empty()) <<
       "CALCULATE_CHANGES called with unapplied old changes.";
 
   // The mutated model type, or UNSPECIFIED if nothing was mutated.
   ModelTypeSet mutated_model_types;
 
   const syncable::ImmutableEntryKernelMutationMap& mutations =
       write_transaction_info.Get().mutations;
   for (syncable::EntryKernelMutationMap::const_iterator it =
@@ skipping 22 matching lines @@
       weak_handle_this_.Call(FROM_HERE,
                              &SyncManagerImpl::RequestNudgeForDataTypes,
                              FROM_HERE,
                              mutated_model_types);
     } else {
       NOTREACHED();
     }
   }
 }
 
-void SyncManagerImpl::SetExtraChangeRecordData(int64 id,
-    ModelType type, ChangeReorderBuffer* buffer,
-    Cryptographer* cryptographer, const syncable::EntryKernel& original,
-    bool existed_before, bool exists_now) {
+void SyncManagerImpl::SetExtraChangeRecordData(
+    int64_t id,
+    ModelType type,
+    ChangeReorderBuffer* buffer,
+    Cryptographer* cryptographer,
+    const syncable::EntryKernel& original,
+    bool existed_before,
+    bool exists_now) {
   // If this is a deletion and the datatype was encrypted, we need to decrypt it
   // and attach it to the buffer.
   if (!exists_now && existed_before) {
     sync_pb::EntitySpecifics original_specifics(original.ref(SPECIFICS));
     if (type == PASSWORDS) {
       // Passwords must use their own legacy ExtraPasswordChangeRecordData.
       scoped_ptr<sync_pb::PasswordSpecificsData> data(
           DecryptPasswordSpecifics(original_specifics, cryptographer));
       if (!data) {
         NOTREACHED();
         return;
       }
       buffer->SetExtraDataForId(id, new ExtraPasswordChangeRecordData(*data));
     } else if (original_specifics.has_encrypted()) {
       // All other datatypes can just create a new unencrypted specifics and
       // attach it.
       const sync_pb::EncryptedData& encrypted = original_specifics.encrypted();
       if (!cryptographer->Decrypt(encrypted, &original_specifics)) {
         NOTREACHED();
         return;
       }
     }
     buffer->SetSpecificsForId(id, original_specifics);
   }
 }
 
 void SyncManagerImpl::HandleCalculateChangesChangeEventFromSyncer(
     const ImmutableWriteTransactionInfo& write_transaction_info,
     syncable::BaseTransaction* trans,
-    std::vector<int64>* entries_changed) {
+    std::vector<int64_t>* entries_changed) {
   // We only expect one notification per sync step, so change_buffers_ should
   // contain no pending entries.
   LOG_IF(WARNING, !change_records_.empty()) <<
       "CALCULATE_CHANGES called with unapplied old changes.";
 
   ChangeReorderBuffer change_buffers[MODEL_TYPE_COUNT];
 
   Cryptographer* crypto = directory()->GetCryptographer(trans);
   const syncable::ImmutableEntryKernelMutationMap& mutations =
       write_transaction_info.Get().mutations;
   for (syncable::EntryKernelMutationMap::const_iterator it =
            mutations.Get().begin(); it != mutations.Get().end(); ++it) {
     bool existed_before = !it->second.original.ref(syncable::IS_DEL);
     bool exists_now = !it->second.mutated.ref(syncable::IS_DEL);
 
     // Omit items that aren't associated with a model.
     ModelType type =
         GetModelTypeFromSpecifics(it->second.mutated.ref(SPECIFICS));
     if (type < FIRST_REAL_MODEL_TYPE)
       continue;
 
-    int64 handle = it->first;
+    int64_t handle = it->first;
     if (exists_now && !existed_before)
       change_buffers[type].PushAddedItem(handle);
     else if (!exists_now && existed_before)
       change_buffers[type].PushDeletedItem(handle);
     else if (exists_now && existed_before &&
              VisiblePropertiesDiffer(it->second, crypto))
       change_buffers[type].PushUpdatedItem(handle);
 
     SetExtraChangeRecordData(handle, type, &change_buffers[type], crypto,
                              it->second.original, existed_before, exists_now);
@@ skipping 247 matching lines @@
 }
 
 void SyncManagerImpl::ClearServerData(const ClearServerDataCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   scheduler_->Start(SyncScheduler::CLEAR_SERVER_DATA_MODE, base::Time());
   ClearParams params(callback);
   scheduler_->ScheduleClearServerData(params);
 }
 
 }  // namespace syncer