Retry 35837 linux: grab device name before closing it

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"
@@ skipping 209 matching lines @@
                       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_alsa_wrapper_, PcmClose(kFakeHandle)).WillOnce(Return(0));
+  EXPECT_CALL(mock_alsa_wrapper_, PcmName(kFakeHandle))
+      .WillOnce(Return(kTestDeviceName));
   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;
@@ skipping 10 matching lines @@
   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_alsa_wrapper_, PcmName(kFakeHandle))
+      .WillOnce(Return(kTestDeviceName));
   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 *
@@ skipping 25 matching lines @@
   EXPECT_EQ(AlsaPcmOutputStream::kIsOpened,
             test_stream_->shared_data_.state());
   EXPECT_EQ(kFakeHandle, test_stream_->playback_handle_);
   EXPECT_EQ(kTestFramesPerPacket, test_stream_->frames_per_packet_);
   EXPECT_TRUE(test_stream_->packet_.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_, ReleaseStream(test_stream_.get()));
   test_stream_->Close();
   message_loop_.RunAllPending();
 
   EXPECT_TRUE(test_stream_->playback_handle_ == NULL);
   EXPECT_FALSE(test_stream_->packet_.get());
   EXPECT_TRUE(test_stream_->stop_stream_);
 }
 
 TEST_F(AlsaPcmOutputStreamTest, PcmOpenFailed) {
@@ skipping 23 matching lines @@
 }
 
 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_, PcmName(kFakeHandle))
+      .WillOnce(Return(kTestDeviceName));
   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_TRUE(test_stream_->Open(kTestPacketSize));
   EXPECT_EQ(AlsaPcmOutputStream::kIsOpened,
             test_stream_->shared_data_.state());
   ASSERT_FALSE(test_stream_->stop_stream_);
   message_loop_.RunAllPending();
@@ skipping 48 matching lines @@
   EXPECT_CALL(mock_alsa_wrapper_, PcmAvailUpdate(kFakeHandle))
       .WillOnce(Return(1));
 
   test_stream_->Start(&mock_callback);
   message_loop_.RunAllPending();
 
   EXPECT_CALL(mock_manager_, ReleaseStream(test_stream_.get()));
   EXPECT_CALL(mock_callback, OnClose(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) {
   // Nothing should happen.  Don't set any expectations and Our strict mocks
   // should verify most of this.
 
   // Test regular used-up packet.
   packet_.used = packet_.size;
@@ skipping 223 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);
 }