Remove GetAudioManager and GetMediaStreamManager from ResourceContext. The reason is the content mo…

content/browser/speech/speech_recognizer.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_recognizer.h"
 
 #include "base/bind.h"
 #include "base/time.h"
+#include "content/browser/browser_main_loop.h"
 #include "content/public/browser/speech_recognizer_delegate.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/speech_input_result.h"
 #include "net/url_request/url_request_context_getter.h"
 
+using content::BrowserMainLoop;
 using content::BrowserThread;
 using media::AudioInputController;
 using std::string;
 
 namespace {
 
 // The following constants are related to the volume level indicator shown in
 // the UI for recorded audio.
 // Multiplier used when new volume is greater than previous level.
 const float kUpSmoothingFactor = 1.0f;
@@ skipping 31 matching lines @@
 const ChannelLayout SpeechRecognizer::kChannelLayout = CHANNEL_LAYOUT_MONO;
 const int SpeechRecognizer::kNumBitsPerAudioSample = 16;
 const int SpeechRecognizer::kNoSpeechTimeoutSec = 8;
 const int SpeechRecognizer::kEndpointerEstimationTimeMs = 300;
 
 SpeechRecognizer::SpeechRecognizer(content::SpeechRecognizerDelegate* delegate,
                                    int caller_id,
                                    const std::string& language,
                                    const std::string& grammar,
                                    net::URLRequestContextGetter* context_getter,
-                                   AudioManager* audio_manager,
                                    bool filter_profanities,
                                    const std::string& hardware_info,
                                    const std::string& origin_url)
     : delegate_(delegate),
       caller_id_(caller_id),
       language_(language),
       grammar_(grammar),
       filter_profanities_(filter_profanities),
       hardware_info_(hardware_info),
       origin_url_(origin_url),
       context_getter_(context_getter),
-      audio_manager_(audio_manager),
       codec_(AudioEncoder::CODEC_FLAC),
       encoder_(NULL),
       endpointer_(kAudioSampleRate),
       num_samples_recorded_(0),
-      audio_level_(0.0f) {
+      audio_level_(0.0f),
+      audio_manager_(NULL) {
   endpointer_.set_speech_input_complete_silence_length(
       base::Time::kMicrosecondsPerSecond / 2);
   endpointer_.set_long_speech_input_complete_silence_length(
       base::Time::kMicrosecondsPerSecond);
   endpointer_.set_long_speech_length(3 * base::Time::kMicrosecondsPerSecond);
   endpointer_.StartSession();
 }
 
 SpeechRecognizer::~SpeechRecognizer() {
   // Recording should have stopped earlier due to the endpointer or
@@ skipping 14 matching lines @@
   // starting to treat the audio as user input. In |HandleOnData| we wait until
   // such time has passed before switching to user input mode.
   endpointer_.SetEnvironmentEstimationMode();
 
   encoder_.reset(AudioEncoder::Create(codec_, kAudioSampleRate,
                                       kNumBitsPerAudioSample));
   int samples_per_packet = (kAudioSampleRate * kAudioPacketIntervalMs) / 1000;
   AudioParameters params(AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout,
                          kAudioSampleRate, kNumBitsPerAudioSample,
                          samples_per_packet);
-  audio_controller_ = AudioInputController::Create(audio_manager_, this,
-                                                   params);
+  audio_controller_ = AudioInputController::Create(
+      audio_manager_ ? audio_manager_ : BrowserMainLoop::GetAudioManager(),
+      this, params);
   DCHECK(audio_controller_.get());
   VLOG(1) << "SpeechRecognizer starting record.";
   num_samples_recorded_ = 0;
   audio_controller_->Record();
 
   return true;
 }
 
 void SpeechRecognizer::CancelRecognition() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
@@ skipping 183 matching lines @@
   // TODO(satish): investigate the possibility to utilize the closure
   // and switch to async. version of this method. Compare with how
   // it's done in e.g. the AudioRendererHost.
   base::WaitableEvent closed_event(true, false);
   audio_controller_->Close(base::Bind(&base::WaitableEvent::Signal,
                            base::Unretained(&closed_event)));
   closed_event.Wait();
   audio_controller_ = NULL;  // Releases the ref ptr.
 }
 
+void SpeechRecognizer::SetAudioManagerForTesting(AudioManager* audio_manager) {
+  audio_manager_ = audio_manager;
+}
+
 }  // namespace speech_input