Revert of Removing #defines previously used for building without BoringSSL/OpenSSL.

webrtc/api/peerconnection_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 28 matching lines @@
 #include "webrtc/base/thread.h"
 #include "webrtc/base/virtualsocketserver.h"
 #include "webrtc/media/engine/fakewebrtcvideoengine.h"
 #include "webrtc/p2p/base/p2pconstants.h"
 #include "webrtc/p2p/base/portinterface.h"
 #include "webrtc/p2p/base/sessiondescription.h"
 #include "webrtc/p2p/base/testturnserver.h"
 #include "webrtc/p2p/client/basicportallocator.h"
 #include "webrtc/pc/mediasession.h"
 
+#define MAYBE_SKIP_TEST(feature)                    \
+  if (!(feature())) {                               \
+    LOG(LS_INFO) << "Feature disabled... skipping"; \
+    return;                                         \
+  }
+
 using cricket::ContentInfo;
 using cricket::FakeWebRtcVideoDecoder;
 using cricket::FakeWebRtcVideoDecoderFactory;
 using cricket::FakeWebRtcVideoEncoder;
 using cricket::FakeWebRtcVideoEncoderFactory;
 using cricket::MediaContentDescription;
 using webrtc::DataBuffer;
 using webrtc::DataChannelInterface;
 using webrtc::DtmfSender;
 using webrtc::DtmfSenderInterface;
@@ skipping 151 matching lines @@
   }
 
   static PeerConnectionTestClient* CreateClient(
       const std::string& id,
       const MediaConstraintsInterface* constraints,
       const PeerConnectionFactory::Options* options,
       const PeerConnectionInterface::RTCConfiguration* config,
       rtc::Thread* network_thread,
       rtc::Thread* worker_thread) {
     std::unique_ptr<FakeRTCCertificateGenerator> cert_generator(
-        new FakeRTCCertificateGenerator());
+        rtc::SSLStreamAdapter::HaveDtlsSrtp() ?
+            new FakeRTCCertificateGenerator() : nullptr);
 
     return CreateClientWithDtlsIdentityStore(id, constraints, options, config,
                                              std::move(cert_generator), true,
                                              network_thread, worker_thread);
   }
 
   static PeerConnectionTestClient* CreateClientPreferNoConstraints(
       const std::string& id,
       const PeerConnectionFactory::Options* options,
       rtc::Thread* network_thread,
       rtc::Thread* worker_thread) {
     std::unique_ptr<FakeRTCCertificateGenerator> cert_generator(
-        new FakeRTCCertificateGenerator());
+        rtc::SSLStreamAdapter::HaveDtlsSrtp() ?
+            new FakeRTCCertificateGenerator() : nullptr);
 
     return CreateClientWithDtlsIdentityStore(id, nullptr, options, nullptr,
                                              std::move(cert_generator), false,
                                              network_thread, worker_thread);
   }
 
   ~PeerConnectionTestClient() {
   }
 
   void Negotiate() { Negotiate(true, true); }
@@ skipping 1213 matching lines @@
     EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceGatheringComplete,
                    receiving_client_->ice_gathering_state(),
                    kMaxWaitForFramesMs);
 
     // Check that the expected number of frames have arrived.
     EXPECT_TRUE_WAIT(FramesHaveArrived(audio_frame_count, video_frame_count),
                      kMaxWaitForFramesMs);
   }
 
   void SetupAndVerifyDtlsCall() {
+    MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
     FakeConstraints setup_constraints;
     setup_constraints.AddMandatory(MediaConstraintsInterface::kEnableDtlsSrtp,
                                    true);
     // Disable resolution adaptation, we don't want it interfering with the
     // test results.
     webrtc::PeerConnectionInterface::RTCConfiguration rtc_config;
     rtc_config.set_cpu_adaptation(false);
 
     ASSERT_TRUE(CreateTestClients(&setup_constraints, nullptr, &rtc_config,
                                   &setup_constraints, nullptr, &rtc_config));
     LocalP2PTest();
     VerifyRenderedAspectRatio(640, 480);
   }
 
   PeerConnectionTestClient* CreateDtlsClientWithAlternateKey() {
     FakeConstraints setup_constraints;
     setup_constraints.AddMandatory(MediaConstraintsInterface::kEnableDtlsSrtp,
                                    true);
     // Disable resolution adaptation, we don't want it interfering with the
     // test results.
     webrtc::PeerConnectionInterface::RTCConfiguration rtc_config;
     rtc_config.set_cpu_adaptation(false);
 
     std::unique_ptr<FakeRTCCertificateGenerator> cert_generator(
-        new FakeRTCCertificateGenerator());
+        rtc::SSLStreamAdapter::HaveDtlsSrtp() ?
+            new FakeRTCCertificateGenerator() : nullptr);
     cert_generator->use_alternate_key();
 
     // Make sure the new client is using a different certificate.
     return PeerConnectionTestClient::CreateClientWithDtlsIdentityStore(
         "New Peer: ", &setup_constraints, nullptr, &rtc_config,
         std::move(cert_generator), prefer_constraint_apis_,
         network_thread_.get(), worker_thread_.get());
   }
 
   void SendRtpData(webrtc::DataChannelInterface* dc, const std::string& data) {
@@ skipping 175 matching lines @@
 
 TEST_F(P2PTestConductor, OneWayMediaCallWithoutConstraints) {
   ASSERT_TRUE(CreateTestClientsThatPreferNoConstraints());
   receiving_client()->set_auto_add_stream(false);
   LocalP2PTest();
 }
 
 // This test sets up a audio call initially and then upgrades to audio/video,
 // using DTLS.
 TEST_F(P2PTestConductor, LocalP2PTestDtlsRenegotiate) {
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   FakeConstraints setup_constraints;
   setup_constraints.AddMandatory(MediaConstraintsInterface::kEnableDtlsSrtp,
                                  true);
   ASSERT_TRUE(CreateTestClients(&setup_constraints, &setup_constraints));
   receiving_client()->SetReceiveAudioVideo(true, false);
   LocalP2PTest();
   receiving_client()->SetReceiveAudioVideo(true, true);
   receiving_client()->Negotiate();
 }
 
 // This test sets up a call transfer to a new caller with a different DTLS
 // fingerprint.
 TEST_F(P2PTestConductor, LocalP2PTestDtlsTransferCallee) {
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   SetupAndVerifyDtlsCall();
 
   // Keeping the original peer around which will still send packets to the
   // receiving client. These SRTP packets will be dropped.
   std::unique_ptr<PeerConnectionTestClient> original_peer(
       set_initializing_client(CreateDtlsClientWithAlternateKey()));
   original_peer->pc()->Close();
 
   SetSignalingReceivers();
   receiving_client()->SetExpectIceRestart(true);
   LocalP2PTest();
   VerifyRenderedAspectRatio(640, 480);
 }
 
 // This test sets up a non-bundle call and apply bundle during ICE restart. When
 // bundle is in effect in the restart, the channel can successfully reset its
 // DTLS-SRTP context.
 TEST_F(P2PTestConductor, LocalP2PTestDtlsBundleInIceRestart) {
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   FakeConstraints setup_constraints;
   setup_constraints.AddMandatory(MediaConstraintsInterface::kEnableDtlsSrtp,
                                  true);
   ASSERT_TRUE(CreateTestClients(&setup_constraints, &setup_constraints));
   receiving_client()->RemoveBundleFromReceivedSdp(true);
   LocalP2PTest();
   VerifyRenderedAspectRatio(640, 480);
 
   initializing_client()->IceRestart();
   receiving_client()->SetExpectIceRestart(true);
   receiving_client()->RemoveBundleFromReceivedSdp(false);
   LocalP2PTest();
   VerifyRenderedAspectRatio(640, 480);
 }
 
 // This test sets up a call transfer to a new callee with a different DTLS
 // fingerprint.
 TEST_F(P2PTestConductor, LocalP2PTestDtlsTransferCaller) {
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   SetupAndVerifyDtlsCall();
 
   // Keeping the original peer around which will still send packets to the
   // receiving client. These SRTP packets will be dropped.
   std::unique_ptr<PeerConnectionTestClient> original_peer(
       set_receiving_client(CreateDtlsClientWithAlternateKey()));
   original_peer->pc()->Close();
 
   SetSignalingReceivers();
   initializing_client()->IceRestart();
@@ skipping 13 matching lines @@
   SetCaptureRotation(webrtc::kVideoRotation_90);
   receiving_client()->RemoveCvoFromReceivedSdp(true);
   LocalP2PTest();
   VerifyRenderedAspectRatio(480, 640, webrtc::kVideoRotation_0);
 }
 
 // This test sets up a call between two endpoints that are configured to use
 // DTLS key agreement. The offerer don't support SDES. As a result, DTLS is
 // negotiated and used for transport.
 TEST_F(P2PTestConductor, LocalP2PTestOfferDtlsButNotSdes) {
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   FakeConstraints setup_constraints;
   setup_constraints.AddMandatory(MediaConstraintsInterface::kEnableDtlsSrtp,
                                  true);
   ASSERT_TRUE(CreateTestClients(&setup_constraints, &setup_constraints));
   receiving_client()->RemoveSdesCryptoFromReceivedSdp(true);
   LocalP2PTest();
   VerifyRenderedAspectRatio(640, 480);
 }
 
 #ifdef HAVE_SCTP
@@ skipping 456 matching lines @@
   EXPECT_TRUE_WAIT(initializing_client()->data_observer()->IsOpen(),
                    kMaxWaitMs);
   EXPECT_TRUE_WAIT(receiving_client()->data_observer()->IsOpen(),
                    kMaxWaitMs);
 }
 
 // This test sets up a Jsep call with SCTP DataChannel and verifies the
 // negotiation is completed without error.
 #ifdef HAVE_SCTP
 TEST_F(P2PTestConductor, CreateOfferWithSctpDataChannel) {
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   FakeConstraints constraints;
   constraints.SetMandatory(
       MediaConstraintsInterface::kEnableDtlsSrtp, true);
   ASSERT_TRUE(CreateTestClients(&constraints, &constraints));
   initializing_client()->CreateDataChannel();
   initializing_client()->Negotiate(false, false);
 }
 #endif
 
 // This test sets up a call between two parties with audio, and video.
@@ skipping 564 matching lines @@
   servers.push_back(server);
   EXPECT_EQ(webrtc::RTCErrorType::NONE,
             webrtc::ParseIceServers(servers, &stun_servers_, &turn_servers_));
   EXPECT_EQ(2U, turn_servers_.size());
   EXPECT_NE(turn_servers_[0].priority, turn_servers_[1].priority);
 }
 
 #endif // if !defined(THREAD_SANITIZER)
 
 }  // namespace