bluetooth: Move writeValue to mojo

content/renderer/bluetooth/web_bluetooth_impl.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/web_bluetooth_impl.h"
 
+#include "content/child/mojo/type_converters.h"
 #include "content/child/thread_safe_sender.h"
+#include "content/public/common/service_registry.h"
 #include "content/renderer/bluetooth/bluetooth_dispatcher.h"
 #include "ipc/ipc_message.h"
+#include "mojo/public/cpp/bindings/array.h"
 
 namespace content {
 
-WebBluetoothImpl::WebBluetoothImpl(ThreadSafeSender* thread_safe_sender)
-    : WebBluetoothImpl(thread_safe_sender, MSG_ROUTING_NONE) {}
-
-WebBluetoothImpl::WebBluetoothImpl(ThreadSafeSender* thread_safe_sender,
+WebBluetoothImpl::WebBluetoothImpl(ServiceRegistry* service_registry,
+                                   ThreadSafeSender* thread_safe_sender,
                                    int frame_routing_id)
-    : thread_safe_sender_(thread_safe_sender),
+    : service_registry_(service_registry),
+      thread_safe_sender_(thread_safe_sender),
       frame_routing_id_(frame_routing_id) {}
 
 WebBluetoothImpl::~WebBluetoothImpl() {
 }
 
 void WebBluetoothImpl::requestDevice(
     const blink::WebRequestDeviceOptions& options,
     blink::WebBluetoothRequestDeviceCallbacks* callbacks) {
   GetDispatcher()->requestDevice(frame_routing_id_, options, callbacks);
 }
@@ skipping 36 matching lines @@
     const blink::WebString& characteristic_instance_id,
     blink::WebBluetoothReadValueCallbacks* callbacks) {
   GetDispatcher()->readValue(frame_routing_id_, characteristic_instance_id,
                              callbacks);
 }
 
 void WebBluetoothImpl::writeValue(
     const blink::WebString& characteristic_instance_id,
     const blink::WebVector<uint8_t>& value,
     blink::WebBluetoothWriteValueCallbacks* callbacks) {
-  GetDispatcher()->writeValue(frame_routing_id_, characteristic_instance_id,
-                              value, callbacks);
+  GetWebBluetoothService().RemoteCharacteristicWriteValue(
+      mojo::String::From(characteristic_instance_id),
+      mojo::Array<uint8_t>::From(value),
+      base::Bind(&WebBluetoothImpl::OnWriteValueComplete,
+                 base::Unretained(this), value,
+                 base::Passed(make_scoped_ptr(callbacks))));
 }
 
 void WebBluetoothImpl::startNotifications(
     const blink::WebString& characteristic_instance_id,
     blink::WebBluetoothRemoteGATTCharacteristic* characteristic,
     blink::WebBluetoothNotificationsCallbacks* callbacks) {
   GetDispatcher()->startNotifications(
       frame_routing_id_, characteristic_instance_id, characteristic, callbacks);
 }
 
@@ skipping 12 matching lines @@
       frame_routing_id_, characteristic_instance_id, characteristic);
 }
 
 void WebBluetoothImpl::registerCharacteristicObject(
     const blink::WebString& characteristic_instance_id,
     blink::WebBluetoothRemoteGATTCharacteristic* characteristic) {
   GetDispatcher()->registerCharacteristicObject(
       frame_routing_id_, characteristic_instance_id, characteristic);
 }
 
+void WebBluetoothImpl::OnWriteValueComplete(
+    const blink::WebVector<uint8_t>& value,
+    scoped_ptr<blink::WebBluetoothWriteValueCallbacks> callbacks,
+    blink::mojom::WebBluetoothError error) {
+  if (error == blink::mojom::WebBluetoothError::SUCCESS) {
+    callbacks->onSuccess(value);
+  } else {
+    callbacks->onError(error);
+  }
+}
+
 BluetoothDispatcher* WebBluetoothImpl::GetDispatcher() {
   return BluetoothDispatcher::GetOrCreateThreadSpecificInstance(
       thread_safe_sender_.get());
 }
 
+blink::mojom::WebBluetoothService& WebBluetoothImpl::GetWebBluetoothService() {
+  if (!web_bluetooth_service_) {
+    service_registry_->ConnectToRemoteService(
+        mojo::GetProxy(&web_bluetooth_service_));
+  }
+  return *web_bluetooth_service_;
+}
+
 }  // namespace content