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)
+  FakeVideoMediaChannel(FakeVideoEngine* engine, const VideoOptions& options)
       : engine_(engine), max_bps_(-1) {
     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(); }
@@ skipping 299 matching lines @@
   friend class FakeMediaEngine;
 };
 
 class FakeVideoEngine : public FakeBaseEngine {
  public:
   FakeVideoEngine() : capture_(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);
+    channels_.emplace_back(ch);
     return ch;
   }
+
   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;
   }
 
  private:
   std::vector<FakeVideoMediaChannel*> channels_;
   std::vector<VideoCodec> codecs_;
@@ skipping 97 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_