[Extensions] Convert some SyncExtensionFunctions

extensions/browser/api/system_display/system_display_api.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "extensions/browser/api/system_display/system_display_api.h"
 
 #include <memory>
 #include <string>
 
 #include "build/build_config.h"
 #include "extensions/browser/api/system_display/display_info_provider.h"
 #include "extensions/common/api/system_display.h"
 
 #if defined(OS_CHROMEOS)
 #include "extensions/common/manifest_handlers/kiosk_mode_info.h"
 #endif
 
 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() {
-  DisplayInfoProvider::DisplayUnitInfoList all_displays_info =
-      DisplayInfoProvider::Get()->GetAllDisplaysInfo();
-  results_ = system_display::GetInfo::Results::Create(all_displays_info);
+bool SystemDisplayFunction::ShouldRestrictToKioskAndWebUI() {
   return true;
 }
 
-bool SystemDisplayGetDisplayLayoutFunction::RunSync() {
+ExtensionFunction::ResponseAction SystemDisplayGetInfoFunction::Run() {
+  DisplayInfoProvider::DisplayUnitInfoList all_displays_info =
+      DisplayInfoProvider::Get()->GetAllDisplaysInfo();
+  return RespondNow(
+      ArgumentList(display::GetInfo::Results::Create(all_displays_info)));
+}
+
+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.

-  SetError(kCrosOnlyError);
-  return false;
+  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() {
+bool SystemDisplayGetDisplayLayoutFunction::ShouldRestrictToKioskAndWebUI() {
+  return false;
+}
+
+ExtensionFunction::ResponseAction
+SystemDisplaySetDisplayPropertiesFunction::Run() {
 #if !defined(OS_CHROMEOS)
-  SetError(kCrosOnlyError);
-  return false;
+  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
 }
 
 }  // namespace extensions