Adding "adapter" ORTC objects on top of ChannelManager/BaseChannel/etc.

webrtc/api/rtptransportinterface.h

Index: webrtc/api/rtptransportinterface.h
diff --git a/webrtc/api/rtptransportinterface.h b/webrtc/api/rtptransportinterface.h
new file mode 100644
index 0000000000000000000000000000000000000000..939903bd87626ddb91b8a49cd2a4cf91781230ca
--- /dev/null
+++ b/webrtc/api/rtptransportinterface.h
@@ -0,0 +1,71 @@
+/*
+ *  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.
+ */
+
+#ifndef WEBRTC_API_RTPTRANSPORTINTERFACE_H_
+#define WEBRTC_API_RTPTRANSPORTINTERFACE_H_
+
+#include <string>
+
+#include "webrtc/api/packettransportinterface.h"
+#include "webrtc/api/rtcerror.h"
+#include "webrtc/base/optional.h"
+
+namespace webrtc {
+
+class RtpTransportShim;
+
+struct RtcpParameters {
+  // The SSRC to be used in the "SSRC of packet sender" field.
+  // If not set, one will be chosen by the implementation.
+  // TODO(deadbeef): Not implemented.
+  rtc::Optional<uint32_t> ssrc;
+
+  // RTCP CNAME; if empty, one will be chosen by the implementation.
+  std::string cname;
+
+  // Send reduced-size RTCP?
+  bool reduced_size = false;
+
+  // Send RTCP multiplexed on the RTP transport?
+  bool mux = true;
+};
+
+// Base class for different types of RTP transports that can be created by an
+// OrtcFactory. Used by RtpSender/RtpReceivers.
+class RtpTransportInterface {
+ public:
+  virtual ~RtpTransportInterface() {}
+
+  // Returns packet transport that's used to send RTP packets.
+  virtual PacketTransportInterface* GetRtpPacketTransport() const = 0;
+
+  // Returns separate packet transport that's used to send RTCP packets.
+  // If RTCP multiplexing is being used, returns nullptr.
+  virtual PacketTransportInterface* GetRtcpPacketTransport() const = 0;
+
+  // Set/get RTCP params. Changing "mux" from "true" to "false" is not allowed.
+  virtual RTCError SetRtcpParameters(const RtcpParameters& parameters) = 0;
+  virtual RtcpParameters GetRtcpParameters() const = 0;
+
+ protected:
+  // Only for internal use.
+  // Returns a pointer to the internal (non-public) interface.
+  virtual RtpTransportShim* GetInternal() = 0;

[pthatcher1, 2017/02/08 01:33:49]

Again, I'd like to understand this model better.

[Taylor Brandstetter, 2017/02/10 00:19:45]

Ok, so suppose the user of the API passes an "RtpTransportInterface" into
CreateRtpSender. There needs to be some way to downcast that
RtpTransportInterface pointer (which is a pointer to a proxy object) to the
internal interface. This approach - a protected "GetInternal" method - seemed
cleaner than having a mess of static casting and crossing fingers.

But I'm open to any other ideas. We haven't really had to deal with this problem
before, so it would be good to establish a pattern we like (even though it could
be easily changed later since it's not public).

P.S. When you say "Again," in a code review, I'm not sure what you're referring
to since comments end up in alphabetical order by files.

+
+  // Classes that can use this internal interface.
+  friend class OrtcFactory;
+  friend class RtpSenderShim;
+  friend class RtpReceiverShim;
+  friend class RtpTransportControllerShim;
+};
+
+}  // namespace webrtc
+
+#endif  // WEBRTC_API_RTPTRANSPORTINTERFACE_H_