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::OnWriteValue, base::Unretained(this), value,

[Ken Rockot(use gerrit already), 2016/03/17 18:16:13]

Here's a fun problem. If you can't get a WebBluetoothService (say the flag's not
enabled), this call to RemoteCharacteristicWriteValue will silently fail --
there's not much else it can do really, it's writing to a dead pipe.

In such a case, your |callbacks| will be destroyed without either onSuccess or
onError being called. If callbacks comes from a promise adapter (it does,
right?), this is a problem, because promise adapter callbacks must not be
destroyed until one of the callbacks is called.

I introduced ScopedWebCallbacks (in content/child) specifically for this
purpose. Essentially it's just a scoped_ptr which allows you to take back
ownership of the WebCallbacks; but if it's destroyed before you do that, it
invokes a custom destruction callback which you can use to, say, run the
WebCallbacks with a default error code. WebUSB uses this.

It adds a layer of ugliness to wrap callbacks like this, but I haven't come up
with a better alternative yet.

[ortuno, 2016/03/18 01:19:20]

As discussed offline, ScriptPromiseResolver only DCHECKS that resolve or reject
have been called. In release builds the only consequence of a service dropping
callbacks is that a promise will hang. In tests if a callback is dropped then
the test will fail, which is basically the same as us returning an error when
the callback is dropped. I think the extra layer would add little benefit.

+                 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::OnWriteValue(
+    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::WebBluetoothServicePtr&
+WebBluetoothImpl::GetWebBluetoothService() {
+  if (!web_bluetooth_service_) {
+    service_registry_->ConnectToRemoteService(
+        mojo::GetProxy(&web_bluetooth_service_));
+  }
+  return web_bluetooth_service_;
+}
+
 }  // namespace content