Rewrite PeerConnection integration tests using better testing practices.

webrtc/pc/peerconnection_integrationtest.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.
+ */
+
+// Disable for TSan v2, see
+// https://code.google.com/p/webrtc/issues/detail?id=1205 for details.
+#if !defined(THREAD_SANITIZER)
+
+#include <stdio.h>
+
+#include <algorithm>
+#include <functional>
+#include <list>
+#include <map>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "webrtc/api/fakemetricsobserver.h"
+#include "webrtc/api/mediastreaminterface.h"
+#include "webrtc/api/peerconnectioninterface.h"
+#include "webrtc/api/test/fakeconstraints.h"
+#include "webrtc/base/asyncinvoker.h"
+#include "webrtc/base/fakenetwork.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/helpers.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/p2pconstants.h"
+#include "webrtc/p2p/base/portinterface.h"
+#include "webrtc/p2p/base/sessiondescription.h"
+#include "webrtc/p2p/base/testturnserver.h"
+#include "webrtc/p2p/client/basicportallocator.h"
+#include "webrtc/pc/dtmfsender.h"
+#include "webrtc/pc/localaudiosource.h"
+#include "webrtc/pc/mediasession.h"
+#include "webrtc/pc/peerconnection.h"
+#include "webrtc/pc/peerconnectionfactory.h"
+#include "webrtc/pc/test/fakeaudiocapturemodule.h"
+#include "webrtc/pc/test/fakeperiodicvideocapturer.h"
+#include "webrtc/pc/test/fakertccertificategenerator.h"
+#include "webrtc/pc/test/fakevideotrackrenderer.h"
+#include "webrtc/pc/test/mockpeerconnectionobservers.h"
+
+using cricket::ContentInfo;
+using cricket::FakeWebRtcVideoDecoder;
+using cricket::FakeWebRtcVideoDecoderFactory;
+using cricket::FakeWebRtcVideoEncoder;
+using cricket::FakeWebRtcVideoEncoderFactory;
+using cricket::MediaContentDescription;
+using webrtc::DataBuffer;
+using webrtc::DataChannelInterface;
+using webrtc::DtmfSender;
+using webrtc::DtmfSenderInterface;
+using webrtc::DtmfSenderObserverInterface;
+using webrtc::FakeConstraints;
+using webrtc::MediaConstraintsInterface;
+using webrtc::MediaStreamInterface;
+using webrtc::MediaStreamTrackInterface;
+using webrtc::MockCreateSessionDescriptionObserver;
+using webrtc::MockDataChannelObserver;
+using webrtc::MockSetSessionDescriptionObserver;
+using webrtc::MockStatsObserver;
+using webrtc::ObserverInterface;
+using webrtc::PeerConnectionInterface;
+using webrtc::PeerConnectionFactory;
+using webrtc::SessionDescriptionInterface;
+using webrtc::StreamCollectionInterface;
+
+namespace {
+
+static const int kDefaultTimeout = 10000;
+static const int kMaxWaitForStatsMs = 3000;
+static const int kMaxWaitForActivationMs = 5000;
+static const int kMaxWaitForFramesMs = 10000;
+static const int kEndAudioFrameCount = 3;

[pthatcher1, 2017/03/20 18:23:17]

Can you leave a comment explaining what these are?

[Taylor Brandstetter, 2017/03/23 04:46:25]

Done.

+static const int kEndVideoFrameCount = 3;
+
+static const char kDefaultStreamLabel[] = "stream_label";
+static const char kDefaultVideoTrackId[] = "video_track";
+static const char kDefaultAudioTrackId[] = "audio_track";
+static const char kDataChannelLabel[] = "data_channel";
+
+// 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;
+
+// Helper function for constructing offer/answer options to initiate an ICE
+// restart.
+PeerConnectionInterface::RTCOfferAnswerOptions IceRestartOfferAnswerOptions() {
+  PeerConnectionInterface::RTCOfferAnswerOptions options;
+  options.ice_restart = true;
+  return options;
+}
+
+class SignalingMessageReceiver {

[pthatcher1, 2017/03/20 18:23:17]

SignalingReceiverInterface might be a better name.

[Taylor Brandstetter, 2017/03/23 04:46:25]

I prefer the current name personally.

+ public:
+  virtual void ReceiveSdpMessage(const std::string& type,
+                                 const std::string& msg) = 0;
+  virtual void ReceiveIceMessage(const std::string& sdp_mid,
+                                 int sdp_mline_index,
+                                 const std::string& msg) = 0;
+
+ protected:
+  SignalingMessageReceiver() {}
+  virtual ~SignalingMessageReceiver() {}
+};
+
+class MockRtpReceiverObserver : public webrtc::RtpReceiverObserverInterface {
+ public:
+  explicit MockRtpReceiverObserver(cricket::MediaType media_type)
+      : expected_media_type_(media_type) {}
+
+  void OnFirstPacketReceived(cricket::MediaType media_type) override {
+    ASSERT_EQ(expected_media_type_, media_type);
+    first_packet_received_ = true;
+  }
+
+  bool first_packet_received() const { return first_packet_received_; }
+
+  virtual ~MockRtpReceiverObserver() {}
+
+ private:
+  bool first_packet_received_ = false;
+  cricket::MediaType expected_media_type_;
+};
+
+// Helper class that wraps a peer connection, observes it, and can accept
+// signaling messages from another wrapper.
+//
+// Uses a fake network, fake A/V capture, and optionally fake
+// encoders/decoders, though they aren't used by default since they don't
+// advertise support of any codecs.
+class PeerConnectionWrapper : public webrtc::PeerConnectionObserver,
+                              public SignalingMessageReceiver,
+                              public ObserverInterface {
+ public:
+  // Different factory methods for convenience.
+  static PeerConnectionWrapper* CreateWithDtlsIdentityStore(
+      const std::string& debug_name,
+      std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
+      rtc::Thread* network_thread,
+      rtc::Thread* worker_thread) {
+    PeerConnectionWrapper* client(new PeerConnectionWrapper(debug_name));
+    if (!client->Init(nullptr, nullptr, nullptr, std::move(cert_generator),
+                      network_thread, worker_thread)) {
+      delete client;
+      return nullptr;
+    }
+    return client;
+  }
+
+  static PeerConnectionWrapper* CreateWithConfig(
+      const std::string& debug_name,
+      const PeerConnectionInterface::RTCConfiguration& config,
+      rtc::Thread* network_thread,
+      rtc::Thread* worker_thread) {
+    std::unique_ptr<FakeRTCCertificateGenerator> cert_generator(
+        new FakeRTCCertificateGenerator());
+    PeerConnectionWrapper* client(new PeerConnectionWrapper(debug_name));
+    if (!client->Init(nullptr, nullptr, &config, std::move(cert_generator),
+                      network_thread, worker_thread)) {
+      delete client;
+      return nullptr;
+    }
+    return client;
+  }
+
+  static PeerConnectionWrapper* CreateWithOptions(
+      const std::string& debug_name,
+      const PeerConnectionFactory::Options& options,
+      rtc::Thread* network_thread,
+      rtc::Thread* worker_thread) {
+    std::unique_ptr<FakeRTCCertificateGenerator> cert_generator(
+        new FakeRTCCertificateGenerator());
+    PeerConnectionWrapper* client(new PeerConnectionWrapper(debug_name));
+    if (!client->Init(nullptr, &options, nullptr, std::move(cert_generator),
+                      network_thread, worker_thread)) {
+      delete client;
+      return nullptr;
+    }
+    return client;
+  }
+
+  static PeerConnectionWrapper* CreateWithConstraints(
+      const std::string& debug_name,
+      const MediaConstraintsInterface* constraints,
+      rtc::Thread* network_thread,
+      rtc::Thread* worker_thread) {
+    std::unique_ptr<FakeRTCCertificateGenerator> cert_generator(
+        new FakeRTCCertificateGenerator());
+    PeerConnectionWrapper* client(new PeerConnectionWrapper(debug_name));
+    if (!client->Init(constraints, nullptr, nullptr, std::move(cert_generator),
+                      network_thread, worker_thread)) {
+      delete client;
+      return nullptr;
+    }
+    return client;

[pthatcher1, 2017/03/20 18:23:17]

This is repeated 4 times.  A simple Create method that takes all 7 parameters
and does the "delete if Init failed" part might make sense.

[Taylor Brandstetter, 2017/03/23 04:46:25]

That's what we had before which I intentionally changed because it results in
test code that looks like:

CreatePeerConnection(something, nullptr, nullptr, something, nullptr, nullptr,
nullptr);

My goal was prioritizing the readability of the tests, rather than reducing code
duplication. Though this could be cleaned up further by using the whole
"builder" pattern. I'll leave a todo.

[pthatcher1, 2017/03/25 03:38:34]

What I mean was to have the 7-parameter version and then call
CreatePeerConnection(something, nullptr, nullptr, something, nullptr, nullptr,
nullptr); in the specialized methods.  You would have the exact same test code,
but just less duplication in the helper methods.   The builder pattern is fine
too.

[Taylor Brandstetter, 2017/03/27 17:12:16]

Oh; that makes more sense. Sorry I misunderstood.

+  }
+
+  webrtc::PeerConnectionInterface* pc() const { return peer_connection_.get(); }
+
+  // If a signaling message receiver is set (via ConnectFakeSignaling), this
+  // will set the whole offer/answer exchange in motion. Just need to wait for
+  // the signaling state to reach "stable".
+  void CreateSetAndSignalOffer() {

[pthatcher1, 2017/03/20 18:23:17]

I read that as "(Create set) and (Signal offer)".  It took me a while to realize
that it means "(create offer) and (set offer) and (signal offer)".

Maybe "CreateAndSetAndSignalOffer"?

Or maybe just change the call sites to SetLocalAndSignal(CreateOffer())?

[Taylor Brandstetter, 2017/03/23 04:46:25]

Went with first suggestion.

+    auto offer = CreateOffer();
+    ASSERT_NE(nullptr, offer);
+    EXPECT_TRUE(SetLocalDescriptionAndSendSdpMessage(std::move(offer)));
+  }
+
+  // Sets the options to be used when CreateSetAndSignalOffer is called, or
+  // when a remote offer is received (via fake signaling) and an answer is
+  // generated. By default, uses default options.
+  void SetOfferAnswerOptions(
+      const PeerConnectionInterface::RTCOfferAnswerOptions& options) {
+    offer_answer_options_ = options;
+  }
+
+  // Set a callback to be invoked when SDP is received via the fake signaling
+  // channel, which provides an opportunity to munge (modify) the SDP. This is
+  // used to test SDP being applied that a PeerConnection would normally not
+  // generate, but a non-JSEP endpoint might.
+  void SetReceivedSdpMunger(
+      std::function<void(cricket::SessionDescription*)> munger) {
+    received_sdp_munger_ = munger;
+  }
+
+  // Siimlar to the above, but this is run on SDP immediately after it's
+  // generated.
+  void SetGeneratedSdpMunger(
+      std::function<void(cricket::SessionDescription*)> munger) {
+    generated_sdp_munger_ = munger;
+  }
+
+  // Number of times the gathering state has transitioned to "gathering".
+  // Useful for telling if an ICE restart occurred as expected.
+  int transitions_to_gathering_state() const {
+    return transitions_to_gathering_state_;
+  }
+
+  // TODO(deadbeef): Switch the majority of these tests to use AddTrack instead
+  // of AddStream since AddStream is deprecated.
+  void AddAudioVideoMediaStream() {
+    AddMediaStreamFromTracks(CreateLocalAudioTrack(), CreateLocalVideoTrack());
+  }
+
+  void AddAudioOnlyMediaStream() {
+    AddMediaStreamFromTracks(CreateLocalAudioTrack(), nullptr);
+  }
+
+  void AddVideoOnlyMediaStream() {
+    AddMediaStreamFromTracks(nullptr, CreateLocalVideoTrack());
+  }
+
+  rtc::scoped_refptr<webrtc::AudioTrackInterface> CreateLocalAudioTrack() {
+    FakeConstraints constraints;
+    // Disable highpass filter so that we can get all the test audio frames.
+    constraints.AddMandatory(MediaConstraintsInterface::kHighpassFilter, false);
+    rtc::scoped_refptr<webrtc::AudioSourceInterface> source =
+        peer_connection_factory_->CreateAudioSource(&constraints);
+    // TODO(perkj): Test audio source when it is implemented. Currently audio
+    // always use the default input.
+    return peer_connection_factory_->CreateAudioTrack(kDefaultAudioTrackId,
+                                                      source);
+  }
+
+  rtc::scoped_refptr<webrtc::VideoTrackInterface> CreateLocalVideoTrack() {
+    return CreateLocalVideoTrackInternal(
+        kDefaultVideoTrackId, FakeConstraints(), webrtc::kVideoRotation_0);
+  }
+
+  rtc::scoped_refptr<webrtc::VideoTrackInterface>
+  CreateLocalVideoTrackWithConstraints(const FakeConstraints& constraints) {
+    return CreateLocalVideoTrackInternal(kDefaultVideoTrackId, constraints,
+                                         webrtc::kVideoRotation_0);
+  }
+
+  rtc::scoped_refptr<webrtc::VideoTrackInterface>
+  CreateLocalVideoTrackWithRotation(webrtc::VideoRotation rotation) {
+    return CreateLocalVideoTrackInternal(kDefaultVideoTrackId,
+                                         FakeConstraints(), rotation);
+  }
+
+  rtc::scoped_refptr<webrtc::VideoTrackInterface> CreateLocalVideoTrackWithId(
+      const std::string& id) {
+    return CreateLocalVideoTrackInternal(id, FakeConstraints(),
+                                         webrtc::kVideoRotation_0);
+  }
+
+  void AddMediaStreamFromTracks(
+      rtc::scoped_refptr<webrtc::AudioTrackInterface> audio,
+      rtc::scoped_refptr<webrtc::VideoTrackInterface> video) {
+    AddMediaStreamFromTracksWithLabel(audio, video, kDefaultStreamLabel);
+  }
+
+  void AddMediaStreamFromTracksWithLabel(
+      rtc::scoped_refptr<webrtc::AudioTrackInterface> audio,
+      rtc::scoped_refptr<webrtc::VideoTrackInterface> video,
+      const std::string& stream_label) {
+    rtc::scoped_refptr<MediaStreamInterface> stream =
+        peer_connection_factory_->CreateLocalMediaStream(stream_label);
+    if (audio) {
+      stream->AddTrack(audio);
+    }
+    if (video) {
+      stream->AddTrack(video);
+    }
+    EXPECT_TRUE(pc()->AddStream(stream));
+  }
+
+  bool SignalingStateStable() {
+    return pc()->signaling_state() == webrtc::PeerConnectionInterface::kStable;
+  }
+
+  void CreateDataChannel() { CreateDataChannel(nullptr); }
+
+  void CreateDataChannel(const webrtc::DataChannelInit* init) {
+    data_channel_ = pc()->CreateDataChannel(kDataChannelLabel, init);
+    ASSERT_TRUE(data_channel_.get() != nullptr);
+    data_observer_.reset(new MockDataChannelObserver(data_channel_));
+  }
+
+  DataChannelInterface* data_channel() { return data_channel_; }
+  const MockDataChannelObserver* data_observer() const {
+    return data_observer_.get();
+  }
+
+  bool ReceivedAudioFrames(int number_of_frames) const {
+    return number_of_frames <= fake_audio_capture_module_->frames_received();
+  }
+
+  int audio_frames_received() const {
+    return fake_audio_capture_module_->frames_received();
+  }
+
+  bool ReceivedVideoFramesForEachTrack(int number_of_frames) {

[pthatcher1, 2017/03/20 18:23:17]

Would it give more information to failing tests to return the number of tracks
that received enough frames, and then compare that to the number of tracks? 
That way, you get "3 vs 4" or "0 vs 4" instead of just "false".

But maybe that doesn't matter.  Just an idea.

[Taylor Brandstetter, 2017/03/23 04:46:25]

I'll make a helper function that handles this. It's the main point of
unpleasantness currently.

+    if (video_decoder_factory_enabled_) {
+      const std::vector<FakeWebRtcVideoDecoder*>& decoders =
+          fake_video_decoder_factory_->decoders();
+      if (decoders.empty()) {
+        return number_of_frames <= 0;
+      }
+      // Note - this checks that EACH decoder has the requisite number
+      // of frames. The video_frames_received() function sums them.
+      for (FakeWebRtcVideoDecoder* decoder : decoders) {
+        if (number_of_frames > decoder->GetNumFramesReceived()) {
+          return false;
+        }
+      }
+      return true;
+    } else {
+      if (fake_video_renderers_.empty()) {
+        return number_of_frames <= 0;
+      }
+
+      for (const auto& pair : fake_video_renderers_) {
+        if (number_of_frames > pair.second->num_rendered_frames()) {
+          return false;
+        }
+      }
+      return true;
+    }
+  }
+
+  int video_frames_received() const {
+    int total = 0;
+    if (video_decoder_factory_enabled_) {
+      const std::vector<FakeWebRtcVideoDecoder*>& decoders =
+          fake_video_decoder_factory_->decoders();
+      for (const FakeWebRtcVideoDecoder* decoder : decoders) {
+        total += decoder->GetNumFramesReceived();
+      }
+    } else {
+      for (const auto& pair : fake_video_renderers_) {
+        total += pair.second->num_rendered_frames();
+      }
+      for (const auto& renderer : removed_fake_video_renderers_) {
+        total += renderer->num_rendered_frames();
+      }
+    }
+    return total;
+  }
+
+  // Returns a MockStatsObserver in a state after stats gathering finished,
+  // which can be used to access the gathered stats.
+  rtc::scoped_refptr<MockStatsObserver> GetStatsForTrack(
+      webrtc::MediaStreamTrackInterface* track) {
+    rtc::scoped_refptr<MockStatsObserver> observer(
+        new rtc::RefCountedObject<MockStatsObserver>());
+    EXPECT_TRUE(peer_connection_->GetStats(
+        observer, nullptr, PeerConnectionInterface::kStatsOutputLevelStandard));
+    EXPECT_TRUE_WAIT(observer->called(), kDefaultTimeout);
+    return observer;
+  }
+
+  // Version that doesn't take a track "filter", and gathers all stats.
+  rtc::scoped_refptr<MockStatsObserver> GetStats() {
+    return GetStatsForTrack(nullptr);
+  }
+
+  int rendered_width() {
+    EXPECT_FALSE(fake_video_renderers_.empty());
+    return fake_video_renderers_.empty()
+               ? 0
+               : fake_video_renderers_.begin()->second->width();
+  }
+
+  int rendered_height() {
+    EXPECT_FALSE(fake_video_renderers_.empty());
+    return fake_video_renderers_.empty()
+               ? 0
+               : fake_video_renderers_.begin()->second->height();
+  }
+
+  double rendered_aspect_ratio() {
+    if (rendered_height() == 0) {
+      return 0.0;
+    }
+    return static_cast<double>(rendered_width()) / rendered_height();
+  }
+
+  webrtc::VideoRotation rendered_rotation() {
+    EXPECT_FALSE(fake_video_renderers_.empty());
+    return fake_video_renderers_.empty()
+               ? webrtc::kVideoRotation_0
+               : fake_video_renderers_.begin()->second->rotation();
+  }
+
+  int local_rendered_width() {
+    return local_video_renderer_ ? local_video_renderer_->width() : 0;
+  }
+
+  int local_rendered_height() {
+    return local_video_renderer_ ? local_video_renderer_->height() : 0;
+  }
+
+  double local_rendered_aspect_ratio() {
+    if (local_rendered_height() == 0) {
+      return 0.0;
+    }
+    return static_cast<double>(local_rendered_width()) /
+           local_rendered_height();
+  }
+
+  size_t number_of_remote_streams() {
+    if (!pc()) {
+      return 0;
+    }
+    return pc()->remote_streams()->count();
+  }
+
+  StreamCollectionInterface* remote_streams() const {
+    if (!pc()) {
+      ADD_FAILURE();
+      return nullptr;
+    }
+    return pc()->remote_streams();
+  }
+
+  StreamCollectionInterface* local_streams() {
+    if (!pc()) {
+      ADD_FAILURE();
+      return nullptr;
+    }
+    return pc()->local_streams();
+  }
+
+  webrtc::PeerConnectionInterface::SignalingState signaling_state() {
+    return pc()->signaling_state();
+  }
+
+  webrtc::PeerConnectionInterface::IceConnectionState ice_connection_state() {
+    return pc()->ice_connection_state();
+  }
+
+  webrtc::PeerConnectionInterface::IceGatheringState ice_gathering_state() {
+    return pc()->ice_gathering_state();
+  }
+
+  // Returns a MockRtpReceiverObserver for each RtpReceiver returned by
+  // GetReceivers. They're updated automatically when a remote offer/answer
+  // from the fake signaling channel is applied, or when
+  // ResetRtpReceiverObservers below is called.
+  const std::vector<std::unique_ptr<MockRtpReceiverObserver>>&
+  rtp_receiver_observers() {
+    return rtp_receiver_observers_;
+  }
+
+  void ResetRtpReceiverObservers() {
+    rtp_receiver_observers_.clear();
+    for (auto receiver : pc()->GetReceivers()) {
+      std::unique_ptr<MockRtpReceiverObserver> observer(
+          new MockRtpReceiverObserver(receiver->media_type()));
+      receiver->SetObserver(observer.get());
+      rtp_receiver_observers_.push_back(std::move(observer));
+    }
+  }
+
+ private:
+  explicit PeerConnectionWrapper(const std::string& debug_name)
+      : debug_name_(debug_name) {}
+
+  bool Init(
+      const MediaConstraintsInterface* constraints,
+      const PeerConnectionFactory::Options* options,
+      const PeerConnectionInterface::RTCConfiguration* config,
+      std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
+      rtc::Thread* network_thread,
+      rtc::Thread* worker_thread) {
+    // There's an error in this test code if Init ends up being called twice.
+    RTC_DCHECK(!peer_connection_);
+    RTC_DCHECK(!peer_connection_factory_);
+
+    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::BasicPortAllocator(fake_network_manager_.get()));
+    fake_audio_capture_module_ = FakeAudioCaptureModule::Create();
+    if (!fake_audio_capture_module_) {
+      return false;
+    }
+    // Note that these factories don't end up getting used unless supported
+    // codecs are added to them.
+    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,
+      std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator) {
+    PeerConnectionInterface::RTCConfiguration modified_config;
+    // If |config| is null, this will result in a default configuration being
+    // used.
+    if (config) {
+      modified_config = *config;
+    }
+    // Disable resolution adaptation; we don't want it interfering with the
+    // test results.
+    // TODO(deadbeef): Do something more robust. Since we're testing for aspect
+    // ratios and not specific resolutions, is this even necessary?
+    modified_config.set_cpu_adaptation(false);
+
+    return peer_connection_factory_->CreatePeerConnection(
+        modified_config, constraints, std::move(port_allocator),
+        std::move(cert_generator), this);
+  }
+
+  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);
+  }
+
+  rtc::scoped_refptr<webrtc::VideoTrackInterface> CreateLocalVideoTrackInternal(
+      const std::string& track_id,
+      const FakeConstraints& constraints,
+      webrtc::VideoRotation rotation) {
+    // Set max frame rate to 10fps to reduce the risk of test flakiness.
+    // TODO(deadbeef): Do something more robust.
+    FakeConstraints source_constraints = constraints;
+    source_constraints.SetMandatoryMaxFrameRate(10);
+
+    cricket::FakeVideoCapturer* fake_capturer =
+        new webrtc::FakePeriodicVideoCapturer();
+    fake_capturer->SetRotation(rotation);
+    video_capturers_.push_back(fake_capturer);
+    rtc::scoped_refptr<webrtc::VideoTrackSourceInterface> source =
+        peer_connection_factory_->CreateVideoSource(fake_capturer,
+                                                    &source_constraints);
+    rtc::scoped_refptr<webrtc::VideoTrackInterface> track(
+        peer_connection_factory_->CreateVideoTrack(track_id, source));
+    if (!local_video_renderer_) {
+      local_video_renderer_.reset(new webrtc::FakeVideoTrackRenderer(track));
+    }
+    return track;
+  }
+
+  void HandleIncomingOffer(const std::string& msg) {
+    LOG(LS_INFO) << debug_name_ << ": HandleIncomingOffer";
+    std::unique_ptr<SessionDescriptionInterface> desc(
+        webrtc::CreateSessionDescription("offer", msg, nullptr));
+    if (received_sdp_munger_) {
+      received_sdp_munger_(desc->description());
+    }
+
+    EXPECT_TRUE(SetRemoteDescription(std::move(desc)));
+    // Setting a remote description may have changed the number of receivers,
+    // so reset the receiver observers.
+    ResetRtpReceiverObservers();
+    auto answer = CreateAnswer();
+    ASSERT_NE(nullptr, answer);
+    EXPECT_TRUE(SetLocalDescriptionAndSendSdpMessage(std::move(answer)));
+  }
+
+  void HandleIncomingAnswer(const std::string& msg) {
+    LOG(LS_INFO) << debug_name_ << ": HandleIncomingAnswer";
+    std::unique_ptr<SessionDescriptionInterface> desc(
+        webrtc::CreateSessionDescription("answer", msg, nullptr));
+    if (received_sdp_munger_) {
+      received_sdp_munger_(desc->description());
+    }
+
+    EXPECT_TRUE(SetRemoteDescription(std::move(desc)));
+    // Set the RtpReceiverObserver after receivers are created.
+    ResetRtpReceiverObservers();
+  }
+
+  // Returns null on failure.
+  std::unique_ptr<SessionDescriptionInterface> CreateOfferOrAnswer(bool offer) {
+    rtc::scoped_refptr<MockCreateSessionDescriptionObserver> observer(
+        new rtc::RefCountedObject<MockCreateSessionDescriptionObserver>());
+    if (offer) {
+      pc()->CreateOffer(observer, offer_answer_options_);
+    } else {
+      pc()->CreateAnswer(observer, offer_answer_options_);
+    }
+
+    EXPECT_EQ_WAIT(true, observer->called(), kDefaultTimeout);
+    if (!observer->result()) {
+      return nullptr;
+    }
+    auto description = observer->MoveDescription();
+    if (generated_sdp_munger_) {
+      generated_sdp_munger_(description->description());
+    }
+    return description;
+  }
+
+  // Returns null on failure.
+  std::unique_ptr<SessionDescriptionInterface> CreateOffer() {
+    return CreateOfferOrAnswer(true);
+  }
+
+  // Returns null on failure.
+  std::unique_ptr<SessionDescriptionInterface> CreateAnswer() {
+    return CreateOfferOrAnswer(false);

[pthatcher1, 2017/03/20 18:23:17]

It seems like this would be a little more clear as:

rtc::scoped_refptr<MockCreateSessionDescriptionObserver> observer(...));
pc()->CreateOffer(observer, offer_answer_options_);
return WaitForDescriptionFromObserver(observer);

And then move the common code into WaitForDescriptionFromObserver.

But it's just test code, so maybe it doesn't matter.

[Taylor Brandstetter, 2017/03/23 04:46:25]

Done.

+  }
+
+  // Setting the local description and sending the SDP message over the fake
+  // signaling channel are combined into the same method because the SDP
+  // message needs to be sent as soon as SetLocalDescription finishes, without
+  // waiting for the observer to be called. This ensures that ICE candidates
+  // don't outrace the description.
+  bool SetLocalDescriptionAndSendSdpMessage(
+      std::unique_ptr<SessionDescriptionInterface> desc) {
+    rtc::scoped_refptr<MockSetSessionDescriptionObserver> observer(
+        new rtc::RefCountedObject<MockSetSessionDescriptionObserver>());
+    LOG(LS_INFO) << debug_name_ << ": SetLocalDescriptionAndSendSdpMessage";
+    std::string type = desc->type();
+    std::string sdp;
+    EXPECT_TRUE(desc->ToString(&sdp));
+    pc()->SetLocalDescription(observer, desc.release());
+    // As mentioned above, we need to send the message immediately after
+    // SetLocalDescription.
+    SendSdpMessage(type, sdp);
+    EXPECT_TRUE_WAIT(observer->called(), kDefaultTimeout);
+    return true;
+  }
+
+  bool SetRemoteDescription(std::unique_ptr<SessionDescriptionInterface> desc) {
+    rtc::scoped_refptr<MockSetSessionDescriptionObserver> observer(
+        new rtc::RefCountedObject<MockSetSessionDescriptionObserver>());
+    LOG(LS_INFO) << debug_name_ << ": SetRemoteDescription";
+    pc()->SetRemoteDescription(observer, desc.release());
+    EXPECT_TRUE_WAIT(observer->called(), kDefaultTimeout);
+    return observer->result();
+  }
+
+  // Simulate sending a blob of SDP with delay |signaling_delay_ms_| (0 by
+  // default).
+  void SendSdpMessage(const std::string& type, const std::string& msg) {
+    invoker_.AsyncInvokeDelayed<void>(
+        RTC_FROM_HERE, rtc::Thread::Current(),
+        rtc::Bind(&PeerConnectionWrapper::RelaySdpMessageIfReceiverExists, this,
+                  type, msg),
+        signaling_delay_ms_);
+  }
+
+  void RelaySdpMessageIfReceiverExists(const std::string& type,
+                                       const std::string& msg) {
+    if (signaling_message_receiver_) {
+      signaling_message_receiver_->ReceiveSdpMessage(type, msg);
+    }
+  }
+
+  // Simulate trickling an ICE candidate with delay |signaling_delay_ms_| (0 by
+  // default).
+  void SendIceMessage(const std::string& sdp_mid,
+                      int sdp_mline_index,
+                      const std::string& msg) {
+    invoker_.AsyncInvokeDelayed<void>(
+        RTC_FROM_HERE, rtc::Thread::Current(),
+        rtc::Bind(&PeerConnectionWrapper::RelayIceMessageIfReceiverExists, this,
+                  sdp_mid, sdp_mline_index, msg),
+        signaling_delay_ms_);
+  }
+
+  void RelayIceMessageIfReceiverExists(const std::string& sdp_mid,
+                                       int sdp_mline_index,
+                                       const std::string& msg) {
+    if (signaling_message_receiver_) {
+      signaling_message_receiver_->ReceiveIceMessage(sdp_mid, sdp_mline_index,
+                                                     msg);
+    }
+  }
+
+  // SignalingMessageReceiver callbacks.
+  void ReceiveSdpMessage(const std::string& type,
+                         const std::string& msg) override {
+    if (type == webrtc::SessionDescriptionInterface::kOffer) {
+      HandleIncomingOffer(msg);
+    } else {
+      HandleIncomingAnswer(msg);
+    }
+  }
+
+  void ReceiveIceMessage(const std::string& sdp_mid,
+                         int sdp_mline_index,
+                         const std::string& msg) override {
+    LOG(LS_INFO) << debug_name_ << ": ReceiveIceMessage";
+    std::unique_ptr<webrtc::IceCandidateInterface> candidate(
+        webrtc::CreateIceCandidate(sdp_mid, sdp_mline_index, msg, nullptr));
+    EXPECT_TRUE(pc()->AddIceCandidate(candidate.get()));
+  }
+
+  // PeerConnectionObserver callbacks.
+  void OnSignalingChange(
+      webrtc::PeerConnectionInterface::SignalingState new_state) override {
+    EXPECT_EQ(pc()->signaling_state(), new_state);
+  }
+  void OnAddStream(
+      rtc::scoped_refptr<MediaStreamInterface> media_stream) override {
+    media_stream->RegisterObserver(this);
+    for (size_t i = 0; i < media_stream->GetVideoTracks().size(); ++i) {
+      const std::string id = media_stream->GetVideoTracks()[i]->id();
+      ASSERT_TRUE(fake_video_renderers_.find(id) ==
+                  fake_video_renderers_.end());
+      fake_video_renderers_[id].reset(new webrtc::FakeVideoTrackRenderer(
+          media_stream->GetVideoTracks()[i]));
+    }
+  }
+  void OnRemoveStream(
+      rtc::scoped_refptr<MediaStreamInterface> media_stream) override {}
+  void OnRenegotiationNeeded() override {}
+  void OnIceConnectionChange(
+      webrtc::PeerConnectionInterface::IceConnectionState new_state) override {
+    EXPECT_EQ(pc()->ice_connection_state(), new_state);
+  }
+  void OnIceGatheringChange(
+      webrtc::PeerConnectionInterface::IceGatheringState new_state) override {
+    if (new_state == PeerConnectionInterface::kIceGatheringGathering) {
+      ++transitions_to_gathering_state_;
+    }
+    EXPECT_EQ(pc()->ice_gathering_state(), new_state);
+  }
+  void OnIceCandidate(const webrtc::IceCandidateInterface* candidate) override {
+    LOG(LS_INFO) << debug_name_ << ": OnIceCandidate";
+
+    std::string ice_sdp;
+    EXPECT_TRUE(candidate->ToString(&ice_sdp));
+    if (signaling_message_receiver_ == nullptr) {
+      // Remote party may be deleted.
+      return;
+    }
+    SendIceMessage(candidate->sdp_mid(), candidate->sdp_mline_index(), ice_sdp);
+  }
+  void OnDataChannel(
+      rtc::scoped_refptr<DataChannelInterface> data_channel) override {
+    LOG(LS_INFO) << debug_name_ << ": OnDataChannel";
+    data_channel_ = data_channel;
+    data_observer_.reset(new MockDataChannelObserver(data_channel));
+  }
+
+  // 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();) {
+      if (remote_streams->FindVideoTrack(it->first) == nullptr) {
+        auto to_remove = it++;
+        removed_fake_video_renderers_.push_back(std::move(to_remove->second));
+        fake_video_renderers_.erase(to_remove);
+      } else {
+        ++it;
+      }
+    }
+    // Create renderers for new video tracks.
+    for (size_t stream_index = 0; stream_index < remote_streams->count();
+         ++stream_index) {
+      MediaStreamInterface* remote_stream = remote_streams->at(stream_index);
+      for (size_t track_index = 0;
+           track_index < remote_stream->GetVideoTracks().size();
+           ++track_index) {
+        const std::string id =
+            remote_stream->GetVideoTracks()[track_index]->id();
+        if (fake_video_renderers_.find(id) != fake_video_renderers_.end()) {
+          continue;
+        }
+        fake_video_renderers_[id].reset(new webrtc::FakeVideoTrackRenderer(
+            remote_stream->GetVideoTracks()[track_index]));
+      }
+    }
+  }
+
+  std::string debug_name_;
+
+  std::unique_ptr<rtc::FakeNetworkManager> fake_network_manager_;
+
+  rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection_;
+  rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface>
+      peer_connection_factory_;
+
+  // 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;
+
+  // 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_;
+  // |local_video_renderer_| attached to the first created local video track.
+  std::unique_ptr<webrtc::FakeVideoTrackRenderer> local_video_renderer_;
+
+  PeerConnectionInterface::RTCOfferAnswerOptions offer_answer_options_;
+  std::function<void(cricket::SessionDescription*)> received_sdp_munger_;
+  std::function<void(cricket::SessionDescription*)> generated_sdp_munger_;
+
+  rtc::scoped_refptr<DataChannelInterface> data_channel_;
+  std::unique_ptr<MockDataChannelObserver> data_observer_;
+
+  std::vector<std::unique_ptr<MockRtpReceiverObserver>> rtp_receiver_observers_;
+
+  int transitions_to_gathering_state_ = 0;
+
+  rtc::AsyncInvoker invoker_;
+
+  friend class PeerConnectionIntegrationTest;
+};
+
+// Tests two PeerConnections connecting to each other end-to-end, using a
+// virtual network, fake A/V capture and fake encoder/decoders. The
+// PeerConnections share the threads/socket servers, but use separate versions
+// of everything else (including "PeerConnectionFactory"s).
+class PeerConnectionIntegrationTest : public testing::Test {
+ public:
+  PeerConnectionIntegrationTest()
+      : 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());
+  }
+
+  ~PeerConnectionIntegrationTest() {
+    if (caller_pc_wrapper_) {
+      caller_pc_wrapper_->set_signaling_message_receiver(nullptr);
+    }
+    if (callee_pc_wrapper_) {
+      callee_pc_wrapper_->set_signaling_message_receiver(nullptr);
+    }
+  }
+
+  bool SignalingStateStable() {
+    return caller_pc_wrapper_->SignalingStateStable() &&
+           callee_pc_wrapper_->SignalingStateStable();
+  }
+
+  bool CreatePeerConnectionWrappers() {
+    return CreatePeerConnectionWrappersWithConfig(
+        PeerConnectionInterface::RTCConfiguration(),
+        PeerConnectionInterface::RTCConfiguration());
+  }
+
+  bool CreatePeerConnectionWrappersWithConstraints(
+      MediaConstraintsInterface* caller_constraints,
+      MediaConstraintsInterface* callee_constraints) {
+    caller_pc_wrapper_.reset(PeerConnectionWrapper::CreateWithConstraints(
+        "Caller", caller_constraints, network_thread_.get(),
+        worker_thread_.get()));
+    callee_pc_wrapper_.reset(PeerConnectionWrapper::CreateWithConstraints(
+        "Callee", callee_constraints, network_thread_.get(),
+        worker_thread_.get()));
+    return caller_pc_wrapper_ && callee_pc_wrapper_;
+  }
+
+  bool CreatePeerConnectionWrappersWithConfig(
+      const PeerConnectionInterface::RTCConfiguration& caller_config,
+      const PeerConnectionInterface::RTCConfiguration& callee_config) {
+    caller_pc_wrapper_.reset(PeerConnectionWrapper::CreateWithConfig(
+        "Caller", caller_config, network_thread_.get(), worker_thread_.get()));
+    callee_pc_wrapper_.reset(PeerConnectionWrapper::CreateWithConfig(
+        "Callee", callee_config, network_thread_.get(), worker_thread_.get()));
+    return caller_pc_wrapper_ && callee_pc_wrapper_;
+  }
+
+  bool CreatePeerConnectionWrappersWithOptions(
+      const PeerConnectionFactory::Options& caller_options,
+      const PeerConnectionFactory::Options& callee_options) {
+    caller_pc_wrapper_.reset(PeerConnectionWrapper::CreateWithOptions(
+        "Caller", caller_options, network_thread_.get(), worker_thread_.get()));
+    callee_pc_wrapper_.reset(PeerConnectionWrapper::CreateWithOptions(
+        "Callee", callee_options, network_thread_.get(), worker_thread_.get()));
+    return caller_pc_wrapper_ && callee_pc_wrapper_;
+  }
+
+  PeerConnectionWrapper* CreatePeerConnectionWrapperWithAlternateKey() {
+    std::unique_ptr<FakeRTCCertificateGenerator> cert_generator(
+        new FakeRTCCertificateGenerator());
+    cert_generator->use_alternate_key();
+
+    // Make sure the new client is using a different certificate.
+    return PeerConnectionWrapper::CreateWithDtlsIdentityStore(
+        "New Peer", std::move(cert_generator), network_thread_.get(),
+        worker_thread_.get());
+  }
+
+  // Once called, SDP blobs and ICE candidates will be automatically signaled
+  // between PeerConnections.
+  void ConnectFakeSignaling() {
+    caller_pc_wrapper_->set_signaling_message_receiver(
+        callee_pc_wrapper_.get());
+    callee_pc_wrapper_->set_signaling_message_receiver(
+        caller_pc_wrapper_.get());
+  }
+
+  void SetSignalingDelayMs(int delay_ms) {
+    caller_pc_wrapper_->set_signaling_delay_ms(delay_ms);
+    callee_pc_wrapper_->set_signaling_delay_ms(delay_ms);
+  }
+
+  void EnableVideoDecoderFactory() {
+    caller_pc_wrapper_->EnableVideoDecoderFactory();
+    callee_pc_wrapper_->EnableVideoDecoderFactory();
+  }
+
+  // Messages may get lost on the unreliable DataChannel, so we send multiple
+  // times to avoid test flakiness.
+  void SendRtpDataWithRetries(webrtc::DataChannelInterface* dc,
+                              const std::string& data,
+                              int retries) {
+    for (int i = 0; i < retries; ++i) {
+      dc->Send(DataBuffer(data));
+    }
+  }
+
+  rtc::Thread* network_thread() { return network_thread_.get(); }
+
+  rtc::VirtualSocketServer* virtual_socket_server() { return ss_.get(); }
+
+  PeerConnectionWrapper* caller_pc_wrapper() {
+    return caller_pc_wrapper_.get();
+  }
+
+  // Set the |caller_pc_wrapper_| to the |wrapper| passed in and return the
+  // original |caller_pc_wrapper_|.
+  PeerConnectionWrapper* SetCallerPcWrapperAndReturnCurrent(
+      PeerConnectionWrapper* wrapper) {
+    PeerConnectionWrapper* old = caller_pc_wrapper_.release();
+    caller_pc_wrapper_.reset(wrapper);
+    return old;
+  }
+
+  PeerConnectionWrapper* callee_pc_wrapper() {
+    return callee_pc_wrapper_.get();
+  }
+
+  // Set the |callee_pc_wrapper_| to the |wrapper| passed in and return the
+  // original |callee_pc_wrapper_|.
+  PeerConnectionWrapper* SetCalleePcWrapperAndReturnCurrent(
+      PeerConnectionWrapper* wrapper) {
+    PeerConnectionWrapper* old = callee_pc_wrapper_.release();
+    callee_pc_wrapper_.reset(wrapper);
+    return old;
+  }
+
+  void TestGcmNegotiationUsesCipherSuite(bool local_gcm_enabled,
+                                         bool remote_gcm_enabled,
+                                         int expected_cipher_suite) {
+    PeerConnectionFactory::Options caller_options;
+    caller_options.crypto_options.enable_gcm_crypto_suites = local_gcm_enabled;
+    PeerConnectionFactory::Options callee_options;
+    callee_options.crypto_options.enable_gcm_crypto_suites = remote_gcm_enabled;
+    ASSERT_TRUE(CreatePeerConnectionWrappersWithOptions(caller_options,
+                                                        callee_options));
+    rtc::scoped_refptr<webrtc::FakeMetricsObserver> caller_observer =
+        new rtc::RefCountedObject<webrtc::FakeMetricsObserver>();
+    caller_pc_wrapper()->pc()->RegisterUMAObserver(caller_observer);
+    ConnectFakeSignaling();
+    caller_pc_wrapper()->AddAudioVideoMediaStream();
+    callee_pc_wrapper()->AddAudioVideoMediaStream();
+    caller_pc_wrapper()->CreateSetAndSignalOffer();
+    ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+    EXPECT_EQ_WAIT(rtc::SrtpCryptoSuiteToName(expected_cipher_suite),
+                   caller_pc_wrapper()->GetStats()->SrtpCipher(),
+                   kDefaultTimeout);
+    EXPECT_EQ(
+        1, caller_observer->GetEnumCounter(webrtc::kEnumCounterAudioSrtpCipher,
+                                           expected_cipher_suite));
+    caller_pc_wrapper()->pc()->RegisterUMAObserver(nullptr);
+  }
+
+ 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
+  // |caller_pc_wrapper_| and |callee_pc_wrapper_| so they must be destroyed
+  // later.
+  std::unique_ptr<rtc::Thread> network_thread_;
+  std::unique_ptr<rtc::Thread> worker_thread_;
+  std::unique_ptr<PeerConnectionWrapper> caller_pc_wrapper_;
+  std::unique_ptr<PeerConnectionWrapper> callee_pc_wrapper_;

[pthatcher1, 2017/03/20 18:23:17]

I think you ought to just call this caller_ and callee_.

[Taylor Brandstetter, 2017/03/23 04:46:25]

Done.

+};
+
+// Test the OnFirstPacketReceived callback from audio/video RtpReceivers.  This
+// includes testing that the callback is invoked if an observer is connected
+// after the first packet has already been received.
+TEST_F(PeerConnectionIntegrationTest,
+       RtpReceiverObserverOnFirstPacketReceived) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  // Start offer/answer exchange and wait for it to complete.
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  // Should be one receiver each for audio/video.
+  EXPECT_EQ(2, caller_pc_wrapper()->rtp_receiver_observers().size());
+  EXPECT_EQ(2, callee_pc_wrapper()->rtp_receiver_observers().size());
+  // Wait for all "first packet received" callbacks to be fired.
+  EXPECT_TRUE_WAIT(
+      std::all_of(caller_pc_wrapper()->rtp_receiver_observers().begin(),
+                  caller_pc_wrapper()->rtp_receiver_observers().end(),
+                  [](const std::unique_ptr<MockRtpReceiverObserver>& o) {
+                    return o->first_packet_received();
+                  }),

[pthatcher1, 2017/03/20 18:23:17]

This is repeated many times.  Does it make sense to make a method for it?  Then
you'd have 


EXPECT_TRUE_WAIT(ReceivedPackets(caller), kMaxWaitForFramesMs)
EXPECT_TRUE_WAIT(ReceivedPackets(callee), kMaxWaitForFramesMs)

[Taylor Brandstetter, 2017/03/23 04:46:25]

I did something similar, see new patchset.

+      kMaxWaitForFramesMs);
+  EXPECT_TRUE_WAIT(
+      std::all_of(callee_pc_wrapper()->rtp_receiver_observers().begin(),
+                  callee_pc_wrapper()->rtp_receiver_observers().end(),
+                  [](const std::unique_ptr<MockRtpReceiverObserver>& o) {
+                    return o->first_packet_received();
+                  }),
+      kMaxWaitForFramesMs);
+  // If new observers are set after the first packet was already received, the
+  // callback should still be invoked.
+  caller_pc_wrapper()->ResetRtpReceiverObservers();
+  callee_pc_wrapper()->ResetRtpReceiverObservers();
+  EXPECT_EQ(2, caller_pc_wrapper()->rtp_receiver_observers().size());
+  EXPECT_EQ(2, callee_pc_wrapper()->rtp_receiver_observers().size());
+  EXPECT_TRUE(
+      std::all_of(caller_pc_wrapper()->rtp_receiver_observers().begin(),
+                  caller_pc_wrapper()->rtp_receiver_observers().end(),
+                  [](const std::unique_ptr<MockRtpReceiverObserver>& o) {
+                    return o->first_packet_received();
+                  }));
+  EXPECT_TRUE(
+      std::all_of(callee_pc_wrapper()->rtp_receiver_observers().begin(),
+                  callee_pc_wrapper()->rtp_receiver_observers().end(),
+                  [](const std::unique_ptr<MockRtpReceiverObserver>& o) {
+                    return o->first_packet_received();
+                  }));
+}
+
+class DummyDtmfObserver : public DtmfSenderObserverInterface {
+ public:
+  DummyDtmfObserver() : completed_(false) {}
+
+  // Implements DtmfSenderObserverInterface.
+  void OnToneChange(const std::string& tone) override {
+    tones_.push_back(tone);
+    if (tone.empty()) {
+      completed_ = true;
+    }
+  }
+
+  const std::vector<std::string>& tones() const { return tones_; }
+  bool completed() const { return completed_; }
+
+ private:
+  bool completed_;
+  std::vector<std::string> tones_;
+};
+
+// Assumes |sender| already has an audio track added and the offer/answer
+// exchange is done.
+void TestDtmfBetween(PeerConnectionWrapper* sender,
+                     PeerConnectionWrapper* receiver) {

[pthatcher1, 2017/03/20 18:23:17]

Could probably just call it "TestDtmf".  I'm not sure what "between" adds.

[Taylor Brandstetter, 2017/03/23 04:46:25]

I'll call it TestDtmfFromSenderToReceiver to hint at the meaning of the
arguments.

+  DummyDtmfObserver observer;
+  rtc::scoped_refptr<DtmfSenderInterface> dtmf_sender;
+
+  // We should be able to create a DTMF sender from a local track.
+  webrtc::AudioTrackInterface* localtrack =
+      sender->local_streams()->at(0)->GetAudioTracks()[0];
+  dtmf_sender = sender->pc()->CreateDtmfSender(localtrack);
+  ASSERT_NE(nullptr, dtmf_sender.get());
+  dtmf_sender->RegisterObserver(&observer);
+
+  // Test the DtmfSender object just created.
+  EXPECT_TRUE(dtmf_sender->CanInsertDtmf());
+  EXPECT_TRUE(dtmf_sender->InsertDtmf("1a", 100, 50));
+
+  EXPECT_TRUE_WAIT(observer.completed(), kDefaultTimeout);
+  std::vector<std::string> tones = {"1", "a", ""};
+  EXPECT_EQ(tones, observer.tones());
+  dtmf_sender->UnregisterObserver();
+  // TODO(deadbeef): Verify the tones were actually received end-to-end.
+}
+
+// Verifies the DtmfSenderObserver callbacks for a DtmfSender (one in each
+// direction).
+TEST_F(PeerConnectionIntegrationTest, DtmfSenderObserver) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  // Only need audio for DTMF.
+  caller_pc_wrapper()->AddAudioOnlyMediaStream();
+  callee_pc_wrapper()->AddAudioOnlyMediaStream();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  TestDtmfBetween(caller_pc_wrapper(), callee_pc_wrapper());
+  TestDtmfBetween(callee_pc_wrapper(), caller_pc_wrapper());
+}
+
+// Basic end-to-end test, verifying media can be encoded/transmitted/decoded
+// between two connections, using DTLS-SRTP.
+TEST_F(PeerConnectionIntegrationTest, EndToEndCallWithDtls) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  // Do normal offer/answer and wait for some frames to be received in each
+  // direction.
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  EXPECT_TRUE_WAIT(
+      caller_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          caller_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount) &&
+          callee_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount),
+      kMaxWaitForFramesMs);
+}
+
+// Uses SDES instead of DTLS for key agreement.
+TEST_F(PeerConnectionIntegrationTest, EndToEndCallWithSdes) {
+  PeerConnectionInterface::RTCConfiguration sdes_config;
+  sdes_config.enable_dtls_srtp.emplace(false);
+  ASSERT_TRUE(CreatePeerConnectionWrappersWithConfig(sdes_config, sdes_config));
+  ConnectFakeSignaling();
+
+  // Do normal offer/answer and wait for some frames to be received in each
+  // direction.
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  EXPECT_TRUE_WAIT(
+      caller_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          caller_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount) &&
+          callee_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount),
+      kMaxWaitForFramesMs);
+}
+
+// This test sets up a call between two parties (using DTLS) and tests that we
+// can get a video aspect ratio of 16:9.
+TEST_F(PeerConnectionIntegrationTest, SendAndReceive16To9AspectRatio) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+
+  // Add video tracks with 16:9 constraint.
+  FakeConstraints constraints;
+  double requested_ratio = 16.0 / 9;
+  constraints.SetMandatoryMinAspectRatio(requested_ratio);
+  caller_pc_wrapper()->AddMediaStreamFromTracks(
+      nullptr,
+      caller_pc_wrapper()->CreateLocalVideoTrackWithConstraints(constraints));
+  callee_pc_wrapper()->AddMediaStreamFromTracks(
+      nullptr,
+      callee_pc_wrapper()->CreateLocalVideoTrackWithConstraints(constraints));
+
+  // Do normal offer/answer and wait for at least one frame to be received in
+  // each direction.
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  EXPECT_TRUE_WAIT(caller_pc_wrapper()->ReceivedVideoFramesForEachTrack(1),
+                   kMaxWaitForFramesMs);
+  EXPECT_TRUE_WAIT(callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(1),
+                   kMaxWaitForFramesMs);
+
+  // Check rendered aspect ratio.
+  EXPECT_EQ(requested_ratio,
+            caller_pc_wrapper()->local_rendered_aspect_ratio());
+  EXPECT_EQ(requested_ratio, caller_pc_wrapper()->rendered_aspect_ratio());
+  EXPECT_EQ(requested_ratio,
+            callee_pc_wrapper()->local_rendered_aspect_ratio());
+  EXPECT_EQ(requested_ratio, callee_pc_wrapper()->rendered_aspect_ratio());
+}
+
+// This test sets up a call between two parties with a source resolution of
+// 1280x720 and verifies that a 16:9 aspect ratio is received.
+TEST_F(PeerConnectionIntegrationTest,
+       Send1280By720ResolutionAndReceive16To9AspectRatio) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+
+  // Similar to above test, but uses MandatoryMin[Width/Height] constraint
+  // instead of aspect ratio constraint.
+  FakeConstraints constraints;
+  constraints.SetMandatoryMinWidth(1280);
+  constraints.SetMandatoryMinHeight(720);
+  caller_pc_wrapper()->AddMediaStreamFromTracks(
+      nullptr,
+      caller_pc_wrapper()->CreateLocalVideoTrackWithConstraints(constraints));
+  callee_pc_wrapper()->AddMediaStreamFromTracks(
+      nullptr,
+      callee_pc_wrapper()->CreateLocalVideoTrackWithConstraints(constraints));
+
+  // Do normal offer/answer and wait for at least one frame to be received in
+  // each direction.
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  EXPECT_TRUE_WAIT(caller_pc_wrapper()->ReceivedVideoFramesForEachTrack(1) &&
+                       callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(1),
+                   kMaxWaitForFramesMs);
+
+  // Check rendered aspect ratio.
+  EXPECT_EQ(16.0 / 9, caller_pc_wrapper()->local_rendered_aspect_ratio());
+  EXPECT_EQ(16.0 / 9, caller_pc_wrapper()->rendered_aspect_ratio());
+  EXPECT_EQ(16.0 / 9, callee_pc_wrapper()->local_rendered_aspect_ratio());
+  EXPECT_EQ(16.0 / 9, callee_pc_wrapper()->rendered_aspect_ratio());
+}
+
+// This test sets up an one-way call, with media only from caller to
+// callee.
+TEST_F(PeerConnectionIntegrationTest, OneWayMediaCall) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  EXPECT_TRUE_WAIT(
+      callee_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount),
+      kMaxWaitForFramesMs);
+}
+
+// This test sets up a audio call initially, with the callee rejecting video
+// initially. Then later the callee decides to upgrade to audio/video, and
+// initiates a new offer/answer exchange.
+TEST_F(PeerConnectionIntegrationTest, AudioToVideoUpgrade) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  // Initially, offer an audio/video stream from the caller, but refuse to
+  // send/receive video on the callee side.
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  callee_pc_wrapper()->AddMediaStreamFromTracks(
+      callee_pc_wrapper()->CreateLocalAudioTrack(), nullptr);
+  PeerConnectionInterface::RTCOfferAnswerOptions options;
+  options.offer_to_receive_video = 0;
+  callee_pc_wrapper()->SetOfferAnswerOptions(options);
+  // Do offer/answer and make sure audio is still received end-to-end.
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  EXPECT_TRUE_WAIT(
+      caller_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          callee_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount),
+      kMaxWaitForFramesMs);
+  // Sanity check that the callee's description has a rejected video section.
+  ASSERT_NE(nullptr, callee_pc_wrapper()->pc()->local_description());
+  const ContentInfo* callee_video_content = GetFirstVideoContent(
+      callee_pc_wrapper()->pc()->local_description()->description());
+  ASSERT_NE(nullptr, callee_video_content);
+  EXPECT_TRUE(callee_video_content->rejected);
+  // Now negotiate with video and ensure negotiation succeeds, with video
+  // frames and additional audio frames being received.
+  callee_pc_wrapper()->AddMediaStreamFromTracksWithLabel(
+      nullptr, callee_pc_wrapper()->CreateLocalVideoTrack(),
+      "video_only_stream");
+  options.offer_to_receive_video = 1;
+  callee_pc_wrapper()->SetOfferAnswerOptions(options);
+  callee_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  int last_caller_audio_frames = caller_pc_wrapper()->audio_frames_received();
+  int last_callee_audio_frames = callee_pc_wrapper()->audio_frames_received();
+  EXPECT_TRUE_WAIT(caller_pc_wrapper()->ReceivedAudioFrames(
+                       kEndAudioFrameCount + last_caller_audio_frames) &&
+                       callee_pc_wrapper()->ReceivedAudioFrames(
+                           kEndAudioFrameCount + last_callee_audio_frames) &&
+                       caller_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+                           kEndVideoFrameCount) &&
+                       callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+                           kEndVideoFrameCount),
+                   kMaxWaitForFramesMs);
+}
+
+// This test sets up a call that's transferred to a new caller with a different
+// DTLS fingerprint.
+TEST_F(PeerConnectionIntegrationTest, CallTransferredForCallee) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+
+  // Keep the original peer around which will still send packets to the
+  // receiving client. These SRTP packets will be dropped.
+  std::unique_ptr<PeerConnectionWrapper> original_peer(
+      SetCallerPcWrapperAndReturnCurrent(
+          CreatePeerConnectionWrapperWithAlternateKey()));
+  // TODO(deadbeef): Why do we call Close here? That goes against the comment
+  // directly above.
+  original_peer->pc()->Close();
+
+  // Store the last frame counts so we can ensure additional frames are
+  // received from the new peer.
+  int last_audio_frames = callee_pc_wrapper()->audio_frames_received();
+  int last_video_frames = callee_pc_wrapper()->video_frames_received();
+
+  ConnectFakeSignaling();
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  // Wait for some additional frames to be transmitted end-to-end.
+  EXPECT_TRUE_WAIT(
+      caller_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          caller_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount) &&
+          callee_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount +
+                                                   last_audio_frames) &&
+          callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount + last_video_frames),
+      kMaxWaitForFramesMs);
+}
+
+// This test sets up a call that's transferred to a new callee with a different
+// DTLS fingerprint.
+TEST_F(PeerConnectionIntegrationTest, CallTransferredForCaller) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+
+  // Keep the original peer around which will still send packets to the
+  // receiving client. These SRTP packets will be dropped.
+  std::unique_ptr<PeerConnectionWrapper> original_peer(
+      SetCalleePcWrapperAndReturnCurrent(
+          CreatePeerConnectionWrapperWithAlternateKey()));
+  // TODO(deadbeef): Why do we call Close here? That goes against the comment
+  // directly above.
+  original_peer->pc()->Close();
+
+  // Store the last frame counts so we can ensure additional frames are
+  // received from the new peer.
+  int last_audio_frames = caller_pc_wrapper()->audio_frames_received();
+  int last_video_frames = caller_pc_wrapper()->video_frames_received();
+
+  ConnectFakeSignaling();
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->SetOfferAnswerOptions(IceRestartOfferAnswerOptions());
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  // Wait for some additional frames to be transmitted end-to-end.
+  EXPECT_TRUE_WAIT(
+      caller_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount +
+                                               last_audio_frames) &&
+          caller_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount + last_video_frames) &&
+          callee_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount),
+      kMaxWaitForFramesMs);
+}
+
+// This test sets up a non-bundled call and negotiates bundling at the same
+// time as starting an ICE restart. When bundling is in effect in the restart,
+// the DTLS-SRTP context should be successfully reset.
+TEST_F(PeerConnectionIntegrationTest, BundlingEnabledWhileIceRestartOccurs) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  // Remove the bundle group from the SDP received by the callee.
+  callee_pc_wrapper()->SetReceivedSdpMunger(
+      [](cricket::SessionDescription* desc) {
+        desc->RemoveGroupByName("BUNDLE");
+      });
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  EXPECT_TRUE_WAIT(
+      caller_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          caller_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount) &&
+          callee_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount),

[pthatcher1, 2017/03/20 18:23:17]

This seems like another duplicate that could be moved into a method, so you can
have something like:

EXPECT_TRUE_WAIT(ReceivedFrames(caller, callee), kMaxWaitForFramesMs);

+      kMaxWaitForFramesMs);
+
+  // Now stop removing the BUNDLE group, and trigger an ICE restart.
+  callee_pc_wrapper()->SetReceivedSdpMunger(nullptr);
+  caller_pc_wrapper()->SetOfferAnswerOptions(IceRestartOfferAnswerOptions());
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  EXPECT_TRUE_WAIT(
+      caller_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          caller_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount) &&
+          callee_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount),
+      kMaxWaitForFramesMs);
+}
+
+// Test CVO (Coordination of Video Orientation). If a video source is rotated
+// and both peers support the CVO RTP header extension, the actual video frames
+// don't need to be encoded in different resolutions, since the rotation is
+// communicated through the RTP header extension.
+TEST_F(PeerConnectionIntegrationTest, RotatedVideoWithCVOExtension) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  // Add rotated video tracks.
+  caller_pc_wrapper()->AddMediaStreamFromTracks(
+      nullptr, caller_pc_wrapper()->CreateLocalVideoTrackWithRotation(
+                   webrtc::kVideoRotation_90));
+  callee_pc_wrapper()->AddMediaStreamFromTracks(
+      nullptr, callee_pc_wrapper()->CreateLocalVideoTrackWithRotation(
+                   webrtc::kVideoRotation_270));
+
+  // Wait for video frames to be received by both sides.
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  EXPECT_TRUE_WAIT(caller_pc_wrapper()->ReceivedVideoFramesForEachTrack(1),
+                   kMaxWaitForFramesMs);
+  EXPECT_TRUE_WAIT(callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(1),
+                   kMaxWaitForFramesMs);
+
+  // Ensure that the aspect ratio is unmodified.
+  // TODO(deadbeef): Where does 4:3 come from? Should be explicit in the test,
+  // not just assumed.

[pthatcher1, 2017/03/20 18:23:17]

Perhaps make constants for kUnrotatedAspectRatio and kRotatedAspectRatio and use
those here and move the comment about "why 4:3" up to where they are defined.

[Taylor Brandstetter, 2017/03/23 04:46:25]

I don't think that helps, since ultimately the constant should be removed and
the test should contain the 4:3 value explicitly, both when setting up the video
track and for the assertion.

+  EXPECT_EQ(4.0 / 3, caller_pc_wrapper()->local_rendered_aspect_ratio());
+  EXPECT_EQ(4.0 / 3, caller_pc_wrapper()->rendered_aspect_ratio());
+  EXPECT_EQ(4.0 / 3, callee_pc_wrapper()->local_rendered_aspect_ratio());
+  EXPECT_EQ(4.0 / 3, callee_pc_wrapper()->rendered_aspect_ratio());
+  // Ensure that the CVO bits were surfaced to the renderer.
+  EXPECT_EQ(webrtc::kVideoRotation_270,
+            caller_pc_wrapper()->rendered_rotation());
+  EXPECT_EQ(webrtc::kVideoRotation_90,
+            callee_pc_wrapper()->rendered_rotation());
+}
+
+// Test that when the CVO extension isn't supported, video is rotated the
+// old-fashioned way, by encoding rotated frames.
+TEST_F(PeerConnectionIntegrationTest, RotatedVideoWithoutCVOExtension) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  // Add rotated video tracks.
+  caller_pc_wrapper()->AddMediaStreamFromTracks(
+      nullptr, caller_pc_wrapper()->CreateLocalVideoTrackWithRotation(
+                   webrtc::kVideoRotation_90));
+  callee_pc_wrapper()->AddMediaStreamFromTracks(
+      nullptr, callee_pc_wrapper()->CreateLocalVideoTrackWithRotation(
+                   webrtc::kVideoRotation_270));
+
+  // Remove the CVO extension from the offered SDP.
+  callee_pc_wrapper()->SetReceivedSdpMunger(
+      [](cricket::SessionDescription* desc) {
+        cricket::VideoContentDescription* video =
+            GetFirstVideoContentDescription(desc);
+        video->ClearRtpHeaderExtensions();
+      });
+  // Wait for video frames to be received by both sides.
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  EXPECT_TRUE_WAIT(caller_pc_wrapper()->ReceivedVideoFramesForEachTrack(1),
+                   kMaxWaitForFramesMs);
+  EXPECT_TRUE_WAIT(callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(1),
+                   kMaxWaitForFramesMs);
+
+  // Expect that the aspect ratio is inversed to account for the 90/270 degree
+  // rotation.
+  // TODO(deadbeef): Where does 4:3 come from? Should be explicit in the test,
+  // not just assumed.
+  EXPECT_EQ(3.0 / 4, caller_pc_wrapper()->local_rendered_aspect_ratio());
+  EXPECT_EQ(3.0 / 4, caller_pc_wrapper()->rendered_aspect_ratio());
+  EXPECT_EQ(3.0 / 4, callee_pc_wrapper()->local_rendered_aspect_ratio());
+  EXPECT_EQ(3.0 / 4, callee_pc_wrapper()->rendered_aspect_ratio());
+  // Expect that each endpoint is unaware of the rotation of the other endpoint.
+  EXPECT_EQ(webrtc::kVideoRotation_0, caller_pc_wrapper()->rendered_rotation());
+  EXPECT_EQ(webrtc::kVideoRotation_0, callee_pc_wrapper()->rendered_rotation());
+}
+
+// TODO(deadbeef): The tests below rely on RTCOfferAnswerOptions to reject an
+// m= section. When we implement Unified Plan SDP, the right way to do this
+// would be by stopping an RtpTransceiver.
+
+// Test that if the answerer rejects the audio m= section, no audio is sent or
+// received, but video still can be.
+TEST_F(PeerConnectionIntegrationTest, AnswererRejectsAudioSection) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  // Only add video track for callee, and set offer_to_receive_audio to 0, so
+  // it will reject the audio m= section completely.
+  PeerConnectionInterface::RTCOfferAnswerOptions options;
+  options.offer_to_receive_audio = 0;
+  callee_pc_wrapper()->SetOfferAnswerOptions(options);
+  callee_pc_wrapper()->AddMediaStreamFromTracks(
+      nullptr, callee_pc_wrapper()->CreateLocalVideoTrack());
+  // Do offer/answer and wait for successful end-to-end video frames.
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  EXPECT_TRUE_WAIT(caller_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+                       kEndVideoFrameCount) &&
+                       callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+                           kEndVideoFrameCount),
+                   kMaxWaitForFramesMs);
+  // Shouldn't have received audio frames at any point.
+  EXPECT_EQ(0, caller_pc_wrapper()->audio_frames_received());
+  EXPECT_EQ(0, callee_pc_wrapper()->audio_frames_received());
+  // Sanity check that the callee's description has a rejected audio section.
+  ASSERT_NE(nullptr, callee_pc_wrapper()->pc()->local_description());
+  const ContentInfo* callee_audio_content = GetFirstAudioContent(
+      callee_pc_wrapper()->pc()->local_description()->description());
+  ASSERT_NE(nullptr, callee_audio_content);
+  EXPECT_TRUE(callee_audio_content->rejected);
+}
+
+// Test that if the answerer rejects the video m= section, no video is sent or
+// received, but audio still can be.
+TEST_F(PeerConnectionIntegrationTest, AnswererRejectsVideoSection) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  // Only add audio track for callee, and set offer_to_receive_video to 0, so
+  // it will reject the video m= section completely.
+  PeerConnectionInterface::RTCOfferAnswerOptions options;
+  options.offer_to_receive_video = 0;
+  callee_pc_wrapper()->SetOfferAnswerOptions(options);
+  callee_pc_wrapper()->AddMediaStreamFromTracks(
+      callee_pc_wrapper()->CreateLocalAudioTrack(), nullptr);
+  // Do offer/answer and wait for successful end-to-end audio frames.
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  EXPECT_TRUE_WAIT(
+      caller_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          callee_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount),
+      kMaxWaitForFramesMs);
+  // Shouldn't have received video frames at any point.
+  EXPECT_EQ(0, caller_pc_wrapper()->video_frames_received());
+  EXPECT_EQ(0, callee_pc_wrapper()->video_frames_received());
+  // Sanity check that the callee's description has a rejected video section.
+  ASSERT_NE(nullptr, callee_pc_wrapper()->pc()->local_description());
+  const ContentInfo* callee_video_content = GetFirstVideoContent(
+      callee_pc_wrapper()->pc()->local_description()->description());
+  ASSERT_NE(nullptr, callee_video_content);
+  EXPECT_TRUE(callee_video_content->rejected);
+}
+
+// Test that if the answerer rejects both audio and video m= sections, nothing
+// bad happens.
+// TODO(deadbeef): Test that a data channel still works. Currently this doesn't
+// test anything but the fact that negotiation succeeds, which doesn't mean
+// much.
+TEST_F(PeerConnectionIntegrationTest, AnswererRejectsAudioAndVideoSections) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  // Don't give the callee any tracks, and set offer_to_receive_X to 0, so it
+  // will reject both audio and video m= sections.
+  PeerConnectionInterface::RTCOfferAnswerOptions options;
+  options.offer_to_receive_audio = 0;
+  options.offer_to_receive_video = 0;
+  callee_pc_wrapper()->SetOfferAnswerOptions(options);
+  // Do offer/answer and wait for stable signaling state.
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  // Sanity check that the callee's description has rejected m= sections.
+  ASSERT_NE(nullptr, callee_pc_wrapper()->pc()->local_description());
+  const ContentInfo* callee_audio_content = GetFirstAudioContent(
+      callee_pc_wrapper()->pc()->local_description()->description());
+  ASSERT_NE(nullptr, callee_audio_content);
+  EXPECT_TRUE(callee_audio_content->rejected);
+  const ContentInfo* callee_video_content = GetFirstVideoContent(
+      callee_pc_wrapper()->pc()->local_description()->description());
+  ASSERT_NE(nullptr, callee_video_content);
+  EXPECT_TRUE(callee_video_content->rejected);
+}
+
+// This test sets up an audio and video call between two parties. After the
+// call runs for a while, the caller sends an updated offer with video being
+// rejected. Once the re-negotiation is done, the video flow should stop and
+// the audio flow should continue.
+TEST_F(PeerConnectionIntegrationTest, VideoRejectedInSubsequentOffer) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  EXPECT_TRUE_WAIT(
+      caller_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          caller_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount) &&
+          callee_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount),
+      kMaxWaitForFramesMs);
+
+  // Renegotiate, rejecting the video m= section.
+  // TODO(deadbeef): When an RtpTransceiver API is available, use that to
+  // reject the video m= section.
+  caller_pc_wrapper()->SetGeneratedSdpMunger(
+      [](cricket::SessionDescription* description) {
+        for (cricket::ContentInfo& content : description->contents()) {
+          if (cricket::IsVideoContent(&content)) {
+            content.rejected = true;
+          }
+        }
+      });
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kMaxWaitForActivationMs);
+
+  // Sanity check that the caller's description has a rejected video section.
+  ASSERT_NE(nullptr, caller_pc_wrapper()->pc()->local_description());
+  const ContentInfo* caller_video_content = GetFirstVideoContent(
+      caller_pc_wrapper()->pc()->local_description()->description());
+  ASSERT_NE(nullptr, caller_video_content);
+  EXPECT_TRUE(caller_video_content->rejected);
+
+  int caller_audio_received = caller_pc_wrapper()->audio_frames_received();
+  int caller_video_received = caller_pc_wrapper()->video_frames_received();
+  int callee_audio_received = callee_pc_wrapper()->audio_frames_received();
+  int callee_video_received = callee_pc_wrapper()->video_frames_received();
+
+  // Wait for some additional audio frames to be received.
+  EXPECT_TRUE_WAIT(caller_pc_wrapper()->ReceivedAudioFrames(
+                       caller_audio_received + kEndAudioFrameCount) &&
+                       callee_pc_wrapper()->ReceivedAudioFrames(
+                           callee_audio_received + kEndAudioFrameCount),
+                   kMaxWaitForFramesMs);
+
+  // During this time, we shouldn't have received any additional video frames
+  // for the rejected video tracks.
+  EXPECT_EQ(caller_video_received,
+            caller_pc_wrapper()->video_frames_received());
+  EXPECT_EQ(callee_video_received,
+            callee_pc_wrapper()->video_frames_received());
+}
+
+// Basic end-to-end test, but without SSRC/MSID signaling. This functionality
+// is needed to support legacy endpoints.
+// TODO(deadbeef): When we support the MID extension and demuxing on MID, also
+// add a test for an end-to-end test without MID signaling either (basically,
+// the minimum acceptable SDP).
+TEST_F(PeerConnectionIntegrationTest, EndToEndCallWithoutSsrcOrMsidSignaling) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  // Add audio and video, testing that packets can be demuxed on payload type.
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  // Remove all stream information (SSRCs, track IDs, etc.) and "msid-semantic"
+  // attribute from received SDP, simulating a legacy endpoint.
+  callee_pc_wrapper()->SetReceivedSdpMunger(
+      [](cricket::SessionDescription* desc) {
+        for (ContentInfo& content : desc->contents()) {
+          MediaContentDescription* media_desc =
+              static_cast<MediaContentDescription*>(content.description);
+          media_desc->mutable_streams().clear();
+        }
+        desc->set_msid_supported(false);
+      });
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  EXPECT_TRUE_WAIT(
+      caller_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          caller_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount) &&
+          callee_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount),
+      kMaxWaitForFramesMs);
+}
+
+// Test that if two video tracks are sent (from caller to callee, in this test),
+// they're transmitted correctly end-to-end.
+TEST_F(PeerConnectionIntegrationTest, EndToEndCallWithTwoVideoTracks) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  // Add one audio/video stream, and one video-only stream.
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->AddMediaStreamFromTracksWithLabel(
+      nullptr, caller_pc_wrapper()->CreateLocalVideoTrackWithId("extra_track"),
+      "extra_stream");
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  ASSERT_EQ(2u, callee_pc_wrapper()->number_of_remote_streams());
+  EXPECT_TRUE_WAIT(
+      callee_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount),
+      kMaxWaitForFramesMs);
+}
+
+// Test that if applying a true "max bundle" offer, which uses ports of 0,
+// "a=bundle-only", omitting "a=fingerprint", "a=setup", "a=ice-ufrag" and
+// "a=ice-pwd" for all but the audio "m=" section, negotiation still completes
+// successfully and media flows.
+// TODO(deadbeef): Update this test to also omit "a=rtcp-mux", once that works.
+// TODO(deadbeef): Won't need this test once we start generating actual
+// standards-compliant SDP.
+TEST_F(PeerConnectionIntegrationTest,
+       EndToEndCallWithSpecCompliantMaxBundleOffer) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  // Do the equivalent of setting the port to 0, adding a=bundle-only, and
+  // removing a=ice-ufrag, a=ice-pwd, a=fingerprint and a=setup from all
+  // but the first m= section.
+  callee_pc_wrapper()->SetReceivedSdpMunger(
+      [](cricket::SessionDescription* desc) {
+        bool first = true;
+        for (cricket::ContentInfo& content : desc->contents()) {
+          if (first) {
+            first = false;
+            continue;
+          }
+          content.bundle_only = true;
+        }
+        first = true;
+        for (cricket::TransportInfo& transport : desc->transport_infos()) {
+          if (first) {
+            first = false;
+            continue;
+          }
+          transport.description.ice_ufrag.clear();
+          transport.description.ice_pwd.clear();
+          transport.description.connection_role = cricket::CONNECTIONROLE_NONE;
+          transport.description.identity_fingerprint.reset(nullptr);
+        }
+      });

[pthatcher1, 2017/03/20 18:23:17]

Would it be worth giving this a named method? 
callee_pc_wrapper()->SetReceivedSdpMunger(MakeSpecCompliantMaxBundle) would look
nice.

[Taylor Brandstetter, 2017/03/23 04:46:25]

Done.

+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  EXPECT_TRUE_WAIT(
+      caller_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          caller_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount) &&
+          callee_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount),
+      kMaxWaitForFramesMs);
+}
+
+// Test that we can receive the audio output level from a remote audio track.
+// TODO(deadbeef): Use a fake audio source and verify that the output level is
+// exactly what the source on the other side was configured with.
+TEST_F(PeerConnectionIntegrationTest, GetAudioOutputLevelStats) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  // Just add an audio track.
+  caller_pc_wrapper()->AddMediaStreamFromTracks(
+      caller_pc_wrapper()->CreateLocalAudioTrack(), nullptr);
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+
+  // Get the audio output level stats. Note that the level is not available
+  // until an RTCP packet has been received.
+  EXPECT_TRUE_WAIT(callee_pc_wrapper()->GetStats()->AudioOutputLevel() > 0,
+                   kMaxWaitForFramesMs);
+}
+
+// Test that an audio input level is reported.
+// TODO(deadbeef): Use a fake audio source and verify that the input level is
+// exactly what the source was configured with.
+TEST_F(PeerConnectionIntegrationTest, GetAudioInputLevelStats) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  // Just add an audio track.
+  caller_pc_wrapper()->AddMediaStreamFromTracks(
+      caller_pc_wrapper()->CreateLocalAudioTrack(), nullptr);
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+
+  // Get the audio input level stats. The level should be available very
+  // soon after the test starts.
+  EXPECT_TRUE_WAIT(caller_pc_wrapper()->GetStats()->AudioInputLevel() > 0,
+                   kMaxWaitForStatsMs);
+}
+
+// Test that we can get incoming byte counts from both audio and video tracks.
+TEST_F(PeerConnectionIntegrationTest, GetBytesReceivedStats) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  // Do offer/answer, wait for the callee to receive some frames.
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  EXPECT_TRUE_WAIT(
+      callee_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount),
+      kMaxWaitForFramesMs);
+
+  // Get a handle to the remote tracks created, so they can be used as GetStats
+  // filters.
+  StreamCollectionInterface* remote_streams =
+      callee_pc_wrapper()->remote_streams();
+  ASSERT_EQ(1u, remote_streams->count());
+  ASSERT_EQ(1u, remote_streams->at(0)->GetAudioTracks().size());
+  ASSERT_EQ(1u, remote_streams->at(0)->GetVideoTracks().size());
+  MediaStreamTrackInterface* remote_audio_track =
+      remote_streams->at(0)->GetAudioTracks()[0];
+  MediaStreamTrackInterface* remote_video_track =
+      remote_streams->at(0)->GetVideoTracks()[0];
+
+  // We received frames, so we definitely should have nonzero "received bytes"
+  // stats at this point.
+  EXPECT_GT(callee_pc_wrapper()
+                ->GetStatsForTrack(remote_audio_track)
+                ->BytesReceived(),
+            0);
+  EXPECT_GT(callee_pc_wrapper()
+                ->GetStatsForTrack(remote_video_track)
+                ->BytesReceived(),
+            0);
+}
+
+// Test that we can get outgoing byte counts from both audio and video tracks.
+TEST_F(PeerConnectionIntegrationTest, GetBytesSentStats) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  auto audio_track = caller_pc_wrapper()->CreateLocalAudioTrack();
+  auto video_track = caller_pc_wrapper()->CreateLocalVideoTrack();
+  caller_pc_wrapper()->AddMediaStreamFromTracks(audio_track, video_track);
+  // Do offer/answer, wait for the callee to receive some frames.
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  EXPECT_TRUE_WAIT(
+      callee_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount),
+      kMaxWaitForFramesMs);
+
+  // The callee received frames, so we definitely should have nonzero "sent
+  // bytes" stats at this point.
+  EXPECT_GT(caller_pc_wrapper()->GetStatsForTrack(audio_track)->BytesSent(), 0);
+  EXPECT_GT(caller_pc_wrapper()->GetStatsForTrack(video_track)->BytesSent(), 0);
+}
+
+// Test that DTLS 1.0 is used if both sides only support DTLS 1.0.
+TEST_F(PeerConnectionIntegrationTest, EndToEndCallWithDtls10) {
+  PeerConnectionFactory::Options dtls_10_options;
+  dtls_10_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_10;
+  ASSERT_TRUE(CreatePeerConnectionWrappersWithOptions(dtls_10_options,
+                                                      dtls_10_options));
+  ConnectFakeSignaling();
+  // Do normal offer/answer and wait for some frames to be received in each
+  // direction.
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  EXPECT_TRUE_WAIT(
+      caller_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          caller_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount) &&
+          callee_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount),
+      kMaxWaitForFramesMs);
+}
+
+// Test getting cipher stats and UMA metrics when DTLS 1.0 is negotiated.
+TEST_F(PeerConnectionIntegrationTest, Dtls10CipherStatsAndUmaMetrics) {
+  PeerConnectionFactory::Options dtls_10_options;
+  dtls_10_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_10;
+  ASSERT_TRUE(CreatePeerConnectionWrappersWithOptions(dtls_10_options,
+                                                      dtls_10_options));
+  ConnectFakeSignaling();
+  // Register UMA observer before signaling begins.
+  rtc::scoped_refptr<webrtc::FakeMetricsObserver> caller_observer =
+      new rtc::RefCountedObject<webrtc::FakeMetricsObserver>();
+  caller_pc_wrapper()->pc()->RegisterUMAObserver(caller_observer);
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  EXPECT_TRUE_WAIT(
+      rtc::SSLStreamAdapter::IsAcceptableCipher(
+          caller_pc_wrapper()->GetStats()->DtlsCipher(), rtc::KT_DEFAULT),
+      kDefaultTimeout);
+  EXPECT_EQ_WAIT(rtc::SrtpCryptoSuiteToName(kDefaultSrtpCryptoSuite),
+                 caller_pc_wrapper()->GetStats()->SrtpCipher(),
+                 kDefaultTimeout);
+  EXPECT_EQ(1,
+            caller_observer->GetEnumCounter(webrtc::kEnumCounterAudioSrtpCipher,
+                                            kDefaultSrtpCryptoSuite));
+}
+
+// Test getting cipher stats and UMA metrics when DTLS 1.2 is negotiated.
+TEST_F(PeerConnectionIntegrationTest, Dtls12CipherStatsAndUmaMetrics) {
+  PeerConnectionFactory::Options dtls_12_options;
+  dtls_12_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_12;
+  ASSERT_TRUE(CreatePeerConnectionWrappersWithOptions(dtls_12_options,
+                                                      dtls_12_options));
+  ConnectFakeSignaling();
+  // Register UMA observer before signaling begins.
+  rtc::scoped_refptr<webrtc::FakeMetricsObserver> caller_observer =
+      new rtc::RefCountedObject<webrtc::FakeMetricsObserver>();
+  caller_pc_wrapper()->pc()->RegisterUMAObserver(caller_observer);
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  EXPECT_TRUE_WAIT(
+      rtc::SSLStreamAdapter::IsAcceptableCipher(
+          caller_pc_wrapper()->GetStats()->DtlsCipher(), rtc::KT_DEFAULT),
+      kDefaultTimeout);
+  EXPECT_EQ_WAIT(rtc::SrtpCryptoSuiteToName(kDefaultSrtpCryptoSuite),
+                 caller_pc_wrapper()->GetStats()->SrtpCipher(),
+                 kDefaultTimeout);
+  EXPECT_EQ(1,
+            caller_observer->GetEnumCounter(webrtc::kEnumCounterAudioSrtpCipher,
+                                            kDefaultSrtpCryptoSuite));
+}
+
+// Test that DTLS 1.0 can be used if the caller supports DTLS 1.2 and the
+// callee only supports 1.0.
+TEST_F(PeerConnectionIntegrationTest, CallerDtls12ToCalleeDtls10) {
+  PeerConnectionFactory::Options caller_options;
+  caller_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_12;
+  PeerConnectionFactory::Options callee_options;
+  callee_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_10;
+  ASSERT_TRUE(
+      CreatePeerConnectionWrappersWithOptions(caller_options, callee_options));
+  ConnectFakeSignaling();
+  // Do normal offer/answer and wait for some frames to be received in each
+  // direction.
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  EXPECT_TRUE_WAIT(
+      caller_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          caller_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount) &&
+          callee_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount),
+      kMaxWaitForFramesMs);
+}
+
+// Test that DTLS 1.0 can be used if the caller only supports DTLS 1.0 and the
+// callee supports 1.2.
+TEST_F(PeerConnectionIntegrationTest, CallerDtls10ToCalleeDtls12) {
+  PeerConnectionFactory::Options caller_options;
+  caller_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_10;
+  PeerConnectionFactory::Options callee_options;
+  callee_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_12;
+  ASSERT_TRUE(
+      CreatePeerConnectionWrappersWithOptions(caller_options, callee_options));
+  ConnectFakeSignaling();
+  // Do normal offer/answer and wait for some frames to be received in each
+  // direction.
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  EXPECT_TRUE_WAIT(
+      caller_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          caller_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount) &&
+          callee_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount),
+      kMaxWaitForFramesMs);
+}
+
+// Test that a non-GCM cipher is used if both sides only support non-GCM.
+TEST_F(PeerConnectionIntegrationTest, NonGcmCipherUsedWhenGcmNotSupported) {
+  bool local_gcm_enabled = false;
+  bool remote_gcm_enabled = false;
+  int expected_cipher_suite = kDefaultSrtpCryptoSuite;
+  TestGcmNegotiationUsesCipherSuite(local_gcm_enabled, remote_gcm_enabled,
+                                    expected_cipher_suite);
+}
+
+// Test that a GCM cipher is used if both ends support it.
+TEST_F(PeerConnectionIntegrationTest, GcmCipherUsedWhenGcmSupported) {
+  bool local_gcm_enabled = true;
+  bool remote_gcm_enabled = true;
+  int expected_cipher_suite = kDefaultSrtpCryptoSuiteGcm;
+  TestGcmNegotiationUsesCipherSuite(local_gcm_enabled, remote_gcm_enabled,
+                                    expected_cipher_suite);
+}
+
+// Test that GCM isn't used if only the offerer supports it.
+TEST_F(PeerConnectionIntegrationTest,
+       NonGcmCipherUsedWhenOnlyCallerSupportsGcm) {
+  bool local_gcm_enabled = true;
+  bool remote_gcm_enabled = false;
+  int expected_cipher_suite = kDefaultSrtpCryptoSuite;
+  TestGcmNegotiationUsesCipherSuite(local_gcm_enabled, remote_gcm_enabled,
+                                    expected_cipher_suite);
+}
+
+// Test that GCM isn't used if only the answerer supports it.
+TEST_F(PeerConnectionIntegrationTest,
+       NonGcmCipherUsedWhenOnlyCalleeSupportsGcm) {
+  bool local_gcm_enabled = false;
+  bool remote_gcm_enabled = true;
+  int expected_cipher_suite = kDefaultSrtpCryptoSuite;
+  TestGcmNegotiationUsesCipherSuite(local_gcm_enabled, remote_gcm_enabled,
+                                    expected_cipher_suite);
+}
+
+// This test sets up a call between two parties with audio, video and an RTP
+// data channel.
+TEST_F(PeerConnectionIntegrationTest, EndToEndCallWithRtpDataChannel) {
+  FakeConstraints setup_constraints;
+  setup_constraints.SetAllowRtpDataChannels();
+  ASSERT_TRUE(CreatePeerConnectionWrappersWithConstraints(&setup_constraints,
+                                                          &setup_constraints));
+  ConnectFakeSignaling();
+  // Expect that data channel created on caller side will show up for callee as
+  // well.
+  caller_pc_wrapper()->CreateDataChannel();
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  // Ensure the existence of the RTP data channel didn't impede audio/video.
+  EXPECT_TRUE_WAIT(
+      caller_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          caller_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount) &&
+          callee_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount),
+      kMaxWaitForFramesMs);
+  ASSERT_NE(nullptr, caller_pc_wrapper()->data_channel());
+  ASSERT_NE(nullptr, callee_pc_wrapper()->data_channel());
+  EXPECT_TRUE_WAIT(caller_pc_wrapper()->data_observer()->IsOpen(),
+                   kDefaultTimeout);
+  EXPECT_TRUE_WAIT(callee_pc_wrapper()->data_observer()->IsOpen(),
+                   kDefaultTimeout);
+
+  // Ensure data can be sent in both directions.
+  std::string data = "hello world";
+  SendRtpDataWithRetries(caller_pc_wrapper()->data_channel(), data, 5);
+  EXPECT_EQ_WAIT(data, callee_pc_wrapper()->data_observer()->last_message(),
+                 kDefaultTimeout);
+  SendRtpDataWithRetries(callee_pc_wrapper()->data_channel(), data, 5);
+  EXPECT_EQ_WAIT(data, caller_pc_wrapper()->data_observer()->last_message(),
+                 kDefaultTimeout);
+}
+
+// Ensure that an RTP data channel is signaled as closed for the caller when
+// the callee rejects it in a subsequent offer.
+TEST_F(PeerConnectionIntegrationTest,
+       RtpDataChannelSignaledClosedInCalleeOffer) {
+  // Same procedure as above test.
+  FakeConstraints setup_constraints;
+  setup_constraints.SetAllowRtpDataChannels();
+  ASSERT_TRUE(CreatePeerConnectionWrappersWithConstraints(&setup_constraints,
+                                                          &setup_constraints));
+  ConnectFakeSignaling();
+  caller_pc_wrapper()->CreateDataChannel();
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  ASSERT_NE(nullptr, caller_pc_wrapper()->data_channel());
+  ASSERT_NE(nullptr, callee_pc_wrapper()->data_channel());
+  ASSERT_TRUE_WAIT(caller_pc_wrapper()->data_observer()->IsOpen(),
+                   kDefaultTimeout);
+  ASSERT_TRUE_WAIT(callee_pc_wrapper()->data_observer()->IsOpen(),
+                   kDefaultTimeout);
+
+  // Close the data channel on the callee, and do an updated offer/answer.
+  callee_pc_wrapper()->data_channel()->Close();
+  callee_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  EXPECT_FALSE(caller_pc_wrapper()->data_observer()->IsOpen());
+  EXPECT_FALSE(callee_pc_wrapper()->data_observer()->IsOpen());
+}
+
+// Tests that data is buffered in an RTP data channel until an observer is
+// registered for it.
+//
+// NOTE: 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 expected to be used in that case.
+TEST_F(PeerConnectionIntegrationTest,
+       DataBufferedUntilRtpDataChannelObserverRegistered) {
+  // Use fake clock and simulated network delay so that we predictably can wait
+  // until an SCTP message has been delivered without "sleep()"ing.
+  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));
+  virtual_socket_server()->set_delay_mean(5);  // 5 ms per hop.
+  virtual_socket_server()->UpdateDelayDistribution();
+
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  caller_pc_wrapper()->CreateDataChannel();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE(caller_pc_wrapper()->data_channel() != nullptr);
+  ASSERT_TRUE_SIMULATED_WAIT(callee_pc_wrapper()->data_channel() != nullptr,
+                             kDefaultTimeout, fake_clock);
+  ASSERT_TRUE_SIMULATED_WAIT(caller_pc_wrapper()->data_observer()->IsOpen(),
+                             kDefaultTimeout, fake_clock);
+  ASSERT_EQ_SIMULATED_WAIT(DataChannelInterface::kOpen,
+                           callee_pc_wrapper()->data_channel()->state(),
+                           kDefaultTimeout, fake_clock);
+
+  // Unregister the observer which is normally automatically registered.
+  callee_pc_wrapper()->data_channel()->UnregisterObserver();
+  // Send data and advance fake clock until it should have been received.
+  std::string data = "hello world";
+  caller_pc_wrapper()->data_channel()->Send(DataBuffer(data));
+  SIMULATED_WAIT(false, 50, fake_clock);
+
+  // Attach data channel and expect data to be received immediately. Note that
+  // EXPECT_EQ_WAIT is used, such that the simulated clock is not advanced any
+  // further, but data can be received even if the callback is asynchronous.
+  MockDataChannelObserver new_observer(callee_pc_wrapper()->data_channel());
+  EXPECT_EQ_SIMULATED_WAIT(data, new_observer.last_message(), kDefaultTimeout,
+                           fake_clock);
+}
+
+// This test sets up a call between two parties with audio, video and but only
+// the caller client supports RTP data channels.
+TEST_F(PeerConnectionIntegrationTest, RtpDataChannelsRejectedByCallee) {
+  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(CreatePeerConnectionWrappersWithConstraints(
+      &setup_constraints_1, &setup_constraints_2));
+  ConnectFakeSignaling();
+  caller_pc_wrapper()->CreateDataChannel();
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  // The caller should still have a data channel, but it should be closed, and
+  // one should ever have been created for the callee.
+  EXPECT_TRUE(caller_pc_wrapper()->data_channel() != nullptr);
+  EXPECT_FALSE(caller_pc_wrapper()->data_observer()->IsOpen());
+  EXPECT_EQ(nullptr, callee_pc_wrapper()->data_channel());
+}
+
+// This test sets up a call between two parties with audio, and video. When
+// audio and video is setup and flowing, an RTP data channel is negotiated.
+TEST_F(PeerConnectionIntegrationTest, AddRtpDataChannelInSubsequentOffer) {
+  FakeConstraints setup_constraints;
+  setup_constraints.SetAllowRtpDataChannels();
+  ASSERT_TRUE(CreatePeerConnectionWrappersWithConstraints(&setup_constraints,
+                                                          &setup_constraints));
+  ConnectFakeSignaling();
+  // Do initial offer/answer with audio/video.
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  // Create data channel and do new offer and answer.
+  caller_pc_wrapper()->CreateDataChannel();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  ASSERT_NE(nullptr, caller_pc_wrapper()->data_channel());
+  ASSERT_NE(nullptr, callee_pc_wrapper()->data_channel());
+  EXPECT_TRUE_WAIT(caller_pc_wrapper()->data_observer()->IsOpen(),
+                   kDefaultTimeout);
+  EXPECT_TRUE_WAIT(callee_pc_wrapper()->data_observer()->IsOpen(),
+                   kDefaultTimeout);
+  // Ensure data can be sent in both directions.
+  std::string data = "hello world";
+  SendRtpDataWithRetries(caller_pc_wrapper()->data_channel(), data, 5);
+  EXPECT_EQ_WAIT(data, callee_pc_wrapper()->data_observer()->last_message(),
+                 kDefaultTimeout);
+  SendRtpDataWithRetries(callee_pc_wrapper()->data_channel(), data, 5);
+  EXPECT_EQ_WAIT(data, caller_pc_wrapper()->data_observer()->last_message(),
+                 kDefaultTimeout);
+}
+
+#ifdef HAVE_SCTP
+
+// This test sets up a call between two parties with audio, video and an SCTP
+// data channel.
+TEST_F(PeerConnectionIntegrationTest, EndToEndCallWithSctpDataChannel) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  // Expect that data channel created on caller side will show up for callee as
+  // well.
+  caller_pc_wrapper()->CreateDataChannel();
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  // Ensure the existence of the SCTP data channel didn't impede audio/video.
+  EXPECT_TRUE_WAIT(
+      caller_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          caller_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount) &&
+          callee_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount),
+      kMaxWaitForFramesMs);
+  // Caller data channel should already exist (it created one). Callee data
+  // channel may not exist yet, since negotiation happens in-band, not in SDP.
+  ASSERT_NE(nullptr, caller_pc_wrapper()->data_channel());
+  ASSERT_TRUE_WAIT(callee_pc_wrapper()->data_channel() != nullptr,
+                   kDefaultTimeout);
+  EXPECT_TRUE_WAIT(caller_pc_wrapper()->data_observer()->IsOpen(),
+                   kDefaultTimeout);
+  EXPECT_TRUE_WAIT(callee_pc_wrapper()->data_observer()->IsOpen(),
+                   kDefaultTimeout);
+
+  // Ensure data can be sent in both directions.
+  std::string data = "hello world";
+  caller_pc_wrapper()->data_channel()->Send(DataBuffer(data));
+  EXPECT_EQ_WAIT(data, callee_pc_wrapper()->data_observer()->last_message(),
+                 kDefaultTimeout);
+  callee_pc_wrapper()->data_channel()->Send(DataBuffer(data));
+  EXPECT_EQ_WAIT(data, caller_pc_wrapper()->data_observer()->last_message(),
+                 kDefaultTimeout);
+}
+
+// Ensure that when the callee closes an SCTP data channel, the closing
+// procedure results in the data channel being closed for the caller as well.
+TEST_F(PeerConnectionIntegrationTest, CalleeClosesSctpDataChannel) {
+  // Same procedure as above test.
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  caller_pc_wrapper()->CreateDataChannel();
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  ASSERT_NE(nullptr, caller_pc_wrapper()->data_channel());
+  ASSERT_TRUE_WAIT(callee_pc_wrapper()->data_channel() != nullptr,
+                   kDefaultTimeout);
+  ASSERT_TRUE_WAIT(caller_pc_wrapper()->data_observer()->IsOpen(),
+                   kDefaultTimeout);
+  ASSERT_TRUE_WAIT(callee_pc_wrapper()->data_observer()->IsOpen(),
+                   kDefaultTimeout);
+
+  // Close the data channel on the callee side, and wait for it to reach the
+  // "closed" state on both sides.
+  callee_pc_wrapper()->data_channel()->Close();
+  EXPECT_TRUE_WAIT(!caller_pc_wrapper()->data_observer()->IsOpen(),
+                   kDefaultTimeout);
+  EXPECT_TRUE_WAIT(!callee_pc_wrapper()->data_observer()->IsOpen(),
+                   kDefaultTimeout);
+}
+
+// Test usrsctp's ability to process unordered data stream, where data actually
+// arrives out of order using simulated delays. Previously there have been some
+// bugs in this area.
+TEST_F(PeerConnectionIntegrationTest, StressTestUnorderedSctpDataChannel) {
+  // Introduce random network delays.
+  // Otherwise it's not a true "unordered" test.
+  virtual_socket_server()->set_delay_mean(20);
+  virtual_socket_server()->set_delay_stddev(5);
+  virtual_socket_server()->UpdateDelayDistribution();
+  // Normal procedure, but with unordered data channel config.
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  webrtc::DataChannelInit init;
+  init.ordered = false;
+  caller_pc_wrapper()->CreateDataChannel(&init);
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  ASSERT_NE(nullptr, caller_pc_wrapper()->data_channel());
+  ASSERT_TRUE_WAIT(callee_pc_wrapper()->data_channel() != nullptr,
+                   kDefaultTimeout);
+  ASSERT_TRUE_WAIT(caller_pc_wrapper()->data_observer()->IsOpen(),
+                   kDefaultTimeout);
+  ASSERT_TRUE_WAIT(callee_pc_wrapper()->data_observer()->IsOpen(),
+                   kDefaultTimeout);
+
+  static constexpr int kNumMessages = 100;
+  // Deliberately chosen to be larger than the MTU so messages get fragmented.
+  static constexpr size_t kMaxMessageSize = 4096;
+  // Create and send random messages.
+  std::vector<std::string> sent_messages;
+  for (int i = 0; i < kNumMessages; ++i) {
+    size_t length =
+        (rand() % kMaxMessageSize) + 1;  // NOLINT (rand_r instead of rand)
+    std::string message;
+    ASSERT_TRUE(rtc::CreateRandomString(length, &message));
+    caller_pc_wrapper()->data_channel()->Send(DataBuffer(message));
+    callee_pc_wrapper()->data_channel()->Send(DataBuffer(message));
+    sent_messages.push_back(message);
+  }
+
+  // Wait for all messages to be received.
+  EXPECT_EQ_WAIT(kNumMessages,
+                 caller_pc_wrapper()->data_observer()->received_message_count(),
+                 kDefaultTimeout);
+  EXPECT_EQ_WAIT(kNumMessages,
+                 callee_pc_wrapper()->data_observer()->received_message_count(),
+                 kDefaultTimeout);
+
+  // Sort and compare to make sure none of the messages were corrupted.
+  std::vector<std::string> caller_pc_wrapper_received_messages =
+      caller_pc_wrapper()->data_observer()->messages();
+  std::vector<std::string> callee_pc_wrapper_received_messages =
+      callee_pc_wrapper()->data_observer()->messages();
+  std::sort(sent_messages.begin(), sent_messages.end());
+  std::sort(caller_pc_wrapper_received_messages.begin(),
+            caller_pc_wrapper_received_messages.end());
+  std::sort(callee_pc_wrapper_received_messages.begin(),
+            callee_pc_wrapper_received_messages.end());
+  EXPECT_EQ(sent_messages, caller_pc_wrapper_received_messages);
+  EXPECT_EQ(sent_messages, callee_pc_wrapper_received_messages);
+}
+
+// This test sets up a call between two parties with audio, and video. When
+// audio and video are setup and flowing, an SCTP data channel is negotiated.
+TEST_F(PeerConnectionIntegrationTest, AddSctpDataChannelInSubsequentOffer) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  // Do initial offer/answer with audio/video.
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  // Create data channel and do new offer and answer.
+  caller_pc_wrapper()->CreateDataChannel();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  // Caller data channel should already exist (it created one). Callee data
+  // channel may not exist yet, since negotiation happens in-band, not in SDP.
+  ASSERT_NE(nullptr, caller_pc_wrapper()->data_channel());
+  ASSERT_TRUE_WAIT(callee_pc_wrapper()->data_channel() != nullptr,
+                   kDefaultTimeout);
+  EXPECT_TRUE_WAIT(caller_pc_wrapper()->data_observer()->IsOpen(),
+                   kDefaultTimeout);
+  EXPECT_TRUE_WAIT(callee_pc_wrapper()->data_observer()->IsOpen(),
+                   kDefaultTimeout);
+  // Ensure data can be sent in both directions.
+  std::string data = "hello world";
+  caller_pc_wrapper()->data_channel()->Send(DataBuffer(data));
+  EXPECT_EQ_WAIT(data, callee_pc_wrapper()->data_observer()->last_message(),
+                 kDefaultTimeout);
+  callee_pc_wrapper()->data_channel()->Send(DataBuffer(data));
+  EXPECT_EQ_WAIT(data, caller_pc_wrapper()->data_observer()->last_message(),
+                 kDefaultTimeout);
+}
+
+#endif  // HAVE_SCTP
+
+// Test that the ICE connection and gathering states eventually reach
+// "complete".
+TEST_F(PeerConnectionIntegrationTest, IceStatesReachCompletion) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  // Do normal offer/answer.
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceGatheringComplete,
+                 caller_pc_wrapper()->ice_gathering_state(),
+                 kMaxWaitForFramesMs);
+  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceGatheringComplete,
+                 callee_pc_wrapper()->ice_gathering_state(),
+                 kMaxWaitForFramesMs);
+  // After the best candidate pair is selected and all candidates are signaled,
+  // the ICE connection state should reach "complete".
+  // TODO(deadbeef): Currently, the ICE "controlled" agent (the
+  // answerer/"callee" by default) only reaches "connected". When this is
+  // fixed, this test should be updated.
+  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionCompleted,
+                 caller_pc_wrapper()->ice_connection_state(), kDefaultTimeout);
+  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected,
+                 callee_pc_wrapper()->ice_connection_state(), kDefaultTimeout);
+}
+
+// This test sets up a call between two parties with audio and video.
+// During the call, the caller restarts ICE and the test verifies that
+// new ICE candidates are generated and audio and video still can flow, and the
+// ICE state reaches completed again.
+TEST_F(PeerConnectionIntegrationTest, MediaContinuesFlowingAfterIceRestart) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  // Do normal offer/answer and wait for ICE to complete.
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionCompleted,
+                 caller_pc_wrapper()->ice_connection_state(),
+                 kMaxWaitForFramesMs);
+  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected,
+                 callee_pc_wrapper()->ice_connection_state(),
+                 kMaxWaitForFramesMs);
+
+  // To verify that the ICE restart actually occurs, get
+  // ufrag/password/candidates before and after restart.
+  // Create an SDP string of the first audio candidate for both clients.
+  const webrtc::IceCandidateCollection* audio_candidates_caller =
+      caller_pc_wrapper()->pc()->local_description()->candidates(0);
+  const webrtc::IceCandidateCollection* audio_candidates_callee =
+      callee_pc_wrapper()->pc()->local_description()->candidates(0);
+  ASSERT_GT(audio_candidates_caller->count(), 0u);
+  ASSERT_GT(audio_candidates_callee->count(), 0u);
+  std::string caller_candidate_pre_restart;
+  ASSERT_TRUE(
+      audio_candidates_caller->at(0)->ToString(&caller_candidate_pre_restart));
+  std::string callee_candidate_pre_restart;
+  ASSERT_TRUE(
+      audio_candidates_callee->at(0)->ToString(&callee_candidate_pre_restart));
+  const cricket::SessionDescription* desc =
+      caller_pc_wrapper()->pc()->local_description()->description();
+  std::string caller_ufrag_pre_restart =
+      desc->transport_infos()[0].description.ice_ufrag;
+  desc = callee_pc_wrapper()->pc()->local_description()->description();
+  std::string callee_ufrag_pre_restart =
+      desc->transport_infos()[0].description.ice_ufrag;
+
+  // Have the caller initiate an ICE restart.
+  caller_pc_wrapper()->SetOfferAnswerOptions(IceRestartOfferAnswerOptions());
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionCompleted,
+                 caller_pc_wrapper()->ice_connection_state(),
+                 kMaxWaitForFramesMs);
+  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected,
+                 callee_pc_wrapper()->ice_connection_state(),
+                 kMaxWaitForFramesMs);
+
+  // Grab the ufrags/candidates again.
+  audio_candidates_caller =
+      caller_pc_wrapper()->pc()->local_description()->candidates(0);
+  audio_candidates_callee =
+      callee_pc_wrapper()->pc()->local_description()->candidates(0);
+  ASSERT_GT(audio_candidates_caller->count(), 0u);
+  ASSERT_GT(audio_candidates_callee->count(), 0u);
+  std::string caller_candidate_post_restart;
+  ASSERT_TRUE(
+      audio_candidates_caller->at(0)->ToString(&caller_candidate_post_restart));
+  std::string callee_candidate_post_restart;
+  ASSERT_TRUE(
+      audio_candidates_callee->at(0)->ToString(&callee_candidate_post_restart));
+  desc = caller_pc_wrapper()->pc()->local_description()->description();
+  std::string caller_ufrag_post_restart =
+      desc->transport_infos()[0].description.ice_ufrag;
+  desc = callee_pc_wrapper()->pc()->local_description()->description();
+  std::string callee_ufrag_post_restart =
+      desc->transport_infos()[0].description.ice_ufrag;
+  // Sanity check that an ICE restart was actually negotiated in SDP.
+  ASSERT_NE(caller_candidate_pre_restart, caller_candidate_post_restart);
+  ASSERT_NE(callee_candidate_pre_restart, callee_candidate_post_restart);
+  ASSERT_NE(caller_ufrag_pre_restart, caller_ufrag_post_restart);
+  ASSERT_NE(callee_ufrag_pre_restart, callee_ufrag_post_restart);
+
+  // Ensure that additional frames are received after the ICE restart.
+  int last_caller_audio_frames = caller_pc_wrapper()->audio_frames_received();
+  int last_caller_video_frames = caller_pc_wrapper()->video_frames_received();
+  int last_callee_audio_frames = callee_pc_wrapper()->audio_frames_received();
+  int last_callee_video_frames = callee_pc_wrapper()->video_frames_received();
+  EXPECT_TRUE_WAIT(caller_pc_wrapper()->ReceivedAudioFrames(
+                       kEndAudioFrameCount + last_caller_audio_frames) &&
+                       caller_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+                           kEndVideoFrameCount + last_caller_video_frames) &&
+                       callee_pc_wrapper()->ReceivedAudioFrames(
+                           kEndAudioFrameCount + last_callee_audio_frames) &&
+                       callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+                           kEndVideoFrameCount + last_callee_video_frames),
+                   kMaxWaitForFramesMs);
+}
+
+// Verify that audio/video can be received end-to-end when ICE renomination is
+// enabled.
+TEST_F(PeerConnectionIntegrationTest, EndToEndCallWithIceRenomination) {
+  PeerConnectionInterface::RTCConfiguration config;
+  config.enable_ice_renomination = true;
+  ASSERT_TRUE(CreatePeerConnectionWrappersWithConfig(config, config));
+  ConnectFakeSignaling();
+  // Do normal offer/answer and wait for some frames to be received in each
+  // direction.
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  // Sanity check that ICE renomination was actually negotiated.
+  const cricket::SessionDescription* desc =
+      caller_pc_wrapper()->pc()->local_description()->description();
+  for (const cricket::TransportInfo& info : desc->transport_infos()) {
+    ASSERT_NE(info.description.transport_options.end(),
+              std::find(info.description.transport_options.begin(),
+                        info.description.transport_options.end(),
+                        cricket::ICE_RENOMINATION_STR));
+  }
+  desc = callee_pc_wrapper()->pc()->local_description()->description();
+  for (const cricket::TransportInfo& info : desc->transport_infos()) {
+    ASSERT_NE(info.description.transport_options.end(),
+              std::find(info.description.transport_options.begin(),
+                        info.description.transport_options.end(),
+                        cricket::ICE_RENOMINATION_STR));
+  }
+  EXPECT_TRUE_WAIT(
+      caller_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          caller_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount) &&
+          callee_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount),
+      kMaxWaitForFramesMs);
+}
+
+// This test sets up a call between two parties with audio and video. It then
+// renegotiates setting the video m-line to "port 0", then later renegotiates
+// again, enabling video.
+TEST_F(PeerConnectionIntegrationTest,
+       VideoFlowsAfterMediaSectionIsRejectedAndRecycled) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+
+  // Do initial negotiation, only sending media from the caller. Will result in
+  // video and audio recvonly "m=" sections.
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+
+  // Negotiate again, disabling the video "m=" section (the callee will set the
+  // port to 0 due to offer_to_receive_video = 0).
+  PeerConnectionInterface::RTCOfferAnswerOptions options;
+  options.offer_to_receive_video = 0;
+  callee_pc_wrapper()->SetOfferAnswerOptions(options);
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  // Sanity check that video "m=" section was actually rejected.
+  const ContentInfo* answer_video_content = cricket::GetFirstVideoContent(
+      callee_pc_wrapper()->pc()->local_description()->description());
+  ASSERT_NE(nullptr, answer_video_content);
+  ASSERT_TRUE(answer_video_content->rejected);
+
+  // Enable video and do negotiation again, making sure video is received
+  // end-to-end, also adding media stream to callee.
+  options.offer_to_receive_video = 1;
+  callee_pc_wrapper()->SetOfferAnswerOptions(options);
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  // Verify caller receives frames from the newly added stream, and the callee
+  // receives additional frames from the re-enabled video m= section.
+  int last_callee_audio_frames = callee_pc_wrapper()->audio_frames_received();
+  int last_callee_video_frames = callee_pc_wrapper()->video_frames_received();
+  EXPECT_TRUE_WAIT(
+      caller_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          caller_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount) &&
+          callee_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount +
+                                                   last_callee_audio_frames) &&
+          callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount + last_callee_video_frames),
+      kMaxWaitForFramesMs);
+}
+
+// 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(PeerConnectionIntegrationTest,
+       DISABLED_EndToEndCallWithVideoDecoderFactory) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  EnableVideoDecoderFactory();
+  ConnectFakeSignaling();
+  caller_pc_wrapper()->AddAudioVideoMediaStream();
+  callee_pc_wrapper()->AddAudioVideoMediaStream();
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  EXPECT_TRUE_WAIT(
+      caller_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          caller_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount) &&
+          callee_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount),
+      kMaxWaitForFramesMs);
+}
+
+// This tests that if we negotiate after calling CreateSender but before we
+// have a track, then set a track later, frames from the newly-set track are
+// received end-to-end.
+// TODO(deadbeef): Change this test to use AddTransceiver, once that's
+// implemented.
+TEST_F(PeerConnectionIntegrationTest,
+       MediaFlowsAfterEarlyWarmupWithCreateSender) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  auto caller_audio_sender =
+      caller_pc_wrapper()->pc()->CreateSender("audio", "caller_stream");
+  auto caller_video_sender =
+      caller_pc_wrapper()->pc()->CreateSender("video", "caller_stream");
+  auto callee_audio_sender =
+      callee_pc_wrapper()->pc()->CreateSender("audio", "callee_stream");
+  auto callee_video_sender =
+      callee_pc_wrapper()->pc()->CreateSender("video", "callee_stream");
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kMaxWaitForActivationMs);
+  // Wait for ICE to complete, without any tracks being set.
+  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionCompleted,
+                 caller_pc_wrapper()->ice_connection_state(),
+                 kMaxWaitForFramesMs);
+  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected,
+                 callee_pc_wrapper()->ice_connection_state(),
+                 kMaxWaitForFramesMs);
+  // Now set the tracks, and expect frames to immediately start flowing.
+  EXPECT_TRUE(caller_audio_sender->SetTrack(
+      caller_pc_wrapper()->CreateLocalAudioTrack()));
+  EXPECT_TRUE(caller_video_sender->SetTrack(
+      caller_pc_wrapper()->CreateLocalVideoTrack()));
+  EXPECT_TRUE(callee_audio_sender->SetTrack(
+      callee_pc_wrapper()->CreateLocalAudioTrack()));
+  EXPECT_TRUE(callee_video_sender->SetTrack(
+      callee_pc_wrapper()->CreateLocalVideoTrack()));
+  EXPECT_TRUE_WAIT(
+      caller_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          caller_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount) &&
+          callee_pc_wrapper()->ReceivedAudioFrames(kEndAudioFrameCount) &&
+          callee_pc_wrapper()->ReceivedVideoFramesForEachTrack(
+              kEndVideoFrameCount),
+      kMaxWaitForFramesMs);
+}
+
+// This test verifies that a remote video track can be added via AddStream,
+// and sent end-to-end. For this particular test, it's simply echoed back
+// from the caller to the callee, rather than being forwarded to a third
+// PeerConnection.
+TEST_F(PeerConnectionIntegrationTest, CanSendRemoteVideoTrack) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  // Just send a video track from the caller.
+  caller_pc_wrapper()->AddMediaStreamFromTracks(
+      nullptr, caller_pc_wrapper()->CreateLocalVideoTrack());
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kMaxWaitForActivationMs);
+  ASSERT_EQ(1, callee_pc_wrapper()->remote_streams()->count());
+
+  // Echo the stream back, and do a new offer/anwer (initiated by callee this
+  // time).
+  callee_pc_wrapper()->pc()->AddStream(
+      callee_pc_wrapper()->remote_streams()->at(0));
+  callee_pc_wrapper()->CreateSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kMaxWaitForActivationMs);
+
+  EXPECT_TRUE_WAIT(
+      caller_pc_wrapper()->ReceivedVideoFramesForEachTrack(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.

[pthatcher1, 2017/03/20 18:23:17]

Wow.  That's thorough.

+TEST_F(PeerConnectionIntegrationTest, 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;
+  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(
+      CreatePeerConnectionWrappersWithConfig(client_1_config, client_2_config));
+  // Set up the simulated delays.
+  SetSignalingDelayMs(signaling_trip_delay_ms);
+  ConnectFakeSignaling();
+  virtual_socket_server()->set_delay_mean(media_hop_delay_ms);
+  virtual_socket_server()->UpdateDelayDistribution();
+
+  // Set "offer to receive audio/video" without adding any tracks, so we just
+  // set up ICE/DTLS with no media.
+  PeerConnectionInterface::RTCOfferAnswerOptions options;
+  options.offer_to_receive_audio = 1;
+  options.offer_to_receive_video = 1;
+  caller_pc_wrapper()->SetOfferAnswerOptions(options);
+  caller_pc_wrapper()->CreateSetAndSignalOffer();
+  // 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(
+      (callee_pc_wrapper()->ice_connection_state() ==
+           webrtc::PeerConnectionInterface::kIceConnectionConnected ||
+       callee_pc_wrapper()->ice_connection_state() ==
+           webrtc::PeerConnectionInterface::kIceConnectionCompleted) &&
+          (caller_pc_wrapper()->ice_connection_state() ==
+               webrtc::PeerConnectionInterface::kIceConnectionConnected ||
+           caller_pc_wrapper()->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 SetCallerPcWrapperAndReturnCurrent(nullptr);
+  delete SetCalleePcWrapperAndReturnCurrent(nullptr);
+}
+
+#endif  // if !defined(THREAD_SANITIZER)
+
+}  // namespace