From 86f613d6b893d03c822373f7e7ec51db78a90f9f Mon Sep 17 00:00:00 2001 From: "pbos@webrtc.org" Date: Tue, 10 Jun 2014 08:53:05 +0000 Subject: [PATCH] Move WebRtcVideoEngine2 fakes to unittest header. BUG=1788 R=wu@webrtc.org Review URL: https://webrtc-codereview.appspot.com/18509004 git-svn-id: http://webrtc.googlecode.com/svn/trunk@6382 4adac7df-926f-26a2-2b94-8c16560cd09d --- talk/libjingle_tests.gyp | 1 + .../webrtc/webrtcvideoengine2_unittest.cc | 367 +++++++++--------- .../webrtc/webrtcvideoengine2_unittest.h | 157 ++++++++ 3 files changed, 339 insertions(+), 186 deletions(-) create mode 100644 talk/media/webrtc/webrtcvideoengine2_unittest.h diff --git a/talk/libjingle_tests.gyp b/talk/libjingle_tests.gyp index 1cbfe85ddf..9fefa91aa2 100755 --- a/talk/libjingle_tests.gyp +++ b/talk/libjingle_tests.gyp @@ -301,6 +301,7 @@ # 'media/devices/devicemanager_unittest.cc', 'media/webrtc/webrtcvideoengine_unittest.cc', 'media/webrtc/webrtcvideoengine2_unittest.cc', + 'media/webrtc/webrtcvideoengine2_unittest.h', 'media/webrtc/webrtcvoiceengine_unittest.cc', ], 'conditions': [ diff --git a/talk/media/webrtc/webrtcvideoengine2_unittest.cc b/talk/media/webrtc/webrtcvideoengine2_unittest.cc index c478b42ca8..2e8f924128 100644 --- a/talk/media/webrtc/webrtcvideoengine2_unittest.cc +++ b/talk/media/webrtc/webrtcvideoengine2_unittest.cc @@ -26,13 +26,14 @@ */ #include +#include #include "talk/base/gunit.h" #include "talk/media/base/testutils.h" #include "talk/media/base/videoengine_unittest.h" #include "talk/media/webrtc/webrtcvideoengine2.h" +#include "talk/media/webrtc/webrtcvideoengine2_unittest.h" #include "talk/media/webrtc/webrtcvideochannelfactory.h" -#include "webrtc/call.h" namespace { static const cricket::VideoCodec kVp8Codec720p(100, "VP8", 1280, 720, 30, 0); @@ -50,234 +51,228 @@ static const uint32 kRtxSsrcs1[] = {4}; } // namespace namespace cricket { -class FakeVideoSendStream : public webrtc::VideoSendStream { - public: - FakeVideoSendStream(const webrtc::VideoSendStream::Config& config, - const std::vector& video_streams) - : sending_(false), config_(config), video_streams_(video_streams) {} +FakeVideoSendStream::FakeVideoSendStream( + const webrtc::VideoSendStream::Config& config, + const std::vector& video_streams) + : sending_(false), config_(config), video_streams_(video_streams) { +} - webrtc::VideoSendStream::Config GetConfig() { return config_; } - std::vector GetVideoStreams() { return video_streams_; } +webrtc::VideoSendStream::Config FakeVideoSendStream::GetConfig() { + return config_; +} - bool IsSending() { return sending_; } +std::vector FakeVideoSendStream::GetVideoStreams() { + return video_streams_; +} - private: - virtual webrtc::VideoSendStream::Stats GetStats() const OVERRIDE { - return webrtc::VideoSendStream::Stats(); - } +bool FakeVideoSendStream::IsSending() { + return sending_; +} - virtual bool ReconfigureVideoEncoder( - const std::vector& streams, - const void* encoder_specific) OVERRIDE { - video_streams_ = streams; - return true; - } +webrtc::VideoSendStream::Stats FakeVideoSendStream::GetStats() const { + return webrtc::VideoSendStream::Stats(); +} - virtual webrtc::VideoSendStreamInput* Input() OVERRIDE { - // TODO(pbos): Fix. - return NULL; - } +bool FakeVideoSendStream::ReconfigureVideoEncoder( + const std::vector& streams, + const void* encoder_specific) { + video_streams_ = streams; + return true; +} - virtual void Start() OVERRIDE { sending_ = true; } +webrtc::VideoSendStreamInput* FakeVideoSendStream::Input() { + // TODO(pbos): Fix. + return NULL; +} - virtual void Stop() OVERRIDE { sending_ = false; } +void FakeVideoSendStream::Start() { + sending_ = true; +} - bool sending_; - webrtc::VideoSendStream::Config config_; - std::vector video_streams_; -}; +void FakeVideoSendStream::Stop() { + sending_ = false; +} -class FakeVideoReceiveStream : public webrtc::VideoReceiveStream { - public: - explicit FakeVideoReceiveStream( - const webrtc::VideoReceiveStream::Config& config) - : config_(config), receiving_(false) {} +FakeVideoReceiveStream::FakeVideoReceiveStream( + const webrtc::VideoReceiveStream::Config& config) + : config_(config), receiving_(false) { +} - webrtc::VideoReceiveStream::Config GetConfig() { return config_; } +webrtc::VideoReceiveStream::Config FakeVideoReceiveStream::GetConfig() { + return config_; +} - private: - virtual webrtc::VideoReceiveStream::Stats GetStats() const OVERRIDE { - return webrtc::VideoReceiveStream::Stats(); - } +webrtc::VideoReceiveStream::Stats FakeVideoReceiveStream::GetStats() const { + return webrtc::VideoReceiveStream::Stats(); +} - virtual void Start() OVERRIDE { receiving_ = true; } - virtual void Stop() OVERRIDE { receiving_ = false; } - virtual void GetCurrentReceiveCodec(webrtc::VideoCodec* codec) OVERRIDE {} +void FakeVideoReceiveStream::Start() { + receiving_ = true; +} +void FakeVideoReceiveStream::Stop() { + receiving_ = false; +} +void FakeVideoReceiveStream::GetCurrentReceiveCodec(webrtc::VideoCodec* codec) { +} - webrtc::VideoReceiveStream::Config config_; - bool receiving_; -}; +FakeCall::FakeCall() { SetVideoCodecs(GetDefaultVideoCodecs()); } -class FakeCall : public webrtc::Call { - public: - FakeCall() { SetVideoCodecs(GetDefaultVideoCodecs()); } +FakeCall::~FakeCall() { + EXPECT_EQ(0u, video_send_streams_.size()); + EXPECT_EQ(0u, video_receive_streams_.size()); +} - ~FakeCall() { - EXPECT_EQ(0u, video_send_streams_.size()); - EXPECT_EQ(0u, video_receive_streams_.size()); - } +void FakeCall::SetVideoCodecs(const std::vector codecs) { + codecs_ = codecs; +} - void SetVideoCodecs(const std::vector codecs) { - codecs_ = codecs; - } +std::vector FakeCall::GetVideoSendStreams() { + return video_send_streams_; +} - std::vector GetVideoSendStreams() { - return video_send_streams_; - } +std::vector FakeCall::GetVideoReceiveStreams() { + return video_receive_streams_; +} - std::vector GetVideoReceiveStreams() { - return video_receive_streams_; - } +webrtc::VideoCodec FakeCall::GetEmptyVideoCodec() { + webrtc::VideoCodec codec; + codec.minBitrate = 300; + codec.startBitrate = 800; + codec.maxBitrate = 1500; + codec.maxFramerate = 10; + codec.width = 640; + codec.height = 480; + codec.qpMax = 56; - webrtc::VideoCodec GetEmptyVideoCodec() { - webrtc::VideoCodec codec; - codec.minBitrate = 300; - codec.startBitrate = 800; - codec.maxBitrate = 1500; - codec.maxFramerate = 10; - codec.width = 640; - codec.height = 480; - codec.qpMax = 56; + return codec; +} - return codec; - } +webrtc::VideoCodec FakeCall::GetVideoCodecVp8() { + webrtc::VideoCodec vp8_codec = GetEmptyVideoCodec(); + vp8_codec.codecType = webrtc::kVideoCodecVP8; + strcpy(vp8_codec.plName, kVp8Codec.name.c_str()); + vp8_codec.plType = kVp8Codec.id; - webrtc::VideoCodec GetVideoCodecVp8() { - webrtc::VideoCodec vp8_codec = GetEmptyVideoCodec(); - vp8_codec.codecType = webrtc::kVideoCodecVP8; - strcpy(vp8_codec.plName, kVp8Codec.name.c_str()); - vp8_codec.plType = kVp8Codec.id; + return vp8_codec; +} - return vp8_codec; - } +webrtc::VideoCodec FakeCall::GetVideoCodecVp9() { + webrtc::VideoCodec vp9_codec = GetEmptyVideoCodec(); + // TODO(pbos): Add a correct codecType when webrtc has one. + vp9_codec.codecType = webrtc::kVideoCodecVP8; + strcpy(vp9_codec.plName, kVp9Codec.name.c_str()); + vp9_codec.plType = kVp9Codec.id; - webrtc::VideoCodec GetVideoCodecVp9() { - webrtc::VideoCodec vp9_codec = GetEmptyVideoCodec(); - // TODO(pbos): Add a correct codecType when webrtc has one. - vp9_codec.codecType = webrtc::kVideoCodecVP8; - strcpy(vp9_codec.plName, kVp9Codec.name.c_str()); - vp9_codec.plType = kVp9Codec.id; + return vp9_codec; +} - return vp9_codec; - } +std::vector FakeCall::GetDefaultVideoCodecs() { + std::vector codecs; + codecs.push_back(GetVideoCodecVp8()); + // codecs.push_back(GetVideoCodecVp9()); - std::vector GetDefaultVideoCodecs() { - std::vector codecs; - codecs.push_back(GetVideoCodecVp8()); - // codecs.push_back(GetVideoCodecVp9()); + return codecs; +} - return codecs; - } +webrtc::VideoSendStream::Config FakeCall::GetDefaultSendConfig() { + webrtc::VideoSendStream::Config config; + // TODO(pbos): Encoder settings. + // config.codec = GetVideoCodecVp8(); + return config; +} - private: - virtual webrtc::VideoSendStream::Config GetDefaultSendConfig() OVERRIDE { - webrtc::VideoSendStream::Config config; - // TODO(pbos): Encoder settings. - // config.codec = GetVideoCodecVp8(); - return config; - } +webrtc::VideoSendStream* FakeCall::CreateVideoSendStream( + const webrtc::VideoSendStream::Config& config, + const std::vector& video_streams, + const void* encoder_settings) { + FakeVideoSendStream* fake_stream = + new FakeVideoSendStream(config, video_streams); + video_send_streams_.push_back(fake_stream); + return fake_stream; +} - virtual webrtc::VideoSendStream* CreateVideoSendStream( - const webrtc::VideoSendStream::Config& config, - const std::vector& video_streams, - const void* encoder_settings) OVERRIDE { - FakeVideoSendStream* fake_stream = - new FakeVideoSendStream(config, video_streams); - video_send_streams_.push_back(fake_stream); - return fake_stream; - } - - virtual void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) - OVERRIDE { - FakeVideoSendStream* fake_stream = - static_cast(send_stream); - for (size_t i = 0; i < video_send_streams_.size(); ++i) { - if (video_send_streams_[i] == fake_stream) { - delete video_send_streams_[i]; - video_send_streams_.erase(video_send_streams_.begin() + i); - return; - } +void FakeCall::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) { + FakeVideoSendStream* fake_stream = + static_cast(send_stream); + for (size_t i = 0; i < video_send_streams_.size(); ++i) { + if (video_send_streams_[i] == fake_stream) { + delete video_send_streams_[i]; + video_send_streams_.erase(video_send_streams_.begin() + i); + return; } - ADD_FAILURE() << "DestroyVideoSendStream called with unknown paramter."; } + ADD_FAILURE() << "DestroyVideoSendStream called with unknown paramter."; +} - virtual webrtc::VideoReceiveStream::Config GetDefaultReceiveConfig() - OVERRIDE { - return webrtc::VideoReceiveStream::Config(); - } +webrtc::VideoReceiveStream::Config FakeCall::GetDefaultReceiveConfig() { + return webrtc::VideoReceiveStream::Config(); +} - virtual webrtc::VideoReceiveStream* CreateVideoReceiveStream( - const webrtc::VideoReceiveStream::Config& config) OVERRIDE { - video_receive_streams_.push_back(new FakeVideoReceiveStream(config)); - return video_receive_streams_[video_receive_streams_.size() - 1]; - } +webrtc::VideoReceiveStream* FakeCall::CreateVideoReceiveStream( + const webrtc::VideoReceiveStream::Config& config) { + video_receive_streams_.push_back(new FakeVideoReceiveStream(config)); + return video_receive_streams_[video_receive_streams_.size() - 1]; +} - virtual void DestroyVideoReceiveStream( - webrtc::VideoReceiveStream* receive_stream) OVERRIDE { - FakeVideoReceiveStream* fake_stream = - static_cast(receive_stream); - for (size_t i = 0; i < video_receive_streams_.size(); ++i) { - if (video_receive_streams_[i] == fake_stream) { - delete video_receive_streams_[i]; - video_receive_streams_.erase(video_receive_streams_.begin() + i); - return; - } +void FakeCall::DestroyVideoReceiveStream( + webrtc::VideoReceiveStream* receive_stream) { + FakeVideoReceiveStream* fake_stream = + static_cast(receive_stream); + for (size_t i = 0; i < video_receive_streams_.size(); ++i) { + if (video_receive_streams_[i] == fake_stream) { + delete video_receive_streams_[i]; + video_receive_streams_.erase(video_receive_streams_.begin() + i); + return; } - ADD_FAILURE() << "DestroyVideoReceiveStream called with unknown paramter."; } + ADD_FAILURE() << "DestroyVideoReceiveStream called with unknown paramter."; +} - virtual webrtc::PacketReceiver* Receiver() OVERRIDE { - // TODO(pbos): Fix this. - return NULL; - } +webrtc::PacketReceiver* FakeCall::Receiver() { + // TODO(pbos): Fix this. + return NULL; +} - virtual uint32_t SendBitrateEstimate() OVERRIDE { return 0; } +uint32_t FakeCall::SendBitrateEstimate() { + return 0; +} - virtual uint32_t ReceiveBitrateEstimate() OVERRIDE { return 0; } +uint32_t FakeCall::ReceiveBitrateEstimate() { + return 0; +} - private: - std::vector codecs_; - std::vector video_send_streams_; - std::vector video_receive_streams_; -}; +FakeWebRtcVideoChannel2::FakeWebRtcVideoChannel2( + FakeCall* call, + WebRtcVideoEngine2* engine, + VoiceMediaChannel* voice_channel) + : WebRtcVideoChannel2(call, engine, engine->GetVideoEncoderFactory()), + fake_call_(call), + voice_channel_(voice_channel) { +} -class FakeWebRtcVideoChannel2 : public WebRtcVideoChannel2 { - public: - FakeWebRtcVideoChannel2(FakeCall* call, - WebRtcVideoEngine2* engine, - VoiceMediaChannel* voice_channel) - : WebRtcVideoChannel2(call, engine, engine->GetVideoEncoderFactory()), - fake_call_(call), - voice_channel_(voice_channel) {} +FakeWebRtcVideoChannel2::~FakeWebRtcVideoChannel2() { +} - virtual ~FakeWebRtcVideoChannel2() {} +VoiceMediaChannel* FakeWebRtcVideoChannel2::GetVoiceChannel() { + return voice_channel_; +} +FakeCall* FakeWebRtcVideoChannel2::GetFakeCall() { + return fake_call_; +} - VoiceMediaChannel* GetVoiceChannel() { return voice_channel_; } - FakeCall* GetFakeCall() { return fake_call_; } +FakeWebRtcVideoChannel2* FakeWebRtcVideoMediaChannelFactory::GetFakeChannel( + VideoMediaChannel* channel) { + return channel_map_[channel]; +} - private: - FakeCall* fake_call_; - VoiceMediaChannel* voice_channel_; -}; - -class FakeWebRtcVideoMediaChannelFactory : public WebRtcVideoChannelFactory { - public: - FakeWebRtcVideoChannel2* GetFakeChannel(VideoMediaChannel* channel) { - return channel_map_[channel]; - } - - private: - virtual WebRtcVideoChannel2* Create(WebRtcVideoEngine2* engine, - VoiceMediaChannel* voice_channel) - OVERRIDE { - FakeWebRtcVideoChannel2* channel = - new FakeWebRtcVideoChannel2(new FakeCall(), engine, voice_channel); - channel_map_[channel] = channel; - return channel; - } - - std::map channel_map_; -}; +WebRtcVideoChannel2* FakeWebRtcVideoMediaChannelFactory::Create( + WebRtcVideoEngine2* engine, + VoiceMediaChannel* voice_channel) { + FakeWebRtcVideoChannel2* channel = + new FakeWebRtcVideoChannel2(new FakeCall(), engine, voice_channel); + channel_map_[channel] = channel; + return channel; +} class WebRtcVideoEngine2Test : public testing::Test { public: diff --git a/talk/media/webrtc/webrtcvideoengine2_unittest.h b/talk/media/webrtc/webrtcvideoengine2_unittest.h new file mode 100644 index 0000000000..879b4f4044 --- /dev/null +++ b/talk/media/webrtc/webrtcvideoengine2_unittest.h @@ -0,0 +1,157 @@ +/* + * libjingle + * Copyright 2014 Google Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO + * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef TALK_MEDIA_WEBRTC_WEBRTCVIDEOENGINE2_UNITTEST_H_ +#define TALK_MEDIA_WEBRTC_WEBRTCVIDEOENGINE2_UNITTEST_H_ + +#include +#include + +#include "webrtc/call.h" +#include "webrtc/video_receive_stream.h" +#include "webrtc/video_send_stream.h" + +namespace cricket { +class FakeVideoSendStream : public webrtc::VideoSendStream { + public: + FakeVideoSendStream(const webrtc::VideoSendStream::Config& config, + const std::vector& video_streams); + webrtc::VideoSendStream::Config GetConfig(); + std::vector GetVideoStreams(); + + bool IsSending(); + + private: + virtual webrtc::VideoSendStream::Stats GetStats() const OVERRIDE; + + virtual bool ReconfigureVideoEncoder( + const std::vector& streams, + const void* encoder_specific); + + virtual webrtc::VideoSendStreamInput* Input() OVERRIDE; + + virtual void Start() OVERRIDE; + virtual void Stop() OVERRIDE; + + bool sending_; + webrtc::VideoSendStream::Config config_; + std::vector video_streams_; +}; + +class FakeVideoReceiveStream : public webrtc::VideoReceiveStream { + public: + explicit FakeVideoReceiveStream( + const webrtc::VideoReceiveStream::Config& config); + + webrtc::VideoReceiveStream::Config GetConfig(); + + private: + virtual webrtc::VideoReceiveStream::Stats GetStats() const OVERRIDE; + + virtual void Start() OVERRIDE; + virtual void Stop() OVERRIDE; + virtual void GetCurrentReceiveCodec(webrtc::VideoCodec* codec); + + webrtc::VideoReceiveStream::Config config_; + bool receiving_; +}; + +class FakeCall : public webrtc::Call { + public: + FakeCall(); + ~FakeCall(); + + void SetVideoCodecs(const std::vector codecs); + + std::vector GetVideoSendStreams(); + std::vector GetVideoReceiveStreams(); + + webrtc::VideoCodec GetEmptyVideoCodec(); + + webrtc::VideoCodec GetVideoCodecVp8(); + webrtc::VideoCodec GetVideoCodecVp9(); + + std::vector GetDefaultVideoCodecs(); + + private: + virtual webrtc::VideoSendStream::Config GetDefaultSendConfig() OVERRIDE; + + virtual webrtc::VideoSendStream* CreateVideoSendStream( + const webrtc::VideoSendStream::Config& config, + const std::vector& video_streams, + const void* encoder_settings) OVERRIDE; + + virtual void DestroyVideoSendStream( + webrtc::VideoSendStream* send_stream) OVERRIDE; + + virtual webrtc::VideoReceiveStream::Config GetDefaultReceiveConfig() OVERRIDE; + + virtual webrtc::VideoReceiveStream* CreateVideoReceiveStream( + const webrtc::VideoReceiveStream::Config& config) OVERRIDE; + + virtual void DestroyVideoReceiveStream( + webrtc::VideoReceiveStream* receive_stream) OVERRIDE; + virtual webrtc::PacketReceiver* Receiver() OVERRIDE; + + virtual uint32_t SendBitrateEstimate() OVERRIDE; + virtual uint32_t ReceiveBitrateEstimate() OVERRIDE; + + std::vector codecs_; + std::vector video_send_streams_; + std::vector video_receive_streams_; +}; + +class FakeWebRtcVideoChannel2 : public WebRtcVideoChannel2 { + public: + FakeWebRtcVideoChannel2(FakeCall* call, + WebRtcVideoEngine2* engine, + VoiceMediaChannel* voice_channel); + virtual ~FakeWebRtcVideoChannel2(); + + VoiceMediaChannel* GetVoiceChannel(); + FakeCall* GetFakeCall(); + + private: + FakeCall* fake_call_; + VoiceMediaChannel* voice_channel_; +}; + +class FakeWebRtcVideoMediaChannelFactory : public WebRtcVideoChannelFactory { + public: + FakeWebRtcVideoChannel2* GetFakeChannel(VideoMediaChannel* channel); + + private: + virtual WebRtcVideoChannel2* Create( + WebRtcVideoEngine2* engine, + VoiceMediaChannel* voice_channel) OVERRIDE; + + std::map channel_map_; +}; + + +} // namespace cricket +#endif // TALK_MEDIA_WEBRTC_WEBRTCVIDEOENGINE2_UNITTEST_H_