Add Pause and Resume to Web TTS & Extension TTS APIs

chrome/browser/speech/tts_controller.cc

Index: chrome/browser/speech/tts_controller.cc
diff --git a/chrome/browser/speech/tts_controller.cc b/chrome/browser/speech/tts_controller.cc
index d7fb66e1e63bd4c78bd6ff20acc8081211aa6e57..0d1d131574d46b53b921ec675b9253cef29207d5 100644
--- a/chrome/browser/speech/tts_controller.cc
+++ b/chrome/browser/speech/tts_controller.cc
@@ -117,6 +117,7 @@ TtsController* TtsController::GetInstance() {
 
 TtsController::TtsController()
     : current_utterance_(NULL),
+      paused_(false),
       platform_impl_(NULL) {
 }
 
@@ -131,7 +132,7 @@ TtsController::~TtsController() {
 }
 
 void TtsController::SpeakOrEnqueue(Utterance* utterance) {
-  if (IsSpeaking() && utterance->can_enqueue()) {
+  if (paused_ || (IsSpeaking() && utterance->can_enqueue())) {

[David Tseng, 2013/05/13 17:49:54]

I don't remember why isSpeaking is needed here. It seems wrong now that I think
about it since a speak call can occur in-between queued up calls to native
speak(). What do you think?

[dmazzoni, 2013/05/13 19:34:38]

Are you thinking about the change we made on Mac where IsSpeaking checks
the platform speech synthesizer and queues even if anything is speaking?
If you set that aside for the moment, checking IsSpeaking is correct here -
if the user sets the enqueue flag, then we add it to the queue if another
utterance is already speaking. If the user doesn't set the enqueue flag,
then we always speak now.

Is that what you were worried about, or something else?

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

Got it. That won't happen because IsSpeaking checks current_utterance_,
which will be set if there's an utterance that we've called Speak on but
hasn't actually started speaking yet. IsSpeaking will never return false
while we have anything in the queue.

     utterance_queue_.push(utterance);
   } else {

[David Tseng, 2013/05/13 17:49:54]

What happens if we're currently paused and get a non-enqueued utterance?
Shouldn't that flush what's on the queue?

Also, can_enqueue seems like a bad name; how about should_enqueue (or just
enqueue)?

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

Done.
Can enqueue means that it is allowed to be enqueued if it can't be spoken now.
If it can be spoken now, it will be.

     Stop();
@@ -196,6 +197,7 @@ void TtsController::SpeakNow(Utterance* utterance) {
 }
 
 void TtsController::Stop() {
+  paused_ = false;
   if (current_utterance_ && !current_utterance_->extension_id().empty()) {
     ExtensionTtsEngineStop(current_utterance_);
   } else {
@@ -210,6 +212,28 @@ void TtsController::Stop() {
   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,
@@ -253,6 +277,9 @@ void TtsController::FinishCurrentUtterance() {
 }
 
 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_) {