blob: b1cee6d738bc9ed8c78c9e54654f53c68c748b3d [file] [log] [blame]
/*
* Copyright 2018 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef PC_TEST_FAKEPEERCONNECTIONBASE_H_
#define PC_TEST_FAKEPEERCONNECTIONBASE_H_
#include <map>
#include <memory>
#include <set>
#include <string>
#include <vector>
#include "pc/peerconnectioninternal.h"
namespace webrtc {
// Customized PeerConnection fakes can be created by subclassing
// FakePeerConnectionBase then overriding the interesting methods. This class
// takes care of providing default implementations for all the pure virtual
// functions specified in the interfaces.
class FakePeerConnectionBase : public PeerConnectionInternal {
public:
// PeerConnectionInterface implementation.
rtc::scoped_refptr<StreamCollectionInterface> local_streams() override {
return nullptr;
}
rtc::scoped_refptr<StreamCollectionInterface> remote_streams() override {
return nullptr;
}
bool AddStream(MediaStreamInterface* stream) override { return false; }
void RemoveStream(MediaStreamInterface* stream) override {}
RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> AddTrack(
rtc::scoped_refptr<MediaStreamTrackInterface> track,
const std::vector<std::string>& stream_labels) override {
return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
}
rtc::scoped_refptr<RtpSenderInterface> AddTrack(
MediaStreamTrackInterface* track,
std::vector<MediaStreamInterface*> streams) override {
return nullptr;
}
bool RemoveTrack(RtpSenderInterface* sender) override { return false; }
RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
rtc::scoped_refptr<MediaStreamTrackInterface> track) override {
return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
}
RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
rtc::scoped_refptr<MediaStreamTrackInterface> track,
const RtpTransceiverInit& init) override {
return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
}
RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
cricket::MediaType media_type) override {
return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
}
RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
cricket::MediaType media_type,
const RtpTransceiverInit& init) override {
return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
}
rtc::scoped_refptr<DtmfSenderInterface> CreateDtmfSender(
AudioTrackInterface* track) override {
return nullptr;
}
rtc::scoped_refptr<RtpSenderInterface> CreateSender(
const std::string& kind,
const std::string& stream_id) override {
return nullptr;
}
std::vector<rtc::scoped_refptr<RtpSenderInterface>> GetSenders()
const override {
return {};
}
std::vector<rtc::scoped_refptr<RtpReceiverInterface>> GetReceivers()
const override {
return {};
}
std::vector<rtc::scoped_refptr<RtpTransceiverInterface>> GetTransceivers()
const override {
return {};
}
bool GetStats(StatsObserver* observer,
MediaStreamTrackInterface* track,
StatsOutputLevel level) override {
return false;
}
void GetStats(RTCStatsCollectorCallback* callback) override {}
void ClearStatsCache() override {}
rtc::scoped_refptr<DataChannelInterface> CreateDataChannel(
const std::string& label,
const DataChannelInit* config) override {
return nullptr;
}
const SessionDescriptionInterface* local_description() const override {
return nullptr;
}
const SessionDescriptionInterface* remote_description() const override {
return nullptr;
}
const SessionDescriptionInterface* current_local_description()
const override {
return nullptr;
}
const SessionDescriptionInterface* current_remote_description()
const override {
return nullptr;
}
const SessionDescriptionInterface* pending_local_description()
const override {
return nullptr;
}
const SessionDescriptionInterface* pending_remote_description()
const override {
return nullptr;
}
void CreateOffer(CreateSessionDescriptionObserver* observer,
const MediaConstraintsInterface* constraints) override {}
void CreateOffer(CreateSessionDescriptionObserver* observer,
const RTCOfferAnswerOptions& options) override {}
void CreateAnswer(CreateSessionDescriptionObserver* observer,
const RTCOfferAnswerOptions& options) override {}
void CreateAnswer(CreateSessionDescriptionObserver* observer,
const MediaConstraintsInterface* constraints) override {}
void SetLocalDescription(SetSessionDescriptionObserver* observer,
SessionDescriptionInterface* desc) override {}
void SetRemoteDescription(SetSessionDescriptionObserver* observer,
SessionDescriptionInterface* desc) override {}
void SetRemoteDescription(
std::unique_ptr<SessionDescriptionInterface> desc,
rtc::scoped_refptr<SetRemoteDescriptionObserverInterface> observer)
override {}
bool UpdateIce(const IceServers& configuration,
const MediaConstraintsInterface* constraints) override {
return false;
}
bool UpdateIce(const IceServers& configuration) override { return false; }
RTCConfiguration GetConfiguration() override { return RTCConfiguration(); }
bool SetConfiguration(const PeerConnectionInterface::RTCConfiguration& config,
RTCError* error) override {
return false;
}
bool SetConfiguration(
const PeerConnectionInterface::RTCConfiguration& config) override {
return false;
}
bool AddIceCandidate(const IceCandidateInterface* candidate) override {
return false;
}
bool RemoveIceCandidates(
const std::vector<cricket::Candidate>& candidates) override {
return false;
}
void RegisterUMAObserver(UMAObserver* observer) override {}
RTCError SetBitrate(const BitrateParameters& bitrate) override {
return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
}
void SetBitrateAllocationStrategy(
std::unique_ptr<rtc::BitrateAllocationStrategy>
bitrate_allocation_strategy) override {}
void SetAudioPlayout(bool playout) override {}
void SetAudioRecording(bool recording) override {}
SignalingState signaling_state() override { return SignalingState::kStable; }
IceConnectionState ice_connection_state() override {
return IceConnectionState::kIceConnectionNew;
}
IceGatheringState ice_gathering_state() override {
return IceGatheringState::kIceGatheringNew;
}
bool StartRtcEventLog(rtc::PlatformFile file,
int64_t max_size_bytes) override {
return false;
}
bool StartRtcEventLog(std::unique_ptr<RtcEventLogOutput> output,
int64_t output_period_ms) override {
return false;
}
void StopRtcEventLog() override {}
void Close() override {}
// PeerConnectionInternal implementation.
rtc::Thread* network_thread() const override { return nullptr; }
rtc::Thread* worker_thread() const override { return nullptr; }
rtc::Thread* signaling_thread() const override { return nullptr; }
std::string session_id() const override { return ""; }
bool initial_offerer() const override { return false; }
cricket::VoiceChannel* voice_channel() const override { return nullptr; }
cricket::VideoChannel* video_channel() const override { return nullptr; }
std::vector<
rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>
GetTransceiversInternal() const override {
return {};
}
bool GetLocalTrackIdBySsrc(uint32_t ssrc, std::string* track_id) override {
return false;
}
bool GetRemoteTrackIdBySsrc(uint32_t ssrc, std::string* track_id) override {
return false;
}
sigslot::signal1<DataChannel*>& SignalDataChannelCreated() override {
return SignalDataChannelCreated_;
}
cricket::RtpDataChannel* rtp_data_channel() const override { return nullptr; }
std::vector<rtc::scoped_refptr<DataChannel>> sctp_data_channels()
const override {
return {};
}
rtc::Optional<std::string> sctp_content_name() const override {
return rtc::nullopt;
}
rtc::Optional<std::string> sctp_transport_name() const override {
return rtc::nullopt;
}
std::map<std::string, std::string> GetTransportNamesByMid() const override {
return {};
}
std::map<std::string, cricket::TransportStats> GetTransportStatsByNames(
const std::set<std::string>& transport_names) override {
return {};
}
Call::Stats GetCallStats() override { return Call::Stats(); }
bool GetLocalCertificate(
const std::string& transport_name,
rtc::scoped_refptr<rtc::RTCCertificate>* certificate) override {
return false;
}
std::unique_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate(
const std::string& transport_name) override {
return nullptr;
}
bool IceRestartPending(const std::string& content_name) const override {
return false;
}
bool NeedsIceRestart(const std::string& content_name) const override {
return false;
}
bool GetSslRole(const std::string& content_name,
rtc::SSLRole* role) override {
return false;
}
protected:
sigslot::signal1<DataChannel*> SignalDataChannelCreated_;
};
} // namespace webrtc
#endif // PC_TEST_FAKEPEERCONNECTIONBASE_H_