Refactoring of chrome speech recognition architecture (CL1.2)

content/browser/speech/speech_recognizer_impl_unittest.cc

Index: content/browser/speech/speech_recognizer_impl_unittest.cc
diff --git a/content/browser/speech/speech_recognizer_impl_unittest.cc b/content/browser/speech/speech_recognizer_impl_unittest.cc
index baf3a3ef6623de76b3b3cd342ae9ece06050f491..1c9c9b13ce98c55b37d2f6758352d9c4d60dea7a 100644
--- a/content/browser/speech/speech_recognizer_impl_unittest.cc
+++ b/content/browser/speech/speech_recognizer_impl_unittest.cc
@@ -6,7 +6,7 @@
 
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/speech/speech_recognizer_impl.h"
-#include "content/public/browser/speech_recognizer_delegate.h"
+#include "content/public/browser/speech_recognition_event_listener.h"
 #include "content/test/test_url_fetcher_factory.h"
 #include "media/audio/audio_manager.h"
 #include "media/audio/fake_audio_input_stream.h"
@@ -66,16 +66,16 @@ class MockAudioManager : public AudioManager {
 
 namespace speech {
 
-class SpeechRecognizerTest : public content::SpeechRecognizerDelegate,
-                             public testing::Test {
+class SpeechRecognizerImplTest : public content::SpeechRecognitionEventListener,
+                                 public testing::Test {
  public:
-  SpeechRecognizerTest()
+  SpeechRecognizerImplTest()
       : io_thread_(BrowserThread::IO, &message_loop_),
         audio_manager_(new MockAudioManager()),
-        recording_complete_(false),
-        recognition_complete_(false),
+        audio_closed_(false),
+        recognition_ended_(false),
         result_received_(false),
-        audio_received_(false),
+        audio_started_(false),
         error_(content::SPEECH_RECOGNITION_ERROR_NONE),
         volume_(-1.0f) {
     recognizer_ = new SpeechRecognizerImpl(
@@ -90,44 +90,41 @@ class SpeechRecognizerTest : public content::SpeechRecognizerDelegate,
     audio_packet_.resize(audio_packet_length_bytes);
   }
 
-  // Overridden from content::SpeechRecognizerDelegate:
-  virtual void SetRecognitionResult(
-      int caller_id,
-      const content::SpeechRecognitionResult& result) OVERRIDE {
-    result_received_ = true;
-  }
-
-  virtual void DidCompleteRecording(int caller_id) OVERRIDE {
-    recording_complete_ = true;
+  // Overridden from content::SpeechRecognitionEventListener:
+  virtual void OnAudioStart(int session_id) OVERRIDE {
+    audio_started_ = true;
   }
 
-  virtual void DidCompleteRecognition(int caller_id) OVERRIDE {
-    recognition_complete_ = true;
+  virtual void OnAudioEnd(int session_id) OVERRIDE {
+    audio_closed_ = true;

[Satish, 2012/03/13 15:30:15]

use audio_ended_ to match audio_started_ above?

[Primiano Tucci (use gerrit), 2012/03/14 09:40:35]

Right.

   }
 
-  virtual void DidCompleteEnvironmentEstimation(int caller_id) OVERRIDE {
+  virtual void OnRecognitionResult(
+      int session_id, const content::SpeechRecognitionResult& result) OVERRIDE {
+    result_received_ = true;
   }
 
-  virtual void DidStartReceivingAudio(int caller_id) OVERRIDE {
-    audio_received_ = true;
+  virtual void OnRecognitionError(
+      int session_id,
+      const content::SpeechRecognitionErrorCode& error) OVERRIDE {
+    error_ = error;
   }
 
-  virtual void DidStartReceivingSpeech(int caller_id) OVERRIDE {
+  virtual void OnAudioLevelsChanged(int session_id, float volume,
+                                    float noise_volume) OVERRIDE {
+    volume_ = volume;
+    noise_volume_ = noise_volume;
   }
 
-  virtual void DidStopReceivingSpeech(int caller_id) OVERRIDE {
+  virtual void OnRecognitionEnd(int session_id, bool success) OVERRIDE {
+    recognition_ended_ = true;
   }
 
-  virtual void OnRecognizerError(
-      int caller_id, content::SpeechRecognitionErrorCode error) OVERRIDE {
-    error_ = error;
-  }
+  virtual void OnRecognitionStart(int session_id) OVERRIDE {}
+  virtual void OnEnvironmentEstimationComplete(int session_id) OVERRIDE {}
+  virtual void OnSoundStart(int session_id) OVERRIDE {}
+  virtual void OnSoundEnd(int session_id) OVERRIDE {}
 

[Satish, 2012/03/13 15:30:15]

remove extra newline

[Primiano Tucci (use gerrit), 2012/03/14 09:40:35]

Done.

-  virtual void SetInputVolume(int caller_id, float volume,
-                              float noise_volume) OVERRIDE {
-    volume_ = volume;
-    noise_volume_ = noise_volume;
-  }
 
   // testing::Test methods.
   virtual void SetUp() OVERRIDE {
@@ -159,10 +156,10 @@ class SpeechRecognizerTest : public content::SpeechRecognizerDelegate,
   BrowserThreadImpl io_thread_;
   scoped_refptr<SpeechRecognizerImpl> recognizer_;
   scoped_ptr<AudioManager> audio_manager_;
-  bool recording_complete_;
-  bool recognition_complete_;
+  bool audio_closed_;
+  bool recognition_ended_;
   bool result_received_;
-  bool audio_received_;
+  bool audio_started_;
   content::SpeechRecognitionErrorCode error_;
   TestURLFetcherFactory url_fetcher_factory_;
   TestAudioInputControllerFactory audio_input_controller_factory_;
@@ -171,33 +168,33 @@ class SpeechRecognizerTest : public content::SpeechRecognizerDelegate,
   float noise_volume_;
 };
 
-TEST_F(SpeechRecognizerTest, StopNoData) {
+TEST_F(SpeechRecognizerImplTest, StopNoData) {
   // Check for callbacks when stopping record before any audio gets recorded.
-  EXPECT_TRUE(recognizer_->StartRecording());
-  recognizer_->CancelRecognition();
-  EXPECT_FALSE(recording_complete_);
-  EXPECT_FALSE(recognition_complete_);
+  EXPECT_TRUE(recognizer_->StartRecognition());
+  recognizer_->AbortRecognition();
+  EXPECT_FALSE(audio_closed_);
+  EXPECT_FALSE(recognition_ended_);
   EXPECT_FALSE(result_received_);
-  EXPECT_FALSE(audio_received_);
+  EXPECT_FALSE(audio_started_);
   EXPECT_EQ(content::SPEECH_RECOGNITION_ERROR_NONE, error_);
 }
 
-TEST_F(SpeechRecognizerTest, CancelNoData) {
+TEST_F(SpeechRecognizerImplTest, CancelNoData) {
   // Check for callbacks when canceling recognition before any audio gets
   // recorded.
-  EXPECT_TRUE(recognizer_->StartRecording());
-  recognizer_->StopRecording();
-  EXPECT_TRUE(recording_complete_);
-  EXPECT_TRUE(recognition_complete_);
+  EXPECT_TRUE(recognizer_->StartRecognition());
+  recognizer_->StopAudioCapture();
+  EXPECT_TRUE(audio_closed_);
+  EXPECT_TRUE(recognition_ended_);
   EXPECT_FALSE(result_received_);
-  EXPECT_FALSE(audio_received_);
+  EXPECT_FALSE(audio_started_);
   EXPECT_EQ(content::SPEECH_RECOGNITION_ERROR_NONE, error_);
 }
 
-TEST_F(SpeechRecognizerTest, StopWithData) {
+TEST_F(SpeechRecognizerImplTest, StopWithData) {
   // Start recording, give some data and then stop. This should wait for the
   // network callback to arrive before completion.
-  EXPECT_TRUE(recognizer_->StartRecording());
+  EXPECT_TRUE(recognizer_->StartRecognition());
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
@@ -216,10 +213,10 @@ TEST_F(SpeechRecognizerTest, StopWithData) {
     EXPECT_EQ(i + 1, fetcher->upload_chunks().size());
   }
 
-  recognizer_->StopRecording();
-  EXPECT_TRUE(audio_received_);
-  EXPECT_TRUE(recording_complete_);
-  EXPECT_FALSE(recognition_complete_);
+  recognizer_->StopAudioCapture();
+  EXPECT_TRUE(audio_started_);
+  EXPECT_TRUE(audio_closed_);
+  EXPECT_FALSE(recognition_ended_);
   EXPECT_FALSE(result_received_);
   EXPECT_EQ(content::SPEECH_RECOGNITION_ERROR_NONE, error_);
 
@@ -236,34 +233,34 @@ TEST_F(SpeechRecognizerTest, StopWithData) {
       "{\"status\":0,\"hypotheses\":[{\"utterance\":\"123\"}]}");
   fetcher->delegate()->OnURLFetchComplete(fetcher);
 
-  EXPECT_TRUE(recognition_complete_);
+  EXPECT_TRUE(recognition_ended_);
   EXPECT_TRUE(result_received_);
   EXPECT_EQ(content::SPEECH_RECOGNITION_ERROR_NONE, error_);
 }
 
-TEST_F(SpeechRecognizerTest, CancelWithData) {
+TEST_F(SpeechRecognizerImplTest, CancelWithData) {
   // Start recording, give some data and then cancel. This should create
   // a network request but give no callbacks.
-  EXPECT_TRUE(recognizer_->StartRecording());
+  EXPECT_TRUE(recognizer_->StartRecognition());
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
   controller->event_handler()->OnData(controller, &audio_packet_[0],
                                       audio_packet_.size());
   MessageLoop::current()->RunAllPending();
-  recognizer_->CancelRecognition();
+  recognizer_->AbortRecognition();
   ASSERT_TRUE(url_fetcher_factory_.GetFetcherByID(0));
-  EXPECT_TRUE(audio_received_);
-  EXPECT_FALSE(recording_complete_);
-  EXPECT_FALSE(recognition_complete_);
+  EXPECT_TRUE(audio_started_);
+  EXPECT_FALSE(audio_closed_);
+  EXPECT_FALSE(recognition_ended_);
   EXPECT_FALSE(result_received_);
   EXPECT_EQ(content::SPEECH_RECOGNITION_ERROR_NONE, error_);
 }
 
-TEST_F(SpeechRecognizerTest, ConnectionError) {
+TEST_F(SpeechRecognizerImplTest, ConnectionError) {
   // Start recording, give some data and then stop. Issue the network callback
   // with a connection error and verify that the recognizer bubbles the error up
-  EXPECT_TRUE(recognizer_->StartRecording());
+  EXPECT_TRUE(recognizer_->StartRecognition());
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
@@ -273,10 +270,10 @@ TEST_F(SpeechRecognizerTest, ConnectionError) {
   TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
-  recognizer_->StopRecording();
-  EXPECT_TRUE(audio_received_);
-  EXPECT_TRUE(recording_complete_);
-  EXPECT_FALSE(recognition_complete_);
+  recognizer_->StopAudioCapture();
+  EXPECT_TRUE(audio_started_);
+  EXPECT_TRUE(audio_closed_);
+  EXPECT_FALSE(recognition_ended_);
   EXPECT_FALSE(result_received_);
   EXPECT_EQ(content::SPEECH_RECOGNITION_ERROR_NONE, error_);
 
@@ -290,15 +287,15 @@ TEST_F(SpeechRecognizerTest, ConnectionError) {
   fetcher->SetResponseString("");
   fetcher->delegate()->OnURLFetchComplete(fetcher);
 
-  EXPECT_FALSE(recognition_complete_);
+  EXPECT_FALSE(recognition_ended_);
   EXPECT_FALSE(result_received_);
   EXPECT_EQ(content::SPEECH_RECOGNITION_ERROR_NETWORK, error_);
 }
 
-TEST_F(SpeechRecognizerTest, ServerError) {
+TEST_F(SpeechRecognizerImplTest, ServerError) {
   // Start recording, give some data and then stop. Issue the network callback
   // with a 500 error and verify that the recognizer bubbles the error up
-  EXPECT_TRUE(recognizer_->StartRecording());
+  EXPECT_TRUE(recognizer_->StartRecognition());
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
@@ -308,10 +305,10 @@ TEST_F(SpeechRecognizerTest, ServerError) {
   TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
-  recognizer_->StopRecording();
-  EXPECT_TRUE(audio_received_);
-  EXPECT_TRUE(recording_complete_);
-  EXPECT_FALSE(recognition_complete_);
+  recognizer_->StopAudioCapture();
+  EXPECT_TRUE(audio_started_);
+  EXPECT_TRUE(audio_closed_);
+  EXPECT_FALSE(recognition_ended_);
   EXPECT_FALSE(result_received_);
   EXPECT_EQ(content::SPEECH_RECOGNITION_ERROR_NONE, error_);
 
@@ -324,30 +321,30 @@ TEST_F(SpeechRecognizerTest, ServerError) {
   fetcher->SetResponseString("Internal Server Error");
   fetcher->delegate()->OnURLFetchComplete(fetcher);
 
-  EXPECT_FALSE(recognition_complete_);
+  EXPECT_FALSE(recognition_ended_);
   EXPECT_FALSE(result_received_);
   EXPECT_EQ(content::SPEECH_RECOGNITION_ERROR_NETWORK, error_);
 }
 
-TEST_F(SpeechRecognizerTest, AudioControllerErrorNoData) {
+TEST_F(SpeechRecognizerImplTest, AudioControllerErrorNoData) {
   // Check if things tear down properly if AudioInputController threw an error.
-  EXPECT_TRUE(recognizer_->StartRecording());
+  EXPECT_TRUE(recognizer_->StartRecognition());
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
   controller->event_handler()->OnError(controller, 0);
   MessageLoop::current()->RunAllPending();
-  EXPECT_FALSE(audio_received_);
-  EXPECT_FALSE(recording_complete_);
-  EXPECT_FALSE(recognition_complete_);
+  EXPECT_FALSE(audio_started_);
+  EXPECT_FALSE(audio_closed_);
+  EXPECT_FALSE(recognition_ended_);
   EXPECT_FALSE(result_received_);
   EXPECT_EQ(content::SPEECH_RECOGNITION_ERROR_AUDIO, error_);
 }
 
-TEST_F(SpeechRecognizerTest, AudioControllerErrorWithData) {
+TEST_F(SpeechRecognizerImplTest, AudioControllerErrorWithData) {
   // Check if things tear down properly if AudioInputController threw an error
   // after giving some audio data.
-  EXPECT_TRUE(recognizer_->StartRecording());
+  EXPECT_TRUE(recognizer_->StartRecognition());
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
@@ -356,17 +353,17 @@ TEST_F(SpeechRecognizerTest, AudioControllerErrorWithData) {
   controller->event_handler()->OnError(controller, 0);
   MessageLoop::current()->RunAllPending();
   ASSERT_TRUE(url_fetcher_factory_.GetFetcherByID(0));
-  EXPECT_TRUE(audio_received_);
-  EXPECT_FALSE(recording_complete_);
-  EXPECT_FALSE(recognition_complete_);
+  EXPECT_TRUE(audio_started_);
+  EXPECT_FALSE(audio_closed_);
+  EXPECT_FALSE(recognition_ended_);
   EXPECT_FALSE(result_received_);
   EXPECT_EQ(content::SPEECH_RECOGNITION_ERROR_AUDIO, error_);
 }
 
-TEST_F(SpeechRecognizerTest, NoSpeechCallbackIssued) {
+TEST_F(SpeechRecognizerImplTest, NoSpeechCallbackIssued) {
   // Start recording and give a lot of packets with audio samples set to zero.
   // This should trigger the no-speech detector and issue a callback.
-  EXPECT_TRUE(recognizer_->StartRecording());
+  EXPECT_TRUE(recognizer_->StartRecognition());
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
@@ -381,19 +378,19 @@ TEST_F(SpeechRecognizerTest, NoSpeechCallbackIssued) {
                                         audio_packet_.size());
   }
   MessageLoop::current()->RunAllPending();
-  EXPECT_TRUE(audio_received_);
-  EXPECT_FALSE(recording_complete_);
-  EXPECT_FALSE(recognition_complete_);
+  EXPECT_TRUE(audio_started_);
+  EXPECT_FALSE(audio_closed_);
+  EXPECT_FALSE(recognition_ended_);
   EXPECT_FALSE(result_received_);
   EXPECT_EQ(content::SPEECH_RECOGNITION_ERROR_NO_SPEECH, error_);
 }
 
-TEST_F(SpeechRecognizerTest, NoSpeechCallbackNotIssued) {
+TEST_F(SpeechRecognizerImplTest, NoSpeechCallbackNotIssued) {
   // Start recording and give a lot of packets with audio samples set to zero
   // and then some more with reasonably loud audio samples. This should be
   // treated as normal speech input and the no-speech detector should not get
   // triggered.
-  EXPECT_TRUE(recognizer_->StartRecording());
+  EXPECT_TRUE(recognizer_->StartRecognition());
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
@@ -417,18 +414,18 @@ TEST_F(SpeechRecognizerTest, NoSpeechCallbackNotIssued) {
 
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(content::SPEECH_RECOGNITION_ERROR_NONE, error_);
-  EXPECT_TRUE(audio_received_);
-  EXPECT_FALSE(recording_complete_);
-  EXPECT_FALSE(recognition_complete_);
-  recognizer_->CancelRecognition();
+  EXPECT_TRUE(audio_started_);
+  EXPECT_FALSE(audio_closed_);
+  EXPECT_FALSE(recognition_ended_);
+  recognizer_->AbortRecognition();
 }
 
-TEST_F(SpeechRecognizerTest, SetInputVolumeCallback) {
+TEST_F(SpeechRecognizerImplTest, SetInputVolumeCallback) {
   // Start recording and give a lot of packets with audio samples set to zero
   // and then some more with reasonably loud audio samples. Check that we don't
   // get the callback during estimation phase, then get zero for the silence
   // samples and proper volume for the loud audio.
-  EXPECT_TRUE(recognizer_->StartRecording());
+  EXPECT_TRUE(recognizer_->StartRecognition());
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
@@ -460,9 +457,9 @@ TEST_F(SpeechRecognizerTest, SetInputVolumeCallback) {
   EXPECT_FLOAT_EQ(0.75071919f, noise_volume_);
 
   EXPECT_EQ(content::SPEECH_RECOGNITION_ERROR_NONE, error_);
-  EXPECT_FALSE(recording_complete_);
-  EXPECT_FALSE(recognition_complete_);
-  recognizer_->CancelRecognition();
+  EXPECT_FALSE(audio_closed_);
+  EXPECT_FALSE(recognition_ended_);
+  recognizer_->AbortRecognition();
 }
 
 }  // namespace speech