device/bluetooth: Rename device::bluetooth_utils::UUID to device::BluetoothUUID

device/bluetooth/bluetooth_gatt_characteristic.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_GATT_CHARACTERISTIC_H_
 #define DEVICE_BLUETOOTH_GATT_CHARACTERISTIC_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
-#include "device/bluetooth/bluetooth_utils.h"
+#include "device/bluetooth/bluetooth_uuid.h"
 
 namespace device {
 
 class BluetoothGattDescriptor;
 class BluetoothGattService;
 
 // BluetoothGattCharacteristic represents a local or remote GATT characteristic.
 // A GATT characteristic is a basic data element used to construct a GATT
 // service. Hence, instances of a BluetoothGattCharacteristic are associated
 // with a BluetoothGattService. There are two ways in which this class is used:
@@ skipping 50 matching lines @@
   // Interface for observing changes from a BluetoothGattCharacteristic.
   // Properties of remote characteristics are received asynchonously. The
   // Observer interface can be used to be notified when the initial values of a
   // characteristic are received as well as when successive changes occur during
   // its life cycle.
   class Observer {
    public:
     // Called when the UUID of |characteristic| has changed.
     virtual void UuidChanged(
         BluetoothGattCharacteristic* characteristic,
-        const bluetooth_utils::UUID& uuid) {}
+        const BluetoothUUID& uuid) {}
 
     // Called when the current value of |characteristic| has changed.
     virtual void ValueChanged(
         BluetoothGattCharacteristic* characteristic,
         const std::vector<uint8>& value) {}
 
     // Called when the descriptors that are associated with |characteristic|
     // have changed.
     virtual void DescriptorsChanged(
         BluetoothGattCharacteristic* characteristic,
@@ skipping 24 matching lines @@
   // for write requests by default, unless an instance of
   // BluetoothGattService::Delegate has been provided to the associated
   // BluetoothGattService instance, in which case the delegate will handle read
   // and write requests.
   //
   // NOTE: Don't explicitly set |kPropertyExtendedProperties| in |properties|.
   // Instead, create and add a BluetoothGattDescriptor that represents the
   // "Characteristic Extended Properties" descriptor and this will automatically
   // set the correspoding bit in the characteristic's properties field. If
   // |properties| has |kPropertyExtendedProperties| set, it will be ignored.
-  static BluetoothGattCharacteristic* Create(const bluetooth_utils::UUID& uuid,
+  static BluetoothGattCharacteristic* Create(const BluetoothUUID& uuid,
                                              const std::vector<uint8>& value,
                                              Properties properties,
                                              Permissions permissions);
 
   // The Bluetooth-specific UUID of the characteristic.
-  virtual const bluetooth_utils::UUID& GetUuid() const = 0;
+  virtual const BluetoothUUID& GetUuid() const = 0;
 
   // Returns true, if this characteristic is hosted locally. If false, then this
   // instance represents a remote GATT characteristic.
   virtual bool IsLocal() const = 0;
 
   // Returns a pointer to the GATT service this characteristic belongs to.
   virtual const BluetoothGattService* GetService() const = 0;
 
   // Returns the list of GATT characteristic descriptors that provide more
   // information about this characteristic.
@@ skipping 41 matching lines @@
   BluetoothGattCharacteristic();
   virtual ~BluetoothGattCharacteristic();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BluetoothGattCharacteristic);
 };
 
 }  // namespace device
 
 #endif  // DEVICE_BLUETOOTH_GATT_CHARACTERISTIC_H_