Move Alsa device opening into the audio thread, and add in support for multi-channel audio.

media/audio/linux/alsa_output_unittest.cc

 // Copyright (c) 2009 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/logging.h"
+#include "base/string_util.h"
 #include "media/audio/linux/alsa_output.h"
 #include "media/audio/linux/alsa_wrapper.h"
 #include "media/audio/linux/audio_manager_linux.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::DoAll;
 using testing::Eq;
+using testing::InSequence;
+using testing::Invoke;
+using testing::Mock;
+using testing::MockFunction;
 using testing::Return;
 using testing::SetArgumentPointee;
 using testing::StrictMock;
 using testing::StrEq;
+using testing::Unused;
 
 class MockAlsaWrapper : public AlsaWrapper {
  public:
+  MOCK_METHOD3(DeviceNameHint, int(int card,
+                                   const char* iface,
+                                   void*** hints));
+  MOCK_METHOD2(DeviceNameGetHint, char*(const void* hint, const char* id));
+  MOCK_METHOD1(DeviceNameFreeHint, int(void** hints));
+
   MOCK_METHOD4(PcmOpen, int(snd_pcm_t** handle, const char* name,
                             snd_pcm_stream_t stream, int mode));
   MOCK_METHOD1(PcmClose, int(snd_pcm_t* handle));
   MOCK_METHOD1(PcmPrepare, int(snd_pcm_t* handle));
   MOCK_METHOD1(PcmDrop, int(snd_pcm_t* handle));
   MOCK_METHOD2(PcmDelay, int(snd_pcm_t* handle, snd_pcm_sframes_t* delay));
   MOCK_METHOD3(PcmWritei, snd_pcm_sframes_t(snd_pcm_t* handle,
                                             const void* buffer,
                                             snd_pcm_uframes_t size));
   MOCK_METHOD3(PcmRecover, int(snd_pcm_t* handle, int err, int silent));
@@ skipping 25 matching lines @@
   MOCK_METHOD0(MuteAll, void());
   MOCK_METHOD0(UnMuteAll, void());
 
   MOCK_METHOD1(ReleaseStream, void(AlsaPcmOutputStream* stream));
 };
 
 class AlsaPcmOutputStreamTest : public testing::Test {
  protected:
   AlsaPcmOutputStreamTest()
       : packet_(kTestPacketSize + 1) {
-    test_stream_ = new AlsaPcmOutputStream(kTestDeviceName,
-                                           kTestFormat,
-                                           kTestChannels,
-                                           kTestSampleRate,
-                                           kTestBitsPerSample,
-                                           &mock_alsa_wrapper_,
-                                           &mock_manager_,
-                                           &message_loop_);
-
+    test_stream_ = CreateStreamWithChannels(kTestChannels);
     packet_.size = kTestPacketSize;
   }
 
   virtual ~AlsaPcmOutputStreamTest() {
     test_stream_ = NULL;
   }
 
+  AlsaPcmOutputStream* CreateStreamWithChannels(int channels) {
+    return new AlsaPcmOutputStream(kTestDeviceName,
+                                   kTestFormat,
+                                   channels,
+                                   kTestSampleRate,
+                                   kTestBitsPerSample,
+                                   &mock_alsa_wrapper_,
+                                   &mock_manager_,
+                                   &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");
+  }
+
   static const int kTestChannels;
   static const int kTestSampleRate;
   static const int kTestBitsPerSample;
   static const int kTestBytesPerFrame;
   static const AudioManager::Format kTestFormat;
   static const char kTestDeviceName[];
   static const char kDummyMessage[];
   static const int kTestFramesPerPacket;
   static const size_t 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_;
   MessageLoop message_loop_;
   scoped_refptr<AlsaPcmOutputStream> test_stream_;
   AlsaPcmOutputStream::Packet packet_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AlsaPcmOutputStreamTest);
 };
 
 const int AlsaPcmOutputStreamTest::kTestChannels = 2;
 const int AlsaPcmOutputStreamTest::kTestSampleRate =
     AudioManager::kAudioCDSampleRate;
 const int AlsaPcmOutputStreamTest::kTestBitsPerSample = 8;
 const int AlsaPcmOutputStreamTest::kTestBytesPerFrame =
     AlsaPcmOutputStreamTest::kTestBitsPerSample / 8 *
     AlsaPcmOutputStreamTest::kTestChannels;
 const AudioManager::Format AlsaPcmOutputStreamTest::kTestFormat =
     AudioManager::AUDIO_PCM_LINEAR;
 const char AlsaPcmOutputStreamTest::kTestDeviceName[] = "TestDevice";
 const char AlsaPcmOutputStreamTest::kDummyMessage[] = "dummy";
-const int AlsaPcmOutputStreamTest::kTestFramesPerPacket = 100;
+const int AlsaPcmOutputStreamTest::kTestFramesPerPacket = 1000;
 const size_t AlsaPcmOutputStreamTest::kTestPacketSize =
     AlsaPcmOutputStreamTest::kTestFramesPerPacket *
     AlsaPcmOutputStreamTest::kTestBytesPerFrame;
 const int AlsaPcmOutputStreamTest::kTestFailedErrno = -EACCES;
 snd_pcm_t* const AlsaPcmOutputStreamTest::kFakeHandle =
     reinterpret_cast<snd_pcm_t*>(1);
 
+char AlsaPcmOutputStreamTest::kSurround40[] = "surround40:CARD=foo,DEV=0";
+char AlsaPcmOutputStreamTest::kSurround41[] = "surround41:CARD=foo,DEV=0";
+char AlsaPcmOutputStreamTest::kSurround50[] = "surround50:CARD=foo,DEV=0";
+char AlsaPcmOutputStreamTest::kSurround51[] = "surround51:CARD=foo,DEV=0";
+char AlsaPcmOutputStreamTest::kSurround70[] = "surround70:CARD=foo,DEV=0";
+char AlsaPcmOutputStreamTest::kSurround71[] = "surround71:CARD=foo,DEV=0";
+void* AlsaPcmOutputStreamTest::kFakeHints[] = {
+    kSurround40, kSurround41, kSurround50, kSurround51,
+    kSurround70, kSurround71, NULL };
+
 TEST_F(AlsaPcmOutputStreamTest, ConstructedState) {
   EXPECT_EQ(AlsaPcmOutputStream::kCreated,
             test_stream_->shared_data_.state());
 
   // Should support mono.
-  test_stream_ = new AlsaPcmOutputStream(kTestDeviceName,
-                                         kTestFormat,
-                                         1,  // Channels.
-                                         kTestSampleRate,
-                                         kTestBitsPerSample,
-                                         &mock_alsa_wrapper_,
-                                         &mock_manager_,
-                                         &message_loop_);
+  test_stream_ = CreateStreamWithChannels(1);
   EXPECT_EQ(AlsaPcmOutputStream::kCreated,
             test_stream_->shared_data_.state());
 
-  // Should not support multi-channel.
-  test_stream_ = new AlsaPcmOutputStream(kTestDeviceName,
-                                         kTestFormat,
-                                         3,  // Channels.
-                                         kTestSampleRate,
-                                         kTestBitsPerSample,
-                                         &mock_alsa_wrapper_,
-                                         &mock_manager_,
-                                         &message_loop_);
-  EXPECT_EQ(AlsaPcmOutputStream::kInError,
+  // Should support multi-channel.
+  test_stream_ = CreateStreamWithChannels(3);
+  EXPECT_EQ(AlsaPcmOutputStream::kCreated,
             test_stream_->shared_data_.state());
 
   // Bad bits per sample.
   test_stream_ = new AlsaPcmOutputStream(kTestDeviceName,
                                          kTestFormat,
                                          kTestChannels,
                                          kTestSampleRate,
                                          kTestBitsPerSample - 1,
                                          &mock_alsa_wrapper_,
                                          &mock_manager_,
                                          &message_loop_);
   EXPECT_EQ(AlsaPcmOutputStream::kInError,
             test_stream_->shared_data_.state());
 
   // Bad format.
   test_stream_ = new AlsaPcmOutputStream(kTestDeviceName,
                                          AudioManager::AUDIO_PCM_DELTA,
                                          kTestChannels,
                                          kTestSampleRate,
                                          kTestBitsPerSample,
                                          &mock_alsa_wrapper_,
                                          &mock_manager_,
                                          &message_loop_);
   EXPECT_EQ(AlsaPcmOutputStream::kInError,
             test_stream_->shared_data_.state());
 }
 
+TEST_F(AlsaPcmOutputStreamTest, LatencyFloor) {
+  const double kMicrosPerFrame =
+      static_cast<double>(1000000) / kTestSampleRate;
+  const double kPacketFramesInMinLatency =
+      AlsaPcmOutputStream::kMinLatencyMicros / kMicrosPerFrame / 2.0;
+  const int kMinLatencyPacketSize =
+      static_cast<int>(kPacketFramesInMinLatency * kTestBytesPerFrame);
+
+  // Test that packets which would cause a latency under less than
+  // AlsaPcmOutputStream::kMinLatencyMicros will get clipped to
+  // AlsaPcmOutputStream::kMinLatencyMicros,
+  EXPECT_CALL(mock_alsa_wrapper_, PcmOpen(_, _, _, _))
+      .WillOnce(DoAll(SetArgumentPointee<0>(kFakeHandle),
+                      Return(0)));
+  EXPECT_CALL(mock_alsa_wrapper_,
+              PcmSetParams(_, _, _, _, _, _,
+                           AlsaPcmOutputStream::kMinLatencyMicros))
+      .WillOnce(Return(0));
+
+  ASSERT_TRUE(test_stream_->Open(kMinLatencyPacketSize));
+  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_manager_, ReleaseStream(test_stream_.get()));
+  test_stream_->Close();
+  message_loop_.RunAllPending();
+
+  Mock::VerifyAndClear(&mock_alsa_wrapper_);
+  Mock::VerifyAndClear(&mock_manager_);
+
+  // Test that having more packets ends up with a latency based on packet size.
+  const int kOverMinLatencyPacketSize =
+      (kPacketFramesInMinLatency + 1) * kTestBytesPerFrame;
+  int64 expected_micros = 2 *
+      AlsaPcmOutputStream::FramesToMicros(
+          kOverMinLatencyPacketSize / kTestBytesPerFrame,
+          kTestSampleRate);
+
+  // Recreate the stream to reset the state.
+  test_stream_ = CreateStreamWithChannels(kTestChannels);
+
+  EXPECT_CALL(mock_alsa_wrapper_, PcmOpen(_, _, _, _))
+      .WillOnce(DoAll(SetArgumentPointee<0>(kFakeHandle), Return(0)));
+  EXPECT_CALL(mock_alsa_wrapper_,
+              PcmSetParams(_, _, _, _, _, _, expected_micros))
+      .WillOnce(Return(0));
+
+  ASSERT_TRUE(test_stream_->Open(kOverMinLatencyPacketSize));
+  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_manager_, ReleaseStream(test_stream_.get()));
+  test_stream_->Close();
+  message_loop_.RunAllPending();
+
+  Mock::VerifyAndClear(&mock_alsa_wrapper_);
+  Mock::VerifyAndClear(&mock_manager_);
+}
+
 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.
   EXPECT_CALL(mock_alsa_wrapper_,
               PcmOpen(_, StrEq(kTestDeviceName),
                       SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK))
       .WillOnce(DoAll(SetArgumentPointee<0>(kFakeHandle),
                       Return(0)));
   EXPECT_CALL(mock_alsa_wrapper_,
               PcmSetParams(kFakeHandle,
-                           SND_PCM_FORMAT_S8,
+                           SND_PCM_FORMAT_U8,
                            SND_PCM_ACCESS_RW_INTERLEAVED,
                            kTestChannels,
                            kTestSampleRate,
                            1,
                            expected_micros))
       .WillOnce(Return(0));
 
   // Open the stream.
   ASSERT_TRUE(test_stream_->Open(kTestPacketSize));
   message_loop_.RunAllPending();
@@ skipping 16 matching lines @@
   EXPECT_FALSE(test_stream_->packet_.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));
 
-  // If open fails, the stream stays in kCreated because it has effectively had
-  // no changes.
-  ASSERT_FALSE(test_stream_->Open(kTestPacketSize));
-  EXPECT_EQ(AlsaPcmOutputStream::kCreated,
+  // Open still succeeds since PcmOpen is delegated to another thread.
+  ASSERT_TRUE(test_stream_->Open(kTestPacketSize));
+  ASSERT_EQ(AlsaPcmOutputStream::kIsOpened,
             test_stream_->shared_data_.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_->shared_data_.state());
+  EXPECT_TRUE(test_stream_->stop_stream_);
+  EXPECT_TRUE(test_stream_->playback_handle_ == NULL);
+  EXPECT_FALSE(test_stream_->packet_.get());
+
+  // Close the stream since we opened it to make destruction happy.
+  EXPECT_CALL(mock_manager_, ReleaseStream(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));
   EXPECT_CALL(mock_alsa_wrapper_, PcmClose(kFakeHandle))
       .WillOnce(Return(0));
   EXPECT_CALL(mock_alsa_wrapper_, StrError(kTestFailedErrno))
       .WillOnce(Return(kDummyMessage));
 
   // If open fails, the stream stays in kCreated because it has effectively had
   // no changes.
-  ASSERT_FALSE(test_stream_->Open(kTestPacketSize));
-  EXPECT_EQ(AlsaPcmOutputStream::kCreated,
+  ASSERT_TRUE(test_stream_->Open(kTestPacketSize));
+  EXPECT_EQ(AlsaPcmOutputStream::kIsOpened,
             test_stream_->shared_data_.state());
+  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_->shared_data_.state());
+  EXPECT_TRUE(test_stream_->stop_stream_);
+  EXPECT_TRUE(test_stream_->playback_handle_ == NULL);
+  EXPECT_FALSE(test_stream_->packet_.get());
+
+  // Close the stream since we opened it to make destruction happy.
+  EXPECT_CALL(mock_manager_, ReleaseStream(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),
                       Return(0)));
   EXPECT_CALL(mock_alsa_wrapper_, PcmSetParams(_, _, _, _, _, _, _))
@@ skipping 117 matching lines @@
   EXPECT_EQ(10u, packet_.size);
 }
 
 TEST_F(AlsaPcmOutputStreamTest, BufferPacket_UnfinishedPacket) {
   // No expectations set on the strict mock because nothing should be called.
   test_stream_->BufferPacket(&packet_);
   EXPECT_EQ(0u, packet_.used);
   EXPECT_EQ(kTestPacketSize, packet_.size);
 }
 
+TEST_F(AlsaPcmOutputStreamTest, AutoSelectDevice_DeviceSelect) {
+  // Try channels from 1 -> 9. and see that we get the more specific surroundXX
+  // device opened for channels 4-8.  For all other channels, the device should
+  // default to |AlsaPcmOutputStream::kDefaultDevice|.  We should also not
+  // downmix any channel in this case because downmixing is only defined for
+  // channels 4-8, which we are guaranteeing to work.
+  //
+  // Note that the loop starts at "1", so the first parameter is ignored in
+  // these arrays.
+  const char* kExpectedDeviceName[] = { NULL,
+                                        AlsaPcmOutputStream::kDefaultDevice,
+                                        AlsaPcmOutputStream::kDefaultDevice,
+                                        AlsaPcmOutputStream::kDefaultDevice,
+                                        kSurround40, kSurround50, kSurround51,
+                                        kSurround70, kSurround71,
+                                        AlsaPcmOutputStream::kDefaultDevice };
+  bool kExpectedDownmix[] = { false, false, false, false, false, false,
+                              false, false, false, false };
+
+  for (int i = 1; i <= 9; ++i) {
+    SCOPED_TRACE(StringPrintf("Attempting %d Channel", i));
+
+    // Hints will only be grabbed for channel numbers that have non-default
+    // devices associated with them.
+    if (kExpectedDeviceName[i] != AlsaPcmOutputStream::kDefaultDevice) {
+      // The DeviceNameHint and DeviceNameFreeHint need to be paired to avoid a
+      // memory leak.
+      EXPECT_CALL(mock_alsa_wrapper_, DeviceNameHint(_, _, _))
+          .WillOnce(DoAll(SetArgumentPointee<2>(&kFakeHints[0]), Return(0)));
+      EXPECT_CALL(mock_alsa_wrapper_, DeviceNameFreeHint(&kFakeHints[0]))
+          .Times(1);
+    }
+
+    EXPECT_CALL(mock_alsa_wrapper_,
+                PcmOpen(_, StrEq(kExpectedDeviceName[i]), _, _))
+        .WillOnce(DoAll(SetArgumentPointee<0>(kFakeHandle), Return(0)));
+    EXPECT_CALL(mock_alsa_wrapper_,
+                PcmSetParams(kFakeHandle, _, _, i, _, _, _))
+        .WillOnce(Return(0));
+
+    // The parameters are specified by ALSA documentation, and are in constants
+    // in the implementation files.
+    EXPECT_CALL(mock_alsa_wrapper_, DeviceNameGetHint(_, StrEq("IOID")))
+        .WillRepeatedly(Invoke(OutputHint));
+    EXPECT_CALL(mock_alsa_wrapper_, DeviceNameGetHint(_, StrEq("NAME")))
+        .WillRepeatedly(Invoke(EchoHint));
+
+
+    test_stream_ = CreateStreamWithChannels(i);
+    EXPECT_TRUE(test_stream_->AutoSelectDevice(i));
+    EXPECT_EQ(kExpectedDownmix[i], test_stream_->should_downmix_);
+
+    Mock::VerifyAndClearExpectations(&mock_alsa_wrapper_);
+    Mock::VerifyAndClearExpectations(&mock_manager_);
+  }
+}
+
+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:
+  //
+  //   1) Try open "surround50"
+  //   2) Try open "plug:surround50".
+  //   3) Try open "default".
+  //   4) Try open "plug:default".
+  //   5) Give up trying to open.
+  //
+  const string first_try = kSurround50;
+  const string second_try = string(AlsaPcmOutputStream::kPlugPrefix) +
+                            kSurround50;
+  const string third_try = AlsaPcmOutputStream::kDefaultDevice;
+  const string fourth_try = string(AlsaPcmOutputStream::kPlugPrefix) +
+                            AlsaPcmOutputStream::kDefaultDevice;
+
+  EXPECT_CALL(mock_alsa_wrapper_, DeviceNameHint(_, _, _))
+      .WillOnce(DoAll(SetArgumentPointee<2>(&kFakeHints[0]), Return(0)));
+  EXPECT_CALL(mock_alsa_wrapper_, DeviceNameFreeHint(&kFakeHints[0]))
+      .Times(1);
+  EXPECT_CALL(mock_alsa_wrapper_, DeviceNameGetHint(_, StrEq("IOID")))
+      .WillRepeatedly(Invoke(OutputHint));
+  EXPECT_CALL(mock_alsa_wrapper_, DeviceNameGetHint(_, StrEq("NAME")))
+      .WillRepeatedly(Invoke(EchoHint));
+  EXPECT_CALL(mock_alsa_wrapper_, StrError(kTestFailedErrno))
+      .WillRepeatedly(Return(kDummyMessage));
+
+  InSequence s;
+  EXPECT_CALL(mock_alsa_wrapper_, PcmOpen(_, StrEq(first_try.c_str()), _, _))
+      .WillOnce(Return(kTestFailedErrno));
+  EXPECT_CALL(mock_alsa_wrapper_, PcmOpen(_, StrEq(second_try.c_str()), _, _))
+      .WillOnce(Return(kTestFailedErrno));
+  EXPECT_CALL(mock_alsa_wrapper_, PcmOpen(_, StrEq(third_try.c_str()), _, _))
+      .WillOnce(Return(kTestFailedErrno));
+  EXPECT_CALL(mock_alsa_wrapper_, PcmOpen(_, StrEq(fourth_try.c_str()), _, _))
+      .WillOnce(Return(kTestFailedErrno));
+
+  test_stream_ = CreateStreamWithChannels(5);
+  EXPECT_FALSE(test_stream_->AutoSelectDevice(5));
+}
+
+TEST_F(AlsaPcmOutputStreamTest, AutoSelectDevice_HintFail) {
+  // Should get |kDefaultDevice|, and force a 2-channel downmix on a failure to
+  // enumerate devices.
+  EXPECT_CALL(mock_alsa_wrapper_, DeviceNameHint(_, _, _))
+      .WillRepeatedly(Return(kTestFailedErrno));
+  EXPECT_CALL(mock_alsa_wrapper_,
+              PcmOpen(_, StrEq(AlsaPcmOutputStream::kDefaultDevice), _, _))
+      .WillOnce(DoAll(SetArgumentPointee<0>(kFakeHandle), Return(0)));
+  EXPECT_CALL(mock_alsa_wrapper_,
+              PcmSetParams(kFakeHandle, _, _, 2, _, _, _))
+      .WillOnce(Return(0));
+  EXPECT_CALL(mock_alsa_wrapper_, StrError(kTestFailedErrno))
+      .WillOnce(Return(kDummyMessage));
+
+  test_stream_ = CreateStreamWithChannels(5);
+  EXPECT_TRUE(test_stream_->AutoSelectDevice(5));
+  EXPECT_TRUE(test_stream_->should_downmix_);
+}
+
 TEST_F(AlsaPcmOutputStreamTest, BufferPacket_StopStream) {
   test_stream_->stop_stream_ = true;
   test_stream_->BufferPacket(&packet_);
   EXPECT_EQ(0u, packet_.used);
   EXPECT_EQ(0u, packet_.size);
 }
 
 TEST_F(AlsaPcmOutputStreamTest, ScheduleNextWrite) {
   test_stream_->shared_data_.TransitionTo(AlsaPcmOutputStream::kIsOpened);
   test_stream_->shared_data_.TransitionTo(AlsaPcmOutputStream::kIsPlaying);
@@ skipping 11 matching lines @@
 
   test_stream_->stop_stream_ = true;
   test_stream_->ScheduleNextWrite(&packet_);
 
   // 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_->shared_data_.TransitionTo(AlsaPcmOutputStream::kIsClosed);
 }