Switch to standard integer types in device/.

device/bluetooth/bluetooth_device_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_device_bluez.h"
 
 #include <stdio.h>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 34 matching lines @@
   UMA_PAIRING_RESULT_AUTH_TIMEOUT,
   UMA_PAIRING_RESULT_UNSUPPORTED_DEVICE,
   UMA_PAIRING_RESULT_UNKNOWN_ERROR,
   // NOTE: Add new pairing results immediately above this line. Make sure to
   // update the enum list in tools/histogram/histograms.xml accordinly.
   UMA_PAIRING_RESULT_COUNT
 };
 
 void ParseModalias(const dbus::ObjectPath& object_path,
                    BluetoothDevice::VendorIDSource* vendor_id_source,
-                   uint16* vendor_id,
-                   uint16* product_id,
-                   uint16* device_id) {
+                   uint16_t* vendor_id,
+                   uint16_t* product_id,
+                   uint16_t* device_id) {
   bluez::BluetoothDeviceClient::Properties* properties =
       bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->GetProperties(
           object_path);
   DCHECK(properties);
 
   std::string modalias = properties->modalias.value();
   BluetoothDevice::VendorIDSource source_value;
   int vendor_value, product_value, device_value;
 
   if (sscanf(modalias.c_str(), "bluetooth:v%04xp%04xd%04x", &vendor_value,
@@ skipping 106 matching lines @@
   // send GattServiceRemoved(), GetGattServices() returns no services.
   GattServiceMap gatt_services_swapped;
   gatt_services_swapped.swap(gatt_services_);
   for (const auto& iter : gatt_services_swapped) {
     DCHECK(adapter_);
     adapter()->NotifyGattServiceRemoved(
         static_cast<BluetoothRemoteGattServiceBlueZ*>(iter.second));
   }
 }
 
-uint32 BluetoothDeviceBlueZ::GetBluetoothClass() const {
+uint32_t BluetoothDeviceBlueZ::GetBluetoothClass() const {
   bluez::BluetoothDeviceClient::Properties* properties =
       bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->GetProperties(
           object_path_);
   DCHECK(properties);
 
   return properties->bluetooth_class.value();
 }
 
 std::string BluetoothDeviceBlueZ::GetDeviceName() const {
   bluez::BluetoothDeviceClient::Properties* properties =
@@ skipping 25 matching lines @@
   return CanonicalizeAddress(properties->address.value());
 }
 
 BluetoothDevice::VendorIDSource BluetoothDeviceBlueZ::GetVendorIDSource()
     const {
   VendorIDSource vendor_id_source = VENDOR_ID_UNKNOWN;
   ParseModalias(object_path_, &vendor_id_source, NULL, NULL, NULL);
   return vendor_id_source;
 }
 
-uint16 BluetoothDeviceBlueZ::GetVendorID() const {
-  uint16 vendor_id = 0;
+uint16_t BluetoothDeviceBlueZ::GetVendorID() const {
+  uint16_t vendor_id = 0;
   ParseModalias(object_path_, NULL, &vendor_id, NULL, NULL);
   return vendor_id;
 }
 
-uint16 BluetoothDeviceBlueZ::GetProductID() const {
-  uint16 product_id = 0;
+uint16_t BluetoothDeviceBlueZ::GetProductID() const {
+  uint16_t product_id = 0;
   ParseModalias(object_path_, NULL, NULL, &product_id, NULL);
   return product_id;
 }
 
-uint16 BluetoothDeviceBlueZ::GetDeviceID() const {
-  uint16 device_id = 0;
+uint16_t BluetoothDeviceBlueZ::GetDeviceID() const {
+  uint16_t device_id = 0;
   ParseModalias(object_path_, NULL, NULL, NULL, &device_id);
   return device_id;
 }
 
 bool BluetoothDeviceBlueZ::IsPaired() const {
   bluez::BluetoothDeviceClient::Properties* properties =
       bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->GetProperties(
           object_path_);
   DCHECK(properties);
 
@@ skipping 43 matching lines @@
   const std::vector<std::string>& dbus_uuids = properties->uuids.value();
   for (std::vector<std::string>::const_iterator iter = dbus_uuids.begin();
        iter != dbus_uuids.end(); ++iter) {
     device::BluetoothUUID uuid(*iter);
     DCHECK(uuid.IsValid());
     uuids.push_back(uuid);
   }
   return uuids;
 }
 
-int16 BluetoothDeviceBlueZ::GetInquiryRSSI() const {
+int16_t BluetoothDeviceBlueZ::GetInquiryRSSI() const {
   bluez::BluetoothDeviceClient::Properties* properties =
       bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->GetProperties(
           object_path_);
   DCHECK(properties);
 
   if (!properties->rssi.is_valid())
     return kUnknownPower;
 
   return properties->rssi.value();
 }
 
-int16 BluetoothDeviceBlueZ::GetInquiryTxPower() const {
+int16_t BluetoothDeviceBlueZ::GetInquiryTxPower() const {
   bluez::BluetoothDeviceClient::Properties* properties =
       bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->GetProperties(
           object_path_);
   DCHECK(properties);
 
   if (!properties->tx_power.is_valid())
     return kUnknownPower;
 
   return properties->tx_power.value();
 }
@@ skipping 61 matching lines @@
                  weak_ptr_factory_.GetWeakPtr(), error_callback));
 }
 
 void BluetoothDeviceBlueZ::SetPinCode(const std::string& pincode) {
   if (!pairing_.get())
     return;
 
   pairing_->SetPinCode(pincode);
 }
 
-void BluetoothDeviceBlueZ::SetPasskey(uint32 passkey) {
+void BluetoothDeviceBlueZ::SetPasskey(uint32_t passkey) {
   if (!pairing_.get())
     return;
 
   pairing_->SetPasskey(passkey);
 }
 
 void BluetoothDeviceBlueZ::ConfirmPairing() {
   if (!pairing_.get())
     return;
 
@@ skipping 164 matching lines @@
 
   DCHECK(service->object_path() == object_path);
   scoped_ptr<BluetoothGattService> scoped_service =
       gatt_services_.take_and_erase(iter->first);
 
   DCHECK(adapter_);
   adapter()->NotifyGattServiceRemoved(service);
 }
 
 void BluetoothDeviceBlueZ::OnGetConnInfo(const ConnectionInfoCallback& callback,
-                                         int16 rssi,
-                                         int16 transmit_power,
-                                         int16 max_transmit_power) {
+                                         int16_t rssi,
+                                         int16_t transmit_power,
+                                         int16_t max_transmit_power) {
   callback.Run(ConnectionInfo(rssi, transmit_power, max_transmit_power));
 }
 
 void BluetoothDeviceBlueZ::OnGetConnInfoError(
     const ConnectionInfoCallback& callback,
     const std::string& error_name,
     const std::string& error_message) {
   LOG(WARNING) << object_path_.value()
                << ": Failed to get connection info: " << error_name << ": "
                << error_message;
@@ skipping 165 matching lines @@
 void BluetoothDeviceBlueZ::OnForgetError(const ErrorCallback& error_callback,
                                          const std::string& error_name,
                                          const std::string& error_message) {
   LOG(WARNING) << object_path_.value()
                << ": Failed to remove device: " << error_name << ": "
                << error_message;
   error_callback.Run();
 }
 
 }  // namespace bluez