Build WebRTC with data channel only.

webrtc/pc/peerconnectioninterface_unittest.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 10 matching lines @@
 #include "webrtc/api/rtpreceiverinterface.h"
 #include "webrtc/api/rtpsenderinterface.h"
 #include "webrtc/api/test/fakeconstraints.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/sslstreamadapter.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/virtualsocketserver.h"
 #include "webrtc/media/base/fakevideocapturer.h"
+#include "webrtc/media/engine/webrtcmediaengine.h"
 #include "webrtc/media/sctp/sctptransportinternal.h"
 #include "webrtc/p2p/base/fakeportallocator.h"
 #include "webrtc/pc/audiotrack.h"
 #include "webrtc/pc/mediasession.h"
 #include "webrtc/pc/mediastream.h"
 #include "webrtc/pc/peerconnection.h"
 #include "webrtc/pc/streamcollection.h"
 #include "webrtc/pc/test/fakertccertificategenerator.h"
 #include "webrtc/pc/test/fakevideotracksource.h"
 #include "webrtc/pc/test/mockpeerconnectionobservers.h"
@@ skipping 593 matching lines @@
 };
 
 }  // namespace
 
 // The PeerConnectionMediaConfig tests below verify that configuration and
 // constraints are propagated into the PeerConnection's MediaConfig. These
 // settings are intended for MediaChannel constructors, but that is not
 // exercised by these unittest.
 class PeerConnectionFactoryForTest : public webrtc::PeerConnectionFactory {
  public:
-  PeerConnectionFactoryForTest()
-      : webrtc::PeerConnectionFactory(
-            webrtc::CreateBuiltinAudioEncoderFactory(),
-            webrtc::CreateBuiltinAudioDecoderFactory()) {}
+  static rtc::scoped_refptr<PeerConnectionFactoryForTest>
+  CreatePeerConnectionFactoryForTest() {
+    auto audio_encoder_factory = webrtc::CreateBuiltinAudioEncoderFactory();
+    auto audio_decoder_factory = webrtc::CreateBuiltinAudioDecoderFactory();
+
+    auto media_engine = std::unique_ptr<cricket::MediaEngineInterface>(
+        cricket::WebRtcMediaEngineFactory::Create(
+            nullptr, audio_encoder_factory, audio_decoder_factory, nullptr,
+            nullptr, nullptr));
+
+    std::unique_ptr<webrtc::CallFactoryInterface> call_factory =
+        webrtc::CreateCallFactory();
+
+    std::unique_ptr<webrtc::RtcEventLogFactoryInterface> event_log_factory =
+        webrtc::CreateRtcEventLogFactory();
+
+    return new rtc::RefCountedObject<PeerConnectionFactoryForTest>(
+        rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(),
+        nullptr, audio_encoder_factory, audio_decoder_factory, nullptr, nullptr,
+        nullptr, std::move(media_engine), std::move(call_factory),
+        std::move(event_log_factory));
+  }
+
+  PeerConnectionFactoryForTest(
+      rtc::Thread* network_thread,
+      rtc::Thread* worker_thread,
+      rtc::Thread* signaling_thread,
+      webrtc::AudioDeviceModule* default_adm,
+      rtc::scoped_refptr<webrtc::AudioEncoderFactory> audio_encoder_factory,
+      rtc::scoped_refptr<webrtc::AudioDecoderFactory> audio_decoder_factory,
+      cricket::WebRtcVideoEncoderFactory* video_encoder_factory,
+      cricket::WebRtcVideoDecoderFactory* video_decoder_factory,
+      rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer,
+      std::unique_ptr<cricket::MediaEngineInterface> media_engine,
+      std::unique_ptr<webrtc::CallFactoryInterface> call_factory,
+      std::unique_ptr<webrtc::RtcEventLogFactoryInterface> event_log_factory)
+      : webrtc::PeerConnectionFactory(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)) {}
 
   cricket::TransportController* CreateTransportController(
       cricket::PortAllocator* port_allocator,
       bool redetermine_role_on_ice_restart) override {
     transport_controller = new cricket::TransportController(
         rtc::Thread::Current(), rtc::Thread::Current(), port_allocator,
         redetermine_role_on_ice_restart, rtc::CryptoOptions());
     return transport_controller;
   }
 
   cricket::TransportController* transport_controller;
 };
 
 class PeerConnectionInterfaceTest : public testing::Test {
  protected:
   PeerConnectionInterfaceTest()
       : vss_(new rtc::VirtualSocketServer()), main_(vss_.get()) {
 #ifdef WEBRTC_ANDROID
     webrtc::InitializeAndroidObjects();
 #endif
   }
 
   virtual void SetUp() {
     pc_factory_ = webrtc::CreatePeerConnectionFactory(
         rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(),
         nullptr, nullptr, nullptr);
     ASSERT_TRUE(pc_factory_);
     pc_factory_for_test_ =
-        new rtc::RefCountedObject<PeerConnectionFactoryForTest>();
+        PeerConnectionFactoryForTest::CreatePeerConnectionFactoryForTest();
     pc_factory_for_test_->Initialize();
   }
 
   void CreatePeerConnection() {
     CreatePeerConnection(PeerConnectionInterface::RTCConfiguration(), nullptr);
   }
 
   // DTLS does not work in a loopback call, so is disabled for most of the
   // tests in this file.
   void CreatePeerConnectionWithoutDtls() {
@@ skipping 2673 matching lines @@
 TEST_F(PeerConnectionInterfaceTest, SetBitrateCurrentLessThanImplicitMin) {
   CreatePeerConnection();
   PeerConnectionInterface::BitrateParameters bitrate;
   bitrate.current_bitrate_bps = rtc::Optional<int>(1);
   EXPECT_TRUE(pc_->SetBitrate(bitrate).ok());
 }
 
 class PeerConnectionMediaConfigTest : public testing::Test {
  protected:
   void SetUp() override {
-    pcf_ = new rtc::RefCountedObject<PeerConnectionFactoryForTest>();
+    pcf_ = PeerConnectionFactoryForTest::CreatePeerConnectionFactoryForTest();
     pcf_->Initialize();
   }
   const cricket::MediaConfig TestCreatePeerConnection(
       const PeerConnectionInterface::RTCConfiguration& config,
       const MediaConstraintsInterface *constraints) {
 
     rtc::scoped_refptr<PeerConnectionInterface> pc(pcf_->CreatePeerConnection(
         config, constraints, nullptr, nullptr, &observer_));
     EXPECT_TRUE(pc.get());
     return pc->GetConfiguration().media_config;
@@ skipping 268 matching lines @@
   EXPECT_NE(a, f);
 
   PeerConnectionInterface::RTCConfiguration g;
   g.disable_ipv6 = true;
   EXPECT_NE(a, g);
 
   PeerConnectionInterface::RTCConfiguration h(
       PeerConnectionInterface::RTCConfigurationType::kAggressive);
   EXPECT_NE(a, h);
 }