Eliminate the dependence of tts extension API form tts_controller.cc

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>
@@ skipping 59 matching lines @@
   // If true, the synthesis engine is a remote network resource.
   // It may be higher latency and may incur bandwidth costs.
   bool remote;
 
   // If true, this is implemented by this platform's subclass of
   // TtsPlatformImpl. If false, this is implemented by an extension.
   bool native;
   std::string native_voice_identifier;
 };
 
+// Interface that delegates TTS requests to user-installed extensions.
+class TtsEngineDelegate {
+ public:
+  virtual ~TtsEngineDelegate() {}
+
+  // Return a list of all available voices registered.
+  virtual void GetVoices(Profile* profile,
+                         std::vector<VoiceData>* out_voices) = 0;
+
+  // Speak the given utterance by sending an event to the given TTS engine.
+  virtual void Speak(Utterance* utterance, const VoiceData& voice) = 0;
+
+  // Stop speaking the given utterance by sending an event to the target
+  // associated with this utterance.
+  virtual void Stop(Utterance* utterance) = 0;
+
+  // Pause in the middle of speaking this utterance.
+  virtual void Pause(Utterance* utterance) = 0;
+
+  // Resume speaking this utterance.
+  virtual void Resume(Utterance* utterance) = 0;
+};
+
 // 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;
 };
 
@@ skipping 200 matching lines @@
   // Called by the extension system or platform implementation when the
   // list of voices may have changed and should be re-queried.
   void VoicesChanged();
 
   // Add a delegate that wants to be notified when the set of voices changes.
   void AddVoicesChangedDelegate(VoicesChangedDelegate* delegate);
 
   // Remove delegate that wants to be notified when the set of voices changes.
   void RemoveVoicesChangedDelegate(VoicesChangedDelegate* delegate);
 
+  // Set the delegate that processes TTS requests with user-installed
+  // extensions.
+  void SetTtsEngineDelegate(TtsEngineDelegate* delegate);
+
   // For unit testing.
   void SetPlatformImpl(TtsPlatformImpl* platform_impl);
   int QueueSize();
 
  protected:
   TtsController();
   virtual ~TtsController();
 
  private:
   // Get the platform TTS implementation (or injected mock).
@@ skipping 29 matching lines @@
   // A queue of utterances to speak after the current one finishes.
   std::queue<Utterance*> utterance_queue_;
 
   // A set of delegates that want to be notified when the voices change.
   std::set<VoicesChangedDelegate*> voices_changed_delegates_;
 
   // A pointer to the platform implementation of text-to-speech, for
   // dependency injection.
   TtsPlatformImpl* platform_impl_;
 
+  // The delegate that processes TTS requests with user-installed extensions.
+  TtsEngineDelegate* tts_engine_delegate_;
+
   DISALLOW_COPY_AND_ASSIGN(TtsController);
 };
 
 #endif  // CHROME_BROWSER_SPEECH_TTS_CONTROLLER_H_