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* CreateCall(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());
+  if (!factory_->channel_manager()->media_engine()) {
+    LOG(LS_WARNING)
+        << "Failed to create the Call because the media engine is unset.";
+    return;
+  }
   call_config.audio_state =
-      factory_->channel_manager() ->media_engine()->GetAudioState();
+      factory_->channel_manager()->media_engine()->GetAudioState();
   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(CreateCall(call_config));
 }
 
 }  // namespace webrtc