[Extensions] Convert some SyncExtensionFunctions

chrome/browser/speech/extension_api/tts_engine_extension_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/speech/extension_api/tts_engine_extension_api.h"
 
 #include <stddef.h>
 #include <string>
 #include <utility>
 
@@ skipping 245 matching lines @@
       extensions::ExtensionSystem::Get(profile)->extension_service();
   DCHECK(extension_service);
   extension_service->component_loader()
       ->AddChromeOsSpeechSynthesisExtension();
   return true;
 #else
   return false;
 #endif
 }
 
-bool ExtensionTtsEngineSendTtsEventFunction::RunSync() {
-  int utterance_id;
+ExtensionFunction::ResponseAction
+ExtensionTtsEngineSendTtsEventFunction::Run() {
+  int utterance_id = 0;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &utterance_id));
 
-  base::DictionaryValue* event;
+  base::DictionaryValue* event = nullptr;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &event));
 
   std::string event_type;
   EXTENSION_FUNCTION_VALIDATE(
       event->GetString(constants::kEventTypeKey, &event_type));
 
   int char_index = 0;
   if (event->HasKey(constants::kCharIndexKey)) {
     EXTENSION_FUNCTION_VALIDATE(
         event->GetInteger(constants::kCharIndexKey, &char_index));
   }
 
   // Make sure the extension has included this event type in its manifest.
   bool event_type_allowed = false;
   const std::vector<extensions::TtsVoice>* tts_voices =
       extensions::TtsVoice::GetTtsVoices(extension());
-  if (!tts_voices) {
-    error_ = constants::kErrorUndeclaredEventType;
-    return false;
-  }
+  if (!tts_voices)
+    return RespondNow(Error(constants::kErrorUndeclaredEventType));
 
   for (size_t i = 0; i < tts_voices->size(); i++) {
     const extensions::TtsVoice& voice = tts_voices->at(i);
     if (voice.event_types.find(event_type) != voice.event_types.end()) {
       event_type_allowed = true;
       break;
     }
   }
-  if (!event_type_allowed) {
-    error_ = constants::kErrorUndeclaredEventType;
-    return false;
-  }
+  if (!event_type_allowed)
+    return RespondNow(Error(constants::kErrorUndeclaredEventType));
 
   TtsController* controller = TtsController::GetInstance();
   if (event_type == constants::kEventTypeStart) {
     controller->OnTtsEvent(
         utterance_id, TTS_EVENT_START, char_index, std::string());
   } else if (event_type == constants::kEventTypeEnd) {
     controller->OnTtsEvent(
         utterance_id, TTS_EVENT_END, char_index, std::string());
   } else if (event_type == constants::kEventTypeWord) {
     controller->OnTtsEvent(
@@ skipping 12 matching lines @@
   } else if (event_type == constants::kEventTypePause) {
     controller->OnTtsEvent(
         utterance_id, TTS_EVENT_PAUSE, char_index, std::string());
   } else if (event_type == constants::kEventTypeResume) {
     controller->OnTtsEvent(
         utterance_id, TTS_EVENT_RESUME, char_index, std::string());
   } else {
     EXTENSION_FUNCTION_VALIDATE(false);
   }
 
-  return true;
+  return RespondNow(NoArguments());
 }