Build WebRTC with data channel only.

webrtc/api/peerconnectioninterface.h

 /*
  *  Copyright 2012 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.
  */
 
@@ skipping 72 matching lines @@
 #include "webrtc/api/rtpsenderinterface.h"
 #include "webrtc/api/stats/rtcstatscollectorcallback.h"
 #include "webrtc/api/statstypes.h"
 #include "webrtc/api/umametrics.h"
 #include "webrtc/base/fileutils.h"
 #include "webrtc/base/network.h"
 #include "webrtc/base/rtccertificate.h"
 #include "webrtc/base/rtccertificategenerator.h"
 #include "webrtc/base/socketaddress.h"
 #include "webrtc/base/sslstreamadapter.h"
+#include "webrtc/call/callfactoryinterface.h"
+#include "webrtc/logging/rtc_event_log/rtc_event_log_factory_interface.h"
 #include "webrtc/media/base/mediachannel.h"
 #include "webrtc/media/base/videocapturer.h"
 #include "webrtc/p2p/base/portallocator.h"
 
 namespace rtc {
 class SSLIdentity;
 class Thread;
 }
 
 namespace cricket {
+class MediaEngineInterface;
 class WebRtcVideoDecoderFactory;
 class WebRtcVideoEncoderFactory;
 }
 
 namespace webrtc {
 class AudioDeviceModule;
 class AudioMixer;
+class CallFactoryInterface;
 class MediaConstraintsInterface;
 
 // MediaStream container interface.
 class StreamCollectionInterface : public rtc::RefCountInterface {
  public:
   // TODO(ronghuawu): Update the function names to c++ style, e.g. find -> Find.
   virtual size_t count() = 0;
   virtual MediaStreamInterface* at(size_t index) = 0;
   virtual MediaStreamInterface* find(const std::string& label) = 0;
   virtual MediaStreamTrackInterface* FindAudioTrack(
@@ skipping 891 matching lines @@
   // TODO(ivoc) Remove after Chrome is updated.
   virtual void StopRtcEventLog() = 0;
 
  protected:
   // Dtor and ctor protected as objects shouldn't be created or deleted via
   // this interface.
   PeerConnectionFactoryInterface() {}
   ~PeerConnectionFactoryInterface() {} // NOLINT
 };
 
+// Deprecated. Use the CreateModularPeerConnectionFactory instead.
+//

[Taylor Brandstetter, 2017/06/14 01:54:15]

I don't think we need to deprecate CreatePeerConnectionFactory; we can keep both
around for both "basic" and "advanced" users.

[Zhi Huang, 2017/06/14 06:57:01]

Acknowledged.

 // Create a new instance of PeerConnectionFactoryInterface.
 //
 // This method relies on the thread it's called on as the "signaling thread"
 // for the PeerConnectionFactory it creates.
 //
 // As such, if the current thread is not already running an rtc::Thread message
 // loop, an application using this method must eventually either call
 // rtc::Thread::Current()->Run(), or call
 // rtc::Thread::Current()->ProcessMessages() within the application's own
 // message loop.
 rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory(
     rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,
     rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory);
 
-// Deprecated variant of the above.
+// Deprecated. Use the CreateModularPeerConnectionFactory instead.
 // TODO(kwiberg): Remove.
 rtc::scoped_refptr<PeerConnectionFactoryInterface>
 CreatePeerConnectionFactory();
 
+// Deprecated. Use the CreateModularPeerConnectionFactory instead.
+//
 // Create a new instance of PeerConnectionFactoryInterface.
 //
 // |network_thread|, |worker_thread| and |signaling_thread| are
 // the only mandatory parameters.
 //
 // If non-null, a reference is added to |default_adm|, and ownership of
 // |video_encoder_factory| and |video_decoder_factory| is transferred to the
 // returned factory.
 // TODO(deadbeef): Use rtc::scoped_refptr<> and std::unique_ptr<> to make this
 // ownership transfer and ref counting more obvious.
@@ skipping 10 matching lines @@
 // Deprecated variant of the above.
 // TODO(kwiberg): Remove.
 rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory(
     rtc::Thread* network_thread,
     rtc::Thread* worker_thread,
     rtc::Thread* signaling_thread,
     AudioDeviceModule* default_adm,
     cricket::WebRtcVideoEncoderFactory* encoder_factory,
     cricket::WebRtcVideoDecoderFactory* decoder_factory);
 
+// Deprecated. Use the CreateModularPeerConnectionFactory instead.
+//
 // Create a new instance of PeerConnectionFactoryInterface with external audio
 // mixer.
 //
 // If |audio_mixer| is null, an internal audio mixer will be created and used.
 rtc::scoped_refptr<PeerConnectionFactoryInterface>
 CreatePeerConnectionFactoryWithAudioMixer(
     rtc::Thread* network_thread,
     rtc::Thread* worker_thread,
     rtc::Thread* signaling_thread,
     AudioDeviceModule* default_adm,
     rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,
     rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory,
     cricket::WebRtcVideoEncoderFactory* video_encoder_factory,
     cricket::WebRtcVideoDecoderFactory* video_decoder_factory,
     rtc::scoped_refptr<AudioMixer> audio_mixer);
 
 // Deprecated variant of the above.
 // TODO(kwiberg): Remove.
 rtc::scoped_refptr<PeerConnectionFactoryInterface>
 CreatePeerConnectionFactoryWithAudioMixer(
     rtc::Thread* network_thread,
     rtc::Thread* worker_thread,
     rtc::Thread* signaling_thread,
     AudioDeviceModule* default_adm,
     cricket::WebRtcVideoEncoderFactory* encoder_factory,
     cricket::WebRtcVideoDecoderFactory* decoder_factory,
     rtc::scoped_refptr<AudioMixer> audio_mixer);
 
+// Deprecated. Use the CreateModularPeerConnectionFactory instead.
+//
 // Create a new instance of PeerConnectionFactoryInterface.
 // Same thread is used as worker and network thread.
 inline rtc::scoped_refptr<PeerConnectionFactoryInterface>
 CreatePeerConnectionFactory(
     rtc::Thread* worker_and_network_thread,
     rtc::Thread* signaling_thread,
     AudioDeviceModule* default_adm,
     rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,
     rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory,
     cricket::WebRtcVideoEncoderFactory* video_encoder_factory,
@@ skipping 11 matching lines @@
     rtc::Thread* worker_and_network_thread,
     rtc::Thread* signaling_thread,
     AudioDeviceModule* default_adm,
     cricket::WebRtcVideoEncoderFactory* encoder_factory,
     cricket::WebRtcVideoDecoderFactory* decoder_factory) {
   return CreatePeerConnectionFactory(
       worker_and_network_thread, worker_and_network_thread, signaling_thread,
       default_adm, encoder_factory, decoder_factory);
 }
 
+// Create a new instance of PeerConnectionFactoryInterface.
+//
+// |worker_thread| is the only mandatory parameter. If the |network_thread| or
+// the |signaling_thread| is null, the PeerConnectionFactory would create the
+// |network_thread| internally and use the thread which this method is called as
+// the |signaling_thread|. In this case, all the threads would be owned by the
+// PeerConnectionFactory.
+//
+// If all the threads passed in are non-null, the PeerConnectionFactory will not
+// own them.

[Taylor Brandstetter, 2017/06/14 01:54:15]

This logic related to threads is pretty confusing. I'd prefer if we could change
it to just "if any thread is null, one will be created internally as needed."

[Zhi Huang, 2017/06/14 06:57:01]

I think your suggestion is not equivalent to the original logic.

The original logic is creating and own all of then or creating none of them.
This is why we only have one flag |own_ptr|.

Would it be slightly better to do:

  if (!network_thread || !signaling_thread) {
...
}

Or maybe we can just have two ctors and two CreateModularPCF() which would be
more clear I think.

[Taylor Brandstetter, 2017/06/15 00:35:02]

We already talked about this in person, but for the benefit of other code
reviewers... The trouble now is that there are three possibilities:

1. Passing in null pointer; thread created automatically
2. Passing in a pointer to a thread that the caller owns
3. Passing in a pointer to a thread that the PC factory should own

#3 is needed because WebRtcMediaEngine needs to be constructed on the worker
thread. So CreatePeerConnectionFactory needs to create the worker thread itself,
create the media engine on it, then pass both into PeerConnectionFactory. That's
why landing this CL would be good: https://codereview.webrtc.org/2934103002/

+//
+// If non-null, a reference is added to |default_adm|, and ownership of
+// |video_encoder_factory| and |video_decoder_factory| is transferred to the
+// returned factory.
+// TODO(deadbeef): Use rtc::scoped_refptr<> and std::unique_ptr<> to make this
+// ownership transfer and ref counting more obvious.
+rtc::scoped_refptr<PeerConnectionFactoryInterface>
+CreateModularPeerConnectionFactory(
+    rtc::Thread* network_thread,
+    rtc::Thread* worker_thread,
+    rtc::Thread* signaling_thread,
+    AudioDeviceModule* default_adm,
+    rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,
+    rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory,
+    cricket::WebRtcVideoEncoderFactory* video_encoder_factory,
+    cricket::WebRtcVideoDecoderFactory* video_decoder_factory,
+    rtc::scoped_refptr<AudioMixer> audio_mixer,
+    std::unique_ptr<cricket::MediaEngineInterface> media_engine,
+    std::unique_ptr<CallFactoryInterface> call_factory,
+    std::unique_ptr<RtcEventLogFactoryInterface> event_log_factory);
+
 }  // namespace webrtc
 
 #endif  // WEBRTC_API_PEERCONNECTIONINTERFACE_H_