bluetooth: Implement Service.getCharacteristics

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 47 matching lines @@
       : service_instance_id(service_instance_id),
         characteristic_uuid(characteristic_uuid),
         callbacks(callbacks) {}
   ~BluetoothCharacteristicRequest() {}
 
   blink::WebString service_instance_id;
   blink::WebString characteristic_uuid;
   scoped_ptr<blink::WebBluetoothGetCharacteristicCallbacks> callbacks;
 };
 
+struct BluetoothCharacteristicsRequest {
+  BluetoothCharacteristicsRequest(
+      blink::WebString service_instance_id,
+      blink::WebBluetoothGetCharacteristicsCallbacks* callbacks)
+      : service_instance_id(service_instance_id), callbacks(callbacks) {}
+  ~BluetoothCharacteristicsRequest() {}
+
+  blink::WebString service_instance_id;
+  scoped_ptr<blink::WebBluetoothGetCharacteristicsCallbacks> callbacks;
+};
+
 // Struct that holds a pending WriteValue request.
 struct BluetoothWriteValueRequest {
   BluetoothWriteValueRequest(const blink::WebVector<uint8_t>& value,
                              blink::WebBluetoothWriteValueCallbacks* callbacks)
       : value(value), callbacks(callbacks) {}
   ~BluetoothWriteValueRequest() {}
 
   const blink::WebVector<uint8_t> value;
   scoped_ptr<blink::WebBluetoothWriteValueCallbacks> callbacks;
 };
@@ skipping 94 matching lines @@
   IPC_MESSAGE_HANDLER(BluetoothMsg_GATTServerConnectError,
                       OnGATTServerConnectError);
   IPC_MESSAGE_HANDLER(BluetoothMsg_GetPrimaryServiceSuccess,
                       OnGetPrimaryServiceSuccess);
   IPC_MESSAGE_HANDLER(BluetoothMsg_GetPrimaryServiceError,
                       OnGetPrimaryServiceError);
   IPC_MESSAGE_HANDLER(BluetoothMsg_GetCharacteristicSuccess,
                       OnGetCharacteristicSuccess);
   IPC_MESSAGE_HANDLER(BluetoothMsg_GetCharacteristicError,
                       OnGetCharacteristicError);
+  IPC_MESSAGE_HANDLER(BluetoothMsg_GetCharacteristicsSuccess,
+                      OnGetCharacteristicsSuccess);
+  IPC_MESSAGE_HANDLER(BluetoothMsg_GetCharacteristicsError,
+                      OnGetCharacteristicsError);
   IPC_MESSAGE_HANDLER(BluetoothMsg_ReadCharacteristicValueSuccess,
                       OnReadValueSuccess);
   IPC_MESSAGE_HANDLER(BluetoothMsg_ReadCharacteristicValueError,
                       OnReadValueError);
   IPC_MESSAGE_HANDLER(BluetoothMsg_WriteCharacteristicValueSuccess,
                       OnWriteValueSuccess);
   IPC_MESSAGE_HANDLER(BluetoothMsg_WriteCharacteristicValueError,
                       OnWriteValueError);
   IPC_MESSAGE_HANDLER(BluetoothMsg_StartNotificationsSuccess,
                       OnStartNotificationsSuccess)
@@ skipping 70 matching lines @@
     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, frame_routing_id,
       service_instance_id.utf8(), characteristic_uuid.utf8()));
 }
 
+void BluetoothDispatcher::getCharacteristics(
+    int frame_routing_id,
+    const blink::WebString& service_instance_id,
+    const blink::WebString& characteristics_uuid,
+    blink::WebBluetoothGetCharacteristicsCallbacks* callbacks) {
+  int request_id = pending_characteristics_requests_.Add(
+      new BluetoothCharacteristicsRequest(service_instance_id, callbacks));
+  Send(new BluetoothHostMsg_GetCharacteristics(
+      CurrentWorkerId(), request_id, frame_routing_id,
+      service_instance_id.utf8(), characteristics_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()));
 }
 
@@ skipping 370 matching lines @@
     int thread_id,
     int request_id,
     const std::string& characteristic_instance_id,
     uint32_t characteristic_properties) {
   DCHECK(pending_characteristic_requests_.Lookup(request_id)) << request_id;
 
   BluetoothCharacteristicRequest* request =
       pending_characteristic_requests_.Lookup(request_id);
   request->callbacks->onSuccess(
       blink::adoptWebPtr(new WebBluetoothRemoteGATTCharacteristicInit(
+          request->service_instance_id,
           WebString::fromUTF8(characteristic_instance_id),
-          request->service_instance_id, request->characteristic_uuid,
-          characteristic_properties)));
+          request->characteristic_uuid, characteristic_properties)));
 
   pending_characteristic_requests_.Remove(request_id);
 }
 
 void BluetoothDispatcher::OnGetCharacteristicError(int thread_id,
                                                    int request_id,
                                                    WebBluetoothError error) {
   DCHECK(pending_characteristic_requests_.Lookup(request_id)) << request_id;
 
   pending_characteristic_requests_.Lookup(request_id)
       ->callbacks->onError(WebBluetoothError(error));
 
   pending_characteristic_requests_.Remove(request_id);
 }
 
+void BluetoothDispatcher::OnGetCharacteristicsSuccess(
+    int thread_id,
+    int request_id,
+    const std::vector<std::string>& characteristics_instance_ids,
+    const std::vector<std::string>& characteristics_uuids,
+    const std::vector<uint32_t>& characteristics_properties) {
+  DCHECK(pending_characteristics_requests_.Lookup(request_id)) << request_id;
+
+  BluetoothCharacteristicsRequest* request =
+      pending_characteristics_requests_.Lookup(request_id);
+
+  WebVector<blink::WebBluetoothRemoteGATTCharacteristicInit*>* characteristics =
+      new WebVector<WebBluetoothRemoteGATTCharacteristicInit*>(
+          characteristics_instance_ids.size());
+
+  for (size_t i = 0; i < characteristics_instance_ids.size(); i++) {
+    (*characteristics)[i] = new WebBluetoothRemoteGATTCharacteristicInit(
+        request->service_instance_id,
+        WebString::fromUTF8(characteristics_instance_ids[i]),
+        WebString::fromUTF8(characteristics_uuids[i]),
+        characteristics_properties[i]);
+  }
+
+  request->callbacks->onSuccess(blink::adoptWebPtr(characteristics));
+
+  pending_characteristics_requests_.Lookup(request_id);
+}
+
+void BluetoothDispatcher::OnGetCharacteristicsError(int thread_id,
+                                                    int request_id,
+                                                    WebBluetoothError error) {
+  DCHECK(pending_characteristics_requests_.Lookup(request_id)) << request_id;
+
+  pending_characteristics_requests_.Lookup(request_id)
+      ->callbacks->onError(WebBluetoothError(error));
+
+  pending_characteristics_requests_.Remove(request_id);
+}
+
 void BluetoothDispatcher::OnReadValueSuccess(
     int thread_id,
     int request_id,
     const std::vector<uint8_t>& value) {
   DCHECK(pending_read_value_requests_.Lookup(request_id)) << request_id;
 
   // WebArrayBuffer is not accessible from Source/modules so we pass a
   // WebVector instead.
   pending_read_value_requests_.Lookup(request_id)->onSuccess(value);
 
@@ skipping 114 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