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

device/bluetooth/bluetooth_device.h

 // Copyright (c) 2012 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_DEVICE_H_
 #define DEVICE_BLUETOOTH_BLUETOOTH_DEVICE_H_
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/strings/string16.h"
+#include "device/bluetooth/bluetooth_uuid.h"
 
 namespace device {
 
 class BluetoothProfile;
 class BluetoothSocket;
 
 struct BluetoothOutOfBandPairingData;
 
 // BluetoothDevice represents a remote Bluetooth device, both its properties and
 // capabilities as discovered by a local adapter and actions that may be
@@ skipping 138 matching lines @@
     // This method will be called when the Bluetooth daemon requires that a
     // pairing request, usually only incoming, using the just-works model is
     // authorized. The delegate should decide whether the user should confirm
     // or not, then call ConfirmPairing() on the device to confirm the pairing
     // (whether by user action or by default), RejectPairing() on the device to
     // reject or CancelPairing() on the device to cancel authorization for
     // any other reason.
     virtual void AuthorizePairing(BluetoothDevice* device) = 0;
   };
 
-  // Returns true if uuid is in a a valid canonical format
-  // (see utils::CanonicalUuid).
-  static bool IsUUIDValid(const std::string& uuid);
-
   virtual ~BluetoothDevice();
 
   // Returns the Bluetooth class of the device, used by GetDeviceType()
   // and metrics logging,
   virtual uint32 GetBluetoothClass() const = 0;
 
   // Returns the Bluetooth of address the device. This should be used as
   // a unique key to identify the device and copied where needed.
   virtual std::string GetAddress() const = 0;
 
@@ skipping 43 matching lines @@
 
   // Indicates whether there is a call to Connect() ongoing. For this attribute,
   // we consider a call is ongoing if none of the callbacks passed to Connect()
   // were called after the corresponding call to Connect().
   virtual bool IsConnecting() const = 0;
 
   // Returns the set of UUIDs that this device supports. For classic Bluetooth
   // devices this data is collected from both the EIR data and SDP tables,
   // for Low Energy devices this data is collected from AD and GATT primary
   // services, for dual mode devices this may be collected from both./
-  //
-  // All UUIDs are returned in the canonical 128-bit format.
-  typedef std::vector<std::string> UUIDList;
+  typedef std::vector<BluetoothUUID> UUIDList;
   virtual UUIDList GetUUIDs() const = 0;
 
   // The ErrorCallback is used for methods that can fail in which case it
   // is called, in the success case the callback is simply not called.
   typedef base::Callback<void()> ErrorCallback;
 
   // The ConnectErrorCallback is used for methods that can fail with an error,
   // passed back as an error code argument to this callback.
   // In the success case this callback is not called.
   typedef base::Callback<void(enum ConnectErrorCode)> ConnectErrorCallback;
@@ skipping 74 matching lines @@
   // There is no callback for success because this object is often deleted
   // before that callback would be called.
   virtual void Forget(const ErrorCallback& error_callback) = 0;
 
   // Attempts to open a socket to a service matching |uuid| on this device.  If
   // the connection is successful, |callback| is called with a BluetoothSocket.
   // Otherwise |callback| is called with NULL.  The socket is closed as soon as
   // all references to the BluetoothSocket are released.  Note that the
   // BluetoothSocket object can outlive both this BluetoothDevice and the
   // BluetoothAdapter for this device.
-  virtual void ConnectToService(const std::string& service_uuid,
+  virtual void ConnectToService(const BluetoothUUID& service_uuid,
                                 const SocketCallback& callback) = 0;
 
   // Attempts to initiate an outgoing connection to this device for the profile
   // identified by |profile|, on success the profile's connection callback
   // will be called as well as |callback|; on failure |error_callback| will be
   // called.
   virtual void ConnectToProfile(BluetoothProfile* profile,
                                 const base::Closure& callback,
                                 const ErrorCallback& error_callback) = 0;
 
@@ skipping 18 matching lines @@
 
  private:
   // Returns a localized string containing the device's bluetooth address and
   // a device type for display when |name_| is empty.
   base::string16 GetAddressWithLocalizedDeviceTypeName() const;
 };
 
 }  // namespace device
 
 #endif  // DEVICE_BLUETOOTH_BLUETOOTH_DEVICE_H_