Add Pause and Resume to Web TTS & Extension TTS APIs

chrome/browser/speech/tts_linux.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 "base/memory/singleton.h"
 #include "base/synchronization/lock.h"
 #include "chrome/browser/speech/tts_platform.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 12 matching lines @@
 class TtsPlatformImplLinux : public TtsPlatformImpl {
  public:
   virtual bool PlatformImplAvailable() OVERRIDE;
   virtual bool Speak(
       int utterance_id,
       const std::string& utterance,
       const std::string& lang,
       const VoiceData& voice,
       const UtteranceContinuousParameters& params) OVERRIDE;
   virtual bool StopSpeaking() OVERRIDE;
+  virtual void Pause() OVERRIDE;
+  virtual void Resume() OVERRIDE;
   virtual bool IsSpeaking() OVERRIDE;
   virtual void GetVoices(std::vector<VoiceData>* out_voices) OVERRIDE;
 
   void OnSpeechEvent(SPDNotificationType type);
 
   // Get the single instance of this class.
   static TtsPlatformImplLinux* GetInstance();
 
  private:
   TtsPlatformImplLinux();
@@ skipping 129 matching lines @@
 bool TtsPlatformImplLinux::StopSpeaking() {
   if (!PlatformImplAvailable())
     return false;
   if (libspeechd_loader_.spd_stop(conn_) == -1) {
     Reset();
     return false;
   }
   return true;
 }
 
+void TtsPlatformImplLinux::Pause() {
+  if (!PlatformImplAvailable())
+    return;
+  libspeechd_loader_.spd_pause(conn_);

[David Tseng, 2013/05/13 21:22:48]

Any issues with calling pause (or resume) repeatedly? I noticed you check under
win if we're not already paused before calling pause, but not for linux or mac.

[dmazzoni, 2013/05/14 16:50:27]

The Linux speech dispatcher is the only one that actually fires a pause
and resume event which we can forward directly, so we don't need to
duplicate that logic.

On Mac: we create a new synthesizer for each utterance, so
calling Stop automatically clears the paused state. However, it
could have sent duplicate pause events, so I went ahead and added
a flag.

+}
+
+void TtsPlatformImplLinux::Resume() {
+  if (!PlatformImplAvailable())
+    return;
+  libspeechd_loader_.spd_resume(conn_);
+}
+
 bool TtsPlatformImplLinux::IsSpeaking() {
   return current_notification_ == SPD_EVENT_BEGIN;
 }
 
 void TtsPlatformImplLinux::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_CANCELLED);
   voice.events.insert(TTS_EVENT_MARKER);
+  voice.events.insert(TTS_EVENT_PAUSE);
+  voice.events.insert(TTS_EVENT_RESUME);
 }
 
 void TtsPlatformImplLinux::OnSpeechEvent(SPDNotificationType type) {
   TtsController* controller = TtsController::GetInstance();
   switch (type) {
   case SPD_EVENT_BEGIN:
-  case SPD_EVENT_RESUME:
     controller->OnTtsEvent(utterance_id_, TTS_EVENT_START, 0, std::string());
     break;
+  case SPD_EVENT_RESUME:
+    controller->OnTtsEvent(utterance_id_, TTS_EVENT_RESUME, 0, std::string());
+    break;
   case SPD_EVENT_END:
+    controller->OnTtsEvent(
+        utterance_id_, TTS_EVENT_END, utterance_.size(), std::string());
+    break;
   case SPD_EVENT_PAUSE:
     controller->OnTtsEvent(
-        utterance_id_, TTS_EVENT_END, utterance_.size(), std::string());
+        utterance_id_, TTS_EVENT_PAUSE, utterance_.size(), std::string());
     break;
   case SPD_EVENT_CANCEL:
     controller->OnTtsEvent(
         utterance_id_, TTS_EVENT_CANCELLED, 0, std::string());
     break;
   case SPD_EVENT_INDEX_MARK:
     controller->OnTtsEvent(utterance_id_, TTS_EVENT_MARKER, 0, std::string());
     break;
   }
 }
@@ skipping 36 matching lines @@
 // static
 TtsPlatformImplLinux* TtsPlatformImplLinux::GetInstance() {
   return Singleton<TtsPlatformImplLinux,
                    LeakySingletonTraits<TtsPlatformImplLinux> >::get();
 }
 
 // static
 TtsPlatformImpl* TtsPlatformImpl::GetInstance() {
   return TtsPlatformImplLinux::GetInstance();
 }