Moved instantiation of SpeechRecognitionManager inside browser_main_loop, instead of Singleton.

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 "base/memory/singleton.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"
@@ skipping 13 matching lines @@
 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() {
-  return Singleton<SpeechRecognitionManagerImpl,
-                   LeakySingletonTraits<SpeechRecognitionManagerImpl> >::get();
+  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();
+      is_dispatching_event_(false),
+      delegate_(content::GetContentClient()->browser()->
+                    GetSpeechRecognitionManagerDelegate()) {
+  DCHECK(!g_speech_recognition_manager_impl);
+  g_speech_recognition_manager_impl = this;
 }
 
 SpeechRecognitionManagerImpl::~SpeechRecognitionManagerImpl() {
+  DCHECK(g_speech_recognition_manager_impl);
+  g_speech_recognition_manager_impl = NULL;
   // Recognition sessions will be aborted by the corresponding destructors.
   sessions_.clear();
 }
 
 int SpeechRecognitionManagerImpl::CreateSession(
     const SpeechRecognitionSessionConfig& config) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   const int session_id = GetNextSessionID();
   DCHECK(!SessionExists(session_id));
   // Set-up the new session.
   Session& session = sessions_[session_id];
   session.id = session_id;
   session.config = config;
   session.context = config.initial_context;
 
   std::string hardware_info;
   bool can_report_metrics = false;
-  if (delegate_)
+  if (delegate_.get())
     delegate_->GetDiagnosticInformation(&can_report_metrics, &hardware_info);
 
   GoogleOneShotRemoteEngineConfig remote_engine_config;
   remote_engine_config.language = config.language;
   remote_engine_config.grammar = config.grammar;
   remote_engine_config.audio_sample_rate =
       SpeechRecognizerImpl::kAudioSampleRate;
   remote_engine_config.audio_num_bits_per_sample =
      SpeechRecognizerImpl::kNumBitsPerAudioSample;
   remote_engine_config.filter_profanities = config.filter_profanities;
@@ skipping 14 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!SessionExists(session_id))
     return;
 
   // 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_)
+  if (delegate_.get())
     delegate_->CheckRecognitionIsAllowed(
         session_id,
         base::Bind(&SpeechRecognitionManagerImpl::RecognitionAllowedCallback,
                    Unretained(this)));
 }
 
 void SpeechRecognitionManagerImpl::RecognitionAllowedCallback(int session_id,
                                                               bool is_allowed) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(SessionExists(session_id));
@@ skipping 343 matching lines @@
 }
 
 SpeechRecognitionEventListener* SpeechRecognitionManagerImpl::GetListener(
     int session_id) const {
   const Session& session = GetSession(session_id);
   return session.listener_is_active ? session.config.event_listener : NULL;
 }
 
 SpeechRecognitionEventListener*
 SpeechRecognitionManagerImpl::GetDelegateListener() const {
-  return delegate_ ? delegate_->GetEventListener() : NULL;
+  return delegate_.get() ? delegate_->GetEventListener() : NULL;
 }
 
 const SpeechRecognitionSessionConfig&
 SpeechRecognitionManagerImpl::GetSessionConfig(int session_id) const {
   return GetSession(session_id).config;
 }
 
 bool SpeechRecognitionManagerImpl::HasAudioInputDevices() {
   return BrowserMainLoop::GetAudioManager()->HasAudioInputDevices();
 }
@@ skipping 25 matching lines @@
 
 SpeechRecognitionManagerImpl::Session::Session()
   : id(kSessionIDInvalid),
     listener_is_active(true) {
 }
 
 SpeechRecognitionManagerImpl::Session::~Session() {
 }
 
 }  // namespace speech