Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(97)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: media/audio/linux/alsa_output_unittest.cc

Issue 17315021: Refactored DataBuffer to use unix_hacker style methods. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: fixed remaining style issues Created 7 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « media/audio/linux/alsa_output.cc ('k') | media/audio/mac/audio_low_latency_input_mac.cc » ('j') | webkit/plugins/ppapi/content_decryptor_delegate.cc » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: media/audio/linux/alsa_output_unittest.cc
diff --git a/media/audio/linux/alsa_output_unittest.cc b/media/audio/linux/alsa_output_unittest.cc
index 63422f3b0bce29a4c2c48f8c522aac7516ae182c..f2d9a5fdfce256e3e452e6fd34f343fed8d96725 100644
--- a/media/audio/linux/alsa_output_unittest.cc
+++ b/media/audio/linux/alsa_output_unittest.cc
@@ -32,9 +32,7 @@ namespace media {
class MockAlsaWrapper : public AlsaWrapper {
public:
- MOCK_METHOD3(DeviceNameHint, int(int card,
- const char* iface,
- void*** hints));
+ 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));
@@ -44,20 +42,19 @@ class MockAlsaWrapper : public AlsaWrapper {
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(PcmReadi, snd_pcm_sframes_t(snd_pcm_t* handle,
- void* buffer,
+ MOCK_METHOD3(PcmWritei,
+ snd_pcm_sframes_t(snd_pcm_t* handle, const void* buffer,
+ snd_pcm_uframes_t size));
+ MOCK_METHOD3(PcmReadi, snd_pcm_sframes_t(snd_pcm_t* handle, 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_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));
@@ -68,10 +65,9 @@ class MockAlsaWrapper : public AlsaWrapper {
class MockAudioSourceCallback : public AudioOutputStream::AudioSourceCallback {
public:
- MOCK_METHOD2(OnMoreData, int(AudioBus* audio_bus,
- AudioBuffersState buffers_state));
- MOCK_METHOD3(OnMoreIOData, int(AudioBus* source,
- AudioBus* dest,
+ MOCK_METHOD2(OnMoreData,
+ int(AudioBus* audio_bus, AudioBuffersState buffers_state));
+ MOCK_METHOD3(OnMoreIOData, int(AudioBus* source, AudioBus* dest,
AudioBuffersState buffers_state));
MOCK_METHOD1(OnError, void(AudioOutputStream* stream));
};
@@ -81,12 +77,14 @@ class MockAudioManagerLinux : public AudioManagerLinux {
MOCK_METHOD0(Init, void());
MOCK_METHOD0(HasAudioOutputDevices, bool());
MOCK_METHOD0(HasAudioInputDevices, bool());
- MOCK_METHOD1(MakeLinearOutputStream, AudioOutputStream*(
- const AudioParameters& params));
- MOCK_METHOD2(MakeLowLatencyOutputStream, AudioOutputStream*(
- const AudioParameters& params, const std::string& input_device_id));
- MOCK_METHOD2(MakeLowLatencyInputStream, AudioInputStream*(
- const AudioParameters& params, const std::string& device_id));
+ MOCK_METHOD1(MakeLinearOutputStream,
+ AudioOutputStream*(const AudioParameters& params));
+ MOCK_METHOD2(MakeLowLatencyOutputStream,
+ AudioOutputStream*(const AudioParameters& params,
+ const std::string& input_device_id));
+ MOCK_METHOD2(MakeLowLatencyInputStream,
+ AudioInputStream*(const AudioParameters& params,
+ const std::string& device_id));
// We need to override this function in order to skip the checking the number
// of active output streams. It is because the number of active streams
@@ -110,8 +108,7 @@ class AlsaPcmOutputStreamTest : public testing::Test {
mock_manager_.reset(new StrictMock<MockAudioManagerLinux>());
}
- virtual ~AlsaPcmOutputStreamTest() {
- }
+ virtual ~AlsaPcmOutputStreamTest() {}
AlsaPcmOutputStream* CreateStream(ChannelLayout layout) {
return CreateStream(layout, kTestFramesPerPacket);
@@ -121,9 +118,7 @@ class AlsaPcmOutputStreamTest : public testing::Test {
int32 samples_per_packet) {
AudioParameters params(kTestFormat, layout, kTestSampleRate,
kTestBitsPerSample, samples_per_packet);
- return new AlsaPcmOutputStream(kTestDeviceName,
- params,
- &mock_alsa_wrapper_,
+ return new AlsaPcmOutputStream(kTestDeviceName, params, &mock_alsa_wrapper_,
mock_manager_.get());
}
@@ -133,16 +128,14 @@ class AlsaPcmOutputStreamTest : public testing::Test {
}
// Helper function to malloc the string returned by DeviceNameHint for IOID.
- static char* OutputHint(Unused, Unused) {
- return strdup("Output");
- }
+ 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());
}
@@ -203,14 +196,12 @@ 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 };
+void* AlsaPcmOutputStreamTest::kFakeHints[] = {kSurround40, kSurround41,
+ kSurround50, kSurround51,
+ kSurround70, kSurround71, NULL};
// Custom action to clear a memory buffer.
-ACTION(ClearBuffer) {
- arg0->Zero();
-}
+ACTION(ClearBuffer) { arg0->Zero(); }
TEST_F(AlsaPcmOutputStreamTest, ConstructedState) {
AlsaPcmOutputStream* test_stream = CreateStream(kTestChannelLayout);
@@ -231,28 +222,25 @@ TEST_F(AlsaPcmOutputStreamTest, ConstructedState) {
AudioParameters bad_bps_params(kTestFormat, kTestChannelLayout,
kTestSampleRate, kTestBitsPerSample - 1,
kTestFramesPerPacket);
- test_stream = new AlsaPcmOutputStream(kTestDeviceName,
- bad_bps_params,
- &mock_alsa_wrapper_,
- mock_manager_.get());
+ test_stream =
+ new AlsaPcmOutputStream(kTestDeviceName, bad_bps_params,
+ &mock_alsa_wrapper_, mock_manager_.get());
EXPECT_EQ(AlsaPcmOutputStream::kInError, test_stream->state());
test_stream->Close();
// Bad format.
- AudioParameters bad_format_params(
- AudioParameters::AUDIO_LAST_FORMAT, kTestChannelLayout, kTestSampleRate,
- kTestBitsPerSample, kTestFramesPerPacket);
- test_stream = new AlsaPcmOutputStream(kTestDeviceName,
- bad_format_params,
- &mock_alsa_wrapper_,
- mock_manager_.get());
+ AudioParameters bad_format_params(AudioParameters::AUDIO_LAST_FORMAT,
+ kTestChannelLayout, kTestSampleRate,
+ kTestBitsPerSample, kTestFramesPerPacket);
+ test_stream =
+ new AlsaPcmOutputStream(kTestDeviceName, bad_format_params,
+ &mock_alsa_wrapper_, mock_manager_.get());
EXPECT_EQ(AlsaPcmOutputStream::kInError, test_stream->state());
test_stream->Close();
}
TEST_F(AlsaPcmOutputStreamTest, LatencyFloor) {
- const double kMicrosPerFrame =
- static_cast<double>(1000000) / kTestSampleRate;
+ const double kMicrosPerFrame = static_cast<double>(1000000) / kTestSampleRate;
const double kPacketFramesInMinLatency =
AlsaPcmOutputStream::kMinLatencyMicros / kMicrosPerFrame / 2.0;
@@ -260,19 +248,17 @@ TEST_F(AlsaPcmOutputStreamTest, LatencyFloor) {
// 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(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>(kTestFramesPerPacket),
- SetArgumentPointee<2>(kTestFramesPerPacket / 2),
- Return(0)));
+ EXPECT_CALL(mock_alsa_wrapper_, PcmGetParams(_, _, _)).WillOnce(
+ DoAll(SetArgumentPointee<1>(kTestFramesPerPacket),
+ SetArgumentPointee<2>(kTestFramesPerPacket / 2), Return(0)));
- AlsaPcmOutputStream* test_stream = CreateStream(kTestChannelLayout,
- kPacketFramesInMinLatency);
+ AlsaPcmOutputStream* test_stream =
+ CreateStream(kTestChannelLayout, kPacketFramesInMinLatency);
ASSERT_TRUE(test_stream->Open());
// Now close it and test that everything was released.
@@ -294,18 +280,15 @@ TEST_F(AlsaPcmOutputStreamTest, LatencyFloor) {
EXPECT_CALL(mock_alsa_wrapper_,
PcmSetParams(_, _, _, _, _, _, expected_micros))
.WillOnce(Return(0));
- EXPECT_CALL(mock_alsa_wrapper_, PcmGetParams(_, _, _))
- .WillOnce(DoAll(SetArgumentPointee<1>(kTestFramesPerPacket),
- SetArgumentPointee<2>(kTestFramesPerPacket / 2),
- Return(0)));
+ EXPECT_CALL(mock_alsa_wrapper_, PcmGetParams(_, _, _)).WillOnce(
+ DoAll(SetArgumentPointee<1>(kTestFramesPerPacket),
+ SetArgumentPointee<2>(kTestFramesPerPacket / 2), Return(0)));
- test_stream = CreateStream(kTestChannelLayout,
- kOverMinLatencyPacketSize);
+ test_stream = CreateStream(kTestChannelLayout, kOverMinLatencyPacketSize);
ASSERT_TRUE(test_stream->Open());
// 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));
test_stream->Close();
@@ -322,23 +305,17 @@ TEST_F(AlsaPcmOutputStreamTest, OpenClose) {
// 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)));
+ 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_U8,
- SND_PCM_ACCESS_RW_INTERLEAVED,
- ChannelLayoutToChannelCount(kTestChannelLayout),
- kTestSampleRate,
- 1,
- expected_micros))
- .WillOnce(Return(0));
- EXPECT_CALL(mock_alsa_wrapper_, PcmGetParams(kFakeHandle, _, _))
- .WillOnce(DoAll(SetArgumentPointee<1>(kTestFramesPerPacket),
- SetArgumentPointee<2>(kTestFramesPerPacket / 2),
- Return(0)));
+ PcmSetParams(
+ kFakeHandle, SND_PCM_FORMAT_U8, SND_PCM_ACCESS_RW_INTERLEAVED,
+ ChannelLayoutToChannelCount(kTestChannelLayout),
+ kTestSampleRate, 1, expected_micros)).WillOnce(Return(0));
+ EXPECT_CALL(mock_alsa_wrapper_, PcmGetParams(kFakeHandle, _, _)).WillOnce(
+ DoAll(SetArgumentPointee<1>(kTestFramesPerPacket),
+ SetArgumentPointee<2>(kTestFramesPerPacket / 2), Return(0)));
// Open the stream.
AlsaPcmOutputStream* test_stream = CreateStream(kTestChannelLayout);
@@ -351,8 +328,7 @@ TEST_F(AlsaPcmOutputStreamTest, OpenClose) {
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_, PcmClose(kFakeHandle)).WillOnce(Return(0));
EXPECT_CALL(mock_alsa_wrapper_, PcmName(kFakeHandle))
.WillOnce(Return(kTestDeviceName));
test_stream->Close();
@@ -379,12 +355,10 @@ TEST_F(AlsaPcmOutputStreamTest, PcmOpenFailed) {
TEST_F(AlsaPcmOutputStreamTest, PcmSetParamsFailed) {
EXPECT_CALL(mock_alsa_wrapper_, PcmOpen(_, _, _, _))
- .WillOnce(DoAll(SetArgumentPointee<0>(kFakeHandle),
- Return(0)));
+ .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_, PcmClose(kFakeHandle)).WillOnce(Return(0));
EXPECT_CALL(mock_alsa_wrapper_, PcmName(kFakeHandle))
.WillOnce(Return(kTestDeviceName));
EXPECT_CALL(mock_alsa_wrapper_, StrError(kTestFailedErrno))
@@ -410,24 +384,20 @@ TEST_F(AlsaPcmOutputStreamTest, StartStop) {
// 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)));
+ .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>(kTestFramesPerPacket),
- SetArgumentPointee<2>(kTestFramesPerPacket / 2),
- Return(0)));
+ EXPECT_CALL(mock_alsa_wrapper_, PcmGetParams(_, _, _)).WillOnce(
+ DoAll(SetArgumentPointee<1>(kTestFramesPerPacket),
+ SetArgumentPointee<2>(kTestFramesPerPacket / 2), Return(0)));
// Open the stream.
AlsaPcmOutputStream* test_stream = CreateStream(kTestChannelLayout);
ASSERT_TRUE(test_stream->Open());
// Expect Device setup.
- EXPECT_CALL(mock_alsa_wrapper_, PcmDrop(kFakeHandle))
- .WillOnce(Return(0));
- EXPECT_CALL(mock_alsa_wrapper_, PcmPrepare(kFakeHandle))
- .WillOnce(Return(0));
+ 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;
@@ -441,8 +411,7 @@ TEST_F(AlsaPcmOutputStreamTest, StartStop) {
.WillRepeatedly(Return(kTestFramesPerPacket));
// Expect scheduling.
- EXPECT_CALL(mock_alsa_wrapper_, PcmAvailUpdate(kFakeHandle))
- .Times(AtLeast(2))
+ EXPECT_CALL(mock_alsa_wrapper_, PcmAvailUpdate(kFakeHandle)).Times(AtLeast(2))
.WillRepeatedly(Return(kTestFramesPerPacket));
test_stream->Start(&mock_callback);
@@ -452,8 +421,7 @@ TEST_F(AlsaPcmOutputStreamTest, StartStop) {
test_stream->Stop();
message_loop_.RunUntilIdle();
- 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));
test_stream->Close();
@@ -477,45 +445,42 @@ TEST_F(AlsaPcmOutputStreamTest, WritePacket_FinishedPacket) {
TEST_F(AlsaPcmOutputStreamTest, WritePacket_NormalPacket) {
// We need to open the stream before writing data to ALSA.
EXPECT_CALL(mock_alsa_wrapper_, PcmOpen(_, _, _, _))
- .WillOnce(DoAll(SetArgumentPointee<0>(kFakeHandle),
- Return(0)));
+ .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>(kTestFramesPerPacket),
- SetArgumentPointee<2>(kTestFramesPerPacket / 2),
- Return(0)));
+ 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(), _))
.WillOnce(Return(written));
+ 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,
- _))
- .WillOnce(Return(packet_->GetDataSize() / kTestBytesPerFrame - written));
+ packet_->data() + written * kTestBytesPerFrame, _))
+ .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_, PcmClose(kFakeHandle)).WillOnce(Return(0));
EXPECT_CALL(mock_alsa_wrapper_, PcmName(kFakeHandle))
.WillOnce(Return(kTestDeviceName));
test_stream->Close();
@@ -524,14 +489,12 @@ TEST_F(AlsaPcmOutputStreamTest, WritePacket_NormalPacket) {
TEST_F(AlsaPcmOutputStreamTest, WritePacket_WriteFails) {
// We need to open the stream before writing data to ALSA.
EXPECT_CALL(mock_alsa_wrapper_, PcmOpen(_, _, _, _))
- .WillOnce(DoAll(SetArgumentPointee<0>(kFakeHandle),
- Return(0)));
+ .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>(kTestFramesPerPacket),
- SetArgumentPointee<2>(kTestFramesPerPacket / 2),
- Return(0)));
+ 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);
@@ -548,11 +511,11 @@ TEST_F(AlsaPcmOutputStreamTest, WritePacket_WriteFails) {
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));
+ .WillOnce(Return(kTestFramesPerPacket));
EXPECT_CALL(mock_alsa_wrapper_, PcmWritei(kFakeHandle, _, _))
.WillOnce(Return(kTestFailedErrno));
EXPECT_CALL(mock_alsa_wrapper_, PcmRecover(kFakeHandle, _, _))
@@ -560,12 +523,11 @@ TEST_F(AlsaPcmOutputStreamTest, WritePacket_WriteFails) {
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_, PcmClose(kFakeHandle)).WillOnce(Return(0));
EXPECT_CALL(mock_alsa_wrapper_, PcmName(kFakeHandle))
.WillOnce(Return(kTestDeviceName));
test_stream->Close();
@@ -648,10 +610,10 @@ TEST_F(AlsaPcmOutputStreamTest, BufferPacket_Underrun) {
.WillOnce(Return(SND_PCM_STATE_XRUN));
EXPECT_CALL(mock_alsa_wrapper_, PcmAvailUpdate(_))
.WillRepeatedly(Return(0)); // Buffer is full.
- EXPECT_CALL(mock_callback,
- OnMoreData(_, AllOf(
- Field(&AudioBuffersState::pending_bytes, 0),
- Field(&AudioBuffersState::hardware_delay_bytes, 0))))
+ EXPECT_CALL(
+ mock_callback,
+ OnMoreData(_, AllOf(Field(&AudioBuffersState::pending_bytes, 0),
+ Field(&AudioBuffersState::hardware_delay_bytes, 0))))
.WillOnce(DoAll(ClearBuffer(), Return(kTestFramesPerPacket / 2)));
bool source_exhausted;
@@ -685,25 +647,19 @@ TEST_F(AlsaPcmOutputStreamTest, AutoSelectDevice_DeviceSelect) {
//
// Note that the loop starts at "1", so the first parameter is ignored in
// these arrays.
- const char* kExpectedDeviceName[] = { NULL,
brettw 2013/06/24 20:28:00 I fould the old code here much easier to read.
- AlsaPcmOutputStream::kDefaultDevice,
- AlsaPcmOutputStream::kDefaultDevice,
- AlsaPcmOutputStream::kDefaultDevice,
- kSurround40, kSurround50, kSurround51,
- kSurround70, kSurround71,
- AlsaPcmOutputStream::kDefaultDevice };
- bool kExpectedDownmix[] = { false, false, false, false, false, true,
- false, false, false, false };
- ChannelLayout kExpectedLayouts[] = { CHANNEL_LAYOUT_NONE,
- CHANNEL_LAYOUT_MONO,
- CHANNEL_LAYOUT_STEREO,
- CHANNEL_LAYOUT_SURROUND,
- CHANNEL_LAYOUT_4_0,
- CHANNEL_LAYOUT_5_0,
- CHANNEL_LAYOUT_5_1,
- CHANNEL_LAYOUT_7_0,
- CHANNEL_LAYOUT_7_1 };
-
+ const char* kExpectedDeviceName[] = {
+ NULL, AlsaPcmOutputStream::kDefaultDevice,
+ AlsaPcmOutputStream::kDefaultDevice, AlsaPcmOutputStream::kDefaultDevice,
+ kSurround40, kSurround50, kSurround51, kSurround70, kSurround71,
+ AlsaPcmOutputStream::kDefaultDevice
+ };
+ bool kExpectedDownmix[] = {false, false, false, false, false, true, false,
+ false, false, false};
+ ChannelLayout kExpectedLayouts[] = {
+ CHANNEL_LAYOUT_NONE, CHANNEL_LAYOUT_MONO, CHANNEL_LAYOUT_STEREO,
+ CHANNEL_LAYOUT_SURROUND, CHANNEL_LAYOUT_4_0, CHANNEL_LAYOUT_5_0,
+ CHANNEL_LAYOUT_5_1, CHANNEL_LAYOUT_7_0, CHANNEL_LAYOUT_7_1
+ };
for (int i = 1; i < 9; ++i) {
if (i == 3 || i == 4 || i == 5) // invalid number of channels
@@ -724,8 +680,7 @@ TEST_F(AlsaPcmOutputStreamTest, AutoSelectDevice_DeviceSelect) {
EXPECT_CALL(mock_alsa_wrapper_,
PcmOpen(_, StrEq(kExpectedDeviceName[i]), _, _))
.WillOnce(DoAll(SetArgumentPointee<0>(kFakeHandle), Return(0)));
- EXPECT_CALL(mock_alsa_wrapper_,
- PcmSetParams(kFakeHandle, _, _, i, _, _, _))
+ EXPECT_CALL(mock_alsa_wrapper_, PcmSetParams(kFakeHandle, _, _, i, _, _, _))
.WillOnce(Return(0));
// The parameters are specified by ALSA documentation, and are in constants
@@ -760,16 +715,15 @@ TEST_F(AlsaPcmOutputStreamTest, AutoSelectDevice_FallbackDevices) {
// 5) Give up trying to open.
//
const string first_try = kSurround50;
- const string second_try = string(AlsaPcmOutputStream::kPlugPrefix) +
- 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_, DeviceNameFreeHint(&kFakeHints[0])).Times(1);
EXPECT_CALL(mock_alsa_wrapper_, DeviceNameGetHint(_, StrEq("IOID")))
.WillRepeatedly(Invoke(OutputHint));
EXPECT_CALL(mock_alsa_wrapper_, DeviceNameGetHint(_, StrEq("NAME")))
@@ -800,8 +754,7 @@ TEST_F(AlsaPcmOutputStreamTest, AutoSelectDevice_HintFail) {
EXPECT_CALL(mock_alsa_wrapper_,
PcmOpen(_, StrEq(AlsaPcmOutputStream::kDefaultDevice), _, _))
.WillOnce(DoAll(SetArgumentPointee<0>(kFakeHandle), Return(0)));
- EXPECT_CALL(mock_alsa_wrapper_,
- PcmSetParams(kFakeHandle, _, _, 2, _, _, _))
+ EXPECT_CALL(mock_alsa_wrapper_, PcmSetParams(kFakeHandle, _, _, 2, _, _, _))
.WillOnce(Return(0));
EXPECT_CALL(mock_alsa_wrapper_, StrError(kTestFailedErrno))
.WillOnce(Return(kDummyMessage));
@@ -829,8 +782,7 @@ TEST_F(AlsaPcmOutputStreamTest, ScheduleNextWrite) {
test_stream->TransitionTo(AlsaPcmOutputStream::kIsPlaying);
InitBuffer(test_stream);
DVLOG(1) << test_stream->state();
- EXPECT_CALL(mock_alsa_wrapper_, PcmAvailUpdate(_))
- .WillOnce(Return(10));
+ EXPECT_CALL(mock_alsa_wrapper_, PcmAvailUpdate(_)).WillOnce(Return(10));
test_stream->ScheduleNextWrite(false);
DVLOG(1) << test_stream->state();
// TODO(sergeyu): Figure out how to check that the task has been added to the
« no previous file with comments | « media/audio/linux/alsa_output.cc ('k') | media/audio/mac/audio_low_latency_input_mac.cc » ('j') | webkit/plugins/ppapi/content_decryptor_delegate.cc » ('J')

Powered by Google App Engine
This is Rietveld 408576698