Implement web speech synthesis.

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 <string>
 
 #include "base/json/json_writer.h"
 #include "base/values.h"
@@ skipping 19 matching lines @@
 // Given a language/region code of the form 'fr-FR', returns just the basic
 // language portion, e.g. 'fr'.
 std::string TrimLanguageCode(std::string lang) {
   if (lang.size() >= 5 && lang[2] == '-')
     return lang.substr(0, 2);
   else
     return lang;
 }
 }
 
-void GetExtensionVoices(Profile* profile, ListValue* result_voices) {
+void GetExtensionVoices(Profile* profile, std::vector<VoiceData>* out_voices) {
   ExtensionService* service = profile->GetExtensionService();
   DCHECK(service);
   extensions::EventRouter* event_router =
       extensions::ExtensionSystem::Get(profile)->event_router();
   DCHECK(event_router);
 
   const ExtensionSet* extensions = service->extensions();
   ExtensionSet::const_iterator iter;
   for (iter = extensions->begin(); iter != extensions->end(); ++iter) {
     const Extension* extension = *iter;
 
     if (!event_router->ExtensionHasEventListener(
             extension->id(), tts_engine_events::kOnSpeak) ||
         !event_router->ExtensionHasEventListener(
             extension->id(), tts_engine_events::kOnStop)) {
       continue;
     }
 
     const std::vector<extensions::TtsVoice>* tts_voices =
         extensions::TtsVoice::GetTtsVoices(extension);
     if (!tts_voices)
       continue;
 
     for (size_t i = 0; i < tts_voices->size(); ++i) {
       const extensions::TtsVoice& voice = tts_voices->at(i);
-      DictionaryValue* result_voice = new DictionaryValue();
-      if (!voice.voice_name.empty())
-        result_voice->SetString(constants::kVoiceNameKey, voice.voice_name);
-      if (!voice.lang.empty())
-        result_voice->SetString(constants::kLangKey, voice.lang);
-      if (!voice.gender.empty())
-        result_voice->SetString(constants::kGenderKey, voice.gender);
-      result_voice->SetString(constants::kExtensionIdKey, extension->id());
 
-      ListValue* event_types = new ListValue();
+      out_voices->push_back(VoiceData());
+      VoiceData& result_voice = out_voices->back();
+
+      result_voice.name = voice.voice_name;
+      result_voice.lang = voice.lang;
+      result_voice.gender = voice.gender;
+      result_voice.extension_id = extension->id();
+
       for (std::set<std::string>::const_iterator iter =
                voice.event_types.begin();
            iter != voice.event_types.end();
            ++iter) {
-        event_types->Append(Value::CreateStringValue(*iter));
+        result_voice.events.push_back(*iter);
       }
+
       // If the extension sends end events, the controller will handle
       // queueing and send interrupted and cancelled events.
       if (voice.event_types.find(constants::kEventTypeEnd) !=
           voice.event_types.end()) {
-        event_types->Append(
-            Value::CreateStringValue(constants::kEventTypeCancelled));
-        event_types->Append(Value::CreateStringValue(
-            constants::kEventTypeInterrupted));
+        result_voice.events.push_back(constants::kEventTypeCancelled);
+        result_voice.events.push_back(constants::kEventTypeInterrupted);
       }
-
-      result_voice->Set(constants::kEventTypesKey, event_types);
-      result_voices->Append(result_voice);
     }
   }
 }
 
 bool GetMatchingExtensionVoice(
     Utterance* utterance,
     const Extension** matching_extension,
     size_t* voice_index) {
   // This will only happen during unit testing. Otherwise, an utterance
   // will always have an associated profile.
@@ skipping 100 matching lines @@
     event_types = tts_voices->at(voice_index).event_types;
 
   bool sends_end_event =
       (event_types.find(constants::kEventTypeEnd) != event_types.end());
 
   scoped_ptr<ListValue> args(new ListValue());
   args->Set(0, Value::CreateStringValue(utterance->text()));
 
   // Pass through most options to the speech engine, but remove some
   // that are handled internally.
-  DictionaryValue* options = static_cast<DictionaryValue*>(
-      utterance->options()->DeepCopy());
+  scoped_ptr<DictionaryValue> options(static_cast<DictionaryValue*>(
+      utterance->options()->DeepCopy()));
   if (options->HasKey(constants::kRequiredEventTypesKey))
     options->Remove(constants::kRequiredEventTypesKey, NULL);
   if (options->HasKey(constants::kDesiredEventTypesKey))
     options->Remove(constants::kDesiredEventTypesKey, NULL);
   if (sends_end_event && options->HasKey(constants::kEnqueueKey))
     options->Remove(constants::kEnqueueKey, NULL);
   if (options->HasKey(constants::kSrcIdKey))
     options->Remove(constants::kSrcIdKey, NULL);
   if (options->HasKey(constants::kIsFinalEventKey))
     options->Remove(constants::kIsFinalEventKey, NULL);
   if (options->HasKey(constants::kOnEventKey))
     options->Remove(constants::kOnEventKey, NULL);
 
-  args->Set(1, options);
+  args->Set(1, options.release());
   args->Set(2, Value::CreateIntegerValue(utterance->id()));
 
   scoped_ptr<extensions::Event> event(new extensions::Event(
       tts_engine_events::kOnSpeak, args.Pass()));
   event->restrict_to_profile = utterance->profile();
   extensions::ExtensionSystem::Get(utterance->profile())->event_router()->
       DispatchEventToExtension(utterance->extension_id(), event.Pass());
 }
 
 void ExtensionTtsEngineStop(Utterance* utterance) {
@@ skipping 65 matching lines @@
     std::string error_message;
     event->GetString(constants::kErrorMessageKey, &error_message);
     controller->OnTtsEvent(
         utterance_id, TTS_EVENT_ERROR, char_index, error_message);
   } else {
     EXTENSION_FUNCTION_VALIDATE(false);
   }
 
   return true;
 }