Add bluetoothPrivate.connect

extensions/browser/api/bluetooth/bluetooth_private_api.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 "extensions/browser/api/bluetooth/bluetooth_private_api.h"
 
 #include "base/callback.h"
 #include "base/lazy_instance.h"
 #include "base/strings/string_util.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
 #include "extensions/browser/api/bluetooth/bluetooth_api.h"
 #include "extensions/browser/api/bluetooth/bluetooth_api_pairing_delegate.h"
 #include "extensions/browser/api/bluetooth/bluetooth_event_router.h"
 #include "extensions/common/api/bluetooth_private.h"
 
 namespace bt_private = extensions::api::bluetooth_private;
 namespace SetDiscoveryFilter = bt_private::SetDiscoveryFilter;
 
 namespace extensions {
 
-static base::LazyInstance<BrowserContextKeyedAPIFactory<BluetoothPrivateAPI> >
+static base::LazyInstance<BrowserContextKeyedAPIFactory<BluetoothPrivateAPI>>
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
+namespace {
+
+std::string GetListenerId(const EventListenerInfo& details) {
+  return !details.extension_id.empty() ? details.extension_id
+                                       : details.listener_url.host();
+}
+
+}  // namespace
+
 // static
 BrowserContextKeyedAPIFactory<BluetoothPrivateAPI>*
 BluetoothPrivateAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 BluetoothPrivateAPI::BluetoothPrivateAPI(content::BrowserContext* context)
     : browser_context_(context) {
   EventRouter::Get(browser_context_)
       ->RegisterObserver(this, bt_private::OnPairing::kEventName);
 }
 
 BluetoothPrivateAPI::~BluetoothPrivateAPI() {}
 
 void BluetoothPrivateAPI::Shutdown() {
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
 void BluetoothPrivateAPI::OnListenerAdded(const EventListenerInfo& details) {
   // This function can be called multiple times for the same JS listener, for
   // example, once for the addListener call and again if it is a lazy listener.
   if (!details.browser_context)
     return;
 
-  BluetoothAPI::Get(browser_context_)->event_router()->AddPairingDelegate(
-      details.extension_id);
+  BluetoothAPI::Get(browser_context_)
+      ->event_router()
+      ->AddPairingDelegate(GetListenerId(details));
 }
 
 void BluetoothPrivateAPI::OnListenerRemoved(const EventListenerInfo& details) {
   // This function can be called multiple times for the same JS listener, for
   // example, once for the addListener call and again if it is a lazy listener.
   if (!details.browser_context)
     return;
 
-  BluetoothAPI::Get(browser_context_)->event_router()->RemovePairingDelegate(
-      details.extension_id);
+  BluetoothAPI::Get(browser_context_)
+      ->event_router()
+      ->RemovePairingDelegate(GetListenerId(details));
 }
 
 namespace api {
 
 namespace {
 
 const char kNameProperty[] = "name";
 const char kPoweredProperty[] = "powered";
 const char kDiscoverableProperty[] = "discoverable";
-
 const char kSetAdapterPropertyError[] = "Error setting adapter properties: $1";
-
-const char kDeviceNotFoundError[] =
-    "Given address is not a valid Bluetooth device.";
-
-const char kDeviceNotConnectedError[] = "Device is not connected";
-
-const char kPairingNotEnabled[] =
-    "Pairing must be enabled to set a pairing response.";
-
+const char kDeviceNotFoundError[] = "Invalid Bluetooth device";
+const char kDeviceConnectedError[] = "Device already connected";
+const char kDeviceNotConnectedError[] = "Device not connected";
+const char kPairingNotEnabled[] = "Pairing not enabled";
 const char kInvalidPairingResponseOptions[] =
     "Invalid pairing response options";
-
-const char kAdapterNotPresent[] =
-    "Could not find a Bluetooth adapter.";
-
+const char kAdapterNotPresent[] = "Failed to find a Bluetooth adapter.";
 const char kDisconnectError[] = "Failed to disconnect device";
-
 const char kSetDiscoveryFilterFailed[] = "Failed to set discovery filter";
-
 const char kPairingFailed[] = "Pairing failed";
 
 // Returns true if the pairing response options passed into the
 // setPairingResponse function are valid.
 bool ValidatePairingResponseOptions(
     const device::BluetoothDevice* device,
     const bt_private::SetPairingResponseOptions& options) {
   bool response = options.response != bt_private::PAIRING_RESPONSE_NONE;
-  bool pincode = options.pincode.get() != NULL;
-  bool passkey = options.passkey.get() != NULL;
+  bool pincode = options.pincode.get() != nullptr;
+  bool passkey = options.passkey.get() != nullptr;
 
   if (!response && !pincode && !passkey)
     return false;
   if (pincode && passkey)
     return false;
   if (options.response != bt_private::PAIRING_RESPONSE_CONFIRM &&
       (pincode || passkey))
     return false;
 
   // Check the BluetoothDevice is in expecting the correct response.
   if (!device->ExpectingConfirmation() && !device->ExpectingPinCode() &&
       !device->ExpectingPasskey())
     return false;
   if (pincode && !device->ExpectingPinCode())
     return false;
   if (passkey && !device->ExpectingPasskey())
     return false;
   if (options.response == bt_private::PAIRING_RESPONSE_CONFIRM && !pincode &&
       !passkey && !device->ExpectingConfirmation())
     return false;
 
   return true;
 }
 
 }  // namespace
 
+////////////////////////////////////////////////////////////////////////////////
+
 BluetoothPrivateSetAdapterStateFunction::
     BluetoothPrivateSetAdapterStateFunction() {}
 
 BluetoothPrivateSetAdapterStateFunction::
     ~BluetoothPrivateSetAdapterStateFunction() {}
 
 bool BluetoothPrivateSetAdapterStateFunction::DoWork(
     scoped_refptr<device::BluetoothAdapter> adapter) {
   scoped_ptr<bt_private::SetAdapterState::Params> params(
       bt_private::SetAdapterState::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   if (!adapter->IsPresent()) {
     SetError(kAdapterNotPresent);
     SendResponse(false);
     return true;
   }
 
   const bt_private::NewAdapterState& new_state = params->adapter_state;
 
   // These properties are not owned.
   std::string* name = new_state.name.get();
   bool* powered = new_state.powered.get();
   bool* discoverable = new_state.discoverable.get();
 
   if (name && adapter->GetName() != *name) {
     pending_properties_.insert(kNameProperty);
-    adapter->SetName(*name,
-                     CreatePropertySetCallback(kNameProperty),
+    adapter->SetName(*name, CreatePropertySetCallback(kNameProperty),
                      CreatePropertyErrorCallback(kNameProperty));
   }
 
   if (powered && adapter->IsPowered() != *powered) {
     pending_properties_.insert(kPoweredProperty);
-    adapter->SetPowered(*powered,
-                        CreatePropertySetCallback(kPoweredProperty),
+    adapter->SetPowered(*powered, CreatePropertySetCallback(kPoweredProperty),
                         CreatePropertyErrorCallback(kPoweredProperty));
   }
 
   if (discoverable && adapter->IsDiscoverable() != *discoverable) {
     pending_properties_.insert(kDiscoverableProperty);
     adapter->SetDiscoverable(
-        *discoverable,
-        CreatePropertySetCallback(kDiscoverableProperty),
+        *discoverable, CreatePropertySetCallback(kDiscoverableProperty),
         CreatePropertyErrorCallback(kDiscoverableProperty));
   }
 
   if (pending_properties_.empty())
     SendResponse(true);
   return true;
 }
 
 base::Closure
 BluetoothPrivateSetAdapterStateFunction::CreatePropertySetCallback(
     const std::string& property_name) {
   return base::Bind(
-      &BluetoothPrivateSetAdapterStateFunction::OnAdapterPropertySet,
-      this,
+      &BluetoothPrivateSetAdapterStateFunction::OnAdapterPropertySet, this,
       property_name);
 }
 
 base::Closure
 BluetoothPrivateSetAdapterStateFunction::CreatePropertyErrorCallback(
     const std::string& property_name) {
   return base::Bind(
-      &BluetoothPrivateSetAdapterStateFunction::OnAdapterPropertyError,
-      this,
+      &BluetoothPrivateSetAdapterStateFunction::OnAdapterPropertyError, this,
       property_name);
 }
 
 void BluetoothPrivateSetAdapterStateFunction::OnAdapterPropertySet(
     const std::string& property) {
   DCHECK(pending_properties_.find(property) != pending_properties_.end());
   DCHECK(failed_properties_.find(property) == failed_properties_.end());
 
   pending_properties_.erase(property);
   if (pending_properties_.empty()) {
@@ skipping 13 matching lines @@
   failed_properties_.insert(property);
   if (pending_properties_.empty())
     SendError();
 }
 
 void BluetoothPrivateSetAdapterStateFunction::SendError() {
   DCHECK(pending_properties_.empty());
   DCHECK(!failed_properties_.empty());
 
   std::vector<std::string> failed_vector;
-  std::copy(failed_properties_.begin(),
-            failed_properties_.end(),
+  std::copy(failed_properties_.begin(), failed_properties_.end(),
             std::back_inserter(failed_vector));
 
   std::vector<std::string> replacements(1);
   replacements[0] = base::JoinString(failed_vector, ", ");
   std::string error = base::ReplaceStringPlaceholders(kSetAdapterPropertyError,
-                                                      replacements, NULL);
+                                                      replacements, nullptr);
   SetError(error);
   SendResponse(false);
 }
 
+////////////////////////////////////////////////////////////////////////////////
+
 BluetoothPrivateSetPairingResponseFunction::
     BluetoothPrivateSetPairingResponseFunction() {}
 
 BluetoothPrivateSetPairingResponseFunction::
     ~BluetoothPrivateSetPairingResponseFunction() {}
 
 bool BluetoothPrivateSetPairingResponseFunction::DoWork(
     scoped_refptr<device::BluetoothAdapter> adapter) {
   scoped_ptr<bt_private::SetPairingResponse::Params> params(
       bt_private::SetPairingResponse::Params::Create(*args_));
@@ skipping 39 matching lines @@
         break;
       default:
         NOTREACHED();
     }
   }
 
   SendResponse(true);
   return true;
 }
 
+////////////////////////////////////////////////////////////////////////////////
+
 BluetoothPrivateDisconnectAllFunction::BluetoothPrivateDisconnectAllFunction() {
 }
 
 BluetoothPrivateDisconnectAllFunction::
-    ~BluetoothPrivateDisconnectAllFunction() {
-}
+    ~BluetoothPrivateDisconnectAllFunction() {}
 
 bool BluetoothPrivateDisconnectAllFunction::DoWork(
     scoped_refptr<device::BluetoothAdapter> adapter) {
   scoped_ptr<bt_private::DisconnectAll::Params> params(
       bt_private::DisconnectAll::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   device::BluetoothDevice* device = adapter->GetDevice(params->device_address);
   if (!device) {
     SetError(kDeviceNotFoundError);
@@ skipping 28 matching lines @@
   // error.
   device::BluetoothDevice* device = adapter->GetDevice(device_address);
   if (device && !device->IsConnected())
     SetError(kDeviceNotConnectedError);
   else
     SetError(kDisconnectError);
 
   SendResponse(false);
 }
 
-void BluetoothPrivateSetDiscoveryFilterFunction::OnSuccessCallback() {
-  SendResponse(true);
-}
-
-void BluetoothPrivateSetDiscoveryFilterFunction::OnErrorCallback() {
-  SetError(kSetDiscoveryFilterFailed);
-  SendResponse(false);
-}
+////////////////////////////////////////////////////////////////////////////////
 
 bool BluetoothPrivateSetDiscoveryFilterFunction::DoWork(
     scoped_refptr<device::BluetoothAdapter> adapter) {
   scoped_ptr<SetDiscoveryFilter::Params> params(
       SetDiscoveryFilter::Params::Create(*args_));
   auto& df_param = params->discovery_filter;
 
   scoped_ptr<device::BluetoothDiscoveryFilter> discovery_filter;
 
   // If all filter fields are empty, we are clearing filter. If any field is
@@ skipping 42 matching lines @@
           discovery_filter.Pass(), adapter.get(), GetExtensionId(),
           base::Bind(
               &BluetoothPrivateSetDiscoveryFilterFunction::OnSuccessCallback,
               this),
           base::Bind(
               &BluetoothPrivateSetDiscoveryFilterFunction::OnErrorCallback,
               this));
   return true;
 }
 
+void BluetoothPrivateSetDiscoveryFilterFunction::OnSuccessCallback() {
+  SendResponse(true);
+}
+
+void BluetoothPrivateSetDiscoveryFilterFunction::OnErrorCallback() {
+  SetError(kSetDiscoveryFilterFailed);
+  SendResponse(false);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+BluetoothPrivateConnectFunction::BluetoothPrivateConnectFunction() {}
+
+BluetoothPrivateConnectFunction::~BluetoothPrivateConnectFunction() {}
+
+bool BluetoothPrivateConnectFunction::DoWork(
+    scoped_refptr<device::BluetoothAdapter> adapter) {
+  scoped_ptr<bt_private::Connect::Params> params(
+      bt_private::Connect::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+
+  device::BluetoothDevice* device = adapter->GetDevice(params->device_address);
+  if (!device) {
+    SetError(kDeviceNotFoundError);
+    SendResponse(false);
+    return true;
+  }
+
+  if (device->IsConnected()) {
+    SetError(kDeviceConnectedError);
+    SendResponse(false);
+    return true;
+  }
+
+  device::BluetoothDevice::PairingDelegate* pairing_delegate =
+      BluetoothAPI::Get(browser_context())
+          ->event_router()
+          ->GetPairingDelegate(GetExtensionId());
+  if (!pairing_delegate) {
+    LOG(ERROR) << "No pairing delegate for: " << GetExtensionId();
+    SetError(kPairingNotEnabled);
+    SendResponse(false);
+    return true;
+  }
+  device->Connect(
+      pairing_delegate,
+      base::Bind(&BluetoothPrivateConnectFunction::OnSuccessCallback, this),
+      base::Bind(&BluetoothPrivateConnectFunction::OnErrorCallback, this));
+  return true;
+}
+
+void BluetoothPrivateConnectFunction::OnSuccessCallback() {
+  results_ = bt_private::Connect::Results::Create(
+      bt_private::CONNECT_RESULT_TYPE_SUCCESS);
+  SendResponse(true);
+}
+
+void BluetoothPrivateConnectFunction::OnErrorCallback(
+    device::BluetoothDevice::ConnectErrorCode error) {
+  bt_private::ConnectResultType result = bt_private::CONNECT_RESULT_TYPE_NONE;
+  switch (error) {
+    case device::BluetoothDevice::ERROR_UNKNOWN:
+      result = bt_private::CONNECT_RESULT_TYPE_UNKNOWNERROR;
+      break;
+    case device::BluetoothDevice::ERROR_INPROGRESS:
+      result = bt_private::CONNECT_RESULT_TYPE_INPROGRESS;
+      break;
+    case device::BluetoothDevice::ERROR_FAILED:
+      result = bt_private::CONNECT_RESULT_TYPE_FAILED;
+      break;
+    case device::BluetoothDevice::ERROR_AUTH_FAILED:
+      result = bt_private::CONNECT_RESULT_TYPE_AUTHFAILED;
+      break;
+    case device::BluetoothDevice::ERROR_AUTH_CANCELED:
+      result = bt_private::CONNECT_RESULT_TYPE_AUTHCANCELED;
+      break;
+    case device::BluetoothDevice::ERROR_AUTH_REJECTED:
+      result = bt_private::CONNECT_RESULT_TYPE_AUTHREJECTED;
+      break;
+    case device::BluetoothDevice::ERROR_AUTH_TIMEOUT:
+      result = bt_private::CONNECT_RESULT_TYPE_AUTHTIMEOUT;
+      break;
+    case device::BluetoothDevice::ERROR_UNSUPPORTED_DEVICE:
+      result = bt_private::CONNECT_RESULT_TYPE_UNSUPPORTEDDEVICE;
+      break;
+  }
+  // Set the result type and respond with true (success).
+  results_ = bt_private::Connect::Results::Create(result);
+  SendResponse(true);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 BluetoothPrivatePairFunction::BluetoothPrivatePairFunction() {}
 
 BluetoothPrivatePairFunction::~BluetoothPrivatePairFunction() {}
 
-void BluetoothPrivatePairFunction::OnSuccessCallback() {
-  SendResponse(true);
-}
-
-void BluetoothPrivatePairFunction::OnErrorCallback(
-    device::BluetoothDevice::ConnectErrorCode error) {
-  SetError(kPairingFailed);
-  SendResponse(false);
-}
-
 bool BluetoothPrivatePairFunction::DoWork(
     scoped_refptr<device::BluetoothAdapter> adapter) {
   scoped_ptr<bt_private::Pair::Params> params(
       bt_private::Pair::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
 
   device::BluetoothDevice* device = adapter->GetDevice(params->device_address);
   if (!device) {
     SetError(kDeviceNotFoundError);
     SendResponse(false);
     return true;
   }
 
   BluetoothEventRouter* router =
       BluetoothAPI::Get(browser_context())->event_router();
   if (!router->GetPairingDelegate(GetExtensionId())) {
     SetError(kPairingNotEnabled);
     SendResponse(false);
     return true;
   }
 
   device->Pair(
       router->GetPairingDelegate(GetExtensionId()),
       base::Bind(&BluetoothPrivatePairFunction::OnSuccessCallback, this),
       base::Bind(&BluetoothPrivatePairFunction::OnErrorCallback, this));
   return true;
 }
 
+void BluetoothPrivatePairFunction::OnSuccessCallback() {
+  SendResponse(true);
+}
+
+void BluetoothPrivatePairFunction::OnErrorCallback(
+    device::BluetoothDevice::ConnectErrorCode error) {
+  SetError(kPairingFailed);
+  SendResponse(false);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 }  // namespace api
 
 }  // namespace extensions