Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

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

31 files changed, 7433 insertions, 0 deletions

diff --git a/third_party/libwebrtc/pc/test/DEPS b/third_party/libwebrtc/pc/test/DEPS
new file mode 100644
index 0000000000..33e6d94b25
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/DEPS
@@ -0,0 +1,5 @@
+include_rules = [
+  # Allow include of sdk/android to allow accessing the JVM and Env in tests.
+  "+sdk/android",
+  "+modules/utility/include/jvm_android.h",
+]
diff --git a/third_party/libwebrtc/pc/test/android_test_initializer.cc b/third_party/libwebrtc/pc/test/android_test_initializer.cc
new file mode 100644
index 0000000000..963544cb4b
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/android_test_initializer.cc
@@ -0,0 +1,51 @@
+/*
+ *  Copyright 2015 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 "pc/test/android_test_initializer.h"
+
+#include <jni.h>
+#include <pthread.h>
+#include <stddef.h>
+
+#include "modules/utility/include/jvm_android.h"
+#include "rtc_base/checks.h"
+#include "sdk/android/src/jni/jvm.h"
+// TODO(phoglund): This include is to a target we can't really depend on.
+// We need to either break it out into a smaller target or find some way to
+// not use it.
+#include "rtc_base/ssl_adapter.h"
+
+namespace webrtc {
+
+namespace {
+
+static pthread_once_t g_initialize_once = PTHREAD_ONCE_INIT;
+
+// There can only be one JNI_OnLoad in each binary. So since this is a GTEST
+// C++ runner binary, we want to initialize the same global objects we normally
+// do if this had been a Java binary.
+void EnsureInitializedOnce() {
+  RTC_CHECK(::webrtc::jni::GetJVM() != nullptr);
+  JNIEnv* jni = ::webrtc::jni::AttachCurrentThreadIfNeeded();
+  JavaVM* jvm = NULL;
+  RTC_CHECK_EQ(0, jni->GetJavaVM(&jvm));
+
+  RTC_CHECK(rtc::InitializeSSL()) << "Failed to InitializeSSL()";
+
+  webrtc::JVM::Initialize(jvm);
+}
+
+}  // anonymous namespace
+
+void InitializeAndroidObjects() {
+  RTC_CHECK_EQ(0, pthread_once(&g_initialize_once, &EnsureInitializedOnce));
+}
+
+}  // namespace webrtc
diff --git a/third_party/libwebrtc/pc/test/android_test_initializer.h b/third_party/libwebrtc/pc/test/android_test_initializer.h
new file mode 100644
index 0000000000..4181dd286c
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/android_test_initializer.h
@@ -0,0 +1,20 @@
+/*
+ *  Copyright 2015 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.
+ */
+
+#ifndef PC_TEST_ANDROID_TEST_INITIALIZER_H_
+#define PC_TEST_ANDROID_TEST_INITIALIZER_H_
+
+namespace webrtc {
+
+void InitializeAndroidObjects();
+
+}  // namespace webrtc
+
+#endif  // PC_TEST_ANDROID_TEST_INITIALIZER_H_
diff --git a/third_party/libwebrtc/pc/test/fake_audio_capture_module.cc b/third_party/libwebrtc/pc/test/fake_audio_capture_module.cc
new file mode 100644
index 0000000000..132328291c
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/fake_audio_capture_module.cc
@@ -0,0 +1,521 @@
+/*
+ *  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 "pc/test/fake_audio_capture_module.h"
+
+#include <string.h>
+
+#include "api/make_ref_counted.h"
+#include "api/units/time_delta.h"
+#include "rtc_base/checks.h"
+#include "rtc_base/thread.h"
+#include "rtc_base/time_utils.h"
+
+using ::webrtc::TimeDelta;
+
+// Audio sample value that is high enough that it doesn't occur naturally when
+// frames are being faked. E.g. NetEq will not generate this large sample value
+// unless it has received an audio frame containing a sample of this value.
+// Even simpler buffers would likely just contain audio sample values of 0.
+static const int kHighSampleValue = 10000;
+
+// Constants here are derived by running VoE using a real ADM.
+// The constants correspond to 10ms of mono audio at 44kHz.
+static const int kTimePerFrameMs = 10;
+static const uint8_t kNumberOfChannels = 1;
+static const int kSamplesPerSecond = 44000;
+static const int kTotalDelayMs = 0;
+static const int kClockDriftMs = 0;
+static const uint32_t kMaxVolume = 14392;
+
+FakeAudioCaptureModule::FakeAudioCaptureModule()
+    : audio_callback_(nullptr),
+      recording_(false),
+      playing_(false),
+      play_is_initialized_(false),
+      rec_is_initialized_(false),
+      current_mic_level_(kMaxVolume),
+      started_(false),
+      next_frame_time_(0),
+      frames_received_(0) {
+  process_thread_checker_.Detach();
+}
+
+FakeAudioCaptureModule::~FakeAudioCaptureModule() {
+  if (process_thread_) {
+    process_thread_->Stop();
+  }
+}
+
+rtc::scoped_refptr<FakeAudioCaptureModule> FakeAudioCaptureModule::Create() {
+  auto capture_module = rtc::make_ref_counted<FakeAudioCaptureModule>();
+  if (!capture_module->Initialize()) {
+    return nullptr;
+  }
+  return capture_module;
+}
+
+int FakeAudioCaptureModule::frames_received() const {
+  webrtc::MutexLock lock(&mutex_);
+  return frames_received_;
+}
+
+int32_t FakeAudioCaptureModule::ActiveAudioLayer(
+    AudioLayer* /*audio_layer*/) const {
+  RTC_DCHECK_NOTREACHED();
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::RegisterAudioCallback(
+    webrtc::AudioTransport* audio_callback) {
+  webrtc::MutexLock lock(&mutex_);
+  audio_callback_ = audio_callback;
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::Init() {
+  // Initialize is called by the factory method. Safe to ignore this Init call.
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::Terminate() {
+  // Clean up in the destructor. No action here, just success.
+  return 0;
+}
+
+bool FakeAudioCaptureModule::Initialized() const {
+  RTC_DCHECK_NOTREACHED();
+  return 0;
+}
+
+int16_t FakeAudioCaptureModule::PlayoutDevices() {
+  RTC_DCHECK_NOTREACHED();
+  return 0;
+}
+
+int16_t FakeAudioCaptureModule::RecordingDevices() {
+  RTC_DCHECK_NOTREACHED();
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::PlayoutDeviceName(
+    uint16_t /*index*/,
+    char /*name*/[webrtc::kAdmMaxDeviceNameSize],
+    char /*guid*/[webrtc::kAdmMaxGuidSize]) {
+  RTC_DCHECK_NOTREACHED();
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::RecordingDeviceName(
+    uint16_t /*index*/,
+    char /*name*/[webrtc::kAdmMaxDeviceNameSize],
+    char /*guid*/[webrtc::kAdmMaxGuidSize]) {
+  RTC_DCHECK_NOTREACHED();
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::SetPlayoutDevice(uint16_t /*index*/) {
+  // No playout device, just playing from file. Return success.
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::SetPlayoutDevice(WindowsDeviceType /*device*/) {
+  if (play_is_initialized_) {
+    return -1;
+  }
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::SetRecordingDevice(uint16_t /*index*/) {
+  // No recording device, just dropping audio. Return success.
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::SetRecordingDevice(
+    WindowsDeviceType /*device*/) {
+  if (rec_is_initialized_) {
+    return -1;
+  }
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::PlayoutIsAvailable(bool* /*available*/) {
+  RTC_DCHECK_NOTREACHED();
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::InitPlayout() {
+  play_is_initialized_ = true;
+  return 0;
+}
+
+bool FakeAudioCaptureModule::PlayoutIsInitialized() const {
+  return play_is_initialized_;
+}
+
+int32_t FakeAudioCaptureModule::RecordingIsAvailable(bool* /*available*/) {
+  RTC_DCHECK_NOTREACHED();
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::InitRecording() {
+  rec_is_initialized_ = true;
+  return 0;
+}
+
+bool FakeAudioCaptureModule::RecordingIsInitialized() const {
+  return rec_is_initialized_;
+}
+
+int32_t FakeAudioCaptureModule::StartPlayout() {
+  if (!play_is_initialized_) {
+    return -1;
+  }
+  {
+    webrtc::MutexLock lock(&mutex_);
+    playing_ = true;
+  }
+  bool start = true;
+  UpdateProcessing(start);
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::StopPlayout() {
+  bool start = false;
+  {
+    webrtc::MutexLock lock(&mutex_);
+    playing_ = false;
+    start = ShouldStartProcessing();
+  }
+  UpdateProcessing(start);
+  return 0;
+}
+
+bool FakeAudioCaptureModule::Playing() const {
+  webrtc::MutexLock lock(&mutex_);
+  return playing_;
+}
+
+int32_t FakeAudioCaptureModule::StartRecording() {
+  if (!rec_is_initialized_) {
+    return -1;
+  }
+  {
+    webrtc::MutexLock lock(&mutex_);
+    recording_ = true;
+  }
+  bool start = true;
+  UpdateProcessing(start);
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::StopRecording() {
+  bool start = false;
+  {
+    webrtc::MutexLock lock(&mutex_);
+    recording_ = false;
+    start = ShouldStartProcessing();
+  }
+  UpdateProcessing(start);
+  return 0;
+}
+
+bool FakeAudioCaptureModule::Recording() const {
+  webrtc::MutexLock lock(&mutex_);
+  return recording_;
+}
+
+int32_t FakeAudioCaptureModule::InitSpeaker() {
+  // No speaker, just playing from file. Return success.
+  return 0;
+}
+
+bool FakeAudioCaptureModule::SpeakerIsInitialized() const {
+  RTC_DCHECK_NOTREACHED();
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::InitMicrophone() {
+  // No microphone, just playing from file. Return success.
+  return 0;
+}
+
+bool FakeAudioCaptureModule::MicrophoneIsInitialized() const {
+  RTC_DCHECK_NOTREACHED();
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::SpeakerVolumeIsAvailable(bool* /*available*/) {
+  RTC_DCHECK_NOTREACHED();
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::SetSpeakerVolume(uint32_t /*volume*/) {
+  RTC_DCHECK_NOTREACHED();
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::SpeakerVolume(uint32_t* /*volume*/) const {
+  RTC_DCHECK_NOTREACHED();
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::MaxSpeakerVolume(
+    uint32_t* /*max_volume*/) const {
+  RTC_DCHECK_NOTREACHED();
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::MinSpeakerVolume(
+    uint32_t* /*min_volume*/) const {
+  RTC_DCHECK_NOTREACHED();
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::MicrophoneVolumeIsAvailable(
+    bool* /*available*/) {
+  RTC_DCHECK_NOTREACHED();
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::SetMicrophoneVolume(uint32_t volume) {
+  webrtc::MutexLock lock(&mutex_);
+  current_mic_level_ = volume;
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::MicrophoneVolume(uint32_t* volume) const {
+  webrtc::MutexLock lock(&mutex_);
+  *volume = current_mic_level_;
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::MaxMicrophoneVolume(
+    uint32_t* max_volume) const {
+  *max_volume = kMaxVolume;
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::MinMicrophoneVolume(
+    uint32_t* /*min_volume*/) const {
+  RTC_DCHECK_NOTREACHED();
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::SpeakerMuteIsAvailable(bool* /*available*/) {
+  RTC_DCHECK_NOTREACHED();
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::SetSpeakerMute(bool /*enable*/) {
+  RTC_DCHECK_NOTREACHED();
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::SpeakerMute(bool* /*enabled*/) const {
+  RTC_DCHECK_NOTREACHED();
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::MicrophoneMuteIsAvailable(bool* /*available*/) {
+  RTC_DCHECK_NOTREACHED();
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::SetMicrophoneMute(bool /*enable*/) {
+  RTC_DCHECK_NOTREACHED();
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::MicrophoneMute(bool* /*enabled*/) const {
+  RTC_DCHECK_NOTREACHED();
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::StereoPlayoutIsAvailable(
+    bool* available) const {
+  // No recording device, just dropping audio. Stereo can be dropped just
+  // as easily as mono.
+  *available = true;
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::SetStereoPlayout(bool /*enable*/) {
+  // No recording device, just dropping audio. Stereo can be dropped just
+  // as easily as mono.
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::StereoPlayout(bool* /*enabled*/) const {
+  RTC_DCHECK_NOTREACHED();
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::StereoRecordingIsAvailable(
+    bool* available) const {
+  // Keep thing simple. No stereo recording.
+  *available = false;
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::SetStereoRecording(bool enable) {
+  if (!enable) {
+    return 0;
+  }
+  return -1;
+}
+
+int32_t FakeAudioCaptureModule::StereoRecording(bool* /*enabled*/) const {
+  RTC_DCHECK_NOTREACHED();
+  return 0;
+}
+
+int32_t FakeAudioCaptureModule::PlayoutDelay(uint16_t* delay_ms) const {
+  // No delay since audio frames are dropped.
+  *delay_ms = 0;
+  return 0;
+}
+
+bool FakeAudioCaptureModule::Initialize() {
+  // Set the send buffer samples high enough that it would not occur on the
+  // remote side unless a packet containing a sample of that magnitude has been
+  // sent to it. Note that the audio processing pipeline will likely distort the
+  // original signal.
+  SetSendBuffer(kHighSampleValue);
+  return true;
+}
+
+void FakeAudioCaptureModule::SetSendBuffer(int value) {
+  Sample* buffer_ptr = reinterpret_cast<Sample*>(send_buffer_);
+  const size_t buffer_size_in_samples =
+      sizeof(send_buffer_) / kNumberBytesPerSample;
+  for (size_t i = 0; i < buffer_size_in_samples; ++i) {
+    buffer_ptr[i] = value;
+  }
+}
+
+void FakeAudioCaptureModule::ResetRecBuffer() {
+  memset(rec_buffer_, 0, sizeof(rec_buffer_));
+}
+
+bool FakeAudioCaptureModule::CheckRecBuffer(int value) {
+  const Sample* buffer_ptr = reinterpret_cast<const Sample*>(rec_buffer_);
+  const size_t buffer_size_in_samples =
+      sizeof(rec_buffer_) / kNumberBytesPerSample;
+  for (size_t i = 0; i < buffer_size_in_samples; ++i) {
+    if (buffer_ptr[i] >= value)
+      return true;
+  }
+  return false;
+}
+
+bool FakeAudioCaptureModule::ShouldStartProcessing() {
+  return recording_ || playing_;
+}
+
+void FakeAudioCaptureModule::UpdateProcessing(bool start) {
+  if (start) {
+    if (!process_thread_) {
+      process_thread_ = rtc::Thread::Create();
+      process_thread_->Start();
+    }
+    process_thread_->PostTask([this] { StartProcessP(); });
+  } else {
+    if (process_thread_) {
+      process_thread_->Stop();
+      process_thread_.reset(nullptr);
+      process_thread_checker_.Detach();
+    }
+    webrtc::MutexLock lock(&mutex_);
+    started_ = false;
+  }
+}
+
+void FakeAudioCaptureModule::StartProcessP() {
+  RTC_DCHECK_RUN_ON(&process_thread_checker_);
+  {
+    webrtc::MutexLock lock(&mutex_);
+    if (started_) {
+      // Already started.
+      return;
+    }
+  }
+  ProcessFrameP();
+}
+
+void FakeAudioCaptureModule::ProcessFrameP() {
+  RTC_DCHECK_RUN_ON(&process_thread_checker_);
+  {
+    webrtc::MutexLock lock(&mutex_);
+    if (!started_) {
+      next_frame_time_ = rtc::TimeMillis();
+      started_ = true;
+    }
+
+    // Receive and send frames every kTimePerFrameMs.
+    if (playing_) {
+      ReceiveFrameP();
+    }
+    if (recording_) {
+      SendFrameP();
+    }
+  }
+
+  next_frame_time_ += kTimePerFrameMs;
+  const int64_t current_time = rtc::TimeMillis();
+  const int64_t wait_time =
+      (next_frame_time_ > current_time) ? next_frame_time_ - current_time : 0;
+  process_thread_->PostDelayedTask([this] { ProcessFrameP(); },
+                                   TimeDelta::Millis(wait_time));
+}
+
+void FakeAudioCaptureModule::ReceiveFrameP() {
+  RTC_DCHECK_RUN_ON(&process_thread_checker_);
+  if (!audio_callback_) {
+    return;
+  }
+  ResetRecBuffer();
+  size_t nSamplesOut = 0;
+  int64_t elapsed_time_ms = 0;
+  int64_t ntp_time_ms = 0;
+  if (audio_callback_->NeedMorePlayData(kNumberSamples, kNumberBytesPerSample,
+                                        kNumberOfChannels, kSamplesPerSecond,
+                                        rec_buffer_, nSamplesOut,
+                                        &elapsed_time_ms, &ntp_time_ms) != 0) {
+    RTC_DCHECK_NOTREACHED();
+  }
+  RTC_CHECK(nSamplesOut == kNumberSamples);
+
+  // The SetBuffer() function ensures that after decoding, the audio buffer
+  // should contain samples of similar magnitude (there is likely to be some
+  // distortion due to the audio pipeline). If one sample is detected to
+  // have the same or greater magnitude somewhere in the frame, an actual frame
+  // has been received from the remote side (i.e. faked frames are not being
+  // pulled).
+  if (CheckRecBuffer(kHighSampleValue)) {
+    ++frames_received_;
+  }
+}
+
+void FakeAudioCaptureModule::SendFrameP() {
+  RTC_DCHECK_RUN_ON(&process_thread_checker_);
+  if (!audio_callback_) {
+    return;
+  }
+  bool key_pressed = false;
+  uint32_t current_mic_level = current_mic_level_;
+  if (audio_callback_->RecordedDataIsAvailable(
+          send_buffer_, kNumberSamples, kNumberBytesPerSample,
+          kNumberOfChannels, kSamplesPerSecond, kTotalDelayMs, kClockDriftMs,
+          current_mic_level, key_pressed, current_mic_level) != 0) {
+    RTC_DCHECK_NOTREACHED();
+  }
+  current_mic_level_ = current_mic_level;
+}
diff --git a/third_party/libwebrtc/pc/test/fake_audio_capture_module.h b/third_party/libwebrtc/pc/test/fake_audio_capture_module.h
new file mode 100644
index 0000000000..84ddacb26f
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/fake_audio_capture_module.h
@@ -0,0 +1,235 @@
+/*
+ *  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.
+ */
+
+// This class implements an AudioCaptureModule that can be used to detect if
+// audio is being received properly if it is fed by another AudioCaptureModule
+// in some arbitrary audio pipeline where they are connected. It does not play
+// out or record any audio so it does not need access to any hardware and can
+// therefore be used in the gtest testing framework.
+
+// Note P postfix of a function indicates that it should only be called by the
+// processing thread.
+
+#ifndef PC_TEST_FAKE_AUDIO_CAPTURE_MODULE_H_
+#define PC_TEST_FAKE_AUDIO_CAPTURE_MODULE_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <memory>
+
+#include "api/scoped_refptr.h"
+#include "api/sequence_checker.h"
+#include "modules/audio_device/include/audio_device.h"
+#include "modules/audio_device/include/audio_device_defines.h"
+#include "rtc_base/synchronization/mutex.h"
+#include "rtc_base/thread_annotations.h"
+
+namespace rtc {
+class Thread;
+}  // namespace rtc
+
+class FakeAudioCaptureModule : public webrtc::AudioDeviceModule {
+ public:
+  typedef uint16_t Sample;
+
+  // The value for the following constants have been derived by running VoE
+  // using a real ADM. The constants correspond to 10ms of mono audio at 44kHz.
+  static const size_t kNumberSamples = 440;
+  static const size_t kNumberBytesPerSample = sizeof(Sample);
+
+  // Creates a FakeAudioCaptureModule or returns NULL on failure.
+  static rtc::scoped_refptr<FakeAudioCaptureModule> Create();
+
+  // Returns the number of frames that have been successfully pulled by the
+  // instance. Note that correctly detecting success can only be done if the
+  // pulled frame was generated/pushed from a FakeAudioCaptureModule.
+  int frames_received() const RTC_LOCKS_EXCLUDED(mutex_);
+
+  int32_t ActiveAudioLayer(AudioLayer* audio_layer) const override;
+
+  // Note: Calling this method from a callback may result in deadlock.
+  int32_t RegisterAudioCallback(webrtc::AudioTransport* audio_callback) override
+      RTC_LOCKS_EXCLUDED(mutex_);
+
+  int32_t Init() override;
+  int32_t Terminate() override;
+  bool Initialized() const override;
+
+  int16_t PlayoutDevices() override;
+  int16_t RecordingDevices() override;
+  int32_t PlayoutDeviceName(uint16_t index,
+                            char name[webrtc::kAdmMaxDeviceNameSize],
+                            char guid[webrtc::kAdmMaxGuidSize]) override;
+  int32_t RecordingDeviceName(uint16_t index,
+                              char name[webrtc::kAdmMaxDeviceNameSize],
+                              char guid[webrtc::kAdmMaxGuidSize]) override;
+
+  int32_t SetPlayoutDevice(uint16_t index) override;
+  int32_t SetPlayoutDevice(WindowsDeviceType device) override;
+  int32_t SetRecordingDevice(uint16_t index) override;
+  int32_t SetRecordingDevice(WindowsDeviceType device) override;
+
+  int32_t PlayoutIsAvailable(bool* available) override;
+  int32_t InitPlayout() override;
+  bool PlayoutIsInitialized() const override;
+  int32_t RecordingIsAvailable(bool* available) override;
+  int32_t InitRecording() override;
+  bool RecordingIsInitialized() const override;
+
+  int32_t StartPlayout() RTC_LOCKS_EXCLUDED(mutex_) override;
+  int32_t StopPlayout() RTC_LOCKS_EXCLUDED(mutex_) override;
+  bool Playing() const RTC_LOCKS_EXCLUDED(mutex_) override;
+  int32_t StartRecording() RTC_LOCKS_EXCLUDED(mutex_) override;
+  int32_t StopRecording() RTC_LOCKS_EXCLUDED(mutex_) override;
+  bool Recording() const RTC_LOCKS_EXCLUDED(mutex_) override;
+
+  int32_t InitSpeaker() override;
+  bool SpeakerIsInitialized() const override;
+  int32_t InitMicrophone() override;
+  bool MicrophoneIsInitialized() const override;
+
+  int32_t SpeakerVolumeIsAvailable(bool* available) override;
+  int32_t SetSpeakerVolume(uint32_t volume) override;
+  int32_t SpeakerVolume(uint32_t* volume) const override;
+  int32_t MaxSpeakerVolume(uint32_t* max_volume) const override;
+  int32_t MinSpeakerVolume(uint32_t* min_volume) const override;
+
+  int32_t MicrophoneVolumeIsAvailable(bool* available) override;
+  int32_t SetMicrophoneVolume(uint32_t volume)
+      RTC_LOCKS_EXCLUDED(mutex_) override;
+  int32_t MicrophoneVolume(uint32_t* volume) const
+      RTC_LOCKS_EXCLUDED(mutex_) override;
+  int32_t MaxMicrophoneVolume(uint32_t* max_volume) const override;
+
+  int32_t MinMicrophoneVolume(uint32_t* min_volume) const override;
+
+  int32_t SpeakerMuteIsAvailable(bool* available) override;
+  int32_t SetSpeakerMute(bool enable) override;
+  int32_t SpeakerMute(bool* enabled) const override;
+
+  int32_t MicrophoneMuteIsAvailable(bool* available) override;
+  int32_t SetMicrophoneMute(bool enable) override;
+  int32_t MicrophoneMute(bool* enabled) const override;
+
+  int32_t StereoPlayoutIsAvailable(bool* available) const override;
+  int32_t SetStereoPlayout(bool enable) override;
+  int32_t StereoPlayout(bool* enabled) const override;
+  int32_t StereoRecordingIsAvailable(bool* available) const override;
+  int32_t SetStereoRecording(bool enable) override;
+  int32_t StereoRecording(bool* enabled) const override;
+
+  int32_t PlayoutDelay(uint16_t* delay_ms) const override;
+
+  bool BuiltInAECIsAvailable() const override { return false; }
+  int32_t EnableBuiltInAEC(bool enable) override { return -1; }
+  bool BuiltInAGCIsAvailable() const override { return false; }
+  int32_t EnableBuiltInAGC(bool enable) override { return -1; }
+  bool BuiltInNSIsAvailable() const override { return false; }
+  int32_t EnableBuiltInNS(bool enable) override { return -1; }
+
+  int32_t GetPlayoutUnderrunCount() const override { return -1; }
+
+  absl::optional<webrtc::AudioDeviceModule::Stats> GetStats() const override {
+    return webrtc::AudioDeviceModule::Stats();
+  }
+#if defined(WEBRTC_IOS)
+  int GetPlayoutAudioParameters(
+      webrtc::AudioParameters* params) const override {
+    return -1;
+  }
+  int GetRecordAudioParameters(webrtc::AudioParameters* params) const override {
+    return -1;
+  }
+#endif  // WEBRTC_IOS
+
+  // End of functions inherited from webrtc::AudioDeviceModule.
+
+ protected:
+  // The constructor is protected because the class needs to be created as a
+  // reference counted object (for memory managment reasons). It could be
+  // exposed in which case the burden of proper instantiation would be put on
+  // the creator of a FakeAudioCaptureModule instance. To create an instance of
+  // this class use the Create(..) API.
+  FakeAudioCaptureModule();
+  // The destructor is protected because it is reference counted and should not
+  // be deleted directly.
+  virtual ~FakeAudioCaptureModule();
+
+ private:
+  // Initializes the state of the FakeAudioCaptureModule. This API is called on
+  // creation by the Create() API.
+  bool Initialize();
+  // SetBuffer() sets all samples in send_buffer_ to `value`.
+  void SetSendBuffer(int value);
+  // Resets rec_buffer_. I.e., sets all rec_buffer_ samples to 0.
+  void ResetRecBuffer();
+  // Returns true if rec_buffer_ contains one or more sample greater than or
+  // equal to `value`.
+  bool CheckRecBuffer(int value);
+
+  // Returns true/false depending on if recording or playback has been
+  // enabled/started.
+  bool ShouldStartProcessing() RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
+  // Starts or stops the pushing and pulling of audio frames.
+  void UpdateProcessing(bool start) RTC_LOCKS_EXCLUDED(mutex_);
+
+  // Starts the periodic calling of ProcessFrame() in a thread safe way.
+  void StartProcessP();
+  // Periodcally called function that ensures that frames are pulled and pushed
+  // periodically if enabled/started.
+  void ProcessFrameP() RTC_LOCKS_EXCLUDED(mutex_);
+  // Pulls frames from the registered webrtc::AudioTransport.
+  void ReceiveFrameP() RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+  // Pushes frames to the registered webrtc::AudioTransport.
+  void SendFrameP() RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
+  // Callback for playout and recording.
+  webrtc::AudioTransport* audio_callback_ RTC_GUARDED_BY(mutex_);
+
+  bool recording_ RTC_GUARDED_BY(
+      mutex_);  // True when audio is being pushed from the instance.
+  bool playing_ RTC_GUARDED_BY(
+      mutex_);  // True when audio is being pulled by the instance.
+
+  bool play_is_initialized_;  // True when the instance is ready to pull audio.
+  bool rec_is_initialized_;   // True when the instance is ready to push audio.
+
+  // Input to and output from RecordedDataIsAvailable(..) makes it possible to
+  // modify the current mic level. The implementation does not care about the
+  // mic level so it just feeds back what it receives.
+  uint32_t current_mic_level_ RTC_GUARDED_BY(mutex_);
+
+  // next_frame_time_ is updated in a non-drifting manner to indicate the next
+  // wall clock time the next frame should be generated and received. started_
+  // ensures that next_frame_time_ can be initialized properly on first call.
+  bool started_ RTC_GUARDED_BY(mutex_);
+  int64_t next_frame_time_ RTC_GUARDED_BY(process_thread_checker_);
+
+  std::unique_ptr<rtc::Thread> process_thread_;
+
+  // Buffer for storing samples received from the webrtc::AudioTransport.
+  char rec_buffer_[kNumberSamples * kNumberBytesPerSample];
+  // Buffer for samples to send to the webrtc::AudioTransport.
+  char send_buffer_[kNumberSamples * kNumberBytesPerSample];
+
+  // Counter of frames received that have samples of high enough amplitude to
+  // indicate that the frames are not faked somewhere in the audio pipeline
+  // (e.g. by a jitter buffer).
+  int frames_received_;
+
+  // Protects variables that are accessed from process_thread_ and
+  // the main thread.
+  mutable webrtc::Mutex mutex_;
+  webrtc::SequenceChecker process_thread_checker_;
+};
+
+#endif  // PC_TEST_FAKE_AUDIO_CAPTURE_MODULE_H_
diff --git a/third_party/libwebrtc/pc/test/fake_audio_capture_module_unittest.cc b/third_party/libwebrtc/pc/test/fake_audio_capture_module_unittest.cc
new file mode 100644
index 0000000000..64141b13a9
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/fake_audio_capture_module_unittest.cc
@@ -0,0 +1,198 @@
+/*
+ *  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 "pc/test/fake_audio_capture_module.h"
+
+#include <string.h>
+
+#include <algorithm>
+
+#include "api/scoped_refptr.h"
+#include "rtc_base/gunit.h"
+#include "rtc_base/synchronization/mutex.h"
+#include "test/gtest.h"
+
+class FakeAdmTest : public ::testing::Test, public webrtc::AudioTransport {
+ protected:
+  static const int kMsInSecond = 1000;
+
+  FakeAdmTest()
+      : push_iterations_(0), pull_iterations_(0), rec_buffer_bytes_(0) {
+    memset(rec_buffer_, 0, sizeof(rec_buffer_));
+  }
+
+  void SetUp() override {
+    fake_audio_capture_module_ = FakeAudioCaptureModule::Create();
+    EXPECT_TRUE(fake_audio_capture_module_.get() != NULL);
+  }
+
+  // Callbacks inherited from webrtc::AudioTransport.
+  // ADM is pushing data.
+  int32_t RecordedDataIsAvailable(const void* audioSamples,
+                                  const size_t nSamples,
+                                  const size_t nBytesPerSample,
+                                  const size_t nChannels,
+                                  const uint32_t samplesPerSec,
+                                  const uint32_t totalDelayMS,
+                                  const int32_t clockDrift,
+                                  const uint32_t currentMicLevel,
+                                  const bool keyPressed,
+                                  uint32_t& newMicLevel) override {
+    webrtc::MutexLock lock(&mutex_);
+    rec_buffer_bytes_ = nSamples * nBytesPerSample;
+    if ((rec_buffer_bytes_ == 0) ||
+        (rec_buffer_bytes_ >
+         FakeAudioCaptureModule::kNumberSamples *
+             FakeAudioCaptureModule::kNumberBytesPerSample)) {
+      ADD_FAILURE();
+      return -1;
+    }
+    memcpy(rec_buffer_, audioSamples, rec_buffer_bytes_);
+    ++push_iterations_;
+    newMicLevel = currentMicLevel;
+    return 0;
+  }
+
+  void PullRenderData(int bits_per_sample,
+                      int sample_rate,
+                      size_t number_of_channels,
+                      size_t number_of_frames,
+                      void* audio_data,
+                      int64_t* elapsed_time_ms,
+                      int64_t* ntp_time_ms) override {}
+
+  // ADM is pulling data.
+  int32_t NeedMorePlayData(const size_t nSamples,
+                           const size_t nBytesPerSample,
+                           const size_t nChannels,
+                           const uint32_t samplesPerSec,
+                           void* audioSamples,
+                           size_t& nSamplesOut,
+                           int64_t* elapsed_time_ms,
+                           int64_t* ntp_time_ms) override {
+    webrtc::MutexLock lock(&mutex_);
+    ++pull_iterations_;
+    const size_t audio_buffer_size = nSamples * nBytesPerSample;
+    const size_t bytes_out =
+        RecordedDataReceived()
+            ? CopyFromRecBuffer(audioSamples, audio_buffer_size)
+            : GenerateZeroBuffer(audioSamples, audio_buffer_size);
+    nSamplesOut = bytes_out / nBytesPerSample;
+    *elapsed_time_ms = 0;
+    *ntp_time_ms = 0;
+    return 0;
+  }
+
+  int push_iterations() const {
+    webrtc::MutexLock lock(&mutex_);
+    return push_iterations_;
+  }
+  int pull_iterations() const {
+    webrtc::MutexLock lock(&mutex_);
+    return pull_iterations_;
+  }
+
+  rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
+
+ private:
+  bool RecordedDataReceived() const { return rec_buffer_bytes_ != 0; }
+  size_t GenerateZeroBuffer(void* audio_buffer, size_t audio_buffer_size) {
+    memset(audio_buffer, 0, audio_buffer_size);
+    return audio_buffer_size;
+  }
+  size_t CopyFromRecBuffer(void* audio_buffer, size_t audio_buffer_size) {
+    EXPECT_EQ(audio_buffer_size, rec_buffer_bytes_);
+    const size_t min_buffer_size =
+        std::min(audio_buffer_size, rec_buffer_bytes_);
+    memcpy(audio_buffer, rec_buffer_, min_buffer_size);
+    return min_buffer_size;
+  }
+
+  rtc::AutoThread main_thread_;
+
+  mutable webrtc::Mutex mutex_;
+
+  int push_iterations_;
+  int pull_iterations_;
+
+  char rec_buffer_[FakeAudioCaptureModule::kNumberSamples *
+                   FakeAudioCaptureModule::kNumberBytesPerSample];
+  size_t rec_buffer_bytes_;
+};
+
+TEST_F(FakeAdmTest, PlayoutTest) {
+  EXPECT_EQ(0, fake_audio_capture_module_->RegisterAudioCallback(this));
+
+  bool stereo_available = false;
+  EXPECT_EQ(0, fake_audio_capture_module_->StereoPlayoutIsAvailable(
+                   &stereo_available));
+  EXPECT_TRUE(stereo_available);
+
+  EXPECT_NE(0, fake_audio_capture_module_->StartPlayout());
+  EXPECT_FALSE(fake_audio_capture_module_->PlayoutIsInitialized());
+  EXPECT_FALSE(fake_audio_capture_module_->Playing());
+  EXPECT_EQ(0, fake_audio_capture_module_->StopPlayout());
+
+  EXPECT_EQ(0, fake_audio_capture_module_->InitPlayout());
+  EXPECT_TRUE(fake_audio_capture_module_->PlayoutIsInitialized());
+  EXPECT_FALSE(fake_audio_capture_module_->Playing());
+
+  EXPECT_EQ(0, fake_audio_capture_module_->StartPlayout());
+  EXPECT_TRUE(fake_audio_capture_module_->Playing());
+
+  uint16_t delay_ms = 10;
+  EXPECT_EQ(0, fake_audio_capture_module_->PlayoutDelay(&delay_ms));
+  EXPECT_EQ(0, delay_ms);
+
+  EXPECT_TRUE_WAIT(pull_iterations() > 0, kMsInSecond);
+  EXPECT_GE(0, push_iterations());
+
+  EXPECT_EQ(0, fake_audio_capture_module_->StopPlayout());
+  EXPECT_FALSE(fake_audio_capture_module_->Playing());
+}
+
+TEST_F(FakeAdmTest, RecordTest) {
+  EXPECT_EQ(0, fake_audio_capture_module_->RegisterAudioCallback(this));
+
+  bool stereo_available = false;
+  EXPECT_EQ(0, fake_audio_capture_module_->StereoRecordingIsAvailable(
+                   &stereo_available));
+  EXPECT_FALSE(stereo_available);
+
+  EXPECT_NE(0, fake_audio_capture_module_->StartRecording());
+  EXPECT_FALSE(fake_audio_capture_module_->Recording());
+  EXPECT_EQ(0, fake_audio_capture_module_->StopRecording());
+
+  EXPECT_EQ(0, fake_audio_capture_module_->InitRecording());
+  EXPECT_EQ(0, fake_audio_capture_module_->StartRecording());
+  EXPECT_TRUE(fake_audio_capture_module_->Recording());
+
+  EXPECT_TRUE_WAIT(push_iterations() > 0, kMsInSecond);
+  EXPECT_GE(0, pull_iterations());
+
+  EXPECT_EQ(0, fake_audio_capture_module_->StopRecording());
+  EXPECT_FALSE(fake_audio_capture_module_->Recording());
+}
+
+TEST_F(FakeAdmTest, DuplexTest) {
+  EXPECT_EQ(0, fake_audio_capture_module_->RegisterAudioCallback(this));
+
+  EXPECT_EQ(0, fake_audio_capture_module_->InitPlayout());
+  EXPECT_EQ(0, fake_audio_capture_module_->StartPlayout());
+
+  EXPECT_EQ(0, fake_audio_capture_module_->InitRecording());
+  EXPECT_EQ(0, fake_audio_capture_module_->StartRecording());
+
+  EXPECT_TRUE_WAIT(push_iterations() > 0, kMsInSecond);
+  EXPECT_TRUE_WAIT(pull_iterations() > 0, kMsInSecond);
+
+  EXPECT_EQ(0, fake_audio_capture_module_->StopPlayout());
+  EXPECT_EQ(0, fake_audio_capture_module_->StopRecording());
+}
diff --git a/third_party/libwebrtc/pc/test/fake_data_channel_controller.h b/third_party/libwebrtc/pc/test/fake_data_channel_controller.h
new file mode 100644
index 0000000000..bdab7d2ec9
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/fake_data_channel_controller.h
@@ -0,0 +1,160 @@
+/*
+ *  Copyright 2013 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.
+ */
+
+#ifndef PC_TEST_FAKE_DATA_CHANNEL_CONTROLLER_H_
+#define PC_TEST_FAKE_DATA_CHANNEL_CONTROLLER_H_
+
+#include <set>
+
+#include "pc/sctp_data_channel.h"
+#include "rtc_base/checks.h"
+
+class FakeDataChannelController
+    : public webrtc::SctpDataChannelControllerInterface {
+ public:
+  FakeDataChannelController()
+      : send_blocked_(false),
+        transport_available_(false),
+        ready_to_send_(false),
+        transport_error_(false) {}
+  virtual ~FakeDataChannelController() {}
+
+  bool SendData(int sid,
+                const webrtc::SendDataParams& params,
+                const rtc::CopyOnWriteBuffer& payload,
+                cricket::SendDataResult* result) override {
+    RTC_CHECK(ready_to_send_);
+    RTC_CHECK(transport_available_);
+    if (send_blocked_) {
+      *result = cricket::SDR_BLOCK;
+      return false;
+    }
+
+    if (transport_error_) {
+      *result = cricket::SDR_ERROR;
+      return false;
+    }
+
+    last_sid_ = sid;
+    last_send_data_params_ = params;
+    return true;
+  }
+
+  bool ConnectDataChannel(webrtc::SctpDataChannel* data_channel) override {
+    RTC_CHECK(connected_channels_.find(data_channel) ==
+              connected_channels_.end());
+    if (!transport_available_) {
+      return false;
+    }
+    RTC_LOG(LS_INFO) << "DataChannel connected " << data_channel;
+    connected_channels_.insert(data_channel);
+    return true;
+  }
+
+  void DisconnectDataChannel(webrtc::SctpDataChannel* data_channel) override {
+    RTC_CHECK(connected_channels_.find(data_channel) !=
+              connected_channels_.end());
+    RTC_LOG(LS_INFO) << "DataChannel disconnected " << data_channel;
+    connected_channels_.erase(data_channel);
+  }
+
+  void AddSctpDataStream(int sid) override {
+    RTC_CHECK(sid >= 0);
+    if (!transport_available_) {
+      return;
+    }
+    send_ssrcs_.insert(sid);
+    recv_ssrcs_.insert(sid);
+  }
+
+  void RemoveSctpDataStream(int sid) override {
+    RTC_CHECK(sid >= 0);
+    send_ssrcs_.erase(sid);
+    recv_ssrcs_.erase(sid);
+    // Unlike the real SCTP transport, act like the closing procedure finished
+    // instantly, doing the same snapshot thing as below.
+    for (webrtc::SctpDataChannel* ch : std::set<webrtc::SctpDataChannel*>(
+             connected_channels_.begin(), connected_channels_.end())) {
+      if (connected_channels_.count(ch)) {
+        ch->OnClosingProcedureComplete(sid);
+      }
+    }
+  }
+
+  bool ReadyToSendData() const override { return ready_to_send_; }
+
+  // Set true to emulate the SCTP stream being blocked by congestion control.
+  void set_send_blocked(bool blocked) {
+    send_blocked_ = blocked;
+    if (!blocked) {
+      // Take a snapshot of the connected channels and check to see whether
+      // each value is still in connected_channels_ before calling
+      // OnTransportReady().  This avoids problems where the set gets modified
+      // in response to OnTransportReady().
+      for (webrtc::SctpDataChannel* ch : std::set<webrtc::SctpDataChannel*>(
+               connected_channels_.begin(), connected_channels_.end())) {
+        if (connected_channels_.count(ch)) {
+          ch->OnTransportReady(true);
+        }
+      }
+    }
+  }
+
+  // Set true to emulate the transport channel creation, e.g. after
+  // setLocalDescription/setRemoteDescription called with data content.
+  void set_transport_available(bool available) {
+    transport_available_ = available;
+  }
+
+  // Set true to emulate the transport ReadyToSendData signal when the transport
+  // becomes writable for the first time.
+  void set_ready_to_send(bool ready) {
+    RTC_CHECK(transport_available_);
+    ready_to_send_ = ready;
+    if (ready) {
+      std::set<webrtc::SctpDataChannel*>::iterator it;
+      for (it = connected_channels_.begin(); it != connected_channels_.end();
+           ++it) {
+        (*it)->OnTransportReady(true);
+      }
+    }
+  }
+
+  void set_transport_error() { transport_error_ = true; }
+
+  int last_sid() const { return last_sid_; }
+  const webrtc::SendDataParams& last_send_data_params() const {
+    return last_send_data_params_;
+  }
+
+  bool IsConnected(webrtc::SctpDataChannel* data_channel) const {
+    return connected_channels_.find(data_channel) != connected_channels_.end();
+  }
+
+  bool IsSendStreamAdded(uint32_t stream) const {
+    return send_ssrcs_.find(stream) != send_ssrcs_.end();
+  }
+
+  bool IsRecvStreamAdded(uint32_t stream) const {
+    return recv_ssrcs_.find(stream) != recv_ssrcs_.end();
+  }
+
+ private:
+  int last_sid_;
+  webrtc::SendDataParams last_send_data_params_;
+  bool send_blocked_;
+  bool transport_available_;
+  bool ready_to_send_;
+  bool transport_error_;
+  std::set<webrtc::SctpDataChannel*> connected_channels_;
+  std::set<uint32_t> send_ssrcs_;
+  std::set<uint32_t> recv_ssrcs_;
+};
+#endif  // PC_TEST_FAKE_DATA_CHANNEL_CONTROLLER_H_
diff --git a/third_party/libwebrtc/pc/test/fake_peer_connection_base.h b/third_party/libwebrtc/pc/test/fake_peer_connection_base.h
new file mode 100644
index 0000000000..18b8824c28
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/fake_peer_connection_base.h
@@ -0,0 +1,379 @@
+/*
+ *  Copyright 2018 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.
+ */
+
+#ifndef PC_TEST_FAKE_PEER_CONNECTION_BASE_H_
+#define PC_TEST_FAKE_PEER_CONNECTION_BASE_H_
+
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "absl/types/optional.h"
+#include "api/field_trials_view.h"
+#include "api/sctp_transport_interface.h"
+#include "pc/peer_connection_internal.h"
+#include "test/scoped_key_value_config.h"
+
+namespace webrtc {
+
+// Customized PeerConnection fakes can be created by subclassing
+// FakePeerConnectionBase then overriding the interesting methods. This class
+// takes care of providing default implementations for all the pure virtual
+// functions specified in the interfaces.
+class FakePeerConnectionBase : public PeerConnectionInternal {
+ public:
+  // PeerConnectionInterface implementation.
+
+  rtc::scoped_refptr<StreamCollectionInterface> local_streams() override {
+    return nullptr;
+  }
+
+  rtc::scoped_refptr<StreamCollectionInterface> remote_streams() override {
+    return nullptr;
+  }
+
+  bool AddStream(MediaStreamInterface* stream) override { return false; }
+
+  void RemoveStream(MediaStreamInterface* stream) override {}
+
+  RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> AddTrack(
+      rtc::scoped_refptr<MediaStreamTrackInterface> track,
+      const std::vector<std::string>& stream_ids) override {
+    return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
+  }
+
+  RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> AddTrack(
+      rtc::scoped_refptr<MediaStreamTrackInterface> track,
+      const std::vector<std::string>& stream_ids,
+      const std::vector<RtpEncodingParameters>& init_send_encodings) override {
+    return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
+  }
+
+  RTCError RemoveTrackOrError(
+      rtc::scoped_refptr<RtpSenderInterface> sender) override {
+    return RTCError(RTCErrorType::UNSUPPORTED_OPERATION);
+  }
+
+  RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
+      rtc::scoped_refptr<MediaStreamTrackInterface> track) override {
+    return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
+  }
+
+  RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
+      rtc::scoped_refptr<MediaStreamTrackInterface> track,
+      const RtpTransceiverInit& init) override {
+    return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
+  }
+
+  RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
+      cricket::MediaType media_type) override {
+    return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
+  }
+
+  RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
+      cricket::MediaType media_type,
+      const RtpTransceiverInit& init) override {
+    return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
+  }
+
+  rtc::scoped_refptr<RtpSenderInterface> CreateSender(
+      const std::string& kind,
+      const std::string& stream_id) override {
+    return nullptr;
+  }
+
+  std::vector<rtc::scoped_refptr<RtpSenderInterface>> GetSenders()
+      const override {
+    return {};
+  }
+
+  std::vector<rtc::scoped_refptr<RtpReceiverInterface>> GetReceivers()
+      const override {
+    return {};
+  }
+
+  std::vector<rtc::scoped_refptr<RtpTransceiverInterface>> GetTransceivers()
+      const override {
+    return {};
+  }
+
+  bool GetStats(StatsObserver* observer,
+                MediaStreamTrackInterface* track,
+                StatsOutputLevel level) override {
+    return false;
+  }
+
+  void GetStats(RTCStatsCollectorCallback* callback) override {}
+  void GetStats(
+      rtc::scoped_refptr<RtpSenderInterface> selector,
+      rtc::scoped_refptr<RTCStatsCollectorCallback> callback) override {}
+  void GetStats(
+      rtc::scoped_refptr<RtpReceiverInterface> selector,
+      rtc::scoped_refptr<RTCStatsCollectorCallback> callback) override {}
+
+  void ClearStatsCache() override {}
+
+  rtc::scoped_refptr<SctpTransportInterface> GetSctpTransport() const {
+    return nullptr;
+  }
+
+  RTCErrorOr<rtc::scoped_refptr<DataChannelInterface>> CreateDataChannelOrError(
+      const std::string& label,
+      const DataChannelInit* config) override {
+    return RTCError(RTCErrorType::UNSUPPORTED_OPERATION,
+                    "Fake function called");
+  }
+
+  const SessionDescriptionInterface* local_description() const override {
+    return nullptr;
+  }
+  const SessionDescriptionInterface* remote_description() const override {
+    return nullptr;
+  }
+
+  const SessionDescriptionInterface* current_local_description()
+      const override {
+    return nullptr;
+  }
+  const SessionDescriptionInterface* current_remote_description()
+      const override {
+    return nullptr;
+  }
+
+  const SessionDescriptionInterface* pending_local_description()
+      const override {
+    return nullptr;
+  }
+  const SessionDescriptionInterface* pending_remote_description()
+      const override {
+    return nullptr;
+  }
+
+  void RestartIce() override {}
+
+  void CreateOffer(CreateSessionDescriptionObserver* observer,
+                   const RTCOfferAnswerOptions& options) override {}
+
+  void CreateAnswer(CreateSessionDescriptionObserver* observer,
+                    const RTCOfferAnswerOptions& options) override {}
+
+  void SetLocalDescription(SetSessionDescriptionObserver* observer,
+                           SessionDescriptionInterface* desc) override {}
+
+  void SetRemoteDescription(SetSessionDescriptionObserver* observer,
+                            SessionDescriptionInterface* desc) override {}
+
+  void SetRemoteDescription(
+      std::unique_ptr<SessionDescriptionInterface> desc,
+      rtc::scoped_refptr<SetRemoteDescriptionObserverInterface> observer)
+      override {}
+
+  RTCConfiguration GetConfiguration() override { return RTCConfiguration(); }
+
+  RTCError SetConfiguration(
+      const PeerConnectionInterface::RTCConfiguration& config) override {
+    return RTCError();
+  }
+
+  bool AddIceCandidate(const IceCandidateInterface* candidate) override {
+    return false;
+  }
+
+  bool RemoveIceCandidates(
+      const std::vector<cricket::Candidate>& candidates) override {
+    return false;
+  }
+
+  RTCError SetBitrate(const BitrateSettings& bitrate) override {
+    return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
+  }
+
+  void SetAudioPlayout(bool playout) override {}
+
+  void SetAudioRecording(bool recording) override {}
+
+  rtc::scoped_refptr<DtlsTransportInterface> LookupDtlsTransportByMid(
+      const std::string& mid) {
+    return nullptr;
+  }
+
+  SignalingState signaling_state() override { return SignalingState::kStable; }
+
+  IceConnectionState ice_connection_state() override {
+    return IceConnectionState::kIceConnectionNew;
+  }
+
+  IceConnectionState standardized_ice_connection_state() override {
+    return IceConnectionState::kIceConnectionNew;
+  }
+
+  PeerConnectionState peer_connection_state() override {
+    return PeerConnectionState::kNew;
+  }
+
+  IceGatheringState ice_gathering_state() override {
+    return IceGatheringState::kIceGatheringNew;
+  }
+
+  absl::optional<bool> can_trickle_ice_candidates() { return absl::nullopt; }
+
+  bool StartRtcEventLog(std::unique_ptr<RtcEventLogOutput> output,
+                        int64_t output_period_ms) override {
+    return false;
+  }
+
+  bool StartRtcEventLog(std::unique_ptr<RtcEventLogOutput> output) override {
+    return false;
+  }
+
+  void StopRtcEventLog() override {}
+
+  void Close() override {}
+
+  // PeerConnectionInternal implementation.
+
+  rtc::Thread* network_thread() const override { return nullptr; }
+  rtc::Thread* worker_thread() const override { return nullptr; }
+  rtc::Thread* signaling_thread() const override { return nullptr; }
+
+  std::string session_id() const override { return ""; }
+
+  bool initial_offerer() const override { return false; }
+
+  std::vector<
+      rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>
+  GetTransceiversInternal() const override {
+    return {};
+  }
+
+  sigslot::signal1<SctpDataChannel*>& SignalSctpDataChannelCreated() override {
+    return SignalSctpDataChannelCreated_;
+  }
+
+  absl::optional<std::string> sctp_transport_name() const override {
+    return absl::nullopt;
+  }
+
+  absl::optional<std::string> sctp_mid() const override {
+    return absl::nullopt;
+  }
+
+  std::map<std::string, cricket::TransportStats> GetTransportStatsByNames(
+      const std::set<std::string>& transport_names) override {
+    return {};
+  }
+
+  Call::Stats GetCallStats() override { return Call::Stats(); }
+
+  absl::optional<AudioDeviceModule::Stats> GetAudioDeviceStats() override {
+    return absl::nullopt;
+  }
+
+  bool GetLocalCertificate(
+      const std::string& transport_name,
+      rtc::scoped_refptr<rtc::RTCCertificate>* certificate) override {
+    return false;
+  }
+
+  std::unique_ptr<rtc::SSLCertChain> GetRemoteSSLCertChain(
+      const std::string& transport_name) override {
+    return nullptr;
+  }
+
+  bool IceRestartPending(const std::string& content_name) const override {
+    return false;
+  }
+
+  bool NeedsIceRestart(const std::string& content_name) const override {
+    return false;
+  }
+
+  bool GetSslRole(const std::string& content_name,
+                  rtc::SSLRole* role) override {
+    return false;
+  }
+  const PeerConnectionInterface::RTCConfiguration* configuration()
+      const override {
+    return nullptr;
+  }
+
+  void ReportSdpBundleUsage(
+      const SessionDescriptionInterface& remote_description) override {}
+
+  PeerConnectionMessageHandler* message_handler() override { return nullptr; }
+  RtpTransmissionManager* rtp_manager() override { return nullptr; }
+  const RtpTransmissionManager* rtp_manager() const override { return nullptr; }
+  bool dtls_enabled() const override { return false; }
+  const PeerConnectionFactoryInterface::Options* options() const override {
+    return nullptr;
+  }
+
+  CryptoOptions GetCryptoOptions() override { return CryptoOptions(); }
+  JsepTransportController* transport_controller_s() override { return nullptr; }
+  JsepTransportController* transport_controller_n() override { return nullptr; }
+  DataChannelController* data_channel_controller() override { return nullptr; }
+  cricket::PortAllocator* port_allocator() override { return nullptr; }
+  LegacyStatsCollector* legacy_stats() override { return nullptr; }
+  PeerConnectionObserver* Observer() const override { return nullptr; }
+  bool GetSctpSslRole(rtc::SSLRole* role) override { return false; }
+  PeerConnectionInterface::IceConnectionState ice_connection_state_internal()
+      override {
+    return PeerConnectionInterface::IceConnectionState::kIceConnectionNew;
+  }
+  void SetIceConnectionState(
+      PeerConnectionInterface::IceConnectionState new_state) override {}
+  void NoteUsageEvent(UsageEvent event) override {}
+  bool IsClosed() const override { return false; }
+  bool IsUnifiedPlan() const override { return true; }
+  bool ValidateBundleSettings(
+      const cricket::SessionDescription* desc,
+      const std::map<std::string, const cricket::ContentGroup*>&
+          bundle_groups_by_mid) override {
+    return false;
+  }
+
+  absl::optional<std::string> GetDataMid() const override {
+    return absl::nullopt;
+  }
+  RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
+      cricket::MediaType media_type,
+      rtc::scoped_refptr<MediaStreamTrackInterface> track,
+      const RtpTransceiverInit& init,
+      bool fire_callback = true) override {
+    return RTCError(RTCErrorType::INTERNAL_ERROR, "");
+  }
+  void StartSctpTransport(int local_port,
+                          int remote_port,
+                          int max_message_size) override {}
+
+  void AddRemoteCandidate(const std::string& mid,
+                          const cricket::Candidate& candidate) override {}
+
+  Call* call_ptr() override { return nullptr; }
+  bool SrtpRequired() const override { return false; }
+  bool SetupDataChannelTransport_n(const std::string& mid) override {
+    return false;
+  }
+  void TeardownDataChannelTransport_n() override {}
+  void SetSctpDataMid(const std::string& mid) override {}
+  void ResetSctpDataMid() override {}
+
+  const FieldTrialsView& trials() const override { return field_trials_; }
+
+ protected:
+  webrtc::test::ScopedKeyValueConfig field_trials_;
+  sigslot::signal1<SctpDataChannel*> SignalSctpDataChannelCreated_;
+};
+
+}  // namespace webrtc
+
+#endif  // PC_TEST_FAKE_PEER_CONNECTION_BASE_H_
diff --git a/third_party/libwebrtc/pc/test/fake_peer_connection_for_stats.h b/third_party/libwebrtc/pc/test/fake_peer_connection_for_stats.h
new file mode 100644
index 0000000000..b771d45a0b
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/fake_peer_connection_for_stats.h
@@ -0,0 +1,512 @@
+/*
+ *  Copyright 2018 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.
+ */
+
+#ifndef PC_TEST_FAKE_PEER_CONNECTION_FOR_STATS_H_
+#define PC_TEST_FAKE_PEER_CONNECTION_FOR_STATS_H_
+
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "media/base/fake_media_engine.h"
+#include "pc/channel.h"
+#include "pc/stream_collection.h"
+#include "pc/test/fake_data_channel_controller.h"
+#include "pc/test/fake_peer_connection_base.h"
+
+namespace webrtc {
+
+// Fake VoiceMediaChannel where the result of GetStats can be configured.
+class FakeVoiceMediaChannelForStats : public cricket::FakeVoiceMediaChannel {
+ public:
+  explicit FakeVoiceMediaChannelForStats(TaskQueueBase* network_thread)
+      : cricket::FakeVoiceMediaChannel(nullptr,
+                                       cricket::AudioOptions(),
+                                       network_thread) {}
+
+  void SetStats(const cricket::VoiceMediaInfo& voice_info) {
+    send_stats_ = cricket::VoiceMediaSendInfo();
+    send_stats_->senders = voice_info.senders;
+    send_stats_->send_codecs = voice_info.send_codecs;
+    receive_stats_ = cricket::VoiceMediaReceiveInfo();
+    receive_stats_->receivers = voice_info.receivers;
+    receive_stats_->receive_codecs = voice_info.receive_codecs;
+    receive_stats_->device_underrun_count = voice_info.device_underrun_count;
+  }
+
+  // VoiceMediaChannel overrides.
+  bool GetSendStats(cricket::VoiceMediaSendInfo* info) override {
+    if (send_stats_) {
+      *info = *send_stats_;
+      return true;
+    }
+    return false;
+  }
+  bool GetReceiveStats(cricket::VoiceMediaReceiveInfo* info,
+                       bool get_and_clear_legacy_stats) override {
+    if (receive_stats_) {
+      *info = *receive_stats_;
+      return true;
+    }
+    return false;
+  }
+
+ private:
+  absl::optional<cricket::VoiceMediaSendInfo> send_stats_;
+  absl::optional<cricket::VoiceMediaReceiveInfo> receive_stats_;
+};
+
+// Fake VideoMediaChannel where the result of GetStats can be configured.
+class FakeVideoMediaChannelForStats : public cricket::FakeVideoMediaChannel {
+ public:
+  explicit FakeVideoMediaChannelForStats(TaskQueueBase* network_thread)
+      : cricket::FakeVideoMediaChannel(nullptr,
+                                       cricket::VideoOptions(),
+                                       network_thread) {}
+
+  void SetStats(const cricket::VideoMediaInfo& video_info) {
+    send_stats_ = cricket::VideoMediaSendInfo();
+    send_stats_->senders = video_info.senders;
+    send_stats_->aggregated_senders = video_info.aggregated_senders;
+    send_stats_->send_codecs = video_info.send_codecs;
+    receive_stats_ = cricket::VideoMediaReceiveInfo();
+    receive_stats_->receivers = video_info.receivers;
+    receive_stats_->receive_codecs = video_info.receive_codecs;
+  }
+
+  // VideoMediaChannel overrides.
+  bool GetSendStats(cricket::VideoMediaSendInfo* info) override {
+    if (send_stats_) {
+      *info = *send_stats_;
+      return true;
+    }
+    return false;
+  }
+  bool GetReceiveStats(cricket::VideoMediaReceiveInfo* info) override {
+    if (receive_stats_) {
+      *info = *receive_stats_;
+      return true;
+    }
+    return false;
+  }
+
+ private:
+  absl::optional<cricket::VideoMediaSendInfo> send_stats_;
+  absl::optional<cricket::VideoMediaReceiveInfo> receive_stats_;
+};
+
+constexpr bool kDefaultRtcpMuxRequired = true;
+constexpr bool kDefaultSrtpRequired = true;
+
+class VoiceChannelForTesting : public cricket::VoiceChannel {
+ public:
+  VoiceChannelForTesting(rtc::Thread* worker_thread,
+                         rtc::Thread* network_thread,
+                         rtc::Thread* signaling_thread,
+                         std::unique_ptr<cricket::VoiceMediaChannel> channel,
+                         const std::string& content_name,
+                         bool srtp_required,
+                         webrtc::CryptoOptions crypto_options,
+                         rtc::UniqueRandomIdGenerator* ssrc_generator,
+                         std::string transport_name)
+      : VoiceChannel(worker_thread,
+                     network_thread,
+                     signaling_thread,
+                     std::move(channel),
+                     content_name,
+                     srtp_required,
+                     std::move(crypto_options),
+                     ssrc_generator),
+        test_transport_name_(std::move(transport_name)) {}
+
+ private:
+  absl::string_view transport_name() const override {
+    return test_transport_name_;
+  }
+
+  const std::string test_transport_name_;
+};
+
+class VideoChannelForTesting : public cricket::VideoChannel {
+ public:
+  VideoChannelForTesting(rtc::Thread* worker_thread,
+                         rtc::Thread* network_thread,
+                         rtc::Thread* signaling_thread,
+                         std::unique_ptr<cricket::VideoMediaChannel> channel,
+                         const std::string& content_name,
+                         bool srtp_required,
+                         webrtc::CryptoOptions crypto_options,
+                         rtc::UniqueRandomIdGenerator* ssrc_generator,
+                         std::string transport_name)
+      : VideoChannel(worker_thread,
+                     network_thread,
+                     signaling_thread,
+                     std::move(channel),
+                     content_name,
+                     srtp_required,
+                     std::move(crypto_options),
+                     ssrc_generator),
+        test_transport_name_(std::move(transport_name)) {}
+
+ private:
+  absl::string_view transport_name() const override {
+    return test_transport_name_;
+  }
+
+  const std::string test_transport_name_;
+};
+
+// This class is intended to be fed into the StatsCollector and
+// RTCStatsCollector so that the stats functionality can be unit tested.
+// Individual tests can configure this fake as needed to simulate scenarios
+// under which to test the stats collectors.
+class FakePeerConnectionForStats : public FakePeerConnectionBase {
+ public:
+  // TODO(steveanton): Add support for specifying separate threads to test
+  // multi-threading correctness.
+  FakePeerConnectionForStats()
+      : network_thread_(rtc::Thread::Current()),
+        worker_thread_(rtc::Thread::Current()),
+        signaling_thread_(rtc::Thread::Current()),
+        // TODO(hta): remove separate thread variables and use context.
+        dependencies_(MakeDependencies()),
+        context_(ConnectionContext::Create(&dependencies_)),
+        local_streams_(StreamCollection::Create()),
+        remote_streams_(StreamCollection::Create()) {}
+
+  ~FakePeerConnectionForStats() {
+    for (auto transceiver : transceivers_) {
+      transceiver->internal()->ClearChannel();
+    }
+  }
+
+  static PeerConnectionFactoryDependencies MakeDependencies() {
+    PeerConnectionFactoryDependencies dependencies;
+    dependencies.network_thread = rtc::Thread::Current();
+    dependencies.worker_thread = rtc::Thread::Current();
+    dependencies.signaling_thread = rtc::Thread::Current();
+    dependencies.media_engine = std::make_unique<cricket::FakeMediaEngine>();
+    return dependencies;
+  }
+
+  rtc::scoped_refptr<StreamCollection> mutable_local_streams() {
+    return local_streams_;
+  }
+
+  rtc::scoped_refptr<StreamCollection> mutable_remote_streams() {
+    return remote_streams_;
+  }
+
+  rtc::scoped_refptr<RtpSenderInterface> AddSender(
+      rtc::scoped_refptr<RtpSenderInternal> sender) {
+    // TODO(steveanton): Switch tests to use RtpTransceivers directly.
+    auto sender_proxy = RtpSenderProxyWithInternal<RtpSenderInternal>::Create(
+        signaling_thread_, sender);
+    GetOrCreateFirstTransceiverOfType(sender->media_type())
+        ->internal()
+        ->AddSender(sender_proxy);
+    return sender_proxy;
+  }
+
+  void RemoveSender(rtc::scoped_refptr<RtpSenderInterface> sender) {
+    GetOrCreateFirstTransceiverOfType(sender->media_type())
+        ->internal()
+        ->RemoveSender(sender.get());
+  }
+
+  rtc::scoped_refptr<RtpReceiverInterface> AddReceiver(
+      rtc::scoped_refptr<RtpReceiverInternal> receiver) {
+    // TODO(steveanton): Switch tests to use RtpTransceivers directly.
+    auto receiver_proxy =
+        RtpReceiverProxyWithInternal<RtpReceiverInternal>::Create(
+            signaling_thread_, worker_thread_, receiver);
+    GetOrCreateFirstTransceiverOfType(receiver->media_type())
+        ->internal()
+        ->AddReceiver(receiver_proxy);
+    return receiver_proxy;
+  }
+
+  void RemoveReceiver(rtc::scoped_refptr<RtpReceiverInterface> receiver) {
+    GetOrCreateFirstTransceiverOfType(receiver->media_type())
+        ->internal()
+        ->RemoveReceiver(receiver.get());
+  }
+
+  FakeVoiceMediaChannelForStats* AddVoiceChannel(
+      const std::string& mid,
+      const std::string& transport_name,
+      cricket::VoiceMediaInfo initial_stats = cricket::VoiceMediaInfo()) {
+    auto voice_media_channel =
+        std::make_unique<FakeVoiceMediaChannelForStats>(network_thread_);
+    auto* voice_media_channel_ptr = voice_media_channel.get();
+    auto voice_channel = std::make_unique<VoiceChannelForTesting>(
+        worker_thread_, network_thread_, signaling_thread_,
+        std::move(voice_media_channel), mid, kDefaultSrtpRequired,
+        webrtc::CryptoOptions(), context_->ssrc_generator(), transport_name);
+    auto transceiver =
+        GetOrCreateFirstTransceiverOfType(cricket::MEDIA_TYPE_AUDIO)
+            ->internal();
+    if (transceiver->channel()) {
+      // This transceiver already has a channel, create a new one.
+      transceiver =
+          CreateTransceiverOfType(cricket::MEDIA_TYPE_AUDIO)->internal();
+    }
+    RTC_DCHECK(!transceiver->channel());
+    transceiver->SetChannel(std::move(voice_channel),
+                            [](const std::string&) { return nullptr; });
+    voice_media_channel_ptr->SetStats(initial_stats);
+    return voice_media_channel_ptr;
+  }
+
+  FakeVideoMediaChannelForStats* AddVideoChannel(
+      const std::string& mid,
+      const std::string& transport_name,
+      cricket::VideoMediaInfo initial_stats = cricket::VideoMediaInfo()) {
+    auto video_media_channel =
+        std::make_unique<FakeVideoMediaChannelForStats>(network_thread_);
+    auto video_media_channel_ptr = video_media_channel.get();
+    auto video_channel = std::make_unique<VideoChannelForTesting>(
+        worker_thread_, network_thread_, signaling_thread_,
+        std::move(video_media_channel), mid, kDefaultSrtpRequired,
+        webrtc::CryptoOptions(), context_->ssrc_generator(), transport_name);
+    auto transceiver =
+        GetOrCreateFirstTransceiverOfType(cricket::MEDIA_TYPE_VIDEO)
+            ->internal();
+    if (transceiver->channel()) {
+      // This transceiver already has a channel, create a new one.
+      transceiver =
+          CreateTransceiverOfType(cricket::MEDIA_TYPE_VIDEO)->internal();
+    }
+    RTC_DCHECK(!transceiver->channel());
+    transceiver->SetChannel(std::move(video_channel),
+                            [](const std::string&) { return nullptr; });
+    video_media_channel_ptr->SetStats(initial_stats);
+    return video_media_channel_ptr;
+  }
+
+  void AddSctpDataChannel(const std::string& label) {
+    AddSctpDataChannel(label, InternalDataChannelInit());
+  }
+
+  void AddSctpDataChannel(const std::string& label,
+                          const InternalDataChannelInit& init) {
+    // TODO(bugs.webrtc.org/11547): Supply a separate network thread.
+    AddSctpDataChannel(SctpDataChannel::Create(&data_channel_controller_, label,
+                                               init, rtc::Thread::Current(),
+                                               rtc::Thread::Current()));
+  }
+
+  void AddSctpDataChannel(rtc::scoped_refptr<SctpDataChannel> data_channel) {
+    sctp_data_channels_.push_back(data_channel);
+  }
+
+  void SetTransportStats(const std::string& transport_name,
+                         const cricket::TransportChannelStats& channel_stats) {
+    SetTransportStats(
+        transport_name,
+        std::vector<cricket::TransportChannelStats>{channel_stats});
+  }
+
+  void SetTransportStats(
+      const std::string& transport_name,
+      const std::vector<cricket::TransportChannelStats>& channel_stats_list) {
+    cricket::TransportStats transport_stats;
+    transport_stats.transport_name = transport_name;
+    transport_stats.channel_stats = channel_stats_list;
+    transport_stats_by_name_[transport_name] = transport_stats;
+  }
+
+  void SetCallStats(const Call::Stats& call_stats) { call_stats_ = call_stats; }
+
+  void SetAudioDeviceStats(
+      absl::optional<AudioDeviceModule::Stats> audio_device_stats) {
+    audio_device_stats_ = audio_device_stats;
+  }
+
+  void SetLocalCertificate(
+      const std::string& transport_name,
+      rtc::scoped_refptr<rtc::RTCCertificate> certificate) {
+    local_certificates_by_transport_[transport_name] = certificate;
+  }
+
+  void SetRemoteCertChain(const std::string& transport_name,
+                          std::unique_ptr<rtc::SSLCertChain> chain) {
+    remote_cert_chains_by_transport_[transport_name] = std::move(chain);
+  }
+
+  // PeerConnectionInterface overrides.
+
+  rtc::scoped_refptr<StreamCollectionInterface> local_streams() override {
+    return local_streams_;
+  }
+
+  rtc::scoped_refptr<StreamCollectionInterface> remote_streams() override {
+    return remote_streams_;
+  }
+
+  std::vector<rtc::scoped_refptr<RtpSenderInterface>> GetSenders()
+      const override {
+    std::vector<rtc::scoped_refptr<RtpSenderInterface>> senders;
+    for (auto transceiver : transceivers_) {
+      for (auto sender : transceiver->internal()->senders()) {
+        senders.push_back(sender);
+      }
+    }
+    return senders;
+  }
+
+  std::vector<rtc::scoped_refptr<RtpReceiverInterface>> GetReceivers()
+      const override {
+    std::vector<rtc::scoped_refptr<RtpReceiverInterface>> receivers;
+    for (auto transceiver : transceivers_) {
+      for (auto receiver : transceiver->internal()->receivers()) {
+        receivers.push_back(receiver);
+      }
+    }
+    return receivers;
+  }
+
+  // PeerConnectionInternal overrides.
+
+  rtc::Thread* network_thread() const override { return network_thread_; }
+
+  rtc::Thread* worker_thread() const override { return worker_thread_; }
+
+  rtc::Thread* signaling_thread() const override { return signaling_thread_; }
+
+  std::vector<
+      rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>
+  GetTransceiversInternal() const override {
+    return transceivers_;
+  }
+
+  std::vector<DataChannelStats> GetDataChannelStats() const override {
+    RTC_DCHECK_RUN_ON(signaling_thread());
+    std::vector<DataChannelStats> stats;
+    for (const auto& channel : sctp_data_channels_)
+      stats.push_back(channel->GetStats());
+    return stats;
+  }
+
+  cricket::CandidateStatsList GetPooledCandidateStats() const override {
+    return {};
+  }
+
+  std::map<std::string, cricket::TransportStats> GetTransportStatsByNames(
+      const std::set<std::string>& transport_names) override {
+    RTC_DCHECK_RUN_ON(network_thread_);
+    std::map<std::string, cricket::TransportStats> transport_stats_by_name;
+    for (const std::string& transport_name : transport_names) {
+      transport_stats_by_name[transport_name] =
+          GetTransportStatsByName(transport_name);
+    }
+    return transport_stats_by_name;
+  }
+
+  Call::Stats GetCallStats() override { return call_stats_; }
+
+  absl::optional<AudioDeviceModule::Stats> GetAudioDeviceStats() override {
+    return audio_device_stats_;
+  }
+
+  bool GetLocalCertificate(
+      const std::string& transport_name,
+      rtc::scoped_refptr<rtc::RTCCertificate>* certificate) override {
+    auto it = local_certificates_by_transport_.find(transport_name);
+    if (it != local_certificates_by_transport_.end()) {
+      *certificate = it->second;
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  std::unique_ptr<rtc::SSLCertChain> GetRemoteSSLCertChain(
+      const std::string& transport_name) override {
+    auto it = remote_cert_chains_by_transport_.find(transport_name);
+    if (it != remote_cert_chains_by_transport_.end()) {
+      return it->second->Clone();
+    } else {
+      return nullptr;
+    }
+  }
+
+ private:
+  cricket::TransportStats GetTransportStatsByName(
+      const std::string& transport_name) {
+    auto it = transport_stats_by_name_.find(transport_name);
+    if (it != transport_stats_by_name_.end()) {
+      // If specific transport stats have been specified, return those.
+      return it->second;
+    }
+    // Otherwise, generate some dummy stats.
+    cricket::TransportChannelStats channel_stats;
+    channel_stats.component = cricket::ICE_CANDIDATE_COMPONENT_RTP;
+    cricket::TransportStats transport_stats;
+    transport_stats.transport_name = transport_name;
+    transport_stats.channel_stats.push_back(channel_stats);
+    return transport_stats;
+  }
+
+  rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
+  GetOrCreateFirstTransceiverOfType(cricket::MediaType media_type) {
+    for (auto transceiver : transceivers_) {
+      if (transceiver->internal()->media_type() == media_type) {
+        return transceiver;
+      }
+    }
+    return CreateTransceiverOfType(media_type);
+  }
+
+  rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
+  CreateTransceiverOfType(cricket::MediaType media_type) {
+    auto transceiver = RtpTransceiverProxyWithInternal<RtpTransceiver>::Create(
+        signaling_thread_,
+        rtc::make_ref_counted<RtpTransceiver>(media_type, context_.get()));
+    transceivers_.push_back(transceiver);
+    return transceiver;
+  }
+
+  rtc::Thread* const network_thread_;
+  rtc::Thread* const worker_thread_;
+  rtc::Thread* const signaling_thread_;
+
+  PeerConnectionFactoryDependencies dependencies_;
+  rtc::scoped_refptr<ConnectionContext> context_;
+
+  rtc::scoped_refptr<StreamCollection> local_streams_;
+  rtc::scoped_refptr<StreamCollection> remote_streams_;
+
+  std::vector<
+      rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>
+      transceivers_;
+
+  FakeDataChannelController data_channel_controller_;
+
+  std::vector<rtc::scoped_refptr<SctpDataChannel>> sctp_data_channels_;
+
+  std::map<std::string, cricket::TransportStats> transport_stats_by_name_;
+
+  Call::Stats call_stats_;
+
+  absl::optional<AudioDeviceModule::Stats> audio_device_stats_;
+
+  std::map<std::string, rtc::scoped_refptr<rtc::RTCCertificate>>
+      local_certificates_by_transport_;
+  std::map<std::string, std::unique_ptr<rtc::SSLCertChain>>
+      remote_cert_chains_by_transport_;
+};
+
+}  // namespace webrtc
+
+#endif  // PC_TEST_FAKE_PEER_CONNECTION_FOR_STATS_H_
diff --git a/third_party/libwebrtc/pc/test/fake_periodic_video_source.h b/third_party/libwebrtc/pc/test/fake_periodic_video_source.h
new file mode 100644
index 0000000000..871c29cbae
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/fake_periodic_video_source.h
@@ -0,0 +1,101 @@
+/*
+ *  Copyright 2018 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.
+ */
+
+#ifndef PC_TEST_FAKE_PERIODIC_VIDEO_SOURCE_H_
+#define PC_TEST_FAKE_PERIODIC_VIDEO_SOURCE_H_
+
+#include <memory>
+
+#include "api/video/video_source_interface.h"
+#include "media/base/fake_frame_source.h"
+#include "media/base/video_broadcaster.h"
+#include "rtc_base/synchronization/mutex.h"
+#include "rtc_base/task_queue_for_test.h"
+#include "rtc_base/task_utils/repeating_task.h"
+
+namespace webrtc {
+
+class FakePeriodicVideoSource final
+    : public rtc::VideoSourceInterface<VideoFrame> {
+ public:
+  static constexpr int kDefaultFrameIntervalMs = 33;
+  static constexpr int kDefaultWidth = 640;
+  static constexpr int kDefaultHeight = 480;
+
+  struct Config {
+    int width = kDefaultWidth;
+    int height = kDefaultHeight;
+    int frame_interval_ms = kDefaultFrameIntervalMs;
+    VideoRotation rotation = kVideoRotation_0;
+    int64_t timestamp_offset_ms = 0;
+  };
+
+  FakePeriodicVideoSource() : FakePeriodicVideoSource(Config()) {}
+  explicit FakePeriodicVideoSource(Config config)
+      : frame_source_(
+            config.width,
+            config.height,
+            config.frame_interval_ms * rtc::kNumMicrosecsPerMillisec,
+            config.timestamp_offset_ms * rtc::kNumMicrosecsPerMillisec),
+        task_queue_(std::make_unique<TaskQueueForTest>(
+            "FakePeriodicVideoTrackSource")) {
+    thread_checker_.Detach();
+    frame_source_.SetRotation(config.rotation);
+
+    TimeDelta frame_interval = TimeDelta::Millis(config.frame_interval_ms);
+    RepeatingTaskHandle::Start(task_queue_->Get(), [this, frame_interval] {
+      if (broadcaster_.wants().rotation_applied) {
+        broadcaster_.OnFrame(frame_source_.GetFrameRotationApplied());
+      } else {
+        broadcaster_.OnFrame(frame_source_.GetFrame());
+      }
+      return frame_interval;
+    });
+  }
+
+  rtc::VideoSinkWants wants() const {
+    MutexLock lock(&mutex_);
+    return wants_;
+  }
+
+  void RemoveSink(rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override {
+    RTC_DCHECK(thread_checker_.IsCurrent());
+    broadcaster_.RemoveSink(sink);
+  }
+
+  void AddOrUpdateSink(rtc::VideoSinkInterface<webrtc::VideoFrame>* sink,
+                       const rtc::VideoSinkWants& wants) override {
+    RTC_DCHECK(thread_checker_.IsCurrent());
+    {
+      MutexLock lock(&mutex_);
+      wants_ = wants;
+    }
+    broadcaster_.AddOrUpdateSink(sink, wants);
+  }
+
+  void Stop() {
+    RTC_DCHECK(task_queue_);
+    task_queue_.reset();
+  }
+
+ private:
+  SequenceChecker thread_checker_;
+
+  rtc::VideoBroadcaster broadcaster_;
+  cricket::FakeFrameSource frame_source_;
+  mutable Mutex mutex_;
+  rtc::VideoSinkWants wants_ RTC_GUARDED_BY(&mutex_);
+
+  std::unique_ptr<TaskQueueForTest> task_queue_;
+};
+
+}  // namespace webrtc
+
+#endif  // PC_TEST_FAKE_PERIODIC_VIDEO_SOURCE_H_
diff --git a/third_party/libwebrtc/pc/test/fake_periodic_video_track_source.h b/third_party/libwebrtc/pc/test/fake_periodic_video_track_source.h
new file mode 100644
index 0000000000..98a456f232
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/fake_periodic_video_track_source.h
@@ -0,0 +1,45 @@
+/*
+ *  Copyright 2018 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.
+ */
+
+#ifndef PC_TEST_FAKE_PERIODIC_VIDEO_TRACK_SOURCE_H_
+#define PC_TEST_FAKE_PERIODIC_VIDEO_TRACK_SOURCE_H_
+
+#include "pc/test/fake_periodic_video_source.h"
+#include "pc/video_track_source.h"
+
+namespace webrtc {
+
+// A VideoTrackSource generating frames with configured size and frame interval.
+class FakePeriodicVideoTrackSource : public VideoTrackSource {
+ public:
+  explicit FakePeriodicVideoTrackSource(bool remote)
+      : FakePeriodicVideoTrackSource(FakePeriodicVideoSource::Config(),
+                                     remote) {}
+
+  FakePeriodicVideoTrackSource(FakePeriodicVideoSource::Config config,
+                               bool remote)
+      : VideoTrackSource(remote), source_(config) {}
+
+  ~FakePeriodicVideoTrackSource() = default;
+
+  const FakePeriodicVideoSource& fake_periodic_source() const {
+    return source_;
+  }
+
+ protected:
+  rtc::VideoSourceInterface<VideoFrame>* source() override { return &source_; }
+
+ private:
+  FakePeriodicVideoSource source_;
+};
+
+}  // namespace webrtc
+
+#endif  // PC_TEST_FAKE_PERIODIC_VIDEO_TRACK_SOURCE_H_
diff --git a/third_party/libwebrtc/pc/test/fake_rtc_certificate_generator.h b/third_party/libwebrtc/pc/test/fake_rtc_certificate_generator.h
new file mode 100644
index 0000000000..61da26a12f
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/fake_rtc_certificate_generator.h
@@ -0,0 +1,222 @@
+/*
+ *  Copyright 2013 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.
+ */
+
+#ifndef PC_TEST_FAKE_RTC_CERTIFICATE_GENERATOR_H_
+#define PC_TEST_FAKE_RTC_CERTIFICATE_GENERATOR_H_
+
+#include <string>
+#include <utility>
+
+#include "absl/types/optional.h"
+#include "api/peer_connection_interface.h"
+#include "api/task_queue/task_queue_base.h"
+#include "api/units/time_delta.h"
+#include "rtc_base/rtc_certificate.h"
+#include "rtc_base/rtc_certificate_generator.h"
+
+// RSA with mod size 1024, pub exp 0x10001.
+static const rtc::RTCCertificatePEM kRsaPems[] = {
+    rtc::RTCCertificatePEM(
+        "-----BEGIN RSA PRIVATE KEY-----\n"
+        "MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAMYRkbhmI7kVA/rM\n"
+        "czsZ+6JDhDvnkF+vn6yCAGuRPV03zuRqZtDy4N4to7PZu9PjqrRl7nDMXrG3YG9y\n"
+        "rlIAZ72KjcKKFAJxQyAKLCIdawKRyp8RdK3LEySWEZb0AV58IadqPZDTNHHRX8dz\n"
+        "5aTSMsbbkZ+C/OzTnbiMqLL/vg6jAgMBAAECgYAvgOs4FJcgvp+TuREx7YtiYVsH\n"
+        "mwQPTum2z/8VzWGwR8BBHBvIpVe1MbD/Y4seyI2aco/7UaisatSgJhsU46/9Y4fq\n"
+        "2TwXH9QANf4at4d9n/R6rzwpAJOpgwZgKvdQjkfrKTtgLV+/dawvpxUYkRH4JZM1\n"
+        "CVGukMfKNrSVH4Ap4QJBAOJmGV1ASPnB4r4nc99at7JuIJmd7fmuVUwUgYi4XgaR\n"
+        "WhScBsgYwZ/JoywdyZJgnbcrTDuVcWG56B3vXbhdpMsCQQDf9zeJrjnPZ3Cqm79y\n"
+        "kdqANep0uwZciiNiWxsQrCHztywOvbFhdp8iYVFG9EK8DMY41Y5TxUwsHD+67zao\n"
+        "ZNqJAkEA1suLUP/GvL8IwuRneQd2tWDqqRQ/Td3qq03hP7e77XtF/buya3Ghclo5\n"
+        "54czUR89QyVfJEC6278nzA7n2h1uVQJAcG6mztNL6ja/dKZjYZye2CY44QjSlLo0\n"
+        "MTgTSjdfg/28fFn2Jjtqf9Pi/X+50LWI/RcYMC2no606wRk9kyOuIQJBAK6VSAim\n"
+        "1pOEjsYQn0X5KEIrz1G3bfCbB848Ime3U2/FWlCHMr6ch8kCZ5d1WUeJD3LbwMNG\n"
+        "UCXiYxSsu20QNVw=\n"
+        "-----END RSA PRIVATE KEY-----\n",
+        "-----BEGIN CERTIFICATE-----\n"
+        "MIIBmTCCAQKgAwIBAgIEbzBSAjANBgkqhkiG9w0BAQsFADARMQ8wDQYDVQQDEwZX\n"
+        "ZWJSVEMwHhcNMTQwMTAyMTgyNDQ3WhcNMTQwMjAxMTgyNDQ3WjARMQ8wDQYDVQQD\n"
+        "EwZXZWJSVEMwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMYRkbhmI7kVA/rM\n"
+        "czsZ+6JDhDvnkF+vn6yCAGuRPV03zuRqZtDy4N4to7PZu9PjqrRl7nDMXrG3YG9y\n"
+        "rlIAZ72KjcKKFAJxQyAKLCIdawKRyp8RdK3LEySWEZb0AV58IadqPZDTNHHRX8dz\n"
+        "5aTSMsbbkZ+C/OzTnbiMqLL/vg6jAgMBAAEwDQYJKoZIhvcNAQELBQADgYEAUflI\n"
+        "VUe5Krqf5RVa5C3u/UTAOAUJBiDS3VANTCLBxjuMsvqOG0WvaYWP3HYPgrz0jXK2\n"
+        "LJE/mGw3MyFHEqi81jh95J+ypl6xKW6Rm8jKLR87gUvCaVYn/Z4/P3AqcQTB7wOv\n"
+        "UD0A8qfhfDM+LK6rPAnCsVN0NRDY3jvd6rzix9M=\n"
+        "-----END CERTIFICATE-----\n"),
+    rtc::RTCCertificatePEM(
+        "-----BEGIN RSA PRIVATE KEY-----\n"
+        "MIICXQIBAAKBgQDeYqlyJ1wuiMsi905e3X81/WA/G3ym50PIDZBVtSwZi7JVQPgj\n"
+        "Bl8CPZMvDh9EwB4Ji9ytA8dZZbQ4WbJWPr73zPpJSCvQqz6sOXSlenBRi72acNaQ\n"
+        "sOR/qPvviJx5I6Hqo4qemfnjZhAW85a5BpgrAwKgMLIQTHCTLWwVSyrDrwIDAQAB\n"
+        "AoGARni9eY8/hv+SX+I+05EdXt6MQXNUbQ+cSykBNCfVccLzIFEWUQMT2IHqwl6X\n"
+        "ShIXcq7/n1QzOAEiuzixauM3YHg4xZ1Um2Ha9a7ig5Xg4v6b43bmMkNE6LkoAtYs\n"
+        "qnQdfMh442b1liDud6IMb1Qk0amt3fSrgRMc547TZQVx4QECQQDxUeDm94r3p4ng\n"
+        "5rCLLC1K5/6HSTZsh7jatKPlz7GfP/IZlYV7iE5784/n0wRiCjZOS7hQRy/8m2Gp\n"
+        "pf4aZq+DAkEA6+np4d36FYikydvUrupLT3FkdRHGn/v83qOll/VmeNh+L1xMZlIP\n"
+        "tM26hAXCcQb7O5+J9y3cx2CAQsBS11ZXZQJAfGgTo76WG9p5UEJdXUInD2jOZPwv\n"
+        "XIATolxh6kXKcijLLLlSmT7KB0inNYIpzkkpee+7U1d/u6B3FriGaSHq9QJBAM/J\n"
+        "ICnDdLCgwNvWVraVQC3BpwSB2pswvCFwq7py94V60XFvbw80Ogc6qIv98qvQxVlX\n"
+        "hJIEgA/PjEi+0ng94Q0CQQDm8XSDby35gmjO+6eRmJtAjtB7nguLvrPXM6CPXRmD\n"
+        "sRoBocpHw6j9UdzZ6qYG0FkdXZghezXFY58ro2BYYRR3\n"
+        "-----END RSA PRIVATE KEY-----\n",
+        "-----BEGIN CERTIFICATE-----\n"
+        "MIICWDCCAcGgAwIBAgIJALgDjxMbBOhbMA0GCSqGSIb3DQEBCwUAMEUxCzAJBgNV\n"
+        "BAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBX\n"
+        "aWRnaXRzIFB0eSBMdGQwHhcNMTUxMTEzMjIzMjEzWhcNMTYxMTEyMjIzMjEzWjBF\n"
+        "MQswCQYDVQQGEwJBVTETMBEGA1UECAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50\n"
+        "ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKB\n"
+        "gQDeYqlyJ1wuiMsi905e3X81/WA/G3ym50PIDZBVtSwZi7JVQPgjBl8CPZMvDh9E\n"
+        "wB4Ji9ytA8dZZbQ4WbJWPr73zPpJSCvQqz6sOXSlenBRi72acNaQsOR/qPvviJx5\n"
+        "I6Hqo4qemfnjZhAW85a5BpgrAwKgMLIQTHCTLWwVSyrDrwIDAQABo1AwTjAdBgNV\n"
+        "HQ4EFgQUx2tbJdlcSTCepn09UdYORXKuSTAwHwYDVR0jBBgwFoAUx2tbJdlcSTCe\n"
+        "pn09UdYORXKuSTAwDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQsFAAOBgQAmp9Id\n"
+        "E716gHMqeBG4S2FCgVFCr0a0ugkaneQAN/c2L9CbMemEN9W6jvucUIVOtYd90dDW\n"
+        "lXuowWmT/JctPe3D2qt4yvYW3puECHk2tVQmrJOZiZiTRtWm6HxkmoUYHYp/DtaS\n"
+        "1Xe29gSTnZtI5sQCrGMzk3SGRSSs7ejLKiVDBQ==\n"
+        "-----END CERTIFICATE-----\n")};
+
+// ECDSA with EC_NIST_P256.
+// These PEM strings were created by generating an identity with
+// `SSLIdentity::Create` and invoking `identity->PrivateKeyToPEMString()`,
+// `identity->PublicKeyToPEMString()` and
+// `identity->certificate().ToPEMString()`.
+static const rtc::RTCCertificatePEM kEcdsaPems[] = {
+    rtc::RTCCertificatePEM(
+        "-----BEGIN PRIVATE KEY-----\n"
+        "MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQg+qaRsR5uHtqG689M\n"
+        "A3PHSJNeVpyi5wUKCft62h0UWy+hRANCAAS5Mjc85q9fVq4ln+zOPlaEC/Rzj5Pb\n"
+        "MVZtf1x/8k2KsbmyZoAMDX2yer/atEuXmItMe3yd6/DXnvboU//D3Lyt\n"
+        "-----END PRIVATE KEY-----\n",
+        "-----BEGIN CERTIFICATE-----\n"
+        "MIIBFTCBu6ADAgECAgkA30tGY5XG7oowCgYIKoZIzj0EAwIwEDEOMAwGA1UEAwwF\n"
+        "dGVzdDMwHhcNMTYwNTA5MDkxODA4WhcNMTYwNjA5MDkxODA4WjAQMQ4wDAYDVQQD\n"
+        "DAV0ZXN0MzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLkyNzzmr19WriWf7M4+\n"
+        "VoQL9HOPk9sxVm1/XH/yTYqxubJmgAwNfbJ6v9q0S5eYi0x7fJ3r8Nee9uhT/8Pc\n"
+        "vK0wCgYIKoZIzj0EAwIDSQAwRgIhAIIc3+CqfkZ9lLwTj1PvUtt3KhnqF2kD0War\n"
+        "cCoTBbCxAiEAyp9Cn4vo2ZBhRIVDKyoxmwak8Z0PAVhJAQaWCgoY2D4=\n"
+        "-----END CERTIFICATE-----\n"),
+    rtc::RTCCertificatePEM(
+        "-----BEGIN PRIVATE KEY-----\n"
+        "MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQghL/G4JRYnuDNbQuh\n"
+        "LqkytcE39Alsq6FItDVFgOesfCmhRANCAATd53FjPLyVUcwYguEPbSJM03fP6Rx5\n"
+        "GY1dEZ00+ZykjJI83VfDAyvmpRuGahNtBH0hc+7xkDCbeo6TM0tN35xr\n"
+        "-----END PRIVATE KEY-----\n",
+        "-----BEGIN CERTIFICATE-----\n"
+        "MIIBFDCBu6ADAgECAgkArZYdXMyJ5rswCgYIKoZIzj0EAwIwEDEOMAwGA1UEAwwF\n"
+        "dGVzdDQwHhcNMTYwNTA5MDkxODA4WhcNMTYwNjA5MDkxODA4WjAQMQ4wDAYDVQQD\n"
+        "DAV0ZXN0NDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABN3ncWM8vJVRzBiC4Q9t\n"
+        "IkzTd8/pHHkZjV0RnTT5nKSMkjzdV8MDK+alG4ZqE20EfSFz7vGQMJt6jpMzS03f\n"
+        "nGswCgYIKoZIzj0EAwIDSAAwRQIgb/LBc8OtsC5lEDyjCP6M9xt5mwzUNrQBOFWZ\n"
+        "1fE/g68CIQD7uoFfbiq6dTp8ZwzbwQ8jJf08KjriamqA9OW/4268Dw==\n"
+        "-----END CERTIFICATE-----\n")};
+
+class FakeRTCCertificateGenerator
+    : public rtc::RTCCertificateGeneratorInterface {
+ public:
+  FakeRTCCertificateGenerator() : should_fail_(false), should_wait_(false) {}
+
+  void set_should_fail(bool should_fail) { should_fail_ = should_fail; }
+
+  // If set to true, stalls the generation of the fake certificate until it is
+  // set to false.
+  void set_should_wait(bool should_wait) { should_wait_ = should_wait; }
+
+  void use_original_key() { key_index_ = 0; }
+  void use_alternate_key() { key_index_ = 1; }
+
+  int generated_certificates() { return generated_certificates_; }
+  int generated_failures() { return generated_failures_; }
+
+  void GenerateCertificateAsync(const rtc::KeyParams& key_params,
+                                const absl::optional<uint64_t>& expires_ms,
+                                Callback callback) override {
+    // The certificates are created from constant PEM strings and use its coded
+    // expiration time, we do not support modifying it.
+    RTC_DCHECK(!expires_ms);
+
+    // Only supports RSA-1024-0x10001 and ECDSA-P256.
+    if (key_params.type() == rtc::KT_RSA) {
+      RTC_DCHECK_EQ(key_params.rsa_params().mod_size, 1024);
+      RTC_DCHECK_EQ(key_params.rsa_params().pub_exp, 0x10001);
+    } else {
+      RTC_DCHECK_EQ(key_params.type(), rtc::KT_ECDSA);
+      RTC_DCHECK_EQ(key_params.ec_curve(), rtc::EC_NIST_P256);
+    }
+    rtc::KeyType key_type = key_params.type();
+    webrtc::TaskQueueBase::Current()->PostTask(
+        [this, key_type, callback = std::move(callback)]() mutable {
+          GenerateCertificate(key_type, std::move(callback));
+        });
+  }
+
+  static rtc::scoped_refptr<rtc::RTCCertificate> GenerateCertificate() {
+    switch (rtc::KT_DEFAULT) {
+      case rtc::KT_RSA:
+        return rtc::RTCCertificate::FromPEM(kRsaPems[0]);
+      case rtc::KT_ECDSA:
+        return rtc::RTCCertificate::FromPEM(kEcdsaPems[0]);
+      default:
+        RTC_DCHECK_NOTREACHED();
+        return nullptr;
+    }
+  }
+
+ private:
+  const rtc::RTCCertificatePEM& get_pem(const rtc::KeyType& key_type) const {
+    switch (key_type) {
+      case rtc::KT_RSA:
+        return kRsaPems[key_index_];
+      case rtc::KT_ECDSA:
+        return kEcdsaPems[key_index_];
+      default:
+        RTC_DCHECK_NOTREACHED();
+        return kEcdsaPems[key_index_];
+    }
+  }
+  const std::string& get_key(const rtc::KeyType& key_type) const {
+    return get_pem(key_type).private_key();
+  }
+  const std::string& get_cert(const rtc::KeyType& key_type) const {
+    return get_pem(key_type).certificate();
+  }
+
+  void GenerateCertificate(rtc::KeyType key_type, Callback callback) {
+    // If the certificate generation should be stalled, re-post this same
+    // message to the queue with a small delay so as to wait in a loop until
+    // set_should_wait(false) is called.
+    if (should_wait_) {
+      webrtc::TaskQueueBase::Current()->PostDelayedTask(
+          [this, key_type, callback = std::move(callback)]() mutable {
+            GenerateCertificate(key_type, std::move(callback));
+          },
+          webrtc::TimeDelta::Millis(1));
+      return;
+    }
+    if (should_fail_) {
+      ++generated_failures_;
+      std::move(callback)(nullptr);
+    } else {
+      rtc::scoped_refptr<rtc::RTCCertificate> certificate =
+          rtc::RTCCertificate::FromPEM(get_pem(key_type));
+      RTC_DCHECK(certificate);
+      ++generated_certificates_;
+      std::move(callback)(std::move(certificate));
+    }
+  }
+
+  bool should_fail_;
+  bool should_wait_;
+  int key_index_ = 0;
+  int generated_certificates_ = 0;
+  int generated_failures_ = 0;
+};
+
+#endif  // PC_TEST_FAKE_RTC_CERTIFICATE_GENERATOR_H_
diff --git a/third_party/libwebrtc/pc/test/fake_video_track_renderer.h b/third_party/libwebrtc/pc/test/fake_video_track_renderer.h
new file mode 100644
index 0000000000..f6e341b4b2
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/fake_video_track_renderer.h
@@ -0,0 +1,33 @@
+/*
+ *  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.
+ */
+
+#ifndef PC_TEST_FAKE_VIDEO_TRACK_RENDERER_H_
+#define PC_TEST_FAKE_VIDEO_TRACK_RENDERER_H_
+
+#include "api/media_stream_interface.h"
+#include "media/base/fake_video_renderer.h"
+
+namespace webrtc {
+
+class FakeVideoTrackRenderer : public cricket::FakeVideoRenderer {
+ public:
+  explicit FakeVideoTrackRenderer(VideoTrackInterface* video_track)
+      : video_track_(video_track) {
+    video_track_->AddOrUpdateSink(this, rtc::VideoSinkWants());
+  }
+  ~FakeVideoTrackRenderer() { video_track_->RemoveSink(this); }
+
+ private:
+  rtc::scoped_refptr<VideoTrackInterface> video_track_;
+};
+
+}  // namespace webrtc
+
+#endif  // PC_TEST_FAKE_VIDEO_TRACK_RENDERER_H_
diff --git a/third_party/libwebrtc/pc/test/fake_video_track_source.h b/third_party/libwebrtc/pc/test/fake_video_track_source.h
new file mode 100644
index 0000000000..2042c39175
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/fake_video_track_source.h
@@ -0,0 +1,54 @@
+/*
+ *  Copyright 2016 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.
+ */
+
+#ifndef PC_TEST_FAKE_VIDEO_TRACK_SOURCE_H_
+#define PC_TEST_FAKE_VIDEO_TRACK_SOURCE_H_
+
+#include "api/media_stream_interface.h"
+#include "media/base/video_broadcaster.h"
+#include "pc/video_track_source.h"
+
+namespace webrtc {
+
+// A minimal implementation of VideoTrackSource. Includes a VideoBroadcaster for
+// injection of frames.
+class FakeVideoTrackSource : public VideoTrackSource {
+ public:
+  static rtc::scoped_refptr<FakeVideoTrackSource> Create(bool is_screencast) {
+    return rtc::make_ref_counted<FakeVideoTrackSource>(is_screencast);
+  }
+
+  static rtc::scoped_refptr<FakeVideoTrackSource> Create() {
+    return Create(false);
+  }
+
+  bool is_screencast() const override { return is_screencast_; }
+
+  void InjectFrame(const VideoFrame& frame) {
+    video_broadcaster_.OnFrame(frame);
+  }
+
+ protected:
+  explicit FakeVideoTrackSource(bool is_screencast)
+      : VideoTrackSource(false /* remote */), is_screencast_(is_screencast) {}
+  ~FakeVideoTrackSource() override = default;
+
+  rtc::VideoSourceInterface<VideoFrame>* source() override {
+    return &video_broadcaster_;
+  }
+
+ private:
+  const bool is_screencast_;
+  rtc::VideoBroadcaster video_broadcaster_;
+};
+
+}  // namespace webrtc
+
+#endif  // PC_TEST_FAKE_VIDEO_TRACK_SOURCE_H_
diff --git a/third_party/libwebrtc/pc/test/frame_generator_capturer_video_track_source.h b/third_party/libwebrtc/pc/test/frame_generator_capturer_video_track_source.h
new file mode 100644
index 0000000000..50a3d26c2e
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/frame_generator_capturer_video_track_source.h
@@ -0,0 +1,86 @@
+/*
+ *  Copyright 2018 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.
+ */
+
+#ifndef PC_TEST_FRAME_GENERATOR_CAPTURER_VIDEO_TRACK_SOURCE_H_
+#define PC_TEST_FRAME_GENERATOR_CAPTURER_VIDEO_TRACK_SOURCE_H_
+
+#include <memory>
+#include <utility>
+
+#include "api/task_queue/default_task_queue_factory.h"
+#include "api/task_queue/task_queue_factory.h"
+#include "api/test/create_frame_generator.h"
+#include "pc/video_track_source.h"
+#include "test/frame_generator_capturer.h"
+
+namespace webrtc {
+
+// Implements a VideoTrackSourceInterface to be used for creating VideoTracks.
+// The video source is generated using a FrameGeneratorCapturer, specifically
+// a SquareGenerator that generates frames with randomly sized and colored
+// squares.
+class FrameGeneratorCapturerVideoTrackSource : public VideoTrackSource {
+ public:
+  static const int kDefaultFramesPerSecond = 30;
+  static const int kDefaultWidth = 640;
+  static const int kDefaultHeight = 480;
+  static const int kNumSquaresGenerated = 50;
+
+  struct Config {
+    int frames_per_second = kDefaultFramesPerSecond;
+    int width = kDefaultWidth;
+    int height = kDefaultHeight;
+    int num_squares_generated = 50;
+  };
+
+  FrameGeneratorCapturerVideoTrackSource(Config config,
+                                         Clock* clock,
+                                         bool is_screencast)
+      : VideoTrackSource(false /* remote */),
+        task_queue_factory_(CreateDefaultTaskQueueFactory()),
+        is_screencast_(is_screencast) {
+    video_capturer_ = std::make_unique<test::FrameGeneratorCapturer>(
+        clock,
+        test::CreateSquareFrameGenerator(config.width, config.height,
+                                         absl::nullopt,
+                                         config.num_squares_generated),
+        config.frames_per_second, *task_queue_factory_);
+    video_capturer_->Init();
+  }
+
+  FrameGeneratorCapturerVideoTrackSource(
+      std::unique_ptr<test::FrameGeneratorCapturer> video_capturer,
+      bool is_screencast)
+      : VideoTrackSource(false /* remote */),
+        video_capturer_(std::move(video_capturer)),
+        is_screencast_(is_screencast) {}
+
+  ~FrameGeneratorCapturerVideoTrackSource() = default;
+
+  void Start() { SetState(kLive); }
+
+  void Stop() { SetState(kMuted); }
+
+  bool is_screencast() const override { return is_screencast_; }
+
+ protected:
+  rtc::VideoSourceInterface<VideoFrame>* source() override {
+    return video_capturer_.get();
+  }
+
+ private:
+  const std::unique_ptr<TaskQueueFactory> task_queue_factory_;
+  std::unique_ptr<test::FrameGeneratorCapturer> video_capturer_;
+  const bool is_screencast_;
+};
+
+}  // namespace webrtc
+
+#endif  // PC_TEST_FRAME_GENERATOR_CAPTURER_VIDEO_TRACK_SOURCE_H_
diff --git a/third_party/libwebrtc/pc/test/integration_test_helpers.cc b/third_party/libwebrtc/pc/test/integration_test_helpers.cc
new file mode 100644
index 0000000000..471271f068
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/integration_test_helpers.cc
@@ -0,0 +1,92 @@
+/*
+ *  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 "pc/test/integration_test_helpers.h"
+
+namespace webrtc {
+
+PeerConnectionInterface::RTCOfferAnswerOptions IceRestartOfferAnswerOptions() {
+  PeerConnectionInterface::RTCOfferAnswerOptions options;
+  options.ice_restart = true;
+  return options;
+}
+
+void RemoveSsrcsAndMsids(cricket::SessionDescription* desc) {
+  for (ContentInfo& content : desc->contents()) {
+    content.media_description()->mutable_streams().clear();
+  }
+  desc->set_msid_supported(false);
+  desc->set_msid_signaling(0);
+}
+
+void RemoveSsrcsAndKeepMsids(cricket::SessionDescription* desc) {
+  for (ContentInfo& content : desc->contents()) {
+    std::string track_id;
+    std::vector<std::string> stream_ids;
+    if (!content.media_description()->streams().empty()) {
+      const StreamParams& first_stream =
+          content.media_description()->streams()[0];
+      track_id = first_stream.id;
+      stream_ids = first_stream.stream_ids();
+    }
+    content.media_description()->mutable_streams().clear();
+    StreamParams new_stream;
+    new_stream.id = track_id;
+    new_stream.set_stream_ids(stream_ids);
+    content.media_description()->AddStream(new_stream);
+  }
+}
+
+int FindFirstMediaStatsIndexByKind(
+    const std::string& kind,
+    const std::vector<const webrtc::RTCInboundRTPStreamStats*>& inbound_rtps) {
+  for (size_t i = 0; i < inbound_rtps.size(); i++) {
+    if (*inbound_rtps[i]->kind == kind) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+TaskQueueMetronome::TaskQueueMetronome(TimeDelta tick_period)
+    : tick_period_(tick_period) {
+  sequence_checker_.Detach();
+}
+
+TaskQueueMetronome::~TaskQueueMetronome() {
+  RTC_DCHECK_RUN_ON(&sequence_checker_);
+}
+void TaskQueueMetronome::RequestCallOnNextTick(
+    absl::AnyInvocable<void() &&> callback) {
+  RTC_DCHECK_RUN_ON(&sequence_checker_);
+  callbacks_.push_back(std::move(callback));
+  // Only schedule a tick callback for the first `callback` addition.
+  // Schedule on the current task queue to comply with RequestCallOnNextTick
+  // requirements.
+  if (callbacks_.size() == 1) {
+    TaskQueueBase::Current()->PostDelayedTask(
+        SafeTask(safety_.flag(),
+                 [this] {
+                   RTC_DCHECK_RUN_ON(&sequence_checker_);
+                   std::vector<absl::AnyInvocable<void() &&>> callbacks;
+                   callbacks_.swap(callbacks);
+                   for (auto& callback : callbacks)
+                     std::move(callback)();
+                 }),
+        tick_period_);
+  }
+}
+
+TimeDelta TaskQueueMetronome::TickPeriod() const {
+  RTC_DCHECK_RUN_ON(&sequence_checker_);
+  return tick_period_;
+}
+
+}  // namespace webrtc
diff --git a/third_party/libwebrtc/pc/test/integration_test_helpers.h b/third_party/libwebrtc/pc/test/integration_test_helpers.h
new file mode 100644
index 0000000000..4e01b333b9
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/integration_test_helpers.h
@@ -0,0 +1,1929 @@
+/*
+ *  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.
+ */
+
+#ifndef PC_TEST_INTEGRATION_TEST_HELPERS_H_
+#define PC_TEST_INTEGRATION_TEST_HELPERS_H_
+
+#include <limits.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include <algorithm>
+#include <functional>
+#include <limits>
+#include <list>
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/algorithm/container.h"
+#include "absl/memory/memory.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "api/audio_options.h"
+#include "api/call/call_factory_interface.h"
+#include "api/candidate.h"
+#include "api/crypto/crypto_options.h"
+#include "api/data_channel_interface.h"
+#include "api/field_trials_view.h"
+#include "api/ice_transport_interface.h"
+#include "api/jsep.h"
+#include "api/media_stream_interface.h"
+#include "api/media_types.h"
+#include "api/peer_connection_interface.h"
+#include "api/rtc_error.h"
+#include "api/rtc_event_log/rtc_event_log_factory.h"
+#include "api/rtc_event_log/rtc_event_log_factory_interface.h"
+#include "api/rtc_event_log_output.h"
+#include "api/rtp_receiver_interface.h"
+#include "api/rtp_sender_interface.h"
+#include "api/rtp_transceiver_interface.h"
+#include "api/scoped_refptr.h"
+#include "api/stats/rtc_stats.h"
+#include "api/stats/rtc_stats_report.h"
+#include "api/stats/rtcstats_objects.h"
+#include "api/task_queue/default_task_queue_factory.h"
+#include "api/task_queue/pending_task_safety_flag.h"
+#include "api/task_queue/task_queue_factory.h"
+#include "api/transport/field_trial_based_config.h"
+#include "api/uma_metrics.h"
+#include "api/units/time_delta.h"
+#include "api/video/video_rotation.h"
+#include "api/video_codecs/sdp_video_format.h"
+#include "api/video_codecs/video_decoder_factory.h"
+#include "api/video_codecs/video_encoder_factory.h"
+#include "call/call.h"
+#include "logging/rtc_event_log/fake_rtc_event_log_factory.h"
+#include "media/base/media_engine.h"
+#include "media/base/stream_params.h"
+#include "media/engine/fake_webrtc_video_engine.h"
+#include "media/engine/webrtc_media_engine.h"
+#include "media/engine/webrtc_media_engine_defaults.h"
+#include "modules/audio_device/include/audio_device.h"
+#include "modules/audio_processing/include/audio_processing.h"
+#include "modules/audio_processing/test/audio_processing_builder_for_testing.h"
+#include "p2p/base/fake_ice_transport.h"
+#include "p2p/base/ice_transport_internal.h"
+#include "p2p/base/mock_async_resolver.h"
+#include "p2p/base/p2p_constants.h"
+#include "p2p/base/port.h"
+#include "p2p/base/port_allocator.h"
+#include "p2p/base/port_interface.h"
+#include "p2p/base/test_stun_server.h"
+#include "p2p/base/test_turn_customizer.h"
+#include "p2p/base/test_turn_server.h"
+#include "p2p/client/basic_port_allocator.h"
+#include "pc/dtmf_sender.h"
+#include "pc/local_audio_source.h"
+#include "pc/media_session.h"
+#include "pc/peer_connection.h"
+#include "pc/peer_connection_factory.h"
+#include "pc/peer_connection_proxy.h"
+#include "pc/rtp_media_utils.h"
+#include "pc/session_description.h"
+#include "pc/test/fake_audio_capture_module.h"
+#include "pc/test/fake_periodic_video_source.h"
+#include "pc/test/fake_periodic_video_track_source.h"
+#include "pc/test/fake_rtc_certificate_generator.h"
+#include "pc/test/fake_video_track_renderer.h"
+#include "pc/test/mock_peer_connection_observers.h"
+#include "pc/video_track_source.h"
+#include "rtc_base/checks.h"
+#include "rtc_base/event.h"
+#include "rtc_base/fake_clock.h"
+#include "rtc_base/fake_mdns_responder.h"
+#include "rtc_base/fake_network.h"
+#include "rtc_base/firewall_socket_server.h"
+#include "rtc_base/gunit.h"
+#include "rtc_base/helpers.h"
+#include "rtc_base/ip_address.h"
+#include "rtc_base/logging.h"
+#include "rtc_base/mdns_responder_interface.h"
+#include "rtc_base/numerics/safe_conversions.h"
+#include "rtc_base/rtc_certificate_generator.h"
+#include "rtc_base/socket_address.h"
+#include "rtc_base/ssl_stream_adapter.h"
+#include "rtc_base/task_queue_for_test.h"
+#include "rtc_base/task_utils/repeating_task.h"
+#include "rtc_base/test_certificate_verifier.h"
+#include "rtc_base/thread.h"
+#include "rtc_base/thread_annotations.h"
+#include "rtc_base/time_utils.h"
+#include "rtc_base/virtual_socket_server.h"
+#include "system_wrappers/include/metrics.h"
+#include "test/gmock.h"
+#include "test/scoped_key_value_config.h"
+
+namespace webrtc {
+
+using ::cricket::ContentInfo;
+using ::cricket::StreamParams;
+using ::rtc::SocketAddress;
+using ::testing::_;
+using ::testing::Combine;
+using ::testing::Contains;
+using ::testing::DoAll;
+using ::testing::ElementsAre;
+using ::testing::NiceMock;
+using ::testing::Return;
+using ::testing::SetArgPointee;
+using ::testing::UnorderedElementsAreArray;
+using ::testing::Values;
+using RTCConfiguration = PeerConnectionInterface::RTCConfiguration;
+
+static const int kDefaultTimeout = 10000;
+static const int kMaxWaitForStatsMs = 3000;
+static const int kMaxWaitForActivationMs = 5000;
+static const int kMaxWaitForFramesMs = 10000;
+// Default number of audio/video frames to wait for before considering a test
+// successful.
+static const int kDefaultExpectedAudioFrameCount = 3;
+static const int kDefaultExpectedVideoFrameCount = 3;
+
+static const char kDataChannelLabel[] = "data_channel";
+
+// SRTP cipher name negotiated by the tests. This must be updated if the
+// default changes.
+static const int kDefaultSrtpCryptoSuite = rtc::kSrtpAes128CmSha1_80;
+static const int kDefaultSrtpCryptoSuiteGcm = rtc::kSrtpAeadAes256Gcm;
+
+static const SocketAddress kDefaultLocalAddress("192.168.1.1", 0);
+
+// Helper function for constructing offer/answer options to initiate an ICE
+// restart.
+PeerConnectionInterface::RTCOfferAnswerOptions IceRestartOfferAnswerOptions();
+
+// Remove all stream information (SSRCs, track IDs, etc.) and "msid-semantic"
+// attribute from received SDP, simulating a legacy endpoint.
+void RemoveSsrcsAndMsids(cricket::SessionDescription* desc);
+
+// Removes all stream information besides the stream ids, simulating an
+// endpoint that only signals a=msid lines to convey stream_ids.
+void RemoveSsrcsAndKeepMsids(cricket::SessionDescription* desc);
+
+int FindFirstMediaStatsIndexByKind(
+    const std::string& kind,
+    const std::vector<const webrtc::RTCInboundRTPStreamStats*>& inbound_rtps);
+
+class TaskQueueMetronome : public webrtc::Metronome {
+ public:
+  explicit TaskQueueMetronome(TimeDelta tick_period);
+  ~TaskQueueMetronome() override;
+
+  // webrtc::Metronome implementation.
+  void RequestCallOnNextTick(absl::AnyInvocable<void() &&> callback) override;
+  TimeDelta TickPeriod() const override;
+
+ private:
+  const TimeDelta tick_period_;
+  SequenceChecker sequence_checker_;
+  std::vector<absl::AnyInvocable<void() &&>> callbacks_;
+  ScopedTaskSafetyDetached safety_;
+};
+
+class SignalingMessageReceiver {
+ public:
+  virtual void ReceiveSdpMessage(SdpType type, const std::string& msg) = 0;
+  virtual void ReceiveIceMessage(const std::string& sdp_mid,
+                                 int sdp_mline_index,
+                                 const std::string& msg) = 0;
+
+ protected:
+  SignalingMessageReceiver() {}
+  virtual ~SignalingMessageReceiver() {}
+};
+
+class MockRtpReceiverObserver : public webrtc::RtpReceiverObserverInterface {
+ public:
+  explicit MockRtpReceiverObserver(cricket::MediaType media_type)
+      : expected_media_type_(media_type) {}
+
+  void OnFirstPacketReceived(cricket::MediaType media_type) override {
+    ASSERT_EQ(expected_media_type_, media_type);
+    first_packet_received_ = true;
+  }
+
+  bool first_packet_received() const { return first_packet_received_; }
+
+  virtual ~MockRtpReceiverObserver() {}
+
+ private:
+  bool first_packet_received_ = false;
+  cricket::MediaType expected_media_type_;
+};
+
+// Helper class that wraps a peer connection, observes it, and can accept
+// signaling messages from another wrapper.
+//
+// Uses a fake network, fake A/V capture, and optionally fake
+// encoders/decoders, though they aren't used by default since they don't
+// advertise support of any codecs.
+// TODO(steveanton): See how this could become a subclass of
+// PeerConnectionWrapper defined in peerconnectionwrapper.h.
+class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
+                                         public SignalingMessageReceiver {
+ public:
+  webrtc::PeerConnectionFactoryInterface* pc_factory() const {
+    return peer_connection_factory_.get();
+  }
+
+  webrtc::PeerConnectionInterface* pc() const { return peer_connection_.get(); }
+
+  // If a signaling message receiver is set (via ConnectFakeSignaling), this
+  // will set the whole offer/answer exchange in motion. Just need to wait for
+  // the signaling state to reach "stable".
+  void CreateAndSetAndSignalOffer() {
+    auto offer = CreateOfferAndWait();
+    ASSERT_NE(nullptr, offer);
+    EXPECT_TRUE(SetLocalDescriptionAndSendSdpMessage(std::move(offer)));
+  }
+
+  // Sets the options to be used when CreateAndSetAndSignalOffer is called, or
+  // when a remote offer is received (via fake signaling) and an answer is
+  // generated. By default, uses default options.
+  void SetOfferAnswerOptions(
+      const PeerConnectionInterface::RTCOfferAnswerOptions& options) {
+    offer_answer_options_ = options;
+  }
+
+  // Set a callback to be invoked when SDP is received via the fake signaling
+  // channel, which provides an opportunity to munge (modify) the SDP. This is
+  // used to test SDP being applied that a PeerConnection would normally not
+  // generate, but a non-JSEP endpoint might.
+  void SetReceivedSdpMunger(
+      std::function<void(cricket::SessionDescription*)> munger) {
+    received_sdp_munger_ = std::move(munger);
+  }
+
+  // Similar to the above, but this is run on SDP immediately after it's
+  // generated.
+  void SetGeneratedSdpMunger(
+      std::function<void(cricket::SessionDescription*)> munger) {
+    generated_sdp_munger_ = std::move(munger);
+  }
+
+  // Set a callback to be invoked when a remote offer is received via the fake
+  // signaling channel. This provides an opportunity to change the
+  // PeerConnection state before an answer is created and sent to the caller.
+  void SetRemoteOfferHandler(std::function<void()> handler) {
+    remote_offer_handler_ = std::move(handler);
+  }
+
+  void SetRemoteAsyncResolver(rtc::MockAsyncResolver* resolver) {
+    remote_async_resolver_ = resolver;
+  }
+
+  // Every ICE connection state in order that has been seen by the observer.
+  std::vector<PeerConnectionInterface::IceConnectionState>
+  ice_connection_state_history() const {
+    return ice_connection_state_history_;
+  }
+  void clear_ice_connection_state_history() {
+    ice_connection_state_history_.clear();
+  }
+
+  // Every standardized ICE connection state in order that has been seen by the
+  // observer.
+  std::vector<PeerConnectionInterface::IceConnectionState>
+  standardized_ice_connection_state_history() const {
+    return standardized_ice_connection_state_history_;
+  }
+
+  // Every PeerConnection state in order that has been seen by the observer.
+  std::vector<PeerConnectionInterface::PeerConnectionState>
+  peer_connection_state_history() const {
+    return peer_connection_state_history_;
+  }
+
+  // Every ICE gathering state in order that has been seen by the observer.
+  std::vector<PeerConnectionInterface::IceGatheringState>
+  ice_gathering_state_history() const {
+    return ice_gathering_state_history_;
+  }
+  std::vector<cricket::CandidatePairChangeEvent>
+  ice_candidate_pair_change_history() const {
+    return ice_candidate_pair_change_history_;
+  }
+
+  // Every PeerConnection signaling state in order that has been seen by the
+  // observer.
+  std::vector<PeerConnectionInterface::SignalingState>
+  peer_connection_signaling_state_history() const {
+    return peer_connection_signaling_state_history_;
+  }
+
+  void AddAudioVideoTracks() {
+    AddAudioTrack();
+    AddVideoTrack();
+  }
+
+  rtc::scoped_refptr<RtpSenderInterface> AddAudioTrack() {
+    return AddTrack(CreateLocalAudioTrack());
+  }
+
+  rtc::scoped_refptr<RtpSenderInterface> AddVideoTrack() {
+    return AddTrack(CreateLocalVideoTrack());
+  }
+
+  rtc::scoped_refptr<webrtc::AudioTrackInterface> CreateLocalAudioTrack() {
+    cricket::AudioOptions options;
+    // Disable highpass filter so that we can get all the test audio frames.
+    options.highpass_filter = false;
+    rtc::scoped_refptr<webrtc::AudioSourceInterface> source =
+        peer_connection_factory_->CreateAudioSource(options);
+    // TODO(perkj): Test audio source when it is implemented. Currently audio
+    // always use the default input.
+    return peer_connection_factory_->CreateAudioTrack(rtc::CreateRandomUuid(),
+                                                      source.get());
+  }
+
+  rtc::scoped_refptr<webrtc::VideoTrackInterface> CreateLocalVideoTrack() {
+    webrtc::FakePeriodicVideoSource::Config config;
+    config.timestamp_offset_ms = rtc::TimeMillis();
+    return CreateLocalVideoTrackInternal(config);
+  }
+
+  rtc::scoped_refptr<webrtc::VideoTrackInterface>
+  CreateLocalVideoTrackWithConfig(
+      webrtc::FakePeriodicVideoSource::Config config) {
+    return CreateLocalVideoTrackInternal(config);
+  }
+
+  rtc::scoped_refptr<webrtc::VideoTrackInterface>
+  CreateLocalVideoTrackWithRotation(webrtc::VideoRotation rotation) {
+    webrtc::FakePeriodicVideoSource::Config config;
+    config.rotation = rotation;
+    config.timestamp_offset_ms = rtc::TimeMillis();
+    return CreateLocalVideoTrackInternal(config);
+  }
+
+  rtc::scoped_refptr<RtpSenderInterface> AddTrack(
+      rtc::scoped_refptr<MediaStreamTrackInterface> track,
+      const std::vector<std::string>& stream_ids = {}) {
+    EXPECT_TRUE(track);
+    if (!track) {
+      return nullptr;
+    }
+    auto result = pc()->AddTrack(track, stream_ids);
+    EXPECT_EQ(RTCErrorType::NONE, result.error().type());
+    if (result.ok()) {
+      return result.MoveValue();
+    } else {
+      return nullptr;
+    }
+  }
+
+  std::vector<rtc::scoped_refptr<RtpReceiverInterface>> GetReceiversOfType(
+      cricket::MediaType media_type) {
+    std::vector<rtc::scoped_refptr<RtpReceiverInterface>> receivers;
+    for (const auto& receiver : pc()->GetReceivers()) {
+      if (receiver->media_type() == media_type) {
+        receivers.push_back(receiver);
+      }
+    }
+    return receivers;
+  }
+
+  rtc::scoped_refptr<RtpTransceiverInterface> GetFirstTransceiverOfType(
+      cricket::MediaType media_type) {
+    for (auto transceiver : pc()->GetTransceivers()) {
+      if (transceiver->receiver()->media_type() == media_type) {
+        return transceiver;
+      }
+    }
+    return nullptr;
+  }
+
+  bool SignalingStateStable() {
+    return pc()->signaling_state() == webrtc::PeerConnectionInterface::kStable;
+  }
+
+  bool IceGatheringStateComplete() {
+    return pc()->ice_gathering_state() ==
+           webrtc::PeerConnectionInterface::kIceGatheringComplete;
+  }
+
+  void CreateDataChannel() { CreateDataChannel(nullptr); }
+
+  void CreateDataChannel(const webrtc::DataChannelInit* init) {
+    CreateDataChannel(kDataChannelLabel, init);
+  }
+
+  void CreateDataChannel(const std::string& label,
+                         const webrtc::DataChannelInit* init) {
+    auto data_channel_or_error = pc()->CreateDataChannelOrError(label, init);
+    ASSERT_TRUE(data_channel_or_error.ok());
+    data_channels_.push_back(data_channel_or_error.MoveValue());
+    ASSERT_TRUE(data_channels_.back().get() != nullptr);
+    data_observers_.push_back(
+        std::make_unique<MockDataChannelObserver>(data_channels_.back().get()));
+  }
+
+  // Return the last observed data channel.
+  DataChannelInterface* data_channel() {
+    if (data_channels_.size() == 0) {
+      return nullptr;
+    }
+    return data_channels_.back().get();
+  }
+  // Return all data channels.
+  std::vector<rtc::scoped_refptr<DataChannelInterface>>& data_channels() {
+    return data_channels_;
+  }
+
+  const MockDataChannelObserver* data_observer() const {
+    if (data_observers_.size() == 0) {
+      return nullptr;
+    }
+    return data_observers_.back().get();
+  }
+
+  std::vector<std::unique_ptr<MockDataChannelObserver>>& data_observers() {
+    return data_observers_;
+  }
+
+  int audio_frames_received() const {
+    return fake_audio_capture_module_->frames_received();
+  }
+
+  // Takes minimum of video frames received for each track.
+  //
+  // Can be used like:
+  // EXPECT_GE(expected_frames, min_video_frames_received_per_track());
+  //
+  // To ensure that all video tracks received at least a certain number of
+  // frames.
+  int min_video_frames_received_per_track() const {
+    int min_frames = INT_MAX;
+    if (fake_video_renderers_.empty()) {
+      return 0;
+    }
+
+    for (const auto& pair : fake_video_renderers_) {
+      min_frames = std::min(min_frames, pair.second->num_rendered_frames());
+    }
+    return min_frames;
+  }
+
+  // Returns a MockStatsObserver in a state after stats gathering finished,
+  // which can be used to access the gathered stats.
+  rtc::scoped_refptr<MockStatsObserver> OldGetStatsForTrack(
+      webrtc::MediaStreamTrackInterface* track) {
+    auto observer = rtc::make_ref_counted<MockStatsObserver>();
+    EXPECT_TRUE(peer_connection_->GetStats(
+        observer.get(), nullptr,
+        PeerConnectionInterface::kStatsOutputLevelStandard));
+    EXPECT_TRUE_WAIT(observer->called(), kDefaultTimeout);
+    return observer;
+  }
+
+  // Version that doesn't take a track "filter", and gathers all stats.
+  rtc::scoped_refptr<MockStatsObserver> OldGetStats() {
+    return OldGetStatsForTrack(nullptr);
+  }
+
+  // Synchronously gets stats and returns them. If it times out, fails the test
+  // and returns null.
+  rtc::scoped_refptr<const webrtc::RTCStatsReport> NewGetStats() {
+    auto callback =
+        rtc::make_ref_counted<webrtc::MockRTCStatsCollectorCallback>();
+    peer_connection_->GetStats(callback.get());
+    EXPECT_TRUE_WAIT(callback->called(), kDefaultTimeout);
+    return callback->report();
+  }
+
+  int rendered_width() {
+    EXPECT_FALSE(fake_video_renderers_.empty());
+    return fake_video_renderers_.empty()
+               ? 0
+               : fake_video_renderers_.begin()->second->width();
+  }
+
+  int rendered_height() {
+    EXPECT_FALSE(fake_video_renderers_.empty());
+    return fake_video_renderers_.empty()
+               ? 0
+               : fake_video_renderers_.begin()->second->height();
+  }
+
+  double rendered_aspect_ratio() {
+    if (rendered_height() == 0) {
+      return 0.0;
+    }
+    return static_cast<double>(rendered_width()) / rendered_height();
+  }
+
+  webrtc::VideoRotation rendered_rotation() {
+    EXPECT_FALSE(fake_video_renderers_.empty());
+    return fake_video_renderers_.empty()
+               ? webrtc::kVideoRotation_0
+               : fake_video_renderers_.begin()->second->rotation();
+  }
+
+  int local_rendered_width() {
+    return local_video_renderer_ ? local_video_renderer_->width() : 0;
+  }
+
+  int local_rendered_height() {
+    return local_video_renderer_ ? local_video_renderer_->height() : 0;
+  }
+
+  double local_rendered_aspect_ratio() {
+    if (local_rendered_height() == 0) {
+      return 0.0;
+    }
+    return static_cast<double>(local_rendered_width()) /
+           local_rendered_height();
+  }
+
+  size_t number_of_remote_streams() {
+    if (!pc()) {
+      return 0;
+    }
+    return pc()->remote_streams()->count();
+  }
+
+  StreamCollectionInterface* remote_streams() const {
+    if (!pc()) {
+      ADD_FAILURE();
+      return nullptr;
+    }
+    return pc()->remote_streams().get();
+  }
+
+  StreamCollectionInterface* local_streams() {
+    if (!pc()) {
+      ADD_FAILURE();
+      return nullptr;
+    }
+    return pc()->local_streams().get();
+  }
+
+  webrtc::PeerConnectionInterface::SignalingState signaling_state() {
+    return pc()->signaling_state();
+  }
+
+  webrtc::PeerConnectionInterface::IceConnectionState ice_connection_state() {
+    return pc()->ice_connection_state();
+  }
+
+  webrtc::PeerConnectionInterface::IceConnectionState
+  standardized_ice_connection_state() {
+    return pc()->standardized_ice_connection_state();
+  }
+
+  webrtc::PeerConnectionInterface::IceGatheringState ice_gathering_state() {
+    return pc()->ice_gathering_state();
+  }
+
+  // Returns a MockRtpReceiverObserver for each RtpReceiver returned by
+  // GetReceivers. They're updated automatically when a remote offer/answer
+  // from the fake signaling channel is applied, or when
+  // ResetRtpReceiverObservers below is called.
+  const std::vector<std::unique_ptr<MockRtpReceiverObserver>>&
+  rtp_receiver_observers() {
+    return rtp_receiver_observers_;
+  }
+
+  void ResetRtpReceiverObservers() {
+    rtp_receiver_observers_.clear();
+    for (const rtc::scoped_refptr<RtpReceiverInterface>& receiver :
+         pc()->GetReceivers()) {
+      std::unique_ptr<MockRtpReceiverObserver> observer(
+          new MockRtpReceiverObserver(receiver->media_type()));
+      receiver->SetObserver(observer.get());
+      rtp_receiver_observers_.push_back(std::move(observer));
+    }
+  }
+
+  rtc::FakeNetworkManager* network_manager() const {
+    return fake_network_manager_.get();
+  }
+  cricket::PortAllocator* port_allocator() const { return port_allocator_; }
+
+  webrtc::FakeRtcEventLogFactory* event_log_factory() const {
+    return event_log_factory_;
+  }
+
+  const cricket::Candidate& last_candidate_gathered() const {
+    return last_candidate_gathered_;
+  }
+  const cricket::IceCandidateErrorEvent& error_event() const {
+    return error_event_;
+  }
+
+  // Sets the mDNS responder for the owned fake network manager and keeps a
+  // reference to the responder.
+  void SetMdnsResponder(
+      std::unique_ptr<webrtc::FakeMdnsResponder> mdns_responder) {
+    RTC_DCHECK(mdns_responder != nullptr);
+    mdns_responder_ = mdns_responder.get();
+    network_manager()->set_mdns_responder(std::move(mdns_responder));
+  }
+
+  // Returns null on failure.
+  std::unique_ptr<SessionDescriptionInterface> CreateOfferAndWait() {
+    auto observer =
+        rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
+    pc()->CreateOffer(observer.get(), offer_answer_options_);
+    return WaitForDescriptionFromObserver(observer.get());
+  }
+  bool Rollback() {
+    return SetRemoteDescription(
+        webrtc::CreateSessionDescription(SdpType::kRollback, ""));
+  }
+
+  // Functions for querying stats.
+  void StartWatchingDelayStats() {
+    // Get the baseline numbers for audio_packets and audio_delay.
+    auto received_stats = NewGetStats();
+    auto rtp_stats =
+        received_stats->GetStatsOfType<webrtc::RTCInboundRTPStreamStats>()[0];
+    ASSERT_TRUE(rtp_stats->relative_packet_arrival_delay.is_defined());
+    ASSERT_TRUE(rtp_stats->packets_received.is_defined());
+    ASSERT_TRUE(rtp_stats->track_id.is_defined());
+    rtp_stats_id_ = rtp_stats->id();
+    audio_packets_stat_ = *rtp_stats->packets_received;
+    audio_delay_stat_ = *rtp_stats->relative_packet_arrival_delay;
+    audio_samples_stat_ = *rtp_stats->total_samples_received;
+    audio_concealed_stat_ = *rtp_stats->concealed_samples;
+  }
+
+  void UpdateDelayStats(std::string tag, int desc_size) {
+    auto report = NewGetStats();
+    auto rtp_stats =
+        report->GetAs<webrtc::RTCInboundRTPStreamStats>(rtp_stats_id_);
+    ASSERT_TRUE(rtp_stats);
+    auto delta_packets = *rtp_stats->packets_received - audio_packets_stat_;
+    auto delta_rpad =
+        *rtp_stats->relative_packet_arrival_delay - audio_delay_stat_;
+    auto recent_delay = delta_packets > 0 ? delta_rpad / delta_packets : -1;
+    // The purpose of these checks is to sound the alarm early if we introduce
+    // serious regressions. The numbers are not acceptable for production, but
+    // occur on slow bots.
+    //
+    // An average relative packet arrival delay over the renegotiation of
+    // > 100 ms indicates that something is dramatically wrong, and will impact
+    // quality for sure.
+    // Worst bots:
+    // linux_x86_dbg at 0.206
+#if !defined(NDEBUG)
+    EXPECT_GT(0.25, recent_delay) << tag << " size " << desc_size;
+#else
+    EXPECT_GT(0.1, recent_delay) << tag << " size " << desc_size;
+#endif
+    auto delta_samples =
+        *rtp_stats->total_samples_received - audio_samples_stat_;
+    auto delta_concealed =
+        *rtp_stats->concealed_samples - audio_concealed_stat_;
+    // These limits should be adjusted down as we improve:
+    //
+    // Concealing more than 4000 samples during a renegotiation is unacceptable.
+    // But some bots are slow.
+
+    // Worst bots:
+    // linux_more_configs bot at conceal count 5184
+    // android_arm_rel at conceal count 9241
+    // linux_x86_dbg at 15174
+#if !defined(NDEBUG)
+    EXPECT_GT(18000U, delta_concealed) << "Concealed " << delta_concealed
+                                       << " of " << delta_samples << " samples";
+#else
+    EXPECT_GT(15000U, delta_concealed) << "Concealed " << delta_concealed
+                                       << " of " << delta_samples << " samples";
+#endif
+    // Concealing more than 20% of samples during a renegotiation is
+    // unacceptable.
+    // Worst bots:
+    // Nondebug: Linux32 Release at conceal rate 0.606597 (CI run)
+    // Debug: linux_x86_dbg bot at conceal rate 0.854
+    if (delta_samples > 0) {
+#if !defined(NDEBUG)
+      EXPECT_LT(1.0 * delta_concealed / delta_samples, 0.95)
+          << "Concealed " << delta_concealed << " of " << delta_samples
+          << " samples";
+#else
+      EXPECT_LT(1.0 * delta_concealed / delta_samples, 0.7)
+          << "Concealed " << delta_concealed << " of " << delta_samples
+          << " samples";
+#endif
+    }
+    // Increment trailing counters
+    audio_packets_stat_ = *rtp_stats->packets_received;
+    audio_delay_stat_ = *rtp_stats->relative_packet_arrival_delay;
+    audio_samples_stat_ = *rtp_stats->total_samples_received;
+    audio_concealed_stat_ = *rtp_stats->concealed_samples;
+  }
+
+  // Sets number of candidates expected
+  void ExpectCandidates(int candidate_count) {
+    candidates_expected_ = candidate_count;
+  }
+
+ private:
+  // Constructor used by friend class PeerConnectionIntegrationBaseTest.
+  explicit PeerConnectionIntegrationWrapper(const std::string& debug_name)
+      : debug_name_(debug_name) {}
+
+  bool Init(const PeerConnectionFactory::Options* options,
+            const PeerConnectionInterface::RTCConfiguration* config,
+            webrtc::PeerConnectionDependencies dependencies,
+            rtc::SocketServer* socket_server,
+            rtc::Thread* network_thread,
+            rtc::Thread* worker_thread,
+            std::unique_ptr<webrtc::FakeRtcEventLogFactory> event_log_factory,
+            bool reset_encoder_factory,
+            bool reset_decoder_factory,
+            bool create_media_engine) {
+    // There's an error in this test code if Init ends up being called twice.
+    RTC_DCHECK(!peer_connection_);
+    RTC_DCHECK(!peer_connection_factory_);
+
+    fake_network_manager_.reset(new rtc::FakeNetworkManager());
+    fake_network_manager_->AddInterface(kDefaultLocalAddress);
+
+    std::unique_ptr<cricket::PortAllocator> port_allocator(
+        new cricket::BasicPortAllocator(
+            fake_network_manager_.get(),
+            std::make_unique<rtc::BasicPacketSocketFactory>(socket_server)));
+    port_allocator_ = port_allocator.get();
+    fake_audio_capture_module_ = FakeAudioCaptureModule::Create();
+    if (!fake_audio_capture_module_) {
+      return false;
+    }
+    rtc::Thread* const signaling_thread = rtc::Thread::Current();
+
+    webrtc::PeerConnectionFactoryDependencies pc_factory_dependencies;
+    pc_factory_dependencies.network_thread = network_thread;
+    pc_factory_dependencies.worker_thread = worker_thread;
+    pc_factory_dependencies.signaling_thread = signaling_thread;
+    pc_factory_dependencies.task_queue_factory =
+        webrtc::CreateDefaultTaskQueueFactory();
+    pc_factory_dependencies.trials = std::make_unique<FieldTrialBasedConfig>();
+    pc_factory_dependencies.metronome =
+        std::make_unique<TaskQueueMetronome>(TimeDelta::Millis(8));
+    cricket::MediaEngineDependencies media_deps;
+    media_deps.task_queue_factory =
+        pc_factory_dependencies.task_queue_factory.get();
+    media_deps.adm = fake_audio_capture_module_;
+    webrtc::SetMediaEngineDefaults(&media_deps);
+
+    if (reset_encoder_factory) {
+      media_deps.video_encoder_factory.reset();
+    }
+    if (reset_decoder_factory) {
+      media_deps.video_decoder_factory.reset();
+    }
+
+    if (!media_deps.audio_processing) {
+      // If the standard Creation method for APM returns a null pointer, instead
+      // use the builder for testing to create an APM object.
+      media_deps.audio_processing = AudioProcessingBuilderForTesting().Create();
+    }
+
+    media_deps.trials = pc_factory_dependencies.trials.get();
+
+    if (create_media_engine) {
+      pc_factory_dependencies.media_engine =
+          cricket::CreateMediaEngine(std::move(media_deps));
+    }
+    pc_factory_dependencies.call_factory = webrtc::CreateCallFactory();
+    if (event_log_factory) {
+      event_log_factory_ = event_log_factory.get();
+      pc_factory_dependencies.event_log_factory = std::move(event_log_factory);
+    } else {
+      pc_factory_dependencies.event_log_factory =
+          std::make_unique<webrtc::RtcEventLogFactory>(
+              pc_factory_dependencies.task_queue_factory.get());
+    }
+    peer_connection_factory_ = webrtc::CreateModularPeerConnectionFactory(
+        std::move(pc_factory_dependencies));
+
+    if (!peer_connection_factory_) {
+      return false;
+    }
+    if (options) {
+      peer_connection_factory_->SetOptions(*options);
+    }
+    if (config) {
+      sdp_semantics_ = config->sdp_semantics;
+    }
+
+    dependencies.allocator = std::move(port_allocator);
+    peer_connection_ = CreatePeerConnection(config, std::move(dependencies));
+    return peer_connection_.get() != nullptr;
+  }
+
+  rtc::scoped_refptr<webrtc::PeerConnectionInterface> CreatePeerConnection(
+      const PeerConnectionInterface::RTCConfiguration* config,
+      webrtc::PeerConnectionDependencies dependencies) {
+    PeerConnectionInterface::RTCConfiguration modified_config;
+    modified_config.sdp_semantics = sdp_semantics_;
+    // If `config` is null, this will result in a default configuration being
+    // used.
+    if (config) {
+      modified_config = *config;
+    }
+    // Disable resolution adaptation; we don't want it interfering with the
+    // test results.
+    // TODO(deadbeef): Do something more robust. Since we're testing for aspect
+    // ratios and not specific resolutions, is this even necessary?
+    modified_config.set_cpu_adaptation(false);
+
+    dependencies.observer = this;
+    auto peer_connection_or_error =
+        peer_connection_factory_->CreatePeerConnectionOrError(
+            modified_config, std::move(dependencies));
+    return peer_connection_or_error.ok() ? peer_connection_or_error.MoveValue()
+                                         : nullptr;
+  }
+
+  void set_signaling_message_receiver(
+      SignalingMessageReceiver* signaling_message_receiver) {
+    signaling_message_receiver_ = signaling_message_receiver;
+  }
+
+  void set_signaling_delay_ms(int delay_ms) { signaling_delay_ms_ = delay_ms; }
+
+  void set_signal_ice_candidates(bool signal) {
+    signal_ice_candidates_ = signal;
+  }
+
+  rtc::scoped_refptr<webrtc::VideoTrackInterface> CreateLocalVideoTrackInternal(
+      webrtc::FakePeriodicVideoSource::Config config) {
+    // Set max frame rate to 10fps to reduce the risk of test flakiness.
+    // TODO(deadbeef): Do something more robust.
+    config.frame_interval_ms = 100;
+
+    video_track_sources_.emplace_back(
+        rtc::make_ref_counted<webrtc::FakePeriodicVideoTrackSource>(
+            config, false /* remote */));
+    rtc::scoped_refptr<webrtc::VideoTrackInterface> track(
+        peer_connection_factory_->CreateVideoTrack(
+            rtc::CreateRandomUuid(), video_track_sources_.back().get()));
+    if (!local_video_renderer_) {
+      local_video_renderer_.reset(
+          new webrtc::FakeVideoTrackRenderer(track.get()));
+    }
+    return track;
+  }
+
+  void HandleIncomingOffer(const std::string& msg) {
+    RTC_LOG(LS_INFO) << debug_name_ << ": HandleIncomingOffer";
+    std::unique_ptr<SessionDescriptionInterface> desc =
+        webrtc::CreateSessionDescription(SdpType::kOffer, msg);
+    if (received_sdp_munger_) {
+      received_sdp_munger_(desc->description());
+    }
+
+    EXPECT_TRUE(SetRemoteDescription(std::move(desc)));
+    // Setting a remote description may have changed the number of receivers,
+    // so reset the receiver observers.
+    ResetRtpReceiverObservers();
+    if (remote_offer_handler_) {
+      remote_offer_handler_();
+    }
+    auto answer = CreateAnswer();
+    ASSERT_NE(nullptr, answer);
+    EXPECT_TRUE(SetLocalDescriptionAndSendSdpMessage(std::move(answer)));
+  }
+
+  void HandleIncomingAnswer(const std::string& msg) {
+    RTC_LOG(LS_INFO) << debug_name_ << ": HandleIncomingAnswer";
+    std::unique_ptr<SessionDescriptionInterface> desc =
+        webrtc::CreateSessionDescription(SdpType::kAnswer, msg);
+    if (received_sdp_munger_) {
+      received_sdp_munger_(desc->description());
+    }
+
+    EXPECT_TRUE(SetRemoteDescription(std::move(desc)));
+    // Set the RtpReceiverObserver after receivers are created.
+    ResetRtpReceiverObservers();
+  }
+
+  // Returns null on failure.
+  std::unique_ptr<SessionDescriptionInterface> CreateAnswer() {
+    auto observer =
+        rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
+    pc()->CreateAnswer(observer.get(), offer_answer_options_);
+    return WaitForDescriptionFromObserver(observer.get());
+  }
+
+  std::unique_ptr<SessionDescriptionInterface> WaitForDescriptionFromObserver(
+      MockCreateSessionDescriptionObserver* observer) {
+    EXPECT_EQ_WAIT(true, observer->called(), kDefaultTimeout);
+    if (!observer->result()) {
+      return nullptr;
+    }
+    auto description = observer->MoveDescription();
+    if (generated_sdp_munger_) {
+      generated_sdp_munger_(description->description());
+    }
+    return description;
+  }
+
+  // Setting the local description and sending the SDP message over the fake
+  // signaling channel are combined into the same method because the SDP
+  // message needs to be sent as soon as SetLocalDescription finishes, without
+  // waiting for the observer to be called. This ensures that ICE candidates
+  // don't outrace the description.
+  bool SetLocalDescriptionAndSendSdpMessage(
+      std::unique_ptr<SessionDescriptionInterface> desc) {
+    auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
+    RTC_LOG(LS_INFO) << debug_name_ << ": SetLocalDescriptionAndSendSdpMessage";
+    SdpType type = desc->GetType();
+    std::string sdp;
+    EXPECT_TRUE(desc->ToString(&sdp));
+    RTC_LOG(LS_INFO) << debug_name_ << ": local SDP contents=\n" << sdp;
+    pc()->SetLocalDescription(observer.get(), desc.release());
+    RemoveUnusedVideoRenderers();
+    // As mentioned above, we need to send the message immediately after
+    // SetLocalDescription.
+    SendSdpMessage(type, sdp);
+    EXPECT_TRUE_WAIT(observer->called(), kDefaultTimeout);
+    return true;
+  }
+
+  bool SetRemoteDescription(std::unique_ptr<SessionDescriptionInterface> desc) {
+    auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
+    RTC_LOG(LS_INFO) << debug_name_ << ": SetRemoteDescription";
+    pc()->SetRemoteDescription(observer.get(), desc.release());
+    RemoveUnusedVideoRenderers();
+    EXPECT_TRUE_WAIT(observer->called(), kDefaultTimeout);
+    return observer->result();
+  }
+
+  // This is a work around to remove unused fake_video_renderers from
+  // transceivers that have either stopped or are no longer receiving.
+  void RemoveUnusedVideoRenderers() {
+    if (sdp_semantics_ != SdpSemantics::kUnifiedPlan) {
+      return;
+    }
+    auto transceivers = pc()->GetTransceivers();
+    std::set<std::string> active_renderers;
+    for (auto& transceiver : transceivers) {
+      // Note - we don't check for direction here. This function is called
+      // before direction is set, and in that case, we should not remove
+      // the renderer.
+      if (transceiver->receiver()->media_type() == cricket::MEDIA_TYPE_VIDEO) {
+        active_renderers.insert(transceiver->receiver()->track()->id());
+      }
+    }
+    for (auto it = fake_video_renderers_.begin();
+         it != fake_video_renderers_.end();) {
+      // Remove fake video renderers belonging to any non-active transceivers.
+      if (!active_renderers.count(it->first)) {
+        it = fake_video_renderers_.erase(it);
+      } else {
+        it++;
+      }
+    }
+  }
+
+  // Simulate sending a blob of SDP with delay `signaling_delay_ms_` (0 by
+  // default).
+  void SendSdpMessage(SdpType type, const std::string& msg) {
+    if (signaling_delay_ms_ == 0) {
+      RelaySdpMessageIfReceiverExists(type, msg);
+    } else {
+      rtc::Thread::Current()->PostDelayedTask(
+          SafeTask(task_safety_.flag(),
+                   [this, type, msg] {
+                     RelaySdpMessageIfReceiverExists(type, msg);
+                   }),
+          TimeDelta::Millis(signaling_delay_ms_));
+    }
+  }
+
+  void RelaySdpMessageIfReceiverExists(SdpType type, const std::string& msg) {
+    if (signaling_message_receiver_) {
+      signaling_message_receiver_->ReceiveSdpMessage(type, msg);
+    }
+  }
+
+  // Simulate trickling an ICE candidate with delay `signaling_delay_ms_` (0 by
+  // default).
+  void SendIceMessage(const std::string& sdp_mid,
+                      int sdp_mline_index,
+                      const std::string& msg) {
+    if (signaling_delay_ms_ == 0) {
+      RelayIceMessageIfReceiverExists(sdp_mid, sdp_mline_index, msg);
+    } else {
+      rtc::Thread::Current()->PostDelayedTask(
+          SafeTask(task_safety_.flag(),
+                   [this, sdp_mid, sdp_mline_index, msg] {
+                     RelayIceMessageIfReceiverExists(sdp_mid, sdp_mline_index,
+                                                     msg);
+                   }),
+          TimeDelta::Millis(signaling_delay_ms_));
+    }
+  }
+
+  void RelayIceMessageIfReceiverExists(const std::string& sdp_mid,
+                                       int sdp_mline_index,
+                                       const std::string& msg) {
+    if (signaling_message_receiver_) {
+      signaling_message_receiver_->ReceiveIceMessage(sdp_mid, sdp_mline_index,
+                                                     msg);
+    }
+  }
+
+  // SignalingMessageReceiver callbacks.
+  void ReceiveSdpMessage(SdpType type, const std::string& msg) override {
+    if (type == SdpType::kOffer) {
+      HandleIncomingOffer(msg);
+    } else {
+      HandleIncomingAnswer(msg);
+    }
+  }
+
+  void ReceiveIceMessage(const std::string& sdp_mid,
+                         int sdp_mline_index,
+                         const std::string& msg) override {
+    RTC_LOG(LS_INFO) << debug_name_ << ": ReceiveIceMessage";
+    absl::optional<RTCError> result;
+    pc()->AddIceCandidate(absl::WrapUnique(webrtc::CreateIceCandidate(
+                              sdp_mid, sdp_mline_index, msg, nullptr)),
+                          [&result](RTCError r) { result = r; });
+    EXPECT_TRUE_WAIT(result.has_value(), kDefaultTimeout);
+    EXPECT_TRUE(result.value().ok());
+  }
+
+  // PeerConnectionObserver callbacks.
+  void OnSignalingChange(
+      webrtc::PeerConnectionInterface::SignalingState new_state) override {
+    EXPECT_EQ(pc()->signaling_state(), new_state);
+    peer_connection_signaling_state_history_.push_back(new_state);
+  }
+  void OnAddTrack(rtc::scoped_refptr<RtpReceiverInterface> receiver,
+                  const std::vector<rtc::scoped_refptr<MediaStreamInterface>>&
+                      streams) override {
+    if (receiver->media_type() == cricket::MEDIA_TYPE_VIDEO) {
+      rtc::scoped_refptr<VideoTrackInterface> video_track(
+          static_cast<VideoTrackInterface*>(receiver->track().get()));
+      ASSERT_TRUE(fake_video_renderers_.find(video_track->id()) ==
+                  fake_video_renderers_.end());
+      fake_video_renderers_[video_track->id()] =
+          std::make_unique<FakeVideoTrackRenderer>(video_track.get());
+    }
+  }
+  void OnRemoveTrack(
+      rtc::scoped_refptr<RtpReceiverInterface> receiver) override {
+    if (receiver->media_type() == cricket::MEDIA_TYPE_VIDEO) {
+      auto it = fake_video_renderers_.find(receiver->track()->id());
+      if (it != fake_video_renderers_.end()) {
+        fake_video_renderers_.erase(it);
+      } else {
+        RTC_LOG(LS_ERROR) << "OnRemoveTrack called for non-active renderer";
+      }
+    }
+  }
+  void OnRenegotiationNeeded() override {}
+  void OnIceConnectionChange(
+      webrtc::PeerConnectionInterface::IceConnectionState new_state) override {
+    EXPECT_EQ(pc()->ice_connection_state(), new_state);
+    ice_connection_state_history_.push_back(new_state);
+  }
+  void OnStandardizedIceConnectionChange(
+      webrtc::PeerConnectionInterface::IceConnectionState new_state) override {
+    standardized_ice_connection_state_history_.push_back(new_state);
+  }
+  void OnConnectionChange(
+      webrtc::PeerConnectionInterface::PeerConnectionState new_state) override {
+    peer_connection_state_history_.push_back(new_state);
+  }
+
+  void OnIceGatheringChange(
+      webrtc::PeerConnectionInterface::IceGatheringState new_state) override {
+    EXPECT_EQ(pc()->ice_gathering_state(), new_state);
+    ice_gathering_state_history_.push_back(new_state);
+  }
+
+  void OnIceSelectedCandidatePairChanged(
+      const cricket::CandidatePairChangeEvent& event) {
+    ice_candidate_pair_change_history_.push_back(event);
+  }
+
+  void OnIceCandidate(const webrtc::IceCandidateInterface* candidate) override {
+    RTC_LOG(LS_INFO) << debug_name_ << ": OnIceCandidate";
+
+    if (remote_async_resolver_) {
+      const auto& local_candidate = candidate->candidate();
+      if (local_candidate.address().IsUnresolvedIP()) {
+        RTC_DCHECK(local_candidate.type() == cricket::LOCAL_PORT_TYPE);
+        rtc::SocketAddress resolved_addr(local_candidate.address());
+        const auto resolved_ip = mdns_responder_->GetMappedAddressForName(
+            local_candidate.address().hostname());
+        RTC_DCHECK(!resolved_ip.IsNil());
+        resolved_addr.SetResolvedIP(resolved_ip);
+        EXPECT_CALL(*remote_async_resolver_, GetResolvedAddress(_, _))
+            .WillOnce(DoAll(SetArgPointee<1>(resolved_addr), Return(true)));
+        EXPECT_CALL(*remote_async_resolver_, Destroy(_));
+      }
+    }
+
+    // Check if we expected to have a candidate.
+    EXPECT_GT(candidates_expected_, 1);
+    candidates_expected_--;
+    std::string ice_sdp;
+    EXPECT_TRUE(candidate->ToString(&ice_sdp));
+    if (signaling_message_receiver_ == nullptr || !signal_ice_candidates_) {
+      // Remote party may be deleted.
+      return;
+    }
+    SendIceMessage(candidate->sdp_mid(), candidate->sdp_mline_index(), ice_sdp);
+    last_candidate_gathered_ = candidate->candidate();
+  }
+  void OnIceCandidateError(const std::string& address,
+                           int port,
+                           const std::string& url,
+                           int error_code,
+                           const std::string& error_text) override {
+    error_event_ = cricket::IceCandidateErrorEvent(address, port, url,
+                                                   error_code, error_text);
+  }
+  void OnDataChannel(
+      rtc::scoped_refptr<DataChannelInterface> data_channel) override {
+    RTC_LOG(LS_INFO) << debug_name_ << ": OnDataChannel";
+    data_channels_.push_back(data_channel);
+    data_observers_.push_back(
+        std::make_unique<MockDataChannelObserver>(data_channel.get()));
+  }
+
+  std::string debug_name_;
+
+  std::unique_ptr<rtc::FakeNetworkManager> fake_network_manager_;
+  // Reference to the mDNS responder owned by `fake_network_manager_` after set.
+  webrtc::FakeMdnsResponder* mdns_responder_ = nullptr;
+
+  rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection_;
+  rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface>
+      peer_connection_factory_;
+
+  cricket::PortAllocator* port_allocator_;
+  // Needed to keep track of number of frames sent.
+  rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
+  // Needed to keep track of number of frames received.
+  std::map<std::string, std::unique_ptr<webrtc::FakeVideoTrackRenderer>>
+      fake_video_renderers_;
+  // Needed to ensure frames aren't received for removed tracks.
+  std::vector<std::unique_ptr<webrtc::FakeVideoTrackRenderer>>
+      removed_fake_video_renderers_;
+
+  // For remote peer communication.
+  SignalingMessageReceiver* signaling_message_receiver_ = nullptr;
+  int signaling_delay_ms_ = 0;
+  bool signal_ice_candidates_ = true;
+  cricket::Candidate last_candidate_gathered_;
+  cricket::IceCandidateErrorEvent error_event_;
+
+  // Store references to the video sources we've created, so that we can stop
+  // them, if required.
+  std::vector<rtc::scoped_refptr<webrtc::VideoTrackSource>>
+      video_track_sources_;
+  // `local_video_renderer_` attached to the first created local video track.
+  std::unique_ptr<webrtc::FakeVideoTrackRenderer> local_video_renderer_;
+
+  SdpSemantics sdp_semantics_;
+  PeerConnectionInterface::RTCOfferAnswerOptions offer_answer_options_;
+  std::function<void(cricket::SessionDescription*)> received_sdp_munger_;
+  std::function<void(cricket::SessionDescription*)> generated_sdp_munger_;
+  std::function<void()> remote_offer_handler_;
+  rtc::MockAsyncResolver* remote_async_resolver_ = nullptr;
+  // All data channels either created or observed on this peerconnection
+  std::vector<rtc::scoped_refptr<DataChannelInterface>> data_channels_;
+  std::vector<std::unique_ptr<MockDataChannelObserver>> data_observers_;
+
+  std::vector<std::unique_ptr<MockRtpReceiverObserver>> rtp_receiver_observers_;
+
+  std::vector<PeerConnectionInterface::IceConnectionState>
+      ice_connection_state_history_;
+  std::vector<PeerConnectionInterface::IceConnectionState>
+      standardized_ice_connection_state_history_;
+  std::vector<PeerConnectionInterface::PeerConnectionState>
+      peer_connection_state_history_;
+  std::vector<PeerConnectionInterface::IceGatheringState>
+      ice_gathering_state_history_;
+  std::vector<cricket::CandidatePairChangeEvent>
+      ice_candidate_pair_change_history_;
+  std::vector<PeerConnectionInterface::SignalingState>
+      peer_connection_signaling_state_history_;
+  webrtc::FakeRtcEventLogFactory* event_log_factory_;
+
+  // Number of ICE candidates expected. The default is no limit.
+  int candidates_expected_ = std::numeric_limits<int>::max();
+
+  // Variables for tracking delay stats on an audio track
+  int audio_packets_stat_ = 0;
+  double audio_delay_stat_ = 0.0;
+  uint64_t audio_samples_stat_ = 0;
+  uint64_t audio_concealed_stat_ = 0;
+  std::string rtp_stats_id_;
+
+  ScopedTaskSafety task_safety_;
+
+  friend class PeerConnectionIntegrationBaseTest;
+};
+
+class MockRtcEventLogOutput : public webrtc::RtcEventLogOutput {
+ public:
+  virtual ~MockRtcEventLogOutput() = default;
+  MOCK_METHOD(bool, IsActive, (), (const, override));
+  MOCK_METHOD(bool, Write, (absl::string_view), (override));
+};
+
+// This helper object is used for both specifying how many audio/video frames
+// are expected to be received for a caller/callee. It provides helper functions
+// to specify these expectations. The object initially starts in a state of no
+// expectations.
+class MediaExpectations {
+ public:
+  enum ExpectFrames {
+    kExpectSomeFrames,
+    kExpectNoFrames,
+    kNoExpectation,
+  };
+
+  void ExpectBidirectionalAudioAndVideo() {
+    ExpectBidirectionalAudio();
+    ExpectBidirectionalVideo();
+  }
+
+  void ExpectBidirectionalAudio() {
+    CallerExpectsSomeAudio();
+    CalleeExpectsSomeAudio();
+  }
+
+  void ExpectNoAudio() {
+    CallerExpectsNoAudio();
+    CalleeExpectsNoAudio();
+  }
+
+  void ExpectBidirectionalVideo() {
+    CallerExpectsSomeVideo();
+    CalleeExpectsSomeVideo();
+  }
+
+  void ExpectNoVideo() {
+    CallerExpectsNoVideo();
+    CalleeExpectsNoVideo();
+  }
+
+  void CallerExpectsSomeAudioAndVideo() {
+    CallerExpectsSomeAudio();
+    CallerExpectsSomeVideo();
+  }
+
+  void CalleeExpectsSomeAudioAndVideo() {
+    CalleeExpectsSomeAudio();
+    CalleeExpectsSomeVideo();
+  }
+
+  // Caller's audio functions.
+  void CallerExpectsSomeAudio(
+      int expected_audio_frames = kDefaultExpectedAudioFrameCount) {
+    caller_audio_expectation_ = kExpectSomeFrames;
+    caller_audio_frames_expected_ = expected_audio_frames;
+  }
+
+  void CallerExpectsNoAudio() {
+    caller_audio_expectation_ = kExpectNoFrames;
+    caller_audio_frames_expected_ = 0;
+  }
+
+  // Caller's video functions.
+  void CallerExpectsSomeVideo(
+      int expected_video_frames = kDefaultExpectedVideoFrameCount) {
+    caller_video_expectation_ = kExpectSomeFrames;
+    caller_video_frames_expected_ = expected_video_frames;
+  }
+
+  void CallerExpectsNoVideo() {
+    caller_video_expectation_ = kExpectNoFrames;
+    caller_video_frames_expected_ = 0;
+  }
+
+  // Callee's audio functions.
+  void CalleeExpectsSomeAudio(
+      int expected_audio_frames = kDefaultExpectedAudioFrameCount) {
+    callee_audio_expectation_ = kExpectSomeFrames;
+    callee_audio_frames_expected_ = expected_audio_frames;
+  }
+
+  void CalleeExpectsNoAudio() {
+    callee_audio_expectation_ = kExpectNoFrames;
+    callee_audio_frames_expected_ = 0;
+  }
+
+  // Callee's video functions.
+  void CalleeExpectsSomeVideo(
+      int expected_video_frames = kDefaultExpectedVideoFrameCount) {
+    callee_video_expectation_ = kExpectSomeFrames;
+    callee_video_frames_expected_ = expected_video_frames;
+  }
+
+  void CalleeExpectsNoVideo() {
+    callee_video_expectation_ = kExpectNoFrames;
+    callee_video_frames_expected_ = 0;
+  }
+
+  ExpectFrames caller_audio_expectation_ = kNoExpectation;
+  ExpectFrames caller_video_expectation_ = kNoExpectation;
+  ExpectFrames callee_audio_expectation_ = kNoExpectation;
+  ExpectFrames callee_video_expectation_ = kNoExpectation;
+  int caller_audio_frames_expected_ = 0;
+  int caller_video_frames_expected_ = 0;
+  int callee_audio_frames_expected_ = 0;
+  int callee_video_frames_expected_ = 0;
+};
+
+class MockIceTransport : public webrtc::IceTransportInterface {
+ public:
+  MockIceTransport(const std::string& name, int component)
+      : internal_(std::make_unique<cricket::FakeIceTransport>(
+            name,
+            component,
+            nullptr /* network_thread */)) {}
+  ~MockIceTransport() = default;
+  cricket::IceTransportInternal* internal() { return internal_.get(); }
+
+ private:
+  std::unique_ptr<cricket::FakeIceTransport> internal_;
+};
+
+class MockIceTransportFactory : public IceTransportFactory {
+ public:
+  ~MockIceTransportFactory() override = default;
+  rtc::scoped_refptr<IceTransportInterface> CreateIceTransport(
+      const std::string& transport_name,
+      int component,
+      IceTransportInit init) {
+    RecordIceTransportCreated();
+    return rtc::make_ref_counted<MockIceTransport>(transport_name, component);
+  }
+  MOCK_METHOD(void, RecordIceTransportCreated, ());
+};
+
+// Tests two PeerConnections connecting to each other end-to-end, using a
+// virtual network, fake A/V capture and fake encoder/decoders. The
+// PeerConnections share the threads/socket servers, but use separate versions
+// of everything else (including "PeerConnectionFactory"s).
+class PeerConnectionIntegrationBaseTest : public ::testing::Test {
+ public:
+  PeerConnectionIntegrationBaseTest(
+      SdpSemantics sdp_semantics,
+      absl::optional<std::string> field_trials = absl::nullopt)
+      : sdp_semantics_(sdp_semantics),
+        ss_(new rtc::VirtualSocketServer()),
+        fss_(new rtc::FirewallSocketServer(ss_.get())),
+        network_thread_(new rtc::Thread(fss_.get())),
+        worker_thread_(rtc::Thread::Create()),
+        // TODO(bugs.webrtc.org/10335): Pass optional ScopedKeyValueConfig.
+        field_trials_(new test::ScopedKeyValueConfig(
+            field_trials.has_value() ? *field_trials : "")) {
+    network_thread_->SetName("PCNetworkThread", this);
+    worker_thread_->SetName("PCWorkerThread", this);
+    RTC_CHECK(network_thread_->Start());
+    RTC_CHECK(worker_thread_->Start());
+    webrtc::metrics::Reset();
+  }
+
+  ~PeerConnectionIntegrationBaseTest() {
+    // The PeerConnections should be deleted before the TurnCustomizers.
+    // A TurnPort is created with a raw pointer to a TurnCustomizer. The
+    // TurnPort has the same lifetime as the PeerConnection, so it's expected
+    // that the TurnCustomizer outlives the life of the PeerConnection or else
+    // when Send() is called it will hit a seg fault.
+    if (caller_) {
+      caller_->set_signaling_message_receiver(nullptr);
+      caller_->pc()->Close();
+      delete SetCallerPcWrapperAndReturnCurrent(nullptr);
+    }
+    if (callee_) {
+      callee_->set_signaling_message_receiver(nullptr);
+      callee_->pc()->Close();
+      delete SetCalleePcWrapperAndReturnCurrent(nullptr);
+    }
+
+    // If turn servers were created for the test they need to be destroyed on
+    // the network thread.
+    SendTask(network_thread(), [this] {
+      turn_servers_.clear();
+      turn_customizers_.clear();
+    });
+  }
+
+  bool SignalingStateStable() {
+    return caller_->SignalingStateStable() && callee_->SignalingStateStable();
+  }
+
+  bool DtlsConnected() {
+    // TODO(deadbeef): kIceConnectionConnected currently means both ICE and DTLS
+    // are connected. This is an important distinction. Once we have separate
+    // ICE and DTLS state, this check needs to use the DTLS state.
+    return (callee()->ice_connection_state() ==
+                webrtc::PeerConnectionInterface::kIceConnectionConnected ||
+            callee()->ice_connection_state() ==
+                webrtc::PeerConnectionInterface::kIceConnectionCompleted) &&
+           (caller()->ice_connection_state() ==
+                webrtc::PeerConnectionInterface::kIceConnectionConnected ||
+            caller()->ice_connection_state() ==
+                webrtc::PeerConnectionInterface::kIceConnectionCompleted);
+  }
+
+  // When `event_log_factory` is null, the default implementation of the event
+  // log factory will be used.
+  std::unique_ptr<PeerConnectionIntegrationWrapper> CreatePeerConnectionWrapper(
+      const std::string& debug_name,
+      const PeerConnectionFactory::Options* options,
+      const RTCConfiguration* config,
+      webrtc::PeerConnectionDependencies dependencies,
+      std::unique_ptr<webrtc::FakeRtcEventLogFactory> event_log_factory,
+      bool reset_encoder_factory,
+      bool reset_decoder_factory,
+      bool create_media_engine = true) {
+    RTCConfiguration modified_config;
+    if (config) {
+      modified_config = *config;
+    }
+    modified_config.sdp_semantics = sdp_semantics_;
+    if (!dependencies.cert_generator) {
+      dependencies.cert_generator =
+          std::make_unique<FakeRTCCertificateGenerator>();
+    }
+    std::unique_ptr<PeerConnectionIntegrationWrapper> client(
+        new PeerConnectionIntegrationWrapper(debug_name));
+
+    if (!client->Init(options, &modified_config, std::move(dependencies),
+                      fss_.get(), network_thread_.get(), worker_thread_.get(),
+                      std::move(event_log_factory), reset_encoder_factory,
+                      reset_decoder_factory, create_media_engine)) {
+      return nullptr;
+    }
+    return client;
+  }
+
+  std::unique_ptr<PeerConnectionIntegrationWrapper>
+  CreatePeerConnectionWrapperWithFakeRtcEventLog(
+      const std::string& debug_name,
+      const PeerConnectionFactory::Options* options,
+      const RTCConfiguration* config,
+      webrtc::PeerConnectionDependencies dependencies) {
+    return CreatePeerConnectionWrapper(
+        debug_name, options, config, std::move(dependencies),
+        std::make_unique<webrtc::FakeRtcEventLogFactory>(),
+        /*reset_encoder_factory=*/false,
+        /*reset_decoder_factory=*/false);
+  }
+
+  bool CreatePeerConnectionWrappers() {
+    return CreatePeerConnectionWrappersWithConfig(
+        PeerConnectionInterface::RTCConfiguration(),
+        PeerConnectionInterface::RTCConfiguration());
+  }
+
+  bool CreatePeerConnectionWrappersWithSdpSemantics(
+      SdpSemantics caller_semantics,
+      SdpSemantics callee_semantics) {
+    // Can't specify the sdp_semantics in the passed-in configuration since it
+    // will be overwritten by CreatePeerConnectionWrapper with whatever is
+    // stored in sdp_semantics_. So get around this by modifying the instance
+    // variable before calling CreatePeerConnectionWrapper for the caller and
+    // callee PeerConnections.
+    SdpSemantics original_semantics = sdp_semantics_;
+    sdp_semantics_ = caller_semantics;
+    caller_ = CreatePeerConnectionWrapper(
+        "Caller", nullptr, nullptr, webrtc::PeerConnectionDependencies(nullptr),
+        nullptr,
+        /*reset_encoder_factory=*/false,
+        /*reset_decoder_factory=*/false);
+    sdp_semantics_ = callee_semantics;
+    callee_ = CreatePeerConnectionWrapper(
+        "Callee", nullptr, nullptr, webrtc::PeerConnectionDependencies(nullptr),
+        nullptr,
+        /*reset_encoder_factory=*/false,
+        /*reset_decoder_factory=*/false);
+    sdp_semantics_ = original_semantics;
+    return caller_ && callee_;
+  }
+
+  bool CreatePeerConnectionWrappersWithConfig(
+      const PeerConnectionInterface::RTCConfiguration& caller_config,
+      const PeerConnectionInterface::RTCConfiguration& callee_config) {
+    caller_ = CreatePeerConnectionWrapper(
+        "Caller", nullptr, &caller_config,
+        webrtc::PeerConnectionDependencies(nullptr), nullptr,
+        /*reset_encoder_factory=*/false,
+        /*reset_decoder_factory=*/false);
+    callee_ = CreatePeerConnectionWrapper(
+        "Callee", nullptr, &callee_config,
+        webrtc::PeerConnectionDependencies(nullptr), nullptr,
+        /*reset_encoder_factory=*/false,
+        /*reset_decoder_factory=*/false);
+    return caller_ && callee_;
+  }
+
+  bool CreatePeerConnectionWrappersWithConfigAndDeps(
+      const PeerConnectionInterface::RTCConfiguration& caller_config,
+      webrtc::PeerConnectionDependencies caller_dependencies,
+      const PeerConnectionInterface::RTCConfiguration& callee_config,
+      webrtc::PeerConnectionDependencies callee_dependencies) {
+    caller_ =
+        CreatePeerConnectionWrapper("Caller", nullptr, &caller_config,
+                                    std::move(caller_dependencies), nullptr,
+                                    /*reset_encoder_factory=*/false,
+                                    /*reset_decoder_factory=*/false);
+    callee_ =
+        CreatePeerConnectionWrapper("Callee", nullptr, &callee_config,
+                                    std::move(callee_dependencies), nullptr,
+                                    /*reset_encoder_factory=*/false,
+                                    /*reset_decoder_factory=*/false);
+    return caller_ && callee_;
+  }
+
+  bool CreatePeerConnectionWrappersWithOptions(
+      const PeerConnectionFactory::Options& caller_options,
+      const PeerConnectionFactory::Options& callee_options) {
+    caller_ = CreatePeerConnectionWrapper(
+        "Caller", &caller_options, nullptr,
+        webrtc::PeerConnectionDependencies(nullptr), nullptr,
+        /*reset_encoder_factory=*/false,
+        /*reset_decoder_factory=*/false);
+    callee_ = CreatePeerConnectionWrapper(
+        "Callee", &callee_options, nullptr,
+        webrtc::PeerConnectionDependencies(nullptr), nullptr,
+        /*reset_encoder_factory=*/false,
+        /*reset_decoder_factory=*/false);
+    return caller_ && callee_;
+  }
+
+  bool CreatePeerConnectionWrappersWithFakeRtcEventLog() {
+    PeerConnectionInterface::RTCConfiguration default_config;
+    caller_ = CreatePeerConnectionWrapperWithFakeRtcEventLog(
+        "Caller", nullptr, &default_config,
+        webrtc::PeerConnectionDependencies(nullptr));
+    callee_ = CreatePeerConnectionWrapperWithFakeRtcEventLog(
+        "Callee", nullptr, &default_config,
+        webrtc::PeerConnectionDependencies(nullptr));
+    return caller_ && callee_;
+  }
+
+  std::unique_ptr<PeerConnectionIntegrationWrapper>
+  CreatePeerConnectionWrapperWithAlternateKey() {
+    std::unique_ptr<FakeRTCCertificateGenerator> cert_generator(
+        new FakeRTCCertificateGenerator());
+    cert_generator->use_alternate_key();
+
+    webrtc::PeerConnectionDependencies dependencies(nullptr);
+    dependencies.cert_generator = std::move(cert_generator);
+    return CreatePeerConnectionWrapper("New Peer", nullptr, nullptr,
+                                       std::move(dependencies), nullptr,
+                                       /*reset_encoder_factory=*/false,
+                                       /*reset_decoder_factory=*/false);
+  }
+
+  bool CreateOneDirectionalPeerConnectionWrappers(bool caller_to_callee) {
+    caller_ = CreatePeerConnectionWrapper(
+        "Caller", nullptr, nullptr, webrtc::PeerConnectionDependencies(nullptr),
+        nullptr,
+        /*reset_encoder_factory=*/!caller_to_callee,
+        /*reset_decoder_factory=*/caller_to_callee);
+    callee_ = CreatePeerConnectionWrapper(
+        "Callee", nullptr, nullptr, webrtc::PeerConnectionDependencies(nullptr),
+        nullptr,
+        /*reset_encoder_factory=*/caller_to_callee,
+        /*reset_decoder_factory=*/!caller_to_callee);
+    return caller_ && callee_;
+  }
+
+  bool CreatePeerConnectionWrappersWithoutMediaEngine() {
+    caller_ = CreatePeerConnectionWrapper(
+        "Caller", nullptr, nullptr, webrtc::PeerConnectionDependencies(nullptr),
+        nullptr,
+        /*reset_encoder_factory=*/false,
+        /*reset_decoder_factory=*/false,
+        /*create_media_engine=*/false);
+    callee_ = CreatePeerConnectionWrapper(
+        "Callee", nullptr, nullptr, webrtc::PeerConnectionDependencies(nullptr),
+        nullptr,
+        /*reset_encoder_factory=*/false,
+        /*reset_decoder_factory=*/false,
+        /*create_media_engine=*/false);
+    return caller_ && callee_;
+  }
+
+  cricket::TestTurnServer* CreateTurnServer(
+      rtc::SocketAddress internal_address,
+      rtc::SocketAddress external_address,
+      cricket::ProtocolType type = cricket::ProtocolType::PROTO_UDP,
+      const std::string& common_name = "test turn server") {
+    rtc::Thread* thread = network_thread();
+    rtc::SocketFactory* socket_factory = fss_.get();
+    std::unique_ptr<cricket::TestTurnServer> turn_server;
+    SendTask(network_thread(), [&] {
+      turn_server = std::make_unique<cricket::TestTurnServer>(
+          thread, socket_factory, internal_address, external_address, type,
+          /*ignore_bad_certs=*/true, common_name);
+    });
+    turn_servers_.push_back(std::move(turn_server));
+    // Interactions with the turn server should be done on the network thread.
+    return turn_servers_.back().get();
+  }
+
+  cricket::TestTurnCustomizer* CreateTurnCustomizer() {
+    std::unique_ptr<cricket::TestTurnCustomizer> turn_customizer;
+    SendTask(network_thread(), [&] {
+      turn_customizer = std::make_unique<cricket::TestTurnCustomizer>();
+    });
+    turn_customizers_.push_back(std::move(turn_customizer));
+    // Interactions with the turn customizer should be done on the network
+    // thread.
+    return turn_customizers_.back().get();
+  }
+
+  // Checks that the function counters for a TestTurnCustomizer are greater than
+  // 0.
+  void ExpectTurnCustomizerCountersIncremented(
+      cricket::TestTurnCustomizer* turn_customizer) {
+    SendTask(network_thread(), [turn_customizer] {
+      EXPECT_GT(turn_customizer->allow_channel_data_cnt_, 0u);
+      EXPECT_GT(turn_customizer->modify_cnt_, 0u);
+    });
+  }
+
+  // Once called, SDP blobs and ICE candidates will be automatically signaled
+  // between PeerConnections.
+  void ConnectFakeSignaling() {
+    caller_->set_signaling_message_receiver(callee_.get());
+    callee_->set_signaling_message_receiver(caller_.get());
+  }
+
+  // Once called, SDP blobs will be automatically signaled between
+  // PeerConnections. Note that ICE candidates will not be signaled unless they
+  // are in the exchanged SDP blobs.
+  void ConnectFakeSignalingForSdpOnly() {
+    ConnectFakeSignaling();
+    SetSignalIceCandidates(false);
+  }
+
+  void SetSignalingDelayMs(int delay_ms) {
+    caller_->set_signaling_delay_ms(delay_ms);
+    callee_->set_signaling_delay_ms(delay_ms);
+  }
+
+  void SetSignalIceCandidates(bool signal) {
+    caller_->set_signal_ice_candidates(signal);
+    callee_->set_signal_ice_candidates(signal);
+  }
+
+  // Messages may get lost on the unreliable DataChannel, so we send multiple
+  // times to avoid test flakiness.
+  void SendRtpDataWithRetries(webrtc::DataChannelInterface* dc,
+                              const std::string& data,
+                              int retries) {
+    for (int i = 0; i < retries; ++i) {
+      dc->Send(DataBuffer(data));
+    }
+  }
+
+  rtc::Thread* network_thread() { return network_thread_.get(); }
+
+  rtc::VirtualSocketServer* virtual_socket_server() { return ss_.get(); }
+
+  PeerConnectionIntegrationWrapper* caller() { return caller_.get(); }
+
+  // Destroy peerconnections.
+  // This can be used to ensure that all pointers to on-stack mocks
+  // get dropped before exit.
+  void DestroyPeerConnections() {
+    if (caller_) {
+      caller_->pc()->Close();
+    }
+    if (callee_) {
+      callee_->pc()->Close();
+    }
+    caller_.reset();
+    callee_.reset();
+  }
+
+  // Set the `caller_` to the `wrapper` passed in and return the
+  // original `caller_`.
+  PeerConnectionIntegrationWrapper* SetCallerPcWrapperAndReturnCurrent(
+      PeerConnectionIntegrationWrapper* wrapper) {
+    PeerConnectionIntegrationWrapper* old = caller_.release();
+    caller_.reset(wrapper);
+    return old;
+  }
+
+  PeerConnectionIntegrationWrapper* callee() { return callee_.get(); }
+
+  // Set the `callee_` to the `wrapper` passed in and return the
+  // original `callee_`.
+  PeerConnectionIntegrationWrapper* SetCalleePcWrapperAndReturnCurrent(
+      PeerConnectionIntegrationWrapper* wrapper) {
+    PeerConnectionIntegrationWrapper* old = callee_.release();
+    callee_.reset(wrapper);
+    return old;
+  }
+
+  void SetPortAllocatorFlags(uint32_t caller_flags, uint32_t callee_flags) {
+    SendTask(network_thread(), [this, caller_flags] {
+      caller()->port_allocator()->set_flags(caller_flags);
+    });
+    SendTask(network_thread(), [this, callee_flags] {
+      callee()->port_allocator()->set_flags(callee_flags);
+    });
+  }
+
+  rtc::FirewallSocketServer* firewall() const { return fss_.get(); }
+
+  // Expects the provided number of new frames to be received within
+  // kMaxWaitForFramesMs. The new expected frames are specified in
+  // `media_expectations`. Returns false if any of the expectations were
+  // not met.
+  bool ExpectNewFrames(const MediaExpectations& media_expectations) {
+    // Make sure there are no bogus tracks confusing the issue.
+    caller()->RemoveUnusedVideoRenderers();
+    callee()->RemoveUnusedVideoRenderers();
+    // First initialize the expected frame counts based upon the current
+    // frame count.
+    int total_caller_audio_frames_expected = caller()->audio_frames_received();
+    if (media_expectations.caller_audio_expectation_ ==
+        MediaExpectations::kExpectSomeFrames) {
+      total_caller_audio_frames_expected +=
+          media_expectations.caller_audio_frames_expected_;
+    }
+    int total_caller_video_frames_expected =
+        caller()->min_video_frames_received_per_track();
+    if (media_expectations.caller_video_expectation_ ==
+        MediaExpectations::kExpectSomeFrames) {
+      total_caller_video_frames_expected +=
+          media_expectations.caller_video_frames_expected_;
+    }
+    int total_callee_audio_frames_expected = callee()->audio_frames_received();
+    if (media_expectations.callee_audio_expectation_ ==
+        MediaExpectations::kExpectSomeFrames) {
+      total_callee_audio_frames_expected +=
+          media_expectations.callee_audio_frames_expected_;
+    }
+    int total_callee_video_frames_expected =
+        callee()->min_video_frames_received_per_track();
+    if (media_expectations.callee_video_expectation_ ==
+        MediaExpectations::kExpectSomeFrames) {
+      total_callee_video_frames_expected +=
+          media_expectations.callee_video_frames_expected_;
+    }
+
+    // Wait for the expected frames.
+    EXPECT_TRUE_WAIT(caller()->audio_frames_received() >=
+                             total_caller_audio_frames_expected &&
+                         caller()->min_video_frames_received_per_track() >=
+                             total_caller_video_frames_expected &&
+                         callee()->audio_frames_received() >=
+                             total_callee_audio_frames_expected &&
+                         callee()->min_video_frames_received_per_track() >=
+                             total_callee_video_frames_expected,
+                     kMaxWaitForFramesMs);
+    bool expectations_correct =
+        caller()->audio_frames_received() >=
+            total_caller_audio_frames_expected &&
+        caller()->min_video_frames_received_per_track() >=
+            total_caller_video_frames_expected &&
+        callee()->audio_frames_received() >=
+            total_callee_audio_frames_expected &&
+        callee()->min_video_frames_received_per_track() >=
+            total_callee_video_frames_expected;
+
+    // After the combined wait, print out a more detailed message upon
+    // failure.
+    EXPECT_GE(caller()->audio_frames_received(),
+              total_caller_audio_frames_expected);
+    EXPECT_GE(caller()->min_video_frames_received_per_track(),
+              total_caller_video_frames_expected);
+    EXPECT_GE(callee()->audio_frames_received(),
+              total_callee_audio_frames_expected);
+    EXPECT_GE(callee()->min_video_frames_received_per_track(),
+              total_callee_video_frames_expected);
+
+    // We want to make sure nothing unexpected was received.
+    if (media_expectations.caller_audio_expectation_ ==
+        MediaExpectations::kExpectNoFrames) {
+      EXPECT_EQ(caller()->audio_frames_received(),
+                total_caller_audio_frames_expected);
+      if (caller()->audio_frames_received() !=
+          total_caller_audio_frames_expected) {
+        expectations_correct = false;
+      }
+    }
+    if (media_expectations.caller_video_expectation_ ==
+        MediaExpectations::kExpectNoFrames) {
+      EXPECT_EQ(caller()->min_video_frames_received_per_track(),
+                total_caller_video_frames_expected);
+      if (caller()->min_video_frames_received_per_track() !=
+          total_caller_video_frames_expected) {
+        expectations_correct = false;
+      }
+    }
+    if (media_expectations.callee_audio_expectation_ ==
+        MediaExpectations::kExpectNoFrames) {
+      EXPECT_EQ(callee()->audio_frames_received(),
+                total_callee_audio_frames_expected);
+      if (callee()->audio_frames_received() !=
+          total_callee_audio_frames_expected) {
+        expectations_correct = false;
+      }
+    }
+    if (media_expectations.callee_video_expectation_ ==
+        MediaExpectations::kExpectNoFrames) {
+      EXPECT_EQ(callee()->min_video_frames_received_per_track(),
+                total_callee_video_frames_expected);
+      if (callee()->min_video_frames_received_per_track() !=
+          total_callee_video_frames_expected) {
+        expectations_correct = false;
+      }
+    }
+    return expectations_correct;
+  }
+
+  void ClosePeerConnections() {
+    if (caller())
+      caller()->pc()->Close();
+    if (callee())
+      callee()->pc()->Close();
+  }
+
+  void TestNegotiatedCipherSuite(
+      const PeerConnectionFactory::Options& caller_options,
+      const PeerConnectionFactory::Options& callee_options,
+      int expected_cipher_suite) {
+    ASSERT_TRUE(CreatePeerConnectionWrappersWithOptions(caller_options,
+                                                        callee_options));
+    ConnectFakeSignaling();
+    caller()->AddAudioVideoTracks();
+    callee()->AddAudioVideoTracks();
+    caller()->CreateAndSetAndSignalOffer();
+    ASSERT_TRUE_WAIT(DtlsConnected(), kDefaultTimeout);
+    EXPECT_EQ_WAIT(rtc::SrtpCryptoSuiteToName(expected_cipher_suite),
+                   caller()->OldGetStats()->SrtpCipher(), kDefaultTimeout);
+    // TODO(bugs.webrtc.org/9456): Fix it.
+    EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents(
+                            "WebRTC.PeerConnection.SrtpCryptoSuite.Audio",
+                            expected_cipher_suite));
+  }
+
+  void TestGcmNegotiationUsesCipherSuite(bool local_gcm_enabled,
+                                         bool remote_gcm_enabled,
+                                         bool aes_ctr_enabled,
+                                         int expected_cipher_suite) {
+    PeerConnectionFactory::Options caller_options;
+    caller_options.crypto_options.srtp.enable_gcm_crypto_suites =
+        local_gcm_enabled;
+    caller_options.crypto_options.srtp.enable_aes128_sha1_80_crypto_cipher =
+        aes_ctr_enabled;
+    PeerConnectionFactory::Options callee_options;
+    callee_options.crypto_options.srtp.enable_gcm_crypto_suites =
+        remote_gcm_enabled;
+    callee_options.crypto_options.srtp.enable_aes128_sha1_80_crypto_cipher =
+        aes_ctr_enabled;
+    TestNegotiatedCipherSuite(caller_options, callee_options,
+                              expected_cipher_suite);
+  }
+
+  const FieldTrialsView& trials() const { return *field_trials_.get(); }
+
+ protected:
+  SdpSemantics sdp_semantics_;
+
+ private:
+  rtc::AutoThread main_thread_;  // Used as the signal thread by most tests.
+  // `ss_` is used by `network_thread_` so it must be destroyed later.
+  std::unique_ptr<rtc::VirtualSocketServer> ss_;
+  std::unique_ptr<rtc::FirewallSocketServer> fss_;
+  // `network_thread_` and `worker_thread_` are used by both
+  // `caller_` and `callee_` so they must be destroyed
+  // later.
+  std::unique_ptr<rtc::Thread> network_thread_;
+  std::unique_ptr<rtc::Thread> worker_thread_;
+  // The turn servers and turn customizers should be accessed & deleted on the
+  // network thread to avoid a race with the socket read/write that occurs
+  // on the network thread.
+  std::vector<std::unique_ptr<cricket::TestTurnServer>> turn_servers_;
+  std::vector<std::unique_ptr<cricket::TestTurnCustomizer>> turn_customizers_;
+  std::unique_ptr<PeerConnectionIntegrationWrapper> caller_;
+  std::unique_ptr<PeerConnectionIntegrationWrapper> callee_;
+  std::unique_ptr<FieldTrialsView> field_trials_;
+};
+
+}  // namespace webrtc
+
+#endif  // PC_TEST_INTEGRATION_TEST_HELPERS_H_
diff --git a/third_party/libwebrtc/pc/test/mock_channel_interface.h b/third_party/libwebrtc/pc/test/mock_channel_interface.h
new file mode 100644
index 0000000000..41c142d5ba
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/mock_channel_interface.h
@@ -0,0 +1,73 @@
+/*
+ *  Copyright 2018 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.
+ */
+
+#ifndef PC_TEST_MOCK_CHANNEL_INTERFACE_H_
+#define PC_TEST_MOCK_CHANNEL_INTERFACE_H_
+
+#include <string>
+#include <vector>
+
+#include "pc/channel_interface.h"
+#include "test/gmock.h"
+
+namespace cricket {
+
+// Mock class for BaseChannel.
+// Use this class in unit tests to avoid dependecy on a specific
+// implementation of BaseChannel.
+class MockChannelInterface : public cricket::ChannelInterface {
+ public:
+  MOCK_METHOD(cricket::MediaType, media_type, (), (const, override));
+  MOCK_METHOD(VideoChannel*, AsVideoChannel, (), (override));
+  MOCK_METHOD(VoiceChannel*, AsVoiceChannel, (), (override));
+  MOCK_METHOD(MediaChannel*, media_channel, (), (override));
+  MOCK_METHOD(MediaChannel*, media_send_channel, (), (override));
+  MOCK_METHOD(VoiceMediaChannel*, voice_media_send_channel, (), (override));
+  MOCK_METHOD(VideoMediaChannel*, video_media_send_channel, (), (override));
+  MOCK_METHOD(MediaChannel*, media_receive_channel, (), (override));
+  MOCK_METHOD(VoiceMediaChannel*, voice_media_receive_channel, (), (override));
+  MOCK_METHOD(VideoMediaChannel*, video_media_receive_channel, (), (override));
+  MOCK_METHOD(absl::string_view, transport_name, (), (const, override));
+  MOCK_METHOD(const std::string&, mid, (), (const, override));
+  MOCK_METHOD(void, Enable, (bool), (override));
+  MOCK_METHOD(void,
+              SetFirstPacketReceivedCallback,
+              (std::function<void()>),
+              (override));
+  MOCK_METHOD(bool,
+              SetLocalContent,
+              (const cricket::MediaContentDescription*,
+               webrtc::SdpType,
+               std::string&),
+              (override));
+  MOCK_METHOD(bool,
+              SetRemoteContent,
+              (const cricket::MediaContentDescription*,
+               webrtc::SdpType,
+               std::string&),
+              (override));
+  MOCK_METHOD(bool, SetPayloadTypeDemuxingEnabled, (bool), (override));
+  MOCK_METHOD(const std::vector<StreamParams>&,
+              local_streams,
+              (),
+              (const, override));
+  MOCK_METHOD(const std::vector<StreamParams>&,
+              remote_streams,
+              (),
+              (const, override));
+  MOCK_METHOD(bool,
+              SetRtpTransport,
+              (webrtc::RtpTransportInternal*),
+              (override));
+};
+
+}  // namespace cricket
+
+#endif  // PC_TEST_MOCK_CHANNEL_INTERFACE_H_
diff --git a/third_party/libwebrtc/pc/test/mock_data_channel.h b/third_party/libwebrtc/pc/test/mock_data_channel.h
new file mode 100644
index 0000000000..f1c5374d28
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/mock_data_channel.h
@@ -0,0 +1,72 @@
+/*
+ *  Copyright 2016 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.
+ */
+
+#ifndef PC_TEST_MOCK_DATA_CHANNEL_H_
+#define PC_TEST_MOCK_DATA_CHANNEL_H_
+
+#include <string>
+
+#include "pc/sctp_data_channel.h"
+#include "test/gmock.h"
+
+namespace webrtc {
+
+class MockSctpDataChannel : public SctpDataChannel {
+ public:
+  MockSctpDataChannel(int id, DataState state)
+      : MockSctpDataChannel(id,
+                            "MockSctpDataChannel",
+                            state,
+                            "udp",
+                            0,
+                            0,
+                            0,
+                            0) {}
+  MockSctpDataChannel(
+      int id,
+      const std::string& label,
+      DataState state,
+      const std::string& protocol,
+      uint32_t messages_sent,
+      uint64_t bytes_sent,
+      uint32_t messages_received,
+      uint64_t bytes_received,
+      const InternalDataChannelInit& config = InternalDataChannelInit(),
+      rtc::Thread* signaling_thread = rtc::Thread::Current(),
+      rtc::Thread* network_thread = rtc::Thread::Current())
+      : SctpDataChannel(config,
+                        nullptr,
+                        label,
+                        signaling_thread,
+                        network_thread) {
+    EXPECT_CALL(*this, id()).WillRepeatedly(::testing::Return(id));
+    EXPECT_CALL(*this, state()).WillRepeatedly(::testing::Return(state));
+    EXPECT_CALL(*this, protocol()).WillRepeatedly(::testing::Return(protocol));
+    EXPECT_CALL(*this, messages_sent())
+        .WillRepeatedly(::testing::Return(messages_sent));
+    EXPECT_CALL(*this, bytes_sent())
+        .WillRepeatedly(::testing::Return(bytes_sent));
+    EXPECT_CALL(*this, messages_received())
+        .WillRepeatedly(::testing::Return(messages_received));
+    EXPECT_CALL(*this, bytes_received())
+        .WillRepeatedly(::testing::Return(bytes_received));
+  }
+  MOCK_METHOD(int, id, (), (const, override));
+  MOCK_METHOD(DataState, state, (), (const, override));
+  MOCK_METHOD(std::string, protocol, (), (const, override));
+  MOCK_METHOD(uint32_t, messages_sent, (), (const, override));
+  MOCK_METHOD(uint64_t, bytes_sent, (), (const, override));
+  MOCK_METHOD(uint32_t, messages_received, (), (const, override));
+  MOCK_METHOD(uint64_t, bytes_received, (), (const, override));
+};
+
+}  // namespace webrtc
+
+#endif  // PC_TEST_MOCK_DATA_CHANNEL_H_
diff --git a/third_party/libwebrtc/pc/test/mock_peer_connection_internal.h b/third_party/libwebrtc/pc/test/mock_peer_connection_internal.h
new file mode 100644
index 0000000000..23ecc93e43
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/mock_peer_connection_internal.h
@@ -0,0 +1,332 @@
+/*
+ *  Copyright 2022 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.
+ */
+
+#ifndef PC_TEST_MOCK_PEER_CONNECTION_INTERNAL_H_
+#define PC_TEST_MOCK_PEER_CONNECTION_INTERNAL_H_
+
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "modules/audio_device/include/audio_device.h"
+#include "pc/peer_connection_internal.h"
+#include "test/gmock.h"
+
+namespace webrtc {
+
+class MockPeerConnectionInternal : public PeerConnectionInternal {
+ public:
+  MockPeerConnectionInternal() {}
+  ~MockPeerConnectionInternal() = default;
+  // PeerConnectionInterface
+  MOCK_METHOD(rtc::scoped_refptr<StreamCollectionInterface>,
+              local_streams,
+              (),
+              (override));
+  MOCK_METHOD(rtc::scoped_refptr<StreamCollectionInterface>,
+              remote_streams,
+              (),
+              (override));
+  MOCK_METHOD(bool, AddStream, (MediaStreamInterface*), (override));
+  MOCK_METHOD(void, RemoveStream, (MediaStreamInterface*), (override));
+  MOCK_METHOD(RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>>,
+              AddTrack,
+              (rtc::scoped_refptr<MediaStreamTrackInterface>,
+               const std::vector<std::string>&),
+              (override));
+  MOCK_METHOD(RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>>,
+              AddTrack,
+              (rtc::scoped_refptr<MediaStreamTrackInterface>,
+               const std::vector<std::string>&,
+               const std::vector<RtpEncodingParameters>&),
+              (override));
+  MOCK_METHOD(RTCError,
+              RemoveTrackOrError,
+              (rtc::scoped_refptr<RtpSenderInterface>),
+              (override));
+  MOCK_METHOD(RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>,
+              AddTransceiver,
+              (rtc::scoped_refptr<MediaStreamTrackInterface>),
+              (override));
+  MOCK_METHOD(RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>,
+              AddTransceiver,
+              (rtc::scoped_refptr<MediaStreamTrackInterface>,
+               const RtpTransceiverInit&),
+              (override));
+  MOCK_METHOD(RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>,
+              AddTransceiver,
+              (cricket::MediaType),
+              (override));
+  MOCK_METHOD(RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>,
+              AddTransceiver,
+              (cricket::MediaType, const RtpTransceiverInit&),
+              (override));
+  MOCK_METHOD(rtc::scoped_refptr<RtpSenderInterface>,
+              CreateSender,
+              (const std::string&, const std::string&),
+              (override));
+  MOCK_METHOD(std::vector<rtc::scoped_refptr<RtpSenderInterface>>,
+              GetSenders,
+              (),
+              (const, override));
+  MOCK_METHOD(std::vector<rtc::scoped_refptr<RtpReceiverInterface>>,
+              GetReceivers,
+              (),
+              (const, override));
+  MOCK_METHOD(std::vector<rtc::scoped_refptr<RtpTransceiverInterface>>,
+              GetTransceivers,
+              (),
+              (const, override));
+  MOCK_METHOD(bool,
+              GetStats,
+              (StatsObserver*, MediaStreamTrackInterface*, StatsOutputLevel),
+              (override));
+  MOCK_METHOD(void, GetStats, (RTCStatsCollectorCallback*), (override));
+  MOCK_METHOD(void,
+              GetStats,
+              (rtc::scoped_refptr<RtpSenderInterface>,
+               rtc::scoped_refptr<RTCStatsCollectorCallback>),
+              (override));
+  MOCK_METHOD(void,
+              GetStats,
+              (rtc::scoped_refptr<RtpReceiverInterface>,
+               rtc::scoped_refptr<RTCStatsCollectorCallback>),
+              (override));
+  MOCK_METHOD(void, ClearStatsCache, (), (override));
+  MOCK_METHOD(RTCErrorOr<rtc::scoped_refptr<DataChannelInterface>>,
+              CreateDataChannelOrError,
+              (const std::string&, const DataChannelInit*),
+              (override));
+  MOCK_METHOD(SessionDescriptionInterface*,
+              local_description,
+              (),
+              (const, override));
+  MOCK_METHOD(SessionDescriptionInterface*,
+              remote_description,
+              (),
+              (const, override));
+  MOCK_METHOD(SessionDescriptionInterface*,
+              current_local_description,
+              (),
+              (const, override));
+  MOCK_METHOD(SessionDescriptionInterface*,
+              current_remote_description,
+              (),
+              (const, override));
+  MOCK_METHOD(SessionDescriptionInterface*,
+              pending_local_description,
+              (),
+              (const, override));
+  MOCK_METHOD(SessionDescriptionInterface*,
+              pending_remote_description,
+              (),
+              (const, override));
+  MOCK_METHOD(void, RestartIce, (), (override));
+  MOCK_METHOD(void,
+              CreateOffer,
+              (CreateSessionDescriptionObserver*, const RTCOfferAnswerOptions&),
+              (override));
+  MOCK_METHOD(void,
+              CreateAnswer,
+              (CreateSessionDescriptionObserver*, const RTCOfferAnswerOptions&),
+              (override));
+
+  MOCK_METHOD(void,
+              SetLocalDescription,
+              (SetSessionDescriptionObserver*, SessionDescriptionInterface*),
+              (override));
+  MOCK_METHOD(void,
+              SetRemoteDescription,
+              (SetSessionDescriptionObserver*, SessionDescriptionInterface*),
+              (override));
+  MOCK_METHOD(void,
+              SetRemoteDescription,
+              (std::unique_ptr<SessionDescriptionInterface>,
+               rtc::scoped_refptr<SetRemoteDescriptionObserverInterface>),
+              (override));
+  MOCK_METHOD(PeerConnectionInterface::RTCConfiguration,
+              GetConfiguration,
+              (),
+              (override));
+  MOCK_METHOD(RTCError,
+              SetConfiguration,
+              (const PeerConnectionInterface::RTCConfiguration&),
+              (override));
+  MOCK_METHOD(bool,
+              AddIceCandidate,
+              (const IceCandidateInterface*),
+              (override));
+  MOCK_METHOD(bool,
+              RemoveIceCandidates,
+              (const std::vector<cricket::Candidate>&),
+              (override));
+  MOCK_METHOD(RTCError, SetBitrate, (const BitrateSettings&), (override));
+  MOCK_METHOD(void, SetAudioPlayout, (bool), (override));
+  MOCK_METHOD(void, SetAudioRecording, (bool), (override));
+  MOCK_METHOD(rtc::scoped_refptr<DtlsTransportInterface>,
+              LookupDtlsTransportByMid,
+              (const std::string&),
+              (override));
+  MOCK_METHOD(rtc::scoped_refptr<SctpTransportInterface>,
+              GetSctpTransport,
+              (),
+              (const, override));
+  MOCK_METHOD(SignalingState, signaling_state, (), (override));
+  MOCK_METHOD(IceConnectionState, ice_connection_state, (), (override));
+  MOCK_METHOD(IceConnectionState,
+              standardized_ice_connection_state,
+              (),
+              (override));
+  MOCK_METHOD(PeerConnectionState, peer_connection_state, (), (override));
+  MOCK_METHOD(IceGatheringState, ice_gathering_state, (), (override));
+  MOCK_METHOD(absl::optional<bool>, can_trickle_ice_candidates, (), (override));
+  MOCK_METHOD(bool,
+              StartRtcEventLog,
+              (std::unique_ptr<RtcEventLogOutput>, int64_t),
+              (override));
+  MOCK_METHOD(bool,
+              StartRtcEventLog,
+              (std::unique_ptr<RtcEventLogOutput>),
+              (override));
+  MOCK_METHOD(void, StopRtcEventLog, (), (override));
+  MOCK_METHOD(void, Close, (), (override));
+  MOCK_METHOD(rtc::Thread*, signaling_thread, (), (const, override));
+
+  // PeerConnectionSdpMethods
+  MOCK_METHOD(std::string, session_id, (), (const, override));
+  MOCK_METHOD(bool, NeedsIceRestart, (const std::string&), (const, override));
+  MOCK_METHOD(absl::optional<std::string>, sctp_mid, (), (const, override));
+  MOCK_METHOD(PeerConnectionInterface::RTCConfiguration*,
+              configuration,
+              (),
+              (const, override));
+  MOCK_METHOD(void,
+              ReportSdpBundleUsage,
+              (const SessionDescriptionInterface&),
+              (override));
+  MOCK_METHOD(PeerConnectionMessageHandler*, message_handler, (), (override));
+  MOCK_METHOD(RtpTransmissionManager*, rtp_manager, (), (override));
+  MOCK_METHOD(const RtpTransmissionManager*,
+              rtp_manager,
+              (),
+              (const, override));
+  MOCK_METHOD(bool, dtls_enabled, (), (const, override));
+  MOCK_METHOD(const PeerConnectionFactoryInterface::Options*,
+              options,
+              (),
+              (const, override));
+  MOCK_METHOD(CryptoOptions, GetCryptoOptions, (), (override));
+  MOCK_METHOD(JsepTransportController*, transport_controller_s, (), (override));
+  MOCK_METHOD(JsepTransportController*, transport_controller_n, (), (override));
+  MOCK_METHOD(DataChannelController*, data_channel_controller, (), (override));
+  MOCK_METHOD(cricket::PortAllocator*, port_allocator, (), (override));
+  MOCK_METHOD(LegacyStatsCollector*, legacy_stats, (), (override));
+  MOCK_METHOD(PeerConnectionObserver*, Observer, (), (const, override));
+  MOCK_METHOD(bool, GetSctpSslRole, (rtc::SSLRole*), (override));
+  MOCK_METHOD(PeerConnectionInterface::IceConnectionState,
+              ice_connection_state_internal,
+              (),
+              (override));
+  MOCK_METHOD(void,
+              SetIceConnectionState,
+              (PeerConnectionInterface::IceConnectionState),
+              (override));
+  MOCK_METHOD(void, NoteUsageEvent, (UsageEvent), (override));
+  MOCK_METHOD(bool, IsClosed, (), (const, override));
+  MOCK_METHOD(bool, IsUnifiedPlan, (), (const, override));
+  MOCK_METHOD(bool,
+              ValidateBundleSettings,
+              (const cricket::SessionDescription*,
+               (const std::map<std::string, const cricket::ContentGroup*>&)),
+              (override));
+  MOCK_METHOD(absl::optional<std::string>, GetDataMid, (), (const, override));
+  MOCK_METHOD(RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>,
+              AddTransceiver,
+              (cricket::MediaType,
+               rtc::scoped_refptr<MediaStreamTrackInterface>,
+               const RtpTransceiverInit&,
+               bool),
+              (override));
+  MOCK_METHOD(void, StartSctpTransport, (int, int, int), (override));
+  MOCK_METHOD(void,
+              AddRemoteCandidate,
+              (const std::string&, const cricket::Candidate&),
+              (override));
+  MOCK_METHOD(Call*, call_ptr, (), (override));
+  MOCK_METHOD(bool, SrtpRequired, (), (const, override));
+  MOCK_METHOD(bool,
+              SetupDataChannelTransport_n,
+              (const std::string&),
+              (override));
+  MOCK_METHOD(void, TeardownDataChannelTransport_n, (), (override));
+  MOCK_METHOD(void, SetSctpDataMid, (const std::string&), (override));
+  MOCK_METHOD(void, ResetSctpDataMid, (), (override));
+  MOCK_METHOD(const FieldTrialsView&, trials, (), (const, override));
+
+  // PeerConnectionInternal
+  MOCK_METHOD(rtc::Thread*, network_thread, (), (const, override));
+  MOCK_METHOD(rtc::Thread*, worker_thread, (), (const, override));
+  MOCK_METHOD(bool, initial_offerer, (), (const, override));
+  MOCK_METHOD(
+      std::vector<
+          rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>,
+      GetTransceiversInternal,
+      (),
+      (const, override));
+  MOCK_METHOD(sigslot::signal1<SctpDataChannel*>&,
+              SignalSctpDataChannelCreated,
+              (),
+              (override));
+  MOCK_METHOD(std::vector<DataChannelStats>,
+              GetDataChannelStats,
+              (),
+              (const, override));
+  MOCK_METHOD(absl::optional<std::string>,
+              sctp_transport_name,
+              (),
+              (const, override));
+  MOCK_METHOD(cricket::CandidateStatsList,
+              GetPooledCandidateStats,
+              (),
+              (const, override));
+  MOCK_METHOD((std::map<std::string, cricket::TransportStats>),
+              GetTransportStatsByNames,
+              (const std::set<std::string>&),
+              (override));
+  MOCK_METHOD(Call::Stats, GetCallStats, (), (override));
+  MOCK_METHOD(absl::optional<AudioDeviceModule::Stats>,
+              GetAudioDeviceStats,
+              (),
+              (override));
+  MOCK_METHOD(bool,
+              GetLocalCertificate,
+              (const std::string&, rtc::scoped_refptr<rtc::RTCCertificate>*),
+              (override));
+  MOCK_METHOD(std::unique_ptr<rtc::SSLCertChain>,
+              GetRemoteSSLCertChain,
+              (const std::string&),
+              (override));
+  MOCK_METHOD(bool, IceRestartPending, (const std::string&), (const, override));
+  MOCK_METHOD(bool,
+              GetSslRole,
+              (const std::string&, rtc::SSLRole*),
+              (override));
+  MOCK_METHOD(void, NoteDataAddedEvent, (), (override));
+  MOCK_METHOD(void,
+              OnSctpDataChannelClosed,
+              (DataChannelInterface*),
+              (override));
+};
+
+}  // namespace webrtc
+
+#endif  // PC_TEST_MOCK_PEER_CONNECTION_INTERNAL_H_
diff --git a/third_party/libwebrtc/pc/test/mock_peer_connection_observers.h b/third_party/libwebrtc/pc/test/mock_peer_connection_observers.h
new file mode 100644
index 0000000000..e9d97a97f6
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/mock_peer_connection_observers.h
@@ -0,0 +1,599 @@
+/*
+ *  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.
+ */
+
+// This file contains mock implementations of observers used in PeerConnection.
+// TODO(steveanton): These aren't really mocks and should be renamed.
+
+#ifndef PC_TEST_MOCK_PEER_CONNECTION_OBSERVERS_H_
+#define PC_TEST_MOCK_PEER_CONNECTION_OBSERVERS_H_
+
+#include <map>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "api/data_channel_interface.h"
+#include "api/jsep_ice_candidate.h"
+#include "pc/stream_collection.h"
+#include "rtc_base/checks.h"
+
+namespace webrtc {
+
+class MockPeerConnectionObserver : public PeerConnectionObserver {
+ public:
+  struct AddTrackEvent {
+    explicit AddTrackEvent(
+        rtc::scoped_refptr<RtpReceiverInterface> event_receiver,
+        std::vector<rtc::scoped_refptr<MediaStreamInterface>> event_streams)
+        : receiver(std::move(event_receiver)),
+          streams(std::move(event_streams)) {
+      for (auto stream : streams) {
+        std::vector<rtc::scoped_refptr<MediaStreamTrackInterface>> tracks;
+        for (auto audio_track : stream->GetAudioTracks()) {
+          tracks.push_back(audio_track);
+        }
+        for (auto video_track : stream->GetVideoTracks()) {
+          tracks.push_back(video_track);
+        }
+        snapshotted_stream_tracks[stream] = tracks;
+      }
+    }
+
+    rtc::scoped_refptr<RtpReceiverInterface> receiver;
+    std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams;
+    // This map records the tracks present in each stream at the time the
+    // OnAddTrack callback was issued.
+    std::map<rtc::scoped_refptr<MediaStreamInterface>,
+             std::vector<rtc::scoped_refptr<MediaStreamTrackInterface>>>
+        snapshotted_stream_tracks;
+  };
+
+  MockPeerConnectionObserver() : remote_streams_(StreamCollection::Create()) {}
+  virtual ~MockPeerConnectionObserver() {}
+  void SetPeerConnectionInterface(PeerConnectionInterface* pc) {
+    pc_ = pc;
+    if (pc) {
+      state_ = pc_->signaling_state();
+    }
+  }
+  void OnSignalingChange(
+      PeerConnectionInterface::SignalingState new_state) override {
+    RTC_DCHECK(pc_);
+    RTC_DCHECK(pc_->signaling_state() == new_state);
+    state_ = new_state;
+  }
+
+  MediaStreamInterface* RemoteStream(const std::string& label) {
+    return remote_streams_->find(label);
+  }
+  StreamCollectionInterface* remote_streams() const {
+    return remote_streams_.get();
+  }
+  void OnAddStream(rtc::scoped_refptr<MediaStreamInterface> stream) override {
+    last_added_stream_ = stream;
+    remote_streams_->AddStream(stream);
+  }
+  void OnRemoveStream(
+      rtc::scoped_refptr<MediaStreamInterface> stream) override {
+    last_removed_stream_ = stream;
+    remote_streams_->RemoveStream(stream.get());
+  }
+  void OnRenegotiationNeeded() override { renegotiation_needed_ = true; }
+  void OnNegotiationNeededEvent(uint32_t event_id) override {
+    latest_negotiation_needed_event_ = event_id;
+  }
+  void OnDataChannel(
+      rtc::scoped_refptr<DataChannelInterface> data_channel) override {
+    last_datachannel_ = data_channel;
+  }
+
+  void OnIceConnectionChange(
+      PeerConnectionInterface::IceConnectionState new_state) override {
+    RTC_DCHECK(pc_);
+    RTC_DCHECK(pc_->ice_connection_state() == new_state);
+    // When ICE is finished, the caller will get to a kIceConnectionCompleted
+    // state, because it has the ICE controlling role, while the callee
+    // will get to a kIceConnectionConnected state. This means that both ICE
+    // and DTLS are connected.
+    ice_connected_ =
+        (new_state == PeerConnectionInterface::kIceConnectionConnected) ||
+        (new_state == PeerConnectionInterface::kIceConnectionCompleted);
+    callback_triggered_ = true;
+  }
+  void OnIceGatheringChange(
+      PeerConnectionInterface::IceGatheringState new_state) override {
+    RTC_DCHECK(pc_);
+    RTC_DCHECK(pc_->ice_gathering_state() == new_state);
+    ice_gathering_complete_ =
+        new_state == PeerConnectionInterface::kIceGatheringComplete;
+    callback_triggered_ = true;
+  }
+  void OnIceCandidate(const IceCandidateInterface* candidate) override {
+    RTC_DCHECK(pc_);
+    candidates_.push_back(std::make_unique<JsepIceCandidate>(
+        candidate->sdp_mid(), candidate->sdp_mline_index(),
+        candidate->candidate()));
+    callback_triggered_ = true;
+  }
+
+  void OnIceCandidatesRemoved(
+      const std::vector<cricket::Candidate>& candidates) override {
+    num_candidates_removed_++;
+    callback_triggered_ = true;
+  }
+
+  void OnIceConnectionReceivingChange(bool receiving) override {
+    callback_triggered_ = true;
+  }
+
+  void OnAddTrack(rtc::scoped_refptr<RtpReceiverInterface> receiver,
+                  const std::vector<rtc::scoped_refptr<MediaStreamInterface>>&
+                      streams) override {
+    RTC_DCHECK(receiver);
+    num_added_tracks_++;
+    last_added_track_label_ = receiver->id();
+    add_track_events_.push_back(AddTrackEvent(receiver, streams));
+  }
+
+  void OnTrack(
+      rtc::scoped_refptr<RtpTransceiverInterface> transceiver) override {
+    on_track_transceivers_.push_back(transceiver);
+  }
+
+  void OnRemoveTrack(
+      rtc::scoped_refptr<RtpReceiverInterface> receiver) override {
+    remove_track_events_.push_back(receiver);
+  }
+
+  std::vector<rtc::scoped_refptr<RtpReceiverInterface>> GetAddTrackReceivers() {
+    std::vector<rtc::scoped_refptr<RtpReceiverInterface>> receivers;
+    for (const AddTrackEvent& event : add_track_events_) {
+      receivers.push_back(event.receiver);
+    }
+    return receivers;
+  }
+
+  int CountAddTrackEventsForStream(const std::string& stream_id) {
+    int found_tracks = 0;
+    for (const AddTrackEvent& event : add_track_events_) {
+      bool has_stream_id = false;
+      for (auto stream : event.streams) {
+        if (stream->id() == stream_id) {
+          has_stream_id = true;
+          break;
+        }
+      }
+      if (has_stream_id) {
+        ++found_tracks;
+      }
+    }
+    return found_tracks;
+  }
+
+  // Returns the id of the last added stream.
+  // Empty string if no stream have been added.
+  std::string GetLastAddedStreamId() {
+    if (last_added_stream_.get())
+      return last_added_stream_->id();
+    return "";
+  }
+  std::string GetLastRemovedStreamId() {
+    if (last_removed_stream_.get())
+      return last_removed_stream_->id();
+    return "";
+  }
+
+  IceCandidateInterface* last_candidate() {
+    if (candidates_.empty()) {
+      return nullptr;
+    } else {
+      return candidates_.back().get();
+    }
+  }
+
+  std::vector<const IceCandidateInterface*> GetAllCandidates() {
+    std::vector<const IceCandidateInterface*> candidates;
+    for (const auto& candidate : candidates_) {
+      candidates.push_back(candidate.get());
+    }
+    return candidates;
+  }
+
+  std::vector<IceCandidateInterface*> GetCandidatesByMline(int mline_index) {
+    std::vector<IceCandidateInterface*> candidates;
+    for (const auto& candidate : candidates_) {
+      if (candidate->sdp_mline_index() == mline_index) {
+        candidates.push_back(candidate.get());
+      }
+    }
+    return candidates;
+  }
+
+  bool legacy_renegotiation_needed() const { return renegotiation_needed_; }
+  void clear_legacy_renegotiation_needed() { renegotiation_needed_ = false; }
+
+  bool has_negotiation_needed_event() {
+    return latest_negotiation_needed_event_.has_value();
+  }
+  uint32_t latest_negotiation_needed_event() {
+    return latest_negotiation_needed_event_.value_or(0u);
+  }
+  void clear_latest_negotiation_needed_event() {
+    latest_negotiation_needed_event_ = absl::nullopt;
+  }
+
+  rtc::scoped_refptr<PeerConnectionInterface> pc_;
+  PeerConnectionInterface::SignalingState state_;
+  std::vector<std::unique_ptr<IceCandidateInterface>> candidates_;
+  rtc::scoped_refptr<DataChannelInterface> last_datachannel_;
+  rtc::scoped_refptr<StreamCollection> remote_streams_;
+  bool renegotiation_needed_ = false;
+  absl::optional<uint32_t> latest_negotiation_needed_event_;
+  bool ice_gathering_complete_ = false;
+  bool ice_connected_ = false;
+  bool callback_triggered_ = false;
+  int num_added_tracks_ = 0;
+  std::string last_added_track_label_;
+  std::vector<AddTrackEvent> add_track_events_;
+  std::vector<rtc::scoped_refptr<RtpReceiverInterface>> remove_track_events_;
+  std::vector<rtc::scoped_refptr<RtpTransceiverInterface>>
+      on_track_transceivers_;
+  int num_candidates_removed_ = 0;
+
+ private:
+  rtc::scoped_refptr<MediaStreamInterface> last_added_stream_;
+  rtc::scoped_refptr<MediaStreamInterface> last_removed_stream_;
+};
+
+class MockCreateSessionDescriptionObserver
+    : public webrtc::CreateSessionDescriptionObserver {
+ public:
+  MockCreateSessionDescriptionObserver()
+      : called_(false),
+        error_("MockCreateSessionDescriptionObserver not called") {}
+  virtual ~MockCreateSessionDescriptionObserver() {}
+  void OnSuccess(SessionDescriptionInterface* desc) override {
+    MutexLock lock(&mutex_);
+    called_ = true;
+    error_ = "";
+    desc_.reset(desc);
+  }
+  void OnFailure(webrtc::RTCError error) override {
+    MutexLock lock(&mutex_);
+    called_ = true;
+    error_ = error.message();
+  }
+  bool called() const {
+    MutexLock lock(&mutex_);
+    return called_;
+  }
+  bool result() const {
+    MutexLock lock(&mutex_);
+    return error_.empty();
+  }
+  const std::string& error() const {
+    MutexLock lock(&mutex_);
+    return error_;
+  }
+  std::unique_ptr<SessionDescriptionInterface> MoveDescription() {
+    MutexLock lock(&mutex_);
+    return std::move(desc_);
+  }
+
+ private:
+  mutable Mutex mutex_;
+  bool called_ RTC_GUARDED_BY(mutex_);
+  std::string error_ RTC_GUARDED_BY(mutex_);
+  std::unique_ptr<SessionDescriptionInterface> desc_ RTC_GUARDED_BY(mutex_);
+};
+
+class MockSetSessionDescriptionObserver
+    : public webrtc::SetSessionDescriptionObserver {
+ public:
+  static rtc::scoped_refptr<MockSetSessionDescriptionObserver> Create() {
+    return rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
+  }
+
+  MockSetSessionDescriptionObserver()
+      : called_(false),
+        error_("MockSetSessionDescriptionObserver not called") {}
+  ~MockSetSessionDescriptionObserver() override {}
+  void OnSuccess() override {
+    MutexLock lock(&mutex_);
+
+    called_ = true;
+    error_ = "";
+  }
+  void OnFailure(webrtc::RTCError error) override {
+    MutexLock lock(&mutex_);
+    called_ = true;
+    error_ = error.message();
+  }
+
+  bool called() const {
+    MutexLock lock(&mutex_);
+    return called_;
+  }
+  bool result() const {
+    MutexLock lock(&mutex_);
+    return error_.empty();
+  }
+  const std::string& error() const {
+    MutexLock lock(&mutex_);
+    return error_;
+  }
+
+ private:
+  mutable Mutex mutex_;
+  bool called_;
+  std::string error_;
+};
+
+class FakeSetLocalDescriptionObserver
+    : public SetLocalDescriptionObserverInterface {
+ public:
+  bool called() const { return error_.has_value(); }
+  RTCError& error() {
+    RTC_DCHECK(error_.has_value());
+    return *error_;
+  }
+
+  // SetLocalDescriptionObserverInterface implementation.
+  void OnSetLocalDescriptionComplete(RTCError error) override {
+    error_ = std::move(error);
+  }
+
+ private:
+  // Set on complete, on success this is set to an RTCError::OK() error.
+  absl::optional<RTCError> error_;
+};
+
+class FakeSetRemoteDescriptionObserver
+    : public SetRemoteDescriptionObserverInterface {
+ public:
+  bool called() const { return error_.has_value(); }
+  RTCError& error() {
+    RTC_DCHECK(error_.has_value());
+    return *error_;
+  }
+
+  // SetRemoteDescriptionObserverInterface implementation.
+  void OnSetRemoteDescriptionComplete(RTCError error) override {
+    error_ = std::move(error);
+  }
+
+ private:
+  // Set on complete, on success this is set to an RTCError::OK() error.
+  absl::optional<RTCError> error_;
+};
+
+class MockDataChannelObserver : public webrtc::DataChannelObserver {
+ public:
+  struct Message {
+    std::string data;
+    bool binary;
+  };
+
+  explicit MockDataChannelObserver(webrtc::DataChannelInterface* channel)
+      : channel_(channel) {
+    channel_->RegisterObserver(this);
+    states_.push_back(channel_->state());
+  }
+  virtual ~MockDataChannelObserver() { channel_->UnregisterObserver(); }
+
+  void OnBufferedAmountChange(uint64_t previous_amount) override {}
+
+  void OnStateChange() override { states_.push_back(channel_->state()); }
+  void OnMessage(const DataBuffer& buffer) override {
+    messages_.push_back(
+        {std::string(buffer.data.data<char>(), buffer.data.size()),
+         buffer.binary});
+  }
+
+  bool IsOpen() const { return state() == DataChannelInterface::kOpen; }
+  std::vector<Message> messages() const { return messages_; }
+  std::string last_message() const {
+    if (messages_.empty())
+      return {};
+
+    return messages_.back().data;
+  }
+  bool last_message_is_binary() const {
+    if (messages_.empty())
+      return false;
+    return messages_.back().binary;
+  }
+  size_t received_message_count() const { return messages_.size(); }
+
+  DataChannelInterface::DataState state() const { return states_.back(); }
+  const std::vector<DataChannelInterface::DataState>& states() const {
+    return states_;
+  }
+
+ private:
+  rtc::scoped_refptr<webrtc::DataChannelInterface> channel_;
+  std::vector<DataChannelInterface::DataState> states_;
+  std::vector<Message> messages_;
+};
+
+class MockStatsObserver : public webrtc::StatsObserver {
+ public:
+  MockStatsObserver() : called_(false), stats_() {}
+  virtual ~MockStatsObserver() {}
+
+  virtual void OnComplete(const StatsReports& reports) {
+    RTC_CHECK(!called_);
+    called_ = true;
+    stats_.Clear();
+    stats_.number_of_reports = reports.size();
+    for (const auto* r : reports) {
+      if (r->type() == StatsReport::kStatsReportTypeSsrc) {
+        stats_.timestamp = r->timestamp();
+        GetIntValue(r, StatsReport::kStatsValueNameAudioOutputLevel,
+                    &stats_.audio_output_level);
+        GetIntValue(r, StatsReport::kStatsValueNameAudioInputLevel,
+                    &stats_.audio_input_level);
+        GetIntValue(r, StatsReport::kStatsValueNameBytesReceived,
+                    &stats_.bytes_received);
+        GetIntValue(r, StatsReport::kStatsValueNameBytesSent,
+                    &stats_.bytes_sent);
+        GetInt64Value(r, StatsReport::kStatsValueNameCaptureStartNtpTimeMs,
+                      &stats_.capture_start_ntp_time);
+        stats_.track_ids.emplace_back();
+        GetStringValue(r, StatsReport::kStatsValueNameTrackId,
+                       &stats_.track_ids.back());
+      } else if (r->type() == StatsReport::kStatsReportTypeBwe) {
+        stats_.timestamp = r->timestamp();
+        GetIntValue(r, StatsReport::kStatsValueNameAvailableReceiveBandwidth,
+                    &stats_.available_receive_bandwidth);
+      } else if (r->type() == StatsReport::kStatsReportTypeComponent) {
+        stats_.timestamp = r->timestamp();
+        GetStringValue(r, StatsReport::kStatsValueNameDtlsCipher,
+                       &stats_.dtls_cipher);
+        GetStringValue(r, StatsReport::kStatsValueNameSrtpCipher,
+                       &stats_.srtp_cipher);
+      }
+    }
+  }
+
+  bool called() const { return called_; }
+  size_t number_of_reports() const { return stats_.number_of_reports; }
+  double timestamp() const { return stats_.timestamp; }
+
+  int AudioOutputLevel() const {
+    RTC_CHECK(called_);
+    return stats_.audio_output_level;
+  }
+
+  int AudioInputLevel() const {
+    RTC_CHECK(called_);
+    return stats_.audio_input_level;
+  }
+
+  int BytesReceived() const {
+    RTC_CHECK(called_);
+    return stats_.bytes_received;
+  }
+
+  int BytesSent() const {
+    RTC_CHECK(called_);
+    return stats_.bytes_sent;
+  }
+
+  int64_t CaptureStartNtpTime() const {
+    RTC_CHECK(called_);
+    return stats_.capture_start_ntp_time;
+  }
+
+  int AvailableReceiveBandwidth() const {
+    RTC_CHECK(called_);
+    return stats_.available_receive_bandwidth;
+  }
+
+  std::string DtlsCipher() const {
+    RTC_CHECK(called_);
+    return stats_.dtls_cipher;
+  }
+
+  std::string SrtpCipher() const {
+    RTC_CHECK(called_);
+    return stats_.srtp_cipher;
+  }
+
+  std::vector<std::string> TrackIds() const {
+    RTC_CHECK(called_);
+    return stats_.track_ids;
+  }
+
+ private:
+  bool GetIntValue(const StatsReport* report,
+                   StatsReport::StatsValueName name,
+                   int* value) {
+    const StatsReport::Value* v = report->FindValue(name);
+    if (v) {
+      // TODO(tommi): We should really just be using an int here :-/
+      *value = rtc::FromString<int>(v->ToString());
+    }
+    return v != nullptr;
+  }
+
+  bool GetInt64Value(const StatsReport* report,
+                     StatsReport::StatsValueName name,
+                     int64_t* value) {
+    const StatsReport::Value* v = report->FindValue(name);
+    if (v) {
+      // TODO(tommi): We should really just be using an int here :-/
+      *value = rtc::FromString<int64_t>(v->ToString());
+    }
+    return v != nullptr;
+  }
+
+  bool GetStringValue(const StatsReport* report,
+                      StatsReport::StatsValueName name,
+                      std::string* value) {
+    const StatsReport::Value* v = report->FindValue(name);
+    if (v)
+      *value = v->ToString();
+    return v != nullptr;
+  }
+
+  bool called_;
+  struct {
+    void Clear() {
+      number_of_reports = 0;
+      timestamp = 0;
+      audio_output_level = 0;
+      audio_input_level = 0;
+      bytes_received = 0;
+      bytes_sent = 0;
+      capture_start_ntp_time = 0;
+      available_receive_bandwidth = 0;
+      dtls_cipher.clear();
+      srtp_cipher.clear();
+      track_ids.clear();
+    }
+
+    size_t number_of_reports;
+    double timestamp;
+    int audio_output_level;
+    int audio_input_level;
+    int bytes_received;
+    int bytes_sent;
+    int64_t capture_start_ntp_time;
+    int available_receive_bandwidth;
+    std::string dtls_cipher;
+    std::string srtp_cipher;
+    std::vector<std::string> track_ids;
+  } stats_;
+};
+
+// Helper class that just stores the report from the callback.
+class MockRTCStatsCollectorCallback : public webrtc::RTCStatsCollectorCallback {
+ public:
+  rtc::scoped_refptr<const RTCStatsReport> report() { return report_; }
+
+  bool called() const { return called_; }
+
+ protected:
+  void OnStatsDelivered(
+      const rtc::scoped_refptr<const RTCStatsReport>& report) override {
+    report_ = report;
+    called_ = true;
+  }
+
+ private:
+  bool called_ = false;
+  rtc::scoped_refptr<const RTCStatsReport> report_;
+};
+
+}  // namespace webrtc
+
+#endif  // PC_TEST_MOCK_PEER_CONNECTION_OBSERVERS_H_
diff --git a/third_party/libwebrtc/pc/test/mock_rtp_receiver_internal.h b/third_party/libwebrtc/pc/test/mock_rtp_receiver_internal.h
new file mode 100644
index 0000000000..e76b56755d
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/mock_rtp_receiver_internal.h
@@ -0,0 +1,82 @@
+/*
+ *  Copyright 2016 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.
+ */
+
+#ifndef PC_TEST_MOCK_RTP_RECEIVER_INTERNAL_H_
+#define PC_TEST_MOCK_RTP_RECEIVER_INTERNAL_H_
+
+#include <string>
+#include <vector>
+
+#include "absl/types/optional.h"
+#include "pc/rtp_receiver.h"
+#include "test/gmock.h"
+
+namespace webrtc {
+
+// The definition of MockRtpReceiver is copied in to avoid multiple inheritance.
+class MockRtpReceiverInternal : public RtpReceiverInternal {
+ public:
+  // RtpReceiverInterface methods.
+  MOCK_METHOD(rtc::scoped_refptr<MediaStreamTrackInterface>,
+              track,
+              (),
+              (const, override));
+  MOCK_METHOD(rtc::scoped_refptr<DtlsTransportInterface>,
+              dtls_transport,
+              (),
+              (const, override));
+  MOCK_METHOD(std::vector<std::string>, stream_ids, (), (const, override));
+  MOCK_METHOD(std::vector<rtc::scoped_refptr<MediaStreamInterface>>,
+              streams,
+              (),
+              (const, override));
+  MOCK_METHOD(cricket::MediaType, media_type, (), (const, override));
+  MOCK_METHOD(std::string, id, (), (const, override));
+  MOCK_METHOD(RtpParameters, GetParameters, (), (const, override));
+  MOCK_METHOD(void, SetObserver, (RtpReceiverObserverInterface*), (override));
+  MOCK_METHOD(void,
+              SetJitterBufferMinimumDelay,
+              (absl::optional<double>),
+              (override));
+  MOCK_METHOD(std::vector<RtpSource>, GetSources, (), (const, override));
+  MOCK_METHOD(void,
+              SetFrameDecryptor,
+              (rtc::scoped_refptr<FrameDecryptorInterface>),
+              (override));
+  MOCK_METHOD(rtc::scoped_refptr<FrameDecryptorInterface>,
+              GetFrameDecryptor,
+              (),
+              (const, override));
+
+  // RtpReceiverInternal methods.
+  MOCK_METHOD(void, Stop, (), (override));
+  MOCK_METHOD(void,
+              SetMediaChannel,
+              (cricket::MediaReceiveChannelInterface*),
+              (override));
+  MOCK_METHOD(void, SetupMediaChannel, (uint32_t), (override));
+  MOCK_METHOD(void, SetupUnsignaledMediaChannel, (), (override));
+  MOCK_METHOD(absl::optional<uint32_t>, ssrc, (), (const, override));
+  MOCK_METHOD(void, NotifyFirstPacketReceived, (), (override));
+  MOCK_METHOD(void, set_stream_ids, (std::vector<std::string>), (override));
+  MOCK_METHOD(void,
+              set_transport,
+              (rtc::scoped_refptr<DtlsTransportInterface>),
+              (override));
+  MOCK_METHOD(void,
+              SetStreams,
+              (const std::vector<rtc::scoped_refptr<MediaStreamInterface>>&),
+              (override));
+  MOCK_METHOD(int, AttachmentId, (), (const, override));
+};
+
+}  // namespace webrtc
+
+#endif  // PC_TEST_MOCK_RTP_RECEIVER_INTERNAL_H_
diff --git a/third_party/libwebrtc/pc/test/mock_rtp_sender_internal.h b/third_party/libwebrtc/pc/test/mock_rtp_sender_internal.h
new file mode 100644
index 0000000000..8ed0ede21b
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/mock_rtp_sender_internal.h
@@ -0,0 +1,109 @@
+/*
+ *  Copyright 2016 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.
+ */
+
+#ifndef PC_TEST_MOCK_RTP_SENDER_INTERNAL_H_
+#define PC_TEST_MOCK_RTP_SENDER_INTERNAL_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "pc/rtp_sender.h"
+#include "test/gmock.h"
+
+namespace webrtc {
+
+// The definition of MockRtpSender is copied in to avoid multiple inheritance.
+class MockRtpSenderInternal : public RtpSenderInternal {
+ public:
+  // RtpSenderInterface methods.
+  MOCK_METHOD(bool, SetTrack, (MediaStreamTrackInterface*), (override));
+  MOCK_METHOD(rtc::scoped_refptr<MediaStreamTrackInterface>,
+              track,
+              (),
+              (const, override));
+  MOCK_METHOD(uint32_t, ssrc, (), (const, override));
+  MOCK_METHOD(rtc::scoped_refptr<DtlsTransportInterface>,
+              dtls_transport,
+              (),
+              (const, override));
+  MOCK_METHOD(cricket::MediaType, media_type, (), (const, override));
+  MOCK_METHOD(std::string, id, (), (const, override));
+  MOCK_METHOD(std::vector<std::string>, stream_ids, (), (const, override));
+  MOCK_METHOD(std::vector<RtpEncodingParameters>,
+              init_send_encodings,
+              (),
+              (const, override));
+  MOCK_METHOD(void,
+              set_transport,
+              (rtc::scoped_refptr<DtlsTransportInterface>),
+              (override));
+  MOCK_METHOD(RtpParameters, GetParameters, (), (const, override));
+  MOCK_METHOD(RtpParameters, GetParametersInternal, (), (const, override));
+  MOCK_METHOD(RtpParameters,
+              GetParametersInternalWithAllLayers,
+              (),
+              (const, override));
+  MOCK_METHOD(RTCError, SetParameters, (const RtpParameters&), (override));
+  MOCK_METHOD(void,
+              SetParametersAsync,
+              (const RtpParameters&, SetParametersCallback),
+              (override));
+  MOCK_METHOD(void,
+              SetParametersInternal,
+              (const RtpParameters&, SetParametersCallback, bool blocking),
+              (override));
+  MOCK_METHOD(RTCError,
+              SetParametersInternalWithAllLayers,
+              (const RtpParameters&),
+              (override));
+  MOCK_METHOD(RTCError, CheckSVCParameters, (const RtpParameters&), (override));
+  MOCK_METHOD(void,
+              SetVideoCodecPreferences,
+              (std::vector<cricket::VideoCodec>),
+              (override));
+  MOCK_METHOD(rtc::scoped_refptr<DtmfSenderInterface>,
+              GetDtmfSender,
+              (),
+              (const, override));
+  MOCK_METHOD(void,
+              SetFrameEncryptor,
+              (rtc::scoped_refptr<FrameEncryptorInterface>),
+              (override));
+  MOCK_METHOD(rtc::scoped_refptr<FrameEncryptorInterface>,
+              GetFrameEncryptor,
+              (),
+              (const, override));
+  MOCK_METHOD(void,
+              SetEncoderToPacketizerFrameTransformer,
+              (rtc::scoped_refptr<FrameTransformerInterface>),
+              (override));
+  MOCK_METHOD(void,
+              SetEncoderSelector,
+              (std::unique_ptr<VideoEncoderFactory::EncoderSelectorInterface>),
+              (override));
+
+  // RtpSenderInternal methods.
+  MOCK_METHOD1(SetMediaChannel, void(cricket::MediaSendChannelInterface*));
+  MOCK_METHOD1(SetSsrc, void(uint32_t));
+  MOCK_METHOD1(set_stream_ids, void(const std::vector<std::string>&));
+  MOCK_METHOD1(SetStreams, void(const std::vector<std::string>&));
+  MOCK_METHOD1(set_init_send_encodings,
+               void(const std::vector<RtpEncodingParameters>&));
+  MOCK_METHOD0(Stop, void());
+  MOCK_CONST_METHOD0(AttachmentId, int());
+  MOCK_METHOD1(DisableEncodingLayers,
+               RTCError(const std::vector<std::string>&));
+  MOCK_METHOD0(SetTransceiverAsStopped, void());
+};
+
+}  // namespace webrtc
+
+#endif  // PC_TEST_MOCK_RTP_SENDER_INTERNAL_H_
diff --git a/third_party/libwebrtc/pc/test/mock_voice_media_channel.h b/third_party/libwebrtc/pc/test/mock_voice_media_channel.h
new file mode 100644
index 0000000000..2e5a8b5801
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/mock_voice_media_channel.h
@@ -0,0 +1,163 @@
+/*
+ *  Copyright 2021 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.
+ */
+#ifndef PC_TEST_MOCK_VOICE_MEDIA_CHANNEL_H_
+#define PC_TEST_MOCK_VOICE_MEDIA_CHANNEL_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "api/call/audio_sink.h"
+#include "media/base/media_channel.h"
+#include "media/base/media_channel_impl.h"
+#include "modules/rtp_rtcp/source/rtp_packet_received.h"
+#include "rtc_base/gunit.h"
+#include "test/gmock.h"
+#include "test/gtest.h"
+
+using ::testing::InvokeWithoutArgs;
+using ::testing::Mock;
+
+namespace cricket {
+class MockVoiceMediaChannel : public VoiceMediaChannel {
+ public:
+  explicit MockVoiceMediaChannel(webrtc::TaskQueueBase* network_thread)
+      : VoiceMediaChannel(network_thread) {}
+
+  MOCK_METHOD(void,
+              SetInterface,
+              (MediaChannelNetworkInterface * iface),
+              (override));
+  MOCK_METHOD(void,
+              OnPacketReceived,
+              (const webrtc::RtpPacketReceived& packet),
+              (override));
+  MOCK_METHOD(void,
+              OnPacketSent,
+              (const rtc::SentPacket& sent_packet),
+              (override));
+  MOCK_METHOD(void, OnReadyToSend, (bool ready), (override));
+  MOCK_METHOD(void,
+              OnNetworkRouteChanged,
+              (absl::string_view transport_name,
+               const rtc::NetworkRoute& network_route),
+              (override));
+  MOCK_METHOD(bool, AddSendStream, (const StreamParams& sp), (override));
+  MOCK_METHOD(bool, RemoveSendStream, (uint32_t ssrc), (override));
+  MOCK_METHOD(bool, AddRecvStream, (const StreamParams& sp), (override));
+  MOCK_METHOD(bool, RemoveRecvStream, (uint32_t ssrc), (override));
+  MOCK_METHOD(void, ResetUnsignaledRecvStream, (), (override));
+  MOCK_METHOD(absl::optional<uint32_t>,
+              GetUnsignaledSsrc,
+              (),
+              (const, override));
+  MOCK_METHOD(void, OnDemuxerCriteriaUpdatePending, (), (override));
+  MOCK_METHOD(void, OnDemuxerCriteriaUpdateComplete, (), (override));
+  MOCK_METHOD(int, GetRtpSendTimeExtnId, (), (const, override));
+  MOCK_METHOD(
+      void,
+      SetFrameEncryptor,
+      (uint32_t ssrc,
+       rtc::scoped_refptr<webrtc::FrameEncryptorInterface> frame_encryptor),
+      (override));
+  MOCK_METHOD(
+      void,
+      SetFrameDecryptor,
+      (uint32_t ssrc,
+       rtc::scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor),
+      (override));
+  MOCK_METHOD(webrtc::RtpParameters,
+              GetRtpSendParameters,
+              (uint32_t ssrc),
+              (const, override));
+  MOCK_METHOD(webrtc::RTCError,
+              SetRtpSendParameters,
+              (uint32_t ssrc,
+               const webrtc::RtpParameters& parameters,
+               webrtc::SetParametersCallback callback),
+              (override));
+  MOCK_METHOD(
+      void,
+      SetEncoderToPacketizerFrameTransformer,
+      (uint32_t ssrc,
+       rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer),
+      (override));
+  MOCK_METHOD(
+      void,
+      SetDepacketizerToDecoderFrameTransformer,
+      (uint32_t ssrc,
+       rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer),
+      (override));
+
+  MOCK_METHOD(bool,
+              SetSendParameters,
+              (const AudioSendParameters& params),
+              (override));
+  MOCK_METHOD(bool,
+              SetRecvParameters,
+              (const AudioRecvParameters& params),
+              (override));
+  MOCK_METHOD(webrtc::RtpParameters,
+              GetRtpReceiveParameters,
+              (uint32_t ssrc),
+              (const, override));
+  MOCK_METHOD(webrtc::RtpParameters,
+              GetDefaultRtpReceiveParameters,
+              (),
+              (const, override));
+  MOCK_METHOD(void, SetPlayout, (bool playout), (override));
+  MOCK_METHOD(void, SetSend, (bool send), (override));
+  MOCK_METHOD(bool,
+              SetAudioSend,
+              (uint32_t ssrc,
+               bool enable,
+               const AudioOptions* options,
+               AudioSource* source),
+              (override));
+  MOCK_METHOD(bool,
+              SetOutputVolume,
+              (uint32_t ssrc, double volume),
+              (override));
+  MOCK_METHOD(bool, SetDefaultOutputVolume, (double volume), (override));
+  MOCK_METHOD(bool, CanInsertDtmf, (), (override));
+  MOCK_METHOD(bool,
+              InsertDtmf,
+              (uint32_t ssrc, int event, int duration),
+              (override));
+  MOCK_METHOD(bool, GetSendStats, (VoiceMediaSendInfo * info), (override));
+  MOCK_METHOD(bool,
+              GetReceiveStats,
+              (VoiceMediaReceiveInfo * info, bool get_and_clear_legacy_stats),
+              (override));
+  MOCK_METHOD(void,
+              SetRawAudioSink,
+              (uint32_t ssrc, std::unique_ptr<webrtc::AudioSinkInterface> sink),
+              (override));
+  MOCK_METHOD(void,
+              SetDefaultRawAudioSink,
+              (std::unique_ptr<webrtc::AudioSinkInterface> sink),
+              (override));
+  MOCK_METHOD(std::vector<webrtc::RtpSource>,
+              GetSources,
+              (uint32_t ssrc),
+              (const, override));
+
+  MOCK_METHOD(bool,
+              SetBaseMinimumPlayoutDelayMs,
+              (uint32_t ssrc, int delay_ms),
+              (override));
+  MOCK_METHOD(absl::optional<int>,
+              GetBaseMinimumPlayoutDelayMs,
+              (uint32_t ssrc),
+              (const, override));
+};
+}  // namespace cricket
+
+#endif  // PC_TEST_MOCK_VOICE_MEDIA_CHANNEL_H_
diff --git a/third_party/libwebrtc/pc/test/peer_connection_test_wrapper.cc b/third_party/libwebrtc/pc/test/peer_connection_test_wrapper.cc
new file mode 100644
index 0000000000..8325e59510
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/peer_connection_test_wrapper.cc
@@ -0,0 +1,356 @@
+/*
+ *  Copyright 2013 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 "pc/test/peer_connection_test_wrapper.h"
+
+#include <stddef.h>
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/types/optional.h"
+#include "api/audio/audio_mixer.h"
+#include "api/create_peerconnection_factory.h"
+#include "api/sequence_checker.h"
+#include "api/video_codecs/builtin_video_decoder_factory.h"
+#include "api/video_codecs/builtin_video_encoder_factory.h"
+#include "api/video_codecs/video_decoder_factory.h"
+#include "api/video_codecs/video_encoder_factory.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/port_allocator.h"
+#include "pc/test/fake_periodic_video_source.h"
+#include "pc/test/fake_periodic_video_track_source.h"
+#include "pc/test/fake_rtc_certificate_generator.h"
+#include "pc/test/mock_peer_connection_observers.h"
+#include "rtc_base/gunit.h"
+#include "rtc_base/logging.h"
+#include "rtc_base/rtc_certificate_generator.h"
+#include "rtc_base/string_encode.h"
+#include "rtc_base/time_utils.h"
+#include "test/gtest.h"
+
+using webrtc::FakeVideoTrackRenderer;
+using webrtc::IceCandidateInterface;
+using webrtc::MediaStreamInterface;
+using webrtc::MediaStreamTrackInterface;
+using webrtc::MockSetSessionDescriptionObserver;
+using webrtc::PeerConnectionInterface;
+using webrtc::RtpReceiverInterface;
+using webrtc::SdpType;
+using webrtc::SessionDescriptionInterface;
+using webrtc::VideoTrackInterface;
+
+namespace {
+const char kStreamIdBase[] = "stream_id";
+const char kVideoTrackLabelBase[] = "video_track";
+const char kAudioTrackLabelBase[] = "audio_track";
+constexpr int kMaxWait = 10000;
+constexpr int kTestAudioFrameCount = 3;
+constexpr int kTestVideoFrameCount = 3;
+}  // namespace
+
+void PeerConnectionTestWrapper::Connect(PeerConnectionTestWrapper* caller,
+                                        PeerConnectionTestWrapper* callee) {
+  caller->SignalOnIceCandidateReady.connect(
+      callee, &PeerConnectionTestWrapper::AddIceCandidate);
+  callee->SignalOnIceCandidateReady.connect(
+      caller, &PeerConnectionTestWrapper::AddIceCandidate);
+
+  caller->SignalOnSdpReady.connect(callee,
+                                   &PeerConnectionTestWrapper::ReceiveOfferSdp);
+  callee->SignalOnSdpReady.connect(
+      caller, &PeerConnectionTestWrapper::ReceiveAnswerSdp);
+}
+
+PeerConnectionTestWrapper::PeerConnectionTestWrapper(
+    const std::string& name,
+    rtc::SocketServer* socket_server,
+    rtc::Thread* network_thread,
+    rtc::Thread* worker_thread)
+    : name_(name),
+      socket_server_(socket_server),
+      network_thread_(network_thread),
+      worker_thread_(worker_thread),
+      pending_negotiation_(false) {
+  pc_thread_checker_.Detach();
+}
+
+PeerConnectionTestWrapper::~PeerConnectionTestWrapper() {
+  RTC_DCHECK_RUN_ON(&pc_thread_checker_);
+  // Either network_thread or worker_thread might be active at this point.
+  // Relying on ~PeerConnection to properly wait for them doesn't work,
+  // as a vptr race might occur (before we enter the destruction body).
+  // See: bugs.webrtc.org/9847
+  if (pc()) {
+    pc()->Close();
+  }
+}
+
+bool PeerConnectionTestWrapper::CreatePc(
+    const webrtc::PeerConnectionInterface::RTCConfiguration& config,
+    rtc::scoped_refptr<webrtc::AudioEncoderFactory> audio_encoder_factory,
+    rtc::scoped_refptr<webrtc::AudioDecoderFactory> audio_decoder_factory) {
+  std::unique_ptr<cricket::PortAllocator> port_allocator(
+      new cricket::FakePortAllocator(
+          network_thread_,
+          std::make_unique<rtc::BasicPacketSocketFactory>(socket_server_),
+          &field_trials_));
+
+  RTC_DCHECK_RUN_ON(&pc_thread_checker_);
+
+  fake_audio_capture_module_ = FakeAudioCaptureModule::Create();
+  if (fake_audio_capture_module_ == nullptr) {
+    return false;
+  }
+
+  peer_connection_factory_ = webrtc::CreatePeerConnectionFactory(
+      network_thread_, worker_thread_, rtc::Thread::Current(),
+      rtc::scoped_refptr<webrtc::AudioDeviceModule>(fake_audio_capture_module_),
+      audio_encoder_factory, audio_decoder_factory,
+      webrtc::CreateBuiltinVideoEncoderFactory(),
+      webrtc::CreateBuiltinVideoDecoderFactory(), nullptr /* audio_mixer */,
+      nullptr /* audio_processing */);
+  if (!peer_connection_factory_) {
+    return false;
+  }
+
+  std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator(
+      new FakeRTCCertificateGenerator());
+  webrtc::PeerConnectionDependencies deps(this);
+  deps.allocator = std::move(port_allocator);
+  deps.cert_generator = std::move(cert_generator);
+  auto result = peer_connection_factory_->CreatePeerConnectionOrError(
+      config, std::move(deps));
+  if (result.ok()) {
+    peer_connection_ = result.MoveValue();
+    return true;
+  } else {
+    return false;
+  }
+}
+
+rtc::scoped_refptr<webrtc::DataChannelInterface>
+PeerConnectionTestWrapper::CreateDataChannel(
+    const std::string& label,
+    const webrtc::DataChannelInit& init) {
+  auto result = peer_connection_->CreateDataChannelOrError(label, &init);
+  if (!result.ok()) {
+    RTC_LOG(LS_ERROR) << "CreateDataChannel failed: "
+                      << ToString(result.error().type()) << " "
+                      << result.error().message();
+    return nullptr;
+  }
+  return result.MoveValue();
+}
+
+void PeerConnectionTestWrapper::WaitForNegotiation() {
+  EXPECT_TRUE_WAIT(!pending_negotiation_, kMaxWait);
+}
+
+void PeerConnectionTestWrapper::OnSignalingChange(
+    webrtc::PeerConnectionInterface::SignalingState new_state) {
+  if (new_state == webrtc::PeerConnectionInterface::SignalingState::kStable) {
+    pending_negotiation_ = false;
+  }
+}
+
+void PeerConnectionTestWrapper::OnAddTrack(
+    rtc::scoped_refptr<RtpReceiverInterface> receiver,
+    const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams) {
+  RTC_LOG(LS_INFO) << "PeerConnectionTestWrapper " << name_ << ": OnAddTrack";
+  if (receiver->track()->kind() == MediaStreamTrackInterface::kVideoKind) {
+    auto* video_track =
+        static_cast<VideoTrackInterface*>(receiver->track().get());
+    renderer_ = std::make_unique<FakeVideoTrackRenderer>(video_track);
+  }
+}
+
+void PeerConnectionTestWrapper::OnIceCandidate(
+    const IceCandidateInterface* candidate) {
+  std::string sdp;
+  EXPECT_TRUE(candidate->ToString(&sdp));
+  SignalOnIceCandidateReady(candidate->sdp_mid(), candidate->sdp_mline_index(),
+                            sdp);
+}
+
+void PeerConnectionTestWrapper::OnDataChannel(
+    rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) {
+  SignalOnDataChannel(data_channel.get());
+}
+
+void PeerConnectionTestWrapper::OnSuccess(SessionDescriptionInterface* desc) {
+  // This callback should take the ownership of `desc`.
+  std::unique_ptr<SessionDescriptionInterface> owned_desc(desc);
+  std::string sdp;
+  EXPECT_TRUE(desc->ToString(&sdp));
+
+  RTC_LOG(LS_INFO) << "PeerConnectionTestWrapper " << name_ << ": "
+                   << webrtc::SdpTypeToString(desc->GetType())
+                   << " sdp created: " << sdp;
+
+  SetLocalDescription(desc->GetType(), sdp);
+
+  SignalOnSdpReady(sdp);
+}
+
+void PeerConnectionTestWrapper::CreateOffer(
+    const webrtc::PeerConnectionInterface::RTCOfferAnswerOptions& options) {
+  RTC_LOG(LS_INFO) << "PeerConnectionTestWrapper " << name_ << ": CreateOffer.";
+  pending_negotiation_ = true;
+  peer_connection_->CreateOffer(this, options);
+}
+
+void PeerConnectionTestWrapper::CreateAnswer(
+    const webrtc::PeerConnectionInterface::RTCOfferAnswerOptions& options) {
+  RTC_LOG(LS_INFO) << "PeerConnectionTestWrapper " << name_
+                   << ": CreateAnswer.";
+  pending_negotiation_ = true;
+  peer_connection_->CreateAnswer(this, options);
+}
+
+void PeerConnectionTestWrapper::ReceiveOfferSdp(const std::string& sdp) {
+  SetRemoteDescription(SdpType::kOffer, sdp);
+  CreateAnswer(webrtc::PeerConnectionInterface::RTCOfferAnswerOptions());
+}
+
+void PeerConnectionTestWrapper::ReceiveAnswerSdp(const std::string& sdp) {
+  SetRemoteDescription(SdpType::kAnswer, sdp);
+}
+
+void PeerConnectionTestWrapper::SetLocalDescription(SdpType type,
+                                                    const std::string& sdp) {
+  RTC_LOG(LS_INFO) << "PeerConnectionTestWrapper " << name_
+                   << ": SetLocalDescription " << webrtc::SdpTypeToString(type)
+                   << " " << sdp;
+
+  auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
+  peer_connection_->SetLocalDescription(
+      observer.get(), webrtc::CreateSessionDescription(type, sdp).release());
+}
+
+void PeerConnectionTestWrapper::SetRemoteDescription(SdpType type,
+                                                     const std::string& sdp) {
+  RTC_LOG(LS_INFO) << "PeerConnectionTestWrapper " << name_
+                   << ": SetRemoteDescription " << webrtc::SdpTypeToString(type)
+                   << " " << sdp;
+
+  auto observer = rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
+  peer_connection_->SetRemoteDescription(
+      observer.get(), webrtc::CreateSessionDescription(type, sdp).release());
+}
+
+void PeerConnectionTestWrapper::AddIceCandidate(const std::string& sdp_mid,
+                                                int sdp_mline_index,
+                                                const std::string& candidate) {
+  std::unique_ptr<webrtc::IceCandidateInterface> owned_candidate(
+      webrtc::CreateIceCandidate(sdp_mid, sdp_mline_index, candidate, NULL));
+  EXPECT_TRUE(peer_connection_->AddIceCandidate(owned_candidate.get()));
+}
+
+void PeerConnectionTestWrapper::WaitForCallEstablished() {
+  WaitForConnection();
+  WaitForAudio();
+  WaitForVideo();
+}
+
+void PeerConnectionTestWrapper::WaitForConnection() {
+  EXPECT_TRUE_WAIT(CheckForConnection(), kMaxWait);
+  RTC_LOG(LS_INFO) << "PeerConnectionTestWrapper " << name_ << ": Connected.";
+}
+
+bool PeerConnectionTestWrapper::CheckForConnection() {
+  return (peer_connection_->ice_connection_state() ==
+          PeerConnectionInterface::kIceConnectionConnected) ||
+         (peer_connection_->ice_connection_state() ==
+          PeerConnectionInterface::kIceConnectionCompleted);
+}
+
+void PeerConnectionTestWrapper::WaitForAudio() {
+  EXPECT_TRUE_WAIT(CheckForAudio(), kMaxWait);
+  RTC_LOG(LS_INFO) << "PeerConnectionTestWrapper " << name_
+                   << ": Got enough audio frames.";
+}
+
+bool PeerConnectionTestWrapper::CheckForAudio() {
+  return (fake_audio_capture_module_->frames_received() >=
+          kTestAudioFrameCount);
+}
+
+void PeerConnectionTestWrapper::WaitForVideo() {
+  EXPECT_TRUE_WAIT(CheckForVideo(), kMaxWait);
+  RTC_LOG(LS_INFO) << "PeerConnectionTestWrapper " << name_
+                   << ": Got enough video frames.";
+}
+
+bool PeerConnectionTestWrapper::CheckForVideo() {
+  if (!renderer_) {
+    return false;
+  }
+  return (renderer_->num_rendered_frames() >= kTestVideoFrameCount);
+}
+
+void PeerConnectionTestWrapper::GetAndAddUserMedia(
+    bool audio,
+    const cricket::AudioOptions& audio_options,
+    bool video) {
+  rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
+      GetUserMedia(audio, audio_options, video);
+  for (const auto& audio_track : stream->GetAudioTracks()) {
+    EXPECT_TRUE(peer_connection_->AddTrack(audio_track, {stream->id()}).ok());
+  }
+  for (const auto& video_track : stream->GetVideoTracks()) {
+    EXPECT_TRUE(peer_connection_->AddTrack(video_track, {stream->id()}).ok());
+  }
+}
+
+rtc::scoped_refptr<webrtc::MediaStreamInterface>
+PeerConnectionTestWrapper::GetUserMedia(
+    bool audio,
+    const cricket::AudioOptions& audio_options,
+    bool video) {
+  std::string stream_id =
+      kStreamIdBase + rtc::ToString(num_get_user_media_calls_++);
+  rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
+      peer_connection_factory_->CreateLocalMediaStream(stream_id);
+
+  if (audio) {
+    cricket::AudioOptions options = audio_options;
+    // Disable highpass filter so that we can get all the test audio frames.
+    options.highpass_filter = false;
+    rtc::scoped_refptr<webrtc::AudioSourceInterface> source =
+        peer_connection_factory_->CreateAudioSource(options);
+    rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
+        peer_connection_factory_->CreateAudioTrack(kAudioTrackLabelBase,
+                                                   source.get()));
+    stream->AddTrack(audio_track);
+  }
+
+  if (video) {
+    // Set max frame rate to 10fps to reduce the risk of the tests to be flaky.
+    webrtc::FakePeriodicVideoSource::Config config;
+    config.frame_interval_ms = 100;
+    config.timestamp_offset_ms = rtc::TimeMillis();
+
+    auto source = rtc::make_ref_counted<webrtc::FakePeriodicVideoTrackSource>(
+        config, /* remote */ false);
+
+    std::string videotrack_label = stream_id + kVideoTrackLabelBase;
+    rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
+        peer_connection_factory_->CreateVideoTrack(videotrack_label,
+                                                   source.get()));
+
+    stream->AddTrack(video_track);
+  }
+  return stream;
+}
diff --git a/third_party/libwebrtc/pc/test/peer_connection_test_wrapper.h b/third_party/libwebrtc/pc/test/peer_connection_test_wrapper.h
new file mode 100644
index 0000000000..cda3ecb73b
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/peer_connection_test_wrapper.h
@@ -0,0 +1,135 @@
+/*
+ *  Copyright 2013 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.
+ */
+
+#ifndef PC_TEST_PEER_CONNECTION_TEST_WRAPPER_H_
+#define PC_TEST_PEER_CONNECTION_TEST_WRAPPER_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "api/audio_codecs/audio_decoder_factory.h"
+#include "api/audio_codecs/audio_encoder_factory.h"
+#include "api/audio_options.h"
+#include "api/data_channel_interface.h"
+#include "api/jsep.h"
+#include "api/media_stream_interface.h"
+#include "api/peer_connection_interface.h"
+#include "api/rtc_error.h"
+#include "api/rtp_receiver_interface.h"
+#include "api/scoped_refptr.h"
+#include "api/sequence_checker.h"
+#include "pc/test/fake_audio_capture_module.h"
+#include "pc/test/fake_video_track_renderer.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
+#include "rtc_base/thread.h"
+#include "test/scoped_key_value_config.h"
+
+class PeerConnectionTestWrapper
+    : public webrtc::PeerConnectionObserver,
+      public webrtc::CreateSessionDescriptionObserver,
+      public sigslot::has_slots<> {
+ public:
+  static void Connect(PeerConnectionTestWrapper* caller,
+                      PeerConnectionTestWrapper* callee);
+
+  PeerConnectionTestWrapper(const std::string& name,
+                            rtc::SocketServer* socket_server,
+                            rtc::Thread* network_thread,
+                            rtc::Thread* worker_thread);
+  virtual ~PeerConnectionTestWrapper();
+
+  bool CreatePc(
+      const webrtc::PeerConnectionInterface::RTCConfiguration& config,
+      rtc::scoped_refptr<webrtc::AudioEncoderFactory> audio_encoder_factory,
+      rtc::scoped_refptr<webrtc::AudioDecoderFactory> audio_decoder_factory);
+
+  rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pc_factory()
+      const {
+    return peer_connection_factory_;
+  }
+  webrtc::PeerConnectionInterface* pc() { return peer_connection_.get(); }
+
+  rtc::scoped_refptr<webrtc::DataChannelInterface> CreateDataChannel(
+      const std::string& label,
+      const webrtc::DataChannelInit& init);
+
+  void WaitForNegotiation();
+
+  // Implements PeerConnectionObserver.
+  void OnSignalingChange(
+      webrtc::PeerConnectionInterface::SignalingState new_state) override;
+  void OnAddTrack(
+      rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver,
+      const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>>&
+          streams) override;
+  void OnDataChannel(
+      rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) override;
+  void OnRenegotiationNeeded() override {}
+  void OnIceConnectionChange(
+      webrtc::PeerConnectionInterface::IceConnectionState new_state) override {}
+  void OnIceGatheringChange(
+      webrtc::PeerConnectionInterface::IceGatheringState new_state) override {}
+  void OnIceCandidate(const webrtc::IceCandidateInterface* candidate) override;
+
+  // Implements CreateSessionDescriptionObserver.
+  void OnSuccess(webrtc::SessionDescriptionInterface* desc) override;
+  void OnFailure(webrtc::RTCError) override {}
+
+  void CreateOffer(
+      const webrtc::PeerConnectionInterface::RTCOfferAnswerOptions& options);
+  void CreateAnswer(
+      const webrtc::PeerConnectionInterface::RTCOfferAnswerOptions& options);
+  void ReceiveOfferSdp(const std::string& sdp);
+  void ReceiveAnswerSdp(const std::string& sdp);
+  void AddIceCandidate(const std::string& sdp_mid,
+                       int sdp_mline_index,
+                       const std::string& candidate);
+  void WaitForCallEstablished();
+  void WaitForConnection();
+  void WaitForAudio();
+  void WaitForVideo();
+  void GetAndAddUserMedia(bool audio,
+                          const cricket::AudioOptions& audio_options,
+                          bool video);
+
+  // sigslots
+  sigslot::signal3<const std::string&, int, const std::string&>
+      SignalOnIceCandidateReady;
+  sigslot::signal1<const std::string&> SignalOnSdpReady;
+  sigslot::signal1<webrtc::DataChannelInterface*> SignalOnDataChannel;
+
+ private:
+  void SetLocalDescription(webrtc::SdpType type, const std::string& sdp);
+  void SetRemoteDescription(webrtc::SdpType type, const std::string& sdp);
+  bool CheckForConnection();
+  bool CheckForAudio();
+  bool CheckForVideo();
+  rtc::scoped_refptr<webrtc::MediaStreamInterface> GetUserMedia(
+      bool audio,
+      const cricket::AudioOptions& audio_options,
+      bool video);
+
+  webrtc::test::ScopedKeyValueConfig field_trials_;
+  std::string name_;
+  rtc::SocketServer* const socket_server_;
+  rtc::Thread* const network_thread_;
+  rtc::Thread* const worker_thread_;
+  webrtc::SequenceChecker pc_thread_checker_;
+  rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection_;
+  rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface>
+      peer_connection_factory_;
+  rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
+  std::unique_ptr<webrtc::FakeVideoTrackRenderer> renderer_;
+  int num_get_user_media_calls_ = 0;
+  bool pending_negotiation_;
+};
+
+#endif  // PC_TEST_PEER_CONNECTION_TEST_WRAPPER_H_
diff --git a/third_party/libwebrtc/pc/test/rtc_stats_obtainer.h b/third_party/libwebrtc/pc/test/rtc_stats_obtainer.h
new file mode 100644
index 0000000000..b1cc701a06
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/rtc_stats_obtainer.h
@@ -0,0 +1,55 @@
+/*
+ *  Copyright 2016 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.
+ */
+
+#ifndef PC_TEST_RTC_STATS_OBTAINER_H_
+#define PC_TEST_RTC_STATS_OBTAINER_H_
+
+#include "api/make_ref_counted.h"
+#include "api/sequence_checker.h"
+#include "api/stats/rtc_stats_collector_callback.h"
+#include "api/stats/rtc_stats_report.h"
+#include "rtc_base/gunit.h"
+
+namespace webrtc {
+
+class RTCStatsObtainer : public RTCStatsCollectorCallback {
+ public:
+  static rtc::scoped_refptr<RTCStatsObtainer> Create(
+      rtc::scoped_refptr<const RTCStatsReport>* report_ptr = nullptr) {
+    return rtc::make_ref_counted<RTCStatsObtainer>(report_ptr);
+  }
+
+  void OnStatsDelivered(
+      const rtc::scoped_refptr<const RTCStatsReport>& report) override {
+    EXPECT_TRUE(thread_checker_.IsCurrent());
+    report_ = report;
+    if (report_ptr_)
+      *report_ptr_ = report_;
+  }
+
+  rtc::scoped_refptr<const RTCStatsReport> report() const {
+    EXPECT_TRUE(thread_checker_.IsCurrent());
+    return report_;
+  }
+
+ protected:
+  explicit RTCStatsObtainer(
+      rtc::scoped_refptr<const RTCStatsReport>* report_ptr)
+      : report_ptr_(report_ptr) {}
+
+ private:
+  SequenceChecker thread_checker_;
+  rtc::scoped_refptr<const RTCStatsReport> report_;
+  rtc::scoped_refptr<const RTCStatsReport>* report_ptr_;
+};
+
+}  // namespace webrtc
+
+#endif  // PC_TEST_RTC_STATS_OBTAINER_H_
diff --git a/third_party/libwebrtc/pc/test/rtp_transport_test_util.h b/third_party/libwebrtc/pc/test/rtp_transport_test_util.h
new file mode 100644
index 0000000000..0353b74754
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/rtp_transport_test_util.h
@@ -0,0 +1,78 @@
+/*
+ *  Copyright 2017 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.
+ */
+
+#ifndef PC_TEST_RTP_TRANSPORT_TEST_UTIL_H_
+#define PC_TEST_RTP_TRANSPORT_TEST_UTIL_H_
+
+#include "call/rtp_packet_sink_interface.h"
+#include "modules/rtp_rtcp/source/rtp_packet_received.h"
+#include "pc/rtp_transport_internal.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
+
+namespace webrtc {
+
+// Used to handle the signals when the RtpTransport receives an RTP/RTCP packet.
+// Used in Rtp/Srtp/DtlsTransport unit tests.
+class TransportObserver : public RtpPacketSinkInterface,
+                          public sigslot::has_slots<> {
+ public:
+  TransportObserver() {}
+
+  explicit TransportObserver(RtpTransportInternal* rtp_transport) {
+    rtp_transport->SignalRtcpPacketReceived.connect(
+        this, &TransportObserver::OnRtcpPacketReceived);
+    rtp_transport->SignalReadyToSend.connect(this,
+                                             &TransportObserver::OnReadyToSend);
+  }
+
+  // RtpPacketInterface override.
+  void OnRtpPacket(const RtpPacketReceived& packet) override {
+    rtp_count_++;
+    last_recv_rtp_packet_ = packet.Buffer();
+  }
+
+  void OnRtcpPacketReceived(rtc::CopyOnWriteBuffer* packet,
+                            int64_t packet_time_us) {
+    rtcp_count_++;
+    last_recv_rtcp_packet_ = *packet;
+  }
+
+  int rtp_count() const { return rtp_count_; }
+  int rtcp_count() const { return rtcp_count_; }
+
+  rtc::CopyOnWriteBuffer last_recv_rtp_packet() {
+    return last_recv_rtp_packet_;
+  }
+
+  rtc::CopyOnWriteBuffer last_recv_rtcp_packet() {
+    return last_recv_rtcp_packet_;
+  }
+
+  void OnReadyToSend(bool ready) {
+    ready_to_send_signal_count_++;
+    ready_to_send_ = ready;
+  }
+
+  bool ready_to_send() { return ready_to_send_; }
+
+  int ready_to_send_signal_count() { return ready_to_send_signal_count_; }
+
+ private:
+  bool ready_to_send_ = false;
+  int rtp_count_ = 0;
+  int rtcp_count_ = 0;
+  int ready_to_send_signal_count_ = 0;
+  rtc::CopyOnWriteBuffer last_recv_rtp_packet_;
+  rtc::CopyOnWriteBuffer last_recv_rtcp_packet_;
+};
+
+}  // namespace webrtc
+
+#endif  // PC_TEST_RTP_TRANSPORT_TEST_UTIL_H_
diff --git a/third_party/libwebrtc/pc/test/srtp_test_util.h b/third_party/libwebrtc/pc/test/srtp_test_util.h
new file mode 100644
index 0000000000..ae02310eba
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/srtp_test_util.h
@@ -0,0 +1,45 @@
+/*
+ *  Copyright 2017 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.
+ */
+
+#ifndef PC_TEST_SRTP_TEST_UTIL_H_
+#define PC_TEST_SRTP_TEST_UTIL_H_
+
+#include <string>
+
+namespace rtc {
+
+extern const char kCsAesCm128HmacSha1_32[];
+extern const char kCsAeadAes128Gcm[];
+extern const char kCsAeadAes256Gcm[];
+
+static const uint8_t kTestKey1[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234";
+static const uint8_t kTestKey2[] = "4321ZYXWVUTSRQPONMLKJIHGFEDCBA";
+static const int kTestKeyLen = 30;
+
+static int rtp_auth_tag_len(const std::string& cs) {
+  if (cs == kCsAesCm128HmacSha1_32) {
+    return 4;
+  } else if (cs == kCsAeadAes128Gcm || cs == kCsAeadAes256Gcm) {
+    return 16;
+  } else {
+    return 10;
+  }
+}
+static int rtcp_auth_tag_len(const std::string& cs) {
+  if (cs == kCsAeadAes128Gcm || cs == kCsAeadAes256Gcm) {
+    return 16;
+  } else {
+    return 10;
+  }
+}
+
+}  // namespace rtc
+
+#endif  // PC_TEST_SRTP_TEST_UTIL_H_
diff --git a/third_party/libwebrtc/pc/test/svc_e2e_tests.cc b/third_party/libwebrtc/pc/test/svc_e2e_tests.cc
new file mode 100644
index 0000000000..dea0763758
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/svc_e2e_tests.cc
@@ -0,0 +1,507 @@
+/*
+ *  Copyright (c) 2022 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 <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "api/media_stream_interface.h"
+#include "api/stats/rtcstats_objects.h"
+#include "api/test/create_network_emulation_manager.h"
+#include "api/test/create_peer_connection_quality_test_frame_generator.h"
+#include "api/test/create_peerconnection_quality_test_fixture.h"
+#include "api/test/frame_generator_interface.h"
+#include "api/test/metrics/global_metrics_logger_and_exporter.h"
+#include "api/test/network_emulation_manager.h"
+#include "api/test/pclf/media_configuration.h"
+#include "api/test/pclf/media_quality_test_params.h"
+#include "api/test/pclf/peer_configurer.h"
+#include "api/test/peerconnection_quality_test_fixture.h"
+#include "api/test/simulated_network.h"
+#include "api/test/time_controller.h"
+#include "api/video_codecs/vp9_profile.h"
+#include "call/simulated_network.h"
+#include "modules/video_coding/codecs/vp9/include/vp9.h"
+#include "modules/video_coding/svc/scalability_mode_util.h"
+#include "rtc_base/containers/flat_map.h"
+#include "system_wrappers/include/field_trial.h"
+#include "test/field_trial.h"
+#include "test/gmock.h"
+#include "test/gtest.h"
+#include "test/pc/e2e/analyzer/video/default_video_quality_analyzer.h"
+#include "test/pc/e2e/network_quality_metrics_reporter.h"
+#include "test/testsupport/file_utils.h"
+
+namespace webrtc {
+namespace {
+
+using ::cricket::kAv1CodecName;
+using ::cricket::kH264CodecName;
+using ::cricket::kVp8CodecName;
+using ::cricket::kVp9CodecName;
+using ::testing::Combine;
+using ::testing::Optional;
+using ::testing::UnitTest;
+using ::testing::Values;
+using ::testing::ValuesIn;
+using ::webrtc::webrtc_pc_e2e::EmulatedSFUConfig;
+using ::webrtc::webrtc_pc_e2e::PeerConfigurer;
+using ::webrtc::webrtc_pc_e2e::RunParams;
+using ::webrtc::webrtc_pc_e2e::ScreenShareConfig;
+using ::webrtc::webrtc_pc_e2e::VideoCodecConfig;
+using ::webrtc::webrtc_pc_e2e::VideoConfig;
+
+std::unique_ptr<webrtc_pc_e2e::PeerConnectionE2EQualityTestFixture>
+CreateTestFixture(absl::string_view test_case_name,
+                  TimeController& time_controller,
+                  std::pair<EmulatedNetworkManagerInterface*,
+                            EmulatedNetworkManagerInterface*> network_links,
+                  rtc::FunctionView<void(PeerConfigurer*)> alice_configurer,
+                  rtc::FunctionView<void(PeerConfigurer*)> bob_configurer,
+                  std::unique_ptr<VideoQualityAnalyzerInterface>
+                      video_quality_analyzer = nullptr) {
+  auto fixture = webrtc_pc_e2e::CreatePeerConnectionE2EQualityTestFixture(
+      std::string(test_case_name), time_controller, nullptr,
+      std::move(video_quality_analyzer));
+  auto alice = std::make_unique<PeerConfigurer>(
+      network_links.first->network_dependencies());
+  auto bob = std::make_unique<PeerConfigurer>(
+      network_links.second->network_dependencies());
+  alice_configurer(alice.get());
+  bob_configurer(bob.get());
+  fixture->AddPeer(std::move(alice));
+  fixture->AddPeer(std::move(bob));
+  return fixture;
+}
+
+// Takes the current active field trials set, and appends some new trials.
+std::string AppendFieldTrials(std::string new_trial_string) {
+  return std::string(field_trial::GetFieldTrialString()) + new_trial_string;
+}
+
+enum class UseDependencyDescriptor {
+  Enabled,
+  Disabled,
+};
+
+struct SvcTestParameters {
+  static SvcTestParameters Create(const std::string& codec_name,
+                                  const std::string& scalability_mode_str) {
+    absl::optional<ScalabilityMode> scalability_mode =
+        ScalabilityModeFromString(scalability_mode_str);
+    RTC_CHECK(scalability_mode.has_value())
+        << "Unsupported scalability mode: " << scalability_mode_str;
+
+    int num_spatial_layers =
+        ScalabilityModeToNumSpatialLayers(*scalability_mode);
+    int num_temporal_layers =
+        ScalabilityModeToNumTemporalLayers(*scalability_mode);
+
+    return SvcTestParameters{codec_name, scalability_mode_str,
+                             num_spatial_layers, num_temporal_layers};
+  }
+
+  std::string codec_name;
+  std::string scalability_mode;
+  int expected_spatial_layers;
+  int expected_temporal_layers;
+};
+
+class SvcTest : public testing::TestWithParam<
+                    std::tuple<SvcTestParameters, UseDependencyDescriptor>> {
+ public:
+  SvcTest()
+      : video_codec_config(ToVideoCodecConfig(SvcTestParameters().codec_name)) {
+  }
+
+  static VideoCodecConfig ToVideoCodecConfig(absl::string_view codec) {
+    if (codec == cricket::kVp9CodecName) {
+      return VideoCodecConfig(
+          cricket::kVp9CodecName,
+          {{kVP9FmtpProfileId, VP9ProfileToString(VP9Profile::kProfile0)}});
+    }
+
+    return VideoCodecConfig(std::string(codec));
+  }
+
+  const SvcTestParameters& SvcTestParameters() const {
+    return std::get<0>(GetParam());
+  }
+
+  bool UseDependencyDescriptor() const {
+    return std::get<1>(GetParam()) == UseDependencyDescriptor::Enabled;
+  }
+
+  bool IsSMode() const {
+    return SvcTestParameters().scalability_mode[0] == 'S';
+  }
+
+ protected:
+  VideoCodecConfig video_codec_config;
+};
+
+std::string SvcTestNameGenerator(
+    const testing::TestParamInfo<SvcTest::ParamType>& info) {
+  return std::get<0>(info.param).scalability_mode +
+         (std::get<1>(info.param) == UseDependencyDescriptor::Enabled ? "_DD"
+                                                                      : "");
+}
+
+}  // namespace
+
+// Records how many frames are seen for each spatial and temporal index at the
+// encoder and decoder level.
+class SvcVideoQualityAnalyzer : public DefaultVideoQualityAnalyzer {
+ public:
+  using SpatialTemporalLayerCounts =
+      webrtc::flat_map<int, webrtc::flat_map<int, int>>;
+
+  explicit SvcVideoQualityAnalyzer(webrtc::Clock* clock)
+      : DefaultVideoQualityAnalyzer(clock,
+                                    test::GetGlobalMetricsLogger(),
+                                    DefaultVideoQualityAnalyzerOptions{
+                                        .compute_psnr = false,
+                                        .compute_ssim = false,
+                                    }) {}
+  ~SvcVideoQualityAnalyzer() override = default;
+
+  void OnFrameEncoded(absl::string_view peer_name,
+                      uint16_t frame_id,
+                      const EncodedImage& encoded_image,
+                      const EncoderStats& stats,
+                      bool discarded) override {
+    absl::optional<int> spatial_id = encoded_image.SpatialIndex();
+    absl::optional<int> temporal_id = encoded_image.TemporalIndex();
+    encoder_layers_seen_[spatial_id.value_or(0)][temporal_id.value_or(0)]++;
+    DefaultVideoQualityAnalyzer::OnFrameEncoded(
+        peer_name, frame_id, encoded_image, stats, discarded);
+  }
+
+  void OnFramePreDecode(absl::string_view peer_name,
+                        uint16_t frame_id,
+                        const EncodedImage& input_image) override {
+    absl::optional<int> spatial_id = input_image.SpatialIndex();
+    absl::optional<int> temporal_id = input_image.TemporalIndex();
+    if (!spatial_id) {
+      decoder_layers_seen_[0][temporal_id.value_or(0)]++;
+    } else {
+      for (int i = 0; i <= *spatial_id; ++i) {
+        // If there are no spatial layers (for example VP8), we still want to
+        // record the temporal index for pseudo-layer "0" frames.
+        if (*spatial_id == 0 ||
+            input_image.SpatialLayerFrameSize(i).value_or(0) > 0) {
+          decoder_layers_seen_[i][temporal_id.value_or(0)]++;
+        }
+      }
+    }
+    DefaultVideoQualityAnalyzer::OnFramePreDecode(peer_name, frame_id,
+                                                  input_image);
+  }
+
+  void OnStatsReports(
+      absl::string_view pc_label,
+      const rtc::scoped_refptr<const RTCStatsReport>& report) override {
+    // Extract the scalability mode reported in the stats.
+    auto outbound_stats = report->GetStatsOfType<RTCOutboundRTPStreamStats>();
+    for (const auto& stat : outbound_stats) {
+      if (stat->scalability_mode.is_defined()) {
+        reported_scalability_mode_ = *stat->scalability_mode;
+      }
+    }
+  }
+
+  const SpatialTemporalLayerCounts& encoder_layers_seen() const {
+    return encoder_layers_seen_;
+  }
+  const SpatialTemporalLayerCounts& decoder_layers_seen() const {
+    return decoder_layers_seen_;
+  }
+  const absl::optional<std::string> reported_scalability_mode() const {
+    return reported_scalability_mode_;
+  }
+
+ private:
+  SpatialTemporalLayerCounts encoder_layers_seen_;
+  SpatialTemporalLayerCounts decoder_layers_seen_;
+  absl::optional<std::string> reported_scalability_mode_;
+};
+
+MATCHER_P2(HasSpatialAndTemporalLayers,
+           expected_spatial_layers,
+           expected_temporal_layers,
+           "") {
+  if (arg.size() != static_cast<size_t>(expected_spatial_layers)) {
+    *result_listener << "spatial layer count mismatch expected "
+                     << expected_spatial_layers << " but got " << arg.size();
+    return false;
+  }
+  for (const auto& [spatial_layer_index, temporal_layers] : arg) {
+    if (spatial_layer_index < 0 ||
+        spatial_layer_index >= expected_spatial_layers) {
+      *result_listener << "spatial layer index is not in range [0,"
+                       << expected_spatial_layers << "[.";
+      return false;
+    }
+
+    if (temporal_layers.size() !=
+        static_cast<size_t>(expected_temporal_layers)) {
+      *result_listener << "temporal layer count mismatch on spatial layer "
+                       << spatial_layer_index << ", expected "
+                       << expected_temporal_layers << " but got "
+                       << temporal_layers.size();
+      return false;
+    }
+    for (const auto& [temporal_layer_index, temporal_layer_frame_count] :
+         temporal_layers) {
+      if (temporal_layer_index < 0 ||
+          temporal_layer_index >= expected_temporal_layers) {
+        *result_listener << "temporal layer index on spatial layer "
+                         << spatial_layer_index << " is not in range [0,"
+                         << expected_temporal_layers << "[.";
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+MATCHER_P2(HasSpatialAndTemporalLayersSMode,
+           expected_spatial_layers,
+           expected_temporal_layers,
+           "") {
+  if (arg.size() != 1) {
+    *result_listener << "spatial layer count mismatch expected 1 but got "
+                     << arg.size();
+    return false;
+  }
+  for (const auto& [spatial_layer_index, temporal_layers] : arg) {
+    if (spatial_layer_index != expected_spatial_layers - 1) {
+      *result_listener << "spatial layer index is not equal to "
+                       << expected_spatial_layers - 1 << ".";
+      return false;
+    }
+
+    if (temporal_layers.size() !=
+        static_cast<size_t>(expected_temporal_layers)) {
+      *result_listener << "temporal layer count mismatch on spatial layer "
+                       << spatial_layer_index << ", expected "
+                       << expected_temporal_layers << " but got "
+                       << temporal_layers.size();
+      return false;
+    }
+    for (const auto& [temporal_layer_index, temporal_layer_frame_count] :
+         temporal_layers) {
+      if (temporal_layer_index < 0 ||
+          temporal_layer_index >= expected_temporal_layers) {
+        *result_listener << "temporal layer index on spatial layer "
+                         << spatial_layer_index << " is not in range [0,"
+                         << expected_temporal_layers << "[.";
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+TEST_P(SvcTest, ScalabilityModeSupported) {
+  std::string trials;
+  if (UseDependencyDescriptor()) {
+    trials += "WebRTC-DependencyDescriptorAdvertised/Enabled/";
+  }
+  webrtc::test::ScopedFieldTrials override_trials(AppendFieldTrials(trials));
+  std::unique_ptr<NetworkEmulationManager> network_emulation_manager =
+      CreateNetworkEmulationManager(webrtc::TimeMode::kSimulated);
+  auto analyzer = std::make_unique<SvcVideoQualityAnalyzer>(
+      network_emulation_manager->time_controller()->GetClock());
+  SvcVideoQualityAnalyzer* analyzer_ptr = analyzer.get();
+  auto fixture = CreateTestFixture(
+      UnitTest::GetInstance()->current_test_info()->name(),
+      *network_emulation_manager->time_controller(),
+      network_emulation_manager->CreateEndpointPairWithTwoWayRoutes(
+          BuiltInNetworkBehaviorConfig()),
+      [this](PeerConfigurer* alice) {
+        VideoConfig video(/*stream_label=*/"alice-video", /*width=*/1850,
+                          /*height=*/1110, /*fps=*/30);
+        if (IsSMode()) {
+          video.emulated_sfu_config = EmulatedSFUConfig(
+              SvcTestParameters().expected_spatial_layers - 1,
+              SvcTestParameters().expected_temporal_layers - 1);
+        }
+        RtpEncodingParameters parameters;
+        parameters.scalability_mode = SvcTestParameters().scalability_mode;
+        video.encoding_params.push_back(parameters);
+        alice->AddVideoConfig(
+            std::move(video),
+            CreateScreenShareFrameGenerator(
+                video, ScreenShareConfig(TimeDelta::Seconds(5))));
+        alice->SetVideoCodecs({video_codec_config});
+      },
+      [](PeerConfigurer* bob) {}, std::move(analyzer));
+  fixture->Run(RunParams(TimeDelta::Seconds(5)));
+  EXPECT_THAT(analyzer_ptr->encoder_layers_seen(),
+              HasSpatialAndTemporalLayers(
+                  SvcTestParameters().expected_spatial_layers,
+                  SvcTestParameters().expected_temporal_layers));
+  if (IsSMode()) {
+    EXPECT_THAT(analyzer_ptr->decoder_layers_seen(),
+                HasSpatialAndTemporalLayersSMode(
+                    SvcTestParameters().expected_spatial_layers,
+                    SvcTestParameters().expected_temporal_layers));
+  } else {
+    EXPECT_THAT(analyzer_ptr->decoder_layers_seen(),
+                HasSpatialAndTemporalLayers(
+                    SvcTestParameters().expected_spatial_layers,
+                    SvcTestParameters().expected_temporal_layers));
+  }
+  EXPECT_THAT(analyzer_ptr->reported_scalability_mode(),
+              Optional(SvcTestParameters().scalability_mode));
+
+  RTC_LOG(LS_INFO) << "Encoder layers seen: "
+                   << analyzer_ptr->encoder_layers_seen().size();
+  for (auto& [spatial_index, temporal_layers] :
+       analyzer_ptr->encoder_layers_seen()) {
+    for (auto& [temporal_index, frame_count] : temporal_layers) {
+      RTC_LOG(LS_INFO) << "  Layer: " << spatial_index << "," << temporal_index
+                       << " frames: " << frame_count;
+    }
+  }
+  RTC_LOG(LS_INFO) << "Decoder layers seen: "
+                   << analyzer_ptr->decoder_layers_seen().size();
+  for (auto& [spatial_index, temporal_layers] :
+       analyzer_ptr->decoder_layers_seen()) {
+    for (auto& [temporal_index, frame_count] : temporal_layers) {
+      RTC_LOG(LS_INFO) << "  Layer: " << spatial_index << "," << temporal_index
+                       << " frames: " << frame_count;
+    }
+  }
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    SvcTestVP8,
+    SvcTest,
+    Combine(Values(SvcTestParameters::Create(kVp8CodecName, "L1T1"),
+                   SvcTestParameters::Create(kVp8CodecName, "L1T2"),
+                   SvcTestParameters::Create(kVp8CodecName, "L1T3")),
+            Values(UseDependencyDescriptor::Disabled,
+                   UseDependencyDescriptor::Enabled)),
+    SvcTestNameGenerator);
+
+#if defined(WEBRTC_USE_H264)
+INSTANTIATE_TEST_SUITE_P(
+    SvcTestH264,
+    SvcTest,
+    Combine(ValuesIn({
+                SvcTestParameters::Create(kH264CodecName, "L1T1"),
+                SvcTestParameters::Create(kH264CodecName, "L1T2"),
+                SvcTestParameters::Create(kH264CodecName, "L1T3"),
+            }),
+            // Like AV1, H.264 RTP format does not include SVC related
+            // information, so always use Dependency Descriptor.
+            Values(UseDependencyDescriptor::Enabled)),
+    SvcTestNameGenerator);
+#endif
+
+#if defined(RTC_ENABLE_VP9)
+INSTANTIATE_TEST_SUITE_P(
+    SvcTestVP9,
+    SvcTest,
+    Combine(
+        // TODO(bugs.webrtc.org/13960): Fix and enable remaining VP9 modes
+        ValuesIn({
+            SvcTestParameters::Create(kVp9CodecName, "L1T1"),
+            SvcTestParameters::Create(kVp9CodecName, "L1T2"),
+            SvcTestParameters::Create(kVp9CodecName, "L1T3"),
+            SvcTestParameters::Create(kVp9CodecName, "L2T1"),
+            SvcTestParameters::Create(kVp9CodecName, "L2T1h"),
+            SvcTestParameters::Create(kVp9CodecName, "L2T1_KEY"),
+            SvcTestParameters::Create(kVp9CodecName, "L2T2"),
+            SvcTestParameters::Create(kVp9CodecName, "L2T2h"),
+            SvcTestParameters::Create(kVp9CodecName, "L2T2_KEY"),
+            SvcTestParameters::Create(kVp9CodecName, "L2T2_KEY_SHIFT"),
+            SvcTestParameters::Create(kVp9CodecName, "L2T3"),
+            SvcTestParameters::Create(kVp9CodecName, "L2T3h"),
+            SvcTestParameters::Create(kVp9CodecName, "L2T3_KEY"),
+            // SvcTestParameters::Create(kVp9CodecName, "L2T3_KEY_SHIFT"),
+            SvcTestParameters::Create(kVp9CodecName, "L3T1"),
+            SvcTestParameters::Create(kVp9CodecName, "L3T1h"),
+            SvcTestParameters::Create(kVp9CodecName, "L3T1_KEY"),
+            SvcTestParameters::Create(kVp9CodecName, "L3T2"),
+            SvcTestParameters::Create(kVp9CodecName, "L3T2h"),
+            SvcTestParameters::Create(kVp9CodecName, "L3T2_KEY"),
+            // SvcTestParameters::Create(kVp9CodecName, "L3T2_KEY_SHIFT"),
+            SvcTestParameters::Create(kVp9CodecName, "L3T3"),
+            SvcTestParameters::Create(kVp9CodecName, "L3T3h"),
+            SvcTestParameters::Create(kVp9CodecName, "L3T3_KEY"),
+            // SvcTestParameters::Create(kVp9CodecName, "L3T3_KEY_SHIFT"),
+            SvcTestParameters::Create(kVp9CodecName, "S2T1"),
+            SvcTestParameters::Create(kVp9CodecName, "S2T1h"),
+            SvcTestParameters::Create(kVp9CodecName, "S2T2"),
+            SvcTestParameters::Create(kVp9CodecName, "S2T2h"),
+            SvcTestParameters::Create(kVp9CodecName, "S2T3"),
+            SvcTestParameters::Create(kVp9CodecName, "S2T3h"),
+            SvcTestParameters::Create(kVp9CodecName, "S3T1"),
+            SvcTestParameters::Create(kVp9CodecName, "S3T1h"),
+            SvcTestParameters::Create(kVp9CodecName, "S3T2"),
+            SvcTestParameters::Create(kVp9CodecName, "S3T2h"),
+            SvcTestParameters::Create(kVp9CodecName, "S3T3"),
+            SvcTestParameters::Create(kVp9CodecName, "S3T3h"),
+        }),
+        Values(UseDependencyDescriptor::Disabled,
+               UseDependencyDescriptor::Enabled)),
+    SvcTestNameGenerator);
+
+INSTANTIATE_TEST_SUITE_P(
+    SvcTestAV1,
+    SvcTest,
+    Combine(ValuesIn({
+                SvcTestParameters::Create(kAv1CodecName, "L1T1"),
+                SvcTestParameters::Create(kAv1CodecName, "L1T2"),
+                SvcTestParameters::Create(kAv1CodecName, "L1T3"),
+                SvcTestParameters::Create(kAv1CodecName, "L2T1"),
+                SvcTestParameters::Create(kAv1CodecName, "L2T1h"),
+                SvcTestParameters::Create(kAv1CodecName, "L2T1_KEY"),
+                SvcTestParameters::Create(kAv1CodecName, "L2T2"),
+                SvcTestParameters::Create(kAv1CodecName, "L2T2h"),
+                SvcTestParameters::Create(kAv1CodecName, "L2T2_KEY"),
+                SvcTestParameters::Create(kAv1CodecName, "L2T2_KEY_SHIFT"),
+                SvcTestParameters::Create(kAv1CodecName, "L2T3"),
+                SvcTestParameters::Create(kAv1CodecName, "L2T3h"),
+                SvcTestParameters::Create(kAv1CodecName, "L2T3_KEY"),
+                // SvcTestParameters::Create(kAv1CodecName, "L2T3_KEY_SHIFT"),
+                SvcTestParameters::Create(kAv1CodecName, "L3T1"),
+                SvcTestParameters::Create(kAv1CodecName, "L3T1h"),
+                SvcTestParameters::Create(kAv1CodecName, "L3T1_KEY"),
+                SvcTestParameters::Create(kAv1CodecName, "L3T2"),
+                SvcTestParameters::Create(kAv1CodecName, "L3T2h"),
+                SvcTestParameters::Create(kAv1CodecName, "L3T2_KEY"),
+                // SvcTestParameters::Create(kAv1CodecName, "L3T2_KEY_SHIFT"),
+                SvcTestParameters::Create(kAv1CodecName, "L3T3"),
+                SvcTestParameters::Create(kAv1CodecName, "L3T3h"),
+                SvcTestParameters::Create(kAv1CodecName, "L3T3_KEY"),
+                // SvcTestParameters::Create(kAv1CodecName, "L3T3_KEY_SHIFT"),
+                SvcTestParameters::Create(kAv1CodecName, "S2T1"),
+                SvcTestParameters::Create(kAv1CodecName, "S2T1h"),
+                SvcTestParameters::Create(kAv1CodecName, "S2T2"),
+                SvcTestParameters::Create(kAv1CodecName, "S2T2h"),
+                SvcTestParameters::Create(kAv1CodecName, "S2T3"),
+                SvcTestParameters::Create(kAv1CodecName, "S2T3h"),
+                SvcTestParameters::Create(kAv1CodecName, "S3T1"),
+                SvcTestParameters::Create(kAv1CodecName, "S3T1h"),
+                SvcTestParameters::Create(kAv1CodecName, "S3T2"),
+                SvcTestParameters::Create(kAv1CodecName, "S3T2h"),
+                SvcTestParameters::Create(kAv1CodecName, "S3T3"),
+                SvcTestParameters::Create(kAv1CodecName, "S3T3h"),
+            }),
+            Values(UseDependencyDescriptor::Enabled)),
+    SvcTestNameGenerator);
+
+#endif
+
+}  // namespace webrtc
diff --git a/third_party/libwebrtc/pc/test/test_sdp_strings.h b/third_party/libwebrtc/pc/test/test_sdp_strings.h
new file mode 100644
index 0000000000..e4ad325d31
--- /dev/null
+++ b/third_party/libwebrtc/pc/test/test_sdp_strings.h
@@ -0,0 +1,184 @@
+/*
+ *  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.
+ */
+
+// This file contain SDP strings used for testing.
+
+#ifndef PC_TEST_TEST_SDP_STRINGS_H_
+#define PC_TEST_TEST_SDP_STRINGS_H_
+
+namespace webrtc {
+
+// SDP offer string from a Nightly FireFox build.
+static const char kFireFoxSdpOffer[] =
+    "v=0\r\n"
+    "o=Mozilla-SIPUA 23551 0 IN IP4 0.0.0.0\r\n"
+    "s=SIP Call\r\n"
+    "t=0 0\r\n"
+    "a=ice-ufrag:e5785931\r\n"
+    "a=ice-pwd:36fb7878390db89481c1d46daa4278d8\r\n"
+    "a=fingerprint:sha-256 A7:24:72:CA:6E:02:55:39:BA:66:DF:6E:CC:4C:D8:B0:1A:"
+    "BF:1A:56:65:7D:F4:03:AD:7E:77:43:2A:29:EC:93\r\n"
+    "m=audio 36993 RTP/SAVPF 109 0 8 101\r\n"
+    "c=IN IP4 74.95.2.170\r\n"
+    "a=rtpmap:109 opus/48000/2\r\n"
+    "a=ptime:20\r\n"
+    "a=rtcp-mux\r\n"
+    "a=rtpmap:0 PCMU/8000\r\n"
+    "a=rtpmap:8 PCMA/8000\r\n"
+    "a=rtpmap:101 telephone-event/8000\r\n"
+    "a=fmtp:101 0-15\r\n"
+    "a=sendrecv\r\n"
+    "a=candidate:0 1 UDP 2112946431 172.16.191.1 61725 typ host\r\n"
+    "a=candidate:2 1 UDP 2112487679 172.16.131.1 58798 typ host\r\n"
+    "a=candidate:4 1 UDP 2113667327 10.0.254.2 58122 typ host\r\n"
+    "a=candidate:5 1 UDP 1694302207 74.95.2.170 36993 typ srflx raddr "
+    "10.0.254.2 rport 58122\r\n"
+    "a=candidate:0 2 UDP 2112946430 172.16.191.1 55025 typ host\r\n"
+    "a=candidate:2 2 UDP 2112487678 172.16.131.1 63576 typ host\r\n"
+    "a=candidate:4 2 UDP 2113667326 10.0.254.2 50962 typ host\r\n"
+    "a=candidate:5 2 UDP 1694302206 74.95.2.170 41028 typ srflx raddr"
+    " 10.0.254.2 rport 50962\r\n"
+    "m=video 38826 RTP/SAVPF 120\r\n"
+    "c=IN IP4 74.95.2.170\r\n"
+    "a=rtcp-mux\r\n"
+    "a=rtpmap:120 VP8/90000\r\n"
+    "a=sendrecv\r\n"
+    "a=candidate:0 1 UDP 2112946431 172.16.191.1 62017 typ host\r\n"
+    "a=candidate:2 1 UDP 2112487679 172.16.131.1 59741 typ host\r\n"
+    "a=candidate:4 1 UDP 2113667327 10.0.254.2 62652 typ host\r\n"
+    "a=candidate:5 1 UDP 1694302207 74.95.2.170 38826 typ srflx raddr"
+    " 10.0.254.2 rport 62652\r\n"
+    "a=candidate:0 2 UDP 2112946430 172.16.191.1 63440 typ host\r\n"
+    "a=candidate:2 2 UDP 2112487678 172.16.131.1 51847 typ host\r\n"
+    "a=candidate:4 2 UDP 2113667326 10.0.254.2 58890 typ host\r\n"
+    "a=candidate:5 2 UDP 1694302206 74.95.2.170 33611 typ srflx raddr"
+    " 10.0.254.2 rport 58890\r\n"
+#ifdef WEBRTC_HAVE_SCTP
+    "m=application 45536 DTLS/SCTP 5000\r\n"
+    "c=IN IP4 74.95.2.170\r\n"
+    "a=fmtp:5000 protocol=webrtc-datachannel;streams=16\r\n"
+    "a=sendrecv\r\n"
+    "a=candidate:0 1 UDP 2112946431 172.16.191.1 60248 typ host\r\n"
+    "a=candidate:2 1 UDP 2112487679 172.16.131.1 55925 typ host\r\n"
+    "a=candidate:4 1 UDP 2113667327 10.0.254.2 65268 typ host\r\n"
+    "a=candidate:5 1 UDP 1694302207 74.95.2.170 45536 typ srflx raddr"
+    " 10.0.254.2 rport 65268\r\n"
+    "a=candidate:0 2 UDP 2112946430 172.16.191.1 49162 typ host\r\n"
+    "a=candidate:2 2 UDP 2112487678 172.16.131.1 59635 typ host\r\n"
+    "a=candidate:4 2 UDP 2113667326 10.0.254.2 61232 typ host\r\n"
+    "a=candidate:5 2 UDP 1694302206 74.95.2.170 45468 typ srflx raddr"
+    " 10.0.254.2 rport 61232\r\n"
+#endif
+    ;  // NOLINT(whitespace/semicolon)
+
+// Audio SDP with a limited set of audio codecs.
+static const char kAudioSdpPlanB[] =
+    "v=0\r\n"
+    "o=- 7859371131 2 IN IP4 192.168.30.208\r\n"
+    "s=-\r\n"
+    "c=IN IP4 192.168.30.208\r\n"
+    "t=0 0\r\n"
+    "m=audio 16000 RTP/SAVPF 0 8 126\r\n"
+    "a=rtpmap:0 PCMU/8000\r\n"
+    "a=rtpmap:8 PCMA/8000\r\n"
+    "a=rtpmap:126 telephone-event/8000\r\n"
+    "a=sendrecv\r\n"
+    "a=rtcp:16000 IN IP4 192.168.30.208\r\n"
+    "a=rtcp-mux\r\n"
+    "a=crypto:0 AES_CM_128_HMAC_SHA1_80 "
+    "inline:tvKIFjbMQ7W0/C2RzhwN0oQglj/7GJg+frdsNRxt\r\n"
+    "a=ice-ufrag:AI2sRT3r\r\n"
+    "a=ice-pwd:lByS9z2RSQlSE9XurlvjYmEm\r\n"
+    "a=ssrc:4227871655 cname:GeAAgb6XCPNLVMX5\r\n"
+    "a=ssrc:4227871655 msid:1NFAV3iD08ioO2339rQS9pfOI9mDf6GeG9F4 a0\r\n"
+    "a=ssrc:4227871655 mslabel:1NFAV3iD08ioO2339rQS9pfOI9mDf6GeG9F4\r\n"
+    "a=ssrc:4227871655 label:1NFAV3iD08ioO2339rQS9pfOI9mDf6GeG9F4a0\r\n"
+    "a=mid:audio\r\n";
+// Same string as above but with the MID changed to the Unified Plan default.
+// This is needed so that this SDP can be used as an answer for a Unified Plan
+// offer.
+static const char kAudioSdpUnifiedPlan[] =
+    "v=0\r\n"
+    "o=- 7859371131 2 IN IP4 192.168.30.208\r\n"
+    "s=-\r\n"
+    "c=IN IP4 192.168.30.208\r\n"
+    "t=0 0\r\n"
+    "m=audio 16000 RTP/SAVPF 0 8 126\r\n"
+    "a=rtpmap:0 PCMU/8000\r\n"
+    "a=rtpmap:8 PCMA/8000\r\n"
+    "a=rtpmap:126 telephone-event/8000\r\n"
+    "a=sendrecv\r\n"
+    "a=rtcp:16000 IN IP4 192.168.30.208\r\n"
+    "a=rtcp-mux\r\n"
+    "a=crypto:0 AES_CM_128_HMAC_SHA1_80 "
+    "inline:tvKIFjbMQ7W0/C2RzhwN0oQglj/7GJg+frdsNRxt\r\n"
+    "a=ice-ufrag:AI2sRT3r\r\n"
+    "a=ice-pwd:lByS9z2RSQlSE9XurlvjYmEm\r\n"
+    "a=ssrc:4227871655 cname:GeAAgb6XCPNLVMX5\r\n"
+    "a=ssrc:4227871655 msid:1NFAV3iD08ioO2339rQS9pfOI9mDf6GeG9F4 a0\r\n"
+    "a=ssrc:4227871655 mslabel:1NFAV3iD08ioO2339rQS9pfOI9mDf6GeG9F4\r\n"
+    "a=ssrc:4227871655 label:1NFAV3iD08ioO2339rQS9pfOI9mDf6GeG9F4a0\r\n"
+    "a=mid:0\r\n";
+
+static const char kAudioSdpWithUnsupportedCodecsPlanB[] =
+    "v=0\r\n"
+    "o=- 6858750541 2 IN IP4 192.168.30.208\r\n"
+    "s=-\r\n"
+    "c=IN IP4 192.168.30.208\r\n"
+    "t=0 0\r\n"
+    "m=audio 16000 RTP/SAVPF 0 8 109 110 126\r\n"
+    "a=rtpmap:0 PCMU/8000\r\n"
+    "a=rtpmap:8 PCMA/8000\r\n"
+    "a=rtpmap:109 WeirdCodec1/8000\r\n"
+    "a=rtpmap:110 WeirdCodec2/8000\r\n"
+    "a=rtpmap:126 telephone-event/8000\r\n"
+    "a=sendonly\r\n"
+    "a=rtcp:16000 IN IP4 192.168.30.208\r\n"
+    "a=rtcp-mux\r\n"
+    "a=crypto:0 AES_CM_128_HMAC_SHA1_80 "
+    "inline:tvKIFjbMQ7W0/C2RzhwN0oQglj/7GJg+frdsNRxt\r\n"
+    "a=ice-ufrag:AI2sRT3r\r\n"
+    "a=ice-pwd:lByS9z2RSQlSE9XurlvjYmEm\r\n"
+    "a=ssrc:4227871655 cname:TsmD02HRfhkJBm4m\r\n"
+    "a=ssrc:4227871655 msid:7nU0TApbB-n4dfPlCplWT9QTEsbBDS1IlpW3 a0\r\n"
+    "a=ssrc:4227871655 mslabel:7nU0TApbB-n4dfPlCplWT9QTEsbBDS1IlpW3\r\n"
+    "a=ssrc:4227871655 label:7nU0TApbB-n4dfPlCplWT9QTEsbBDS1IlpW3a0\r\n"
+    "a=mid:audio\r\n";
+// Same string as above but with the MID changed to the Unified Plan default.
+// This is needed so that this SDP can be used as an answer for a Unified Plan
+// offer.
+static const char kAudioSdpWithUnsupportedCodecsUnifiedPlan[] =
+    "v=0\r\n"
+    "o=- 6858750541 2 IN IP4 192.168.30.208\r\n"
+    "s=-\r\n"
+    "c=IN IP4 192.168.30.208\r\n"
+    "t=0 0\r\n"
+    "m=audio 16000 RTP/SAVPF 0 8 109 110 126\r\n"
+    "a=rtpmap:0 PCMU/8000\r\n"
+    "a=rtpmap:8 PCMA/8000\r\n"
+    "a=rtpmap:109 WeirdCodec1/8000\r\n"
+    "a=rtpmap:110 WeirdCodec2/8000\r\n"
+    "a=rtpmap:126 telephone-event/8000\r\n"
+    "a=sendonly\r\n"
+    "a=rtcp:16000 IN IP4 192.168.30.208\r\n"
+    "a=rtcp-mux\r\n"
+    "a=crypto:0 AES_CM_128_HMAC_SHA1_80 "
+    "inline:tvKIFjbMQ7W0/C2RzhwN0oQglj/7GJg+frdsNRxt\r\n"
+    "a=ice-ufrag:AI2sRT3r\r\n"
+    "a=ice-pwd:lByS9z2RSQlSE9XurlvjYmEm\r\n"
+    "a=ssrc:4227871655 cname:TsmD02HRfhkJBm4m\r\n"
+    "a=ssrc:4227871655 msid:7nU0TApbB-n4dfPlCplWT9QTEsbBDS1IlpW3 a0\r\n"
+    "a=ssrc:4227871655 mslabel:7nU0TApbB-n4dfPlCplWT9QTEsbBDS1IlpW3\r\n"
+    "a=ssrc:4227871655 label:7nU0TApbB-n4dfPlCplWT9QTEsbBDS1IlpW3a0\r\n"
+    "a=mid:0\r\n";
+
+}  // namespace webrtc
+
+#endif  // PC_TEST_TEST_SDP_STRINGS_H_