bluetooth: browser-side implementation of writeValue.

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"
@@ skipping 145 matching lines @@
   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_HANDLER(BluetoothMsg_WriteCharacteristicValueSuccess,
+                      OnWriteValueSuccess);
+  IPC_MESSAGE_HANDLER(BluetoothMsg_WriteCharacteristicValueError,
+                      OnWriteValueError);
   IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled) << "Unhandled message:" << msg.type();
 }
 
 void BluetoothDispatcher::requestDevice(
     const WebRequestDeviceOptions& options,
     blink::WebBluetoothRequestDeviceCallbacks* callbacks) {
   int request_id = pending_requests_.Add(callbacks);
 
@@ skipping 50 matching lines @@
 }
 
 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::writeValue(
+    const blink::WebString& characteristic_instance_id,
+    const unsigned char* bytes,
+    unsigned byteLength,
+    blink::WebBluetoothWriteValueCallbacks* callbacks) {
+  int request_id = pending_write_value_requests_.Add(callbacks);
+  std::vector<uint8_t> value(byteLength);

[Jeffrey Yasskin, 2015/07/07 00:31:42]

You can initialize this with "std::vector<uint8_t> value(bytes, bytes +
byteLength);"

+  for (unsigned i = 0; i < byteLength; i++)
+    value[i] = bytes[i];
+
+  Send(new BluetoothHostMsg_WriteValue(
+      CurrentWorkerId(), request_id, characteristic_instance_id.utf8(), value));
+}
+
 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 151 matching lines @@
   pending_read_value_requests_.Lookup(request_id)
       ->onError(new WebBluetoothError(
           // TODO(ortuno): Return more descriptive error messages.
           // http://crbug.com/490419
           WebBluetoothErrorFromBluetoothError(error_type),
           WebString::fromUTF8(error_message)));
 
   pending_read_value_requests_.Remove(request_id);
 }
 
+void BluetoothDispatcher::OnWriteValueSuccess(int thread_id, int request_id) {
+  DCHECK(pending_write_value_requests_.Lookup(request_id)) << request_id;
+
+  pending_write_value_requests_.Lookup(request_id)->onSuccess();
+
+  pending_write_value_requests_.Remove(request_id);
+}
+
+void BluetoothDispatcher::OnWriteValueError(int thread_id,
+                                            int request_id,
+                                            BluetoothError error_type,
+                                            const std::string& error_message) {
+  DCHECK(pending_write_value_requests_.Lookup(request_id)) << request_id;
+
+  pending_write_value_requests_.Lookup(request_id)
+      ->onError(
+          new WebBluetoothError(WebBluetoothErrorFromBluetoothError(error_type),
+                                WebString::fromUTF8(error_message)));
+
+  pending_write_value_requests_.Remove(request_id);
+}
+
 }  // namespace content