Bluetooth Extension API: Add a discovery API

chrome/browser/extensions/api/bluetooth/bluetooth_api.cc

 // Copyright (c) 2012 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 "chrome/browser/extensions/api/bluetooth/bluetooth_api.h"
 
 #if defined(OS_CHROMEOS)
 #include <errno.h>
 #endif
 
 #include <string>
 
-#include "base/utf_string_conversions.h"
+#include "chrome/browser/extensions/api/bluetooth/bluetooth_api_utils.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/experimental_bluetooth.h"
 #include "content/public/browser/browser_thread.h"
 
 #if defined(OS_CHROMEOS)
 #include "base/memory/ref_counted.h"
 #include "base/safe_strerror_posix.h"
-#include "base/synchronization/lock.h"
 #include "chrome/browser/chromeos/bluetooth/bluetooth_adapter.h"
 #include "chrome/browser/chromeos/bluetooth/bluetooth_device.h"
 #include "chrome/browser/chromeos/bluetooth/bluetooth_socket.h"
 #include "chrome/browser/chromeos/extensions/bluetooth_event_router.h"
 #include "chromeos/dbus/bluetooth_out_of_band_client.h"
 
 namespace {
 
 chromeos::ExtensionBluetoothEventRouter* GetEventRouter(Profile* profile) {
   return profile->GetExtensionService()->bluetooth_event_router();
 }
 
 const chromeos::BluetoothAdapter* GetAdapter(Profile* profile) {
   return GetEventRouter(profile)->adapter();
 }
 
 chromeos::BluetoothAdapter* GetMutableAdapter(Profile* profile) {
   return GetEventRouter(profile)->GetMutableAdapter();
 }
 
-// Fill in a Device object from a chromeos::BluetoothDevice.
-void PopulateApiDevice(const chromeos::BluetoothDevice& device,
-                       extensions::api::experimental_bluetooth::Device* out) {
-  out->name = UTF16ToUTF8(device.GetName());
-  out->address = device.address();
-  out->paired = device.IsPaired();
-  out->bonded = device.IsBonded();
-  out->connected = device.IsConnected();
-}
-
-// The caller takes ownership of the returned pointer.
-base::Value* BluetoothDeviceToValue(const chromeos::BluetoothDevice& device) {
-  extensions::api::experimental_bluetooth::Device api_device;
-  PopulateApiDevice(device, &api_device);
-  return api_device.ToValue().release();
-}
-
 }  // namespace
 #endif
 
 namespace {
 
 const char kCouldNotGetLocalOutOfBandPairingData[] =
     "Could not get local Out Of Band Pairing Data";
 const char kCouldNotSetOutOfBandPairingData[] =
     "Could not set Out Of Band Pairing Data";
 const char kFailedToConnect[] = "Connection failed";
 const char kInvalidDevice[] = "Invalid device";
 const char kSocketNotFoundError[] = "Socket not found: invalid socket id";
+const char kStartDiscoveryFailed[] =
+    "Starting discovery failed, or already discovering";
+const char kStopDiscoveryFailed[] = "Failed to stop discovery";
 
 }  // namespace
 
 namespace Connect = extensions::api::experimental_bluetooth::Connect;
 namespace Disconnect = extensions::api::experimental_bluetooth::Disconnect;
 namespace GetDevices = extensions::api::experimental_bluetooth::GetDevices;
 namespace Read = extensions::api::experimental_bluetooth::Read;
 namespace SetOutOfBandPairingData =
     extensions::api::experimental_bluetooth::SetOutOfBandPairingData;
 namespace Write = extensions::api::experimental_bluetooth::Write;
@@ skipping 21 matching lines @@
 BluetoothGetDevicesFunction::BluetoothGetDevicesFunction()
     : callbacks_pending_(0) {}
 
 void BluetoothGetDevicesFunction::AddDeviceIfTrue(
     ListValue* list,
     const chromeos::BluetoothDevice* device,
     bool result) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   if (result)
-    list->Append(BluetoothDeviceToValue(*device));
+    list->Append(experimental_bluetooth::BluetoothDeviceToValue(*device));
 
   callbacks_pending_--;
   if (callbacks_pending_ == -1) {
     SendResponse(true);
     Release();  // Added in RunImpl
   }
 }
 
 bool BluetoothGetDevicesFunction::RunImpl() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
@@ skipping 16 matching lines @@
       GetMutableAdapter(profile())->GetDevices();
   for (chromeos::BluetoothAdapter::DeviceList::iterator i = devices.begin();
       i != devices.end(); ++i) {
     chromeos::BluetoothDevice* device = *i;
 
     if (options.uuid.get() != NULL &&
         !(device->ProvidesServiceWithUUID(*(options.uuid))))
       continue;
 
     if (options.name.get() == NULL) {
-      matches->Append(BluetoothDeviceToValue(*device));
+      matches->Append(experimental_bluetooth::BluetoothDeviceToValue(*device));
       continue;
     }
 
     callbacks_pending_++;
     device->ProvidesServiceWithName(
         *(options.name),
         base::Bind(&BluetoothGetDevicesFunction::AddDeviceIfTrue,
                    this,
                    matches,
                    device));
   }
   callbacks_pending_--;
 
   if (callbacks_pending_ == -1) {
     SendResponse(true);
     Release();
   }
 
   return true;
 }
 
 void BluetoothConnectFunction::ConnectToServiceCallback(
     const chromeos::BluetoothDevice* device,
     const std::string& service_uuid,
     scoped_refptr<chromeos::BluetoothSocket> socket) {
   if (socket.get()) {
     int socket_id = GetEventRouter(profile())->RegisterSocket(socket);
 
     experimental_bluetooth::Socket result_socket;
-    PopulateApiDevice(*device, &result_socket.device);
+    experimental_bluetooth::BluetoothDeviceToApiDevice(
+        *device, &result_socket.device);
     result_socket.service_uuid = service_uuid;
     result_socket.id = socket_id;
     result_.reset(result_socket.ToValue().release());
     SendResponse(true);
   } else {
     SetError(kFailedToConnect);
     SendResponse(false);
   }
 
   Release();  // Added in RunImpl
@@ skipping 228 matching lines @@
 bool BluetoothGetLocalOutOfBandPairingDataFunction::RunImpl() {
   AddRef();  // Released in one of the callbacks below
   GetMutableAdapter(profile())->ReadLocalOutOfBandPairingData(
       base::Bind(&BluetoothGetLocalOutOfBandPairingDataFunction::ReadCallback,
           this),
       base::Bind(&BluetoothGetLocalOutOfBandPairingDataFunction::ErrorCallback,
           this));
   return true;
 }
 
+void BluetoothStartDiscoveryFunction::OnSuccessCallback() {
+  SendResponse(true);
+  Release();  // Added in RunImpl
+}
+
+void BluetoothStartDiscoveryFunction::OnErrorCallback() {
+  SetError(kStartDiscoveryFailed);
+  SendResponse(false);
+  Release();  // Added in RunImpl
+}
+
+bool BluetoothStartDiscoveryFunction::RunImpl() {
+  GetEventRouter(profile())->SetSendDiscoveryEvents(true);
+
+  // BluetoothAdapter will throw an error if we SetDiscovering(true) when
+  // discovery is already in progress
+  if (GetMutableAdapter(profile())->IsDiscovering()) {
+    SendResponse(true);
+    return true;
+  }
+
+  AddRef();  // Removed in whichever callback is called.
+  GetMutableAdapter(profile())->SetDiscovering(true,
+      base::Bind(&BluetoothStartDiscoveryFunction::OnSuccessCallback, this),
+      base::Bind(&BluetoothStartDiscoveryFunction::OnErrorCallback, this));
+  return true;
+}
+
+void BluetoothStopDiscoveryFunction::OnSuccessCallback() {
+  SendResponse(true);
+  Release();  // Added in RunImpl
+}
+
+void BluetoothStopDiscoveryFunction::OnErrorCallback() {
+  SetError(kStopDiscoveryFailed);
+  SendResponse(false);
+  Release();  // Added in RunImpl
+}
+
+bool BluetoothStopDiscoveryFunction::RunImpl() {
+  GetEventRouter(profile())->SetSendDiscoveryEvents(false);
+  AddRef();  // Removed in whichever callback is called.
+  GetMutableAdapter(profile())->SetDiscovering(false,
+      base::Bind(&BluetoothStopDiscoveryFunction::OnSuccessCallback, this),
+      base::Bind(&BluetoothStopDiscoveryFunction::OnErrorCallback, this));
+  return true;
+}
+
 #else
 
 // -----------------------------------------------------------------------------
 // NIY stubs
 // -----------------------------------------------------------------------------
 bool BluetoothIsAvailableFunction::RunImpl() {
   NOTREACHED() << "Not implemented yet";
   return false;
 }
 
@@ skipping 44 matching lines @@
 }
 
 void BluetoothWriteFunction::Work() {
 }
 
 bool BluetoothWriteFunction::Respond() {
   NOTREACHED() << "Not implemented yet";
   return false;
 }
 
+bool BluetoothStartDiscoveryFunction::RunImpl() {
+  NOTREACHED() << "Not implemented yet";
+  return false;
+}
+
+bool BluetoothStopDiscoveryFunction::RunImpl() {
+  NOTREACHED() << "Not implemented yet";
+  return false;
+}
+
 bool BluetoothSetOutOfBandPairingDataFunction::RunImpl() {
   NOTREACHED() << "Not implemented yet";
   return false;
 }
 
 bool BluetoothGetLocalOutOfBandPairingDataFunction::RunImpl() {
   NOTREACHED() << "Not implemented yet";
   return false;
 }
 
 #endif
 
 BluetoothReadFunction::BluetoothReadFunction() {}
 BluetoothReadFunction::~BluetoothReadFunction() {}
 
 BluetoothWriteFunction::BluetoothWriteFunction() {}
 BluetoothWriteFunction::~BluetoothWriteFunction() {}
 
 }  // namespace api
 }  // namespace extensions