[Extensions] Convert some SyncExtensionFunctions

extensions/browser/api/management/management_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 "extensions/browser/api/management/management_api.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 250 matching lines @@
 
     if (extension.ShouldNotBeVisible())
       continue;  // Skip built-in extensions/apps.
 
     extension_list->push_back(CreateExtensionInfo(extension, context));
   }
 }
 
 }  // namespace
 
-bool ManagementGetAllFunction::RunSync() {
+ExtensionFunction::ResponseAction ManagementGetAllFunction::Run() {
   ExtensionInfoList extensions;
   ExtensionRegistry* registry = ExtensionRegistry::Get(browser_context());
 
   AddExtensionInfo(registry->enabled_extensions(), &extensions,
                    browser_context());
   AddExtensionInfo(registry->disabled_extensions(), &extensions,
                    browser_context());
   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());
   ExtensionRegistry* registry = ExtensionRegistry::Get(browser_context());
 
   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());
 
   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() {
   std::unique_ptr<management::GetPermissionWarningsByManifest::Params> params(
       management::GetPermissionWarningsByManifest::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   const ManagementAPIDelegate* delegate = ManagementAPI::GetFactoryInstance()
                                               ->Get(browser_context())
                                               ->GetDelegate();
@@ skipping 42 matching lines @@
 
 void ManagementGetPermissionWarningsByManifestFunction::OnParseFailure(
     const std::string& error) {
   error_ = error;
   SendResponse(false);
 
   // Matched with AddRef() in RunAsync().
   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() {
 }
 
 ManagementSetEnabledFunction::~ManagementSetEnabledFunction() {
 }
 
 ExtensionFunction::ResponseAction ManagementSetEnabledFunction::Run() {
   std::unique_ptr<management::SetEnabled::Params> params(
@@ skipping 274 matching lines @@
           ->GetDelegate()
           ->CreateAppShortcutFunctionDelegate(this, extension)) {
     // Matched with a Release() in OnCloseShortcutPrompt().
     AddRef();
   }
 
   // Response is sent async in OnCloseShortcutPrompt().
   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_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   const Extension* extension =
       ExtensionRegistry::Get(browser_context())
           ->GetExtensionById(params->id, ExtensionRegistry::EVERYTHING);
   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);
 
   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;
   switch (app_launch_type) {
     case management::LAUNCH_TYPE_OPEN_AS_PINNED_TAB:
       launch_type = LAUNCH_TYPE_PINNED;
       break;
     case management::LAUNCH_TYPE_OPEN_AS_REGULAR_TAB:
       launch_type = LAUNCH_TYPE_REGULAR;
       break;
     case management::LAUNCH_TYPE_OPEN_FULL_SCREEN:
       launch_type = LAUNCH_TYPE_FULLSCREEN;
       break;
     case management::LAUNCH_TYPE_OPEN_AS_WINDOW:
       launch_type = LAUNCH_TYPE_WINDOW;
       break;
     case management::LAUNCH_TYPE_NONE:
       NOTREACHED();
   }
 
   delegate->SetLaunchType(browser_context(), params->id, launch_type);
 
-  return true;
+  return RespondNow(NoArguments());
 }
 
 ManagementGenerateAppForLinkFunction::ManagementGenerateAppForLinkFunction() {
 }
 
 ManagementGenerateAppForLinkFunction::~ManagementGenerateAppForLinkFunction() {
 }
 
 void ManagementGenerateAppForLinkFunction::FinishCreateBookmarkApp(
     const Extension* extension,
@@ skipping 129 matching lines @@
 ManagementAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 void ManagementAPI::OnListenerAdded(const EventListenerInfo& details) {
   management_event_router_.reset(new ManagementEventRouter(browser_context_));
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
 }  // namespace extensions