Devirtualize SpeechRecognitionEngine

content/browser/speech/speech_recognition_engine_unittest.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/google_streaming_remote_engine.h"
+#include "content/browser/speech/speech_recognition_engine.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <queue>
 
 #include "base/big_endian.h"
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_conversions.h"
@@ skipping 17 matching lines @@
 
 namespace content {
 
 // Frame types for framed POST data.
 static const uint32_t kFrameTypePreamble = 0;
 static const uint32_t kFrameTypeRecognitionAudio = 1;
 
 // Note: the terms upstream and downstream are from the point-of-view of the
 // client (engine_under_test_).
 
-class GoogleStreamingRemoteEngineTest : public SpeechRecognitionEngineDelegate,
-                                        public testing::Test {
+class SpeechRecognitionEngineTest
+    : public SpeechRecognitionEngine::Delegate,
+      public testing::Test {
  public:
-  GoogleStreamingRemoteEngineTest()
+  SpeechRecognitionEngineTest()
       : last_number_of_upstream_chunks_seen_(0U),
         error_(SPEECH_RECOGNITION_ERROR_NONE),
         end_of_utterance_counter_(0) { }
 
   // Creates a speech recognition request and invokes its URL fetcher delegate
   // with the given test data.
   void CreateAndTestRequest(bool success, const std::string& http_response);
 
   // SpeechRecognitionRequestDelegate methods.
   void OnSpeechRecognitionEngineResults(
@@ skipping 31 matching lines @@
   void InjectDummyAudioChunk();
   size_t UpstreamChunksUploadedFromLastCall();
   std::string LastUpstreamChunkUploaded();
   void ProvideMockProtoResultDownstream(
       const proto::SpeechRecognitionEvent& result);
   void ProvideMockResultDownstream(const SpeechRecognitionResult& result);
   void ExpectResultsReceived(const SpeechRecognitionResults& result);
   void ExpectFramedChunk(const std::string& chunk, uint32_t type);
   void CloseMockDownstream(DownstreamError error);
 
-  std::unique_ptr<GoogleStreamingRemoteEngine> engine_under_test_;
+  std::unique_ptr<SpeechRecognitionEngine> engine_under_test_;
   TestURLFetcherFactory url_fetcher_factory_;
   size_t last_number_of_upstream_chunks_seen_;
   base::MessageLoop message_loop_;
   std::string response_buffer_;
   SpeechRecognitionErrorCode error_;
   int end_of_utterance_counter_;
   std::queue<SpeechRecognitionResults> results_;
 };
 
-TEST_F(GoogleStreamingRemoteEngineTest, SingleDefinitiveResult) {
+TEST_F(SpeechRecognitionEngineTest, SingleDefinitiveResult) {
   StartMockRecognition();
   ASSERT_TRUE(GetUpstreamFetcher());
   ASSERT_EQ(0U, UpstreamChunksUploadedFromLastCall());
 
   // Inject some dummy audio chunks and check a corresponding chunked upload
   // is performed every time on the server.
   for (int i = 0; i < 3; ++i) {
     InjectDummyAudioChunk();
     ASSERT_EQ(1U, UpstreamChunksUploadedFromLastCall());
   }
@@ skipping 19 matching lines @@
   ASSERT_TRUE(engine_under_test_->IsRecognitionPending());
 
   // Ensure everything is closed cleanly after the downstream is closed.
   CloseMockDownstream(DOWNSTREAM_ERROR_NONE);
   ASSERT_FALSE(engine_under_test_->IsRecognitionPending());
   EndMockRecognition();
   ASSERT_EQ(SPEECH_RECOGNITION_ERROR_NONE, error_);
   ASSERT_EQ(0U, results_.size());
 }
 
-TEST_F(GoogleStreamingRemoteEngineTest, SeveralStreamingResults) {
+TEST_F(SpeechRecognitionEngineTest, SeveralStreamingResults) {
   StartMockRecognition();
   ASSERT_TRUE(GetUpstreamFetcher());
   ASSERT_EQ(0U, UpstreamChunksUploadedFromLastCall());
 
   for (int i = 0; i < 4; ++i) {
     InjectDummyAudioChunk();
     ASSERT_EQ(1U, UpstreamChunksUploadedFromLastCall());
 
     SpeechRecognitionResults results;
     results.push_back(SpeechRecognitionResult());
@@ skipping 25 matching lines @@
   ASSERT_TRUE(engine_under_test_->IsRecognitionPending());
 
   // Ensure everything is closed cleanly after the downstream is closed.
   CloseMockDownstream(DOWNSTREAM_ERROR_NONE);
   ASSERT_FALSE(engine_under_test_->IsRecognitionPending());
   EndMockRecognition();
   ASSERT_EQ(SPEECH_RECOGNITION_ERROR_NONE, error_);
   ASSERT_EQ(0U, results_.size());
 }
 
-TEST_F(GoogleStreamingRemoteEngineTest, NoFinalResultAfterAudioChunksEnded) {
+TEST_F(SpeechRecognitionEngineTest, NoFinalResultAfterAudioChunksEnded) {
   StartMockRecognition();
   ASSERT_TRUE(GetUpstreamFetcher());
   ASSERT_EQ(0U, UpstreamChunksUploadedFromLastCall());
 
   // Simulate one pushed audio chunk.
   InjectDummyAudioChunk();
   ASSERT_EQ(1U, UpstreamChunksUploadedFromLastCall());
 
   // Simulate the corresponding definitive result.
   SpeechRecognitionResults results;
@@ skipping 16 matching lines @@
   SpeechRecognitionResults empty_results;
   ExpectResultsReceived(empty_results);
 
   // Ensure everything is closed cleanly after the downstream is closed.
   ASSERT_FALSE(engine_under_test_->IsRecognitionPending());
   EndMockRecognition();
   ASSERT_EQ(SPEECH_RECOGNITION_ERROR_NONE, error_);
   ASSERT_EQ(0U, results_.size());
 }
 
-TEST_F(GoogleStreamingRemoteEngineTest, NoMatchError) {
+TEST_F(SpeechRecognitionEngineTest, NoMatchError) {
   StartMockRecognition();
   ASSERT_TRUE(GetUpstreamFetcher());
   ASSERT_EQ(0U, UpstreamChunksUploadedFromLastCall());
 
   for (int i = 0; i < 3; ++i)
     InjectDummyAudioChunk();
   engine_under_test_->AudioChunksEnded();
   ASSERT_EQ(4U, UpstreamChunksUploadedFromLastCall());
   ASSERT_TRUE(engine_under_test_->IsRecognitionPending());
 
@@ skipping 10 matching lines @@
 
   CloseMockDownstream(DOWNSTREAM_ERROR_WEBSERVICE_NO_MATCH);
 
   // Expect an empty result.
   ASSERT_FALSE(engine_under_test_->IsRecognitionPending());
   EndMockRecognition();
   SpeechRecognitionResults empty_result;
   ExpectResultsReceived(empty_result);
 }
 
-TEST_F(GoogleStreamingRemoteEngineTest, HTTPError) {
+TEST_F(SpeechRecognitionEngineTest, HTTPError) {
   StartMockRecognition();
   ASSERT_TRUE(GetUpstreamFetcher());
   ASSERT_EQ(0U, UpstreamChunksUploadedFromLastCall());
 
   InjectDummyAudioChunk();
   ASSERT_EQ(1U, UpstreamChunksUploadedFromLastCall());
 
   // Close the downstream with a HTTP 500 error.
   CloseMockDownstream(DOWNSTREAM_ERROR_HTTP500);
 
   // Expect a SPEECH_RECOGNITION_ERROR_NETWORK error to be raised.
   ASSERT_FALSE(engine_under_test_->IsRecognitionPending());
   EndMockRecognition();
   ASSERT_EQ(SPEECH_RECOGNITION_ERROR_NETWORK, error_);
   ASSERT_EQ(0U, results_.size());
 }
 
-TEST_F(GoogleStreamingRemoteEngineTest, NetworkError) {
+TEST_F(SpeechRecognitionEngineTest, NetworkError) {
   StartMockRecognition();
   ASSERT_TRUE(GetUpstreamFetcher());
   ASSERT_EQ(0U, UpstreamChunksUploadedFromLastCall());
 
   InjectDummyAudioChunk();
   ASSERT_EQ(1U, UpstreamChunksUploadedFromLastCall());
 
   // Close the downstream fetcher simulating a network failure.
   CloseMockDownstream(DOWNSTREAM_ERROR_NETWORK);
 
   // Expect a SPEECH_RECOGNITION_ERROR_NETWORK error to be raised.
   ASSERT_FALSE(engine_under_test_->IsRecognitionPending());
   EndMockRecognition();
   ASSERT_EQ(SPEECH_RECOGNITION_ERROR_NETWORK, error_);
   ASSERT_EQ(0U, results_.size());
 }
 
-TEST_F(GoogleStreamingRemoteEngineTest, Stability) {
+TEST_F(SpeechRecognitionEngineTest, Stability) {
   StartMockRecognition();
   ASSERT_TRUE(GetUpstreamFetcher());
   ASSERT_EQ(0U, UpstreamChunksUploadedFromLastCall());
 
   // Upload a dummy audio chunk.
   InjectDummyAudioChunk();
   ASSERT_EQ(1U, UpstreamChunksUploadedFromLastCall());
   engine_under_test_->AudioChunksEnded();
 
   // Simulate a protobuf message with an intermediate result without confidence,
@@ skipping 26 matching lines @@
   ASSERT_FALSE(engine_under_test_->IsRecognitionPending());
   EndMockRecognition();
 
   // Since there was no final result, we get an empty "no match" result.
   SpeechRecognitionResults empty_result;
   ExpectResultsReceived(empty_result);
   ASSERT_EQ(SPEECH_RECOGNITION_ERROR_NONE, error_);
   ASSERT_EQ(0U, results_.size());
 }
 
-TEST_F(GoogleStreamingRemoteEngineTest, EndOfUtterance) {
+TEST_F(SpeechRecognitionEngineTest, EndOfUtterance) {
   StartMockRecognition();
   ASSERT_TRUE(GetUpstreamFetcher());
 
   // Simulate a END_OF_UTTERANCE proto event with continuous true.
   SpeechRecognitionEngine::Config config;
   config.continuous = true;
   engine_under_test_->SetConfig(config);
   proto::SpeechRecognitionEvent proto_event;
   proto_event.set_endpoint(proto::SpeechRecognitionEvent::END_OF_UTTERANCE);
   ASSERT_EQ(0, end_of_utterance_counter_);
   ProvideMockProtoResultDownstream(proto_event);
   ASSERT_EQ(0, end_of_utterance_counter_);
 
   // Simulate a END_OF_UTTERANCE proto event with continuous false.
   config.continuous = false;
   engine_under_test_->SetConfig(config);
   ProvideMockProtoResultDownstream(proto_event);
   ASSERT_EQ(1, end_of_utterance_counter_);
 
   // Shut down.
   CloseMockDownstream(DOWNSTREAM_ERROR_NONE);
   EndMockRecognition();
 }
 
-TEST_F(GoogleStreamingRemoteEngineTest, SendPreamble) {
+TEST_F(SpeechRecognitionEngineTest, SendPreamble) {
   const size_t kPreambleLength = 100;
   scoped_refptr<SpeechRecognitionSessionPreamble> preamble =
       new SpeechRecognitionSessionPreamble();
   preamble->sample_rate = 16000;
   preamble->sample_depth = 2;
   preamble->sample_data.assign(kPreambleLength, 0);
   SpeechRecognitionEngine::Config config;
   config.auth_token = "foo";
   config.auth_scope = "bar";
   config.preamble = preamble;
@@ skipping 29 matching lines @@
   ASSERT_TRUE(engine_under_test_->IsRecognitionPending());
 
   // Ensure everything is closed cleanly after the downstream is closed.
   CloseMockDownstream(DOWNSTREAM_ERROR_NONE);
   ASSERT_FALSE(engine_under_test_->IsRecognitionPending());
   EndMockRecognition();
   ASSERT_EQ(SPEECH_RECOGNITION_ERROR_NONE, error_);
   ASSERT_EQ(0U, results_.size());
 }
 
-void GoogleStreamingRemoteEngineTest::SetUp() {
+void SpeechRecognitionEngineTest::SetUp() {
   engine_under_test_.reset(
-      new  GoogleStreamingRemoteEngine(NULL /*URLRequestContextGetter*/));
+      new SpeechRecognitionEngine(NULL /*URLRequestContextGetter*/));
   engine_under_test_->set_delegate(this);
 }
 
-void GoogleStreamingRemoteEngineTest::TearDown() {
+void SpeechRecognitionEngineTest::TearDown() {
   engine_under_test_.reset();
 }
 
-TestURLFetcher* GoogleStreamingRemoteEngineTest::GetUpstreamFetcher() {
+TestURLFetcher* SpeechRecognitionEngineTest::GetUpstreamFetcher() {
   return url_fetcher_factory_.GetFetcherByID(
-        GoogleStreamingRemoteEngine::kUpstreamUrlFetcherIdForTesting);
+        SpeechRecognitionEngine::kUpstreamUrlFetcherIdForTesting);
 }
 
-TestURLFetcher* GoogleStreamingRemoteEngineTest::GetDownstreamFetcher() {
+TestURLFetcher* SpeechRecognitionEngineTest::GetDownstreamFetcher() {
   return url_fetcher_factory_.GetFetcherByID(
-        GoogleStreamingRemoteEngine::kDownstreamUrlFetcherIdForTesting);
+        SpeechRecognitionEngine::kDownstreamUrlFetcherIdForTesting);
 }
 
 // Starts recognition on the engine, ensuring that both stream fetchers are
 // created.
-void GoogleStreamingRemoteEngineTest::StartMockRecognition() {
+void SpeechRecognitionEngineTest::StartMockRecognition() {
   DCHECK(engine_under_test_.get());
 
   ASSERT_FALSE(engine_under_test_->IsRecognitionPending());
 
   engine_under_test_->StartRecognition();
   ASSERT_TRUE(engine_under_test_->IsRecognitionPending());
 
   TestURLFetcher* upstream_fetcher = GetUpstreamFetcher();
   ASSERT_TRUE(upstream_fetcher);
   upstream_fetcher->set_url(upstream_fetcher->GetOriginalURL());
 
   TestURLFetcher* downstream_fetcher = GetDownstreamFetcher();
   ASSERT_TRUE(downstream_fetcher);
   downstream_fetcher->set_url(downstream_fetcher->GetOriginalURL());
 }
 
-void GoogleStreamingRemoteEngineTest::EndMockRecognition() {
+void SpeechRecognitionEngineTest::EndMockRecognition() {
   DCHECK(engine_under_test_.get());
   engine_under_test_->EndRecognition();
   ASSERT_FALSE(engine_under_test_->IsRecognitionPending());
 
   // TODO(primiano): In order to be very pedantic we should check that both the
   // upstream and downstream URL fetchers have been disposed at this time.
   // Unfortunately it seems that there is no direct way to detect (in tests)
   // if a url_fetcher has been freed or not, since they are not automatically
   // de-registered from the TestURLFetcherFactory on destruction.
 }
 
-void GoogleStreamingRemoteEngineTest::InjectDummyAudioChunk() {
+void SpeechRecognitionEngineTest::InjectDummyAudioChunk() {
   unsigned char dummy_audio_buffer_data[2] = {'\0', '\0'};
   scoped_refptr<AudioChunk> dummy_audio_chunk(
       new AudioChunk(&dummy_audio_buffer_data[0],
                      sizeof(dummy_audio_buffer_data),
                      2 /* bytes per sample */));
   DCHECK(engine_under_test_.get());
   engine_under_test_->TakeAudioChunk(*dummy_audio_chunk.get());
 }
 
-size_t GoogleStreamingRemoteEngineTest::UpstreamChunksUploadedFromLastCall() {
+size_t SpeechRecognitionEngineTest::UpstreamChunksUploadedFromLastCall() {
   TestURLFetcher* upstream_fetcher = GetUpstreamFetcher();
   DCHECK(upstream_fetcher);
   const size_t number_of_chunks = upstream_fetcher->upload_chunks().size();
   DCHECK_GE(number_of_chunks, last_number_of_upstream_chunks_seen_);
   const size_t new_chunks = number_of_chunks -
                             last_number_of_upstream_chunks_seen_;
   last_number_of_upstream_chunks_seen_ = number_of_chunks;
   return new_chunks;
 }
 
-std::string GoogleStreamingRemoteEngineTest::LastUpstreamChunkUploaded() {
+std::string SpeechRecognitionEngineTest::LastUpstreamChunkUploaded() {
   TestURLFetcher* upstream_fetcher = GetUpstreamFetcher();
   DCHECK(upstream_fetcher);
   DCHECK(!upstream_fetcher->upload_chunks().empty());
   return upstream_fetcher->upload_chunks().back();
 }
 
-void GoogleStreamingRemoteEngineTest::ProvideMockProtoResultDownstream(
+void SpeechRecognitionEngineTest::ProvideMockProtoResultDownstream(
     const proto::SpeechRecognitionEvent& result) {
   TestURLFetcher* downstream_fetcher = GetDownstreamFetcher();
 
   ASSERT_TRUE(downstream_fetcher);
   downstream_fetcher->set_status(URLRequestStatus(/* default=SUCCESS */));
   downstream_fetcher->set_response_code(200);
 
   std::string response_string = SerializeProtobufResponse(result);
   response_buffer_.append(response_string);
   downstream_fetcher->SetResponseString(response_buffer_);
   downstream_fetcher->delegate()->OnURLFetchDownloadProgress(
       downstream_fetcher,
       response_buffer_.size(),
       -1 /* total response length not used */);
 }
 
-void GoogleStreamingRemoteEngineTest::ProvideMockResultDownstream(
+void SpeechRecognitionEngineTest::ProvideMockResultDownstream(
     const SpeechRecognitionResult& result) {
   proto::SpeechRecognitionEvent proto_event;
   proto_event.set_status(proto::SpeechRecognitionEvent::STATUS_SUCCESS);
   proto::SpeechRecognitionResult* proto_result = proto_event.add_result();
   proto_result->set_final(!result.is_provisional);
   for (size_t i = 0; i < result.hypotheses.size(); ++i) {
     proto::SpeechRecognitionAlternative* proto_alternative =
         proto_result->add_alternative();
     const SpeechRecognitionHypothesis& hypothesis = result.hypotheses[i];
     proto_alternative->set_confidence(hypothesis.confidence);
     proto_alternative->set_transcript(base::UTF16ToUTF8(hypothesis.utterance));
   }
   ProvideMockProtoResultDownstream(proto_event);
 }
 
-void GoogleStreamingRemoteEngineTest::CloseMockDownstream(
+void SpeechRecognitionEngineTest::CloseMockDownstream(
     DownstreamError error) {
   TestURLFetcher* downstream_fetcher = GetDownstreamFetcher();
   ASSERT_TRUE(downstream_fetcher);
 
   const net::Error net_error =
       (error == DOWNSTREAM_ERROR_NETWORK) ? net::ERR_FAILED : net::OK;
   downstream_fetcher->set_status(URLRequestStatus::FromError(net_error));
   downstream_fetcher->set_response_code(
       (error == DOWNSTREAM_ERROR_HTTP500) ? 500 : 200);
 
   if (error == DOWNSTREAM_ERROR_WEBSERVICE_NO_MATCH) {
     // Send empty response.
     proto::SpeechRecognitionEvent response;
     response_buffer_.append(SerializeProtobufResponse(response));
   }
   downstream_fetcher->SetResponseString(response_buffer_);
   downstream_fetcher->delegate()->OnURLFetchComplete(downstream_fetcher);
 }
 
-void GoogleStreamingRemoteEngineTest::ExpectResultsReceived(
+void SpeechRecognitionEngineTest::ExpectResultsReceived(
     const SpeechRecognitionResults& results) {
   ASSERT_GE(1U, results_.size());
   ASSERT_TRUE(ResultsAreEqual(results, results_.front()));
   results_.pop();
 }
 
-bool GoogleStreamingRemoteEngineTest::ResultsAreEqual(
+bool SpeechRecognitionEngineTest::ResultsAreEqual(
     const SpeechRecognitionResults& a, const SpeechRecognitionResults& b) {
   if (a.size() != b.size())
     return false;
 
   SpeechRecognitionResults::const_iterator it_a = a.begin();
   SpeechRecognitionResults::const_iterator it_b = b.begin();
   for (; it_a != a.end() && it_b != b.end(); ++it_a, ++it_b) {
     if (it_a->is_provisional != it_b->is_provisional ||
         it_a->hypotheses.size() != it_b->hypotheses.size()) {
       return false;
     }
     for (size_t i = 0; i < it_a->hypotheses.size(); ++i) {
       const SpeechRecognitionHypothesis& hyp_a = it_a->hypotheses[i];
       const SpeechRecognitionHypothesis& hyp_b = it_b->hypotheses[i];
       if (hyp_a.utterance != hyp_b.utterance ||
           hyp_a.confidence != hyp_b.confidence) {
         return false;
       }
     }
   }
 
   return true;
 }
 
-void GoogleStreamingRemoteEngineTest::ExpectFramedChunk(
+void SpeechRecognitionEngineTest::ExpectFramedChunk(
     const std::string& chunk, uint32_t type) {
   uint32_t value;
   base::ReadBigEndian(&chunk[0], &value);
   EXPECT_EQ(chunk.size() - 8, value);
   base::ReadBigEndian(&chunk[4], &value);
   EXPECT_EQ(type, value);
 }
 
-std::string GoogleStreamingRemoteEngineTest::SerializeProtobufResponse(
+std::string SpeechRecognitionEngineTest::SerializeProtobufResponse(
     const proto::SpeechRecognitionEvent& msg) {
   std::string msg_string;
   msg.SerializeToString(&msg_string);
 
   // Prepend 4 byte prefix length indication to the protobuf message as
   // envisaged by the google streaming recognition webservice protocol.
   uint32_t prefix = HostToNet32(checked_cast<uint32_t>(msg_string.size()));
   msg_string.insert(0, reinterpret_cast<char*>(&prefix), sizeof(prefix));
 
   return msg_string;
 }
 
 }  // namespace content