tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

MockCall.h (13200B)

      1 /* This Source Code Form is subject to the terms of the Mozilla Public
      2 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
      3 * You can obtain one at http://mozilla.org/MPL/2.0/. */
      4 
      5 #ifndef MOCK_CALL_H_
      6 #define MOCK_CALL_H_
      7 
      8 #include "gmock/gmock.h"
      9 #include "mozilla/Assertions.h"
     10 #include "mozilla/Maybe.h"
     11 #include "mozilla/media/MediaUtils.h"
     12 #include "WebrtcCallWrapper.h"
     13 #include "WebrtcEnvironmentWrapper.h"
     14 #include "PeerConnectionCtx.h"
     15 
     16 // libwebrtc
     17 #include "api/call/audio_sink.h"
     18 #include "call/call.h"
     19 
     20 namespace test {
     21 class MockCallWrapper;
     22 
     23 class MockAudioSendStream : public webrtc::AudioSendStream {
     24 public:
     25  explicit MockAudioSendStream(RefPtr<MockCallWrapper> aCallWrapper)
     26      : mCallWrapper(std::move(aCallWrapper)) {}
     27 
     28  const webrtc::AudioSendStream::Config& GetConfig() const override;
     29 
     30  void Reconfigure(const Config& config,
     31                   webrtc::SetParametersCallback callback) override;
     32 
     33  void Start() override {}
     34 
     35  void Stop() override {}
     36 
     37  void SendAudioData(std::unique_ptr<webrtc::AudioFrame> audio_frame) override {
     38  }
     39 
     40  bool SendTelephoneEvent(int payload_type, int payload_frequency, int event,
     41                          int duration_ms) override {
     42    return true;
     43  }
     44 
     45  void SetMuted(bool muted) override {}
     46 
     47  Stats GetStats() const override { return mStats; }
     48 
     49  Stats GetStats(bool has_remote_tracks) const override { return mStats; }
     50 
     51  virtual ~MockAudioSendStream() {}
     52 
     53  const RefPtr<MockCallWrapper> mCallWrapper;
     54  webrtc::AudioSendStream::Stats mStats;
     55 };
     56 
     57 class MockAudioReceiveStream : public webrtc::AudioReceiveStreamInterface {
     58 public:
     59  explicit MockAudioReceiveStream(RefPtr<MockCallWrapper> aCallWrapper)
     60      : mCallWrapper(std::move(aCallWrapper)) {}
     61 
     62  void Start() override {}
     63 
     64  void Stop() override {}
     65 
     66  bool IsRunning() const override { return true; }
     67 
     68  Stats GetStats(bool get_and_clear_legacy_stats) const override {
     69    return mStats;
     70  }
     71 
     72  void SetSink(webrtc::AudioSinkInterface* sink) override {}
     73 
     74  void SetGain(float gain) override {}
     75 
     76  std::vector<webrtc::RtpSource> GetSources() const override {
     77    return mRtpSources;
     78  }
     79 
     80  webrtc::AudioMixer::Source* source() override { return nullptr; }
     81 
     82  void SetRtcpMode(webrtc::RtcpMode mode) override {}
     83 
     84  virtual void SetDepacketizerToDecoderFrameTransformer(
     85      webrtc::scoped_refptr<webrtc::FrameTransformerInterface>
     86          frame_transformer) override {
     87    MOZ_CRASH(
     88        "Unimplemented after webrtc.org e2561e17e2 removed the Reconfigure "
     89        "method.");
     90  }
     91  virtual void SetDecoderMap(
     92      std::map<int, webrtc::SdpAudioFormat> decoder_map) override;
     93  virtual void SetNackHistory(int history_ms) override {
     94    MOZ_CRASH(
     95        "Unimplemented after webrtc.org e2561e17e2 removed the Reconfigure "
     96        "method.");
     97  }
     98  virtual void SetNonSenderRttMeasurement(bool enabled) override {}
     99  void SetFrameDecryptor(webrtc::scoped_refptr<webrtc::FrameDecryptorInterface>
    100                             frame_decryptor) override {}
    101  bool SetBaseMinimumPlayoutDelayMs(int delay_ms) override { return false; }
    102  int GetBaseMinimumPlayoutDelayMs() const override { return 0; }
    103  uint32_t remote_ssrc() const override { return 0; }
    104 
    105  virtual ~MockAudioReceiveStream() {}
    106 
    107  const RefPtr<MockCallWrapper> mCallWrapper;
    108  webrtc::AudioReceiveStreamInterface::Stats mStats;
    109  std::vector<webrtc::RtpSource> mRtpSources;
    110 };
    111 
    112 class MockVideoSendStream : public webrtc::VideoSendStream {
    113 public:
    114  explicit MockVideoSendStream(RefPtr<MockCallWrapper> aCallWrapper)
    115      : mCallWrapper(std::move(aCallWrapper)) {}
    116 
    117  void Start() override {}
    118 
    119  void Stop() override {}
    120 
    121  bool started() override { return false; }
    122 
    123  void SetSource(
    124      webrtc::VideoSourceInterface<webrtc::VideoFrame>* source,
    125      const webrtc::DegradationPreference& degradation_preference) override;
    126 
    127  void ReconfigureVideoEncoder(webrtc::VideoEncoderConfig config) override;
    128 
    129  void ReconfigureVideoEncoder(webrtc::VideoEncoderConfig config,
    130                               webrtc::SetParametersCallback callback) override;
    131 
    132  Stats GetStats() override { return mStats; }
    133 
    134  void AddAdaptationResource(
    135      webrtc::scoped_refptr<webrtc::Resource> resource) override {}
    136 
    137  std::vector<webrtc::scoped_refptr<webrtc::Resource>> GetAdaptationResources()
    138      override {
    139    return std::vector<webrtc::scoped_refptr<webrtc::Resource>>();
    140  }
    141 
    142  void SetCsrcs(webrtc::ArrayView<const uint32_t> csrcs) override {}
    143  void GenerateKeyFrame(const std::vector<std::string>& rids) override {}
    144 
    145  virtual ~MockVideoSendStream() {}
    146 
    147  const RefPtr<MockCallWrapper> mCallWrapper;
    148  webrtc::VideoSendStream::Stats mStats;
    149 };
    150 
    151 class MockVideoReceiveStream : public webrtc::VideoReceiveStreamInterface {
    152 public:
    153  explicit MockVideoReceiveStream(RefPtr<MockCallWrapper> aCallWrapper)
    154      : mCallWrapper(std::move(aCallWrapper)) {}
    155 
    156  void Start() override {}
    157 
    158  void Stop() override {}
    159 
    160  Stats GetStats() const override { return mStats; }
    161 
    162  std::vector<webrtc::RtpSource> GetSources() const override {
    163    return std::vector<webrtc::RtpSource>();
    164  }
    165 
    166  bool SetBaseMinimumPlayoutDelayMs(int delay_ms) override { return false; }
    167 
    168  int GetBaseMinimumPlayoutDelayMs() const override { return 0; }
    169 
    170  void SetFrameDecryptor(webrtc::scoped_refptr<webrtc::FrameDecryptorInterface>
    171                             frame_decryptor) override {}
    172 
    173  void SetDepacketizerToDecoderFrameTransformer(
    174      webrtc::scoped_refptr<webrtc::FrameTransformerInterface>
    175          frame_transformer) override {}
    176 
    177  RecordingState SetAndGetRecordingState(RecordingState state,
    178                                         bool generate_key_frame) override {
    179    return {};
    180  }
    181 
    182  void GenerateKeyFrame() override {}
    183 
    184  void SetRtcpMode(webrtc::RtcpMode mode) override {}
    185 
    186  void SetFlexFecProtection(
    187      webrtc::RtpPacketSinkInterface* flexfec_sink) override {}
    188 
    189  void SetLossNotificationEnabled(bool enabled) override {}
    190 
    191  void SetNackHistory(webrtc::TimeDelta history) override {}
    192 
    193  void SetProtectionPayloadTypes(int red_payload_type,
    194                                 int ulpfec_payload_type) override {}
    195 
    196  void SetRtcpXr(Config::Rtp::RtcpXr rtcp_xr) override {}
    197 
    198  virtual void SetAssociatedPayloadTypes(
    199      std::map<int, int> associated_payload_types) override {}
    200 
    201  virtual void UpdateRtxSsrc(uint32_t ssrc) override {};
    202 
    203  virtual ~MockVideoReceiveStream() {}
    204 
    205  const RefPtr<MockCallWrapper> mCallWrapper;
    206  webrtc::VideoReceiveStreamInterface::Stats mStats;
    207 };
    208 
    209 class MockCall : public webrtc::Call {
    210 public:
    211  explicit MockCall(RefPtr<MockCallWrapper> aCallWrapper)
    212      : mCallWrapper(std::move(aCallWrapper)) {}
    213 
    214  webrtc::AudioSendStream* CreateAudioSendStream(
    215      const webrtc::AudioSendStream::Config& config) override {
    216    MOZ_RELEASE_ASSERT(!mAudioSendConfig);
    217    mAudioSendConfig = mozilla::Some(config);
    218    return new MockAudioSendStream(mCallWrapper);
    219  }
    220 
    221  void DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) override {
    222    mAudioSendConfig = mozilla::Nothing();
    223    delete static_cast<MockAudioSendStream*>(send_stream);
    224  }
    225 
    226  webrtc::AudioReceiveStreamInterface* CreateAudioReceiveStream(
    227      const webrtc::AudioReceiveStreamInterface::Config& config) override {
    228    MOZ_RELEASE_ASSERT(!mAudioReceiveConfig);
    229    mAudioReceiveConfig = mozilla::Some(config);
    230    return new MockAudioReceiveStream(mCallWrapper);
    231  }
    232  void DestroyAudioReceiveStream(
    233      webrtc::AudioReceiveStreamInterface* receive_stream) override {
    234    mAudioReceiveConfig = mozilla::Nothing();
    235    delete static_cast<MockAudioReceiveStream*>(receive_stream);
    236  }
    237 
    238  webrtc::VideoSendStream* CreateVideoSendStream(
    239      webrtc::VideoSendStream::Config config,
    240      webrtc::VideoEncoderConfig encoder_config) override {
    241    MOZ_RELEASE_ASSERT(!mVideoSendConfig);
    242    MOZ_RELEASE_ASSERT(!mVideoSendEncoderConfig);
    243    mVideoSendConfig = mozilla::Some(std::move(config));
    244    mVideoSendEncoderConfig = mozilla::Some(std::move(encoder_config));
    245    return new MockVideoSendStream(mCallWrapper);
    246  }
    247 
    248  void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) override {
    249    mVideoSendConfig = mozilla::Nothing();
    250    mVideoSendEncoderConfig = mozilla::Nothing();
    251    delete static_cast<MockVideoSendStream*>(send_stream);
    252  }
    253 
    254  webrtc::VideoReceiveStreamInterface* CreateVideoReceiveStream(
    255      webrtc::VideoReceiveStreamInterface::Config configuration) override {
    256    MOZ_RELEASE_ASSERT(!mVideoReceiveConfig);
    257    mVideoReceiveConfig = mozilla::Some(std::move(configuration));
    258    return new MockVideoReceiveStream(mCallWrapper);
    259  }
    260 
    261  void DestroyVideoReceiveStream(
    262      webrtc::VideoReceiveStreamInterface* receive_stream) override {
    263    mVideoReceiveConfig = mozilla::Nothing();
    264    delete static_cast<MockVideoReceiveStream*>(receive_stream);
    265  }
    266 
    267  webrtc::FlexfecReceiveStream* CreateFlexfecReceiveStream(
    268      const webrtc::FlexfecReceiveStream::Config config) override {
    269    return nullptr;
    270  }
    271 
    272  void DestroyFlexfecReceiveStream(
    273      webrtc::FlexfecReceiveStream* receive_stream) override {}
    274 
    275  void AddAdaptationResource(
    276      webrtc::scoped_refptr<webrtc::Resource> resource) override {}
    277 
    278  webrtc::PacketReceiver* Receiver() override { return nullptr; }
    279 
    280  webrtc::RtpTransportControllerSendInterface* GetTransportControllerSend()
    281      override {
    282    return nullptr;
    283  }
    284 
    285  Stats GetStats() const override { return mStats; }
    286 
    287  void SignalChannelNetworkState(webrtc::MediaType media,
    288                                 webrtc::NetworkState state) override {}
    289 
    290  void OnAudioTransportOverheadChanged(
    291      int transport_overhead_per_packet) override {}
    292 
    293  void OnLocalSsrcUpdated(webrtc::AudioReceiveStreamInterface& stream,
    294                          uint32_t local_ssrc) override {}
    295  void OnLocalSsrcUpdated(webrtc::VideoReceiveStreamInterface& stream,
    296                          uint32_t local_ssrc) override {}
    297  void OnLocalSsrcUpdated(webrtc::FlexfecReceiveStream& stream,
    298                          uint32_t local_ssrc) override {}
    299 
    300  void OnUpdateSyncGroup(webrtc::AudioReceiveStreamInterface& stream,
    301                         absl::string_view sync_group) override {}
    302 
    303  void OnSentPacket(const webrtc::SentPacketInfo& sent_packet) override {}
    304 
    305  void SetClientBitratePreferences(
    306      const webrtc::BitrateSettings& preferences) override {}
    307 
    308  void SetEncoderInfo(const webrtc::VideoEncoder::EncoderInfo& aInfo) {
    309    mEncoderInfo = aInfo;
    310  }
    311 
    312  void SetPreferredRtcpCcAckType(
    313      webrtc::RtcpFeedbackType preferred_rtcp_cc_ack_type) override {}
    314  std::optional<int> FeedbackAccordingToRfc8888Count() override { return 0; }
    315  std::optional<int> FeedbackAccordingToTransportCcCount() override {
    316    return 0;
    317  }
    318 
    319  std::vector<webrtc::VideoStream> CreateEncoderStreams(int width, int height) {
    320    mVideoSendEncoderConfig->video_stream_factory->SetEncoderInfo(mEncoderInfo);
    321    return mVideoSendEncoderConfig->video_stream_factory->CreateEncoderStreams(
    322        mUnusedConfig, width, height, *mVideoSendEncoderConfig);
    323  }
    324 
    325  virtual webrtc::TaskQueueBase* network_thread() const override {
    326    return nullptr;
    327  }
    328 
    329  virtual webrtc::TaskQueueBase* worker_thread() const override {
    330    return nullptr;
    331  }
    332 
    333  virtual ~MockCall() {};
    334 
    335  const RefPtr<MockCallWrapper> mCallWrapper;
    336  mozilla::Maybe<webrtc::AudioReceiveStreamInterface::Config>
    337      mAudioReceiveConfig;
    338  mozilla::Maybe<webrtc::AudioSendStream::Config> mAudioSendConfig;
    339  mozilla::Maybe<webrtc::VideoReceiveStreamInterface::Config>
    340      mVideoReceiveConfig;
    341  mozilla::Maybe<webrtc::VideoSendStream::Config> mVideoSendConfig;
    342  mozilla::Maybe<webrtc::VideoEncoderConfig> mVideoSendEncoderConfig;
    343  webrtc::Call::Stats mStats;
    344  webrtc::MozTrialsConfig mUnusedConfig;
    345  webrtc::VideoEncoder::EncoderInfo mEncoderInfo;
    346  webrtc::DegradationPreference mConfiguredDegradationPreference;
    347 };
    348 
    349 class MockCallWrapper : public mozilla::WebrtcCallWrapper {
    350 public:
    351  MockCallWrapper(
    352      RefPtr<mozilla::SharedWebrtcState> aSharedState,
    353      mozilla::UniquePtr<webrtc::VideoBitrateAllocatorFactory>
    354          aVideoBitrateAllocatorFactory,
    355      mozilla::UniquePtr<webrtc::RtcEventLog> aEventLog,
    356      mozilla::UniquePtr<webrtc::TaskQueueFactory> aTaskQueueFactory,
    357      const mozilla::dom::RTCStatsTimestampMaker& aTimestampMaker,
    358      mozilla::UniquePtr<mozilla::media::ShutdownBlockingTicket>
    359          aShutdownTicket)
    360      : mozilla::WebrtcCallWrapper(
    361            std::move(aSharedState), std::move(aVideoBitrateAllocatorFactory),
    362            mozilla::WebrtcEnvironmentWrapper::Create(aTimestampMaker),
    363            aTimestampMaker, std::move(aShutdownTicket)) {}
    364 
    365  static RefPtr<MockCallWrapper> Create() {
    366    auto state = mozilla::MakeRefPtr<mozilla::SharedWebrtcState>(
    367        mozilla::AbstractThread::GetCurrent(), webrtc::AudioState::Config(),
    368        nullptr, nullptr);
    369    auto wrapper = mozilla::MakeRefPtr<MockCallWrapper>(
    370        state, nullptr, nullptr, nullptr,
    371        mozilla::dom::RTCStatsTimestampMaker::Create(), nullptr);
    372    wrapper->SetCall(mozilla::WrapUnique(new MockCall(wrapper)));
    373    return wrapper;
    374  }
    375 
    376  MockCall* GetMockCall() { return static_cast<MockCall*>(Call()); }
    377 };
    378 
    379 }  // namespace test
    380 #endif