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 132 matching lines @@
                             GetPlatformImpl()->error());
       delete utterance;
       return;
     }
   }
 }
 
 void TtsControllerImpl::Stop() {
   paused_ = false;
   if (current_utterance_ && !current_utterance_->extension_id().empty()) {
-#if !defined(OS_ANDROID)
     if (tts_engine_delegate_)
       tts_engine_delegate_->Stop(current_utterance_);
-#endif
   } else {
     GetPlatformImpl()->clear_error();
     GetPlatformImpl()->StopSpeaking();
   }
 
   if (current_utterance_)
     current_utterance_->OnTtsEvent(TTS_EVENT_INTERRUPTED, kInvalidCharIndex,
                                    std::string());
   FinishCurrentUtterance();
   ClearUtteranceQueue(true);  // Send events.
 }
 
 void TtsControllerImpl::Pause() {
   paused_ = true;
   if (current_utterance_ && !current_utterance_->extension_id().empty()) {
-#if !defined(OS_ANDROID)
     if (tts_engine_delegate_)
       tts_engine_delegate_->Pause(current_utterance_);
-#endif
   } else if (current_utterance_) {
     GetPlatformImpl()->clear_error();
     GetPlatformImpl()->Pause();
   }
 }
 
 void TtsControllerImpl::Resume() {
   paused_ = false;
   if (current_utterance_ && !current_utterance_->extension_id().empty()) {
-#if !defined(OS_ANDROID)
     if (tts_engine_delegate_)
       tts_engine_delegate_->Resume(current_utterance_);
-#endif
   } else if (current_utterance_) {
     GetPlatformImpl()->clear_error();
     GetPlatformImpl()->Resume();
   } else {
     SpeakNextUtterance();
   }
 }
 
 void TtsControllerImpl::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;
   }
   current_utterance_->OnTtsEvent(event_type, char_index, error_message);
   if (current_utterance_->finished()) {
     FinishCurrentUtterance();
     SpeakNextUtterance();
   }
 }
 
 void TtsControllerImpl::GetVoices(content::BrowserContext* browser_context,
                               std::vector<VoiceData>* out_voices) {
-#if !defined(OS_ANDROID)
   if (browser_context && tts_engine_delegate_)
     tts_engine_delegate_->GetVoices(browser_context, out_voices);
-#endif
 
   TtsPlatformImpl* platform_impl = GetPlatformImpl();
   if (platform_impl) {
     // Ensure we have all built-in voices loaded. This is a no-op if already
     // loaded.
     platform_impl->LoadBuiltInTtsExtension(browser_context);
     if (platform_impl->PlatformImplAvailable())
       platform_impl->GetVoices(out_voices);
   }
 }
@@ skipping 127 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_->extension_id().empty()) {
+      if (tts_engine_delegate_)
+        tts_engine_delegate_->Stop(current_utterance_);
+    } else {
+      GetPlatformImpl()->clear_error();
+      GetPlatformImpl()->StopSpeaking();
+    }
+
+    FinishCurrentUtterance();
+    if (!paused_)
+      SpeakNextUtterance();
+  }
+}
+
 void TtsControllerImpl::SetTtsEngineDelegate(
     TtsEngineDelegate* delegate) {
   tts_engine_delegate_ = delegate;
 }
 
 TtsEngineDelegate* TtsControllerImpl::GetTtsEngineDelegate() {
   return tts_engine_delegate_;
 }