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());

[tommi (sloooow) - chröme, 2013/03/07 13:04:46]

nit: if you can assume that |out_voices| is always empty when the function is
called (and maybe it might be worth DCHECK()ing that), then you can call
out_voices->resize(tts_voices->size()) prior to the loop and then at(i) for both
tts_voices and out_voices and remove push_back().

[dmazzoni, 2013/03/19 17:30:22]

Actually we can't assume that - there are also platform voices, we might be
appending onto the end.

Since this vector is so tiny, ok to leave it like this? I do wish there was a
one-liner to add to the end of the vector and get a pointer or reference...

[tommi (sloooow) - chröme, 2013/03/21 14:34:02]

OK as is

+      VoiceData* result_voice = &out_voices->back();

[hans, 2013/03/09 14:19:52]

i would have made result_voice a reference instead, but I don't think it matters
much

[dmazzoni, 2013/03/19 17:30:22]

Done.

+
+      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 =

[tommi (sloooow) - chröme, 2013/03/07 13:04:46]

std::copy now that both variables are stl?

[dmazzoni, 2013/03/19 17:30:22]

I tried this and it crashes - any idea what I'm doing wrong?

std::copy(voice.event_types.begin(),
          voice.event_types.end(),
          result_voice.events.begin());

[tommi (sloooow) - chröme, 2013/03/21 14:34:02]

hmm... maybe you need to do something like:

result_voice->events.reserve(voice.event_types.size() +
                             result_voice->events.size());
std::copy(voice.event_types.begin(), voice.event_types.end(),
          std::back_inserter(result_voice->events.begin()));

Anyway, it's a total nit and getting into stl trivia territory so if it gives
you problems, just leave as is.

                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 201 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;
 }