[Extensions] Convert some SyncExtensionFunctions

extensions/browser/api/system_display/system_display_api.cc

Index: extensions/browser/api/system_display/system_display_api.cc
diff --git a/extensions/browser/api/system_display/system_display_api.cc b/extensions/browser/api/system_display/system_display_api.cc
index 2b09bad50bcd88c0cb5771da2772fb3a04223ff4..cbab1a7ac730589c1a207c7cb9a0026fb50d7a82 100644
--- a/extensions/browser/api/system_display/system_display_api.cc
+++ b/extensions/browser/api/system_display/system_display_api.cc
@@ -17,162 +17,157 @@
 
 namespace extensions {
 
-namespace system_display = api::system_display;
+namespace display = api::system_display;
 
 const char SystemDisplayFunction::kCrosOnlyError[] =
     "Function available only on ChromeOS.";
 const char SystemDisplayFunction::kKioskOnlyError[] =
     "Only kiosk enabled extensions are allowed to use this function.";
 
-bool SystemDisplayFunction::CheckValidExtension() {
+bool SystemDisplayFunction::PreRunValidation(std::string* error) {
+  if (!UIThreadExtensionFunction::PreRunValidation(error))
+    return false;
+  if (!ShouldRestrictToKioskAndWebUI())
+    return true;
+
   if (!extension())
     return true;
 #if defined(OS_CHROMEOS)
   if (KioskModeInfo::IsKioskEnabled(extension()))
     return true;
 #endif
-  SetError(kKioskOnlyError);
+  *error = kKioskOnlyError;
   return false;
 }
 
-bool SystemDisplayGetInfoFunction::RunSync() {
+bool SystemDisplayFunction::ShouldRestrictToKioskAndWebUI() {
+  return true;
+}
+
+ExtensionFunction::ResponseAction SystemDisplayGetInfoFunction::Run() {
   DisplayInfoProvider::DisplayUnitInfoList all_displays_info =
       DisplayInfoProvider::Get()->GetAllDisplaysInfo();
-  results_ = system_display::GetInfo::Results::Create(all_displays_info);
-  return true;
+  return RespondNow(
+      ArgumentList(display::GetInfo::Results::Create(all_displays_info)));
 }
 
-bool SystemDisplayGetDisplayLayoutFunction::RunSync() {
-#if !defined(OS_CHROMEOS)
-  SetError(kCrosOnlyError);
+bool SystemDisplayGetInfoFunction::ShouldRestrictToKioskAndWebUI() {
   return false;
+}
+
+ExtensionFunction::ResponseAction SystemDisplayGetDisplayLayoutFunction::Run() {
+#if !defined(OS_CHROMEOS)

[lazyboy, 2016/08/26 23:13:16]

As 8 out of 9 functions in this namespace is CrOS only, can we also pull this to
PreRunValidation()?

Also the loner SystemDisplayGetInfoFunction seems sufficiently different that
you might consider not extending it from SystemDisplayFunction and extending it
directly from UIThreadExtensionFunction...

[Devlin, 2016/08/29 16:05:56]

Done. Originally I avoided that because it means all this code will be compiled
on all platforms, but it looks like that's not a problem.

+  return RespondNow(Error(kCrosOnlyError));
 #else
   DisplayInfoProvider::DisplayLayoutList display_layout =
       DisplayInfoProvider::Get()->GetDisplayLayout();
-  results_ = system_display::GetDisplayLayout::Results::Create(display_layout);
-  return true;
+  return RespondNow(
+      ArgumentList(display::GetDisplayLayout::Results::Create(display_layout)));
 #endif
 }
 
-bool SystemDisplaySetDisplayPropertiesFunction::RunSync() {
-#if !defined(OS_CHROMEOS)
-  SetError(kCrosOnlyError);
+bool SystemDisplayGetDisplayLayoutFunction::ShouldRestrictToKioskAndWebUI() {
   return false;
+}
+
+ExtensionFunction::ResponseAction
+SystemDisplaySetDisplayPropertiesFunction::Run() {
+#if !defined(OS_CHROMEOS)
+  return RespondNow(Error(kCrosOnlyError));
 #else
-  if (!CheckValidExtension())
-    return false;
   std::string error;
-  std::unique_ptr<system_display::SetDisplayProperties::Params> params(
-      system_display::SetDisplayProperties::Params::Create(*args_));
+  std::unique_ptr<display::SetDisplayProperties::Params> params(
+      display::SetDisplayProperties::Params::Create(*args_));
   bool result =
       DisplayInfoProvider::Get()->SetInfo(params->id, params->info, &error);
   if (!result)
-    SetError(error);
-  return result;
+    return RespondNow(Error(error));
+  return RespondNow(NoArguments());
 #endif
 }
 
-bool SystemDisplaySetDisplayLayoutFunction::RunSync() {
+ExtensionFunction::ResponseAction SystemDisplaySetDisplayLayoutFunction::Run() {
 #if !defined(OS_CHROMEOS)
-  SetError(kCrosOnlyError);
-  return false;
+  return RespondNow(Error(kCrosOnlyError));
 #else
-  if (!CheckValidExtension())
-    return false;
-  std::unique_ptr<system_display::SetDisplayLayout::Params> params(
-      system_display::SetDisplayLayout::Params::Create(*args_));
-  if (!DisplayInfoProvider::Get()->SetDisplayLayout(params->layouts)) {
-    SetError("Unable to set display layout");
-    return false;
-  }
-  return true;
+  std::unique_ptr<display::SetDisplayLayout::Params> params(
+      display::SetDisplayLayout::Params::Create(*args_));
+  if (!DisplayInfoProvider::Get()->SetDisplayLayout(params->layouts))
+    return RespondNow(Error("Unable to set display layout"));
+  return RespondNow(NoArguments());
 #endif
 }
 
-bool SystemDisplayEnableUnifiedDesktopFunction::RunSync() {
+ExtensionFunction::ResponseAction
+SystemDisplayEnableUnifiedDesktopFunction::Run() {
 #if !defined(OS_CHROMEOS)
-  SetError(kCrosOnlyError);
-  return false;
+  return RespondNow(Error(kCrosOnlyError));
 #else
-  if (!CheckValidExtension())
-    return false;
-  std::unique_ptr<system_display::EnableUnifiedDesktop::Params> params(
-      system_display::EnableUnifiedDesktop::Params::Create(*args_));
+  std::unique_ptr<display::EnableUnifiedDesktop::Params> params(
+      display::EnableUnifiedDesktop::Params::Create(*args_));
   DisplayInfoProvider::Get()->EnableUnifiedDesktop(params->enabled);
-  return true;
+  return RespondNow(NoArguments());
 #endif
 }
 
-bool SystemDisplayOverscanCalibrationStartFunction::RunSync() {
+ExtensionFunction::ResponseAction
+SystemDisplayOverscanCalibrationStartFunction::Run() {
 #if !defined(OS_CHROMEOS)
-  SetError(kCrosOnlyError);
-  return false;
+  return RespondNow(Error(kCrosOnlyError));
 #else
-  if (!CheckValidExtension())
-    return false;
-  std::unique_ptr<system_display::OverscanCalibrationStart::Params> params(
-      system_display::OverscanCalibrationStart::Params::Create(*args_));
-  if (!DisplayInfoProvider::Get()->OverscanCalibrationStart(params->id)) {
-    SetError("Invalid display ID: " + params->id);
-    return false;
-  }
-  return true;
+  std::unique_ptr<display::OverscanCalibrationStart::Params> params(
+      display::OverscanCalibrationStart::Params::Create(*args_));
+  if (!DisplayInfoProvider::Get()->OverscanCalibrationStart(params->id))
+    return RespondNow(Error("Invalid display ID: " + params->id));
+  return RespondNow(NoArguments());
 #endif
 }
 
-bool SystemDisplayOverscanCalibrationAdjustFunction::RunSync() {
+ExtensionFunction::ResponseAction
+SystemDisplayOverscanCalibrationAdjustFunction::Run() {
 #if !defined(OS_CHROMEOS)
-  SetError(kCrosOnlyError);
-  return false;
+  return RespondNow(Error(kCrosOnlyError));
 #else
-  if (!CheckValidExtension())
-    return false;
-  std::unique_ptr<system_display::OverscanCalibrationAdjust::Params> params(
-      system_display::OverscanCalibrationAdjust::Params::Create(*args_));
-  if (!params) {
-    SetError("Invalid parameters");
-    return false;
-  }
+  std::unique_ptr<display::OverscanCalibrationAdjust::Params> params(
+      display::OverscanCalibrationAdjust::Params::Create(*args_));
+  if (!params)
+    return RespondNow(Error("Invalid parameters"));
   if (!DisplayInfoProvider::Get()->OverscanCalibrationAdjust(params->id,
                                                              params->delta)) {
-    SetError("Calibration not started for display ID: " + params->id);
-    return false;
+    return RespondNow(
+        Error("Calibration not started for display ID: " + params->id));
   }
-  return true;
+  return RespondNow(NoArguments());
+  ;
 #endif
 }
 
-bool SystemDisplayOverscanCalibrationResetFunction::RunSync() {
+ExtensionFunction::ResponseAction
+SystemDisplayOverscanCalibrationResetFunction::Run() {
 #if !defined(OS_CHROMEOS)
-  SetError(kCrosOnlyError);
-  return false;
+  return RespondNow(Error(kCrosOnlyError));
 #else
-  if (!CheckValidExtension())
-    return false;
-  std::unique_ptr<system_display::OverscanCalibrationReset::Params> params(
-      system_display::OverscanCalibrationReset::Params::Create(*args_));
-  if (!DisplayInfoProvider::Get()->OverscanCalibrationReset(params->id)) {
-    SetError("Calibration not started for display ID: " + params->id);
-    return false;
-  }
-  return true;
+  std::unique_ptr<display::OverscanCalibrationReset::Params> params(
+      display::OverscanCalibrationReset::Params::Create(*args_));
+  if (!DisplayInfoProvider::Get()->OverscanCalibrationReset(params->id))
+    return RespondNow(
+        Error("Calibration not started for display ID: " + params->id));
+  return RespondNow(NoArguments());
 #endif
 }
 
-bool SystemDisplayOverscanCalibrationCompleteFunction::RunSync() {
+ExtensionFunction::ResponseAction
+SystemDisplayOverscanCalibrationCompleteFunction::Run() {
 #if !defined(OS_CHROMEOS)
-  SetError(kCrosOnlyError);
-  return false;
+  return RespondNow(Error(kCrosOnlyError));
 #else
-  if (!CheckValidExtension())
-    return false;
-  std::unique_ptr<system_display::OverscanCalibrationComplete::Params> params(
-      system_display::OverscanCalibrationComplete::Params::Create(*args_));
+  std::unique_ptr<display::OverscanCalibrationComplete::Params> params(
+      display::OverscanCalibrationComplete::Params::Create(*args_));
   if (!DisplayInfoProvider::Get()->OverscanCalibrationComplete(params->id)) {
-    SetError("Calibration not started for display ID: " + params->id);
-    return false;
+    return RespondNow(
+        Error("Calibration not started for display ID: " + params->id));
   }
-  return true;
+  return RespondNow(NoArguments());
 #endif
 }