Build WebRTC with data channel only.

webrtc/pc/peerconnection.cc

 /*
  *  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 202 matching lines @@
   if (error) {
     error->set_type(type);
   }
   return type == webrtc::RTCErrorType::NONE;
 }
 
 }  // namespace
 
 namespace webrtc {
 
+std::unique_ptr<RtcEventLog> CreateRtcEventLog();
+Call* CreateCallImpl(const Call::Config& config);
+
 bool PeerConnectionInterface::RTCConfiguration::operator==(
     const PeerConnectionInterface::RTCConfiguration& o) const {
   // This static_assert prevents us from accidentally breaking operator==.
   struct stuff_being_tested_for_equality {
     IceTransportsType type;
     IceServers servers;
     BundlePolicy bundle_policy;
     RtcpMuxPolicy rtcp_mux_policy;
     TcpCandidatePolicy tcp_candidate_policy;
     CandidateNetworkPolicy candidate_network_policy;
@@ skipping 155 matching lines @@
   if (!constraints) {
     return true;
   }
   return mandatory_constraints_satisfied == constraints->GetMandatory().size();
 }
 
 PeerConnection::PeerConnection(PeerConnectionFactory* factory)
     : factory_(factory),
       observer_(NULL),
       uma_observer_(NULL),
-      event_log_(RtcEventLog::Create()),
+      event_log_(CreateRtcEventLog()),
       signaling_state_(kStable),
       ice_connection_state_(kIceConnectionNew),
       ice_gathering_state_(kIceGatheringNew),
       rtcp_cname_(GenerateRtcpCname()),
       local_streams_(StreamCollection::Create()),
       remote_streams_(StreamCollection::Create()) {}
 
 PeerConnection::~PeerConnection() {
   TRACE_EVENT0("webrtc", "PeerConnection::~PeerConnection");
   RTC_DCHECK(signaling_thread()->IsCurrent());
@@ skipping 1919 matching lines @@
 }
 
 void PeerConnection::CreateCall_w() {
   RTC_DCHECK(!call_);
 
   const int kMinBandwidthBps = 30000;
   const int kStartBandwidthBps = 300000;
   const int kMaxBandwidthBps = 2000000;
 
   webrtc::Call::Config call_config(event_log_.get());
-  call_config.audio_state =
-      factory_->channel_manager() ->media_engine()->GetAudioState();
+  if (factory_->channel_manager()->media_engine()) {
+    call_config.audio_state =
+        factory_->channel_manager()->media_engine()->GetAudioState();
+  } else {
+    LOG(LS_WARNING) << "The Call::Config.audio_state is unset because the "
+                       "media engine is unset.";

[Taylor Brandstetter, 2017/05/18 17:57:05]

When will this warning be hit? If it's only hit when CreateCallImpl returns
nullptr, then it would be slightly simpler to move the body of this function
into CreateCallImpl, or just return nullptr early here.

[Zhi Huang, 2017/05/23 03:40:35]

Done.

+  }
+
   call_config.bitrate_config.min_bitrate_bps = kMinBandwidthBps;
   call_config.bitrate_config.start_bitrate_bps = kStartBandwidthBps;
   call_config.bitrate_config.max_bitrate_bps = kMaxBandwidthBps;
-
-  call_.reset(webrtc::Call::Create(call_config));
+  call_.reset(CreateCallImpl(call_config));
 }
 
 }  // namespace webrtc