Assume pending buffered bytes is zero when ALSA has underrun.

media/audio/linux/alsa_output_unittest.cc

 // Copyright (c) 2010 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 29 matching lines @@
   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));
   MOCK_METHOD7(PcmSetParams, int(snd_pcm_t* handle, snd_pcm_format_t format,
                                  snd_pcm_access_t access, unsigned int channels,
                                  unsigned int rate, int soft_resample,
                                  unsigned int latency));
   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(StrError, const char*(int errnum));
 };
 
 class MockAudioSourceCallback : public AudioOutputStream::AudioSourceCallback {
  public:
   MOCK_METHOD4(OnMoreData, uint32(AudioOutputStream* stream, void* dest,
                                   uint32 max_size, uint32 pending_bytes));
   MOCK_METHOD1(OnClose, void(AudioOutputStream* stream));
   MOCK_METHOD2(OnError, void(AudioOutputStream* stream, int code));
@@ skipping 333 matching lines @@
   message_loop_.RunAllPending();
 
   // Expect Device setup.
   EXPECT_CALL(mock_alsa_wrapper_, PcmDrop(kFakeHandle))
       .WillOnce(Return(0));
   EXPECT_CALL(mock_alsa_wrapper_, PcmPrepare(kFakeHandle))
       .WillOnce(Return(0));
 
   // Expect the pre-roll.
   MockAudioSourceCallback mock_callback;
+  EXPECT_CALL(mock_alsa_wrapper_, PcmState(kFakeHandle))
+      .Times(2)
+      .WillRepeatedly(Return(SND_PCM_STATE_RUNNING));
   EXPECT_CALL(mock_alsa_wrapper_, PcmDelay(kFakeHandle, _))
       .Times(2)
       .WillRepeatedly(DoAll(SetArgumentPointee<1>(0), Return(0)));
   EXPECT_CALL(mock_callback,
               OnMoreData(test_stream_.get(), _, kTestPacketSize, 0))
       .Times(2)
       .WillRepeatedly(Return(kTestPacketSize));
   EXPECT_CALL(mock_alsa_wrapper_, PcmWritei(kFakeHandle, _, _))
       .Times(2)
       .WillRepeatedly(Return(kTestPacketSize));
@@ skipping 74 matching lines @@
   test_stream_->stop_stream_ = true;
   test_stream_->WritePacket(&packet_);
   EXPECT_EQ(packet_.size, packet_.used);
 }
 
 TEST_F(AlsaPcmOutputStreamTest, BufferPacket) {
   packet_.used = packet_.size;
 
   // Return a partially filled packet.
   MockAudioSourceCallback mock_callback;
+  EXPECT_CALL(mock_alsa_wrapper_, PcmState(_))
+      .WillOnce(Return(SND_PCM_STATE_RUNNING));
   EXPECT_CALL(mock_alsa_wrapper_, PcmDelay(_, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(1), Return(0)));
   EXPECT_CALL(mock_callback,
               OnMoreData(test_stream_.get(), packet_.buffer.get(),
                          packet_.capacity, kTestBytesPerFrame))
       .WillOnce(Return(10));
 
   test_stream_->shared_data_.set_source_callback(&mock_callback);
   test_stream_->BufferPacket(&packet_);
 
   EXPECT_EQ(0u, packet_.used);
   EXPECT_EQ(10u, packet_.size);
 }
 
+TEST_F(AlsaPcmOutputStreamTest, BufferPacket_Negative) {
+  packet_.used = packet_.size;
+
+  // Simulate where the underrun has occurred right after checking the delay.
+  MockAudioSourceCallback mock_callback;
+  EXPECT_CALL(mock_alsa_wrapper_, PcmState(_))
+      .WillOnce(Return(SND_PCM_STATE_RUNNING));
+  EXPECT_CALL(mock_alsa_wrapper_, PcmDelay(_, _))
+      .WillOnce(DoAll(SetArgumentPointee<1>(-1), Return(0)));
+  EXPECT_CALL(mock_callback,
+              OnMoreData(test_stream_.get(), packet_.buffer.get(),
+                         packet_.capacity, 0))
+      .WillOnce(Return(10));
+
+  test_stream_->shared_data_.set_source_callback(&mock_callback);
+  test_stream_->BufferPacket(&packet_);
+
+  EXPECT_EQ(0u, packet_.used);
+  EXPECT_EQ(10u, packet_.size);
+}
+
+TEST_F(AlsaPcmOutputStreamTest, BufferPacket_Underrun) {
+  packet_.used = packet_.size;
+
+  // If ALSA has underrun then we should assume a delay of zero.
+  MockAudioSourceCallback mock_callback;
+  EXPECT_CALL(mock_alsa_wrapper_, PcmState(_))
+      .WillOnce(Return(SND_PCM_STATE_XRUN));
+  EXPECT_CALL(mock_callback,
+              OnMoreData(test_stream_.get(), packet_.buffer.get(),
+                         packet_.capacity, 0))
+      .WillOnce(Return(10));
+
+  test_stream_->shared_data_.set_source_callback(&mock_callback);
+  test_stream_->BufferPacket(&packet_);
+
+  EXPECT_EQ(0u, packet_.used);
+  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
@@ skipping 139 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);
 }