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 (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();
     SpeakNow(utterance);
   }
 }
 
 void TtsController::SpeakNow(Utterance* utterance) {
   // Get all available voices and try to find a matching voice.
   std::vector<VoiceData> voices;
   GetVoices(utterance->profile(), &voices);
   int index = GetMatchingVoice(utterance, voices);
@@ skipping 42 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;
 }