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 374 matching lines @@
     kv.second.ice_restart = ice_restart;
   }
 
   if (!constraints) {
     return true;
   }
   return mandatory_constraints_satisfied == constraints->GetMandatory().size();
 }
 
 PeerConnection::PeerConnection(PeerConnectionFactory* factory)
+    : PeerConnection(factory,
+                     std::unique_ptr<RtcEventLog>(),
+                     std::unique_ptr<Call>() /*Call*/) {}
+
+PeerConnection::PeerConnection(PeerConnectionFactory* factory,
+                               std::unique_ptr<RtcEventLog> event_log,
+                               std::unique_ptr<Call> call)
     : factory_(factory),
       observer_(NULL),
       uma_observer_(NULL),
-      event_log_(RtcEventLog::Create()),
+      event_log_(std::move(event_log)),
       signaling_state_(kStable),
       ice_connection_state_(kIceConnectionNew),
       ice_gathering_state_(kIceGatheringNew),
       rtcp_cname_(GenerateRtcpCname()),
       local_streams_(StreamCollection::Create()),
-      remote_streams_(StreamCollection::Create()) {}
+      remote_streams_(StreamCollection::Create()),
+      call_(std::move(call)) {}
 
 PeerConnection::~PeerConnection() {
   TRACE_EVENT0("webrtc", "PeerConnection::~PeerConnection");
   RTC_DCHECK(signaling_thread()->IsCurrent());
   // Need to detach RTP senders/receivers from WebRtcSession,
   // since it's about to be destroyed.
   for (const auto& sender : senders_) {
     sender->internal()->Stop();
   }
   for (const auto& receiver : receivers_) {
@@ skipping 38 matching lines @@
   port_allocator_ = std::move(allocator);
 
   // The port allocator lives on the network thread and should be initialized
   // there.
   if (!network_thread()->Invoke<bool>(
           RTC_FROM_HERE, rtc::Bind(&PeerConnection::InitializePortAllocator_n,
                                    this, configuration))) {
     return false;
   }
 
-  // Call must be constructed on the worker thread.
-  factory_->worker_thread()->Invoke<void>(
-      RTC_FROM_HERE, rtc::Bind(&PeerConnection::CreateCall_w,
-                               this));
 
   session_.reset(new WebRtcSession(
       call_.get(), factory_->channel_manager(), configuration.media_config,
       event_log_.get(),
       factory_->network_thread(),
       factory_->worker_thread(), factory_->signaling_thread(),
       port_allocator_.get(),
       std::unique_ptr<cricket::TransportController>(
           factory_->CreateTransportController(
               port_allocator_.get(),
@@ skipping 1891 matching lines @@
   }
   return event_log_->StartLogging(file, max_size_bytes);
 }
 
 void PeerConnection::StopRtcEventLog_w() {
   if (event_log_) {
     event_log_->StopLogging();
   }
 }
 
-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();
-  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));
-}
-
 }  // namespace webrtc