Implement web speech synthesis.

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"
+#include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_function_registry.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/speech/extension_api/tts_engine_extension_api.h"
 #include "chrome/browser/speech/extension_api/tts_extension_api_constants.h"
 #include "chrome/browser/speech/tts_controller.h"
 #include "chrome/common/extensions/api/speech/tts_engine_manifest_handler.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace constants = tts_extension_api_constants;
 
+namespace events {
+const char kOnEvent[] = "tts.onEvent";
+};  // namespace events
+
+namespace {
+
+const char *TtsEventTypeToString(TtsEventType event_type) {
+  switch (event_type) {
+  case TTS_EVENT_START:
+    return constants::kEventTypeStart;
+  case TTS_EVENT_END:
+    return constants::kEventTypeEnd;
+  case TTS_EVENT_WORD:
+    return constants::kEventTypeWord;
+  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;
+  default:
+    NOTREACHED();
+    return "";
+  }
+}
+
+}  // anonymous namespace
+
 namespace extensions {
 
+// One of these is constructed for each utterance, and deleted
+// when the utterance gets any final event.
+class TtsExtensionEventHandler : public UtteranceEventDelegate {
+ public:
+  virtual void OnTtsEvent(Utterance* utterance,
+                          TtsEventType event_type,
+                          int char_index,
+                          const std::string& error_message) OVERRIDE;
+};
+
+void TtsExtensionEventHandler::OnTtsEvent(Utterance* utterance,
+                                          TtsEventType event_type,
+                                          int char_index,
+                                          const std::string& error_message) {
+  if (utterance->src_id() < 0)
+    return;
+
+  std::string event_type_string = TtsEventTypeToString(event_type);
+  const std::set<std::string>& desired_event_types =
+      utterance->desired_event_types();
+  if (desired_event_types.size() > 0 &&
+      desired_event_types.find(event_type_string) ==
+      desired_event_types.end()) {
+    return;
+  }
+
+  scoped_ptr<DictionaryValue> details(new DictionaryValue());
+  if (char_index >= 0)
+    details->SetInteger(constants::kCharIndexKey, char_index);
+  details->SetString(constants::kEventTypeKey, event_type_string);
+  if (event_type == TTS_EVENT_ERROR) {
+    details->SetString(constants::kErrorMessageKey, error_message);
+  }
+  details->SetInteger(constants::kSrcIdKey, utterance->src_id());
+  details->SetBoolean(constants::kIsFinalEventKey, utterance->finished());
+
+  scoped_ptr<ListValue> arguments(new ListValue());
+  arguments->Set(0, details.release());
+
+  scoped_ptr<extensions::Event> event(
+      new extensions::Event(events::kOnEvent, arguments.Pass()));
+  event->restrict_to_profile = utterance->profile();
+  event->event_url = utterance->src_url();
+  extensions::ExtensionSystem::Get(utterance->profile())->event_router()->
+      DispatchEventToExtension(utterance->src_extension_id(), event.Pass());
+
+  if (utterance->finished())
+    delete this;
+}
+
+
 bool TtsSpeakFunction::RunImpl() {
   std::string text;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &text));
   if (text.size() > 32768) {
     error_ = constants::kErrorUtteranceTooLong;
     return false;
   }
 
   scoped_ptr<DictionaryValue> options(new DictionaryValue());
   if (args_->GetSize() >= 2) {
@@ skipping 61 matching lines @@
   if (options->HasKey(constants::kEnqueueKey)) {
     EXTENSION_FUNCTION_VALIDATE(
         options->GetBoolean(constants::kEnqueueKey, &can_enqueue));
   }
 
   std::set<std::string> required_event_types;
   if (options->HasKey(constants::kRequiredEventTypesKey)) {
     ListValue* list;
     EXTENSION_FUNCTION_VALIDATE(
         options->GetList(constants::kRequiredEventTypesKey, &list));
-    for (size_t i = 0; i < list->GetSize(); i++) {
+    for (size_t i = 0; i < list->GetSize(); ++i) {
       std::string event_type;
       if (!list->GetString(i, &event_type))
         required_event_types.insert(event_type);
     }
   }
 
   std::set<std::string> desired_event_types;
   if (options->HasKey(constants::kDesiredEventTypesKey)) {
     ListValue* list;
     EXTENSION_FUNCTION_VALIDATE(
         options->GetList(constants::kDesiredEventTypesKey, &list));
-    for (size_t i = 0; i < list->GetSize(); i++) {
+    for (size_t i = 0; i < list->GetSize(); ++i) {
       std::string event_type;
       if (!list->GetString(i, &event_type))
         desired_event_types.insert(event_type);
     }
   }
 
   std::string voice_extension_id;
   if (options->HasKey(constants::kExtensionIdKey)) {
     EXTENSION_FUNCTION_VALIDATE(
         options->GetString(constants::kExtensionIdKey, &voice_extension_id));
@@ skipping 23 matching lines @@
   utterance->set_src_id(src_id);
   utterance->set_src_url(source_url());
   utterance->set_lang(lang);
   utterance->set_gender(gender);
   utterance->set_continuous_parameters(continuous_params);
   utterance->set_can_enqueue(can_enqueue);
   utterance->set_required_event_types(required_event_types);
   utterance->set_desired_event_types(desired_event_types);
   utterance->set_extension_id(voice_extension_id);
   utterance->set_options(options.get());
+  utterance->set_event_delegate(new TtsExtensionEventHandler());
 
   TtsController* controller = TtsController::GetInstance();
   controller->SpeakOrEnqueue(utterance);
   return true;
 }
 
 bool TtsStopSpeakingFunction::RunImpl() {
   TtsController::GetInstance()->Stop();
   return true;
 }
 
 bool TtsIsSpeakingFunction::RunImpl() {
   SetResult(Value::CreateBooleanValue(
       TtsController::GetInstance()->IsSpeaking()));
   return true;
 }
 
 bool TtsGetVoicesFunction::RunImpl() {
-  SetResult(TtsController::GetInstance()->GetVoices(profile()));
+  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.empty())
+      result_voice->SetString(constants::kGenderKey, voice.gender);
+    if (!voice.extension_id.empty())
+      result_voice->SetString(constants::kExtensionIdKey, voice.extension_id);
+
+    ListValue* event_types = new ListValue();
+    for (size_t j = 0; j < voice.events.size(); ++j)
+      event_types->Append(Value::CreateStringValue(voice.events[j]));
+    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) {
   (new TtsEngineManifestHandler)->Register();
@@ skipping 10 matching lines @@
 }
 
 static base::LazyInstance<ProfileKeyedAPIFactory<TtsAPI> >
 g_factory = LAZY_INSTANCE_INITIALIZER;
 
 ProfileKeyedAPIFactory<TtsAPI>* TtsAPI::GetFactoryInstance() {
   return &g_factory.Get();
 }
 
 }  // namespace extensions