Add Pause and Resume to Web TTS & Extension TTS APIs

chrome/browser/speech/extension_api/tts_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_extension_api.h"
 
 #include <string>
 
 #include "base/lazy_instance.h"
 #include "base/values.h"
@@ skipping 22 matching lines @@
     case TTS_EVENT_SENTENCE:
       return constants::kEventTypeSentence;
     case TTS_EVENT_MARKER:
       return constants::kEventTypeMarker;
     case TTS_EVENT_INTERRUPTED:
       return constants::kEventTypeInterrupted;
     case TTS_EVENT_CANCELLED:
       return constants::kEventTypeCancelled;
     case TTS_EVENT_ERROR:
       return constants::kEventTypeError;
+    case TTS_EVENT_PAUSE:
+      return constants::kEventTypePause;
+    case TTS_EVENT_RESUME:
+      return constants::kEventTypeResume;
     default:
       NOTREACHED();
       return constants::kEventTypeError;
   }
 }
 
 TtsEventType TtsEventTypeFromString(const std::string& str) {
   if (str == constants::kEventTypeStart)
     return TTS_EVENT_START;
   if (str == constants::kEventTypeEnd)
     return TTS_EVENT_END;
   if (str == constants::kEventTypeWord)
     return TTS_EVENT_WORD;
   if (str == constants::kEventTypeSentence)
     return TTS_EVENT_SENTENCE;
   if (str == constants::kEventTypeMarker)
     return TTS_EVENT_MARKER;
   if (str == constants::kEventTypeInterrupted)
     return TTS_EVENT_INTERRUPTED;
   if (str == constants::kEventTypeCancelled)
     return TTS_EVENT_CANCELLED;
   if (str == constants::kEventTypeError)
     return TTS_EVENT_ERROR;
+  if (str == constants::kEventTypePause)
+    return TTS_EVENT_PAUSE;
+  if (str == constants::kEventTypeResume)
+    return TTS_EVENT_RESUME;
 
   NOTREACHED();
   return TTS_EVENT_ERROR;
 }
 
 namespace extensions {
 
 // One of these is constructed for each utterance, and deleted
 // when the utterance gets any final event.
 class TtsExtensionEventHandler : public UtteranceEventDelegate {
@@ skipping 191 matching lines @@
   TtsController* controller = TtsController::GetInstance();
   controller->SpeakOrEnqueue(utterance);
   return true;
 }
 
 bool TtsStopSpeakingFunction::RunImpl() {
   TtsController::GetInstance()->Stop();
   return true;
 }
 
+bool TtsPauseFunction::RunImpl() {
+  TtsController::GetInstance()->Pause();
+  return true;
+}
+
+bool TtsResumeFunction::RunImpl() {
+  TtsController::GetInstance()->Resume();
+  return true;
+}
+
 bool TtsIsSpeakingFunction::RunImpl() {
   SetResult(Value::CreateBooleanValue(
       TtsController::GetInstance()->IsSpeaking()));
   return true;
 }
 
 bool TtsGetVoicesFunction::RunImpl() {
   std::vector<VoiceData> voices;
   TtsController::GetInstance()->GetVoices(profile(), &voices);
 
   scoped_ptr<ListValue> result_voices(new ListValue());
   for (size_t i = 0; i < voices.size(); ++i) {
     const VoiceData& voice = voices[i];
     DictionaryValue* result_voice = new DictionaryValue();
     result_voice->SetString(constants::kVoiceNameKey, voice.name);
     if (!voice.lang.empty())
       result_voice->SetString(constants::kLangKey, voice.lang);
     if (voice.gender == TTS_GENDER_MALE)
       result_voice->SetString(constants::kGenderKey, constants::kGenderMale);
     else if (voice.gender == TTS_GENDER_FEMALE)
       result_voice->SetString(constants::kGenderKey, constants::kGenderFemale);
     if (!voice.extension_id.empty())
       result_voice->SetString(constants::kExtensionIdKey, voice.extension_id);
 
     ListValue* event_types = new ListValue();
     for (std::set<TtsEventType>::iterator iter = voice.events.begin();
          iter != voice.events.end(); ++iter) {
-      const char* event_name_constant = NULL;
-      switch (*iter) {
-        case TTS_EVENT_START:
-          event_name_constant = constants::kEventTypeStart;
-          break;
-        case TTS_EVENT_END:
-          event_name_constant = constants::kEventTypeEnd;
-          break;
-        case TTS_EVENT_WORD:
-          event_name_constant = constants::kEventTypeWord;
-          break;
-        case TTS_EVENT_SENTENCE:
-          event_name_constant = constants::kEventTypeSentence;
-          break;
-        case TTS_EVENT_MARKER:
-          event_name_constant = constants::kEventTypeMarker;
-          break;
-        case TTS_EVENT_INTERRUPTED:
-          event_name_constant = constants::kEventTypeInterrupted;
-          break;
-        case TTS_EVENT_CANCELLED:
-          event_name_constant = constants::kEventTypeCancelled;
-          break;
-        case TTS_EVENT_ERROR:
-          event_name_constant = constants::kEventTypeError;
-          break;
-      }
-      if (event_name_constant)
-        event_types->Append(Value::CreateStringValue(event_name_constant));
+      const char* event_name_constant = TtsEventTypeToString(*iter);
+      event_types->Append(Value::CreateStringValue(event_name_constant));
     }
     result_voice->Set(constants::kEventTypesKey, event_types);
 
     result_voices->Append(result_voice);
   }
 
   SetResult(result_voices.release());
   return true;
 }
 
 // static
 TtsAPI* TtsAPI::Get(Profile* profile) {
   return ProfileKeyedAPIFactory<TtsAPI>::GetForProfile(profile);
 }
 
 TtsAPI::TtsAPI(Profile* profile) {
   ExtensionFunctionRegistry* registry =
       ExtensionFunctionRegistry::GetInstance();
   registry->RegisterFunction<ExtensionTtsEngineSendTtsEventFunction>();
   registry->RegisterFunction<TtsGetVoicesFunction>();
   registry->RegisterFunction<TtsIsSpeakingFunction>();
   registry->RegisterFunction<TtsSpeakFunction>();
   registry->RegisterFunction<TtsStopSpeakingFunction>();
+  registry->RegisterFunction<TtsPauseFunction>();
+  registry->RegisterFunction<TtsResumeFunction>();
 }
 
 TtsAPI::~TtsAPI() {
 }
 
 static base::LazyInstance<ProfileKeyedAPIFactory<TtsAPI> >
 g_factory = LAZY_INSTANCE_INITIALIZER;
 
 ProfileKeyedAPIFactory<TtsAPI>* TtsAPI::GetFactoryInstance() {
   return &g_factory.Get();
 }
 
 }  // namespace extensions