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,

[Jeffrey Yasskin, 2016/01/13 19:25:34]

I wish we had different types for routing IDs, request IDs, etc., so if we got
this in the wrong order by accident, the compiler would tell us. You don't need
to do anything in this CL; I'm just complaining.

[ortuno, 2016/01/13 21:34:31]

I feel you. Hopefully with mojo we can get rid of a couple of these.

+      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