bluetooth: Implement allowed devices map

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 43 matching lines @@
       ThreadSafeSender* thread_safe_sender);
 
   // IPC Send and Receiving interface, see IPC::Sender and IPC::Listener.
   bool Send(IPC::Message* msg);
   void OnMessageReceived(const IPC::Message& msg);
 
   // Corresponding to WebBluetoothImpl methods.
   void requestDevice(int frame_routing_id,
                      const blink::WebRequestDeviceOptions& options,
                      blink::WebBluetoothRequestDeviceCallbacks* callbacks);
-  void connectGATT(const blink::WebString& device_id,
+  void connectGATT(int frame_routing_id,
+                   const blink::WebString& device_id,
                    blink::WebBluetoothConnectGATTCallbacks* callbacks);
   void getPrimaryService(
+      int frame_routing_id,
       const blink::WebString& device_id,
       const blink::WebString& service_uuid,
       blink::WebBluetoothGetPrimaryServiceCallbacks* callbacks);
 
   void getCharacteristic(
+      int frame_routing_id,
       const blink::WebString& service_instance_id,
       const blink::WebString& characteristic_uuid,
       blink::WebBluetoothGetCharacteristicCallbacks* callbacks);
-  void readValue(const blink::WebString& characteristic_instance_id,
+  void readValue(int frame_routing_id,
+                 const blink::WebString& characteristic_instance_id,
                  blink::WebBluetoothReadValueCallbacks* callbacks);
-  void writeValue(const blink::WebString& characteristic_instance_id,
+  void writeValue(int frame_routing_id,
+                  const blink::WebString& characteristic_instance_id,
                   const blink::WebVector<uint8_t>& value,
                   blink::WebBluetoothWriteValueCallbacks*);
-  void startNotifications(const blink::WebString& characteristic_instance_id,
+  void startNotifications(int frame_routing_id,
+                          const blink::WebString& characteristic_instance_id,
                           blink::WebBluetoothGATTCharacteristic* delegate,
                           blink::WebBluetoothNotificationsCallbacks*);
-  void stopNotifications(const blink::WebString& characteristic_instance_id,
+  void stopNotifications(int frame_routing_id,
+                         const blink::WebString& characteristic_instance_id,
                          blink::WebBluetoothGATTCharacteristic* delegate,
                          blink::WebBluetoothNotificationsCallbacks*);
   void characteristicObjectRemoved(
+      int frame_routing_id,
       const blink::WebString& characteristic_instance_id,
       blink::WebBluetoothGATTCharacteristic* delegate);
   void registerCharacteristicObject(
+      int frame_routing_id,
       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
   // a notification request, the request is immediately queued. If
   // there are no other pending requests then the request is processed.
   // When a characteristic object gets destroyed BluetoothDispatcher
   // gets notified by characteristicObjectRemoved. When this happens
   // a stop request should be queued if the characteristic was subscribed
   // to notifications.
 
   // Helper functions for notification requests queue:
 
   // Creates a notification request and queues it.
   int QueueNotificationRequest(
+      int frame_routing_id,
       const std::string& characteristic_instance_id,
       blink::WebBluetoothGATTCharacteristic* characteristic,
       blink::WebBluetoothNotificationsCallbacks* callbacks,
       NotificationsRequestType type);
   // Pops the last requests and runs the next request in the queue.
   void PopNotificationRequestQueueAndProcessNext(int request_id);
   // Checks if there is more than one request in the queue i.e. if there
   // are other requests besides the one being processed.
   bool HasNotificationRequestResponsePending(
       const std::string& characteristic_instance_id);
@@ skipping 24 matching lines @@
   // 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(
+      int frame_routing_id,
       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,
@@ skipping 79 matching lines @@
   // 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_