trunk/src/media/audio/audio_output_proxy_unittest.cc - Issue 38533002: Revert 230334 "Improve and simplify AudioOutputDispatcher."

Unified Diff: trunk/src/media/audio/audio_output_proxy_unittest.cc

Issue 38533002: Revert 230334 "Improve and simplify AudioOutputDispatcher." (Closed) Base URL: svn://svn.chromium.org/chrome/

Patch Set: Created 7 years, 2 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

Index: trunk/src/media/audio/audio_output_proxy_unittest.cc

===================================================================

--- trunk/src/media/audio/audio_output_proxy_unittest.cc (revision 230541)

+++ trunk/src/media/audio/audio_output_proxy_unittest.cc (working copy)

@@ -6,7 +6,6 @@

#include "base/message_loop/message_loop.h"

#include "base/message_loop/message_loop_proxy.h"

-#include "base/run_loop.h"

#include "media/audio/audio_manager.h"

#include "media/audio/audio_manager_base.h"

#include "media/audio/audio_output_dispatcher_impl.h"

@@ -37,8 +36,11 @@

namespace {

-static const int kTestCloseDelayMs = 10;

+static const int kTestCloseDelayMs = 100;

+// Used in the test where we don't want a stream to be closed unexpectedly.

+static const int kTestBigCloseDelaySeconds = 1000;

// Delay between callbacks to AudioSourceCallback::OnMoreData.

static const int kOnMoreDataCallbackDelayMs = 10;

@@ -146,26 +148,33 @@

.WillRepeatedly(Return(message_loop_.message_loop_proxy()));

EXPECT_CALL(manager_, GetWorkerLoop())

.WillRepeatedly(Return(message_loop_.message_loop_proxy()));

- // Use a low sample rate and large buffer size when testing otherwise the

- // FakeAudioOutputStream will keep the message loop busy indefinitely; i.e.,

- // RunUntilIdle() will never terminate.

- params_ = AudioParameters(AudioParameters::AUDIO_PCM_LINEAR,

- CHANNEL_LAYOUT_STEREO, 8000, 16, 2048);

InitDispatcher(base::TimeDelta::FromMilliseconds(kTestCloseDelayMs));

}

virtual void TearDown() {

+ // All paused proxies should have been closed at this point.

+ EXPECT_EQ(0u, dispatcher_impl_->paused_proxies_);

// This is necessary to free all proxy objects that have been

// closed by the test.

message_loop_.RunUntilIdle();

}

virtual void InitDispatcher(base::TimeDelta close_delay) {

+ // Use a low sample rate and large buffer size when testing otherwise the

+ // FakeAudioOutputStream will keep the message loop busy indefinitely; i.e.,

+ // RunUntilIdle() will never terminate.

+ params_ = AudioParameters(AudioParameters::AUDIO_PCM_LINEAR,

+ CHANNEL_LAYOUT_STEREO, 8000, 16, 2048);

dispatcher_impl_ = new AudioOutputDispatcherImpl(&manager(),

params_,

std::string(),

close_delay);

+ // Necessary to know how long the dispatcher will wait before posting

+ // StopStreamTask.

+ pause_delay_ = dispatcher_impl_->pause_delay_;

}

virtual void OnStart() {}

@@ -174,24 +183,15 @@

return manager_;

}

- void WaitForCloseTimer(MockAudioOutputStream* stream) {

- base::RunLoop run_loop;

- EXPECT_CALL(*stream, Close())

- .WillOnce(testing::InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));

- run_loop.Run();

+ // Wait for the close timer to fire.

+ void WaitForCloseTimer(const int timer_delay_ms) {

+ message_loop_.RunUntilIdle(); // OpenTask() may reset the timer.

+ base::PlatformThread::Sleep(

+ base::TimeDelta::FromMilliseconds(timer_delay_ms) * 2);

+ message_loop_.RunUntilIdle();

}

- void CloseAndWaitForCloseTimer(AudioOutputProxy* proxy,

- MockAudioOutputStream* stream) {

- // Close the stream and verify it doesn't happen immediately.

- proxy->Close();

- Mock::VerifyAndClear(stream);

- // Wait for the actual close event to come from the close timer.

- WaitForCloseTimer(stream);

- }

- // Basic Open() and Close() test.

+ // Methods that do actual tests.

void OpenAndClose(AudioOutputDispatcher* dispatcher) {

MockAudioOutputStream stream(&manager_, params_);

@@ -199,13 +199,16 @@

.WillOnce(Return(&stream));

EXPECT_CALL(stream, Open())

.WillOnce(Return(true));

+ EXPECT_CALL(stream, Close())

+ .Times(1);

AudioOutputProxy* proxy = new AudioOutputProxy(dispatcher);

EXPECT_TRUE(proxy->Open());

- CloseAndWaitForCloseTimer(proxy, &stream);

+ proxy->Close();

+ WaitForCloseTimer(kTestCloseDelayMs);

}

- // Creates a stream, and then calls Start() and Stop().

+ // Create a stream, and then calls Start() and Stop().

void StartAndStop(AudioOutputDispatcher* dispatcher) {

MockAudioOutputStream stream(&manager_, params_);

@@ -215,6 +218,8 @@

.WillOnce(Return(true));

EXPECT_CALL(stream, SetVolume(_))

.Times(1);

+ EXPECT_CALL(stream, Close())

+ .Times(1);

AudioOutputProxy* proxy = new AudioOutputProxy(dispatcher);

EXPECT_TRUE(proxy->Open());

@@ -223,12 +228,13 @@

OnStart();

proxy->Stop();

- CloseAndWaitForCloseTimer(proxy, &stream);

+ proxy->Close();

+ WaitForCloseTimer(kTestCloseDelayMs);

EXPECT_TRUE(stream.stop_called());

EXPECT_TRUE(stream.start_called());

}

- // Verify that the stream is closed after Stop() is called.

+ // Verify that the stream is closed after Stop is called.

void CloseAfterStop(AudioOutputDispatcher* dispatcher) {

MockAudioOutputStream stream(&manager_, params_);

@@ -238,6 +244,8 @@

.WillOnce(Return(true));

EXPECT_CALL(stream, SetVolume(_))

.Times(1);

+ EXPECT_CALL(stream, Close())

+ .Times(1);

AudioOutputProxy* proxy = new AudioOutputProxy(dispatcher);

EXPECT_TRUE(proxy->Open());

@@ -246,14 +254,19 @@

OnStart();

proxy->Stop();

- // Wait for the close timer to fire after StopStream().

- WaitForCloseTimer(&stream);

+ // Wait for StopStream() to post StopStreamTask().

+ base::PlatformThread::Sleep(pause_delay_ * 2);

+ WaitForCloseTimer(kTestCloseDelayMs);

+ // Verify expectation before calling Close().

+ Mock::VerifyAndClear(&stream);

proxy->Close();

EXPECT_TRUE(stream.stop_called());

EXPECT_TRUE(stream.start_called());

}

- // Create two streams, but don't start them. Only one device must be opened.

+ // Create two streams, but don't start them. Only one device must be open.

void TwoStreams(AudioOutputDispatcher* dispatcher) {

MockAudioOutputStream stream(&manager_, params_);

@@ -261,13 +274,16 @@

.WillOnce(Return(&stream));

EXPECT_CALL(stream, Open())

.WillOnce(Return(true));

+ EXPECT_CALL(stream, Close())

+ .Times(1);

AudioOutputProxy* proxy1 = new AudioOutputProxy(dispatcher);

AudioOutputProxy* proxy2 = new AudioOutputProxy(dispatcher);

EXPECT_TRUE(proxy1->Open());

EXPECT_TRUE(proxy2->Open());

proxy1->Close();

- CloseAndWaitForCloseTimer(proxy2, &stream);

+ proxy2->Close();

+ WaitForCloseTimer(kTestCloseDelayMs);

EXPECT_FALSE(stream.stop_called());

EXPECT_FALSE(stream.start_called());

}

@@ -286,6 +302,7 @@

AudioOutputProxy* proxy = new AudioOutputProxy(dispatcher);

EXPECT_FALSE(proxy->Open());

proxy->Close();

+ WaitForCloseTimer(kTestCloseDelayMs);

EXPECT_FALSE(stream.stop_called());

EXPECT_FALSE(stream.start_called());

}

@@ -297,45 +314,61 @@

.WillOnce(Return(&stream));

EXPECT_CALL(stream, Open())

.WillOnce(Return(true));

+ EXPECT_CALL(stream, Close())

+ .Times(1);

AudioOutputProxy* proxy = new AudioOutputProxy(dispatcher);

EXPECT_TRUE(proxy->Open());

- WaitForCloseTimer(&stream);

+ // Simulate a delay.

+ base::PlatformThread::Sleep(

+ base::TimeDelta::FromMilliseconds(kTestCloseDelayMs) * 2);

+ message_loop_.RunUntilIdle();

+ // Verify expectation before calling Close().

+ Mock::VerifyAndClear(&stream);

proxy->Close();

EXPECT_FALSE(stream.stop_called());

EXPECT_FALSE(stream.start_called());

}

- void OneStream_TwoPlays(AudioOutputDispatcher* dispatcher) {

- MockAudioOutputStream stream(&manager_, params_);

+ void TwoStreams_OnePlaying(AudioOutputDispatcher* dispatcher) {

+ MockAudioOutputStream stream1(&manager_, params_);

+ MockAudioOutputStream stream2(&manager_, params_);

EXPECT_CALL(manager(), MakeAudioOutputStream(_, _, _))

- .WillOnce(Return(&stream));

+ .WillOnce(Return(&stream1))

+ .WillOnce(Return(&stream2));

- EXPECT_CALL(stream, Open())

+ EXPECT_CALL(stream1, Open())

.WillOnce(Return(true));

- EXPECT_CALL(stream, SetVolume(_))

- .Times(2);

+ EXPECT_CALL(stream1, SetVolume(_))

+ .Times(1);

+ EXPECT_CALL(stream1, Close())

+ .Times(1);

+ EXPECT_CALL(stream2, Open())

+ .WillOnce(Return(true));

+ EXPECT_CALL(stream2, Close())

+ .Times(1);

AudioOutputProxy* proxy1 = new AudioOutputProxy(dispatcher);

+ AudioOutputProxy* proxy2 = new AudioOutputProxy(dispatcher);

EXPECT_TRUE(proxy1->Open());

+ EXPECT_TRUE(proxy2->Open());

proxy1->Start(&callback_);

+ message_loop_.RunUntilIdle();

OnStart();

proxy1->Stop();

- // The stream should now be idle and get reused by |proxy2|.

- AudioOutputProxy* proxy2 = new AudioOutputProxy(dispatcher);

- EXPECT_TRUE(proxy2->Open());

- proxy2->Start(&callback_);

- OnStart();

- proxy2->Stop();

proxy1->Close();

- CloseAndWaitForCloseTimer(proxy2, &stream);

- EXPECT_TRUE(stream.stop_called());

- EXPECT_TRUE(stream.start_called());

+ proxy2->Close();

+ EXPECT_TRUE(stream1.stop_called());

+ EXPECT_TRUE(stream1.start_called());

+ EXPECT_FALSE(stream2.stop_called());

+ EXPECT_FALSE(stream2.start_called());

}

void TwoStreams_BothPlaying(AudioOutputDispatcher* dispatcher) {

@@ -350,11 +383,15 @@

.WillOnce(Return(true));

EXPECT_CALL(stream1, SetVolume(_))

.Times(1);

+ EXPECT_CALL(stream1, Close())

+ .Times(1);

EXPECT_CALL(stream2, Open())

.WillOnce(Return(true));

EXPECT_CALL(stream2, SetVolume(_))

.Times(1);

+ EXPECT_CALL(stream2, Close())

+ .Times(1);

AudioOutputProxy* proxy1 = new AudioOutputProxy(dispatcher);

AudioOutputProxy* proxy2 = new AudioOutputProxy(dispatcher);

@@ -365,11 +402,10 @@

proxy2->Start(&callback_);

OnStart();

proxy1->Stop();

- CloseAndWaitForCloseTimer(proxy1, &stream1);

proxy2->Stop();

- CloseAndWaitForCloseTimer(proxy2, &stream2);

+ proxy1->Close();

+ proxy2->Close();

EXPECT_TRUE(stream1.stop_called());

EXPECT_TRUE(stream1.start_called());

EXPECT_TRUE(stream2.stop_called());

@@ -383,12 +419,20 @@

.WillOnce(Return(&stream));

EXPECT_CALL(stream, Open())

.WillOnce(Return(true));

+ EXPECT_CALL(stream, Close())

+ .Times(1);

AudioOutputProxy* proxy = new AudioOutputProxy(dispatcher);

EXPECT_TRUE(proxy->Open());

- WaitForCloseTimer(&stream);

+ // Simulate a delay.

+ base::PlatformThread::Sleep(

+ base::TimeDelta::FromMilliseconds(kTestCloseDelayMs) * 2);

+ message_loop_.RunUntilIdle();

+ // Verify expectation before calling Close().

+ Mock::VerifyAndClear(&stream);

// |stream| is closed at this point. Start() should reopen it again.

EXPECT_CALL(manager(), MakeAudioOutputStream(_, _, _))

.Times(2)

@@ -411,6 +455,7 @@

base::MessageLoop message_loop_;

scoped_refptr<AudioOutputDispatcherImpl> dispatcher_impl_;

+ base::TimeDelta pause_delay_;

MockAudioManager manager_;

MockAudioSourceCallback callback_;

AudioParameters params_;

@@ -423,6 +468,7 @@

}

virtual void InitDispatcher(base::TimeDelta close_delay) OVERRIDE {

+ AudioOutputProxyTest::InitDispatcher(close_delay);

// Use a low sample rate and large buffer size when testing otherwise the

// FakeAudioOutputStream will keep the message loop busy indefinitely; i.e.,

// RunUntilIdle() will never terminate.

@@ -435,13 +481,10 @@

}

virtual void OnStart() OVERRIDE {

- // Let Start() run for a bit.

- base::RunLoop run_loop;

- message_loop_.PostDelayedTask(

- FROM_HERE,

- run_loop.QuitClosure(),

+ // Let start run for a bit.

+ message_loop_.RunUntilIdle();

+ base::PlatformThread::Sleep(

base::TimeDelta::FromMilliseconds(kStartRunTimeMs));

- run_loop.Run();

}

protected:

@@ -450,82 +493,86 @@

};

TEST_F(AudioOutputProxyTest, CreateAndClose) {

- AudioOutputProxy* proxy = new AudioOutputProxy(dispatcher_impl_);

+ AudioOutputProxy* proxy = new AudioOutputProxy(dispatcher_impl_.get());

proxy->Close();

}

TEST_F(AudioOutputResamplerTest, CreateAndClose) {

- AudioOutputProxy* proxy = new AudioOutputProxy(resampler_);

+ AudioOutputProxy* proxy = new AudioOutputProxy(resampler_.get());

proxy->Close();

}

TEST_F(AudioOutputProxyTest, OpenAndClose) {

- OpenAndClose(dispatcher_impl_);

+ OpenAndClose(dispatcher_impl_.get());

}

TEST_F(AudioOutputResamplerTest, OpenAndClose) {

- OpenAndClose(resampler_);

+ OpenAndClose(resampler_.get());

}

// Create a stream, and verify that it is closed after kTestCloseDelayMs.

// if it doesn't start playing.

TEST_F(AudioOutputProxyTest, CreateAndWait) {

- CreateAndWait(dispatcher_impl_);

+ CreateAndWait(dispatcher_impl_.get());

}

// Create a stream, and verify that it is closed after kTestCloseDelayMs.

// if it doesn't start playing.

TEST_F(AudioOutputResamplerTest, CreateAndWait) {

- CreateAndWait(resampler_);

+ CreateAndWait(resampler_.get());

}

TEST_F(AudioOutputProxyTest, StartAndStop) {

- StartAndStop(dispatcher_impl_);

+ StartAndStop(dispatcher_impl_.get());

}

TEST_F(AudioOutputResamplerTest, StartAndStop) {

- StartAndStop(resampler_);

+ StartAndStop(resampler_.get());

}

TEST_F(AudioOutputProxyTest, CloseAfterStop) {

- CloseAfterStop(dispatcher_impl_);

+ CloseAfterStop(dispatcher_impl_.get());

}

TEST_F(AudioOutputResamplerTest, CloseAfterStop) {

- CloseAfterStop(resampler_);

+ CloseAfterStop(resampler_.get());

}

-TEST_F(AudioOutputProxyTest, TwoStreams) { TwoStreams(dispatcher_impl_); }

+TEST_F(AudioOutputProxyTest, TwoStreams) { TwoStreams(dispatcher_impl_.get()); }

-TEST_F(AudioOutputResamplerTest, TwoStreams) { TwoStreams(resampler_); }

+TEST_F(AudioOutputResamplerTest, TwoStreams) { TwoStreams(resampler_.get()); }

// Two streams: verify that second stream is allocated when the first

// starts playing.

-TEST_F(AudioOutputProxyTest, OneStream_TwoPlays) {

- OneStream_TwoPlays(dispatcher_impl_);

+TEST_F(AudioOutputProxyTest, TwoStreams_OnePlaying) {

+ InitDispatcher(base::TimeDelta::FromSeconds(kTestBigCloseDelaySeconds));

+ TwoStreams_OnePlaying(dispatcher_impl_.get());

}

-TEST_F(AudioOutputResamplerTest, OneStream_TwoPlays) {

- OneStream_TwoPlays(resampler_);

+TEST_F(AudioOutputResamplerTest, TwoStreams_OnePlaying) {

+ InitDispatcher(base::TimeDelta::FromSeconds(kTestBigCloseDelaySeconds));

+ TwoStreams_OnePlaying(resampler_.get());

}

// Two streams, both are playing. Dispatcher should not open a third stream.

TEST_F(AudioOutputProxyTest, TwoStreams_BothPlaying) {

- TwoStreams_BothPlaying(dispatcher_impl_);

+ InitDispatcher(base::TimeDelta::FromSeconds(kTestBigCloseDelaySeconds));

+ TwoStreams_BothPlaying(dispatcher_impl_.get());

}

TEST_F(AudioOutputResamplerTest, TwoStreams_BothPlaying) {

- TwoStreams_BothPlaying(resampler_);

+ InitDispatcher(base::TimeDelta::FromSeconds(kTestBigCloseDelaySeconds));

+ TwoStreams_BothPlaying(resampler_.get());

}

-TEST_F(AudioOutputProxyTest, OpenFailed) { OpenFailed(dispatcher_impl_); }

+TEST_F(AudioOutputProxyTest, OpenFailed) { OpenFailed(dispatcher_impl_.get()); }

// Start() method failed.

TEST_F(AudioOutputProxyTest, StartFailed) {

- StartFailed(dispatcher_impl_);

+ StartFailed(dispatcher_impl_.get());

}

-TEST_F(AudioOutputResamplerTest, StartFailed) { StartFailed(resampler_); }

+TEST_F(AudioOutputResamplerTest, StartFailed) { StartFailed(resampler_.get()); }

// Simulate AudioOutputStream::Create() failure with a low latency stream and

// ensure AudioOutputResampler falls back to the high latency path.

@@ -537,10 +584,13 @@

.WillRepeatedly(Return(&stream));

EXPECT_CALL(stream, Open())

.WillOnce(Return(true));

+ EXPECT_CALL(stream, Close())

+ .Times(1);

- AudioOutputProxy* proxy = new AudioOutputProxy(resampler_);

+ AudioOutputProxy* proxy = new AudioOutputProxy(resampler_.get());

EXPECT_TRUE(proxy->Open());

- CloseAndWaitForCloseTimer(proxy, &stream);

+ proxy->Close();

+ WaitForCloseTimer(kTestCloseDelayMs);

}

// Simulate AudioOutputStream::Open() failure with a low latency stream and

@@ -558,10 +608,13 @@

.Times(1);

EXPECT_CALL(okay_stream, Open())

.WillOnce(Return(true));

+ EXPECT_CALL(okay_stream, Close())

+ .Times(1);

- AudioOutputProxy* proxy = new AudioOutputProxy(resampler_);

+ AudioOutputProxy* proxy = new AudioOutputProxy(resampler_.get());

EXPECT_TRUE(proxy->Open());

- CloseAndWaitForCloseTimer(proxy, &okay_stream);

+ proxy->Close();

+ WaitForCloseTimer(kTestCloseDelayMs);

}

// Simulate failures to open both the low latency and the fallback high latency

@@ -592,10 +645,13 @@

.WillOnce(Return(&okay_stream));

EXPECT_CALL(okay_stream, Open())

.WillOnce(Return(true));

+ EXPECT_CALL(okay_stream, Close())

+ .Times(1);

- AudioOutputProxy* proxy = new AudioOutputProxy(resampler_);

+ AudioOutputProxy* proxy = new AudioOutputProxy(resampler_.get());

EXPECT_TRUE(proxy->Open());

- CloseAndWaitForCloseTimer(proxy, &okay_stream);

+ proxy->Close();

+ WaitForCloseTimer(kTestCloseDelayMs);

}

// Simulate failures to open both the low latency, the fallback high latency

@@ -613,9 +669,10 @@

.Times(kFallbackCount)

.WillRepeatedly(Return(static_cast<AudioOutputStream*>(NULL)));

- AudioOutputProxy* proxy = new AudioOutputProxy(resampler_);

+ AudioOutputProxy* proxy = new AudioOutputProxy(resampler_.get());

EXPECT_FALSE(proxy->Open());

proxy->Close();

+ WaitForCloseTimer(kTestCloseDelayMs);

}

// Simulate an eventual OpenStream() failure; i.e. successful OpenStream() calls

@@ -623,55 +680,72 @@

TEST_F(AudioOutputResamplerTest, LowLatencyOpenEventuallyFails) {

MockAudioOutputStream stream1(&manager_, params_);

MockAudioOutputStream stream2(&manager_, params_);

+ MockAudioOutputStream stream3(&manager_, params_);

// Setup the mock such that all three streams are successfully created.

EXPECT_CALL(manager(), MakeAudioOutputStream(_, _, _))

.WillOnce(Return(&stream1))

.WillOnce(Return(&stream2))

+ .WillOnce(Return(&stream3))

.WillRepeatedly(Return(static_cast<AudioOutputStream*>(NULL)));

// Stream1 should be able to successfully open and start.

EXPECT_CALL(stream1, Open())

.WillOnce(Return(true));

+ EXPECT_CALL(stream1, Close())

+ .Times(1);

EXPECT_CALL(stream1, SetVolume(_))

.Times(1);

// Stream2 should also be able to successfully open and start.

EXPECT_CALL(stream2, Open())

.WillOnce(Return(true));

+ EXPECT_CALL(stream2, Close())

+ .Times(1);

EXPECT_CALL(stream2, SetVolume(_))

.Times(1);

+ // Stream3 should fail on Open() (yet still be closed since

+ // MakeAudioOutputStream returned a valid AudioOutputStream object).

+ EXPECT_CALL(stream3, Open())

+ .WillOnce(Return(false));

+ EXPECT_CALL(stream3, Close())

+ .Times(1);

// Open and start the first proxy and stream.

- AudioOutputProxy* proxy1 = new AudioOutputProxy(resampler_);

+ AudioOutputProxy* proxy1 = new AudioOutputProxy(resampler_.get());

EXPECT_TRUE(proxy1->Open());

proxy1->Start(&callback_);

OnStart();

// Open and start the second proxy and stream.

- AudioOutputProxy* proxy2 = new AudioOutputProxy(resampler_);

+ AudioOutputProxy* proxy2 = new AudioOutputProxy(resampler_.get());

EXPECT_TRUE(proxy2->Open());

proxy2->Start(&callback_);

OnStart();

// Attempt to open the third stream which should fail.

- AudioOutputProxy* proxy3 = new AudioOutputProxy(resampler_);

+ AudioOutputProxy* proxy3 = new AudioOutputProxy(resampler_.get());

EXPECT_FALSE(proxy3->Open());

- proxy3->Close();

// Perform the required Stop()/Close() shutdown dance for each proxy. Under

// the hood each proxy should correctly call CloseStream() if OpenStream()

// succeeded or not.

+ proxy3->Stop();

+ proxy3->Close();

proxy2->Stop();

- CloseAndWaitForCloseTimer(proxy2, &stream2);

+ proxy2->Close();

proxy1->Stop();

- CloseAndWaitForCloseTimer(proxy1, &stream1);

+ proxy1->Close();

+ // Wait for all of the messages to fly and then verify stream behavior.

+ WaitForCloseTimer(kTestCloseDelayMs);

EXPECT_TRUE(stream1.stop_called());

EXPECT_TRUE(stream1.start_called());

EXPECT_TRUE(stream2.stop_called());

EXPECT_TRUE(stream2.start_called());

+ EXPECT_FALSE(stream3.stop_called());

+ EXPECT_FALSE(stream3.start_called());

}

} // namespace media

« no previous file with comments | « trunk/src/media/audio/audio_output_dispatcher_impl.cc ('k') | no next file » | no next file with comments »