Build WebRTC with data channel only.

webrtc/pc/createpeerconnectionfactory.cc

+/*
+ *  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/audio_codecs/builtin_audio_decoder_factory.h"
+#include "webrtc/api/audio_codecs/builtin_audio_encoder_factory.h"
+#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/logging/rtc_event_log/rtc_event_log_factory_interface.h"
+#include "webrtc/media/engine/webrtcmediaengine.h"
+
+namespace webrtc {
+
+class MediaEngineCreator {

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

Is this just because "rtc::Bind" requires a class? It seems like there must be a
better way.

Anyone else know of one?

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

I just wanna have something work here.

Maybe we can leave this at it is because once your CL is landed, we don't need
to create MediaEngine on the worker thread any more.

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

Acknowledged.

+ public:
+  std::unique_ptr<cricket::MediaEngineInterface> CreateMediaEngine_w(
+      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 std::unique_ptr<cricket::MediaEngineInterface>(
+        cricket::WebRtcMediaEngineFactory::Create(
+            default_adm, audio_encoder_factory, audio_decoder_factory,
+            video_encoder_factory, video_decoder_factory, audio_mixer));
+  }
+};
+
+rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory(
+    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();
+
+  MediaEngineCreator media_engine_creator;
+  std::unique_ptr<cricket::MediaEngineInterface> media_engine =
+      worker_thread->Invoke<std::unique_ptr<cricket::MediaEngineInterface>>(
+          RTC_FROM_HERE,
+          rtc::Bind(
+              &MediaEngineCreator::CreateMediaEngine_w, &media_engine_creator,
+              nullptr /*default_adm*/, audio_encoder_factory,
+              audio_decoder_factory, nullptr /*video_encoder_factory*/,
+              nullptr /*video_decoder_factory*/, nullptr /*audio_mixer*/));
+
+  std::unique_ptr<CallFactoryInterface> call_factory = CreateCallFactory();
+
+  std::unique_ptr<RtcEventLogFactoryInterface> event_log_factory =
+      CreateRtcEventLogFactory();
+
+  // The PeerConnectionFactory would create the network thread and signaling
+  // thread internally and own all the threads.
+  return CreateModularPeerConnectionFactory(
+      nullptr, /*network_thread*/
+      worker_thread.release(), nullptr /*signaling_thread*/,

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

So, this results in ownership of |worker_thread| being transferred, specifically
because |network_thread| is null? This is the part of
CreateModularPeerConnectionFactory that's confusing. Also, it would be nice if
the code duplication between this and CreatePeerConnectionFactoryWithAudioMixer
could be avoided.

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

Again, I think this won't be an issue once your CL is landed and we can create
the MediaEngine on the signaling thread.
Done.

+      nullptr /*default_adm*/, audio_encoder_factory, audio_decoder_factory,
+      nullptr /*video_encoder_factory*/, nullptr /*video_decoder_factory*/,
+      nullptr /*audio_mixer*/, std::move(media_engine), std::move(call_factory),
+      std::move(event_log_factory));
+}
+
+rtc::scoped_refptr<PeerConnectionFactoryInterface>
+CreatePeerConnectionFactory() {
+  return CreatePeerConnectionFactory(CreateBuiltinAudioEncoderFactory(),
+                                     CreateBuiltinAudioDecoderFactory());
+}
+
+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) {
+  MediaEngineCreator media_engine_creator;
+  std::unique_ptr<cricket::MediaEngineInterface> media_engine =
+      worker_thread->Invoke<std::unique_ptr<cricket::MediaEngineInterface>>(
+          RTC_FROM_HERE,
+          rtc::Bind(&MediaEngineCreator::CreateMediaEngine_w,
+                    &media_engine_creator, default_adm, audio_encoder_factory,
+                    audio_decoder_factory, video_encoder_factory,
+                    video_decoder_factory, audio_mixer));
+
+  std::unique_ptr<CallFactoryInterface> call_factory = CreateCallFactory();
+
+  std::unique_ptr<RtcEventLogFactoryInterface> event_log_factory =
+      CreateRtcEventLogFactory();
+
+  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::move(media_engine),
+      std::move(call_factory), std::move(event_log_factory));
+}
+
+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,
+      CreateBuiltinAudioEncoderFactory(), CreateBuiltinAudioDecoderFactory(),
+      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