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

webrtc/api/ortcfactoryinterface.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_API_ORTCFACTORYINTERFACE_H_

[the sun, 2017/02/07 08:26:27]

Would it make sense to put this in api/ortc/ instead? It'd be nice to keep PC
and ORTC APIs separated.

[Taylor Brandstetter, 2017/02/07 16:30:00]

You're right, now that the api > pc move has happened it's a good time to make
that separation.

 #define WEBRTC_API_ORTCFACTORYINTERFACE_H_
 
 #include <memory>
 
+#include "webrtc/api/mediaconstraintsinterface.h"
+#include "webrtc/api/mediastreaminterface.h"
+#include "webrtc/api/mediatypes.h"
+#include "webrtc/api/ortcrtpreceiverinterface.h"
+#include "webrtc/api/ortcrtpsenderinterface.h"
+#include "webrtc/api/packettransportinterface.h"
+#include "webrtc/api/rtcerror.h"
+#include "webrtc/api/rtpparameters.h"
+#include "webrtc/api/rtptransportcontrollerinterface.h"
+#include "webrtc/api/rtptransportinterface.h"
 #include "webrtc/api/udptransportinterface.h"
 #include "webrtc/base/network.h"
+#include "webrtc/base/scoped_ref_ptr.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/p2p/base/packetsocketfactory.h"
 
 namespace webrtc {
 
+// TODO(deadbeef): This should be part of /api/, but currently it's not and
+// including its header violates checkdeps rules.
+class AudioDeviceModule;
+
 // WARNING: This is experimental/under development, so use at your own risk; no
 // guarantee about API stability is guaranteed here yet.
 //
 // This class is the ORTC analog of PeerConnectionFactory. It acts as a factory
 // for ORTC objects that can be connected to each other.
 //
 // Some of these objects may not be represented by the ORTC specification, but
 // follow the same general principles.
 //
+// If one of the factory methods takes another object as an argument, it MUST
+// have been created by the same OrtcFactory.
+//
 // On object lifetimes: The factory must not be destroyed before destroying the
 // objects it created, and the objects passed into the factory must not be
 // destroyed before destroying the factory.
 class OrtcFactoryInterface {
  public:
   // |network_thread| is the thread on which packets are sent and received.
   // If null, a new rtc::Thread with a default socket server is created.
   //
   // |signaling_thread| is used for callbacks to the consumer of the API. If
   // null, the current thread will be used, which assumes that the API consumer
   // is running a message loop on this thread (either using an existing
   // rtc::Thread, or by calling rtc::Thread::Current()->ProcessMessages).
   //
   // |network_manager| is used to determine which network interfaces are
   // available. This is used for ICE, for example. If null, a default
   // implementation will be used. Only accessed on |network_thread|.
   //
   // |socket_factory| is used (on the network thread) for creating sockets. If
   // it's null, a default implementation will be used, which assumes
   // |network_thread| is a normal rtc::Thread.
   //
+  // |adm| is optional, and allows a different audio device implementation to
+  // be injected; otherwise a platform-specific module will be used that will
+  // use the default audio input.
+  //
   // Note that the OrtcFactoryInterface does not take ownership of any of the
-  // objects
-  // passed in, and as previously stated, these objects can't be destroyed
-  // before the factory is.
-  static std::unique_ptr<OrtcFactoryInterface> Create(
+  // objects passed in, and as previously stated, these objects can't be
+  // destroyed before the factory is.
+  static RTCErrorOr<std::unique_ptr<OrtcFactoryInterface>> Create(
       rtc::Thread* network_thread,
       rtc::Thread* signaling_thread,
       rtc::NetworkManager* network_manager,
-      rtc::PacketSocketFactory* socket_factory);
+      rtc::PacketSocketFactory* socket_factory,
+      AudioDeviceModule* adm);
+
   // Constructor for convenience which uses default implementations of
   // everything (though does still require that the current thread runs a
   // message loop; see above).
-  static std::unique_ptr<OrtcFactoryInterface> Create() {
-    return Create(nullptr, nullptr, nullptr, nullptr);
+  static RTCErrorOr<std::unique_ptr<OrtcFactoryInterface>> Create() {
+    return Create(nullptr, nullptr, nullptr, nullptr, nullptr);
   }
 
   virtual ~OrtcFactoryInterface() {}
 
-  virtual std::unique_ptr<UdpTransportInterface>
+  // Creates an RTP transport controller, which is required for calls to
+  // CreateRtpTransport methods. If your application has some notion of a
+  // "call", you should create one transport controller per call.
+  // TODO(deadbeef): Add MediaConfig and RtcEventLog arguments?
+  virtual RTCErrorOr<std::unique_ptr<RtpTransportControllerInterface>>
+  CreateRtpTransportController() = 0;
+
+  // Creates an RTP transport using the provided packet transports and
+  // transport controller.
+  //
+  // |rtp| will be used for sending RTP packets, and |rtcp| for RTCP packets.
+  //
+  // |rtp| can't be null. |rtcp| can if RTCP muxing is being used immediately,
+  // meaning |rtcp_parameters.mux| is true.
+  //
+  // |transport_controller| must not be null.
+  virtual RTCErrorOr<std::unique_ptr<RtpTransportInterface>> CreateRtpTransport(
+      const RtcpParameters& rtcp_parameters,
+      PacketTransportInterface* rtp,
+      PacketTransportInterface* rtcp,
+      RtpTransportControllerInterface* transport_controller) = 0;
+
+  // Returns the capabilities of an RTP sender of type |kind|. These
+  // capabilities can be used to determine what RtpParameters to use to create
+  // an RtpSender.
+  //
+  // If for some reason you pass in MEDIA_TYPE_DATA, returns an empty structure.
+  virtual RtpCapabilities GetRtpSenderCapabilities(
+      cricket::MediaType kind) const = 0;
+
+  // Creates an RTP sender and starts sending the provided |track| (assuming an
+  // active encoding exists in |rtp_parameters|).
+  //
+  // |track| and |transport| must not be null.
+  virtual RTCErrorOr<std::unique_ptr<OrtcRtpSenderInterface>> CreateRtpSender(
+      rtc::scoped_refptr<MediaStreamTrackInterface> track,
+      const RtpParameters& rtp_parameters,
+      RtpTransportInterface* transport) = 0;
+
+  // Same as above, but allows creating the sender without a track.
+  //
+  // |kind| must be MEDIA_TYPE_AUDIO or MEDIA_TYPE_VIDEO.
+  virtual RTCErrorOr<std::unique_ptr<OrtcRtpSenderInterface>> CreateRtpSender(
+      cricket::MediaType kind,
+      const RtpParameters& rtp_parameters,
+      RtpTransportInterface* transport) = 0;
+
+  // Returns the capabilities of an RTP receiver of type |kind|. These
+  // capabilities can be used to determine what RtpParameters to use to create
+  // an RtpReceiver.
+  //
+  // If for some reason you pass in MEDIA_TYPE_DATA, returns an empty structure.
+  virtual RtpCapabilities GetRtpReceiverCapabilities(
+      cricket::MediaType kind) const = 0;
+
+  // Creates an RTP receiver and prepares to receive a MediaStreamTrack
+  // described by |rtp_parameters|.
+  //
+  // |kind| must be MEDIA_TYPE_AUDIO or MEDIA_TYPE_VIDEO.
+  //
+  // |transport| must not be null.
+  virtual RTCErrorOr<std::unique_ptr<OrtcRtpReceiverInterface>>
+  CreateRtpReceiver(cricket::MediaType kind,
+                    const RtpParameters& rtp_parameters,
+                    RtpTransportInterface* transport) = 0;
+
+  // Create a UDP transport with IP address family |family|, using a port
+  // within the specified range.
+  //
+  // |family| must be AF_INET or AF_INET6.
+  //
+  // |min_port|/|max_port| values of 0 indicate no range restriction.
+  //
+  // Returns an error if the transport wasn't successfully created.
+  virtual RTCErrorOr<std::unique_ptr<UdpTransportInterface>>
   CreateUdpTransport(int family, uint16_t min_port, uint16_t max_port) = 0;
+
+  // NOTE: The methods below to create tracks/sources return scoped_refptrs
+  // rather than unique_ptrs, because these interfaces are also used with
+  // PeerConnection, where everything is ref-counted.
+
+  // Creates a audio source representing the default microphone input.
+  // |options| decides audio processing settings.
+  virtual rtc::scoped_refptr<AudioSourceInterface> CreateAudioSource(
+      const cricket::AudioOptions& options) = 0;
+
+  // Version of the above method that uses default options.
+  rtc::scoped_refptr<AudioSourceInterface> CreateAudioSource() {
+    return CreateAudioSource(cricket::AudioOptions());
+  }
+
+  // Creates a video source object wrapping and taking ownership of |capturer|.
+  //
+  // |constraints| can be used for selection of resolution and frame rate, and
+  // may be null if no constraints are desired.
+  virtual rtc::scoped_refptr<VideoTrackSourceInterface> CreateVideoSource(
+      std::unique_ptr<cricket::VideoCapturer> capturer,
+      const MediaConstraintsInterface* constraints) = 0;
+
+  // Version of the above method that omits |constraints|.
+  rtc::scoped_refptr<VideoTrackSourceInterface> CreateVideoSource(
+      std::unique_ptr<cricket::VideoCapturer> capturer) {
+    return CreateVideoSource(std::move(capturer), nullptr);
+  }
+
+  // Creates a new local video track wrapping |source|. The same |source| can
+  // be used in several tracks.
+  virtual rtc::scoped_refptr<VideoTrackInterface> CreateVideoTrack(
+      const std::string& id,
+      VideoTrackSourceInterface* source) = 0;
+
+  // Creates an new local audio track wrapping |source|.
+  virtual rtc::scoped_refptr<AudioTrackInterface> CreateAudioTrack(
+      const std::string& id,
+      AudioSourceInterface* source) = 0;
+
   // Method for convenience that has no port range restrictions.
-  std::unique_ptr<UdpTransportInterface> CreateUdpTransport(int family) {
+  RTCErrorOr<std::unique_ptr<UdpTransportInterface>> CreateUdpTransport(
+      int family) {
     return CreateUdpTransport(family, 0, 0);
   }
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_API_ORTCFACTORYINTERFACE_H_