Add Pause and Resume to Web TTS & Extension TTS APIs

chrome/browser/speech/tts_win.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 <math.h>
 #include <sapi.h>
 
 #include "base/memory/singleton.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
@@ skipping 10 matching lines @@
 
   virtual bool Speak(
       int utterance_id,
       const std::string& utterance,
       const std::string& lang,
       const VoiceData& voice,
       const UtteranceContinuousParameters& params);
 
   virtual bool StopSpeaking();
 
+  virtual void Pause();
+
+  virtual void Resume();
+
   virtual bool IsSpeaking();
 
   virtual void GetVoices(std::vector<VoiceData>* out_voices) OVERRIDE;
 
   // Get the single instance of this class.
   static TtsPlatformImplWin* GetInstance();
 
   static void __stdcall SpeechEventCallback(WPARAM w_param, LPARAM l_param);
 
  private:
   TtsPlatformImplWin();
   virtual ~TtsPlatformImplWin() {}
 
   void OnSpeechEvent();
 
   base::win::ScopedComPtr<ISpVoice> speech_synthesizer_;
 
   // These apply to the current utterance only.
   std::wstring utterance_;
   int utterance_id_;
   int prefix_len_;
   ULONG stream_number_;
   int char_position_;
+  bool paused_;
 
   friend struct DefaultSingletonTraits<TtsPlatformImplWin>;
 
   DISALLOW_COPY_AND_ASSIGN(TtsPlatformImplWin);
 };
 
 // static
 TtsPlatformImpl* TtsPlatformImpl::GetInstance() {
   return TtsPlatformImplWin::GetInstance();
 }
@@ skipping 54 matching lines @@
 bool TtsPlatformImplWin::StopSpeaking() {
   if (speech_synthesizer_.get()) {
     // Clear the stream number so that any further events relating to this
     // utterance are ignored.
     stream_number_ = 0;
 
     if (IsSpeaking()) {
       // Stop speech by speaking the empty string with the purge flag.
       speech_synthesizer_->Speak(L"", SPF_ASYNC | SPF_PURGEBEFORESPEAK, NULL);
     }
+    if (paused_) {
+      speech_synthesizer_->Resume();
+      paused_ = false;
+    }
   }
   return true;
 }
 
+void TtsPlatformImplWin::Pause() {
+  if (speech_synthesizer_.get() && utterance_id_ && !paused_) {
+    speech_synthesizer_->Pause();
+    paused_ = true;
+    TtsController::GetInstance()->OnTtsEvent(
+        utterance_id_, TTS_EVENT_PAUSE, char_position_, "");
+  }
+}
+
+void TtsPlatformImplWin::Resume() {
+  if (speech_synthesizer_.get() && utterance_id_ && paused_) {
+    speech_synthesizer_->Resume();
+    paused_ = false;
+    TtsController::GetInstance()->OnTtsEvent(
+        utterance_id_, TTS_EVENT_RESUME, char_position_, "");
+  }
+}
+
 bool TtsPlatformImplWin::IsSpeaking() {
   if (speech_synthesizer_.get()) {
     SPVOICESTATUS status;
     HRESULT result = speech_synthesizer_->GetStatus(&status, NULL);
     if (result == S_OK) {
       if (status.dwRunningState == 0 ||  // 0 == waiting to speak
           status.dwRunningState == SPRS_IS_SPEAKING) {
         return true;
       }
     }
   }
   return false;
 }
 
 void TtsPlatformImplWin::GetVoices(
     std::vector<VoiceData>* out_voices) {
   // TODO: get all voices, not just default voice.
   // http://crbug.com/88059
   out_voices->push_back(VoiceData());
   VoiceData& voice = out_voices->back();
   voice.native = true;
   voice.name = "native";
   voice.events.insert(TTS_EVENT_START);
   voice.events.insert(TTS_EVENT_END);
   voice.events.insert(TTS_EVENT_MARKER);
   voice.events.insert(TTS_EVENT_WORD);
   voice.events.insert(TTS_EVENT_SENTENCE);
+  voice.events.insert(TTS_EVENT_PAUSE);
+  voice.events.insert(TTS_EVENT_RESUME);
 }
 
 void TtsPlatformImplWin::OnSpeechEvent() {
   TtsController* controller = TtsController::GetInstance();
   SPEVENT event;
   while (S_OK == speech_synthesizer_->GetEvents(1, &event, NULL)) {
     if (event.ulStreamNum != stream_number_)
       continue;
 
     switch (event.eEventId) {
@@ skipping 23 matching lines @@
           std::string());
       break;
     }
   }
 }
 
 TtsPlatformImplWin::TtsPlatformImplWin()
   : utterance_id_(0),
     prefix_len_(0),
     stream_number_(0),
-    char_position_(0) {
+    char_position_(0),
+    paused_(false) {
   speech_synthesizer_.CreateInstance(CLSID_SpVoice);
   if (speech_synthesizer_.get()) {
     ULONGLONG event_mask =
         SPFEI(SPEI_START_INPUT_STREAM) |
         SPFEI(SPEI_TTS_BOOKMARK) |
         SPFEI(SPEI_WORD_BOUNDARY) |
         SPFEI(SPEI_SENTENCE_BOUNDARY) |
         SPFEI(SPEI_END_INPUT_STREAM);
     speech_synthesizer_->SetInterest(event_mask, event_mask);
     speech_synthesizer_->SetNotifyCallbackFunction(
         TtsPlatformImplWin::SpeechEventCallback, 0, 0);
   }
 }
 
 // static
 TtsPlatformImplWin* TtsPlatformImplWin::GetInstance() {
   return Singleton<TtsPlatformImplWin,
                    LeakySingletonTraits<TtsPlatformImplWin> >::get();
 }
 
 // static
 void TtsPlatformImplWin::SpeechEventCallback(
     WPARAM w_param, LPARAM l_param) {
   GetInstance()->OnSpeechEvent();
 }