Refactored DataBuffer to use unix_hacker style methods.

media/audio/linux/alsa_output_unittest.cc

 // Copyright (c) 2012 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/strings/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 124 matching lines @@
   // 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(AlsaPcmOutputStream* test_stream) {
     DCHECK(test_stream);
     packet_ = new media::DataBuffer(kTestPacketSize);
-    packet_->SetDataSize(kTestPacketSize);
+    packet_->set_data_size(kTestPacketSize);
     test_stream->buffer_.reset(new media::SeekableBuffer(0, kTestPacketSize));
     test_stream->buffer_->Append(packet_.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[];
@@ skipping 328 matching lines @@
   EXPECT_CALL(mock_alsa_wrapper_, PcmGetParams(_, _, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(kTestFramesPerPacket),
                       SetArgumentPointee<2>(kTestFramesPerPacket / 2),
                       Return(0)));
   AlsaPcmOutputStream* test_stream = CreateStream(kTestChannelLayout);
   ASSERT_TRUE(test_stream->Open());
   InitBuffer(test_stream);
   test_stream->TransitionTo(AlsaPcmOutputStream::kIsPlaying);
 
   // Write a little less than half the data.
-  int written = packet_->GetDataSize() / kTestBytesPerFrame / 2 - 1;
+  int written = packet_->data_size() / kTestBytesPerFrame / 2 - 1;
   EXPECT_CALL(mock_alsa_wrapper_, PcmAvailUpdate(kFakeHandle))
         .WillOnce(Return(written));
-  EXPECT_CALL(mock_alsa_wrapper_, PcmWritei(kFakeHandle, packet_->GetData(), _))
+  EXPECT_CALL(mock_alsa_wrapper_, PcmWritei(kFakeHandle, packet_->data(), _))
       .WillOnce(Return(written));
 
   test_stream->WritePacket();
 
   ASSERT_EQ(test_stream->buffer_->forward_bytes(),
-            packet_->GetDataSize() - written * kTestBytesPerFrame);
+            packet_->data_size() - written * kTestBytesPerFrame);
 
   // Write the rest.
   EXPECT_CALL(mock_alsa_wrapper_, PcmAvailUpdate(kFakeHandle))
       .WillOnce(Return(kTestFramesPerPacket - written));
   EXPECT_CALL(mock_alsa_wrapper_,
               PcmWritei(kFakeHandle,
-                        packet_->GetData() + written * kTestBytesPerFrame,
+                        packet_->data() + written * kTestBytesPerFrame,
                         _))
-      .WillOnce(Return(packet_->GetDataSize() / kTestBytesPerFrame - written));
+      .WillOnce(Return(packet_->data_size() / kTestBytesPerFrame - written));
   test_stream->WritePacket();
   EXPECT_EQ(0, test_stream->buffer_->forward_bytes());
 
   // 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));
   test_stream->Close();
 }
@@ skipping 18 matching lines @@
   // continues normally.
   EXPECT_CALL(mock_alsa_wrapper_, PcmAvailUpdate(kFakeHandle))
       .WillOnce(Return(kTestFramesPerPacket));
   EXPECT_CALL(mock_alsa_wrapper_, PcmWritei(kFakeHandle, _, _))
       .WillOnce(Return(-EINTR));
   EXPECT_CALL(mock_alsa_wrapper_, PcmRecover(kFakeHandle, _, _))
       .WillOnce(Return(0));
 
   test_stream->WritePacket();
 
-  ASSERT_EQ(test_stream->buffer_->forward_bytes(), packet_->GetDataSize());
+  ASSERT_EQ(test_stream->buffer_->forward_bytes(), packet_->data_size());
 
   // Fail the next write, and see that stop_stream_ is set.
   EXPECT_CALL(mock_alsa_wrapper_, PcmAvailUpdate(kFakeHandle))
         .WillOnce(Return(kTestFramesPerPacket));
   EXPECT_CALL(mock_alsa_wrapper_, PcmWritei(kFakeHandle, _, _))
       .WillOnce(Return(kTestFailedErrno));
   EXPECT_CALL(mock_alsa_wrapper_, PcmRecover(kFakeHandle, _, _))
       .WillOnce(Return(kTestFailedErrno));
   EXPECT_CALL(mock_alsa_wrapper_, StrError(kTestFailedErrno))
       .WillOnce(Return(kDummyMessage));
   test_stream->WritePacket();
-  EXPECT_EQ(test_stream->buffer_->forward_bytes(), packet_->GetDataSize());
+  EXPECT_EQ(test_stream->buffer_->forward_bytes(), packet_->data_size());
   EXPECT_TRUE(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));
   test_stream->Close();
 }
 
@@ skipping 285 matching lines @@
 
   // 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);
   test_stream->Close();
 }
 
 }  // namespace media