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

webrtc/ortc/rtptransportcontrolleradapter.h

Index: webrtc/ortc/rtptransportcontrolleradapter.h
diff --git a/webrtc/ortc/rtptransportcontrolleradapter.h b/webrtc/ortc/rtptransportcontrolleradapter.h
new file mode 100644
index 0000000000000000000000000000000000000000..7d4058d1986389782d452cc53b232f7b4fc54e39
--- /dev/null
+++ b/webrtc/ortc/rtptransportcontrolleradapter.h
@@ -0,0 +1,203 @@
+/*
+ *  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_ORTC_RTPTRANSPORTCONTROLLERADAPTER_H_
+#define WEBRTC_ORTC_RTPTRANSPORTCONTROLLERADAPTER_H_
+
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "webrtc/base/constructormagic.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/call/call.h"
+#include "webrtc/logging/rtc_event_log/rtc_event_log.h"
+#include "webrtc/api/ortc/ortcrtpreceiverinterface.h"
+#include "webrtc/api/ortc/ortcrtpsenderinterface.h"
+#include "webrtc/api/ortc/rtptransportcontrollerinterface.h"
+#include "webrtc/pc/channelmanager.h"
+#include "webrtc/pc/mediacontroller.h"
+#include "webrtc/media/base/mediachannel.h"  // For MediaConfig.
+
+namespace webrtc {
+
+class RtpTransportAdapter;
+class OrtcRtpSenderAdapter;
+class OrtcRtpReceiverAdapter;
+
+// Implementation of RtpTransportControllerInterface. Wraps a MediaController,
+// a VoiceChannel and VideoChannel, and maintains a list of dependent RTP
+// transports.
+//
+// When used along with an RtpSenderAdapter or RtpReceiverAdapter, the
+// sender/receiver passes its parameters along to this class, which turns them
+// into cricket:: media descriptions (the interface used by BaseChannel).
+//
+// Due to the fact that BaseChannel has different subclasses for audio/video,
+// the actual BaseChannel object is not created until an RtpSender/RtpReceiver
+// needs them.
+//
+// All methods should be called on the signaling thread.
+//
+// TODO(deadbeef): When BaseChannel is split apart into separate
+// "RtpSender"/"RtpTransceiver"/"RtpSender"/"RtpReceiver" objects, this adapter
+// object can be replaced by a "real" one.
+class RtpTransportControllerAdapter : public RtpTransportControllerInterface,
+                                      public sigslot::has_slots<> {
+ public:
+  // Creates a proxy that will call "public interface" methods on the correct
+  // thread.
+  //
+  // Doesn't take ownership of any objects passed in.
+  //
+  // |channel_manager| must not be null.
+  static std::unique_ptr<RtpTransportControllerInterface> CreateProxied(
+      const cricket::MediaConfig& config,
+      cricket::ChannelManager* channel_manager,
+      webrtc::RtcEventLog* event_log,
+      rtc::Thread* signaling_thread,
+      rtc::Thread* worker_thread);
+
+  ~RtpTransportControllerAdapter() override;
+
+  // RtpTransportControllerInterface implementation.
+  std::vector<RtpTransportInterface*> GetTransports() const override;
+
+  // Used by OrtcFactory to create RtpSenders/RtpReceivers using this
+  // controller. Called "CreateProxied" because these methods return proxies
+  // that will safely call methods on the correct thread.
+  RTCErrorOr<std::unique_ptr<OrtcRtpSenderInterface>> CreateProxiedRtpSender(
+      cricket::MediaType kind,
+      RtpTransportInterface* transport_proxy);
+  RTCErrorOr<std::unique_ptr<OrtcRtpReceiverInterface>>
+  CreateProxiedRtpReceiver(cricket::MediaType kind,
+                           RtpTransportInterface* transport_proxy);
+
+  // Methods used internally by RtpTransportAdapter.
+  MediaControllerInterface* media_controller() const {
+    return media_controller_.get();
+  }
+
+  rtc::Thread* signaling_thread() const { return signaling_thread_; }
+  rtc::Thread* worker_thread() const { return worker_thread_; }
+
+  // Doesn't take ownership.
+  //
+  // NOTE: "AddTransport" takes a proxy class, such that "GetTransports()" can
+  // return proxies, but the other methods take a pointer to the inner object,
+  // since these methods are called by the inner object which is unaware of the
+  // proxy.
+  void AddTransport(RtpTransportInterface* transport_proxy);
+  void RemoveTransport(RtpTransportAdapter* inner_transport);
+  RTCError SetRtcpParameters(const RtcpParameters& parameters,
+                             RtpTransportInterface* inner_transport);
+
+  cricket::VoiceChannel* voice_channel() { return voice_channel_; }
+  cricket::VideoChannel* video_channel() { return video_channel_; }
+
+  // |primary_ssrc| out parameter is filled with either
+  // |parameters.encodings[0].ssrc|, or a generated SSRC if that's left unset.
+  RTCError ValidateAndApplyAudioSenderParameters(
+      const RtpParameters& parameters,
+      uint32_t* primary_ssrc);
+  RTCError ValidateAndApplyVideoSenderParameters(
+      const RtpParameters& parameters,
+      uint32_t* primary_ssrc);
+  RTCError ValidateAndApplyAudioReceiverParameters(
+      const RtpParameters& parameters);
+  RTCError ValidateAndApplyVideoReceiverParameters(
+      const RtpParameters& parameters);
+
+ protected:
+  RtpTransportControllerAdapter* GetInternal() override { return this; }
+
+ private:
+  // Only expected to be called by RtpTransportControllerAdapter::CreateProxied.
+  RtpTransportControllerAdapter(const cricket::MediaConfig& config,
+                                cricket::ChannelManager* channel_manager,
+                                webrtc::RtcEventLog* event_log,
+                                rtc::Thread* signaling_thread,
+                                rtc::Thread* worker_thread);
+
+  // These return an error if another of the same type of object is already
+  // attached, or if |transport_proxy| can't be used with the sender/receiver
+  // due to the limitation that the sender/receiver of the same media type must
+  // use the same transport.
+  RTCError AttachAudioSender(OrtcRtpSenderAdapter* sender,
+                             RtpTransportInterface* inner_transport);
+  RTCError AttachVideoSender(OrtcRtpSenderAdapter* sender,
+                             RtpTransportInterface* inner_transport);
+  RTCError AttachAudioReceiver(OrtcRtpReceiverAdapter* receiver,
+                               RtpTransportInterface* inner_transport);
+  RTCError AttachVideoReceiver(OrtcRtpReceiverAdapter* receiver,
+                               RtpTransportInterface* inner_transport);
+
+  void OnAudioSenderDestroyed();
+  void OnVideoSenderDestroyed();
+  void OnAudioReceiverDestroyed();
+  void OnVideoReceiverDestroyed();
+
+  void CreateVoiceChannel();
+  void CreateVideoChannel();
+  void DestroyVoiceChannel();
+  void DestroyVideoChannel();
+
+  void CopyRtcpParametersToDescriptions(
+      const RtcpParameters& params,
+      cricket::MediaContentDescription* local,
+      cricket::MediaContentDescription* remote);
+
+  // Helper function to generate an SSRC that doesn't match one in any of the
+  // "content description" structs, or in |new_ssrcs| (which is needed since
+  // multiple SSRCs may be gneerated in one go).
+  uint32_t GenerateUnusedSsrc(std::set<uint32_t>* new_ssrcs) const;
+
+  // |description| is the matching description where existing SSRCs can be
+  // found.
+  //
+  // This is a member function because it may need to generate SSRCs that don't
+  // match existing ones, which is more than ToStreamParamsVec does.
+  RTCErrorOr<cricket::StreamParamsVec> MakeSendStreamParamsVec(
+      std::vector<RtpEncodingParameters> encodings,
+      const std::string& cname,
+      const cricket::MediaContentDescription& description) const;
+
+  rtc::Thread* signaling_thread_;
+  rtc::Thread* worker_thread_;
+  // |transport_proxies_| and |inner_audio_transport_|/|inner_audio_transport_|
+  // are somewhat redundant, but the latter are only set when
+  // RtpSenders/RtpReceivers are attached to the transport.
+  std::vector<RtpTransportInterface*> transport_proxies_;
+  RtpTransportInterface* inner_audio_transport_ = nullptr;
+  RtpTransportInterface* inner_video_transport_ = nullptr;
+  std::unique_ptr<MediaControllerInterface> media_controller_;
+
+  // BaseChannel takes content descriptions as input, so we store them here
+  // such that they can be updated when a new RtpSenderAdapter/
+  // RtpReceiverAdapter attaches itself.
+  cricket::AudioContentDescription local_audio_description_;
+  cricket::AudioContentDescription remote_audio_description_;
+  cricket::VideoContentDescription local_video_description_;
+  cricket::VideoContentDescription remote_video_description_;
+  cricket::VoiceChannel* voice_channel_ = nullptr;
+  cricket::VideoChannel* video_channel_ = nullptr;
+  bool have_audio_sender_ = false;
+  bool have_video_sender_ = false;
+  bool have_audio_receiver_ = false;
+  bool have_video_receiver_ = false;
+
+  RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(RtpTransportControllerAdapter);
+};
+
+}  // namespace webrtc
+
+#endif  // WEBRTC_ORTC_RTPTRANSPORTCONTROLLERADAPTER_H_