Removing AudioSystem::GetAudioManager() usage from speech recognition

content/browser/speech/speech_recognizer_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_recognizer_impl.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 
@@ skipping 96 matching lines @@
 
 }  // namespace
 
 const int SpeechRecognizerImpl::kAudioSampleRate = 16000;
 const ChannelLayout SpeechRecognizerImpl::kChannelLayout =
     media::CHANNEL_LAYOUT_MONO;
 const int SpeechRecognizerImpl::kNumBitsPerAudioSample = 16;
 const int SpeechRecognizerImpl::kNoSpeechTimeoutMs = 8000;
 const int SpeechRecognizerImpl::kEndpointerEstimationTimeMs = 300;
 media::AudioSystem* SpeechRecognizerImpl::audio_system_for_tests_ = nullptr;
+media::AudioManager* SpeechRecognizerImpl::audio_manager_for_tests_ = nullptr;
 
 static_assert(SpeechRecognizerImpl::kNumBitsPerAudioSample % 8 == 0,
               "kNumBitsPerAudioSample must be a multiple of 8");
 
 // SpeechRecognizerImpl::OnDataConverter implementation
 
 SpeechRecognizerImpl::OnDataConverter::OnDataConverter(
     const AudioParameters& input_params,
     const AudioParameters& output_params)
     : audio_converter_(input_params, output_params, false),
@@ skipping 44 matching lines @@
   // Indicate that the recorded audio has in fact been used by the converter.
   data_was_converted_ = true;
   return 1;
 }
 
 // SpeechRecognizerImpl implementation
 
 SpeechRecognizerImpl::SpeechRecognizerImpl(
     SpeechRecognitionEventListener* listener,
     media::AudioSystem* audio_system,
+    media::AudioManager* audio_manager,
     int session_id,
     bool continuous,
     bool provisional_results,
     SpeechRecognitionEngine* engine)
     : SpeechRecognizer(listener, session_id),
       audio_system_(audio_system),
+      audio_manager_(audio_manager),
       recognition_engine_(engine),
       endpointer_(kAudioSampleRate),
       audio_log_(MediaInternals::GetInstance()->CreateAudioLog(
           media::AudioLogFactory::AUDIO_INPUT_CONTROLLER)),
       is_dispatching_event_(false),
       provisional_results_(provisional_results),
       end_of_utterance_(false),
       state_(STATE_IDLE),
       weak_ptr_factory_(this) {
   DCHECK(recognition_engine_ != nullptr);
@@ skipping 429 matching lines @@
     DVLOG(1) << "SRI::input_parameters: "
              << input_parameters.AsHumanReadableString();
   }
 
   // Create an audio converter which converts data between native input format
   // and WebSpeech specific output format.
   audio_converter_.reset(
       new OnDataConverter(input_parameters, output_parameters));
 
   audio_controller_ = AudioInputController::Create(
-      GetAudioSystem()->GetAudioManager(), this, this, nullptr,
-      input_parameters, device_id_,
+      GetAudioManager(), this, this, nullptr, input_parameters, device_id_,
       /*agc_is_enabled*/ false,
       BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE));
 
   if (!audio_controller_.get()) {
     return Abort(
         SpeechRecognitionError(SPEECH_RECOGNITION_ERROR_AUDIO_CAPTURE));
   }
 
   audio_log_->OnCreated(0, input_parameters, device_id_);
 
@@ skipping 228 matching lines @@
 
   float noise_level = (endpointer_.NoiseLevelDb() - kAudioMeterMinDb) /
       (kAudioMeterDbRange / kAudioMeterRangeMaxUnclipped);
   noise_level = std::min(std::max(0.0f, noise_level),
                          kAudioMeterRangeMaxUnclipped);
 
   listener()->OnAudioLevelsChange(
       session_id(), clip_detected ? 1.0f : audio_level_, noise_level);
 }
 
-void SpeechRecognizerImpl::SetAudioSystemForTesting(
-    media::AudioSystem* audio_system) {
+void SpeechRecognizerImpl::SetAudioEnvironmentForTesting(
+    media::AudioSystem* audio_system,
+    media::AudioManager* audio_manager) {
   audio_system_for_tests_ = audio_system;
+  audio_manager_for_tests_ = audio_manager;
 }
 
 media::AudioSystem* SpeechRecognizerImpl::GetAudioSystem() {
   return audio_system_for_tests_ ? audio_system_for_tests_ : audio_system_;
 }
 
+media::AudioManager* SpeechRecognizerImpl::GetAudioManager() {
+  return audio_manager_for_tests_ ? audio_manager_for_tests_ : audio_manager_;
+}
+
 SpeechRecognizerImpl::FSMEventArgs::FSMEventArgs(FSMEvent event_value)
     : event(event_value),
       audio_data(NULL),
       engine_error(SPEECH_RECOGNITION_ERROR_NONE) {
 }
 
 SpeechRecognizerImpl::FSMEventArgs::FSMEventArgs(const FSMEventArgs& other) =
     default;
 
 SpeechRecognizerImpl::FSMEventArgs::~FSMEventArgs() {
 }
 
 }  // namespace content