Implement chrome.bluetoothLowEnergy.resetAdvertising().

extensions/browser/api/bluetooth_low_energy/bluetooth_low_energy_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_low_energy/bluetooth_low_energy_api.h"
 
 #include <stdint.h>
 #include <algorithm>
 #include <iterator>
 #include <utility>
@@ skipping 336 matching lines @@
 }
 
 BluetoothLowEnergyAPI::~BluetoothLowEnergyAPI() {}
 
 void BluetoothLowEnergyAPI::Shutdown() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 namespace api {
 
-BluetoothLowEnergyExtensionFunctionDeprecated::
-    BluetoothLowEnergyExtensionFunctionDeprecated() {}
-
-BluetoothLowEnergyExtensionFunctionDeprecated::
-    ~BluetoothLowEnergyExtensionFunctionDeprecated() {}
-
-bool BluetoothLowEnergyExtensionFunctionDeprecated::RunAsync() {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-  if (!BluetoothManifestData::CheckLowEnergyPermitted(extension())) {
-    error_ = kErrorPermissionDenied;
-    return false;
-  }
-
-  BluetoothLowEnergyEventRouter* event_router =
-      GetEventRouter(browser_context());
-  if (!event_router->IsBluetoothSupported()) {
-    SetError(kErrorPlatformNotSupported);
-    return false;
-  }
-
-  // It is safe to pass |this| here as ExtensionFunction is refcounted.
-  if (!event_router->InitializeAdapterAndInvokeCallback(base::Bind(
-          &DoWorkCallback<bool>,
-          base::Bind(&BluetoothLowEnergyExtensionFunctionDeprecated::DoWork,
-                     this)))) {
-    SetError(kErrorAdapterNotInitialized);
-    return false;
-  }
-
-  return true;
-}
-
 BluetoothLowEnergyExtensionFunction::BluetoothLowEnergyExtensionFunction()
     : event_router_(nullptr) {}
 
 BluetoothLowEnergyExtensionFunction::~BluetoothLowEnergyExtensionFunction() {}
 
 ExtensionFunction::ResponseAction BluetoothLowEnergyExtensionFunction::Run() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!BluetoothManifestData::CheckLowEnergyPermitted(extension()))
     return RespondNow(Error(kErrorPermissionDenied));
@@ skipping 45 matching lines @@
 
 // Causes link error on Windows. API will never be on Windows, so #ifdefing.
 #if !defined(OS_WIN)
   params_ = Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get() != NULL);
 #endif
 
   return BluetoothLowEnergyExtensionFunction::Run();
 }
 
-bool BluetoothLowEnergyConnectFunction::DoWork() {
+void BluetoothLowEnergyConnectFunction::DoWork() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BluetoothLowEnergyEventRouter* event_router =
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
-    SetError(kErrorAdapterNotInitialized);
-    SendResponse(false);
-    return false;
+    Respond(Error(kErrorAdapterNotInitialized));
+    return;
   }
 
   std::unique_ptr<apibtle::Connect::Params> params(
       apibtle::Connect::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   bool persistent = false;  // Not persistent by default.
   apibtle::ConnectProperties* properties = params->properties.get();
   if (properties)
     persistent = properties->persistent;
 
   event_router->Connect(
       persistent, extension(), params->device_address,
       base::Bind(&BluetoothLowEnergyConnectFunction::SuccessCallback, this),
       base::Bind(&BluetoothLowEnergyConnectFunction::ErrorCallback, this));
-
-  return true;
 }
 
 void BluetoothLowEnergyConnectFunction::SuccessCallback() {
-  SendResponse(true);
+  Respond(NoArguments());
 }
 
 void BluetoothLowEnergyConnectFunction::ErrorCallback(
     BluetoothLowEnergyEventRouter::Status status) {
-  SetError(StatusToString(status));
-  SendResponse(false);
+  Respond(Error(StatusToString(status)));
 }
 
-bool BluetoothLowEnergyDisconnectFunction::DoWork() {
+void BluetoothLowEnergyDisconnectFunction::DoWork() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BluetoothLowEnergyEventRouter* event_router =
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
-    SetError(kErrorAdapterNotInitialized);
-    SendResponse(false);
-    return false;
+    Respond(Error(kErrorAdapterNotInitialized));
+    return;
   }
 
   std::unique_ptr<apibtle::Disconnect::Params> params(
       apibtle::Disconnect::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   event_router->Disconnect(
       extension(), params->device_address,
       base::Bind(&BluetoothLowEnergyDisconnectFunction::SuccessCallback, this),
       base::Bind(&BluetoothLowEnergyDisconnectFunction::ErrorCallback, this));
-
-  return true;
 }
 
 void BluetoothLowEnergyDisconnectFunction::SuccessCallback() {
-  SendResponse(true);
+  Respond(NoArguments());
 }
 
 void BluetoothLowEnergyDisconnectFunction::ErrorCallback(
     BluetoothLowEnergyEventRouter::Status status) {
-  SetError(StatusToString(status));
-  SendResponse(false);
+  Respond(Error(StatusToString(status)));
 }
 
-bool BluetoothLowEnergyGetServiceFunction::DoWork() {
+void BluetoothLowEnergyGetServiceFunction::DoWork() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BluetoothLowEnergyEventRouter* event_router =
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
-    SetError(kErrorAdapterNotInitialized);
-    SendResponse(false);
-    return false;
+    Respond(Error(kErrorAdapterNotInitialized));
+    return;
   }
 
   std::unique_ptr<apibtle::GetService::Params> params(
       apibtle::GetService::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   apibtle::Service service;
   BluetoothLowEnergyEventRouter::Status status =
       event_router->GetService(params->service_id, &service);
   if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
-    SetError(StatusToString(status));
-    SendResponse(false);
-    return false;
+    Respond(Error(StatusToString(status)));
+    return;
   }
 
-  results_ = apibtle::GetService::Results::Create(service);
-  SendResponse(true);
-
-  return true;
+  Respond(ArgumentList(apibtle::GetService::Results::Create(service)));
 }
 
-bool BluetoothLowEnergyGetServicesFunction::DoWork() {
+void BluetoothLowEnergyGetServicesFunction::DoWork() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BluetoothLowEnergyEventRouter* event_router =
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
-    SetError(kErrorAdapterNotInitialized);
-    SendResponse(false);
-    return false;
+    Respond(Error(kErrorAdapterNotInitialized));
+    return;
   }
 
   std::unique_ptr<apibtle::GetServices::Params> params(
       apibtle::GetServices::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   BluetoothLowEnergyEventRouter::ServiceList service_list;
   if (!event_router->GetServices(params->device_address, &service_list)) {
-    SetError(kErrorNotFound);
-    SendResponse(false);
-    return false;
+    Respond(Error(kErrorNotFound));
+    return;
   }
 
-  results_ = apibtle::GetServices::Results::Create(service_list);
-  SendResponse(true);
-
-  return true;
+  Respond(ArgumentList(apibtle::GetServices::Results::Create(service_list)));
 }
 
-bool BluetoothLowEnergyGetCharacteristicFunction::DoWork() {
+void BluetoothLowEnergyGetCharacteristicFunction::DoWork() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BluetoothLowEnergyEventRouter* event_router =
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
-    SetError(kErrorAdapterNotInitialized);
-    SendResponse(false);
-    return false;
+    Respond(Error(kErrorAdapterNotInitialized));
+    return;
   }
 
   std::unique_ptr<apibtle::GetCharacteristic::Params> params(
       apibtle::GetCharacteristic::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   apibtle::Characteristic characteristic;
   BluetoothLowEnergyEventRouter::Status status =
       event_router->GetCharacteristic(extension(), params->characteristic_id,
                                       &characteristic);
   if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
-    SetError(StatusToString(status));
-    SendResponse(false);
-    return false;
+    Respond(Error(StatusToString(status)));
+    return;
   }
 
   // Manually construct the result instead of using
   // apibtle::GetCharacteristic::Result::Create as it doesn't convert lists of
   // enums correctly.
-  SetResult(apibtle::CharacteristicToValue(&characteristic));
-  SendResponse(true);
-
-  return true;
+  Respond(OneArgument(apibtle::CharacteristicToValue(&characteristic)));
 }
 
-bool BluetoothLowEnergyGetCharacteristicsFunction::DoWork() {
+void BluetoothLowEnergyGetCharacteristicsFunction::DoWork() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BluetoothLowEnergyEventRouter* event_router =
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
-    SetError(kErrorAdapterNotInitialized);
-    SendResponse(false);
-    return false;
+    Respond(Error(kErrorAdapterNotInitialized));
+    return;
   }
 
   std::unique_ptr<apibtle::GetCharacteristics::Params> params(
       apibtle::GetCharacteristics::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   BluetoothLowEnergyEventRouter::CharacteristicList characteristic_list;
   BluetoothLowEnergyEventRouter::Status status =
       event_router->GetCharacteristics(extension(), params->service_id,
                                        &characteristic_list);
   if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
-    SetError(StatusToString(status));
-    SendResponse(false);
-    return false;
+    Respond(Error(StatusToString(status)));
+    return;
   }
 
   // Manually construct the result instead of using
   // apibtle::GetCharacteristics::Result::Create as it doesn't convert lists of
   // enums correctly.
   std::unique_ptr<base::ListValue> result(new base::ListValue());
   for (apibtle::Characteristic& characteristic : characteristic_list)
     result->Append(apibtle::CharacteristicToValue(&characteristic));
 
-  SetResult(std::move(result));
-  SendResponse(true);
-
-  return true;
+  Respond(OneArgument(std::move(result)));
 }
 
-bool BluetoothLowEnergyGetIncludedServicesFunction::DoWork() {
+void BluetoothLowEnergyGetIncludedServicesFunction::DoWork() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BluetoothLowEnergyEventRouter* event_router =
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
-    SetError(kErrorAdapterNotInitialized);
-    SendResponse(false);
-    return false;
+    Respond(Error(kErrorAdapterNotInitialized));
+    return;
   }
 
   std::unique_ptr<apibtle::GetIncludedServices::Params> params(
       apibtle::GetIncludedServices::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   BluetoothLowEnergyEventRouter::ServiceList service_list;
   BluetoothLowEnergyEventRouter::Status status =
       event_router->GetIncludedServices(params->service_id, &service_list);
   if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
-    SetError(StatusToString(status));
-    SendResponse(false);
-    return false;
+    Respond(Error(StatusToString(status)));
+    return;
   }
 
-  results_ = apibtle::GetIncludedServices::Results::Create(service_list);
-  SendResponse(true);
-
-  return true;
+  Respond(ArgumentList(
+      apibtle::GetIncludedServices::Results::Create(service_list)));
 }
 
-bool BluetoothLowEnergyGetDescriptorFunction::DoWork() {
+void BluetoothLowEnergyGetDescriptorFunction::DoWork() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BluetoothLowEnergyEventRouter* event_router =
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
-    SetError(kErrorAdapterNotInitialized);
-    SendResponse(false);
-    return false;
+    Respond(Error(kErrorAdapterNotInitialized));
+    return;
   }
 
   std::unique_ptr<apibtle::GetDescriptor::Params> params(
       apibtle::GetDescriptor::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   apibtle::Descriptor descriptor;
   BluetoothLowEnergyEventRouter::Status status = event_router->GetDescriptor(
       extension(), params->descriptor_id, &descriptor);
   if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
-    SetError(StatusToString(status));
-    SendResponse(false);
-    return false;
+    Respond(Error(StatusToString(status)));
+    return;
   }
 
   // Manually construct the result instead of using
   // apibtle::GetDescriptor::Result::Create as it doesn't convert lists of enums
   // correctly.
-  SetResult(apibtle::DescriptorToValue(&descriptor));
-  SendResponse(true);
-
-  return true;
+  Respond(OneArgument(apibtle::DescriptorToValue(&descriptor)));
 }
 
-bool BluetoothLowEnergyGetDescriptorsFunction::DoWork() {
+void BluetoothLowEnergyGetDescriptorsFunction::DoWork() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BluetoothLowEnergyEventRouter* event_router =
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
-    SetError(kErrorAdapterNotInitialized);
-    SendResponse(false);
-    return false;
+    Respond(Error(kErrorAdapterNotInitialized));
+    return;
   }
 
   std::unique_ptr<apibtle::GetDescriptors::Params> params(
       apibtle::GetDescriptors::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   BluetoothLowEnergyEventRouter::DescriptorList descriptor_list;
   BluetoothLowEnergyEventRouter::Status status = event_router->GetDescriptors(
       extension(), params->characteristic_id, &descriptor_list);
   if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
-    SetError(StatusToString(status));
-    SendResponse(false);
-    return false;
+    Respond(Error(StatusToString(status)));
+    return;
   }
 
   // Manually construct the result instead of using
   // apibtle::GetDescriptors::Result::Create as it doesn't convert lists of
   // enums correctly.
   std::unique_ptr<base::ListValue> result(new base::ListValue());
   for (apibtle::Descriptor& descriptor : descriptor_list)
     result->Append(apibtle::DescriptorToValue(&descriptor));
 
-  SetResult(std::move(result));
-  SendResponse(true);
-
-  return true;
+  Respond(OneArgument(std::move(result)));
 }
 
-bool BluetoothLowEnergyReadCharacteristicValueFunction::DoWork() {
+void BluetoothLowEnergyReadCharacteristicValueFunction::DoWork() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BluetoothLowEnergyEventRouter* event_router =
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
-    SetError(kErrorAdapterNotInitialized);
-    SendResponse(false);
-    return false;
+    Respond(Error(kErrorAdapterNotInitialized));
+    return;
   }
 
   std::unique_ptr<apibtle::ReadCharacteristicValue::Params> params(
       apibtle::ReadCharacteristicValue::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   instance_id_ = params->characteristic_id;
   event_router->ReadCharacteristicValue(
       extension(), instance_id_,
       base::Bind(
           &BluetoothLowEnergyReadCharacteristicValueFunction::SuccessCallback,
           this),
       base::Bind(
           &BluetoothLowEnergyReadCharacteristicValueFunction::ErrorCallback,
           this));
-
-  return true;
 }
 
 void BluetoothLowEnergyReadCharacteristicValueFunction::SuccessCallback() {
   // Obtain info on the characteristic and see whether or not the characteristic
   // is still around.
   apibtle::Characteristic characteristic;
   BluetoothLowEnergyEventRouter::Status status =
       GetEventRouter(browser_context())
           ->GetCharacteristic(extension(), instance_id_, &characteristic);
   if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
-    SetError(StatusToString(status));
-    SendResponse(false);
+    Respond(Error(StatusToString(status)));
     return;
   }
 
   // Manually construct the result instead of using
   // apibtle::GetCharacteristic::Result::Create as it doesn't convert lists of
   // enums correctly.
-  SetResult(apibtle::CharacteristicToValue(&characteristic));
-  SendResponse(true);
+  Respond(OneArgument(apibtle::CharacteristicToValue(&characteristic)));
 }
 
 void BluetoothLowEnergyReadCharacteristicValueFunction::ErrorCallback(
     BluetoothLowEnergyEventRouter::Status status) {
-  SetError(StatusToString(status));
-  SendResponse(false);
+  Respond(Error(StatusToString(status)));
 }
 
-bool BluetoothLowEnergyWriteCharacteristicValueFunction::DoWork() {
+void BluetoothLowEnergyWriteCharacteristicValueFunction::DoWork() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BluetoothLowEnergyEventRouter* event_router =
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
-    SetError(kErrorAdapterNotInitialized);
-    SendResponse(false);
-    return false;
+    Respond(Error(kErrorAdapterNotInitialized));
+    return;
   }
 
   std::unique_ptr<apibtle::WriteCharacteristicValue::Params> params(
       apibtle::WriteCharacteristicValue::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   std::vector<uint8_t> value(params->value.begin(), params->value.end());
   event_router->WriteCharacteristicValue(
       extension(), params->characteristic_id, value,
       base::Bind(
           &BluetoothLowEnergyWriteCharacteristicValueFunction::SuccessCallback,
           this),
       base::Bind(
           &BluetoothLowEnergyWriteCharacteristicValueFunction::ErrorCallback,
           this));
-
-  return true;
 }
 
 void BluetoothLowEnergyWriteCharacteristicValueFunction::SuccessCallback() {
-  results_ = apibtle::WriteCharacteristicValue::Results::Create();
-  SendResponse(true);
+  Respond(ArgumentList(apibtle::WriteCharacteristicValue::Results::Create()));
 }
 
 void BluetoothLowEnergyWriteCharacteristicValueFunction::ErrorCallback(
     BluetoothLowEnergyEventRouter::Status status) {
-  SetError(StatusToString(status));
-  SendResponse(false);
+  Respond(Error(StatusToString(status)));
 }
 
-bool BluetoothLowEnergyStartCharacteristicNotificationsFunction::DoWork() {
+void BluetoothLowEnergyStartCharacteristicNotificationsFunction::DoWork() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BluetoothLowEnergyEventRouter* event_router =
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
-    SetError(kErrorAdapterNotInitialized);
-    SendResponse(false);
-    return false;
+    Respond(Error(kErrorAdapterNotInitialized));
+    return;
   }
 
   std::unique_ptr<apibtle::StartCharacteristicNotifications::Params> params(
       apibtle::StartCharacteristicNotifications::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   bool persistent = false;  // Not persistent by default.
   apibtle::NotificationProperties* properties = params->properties.get();
   if (properties)
     persistent = properties->persistent;
 
   event_router->StartCharacteristicNotifications(
       persistent, extension(), params->characteristic_id,
       base::Bind(&BluetoothLowEnergyStartCharacteristicNotificationsFunction::
                      SuccessCallback,
                  this),
       base::Bind(&BluetoothLowEnergyStartCharacteristicNotificationsFunction::
                      ErrorCallback,
                  this));
-
-  return true;
 }
 
 void BluetoothLowEnergyStartCharacteristicNotificationsFunction::
     SuccessCallback() {
-  SendResponse(true);
+  Respond(NoArguments());
 }
 
 void BluetoothLowEnergyStartCharacteristicNotificationsFunction::ErrorCallback(
     BluetoothLowEnergyEventRouter::Status status) {
-  SetError(StatusToString(status));
-  SendResponse(false);
+  Respond(Error(StatusToString(status)));
 }
 
-bool BluetoothLowEnergyStopCharacteristicNotificationsFunction::DoWork() {
+void BluetoothLowEnergyStopCharacteristicNotificationsFunction::DoWork() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BluetoothLowEnergyEventRouter* event_router =
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
-    SetError(kErrorAdapterNotInitialized);
-    SendResponse(false);
-    return false;
+    Respond(Error(kErrorAdapterNotInitialized));
+    return;
   }
 
   std::unique_ptr<apibtle::StopCharacteristicNotifications::Params> params(
       apibtle::StopCharacteristicNotifications::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   event_router->StopCharacteristicNotifications(
       extension(), params->characteristic_id,
       base::Bind(&BluetoothLowEnergyStopCharacteristicNotificationsFunction::
                      SuccessCallback,
                  this),
       base::Bind(&BluetoothLowEnergyStopCharacteristicNotificationsFunction::
                      ErrorCallback,
                  this));
-
-  return true;
 }
 
 void BluetoothLowEnergyStopCharacteristicNotificationsFunction::
     SuccessCallback() {
-  SendResponse(true);
+  Respond(NoArguments());
 }
 
 void BluetoothLowEnergyStopCharacteristicNotificationsFunction::ErrorCallback(
     BluetoothLowEnergyEventRouter::Status status) {
-  SetError(StatusToString(status));
-  SendResponse(false);
+  Respond(Error(StatusToString(status)));
 }
 
-bool BluetoothLowEnergyReadDescriptorValueFunction::DoWork() {
+void BluetoothLowEnergyReadDescriptorValueFunction::DoWork() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BluetoothLowEnergyEventRouter* event_router =
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
-    SetError(kErrorAdapterNotInitialized);
-    SendResponse(false);
-    return false;
+    Respond(Error(kErrorAdapterNotInitialized));
+    return;
   }
 
   std::unique_ptr<apibtle::ReadDescriptorValue::Params> params(
       apibtle::ReadDescriptorValue::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   instance_id_ = params->descriptor_id;
   event_router->ReadDescriptorValue(
       extension(), instance_id_,
       base::Bind(
           &BluetoothLowEnergyReadDescriptorValueFunction::SuccessCallback,
           this),
       base::Bind(&BluetoothLowEnergyReadDescriptorValueFunction::ErrorCallback,
                  this));
-
-  return true;
 }
 
 void BluetoothLowEnergyReadDescriptorValueFunction::SuccessCallback() {
   // Obtain info on the descriptor and see whether or not the descriptor is
   // still around.
   apibtle::Descriptor descriptor;
   BluetoothLowEnergyEventRouter::Status status =
       GetEventRouter(browser_context())
           ->GetDescriptor(extension(), instance_id_, &descriptor);
   if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
-    SetError(StatusToString(status));
-    SendResponse(false);
+    Respond(Error(StatusToString(status)));
     return;
   }
 
   // Manually construct the result instead of using
   // apibtle::GetDescriptor::Results::Create as it doesn't convert lists of
   // enums correctly.
-  SetResult(apibtle::DescriptorToValue(&descriptor));
-  SendResponse(true);
+  Respond(OneArgument(apibtle::DescriptorToValue(&descriptor)));
 }
 
 void BluetoothLowEnergyReadDescriptorValueFunction::ErrorCallback(
     BluetoothLowEnergyEventRouter::Status status) {
-  SetError(StatusToString(status));
-  SendResponse(false);
+  Respond(Error(StatusToString(status)));
 }
 
-bool BluetoothLowEnergyWriteDescriptorValueFunction::DoWork() {
+void BluetoothLowEnergyWriteDescriptorValueFunction::DoWork() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BluetoothLowEnergyEventRouter* event_router =
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
-    SetError(kErrorAdapterNotInitialized);
-    SendResponse(false);
-    return false;
+    Respond(Error(kErrorAdapterNotInitialized));
+    return;
   }
 
   std::unique_ptr<apibtle::WriteDescriptorValue::Params> params(
       apibtle::WriteDescriptorValue::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   std::vector<uint8_t> value(params->value.begin(), params->value.end());
   event_router->WriteDescriptorValue(
       extension(), params->descriptor_id, value,
       base::Bind(
           &BluetoothLowEnergyWriteDescriptorValueFunction::SuccessCallback,
           this),
       base::Bind(&BluetoothLowEnergyWriteDescriptorValueFunction::ErrorCallback,
                  this));
-
-  return true;
 }
 
 void BluetoothLowEnergyWriteDescriptorValueFunction::SuccessCallback() {
-  results_ = apibtle::WriteDescriptorValue::Results::Create();
-  SendResponse(true);
+  Respond(ArgumentList(apibtle::WriteDescriptorValue::Results::Create()));
 }
 
 void BluetoothLowEnergyWriteDescriptorValueFunction::ErrorCallback(
     BluetoothLowEnergyEventRouter::Status status) {
-  SetError(StatusToString(status));
-  SendResponse(false);
+  Respond(Error(StatusToString(status)));
 }
 
 BluetoothLowEnergyAdvertisementFunction::
     BluetoothLowEnergyAdvertisementFunction()
     : advertisements_manager_(nullptr) {}
 
 BluetoothLowEnergyAdvertisementFunction::
     ~BluetoothLowEnergyAdvertisementFunction() {}
 
 int BluetoothLowEnergyAdvertisementFunction::AddAdvertisement(
@@ skipping 13 matching lines @@
     int advertisement_id) {
   DCHECK(advertisements_manager_);
   advertisements_manager_->Remove(extension_id(), advertisement_id);
 }
 
 const base::hash_set<int>*
 BluetoothLowEnergyAdvertisementFunction::GetAdvertisementIds() {
   return advertisements_manager_->GetResourceIds(extension_id());
 }
 
-bool BluetoothLowEnergyAdvertisementFunction::RunAsync() {
+ExtensionFunction::ResponseAction
+BluetoothLowEnergyAdvertisementFunction::Run() {
   Initialize();
 
   // Check permission in the manifest.
   if (!BluetoothManifestData::CheckPeripheralPermitted(extension())) {
-    SetError(kErrorPermissionDenied);
-    return false;
+    return RespondNow(Error(kErrorPermissionDenied));
   }
 
   // For advertisement API to be available the app has to be either auto
   // launched in Kiosk Mode or the enable-ble-advertisement-in-apps
   // should be set.
   if (!(IsAutoLaunchedKioskApp(extension()->id()) ||
         IsPeripheralFlagEnabled())) {
-    SetError(kErrorPermissionDenied);
-    return false;
+    return RespondNow(Error(kErrorPermissionDenied));
   }
 
-  return BluetoothLowEnergyExtensionFunctionDeprecated::RunAsync();
+  return BluetoothLowEnergyExtensionFunction::Run();
 }
 
 void BluetoothLowEnergyAdvertisementFunction::Initialize() {
   advertisements_manager_ =
       ApiResourceManager<BluetoothApiAdvertisement>::Get(browser_context());
 }
 
 // RegisterAdvertisement:
 
-bool BluetoothLowEnergyRegisterAdvertisementFunction::DoWork() {
+void BluetoothLowEnergyRegisterAdvertisementFunction::DoWork() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BluetoothLowEnergyEventRouter* event_router =
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
-    SetError(kErrorAdapterNotInitialized);
-    SendResponse(false);
-    return false;
+    Respond(Error(kErrorAdapterNotInitialized));
+    return;
   }
 
   std::unique_ptr<apibtle::RegisterAdvertisement::Params> params(
       apibtle::RegisterAdvertisement::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   std::unique_ptr<device::BluetoothAdvertisement::Data> advertisement_data(
       new device::BluetoothAdvertisement::Data(
           params->advertisement.type ==
                   apibtle::AdvertisementType::ADVERTISEMENT_TYPE_BROADCAST
@@ skipping 16 matching lines @@
   }
 
   event_router->adapter()->RegisterAdvertisement(
       std::move(advertisement_data),
       base::Bind(
           &BluetoothLowEnergyRegisterAdvertisementFunction::SuccessCallback,
           this),
       base::Bind(
           &BluetoothLowEnergyRegisterAdvertisementFunction::ErrorCallback,
           this));
-
-  return true;
 }
 
 void BluetoothLowEnergyRegisterAdvertisementFunction::SuccessCallback(
     scoped_refptr<device::BluetoothAdvertisement> advertisement) {
-  results_ = apibtle::RegisterAdvertisement::Results::Create(AddAdvertisement(
-      new BluetoothApiAdvertisement(extension_id(), advertisement)));
-  SendResponse(true);
+  Respond(ArgumentList(
+      apibtle::RegisterAdvertisement::Results::Create(AddAdvertisement(
+          new BluetoothApiAdvertisement(extension_id(), advertisement)))));
 }
 
 void BluetoothLowEnergyRegisterAdvertisementFunction::ErrorCallback(
     device::BluetoothAdvertisement::ErrorCode status) {
   switch (status) {
     case device::BluetoothAdvertisement::ErrorCode::
         ERROR_ADVERTISEMENT_ALREADY_EXISTS:
-      SetError(kStatusAdvertisementAlreadyExists);
+      Respond(Error(kStatusAdvertisementAlreadyExists));
       break;
     case device::BluetoothAdvertisement::ErrorCode::
         ERROR_ADVERTISEMENT_INVALID_LENGTH:
-      SetError(kErrorInvalidAdvertisementLength);
+      Respond(Error(kErrorInvalidAdvertisementLength));
       break;
     default:
-      SetError(kErrorOperationFailed);
+      Respond(Error(kErrorOperationFailed));
   }
-  SendResponse(false);
 }
 
 // UnregisterAdvertisement:
 
-bool BluetoothLowEnergyUnregisterAdvertisementFunction::DoWork() {
+void BluetoothLowEnergyUnregisterAdvertisementFunction::DoWork() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BluetoothLowEnergyEventRouter* event_router =
       GetEventRouter(browser_context());
 
   // If we don't have an initialized adapter, unregistering is a no-op.
   if (!event_router->HasAdapter())
-    return true;
+    return;
 
   std::unique_ptr<apibtle::UnregisterAdvertisement::Params> params(
       apibtle::UnregisterAdvertisement::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   BluetoothApiAdvertisement* advertisement =
       GetAdvertisement(params->advertisement_id);
   if (!advertisement) {
-    error_ = kStatusAdvertisementDoesNotExist;
-    SendResponse(false);
-    return false;
+    Respond(Error(kStatusAdvertisementDoesNotExist));
+    return;
   }
 
   advertisement->advertisement()->Unregister(
       base::Bind(
           &BluetoothLowEnergyUnregisterAdvertisementFunction::SuccessCallback,
           this, params->advertisement_id),
       base::Bind(
           &BluetoothLowEnergyUnregisterAdvertisementFunction::ErrorCallback,
           this, params->advertisement_id));
-
-  return true;
 }
 
 void BluetoothLowEnergyUnregisterAdvertisementFunction::SuccessCallback(
     int advertisement_id) {
   RemoveAdvertisement(advertisement_id);
-  SendResponse(true);
+  Respond(NoArguments());
 }
 
 void BluetoothLowEnergyUnregisterAdvertisementFunction::ErrorCallback(
     int advertisement_id,
     device::BluetoothAdvertisement::ErrorCode status) {
   RemoveAdvertisement(advertisement_id);
   switch (status) {
     case device::BluetoothAdvertisement::ErrorCode::
         ERROR_ADVERTISEMENT_DOES_NOT_EXIST:
-      SetError(kStatusAdvertisementDoesNotExist);
+      Respond(Error(kStatusAdvertisementDoesNotExist));
       break;
     default:
-      SetError(kErrorOperationFailed);
+      Respond(Error(kErrorOperationFailed));
   }
-  SendResponse(false);
 }
 
 // ResetAdvertising:
 
-bool BluetoothLowEnergyResetAdvertisingFunction::DoWork() {
+void BluetoothLowEnergyResetAdvertisingFunction::DoWork() {
 #if defined(OS_CHROMEOS) || defined(OS_LINUX)
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BluetoothLowEnergyEventRouter* event_router =
       GetEventRouter(browser_context());
 
   // If the adapter is not initialized, there is nothing to reset.
   if (!event_router->HasAdapter()) {
-    SendResponse(true);
-    return true;
+    Respond(NoArguments());
+    return;
   }
 
   const base::hash_set<int>* advertisement_ids = GetAdvertisementIds();
   if (!advertisement_ids || advertisement_ids->empty()) {
-    SendResponse(true);
-    return true;
+    Respond(NoArguments());
+    return;
   }
 
   // Copy the hash set, as RemoveAdvertisement can change advertisement_ids
   // while we are iterating over it.
   base::hash_set<int> advertisement_ids_tmp = *advertisement_ids;
   for (int advertisement_id : advertisement_ids_tmp) {
     RemoveAdvertisement(advertisement_id);
   }
 
   event_router->adapter()->ResetAdvertising(
       base::Bind(&BluetoothLowEnergyResetAdvertisingFunction::SuccessCallback,
                  this),
       base::Bind(&BluetoothLowEnergyResetAdvertisingFunction::ErrorCallback,
                  this));
 #endif
-
-  return true;
 }
 
 void BluetoothLowEnergyResetAdvertisingFunction::SuccessCallback() {
-  SendResponse(true);
+  Respond(NoArguments());
 }
 
 void BluetoothLowEnergyResetAdvertisingFunction::ErrorCallback(
     device::BluetoothAdvertisement::ErrorCode status) {
-  error_ = kErrorOperationFailed;
-  SendResponse(false);
+  Respond(Error(kErrorOperationFailed));
 }
 
 // SetAdvertisingInterval:
 
 template class BLEPeripheralExtensionFunction<
     apibtle::SetAdvertisingInterval::Params>;
 
 void BluetoothLowEnergySetAdvertisingIntervalFunction::DoWork() {
 #if defined(OS_CHROMEOS) || defined(OS_LINUX)
   BluetoothLowEnergyEventRouter* event_router =
@@ skipping 218 matching lines @@
                         params_->response.value->end());
   }
   event_router_->HandleRequestResponse(
       extension(), params_->response.request_id, params_->response.is_error,
       uint8_vector);
   Respond(NoArguments());
 }
 
 }  // namespace api
 }  // namespace extensions