Add Pause and Resume to Web TTS & Extension TTS APIs

chrome/browser/speech/tts_controller.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 "chrome/browser/speech/tts_controller.h"
 
 #include <string>
 #include <vector>
 
 #include "base/float_util.h"
@@ skipping 99 matching lines @@
 // TtsController
 //
 
 // static
 TtsController* TtsController::GetInstance() {
   return Singleton<TtsController>::get();
 }
 
 TtsController::TtsController()
     : current_utterance_(NULL),
+      paused_(false),
       platform_impl_(NULL) {
 }
 
 TtsController::~TtsController() {
   if (current_utterance_) {
     current_utterance_->Finish();
     delete current_utterance_;
   }
 
   // Clear any queued utterances too.
   ClearUtteranceQueue(false);  // Don't sent events.
 }
 
 void TtsController::SpeakOrEnqueue(Utterance* utterance) {
-  if (IsSpeaking() && utterance->can_enqueue()) {
+  // If we're paused and we get an utterance that can't be queued,
+  // flush the queue but stay in the paused state.
+  if (paused_ && !utterance->can_enqueue()) {
+    Stop();
+    paused_ = true;
+    return;
+  }
+
+  if (paused_ || (IsSpeaking() && utterance->can_enqueue())) {
     utterance_queue_.push(utterance);
   } else {
     Stop();
     SpeakNow(utterance);
   }
 }
 
 void TtsController::SpeakNow(Utterance* utterance) {
   // Get all available voices and try to find a matching voice.
   std::vector<VoiceData> voices;
@@ skipping 44 matching lines @@
       utterance->OnTtsEvent(TTS_EVENT_ERROR, kInvalidCharIndex,
                             GetPlatformImpl()->error());
       delete utterance;
       return;
     }
     current_utterance_ = utterance;
   }
 }
 
 void TtsController::Stop() {
+  paused_ = false;
   if (current_utterance_ && !current_utterance_->extension_id().empty()) {
     ExtensionTtsEngineStop(current_utterance_);
   } else {
     GetPlatformImpl()->clear_error();
     GetPlatformImpl()->StopSpeaking();
   }
 
   if (current_utterance_)
     current_utterance_->OnTtsEvent(TTS_EVENT_INTERRUPTED, kInvalidCharIndex,
                                    std::string());
   FinishCurrentUtterance();
   ClearUtteranceQueue(true);  // Send events.
 }
 
+void TtsController::Pause() {
+  paused_ = true;
+  if (current_utterance_ && !current_utterance_->extension_id().empty()) {
+    ExtensionTtsEnginePause(current_utterance_);
+  } else if (current_utterance_) {
+    GetPlatformImpl()->clear_error();
+    GetPlatformImpl()->Pause();
+  }
+}
+
+void TtsController::Resume() {
+  paused_ = false;
+  if (current_utterance_ && !current_utterance_->extension_id().empty()) {
+    ExtensionTtsEngineResume(current_utterance_);
+  } else if (current_utterance_) {
+    GetPlatformImpl()->clear_error();
+    GetPlatformImpl()->Resume();
+  } else {
+    SpeakNextUtterance();
+  }
+}
+
 void TtsController::OnTtsEvent(int utterance_id,
                                         TtsEventType event_type,
                                         int char_index,
                                         const std::string& error_message) {
   // We may sometimes receive completion callbacks "late", after we've
   // already finished the utterance (for example because another utterance
   // interrupted or we got a call to Stop). This is normal and we can
   // safely just ignore these events.
   if (!current_utterance_ || utterance_id != current_utterance_->id())
     return;
@@ skipping 23 matching lines @@
   if (current_utterance_) {
     if (!current_utterance_->finished())
       current_utterance_->OnTtsEvent(TTS_EVENT_INTERRUPTED, kInvalidCharIndex,
                                      std::string());
     delete current_utterance_;
     current_utterance_ = NULL;
   }
 }
 
 void TtsController::SpeakNextUtterance() {
+  if (paused_)
+    return;
+
   // Start speaking the next utterance in the queue.  Keep trying in case
   // one fails but there are still more in the queue to try.
   while (!utterance_queue_.empty() && !current_utterance_) {
     Utterance* utterance = utterance_queue_.front();
     utterance_queue_.pop();
     SpeakNow(utterance);
   }
 }
 
 void TtsController::RetrySpeakingQueuedUtterances() {
@@ skipping 80 matching lines @@
           continue;
       }
 
       return static_cast<int>(i);
     }
   }
 
   return -1;
 }