Wire up RTP keep-alive in ortc api.

webrtc/ortc/rtptransportadapter.h

 /*
  *  Copyright 2017 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.
  */
 
@@ skipping 36 matching lines @@
       PacketTransportInterface* rtcp,
       RtpTransportControllerAdapter* rtp_transport_controller);
 
   ~RtpTransportAdapter() override;
 
   // RtpTransportInterface implementation.
   PacketTransportInterface* GetRtpPacketTransport() const override;
   PacketTransportInterface* GetRtcpPacketTransport() const override;
   RTCError SetRtcpParameters(const RtcpParameters& parameters) override;
   RtcpParameters GetRtcpParameters() const override { return rtcp_parameters_; }
+  RTCError SetRtpTransportParameters(
+      const RtpTransportParameters& parameters) override;
+  RtpTransportParameters GetRtpTransportParameters() const override;
 
   // SRTP specific implementation.
   RTCError SetSrtpSendKey(const cricket::CryptoParams& params) override;
   RTCError SetSrtpReceiveKey(const cricket::CryptoParams& params) override;
 
   // Methods used internally by OrtcFactory.
   RtpTransportControllerAdapter* rtp_transport_controller() {
     return rtp_transport_controller_;
   }
   void TakeOwnershipOfRtpTransportController(
       std::unique_ptr<RtpTransportControllerInterface> controller);
 
   // Used by RtpTransportControllerAdapter to tell when it should stop
   // returning this transport from GetTransports().
   sigslot::signal1<RtpTransportAdapter*> SignalDestroyed;
 
   // Used by the RtpTransportControllerAdapter to tell if an rtp sender or
   // receiver can be created.
   bool is_srtp_transport() { return is_srtp_transport_; }
   // Used by the RtpTransportControllerAdapter to set keys for senders and
   // receivers.
   rtc::Optional<cricket::CryptoParams> send_key() { return send_key_; }
   rtc::Optional<cricket::CryptoParams> receive_key() { return receive_key_; }
 
  protected:
   RtpTransportAdapter* GetInternal() override { return this; }
 
  private:
   RtpTransportAdapter(const RtcpParameters& rtcp_parameters,

[Taylor Brandstetter, 2017/07/12 16:19:50]

Since the constructor (and factory methods) take RtcpParameters, I think they
should take the RtpTransportParameters as well for consistency. Maybe for the
keepalive options it doesn't matter, but it seems likely we could add things to
RtpTransportParameters in the future which we would want to have available at
construction time.

[sprang_webrtc, 2017/07/16 09:34:03]

Done.

                       PacketTransportInterface* rtp,
                       PacketTransportInterface* rtcp,
                       RtpTransportControllerAdapter* rtp_transport_controller,
                       bool is_srtp_transport);
 
   PacketTransportInterface* rtp_packet_transport_;
   PacketTransportInterface* rtcp_packet_transport_;
   RtpTransportControllerAdapter* rtp_transport_controller_;
   // Non-null if this class owns the transport controller.
   std::unique_ptr<RtpTransportControllerInterface>
       owned_rtp_transport_controller_;
   RtcpParameters rtcp_parameters_;
+  RtpTransportParameters rtp_transport_parameters_;
 
   // SRTP specific members.
   rtc::Optional<cricket::CryptoParams> send_key_;
   rtc::Optional<cricket::CryptoParams> receive_key_;
   bool is_srtp_transport_;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(RtpTransportAdapter);
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_ORTC_RTPTRANSPORTADAPTER_H_