Small refactor to media architecture in order to allow end-to-end tests.

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/basictypes.h"
 #include "base/bind.h"
 #include "base/time.h"
 #include "content/browser/browser_main_loop.h"
@@ skipping 55 matching lines @@
 
 }  // namespace
 
 namespace speech {
 
 const int SpeechRecognizer::kAudioSampleRate = 16000;
 const ChannelLayout SpeechRecognizer::kChannelLayout = CHANNEL_LAYOUT_MONO;
 const int SpeechRecognizer::kNumBitsPerAudioSample = 16;
 const int SpeechRecognizer::kNoSpeechTimeoutMs = 8000;
 const int SpeechRecognizer::kEndpointerEstimationTimeMs = 300;
+media::AudioManager* SpeechRecognizer::audio_manager_for_tests_ = NULL;
 
 COMPILE_ASSERT(SpeechRecognizer::kNumBitsPerAudioSample % 8 == 0,
                kNumBitsPerAudioSample_must_be_a_multiple_of_8);
 
 SpeechRecognizer::SpeechRecognizer(
     SpeechRecognitionEventListener* listener,
     int session_id,
     bool is_single_shot,
     SpeechRecognitionEngine* engine)
     : listener_(listener),
-      testing_audio_manager_(NULL),
       recognition_engine_(engine),
       endpointer_(kAudioSampleRate),
       session_id_(session_id),
       is_dispatching_event_(false),
       is_single_shot_(is_single_shot),
       state_(STATE_IDLE) {
   DCHECK(listener_ != NULL);
   DCHECK(recognition_engine_ != NULL);
   if (is_single_shot) {
     // In single shot recognition, the session is automatically ended after:
@@ skipping 138 matching lines @@
   scoped_refptr<SpeechRecognizer> me(this);
 
   if (event_args.event == EVENT_AUDIO_DATA) {
     DCHECK(event_args.audio_data.get() != NULL);
     ProcessAudioPipeline(*event_args.audio_data);
   }
 
   // The audio pipeline must be processed before the event dispatch, otherwise
   // it would take actions according to the future state instead of the current.
   state_ = ExecuteTransitionAndGetNextState(event_args);
-
   is_dispatching_event_ = false;
 }
 
 SpeechRecognizer::FSMState
 SpeechRecognizer::ExecuteTransitionAndGetNextState(
     const FSMEventArgs& event_args) {
   const FSMEvent event = event_args.event;
   switch (state_) {
     case STATE_IDLE:
       switch (event) {
@@ skipping 130 matching lines @@
   if (route_to_sr_engine) {
     DCHECK(recognition_engine_.get() != NULL);
     recognition_engine_->TakeAudioChunk(raw_audio);
   }
 }
 
 SpeechRecognizer::FSMState
 SpeechRecognizer::StartRecording(const FSMEventArgs&) {
   DCHECK(recognition_engine_.get() != NULL);
   DCHECK(!IsCapturingAudio());
-  AudioManager* audio_manager = (testing_audio_manager_ != NULL) ?
-                                 testing_audio_manager_ :
+  AudioManager* audio_manager = (audio_manager_for_tests_ != NULL) ?
+                                 audio_manager_for_tests_ :
                                  BrowserMainLoop::GetAudioManager();
   DCHECK(audio_manager != NULL);
 
   DVLOG(1) << "SpeechRecognizer starting audio capture.";
   num_samples_recorded_ = 0;
   audio_level_ = 0;
   listener_->OnRecognitionStart(session_id_);
 
   if (!audio_manager->HasAudioInputDevices()) {
     return Abort(SpeechRecognitionError(
@@ skipping 71 matching lines @@
 SpeechRecognizer::DetectEndOfSpeech(const FSMEventArgs& event_args) {
   if (endpointer_.speech_input_complete())
     return StopCaptureAndWaitForResult(event_args);
   return STATE_RECOGNIZING;
 }
 
 SpeechRecognizer::FSMState
 SpeechRecognizer::StopCaptureAndWaitForResult(const FSMEventArgs&) {
   DCHECK(state_ >= STATE_ESTIMATING_ENVIRONMENT && state_ <= STATE_RECOGNIZING);
 
+  recognition_engine_->AudioChunksEnded();
+
   DVLOG(1) << "Concluding recognition";
   CloseAudioControllerAsynchronously();
-  recognition_engine_->AudioChunksEnded();
 
   if (state_ > STATE_WAITING_FOR_SPEECH)
     listener_->OnSoundEnd(session_id_);
 
   listener_->OnAudioEnd(session_id_);
   return STATE_WAITING_FINAL_RESULT;
 }
 
 SpeechRecognizer::FSMState
 SpeechRecognizer::AbortSilently(const FSMEventArgs& event_args) {
@@ skipping 140 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 SpeechRecognizer::SetAudioManagerForTesting(
+void SpeechRecognizer::SetAudioManagerForTests(
     AudioManager* audio_manager) {
-  testing_audio_manager_ = audio_manager;
+  audio_manager_for_tests_ = audio_manager;
 }
 
 SpeechRecognizer::FSMEventArgs::FSMEventArgs(FSMEvent event_value)
     : event(event_value),
       audio_error_code(0),
       audio_data(NULL),
       engine_error(content::SPEECH_RECOGNITION_ERROR_NONE) {
 }
 
 SpeechRecognizer::FSMEventArgs::~FSMEventArgs() {
 }
 
 }  // namespace speech