bluetooth: Move writeValue to mojo

content/renderer/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/renderer/bluetooth/bluetooth_dispatcher.h"
 
 #include <stddef.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/mojo/type_converters.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/common/bluetooth/bluetooth_messages.h"
+#include "content/public/common/service_registry.h"
+#include "content/renderer/bluetooth/bluetooth_type_converters.h"
 #include "device/bluetooth/bluetooth_uuid.h"
+#include "mojo/public/cpp/bindings/array.h"
 #include "third_party/WebKit/public/platform/WebPassOwnPtr.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/WebBluetoothRemoteGATTCharacteristic.h"
 #include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothRemoteGATTCharacteristicInit.h"
 #include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothRemoteGATTService.h"
 #include "third_party/WebKit/public/platform/modules/bluetooth/WebRequestDeviceOptions.h"
 
 using blink::WebBluetoothDevice;
-using blink::WebBluetoothError;
 using blink::WebBluetoothRemoteGATTCharacteristicInit;
 using blink::WebBluetoothRemoteGATTServerConnectCallbacks;
 using blink::WebBluetoothRemoteGATTService;
 using blink::WebBluetoothReadValueCallbacks;
 using blink::WebBluetoothRequestDeviceCallbacks;
 using blink::WebBluetoothScanFilter;
 using blink::WebRequestDeviceOptions;
 using blink::WebString;
 using blink::WebVector;
 using NotificationsRequestType =
@@ skipping 33 matching lines @@
   BluetoothCharacteristicsRequest(
       blink::WebString service_instance_id,
       blink::WebBluetoothGetCharacteristicsCallbacks* callbacks)
       : service_instance_id(service_instance_id), callbacks(callbacks) {}
   ~BluetoothCharacteristicsRequest() {}
 
   blink::WebString service_instance_id;
   scoped_ptr<blink::WebBluetoothGetCharacteristicsCallbacks> callbacks;
 };
 
-// Struct that holds a pending WriteValue request.
-struct BluetoothWriteValueRequest {
-  BluetoothWriteValueRequest(const blink::WebVector<uint8_t>& value,
-                             blink::WebBluetoothWriteValueCallbacks* callbacks)
-      : value(value), callbacks(callbacks) {}
-  ~BluetoothWriteValueRequest() {}
-
-  const blink::WebVector<uint8_t> value;
-  scoped_ptr<blink::WebBluetoothWriteValueCallbacks> callbacks;
-};
-
 // Struct that holds a pending Start/StopNotifications request.
 struct BluetoothNotificationsRequest {
   BluetoothNotificationsRequest(
       int frame_routing_id,
       const std::string characteristic_instance_id,
       blink::WebBluetoothRemoteGATTCharacteristic* characteristic,
       blink::WebBluetoothNotificationsCallbacks* callbacks,
       NotificationsRequestType type)
       : frame_routing_id(frame_routing_id),
         characteristic_instance_id(characteristic_instance_id),
@@ skipping 37 matching lines @@
       return WebBluetoothDevice::VendorIDSource::Bluetooth;
     case device::BluetoothDevice::VENDOR_ID_USB:
       return WebBluetoothDevice::VendorIDSource::USB;
   }
   NOTREACHED();
   return WebBluetoothDevice::VendorIDSource::Unknown;
 }
 
 }  // namespace
 
-BluetoothDispatcher::BluetoothDispatcher(ThreadSafeSender* sender)
-    : thread_safe_sender_(sender) {
+BluetoothDispatcher::BluetoothDispatcher(ThreadSafeSender* sender,
+                                         ServiceRegistry* service_registry)
+    : thread_safe_sender_(sender), service_registry_(service_registry) {
   g_dispatcher_tls.Pointer()->Set(static_cast<void*>(this));
 }
 
 BluetoothDispatcher::~BluetoothDispatcher() {

[ortuno, 2016/03/09 01:21:22]

FWIW I tried setting a error handler but it never gets called even when the
Service was destroyed because the renderer process died.

   g_dispatcher_tls.Pointer()->Set(kHasBeenDeleted);
 }
 
 BluetoothDispatcher* BluetoothDispatcher::GetOrCreateThreadSpecificInstance(
-    ThreadSafeSender* thread_safe_sender) {
+    ThreadSafeSender* thread_safe_sender,
+    ServiceRegistry* service_registry) {
   if (g_dispatcher_tls.Pointer()->Get() == kHasBeenDeleted) {
     NOTREACHED() << "Re-instantiating TLS BluetoothDispatcher.";
     g_dispatcher_tls.Pointer()->Set(NULL);
   }
   if (g_dispatcher_tls.Pointer()->Get())
     return static_cast<BluetoothDispatcher*>(g_dispatcher_tls.Pointer()->Get());
 
-  BluetoothDispatcher* dispatcher = new BluetoothDispatcher(thread_safe_sender);
+  BluetoothDispatcher* dispatcher =
+      new BluetoothDispatcher(thread_safe_sender, service_registry);
   if (CurrentWorkerId())
     WorkerThread::AddObserver(dispatcher);
   return dispatcher;
 }
 
 bool BluetoothDispatcher::Send(IPC::Message* msg) {
   return thread_safe_sender_->Send(msg);
 }
 
 void BluetoothDispatcher::OnMessageReceived(const IPC::Message& msg) {
@@ skipping 15 matching lines @@
   IPC_MESSAGE_HANDLER(BluetoothMsg_GetCharacteristicError,
                       OnGetCharacteristicError);
   IPC_MESSAGE_HANDLER(BluetoothMsg_GetCharacteristicsSuccess,
                       OnGetCharacteristicsSuccess);
   IPC_MESSAGE_HANDLER(BluetoothMsg_GetCharacteristicsError,
                       OnGetCharacteristicsError);
   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_HANDLER(BluetoothMsg_StartNotificationsSuccess,
                       OnStartNotificationsSuccess)
   IPC_MESSAGE_HANDLER(BluetoothMsg_StartNotificationsError,
                       OnStartNotificationsError)
   IPC_MESSAGE_HANDLER(BluetoothMsg_StopNotificationsSuccess,
                       OnStopNotificationsSuccess)
   IPC_MESSAGE_HANDLER(BluetoothMsg_CharacteristicValueChanged,
                       OnCharacteristicValueChanged)
   IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
@@ skipping 89 matching lines @@
   Send(new BluetoothHostMsg_ReadValue(CurrentWorkerId(), request_id,
                                       frame_routing_id,
                                       characteristic_instance_id.utf8()));
 }
 
 void BluetoothDispatcher::writeValue(
     int frame_routing_id,
     const blink::WebString& characteristic_instance_id,
     const blink::WebVector<uint8_t>& value,
     blink::WebBluetoothWriteValueCallbacks* callbacks) {
-  int request_id = pending_write_value_requests_.Add(
-      new BluetoothWriteValueRequest(value, callbacks));
-  Send(new BluetoothHostMsg_WriteValue(
-      CurrentWorkerId(), request_id, frame_routing_id,
-      characteristic_instance_id.utf8(),
-      std::vector<uint8_t>(value.begin(), value.end())));
+  GetBluetoothService()->RemoteCharacteristicWriteValue(
+      frame_routing_id, mojo::String::From(characteristic_instance_id),
+      mojo::Array<uint8_t>::From(value),
+      base::Bind(&BluetoothDispatcher::OnWriteValue, base::Unretained(this),

[ortuno, 2016/03/09 01:21:23]

This is safe because if the class gets destroyed the InterfacePtr will also be
destroyed and no messages will arrive right? Or do I need to make a
WeakPtrFactory?

[Ken Rockot(use gerrit already), 2016/03/09 19:31:26]

Correct, the callback will never be invoked if the BluetoothServerPtr has been
reset or destroyed.

+                 value, base::Passed(make_scoped_ptr(callbacks))));
+}
+
+void BluetoothDispatcher::OnWriteValue(
+    const blink::WebVector<uint8_t>& value,
+    scoped_ptr<blink::WebBluetoothWriteValueCallbacks> callbacks,
+    blink::mojom::WebBluetoothError error) {
+  if (error == blink::mojom::WebBluetoothError::SUCCESS) {

[ortuno, 2016/03/09 01:21:23]

It would be nice if there was a way we could do this without having to check for
SUCCESS. Otherwise we will have this logic in all of our functions.

[Ken Rockot(use gerrit already), 2016/03/09 19:31:26]

Can you elaborate on what a more ideal situation would look like?

[ortuno, 2016/03/16 16:29:45]

Jeffrey started a thread about it a while ago:
https://groups.google.com/a/chromium.org/forum/#!msg/mojo-dev/7kNfPXtVLxM/Qea...

+    callbacks->onSuccess(value);
+  } else {
+    callbacks->onError(error);
+  }
 }
 
 void BluetoothDispatcher::startNotifications(
     int frame_routing_id,
     const blink::WebString& characteristic_instance_id,
     blink::WebBluetoothRemoteGATTCharacteristic* characteristic,
     blink::WebBluetoothNotificationsCallbacks* callbacks) {
   int request_id = QueueNotificationRequest(
       frame_routing_id, characteristic_instance_id.utf8(), characteristic,
       callbacks, NotificationsRequestType::START);
@@ skipping 292 matching lines @@
       ->onSuccess(blink::adoptWebPtr(new WebBluetoothDevice(
           WebString::fromUTF8(device.id), WebString(device.name),
           device.tx_power, device.rssi, device.device_class,
           GetWebVendorIdSource(device.vendor_id_source), device.vendor_id,
           device.product_id, device.product_version, uuids)));
   pending_requests_.Remove(request_id);
 }
 
 void BluetoothDispatcher::OnRequestDeviceError(int thread_id,
                                                int request_id,
-                                               WebBluetoothError error) {
+                                               blink::WebBluetoothError error) {
   DCHECK(pending_requests_.Lookup(request_id)) << request_id;
-  pending_requests_.Lookup(request_id)->onError(WebBluetoothError(error));
+  pending_requests_.Lookup(request_id)
+      ->onError(blink::WebBluetoothError(error));
   pending_requests_.Remove(request_id);
 }
 
 void BluetoothDispatcher::OnGATTServerConnectSuccess(int thread_id,
                                                      int request_id) {
   DCHECK(pending_connect_requests_.Lookup(request_id)) << request_id;
   pending_connect_requests_.Lookup(request_id)->onSuccess();
   pending_connect_requests_.Remove(request_id);
 }
 
-void BluetoothDispatcher::OnGATTServerConnectError(int thread_id,
-                                                   int request_id,
-                                                   WebBluetoothError error) {
+void BluetoothDispatcher::OnGATTServerConnectError(
+    int thread_id,
+    int request_id,
+    blink::WebBluetoothError error) {
   DCHECK(pending_connect_requests_.Lookup(request_id)) << request_id;
   pending_connect_requests_.Lookup(request_id)
-      ->onError(WebBluetoothError(error));
+      ->onError(blink::WebBluetoothError(error));
   pending_connect_requests_.Remove(request_id);
 }
 
 void BluetoothDispatcher::OnGetPrimaryServiceSuccess(
     int thread_id,
     int request_id,
     const std::string& service_instance_id) {
   DCHECK(pending_primary_service_requests_.Lookup(request_id)) << request_id;
   BluetoothPrimaryServiceRequest* request =
       pending_primary_service_requests_.Lookup(request_id);
   request->callbacks->onSuccess(
       blink::adoptWebPtr(new WebBluetoothRemoteGATTService(
           WebString::fromUTF8(service_instance_id), request->service_uuid,
           true /* isPrimary */, request->device_id)));
   pending_primary_service_requests_.Remove(request_id);
 }
 
-void BluetoothDispatcher::OnGetPrimaryServiceError(int thread_id,
-                                                   int request_id,
-                                                   WebBluetoothError error) {
+void BluetoothDispatcher::OnGetPrimaryServiceError(
+    int thread_id,
+    int request_id,
+    blink::WebBluetoothError error) {
   DCHECK(pending_primary_service_requests_.Lookup(request_id)) << request_id;
 
   pending_primary_service_requests_.Lookup(request_id)
-      ->callbacks->onError(WebBluetoothError(error));
+      ->callbacks->onError(blink::WebBluetoothError(error));
   pending_primary_service_requests_.Remove(request_id);
 }
 
 void BluetoothDispatcher::OnGetCharacteristicSuccess(
     int thread_id,
     int request_id,
     const std::string& characteristic_instance_id,
     uint32_t characteristic_properties) {
   DCHECK(pending_characteristic_requests_.Lookup(request_id)) << request_id;
 
   BluetoothCharacteristicRequest* request =
       pending_characteristic_requests_.Lookup(request_id);
   request->callbacks->onSuccess(
       blink::adoptWebPtr(new WebBluetoothRemoteGATTCharacteristicInit(
           request->service_instance_id,
           WebString::fromUTF8(characteristic_instance_id),
           request->characteristic_uuid, characteristic_properties)));
 
   pending_characteristic_requests_.Remove(request_id);
 }
 
-void BluetoothDispatcher::OnGetCharacteristicError(int thread_id,
-                                                   int request_id,
-                                                   WebBluetoothError error) {
+void BluetoothDispatcher::OnGetCharacteristicError(
+    int thread_id,
+    int request_id,
+    blink::WebBluetoothError error) {
   DCHECK(pending_characteristic_requests_.Lookup(request_id)) << request_id;
 
   pending_characteristic_requests_.Lookup(request_id)
-      ->callbacks->onError(WebBluetoothError(error));
+      ->callbacks->onError(blink::WebBluetoothError(error));
 
   pending_characteristic_requests_.Remove(request_id);
 }
 
 void BluetoothDispatcher::OnGetCharacteristicsSuccess(
     int thread_id,
     int request_id,
     const std::vector<std::string>& characteristics_instance_ids,
     const std::vector<std::string>& characteristics_uuids,
     const std::vector<uint32_t>& characteristics_properties) {
@@ skipping 12 matching lines @@
         WebString::fromUTF8(characteristics_instance_ids[i]),
         WebString::fromUTF8(characteristics_uuids[i]),
         characteristics_properties[i]);
   }
 
   request->callbacks->onSuccess(blink::adoptWebPtr(characteristics));
 
   pending_characteristics_requests_.Remove(request_id);
 }
 
-void BluetoothDispatcher::OnGetCharacteristicsError(int thread_id,
-                                                    int request_id,
-                                                    WebBluetoothError error) {
+void BluetoothDispatcher::OnGetCharacteristicsError(
+    int thread_id,
+    int request_id,
+    blink::WebBluetoothError error) {
   DCHECK(pending_characteristics_requests_.Lookup(request_id)) << request_id;
 
   pending_characteristics_requests_.Lookup(request_id)
-      ->callbacks->onError(WebBluetoothError(error));
+      ->callbacks->onError(blink::WebBluetoothError(error));
 
   pending_characteristics_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(value);
 
   pending_read_value_requests_.Remove(request_id);
 }
 
 void BluetoothDispatcher::OnReadValueError(int thread_id,
                                            int request_id,
-                                           WebBluetoothError error) {
+                                           blink::WebBluetoothError error) {
   DCHECK(pending_read_value_requests_.Lookup(request_id)) << request_id;
 
   pending_read_value_requests_.Lookup(request_id)
-      ->onError(WebBluetoothError(error));
+      ->onError(blink::WebBluetoothError(error));
 
   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;
-
-  BluetoothWriteValueRequest* request =
-      pending_write_value_requests_.Lookup(request_id);
-  request->callbacks->onSuccess(request->value);
-
-  pending_write_value_requests_.Remove(request_id);
-}
-
-void BluetoothDispatcher::OnWriteValueError(int thread_id,
-                                            int request_id,
-                                            WebBluetoothError error) {
-  DCHECK(pending_write_value_requests_.Lookup(request_id)) << request_id;
-
-  BluetoothWriteValueRequest* request =
-      pending_write_value_requests_.Lookup(request_id);
-  request->callbacks->onError(WebBluetoothError(error));
-
-  pending_write_value_requests_.Remove(request_id);
-}
-
 void BluetoothDispatcher::OnStartNotificationsSuccess(int thread_id,
                                                       int request_id) {
   DCHECK(pending_notifications_requests_.Lookup(request_id)) << request_id;
 
   BluetoothNotificationsRequest* request =
       pending_notifications_requests_.Lookup(request_id);
 
   DCHECK(notification_requests_queues_[request->characteristic_instance_id]
              .front() == request_id);
 
@@ skipping 16 matching lines @@
         request->frame_routing_id, request->characteristic_instance_id,
         nullptr /* characteristic */, nullptr /* callbacks */,
         NotificationsRequestType::STOP);
   }
 
   request->callbacks->onSuccess();
 
   PopNotificationRequestQueueAndProcessNext(request_id);
 }
 
-void BluetoothDispatcher::OnStartNotificationsError(int thread_id,
-                                                    int request_id,
-                                                    WebBluetoothError error) {
+void BluetoothDispatcher::OnStartNotificationsError(
+    int thread_id,
+    int request_id,
+    blink::WebBluetoothError error) {
   DCHECK(pending_notifications_requests_.Lookup(request_id)) << request_id;
 
   BluetoothNotificationsRequest* request =
       pending_notifications_requests_.Lookup(request_id);
 
   DCHECK(notification_requests_queues_[request->characteristic_instance_id]
              .front() == request_id);
 
   // We only send an IPC for inactive notifications.
   DCHECK(
@@ skipping 28 matching lines @@
 void BluetoothDispatcher::OnCharacteristicValueChanged(
     int thread_id,
     const std::string& characteristic_instance_id,
     const std::vector<uint8_t> new_value) {
   auto active_iter = active_characteristics_.find(characteristic_instance_id);
   if (active_iter != active_characteristics_.end()) {
     active_iter->second->dispatchCharacteristicValueChanged(new_value);
   }
 }
 
+mojom::BluetoothServicePtr& BluetoothDispatcher::GetBluetoothService() {
+  if (!bluetooth_service_) {
+    service_registry_->ConnectToRemoteService(
+        mojo::GetProxy(&bluetooth_service_));
+  }
+  return bluetooth_service_;
+}
+
 }  // namespace content