Cancel any pending speech recognitions when the dispatcher host terminates.

chrome/browser/speech/speech_input_dispatcher_host.cc

 // Copyright (c) 2010 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/speech_input_dispatcher_host.h"
 
 #include "base/lazy_instance.h"
 #include "chrome/common/render_messages.h"
 
 namespace speech_input {
@@ skipping 87 matching lines @@
 int SpeechInputDispatcherHost::SpeechInputCallers::request_id(int id) {
   return callers_[id].request_id;
 }
 
 //-------------------------- SpeechInputDispatcherHost -------------------------
 
 SpeechInputManager::AccessorMethod*
     SpeechInputDispatcherHost::manager_accessor_ = &SpeechInputManager::Get;
 
 SpeechInputDispatcherHost::SpeechInputDispatcherHost(int render_process_id)
-    : render_process_id_(render_process_id) {
+    : render_process_id_(render_process_id),
+      received_speech_request_(false) {
   // This is initialized by Browser. Do not add any non-trivial
   // initialization here, instead do it lazily when required (e.g. see the
   // method |manager()|) or add an Init() method.
 }
 
 SpeechInputDispatcherHost::~SpeechInputDispatcherHost() {
+  // If the renderer crashed for some reason or if we didn't receive a proper
+  // Cancel/Stop call for an existing session, cancel such active sessions now.
+  // We first check if this dispatcher received any speech IPC requst so that
+  // we don't end up creating the speech input manager for web pages which don't
+  // use speech input.
+  if (received_speech_request_)

[bulach, 2011/01/20 14:47:20]

suggest: may_have_pending_requests_ ?
it seems slightly better:

if (may_have_pending_requests_)
  manager()->CancelAllRequestsWithDelegate(this);

[Satish, 2011/01/20 15:09:03]

Done.

+    manager()->CancelAllRequestsWithDelegate(this);
 }
 
 SpeechInputManager* SpeechInputDispatcherHost::manager() {
   return (*manager_accessor_)();
 }
 
 bool SpeechInputDispatcherHost::OnMessageReceived(
     const IPC::Message& message, bool* message_was_ok) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   uint32 message_type = message.type();
   if (message_type == ViewHostMsg_SpeechInput_StartRecognition::ID ||
       message_type == ViewHostMsg_SpeechInput_CancelRecognition::ID ||
       message_type == ViewHostMsg_SpeechInput_StopRecording::ID) {
     if (!SpeechInputManager::IsFeatureEnabled()) {
       *message_was_ok = false;
       return true;
     }
 
+    received_speech_request_ = true;
     IPC_BEGIN_MESSAGE_MAP_EX(SpeechInputDispatcherHost, message,
                              *message_was_ok)
       IPC_MESSAGE_HANDLER(ViewHostMsg_SpeechInput_StartRecognition,
                           OnStartRecognition)
       IPC_MESSAGE_HANDLER(ViewHostMsg_SpeechInput_CancelRecognition,
                           OnCancelRecognition)
       IPC_MESSAGE_HANDLER(ViewHostMsg_SpeechInput_StopRecording,
                           OnStopRecording)
     IPC_END_MESSAGE_MAP()
     return true;
@@ skipping 66 matching lines @@
     g_speech_input_callers.Get().render_view_id(caller_id);
   int caller_request_id = g_speech_input_callers.Get().request_id(caller_id);
   Send(new ViewMsg_SpeechInput_RecognitionComplete(caller_render_view_id,
                                                    caller_request_id));
   // Request sequence ended, so remove mapping.
   g_speech_input_callers.Get().RemoveId(caller_id);
   VLOG(1) << "SpeechInputDispatcherHost::DidCompleteRecognition exit";
 }
 
 }  // namespace speech_input