SpeechInputExtensionManager now interface (exclusively) with SpeechRecognitionManagerDelegate (Spee…

content/browser/speech/speech_recognition_manager_impl.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 "content/browser/speech/speech_recognition_manager_impl.h"
 
 #include "base/bind.h"
 #include "content/browser/browser_main_loop.h"
 #include "content/browser/speech/google_one_shot_remote_engine.h"
 #include "content/browser/speech/speech_recognition_engine.h"
 #include "content/browser/speech/speech_recognizer_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/speech_recognition_event_listener.h"
 #include "content/public/browser/speech_recognition_manager_delegate.h"
 #include "content/public/browser/speech_recognition_session_config.h"
 #include "content/public/browser/speech_recognition_session_context.h"
 #include "content/public/common/speech_recognition_result.h"
 #include "media/audio/audio_manager.h"
 
 using base::Callback;
-using base::Unretained;
 using content::BrowserMainLoop;
 using content::BrowserThread;
 using content::SpeechRecognitionError;
 using content::SpeechRecognitionEventListener;
 using content::SpeechRecognitionManager;
 using content::SpeechRecognitionResult;
 using content::SpeechRecognitionSessionContext;
 using content::SpeechRecognitionSessionConfig;
 
 namespace content {
 const int SpeechRecognitionManager::kSessionIDInvalid = 0;
 
 SpeechRecognitionManager* SpeechRecognitionManager::GetInstance() {
   return speech::SpeechRecognitionManagerImpl::GetInstance();
 }
 }  // namespace content
 
 namespace {
 speech::SpeechRecognitionManagerImpl* g_speech_recognition_manager_impl;
 }  // namespace
 
 namespace speech {
 
 SpeechRecognitionManagerImpl* SpeechRecognitionManagerImpl::GetInstance() {
-  DCHECK(g_speech_recognition_manager_impl);
   return g_speech_recognition_manager_impl;
 }
 
 SpeechRecognitionManagerImpl::SpeechRecognitionManagerImpl()
     : session_id_capturing_audio_(kSessionIDInvalid),
       last_session_id_(kSessionIDInvalid),
       is_dispatching_event_(false),
       delegate_(content::GetContentClient()->browser()->
                     GetSpeechRecognitionManagerDelegate()) {
   DCHECK(!g_speech_recognition_manager_impl);
@@ skipping 53 matching lines @@
   // If there is another active session, abort that.
   if (session_id_capturing_audio_ != kSessionIDInvalid &&
       session_id_capturing_audio_ != session_id) {
     AbortSession(session_id_capturing_audio_);
   }
 
   if (delegate_.get())
     delegate_->CheckRecognitionIsAllowed(
         session_id,
         base::Bind(&SpeechRecognitionManagerImpl::RecognitionAllowedCallback,
-                   Unretained(this)));
+                   this->AsWeakPtr()));
 }
 
 void SpeechRecognitionManagerImpl::RecognitionAllowedCallback(int session_id,
                                                               bool is_allowed) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(SessionExists(session_id));
   if (is_allowed) {
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
         base::Bind(&SpeechRecognitionManagerImpl::DispatchEvent,
-                   Unretained(this), session_id, EVENT_START));
+                   this->AsWeakPtr(), session_id, EVENT_START));
   } else {
     sessions_.erase(session_id);
   }
 }
 
 void SpeechRecognitionManagerImpl::AbortSession(int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!SessionExists(session_id))
     return;
 
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-      base::Bind(&SpeechRecognitionManagerImpl::DispatchEvent, Unretained(this),
-                 session_id, EVENT_ABORT));
+      base::Bind(&SpeechRecognitionManagerImpl::DispatchEvent,
+                 this->AsWeakPtr(), session_id, EVENT_ABORT));
 }
 
 void SpeechRecognitionManagerImpl::StopAudioCaptureForSession(int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!SessionExists(session_id))
     return;
 
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-      base::Bind(&SpeechRecognitionManagerImpl::DispatchEvent, Unretained(this),
-                 session_id, EVENT_STOP_CAPTURE));
+      base::Bind(&SpeechRecognitionManagerImpl::DispatchEvent,
+                 this->AsWeakPtr(), session_id, EVENT_STOP_CAPTURE));
 }
 
 // Here begins the SpeechRecognitionEventListener interface implementation,
 // which will simply relay the events to the proper listener registered for the
 // particular session (most likely InputTagSpeechDispatcherHost) and to the
 // catch-all listener provided by the delegate (if any).
 
 void SpeechRecognitionManagerImpl::OnRecognitionStart(int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!SessionExists(session_id))
@@ skipping 57 matching lines @@
 void SpeechRecognitionManagerImpl::OnAudioEnd(int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!SessionExists(session_id))
     return;
 
   if (SpeechRecognitionEventListener* delegate_listener = GetDelegateListener())
     delegate_listener->OnAudioEnd(session_id);
   if (SpeechRecognitionEventListener* listener = GetListener(session_id))
     listener->OnAudioEnd(session_id);
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-      base::Bind(&SpeechRecognitionManagerImpl::DispatchEvent, Unretained(this),
-                 session_id, EVENT_AUDIO_ENDED));
+      base::Bind(&SpeechRecognitionManagerImpl::DispatchEvent,
+                 this->AsWeakPtr(), session_id, EVENT_AUDIO_ENDED));
 }
 
 void SpeechRecognitionManagerImpl::OnRecognitionResult(
     int session_id, const content::SpeechRecognitionResult& result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!SessionExists(session_id))
     return;
 
   if (SpeechRecognitionEventListener* delegate_listener = GetDelegateListener())
     delegate_listener->OnRecognitionResult(session_id, result);
@@ skipping 28 matching lines @@
 void SpeechRecognitionManagerImpl::OnRecognitionEnd(int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!SessionExists(session_id))
     return;
 
   if (SpeechRecognitionEventListener* delegate_listener = GetDelegateListener())
     delegate_listener->OnRecognitionEnd(session_id);
   if (SpeechRecognitionEventListener* listener = GetListener(session_id))
     listener->OnRecognitionEnd(session_id);
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-      base::Bind(&SpeechRecognitionManagerImpl::DispatchEvent, Unretained(this),
-                 session_id, EVENT_RECOGNITION_ENDED));
+      base::Bind(&SpeechRecognitionManagerImpl::DispatchEvent,
+                 this->AsWeakPtr(), session_id, EVENT_RECOGNITION_ENDED));
 }
 
 // TODO(primiano) After CL2: if we see that both InputTagDispatcherHost and
 // SpeechRecognitionDispatcherHost do the same lookup operations, implement the
 // lookup method directly here.
 int SpeechRecognitionManagerImpl::LookupSessionByContext(
     Callback<bool(const SpeechRecognitionSessionContext&)> matcher) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   SessionsTable::const_iterator iter;
   // Note: the callback (matcher) must NEVER perform non-const calls on us.
@@ skipping 25 matching lines @@
       AbortSession(session.id);
       session.listener_is_active = false;
     }
   }
 }
 
 // -----------------------  Core FSM implementation ---------------------------
 void SpeechRecognitionManagerImpl::DispatchEvent(int session_id,
                                                  FSMEvent event) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  // There are some corner cases in which the session might be deleted (due to
+  // an EndRecognition event) between a request (e.g. Abort) and its dispatch.
+  if (!SessionExists(session_id))
+    return;
+
   const Session& session = GetSession(session_id);
   FSMState session_state = GetSessionState(session_id);
   DCHECK_LE(session_state, SESSION_STATE_MAX_VALUE);
   DCHECK_LE(event, EVENT_MAX_VALUE);
 
   // Event dispatching must be sequential, otherwise it will break all the rules
   // and the assumptions of the finite state automata model.
   DCHECK(!is_dispatching_event_);
   is_dispatching_event_ = true;
   ExecuteTransitionAndGetNextState(session, session_state, event);
@@ skipping 159 matching lines @@
   return BrowserMainLoop::GetAudioManager()->GetAudioInputDeviceModel();
 }
 
 void SpeechRecognitionManagerImpl::ShowAudioInputSettings() {
   // Since AudioManager::ShowAudioInputSettings can potentially launch external
   // processes, do that in the FILE thread to not block the calling threads.
   if (!BrowserThread::CurrentlyOn(BrowserThread::FILE)) {
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         base::Bind(&SpeechRecognitionManagerImpl::ShowAudioInputSettings,
-                   Unretained(this)));
+                   this->AsWeakPtr()));
     return;
   }
 
   media::AudioManager* audio_manager = BrowserMainLoop::GetAudioManager();
   DCHECK(audio_manager->CanShowAudioInputSettings());
   if (audio_manager->CanShowAudioInputSettings())
     audio_manager->ShowAudioInputSettings();
 }
 
 SpeechRecognitionManagerImpl::Session::Session()
   : id(kSessionIDInvalid),
     listener_is_active(true) {
 }
 
 SpeechRecognitionManagerImpl::Session::~Session() {
 }
 
 }  // namespace speech