bluetooth: Use BluetoothAdapter in BluetoothDispatcherHost.

content/browser/bluetooth/bluetooth_dispatcher_host.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/browser/bluetooth/bluetooth_dispatcher_host.h"
 
 #include "content/common/bluetooth/bluetooth_messages.h"
+#include "device/bluetooth/bluetooth_adapter.h"
+#include "device/bluetooth/bluetooth_adapter_factory.h"
+#include "device/bluetooth/bluetooth_device.h"
+
+using device::BluetoothAdapter;
+using device::BluetoothAdapterFactory;
+using device::BluetoothDevice;
 
 namespace content {
 
-BluetoothDispatcherHost::BluetoothDispatcherHost()
-    : BrowserMessageFilter(BluetoothMsgStart),
-      bluetooth_mock_data_set_(MockData::NOT_MOCKING),
-      bluetooth_request_device_reject_type_(BluetoothError::NOT_FOUND) {
+scoped_refptr<BluetoothDispatcherHost> BluetoothDispatcherHost::Create() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  // Hold a reference to the BluetoothDispatcherHost because the callback below
+  // may run and would otherwise release the BluetoothDispatcherHost
+  // prematurely.
+  scoped_refptr<BluetoothDispatcherHost> host(new BluetoothDispatcherHost());
+  if (BluetoothAdapterFactory::IsBluetoothAdapterAvailable())
+    BluetoothAdapterFactory::GetAdapter(
+        base::Bind(&BluetoothDispatcherHost::set_adapter, host));
+  return host;
 }
 
 bool BluetoothDispatcherHost::OnMessageReceived(const IPC::Message& message) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(BluetoothDispatcherHost, message)
   IPC_MESSAGE_HANDLER(BluetoothHostMsg_RequestDevice, OnRequestDevice)
   IPC_MESSAGE_HANDLER(BluetoothHostMsg_SetBluetoothMockDataSetForTesting,
                       OnSetBluetoothMockDataSetForTesting)
   IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
+BluetoothDispatcherHost::BluetoothDispatcherHost()
+    : BrowserMessageFilter(BluetoothMsgStart),
+      bluetooth_mock_data_set_(MockData::NOT_MOCKING),
+      bluetooth_request_device_reject_type_(BluetoothError::NOT_FOUND) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+}
+
 BluetoothDispatcherHost::~BluetoothDispatcherHost() {
+  // Clear adapter, releasing observer references.
+  set_adapter(scoped_refptr<device::BluetoothAdapter>());
+}
+
+void BluetoothDispatcherHost::set_adapter(
+    scoped_refptr<device::BluetoothAdapter> adapter) {
+  if (adapter_.get())
+    adapter_->RemoveObserver(this);
+  adapter_ = adapter;
+  if (adapter_.get())
+    adapter_->AddObserver(this);
 }
 
 void BluetoothDispatcherHost::OnRequestDevice(int thread_id, int request_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // Mock implementation util a more complete implementation is built out.

[armansito, 2014/12/10 00:40:04]

nit: s/util/until/ ?

[scheib, 2014/12/10 17:54:02]

Done.

   switch (bluetooth_mock_data_set_) {
     case MockData::NOT_MOCKING: {
-      Send(new BluetoothMsg_RequestDeviceError(thread_id, request_id,
-                                               BluetoothError::NOT_FOUND));
+      // TODO(scheib): Filter devices by services: crbug.com/440594
+      // TODO(scheib): Device selection UI: crbug.com/436280
+      BluetoothAdapter::DeviceList devices = adapter_->GetDevices();

[armansito, 2014/12/10 00:40:04]

I don't know what the final behavior will look like in the end but the correct
way to find devices is to not only check within GetDevices but also to initiate
device discovery and observing new devices via
BluetoothAdapter::Observer::DeviceAdded.

[scheib, 2014/12/10 17:54:02]

Done.

+      if (devices.begin() == devices.end()) {
+        Send(new BluetoothMsg_RequestDeviceError(thread_id, request_id,
+                                                 BluetoothError::NOT_FOUND));
+      } else {
+        BluetoothDevice* device = *devices.begin();
+        Send(new BluetoothMsg_RequestDeviceSuccess(thread_id, request_id,
+                                                   device->GetAddress()));
+      }
       return;
     }
     case MockData::REJECT: {
       Send(new BluetoothMsg_RequestDeviceError(
           thread_id, request_id, bluetooth_request_device_reject_type_));
       return;
     }
     case MockData::RESOLVE: {
       Send(new BluetoothMsg_RequestDeviceSuccess(thread_id, request_id,
                                                  "Empty Mock deviceId"));
@@ skipping 14 matching lines @@
     bluetooth_request_device_reject_type_ = BluetoothError::SECURITY;
   } else if (name == "ResolveRequestDevice_Empty" ||  // TODO(scheib): Remove.
              name == "Single Empty Device") {
     bluetooth_mock_data_set_ = MockData::RESOLVE;
   } else {
     bluetooth_mock_data_set_ = MockData::NOT_MOCKING;
   }
 }
 
 }  // namespace content