Fixes in AlsaPcmOutputStream.

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/message_loop.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 "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"
 
 using testing::_;
 using testing::DoAll;
 using testing::Eq;
 using testing::InSequence;
 using testing::Invoke;
 using testing::Mock;
 using testing::MockFunction;
@@ skipping 18 matching lines @@
   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));
   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_METHOD3(PcmGetParams, int(snd_pcm_t* handle, snd_pcm_uframes_t* buffer_size,
+                                 snd_pcm_uframes_t* period_size));
   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,
@@ skipping 10 matching lines @@
                                                    int sample_rate,
                                                    char bits_per_sample));
   MOCK_METHOD0(MuteAll, void());
   MOCK_METHOD0(UnMuteAll, void());
 
   MOCK_METHOD1(ReleaseStream, void(AlsaPcmOutputStream* stream));
 };
 
 class AlsaPcmOutputStreamTest : public testing::Test {
  protected:
-  AlsaPcmOutputStreamTest()
-      : packet_(kTestPacketSize + 1) {
+  AlsaPcmOutputStreamTest() {
     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");
   }
 
+  // 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());
+  }
+
   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 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_;
   MessageLoop message_loop_;
   scoped_refptr<AlsaPcmOutputStream> test_stream_;
-  AlsaPcmOutputStream::Packet packet_;
+  scoped_refptr<media::DataBuffer> 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 =
@@ skipping 71 matching lines @@
   // 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));
+  EXPECT_CALL(mock_alsa_wrapper_, PcmGetParams(_, _, _))
+      .WillOnce(DoAll(SetArgumentPointee<1>(kTestPacketSize),
+                      SetArgumentPointee<2>(kTestPacketSize / 2),
+                      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_, PcmName(kFakeHandle))
       .WillOnce(Return(kTestDeviceName));
   EXPECT_CALL(mock_manager_, ReleaseStream(test_stream_.get()));
   test_stream_->Close();
@@ skipping 11 matching lines @@
           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));
+  EXPECT_CALL(mock_alsa_wrapper_, PcmGetParams(_, _, _))
+      .WillOnce(DoAll(SetArgumentPointee<1>(kTestPacketSize),
+                      SetArgumentPointee<2>(kTestPacketSize / 2),
+                      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()));
@@ skipping 19 matching lines @@
                       Return(0)));
   EXPECT_CALL(mock_alsa_wrapper_,
               PcmSetParams(kFakeHandle,
                            SND_PCM_FORMAT_U8,
                            SND_PCM_ACCESS_RW_INTERLEAVED,
                            kTestChannels,
                            kTestSampleRate,
                            1,
                            expected_micros))
       .WillOnce(Return(0));
+  EXPECT_CALL(mock_alsa_wrapper_, PcmGetParams(kFakeHandle, _, _))
+      .WillOnce(DoAll(SetArgumentPointee<1>(kTestPacketSize),
+                      SetArgumentPointee<2>(kTestPacketSize/2),
+                      Return(0)));
 
   // Open the stream.
   ASSERT_TRUE(test_stream_->Open(kTestPacketSize));
   message_loop_.RunAllPending();
 
   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_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_, ReleaseStream(test_stream_.get()));
   test_stream_->Close();
   message_loop_.RunAllPending();
 
   EXPECT_TRUE(test_stream_->playback_handle_ == NULL);
-  EXPECT_FALSE(test_stream_->packet_.get());
+  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(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());
+  EXPECT_FALSE(test_stream_->buffer_.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),
@@ skipping 13 matching lines @@
   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());
+  EXPECT_FALSE(test_stream_->buffer_.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(_, _, _, _, _, _, _))
       .WillOnce(Return(0));
+  EXPECT_CALL(mock_alsa_wrapper_, PcmGetParams(_, _, _))
+      .WillOnce(DoAll(SetArgumentPointee<1>(kTestPacketSize),
+                      SetArgumentPointee<2>(kTestPacketSize / 2),
+                      Return(0)));
 
   // Open the stream.
   ASSERT_TRUE(test_stream_->Open(kTestPacketSize));
   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));
-
   // Expect scheduling.
   EXPECT_CALL(mock_alsa_wrapper_, PcmAvailUpdate(kFakeHandle))
       .WillOnce(Return(1));
 
+  MockAudioSourceCallback mock_callback;
   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) {
+  InitBuffer();
+
   // 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;
-  test_stream_->WritePacket(&packet_);
-
-  // Test empty packet.
-  packet_.used = packet_.size = 0;
-  test_stream_->WritePacket(&packet_);
+  // Test empty buffer.
+  test_stream_->buffer_->Clear();
+  test_stream_->WritePacket();
 }
 
 TEST_F(AlsaPcmOutputStreamTest, WritePacket_NormalPacket) {
+  InitBuffer();
+
   // Write a little less than half the data.
-  EXPECT_CALL(mock_alsa_wrapper_, PcmWritei(_, packet_.buffer.get(), _))
-      .WillOnce(Return(packet_.size / kTestBytesPerFrame / 2 - 1));
+  int written = packet_->GetDataSize() / kTestBytesPerFrame / 2 - 1;
+  EXPECT_CALL(mock_alsa_wrapper_, PcmWritei(_, packet_->GetData(), _))
+      .WillOnce(Return(written));
 
-  test_stream_->WritePacket(&packet_);
+  test_stream_->WritePacket();
 
-  ASSERT_EQ(packet_.size / 2 - kTestBytesPerFrame, packet_.used);
+  ASSERT_EQ(test_stream_->buffer_->forward_bytes(),
+            packet_->GetDataSize() - written * kTestBytesPerFrame);
 
   // Write the rest.
   EXPECT_CALL(mock_alsa_wrapper_,
-              PcmWritei(_, packet_.buffer.get() + packet_.used, _))
-      .WillOnce(Return(packet_.size / kTestBytesPerFrame / 2 + 1));
-  test_stream_->WritePacket(&packet_);
-  EXPECT_EQ(packet_.size, packet_.used);
+              PcmWritei(_, packet_->GetData() + written * kTestBytesPerFrame,
+                        _))
+      .WillOnce(Return(packet_->GetDataSize() / kTestBytesPerFrame - written));
+  test_stream_->WritePacket();
+  EXPECT_EQ(0u, test_stream_->buffer_->forward_bytes());
 }
 
 TEST_F(AlsaPcmOutputStreamTest, WritePacket_WriteFails) {
+  InitBuffer();
+
   // Fail due to a recoverable error and see that PcmRecover code path
   // continues normally.
   EXPECT_CALL(mock_alsa_wrapper_, PcmWritei(_, _, _))
       .WillOnce(Return(-EINTR));
   EXPECT_CALL(mock_alsa_wrapper_, PcmRecover(_, _, _))
-      .WillOnce(Return(packet_.size / kTestBytesPerFrame / 2 - 1));
+      .WillOnce(Return(packet_->GetDataSize() / kTestBytesPerFrame / 2 - 1));
 
-  test_stream_->WritePacket(&packet_);
+  test_stream_->WritePacket();
 
-  ASSERT_EQ(packet_.size / 2 - kTestBytesPerFrame, packet_.used);
+  ASSERT_EQ(test_stream_->buffer_->forward_bytes(),
+            packet_->GetDataSize() / 2 + kTestBytesPerFrame);
 
   // Fail the next write, and see that stop_stream_ is set.
   EXPECT_CALL(mock_alsa_wrapper_, PcmWritei(_, _, _))
       .WillOnce(Return(kTestFailedErrno));
   EXPECT_CALL(mock_alsa_wrapper_, PcmRecover(_, _, _))
       .WillOnce(Return(kTestFailedErrno));
   EXPECT_CALL(mock_alsa_wrapper_, StrError(kTestFailedErrno))
       .WillOnce(Return(kDummyMessage));
-  test_stream_->WritePacket(&packet_);
-  EXPECT_EQ(packet_.size / 2 - kTestBytesPerFrame, packet_.used);
+  test_stream_->WritePacket();
+  EXPECT_EQ(test_stream_->buffer_->forward_bytes(),
+            packet_->GetDataSize() / 2 + kTestBytesPerFrame);
   EXPECT_TRUE(test_stream_->stop_stream_);
 }
 
 TEST_F(AlsaPcmOutputStreamTest, WritePacket_StopStream) {
+  InitBuffer();
+
   // No expectations set on the strict mock because nothing should be called.
   test_stream_->stop_stream_ = true;
-  test_stream_->WritePacket(&packet_);
-  EXPECT_EQ(packet_.size, packet_.used);
+  test_stream_->WritePacket();
+  EXPECT_EQ(0u, test_stream_->buffer_->forward_bytes());
 }
 
 TEST_F(AlsaPcmOutputStreamTest, BufferPacket) {
-  packet_.used = packet_.size;
+  InitBuffer();
+  test_stream_->buffer_->Clear();
 
   // 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))
+              OnMoreData(test_stream_.get(), _, _, kTestBytesPerFrame))
       .WillOnce(Return(10));
 
   test_stream_->shared_data_.set_source_callback(&mock_callback);
-  test_stream_->BufferPacket(&packet_);
+  test_stream_->BufferPacket();
 
-  EXPECT_EQ(0u, packet_.used);
-  EXPECT_EQ(10u, packet_.size);
+  EXPECT_EQ(10u, test_stream_->buffer_->forward_bytes());
 }
 
 TEST_F(AlsaPcmOutputStreamTest, BufferPacket_Negative) {
-  packet_.used = packet_.size;
+  InitBuffer();
+  test_stream_->buffer_->Clear();
 
   // 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))
+              OnMoreData(test_stream_.get(), _, _, 0))
       .WillOnce(Return(10));
 
   test_stream_->shared_data_.set_source_callback(&mock_callback);
-  test_stream_->BufferPacket(&packet_);
+  test_stream_->BufferPacket();
 
-  EXPECT_EQ(0u, packet_.used);
-  EXPECT_EQ(10u, packet_.size);
+  EXPECT_EQ(10u, test_stream_->buffer_->forward_bytes());
 }
 
 TEST_F(AlsaPcmOutputStreamTest, BufferPacket_Underrun) {
-  packet_.used = packet_.size;
+  InitBuffer();
+  test_stream_->buffer_->Clear();
 
   // 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))
+              OnMoreData(test_stream_.get(), _, _, 0))
       .WillOnce(Return(10));
 
   test_stream_->shared_data_.set_source_callback(&mock_callback);
-  test_stream_->BufferPacket(&packet_);
+  test_stream_->BufferPacket();
 
-  EXPECT_EQ(0u, packet_.used);
-  EXPECT_EQ(10u, packet_.size);
+  EXPECT_EQ(10u, test_stream_->buffer_->forward_bytes());
 }
 
-TEST_F(AlsaPcmOutputStreamTest, BufferPacket_UnfinishedPacket) {
+TEST_F(AlsaPcmOutputStreamTest, BufferPacket_FullBuffer) {
+  InitBuffer();
   // 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_stream_->BufferPacket();
+  EXPECT_EQ(kTestPacketSize, test_stream_->buffer_->forward_bytes());
 }
 
 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
@@ skipping 104 matching lines @@
       .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) {
+  InitBuffer();
   test_stream_->stop_stream_ = true;
-  test_stream_->BufferPacket(&packet_);
-  EXPECT_EQ(0u, packet_.used);
-  EXPECT_EQ(0u, packet_.size);
+  test_stream_->BufferPacket();
+  EXPECT_EQ(0u, test_stream_->buffer_->forward_bytes());
 }
 
 TEST_F(AlsaPcmOutputStreamTest, ScheduleNextWrite) {
   test_stream_->shared_data_.TransitionTo(AlsaPcmOutputStream::kIsOpened);
   test_stream_->shared_data_.TransitionTo(AlsaPcmOutputStream::kIsPlaying);
 
+  InitBuffer();
+
   EXPECT_CALL(mock_alsa_wrapper_, PcmAvailUpdate(_))
       .WillOnce(Return(10));
-  test_stream_->ScheduleNextWrite(&packet_);
+  test_stream_->ScheduleNextWrite();
 
   test_stream_->shared_data_.TransitionTo(AlsaPcmOutputStream::kIsClosed);
 }
 
 TEST_F(AlsaPcmOutputStreamTest, ScheduleNextWrite_StopStream) {
   test_stream_->shared_data_.TransitionTo(AlsaPcmOutputStream::kIsOpened);
   test_stream_->shared_data_.TransitionTo(AlsaPcmOutputStream::kIsPlaying);
 
+  InitBuffer();
+
   test_stream_->stop_stream_ = true;
-  test_stream_->ScheduleNextWrite(&packet_);
+  test_stream_->ScheduleNextWrite();
 
   // 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);
 }