Refactoring of chrome speech recognition architecture (CL1.6)

content/browser/speech/speech_recognizer_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_recognizer_impl.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/time.h"
 #include "content/browser/browser_main_loop.h"
@@ skipping 45 matching lines @@
     if (samples[i] <= -32767 || samples[i] >= 32767) {
       if (++clipping_samples > kThreshold)
         return true;
     }
   }
   return false;
 }
 
 }  // namespace
 
+// TODO(primiano) Create(...) is transitional (until we fix speech input
+// extensions) and should be removed soon. The manager should be the only one
+// knowing the existence of SpeechRecognizer(Impl), thus the only one in charge
+// of instantiating it.
 SpeechRecognizer* SpeechRecognizer::Create(
     SpeechRecognitionEventListener* listener,
-    int caller_id,
+    int session_id,
     const std::string& language,
     const std::string& grammar,
     net::URLRequestContextGetter* context_getter,
     bool filter_profanities,
     const std::string& hardware_info,
     const std::string& origin_url) {
   speech::GoogleOneShotRemoteEngineConfig remote_engine_config;
   remote_engine_config.language = language;
   remote_engine_config.grammar = grammar;
   remote_engine_config.audio_sample_rate =
       speech::SpeechRecognizerImpl::kAudioSampleRate;
   remote_engine_config.audio_num_bits_per_sample =
       speech::SpeechRecognizerImpl::kNumBitsPerAudioSample;
   remote_engine_config.filter_profanities = filter_profanities;
   remote_engine_config.hardware_info = hardware_info;
   remote_engine_config.origin_url = origin_url;
 
   // SpeechRecognizerImpl takes ownership of google_remote_engine.
   speech::GoogleOneShotRemoteEngine* google_remote_engine =
       new speech::GoogleOneShotRemoteEngine(context_getter);
   google_remote_engine->SetConfig(remote_engine_config);
 
   return new speech::SpeechRecognizerImpl(listener,
-                                          caller_id,
+                                          session_id,
                                           google_remote_engine);
 }
 
 namespace speech {
 
 const int SpeechRecognizerImpl::kAudioSampleRate = 16000;
 const ChannelLayout SpeechRecognizerImpl::kChannelLayout = CHANNEL_LAYOUT_MONO;
 const int SpeechRecognizerImpl::kNumBitsPerAudioSample = 16;
 const int SpeechRecognizerImpl::kNoSpeechTimeoutMs = 8000;
 const int SpeechRecognizerImpl::kEndpointerEstimationTimeMs = 300;
 
 COMPILE_ASSERT(SpeechRecognizerImpl::kNumBitsPerAudioSample % 8 == 0,
                kNumBitsPerAudioSample_must_be_a_multiple_of_8);
 
 SpeechRecognizerImpl::SpeechRecognizerImpl(
     SpeechRecognitionEventListener* listener,
-    int caller_id,
+    int session_id,
     SpeechRecognitionEngine* engine)
     : listener_(listener),
       testing_audio_manager_(NULL),
       recognition_engine_(engine),
       endpointer_(kAudioSampleRate),
-      caller_id_(caller_id),
+      session_id_(session_id),
       is_dispatching_event_(false),
       state_(STATE_IDLE) {
   DCHECK(listener_ != NULL);
   DCHECK(recognition_engine_ != 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();
@@ skipping 273 matching lines @@
   DCHECK(recognition_engine_.get() != NULL);
   DCHECK(!IsCapturingAudio());
   AudioManager* audio_manager = (testing_audio_manager_ != NULL) ?
                                  testing_audio_manager_ :
                                  BrowserMainLoop::GetAudioManager();
   DCHECK(audio_manager != NULL);
 
   DVLOG(1) << "SpeechRecognizerImpl starting audio capture.";
   num_samples_recorded_ = 0;
   audio_level_ = 0;
-  listener_->OnRecognitionStart(caller_id_);
+  listener_->OnRecognitionStart(session_id_);
 
   if (!audio_manager->HasAudioInputDevices()) {
     return AbortWithError(SpeechRecognitionError(
         content::SPEECH_RECOGNITION_ERROR_AUDIO,
         content::SPEECH_AUDIO_ERROR_DETAILS_NO_MIC));
   }
 
   if (audio_manager->IsRecordingInProcess()) {
     return AbortWithError(SpeechRecognitionError(
         content::SPEECH_RECOGNITION_ERROR_AUDIO,
@@ skipping 20 matching lines @@
   audio_controller_->Record();
   return STATE_STARTING;
 }
 
 SpeechRecognizerImpl::FSMState
 SpeechRecognizerImpl::StartRecognitionEngine(const FSMEventArgs& event_args) {
   // This is the first audio packet captured, so the recognition engine is
   // started and the delegate notified about the event.
   DCHECK(recognition_engine_.get() != NULL);
   recognition_engine_->StartRecognition();
-  listener_->OnAudioStart(caller_id_);
+  listener_->OnAudioStart(session_id_);
 
   // This is a little hack, since TakeAudioChunk() is already called by
   // ProcessAudioPipeline(). It is the best tradeoff, unless we allow dropping
   // the first audio chunk captured after opening the audio device.
   recognition_engine_->TakeAudioChunk(*(event_args.audio_data));
   return STATE_ESTIMATING_ENVIRONMENT;
 }
 
 SpeechRecognizerImpl::FSMState
 SpeechRecognizerImpl::WaitEnvironmentEstimationCompletion(const FSMEventArgs&) {
   DCHECK(endpointer_.IsEstimatingEnvironment());
   if (GetElapsedTimeMs() >= kEndpointerEstimationTimeMs) {
     endpointer_.SetUserInputMode();
-    listener_->OnEnvironmentEstimationComplete(caller_id_);
+    listener_->OnEnvironmentEstimationComplete(session_id_);
     return STATE_WAITING_FOR_SPEECH;
   } else {
     return STATE_ESTIMATING_ENVIRONMENT;
   }
 }
 
 SpeechRecognizerImpl::FSMState
 SpeechRecognizerImpl::DetectUserSpeechOrTimeout(const FSMEventArgs&) {
   if (endpointer_.DidStartReceivingSpeech()) {
-    listener_->OnSoundStart(caller_id_);
+    listener_->OnSoundStart(session_id_);
     return STATE_RECOGNIZING;
   } else if (GetElapsedTimeMs() >= kNoSpeechTimeoutMs) {
     return AbortWithError(
         SpeechRecognitionError(content::SPEECH_RECOGNITION_ERROR_NO_SPEECH));
   }
   return STATE_WAITING_FOR_SPEECH;
 }
 
 SpeechRecognizerImpl::FSMState
 SpeechRecognizerImpl::DetectEndOfSpeech(const FSMEventArgs& event_args) {
   if (endpointer_.speech_input_complete()) {
     return StopCaptureAndWaitForResult(event_args);
   }
   return STATE_RECOGNIZING;
 }
 
 SpeechRecognizerImpl::FSMState
 SpeechRecognizerImpl::StopCaptureAndWaitForResult(const FSMEventArgs&) {
   DCHECK(state_ >= STATE_ESTIMATING_ENVIRONMENT && state_ <= STATE_RECOGNIZING);
 
   DVLOG(1) << "Concluding recognition";
   CloseAudioControllerAsynchronously();
   recognition_engine_->AudioChunksEnded();
 
   if (state_ > STATE_WAITING_FOR_SPEECH)
-    listener_->OnSoundEnd(caller_id_);
+    listener_->OnSoundEnd(session_id_);
 
-  listener_->OnAudioEnd(caller_id_);
+  listener_->OnAudioEnd(session_id_);
   return STATE_WAITING_FINAL_RESULT;
 }
 
 SpeechRecognizerImpl::FSMState
 SpeechRecognizerImpl::Abort(const FSMEventArgs& event_args) {
   // TODO(primiano) Should raise SPEECH_RECOGNITION_ERROR_ABORTED in lack of
   // other specific error sources (so that it was an explicit abort request).
   // However, SPEECH_RECOGNITION_ERROR_ABORTED is not currently caught by
   // ChromeSpeechRecognitionManagerDelegate and would cause an exception.
   // JS support will probably need it in future.
@@ skipping 18 matching lines @@
 
   DVLOG(1) << "SpeechRecognizerImpl canceling recognition. ";
 
   // The recognition engine is initialized only after STATE_STARTING.
   if (state_ > STATE_STARTING) {
     DCHECK(recognition_engine_.get() != NULL);
     recognition_engine_->EndRecognition();
   }
 
   if (state_ > STATE_WAITING_FOR_SPEECH && state_ < STATE_WAITING_FINAL_RESULT)
-    listener_->OnSoundEnd(caller_id_);
+    listener_->OnSoundEnd(session_id_);
 
   if (state_ > STATE_STARTING && state_ < STATE_WAITING_FINAL_RESULT)
-    listener_->OnAudioEnd(caller_id_);
+    listener_->OnAudioEnd(session_id_);
 
   if (error != NULL)
-    listener_->OnRecognitionError(caller_id_, *error);
+    listener_->OnRecognitionError(session_id_, *error);
 
-  listener_->OnRecognitionEnd(caller_id_);
+  listener_->OnRecognitionEnd(session_id_);
 
   return STATE_IDLE;
 }
 
 SpeechRecognizerImpl::FSMState
 SpeechRecognizerImpl::ProcessIntermediateResult(const FSMEventArgs&) {
   // This is in preparation for future speech recognition functions.
   NOTREACHED();
   return state_;
 }
 
 SpeechRecognizerImpl::FSMState
 SpeechRecognizerImpl::ProcessFinalResult(const FSMEventArgs& event_args) {
   const SpeechRecognitionResult& result = event_args.engine_result;
   DVLOG(1) << "Got valid result";
   recognition_engine_->EndRecognition();
-  listener_->OnRecognitionResult(caller_id_, result);
-  listener_->OnRecognitionEnd(caller_id_);
+  listener_->OnRecognitionResult(session_id_, result);
+  listener_->OnRecognitionEnd(session_id_);
   return STATE_IDLE;
 }
 
 SpeechRecognizerImpl::FSMState
 SpeechRecognizerImpl::DoNothing(const FSMEventArgs&) const {
   return state_;  // Just keep the current state.
 }
 
 SpeechRecognizerImpl::FSMState
 SpeechRecognizerImpl::NotFeasible(const FSMEventArgs& event_args) {
@@ skipping 30 matching lines @@
   const float smoothing_factor = (level > audio_level_) ? kUpSmoothingFactor :
                                                           kDownSmoothingFactor;
   audio_level_ += (level - audio_level_) * smoothing_factor;
 
   float noise_level = (endpointer_.NoiseLevelDb() - kAudioMeterMinDb) /
       (kAudioMeterDbRange / kAudioMeterRangeMaxUnclipped);
   noise_level = std::min(std::max(0.0f, noise_level),
                          kAudioMeterRangeMaxUnclipped);
 
   listener_->OnAudioLevelsChange(
-      caller_id_, clip_detected ? 1.0f : audio_level_, noise_level);
+      session_id_, clip_detected ? 1.0f : audio_level_, noise_level);
 }
 
 const SpeechRecognitionEngine&
     SpeechRecognizerImpl::recognition_engine() const {
   return *(recognition_engine_.get());
 }
 
 void SpeechRecognizerImpl::SetAudioManagerForTesting(
     AudioManager* audio_manager) {
   testing_audio_manager_ = audio_manager;
 }
 
 SpeechRecognizerImpl::FSMEventArgs::FSMEventArgs(FSMEvent event_value)
     : event(event_value),
       audio_error_code(0),
       audio_data(NULL),
       engine_error(content::SPEECH_RECOGNITION_ERROR_NONE) {
 }
 
 SpeechRecognizerImpl::FSMEventArgs::~FSMEventArgs() {
 }
 
 }  // namespace speech