bluetooth: Add characteristicvaluechanged event

content/renderer/bluetooth/bluetooth_dispatcher.h

 // 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.
 
 #ifndef CONTENT_CHILD_BLUETOOTH_BLUETOOTH_DISPATCHER_H_
 #define CONTENT_CHILD_BLUETOOTH_BLUETOOTH_DISPATCHER_H_
 
 #include <map>
 #include <queue>
 
@@ skipping 68 matching lines @@
                   blink::WebBluetoothWriteValueCallbacks*);
   void startNotifications(const blink::WebString& characteristic_instance_id,
                           blink::WebBluetoothGATTCharacteristic* delegate,
                           blink::WebBluetoothNotificationsCallbacks*);
   void stopNotifications(const blink::WebString& characteristic_instance_id,
                          blink::WebBluetoothGATTCharacteristic* delegate,
                          blink::WebBluetoothNotificationsCallbacks*);
   void characteristicObjectRemoved(
       const blink::WebString& characteristic_instance_id,
       blink::WebBluetoothGATTCharacteristic* delegate);
+  void registerCharacteristicObject(
+      const blink::WebString& characteristic_instance_id,
+      blink::WebBluetoothGATTCharacteristic* characteristic);
 
   // WorkerThread::Observer implementation.
   void WillStopCurrentWorkerThread() override;
 
   enum class NotificationsRequestType { START = 0, STOP = 1 };
 
  private:
   // Notifications Queueing Notes:
   // To avoid races and sending unnecessary IPC messages we implement
   // a queueing system for notification requests. When receiving
@@ skipping 34 matching lines @@
       const std::string& characteristic_instance_id,
       blink::WebBluetoothGATTCharacteristic* characteristic);
 
   // The following functions decide whether to resolve the request immediately
   // or send an IPC to change the subscription state.
   // You should never call these functions if PendingNotificationRequest
   // is true since there is currently another request being processed.
   void ResolveOrSendStartNotificationRequest(int request_id);
   void ResolveOrSendStopNotificationsRequest(int request_id);
 
+  // Tells BluetoothDispatcherHost that we are no longer interested in
+  // events for the characteristic.
+  // TODO(ortuno): We should unregister a characteristic once there are no
+  // characteristic objects that have listeners attached.
+  // For now, we call this function when an object gets destroyed. So if there
+  // are two frames registered for notifications from the same characteristic
+  // and one of the characteristic objects gets destroyed both will stop
+  // receiving notifications.
+  // https://crbug.com/541388
+  void UnregisterCharacteristicObject(
+      const blink::WebString& characteristic_instance_id);
+
   // IPC Handlers, see definitions in bluetooth_messages.h.
   void OnRequestDeviceSuccess(int thread_id,
                               int request_id,
                               const BluetoothDevice& device);
   void OnRequestDeviceError(int thread_id,
                             int request_id,
                             blink::WebBluetoothError error);
   void OnConnectGATTSuccess(int thread_id,
                             int request_id,
                             const std::string& message);
@@ skipping 21 matching lines @@
                         blink::WebBluetoothError error);
   void OnWriteValueSuccess(int thread_id, int request_id);
   void OnWriteValueError(int thread_id,
                          int request_id,
                          blink::WebBluetoothError error);
   void OnStartNotificationsSuccess(int thread_id, int request_id);
   void OnStartNotificationsError(int thread_id,
                                  int request_id,
                                  blink::WebBluetoothError error);
   void OnStopNotificationsSuccess(int thread_id, int request_id);
+  void OnCharacteristicValueChanged(
+      int thread_id,
+      const std::string& characteristic_instance_id,
+      const std::vector<uint8_t> value);
 
   scoped_refptr<ThreadSafeSender> thread_safe_sender_;
 
   // Map of characteristic_instance_id to a queue of Notification Requests' IDs.
   // See "Notifications Queueing Note" above.
   std::map<std::string, std::queue<int>> notification_requests_queues_;
 
   // Tracks device requests sent to browser to match replies with callbacks.
   // Owns callback objects.
   IDMap<blink::WebBluetoothRequestDeviceCallbacks, IDMapOwnPointer>
@@ skipping 16 matching lines @@
       pending_write_value_requests_;
   IDMap<BluetoothNotificationsRequest, IDMapOwnPointer>
       pending_notifications_requests_;
 
   // Map of characteristic_instance_id to a set of
   // WebBluetoothGATTCharacteristic pointers. Keeps track of which
   // objects are subscribed to notifications.
   std::map<std::string, std::set<blink::WebBluetoothGATTCharacteristic*>>
       active_notification_subscriptions_;
 
+  // Map of characteristic_instance_ids to WebBluetoothGATTCharacteristics.
+  // Keeps track of what characteristics have listeners.
+  // TODO(ortuno): We are assuming that there exists a single frame per
+  // dispatcher, so there could be at most one characteristic object per
+  // characteristic_instance_id. Change to a set when we support multiple
+  // frames.
+  // http://crbug.com/541388
+  std::map<std::string, blink::WebBluetoothGATTCharacteristic*>
+      active_characteristics_;
+
   DISALLOW_COPY_AND_ASSIGN(BluetoothDispatcher);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_CHILD_BLUETOOTH_BLUETOOTH_DISPATCHER_H_