Switch to standard integer types in device/.

device/bluetooth/bluetooth_pairing_bluez.cc

 // Copyright 2014 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 "device/bluetooth/bluetooth_pairing_bluez.h"
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_device_bluez.h"
@@ skipping 10 matching lines @@
   UMA_PAIRING_METHOD_DISPLAY_PINCODE,
   UMA_PAIRING_METHOD_DISPLAY_PASSKEY,
   UMA_PAIRING_METHOD_CONFIRM_PASSKEY,
   // NOTE: Add new pairing methods immediately above this line. Make sure to
   // update the enum list in tools/histogram/histograms.xml accordingly.
   UMA_PAIRING_METHOD_COUNT
 };
 
 // Number of keys that will be entered for a passkey, six digits plus the
 // final enter.
-const uint16 kPasskeyMaxKeysEntered = 7;
+const uint16_t kPasskeyMaxKeysEntered = 7;
 
 }  // namespace
 
 namespace bluez {
 
 BluetoothPairingBlueZ::BluetoothPairingBlueZ(
     BluetoothDeviceBlueZ* device,
     BluetoothDevice::PairingDelegate* pairing_delegate)
     : device_(device),
       pairing_delegate_(pairing_delegate),
@@ skipping 86 matching lines @@
   ResetCallbacks();
   passkey_callback_ = callback;
   pairing_delegate_used_ = true;
   pairing_delegate_->RequestPasskey(device_);
 }
 
 bool BluetoothPairingBlueZ::ExpectingPasskey() const {
   return !passkey_callback_.is_null();
 }
 
-void BluetoothPairingBlueZ::SetPasskey(uint32 passkey) {
+void BluetoothPairingBlueZ::SetPasskey(uint32_t passkey) {
   if (passkey_callback_.is_null())
     return;
 
   passkey_callback_.Run(bluez::BluetoothAgentServiceProvider::Delegate::SUCCESS,
                         passkey);
   passkey_callback_.Reset();
 
   // If this is not an outgoing connection to the device, clean up the pairing
   // context since the pairing is done. The outgoing connection case is cleaned
   // up in the callback for the underlying Pair() call.
   if (!device_->IsConnecting())
     device_->EndPairing();
 }
 
-void BluetoothPairingBlueZ::DisplayPasskey(uint32 passkey) {
+void BluetoothPairingBlueZ::DisplayPasskey(uint32_t passkey) {
   UMA_HISTOGRAM_ENUMERATION("Bluetooth.PairingMethod",
                             UMA_PAIRING_METHOD_DISPLAY_PASSKEY,
                             UMA_PAIRING_METHOD_COUNT);
 
   ResetCallbacks();
   pairing_delegate_used_ = true;
   pairing_delegate_->DisplayPasskey(device_, passkey);
 }
 
-void BluetoothPairingBlueZ::KeysEntered(uint16 entered) {
+void BluetoothPairingBlueZ::KeysEntered(uint16_t entered) {
   pairing_delegate_used_ = true;
   pairing_delegate_->KeysEntered(device_, entered);
 
   // If this is not an outgoing connection to the device, the pairing context
   // needs to be cleaned up again as there's no reliable indication of
   // completion of incoming pairing.
   if (entered >= kPasskeyMaxKeysEntered && !device_->IsConnecting())
     device_->EndPairing();
 }
 
 void BluetoothPairingBlueZ::RequestConfirmation(
-    uint32 passkey,
+    uint32_t passkey,
     const bluez::BluetoothAgentServiceProvider::Delegate::ConfirmationCallback&
         callback) {
   UMA_HISTOGRAM_ENUMERATION("Bluetooth.PairingMethod",
                             UMA_PAIRING_METHOD_CONFIRM_PASSKEY,
                             UMA_PAIRING_METHOD_COUNT);
 
   ResetCallbacks();
   confirmation_callback_ = callback;
   pairing_delegate_used_ = true;
   pairing_delegate_->ConfirmPasskey(device_, passkey);
@@ skipping 77 matching lines @@
   // If this is not an outgoing connection to the device, clean up the pairing
   // context since the pairing is done. The outgoing connection case is cleaned
   // up in the callback for the underlying Pair() call.
   if (!device_->IsConnecting())
     device_->EndPairing();
 
   return callback_run;
 }
 
 }  // namespace bluez