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

device/bluetooth/bluetooth_gatt_service.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_SERVICE_H_
 #define DEVICE_BLUETOOTH_GATT_SERVICE_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 BluetoothGattCharacteristic;
 class BluetoothGattDescriptor;
 
 // BluetoothGattService represents a local or remote GATT service. A GATT
 // service is hosted by a peripheral and represents a collection of data in
 // the form of GATT characteristics and a set of included GATT services if this
 // service is what is called "a primary service".
@@ skipping 103 matching lines @@
 
   // Interface for observing changes from a BluetoothGattService. Properties
   // of remote services are received asynchronously. The Observer interface can
   // be used to be notified when the initial values of a service are received
   // as well as when successive changes occur during its life cycle.
   class Observer {
    public:
     // Called when the UUID of |service| have changed.
     virtual void UuidChanged(
         BluetoothGattService* service,
-        const bluetooth_utils::UUID& uuid) {}
+        const BluetoothUUID& uuid) {}
 
     // Called when the services included by |service| have changed.
     virtual void IncludedServicesChanged(
         BluetoothGattService* service,
         const std::vector<BluetoothGattService*>& included_services) {}
 
     // Called when the characteristics that belong to |service| have changed.
     virtual void CharacteristicsChanged(
         BluetoothGattService* service,
         const std::vector<BluetoothGattCharacteristic*>& characteristics) {}
   };
 
   // The ErrorCallback is used by methods to asynchronously report errors.
   typedef base::Callback<void(const std::string&)> ErrorCallback;
 
   // Constructs a BluetoothGattService that can be locally hosted when the local
   // adapter is in the peripheral role. The resulting object can then be made
   // available by calling the "Register" method. This method constructs a
   // service with UUID |uuid|. Whether the constructed service is primary or
   // secondary is determined by |is_primary|. |delegate| is used to send certain
   // peripheral role events. If |delegate| is NULL, then this service will
   // employ a default behavior when responding to read and write requests based
   // on the cached value of its characteristics and descriptors at a given time.
-  static BluetoothGattService* Create(const bluetooth_utils::UUID& uuid,
+  static BluetoothGattService* Create(const BluetoothUUID& uuid,
                                       bool is_primary,
                                       Delegate* delegate);
 
   // The Bluetooth-specific UUID of the service.
-  virtual const bluetooth_utils::UUID& GetUuid() const = 0;
+  virtual const BluetoothUUID& GetUuid() const = 0;
 
   // Returns true, if this service hosted locally. If false, then this service
   // represents a remote GATT service.
   virtual bool IsLocal() const = 0;
 
   // Indicates whether the type of this service is primary or secondary. A
   // primary service describes the primary function of the peripheral that
   // hosts it, while a secondary service only makes sense in the presence of a
   // primary service. A primary service may include other primary or secondary
   // services.
@@ skipping 41 matching lines @@
   BluetoothGattService();
   virtual ~BluetoothGattService();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BluetoothGattService);
 };
 
 }  // namespace device
 
 #endif  // DEVICE_BLUETOOTH_GATT_SERVICE_H_