bluetooth: Add characteristicvaluechanged event

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.
 
 // NETWORK_ERROR Note:
 // When a device can't be found in the BluetoothAdapter, that generally
 // indicates that it's gone out of range. We reject with a NetworkError in that
 // case.
 // https://webbluetoothchrome.github.io/web-bluetooth/#dom-bluetoothdevice-connectgatt
 
@@ skipping 195 matching lines @@
   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_HANDLER(BluetoothHostMsg_ReadValue, OnReadValue)
   IPC_MESSAGE_HANDLER(BluetoothHostMsg_WriteValue, OnWriteValue)
   IPC_MESSAGE_HANDLER(BluetoothHostMsg_StartNotifications, OnStartNotifications)
   IPC_MESSAGE_HANDLER(BluetoothHostMsg_StopNotifications, OnStopNotifications)
+  IPC_MESSAGE_HANDLER(BluetoothHostMsg_RegisterCharacteristic,
+                      OnRegisterCharacteristicObject);
+  IPC_MESSAGE_HANDLER(BluetoothHostMsg_UnregisterCharacteristic,
+                      OnUnregisterCharacteristicObject);
   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;
   // Reset the discovery session timer to use the new delay time.
@@ skipping 138 matching lines @@
     if (session->chooser) {
       session->chooser->RemoveDevice(device->GetAddress());
     }
   }
 }
 
 void BluetoothDispatcherHost::GattCharacteristicValueChanged(
     device::BluetoothAdapter* adapter,
     device::BluetoothGattCharacteristic* characteristic,
     const std::vector<uint8>& value) {
-  // TODO(ortuno): Notify renderer the characteristic changed.
-  // http://crbug.com/529560
-  VLOG(1) << "Characteristic updated.";
+  VLOG(1) << "Characteristic updated: " << characteristic->GetIdentifier();
+  auto iter =
+      active_characteristic_threads_.find(characteristic->GetIdentifier());
+
+  if (iter == active_characteristic_threads_.end()) {
+    return;
+  }
+
+  for (int thread_id : iter->second) {
+    // Yield to the event loop so that the event gets dispatched after the
+    // readValue promise resolves.
+    // TODO(ortuno): Make sure the order of fulfulling promises and triggering
+    // events matches the spec and that events don't get lost.
+    // https://crbug.com/543882
+    if (!base::ThreadTaskRunnerHandle::Get()->PostTask(
+            FROM_HERE,
+            base::Bind(&BluetoothDispatcherHost::NotifyActiveCharacteristic,
+                       weak_ptr_on_ui_thread_, thread_id,
+                       characteristic->GetIdentifier(), value))) {
+      LOG(WARNING) << "No TaskRunner.";
+    }
+  }
+}
+
+void BluetoothDispatcherHost::NotifyActiveCharacteristic(
+    int thread_id,
+    const std::string& characteristic_instance_id,
+    const std::vector<uint8>& value) {
+  Send(new BluetoothMsg_CharacteristicValueChanged(
+      thread_id, characteristic_instance_id, value));
 }
 
 void BluetoothDispatcherHost::OnRequestDevice(
     int thread_id,
     int request_id,
     int frame_routing_id,
     const std::vector<BluetoothScanFilter>& filters,
     const std::vector<BluetoothUUID>& optional_services) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   RecordWebBluetoothFunctionCall(UMAWebBluetoothFunction::REQUEST_DEVICE);
@@ skipping 411 matching lines @@
   if (notify_session_iter == characteristic_id_to_notify_session_.end()) {
     Send(new BluetoothMsg_StopNotificationsSuccess(thread_id, request_id));
     return;
   }
   notify_session_iter->second->Stop(
       base::Bind(&BluetoothDispatcherHost::OnStopNotifySession,
                  weak_ptr_factory_.GetWeakPtr(), thread_id, request_id,
                  characteristic_instance_id));
 }
 
+void BluetoothDispatcherHost::OnRegisterCharacteristicObject(
+    int thread_id,
+    const std::string& characteristic_instance_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  active_characteristic_threads_[characteristic_instance_id].insert(thread_id);
+}
+
+void BluetoothDispatcherHost::OnUnregisterCharacteristicObject(
+    int thread_id,
+    const std::string& characteristic_instance_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  auto active_iter =
+      active_characteristic_threads_.find(characteristic_instance_id);
+  if (active_iter != active_characteristic_threads_.end()) {

[palmer, 2015/10/19 19:23:33]

Nit: Could save a level of indentation here by returning if (active_iter| ==
active_characteristic_threads_.end());.

[ortuno, 2015/10/19 20:09:18]

Done.

+    std::set<int>& thread_ids_set = active_iter->second;
+    thread_ids_set.erase(thread_id);
+    if (thread_ids_set.empty()) {
+      active_characteristic_threads_.erase(active_iter);
+    }
+  }
+}
+
 void BluetoothDispatcherHost::OnDiscoverySessionStarted(
     int chooser_id,
     scoped_ptr<device::BluetoothDiscoverySession> discovery_session) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   VLOG(1) << "Started discovery session for " << chooser_id;
   if (RequestDeviceSession* session =
           request_device_sessions_.Lookup(chooser_id)) {
     session->discovery_session = discovery_session.Pass();
 
     // Arrange to stop discovery later.
@@ skipping 266 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   NOTIMPLEMENTED();
 }
 
 void BluetoothDispatcherHost::ShowBluetoothAdapterOffLink() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   NOTIMPLEMENTED();
 }
 
 }  // namespace content