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

device/bluetooth/bluetooth_profile_chromeos.cc

 // 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_profile_chromeos.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 51 matching lines @@
   DCHECK(object_path_.value().empty());
   DCHECK(profile_.get() == NULL);
 
   if (adapter_.get()) {
     adapter_->RemoveObserver(this);
     adapter_ = NULL;
   }
 }
 
 void BluetoothProfileChromeOS::Init(
-    const std::string& uuid,
+    const device::BluetoothUUID& uuid,
     const device::BluetoothProfile::Options& options,
     const ProfileCallback& callback) {
   DCHECK(object_path_.value().empty());
   DCHECK(profile_.get() == NULL);
 
-  if (!BluetoothDevice::IsUUIDValid(uuid)) {
+  if (!uuid.IsValid()) {
     callback.Run(NULL);
     return;
   }
 
   uuid_ = uuid;
 
   options_.name = options.name;
-  options_.service = uuid;
+  options_.service = uuid.canonical_value();
   options_.channel = options.channel;
   options_.psm = options.psm;
   options_.require_authentication = options.require_authentication;
   options_.require_authorization = options.require_authorization;
   options_.auto_connect = options.auto_connect;
   options_.version = options.version;
   options_.features = options.features;
 
   // The object path is relatively meaningless, but has to be unique, so we
   // use the UUID of the profile.
   std::string uuid_path;
-  base::ReplaceChars(uuid, ":-", "_", &uuid_path);
+  base::ReplaceChars(uuid.canonical_value(), ":-", "_", &uuid_path);
 
   object_path_ = dbus::ObjectPath("/org/chromium/bluetooth_profile/" +
                                   uuid_path);
 
   dbus::Bus* system_bus = DBusThreadManager::Get()->GetSystemBus();
   profile_.reset(BluetoothProfileServiceProvider::Create(
       system_bus, object_path_, this));
   DCHECK(profile_.get());
 
   // Now the profile object is registered we need an adapter to register it
@@ skipping 27 matching lines @@
 
 void BluetoothProfileChromeOS::AdapterPresentChanged(BluetoothAdapter* adapter,
                                                      bool present) {
   if (!present)
     return;
 
   VLOG(1) << object_path_.value() << ": Register profile";
   DBusThreadManager::Get()->GetBluetoothProfileManagerClient()->
       RegisterProfile(
           object_path_,
-          uuid_,
+          uuid_.canonical_value(),
           options_,
           base::Bind(&BluetoothProfileChromeOS::OnInternalRegisterProfile,
                      weak_ptr_factory_.GetWeakPtr()),
           base::Bind(&BluetoothProfileChromeOS::OnInternalRegisterProfileError,
                      weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothProfileChromeOS::OnGetAdapter(
     const ProfileCallback& callback,
     scoped_refptr<device::BluetoothAdapter> adapter) {
   DCHECK(!adapter_.get());
   adapter_ = adapter;
   adapter_->AddObserver(this);
 
   VLOG(1) << object_path_.value() << ": Register profile";
   DBusThreadManager::Get()->GetBluetoothProfileManagerClient()->
       RegisterProfile(
           object_path_,
-          uuid_,
+          uuid_.canonical_value(),
           options_,
           base::Bind(&BluetoothProfileChromeOS::OnRegisterProfile,
                      weak_ptr_factory_.GetWeakPtr(),
                      callback),
           base::Bind(&BluetoothProfileChromeOS::OnRegisterProfileError,
                      weak_ptr_factory_.GetWeakPtr(),
                      callback));
 }
 
 void BluetoothProfileChromeOS::Release() {
@@ skipping 111 matching lines @@
       static_cast<BluetoothAdapterChromeOS*>(adapter_.get())->
           GetDeviceWithPath(device_path);
   DCHECK(device);
 
   scoped_refptr<BluetoothSocket> socket((
       BluetoothSocketChromeOS::Create(fd.get())));
   connection_callback_.Run(device, socket);
 }
 
 }  // namespace chromeos