bluetooth: Impl uses new WebBluetoothGATTRemoteServer content/browser.

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"
 
 using blink::WebBluetoothDevice;
 using blink::WebBluetoothError;
 using blink::WebBluetoothRequestDeviceCallbacks;
+using blink::WebBluetoothGATTRemoteServer;

[scheib, 2015/04/19 04:44:19]

sort these lines. (surprised a script didn't mention it already?)

[ortuno, 2015/04/20 20:09:33]

Done.

+using blink::WebBluetoothConnectGATTCallbacks;
 using blink::WebString;
 using blink::WebVector;
 
 namespace content {
 
 namespace {
 
 base::LazyInstance<base::ThreadLocalPointer<BluetoothDispatcher>>::Leaky
     g_dispatcher_tls = LAZY_INSTANCE_INITIALIZER;
 
@@ skipping 59 matching lines @@
 bool BluetoothDispatcher::Send(IPC::Message* msg) {
   return thread_safe_sender_->Send(msg);
 }
 
 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_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(std::string instance_id,
+    blink::WebBluetoothConnectGATTCallbacks* callbacks) {
+  int request_id = pending_connect_requests_.Add(callbacks);
+  Send(new BluetoothHostMsg_ConnectGATT(CurrentWorkerId(), request_id,
+                                        instance_id));
+}
+
 void BluetoothDispatcher::SetBluetoothMockDataSetForTesting(
     const std::string& name) {
   Send(new BluetoothHostMsg_SetBluetoothMockDataSetForTesting(name));
 }
 
 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;
 
   WebVector<WebString> uuids(device.uuids.size());
   for (size_t i = 0; i < device.uuids.size(); ++i)
     uuids[i] = WebString::fromUTF8(device.uuids[i].c_str());
 
   pending_requests_.Lookup(request_id)
       ->onSuccess(new WebBluetoothDevice(
           WebString::fromUTF8(device.instance_id), WebString(device.name),
           device.device_class, GetWebVendorIdSource(device.vendor_id_source),
           device.vendor_id, device.product_id, device.product_version,
           device.paired, device.connected, uuids));
   pending_requests_.Remove(request_id);
 }
 
+void BluetoothDispatcher::OnConnectGATTSuccess(int thread_id,
+                                               int request_id,
+                                               const std::string& instance_id) {
+  DCHECK(pending_connect_requests_.Lookup(request_id)) << request_id;

[Tom Sepez, 2015/04/20 15:54:00]

This is in the renderer, so it OK to assume that the more trusted browser
process won't send a bad response, right?

[scheib, 2015/04/20 16:50:12]

Right. If the browser is functioning correctly it will send a valid response. It
is not a security concern if it doesn't, we'll just crash the renderer on the
call to onSuccess below from null pointer. As it's not expected to be data we
should handle, and not a security concern, it's DCHECK.
https://www.chromium.org/developers/coding-style#TOC-CHECK-DCHECK-and-NOTREAC...

+  pending_connect_requests_.Lookup(request_id)
+      ->onSuccess(new WebBluetoothGATTRemoteServer(
+          WebString::fromUTF8(instance_id), true /* connected */));
+  pending_connect_requests_.Remove(request_id);
+}
+
 void BluetoothDispatcher::OnRequestDeviceError(int thread_id,
                                                int request_id,
                                                BluetoothError error_type) {
   DCHECK(pending_requests_.Lookup(request_id)) << request_id;
   pending_requests_.Lookup(request_id)
       ->onError(new WebBluetoothError(
           WebBluetoothErrorFromBluetoothError(error_type), ""));
   pending_requests_.Remove(request_id);
 }
 
 }  // namespace content