Ensures that audio tasks cannot run after AudioManager is deleted.

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/run_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/sys_byteorder.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.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 "content/public/test/test_browser_thread_bundle.h"
 #include "media/audio/audio_device_description.h"
 #include "media/audio/audio_system_impl.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/audio/test_audio_thread.h"
 #include "media/base/audio_bus.h"
 #include "media/base/test_helpers.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using media::AudioInputController;
 using media::AudioInputStream;
 using media::AudioOutputStream;
 using media::AudioParameters;
 using media::TestAudioInputController;
 using media::TestAudioInputControllerFactory;
 
 namespace content {
 
 class SpeechRecognizerImplTest : public SpeechRecognitionEventListener,
                                  public testing::Test {
  public:
   SpeechRecognizerImplTest()
-      : audio_thread_("SpeechAudioThread"),
-        recognition_started_(false),
+      : recognition_started_(false),
         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 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;
 
-    audio_thread_.StartAndWaitForTesting();
-    audio_manager_.reset(
-        new media::MockAudioManager(audio_thread_.task_runner()));
+    audio_manager_.reset(new media::MockAudioManager(
+        base::MakeUnique<media::TestAudioThread>(true)));
     audio_manager_->SetInputStreamParameters(
         media::AudioParameters::UnavailableDeviceParams());
     audio_system_ = media::AudioSystemImpl::Create(audio_manager_.get());
     recognizer_ = new SpeechRecognizerImpl(
         this, audio_system_.get(), audio_manager_.get(), kTestingSessionId,
         false, false, sr_engine);
 
     int audio_packet_length_bytes =
         (SpeechRecognizerImpl::kAudioSampleRate *
          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();
   }
 
-  ~SpeechRecognizerImplTest() override {
-    // Deleting |audio_manager_| on audio thread.
-    audio_system_.reset();
-    audio_manager_.reset();
-    audio_thread_.Stop();
-  }
+  ~SpeechRecognizerImplTest() override { audio_manager_->Shutdown(); }
 
   void CheckEventsConsistency() {
     // Note: "!x || y" == "x implies y".
     EXPECT_TRUE(!recognition_ended_ || recognition_started_);
     EXPECT_TRUE(!audio_ended_ || audio_started_);
     EXPECT_TRUE(!sound_ended_ || sound_started_);
     EXPECT_TRUE(!audio_started_ || recognition_started_);
     EXPECT_TRUE(!sound_started_ || audio_started_);
     EXPECT_TRUE(!audio_ended_ || (sound_ended_ || !sound_started_));
     EXPECT_TRUE(!recognition_ended_ || (audio_ended_ || !audio_started_));
@@ skipping 92 matching lines @@
   }
 
   void OnData(media::AudioBus* data) {
     auto* writer =
         static_cast<AudioInputController::SyncWriter*>(recognizer_.get());
     writer->Write(data, 0.0, false, 0);
   }
 
   void WaitForAudioThreadToPostDeviceInfo() {
     media::WaitableMessageLoopEvent event;
-    audio_thread_.task_runner()->PostTaskAndReply(
+    audio_manager_->GetTaskRunner()->PostTaskAndReply(
         FROM_HERE, base::Bind(&base::DoNothing), event.GetClosure());
-    // Runs the loop and waits for the |audio_thread_| to call event's closure,
+    // Runs the loop and waits for the audio thread to call event's closure,
     // which means AudioSystem reply containing device parameters is already
     // queued on the main thread.
     event.RunAndWait();
   }
 
  protected:
   TestBrowserThreadBundle thread_bundle_;
   scoped_refptr<SpeechRecognizerImpl> recognizer_;
-  base::Thread audio_thread_;
-  media::MockAudioManager::UniquePtr audio_manager_;
+  std::unique_ptr<media::MockAudioManager> audio_manager_;
   std::unique_ptr<media::AudioSystem> audio_system_;
   bool recognition_started_;
   bool recognition_ended_;
   bool result_received_;
   bool audio_started_;
   bool audio_ended_;
   bool sound_started_;
   bool sound_ended_;
   SpeechRecognitionErrorCode error_;
   net::TestURLFetcherFactory url_fetcher_factory_;
@@ skipping 20 matching lines @@
   CheckFinalEventsConsistency();
 }
 
 TEST_F(SpeechRecognizerImplTest, StopBeforeDeviceInfoReceived) {
   // Check for callbacks when stopping record before reply is received from
   // AudioSystem.
   base::WaitableEvent event(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                             base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   // Block audio thread.
-  audio_thread_.task_runner()->PostTask(
+  audio_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&base::WaitableEvent::Wait, base::Unretained(&event)));
 
   recognizer_->StartRecognition(
       media::AudioDeviceDescription::kDefaultDeviceId);
   recognizer_->StopAudioCapture();
   base::RunLoop().RunUntilIdle();
 
   // Release audio thread and receive a callback from it.
   event.Signal();
   WaitForAudioThreadToPostDeviceInfo();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(recognition_started_);
   EXPECT_FALSE(audio_started_);
   EXPECT_FALSE(result_received_);
   EXPECT_EQ(SPEECH_RECOGNITION_ERROR_NONE, error_);
   CheckFinalEventsConsistency();
 }
 
 TEST_F(SpeechRecognizerImplTest, CancelBeforeDeviceInfoReceived) {
   // Check for callbacks when stopping record before reply is received from
   // AudioSystem.
   base::WaitableEvent event(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                             base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   // Block audio thread.
-  audio_thread_.task_runner()->PostTask(
+  audio_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&base::WaitableEvent::Wait, base::Unretained(&event)));
 
   recognizer_->StartRecognition(
       media::AudioDeviceDescription::kDefaultDeviceId);
   recognizer_->AbortRecognition();
   base::RunLoop().RunUntilIdle();
 
   // Release audio thread and receive a callback from it.
   event.Signal();
@@ skipping 347 matching lines @@
 
   EXPECT_EQ(SPEECH_RECOGNITION_ERROR_NONE, error_);
   EXPECT_FALSE(audio_ended_);
   EXPECT_FALSE(recognition_ended_);
   recognizer_->AbortRecognition();
   base::RunLoop().RunUntilIdle();
   CheckFinalEventsConsistency();
 }
 
 }  // namespace content