bluetooth: Add characteristicvaluechanged event

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"
@@ skipping 159 matching lines @@
   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_HANDLER(BluetoothMsg_CharacteristicValueChanged,
+                      OnCharacteristicValueChanged)
   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 98 matching lines @@
           characteristic_instance_id.utf8())) {
     return;
   }
 
   ResolveOrSendStopNotificationsRequest(request_id);
 }
 
 void BluetoothDispatcher::characteristicObjectRemoved(
     const blink::WebString& characteristic_instance_id,
     blink::WebBluetoothGATTCharacteristic* characteristic) {
-  // A characteristic object is in the queue waiting for a response
-  // or in the set of active notifications.
+  // We need to remove references to the object from the following:
+  //  1) The set of active characteristics
+  //  2) The queue waiting for a response
+  //  3) The set of active notifications
 
+  // 1
+  // TODO(ortuno): We should only unregister a characteristic once
+  // there are no characteristic objects that have listeners attached.
+  // https://crbug.com/541388
+  UnregisterCharacteristicObject(characteristic_instance_id);
+
+  // 2
   // If the object is in the queue we null the characteristic. If this is the
   // first object waiting for a response OnStartNotificationsSuccess will make
   // sure not to add the characteristic to the map and it will queue a Stop
   // request. Otherwise ResolveOrSendStartNotificationRequest will make sure not
   // to add it to active notification subscriptions.
   bool found = false;
   for (IDMap<BluetoothNotificationsRequest, IDMapOwnPointer>::iterator iter(
            &pending_notifications_requests_);
        !iter.IsAtEnd(); iter.Advance()) {
     if (iter.GetCurrentValue()->characteristic == characteristic) {
       found = true;
       iter.GetCurrentValue()->characteristic = nullptr;
     }
   }
 
   if (found) {
     // A characteristic will never be in the set of active notifications
     // and in the queue at the same time.
     auto subscriptions_iter = active_notification_subscriptions_.find(
         characteristic_instance_id.utf8());
     if (subscriptions_iter != active_notification_subscriptions_.end()) {
       DCHECK(!ContainsKey(subscriptions_iter->second, characteristic));
     }
     return;
   }
 
+  // 3
   // If the object is not in the queue then:
   //   1. The subscription was inactive already: this characteristic
   //      object didn't subscribe to notifications.
   //   2. The subscription will become inactive: the characteristic
   //      object that subscribed to notifications is getting destroyed.
   //   3. The subscription will still be active: there are other
   //      characteristic objects subscribed to notifications.
 
   if (!HasActiveNotificationSubscription(characteristic_instance_id.utf8())) {
     return;
   }
 
   // For 2 and 3 calling ResolveOrSendStopNotificationsRequest ensures the
   // notification subscription is released.
   // We pass in the characteristic so that ResolveOrSendStopNotificationsRequest
   // can remove the characteristic from ActiveNotificationSubscriptions.
   ResolveOrSendStopNotificationsRequest(QueueNotificationRequest(
       characteristic_instance_id.utf8(), characteristic,
       nullptr /* callbacks */, NotificationsRequestType::STOP));
 }
 
+void BluetoothDispatcher::registerCharacteristicObject(
+    const blink::WebString& characteristic_instance_id,
+    blink::WebBluetoothGATTCharacteristic* characteristic) {
+  // TODO(ortuno): After the Object manager is implemented, there will
+  // only be one object per characteristic. But for now we remove
+  // the previous object.
+  // https://crbug.com/495270
+  active_characteristics_.erase(characteristic_instance_id.utf8());
+
+  active_characteristics_.insert(
+      std::make_pair(characteristic_instance_id.utf8(), characteristic));
+
+  Send(new BluetoothHostMsg_RegisterCharacteristic(
+      CurrentWorkerId(), characteristic_instance_id.utf8()));
+}
+
 void BluetoothDispatcher::WillStopCurrentWorkerThread() {
   delete this;
 }
 
 int BluetoothDispatcher::QueueNotificationRequest(
     const std::string& characteristic_instance_id,
     blink::WebBluetoothGATTCharacteristic* characteristic,
     blink::WebBluetoothNotificationsCallbacks* callbacks,
     NotificationsRequestType type) {
   int request_id =
@@ skipping 135 matching lines @@
   //   1) OnStartNotificationSuccess queues a Stop request because the object
   //      got destroyed in characteristicObjectRemoved.
   //   2) The last characteristic object that held this subscription got
   //      destroyed in characteristicObjectRemoved.
   if (callbacks != nullptr) {
     callbacks->onSuccess();
   }
   PopNotificationRequestQueueAndProcessNext(request_id);
 }
 
+void BluetoothDispatcher::UnregisterCharacteristicObject(
+    const blink::WebString& characteristic_instance_id) {
+  int removed =
+      active_characteristics_.erase(characteristic_instance_id.utf8());
+  if (removed != 0) {
+    Send(new BluetoothHostMsg_UnregisterCharacteristic(
+        CurrentWorkerId(), characteristic_instance_id.utf8()));
+  }
+}
+
 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 196 matching lines @@
   DCHECK(
       !HasActiveNotificationSubscription(request->characteristic_instance_id));
 
   if (request->callbacks != nullptr) {
     request->callbacks->onSuccess();
   }
 
   PopNotificationRequestQueueAndProcessNext(request_id);
 }
 
+void BluetoothDispatcher::OnCharacteristicValueChanged(
+    int thread_id,
+    const std::string& characteristic_instance_id,
+    const std::vector<uint8_t> new_value) {
+  auto active_iter = active_characteristics_.find(characteristic_instance_id);
+  if (active_iter != active_characteristics_.end()) {
+    active_iter->second->dispatchCharacteristicValueChanged(new_value);
+  }
+}
+
 }  // namespace content