Build WebRTC with data channel only.

webrtc/pc/peerconnectionfactory.cc

Index: webrtc/pc/peerconnectionfactory.cc
diff --git a/webrtc/pc/peerconnectionfactory.cc b/webrtc/pc/peerconnectionfactory.cc
index 777bac1eb59aadd49bcc9af1d44ac66e9d02276f..5ec17e0114478f7c23e8414286778131e4f36124 100644
--- a/webrtc/pc/peerconnectionfactory.cc
+++ b/webrtc/pc/peerconnectionfactory.cc
@@ -37,6 +37,20 @@
 
 namespace webrtc {
 
+rtc::scoped_refptr<AudioEncoderFactory> CreateBuiltinAudioEncoderFactoryImpl();
+
+rtc::scoped_refptr<AudioDecoderFactory> CreateBuiltinAudioDecoderFactoryImpl();
+
+std::unique_ptr<cricket::MediaEngineInterface> CreateMediaEngine(
+    webrtc::AudioDeviceModule* adm,
+    const rtc::scoped_refptr<webrtc::AudioEncoderFactory>&
+        audio_encoder_factory,
+    const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
+        audio_decoder_factory,
+    cricket::WebRtcVideoEncoderFactory* video_encoder_factory,
+    cricket::WebRtcVideoDecoderFactory* video_decoder_factory,
+    rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer);
+
 rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory(
     rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,
     rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory) {
@@ -56,8 +70,8 @@ rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory(
 
 rtc::scoped_refptr<PeerConnectionFactoryInterface>
 CreatePeerConnectionFactory() {
-  return CreatePeerConnectionFactory(CreateBuiltinAudioEncoderFactory(),
-                                     CreateBuiltinAudioDecoderFactory());
+  return CreatePeerConnectionFactory(CreateBuiltinAudioEncoderFactoryImpl(),

[the sun, 2017/05/29 13:55:32]

I think we could reduce the build target clutter and size of this CL a bit with
a slightly different approach:

Instead of adding these functions which are "compile time polymorphic", remove
the "CreatePeerConnectionFactory(...)" functions from this file (and the PCF
interface) and keep just the one which is most flexible. Then create separate
build targets to implement these convenience methods, one for the standard
functions which add audio+video+data, another one which calls new
rtc::RefCountedObject<PeerConnectionFactory>(...) with empty scoped_refptr:s for
the audio codec factories, etc.

It looks like CreateMediaEngine() could be forwarded to PCF as a factory method
in the same way.

[Zhi Huang, 2017/05/31 00:03:29]

If I understand correctly, basically you are suggesting that instead of having
helper functions like CreateBuiltinAudioEncoderFactoryImpl, we can have
different implementations of this constructor in different targets and the user
can choose the constructors by linking against different targets.

This should make it cleaner here.

Done.

+                                     CreateBuiltinAudioDecoderFactoryImpl());
 }
 
 rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory(
@@ -127,8 +141,9 @@ CreatePeerConnectionFactoryWithAudioMixer(
     rtc::scoped_refptr<AudioMixer> audio_mixer) {
   return CreatePeerConnectionFactoryWithAudioMixer(
       network_thread, worker_thread, signaling_thread, default_adm,
-      CreateBuiltinAudioEncoderFactory(), CreateBuiltinAudioDecoderFactory(),
-      encoder_factory, decoder_factory, audio_mixer);
+      CreateBuiltinAudioEncoderFactoryImpl(),
+      CreateBuiltinAudioDecoderFactoryImpl(), encoder_factory, decoder_factory,
+      audio_mixer);
 }
 
 PeerConnectionFactory::PeerConnectionFactory(
@@ -385,12 +400,9 @@ rtc::Thread* PeerConnectionFactory::network_thread() {
 std::unique_ptr<cricket::MediaEngineInterface>
 PeerConnectionFactory::CreateMediaEngine_w() {
   RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
-  return std::unique_ptr<cricket::MediaEngineInterface>(
-      cricket::WebRtcMediaEngineFactory::Create(
-          default_adm_.get(), audio_encoder_factory_,
-          audio_decoder_factory_,
-          video_encoder_factory_.get(), video_decoder_factory_.get(),
-          external_audio_mixer_));
+  return CreateMediaEngine(default_adm_.get(), audio_encoder_factory_,
+                           audio_decoder_factory_, video_encoder_factory_.get(),
+                           video_decoder_factory_.get(), external_audio_mixer_);
 }
 
 }  // namespace webrtc