[Extensions] Convert some ChromeSyncExtensionFunctions

chrome/browser/extensions/api/autotest_private/autotest_private_api.cc

 // Copyright (c) 2012 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/autotest_private/autotest_private_api.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/lazy_instance.h"
@@ skipping 48 matching lines @@
   base::ListValue* permissions = new base::ListValue;
   std::set<std::string> perm_list =
       ext->permissions_data()->active_permissions().GetAPIsAsStrings();
   for (std::set<std::string>::const_iterator perm = perm_list.begin();
        perm != perm_list.end(); ++perm) {
     permissions->AppendString(perm->c_str());
   }
   return permissions;
 }
 
-bool IsTestMode(Profile* profile) {
-  return AutotestPrivateAPI::GetFactoryInstance()->Get(profile)->test_mode();
+bool IsTestMode(content::BrowserContext* context) {
+  return AutotestPrivateAPI::GetFactoryInstance()->Get(context)->test_mode();
 }
 
 }  // namespace
 
-bool AutotestPrivateLogoutFunction::RunSync() {
+ExtensionFunction::ResponseAction AutotestPrivateLogoutFunction::Run() {
   DVLOG(1) << "AutotestPrivateLogoutFunction";
-  if (!IsTestMode(GetProfile()))
+  if (!IsTestMode(browser_context()))
     chrome::AttemptUserExit();
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool AutotestPrivateRestartFunction::RunSync() {
+ExtensionFunction::ResponseAction AutotestPrivateRestartFunction::Run() {
   DVLOG(1) << "AutotestPrivateRestartFunction";
-  if (!IsTestMode(GetProfile()))
+  if (!IsTestMode(browser_context()))
     chrome::AttemptRestart();
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool AutotestPrivateShutdownFunction::RunSync() {
+ExtensionFunction::ResponseAction AutotestPrivateShutdownFunction::Run() {
   std::unique_ptr<api::autotest_private::Shutdown::Params> params(
       api::autotest_private::Shutdown::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   DVLOG(1) << "AutotestPrivateShutdownFunction " << params->force;
 
-  if (!IsTestMode(GetProfile()))
+  if (!IsTestMode(browser_context()))
     chrome::AttemptExit();
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool AutotestPrivateLoginStatusFunction::RunSync() {
+ExtensionFunction::ResponseAction AutotestPrivateLoginStatusFunction::Run() {
   DVLOG(1) << "AutotestPrivateLoginStatusFunction";
 
   std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue);
 #if defined(OS_CHROMEOS)
   const user_manager::UserManager* user_manager =
       user_manager::UserManager::Get();
   const bool is_screen_locked =
       !!chromeos::ScreenLocker::default_screen_locker();
 
   if (user_manager) {
@@ skipping 22 matching lines @@
 
         default:
           user_image = base::IntToString(user->image_index());
           break;
       }
       result->SetString("userImage", user_image);
     }
   }
 #endif
 
-  SetResult(std::move(result));
-  return true;
+  return RespondNow(OneArgument(std::move(result)));
 }
 
-bool AutotestPrivateLockScreenFunction::RunSync() {
+ExtensionFunction::ResponseAction AutotestPrivateLockScreenFunction::Run() {
   DVLOG(1) << "AutotestPrivateLockScreenFunction";
 #if defined(OS_CHROMEOS)
   chromeos::DBusThreadManager::Get()->GetSessionManagerClient()->
       RequestLockScreen();
 #endif
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool AutotestPrivateGetExtensionsInfoFunction::RunSync() {
+ExtensionFunction::ResponseAction
+AutotestPrivateGetExtensionsInfoFunction::Run() {
   DVLOG(1) << "AutotestPrivateGetExtensionsInfoFunction";
 
   ExtensionService* service =
-      ExtensionSystem::Get(GetProfile())->extension_service();
-  ExtensionRegistry* registry = ExtensionRegistry::Get(GetProfile());
+      ExtensionSystem::Get(browser_context())->extension_service();
+  ExtensionRegistry* registry = ExtensionRegistry::Get(browser_context());
   const ExtensionSet& extensions = registry->enabled_extensions();
   const ExtensionSet& disabled_extensions = registry->disabled_extensions();
   ExtensionActionManager* extension_action_manager =
-      ExtensionActionManager::Get(GetProfile());
+      ExtensionActionManager::Get(browser_context());
 
   base::ListValue* extensions_values = new base::ListValue;
   ExtensionList all;
   all.insert(all.end(), extensions.begin(), extensions.end());
   all.insert(all.end(), disabled_extensions.begin(), disabled_extensions.end());
   for (ExtensionList::const_iterator it = all.begin();
        it != all.end(); ++it) {
     const Extension* extension = it->get();
     std::string id = extension->id();
     std::unique_ptr<base::DictionaryValue> extension_value(
@@ skipping 16 matching lines @@
 
     Manifest::Location location = extension->location();
     extension_value->SetBoolean("isComponent",
                                 location == Manifest::COMPONENT);
     extension_value->SetBoolean("isInternal",
                                 location == Manifest::INTERNAL);
     extension_value->SetBoolean("isUserInstalled",
         location == Manifest::INTERNAL ||
         Manifest::IsUnpackedLocation(location));
     extension_value->SetBoolean("isEnabled", service->IsExtensionEnabled(id));
-    extension_value->SetBoolean("allowedInIncognito",
-        util::IsIncognitoEnabled(id, GetProfile()));
+    extension_value->SetBoolean(
+        "allowedInIncognito", util::IsIncognitoEnabled(id, browser_context()));
     extension_value->SetBoolean(
         "hasPageAction",
         extension_action_manager->GetPageAction(*extension) != NULL);
 
     extensions_values->Append(std::move(extension_value));
   }
 
   std::unique_ptr<base::DictionaryValue> return_value(
       new base::DictionaryValue);
   return_value->Set("extensions", extensions_values);
-  SetResult(std::move(return_value));
-  return true;
+  return RespondNow(OneArgument(std::move(return_value)));
 }
 
 static int AccessArray(const volatile int arr[], const volatile int *index) {
   return arr[*index];
 }
 
-bool AutotestPrivateSimulateAsanMemoryBugFunction::RunSync() {
+ExtensionFunction::ResponseAction
+AutotestPrivateSimulateAsanMemoryBugFunction::Run() {
   DVLOG(1) << "AutotestPrivateSimulateAsanMemoryBugFunction";
-  if (!IsTestMode(GetProfile())) {
+  if (!IsTestMode(browser_context())) {
     // This array is volatile not to let compiler optimize us out.
     volatile int testarray[3] = {0, 0, 0};
 
     // Cause Address Sanitizer to abort this process.
     volatile int index = 5;
     AccessArray(testarray, &index);
   }
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool AutotestPrivateSetTouchpadSensitivityFunction::RunSync() {
+ExtensionFunction::ResponseAction
+AutotestPrivateSetTouchpadSensitivityFunction::Run() {
   std::unique_ptr<api::autotest_private::SetTouchpadSensitivity::Params> params(
       api::autotest_private::SetTouchpadSensitivity::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   DVLOG(1) << "AutotestPrivateSetTouchpadSensitivityFunction " << params->value;
 
 #if defined(OS_CHROMEOS)
   chromeos::system::InputDeviceSettings::Get()->SetTouchpadSensitivity(
       params->value);
 #endif
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool AutotestPrivateSetTapToClickFunction::RunSync() {
+ExtensionFunction::ResponseAction AutotestPrivateSetTapToClickFunction::Run() {
   std::unique_ptr<api::autotest_private::SetTapToClick::Params> params(
       api::autotest_private::SetTapToClick::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   DVLOG(1) << "AutotestPrivateSetTapToClickFunction " << params->enabled;
 
 #if defined(OS_CHROMEOS)
   chromeos::system::InputDeviceSettings::Get()->SetTapToClick(params->enabled);
 #endif
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool AutotestPrivateSetThreeFingerClickFunction::RunSync() {
+ExtensionFunction::ResponseAction
+AutotestPrivateSetThreeFingerClickFunction::Run() {
   std::unique_ptr<api::autotest_private::SetThreeFingerClick::Params> params(
       api::autotest_private::SetThreeFingerClick::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   DVLOG(1) << "AutotestPrivateSetThreeFingerClickFunction " << params->enabled;
 
 #if defined(OS_CHROMEOS)
   chromeos::system::InputDeviceSettings::Get()->SetThreeFingerClick(
       params->enabled);
 #endif
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool AutotestPrivateSetTapDraggingFunction::RunSync() {
+ExtensionFunction::ResponseAction AutotestPrivateSetTapDraggingFunction::Run() {
   std::unique_ptr<api::autotest_private::SetTapDragging::Params> params(
       api::autotest_private::SetTapDragging::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   DVLOG(1) << "AutotestPrivateSetTapDraggingFunction " << params->enabled;
 
 #if defined(OS_CHROMEOS)
   chromeos::system::InputDeviceSettings::Get()->SetTapDragging(params->enabled);
 #endif
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool AutotestPrivateSetNaturalScrollFunction::RunSync() {
+ExtensionFunction::ResponseAction
+AutotestPrivateSetNaturalScrollFunction::Run() {
   std::unique_ptr<api::autotest_private::SetNaturalScroll::Params> params(
       api::autotest_private::SetNaturalScroll::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   DVLOG(1) << "AutotestPrivateSetNaturalScrollFunction " << params->enabled;
 
 #if defined(OS_CHROMEOS)
   chromeos::system::InputDeviceSettings::Get()->SetNaturalScroll(
       params->enabled);
 #endif
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool AutotestPrivateSetMouseSensitivityFunction::RunSync() {
+ExtensionFunction::ResponseAction
+AutotestPrivateSetMouseSensitivityFunction::Run() {
   std::unique_ptr<api::autotest_private::SetMouseSensitivity::Params> params(
       api::autotest_private::SetMouseSensitivity::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   DVLOG(1) << "AutotestPrivateSetMouseSensitivityFunction " << params->value;
 
 #if defined(OS_CHROMEOS)
   chromeos::system::InputDeviceSettings::Get()->SetMouseSensitivity(
       params->value);
 #endif
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool AutotestPrivateSetPrimaryButtonRightFunction::RunSync() {
+ExtensionFunction::ResponseAction
+AutotestPrivateSetPrimaryButtonRightFunction::Run() {
   std::unique_ptr<api::autotest_private::SetPrimaryButtonRight::Params> params(
       api::autotest_private::SetPrimaryButtonRight::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   DVLOG(1) << "AutotestPrivateSetPrimaryButtonRightFunction " << params->right;
 
 #if defined(OS_CHROMEOS)
   chromeos::system::InputDeviceSettings::Get()->SetPrimaryButtonRight(
       params->right);
 #endif
-  return true;
+  return RespondNow(NoArguments());
 }
 
 // static
 std::string AutotestPrivateGetVisibleNotificationsFunction::ConvertToString(
     message_center::NotificationType type) {
 #if defined(OS_CHROMEOS)
   switch (type) {
     case message_center::NOTIFICATION_TYPE_SIMPLE:
       return "simple";
     case message_center::NOTIFICATION_TYPE_BASE_FORMAT:
       return "base_format";
     case message_center::NOTIFICATION_TYPE_IMAGE:
       return "image";
     case message_center::NOTIFICATION_TYPE_MULTIPLE:
       return "multiple";
     case message_center::NOTIFICATION_TYPE_PROGRESS:
       return "progress";
     case message_center::NOTIFICATION_TYPE_CUSTOM:
       return "custom";
   }
 #endif
   return "unknown";
 }
 
-bool AutotestPrivateGetVisibleNotificationsFunction::RunSync() {
+ExtensionFunction::ResponseAction
+AutotestPrivateGetVisibleNotificationsFunction::Run() {
   DVLOG(1) << "AutotestPrivateGetVisibleNotificationsFunction";
   std::unique_ptr<base::ListValue> values(new base::ListValue);
 #if defined(OS_CHROMEOS)
   for (auto* notification :
        message_center::MessageCenter::Get()->GetVisibleNotifications()) {
     base::DictionaryValue* result(new base::DictionaryValue);
     result->SetString("id", notification->id());
     result->SetString("type", ConvertToString(notification->type()));
     result->SetString("title", notification->title());
     result->SetString("message", notification->message());
     result->SetInteger("priority", notification->priority());
     result->SetInteger("progress", notification->progress());
     values->Append(result);
   }
 
 #endif
-  SetResult(std::move(values));
-  return true;
+  return RespondNow(OneArgument(std::move(values)));
 }
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<AutotestPrivateAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<AutotestPrivateAPI>*
 AutotestPrivateAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 template <>
 KeyedService*
 BrowserContextKeyedAPIFactory<AutotestPrivateAPI>::BuildServiceInstanceFor(
     content::BrowserContext* context) const {
   return new AutotestPrivateAPI();
 }
 
 AutotestPrivateAPI::AutotestPrivateAPI() : test_mode_(false) {
 }
 
 AutotestPrivateAPI::~AutotestPrivateAPI() {
 }
 
 }  // namespace extensions