bluetooth: Subscribe to notifications

content/renderer/bluetooth/bluetooth_dispatcher.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/renderer/bluetooth/bluetooth_dispatcher.h"
 
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/common/bluetooth/bluetooth_messages.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 #include "third_party/WebKit/public/platform/WebPassOwnPtr.h"
 #include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothDevice.h"
 #include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothError.h"
 #include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothGATTCharacteristic.h"
+#include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothGATTCharacteristicDelegate.h"
 #include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothGATTRemoteServer.h"
 #include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothGATTService.h"
 #include "third_party/WebKit/public/platform/modules/bluetooth/WebRequestDeviceOptions.h"
 
 using blink::WebBluetoothConnectGATTCallbacks;
 using blink::WebBluetoothDevice;
 using blink::WebBluetoothError;
 using blink::WebBluetoothGATTCharacteristic;
 using blink::WebBluetoothGATTRemoteServer;
 using blink::WebBluetoothGATTService;
@@ skipping 27 matching lines @@
       : service_instance_id(service_instance_id),
         characteristic_uuid(characteristic_uuid),
         callbacks(callbacks) {}
   ~BluetoothCharacteristicRequest() {}
 
   blink::WebString service_instance_id;
   blink::WebString characteristic_uuid;
   scoped_ptr<blink::WebBluetoothGetCharacteristicCallbacks> callbacks;
 };
 
+struct BluetoothNotificationsRequest {
+  BluetoothNotificationsRequest(
+      blink::WebString characteristic_instance_id,
+      blink::WebBluetoothGATTCharacteristicDelegate* delegate,
+      blink::WebBluetoothNotificationsCallbacks* callbacks)
+      : characteristic_instance_id(characteristic_instance_id),
+        delegate(delegate),
+        callbacks(callbacks) {}
+  ~BluetoothNotificationsRequest() {}
+
+  blink::WebString characteristic_instance_id;
+  // Note that the delegate is owned by the execution context on the blink
+  // side which can destroy the delegate at any point. Since the delegate
+  // implements ActiveDOMObject we do get notify when it's being destroyed,
+  // so we can remove any references to it.
+  blink::WebBluetoothGATTCharacteristicDelegate* delegate;
+  scoped_ptr<blink::WebBluetoothNotificationsCallbacks> callbacks;
+};
+
 namespace content {
 
 namespace {
 
 base::LazyInstance<base::ThreadLocalPointer<void>>::Leaky g_dispatcher_tls =
     LAZY_INSTANCE_INITIALIZER;
 
 void* const kHasBeenDeleted = reinterpret_cast<void*>(0x1);
 
 int CurrentWorkerId() {
@@ skipping 61 matching lines @@
   IPC_MESSAGE_HANDLER(BluetoothMsg_GetCharacteristicError,
                       OnGetCharacteristicError);
   IPC_MESSAGE_HANDLER(BluetoothMsg_ReadCharacteristicValueSuccess,
                       OnReadValueSuccess);
   IPC_MESSAGE_HANDLER(BluetoothMsg_ReadCharacteristicValueError,
                       OnReadValueError);
   IPC_MESSAGE_HANDLER(BluetoothMsg_WriteCharacteristicValueSuccess,
                       OnWriteValueSuccess);
   IPC_MESSAGE_HANDLER(BluetoothMsg_WriteCharacteristicValueError,
                       OnWriteValueError);
+  IPC_MESSAGE_HANDLER(BluetoothMsg_StartNotificationsSuccess,
+                      OnStartNotificationsSuccess)
+  IPC_MESSAGE_HANDLER(BluetoothMsg_StartNotificationsError,
+                      OnStartNotificationsError)
+  IPC_MESSAGE_HANDLER(BluetoothMsg_StopNotificationsSuccess,
+                      OnStopNotificationsSuccess)
   IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled) << "Unhandled message:" << msg.type();
 }
 
 void BluetoothDispatcher::requestDevice(
     int frame_routing_id,
     const WebRequestDeviceOptions& options,
     blink::WebBluetoothRequestDeviceCallbacks* callbacks) {
   int request_id = pending_requests_.Add(callbacks);
@@ skipping 62 matching lines @@
 void BluetoothDispatcher::writeValue(
     const blink::WebString& characteristic_instance_id,
     const std::vector<uint8_t>& value,
     blink::WebBluetoothWriteValueCallbacks* callbacks) {
   int request_id = pending_write_value_requests_.Add(callbacks);
 
   Send(new BluetoothHostMsg_WriteValue(
       CurrentWorkerId(), request_id, characteristic_instance_id.utf8(), value));
 }
 
+void BluetoothDispatcher::startNotifications(
+    const blink::WebString& characteristic_instance_id,
+    blink::WebBluetoothGATTCharacteristicDelegate* delegate,
+    blink::WebBluetoothNotificationsCallbacks* callbacks) {
+  // If an object is already subcribed to notifications from the characteristic,
+  // no need to subscribe to the dispatcher host again.
+  if (HasActiveCharacteristicNotification(characteristic_instance_id)) {
+    AddToActiveNotificationsMap(characteristic_instance_id, delegate);
+    callbacks->onSuccess();
+    return;
+  }
+
+  int request_id = pending_start_notifications_requests_.Add(
+      new BluetoothNotificationsRequest(characteristic_instance_id, delegate,
+                                        callbacks));
+
+  Send(new BluetoothHostMsg_StartNotifications(
+      CurrentWorkerId(), request_id, characteristic_instance_id.utf8()));
+}
+
+void BluetoothDispatcher::stopNotifications(
+    const blink::WebString& characteristic_instance_id,
+    blink::WebBluetoothGATTCharacteristicDelegate* delegate,
+    blink::WebBluetoothNotificationsCallbacks* callbacks) {
+  // If this is not an active characteristic then no need to unsubscribe.
+  if (!HasActiveCharacteristicNotification(characteristic_instance_id)) {
+    callbacks->onSuccess();
+    return;
+  }
+
+  if (WillBeActiveNotificationWhenRemoved(characteristic_instance_id,
+                                          delegate)) {
+    RemoveFromActiveNotificationsMap(characteristic_instance_id, delegate);
+    callbacks->onSuccess();
+    return;
+  }
+
+  int request_id = pending_stop_notifications_requests_.Add(
+      new BluetoothNotificationsRequest(characteristic_instance_id, delegate,
+                                        callbacks));
+
+  Send(new BluetoothHostMsg_StopNotifications(
+      CurrentWorkerId(), request_id, characteristic_instance_id.utf8()));
+}
+
+void BluetoothDispatcher::characteristicDelegateRemoved(
+    const blink::WebString& characteristic_instance_id,
+    blink::WebBluetoothGATTCharacteristicDelegate* delegate) {
+  RemoveFromActiveNotificationsMap(characteristic_instance_id, delegate);
+
+  // If the characteristic is still active no need to unsubscribe.
+  if (HasActiveCharacteristicNotification(characteristic_instance_id)) {
+    return;
+  }
+
+  // There could be a request pending on a delegate so we need to check
+  // the requests map. We ignore the stop request since we don't use
+  // the delegate in those.
+  for (IDMap<BluetoothNotificationsRequest, IDMapOwnPointer>::iterator iter(
+           &pending_start_notifications_requests_);
+       !iter.IsAtEnd(); iter.Advance()) {
+    iter.GetCurrentValue()->delegate = nullptr;
+  }
+}
+
 void BluetoothDispatcher::WillStopCurrentWorkerThread() {
   delete this;
 }
 
+bool BluetoothDispatcher::HasActiveCharacteristicNotification(
+    const blink::WebString& characteristic_instance_id) {
+  auto char_iter = active_characteristic_notifications.find(
+      characteristic_instance_id.utf8());
+
+  // An active characteristic will point to a set of delegates.
+  if (char_iter == active_characteristic_notifications.end()) {
+    return false;
+  }
+
+  return true;
+}
+
+void BluetoothDispatcher::AddToActiveNotificationsMap(
+    const blink::WebString& characteristic_instance_id,
+    blink::WebBluetoothGATTCharacteristicDelegate* delegate) {
+  auto char_iter = active_characteristic_notifications.find(
+      characteristic_instance_id.utf8());
+
+  // First object that subscribes to notifications for the characteristic.
+  if (char_iter == active_characteristic_notifications.end()) {
+    std::set<blink::WebBluetoothGATTCharacteristicDelegate*> delegates;
+    delegates.insert(delegate);
+    active_characteristic_notifications.insert(
+        std::make_pair(characteristic_instance_id.utf8(), delegates));
+    return;
+  }
+  // Otherwise add to already existing set.
+  char_iter->second.insert(delegate);
+}
+
+bool BluetoothDispatcher::WillBeActiveNotificationWhenRemoved(
+    const blink::WebString& characteristic_instance_id,
+    blink::WebBluetoothGATTCharacteristicDelegate* delegate) {
+  auto char_iter = active_characteristic_notifications.find(
+      characteristic_instance_id.utf8());
+
+  // The characteristic will point to a set as long as there is at least
+  // one delegate subscribed to notifications.
+  if (char_iter == active_characteristic_notifications.end()) {
+    return false;
+  }
+  const std::set<blink::WebBluetoothGATTCharacteristicDelegate*>& delegate_set =
+      char_iter->second;
+  // If we find the delegate and the size of the set is one then removing
+  // the delegate will make the notification inactive.
+  if (delegate_set.find(delegate) != delegate_set.end() &&
+      delegate_set.size() == 1) {
+    return false;
+  }
+  return true;
+}
+
+void BluetoothDispatcher::RemoveFromActiveNotificationsMap(
+    const blink::WebString& characteristic_instance_id,
+    blink::WebBluetoothGATTCharacteristicDelegate* delegate) {
+  auto char_iter = active_characteristic_notifications.find(
+      characteristic_instance_id.utf8());
+
+  if (char_iter == active_characteristic_notifications.end()) {
+    return;
+  }
+
+  char_iter->second.erase(delegate);
+
+  if (char_iter->second.size() == 0) {
+    active_characteristic_notifications.erase(char_iter);
+  }
+}
+
 void BluetoothDispatcher::OnRequestDeviceSuccess(
     int thread_id,
     int request_id,
     const BluetoothDevice& device) {
   DCHECK(pending_requests_.Lookup(request_id)) << request_id;
 
   WebVector<WebString> uuids(device.uuids.size());
   for (size_t i = 0; i < device.uuids.size(); ++i)
     uuids[i] = WebString::fromUTF8(device.uuids[i].c_str());
 
@@ skipping 137 matching lines @@
                                             int request_id,
                                             WebBluetoothError error) {
   DCHECK(pending_write_value_requests_.Lookup(request_id)) << request_id;
 
   pending_write_value_requests_.Lookup(request_id)
       ->onError(WebBluetoothError(error));
 
   pending_write_value_requests_.Remove(request_id);
 }
 
+void BluetoothDispatcher::OnStartNotificationsSuccess(int thread_id,
+                                                      int request_id) {
+  DCHECK(pending_start_notifications_requests_.Lookup(request_id))
+      << request_id;
+
+  BluetoothNotificationsRequest* request =
+      pending_start_notifications_requests_.Lookup(request_id);
+
+  // The object requesting the notification could have been destroyed
+  // while waiting for the subscription. characteristicDelegateRemoved
+  // nulls the delegate when the delegate gets destroyed.
+  if (request->delegate != nullptr) {

[ortuno, 2015/09/16 16:30:08]

Argh. This doesn't work. If the delegate gets destroyed we are left subscribed
to notifications. I think you are right. We are going to need to queue requests
for the same characteristic.

+    AddToActiveNotificationsMap(request->characteristic_instance_id,
+                                request->delegate);
+  }
+  request->callbacks->onSuccess();
+
+  pending_start_notifications_requests_.Remove(request_id);
+}
+
+void BluetoothDispatcher::OnStartNotificationsError(int thread_id,
+                                                    int request_id,
+                                                    WebBluetoothError error) {
+  DCHECK(pending_start_notifications_requests_.Lookup(request_id))
+      << request_id;
+
+  pending_start_notifications_requests_.Lookup(request_id)
+      ->callbacks->onError(error);
+
+  pending_start_notifications_requests_.Remove(request_id);
+}
+
+void BluetoothDispatcher::OnStopNotificationsSuccess(int thread_id,
+                                                     int request_id) {
+  DCHECK(pending_stop_notifications_requests_.Lookup(request_id)) << request_id;
+
+  BluetoothNotificationsRequest* request =
+      pending_stop_notifications_requests_.Lookup(request_id);
+
+  RemoveFromActiveNotificationsMap(request->characteristic_instance_id,
+                                   request->delegate);
+
+  pending_stop_notifications_requests_.Lookup(request_id)
+      ->callbacks->onSuccess();
+
+  pending_stop_notifications_requests_.Remove(request_id);
+}
+
 }  // namespace content