Switch to standard integer types in device/.

device/bluetooth/bluetooth_gatt_descriptor.h

 // 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.
 
 #ifndef DEVICE_BLUETOOTH_BLUETOOTH_GATT_DESCRIPTOR_H_
 #define DEVICE_BLUETOOTH_BLUETOOTH_GATT_DESCRIPTOR_H_
 
+#include <stdint.h>
+
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/callback.h"
+#include "base/macros.h"
 #include "device/bluetooth/bluetooth_export.h"
 #include "device/bluetooth/bluetooth_gatt_characteristic.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 
 namespace device {
 
 // BluetoothGattDescriptor represents a local or remote GATT characteristic
 // descriptor. A GATT characteristic descriptor provides further information
 // about a characteristic's value. They can be used to describe the
 // characteristic's features or to control certain behaviors.
 class DEVICE_BLUETOOTH_EXPORT BluetoothGattDescriptor {
  public:
   // The ErrorCallback is used by methods to asynchronously report errors.
   typedef base::Callback<void(BluetoothGattService::GattErrorCode)>
       ErrorCallback;
 
   // The ValueCallback is used to return the value of a remote characteristic
   // descriptor upon a read request.
-  typedef base::Callback<void(const std::vector<uint8>&)> ValueCallback;
+  typedef base::Callback<void(const std::vector<uint8_t>&)> ValueCallback;
 
   // The Bluetooth Specification declares several predefined descriptors that
   // profiles can use. The following are definitions for the list of UUIDs
   // and descriptions of the characteristic descriptors that they represent.
   // Possible values for and further information on each descriptor can be found
   // in Core v4.0, Volume 3, Part G, Section 3.3.3. All of these descriptors are
   // optional and may not be present for a given characteristic.
 
   // The "Characteristic Extended Properties" descriptor. This defines
   // additional "Characteristic Properties" which cannot fit into the allocated
@@ skipping 84 matching lines @@
   // an instance of BluetoothGattService::Delegate has been provided to the
   // associated BluetoothGattService instance, in which case the delegate will
   // handle the read and write requests.
   //
   // Currently, only custom UUIDs, |kCharacteristicDescriptionUuid|, and
   // |kCharacteristicPresentationFormat| are supported for locally hosted
   // descriptors. This method will return NULL if |uuid| is any one of the
   // unsupported predefined descriptor UUIDs.
   static BluetoothGattDescriptor* Create(
       const BluetoothUUID& uuid,
-      const std::vector<uint8>& value,
+      const std::vector<uint8_t>& value,
       BluetoothGattCharacteristic::Permissions permissions);
 
   // Identifier used to uniquely identify a GATT descriptor object. This is
   // different from the descriptor UUID: while multiple descriptors with the
   // same UUID can exist on a Bluetooth device, the identifier returned from
   // this method is unique among all descriptors on the adapter. The contents of
   // the identifier are platform specific.
   virtual std::string GetIdentifier() const = 0;
 
   // The Bluetooth-specific UUID of the characteristic descriptor.
   virtual BluetoothUUID GetUUID() const = 0;
 
   // Returns true, if this characteristic descriptor is hosted locally. If
   // false, then this instance represents a remote descriptor.
   virtual bool IsLocal() const = 0;
 
   // Returns the value of the descriptor. For remote descriptors, this is the
   // most recently cached value of the remote descriptor. For local descriptors
   // this is the most recently updated value or the value retrieved from the
   // delegate.
-  virtual const std::vector<uint8>& GetValue() const = 0;
+  virtual const std::vector<uint8_t>& GetValue() const = 0;
 
   // Returns a pointer to the GATT characteristic that this characteristic
   // descriptor belongs to.
   virtual BluetoothGattCharacteristic* GetCharacteristic() const = 0;
 
   // Returns the bitmask of characteristic descriptor attribute permissions.
   virtual BluetoothGattCharacteristic::Permissions GetPermissions() const = 0;
 
   // Sends a read request to a remote characteristic descriptor to read its
   // value. |callback| is called to return the read value on success and
   // |error_callback| is called for failures.
   virtual void ReadRemoteDescriptor(const ValueCallback& callback,
                                     const ErrorCallback& error_callback) = 0;
 
   // Sends a write request to a remote characteristic descriptor, to modify the
   // value of the descriptor with the new value |new_value|. |callback| is
   // called to signal success and |error_callback| for failures. This method
   // only applies to remote descriptors and will fail for those that are locally
   // hosted.
-  virtual void WriteRemoteDescriptor(
-      const std::vector<uint8>& new_value,
-      const base::Closure& callback,
-      const ErrorCallback& error_callback) = 0;
+  virtual void WriteRemoteDescriptor(const std::vector<uint8_t>& new_value,
+                                     const base::Closure& callback,
+                                     const ErrorCallback& error_callback) = 0;
 
  protected:
   BluetoothGattDescriptor();
   virtual ~BluetoothGattDescriptor();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BluetoothGattDescriptor);
 };
 
 }  // namespace device
 
 #endif  // DEVICE_BLUETOOTH_BLUETOOTH_GATT_DESCRIPTOR_H_