Switch Speech Recognition to asynchronous callback-based AudioManager interactions.

content/browser/speech/speech_recognizer_impl.h

 // 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.
 
 #ifndef CONTENT_BROWSER_SPEECH_SPEECH_RECOGNIZER_IMPL_H_
 #define CONTENT_BROWSER_SPEECH_SPEECH_RECOGNIZER_IMPL_H_
 
 #include <memory>
 #include <string>
 
 #include "base/macros.h"
+#include "base/memory/weak_ptr.h"
 #include "content/browser/speech/endpointer/endpointer.h"
 #include "content/browser/speech/speech_recognition_engine.h"
 #include "content/browser/speech/speech_recognizer.h"
 #include "content/public/common/speech_recognition_error.h"
 #include "content/public/common/speech_recognition_result.h"
 #include "media/audio/audio_input_controller.h"
 #include "media/audio/audio_logging.h"
 #include "net/url_request/url_request_context_getter.h"
 
 namespace media {
 class AudioBus;
-class AudioManager;
+class AudioSystem;
 }
 
 namespace content {
 
 class SpeechRecognitionEventListener;
 
 // Handles speech recognition for a session (identified by |session_id|), taking
 // care of audio capture, silence detection/endpointer and interaction with the
 // SpeechRecognitionEngine.
 class CONTENT_EXPORT SpeechRecognizerImpl
     : public SpeechRecognizer,
       public media::AudioInputController::EventHandler,
       public media::AudioInputController::SyncWriter,
       public NON_EXPORTED_BASE(SpeechRecognitionEngine::Delegate) {
  public:
   static const int kAudioSampleRate;
   static const media::ChannelLayout kChannelLayout;
   static const int kNumBitsPerAudioSample;
   static const int kNoSpeechTimeoutMs;
   static const int kEndpointerEstimationTimeMs;
 
-  static void SetAudioManagerForTesting(media::AudioManager* audio_manager);
+  static void SetAudioSystemForTesting(media::AudioSystem* audio_system);
 
   SpeechRecognizerImpl(SpeechRecognitionEventListener* listener,
+                       media::AudioSystem* audio_system,
                        int session_id,
                        bool continuous,
                        bool provisional_results,
                        SpeechRecognitionEngine* engine);
 
   void StartRecognition(const std::string& device_id) override;
   void AbortRecognition() override;
   void StopAudioCapture() override;
   bool IsActive() const override;
   bool IsCapturingAudio() const override;
   const SpeechRecognitionEngine& recognition_engine() const;
 
  private:
   friend class SpeechRecognizerTest;
 
   enum FSMState {
     STATE_IDLE = 0,
+    STATE_PREPARING,
     STATE_STARTING,
     STATE_ESTIMATING_ENVIRONMENT,
     STATE_WAITING_FOR_SPEECH,
     STATE_RECOGNIZING,
     STATE_WAITING_FINAL_RESULT,
     STATE_ENDED,
     STATE_MAX_VALUE = STATE_ENDED
   };
 
   enum FSMEvent {
     EVENT_ABORT = 0,
+    EVENT_PREPARE,
     EVENT_START,
     EVENT_STOP_CAPTURE,
     EVENT_AUDIO_DATA,
     EVENT_ENGINE_RESULT,
     EVENT_ENGINE_ERROR,
     EVENT_AUDIO_ERROR,
     EVENT_MAX_VALUE = EVENT_AUDIO_ERROR
   };
 
   struct FSMEventArgs {
@@ skipping 12 matching lines @@
   // Entry point for pushing any new external event into the recognizer FSM.
   void DispatchEvent(const FSMEventArgs& event_args);
 
   // Defines the behavior of the recognizer FSM, selecting the appropriate
   // transition according to the current state and event.
   FSMState ExecuteTransitionAndGetNextState(const FSMEventArgs& args);
 
   // Process a new audio chunk in the audio pipeline (endpointer, vumeter, etc).
   void ProcessAudioPipeline(const AudioChunk& raw_audio);
 
+  // Callback from AudioSystem.
+  void OnDeviceInfo(const media::AudioParameters& params);
+
   // The methods below handle transitions of the recognizer FSM.
+  FSMState PrepareRecognition(const FSMEventArgs&);
   FSMState StartRecording(const FSMEventArgs& event_args);
   FSMState StartRecognitionEngine(const FSMEventArgs& event_args);
   FSMState WaitEnvironmentEstimationCompletion(const FSMEventArgs& event_args);
   FSMState DetectUserSpeechOrTimeout(const FSMEventArgs& event_args);
   FSMState StopCaptureAndWaitForResult(const FSMEventArgs& event_args);
   FSMState ProcessIntermediateResult(const FSMEventArgs& event_args);
   FSMState ProcessFinalResult(const FSMEventArgs& event_args);
   FSMState AbortSilently(const FSMEventArgs& event_args);
   FSMState AbortWithError(const FSMEventArgs& event_args);
   FSMState Abort(const SpeechRecognitionError& error);
@@ skipping 27 matching lines @@
              uint32_t hardware_delay_bytes) override;
   void Close() override;
 
   // SpeechRecognitionEngineDelegate methods.
   void OnSpeechRecognitionEngineResults(
       const SpeechRecognitionResults& results) override;
   void OnSpeechRecognitionEngineEndOfUtterance() override;
   void OnSpeechRecognitionEngineError(
       const SpeechRecognitionError& error) override;
 
-  static media::AudioManager* audio_manager_for_tests_;
+  media::AudioSystem* GetAudioSystem();
 
+  // Substitutes the real audio system in browser tests.
+  static media::AudioSystem* audio_system_for_tests_;
+  media::AudioSystem* audio_system_;
   std::unique_ptr<SpeechRecognitionEngine> recognition_engine_;
   Endpointer endpointer_;
   scoped_refptr<media::AudioInputController> audio_controller_;
   std::unique_ptr<media::AudioLog> audio_log_;
   int num_samples_recorded_;
   float audio_level_;
   bool is_dispatching_event_;
   bool provisional_results_;
   bool end_of_utterance_;
   FSMState state_;
   std::string device_id_;
+  media::AudioParameters device_params_;
 
   class OnDataConverter;
 
   // Converts data between native input format and a WebSpeech specific
   // output format.
   std::unique_ptr<SpeechRecognizerImpl::OnDataConverter> audio_converter_;
 
+  base::WeakPtrFactory<SpeechRecognizerImpl> weak_ptr_factory_;
   DISALLOW_COPY_AND_ASSIGN(SpeechRecognizerImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SPEECH_SPEECH_RECOGNIZER_IMPL_H_