Fix crash when TTS utterances are queued on shutdown.

chrome/browser/extensions/extension_tts_api_controller.cc

 // Copyright (c) 2011 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/extensions/extension_tts_api_controller.h"
 
 #include <string>
 #include <vector>
 
 #include "base/float_util.h"
@@ skipping 132 matching lines @@
 ExtensionTtsController::ExtensionTtsController()
     : current_utterance_(NULL),
       platform_impl_(NULL) {
 }
 
 ExtensionTtsController::~ExtensionTtsController() {
   if (current_utterance_) {
     current_utterance_->Finish();
     delete current_utterance_;
   }
-  ClearUtteranceQueue();
+
+  // Clear any queued utterances too, but don't send "cancelled" events
+  // because we're being destroyed.
+  ClearUtteranceQueue(/*send_events=*/false);

[Aaron Boodman, 2011/11/16 09:26:36]

It's more common in Chrome code to do:

ClearUtteranceQueue(false);  // don't send events

Or you can define a named constant, like:

const bool kSendEvents = false;
Clear(kSendEvents);

[dmazzoni, 2011/11/16 15:50:39]

Done.

 }
 
 void ExtensionTtsController::SpeakOrEnqueue(Utterance* utterance) {
   if (IsSpeaking() && utterance->can_enqueue()) {
     utterance_queue_.push(utterance);
   } else {
     Stop();
     SpeakNow(utterance);
   }
 }
@@ skipping 38 matching lines @@
   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, -1, std::string());
   FinishCurrentUtterance();
-  ClearUtteranceQueue();
+  ClearUtteranceQueue(/*send_events=*/true);
 }
 
 void ExtensionTtsController::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.
@@ skipping 65 matching lines @@
 void ExtensionTtsController::SpeakNextUtterance() {
   // 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 ExtensionTtsController::ClearUtteranceQueue() {
+void ExtensionTtsController::ClearUtteranceQueue(bool send_events) {
   while (!utterance_queue_.empty()) {
     Utterance* utterance = utterance_queue_.front();
     utterance_queue_.pop();
-    utterance->OnTtsEvent(TTS_EVENT_CANCELLED, -1, std::string());
+    if (send_events)
+      utterance->OnTtsEvent(TTS_EVENT_CANCELLED, -1, std::string());
+    else
+      utterance->Finish();
     delete utterance;
   }
 }
 
 void ExtensionTtsController::SetPlatformImpl(
     ExtensionTtsPlatformImpl* platform_impl) {
   platform_impl_ = platform_impl;
 }
 
 int ExtensionTtsController::QueueSize() {
   return static_cast<int>(utterance_queue_.size());
 }
 
 ExtensionTtsPlatformImpl* ExtensionTtsController::GetPlatformImpl() {
   if (!platform_impl_)
     platform_impl_ = ExtensionTtsPlatformImpl::GetInstance();
   return platform_impl_;
 }