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

webrtc/pc/ortcfactory.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.
  */
 
 #ifndef WEBRTC_PC_ORTCFACTORY_H_
 #define WEBRTC_PC_ORTCFACTORY_H_
 
 #include <memory>
 
 #include "webrtc/api/ortcfactoryinterface.h"
 #include "webrtc/base/constructormagic.h"
+#include "webrtc/base/scoped_ref_ptr.h"
+#include "webrtc/media/engine/webrtcmediaengine.h"
+#include "webrtc/pc/channelmanager.h"
 
 namespace webrtc {
 
 // Implementation of OrtcFactoryInterface.
 //
 // See ortcfactoryinterface.h for documentation.
 class OrtcFactory : public OrtcFactoryInterface {
  public:
+  ~OrtcFactory() override;
+
+  RTCErrorOr<std::unique_ptr<RtpTransportControllerInterface>>
+  CreateRtpTransportController() override;
+
+  RTCErrorOr<std::unique_ptr<RtpTransportInterface>> CreateRtpTransport(
+      const RtcpParameters& rtcp_parameters,
+      PacketTransportInterface* rtp,
+      PacketTransportInterface* rtcp,
+      RtpTransportControllerInterface* transport_controller) override;

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

I think we should consider making the common case the easy one:
CreateRtpTransport without an RtpTransportController passed in creates on and
then it's owned by the RtpTransport.  Basically, when bundled.  Then you only
have to create an RtpTransportController if you don't want it bundled.

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

I think the transport_controller should be the first arg and the rtcp_parameters
the last arg.

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

Good idea. Done.

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

const parameters should go first according to the style guide. And especially if
transport_controller becomes an optional parameter, it makes sense to go on the
end.

+
+  RtpCapabilities GetRtpSenderCapabilities(
+      cricket::MediaType kind) const override;
+
+  RTCErrorOr<std::unique_ptr<OrtcRtpSenderInterface>> CreateRtpSender(
+      rtc::scoped_refptr<MediaStreamTrackInterface> track,

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

Why do you need to pass in a track?  

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

Because this is a combination of "create and send". Though, after thinking about
this more, I'm going to change this. I didn't like how in ORTC, you needed to
construct a transport object and then call "start". But constructing a
sender/receiver and then calling "send/receive" makes more sense.

+      const RtpParameters& rtp_parameters,

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

Why do you need to pass in the rtp_parameters?

+      RtpTransportInterface* transport) override;
+
+  RTCErrorOr<std::unique_ptr<OrtcRtpSenderInterface>> CreateRtpSender(
+      cricket::MediaType kind,
+      const RtpParameters& rtp_parameters,

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

Why does it need to pass in the rtp_parameters?

+      RtpTransportInterface* transport) override;
+
+  RtpCapabilities GetRtpReceiverCapabilities(
+      cricket::MediaType kind) const override;
+
+  RTCErrorOr<std::unique_ptr<OrtcRtpReceiverInterface>> CreateRtpReceiver(
+      cricket::MediaType kind,
+      const RtpParameters& rtp_parameters,

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

Same here

+      RtpTransportInterface* transport) override;
+
+  RTCErrorOr<std::unique_ptr<UdpTransportInterface>>
+  CreateUdpTransport(int family, uint16_t min_port, uint16_t max_port) override;
+
+  rtc::scoped_refptr<AudioSourceInterface> CreateAudioSource(
+      const cricket::AudioOptions& options) override;
+
+  rtc::scoped_refptr<VideoTrackSourceInterface> CreateVideoSource(
+      std::unique_ptr<cricket::VideoCapturer> capturer,
+      const MediaConstraintsInterface* constraints) override;

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

Why are CreateAudioSource and CreateVideoSource part of the ORTC?

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

Because these objects may need to use the same threads and/or other resources as
the other ORTC objects to function properly. The same pattern is used with
PeerConnectionFactory. Maybe we could move this to a separate factory object,
but I didn't want to try to design that right now.

+
+  rtc::scoped_refptr<VideoTrackInterface> CreateVideoTrack(
+      const std::string& id,
+      VideoTrackSourceInterface* source) override;
+
+  rtc::scoped_refptr<AudioTrackInterface> CreateAudioTrack(
+      const std::string& id,
+      AudioSourceInterface* source) override;

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

Why is creating tracks part of ORTC?

+
+  rtc::Thread* network_thread() { return network_thread_; }
+  rtc::Thread* worker_thread() { return worker_thread_.get(); }
+  rtc::Thread* signaling_thread() { return signaling_thread_; }
+
+ private:
+  // Should only be called by OrtcFactoryInterface::Create.
   OrtcFactory(rtc::Thread* network_thread,
               rtc::Thread* signaling_thread,
               rtc::NetworkManager* network_manager,
-              rtc::PacketSocketFactory* socket_factory);
-  ~OrtcFactory() override;
-  std::unique_ptr<UdpTransportInterface>
-  CreateUdpTransport(int family, uint16_t min_port, uint16_t max_port) override;
+              rtc::PacketSocketFactory* socket_factory,
+              AudioDeviceModule* adm);
 
-  rtc::Thread* network_thread() { return network_thread_; }
-  rtc::Thread* worker_thread() { return owned_worker_thread_.get(); }
-  rtc::Thread* signaling_thread() { return signaling_thread_; }
+  // Performs initialization that can fail. Called by factory method after
+  // construction, and if it fails, no object is returned.
+  RTCError Initialize();
+  std::unique_ptr<cricket::MediaEngineInterface> CreateMediaEngine_w();
 
- private:
+  // Threads and networking objects.
   rtc::Thread* network_thread_;
   rtc::Thread* signaling_thread_;
   rtc::NetworkManager* network_manager_;
   rtc::PacketSocketFactory* socket_factory_;
+  AudioDeviceModule* adm_;
   // If we created/own the objects above, these will be non-null and thus will
   // be released automatically upon destruction.
   std::unique_ptr<rtc::Thread> owned_network_thread_;
-  std::unique_ptr<rtc::Thread> owned_worker_thread_;
   bool wraps_signaling_thread_ = false;
   std::unique_ptr<rtc::NetworkManager> owned_network_manager_;
   std::unique_ptr<rtc::PacketSocketFactory> owned_socket_factory_;
+  // We always own the worker thread.
+  std::unique_ptr<rtc::Thread> worker_thread_;
+  // Media-releated objects.
+  std::unique_ptr<RtcEventLog> null_event_log_;
+  rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory_;
+  std::unique_ptr<cricket::ChannelManager> channel_manager_;
+
+  friend class OrtcFactoryInterface;
+
   RTC_DISALLOW_COPY_AND_ASSIGN(OrtcFactory);
 };
 
-BEGIN_OWNED_PROXY_MAP(OrtcFactory)
-  PROXY_SIGNALING_THREAD_DESTRUCTOR()
-  PROXY_METHOD3(std::unique_ptr<UdpTransportInterface>,
-                CreateUdpTransport,
-                int,
-                uint16_t,
-                uint16_t)
-END_PROXY_MAP()
-
 }  // namespace webrtc
 
 #endif  // WEBRTC_PC_ORTCFACTORY_H_