Clean up Bluetooth API implementation.

chrome/browser/extensions/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 "chrome/browser/extensions/api/bluetooth/bluetooth_private_api.h"
 
 #include "base/callback.h"
 #include "base/lazy_instance.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_api.h"
@@ skipping 102 matching lines @@
 }
 
 }  // namespace
 
 BluetoothPrivateSetAdapterStateFunction::
     BluetoothPrivateSetAdapterStateFunction() {}
 
 BluetoothPrivateSetAdapterStateFunction::
     ~BluetoothPrivateSetAdapterStateFunction() {}
 
-bool BluetoothPrivateSetAdapterStateFunction::DoWork(
+void 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;
+    return;
   }
 
   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) {
@@ skipping 13 matching lines @@
   if (discoverable && adapter->IsDiscoverable() != *discoverable) {
     pending_properties_.insert(kDiscoverableProperty);
     adapter->SetDiscoverable(
         *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,
       property_name);
 }
@@ skipping 48 matching lines @@
   SetError(error);
   SendResponse(false);
 }
 
 BluetoothPrivateSetPairingResponseFunction::
     BluetoothPrivateSetPairingResponseFunction() {}
 
 BluetoothPrivateSetPairingResponseFunction::
     ~BluetoothPrivateSetPairingResponseFunction() {}
 
-bool BluetoothPrivateSetPairingResponseFunction::DoWork(
+void BluetoothPrivateSetPairingResponseFunction::DoWork(
     scoped_refptr<device::BluetoothAdapter> adapter) {
   scoped_ptr<bt_private::SetPairingResponse::Params> params(
       bt_private::SetPairingResponse::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   const bt_private::SetPairingResponseOptions& options = params->options;
 
   BluetoothEventRouter* router =
       BluetoothAPI::Get(browser_context())->event_router();
   if (!router->GetPairingDelegate(extension_id())) {
     SetError(kPairingNotEnabled);
     SendResponse(false);
-    return true;
+    return;
   }
 
   const std::string& device_address = options.device.address;
   device::BluetoothDevice* device = adapter->GetDevice(device_address);
   if (!device) {
     SetError(kDeviceNotFoundError);
     SendResponse(false);
-    return true;
+    return;
   }
 
   if (!ValidatePairingResponseOptions(device, options)) {
     SetError(kInvalidPairingResponseOptions);
     SendResponse(false);
-    return true;
+    return;
   }
 
   if (options.pincode.get()) {
     device->SetPinCode(*options.pincode.get());
   } else if (options.passkey.get()) {
     device->SetPasskey(*options.passkey.get());
   } else {
     switch (options.response) {
       case bt_private::PAIRING_RESPONSE_CONFIRM:
         device->ConfirmPairing();
         break;
       case bt_private::PAIRING_RESPONSE_REJECT:
         device->RejectPairing();
         break;
       case bt_private::PAIRING_RESPONSE_CANCEL:
         device->CancelPairing();
         break;
       default:
         NOTREACHED();
     }
   }
 
   SendResponse(true);
-  return true;
 }
 
 }  // namespace api
 
 }  // namespace extensions