chrome/browser/vr/speech_recognizer_unittest.cc - chromium/src - Git at Google

 // Copyright 2017 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 "chrome/browser/vr/speech_recognizer.h"

 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/timer/mock_timer.h"
 #include "chrome/browser/vr/browser_ui_interface.h"
 #include "chrome/browser/vr/test/mock_browser_ui_interface.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/speech_recognition_event_listener.h"
 #include "content/public/browser/speech_recognition_manager.h"
 #include "content/public/browser/speech_recognition_session_config.h"
 #include "content/public/browser/speech_recognition_session_context.h"
 #include "content/public/common/speech_recognition_error.h"
 #include "content/public/common/speech_recognition_result.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace vr {

 static const int kTestSessionId = 1;
 const char kTestInterimResult[] = "kitten";
 const char kTestResult[] = "cat";
 const char kTestResultMultiple[] = "cat video";

 enum FakeRecognitionEvent {
   RECOGNITION_START = 0,
   RECOGNITION_END,
   NETWORK_ERROR,
   SOUND_START,
   SOUND_END,
   AUDIO_START,
   AUDIO_END,
   INTERIM_RESULT,
   FINAL_RESULT,
   MULTIPLE_FINAL_RESULT,
 };

 class FakeSpeechRecognitionManager : public content::SpeechRecognitionManager {
  public:
   FakeSpeechRecognitionManager() {}
   ~FakeSpeechRecognitionManager() override {}

   // SpeechRecognitionManager methods.
   int CreateSession(
       const content::SpeechRecognitionSessionConfig& config) override {
     session_ctx_ = config.initial_context;
     session_config_ = config;
     session_id_ = kTestSessionId;
     return session_id_;
   }

   void StartSession(int session_id) override {}

   void AbortSession(int session_id) override {
     DCHECK(session_id_ == session_id);
     session_id_ = 0;
   }

   void AbortAllSessionsForRenderProcess(int render_process_id) override {}
   void AbortAllSessionsForRenderView(int render_process_id,
                                      int render_view_id) override {}
   void StopAudioCaptureForSession(int session_id) override {}

   const content::SpeechRecognitionSessionConfig& GetSessionConfig(
       int session_id) const override {
     DCHECK(session_id_ == session_id);
     return session_config_;
   }

   content::SpeechRecognitionSessionContext GetSessionContext(
       int session_id) const override {
     DCHECK(session_id_ == session_id);
     return session_ctx_;
   }

   int GetSession(int render_process_id,
                  int render_view_id,
                  int request_id) const override {
     return session_id_;
   }

   void FakeSpeechRecognitionEvent(FakeRecognitionEvent event) {
     if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)) {
       content::BrowserThread::PostTask(
           content::BrowserThread::IO, FROM_HERE,
           base::BindOnce(
               &FakeSpeechRecognitionManager::FakeSpeechRecognitionEvent,
               base::Unretained(this), event));
       return;
     }
     DCHECK(GetActiveListener());
     content::SpeechRecognitionError error(
         content::SPEECH_RECOGNITION_ERROR_NETWORK);
     switch (event) {
       case RECOGNITION_START:
         GetActiveListener()->OnRecognitionStart(kTestSessionId);
         break;
       case RECOGNITION_END:
         GetActiveListener()->OnRecognitionEnd(kTestSessionId);
         break;
       case NETWORK_ERROR:
         GetActiveListener()->OnRecognitionError(kTestSessionId, error);
         break;
       case SOUND_START:
         GetActiveListener()->OnSoundStart(kTestSessionId);
         break;
       case INTERIM_RESULT:
         SendFakeInterimResults();
         break;
       case FINAL_RESULT:
         SendFakeFinalResults();
         break;
       case MULTIPLE_FINAL_RESULT:
         SendFakeMultipleFinalResults();
         break;
       default:
         NOTREACHED();
     }
   }

   void SendFakeInterimResults() {
     if (!session_id_)
       return;

     SendRecognitionResult(kTestInterimResult, true);
   }

   void SendFakeFinalResults() {
     if (!session_id_)
       return;

     SendRecognitionResult(kTestResult, false);
     FakeSpeechRecognitionEvent(RECOGNITION_END);
     session_id_ = 0;
   }

   void SendFakeMultipleFinalResults() {
     if (!session_id_)
       return;

     SendRecognitionResult(kTestResult, false);
     SendRecognitionResult(kTestResultMultiple, false);
     FakeSpeechRecognitionEvent(RECOGNITION_END);
     session_id_ = 0;
   }

  private:
   void SendRecognitionResult(const char* string, bool is_provisional) {
     content::SpeechRecognitionEventListener* listener = GetActiveListener();
     if (!listener)
       return;
     listener->OnAudioStart(session_id_);
     listener->OnAudioEnd(session_id_);

     content::SpeechRecognitionResult result;
     result.hypotheses.push_back(
         content::SpeechRecognitionHypothesis(base::ASCIIToUTF16(string), 1.0));
     result.is_provisional = is_provisional;
     content::SpeechRecognitionResults results;
     results.push_back(result);

     listener->OnRecognitionResults(session_id_, results);
   }

   content::SpeechRecognitionEventListener* GetActiveListener() {
     DCHECK(session_id_ != 0);
     return session_config_.event_listener.get();
   }

   int session_id_ = 0;
   content::SpeechRecognitionSessionContext session_ctx_;
   content::SpeechRecognitionSessionConfig session_config_;

   DISALLOW_COPY_AND_ASSIGN(FakeSpeechRecognitionManager);
 };

 class MockVoiceSearchDelegate : public VoiceResultDelegate {
  public:
   MockVoiceSearchDelegate() = default;
   ~MockVoiceSearchDelegate() override = default;

   MOCK_METHOD1(OnVoiceResults, void(const base::string16& result));

  private:
   DISALLOW_COPY_AND_ASSIGN(MockVoiceSearchDelegate);
 };

 class SpeechRecognizerTest : public testing::Test {
  public:
   SpeechRecognizerTest()
       : fake_speech_recognition_manager_(new FakeSpeechRecognitionManager()),
         ui_(new MockBrowserUiInterface),
         delegate_(new MockVoiceSearchDelegate),
         speech_recognizer_(
             new SpeechRecognizer(delegate_.get(), ui_.get(), nullptr, "en")) {
     SpeechRecognizer::SetManagerForTest(fake_speech_recognition_manager_.get());
   }

   ~SpeechRecognizerTest() override {
     SpeechRecognizer::SetManagerForTest(nullptr);
   }

  protected:
   content::TestBrowserThreadBundle thread_bundle_;
   std::unique_ptr<FakeSpeechRecognitionManager>
       fake_speech_recognition_manager_;
   std::unique_ptr<MockBrowserUiInterface> ui_;
   std::unique_ptr<MockVoiceSearchDelegate> delegate_;
   std::unique_ptr<SpeechRecognizer> speech_recognizer_;

  private:
   DISALLOW_COPY_AND_ASSIGN(SpeechRecognizerTest);
 };

 TEST_F(SpeechRecognizerTest, ReceivedCorrectSpeechResult) {
   testing::Sequence s;
   EXPECT_CALL(*ui_, SetSpeechRecognitionEnabled(true)).InSequence(s);
   EXPECT_CALL(*ui_, SetRecognitionResult(base::ASCIIToUTF16(kTestResult)))
       .InSequence(s);
   EXPECT_CALL(*delegate_, OnVoiceResults(base::ASCIIToUTF16(kTestResult)))
       .Times(1)
       .InSequence(s);
   EXPECT_CALL(*ui_, SetSpeechRecognitionEnabled(false)).InSequence(s);

   speech_recognizer_->Start();
   base::RunLoop().RunUntilIdle();

   // This should not trigger SetRecognitionResult as we don't show interim
   // result.
   fake_speech_recognition_manager_->FakeSpeechRecognitionEvent(INTERIM_RESULT);
   base::RunLoop().RunUntilIdle();

   // This should trigger SetRecognitionResult as we received final result.
   fake_speech_recognition_manager_->FakeSpeechRecognitionEvent(FINAL_RESULT);
   base::RunLoop().RunUntilIdle();
 }

 // Test for crbug.com/785051. It is possible that we receive multiple final
 // results in one recognition session. We should only navigate once in this
 // case.
 TEST_F(SpeechRecognizerTest, MultipleResultsTriggerNavigation) {
   testing::Sequence s;
   EXPECT_CALL(*ui_, SetSpeechRecognitionEnabled(true)).InSequence(s);
   EXPECT_CALL(*ui_,
               SetRecognitionResult(base::ASCIIToUTF16(kTestResultMultiple)))
       .InSequence(s);
   EXPECT_CALL(*delegate_,
               OnVoiceResults(base::ASCIIToUTF16(kTestResultMultiple)))
       .Times(1)
       .InSequence(s);
   EXPECT_CALL(*ui_, SetSpeechRecognitionEnabled(false)).InSequence(s);

   speech_recognizer_->Start();
   base::RunLoop().RunUntilIdle();

   fake_speech_recognition_manager_->FakeSpeechRecognitionEvent(
       MULTIPLE_FINAL_RESULT);
   base::RunLoop().RunUntilIdle();
 }

 TEST_F(SpeechRecognizerTest, ReceivedSpeechRecognitionStates) {
   speech_recognizer_->Start();
   base::RunLoop().RunUntilIdle();

   testing::Sequence s;
   EXPECT_CALL(*ui_,
               OnSpeechRecognitionStateChanged(SPEECH_RECOGNITION_RECOGNIZING))
       .InSequence(s);
   EXPECT_CALL(*ui_,
               OnSpeechRecognitionStateChanged(SPEECH_RECOGNITION_NETWORK_ERROR))
       .InSequence(s);
   EXPECT_CALL(*ui_, OnSpeechRecognitionStateChanged(SPEECH_RECOGNITION_END))
       .InSequence(s);

   fake_speech_recognition_manager_->FakeSpeechRecognitionEvent(
       RECOGNITION_START);
   base::RunLoop().RunUntilIdle();

   fake_speech_recognition_manager_->FakeSpeechRecognitionEvent(NETWORK_ERROR);
   base::RunLoop().RunUntilIdle();

   fake_speech_recognition_manager_->FakeSpeechRecognitionEvent(RECOGNITION_END);
   base::RunLoop().RunUntilIdle();
 }

 TEST_F(SpeechRecognizerTest, NoSoundTimeout) {
   testing::Sequence s;
   EXPECT_CALL(*ui_, SetSpeechRecognitionEnabled(true)).InSequence(s);
   EXPECT_CALL(*ui_,
               OnSpeechRecognitionStateChanged(SPEECH_RECOGNITION_IN_SPEECH))
       .InSequence(s);
   EXPECT_CALL(*ui_, OnSpeechRecognitionStateChanged(SPEECH_RECOGNITION_END))
       .InSequence(s);
   EXPECT_CALL(*ui_, SetSpeechRecognitionEnabled(false)).InSequence(s);

   speech_recognizer_->Start();
   base::RunLoop().RunUntilIdle();

   auto mock_timer = std::make_unique<base::MockTimer>(false, false);
   base::MockTimer* timer_ptr = mock_timer.get();
   speech_recognizer_->SetSpeechTimerForTest(std::move(mock_timer));

   fake_speech_recognition_manager_->FakeSpeechRecognitionEvent(SOUND_START);
   base::RunLoop().RunUntilIdle();

   // This should trigger a SPEECH_RECOGNITION_READY state notification.
   timer_ptr->Fire();
   base::RunLoop().RunUntilIdle();
 }

 // This test that it is safe to reset speech_recognizer_ on UI thread after post
 // a task to start speech recognition on IO thread.
 TEST_F(SpeechRecognizerTest, SafeToResetAfterStart) {
   EXPECT_CALL(*ui_,
               OnSpeechRecognitionStateChanged(SPEECH_RECOGNITION_RECOGNIZING));
   EXPECT_CALL(*ui_, SetRecognitionResult(base::ASCIIToUTF16(kTestResult)))
       .Times(0);

   speech_recognizer_->Start();
   base::RunLoop().RunUntilIdle();

   fake_speech_recognition_manager_->FakeSpeechRecognitionEvent(
       RECOGNITION_START);
   base::RunLoop().RunUntilIdle();

   fake_speech_recognition_manager_->FakeSpeechRecognitionEvent(FINAL_RESULT);
   // Reset shouldn't crash the test.
   speech_recognizer_.reset(nullptr);
   base::RunLoop().RunUntilIdle();
 }

 // This test that calling start after stop should still work as expected.
 TEST_F(SpeechRecognizerTest, RestartAfterStop) {
   EXPECT_CALL(*ui_, SetRecognitionResult(base::ASCIIToUTF16(kTestResult)))
       .Times(1);

   speech_recognizer_->Start();
   base::RunLoop().RunUntilIdle();

   fake_speech_recognition_manager_->FakeSpeechRecognitionEvent(FINAL_RESULT);
   speech_recognizer_->Stop();
   base::RunLoop().RunUntilIdle();

   speech_recognizer_->Start();
   base::RunLoop().RunUntilIdle();

   fake_speech_recognition_manager_->FakeSpeechRecognitionEvent(FINAL_RESULT);
   base::RunLoop().RunUntilIdle();
 }

 }  // namespace vr
	// Copyright 2017 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 "chrome/browser/vr/speech_recognizer.h"

	#include "base/logging.h"
	#include "base/memory/ptr_util.h"
	#include "base/memory/ref_counted.h"
	#include "base/message_loop/message_loop.h"
	#include "base/run_loop.h"
	#include "base/strings/utf_string_conversions.h"
	#include "base/threading/thread_task_runner_handle.h"
	#include "base/timer/mock_timer.h"
	#include "chrome/browser/vr/browser_ui_interface.h"
	#include "chrome/browser/vr/test/mock_browser_ui_interface.h"
	#include "content/public/browser/browser_thread.h"
	#include "content/public/browser/speech_recognition_event_listener.h"
	#include "content/public/browser/speech_recognition_manager.h"
	#include "content/public/browser/speech_recognition_session_config.h"
	#include "content/public/browser/speech_recognition_session_context.h"
	#include "content/public/common/speech_recognition_error.h"
	#include "content/public/common/speech_recognition_result.h"
	#include "content/public/test/test_browser_thread_bundle.h"
	#include "testing/gmock/include/gmock/gmock.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace vr {

	static const int kTestSessionId = 1;
	const char kTestInterimResult[] = "kitten";
	const char kTestResult[] = "cat";
	const char kTestResultMultiple[] = "cat video";

	enum FakeRecognitionEvent {
	RECOGNITION_START = 0,
	RECOGNITION_END,
	NETWORK_ERROR,
	SOUND_START,
	SOUND_END,
	AUDIO_START,
	AUDIO_END,
	INTERIM_RESULT,
	FINAL_RESULT,
	MULTIPLE_FINAL_RESULT,
	};

	class FakeSpeechRecognitionManager : public content::SpeechRecognitionManager {
	public:
	FakeSpeechRecognitionManager() {}
	~FakeSpeechRecognitionManager() override {}

	// SpeechRecognitionManager methods.
	int CreateSession(
	const content::SpeechRecognitionSessionConfig& config) override {
	session_ctx_ = config.initial_context;
	session_config_ = config;
	session_id_ = kTestSessionId;
	return session_id_;
	}

	void StartSession(int session_id) override {}

	void AbortSession(int session_id) override {
	DCHECK(session_id_ == session_id);
	session_id_ = 0;
	}

	void AbortAllSessionsForRenderProcess(int render_process_id) override {}
	void AbortAllSessionsForRenderView(int render_process_id,
	int render_view_id) override {}
	void StopAudioCaptureForSession(int session_id) override {}

	const content::SpeechRecognitionSessionConfig& GetSessionConfig(
	int session_id) const override {
	DCHECK(session_id_ == session_id);
	return session_config_;
	}

	content::SpeechRecognitionSessionContext GetSessionContext(
	int session_id) const override {
	DCHECK(session_id_ == session_id);
	return session_ctx_;
	}

	int GetSession(int render_process_id,
	int render_view_id,
	int request_id) const override {
	return session_id_;
	}

	void FakeSpeechRecognitionEvent(FakeRecognitionEvent event) {
	if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)) {
	content::BrowserThread::PostTask(
	content::BrowserThread::IO, FROM_HERE,
	base::BindOnce(
	&FakeSpeechRecognitionManager::FakeSpeechRecognitionEvent,
	base::Unretained(this), event));
	return;
	}
	DCHECK(GetActiveListener());
	content::SpeechRecognitionError error(
	content::SPEECH_RECOGNITION_ERROR_NETWORK);
	switch (event) {
	case RECOGNITION_START:
	GetActiveListener()->OnRecognitionStart(kTestSessionId);
	break;
	case RECOGNITION_END:
	GetActiveListener()->OnRecognitionEnd(kTestSessionId);
	break;
	case NETWORK_ERROR:
	GetActiveListener()->OnRecognitionError(kTestSessionId, error);
	break;
	case SOUND_START:
	GetActiveListener()->OnSoundStart(kTestSessionId);
	break;
	case INTERIM_RESULT:
	SendFakeInterimResults();
	break;
	case FINAL_RESULT:
	SendFakeFinalResults();
	break;
	case MULTIPLE_FINAL_RESULT:
	SendFakeMultipleFinalResults();
	break;
	default:
	NOTREACHED();
	}
	}

	void SendFakeInterimResults() {
	if (!session_id_)
	return;

	SendRecognitionResult(kTestInterimResult, true);
	}

	void SendFakeFinalResults() {
	if (!session_id_)
	return;

	SendRecognitionResult(kTestResult, false);
	FakeSpeechRecognitionEvent(RECOGNITION_END);
	session_id_ = 0;
	}

	void SendFakeMultipleFinalResults() {
	if (!session_id_)
	return;

	SendRecognitionResult(kTestResult, false);
	SendRecognitionResult(kTestResultMultiple, false);
	FakeSpeechRecognitionEvent(RECOGNITION_END);
	session_id_ = 0;
	}

	private:
	void SendRecognitionResult(const char* string, bool is_provisional) {
	content::SpeechRecognitionEventListener* listener = GetActiveListener();
	if (!listener)
	return;
	listener->OnAudioStart(session_id_);
	listener->OnAudioEnd(session_id_);

	content::SpeechRecognitionResult result;
	result.hypotheses.push_back(
	content::SpeechRecognitionHypothesis(base::ASCIIToUTF16(string), 1.0));
	result.is_provisional = is_provisional;
	content::SpeechRecognitionResults results;
	results.push_back(result);

	listener->OnRecognitionResults(session_id_, results);
	}

	content::SpeechRecognitionEventListener* GetActiveListener() {
	DCHECK(session_id_ != 0);
	return session_config_.event_listener.get();
	}

	int session_id_ = 0;
	content::SpeechRecognitionSessionContext session_ctx_;
	content::SpeechRecognitionSessionConfig session_config_;

	DISALLOW_COPY_AND_ASSIGN(FakeSpeechRecognitionManager);
	};

	class MockVoiceSearchDelegate : public VoiceResultDelegate {
	public:
	MockVoiceSearchDelegate() = default;
	~MockVoiceSearchDelegate() override = default;

	MOCK_METHOD1(OnVoiceResults, void(const base::string16& result));

	private:
	DISALLOW_COPY_AND_ASSIGN(MockVoiceSearchDelegate);
	};

	class SpeechRecognizerTest : public testing::Test {
	public:
	SpeechRecognizerTest()
	: fake_speech_recognition_manager_(new FakeSpeechRecognitionManager()),
	ui_(new MockBrowserUiInterface),
	delegate_(new MockVoiceSearchDelegate),
	speech_recognizer_(
	new SpeechRecognizer(delegate_.get(), ui_.get(), nullptr, "en")) {
	SpeechRecognizer::SetManagerForTest(fake_speech_recognition_manager_.get());
	}

	~SpeechRecognizerTest() override {
	SpeechRecognizer::SetManagerForTest(nullptr);
	}

	protected:
	content::TestBrowserThreadBundle thread_bundle_;
	std::unique_ptr<FakeSpeechRecognitionManager>
	fake_speech_recognition_manager_;
	std::unique_ptr<MockBrowserUiInterface> ui_;
	std::unique_ptr<MockVoiceSearchDelegate> delegate_;
	std::unique_ptr<SpeechRecognizer> speech_recognizer_;

	private:
	DISALLOW_COPY_AND_ASSIGN(SpeechRecognizerTest);
	};

	TEST_F(SpeechRecognizerTest, ReceivedCorrectSpeechResult) {
	testing::Sequence s;
	EXPECT_CALL(*ui_, SetSpeechRecognitionEnabled(true)).InSequence(s);
	EXPECT_CALL(*ui_, SetRecognitionResult(base::ASCIIToUTF16(kTestResult)))
	.InSequence(s);
	EXPECT_CALL(*delegate_, OnVoiceResults(base::ASCIIToUTF16(kTestResult)))
	.Times(1)
	.InSequence(s);
	EXPECT_CALL(*ui_, SetSpeechRecognitionEnabled(false)).InSequence(s);

	speech_recognizer_->Start();
	base::RunLoop().RunUntilIdle();

	// This should not trigger SetRecognitionResult as we don't show interim
	// result.
	fake_speech_recognition_manager_->FakeSpeechRecognitionEvent(INTERIM_RESULT);
	base::RunLoop().RunUntilIdle();

	// This should trigger SetRecognitionResult as we received final result.
	fake_speech_recognition_manager_->FakeSpeechRecognitionEvent(FINAL_RESULT);
	base::RunLoop().RunUntilIdle();
	}

	// Test for crbug.com/785051. It is possible that we receive multiple final
	// results in one recognition session. We should only navigate once in this
	// case.
	TEST_F(SpeechRecognizerTest, MultipleResultsTriggerNavigation) {
	testing::Sequence s;
	EXPECT_CALL(*ui_, SetSpeechRecognitionEnabled(true)).InSequence(s);
	EXPECT_CALL(*ui_,
	SetRecognitionResult(base::ASCIIToUTF16(kTestResultMultiple)))
	.InSequence(s);
	EXPECT_CALL(*delegate_,
	OnVoiceResults(base::ASCIIToUTF16(kTestResultMultiple)))
	.Times(1)
	.InSequence(s);
	EXPECT_CALL(*ui_, SetSpeechRecognitionEnabled(false)).InSequence(s);

	speech_recognizer_->Start();
	base::RunLoop().RunUntilIdle();

	fake_speech_recognition_manager_->FakeSpeechRecognitionEvent(
	MULTIPLE_FINAL_RESULT);
	base::RunLoop().RunUntilIdle();
	}

	TEST_F(SpeechRecognizerTest, ReceivedSpeechRecognitionStates) {
	speech_recognizer_->Start();
	base::RunLoop().RunUntilIdle();

	testing::Sequence s;
	EXPECT_CALL(*ui_,
	OnSpeechRecognitionStateChanged(SPEECH_RECOGNITION_RECOGNIZING))
	.InSequence(s);
	EXPECT_CALL(*ui_,
	OnSpeechRecognitionStateChanged(SPEECH_RECOGNITION_NETWORK_ERROR))
	.InSequence(s);
	EXPECT_CALL(*ui_, OnSpeechRecognitionStateChanged(SPEECH_RECOGNITION_END))
	.InSequence(s);

	fake_speech_recognition_manager_->FakeSpeechRecognitionEvent(
	RECOGNITION_START);
	base::RunLoop().RunUntilIdle();

	fake_speech_recognition_manager_->FakeSpeechRecognitionEvent(NETWORK_ERROR);
	base::RunLoop().RunUntilIdle();

	fake_speech_recognition_manager_->FakeSpeechRecognitionEvent(RECOGNITION_END);
	base::RunLoop().RunUntilIdle();
	}

	TEST_F(SpeechRecognizerTest, NoSoundTimeout) {
	testing::Sequence s;
	EXPECT_CALL(*ui_, SetSpeechRecognitionEnabled(true)).InSequence(s);
	EXPECT_CALL(*ui_,
	OnSpeechRecognitionStateChanged(SPEECH_RECOGNITION_IN_SPEECH))
	.InSequence(s);
	EXPECT_CALL(*ui_, OnSpeechRecognitionStateChanged(SPEECH_RECOGNITION_END))
	.InSequence(s);
	EXPECT_CALL(*ui_, SetSpeechRecognitionEnabled(false)).InSequence(s);

	speech_recognizer_->Start();
	base::RunLoop().RunUntilIdle();

	auto mock_timer = std::make_unique<base::MockTimer>(false, false);
	base::MockTimer* timer_ptr = mock_timer.get();
	speech_recognizer_->SetSpeechTimerForTest(std::move(mock_timer));

	fake_speech_recognition_manager_->FakeSpeechRecognitionEvent(SOUND_START);
	base::RunLoop().RunUntilIdle();

	// This should trigger a SPEECH_RECOGNITION_READY state notification.
	timer_ptr->Fire();
	base::RunLoop().RunUntilIdle();
	}

	// This test that it is safe to reset speech_recognizer_ on UI thread after post
	// a task to start speech recognition on IO thread.
	TEST_F(SpeechRecognizerTest, SafeToResetAfterStart) {
	EXPECT_CALL(*ui_,
	OnSpeechRecognitionStateChanged(SPEECH_RECOGNITION_RECOGNIZING));
	EXPECT_CALL(*ui_, SetRecognitionResult(base::ASCIIToUTF16(kTestResult)))
	.Times(0);

	speech_recognizer_->Start();
	base::RunLoop().RunUntilIdle();

	fake_speech_recognition_manager_->FakeSpeechRecognitionEvent(
	RECOGNITION_START);
	base::RunLoop().RunUntilIdle();

	fake_speech_recognition_manager_->FakeSpeechRecognitionEvent(FINAL_RESULT);
	// Reset shouldn't crash the test.
	speech_recognizer_.reset(nullptr);
	base::RunLoop().RunUntilIdle();
	}

	// This test that calling start after stop should still work as expected.
	TEST_F(SpeechRecognizerTest, RestartAfterStop) {
	EXPECT_CALL(*ui_, SetRecognitionResult(base::ASCIIToUTF16(kTestResult)))
	.Times(1);

	speech_recognizer_->Start();
	base::RunLoop().RunUntilIdle();

	fake_speech_recognition_manager_->FakeSpeechRecognitionEvent(FINAL_RESULT);
	speech_recognizer_->Stop();
	base::RunLoop().RunUntilIdle();

	speech_recognizer_->Start();
	base::RunLoop().RunUntilIdle();

	fake_speech_recognition_manager_->FakeSpeechRecognitionEvent(FINAL_RESULT);
	base::RunLoop().RunUntilIdle();
	}

	} // namespace vr