Pass task runners to AudioManager constructor.

media/audio/alsa/alsa_output_unittest.cc

 // Copyright 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 <stdint.h>
 
 #include "base/macros.h"
+#include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
+#include "base/test/test_message_loop.h"
+#include "base/thread_task_runner_handle.h"
 #include "media/audio/alsa/alsa_output.h"
 #include "media/audio/alsa/alsa_wrapper.h"
 #include "media/audio/alsa/audio_manager_alsa.h"
 #include "media/audio/fake_audio_log_factory.h"
 #include "media/audio/mock_audio_source_callback.h"
 #include "media/base/data_buffer.h"
 #include "media/base/seekable_buffer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 46 matching lines @@
   MOCK_METHOD1(PcmName, const char*(snd_pcm_t* handle));
   MOCK_METHOD1(PcmAvailUpdate, snd_pcm_sframes_t(snd_pcm_t* handle));
   MOCK_METHOD1(PcmState, snd_pcm_state_t(snd_pcm_t* handle));
   MOCK_METHOD1(PcmStart, int(snd_pcm_t* handle));
 
   MOCK_METHOD1(StrError, const char*(int errnum));
 };
 
 class MockAudioManagerAlsa : public AudioManagerAlsa {
  public:
-  MockAudioManagerAlsa() : AudioManagerAlsa(&fake_audio_log_factory_) {}
+  MockAudioManagerAlsa()
+      : AudioManagerAlsa(base::ThreadTaskRunnerHandle::Get(),
+                         base::ThreadTaskRunnerHandle::Get(),
+                         &fake_audio_log_factory_) {}
   MOCK_METHOD0(Init, void());
   MOCK_METHOD0(HasAudioOutputDevices, bool());
   MOCK_METHOD0(HasAudioInputDevices, bool());
   MOCK_METHOD1(MakeLinearOutputStream, AudioOutputStream*(
       const AudioParameters& params));
   MOCK_METHOD2(MakeLowLatencyOutputStream, AudioOutputStream*(
       const AudioParameters& params,
       const std::string& device_id));
   MOCK_METHOD2(MakeLowLatencyInputStream, AudioInputStream*(
       const AudioParameters& params, const std::string& device_id));
 
   // We need to override this function in order to skip the checking the number
   // of active output streams. It is because the number of active streams
   // is managed inside MakeAudioOutputStream, and we don't use
   // MakeAudioOutputStream to create the stream in the tests.
   void ReleaseOutputStream(AudioOutputStream* stream) override {
     DCHECK(stream);
     delete stream;
   }
 
-  // We don't mock this method since all tests will do the same thing
-  // and use the current task runner.
-  scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner() override {
-    return base::MessageLoop::current()->task_runner();
-  }
-
  private:
   FakeAudioLogFactory fake_audio_log_factory_;
 };
 
 class AlsaPcmOutputStreamTest : public testing::Test {
  protected:
   AlsaPcmOutputStreamTest() {
     mock_manager_.reset(new StrictMock<MockAudioManagerAlsa>());
   }
 
@@ skipping 49 matching lines @@
   // Used to simulate DeviceNameHint.
   static char kSurround40[];
   static char kSurround41[];
   static char kSurround50[];
   static char kSurround51[];
   static char kSurround70[];
   static char kSurround71[];
   static void* kFakeHints[];
   static char kGenericSurround50[];
 
+  base::TestMessageLoop message_loop_;
   StrictMock<MockAlsaWrapper> mock_alsa_wrapper_;
-  scoped_ptr<StrictMock<MockAudioManagerAlsa> > mock_manager_;
-  base::MessageLoop message_loop_;
+  std::unique_ptr<StrictMock<MockAudioManagerAlsa>, AudioManagerDeleter>
+      mock_manager_;
   scoped_refptr<media::DataBuffer> packet_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AlsaPcmOutputStreamTest);
 };
 
 const ChannelLayout AlsaPcmOutputStreamTest::kTestChannelLayout =
     CHANNEL_LAYOUT_STEREO;
 const int AlsaPcmOutputStreamTest::kTestSampleRate =
     AudioParameters::kAudioCDSampleRate;
@@ skipping 251 matching lines @@
   // Expect scheduling.
   EXPECT_CALL(mock_alsa_wrapper_, PcmAvailUpdate(kFakeHandle))
       .Times(AtLeast(2))
       .WillRepeatedly(Return(kTestFramesPerPacket));
 
   test_stream->Start(&mock_callback);
   // Start() will issue a WriteTask() directly and then schedule the next one,
   // call Stop() immediately after to ensure we don't run the message loop
   // forever.
   test_stream->Stop();
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_CALL(mock_alsa_wrapper_, PcmClose(kFakeHandle))
       .WillOnce(Return(0));
   EXPECT_CALL(mock_alsa_wrapper_, PcmName(kFakeHandle))
       .WillOnce(Return(kTestDeviceName));
   test_stream->Close();
 }
 
 TEST_F(AlsaPcmOutputStreamTest, WritePacket_FinishedPacket) {
   AlsaPcmOutputStream* test_stream = CreateStream(kTestChannelLayout);
@@ skipping 397 matching lines @@
 
   // TODO(ajwong): Find a way to test whether or not another task has been
   // posted so we can verify that the Alsa code will indeed break the task
   // posting loop.
 
   test_stream->TransitionTo(AlsaPcmOutputStream::kIsClosed);
   test_stream->Close();
 }
 
 }  // namespace media