Stop utterances from a tab when that tab is closed.

chrome/browser/speech/tts_controller_impl.cc

 // Copyright 2014 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_impl.h"
 
 #include <string>
 #include <vector>
 
 #include "base/float_util.h"
@@ skipping 73 matching lines @@
                            int char_index,
                            const std::string& error_message) {
   if (char_index >= 0)
     char_index_ = char_index;
   if (IsFinalTtsEventType(event_type))
     finished_ = true;
 
   if (event_delegate_)
     event_delegate_->OnTtsEvent(this, event_type, char_index, error_message);
   if (finished_)
-    event_delegate_.reset();
+    event_delegate_ = NULL;
 }
 
 void Utterance::Finish() {
   finished_ = true;
 }
 
 void Utterance::set_options(const base::Value* options) {
   options_.reset(options->DeepCopy());
 }
 
@@ skipping 347 matching lines @@
 void TtsControllerImpl::AddVoicesChangedDelegate(
     VoicesChangedDelegate* delegate) {
   voices_changed_delegates_.insert(delegate);
 }
 
 void TtsControllerImpl::RemoveVoicesChangedDelegate(
     VoicesChangedDelegate* delegate) {
   voices_changed_delegates_.erase(delegate);
 }
 
+void TtsControllerImpl::RemoveUtteranceEventDelegate(
+    UtteranceEventDelegate* delegate) {
+  // First clear any pending utterances with this delegate.
+  std::queue<Utterance*> old_queue = utterance_queue_;
+  utterance_queue_ = std::queue<Utterance*>();
+  while (!old_queue.empty()) {
+    Utterance* utterance = old_queue.front();
+    old_queue.pop();
+    if (utterance->event_delegate() != delegate)
+      utterance_queue_.push(utterance);
+    else
+      delete utterance;
+  }
+
+  if (current_utterance_ && current_utterance_->event_delegate() == delegate) {
+    current_utterance_->set_event_delegate(NULL);
+    if (current_utterance_ && !current_utterance_->extension_id().empty()) {

[David Tseng, 2014/10/31 22:33:04]

Why the redundant check for current_utterance?

[dmazzoni, 2014/10/31 22:44:22]

Fixed.

+#if !defined(OS_ANDROID)

[David Tseng, 2014/10/31 22:33:04]

Can this happen? (i.e. an utterance with an extension id set on Android).

[dmazzoni, 2014/10/31 22:44:22]

No. I copied this from other code where we handle Stop, but I think we can get
rid of the ifdef now. Previously this was code that only compiled on a system
with extensions, but now that's been abstracted so the ifdef isn't needed.

+      if (tts_engine_delegate_)
+        tts_engine_delegate_->Stop(current_utterance_);
+#endif
+    } else {
+      GetPlatformImpl()->clear_error();

[David Tseng, 2014/10/31 22:33:04]

What's the purpose of doing this?

[dmazzoni, 2014/10/31 22:44:22]

We do this before every call to the platform TTS so that if it calls back with
an error we know it's from the latest request.

+      GetPlatformImpl()->StopSpeaking();

[David Tseng, 2014/10/31 22:33:04]

Is this behavior part of the web speech spec?I'm curious what it says for other
browser navigation like refresh or user navigation. Would this code cover those
cases?

What if I wanted to speak a goodbye message during navigation for example?

[dmazzoni, 2014/10/31 22:44:22]

See crbug.com/418806, there are concerns about a really long message that the
user would have no way to stop, and adware, and things like that.

The thought is that it should behave like any other tab audio; when you close
the tab it's gone.

If the user really wants something to say goodbye, they should probably install
an extension or app version, or maybe even something like service workers that
can run when a tab isn't active.

[David Tseng, 2014/11/02 19:55:44]

Are there any concerns over really long utterances in general (not just after
tab close)? Any thoughts given to chunking? Obviously, not for this cl.

+    }
+
+    FinishCurrentUtterance();
+    if (!paused_)
+      SpeakNextUtterance();
+  }
+}
+
 void TtsControllerImpl::SetTtsEngineDelegate(
     TtsEngineDelegate* delegate) {
   tts_engine_delegate_ = delegate;
 }
 
 TtsEngineDelegate* TtsControllerImpl::GetTtsEngineDelegate() {
   return tts_engine_delegate_;
 }