This source file includes following definitions.
- renderer_
- TEST_F
- TEST_F
#include <vector>
#include "content/renderer/media/audio_device_factory.h"
#include "content/renderer/media/audio_message_filter.h"
#include "content/renderer/media/media_stream_audio_renderer.h"
#include "content/renderer/media/mock_media_stream_dependency_factory.h"
#include "content/renderer/media/webrtc_audio_device_impl.h"
#include "content/renderer/media/webrtc_audio_renderer.h"
#include "media/audio/audio_output_device.h"
#include "media/audio/audio_output_ipc.h"
#include "media/base/audio_bus.h"
#include "media/base/mock_audio_renderer_sink.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/libjingle/source/talk/app/webrtc/mediastreaminterface.h"
using testing::Return;
namespace content {
namespace {
class MockAudioOutputIPC : public media::AudioOutputIPC {
public:
MockAudioOutputIPC() {}
virtual ~MockAudioOutputIPC() {}
MOCK_METHOD3(CreateStream, void(media::AudioOutputIPCDelegate* delegate,
const media::AudioParameters& params,
int session_id));
MOCK_METHOD0(PlayStream, void());
MOCK_METHOD0(PauseStream, void());
MOCK_METHOD0(CloseStream, void());
MOCK_METHOD1(SetVolume, void(double volume));
};
class FakeAudioOutputDevice
: NON_EXPORTED_BASE(public media::AudioOutputDevice) {
public:
FakeAudioOutputDevice(
scoped_ptr<media::AudioOutputIPC> ipc,
const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
: AudioOutputDevice(ipc.Pass(),
io_task_runner) {}
MOCK_METHOD0(Start, void());
MOCK_METHOD0(Stop, void());
MOCK_METHOD0(Pause, void());
MOCK_METHOD0(Play, void());
MOCK_METHOD1(SetVolume, bool(double volume));
protected:
virtual ~FakeAudioOutputDevice() {}
};
class MockAudioDeviceFactory : public AudioDeviceFactory {
public:
MockAudioDeviceFactory() {}
virtual ~MockAudioDeviceFactory() {}
MOCK_METHOD1(CreateOutputDevice, media::AudioOutputDevice*(int));
MOCK_METHOD1(CreateInputDevice, media::AudioInputDevice*(int));
};
class MockAudioRendererSource : public WebRtcAudioRendererSource {
public:
MockAudioRendererSource() {}
virtual ~MockAudioRendererSource() {}
MOCK_METHOD3(RenderData, void(media::AudioBus* audio_bus,
int sample_rate,
int audio_delay_milliseconds));
MOCK_METHOD1(RemoveAudioRenderer, void(WebRtcAudioRenderer* renderer));
};
}
class WebRtcAudioRendererTest : public testing::Test {
protected:
WebRtcAudioRendererTest()
: message_loop_(new base::MessageLoopForIO),
mock_ipc_(new MockAudioOutputIPC()),
mock_output_device_(new FakeAudioOutputDevice(
scoped_ptr<media::AudioOutputIPC>(mock_ipc_),
message_loop_->message_loop_proxy())),
factory_(new MockAudioDeviceFactory()),
source_(new MockAudioRendererSource()),
stream_(new talk_base::RefCountedObject<MockMediaStream>("label")),
renderer_(new WebRtcAudioRenderer(stream_, 1, 1, 1, 44100, 441)) {
EXPECT_CALL(*factory_.get(), CreateOutputDevice(1))
.WillOnce(Return(mock_output_device_));
EXPECT_CALL(*mock_output_device_, Start());
EXPECT_TRUE(renderer_->Initialize(source_.get()));
renderer_proxy_ = renderer_->CreateSharedAudioRendererProxy(stream_);
}
scoped_ptr<base::MessageLoopForIO> message_loop_;
MockAudioOutputIPC* mock_ipc_;
scoped_refptr<FakeAudioOutputDevice> mock_output_device_;
scoped_ptr<MockAudioDeviceFactory> factory_;
scoped_ptr<MockAudioRendererSource> source_;
scoped_refptr<webrtc::MediaStreamInterface> stream_;
scoped_refptr<WebRtcAudioRenderer> renderer_;
scoped_refptr<MediaStreamAudioRenderer> renderer_proxy_;
};
TEST_F(WebRtcAudioRendererTest, StopRenderer) {
renderer_proxy_->Start();
EXPECT_CALL(*mock_output_device_, Stop());
EXPECT_CALL(*source_.get(), RemoveAudioRenderer(renderer_.get()));
renderer_proxy_->Stop();
}
TEST_F(WebRtcAudioRendererTest, MultipleRenderers) {
renderer_proxy_->Start();
std::vector<scoped_refptr<MediaStreamAudioRenderer> > renderer_proxies_;
static const int kNumberOfRendererProxy = 5;
for (int i = 0; i < kNumberOfRendererProxy; ++i) {
scoped_refptr<MediaStreamAudioRenderer> renderer_proxy(
renderer_->CreateSharedAudioRendererProxy(stream_));
renderer_proxy->Start();
renderer_proxies_.push_back(renderer_proxy);
}
EXPECT_CALL(*mock_output_device_, Stop()).Times(0);
renderer_proxy_->Stop();
for (int i = 0; i < kNumberOfRendererProxy; ++i) {
if (i != kNumberOfRendererProxy -1) {
EXPECT_CALL(*mock_output_device_, Stop()).Times(0);
} else {
EXPECT_CALL(*source_.get(), RemoveAudioRenderer(renderer_.get()));
EXPECT_CALL(*mock_output_device_, Stop());
}
renderer_proxies_[i]->Stop();
}
}
}