Source code
Revision control
Copy as Markdown
Other Tools
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
#ifndef MOCK_CALL_H_
#define MOCK_CALL_H_
#include "gmock/gmock.h"
#include "mozilla/Assertions.h"
#include "mozilla/Maybe.h"
#include "mozilla/media/MediaUtils.h"
#include "WebrtcCallWrapper.h"
#include "PeerConnectionCtx.h"
// libwebrtc
#include "api/call/audio_sink.h"
#include "call/call.h"
namespace test {
class MockCallWrapper;
class MockAudioSendStream : public webrtc::AudioSendStream {
public:
explicit MockAudioSendStream(RefPtr<MockCallWrapper> aCallWrapper)
: mCallWrapper(std::move(aCallWrapper)) {}
const webrtc::AudioSendStream::Config& GetConfig() const override;
void Reconfigure(const Config& config,
webrtc::SetParametersCallback callback) override;
void Start() override {}
void Stop() override {}
void SendAudioData(std::unique_ptr<webrtc::AudioFrame> audio_frame) override {
}
bool SendTelephoneEvent(int payload_type, int payload_frequency, int event,
int duration_ms) override {
return true;
}
void SetMuted(bool muted) override {}
Stats GetStats() const override { return mStats; }
Stats GetStats(bool has_remote_tracks) const override { return mStats; }
virtual ~MockAudioSendStream() {}
const RefPtr<MockCallWrapper> mCallWrapper;
webrtc::AudioSendStream::Stats mStats;
};
class MockAudioReceiveStream : public webrtc::AudioReceiveStreamInterface {
public:
explicit MockAudioReceiveStream(RefPtr<MockCallWrapper> aCallWrapper)
: mCallWrapper(std::move(aCallWrapper)) {}
void Start() override {}
void Stop() override {}
bool IsRunning() const override { return true; }
Stats GetStats(bool get_and_clear_legacy_stats) const override {
return mStats;
}
void SetSink(webrtc::AudioSinkInterface* sink) override {}
void SetGain(float gain) override {}
std::vector<webrtc::RtpSource> GetSources() const override {
return mRtpSources;
}
void SetRtcpMode(webrtc::RtcpMode mode) override {}
virtual void SetDepacketizerToDecoderFrameTransformer(
rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)
override {
MOZ_CRASH(
"Unimplemented after webrtc.org e2561e17e2 removed the Reconfigure "
"method.");
}
virtual void SetDecoderMap(
std::map<int, webrtc::SdpAudioFormat> decoder_map) override;
virtual void SetNackHistory(int history_ms) override {
MOZ_CRASH(
"Unimplemented after webrtc.org e2561e17e2 removed the Reconfigure "
"method.");
}
virtual void SetNonSenderRttMeasurement(bool enabled) override {}
void SetFrameDecryptor(rtc::scoped_refptr<webrtc::FrameDecryptorInterface>
frame_decryptor) override {}
bool SetBaseMinimumPlayoutDelayMs(int delay_ms) override { return false; }
int GetBaseMinimumPlayoutDelayMs() const override { return 0; }
uint32_t remote_ssrc() const override { return 0; }
virtual ~MockAudioReceiveStream() {}
const RefPtr<MockCallWrapper> mCallWrapper;
webrtc::AudioReceiveStreamInterface::Stats mStats;
std::vector<webrtc::RtpSource> mRtpSources;
};
class MockVideoSendStream : public webrtc::VideoSendStream {
public:
explicit MockVideoSendStream(RefPtr<MockCallWrapper> aCallWrapper)
: mCallWrapper(std::move(aCallWrapper)) {}
void Start() override {}
void Stop() override {}
bool started() override { return false; }
void SetSource(
rtc::VideoSourceInterface<webrtc::VideoFrame>* source,
const webrtc::DegradationPreference& degradation_preference) override {}
void ReconfigureVideoEncoder(webrtc::VideoEncoderConfig config) override;
void ReconfigureVideoEncoder(webrtc::VideoEncoderConfig config,
webrtc::SetParametersCallback callback) override;
Stats GetStats() override { return mStats; }
void AddAdaptationResource(
rtc::scoped_refptr<webrtc::Resource> resource) override {}
std::vector<rtc::scoped_refptr<webrtc::Resource>> GetAdaptationResources()
override {
return std::vector<rtc::scoped_refptr<webrtc::Resource>>();
}
void GenerateKeyFrame(const std::vector<std::string>& rids) override {}
virtual ~MockVideoSendStream() {}
const RefPtr<MockCallWrapper> mCallWrapper;
webrtc::VideoSendStream::Stats mStats;
};
class MockVideoReceiveStream : public webrtc::VideoReceiveStreamInterface {
public:
explicit MockVideoReceiveStream(RefPtr<MockCallWrapper> aCallWrapper)
: mCallWrapper(std::move(aCallWrapper)) {}
void Start() override {}
void Stop() override {}
Stats GetStats() const override { return mStats; }
std::vector<webrtc::RtpSource> GetSources() const override {
return std::vector<webrtc::RtpSource>();
}
bool SetBaseMinimumPlayoutDelayMs(int delay_ms) override { return false; }
int GetBaseMinimumPlayoutDelayMs() const override { return 0; }
void SetFrameDecryptor(rtc::scoped_refptr<webrtc::FrameDecryptorInterface>
frame_decryptor) override {}
void SetDepacketizerToDecoderFrameTransformer(
rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)
override {}
RecordingState SetAndGetRecordingState(RecordingState state,
bool generate_key_frame) override {
return {};
}
void GenerateKeyFrame() override {}
void SetRtcpMode(webrtc::RtcpMode mode) override {}
void SetFlexFecProtection(
webrtc::RtpPacketSinkInterface* flexfec_sink) override {}
void SetLossNotificationEnabled(bool enabled) override {}
void SetNackHistory(webrtc::TimeDelta history) override {}
void SetProtectionPayloadTypes(int red_payload_type,
int ulpfec_payload_type) override {}
void SetRtcpXr(Config::Rtp::RtcpXr rtcp_xr) override {}
virtual void SetAssociatedPayloadTypes(
std::map<int, int> associated_payload_types) override {}
virtual void UpdateRtxSsrc(uint32_t ssrc) override {};
virtual ~MockVideoReceiveStream() {}
const RefPtr<MockCallWrapper> mCallWrapper;
webrtc::VideoReceiveStreamInterface::Stats mStats;
};
class MockCall : public webrtc::Call {
public:
explicit MockCall(RefPtr<MockCallWrapper> aCallWrapper)
: mCallWrapper(std::move(aCallWrapper)) {}
webrtc::AudioSendStream* CreateAudioSendStream(
const webrtc::AudioSendStream::Config& config) override {
MOZ_RELEASE_ASSERT(!mAudioSendConfig);
mAudioSendConfig = mozilla::Some(config);
return new MockAudioSendStream(mCallWrapper);
}
void DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) override {
mAudioSendConfig = mozilla::Nothing();
delete static_cast<MockAudioSendStream*>(send_stream);
}
webrtc::AudioReceiveStreamInterface* CreateAudioReceiveStream(
const webrtc::AudioReceiveStreamInterface::Config& config) override {
MOZ_RELEASE_ASSERT(!mAudioReceiveConfig);
mAudioReceiveConfig = mozilla::Some(config);
return new MockAudioReceiveStream(mCallWrapper);
}
void DestroyAudioReceiveStream(
webrtc::AudioReceiveStreamInterface* receive_stream) override {
mAudioReceiveConfig = mozilla::Nothing();
delete static_cast<MockAudioReceiveStream*>(receive_stream);
}
webrtc::VideoSendStream* CreateVideoSendStream(
webrtc::VideoSendStream::Config config,
webrtc::VideoEncoderConfig encoder_config) override {
MOZ_RELEASE_ASSERT(!mVideoSendConfig);
MOZ_RELEASE_ASSERT(!mVideoSendEncoderConfig);
mVideoSendConfig = mozilla::Some(std::move(config));
mVideoSendEncoderConfig = mozilla::Some(std::move(encoder_config));
return new MockVideoSendStream(mCallWrapper);
}
void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) override {
mVideoSendConfig = mozilla::Nothing();
mVideoSendEncoderConfig = mozilla::Nothing();
delete static_cast<MockVideoSendStream*>(send_stream);
}
webrtc::VideoReceiveStreamInterface* CreateVideoReceiveStream(
webrtc::VideoReceiveStreamInterface::Config configuration) override {
MOZ_RELEASE_ASSERT(!mVideoReceiveConfig);
mVideoReceiveConfig = mozilla::Some(std::move(configuration));
return new MockVideoReceiveStream(mCallWrapper);
}
void DestroyVideoReceiveStream(
webrtc::VideoReceiveStreamInterface* receive_stream) override {
mVideoReceiveConfig = mozilla::Nothing();
delete static_cast<MockVideoReceiveStream*>(receive_stream);
}
webrtc::FlexfecReceiveStream* CreateFlexfecReceiveStream(
const webrtc::FlexfecReceiveStream::Config config) override {
return nullptr;
}
void DestroyFlexfecReceiveStream(
webrtc::FlexfecReceiveStream* receive_stream) override {}
void AddAdaptationResource(
rtc::scoped_refptr<webrtc::Resource> resource) override {}
webrtc::PacketReceiver* Receiver() override { return nullptr; }
webrtc::RtpTransportControllerSendInterface* GetTransportControllerSend()
override {
return nullptr;
}
Stats GetStats() const override { return mStats; }
void SignalChannelNetworkState(webrtc::MediaType media,
webrtc::NetworkState state) override {}
void OnAudioTransportOverheadChanged(
int transport_overhead_per_packet) override {}
void OnLocalSsrcUpdated(webrtc::AudioReceiveStreamInterface& stream,
uint32_t local_ssrc) override {}
void OnLocalSsrcUpdated(webrtc::VideoReceiveStreamInterface& stream,
uint32_t local_ssrc) override {}
void OnLocalSsrcUpdated(webrtc::FlexfecReceiveStream& stream,
uint32_t local_ssrc) override {}
void OnUpdateSyncGroup(webrtc::AudioReceiveStreamInterface& stream,
absl::string_view sync_group) override {}
void OnSentPacket(const rtc::SentPacket& sent_packet) override {}
void SetClientBitratePreferences(
const webrtc::BitrateSettings& preferences) override {}
std::vector<webrtc::VideoStream> CreateEncoderStreams(int width, int height) {
return mVideoSendEncoderConfig->video_stream_factory->CreateEncoderStreams(
mUnusedConfig, width, height, *mVideoSendEncoderConfig);
}
virtual const webrtc::FieldTrialsView& trials() const override {
return mUnusedConfig;
}
virtual webrtc::TaskQueueBase* network_thread() const override {
return nullptr;
}
virtual webrtc::TaskQueueBase* worker_thread() const override {
return nullptr;
}
virtual ~MockCall() {};
const RefPtr<MockCallWrapper> mCallWrapper;
mozilla::Maybe<webrtc::AudioReceiveStreamInterface::Config>
mAudioReceiveConfig;
mozilla::Maybe<webrtc::AudioSendStream::Config> mAudioSendConfig;
mozilla::Maybe<webrtc::VideoReceiveStreamInterface::Config>
mVideoReceiveConfig;
mozilla::Maybe<webrtc::VideoSendStream::Config> mVideoSendConfig;
mozilla::Maybe<webrtc::VideoEncoderConfig> mVideoSendEncoderConfig;
webrtc::Call::Stats mStats;
webrtc::NoTrialsConfig mUnusedConfig;
};
class MockCallWrapper : public mozilla::WebrtcCallWrapper {
public:
MockCallWrapper(
RefPtr<mozilla::SharedWebrtcState> aSharedState,
mozilla::UniquePtr<webrtc::VideoBitrateAllocatorFactory>
aVideoBitrateAllocatorFactory,
mozilla::UniquePtr<webrtc::RtcEventLog> aEventLog,
mozilla::UniquePtr<webrtc::TaskQueueFactory> aTaskQueueFactory,
const mozilla::dom::RTCStatsTimestampMaker& aTimestampMaker,
mozilla::UniquePtr<mozilla::media::ShutdownBlockingTicket>
aShutdownTicket)
: mozilla::WebrtcCallWrapper(
std::move(aSharedState), std::move(aVideoBitrateAllocatorFactory),
std::move(aEventLog), std::move(aTaskQueueFactory), aTimestampMaker,
std::move(aShutdownTicket)) {}
static RefPtr<MockCallWrapper> Create() {
auto state = mozilla::MakeRefPtr<mozilla::SharedWebrtcState>(
mozilla::AbstractThread::GetCurrent(), webrtc::AudioState::Config(),
nullptr, nullptr);
auto wrapper = mozilla::MakeRefPtr<MockCallWrapper>(
state, nullptr, nullptr, nullptr,
mozilla::dom::RTCStatsTimestampMaker::Create(), nullptr);
wrapper->SetCall(mozilla::WrapUnique(new MockCall(wrapper)));
return wrapper;
}
MockCall* GetMockCall() { return static_cast<MockCall*>(Call()); }
};
} // namespace test
#endif