bluetooth: Browser-side implementation of readValue

content/child/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/child/bluetooth/bluetooth_dispatcher.h"
 
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/common/bluetooth/bluetooth_messages.h"
 #include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothDevice.h"
 #include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothError.h"
 #include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothGATTCharacteristic.h"
 #include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothGATTRemoteServer.h"
 #include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothGATTService.h"
 
 using blink::WebBluetoothConnectGATTCallbacks;
 using blink::WebBluetoothDevice;
 using blink::WebBluetoothError;
 using blink::WebBluetoothGATTCharacteristic;
 using blink::WebBluetoothGATTRemoteServer;
 using blink::WebBluetoothGATTService;
+using blink::WebBluetoothReadValueCallbacks;
 using blink::WebBluetoothRequestDeviceCallbacks;
 using blink::WebString;
 using blink::WebVector;
 
 struct BluetoothPrimaryServiceRequest {
   BluetoothPrimaryServiceRequest(
       blink::WebString device_instance_id,
       blink::WebString service_uuid,
       blink::WebBluetoothGetPrimaryServiceCallbacks* callbacks)
       : device_instance_id(device_instance_id),
@@ skipping 102 matching lines @@
   IPC_MESSAGE_HANDLER(BluetoothMsg_ConnectGATTSuccess, OnConnectGATTSuccess);
   IPC_MESSAGE_HANDLER(BluetoothMsg_ConnectGATTError, OnConnectGATTError);
   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_ReadCharacteristicValueSuccess,
+                      OnReadValueSuccess);
+  IPC_MESSAGE_HANDLER(BluetoothMsg_ReadCharacteristicValueError,
+                      OnReadValueError);
   IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled) << "Unhandled message:" << msg.type();
 }
 
 void BluetoothDispatcher::requestDevice(
     blink::WebBluetoothRequestDeviceCallbacks* callbacks) {
   int request_id = pending_requests_.Add(callbacks);
   Send(new BluetoothHostMsg_RequestDevice(CurrentWorkerId(), request_id));
 }
@@ skipping 23 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,
                                               service_instance_id.utf8(),
                                               characteristic_uuid.utf8()));
 }
 
+void BluetoothDispatcher::readValue(
+    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,
+                                      characteristic_instance_id.utf8()));
+}
+
 void BluetoothDispatcher::OnWorkerRunLoopStopped() {
   delete this;
 }
 
 void BluetoothDispatcher::OnRequestDeviceSuccess(
     int thread_id,
     int request_id,
     const BluetoothDevice& device) {
   DCHECK(pending_requests_.Lookup(request_id)) << request_id;
 
@@ skipping 79 matching lines @@
           // http://crbug.com/490419
           WebBluetoothErrorFromBluetoothError(error_type), ""));
   pending_primary_service_requests_.Remove(request_id);
 }
 
 void BluetoothDispatcher::OnGetCharacteristicSuccess(
     int thread_id,
     int request_id,
     const std::string& characteristic_instance_id) {
   DCHECK(pending_characteristic_requests_.Lookup(request_id)) << request_id;
-
   BluetoothCharacteristicRequest* request =
       pending_characteristic_requests_.Lookup(request_id);
   request->callbacks->onSuccess(new WebBluetoothGATTCharacteristic(
       WebString::fromUTF8(characteristic_instance_id),
       request->service_instance_id, request->characteristic_uuid));
 
   pending_characteristic_requests_.Remove(request_id);
 }
 
 void BluetoothDispatcher::OnGetCharacteristicError(int thread_id,
                                                    int request_id,
                                                    BluetoothError error_type) {
   DCHECK(pending_characteristic_requests_.Lookup(request_id)) << request_id;
-

[Jeffrey Yasskin, 2015/06/10 21:03:45]

I kinda liked these blank lines.

[ortuno, 2015/06/10 22:03:01]

Done.

   // Since we couldn't find the characteristic return null. See Step 3 of
   // getCharacteristic algorithm:
   // https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothgattservice-getcharacteristic
   if (error_type == BluetoothError::NOT_FOUND) {
     pending_characteristic_requests_.Lookup(request_id)
         ->callbacks->onSuccess(nullptr);
   } else {
     pending_characteristic_requests_.Lookup(request_id)
         ->callbacks->onError(new WebBluetoothError(
             // TODO(ortuno): Return more descriptive error messages.
             // http://crbug.com/490419
             WebBluetoothErrorFromBluetoothError(error_type), ""));
   }
   pending_characteristic_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(new WebVector<uint8_t>(value));
+
+  pending_read_value_requests_.Remove(request_id);
+}
+
+void BluetoothDispatcher::OnReadValueError(int thread_id,
+                                           int request_id,
+                                           BluetoothError error_type) {
+  DCHECK(pending_read_value_requests_.Lookup(request_id)) << request_id;
+
+  pending_read_value_requests_.Lookup(request_id)
+      ->onError(new WebBluetoothError(
+          // TODO(ortuno): Return more descriptive error messages.
+          // http://crbug.com/490419
+          WebBluetoothErrorFromBluetoothError(error_type), ""));
+
+  pending_read_value_requests_.Remove(request_id);
+}
+
 }  // namespace content