Refactoring of chrome speech recognition architecture (CL1.3)

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 6f7b4fdd6660c39e6f560f0faa8a6f102fb866a9..3c3ff5246c26b075cf5f8fd534819bc9f0348f2d 100644
--- a/content/browser/speech/speech_recognizer_impl_unittest.cc
+++ b/content/browser/speech/speech_recognizer_impl_unittest.cc
@@ -5,6 +5,7 @@
 #include <vector>
 
 #include "content/browser/browser_thread_impl.h"
+#include "content/browser/speech/google_ssfe_remote_engine.h"
 #include "content/browser/speech/speech_recognizer_impl.h"
 #include "content/public/browser/speech_recognition_event_listener.h"
 #include "content/test/test_url_fetcher_factory.h"
@@ -16,6 +17,7 @@
 #include "net/url_request/url_request_status.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using base::MessageLoopProxy;
 using content::BrowserThread;
 using content::BrowserThreadImpl;
 using media::AudioInputController;
@@ -81,7 +83,7 @@ class MockAudioManager : public AudioManagerBase {
   scoped_ptr<base::Thread> audio_thread_;
   DISALLOW_COPY_AND_ASSIGN(MockAudioManager);
 };
-}  // namespace
+} // namespace

[hans, 2012/03/16 11:12:56]

the extra space should be there

[Primiano Tucci (use gerrit), 2012/03/16 15:03:42]

Done.

 
 
 namespace speech {
@@ -98,13 +100,21 @@ class SpeechRecognizerImplTest : public content::SpeechRecognitionEventListener,
         audio_started_(false),
         error_(content::SPEECH_RECOGNITION_ERROR_NONE),
         volume_(-1.0f) {
-    recognizer_ = new SpeechRecognizerImpl(
-        this, 1, std::string(), std::string(), NULL, false, std::string(),
-        std::string());
+    GoogleSSFERemoteEngine* sr_engine =
+        new GoogleSSFERemoteEngine(NULL /* URLRequestContextGetter */);
+    GoogleSSFERemoteEngineConfig config;
+    config.audio_num_bits_per_sample =
+        SpeechRecognizerImpl::kNumBitsPerAudioSample;
+    config.audio_sample_rate = SpeechRecognizerImpl::kAudioSampleRate;
+    config.filter_profanities = false;
+    sr_engine->SetConfiguration(config);
+
+    recognizer_ = new SpeechRecognizerImpl(this, 1, sr_engine);
     recognizer_->SetAudioManagerForTesting(audio_manager_.get());
+
     int audio_packet_length_bytes =
         (SpeechRecognizerImpl::kAudioSampleRate *
-         SpeechRecognizerImpl::kAudioPacketIntervalMs *
+         GoogleSSFERemoteEngine::kAudioPacketIntervalMs *
          ChannelLayoutToChannelCount(SpeechRecognizerImpl::kChannelLayout) *
          SpeechRecognizerImpl::kNumBitsPerAudioSample) / (8 * 1000);
     audio_packet_.resize(audio_packet_length_bytes);
@@ -125,13 +135,12 @@ class SpeechRecognizerImplTest : public content::SpeechRecognitionEventListener,
   }
 
   virtual void OnRecognitionError(
-      int caller_id,
-      const content::SpeechRecognitionErrorCode& error) OVERRIDE {
-    error_ = error;
+      int caller_id, const content::SpeechRecognitionError& error) OVERRIDE {
+    error_ = error.code;
   }
 
   virtual void OnAudioLevelsChange(int caller_id, float volume,
-                                   float noise_volume) OVERRIDE {
+                                    float noise_volume) OVERRIDE {
     volume_ = volume;
     noise_volume_ = noise_volume;
   }
@@ -189,10 +198,11 @@ class SpeechRecognizerImplTest : public content::SpeechRecognitionEventListener,
 
 TEST_F(SpeechRecognizerImplTest, StopNoData) {
   // Check for callbacks when stopping record before any audio gets recorded.
-  EXPECT_TRUE(recognizer_->StartRecognition());
+  recognizer_->StartRecognition();
   recognizer_->AbortRecognition();
+  MessageLoop::current()->RunAllPending();
   EXPECT_FALSE(audio_ended_);
-  EXPECT_FALSE(recognition_ended_);
+  EXPECT_TRUE(recognition_ended_);

[Primiano Tucci (use gerrit), 2012/03/15 09:14:36]

The event interface is slightly changed. AudioEnded and RecognitionEnded now are
always raised, in order to guarantee start/end closure.

   EXPECT_FALSE(result_received_);
   EXPECT_FALSE(audio_started_);
   EXPECT_EQ(content::SPEECH_RECOGNITION_ERROR_NONE, error_);
@@ -201,9 +211,10 @@ TEST_F(SpeechRecognizerImplTest, StopNoData) {
 TEST_F(SpeechRecognizerImplTest, CancelNoData) {
   // Check for callbacks when canceling recognition before any audio gets
   // recorded.
-  EXPECT_TRUE(recognizer_->StartRecognition());
+  recognizer_->StartRecognition();
   recognizer_->StopAudioCapture();
-  EXPECT_TRUE(audio_ended_);
+  MessageLoop::current()->RunAllPending();
+  EXPECT_FALSE(audio_ended_);
   EXPECT_TRUE(recognition_ended_);
   EXPECT_FALSE(result_received_);
   EXPECT_FALSE(audio_started_);
@@ -213,7 +224,8 @@ TEST_F(SpeechRecognizerImplTest, CancelNoData) {
 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_->StartRecognition());
+  recognizer_->StartRecognition();
+  MessageLoop::current()->RunAllPending();
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
@@ -233,6 +245,7 @@ TEST_F(SpeechRecognizerImplTest, StopWithData) {
   }
 
   recognizer_->StopAudioCapture();
+  MessageLoop::current()->RunAllPending();
   EXPECT_TRUE(audio_started_);
   EXPECT_TRUE(audio_ended_);
   EXPECT_FALSE(recognition_ended_);
@@ -251,16 +264,16 @@ TEST_F(SpeechRecognizerImplTest, StopWithData) {
   fetcher->SetResponseString(
       "{\"status\":0,\"hypotheses\":[{\"utterance\":\"123\"}]}");
   fetcher->delegate()->OnURLFetchComplete(fetcher);
-
+  MessageLoop::current()->RunAllPending();
   EXPECT_TRUE(recognition_ended_);
   EXPECT_TRUE(result_received_);
   EXPECT_EQ(content::SPEECH_RECOGNITION_ERROR_NONE, error_);
 }
 
 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_->StartRecognition());
+  // Start recording, give some data and then cancel.
+  recognizer_->StartRecognition();
+  MessageLoop::current()->RunAllPending();
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
@@ -268,10 +281,11 @@ TEST_F(SpeechRecognizerImplTest, CancelWithData) {
                                       audio_packet_.size());
   MessageLoop::current()->RunAllPending();
   recognizer_->AbortRecognition();
+  MessageLoop::current()->RunAllPending();
   ASSERT_TRUE(url_fetcher_factory_.GetFetcherByID(0));
   EXPECT_TRUE(audio_started_);
-  EXPECT_FALSE(audio_ended_);
-  EXPECT_FALSE(recognition_ended_);
+  EXPECT_TRUE(audio_ended_);
+  EXPECT_TRUE(recognition_ended_);
   EXPECT_FALSE(result_received_);
   EXPECT_EQ(content::SPEECH_RECOGNITION_ERROR_NONE, error_);
 }
@@ -279,7 +293,8 @@ TEST_F(SpeechRecognizerImplTest, CancelWithData) {
 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_->StartRecognition());
+  recognizer_->StartRecognition();
+  MessageLoop::current()->RunAllPending();
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
@@ -290,6 +305,7 @@ TEST_F(SpeechRecognizerImplTest, ConnectionError) {
   ASSERT_TRUE(fetcher);
 
   recognizer_->StopAudioCapture();
+  MessageLoop::current()->RunAllPending();
   EXPECT_TRUE(audio_started_);
   EXPECT_TRUE(audio_ended_);
   EXPECT_FALSE(recognition_ended_);
@@ -305,8 +321,8 @@ TEST_F(SpeechRecognizerImplTest, ConnectionError) {
   fetcher->set_response_code(0);
   fetcher->SetResponseString("");
   fetcher->delegate()->OnURLFetchComplete(fetcher);
-
-  EXPECT_FALSE(recognition_ended_);
+  MessageLoop::current()->RunAllPending();
+  EXPECT_TRUE(recognition_ended_);
   EXPECT_FALSE(result_received_);
   EXPECT_EQ(content::SPEECH_RECOGNITION_ERROR_NETWORK, error_);
 }
@@ -314,7 +330,8 @@ TEST_F(SpeechRecognizerImplTest, ConnectionError) {
 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_->StartRecognition());
+  recognizer_->StartRecognition();
+  MessageLoop::current()->RunAllPending();
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
@@ -325,6 +342,7 @@ TEST_F(SpeechRecognizerImplTest, ServerError) {
   ASSERT_TRUE(fetcher);
 
   recognizer_->StopAudioCapture();
+  MessageLoop::current()->RunAllPending();
   EXPECT_TRUE(audio_started_);
   EXPECT_TRUE(audio_ended_);
   EXPECT_FALSE(recognition_ended_);
@@ -339,15 +357,16 @@ TEST_F(SpeechRecognizerImplTest, ServerError) {
   fetcher->set_response_code(500);
   fetcher->SetResponseString("Internal Server Error");
   fetcher->delegate()->OnURLFetchComplete(fetcher);
-
-  EXPECT_FALSE(recognition_ended_);
+  MessageLoop::current()->RunAllPending();
+  EXPECT_TRUE(recognition_ended_);
   EXPECT_FALSE(result_received_);
   EXPECT_EQ(content::SPEECH_RECOGNITION_ERROR_NETWORK, error_);
 }
 
 TEST_F(SpeechRecognizerImplTest, AudioControllerErrorNoData) {
   // Check if things tear down properly if AudioInputController threw an error.
-  EXPECT_TRUE(recognizer_->StartRecognition());
+  recognizer_->StartRecognition();
+  MessageLoop::current()->RunAllPending();
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
@@ -355,7 +374,7 @@ TEST_F(SpeechRecognizerImplTest, AudioControllerErrorNoData) {
   MessageLoop::current()->RunAllPending();
   EXPECT_FALSE(audio_started_);
   EXPECT_FALSE(audio_ended_);
-  EXPECT_FALSE(recognition_ended_);
+  EXPECT_TRUE(recognition_ended_);
   EXPECT_FALSE(result_received_);
   EXPECT_EQ(content::SPEECH_RECOGNITION_ERROR_AUDIO, error_);
 }
@@ -363,7 +382,8 @@ TEST_F(SpeechRecognizerImplTest, AudioControllerErrorNoData) {
 TEST_F(SpeechRecognizerImplTest, AudioControllerErrorWithData) {
   // Check if things tear down properly if AudioInputController threw an error
   // after giving some audio data.
-  EXPECT_TRUE(recognizer_->StartRecognition());
+  recognizer_->StartRecognition();
+  MessageLoop::current()->RunAllPending();
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
@@ -373,8 +393,8 @@ TEST_F(SpeechRecognizerImplTest, AudioControllerErrorWithData) {
   MessageLoop::current()->RunAllPending();
   ASSERT_TRUE(url_fetcher_factory_.GetFetcherByID(0));
   EXPECT_TRUE(audio_started_);
-  EXPECT_FALSE(audio_ended_);
-  EXPECT_FALSE(recognition_ended_);
+  EXPECT_TRUE(audio_ended_);
+  EXPECT_TRUE(recognition_ended_);
   EXPECT_FALSE(result_received_);
   EXPECT_EQ(content::SPEECH_RECOGNITION_ERROR_AUDIO, error_);
 }
@@ -382,15 +402,14 @@ TEST_F(SpeechRecognizerImplTest, AudioControllerErrorWithData) {
 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_->StartRecognition());
+  recognizer_->StartRecognition();
+  MessageLoop::current()->RunAllPending();
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
-  controller = audio_input_controller_factory_.controller();
-  ASSERT_TRUE(controller);
 
-  int num_packets = (SpeechRecognizerImpl::kNoSpeechTimeoutSec * 1000) /
-                     SpeechRecognizerImpl::kAudioPacketIntervalMs;
+  int num_packets = (SpeechRecognizerImpl::kNoSpeechTimeoutMs) /
+                     GoogleSSFERemoteEngine::kAudioPacketIntervalMs + 1;
   // The vector is already filled with zero value samples on create.
   for (int i = 0; i < num_packets; ++i) {
     controller->event_handler()->OnData(controller, &audio_packet_[0],
@@ -398,8 +417,8 @@ TEST_F(SpeechRecognizerImplTest, NoSpeechCallbackIssued) {
   }
   MessageLoop::current()->RunAllPending();
   EXPECT_TRUE(audio_started_);
-  EXPECT_FALSE(audio_ended_);
-  EXPECT_FALSE(recognition_ended_);
+  EXPECT_TRUE(audio_ended_);
+  EXPECT_TRUE(recognition_ended_);
   EXPECT_FALSE(result_received_);
   EXPECT_EQ(content::SPEECH_RECOGNITION_ERROR_NO_SPEECH, error_);
 }
@@ -409,15 +428,16 @@ TEST_F(SpeechRecognizerImplTest, NoSpeechCallbackNotIssued) {
   // 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_->StartRecognition());
+  recognizer_->StartRecognition();
+  MessageLoop::current()->RunAllPending();
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
   controller = audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
 
-  int num_packets = (SpeechRecognizerImpl::kNoSpeechTimeoutSec * 1000) /
-                     SpeechRecognizerImpl::kAudioPacketIntervalMs;
+  int num_packets = (SpeechRecognizerImpl::kNoSpeechTimeoutMs) /
+                     GoogleSSFERemoteEngine::kAudioPacketIntervalMs;
 
   // The vector is already filled with zero value samples on create.
   for (int i = 0; i < num_packets / 2; ++i) {
@@ -437,6 +457,7 @@ TEST_F(SpeechRecognizerImplTest, NoSpeechCallbackNotIssued) {
   EXPECT_FALSE(audio_ended_);
   EXPECT_FALSE(recognition_ended_);
   recognizer_->AbortRecognition();
+  MessageLoop::current()->RunAllPending();
 }
 
 TEST_F(SpeechRecognizerImplTest, SetInputVolumeCallback) {
@@ -444,7 +465,8 @@ TEST_F(SpeechRecognizerImplTest, SetInputVolumeCallback) {
   // 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_->StartRecognition());
+  recognizer_->StartRecognition();
+  MessageLoop::current()->RunAllPending();
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
@@ -453,7 +475,7 @@ TEST_F(SpeechRecognizerImplTest, SetInputVolumeCallback) {
 
   // Feed some samples to begin with for the endpointer to do noise estimation.
   int num_packets = SpeechRecognizerImpl::kEndpointerEstimationTimeMs /
-                    SpeechRecognizerImpl::kAudioPacketIntervalMs;
+                    GoogleSSFERemoteEngine::kAudioPacketIntervalMs;
   FillPacketWithNoise();
   for (int i = 0; i < num_packets; ++i) {
     controller->event_handler()->OnData(controller, &audio_packet_[0],
@@ -479,6 +501,7 @@ TEST_F(SpeechRecognizerImplTest, SetInputVolumeCallback) {
   EXPECT_FALSE(audio_ended_);
   EXPECT_FALSE(recognition_ended_);
   recognizer_->AbortRecognition();
+  MessageLoop::current()->RunAllPending();
 }
 
 }  // namespace speech