bluetooth: Browser side partial implementation of getPrimaryService.

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"
 #include "content/child/thread_safe_sender.h"
 #include "content/common/bluetooth/bluetooth_messages.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/WebBluetoothGATTRemoteServer.h"
+#include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothGATTService.h"
 
 using blink::WebBluetoothConnectGATTCallbacks;
 using blink::WebBluetoothDevice;
 using blink::WebBluetoothError;
 using blink::WebBluetoothGATTRemoteServer;
+using blink::WebBluetoothGATTService;
 using blink::WebBluetoothRequestDeviceCallbacks;
 using blink::WebString;
 using blink::WebVector;
 
 namespace content {
 
 namespace {
 
 base::LazyInstance<base::ThreadLocalPointer<BluetoothDispatcher>>::Leaky
     g_dispatcher_tls = LAZY_INSTANCE_INITIALIZER;
@@ skipping 64 matching lines @@
 }
 
 void BluetoothDispatcher::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(BluetoothDispatcher, msg)
   IPC_MESSAGE_HANDLER(BluetoothMsg_RequestDeviceSuccess,
                       OnRequestDeviceSuccess);
   IPC_MESSAGE_HANDLER(BluetoothMsg_RequestDeviceError, OnRequestDeviceError);
   IPC_MESSAGE_HANDLER(BluetoothMsg_ConnectGATTSuccess, OnConnectGATTSuccess);
   IPC_MESSAGE_HANDLER(BluetoothMsg_ConnectGATTError, OnConnectGATTError);
+  IPC_MESSAGE_HANDLER(BluetoothMsg_GetPrimaryServiceSuccess,
+                      OnGetPrimaryServiceSuccess);
+  IPC_MESSAGE_HANDLER(BluetoothMsg_GetPrimaryServiceError,
+                      OnGetPrimaryServiceError);
   IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled) << "Unhandled message:" << msg.type();
 }
 
 void BluetoothDispatcher::requestDevice(
     blink::WebBluetoothRequestDeviceCallbacks* callbacks) {
   int request_id = pending_requests_.Add(callbacks);
   Send(new BluetoothHostMsg_RequestDevice(CurrentWorkerId(), request_id));
 }
 
 void BluetoothDispatcher::connectGATT(
     const blink::WebString& device_instance_id,
     blink::WebBluetoothConnectGATTCallbacks* callbacks) {
   int request_id = pending_connect_requests_.Add(callbacks);
   Send(new BluetoothHostMsg_ConnectGATT(CurrentWorkerId(), request_id,
                                         device_instance_id.utf8()));
 }
 
+void BluetoothDispatcher::getPrimaryService(
+    const blink::WebString& device_instance_id,
+    const blink::WebString& service_uuid,

[Jeffrey Yasskin, 2015/05/27 18:36:59]

Add a TODO to check that the service_uuid is valid (initially
https://webbluetoothcg.github.io/web-bluetooth/#dfn-valid-uuid, but eventually
https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothuuid-getservice).

I think this can happen on the renderer side: the browser still needs to be
resilient to malformed UUIDs, but it doesn't need to send the right exception
back to a malicious renderer. The renderer can be responsible for producing the
specified exception for bad user-provided strings.

[ortuno, 2015/05/27 21:07:45]

Done.
OK. Once I implement BluetoothUUID I will do the checks in the renderer.

+    blink::WebBluetoothGetPrimaryServiceCallbacks* callbacks) {
+  int request_id = pending_primary_service_requests_.Add(callbacks);
+  Send(new BluetoothHostMsg_GetPrimaryService(CurrentWorkerId(), request_id,
+                                              device_instance_id.utf8(),
+                                              service_uuid.utf8()));
+}
+
 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 38 matching lines @@
                                              BluetoothError error_type) {
   DCHECK(pending_connect_requests_.Lookup(request_id)) << request_id;
   pending_connect_requests_.Lookup(request_id)
       ->onError(new WebBluetoothError(
           // TODO(ortuno): Return more descriptive error messages.
           // http://crbug.com/490419
           WebBluetoothErrorFromBluetoothError(error_type), ""));
   pending_connect_requests_.Remove(request_id);
 }
 
+void BluetoothDispatcher::OnGetPrimaryServiceSuccess(
+    int thread_id,
+    int request_id,
+    const std::string& device_instance_id,
+    const std::string& uuid) {
+  DCHECK(pending_primary_service_requests_.Lookup(request_id)) << request_id;
+  pending_primary_service_requests_.Lookup(request_id)
+      ->onSuccess(new WebBluetoothGATTService(

[Jeffrey Yasskin, 2015/05/27 18:36:59]

Would putting the instance ID in here be more obvious if the spec included a
private [[representedService]] field, like the [[representedDevice]] field for
devices?

[ortuno, 2015/05/27 21:07:45]

I don't think it would make that much of a difference.

+          WebString::fromUTF8(uuid), true /* isPrimary */,
+          WebString::fromUTF8(device_instance_id)));
+  pending_primary_service_requests_.Remove(request_id);
+}
+
+void BluetoothDispatcher::OnGetPrimaryServiceError(int thread_id,
+                                                   int request_id,
+                                                   BluetoothError error_type) {
+  DCHECK(pending_primary_service_requests_.Lookup(request_id)) << request_id;
+
+  // Since we couldn't find the service return null. See Step 3 of
+  // getPrimaryService algorithm:
+  // https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothgattremoteserver-getprimaryservice
+  if (error_type == BluetoothError::NOT_FOUND) {
+    pending_primary_service_requests_.Lookup(request_id)->onSuccess(nullptr);
+    pending_primary_service_requests_.Remove(request_id);
+    return;
+  }
+
+  pending_primary_service_requests_.Lookup(request_id)
+      ->onError(new WebBluetoothError(
+          // TODO(ortuno): Return more descriptive error messages.
+          // http://crbug.com/490419
+          WebBluetoothErrorFromBluetoothError(error_type), ""));
+  pending_primary_service_requests_.Remove(request_id);
+}
+
 }  // namespace content