Introduce RtpTransportInternal and SrtpTransport.

webrtc/pc/rtptransportinternal.h

Index: webrtc/pc/rtptransportinternal.h
diff --git a/webrtc/pc/rtptransportinternal.h b/webrtc/pc/rtptransportinternal.h
new file mode 100644
index 0000000000000000000000000000000000000000..b37950632a1eff89dbd52998f4f5ef4705582960
--- /dev/null
+++ b/webrtc/pc/rtptransportinternal.h
@@ -0,0 +1,65 @@
+/*
+ *  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_PC_RTPTRANSPORTINTERNAL_H_
+#define WEBRTC_PC_RTPTRANSPORTINTERNAL_H_
+
+#include "webrtc/api/ortc/rtptransportinterface.h"
+#include "webrtc/rtc_base/sigslot.h"
+
+namespace rtc {
+class CopyOnWriteBuffer;
+struct PacketOptions;
+struct PacketTime;
+}  // namespace rtc
+
+namespace webrtc {
+
+class RtpTransportInternal : public RtpTransportInterface,

[Taylor Brandstetter, 2017/07/18 22:17:53]

A brief comment summarizing this class would be nice; for example, "This
represents the internal interface beneath RtpTransportInterface; it's not
accessible to API consumers but is accessible to internal classes in order to
send/receive RTP/RTCP packets, belonging to a single RTP session."

[Zach Stein, 2017/07/18 23:26:31]

Done.

+                             public sigslot::has_slots<> {
+ public:
+  virtual void SetRtcpMuxEnabled(bool enable) = 0;
+
+  // TODO(zstein): Remove PacketTransport setters. Clients should pass these
+  // in to constructors instead and construct a new RtpTransportInternal instead
+  // of updating them.
+
+  virtual rtc::PacketTransportInternal* rtp_packet_transport() const = 0;
+  virtual void SetRtpPacketTransport(rtc::PacketTransportInternal* rtp) = 0;
+
+  virtual rtc::PacketTransportInternal* rtcp_packet_transport() const = 0;
+  virtual void SetRtcpPacketTransport(rtc::PacketTransportInternal* rtcp) = 0;
+
+  // Called whenever a transport's ready-to-send state changes. The argument
+  // is true if all used transports are ready to send. This is more specific
+  // than just "writable"; it means the last send didn't return ENOTCONN.
+  sigslot::signal1<bool> SignalReadyToSend;
+
+  // TODO(zstein): Consider having two signals - RtpPacketReceived and
+  // RtcpPacketReceived.
+  // The first argument is true for RTCP packets and false for RTP packets.
+  sigslot::signal3<bool, rtc::CopyOnWriteBuffer*, const rtc::PacketTime&>
+      SignalPacketReceived;
+
+  virtual bool IsWritable(bool rtcp) const = 0;
+
+  virtual bool SendPacket(bool rtcp,
+                          rtc::CopyOnWriteBuffer* packet,
+                          const rtc::PacketOptions& options,
+                          int flags) = 0;
+
+  virtual bool HandlesPayloadType(int payload_type) const = 0;
+
+  virtual void AddHandledPayloadType(int payload_type) = 0;
+};
+
+}  // namespace webrtc
+
+#endif  // WEBRTC_PC_RTPTRANSPORTINTERNAL_H_