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);
+
+  // There are no cases in which a normal renderer could pass

[scheib, 2015/06/04 06:30:48]

Move this comment either just above the 'if' line, or inside the conditional
block.
Reword:
 // A service_instance_id not in the map implies a hostile renderer
 // because a renderer obtains the service id from this class and
 // it will be added to the map at that time.

[ortuno, 2015/06/05 19:37:44]

Done.

+  // a service_instance_id not in our map so we can assume
+  // the renderer is hostile.
+  auto device_iter = service_to_device_.find(service_instance_id);
+  if (device_iter == service_to_device_.end()) {
+    BadMessageReceived();  // Kill the renderer.
+    return;
+  }
+
+  // TODO(ortuno): Check if domain has access to device.
+  // https://crbug.com/493459
+  device::BluetoothDevice* device =
+      adapter_->GetDevice(device_iter->second /* device_instance_id */);
+
+  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 84 matching lines @@
   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(

[scheib, 2015/06/04 06:30:48]

Maybe for paranoia:

auto insert_result = service_to_device_.insert(
    make_pair(service_identifier, device_instance_id));
// DCHECK that insert found no previous entry, or entry value matches:
DCHECK(!insert_result.second 
    || insert_result.first.second == device_instance_id);

[ortuno, 2015/06/05 19:37:44]

If you call getPrimaryService("some uuid") twice the DCHECK would execute.

[scheib, 2015/06/08 17:02:07]

Whoops, overlooked this. Discussed in person too, but for record, this check is
that either it wasn't found in map, or if there was already an entry it checks
that the value stored already matches what we wanted to store.

+          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