bluetooth: Move writeValue to mojo

content/renderer/bluetooth/web_bluetooth_impl.cc

Index: content/renderer/bluetooth/web_bluetooth_impl.cc
diff --git a/content/renderer/bluetooth/web_bluetooth_impl.cc b/content/renderer/bluetooth/web_bluetooth_impl.cc
index 2df80b3ad7421d2ef0dc55b3a12fa2c0ff923dba..8ae90cf611419b5b8b37e5ce8521cbf596eee744 100644
--- a/content/renderer/bluetooth/web_bluetooth_impl.cc
+++ b/content/renderer/bluetooth/web_bluetooth_impl.cc
@@ -4,18 +4,20 @@
 
 #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() {
@@ -72,8 +74,11 @@ 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(
@@ -106,9 +111,29 @@ void WebBluetoothImpl::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