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

chrome/browser/extensions/api/bluetooth/bluetooth_event_router.cc

 // 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.
 
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_event_router.h"
 
 #include <map>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 92 matching lines @@
 
 bool BluetoothEventRouter::ReleaseSocket(int id) {
   SocketMap::iterator socket_entry = socket_map_.find(id);
   if (socket_entry == socket_map_.end())
     return false;
   socket_map_.erase(socket_entry);
   return true;
 }
 
 void BluetoothEventRouter::AddProfile(
-    const std::string& uuid,
+    const device::BluetoothUUID& uuid,
     const std::string& extension_id,
     device::BluetoothProfile* bluetooth_profile) {
   DCHECK(!HasProfile(uuid));
   ExtensionBluetoothProfileRecord record = { extension_id, bluetooth_profile };
   bluetooth_profile_map_[uuid] = record;
 }
 
-void BluetoothEventRouter::RemoveProfile(const std::string& uuid) {
+void BluetoothEventRouter::RemoveProfile(const device::BluetoothUUID& uuid) {
   BluetoothProfileMap::iterator iter = bluetooth_profile_map_.find(uuid);
   if (iter != bluetooth_profile_map_.end()) {
     device::BluetoothProfile* bluetooth_profile = iter->second.profile;
     bluetooth_profile_map_.erase(iter);
     bluetooth_profile->Unregister();
   }
 }
 
-bool BluetoothEventRouter::HasProfile(const std::string& uuid) const {
+bool BluetoothEventRouter::HasProfile(const device::BluetoothUUID& uuid) const {
   return bluetooth_profile_map_.find(uuid) != bluetooth_profile_map_.end();
 }
 
 void BluetoothEventRouter::StartDiscoverySession(
     device::BluetoothAdapter* adapter,
     const std::string& extension_id,
     const base::Closure& callback,
     const base::Closure& error_callback) {
   if (adapter != adapter_.get()) {
     error_callback.Run();
@@ skipping 28 matching lines @@
   if (iter == discovery_session_map_.end() || !iter->second->IsActive()) {
     DVLOG(1) << "No active discovery session exists for extension.";
     error_callback.Run();
     return;
   }
   device::BluetoothDiscoverySession* session = iter->second;
   session->Stop(callback, error_callback);
 }
 
 device::BluetoothProfile* BluetoothEventRouter::GetProfile(
-    const std::string& uuid) const {
+    const device::BluetoothUUID& uuid) const {
   BluetoothProfileMap::const_iterator iter = bluetooth_profile_map_.find(uuid);
   if (iter != bluetooth_profile_map_.end())
     return iter->second.profile;
 
   return NULL;
 }
 
 scoped_refptr<device::BluetoothSocket> BluetoothEventRouter::GetSocket(int id) {
   SocketMap::iterator socket_entry = socket_map_.find(id);
   if (socket_entry == socket_map_.end())
     return NULL;
   return socket_entry->second.socket;
 }
 
 void BluetoothEventRouter::DispatchConnectionEvent(
     const std::string& extension_id,
-    const std::string& uuid,
+    const device::BluetoothUUID& uuid,
     const device::BluetoothDevice* device,
     scoped_refptr<device::BluetoothSocket> socket) {
   if (!HasProfile(uuid))
     return;
 
   int socket_id = RegisterSocket(extension_id, socket);
   bluetooth::Socket result_socket;
   bluetooth::BluetoothDeviceToApiDevice(*device, &result_socket.device);
-  result_socket.profile.uuid = uuid;
+  result_socket.profile.uuid = uuid.canonical_value();
   result_socket.id = socket_id;
 
   scoped_ptr<base::ListValue> args =
       bluetooth::OnConnection::Create(result_socket);
   scoped_ptr<Event> event(new Event(
       bluetooth::OnConnection::kEventName, args.Pass()));
   ExtensionSystem::Get(browser_context_)
       ->event_router()
       ->DispatchEventToExtension(extension_id, event.Pass());
 }
@@ skipping 262 matching lines @@
     case chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED: {
       extensions::UnloadedExtensionInfo* info =
           content::Details<extensions::UnloadedExtensionInfo>(details).ptr();
       CleanUpForExtension(info->extension->id());
       break;
     }
   }
 }
 
 }  // namespace extensions