Switch to standard integer types in components/, part 3 of 4.

components/proximity_auth/ble/bluetooth_low_energy_connection.h

 // Copyright 2015 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.
 
 #ifndef COMPONENTS_PROXIMITY_AUTH_BLE_BLUETOOTH_LOW_ENERGY_CONNECTION_H_
 #define COMPONENTS_PROXIMITY_AUTH_BLE_BLUETOOTH_LOW_ENERGY_CONNECTION_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <queue>
 #include <string>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
 #include "components/proximity_auth/ble/bluetooth_low_energy_characteristics_finder.h"
 #include "components/proximity_auth/ble/fake_wire_message.h"
@@ skipping 34 matching lines @@
 //                              |
 //    Read kInvitationResponseSignal from Reader Characteristic
 //                              |
 //                              |
 //                              |
 //           Proximity Auth Connection Established
 class BluetoothLowEnergyConnection : public Connection,
                                      public device::BluetoothAdapter::Observer {
  public:
   // Signals sent to the remote device to indicate connection related events.
-  enum class ControlSignal : uint32 {
+  enum class ControlSignal : uint32_t {
     kInviteToConnectSignal = 0,
     kInvitationResponseSignal = 1,
     kSendSignal = 2,
     kDisconnectSignal = 3,
   };
 
   // The sub-state of a proximity_auth::BluetoothLowEnergyConnection class
   // extends the IN_PROGRESS state of proximity_auth::Connection::Status.
   enum class SubStatus {
     DISCONNECTED,
@@ skipping 44 matching lines @@
   void SendMessageImpl(scoped_ptr<WireMessage> message) override;
 
   // device::BluetoothAdapter::Observer:
   void DeviceChanged(device::BluetoothAdapter* adapter,
                      device::BluetoothDevice* device) override;
   void DeviceRemoved(device::BluetoothAdapter* adapter,
                      device::BluetoothDevice* device) override;
   void GattCharacteristicValueChanged(
       device::BluetoothAdapter* adapter,
       device::BluetoothGattCharacteristic* characteristic,
-      const std::vector<uint8>& value) override;
+      const std::vector<uint8_t>& value) override;
 
  private:
   // Represents a request to write |value| to a some characteristic.
   // |is_last_write_for_wire_messsage| indicates whether this request
   // corresponds to the last write request for some wire message.
   // A WireMessage corresponds to exactly two WriteRequest: the first containing
   // a kSendSignal + the size of the WireMessage, and the second containing a
   // SendStatusSignal + the serialized WireMessage.
   struct WriteRequest {
-    WriteRequest(const std::vector<uint8>& val, bool flag);
+    WriteRequest(const std::vector<uint8_t>& val, bool flag);
     ~WriteRequest();
 
-    std::vector<uint8> value;
+    std::vector<uint8_t> value;
     bool is_last_write_for_wire_message;
     int number_of_failed_attempts;
   };
 
   // Creates the GATT connection with |remote_device|.
   void CreateGattConnection();
 
   // Called when a GATT connection is created.
   void OnGattConnectionCreated(
       scoped_ptr<device::BluetoothGattConnection> gatt_connection);
@@ skipping 57 matching lines @@
   void OnRemoteCharacteristicWritten(bool run_did_send_message_callback);
 
   // Called when there is an error writing to the remote characteristic
   // |to_peripheral_char_|.
   void OnWriteRemoteCharacteristicError(
       bool run_did_send_message_callback,
       device::BluetoothGattService::GattErrorCode error);
 
   // Builds the value to be written on |to_peripheral_char_|. The value
   // corresponds to |signal| concatenated with |payload|.
-  WriteRequest BuildWriteRequest(const std::vector<uint8>& signal,
-                                 const std::vector<uint8>& bytes,
+  WriteRequest BuildWriteRequest(const std::vector<uint8_t>& signal,
+                                 const std::vector<uint8_t>& bytes,
                                  bool is_last_message_for_wire_message);
 
   // Prints the time elapsed since |Connect()| was called.
   void PrintTimeElapsed();
 
   // Returns the device corresponding to |remote_device_address_|.
   device::BluetoothDevice* GetRemoteDevice();
 
   // Returns the service corresponding to |remote_service_| in the current
   // device.
   device::BluetoothGattService* GetRemoteService();
 
   // Returns the characteristic corresponding to |identifier| in the current
   // service.
   device::BluetoothGattCharacteristic* GetGattCharacteristic(
       const std::string& identifier);
 
-  // Convert the first 4 bytes from a byte vector to a uint32.
-  uint32 ToUint32(const std::vector<uint8>& bytes);
+  // Convert the first 4 bytes from a byte vector to a uint32_t.
+  uint32_t ToUint32(const std::vector<uint8_t>& bytes);
 
-  // Convert an uint32 to a byte vector.
-  const std::vector<uint8> ToByteVector(uint32 value);
+  // Convert an uint32_t to a byte vector.
+  const std::vector<uint8_t> ToByteVector(uint32_t value);
 
   // The Bluetooth adapter over which the Bluetooth connection will be made.
   scoped_refptr<device::BluetoothAdapter> adapter_;
 
   // Remote service the |gatt_connection_| was established with.
   RemoteAttribute remote_service_;
 
   // Characteristic used to send data to the remote device.
   RemoteAttribute to_peripheral_char_;
 
@@ skipping 48 matching lines @@
   base::TimeTicks start_time_;
 
   base::WeakPtrFactory<BluetoothLowEnergyConnection> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothLowEnergyConnection);
 };
 
 }  // namespace proximity_auth
 
 #endif  // COMPONENTS_PROXIMITY_AUTH_BLE_BLUETOOTH_LOW_ENERGY_CONNECTION_H_