Switch to standard integer types in device/.

device/bluetooth/dbus/fake_bluetooth_gatt_characteristic_client.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/dbus/fake_bluetooth_gatt_characteristic_client.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 161 matching lines @@
       delete delayed;
     }
     return;
   }
 
   base::Closure completed_callback;
   if (!IsHeartRateVisible()) {
     completed_callback =
         base::Bind(error_callback, kUnknownCharacteristicError, "");
   } else {
-    std::vector<uint8> value = {0x06};  // Location is "foot".
+    std::vector<uint8_t> value = {0x06};  // Location is "foot".
     completed_callback = base::Bind(
         &FakeBluetoothGattCharacteristicClient::DelayedReadValueCallback,
         weak_ptr_factory_.GetWeakPtr(), object_path, callback, value);
   }
 
   if (extra_requests_ > 0) {
     action_extra_requests_["ReadValue"] =
         new DelayedCallback(completed_callback, extra_requests_);
     return;
   }
 
   completed_callback.Run();
 }
 
 void FakeBluetoothGattCharacteristicClient::WriteValue(
     const dbus::ObjectPath& object_path,
-    const std::vector<uint8>& value,
+    const std::vector<uint8_t>& value,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   if (!authenticated_) {
     error_callback.Run("org.bluez.Error.NotPaired", "Please login");
     return;
   }
 
   if (!authorized_) {
     error_callback.Run("org.bluez.Error.NotAuthorized", "Authorize first");
     return;
@@ skipping 268 matching lines @@
 void FakeBluetoothGattCharacteristicClient::
     ScheduleHeartRateMeasurementValueChange() {
   if (!IsHeartRateVisible())
     return;
 
   // Don't send updates if the characteristic is not notifying.
   if (!heart_rate_measurement_properties_->notifying.value())
     return;
 
   VLOG(2) << "Updating heart rate value.";
-  std::vector<uint8> measurement = GetHeartRateMeasurementValue();
+  std::vector<uint8_t> measurement = GetHeartRateMeasurementValue();
   heart_rate_measurement_properties_->value.ReplaceValue(measurement);
 
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&FakeBluetoothGattCharacteristicClient::
                                 ScheduleHeartRateMeasurementValueChange,
                             weak_ptr_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(
           kHeartRateMeasurementNotificationIntervalMs));
 }
 
 void FakeBluetoothGattCharacteristicClient::DelayedReadValueCallback(
     const dbus::ObjectPath& object_path,
     const ValueCallback& callback,
     const std::vector<uint8_t>& value) {
   Properties* properties = GetProperties(object_path);
   DCHECK(properties);
 
   properties->value.ReplaceValue(value);
   callback.Run(value);
 }
 
-std::vector<uint8>
+std::vector<uint8_t>
 FakeBluetoothGattCharacteristicClient::GetHeartRateMeasurementValue() {
   // TODO(armansito): We should make sure to properly pack this struct to ensure
   // correct byte alignment and endianness. It doesn't matter too much right now
   // as this is a fake and GCC on Linux seems to do the right thing.
   struct {
-    uint8 flags;
-    uint8 bpm;
-    uint16 energy_expanded;
-    uint16 rr_interval;
+    uint8_t flags;
+    uint8_t bpm;
+    uint16_t energy_expanded;
+    uint16_t rr_interval;
   } value;
 
   // Flags in LSB:     0       11   1 1 000
   //                   |       |    | | |
   // 8-bit bpm format --       |    | | |
   // Sensor contact supported --    | | |
   // Energy expanded field present -- | |
   // RR-Interval values present ------- |
   // Reserved for future use ------------
   value.flags = 0x0;
   value.flags |= (0x03 << 1);
   value.flags |= (0x01 << 3);
   value.flags |= (0x01 << 4);
 
   // Pick a value between 117 bpm and 153 bpm for heart rate.
-  value.bpm = static_cast<uint8>(base::RandInt(117, 153));
+  value.bpm = static_cast<uint8_t>(base::RandInt(117, 153));
 
   // Total calories burned in kJoules since the last reset. Increment this by 1
   // every time. It's fine if it overflows: it becomes 0 when the user resets
   // the heart rate monitor (or pretend that he had a lot of cheeseburgers).
   value.energy_expanded = calories_burned_++;
 
   // Include one RR-Interval value, in seconds.
   value.rr_interval = 60 / value.bpm;
 
   // Return the bytes in an array.
-  uint8* bytes = reinterpret_cast<uint8*>(&value);
-  std::vector<uint8> return_value;
+  uint8_t* bytes = reinterpret_cast<uint8_t*>(&value);
+  std::vector<uint8_t> return_value;
   return_value.assign(bytes, bytes + sizeof(value));
   return return_value;
 }
 
 bool FakeBluetoothGattCharacteristicClient::IsHeartRateVisible() const {
   DCHECK(heart_rate_visible_ != heart_rate_measurement_path_.empty());
   DCHECK(heart_rate_visible_ != body_sensor_location_path_.empty());
   DCHECK(heart_rate_visible_ != heart_rate_control_point_path_.empty());
   DCHECK(heart_rate_visible_ == !!heart_rate_measurement_properties_.get());
   DCHECK(heart_rate_visible_ == !!body_sensor_location_properties_.get());
   DCHECK(heart_rate_visible_ == !!heart_rate_control_point_properties_.get());
   return heart_rate_visible_;
 }
 
 }  // namespace bluez