Adding upstream version 115.7.0esr.upstream/115.7.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 3835 insertions, 0 deletions

diff --git a/third_party/libwebrtc/pc/peer_connection_interface_unittest.cc b/third_party/libwebrtc/pc/peer_connection_interface_unittest.cc
new file mode 100644
index 0000000000..f7f408bcc8
--- /dev/null
+++ b/third_party/libwebrtc/pc/peer_connection_interface_unittest.cc
@@ -0,0 +1,3835 @@
+/*
+ *  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.
+ */
+
+#include "api/peer_connection_interface.h"
+
+#include <limits.h>
+#include <stdint.h>
+
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/strings/str_replace.h"
+#include "absl/types/optional.h"
+#include "api/audio/audio_mixer.h"
+#include "api/audio_codecs/builtin_audio_decoder_factory.h"
+#include "api/audio_codecs/builtin_audio_encoder_factory.h"
+#include "api/call/call_factory_interface.h"
+#include "api/create_peerconnection_factory.h"
+#include "api/data_channel_interface.h"
+#include "api/jsep.h"
+#include "api/media_stream_interface.h"
+#include "api/media_types.h"
+#include "api/rtc_error.h"
+#include "api/rtc_event_log/rtc_event_log.h"
+#include "api/rtc_event_log/rtc_event_log_factory.h"
+#include "api/rtc_event_log_output.h"
+#include "api/rtp_receiver_interface.h"
+#include "api/rtp_sender_interface.h"
+#include "api/rtp_transceiver_direction.h"
+#include "api/scoped_refptr.h"
+#include "api/task_queue/default_task_queue_factory.h"
+#include "api/transport/field_trial_based_config.h"
+#include "api/video_codecs/builtin_video_decoder_factory.h"
+#include "api/video_codecs/builtin_video_encoder_factory.h"
+#include "media/base/codec.h"
+#include "media/base/media_config.h"
+#include "media/base/media_engine.h"
+#include "media/base/stream_params.h"
+#include "media/engine/webrtc_media_engine.h"
+#include "media/engine/webrtc_media_engine_defaults.h"
+#include "media/sctp/sctp_transport_internal.h"
+#include "modules/audio_device/include/audio_device.h"
+#include "modules/audio_processing/include/audio_processing.h"
+#include "p2p/base/fake_port_allocator.h"
+#include "p2p/base/p2p_constants.h"
+#include "p2p/base/port.h"
+#include "p2p/base/port_allocator.h"
+#include "p2p/base/transport_description.h"
+#include "p2p/base/transport_info.h"
+#include "pc/audio_track.h"
+#include "pc/media_session.h"
+#include "pc/media_stream.h"
+#include "pc/peer_connection.h"
+#include "pc/peer_connection_factory.h"
+#include "pc/rtp_sender.h"
+#include "pc/rtp_sender_proxy.h"
+#include "pc/session_description.h"
+#include "pc/stream_collection.h"
+#include "pc/test/fake_audio_capture_module.h"
+#include "pc/test/fake_rtc_certificate_generator.h"
+#include "pc/test/fake_video_track_source.h"
+#include "pc/test/mock_peer_connection_observers.h"
+#include "pc/test/test_sdp_strings.h"
+#include "pc/video_track.h"
+#include "rtc_base/checks.h"
+#include "rtc_base/gunit.h"
+#include "rtc_base/rtc_certificate_generator.h"
+#include "rtc_base/socket_address.h"
+#include "rtc_base/thread.h"
+#include "rtc_base/virtual_socket_server.h"
+#include "test/gmock.h"
+#include "test/gtest.h"
+#include "test/scoped_key_value_config.h"
+
+#ifdef WEBRTC_ANDROID
+#include "pc/test/android_test_initializer.h"
+#endif
+
+namespace webrtc {
+namespace {
+
+static const char kStreamId1[] = "local_stream_1";
+static const char kStreamId2[] = "local_stream_2";
+static const char kStreamId3[] = "local_stream_3";
+static const int kDefaultStunPort = 3478;
+static const char kStunAddressOnly[] = "stun:address";
+static const char kStunInvalidPort[] = "stun:address:-1";
+static const char kStunAddressPortAndMore1[] = "stun:address:port:more";
+static const char kStunAddressPortAndMore2[] = "stun:address:port more";
+static const char kTurnIceServerUri[] = "turn:turn.example.org";
+static const char kTurnUsername[] = "user";
+static const char kTurnPassword[] = "password";
+static const char kTurnHostname[] = "turn.example.org";
+static const uint32_t kTimeout = 10000U;
+
+static const char kStreams[][8] = {"stream1", "stream2"};
+static const char kAudioTracks[][32] = {"audiotrack0", "audiotrack1"};
+static const char kVideoTracks[][32] = {"videotrack0", "videotrack1"};
+
+static const char kRecvonly[] = "recvonly";
+static const char kSendrecv[] = "sendrecv";
+constexpr uint64_t kTiebreakerDefault = 44444;
+
+// Reference SDP with a MediaStream with label "stream1" and audio track with
+// id "audio_1" and a video track with id "video_1;
+static const char kSdpStringWithStream1PlanB[] =
+    "v=0\r\n"
+    "o=- 0 0 IN IP4 127.0.0.1\r\n"
+    "s=-\r\n"
+    "t=0 0\r\n"
+    "m=audio 1 RTP/AVPF 111\r\n"
+    "a=ice-ufrag:e5785931\r\n"
+    "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n"
+    "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:"
+    "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n"
+    "a=mid:audio\r\n"
+    "a=sendrecv\r\n"
+    "a=rtcp-mux\r\n"
+    "a=rtpmap:111 OPUS/48000/2\r\n"
+    "a=ssrc:1 cname:stream1\r\n"
+    "a=ssrc:1 msid:stream1 audiotrack0\r\n"
+    "m=video 1 RTP/AVPF 120\r\n"
+    "a=ice-ufrag:e5785931\r\n"
+    "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n"
+    "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:"
+    "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n"
+    "a=mid:video\r\n"
+    "a=sendrecv\r\n"
+    "a=rtcp-mux\r\n"
+    "a=rtpmap:120 VP8/90000\r\n"
+    "a=ssrc:2 cname:stream1\r\n"
+    "a=ssrc:2 msid:stream1 videotrack0\r\n";
+// Same string as above but with the MID changed to the Unified Plan default and
+// a=msid added. This is needed so that this SDP can be used as an answer for a
+// Unified Plan offer.
+static const char kSdpStringWithStream1UnifiedPlan[] =
+    "v=0\r\n"
+    "o=- 0 0 IN IP4 127.0.0.1\r\n"
+    "s=-\r\n"
+    "t=0 0\r\n"
+    "m=audio 1 RTP/AVPF 111\r\n"
+    "a=ice-ufrag:e5785931\r\n"
+    "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n"
+    "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:"
+    "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n"
+    "a=mid:0\r\n"
+    "a=sendrecv\r\n"
+    "a=rtcp-mux\r\n"
+    "a=rtpmap:111 OPUS/48000/2\r\n"
+    "a=msid:stream1 audiotrack0\r\n"
+    "a=ssrc:1 cname:stream1\r\n"
+    "m=video 1 RTP/AVPF 120\r\n"
+    "a=ice-ufrag:e5785931\r\n"
+    "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n"
+    "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:"
+    "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n"
+    "a=mid:1\r\n"
+    "a=sendrecv\r\n"
+    "a=rtcp-mux\r\n"
+    "a=rtpmap:120 VP8/90000\r\n"
+    "a=msid:stream1 videotrack0\r\n"
+    "a=ssrc:2 cname:stream1\r\n";
+
+// Reference SDP with a MediaStream with label "stream1" and audio track with
+// id "audio_1";
+static const char kSdpStringWithStream1AudioTrackOnly[] =
+    "v=0\r\n"
+    "o=- 0 0 IN IP4 127.0.0.1\r\n"
+    "s=-\r\n"
+    "t=0 0\r\n"
+    "m=audio 1 RTP/AVPF 111\r\n"
+    "a=ice-ufrag:e5785931\r\n"
+    "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n"
+    "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:"
+    "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n"
+    "a=mid:audio\r\n"
+    "a=sendrecv\r\n"
+    "a=rtpmap:111 OPUS/48000/2\r\n"
+    "a=ssrc:1 cname:stream1\r\n"
+    "a=ssrc:1 msid:stream1 audiotrack0\r\n"
+    "a=rtcp-mux\r\n";
+
+// Reference SDP with two MediaStreams with label "stream1" and "stream2. Each
+// MediaStreams have one audio track and one video track.
+// This uses MSID.
+static const char kSdpStringWithStream1And2PlanB[] =
+    "v=0\r\n"
+    "o=- 0 0 IN IP4 127.0.0.1\r\n"
+    "s=-\r\n"
+    "t=0 0\r\n"
+    "a=msid-semantic: WMS stream1 stream2\r\n"
+    "m=audio 1 RTP/AVPF 111\r\n"
+    "a=ice-ufrag:e5785931\r\n"
+    "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n"
+    "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:"
+    "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n"
+    "a=mid:audio\r\n"
+    "a=sendrecv\r\n"
+    "a=rtcp-mux\r\n"
+    "a=rtpmap:111 OPUS/48000/2\r\n"
+    "a=ssrc:1 cname:stream1\r\n"
+    "a=ssrc:1 msid:stream1 audiotrack0\r\n"
+    "a=ssrc:3 cname:stream2\r\n"
+    "a=ssrc:3 msid:stream2 audiotrack1\r\n"
+    "m=video 1 RTP/AVPF 120\r\n"
+    "a=ice-ufrag:e5785931\r\n"
+    "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n"
+    "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:"
+    "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n"
+    "a=mid:video\r\n"
+    "a=sendrecv\r\n"
+    "a=rtcp-mux\r\n"
+    "a=rtpmap:120 VP8/0\r\n"
+    "a=ssrc:2 cname:stream1\r\n"
+    "a=ssrc:2 msid:stream1 videotrack0\r\n"
+    "a=ssrc:4 cname:stream2\r\n"
+    "a=ssrc:4 msid:stream2 videotrack1\r\n";
+static const char kSdpStringWithStream1And2UnifiedPlan[] =
+    "v=0\r\n"
+    "o=- 0 0 IN IP4 127.0.0.1\r\n"
+    "s=-\r\n"
+    "t=0 0\r\n"
+    "a=msid-semantic: WMS stream1 stream2\r\n"
+    "m=audio 1 RTP/AVPF 111\r\n"
+    "a=ice-ufrag:e5785931\r\n"
+    "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n"
+    "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:"
+    "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n"
+    "a=mid:0\r\n"
+    "a=sendrecv\r\n"
+    "a=rtcp-mux\r\n"
+    "a=rtpmap:111 OPUS/48000/2\r\n"
+    "a=ssrc:1 cname:stream1\r\n"
+    "a=ssrc:1 msid:stream1 audiotrack0\r\n"
+    "m=video 1 RTP/AVPF 120\r\n"
+    "a=ice-ufrag:e5785931\r\n"
+    "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n"
+    "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:"
+    "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n"
+    "a=mid:1\r\n"
+    "a=sendrecv\r\n"
+    "a=rtcp-mux\r\n"
+    "a=rtpmap:120 VP8/0\r\n"
+    "a=ssrc:2 cname:stream1\r\n"
+    "a=ssrc:2 msid:stream1 videotrack0\r\n"
+    "m=audio 1 RTP/AVPF 111\r\n"
+    "a=ice-ufrag:e5785931\r\n"
+    "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n"
+    "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:"
+    "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n"
+    "a=mid:2\r\n"
+    "a=sendrecv\r\n"
+    "a=rtcp-mux\r\n"
+    "a=rtpmap:111 OPUS/48000/2\r\n"
+    "a=ssrc:3 cname:stream2\r\n"
+    "a=ssrc:3 msid:stream2 audiotrack1\r\n"
+    "m=video 1 RTP/AVPF 120\r\n"
+    "a=ice-ufrag:e5785931\r\n"
+    "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n"
+    "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:"
+    "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n"
+    "a=mid:3\r\n"
+    "a=sendrecv\r\n"
+    "a=rtcp-mux\r\n"
+    "a=rtpmap:120 VP8/0\r\n"
+    "a=ssrc:4 cname:stream2\r\n"
+    "a=ssrc:4 msid:stream2 videotrack1\r\n";
+
+// Reference SDP without MediaStreams. Msid is not supported.
+static const char kSdpStringWithoutStreams[] =
+    "v=0\r\n"
+    "o=- 0 0 IN IP4 127.0.0.1\r\n"
+    "s=-\r\n"
+    "t=0 0\r\n"
+    "m=audio 1 RTP/AVPF 111\r\n"
+    "a=ice-ufrag:e5785931\r\n"
+    "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n"
+    "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:"
+    "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n"
+    "a=mid:audio\r\n"
+    "a=sendrecv\r\n"
+    "a=rtcp-mux\r\n"
+    "a=rtpmap:111 OPUS/48000/2\r\n"
+    "m=video 1 RTP/AVPF 120\r\n"
+    "a=ice-ufrag:e5785931\r\n"
+    "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n"
+    "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:"
+    "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n"
+    "a=mid:video\r\n"
+    "a=sendrecv\r\n"
+    "a=rtcp-mux\r\n"
+    "a=rtpmap:120 VP8/90000\r\n";
+
+// Reference SDP without MediaStreams. Msid is supported.
+static const char kSdpStringWithMsidWithoutStreams[] =
+    "v=0\r\n"
+    "o=- 0 0 IN IP4 127.0.0.1\r\n"
+    "s=-\r\n"
+    "t=0 0\r\n"
+    "a=msid-semantic: WMS\r\n"
+    "m=audio 1 RTP/AVPF 111\r\n"
+    "a=ice-ufrag:e5785931\r\n"
+    "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n"
+    "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:"
+    "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n"
+    "a=mid:audio\r\n"
+    "a=sendrecv\r\n"
+    "a=rtcp-mux\r\n"
+    "a=rtpmap:111 OPUS/48000/2\r\n"
+    "m=video 1 RTP/AVPF 120\r\n"
+    "a=ice-ufrag:e5785931\r\n"
+    "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n"
+    "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:"
+    "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n"
+    "a=mid:video\r\n"
+    "a=sendrecv\r\n"
+    "a=rtcp-mux\r\n"
+    "a=rtpmap:120 VP8/90000\r\n";
+
+// Reference SDP without MediaStreams and audio only.
+static const char kSdpStringWithoutStreamsAudioOnly[] =
+    "v=0\r\n"
+    "o=- 0 0 IN IP4 127.0.0.1\r\n"
+    "s=-\r\n"
+    "t=0 0\r\n"
+    "m=audio 1 RTP/AVPF 111\r\n"
+    "a=ice-ufrag:e5785931\r\n"
+    "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n"
+    "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:"
+    "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n"
+    "a=mid:audio\r\n"
+    "a=sendrecv\r\n"
+    "a=rtcp-mux\r\n"
+    "a=rtpmap:111 OPUS/48000/2\r\n";
+
+// Reference SENDONLY SDP without MediaStreams. Msid is not supported.
+static const char kSdpStringSendOnlyWithoutStreams[] =
+    "v=0\r\n"
+    "o=- 0 0 IN IP4 127.0.0.1\r\n"
+    "s=-\r\n"
+    "t=0 0\r\n"
+    "m=audio 1 RTP/AVPF 111\r\n"
+    "a=ice-ufrag:e5785931\r\n"
+    "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n"
+    "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:"
+    "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n"
+    "a=mid:audio\r\n"
+    "a=sendrecv\r\n"
+    "a=sendonly\r\n"
+    "a=rtcp-mux\r\n"
+    "a=rtpmap:111 OPUS/48000/2\r\n"
+    "m=video 1 RTP/AVPF 120\r\n"
+    "a=ice-ufrag:e5785931\r\n"
+    "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n"
+    "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:"
+    "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n"
+    "a=mid:video\r\n"
+    "a=sendrecv\r\n"
+    "a=sendonly\r\n"
+    "a=rtcp-mux\r\n"
+    "a=rtpmap:120 VP8/90000\r\n";
+
+static const char kSdpStringInit[] =
+    "v=0\r\n"
+    "o=- 0 0 IN IP4 127.0.0.1\r\n"
+    "s=-\r\n"
+    "t=0 0\r\n"
+    "a=msid-semantic: WMS\r\n";
+
+static const char kSdpStringAudio[] =
+    "m=audio 1 RTP/AVPF 111\r\n"
+    "a=ice-ufrag:e5785931\r\n"
+    "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n"
+    "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:"
+    "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n"
+    "a=mid:audio\r\n"
+    "a=sendrecv\r\n"
+    "a=rtcp-mux\r\n"
+    "a=rtpmap:111 OPUS/48000/2\r\n";
+
+static const char kSdpStringVideo[] =
+    "m=video 1 RTP/AVPF 120\r\n"
+    "a=ice-ufrag:e5785931\r\n"
+    "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n"
+    "a=fingerprint:sha-256 58:AB:6E:F5:F1:E4:57:B7:E9:46:F4:86:04:28:F9:A7:ED:"
+    "BD:AB:AE:40:EF:CE:9A:51:2C:2A:B1:9B:8B:78:84\r\n"
+    "a=mid:video\r\n"
+    "a=sendrecv\r\n"
+    "a=rtcp-mux\r\n"
+    "a=rtpmap:120 VP8/90000\r\n";
+
+static const char kSdpStringMs1Audio0[] =
+    "a=ssrc:1 cname:stream1\r\n"
+    "a=ssrc:1 msid:stream1 audiotrack0\r\n";
+
+static const char kSdpStringMs1Video0[] =
+    "a=ssrc:2 cname:stream1\r\n"
+    "a=ssrc:2 msid:stream1 videotrack0\r\n";
+
+static const char kSdpStringMs1Audio1[] =
+    "a=ssrc:3 cname:stream1\r\n"
+    "a=ssrc:3 msid:stream1 audiotrack1\r\n";
+
+static const char kSdpStringMs1Video1[] =
+    "a=ssrc:4 cname:stream1\r\n"
+    "a=ssrc:4 msid:stream1 videotrack1\r\n";
+
+static const char kDtlsSdesFallbackSdp[] =
+    "v=0\r\n"
+    "o=xxxxxx 7 2 IN IP4 0.0.0.0\r\n"
+    "s=-\r\n"
+    "c=IN IP4 0.0.0.0\r\n"
+    "t=0 0\r\n"
+    "a=group:BUNDLE audio\r\n"
+    "a=msid-semantic: WMS\r\n"
+    "m=audio 1 RTP/SAVPF 0\r\n"
+    "a=sendrecv\r\n"
+    "a=rtcp-mux\r\n"
+    "a=mid:audio\r\n"
+    "a=ssrc:1 cname:stream1\r\n"
+    "a=ice-ufrag:e5785931\r\n"
+    "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n"
+    "a=rtpmap:0 pcmu/8000\r\n"
+    "a=fingerprint:sha-1 "
+    "4A:AD:B9:B1:3F:82:18:3B:54:02:12:DF:3E:5D:49:6B:19:E5:7C:AB\r\n"
+    "a=setup:actpass\r\n"
+    "a=crypto:0 AES_CM_128_HMAC_SHA1_80 "
+    "inline:NzB4d1BINUAvLEw6UzF3WSJ+PSdFcGdUJShpX1Zj|2^20|1:32 "
+    "dummy_session_params\r\n";
+
+class RtcEventLogOutputNull final : public RtcEventLogOutput {
+ public:
+  bool IsActive() const override { return true; }
+  bool Write(const absl::string_view /*output*/) override { return true; }
+};
+
+using ::cricket::StreamParams;
+using ::testing::Eq;
+using ::testing::Exactly;
+using ::testing::SizeIs;
+using ::testing::Values;
+
+using RTCConfiguration = PeerConnectionInterface::RTCConfiguration;
+using RTCOfferAnswerOptions = PeerConnectionInterface::RTCOfferAnswerOptions;
+
+// Gets the first ssrc of given content type from the ContentInfo.
+bool GetFirstSsrc(const cricket::ContentInfo* content_info, int* ssrc) {
+  if (!content_info || !ssrc) {
+    return false;
+  }
+  const cricket::MediaContentDescription* media_desc =
+      content_info->media_description();
+  if (!media_desc || media_desc->streams().empty()) {
+    return false;
+  }
+  *ssrc = media_desc->streams().begin()->first_ssrc();
+  return true;
+}
+
+// Get the ufrags out of an SDP blob. Useful for testing ICE restart
+// behavior.
+std::vector<std::string> GetUfrags(
+    const webrtc::SessionDescriptionInterface* desc) {
+  std::vector<std::string> ufrags;
+  for (const cricket::TransportInfo& info :
+       desc->description()->transport_infos()) {
+    ufrags.push_back(info.description.ice_ufrag);
+  }
+  return ufrags;
+}
+
+void SetSsrcToZero(std::string* sdp) {
+  const char kSdpSsrcAtribute[] = "a=ssrc:";
+  const char kSdpSsrcAtributeZero[] = "a=ssrc:0";
+  size_t ssrc_pos = 0;
+  while ((ssrc_pos = sdp->find(kSdpSsrcAtribute, ssrc_pos)) !=
+         std::string::npos) {
+    size_t end_ssrc = sdp->find(" ", ssrc_pos);
+    sdp->replace(ssrc_pos, end_ssrc - ssrc_pos, kSdpSsrcAtributeZero);
+    ssrc_pos = end_ssrc;
+  }
+}
+
+// Check if `streams` contains the specified track.
+bool ContainsTrack(const std::vector<cricket::StreamParams>& streams,
+                   const std::string& stream_id,
+                   const std::string& track_id) {
+  for (const cricket::StreamParams& params : streams) {
+    if (params.first_stream_id() == stream_id && params.id == track_id) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Check if `senders` contains the specified sender, by id.
+bool ContainsSender(
+    const std::vector<rtc::scoped_refptr<RtpSenderInterface>>& senders,
+    const std::string& id) {
+  for (const auto& sender : senders) {
+    if (sender->id() == id) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Check if `senders` contains the specified sender, by id and stream id.
+bool ContainsSender(
+    const std::vector<rtc::scoped_refptr<RtpSenderInterface>>& senders,
+    const std::string& id,
+    const std::string& stream_id) {
+  for (const auto& sender : senders) {
+    if (sender->id() == id && sender->stream_ids()[0] == stream_id) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Create a collection of streams.
+// CreateStreamCollection(1) creates a collection that
+// correspond to kSdpStringWithStream1.
+// CreateStreamCollection(2) correspond to kSdpStringWithStream1And2.
+rtc::scoped_refptr<StreamCollection> CreateStreamCollection(
+    int number_of_streams,
+    int tracks_per_stream) {
+  rtc::scoped_refptr<StreamCollection> local_collection(
+      StreamCollection::Create());
+
+  for (int i = 0; i < number_of_streams; ++i) {
+    rtc::scoped_refptr<webrtc::MediaStreamInterface> stream(
+        webrtc::MediaStream::Create(kStreams[i]));
+
+    for (int j = 0; j < tracks_per_stream; ++j) {
+      // Add a local audio track.
+      rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
+          webrtc::AudioTrack::Create(kAudioTracks[i * tracks_per_stream + j],
+                                     nullptr));
+      stream->AddTrack(audio_track);
+
+      // Add a local video track.
+      rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
+          webrtc::VideoTrack::Create(kVideoTracks[i * tracks_per_stream + j],
+                                     webrtc::FakeVideoTrackSource::Create(),
+                                     rtc::Thread::Current()));
+      stream->AddTrack(video_track);
+    }
+
+    local_collection->AddStream(stream);
+  }
+  return local_collection;
+}
+
+// Check equality of StreamCollections.
+bool CompareStreamCollections(StreamCollectionInterface* s1,
+                              StreamCollectionInterface* s2) {
+  if (s1 == nullptr || s2 == nullptr || s1->count() != s2->count()) {
+    return false;
+  }
+
+  for (size_t i = 0; i != s1->count(); ++i) {
+    if (s1->at(i)->id() != s2->at(i)->id()) {
+      return false;
+    }
+    webrtc::AudioTrackVector audio_tracks1 = s1->at(i)->GetAudioTracks();
+    webrtc::AudioTrackVector audio_tracks2 = s2->at(i)->GetAudioTracks();
+    webrtc::VideoTrackVector video_tracks1 = s1->at(i)->GetVideoTracks();
+    webrtc::VideoTrackVector video_tracks2 = s2->at(i)->GetVideoTracks();
+
+    if (audio_tracks1.size() != audio_tracks2.size()) {
+      return false;
+    }
+    for (size_t j = 0; j != audio_tracks1.size(); ++j) {
+      if (audio_tracks1[j]->id() != audio_tracks2[j]->id()) {
+        return false;
+      }
+    }
+    if (video_tracks1.size() != video_tracks2.size()) {
+      return false;
+    }
+    for (size_t j = 0; j != video_tracks1.size(); ++j) {
+      if (video_tracks1[j]->id() != video_tracks2[j]->id()) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+// Helper class to test Observer.
+class MockTrackObserver : public ObserverInterface {
+ public:
+  explicit MockTrackObserver(NotifierInterface* notifier)
+      : notifier_(notifier) {
+    notifier_->RegisterObserver(this);
+  }
+
+  ~MockTrackObserver() { Unregister(); }
+
+  void Unregister() {
+    if (notifier_) {
+      notifier_->UnregisterObserver(this);
+      notifier_ = nullptr;
+    }
+  }
+
+  MOCK_METHOD(void, OnChanged, (), (override));
+
+ private:
+  NotifierInterface* notifier_;
+};
+
+// The PeerConnectionMediaConfig tests below verify that configuration and
+// constraints are propagated into the PeerConnection's MediaConfig. These
+// settings are intended for MediaChannel constructors, but that is not
+// exercised by these unittest.
+class PeerConnectionFactoryForTest : public webrtc::PeerConnectionFactory {
+ public:
+  static rtc::scoped_refptr<PeerConnectionFactoryForTest>
+  CreatePeerConnectionFactoryForTest() {
+    PeerConnectionFactoryDependencies dependencies;
+    dependencies.worker_thread = rtc::Thread::Current();
+    dependencies.network_thread = rtc::Thread::Current();
+    dependencies.signaling_thread = rtc::Thread::Current();
+    dependencies.task_queue_factory = CreateDefaultTaskQueueFactory();
+    dependencies.trials = std::make_unique<FieldTrialBasedConfig>();
+    cricket::MediaEngineDependencies media_deps;
+    media_deps.task_queue_factory = dependencies.task_queue_factory.get();
+    // Use fake audio device module since we're only testing the interface
+    // level, and using a real one could make tests flaky when run in parallel.
+    media_deps.adm = FakeAudioCaptureModule::Create();
+    SetMediaEngineDefaults(&media_deps);
+    media_deps.trials = dependencies.trials.get();
+    dependencies.media_engine =
+        cricket::CreateMediaEngine(std::move(media_deps));
+    dependencies.call_factory = webrtc::CreateCallFactory();
+    dependencies.event_log_factory = std::make_unique<RtcEventLogFactory>(
+        dependencies.task_queue_factory.get());
+
+    return rtc::make_ref_counted<PeerConnectionFactoryForTest>(
+        std::move(dependencies));
+  }
+
+  using PeerConnectionFactory::PeerConnectionFactory;
+
+ private:
+  rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
+};
+
+// TODO(steveanton): Convert to use the new PeerConnectionWrapper.
+class PeerConnectionInterfaceBaseTest : public ::testing::Test {
+ protected:
+  explicit PeerConnectionInterfaceBaseTest(SdpSemantics sdp_semantics)
+      : vss_(new rtc::VirtualSocketServer()),
+        main_(vss_.get()),
+        sdp_semantics_(sdp_semantics) {
+#ifdef WEBRTC_ANDROID
+    webrtc::InitializeAndroidObjects();
+#endif
+  }
+
+  void SetUp() override {
+    // Use fake audio capture module since we're only testing the interface
+    // level, and using a real one could make tests flaky when run in parallel.
+    fake_audio_capture_module_ = FakeAudioCaptureModule::Create();
+    pc_factory_ = webrtc::CreatePeerConnectionFactory(
+        rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(),
+        rtc::scoped_refptr<webrtc::AudioDeviceModule>(
+            fake_audio_capture_module_),
+        webrtc::CreateBuiltinAudioEncoderFactory(),
+        webrtc::CreateBuiltinAudioDecoderFactory(),
+        webrtc::CreateBuiltinVideoEncoderFactory(),
+        webrtc::CreateBuiltinVideoDecoderFactory(), nullptr /* audio_mixer */,
+        nullptr /* audio_processing */);
+    ASSERT_TRUE(pc_factory_);
+  }
+
+  void TearDown() override {
+    if (pc_)
+      pc_->Close();
+  }
+
+  void CreatePeerConnection() {
+    CreatePeerConnection(PeerConnectionInterface::RTCConfiguration());
+  }
+
+  // DTLS does not work in a loopback call, so is disabled for many
+  // tests in this file.
+  void CreatePeerConnectionWithoutDtls() {
+    RTCConfiguration config;
+    PeerConnectionFactoryInterface::Options options;
+    options.disable_encryption = true;
+    pc_factory_->SetOptions(options);
+    CreatePeerConnection(config);
+    options.disable_encryption = false;
+    pc_factory_->SetOptions(options);
+  }
+
+  void CreatePeerConnectionWithIceTransportsType(
+      PeerConnectionInterface::IceTransportsType type) {
+    PeerConnectionInterface::RTCConfiguration config;
+    config.type = type;
+    return CreatePeerConnection(config);
+  }
+
+  void CreatePeerConnectionWithIceServer(const std::string& uri,
+                                         const std::string& username,
+                                         const std::string& password) {
+    PeerConnectionInterface::RTCConfiguration config;
+    PeerConnectionInterface::IceServer server;
+    server.uri = uri;
+    server.username = username;
+    server.password = password;
+    config.servers.push_back(server);
+    CreatePeerConnection(config);
+  }
+
+  void CreatePeerConnection(const RTCConfiguration& config) {
+    if (pc_) {
+      pc_->Close();
+      pc_ = nullptr;
+    }
+    std::unique_ptr<cricket::FakePortAllocator> port_allocator(
+        new cricket::FakePortAllocator(
+            rtc::Thread::Current(),
+            std::make_unique<rtc::BasicPacketSocketFactory>(vss_.get()),
+            &field_trials_));
+    port_allocator_ = port_allocator.get();
+    port_allocator_->SetIceTiebreaker(kTiebreakerDefault);
+
+    // Create certificate generator unless DTLS constraint is explicitly set to
+    // false.
+    std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator;
+
+    // These won't be used if encryption is turned off, but that's harmless.
+    fake_certificate_generator_ = new FakeRTCCertificateGenerator();
+    cert_generator.reset(fake_certificate_generator_);
+
+    RTCConfiguration modified_config = config;
+    modified_config.sdp_semantics = sdp_semantics_;
+    PeerConnectionDependencies pc_dependencies(&observer_);
+    pc_dependencies.cert_generator = std::move(cert_generator);
+    pc_dependencies.allocator = std::move(port_allocator);
+    auto result = pc_factory_->CreatePeerConnectionOrError(
+        modified_config, std::move(pc_dependencies));
+    ASSERT_TRUE(result.ok());
+    pc_ = result.MoveValue();
+    observer_.SetPeerConnectionInterface(pc_.get());
+    EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_);
+  }
+
+  void CreatePeerConnectionExpectFail(const std::string& uri) {
+    PeerConnectionInterface::RTCConfiguration config;
+    PeerConnectionInterface::IceServer server;
+    server.uri = uri;
+    config.servers.push_back(server);
+    config.sdp_semantics = sdp_semantics_;
+    PeerConnectionDependencies pc_dependencies(&observer_);
+    auto result = pc_factory_->CreatePeerConnectionOrError(
+        config, std::move(pc_dependencies));
+    EXPECT_FALSE(result.ok());
+  }
+
+  void CreatePeerConnectionExpectFail(
+      PeerConnectionInterface::RTCConfiguration config) {
+    PeerConnectionInterface::IceServer server;
+    server.uri = kTurnIceServerUri;
+    server.password = kTurnPassword;
+    config.servers.push_back(server);
+    config.sdp_semantics = sdp_semantics_;
+    PeerConnectionDependencies pc_dependencies(&observer_);
+    auto result = pc_factory_->CreatePeerConnectionOrError(
+        config, std::move(pc_dependencies));
+    EXPECT_FALSE(result.ok());
+  }
+
+  void CreatePeerConnectionWithDifferentConfigurations() {
+    CreatePeerConnectionWithIceServer(kStunAddressOnly, "", "");
+    EXPECT_EQ(1u, port_allocator_->stun_servers().size());
+    EXPECT_EQ(0u, port_allocator_->turn_servers().size());
+    EXPECT_EQ("address", port_allocator_->stun_servers().begin()->hostname());
+    EXPECT_EQ(kDefaultStunPort,
+              port_allocator_->stun_servers().begin()->port());
+
+    CreatePeerConnectionExpectFail(kStunInvalidPort);
+    CreatePeerConnectionExpectFail(kStunAddressPortAndMore1);
+    CreatePeerConnectionExpectFail(kStunAddressPortAndMore2);
+
+    CreatePeerConnectionWithIceServer(kTurnIceServerUri, kTurnUsername,
+                                      kTurnPassword);
+    EXPECT_EQ(0u, port_allocator_->stun_servers().size());
+    EXPECT_EQ(1u, port_allocator_->turn_servers().size());
+    EXPECT_EQ(kTurnUsername,
+              port_allocator_->turn_servers()[0].credentials.username);
+    EXPECT_EQ(kTurnPassword,
+              port_allocator_->turn_servers()[0].credentials.password);
+    EXPECT_EQ(kTurnHostname,
+              port_allocator_->turn_servers()[0].ports[0].address.hostname());
+  }
+
+  void ReleasePeerConnection() {
+    pc_ = nullptr;
+    observer_.SetPeerConnectionInterface(nullptr);
+  }
+
+  rtc::scoped_refptr<VideoTrackInterface> CreateVideoTrack(
+      const std::string& label) {
+    return pc_factory_->CreateVideoTrack(label,
+                                         FakeVideoTrackSource::Create().get());
+  }
+
+  void AddVideoTrack(const std::string& track_label,
+                     const std::vector<std::string>& stream_ids = {}) {
+    auto sender_or_error =
+        pc_->AddTrack(CreateVideoTrack(track_label), stream_ids);
+    ASSERT_EQ(RTCErrorType::NONE, sender_or_error.error().type());
+  }
+
+  void AddVideoStream(const std::string& label) {
+    rtc::scoped_refptr<MediaStreamInterface> stream(
+        pc_factory_->CreateLocalMediaStream(label));
+    stream->AddTrack(CreateVideoTrack(label + "v0"));
+    ASSERT_TRUE(pc_->AddStream(stream.get()));
+  }
+
+  rtc::scoped_refptr<AudioTrackInterface> CreateAudioTrack(
+      const std::string& label) {
+    return pc_factory_->CreateAudioTrack(label, nullptr);
+  }
+
+  void AddAudioTrack(const std::string& track_label,
+                     const std::vector<std::string>& stream_ids = {}) {
+    auto sender_or_error =
+        pc_->AddTrack(CreateAudioTrack(track_label), stream_ids);
+    ASSERT_EQ(RTCErrorType::NONE, sender_or_error.error().type());
+  }
+
+  void AddAudioStream(const std::string& label) {
+    rtc::scoped_refptr<MediaStreamInterface> stream(
+        pc_factory_->CreateLocalMediaStream(label));
+    stream->AddTrack(CreateAudioTrack(label + "a0"));
+    ASSERT_TRUE(pc_->AddStream(stream.get()));
+  }
+
+  void AddAudioVideoStream(const std::string& stream_id,
+                           const std::string& audio_track_label,
+                           const std::string& video_track_label) {
+    // Create a local stream.
+    rtc::scoped_refptr<MediaStreamInterface> stream(
+        pc_factory_->CreateLocalMediaStream(stream_id));
+    stream->AddTrack(CreateAudioTrack(audio_track_label));
+    stream->AddTrack(CreateVideoTrack(video_track_label));
+    ASSERT_TRUE(pc_->AddStream(stream.get()));
+  }
+
+  rtc::scoped_refptr<RtpReceiverInterface> GetFirstReceiverOfType(
+      cricket::MediaType media_type) {
+    for (auto receiver : pc_->GetReceivers()) {
+      if (receiver->media_type() == media_type) {
+        return receiver;
+      }
+    }
+    return nullptr;
+  }
+
+  bool DoCreateOfferAnswer(std::unique_ptr<SessionDescriptionInterface>* desc,
+                           const RTCOfferAnswerOptions* options,
+                           bool offer) {
+    auto observer =
+        rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
+    if (offer) {
+      pc_->CreateOffer(observer.get(),
+                       options ? *options : RTCOfferAnswerOptions());
+    } else {
+      pc_->CreateAnswer(observer.get(),
+                        options ? *options : RTCOfferAnswerOptions());
+    }
+    EXPECT_EQ_WAIT(true, observer->called(), kTimeout);
+    *desc = observer->MoveDescription();
+    return observer->result();
+  }
+
+  bool DoCreateOffer(std::unique_ptr<SessionDescriptionInterface>* desc,
+                     const RTCOfferAnswerOptions* options) {
+    return DoCreateOfferAnswer(desc, options, true);
+  }
+
+  bool DoCreateAnswer(std::unique_ptr<SessionDescriptionInterface>* desc,
+                      const RTCOfferAnswerOptions* options) {
+    return DoCreateOfferAnswer(desc, options, false);
+  }
+
+  bool DoSetSessionDescription(
+      std::unique_ptr<SessionDescriptionInterface> desc,
+      bool local) {
+    auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
+    if (local) {
+      pc_->SetLocalDescription(observer.get(), desc.release());
+    } else {
+      pc_->SetRemoteDescription(observer.get(), desc.release());
+    }
+    if (pc_->signaling_state() != PeerConnectionInterface::kClosed) {
+      EXPECT_EQ_WAIT(true, observer->called(), kTimeout);
+    }
+    return observer->result();
+  }
+
+  bool DoSetLocalDescription(
+      std::unique_ptr<SessionDescriptionInterface> desc) {
+    return DoSetSessionDescription(std::move(desc), true);
+  }
+
+  bool DoSetRemoteDescription(
+      std::unique_ptr<SessionDescriptionInterface> desc) {
+    return DoSetSessionDescription(std::move(desc), false);
+  }
+
+  // Calls PeerConnection::GetStats and check the return value.
+  // It does not verify the values in the StatReports since a RTCP packet might
+  // be required.
+  bool DoGetStats(MediaStreamTrackInterface* track) {
+    auto observer = rtc::make_ref_counted<MockStatsObserver>();
+    if (!pc_->GetStats(observer.get(), track,
+                       PeerConnectionInterface::kStatsOutputLevelStandard))
+      return false;
+    EXPECT_TRUE_WAIT(observer->called(), kTimeout);
+    return observer->called();
+  }
+
+  // Call the standards-compliant GetStats function.
+  bool DoGetRTCStats() {
+    auto callback =
+        rtc::make_ref_counted<webrtc::MockRTCStatsCollectorCallback>();
+    pc_->GetStats(callback.get());
+    EXPECT_TRUE_WAIT(callback->called(), kTimeout);
+    return callback->called();
+  }
+
+  void InitiateCall() {
+    CreatePeerConnectionWithoutDtls();
+    // Create a local stream with audio&video tracks.
+    if (sdp_semantics_ == SdpSemantics::kPlanB_DEPRECATED) {
+      AddAudioVideoStream(kStreamId1, "audio_track", "video_track");
+    } else {
+      // Unified Plan does not support AddStream, so just add an audio and video
+      // track.
+      AddAudioTrack(kAudioTracks[0], {kStreamId1});
+      AddVideoTrack(kVideoTracks[0], {kStreamId1});
+    }
+    CreateOfferReceiveAnswer();
+  }
+
+  // Verify that RTP Header extensions has been negotiated for audio and video.
+  void VerifyRemoteRtpHeaderExtensions() {
+    const cricket::MediaContentDescription* desc =
+        cricket::GetFirstAudioContentDescription(
+            pc_->remote_description()->description());
+    ASSERT_TRUE(desc != nullptr);
+    EXPECT_GT(desc->rtp_header_extensions().size(), 0u);
+
+    desc = cricket::GetFirstVideoContentDescription(
+        pc_->remote_description()->description());
+    ASSERT_TRUE(desc != nullptr);
+    EXPECT_GT(desc->rtp_header_extensions().size(), 0u);
+  }
+
+  void CreateOfferAsRemoteDescription() {
+    std::unique_ptr<SessionDescriptionInterface> offer;
+    ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+    std::string sdp;
+    EXPECT_TRUE(offer->ToString(&sdp));
+    std::unique_ptr<SessionDescriptionInterface> remote_offer(
+        webrtc::CreateSessionDescription(SdpType::kOffer, sdp));
+    EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_offer)));
+    EXPECT_EQ(PeerConnectionInterface::kHaveRemoteOffer, observer_.state_);
+  }
+
+  void CreateAndSetRemoteOffer(const std::string& sdp) {
+    std::unique_ptr<SessionDescriptionInterface> remote_offer(
+        webrtc::CreateSessionDescription(SdpType::kOffer, sdp));
+    EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_offer)));
+    EXPECT_EQ(PeerConnectionInterface::kHaveRemoteOffer, observer_.state_);
+  }
+
+  void CreateAnswerAsLocalDescription() {
+    std::unique_ptr<SessionDescriptionInterface> answer;
+    ASSERT_TRUE(DoCreateAnswer(&answer, nullptr));
+
+    // TODO(perkj): Currently SetLocalDescription fails if any parameters in an
+    // audio codec change, even if the parameter has nothing to do with
+    // receiving. Not all parameters are serialized to SDP.
+    // Since CreatePrAnswerAsLocalDescription serialize/deserialize
+    // the SessionDescription, it is necessary to do that here to in order to
+    // get ReceiveOfferCreatePrAnswerAndAnswer and RenegotiateAudioOnly to pass.
+    // https://code.google.com/p/webrtc/issues/detail?id=1356
+    std::string sdp;
+    EXPECT_TRUE(answer->ToString(&sdp));
+    std::unique_ptr<SessionDescriptionInterface> new_answer(
+        webrtc::CreateSessionDescription(SdpType::kAnswer, sdp));
+    EXPECT_TRUE(DoSetLocalDescription(std::move(new_answer)));
+    EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_);
+  }
+
+  void CreatePrAnswerAsLocalDescription() {
+    std::unique_ptr<SessionDescriptionInterface> answer;
+    ASSERT_TRUE(DoCreateAnswer(&answer, nullptr));
+
+    std::string sdp;
+    EXPECT_TRUE(answer->ToString(&sdp));
+    std::unique_ptr<SessionDescriptionInterface> pr_answer(
+        webrtc::CreateSessionDescription(SdpType::kPrAnswer, sdp));
+    EXPECT_TRUE(DoSetLocalDescription(std::move(pr_answer)));
+    EXPECT_EQ(PeerConnectionInterface::kHaveLocalPrAnswer, observer_.state_);
+  }
+
+  void CreateOfferReceiveAnswer() {
+    CreateOfferAsLocalDescription();
+    std::string sdp;
+    EXPECT_TRUE(pc_->local_description()->ToString(&sdp));
+    CreateAnswerAsRemoteDescription(sdp);
+  }
+
+  void CreateOfferAsLocalDescription() {
+    std::unique_ptr<SessionDescriptionInterface> offer;
+    ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+    // TODO(perkj): Currently SetLocalDescription fails if any parameters in an
+    // audio codec change, even if the parameter has nothing to do with
+    // receiving. Not all parameters are serialized to SDP.
+    // Since CreatePrAnswerAsLocalDescription serialize/deserialize
+    // the SessionDescription, it is necessary to do that here to in order to
+    // get ReceiveOfferCreatePrAnswerAndAnswer and RenegotiateAudioOnly to pass.
+    // https://code.google.com/p/webrtc/issues/detail?id=1356
+    std::string sdp;
+    EXPECT_TRUE(offer->ToString(&sdp));
+    std::unique_ptr<SessionDescriptionInterface> new_offer(
+        webrtc::CreateSessionDescription(SdpType::kOffer, sdp));
+
+    EXPECT_TRUE(DoSetLocalDescription(std::move(new_offer)));
+    EXPECT_EQ(PeerConnectionInterface::kHaveLocalOffer, observer_.state_);
+    // Wait for the ice_complete message, so that SDP will have candidates.
+    EXPECT_TRUE_WAIT(observer_.ice_gathering_complete_, kTimeout);
+  }
+
+  void CreateAnswerAsRemoteDescription(const std::string& sdp) {
+    std::unique_ptr<SessionDescriptionInterface> answer(
+        webrtc::CreateSessionDescription(SdpType::kAnswer, sdp));
+    ASSERT_TRUE(answer);
+    EXPECT_TRUE(DoSetRemoteDescription(std::move(answer)));
+    EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_);
+  }
+
+  void CreatePrAnswerAndAnswerAsRemoteDescription(const std::string& sdp) {
+    std::unique_ptr<SessionDescriptionInterface> pr_answer(
+        webrtc::CreateSessionDescription(SdpType::kPrAnswer, sdp));
+    ASSERT_TRUE(pr_answer);
+    EXPECT_TRUE(DoSetRemoteDescription(std::move(pr_answer)));
+    EXPECT_EQ(PeerConnectionInterface::kHaveRemotePrAnswer, observer_.state_);
+    std::unique_ptr<SessionDescriptionInterface> answer(
+        webrtc::CreateSessionDescription(SdpType::kAnswer, sdp));
+    ASSERT_TRUE(answer);
+    EXPECT_TRUE(DoSetRemoteDescription(std::move(answer)));
+    EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_);
+  }
+
+  // Waits until a remote stream with the given id is signaled. This helper
+  // function will verify both OnAddTrack and OnAddStream (Plan B only) are
+  // called with the given stream id and expected number of tracks.
+  void WaitAndVerifyOnAddStream(const std::string& stream_id,
+                                int expected_num_tracks) {
+    // Verify that both OnAddStream and OnAddTrack are called.
+    EXPECT_EQ_WAIT(stream_id, observer_.GetLastAddedStreamId(), kTimeout);
+    EXPECT_EQ_WAIT(expected_num_tracks,
+                   observer_.CountAddTrackEventsForStream(stream_id), kTimeout);
+  }
+
+  // Creates an offer and applies it as a local session description.
+  // Creates an answer with the same SDP an the offer but removes all lines
+  // that start with a:ssrc"
+  void CreateOfferReceiveAnswerWithoutSsrc() {
+    CreateOfferAsLocalDescription();
+    std::string sdp;
+    EXPECT_TRUE(pc_->local_description()->ToString(&sdp));
+    SetSsrcToZero(&sdp);
+    CreateAnswerAsRemoteDescription(sdp);
+  }
+
+  // This function creates a MediaStream with label kStreams[0] and
+  // `number_of_audio_tracks` and `number_of_video_tracks` tracks and the
+  // corresponding SessionDescriptionInterface. The SessionDescriptionInterface
+  // is returned and the MediaStream is stored in
+  // `reference_collection_`
+  std::unique_ptr<SessionDescriptionInterface>
+  CreateSessionDescriptionAndReference(size_t number_of_audio_tracks,
+                                       size_t number_of_video_tracks) {
+    EXPECT_LE(number_of_audio_tracks, 2u);
+    EXPECT_LE(number_of_video_tracks, 2u);
+
+    reference_collection_ = StreamCollection::Create();
+    std::string sdp_ms1 = std::string(kSdpStringInit);
+
+    std::string mediastream_id = kStreams[0];
+
+    rtc::scoped_refptr<webrtc::MediaStreamInterface> stream(
+        webrtc::MediaStream::Create(mediastream_id));
+    reference_collection_->AddStream(stream);
+
+    if (number_of_audio_tracks > 0) {
+      sdp_ms1 += std::string(kSdpStringAudio);
+      sdp_ms1 += std::string(kSdpStringMs1Audio0);
+      AddAudioTrack(kAudioTracks[0], stream.get());
+    }
+    if (number_of_audio_tracks > 1) {
+      sdp_ms1 += kSdpStringMs1Audio1;
+      AddAudioTrack(kAudioTracks[1], stream.get());
+    }
+
+    if (number_of_video_tracks > 0) {
+      sdp_ms1 += std::string(kSdpStringVideo);
+      sdp_ms1 += std::string(kSdpStringMs1Video0);
+      AddVideoTrack(kVideoTracks[0], stream.get());
+    }
+    if (number_of_video_tracks > 1) {
+      sdp_ms1 += kSdpStringMs1Video1;
+      AddVideoTrack(kVideoTracks[1], stream.get());
+    }
+
+    return std::unique_ptr<SessionDescriptionInterface>(
+        webrtc::CreateSessionDescription(SdpType::kOffer, sdp_ms1));
+  }
+
+  void AddAudioTrack(const std::string& track_id,
+                     MediaStreamInterface* stream) {
+    rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
+        webrtc::AudioTrack::Create(track_id, nullptr));
+    ASSERT_TRUE(stream->AddTrack(audio_track));
+  }
+
+  void AddVideoTrack(const std::string& track_id,
+                     MediaStreamInterface* stream) {
+    rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
+        webrtc::VideoTrack::Create(track_id,
+                                   webrtc::FakeVideoTrackSource::Create(),
+                                   rtc::Thread::Current()));
+    ASSERT_TRUE(stream->AddTrack(video_track));
+  }
+
+  std::unique_ptr<SessionDescriptionInterface> CreateOfferWithOneAudioTrack() {
+    CreatePeerConnectionWithoutDtls();
+    AddAudioTrack(kAudioTracks[0]);
+    std::unique_ptr<SessionDescriptionInterface> offer;
+    EXPECT_TRUE(DoCreateOffer(&offer, nullptr));
+    return offer;
+  }
+
+  std::unique_ptr<SessionDescriptionInterface> CreateOfferWithOneAudioStream() {
+    CreatePeerConnectionWithoutDtls();
+    AddAudioStream(kStreamId1);
+    std::unique_ptr<SessionDescriptionInterface> offer;
+    EXPECT_TRUE(DoCreateOffer(&offer, nullptr));
+    return offer;
+  }
+
+  std::unique_ptr<SessionDescriptionInterface> CreateAnswerWithOneAudioTrack() {
+    EXPECT_TRUE(DoSetRemoteDescription(CreateOfferWithOneAudioTrack()));
+    std::unique_ptr<SessionDescriptionInterface> answer;
+    EXPECT_TRUE(DoCreateAnswer(&answer, nullptr));
+    return answer;
+  }
+
+  std::unique_ptr<SessionDescriptionInterface>
+  CreateAnswerWithOneAudioStream() {
+    EXPECT_TRUE(DoSetRemoteDescription(CreateOfferWithOneAudioStream()));
+    std::unique_ptr<SessionDescriptionInterface> answer;
+    EXPECT_TRUE(DoCreateAnswer(&answer, nullptr));
+    return answer;
+  }
+
+  const std::string& GetFirstAudioStreamCname(
+      const SessionDescriptionInterface* desc) {
+    const cricket::AudioContentDescription* audio_desc =
+        cricket::GetFirstAudioContentDescription(desc->description());
+    return audio_desc->streams()[0].cname;
+  }
+
+  std::unique_ptr<SessionDescriptionInterface> CreateOfferWithOptions(
+      const RTCOfferAnswerOptions& offer_answer_options) {
+    RTC_DCHECK(pc_);
+    auto observer =
+        rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
+    pc_->CreateOffer(observer.get(), offer_answer_options);
+    EXPECT_EQ_WAIT(true, observer->called(), kTimeout);
+    return observer->MoveDescription();
+  }
+
+  void CreateOfferWithOptionsAsRemoteDescription(
+      std::unique_ptr<SessionDescriptionInterface>* desc,
+      const RTCOfferAnswerOptions& offer_answer_options) {
+    *desc = CreateOfferWithOptions(offer_answer_options);
+    ASSERT_TRUE(desc != nullptr);
+    std::string sdp;
+    EXPECT_TRUE((*desc)->ToString(&sdp));
+    std::unique_ptr<SessionDescriptionInterface> remote_offer(
+        webrtc::CreateSessionDescription(SdpType::kOffer, sdp));
+    EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_offer)));
+    EXPECT_EQ(PeerConnectionInterface::kHaveRemoteOffer, observer_.state_);
+  }
+
+  void CreateOfferWithOptionsAsLocalDescription(
+      std::unique_ptr<SessionDescriptionInterface>* desc,
+      const RTCOfferAnswerOptions& offer_answer_options) {
+    *desc = CreateOfferWithOptions(offer_answer_options);
+    ASSERT_TRUE(desc != nullptr);
+    std::string sdp;
+    EXPECT_TRUE((*desc)->ToString(&sdp));
+    std::unique_ptr<SessionDescriptionInterface> new_offer(
+        webrtc::CreateSessionDescription(SdpType::kOffer, sdp));
+
+    EXPECT_TRUE(DoSetLocalDescription(std::move(new_offer)));
+    EXPECT_EQ(PeerConnectionInterface::kHaveLocalOffer, observer_.state_);
+  }
+
+  bool HasCNCodecs(const cricket::ContentInfo* content) {
+    RTC_DCHECK(content);
+    RTC_DCHECK(content->media_description());
+    for (const cricket::AudioCodec& codec :
+         content->media_description()->as_audio()->codecs()) {
+      if (codec.name == "CN") {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  const char* GetSdpStringWithStream1() const {
+    if (sdp_semantics_ == SdpSemantics::kPlanB_DEPRECATED) {
+      return kSdpStringWithStream1PlanB;
+    } else {
+      return kSdpStringWithStream1UnifiedPlan;
+    }
+  }
+
+  const char* GetSdpStringWithStream1And2() const {
+    if (sdp_semantics_ == SdpSemantics::kPlanB_DEPRECATED) {
+      return kSdpStringWithStream1And2PlanB;
+    } else {
+      return kSdpStringWithStream1And2UnifiedPlan;
+    }
+  }
+
+  rtc::SocketServer* socket_server() const { return vss_.get(); }
+
+  webrtc::test::ScopedKeyValueConfig field_trials_;
+  std::unique_ptr<rtc::VirtualSocketServer> vss_;
+  rtc::AutoSocketServerThread main_;
+  rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
+  cricket::FakePortAllocator* port_allocator_ = nullptr;
+  FakeRTCCertificateGenerator* fake_certificate_generator_ = nullptr;
+  rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pc_factory_;
+  rtc::scoped_refptr<PeerConnectionInterface> pc_;
+  MockPeerConnectionObserver observer_;
+  rtc::scoped_refptr<StreamCollection> reference_collection_;
+  const SdpSemantics sdp_semantics_;
+};
+
+class PeerConnectionInterfaceTest
+    : public PeerConnectionInterfaceBaseTest,
+      public ::testing::WithParamInterface<SdpSemantics> {
+ protected:
+  PeerConnectionInterfaceTest() : PeerConnectionInterfaceBaseTest(GetParam()) {}
+};
+
+class PeerConnectionInterfaceTestPlanB
+    : public PeerConnectionInterfaceBaseTest {
+ protected:
+  PeerConnectionInterfaceTestPlanB()
+      : PeerConnectionInterfaceBaseTest(SdpSemantics::kPlanB_DEPRECATED) {}
+};
+
+// Generate different CNAMEs when PeerConnections are created.
+// The CNAMEs are expected to be generated randomly. It is possible
+// that the test fails, though the possibility is very low.
+TEST_P(PeerConnectionInterfaceTest, CnameGenerationInOffer) {
+  std::unique_ptr<SessionDescriptionInterface> offer1 =
+      CreateOfferWithOneAudioTrack();
+  std::unique_ptr<SessionDescriptionInterface> offer2 =
+      CreateOfferWithOneAudioTrack();
+  EXPECT_NE(GetFirstAudioStreamCname(offer1.get()),
+            GetFirstAudioStreamCname(offer2.get()));
+}
+
+TEST_P(PeerConnectionInterfaceTest, CnameGenerationInAnswer) {
+  std::unique_ptr<SessionDescriptionInterface> answer1 =
+      CreateAnswerWithOneAudioTrack();
+  std::unique_ptr<SessionDescriptionInterface> answer2 =
+      CreateAnswerWithOneAudioTrack();
+  EXPECT_NE(GetFirstAudioStreamCname(answer1.get()),
+            GetFirstAudioStreamCname(answer2.get()));
+}
+
+TEST_P(PeerConnectionInterfaceTest,
+       CreatePeerConnectionWithDifferentConfigurations) {
+  CreatePeerConnectionWithDifferentConfigurations();
+}
+
+TEST_P(PeerConnectionInterfaceTest,
+       CreatePeerConnectionWithDifferentIceTransportsTypes) {
+  CreatePeerConnectionWithIceTransportsType(PeerConnectionInterface::kNone);
+  EXPECT_EQ(cricket::CF_NONE, port_allocator_->candidate_filter());
+  CreatePeerConnectionWithIceTransportsType(PeerConnectionInterface::kRelay);
+  EXPECT_EQ(cricket::CF_RELAY, port_allocator_->candidate_filter());
+  CreatePeerConnectionWithIceTransportsType(PeerConnectionInterface::kNoHost);
+  EXPECT_EQ(cricket::CF_ALL & ~cricket::CF_HOST,
+            port_allocator_->candidate_filter());
+  CreatePeerConnectionWithIceTransportsType(PeerConnectionInterface::kAll);
+  EXPECT_EQ(cricket::CF_ALL, port_allocator_->candidate_filter());
+}
+
+// Test that when a PeerConnection is created with a nonzero candidate pool
+// size, the pooled PortAllocatorSession is created with all the attributes
+// in the RTCConfiguration.
+TEST_P(PeerConnectionInterfaceTest, CreatePeerConnectionWithPooledCandidates) {
+  PeerConnectionInterface::RTCConfiguration config;
+  config.sdp_semantics = sdp_semantics_;
+  PeerConnectionInterface::IceServer server;
+  server.uri = kStunAddressOnly;
+  config.servers.push_back(server);
+  config.type = PeerConnectionInterface::kRelay;
+  config.tcp_candidate_policy =
+      PeerConnectionInterface::kTcpCandidatePolicyDisabled;
+  config.candidate_network_policy =
+      PeerConnectionInterface::kCandidateNetworkPolicyLowCost;
+  config.ice_candidate_pool_size = 1;
+  CreatePeerConnection(config);
+
+  const cricket::FakePortAllocatorSession* session =
+      static_cast<const cricket::FakePortAllocatorSession*>(
+          port_allocator_->GetPooledSession());
+  ASSERT_NE(nullptr, session);
+  EXPECT_EQ(1UL, session->stun_servers().size());
+  EXPECT_LT(0U, session->flags() & cricket::PORTALLOCATOR_DISABLE_TCP);
+  EXPECT_LT(0U,
+            session->flags() & cricket::PORTALLOCATOR_DISABLE_COSTLY_NETWORKS);
+}
+
+// Test that network-related RTCConfiguration members are applied to the
+// PortAllocator when CreatePeerConnection is called. Specifically:
+// - disable_ipv6_on_wifi
+// - max_ipv6_networks
+// - tcp_candidate_policy
+// - candidate_network_policy
+// - prune_turn_ports
+//
+// Note that the candidate filter (RTCConfiguration::type) is already tested
+// above.
+TEST_P(PeerConnectionInterfaceTest,
+       CreatePeerConnectionAppliesNetworkConfigToPortAllocator) {
+  // Create fake port allocator.
+  std::unique_ptr<rtc::PacketSocketFactory> packet_socket_factory(
+      new rtc::BasicPacketSocketFactory(socket_server()));
+  std::unique_ptr<cricket::FakePortAllocator> port_allocator(
+      new cricket::FakePortAllocator(
+          rtc::Thread::Current(), packet_socket_factory.get(), &field_trials_));
+  cricket::FakePortAllocator* raw_port_allocator = port_allocator.get();
+
+  // Create RTCConfiguration with some network-related fields relevant to
+  // PortAllocator populated.
+  PeerConnectionInterface::RTCConfiguration config;
+  config.sdp_semantics = sdp_semantics_;
+  config.disable_ipv6_on_wifi = true;
+  config.max_ipv6_networks = 10;
+  config.tcp_candidate_policy =
+      PeerConnectionInterface::kTcpCandidatePolicyDisabled;
+  config.candidate_network_policy =
+      PeerConnectionInterface::kCandidateNetworkPolicyLowCost;
+  config.prune_turn_ports = true;
+
+  // Create the PC factory and PC with the above config.
+  rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pc_factory(
+      webrtc::CreatePeerConnectionFactory(
+          rtc::Thread::Current(), rtc::Thread::Current(),
+          rtc::Thread::Current(), fake_audio_capture_module_,
+          webrtc::CreateBuiltinAudioEncoderFactory(),
+          webrtc::CreateBuiltinAudioDecoderFactory(),
+          webrtc::CreateBuiltinVideoEncoderFactory(),
+          webrtc::CreateBuiltinVideoDecoderFactory(), nullptr /* audio_mixer */,
+          nullptr /* audio_processing */));
+  PeerConnectionDependencies pc_dependencies(&observer_);
+  pc_dependencies.allocator = std::move(port_allocator);
+  auto result = pc_factory_->CreatePeerConnectionOrError(
+      config, std::move(pc_dependencies));
+  EXPECT_TRUE(result.ok());
+  observer_.SetPeerConnectionInterface(result.value().get());
+
+  // Now validate that the config fields set above were applied to the
+  // PortAllocator, as flags or otherwise.
+  EXPECT_FALSE(raw_port_allocator->flags() &
+               cricket::PORTALLOCATOR_ENABLE_IPV6_ON_WIFI);
+  EXPECT_EQ(10, raw_port_allocator->max_ipv6_networks());
+  EXPECT_TRUE(raw_port_allocator->flags() & cricket::PORTALLOCATOR_DISABLE_TCP);
+  EXPECT_TRUE(raw_port_allocator->flags() &
+              cricket::PORTALLOCATOR_DISABLE_COSTLY_NETWORKS);
+  EXPECT_EQ(webrtc::PRUNE_BASED_ON_PRIORITY,
+            raw_port_allocator->turn_port_prune_policy());
+}
+
+// Check that GetConfiguration returns the configuration the PeerConnection was
+// constructed with, before SetConfiguration is called.
+TEST_P(PeerConnectionInterfaceTest, GetConfigurationAfterCreatePeerConnection) {
+  PeerConnectionInterface::RTCConfiguration config;
+  config.sdp_semantics = sdp_semantics_;
+  config.type = PeerConnectionInterface::kRelay;
+  CreatePeerConnection(config);
+
+  PeerConnectionInterface::RTCConfiguration returned_config =
+      pc_->GetConfiguration();
+  EXPECT_EQ(PeerConnectionInterface::kRelay, returned_config.type);
+}
+
+// Check that GetConfiguration returns the last configuration passed into
+// SetConfiguration.
+TEST_P(PeerConnectionInterfaceTest, GetConfigurationAfterSetConfiguration) {
+  PeerConnectionInterface::RTCConfiguration starting_config;
+  starting_config.sdp_semantics = sdp_semantics_;
+  starting_config.bundle_policy =
+      webrtc::PeerConnection::kBundlePolicyMaxBundle;
+  CreatePeerConnection(starting_config);
+
+  PeerConnectionInterface::RTCConfiguration config = pc_->GetConfiguration();
+  config.type = PeerConnectionInterface::kRelay;
+  EXPECT_TRUE(pc_->SetConfiguration(config).ok());
+
+  PeerConnectionInterface::RTCConfiguration returned_config =
+      pc_->GetConfiguration();
+  EXPECT_EQ(PeerConnectionInterface::kRelay, returned_config.type);
+}
+
+TEST_P(PeerConnectionInterfaceTest, SetConfigurationFailsAfterClose) {
+  CreatePeerConnection();
+
+  pc_->Close();
+
+  EXPECT_FALSE(
+      pc_->SetConfiguration(PeerConnectionInterface::RTCConfiguration()).ok());
+}
+
+TEST_F(PeerConnectionInterfaceTestPlanB, AddStreams) {
+  CreatePeerConnectionWithoutDtls();
+  AddVideoStream(kStreamId1);
+  AddAudioStream(kStreamId2);
+  ASSERT_EQ(2u, pc_->local_streams()->count());
+
+  // Test we can add multiple local streams to one peerconnection.
+  rtc::scoped_refptr<MediaStreamInterface> stream(
+      pc_factory_->CreateLocalMediaStream(kStreamId3));
+  rtc::scoped_refptr<AudioTrackInterface> audio_track(
+      pc_factory_->CreateAudioTrack(
+          kStreamId3, static_cast<AudioSourceInterface*>(nullptr)));
+  stream->AddTrack(audio_track);
+  EXPECT_TRUE(pc_->AddStream(stream.get()));
+  EXPECT_EQ(3u, pc_->local_streams()->count());
+
+  // Remove the third stream.
+  pc_->RemoveStream(pc_->local_streams()->at(2));
+  EXPECT_EQ(2u, pc_->local_streams()->count());
+
+  // Remove the second stream.
+  pc_->RemoveStream(pc_->local_streams()->at(1));
+  EXPECT_EQ(1u, pc_->local_streams()->count());
+
+  // Remove the first stream.
+  pc_->RemoveStream(pc_->local_streams()->at(0));
+  EXPECT_EQ(0u, pc_->local_streams()->count());
+}
+
+// Test that the created offer includes streams we added.
+// Don't run under Unified Plan since the stream API is not available.
+TEST_F(PeerConnectionInterfaceTestPlanB, AddedStreamsPresentInOffer) {
+  CreatePeerConnectionWithoutDtls();
+  AddAudioVideoStream(kStreamId1, "audio_track", "video_track");
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+
+  const cricket::AudioContentDescription* audio_desc =
+      cricket::GetFirstAudioContentDescription(offer->description());
+  EXPECT_TRUE(ContainsTrack(audio_desc->streams(), kStreamId1, "audio_track"));
+
+  const cricket::VideoContentDescription* video_desc =
+      cricket::GetFirstVideoContentDescription(offer->description());
+  EXPECT_TRUE(ContainsTrack(video_desc->streams(), kStreamId1, "video_track"));
+
+  // Add another stream and ensure the offer includes both the old and new
+  // streams.
+  AddAudioVideoStream(kStreamId2, "audio_track2", "video_track2");
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+
+  audio_desc = cricket::GetFirstAudioContentDescription(offer->description());
+  EXPECT_TRUE(ContainsTrack(audio_desc->streams(), kStreamId1, "audio_track"));
+  EXPECT_TRUE(ContainsTrack(audio_desc->streams(), kStreamId2, "audio_track2"));
+
+  video_desc = cricket::GetFirstVideoContentDescription(offer->description());
+  EXPECT_TRUE(ContainsTrack(video_desc->streams(), kStreamId1, "video_track"));
+  EXPECT_TRUE(ContainsTrack(video_desc->streams(), kStreamId2, "video_track2"));
+}
+
+// Don't run under Unified Plan since the stream API is not available.
+TEST_F(PeerConnectionInterfaceTestPlanB, RemoveStream) {
+  CreatePeerConnectionWithoutDtls();
+  AddVideoStream(kStreamId1);
+  ASSERT_EQ(1u, pc_->local_streams()->count());
+  pc_->RemoveStream(pc_->local_streams()->at(0));
+  EXPECT_EQ(0u, pc_->local_streams()->count());
+}
+
+// Test for AddTrack and RemoveTrack methods.
+// Tests that the created offer includes tracks we added,
+// and that the RtpSenders are created correctly.
+// Also tests that RemoveTrack removes the tracks from subsequent offers.
+// Only tested with Plan B since Unified Plan is covered in more detail by tests
+// in peerconnection_jsep_unittests.cc
+TEST_F(PeerConnectionInterfaceTestPlanB, AddTrackRemoveTrack) {
+  CreatePeerConnectionWithoutDtls();
+  rtc::scoped_refptr<AudioTrackInterface> audio_track(
+      CreateAudioTrack("audio_track"));
+  rtc::scoped_refptr<VideoTrackInterface> video_track(
+      CreateVideoTrack("video_track"));
+  auto audio_sender = pc_->AddTrack(audio_track, {kStreamId1}).MoveValue();
+  auto video_sender = pc_->AddTrack(video_track, {kStreamId1}).MoveValue();
+  EXPECT_EQ(1UL, audio_sender->stream_ids().size());
+  EXPECT_EQ(kStreamId1, audio_sender->stream_ids()[0]);
+  EXPECT_EQ("audio_track", audio_sender->id());
+  EXPECT_EQ(audio_track, audio_sender->track());
+  EXPECT_EQ(1UL, video_sender->stream_ids().size());
+  EXPECT_EQ(kStreamId1, video_sender->stream_ids()[0]);
+  EXPECT_EQ("video_track", video_sender->id());
+  EXPECT_EQ(video_track, video_sender->track());
+
+  // Now create an offer and check for the senders.
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+
+  const cricket::ContentInfo* audio_content =
+      cricket::GetFirstAudioContent(offer->description());
+  EXPECT_TRUE(ContainsTrack(audio_content->media_description()->streams(),
+                            kStreamId1, "audio_track"));
+
+  const cricket::ContentInfo* video_content =
+      cricket::GetFirstVideoContent(offer->description());
+  EXPECT_TRUE(ContainsTrack(video_content->media_description()->streams(),
+                            kStreamId1, "video_track"));
+
+  EXPECT_TRUE(DoSetLocalDescription(std::move(offer)));
+
+  // Now try removing the tracks.
+  EXPECT_TRUE(pc_->RemoveTrackOrError(audio_sender).ok());
+  EXPECT_TRUE(pc_->RemoveTrackOrError(video_sender).ok());
+
+  // Create a new offer and ensure it doesn't contain the removed senders.
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+
+  audio_content = cricket::GetFirstAudioContent(offer->description());
+  EXPECT_FALSE(ContainsTrack(audio_content->media_description()->streams(),
+                             kStreamId1, "audio_track"));
+
+  video_content = cricket::GetFirstVideoContent(offer->description());
+  EXPECT_FALSE(ContainsTrack(video_content->media_description()->streams(),
+                             kStreamId1, "video_track"));
+
+  EXPECT_TRUE(DoSetLocalDescription(std::move(offer)));
+
+  // Calling RemoveTrack on a sender no longer attached to a PeerConnection
+  // should return false.
+  EXPECT_FALSE(pc_->RemoveTrackOrError(audio_sender).ok());
+  EXPECT_FALSE(pc_->RemoveTrackOrError(video_sender).ok());
+}
+
+// Test for AddTrack with init_send_encoding.
+TEST_F(PeerConnectionInterfaceTestPlanB, AddTrackWithSendEncodings) {
+  CreatePeerConnectionWithoutDtls();
+  rtc::scoped_refptr<AudioTrackInterface> audio_track(
+      CreateAudioTrack("audio_track"));
+  rtc::scoped_refptr<VideoTrackInterface> video_track(
+      CreateVideoTrack("video_track"));
+  RtpEncodingParameters audio_encodings;
+  audio_encodings.active = false;
+  auto audio_sender =
+      pc_->AddTrack(audio_track, {kStreamId1}, {audio_encodings}).MoveValue();
+  RtpEncodingParameters video_encodings;
+  video_encodings.active = true;
+  auto video_sender =
+      pc_->AddTrack(video_track, {kStreamId1}, {video_encodings}).MoveValue();
+  EXPECT_EQ(1UL, audio_sender->stream_ids().size());
+  EXPECT_EQ(kStreamId1, audio_sender->stream_ids()[0]);
+  EXPECT_EQ("audio_track", audio_sender->id());
+  EXPECT_EQ(audio_track, audio_sender->track());
+  EXPECT_EQ(1UL, video_sender->stream_ids().size());
+  EXPECT_EQ(kStreamId1, video_sender->stream_ids()[0]);
+  EXPECT_EQ("video_track", video_sender->id());
+  EXPECT_EQ(video_track, video_sender->track());
+
+  // Now create an offer and check for the senders.
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+
+  const cricket::ContentInfo* audio_content =
+      cricket::GetFirstAudioContent(offer->description());
+  EXPECT_TRUE(ContainsTrack(audio_content->media_description()->streams(),
+                            kStreamId1, "audio_track"));
+
+  const cricket::ContentInfo* video_content =
+      cricket::GetFirstVideoContent(offer->description());
+  EXPECT_TRUE(ContainsTrack(video_content->media_description()->streams(),
+                            kStreamId1, "video_track"));
+
+  EXPECT_TRUE(DoSetLocalDescription(std::move(offer)));
+
+  // Check the encodings.
+  ASSERT_THAT(audio_sender->GetParameters().encodings, SizeIs(1));
+  EXPECT_THAT(audio_sender->GetParameters().encodings[0].active, Eq(false));
+  ASSERT_THAT(video_sender->GetParameters().encodings, SizeIs(1));
+  EXPECT_THAT(video_sender->GetParameters().encodings[0].active, Eq(true));
+
+  // Now try removing the tracks.
+  EXPECT_TRUE(pc_->RemoveTrackOrError(audio_sender).ok());
+  EXPECT_TRUE(pc_->RemoveTrackOrError(video_sender).ok());
+}
+
+// Test creating senders without a stream specified,
+// expecting a random stream ID to be generated.
+TEST_P(PeerConnectionInterfaceTest, AddTrackWithoutStream) {
+  CreatePeerConnectionWithoutDtls();
+  rtc::scoped_refptr<AudioTrackInterface> audio_track(
+      CreateAudioTrack("audio_track"));
+  rtc::scoped_refptr<VideoTrackInterface> video_track(
+      CreateVideoTrack("video_track"));
+  auto audio_sender =
+      pc_->AddTrack(audio_track, std::vector<std::string>()).MoveValue();
+  auto video_sender =
+      pc_->AddTrack(video_track, std::vector<std::string>()).MoveValue();
+  EXPECT_EQ("audio_track", audio_sender->id());
+  EXPECT_EQ(audio_track, audio_sender->track());
+  EXPECT_EQ("video_track", video_sender->id());
+  EXPECT_EQ(video_track, video_sender->track());
+  if (sdp_semantics_ == SdpSemantics::kPlanB_DEPRECATED) {
+    // If the ID is truly a random GUID, it should be infinitely unlikely they
+    // will be the same.
+    EXPECT_NE(video_sender->stream_ids(), audio_sender->stream_ids());
+  } else {
+    // We allows creating tracks without stream ids under Unified Plan
+    // semantics.
+    EXPECT_EQ(0u, video_sender->stream_ids().size());
+    EXPECT_EQ(0u, audio_sender->stream_ids().size());
+  }
+}
+
+// Test that we can call GetStats() after AddTrack but before connecting
+// the PeerConnection to a peer.
+TEST_P(PeerConnectionInterfaceTest, AddTrackBeforeConnecting) {
+  CreatePeerConnectionWithoutDtls();
+  rtc::scoped_refptr<AudioTrackInterface> audio_track(
+      CreateAudioTrack("audio_track"));
+  rtc::scoped_refptr<VideoTrackInterface> video_track(
+      CreateVideoTrack("video_track"));
+  auto audio_sender = pc_->AddTrack(audio_track, std::vector<std::string>());
+  auto video_sender = pc_->AddTrack(video_track, std::vector<std::string>());
+  EXPECT_TRUE(DoGetStats(nullptr));
+}
+
+TEST_P(PeerConnectionInterfaceTest, AttachmentIdIsSetOnAddTrack) {
+  CreatePeerConnectionWithoutDtls();
+  rtc::scoped_refptr<AudioTrackInterface> audio_track(
+      CreateAudioTrack("audio_track"));
+  rtc::scoped_refptr<VideoTrackInterface> video_track(
+      CreateVideoTrack("video_track"));
+  auto audio_sender = pc_->AddTrack(audio_track, std::vector<std::string>());
+  ASSERT_TRUE(audio_sender.ok());
+  auto* audio_sender_proxy =
+      static_cast<RtpSenderProxyWithInternal<RtpSenderInternal>*>(
+          audio_sender.value().get());
+  EXPECT_NE(0, audio_sender_proxy->internal()->AttachmentId());
+
+  auto video_sender = pc_->AddTrack(video_track, std::vector<std::string>());
+  ASSERT_TRUE(video_sender.ok());
+  auto* video_sender_proxy =
+      static_cast<RtpSenderProxyWithInternal<RtpSenderInternal>*>(
+          video_sender.value().get());
+  EXPECT_NE(0, video_sender_proxy->internal()->AttachmentId());
+}
+
+// Don't run under Unified Plan since the stream API is not available.
+TEST_F(PeerConnectionInterfaceTestPlanB, AttachmentIdIsSetOnAddStream) {
+  CreatePeerConnectionWithoutDtls();
+  AddVideoStream(kStreamId1);
+  auto senders = pc_->GetSenders();
+  ASSERT_EQ(1u, senders.size());
+  auto* sender_proxy =
+      static_cast<RtpSenderProxyWithInternal<RtpSenderInternal>*>(
+          senders[0].get());
+  EXPECT_NE(0, sender_proxy->internal()->AttachmentId());
+}
+
+TEST_P(PeerConnectionInterfaceTest, CreateOfferReceiveAnswer) {
+  InitiateCall();
+  WaitAndVerifyOnAddStream(kStreamId1, 2);
+  VerifyRemoteRtpHeaderExtensions();
+}
+
+TEST_P(PeerConnectionInterfaceTest, CreateOfferReceivePrAnswerAndAnswer) {
+  CreatePeerConnectionWithoutDtls();
+  AddVideoTrack(kVideoTracks[0], {kStreamId1});
+  CreateOfferAsLocalDescription();
+  std::string offer;
+  EXPECT_TRUE(pc_->local_description()->ToString(&offer));
+  CreatePrAnswerAndAnswerAsRemoteDescription(offer);
+  WaitAndVerifyOnAddStream(kStreamId1, 1);
+}
+
+TEST_P(PeerConnectionInterfaceTest, ReceiveOfferCreateAnswer) {
+  CreatePeerConnectionWithoutDtls();
+  AddVideoTrack(kVideoTracks[0], {kStreamId1});
+
+  CreateOfferAsRemoteDescription();
+  CreateAnswerAsLocalDescription();
+
+  WaitAndVerifyOnAddStream(kStreamId1, 1);
+}
+
+TEST_P(PeerConnectionInterfaceTest, ReceiveOfferCreatePrAnswerAndAnswer) {
+  CreatePeerConnectionWithoutDtls();
+  AddVideoTrack(kVideoTracks[0], {kStreamId1});
+
+  CreateOfferAsRemoteDescription();
+  CreatePrAnswerAsLocalDescription();
+  CreateAnswerAsLocalDescription();
+
+  WaitAndVerifyOnAddStream(kStreamId1, 1);
+}
+
+// Don't run under Unified Plan since the stream API is not available.
+TEST_F(PeerConnectionInterfaceTestPlanB, Renegotiate) {
+  InitiateCall();
+  ASSERT_EQ(1u, pc_->remote_streams()->count());
+  pc_->RemoveStream(pc_->local_streams()->at(0));
+  CreateOfferReceiveAnswer();
+  EXPECT_EQ(0u, pc_->remote_streams()->count());
+  AddVideoStream(kStreamId1);
+  CreateOfferReceiveAnswer();
+}
+
+// Tests that after negotiating an audio only call, the respondent can perform a
+// renegotiation that removes the audio stream.
+TEST_F(PeerConnectionInterfaceTestPlanB, RenegotiateAudioOnly) {
+  CreatePeerConnectionWithoutDtls();
+  AddAudioStream(kStreamId1);
+  CreateOfferAsRemoteDescription();
+  CreateAnswerAsLocalDescription();
+
+  ASSERT_EQ(1u, pc_->remote_streams()->count());
+  pc_->RemoveStream(pc_->local_streams()->at(0));
+  CreateOfferReceiveAnswer();
+  EXPECT_EQ(0u, pc_->remote_streams()->count());
+}
+
+// Test that candidates are generated and that we can parse our own candidates.
+TEST_P(PeerConnectionInterfaceTest, IceCandidates) {
+  CreatePeerConnectionWithoutDtls();
+
+  EXPECT_FALSE(pc_->AddIceCandidate(observer_.last_candidate()));
+  // SetRemoteDescription takes ownership of offer.
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  AddVideoTrack(kVideoTracks[0]);
+  EXPECT_TRUE(DoCreateOffer(&offer, nullptr));
+  EXPECT_TRUE(DoSetRemoteDescription(std::move(offer)));
+
+  // SetLocalDescription takes ownership of answer.
+  std::unique_ptr<SessionDescriptionInterface> answer;
+  EXPECT_TRUE(DoCreateAnswer(&answer, nullptr));
+  EXPECT_TRUE(DoSetLocalDescription(std::move(answer)));
+
+  EXPECT_TRUE_WAIT(observer_.last_candidate() != nullptr, kTimeout);
+  EXPECT_TRUE_WAIT(observer_.ice_gathering_complete_, kTimeout);
+
+  EXPECT_TRUE(pc_->AddIceCandidate(observer_.last_candidate()));
+}
+
+// Test that CreateOffer and CreateAnswer will fail if the track labels are
+// not unique.
+TEST_F(PeerConnectionInterfaceTestPlanB, CreateOfferAnswerWithInvalidStream) {
+  CreatePeerConnectionWithoutDtls();
+  // Create a regular offer for the CreateAnswer test later.
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  EXPECT_TRUE(DoCreateOffer(&offer, nullptr));
+  EXPECT_TRUE(offer);
+  offer.reset();
+
+  // Create a local stream with audio&video tracks having same label.
+  AddAudioTrack("track_label", {kStreamId1});
+  AddVideoTrack("track_label", {kStreamId1});
+
+  // Test CreateOffer
+  EXPECT_FALSE(DoCreateOffer(&offer, nullptr));
+
+  // Test CreateAnswer
+  std::unique_ptr<SessionDescriptionInterface> answer;
+  EXPECT_FALSE(DoCreateAnswer(&answer, nullptr));
+}
+
+// Test that we will get different SSRCs for each tracks in the offer and answer
+// we created.
+TEST_P(PeerConnectionInterfaceTest, SsrcInOfferAnswer) {
+  CreatePeerConnectionWithoutDtls();
+  // Create a local stream with audio&video tracks having different labels.
+  AddAudioTrack(kAudioTracks[0], {kStreamId1});
+  AddVideoTrack(kVideoTracks[0], {kStreamId1});
+
+  // Test CreateOffer
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+  int audio_ssrc = 0;
+  int video_ssrc = 0;
+  EXPECT_TRUE(
+      GetFirstSsrc(GetFirstAudioContent(offer->description()), &audio_ssrc));
+  EXPECT_TRUE(
+      GetFirstSsrc(GetFirstVideoContent(offer->description()), &video_ssrc));
+  EXPECT_NE(audio_ssrc, video_ssrc);
+
+  // Test CreateAnswer
+  EXPECT_TRUE(DoSetRemoteDescription(std::move(offer)));
+  std::unique_ptr<SessionDescriptionInterface> answer;
+  ASSERT_TRUE(DoCreateAnswer(&answer, nullptr));
+  audio_ssrc = 0;
+  video_ssrc = 0;
+  EXPECT_TRUE(
+      GetFirstSsrc(GetFirstAudioContent(answer->description()), &audio_ssrc));
+  EXPECT_TRUE(
+      GetFirstSsrc(GetFirstVideoContent(answer->description()), &video_ssrc));
+  EXPECT_NE(audio_ssrc, video_ssrc);
+}
+
+// Test that it's possible to call AddTrack on a MediaStream after adding
+// the stream to a PeerConnection.
+// TODO(deadbeef): Remove this test once this behavior is no longer supported.
+// Don't run under Unified Plan since the stream API is not available.
+TEST_F(PeerConnectionInterfaceTestPlanB, AddTrackAfterAddStream) {
+  CreatePeerConnectionWithoutDtls();
+  // Create audio stream and add to PeerConnection.
+  AddAudioStream(kStreamId1);
+  MediaStreamInterface* stream = pc_->local_streams()->at(0);
+
+  // Add video track to the audio-only stream.
+  rtc::scoped_refptr<VideoTrackInterface> video_track(
+      CreateVideoTrack("video_label"));
+  stream->AddTrack(video_track);
+
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+
+  const cricket::MediaContentDescription* video_desc =
+      cricket::GetFirstVideoContentDescription(offer->description());
+  EXPECT_TRUE(video_desc != nullptr);
+}
+
+// Test that it's possible to call RemoveTrack on a MediaStream after adding
+// the stream to a PeerConnection.
+// TODO(deadbeef): Remove this test once this behavior is no longer supported.
+// Don't run under Unified Plan since the stream API is not available.
+TEST_F(PeerConnectionInterfaceTestPlanB, RemoveTrackAfterAddStream) {
+  CreatePeerConnectionWithoutDtls();
+  // Create audio/video stream and add to PeerConnection.
+  AddAudioVideoStream(kStreamId1, "audio_label", "video_label");
+  MediaStreamInterface* stream = pc_->local_streams()->at(0);
+
+  // Remove the video track.
+  stream->RemoveTrack(stream->GetVideoTracks()[0]);
+
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+
+  const cricket::MediaContentDescription* video_desc =
+      cricket::GetFirstVideoContentDescription(offer->description());
+  EXPECT_TRUE(video_desc == nullptr);
+}
+
+// Test creating a sender with a stream ID, and ensure the ID is populated
+// in the offer.
+// Don't run under Unified Plan since the stream API is not available.
+TEST_F(PeerConnectionInterfaceTestPlanB, CreateSenderWithStream) {
+  CreatePeerConnectionWithoutDtls();
+  pc_->CreateSender("video", kStreamId1);
+
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+
+  const cricket::MediaContentDescription* video_desc =
+      cricket::GetFirstVideoContentDescription(offer->description());
+  ASSERT_TRUE(video_desc != nullptr);
+  ASSERT_EQ(1u, video_desc->streams().size());
+  EXPECT_EQ(kStreamId1, video_desc->streams()[0].first_stream_id());
+}
+
+// Test that we can specify a certain track that we want statistics about.
+TEST_P(PeerConnectionInterfaceTest, GetStatsForSpecificTrack) {
+  InitiateCall();
+  ASSERT_LT(0u, pc_->GetSenders().size());
+  ASSERT_LT(0u, pc_->GetReceivers().size());
+  rtc::scoped_refptr<MediaStreamTrackInterface> remote_audio =
+      pc_->GetReceivers()[0]->track();
+  EXPECT_TRUE(DoGetStats(remote_audio.get()));
+
+  // Remove the stream. Since we are sending to our selves the local
+  // and the remote stream is the same.
+  pc_->RemoveTrackOrError(pc_->GetSenders()[0]);
+  // Do a re-negotiation.
+  CreateOfferReceiveAnswer();
+
+  // Test that we still can get statistics for the old track. Even if it is not
+  // sent any longer.
+  EXPECT_TRUE(DoGetStats(remote_audio.get()));
+}
+
+// Test that we can get stats on a video track.
+TEST_P(PeerConnectionInterfaceTest, GetStatsForVideoTrack) {
+  InitiateCall();
+  auto video_receiver = GetFirstReceiverOfType(cricket::MEDIA_TYPE_VIDEO);
+  ASSERT_TRUE(video_receiver);
+  EXPECT_TRUE(DoGetStats(video_receiver->track().get()));
+}
+
+// Test that we don't get statistics for an invalid track.
+TEST_P(PeerConnectionInterfaceTest, GetStatsForInvalidTrack) {
+  InitiateCall();
+  rtc::scoped_refptr<AudioTrackInterface> unknown_audio_track(
+      pc_factory_->CreateAudioTrack("unknown track", nullptr));
+  EXPECT_FALSE(DoGetStats(unknown_audio_track.get()));
+}
+
+TEST_P(PeerConnectionInterfaceTest, GetRTCStatsBeforeAndAfterCalling) {
+  CreatePeerConnectionWithoutDtls();
+  EXPECT_TRUE(DoGetRTCStats());
+  // Clearing stats cache is needed now, but should be temporary.
+  // https://bugs.chromium.org/p/webrtc/issues/detail?id=8693
+  pc_->ClearStatsCache();
+  AddAudioTrack(kAudioTracks[0], {kStreamId1});
+  AddVideoTrack(kVideoTracks[0], {kStreamId1});
+  EXPECT_TRUE(DoGetRTCStats());
+  pc_->ClearStatsCache();
+  CreateOfferReceiveAnswer();
+  EXPECT_TRUE(DoGetRTCStats());
+}
+
+// This tests that a SCTP data channel is returned using different
+// DataChannelInit configurations.
+TEST_P(PeerConnectionInterfaceTest, CreateSctpDataChannel) {
+  RTCConfiguration rtc_config;
+  CreatePeerConnection(rtc_config);
+
+  webrtc::DataChannelInit config;
+  auto channel = pc_->CreateDataChannelOrError("1", &config);
+  EXPECT_TRUE(channel.ok());
+  EXPECT_TRUE(channel.value()->reliable());
+  EXPECT_TRUE(observer_.renegotiation_needed_);
+  observer_.renegotiation_needed_ = false;
+
+  config.ordered = false;
+  channel = pc_->CreateDataChannelOrError("2", &config);
+  EXPECT_TRUE(channel.ok());
+  EXPECT_TRUE(channel.value()->reliable());
+  EXPECT_FALSE(observer_.renegotiation_needed_);
+
+  config.ordered = true;
+  config.maxRetransmits = 0;
+  channel = pc_->CreateDataChannelOrError("3", &config);
+  EXPECT_TRUE(channel.ok());
+  EXPECT_FALSE(channel.value()->reliable());
+  EXPECT_FALSE(observer_.renegotiation_needed_);
+
+  config.maxRetransmits = absl::nullopt;
+  config.maxRetransmitTime = 0;
+  channel = pc_->CreateDataChannelOrError("4", &config);
+  EXPECT_TRUE(channel.ok());
+  EXPECT_FALSE(channel.value()->reliable());
+  EXPECT_FALSE(observer_.renegotiation_needed_);
+}
+
+// For backwards compatibility, we want people who "unset" maxRetransmits
+// and maxRetransmitTime by setting them to -1 to get what they want.
+TEST_P(PeerConnectionInterfaceTest, CreateSctpDataChannelWithMinusOne) {
+  RTCConfiguration rtc_config;
+  CreatePeerConnection(rtc_config);
+
+  webrtc::DataChannelInit config;
+  config.maxRetransmitTime = -1;
+  config.maxRetransmits = -1;
+  auto channel = pc_->CreateDataChannelOrError("1", &config);
+  EXPECT_TRUE(channel.ok());
+}
+
+// This tests that no data channel is returned if both maxRetransmits and
+// maxRetransmitTime are set for SCTP data channels.
+TEST_P(PeerConnectionInterfaceTest,
+       CreateSctpDataChannelShouldFailForInvalidConfig) {
+  RTCConfiguration rtc_config;
+  CreatePeerConnection(rtc_config);
+
+  std::string label = "test";
+  webrtc::DataChannelInit config;
+  config.maxRetransmits = 0;
+  config.maxRetransmitTime = 0;
+
+  auto channel = pc_->CreateDataChannelOrError(label, &config);
+  EXPECT_FALSE(channel.ok());
+}
+
+// The test verifies that creating a SCTP data channel with an id already in use
+// or out of range should fail.
+TEST_P(PeerConnectionInterfaceTest,
+       CreateSctpDataChannelWithInvalidIdShouldFail) {
+  RTCConfiguration rtc_config;
+  CreatePeerConnection(rtc_config);
+
+  webrtc::DataChannelInit config;
+
+  config.id = 1;
+  config.negotiated = true;
+  auto channel = pc_->CreateDataChannelOrError("1", &config);
+  EXPECT_TRUE(channel.ok());
+  EXPECT_EQ(1, channel.value()->id());
+
+  channel = pc_->CreateDataChannelOrError("x", &config);
+  EXPECT_FALSE(channel.ok());
+
+  config.id = cricket::kMaxSctpSid;
+  config.negotiated = true;
+  channel = pc_->CreateDataChannelOrError("max", &config);
+  EXPECT_TRUE(channel.ok());
+  EXPECT_EQ(config.id, channel.value()->id());
+
+  config.id = cricket::kMaxSctpSid + 1;
+  config.negotiated = true;
+  channel = pc_->CreateDataChannelOrError("x", &config);
+  EXPECT_FALSE(channel.ok());
+}
+
+// Verifies that duplicated label is allowed for SCTP data channel.
+TEST_P(PeerConnectionInterfaceTest, SctpDuplicatedLabelAllowed) {
+  RTCConfiguration rtc_config;
+  CreatePeerConnection(rtc_config);
+
+  std::string label = "test";
+  auto channel = pc_->CreateDataChannelOrError(label, nullptr);
+  EXPECT_TRUE(channel.ok());
+
+  auto dup_channel = pc_->CreateDataChannelOrError(label, nullptr);
+  EXPECT_TRUE(dup_channel.ok());
+}
+
+#ifdef WEBRTC_HAVE_SCTP
+// This tests that SCTP data channels can be rejected in an answer.
+TEST_P(PeerConnectionInterfaceTest, TestRejectSctpDataChannelInAnswer)
+#else
+TEST_P(PeerConnectionInterfaceTest, DISABLED_TestRejectSctpDataChannelInAnswer)
+#endif
+{
+  RTCConfiguration rtc_config;
+  CreatePeerConnection(rtc_config);
+
+  auto offer_channel = pc_->CreateDataChannelOrError("offer_channel", NULL);
+
+  CreateOfferAsLocalDescription();
+
+  // Create an answer where the m-line for data channels are rejected.
+  std::string sdp;
+  EXPECT_TRUE(pc_->local_description()->ToString(&sdp));
+  std::unique_ptr<SessionDescriptionInterface> answer(
+      webrtc::CreateSessionDescription(SdpType::kAnswer, sdp));
+  ASSERT_TRUE(answer);
+  cricket::ContentInfo* data_info =
+      cricket::GetFirstDataContent(answer->description());
+  data_info->rejected = true;
+
+  DoSetRemoteDescription(std::move(answer));
+  EXPECT_EQ(DataChannelInterface::kClosed, offer_channel.value()->state());
+}
+
+// Test that we can create a session description from an SDP string from
+// FireFox, use it as a remote session description, generate an answer and use
+// the answer as a local description.
+TEST_P(PeerConnectionInterfaceTest, ReceiveFireFoxOffer) {
+  RTCConfiguration rtc_config;
+  CreatePeerConnection(rtc_config);
+  AddAudioTrack("audio_label");
+  AddVideoTrack("video_label");
+  std::unique_ptr<SessionDescriptionInterface> desc(
+      webrtc::CreateSessionDescription(SdpType::kOffer,
+                                       webrtc::kFireFoxSdpOffer, nullptr));
+  EXPECT_TRUE(DoSetSessionDescription(std::move(desc), false));
+  CreateAnswerAsLocalDescription();
+  ASSERT_TRUE(pc_->local_description() != nullptr);
+  ASSERT_TRUE(pc_->remote_description() != nullptr);
+
+  const cricket::ContentInfo* content =
+      cricket::GetFirstAudioContent(pc_->local_description()->description());
+  ASSERT_TRUE(content != nullptr);
+  EXPECT_FALSE(content->rejected);
+
+  content =
+      cricket::GetFirstVideoContent(pc_->local_description()->description());
+  ASSERT_TRUE(content != nullptr);
+  EXPECT_FALSE(content->rejected);
+#ifdef WEBRTC_HAVE_SCTP
+  content =
+      cricket::GetFirstDataContent(pc_->local_description()->description());
+  ASSERT_TRUE(content != nullptr);
+  EXPECT_FALSE(content->rejected);
+#endif
+}
+
+// Test that fallback from DTLS to SDES is not supported.
+// The fallback was previously supported but was removed to simplify the code
+// and because it's non-standard.
+TEST_P(PeerConnectionInterfaceTest, DtlsSdesFallbackNotSupported) {
+  RTCConfiguration rtc_config;
+  CreatePeerConnection(rtc_config);
+  // Wait for fake certificate to be generated. Previously, this is what caused
+  // the "a=crypto" lines to be rejected.
+  AddAudioTrack("audio_label");
+  AddVideoTrack("video_label");
+  ASSERT_NE(nullptr, fake_certificate_generator_);
+  EXPECT_EQ_WAIT(1, fake_certificate_generator_->generated_certificates(),
+                 kTimeout);
+  std::unique_ptr<SessionDescriptionInterface> desc(
+      webrtc::CreateSessionDescription(SdpType::kOffer, kDtlsSdesFallbackSdp,
+                                       nullptr));
+  EXPECT_FALSE(DoSetSessionDescription(std::move(desc), /*local=*/false));
+}
+
+// Test that we can create an audio only offer and receive an answer with a
+// limited set of audio codecs and receive an updated offer with more audio
+// codecs, where the added codecs are not supported.
+TEST_P(PeerConnectionInterfaceTest, ReceiveUpdatedAudioOfferWithBadCodecs) {
+  CreatePeerConnectionWithoutDtls();
+  AddAudioTrack("audio_label");
+  CreateOfferAsLocalDescription();
+
+  const char* answer_sdp = (sdp_semantics_ == SdpSemantics::kPlanB_DEPRECATED
+                                ? webrtc::kAudioSdpPlanB
+                                : webrtc::kAudioSdpUnifiedPlan);
+  std::unique_ptr<SessionDescriptionInterface> answer(
+      webrtc::CreateSessionDescription(SdpType::kAnswer, answer_sdp, nullptr));
+  EXPECT_TRUE(DoSetSessionDescription(std::move(answer), false));
+
+  const char* reoffer_sdp =
+      (sdp_semantics_ == SdpSemantics::kPlanB_DEPRECATED
+           ? webrtc::kAudioSdpWithUnsupportedCodecsPlanB
+           : webrtc::kAudioSdpWithUnsupportedCodecsUnifiedPlan);
+  std::unique_ptr<SessionDescriptionInterface> updated_offer(
+      webrtc::CreateSessionDescription(SdpType::kOffer, reoffer_sdp, nullptr));
+  EXPECT_TRUE(DoSetSessionDescription(std::move(updated_offer), false));
+  CreateAnswerAsLocalDescription();
+}
+
+// Test that if we're receiving (but not sending) a track, subsequent offers
+// will have m-lines with a=recvonly.
+TEST_P(PeerConnectionInterfaceTest, CreateSubsequentRecvOnlyOffer) {
+  RTCConfiguration rtc_config;
+  CreatePeerConnection(rtc_config);
+  CreateAndSetRemoteOffer(GetSdpStringWithStream1());
+  CreateAnswerAsLocalDescription();
+
+  // At this point we should be receiving stream 1, but not sending anything.
+  // A new offer should be recvonly.
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  DoCreateOffer(&offer, nullptr);
+
+  const cricket::ContentInfo* video_content =
+      cricket::GetFirstVideoContent(offer->description());
+  ASSERT_EQ(RtpTransceiverDirection::kRecvOnly,
+            video_content->media_description()->direction());
+
+  const cricket::ContentInfo* audio_content =
+      cricket::GetFirstAudioContent(offer->description());
+  ASSERT_EQ(RtpTransceiverDirection::kRecvOnly,
+            audio_content->media_description()->direction());
+}
+
+// Test that if we're receiving (but not sending) a track, and the
+// offerToReceiveVideo/offerToReceiveAudio constraints are explicitly set to
+// false, the generated m-lines will be a=inactive.
+TEST_P(PeerConnectionInterfaceTest, CreateSubsequentInactiveOffer) {
+  RTCConfiguration rtc_config;
+  CreatePeerConnection(rtc_config);
+  CreateAndSetRemoteOffer(GetSdpStringWithStream1());
+  CreateAnswerAsLocalDescription();
+
+  // At this point we should be receiving stream 1, but not sending anything.
+  // A new offer would be recvonly, but we'll set the "no receive" constraints
+  // to make it inactive.
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  RTCOfferAnswerOptions options;
+  options.offer_to_receive_audio = 0;
+  options.offer_to_receive_video = 0;
+  DoCreateOffer(&offer, &options);
+
+  const cricket::ContentInfo* video_content =
+      cricket::GetFirstVideoContent(offer->description());
+  ASSERT_EQ(RtpTransceiverDirection::kInactive,
+            video_content->media_description()->direction());
+
+  const cricket::ContentInfo* audio_content =
+      cricket::GetFirstAudioContent(offer->description());
+  ASSERT_EQ(RtpTransceiverDirection::kInactive,
+            audio_content->media_description()->direction());
+}
+
+// Test that we can use SetConfiguration to change the ICE servers of the
+// PortAllocator.
+TEST_P(PeerConnectionInterfaceTest, SetConfigurationChangesIceServers) {
+  CreatePeerConnection();
+
+  PeerConnectionInterface::RTCConfiguration config = pc_->GetConfiguration();
+  PeerConnectionInterface::IceServer server;
+  server.uri = "stun:test_hostname";
+  config.servers.push_back(server);
+  EXPECT_TRUE(pc_->SetConfiguration(config).ok());
+
+  EXPECT_EQ(1u, port_allocator_->stun_servers().size());
+  EXPECT_EQ("test_hostname",
+            port_allocator_->stun_servers().begin()->hostname());
+}
+
+TEST_P(PeerConnectionInterfaceTest, SetConfigurationChangesCandidateFilter) {
+  CreatePeerConnection();
+  PeerConnectionInterface::RTCConfiguration config = pc_->GetConfiguration();
+  config.type = PeerConnectionInterface::kRelay;
+  EXPECT_TRUE(pc_->SetConfiguration(config).ok());
+  EXPECT_EQ(cricket::CF_RELAY, port_allocator_->candidate_filter());
+}
+
+TEST_P(PeerConnectionInterfaceTest, SetConfigurationChangesPruneTurnPortsFlag) {
+  PeerConnectionInterface::RTCConfiguration config;
+  config.prune_turn_ports = false;
+  CreatePeerConnection(config);
+  config = pc_->GetConfiguration();
+  EXPECT_EQ(webrtc::NO_PRUNE, port_allocator_->turn_port_prune_policy());
+
+  config.prune_turn_ports = true;
+  EXPECT_TRUE(pc_->SetConfiguration(config).ok());
+  EXPECT_EQ(webrtc::PRUNE_BASED_ON_PRIORITY,
+            port_allocator_->turn_port_prune_policy());
+}
+
+// Test that the ice check interval can be changed. This does not verify that
+// the setting makes it all the way to P2PTransportChannel, as that would
+// require a very complex set of mocks.
+TEST_P(PeerConnectionInterfaceTest, SetConfigurationChangesIceCheckInterval) {
+  PeerConnectionInterface::RTCConfiguration config;
+  config.ice_check_min_interval = absl::nullopt;
+  CreatePeerConnection(config);
+  config = pc_->GetConfiguration();
+  config.ice_check_min_interval = 100;
+  EXPECT_TRUE(pc_->SetConfiguration(config).ok());
+  config = pc_->GetConfiguration();
+  EXPECT_EQ(config.ice_check_min_interval, 100);
+}
+
+TEST_P(PeerConnectionInterfaceTest,
+       SetConfigurationChangesSurfaceIceCandidatesOnIceTransportTypeChanged) {
+  PeerConnectionInterface::RTCConfiguration config;
+  config.surface_ice_candidates_on_ice_transport_type_changed = false;
+  CreatePeerConnection(config);
+  config = pc_->GetConfiguration();
+  EXPECT_FALSE(config.surface_ice_candidates_on_ice_transport_type_changed);
+
+  config.surface_ice_candidates_on_ice_transport_type_changed = true;
+  EXPECT_TRUE(pc_->SetConfiguration(config).ok());
+  config = pc_->GetConfiguration();
+  EXPECT_TRUE(config.surface_ice_candidates_on_ice_transport_type_changed);
+}
+
+// Test that when SetConfiguration changes both the pool size and other
+// attributes, the pooled session is created with the updated attributes.
+TEST_P(PeerConnectionInterfaceTest,
+       SetConfigurationCreatesPooledSessionCorrectly) {
+  CreatePeerConnection();
+  PeerConnectionInterface::RTCConfiguration config = pc_->GetConfiguration();
+  config.ice_candidate_pool_size = 1;
+  PeerConnectionInterface::IceServer server;
+  server.uri = kStunAddressOnly;
+  config.servers.push_back(server);
+  config.type = PeerConnectionInterface::kRelay;
+  EXPECT_TRUE(pc_->SetConfiguration(config).ok());
+
+  const cricket::FakePortAllocatorSession* session =
+      static_cast<const cricket::FakePortAllocatorSession*>(
+          port_allocator_->GetPooledSession());
+  ASSERT_NE(nullptr, session);
+  EXPECT_EQ(1UL, session->stun_servers().size());
+}
+
+// Test that after SetLocalDescription, changing the pool size is not allowed,
+// and an invalid modification error is returned.
+TEST_P(PeerConnectionInterfaceTest,
+       CantChangePoolSizeAfterSetLocalDescription) {
+  CreatePeerConnection();
+  // Start by setting a size of 1.
+  PeerConnectionInterface::RTCConfiguration config = pc_->GetConfiguration();
+  config.ice_candidate_pool_size = 1;
+  EXPECT_TRUE(pc_->SetConfiguration(config).ok());
+
+  // Set remote offer; can still change pool size at this point.
+  CreateOfferAsRemoteDescription();
+  config.ice_candidate_pool_size = 2;
+  EXPECT_TRUE(pc_->SetConfiguration(config).ok());
+
+  // Set local answer; now it's too late.
+  CreateAnswerAsLocalDescription();
+  config.ice_candidate_pool_size = 3;
+  RTCError error = pc_->SetConfiguration(config);
+  EXPECT_EQ(RTCErrorType::INVALID_MODIFICATION, error.type());
+}
+
+// Test that after setting an answer, extra pooled sessions are discarded. The
+// ICE candidate pool is only intended to be used for the first offer/answer.
+TEST_P(PeerConnectionInterfaceTest,
+       ExtraPooledSessionsDiscardedAfterApplyingAnswer) {
+  CreatePeerConnection();
+
+  // Set a larger-than-necessary size.
+  PeerConnectionInterface::RTCConfiguration config = pc_->GetConfiguration();
+  config.ice_candidate_pool_size = 4;
+  EXPECT_TRUE(pc_->SetConfiguration(config).ok());
+
+  // Do offer/answer.
+  CreateOfferAsRemoteDescription();
+  CreateAnswerAsLocalDescription();
+
+  // Expect no pooled sessions to be left.
+  const cricket::PortAllocatorSession* session =
+      port_allocator_->GetPooledSession();
+  EXPECT_EQ(nullptr, session);
+}
+
+// After Close is called, pooled candidates should be discarded so as to not
+// waste network resources.
+TEST_P(PeerConnectionInterfaceTest, PooledSessionsDiscardedAfterClose) {
+  CreatePeerConnection();
+
+  PeerConnectionInterface::RTCConfiguration config = pc_->GetConfiguration();
+  config.ice_candidate_pool_size = 3;
+  EXPECT_TRUE(pc_->SetConfiguration(config).ok());
+  pc_->Close();
+
+  // Expect no pooled sessions to be left.
+  const cricket::PortAllocatorSession* session =
+      port_allocator_->GetPooledSession();
+  EXPECT_EQ(nullptr, session);
+}
+
+// Test that SetConfiguration returns an invalid modification error if
+// modifying a field in the configuration that isn't allowed to be modified.
+TEST_P(PeerConnectionInterfaceTest,
+       SetConfigurationReturnsInvalidModificationError) {
+  PeerConnectionInterface::RTCConfiguration config;
+  config.bundle_policy = PeerConnectionInterface::kBundlePolicyBalanced;
+  config.rtcp_mux_policy = PeerConnectionInterface::kRtcpMuxPolicyNegotiate;
+  config.continual_gathering_policy = PeerConnectionInterface::GATHER_ONCE;
+  CreatePeerConnection(config);
+
+  PeerConnectionInterface::RTCConfiguration modified_config =
+      pc_->GetConfiguration();
+  modified_config.bundle_policy =
+      PeerConnectionInterface::kBundlePolicyMaxBundle;
+  RTCError error = pc_->SetConfiguration(modified_config);
+  EXPECT_EQ(RTCErrorType::INVALID_MODIFICATION, error.type());
+
+  modified_config = pc_->GetConfiguration();
+  modified_config.rtcp_mux_policy =
+      PeerConnectionInterface::kRtcpMuxPolicyRequire;
+  error = pc_->SetConfiguration(modified_config);
+  EXPECT_EQ(RTCErrorType::INVALID_MODIFICATION, error.type());
+
+  modified_config = pc_->GetConfiguration();
+  modified_config.continual_gathering_policy =
+      PeerConnectionInterface::GATHER_CONTINUALLY;
+  error = pc_->SetConfiguration(modified_config);
+  EXPECT_EQ(RTCErrorType::INVALID_MODIFICATION, error.type());
+}
+
+// Test that SetConfiguration returns a range error if the candidate pool size
+// is negative or larger than allowed by the spec.
+TEST_P(PeerConnectionInterfaceTest,
+       SetConfigurationReturnsRangeErrorForBadCandidatePoolSize) {
+  PeerConnectionInterface::RTCConfiguration config;
+  CreatePeerConnection(config);
+  config = pc_->GetConfiguration();
+
+  config.ice_candidate_pool_size = -1;
+  RTCError error = pc_->SetConfiguration(config);
+  EXPECT_EQ(RTCErrorType::INVALID_RANGE, error.type());
+
+  config.ice_candidate_pool_size = INT_MAX;
+  error = pc_->SetConfiguration(config);
+  EXPECT_EQ(RTCErrorType::INVALID_RANGE, error.type());
+}
+
+// Test that SetConfiguration returns a syntax error if parsing an ICE server
+// URL failed.
+TEST_P(PeerConnectionInterfaceTest,
+       SetConfigurationReturnsSyntaxErrorFromBadIceUrls) {
+  PeerConnectionInterface::RTCConfiguration config;
+  CreatePeerConnection(config);
+  config = pc_->GetConfiguration();
+
+  PeerConnectionInterface::IceServer bad_server;
+  bad_server.uri = "stunn:www.example.com";
+  config.servers.push_back(bad_server);
+  RTCError error = pc_->SetConfiguration(config);
+  EXPECT_EQ(RTCErrorType::SYNTAX_ERROR, error.type());
+}
+
+// Test that SetConfiguration returns an invalid parameter error if a TURN
+// IceServer is missing a username or password.
+TEST_P(PeerConnectionInterfaceTest,
+       SetConfigurationReturnsInvalidParameterIfCredentialsMissing) {
+  PeerConnectionInterface::RTCConfiguration config;
+  CreatePeerConnection(config);
+  config = pc_->GetConfiguration();
+
+  PeerConnectionInterface::IceServer bad_server;
+  bad_server.uri = "turn:www.example.com";
+  // Missing password.
+  bad_server.username = "foo";
+  config.servers.push_back(bad_server);
+  RTCError error;
+  EXPECT_EQ(pc_->SetConfiguration(config).type(),
+            RTCErrorType::INVALID_PARAMETER);
+}
+
+// Test that PeerConnection::Close changes the states to closed and all remote
+// tracks change state to ended.
+TEST_P(PeerConnectionInterfaceTest, CloseAndTestStreamsAndStates) {
+  // Initialize a PeerConnection and negotiate local and remote session
+  // description.
+  InitiateCall();
+
+  // With Plan B, verify the stream count. The analog with Unified Plan is the
+  // RtpTransceiver count.
+  if (sdp_semantics_ == SdpSemantics::kPlanB_DEPRECATED) {
+    ASSERT_EQ(1u, pc_->local_streams()->count());
+    ASSERT_EQ(1u, pc_->remote_streams()->count());
+  } else {
+    ASSERT_EQ(2u, pc_->GetTransceivers().size());
+  }
+
+  pc_->Close();
+
+  EXPECT_EQ(PeerConnectionInterface::kClosed, pc_->signaling_state());
+  EXPECT_EQ(PeerConnectionInterface::kIceConnectionClosed,
+            pc_->ice_connection_state());
+  EXPECT_EQ(PeerConnectionInterface::kIceGatheringComplete,
+            pc_->ice_gathering_state());
+
+  if (sdp_semantics_ == SdpSemantics::kPlanB_DEPRECATED) {
+    EXPECT_EQ(1u, pc_->local_streams()->count());
+    EXPECT_EQ(1u, pc_->remote_streams()->count());
+  } else {
+    // Verify that the RtpTransceivers are still returned.
+    EXPECT_EQ(2u, pc_->GetTransceivers().size());
+  }
+
+  auto audio_receiver = GetFirstReceiverOfType(cricket::MEDIA_TYPE_AUDIO);
+  auto video_receiver = GetFirstReceiverOfType(cricket::MEDIA_TYPE_VIDEO);
+  if (sdp_semantics_ == SdpSemantics::kPlanB_DEPRECATED) {
+    ASSERT_TRUE(audio_receiver);
+    ASSERT_TRUE(video_receiver);
+    // Track state may be updated asynchronously.
+    EXPECT_EQ_WAIT(MediaStreamTrackInterface::kEnded,
+                   audio_receiver->track()->state(), kTimeout);
+    EXPECT_EQ_WAIT(MediaStreamTrackInterface::kEnded,
+                   video_receiver->track()->state(), kTimeout);
+  } else {
+    ASSERT_FALSE(audio_receiver);
+    ASSERT_FALSE(video_receiver);
+  }
+}
+
+// Test that PeerConnection methods fails gracefully after
+// PeerConnection::Close has been called.
+// Don't run under Unified Plan since the stream API is not available.
+TEST_F(PeerConnectionInterfaceTestPlanB, CloseAndTestMethods) {
+  CreatePeerConnectionWithoutDtls();
+  AddAudioVideoStream(kStreamId1, "audio_label", "video_label");
+  CreateOfferAsRemoteDescription();
+  CreateAnswerAsLocalDescription();
+
+  ASSERT_EQ(1u, pc_->local_streams()->count());
+  rtc::scoped_refptr<MediaStreamInterface> local_stream(
+      pc_->local_streams()->at(0));
+
+  pc_->Close();
+
+  pc_->RemoveStream(local_stream.get());
+  EXPECT_FALSE(pc_->AddStream(local_stream.get()));
+
+  EXPECT_FALSE(pc_->CreateDataChannelOrError("test", NULL).ok());
+
+  EXPECT_TRUE(pc_->local_description() != nullptr);
+  EXPECT_TRUE(pc_->remote_description() != nullptr);
+
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  EXPECT_FALSE(DoCreateOffer(&offer, nullptr));
+  std::unique_ptr<SessionDescriptionInterface> answer;
+  EXPECT_FALSE(DoCreateAnswer(&answer, nullptr));
+
+  std::string sdp;
+  ASSERT_TRUE(pc_->remote_description()->ToString(&sdp));
+  std::unique_ptr<SessionDescriptionInterface> remote_offer(
+      webrtc::CreateSessionDescription(SdpType::kOffer, sdp));
+  EXPECT_FALSE(DoSetRemoteDescription(std::move(remote_offer)));
+
+  ASSERT_TRUE(pc_->local_description()->ToString(&sdp));
+  std::unique_ptr<SessionDescriptionInterface> local_offer(
+      webrtc::CreateSessionDescription(SdpType::kOffer, sdp));
+  EXPECT_FALSE(DoSetLocalDescription(std::move(local_offer)));
+}
+
+// Test that GetStats can still be called after PeerConnection::Close.
+TEST_P(PeerConnectionInterfaceTest, CloseAndGetStats) {
+  InitiateCall();
+  pc_->Close();
+  DoGetStats(nullptr);
+}
+
+// NOTE: The series of tests below come from what used to be
+// mediastreamsignaling_unittest.cc, and are mostly aimed at testing that
+// setting a remote or local description has the expected effects.
+
+// This test verifies that the remote MediaStreams corresponding to a received
+// SDP string is created. In this test the two separate MediaStreams are
+// signaled.
+TEST_P(PeerConnectionInterfaceTest, UpdateRemoteStreams) {
+  RTCConfiguration config;
+  CreatePeerConnection(config);
+  CreateAndSetRemoteOffer(GetSdpStringWithStream1());
+
+  rtc::scoped_refptr<StreamCollection> reference(CreateStreamCollection(1, 1));
+  EXPECT_TRUE(
+      CompareStreamCollections(observer_.remote_streams(), reference.get()));
+  MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0);
+  EXPECT_TRUE(remote_stream->GetVideoTracks()[0]->GetSource() != nullptr);
+
+  // Create a session description based on another SDP with another
+  // MediaStream.
+  CreateAndSetRemoteOffer(GetSdpStringWithStream1And2());
+
+  rtc::scoped_refptr<StreamCollection> reference2(CreateStreamCollection(2, 1));
+  EXPECT_TRUE(
+      CompareStreamCollections(observer_.remote_streams(), reference2.get()));
+}
+
+// This test verifies that when remote tracks are added/removed from SDP, the
+// created remote streams are updated appropriately.
+// Don't run under Unified Plan since this test uses Plan B SDP to test Plan B
+// specific behavior.
+TEST_F(PeerConnectionInterfaceTestPlanB,
+       AddRemoveTrackFromExistingRemoteMediaStream) {
+  RTCConfiguration config;
+  CreatePeerConnection(config);
+  std::unique_ptr<SessionDescriptionInterface> desc_ms1 =
+      CreateSessionDescriptionAndReference(1, 1);
+  EXPECT_TRUE(DoSetRemoteDescription(std::move(desc_ms1)));
+  EXPECT_TRUE(CompareStreamCollections(observer_.remote_streams(),
+                                       reference_collection_.get()));
+
+  // Add extra audio and video tracks to the same MediaStream.
+  std::unique_ptr<SessionDescriptionInterface> desc_ms1_two_tracks =
+      CreateSessionDescriptionAndReference(2, 2);
+  EXPECT_TRUE(DoSetRemoteDescription(std::move(desc_ms1_two_tracks)));
+  EXPECT_TRUE(CompareStreamCollections(observer_.remote_streams(),
+                                       reference_collection_.get()));
+  rtc::scoped_refptr<AudioTrackInterface> audio_track2 =
+      observer_.remote_streams()->at(0)->GetAudioTracks()[1];
+  EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, audio_track2->state());
+  rtc::scoped_refptr<VideoTrackInterface> video_track2 =
+      observer_.remote_streams()->at(0)->GetVideoTracks()[1];
+  EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, video_track2->state());
+
+  // Remove the extra audio and video tracks.
+  std::unique_ptr<SessionDescriptionInterface> desc_ms2 =
+      CreateSessionDescriptionAndReference(1, 1);
+  MockTrackObserver audio_track_observer(audio_track2.get());
+  MockTrackObserver video_track_observer(video_track2.get());
+
+  EXPECT_CALL(audio_track_observer, OnChanged()).Times(Exactly(1));
+  EXPECT_CALL(video_track_observer, OnChanged()).Times(Exactly(1));
+  EXPECT_TRUE(DoSetRemoteDescription(std::move(desc_ms2)));
+  EXPECT_TRUE(CompareStreamCollections(observer_.remote_streams(),
+                                       reference_collection_.get()));
+  // Track state may be updated asynchronously.
+  EXPECT_EQ_WAIT(webrtc::MediaStreamTrackInterface::kEnded,
+                 audio_track2->state(), kTimeout);
+  EXPECT_EQ_WAIT(webrtc::MediaStreamTrackInterface::kEnded,
+                 video_track2->state(), kTimeout);
+}
+
+// This tests that remote tracks are ended if a local session description is set
+// that rejects the media content type.
+TEST_P(PeerConnectionInterfaceTest, RejectMediaContent) {
+  RTCConfiguration config;
+  CreatePeerConnection(config);
+  // First create and set a remote offer, then reject its video content in our
+  // answer.
+  CreateAndSetRemoteOffer(kSdpStringWithStream1PlanB);
+  auto audio_receiver = GetFirstReceiverOfType(cricket::MEDIA_TYPE_AUDIO);
+  ASSERT_TRUE(audio_receiver);
+  auto video_receiver = GetFirstReceiverOfType(cricket::MEDIA_TYPE_VIDEO);
+  ASSERT_TRUE(video_receiver);
+
+  rtc::scoped_refptr<MediaStreamTrackInterface> remote_audio =
+      audio_receiver->track();
+  EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, remote_audio->state());
+  rtc::scoped_refptr<MediaStreamTrackInterface> remote_video =
+      video_receiver->track();
+  EXPECT_EQ(MediaStreamTrackInterface::kLive, remote_video->state());
+
+  std::unique_ptr<SessionDescriptionInterface> local_answer;
+  EXPECT_TRUE(DoCreateAnswer(&local_answer, nullptr));
+  cricket::ContentInfo* video_info =
+      local_answer->description()->GetContentByName("video");
+  video_info->rejected = true;
+  EXPECT_TRUE(DoSetLocalDescription(std::move(local_answer)));
+  EXPECT_EQ(MediaStreamTrackInterface::kEnded, remote_video->state());
+  EXPECT_EQ(MediaStreamTrackInterface::kLive, remote_audio->state());
+
+  // Now create an offer where we reject both video and audio.
+  std::unique_ptr<SessionDescriptionInterface> local_offer;
+  EXPECT_TRUE(DoCreateOffer(&local_offer, nullptr));
+  video_info = local_offer->description()->GetContentByName("video");
+  ASSERT_TRUE(video_info != nullptr);
+  video_info->rejected = true;
+  cricket::ContentInfo* audio_info =
+      local_offer->description()->GetContentByName("audio");
+  ASSERT_TRUE(audio_info != nullptr);
+  audio_info->rejected = true;
+  EXPECT_TRUE(DoSetLocalDescription(std::move(local_offer)));
+  // Track state may be updated asynchronously.
+  EXPECT_EQ_WAIT(MediaStreamTrackInterface::kEnded, remote_audio->state(),
+                 kTimeout);
+  EXPECT_EQ_WAIT(MediaStreamTrackInterface::kEnded, remote_video->state(),
+                 kTimeout);
+}
+
+// This tests that we won't crash if the remote track has been removed outside
+// of PeerConnection and then PeerConnection tries to reject the track.
+// Don't run under Unified Plan since the stream API is not available.
+TEST_F(PeerConnectionInterfaceTestPlanB, RemoveTrackThenRejectMediaContent) {
+  RTCConfiguration config;
+  CreatePeerConnection(config);
+  CreateAndSetRemoteOffer(GetSdpStringWithStream1());
+  MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0);
+  remote_stream->RemoveTrack(remote_stream->GetVideoTracks()[0]);
+  remote_stream->RemoveTrack(remote_stream->GetAudioTracks()[0]);
+
+  std::unique_ptr<SessionDescriptionInterface> local_answer(
+      webrtc::CreateSessionDescription(SdpType::kAnswer,
+                                       GetSdpStringWithStream1(), nullptr));
+  cricket::ContentInfo* video_info =
+      local_answer->description()->GetContentByName("video");
+  video_info->rejected = true;
+  cricket::ContentInfo* audio_info =
+      local_answer->description()->GetContentByName("audio");
+  audio_info->rejected = true;
+  EXPECT_TRUE(DoSetLocalDescription(std::move(local_answer)));
+
+  // No crash is a pass.
+}
+
+// This tests that if a recvonly remote description is set, no remote streams
+// will be created, even if the description contains SSRCs/MSIDs.
+// See: https://code.google.com/p/webrtc/issues/detail?id=5054
+TEST_P(PeerConnectionInterfaceTest, RecvonlyDescriptionDoesntCreateStream) {
+  RTCConfiguration config;
+  CreatePeerConnection(config);
+
+  std::string recvonly_offer = GetSdpStringWithStream1();
+  absl::StrReplaceAll({{kSendrecv, kRecvonly}}, &recvonly_offer);
+  CreateAndSetRemoteOffer(recvonly_offer);
+
+  EXPECT_EQ(0u, observer_.remote_streams()->count());
+}
+
+// This tests that a default MediaStream is created if a remote session
+// description doesn't contain any streams and no MSID support.
+// It also tests that the default stream is updated if a video m-line is added
+// in a subsequent session description.
+// Don't run under Unified Plan since this behavior is Plan B specific.
+TEST_F(PeerConnectionInterfaceTestPlanB, SdpWithoutMsidCreatesDefaultStream) {
+  RTCConfiguration config;
+  CreatePeerConnection(config);
+  CreateAndSetRemoteOffer(kSdpStringWithoutStreamsAudioOnly);
+
+  ASSERT_EQ(1u, observer_.remote_streams()->count());
+  MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0);
+
+  EXPECT_EQ(1u, remote_stream->GetAudioTracks().size());
+  EXPECT_EQ(0u, remote_stream->GetVideoTracks().size());
+  EXPECT_EQ("default", remote_stream->id());
+
+  CreateAndSetRemoteOffer(kSdpStringWithoutStreams);
+  ASSERT_EQ(1u, observer_.remote_streams()->count());
+  ASSERT_EQ(1u, remote_stream->GetAudioTracks().size());
+  EXPECT_EQ("defaulta0", remote_stream->GetAudioTracks()[0]->id());
+  EXPECT_EQ(MediaStreamTrackInterface::kLive,
+            remote_stream->GetAudioTracks()[0]->state());
+  ASSERT_EQ(1u, remote_stream->GetVideoTracks().size());
+  EXPECT_EQ("defaultv0", remote_stream->GetVideoTracks()[0]->id());
+  EXPECT_EQ(MediaStreamTrackInterface::kLive,
+            remote_stream->GetVideoTracks()[0]->state());
+}
+
+// This tests that a default MediaStream is created if a remote session
+// description doesn't contain any streams and media direction is send only.
+// Don't run under Unified Plan since this behavior is Plan B specific.
+TEST_F(PeerConnectionInterfaceTestPlanB,
+       SendOnlySdpWithoutMsidCreatesDefaultStream) {
+  RTCConfiguration config;
+  CreatePeerConnection(config);
+  CreateAndSetRemoteOffer(kSdpStringSendOnlyWithoutStreams);
+
+  ASSERT_EQ(1u, observer_.remote_streams()->count());
+  MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0);
+
+  EXPECT_EQ(1u, remote_stream->GetAudioTracks().size());
+  EXPECT_EQ(1u, remote_stream->GetVideoTracks().size());
+  EXPECT_EQ("default", remote_stream->id());
+}
+
+// This tests that it won't crash when PeerConnection tries to remove
+// a remote track that as already been removed from the MediaStream.
+// Don't run under Unified Plan since this behavior is Plan B specific.
+TEST_F(PeerConnectionInterfaceTestPlanB, RemoveAlreadyGoneRemoteStream) {
+  RTCConfiguration config;
+  CreatePeerConnection(config);
+  CreateAndSetRemoteOffer(GetSdpStringWithStream1());
+  MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0);
+  remote_stream->RemoveTrack(remote_stream->GetAudioTracks()[0]);
+  remote_stream->RemoveTrack(remote_stream->GetVideoTracks()[0]);
+
+  CreateAndSetRemoteOffer(kSdpStringWithoutStreams);
+
+  // No crash is a pass.
+}
+
+// This tests that a default MediaStream is created if the remote session
+// description doesn't contain any streams and don't contain an indication if
+// MSID is supported.
+// Don't run under Unified Plan since this behavior is Plan B specific.
+TEST_F(PeerConnectionInterfaceTestPlanB,
+       SdpWithoutMsidAndStreamsCreatesDefaultStream) {
+  RTCConfiguration config;
+  CreatePeerConnection(config);
+  CreateAndSetRemoteOffer(kSdpStringWithoutStreams);
+
+  ASSERT_EQ(1u, observer_.remote_streams()->count());
+  MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0);
+  EXPECT_EQ(1u, remote_stream->GetAudioTracks().size());
+  EXPECT_EQ(1u, remote_stream->GetVideoTracks().size());
+}
+
+// This tests that a default MediaStream is not created if the remote session
+// description doesn't contain any streams but does support MSID.
+// Don't run under Unified Plan since this behavior is Plan B specific.
+TEST_F(PeerConnectionInterfaceTestPlanB, SdpWithMsidDontCreatesDefaultStream) {
+  RTCConfiguration config;
+  CreatePeerConnection(config);
+  CreateAndSetRemoteOffer(kSdpStringWithMsidWithoutStreams);
+  EXPECT_EQ(0u, observer_.remote_streams()->count());
+}
+
+// This tests that when setting a new description, the old default tracks are
+// not destroyed and recreated.
+// See: https://bugs.chromium.org/p/webrtc/issues/detail?id=5250
+// Don't run under Unified Plan since this behavior is Plan B specific.
+TEST_F(PeerConnectionInterfaceTestPlanB,
+       DefaultTracksNotDestroyedAndRecreated) {
+  RTCConfiguration config;
+  CreatePeerConnection(config);
+  CreateAndSetRemoteOffer(kSdpStringWithoutStreamsAudioOnly);
+
+  ASSERT_EQ(1u, observer_.remote_streams()->count());
+  MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0);
+  ASSERT_EQ(1u, remote_stream->GetAudioTracks().size());
+
+  // Set the track to "disabled", then set a new description and ensure the
+  // track is still disabled, which ensures it hasn't been recreated.
+  remote_stream->GetAudioTracks()[0]->set_enabled(false);
+  CreateAndSetRemoteOffer(kSdpStringWithoutStreamsAudioOnly);
+  ASSERT_EQ(1u, remote_stream->GetAudioTracks().size());
+  EXPECT_FALSE(remote_stream->GetAudioTracks()[0]->enabled());
+}
+
+// This tests that a default MediaStream is not created if a remote session
+// description is updated to not have any MediaStreams.
+// Don't run under Unified Plan since this behavior is Plan B specific.
+TEST_F(PeerConnectionInterfaceTestPlanB, VerifyDefaultStreamIsNotCreated) {
+  RTCConfiguration config;
+  CreatePeerConnection(config);
+  CreateAndSetRemoteOffer(GetSdpStringWithStream1());
+  rtc::scoped_refptr<StreamCollection> reference(CreateStreamCollection(1, 1));
+  EXPECT_TRUE(
+      CompareStreamCollections(observer_.remote_streams(), reference.get()));
+
+  CreateAndSetRemoteOffer(kSdpStringWithoutStreams);
+  EXPECT_EQ(0u, observer_.remote_streams()->count());
+}
+
+// This tests that a default MediaStream is created if a remote SDP comes from
+// an endpoint that doesn't signal SSRCs, but signals media stream IDs.
+TEST_F(PeerConnectionInterfaceTestPlanB,
+       SdpWithMsidWithoutSsrcCreatesDefaultStream) {
+  RTCConfiguration config;
+  CreatePeerConnection(config);
+  std::string sdp_string = kSdpStringWithoutStreamsAudioOnly;
+  // Add a=msid lines to simulate a Unified Plan endpoint that only
+  // signals stream IDs with a=msid lines.
+  sdp_string.append("a=msid:audio_stream_id audio_track_id\n");
+
+  CreateAndSetRemoteOffer(sdp_string);
+
+  ASSERT_EQ(1u, observer_.remote_streams()->count());
+  MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0);
+  EXPECT_EQ("default", remote_stream->id());
+  ASSERT_EQ(1u, remote_stream->GetAudioTracks().size());
+}
+
+// This tests that when a Plan B endpoint receives an SDP that signals no media
+// stream IDs indicated by the special character "-" in the a=msid line, that
+// a default stream ID will be used for the MediaStream ID. This can occur
+// when a Unified Plan endpoint signals no media stream IDs, but signals both
+// a=ssrc msid and a=msid lines for interop signaling with Plan B.
+TEST_F(PeerConnectionInterfaceTestPlanB,
+       SdpWithEmptyMsidAndSsrcCreatesDefaultStreamId) {
+  RTCConfiguration config;
+  CreatePeerConnection(config);
+  // Add a a=msid line to the SDP. This is prioritized when parsing the SDP, so
+  // the sender's stream ID will be interpreted as no stream IDs.
+  std::string sdp_string = kSdpStringWithStream1AudioTrackOnly;
+  sdp_string.append("a=msid:- audiotrack0\n");
+
+  CreateAndSetRemoteOffer(sdp_string);
+
+  ASSERT_EQ(1u, observer_.remote_streams()->count());
+  // Because SSRCs are signaled the track ID will be what was signaled in the
+  // a=msid line.
+  EXPECT_EQ("audiotrack0", observer_.last_added_track_label_);
+  MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0);
+  EXPECT_EQ("default", remote_stream->id());
+  ASSERT_EQ(1u, remote_stream->GetAudioTracks().size());
+
+  // Previously a bug ocurred when setting the remote description a second time.
+  // This is because we checked equality of the remote StreamParams stream ID
+  // (empty), and the previously set stream ID for the remote sender
+  // ("default"). This cause a track to be removed, then added, when really
+  // nothing should occur because it is the same track.
+  CreateAndSetRemoteOffer(sdp_string);
+  EXPECT_EQ(0u, observer_.remove_track_events_.size());
+  EXPECT_EQ(1u, observer_.add_track_events_.size());
+  EXPECT_EQ("audiotrack0", observer_.last_added_track_label_);
+  remote_stream = observer_.remote_streams()->at(0);
+  EXPECT_EQ("default", remote_stream->id());
+  ASSERT_EQ(1u, remote_stream->GetAudioTracks().size());
+}
+
+// This tests that an RtpSender is created when the local description is set
+// after adding a local stream.
+// TODO(deadbeef): This test and the one below it need to be updated when
+// an RtpSender's lifetime isn't determined by when a local description is set.
+// Don't run under Unified Plan since this behavior is Plan B specific.
+TEST_F(PeerConnectionInterfaceTestPlanB, LocalDescriptionChanged) {
+  RTCConfiguration config;
+  CreatePeerConnection(config);
+
+  // Create an offer with 1 stream with 2 tracks of each type.
+  rtc::scoped_refptr<StreamCollection> stream_collection =
+      CreateStreamCollection(1, 2);
+  pc_->AddStream(stream_collection->at(0));
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+  EXPECT_TRUE(DoSetLocalDescription(std::move(offer)));
+
+  auto senders = pc_->GetSenders();
+  EXPECT_EQ(4u, senders.size());
+  EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0]));
+  EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0]));
+  EXPECT_TRUE(ContainsSender(senders, kAudioTracks[1]));
+  EXPECT_TRUE(ContainsSender(senders, kVideoTracks[1]));
+
+  // Remove an audio and video track.
+  pc_->RemoveStream(stream_collection->at(0));
+  stream_collection = CreateStreamCollection(1, 1);
+  pc_->AddStream(stream_collection->at(0));
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+  EXPECT_TRUE(DoSetLocalDescription(std::move(offer)));
+
+  senders = pc_->GetSenders();
+  EXPECT_EQ(2u, senders.size());
+  EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0]));
+  EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0]));
+  EXPECT_FALSE(ContainsSender(senders, kAudioTracks[1]));
+  EXPECT_FALSE(ContainsSender(senders, kVideoTracks[1]));
+}
+
+// This tests that an RtpSender is created when the local description is set
+// before adding a local stream.
+// Don't run under Unified Plan since this behavior is Plan B specific.
+TEST_F(PeerConnectionInterfaceTestPlanB,
+       AddLocalStreamAfterLocalDescriptionChanged) {
+  RTCConfiguration config;
+  CreatePeerConnection(config);
+
+  rtc::scoped_refptr<StreamCollection> stream_collection =
+      CreateStreamCollection(1, 2);
+  // Add a stream to create the offer, but remove it afterwards.
+  pc_->AddStream(stream_collection->at(0));
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+  pc_->RemoveStream(stream_collection->at(0));
+
+  EXPECT_TRUE(DoSetLocalDescription(std::move(offer)));
+  auto senders = pc_->GetSenders();
+  EXPECT_EQ(0u, senders.size());
+
+  pc_->AddStream(stream_collection->at(0));
+  senders = pc_->GetSenders();
+  EXPECT_EQ(4u, senders.size());
+  EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0]));
+  EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0]));
+  EXPECT_TRUE(ContainsSender(senders, kAudioTracks[1]));
+  EXPECT_TRUE(ContainsSender(senders, kVideoTracks[1]));
+}
+
+// This tests that the expected behavior occurs if the SSRC on a local track is
+// changed when SetLocalDescription is called.
+TEST_P(PeerConnectionInterfaceTest,
+       ChangeSsrcOnTrackInLocalSessionDescription) {
+  RTCConfiguration config;
+  CreatePeerConnection(config);
+
+  AddAudioTrack(kAudioTracks[0]);
+  AddVideoTrack(kVideoTracks[0]);
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+  // Grab a copy of the offer before it gets passed into the PC.
+  std::unique_ptr<SessionDescriptionInterface> modified_offer =
+      webrtc::CreateSessionDescription(
+          webrtc::SdpType::kOffer, offer->session_id(),
+          offer->session_version(), offer->description()->Clone());
+  EXPECT_TRUE(DoSetLocalDescription(std::move(offer)));
+
+  auto senders = pc_->GetSenders();
+  EXPECT_EQ(2u, senders.size());
+  EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0]));
+  EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0]));
+
+  // Change the ssrc of the audio and video track.
+  cricket::MediaContentDescription* desc =
+      cricket::GetFirstAudioContentDescription(modified_offer->description());
+  ASSERT_TRUE(desc != nullptr);
+  for (StreamParams& stream : desc->mutable_streams()) {
+    for (unsigned int& ssrc : stream.ssrcs) {
+      ++ssrc;
+    }
+  }
+
+  desc =
+      cricket::GetFirstVideoContentDescription(modified_offer->description());
+  ASSERT_TRUE(desc != nullptr);
+  for (StreamParams& stream : desc->mutable_streams()) {
+    for (unsigned int& ssrc : stream.ssrcs) {
+      ++ssrc;
+    }
+  }
+
+  EXPECT_TRUE(DoSetLocalDescription(std::move(modified_offer)));
+  senders = pc_->GetSenders();
+  EXPECT_EQ(2u, senders.size());
+  EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0]));
+  EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0]));
+  // TODO(deadbeef): Once RtpSenders expose parameters, check that the SSRC
+  // changed.
+}
+
+// This tests that the expected behavior occurs if a new session description is
+// set with the same tracks, but on a different MediaStream.
+// Don't run under Unified Plan since the stream API is not available.
+TEST_F(PeerConnectionInterfaceTestPlanB,
+       SignalSameTracksInSeparateMediaStream) {
+  RTCConfiguration config;
+  CreatePeerConnection(config);
+
+  rtc::scoped_refptr<StreamCollection> stream_collection =
+      CreateStreamCollection(2, 1);
+  pc_->AddStream(stream_collection->at(0));
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+  EXPECT_TRUE(DoSetLocalDescription(std::move(offer)));
+
+  auto senders = pc_->GetSenders();
+  EXPECT_EQ(2u, senders.size());
+  EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0], kStreams[0]));
+  EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0], kStreams[0]));
+
+  // Add a new MediaStream but with the same tracks as in the first stream.
+  rtc::scoped_refptr<webrtc::MediaStreamInterface> stream_1(
+      webrtc::MediaStream::Create(kStreams[1]));
+  stream_1->AddTrack(stream_collection->at(0)->GetVideoTracks()[0]);
+  stream_1->AddTrack(stream_collection->at(0)->GetAudioTracks()[0]);
+  pc_->AddStream(stream_1.get());
+
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+  EXPECT_TRUE(DoSetLocalDescription(std::move(offer)));
+
+  auto new_senders = pc_->GetSenders();
+  // Should be the same senders as before, but with updated stream id.
+  // Note that this behavior is subject to change in the future.
+  // We may decide the PC should ignore existing tracks in AddStream.
+  EXPECT_EQ(senders, new_senders);
+  EXPECT_TRUE(ContainsSender(new_senders, kAudioTracks[0], kStreams[1]));
+  EXPECT_TRUE(ContainsSender(new_senders, kVideoTracks[0], kStreams[1]));
+}
+
+// This tests that PeerConnectionObserver::OnAddTrack is correctly called.
+TEST_P(PeerConnectionInterfaceTest, OnAddTrackCallback) {
+  RTCConfiguration config;
+  CreatePeerConnection(config);
+  CreateAndSetRemoteOffer(kSdpStringWithStream1AudioTrackOnly);
+  EXPECT_EQ(observer_.num_added_tracks_, 1);
+  EXPECT_EQ(observer_.last_added_track_label_, kAudioTracks[0]);
+
+  // Create and set the updated remote SDP.
+  CreateAndSetRemoteOffer(kSdpStringWithStream1PlanB);
+  EXPECT_EQ(observer_.num_added_tracks_, 2);
+  EXPECT_EQ(observer_.last_added_track_label_, kVideoTracks[0]);
+}
+
+// Test that when SetConfiguration is called and the configuration is
+// changing, the next offer causes an ICE restart.
+TEST_P(PeerConnectionInterfaceTest, SetConfigurationCausingIceRestart) {
+  PeerConnectionInterface::RTCConfiguration config;
+  config.sdp_semantics = sdp_semantics_;
+  config.type = PeerConnectionInterface::kRelay;
+  CreatePeerConnection(config);
+  config = pc_->GetConfiguration();
+  AddAudioTrack(kAudioTracks[0], {kStreamId1});
+  AddVideoTrack(kVideoTracks[0], {kStreamId1});
+
+  // Do initial offer/answer so there's something to restart.
+  CreateOfferAsLocalDescription();
+  CreateAnswerAsRemoteDescription(GetSdpStringWithStream1());
+
+  // Grab the ufrags.
+  std::vector<std::string> initial_ufrags = GetUfrags(pc_->local_description());
+
+  // Change ICE policy, which should trigger an ICE restart on the next offer.
+  config.type = PeerConnectionInterface::kAll;
+  EXPECT_TRUE(pc_->SetConfiguration(config).ok());
+  CreateOfferAsLocalDescription();
+
+  // Grab the new ufrags.
+  std::vector<std::string> subsequent_ufrags =
+      GetUfrags(pc_->local_description());
+
+  // Sanity check.
+  EXPECT_EQ(initial_ufrags.size(), subsequent_ufrags.size());
+  // Check that each ufrag is different.
+  for (int i = 0; i < static_cast<int>(initial_ufrags.size()); ++i) {
+    EXPECT_NE(initial_ufrags[i], subsequent_ufrags[i]);
+  }
+}
+
+// Test that when SetConfiguration is called and the configuration *isn't*
+// changing, the next offer does *not* cause an ICE restart.
+TEST_P(PeerConnectionInterfaceTest, SetConfigurationNotCausingIceRestart) {
+  PeerConnectionInterface::RTCConfiguration config;
+  config.sdp_semantics = sdp_semantics_;
+  config.type = PeerConnectionInterface::kRelay;
+  CreatePeerConnection(config);
+  config = pc_->GetConfiguration();
+  AddAudioTrack(kAudioTracks[0]);
+  AddVideoTrack(kVideoTracks[0]);
+
+  // Do initial offer/answer so there's something to restart.
+  CreateOfferAsLocalDescription();
+  CreateAnswerAsRemoteDescription(GetSdpStringWithStream1());
+
+  // Grab the ufrags.
+  std::vector<std::string> initial_ufrags = GetUfrags(pc_->local_description());
+
+  // Call SetConfiguration with a config identical to what the PC was
+  // constructed with.
+  EXPECT_TRUE(pc_->SetConfiguration(config).ok());
+  CreateOfferAsLocalDescription();
+
+  // Grab the new ufrags.
+  std::vector<std::string> subsequent_ufrags =
+      GetUfrags(pc_->local_description());
+
+  EXPECT_EQ(initial_ufrags, subsequent_ufrags);
+}
+
+// Test for a weird corner case scenario:
+// 1. Audio/video session established.
+// 2. SetConfiguration changes ICE config; ICE restart needed.
+// 3. ICE restart initiated by remote peer, but only for one m= section.
+// 4. Next createOffer should initiate an ICE restart, but only for the other
+//    m= section; it would be pointless to do an ICE restart for the m= section
+//    that was already restarted.
+TEST_P(PeerConnectionInterfaceTest, SetConfigurationCausingPartialIceRestart) {
+  PeerConnectionInterface::RTCConfiguration config;
+  config.sdp_semantics = sdp_semantics_;
+  config.type = PeerConnectionInterface::kRelay;
+  CreatePeerConnection(config);
+  config = pc_->GetConfiguration();
+  AddAudioTrack(kAudioTracks[0], {kStreamId1});
+  AddVideoTrack(kVideoTracks[0], {kStreamId1});
+
+  // Do initial offer/answer so there's something to restart.
+  CreateOfferAsLocalDescription();
+  CreateAnswerAsRemoteDescription(GetSdpStringWithStream1());
+
+  // Change ICE policy, which should set the "needs-ice-restart" flag.
+  config.type = PeerConnectionInterface::kAll;
+  EXPECT_TRUE(pc_->SetConfiguration(config).ok());
+
+  // Do ICE restart for the first m= section, initiated by remote peer.
+  std::unique_ptr<webrtc::SessionDescriptionInterface> remote_offer(
+      webrtc::CreateSessionDescription(SdpType::kOffer,
+                                       GetSdpStringWithStream1(), nullptr));
+  ASSERT_TRUE(remote_offer);
+  remote_offer->description()->transport_infos()[0].description.ice_ufrag =
+      "modified";
+  EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_offer)));
+  CreateAnswerAsLocalDescription();
+
+  // Grab the ufrags.
+  std::vector<std::string> initial_ufrags = GetUfrags(pc_->local_description());
+  ASSERT_EQ(2U, initial_ufrags.size());
+
+  // Create offer and grab the new ufrags.
+  CreateOfferAsLocalDescription();
+  std::vector<std::string> subsequent_ufrags =
+      GetUfrags(pc_->local_description());
+  ASSERT_EQ(2U, subsequent_ufrags.size());
+
+  // Ensure that only the ufrag for the second m= section changed.
+  EXPECT_EQ(initial_ufrags[0], subsequent_ufrags[0]);
+  EXPECT_NE(initial_ufrags[1], subsequent_ufrags[1]);
+}
+
+// Tests that the methods to return current/pending descriptions work as
+// expected at different points in the offer/answer exchange. This test does
+// one offer/answer exchange as the offerer, then another as the answerer.
+TEST_P(PeerConnectionInterfaceTest, CurrentAndPendingDescriptions) {
+  // This disables DTLS so we can apply an answer to ourselves.
+  CreatePeerConnection();
+
+  // Create initial local offer and get SDP (which will also be used as
+  // answer/pranswer);
+  std::unique_ptr<SessionDescriptionInterface> local_offer;
+  ASSERT_TRUE(DoCreateOffer(&local_offer, nullptr));
+  std::string sdp;
+  EXPECT_TRUE(local_offer->ToString(&sdp));
+
+  // Set local offer.
+  SessionDescriptionInterface* local_offer_ptr = local_offer.get();
+  EXPECT_TRUE(DoSetLocalDescription(std::move(local_offer)));
+  EXPECT_EQ(local_offer_ptr, pc_->pending_local_description());
+  EXPECT_EQ(nullptr, pc_->pending_remote_description());
+  EXPECT_EQ(nullptr, pc_->current_local_description());
+  EXPECT_EQ(nullptr, pc_->current_remote_description());
+
+  // Set remote pranswer.
+  std::unique_ptr<SessionDescriptionInterface> remote_pranswer(
+      webrtc::CreateSessionDescription(SdpType::kPrAnswer, sdp));
+  SessionDescriptionInterface* remote_pranswer_ptr = remote_pranswer.get();
+  EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_pranswer)));
+  EXPECT_EQ(local_offer_ptr, pc_->pending_local_description());
+  EXPECT_EQ(remote_pranswer_ptr, pc_->pending_remote_description());
+  EXPECT_EQ(nullptr, pc_->current_local_description());
+  EXPECT_EQ(nullptr, pc_->current_remote_description());
+
+  // Set remote answer.
+  std::unique_ptr<SessionDescriptionInterface> remote_answer(
+      webrtc::CreateSessionDescription(SdpType::kAnswer, sdp));
+  SessionDescriptionInterface* remote_answer_ptr = remote_answer.get();
+  EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_answer)));
+  EXPECT_EQ(nullptr, pc_->pending_local_description());
+  EXPECT_EQ(nullptr, pc_->pending_remote_description());
+  EXPECT_EQ(local_offer_ptr, pc_->current_local_description());
+  EXPECT_EQ(remote_answer_ptr, pc_->current_remote_description());
+
+  // Set remote offer.
+  std::unique_ptr<SessionDescriptionInterface> remote_offer(
+      webrtc::CreateSessionDescription(SdpType::kOffer, sdp));
+  SessionDescriptionInterface* remote_offer_ptr = remote_offer.get();
+  EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_offer)));
+  EXPECT_EQ(remote_offer_ptr, pc_->pending_remote_description());
+  EXPECT_EQ(nullptr, pc_->pending_local_description());
+  EXPECT_EQ(local_offer_ptr, pc_->current_local_description());
+  EXPECT_EQ(remote_answer_ptr, pc_->current_remote_description());
+
+  // Set local pranswer.
+  std::unique_ptr<SessionDescriptionInterface> local_pranswer(
+      webrtc::CreateSessionDescription(SdpType::kPrAnswer, sdp));
+  SessionDescriptionInterface* local_pranswer_ptr = local_pranswer.get();
+  EXPECT_TRUE(DoSetLocalDescription(std::move(local_pranswer)));
+  EXPECT_EQ(remote_offer_ptr, pc_->pending_remote_description());
+  EXPECT_EQ(local_pranswer_ptr, pc_->pending_local_description());
+  EXPECT_EQ(local_offer_ptr, pc_->current_local_description());
+  EXPECT_EQ(remote_answer_ptr, pc_->current_remote_description());
+
+  // Set local answer.
+  std::unique_ptr<SessionDescriptionInterface> local_answer(
+      webrtc::CreateSessionDescription(SdpType::kAnswer, sdp));
+  SessionDescriptionInterface* local_answer_ptr = local_answer.get();
+  EXPECT_TRUE(DoSetLocalDescription(std::move(local_answer)));
+  EXPECT_EQ(nullptr, pc_->pending_remote_description());
+  EXPECT_EQ(nullptr, pc_->pending_local_description());
+  EXPECT_EQ(remote_offer_ptr, pc_->current_remote_description());
+  EXPECT_EQ(local_answer_ptr, pc_->current_local_description());
+}
+
+// Tests that it won't crash when calling StartRtcEventLog or StopRtcEventLog
+// after the PeerConnection is closed.
+// This version tests the StartRtcEventLog version that receives an object
+// of type `RtcEventLogOutput`.
+TEST_P(PeerConnectionInterfaceTest,
+       StartAndStopLoggingToOutputAfterPeerConnectionClosed) {
+  CreatePeerConnection();
+  // The RtcEventLog will be reset when the PeerConnection is closed.
+  pc_->Close();
+
+  EXPECT_FALSE(
+      pc_->StartRtcEventLog(std::make_unique<webrtc::RtcEventLogOutputNull>(),
+                            webrtc::RtcEventLog::kImmediateOutput));
+  pc_->StopRtcEventLog();
+}
+
+// Test that generated offers/answers include "ice-option:trickle".
+TEST_P(PeerConnectionInterfaceTest, OffersAndAnswersHaveTrickleIceOption) {
+  CreatePeerConnection();
+
+  // First, create an offer with audio/video.
+  RTCOfferAnswerOptions options;
+  options.offer_to_receive_audio = 1;
+  options.offer_to_receive_video = 1;
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  ASSERT_TRUE(DoCreateOffer(&offer, &options));
+  cricket::SessionDescription* desc = offer->description();
+  ASSERT_EQ(2u, desc->transport_infos().size());
+  EXPECT_TRUE(desc->transport_infos()[0].description.HasOption("trickle"));
+  EXPECT_TRUE(desc->transport_infos()[1].description.HasOption("trickle"));
+
+  // Apply the offer as a remote description, then create an answer.
+  EXPECT_FALSE(pc_->can_trickle_ice_candidates());
+  EXPECT_TRUE(DoSetRemoteDescription(std::move(offer)));
+  ASSERT_TRUE(pc_->can_trickle_ice_candidates());
+  EXPECT_TRUE(*(pc_->can_trickle_ice_candidates()));
+  std::unique_ptr<SessionDescriptionInterface> answer;
+  ASSERT_TRUE(DoCreateAnswer(&answer, &options));
+  desc = answer->description();
+  ASSERT_EQ(2u, desc->transport_infos().size());
+  EXPECT_TRUE(desc->transport_infos()[0].description.HasOption("trickle"));
+  EXPECT_TRUE(desc->transport_infos()[1].description.HasOption("trickle"));
+}
+
+// Test that ICE renomination isn't offered if it's not enabled in the PC's
+// RTCConfiguration.
+TEST_P(PeerConnectionInterfaceTest, IceRenominationNotOffered) {
+  PeerConnectionInterface::RTCConfiguration config;
+  config.sdp_semantics = sdp_semantics_;
+  config.enable_ice_renomination = false;
+  CreatePeerConnection(config);
+  AddAudioTrack("foo");
+
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+  cricket::SessionDescription* desc = offer->description();
+  EXPECT_EQ(1u, desc->transport_infos().size());
+  EXPECT_FALSE(
+      desc->transport_infos()[0].description.GetIceParameters().renomination);
+}
+
+// Test that the ICE renomination option is present in generated offers/answers
+// if it's enabled in the PC's RTCConfiguration.
+TEST_P(PeerConnectionInterfaceTest, IceRenominationOptionInOfferAndAnswer) {
+  PeerConnectionInterface::RTCConfiguration config;
+  config.sdp_semantics = sdp_semantics_;
+  config.enable_ice_renomination = true;
+  CreatePeerConnection(config);
+  AddAudioTrack("foo");
+
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+  cricket::SessionDescription* desc = offer->description();
+  EXPECT_EQ(1u, desc->transport_infos().size());
+  EXPECT_TRUE(
+      desc->transport_infos()[0].description.GetIceParameters().renomination);
+
+  // Set the offer as a remote description, then create an answer and ensure it
+  // has the renomination flag too.
+  EXPECT_TRUE(DoSetRemoteDescription(std::move(offer)));
+  std::unique_ptr<SessionDescriptionInterface> answer;
+  ASSERT_TRUE(DoCreateAnswer(&answer, nullptr));
+  desc = answer->description();
+  EXPECT_EQ(1u, desc->transport_infos().size());
+  EXPECT_TRUE(
+      desc->transport_infos()[0].description.GetIceParameters().renomination);
+}
+
+// Test that if CreateOffer is called with the deprecated "offer to receive
+// audio/video" constraints, they're processed and result in an offer with
+// audio/video sections just as if RTCOfferAnswerOptions had been used.
+TEST_P(PeerConnectionInterfaceTest, CreateOfferWithOfferToReceiveConstraints) {
+  CreatePeerConnection();
+
+  RTCOfferAnswerOptions options;
+  options.offer_to_receive_audio = 1;
+  options.offer_to_receive_video = 1;
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  ASSERT_TRUE(DoCreateOffer(&offer, &options));
+
+  cricket::SessionDescription* desc = offer->description();
+  const cricket::ContentInfo* audio = cricket::GetFirstAudioContent(desc);
+  const cricket::ContentInfo* video = cricket::GetFirstVideoContent(desc);
+  ASSERT_NE(nullptr, audio);
+  ASSERT_NE(nullptr, video);
+  EXPECT_FALSE(audio->rejected);
+  EXPECT_FALSE(video->rejected);
+}
+
+// Test that if CreateAnswer is called with the deprecated "offer to receive
+// audio/video" constraints, they're processed and can be used to reject an
+// offered m= section just as can be done with RTCOfferAnswerOptions;
+// Don't run under Unified Plan since this behavior is not supported.
+TEST_F(PeerConnectionInterfaceTestPlanB,
+       CreateAnswerWithOfferToReceiveConstraints) {
+  CreatePeerConnection();
+
+  // First, create an offer with audio/video and apply it as a remote
+  // description.
+  RTCOfferAnswerOptions options;
+  options.offer_to_receive_audio = 1;
+  options.offer_to_receive_video = 1;
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  ASSERT_TRUE(DoCreateOffer(&offer, &options));
+  EXPECT_TRUE(DoSetRemoteDescription(std::move(offer)));
+
+  // Now create answer that rejects audio/video.
+  options.offer_to_receive_audio = 0;
+  options.offer_to_receive_video = 0;
+  std::unique_ptr<SessionDescriptionInterface> answer;
+  ASSERT_TRUE(DoCreateAnswer(&answer, &options));
+
+  cricket::SessionDescription* desc = answer->description();
+  const cricket::ContentInfo* audio = cricket::GetFirstAudioContent(desc);
+  const cricket::ContentInfo* video = cricket::GetFirstVideoContent(desc);
+  ASSERT_NE(nullptr, audio);
+  ASSERT_NE(nullptr, video);
+  EXPECT_TRUE(audio->rejected);
+  EXPECT_TRUE(video->rejected);
+}
+
+// Test that negotiation can succeed with a data channel only, and with the max
+// bundle policy. Previously there was a bug that prevented this.
+#ifdef WEBRTC_HAVE_SCTP
+TEST_P(PeerConnectionInterfaceTest, DataChannelOnlyOfferWithMaxBundlePolicy) {
+#else
+TEST_P(PeerConnectionInterfaceTest,
+       DISABLED_DataChannelOnlyOfferWithMaxBundlePolicy) {
+#endif  // WEBRTC_HAVE_SCTP
+  PeerConnectionInterface::RTCConfiguration config;
+  config.sdp_semantics = sdp_semantics_;
+  config.bundle_policy = PeerConnectionInterface::kBundlePolicyMaxBundle;
+  CreatePeerConnection(config);
+
+  // First, create an offer with only a data channel and apply it as a remote
+  // description.
+  pc_->CreateDataChannelOrError("test", nullptr);
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+  EXPECT_TRUE(DoSetRemoteDescription(std::move(offer)));
+
+  // Create and set answer as well.
+  std::unique_ptr<SessionDescriptionInterface> answer;
+  ASSERT_TRUE(DoCreateAnswer(&answer, nullptr));
+  EXPECT_TRUE(DoSetLocalDescription(std::move(answer)));
+}
+
+TEST_P(PeerConnectionInterfaceTest, SetBitrateWithoutMinSucceeds) {
+  CreatePeerConnection();
+  BitrateSettings bitrate;
+  bitrate.start_bitrate_bps = 100000;
+  EXPECT_TRUE(pc_->SetBitrate(bitrate).ok());
+}
+
+TEST_P(PeerConnectionInterfaceTest, SetBitrateNegativeMinFails) {
+  CreatePeerConnection();
+  BitrateSettings bitrate;
+  bitrate.min_bitrate_bps = -1;
+  EXPECT_FALSE(pc_->SetBitrate(bitrate).ok());
+}
+
+TEST_P(PeerConnectionInterfaceTest, SetBitrateCurrentLessThanMinFails) {
+  CreatePeerConnection();
+  BitrateSettings bitrate;
+  bitrate.min_bitrate_bps = 5;
+  bitrate.start_bitrate_bps = 3;
+  EXPECT_FALSE(pc_->SetBitrate(bitrate).ok());
+}
+
+TEST_P(PeerConnectionInterfaceTest, SetBitrateCurrentNegativeFails) {
+  CreatePeerConnection();
+  BitrateSettings bitrate;
+  bitrate.start_bitrate_bps = -1;
+  EXPECT_FALSE(pc_->SetBitrate(bitrate).ok());
+}
+
+TEST_P(PeerConnectionInterfaceTest, SetBitrateMaxLessThanCurrentFails) {
+  CreatePeerConnection();
+  BitrateSettings bitrate;
+  bitrate.start_bitrate_bps = 10;
+  bitrate.max_bitrate_bps = 8;
+  EXPECT_FALSE(pc_->SetBitrate(bitrate).ok());
+}
+
+TEST_P(PeerConnectionInterfaceTest, SetBitrateMaxLessThanMinFails) {
+  CreatePeerConnection();
+  BitrateSettings bitrate;
+  bitrate.min_bitrate_bps = 10;
+  bitrate.max_bitrate_bps = 8;
+  EXPECT_FALSE(pc_->SetBitrate(bitrate).ok());
+}
+
+TEST_P(PeerConnectionInterfaceTest, SetBitrateMaxNegativeFails) {
+  CreatePeerConnection();
+  BitrateSettings bitrate;
+  bitrate.max_bitrate_bps = -1;
+  EXPECT_FALSE(pc_->SetBitrate(bitrate).ok());
+}
+
+// The current bitrate from BitrateSettings is currently clamped
+// by Call's BitrateConstraints, which comes from the SDP or a default value.
+// This test checks that a call to SetBitrate with a current bitrate that will
+// be clamped succeeds.
+TEST_P(PeerConnectionInterfaceTest, SetBitrateCurrentLessThanImplicitMin) {
+  CreatePeerConnection();
+  BitrateSettings bitrate;
+  bitrate.start_bitrate_bps = 1;
+  EXPECT_TRUE(pc_->SetBitrate(bitrate).ok());
+}
+
+// The following tests verify that the offer can be created correctly.
+TEST_P(PeerConnectionInterfaceTest,
+       CreateOfferFailsWithInvalidOfferToReceiveAudio) {
+  RTCOfferAnswerOptions rtc_options;
+
+  // Setting offer_to_receive_audio to a value lower than kUndefined or greater
+  // than kMaxOfferToReceiveMedia should be treated as invalid.
+  rtc_options.offer_to_receive_audio = RTCOfferAnswerOptions::kUndefined - 1;
+  CreatePeerConnection();
+  EXPECT_FALSE(CreateOfferWithOptions(rtc_options));
+
+  rtc_options.offer_to_receive_audio =
+      RTCOfferAnswerOptions::kMaxOfferToReceiveMedia + 1;
+  EXPECT_FALSE(CreateOfferWithOptions(rtc_options));
+}
+
+TEST_P(PeerConnectionInterfaceTest,
+       CreateOfferFailsWithInvalidOfferToReceiveVideo) {
+  RTCOfferAnswerOptions rtc_options;
+
+  // Setting offer_to_receive_video to a value lower than kUndefined or greater
+  // than kMaxOfferToReceiveMedia should be treated as invalid.
+  rtc_options.offer_to_receive_video = RTCOfferAnswerOptions::kUndefined - 1;
+  CreatePeerConnection();
+  EXPECT_FALSE(CreateOfferWithOptions(rtc_options));
+
+  rtc_options.offer_to_receive_video =
+      RTCOfferAnswerOptions::kMaxOfferToReceiveMedia + 1;
+  EXPECT_FALSE(CreateOfferWithOptions(rtc_options));
+}
+
+// Test that the audio and video content will be added to an offer if both
+// `offer_to_receive_audio` and `offer_to_receive_video` options are 1.
+TEST_P(PeerConnectionInterfaceTest, CreateOfferWithAudioVideoOptions) {
+  RTCOfferAnswerOptions rtc_options;
+  rtc_options.offer_to_receive_audio = 1;
+  rtc_options.offer_to_receive_video = 1;
+
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  CreatePeerConnection();
+  offer = CreateOfferWithOptions(rtc_options);
+  ASSERT_TRUE(offer);
+  EXPECT_NE(nullptr, GetFirstAudioContent(offer->description()));
+  EXPECT_NE(nullptr, GetFirstVideoContent(offer->description()));
+}
+
+// Test that only audio content will be added to the offer if only
+// `offer_to_receive_audio` options is 1.
+TEST_P(PeerConnectionInterfaceTest, CreateOfferWithAudioOnlyOptions) {
+  RTCOfferAnswerOptions rtc_options;
+  rtc_options.offer_to_receive_audio = 1;
+  rtc_options.offer_to_receive_video = 0;
+
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  CreatePeerConnection();
+  offer = CreateOfferWithOptions(rtc_options);
+  ASSERT_TRUE(offer);
+  EXPECT_NE(nullptr, GetFirstAudioContent(offer->description()));
+  EXPECT_EQ(nullptr, GetFirstVideoContent(offer->description()));
+}
+
+// Test that only video content will be added if only `offer_to_receive_video`
+// options is 1.
+TEST_P(PeerConnectionInterfaceTest, CreateOfferWithVideoOnlyOptions) {
+  RTCOfferAnswerOptions rtc_options;
+  rtc_options.offer_to_receive_audio = 0;
+  rtc_options.offer_to_receive_video = 1;
+
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  CreatePeerConnection();
+  offer = CreateOfferWithOptions(rtc_options);
+  ASSERT_TRUE(offer);
+  EXPECT_EQ(nullptr, GetFirstAudioContent(offer->description()));
+  EXPECT_NE(nullptr, GetFirstVideoContent(offer->description()));
+}
+
+// Test that no media content will be added to the offer if using default
+// RTCOfferAnswerOptions.
+TEST_P(PeerConnectionInterfaceTest, CreateOfferWithDefaultOfferAnswerOptions) {
+  RTCOfferAnswerOptions rtc_options;
+
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  CreatePeerConnection();
+  offer = CreateOfferWithOptions(rtc_options);
+  ASSERT_TRUE(offer);
+  EXPECT_EQ(nullptr, GetFirstAudioContent(offer->description()));
+  EXPECT_EQ(nullptr, GetFirstVideoContent(offer->description()));
+}
+
+// Test that if `ice_restart` is true, the ufrag/pwd will change, otherwise
+// ufrag/pwd will be the same in the new offer.
+TEST_P(PeerConnectionInterfaceTest, CreateOfferWithIceRestart) {
+  CreatePeerConnection();
+
+  RTCOfferAnswerOptions rtc_options;
+  rtc_options.ice_restart = false;
+  rtc_options.offer_to_receive_audio = 1;
+
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  CreateOfferWithOptionsAsLocalDescription(&offer, rtc_options);
+  std::string mid = cricket::GetFirstAudioContent(offer->description())->name;
+  auto ufrag1 =
+      offer->description()->GetTransportInfoByName(mid)->description.ice_ufrag;
+  auto pwd1 =
+      offer->description()->GetTransportInfoByName(mid)->description.ice_pwd;
+
+  // `ice_restart` is false, the ufrag/pwd shouldn't change.
+  CreateOfferWithOptionsAsLocalDescription(&offer, rtc_options);
+  auto ufrag2 =
+      offer->description()->GetTransportInfoByName(mid)->description.ice_ufrag;
+  auto pwd2 =
+      offer->description()->GetTransportInfoByName(mid)->description.ice_pwd;
+
+  // `ice_restart` is true, the ufrag/pwd should change.
+  rtc_options.ice_restart = true;
+  CreateOfferWithOptionsAsLocalDescription(&offer, rtc_options);
+  auto ufrag3 =
+      offer->description()->GetTransportInfoByName(mid)->description.ice_ufrag;
+  auto pwd3 =
+      offer->description()->GetTransportInfoByName(mid)->description.ice_pwd;
+
+  EXPECT_EQ(ufrag1, ufrag2);
+  EXPECT_EQ(pwd1, pwd2);
+  EXPECT_NE(ufrag2, ufrag3);
+  EXPECT_NE(pwd2, pwd3);
+}
+
+// Test that if `use_rtp_mux` is true, the bundling will be enabled in the
+// offer; if it is false, there won't be any bundle group in the offer.
+TEST_P(PeerConnectionInterfaceTest, CreateOfferWithRtpMux) {
+  RTCOfferAnswerOptions rtc_options;
+  rtc_options.offer_to_receive_audio = 1;
+  rtc_options.offer_to_receive_video = 1;
+
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  CreatePeerConnection();
+
+  rtc_options.use_rtp_mux = true;
+  offer = CreateOfferWithOptions(rtc_options);
+  ASSERT_TRUE(offer);
+  EXPECT_NE(nullptr, GetFirstAudioContent(offer->description()));
+  EXPECT_NE(nullptr, GetFirstVideoContent(offer->description()));
+  EXPECT_TRUE(offer->description()->HasGroup(cricket::GROUP_TYPE_BUNDLE));
+
+  rtc_options.use_rtp_mux = false;
+  offer = CreateOfferWithOptions(rtc_options);
+  ASSERT_TRUE(offer);
+  EXPECT_NE(nullptr, GetFirstAudioContent(offer->description()));
+  EXPECT_NE(nullptr, GetFirstVideoContent(offer->description()));
+  EXPECT_FALSE(offer->description()->HasGroup(cricket::GROUP_TYPE_BUNDLE));
+}
+
+// This test ensures OnRenegotiationNeeded is called when we add track with
+// MediaStream -> AddTrack in the same way it is called when we add track with
+// PeerConnection -> AddTrack.
+// The test can be removed once addStream is rewritten in terms of addTrack
+// https://bugs.chromium.org/p/webrtc/issues/detail?id=7815
+// Don't run under Unified Plan since the stream API is not available.
+TEST_F(PeerConnectionInterfaceTestPlanB,
+       MediaStreamAddTrackRemoveTrackRenegotiate) {
+  CreatePeerConnectionWithoutDtls();
+  rtc::scoped_refptr<MediaStreamInterface> stream(
+      pc_factory_->CreateLocalMediaStream(kStreamId1));
+  pc_->AddStream(stream.get());
+  rtc::scoped_refptr<AudioTrackInterface> audio_track(
+      CreateAudioTrack("audio_track"));
+  rtc::scoped_refptr<VideoTrackInterface> video_track(
+      CreateVideoTrack("video_track"));
+  stream->AddTrack(audio_track);
+  EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
+  observer_.renegotiation_needed_ = false;
+
+  CreateOfferReceiveAnswer();
+  stream->AddTrack(video_track);
+  EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
+  observer_.renegotiation_needed_ = false;
+
+  CreateOfferReceiveAnswer();
+  stream->RemoveTrack(audio_track);
+  EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
+  observer_.renegotiation_needed_ = false;
+
+  CreateOfferReceiveAnswer();
+  stream->RemoveTrack(video_track);
+  EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
+  observer_.renegotiation_needed_ = false;
+}
+
+// Tests that an error is returned if a description is applied that has fewer
+// media sections than the existing description.
+TEST_P(PeerConnectionInterfaceTest,
+       MediaSectionCountEnforcedForSubsequentOffer) {
+  CreatePeerConnection();
+  AddAudioTrack("audio_label");
+  AddVideoTrack("video_label");
+
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+  EXPECT_TRUE(DoSetRemoteDescription(std::move(offer)));
+
+  // A remote offer with fewer media sections should be rejected.
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+  offer->description()->contents().pop_back();
+  offer->description()->contents().pop_back();
+  ASSERT_TRUE(offer->description()->contents().empty());
+  EXPECT_FALSE(DoSetRemoteDescription(std::move(offer)));
+
+  std::unique_ptr<SessionDescriptionInterface> answer;
+  ASSERT_TRUE(DoCreateAnswer(&answer, nullptr));
+  EXPECT_TRUE(DoSetLocalDescription(std::move(answer)));
+
+  // A subsequent local offer with fewer media sections should be rejected.
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+  offer->description()->contents().pop_back();
+  offer->description()->contents().pop_back();
+  ASSERT_TRUE(offer->description()->contents().empty());
+  EXPECT_FALSE(DoSetLocalDescription(std::move(offer)));
+}
+
+TEST_P(PeerConnectionInterfaceTest, ExtmapAllowMixedIsConfigurable) {
+  RTCConfiguration config;
+  // Default behavior is true.
+  CreatePeerConnection(config);
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+  EXPECT_TRUE(offer->description()->extmap_allow_mixed());
+  // Possible to set to false.
+  config.offer_extmap_allow_mixed = false;
+  CreatePeerConnection(config);
+  offer = nullptr;
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+  EXPECT_FALSE(offer->description()->extmap_allow_mixed());
+}
+
+TEST_P(PeerConnectionInterfaceTest,
+       RtpSenderSetDegradationPreferenceWithoutEncodings) {
+  CreatePeerConnection();
+  AddVideoTrack("video_label");
+
+  std::vector<rtc::scoped_refptr<RtpSenderInterface>> rtp_senders =
+      pc_->GetSenders();
+  ASSERT_EQ(rtp_senders.size(), 1u);
+  ASSERT_EQ(rtp_senders[0]->media_type(), cricket::MEDIA_TYPE_VIDEO);
+  rtc::scoped_refptr<RtpSenderInterface> video_rtp_sender = rtp_senders[0];
+  RtpParameters parameters = video_rtp_sender->GetParameters();
+  ASSERT_NE(parameters.degradation_preference,
+            DegradationPreference::MAINTAIN_RESOLUTION);
+  parameters.degradation_preference =
+      DegradationPreference::MAINTAIN_RESOLUTION;
+  ASSERT_TRUE(video_rtp_sender->SetParameters(parameters).ok());
+
+  std::unique_ptr<SessionDescriptionInterface> local_offer;
+  ASSERT_TRUE(DoCreateOffer(&local_offer, nullptr));
+  ASSERT_TRUE(DoSetLocalDescription(std::move(local_offer)));
+
+  RtpParameters parameters_new = video_rtp_sender->GetParameters();
+  ASSERT_EQ(parameters_new.degradation_preference,
+            DegradationPreference::MAINTAIN_RESOLUTION);
+}
+
+INSTANTIATE_TEST_SUITE_P(PeerConnectionInterfaceTest,
+                         PeerConnectionInterfaceTest,
+                         Values(SdpSemantics::kPlanB_DEPRECATED,
+                                SdpSemantics::kUnifiedPlan));
+
+class PeerConnectionMediaConfigTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    pcf_ = PeerConnectionFactoryForTest::CreatePeerConnectionFactoryForTest();
+  }
+  const cricket::MediaConfig TestCreatePeerConnection(
+      const RTCConfiguration& config) {
+    PeerConnectionDependencies pc_dependencies(&observer_);
+    auto result =
+        pcf_->CreatePeerConnectionOrError(config, std::move(pc_dependencies));
+    EXPECT_TRUE(result.ok());
+    observer_.SetPeerConnectionInterface(result.value().get());
+    return result.value()->GetConfiguration().media_config;
+  }
+
+  rtc::scoped_refptr<PeerConnectionFactoryForTest> pcf_;
+  MockPeerConnectionObserver observer_;
+};
+
+// This sanity check validates the test infrastructure itself.
+TEST_F(PeerConnectionMediaConfigTest, TestCreateAndClose) {
+  PeerConnectionInterface::RTCConfiguration config;
+  config.sdp_semantics = SdpSemantics::kUnifiedPlan;
+  PeerConnectionDependencies pc_dependencies(&observer_);
+  auto result =
+      pcf_->CreatePeerConnectionOrError(config, std::move(pc_dependencies));
+  EXPECT_TRUE(result.ok());
+  observer_.SetPeerConnectionInterface(result.value().get());
+  result.value()->Close();  // No abort -> ok.
+  SUCCEED();
+}
+
+// This test verifies the default behaviour with no constraints and a
+// default RTCConfiguration.
+TEST_F(PeerConnectionMediaConfigTest, TestDefaults) {
+  PeerConnectionInterface::RTCConfiguration config;
+  config.sdp_semantics = SdpSemantics::kUnifiedPlan;
+
+  const cricket::MediaConfig& media_config = TestCreatePeerConnection(config);
+
+  EXPECT_TRUE(media_config.enable_dscp);
+  EXPECT_TRUE(media_config.video.enable_cpu_adaptation);
+  EXPECT_TRUE(media_config.video.enable_prerenderer_smoothing);
+  EXPECT_FALSE(media_config.video.suspend_below_min_bitrate);
+  EXPECT_FALSE(media_config.video.experiment_cpu_load_estimator);
+}
+
+// This test verifies that the enable_prerenderer_smoothing flag is
+// propagated from RTCConfiguration to the PeerConnection.
+TEST_F(PeerConnectionMediaConfigTest, TestDisablePrerendererSmoothingTrue) {
+  PeerConnectionInterface::RTCConfiguration config;
+  config.sdp_semantics = SdpSemantics::kUnifiedPlan;
+
+  config.set_prerenderer_smoothing(false);
+  const cricket::MediaConfig& media_config = TestCreatePeerConnection(config);
+
+  EXPECT_FALSE(media_config.video.enable_prerenderer_smoothing);
+}
+
+// This test verifies that the experiment_cpu_load_estimator flag is
+// propagated from RTCConfiguration to the PeerConnection.
+TEST_F(PeerConnectionMediaConfigTest, TestEnableExperimentCpuLoadEstimator) {
+  PeerConnectionInterface::RTCConfiguration config;
+  config.sdp_semantics = SdpSemantics::kUnifiedPlan;
+
+  config.set_experiment_cpu_load_estimator(true);
+  const cricket::MediaConfig& media_config = TestCreatePeerConnection(config);
+
+  EXPECT_TRUE(media_config.video.experiment_cpu_load_estimator);
+}
+
+// Tests a few random fields being different.
+TEST(RTCConfigurationTest, ComparisonOperators) {
+  PeerConnectionInterface::RTCConfiguration a;
+  PeerConnectionInterface::RTCConfiguration b;
+  EXPECT_EQ(a, b);
+
+  PeerConnectionInterface::RTCConfiguration c;
+  c.servers.push_back(PeerConnectionInterface::IceServer());
+  EXPECT_NE(a, c);
+
+  PeerConnectionInterface::RTCConfiguration d;
+  d.type = PeerConnectionInterface::kRelay;
+  EXPECT_NE(a, d);
+
+  PeerConnectionInterface::RTCConfiguration e;
+  e.audio_jitter_buffer_max_packets = 5;
+  EXPECT_NE(a, e);
+
+  PeerConnectionInterface::RTCConfiguration f;
+  f.ice_connection_receiving_timeout = 1337;
+  EXPECT_NE(a, f);
+
+  PeerConnectionInterface::RTCConfiguration h(
+      PeerConnectionInterface::RTCConfigurationType::kAggressive);
+  EXPECT_NE(a, h);
+}
+
+}  // namespace
+}  // namespace webrtc