bluetooth: Browser-side implementation of getCharacteristic

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"
 #include "device/bluetooth/bluetooth_discovery_session.h"
+#include "device/bluetooth/bluetooth_gatt_characteristic.h"
 #include "device/bluetooth/bluetooth_gatt_service.h"
 
 using device::BluetoothAdapter;
 using device::BluetoothAdapterFactory;
+using device::BluetoothGattCharacteristic;
 using device::BluetoothGattService;
 
 namespace content {
 
 // TODO(ortuno): Once we have a chooser for scanning and the right
 // callback for discovered services we should delete these constants.
 // https://crbug.com/436280 and https://crbug.com/484504
 const int kDelayTime = 5;         // 5 seconds for scanning and discovering
 const int kTestingDelayTime = 0;  // No need to wait during tests
 
@@ skipping 20 matching lines @@
   *thread = BrowserThread::UI;
 }
 
 bool BluetoothDispatcherHost::OnMessageReceived(const IPC::Message& message) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(BluetoothDispatcherHost, message)
   IPC_MESSAGE_HANDLER(BluetoothHostMsg_RequestDevice, OnRequestDevice)
   IPC_MESSAGE_HANDLER(BluetoothHostMsg_ConnectGATT, OnConnectGATT)
   IPC_MESSAGE_HANDLER(BluetoothHostMsg_GetPrimaryService, OnGetPrimaryService)
+  IPC_MESSAGE_HANDLER(BluetoothHostMsg_GetCharacteristic, OnGetCharacteristic)
   IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void BluetoothDispatcherHost::SetBluetoothAdapterForTesting(
     scoped_refptr<device::BluetoothAdapter> mock_adapter) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   current_delay_time_ = kTestingDelayTime;
   set_adapter(mock_adapter.Pass());
@@ skipping 75 matching lines @@
   // For now just wait a fixed time and call OnServiceDiscovered.
   // TODO(ortuno): Use callback once it's implemented http://crbug.com/484504
   BrowserThread::PostDelayedTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&BluetoothDispatcherHost::OnServicesDiscovered,
                  weak_ptr_factory_.GetWeakPtr(), thread_id, request_id,
                  device_instance_id, service_uuid),
       base::TimeDelta::FromSeconds(current_delay_time_));
 }
 
+void BluetoothDispatcherHost::OnGetCharacteristic(
+    int thread_id,
+    int request_id,
+    const std::string& service_instance_id,
+    const std::string& characteristic_uuid) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  // TODO(ortuno): Check if domain has access to device.
+  // https://crbug.com/493459
+  device::BluetoothDevice* device =
+      adapter_->GetDevice(service_to_device_[service_instance_id]);

[Jeffrey Yasskin, 2015/06/02 22:12:28]

Generally avoid using operator[] on a map to check if a key is present: it'll
insert the key into the map, which can make the map grow indefinitely.

Use `auto device_iter = service_to_device_.find(service_instance_id); if
(device_iter == service_to_device_.end()) Send(NETWORK_ERROR);` instead, or, if
only a malicious renderer could send an unknown service_id, kill the renderer
instead.

[ortuno, 2015/06/03 20:27:22]

Done.

+  if (device == NULL) {
+    Send(new BluetoothMsg_GetCharacteristicError(
+        thread_id, request_id, BluetoothError::NETWORK_ERROR));
+    return;
+  }
+  // TODO(ortuno): Check if domain has access to service
+  // http://crbug.com/493460
+  device::BluetoothGattService* service =
+      device->GetGattService(service_instance_id);
+  if (!service) {
+    Send(new BluetoothMsg_GetCharacteristicError(
+        thread_id, request_id, BluetoothError::NETWORK_ERROR));
+    return;
+  }
+
+  for (BluetoothGattCharacteristic* characteristic :
+       service->GetCharacteristics()) {
+    if (characteristic->GetUUID().canonical_value() == characteristic_uuid) {
+      // TODO(ortuno): Use generated instance ID instead.
+      // https://crbug.com/495379
+      Send(new BluetoothMsg_GetCharacteristicSuccess(
+          thread_id, request_id, characteristic->GetIdentifier()));
+      return;
+    }
+  }
+  Send(new BluetoothMsg_GetCharacteristicError(thread_id, request_id,
+                                               BluetoothError::NOT_FOUND));
+}
+
 void BluetoothDispatcherHost::OnDiscoverySessionStarted(
     int thread_id,
     int request_id,
     scoped_ptr<device::BluetoothDiscoverySession> discovery_session) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostDelayedTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&BluetoothDispatcherHost::StopDiscoverySession,
                  weak_ptr_factory_.GetWeakPtr(), thread_id, request_id,
                  base::Passed(&discovery_session)),
@@ skipping 62 matching lines @@
   // from it.
   Send(new BluetoothMsg_ConnectGATTSuccess(thread_id, request_id,
                                            device_instance_id));
 }
 
 void BluetoothDispatcherHost::OnCreateGATTConnectionError(
     int thread_id,
     int request_id,
     const std::string& device_instance_id,
     device::BluetoothDevice::ConnectErrorCode error_code) {
-  // There was an error creating the ATT Bearer so we reject with
+  // There was an error 'creating the ATT Bearer so we reject with

[Jeffrey Yasskin, 2015/06/02 22:12:29]

s/'//

[ortuno, 2015/06/03 20:27:22]

Done.

   // NetworkError.
   // https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothdevice-connectgatt
   Send(new BluetoothMsg_ConnectGATTError(thread_id, request_id,
                                          BluetoothError::NETWORK_ERROR));
 }
 
 void BluetoothDispatcherHost::OnServicesDiscovered(
     int thread_id,
     int request_id,
     const std::string& device_instance_id,
     const std::string& service_uuid) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   device::BluetoothDevice* device = adapter_->GetDevice(device_instance_id);
   if (device == NULL) {
     Send(new BluetoothMsg_GetPrimaryServiceError(
         thread_id, request_id, BluetoothError::NETWORK_ERROR));
     return;
   }
   for (BluetoothGattService* service : device->GetGattServices()) {
     if (service->GetUUID().canonical_value() == service_uuid) {
+      // TODO(ortuno): Use generated instance ID instead.
+      // https://crbug.com/495379
+      const std::string& service_identifier = service->GetIdentifier();
+      service_to_device_.insert(
+          make_pair(service_identifier, device_instance_id));
       Send(new BluetoothMsg_GetPrimaryServiceSuccess(thread_id, request_id,
-                                                     service->GetIdentifier()));
+                                                     service_identifier));
       return;
     }
   }
   Send(new BluetoothMsg_GetPrimaryServiceError(thread_id, request_id,
                                                BluetoothError::NOT_FOUND));
 }
 
 }  // namespace content