Build WebRTC with data channel only.

webrtc/pc/channelmanager.cc

 /*
  *  Copyright 2004 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 71 matching lines @@
     enable_rtx_ = enable;
     return true;
   } else {
     LOG(LS_WARNING) << "Cannot toggle rtx after initialization!";
     return false;
   }
 }
 
 void ChannelManager::GetSupportedAudioSendCodecs(
     std::vector<AudioCodec>* codecs) const {
+  if (!media_engine_) {
+    LOG(LS_WARNING) << "Failed to get supported audio sending codecs because "
+                       "the media_engine_ is unset.";

[Taylor Brandstetter, 2017/05/30 17:30:53]

Will this occur during normal circumstances in a data channel-only build? If so,
the "warning" log level (or even "info") may be too severe.

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

I'll remove these.

+    return;
+  }
   *codecs = media_engine_->audio_send_codecs();
 }
 
 void ChannelManager::GetSupportedAudioReceiveCodecs(
     std::vector<AudioCodec>* codecs) const {
+  if (!media_engine_) {
+    LOG(LS_WARNING) << "Failed to get supported audio receiving codecs because "
+                       "the media_engine_ is unset.";
+    return;
+  }
   *codecs = media_engine_->audio_recv_codecs();
 }
 
 void ChannelManager::GetSupportedAudioRtpHeaderExtensions(
     RtpHeaderExtensions* ext) const {
+  if (!media_engine_) {
+    LOG(LS_WARNING) << "Failed to get audio RTP header extensions because the "
+                       "media_engine_ is unset.";
+    return;
+  }
   *ext = media_engine_->GetAudioCapabilities().header_extensions;
 }
 
 void ChannelManager::GetSupportedVideoCodecs(
     std::vector<VideoCodec>* codecs) const {
+  if (!media_engine_) {
+    LOG(LS_WARNING)
+        << "Failed to get video codecs because the media_engine_ is unset.";
+    return;
+  }
   codecs->clear();
 
   std::vector<VideoCodec> video_codecs = media_engine_->video_codecs();
   for (const auto& video_codec : video_codecs) {
     if (!enable_rtx_ &&
         _stricmp(kRtxCodecName, video_codec.name.c_str()) == 0) {
       continue;
     }
     codecs->push_back(video_codec);
   }
 }
 
 void ChannelManager::GetSupportedVideoRtpHeaderExtensions(
     RtpHeaderExtensions* ext) const {
+  if (!media_engine_) {
+    LOG(LS_WARNING) << "Failed to get video RTP header extensions because the "
+                       "media_engine_ is unset.";
+    return;
+  }
   *ext = media_engine_->GetVideoCapabilities().header_extensions;
 }
 
 void ChannelManager::GetSupportedDataCodecs(
     std::vector<DataCodec>* codecs) const {
+  if (!data_media_engine_) {
+    LOG(LS_WARNING) << "Failed to get supported data codecs because the "
+                       "data_media_engine_ is unset.";
+    return;
+  }
   *codecs = data_media_engine_->data_codecs();
 }
 
 bool ChannelManager::Init() {
   RTC_DCHECK(!initialized_);
   if (initialized_) {
     return false;
   }
   RTC_DCHECK(network_thread_);
   RTC_DCHECK(worker_thread_);
   if (!network_thread_->IsCurrent()) {
     // Do not allow invoking calls to other threads on the network thread.
     network_thread_->Invoke<bool>(
         RTC_FROM_HERE,
         rtc::Bind(&rtc::Thread::SetAllowBlockingCalls, network_thread_, false));
   }
 
   initialized_ = worker_thread_->Invoke<bool>(
       RTC_FROM_HERE, Bind(&ChannelManager::InitMediaEngine_w, this));
   RTC_DCHECK(initialized_);
   return initialized_;
 }
 
 bool ChannelManager::InitMediaEngine_w() {
   RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
-  return media_engine_->Init();
+  if (media_engine_) {
+    return media_engine_->Init();
+  }
+  return true;
 }
 
 void ChannelManager::Terminate() {
   RTC_DCHECK(initialized_);
   if (!initialized_) {
     return;
   }
   worker_thread_->Invoke<void>(RTC_FROM_HERE,
                                Bind(&ChannelManager::Terminate_w, this));
   initialized_ = false;
@@ skipping 54 matching lines @@
     DtlsTransportInternal* rtcp_dtls_transport,
     rtc::PacketTransportInternal* rtp_packet_transport,
     rtc::PacketTransportInternal* rtcp_packet_transport,
     rtc::Thread* signaling_thread,
     const std::string& content_name,
     bool srtp_required,
     const AudioOptions& options) {
   RTC_DCHECK(initialized_);
   RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
   RTC_DCHECK(nullptr != call);
+  if (!media_engine_) {
+    return nullptr;
+  }
 
   VoiceMediaChannel* media_channel = media_engine_->CreateChannel(
       call, media_config, options);
   if (!media_channel)
     return nullptr;
 
   VoiceChannel* voice_channel =
       new VoiceChannel(worker_thread_, network_thread_, signaling_thread,
                        media_engine_.get(), media_channel, content_name,
                        rtcp_packet_transport == nullptr, srtp_required);
@@ skipping 190 matching lines @@
                           media_engine_.get(), file, max_size_bytes));
 }
 
 void ChannelManager::StopAecDump() {
   worker_thread_->Invoke<void>(
       RTC_FROM_HERE,
       Bind(&MediaEngineInterface::StopAecDump, media_engine_.get()));
 }
 
 }  // namespace cricket