Remove the AudioManager singleton.

media/audio/linux/alsa_output_unittest.cc

 // Copyright (c) 2011 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 "base/message_loop.h"
 #include "base/stringprintf.h"
 #include "media/audio/linux/alsa_output.h"
 #include "media/audio/linux/alsa_wrapper.h"
 #include "media/audio/linux/audio_manager_linux.h"
 #include "media/base/data_buffer.h"
@@ skipping 73 matching lines @@
       const AudioParameters& params, const std::string& device_id));
   MOCK_METHOD0(MuteAll, void());
   MOCK_METHOD0(UnMuteAll, void());
 
   MOCK_METHOD1(ReleaseOutputStream, void(AudioOutputStream* stream));
 };
 
 class AlsaPcmOutputStreamTest : public testing::Test {
  protected:
   AlsaPcmOutputStreamTest() {
+    mock_manager_ = new StrictMock<MockAudioManagerLinux>();
     test_stream_.reset(CreateStream(kTestChannelLayout));
   }
 
   virtual ~AlsaPcmOutputStreamTest() {
     test_stream_.reset(NULL);
   }
 
   AlsaPcmOutputStream* CreateStream(ChannelLayout layout) {
     return CreateStream(layout, kTestFramesPerPacket);
   }
 
   AlsaPcmOutputStream* CreateStream(ChannelLayout layout,
                                     int32 samples_per_packet) {
     AudioParameters params(kTestFormat, layout, kTestSampleRate,
                            kTestBitsPerSample, samples_per_packet);
     return new AlsaPcmOutputStream(kTestDeviceName,
                                    params,
                                    &mock_alsa_wrapper_,
-                                   &mock_manager_,
+                                   mock_manager_.get(),

[scherkus (not reviewing), 2011/12/09 22:47:30]

.get() here and below

[tommi (sloooow) - chröme, 2011/12/10 00:11:14]

Done.

                                    &message_loop_);
   }
 
   // Helper function to malloc the string returned by DeviceNameHint for NAME.
   static char* EchoHint(const void* name, Unused) {
     return strdup(static_cast<const char*>(name));
   }
 
   // Helper function to malloc the string returned by DeviceNameHint for IOID.
   static char* OutputHint(Unused, Unused) {
     return strdup("Output");
   }
 
   // Helper function to initialize |test_stream_->buffer_|. Must be called
   // in all tests that use buffer_ without opening the stream.
   void InitBuffer() {
     packet_ = new media::DataBuffer(kTestPacketSize);
     packet_->SetDataSize(kTestPacketSize);
     test_stream_->buffer_.reset(new media::SeekableBuffer(0, kTestPacketSize));
     test_stream_->buffer_->Append(packet_.get());
   }
 
+  MockAudioManagerLinux& mock_manager() {
+    return *mock_manager_.get();
+  }
+
   static const ChannelLayout kTestChannelLayout;
   static const int kTestSampleRate;
   static const int kTestBitsPerSample;
   static const int kTestBytesPerFrame;
   static const AudioParameters::Format kTestFormat;
   static const char kTestDeviceName[];
   static const char kDummyMessage[];
   static const uint32 kTestFramesPerPacket;
   static const uint32 kTestPacketSize;
   static const int kTestFailedErrno;
   static snd_pcm_t* const kFakeHandle;
 
   // 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[];
 
   StrictMock<MockAlsaWrapper> mock_alsa_wrapper_;
-  StrictMock<MockAudioManagerLinux> mock_manager_;
+  scoped_refptr<StrictMock<MockAudioManagerLinux> > mock_manager_;
   MessageLoop message_loop_;
   scoped_ptr<AlsaPcmOutputStream> test_stream_;
   scoped_refptr<media::DataBuffer> packet_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AlsaPcmOutputStreamTest);
 };
 
 const ChannelLayout AlsaPcmOutputStreamTest::kTestChannelLayout =
     CHANNEL_LAYOUT_STEREO;
@@ skipping 36 matching lines @@
   test_stream_.reset(CreateStream(CHANNEL_LAYOUT_SURROUND));
   EXPECT_EQ(AlsaPcmOutputStream::kCreated, test_stream_->state());
 
   // Bad bits per sample.
   AudioParameters bad_bps_params(kTestFormat, kTestChannelLayout,
                                  kTestSampleRate, kTestBitsPerSample - 1,
                                  kTestFramesPerPacket);
   test_stream_.reset(new AlsaPcmOutputStream(kTestDeviceName,
                                              bad_bps_params,
                                              &mock_alsa_wrapper_,
-                                             &mock_manager_,
+                                             mock_manager_.get(),
                                              &message_loop_));
   EXPECT_EQ(AlsaPcmOutputStream::kInError, test_stream_->state());
 
   // Bad format.
   AudioParameters bad_format_params(
       AudioParameters::AUDIO_LAST_FORMAT, kTestChannelLayout, kTestSampleRate,
       kTestBitsPerSample, kTestFramesPerPacket);
   test_stream_.reset(new AlsaPcmOutputStream(kTestDeviceName,
                                              bad_format_params,
                                              &mock_alsa_wrapper_,
-                                             &mock_manager_,
+                                             mock_manager_.get(),
                                              &message_loop_));
   EXPECT_EQ(AlsaPcmOutputStream::kInError, test_stream_->state());
 }
 
 TEST_F(AlsaPcmOutputStreamTest, LatencyFloor) {
   const double kMicrosPerFrame =
       static_cast<double>(1000000) / kTestSampleRate;
   const double kPacketFramesInMinLatency =
       AlsaPcmOutputStream::kMinLatencyMicros / kMicrosPerFrame / 2.0;
 
@@ skipping 14 matching lines @@
 
   test_stream_.reset(CreateStream(kTestChannelLayout,
                                   kPacketFramesInMinLatency));
   ASSERT_TRUE(test_stream_->Open());
   message_loop_.RunAllPending();
 
   // Now close it and test that everything was released.
   EXPECT_CALL(mock_alsa_wrapper_, PcmClose(kFakeHandle)).WillOnce(Return(0));
   EXPECT_CALL(mock_alsa_wrapper_, PcmName(kFakeHandle))
       .WillOnce(Return(kTestDeviceName));
-  EXPECT_CALL(mock_manager_, ReleaseOutputStream(test_stream_.get()));
+  EXPECT_CALL(mock_manager(), ReleaseOutputStream(test_stream_.get()));
   test_stream_->Close();
   message_loop_.RunAllPending();
 
   Mock::VerifyAndClear(&mock_alsa_wrapper_);
-  Mock::VerifyAndClear(&mock_manager_);
+  Mock::VerifyAndClear(mock_manager_.get());
 
   // Test that having more packets ends up with a latency based on packet size.
   const int kOverMinLatencyPacketSize = kPacketFramesInMinLatency + 1;
   int64 expected_micros = 2 * AlsaPcmOutputStream::FramesToMicros(
       kOverMinLatencyPacketSize, kTestSampleRate);
 
   EXPECT_CALL(mock_alsa_wrapper_, PcmOpen(_, _, _, _))
       .WillOnce(DoAll(SetArgumentPointee<0>(kFakeHandle), Return(0)));
   EXPECT_CALL(mock_alsa_wrapper_,
               PcmSetParams(_, _, _, _, _, _, expected_micros))
       .WillOnce(Return(0));
   EXPECT_CALL(mock_alsa_wrapper_, PcmGetParams(_, _, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(kTestFramesPerPacket),
                       SetArgumentPointee<2>(kTestFramesPerPacket / 2),
                       Return(0)));
 
   test_stream_.reset(CreateStream(kTestChannelLayout,
                                   kOverMinLatencyPacketSize));
   ASSERT_TRUE(test_stream_->Open());
   message_loop_.RunAllPending();
 
   // Now close it and test that everything was released.
   EXPECT_CALL(mock_alsa_wrapper_, PcmClose(kFakeHandle))
       .WillOnce(Return(0));
   EXPECT_CALL(mock_alsa_wrapper_, PcmName(kFakeHandle))
       .WillOnce(Return(kTestDeviceName));
-  EXPECT_CALL(mock_manager_, ReleaseOutputStream(test_stream_.get()));
+  EXPECT_CALL(mock_manager(), ReleaseOutputStream(test_stream_.get()));
   test_stream_->Close();
   message_loop_.RunAllPending();
 
   Mock::VerifyAndClear(&mock_alsa_wrapper_);
-  Mock::VerifyAndClear(&mock_manager_);
+  Mock::VerifyAndClear(mock_manager_.get());
 }
 
 TEST_F(AlsaPcmOutputStreamTest, OpenClose) {
   int64 expected_micros = 2 *
       AlsaPcmOutputStream::FramesToMicros(kTestPacketSize / kTestBytesPerFrame,
                                           kTestSampleRate);
 
   // Open() call opens the playback device, sets the parameters, posts a task
   // with the resulting configuration data, and transitions the object state to
   // kIsOpened.
@@ skipping 24 matching lines @@
   EXPECT_EQ(kFakeHandle, test_stream_->playback_handle_);
   EXPECT_EQ(kTestFramesPerPacket, test_stream_->frames_per_packet_);
   EXPECT_TRUE(test_stream_->buffer_.get());
   EXPECT_FALSE(test_stream_->stop_stream_);
 
   // Now close it and test that everything was released.
   EXPECT_CALL(mock_alsa_wrapper_, PcmClose(kFakeHandle))
       .WillOnce(Return(0));
   EXPECT_CALL(mock_alsa_wrapper_, PcmName(kFakeHandle))
       .WillOnce(Return(kTestDeviceName));
-  EXPECT_CALL(mock_manager_, ReleaseOutputStream(test_stream_.get()));
+  EXPECT_CALL(mock_manager(), ReleaseOutputStream(test_stream_.get()));
   test_stream_->Close();
   message_loop_.RunAllPending();
 
   EXPECT_TRUE(test_stream_->playback_handle_ == NULL);
   EXPECT_FALSE(test_stream_->buffer_.get());
   EXPECT_TRUE(test_stream_->stop_stream_);
 }
 
 TEST_F(AlsaPcmOutputStreamTest, PcmOpenFailed) {
   EXPECT_CALL(mock_alsa_wrapper_, PcmOpen(_, _, _, _))
       .WillOnce(Return(kTestFailedErrno));
   EXPECT_CALL(mock_alsa_wrapper_, StrError(kTestFailedErrno))
       .WillOnce(Return(kDummyMessage));
 
   // Open still succeeds since PcmOpen is delegated to another thread.
   ASSERT_TRUE(test_stream_->Open());
   ASSERT_EQ(AlsaPcmOutputStream::kIsOpened, test_stream_->state());
   ASSERT_FALSE(test_stream_->stop_stream_);
   message_loop_.RunAllPending();
 
   // Ensure internal state is set for a no-op stream if PcmOpen() failes.
   EXPECT_EQ(AlsaPcmOutputStream::kIsOpened, test_stream_->state());
   EXPECT_TRUE(test_stream_->stop_stream_);
   EXPECT_TRUE(test_stream_->playback_handle_ == NULL);
   EXPECT_FALSE(test_stream_->buffer_.get());
 
   // Close the stream since we opened it to make destruction happy.
-  EXPECT_CALL(mock_manager_, ReleaseOutputStream(test_stream_.get()));
+  EXPECT_CALL(mock_manager(), ReleaseOutputStream(test_stream_.get()));
   test_stream_->Close();
   message_loop_.RunAllPending();
 }
 
 TEST_F(AlsaPcmOutputStreamTest, PcmSetParamsFailed) {
   EXPECT_CALL(mock_alsa_wrapper_, PcmOpen(_, _, _, _))
       .WillOnce(DoAll(SetArgumentPointee<0>(kFakeHandle),
                       Return(0)));
   EXPECT_CALL(mock_alsa_wrapper_, PcmSetParams(_, _, _, _, _, _, _))
       .WillOnce(Return(kTestFailedErrno));
@@ skipping 11 matching lines @@
   ASSERT_FALSE(test_stream_->stop_stream_);
   message_loop_.RunAllPending();
 
   // Ensure internal state is set for a no-op stream if PcmSetParams() failes.
   EXPECT_EQ(AlsaPcmOutputStream::kIsOpened, test_stream_->state());
   EXPECT_TRUE(test_stream_->stop_stream_);
   EXPECT_TRUE(test_stream_->playback_handle_ == NULL);
   EXPECT_FALSE(test_stream_->buffer_.get());
 
   // Close the stream since we opened it to make destruction happy.
-  EXPECT_CALL(mock_manager_, ReleaseOutputStream(test_stream_.get()));
+  EXPECT_CALL(mock_manager(), ReleaseOutputStream(test_stream_.get()));
   test_stream_->Close();
   message_loop_.RunAllPending();
 }
 
 TEST_F(AlsaPcmOutputStreamTest, StartStop) {
   // Open() call opens the playback device, sets the parameters, posts a task
   // with the resulting configuration data, and transitions the object state to
   // kIsOpened.
   EXPECT_CALL(mock_alsa_wrapper_, PcmOpen(_, _, _, _))
       .WillOnce(DoAll(SetArgumentPointee<0>(kFakeHandle),
@@ skipping 36 matching lines @@
       .Times(AtLeast(3))
       .WillOnce(Return(kTestFramesPerPacket))  // Buffer is empty.
       .WillOnce(Return(kTestFramesPerPacket))
       .WillRepeatedly(DoAll(InvokeWithoutArgs(&message_loop_,
                                               &MessageLoop::QuitNow),
                                               Return(0)));  // Buffer is full.
 
   test_stream_->Start(&mock_callback);
   message_loop_.RunAllPending();
 
-  EXPECT_CALL(mock_manager_, ReleaseOutputStream(test_stream_.get()));
+  EXPECT_CALL(mock_manager(), ReleaseOutputStream(test_stream_.get()));
   EXPECT_CALL(mock_alsa_wrapper_, PcmClose(kFakeHandle))
       .WillOnce(Return(0));
   EXPECT_CALL(mock_alsa_wrapper_, PcmName(kFakeHandle))
       .WillOnce(Return(kTestDeviceName));
   test_stream_->Close();
   message_loop_.RunAllPending();
 }
 
 TEST_F(AlsaPcmOutputStreamTest, WritePacket_FinishedPacket) {
   InitBuffer();
@@ skipping 208 matching lines @@
     EXPECT_CALL(mock_alsa_wrapper_, DeviceNameGetHint(_, StrEq("IOID")))
         .WillRepeatedly(Invoke(OutputHint));
     EXPECT_CALL(mock_alsa_wrapper_, DeviceNameGetHint(_, StrEq("NAME")))
         .WillRepeatedly(Invoke(EchoHint));
 
     test_stream_.reset(CreateStream(kExpectedLayouts[i]));
     EXPECT_TRUE(test_stream_->AutoSelectDevice(i));
     EXPECT_EQ(kExpectedDownmix[i], test_stream_->should_downmix_);
 
     Mock::VerifyAndClearExpectations(&mock_alsa_wrapper_);
-    Mock::VerifyAndClearExpectations(&mock_manager_);
+    Mock::VerifyAndClearExpectations(mock_manager_.get());
   }
 }
 
 TEST_F(AlsaPcmOutputStreamTest, AutoSelectDevice_FallbackDevices) {
   using std::string;
 
   // If there are problems opening a multi-channel device, it the fallbacks
   // operations should be as follows.  Assume the multi-channel device name is
   // surround50:
   //
@@ skipping 93 matching lines @@
 
   test_stream_->stop_stream_ = true;
   test_stream_->ScheduleNextWrite(true);
 
   // 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);
 }