Switch to standard integer types in sync/.

sync/syncable/nigori_util.cc

 // Copyright 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/syncable/nigori_util.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <queue>
 #include <string>
 #include <vector>
 
 #include "base/json/json_writer.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/entry.h"
+#include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/nigori_handler.h"
-#include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/syncable_util.h"
 #include "sync/syncable/syncable_write_transaction.h"
 #include "sync/util/cryptographer.h"
 
 namespace syncer {
 namespace syncable {
 
 bool ProcessUnsyncedChangesForEncryption(
     WriteTransaction* const trans) {
   NigoriHandler* nigori_handler = trans->directory()->GetNigoriHandler();
   ModelTypeSet encrypted_types = nigori_handler->GetEncryptedTypes(trans);
   Cryptographer* cryptographer = trans->directory()->GetCryptographer(trans);
   DCHECK(cryptographer->is_ready());
 
   // Get list of all datatypes with unsynced changes. It's possible that our
   // local changes need to be encrypted if encryption for that datatype was
   // just turned on (and vice versa).
   // Note: we do not attempt to re-encrypt data with a new key here as key
   // changes in this code path are likely due to consistency issues (we have
   // to be updated to a key we already have, e.g. an old key).
-  std::vector<int64> handles;
+  std::vector<int64_t> handles;
   GetUnsyncedEntries(trans, &handles);
   for (size_t i = 0; i < handles.size(); ++i) {
     MutableEntry entry(trans, GET_BY_HANDLE, handles[i]);
     const sync_pb::EntitySpecifics& specifics = entry.GetSpecifics();
     // Ignore types that don't need encryption or entries that are already
     // encrypted.
     if (!SpecificsNeedsEncryption(encrypted_types, specifics))
       continue;
     if (!UpdateEntryWithEncryption(trans, specifics, &entry))
       return false;
   }
   return true;
 }
 
 bool VerifyUnsyncedChangesAreEncrypted(
     BaseTransaction* const trans,
     ModelTypeSet encrypted_types) {
-  std::vector<int64> handles;
+  std::vector<int64_t> handles;
   GetUnsyncedEntries(trans, &handles);
   for (size_t i = 0; i < handles.size(); ++i) {
     Entry entry(trans, GET_BY_HANDLE, handles[i]);
     if (!entry.good()) {
       NOTREACHED();
       return false;
     }
     if (EntryNeedsEncryption(encrypted_types, entry))
       return false;
   }
@@ skipping 252 matching lines @@
     encrypted_types.Put(FAVICON_TRACKING);
   if (nigori.encrypt_articles())
     encrypted_types.Put(ARTICLES);
   if (nigori.encrypt_app_list())
     encrypted_types.Put(APP_LIST);
   return encrypted_types;
 }
 
 }  // namespace syncable
 }  // namespace syncer