Temporarily rename P2PTestConductor.

talk/app/webrtc/peerconnection_unittest.cc

 /*
  * libjingle
  * Copyright 2012 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 828 matching lines @@
   bool remove_msid_ = false;  // True if MSID should be removed in received SDP.
   bool remove_bundle_ =
       false;  // True if bundle should be removed in received SDP.
   bool remove_sdes_ =
       false;  // True if a=crypto should be removed in received SDP.
 
   rtc::scoped_refptr<DataChannelInterface> data_channel_;
   rtc::scoped_ptr<MockDataChannelObserver> data_observer_;
 };
 
-class P2PTestConductor : public testing::Test {
+// TODO(deadbeef): Rename this to P2PTestConductor once the Linux memcheck and
+// Windows DrMemory Full bots' blacklists are updated.
+class JsepPeerConnectionP2PTestClient : public testing::Test {
  public:
-  P2PTestConductor()
+  JsepPeerConnectionP2PTestClient()
       : pss_(new rtc::PhysicalSocketServer),
         ss_(new rtc::VirtualSocketServer(pss_.get())),
         ss_scope_(ss_.get()) {}
 
   bool SessionActive() {
     return initiating_client_->SessionActive() &&
            receiving_client_->SessionActive();
   }
 
   // Return true if the number of frames provided have been received or it is
@@ skipping 34 matching lines @@
     EXPECT_EQ(height, initializing_client()->rendered_height());
   }
 
   void VerifySessionDescriptions() {
     initiating_client_->VerifyRejectedMediaInSessionDescription();
     receiving_client_->VerifyRejectedMediaInSessionDescription();
     initiating_client_->VerifyLocalIceUfragAndPassword();
     receiving_client_->VerifyLocalIceUfragAndPassword();
   }
 
-  ~P2PTestConductor() {
+  ~JsepPeerConnectionP2PTestClient() {
     if (initiating_client_) {
       initiating_client_->set_signaling_message_receiver(nullptr);
     }
     if (receiving_client_) {
       receiving_client_->set_signaling_message_receiver(nullptr);
     }
   }
 
   bool CreateTestClients() { return CreateTestClients(nullptr, nullptr); }
 
@@ skipping 119 matching lines @@
   rtc::scoped_ptr<PeerConnectionTestClient> receiving_client_;
 };
 
 // Disable for TSan v2, see
 // https://code.google.com/p/webrtc/issues/detail?id=1205 for details.
 #if !defined(THREAD_SANITIZER)
 
 // This test sets up a Jsep call between two parties and test Dtmf.
 // TODO(holmer): Disabled due to sometimes crashing on buildbots.
 // See issue webrtc/2378.
-TEST_F(P2PTestConductor, DISABLED_LocalP2PTestDtmf) {
+TEST_F(JsepPeerConnectionP2PTestClient, DISABLED_LocalP2PTestDtmf) {
   ASSERT_TRUE(CreateTestClients());
   LocalP2PTest();
   VerifyDtmf();
 }
 
 // This test sets up a Jsep call between two parties and test that we can get a
 // video aspect ratio of 16:9.
-TEST_F(P2PTestConductor, LocalP2PTest16To9) {
+TEST_F(JsepPeerConnectionP2PTestClient, LocalP2PTest16To9) {
   ASSERT_TRUE(CreateTestClients());
   FakeConstraints constraint;
   double requested_ratio = 640.0/360;
   constraint.SetMandatoryMinAspectRatio(requested_ratio);
   SetVideoConstraints(constraint, constraint);
   LocalP2PTest();
 
   ASSERT_LE(0, initializing_client()->rendered_height());
   double initiating_video_ratio =
       static_cast<double>(initializing_client()->rendered_width()) /
       initializing_client()->rendered_height();
   EXPECT_LE(requested_ratio, initiating_video_ratio);
 
   ASSERT_LE(0, receiving_client()->rendered_height());
   double receiving_video_ratio =
       static_cast<double>(receiving_client()->rendered_width()) /
       receiving_client()->rendered_height();
   EXPECT_LE(requested_ratio, receiving_video_ratio);
 }
 
 // This test sets up a Jsep call between two parties and test that the
 // received video has a resolution of 1280*720.
 // TODO(mallinath): Enable when
 // http://code.google.com/p/webrtc/issues/detail?id=981 is fixed.
-TEST_F(P2PTestConductor, DISABLED_LocalP2PTest1280By720) {
+TEST_F(JsepPeerConnectionP2PTestClient, DISABLED_LocalP2PTest1280By720) {
   ASSERT_TRUE(CreateTestClients());
   FakeConstraints constraint;
   constraint.SetMandatoryMinWidth(1280);
   constraint.SetMandatoryMinHeight(720);
   SetVideoConstraints(constraint, constraint);
   LocalP2PTest();
   VerifyRenderedSize(1280, 720);
 }
 
 // This test sets up a call between two endpoints that are configured to use
 // DTLS key agreement. As a result, DTLS is negotiated and used for transport.
-TEST_F(P2PTestConductor, LocalP2PTestDtls) {
+TEST_F(JsepPeerConnectionP2PTestClient, LocalP2PTestDtls) {
   MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   FakeConstraints setup_constraints;
   setup_constraints.AddMandatory(MediaConstraintsInterface::kEnableDtlsSrtp,
                                  true);
   ASSERT_TRUE(CreateTestClients(&setup_constraints, &setup_constraints));
   LocalP2PTest();
   VerifyRenderedSize(640, 480);
 }
 
 // This test sets up a audio call initially and then upgrades to audio/video,
 // using DTLS.
-TEST_F(P2PTestConductor, LocalP2PTestDtlsRenegotiate) {
+TEST_F(JsepPeerConnectionP2PTestClient, 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 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) {
+TEST_F(JsepPeerConnectionP2PTestClient, 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();
   VerifyRenderedSize(640, 480);
 }
 
 // This test sets up a Jsep call between two parties, and the callee only
 // accept to receive video.
-TEST_F(P2PTestConductor, LocalP2PTestAnswerVideo) {
+TEST_F(JsepPeerConnectionP2PTestClient, LocalP2PTestAnswerVideo) {
   ASSERT_TRUE(CreateTestClients());
   receiving_client()->SetReceiveAudioVideo(false, true);
   LocalP2PTest();
 }
 
 // This test sets up a Jsep call between two parties, and the callee only
 // accept to receive audio.
-TEST_F(P2PTestConductor, LocalP2PTestAnswerAudio) {
+TEST_F(JsepPeerConnectionP2PTestClient, LocalP2PTestAnswerAudio) {
   ASSERT_TRUE(CreateTestClients());
   receiving_client()->SetReceiveAudioVideo(true, false);
   LocalP2PTest();
 }
 
 // This test sets up a Jsep call between two parties, and the callee reject both
 // audio and video.
-TEST_F(P2PTestConductor, LocalP2PTestAnswerNone) {
+TEST_F(JsepPeerConnectionP2PTestClient, LocalP2PTestAnswerNone) {
   ASSERT_TRUE(CreateTestClients());
   receiving_client()->SetReceiveAudioVideo(false, false);
   LocalP2PTest();
 }
 
 // This test sets up an audio and video call between two parties. After the call
 // runs for a while (10 frames), the caller sends an update offer with video
 // being rejected. Once the re-negotiation is done, the video flow should stop
 // and the audio flow should continue.
 // Disabled due to b/14955157.
-TEST_F(P2PTestConductor, DISABLED_UpdateOfferWithRejectedContent) {
+TEST_F(JsepPeerConnectionP2PTestClient,
+       DISABLED_UpdateOfferWithRejectedContent) {
   ASSERT_TRUE(CreateTestClients());
   LocalP2PTest();
   TestUpdateOfferWithRejectedContent();
 }
 
 // This test sets up a Jsep call between two parties. The MSID is removed from
 // the SDP strings from the caller.
 // Disabled due to b/14955157.
-TEST_F(P2PTestConductor, DISABLED_LocalP2PTestWithoutMsid) {
+TEST_F(JsepPeerConnectionP2PTestClient, DISABLED_LocalP2PTestWithoutMsid) {
   ASSERT_TRUE(CreateTestClients());
   receiving_client()->RemoveMsidFromReceivedSdp(true);
   // TODO(perkj): Currently there is a bug that cause audio to stop playing if
   // audio and video is muxed when MSID is disabled. Remove
   // SetRemoveBundleFromSdp once
   // https://code.google.com/p/webrtc/issues/detail?id=1193 is fixed.
   receiving_client()->RemoveBundleFromReceivedSdp(true);
   LocalP2PTest();
 }
 
 // This test sets up a Jsep call between two parties and the initiating peer
 // sends two steams.
 // TODO(perkj): Disabled due to
 // https://code.google.com/p/webrtc/issues/detail?id=1454
-TEST_F(P2PTestConductor, DISABLED_LocalP2PTestTwoStreams) {
+TEST_F(JsepPeerConnectionP2PTestClient, DISABLED_LocalP2PTestTwoStreams) {
   ASSERT_TRUE(CreateTestClients());
   // Set optional video constraint to max 320pixels to decrease CPU usage.
   FakeConstraints constraint;
   constraint.SetOptionalMaxWidth(320);
   SetVideoConstraints(constraint, constraint);
   initializing_client()->AddMediaStream(true, true);
   initializing_client()->AddMediaStream(false, true);
   ASSERT_EQ(2u, initializing_client()->NumberOfLocalMediaStreams());
   LocalP2PTest();
   EXPECT_EQ(2u, receiving_client()->number_of_remote_streams());
 }
 
 // Test that we can receive the audio output level from a remote audio track.
-TEST_F(P2PTestConductor, GetAudioOutputLevelStats) {
+TEST_F(JsepPeerConnectionP2PTestClient, GetAudioOutputLevelStats) {
   ASSERT_TRUE(CreateTestClients());
   LocalP2PTest();
 
   StreamCollectionInterface* remote_streams =
       initializing_client()->remote_streams();
   ASSERT_GT(remote_streams->count(), 0u);
   ASSERT_GT(remote_streams->at(0)->GetAudioTracks().size(), 0u);
   MediaStreamTrackInterface* remote_audio_track =
       remote_streams->at(0)->GetAudioTracks()[0];
 
   // Get the audio output level stats. Note that the level is not available
   // until a RTCP packet has been received.
   EXPECT_TRUE_WAIT(
       initializing_client()->GetAudioOutputLevelStats(remote_audio_track) > 0,
       kMaxWaitForStatsMs);
 }
 
 // Test that an audio input level is reported.
-TEST_F(P2PTestConductor, GetAudioInputLevelStats) {
+TEST_F(JsepPeerConnectionP2PTestClient, GetAudioInputLevelStats) {
   ASSERT_TRUE(CreateTestClients());
   LocalP2PTest();
 
   // Get the audio input level stats.  The level should be available very
   // soon after the test starts.
   EXPECT_TRUE_WAIT(initializing_client()->GetAudioInputLevelStats() > 0,
       kMaxWaitForStatsMs);
 }
 
 // Test that we can get incoming byte counts from both audio and video tracks.
-TEST_F(P2PTestConductor, GetBytesReceivedStats) {
+TEST_F(JsepPeerConnectionP2PTestClient, GetBytesReceivedStats) {
   ASSERT_TRUE(CreateTestClients());
   LocalP2PTest();
 
   StreamCollectionInterface* remote_streams =
       initializing_client()->remote_streams();
   ASSERT_GT(remote_streams->count(), 0u);
   ASSERT_GT(remote_streams->at(0)->GetAudioTracks().size(), 0u);
   MediaStreamTrackInterface* remote_audio_track =
       remote_streams->at(0)->GetAudioTracks()[0];
   EXPECT_TRUE_WAIT(
       initializing_client()->GetBytesReceivedStats(remote_audio_track) > 0,
       kMaxWaitForStatsMs);
 
   MediaStreamTrackInterface* remote_video_track =
       remote_streams->at(0)->GetVideoTracks()[0];
   EXPECT_TRUE_WAIT(
       initializing_client()->GetBytesReceivedStats(remote_video_track) > 0,
       kMaxWaitForStatsMs);
 }
 
 // Test that we can get outgoing byte counts from both audio and video tracks.
-TEST_F(P2PTestConductor, GetBytesSentStats) {
+TEST_F(JsepPeerConnectionP2PTestClient, GetBytesSentStats) {
   ASSERT_TRUE(CreateTestClients());
   LocalP2PTest();
 
   StreamCollectionInterface* local_streams =
       initializing_client()->local_streams();
   ASSERT_GT(local_streams->count(), 0u);
   ASSERT_GT(local_streams->at(0)->GetAudioTracks().size(), 0u);
   MediaStreamTrackInterface* local_audio_track =
       local_streams->at(0)->GetAudioTracks()[0];
   EXPECT_TRUE_WAIT(
       initializing_client()->GetBytesSentStats(local_audio_track) > 0,
       kMaxWaitForStatsMs);
 
   MediaStreamTrackInterface* local_video_track =
       local_streams->at(0)->GetVideoTracks()[0];
   EXPECT_TRUE_WAIT(
       initializing_client()->GetBytesSentStats(local_video_track) > 0,
       kMaxWaitForStatsMs);
 }
 
 // Test that DTLS 1.0 is used if both sides only support DTLS 1.0.
-TEST_F(P2PTestConductor, GetDtls12None) {
+TEST_F(JsepPeerConnectionP2PTestClient, GetDtls12None) {
   PeerConnectionFactory::Options init_options;
   init_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_10;
   PeerConnectionFactory::Options recv_options;
   recv_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_10;
   ASSERT_TRUE(
       CreateTestClients(nullptr, &init_options, nullptr, &recv_options));
   rtc::scoped_refptr<webrtc::FakeMetricsObserver>
       init_observer = new rtc::RefCountedObject<webrtc::FakeMetricsObserver>();
   initializing_client()->pc()->RegisterUMAObserver(init_observer);
   LocalP2PTest();
@@ skipping 10 matching lines @@
 
   EXPECT_EQ_WAIT(kDefaultSrtpCipher,
                  initializing_client()->GetSrtpCipherStats(),
                  kMaxWaitForStatsMs);
   EXPECT_EQ(1, init_observer->GetEnumCounter(
                    webrtc::kEnumCounterAudioSrtpCipher,
                    rtc::GetSrtpCryptoSuiteFromName(kDefaultSrtpCipher)));
 }
 
 // Test that DTLS 1.2 is used if both ends support it.
-TEST_F(P2PTestConductor, GetDtls12Both) {
+TEST_F(JsepPeerConnectionP2PTestClient, GetDtls12Both) {
   PeerConnectionFactory::Options init_options;
   init_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_12;
   PeerConnectionFactory::Options recv_options;
   recv_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_12;
   ASSERT_TRUE(
       CreateTestClients(nullptr, &init_options, nullptr, &recv_options));
   rtc::scoped_refptr<webrtc::FakeMetricsObserver>
       init_observer = new rtc::RefCountedObject<webrtc::FakeMetricsObserver>();
   initializing_client()->pc()->RegisterUMAObserver(init_observer);
   LocalP2PTest();
@@ skipping 11 matching lines @@
   EXPECT_EQ_WAIT(kDefaultSrtpCipher,
                  initializing_client()->GetSrtpCipherStats(),
                  kMaxWaitForStatsMs);
   EXPECT_EQ(1, init_observer->GetEnumCounter(
                    webrtc::kEnumCounterAudioSrtpCipher,
                    rtc::GetSrtpCryptoSuiteFromName(kDefaultSrtpCipher)));
 }
 
 // Test that DTLS 1.0 is used if the initator supports DTLS 1.2 and the
 // received supports 1.0.
-TEST_F(P2PTestConductor, GetDtls12Init) {
+TEST_F(JsepPeerConnectionP2PTestClient, GetDtls12Init) {
   PeerConnectionFactory::Options init_options;
   init_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_12;
   PeerConnectionFactory::Options recv_options;
   recv_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_10;
   ASSERT_TRUE(
       CreateTestClients(nullptr, &init_options, nullptr, &recv_options));
   rtc::scoped_refptr<webrtc::FakeMetricsObserver>
       init_observer = new rtc::RefCountedObject<webrtc::FakeMetricsObserver>();
   initializing_client()->pc()->RegisterUMAObserver(init_observer);
   LocalP2PTest();
@@ skipping 11 matching lines @@
   EXPECT_EQ_WAIT(kDefaultSrtpCipher,
                  initializing_client()->GetSrtpCipherStats(),
                  kMaxWaitForStatsMs);
   EXPECT_EQ(1, init_observer->GetEnumCounter(
                    webrtc::kEnumCounterAudioSrtpCipher,
                    rtc::GetSrtpCryptoSuiteFromName(kDefaultSrtpCipher)));
 }
 
 // Test that DTLS 1.0 is used if the initator supports DTLS 1.0 and the
 // received supports 1.2.
-TEST_F(P2PTestConductor, GetDtls12Recv) {
+TEST_F(JsepPeerConnectionP2PTestClient, GetDtls12Recv) {
   PeerConnectionFactory::Options init_options;
   init_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_10;
   PeerConnectionFactory::Options recv_options;
   recv_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_12;
   ASSERT_TRUE(
       CreateTestClients(nullptr, &init_options, nullptr, &recv_options));
   rtc::scoped_refptr<webrtc::FakeMetricsObserver>
       init_observer = new rtc::RefCountedObject<webrtc::FakeMetricsObserver>();
   initializing_client()->pc()->RegisterUMAObserver(init_observer);
   LocalP2PTest();
@@ skipping 10 matching lines @@
 
   EXPECT_EQ_WAIT(kDefaultSrtpCipher,
                  initializing_client()->GetSrtpCipherStats(),
                  kMaxWaitForStatsMs);
   EXPECT_EQ(1, init_observer->GetEnumCounter(
                    webrtc::kEnumCounterAudioSrtpCipher,
                    rtc::GetSrtpCryptoSuiteFromName(kDefaultSrtpCipher)));
 }
 
 // This test sets up a call between two parties with audio, video and data.
-TEST_F(P2PTestConductor, LocalP2PTestDataChannel) {
+TEST_F(JsepPeerConnectionP2PTestClient, LocalP2PTestDataChannel) {
   FakeConstraints setup_constraints;
   setup_constraints.SetAllowRtpDataChannels();
   ASSERT_TRUE(CreateTestClients(&setup_constraints, &setup_constraints));
   initializing_client()->CreateDataChannel();
   LocalP2PTest();
   ASSERT_TRUE(initializing_client()->data_channel() != nullptr);
   ASSERT_TRUE(receiving_client()->data_channel() != nullptr);
   EXPECT_TRUE_WAIT(initializing_client()->data_observer()->IsOpen(),
                    kMaxWaitMs);
   EXPECT_TRUE_WAIT(receiving_client()->data_observer()->IsOpen(),
@@ skipping 16 matching lines @@
   EXPECT_FALSE(receiving_client()->data_observer()->IsOpen());
 }
 
 // This test sets up a call between two parties and creates a data channel.
 // The test tests that received data is buffered unless an observer has been
 // registered.
 // Rtp data channels can receive data before the underlying
 // transport has detected that a channel is writable and thus data can be
 // received before the data channel state changes to open. That is hard to test
 // but the same buffering is used in that case.
-TEST_F(P2PTestConductor, RegisterDataChannelObserver) {
+TEST_F(JsepPeerConnectionP2PTestClient, RegisterDataChannelObserver) {
   FakeConstraints setup_constraints;
   setup_constraints.SetAllowRtpDataChannels();
   ASSERT_TRUE(CreateTestClients(&setup_constraints, &setup_constraints));
   initializing_client()->CreateDataChannel();
   initializing_client()->Negotiate();
 
   ASSERT_TRUE(initializing_client()->data_channel() != nullptr);
   ASSERT_TRUE(receiving_client()->data_channel() != nullptr);
   EXPECT_TRUE_WAIT(initializing_client()->data_observer()->IsOpen(),
                    kMaxWaitMs);
   EXPECT_EQ_WAIT(DataChannelInterface::kOpen,
                  receiving_client()->data_channel()->state(), kMaxWaitMs);
 
   // Unregister the existing observer.
   receiving_client()->data_channel()->UnregisterObserver();
 
   std::string data = "hello world";
   SendRtpData(initializing_client()->data_channel(), data);
 
   // Wait a while to allow the sent data to arrive before an observer is
   // registered..
   rtc::Thread::Current()->ProcessMessages(100);
 
   MockDataChannelObserver new_observer(receiving_client()->data_channel());
   EXPECT_EQ_WAIT(data, new_observer.last_message(), kMaxWaitMs);
 }
 
 // This test sets up a call between two parties with audio, video and but only
 // the initiating client support data.
-TEST_F(P2PTestConductor, LocalP2PTestReceiverDoesntSupportData) {
+TEST_F(JsepPeerConnectionP2PTestClient, LocalP2PTestReceiverDoesntSupportData) {
   FakeConstraints setup_constraints_1;
   setup_constraints_1.SetAllowRtpDataChannels();
   // Must disable DTLS to make negotiation succeed.
   setup_constraints_1.SetMandatory(
       MediaConstraintsInterface::kEnableDtlsSrtp, false);
   FakeConstraints setup_constraints_2;
   setup_constraints_2.SetMandatory(
       MediaConstraintsInterface::kEnableDtlsSrtp, false);
   ASSERT_TRUE(CreateTestClients(&setup_constraints_1, &setup_constraints_2));
   initializing_client()->CreateDataChannel();
   LocalP2PTest();
   EXPECT_TRUE(initializing_client()->data_channel() != nullptr);
   EXPECT_FALSE(receiving_client()->data_channel());
   EXPECT_FALSE(initializing_client()->data_observer()->IsOpen());
 }
 
 // This test sets up a call between two parties with audio, video. When audio
 // and video is setup and flowing and data channel is negotiated.
-TEST_F(P2PTestConductor, AddDataChannelAfterRenegotiation) {
+TEST_F(JsepPeerConnectionP2PTestClient, AddDataChannelAfterRenegotiation) {
   FakeConstraints setup_constraints;
   setup_constraints.SetAllowRtpDataChannels();
   ASSERT_TRUE(CreateTestClients(&setup_constraints, &setup_constraints));
   LocalP2PTest();
   initializing_client()->CreateDataChannel();
   // Send new offer and answer.
   initializing_client()->Negotiate();
   ASSERT_TRUE(initializing_client()->data_channel() != nullptr);
   ASSERT_TRUE(receiving_client()->data_channel() != nullptr);
   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) {
+TEST_F(JsepPeerConnectionP2PTestClient, 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.
 // During the call, the initializing side restart ice and the test verifies that
 // new ice candidates are generated and audio and video still can flow.
-TEST_F(P2PTestConductor, IceRestart) {
+TEST_F(JsepPeerConnectionP2PTestClient, IceRestart) {
   ASSERT_TRUE(CreateTestClients());
 
   // Negotiate and wait for ice completion and make sure audio and video plays.
   LocalP2PTest();
 
   // Create a SDP string of the first audio candidate for both clients.
   const webrtc::IceCandidateCollection* audio_candidates_initiator =
       initializing_client()->pc()->local_description()->candidates(0);
   const webrtc::IceCandidateCollection* audio_candidates_receiver =
       receiving_client()->pc()->local_description()->candidates(0);
@@ skipping 30 matching lines @@
   // Verify that the first candidates in the local session descriptions has
   // changed.
   EXPECT_NE(initiator_candidate, initiator_candidate_restart);
   EXPECT_NE(receiver_candidate, receiver_candidate_restart);
 }
 
 // This test sets up a Jsep call between two parties with external
 // VideoDecoderFactory.
 // TODO(holmer): Disabled due to sometimes crashing on buildbots.
 // See issue webrtc/2378.
-TEST_F(P2PTestConductor, DISABLED_LocalP2PTestWithVideoDecoderFactory) {
+TEST_F(JsepPeerConnectionP2PTestClient,
+       DISABLED_LocalP2PTestWithVideoDecoderFactory) {
   ASSERT_TRUE(CreateTestClients());
   EnableVideoDecoderFactory();
   LocalP2PTest();
 }
 
 class IceServerParsingTest : public testing::Test {
  public:
   // Convenience for parsing a single URL.
   bool ParseUrl(const std::string& url) {
     return ParseUrl(url, std::string(), std::string());
@@ skipping 162 matching lines @@
   server.urls.push_back("stun:hostname");
   server.urls.push_back("turn:hostname");
   servers.push_back(server);
   EXPECT_TRUE(webrtc::ParseIceServers(servers, &stun_configurations_,
                                       &turn_configurations_));
   EXPECT_EQ(1U, stun_configurations_.size());
   EXPECT_EQ(1U, turn_configurations_.size());
 }
 
 #endif // if !defined(THREAD_SANITIZER)