Adding an end-to-end connection time test.

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 12 matching lines @@
 #include "webrtc/api/mediastreaminterface.h"
 #include "webrtc/api/peerconnection.h"
 #include "webrtc/api/peerconnectionfactory.h"
 #include "webrtc/api/peerconnectioninterface.h"
 #include "webrtc/api/test/fakeaudiocapturemodule.h"
 #include "webrtc/api/test/fakeconstraints.h"
 #include "webrtc/api/test/fakeperiodicvideocapturer.h"
 #include "webrtc/api/test/fakertccertificategenerator.h"
 #include "webrtc/api/test/fakevideotrackrenderer.h"
 #include "webrtc/api/test/mockpeerconnectionobservers.h"
+#include "webrtc/base/fakenetwork.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/physicalsocketserver.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/sslstreamadapter.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/virtualsocketserver.h"
 #include "webrtc/media/engine/fakewebrtcvideoengine.h"
-#include "webrtc/p2p/base/fakeportallocator.h"
 #include "webrtc/p2p/base/p2pconstants.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;
@@ skipping 42 matching lines @@
 
 // Disable for TSan v2, see
 // https://code.google.com/p/webrtc/issues/detail?id=1205 for details.
 // This declaration is also #ifdef'd as it causes unused-variable errors.
 #if !defined(THREAD_SANITIZER)
 // SRTP cipher name negotiated by the tests. This must be updated if the
 // default changes.
 static const int kDefaultSrtpCryptoSuite = rtc::SRTP_AES128_CM_SHA1_32;
 #endif
 
+// Used to simulate signaling ICE/SDP between two PeerConnections.
+enum { MSG_SDP_MESSAGE, MSG_ICE_MESSAGE };
+
 static void RemoveLinesFromSdp(const std::string& line_start,
                                std::string* sdp) {
   const char kSdpLineEnd[] = "\r\n";
   size_t ssrc_pos = 0;
   while ((ssrc_pos = sdp->find(line_start, ssrc_pos)) !=
       std::string::npos) {
     size_t end_ssrc = sdp->find(kSdpLineEnd, ssrc_pos);
     sdp->erase(ssrc_pos, end_ssrc - ssrc_pos + strlen(kSdpLineEnd));
   }
 }
@@ skipping 45 matching lines @@
 
   virtual ~MockRtpReceiverObserver() {}
 
  private:
   bool first_packet_received_ = false;
   cricket::MediaType expected_media_type_;
 };
 
 class PeerConnectionTestClient : public webrtc::PeerConnectionObserver,
                                  public SignalingMessageReceiver,
-                                 public ObserverInterface {
+                                 public ObserverInterface,
+                                 public rtc::MessageHandler {
  public:
+  // If |config| is not provided, uses a default constructed RTCConfiguration.
   static PeerConnectionTestClient* CreateClientWithDtlsIdentityStore(
       const std::string& id,
       const MediaConstraintsInterface* constraints,
+      const webrtc::PeerConnectionInterface::RTCConfiguration* config,
       const PeerConnectionFactory::Options* options,
       std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
       bool prefer_constraint_apis,
       rtc::Thread* network_thread,
       rtc::Thread* worker_thread) {
     PeerConnectionTestClient* client(new PeerConnectionTestClient(id));
-    if (!client->Init(constraints, options, std::move(cert_generator),
+    if (!client->Init(constraints, config, options, std::move(cert_generator),
                       prefer_constraint_apis, network_thread, worker_thread)) {
       delete client;
       return nullptr;
     }
     return client;
   }
 
   static PeerConnectionTestClient* CreateClient(
       const std::string& id,
       const MediaConstraintsInterface* constraints,
+      const webrtc::PeerConnectionInterface::RTCConfiguration* config,
       const PeerConnectionFactory::Options* options,
       rtc::Thread* network_thread,
       rtc::Thread* worker_thread) {
     std::unique_ptr<FakeRTCCertificateGenerator> cert_generator(
         rtc::SSLStreamAdapter::HaveDtlsSrtp() ?
             new FakeRTCCertificateGenerator() : nullptr);
 
-    return CreateClientWithDtlsIdentityStore(
-        id, constraints, options, std::move(cert_generator), true,
-        network_thread, worker_thread);
+    return CreateClientWithDtlsIdentityStore(id, constraints, config, options,
+                                             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(
         rtc::SSLStreamAdapter::HaveDtlsSrtp() ?
             new FakeRTCCertificateGenerator() : nullptr);
 
-    return CreateClientWithDtlsIdentityStore(
-        id, nullptr, options, std::move(cert_generator), false,
-        network_thread, worker_thread);
+    return CreateClientWithDtlsIdentityStore(id, nullptr, nullptr, options,
+                                             std::move(cert_generator), false,
+                                             network_thread, worker_thread);
   }
 
   ~PeerConnectionTestClient() {
   }
 
   void Negotiate() { Negotiate(true, true); }
 
   void Negotiate(bool audio, bool video) {
     std::unique_ptr<SessionDescriptionInterface> offer;
     ASSERT_TRUE(DoCreateOffer(&offer));
 
     if (offer->description()->GetContentByName("audio")) {
       offer->description()->GetContentByName("audio")->rejected = !audio;
     }
     if (offer->description()->GetContentByName("video")) {
       offer->description()->GetContentByName("video")->rejected = !video;
     }
 
     std::string sdp;
     EXPECT_TRUE(offer->ToString(&sdp));
     EXPECT_TRUE(DoSetLocalDescription(offer.release()));
-    signaling_message_receiver_->ReceiveSdpMessage(
-        webrtc::SessionDescriptionInterface::kOffer, sdp);
+    SendSdpMessage(webrtc::SessionDescriptionInterface::kOffer, sdp);
+  }
+
+  typedef std::pair<std::string, std::string> SdpMessage;
+  void SendSdpMessage(const std::string& type, std::string& msg) {
+    if (signaling_delay_ms_ == 0) {
+      if (signaling_message_receiver_) {
+        signaling_message_receiver_->ReceiveSdpMessage(type, msg);
+      }
+    } else {
+      rtc::Thread::Current()->PostDelayed(
+          RTC_FROM_HERE, signaling_delay_ms_, this, MSG_SDP_MESSAGE,
+          new rtc::TypedMessageData<SdpMessage>(SdpMessage(type, msg)));
+    }
+  }
+
+  typedef std::tuple<std::string, int, std::string> IceMessage;
+  void SendIceMessage(const std::string& sdp_mid,
+                      int sdp_mline_index,
+                      const std::string& msg) {
+    if (signaling_delay_ms_ == 0) {
+      if (signaling_message_receiver_) {
+        signaling_message_receiver_->ReceiveIceMessage(sdp_mid, sdp_mline_index,
+                                                       msg);
+      }
+    } else {
+      rtc::Thread::Current()->PostDelayed(
+          RTC_FROM_HERE, signaling_delay_ms_, this, MSG_ICE_MESSAGE,
+          new rtc::TypedMessageData<IceMessage>(
+              IceMessage(sdp_mid, sdp_mline_index, msg)));
+    }
+  }
+
+  // MessageHandler callback.
+  void OnMessage(rtc::Message* msg) override {
+    switch (msg->message_id) {
+      case MSG_SDP_MESSAGE: {
+        auto sdp_message =
+            static_cast<rtc::TypedMessageData<SdpMessage>*>(msg->pdata);
+        if (signaling_message_receiver_) {
+          signaling_message_receiver_->ReceiveSdpMessage(
+              std::get<0>(sdp_message->data()),
+              std::get<1>(sdp_message->data()));
+        }
+        delete sdp_message;
+        break;
+      }
+      case MSG_ICE_MESSAGE: {
+        auto ice_message =
+            static_cast<rtc::TypedMessageData<IceMessage>*>(msg->pdata);
+        if (signaling_message_receiver_) {
+          signaling_message_receiver_->ReceiveIceMessage(
+              std::get<0>(ice_message->data()),
+              std::get<1>(ice_message->data()),
+              std::get<2>(ice_message->data()));
+        }
+        delete ice_message;
+        break;
+      }
+      default:
+        RTC_CHECK(false);
+    }
   }
 
   // SignalingMessageReceiver callback.
   void ReceiveSdpMessage(const std::string& type, std::string& msg) override {
     FilterIncomingSdpMessage(&msg);
     if (type == webrtc::SessionDescriptionInterface::kOffer) {
       HandleIncomingOffer(msg);
     } else {
       HandleIncomingAnswer(msg);
     }
@@ skipping 38 matching lines @@
   }
   void OnIceCandidate(const webrtc::IceCandidateInterface* candidate) override {
     LOG(INFO) << id_ << "OnIceCandidate";
 
     std::string ice_sdp;
     EXPECT_TRUE(candidate->ToString(&ice_sdp));
     if (signaling_message_receiver_ == nullptr) {
       // Remote party may be deleted.
       return;
     }
-    signaling_message_receiver_->ReceiveIceMessage(
-        candidate->sdp_mid(), candidate->sdp_mline_index(), ice_sdp);
+    SendIceMessage(candidate->sdp_mid(), candidate->sdp_mline_index(), ice_sdp);
   }
 
   // MediaStreamInterface callback
   void OnChanged() override {
     // Track added or removed from MediaStream, so update our renderers.
     rtc::scoped_refptr<StreamCollectionInterface> remote_streams =
         pc()->remote_streams();
     // Remove renderers for tracks that were removed.
     for (auto it = fake_video_renderers_.begin();
          it != fake_video_renderers_.end();) {
@@ skipping 54 matching lines @@
   // Defaults to true.
   void set_auto_add_stream(bool auto_add_stream) {
     auto_add_stream_ = auto_add_stream;
   }
 
   void set_signaling_message_receiver(
       SignalingMessageReceiver* signaling_message_receiver) {
     signaling_message_receiver_ = signaling_message_receiver;
   }
 
+  void set_signaling_delay_ms(int delay_ms) { signaling_delay_ms_ = delay_ms; }
+
   void EnableVideoDecoderFactory() {
     video_decoder_factory_enabled_ = true;
     fake_video_decoder_factory_->AddSupportedVideoCodecType(
         webrtc::kVideoCodecVP8);
   }
 
   void IceRestart() {
     offer_answer_constraints_.SetMandatoryIceRestart(true);
     offer_answer_options_.ice_restart = true;
     SetExpectIceRestart(true);
   }
 
   void SetExpectIceRestart(bool expect_restart) {
     expect_ice_restart_ = expect_restart;
   }
 
   bool ExpectIceRestart() const { return expect_ice_restart_; }
 
+  // Below 3 methods assume streams will be offered.
+  // Thus they'll only set the "offer to receive" flag to true if it's
+  // currently false, not if it's just unset.
   void SetReceiveAudioVideo(bool audio, bool video) {
     SetReceiveAudio(audio);
     SetReceiveVideo(video);
     ASSERT_EQ(audio, can_receive_audio());
     ASSERT_EQ(video, can_receive_video());
   }
 
   void SetReceiveAudio(bool audio) {
-    if (audio && can_receive_audio())
+    if (audio && can_receive_audio()) {
       return;
+    }
     offer_answer_constraints_.SetMandatoryReceiveAudio(audio);
     offer_answer_options_.offer_to_receive_audio = audio ? 1 : 0;
   }
 
   void SetReceiveVideo(bool video) {
-    if (video && can_receive_video())
+    if (video && can_receive_video()) {
       return;
+    }
     offer_answer_constraints_.SetMandatoryReceiveVideo(video);
     offer_answer_options_.offer_to_receive_video = video ? 1 : 0;
   }
+
+  void SetOfferToReceiveAudioVideo(bool audio, bool video) {
+    offer_answer_constraints_.SetMandatoryReceiveAudio(audio);
+    offer_answer_options_.offer_to_receive_audio = audio ? 1 : 0;
+    offer_answer_constraints_.SetMandatoryReceiveVideo(video);
+    offer_answer_options_.offer_to_receive_video = video ? 1 : 0;
+  }
 
   void RemoveMsidFromReceivedSdp(bool remove) { remove_msid_ = remove; }
 
   void RemoveSdesCryptoFromReceivedSdp(bool remove) { remove_sdes_ = remove; }
 
   void RemoveBundleFromReceivedSdp(bool remove) { remove_bundle_ = remove; }
 
   void RemoveCvoFromReceivedSdp(bool remove) { remove_cvo_ = remove; }
 
   bool can_receive_audio() {
@@ skipping 415 matching lines @@
 
    private:
     bool completed_;
     std::vector<std::string> tones_;
   };
 
   explicit PeerConnectionTestClient(const std::string& id) : id_(id) {}
 
   bool Init(
       const MediaConstraintsInterface* constraints,
+      const webrtc::PeerConnectionInterface::RTCConfiguration* config,
       const PeerConnectionFactory::Options* options,
       std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
       bool prefer_constraint_apis,
       rtc::Thread* network_thread,
       rtc::Thread* worker_thread) {
     EXPECT_TRUE(!peer_connection_);
     EXPECT_TRUE(!peer_connection_factory_);
     if (!prefer_constraint_apis) {
       EXPECT_TRUE(!constraints);
     }
     prefer_constraint_apis_ = prefer_constraint_apis;
 
+    fake_network_manager_.reset(new rtc::FakeNetworkManager());
+    fake_network_manager_->AddInterface(rtc::SocketAddress("192.168.1.1", 0));
+
     std::unique_ptr<cricket::PortAllocator> port_allocator(
-        new cricket::FakePortAllocator(network_thread, nullptr));
+        new cricket::BasicPortAllocator(fake_network_manager_.get()));

[Taylor Brandstetter, 2016/07/12 19:33:34]

Switched to using a BasicPortAllocator so we can test TURN connections as well.
Note that we're still using a virtual network.

     fake_audio_capture_module_ = FakeAudioCaptureModule::Create();
 
     if (fake_audio_capture_module_ == nullptr) {
       return false;
     }
     fake_video_decoder_factory_ = new FakeWebRtcVideoDecoderFactory();
     fake_video_encoder_factory_ = new FakeWebRtcVideoEncoderFactory();
     rtc::Thread* const signaling_thread = rtc::Thread::Current();
     peer_connection_factory_ = webrtc::CreatePeerConnectionFactory(
         network_thread, worker_thread, signaling_thread,
         fake_audio_capture_module_, fake_video_encoder_factory_,
         fake_video_decoder_factory_);
     if (!peer_connection_factory_) {
       return false;
     }
     if (options) {
       peer_connection_factory_->SetOptions(*options);
     }
-    peer_connection_ = CreatePeerConnection(
-        std::move(port_allocator), constraints, std::move(cert_generator));
+    peer_connection_ =
+        CreatePeerConnection(std::move(port_allocator), constraints, config,
+                             std::move(cert_generator));
     return peer_connection_.get() != nullptr;
   }
 
   rtc::scoped_refptr<webrtc::PeerConnectionInterface> CreatePeerConnection(
       std::unique_ptr<cricket::PortAllocator> port_allocator,
       const MediaConstraintsInterface* constraints,
+      const webrtc::PeerConnectionInterface::RTCConfiguration* config,
       std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator) {
     // CreatePeerConnection with RTCConfiguration.
-    webrtc::PeerConnectionInterface::RTCConfiguration config;
-    webrtc::PeerConnectionInterface::IceServer ice_server;
-    ice_server.uri = "stun:stun.l.google.com:19302";

[Taylor Brandstetter, 2016/07/12 19:33:34]

This STUN server wasn't doing anything since the FakePortAllocator was ignoring
it. Now what I'm using a BasicPortAllocator we actually *don't* want to add an
ICE server. We have separate tests for parsing ICE server strings so I don't
think anything is lost by removing this.

-    config.servers.push_back(ice_server);
+    webrtc::PeerConnectionInterface::RTCConfiguration default_config;
+
+    if (!config) {
+      config = &default_config;
+    }
 
     return peer_connection_factory_->CreatePeerConnection(
-        config, constraints, std::move(port_allocator),
+        *config, constraints, std::move(port_allocator),
         std::move(cert_generator), this);
   }
 
   void HandleIncomingOffer(const std::string& msg) {
     LOG(INFO) << id_ << "HandleIncomingOffer ";
     if (NumberOfLocalMediaStreams() == 0 && auto_add_stream_) {
       // If we are not sending any streams ourselves it is time to add some.
       AddMediaStream(true, true);
     }
     std::unique_ptr<SessionDescriptionInterface> desc(
         webrtc::CreateSessionDescription("offer", msg, nullptr));
     EXPECT_TRUE(DoSetRemoteDescription(desc.release()));
     // Set the RtpReceiverObserver after receivers are created.
     SetRtpReceiverObservers();
     std::unique_ptr<SessionDescriptionInterface> answer;
     EXPECT_TRUE(DoCreateAnswer(&answer));
     std::string sdp;
     EXPECT_TRUE(answer->ToString(&sdp));
     EXPECT_TRUE(DoSetLocalDescription(answer.release()));
-    if (signaling_message_receiver_) {
-      signaling_message_receiver_->ReceiveSdpMessage(
-          webrtc::SessionDescriptionInterface::kAnswer, sdp);
-    }
+    SendSdpMessage(webrtc::SessionDescriptionInterface::kAnswer, sdp);
   }
 
   void HandleIncomingAnswer(const std::string& msg) {
     LOG(INFO) << id_ << "HandleIncomingAnswer";
     std::unique_ptr<SessionDescriptionInterface> desc(
         webrtc::CreateSessionDescription("answer", msg, nullptr));
     EXPECT_TRUE(DoSetRemoteDescription(desc.release()));
     // Set the RtpReceiverObserver after receivers are created.
     SetRtpReceiverObservers();
   }
@@ skipping 80 matching lines @@
       RemoveLinesFromSdp(kSdpSdesCryptoAttribute, sdp);
     }
     if (remove_cvo_) {
       const char kSdpCvoExtenstion[] = "urn:3gpp:video-orientation";
       RemoveLinesFromSdp(kSdpCvoExtenstion, sdp);
     }
   }
 
   std::string id_;
 
+  std::unique_ptr<rtc::FakeNetworkManager> fake_network_manager_;
+
   rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection_;
   rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface>
       peer_connection_factory_;
 
   bool prefer_constraint_apis_ = true;
   bool auto_add_stream_ = true;
 
   typedef std::pair<std::string, std::string> IceUfragPwdPair;
   std::map<int, IceUfragPwdPair> ice_ufrag_pwd_;
   bool expect_ice_restart_ = false;
 
   // Needed to keep track of number of frames sent.
   rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
   // Needed to keep track of number of frames received.
   std::map<std::string, std::unique_ptr<webrtc::FakeVideoTrackRenderer>>
       fake_video_renderers_;
   // Needed to ensure frames aren't received for removed tracks.
   std::vector<std::unique_ptr<webrtc::FakeVideoTrackRenderer>>
       removed_fake_video_renderers_;
   // Needed to keep track of number of frames received when external decoder
   // used.
   FakeWebRtcVideoDecoderFactory* fake_video_decoder_factory_ = nullptr;
   FakeWebRtcVideoEncoderFactory* fake_video_encoder_factory_ = nullptr;
   bool video_decoder_factory_enabled_ = false;
   webrtc::FakeConstraints video_constraints_;
 
   // For remote peer communication.
   SignalingMessageReceiver* signaling_message_receiver_ = nullptr;
+  int signaling_delay_ms_ = 0;
 
   // Store references to the video capturers we've created, so that we can stop
   // them, if required.
   std::vector<cricket::FakeVideoCapturer*> video_capturers_;
   webrtc::VideoRotation capture_rotation_ = webrtc::kVideoRotation_0;
   // |local_video_renderer_| attached to the first created local video track.
   std::unique_ptr<webrtc::FakeVideoTrackRenderer> local_video_renderer_;
 
   webrtc::FakeConstraints offer_answer_constraints_;
   PeerConnectionInterface::RTCOfferAnswerOptions offer_answer_options_;
@@ skipping 116 matching lines @@
     }
     if (receiving_client_) {
       receiving_client_->set_signaling_message_receiver(nullptr);
     }
   }
 
   bool CreateTestClients() { return CreateTestClients(nullptr, nullptr); }
 
   bool CreateTestClients(MediaConstraintsInterface* init_constraints,
                          MediaConstraintsInterface* recv_constraints) {
-    return CreateTestClients(init_constraints, nullptr, recv_constraints,
-                             nullptr);
+    return CreateTestClients(init_constraints, nullptr, nullptr,
+                             recv_constraints, nullptr, nullptr);
   }
 
   bool CreateTestClientsThatPreferNoConstraints() {
     initiating_client_.reset(
         PeerConnectionTestClient::CreateClientPreferNoConstraints(
             "Caller: ", nullptr, network_thread_.get(), worker_thread_.get()));
     receiving_client_.reset(
         PeerConnectionTestClient::CreateClientPreferNoConstraints(
             "Callee: ", nullptr, network_thread_.get(), worker_thread_.get()));
     if (!initiating_client_ || !receiving_client_) {
       return false;
     }
     // Remember the choice for possible later resets of the clients.
     prefer_constraint_apis_ = false;
     SetSignalingReceivers();
     return true;
   }
 
   void SetSignalingReceivers() {
     initiating_client_->set_signaling_message_receiver(receiving_client_.get());
     receiving_client_->set_signaling_message_receiver(initiating_client_.get());
   }
 
-  bool CreateTestClients(MediaConstraintsInterface* init_constraints,
-                         PeerConnectionFactory::Options* init_options,
-                         MediaConstraintsInterface* recv_constraints,
-                         PeerConnectionFactory::Options* recv_options) {
+  void SetSignalingDelayMs(int delay_ms) {
+    initiating_client_->set_signaling_delay_ms(delay_ms);
+    receiving_client_->set_signaling_delay_ms(delay_ms);
+  }
+
+  bool CreateTestClients(
+      MediaConstraintsInterface* init_constraints,
+      const webrtc::PeerConnectionInterface::RTCConfiguration* init_config,
+      PeerConnectionFactory::Options* init_options,
+      MediaConstraintsInterface* recv_constraints,
+      const webrtc::PeerConnectionInterface::RTCConfiguration* recv_config,
+      PeerConnectionFactory::Options* recv_options) {
     initiating_client_.reset(PeerConnectionTestClient::CreateClient(
-        "Caller: ", init_constraints, init_options, network_thread_.get(),
-        worker_thread_.get()));
+        "Caller: ", init_constraints, init_config, init_options,
+        network_thread_.get(), worker_thread_.get()));
     receiving_client_.reset(PeerConnectionTestClient::CreateClient(
-        "Callee: ", recv_constraints, recv_options, network_thread_.get(),
-        worker_thread_.get()));
+        "Callee: ", recv_constraints, recv_config, recv_options,
+        network_thread_.get(), worker_thread_.get()));
     if (!initiating_client_ || !receiving_client_) {
       return false;
     }
     SetSignalingReceivers();
     return true;
   }
 
   void SetVideoConstraints(const webrtc::FakeConstraints& init_constraints,
                            const webrtc::FakeConstraints& recv_constraints) {
     initiating_client_->SetVideoConstraints(init_constraints);
@@ skipping 79 matching lines @@
     setup_constraints.AddMandatory(MediaConstraintsInterface::kEnableDtlsSrtp,
                                    true);
 
     std::unique_ptr<FakeRTCCertificateGenerator> cert_generator(
         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,
+        "New Peer: ", &setup_constraints, nullptr, nullptr,
         std::move(cert_generator), prefer_constraint_apis_,
         network_thread_.get(), worker_thread_.get());
   }
 
   void SendRtpData(webrtc::DataChannelInterface* dc, const std::string& data) {
     // Messages may get lost on the unreliable DataChannel, so we send multiple
     // times to avoid test flakiness.
     static const size_t kSendAttempts = 5;
 
     for (size_t i = 0; i < kSendAttempts; ++i) {
       dc->Send(DataBuffer(data));
     }
   }
 
+  rtc::Thread* network_thread() { return network_thread_.get(); }
+
+  rtc::VirtualSocketServer* virtual_socket_server() { return ss_.get(); }
+
   PeerConnectionTestClient* initializing_client() {
     return initiating_client_.get();
   }
 
   // Set the |initiating_client_| to the |client| passed in and return the
   // original |initiating_client_|.
   PeerConnectionTestClient* set_initializing_client(
       PeerConnectionTestClient* client) {
     PeerConnectionTestClient* old = initiating_client_.release();
     initiating_client_.reset(client);
@@ skipping 370 matching lines @@
       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) {
   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));
+  ASSERT_TRUE(CreateTestClients(nullptr, nullptr, &init_options, nullptr,
+                                nullptr, &recv_options));
   rtc::scoped_refptr<webrtc::FakeMetricsObserver>
       init_observer = new rtc::RefCountedObject<webrtc::FakeMetricsObserver>();
   initializing_client()->pc()->RegisterUMAObserver(init_observer);
   LocalP2PTest();
 
   EXPECT_TRUE_WAIT(
       rtc::SSLStreamAdapter::IsAcceptableCipher(
           initializing_client()->GetDtlsCipherStats(), rtc::KT_DEFAULT),
       kMaxWaitForStatsMs);
   EXPECT_EQ_WAIT(rtc::SrtpCryptoSuiteToName(kDefaultSrtpCryptoSuite),
                  initializing_client()->GetSrtpCipherStats(),
                  kMaxWaitForStatsMs);
   EXPECT_EQ(1,
             init_observer->GetEnumCounter(webrtc::kEnumCounterAudioSrtpCipher,
                                           kDefaultSrtpCryptoSuite));
 }
 
 // Test that DTLS 1.2 is used if both ends support it.
 TEST_F(P2PTestConductor, 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));
+  ASSERT_TRUE(CreateTestClients(nullptr, nullptr, &init_options, nullptr,
+                                nullptr, &recv_options));
   rtc::scoped_refptr<webrtc::FakeMetricsObserver>
       init_observer = new rtc::RefCountedObject<webrtc::FakeMetricsObserver>();
   initializing_client()->pc()->RegisterUMAObserver(init_observer);
   LocalP2PTest();
 
   EXPECT_TRUE_WAIT(
       rtc::SSLStreamAdapter::IsAcceptableCipher(
           initializing_client()->GetDtlsCipherStats(), rtc::KT_DEFAULT),
       kMaxWaitForStatsMs);
   EXPECT_EQ_WAIT(rtc::SrtpCryptoSuiteToName(kDefaultSrtpCryptoSuite),
                  initializing_client()->GetSrtpCipherStats(),
                  kMaxWaitForStatsMs);
   EXPECT_EQ(1,
             init_observer->GetEnumCounter(webrtc::kEnumCounterAudioSrtpCipher,
                                           kDefaultSrtpCryptoSuite));
 }
 
 // Test that DTLS 1.0 is used if the initator supports DTLS 1.2 and the
 // received supports 1.0.
 TEST_F(P2PTestConductor, 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));
+  ASSERT_TRUE(CreateTestClients(nullptr, nullptr, &init_options, nullptr,
+                                nullptr, &recv_options));
   rtc::scoped_refptr<webrtc::FakeMetricsObserver>
       init_observer = new rtc::RefCountedObject<webrtc::FakeMetricsObserver>();
   initializing_client()->pc()->RegisterUMAObserver(init_observer);
   LocalP2PTest();
 
   EXPECT_TRUE_WAIT(
       rtc::SSLStreamAdapter::IsAcceptableCipher(
           initializing_client()->GetDtlsCipherStats(), rtc::KT_DEFAULT),
       kMaxWaitForStatsMs);
   EXPECT_EQ_WAIT(rtc::SrtpCryptoSuiteToName(kDefaultSrtpCryptoSuite),
                  initializing_client()->GetSrtpCipherStats(),
                  kMaxWaitForStatsMs);
   EXPECT_EQ(1,
             init_observer->GetEnumCounter(webrtc::kEnumCounterAudioSrtpCipher,
                                           kDefaultSrtpCryptoSuite));
 }
 
 // Test that DTLS 1.0 is used if the initator supports DTLS 1.0 and the
 // received supports 1.2.
 TEST_F(P2PTestConductor, 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));
+  ASSERT_TRUE(CreateTestClients(nullptr, nullptr, &init_options, nullptr,
+                                nullptr, &recv_options));
   rtc::scoped_refptr<webrtc::FakeMetricsObserver>
       init_observer = new rtc::RefCountedObject<webrtc::FakeMetricsObserver>();
   initializing_client()->pc()->RegisterUMAObserver(init_observer);
   LocalP2PTest();
 
   EXPECT_TRUE_WAIT(
       rtc::SSLStreamAdapter::IsAcceptableCipher(
           initializing_client()->GetDtlsCipherStats(), rtc::KT_DEFAULT),
       kMaxWaitForStatsMs);
   EXPECT_EQ_WAIT(rtc::SrtpCryptoSuiteToName(kDefaultSrtpCryptoSuite),
@@ skipping 289 matching lines @@
   // Echo the stream back.
   receiving_client()->pc()->AddStream(
       receiving_client()->remote_streams()->at(0));
   receiving_client()->Negotiate();
 
   EXPECT_TRUE_WAIT(
       initializing_client()->VideoFramesReceivedCheck(kEndVideoFrameCount),
       kMaxWaitForFramesMs);
 }
 
+// Test that we achieve the expected end-to-end connection time, using a
+// fake clock and simulated latency on the media and signaling paths.
+// We use a TURN<->TURN connection because this is usually the quickest to
+// set up initially, especially when we're confident the connection will work
+// and can start sending media before we get a STUN response.
+//
+// With various optimizations enabled, here are the trips we expect to be
+// required:
+// 1. 2 signaling trip: Signaling offer and offerer's TURN candidate, then
+//                      signaling answer (with DTLS fingerprint).
+// 2. 9 media trips: Rest of the DTLS handshake. 3 hops in each direction when
+//                   using TURN<->TURN pair, and DTLS exchange is 4 packets,
+//                   the first of which should have arrived before the answer.
+TEST_F(P2PTestConductor, EndToEndConnectionTimeWithTurnTurnPair) {
+  rtc::ScopedFakeClock fake_clock;
+  // Some things use a time of "0" as a special value, so we need to start out
+  // the fake clock at a nonzero time.
+  // TODO(deadbeef): Fix this.
+  fake_clock.AdvanceTime(rtc::TimeDelta::FromSeconds(1));
+
+  static constexpr int media_trip_delay_ms = 50;
+  static constexpr int signaling_trip_delay_ms = 500;
+  // For explanation of these values, see comment above.
+  static constexpr int required_media_trips = 9;
+  static constexpr int required_signaling_trips = 2;
+  // For internal delays (such as posting an event asychronously).
+  static constexpr int allowed_internal_delay_ms = 20;
+  static constexpr int total_connection_time_ms =
+      media_trip_delay_ms * required_media_trips +
+      signaling_trip_delay_ms * required_signaling_trips +
+      allowed_internal_delay_ms;
+
+  static const rtc::SocketAddress turn_server_1_internal_address{"88.88.88.0",
+                                                                 3478};
+  static const rtc::SocketAddress turn_server_1_external_address{"88.88.88.1",
+                                                                 0};
+  static const rtc::SocketAddress turn_server_2_internal_address{"99.99.99.0",
+                                                                 3478};
+  static const rtc::SocketAddress turn_server_2_external_address{"99.99.99.1",
+                                                                 0};
+  cricket::TestTurnServer turn_server_1(network_thread(),
+                                        turn_server_1_internal_address,
+                                        turn_server_1_external_address);
+  cricket::TestTurnServer turn_server_2(network_thread(),
+                                        turn_server_2_internal_address,
+                                        turn_server_2_external_address);
+  // Bypass permission check on received packets so media can be sent before
+  // the candidate is signaled.
+  turn_server_1.set_enable_permission_checks(false);
+  turn_server_2.set_enable_permission_checks(false);
+
+  webrtc::PeerConnectionInterface::RTCConfiguration client_1_config;
+  webrtc::PeerConnectionInterface::IceServer ice_server_1;
+  ice_server_1.urls.push_back("turn:88.88.88.0:3478");
+  ice_server_1.username = "test";
+  ice_server_1.password = "test";
+  client_1_config.servers.push_back(ice_server_1);
+  client_1_config.type = webrtc::PeerConnectionInterface::kRelay;
+  client_1_config.presume_writable_when_fully_relayed = true;
+
+  webrtc::PeerConnectionInterface::RTCConfiguration client_2_config;
+  webrtc::PeerConnectionInterface::IceServer ice_server_2;
+  ice_server_2.urls.push_back("turn:99.99.99.0:3478");
+  ice_server_2.username = "test";
+  ice_server_2.password = "test";
+  client_2_config.servers.push_back(ice_server_2);
+  client_2_config.type = webrtc::PeerConnectionInterface::kRelay;
+  client_2_config.presume_writable_when_fully_relayed = true;
+
+  ASSERT_TRUE(CreateTestClients(nullptr, &client_1_config, nullptr, nullptr,
+                                &client_2_config, nullptr));
+  // Set up the simulated delays.
+  SetSignalingDelayMs(signaling_trip_delay_ms);
+  virtual_socket_server()->set_delay_mean(media_trip_delay_ms);
+  virtual_socket_server()->UpdateDelayDistribution();
+
+  initializing_client()->SetOfferToReceiveAudioVideo(true, true);
+  initializing_client()->Negotiate();
+  // TODO(deadbeef): kIceConnectionConnected currently means both ICE and DTLS
+  // are connected. This is an important distinction. Once we have separate ICE
+  // and DTLS state, this check needs to use the DTLS state.
+  EXPECT_TRUE_SIMULATED_WAIT(
+      (receiving_client()->ice_connection_state() ==
+           webrtc::PeerConnectionInterface::kIceConnectionConnected ||
+       receiving_client()->ice_connection_state() ==
+           webrtc::PeerConnectionInterface::kIceConnectionCompleted) &&
+          (initializing_client()->ice_connection_state() ==
+               webrtc::PeerConnectionInterface::kIceConnectionConnected ||
+           initializing_client()->ice_connection_state() ==
+               webrtc::PeerConnectionInterface::kIceConnectionCompleted),
+      total_connection_time_ms, fake_clock);
+  // Need to free the clients here since they're using things we created on
+  // the stack.
+  delete set_initializing_client(nullptr);
+  delete set_receiving_client(nullptr);
+}
+
 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());
   }
 
   bool ParseUrl(const std::string& url,
                 const std::string& username,
                 const std::string& password) {
@@ skipping 172 matching lines @@
   server.urls.push_back("turn:hostname2");
   servers.push_back(server);
   EXPECT_TRUE(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