bluetoothPrivate: Add disconnectAll function

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"
@@ skipping 53 matching lines @@
 
 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 kInvalidPairingResponseOptions[] =
     "Invalid pairing response options";
 
 const char kAdapterNotPresent[] =
     "Could not find a Bluetooth adapter.";
 
+const char kDisconnectError[] = "Failed to disconnect device";
+
 // 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;
 
   if (!response && !pincode && !passkey)
@@ skipping 185 matching lines @@
         break;
       default:
         NOTREACHED();
     }
   }
 
   SendResponse(true);
   return true;
 }
 
+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);
+    SendResponse(false);
+    return true;
+  }
+
+  if (!device->IsConnected()) {
+    SetError(kDeviceNotConnectedError);
+    SendResponse(false);
+    return true;
+  }
+
+  device->Disconnect(
+      base::Bind(&BluetoothPrivateDisconnectAllFunction::OnSuccessCallback,
+                 this),
+      base::Bind(&BluetoothPrivateDisconnectAllFunction::OnErrorCallback, this,
+                 adapter, params->device_address));
+
+  return true;
+}
+
+void BluetoothPrivateDisconnectAllFunction::OnSuccessCallback() {
+  SendResponse(true);
+}
+
+void BluetoothPrivateDisconnectAllFunction::OnErrorCallback(
+    scoped_refptr<device::BluetoothAdapter> adapter,
+    const std::string& device_address) {
+  // The call to Disconnect may report an error if the device was disconnected
+  // due to an external reason. In this case, report "Not Connected" as the
+  // error.
+  device::BluetoothDevice* device = adapter->GetDevice(device_address);
+  if (device && !device->IsConnected())
+    SetError(kDeviceNotConnectedError);
+  else
+    SetError(kDisconnectError);
+
+  SendResponse(false);
+}
+
 }  // namespace core_api
 
 }  // namespace extensions