Switch to standard integer types in device/.

device/bluetooth/bluetooth_adapter_bluez.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 "device/bluetooth/bluetooth_adapter_bluez.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
+#include "build/build_config.h"
 #include "device/bluetooth/bluetooth_adapter_profile_bluez.h"
 #include "device/bluetooth/bluetooth_advertisement_bluez.h"
 #include "device/bluetooth/bluetooth_audio_sink_bluez.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_device_bluez.h"
 #include "device/bluetooth/bluetooth_discovery_session_outcome.h"
 #include "device/bluetooth/bluetooth_pairing_bluez.h"
 #include "device/bluetooth/bluetooth_remote_gatt_characteristic_bluez.h"
 #include "device/bluetooth/bluetooth_remote_gatt_descriptor_bluez.h"
 #include "device/bluetooth/bluetooth_remote_gatt_service_bluez.h"
@@ skipping 547 matching lines @@
   BluetoothPairingBlueZ* pairing = GetPairing(device_path);
   if (!pairing) {
     callback.Run(REJECTED, 0);
     return;
   }
 
   pairing->RequestPasskey(callback);
 }
 
 void BluetoothAdapterBlueZ::DisplayPasskey(const dbus::ObjectPath& device_path,
-                                           uint32 passkey,
-                                           uint16 entered) {
+                                           uint32_t passkey,
+                                           uint16_t entered) {
   DCHECK(IsPresent());
   DCHECK(agent_.get());
   VLOG(1) << device_path.value() << ": DisplayPasskey: " << passkey << " ("
           << entered << " entered)";
 
   BluetoothPairingBlueZ* pairing = GetPairing(device_path);
   if (!pairing)
     return;
 
   if (entered == 0)
     pairing->DisplayPasskey(passkey);
 
   pairing->KeysEntered(entered);
 }
 
 void BluetoothAdapterBlueZ::RequestConfirmation(
     const dbus::ObjectPath& device_path,
-    uint32 passkey,
+    uint32_t passkey,
     const ConfirmationCallback& callback) {
   DCHECK(IsPresent());
   DCHECK(agent_.get());
   VLOG(1) << device_path.value() << ": RequestConfirmation: " << passkey;
 
   BluetoothPairingBlueZ* pairing = GetPairing(device_path);
   if (!pairing) {
     callback.Run(REJECTED);
     return;
   }
@@ skipping 374 matching lines @@
                 descriptor->GetCharacteristic()->GetService())
                 ->GetAdapter(),
             this);
 
   FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                     GattDescriptorRemoved(this, descriptor));
 }
 
 void BluetoothAdapterBlueZ::NotifyGattCharacteristicValueChanged(
     BluetoothRemoteGattCharacteristicBlueZ* characteristic,
-    const std::vector<uint8>& value) {
+    const std::vector<uint8_t>& value) {
   DCHECK_EQ(static_cast<BluetoothRemoteGattServiceBlueZ*>(
                 characteristic->GetService())
                 ->GetAdapter(),
             this);
 
   FOR_EACH_OBSERVER(
       BluetoothAdapter::Observer, observers_,
       GattCharacteristicValueChanged(this, characteristic, value));
 }
 
 void BluetoothAdapterBlueZ::NotifyGattDescriptorValueChanged(
     BluetoothRemoteGattDescriptorBlueZ* descriptor,
-    const std::vector<uint8>& value) {
+    const std::vector<uint8_t>& value) {
   DCHECK_EQ(static_cast<BluetoothRemoteGattServiceBlueZ*>(
                 descriptor->GetCharacteristic()->GetService())
                 ->GetAdapter(),
             this);
 
   FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                     GattDescriptorValueChanged(this, descriptor, value));
 }
 
 void BluetoothAdapterBlueZ::UseProfile(
@@ skipping 481 matching lines @@
 
     // If the queued request resulted in a pending call, then let it
     // asynchonously process the remaining queued requests once the pending
     // call returns.
     if (discovery_request_pending_)
       return;
   }
 }
 
 }  // namespace bluez