Wire up RTP keep-alive in ortc api.

webrtc/ortc/rtptransportadapter.cc

 /*
  *  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.
  */
 
 #include "webrtc/ortc/rtptransportadapter.h"
 
 #include <algorithm>  // For std::find.
 #include <set>
 #include <sstream>
 #include <utility>  // For std::move.
 
 #include "webrtc/api/proxy.h"
 #include "webrtc/rtc_base/logging.h"
 
 namespace webrtc {
 
 BEGIN_OWNED_PROXY_MAP(RtpTransport)
 PROXY_SIGNALING_THREAD_DESTRUCTOR()
 PROXY_CONSTMETHOD0(PacketTransportInterface*, GetRtpPacketTransport)
 PROXY_CONSTMETHOD0(PacketTransportInterface*, GetRtcpPacketTransport)
 PROXY_METHOD1(RTCError, SetRtcpParameters, const RtcpParameters&)
 PROXY_CONSTMETHOD0(RtcpParameters, GetRtcpParameters)
+PROXY_METHOD1(RTCError,
+              SetRtpTransportParameters,
+              const RtpTransportParameters&)
+PROXY_CONSTMETHOD0(RtpTransportParameters, GetRtpTransportParameters)
 protected:
 RtpTransportAdapter* GetInternal() override {
   return internal();
 }
 END_PROXY_MAP()
 
 BEGIN_OWNED_PROXY_MAP(SrtpTransport)
 PROXY_SIGNALING_THREAD_DESTRUCTOR()
 PROXY_CONSTMETHOD0(PacketTransportInterface*, GetRtpPacketTransport)
 PROXY_CONSTMETHOD0(PacketTransportInterface*, GetRtcpPacketTransport)
 PROXY_METHOD1(RTCError, SetRtcpParameters, const RtcpParameters&)
 PROXY_CONSTMETHOD0(RtcpParameters, GetRtcpParameters)
+PROXY_METHOD1(RTCError,
+              SetRtpTransportParameters,
+              const RtpTransportParameters&)
+PROXY_CONSTMETHOD0(RtpTransportParameters, GetRtpTransportParameters)
 PROXY_METHOD1(RTCError, SetSrtpSendKey, const cricket::CryptoParams&)
 PROXY_METHOD1(RTCError, SetSrtpReceiveKey, const cricket::CryptoParams&)
 protected:
 RtpTransportAdapter* GetInternal() override {
   return internal();
 }
 END_PROXY_MAP()
 
 // static
 RTCErrorOr<std::unique_ptr<RtpTransportInterface>>
@@ skipping 120 matching lines @@
   if (!err.ok()) {
     return err;
   }
   rtcp_parameters_ = copy;
   if (rtcp_parameters_.mux) {
     rtcp_packet_transport_ = nullptr;
   }
   return RTCError::OK();
 }
 
+RTCError RtpTransportAdapter::SetRtpTransportParameters(
+    const RtpTransportParameters& parameters) {
+  RTCError err =
+      rtp_transport_controller_->SetRtpTransportParameters(parameters);

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

Ok, so setting RTP transport parameters on one RtpTransport will affect the
entire transport controller (in other words, the whole Call)? This limitation
should be called out in the applicable header file(s) in webrtc/api/ortc/.

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

That was the idea, since the keep-alive is about keeping the underlying
transport (ie udp socket) alive, rather than and individual rtp transport. Hope
I'm not confusing terminology here.
Right now, the implementation is handling the keep-alive on a stream-basis, but
ultimately it would probably be better to do it on a call basis, that's why I
moved the config to webrtc::Call::Config

Do you think it would make more sense to move it back?

[Taylor Brandstetter, 2017/07/17 23:13:11]

We may be confusing terminology.

Here's what the objects in this API represent, conceptually:

RtpTransport = RTP transport layer on top of one underlying 5-tuple (or ICE
component, if using ICE). Equates to a "media transport" as defined in RFC7656.

RtpTransportController = Controlling multiple RTP transports between the same
pair of "endpoints". Some things, like bandwidth estimation and A/V sync,
operate at this level. Most closely equates to a "multimedia session" as defined
in RFC7656, or a PeerConnection in the WebRTC 1.0 object model.

So "Call" is conceptually more like RtpTransportController. It encompasses
*multiple* underlying transports (when BUNDLE is not used).

There's unfortunately not an object that maps easily to "RtpTransport" at the
"Call" level. The closest thing is RtpStreamReceiverController, but that's only
for the receive side. So, I'd be fine with what you've done, as long as we call
out the limitation. Or you could move the config out of webrtc::Call::Config,
and leave it per-stream for now, until we have a nice "transport" abstraction to
use.

[ilnik, 2017/07/21 12:21:18]

Done.

+  if (!err.ok()) {
+    return err;
+  }
+  rtp_transport_parameters_ = parameters;
+  return RTCError::OK();
+}
+
+RtpTransportParameters RtpTransportAdapter::GetRtpTransportParameters() const {
+  return rtp_transport_parameters_;
+}
+
 RTCError RtpTransportAdapter::SetSrtpSendKey(
     const cricket::CryptoParams& params) {
   if (send_key_) {
     LOG_AND_RETURN_ERROR(
         webrtc::RTCErrorType::UNSUPPORTED_OPERATION,
         "Setting the SRTP send key twice is currently unsupported.");
   }
   if (receive_key_ && receive_key_->cipher_suite != params.cipher_suite) {
     LOG_AND_RETURN_ERROR(
         webrtc::RTCErrorType::UNSUPPORTED_OPERATION,
@@ skipping 13 matching lines @@
   if (send_key_ && send_key_->cipher_suite != params.cipher_suite) {
     LOG_AND_RETURN_ERROR(
         webrtc::RTCErrorType::UNSUPPORTED_OPERATION,
         "The send key and receive key must have the same cipher suite.");
   }
   receive_key_ = rtc::Optional<cricket::CryptoParams>(params);
   return RTCError::OK();
 }
 
 }  // namespace webrtc