bluetooth: Implement allowed devices map

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 <stddef.h>
 
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 52 matching lines @@
   ~BluetoothCharacteristicRequest() {}
 
   blink::WebString service_instance_id;
   blink::WebString characteristic_uuid;
   scoped_ptr<blink::WebBluetoothGetCharacteristicCallbacks> callbacks;
 };
 
 // Struct that holds a pending Start/StopNotifications request.
 struct BluetoothNotificationsRequest {
   BluetoothNotificationsRequest(
+      int frame_routing_id,
       const std::string characteristic_instance_id,
       blink::WebBluetoothGATTCharacteristic* characteristic,
       blink::WebBluetoothNotificationsCallbacks* callbacks,
       NotificationsRequestType type)
-      : characteristic_instance_id(characteristic_instance_id),
+      : frame_routing_id(frame_routing_id),
+        characteristic_instance_id(characteristic_instance_id),
         characteristic(characteristic),
         callbacks(callbacks),
         type(type) {}
   ~BluetoothNotificationsRequest() {}
 
+  const int frame_routing_id;
   const std::string characteristic_instance_id;
   // The characteristic object is owned by the execution context on
   // the blink side which can destroy the object at any point. Since the
   // object implements ActiveDOMObject, the object calls Stop when is getting
   // destroyed, which in turn calls characteristicObjectRemoved.
   // characteristicObjectRemoved will null any pointers to the object
   // and queue a stop notifications request if necessary.
   blink::WebBluetoothGATTCharacteristic* characteristic;
   scoped_ptr<blink::WebBluetoothNotificationsCallbacks> callbacks;
   NotificationsRequestType type;
@@ skipping 116 matching lines @@
   for (const WebString& optional_service : options.optionalServices) {
     optional_services.push_back(device::BluetoothUUID(optional_service.utf8()));
   }
 
   Send(new BluetoothHostMsg_RequestDevice(CurrentWorkerId(), request_id,
                                           frame_routing_id, filters,
                                           optional_services));
 }
 
 void BluetoothDispatcher::connectGATT(
+    int frame_routing_id,
     const blink::WebString& device_id,
     blink::WebBluetoothConnectGATTCallbacks* callbacks) {
   int request_id = pending_connect_requests_.Add(callbacks);
   Send(new BluetoothHostMsg_ConnectGATT(CurrentWorkerId(), request_id,
-                                        device_id.utf8()));
+                                        frame_routing_id, device_id.utf8()));
 }
 
 void BluetoothDispatcher::getPrimaryService(
+    int frame_routing_id,
     const blink::WebString& device_id,
     const blink::WebString& service_uuid,
     blink::WebBluetoothGetPrimaryServiceCallbacks* callbacks) {
   int request_id = pending_primary_service_requests_.Add(
       new BluetoothPrimaryServiceRequest(device_id, service_uuid, callbacks));
   Send(new BluetoothHostMsg_GetPrimaryService(
-      CurrentWorkerId(), request_id, device_id.utf8(), service_uuid.utf8()));
+      CurrentWorkerId(), request_id, frame_routing_id, device_id.utf8(),
+      service_uuid.utf8()));
 }
 
 void BluetoothDispatcher::getCharacteristic(
+    int frame_routing_id,
     const blink::WebString& service_instance_id,
     const blink::WebString& characteristic_uuid,
     blink::WebBluetoothGetCharacteristicCallbacks* callbacks) {
   int request_id =
       pending_characteristic_requests_.Add(new BluetoothCharacteristicRequest(
           service_instance_id, characteristic_uuid, callbacks));
-  Send(new BluetoothHostMsg_GetCharacteristic(CurrentWorkerId(), request_id,
-                                              service_instance_id.utf8(),
-                                              characteristic_uuid.utf8()));
+  Send(new BluetoothHostMsg_GetCharacteristic(
+      CurrentWorkerId(), request_id, frame_routing_id,
+      service_instance_id.utf8(), characteristic_uuid.utf8()));
 }
 
 void BluetoothDispatcher::readValue(
+    int frame_routing_id,
     const blink::WebString& characteristic_instance_id,
     blink::WebBluetoothReadValueCallbacks* callbacks) {
   int request_id = pending_read_value_requests_.Add(callbacks);
   Send(new BluetoothHostMsg_ReadValue(CurrentWorkerId(), request_id,
+                                      frame_routing_id,
                                       characteristic_instance_id.utf8()));
 }
 
 void BluetoothDispatcher::writeValue(
+    int frame_routing_id,
     const blink::WebString& characteristic_instance_id,
     const blink::WebVector<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(),
+      CurrentWorkerId(), request_id, frame_routing_id,
+      characteristic_instance_id.utf8(),
       std::vector<uint8_t>(value.begin(), value.end())));
 }
 
 void BluetoothDispatcher::startNotifications(
+    int frame_routing_id,
     const blink::WebString& characteristic_instance_id,
     blink::WebBluetoothGATTCharacteristic* characteristic,
     blink::WebBluetoothNotificationsCallbacks* callbacks) {
-  int request_id = QueueNotificationRequest(characteristic_instance_id.utf8(),
-                                            characteristic, callbacks,
-                                            NotificationsRequestType::START);
+  int request_id = QueueNotificationRequest(
+      frame_routing_id, characteristic_instance_id.utf8(), characteristic,
+      callbacks, NotificationsRequestType::START);
   // The Notification subscription's state can change after a request
   // finishes. To avoid resolving with a soon-to-be-invalid state we queue
   // requests.
   if (HasNotificationRequestResponsePending(
           characteristic_instance_id.utf8())) {
     return;
   }
 
   ResolveOrSendStartNotificationRequest(request_id);
 }
 
 void BluetoothDispatcher::stopNotifications(
+    int frame_routing_id,
     const blink::WebString& characteristic_instance_id,
     blink::WebBluetoothGATTCharacteristic* characteristic,
     blink::WebBluetoothNotificationsCallbacks* callbacks) {
-  int request_id = QueueNotificationRequest(characteristic_instance_id.utf8(),
-                                            characteristic, callbacks,
-                                            NotificationsRequestType::STOP);
+  int request_id = QueueNotificationRequest(
+      frame_routing_id, characteristic_instance_id.utf8(), characteristic,
+      callbacks, NotificationsRequestType::STOP);
   if (HasNotificationRequestResponsePending(
           characteristic_instance_id.utf8())) {
     return;
   }
 
   ResolveOrSendStopNotificationsRequest(request_id);
 }
 
 void BluetoothDispatcher::characteristicObjectRemoved(
+    int frame_routing_id,
     const blink::WebString& characteristic_instance_id,
     blink::WebBluetoothGATTCharacteristic* characteristic) {
   // 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);
+  UnregisterCharacteristicObject(frame_routing_id, 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_);
@@ skipping 26 matching lines @@
 
   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,
+      frame_routing_id, characteristic_instance_id.utf8(), characteristic,
       nullptr /* callbacks */, NotificationsRequestType::STOP));
 }
 
 void BluetoothDispatcher::registerCharacteristicObject(
+    int frame_routing_id,
     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()));
+      CurrentWorkerId(), frame_routing_id, characteristic_instance_id.utf8()));
 }
 
 void BluetoothDispatcher::WillStopCurrentWorkerThread() {
   delete this;
 }
 
 int BluetoothDispatcher::QueueNotificationRequest(
+    int frame_routing_id,
     const std::string& characteristic_instance_id,
     blink::WebBluetoothGATTCharacteristic* characteristic,
     blink::WebBluetoothNotificationsCallbacks* callbacks,
     NotificationsRequestType type) {
   int request_id =
       pending_notifications_requests_.Add(new BluetoothNotificationsRequest(
-          characteristic_instance_id, characteristic, callbacks, type));
+          frame_routing_id, characteristic_instance_id, characteristic,
+          callbacks, type));
   notification_requests_queues_[characteristic_instance_id].push(request_id);
 
   return request_id;
 }
 
 void BluetoothDispatcher::PopNotificationRequestQueueAndProcessNext(
     int request_id) {
   BluetoothNotificationsRequest* old_request =
       pending_notifications_requests_.Lookup(request_id);
 
@@ skipping 65 matching lines @@
     DCHECK(!HasActiveNotificationSubscription(characteristic_instance_id));
     return true;
   }
   return false;
 }
 
 void BluetoothDispatcher::ResolveOrSendStartNotificationRequest(
     int request_id) {
   BluetoothNotificationsRequest* request =
       pending_notifications_requests_.Lookup(request_id);
+  const int frame_routing_id = request->frame_routing_id;
   const std::string& characteristic_instance_id =
       request->characteristic_instance_id;
   blink::WebBluetoothGATTCharacteristic* characteristic =
       request->characteristic;
   blink::WebBluetoothNotificationsCallbacks* callbacks =
       request->callbacks.get();
 
   // If an object is already subscribed to notifications from the characteristic
   // no need to send an IPC again.
   if (HasActiveNotificationSubscription(characteristic_instance_id)) {
     // The object could have been destroyed while we waited.
     if (characteristic != nullptr) {
       AddToActiveNotificationSubscriptions(characteristic_instance_id,
                                            characteristic);
     }
     callbacks->onSuccess();
 
     PopNotificationRequestQueueAndProcessNext(request_id);
     return;
   }
 
   Send(new BluetoothHostMsg_StartNotifications(CurrentWorkerId(), request_id,
+                                               frame_routing_id,
                                                characteristic_instance_id));
 }
 
 void BluetoothDispatcher::ResolveOrSendStopNotificationsRequest(
     int request_id) {
   // The Notification subscription's state can change after a request
   // finishes. To avoid resolving with a soon-to-be-invalid state we queue
   // requests.
   BluetoothNotificationsRequest* request =
       pending_notifications_requests_.Lookup(request_id);
+  const int frame_routing_id = request->frame_routing_id;
   const std::string& characteristic_instance_id =
       request->characteristic_instance_id;
   blink::WebBluetoothGATTCharacteristic* characteristic =
       request->characteristic;
   blink::WebBluetoothNotificationsCallbacks* callbacks =
       request->callbacks.get();
 
   // If removing turns the subscription inactive then stop.
   if (RemoveFromActiveNotificationSubscriptions(characteristic_instance_id,
                                                 characteristic)) {
     Send(new BluetoothHostMsg_StopNotifications(CurrentWorkerId(), request_id,
+                                                frame_routing_id,
                                                 characteristic_instance_id));
     return;
   }
 
   // We could be processing a request with nullptr callbacks due to:
   //   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(
+    int frame_routing_id,
     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()));
+        CurrentWorkerId(), frame_routing_id,
+        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());
@@ skipping 150 matching lines @@
 
   // The object requesting the notification could have been destroyed
   // while waiting for the subscription. characteristicRemoved
   // nulls the characteristic when the corresponding js object gets destroyed.
   // A Stop request must be issued as the subscription is no longer needed.
   // The Stop requets is added to the end of the queue in case another
   // Start request exists in the queue from another characteristic object,
   // which would result in the subscription continuing.
   if (request->characteristic == nullptr) {
     QueueNotificationRequest(
-        request->characteristic_instance_id, nullptr /* characteristic */,
-        nullptr /* callbacks */, NotificationsRequestType::STOP);
+        request->frame_routing_id, request->characteristic_instance_id,
+        nullptr /* characteristic */, nullptr /* callbacks */,
+        NotificationsRequestType::STOP);
   }
 
   request->callbacks->onSuccess();
 
   PopNotificationRequestQueueAndProcessNext(request_id);
 }
 
 void BluetoothDispatcher::OnStartNotificationsError(int thread_id,
                                                     int request_id,
                                                     WebBluetoothError error) {
@@ skipping 39 matching lines @@
     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