[Extensions] Remove AsyncExtensionFunction usage from bluetooth and related APIs

AsyncExtensionFunction is deprecated and soon will be removed.

This CL does not produce any behavior changes.

Bug: 829174
Change-Id: Ic686837c11c4f8a4047a7748f133798e24d9203a
Reviewed-on: https://chromium-review.googlesource.com/997098Reviewed-by: Devlin <rdevlin.cronin@chromium.org>
Commit-Queue: Istiaque Ahmed <lazyboy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#549562}

chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_api.cc

@@ -324,7 +324,8 @@ EasyUnlockPrivatePerformECDHKeyAgreementFunction() {}
 EasyUnlockPrivatePerformECDHKeyAgreementFunction::
 ~EasyUnlockPrivatePerformECDHKeyAgreementFunction() {}
 
-bool EasyUnlockPrivatePerformECDHKeyAgreementFunction::RunAsync() {
+ExtensionFunction::ResponseAction
+EasyUnlockPrivatePerformECDHKeyAgreementFunction::Run() {
   std::unique_ptr<easy_unlock_private::PerformECDHKeyAgreement::Params> params =
       easy_unlock_private::PerformECDHKeyAgreement::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
@@ -333,17 +334,21 @@ bool EasyUnlockPrivatePerformECDHKeyAgreementFunction::RunAsync() {
       *params,
       base::Bind(&EasyUnlockPrivatePerformECDHKeyAgreementFunction::OnData,
                  this));
-  return true;
+  // TODO(https://crbug.com/829182): Resolve this.
+  return did_respond() ? AlreadyResponded() : RespondLater();
 }
 
 void EasyUnlockPrivatePerformECDHKeyAgreementFunction::OnData(
     const std::string& secret_key) {
   // TODO(tbarzic): Improve error handling.
   if (!secret_key.empty()) {
-    results_ = easy_unlock_private::PerformECDHKeyAgreement::Results::Create(
-        std::vector<char>(secret_key.begin(), secret_key.end()));
+    Respond(ArgumentList(
+        easy_unlock_private::PerformECDHKeyAgreement::Results::Create(
+            std::vector<char>(secret_key.begin(), secret_key.end()))));
+    return;
   }
-  SendResponse(true);
+
+  Respond(NoArguments());
 }
 
 EasyUnlockPrivateGenerateEcP256KeyPairFunction::
@@ -352,11 +357,13 @@ EasyUnlockPrivateGenerateEcP256KeyPairFunction() {}
 EasyUnlockPrivateGenerateEcP256KeyPairFunction::
 ~EasyUnlockPrivateGenerateEcP256KeyPairFunction() {}
 
-bool EasyUnlockPrivateGenerateEcP256KeyPairFunction::RunAsync() {
+ExtensionFunction::ResponseAction
+EasyUnlockPrivateGenerateEcP256KeyPairFunction::Run() {
   GetCryptoDelegate(browser_context())->GenerateEcP256KeyPair(
       base::Bind(&EasyUnlockPrivateGenerateEcP256KeyPairFunction::OnData,
                  this));
-  return true;
+  // TODO(https://crbug.com/829182): Resolve this.
+  return did_respond() ? AlreadyResponded() : RespondLater();
 }
 
 void EasyUnlockPrivateGenerateEcP256KeyPairFunction::OnData(
@@ -364,11 +371,14 @@ void EasyUnlockPrivateGenerateEcP256KeyPairFunction::OnData(
     const std::string& public_key) {
   // TODO(tbarzic): Improve error handling.
   if (!public_key.empty() && !private_key.empty()) {
-    results_ = easy_unlock_private::GenerateEcP256KeyPair::Results::Create(
-        std::vector<char>(public_key.begin(), public_key.end()),
-        std::vector<char>(private_key.begin(), private_key.end()));
+    Respond(ArgumentList(
+        easy_unlock_private::GenerateEcP256KeyPair::Results::Create(
+            std::vector<char>(public_key.begin(), public_key.end()),
+            std::vector<char>(private_key.begin(), private_key.end()))));
+    return;
   }
-  SendResponse(true);
+
+  Respond(NoArguments());
 }
 
 EasyUnlockPrivateCreateSecureMessageFunction::
@@ -377,7 +387,8 @@ EasyUnlockPrivateCreateSecureMessageFunction() {}
 EasyUnlockPrivateCreateSecureMessageFunction::
 ~EasyUnlockPrivateCreateSecureMessageFunction() {}
 
-bool EasyUnlockPrivateCreateSecureMessageFunction::RunAsync() {
+ExtensionFunction::ResponseAction
+EasyUnlockPrivateCreateSecureMessageFunction::Run() {
   std::unique_ptr<easy_unlock_private::CreateSecureMessage::Params> params =
       easy_unlock_private::CreateSecureMessage::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
@@ -386,17 +397,21 @@ bool EasyUnlockPrivateCreateSecureMessageFunction::RunAsync() {
       *params,
       base::Bind(&EasyUnlockPrivateCreateSecureMessageFunction::OnData,
                  this));
-  return true;
+  // TODO(https://crbug.com/829182): Resolve this.
+  return did_respond() ? AlreadyResponded() : RespondLater();
 }
 
 void EasyUnlockPrivateCreateSecureMessageFunction::OnData(
     const std::string& message) {
   // TODO(tbarzic): Improve error handling.
   if (!message.empty()) {
-    results_ = easy_unlock_private::CreateSecureMessage::Results::Create(
-        std::vector<char>(message.begin(), message.end()));
+    Respond(
+        ArgumentList(easy_unlock_private::CreateSecureMessage::Results::Create(
+            std::vector<char>(message.begin(), message.end()))));
+    return;
   }
-  SendResponse(true);
+
+  Respond(NoArguments());
 }
 
 EasyUnlockPrivateUnwrapSecureMessageFunction::
@@ -405,7 +420,8 @@ EasyUnlockPrivateUnwrapSecureMessageFunction() {}
 EasyUnlockPrivateUnwrapSecureMessageFunction::
 ~EasyUnlockPrivateUnwrapSecureMessageFunction() {}
 
-bool EasyUnlockPrivateUnwrapSecureMessageFunction::RunAsync() {
+ExtensionFunction::ResponseAction
+EasyUnlockPrivateUnwrapSecureMessageFunction::Run() {
   std::unique_ptr<easy_unlock_private::UnwrapSecureMessage::Params> params =
       easy_unlock_private::UnwrapSecureMessage::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
@@ -414,17 +430,21 @@ bool EasyUnlockPrivateUnwrapSecureMessageFunction::RunAsync() {
       *params,
       base::Bind(&EasyUnlockPrivateUnwrapSecureMessageFunction::OnData,
                  this));
-  return true;
+  // TODO(https://crbug.com/829182): Resolve this.
+  return did_respond() ? AlreadyResponded() : RespondLater();
 }
 
 void EasyUnlockPrivateUnwrapSecureMessageFunction::OnData(
     const std::string& data) {
   // TODO(tbarzic): Improve error handling.
   if (!data.empty()) {
-    results_ = easy_unlock_private::UnwrapSecureMessage::Results::Create(
-        std::vector<char>(data.begin(), data.end()));
+    Respond(
+        ArgumentList(easy_unlock_private::UnwrapSecureMessage::Results::Create(
+            std::vector<char>(data.begin(), data.end()))));
+    return;
   }
-  SendResponse(true);
+
+  Respond(NoArguments());
 }
 
 EasyUnlockPrivateSetPermitAccessFunction::
@@ -551,16 +571,16 @@ EasyUnlockPrivateGetRemoteDevicesFunction::
     ~EasyUnlockPrivateGetRemoteDevicesFunction() {
 }
 
-bool EasyUnlockPrivateGetRemoteDevicesFunction::RunAsync() {
+ExtensionFunction::ResponseAction
+EasyUnlockPrivateGetRemoteDevicesFunction::Run() {
   // Check that we are inside a user profile.
   Profile* profile = Profile::FromBrowserContext(browser_context());
   chromeos::EasyUnlockService* easy_unlock_service =
       chromeos::EasyUnlockService::Get(profile);
   if (easy_unlock_service->GetType() !=
       chromeos::EasyUnlockService::TYPE_REGULAR) {
-    SetError("This function must be called inside a user session.");
-    SendResponse(true);
-    return true;
+    return RespondNow(
+        Error("This function must be called inside a user session."));
   }
 
   // Get the synced unlock key data.
@@ -574,20 +594,14 @@ bool EasyUnlockPrivateGetRemoteDevicesFunction::RunAsync() {
   expected_devices_count_ = unlock_keys.size();
 
   remote_devices_.reset(new base::ListValue());
-  if (expected_devices_count_ == 0) {
-    SetResult(std::move(remote_devices_));
-    SendResponse(true);
-    return true;
-  }
+  if (expected_devices_count_ == 0)
+    return RespondNow(OneArgument(std::move(remote_devices_)));
 
   // If there is a BLE unlock key, then don't return anything, so the app does
   // not try the classic Bluetooth protocol.
   for (const auto& unlock_key : unlock_keys) {
-    if (unlock_key.bluetooth_address().empty()) {
-      SetResult(std::move(remote_devices_));
-      SendResponse(true);
-      return true;
-    }
+    if (unlock_key.bluetooth_address().empty())
+      return RespondNow(OneArgument(std::move(remote_devices_)));
   }
 
   // Derive the PSKs for the user's unlock keys.
@@ -601,8 +615,7 @@ bool EasyUnlockPrivateGetRemoteDevicesFunction::RunAsync() {
             &EasyUnlockPrivateGetRemoteDevicesFunction::OnPSKDerivedForDevice,
             this, unlock_key));
   }
-
-  return true;
+  return did_respond() ? AlreadyResponded() : RespondLater();
 }
 
 std::string EasyUnlockPrivateGetRemoteDevicesFunction::GetUserPrivateKey() {
@@ -656,10 +669,8 @@ void EasyUnlockPrivateGetRemoteDevicesFunction::OnPSKDerivedForDevice(
   // If all PSKs are derived, then return from the API call.
   PA_LOG(INFO) << "Derived PSK for " << b64_public_key << ": "
                << remote_devices_->GetSize() << "/" << expected_devices_count_;
-  if (remote_devices_->GetSize() == expected_devices_count_) {
-    SetResult(std::move(remote_devices_));
-    SendResponse(true);
-  }
+  if (remote_devices_->GetSize() == expected_devices_count_)
+    Respond(OneArgument(std::move(remote_devices_)));
 }
 
 EasyUnlockPrivateGetUserInfoFunction::EasyUnlockPrivateGetUserInfoFunction() {
@@ -759,9 +770,8 @@ EasyUnlockPrivateFindSetupConnectionFunction::
 
 void EasyUnlockPrivateFindSetupConnectionFunction::
     OnConnectionFinderTimedOut() {
-  SetError("No connection found.");
   connection_finder_.reset();
-  SendResponse(false);
+  Respond(Error("No connection found."));
 }
 
 void EasyUnlockPrivateFindSetupConnectionFunction::OnConnectionFound(
@@ -772,12 +782,13 @@ void EasyUnlockPrivateFindSetupConnectionFunction::OnConnectionFound(
   int connection_id =
       GetConnectionManager(browser_context())
           ->AddConnection(extension(), std::move(connection), persistent);
-  results_ = easy_unlock_private::FindSetupConnection::Results::Create(
-      connection_id, device_address);
-  SendResponse(true);
+  Respond(
+      ArgumentList(easy_unlock_private::FindSetupConnection::Results::Create(
+          connection_id, device_address)));
 }
 
-bool EasyUnlockPrivateFindSetupConnectionFunction::RunAsync() {
+ExtensionFunction::ResponseAction
+EasyUnlockPrivateFindSetupConnectionFunction::Run() {
   std::unique_ptr<easy_unlock_private::FindSetupConnection::Params> params =
       easy_unlock_private::FindSetupConnection::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
@@ -797,7 +808,8 @@ bool EasyUnlockPrivateFindSetupConnectionFunction::RunAsync() {
                                OnConnectionFinderTimedOut,
                            this));
 
-  return true;
+  // TODO(https://crbug.com/829182): Resolve this.
+  return did_respond() ? AlreadyResponded() : RespondLater();
 }
 
 EasyUnlockPrivateSetupConnectionDisconnectFunction::

chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_api.h

@@ -12,8 +12,6 @@
 
 #include "base/macros.h"
 #include "device/bluetooth/bluetooth_device.h"
-#include "extensions/browser/api/bluetooth/bluetooth_extension_function.h"
-#include "extensions/browser/api/bluetooth_socket/bluetooth_socket_api.h"
 #include "extensions/browser/browser_context_keyed_api_factory.h"
 #include "extensions/browser/extension_function.h"
 
@@ -74,8 +72,6 @@ class EasyUnlockPrivateAPI : public BrowserContextKeyedAPI {
   DISALLOW_COPY_AND_ASSIGN(EasyUnlockPrivateAPI);
 };
 
-// TODO(tbarzic): Replace SyncExtensionFunction/AsyncExtensionFunction overrides
-// with UIThreadExtensionFunction throughout the file.
 class EasyUnlockPrivateGetStringsFunction : public UIThreadExtensionFunction {
  public:
   EasyUnlockPrivateGetStringsFunction();
@@ -94,14 +90,15 @@ class EasyUnlockPrivateGetStringsFunction : public UIThreadExtensionFunction {
 };
 
 class EasyUnlockPrivatePerformECDHKeyAgreementFunction
-    : public AsyncExtensionFunction {
+    : public UIThreadExtensionFunction {
  public:
   EasyUnlockPrivatePerformECDHKeyAgreementFunction();
 
  protected:
   ~EasyUnlockPrivatePerformECDHKeyAgreementFunction() override;
 
-  bool RunAsync() override;
+  // ExtensionFunction:
+  ResponseAction Run() override;
 
  private:
   void OnData(const std::string& secret_key);
@@ -113,14 +110,15 @@ class EasyUnlockPrivatePerformECDHKeyAgreementFunction
 };
 
 class EasyUnlockPrivateGenerateEcP256KeyPairFunction
-    : public AsyncExtensionFunction {
+    : public UIThreadExtensionFunction {
  public:
   EasyUnlockPrivateGenerateEcP256KeyPairFunction();
 
  protected:
   ~EasyUnlockPrivateGenerateEcP256KeyPairFunction() override;
 
-  bool RunAsync() override;
+  // ExtensionFunction:
+  ResponseAction Run() override;
 
  private:
   void OnData(const std::string& public_key,
@@ -133,14 +131,15 @@ class EasyUnlockPrivateGenerateEcP256KeyPairFunction
 };
 
 class EasyUnlockPrivateCreateSecureMessageFunction
-    : public AsyncExtensionFunction {
+    : public UIThreadExtensionFunction {
  public:
   EasyUnlockPrivateCreateSecureMessageFunction();
 
  protected:
   ~EasyUnlockPrivateCreateSecureMessageFunction() override;
 
-  bool RunAsync() override;
+  // ExtensionFunction:
+  ResponseAction Run() override;
 
  private:
   void OnData(const std::string& message);
@@ -152,14 +151,15 @@ class EasyUnlockPrivateCreateSecureMessageFunction
 };
 
 class EasyUnlockPrivateUnwrapSecureMessageFunction
-    : public AsyncExtensionFunction {
+    : public UIThreadExtensionFunction {
  public:
   EasyUnlockPrivateUnwrapSecureMessageFunction();
 
  protected:
   ~EasyUnlockPrivateUnwrapSecureMessageFunction() override;
 
-  bool RunAsync() override;
+  // ExtensionFunction:
+  ResponseAction Run() override;
 
  private:
   void OnData(const std::string& data);
@@ -241,7 +241,7 @@ class EasyUnlockPrivateSetRemoteDevicesFunction
 };
 
 class EasyUnlockPrivateGetRemoteDevicesFunction
-    : public AsyncExtensionFunction {
+    : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("easyUnlockPrivate.getRemoteDevices",
                              EASYUNLOCKPRIVATE_GETREMOTEDEVICES)
@@ -259,8 +259,8 @@ class EasyUnlockPrivateGetRemoteDevicesFunction
   virtual std::vector<cryptauth::ExternalDeviceInfo> GetUnlockKeys();
 
  private:
-  // AsyncExtensionFunction:
-  bool RunAsync() override;
+  // ExtensionFunction:
+  ResponseAction Run() override;
 
   // Callback when the PSK of a device is derived.
   void OnPSKDerivedForDevice(const cryptauth::ExternalDeviceInfo& device,
@@ -330,7 +330,7 @@ class EasyUnlockPrivateHideErrorBubbleFunction
 };
 
 class EasyUnlockPrivateFindSetupConnectionFunction
-    : public AsyncExtensionFunction {
+    : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("easyUnlockPrivate.findSetupConnection",
                              EASYUNLOCKPRIVATE_FINDSETUPCONNECTION)
@@ -339,8 +339,8 @@ class EasyUnlockPrivateFindSetupConnectionFunction
  private:
   ~EasyUnlockPrivateFindSetupConnectionFunction() override;
 
-  // AsyncExtensionFunction:
-  bool RunAsync() override;
+  // ExtensionFunction:
+  ResponseAction Run() override;
 
   // Called when the connection with the remote device advertising the setup
   // service was found.

extensions/browser/api/bluetooth/bluetooth_api.cc

@@ -107,20 +107,20 @@ void BluetoothAPI::OnListenerRemoved(const EventListenerInfo& details) {
 
 namespace api {
 
-BluetoothGetAdapterStateFunction::~BluetoothGetAdapterStateFunction() {}
+BluetoothGetAdapterStateFunction::~BluetoothGetAdapterStateFunction() = default;
 
-bool BluetoothGetAdapterStateFunction::DoWork(
+void BluetoothGetAdapterStateFunction::DoWork(
     scoped_refptr<BluetoothAdapter> adapter) {
   bluetooth::AdapterState state;
   PopulateAdapterState(*adapter, &state);
-  results_ = bluetooth::GetAdapterState::Results::Create(state);
-  SendResponse(true);
-  return true;
+  Respond(ArgumentList(bluetooth::GetAdapterState::Results::Create(state)));
 }
 
-BluetoothGetDevicesFunction::~BluetoothGetDevicesFunction() {}
+BluetoothGetDevicesFunction::BluetoothGetDevicesFunction() = default;
 
-bool BluetoothGetDevicesFunction::DoWork(
+BluetoothGetDevicesFunction::~BluetoothGetDevicesFunction() = default;
+
+void BluetoothGetDevicesFunction::DoWork(
     scoped_refptr<BluetoothAdapter> adapter) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
@@ -139,73 +139,64 @@ bool BluetoothGetDevicesFunction::DoWork(
     device_list->Append(extension_device.ToValue());
   }
 
-  SetResult(std::move(device_list));
-  SendResponse(true);
-
-  return true;
+  Respond(OneArgument(std::move(device_list)));
 }
 
-BluetoothGetDeviceFunction::~BluetoothGetDeviceFunction() {}
+BluetoothGetDeviceFunction::BluetoothGetDeviceFunction() = default;
+
+BluetoothGetDeviceFunction::~BluetoothGetDeviceFunction() = default;
+
+bool BluetoothGetDeviceFunction::CreateParams() {
+  params_ = GetDevice::Params::Create(*args_);
+  return params_ != nullptr;
+}
 
-bool BluetoothGetDeviceFunction::DoWork(
+void BluetoothGetDeviceFunction::DoWork(
     scoped_refptr<BluetoothAdapter> adapter) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  std::unique_ptr<GetDevice::Params> params(GetDevice::Params::Create(*args_));
-  EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
-
-  BluetoothDevice* device = adapter->GetDevice(params->device_address);
+  BluetoothDevice* device = adapter->GetDevice(params_->device_address);
   if (device) {
     bluetooth::Device extension_device;
     bluetooth::BluetoothDeviceToApiDevice(*device, &extension_device);
-    SetResult(extension_device.ToValue());
-    SendResponse(true);
+    Respond(OneArgument(extension_device.ToValue()));
   } else {
-    SetError(kInvalidDevice);
-    SendResponse(false);
+    Respond(Error(kInvalidDevice));
   }
-
-  return false;
 }
 
 void BluetoothStartDiscoveryFunction::OnSuccessCallback() {
-  SendResponse(true);
+  Respond(NoArguments());
 }
 
 void BluetoothStartDiscoveryFunction::OnErrorCallback() {
-  SetError(kStartDiscoveryFailed);
-  SendResponse(false);
+  Respond(Error(kStartDiscoveryFailed));
 }
 
-bool BluetoothStartDiscoveryFunction::DoWork(
+void BluetoothStartDiscoveryFunction::DoWork(
     scoped_refptr<BluetoothAdapter> adapter) {
   GetEventRouter(browser_context())
       ->StartDiscoverySession(
           adapter.get(), GetExtensionId(),
           base::Bind(&BluetoothStartDiscoveryFunction::OnSuccessCallback, this),
           base::Bind(&BluetoothStartDiscoveryFunction::OnErrorCallback, this));
-
-  return true;
 }
 
 void BluetoothStopDiscoveryFunction::OnSuccessCallback() {
-  SendResponse(true);
+  Respond(NoArguments());
 }
 
 void BluetoothStopDiscoveryFunction::OnErrorCallback() {
-  SetError(kStopDiscoveryFailed);
-  SendResponse(false);
+  Respond(Error(kStopDiscoveryFailed));
 }
 
-bool BluetoothStopDiscoveryFunction::DoWork(
+void BluetoothStopDiscoveryFunction::DoWork(
     scoped_refptr<BluetoothAdapter> adapter) {
   GetEventRouter(browser_context())
       ->StopDiscoverySession(
           adapter.get(), GetExtensionId(),
           base::Bind(&BluetoothStopDiscoveryFunction::OnSuccessCallback, this),
           base::Bind(&BluetoothStopDiscoveryFunction::OnErrorCallback, this));
-
-  return true;
 }
 
 }  // namespace api

extensions/browser/api/bluetooth/bluetooth_api.h

@@ -75,29 +75,42 @@ class BluetoothGetAdapterStateFunction : public BluetoothExtensionFunction {
   ~BluetoothGetAdapterStateFunction() override;
 
   // BluetoothExtensionFunction:
-  bool DoWork(scoped_refptr<device::BluetoothAdapter> adapter) override;
+  void DoWork(scoped_refptr<device::BluetoothAdapter> adapter) override;
 };
 
 class BluetoothGetDevicesFunction : public BluetoothExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("bluetooth.getDevices", BLUETOOTH_GETDEVICES)
 
+  BluetoothGetDevicesFunction();
+
  protected:
   ~BluetoothGetDevicesFunction() override;
 
   // BluetoothExtensionFunction:
-  bool DoWork(scoped_refptr<device::BluetoothAdapter> adapter) override;
+  void DoWork(scoped_refptr<device::BluetoothAdapter> adapter) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(BluetoothGetDevicesFunction);
 };
 
 class BluetoothGetDeviceFunction : public BluetoothExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("bluetooth.getDevice", BLUETOOTH_GETDEVICE)
 
+  BluetoothGetDeviceFunction();
+
   // BluetoothExtensionFunction:
-  bool DoWork(scoped_refptr<device::BluetoothAdapter> adapter) override;
+  bool CreateParams() override;
+  void DoWork(scoped_refptr<device::BluetoothAdapter> adapter) override;
 
  protected:
   ~BluetoothGetDeviceFunction() override;
+
+ private:
+  std::unique_ptr<extensions::api::bluetooth::GetDevice::Params> params_;
+
+  DISALLOW_COPY_AND_ASSIGN(BluetoothGetDeviceFunction);
 };
 
 class BluetoothStartDiscoveryFunction : public BluetoothExtensionFunction {
@@ -109,7 +122,7 @@ class BluetoothStartDiscoveryFunction : public BluetoothExtensionFunction {
   ~BluetoothStartDiscoveryFunction() override {}
 
   // BluetoothExtensionFunction:
-  bool DoWork(scoped_refptr<device::BluetoothAdapter> adapter) override;
+  void DoWork(scoped_refptr<device::BluetoothAdapter> adapter) override;
 
  private:
   void OnSuccessCallback();
@@ -124,7 +137,7 @@ class BluetoothStopDiscoveryFunction : public BluetoothExtensionFunction {
   ~BluetoothStopDiscoveryFunction() override {}
 
   // BluetoothExtensionFunction:
-  bool DoWork(scoped_refptr<device::BluetoothAdapter> adapter) override;
+  void DoWork(scoped_refptr<device::BluetoothAdapter> adapter) override;
 
  private:
   void OnSuccessCallback();

extensions/browser/api/bluetooth/bluetooth_extension_function.cc

@@ -49,16 +49,20 @@ BluetoothExtensionFunction::BluetoothExtensionFunction() {
 BluetoothExtensionFunction::~BluetoothExtensionFunction() {
 }
 
-bool BluetoothExtensionFunction::RunAsync() {
+ExtensionFunction::ResponseAction BluetoothExtensionFunction::Run() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  if (!IsBluetoothSupported(browser_context())) {
-    SetError(kPlatformNotSupported);
-    return false;
-  }
+  EXTENSION_FUNCTION_VALIDATE(CreateParams());
+
+  if (!IsBluetoothSupported(browser_context()))
+    return RespondNow(Error(kPlatformNotSupported));
+
   GetAdapter(base::Bind(&BluetoothExtensionFunction::RunOnAdapterReady, this),
              browser_context());
+  return did_respond() ? AlreadyResponded() : RespondLater();
+}
 
+bool BluetoothExtensionFunction::CreateParams() {
   return true;
 }
 

extensions/browser/api/bluetooth/bluetooth_extension_function.h

@@ -22,7 +22,7 @@ namespace api {
 // Base class for bluetooth extension functions. This class initializes
 // bluetooth adapter and calls (on the UI thread) DoWork() implemented by
 // individual bluetooth extension functions.
-class BluetoothExtensionFunction : public AsyncExtensionFunction {
+class BluetoothExtensionFunction : public UIThreadExtensionFunction {
  public:
   BluetoothExtensionFunction();
 
@@ -30,17 +30,19 @@ class BluetoothExtensionFunction : public AsyncExtensionFunction {
   ~BluetoothExtensionFunction() override;
 
   // ExtensionFunction:
-  bool RunAsync() override;
+  ResponseAction Run() override;
 
   // Use instead of extension_id() so that this can be run from WebUI.
   std::string GetExtensionId();
 
+  virtual bool CreateParams();
+
  private:
   void RunOnAdapterReady(scoped_refptr<device::BluetoothAdapter> adapter);
 
   // Implemented by individual bluetooth extension functions, called
   // automatically on the UI thread once |adapter| has been initialized.
-  virtual bool DoWork(scoped_refptr<device::BluetoothAdapter> adapter) = 0;
+  virtual void DoWork(scoped_refptr<device::BluetoothAdapter> adapter) = 0;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothExtensionFunction);
 };

extensions/browser/api/bluetooth/bluetooth_private_api.h

@@ -48,6 +48,30 @@ class BluetoothPrivateAPI : public BrowserContextKeyedAPI,
 
 namespace api {
 
+namespace bluetooth_private {
+namespace SetAdapterState {
+struct Params;
+}  // namespace SetAdapterState
+namespace SetPairingResponse {
+struct Params;
+}  // namespace SetPairingResponse
+namespace DisconnectAll {
+struct Params;
+}  // namespace DisconnectAll
+namespace ForgetDevice {
+struct Params;
+}  // namespace ForgetDevice
+namespace SetDiscoveryFilter {
+struct Params;
+}  // namespace SetDiscoveryFilter
+namespace Connect {
+struct Params;
+}  // namespace Connect
+namespace Pair {
+struct Params;
+}  // namespace Pair
+}  // namespace bluetooth_private
+
 class BluetoothPrivateSetAdapterStateFunction
     : public BluetoothExtensionFunction {
  public:
@@ -65,7 +89,8 @@ class BluetoothPrivateSetAdapterStateFunction
   void SendError();
 
   // BluetoothExtensionFunction overrides:
-  bool DoWork(scoped_refptr<device::BluetoothAdapter> adapter) override;
+  bool CreateParams() override;
+  void DoWork(scoped_refptr<device::BluetoothAdapter> adapter) override;
 
   // Set of expected adapter properties to be changed.
   std::set<std::string> pending_properties_;
@@ -77,6 +102,8 @@ class BluetoothPrivateSetAdapterStateFunction
   // up state requests.
   bool parsed_ = false;
 
+  std::unique_ptr<bluetooth_private::SetAdapterState::Params> params_;
+
   DISALLOW_COPY_AND_ASSIGN(BluetoothPrivateSetAdapterStateFunction);
 };
 
@@ -87,10 +114,14 @@ class BluetoothPrivateSetPairingResponseFunction
                              BLUETOOTHPRIVATE_SETPAIRINGRESPONSE)
   BluetoothPrivateSetPairingResponseFunction();
   // BluetoothExtensionFunction overrides:
-  bool DoWork(scoped_refptr<device::BluetoothAdapter> adapter) override;
+  bool CreateParams() override;
+  void DoWork(scoped_refptr<device::BluetoothAdapter> adapter) override;
 
  private:
   ~BluetoothPrivateSetPairingResponseFunction() override;
+
+  std::unique_ptr<bluetooth_private::SetPairingResponse::Params> params_;
+
   DISALLOW_COPY_AND_ASSIGN(BluetoothPrivateSetPairingResponseFunction);
 };
 
@@ -102,7 +133,8 @@ class BluetoothPrivateDisconnectAllFunction
   BluetoothPrivateDisconnectAllFunction();
 
   // BluetoothExtensionFunction overrides:
-  bool DoWork(scoped_refptr<device::BluetoothAdapter> adapter) override;
+  bool CreateParams() override;
+  void DoWork(scoped_refptr<device::BluetoothAdapter> adapter) override;
 
  private:
   ~BluetoothPrivateDisconnectAllFunction() override;
@@ -111,6 +143,8 @@ class BluetoothPrivateDisconnectAllFunction
   void OnErrorCallback(scoped_refptr<device::BluetoothAdapter> adapter,
                        const std::string& device_address);
 
+  std::unique_ptr<bluetooth_private::DisconnectAll::Params> params_;
+
   DISALLOW_COPY_AND_ASSIGN(BluetoothPrivateDisconnectAllFunction);
 };
 
@@ -121,7 +155,8 @@ class BluetoothPrivateForgetDeviceFunction : public BluetoothExtensionFunction {
   BluetoothPrivateForgetDeviceFunction();
 
   // BluetoothExtensionFunction overrides:
-  bool DoWork(scoped_refptr<device::BluetoothAdapter> adapter) override;
+  bool CreateParams() override;
+  void DoWork(scoped_refptr<device::BluetoothAdapter> adapter) override;
 
  private:
   ~BluetoothPrivateForgetDeviceFunction() override;
@@ -130,6 +165,8 @@ class BluetoothPrivateForgetDeviceFunction : public BluetoothExtensionFunction {
   void OnErrorCallback(scoped_refptr<device::BluetoothAdapter> adapter,
                        const std::string& device_address);
 
+  std::unique_ptr<bluetooth_private::ForgetDevice::Params> params_;
+
   DISALLOW_COPY_AND_ASSIGN(BluetoothPrivateForgetDeviceFunction);
 };
 
@@ -138,16 +175,22 @@ class BluetoothPrivateSetDiscoveryFilterFunction
  public:
   DECLARE_EXTENSION_FUNCTION("bluetoothPrivate.setDiscoveryFilter",
                              BLUETOOTHPRIVATE_SETDISCOVERYFILTER)
+  BluetoothPrivateSetDiscoveryFilterFunction();
 
  protected:
-  ~BluetoothPrivateSetDiscoveryFilterFunction() override {}
+  ~BluetoothPrivateSetDiscoveryFilterFunction() override;
 
   // BluetoothExtensionFunction:
-  bool DoWork(scoped_refptr<device::BluetoothAdapter> adapter) override;
+  bool CreateParams() override;
+  void DoWork(scoped_refptr<device::BluetoothAdapter> adapter) override;
 
  private:
   void OnSuccessCallback();
   void OnErrorCallback();
+
+  std::unique_ptr<bluetooth_private::SetDiscoveryFilter::Params> params_;
+
+  DISALLOW_COPY_AND_ASSIGN(BluetoothPrivateSetDiscoveryFilterFunction);
 };
 
 class BluetoothPrivateConnectFunction : public BluetoothExtensionFunction {
@@ -157,7 +200,8 @@ class BluetoothPrivateConnectFunction : public BluetoothExtensionFunction {
   BluetoothPrivateConnectFunction();
 
   // BluetoothExtensionFunction:
-  bool DoWork(scoped_refptr<device::BluetoothAdapter> adapter) override;
+  bool CreateParams() override;
+  void DoWork(scoped_refptr<device::BluetoothAdapter> adapter) override;
 
  private:
   ~BluetoothPrivateConnectFunction() override;
@@ -165,6 +209,8 @@ class BluetoothPrivateConnectFunction : public BluetoothExtensionFunction {
   void OnSuccessCallback();
   void OnErrorCallback(device::BluetoothDevice::ConnectErrorCode error);
 
+  std::unique_ptr<bluetooth_private::Connect::Params> params_;
+
   DISALLOW_COPY_AND_ASSIGN(BluetoothPrivateConnectFunction);
 };
 
@@ -174,7 +220,8 @@ class BluetoothPrivatePairFunction : public BluetoothExtensionFunction {
   BluetoothPrivatePairFunction();
 
   // BluetoothExtensionFunction:
-  bool DoWork(scoped_refptr<device::BluetoothAdapter> adapter) override;
+  bool CreateParams() override;
+  void DoWork(scoped_refptr<device::BluetoothAdapter> adapter) override;
 
  private:
   ~BluetoothPrivatePairFunction() override;
@@ -182,6 +229,8 @@ class BluetoothPrivatePairFunction : public BluetoothExtensionFunction {
   void OnSuccessCallback();
   void OnErrorCallback(device::BluetoothDevice::ConnectErrorCode error);
 
+  std::unique_ptr<bluetooth_private::Pair::Params> params_;
+
   DISALLOW_COPY_AND_ASSIGN(BluetoothPrivatePairFunction);
 };
 

extensions/browser/api/bluetooth_socket/bluetooth_socket_api.h

@@ -39,23 +39,15 @@ class BluetoothSocketEventDispatcher;
 // thread while providing methods to manage resources of that class. This
 // follows the pattern of AsyncApiFunction, but does not derive from it,
 // because BluetoothApiSocket methods must be called on the UI Thread.
-class BluetoothSocketAsyncApiFunction : public AsyncExtensionFunction {
+class BluetoothSocketAsyncApiFunction : public UIThreadExtensionFunction {
  public:
   BluetoothSocketAsyncApiFunction();
 
  protected:
   ~BluetoothSocketAsyncApiFunction() override;
 
-  // AsyncExtensionFunction:
-  bool RunAsync() override;
-
-  bool PrePrepare();
-  bool Respond();
-  void AsyncWorkCompleted();
-
-  virtual bool Prepare() = 0;
-  virtual void Work();
-  virtual void AsyncWorkStart();
+  // UIThreadExtensionFunction:
+  bool PreRunValidation(std::string* error) override;
 
   content::BrowserThread::ID work_thread_id() const;
 
@@ -77,9 +69,7 @@ class BluetoothSocketCreateFunction : public BluetoothSocketAsyncApiFunction {
  protected:
   ~BluetoothSocketCreateFunction() override;
 
-  // BluetoothSocketAsyncApiFunction:
-  bool Prepare() override;
-  void Work() override;
+  ResponseAction Run() override;
 
  private:
   std::unique_ptr<bluetooth_socket::Create::Params> params_;
@@ -94,9 +84,8 @@ class BluetoothSocketUpdateFunction : public BluetoothSocketAsyncApiFunction {
  protected:
   ~BluetoothSocketUpdateFunction() override;
 
-  // BluetoothSocketAsyncApiFunction:
-  bool Prepare() override;
-  void Work() override;
+  // UIThreadExtensionFunction:
+  ResponseAction Run() override;
 
  private:
   std::unique_ptr<bluetooth_socket::Update::Params> params_;
@@ -113,13 +102,11 @@ class BluetoothSocketSetPausedFunction
  protected:
   ~BluetoothSocketSetPausedFunction() override;
 
-  // BluetoothSocketAsyncApiFunction:
-  bool Prepare() override;
-  void Work() override;
+  // UIThreadExtensionFunction:
+  ResponseAction Run() override;
 
  private:
   std::unique_ptr<bluetooth_socket::SetPaused::Params> params_;
-  BluetoothSocketEventDispatcher* socket_event_dispatcher_;
 };
 
 class BluetoothSocketListenFunction : public BluetoothSocketAsyncApiFunction {
@@ -134,14 +121,14 @@ class BluetoothSocketListenFunction : public BluetoothSocketAsyncApiFunction {
       const device::BluetoothAdapter::CreateServiceCallback& callback,
       const device::BluetoothAdapter::CreateServiceErrorCallback&
           error_callback) = 0;
-  virtual void CreateResults() = 0;
+  virtual std::unique_ptr<base::ListValue> CreateResults() = 0;
 
   virtual int socket_id() const = 0;
   virtual const std::string& uuid() const = 0;
 
-  // BluetoothSocketAsyncApiFunction:
-  bool Prepare() override;
-  void AsyncWorkStart() override;
+  // UIThreadExtensionFunction:
+  ResponseAction Run() override;
+  bool PreRunValidation(std::string* error) override;
 
  protected:
   ~BluetoothSocketListenFunction() override;
@@ -150,7 +137,7 @@ class BluetoothSocketListenFunction : public BluetoothSocketAsyncApiFunction {
   virtual void OnCreateService(scoped_refptr<device::BluetoothSocket> socket);
   virtual void OnCreateServiceError(const std::string& message);
 
-  BluetoothSocketEventDispatcher* socket_event_dispatcher_;
+  BluetoothSocketEventDispatcher* socket_event_dispatcher_ = nullptr;
 };
 
 class BluetoothSocketListenUsingRfcommFunction
@@ -173,7 +160,7 @@ class BluetoothSocketListenUsingRfcommFunction
       const device::BluetoothAdapter::CreateServiceCallback& callback,
       const device::BluetoothAdapter::CreateServiceErrorCallback&
           error_callback) override;
-  void CreateResults() override;
+  std::unique_ptr<base::ListValue> CreateResults() override;
 
  protected:
   ~BluetoothSocketListenUsingRfcommFunction() override;
@@ -202,7 +189,7 @@ class BluetoothSocketListenUsingL2capFunction
       const device::BluetoothAdapter::CreateServiceCallback& callback,
       const device::BluetoothAdapter::CreateServiceErrorCallback&
           error_callback) override;
-  void CreateResults() override;
+  std::unique_ptr<base::ListValue> CreateResults() override;
 
  protected:
   ~BluetoothSocketListenUsingL2capFunction() override;
@@ -219,9 +206,9 @@ class BluetoothSocketAbstractConnectFunction :
  protected:
   ~BluetoothSocketAbstractConnectFunction() override;
 
-  // BluetoothSocketAsyncApiFunction:
-  bool Prepare() override;
-  void AsyncWorkStart() override;
+  // UIThreadExtensionFunction:
+  bool PreRunValidation(std::string* error) override;
+  ResponseAction Run() override;
 
   // Subclasses should implement this method to connect to the service
   // registered with |uuid| on the |device|.
@@ -235,7 +222,7 @@ class BluetoothSocketAbstractConnectFunction :
   virtual void OnGetAdapter(scoped_refptr<device::BluetoothAdapter> adapter);
 
   std::unique_ptr<bluetooth_socket::Connect::Params> params_;
-  BluetoothSocketEventDispatcher* socket_event_dispatcher_;
+  BluetoothSocketEventDispatcher* socket_event_dispatcher_ = nullptr;
 };
 
 class BluetoothSocketConnectFunction :
@@ -265,9 +252,8 @@ class BluetoothSocketDisconnectFunction
  protected:
   ~BluetoothSocketDisconnectFunction() override;
 
-  // BluetoothSocketAsyncApiFunction:
-  bool Prepare() override;
-  void AsyncWorkStart() override;
+  // UIThreadExtensionFunction:
+  ResponseAction Run() override;
 
  private:
   virtual void OnSuccess();
@@ -284,9 +270,8 @@ class BluetoothSocketCloseFunction : public BluetoothSocketAsyncApiFunction {
  protected:
   ~BluetoothSocketCloseFunction() override;
 
-  // BluetoothSocketAsyncApiFunction:
-  bool Prepare() override;
-  void Work() override;
+  // UIThreadExtensionFunction:
+  ResponseAction Run() override;
 
  private:
   std::unique_ptr<bluetooth_socket::Close::Params> params_;
@@ -301,9 +286,8 @@ class BluetoothSocketSendFunction : public BluetoothSocketAsyncApiFunction {
  protected:
   ~BluetoothSocketSendFunction() override;
 
-  // BluetoothSocketAsyncApiFunction:
-  bool Prepare() override;
-  void AsyncWorkStart() override;
+  // UIThreadExtensionFunction:
+  ResponseAction Run() override;
 
  private:
   void OnSuccess(int bytes_sent);
@@ -325,9 +309,8 @@ class BluetoothSocketGetInfoFunction : public BluetoothSocketAsyncApiFunction {
  protected:
   ~BluetoothSocketGetInfoFunction() override;
 
-  // BluetoothSocketAsyncApiFunction:
-  bool Prepare() override;
-  void Work() override;
+  // UIThreadExtensionFunction:
+  ResponseAction Run() override;
 
  private:
   std::unique_ptr<bluetooth_socket::GetInfo::Params> params_;
@@ -344,9 +327,8 @@ class BluetoothSocketGetSocketsFunction
  protected:
   ~BluetoothSocketGetSocketsFunction() override;
 
-  // BluetoothSocketAsyncApiFunction:
-  bool Prepare() override;
-  void Work() override;
+  // UIThreadExtensionFunction:
+  ResponseAction Run() override;
 };
 
 }  // namespace api