[Bluetooth] Clean up code to extract a UUID from SDP data.

device/bluetooth/bluetooth_device_mac.mm

 // Copyright 2013 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.
 
 #include "device/bluetooth/bluetooth_device_mac.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/hash.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
-#include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "device/bluetooth/bluetooth_profile_mac.h"
 #include "device/bluetooth/bluetooth_socket_mac.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 
 // Replicate specific 10.7 SDK declarations for building with prior SDKs.
 #if !defined(MAC_OS_X_VERSION_10_7) || \
     MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_7
 
 @interface IOBluetoothDevice (LionSDKDeclarations)
 - (NSString*)addressString;
 - (unsigned int)classOfDevice;
 - (BluetoothConnectionHandle)connectionHandle;
 - (BluetoothHCIRSSIValue)rawRSSI;
 - (NSArray*)services;
 @end
 
 #endif  // MAC_OS_X_VERSION_10_7
 
 // Undocumented API for accessing the Bluetooth transmit power level.
 // Similar to the API defined here [ http://goo.gl/20Q5vE ].
 @interface IOBluetoothHostController (UndocumentedAPI)
 - (IOReturn)
     BluetoothHCIReadTransmitPowerLevel:(BluetoothConnectionHandle)connection
                                 inType:(BluetoothHCITransmitPowerLevelType)type
                  outTransmitPowerLevel:(BluetoothHCITransmitPowerLevel*)level;
 @end
 
+namespace device {
 namespace {
 
-void ExtractUuid(IOBluetoothSDPDataElement* service_class_data,
-                 std::string* uuid) {
+// Returns the first (should be, only) UUID contained within the
+// |service_class_data|. Returns an invalid (empty) UUID if none is found.
+BluetoothUUID ExtractUuid(IOBluetoothSDPDataElement* service_class_data) {
   NSArray* inner_elements = [service_class_data getArrayValue];
   IOBluetoothSDPUUID* sdp_uuid = nil;
   for (IOBluetoothSDPDataElement* inner_element in inner_elements) {
     if ([inner_element getTypeDescriptor] == kBluetoothSDPDataElementTypeUUID) {
       sdp_uuid = [[inner_element getUUIDValue] getUUIDWithLength:16];
       break;
     }
   }
-  if (sdp_uuid != nil) {
-    const uint8* uuid_bytes = reinterpret_cast<const uint8*>([sdp_uuid bytes]);
-    *uuid = base::StringPrintf(
-        "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
-        uuid_bytes[0], uuid_bytes[1], uuid_bytes[2], uuid_bytes[3],
-        uuid_bytes[4], uuid_bytes[5], uuid_bytes[6], uuid_bytes[7],
-        uuid_bytes[8], uuid_bytes[9], uuid_bytes[10], uuid_bytes[11],
-        uuid_bytes[12], uuid_bytes[13], uuid_bytes[14], uuid_bytes[15]);
-  }
+
+  if (!sdp_uuid)
+    return BluetoothUUID();
+
+  const uint8* uuid_bytes = reinterpret_cast<const uint8*>([sdp_uuid bytes]);
+  std::string uuid_str = base::HexEncode(uuid_bytes, 16);
+  DCHECK_EQ(uuid_str.size(), 32U);
+  uuid_str.insert(8, "-");
+  uuid_str.insert(13, "-");
+  uuid_str.insert(18, "-");
+  uuid_str.insert(23, "-");
+  return BluetoothUUID(uuid_str);
 }
 
 }  // namespace
 
-namespace device {
-
 BluetoothDeviceMac::BluetoothDeviceMac(IOBluetoothDevice* device)
     : device_([device retain]) {
 }
 
 BluetoothDeviceMac::~BluetoothDeviceMac() {
 }
 
 void BluetoothDeviceMac::AddObserver(
     device::BluetoothDevice::Observer* observer) {
   DCHECK(observer);
@@ skipping 70 matching lines @@
   return false;
 }
 
 bool BluetoothDeviceMac::IsConnecting() const {
   return false;
 }
 
 BluetoothDevice::UUIDList BluetoothDeviceMac::GetUUIDs() const {
   UUIDList uuids;
   for (IOBluetoothSDPServiceRecord* service_record in [device_ services]) {
-    const BluetoothSDPServiceAttributeID service_class_id = 1;
     IOBluetoothSDPDataElement* service_class_data =
-        [service_record getAttributeDataElement:service_class_id];
+        [service_record getAttributeDataElement:
+            kBluetoothSDPAttributeIdentifierServiceClassIDList];
     if ([service_class_data getTypeDescriptor] ==
             kBluetoothSDPDataElementTypeDataElementSequence) {
-      std::string uuid_str;
-      ExtractUuid(service_class_data, &uuid_str);
-      uuids.push_back(BluetoothUUID(uuid_str));
+      BluetoothUUID uuid = ExtractUuid(service_class_data);
+      if (uuid.IsValid())
+        uuids.push_back(uuid);
     }
   }
   return uuids;
 }
 
 bool BluetoothDeviceMac::ExpectingPinCode() const {
   NOTIMPLEMENTED();
   return false;
 }
 
@@ skipping 86 matching lines @@
 
   return power_level;
 }
 
 // static
 std::string BluetoothDeviceMac::GetDeviceAddress(IOBluetoothDevice* device) {
   return CanonicalizeAddress(base::SysNSStringToUTF8([device addressString]));
 }
 
 }  // namespace device