Implement web speech synthesis.

chrome/browser/speech/tts_controller.h

 // 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.
 
 #ifndef CHROME_BROWSER_SPEECH_TTS_CONTROLLER_H_
 #define CHROME_BROWSER_SPEECH_TTS_CONTROLLER_H_
 
 #include <queue>
 #include <set>
 #include <string>
+#include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "googleurl/src/gurl.h"
 
+class Utterance;
 class TtsPlatformImpl;
 class Profile;
 
 namespace base {
-class ListValue;
 class Value;
 }
 
 // Events sent back from the TTS engine indicating the progress.
 enum TtsEventType {
   TTS_EVENT_START,
   TTS_EVENT_END,
   TTS_EVENT_WORD,
   TTS_EVENT_SENTENCE,
   TTS_EVENT_MARKER,
   TTS_EVENT_INTERRUPTED,
   TTS_EVENT_CANCELLED,
   TTS_EVENT_ERROR
 };
 
+// Returns true if this event type is one that indicates an utterance
+// is finished and can be destroyed.
+bool IsFinalTtsEventType(TtsEventType event_type);
 
 // The continuous parameters that apply to a given utterance.
 struct UtteranceContinuousParameters {
   UtteranceContinuousParameters();
 
   double rate;
   double pitch;
   double volume;
 };
 
+// Information about one voice.
+struct VoiceData {
+  VoiceData();
+  ~VoiceData();
+
+  std::string name;
+  std::string lang;
+  std::string gender;
+  std::string extension_id;
+  std::vector<std::string> events;
+};
+
+// Class that wants to receive events on utterances.
+class UtteranceEventDelegate {
+ public:
+  virtual ~UtteranceEventDelegate() {}
+  virtual void OnTtsEvent(Utterance* utterance,
+                          TtsEventType event_type,
+                          int char_index,
+                          const std::string& error_message) = 0;
+};
 
 // One speech utterance.
 class Utterance {
  public:
   // Construct an utterance given a profile and a completion task to call
   // when the utterance is done speaking. Before speaking this utterance,
   // its other parameters like text, rate, pitch, etc. should all be set.
   explicit Utterance(Profile* profile);
   ~Utterance();
 
@@ skipping 62 matching lines @@
   }
   const std::set<std::string>& desired_event_types() const {
     return desired_event_types_;
   }
 
   const std::string& extension_id() const { return extension_id_; }
   void set_extension_id(const std::string& extension_id) {
     extension_id_ = extension_id;
   }
 
+  UtteranceEventDelegate* event_delegate() const { return event_delegate_; }
+  void set_event_delegate(UtteranceEventDelegate* event_delegate) {
+    event_delegate_ = event_delegate;
+  }
+
   // Getters and setters for internal state.
   Profile* profile() const { return profile_; }
   int id() const { return id_; }
   bool finished() const { return finished_; }
 
  private:
   // The profile that initiated this utterance.
   Profile* profile_;
 
   // The extension ID of the extension providing TTS for this utterance, or
@@ skipping 19 matching lines @@
   // receive events.
   std::string src_extension_id_;
 
   // The source extension's ID of this utterance, so that it can associate
   // events with the appropriate callback.
   int src_id_;
 
   // The URL of the page where the source extension called speak.
   GURL src_url_;
 
+  // The delegate to be called when an utterance event is fired.
+  // Weak reference; it will be cleared after we fire a "final" event
+  // (as determined by IsFinalTtsEventType).
+  UtteranceEventDelegate* event_delegate_;
+
   // The parsed options.
   std::string voice_name_;
   std::string lang_;
   std::string gender_;
   UtteranceContinuousParameters continuous_parameters_;
   bool can_enqueue_;
   std::set<std::string> required_event_types_;
   std::set<std::string> desired_event_types_;
 
   // The index of the current char being spoken.
   int char_index_;
 
   // True if this utterance received an event indicating it's done.
   bool finished_;
 };
 
-
 // Singleton class that manages text-to-speech for the TTS and TTS engine
 // extension APIs, maintaining a queue of pending utterances and keeping
 // track of all state.
 class TtsController {
  public:
   // Get the single instance of this class.
   static TtsController* GetInstance();
 
   // Returns true if we're currently speaking an utterance.
   bool IsSpeaking();
@@ skipping 11 matching lines @@
   // the callback function, and in addition, completion and error events
   // trigger finishing the current utterance and starting the next one, if
   // any.
   void OnTtsEvent(int utterance_id,
                   TtsEventType event_type,
                   int char_index,
                   const std::string& error_message);
 
   // Return a list of all available voices, including the native voice,
   // if supported, and all voices registered by extensions.
-  base::ListValue* GetVoices(Profile* profile);
+  void GetVoices(Profile* profile, std::vector<VoiceData>* out_voices);
 
   // Called by TtsExtensionLoaderChromeOs::LoadTtsExtension when it
   // finishes loading the built-in TTS component extension.
   void RetrySpeakingQueuedUtterances();
 
   // For unit testing.
   void SetPlatformImpl(TtsPlatformImpl* platform_impl);
   int QueueSize();
 
  protected:
@@ skipping 27 matching lines @@
   std::queue<Utterance*> utterance_queue_;
 
   // A pointer to the platform implementation of text-to-speech, for
   // dependency injection.
   TtsPlatformImpl* platform_impl_;
 
   DISALLOW_COPY_AND_ASSIGN(TtsController);
 };
 
 #endif  // CHROME_BROWSER_SPEECH_TTS_CONTROLLER_H_