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 <map>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
@@ skipping 20 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 140 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_);
+}
+
+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) {
   if (!all_native_voices_.get()) {
     all_native_voices_.reset(new std::map<std::string, SPDChromeVoice>());
     char** modules = libspeechd_loader_.spd_list_modules(conn_);
     if (!modules)
@@ skipping 29 matching lines @@
        it != all_native_voices_->end();
        it++) {
     out_voices->push_back(VoiceData());
     VoiceData& voice = out_voices->back();
     voice.native = true;
     voice.name = it->first;
     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();
 }