[Extensions] Convert some SyncExtensionFunctions

chrome/browser/extensions/api/easy_unlock_private/easy_unlock_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/easy_unlock_private/easy_unlock_private_api.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/base64url.h"
@@ skipping 119 matching lines @@
   if (!crypto_delegate_)
     crypto_delegate_ = EasyUnlockPrivateCryptoDelegate::Create();
   return crypto_delegate_.get();
 }
 
 EasyUnlockPrivateGetStringsFunction::EasyUnlockPrivateGetStringsFunction() {
 }
 EasyUnlockPrivateGetStringsFunction::~EasyUnlockPrivateGetStringsFunction() {
 }
 
-bool EasyUnlockPrivateGetStringsFunction::RunSync() {
+ExtensionFunction::ResponseAction EasyUnlockPrivateGetStringsFunction::Run() {
   std::unique_ptr<base::DictionaryValue> strings(new base::DictionaryValue);
 
 #if defined(OS_CHROMEOS)
   const base::string16 device_type = ash::GetChromeOSDeviceName();
 #else
   // TODO(isherman): Set an appropriate device name for non-ChromeOS devices.
   const base::string16 device_type = base::ASCIIToUTF16("Chromeschnozzle");
 #endif  // defined(OS_CHROMEOS)
 
 #if defined(OS_CHROMEOS)
@@ skipping 201 matching lines @@
   strings->SetString(
       "setupErrorFindingPhone",
       l10n_util::GetStringUTF16(IDS_EASY_UNLOCK_SETUP_ERROR_FINDING_PHONE));
   strings->SetString("setupErrorSyncPhoneState",
                      l10n_util::GetStringUTF16(
                          IDS_EASY_UNLOCK_SETUP_ERROR_SYNC_PHONE_STATE_FAILED));
   strings->SetString("setupErrorConnectingToPhone",
                      l10n_util::GetStringUTF16(
                          IDS_EASY_UNLOCK_SETUP_ERROR_CONNECTING_TO_PHONE));
 
-  SetResult(std::move(strings));
-  return true;
+  return RespondNow(OneArgument(std::move(strings)));
 }
 
 EasyUnlockPrivatePerformECDHKeyAgreementFunction::
 EasyUnlockPrivatePerformECDHKeyAgreementFunction() {}
 
 EasyUnlockPrivatePerformECDHKeyAgreementFunction::
 ~EasyUnlockPrivatePerformECDHKeyAgreementFunction() {}
 
 bool EasyUnlockPrivatePerformECDHKeyAgreementFunction::RunAsync() {
   std::unique_ptr<easy_unlock_private::PerformECDHKeyAgreement::Params> params =
@@ skipping 153 matching lines @@
                      OnConnectError,
                  this));
 }
 
 EasyUnlockPrivateUpdateScreenlockStateFunction::
     EasyUnlockPrivateUpdateScreenlockStateFunction() {}
 
 EasyUnlockPrivateUpdateScreenlockStateFunction::
     ~EasyUnlockPrivateUpdateScreenlockStateFunction() {}
 
-bool EasyUnlockPrivateUpdateScreenlockStateFunction::RunSync() {
+ExtensionFunction::ResponseAction
+EasyUnlockPrivateUpdateScreenlockStateFunction::Run() {
   std::unique_ptr<easy_unlock_private::UpdateScreenlockState::Params> params(
       easy_unlock_private::UpdateScreenlockState::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   Profile* profile = Profile::FromBrowserContext(browser_context());
   if (EasyUnlockService::Get(profile)->UpdateScreenlockState(
-          ToScreenlockState(params->state)))
-    return true;
-
-  SetError("Not allowed");
-  return false;
+          ToScreenlockState(params->state))) {
+    return RespondNow(NoArguments());
+  }
+  return RespondNow(Error("Not allowed"));
 }
 
 EasyUnlockPrivateSetPermitAccessFunction::
     EasyUnlockPrivateSetPermitAccessFunction() {
 }
 
 EasyUnlockPrivateSetPermitAccessFunction::
     ~EasyUnlockPrivateSetPermitAccessFunction() {
 }
 
-bool EasyUnlockPrivateSetPermitAccessFunction::RunSync() {
+ExtensionFunction::ResponseAction
+EasyUnlockPrivateSetPermitAccessFunction::Run() {
   std::unique_ptr<easy_unlock_private::SetPermitAccess::Params> params(
       easy_unlock_private::SetPermitAccess::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   Profile* profile = Profile::FromBrowserContext(browser_context());
   EasyUnlockService::Get(profile)
       ->SetPermitAccess(*params->permit_access.ToValue());
-
-  return true;
+  return RespondNow(NoArguments());
 }
 
 EasyUnlockPrivateGetPermitAccessFunction::
     EasyUnlockPrivateGetPermitAccessFunction() {
 }
 
 EasyUnlockPrivateGetPermitAccessFunction::
     ~EasyUnlockPrivateGetPermitAccessFunction() {
 }
 
-bool EasyUnlockPrivateGetPermitAccessFunction::RunSync() {
+ExtensionFunction::ResponseAction
+EasyUnlockPrivateGetPermitAccessFunction::Run() {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           proximity_auth::switches::kEnableBluetoothLowEnergyDiscovery)) {
-    ReturnPermitAccessForExperiment();
-    return true;
+    return GetPermitAccessForExperiment();
   }
 
   Profile* profile = Profile::FromBrowserContext(browser_context());
   const base::DictionaryValue* permit_value =
       EasyUnlockService::Get(profile)->GetPermitAccess();
+
   if (permit_value) {
     std::unique_ptr<easy_unlock_private::PermitRecord> permit =
         easy_unlock_private::PermitRecord::FromValue(*permit_value);
-    results_ = easy_unlock_private::GetPermitAccess::Results::Create(*permit);
+    return RespondNow(ArgumentList(
+        easy_unlock_private::GetPermitAccess::Results::Create(*permit)));
   }
 
-  return true;
+  return RespondNow(NoArguments());
 }
 
 void EasyUnlockPrivateGetPermitAccessFunction::GetKeyPairForExperiment(
     std::string* user_public_key,
     std::string* user_private_key) {
   Profile* profile = Profile::FromBrowserContext(browser_context());
   proximity_auth::CryptAuthEnrollmentManager* enrollment_manager =
       EasyUnlockService::Get(profile)
           ->proximity_auth_client()
           ->GetCryptAuthEnrollmentManager();
   base::Base64UrlEncode(enrollment_manager->GetUserPublicKey(),
                         base::Base64UrlEncodePolicy::INCLUDE_PADDING,
                         user_public_key);
   base::Base64UrlEncode(enrollment_manager->GetUserPrivateKey(),
                         base::Base64UrlEncodePolicy::INCLUDE_PADDING,
                         user_private_key);
 }
 
-void EasyUnlockPrivateGetPermitAccessFunction::
-    ReturnPermitAccessForExperiment() {
+ExtensionFunction::ResponseAction
+EasyUnlockPrivateGetPermitAccessFunction::GetPermitAccessForExperiment() {
   // Check that we are inside a user session.
   Profile* profile = Profile::FromBrowserContext(browser_context());
   EasyUnlockService* easy_unlock_service = EasyUnlockService::Get(profile);
   if (easy_unlock_service->GetType() != EasyUnlockService::TYPE_REGULAR) {
-    SetError("This function must be called inside a user session.");
-    SendResponse(true);
-    return;
+    return RespondNow(
+        Error("This function must be called inside a user session."));
   }
 
   std::string b64_public_key, b64_private_key;
   GetKeyPairForExperiment(&b64_public_key, &b64_private_key);
 
   // Fill in the permit access JSON dictionary.
   proximity_auth::ProximityAuthClient* client =
       easy_unlock_service->proximity_auth_client();
   std::unique_ptr<base::DictionaryValue> permit_access(
       new base::DictionaryValue());
   permit_access->SetString("permitId",
                            "permit://google.com/" + client->GetAccountId());
   permit_access->SetString("id", b64_public_key);
   permit_access->SetString("type", "access");
   permit_access->SetString("data", b64_private_key);
 
   PA_LOG(INFO) << "Returning permit access for "
                << "chrome.easyUnlockPrivate.getPermitAccess:\n"
                << "  id: " << b64_public_key;
 
-  std::unique_ptr<easy_unlock_private::PermitRecord> result =
-      easy_unlock_private::PermitRecord::FromValue(*permit_access);
-  results_ = easy_unlock_private::GetPermitAccess::Results::Create(*result);
+  return RespondNow(OneArgument(std::move(permit_access)));
 }
 
 EasyUnlockPrivateClearPermitAccessFunction::
     EasyUnlockPrivateClearPermitAccessFunction() {
 }
 
 EasyUnlockPrivateClearPermitAccessFunction::
     ~EasyUnlockPrivateClearPermitAccessFunction() {
 }
 
-bool EasyUnlockPrivateClearPermitAccessFunction::RunSync() {
+ExtensionFunction::ResponseAction
+EasyUnlockPrivateClearPermitAccessFunction::Run() {
   Profile* profile = Profile::FromBrowserContext(browser_context());
   EasyUnlockService::Get(profile)->ClearPermitAccess();
-  return true;
+  return RespondNow(NoArguments());
 }
 
 EasyUnlockPrivateSetRemoteDevicesFunction::
     EasyUnlockPrivateSetRemoteDevicesFunction() {
 }
 
 EasyUnlockPrivateSetRemoteDevicesFunction::
     ~EasyUnlockPrivateSetRemoteDevicesFunction() {
 }
 
-bool EasyUnlockPrivateSetRemoteDevicesFunction::RunSync() {
+ExtensionFunction::ResponseAction
+EasyUnlockPrivateSetRemoteDevicesFunction::Run() {
   std::unique_ptr<easy_unlock_private::SetRemoteDevices::Params> params(
       easy_unlock_private::SetRemoteDevices::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   Profile* profile = Profile::FromBrowserContext(browser_context());
   base::ListValue devices;
   for (const easy_unlock_private::Device& device : params->devices)
     devices.Append(device.ToValue());
 
   // Store the BLE device if we are trying out the BLE experiment.
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           proximity_auth::switches::kEnableBluetoothLowEnergyDiscovery)) {
     EasyUnlockService::Get(profile)->SetRemoteBleDevices(devices);
   } else {
     EasyUnlockService::Get(profile)->SetRemoteDevices(devices);
   }
 
-  return true;
+  return RespondNow(NoArguments());
 }
 
 EasyUnlockPrivateGetRemoteDevicesFunction::
     EasyUnlockPrivateGetRemoteDevicesFunction() {
 }
 
 EasyUnlockPrivateGetRemoteDevicesFunction::
     ~EasyUnlockPrivateGetRemoteDevicesFunction() {
 }
 
@@ skipping 170 matching lines @@
 }
 
 EasyUnlockPrivateTrySignInSecretFunction::
     EasyUnlockPrivateTrySignInSecretFunction() {
 }
 
 EasyUnlockPrivateTrySignInSecretFunction::
     ~EasyUnlockPrivateTrySignInSecretFunction() {
 }
 
-bool EasyUnlockPrivateTrySignInSecretFunction::RunSync() {
+ExtensionFunction::ResponseAction
+EasyUnlockPrivateTrySignInSecretFunction::Run() {
   std::unique_ptr<easy_unlock_private::TrySignInSecret::Params> params(
       easy_unlock_private::TrySignInSecret::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   Profile* profile = Profile::FromBrowserContext(browser_context());
   EasyUnlockService::Get(profile)->FinalizeSignin(std::string(
       params->sign_in_secret.begin(), params->sign_in_secret.end()));
-  return true;
+  return RespondNow(NoArguments());
 }
 
 EasyUnlockPrivateGetUserInfoFunction::EasyUnlockPrivateGetUserInfoFunction() {
 }
 
 EasyUnlockPrivateGetUserInfoFunction::~EasyUnlockPrivateGetUserInfoFunction() {
 }
 
-bool EasyUnlockPrivateGetUserInfoFunction::RunSync() {
+ExtensionFunction::ResponseAction EasyUnlockPrivateGetUserInfoFunction::Run() {
   EasyUnlockService* service =
       EasyUnlockService::Get(Profile::FromBrowserContext(browser_context()));
   std::vector<easy_unlock_private::UserInfo> users;
   const AccountId& account_id = service->GetAccountId();
   if (account_id.is_valid()) {
     easy_unlock_private::UserInfo user;
     user.user_id = account_id.GetUserEmail();
     user.logged_in = service->GetType() == EasyUnlockService::TYPE_REGULAR;
     user.data_ready = user.logged_in || service->GetRemoteDevices() != NULL;
 
     EasyUnlockService::UserSettings user_settings =
         EasyUnlockService::GetUserSettings(account_id);
     user.require_close_proximity = user_settings.require_close_proximity;
 
     user.device_user_id = proximity_auth::CalculateDeviceUserId(
         EasyUnlockService::GetDeviceId(), account_id.GetUserEmail());
 
     user.ble_discovery_enabled =
         base::CommandLine::ForCurrentProcess()->HasSwitch(
             proximity_auth::switches::kEnableBluetoothLowEnergyDiscovery);
     users.push_back(std::move(user));
   }
-  results_ = easy_unlock_private::GetUserInfo::Results::Create(users);
-  return true;
+  return RespondNow(
+      ArgumentList(easy_unlock_private::GetUserInfo::Results::Create(users)));
 }
 
 EasyUnlockPrivateGetConnectionInfoFunction::
     EasyUnlockPrivateGetConnectionInfoFunction() {
 }
 
 EasyUnlockPrivateGetConnectionInfoFunction::
     ~EasyUnlockPrivateGetConnectionInfoFunction() {
 }
 
@@ skipping 33 matching lines @@
 }
 
 EasyUnlockPrivateShowErrorBubbleFunction::
     EasyUnlockPrivateShowErrorBubbleFunction() {
 }
 
 EasyUnlockPrivateShowErrorBubbleFunction::
     ~EasyUnlockPrivateShowErrorBubbleFunction() {
 }
 
-bool EasyUnlockPrivateShowErrorBubbleFunction::RunSync() {
+ExtensionFunction::ResponseAction
+EasyUnlockPrivateShowErrorBubbleFunction::Run() {
   content::WebContents* web_contents = GetAssociatedWebContents();
-  if (!web_contents) {
-    SetError("A foreground app window is required.");
-    return true;
-  }
+  if (!web_contents)
+    return RespondNow(Error("A foreground app window is required."));
 
   std::unique_ptr<easy_unlock_private::ShowErrorBubble::Params> params(
       easy_unlock_private::ShowErrorBubble::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   if (params->link_range.start < 0 ||
       params->link_range.end < 0 ||
       base::saturated_cast<size_t>(params->link_range.end) >
           params->message.size()) {
-    SetError("Invalid link range.");
-    return true;
+    return RespondNow(Error("Invalid link range."));
   }
 
 #if defined(TOOLKIT_VIEWS)
   gfx::Rect anchor_rect(
       params->anchor_rect.left, params->anchor_rect.top,
       params->anchor_rect.width, params->anchor_rect.height);
   anchor_rect +=
       web_contents->GetContainerBounds().OffsetFromOrigin();
   ShowProximityAuthErrorBubble(
       base::UTF8ToUTF16(params->message),
       gfx::Range(params->link_range.start, params->link_range.end),
       GURL(params->link_target), anchor_rect, web_contents);
+  return RespondNow(NoArguments());
 #else
-  SetError("Not supported on non-Views platforms.");
+  return RespondNow(Error("Not supported on non-Views platforms."));
 #endif
-  return true;
 }
 
 EasyUnlockPrivateHideErrorBubbleFunction::
     EasyUnlockPrivateHideErrorBubbleFunction() {
 }
 
 EasyUnlockPrivateHideErrorBubbleFunction::
     ~EasyUnlockPrivateHideErrorBubbleFunction() {
 }
 
-bool EasyUnlockPrivateHideErrorBubbleFunction::RunSync() {
+ExtensionFunction::ResponseAction
+EasyUnlockPrivateHideErrorBubbleFunction::Run() {
 #if defined(TOOLKIT_VIEWS)
   HideProximityAuthErrorBubble();
+  return RespondNow(NoArguments());
 #else
-  SetError("Not supported on non-Views platforms.");
+  return RespondNow(Error("Not supported on non-Views platforms."));
 #endif
-  return true;
 }
 
 EasyUnlockPrivateSetAutoPairingResultFunction::
     EasyUnlockPrivateSetAutoPairingResultFunction() {
 }
 
 EasyUnlockPrivateSetAutoPairingResultFunction::
     ~EasyUnlockPrivateSetAutoPairingResultFunction() {
 }
 
-bool EasyUnlockPrivateSetAutoPairingResultFunction::RunSync() {
+ExtensionFunction::ResponseAction
+EasyUnlockPrivateSetAutoPairingResultFunction::Run() {
   std::unique_ptr<easy_unlock_private::SetAutoPairingResult::Params> params =
       easy_unlock_private::SetAutoPairingResult::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
   std::string error_message;
   if (params->result.error_message)
     error_message = *params->result.error_message;
 
   Profile* profile = Profile::FromBrowserContext(browser_context());
   EasyUnlockService::Get(profile)
       ->SetAutoPairingResult(params->result.success, error_message);
 
-  return true;
+  return RespondNow(NoArguments());
 }
 
 EasyUnlockPrivateFindSetupConnectionFunction::
     EasyUnlockPrivateFindSetupConnectionFunction()
     : bluetooth_throttler_(new proximity_auth::BluetoothThrottlerImpl(
           base::WrapUnique(new base::DefaultTickClock()))) {}
 
 EasyUnlockPrivateFindSetupConnectionFunction::
     ~EasyUnlockPrivateFindSetupConnectionFunction() {
   // |connection_finder_| has a raw pointer to |bluetooth_throttler_|, so it
@@ skipping 46 matching lines @@
 
   return true;
 }
 
 EasyUnlockPrivateSetupConnectionStatusFunction::
     EasyUnlockPrivateSetupConnectionStatusFunction() {}
 
 EasyUnlockPrivateSetupConnectionStatusFunction::
     ~EasyUnlockPrivateSetupConnectionStatusFunction() {}
 
-bool EasyUnlockPrivateSetupConnectionStatusFunction::RunSync() {
+ExtensionFunction::ResponseAction
+EasyUnlockPrivateSetupConnectionStatusFunction::Run() {
   std::unique_ptr<easy_unlock_private::SetupConnectionStatus::Params> params =
       easy_unlock_private::SetupConnectionStatus::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
   api::easy_unlock_private::ConnectionStatus status =
       GetConnectionManager(browser_context())
           ->ConnectionStatus(extension(), params->connection_id);
-  results_ =
-      easy_unlock_private::SetupConnectionStatus::Results::Create(status);
   if (status == api::easy_unlock_private::CONNECTION_STATUS_NONE)
-    SetError("Invalid connectionId");
-  return true;
+    return RespondNow(Error("Invalid connectionId"));
+  return RespondNow(ArgumentList(
+      easy_unlock_private::SetupConnectionStatus::Results::Create(status)));
 }
 
 EasyUnlockPrivateSetupConnectionDisconnectFunction::
     EasyUnlockPrivateSetupConnectionDisconnectFunction() {}
 
 EasyUnlockPrivateSetupConnectionDisconnectFunction::
     ~EasyUnlockPrivateSetupConnectionDisconnectFunction() {}
 
-bool EasyUnlockPrivateSetupConnectionDisconnectFunction::RunSync() {
+ExtensionFunction::ResponseAction
+EasyUnlockPrivateSetupConnectionDisconnectFunction::Run() {
   std::unique_ptr<easy_unlock_private::SetupConnectionDisconnect::Params>
       params = easy_unlock_private::SetupConnectionDisconnect::Params::Create(
           *args_);
   EXTENSION_FUNCTION_VALIDATE(params);
-  bool success = GetConnectionManager(browser_context())
-                     ->Disconnect(extension(), params->connection_id);
-  if (!success)
-    SetError("Invalid connectionId.");
-  return true;
+  if (!GetConnectionManager(browser_context())
+           ->Disconnect(extension(), params->connection_id)) {
+    return RespondNow(Error("Invalid connectionId."));
+  }
+  return RespondNow(NoArguments());
 }
 
 EasyUnlockPrivateSetupConnectionSendFunction::
     EasyUnlockPrivateSetupConnectionSendFunction() {}
 
 EasyUnlockPrivateSetupConnectionSendFunction::
     ~EasyUnlockPrivateSetupConnectionSendFunction() {}
 
-bool EasyUnlockPrivateSetupConnectionSendFunction::RunSync() {
+ExtensionFunction::ResponseAction
+EasyUnlockPrivateSetupConnectionSendFunction::Run() {
   std::unique_ptr<easy_unlock_private::SetupConnectionSend::Params> params =
       easy_unlock_private::SetupConnectionSend::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
   std::string payload(params->data.begin(), params->data.end());
-  bool success = GetConnectionManager(browser_context())
-                     ->SendMessage(extension(), params->connection_id, payload);
-  if (!success)
-    SetError("Invalid connectionId.");
-  return true;
+  if (!GetConnectionManager(browser_context())
+           ->SendMessage(extension(), params->connection_id, payload)) {
+    return RespondNow(Error("Invalid connectionId."));
+  }
+  return RespondNow(NoArguments());
 }
 
 EasyUnlockPrivateSetupConnectionGetDeviceAddressFunction::
     EasyUnlockPrivateSetupConnectionGetDeviceAddressFunction() {}
 
 EasyUnlockPrivateSetupConnectionGetDeviceAddressFunction::
     ~EasyUnlockPrivateSetupConnectionGetDeviceAddressFunction() {}
 
-bool EasyUnlockPrivateSetupConnectionGetDeviceAddressFunction::RunSync() {
+ExtensionFunction::ResponseAction
+EasyUnlockPrivateSetupConnectionGetDeviceAddressFunction::Run() {
   std::unique_ptr<easy_unlock_private::SetupConnectionGetDeviceAddress::Params>
       params =
           easy_unlock_private::SetupConnectionGetDeviceAddress::Params::Create(
               *args_);
   EXTENSION_FUNCTION_VALIDATE(params);
   std::string device_address =
       GetConnectionManager(browser_context())
           ->GetDeviceAddress(extension(), params->connection_id);
-  results_ =
+  if (device_address.empty())
+    return RespondNow(Error("Invalid connectionId."));
+  return RespondNow(ArgumentList(
       easy_unlock_private::SetupConnectionGetDeviceAddress::Results::Create(
-          device_address);
-  if (device_address.empty())
-    SetError("Invalid connectionId.");
-  return true;
+          device_address)));
 }
 
 }  // namespace extensions