[Extensions] Convert some SyncExtensionFunctions

SyncExtensionFunctions, AsyncExtensionFunctions,
ChromeSyncExtensionFunctions, and ChromeAsyncExtensionFunctions are
deprecated.

Remove SyncExtensionFunctions from:
- management
- metrics_private
- system_private
- networking_private
- power

BUG=634140

Review-Url: https://codereview.chromium.org/2261313002
Cr-Commit-Position: refs/heads/master@{#414284}

chrome/browser/extensions/api/management/chrome_management_api_delegate.cc

@@ -171,7 +171,7 @@ ChromeManagementAPIDelegate::ChromeManagementAPIDelegate() {
 ChromeManagementAPIDelegate::~ChromeManagementAPIDelegate() {
 }
 
-bool ChromeManagementAPIDelegate::LaunchAppFunctionDelegate(
+void ChromeManagementAPIDelegate::LaunchAppFunctionDelegate(
     const extensions::Extension* extension,
     content::BrowserContext* context) const {
   // Look at prefs to find the right launch container.
@@ -184,8 +184,6 @@ bool ChromeManagementAPIDelegate::LaunchAppFunctionDelegate(
       NEW_FOREGROUND_TAB, extensions::SOURCE_MANAGEMENT_API));
   extensions::RecordAppLaunchType(extension_misc::APP_LAUNCH_EXTENSION_API,
                                   extension->GetType());
-
-  return true;
 }
 
 GURL ChromeManagementAPIDelegate::GetFullLaunchURL(

chrome/browser/extensions/api/management/chrome_management_api_delegate.h

@@ -20,7 +20,7 @@ class ChromeManagementAPIDelegate : public extensions::ManagementAPIDelegate {
   ~ChromeManagementAPIDelegate() override;
 
   // ManagementAPIDelegate.
-  bool LaunchAppFunctionDelegate(
+  void LaunchAppFunctionDelegate(
       const extensions::Extension* extension,
       content::BrowserContext* context) const override;
   GURL GetFullLaunchURL(const extensions::Extension* extension) const override;

chrome/browser/extensions/api/metrics_private/metrics_private_api.cc

@@ -42,48 +42,51 @@ const size_t kMaxBuckets = 10000; // We don't ever want more than these many
                                   // and would cause crazy memory usage
 } // namespace
 
-bool MetricsPrivateGetIsCrashReportingEnabledFunction::RunSync() {
-  SetResult(base::MakeUnique<base::FundamentalValue>(
-      ChromeMetricsServiceAccessor::IsMetricsAndCrashReportingEnabled()));
-  return true;
+ExtensionFunction::ResponseAction
+MetricsPrivateGetIsCrashReportingEnabledFunction::Run() {
+  return RespondNow(OneArgument(base::MakeUnique<base::FundamentalValue>(
+      ChromeMetricsServiceAccessor::IsMetricsAndCrashReportingEnabled())));
 }
 
-bool MetricsPrivateGetFieldTrialFunction::RunSync() {
+ExtensionFunction::ResponseAction MetricsPrivateGetFieldTrialFunction::Run() {
   std::string name;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &name));
 
-  SetResult(base::MakeUnique<base::StringValue>(
-      base::FieldTrialList::FindFullName(name)));
-  return true;
+  return RespondNow(OneArgument(base::MakeUnique<base::StringValue>(
+      base::FieldTrialList::FindFullName(name))));
 }
 
-bool MetricsPrivateGetVariationParamsFunction::RunSync() {
+ExtensionFunction::ResponseAction
+MetricsPrivateGetVariationParamsFunction::Run() {
   std::unique_ptr<GetVariationParams::Params> params(
       GetVariationParams::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   GetVariationParams::Results::Params result;
+  std::unique_ptr<base::DictionaryValue> dict;
   if (variations::GetVariationParams(params->name,
                                      &result.additional_properties)) {
-    SetResult(result.ToValue());
+    dict = result.ToValue();
   }
-  return true;
+  return RespondNow(dict ? OneArgument(std::move(dict)) : NoArguments());
 }
 
-bool MetricsPrivateRecordUserActionFunction::RunSync() {
+ExtensionFunction::ResponseAction
+MetricsPrivateRecordUserActionFunction::Run() {
   std::unique_ptr<RecordUserAction::Params> params(
       RecordUserAction::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   content::RecordComputedAction(params->name);
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool MetricsHistogramHelperFunction::RecordValue(
-    const std::string& name,
-    base::HistogramType type,
-    int min, int max, size_t buckets,
-    int sample) {
+void MetricsHistogramHelperFunction::RecordValue(const std::string& name,
+                                                 base::HistogramType type,
+                                                 int min,
+                                                 int max,
+                                                 size_t buckets,
+                                                 int sample) {
   // Make sure toxic values don't get to internal code.
   // Fix for maximums
   min = std::min(min, INT_MAX - 3);
@@ -112,10 +115,9 @@ bool MetricsHistogramHelperFunction::RecordValue(
   // that data for this API.  An error message will be logged.
   if (counter)
     counter->Add(sample);
-  return true;
 }
 
-bool MetricsPrivateRecordValueFunction::RunSync() {
+ExtensionFunction::ResponseAction MetricsPrivateRecordValueFunction::Run() {
   std::unique_ptr<RecordValue::Params> params(
       RecordValue::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
@@ -125,78 +127,89 @@ bool MetricsPrivateRecordValueFunction::RunSync() {
 
   base::HistogramType histogram_type(type == "histogram-linear" ?
       base::LINEAR_HISTOGRAM : base::HISTOGRAM);
-  return RecordValue(params->metric.metric_name, histogram_type,
-                     params->metric.min, params->metric.max,
-                     params->metric.buckets, params->value);
+  RecordValue(params->metric.metric_name, histogram_type, params->metric.min,
+              params->metric.max, params->metric.buckets, params->value);
+  return RespondNow(NoArguments());
 }
 
-bool MetricsPrivateRecordSparseValueFunction::RunSync() {
+ExtensionFunction::ResponseAction
+MetricsPrivateRecordSparseValueFunction::Run() {
   std::unique_ptr<RecordSparseValue::Params> params(
       RecordSparseValue::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   // This particular UMA_HISTOGRAM_ macro is okay for
   // non-runtime-constant strings.
   UMA_HISTOGRAM_SPARSE_SLOWLY(params->metric_name, params->value);
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool MetricsPrivateRecordPercentageFunction::RunSync() {
+ExtensionFunction::ResponseAction
+MetricsPrivateRecordPercentageFunction::Run() {
   std::unique_ptr<RecordPercentage::Params> params(
       RecordPercentage::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
-  return RecordValue(params->metric_name, base::LINEAR_HISTOGRAM,
-                     1, 101, 102, params->value);
+  RecordValue(params->metric_name, base::LINEAR_HISTOGRAM, 1, 101, 102,
+              params->value);
+  return RespondNow(NoArguments());
 }
 
-bool MetricsPrivateRecordCountFunction::RunSync() {
+ExtensionFunction::ResponseAction MetricsPrivateRecordCountFunction::Run() {
   std::unique_ptr<RecordCount::Params> params(
       RecordCount::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
-  return RecordValue(params->metric_name, base::HISTOGRAM,
-                     1, 1000000, 50, params->value);
+  RecordValue(params->metric_name, base::HISTOGRAM, 1, 1000000, 50,
+              params->value);
+  return RespondNow(NoArguments());
 }
 
-bool MetricsPrivateRecordSmallCountFunction::RunSync() {
+ExtensionFunction::ResponseAction
+MetricsPrivateRecordSmallCountFunction::Run() {
   std::unique_ptr<RecordSmallCount::Params> params(
       RecordSmallCount::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
-  return RecordValue(params->metric_name, base::HISTOGRAM,
-                     1, 100, 50, params->value);
+  RecordValue(params->metric_name, base::HISTOGRAM, 1, 100, 50, params->value);
+  return RespondNow(NoArguments());
 }
 
-bool MetricsPrivateRecordMediumCountFunction::RunSync() {
+ExtensionFunction::ResponseAction
+MetricsPrivateRecordMediumCountFunction::Run() {
   std::unique_ptr<RecordMediumCount::Params> params(
       RecordMediumCount::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
-  return RecordValue(params->metric_name, base::HISTOGRAM,
-                     1, 10000, 50, params->value);
+  RecordValue(params->metric_name, base::HISTOGRAM, 1, 10000, 50,
+              params->value);
+  return RespondNow(NoArguments());
 }
 
-bool MetricsPrivateRecordTimeFunction::RunSync() {
+ExtensionFunction::ResponseAction MetricsPrivateRecordTimeFunction::Run() {
   std::unique_ptr<RecordTime::Params> params(
       RecordTime::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   static const int kTenSecMs = 10 * 1000;
-  return RecordValue(params->metric_name, base::HISTOGRAM,
-                     1, kTenSecMs, 50, params->value);
+  RecordValue(params->metric_name, base::HISTOGRAM, 1, kTenSecMs, 50,
+              params->value);
+  return RespondNow(NoArguments());
 }
 
-bool MetricsPrivateRecordMediumTimeFunction::RunSync() {
+ExtensionFunction::ResponseAction
+MetricsPrivateRecordMediumTimeFunction::Run() {
   std::unique_ptr<RecordMediumTime::Params> params(
       RecordMediumTime::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   static const int kThreeMinMs = 3 * 60 * 1000;
-  return RecordValue(params->metric_name, base::HISTOGRAM,
-                     1, kThreeMinMs, 50, params->value);
+  RecordValue(params->metric_name, base::HISTOGRAM, 1, kThreeMinMs, 50,
+              params->value);
+  return RespondNow(NoArguments());
 }
 
-bool MetricsPrivateRecordLongTimeFunction::RunSync() {
+ExtensionFunction::ResponseAction MetricsPrivateRecordLongTimeFunction::Run() {
   std::unique_ptr<RecordLongTime::Params> params(
       RecordLongTime::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   static const int kOneHourMs = 60 * 60 * 1000;
-  return RecordValue(params->metric_name, base::HISTOGRAM,
-                     1, kOneHourMs, 50, params->value);
+  RecordValue(params->metric_name, base::HISTOGRAM, 1, kOneHourMs, 50,
+              params->value);
+  return RespondNow(NoArguments());
 }
 
 } // namespace extensions

chrome/browser/extensions/api/metrics_private/metrics_private_api.h

@@ -15,7 +15,7 @@
 namespace extensions {
 
 class MetricsPrivateGetIsCrashReportingEnabledFunction
-    : public SyncExtensionFunction {
+    : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("metricsPrivate.getIsCrashReportingEnabled",
                              METRICSPRIVATE_GETISCRASHRECORDINGENABLED)
@@ -24,10 +24,10 @@ class MetricsPrivateGetIsCrashReportingEnabledFunction
   ~MetricsPrivateGetIsCrashReportingEnabledFunction() override {}
 
   // ExtensionFunction:
-  bool RunSync() override;
+  ResponseAction Run() override;
 };
 
-class MetricsPrivateGetFieldTrialFunction : public SyncExtensionFunction {
+class MetricsPrivateGetFieldTrialFunction : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("metricsPrivate.getFieldTrial",
                              METRICSPRIVATE_GETFIELDTRIAL)
@@ -36,10 +36,11 @@ class MetricsPrivateGetFieldTrialFunction : public SyncExtensionFunction {
   ~MetricsPrivateGetFieldTrialFunction() override {}
 
   // ExtensionFunction:
-  bool RunSync() override;
+  ResponseAction Run() override;
 };
 
-class MetricsPrivateGetVariationParamsFunction : public SyncExtensionFunction {
+class MetricsPrivateGetVariationParamsFunction
+    : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("metricsPrivate.getVariationParams",
                              METRICSPRIVATE_GETVARIATIONPARAMS)
@@ -48,10 +49,11 @@ class MetricsPrivateGetVariationParamsFunction : public SyncExtensionFunction {
   ~MetricsPrivateGetVariationParamsFunction() override {}
 
   // ExtensionFunction:
-  bool RunSync() override;
+  ResponseAction Run() override;
 };
 
-class MetricsPrivateRecordUserActionFunction : public SyncExtensionFunction {
+class MetricsPrivateRecordUserActionFunction
+    : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("metricsPrivate.recordUserAction",
                              METRICSPRIVATE_RECORDUSERACTION)
@@ -60,16 +62,18 @@ class MetricsPrivateRecordUserActionFunction : public SyncExtensionFunction {
   ~MetricsPrivateRecordUserActionFunction() override {}
 
   // ExtensionFunction:
-  bool RunSync() override;
+  ResponseAction Run() override;
 };
 
-class MetricsHistogramHelperFunction : public SyncExtensionFunction {
+class MetricsHistogramHelperFunction : public UIThreadExtensionFunction {
  protected:
   ~MetricsHistogramHelperFunction() override {}
-  virtual bool RecordValue(const std::string& name,
-                           base::HistogramType type,
-                           int min, int max, size_t buckets,
-                           int sample);
+  void RecordValue(const std::string& name,
+                   base::HistogramType type,
+                   int min,
+                   int max,
+                   size_t buckets,
+                   int sample);
 };
 
 class MetricsPrivateRecordValueFunction
@@ -82,7 +86,7 @@ class MetricsPrivateRecordValueFunction
   ~MetricsPrivateRecordValueFunction() override {}
 
   // ExtensionFunction:
-  bool RunSync() override;
+  ResponseAction Run() override;
 };
 
 class MetricsPrivateRecordSparseValueFunction
@@ -95,7 +99,7 @@ class MetricsPrivateRecordSparseValueFunction
   ~MetricsPrivateRecordSparseValueFunction() override {}
 
   // ExtensionFunction:
-  bool RunSync() override;
+  ResponseAction Run() override;
 };
 
 class MetricsPrivateRecordPercentageFunction
@@ -108,7 +112,7 @@ class MetricsPrivateRecordPercentageFunction
   ~MetricsPrivateRecordPercentageFunction() override {}
 
   // ExtensionFunction:
-  bool RunSync() override;
+  ResponseAction Run() override;
 };
 
 class MetricsPrivateRecordCountFunction
@@ -121,7 +125,7 @@ class MetricsPrivateRecordCountFunction
   ~MetricsPrivateRecordCountFunction() override {}
 
   // ExtensionFunction:
-  bool RunSync() override;
+  ResponseAction Run() override;
 };
 
 class MetricsPrivateRecordSmallCountFunction
@@ -134,7 +138,7 @@ class MetricsPrivateRecordSmallCountFunction
   ~MetricsPrivateRecordSmallCountFunction() override {}
 
   // ExtensionFunction:
-  bool RunSync() override;
+  ResponseAction Run() override;
 };
 
 class MetricsPrivateRecordMediumCountFunction
@@ -147,7 +151,7 @@ class MetricsPrivateRecordMediumCountFunction
   ~MetricsPrivateRecordMediumCountFunction() override {}
 
   // ExtensionFunction:
-  bool RunSync() override;
+  ResponseAction Run() override;
 };
 
 class MetricsPrivateRecordTimeFunction : public MetricsHistogramHelperFunction {
@@ -159,7 +163,7 @@ class MetricsPrivateRecordTimeFunction : public MetricsHistogramHelperFunction {
   ~MetricsPrivateRecordTimeFunction() override {}
 
   // ExtensionFunction:
-  bool RunSync() override;
+  ResponseAction Run() override;
 };
 
 class MetricsPrivateRecordMediumTimeFunction
@@ -172,7 +176,7 @@ class MetricsPrivateRecordMediumTimeFunction
   ~MetricsPrivateRecordMediumTimeFunction() override {}
 
   // ExtensionFunction:
-  bool RunSync() override;
+  ResponseAction Run() override;
 };
 
 class MetricsPrivateRecordLongTimeFunction
@@ -185,7 +189,7 @@ class MetricsPrivateRecordLongTimeFunction
   ~MetricsPrivateRecordLongTimeFunction() override {}
 
   // ExtensionFunction:
-  bool RunSync() override;
+  ResponseAction Run() override;
 };
 
 } // namespace extensions

chrome/browser/extensions/api/system_private/system_private_api.cc

@@ -70,18 +70,19 @@ namespace extensions {
 
 namespace system_private = api::system_private;
 
-bool SystemPrivateGetIncognitoModeAvailabilityFunction::RunSync() {
-  PrefService* prefs = GetProfile()->GetPrefs();
+ExtensionFunction::ResponseAction
+SystemPrivateGetIncognitoModeAvailabilityFunction::Run() {
+  PrefService* prefs =
+      Profile::FromBrowserContext(browser_context())->GetPrefs();
   int value = prefs->GetInteger(prefs::kIncognitoModeAvailability);
   EXTENSION_FUNCTION_VALIDATE(
       value >= 0 &&
       value < static_cast<int>(arraysize(kIncognitoModeAvailabilityStrings)));
-  SetResult(base::MakeUnique<base::StringValue>(
-      kIncognitoModeAvailabilityStrings[value]));
-  return true;
+  return RespondNow(OneArgument(base::MakeUnique<base::StringValue>(
+      kIncognitoModeAvailabilityStrings[value])));
 }
 
-bool SystemPrivateGetUpdateStatusFunction::RunSync() {
+ExtensionFunction::ResponseAction SystemPrivateGetUpdateStatusFunction::Run() {
   std::string state;
   double download_progress = 0;
 #if defined(OS_CHROMEOS)
@@ -135,17 +136,16 @@ bool SystemPrivateGetUpdateStatusFunction::RunSync() {
     state = kNotAvailableState;
   }
 #endif
+
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetString(kStateKey, state);
   dict->SetDouble(kDownloadProgressKey, download_progress);
-  SetResult(std::move(dict));
-
-  return true;
+  return RespondNow(OneArgument(std::move(dict)));
 }
 
-bool SystemPrivateGetApiKeyFunction::RunSync() {
-  SetResult(base::MakeUnique<base::StringValue>(google_apis::GetAPIKey()));
-  return true;
+ExtensionFunction::ResponseAction SystemPrivateGetApiKeyFunction::Run() {
+  return RespondNow(OneArgument(
+      base::MakeUnique<base::StringValue>(google_apis::GetAPIKey())));
 }
 
 void DispatchVolumeChangedEvent(double volume, bool is_volume_muted) {

chrome/browser/extensions/api/system_private/system_private_api.h

@@ -8,12 +8,12 @@
 #ifndef CHROME_BROWSER_EXTENSIONS_API_SYSTEM_PRIVATE_SYSTEM_PRIVATE_API_H_
 #define CHROME_BROWSER_EXTENSIONS_API_SYSTEM_PRIVATE_SYSTEM_PRIVATE_API_H_
 
-#include "chrome/browser/extensions/chrome_extension_function.h"
+#include "extensions/browser/extension_function.h"
 
 namespace extensions {
 
 class SystemPrivateGetIncognitoModeAvailabilityFunction
-    : public ChromeSyncExtensionFunction {
+    : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("systemPrivate.getIncognitoModeAvailability",
                              SYSTEMPRIVATE_GETINCOGNITOMODEAVAILABILITY)
@@ -22,12 +22,11 @@ class SystemPrivateGetIncognitoModeAvailabilityFunction
   ~SystemPrivateGetIncognitoModeAvailabilityFunction() override {}
 
   // ExtensionFunction:
-  bool RunSync() override;
+  ResponseAction Run() override;
 };
 
 // API function which returns the status of system update.
-class SystemPrivateGetUpdateStatusFunction
-    : public ChromeSyncExtensionFunction {
+class SystemPrivateGetUpdateStatusFunction : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("systemPrivate.getUpdateStatus",
                              SYSTEMPRIVATE_GETUPDATESTATUS)
@@ -36,11 +35,11 @@ class SystemPrivateGetUpdateStatusFunction
   ~SystemPrivateGetUpdateStatusFunction() override {}
 
   // ExtensionFunction:
-  bool RunSync() override;
+  ResponseAction Run() override;
 };
 
 // API function which returns the Google API key.
-class SystemPrivateGetApiKeyFunction : public SyncExtensionFunction {
+class SystemPrivateGetApiKeyFunction : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("systemPrivate.getApiKey", SYSTEMPRIVATE_GETAPIKEY)
 
@@ -48,7 +47,7 @@ class SystemPrivateGetApiKeyFunction : public SyncExtensionFunction {
   ~SystemPrivateGetApiKeyFunction() override {}
 
   // ExtensionFunction:
-  bool RunSync() override;
+  ResponseAction Run() override;
 };
 
 // Dispatches systemPrivate.onBrightnessChanged event for extensions.

extensions/browser/api/management/management_api.cc

@@ -268,7 +268,7 @@ void AddExtensionInfo(const ExtensionSet& extensions,
 
 }  // namespace
 
-bool ManagementGetAllFunction::RunSync() {
+ExtensionFunction::ResponseAction ManagementGetAllFunction::Run() {
   ExtensionInfoList extensions;
   ExtensionRegistry* registry = ExtensionRegistry::Get(browser_context());
 
@@ -279,11 +279,11 @@ bool ManagementGetAllFunction::RunSync() {
   AddExtensionInfo(registry->terminated_extensions(), &extensions,
                    browser_context());
 
-  results_ = management::GetAll::Results::Create(extensions);
-  return true;
+  return RespondNow(
+      ArgumentList(management::GetAll::Results::Create(extensions)));
 }
 
-bool ManagementGetFunction::RunSync() {
+ExtensionFunction::ResponseAction ManagementGetFunction::Run() {
   std::unique_ptr<management::Get::Params> params(
       management::Get::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
@@ -291,26 +291,20 @@ bool ManagementGetFunction::RunSync() {
 
   const Extension* extension =
       registry->GetExtensionById(params->id, ExtensionRegistry::EVERYTHING);
-  if (!extension) {
-    error_ =
-        ErrorUtils::FormatErrorMessage(keys::kNoExtensionError, params->id);
-    return false;
-  }
+  if (!extension)
+    return RespondNow(Error(keys::kNoExtensionError, params->id));
 
-  results_ = management::Get::Results::Create(
-      CreateExtensionInfo(*extension, browser_context()));
-
-  return true;
+  return RespondNow(ArgumentList(management::Get::Results::Create(
+      CreateExtensionInfo(*extension, browser_context()))));
 }
 
-bool ManagementGetSelfFunction::RunSync() {
-  results_ = management::Get::Results::Create(
-      CreateExtensionInfo(*extension_, browser_context()));
-
-  return true;
+ExtensionFunction::ResponseAction ManagementGetSelfFunction::Run() {
+  return RespondNow(ArgumentList(management::Get::Results::Create(
+      CreateExtensionInfo(*extension_, browser_context()))));
 }
 
-bool ManagementGetPermissionWarningsByIdFunction::RunSync() {
+ExtensionFunction::ResponseAction
+ManagementGetPermissionWarningsByIdFunction::Run() {
   std::unique_ptr<management::GetPermissionWarningsById::Params> params(
       management::GetPermissionWarningsById::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
@@ -318,15 +312,12 @@ bool ManagementGetPermissionWarningsByIdFunction::RunSync() {
   const Extension* extension =
       ExtensionRegistry::Get(browser_context())
           ->GetExtensionById(params->id, ExtensionRegistry::EVERYTHING);
-  if (!extension) {
-    error_ =
-        ErrorUtils::FormatErrorMessage(keys::kNoExtensionError, params->id);
-    return false;
-  }
+  if (!extension)
+    return RespondNow(Error(keys::kNoExtensionError, params->id));
 
   std::vector<std::string> warnings = CreateWarningsList(extension);
-  results_ = management::GetPermissionWarningsById::Results::Create(warnings);
-  return true;
+  return RespondNow(ArgumentList(
+      management::GetPermissionWarningsById::Results::Create(warnings)));
 }
 
 bool ManagementGetPermissionWarningsByManifestFunction::RunAsync() {
@@ -389,27 +380,23 @@ void ManagementGetPermissionWarningsByManifestFunction::OnParseFailure(
   Release();
 }
 
-bool ManagementLaunchAppFunction::RunSync() {
+ExtensionFunction::ResponseAction ManagementLaunchAppFunction::Run() {
   std::unique_ptr<management::LaunchApp::Params> params(
       management::LaunchApp::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   const Extension* extension =
       ExtensionRegistry::Get(browser_context())
           ->GetExtensionById(params->id, ExtensionRegistry::EVERYTHING);
-  if (!extension) {
-    error_ =
-        ErrorUtils::FormatErrorMessage(keys::kNoExtensionError, params->id);
-    return false;
-  }
-  if (!extension->is_app()) {
-    error_ = ErrorUtils::FormatErrorMessage(keys::kNotAnAppError, params->id);
-    return false;
-  }
+  if (!extension)
+    return RespondNow(Error(keys::kNoExtensionError, params->id));
+  if (!extension->is_app())
+    return RespondNow(Error(keys::kNotAnAppError, params->id));
 
   const ManagementAPIDelegate* delegate = ManagementAPI::GetFactoryInstance()
                                               ->Get(browser_context())
                                               ->GetDelegate();
-  return delegate->LaunchAppFunctionDelegate(extension, browser_context());
+  delegate->LaunchAppFunctionDelegate(extension, browser_context());
+  return RespondNow(NoArguments());
 }
 
 ManagementSetEnabledFunction::ManagementSetEnabledFunction() {
@@ -704,11 +691,9 @@ bool ManagementCreateAppShortcutFunction::RunAsync() {
   return true;
 }
 
-bool ManagementSetLaunchTypeFunction::RunSync() {
-  if (!user_gesture()) {
-    error_ = keys::kGestureNeededForSetLaunchTypeError;
-    return false;
-  }
+ExtensionFunction::ResponseAction ManagementSetLaunchTypeFunction::Run() {
+  if (!user_gesture())
+    return RespondNow(Error(keys::kGestureNeededForSetLaunchTypeError));
 
   std::unique_ptr<management::SetLaunchType::Params> params(
       management::SetLaunchType::Params::Create(*args_));
@@ -719,16 +704,11 @@ bool ManagementSetLaunchTypeFunction::RunSync() {
   const ManagementAPIDelegate* delegate = ManagementAPI::GetFactoryInstance()
                                               ->Get(browser_context())
                                               ->GetDelegate();
-  if (!extension) {
-    error_ =
-        ErrorUtils::FormatErrorMessage(keys::kNoExtensionError, params->id);
-    return false;
-  }
+  if (!extension)
+    return RespondNow(Error(keys::kNoExtensionError, params->id));
 
-  if (!extension->is_app()) {
-    error_ = ErrorUtils::FormatErrorMessage(keys::kNotAnAppError, params->id);
-    return false;
-  }
+  if (!extension->is_app())
+    return RespondNow(Error(keys::kNotAnAppError, params->id));
 
   std::vector<management::LaunchType> available_launch_types =
       GetAvailableLaunchTypes(*extension, delegate);
@@ -736,8 +716,7 @@ bool ManagementSetLaunchTypeFunction::RunSync() {
   management::LaunchType app_launch_type = params->launch_type;
   if (std::find(available_launch_types.begin(), available_launch_types.end(),
                 app_launch_type) == available_launch_types.end()) {
-    error_ = keys::kLaunchTypeNotAvailableError;
-    return false;
+    return RespondNow(Error(keys::kLaunchTypeNotAvailableError));
   }
 
   LaunchType launch_type = LAUNCH_TYPE_DEFAULT;
@@ -760,7 +739,7 @@ bool ManagementSetLaunchTypeFunction::RunSync() {
 
   delegate->SetLaunchType(browser_context(), params->id, launch_type);
 
-  return true;
+  return RespondNow(NoArguments());
 }
 
 ManagementGenerateAppForLinkFunction::ManagementGenerateAppForLinkFunction() {

extensions/browser/api/management/management_api.h

@@ -23,17 +23,12 @@ namespace extensions {
 class ExtensionRegistry;
 class RequirementsChecker;
 
-class ManagementFunction : public SyncExtensionFunction {
- protected:
-  ~ManagementFunction() override {}
-};
-
 class AsyncManagementFunction : public AsyncExtensionFunction {
  protected:
   ~AsyncManagementFunction() override {}
 };
 
-class ManagementGetAllFunction : public ManagementFunction {
+class ManagementGetAllFunction : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("management.getAll", MANAGEMENT_GETALL)
 
@@ -41,10 +36,10 @@ class ManagementGetAllFunction : public ManagementFunction {
   ~ManagementGetAllFunction() override {}
 
   // ExtensionFunction:
-  bool RunSync() override;
+  ResponseAction Run() override;
 };
 
-class ManagementGetFunction : public ManagementFunction {
+class ManagementGetFunction : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("management.get", MANAGEMENT_GET)
 
@@ -52,10 +47,10 @@ class ManagementGetFunction : public ManagementFunction {
   ~ManagementGetFunction() override {}
 
   // ExtensionFunction:
-  bool RunSync() override;
+  ResponseAction Run() override;
 };
 
-class ManagementGetSelfFunction : public ManagementFunction {
+class ManagementGetSelfFunction : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("management.getSelf", MANAGEMENT_GETSELF)
 
@@ -63,10 +58,11 @@ class ManagementGetSelfFunction : public ManagementFunction {
   ~ManagementGetSelfFunction() override {}
 
   // ExtensionFunction:
-  bool RunSync() override;
+  ResponseAction Run() override;
 };
 
-class ManagementGetPermissionWarningsByIdFunction : public ManagementFunction {
+class ManagementGetPermissionWarningsByIdFunction
+    : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("management.getPermissionWarningsById",
                              MANAGEMENT_GETPERMISSIONWARNINGSBYID)
@@ -75,7 +71,7 @@ class ManagementGetPermissionWarningsByIdFunction : public ManagementFunction {
   ~ManagementGetPermissionWarningsByIdFunction() override {}
 
   // ExtensionFunction:
-  bool RunSync() override;
+  ResponseAction Run() override;
 };
 
 class ManagementGetPermissionWarningsByManifestFunction
@@ -95,7 +91,7 @@ class ManagementGetPermissionWarningsByManifestFunction
   bool RunAsync() override;
 };
 
-class ManagementLaunchAppFunction : public ManagementFunction {
+class ManagementLaunchAppFunction : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("management.launchApp", MANAGEMENT_LAUNCHAPP)
 
@@ -103,7 +99,7 @@ class ManagementLaunchAppFunction : public ManagementFunction {
   ~ManagementLaunchAppFunction() override {}
 
   // ExtensionFunction:
-  bool RunSync() override;
+  ResponseAction Run() override;
 };
 
 class ManagementSetEnabledFunction : public UIThreadExtensionFunction {
@@ -192,7 +188,7 @@ class ManagementCreateAppShortcutFunction : public AsyncManagementFunction {
   bool RunAsync() override;
 };
 
-class ManagementSetLaunchTypeFunction : public ManagementFunction {
+class ManagementSetLaunchTypeFunction : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("management.setLaunchType",
                              MANAGEMENT_SETLAUNCHTYPE);
@@ -200,7 +196,7 @@ class ManagementSetLaunchTypeFunction : public ManagementFunction {
  protected:
   ~ManagementSetLaunchTypeFunction() override {}
 
-  bool RunSync() override;
+  ResponseAction Run() override;
 };
 
 class ManagementGenerateAppForLinkFunction : public AsyncManagementFunction {

extensions/browser/api/management/management_api_delegate.h

@@ -50,8 +50,8 @@ class ManagementAPIDelegate {
  public:
   virtual ~ManagementAPIDelegate() {}
 
-  // Launches the app |extension|. Returns true on success.
-  virtual bool LaunchAppFunctionDelegate(
+  // Launches the app |extension|.
+  virtual void LaunchAppFunctionDelegate(
       const Extension* extension,
       content::BrowserContext* context) const = 0;
 

extensions/browser/api/networking_private/networking_private_api.cc

@@ -315,13 +315,12 @@ NetworkingPrivateGetEnabledNetworkTypesFunction::
     ~NetworkingPrivateGetEnabledNetworkTypesFunction() {
 }
 
-bool NetworkingPrivateGetEnabledNetworkTypesFunction::RunSync() {
+ExtensionFunction::ResponseAction
+NetworkingPrivateGetEnabledNetworkTypesFunction::Run() {
   std::unique_ptr<base::ListValue> enabled_networks_onc_types(
       GetDelegate(browser_context())->GetEnabledNetworkTypes());
-  if (!enabled_networks_onc_types) {
-    error_ = networking_private::kErrorNotSupported;
-    return false;
-  }
+  if (!enabled_networks_onc_types)
+    return RespondNow(Error(networking_private::kErrorNotSupported));
   std::unique_ptr<base::ListValue> enabled_networks_list(new base::ListValue);
   for (base::ListValue::iterator iter = enabled_networks_onc_types->begin();
        iter != enabled_networks_onc_types->end(); ++iter) {
@@ -344,8 +343,7 @@ bool NetworkingPrivateGetEnabledNetworkTypesFunction::RunSync() {
       LOG(ERROR) << "networkingPrivate: Unexpected type: " << type;
     }
   }
-  SetResult(std::move(enabled_networks_list));
-  return true;
+  return RespondNow(OneArgument(std::move(enabled_networks_list)));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -355,19 +353,17 @@ NetworkingPrivateGetDeviceStatesFunction::
     ~NetworkingPrivateGetDeviceStatesFunction() {
 }
 
-bool NetworkingPrivateGetDeviceStatesFunction::RunSync() {
+ExtensionFunction::ResponseAction
+NetworkingPrivateGetDeviceStatesFunction::Run() {
   std::unique_ptr<NetworkingPrivateDelegate::DeviceStateList> device_states(
       GetDelegate(browser_context())->GetDeviceStateList());
-  if (!device_states) {
-    error_ = networking_private::kErrorNotSupported;
-    return false;
-  }
+  if (!device_states)
+    return RespondNow(Error(networking_private::kErrorNotSupported));
 
   std::unique_ptr<base::ListValue> device_state_list(new base::ListValue);
   for (const auto& properties : *device_states)
     device_state_list->Append(properties->ToValue());
-  SetResult(std::move(device_state_list));
-  return true;
+  return RespondNow(OneArgument(std::move(device_state_list)));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -377,13 +373,17 @@ NetworkingPrivateEnableNetworkTypeFunction::
     ~NetworkingPrivateEnableNetworkTypeFunction() {
 }
 
-bool NetworkingPrivateEnableNetworkTypeFunction::RunSync() {
+ExtensionFunction::ResponseAction
+NetworkingPrivateEnableNetworkTypeFunction::Run() {
   std::unique_ptr<private_api::EnableNetworkType::Params> params =
       private_api::EnableNetworkType::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  return GetDelegate(browser_context())
-      ->EnableNetworkType(private_api::ToString(params->network_type));
+  if (!GetDelegate(browser_context())
+           ->EnableNetworkType(private_api::ToString(params->network_type))) {
+    return RespondNow(Error(networking_private::kErrorNotSupported));
+  }
+  return RespondNow(NoArguments());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -393,12 +393,16 @@ NetworkingPrivateDisableNetworkTypeFunction::
     ~NetworkingPrivateDisableNetworkTypeFunction() {
 }
 
-bool NetworkingPrivateDisableNetworkTypeFunction::RunSync() {
+ExtensionFunction::ResponseAction
+NetworkingPrivateDisableNetworkTypeFunction::Run() {
   std::unique_ptr<private_api::DisableNetworkType::Params> params =
       private_api::DisableNetworkType::Params::Create(*args_);
 
-  return GetDelegate(browser_context())
-      ->DisableNetworkType(private_api::ToString(params->network_type));
+  if (!GetDelegate(browser_context())
+           ->DisableNetworkType(private_api::ToString(params->network_type))) {
+    return RespondNow(Error(networking_private::kErrorNotSupported));
+  }
+  return RespondNow(NoArguments());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -408,8 +412,11 @@ NetworkingPrivateRequestNetworkScanFunction::
     ~NetworkingPrivateRequestNetworkScanFunction() {
 }
 
-bool NetworkingPrivateRequestNetworkScanFunction::RunSync() {
-  return GetDelegate(browser_context())->RequestScan();
+ExtensionFunction::ResponseAction
+NetworkingPrivateRequestNetworkScanFunction::Run() {
+  if (!GetDelegate(browser_context())->RequestScan())
+    return RespondNow(Error(networking_private::kErrorNotSupported));
+  return RespondNow(NoArguments());
 }
 
 ////////////////////////////////////////////////////////////////////////////////

extensions/browser/api/networking_private/networking_private_api.h

@@ -190,7 +190,7 @@ class NetworkingPrivateGetVisibleNetworksFunction
 
 // Implements the chrome.networkingPrivate.getEnabledNetworkTypes method.
 class NetworkingPrivateGetEnabledNetworkTypesFunction
-    : public SyncExtensionFunction {
+    : public UIThreadExtensionFunction {
  public:
   NetworkingPrivateGetEnabledNetworkTypesFunction() {}
   DECLARE_EXTENSION_FUNCTION("networkingPrivate.getEnabledNetworkTypes",
@@ -199,15 +199,16 @@ class NetworkingPrivateGetEnabledNetworkTypesFunction
  protected:
   ~NetworkingPrivateGetEnabledNetworkTypesFunction() override;
 
-  // SyncExtensionFunction overrides.
-  bool RunSync() override;
+  // ExtensionFunction:
+  ResponseAction Run() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateGetEnabledNetworkTypesFunction);
 };
 
 // Implements the chrome.networkingPrivate.getDeviceStates method.
-class NetworkingPrivateGetDeviceStatesFunction : public SyncExtensionFunction {
+class NetworkingPrivateGetDeviceStatesFunction
+    : public UIThreadExtensionFunction {
  public:
   NetworkingPrivateGetDeviceStatesFunction() {}
   DECLARE_EXTENSION_FUNCTION("networkingPrivate.getDeviceStates",
@@ -216,8 +217,8 @@ class NetworkingPrivateGetDeviceStatesFunction : public SyncExtensionFunction {
  protected:
   ~NetworkingPrivateGetDeviceStatesFunction() override;
 
-  // SyncExtensionFunction overrides.
-  bool RunSync() override;
+  // ExtensionFunction:
+  ResponseAction Run() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateGetDeviceStatesFunction);
@@ -225,7 +226,7 @@ class NetworkingPrivateGetDeviceStatesFunction : public SyncExtensionFunction {
 
 // Implements the chrome.networkingPrivate.enableNetworkType method.
 class NetworkingPrivateEnableNetworkTypeFunction
-    : public SyncExtensionFunction {
+    : public UIThreadExtensionFunction {
  public:
   NetworkingPrivateEnableNetworkTypeFunction() {}
   DECLARE_EXTENSION_FUNCTION("networkingPrivate.enableNetworkType",
@@ -234,8 +235,8 @@ class NetworkingPrivateEnableNetworkTypeFunction
  protected:
   ~NetworkingPrivateEnableNetworkTypeFunction() override;
 
-  // SyncExtensionFunction overrides.
-  bool RunSync() override;
+  // ExtensionFunction:
+  ResponseAction Run() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateEnableNetworkTypeFunction);
@@ -243,7 +244,7 @@ class NetworkingPrivateEnableNetworkTypeFunction
 
 // Implements the chrome.networkingPrivate.disableNetworkType method.
 class NetworkingPrivateDisableNetworkTypeFunction
-    : public SyncExtensionFunction {
+    : public UIThreadExtensionFunction {
  public:
   NetworkingPrivateDisableNetworkTypeFunction() {}
   DECLARE_EXTENSION_FUNCTION("networkingPrivate.disableNetworkType",
@@ -252,8 +253,8 @@ class NetworkingPrivateDisableNetworkTypeFunction
  protected:
   ~NetworkingPrivateDisableNetworkTypeFunction() override;
 
-  // SyncExtensionFunction overrides.
-  bool RunSync() override;
+  // ExtensionFunction:
+  ResponseAction Run() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateDisableNetworkTypeFunction);
@@ -261,7 +262,7 @@ class NetworkingPrivateDisableNetworkTypeFunction
 
 // Implements the chrome.networkingPrivate.requestNetworkScan method.
 class NetworkingPrivateRequestNetworkScanFunction
-    : public SyncExtensionFunction {
+    : public UIThreadExtensionFunction {
  public:
   NetworkingPrivateRequestNetworkScanFunction() {}
   DECLARE_EXTENSION_FUNCTION("networkingPrivate.requestNetworkScan",
@@ -270,8 +271,8 @@ class NetworkingPrivateRequestNetworkScanFunction
  protected:
   ~NetworkingPrivateRequestNetworkScanFunction() override;
 
-  // SyncExtensionFunction overrides.
-  bool RunSync() override;
+  // ExtensionFunction:
+  ResponseAction Run() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateRequestNetworkScanFunction);

extensions/browser/api/power/power_api.cc

@@ -46,18 +46,17 @@ std::unique_ptr<device::PowerSaveBlocker> CreatePowerSaveBlocker(
 
 }  // namespace
 
-bool PowerRequestKeepAwakeFunction::RunSync() {
+ExtensionFunction::ResponseAction PowerRequestKeepAwakeFunction::Run() {
   std::unique_ptr<api::power::RequestKeepAwake::Params> params(
       api::power::RequestKeepAwake::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
-  EXTENSION_FUNCTION_VALIDATE(params->level != api::power::LEVEL_NONE);
   PowerAPI::Get(browser_context())->AddRequest(extension_id(), params->level);
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool PowerReleaseKeepAwakeFunction::RunSync() {
+ExtensionFunction::ResponseAction PowerReleaseKeepAwakeFunction::Run() {
   PowerAPI::Get(browser_context())->RemoveRequest(extension_id());
-  return true;
+  return RespondNow(NoArguments());
 }
 
 // static

extensions/browser/api/power/power_api.h

@@ -24,7 +24,7 @@ class BrowserContext;
 namespace extensions {
 
 // Implementation of the chrome.power.requestKeepAwake API.
-class PowerRequestKeepAwakeFunction : public SyncExtensionFunction {
+class PowerRequestKeepAwakeFunction : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("power.requestKeepAwake", POWER_REQUESTKEEPAWAKE)
 
@@ -32,11 +32,11 @@ class PowerRequestKeepAwakeFunction : public SyncExtensionFunction {
   ~PowerRequestKeepAwakeFunction() override {}
 
   // ExtensionFunction:
-  bool RunSync() override;
+  ResponseAction Run() override;
 };
 
 // Implementation of the chrome.power.releaseKeepAwake API.
-class PowerReleaseKeepAwakeFunction : public SyncExtensionFunction {
+class PowerReleaseKeepAwakeFunction : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("power.releaseKeepAwake", POWER_RELEASEKEEPAWAKE)
 
@@ -44,7 +44,7 @@ class PowerReleaseKeepAwakeFunction : public SyncExtensionFunction {
   ~PowerReleaseKeepAwakeFunction() override {}
 
   // ExtensionFunction:
-  bool RunSync() override;
+  ResponseAction Run() override;
 };
 
 // Handles calls made via the chrome.power API. There is a separate instance of