favor DCHECK_CURRENTLY_ON for better logs in content/browser/[q-z]*

content/browser/speech/speech_recognition_manager_impl.cc

 // Copyright (c) 2013 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/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/media_stream_ui_proxy.h"
@@ skipping 21 matching lines @@
 
 namespace content {
 
 SpeechRecognitionManager* SpeechRecognitionManager::manager_for_tests_;
 
 namespace {
 
 SpeechRecognitionManagerImpl* g_speech_recognition_manager_impl;
 
 void ShowAudioInputSettingsOnFileThread(media::AudioManager* audio_manager) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   audio_manager->ShowAudioInputSettings();
 }
 
 }  // namespace
 
 SpeechRecognitionManager* SpeechRecognitionManager::GetInstance() {
   if (manager_for_tests_)
     return manager_for_tests_;
   return SpeechRecognitionManagerImpl::GetInstance();
 }
@@ skipping 31 matching lines @@
     // MediaStreamUIProxy must be deleted on the IO thread.
     BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE,
                               it->second->ui.release());
     delete it->second;
   }
   sessions_.clear();
 }
 
 int SpeechRecognitionManagerImpl::CreateSession(
     const SpeechRecognitionSessionConfig& config) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   const int session_id = GetNextSessionID();
   DCHECK(!SessionExists(session_id));
   // Set-up the new session.
   Session* session = new Session();
   sessions_[session_id] = session;
   session->id = session_id;
   session->config = config;
   session->context = config.initial_context;
 
@@ skipping 48 matching lines @@
       config.continuous,
       config.interim_results,
       google_remote_engine);
 #else
   session->recognizer = new SpeechRecognizerImplAndroid(this, session_id);
 #endif
   return session_id;
 }
 
 void SpeechRecognitionManagerImpl::StartSession(int session_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!SessionExists(session_id))
     return;
 
   // If there is another active session, abort that.
   if (primary_session_id_ != kSessionIDInvalid &&
       primary_session_id_ != session_id) {
     AbortSession(primary_session_id_);
   }
 
   primary_session_id_ = session_id;
 
   if (delegate_) {
     delegate_->CheckRecognitionIsAllowed(
         session_id,
         base::Bind(&SpeechRecognitionManagerImpl::RecognitionAllowedCallback,
                    weak_factory_.GetWeakPtr(),
                    session_id));
   }
 }
 
 void SpeechRecognitionManagerImpl::RecognitionAllowedCallback(int session_id,
                                                               bool ask_user,
                                                               bool is_allowed) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!SessionExists(session_id))
     return;
 
   SessionsTable::iterator iter = sessions_.find(session_id);
   DCHECK(iter != sessions_.end());
   Session* session = iter->second;
 
   if (session->abort_requested)
     return;
 
@@ skipping 27 matching lines @@
                    weak_factory_.GetWeakPtr(),
                    session_id,
                    EVENT_ABORT));
   }
 }
 
 void SpeechRecognitionManagerImpl::MediaRequestPermissionCallback(
     int session_id,
     const MediaStreamDevices& devices,
     scoped_ptr<MediaStreamUIProxy> stream_ui) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   SessionsTable::iterator iter = sessions_.find(session_id);
   if (iter == sessions_.end())
     return;
 
   bool is_allowed = !devices.empty();
   if (is_allowed) {
     // Copy the approved devices array to the context for UI indication.
     iter->second->context.devices = devices;
 
     // Save the UI object.
     iter->second->ui = stream_ui.Pass();
   }
 
   // Clear the label to indicate the request has been done.
   iter->second->context.label.clear();
 
   // Notify the recognition about the request result.
   RecognitionAllowedCallback(iter->first, false, is_allowed);
 }
 
 void SpeechRecognitionManagerImpl::AbortSession(int session_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!SessionExists(session_id))
     return;
 
   SessionsTable::iterator iter = sessions_.find(session_id);
   iter->second->ui.reset();
 
   if (iter->second->abort_requested)
     return;
 
   iter->second->abort_requested = true;
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&SpeechRecognitionManagerImpl::DispatchEvent,
                  weak_factory_.GetWeakPtr(),
                  session_id,
                  EVENT_ABORT));
 }
 
 void SpeechRecognitionManagerImpl::StopAudioCaptureForSession(int session_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!SessionExists(session_id))
     return;
 
   SessionsTable::iterator iter = sessions_.find(session_id);
   iter->second->ui.reset();
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&SpeechRecognitionManagerImpl::DispatchEvent,
                  weak_factory_.GetWeakPtr(),
                  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 and to the catch-all listener provided by the delegate
 // (if any).
 
 void SpeechRecognitionManagerImpl::OnRecognitionStart(int session_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!SessionExists(session_id))
     return;
 
   SessionsTable::iterator iter = sessions_.find(session_id);
   if (iter->second->ui) {
     // Notify the UI that the devices are being used.
     iter->second->ui->OnStarted(base::Closure(),
                                 MediaStreamUIProxy::WindowIdCallback());
   }
 
   DCHECK_EQ(primary_session_id_, session_id);
   if (SpeechRecognitionEventListener* delegate_listener = GetDelegateListener())
     delegate_listener->OnRecognitionStart(session_id);
   if (SpeechRecognitionEventListener* listener = GetListener(session_id))
     listener->OnRecognitionStart(session_id);
 }
 
 void SpeechRecognitionManagerImpl::OnAudioStart(int session_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!SessionExists(session_id))
     return;
 
   DCHECK_EQ(primary_session_id_, session_id);
   if (SpeechRecognitionEventListener* delegate_listener = GetDelegateListener())
     delegate_listener->OnAudioStart(session_id);
   if (SpeechRecognitionEventListener* listener = GetListener(session_id))
     listener->OnAudioStart(session_id);
 }
 
 void SpeechRecognitionManagerImpl::OnEnvironmentEstimationComplete(
     int session_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!SessionExists(session_id))
     return;
 
   DCHECK_EQ(primary_session_id_, session_id);
   if (SpeechRecognitionEventListener* delegate_listener = GetDelegateListener())
     delegate_listener->OnEnvironmentEstimationComplete(session_id);
   if (SpeechRecognitionEventListener* listener = GetListener(session_id))
     listener->OnEnvironmentEstimationComplete(session_id);
 }
 
 void SpeechRecognitionManagerImpl::OnSoundStart(int session_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!SessionExists(session_id))
     return;
 
   DCHECK_EQ(primary_session_id_, session_id);
   if (SpeechRecognitionEventListener* delegate_listener = GetDelegateListener())
     delegate_listener->OnSoundStart(session_id);
   if (SpeechRecognitionEventListener* listener = GetListener(session_id))
     listener->OnSoundStart(session_id);
 }
 
 void SpeechRecognitionManagerImpl::OnSoundEnd(int session_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!SessionExists(session_id))
     return;
 
   if (SpeechRecognitionEventListener* delegate_listener = GetDelegateListener())
     delegate_listener->OnSoundEnd(session_id);
   if (SpeechRecognitionEventListener* listener = GetListener(session_id))
     listener->OnSoundEnd(session_id);
 }
 
 void SpeechRecognitionManagerImpl::OnAudioEnd(int session_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(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);
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&SpeechRecognitionManagerImpl::DispatchEvent,
                  weak_factory_.GetWeakPtr(),
                  session_id,
                  EVENT_AUDIO_ENDED));
 }
 
 void SpeechRecognitionManagerImpl::OnRecognitionResults(
     int session_id, const SpeechRecognitionResults& results) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!SessionExists(session_id))
     return;
 
   if (SpeechRecognitionEventListener* delegate_listener = GetDelegateListener())
     delegate_listener->OnRecognitionResults(session_id, results);
   if (SpeechRecognitionEventListener* listener = GetListener(session_id))
     listener->OnRecognitionResults(session_id, results);
 }
 
 void SpeechRecognitionManagerImpl::OnRecognitionError(
     int session_id, const SpeechRecognitionError& error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!SessionExists(session_id))
     return;
 
   if (SpeechRecognitionEventListener* delegate_listener = GetDelegateListener())
     delegate_listener->OnRecognitionError(session_id, error);
   if (SpeechRecognitionEventListener* listener = GetListener(session_id))
     listener->OnRecognitionError(session_id, error);
 }
 
 void SpeechRecognitionManagerImpl::OnAudioLevelsChange(
     int session_id, float volume, float noise_volume) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!SessionExists(session_id))
     return;
 
   if (SpeechRecognitionEventListener* delegate_listener = GetDelegateListener())
     delegate_listener->OnAudioLevelsChange(session_id, volume, noise_volume);
   if (SpeechRecognitionEventListener* listener = GetListener(session_id))
     listener->OnAudioLevelsChange(session_id, volume, noise_volume);
 }
 
 void SpeechRecognitionManagerImpl::OnRecognitionEnd(int session_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(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);
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&SpeechRecognitionManagerImpl::DispatchEvent,
                  weak_factory_.GetWeakPtr(),
                  session_id,
                  EVENT_RECOGNITION_ENDED));
 }
 
 int SpeechRecognitionManagerImpl::GetSession(
     int render_process_id, int render_view_id, int request_id) const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   SessionsTable::const_iterator iter;
   for (iter = sessions_.begin(); iter != sessions_.end(); ++iter) {
     const int session_id = iter->first;
     const SpeechRecognitionSessionContext& context = iter->second->context;
     if (context.render_process_id == render_process_id &&
         context.render_view_id == render_view_id &&
         context.request_id == request_id) {
       return session_id;
     }
   }
   return kSessionIDInvalid;
 }
 
 SpeechRecognitionSessionContext
 SpeechRecognitionManagerImpl::GetSessionContext(int session_id) const {
   return GetSession(session_id)->context;
 }
 
 void SpeechRecognitionManagerImpl::AbortAllSessionsForRenderProcess(
     int render_process_id) {
   // This method gracefully destroys sessions for the listener. However, since
   // the listener itself is likely to be destroyed after this call, we avoid
   // dispatching further events to it, marking the |listener_is_active| flag.
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   for (SessionsTable::iterator it = sessions_.begin(); it != sessions_.end();
        ++it) {
     Session* session = it->second;
     if (session->context.render_process_id == render_process_id) {
       AbortSession(session->id);
       session->listener_is_active = false;
     }
   }
 }
 
 void SpeechRecognitionManagerImpl::AbortAllSessionsForRenderView(
     int render_process_id,
     int render_view_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   for (SessionsTable::iterator it = sessions_.begin(); it != sessions_.end();
        ++it) {
     Session* session = it->second;
     if (session->context.render_process_id == render_process_id &&
         session->context.render_view_id == render_view_id) {
       AbortSession(session->id);
     }
   }
 }
 
 // -----------------------  Core FSM implementation ---------------------------
 void SpeechRecognitionManagerImpl::DispatchEvent(int session_id,
                                                  FSMEvent event) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(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;
 
   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);
@@ skipping 143 matching lines @@
     last_session_id_ = 1;
   return last_session_id_;
 }
 
 bool SpeechRecognitionManagerImpl::SessionExists(int session_id) const {
   return sessions_.find(session_id) != sessions_.end();
 }
 
 SpeechRecognitionManagerImpl::Session*
 SpeechRecognitionManagerImpl::GetSession(int session_id) const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   SessionsTable::const_iterator iter = sessions_.find(session_id);
   DCHECK(iter != sessions_.end());
   return iter->second;
 }
 
 SpeechRecognitionEventListener* SpeechRecognitionManagerImpl::GetListener(
     int session_id) const {
   Session* session = GetSession(session_id);
   if (session->listener_is_active && session->config.event_listener)
     return session->config.event_listener.get();
@@ skipping 29 matching lines @@
 SpeechRecognitionManagerImpl::Session::Session()
   : id(kSessionIDInvalid),
     abort_requested(false),
     listener_is_active(true) {
 }
 
 SpeechRecognitionManagerImpl::Session::~Session() {
 }
 
 }  // namespace content