Devirtualize SpeechRecognitionEngine

content/browser/speech/speech_recognizer_impl_unittest.cc

 // 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.
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <vector>
 
 #include "base/sys_byteorder.h"
 #include "content/browser/browser_thread_impl.h"
-#include "content/browser/speech/google_streaming_remote_engine.h"
 #include "content/browser/speech/proto/google_streaming_api.pb.h"
+#include "content/browser/speech/speech_recognition_engine.h"
 #include "content/browser/speech/speech_recognizer_impl.h"
 #include "content/public/browser/speech_recognition_event_listener.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/audio/fake_audio_input_stream.h"
 #include "media/audio/fake_audio_output_stream.h"
 #include "media/audio/mock_audio_manager.h"
 #include "media/audio/test_audio_input_controller_factory.h"
 #include "media/base/audio_bus.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/test_url_fetcher_factory.h"
@@ skipping 19 matching lines @@
         recognition_ended_(false),
         result_received_(false),
         audio_started_(false),
         audio_ended_(false),
         sound_started_(false),
         sound_ended_(false),
         error_(SPEECH_RECOGNITION_ERROR_NONE),
         volume_(-1.0f) {
     // SpeechRecognizer takes ownership of sr_engine.
     SpeechRecognitionEngine* sr_engine =
-        new GoogleStreamingRemoteEngine(NULL /* URLRequestContextGetter */);
-    SpeechRecognitionEngineConfig config;
+        new SpeechRecognitionEngine(NULL /* URLRequestContextGetter */);
+    SpeechRecognitionEngine::Config config;
     config.audio_num_bits_per_sample =
         SpeechRecognizerImpl::kNumBitsPerAudioSample;
     config.audio_sample_rate = SpeechRecognizerImpl::kAudioSampleRate;
     config.filter_profanities = false;
     sr_engine->SetConfig(config);
 
     const int kTestingSessionId = 1;
     recognizer_ = new SpeechRecognizerImpl(
         this, kTestingSessionId, false, false, sr_engine);
     audio_manager_.reset(new media::MockAudioManager(
         base::MessageLoop::current()->task_runner().get()));
     recognizer_->SetAudioManagerForTesting(audio_manager_.get());
 
     int audio_packet_length_bytes =
         (SpeechRecognizerImpl::kAudioSampleRate *
-         GoogleStreamingRemoteEngine::kAudioPacketIntervalMs *
+         SpeechRecognitionEngine::kAudioPacketIntervalMs *
          ChannelLayoutToChannelCount(SpeechRecognizerImpl::kChannelLayout) *
          SpeechRecognizerImpl::kNumBitsPerAudioSample) / (8 * 1000);
     audio_packet_.resize(audio_packet_length_bytes);
 
     const int channels =
         ChannelLayoutToChannelCount(SpeechRecognizerImpl::kChannelLayout);
     bytes_per_sample_ = SpeechRecognizerImpl::kNumBitsPerAudioSample / 8;
     const int frames = audio_packet_length_bytes / channels / bytes_per_sample_;
     audio_bus_ = media::AudioBus::Create(channels, frames);
     audio_bus_->Zero();
@@ skipping 189 matching lines @@
   proto_alternative->set_confidence(0.5f);
   proto_alternative->set_transcript("123");
   std::string msg_string;
   proto_event.SerializeToString(&msg_string);
   uint32_t prefix =
       base::HostToNet32(base::checked_cast<uint32_t>(msg_string.size()));
   msg_string.insert(0, reinterpret_cast<char*>(&prefix), sizeof(prefix));
 
   // Issue the network callback to complete the process.
   net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(
-      GoogleStreamingRemoteEngine::kDownstreamUrlFetcherIdForTesting);
+      SpeechRecognitionEngine::kDownstreamUrlFetcherIdForTesting);
   ASSERT_TRUE(fetcher);
   fetcher->set_url(fetcher->GetOriginalURL());
   fetcher->set_status(net::URLRequestStatus());
   fetcher->set_response_code(200);
   fetcher->SetResponseString(msg_string);
   fetcher->delegate()->OnURLFetchComplete(fetcher);
 
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(recognition_ended_);
   EXPECT_TRUE(result_received_);
@@ skipping 129 matching lines @@
 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.
   recognizer_->StartRecognition(media::AudioManagerBase::kDefaultDeviceId);
   base::MessageLoop::current()->RunUntilIdle();
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
 
   int num_packets = (SpeechRecognizerImpl::kNoSpeechTimeoutMs) /
-                     GoogleStreamingRemoteEngine::kAudioPacketIntervalMs + 1;
+                     SpeechRecognitionEngine::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_bus_.get());
   }
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(recognition_started_);
   EXPECT_TRUE(audio_started_);
   EXPECT_FALSE(result_received_);
   EXPECT_EQ(SPEECH_RECOGNITION_ERROR_NO_SPEECH, error_);
   CheckFinalEventsConsistency();
 }
 
 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.
   recognizer_->StartRecognition(media::AudioManagerBase::kDefaultDeviceId);
   base::MessageLoop::current()->RunUntilIdle();
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
   controller = audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
 
   int num_packets = (SpeechRecognizerImpl::kNoSpeechTimeoutMs) /
-                     GoogleStreamingRemoteEngine::kAudioPacketIntervalMs;
+                     SpeechRecognitionEngine::kAudioPacketIntervalMs;
 
   // The vector is already filled with zero value samples on create.
   for (int i = 0; i < num_packets / 2; ++i) {
     controller->event_handler()->OnData(controller, audio_bus_.get());
   }
 
   FillPacketWithTestWaveform();
   for (int i = 0; i < num_packets / 2; ++i) {
     controller->event_handler()->OnData(controller, audio_bus_.get());
   }
@@ skipping 16 matching lines @@
   recognizer_->StartRecognition(media::AudioManagerBase::kDefaultDeviceId);
   base::MessageLoop::current()->RunUntilIdle();
   TestAudioInputController* controller =
       audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
   controller = audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
 
   // Feed some samples to begin with for the endpointer to do noise estimation.
   int num_packets = SpeechRecognizerImpl::kEndpointerEstimationTimeMs /
-                    GoogleStreamingRemoteEngine::kAudioPacketIntervalMs;
+                    SpeechRecognitionEngine::kAudioPacketIntervalMs;
   FillPacketWithNoise();
   for (int i = 0; i < num_packets; ++i) {
     controller->event_handler()->OnData(controller, audio_bus_.get());
   }
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(-1.0f, volume_);  // No audio volume set yet.
 
   // The vector is already filled with zero value samples on create.
   controller->event_handler()->OnData(controller, audio_bus_.get());
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_FLOAT_EQ(0.74939233f, volume_);
 
   FillPacketWithTestWaveform();
   controller->event_handler()->OnData(controller, audio_bus_.get());
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_NEAR(0.89926866f, volume_, 0.00001f);
   EXPECT_FLOAT_EQ(0.75071919f, noise_volume_);
 
   EXPECT_EQ(SPEECH_RECOGNITION_ERROR_NONE, error_);
   EXPECT_FALSE(audio_ended_);
   EXPECT_FALSE(recognition_ended_);
   recognizer_->AbortRecognition();
   base::MessageLoop::current()->RunUntilIdle();
   CheckFinalEventsConsistency();
 }
 
 }  // namespace content