Wire up RTP keep-alive in ortc api.

webrtc/media/base/fakemediaengine.h

 /*
  *  Copyright (c) 2004 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 WEBRTC_MEDIA_BASE_FAKEMEDIAENGINE_H_
 #define WEBRTC_MEDIA_BASE_FAKEMEDIAENGINE_H_
 
 #include <list>
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "webrtc/api/call/audio_sink.h"
 #include "webrtc/media/base/audiosource.h"
 #include "webrtc/media/base/mediaengine.h"
 #include "webrtc/media/base/rtputils.h"
 #include "webrtc/media/base/streamparams.h"
+#include "webrtc/media/engine/webrtcvideoengine.h"
 #include "webrtc/modules/audio_processing/include/audio_processing.h"
 #include "webrtc/p2p/base/sessiondescription.h"
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/rtc_base/copyonwritebuffer.h"
 #include "webrtc/rtc_base/networkroute.h"
+#include "webrtc/rtc_base/ptr_util.h"
 #include "webrtc/rtc_base/stringutils.h"
 
 using webrtc::RtpExtension;
 
 namespace cricket {
 
 class FakeMediaEngine;
 class FakeVideoEngine;
 class FakeVoiceEngine;
 
 // A common helper class that handles sending and receiving RTP/RTCP packets.
 template <class Base> class RtpHelper : public Base {
  public:
   RtpHelper()
       : sending_(false),
         playout_(false),
         fail_set_send_codecs_(false),
         fail_set_recv_codecs_(false),
         send_ssrc_(0),
-        ready_to_send_(false) {}
+        ready_to_send_(false),
+        transport_overhead_per_packet_(0),
+        num_network_route_changes_(0) {}
+  virtual ~RtpHelper() = default;
   const std::vector<RtpExtension>& recv_extensions() {
     return recv_extensions_;
   }
   const std::vector<RtpExtension>& send_extensions() {
     return send_extensions_;
   }
   bool sending() const { return sending_; }
   bool playout() const { return playout_; }
   const std::list<std::string>& rtp_packets() const { return rtp_packets_; }
   const std::list<std::string>& rtcp_packets() const { return rtcp_packets_; }
@@ skipping 231 matching lines @@
   std::set<uint32_t> muted_streams_;
   std::map<uint32_t, webrtc::RtpParameters> rtp_send_parameters_;
   std::map<uint32_t, webrtc::RtpParameters> rtp_receive_parameters_;
   bool fail_set_send_codecs_;
   bool fail_set_recv_codecs_;
   uint32_t send_ssrc_;
   std::string rtcp_cname_;
   bool ready_to_send_;
   int transport_overhead_per_packet_;
   rtc::NetworkRoute last_network_route_;
-  int num_network_route_changes_ = 0;
+  int num_network_route_changes_;
 };
 
 class FakeVoiceMediaChannel : public RtpHelper<VoiceMediaChannel> {
  public:
   struct DtmfInfo {
     DtmfInfo(uint32_t ssrc, int event_code, int duration)
         : ssrc(ssrc),
           event_code(event_code),
           duration(duration) {}
     uint32_t ssrc;
@@ skipping 197 matching lines @@
 inline bool CompareDtmfInfo(const FakeVoiceMediaChannel::DtmfInfo& info,
                             uint32_t ssrc,
                             int event_code,
                             int duration) {
   return (info.duration == duration && info.event_code == event_code &&
           info.ssrc == ssrc);
 }
 
 class FakeVideoMediaChannel : public RtpHelper<VideoMediaChannel> {
  public:
-  explicit FakeVideoMediaChannel(FakeVideoEngine* engine,
-                                 const VideoOptions& options)
-      : engine_(engine), max_bps_(-1) {
+  FakeVideoMediaChannel(FakeVideoEngine* engine, const VideoOptions& options)
+      : FakeVideoMediaChannel(engine,
+                              options,
+                              std::unique_ptr<WebRtcVideoChannel>()) {}
+  FakeVideoMediaChannel(FakeVideoEngine* engine,
+                        const VideoOptions& options,
+                        std::unique_ptr<WebRtcVideoChannel> real_channel)
+      : engine_(engine), max_bps_(-1), real_channel_(std::move(real_channel)) {
     SetOptions(options);
   }
 
   ~FakeVideoMediaChannel();
 
   const std::vector<VideoCodec>& recv_codecs() const { return recv_codecs_; }
   const std::vector<VideoCodec>& send_codecs() const { return send_codecs_; }
   const std::vector<VideoCodec>& codecs() const { return send_codecs(); }
   bool rendering() const { return playout(); }
   const VideoOptions& options() const { return options_; }
   const std::map<uint32_t, rtc::VideoSinkInterface<webrtc::VideoFrame>*>&
   sinks() const {
     return sinks_;
   }
   int max_bps() const { return max_bps_; }
   bool SetSendParameters(const VideoSendParameters& params) override {
+    if (real_channel_)
+      real_channel_->SetSendParameters(params);
     set_send_rtcp_parameters(params.rtcp);
     return (SetSendCodecs(params.codecs) &&
             SetSendRtpHeaderExtensions(params.extensions) &&
             SetMaxSendBandwidth(params.max_bandwidth_bps));
   }
   bool SetRecvParameters(const VideoRecvParameters& params) override {
     set_recv_rtcp_parameters(params.rtcp);
     return (SetRecvCodecs(params.codecs) &&
             SetRecvRtpHeaderExtensions(params.extensions));
   }
   bool AddSendStream(const StreamParams& sp) override {
+    if (real_channel_)
+      real_channel_->AddSendStream(sp);
     return RtpHelper<VideoMediaChannel>::AddSendStream(sp);
   }
   bool RemoveSendStream(uint32_t ssrc) override {
+    if (real_channel_)
+      real_channel_->RemoveSendStream(ssrc);
     return RtpHelper<VideoMediaChannel>::RemoveSendStream(ssrc);
   }
 
   bool GetSendCodec(VideoCodec* send_codec) override {
     if (send_codecs_.empty()) {
       return false;
     }
     *send_codec = send_codecs_[0];
     return true;
   }
   bool SetSink(uint32_t ssrc,
                rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override {
     if (ssrc != 0 && sinks_.find(ssrc) == sinks_.end()) {
       return false;
     }
     if (ssrc != 0) {
       sinks_[ssrc] = sink;
     }
     return true;
   }
   bool HasSink(uint32_t ssrc) const {
     return sinks_.find(ssrc) != sinks_.end() && sinks_.at(ssrc) != nullptr;
   }
 
-  bool SetSend(bool send) override { return set_sending(send); }
+  bool SetSend(bool send) override {
+    if (real_channel_)
+      real_channel_->SetSend(send);
+    return set_sending(send);
+  }
+
   bool SetVideoSend(
       uint32_t ssrc,
       bool enable,
       const VideoOptions* options,
       rtc::VideoSourceInterface<webrtc::VideoFrame>* source) override {
+    if (real_channel_)
+      real_channel_->SetVideoSend(ssrc, enable, options, source);
+
     if (!RtpHelper<VideoMediaChannel>::MuteStream(ssrc, !enable)) {
       return false;
     }
     if (enable && options) {
       if (!SetOptions(*options)) {
         return false;
       }
     }
     sources_[ssrc] = source;
     return true;
@@ skipping 46 matching lines @@
     return true;
   }
 
   FakeVideoEngine* engine_;
   std::vector<VideoCodec> recv_codecs_;
   std::vector<VideoCodec> send_codecs_;
   std::map<uint32_t, rtc::VideoSinkInterface<webrtc::VideoFrame>*> sinks_;
   std::map<uint32_t, rtc::VideoSourceInterface<webrtc::VideoFrame>*> sources_;
   VideoOptions options_;
   int max_bps_;
+  std::unique_ptr<WebRtcVideoChannel> real_channel_;
 };
 
 // Dummy option class, needed for the DataTraits abstraction in
 // channel_unittest.c.
 class DataOptions {};
 
 class FakeDataMediaChannel : public RtpHelper<DataMediaChannel> {
  public:
   explicit FakeDataMediaChannel(void* unused, const DataOptions& options)
       : send_blocked_(false), max_bps_(-1) {}
@@ skipping 167 matching lines @@
 
  private:
   std::vector<FakeVoiceMediaChannel*> channels_;
   std::vector<AudioCodec> codecs_;
 
   friend class FakeMediaEngine;
 };
 
 class FakeVideoEngine : public FakeBaseEngine {
  public:
-  FakeVideoEngine() : capture_(false) {
+  FakeVideoEngine() : capture_(false), create_real_channels_(false) {
     // Add a fake video codec. Note that the name must not be "" as there are
     // sanity checks against that.
     codecs_.push_back(VideoCodec(0, "fake_video_codec"));
   }
+
   void Init() {}
+
   bool SetOptions(const VideoOptions& options) {
     options_ = options;
     options_changed_ = true;
     return true;
   }
 
   VideoMediaChannel* CreateChannel(webrtc::Call* call,
                                    const MediaConfig& config,
                                    const VideoOptions& options) {
     if (fail_create_channel_) {
-      return NULL;
+      return nullptr;
     }
 
-    FakeVideoMediaChannel* ch = new FakeVideoMediaChannel(this, options);
-    channels_.push_back(ch);
-    return ch;
+    channels_.emplace_back(new FakeVideoMediaChannel(
+        this, options,
+        std::unique_ptr<WebRtcVideoChannel>(
+            create_real_channels_ ? new WebRtcVideoChannel(
+                                        call, config, options, nullptr, nullptr)
+                                  : nullptr)));
+    return channels_.back();
   }
+
   FakeVideoMediaChannel* GetChannel(size_t index) {
-    return (channels_.size() > index) ? channels_[index] : NULL;
+    return (channels_.size() > index) ? channels_[index] : nullptr;
   }
+
   void UnregisterChannel(VideoMediaChannel* channel) {
-    channels_.erase(std::find(channels_.begin(), channels_.end(), channel));
+    auto it = std::find(channels_.begin(), channels_.end(), channel);
+    RTC_DCHECK(it != channels_.end());
+    channels_.erase(it);
   }
 
   const std::vector<VideoCodec>& codecs() const { return codecs_; }
+
   void SetCodecs(const std::vector<VideoCodec> codecs) { codecs_ = codecs; }
 
   bool SetCapture(bool capture) {
     capture_ = capture;
     return true;
   }
 
+  void SetCreateRealChannel(bool do_create) {
+    create_real_channels_ = do_create;
+  }
+
  private:
   std::vector<FakeVideoMediaChannel*> channels_;
   std::vector<VideoCodec> codecs_;
   bool capture_;
   VideoOptions options_;
+  bool create_real_channels_;
 
   friend class FakeMediaEngine;
 };
 
 class FakeMediaEngine :
     public CompositeMediaEngine<FakeVoiceEngine, FakeVideoEngine> {
  public:
   FakeMediaEngine()
       : CompositeMediaEngine<FakeVoiceEngine, FakeVideoEngine>(nullptr,
                                                                nullptr,
@@ skipping 38 matching lines @@
   bool options_changed() const {
     return video_.options_changed_;
   }
   void clear_options_changed() {
     video_.options_changed_ = false;
   }
   void set_fail_create_channel(bool fail) {
     voice_.set_fail_create_channel(fail);
     video_.set_fail_create_channel(fail);
   }
+
+  FakeVideoEngine* GetVideoEngine() { return &video_; }
 };
 
 // Have to come afterwards due to declaration order
 inline FakeVoiceMediaChannel::~FakeVoiceMediaChannel() {
   if (engine_) {
     engine_->UnregisterChannel(this);
   }
 }
 
 inline FakeVideoMediaChannel::~FakeVideoMediaChannel() {
@@ skipping 27 matching lines @@
   virtual const std::vector<DataCodec>& data_codecs() { return data_codecs_; }
 
  private:
   std::vector<FakeDataMediaChannel*> channels_;
   std::vector<DataCodec> data_codecs_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_MEDIA_BASE_FAKEMEDIAENGINE_H_