bluetooth: Provide more device attributes in requestDevice reply.

content/browser/bluetooth/bluetooth_dispatcher_host.cc

 // 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.
 
 #include "content/browser/bluetooth/bluetooth_dispatcher_host.h"
 
+#include "base/strings/utf_string_conversions.h"
 #include "content/common/bluetooth/bluetooth_messages.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/bluetooth_device.h"
 
 using device::BluetoothAdapter;
 using device::BluetoothAdapterFactory;
 using device::BluetoothDevice;

[Marijn Kruisselbrink, 2015/01/28 21:45:56]

you should probably get rid of this using statement. Now with both
device::BluetoothDevice and content::BluetoothDevice you have to be explicit
everywhere anyway.

[scheib, 2015/01/28 22:23:55]

Done.

 
 namespace content {
 
+const uint32 kUnspecifiedDeviceClass =
+    0x1F00;  // bluetooth.org/en-us/specification/assigned-numbers/baseband
+
 scoped_refptr<BluetoothDispatcherHost> BluetoothDispatcherHost::Create() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Hold a reference to the BluetoothDispatcherHost because the callback below
   // may run and would otherwise release the BluetoothDispatcherHost
   // prematurely.
   scoped_refptr<BluetoothDispatcherHost> host(new BluetoothDispatcherHost());
   if (BluetoothAdapterFactory::IsBluetoothAdapterAvailable())
     BluetoothAdapterFactory::GetAdapter(
         base::Bind(&BluetoothDispatcherHost::set_adapter, host));
@@ skipping 40 matching lines @@
   switch (bluetooth_mock_data_set_) {
     case MockData::NOT_MOCKING: {
       // TODO(scheib): Filter devices by services: crbug.com/440594
       // TODO(scheib): Device selection UI: crbug.com/436280
       // TODO(scheib): Utilize BluetoothAdapter::Observer::DeviceAdded/Removed.
       BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
       if (devices.begin() == devices.end()) {
         Send(new BluetoothMsg_RequestDeviceError(thread_id, request_id,
                                                  BluetoothError::NOT_FOUND));
       } else {
-        BluetoothDevice* device = *devices.begin();
+        device::BluetoothDevice* device = *devices.begin();
+        content::BluetoothDevice device_ipc(
+            device->GetAddress(),         // instance_id
+            device->GetName(),            // name
+            device->GetBluetoothClass(),  // device_class
+            device->GetVendorIDSource(),  // vendor_id_source
+            device->GetVendorID(),        // vendor_id
+            device->GetProductID(),       // product_id
+            device->GetDeviceID(),        // product_version
+            device->IsPaired(),           // paired
+            device->IsConnected(),        // connected
+            content::BluetoothDevice::UUIDsFromBluetoothUUIDs(
+                device->GetUUIDs()));  // uuids
         Send(new BluetoothMsg_RequestDeviceSuccess(thread_id, request_id,
-                                                   device->GetAddress()));
+                                                   device_ipc));
       }
       return;
     }
     case MockData::REJECT: {
       Send(new BluetoothMsg_RequestDeviceError(
           thread_id, request_id, bluetooth_request_device_reject_type_));
       return;
     }
     case MockData::RESOLVE: {
+      content::BluetoothDevice device_ipc(
+          "Empty Mock Device instanceID",                // instance_id
+          base::UTF8ToUTF16("Empty Mock Device name"),   // name
+          kUnspecifiedDeviceClass,                       // device_class
+          device::BluetoothDevice::VENDOR_ID_BLUETOOTH,  // vendor_id_source
+          0xFFFF,                                        // vendor_id
+          1,                                             // product_id
+          2,                                             // product_version
+          true,                                          // paired
+          false,                                         // connected
+          {"00000000-0000-1000-8000-00805F9B34FB",
+           "10000000-0000-1000-8000-00805F9B34FB"});  // uuids
       Send(new BluetoothMsg_RequestDeviceSuccess(thread_id, request_id,
-                                                 "Empty Mock deviceId"));
+                                                 device_ipc));
       return;
     }
   }
   NOTREACHED();
 }
 
 void BluetoothDispatcherHost::OnSetBluetoothMockDataSetForTesting(
     const std::string& name) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (name == "RejectRequestDevice_NotFoundError") {
     bluetooth_mock_data_set_ = MockData::REJECT;
     bluetooth_request_device_reject_type_ = BluetoothError::NOT_FOUND;
   } else if (name == "RejectRequestDevice_SecurityError") {
     bluetooth_mock_data_set_ = MockData::REJECT;
     bluetooth_request_device_reject_type_ = BluetoothError::SECURITY;
   } else if (name == "ResolveRequestDevice_Empty" ||  // TODO(scheib): Remove.
              name == "Single Empty Device") {
     bluetooth_mock_data_set_ = MockData::RESOLVE;
   } else {
     bluetooth_mock_data_set_ = MockData::NOT_MOCKING;
   }
 }
 
 }  // namespace content