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 43 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;
 static const int kDefaultSrtpCryptoSuiteGcm = rtc::SRTP_AEAD_AES_256_GCM;
 #endif
 
+// Used to simulate signaling ICE/SDP between two PeerConnections.
+enum Message { MSG_SDP_MESSAGE, MSG_ICE_MESSAGE };
+
+struct SdpMessage {
+  std::string type;
+  std::string msg;
+};
+
+struct IceMessage {
+  std::string sdp_mid;
+  int sdp_mline_index;
+  std::string msg;
+};
+
 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 PeerConnectionFactory::Options* options,
-      const PeerConnectionInterface::RTCConfiguration& config,
+      const PeerConnectionInterface::RTCConfiguration* config,
       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, config, 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 PeerConnectionFactory::Options* options,
-      const PeerConnectionInterface::RTCConfiguration& config,
+      const PeerConnectionInterface::RTCConfiguration* config,
       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, config,
                                              std::move(cert_generator), true,
                                              network_thread, worker_thread);
   }
 
   static PeerConnectionTestClient* CreateClientPreferNoConstraints(
       const std::string& id,
       const PeerConnectionFactory::Options* options,
-      const PeerConnectionInterface::RTCConfiguration& config,
       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, config,
+    return CreateClientWithDtlsIdentityStore(id, nullptr, options, nullptr,
                                              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);
+  }
+
+  void SendSdpMessage(const std::string& type, std::string& msg) {
+    if (signaling_delay_ms_ == 0) {
+      if (signaling_message_receiver_) {
+        signaling_message_receiver_->ReceiveSdpMessage(type, msg);

[skvlad, 2016/09/06 18:02:09]

Is it important to send the message synchronously if delay == 0? Or can we just
always post the message, even if it has a zero delay?

[Taylor Brandstetter, 2016/09/07 00:15:40]

Some tests want to ensure that some state changes immediately after calling SLD
or SRD with an answer. And the only way that happens is through SendSdpMessage.
So until those tests are refactored, there's no simple way to avoid this that I
can think of.

+      }
+    } else {
+      rtc::Thread::Current()->PostDelayed(
+          RTC_FROM_HERE, signaling_delay_ms_, this, MSG_SDP_MESSAGE,
+          new rtc::TypedMessageData<SdpMessage>({type, msg}));
+    }
+  }
+
+  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>(
+                                              {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(
+              sdp_message->data().type, sdp_message->data().msg);
+        }
+        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(
+              ice_message->data().sdp_mid, ice_message->data().sdp_mline_index,
+              ice_message->data().msg);
+        }
+        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 418 matching lines @@
    private:
     bool completed_;
     std::vector<std::string> tones_;
   };
 
   explicit PeerConnectionTestClient(const std::string& id) : id_(id) {}
 
   bool Init(
       const MediaConstraintsInterface* constraints,
       const PeerConnectionFactory::Options* options,
-      const PeerConnectionInterface::RTCConfiguration& config,
+      const PeerConnectionInterface::RTCConfiguration* config,
       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()));
     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, 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 PeerConnectionInterface::RTCConfiguration& config,
+      const PeerConnectionInterface::RTCConfiguration* config,
       std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator) {
+    // CreatePeerConnection with RTCConfiguration.
+    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 14 matching lines @@
 
 class P2PTestConductor : public testing::Test {
  public:
   P2PTestConductor()
       : pss_(new rtc::PhysicalSocketServer),
         ss_(new rtc::VirtualSocketServer(pss_.get())),
         network_thread_(new rtc::Thread(ss_.get())),
         worker_thread_(rtc::Thread::Create()) {
     RTC_CHECK(network_thread_->Start());
     RTC_CHECK(worker_thread_->Start());
-    webrtc::PeerConnectionInterface::IceServer ice_server;
-    ice_server.uri = "stun:stun.l.google.com:19302";
-    config_.servers.push_back(ice_server);
   }
 
   bool SessionActive() {
     return initiating_client_->SessionActive() &&
            receiving_client_->SessionActive();
   }
 
   // Return true if the number of frames provided have been received
   // on the video and audio tracks provided.
   bool FramesHaveArrived(int audio_frames_to_receive,
@@ skipping 82 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, config_, network_thread_.get(),
-            worker_thread_.get()));
+            "Caller: ", nullptr, network_thread_.get(), worker_thread_.get()));
     receiving_client_.reset(
         PeerConnectionTestClient::CreateClientPreferNoConstraints(
-            "Callee: ", nullptr, config_, network_thread_.get(),
-            worker_thread_.get()));
+            "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,
+      PeerConnectionFactory::Options* init_options,
+      const PeerConnectionInterface::RTCConfiguration* init_config,
+      MediaConstraintsInterface* recv_constraints,
+      PeerConnectionFactory::Options* recv_options,
+      const PeerConnectionInterface::RTCConfiguration* recv_config) {
     initiating_client_.reset(PeerConnectionTestClient::CreateClient(
-        "Caller: ", init_constraints, init_options, config_,
+        "Caller: ", init_constraints, init_options, init_config,
         network_thread_.get(), worker_thread_.get()));
     receiving_client_.reset(PeerConnectionTestClient::CreateClient(
-        "Callee: ", recv_constraints, recv_options, config_,
+        "Callee: ", recv_constraints, recv_options, recv_config,
         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) {
@@ skipping 80 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, config_,
+        "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);
     return old;
   }
 
   PeerConnectionTestClient* receiving_client() {
     return receiving_client_.get();
   }
 
   // Set the |receiving_client_| to the |client| passed in and return the
   // original |receiving_client_|.
   PeerConnectionTestClient* set_receiving_client(
       PeerConnectionTestClient* client) {
     PeerConnectionTestClient* old = receiving_client_.release();
     receiving_client_.reset(client);
     return old;
   }
-  webrtc::PeerConnectionInterface::RTCConfiguration* config() {
-    return &config_;
-  }
 
   bool AllObserversReceived(
       const std::vector<std::unique_ptr<MockRtpReceiverObserver>>& observers) {
     for (auto& observer : observers) {
       if (!observer->first_packet_received()) {
         return false;
       }
     }
     return true;
   }
 
   void TestGcmNegotiation(bool local_gcm_enabled, bool remote_gcm_enabled,
       int expected_cipher_suite) {
     PeerConnectionFactory::Options init_options;
     init_options.crypto_options.enable_gcm_crypto_suites = local_gcm_enabled;
     PeerConnectionFactory::Options recv_options;
     recv_options.crypto_options.enable_gcm_crypto_suites = remote_gcm_enabled;
-    ASSERT_TRUE(
-        CreateTestClients(nullptr, &init_options, nullptr, &recv_options));
+    ASSERT_TRUE(CreateTestClients(nullptr, &init_options, nullptr, nullptr,
+                                  &recv_options, nullptr));
     rtc::scoped_refptr<webrtc::FakeMetricsObserver>
         init_observer =
             new rtc::RefCountedObject<webrtc::FakeMetricsObserver>();
     initializing_client()->pc()->RegisterUMAObserver(init_observer);
     LocalP2PTest();
 
     EXPECT_EQ_WAIT(rtc::SrtpCryptoSuiteToName(expected_cipher_suite),
                    initializing_client()->GetSrtpCipherStats(),
                    kMaxWaitMs);
     EXPECT_EQ(1,
               init_observer->GetEnumCounter(webrtc::kEnumCounterAudioSrtpCipher,
                                             expected_cipher_suite));
   }
 
  private:
   // |ss_| is used by |network_thread_| so it must be destroyed later.
   std::unique_ptr<rtc::PhysicalSocketServer> pss_;
   std::unique_ptr<rtc::VirtualSocketServer> ss_;
   // |network_thread_| and |worker_thread_| are used by both
   // |initiating_client_| and |receiving_client_| so they must be destroyed
   // later.
   std::unique_ptr<rtc::Thread> network_thread_;
   std::unique_ptr<rtc::Thread> worker_thread_;
   std::unique_ptr<PeerConnectionTestClient> initiating_client_;
   std::unique_ptr<PeerConnectionTestClient> receiving_client_;
   bool prefer_constraint_apis_ = true;
-  webrtc::PeerConnectionInterface::RTCConfiguration config_;
 };
 
 // Disable for TSan v2, see
 // https://code.google.com/p/webrtc/issues/detail?id=1205 for details.
 #if !defined(THREAD_SANITIZER)
 
 TEST_F(P2PTestConductor, TestRtpReceiverObserverCallbackFunction) {
   ASSERT_TRUE(CreateTestClients());
   LocalP2PTest();
   EXPECT_TRUE_WAIT(
@@ skipping 322 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, &init_options, nullptr, nullptr,
+                                &recv_options, nullptr));
   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, &init_options, nullptr, nullptr,
+                                &recv_options, nullptr));
   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, &init_options, nullptr, nullptr,
+                                &recv_options, nullptr));
   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, &init_options, nullptr, nullptr,
+                                &recv_options, nullptr));
   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 280 matching lines @@
   EXPECT_TRUE(
       video_sender->SetTrack(initializing_client()->CreateLocalVideoTrack("")));
   EXPECT_TRUE_WAIT(FramesHaveArrived(kEndAudioFrameCount, kEndVideoFrameCount),
                    kMaxWaitForFramesMs);
 }
 
 #ifdef HAVE_QUIC
 // This test sets up a call between two parties using QUIC instead of DTLS for
 // audio and video, and a QUIC data channel.
 TEST_F(P2PTestConductor, LocalP2PTestQuicDataChannel) {
-  config()->enable_quic = true;
+  PeerConnectionInterface::RTCConfiguration quic_config;
+  quic_config.enable_quic = true;
+  ASSERT_TRUE(CreateTestClients(nullptr, nullptr, &quic_config, nullptr,
+                                nullptr, &quic_config));
   ASSERT_TRUE(CreateTestClients());
   webrtc::DataChannelInit init;
   init.ordered = false;
   init.reliable = true;
   init.id = 1;
   initializing_client()->CreateDataChannel(&init);
   receiving_client()->CreateDataChannel(&init);
   LocalP2PTest();
   ASSERT_NE(nullptr, initializing_client()->data_channel());
   ASSERT_NE(nullptr, receiving_client()->data_channel());
   EXPECT_TRUE_WAIT(initializing_client()->data_observer()->IsOpen(),
                    kMaxWaitMs);
   EXPECT_TRUE_WAIT(receiving_client()->data_observer()->IsOpen(), kMaxWaitMs);
 
   std::string data = "hello world";
 
   initializing_client()->data_channel()->Send(DataBuffer(data));
   EXPECT_EQ_WAIT(data, receiving_client()->data_observer()->last_message(),
                  kMaxWaitMs);
 
   receiving_client()->data_channel()->Send(DataBuffer(data));
   EXPECT_EQ_WAIT(data, initializing_client()->data_observer()->last_message(),
                  kMaxWaitMs);
 }
 
 // Tests that negotiation of QUIC data channels is completed without error.
 TEST_F(P2PTestConductor, NegotiateQuicDataChannel) {
-  config()->enable_quic = true;
+  PeerConnectionInterface::RTCConfiguration quic_config;
+  quic_config.enable_quic = true;
+  ASSERT_TRUE(CreateTestClients(nullptr, &quic_config, nullptr, nullptr,
+                                &quic_config, nullptr));
   FakeConstraints constraints;
   constraints.SetMandatory(MediaConstraintsInterface::kEnableDtlsSrtp, true);
   ASSERT_TRUE(CreateTestClients(&constraints, &constraints));
   webrtc::DataChannelInit init;
   init.ordered = false;
   init.reliable = true;
   init.id = 1;
   initializing_client()->CreateDataChannel(&init);
   initializing_client()->Negotiate(false, false);
 }
@@ skipping 51 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 network delays we expect to
+// be on the critical path:
+// 1. 2 signaling trips: Signaling offer and offerer's TURN candidate, then
+//                       signaling answer (with DTLS fingerprint).
+// 2. 9 media hops: 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_hop_delay_ms = 50;
+  static constexpr int signaling_trip_delay_ms = 500;
+  // For explanation of these values, see comment above.
+  static constexpr int required_media_hops = 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;

[skvlad, 2016/09/06 18:02:09]

Is this actually needed with a fake clock? Looks like the clock drains all
message queues whenever AdvanceTime() is called, so asynchronous events don't
actually take time.

[Taylor Brandstetter, 2016/09/07 00:15:40]

The thing is, handling a message can post another message with a delay of 0,
just to unwind the stack. And AdvanceTime doesn't guarantee to handle those as
well. Although those extra messages *happen* to be handled in the same tick in
this test, there are some tests where they're not, so I wanted to leave some
wiggle room in case we run into this in the future.

+  static constexpr int total_connection_time_ms =
+      media_hop_delay_ms * required_media_hops +
+      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);
+
+  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;
+
+  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, nullptr, &client_1_config, nullptr,
+                                nullptr, &client_2_config));
+  // Set up the simulated delays.
+  SetSignalingDelayMs(signaling_trip_delay_ms);
+  virtual_socket_server()->set_delay_mean(media_hop_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