Switch to standard integer types in sync/.

sync/engine/apply_control_data_updates_unittest.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/engine/apply_control_data_updates.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <string>
 
 #include "base/format_macros.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "sync/engine/syncer.h"
 #include "sync/engine/syncer_util.h"
 #include "sync/internal_api/public/test/test_entry_factory.h"
 #include "sync/protocol/nigori_specifics.pb.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/nigori_util.h"
@@ skipping 302 matching lines @@
   Cryptographer other_cryptographer(cryptographer->encryptor());
   other_cryptographer.AddKey(other_params);
 
   // Create server specifics with pending keys, new encrypted types,
   // and a custom passphrase (unmigrated).
   sync_pb::EntitySpecifics server_specifics;
   sync_pb::NigoriSpecifics* server_nigori = server_specifics.mutable_nigori();
   other_cryptographer.GetKeys(server_nigori->mutable_encryption_keybag());
   server_nigori->set_encrypt_everything(true);
   server_nigori->set_keybag_is_frozen(true);
-  int64 nigori_handle =
-      entry_factory_->CreateUnappliedNewItem(kNigoriTag,
-                                             server_specifics,
-                                             true);
+  int64_t nigori_handle = entry_factory_->CreateUnappliedNewItem(
+      kNigoriTag, server_specifics, true);
 
   // Initialize the local cryptographer with the local keys.
   cryptographer->AddKey(local_params);
   EXPECT_TRUE(cryptographer->is_ready());
 
   // Set up a local nigori with the local encryption keys and default encrypted
   // types.
   sync_pb::EntitySpecifics local_specifics;
   sync_pb::NigoriSpecifics* local_nigori = local_specifics.mutable_nigori();
   cryptographer->GetKeys(local_nigori->mutable_encryption_keybag());
@@ skipping 54 matching lines @@
   Cryptographer other_cryptographer(cryptographer->encryptor());
   other_cryptographer.AddKey(other_params);
 
   // Create server specifics with pending keys, new encrypted types,
   // and a custom passphrase (unmigrated).
   sync_pb::EntitySpecifics server_specifics;
   sync_pb::NigoriSpecifics* server_nigori = server_specifics.mutable_nigori();
   other_cryptographer.GetKeys(server_nigori->mutable_encryption_keybag());
   server_nigori->set_encrypt_everything(false);
   server_nigori->set_keybag_is_frozen(false);
-  int64 nigori_handle =
-      entry_factory_->CreateUnappliedNewItem(kNigoriTag,
-                                             server_specifics,
-                                             true);
+  int64_t nigori_handle = entry_factory_->CreateUnappliedNewItem(
+      kNigoriTag, server_specifics, true);
 
   // Initialize the local cryptographer with the local keys.
   cryptographer->AddKey(local_params);
   EXPECT_TRUE(cryptographer->is_ready());
 
   // Set up a local nigori with the local encryption keys and default encrypted
   // types.
   sync_pb::EntitySpecifics local_specifics;
   sync_pb::NigoriSpecifics* local_nigori = local_specifics.mutable_nigori();
   cryptographer->GetKeys(local_nigori->mutable_encryption_keybag());
@@ skipping 51 matching lines @@
   }
 
   // Set up the cryptographer with old keys
   cryptographer->AddKey(old_params);
 
   // Create server specifics with old keys and new encrypted types.
   sync_pb::EntitySpecifics server_specifics;
   sync_pb::NigoriSpecifics* server_nigori = server_specifics.mutable_nigori();
   cryptographer->GetKeys(server_nigori->mutable_encryption_keybag());
   server_nigori->set_encrypt_everything(true);
-  int64 nigori_handle =
-      entry_factory_->CreateUnappliedNewItem(kNigoriTag,
-                                             server_specifics,
-                                             true);
+  int64_t nigori_handle = entry_factory_->CreateUnappliedNewItem(
+      kNigoriTag, server_specifics, true);
 
   // Add the new keys to the cryptogrpaher
   cryptographer->AddKey(new_params);
   EXPECT_TRUE(cryptographer->is_ready());
 
   // Set up a local nigori with the superset of keys.
   sync_pb::EntitySpecifics local_specifics;
   sync_pb::NigoriSpecifics* local_nigori = local_specifics.mutable_nigori();
   cryptographer->GetKeys(local_nigori->mutable_encryption_keybag());
   local_nigori->set_encrypt_everything(false);
@@ skipping 51 matching lines @@
 
   // Create server specifics with a migrated keystore passphrase type.
   sync_pb::EntitySpecifics server_specifics;
   sync_pb::NigoriSpecifics* server_nigori = server_specifics.mutable_nigori();
   other_cryptographer.GetKeys(server_nigori->mutable_encryption_keybag());
   server_nigori->set_encrypt_everything(false);
   server_nigori->set_keybag_is_frozen(true);
   server_nigori->set_passphrase_type(
       sync_pb::NigoriSpecifics::KEYSTORE_PASSPHRASE);
   server_nigori->mutable_keystore_decryptor_token();
-  int64 nigori_handle =
-      entry_factory_->CreateUnappliedNewItem(kNigoriTag,
-                                             server_specifics,
-                                             true);
+  int64_t nigori_handle = entry_factory_->CreateUnappliedNewItem(
+      kNigoriTag, server_specifics, true);
 
   // Add the new keys to the cryptographer.
   cryptographer->AddKey(old_params);
   cryptographer->AddKey(new_params);
   EXPECT_TRUE(cryptographer->is_ready());
 
   // Set up a local nigori with a migrated custom passphrase type
   sync_pb::EntitySpecifics local_specifics;
   sync_pb::NigoriSpecifics* local_nigori = local_specifics.mutable_nigori();
   cryptographer->GetKeys(local_nigori->mutable_encryption_keybag());
@@ skipping 58 matching lines @@
   other_cryptographer.AddKey(new_params);
 
   // Create server specifics with a migrated custom passphrase type.
   sync_pb::EntitySpecifics server_specifics;
   sync_pb::NigoriSpecifics* server_nigori = server_specifics.mutable_nigori();
   other_cryptographer.GetKeys(server_nigori->mutable_encryption_keybag());
   server_nigori->set_encrypt_everything(true);
   server_nigori->set_keybag_is_frozen(true);
   server_nigori->set_passphrase_type(
       sync_pb::NigoriSpecifics::CUSTOM_PASSPHRASE);
-  int64 nigori_handle =
-      entry_factory_->CreateUnappliedNewItem(kNigoriTag,
-                                             server_specifics,
-                                             true);
+  int64_t nigori_handle = entry_factory_->CreateUnappliedNewItem(
+      kNigoriTag, server_specifics, true);
 
   // Add the old keys to the cryptographer.
   cryptographer->AddKey(old_params);
   EXPECT_TRUE(cryptographer->is_ready());
 
   // Set up a local nigori with a migrated keystore passphrase type
   sync_pb::EntitySpecifics local_specifics;
   sync_pb::NigoriSpecifics* local_nigori = local_specifics.mutable_nigori();
   cryptographer->GetKeys(local_nigori->mutable_encryption_keybag());
   local_nigori->set_encrypt_everything(false);
@@ skipping 56 matching lines @@
   // Set up the cryptographer with both new keys and old keys.
   Cryptographer other_cryptographer(cryptographer->encryptor());
   other_cryptographer.AddKey(old_params);
 
   // Create server specifics with an unmigrated implicit passphrase type.
   sync_pb::EntitySpecifics server_specifics;
   sync_pb::NigoriSpecifics* server_nigori = server_specifics.mutable_nigori();
   other_cryptographer.GetKeys(server_nigori->mutable_encryption_keybag());
   server_nigori->set_encrypt_everything(true);
   server_nigori->set_keybag_is_frozen(false);
-  int64 nigori_handle =
-      entry_factory_->CreateUnappliedNewItem(kNigoriTag,
-                                             server_specifics,
-                                             true);
+  int64_t nigori_handle = entry_factory_->CreateUnappliedNewItem(
+      kNigoriTag, server_specifics, true);
 
   // Add the old keys to the cryptographer.
   cryptographer->AddKey(old_params);
   cryptographer->AddKey(new_params);
   EXPECT_TRUE(cryptographer->is_ready());
 
   // Set up a local nigori with a migrated custom passphrase type
   sync_pb::EntitySpecifics local_specifics;
   sync_pb::NigoriSpecifics* local_nigori = local_specifics.mutable_nigori();
   cryptographer->GetKeys(local_nigori->mutable_encryption_keybag());
@@ skipping 58 matching lines @@
 
   // Create server specifics with an migrated keystore passphrase type.
   sync_pb::EntitySpecifics server_specifics;
   sync_pb::NigoriSpecifics* server_nigori = server_specifics.mutable_nigori();
   other_cryptographer.GetKeys(server_nigori->mutable_encryption_keybag());
   server_nigori->set_encrypt_everything(false);
   server_nigori->set_keybag_is_frozen(true);
   server_nigori->set_passphrase_type(
       sync_pb::NigoriSpecifics::KEYSTORE_PASSPHRASE);
   server_nigori->mutable_keystore_decryptor_token();
-  int64 nigori_handle =
-      entry_factory_->CreateUnappliedNewItem(kNigoriTag,
-                                             server_specifics,
-                                             true);
+  int64_t nigori_handle = entry_factory_->CreateUnappliedNewItem(
+      kNigoriTag, server_specifics, true);
 
   // Add the old keys to the cryptographer.
   cryptographer->AddKey(old_params);
   cryptographer->AddKey(new_params);
   EXPECT_TRUE(cryptographer->is_ready());
 
   // Set up a local nigori with a migrated custom passphrase type
   sync_pb::EntitySpecifics local_specifics;
   sync_pb::NigoriSpecifics* local_nigori = local_specifics.mutable_nigori();
   cryptographer->GetKeys(local_nigori->mutable_encryption_keybag());
@@ skipping 38 matching lines @@
     syncable::ReadTransaction trans(FROM_HERE, directory());
   }
 }
 
 // Check that we can apply a simple control datatype node successfully.
 TEST_F(ApplyControlDataUpdatesTest, ControlApply) {
   std::string experiment_id = "experiment";
   sync_pb::EntitySpecifics specifics;
   specifics.mutable_experiments()->mutable_keystore_encryption()->
       set_enabled(true);
-  int64 experiment_handle = entry_factory_->CreateUnappliedNewItem(
-      experiment_id, specifics, false);
+  int64_t experiment_handle =
+      entry_factory_->CreateUnappliedNewItem(experiment_id, specifics, false);
   ApplyControlDataUpdates(directory());
 
   EXPECT_FALSE(entry_factory_->GetIsUnappliedForItem(experiment_handle));
   EXPECT_TRUE(
       entry_factory_->GetLocalSpecificsForItem(experiment_handle).
           experiments().keystore_encryption().enabled());
 }
 
 // Verify that we apply top level folders before their children.
 TEST_F(ApplyControlDataUpdatesTest, ControlApplyParentBeforeChild) {
   std::string parent_id = "parent";
   std::string experiment_id = "experiment";
   sync_pb::EntitySpecifics specifics;
   specifics.mutable_experiments()->mutable_keystore_encryption()->
       set_enabled(true);
-  int64 experiment_handle = entry_factory_->CreateUnappliedNewItemWithParent(
+  int64_t experiment_handle = entry_factory_->CreateUnappliedNewItemWithParent(
       experiment_id, specifics, parent_id);
-  int64 parent_handle = entry_factory_->CreateUnappliedNewItem(
-      parent_id, specifics, true);
+  int64_t parent_handle =
+      entry_factory_->CreateUnappliedNewItem(parent_id, specifics, true);
   ApplyControlDataUpdates(directory());
 
   EXPECT_FALSE(entry_factory_->GetIsUnappliedForItem(parent_handle));
   EXPECT_FALSE(entry_factory_->GetIsUnappliedForItem(experiment_handle));
   EXPECT_TRUE(
       entry_factory_->GetLocalSpecificsForItem(experiment_handle).
           experiments().keystore_encryption().enabled());
 }
 
 // Verify that we handle control datatype conflicts by preserving the server
 // data.
 TEST_F(ApplyControlDataUpdatesTest, ControlConflict) {
   std::string experiment_id = "experiment";
   sync_pb::EntitySpecifics local_specifics, server_specifics;
   server_specifics.mutable_experiments()->mutable_keystore_encryption()->
       set_enabled(true);
   local_specifics.mutable_experiments()->mutable_keystore_encryption()->
       set_enabled(false);
-  int64 experiment_handle = entry_factory_->CreateSyncedItem(
-      experiment_id, EXPERIMENTS, false);
+  int64_t experiment_handle =
+      entry_factory_->CreateSyncedItem(experiment_id, EXPERIMENTS, false);
   entry_factory_->SetServerSpecificsForItem(experiment_handle,
                                             server_specifics);
   entry_factory_->SetLocalSpecificsForItem(experiment_handle,
                                            local_specifics);
   ApplyControlDataUpdates(directory());
 
   EXPECT_FALSE(entry_factory_->GetIsUnappliedForItem(experiment_handle));
   EXPECT_TRUE(
       entry_factory_->GetLocalSpecificsForItem(experiment_handle).
           experiments().keystore_encryption().enabled());
@@ skipping 56 matching lines @@
   ApplyControlDataUpdates(directory());
 
   // After applying the updates NIGORI should be marked as having its
   // initial sync completed.
   EXPECT_TRUE(directory()->InitialSyncEndedForType(NIGORI));
   // Verify that there is no side effect on another control type.
   EXPECT_FALSE(directory()->InitialSyncEndedForType(EXPERIMENTS));
 }
 
 }  // namespace syncer