Build WebRTC with data channel only.

webrtc/sdk/android/src/jni/createpeerconnectionfactory_datachannelonly.cc

Index: webrtc/sdk/android/src/jni/createpeerconnectionfactory_datachannelonly.cc
diff --git a/webrtc/sdk/android/src/jni/createpeerconnectionfactory_datachannelonly.cc b/webrtc/sdk/android/src/jni/createpeerconnectionfactory_datachannelonly.cc
new file mode 100644
index 0000000000000000000000000000000000000000..7d0d30b2161d45f51c1f7b0964677ecb89c69738
--- /dev/null
+++ b/webrtc/sdk/android/src/jni/createpeerconnectionfactory_datachannelonly.cc
@@ -0,0 +1,106 @@
+/*

[magjed_webrtc, 2017/06/13 15:14:31]

This is a file I haven't seen before and it's not something I would like to have
since it doesn't scale. I thought we agreed to do link-time polymorphism for
Android since we don't expose passing in modules at the moment. So I would like
you to add an audio_jni.cc file and a null_audio_jni.cc file similar to the
existing video jni files. And in these files you implement different versions of
CreateAudioEncoderFactory() and similar for all the other audio modules that are
arguments to CreateModularPeerConnectionFactory. In peerconnection_jni.cc, you
have only one way to call CreateModularPeerConnectionFactory(), but where all
arguments are replaced with these link-time polymorphism functions.

This link-time polymorphism solution is for Android only, and I understand you
want to do it differently for C++. In the future, we would like to move away
from the link-time polymorphism for Android as well once we can pass in
corresponding Java modules.

Also, can you split out the changes for webrtc/sdk/android into a separate CL?
It's incredibly hard to follow and review this huge CL. Also, it will be easier
for you if you have to revert part of the changes in the future if you split
this huge CL up into multiple CLs.

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

Agree. It would be much better to put them to null_audio_jni.cc

BTW, I would like to keep the datachannelonly_so target as an example. It also
can help us to make sure the modular build won't be broken accidentally.

+ *  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.
+ */
+
+#include "webrtc/api/peerconnectioninterface.h"
+#include "webrtc/base/bind.h"
+#include "webrtc/base/scoped_ref_ptr.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/call/callfactoryinterface.h"
+#include "webrtc/media/engine/webrtcmediaengine.h"  // nogncheck
+
+namespace webrtc {
+
+rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory(

[the sun, 2017/06/13 14:34:39]

Do you really need all of these functions? Isn't the JNI just calling one of
them?

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

You are right. I'll try to remove the unused ones.

+    rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,
+    rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory) {
+  // Create and start the worker thread to create the MediaEngine.
+  std::unique_ptr<rtc::Thread> worker_thread = rtc::Thread::Create();
+  worker_thread->Start();
+
+  return CreateModularPeerConnectionFactory(
+      nullptr, /*network_thread*/
+      worker_thread.release(), nullptr /*signaling_thread*/,
+      nullptr /*default_adm*/, audio_encoder_factory, audio_decoder_factory,
+      nullptr /*video_encoder_factory*/, nullptr /*video_decoder_factory*/,
+      nullptr /*audio_mixer*/, std::unique_ptr<cricket::MediaEngineInterface>(),
+      std::unique_ptr<CallFactoryInterface>(),
+      std::unique_ptr<RtcEventLogFactoryInterface>());
+}
+
+rtc::scoped_refptr<PeerConnectionFactoryInterface>
+CreatePeerConnectionFactory() {
+  return CreatePeerConnectionFactory(nullptr /*AudioEncoderFactory*/,
+                                     nullptr /*AudioDecoderFactory*/);
+}
+
+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) {
+  return CreateModularPeerConnectionFactory(
+      network_thread, worker_thread, signaling_thread, default_adm,
+      audio_encoder_factory, audio_decoder_factory, video_encoder_factory,
+      video_decoder_factory, audio_mixer,
+      std::unique_ptr<cricket::MediaEngineInterface>(),
+      std::unique_ptr<CallFactoryInterface>(),
+      std::unique_ptr<RtcEventLogFactoryInterface>());
+}
+
+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) {
+  return CreatePeerConnectionFactoryWithAudioMixer(
+      network_thread, worker_thread, signaling_thread, default_adm,
+      nullptr, /*AudioEncoderFactory*/
+      nullptr /*AudioDecoderFactory*/, encoder_factory, decoder_factory,
+      audio_mixer);
+}
+
+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) {
+  return CreatePeerConnectionFactoryWithAudioMixer(
+      network_thread, worker_thread, signaling_thread, default_adm,
+      encoder_factory, decoder_factory, nullptr);
+}
+
+rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory(
+    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) {
+  return CreatePeerConnectionFactoryWithAudioMixer(
+      network_thread, worker_thread, signaling_thread, default_adm,
+      audio_encoder_factory, audio_decoder_factory, video_encoder_factory,
+      video_decoder_factory, nullptr);
+}
+
+}  // namespace webrtc