diff --git a/api/audio/echo_canceller3_config.cc b/api/audio/echo_canceller3_config.cc
index 036ef9c..29d0b9a 100644
--- a/api/audio/echo_canceller3_config.cc
+++ b/api/audio/echo_canceller3_config.cc
@@ -10,14 +10,16 @@
 #include "api/audio/echo_canceller3_config.h"
 
 #include <algorithm>
+#include <cmath>
 
-#include "rtc_base/logging.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/numerics/safe_minmax.h"
 
 namespace webrtc {
 namespace {
 bool Limit(float* value, float min, float max) {
   float clamped = rtc::SafeClamp(*value, min, max);
+  clamped = std::isfinite(clamped) ? clamped : min;
   bool res = *value == clamped;
   *value = clamped;
   return res;
@@ -45,9 +47,6 @@
 EchoCanceller3Config::Delay::Delay(const EchoCanceller3Config::Delay& e) =
     default;
 
-EchoCanceller3Config::Mask::Mask() = default;
-EchoCanceller3Config::Mask::Mask(const EchoCanceller3Config::Mask& m) = default;
-
 EchoCanceller3Config::EchoModel::EchoModel() = default;
 EchoCanceller3Config::EchoModel::EchoModel(
     const EchoCanceller3Config::EchoModel& e) = default;
@@ -88,180 +87,161 @@
     c->delay.down_sampling_factor = 4;
     res = false;
   }
-
-  if (c->delay.num_filters == 0) {
-    c->delay.num_filters = 1;
-    res = false;
-  }
-  if (c->delay.api_call_jitter_blocks == 0) {
-    c->delay.api_call_jitter_blocks = 1;
-    res = false;
-  }
-
-  if (c->delay.api_call_jitter_blocks == 0) {
-    c->delay.api_call_jitter_blocks = 1;
-    res = false;
-  }
   if (c->delay.delay_headroom_blocks <= 1 &&
       c->delay.hysteresis_limit_1_blocks == 1) {
     c->delay.hysteresis_limit_1_blocks = 0;
     res = false;
   }
-  res = res && Limit(&c->delay.delay_estimate_smoothing, 0.f, 1.f);
-  res = res && Limit(&c->delay.delay_candidate_detection_threshold, 0.f, 1.f);
-  res = res && Limit(&c->delay.delay_selection_thresholds.initial, 1, 250);
-  res = res && Limit(&c->delay.delay_selection_thresholds.converged, 1, 250);
+  res = res & Limit(&c->delay.default_delay, 0, 5000);
+  res = res & Limit(&c->delay.num_filters, 0, 5000);
+  res = res & Limit(&c->delay.api_call_jitter_blocks, 1, 5000);
+  res = res & Limit(&c->delay.min_echo_path_delay_blocks, 0, 5000);
+  res = res & Limit(&c->delay.delay_headroom_blocks, 0, 5000);
+  res = res & Limit(&c->delay.hysteresis_limit_1_blocks, 0, 5000);
+  res = res & Limit(&c->delay.hysteresis_limit_2_blocks, 0, 5000);
+  res = res & Limit(&c->delay.skew_hysteresis_blocks, 0, 5000);
+  res = res & Limit(&c->delay.fixed_capture_delay_samples, 0, 5000);
+  res = res & Limit(&c->delay.delay_estimate_smoothing, 0.f, 1.f);
+  res = res & Limit(&c->delay.delay_candidate_detection_threshold, 0.f, 1.f);
+  res = res & Limit(&c->delay.delay_selection_thresholds.initial, 1, 250);
+  res = res & Limit(&c->delay.delay_selection_thresholds.converged, 1, 250);
 
-  res = res && Limit(&c->filter.main.length_blocks, 1, 50);
-  res = res && Limit(&c->filter.main.leakage_converged, 0.f, 1000.f);
-  res = res && Limit(&c->filter.main.leakage_diverged, 0.f, 1000.f);
-  res = res && Limit(&c->filter.main.error_floor, 0.f, 1000.f);
-  res = res && Limit(&c->filter.main.noise_gate, 0.f, 100000000.f);
+  res = res & Limit(&c->filter.main.length_blocks, 1, 50);
+  res = res & Limit(&c->filter.main.leakage_converged, 0.f, 1000.f);
+  res = res & Limit(&c->filter.main.leakage_diverged, 0.f, 1000.f);
+  res = res & Limit(&c->filter.main.error_floor, 0.f, 1000.f);
+  res = res & Limit(&c->filter.main.error_ceil, 0.f, 100000000.f);
+  res = res & Limit(&c->filter.main.noise_gate, 0.f, 100000000.f);
 
-  res = res && Limit(&c->filter.main_initial.length_blocks, 1, 50);
-  res = res && Limit(&c->filter.main_initial.leakage_converged, 0.f, 1000.f);
-  res = res && Limit(&c->filter.main_initial.leakage_diverged, 0.f, 1000.f);
-  res = res && Limit(&c->filter.main_initial.error_floor, 0.f, 1000.f);
-  res = res && Limit(&c->filter.main_initial.noise_gate, 0.f, 100000000.f);
+  res = res & Limit(&c->filter.main_initial.length_blocks, 1, 50);
+  res = res & Limit(&c->filter.main_initial.leakage_converged, 0.f, 1000.f);
+  res = res & Limit(&c->filter.main_initial.leakage_diverged, 0.f, 1000.f);
+  res = res & Limit(&c->filter.main_initial.error_floor, 0.f, 1000.f);
+  res = res & Limit(&c->filter.main_initial.error_ceil, 0.f, 100000000.f);
+  res = res & Limit(&c->filter.main_initial.noise_gate, 0.f, 100000000.f);
 
   if (c->filter.main.length_blocks < c->filter.main_initial.length_blocks) {
     c->filter.main_initial.length_blocks = c->filter.main.length_blocks;
     res = false;
   }
 
-  res = res && Limit(&c->filter.shadow.length_blocks, 1, 50);
-  res = res && Limit(&c->filter.shadow.rate, 0.f, 1.f);
-  res = res && Limit(&c->filter.shadow.noise_gate, 0.f, 100000000.f);
+  res = res & Limit(&c->filter.shadow.length_blocks, 1, 50);
+  res = res & Limit(&c->filter.shadow.rate, 0.f, 1.f);
+  res = res & Limit(&c->filter.shadow.noise_gate, 0.f, 100000000.f);
 
-  res = res && Limit(&c->filter.shadow_initial.length_blocks, 1, 50);
-  res = res && Limit(&c->filter.shadow_initial.rate, 0.f, 1.f);
-  res = res && Limit(&c->filter.shadow_initial.noise_gate, 0.f, 100000000.f);
+  res = res & Limit(&c->filter.shadow_initial.length_blocks, 1, 50);
+  res = res & Limit(&c->filter.shadow_initial.rate, 0.f, 1.f);
+  res = res & Limit(&c->filter.shadow_initial.noise_gate, 0.f, 100000000.f);
 
   if (c->filter.shadow.length_blocks < c->filter.shadow_initial.length_blocks) {
     c->filter.shadow_initial.length_blocks = c->filter.shadow.length_blocks;
     res = false;
   }
 
-  res = res && Limit(&c->filter.config_change_duration_blocks, 0, 100000);
-  res = res && Limit(&c->filter.initial_state_seconds, 0.f, 100.f);
+  res = res & Limit(&c->filter.config_change_duration_blocks, 0, 100000);
+  res = res & Limit(&c->filter.initial_state_seconds, 0.f, 100.f);
 
-  res = res && Limit(&c->erle.min, 1.f, 100000.f);
-  res = res && Limit(&c->erle.max_l, 1.f, 100000.f);
-  res = res && Limit(&c->erle.max_h, 1.f, 100000.f);
+  res = res & Limit(&c->erle.min, 1.f, 100000.f);
+  res = res & Limit(&c->erle.max_l, 1.f, 100000.f);
+  res = res & Limit(&c->erle.max_h, 1.f, 100000.f);
   if (c->erle.min > c->erle.max_l || c->erle.min > c->erle.max_h) {
     c->erle.min = std::min(c->erle.max_l, c->erle.max_h);
     res = false;
   }
 
-  res = res && Limit(&c->ep_strength.lf, 0.f, 1000000.f);
-  res = res && Limit(&c->ep_strength.mf, 0.f, 1000000.f);
-  res = res && Limit(&c->ep_strength.hf, 0.f, 1000000.f);
-  res = res && Limit(&c->ep_strength.default_len, 0.f, 1.f);
-
-  res = res && Limit(&c->gain_mask.m0, 0.f, 1.f);
-  res = res && Limit(&c->gain_mask.m1, 0.f, 1.f);
-  res = res && Limit(&c->gain_mask.m2, 0.f, 1.f);
-  res = res && Limit(&c->gain_mask.m3, 0.f, 1.f);
-  res = res && Limit(&c->gain_mask.m5, 0.f, 1.f);
-  res = res && Limit(&c->gain_mask.m6, 0.f, 1.f);
-  res = res && Limit(&c->gain_mask.m7, 0.f, 1.f);
-  res = res && Limit(&c->gain_mask.m8, 0.f, 1.f);
-  res = res && Limit(&c->gain_mask.m9, 0.f, 1.f);
-
-  res = res && Limit(&c->gain_mask.gain_curve_offset, 0.f, 1000.f);
-  res = res && Limit(&c->gain_mask.gain_curve_slope, 0.f, 1000.f);
-  res = res && Limit(&c->gain_mask.temporal_masking_lf, 0.f, 1000.f);
-  res = res && Limit(&c->gain_mask.temporal_masking_hf, 0.f, 1000.f);
-  res = res && Limit(&c->gain_mask.temporal_masking_lf_bands, 0, 65);
-
-  res = res &&
-        Limit(&c->echo_audibility.low_render_limit, 0.f, 32768.f * 32768.f);
-  res = res &&
-        Limit(&c->echo_audibility.normal_render_limit, 0.f, 32768.f * 32768.f);
-  res = res && Limit(&c->echo_audibility.floor_power, 0.f, 32768.f * 32768.f);
-  res = res && Limit(&c->echo_audibility.audibility_threshold_lf, 0.f,
-                     32768.f * 32768.f);
-  res = res && Limit(&c->echo_audibility.audibility_threshold_mf, 0.f,
-                     32768.f * 32768.f);
-  res = res && Limit(&c->echo_audibility.audibility_threshold_hf, 0.f,
-                     32768.f * 32768.f);
-
-  res = res &&
-        Limit(&c->render_levels.active_render_limit, 0.f, 32768.f * 32768.f);
-  res = res && Limit(&c->render_levels.poor_excitation_render_limit, 0.f,
-                     32768.f * 32768.f);
-  res = res && Limit(&c->render_levels.poor_excitation_render_limit_ds8, 0.f,
-                     32768.f * 32768.f);
+  res = res & Limit(&c->ep_strength.lf, 0.f, 1000000.f);
+  res = res & Limit(&c->ep_strength.mf, 0.f, 1000000.f);
+  res = res & Limit(&c->ep_strength.hf, 0.f, 1000000.f);
+  res = res & Limit(&c->ep_strength.default_len, 0.f, 1.f);
 
   res =
-      res && Limit(&c->echo_removal_control.gain_rampup.initial_gain, 0.f, 1.f);
-  res = res && Limit(&c->echo_removal_control.gain_rampup.first_non_zero_gain,
-                     0.f, 1.f);
-  res = res && Limit(&c->echo_removal_control.gain_rampup.non_zero_gain_blocks,
-                     0, 100000);
-  res = res &&
+      res & Limit(&c->echo_audibility.low_render_limit, 0.f, 32768.f * 32768.f);
+  res = res &
+        Limit(&c->echo_audibility.normal_render_limit, 0.f, 32768.f * 32768.f);
+  res = res & Limit(&c->echo_audibility.floor_power, 0.f, 32768.f * 32768.f);
+  res = res & Limit(&c->echo_audibility.audibility_threshold_lf, 0.f,
+                    32768.f * 32768.f);
+  res = res & Limit(&c->echo_audibility.audibility_threshold_mf, 0.f,
+                    32768.f * 32768.f);
+  res = res & Limit(&c->echo_audibility.audibility_threshold_hf, 0.f,
+                    32768.f * 32768.f);
+
+  res = res &
+        Limit(&c->render_levels.active_render_limit, 0.f, 32768.f * 32768.f);
+  res = res & Limit(&c->render_levels.poor_excitation_render_limit, 0.f,
+                    32768.f * 32768.f);
+  res = res & Limit(&c->render_levels.poor_excitation_render_limit_ds8, 0.f,
+                    32768.f * 32768.f);
+
+  res =
+      res & Limit(&c->echo_removal_control.gain_rampup.initial_gain, 0.f, 1.f);
+  res = res & Limit(&c->echo_removal_control.gain_rampup.first_non_zero_gain,
+                    0.f, 1.f);
+  res = res & Limit(&c->echo_removal_control.gain_rampup.non_zero_gain_blocks,
+                    0, 100000);
+  res = res &
         Limit(&c->echo_removal_control.gain_rampup.full_gain_blocks, 0, 100000);
 
-  res = res && Limit(&c->echo_model.noise_floor_hold, 0, 1000);
-  res = res && Limit(&c->echo_model.min_noise_floor_power, 0, 2000000.f);
-  res = res && Limit(&c->echo_model.stationary_gate_slope, 0, 1000000.f);
-  res = res && Limit(&c->echo_model.noise_gate_power, 0, 1000000.f);
-  res = res && Limit(&c->echo_model.noise_gate_slope, 0, 1000000.f);
-  res = res && Limit(&c->echo_model.render_pre_window_size, 0, 100);
-  res = res && Limit(&c->echo_model.render_post_window_size, 0, 100);
-  res = res && Limit(&c->echo_model.render_pre_window_size_init, 0, 100);
-  res = res && Limit(&c->echo_model.render_post_window_size_init, 0, 100);
-  res = res && Limit(&c->echo_model.nonlinear_hold, 0, 100);
-  res = res && Limit(&c->echo_model.nonlinear_release, 0, 1.f);
+  res = res & Limit(&c->echo_model.noise_floor_hold, 0, 1000);
+  res = res & Limit(&c->echo_model.min_noise_floor_power, 0, 2000000.f);
+  res = res & Limit(&c->echo_model.stationary_gate_slope, 0, 1000000.f);
+  res = res & Limit(&c->echo_model.noise_gate_power, 0, 1000000.f);
+  res = res & Limit(&c->echo_model.noise_gate_slope, 0, 1000000.f);
+  res = res & Limit(&c->echo_model.render_pre_window_size, 0, 100);
+  res = res & Limit(&c->echo_model.render_post_window_size, 0, 100);
+  res = res & Limit(&c->echo_model.render_pre_window_size_init, 0, 100);
+  res = res & Limit(&c->echo_model.render_post_window_size_init, 0, 100);
+  res = res & Limit(&c->echo_model.nonlinear_hold, 0, 100);
+  res = res & Limit(&c->echo_model.nonlinear_release, 0, 1.f);
 
-  res = res &&
+  res = res & Limit(&c->suppressor.nearend_average_blocks, 1, 5000);
+
+  res = res &
         Limit(&c->suppressor.normal_tuning.mask_lf.enr_transparent, 0.f, 100.f);
-  res = res &&
+  res = res &
         Limit(&c->suppressor.normal_tuning.mask_lf.enr_suppress, 0.f, 100.f);
-  res = res &&
+  res = res &
         Limit(&c->suppressor.normal_tuning.mask_lf.emr_transparent, 0.f, 100.f);
-  res = res &&
+  res = res &
         Limit(&c->suppressor.normal_tuning.mask_hf.enr_transparent, 0.f, 100.f);
-  res = res &&
+  res = res &
         Limit(&c->suppressor.normal_tuning.mask_hf.enr_suppress, 0.f, 100.f);
-  res = res &&
+  res = res &
         Limit(&c->suppressor.normal_tuning.mask_hf.emr_transparent, 0.f, 100.f);
-  res = res && Limit(&c->suppressor.normal_tuning.max_inc_factor, 0.f, 100.f);
-  res =
-      res && Limit(&c->suppressor.normal_tuning.max_dec_factor_lf, 0.f, 100.f);
+  res = res & Limit(&c->suppressor.normal_tuning.max_inc_factor, 0.f, 100.f);
+  res = res & Limit(&c->suppressor.normal_tuning.max_dec_factor_lf, 0.f, 100.f);
 
-  res = res && Limit(&c->suppressor.nearend_tuning.mask_lf.enr_transparent, 0.f,
-                     100.f);
-  res = res &&
+  res = res & Limit(&c->suppressor.nearend_tuning.mask_lf.enr_transparent, 0.f,
+                    100.f);
+  res = res &
         Limit(&c->suppressor.nearend_tuning.mask_lf.enr_suppress, 0.f, 100.f);
-  res = res && Limit(&c->suppressor.nearend_tuning.mask_lf.emr_transparent, 0.f,
-                     100.f);
-  res = res && Limit(&c->suppressor.nearend_tuning.mask_hf.enr_transparent, 0.f,
-                     100.f);
-  res = res &&
+  res = res & Limit(&c->suppressor.nearend_tuning.mask_lf.emr_transparent, 0.f,
+                    100.f);
+  res = res & Limit(&c->suppressor.nearend_tuning.mask_hf.enr_transparent, 0.f,
+                    100.f);
+  res = res &
         Limit(&c->suppressor.nearend_tuning.mask_hf.enr_suppress, 0.f, 100.f);
-  res = res && Limit(&c->suppressor.nearend_tuning.mask_hf.emr_transparent, 0.f,
-                     100.f);
-  res = res && Limit(&c->suppressor.nearend_tuning.max_inc_factor, 0.f, 100.f);
+  res = res & Limit(&c->suppressor.nearend_tuning.mask_hf.emr_transparent, 0.f,
+                    100.f);
+  res = res & Limit(&c->suppressor.nearend_tuning.max_inc_factor, 0.f, 100.f);
   res =
-      res && Limit(&c->suppressor.nearend_tuning.max_dec_factor_lf, 0.f, 100.f);
+      res & Limit(&c->suppressor.nearend_tuning.max_dec_factor_lf, 0.f, 100.f);
 
-  res = res && Limit(&c->suppressor.dominant_nearend_detection.enr_threshold,
-                     0.f, 1000000.f);
-  res = res && Limit(&c->suppressor.dominant_nearend_detection.snr_threshold,
-                     0.f, 1000000.f);
-  res = res && Limit(&c->suppressor.dominant_nearend_detection.hold_duration, 0,
-                     10000);
-  res =
-      res && Limit(&c->suppressor.dominant_nearend_detection.trigger_threshold,
-                   0, 10000);
+  res = res & Limit(&c->suppressor.dominant_nearend_detection.enr_threshold,
+                    0.f, 1000000.f);
+  res = res & Limit(&c->suppressor.dominant_nearend_detection.snr_threshold,
+                    0.f, 1000000.f);
+  res = res & Limit(&c->suppressor.dominant_nearend_detection.hold_duration, 0,
+                    10000);
+  res = res & Limit(&c->suppressor.dominant_nearend_detection.trigger_threshold,
+                    0, 10000);
 
-  res = res && Limit(&c->suppressor.high_bands_suppression.enr_threshold, 0.f,
-                     1000000.f);
-  res = res && Limit(&c->suppressor.high_bands_suppression.max_gain_during_echo,
-                     0.f, 1.f);
+  res = res & Limit(&c->suppressor.high_bands_suppression.enr_threshold, 0.f,
+                    1000000.f);
+  res = res & Limit(&c->suppressor.high_bands_suppression.max_gain_during_echo,
+                    0.f, 1.f);
 
-  res = res && Limit(&c->suppressor.floor_first_increase, 0.f, 1000000.f);
+  res = res & Limit(&c->suppressor.floor_first_increase, 0.f, 1000000.f);
 
   return res;
 }
diff --git a/api/audio/echo_canceller3_config.h b/api/audio/echo_canceller3_config.h
index 59a84ba..251f282 100644
--- a/api/audio/echo_canceller3_config.h
+++ b/api/audio/echo_canceller3_config.h
@@ -19,7 +19,7 @@
 
 // Configuration struct for EchoCanceller3
 struct RTC_EXPORT EchoCanceller3Config {
-  // Checks and updates the parameters in a config to lie within reasonable
+  // Checks and updates the config parameters to lie within (mostly) reasonable
   // ranges. Returns true if and only of the config did not need to be changed.
   static bool Validate(EchoCanceller3Config* config);
 
@@ -99,26 +99,6 @@
     bool bounded_erl = false;
   } ep_strength;
 
-  struct Mask {
-    Mask();
-    Mask(const Mask& m);
-    float m0 = 0.1f;
-    float m1 = 0.01f;
-    float m2 = 0.0001f;
-    float m3 = 0.01f;
-    float m5 = 0.01f;
-    float m6 = 0.0001f;
-    float m7 = 0.01f;
-    float m8 = 0.0001f;
-    float m9 = 0.1f;
-
-    float gain_curve_offset = 1.45f;
-    float gain_curve_slope = 5.f;
-    float temporal_masking_lf = 0.9f;
-    float temporal_masking_hf = 0.6f;
-    size_t temporal_masking_lf_bands = 3;
-  } gain_mask;
-
   struct EchoAudibility {
     float low_render_limit = 4 * 64.f;
     float normal_render_limit = 64.f;
@@ -126,8 +106,8 @@
     float audibility_threshold_lf = 10;
     float audibility_threshold_mf = 10;
     float audibility_threshold_hf = 10;
-    bool use_stationary_properties = false;
-    bool use_stationarity_properties_at_init = false;
+    bool use_stationary_properties = true;
+    bool use_stationarity_properties_at_init = true;
   } echo_audibility;
 
   struct RenderLevels {
diff --git a/api/audio/echo_canceller3_config_json.cc b/api/audio/echo_canceller3_config_json.cc
index a27f20c..d039c8b 100644
--- a/api/audio/echo_canceller3_config_json.cc
+++ b/api/audio/echo_canceller3_config_json.cc
@@ -30,6 +30,7 @@
   RTC_DCHECK(param);
   int v;
   if (rtc::GetIntFromJsonObject(root, param_name, &v)) {
+    RTC_DCHECK_GE(v, 0);
     *param = v;
   }
 }
@@ -108,21 +109,29 @@
 }
 }  // namespace
 
-EchoCanceller3Config Aec3ConfigFromJsonString(absl::string_view json_string) {
-  EchoCanceller3Config cfg;
+void Aec3ConfigFromJsonString(absl::string_view json_string,
+                              EchoCanceller3Config* config,
+                              bool* parsing_successful) {
+  RTC_DCHECK(config);
+  RTC_DCHECK(parsing_successful);
+  EchoCanceller3Config& cfg = *config;
+  cfg = EchoCanceller3Config();
+  *parsing_successful = true;
 
   Json::Value root;
   bool success = Json::Reader().parse(std::string(json_string), root);
   if (!success) {
     RTC_LOG(LS_ERROR) << "Incorrect JSON format: " << json_string;
-    return EchoCanceller3Config();
+    *parsing_successful = false;
+    return;
   }
 
   Json::Value aec3_root;
   success = rtc::GetValueFromJsonObject(root, "aec3", &aec3_root);
   if (!success) {
     RTC_LOG(LS_ERROR) << "Missing AEC3 config field: " << json_string;
-    return EchoCanceller3Config();
+    *parsing_successful = false;
+    return;
   }
 
   Json::Value section;
@@ -201,26 +210,6 @@
     ReadParam(section, "bounded_erl", &cfg.ep_strength.bounded_erl);
   }
 
-  if (rtc::GetValueFromJsonObject(aec3_root, "gain_mask", &section)) {
-    ReadParam(section, "m1", &cfg.gain_mask.m1);
-    ReadParam(section, "m2", &cfg.gain_mask.m2);
-    ReadParam(section, "m3", &cfg.gain_mask.m3);
-    ReadParam(section, "m5", &cfg.gain_mask.m5);
-    ReadParam(section, "m6", &cfg.gain_mask.m6);
-    ReadParam(section, "m7", &cfg.gain_mask.m7);
-    ReadParam(section, "m8", &cfg.gain_mask.m8);
-    ReadParam(section, "m9", &cfg.gain_mask.m9);
-
-    ReadParam(section, "gain_curve_offset", &cfg.gain_mask.gain_curve_offset);
-    ReadParam(section, "gain_curve_slope", &cfg.gain_mask.gain_curve_slope);
-    ReadParam(section, "temporal_masking_lf",
-              &cfg.gain_mask.temporal_masking_lf);
-    ReadParam(section, "temporal_masking_hf",
-              &cfg.gain_mask.temporal_masking_hf);
-    ReadParam(section, "temporal_masking_lf_bands",
-              &cfg.gain_mask.temporal_masking_lf_bands);
-  }
-
   if (rtc::GetValueFromJsonObject(aec3_root, "echo_audibility", &section)) {
     ReadParam(section, "low_render_limit",
               &cfg.echo_audibility.low_render_limit);
@@ -236,10 +225,19 @@
               &cfg.echo_audibility.audibility_threshold_hf);
     ReadParam(section, "use_stationary_properties",
               &cfg.echo_audibility.use_stationary_properties);
-    ReadParam(section, "use_stationary_properties_at_init",
+    ReadParam(section, "use_stationarity_properties_at_init",
               &cfg.echo_audibility.use_stationarity_properties_at_init);
   }
 
+  if (rtc::GetValueFromJsonObject(aec3_root, "render_levels", &section)) {
+    ReadParam(section, "active_render_limit",
+              &cfg.render_levels.active_render_limit);
+    ReadParam(section, "poor_excitation_render_limit",
+              &cfg.render_levels.poor_excitation_render_limit);
+    ReadParam(section, "poor_excitation_render_limit_ds8",
+              &cfg.render_levels.poor_excitation_render_limit_ds8);
+  }
+
   if (rtc::GetValueFromJsonObject(aec3_root, "echo_removal_control",
                                   &section)) {
     Json::Value subsection;
@@ -315,6 +313,9 @@
                 &cfg.suppressor.dominant_nearend_detection.hold_duration);
       ReadParam(subsection, "trigger_threshold",
                 &cfg.suppressor.dominant_nearend_detection.trigger_threshold);
+      ReadParam(
+          subsection, "use_during_initial_phase",
+          &cfg.suppressor.dominant_nearend_detection.use_during_initial_phase);
     }
 
     if (rtc::GetValueFromJsonObject(section, "high_bands_suppression",
@@ -332,6 +333,12 @@
     ReadParam(section, "enforce_empty_higher_bands",
               &cfg.suppressor.enforce_empty_higher_bands);
   }
+}
+
+EchoCanceller3Config Aec3ConfigFromJsonString(absl::string_view json_string) {
+  EchoCanceller3Config cfg;
+  bool not_used;
+  Aec3ConfigFromJsonString(json_string, &cfg, &not_used);
   return cfg;
 }
 
@@ -435,26 +442,6 @@
 
   ost << "},";
 
-  ost << "\"gain_mask\": {";
-  ost << "\"m0\": " << config.gain_mask.m0 << ",";
-  ost << "\"m1\": " << config.gain_mask.m1 << ",";
-  ost << "\"m2\": " << config.gain_mask.m2 << ",";
-  ost << "\"m3\": " << config.gain_mask.m3 << ",";
-  ost << "\"m5\": " << config.gain_mask.m5 << ",";
-  ost << "\"m6\": " << config.gain_mask.m6 << ",";
-  ost << "\"m7\": " << config.gain_mask.m7 << ",";
-  ost << "\"m8\": " << config.gain_mask.m8 << ",";
-  ost << "\"m9\": " << config.gain_mask.m9 << ",";
-  ost << "\"gain_curve_offset\": " << config.gain_mask.gain_curve_offset << ",";
-  ost << "\"gain_curve_slope\": " << config.gain_mask.gain_curve_slope << ",";
-  ost << "\"temporal_masking_lf\": " << config.gain_mask.temporal_masking_lf
-      << ",";
-  ost << "\"temporal_masking_hf\": " << config.gain_mask.temporal_masking_hf
-      << ",";
-  ost << "\"temporal_masking_lf_bands\": "
-      << config.gain_mask.temporal_masking_lf_bands;
-  ost << "},";
-
   ost << "\"echo_audibility\": {";
   ost << "\"low_render_limit\": " << config.echo_audibility.low_render_limit
       << ",";
@@ -569,7 +556,9 @@
   ost << "\"hold_duration\": "
       << config.suppressor.dominant_nearend_detection.hold_duration << ",";
   ost << "\"trigger_threshold\": "
-      << config.suppressor.dominant_nearend_detection.trigger_threshold;
+      << config.suppressor.dominant_nearend_detection.trigger_threshold << ",";
+  ost << "\"use_during_initial_phase\": "
+      << config.suppressor.dominant_nearend_detection.use_during_initial_phase;
   ost << "},";
   ost << "\"high_bands_suppression\": {";
   ost << "\"enr_threshold\": "
diff --git a/api/audio/echo_canceller3_config_json.h b/api/audio/echo_canceller3_config_json.h
index b315bf0..8973650 100644
--- a/api/audio/echo_canceller3_config_json.h
+++ b/api/audio/echo_canceller3_config_json.h
@@ -15,13 +15,25 @@
 
 #include "absl/strings/string_view.h"
 #include "api/audio/echo_canceller3_config.h"
+#include "rtc_base/system/rtc_export.h"
 
 namespace webrtc {
 // Parses a JSON-encoded string into an Aec3 config. Fields corresponds to
 // substruct names, with the addition that there must be a top-level node
+// "aec3". Produces default config values for anything that cannot be parsed
+// from the string. If any error was found in the parsing, parsing_successful is
+// set to false.
+RTC_EXPORT void Aec3ConfigFromJsonString(absl::string_view json_string,
+                                         EchoCanceller3Config* config,
+                                         bool* parsing_successful);
+
+// To be deprecated.
+// Parses a JSON-encoded string into an Aec3 config. Fields corresponds to
+// substruct names, with the addition that there must be a top-level node
 // "aec3". Returns default config values for anything that cannot be parsed from
 // the string.
-EchoCanceller3Config Aec3ConfigFromJsonString(absl::string_view json_string);
+RTC_EXPORT EchoCanceller3Config
+Aec3ConfigFromJsonString(absl::string_view json_string);
 
 // Encodes an Aec3 config in JSON format. Fields corresponds to substruct names,
 // with the addition that the top-level node is named "aec3".
diff --git a/api/audio_options.cc b/api/audio_options.cc
index a4a37d2..d464118 100644
--- a/api/audio_options.cc
+++ b/api/audio_options.cc
@@ -50,7 +50,6 @@
   SetFrom(&audio_jitter_buffer_fast_accelerate,
           change.audio_jitter_buffer_fast_accelerate);
   SetFrom(&typing_detection, change.typing_detection);
-  SetFrom(&aecm_generate_comfort_noise, change.aecm_generate_comfort_noise);
   SetFrom(&experimental_agc, change.experimental_agc);
   SetFrom(&extended_filter_aec, change.extended_filter_aec);
   SetFrom(&delay_agnostic_aec, change.delay_agnostic_aec);
@@ -78,7 +77,6 @@
          audio_jitter_buffer_fast_accelerate ==
              o.audio_jitter_buffer_fast_accelerate &&
          typing_detection == o.typing_detection &&
-         aecm_generate_comfort_noise == o.aecm_generate_comfort_noise &&
          experimental_agc == o.experimental_agc &&
          extended_filter_aec == o.extended_filter_aec &&
          delay_agnostic_aec == o.delay_agnostic_aec &&
@@ -110,7 +108,6 @@
   ToStringIfSet(&result, "audio_jitter_buffer_fast_accelerate",
                 audio_jitter_buffer_fast_accelerate);
   ToStringIfSet(&result, "typing", typing_detection);
-  ToStringIfSet(&result, "comfort_noise", aecm_generate_comfort_noise);
   ToStringIfSet(&result, "experimental_agc", experimental_agc);
   ToStringIfSet(&result, "extended_filter_aec", extended_filter_aec);
   ToStringIfSet(&result, "delay_agnostic_aec", delay_agnostic_aec);
diff --git a/api/audio_options.h b/api/audio_options.h
index aecff41..8ae8319 100644
--- a/api/audio_options.h
+++ b/api/audio_options.h
@@ -11,6 +11,7 @@
 #ifndef API_AUDIO_OPTIONS_H_
 #define API_AUDIO_OPTIONS_H_
 
+#include <stdint.h>
 #include <string>
 
 #include "absl/types/optional.h"
@@ -55,7 +56,6 @@
   absl::optional<bool> audio_jitter_buffer_fast_accelerate;
   // Audio processing to detect typing.
   absl::optional<bool> typing_detection;
-  absl::optional<bool> aecm_generate_comfort_noise;
   absl::optional<bool> experimental_agc;
   absl::optional<bool> extended_filter_aec;
   absl::optional<bool> delay_agnostic_aec;
diff --git a/api/candidate.cc b/api/candidate.cc
index 10751ae..275b173 100644
--- a/api/candidate.cc
+++ b/api/candidate.cc
@@ -11,6 +11,7 @@
 #include "api/candidate.h"
 
 #include "rtc_base/helpers.h"
+#include "rtc_base/ipaddress.h"
 #include "rtc_base/strings/string_builder.h"
 
 namespace cricket {
diff --git a/api/candidate.h b/api/candidate.h
index 0a84591..4c650d9 100644
--- a/api/candidate.h
+++ b/api/candidate.h
@@ -20,13 +20,14 @@
 #include "rtc_base/checks.h"
 #include "rtc_base/network_constants.h"
 #include "rtc_base/socketaddress.h"
+#include "rtc_base/system/rtc_export.h"
 
 namespace cricket {
 
 // Candidate for ICE based connection discovery.
 // TODO(phoglund): remove things in here that are not needed in the public API.
 
-class Candidate {
+class RTC_EXPORT Candidate {
  public:
   Candidate();
   // TODO(pthatcher): Match the ordering and param list as per RFC 5245
diff --git a/api/cryptoparams.h b/api/cryptoparams.h
index 2350528..abe9055 100644
--- a/api/cryptoparams.h
+++ b/api/cryptoparams.h
@@ -16,6 +16,8 @@
 namespace cricket {
 
 // Parameters for SRTP negotiation, as described in RFC 4568.
+// TODO(benwright) - Rename to SrtpCryptoParams as these only apply to SRTP and
+// not generic crypto parameters for WebRTC.
 struct CryptoParams {
   CryptoParams() : tag(0) {}
   CryptoParams(int t,
diff --git a/api/datachannelinterface.h b/api/datachannelinterface.h
index a0d2b3b..7cb5582 100644
--- a/api/datachannelinterface.h
+++ b/api/datachannelinterface.h
@@ -14,6 +14,8 @@
 #ifndef API_DATACHANNELINTERFACE_H_
 #define API_DATACHANNELINTERFACE_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <string>
 
 #include "rtc_base/checks.h"
diff --git a/api/jsep.cc b/api/jsep.cc
index 52a60f9..01f5720 100644
--- a/api/jsep.cc
+++ b/api/jsep.cc
@@ -38,4 +38,32 @@
   OnFailure(RTCError(RTCErrorType::INTERNAL_ERROR, std::string(error)));
 }
 
+const char SessionDescriptionInterface::kOffer[] = "offer";
+const char SessionDescriptionInterface::kPrAnswer[] = "pranswer";
+const char SessionDescriptionInterface::kAnswer[] = "answer";
+
+const char* SdpTypeToString(SdpType type) {
+  switch (type) {
+    case SdpType::kOffer:
+      return SessionDescriptionInterface::kOffer;
+    case SdpType::kPrAnswer:
+      return SessionDescriptionInterface::kPrAnswer;
+    case SdpType::kAnswer:
+      return SessionDescriptionInterface::kAnswer;
+  }
+  return "";
+}
+
+absl::optional<SdpType> SdpTypeFromString(const std::string& type_str) {
+  if (type_str == SessionDescriptionInterface::kOffer) {
+    return SdpType::kOffer;
+  } else if (type_str == SessionDescriptionInterface::kPrAnswer) {
+    return SdpType::kPrAnswer;
+  } else if (type_str == SessionDescriptionInterface::kAnswer) {
+    return SdpType::kAnswer;
+  } else {
+    return absl::nullopt;
+  }
+}
+
 }  // namespace webrtc
diff --git a/api/jsep.h b/api/jsep.h
index 4d4bcc0..1c50455 100644
--- a/api/jsep.h
+++ b/api/jsep.h
@@ -29,6 +29,7 @@
 #include "absl/types/optional.h"
 #include "api/rtcerror.h"
 #include "rtc_base/refcount.h"
+#include "rtc_base/system/rtc_export.h"
 
 namespace cricket {
 class Candidate;
@@ -73,13 +74,13 @@
 // Creates a IceCandidateInterface based on SDP string.
 // Returns null if the sdp string can't be parsed.
 // |error| may be null.
-IceCandidateInterface* CreateIceCandidate(const std::string& sdp_mid,
-                                          int sdp_mline_index,
-                                          const std::string& sdp,
-                                          SdpParseError* error);
+RTC_EXPORT IceCandidateInterface* CreateIceCandidate(const std::string& sdp_mid,
+                                                     int sdp_mline_index,
+                                                     const std::string& sdp,
+                                                     SdpParseError* error);
 
 // Creates an IceCandidateInterface based on a parsed candidate structure.
-std::unique_ptr<IceCandidateInterface> CreateIceCandidate(
+RTC_EXPORT std::unique_ptr<IceCandidateInterface> CreateIceCandidate(
     const std::string& sdp_mid,
     int sdp_mline_index,
     const cricket::Candidate& candidate);
@@ -121,7 +122,7 @@
 // and is therefore not expected to be thread safe.
 //
 // An instance can be created by CreateSessionDescription.
-class SessionDescriptionInterface {
+class RTC_EXPORT SessionDescriptionInterface {
  public:
   // String representations of the supported SDP types.
   static const char kOffer[];
@@ -181,21 +182,21 @@
 // |error| may be null.
 // TODO(steveanton): This function is deprecated. Please use the functions below
 // which take an SdpType enum instead. Remove this once it is no longer used.
-SessionDescriptionInterface* CreateSessionDescription(const std::string& type,
-                                                      const std::string& sdp,
-                                                      SdpParseError* error);
+RTC_EXPORT SessionDescriptionInterface* CreateSessionDescription(
+    const std::string& type,
+    const std::string& sdp,
+    SdpParseError* error);
 
 // Creates a SessionDescriptionInterface based on the SDP string and the type.
 // Returns null if the SDP string cannot be parsed.
 // If using the signature with |error_out|, details of the parsing error may be
 // written to |error_out| if it is not null.
-std::unique_ptr<SessionDescriptionInterface> CreateSessionDescription(
-    SdpType type,
-    const std::string& sdp);
-std::unique_ptr<SessionDescriptionInterface> CreateSessionDescription(
-    SdpType type,
-    const std::string& sdp,
-    SdpParseError* error_out);
+RTC_EXPORT std::unique_ptr<SessionDescriptionInterface>
+CreateSessionDescription(SdpType type, const std::string& sdp);
+RTC_EXPORT std::unique_ptr<SessionDescriptionInterface>
+CreateSessionDescription(SdpType type,
+                         const std::string& sdp,
+                         SdpParseError* error_out);
 
 // Creates a SessionDescriptionInterface based on a parsed SDP structure and the
 // given type, ID and version.
@@ -206,7 +207,8 @@
     std::unique_ptr<cricket::SessionDescription> description);
 
 // CreateOffer and CreateAnswer callback interface.
-class CreateSessionDescriptionObserver : public rtc::RefCountInterface {
+class RTC_EXPORT CreateSessionDescriptionObserver
+    : public rtc::RefCountInterface {
  public:
   // This callback transfers the ownership of the |desc|.
   // TODO(deadbeef): Make this take an std::unique_ptr<> to avoid confusion
@@ -227,7 +229,7 @@
 };
 
 // SetLocalDescription and SetRemoteDescription callback interface.
-class SetSessionDescriptionObserver : public rtc::RefCountInterface {
+class RTC_EXPORT SetSessionDescriptionObserver : public rtc::RefCountInterface {
  public:
   virtual void OnSuccess() = 0;
   // See description in CreateSessionDescriptionObserver for OnFailure.
diff --git a/api/jsepicecandidate.cc b/api/jsepicecandidate.cc
index b9ba2fe..ed2f792 100644
--- a/api/jsepicecandidate.cc
+++ b/api/jsepicecandidate.cc
@@ -10,6 +10,9 @@
 
 #include "api/jsepicecandidate.h"
 
+#include <algorithm>
+#include <utility>
+
 namespace webrtc {
 
 std::string JsepIceCandidate::sdp_mid() const {
diff --git a/api/jsepicecandidate.h b/api/jsepicecandidate.h
index a57f861..9cc7443 100644
--- a/api/jsepicecandidate.h
+++ b/api/jsepicecandidate.h
@@ -14,6 +14,7 @@
 #ifndef API_JSEPICECANDIDATE_H_
 #define API_JSEPICECANDIDATE_H_
 
+#include <stddef.h>
 #include <string>
 #include <vector>
 
diff --git a/api/media_transport_interface.cc b/api/media_transport_interface.cc
index fc97b0b..039a4a1 100644
--- a/api/media_transport_interface.cc
+++ b/api/media_transport_interface.cc
@@ -17,8 +17,18 @@
 
 #include "api/media_transport_interface.h"
 
+#include <cstdint>
+#include <utility>
+
 namespace webrtc {
 
+MediaTransportSettings::MediaTransportSettings() = default;
+MediaTransportSettings::MediaTransportSettings(const MediaTransportSettings&) =
+    default;
+MediaTransportSettings& MediaTransportSettings::operator=(
+    const MediaTransportSettings&) = default;
+MediaTransportSettings::~MediaTransportSettings() = default;
+
 MediaTransportEncodedAudioFrame::~MediaTransportEncodedAudioFrame() {}
 
 MediaTransportEncodedAudioFrame::MediaTransportEncodedAudioFrame(
@@ -73,4 +83,45 @@
 MediaTransportEncodedVideoFrame::MediaTransportEncodedVideoFrame(
     MediaTransportEncodedVideoFrame&&) = default;
 
+SendDataParams::SendDataParams() = default;
+
+RTCErrorOr<std::unique_ptr<MediaTransportInterface>>
+MediaTransportFactory::CreateMediaTransport(
+    rtc::PacketTransportInternal* packet_transport,
+    rtc::Thread* network_thread,
+    bool is_caller) {
+  MediaTransportSettings settings;
+  settings.is_caller = is_caller;
+  return CreateMediaTransport(packet_transport, network_thread, settings);
+}
+
+RTCErrorOr<std::unique_ptr<MediaTransportInterface>>
+MediaTransportFactory::CreateMediaTransport(
+    rtc::PacketTransportInternal* packet_transport,
+    rtc::Thread* network_thread,
+    const MediaTransportSettings& settings) {
+  return std::unique_ptr<MediaTransportInterface>(nullptr);
+}
+
+absl::optional<TargetTransferRate>
+MediaTransportInterface::GetLatestTargetTransferRate() {
+  return absl::nullopt;
+}
+
+void MediaTransportInterface::SetNetworkChangeCallback(
+    MediaTransportNetworkChangeCallback* callback) {}
+
+void MediaTransportInterface::RemoveTargetTransferRateObserver(
+    webrtc::TargetTransferRateObserver* observer) {}
+
+void MediaTransportInterface::SetTargetTransferRateObserver(
+    webrtc::TargetTransferRateObserver* observer) {}
+
+void MediaTransportInterface::AddTargetTransferRateObserver(
+    webrtc::TargetTransferRateObserver* observer) {}
+
+size_t MediaTransportInterface::GetAudioPacketOverhead() const {
+  return 0;
+}
+
 }  // namespace webrtc
diff --git a/api/media_transport_interface.h b/api/media_transport_interface.h
index 33fa2ad..7570160 100644
--- a/api/media_transport_interface.h
+++ b/api/media_transport_interface.h
@@ -17,13 +17,19 @@
 #ifndef API_MEDIA_TRANSPORT_INTERFACE_H_
 #define API_MEDIA_TRANSPORT_INTERFACE_H_
 
+#include <api/transport/network_control.h>
 #include <memory>
+#include <string>
 #include <utility>
 #include <vector>
 
+#include "absl/types/optional.h"
+#include "api/array_view.h"
 #include "api/rtcerror.h"
 #include "api/video/encoded_image.h"
 #include "common_types.h"  // NOLINT(build/include)
+#include "rtc_base/copyonwritebuffer.h"
+#include "rtc_base/networkroute.h"
 
 namespace rtc {
 class PacketTransportInternal;
@@ -32,6 +38,23 @@
 
 namespace webrtc {
 
+// A collection of settings for creation of media transport.
+struct MediaTransportSettings final {
+  MediaTransportSettings();
+  MediaTransportSettings(const MediaTransportSettings&);
+  MediaTransportSettings& operator=(const MediaTransportSettings&);
+  ~MediaTransportSettings();
+
+  // Group calls are not currently supported, in 1:1 call one side must set
+  // is_caller = true and another is_caller = false.
+  bool is_caller;
+
+  // Must be set if a pre-shared key is used for the call.
+  // TODO(bugs.webrtc.org/9944): This should become zero buffer in the distant
+  // future.
+  absl::optional<std::string> pre_shared_key;
+};
+
 // Represents encoded audio frame in any encoding (type of encoding is opaque).
 // To avoid copying of encoded data use move semantics when passing by value.
 class MediaTransportEncodedAudioFrame final {
@@ -41,7 +64,10 @@
     kSpeech,
 
     // DTX frame (equivalent to webrtc::kAudioFrameCN).
-    kDiscountinuousTransmission,
+    // DTX frame (equivalent to webrtc::kAudioFrameCN).
+    kDiscontinuousTransmission,
+    // TODO(nisse): Mis-spelled version, update users, then delete.
+    kDiscountinuousTransmission = kDiscontinuousTransmission,
   };
 
   MediaTransportEncodedAudioFrame(
@@ -114,6 +140,16 @@
   std::vector<uint8_t> encoded_data_;
 };
 
+// Callback to notify about network route changes.
+class MediaTransportNetworkChangeCallback {
+ public:
+  virtual ~MediaTransportNetworkChangeCallback() = default;
+
+  // Called when the network route is changed, with the new network route.
+  virtual void OnNetworkRouteChanged(
+      const rtc::NetworkRoute& new_network_route) = 0;
+};
+
 // Interface for receiving encoded audio frames from MediaTransportInterface
 // implementations.
 class MediaTransportAudioSinkInterface {
@@ -187,6 +223,85 @@
   virtual void OnKeyFrameRequested(uint64_t channel_id) = 0;
 };
 
+// State of the media transport.  Media transport begins in the pending state.
+// It transitions to writable when it is ready to send media.  It may transition
+// back to pending if the connection is blocked.  It may transition to closed at
+// any time.  Closed is terminal: a transport will never re-open once closed.
+enum class MediaTransportState {
+  kPending,
+  kWritable,
+  kClosed,
+};
+
+// Callback invoked whenever the state of the media transport changes.
+class MediaTransportStateCallback {
+ public:
+  virtual ~MediaTransportStateCallback() = default;
+
+  // Invoked whenever the state of the media transport changes.
+  virtual void OnStateChanged(MediaTransportState state) = 0;
+};
+
+// Supported types of application data messages.
+enum class DataMessageType {
+  // Application data buffer with the binary bit unset.
+  kText,
+
+  // Application data buffer with the binary bit set.
+  kBinary,
+
+  // Transport-agnostic control messages, such as open or open-ack messages.
+  kControl,
+};
+
+// Parameters for sending data.  The parameters may change from message to
+// message, even within a single channel.  For example, control messages may be
+// sent reliably and in-order, even if the data channel is configured for
+// unreliable delivery.
+struct SendDataParams {
+  SendDataParams();
+
+  DataMessageType type = DataMessageType::kText;
+
+  // Whether to deliver the message in order with respect to other ordered
+  // messages with the same channel_id.
+  bool ordered = false;
+
+  // If set, the maximum number of times this message may be
+  // retransmitted by the transport before it is dropped.
+  // Setting this value to zero disables retransmission.
+  // Must be non-negative. |max_rtx_count| and |max_rtx_ms| may not be set
+  // simultaneously.
+  absl::optional<int> max_rtx_count;
+
+  // If set, the maximum number of milliseconds for which the transport
+  // may retransmit this message before it is dropped.
+  // Setting this value to zero disables retransmission.
+  // Must be non-negative. |max_rtx_count| and |max_rtx_ms| may not be set
+  // simultaneously.
+  absl::optional<int> max_rtx_ms;
+};
+
+// Sink for callbacks related to a data channel.
+class DataChannelSink {
+ public:
+  virtual ~DataChannelSink() = default;
+
+  // Callback issued when data is received by the transport.
+  virtual void OnDataReceived(int channel_id,
+                              DataMessageType type,
+                              const rtc::CopyOnWriteBuffer& buffer) = 0;
+
+  // Callback issued when a remote data channel begins the closing procedure.
+  // Messages sent after the closing procedure begins will not be transmitted.
+  virtual void OnChannelClosing(int channel_id) = 0;
+
+  // Callback issued when a (remote or local) data channel completes the closing
+  // procedure.  Closing channels become closed after all pending data has been
+  // transmitted.
+  virtual void OnChannelClosed(int channel_id) = 0;
+};
+
 // Media transport interface for sending / receiving encoded audio/video frames
 // and receiving bandwidth estimate update from congestion control.
 class MediaTransportInterface {
@@ -221,8 +336,71 @@
   // pass a nullptr.
   virtual void SetReceiveVideoSink(MediaTransportVideoSinkInterface* sink) = 0;
 
+  // Sets a target bitrate observer. Before media transport is destructed
+  // the observer must be unregistered (set to nullptr).
+  // A newly registered observer will be called back with the latest recorded
+  // target rate, if available.
+  // TODO(psla): This method will be removed, in favor of
+  // AddTargetTransferRateObserver.
+  virtual void SetTargetTransferRateObserver(
+      TargetTransferRateObserver* observer);
+
+  // Adds a target bitrate observer. Before media transport is destructed
+  // the observer must be unregistered (by calling
+  // RemoveTargetTransferRateObserver).
+  // A newly registered observer will be called back with the latest recorded
+  // target rate, if available.
+  virtual void AddTargetTransferRateObserver(
+      webrtc::TargetTransferRateObserver* observer);
+
+  // Removes an existing |observer| from observers. If observer was never
+  // registered, an error is logged and method does nothing.
+  virtual void RemoveTargetTransferRateObserver(
+      webrtc::TargetTransferRateObserver* observer);
+
+  // Returns the last known target transfer rate as reported to the above
+  // observers.
+  virtual absl::optional<TargetTransferRate> GetLatestTargetTransferRate();
+
+  // Gets the audio packet overhead in bytes. Returned overhead does not include
+  // transport overhead (ipv4/6, turn channeldata, tcp/udp, etc.).
+  // If the transport is capable of fusing packets together, this overhead
+  // might not be a very accurate number.
+  virtual size_t GetAudioPacketOverhead() const;
+
+  // Sets an observer for network change events. If the network route is already
+  // established when the callback is set, |callback| will be called immediately
+  // with the current network route.
+  // Before media transport is destroyed, the callback must be unregistered by
+  // setting it to nullptr.
+  virtual void SetNetworkChangeCallback(
+      MediaTransportNetworkChangeCallback* callback);
+
+  // Sets a state observer callback. Before media transport is destroyed, the
+  // callback must be unregistered by setting it to nullptr.
+  // A newly registered callback will be called with the current state.
+  // Media transport does not invoke this callback concurrently.
+  virtual void SetMediaTransportStateCallback(
+      MediaTransportStateCallback* callback) = 0;
+
+  // Sends a data buffer to the remote endpoint using the given send parameters.
+  // |buffer| may not be larger than 256 KiB. Returns an error if the send
+  // fails.
+  virtual RTCError SendData(int channel_id,
+                            const SendDataParams& params,
+                            const rtc::CopyOnWriteBuffer& buffer) = 0;
+
+  // Closes |channel_id| gracefully.  Returns an error if |channel_id| is not
+  // open.  Data sent after the closing procedure begins will not be
+  // transmitted. The channel becomes closed after pending data is transmitted.
+  virtual RTCError CloseChannel(int channel_id) = 0;
+
+  // Sets a sink for data messages and channel state callbacks. Before media
+  // transport is destroyed, the sink must be unregistered by setting it to
+  // nullptr.
+  virtual void SetDataSink(DataChannelSink* sink) = 0;
+
   // TODO(sukhanov): RtcEventLogs.
-  // TODO(sukhanov): Bandwidth updates.
 };
 
 // If media transport factory is set in peer connection factory, it will be
@@ -240,10 +418,21 @@
   // - Does not take ownership of packet_transport or network_thread.
   // - Does not support group calls, in 1:1 call one side must set
   //   is_caller = true and another is_caller = false.
+  // TODO(bugs.webrtc.org/9938) This constructor will be removed and replaced
+  // with the one below.
   virtual RTCErrorOr<std::unique_ptr<MediaTransportInterface>>
   CreateMediaTransport(rtc::PacketTransportInternal* packet_transport,
                        rtc::Thread* network_thread,
-                       bool is_caller) = 0;
+                       bool is_caller);
+
+  // Creates media transport.
+  // - Does not take ownership of packet_transport or network_thread.
+  // TODO(bugs.webrtc.org/9938): remove default implementation once all children
+  // override it.
+  virtual RTCErrorOr<std::unique_ptr<MediaTransportInterface>>
+  CreateMediaTransport(rtc::PacketTransportInternal* packet_transport,
+                       rtc::Thread* network_thread,
+                       const MediaTransportSettings& settings);
 };
 
 }  // namespace webrtc
diff --git a/api/mediaconstraintsinterface.cc b/api/mediaconstraintsinterface.cc
index 5567786..b66ba05 100644
--- a/api/mediaconstraintsinterface.cc
+++ b/api/mediaconstraintsinterface.cc
@@ -10,7 +10,9 @@
 
 #include "api/mediaconstraintsinterface.h"
 
+#include "absl/types/optional.h"
 #include "api/peerconnectioninterface.h"
+#include "media/base/mediaconfig.h"
 #include "rtc_base/stringencode.h"
 
 namespace {
diff --git a/api/mediaconstraintsinterface.h b/api/mediaconstraintsinterface.h
index 560fa4a..c9a6e1b 100644
--- a/api/mediaconstraintsinterface.h
+++ b/api/mediaconstraintsinterface.h
@@ -21,9 +21,11 @@
 #ifndef API_MEDIACONSTRAINTSINTERFACE_H_
 #define API_MEDIACONSTRAINTSINTERFACE_H_
 
+#include <stddef.h>
 #include <string>
 #include <vector>
 
+#include "api/audio_options.h"
 #include "api/peerconnectioninterface.h"
 
 namespace webrtc {
diff --git a/api/mediastreaminterface.cc b/api/mediastreaminterface.cc
index 6f08a0c..e36d5cb 100644
--- a/api/mediastreaminterface.cc
+++ b/api/mediastreaminterface.cc
@@ -17,34 +17,6 @@
 const char MediaStreamTrackInterface::kVideoKind[] = "video";
 const char MediaStreamTrackInterface::kAudioKind[] = "audio";
 
-void AudioProcessorInterface::GetStats(AudioProcessorStats* /*stats*/) {
-  RTC_NOTREACHED() << "Old-style GetStats() is called but it has no "
-                   << "implementation.";
-  RTC_LOG(LS_ERROR) << "Old-style GetStats() is called but it has no "
-                    << "implementation.";
-}
-
-// TODO(ivoc): Remove this when the function becomes pure virtual.
-AudioProcessorInterface::AudioProcessorStatistics
-AudioProcessorInterface::GetStats(bool /*has_remote_tracks*/) {
-  AudioProcessorStats stats;
-  GetStats(&stats);
-  AudioProcessorStatistics new_stats;
-  new_stats.apm_statistics.divergent_filter_fraction =
-      stats.aec_divergent_filter_fraction;
-  new_stats.apm_statistics.delay_median_ms = stats.echo_delay_median_ms;
-  new_stats.apm_statistics.delay_standard_deviation_ms =
-      stats.echo_delay_std_ms;
-  new_stats.apm_statistics.echo_return_loss = stats.echo_return_loss;
-  new_stats.apm_statistics.echo_return_loss_enhancement =
-      stats.echo_return_loss_enhancement;
-  new_stats.apm_statistics.residual_echo_likelihood =
-      stats.residual_echo_likelihood;
-  new_stats.apm_statistics.residual_echo_likelihood_recent_max =
-      stats.residual_echo_likelihood_recent_max;
-  return new_stats;
-}
-
 VideoTrackInterface::ContentHint VideoTrackInterface::content_hint() const {
   return ContentHint::kNone;
 }
diff --git a/api/mediastreaminterface.h b/api/mediastreaminterface.h
index 2eb2f31..30f8f71 100644
--- a/api/mediastreaminterface.h
+++ b/api/mediastreaminterface.h
@@ -213,47 +213,17 @@
 // statistics.
 class AudioProcessorInterface : public rtc::RefCountInterface {
  public:
-  // Deprecated, use AudioProcessorStatistics instead.
-  // TODO(ivoc): Remove this when all implementations have switched to the new
-  //             GetStats function. See b/67926135.
-  struct AudioProcessorStats {
-    AudioProcessorStats()
-        : typing_noise_detected(false),
-          echo_return_loss(0),
-          echo_return_loss_enhancement(0),
-          echo_delay_median_ms(0),
-          echo_delay_std_ms(0),
-          residual_echo_likelihood(0.0f),
-          residual_echo_likelihood_recent_max(0.0f),
-          aec_divergent_filter_fraction(0.0) {}
-    ~AudioProcessorStats() {}
-
-    bool typing_noise_detected;
-    int echo_return_loss;
-    int echo_return_loss_enhancement;
-    int echo_delay_median_ms;
-    int echo_delay_std_ms;
-    float residual_echo_likelihood;
-    float residual_echo_likelihood_recent_max;
-    float aec_divergent_filter_fraction;
-  };
-  // This struct maintains the optionality of the stats, and will replace the
-  // regular stats struct when all users have been updated.
   struct AudioProcessorStatistics {
     bool typing_noise_detected = false;
     AudioProcessingStats apm_statistics;
   };
 
-  // Get audio processor statistics.
-  virtual void GetStats(AudioProcessorStats* stats);
-
   // Get audio processor statistics. The |has_remote_tracks| argument should be
   // set if there are active remote tracks (this would usually be true during
   // a call). If there are no remote tracks some of the stats will not be set by
   // the AudioProcessor, because they only make sense if there is at least one
   // remote track.
-  // TODO(ivoc): Make pure virtual when all implementions are updated.
-  virtual AudioProcessorStatistics GetStats(bool has_remote_tracks);
+  virtual AudioProcessorStatistics GetStats(bool has_remote_tracks) = 0;
 
  protected:
   ~AudioProcessorInterface() override = default;
diff --git a/api/peerconnectioninterface.cc b/api/peerconnectioninterface.cc
index b4148d7..f2953b5 100644
--- a/api/peerconnectioninterface.cc
+++ b/api/peerconnectioninterface.cc
@@ -159,6 +159,11 @@
   return SetBitrate(bitrate);
 }
 
+PeerConnectionInterface::PeerConnectionState
+PeerConnectionInterface::peer_connection_state() {
+  return PeerConnectionInterface::PeerConnectionState::kNew;
+}
+
 bool PeerConnectionInterface::StartRtcEventLog(rtc::PlatformFile file,
                                                int64_t max_size_bytes) {
   return false;
diff --git a/api/peerconnectioninterface.h b/api/peerconnectioninterface.h
index 3d8a9c1..80c3091 100644
--- a/api/peerconnectioninterface.h
+++ b/api/peerconnectioninterface.h
@@ -77,6 +77,7 @@
 #include "api/audio_codecs/audio_encoder_factory.h"
 #include "api/audio_options.h"
 #include "api/call/callfactoryinterface.h"
+#include "api/crypto/cryptooptions.h"
 #include "api/datachannelinterface.h"
 #include "api/fec_controller.h"
 #include "api/jsep.h"
@@ -112,6 +113,7 @@
 #include "rtc_base/socketaddress.h"
 #include "rtc_base/sslcertificate.h"
 #include "rtc_base/sslstreamadapter.h"
+#include "rtc_base/system/rtc_export.h"
 
 namespace rtc {
 class SSLIdentity;
@@ -158,7 +160,7 @@
 
 class PeerConnectionInterface : public rtc::RefCountInterface {
  public:
-  // See https://w3c.github.io/webrtc-pc/#state-definitions
+  // See https://w3c.github.io/webrtc-pc/#dom-rtcsignalingstate
   enum SignalingState {
     kStable,
     kHaveLocalOffer,
@@ -168,12 +170,24 @@
     kClosed,
   };
 
+  // See https://w3c.github.io/webrtc-pc/#dom-rtcicegatheringstate
   enum IceGatheringState {
     kIceGatheringNew,
     kIceGatheringGathering,
     kIceGatheringComplete
   };
 
+  // See https://w3c.github.io/webrtc-pc/#dom-rtcpeerconnectionstate
+  enum class PeerConnectionState {
+    kNew,
+    kConnecting,
+    kConnected,
+    kDisconnected,
+    kFailed,
+    kClosed,
+  };
+
+  // See https://w3c.github.io/webrtc-pc/#dom-rtciceconnectionstate
   enum IceConnectionState {
     kIceConnectionNew,
     kIceConnectionChecking,
@@ -280,7 +294,7 @@
   // organization of the implementation, which isn't stable. So we
   // need getters and setters at least for fields which applications
   // are interested in.
-  struct RTCConfiguration {
+  struct RTC_EXPORT RTCConfiguration {
     // This struct is subject to reorganization, both for naming
     // consistency, and to group settings to match where they are used
     // in the implementation. To do that, we need getter and setter
@@ -392,6 +406,7 @@
     // Use new combined audio/video bandwidth estimation?
     absl::optional<bool> combined_audio_video_bwe;
 
+    // TODO(bugs.webrtc.org/9891) - Move to crypto_options
     // Can be used to disable DTLS-SRTP. This should never be done, but can be
     // useful for testing purposes, for example in setting up a loopback call
     // with a single PeerConnection.
@@ -554,6 +569,7 @@
     // For all other users, specify kUnifiedPlan.
     SdpSemantics sdp_semantics = SdpSemantics::kPlanB;
 
+    // TODO(bugs.webrtc.org/9891) - Move to crypto_options or remove.
     // Actively reset the SRTP parameters whenever the DTLS transports
     // underneath are reset for every offer/answer negotiation.
     // This is only intended to be a workaround for crbug.com/835958
@@ -567,6 +583,20 @@
     // provided.
     bool use_media_transport = false;
 
+    // If MediaTransportFactory is provided in PeerConnectionFactory, this flag
+    // informs PeerConnection that it should use the MediaTransportInterface for
+    // data channels.  It's invalid to set it to |true| if the
+    // MediaTransportFactory wasn't provided.  Data channels over media
+    // transport are not compatible with RTP or SCTP data channels.  Setting
+    // both |use_media_transport_for_data_channels| and
+    // |enable_rtp_data_channel| is invalid.
+    bool use_media_transport_for_data_channels = false;
+
+    // Defines advanced optional cryptographic settings related to SRTP and
+    // frame encryption for native WebRTC. Setting this will overwrite any
+    // settings set in PeerConnectionFactory (which is deprecated).
+    absl::optional<CryptoOptions> crypto_options;
+
     //
     // Don't forget to update operator== if adding something.
     //
@@ -976,11 +1006,13 @@
   virtual SignalingState signaling_state() = 0;
 
   // Returns the aggregate state of all ICE *and* DTLS transports.
-  // TODO(deadbeef): Implement "PeerConnectionState" according to the standard,
-  // to aggregate ICE+DTLS state, and change the scope of IceConnectionState to
-  // be just the ICE layer. See: crbug.com/webrtc/6145
+  // TODO(jonasolsson): Replace with standardized_ice_connection_state once it
+  // is ready, see crbug.com/webrtc/6145
   virtual IceConnectionState ice_connection_state() = 0;
 
+  // Returns the aggregated state of all ICE and DTLS transports.
+  virtual PeerConnectionState peer_connection_state();
+
   virtual IceGatheringState ice_gathering_state() = 0;
 
   // Starts RtcEventLog using existing file. Takes ownership of |file| and
@@ -1049,6 +1081,10 @@
   virtual void OnIceConnectionChange(
       PeerConnectionInterface::IceConnectionState new_state) = 0;
 
+  // Called any time the PeerConnectionState changes.
+  virtual void OnConnectionChange(
+      PeerConnectionInterface::PeerConnectionState new_state) {}
+
   // Called any time the IceGatheringState changes.
   virtual void OnIceGatheringChange(
       PeerConnectionInterface::IceGatheringState new_state) = 0;
@@ -1180,7 +1216,7 @@
  public:
   class Options {
    public:
-    Options() : crypto_options(rtc::CryptoOptions::NoGcm()) {}
+    Options() {}
 
     // If set to true, created PeerConnections won't enforce any SRTP
     // requirement, allowing unsecured media. Should only be used for
@@ -1209,7 +1245,7 @@
     rtc::SSLProtocolVersion ssl_max_version = rtc::SSL_PROTOCOL_DTLS_12;
 
     // Sets crypto related options, e.g. enabled cipher suites.
-    rtc::CryptoOptions crypto_options;
+    CryptoOptions crypto_options = CryptoOptions::NoGcm();
   };
 
   // Set the options to be used for subsequently created PeerConnections.
@@ -1323,7 +1359,8 @@
 // rtc::Thread::Current()->Run(), or call
 // rtc::Thread::Current()->ProcessMessages() within the application's own
 // message loop.
-rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory(
+RTC_EXPORT rtc::scoped_refptr<PeerConnectionFactoryInterface>
+CreatePeerConnectionFactory(
     rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory,
     rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory);
 
@@ -1337,7 +1374,8 @@
 // returned factory.
 // TODO(deadbeef): Use rtc::scoped_refptr<> and std::unique_ptr<> to make this
 // ownership transfer and ref counting more obvious.
-rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory(
+RTC_EXPORT rtc::scoped_refptr<PeerConnectionFactoryInterface>
+CreatePeerConnectionFactory(
     rtc::Thread* network_thread,
     rtc::Thread* worker_thread,
     rtc::Thread* signaling_thread,
@@ -1353,7 +1391,8 @@
 // If |audio_mixer| is null, an internal audio mixer will be created and used.
 // If |audio_processing| is null, an internal audio processing module will be
 // created and used.
-rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory(
+RTC_EXPORT rtc::scoped_refptr<PeerConnectionFactoryInterface>
+CreatePeerConnectionFactory(
     rtc::Thread* network_thread,
     rtc::Thread* worker_thread,
     rtc::Thread* signaling_thread,
@@ -1375,7 +1414,8 @@
 // be created and used.
 // If |network_controller_factory| is provided, it will be used if enabled via
 // field trial.
-rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory(
+RTC_EXPORT rtc::scoped_refptr<PeerConnectionFactoryInterface>
+CreatePeerConnectionFactory(
     rtc::Thread* network_thread,
     rtc::Thread* worker_thread,
     rtc::Thread* signaling_thread,
@@ -1396,7 +1436,8 @@
 // extra internal video codecs will be added.
 // When building WebRTC with rtc_use_builtin_sw_codecs = false, this is the
 // only available CreatePeerConnectionFactory overload.
-rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory(
+RTC_EXPORT rtc::scoped_refptr<PeerConnectionFactoryInterface>
+CreatePeerConnectionFactory(
     rtc::Thread* network_thread,
     rtc::Thread* worker_thread,
     rtc::Thread* signaling_thread,
@@ -1413,7 +1454,7 @@
 // mixer.
 //
 // If |audio_mixer| is null, an internal audio mixer will be created and used.
-rtc::scoped_refptr<PeerConnectionFactoryInterface>
+RTC_EXPORT rtc::scoped_refptr<PeerConnectionFactoryInterface>
 CreatePeerConnectionFactoryWithAudioMixer(
     rtc::Thread* network_thread,
     rtc::Thread* worker_thread,
@@ -1427,7 +1468,7 @@
 
 // Create a new instance of PeerConnectionFactoryInterface.
 // Same thread is used as worker and network thread.
-inline rtc::scoped_refptr<PeerConnectionFactoryInterface>
+RTC_EXPORT inline rtc::scoped_refptr<PeerConnectionFactoryInterface>
 CreatePeerConnectionFactory(
     rtc::Thread* worker_and_network_thread,
     rtc::Thread* signaling_thread,
diff --git a/api/proxy.cc b/api/proxy.cc
index c86bddf..01e6be5 100644
--- a/api/proxy.cc
+++ b/api/proxy.cc
@@ -23,7 +23,7 @@
   if (t->IsCurrent()) {
     proxy_->OnMessage(nullptr);
   } else {
-    e_.reset(new rtc::Event(false, false));
+    e_ = absl::make_unique<rtc::Event>();
     t->Post(posted_from, this, 0);
     e_->Wait(rtc::Event::kForever);
   }
diff --git a/api/rtp_headers.h b/api/rtp_headers.h
index 799058d..eff6223 100644
--- a/api/rtp_headers.h
+++ b/api/rtp_headers.h
@@ -12,6 +12,7 @@
 #define API_RTP_HEADERS_H_
 
 #include <stddef.h>
+#include <stdint.h>
 #include <string.h>
 
 #include "api/array_view.h"
@@ -19,7 +20,6 @@
 #include "api/video/video_frame_marking.h"
 #include "api/video/video_rotation.h"
 #include "api/video/video_timing.h"
-
 #include "common_types.h"  // NOLINT(build/include)
 
 namespace webrtc {
diff --git a/api/rtpparameters.cc b/api/rtpparameters.cc
index e9f4d5d..063d106 100644
--- a/api/rtpparameters.cc
+++ b/api/rtpparameters.cc
@@ -12,6 +12,7 @@
 #include <algorithm>
 #include <string>
 
+#include "api/array_view.h"
 #include "rtc_base/strings/string_builder.h"
 
 namespace webrtc {
diff --git a/api/rtpparameters.h b/api/rtpparameters.h
index 678ac02..badda07 100644
--- a/api/rtpparameters.h
+++ b/api/rtpparameters.h
@@ -11,12 +11,14 @@
 #ifndef API_RTPPARAMETERS_H_
 #define API_RTPPARAMETERS_H_
 
+#include <stdint.h>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
 #include "absl/types/optional.h"
 #include "api/mediatypes.h"
+#include "rtc_base/system/rtc_export.h"
 
 namespace webrtc {
 
@@ -404,6 +406,14 @@
   // bitrate priority.
   double bitrate_priority = kDefaultBitratePriority;
 
+  // The relative DiffServ Code Point priority for this encoding, allowing
+  // packets to be marked relatively higher or lower without affecting
+  // bandwidth allocations. See https://w3c.github.io/webrtc-dscp-exp/ . NB
+  // we follow chromium's translation of the allowed string enum values for
+  // this field to 1.0, 0.5, et cetera, similar to bitrate_priority above.
+  // TODO(http://crbug.com/webrtc/8630): Implement this per encoding parameter.
+  double network_priority = kDefaultBitratePriority;
+
   // Indicates the preferred duration of media represented by a packet in
   // milliseconds for this encoding. If set, this will take precedence over the
   // ptime set in the RtpCodecParameters. This could happen if SDP negotiation
@@ -471,7 +481,8 @@
   bool operator==(const RtpEncodingParameters& o) const {
     return ssrc == o.ssrc && codec_payload_type == o.codec_payload_type &&
            fec == o.fec && rtx == o.rtx && dtx == o.dtx &&
-           bitrate_priority == o.bitrate_priority && ptime == o.ptime &&
+           bitrate_priority == o.bitrate_priority &&
+           network_priority == o.network_priority && ptime == o.ptime &&
            max_bitrate_bps == o.max_bitrate_bps &&
            min_bitrate_bps == o.min_bitrate_bps &&
            max_framerate == o.max_framerate &&
@@ -607,7 +618,7 @@
   bool operator!=(const RtcpParameters& o) const { return !(*this == o); }
 };
 
-struct RtpParameters {
+struct RTC_EXPORT RtpParameters {
   RtpParameters();
   RtpParameters(const RtpParameters&);
   ~RtpParameters();
diff --git a/api/rtptransceiverinterface.cc b/api/rtptransceiverinterface.cc
index d833339..e62b014 100644
--- a/api/rtptransceiverinterface.cc
+++ b/api/rtptransceiverinterface.cc
@@ -10,6 +10,8 @@
 
 #include "api/rtptransceiverinterface.h"
 
+#include "rtc_base/checks.h"
+
 namespace webrtc {
 
 RtpTransceiverInit::RtpTransceiverInit() = default;
diff --git a/api/rtptransceiverinterface.h b/api/rtptransceiverinterface.h
index 301a380..c01fdaf 100644
--- a/api/rtptransceiverinterface.h
+++ b/api/rtptransceiverinterface.h
@@ -16,9 +16,12 @@
 
 #include "absl/types/optional.h"
 #include "api/array_view.h"
+#include "api/mediatypes.h"
+#include "api/rtpparameters.h"
 #include "api/rtpreceiverinterface.h"
 #include "api/rtpsenderinterface.h"
 #include "rtc_base/refcount.h"
+#include "rtc_base/scoped_ref_ptr.h"
 
 namespace webrtc {
 
diff --git a/api/transport/network_types.cc b/api/transport/network_types.cc
index 48bdcab..80214de 100644
--- a/api/transport/network_types.cc
+++ b/api/transport/network_types.cc
@@ -38,7 +38,7 @@
     const {
   std::vector<PacketResult> res;
   for (const PacketResult& fb : packet_feedbacks) {
-    if (fb.receive_time.IsFinite() && fb.sent_packet.has_value()) {
+    if (fb.receive_time.IsFinite()) {
       res.push_back(fb);
     }
   }
@@ -48,7 +48,7 @@
 std::vector<PacketResult> TransportPacketsFeedback::LostWithSendInfo() const {
   std::vector<PacketResult> res;
   for (const PacketResult& fb : packet_feedbacks) {
-    if (fb.receive_time.IsPlusInfinity() && fb.sent_packet.has_value()) {
+    if (fb.receive_time.IsPlusInfinity()) {
       res.push_back(fb);
     }
   }
diff --git a/api/transport/network_types.h b/api/transport/network_types.h
index 3a00efe..0f1d7ab 100644
--- a/api/transport/network_types.h
+++ b/api/transport/network_types.h
@@ -126,7 +126,7 @@
   PacketResult(const PacketResult&);
   ~PacketResult();
 
-  absl::optional<SentPacket> sent_packet;
+  SentPacket sent_packet;
   Timestamp receive_time = Timestamp::PlusInfinity();
 };
 
@@ -140,6 +140,9 @@
   DataSize prior_in_flight = DataSize::Zero();
   std::vector<PacketResult> packet_feedbacks;
 
+  // Arrival times for messages without send time information.
+  std::vector<Timestamp> sendless_arrival_times;
+
   std::vector<PacketResult> ReceivedWithSendInfo() const;
   std::vector<PacketResult> LostWithSendInfo() const;
   std::vector<PacketResult> PacketsWithFeedback() const;
diff --git a/api/units/data_rate.h b/api/units/data_rate.h
index 4bb988b..28efcd3 100644
--- a/api/units/data_rate.h
+++ b/api/units/data_rate.h
@@ -20,12 +20,12 @@
 #include <cmath>
 #include <limits>
 #include <string>
-
-#include "rtc_base/checks.h"
-#include "rtc_base/numerics/safe_conversions.h"
+#include <type_traits>
 
 #include "api/units/data_size.h"
 #include "api/units/time_delta.h"
+#include "rtc_base/checks.h"
+#include "rtc_base/numerics/safe_conversions.h"
 
 namespace webrtc {
 namespace data_rate_impl {
diff --git a/api/units/time_delta.h b/api/units/time_delta.h
index ec36417..74b5385 100644
--- a/api/units/time_delta.h
+++ b/api/units/time_delta.h
@@ -20,6 +20,7 @@
 #include <cstdlib>
 #include <limits>
 #include <string>
+#include <type_traits>
 
 #include "rtc_base/checks.h"
 #include "rtc_base/numerics/safe_conversions.h"
diff --git a/api/units/timestamp.h b/api/units/timestamp.h
index 0298f5d..80f1839 100644
--- a/api/units/timestamp.h
+++ b/api/units/timestamp.h
@@ -15,9 +15,11 @@
 #include <ostream>  // no-presubmit-check TODO(webrtc:8982)
 #endif              // UNIT_TEST
 
+#include <math.h>
 #include <stdint.h>
 #include <limits>
 #include <string>
+#include <type_traits>
 
 #include "api/units/time_delta.h"
 #include "rtc_base/checks.h"
diff --git a/api/video/builtin_video_bitrate_allocator_factory.cc b/api/video/builtin_video_bitrate_allocator_factory.cc
new file mode 100644
index 0000000..70f6ad0
--- /dev/null
+++ b/api/video/builtin_video_bitrate_allocator_factory.cc
@@ -0,0 +1,56 @@
+/*
+ *  Copyright (c) 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.
+ */
+
+#include "api/video/builtin_video_bitrate_allocator_factory.h"
+
+#include "absl/memory/memory.h"
+#include "media/base/codec.h"
+#include "modules/video_coding/codecs/vp9/svc_rate_allocator.h"
+#include "modules/video_coding/utility/default_video_bitrate_allocator.h"
+#include "modules/video_coding/utility/simulcast_rate_allocator.h"
+#include "rtc_base/system/fallthrough.h"
+
+namespace webrtc {
+
+namespace {
+
+class BuiltinVideoBitrateAllocatorFactory
+    : public VideoBitrateAllocatorFactory {
+ public:
+  BuiltinVideoBitrateAllocatorFactory() = default;
+  ~BuiltinVideoBitrateAllocatorFactory() override = default;
+
+  std::unique_ptr<VideoBitrateAllocator> CreateVideoBitrateAllocator(
+      const VideoCodec& codec) override {
+    std::unique_ptr<VideoBitrateAllocator> rate_allocator;
+    switch (codec.codecType) {
+      case kVideoCodecVP8:
+        RTC_FALLTHROUGH();
+      case kVideoCodecH264:
+        rate_allocator.reset(new SimulcastRateAllocator(codec));
+        break;
+      case kVideoCodecVP9:
+        rate_allocator.reset(new SvcRateAllocator(codec));
+        break;
+      default:
+        rate_allocator.reset(new DefaultVideoBitrateAllocator(codec));
+    }
+    return rate_allocator;
+  }
+};
+
+}  // namespace
+
+std::unique_ptr<VideoBitrateAllocatorFactory>
+CreateBuiltinVideoBitrateAllocatorFactory() {
+  return absl::make_unique<BuiltinVideoBitrateAllocatorFactory>();
+}
+
+}  // namespace webrtc
diff --git a/api/video/builtin_video_bitrate_allocator_factory.h b/api/video/builtin_video_bitrate_allocator_factory.h
new file mode 100644
index 0000000..ac880a0
--- /dev/null
+++ b/api/video/builtin_video_bitrate_allocator_factory.h
@@ -0,0 +1,25 @@
+/*
+ *  Copyright (c) 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 API_VIDEO_BUILTIN_VIDEO_BITRATE_ALLOCATOR_FACTORY_H_
+#define API_VIDEO_BUILTIN_VIDEO_BITRATE_ALLOCATOR_FACTORY_H_
+
+#include <memory>
+
+#include "api/video/video_bitrate_allocator_factory.h"
+
+namespace webrtc {
+
+std::unique_ptr<VideoBitrateAllocatorFactory>
+CreateBuiltinVideoBitrateAllocatorFactory();
+
+}  // namespace webrtc
+
+#endif  // API_VIDEO_BUILTIN_VIDEO_BITRATE_ALLOCATOR_FACTORY_H_
diff --git a/api/video/encoded_image.cc b/api/video/encoded_image.cc
index 5658dfc..e7c6fad 100644
--- a/api/video/encoded_image.cc
+++ b/api/video/encoded_image.cc
@@ -12,11 +12,6 @@
 
 #include <string.h>
 
-#include <algorithm>  // swap
-
-#include "rtc_base/bind.h"
-#include "rtc_base/checks.h"
-
 namespace webrtc {
 
 // FFmpeg's decoder, used by H264DecoderImpl, requires up to 8 bytes padding due
diff --git a/api/video/encoded_image.h b/api/video/encoded_image.h
index ed58d96..5c4a82d 100644
--- a/api/video/encoded_image.h
+++ b/api/video/encoded_image.h
@@ -11,17 +11,22 @@
 #ifndef API_VIDEO_ENCODED_IMAGE_H_
 #define API_VIDEO_ENCODED_IMAGE_H_
 
+#include <stdint.h>
+
 #include "absl/types/optional.h"
+#include "api/video/video_bitrate_allocation.h"
 #include "api/video/video_content_type.h"
 #include "api/video/video_rotation.h"
 #include "api/video/video_timing.h"
 #include "common_types.h"  // NOLINT(build/include)
+#include "rtc_base/checks.h"
+#include "rtc_base/system/rtc_export.h"
 
 namespace webrtc {
 
 // TODO(bug.webrtc.org/9378): This is a legacy api class, which is slowly being
 // cleaned up. Direct use of its members is strongly discouraged.
-class EncodedImage {
+class RTC_EXPORT EncodedImage {
  public:
   static const size_t kBufferPaddingBytesH264;
 
diff --git a/api/video/hdr_metadata.cc b/api/video/hdr_metadata.cc
new file mode 100644
index 0000000..bfe54ce
--- /dev/null
+++ b/api/video/hdr_metadata.cc
@@ -0,0 +1,35 @@
+/*
+ *  Copyright (c) 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.
+ */
+
+#include "api/video/hdr_metadata.h"
+
+namespace webrtc {
+
+HdrMasteringMetadata::Chromaticity::Chromaticity() = default;
+HdrMasteringMetadata::Chromaticity::Chromaticity(const Chromaticity& rhs) =
+    default;
+HdrMasteringMetadata::Chromaticity::Chromaticity(Chromaticity&& rhs) = default;
+HdrMasteringMetadata::Chromaticity& HdrMasteringMetadata::Chromaticity::
+operator=(const Chromaticity& rhs) = default;
+
+HdrMasteringMetadata::HdrMasteringMetadata() = default;
+HdrMasteringMetadata::HdrMasteringMetadata(const HdrMasteringMetadata& rhs) =
+    default;
+HdrMasteringMetadata::HdrMasteringMetadata(HdrMasteringMetadata&& rhs) =
+    default;
+HdrMasteringMetadata& HdrMasteringMetadata::operator=(
+    const HdrMasteringMetadata& rhs) = default;
+
+HdrMetadata::HdrMetadata() = default;
+HdrMetadata::HdrMetadata(const HdrMetadata& rhs) = default;
+HdrMetadata::HdrMetadata(HdrMetadata&& rhs) = default;
+HdrMetadata& HdrMetadata::operator=(const HdrMetadata& rhs) = default;
+
+}  // namespace webrtc
diff --git a/api/video/hdr_metadata.h b/api/video/hdr_metadata.h
new file mode 100644
index 0000000..be0c173
--- /dev/null
+++ b/api/video/hdr_metadata.h
@@ -0,0 +1,96 @@
+/*
+ *  Copyright (c) 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 API_VIDEO_HDR_METADATA_H_
+#define API_VIDEO_HDR_METADATA_H_
+
+#include <stdint.h>
+
+namespace webrtc {
+
+// SMPTE ST 2086 mastering metadata,
+// see https://ieeexplore.ieee.org/document/8353899.
+struct HdrMasteringMetadata {
+  struct Chromaticity {
+    // xy chromaticity coordinates must be calculated as specified in ISO
+    // 11664-3:2012 Section 7, and must be specified with four decimal places.
+    // The x coordinate must be in the range [0.0001, 0.7400] and the y
+    // coordinate must be in the range [0.0001, 0.8400].
+    float x = 0.0f;
+    float y = 0.0f;
+    bool operator==(const Chromaticity& rhs) const {
+      return x == rhs.x && y == rhs.y;
+    }
+
+    Chromaticity();
+    Chromaticity(const Chromaticity& rhs);
+    Chromaticity(Chromaticity&& rhs);
+    Chromaticity& operator=(const Chromaticity& rhs);
+  };
+
+  // The nominal primaries of the mastering display.
+  Chromaticity primary_r;
+  Chromaticity primary_g;
+  Chromaticity primary_b;
+
+  // The nominal chromaticity of the white point of the mastering display.
+  Chromaticity white_point;
+
+  // The nominal maximum display luminance of the mastering display. Specified
+  // in the unit candela/m2. The value must be in the range [5, 10000] with zero
+  // decimal places.
+  float luminance_max = 0.0f;
+
+  // The nominal minimum display luminance of the mastering display. Specified
+  // in the unit candela/m2. The value must be in the range [0.0001, 5.0000]
+  // with four decimal places.
+  float luminance_min = 0.0f;
+
+  HdrMasteringMetadata();
+  HdrMasteringMetadata(const HdrMasteringMetadata& rhs);
+  HdrMasteringMetadata(HdrMasteringMetadata&& rhs);
+  HdrMasteringMetadata& operator=(const HdrMasteringMetadata& rhs);
+
+  bool operator==(const HdrMasteringMetadata& rhs) const {
+    return ((primary_r == rhs.primary_r) && (primary_g == rhs.primary_g) &&
+            (primary_b == rhs.primary_b) && (white_point == rhs.white_point) &&
+            (luminance_max == rhs.luminance_max) &&
+            (luminance_min == rhs.luminance_min));
+  }
+};
+
+// High dynamic range (HDR) metadata common for HDR10 and WebM/VP9-based HDR
+// formats. This struct replicates the HDRMetadata struct defined in
+// https://cs.chromium.org/chromium/src/media/base/hdr_metadata.h
+struct HdrMetadata {
+  HdrMasteringMetadata mastering_metadata;
+  // Max content light level (CLL), i.e. maximum brightness level present in the
+  // stream, in nits. 1 nit = 1 candela/m2.
+  uint32_t max_content_light_level = 0;
+  // Max frame-average light level (FALL), i.e. maximum average brightness of
+  // the brightest frame in the stream, in nits.
+  uint32_t max_frame_average_light_level = 0;
+
+  HdrMetadata();
+  HdrMetadata(const HdrMetadata& rhs);
+  HdrMetadata(HdrMetadata&& rhs);
+  HdrMetadata& operator=(const HdrMetadata& rhs);
+
+  bool operator==(const HdrMetadata& rhs) const {
+    return (
+        (max_content_light_level == rhs.max_content_light_level) &&
+        (max_frame_average_light_level == rhs.max_frame_average_light_level) &&
+        (mastering_metadata == rhs.mastering_metadata));
+  }
+};
+
+}  // namespace webrtc
+
+#endif  // API_VIDEO_HDR_METADATA_H_
diff --git a/api/video/i420_buffer.h b/api/video/i420_buffer.h
index 282b242..631e394 100644
--- a/api/video/i420_buffer.h
+++ b/api/video/i420_buffer.h
@@ -11,16 +11,19 @@
 #ifndef API_VIDEO_I420_BUFFER_H_
 #define API_VIDEO_I420_BUFFER_H_
 
+#include <stdint.h>
 #include <memory>
 
 #include "api/video/video_frame_buffer.h"
 #include "api/video/video_rotation.h"
 #include "rtc_base/memory/aligned_malloc.h"
+#include "rtc_base/scoped_ref_ptr.h"
+#include "rtc_base/system/rtc_export.h"
 
 namespace webrtc {
 
 // Plain I420 buffer in standard memory.
-class I420Buffer : public I420BufferInterface {
+class RTC_EXPORT I420Buffer : public I420BufferInterface {
  public:
   static rtc::scoped_refptr<I420Buffer> Create(int width, int height);
   static rtc::scoped_refptr<I420Buffer> Create(int width,
diff --git a/api/video/video_bitrate_allocation.cc b/api/video/video_bitrate_allocation.cc
index 8922536..1b35690 100644
--- a/api/video/video_bitrate_allocation.cc
+++ b/api/video/video_bitrate_allocation.cc
@@ -10,6 +10,8 @@
 
 #include "api/video/video_bitrate_allocation.h"
 
+#include <cstdint>
+
 #include "rtc_base/checks.h"
 #include "rtc_base/numerics/safe_conversions.h"
 #include "rtc_base/strings/string_builder.h"
diff --git a/api/video/video_bitrate_allocation.h b/api/video/video_bitrate_allocation.h
index 9e2501d..d1771b4 100644
--- a/api/video/video_bitrate_allocation.h
+++ b/api/video/video_bitrate_allocation.h
@@ -11,6 +11,8 @@
 #ifndef API_VIDEO_VIDEO_BITRATE_ALLOCATION_H_
 #define API_VIDEO_VIDEO_BITRATE_ALLOCATION_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <limits>
 #include <string>
 #include <vector>
diff --git a/api/video/video_frame.cc b/api/video/video_frame.cc
index 5521ad8..12da43f 100644
--- a/api/video/video_frame.cc
+++ b/api/video/video_frame.cc
@@ -21,7 +21,7 @@
 
 VideoFrame VideoFrame::Builder::build() {
   return VideoFrame(video_frame_buffer_, timestamp_us_, timestamp_rtp_,
-                    ntp_time_ms_, rotation_, color_space_);
+                    ntp_time_ms_, rotation_, color_space_, hdr_metadata_);
 }
 
 VideoFrame::Builder& VideoFrame::Builder::set_video_frame_buffer(
@@ -64,6 +64,12 @@
   return *this;
 }
 
+VideoFrame::Builder& VideoFrame::Builder::set_hdr_metadata(
+    const HdrMetadata& hdr_metadata) {
+  hdr_metadata_ = hdr_metadata;
+  return *this;
+}
+
 VideoFrame::VideoFrame(const rtc::scoped_refptr<VideoFrameBuffer>& buffer,
                        webrtc::VideoRotation rotation,
                        int64_t timestamp_us)
@@ -90,13 +96,15 @@
                        uint32_t timestamp_rtp,
                        int64_t ntp_time_ms,
                        VideoRotation rotation,
-                       const absl::optional<ColorSpace>& color_space)
+                       const absl::optional<ColorSpace>& color_space,
+                       const absl::optional<HdrMetadata>& hdr_metadata)
     : video_frame_buffer_(buffer),
       timestamp_rtp_(timestamp_rtp),
       ntp_time_ms_(ntp_time_ms),
       timestamp_us_(timestamp_us),
       rotation_(rotation),
-      color_space_(color_space) {}
+      color_space_(color_space),
+      hdr_metadata_(hdr_metadata) {}
 
 VideoFrame::~VideoFrame() = default;
 
diff --git a/api/video/video_frame.h b/api/video/video_frame.h
index dcb533e..58362b0 100644
--- a/api/video/video_frame.h
+++ b/api/video/video_frame.h
@@ -15,12 +15,15 @@
 
 #include "absl/types/optional.h"
 #include "api/video/color_space.h"
+#include "api/video/hdr_metadata.h"
 #include "api/video/video_frame_buffer.h"
 #include "api/video/video_rotation.h"
+#include "rtc_base/scoped_ref_ptr.h"
+#include "rtc_base/system/rtc_export.h"
 
 namespace webrtc {
 
-class VideoFrame {
+class RTC_EXPORT VideoFrame {
  public:
   // Preferred way of building VideoFrame objects.
   class Builder {
@@ -37,6 +40,7 @@
     Builder& set_ntp_time_ms(int64_t ntp_time_ms);
     Builder& set_rotation(VideoRotation rotation);
     Builder& set_color_space(const ColorSpace& color_space);
+    Builder& set_hdr_metadata(const HdrMetadata& hdr_metadata);
 
    private:
     rtc::scoped_refptr<webrtc::VideoFrameBuffer> video_frame_buffer_;
@@ -45,6 +49,7 @@
     int64_t ntp_time_ms_ = 0;
     VideoRotation rotation_ = kVideoRotation_0;
     absl::optional<ColorSpace> color_space_;
+    absl::optional<HdrMetadata> hdr_metadata_;
   };
 
   // To be deprecated. Migrate all use to Builder.
@@ -110,9 +115,12 @@
   VideoRotation rotation() const { return rotation_; }
   void set_rotation(VideoRotation rotation) { rotation_ = rotation; }
 
-  // Set Color space when available.
+  // Get color space when available.
   absl::optional<ColorSpace> color_space() const { return color_space_; }
 
+  // Get HDR metadata when available.
+  absl::optional<HdrMetadata> hdr_metadata() const { return hdr_metadata_; }
+
   // Get render time in milliseconds.
   // TODO(nisse): Deprecated. Migrate all users to timestamp_us().
   int64_t render_time_ms() const;
@@ -133,7 +141,8 @@
              uint32_t timestamp_rtp,
              int64_t ntp_time_ms,
              VideoRotation rotation,
-             const absl::optional<ColorSpace>& color_space);
+             const absl::optional<ColorSpace>& color_space,
+             const absl::optional<HdrMetadata>& hdr_metadata);
 
   // An opaque reference counted handle that stores the pixel data.
   rtc::scoped_refptr<webrtc::VideoFrameBuffer> video_frame_buffer_;
@@ -142,6 +151,7 @@
   int64_t timestamp_us_;
   VideoRotation rotation_;
   absl::optional<ColorSpace> color_space_;
+  absl::optional<HdrMetadata> hdr_metadata_;
 };
 
 }  // namespace webrtc
diff --git a/api/video/video_source_interface.h b/api/video/video_source_interface.h
index 4ee4719..2bf7370 100644
--- a/api/video/video_source_interface.h
+++ b/api/video/video_source_interface.h
@@ -15,12 +15,13 @@
 
 #include "absl/types/optional.h"
 #include "api/video/video_sink_interface.h"
+#include "rtc_base/system/rtc_export.h"
 
 namespace rtc {
 
 // VideoSinkWants is used for notifying the source of properties a video frame
 // should have when it is delivered to a certain sink.
-struct VideoSinkWants {
+struct RTC_EXPORT VideoSinkWants {
   VideoSinkWants();
   VideoSinkWants(const VideoSinkWants&);
   ~VideoSinkWants();
diff --git a/api/video/video_stream_encoder_observer.h b/api/video/video_stream_encoder_observer.h
index b940efd..98b5cfc 100644
--- a/api/video/video_stream_encoder_observer.h
+++ b/api/video/video_stream_encoder_observer.h
@@ -11,6 +11,7 @@
 #ifndef API_VIDEO_VIDEO_STREAM_ENCODER_OBSERVER_H_
 #define API_VIDEO_VIDEO_STREAM_ENCODER_OBSERVER_H_
 
+#include <string>
 #include <vector>
 
 #include "absl/types/optional.h"
@@ -68,6 +69,9 @@
   virtual void OnSendEncodedImage(const EncodedImage& encoded_image,
                                   const CodecSpecificInfo* codec_info) = 0;
 
+  virtual void OnEncoderImplementationChanged(
+      const std::string& implementation_name) = 0;
+
   virtual void OnFrameDropped(DropReason reason) = 0;
 
   // Used to indicate change in content type, which may require a change in
diff --git a/api/video/video_stream_encoder_settings.h b/api/video/video_stream_encoder_settings.h
index b67f33c..37c1de7 100644
--- a/api/video/video_stream_encoder_settings.h
+++ b/api/video/video_stream_encoder_settings.h
@@ -11,6 +11,7 @@
 #ifndef API_VIDEO_VIDEO_STREAM_ENCODER_SETTINGS_H_
 #define API_VIDEO_VIDEO_STREAM_ENCODER_SETTINGS_H_
 
+#include "api/video/video_bitrate_allocator_factory.h"
 #include "api/video_codecs/video_encoder_factory.h"
 
 namespace webrtc {
@@ -24,6 +25,9 @@
 
   // Ownership stays with WebrtcVideoEngine (delegated from PeerConnection).
   VideoEncoderFactory* encoder_factory = nullptr;
+
+  // Ownership stays with WebrtcVideoEngine (delegated from PeerConnection).
+  VideoBitrateAllocatorFactory* bitrate_allocator_factory = nullptr;
 };
 
 }  // namespace webrtc
diff --git a/audio/BUILD.gn b/audio/BUILD.gn
index 91cece9..4b2ec61 100644
--- a/audio/BUILD.gn
+++ b/audio/BUILD.gn
@@ -65,12 +65,14 @@
     "../common_audio:common_audio_c",
     "../logging:rtc_event_audio",
     "../logging:rtc_event_log_api",
+    "../logging:rtc_stream_config",
     "../modules/audio_coding",
+    "../modules/audio_coding:audio_encoder_cng",
     "../modules/audio_coding:audio_format_conversion",
     "../modules/audio_coding:audio_network_adaptor_config",
-    "../modules/audio_coding:cng",
     "../modules/audio_device",
     "../modules/audio_processing",
+    "../modules/audio_processing:api",
     "../modules/bitrate_controller:bitrate_controller",
     "../modules/pacing:pacing",
     "../modules/remote_bitrate_estimator:remote_bitrate_estimator",
@@ -128,22 +130,34 @@
       "mock_voe_channel_proxy.h",
       "remix_resample_unittest.cc",
       "test/audio_stats_test.cc",
+      "test/media_transport_test.cc",
       "time_interval_unittest.cc",
       "transport_feedback_packet_loss_tracker_unittest.cc",
     ]
     deps = [
       ":audio",
       ":audio_end_to_end_test",
+      "../api:loopback_media_transport",
       "../api:mock_audio_mixer",
+      "../api:mock_frame_decryptor",
+      "../api:mock_frame_encryptor",
       "../api/audio:audio_frame_api",
+      "../api/audio_codecs:audio_codecs_api",
+      "../api/audio_codecs/opus:audio_decoder_opus",
+      "../api/audio_codecs/opus:audio_encoder_opus",
       "../api/units:time_delta",
+      "../call:mock_bitrate_allocator",
       "../call:mock_call_interfaces",
       "../call:mock_rtp_interfaces",
       "../call:rtp_interfaces",
       "../call:rtp_receiver",
       "../common_audio",
       "../logging:mocks",
+      "../logging:rtc_event_log_api",
       "../modules/audio_device:mock_audio_device",
+
+      # For TestAudioDeviceModule
+      "../modules/audio_device:audio_device_impl",
       "../modules/audio_mixer:audio_mixer_impl",
       "../modules/audio_processing:audio_processing_statistics",
       "../modules/audio_processing:mocks",
@@ -151,6 +165,7 @@
       "../modules/pacing:pacing",
       "../modules/rtp_rtcp:mock_rtp_rtcp",
       "../modules/rtp_rtcp:rtp_rtcp_format",
+      "../modules/utility",
       "../rtc_base:checks",
       "../rtc_base:rtc_base_approved",
       "../rtc_base:rtc_base_tests_utils",
@@ -265,6 +280,7 @@
       "../test:single_threaded_task_queue",
       "../test:test_common",
       "../test:test_main",
+      "../test:test_support",
       "//testing/gtest",
       "//third_party/abseil-cpp/absl/memory",
     ]
diff --git a/audio/audio_receive_stream.cc b/audio/audio_receive_stream.cc
index 563e8a0..4f2e29c 100644
--- a/audio/audio_receive_stream.cc
+++ b/audio/audio_receive_stream.cc
@@ -13,14 +13,19 @@
 #include <string>
 #include <utility>
 
+#include "absl/memory/memory.h"
+#include "api/array_view.h"
+#include "api/audio_codecs/audio_format.h"
 #include "api/call/audio_sink.h"
+#include "api/rtpparameters.h"
 #include "audio/audio_send_stream.h"
 #include "audio/audio_state.h"
+#include "audio/channel_receive.h"
 #include "audio/channel_receive_proxy.h"
 #include "audio/conversion.h"
+#include "call/rtp_config.h"
 #include "call/rtp_stream_receiver_controller_interface.h"
-#include "modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
-#include "modules/rtp_rtcp/include/rtp_rtcp.h"
+#include "common_types.h"  // NOLINT(build/include)
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/strings/string_builder.h"
@@ -53,6 +58,7 @@
   ss << "{rtp: " << rtp.ToString();
   ss << ", rtcp_send_transport: "
      << (rtcp_send_transport ? "(Transport)" : "null");
+  ss << ", media_transport: " << (media_transport ? "(Transport)" : "null");
   if (!sync_group.empty()) {
     ss << ", sync_group: " << sync_group;
   }
@@ -73,10 +79,10 @@
   return absl::make_unique<voe::ChannelReceiveProxy>(
       absl::make_unique<voe::ChannelReceive>(
           module_process_thread, internal_audio_state->audio_device_module(),
-          config.rtcp_send_transport, event_log, config.rtp.remote_ssrc,
-          config.jitter_buffer_max_packets,
+          config.media_transport, config.rtcp_send_transport, event_log,
+          config.rtp.remote_ssrc, config.jitter_buffer_max_packets,
           config.jitter_buffer_fast_accelerate, config.decoder_factory,
-          config.codec_pair_id, config.frame_decryptor));
+          config.codec_pair_id, config.frame_decryptor, config.crypto_options));
 }
 }  // namespace
 
@@ -106,8 +112,6 @@
     std::unique_ptr<voe::ChannelReceiveProxy> channel_proxy)
     : audio_state_(audio_state), channel_proxy_(std::move(channel_proxy)) {
   RTC_LOG(LS_INFO) << "AudioReceiveStream: " << config.rtp.remote_ssrc;
-  RTC_DCHECK(receiver_controller);
-  RTC_DCHECK(packet_router);
   RTC_DCHECK(config.decoder_factory);
   RTC_DCHECK(config.rtcp_send_transport);
   RTC_DCHECK(audio_state_);
@@ -115,13 +119,16 @@
 
   module_process_thread_checker_.DetachFromThread();
 
-  // Configure bandwidth estimation.
-  channel_proxy_->RegisterReceiverCongestionControlObjects(packet_router);
+  if (!config.media_transport) {
+    RTC_DCHECK(receiver_controller);
+    RTC_DCHECK(packet_router);
+    // Configure bandwidth estimation.
+    channel_proxy_->RegisterReceiverCongestionControlObjects(packet_router);
 
-  // Register with transport.
-  rtp_stream_receiver_ = receiver_controller->CreateReceiver(
-      config.rtp.remote_ssrc, channel_proxy_.get());
-
+    // Register with transport.
+    rtp_stream_receiver_ = receiver_controller->CreateReceiver(
+        config.rtp.remote_ssrc, channel_proxy_.get());
+  }
   ConfigureStream(this, config, true);
 }
 
@@ -130,7 +137,9 @@
   RTC_LOG(LS_INFO) << "~AudioReceiveStream: " << config_.rtp.remote_ssrc;
   Stop();
   channel_proxy_->DisassociateSendChannel();
-  channel_proxy_->ResetReceiverCongestionControlObjects();
+  if (!config_.media_transport) {
+    channel_proxy_->ResetReceiverCongestionControlObjects();
+  }
 }
 
 void AudioReceiveStream::Reconfigure(
diff --git a/audio/audio_receive_stream.h b/audio/audio_receive_stream.h
index e982b04..dde0da4 100644
--- a/audio/audio_receive_stream.h
+++ b/audio/audio_receive_stream.h
@@ -18,7 +18,6 @@
 #include "api/rtp_headers.h"
 #include "audio/audio_state.h"
 #include "call/audio_receive_stream.h"
-#include "call/rtp_packet_sink_interface.h"
 #include "call/syncable.h"
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/thread_checker.h"
diff --git a/audio/audio_receive_stream_unittest.cc b/audio/audio_receive_stream_unittest.cc
index 97c42c4..a5c7e20 100644
--- a/audio/audio_receive_stream_unittest.cc
+++ b/audio/audio_receive_stream_unittest.cc
@@ -13,6 +13,7 @@
 #include <vector>
 
 #include "api/test/mock_audio_mixer.h"
+#include "api/test/mock_frame_decryptor.h"
 #include "audio/audio_receive_stream.h"
 #include "audio/conversion.h"
 #include "audio/mock_voe_channel_proxy.h"
@@ -216,7 +217,7 @@
       "{rtp: {remote_ssrc: 1234, local_ssrc: 5678, transport_cc: off, nack: "
       "{rtp_history_ms: 0}, extensions: [{uri: "
       "urn:ietf:params:rtp-hdrext:ssrc-audio-level, id: 3}]}, "
-      "rtcp_send_transport: null}",
+      "rtcp_send_transport: null, media_transport: null}",
       config.ToString());
 }
 
@@ -373,5 +374,25 @@
 
   recv_stream->Reconfigure(new_config);
 }
+
+TEST(AudioReceiveStreamTest, ReconfigureWithFrameDecryptor) {
+  ConfigHelper helper;
+  auto recv_stream = helper.CreateAudioReceiveStream();
+
+  auto new_config_0 = helper.config();
+  rtc::scoped_refptr<FrameDecryptorInterface> mock_frame_decryptor_0(
+      new rtc::RefCountedObject<MockFrameDecryptor>());
+  new_config_0.frame_decryptor = mock_frame_decryptor_0;
+
+  recv_stream->Reconfigure(new_config_0);
+
+  auto new_config_1 = helper.config();
+  rtc::scoped_refptr<FrameDecryptorInterface> mock_frame_decryptor_1(
+      new rtc::RefCountedObject<MockFrameDecryptor>());
+  new_config_1.frame_decryptor = mock_frame_decryptor_1;
+  new_config_1.crypto_options.sframe.require_frame_encryption = true;
+  recv_stream->Reconfigure(new_config_1);
+}
+
 }  // namespace test
 }  // namespace webrtc
diff --git a/audio/audio_send_stream.cc b/audio/audio_send_stream.cc
index 49d933c..37f89c5 100644
--- a/audio/audio_send_stream.cc
+++ b/audio/audio_send_stream.cc
@@ -15,12 +15,24 @@
 #include <vector>
 
 #include "absl/memory/memory.h"
-
+#include "api/audio_codecs/audio_encoder.h"
+#include "api/audio_codecs/audio_encoder_factory.h"
+#include "api/audio_codecs/audio_format.h"
+#include "api/call/transport.h"
+#include "api/crypto/frameencryptorinterface.h"
 #include "audio/audio_state.h"
+#include "audio/channel_send.h"
 #include "audio/channel_send_proxy.h"
 #include "audio/conversion.h"
+#include "call/rtp_config.h"
 #include "call/rtp_transport_controller_send_interface.h"
+#include "common_audio/vad/include/vad.h"
+#include "common_types.h"  // NOLINT(build/include)
+#include "logging/rtc_event_log/events/rtc_event_audio_send_stream_config.h"
+#include "logging/rtc_event_log/rtc_event_log.h"
+#include "logging/rtc_event_log/rtc_stream_config.h"
 #include "modules/audio_coding/codecs/cng/audio_encoder_cng.h"
+#include "modules/audio_processing/include/audio_processing.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/event.h"
 #include "rtc_base/function_view.h"
@@ -49,14 +61,50 @@
 std::unique_ptr<voe::ChannelSendProxy> CreateChannelAndProxy(
     rtc::TaskQueue* worker_queue,
     ProcessThread* module_process_thread,
+    MediaTransportInterface* media_transport,
     RtcpRttStats* rtcp_rtt_stats,
     RtcEventLog* event_log,
-    FrameEncryptorInterface* frame_encryptor) {
+    FrameEncryptorInterface* frame_encryptor,
+    const webrtc::CryptoOptions& crypto_options,
+    bool extmap_allow_mixed) {
   return absl::make_unique<voe::ChannelSendProxy>(
-      absl::make_unique<voe::ChannelSend>(worker_queue, module_process_thread,
-                                          rtcp_rtt_stats, event_log,
-                                          frame_encryptor));
+      absl::make_unique<voe::ChannelSend>(
+          worker_queue, module_process_thread, media_transport, rtcp_rtt_stats,
+          event_log, frame_encryptor, crypto_options, extmap_allow_mixed));
 }
+
+void UpdateEventLogStreamConfig(RtcEventLog* event_log,
+                                const AudioSendStream::Config& config,
+                                const AudioSendStream::Config* old_config) {
+  using SendCodecSpec = AudioSendStream::Config::SendCodecSpec;
+  // Only update if any of the things we log have changed.
+  auto payload_types_equal = [](const absl::optional<SendCodecSpec>& a,
+                                const absl::optional<SendCodecSpec>& b) {
+    if (a.has_value() && b.has_value()) {
+      return a->format.name == b->format.name &&
+             a->payload_type == b->payload_type;
+    }
+    return !a.has_value() && !b.has_value();
+  };
+
+  if (old_config && config.rtp.ssrc == old_config->rtp.ssrc &&
+      config.rtp.extensions == old_config->rtp.extensions &&
+      payload_types_equal(config.send_codec_spec,
+                          old_config->send_codec_spec)) {
+    return;
+  }
+
+  auto rtclog_config = absl::make_unique<rtclog::StreamConfig>();
+  rtclog_config->local_ssrc = config.rtp.ssrc;
+  rtclog_config->rtp_extensions = config.rtp.extensions;
+  if (config.send_codec_spec) {
+    rtclog_config->codecs.emplace_back(config.send_codec_spec->format.name,
+                                       config.send_codec_spec->payload_type, 0);
+  }
+  event_log->Log(absl::make_unique<RtcEventAudioSendStreamConfig>(
+      std::move(rtclog_config)));
+}
+
 }  // namespace
 
 // Helper class to track the actively sending lifetime of this stream.
@@ -87,8 +135,8 @@
     const rtc::scoped_refptr<webrtc::AudioState>& audio_state,
     rtc::TaskQueue* worker_queue,
     ProcessThread* module_process_thread,
-    RtpTransportControllerSendInterface* transport,
-    BitrateAllocator* bitrate_allocator,
+    RtpTransportControllerSendInterface* rtp_transport,
+    BitrateAllocatorInterface* bitrate_allocator,
     RtcEventLog* event_log,
     RtcpRttStats* rtcp_rtt_stats,
     const absl::optional<RtpState>& suspended_rtp_state,
@@ -96,7 +144,7 @@
     : AudioSendStream(config,
                       audio_state,
                       worker_queue,
-                      transport,
+                      rtp_transport,
                       bitrate_allocator,
                       event_log,
                       rtcp_rtt_stats,
@@ -104,28 +152,32 @@
                       overall_call_lifetime,
                       CreateChannelAndProxy(worker_queue,
                                             module_process_thread,
+                                            config.media_transport,
                                             rtcp_rtt_stats,
                                             event_log,
-                                            config.frame_encryptor)) {}
+                                            config.frame_encryptor,
+                                            config.crypto_options,
+                                            config.rtp.extmap_allow_mixed)) {}
 
 AudioSendStream::AudioSendStream(
     const webrtc::AudioSendStream::Config& config,
     const rtc::scoped_refptr<webrtc::AudioState>& audio_state,
     rtc::TaskQueue* worker_queue,
-    RtpTransportControllerSendInterface* transport,
-    BitrateAllocator* bitrate_allocator,
+    RtpTransportControllerSendInterface* rtp_transport,
+    BitrateAllocatorInterface* bitrate_allocator,
     RtcEventLog* event_log,
     RtcpRttStats* rtcp_rtt_stats,
     const absl::optional<RtpState>& suspended_rtp_state,
     TimeInterval* overall_call_lifetime,
     std::unique_ptr<voe::ChannelSendProxy> channel_proxy)
     : worker_queue_(worker_queue),
-      config_(Config(nullptr)),
+      config_(Config(/*send_transport=*/nullptr,
+                     /*media_transport=*/nullptr)),
       audio_state_(audio_state),
       channel_proxy_(std::move(channel_proxy)),
       event_log_(event_log),
       bitrate_allocator_(bitrate_allocator),
-      transport_(transport),
+      rtp_transport_(rtp_transport),
       packet_loss_tracker_(kPacketLossTrackerMaxWindowSizeMs,
                            kPacketLossRateMinNumAckedPackets,
                            kRecoverablePacketLossRateMinNumAckedPairs),
@@ -137,7 +189,11 @@
   RTC_DCHECK(audio_state_);
   RTC_DCHECK(channel_proxy_);
   RTC_DCHECK(bitrate_allocator_);
-  RTC_DCHECK(transport);
+  // TODO(nisse): Eventually, we should have only media_transport. But for the
+  // time being, we can have either. When media transport is injected, there
+  // should be no rtp_transport, and below check should be strengthened to XOR
+  // (either rtp_transport or media_transport but not both).
+  RTC_DCHECK(rtp_transport || config.media_transport);
   RTC_DCHECK(overall_call_lifetime_);
 
   channel_proxy_->SetRTCPStatus(true);
@@ -147,17 +203,22 @@
   ConfigureStream(this, config, true);
 
   pacer_thread_checker_.DetachFromThread();
-  // Signal congestion controller this object is ready for OnPacket* callbacks.
-  transport_->RegisterPacketFeedbackObserver(this);
+  if (rtp_transport_) {
+    // Signal congestion controller this object is ready for OnPacket*
+    // callbacks.
+    rtp_transport_->RegisterPacketFeedbackObserver(this);
+  }
 }
 
 AudioSendStream::~AudioSendStream() {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   RTC_LOG(LS_INFO) << "~AudioSendStream: " << config_.rtp.ssrc;
   RTC_DCHECK(!sending_);
-  transport_->DeRegisterPacketFeedbackObserver(this);
-  channel_proxy_->RegisterTransport(nullptr);
-  channel_proxy_->ResetSenderCongestionControlObjects();
+  if (rtp_transport_) {
+    rtp_transport_->DeRegisterPacketFeedbackObserver(this);
+    channel_proxy_->RegisterTransport(nullptr);
+    channel_proxy_->ResetSenderCongestionControlObjects();
+  }
   // Lifetime can only be updated after deregistering
   // |timed_send_transport_adapter_| in the underlying channel object to avoid
   // data races in |active_lifetime_|.
@@ -196,6 +257,9 @@
     bool first_time) {
   RTC_LOG(LS_INFO) << "AudioSendStream::ConfigureStream: "
                    << new_config.ToString();
+  UpdateEventLogStreamConfig(stream->event_log_, new_config,
+                             first_time ? nullptr : &stream->config_);
+
   const auto& channel_proxy = stream->channel_proxy_;
   const auto& old_config = stream->config_;
 
@@ -235,6 +299,11 @@
     channel_proxy->SetFrameEncryptor(new_config.frame_encryptor);
   }
 
+  if (first_time ||
+      new_config.rtp.extmap_allow_mixed != old_config.rtp.extmap_allow_mixed) {
+    channel_proxy->SetExtmapAllowMixed(new_config.rtp.extmap_allow_mixed);
+  }
+
   const ExtensionIds old_ids = FindExtensionIds(old_config.rtp.extensions);
   const ExtensionIds new_ids = FindExtensionIds(new_config.rtp.extensions);
   // Audio level indication
@@ -261,14 +330,16 @@
       // Probing in application limited region is only used in combination with
       // send side congestion control, wich depends on feedback packets which
       // requires transport sequence numbers to be enabled.
-      stream->transport_->EnablePeriodicAlrProbing(true);
-      bandwidth_observer = stream->transport_->GetBandwidthObserver();
+      if (stream->rtp_transport_) {
+        stream->rtp_transport_->EnablePeriodicAlrProbing(true);
+        bandwidth_observer = stream->rtp_transport_->GetBandwidthObserver();
+      }
     }
-
-    channel_proxy->RegisterSenderCongestionControlObjects(stream->transport_,
-                                                          bandwidth_observer);
+    if (stream->rtp_transport_) {
+      channel_proxy->RegisterSenderCongestionControlObjects(
+          stream->rtp_transport_, bandwidth_observer);
+    }
   }
-
   // MID RTP header extension.
   if ((first_time || new_ids.mid != old_ids.mid ||
        new_config.rtp.mid != old_config.rtp.mid) &&
@@ -296,11 +367,12 @@
       FindExtensionIds(config_.rtp.extensions).transport_sequence_number != 0 &&
       !webrtc::field_trial::IsEnabled("WebRTC-Audio-ForceNoTWCC");
   if (config_.min_bitrate_bps != -1 && config_.max_bitrate_bps != -1 &&
+      !config_.has_dscp &&
       (has_transport_sequence_number ||
        !webrtc::field_trial::IsEnabled("WebRTC-Audio-SendSideBwe") ||
        webrtc::field_trial::IsEnabled("WebRTC-Audio-ABWENoTWCC"))) {
     // Audio BWE is enabled.
-    transport_->packet_sender()->SetAccountForAudioPackets(true);
+    rtp_transport_->packet_sender()->SetAccountForAudioPackets(true);
     rtp_rtcp_module_->SetAsPartOfAllocation(true);
     ConfigureBitrateObserver(config_.min_bitrate_bps, config_.max_bitrate_bps,
                              config_.bitrate_priority,
@@ -355,6 +427,7 @@
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   webrtc::AudioSendStream::Stats stats;
   stats.local_ssrc = config_.rtp.ssrc;
+  stats.target_bitrate_bps = channel_proxy_->GetBitrate();
 
   webrtc::CallSendStatistics call_stats = channel_proxy_->GetRTCPStatistics();
   stats.bytes_sent = call_stats.bytesSent;
@@ -412,24 +485,22 @@
   return channel_proxy_->ReceivedRTCPPacket(packet, length);
 }
 
-uint32_t AudioSendStream::OnBitrateUpdated(uint32_t bitrate_bps,
-                                           uint8_t fraction_loss,
-                                           int64_t rtt,
-                                           int64_t bwe_period_ms) {
+uint32_t AudioSendStream::OnBitrateUpdated(BitrateAllocationUpdate update) {
   // A send stream may be allocated a bitrate of zero if the allocator decides
   // to disable it. For now we ignore this decision and keep sending on min
   // bitrate.
-  if (bitrate_bps == 0) {
-    bitrate_bps = config_.min_bitrate_bps;
+  if (update.bitrate_bps == 0) {
+    update.bitrate_bps = config_.min_bitrate_bps;
   }
-  RTC_DCHECK_GE(bitrate_bps, static_cast<uint32_t>(config_.min_bitrate_bps));
+  RTC_DCHECK_GE(update.bitrate_bps,
+                static_cast<uint32_t>(config_.min_bitrate_bps));
   // The bitrate allocator might allocate an higher than max configured bitrate
   // if there is room, to allow for, as example, extra FEC. Ignore that for now.
   const uint32_t max_bitrate_bps = config_.max_bitrate_bps;
-  if (bitrate_bps > max_bitrate_bps)
-    bitrate_bps = max_bitrate_bps;
+  if (update.bitrate_bps > max_bitrate_bps)
+    update.bitrate_bps = max_bitrate_bps;
 
-  channel_proxy_->SetBitrate(bitrate_bps, bwe_period_ms);
+  channel_proxy_->SetBitrate(update.bitrate_bps, update.bwe_period_ms);
 
   // The amount of audio protection is not exposed by the encoder, hence
   // always returning 0.
@@ -552,12 +623,12 @@
 
   // Wrap the encoder in a an AudioEncoderCNG, if VAD is enabled.
   if (spec.cng_payload_type) {
-    AudioEncoderCng::Config cng_config;
+    AudioEncoderCngConfig cng_config;
     cng_config.num_channels = encoder->NumChannels();
     cng_config.payload_type = *spec.cng_payload_type;
     cng_config.speech_encoder = std::move(encoder);
     cng_config.vad_mode = Vad::kVadNormal;
-    encoder.reset(new AudioEncoderCng(std::move(cng_config)));
+    encoder = CreateComfortNoiseEncoder(std::move(cng_config));
 
     stream->RegisterCngPayloadType(
         *spec.cng_payload_type,
@@ -679,12 +750,12 @@
           old_encoder = std::move(tmp);
         }
         if (new_config.send_codec_spec->cng_payload_type) {
-          AudioEncoderCng::Config config;
+          AudioEncoderCngConfig config;
           config.speech_encoder = std::move(old_encoder);
           config.num_channels = config.speech_encoder->NumChannels();
           config.payload_type = *new_config.send_codec_spec->cng_payload_type;
           config.vad_mode = Vad::kVadNormal;
-          encoder_ptr->reset(new AudioEncoderCng(std::move(config)));
+          *encoder_ptr = CreateComfortNoiseEncoder(std::move(config));
         } else {
           *encoder_ptr = std::move(old_encoder);
         }
@@ -711,13 +782,16 @@
 
   bool has_transport_sequence_number = new_transport_seq_num_id != 0;
   if (new_config.min_bitrate_bps != -1 && new_config.max_bitrate_bps != -1 &&
+      !new_config.has_dscp &&
       (has_transport_sequence_number ||
        !webrtc::field_trial::IsEnabled("WebRTC-Audio-SendSideBwe"))) {
+    stream->rtp_transport_->packet_sender()->SetAccountForAudioPackets(true);
     stream->ConfigureBitrateObserver(
         new_config.min_bitrate_bps, new_config.max_bitrate_bps,
         new_config.bitrate_priority, has_transport_sequence_number);
     stream->rtp_rtcp_module_->SetAsPartOfAllocation(true);
   } else {
+    stream->rtp_transport_->packet_sender()->SetAccountForAudioPackets(false);
     stream->RemoveBitrateObserver();
     stream->rtp_rtcp_module_->SetAsPartOfAllocation(false);
   }
@@ -729,7 +803,7 @@
                                                bool has_packet_feedback) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   RTC_DCHECK_GE(max_bitrate_bps, min_bitrate_bps);
-  rtc::Event thread_sync_event(false /* manual_reset */, false);
+  rtc::Event thread_sync_event;
   worker_queue_->PostTask([&] {
     // We may get a callback immediately as the observer is registered, so make
     // sure the bitrate limits in config_ are up-to-date.
@@ -749,7 +823,7 @@
 
 void AudioSendStream::RemoveBitrateObserver() {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  rtc::Event thread_sync_event(false /* manual_reset */, false);
+  rtc::Event thread_sync_event;
   worker_queue_->PostTask([this, &thread_sync_event] {
     bitrate_allocator_->RemoveObserver(this);
     thread_sync_event.Set();
diff --git a/audio/audio_send_stream.h b/audio/audio_send_stream.h
index 1ea676b..c86a9dc 100644
--- a/audio/audio_send_stream.h
+++ b/audio/audio_send_stream.h
@@ -45,8 +45,8 @@
                   const rtc::scoped_refptr<webrtc::AudioState>& audio_state,
                   rtc::TaskQueue* worker_queue,
                   ProcessThread* module_process_thread,
-                  RtpTransportControllerSendInterface* transport,
-                  BitrateAllocator* bitrate_allocator,
+                  RtpTransportControllerSendInterface* rtp_transport,
+                  BitrateAllocatorInterface* bitrate_allocator,
                   RtcEventLog* event_log,
                   RtcpRttStats* rtcp_rtt_stats,
                   const absl::optional<RtpState>& suspended_rtp_state,
@@ -55,8 +55,8 @@
   AudioSendStream(const webrtc::AudioSendStream::Config& config,
                   const rtc::scoped_refptr<webrtc::AudioState>& audio_state,
                   rtc::TaskQueue* worker_queue,
-                  RtpTransportControllerSendInterface* transport,
-                  BitrateAllocator* bitrate_allocator,
+                  RtpTransportControllerSendInterface* rtp_transport,
+                  BitrateAllocatorInterface* bitrate_allocator,
                   RtcEventLog* event_log,
                   RtcpRttStats* rtcp_rtt_stats,
                   const absl::optional<RtpState>& suspended_rtp_state,
@@ -83,10 +83,7 @@
   bool DeliverRtcp(const uint8_t* packet, size_t length);
 
   // Implements BitrateAllocatorObserver.
-  uint32_t OnBitrateUpdated(uint32_t bitrate_bps,
-                            uint8_t fraction_loss,
-                            int64_t rtt,
-                            int64_t bwe_period_ms) override;
+  uint32_t OnBitrateUpdated(BitrateAllocationUpdate update) override;
 
   // From PacketFeedbackObserver.
   void OnPacketAdded(uint32_t ssrc, uint16_t seq_num) override;
@@ -140,8 +137,8 @@
   size_t encoder_num_channels_ = 0;
   bool sending_ = false;
 
-  BitrateAllocator* const bitrate_allocator_;
-  RtpTransportControllerSendInterface* const transport_;
+  BitrateAllocatorInterface* const bitrate_allocator_;
+  RtpTransportControllerSendInterface* const rtp_transport_;
 
   rtc::CriticalSection packet_loss_tracker_cs_;
   TransportFeedbackPacketLossTracker packet_loss_tracker_
diff --git a/audio/audio_send_stream_unittest.cc b/audio/audio_send_stream_unittest.cc
index 0a954f8..6a92329 100644
--- a/audio/audio_send_stream_unittest.cc
+++ b/audio/audio_send_stream_unittest.cc
@@ -13,6 +13,7 @@
 #include <vector>
 
 #include "absl/memory/memory.h"
+#include "api/test/mock_frame_encryptor.h"
 #include "api/units/time_delta.h"
 #include "audio/audio_send_stream.h"
 #include "audio/audio_state.h"
@@ -128,7 +129,7 @@
 
 struct ConfigHelper {
   ConfigHelper(bool audio_bwe_enabled, bool expect_set_encoder_call)
-      : stream_config_(nullptr),
+      : stream_config_(/*send_transport=*/nullptr, /*media_transport=*/nullptr),
         audio_processing_(new rtc::RefCountedObject<MockAudioProcessing>()),
         bitrate_allocator_(&limit_observer_),
         worker_queue_("ConfigHelper_worker_queue"),
@@ -196,7 +197,8 @@
     EXPECT_CALL(*channel_proxy_, SetLocalSSRC(kSsrc)).Times(1);
     EXPECT_CALL(*channel_proxy_, SetRTCP_CNAME(StrEq(kCName))).Times(1);
     EXPECT_CALL(*channel_proxy_, SetNACKStatus(true, 10)).Times(1);
-    EXPECT_CALL(*channel_proxy_, SetFrameEncryptor(nullptr)).Times(1);
+    EXPECT_CALL(*channel_proxy_, SetFrameEncryptor(_)).Times(1);
+    EXPECT_CALL(*channel_proxy_, SetExtmapAllowMixed(false)).Times(1);
     EXPECT_CALL(*channel_proxy_,
                 SetSendAudioLevelIndicationStatus(true, kAudioLevelId))
         .Times(1);
@@ -278,6 +280,7 @@
         .WillRepeatedly(Return(report_blocks));
     EXPECT_CALL(*channel_proxy_, GetANAStatistics())
         .WillRepeatedly(Return(ANAStats()));
+    EXPECT_CALL(*channel_proxy_, GetBitrate()).WillRepeatedly(Return(0));
 
     audio_processing_stats_.echo_return_loss = kEchoReturnLoss;
     audio_processing_stats_.echo_return_loss_enhancement =
@@ -316,7 +319,8 @@
 }  // namespace
 
 TEST(AudioSendStreamTest, ConfigToString) {
-  AudioSendStream::Config config(nullptr);
+  AudioSendStream::Config config(/*send_transport=*/nullptr,
+                                 /*media_transport=*/nullptr);
   config.rtp.ssrc = kSsrc;
   config.rtp.c_name = kCName;
   config.min_bitrate_bps = 12000;
@@ -327,12 +331,14 @@
   config.send_codec_spec->transport_cc_enabled = false;
   config.send_codec_spec->cng_payload_type = 42;
   config.encoder_factory = MockAudioEncoderFactory::CreateUnusedFactory();
+  config.rtp.extmap_allow_mixed = true;
   config.rtp.extensions.push_back(
       RtpExtension(RtpExtension::kAudioLevelUri, kAudioLevelId));
   EXPECT_EQ(
-      "{rtp: {ssrc: 1234, extensions: [{uri: "
+      "{rtp: {ssrc: 1234, extmap-allow-mixed: true, extensions: [{uri: "
       "urn:ietf:params:rtp-hdrext:ssrc-audio-level, id: 2}], nack: "
       "{rtp_history_ms: 0}, c_name: foo_name}, send_transport: null, "
+      "media_transport: null, "
       "min_bitrate_bps: 12000, max_bitrate_bps: 34000, "
       "send_codec_spec: {nack_enabled: true, transport_cc_enabled: false, "
       "cng_payload_type: 42, payload_type: 103, "
@@ -470,15 +476,24 @@
   auto send_stream = helper.CreateAudioSendStream();
   EXPECT_CALL(*helper.channel_proxy(),
               SetBitrate(helper.config().max_bitrate_bps, _));
-  send_stream->OnBitrateUpdated(helper.config().max_bitrate_bps + 5000, 0.0, 50,
-                                6000);
+  BitrateAllocationUpdate update;
+  update.bitrate_bps = helper.config().max_bitrate_bps + 5000;
+  update.fraction_loss = 0;
+  update.rtt = 50;
+  update.bwe_period_ms = 6000;
+  send_stream->OnBitrateUpdated(update);
 }
 
 TEST(AudioSendStreamTest, ProbingIntervalOnBitrateUpdated) {
   ConfigHelper helper(false, true);
   auto send_stream = helper.CreateAudioSendStream();
   EXPECT_CALL(*helper.channel_proxy(), SetBitrate(_, 5000));
-  send_stream->OnBitrateUpdated(50000, 0.0, 50, 5000);
+  BitrateAllocationUpdate update;
+  update.bitrate_bps = helper.config().max_bitrate_bps + 5000;
+  update.fraction_loss = 0;
+  update.rtt = 50;
+  update.bwe_period_ms = 5000;
+  send_stream->OnBitrateUpdated(update);
 }
 
 // Test that AudioSendStream doesn't recreate the encoder unnecessarily.
@@ -518,6 +533,32 @@
   send_stream->Reconfigure(new_config);
 }
 
+// Validates that reconfiguring the AudioSendStream with a Frame encryptor
+// correctly reconfigures on the object without crashing.
+TEST(AudioSendStreamTest, ReconfigureWithFrameEncryptor) {
+  ConfigHelper helper(false, true);
+  auto send_stream = helper.CreateAudioSendStream();
+  auto new_config = helper.config();
+
+  rtc::scoped_refptr<FrameEncryptorInterface> mock_frame_encryptor_0(
+      new rtc::RefCountedObject<MockFrameEncryptor>());
+  new_config.frame_encryptor = mock_frame_encryptor_0;
+  EXPECT_CALL(*helper.channel_proxy(), SetFrameEncryptor(Ne(nullptr))).Times(1);
+  send_stream->Reconfigure(new_config);
+
+  // Not updating the frame encryptor shouldn't force it to reconfigure.
+  EXPECT_CALL(*helper.channel_proxy(), SetFrameEncryptor(_)).Times(0);
+  send_stream->Reconfigure(new_config);
+
+  // Updating frame encryptor to a new object should force a call to the proxy.
+  rtc::scoped_refptr<FrameEncryptorInterface> mock_frame_encryptor_1(
+      new rtc::RefCountedObject<MockFrameEncryptor>());
+  new_config.frame_encryptor = mock_frame_encryptor_1;
+  new_config.crypto_options.sframe.require_frame_encryption = true;
+  EXPECT_CALL(*helper.channel_proxy(), SetFrameEncryptor(Ne(nullptr))).Times(1);
+  send_stream->Reconfigure(new_config);
+}
+
 // Checks that AudioSendStream logs the times at which RTP packets are sent
 // through its interface.
 TEST(AudioSendStreamTest, UpdateLifetime) {
diff --git a/audio/audio_transport_impl.cc b/audio/audio_transport_impl.cc
index 94ef6cb..539456e 100644
--- a/audio/audio_transport_impl.cc
+++ b/audio/audio_transport_impl.cc
@@ -17,7 +17,7 @@
 #include "audio/remix_resample.h"
 #include "audio/utility/audio_frame_operations.h"
 #include "call/audio_send_stream.h"
-#include "rtc_base/logging.h"
+#include "rtc_base/checks.h"
 
 namespace webrtc {
 
diff --git a/audio/channel_receive.cc b/audio/channel_receive.cc
index e9f7503..704ba79 100644
--- a/audio/channel_receive.cc
+++ b/audio/channel_receive.cc
@@ -26,6 +26,7 @@
 #include "modules/audio_device/include/audio_device.h"
 #include "modules/pacing/packet_router.h"
 #include "modules/rtp_rtcp/include/receive_statistics.h"
+#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
 #include "modules/rtp_rtcp/source/rtp_packet_received.h"
 #include "modules/utility/include/process_thread.h"
 #include "rtc_base/checks.h"
@@ -50,12 +51,47 @@
 constexpr int kVoiceEngineMinMinPlayoutDelayMs = 0;
 constexpr int kVoiceEngineMaxMinPlayoutDelayMs = 10000;
 
+webrtc::FrameType WebrtcFrameTypeForMediaTransportFrameType(
+    MediaTransportEncodedAudioFrame::FrameType frame_type) {
+  switch (frame_type) {
+    case MediaTransportEncodedAudioFrame::FrameType::kSpeech:
+      return kAudioFrameSpeech;
+      break;
+
+    case MediaTransportEncodedAudioFrame::FrameType::
+        kDiscountinuousTransmission:
+      return kAudioFrameCN;
+      break;
+  }
+}
+
+WebRtcRTPHeader CreateWebrtcRTPHeaderForMediaTransportFrame(
+    const MediaTransportEncodedAudioFrame& frame,
+    uint64_t channel_id) {
+  webrtc::WebRtcRTPHeader webrtc_header = {};
+  webrtc_header.header.payloadType = frame.payload_type();
+  webrtc_header.header.payload_type_frequency = frame.sampling_rate_hz();
+  webrtc_header.header.timestamp = frame.starting_sample_index();
+  webrtc_header.header.sequenceNumber = frame.sequence_number();
+
+  webrtc_header.frameType =
+      WebrtcFrameTypeForMediaTransportFrameType(frame.frame_type());
+
+  webrtc_header.header.ssrc = static_cast<uint32_t>(channel_id);
+
+  // The rest are initialized by the RTPHeader constructor.
+  return webrtc_header;
+}
+
 }  // namespace
 
 int32_t ChannelReceive::OnReceivedPayloadData(
     const uint8_t* payloadData,
     size_t payloadSize,
     const WebRtcRTPHeader* rtpHeader) {
+  // We should not be receiving any RTP packets if media_transport is set.
+  RTC_CHECK(!media_transport_);
+
   if (!channel_state_.Get().playing) {
     // Avoid inserting into NetEQ when we are not playing. Count the
     // packet as discarded.
@@ -82,6 +118,27 @@
   return 0;
 }
 
+// MediaTransportAudioSinkInterface override.
+void ChannelReceive::OnData(uint64_t channel_id,
+                            MediaTransportEncodedAudioFrame frame) {
+  RTC_CHECK(media_transport_);
+
+  if (!channel_state_.Get().playing) {
+    // Avoid inserting into NetEQ when we are not playing. Count the
+    // packet as discarded.
+    return;
+  }
+
+  // Send encoded audio frame to Decoder / NetEq.
+  if (audio_coding_->IncomingPacket(
+          frame.encoded_data().data(), frame.encoded_data().size(),
+          CreateWebrtcRTPHeaderForMediaTransportFrame(frame, channel_id)) !=
+      0) {
+    RTC_DLOG(LS_ERROR) << "ChannelReceive::OnData: unable to "
+                          "push data to the ACM";
+  }
+}
+
 AudioMixer::Source::AudioFrameInfo ChannelReceive::GetAudioFrameWithInfo(
     int sample_rate_hz,
     AudioFrame* audio_frame) {
@@ -199,6 +256,7 @@
 ChannelReceive::ChannelReceive(
     ProcessThread* module_process_thread,
     AudioDeviceModule* audio_device_module,
+    MediaTransportInterface* media_transport,
     Transport* rtcp_send_transport,
     RtcEventLog* rtc_event_log,
     uint32_t remote_ssrc,
@@ -206,7 +264,8 @@
     bool jitter_buffer_fast_playout,
     rtc::scoped_refptr<AudioDecoderFactory> decoder_factory,
     absl::optional<AudioCodecPairId> codec_pair_id,
-    FrameDecryptorInterface* frame_decryptor)
+    rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor,
+    const webrtc::CryptoOptions& crypto_options)
     : event_log_(rtc_event_log),
       rtp_receive_statistics_(
           ReceiveStatistics::Create(Clock::GetRealTimeClock())),
@@ -222,7 +281,9 @@
       _audioDeviceModulePtr(audio_device_module),
       _outputGain(1.0f),
       associated_send_channel_(nullptr),
-      frame_decryptor_(frame_decryptor) {
+      media_transport_(media_transport),
+      frame_decryptor_(frame_decryptor),
+      crypto_options_(crypto_options) {
   RTC_DCHECK(module_process_thread);
   RTC_DCHECK(audio_device_module);
   AudioCodingModule::Config acm_config;
@@ -238,9 +299,7 @@
   rtp_receive_statistics_->EnableRetransmitDetection(remote_ssrc_, true);
   RtpRtcp::Configuration configuration;
   configuration.audio = true;
-  // TODO(nisse): Also set receiver_only = true, but that seems to break RTT
-  // estimation, resulting in test failures for
-  // PeerConnectionIntegrationTest.GetCaptureStartNtpTimeWithOldStatsApi
+  configuration.receiver_only = true;
   configuration.outgoing_transport = rtcp_send_transport;
   configuration.receive_statistics = rtp_receive_statistics_.get();
 
@@ -276,10 +335,19 @@
   // be transmitted since the Transport object will then be invalid.
   // RTCP is enabled by default.
   _rtpRtcpModule->SetRTCPStatus(RtcpMode::kCompound);
+
+  if (media_transport_) {
+    media_transport_->SetReceiveAudioSink(this);
+  }
 }
 
 void ChannelReceive::Terminate() {
   RTC_DCHECK(construction_thread_.CalledOnValidThread());
+
+  if (media_transport_) {
+    media_transport_->SetReceiveAudioSink(nullptr);
+  }
+
   // Must be called on the same thread as Init().
   rtp_receive_statistics_->RegisterRtcpStatisticsCallback(NULL);
 
@@ -369,7 +437,9 @@
     if (has_audio_level)
       last_received_rtp_audio_level_ = audio_level;
     std::vector<uint32_t> csrcs = packet.Csrcs();
-    contributing_sources_.Update(now_ms, csrcs);
+    contributing_sources_.Update(
+        now_ms, csrcs,
+        has_audio_level ? absl::optional<uint8_t>(audio_level) : absl::nullopt);
   }
 
   // Store playout timestamp for the received RTP packet
@@ -429,6 +499,10 @@
     // Update the final payload.
     payload = decrypted_audio_payload.data();
     payload_data_length = decrypted_audio_payload.size();
+  } else if (crypto_options_.sframe.require_frame_encryption) {
+    RTC_DLOG(LS_ERROR)
+        << "FrameDecryptor required but not set, dropping packet";
+    payload_data_length = 0;
   }
 
   if (payload_data_length == 0) {
@@ -705,6 +779,8 @@
   int64_t avg_rtt = 0;
   int64_t max_rtt = 0;
   int64_t min_rtt = 0;
+  // TODO(nisse): This method computes RTT based on sender reports, even though
+  // a receive stream is not supposed to do that.
   if (_rtpRtcpModule->RTT(remote_ssrc_, &rtt, &avg_rtt, &min_rtt, &max_rtt) !=
       0) {
     return 0;
diff --git a/audio/channel_receive.h b/audio/channel_receive.h
index 82eb4df..0c50962 100644
--- a/audio/channel_receive.h
+++ b/audio/channel_receive.h
@@ -19,6 +19,8 @@
 #include "api/audio/audio_mixer.h"
 #include "api/call/audio_sink.h"
 #include "api/call/transport.h"
+#include "api/crypto/cryptooptions.h"
+#include "api/media_transport_interface.h"
 #include "api/rtpreceiverinterface.h"
 #include "audio/audio_level.h"
 #include "call/syncable.h"
@@ -102,11 +104,12 @@
   State state_;
 };
 
-class ChannelReceive : public RtpData {
+class ChannelReceive : public RtpData, public MediaTransportAudioSinkInterface {
  public:
   // Used for receive streams.
   ChannelReceive(ProcessThread* module_process_thread,
                  AudioDeviceModule* audio_device_module,
+                 MediaTransportInterface* media_transport,
                  Transport* rtcp_send_transport,
                  RtcEventLog* rtc_event_log,
                  uint32_t remote_ssrc,
@@ -114,7 +117,8 @@
                  bool jitter_buffer_fast_playout,
                  rtc::scoped_refptr<AudioDecoderFactory> decoder_factory,
                  absl::optional<AudioCodecPairId> codec_pair_id,
-                 FrameDecryptorInterface* frame_decryptor);
+                 rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor,
+                 const webrtc::CryptoOptions& crypto_options);
   virtual ~ChannelReceive();
 
   void SetSink(AudioSinkInterface* sink);
@@ -163,6 +167,10 @@
   int GetRTPStatistics(CallReceiveStatistics& stats);  // NOLINT
   void SetNACKStatus(bool enable, int maxNumberOfPackets);
 
+  // MediaTransportAudioSinkInterface override;
+  void OnData(uint64_t channel_id,
+              MediaTransportEncodedAudioFrame frame) override;
+
   // From RtpData in the RTP/RTCP module
   int32_t OnReceivedPayloadData(const uint8_t* payloadData,
                                 size_t payloadSize,
@@ -257,8 +265,11 @@
 
   rtc::ThreadChecker construction_thread_;
 
+  MediaTransportInterface* const media_transport_;
+
   // E2EE Audio Frame Decryption
-  FrameDecryptorInterface* frame_decryptor_ = nullptr;
+  rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor_;
+  webrtc::CryptoOptions crypto_options_;
 };
 
 }  // namespace voe
diff --git a/audio/channel_receive_proxy.cc b/audio/channel_receive_proxy.cc
index b1c1c45..1dee640 100644
--- a/audio/channel_receive_proxy.cc
+++ b/audio/channel_receive_proxy.cc
@@ -14,7 +14,6 @@
 
 #include "api/call/audio_sink.h"
 #include "audio/channel_send_proxy.h"
-#include "call/rtp_transport_controller_send_interface.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/numerics/safe_minmax.h"
diff --git a/audio/channel_send.cc b/audio/channel_send.cc
index 8639fbd..c0de939 100644
--- a/audio/channel_send.cc
+++ b/audio/channel_send.cc
@@ -48,6 +48,24 @@
 constexpr int64_t kMaxRetransmissionWindowMs = 1000;
 constexpr int64_t kMinRetransmissionWindowMs = 30;
 
+MediaTransportEncodedAudioFrame::FrameType
+MediaTransportFrameTypeForWebrtcFrameType(webrtc::FrameType frame_type) {
+  switch (frame_type) {
+    case kAudioFrameSpeech:
+      return MediaTransportEncodedAudioFrame::FrameType::kSpeech;
+      break;
+
+    case kAudioFrameCN:
+      return MediaTransportEncodedAudioFrame::FrameType::
+          kDiscontinuousTransmission;
+      break;
+
+    default:
+      RTC_CHECK(false) << "Unexpected frame type=" << frame_type;
+      break;
+  }
+}
+
 }  // namespace
 
 const int kTelephoneEventAttenuationdB = 10;
@@ -255,6 +273,23 @@
                               size_t payloadSize,
                               const RTPFragmentationHeader* fragmentation) {
   RTC_DCHECK_RUN_ON(encoder_queue_);
+  rtc::ArrayView<const uint8_t> payload(payloadData, payloadSize);
+
+  if (media_transport() != nullptr) {
+    return SendMediaTransportAudio(frameType, payloadType, timeStamp, payload,
+                                   fragmentation);
+  } else {
+    return SendRtpAudio(frameType, payloadType, timeStamp, payload,
+                        fragmentation);
+  }
+}
+
+int32_t ChannelSend::SendRtpAudio(FrameType frameType,
+                                  uint8_t payloadType,
+                                  uint32_t timeStamp,
+                                  rtc::ArrayView<const uint8_t> payload,
+                                  const RTPFragmentationHeader* fragmentation) {
+  RTC_DCHECK_RUN_ON(encoder_queue_);
   if (_includeAudioLevelIndication) {
     // Store current audio level in the RTP/RTCP module.
     // The level will be used in combination with voice-activity state
@@ -269,16 +304,15 @@
     // TODO(benwright@webrtc.org) - Allocate enough to always encrypt inline.
     // Allocate a buffer to hold the maximum possible encrypted payload.
     size_t max_ciphertext_size = frame_encryptor_->GetMaxCiphertextByteSize(
-        cricket::MEDIA_TYPE_AUDIO, payloadSize);
+        cricket::MEDIA_TYPE_AUDIO, payload.size());
     encrypted_audio_payload.SetSize(max_ciphertext_size);
 
     // Encrypt the audio payload into the buffer.
     size_t bytes_written = 0;
     int encrypt_status = frame_encryptor_->Encrypt(
         cricket::MEDIA_TYPE_AUDIO, _rtpRtcpModule->SSRC(),
-        /*additional_data=*/nullptr,
-        rtc::ArrayView<const uint8_t>(payloadData, payloadSize),
-        encrypted_audio_payload, &bytes_written);
+        /*additional_data=*/nullptr, payload, encrypted_audio_payload,
+        &bytes_written);
     if (encrypt_status != 0) {
       RTC_DLOG(LS_ERROR) << "Channel::SendData() failed encrypt audio payload: "
                          << encrypt_status;
@@ -287,19 +321,23 @@
     // Resize the buffer to the exact number of bytes actually used.
     encrypted_audio_payload.SetSize(bytes_written);
     // Rewrite the payloadData and size to the new encrypted payload.
-    payloadData = encrypted_audio_payload.data();
-    payloadSize = encrypted_audio_payload.size();
+    payload = encrypted_audio_payload;
+  } else if (crypto_options_.sframe.require_frame_encryption) {
+    RTC_DLOG(LS_ERROR) << "Channel::SendData() failed sending audio payload: "
+                       << "A frame encryptor is required but one is not set.";
+    return -1;
   }
 
   // Push data from ACM to RTP/RTCP-module to deliver audio frame for
   // packetization.
   // This call will trigger Transport::SendPacket() from the RTP/RTCP module.
-  if (!_rtpRtcpModule->SendOutgoingData(
-          (FrameType&)frameType, payloadType, timeStamp,
-          // Leaving the time when this frame was
-          // received from the capture device as
-          // undefined for voice for now.
-          -1, payloadData, payloadSize, fragmentation, nullptr, nullptr)) {
+  if (!_rtpRtcpModule->SendOutgoingData((FrameType&)frameType, payloadType,
+                                        timeStamp,
+                                        // Leaving the time when this frame was
+                                        // received from the capture device as
+                                        // undefined for voice for now.
+                                        -1, payload.data(), payload.size(),
+                                        fragmentation, nullptr, nullptr)) {
     RTC_DLOG(LS_ERROR)
         << "ChannelSend::SendData() failed to send data to RTP/RTCP module";
     return -1;
@@ -308,9 +346,68 @@
   return 0;
 }
 
+int32_t ChannelSend::SendMediaTransportAudio(
+    FrameType frameType,
+    uint8_t payloadType,
+    uint32_t timeStamp,
+    rtc::ArrayView<const uint8_t> payload,
+    const RTPFragmentationHeader* fragmentation) {
+  RTC_DCHECK_RUN_ON(encoder_queue_);
+  // TODO(nisse): Use null _transportPtr for MediaTransport.
+  // RTC_DCHECK(_transportPtr == nullptr);
+  uint64_t channel_id;
+  int sampling_rate_hz;
+  {
+    rtc::CritScope cs(&media_transport_lock_);
+    if (media_transport_payload_type_ != payloadType) {
+      // Payload type is being changed, media_transport_sampling_frequency_,
+      // no longer current.
+      return -1;
+    }
+    sampling_rate_hz = media_transport_sampling_frequency_;
+    channel_id = media_transport_channel_id_;
+  }
+  const MediaTransportEncodedAudioFrame frame(
+      /*sampling_rate_hz=*/sampling_rate_hz,
+
+      // TODO(nisse): Timestamp and sample index are the same for all supported
+      // audio codecs except G722. Refactor audio coding module to only use
+      // sample index, and leave translation to RTP time, when needed, for
+      // RTP-specific code.
+      /*starting_sample_index=*/timeStamp,
+
+      // Sample count isn't conveniently available from the AudioCodingModule,
+      // and needs some refactoring to wire up in a good way. For now, left as
+      // zero.
+      /*sample_count=*/0,
+
+      /*sequence_number=*/media_transport_sequence_number_,
+      MediaTransportFrameTypeForWebrtcFrameType(frameType), payloadType,
+      std::vector<uint8_t>(payload.begin(), payload.end()));
+
+  // TODO(nisse): Introduce a MediaTransportSender object bound to a specific
+  // channel id.
+  RTCError rtc_error =
+      media_transport()->SendAudioFrame(channel_id, std::move(frame));
+
+  if (!rtc_error.ok()) {
+    RTC_LOG(LS_ERROR) << "Failed to send frame, rtc_error="
+                      << ToString(rtc_error.type()) << ", "
+                      << rtc_error.message();
+    return -1;
+  }
+
+  ++media_transport_sequence_number_;
+
+  return 0;
+}
+
 bool ChannelSend::SendRtp(const uint8_t* data,
                           size_t len,
                           const PacketOptions& options) {
+  // We should not be sending RTP packets if media transport is available.
+  RTC_CHECK(!media_transport());
+
   rtc::CritScope cs(&_callbackCritSect);
 
   if (_transportPtr == NULL) {
@@ -352,9 +449,12 @@
 
 ChannelSend::ChannelSend(rtc::TaskQueue* encoder_queue,
                          ProcessThread* module_process_thread,
+                         MediaTransportInterface* media_transport,
                          RtcpRttStats* rtcp_rtt_stats,
                          RtcEventLog* rtc_event_log,
-                         FrameEncryptorInterface* frame_encryptor)
+                         FrameEncryptorInterface* frame_encryptor,
+                         const webrtc::CryptoOptions& crypto_options,
+                         bool extmap_allow_mixed)
     : event_log_(rtc_event_log),
       _timeStamp(0),  // This is just an offset, RTP module will add it's own
                       // random offset
@@ -375,7 +475,9 @@
       use_twcc_plr_for_ana_(
           webrtc::field_trial::FindFullName("UseTwccPlrForAna") == "Enabled"),
       encoder_queue_(encoder_queue),
-      frame_encryptor_(frame_encryptor) {
+      media_transport_(media_transport),
+      frame_encryptor_(frame_encryptor),
+      crypto_options_(crypto_options) {
   RTC_DCHECK(module_process_thread);
   RTC_DCHECK(encoder_queue);
   audio_coding_.reset(AudioCodingModule::Create(AudioCodingModule::Config()));
@@ -395,6 +497,7 @@
   configuration.rtt_stats = rtcp_rtt_stats;
   configuration.retransmission_rate_limiter =
       retransmission_rate_limiter_.get();
+  configuration.extmap_allow_mixed = extmap_allow_mixed;
 
   _rtpRtcpModule.reset(RtpRtcp::CreateRtpRtcp(configuration));
   _rtpRtcpModule->SetSendingMediaStatus(false);
@@ -492,7 +595,7 @@
   // to acccess and invalid channel object.
   RTC_DCHECK(encoder_queue_);
 
-  rtc::Event flush(false, false);
+  rtc::Event flush;
   {
     // Clear |encoder_queue_is_active_| under lock to prevent any other tasks
     // than this final "flush task" to be posted on the queue.
@@ -550,6 +653,13 @@
     }
   }
 
+  if (media_transport_) {
+    rtc::CritScope cs(&media_transport_lock_);
+    media_transport_payload_type_ = payload_type;
+    // TODO(nisse): Currently broken for G722, since timestamps passed through
+    // encoder use RTP clock rather than sample count, and they differ for G722.
+    media_transport_sampling_frequency_ = encoder->RtpTimestampRateHz();
+  }
   audio_coding_->SetEncoder(std::move(encoder));
   return true;
 }
@@ -566,6 +676,11 @@
     }
   });
   retransmission_rate_limiter_->SetMaxRate(bitrate_bps);
+  configured_bitrate_bps_ = bitrate_bps;
+}
+
+int ChannelSend::GetBitRate() const {
+  return configured_bitrate_bps_;
 }
 
 void ChannelSend::OnTwccBasedUplinkPacketLossRate(float packet_loss_rate) {
@@ -709,6 +824,10 @@
     RTC_DLOG(LS_ERROR) << "SetLocalSSRC() already sending";
     return -1;
   }
+  if (media_transport_) {
+    rtc::CritScope cs(&media_transport_lock_);
+    media_transport_channel_id_ = ssrc;
+  }
   _rtpRtcpModule->SetSSRC(ssrc);
   return 0;
 }
@@ -719,6 +838,10 @@
   _rtpRtcpModule->SetMid(mid);
 }
 
+void ChannelSend::SetExtmapAllowMixed(bool extmap_allow_mixed) {
+  _rtpRtcpModule->SetExtmapAllowMixed(extmap_allow_mixed);
+}
+
 int ChannelSend::SetSendAudioLevelIndicationStatus(bool enable,
                                                    unsigned char id) {
   _includeAudioLevelIndication = enable;
@@ -982,14 +1105,15 @@
   return rtt;
 }
 
-void ChannelSend::SetFrameEncryptor(FrameEncryptorInterface* frame_encryptor) {
+void ChannelSend::SetFrameEncryptor(
+    rtc::scoped_refptr<FrameEncryptorInterface> frame_encryptor) {
   rtc::CritScope cs(&encoder_queue_lock_);
   if (encoder_queue_is_active_) {
     encoder_queue_->PostTask([this, frame_encryptor]() {
-      this->frame_encryptor_ = frame_encryptor;
+      this->frame_encryptor_ = std::move(frame_encryptor);
     });
   } else {
-    frame_encryptor_ = frame_encryptor;
+    frame_encryptor_ = std::move(frame_encryptor);
   }
 }
 
diff --git a/audio/channel_send.h b/audio/channel_send.h
index ef92f8e..407303f 100644
--- a/audio/channel_send.h
+++ b/audio/channel_send.h
@@ -19,6 +19,8 @@
 #include "api/audio/audio_frame.h"
 #include "api/audio_codecs/audio_encoder.h"
 #include "api/call/transport.h"
+#include "api/crypto/cryptooptions.h"
+#include "api/media_transport_interface.h"
 #include "common_types.h"  // NOLINT(build/include)
 #include "modules/audio_coding/include/audio_coding_module.h"
 #include "modules/audio_processing/rms_level.h"
@@ -118,9 +120,12 @@
 
   ChannelSend(rtc::TaskQueue* encoder_queue,
               ProcessThread* module_process_thread,
+              MediaTransportInterface* media_transport,
               RtcpRttStats* rtcp_rtt_stats,
               RtcEventLog* rtc_event_log,
-              FrameEncryptorInterface* frame_encryptor);
+              FrameEncryptorInterface* frame_encryptor,
+              const webrtc::CryptoOptions& crypto_options,
+              bool extmap_allow_mixed);
 
   virtual ~ChannelSend();
 
@@ -137,6 +142,7 @@
 
   // Codecs
   void SetBitRate(int bitrate_bps, int64_t probing_interval_ms);
+  int GetBitRate() const;
   bool EnableAudioNetworkAdaptor(const std::string& config_string);
   void DisableAudioNetworkAdaptor();
 
@@ -166,6 +172,7 @@
   int SetLocalSSRC(unsigned int ssrc);
 
   void SetMid(const std::string& mid, int extension_id);
+  void SetExtmapAllowMixed(bool extmap_allow_mixed);
   int SetSendAudioLevelIndicationStatus(bool enable, unsigned char id);
   void EnableSendTransportSequenceNumber(int id);
 
@@ -225,7 +232,8 @@
   int64_t GetRTT() const;
 
   // E2EE Custom Audio Frame Encryption
-  void SetFrameEncryptor(FrameEncryptorInterface* frame_encryptor);
+  void SetFrameEncryptor(
+      rtc::scoped_refptr<FrameEncryptorInterface> frame_encryptor);
 
  private:
   class ProcessAndEncodeAudioTask;
@@ -247,6 +255,21 @@
 
   int GetRtpTimestampRateHz() const;
 
+  int32_t SendRtpAudio(FrameType frameType,
+                       uint8_t payloadType,
+                       uint32_t timeStamp,
+                       rtc::ArrayView<const uint8_t> payload,
+                       const RTPFragmentationHeader* fragmentation);
+
+  int32_t SendMediaTransportAudio(FrameType frameType,
+                                  uint8_t payloadType,
+                                  uint32_t timeStamp,
+                                  rtc::ArrayView<const uint8_t> payload,
+                                  const RTPFragmentationHeader* fragmentation);
+
+  // Return media transport or nullptr if using RTP.
+  MediaTransportInterface* media_transport() { return media_transport_; }
+
   // Called on the encoder task queue when a new input audio frame is ready
   // for encoding.
   void ProcessAndEncodeAudioOnTaskQueue(AudioFrame* audio_input);
@@ -296,8 +319,25 @@
   bool encoder_queue_is_active_ RTC_GUARDED_BY(encoder_queue_lock_) = false;
   rtc::TaskQueue* encoder_queue_ = nullptr;
 
+  MediaTransportInterface* const media_transport_;
+  int media_transport_sequence_number_ RTC_GUARDED_BY(encoder_queue_) = 0;
+
+  rtc::CriticalSection media_transport_lock_;
+  // Currently set by SetLocalSSRC.
+  uint64_t media_transport_channel_id_ RTC_GUARDED_BY(&media_transport_lock_) =
+      0;
+  // Cache payload type and sampling frequency from most recent call to
+  // SetEncoder. Needed to set MediaTransportEncodedAudioFrame metadata, and
+  // invalidate on encoder change.
+  int media_transport_payload_type_ RTC_GUARDED_BY(&media_transport_lock_);
+  int media_transport_sampling_frequency_
+      RTC_GUARDED_BY(&media_transport_lock_);
+
   // E2EE Audio Frame Encryption
-  FrameEncryptorInterface* frame_encryptor_ = nullptr;
+  rtc::scoped_refptr<FrameEncryptorInterface> frame_encryptor_;
+  // E2EE Frame Encryption Options
+  webrtc::CryptoOptions crypto_options_;
+  int configured_bitrate_bps_ = 0;
 };
 
 }  // namespace voe
diff --git a/audio/channel_send_proxy.cc b/audio/channel_send_proxy.cc
index 8091bdc..2d0bdd3 100644
--- a/audio/channel_send_proxy.cc
+++ b/audio/channel_send_proxy.cc
@@ -12,11 +12,9 @@
 
 #include <utility>
 
-#include "api/call/audio_sink.h"
+#include "api/crypto/frameencryptorinterface.h"
 #include "call/rtp_transport_controller_send_interface.h"
 #include "rtc_base/checks.h"
-#include "rtc_base/logging.h"
-#include "rtc_base/numerics/safe_minmax.h"
 
 namespace webrtc {
 namespace voe {
@@ -90,6 +88,11 @@
   RTC_DCHECK_EQ(0, error);
 }
 
+void ChannelSendProxy::SetExtmapAllowMixed(bool extmap_allow_mixed) {
+  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+  channel_->SetExtmapAllowMixed(extmap_allow_mixed);
+}
+
 void ChannelSendProxy::SetSendAudioLevelIndicationStatus(bool enable, int id) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   int error = channel_->SetSendAudioLevelIndicationStatus(enable, id);
@@ -150,6 +153,10 @@
   channel_->SetBitRate(bitrate_bps, probing_interval_ms);
 }
 
+int ChannelSendProxy::GetBitrate() const {
+  return channel_->GetBitRate();
+}
+
 void ChannelSendProxy::SetInputMute(bool muted) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   channel_->SetInputMute(muted);
@@ -198,7 +205,7 @@
 }
 
 void ChannelSendProxy::SetFrameEncryptor(
-    FrameEncryptorInterface* frame_encryptor) {
+    rtc::scoped_refptr<FrameEncryptorInterface> frame_encryptor) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   channel_->SetFrameEncryptor(frame_encryptor);
 }
diff --git a/audio/channel_send_proxy.h b/audio/channel_send_proxy.h
index 1b8b4a0..3146830 100644
--- a/audio/channel_send_proxy.h
+++ b/audio/channel_send_proxy.h
@@ -58,6 +58,7 @@
   virtual void SetRTCPStatus(bool enable);
   virtual void SetMid(const std::string& mid, int extension_id);
   virtual void SetRTCP_CNAME(const std::string& c_name);
+  virtual void SetExtmapAllowMixed(bool extmap_allow_mixed);
   virtual void SetSendAudioLevelIndicationStatus(bool enable, int id);
   virtual void EnableSendTransportSequenceNumber(int id);
   virtual void RegisterSenderCongestionControlObjects(
@@ -70,6 +71,7 @@
                                                 int payload_frequency);
   virtual bool SendTelephoneEventOutband(int event, int duration_ms);
   virtual void SetBitrate(int bitrate_bps, int64_t probing_interval_ms);
+  virtual int GetBitrate() const;
   virtual void SetInputMute(bool muted);
 
   virtual void ProcessAndEncodeAudio(std::unique_ptr<AudioFrame> audio_frame);
@@ -86,7 +88,8 @@
   virtual ChannelSend* GetChannel() const;
 
   // E2EE Custom Audio Frame Encryption (Optional)
-  virtual void SetFrameEncryptor(FrameEncryptorInterface* frame_encryptor);
+  virtual void SetFrameEncryptor(
+      rtc::scoped_refptr<FrameEncryptorInterface> frame_encryptor);
 
  private:
   // Thread checkers document and lock usage of some methods on voe::Channel to
diff --git a/audio/mock_voe_channel_proxy.h b/audio/mock_voe_channel_proxy.h
index 910858f..962152f 100644
--- a/audio/mock_voe_channel_proxy.h
+++ b/audio/mock_voe_channel_proxy.h
@@ -16,6 +16,7 @@
 #include <string>
 #include <vector>
 
+#include "api/test/mock_frame_encryptor.h"
 #include "audio/channel_receive_proxy.h"
 #include "audio/channel_send_proxy.h"
 #include "modules/rtp_rtcp/source/rtp_packet_received.h"
@@ -75,6 +76,7 @@
   MOCK_METHOD1(SetLocalSSRC, void(uint32_t ssrc));
   MOCK_METHOD1(SetRTCP_CNAME, void(const std::string& c_name));
   MOCK_METHOD2(SetNACKStatus, void(bool enable, int max_packets));
+  MOCK_METHOD1(SetExtmapAllowMixed, void(bool extmap_allow_mixed));
   MOCK_METHOD2(SetSendAudioLevelIndicationStatus, void(bool enable, int id));
   MOCK_METHOD1(EnableSendTransportSequenceNumber, void(int id));
   MOCK_METHOD2(RegisterSenderCongestionControlObjects,
@@ -99,13 +101,15 @@
                void(std::unique_ptr<AudioFrame>* audio_frame));
   MOCK_METHOD1(SetTransportOverhead, void(int transport_overhead_per_packet));
   MOCK_CONST_METHOD0(GetRtpRtcp, RtpRtcp*());
+  MOCK_CONST_METHOD0(GetBitrate, int());
   MOCK_METHOD1(OnTwccBasedUplinkPacketLossRate, void(float packet_loss_rate));
   MOCK_METHOD1(OnRecoverableUplinkPacketLossRate,
                void(float recoverable_packet_loss_rate));
   MOCK_METHOD0(StartSend, void());
   MOCK_METHOD0(StopSend, void());
-  MOCK_METHOD1(SetFrameEncryptor,
-               void(FrameEncryptorInterface* frame_encryptor));
+  MOCK_METHOD1(
+      SetFrameEncryptor,
+      void(rtc::scoped_refptr<FrameEncryptorInterface> frame_encryptor));
 };
 }  // namespace test
 }  // namespace webrtc
diff --git a/audio/null_audio_poller.cc b/audio/null_audio_poller.cc
index bd5317b..d2b1199 100644
--- a/audio/null_audio_poller.cc
+++ b/audio/null_audio_poller.cc
@@ -9,9 +9,13 @@
  */
 
 #include "audio/null_audio_poller.h"
-#include "rtc_base/logging.h"
+
+#include <stddef.h>
+
+#include "rtc_base/checks.h"
+#include "rtc_base/location.h"
 #include "rtc_base/thread.h"
-#include "rtc_base/timeutils.h"  // for TimeMillis
+#include "rtc_base/timeutils.h"
 
 namespace webrtc {
 namespace internal {
diff --git a/audio/null_audio_poller.h b/audio/null_audio_poller.h
index afb6edb..f91eb7d 100644
--- a/audio/null_audio_poller.h
+++ b/audio/null_audio_poller.h
@@ -11,8 +11,11 @@
 #ifndef AUDIO_NULL_AUDIO_POLLER_H_
 #define AUDIO_NULL_AUDIO_POLLER_H_
 
+#include <stdint.h>
+
 #include "modules/audio_device/include/audio_device_defines.h"
 #include "rtc_base/messagehandler.h"
+#include "rtc_base/messagequeue.h"
 #include "rtc_base/thread_checker.h"
 
 namespace webrtc {
diff --git a/audio/remix_resample.cc b/audio/remix_resample.cc
index eda70c7..cc59e2a 100644
--- a/audio/remix_resample.cc
+++ b/audio/remix_resample.cc
@@ -13,10 +13,7 @@
 #include "api/audio/audio_frame.h"
 #include "audio/utility/audio_frame_operations.h"
 #include "common_audio/resampler/include/push_resampler.h"
-#include "common_audio/signal_processing/include/signal_processing_library.h"
-#include "common_types.h"  // NOLINT(build/include)
 #include "rtc_base/checks.h"
-#include "rtc_base/logging.h"
 
 namespace webrtc {
 namespace voe {
diff --git a/audio/transport_feedback_packet_loss_tracker.cc b/audio/transport_feedback_packet_loss_tracker.cc
index c7acd76..f41439b 100644
--- a/audio/transport_feedback_packet_loss_tracker.cc
+++ b/audio/transport_feedback_packet_loss_tracker.cc
@@ -10,11 +10,11 @@
 
 #include "audio/transport_feedback_packet_loss_tracker.h"
 
+#include <iterator>
 #include <limits>
 #include <utility>
 
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
-#include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/numerics/mod_ops.h"
 
diff --git a/audio/utility/audio_frame_operations.cc b/audio/utility/audio_frame_operations.cc
index fb1f3b0..1a8232b 100644
--- a/audio/utility/audio_frame_operations.cc
+++ b/audio/utility/audio_frame_operations.cc
@@ -12,6 +12,7 @@
 
 #include <string.h>
 #include <algorithm>
+#include <cstdint>
 
 #include "rtc_base/checks.h"
 #include "rtc_base/numerics/safe_conversions.h"
diff --git a/audio/utility/audio_frame_operations.h b/audio/utility/audio_frame_operations.h
index 5993523..c1445b6 100644
--- a/audio/utility/audio_frame_operations.h
+++ b/audio/utility/audio_frame_operations.h
@@ -12,6 +12,7 @@
 #define AUDIO_UTILITY_AUDIO_FRAME_OPERATIONS_H_
 
 #include <stddef.h>
+#include <stdint.h>
 
 #include "api/audio/audio_frame.h"
 
diff --git a/common_audio/BUILD.gn b/common_audio/BUILD.gn
index abcfe9a..911c050 100644
--- a/common_audio/BUILD.gn
+++ b/common_audio/BUILD.gn
@@ -51,6 +51,7 @@
     "../rtc_base:checks",
     "../rtc_base:gtest_prod",
     "../rtc_base:rtc_base_approved",
+    "../rtc_base:sanitizer",
     "../rtc_base/memory:aligned_array",
     "../rtc_base/memory:aligned_malloc",
     "../rtc_base/system:arch",
@@ -389,6 +390,7 @@
       "../system_wrappers:cpu_features_api",
       "../test:fileutils",
       "../test:test_main",
+      "../test:test_support",
       "//testing/gtest",
     ]
 
diff --git a/common_audio/audio_converter.h b/common_audio/audio_converter.h
index 769d724..24a5e72 100644
--- a/common_audio/audio_converter.h
+++ b/common_audio/audio_converter.h
@@ -11,6 +11,7 @@
 #ifndef COMMON_AUDIO_AUDIO_CONVERTER_H_
 #define COMMON_AUDIO_AUDIO_CONVERTER_H_
 
+#include <stddef.h>
 #include <memory>
 
 #include "rtc_base/constructormagic.h"
diff --git a/common_audio/channel_buffer.cc b/common_audio/channel_buffer.cc
index 38d231e..b9b8c25 100644
--- a/common_audio/channel_buffer.cc
+++ b/common_audio/channel_buffer.cc
@@ -10,6 +10,9 @@
 
 #include "common_audio/channel_buffer.h"
 
+#include <cstdint>
+
+#include "common_audio/include/audio_util.h"
 #include "rtc_base/checks.h"
 
 namespace webrtc {
diff --git a/common_audio/fir_filter_c.cc b/common_audio/fir_filter_c.cc
index 3418434..b6ec27a 100644
--- a/common_audio/fir_filter_c.cc
+++ b/common_audio/fir_filter_c.cc
@@ -11,11 +11,8 @@
 #include "common_audio/fir_filter_c.h"
 
 #include <string.h>
-
 #include <memory>
 
-#include "common_audio/fir_filter_neon.h"
-#include "common_audio/fir_filter_sse.h"
 #include "rtc_base/checks.h"
 
 namespace webrtc {
diff --git a/common_audio/fir_filter_factory.cc b/common_audio/fir_filter_factory.cc
index 3243b27..19528e3 100644
--- a/common_audio/fir_filter_factory.cc
+++ b/common_audio/fir_filter_factory.cc
@@ -13,12 +13,12 @@
 #include "common_audio/fir_filter_c.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/system/arch.h"
-#include "system_wrappers/include/cpu_features_wrapper.h"
 
 #if defined(WEBRTC_HAS_NEON)
 #include "common_audio/fir_filter_neon.h"
 #elif defined(WEBRTC_ARCH_X86_FAMILY)
 #include "common_audio/fir_filter_sse.h"
+#include "system_wrappers/include/cpu_features_wrapper.h"  // kSSE2, WebRtc_G...
 #endif
 
 namespace webrtc {
diff --git a/common_audio/fir_filter_sse.h b/common_audio/fir_filter_sse.h
index 7707f93..b768a37 100644
--- a/common_audio/fir_filter_sse.h
+++ b/common_audio/fir_filter_sse.h
@@ -11,6 +11,7 @@
 #ifndef COMMON_AUDIO_FIR_FILTER_SSE_H_
 #define COMMON_AUDIO_FIR_FILTER_SSE_H_
 
+#include <stddef.h>
 #include <memory>
 
 #include "common_audio/fir_filter.h"
diff --git a/common_audio/include/audio_util.h b/common_audio/include/audio_util.h
index de242a4..bca5718 100644
--- a/common_audio/include/audio_util.h
+++ b/common_audio/include/audio_util.h
@@ -11,6 +11,7 @@
 #ifndef COMMON_AUDIO_INCLUDE_AUDIO_UTIL_H_
 #define COMMON_AUDIO_INCLUDE_AUDIO_UTIL_H_
 
+#include <stdint.h>
 #include <algorithm>
 #include <cmath>
 #include <cstring>
diff --git a/common_audio/real_fourier.h b/common_audio/real_fourier.h
index a3e4dd1..4d0d8bf 100644
--- a/common_audio/real_fourier.h
+++ b/common_audio/real_fourier.h
@@ -11,6 +11,7 @@
 #ifndef COMMON_AUDIO_REAL_FOURIER_H_
 #define COMMON_AUDIO_REAL_FOURIER_H_
 
+#include <stddef.h>
 #include <complex>
 #include <memory>
 
diff --git a/common_audio/real_fourier_ooura.h b/common_audio/real_fourier_ooura.h
index bb8eef9..b36c84f 100644
--- a/common_audio/real_fourier_ooura.h
+++ b/common_audio/real_fourier_ooura.h
@@ -11,6 +11,7 @@
 #ifndef COMMON_AUDIO_REAL_FOURIER_OOURA_H_
 #define COMMON_AUDIO_REAL_FOURIER_OOURA_H_
 
+#include <stddef.h>
 #include <complex>
 #include <memory>
 
diff --git a/common_audio/resampler/push_resampler.cc b/common_audio/resampler/push_resampler.cc
index 318d97b..9b89867 100644
--- a/common_audio/resampler/push_resampler.cc
+++ b/common_audio/resampler/push_resampler.cc
@@ -10,12 +10,12 @@
 
 #include "common_audio/resampler/include/push_resampler.h"
 
+#include <stdint.h>
 #include <string.h>
 
 #include "absl/container/inlined_vector.h"
 #include "absl/memory/memory.h"
 #include "common_audio/include/audio_util.h"
-#include "common_audio/resampler/include/resampler.h"
 #include "common_audio/resampler/push_sinc_resampler.h"
 #include "rtc_base/checks.h"
 
diff --git a/common_audio/resampler/push_sinc_resampler.h b/common_audio/resampler/push_sinc_resampler.h
index 1ffe73f..db9cdc1 100644
--- a/common_audio/resampler/push_sinc_resampler.h
+++ b/common_audio/resampler/push_sinc_resampler.h
@@ -11,6 +11,8 @@
 #ifndef COMMON_AUDIO_RESAMPLER_PUSH_SINC_RESAMPLER_H_
 #define COMMON_AUDIO_RESAMPLER_PUSH_SINC_RESAMPLER_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <memory>
 
 #include "common_audio/resampler/sinc_resampler.h"
diff --git a/common_audio/resampler/resampler.cc b/common_audio/resampler/resampler.cc
index aa3a4ba..e4d2aa2 100644
--- a/common_audio/resampler/resampler.cc
+++ b/common_audio/resampler/resampler.cc
@@ -12,6 +12,7 @@
  * A wrapper for resampling a numerous amount of sampling combinations.
  */
 
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
diff --git a/common_audio/resampler/sinc_resampler.cc b/common_audio/resampler/sinc_resampler.cc
index 5aa2061..4601514 100644
--- a/common_audio/resampler/sinc_resampler.cc
+++ b/common_audio/resampler/sinc_resampler.cc
@@ -88,13 +88,13 @@
 #include "common_audio/resampler/sinc_resampler.h"
 
 #include <math.h>
+#include <stdint.h>
 #include <string.h>
-
 #include <limits>
 
 #include "rtc_base/checks.h"
 #include "rtc_base/system/arch.h"
-#include "system_wrappers/include/cpu_features_wrapper.h"
+#include "system_wrappers/include/cpu_features_wrapper.h"  // kSSE2, WebRtc_G...
 
 namespace webrtc {
 
diff --git a/common_audio/resampler/sinc_resampler.h b/common_audio/resampler/sinc_resampler.h
index 8a833ce..0be4318 100644
--- a/common_audio/resampler/sinc_resampler.h
+++ b/common_audio/resampler/sinc_resampler.h
@@ -14,6 +14,7 @@
 #ifndef COMMON_AUDIO_RESAMPLER_SINC_RESAMPLER_H_
 #define COMMON_AUDIO_RESAMPLER_SINC_RESAMPLER_H_
 
+#include <stddef.h>
 #include <memory>
 
 #include "rtc_base/constructormagic.h"
diff --git a/common_audio/resampler/sinc_resampler_sse.cc b/common_audio/resampler/sinc_resampler_sse.cc
index 3906a79..f6a24d0 100644
--- a/common_audio/resampler/sinc_resampler_sse.cc
+++ b/common_audio/resampler/sinc_resampler_sse.cc
@@ -11,10 +11,12 @@
 // Modified from the Chromium original:
 // src/media/base/simd/sinc_resampler_sse.cc
 
-#include "common_audio/resampler/sinc_resampler.h"
-
+#include <stddef.h>
+#include <stdint.h>
 #include <xmmintrin.h>
 
+#include "common_audio/resampler/sinc_resampler.h"
+
 namespace webrtc {
 
 float SincResampler::Convolve_SSE(const float* input_ptr,
diff --git a/common_audio/smoothing_filter.cc b/common_audio/smoothing_filter.cc
index d426bda..0d5aaa4 100644
--- a/common_audio/smoothing_filter.cc
+++ b/common_audio/smoothing_filter.cc
@@ -12,6 +12,7 @@
 
 #include <cmath>
 
+#include "rtc_base/checks.h"
 #include "rtc_base/timeutils.h"
 
 namespace webrtc {
diff --git a/common_audio/smoothing_filter.h b/common_audio/smoothing_filter.h
index cff7469..c467d85 100644
--- a/common_audio/smoothing_filter.h
+++ b/common_audio/smoothing_filter.h
@@ -11,9 +11,10 @@
 #ifndef COMMON_AUDIO_SMOOTHING_FILTER_H_
 #define COMMON_AUDIO_SMOOTHING_FILTER_H_
 
+#include <stdint.h>
+
 #include "absl/types/optional.h"
 #include "rtc_base/constructormagic.h"
-#include "system_wrappers/include/clock.h"
 
 namespace webrtc {
 
diff --git a/common_audio/vad/vad.cc b/common_audio/vad/vad.cc
index 1cb332a..987ed52 100644
--- a/common_audio/vad/vad.cc
+++ b/common_audio/vad/vad.cc
@@ -12,6 +12,7 @@
 
 #include <memory>
 
+#include "common_audio/vad/include/webrtc_vad.h"
 #include "rtc_base/checks.h"
 
 namespace webrtc {
diff --git a/common_audio/wav_file.cc b/common_audio/wav_file.cc
index 008891f..1b8bcbd 100644
--- a/common_audio/wav_file.cc
+++ b/common_audio/wav_file.cc
@@ -10,35 +10,45 @@
 
 #include "common_audio/wav_file.h"
 
+#include <errno.h>
 #include <algorithm>
 #include <cstdio>
-#include <limits>
+#include <type_traits>
 
 #include "common_audio/include/audio_util.h"
 #include "common_audio/wav_header.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
-#include "rtc_base/numerics/safe_conversions.h"
 #include "rtc_base/system/arch.h"
 
 namespace webrtc {
+namespace {
 
 // We write 16-bit PCM WAV files.
-static const WavFormat kWavFormat = kWavFormatPcm;
-static const size_t kBytesPerSample = 2;
+constexpr WavFormat kWavFormat = kWavFormatPcm;
+static_assert(std::is_trivially_destructible<WavFormat>::value, "");
+constexpr size_t kBytesPerSample = 2;
 
 // Doesn't take ownership of the file handle and won't close it.
 class ReadableWavFile : public ReadableWav {
  public:
   explicit ReadableWavFile(FILE* file) : file_(file) {}
+  ReadableWavFile(const ReadableWavFile&) = delete;
+  ReadableWavFile& operator=(const ReadableWavFile&) = delete;
   size_t Read(void* buf, size_t num_bytes) override {
     return fread(buf, 1, num_bytes, file_);
   }
+  bool Eof() const override { return feof(file_) != 0; }
+  bool SeekForward(uint32_t num_bytes) override {
+    return fseek(file_, num_bytes, SEEK_CUR) == 0;
+  }
 
  private:
   FILE* file_;
 };
 
+}  // namespace
+
 WavReader::WavReader(const std::string& filename)
     : WavReader(rtc::OpenPlatformFileReadOnly(filename)) {}
 
diff --git a/common_audio/wav_header.cc b/common_audio/wav_header.cc
index 8fc5fef..e49b748 100644
--- a/common_audio/wav_header.cc
+++ b/common_audio/wav_header.cc
@@ -14,13 +14,13 @@
 
 #include "common_audio/wav_header.h"
 
-#include <algorithm>
 #include <cstring>
 #include <limits>
 #include <string>
 
-#include "common_audio/include/audio_util.h"
 #include "rtc_base/checks.h"
+#include "rtc_base/logging.h"
+#include "rtc_base/sanitizer.h"
 #include "rtc_base/system/arch.h"
 
 namespace webrtc {
@@ -32,6 +32,11 @@
 };
 static_assert(sizeof(ChunkHeader) == 8, "ChunkHeader size");
 
+struct RiffHeader {
+  ChunkHeader header;
+  uint32_t Format;
+};
+
 // We can't nest this definition in WavHeader, because VS2013 gives an error
 // on sizeof(WavHeader::fmt): "error C2070: 'unknown': illegal sizeof operand".
 struct FmtSubchunk {
@@ -46,11 +51,12 @@
 static_assert(sizeof(FmtSubchunk) == 24, "FmtSubchunk size");
 const uint32_t kFmtSubchunkSize = sizeof(FmtSubchunk) - sizeof(ChunkHeader);
 
+// Simple wav header. It does not include chunks that are not essential to read
+// audio samples.
 struct WavHeader {
-  struct {
-    ChunkHeader header;
-    uint32_t Format;
-  } riff;
+  WavHeader(const WavHeader&) = default;
+  WavHeader& operator=(const WavHeader&) = default;
+  RiffHeader riff;
   FmtSubchunk fmt;
   struct {
     ChunkHeader header;
@@ -58,6 +64,87 @@
 };
 static_assert(sizeof(WavHeader) == kWavHeaderSize, "no padding in header");
 
+#ifdef WEBRTC_ARCH_LITTLE_ENDIAN
+static inline void WriteLE16(uint16_t* f, uint16_t x) {
+  *f = x;
+}
+static inline void WriteLE32(uint32_t* f, uint32_t x) {
+  *f = x;
+}
+static inline void WriteFourCC(uint32_t* f, char a, char b, char c, char d) {
+  *f = static_cast<uint32_t>(a) | static_cast<uint32_t>(b) << 8 |
+       static_cast<uint32_t>(c) << 16 | static_cast<uint32_t>(d) << 24;
+}
+
+static inline uint16_t ReadLE16(uint16_t x) {
+  return x;
+}
+static inline uint32_t ReadLE32(uint32_t x) {
+  return x;
+}
+static inline std::string ReadFourCC(uint32_t x) {
+  return std::string(reinterpret_cast<char*>(&x), 4);
+}
+#else
+#error "Write be-to-le conversion functions"
+#endif
+
+static inline uint32_t RiffChunkSize(size_t bytes_in_payload) {
+  return static_cast<uint32_t>(bytes_in_payload + kWavHeaderSize -
+                               sizeof(ChunkHeader));
+}
+
+static inline uint32_t ByteRate(size_t num_channels,
+                                int sample_rate,
+                                size_t bytes_per_sample) {
+  return static_cast<uint32_t>(num_channels * sample_rate * bytes_per_sample);
+}
+
+static inline uint16_t BlockAlign(size_t num_channels,
+                                  size_t bytes_per_sample) {
+  return static_cast<uint16_t>(num_channels * bytes_per_sample);
+}
+
+// Finds a chunk having the sought ID. If found, then |readable| points to the
+// first byte of the sought chunk data. If not found, the end of the file is
+// reached.
+void FindWaveChunk(ChunkHeader* chunk_header,
+                   ReadableWav* readable,
+                   const std::string sought_chunk_id) {
+  RTC_DCHECK_EQ(sought_chunk_id.size(), 4);
+  while (!readable->Eof()) {
+    if (readable->Read(chunk_header, sizeof(*chunk_header)) !=
+        sizeof(*chunk_header))
+      return;  // EOF.
+    if (ReadFourCC(chunk_header->ID) == sought_chunk_id)
+      return;  // Sought chunk found.
+    // Ignore current chunk by skipping its payload.
+    if (!readable->SeekForward(chunk_header->Size))
+      return;  // EOF or error.
+  }
+  return;  // EOF.
+}
+
+bool ReadFmtChunkData(FmtSubchunk* fmt_subchunk, ReadableWav* readable) {
+  // Reads "fmt " chunk payload.
+  if (readable->Read(&(fmt_subchunk->AudioFormat), kFmtSubchunkSize) !=
+      kFmtSubchunkSize)
+    return false;
+  const uint32_t fmt_size = ReadLE32(fmt_subchunk->header.Size);
+  if (fmt_size != kFmtSubchunkSize) {
+    // There is an optional two-byte extension field permitted to be present
+    // with PCM, but which must be zero.
+    int16_t ext_size;
+    if (kFmtSubchunkSize + sizeof(ext_size) != fmt_size)
+      return false;
+    if (readable->Read(&ext_size, sizeof(ext_size)) != sizeof(ext_size))
+      return false;
+    if (ext_size != 0)
+      return false;
+  }
+  return true;
+}
+
 }  // namespace
 
 bool CheckWavParameters(size_t num_channels,
@@ -112,47 +199,6 @@
   return true;
 }
 
-#ifdef WEBRTC_ARCH_LITTLE_ENDIAN
-static inline void WriteLE16(uint16_t* f, uint16_t x) {
-  *f = x;
-}
-static inline void WriteLE32(uint32_t* f, uint32_t x) {
-  *f = x;
-}
-static inline void WriteFourCC(uint32_t* f, char a, char b, char c, char d) {
-  *f = static_cast<uint32_t>(a) | static_cast<uint32_t>(b) << 8 |
-       static_cast<uint32_t>(c) << 16 | static_cast<uint32_t>(d) << 24;
-}
-
-static inline uint16_t ReadLE16(uint16_t x) {
-  return x;
-}
-static inline uint32_t ReadLE32(uint32_t x) {
-  return x;
-}
-static inline std::string ReadFourCC(uint32_t x) {
-  return std::string(reinterpret_cast<char*>(&x), 4);
-}
-#else
-#error "Write be-to-le conversion functions"
-#endif
-
-static inline uint32_t RiffChunkSize(size_t bytes_in_payload) {
-  return static_cast<uint32_t>(bytes_in_payload + kWavHeaderSize -
-                               sizeof(ChunkHeader));
-}
-
-static inline uint32_t ByteRate(size_t num_channels,
-                                int sample_rate,
-                                size_t bytes_per_sample) {
-  return static_cast<uint32_t>(num_channels * sample_rate * bytes_per_sample);
-}
-
-static inline uint16_t BlockAlign(size_t num_channels,
-                                  size_t bytes_per_sample) {
-  return static_cast<uint16_t>(num_channels * bytes_per_sample);
-}
-
 void WriteWavHeader(uint8_t* buf,
                     size_t num_channels,
                     int sample_rate,
@@ -162,7 +208,7 @@
   RTC_CHECK(CheckWavParameters(num_channels, sample_rate, format,
                                bytes_per_sample, num_samples));
 
-  WavHeader header;
+  auto header = rtc::MsanUninitialized<WavHeader>({});
   const size_t bytes_in_payload = bytes_per_sample * num_samples;
 
   WriteFourCC(&header.riff.header.ID, 'R', 'I', 'F', 'F');
@@ -194,25 +240,38 @@
                    WavFormat* format,
                    size_t* bytes_per_sample,
                    size_t* num_samples) {
-  WavHeader header;
-  if (readable->Read(&header, kWavHeaderSize - sizeof(header.data)) !=
-      kWavHeaderSize - sizeof(header.data))
+  auto header = rtc::MsanUninitialized<WavHeader>({});
+
+  // Read RIFF chunk.
+  if (readable->Read(&header.riff, sizeof(header.riff)) != sizeof(header.riff))
+    return false;
+  if (ReadFourCC(header.riff.header.ID) != "RIFF")
+    return false;
+  if (ReadFourCC(header.riff.Format) != "WAVE")
     return false;
 
-  const uint32_t fmt_size = ReadLE32(header.fmt.header.Size);
-  if (fmt_size != kFmtSubchunkSize) {
-    // There is an optional two-byte extension field permitted to be present
-    // with PCM, but which must be zero.
-    int16_t ext_size;
-    if (kFmtSubchunkSize + sizeof(ext_size) != fmt_size)
-      return false;
-    if (readable->Read(&ext_size, sizeof(ext_size)) != sizeof(ext_size))
-      return false;
-    if (ext_size != 0)
-      return false;
-  }
-  if (readable->Read(&header.data, sizeof(header.data)) != sizeof(header.data))
+  // Find "fmt " and "data" chunks. While the official Wave file specification
+  // does not put requirements on the chunks order, it is uncommon to find the
+  // "data" chunk before the "fmt " one. The code below fails if this is not the
+  // case.
+  FindWaveChunk(&header.fmt.header, readable, "fmt ");
+  if (ReadFourCC(header.fmt.header.ID) != "fmt ") {
+    RTC_LOG(LS_ERROR) << "Cannot find 'fmt ' chunk.";
     return false;
+  }
+  if (!ReadFmtChunkData(&header.fmt, readable)) {
+    RTC_LOG(LS_ERROR) << "Cannot read 'fmt ' chunk.";
+    return false;
+  }
+  if (readable->Eof()) {
+    RTC_LOG(LS_ERROR) << "'fmt ' chunk placed after 'data' chunk.";
+    return false;
+  }
+  FindWaveChunk(&header.data.header, readable, "data");
+  if (ReadFourCC(header.data.header.ID) != "data") {
+    RTC_LOG(LS_ERROR) << "Cannot find 'data' chunk.";
+    return false;
+  }
 
   // Parse needed fields.
   *format = static_cast<WavFormat>(ReadLE16(header.fmt.AudioFormat));
@@ -224,16 +283,6 @@
     return false;
   *num_samples = bytes_in_payload / *bytes_per_sample;
 
-  // Sanity check remaining fields.
-  if (ReadFourCC(header.riff.header.ID) != "RIFF")
-    return false;
-  if (ReadFourCC(header.riff.Format) != "WAVE")
-    return false;
-  if (ReadFourCC(header.fmt.header.ID) != "fmt ")
-    return false;
-  if (ReadFourCC(header.data.header.ID) != "data")
-    return false;
-
   if (ReadLE32(header.riff.header.Size) < RiffChunkSize(bytes_in_payload))
     return false;
   if (ReadLE32(header.fmt.ByteRate) !=
diff --git a/common_audio/wav_header.h b/common_audio/wav_header.h
index 872d3ab..a519ba5 100644
--- a/common_audio/wav_header.h
+++ b/common_audio/wav_header.h
@@ -21,8 +21,11 @@
 class ReadableWav {
  public:
   // Returns the number of bytes read.
-  size_t virtual Read(void* buf, size_t num_bytes) = 0;
-  virtual ~ReadableWav() {}
+  virtual size_t Read(void* buf, size_t num_bytes) = 0;
+  // Returns true if the end-of-file has been reached.
+  virtual bool Eof() const = 0;
+  virtual bool SeekForward(uint32_t num_bytes) = 0;
+  virtual ~ReadableWav() = default;
 };
 
 enum WavFormat {
diff --git a/common_audio/wav_header_unittest.cc b/common_audio/wav_header_unittest.cc
index b7169b5..2e2eda5 100644
--- a/common_audio/wav_header_unittest.cc
+++ b/common_audio/wav_header_unittest.cc
@@ -19,12 +19,6 @@
 // Doesn't take ownership of the buffer.
 class ReadableWavBuffer : public ReadableWav {
  public:
-  ReadableWavBuffer(const uint8_t* buf, size_t size)
-      : buf_(buf),
-        size_(size),
-        pos_(0),
-        buf_exhausted_(false),
-        check_read_size_(true) {}
   ReadableWavBuffer(const uint8_t* buf, size_t size, bool check_read_size)
       : buf_(buf),
         size_(size),
@@ -57,6 +51,27 @@
     return num_bytes;
   }
 
+  bool Eof() const override { return pos_ == size_; }
+
+  bool SeekForward(uint32_t num_bytes) override {
+    // Verify we don't try to read outside of a properly sized header.
+    if (size_ >= kWavHeaderSize)
+      EXPECT_GE(size_, pos_ + num_bytes);
+    EXPECT_FALSE(buf_exhausted_);
+
+    const size_t bytes_remaining = size_ - pos_;
+    if (num_bytes > bytes_remaining) {
+      // Error: cannot seek beyond EOF.
+      return false;
+    }
+    if (num_bytes == bytes_remaining) {
+      // There should not be another read attempt after this point.
+      buf_exhausted_ = true;
+    }
+    pos_ += num_bytes;
+    return true;
+  }
+
  private:
   const uint8_t* buf_;
   const size_t size_;
@@ -103,7 +118,7 @@
   // invalid field is indicated in the array name, and in the comments with
   // *BAD*.
   {
-    static const uint8_t kBadRiffID[] = {
+    constexpr uint8_t kBadRiffID[] = {
         // clang-format off
         // clang formatting doesn't respect inline comments.
       'R', 'i', 'f', 'f',  // *BAD*
@@ -121,12 +136,13 @@
       0x99, 0xd0, 0x5b, 0x07,  // size of payload: 123457689
         // clang-format on
     };
-    ReadableWavBuffer r(kBadRiffID, sizeof(kBadRiffID));
+    ReadableWavBuffer r(kBadRiffID, sizeof(kBadRiffID),
+                        /*check_read_size=*/false);
     EXPECT_FALSE(ReadWavHeader(&r, &num_channels, &sample_rate, &format,
                                &bytes_per_sample, &num_samples));
   }
   {
-    static const uint8_t kBadBitsPerSample[] = {
+    constexpr uint8_t kBadBitsPerSample[] = {
         // clang-format off
         // clang formatting doesn't respect inline comments.
       'R', 'I', 'F', 'F',
@@ -144,12 +160,13 @@
       0x99, 0xd0, 0x5b, 0x07,  // size of payload: 123457689
         // clang-format on
     };
-    ReadableWavBuffer r(kBadBitsPerSample, sizeof(kBadBitsPerSample));
+    ReadableWavBuffer r(kBadBitsPerSample, sizeof(kBadBitsPerSample),
+                        /*check_read_size=*/true);
     EXPECT_FALSE(ReadWavHeader(&r, &num_channels, &sample_rate, &format,
                                &bytes_per_sample, &num_samples));
   }
   {
-    static const uint8_t kBadByteRate[] = {
+    constexpr uint8_t kBadByteRate[] = {
         // clang-format off
         // clang formatting doesn't respect inline comments.
       'R', 'I', 'F', 'F',
@@ -167,12 +184,13 @@
       0x99, 0xd0, 0x5b, 0x07,  // size of payload: 123457689
         // clang-format on
     };
-    ReadableWavBuffer r(kBadByteRate, sizeof(kBadByteRate));
+    ReadableWavBuffer r(kBadByteRate, sizeof(kBadByteRate),
+                        /*check_read_size=*/true);
     EXPECT_FALSE(ReadWavHeader(&r, &num_channels, &sample_rate, &format,
                                &bytes_per_sample, &num_samples));
   }
   {
-    static const uint8_t kBadFmtHeaderSize[] = {
+    constexpr uint8_t kBadFmtHeaderSize[] = {
         // clang-format off
         // clang formatting doesn't respect inline comments.
       'R', 'I', 'F', 'F',
@@ -191,12 +209,13 @@
       0x99, 0xd0, 0x5b, 0x07,  // size of payload: 123457689
         // clang-format on
     };
-    ReadableWavBuffer r(kBadFmtHeaderSize, sizeof(kBadFmtHeaderSize), false);
+    ReadableWavBuffer r(kBadFmtHeaderSize, sizeof(kBadFmtHeaderSize),
+                        /*check_read_size=*/false);
     EXPECT_FALSE(ReadWavHeader(&r, &num_channels, &sample_rate, &format,
                                &bytes_per_sample, &num_samples));
   }
   {
-    static const uint8_t kNonZeroExtensionField[] = {
+    constexpr uint8_t kNonZeroExtensionField[] = {
         // clang-format off
         // clang formatting doesn't respect inline comments.
       'R', 'I', 'F', 'F',
@@ -216,12 +235,12 @@
         // clang-format on
     };
     ReadableWavBuffer r(kNonZeroExtensionField, sizeof(kNonZeroExtensionField),
-                        false);
+                        /*check_read_size=*/false);
     EXPECT_FALSE(ReadWavHeader(&r, &num_channels, &sample_rate, &format,
                                &bytes_per_sample, &num_samples));
   }
   {
-    static const uint8_t kMissingDataChunk[] = {
+    constexpr uint8_t kMissingDataChunk[] = {
         // clang-format off
         // clang formatting doesn't respect inline comments.
       'R', 'I', 'F', 'F',
@@ -237,12 +256,13 @@
       8, 0,  // bits per sample: 1 * 8
         // clang-format on
     };
-    ReadableWavBuffer r(kMissingDataChunk, sizeof(kMissingDataChunk));
+    ReadableWavBuffer r(kMissingDataChunk, sizeof(kMissingDataChunk),
+                        /*check_read_size=*/true);
     EXPECT_FALSE(ReadWavHeader(&r, &num_channels, &sample_rate, &format,
                                &bytes_per_sample, &num_samples));
   }
   {
-    static const uint8_t kMissingFmtAndDataChunks[] = {
+    constexpr uint8_t kMissingFmtAndDataChunks[] = {
         // clang-format off
         // clang formatting doesn't respect inline comments.
       'R', 'I', 'F', 'F',
@@ -251,7 +271,8 @@
         // clang-format on
     };
     ReadableWavBuffer r(kMissingFmtAndDataChunks,
-                        sizeof(kMissingFmtAndDataChunks));
+                        sizeof(kMissingFmtAndDataChunks),
+                        /*check_read_size=*/true);
     EXPECT_FALSE(ReadWavHeader(&r, &num_channels, &sample_rate, &format,
                                &bytes_per_sample, &num_samples));
   }
@@ -259,11 +280,11 @@
 
 // Try writing and reading a valid WAV header and make sure it looks OK.
 TEST(WavHeaderTest, WriteAndReadWavHeader) {
-  static const int kSize = 4 + kWavHeaderSize + 4;
+  constexpr int kSize = 4 + kWavHeaderSize + 4;
   uint8_t buf[kSize];
   memset(buf, 0xa4, sizeof(buf));
   WriteWavHeader(buf + 4, 17, 12345, kWavFormatALaw, 1, 123457689);
-  static const uint8_t kExpectedBuf[] = {
+  constexpr uint8_t kExpectedBuf[] = {
       // clang-format off
       // clang formatting doesn't respect inline comments.
     0xa4, 0xa4, 0xa4, 0xa4,  // untouched bytes before header
@@ -291,7 +312,8 @@
   WavFormat format = kWavFormatPcm;
   size_t bytes_per_sample = 0;
   size_t num_samples = 0;
-  ReadableWavBuffer r(buf + 4, sizeof(buf) - 8);
+  ReadableWavBuffer r(buf + 4, sizeof(buf) - 8,
+                      /*check_read_size=*/true);
   EXPECT_TRUE(ReadWavHeader(&r, &num_channels, &sample_rate, &format,
                             &bytes_per_sample, &num_samples));
   EXPECT_EQ(17u, num_channels);
@@ -303,24 +325,25 @@
 
 // Try reading an atypical but valid WAV header and make sure it's parsed OK.
 TEST(WavHeaderTest, ReadAtypicalWavHeader) {
-  static const uint8_t kBuf[] = {
+  constexpr uint8_t kBuf[] = {
       // clang-format off
       // clang formatting doesn't respect inline comments.
     'R', 'I', 'F', 'F',
-    0x3d, 0xd1, 0x5b, 0x07,  // size of whole file - 8 + an extra 128 bytes of
-                             // "metadata": 123457689 + 44 - 8 + 128. (atypical)
+    0xbf, 0xd0, 0x5b, 0x07,  // Size of whole file - 8 + extra 2 bytes of zero
+                             // extension: 123457689 + 44 - 8 + 2 (atypical).
     'W', 'A', 'V', 'E',
     'f', 'm', 't', ' ',
-    18, 0, 0, 0,  // size of fmt block (with an atypical extension size field)
-    6, 0,  // format: A-law (6)
-    17, 0,  // channels: 17
-    0x39, 0x30, 0, 0,  // sample rate: 12345
-    0xc9, 0x33, 0x03, 0,  // byte rate: 1 * 17 * 12345
-    17, 0,  // block align: NumChannels * BytesPerSample
-    8, 0,  // bits per sample: 1 * 8
-    0, 0,  // zero extension size field (atypical)
+    18, 0, 0, 0,             // Size of fmt block (with an atypical extension
+                             // size field).
+    6, 0,                    // Format: A-law (6).
+    17, 0,                   // Channels: 17.
+    0x39, 0x30, 0, 0,        // Sample rate: 12345.
+    0xc9, 0x33, 0x03, 0,     // Byte rate: 1 * 17 * 12345.
+    17, 0,                   // Block align: NumChannels * BytesPerSample.
+    8, 0,                    // Bits per sample: 1 * 8.
+    0, 0,                    // Zero extension size field (atypical).
     'd', 'a', 't', 'a',
-    0x99, 0xd0, 0x5b, 0x07,  // size of payload: 123457689
+    0x99, 0xd0, 0x5b, 0x07,  // Size of payload: 123457689.
       // clang-format on
   };
 
@@ -329,7 +352,7 @@
   WavFormat format = kWavFormatPcm;
   size_t bytes_per_sample = 0;
   size_t num_samples = 0;
-  ReadableWavBuffer r(kBuf, sizeof(kBuf));
+  ReadableWavBuffer r(kBuf, sizeof(kBuf), /*check_read_size=*/true);
   EXPECT_TRUE(ReadWavHeader(&r, &num_channels, &sample_rate, &format,
                             &bytes_per_sample, &num_samples));
   EXPECT_EQ(17u, num_channels);
@@ -339,4 +362,79 @@
   EXPECT_EQ(123457689u, num_samples);
 }
 
+// Try reading a valid WAV header which contains an optional chunk and make sure
+// it's parsed OK.
+TEST(WavHeaderTest, ReadWavHeaderWithOptionalChunk) {
+  constexpr uint8_t kBuf[] = {
+      // clang-format off
+      // clang formatting doesn't respect inline comments.
+    'R', 'I', 'F', 'F',
+    0xcd, 0xd0, 0x5b, 0x07,  // Size of whole file - 8 + an extra 16 bytes of
+                             // "metadata" (8 bytes header, 16 bytes payload):
+                             // 123457689 + 44 - 8 + 16.
+    'W', 'A', 'V', 'E',
+    'f', 'm', 't', ' ',
+    16, 0, 0, 0,             // Size of fmt block.
+    6, 0,                    // Format: A-law (6).
+    17, 0,                   // Channels: 17.
+    0x39, 0x30, 0, 0,        // Sample rate: 12345.
+    0xc9, 0x33, 0x03, 0,     // Byte rate: 1 * 17 * 12345.
+    17, 0,                   // Block align: NumChannels * BytesPerSample.
+    8, 0,                    // Bits per sample: 1 * 8.
+    'L', 'I', 'S', 'T',      // Metadata chunk ID.
+    16, 0, 0, 0,             // Metadata chunk payload size.
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // Metadata (16 bytes).
+    'd', 'a', 't', 'a',
+    0x99, 0xd0, 0x5b, 0x07,  // Size of payload: 123457689.
+      // clang-format on
+  };
+
+  size_t num_channels = 0;
+  int sample_rate = 0;
+  WavFormat format = kWavFormatPcm;
+  size_t bytes_per_sample = 0;
+  size_t num_samples = 0;
+  ReadableWavBuffer r(kBuf, sizeof(kBuf), /*check_read_size=*/true);
+  EXPECT_TRUE(ReadWavHeader(&r, &num_channels, &sample_rate, &format,
+                            &bytes_per_sample, &num_samples));
+  EXPECT_EQ(17u, num_channels);
+  EXPECT_EQ(12345, sample_rate);
+  EXPECT_EQ(kWavFormatALaw, format);
+  EXPECT_EQ(1u, bytes_per_sample);
+  EXPECT_EQ(123457689u, num_samples);
+}
+
+// Try reading an invalid WAV header which has the the data chunk before the
+// format one and make sure it's not parsed.
+TEST(WavHeaderTest, ReadWavHeaderWithDataBeforeFormat) {
+  constexpr uint8_t kBuf[] = {
+      // clang-format off
+      // clang formatting doesn't respect inline comments.
+    'R', 'I', 'F', 'F',
+    52,  0,   0,   0,    // Size of whole file - 8: 16 + 44 - 8.
+    'W', 'A', 'V', 'E',
+    'd', 'a', 't', 'a',
+    16, 0, 0, 0,         // Data chunk payload size.
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // Data 16 bytes.
+    'f', 'm', 't', ' ',
+    16,  0,   0,   0,    // Size of fmt block.
+    6,   0,              // Format: A-law (6).
+    1,   0,              // Channels: 1.
+    60,  0,   0,   0,    // Sample rate: 60.
+    60,  0,   0,   0,    // Byte rate: 1 * 1 * 60.
+    1,   0,              // Block align: NumChannels * BytesPerSample.
+    8,   0,              // Bits per sample: 1 * 8.
+      // clang-format on
+  };
+
+  size_t num_channels = 0;
+  int sample_rate = 0;
+  WavFormat format = kWavFormatPcm;
+  size_t bytes_per_sample = 0;
+  size_t num_samples = 0;
+  ReadableWavBuffer r(kBuf, sizeof(kBuf), /*check_read_size=*/false);
+  EXPECT_FALSE(ReadWavHeader(&r, &num_channels, &sample_rate, &format,
+                             &bytes_per_sample, &num_samples));
+}
+
 }  // namespace webrtc
diff --git a/common_types.h b/common_types.h
index 99c4064..b2fcf17 100644
--- a/common_types.h
+++ b/common_types.h
@@ -11,12 +11,10 @@
 #ifndef COMMON_TYPES_H_
 #define COMMON_TYPES_H_
 
-#include <stddef.h>
-#include <string.h>
-#include <string>
-#include <vector>
+#include <stddef.h>  // For size_t
+#include <cstdint>
 
-#include "api/array_view.h"
+#include "absl/strings/match.h"
 // TODO(sprang): Remove this include when all usage includes it directly.
 #include "api/video/video_bitrate_allocation.h"
 #include "rtc_base/checks.h"
@@ -30,16 +28,6 @@
 
 #define RTP_PAYLOAD_NAME_SIZE 32u
 
-#if defined(WEBRTC_WIN) || defined(WIN32)
-// Compares two strings without regard to case.
-#define STR_CASE_CMP(s1, s2) ::_stricmp(s1, s2)
-// Compares characters of two strings without regard to case.
-#define STR_NCASE_CMP(s1, s2, n) ::_strnicmp(s1, s2, n)
-#else
-#define STR_CASE_CMP(s1, s2) ::strcasecmp(s1, s2)
-#define STR_NCASE_CMP(s1, s2, n) ::strncasecmp(s1, s2, n)
-#endif
-
 namespace webrtc {
 
 enum FrameType {
@@ -207,7 +195,7 @@
 
   bool operator==(const CodecInst& other) const {
     return pltype == other.pltype &&
-           (STR_CASE_CMP(plname, other.plname) == 0) &&
+           absl::EqualsIgnoreCase(plname, other.plname) &&
            plfreq == other.plfreq && pacsize == other.pacsize &&
            channels == other.channels && rate == other.rate;
   }
@@ -361,9 +349,6 @@
 // settings such as resolution.
 typedef SpatialLayer SimulcastStream;
 
-// TODO(sprang): Remove this when downstream projects have been updated.
-using BitrateAllocation = VideoBitrateAllocation;
-
 // Bandwidth over-use detector options.  These are used to drive
 // experimentation with bandwidth estimation parameters.
 // See modules/remote_bitrate_estimator/overuse_detector.h
diff --git a/cras-config/aec_config.cc b/cras-config/aec_config.cc
index 68696c6..adbd453 100644
--- a/cras-config/aec_config.cc
+++ b/cras-config/aec_config.cc
@@ -24,6 +24,14 @@
 	if (ini == NULL)
 		return;
 
+	config->buffering.use_new_render_buffering =
+		AEC_GET_INT(ini, BUFFERING, USE_NEW_RENDER_BUFFERING);
+	config->buffering.excess_render_detection_interval_blocks =
+		AEC_GET_INT(ini, BUFFERING,
+			EXCESS_RENDER_DETECTION_INTERVAL_BLOCKS);
+	config->buffering.max_allowed_excess_render_blocks =
+		AEC_GET_INT(ini, BUFFERING, MAX_ALLOWED_EXCESS_RENDER_BLOCKS);
+
 	config->delay.default_delay =
 		AEC_GET_INT(ini, DELAY, DEFAULT_DELAY);
 	config->delay.down_sampling_factor =
@@ -44,6 +52,14 @@
 		AEC_GET_INT(ini, DELAY, SKEW_HYSTERESIS_BLOCKS);
 	config->delay.fixed_capture_delay_samples =
 		AEC_GET_INT(ini, DELAY, FIXED_CAPTURE_DELAY_SAMPLES);
+	config->delay.delay_estimate_smoothing =
+		AEC_GET_FLOAT(ini, DELAY, DELAY_ESTIMATE_SMOOTHING);
+	config->delay.delay_candidate_detection_threshold =
+		AEC_GET_FLOAT(ini, DELAY, DELAY_CANDIDATE_DETECTION_THRESHOLD);
+	config->delay.delay_selection_thresholds.initial =
+		AEC_GET_INT(ini, DELAY, DELAY_SELECTION_THRESHOLD_INITIAL);
+	config->delay.delay_selection_thresholds.converged =
+		AEC_GET_INT(ini, DELAY, DELAY_SELECTION_THRESHOLD_CONVERGED);
 
 	config->filter.main.length_blocks =
 		AEC_GET_INT(ini, FILTER_MAIN, LENGTH_BLOCKS);
@@ -53,6 +69,8 @@
 		AEC_GET_FLOAT(ini, FILTER_MAIN, LEAKAGE_DIVERGED);
 	config->filter.main.error_floor =
 		AEC_GET_FLOAT(ini, FILTER_MAIN, ERROR_FLOOR);
+	config->filter.main.error_ceil =
+		AEC_GET_FLOAT(ini, FILTER_MAIN, ERROR_CEIL);
 	config->filter.main.noise_gate =
 		AEC_GET_FLOAT(ini, FILTER_MAIN, NOISE_GATE);
 
@@ -71,6 +89,8 @@
 		AEC_GET_FLOAT(ini, FILTER_MAIN_INIT, LEAKAGE_DIVERGED);
 	config->filter.main_initial.error_floor =
 		AEC_GET_FLOAT(ini, FILTER_MAIN_INIT, ERROR_FLOOR);
+	config->filter.main_initial.error_ceil =
+		AEC_GET_FLOAT(ini, FILTER_MAIN_INIT, ERROR_CEIL);
 	config->filter.main_initial.noise_gate =
 		AEC_GET_FLOAT(ini, FILTER_MAIN_INIT, NOISE_GATE);
 
@@ -114,35 +134,6 @@
 	config->ep_strength.echo_can_saturate =
 		AEC_GET_INT(ini, EP_STRENGTH, ECHO_CAN_SATURATE);
 
-	config->gain_mask.m0 =
-		AEC_GET_FLOAT(ini, GAIN_MASK, M0);
-	config->gain_mask.m1 =
-		AEC_GET_FLOAT(ini, GAIN_MASK, M1);
-	config->gain_mask.m2 =
-		AEC_GET_FLOAT(ini, GAIN_MASK, M2);
-	config->gain_mask.m3 =
-		AEC_GET_FLOAT(ini, GAIN_MASK, M3);
-	config->gain_mask.m5 =
-		AEC_GET_FLOAT(ini, GAIN_MASK, M5);
-	config->gain_mask.m6 =
-		AEC_GET_FLOAT(ini, GAIN_MASK, M6);
-	config->gain_mask.m7 =
-		AEC_GET_FLOAT(ini, GAIN_MASK, M7);
-	config->gain_mask.m8 =
-		AEC_GET_FLOAT(ini, GAIN_MASK, M8);
-	config->gain_mask.m9 =
-		AEC_GET_FLOAT(ini, GAIN_MASK, M9);
-	config->gain_mask.gain_curve_offset =
-		AEC_GET_FLOAT(ini, GAIN_MASK, GAIN_CURVE_OFFSET);
-	config->gain_mask.gain_curve_slope =
-		AEC_GET_FLOAT(ini, GAIN_MASK, GAIN_CURVE_SLOPE);
-	config->gain_mask.temporal_masking_lf =
-		AEC_GET_FLOAT(ini, GAIN_MASK, TEMPORAL_MASKING_LF);
-	config->gain_mask.temporal_masking_hf =
-		AEC_GET_FLOAT(ini, GAIN_MASK, TEMPORAL_MASKING_HF);
-	config->gain_mask.temporal_masking_lf_bands =
-		AEC_GET_INT(ini, GAIN_MASK, TEMPORAL_MASKING_LF_BANDS);
-
 	config->echo_audibility.low_render_limit =
 		AEC_GET_FLOAT(ini, ECHO_AUDIBILITY, LOW_RENDER_LIMIT);
 	config->echo_audibility.normal_render_limit =
@@ -157,6 +148,9 @@
 		AEC_GET_FLOAT(ini, ECHO_AUDIBILITY, AUDIBILITY_THRESHOLD_HF);
 	config->echo_audibility.use_stationary_properties =
 		AEC_GET_INT(ini, ECHO_AUDIBILITY, USE_STATIONARY_PROPERTIES);
+	config->echo_audibility.use_stationarity_properties_at_init =
+		AEC_GET_INT(ini, ECHO_AUDIBILITY,
+			    USE_STATIONARITY_PROPERTIES_AT_INIT);
 
 	config->render_levels.active_render_limit =
 		AEC_GET_FLOAT(ini, RENDER_LEVELS, ACTIVE_RENDER_LIMIT);
@@ -253,6 +247,9 @@
 	config->suppressor.dominant_nearend_detection.enr_threshold =
 		AEC_GET_FLOAT(ini, SUPPRESSOR_DOMINANT_NEAREND_DETECTION,
 			ENR_THRESHOLD);
+	config->suppressor.dominant_nearend_detection.enr_exit_threshold =
+		AEC_GET_FLOAT(ini, SUPPRESSOR_DOMINANT_NEAREND_DETECTION,
+			ENR_EXIT_THRESHOLD);
 	config->suppressor.dominant_nearend_detection.snr_threshold =
 		AEC_GET_FLOAT(ini, SUPPRESSOR_DOMINANT_NEAREND_DETECTION,
 			SNR_THRESHOLD);
@@ -262,6 +259,9 @@
 	config->suppressor.dominant_nearend_detection.trigger_threshold =
 		AEC_GET_INT(ini, SUPPRESSOR_DOMINANT_NEAREND_DETECTION,
 			TRIGGER_THRESHOLD);
+	config->suppressor.dominant_nearend_detection.use_during_initial_phase =
+		AEC_GET_INT(ini, SUPPRESSOR_DOMINANT_NEAREND_DETECTION,
+			USE_DURING_INITIAL_PHASE);
 
 	config->suppressor.high_bands_suppression.enr_threshold =
 		AEC_GET_FLOAT(ini, SUPPRESSOR_HIGH_BANDS_SUPPRESSION,
@@ -285,6 +285,14 @@
 	aec_config_get(ini, &config);
 
 	syslog(LOG_ERR, "---- aec config dump ----");
+	syslog(LOG_ERR, "Buffering:");
+	syslog(LOG_ERR, "    use_new_render_buffering %d",
+			config.buffering.use_new_render_buffering);
+	syslog(LOG_ERR, "    excess_render_detection_interval_blocks %zu",
+			config.buffering.excess_render_detection_interval_blocks);
+	syslog(LOG_ERR, "    max_allowed_excess_render_blocks %zu",
+			config.buffering.max_allowed_excess_render_blocks);
+
 	syslog(LOG_ERR, "Delay:");
 	syslog(LOG_ERR, "    default_delay %zu sampling_factor %zu num_filters %zu",
 			config.delay.default_delay,
@@ -301,14 +309,23 @@
 			config.delay.skew_hysteresis_blocks);
 	syslog(LOG_ERR, "    fixed_capture_delay_samples %zu",
 			config.delay.fixed_capture_delay_samples);
+	syslog(LOG_ERR, "    delay_estimate_smoothing %f",
+			config.delay.delay_estimate_smoothing);
+	syslog(LOG_ERR, "    delay_candidate_detection_threshold %f",
+			config.delay.delay_candidate_detection_threshold);
+	syslog(LOG_ERR, "    delay_selection_thresholds.initial %d",
+			config.delay.delay_selection_thresholds.initial);
+	syslog(LOG_ERR, "    delay_selection_thresholds.converged %d",
+			config.delay.delay_selection_thresholds.converged);
 
 	syslog(LOG_ERR, "Filter main configuration:");
 	syslog(LOG_ERR, "    length_blocks %zu, leakage_converged %f, leakage_diverged %f",
 			config.filter.main.length_blocks,
 			config.filter.main.leakage_converged,
 			config.filter.main.leakage_diverged);
-	syslog(LOG_ERR, "    error_floor %f, noise_gate %f",
+	syslog(LOG_ERR, "    error_floor %f, error_ceil %f, noise_gate %f",
 			config.filter.main.error_floor,
+			config.filter.main.error_ceil,
 			config.filter.main.noise_gate);
 	syslog(LOG_ERR, "Filter shadow configuration:");
 	syslog(LOG_ERR, "    length_blocks %zu, rate %f, noise_gate %f",
@@ -316,12 +333,13 @@
 			config.filter.shadow.rate,
 			config.filter.shadow.noise_gate);
 	syslog(LOG_ERR, "Filter main initial configuration:");
-	syslog(LOG_ERR, "    length_blocks %zu, leakage_converged %f",
+	syslog(LOG_ERR, "    length_blocks %zu, leakage_converged %f leakage_diverged %f",
 			config.filter.main_initial.length_blocks,
-			config.filter.main_initial.leakage_converged);
-	syslog(LOG_ERR, "    leakage_diverged %f, error_floor %f, noise_gate %f",
-			config.filter.main_initial.leakage_diverged,
+			config.filter.main_initial.leakage_converged,
+			config.filter.main_initial.leakage_diverged);
+	syslog(LOG_ERR, "    error_floor %f, error_ceil %f, noise_gate %f",
 			config.filter.main_initial.error_floor,
+			config.filter.main_initial.error_ceil,
 			config.filter.main_initial.noise_gate);
 	syslog(LOG_ERR, "Filter shadow initial configuration:");
 	syslog(LOG_ERR, "    length_blocks %zu, rate %f, noise_gate %f",
@@ -349,25 +367,6 @@
 			config.ep_strength.echo_can_saturate,
 			config.ep_strength.bounded_erl,
 			config.ep_strength.reverb_based_on_render);
-	syslog(LOG_ERR, "Gain mask: m0 %f m1 %f m2 %f m3 %f m5 %f",
-			config.gain_mask.m0,
-			config.gain_mask.m1,
-			config.gain_mask.m2,
-			config.gain_mask.m3,
-			config.gain_mask.m5);
-	syslog(LOG_ERR, "    m6 %f m7 %f m8 %f m9 %f",
-			config.gain_mask.m6,
-			config.gain_mask.m7,
-			config.gain_mask.m8,
-			config.gain_mask.m9);
-	syslog(LOG_ERR, "    gain_curve offset %f, gain_curve_slope %f",
-			config.gain_mask.gain_curve_offset,
-			config.gain_mask.gain_curve_slope);
-	syslog(LOG_ERR, "    temporal_masking_lf %f, temporal_masking_hf %f",
-			config.gain_mask.temporal_masking_lf,
-			config.gain_mask.temporal_masking_hf);
-	syslog(LOG_ERR, "    temporal_masking_lf_bands %zu",
-			config.gain_mask.temporal_masking_lf_bands);
 	syslog(LOG_ERR, "Echo audibility:");
 	syslog(LOG_ERR, "    low_render_limit %f, normal_render_limit %f",
 			config.echo_audibility.low_render_limit,
@@ -381,6 +380,9 @@
 			config.echo_audibility.audibility_threshold_hf);
 	syslog(LOG_ERR, "    use_stationary_properties %d",
 			config.echo_audibility.use_stationary_properties);
+	syslog(LOG_ERR, "    use_stationarity_properties_at_init %d",
+			config.echo_audibility.use_stationarity_properties_at_init);
+
 	syslog(LOG_ERR, "Render levels:");
 	syslog(LOG_ERR, "    active_render_limit %f",
 			config.render_levels.active_render_limit);
@@ -447,12 +449,16 @@
 	syslog(LOG_ERR, "    Dominant nearend detection:");
 	syslog(LOG_ERR, "        enr_threshold %f",
 			config.suppressor.dominant_nearend_detection.enr_threshold);
+	syslog(LOG_ERR, "        enr_exit_threshold %f",
+			config.suppressor.dominant_nearend_detection.enr_exit_threshold);
 	syslog(LOG_ERR, "        snr_threshold %f",
 			config.suppressor.dominant_nearend_detection.snr_threshold);
 	syslog(LOG_ERR, "        hold_duration %d",
 			config.suppressor.dominant_nearend_detection.hold_duration);
 	syslog(LOG_ERR, "        trigger_threshold %d",
 			config.suppressor.dominant_nearend_detection.trigger_threshold);
+	syslog(LOG_ERR, "        use_during_initial_phase %d",
+			config.suppressor.dominant_nearend_detection.use_during_initial_phase);
 	syslog(LOG_ERR, "    High bands suppression:");
 	syslog(LOG_ERR, "        enr_threshold %f max_gain_during_echo %f",
 			config.suppressor.high_bands_suppression.enr_threshold,
diff --git a/cras-config/aec_config.h b/cras-config/aec_config.h
index 8255ce5..5318ac9 100644
--- a/cras-config/aec_config.h
+++ b/cras-config/aec_config.h
@@ -10,12 +10,21 @@
 
 #include "api/audio/echo_canceller3_config.h"
 
+#define AEC_BUFFERING_USE_NEW_RENDER_BUFFERING "buffering:use_new_render_buffering"
+#define AEC_BUFFERING_USE_NEW_RENDER_BUFFERING_VALUE 1
+#define AEC_BUFFERING_EXCESS_RENDER_DETECTION_INTERVAL_BLOCKS \
+	"buffering:excess_render_detection_interval_blocks"
+#define AEC_BUFFERING_EXCESS_RENDER_DETECTION_INTERVAL_BLOCKS_VALUE 250
+#define AEC_BUFFERING_MAX_ALLOWED_EXCESS_RENDER_BLOCKS \
+	"buffering:max_allowed_excess_render_blocks"
+#define AEC_BUFFERING_MAX_ALLOWED_EXCESS_RENDER_BLOCKS_VALUE 8
+
 #define AEC_DELAY_DEFAULT_DELAY "delay:default_delay"
 #define AEC_DELAY_DEFAULT_DELAY_VALUE 5
 #define AEC_DELAY_DOWN_SAMPLING_FACTOR "delay:down_sampling_factor"
 #define AEC_DELAY_DOWN_SAMPLING_FACTOR_VALUE 4
 #define AEC_DELAY_NUM_FILTERS "delay:num_filters"
-#define AEC_DELAY_NUM_FILTERS_VALUE 6
+#define AEC_DELAY_NUM_FILTERS_VALUE 5
 #define AEC_DELAY_API_CALL_JITTER_BLOCKS "delay:api_call_jitter_blocks"
 #define AEC_DELAY_API_CALL_JITTER_BLOCKS_VALUE 26
 #define AEC_DELAY_MIN_ECHO_PATH_DELAY_BLOCKS "delay:min_echo_path_delay_blocks"
@@ -31,6 +40,17 @@
 #define AEC_DELAY_FIXED_CAPTURE_DELAY_SAMPLES \
 	"delay:fixed_capture_delay_samples"
 #define AEC_DELAY_FIXED_CAPTURE_DELAY_SAMPLES_VALUE 0
+#define AEC_DELAY_DELAY_ESTIMATE_SMOOTHING "delay:delay_estimate_smoothing"
+#define AEC_DELAY_DELAY_ESTIMATE_SMOOTHING_VALUE 0.7f
+#define AEC_DELAY_DELAY_CANDIDATE_DETECTION_THRESHOLD \
+	"delay:delay_candidate_detection_threshold"
+#define AEC_DELAY_DELAY_CANDIDATE_DETECTION_THRESHOLD_VALUE 0.2f
+#define AEC_DELAY_DELAY_SELECTION_THRESHOLD_INITIAL \
+	"delay:delay_selection_thresholds_initial"
+#define AEC_DELAY_DELAY_SELECTION_THRESHOLD_INITIAL_VALUE 5
+#define AEC_DELAY_DELAY_SELECTION_THRESHOLD_CONVERGED \
+	"delay:delay_selection_thresholds_converged"
+#define AEC_DELAY_DELAY_SELECTION_THRESHOLD_CONVERGED_VALUE 20
 
 // Filter Main configuration
 #define AEC_FILTER_MAIN_LENGTH_BLOCKS "filter.main:length_blocks"
@@ -38,9 +58,11 @@
 #define AEC_FILTER_MAIN_LEAKAGE_CONVERGED "filter.main:leakage_converged"
 #define AEC_FILTER_MAIN_LEAKAGE_CONVERGED_VALUE 0.00005f
 #define AEC_FILTER_MAIN_LEAKAGE_DIVERGED "filter.main:leakage_diverged"
-#define AEC_FILTER_MAIN_LEAKAGE_DIVERGED_VALUE 0.01f
+#define AEC_FILTER_MAIN_LEAKAGE_DIVERGED_VALUE 0.05f
 #define AEC_FILTER_MAIN_ERROR_FLOOR "filter.main:error_floor"
-#define AEC_FILTER_MAIN_ERROR_FLOOR_VALUE 0.1f
+#define AEC_FILTER_MAIN_ERROR_FLOOR_VALUE 0.001f
+#define AEC_FILTER_MAIN_ERROR_CEIL "filter.main:error_ceil"
+#define AEC_FILTER_MAIN_ERROR_CEIL_VALUE 2.f
 #define AEC_FILTER_MAIN_NOISE_GATE "filter.main:noise_gate"
 #define AEC_FILTER_MAIN_NOISE_GATE_VALUE 20075344.f
 
@@ -63,6 +85,8 @@
 #define AEC_FILTER_MAIN_INIT_LEAKAGE_DIVERGED_VALUE 0.5f
 #define AEC_FILTER_MAIN_INIT_ERROR_FLOOR "filter.main_initial:error_floor"
 #define AEC_FILTER_MAIN_INIT_ERROR_FLOOR_VALUE 0.001f
+#define AEC_FILTER_MAIN_INIT_ERROR_CEIL "filter.main_initial:error_ceil"
+#define AEC_FILTER_MAIN_INIT_ERROR_CEIL_VALUE 2.f
 #define AEC_FILTER_MAIN_INIT_NOISE_GATE "filter.main_initial:noise_gate"
 #define AEC_FILTER_MAIN_INIT_NOISE_GATE_VALUE 20075344.f
 
@@ -105,7 +129,7 @@
 #define AEC_EP_STRENGTH_HF "ep_strength:hf"
 #define AEC_EP_STRENGTH_HF_VALUE 1.f
 #define AEC_EP_STRENGTH_DEFAULT_LEN "ep_strength:default_len"
-#define AEC_EP_STRENGTH_DEFAULT_LEN_VALUE 0.88f
+#define AEC_EP_STRENGTH_DEFAULT_LEN_VALUE 0.83f
 #define AEC_EP_STRENGTH_REVERB_BASED_ON_RENDER \
 	"ep_strength:reverb_based_on_render"
 #define AEC_EP_STRENGTH_REVERB_BASED_ON_RENDER_VALUE 1
@@ -114,39 +138,6 @@
 #define AEC_EP_STRENGTH_BOUNDED_ERL "ep_strength:bounded_erl"
 #define AEC_EP_STRENGTH_BOUNDED_ERL_VALUE 0
 
-// Gain mask
-#define AEC_GAIN_MASK_M0 "gain_mask:m0"
-#define AEC_GAIN_MASK_M0_VALUE 0.1f
-#define AEC_GAIN_MASK_M1 "gain_mask:m1"
-#define AEC_GAIN_MASK_M1_VALUE 0.01f
-#define AEC_GAIN_MASK_M2 "gain_mask:m2"
-#define AEC_GAIN_MASK_M2_VALUE 0.0001f
-#define AEC_GAIN_MASK_M3 "gain_mask:m3"
-#define AEC_GAIN_MASK_M3_VALUE 0.01f
-// m4 was removed intentionally.
-// https://webrtc-review.googlesource.com/c/src/+/70421
-#define AEC_GAIN_MASK_M5 "gain_mask:m5"
-#define AEC_GAIN_MASK_M5_VALUE 0.01f
-#define AEC_GAIN_MASK_M6 "gain_mask:m6"
-#define AEC_GAIN_MASK_M6_VALUE 0.0001f
-#define AEC_GAIN_MASK_M7 "gain_mask:m7"
-#define AEC_GAIN_MASK_M7_VALUE 0.01f
-#define AEC_GAIN_MASK_M8 "gain_mask:m8"
-#define AEC_GAIN_MASK_M8_VALUE 0.0001f
-#define AEC_GAIN_MASK_M9 "gain_mask:m9"
-#define AEC_GAIN_MASK_M9_VALUE 0.1f
-#define AEC_GAIN_MASK_GAIN_CURVE_OFFSET "gain_mask:gain_curve_offset"
-#define AEC_GAIN_MASK_GAIN_CURVE_OFFSET_VALUE 1.45f
-#define AEC_GAIN_MASK_GAIN_CURVE_SLOPE "gain_mask:gain_curve_slope"
-#define AEC_GAIN_MASK_GAIN_CURVE_SLOPE_VALUE 5.f
-#define AEC_GAIN_MASK_TEMPORAL_MASKING_LF "gain_mask:temporal_masking_lf"
-#define AEC_GAIN_MASK_TEMPORAL_MASKING_LF_VALUE 0.9f
-#define AEC_GAIN_MASK_TEMPORAL_MASKING_HF "gain_mask:temporal_masking_hf"
-#define AEC_GAIN_MASK_TEMPORAL_MASKING_HF_VALUE 0.6f
-#define AEC_GAIN_MASK_TEMPORAL_MASKING_LF_BANDS \
-	"gain_mask:temporal_masking_lf_bands"
-#define AEC_GAIN_MASK_TEMPORAL_MASKING_LF_BANDS_VALUE 3
-
 #define AEC_ECHO_AUDIBILITY_LOW_RENDER_LIMIT "echo_audibility:low_render_limit"
 #define AEC_ECHO_AUDIBILITY_LOW_RENDER_LIMIT_VALUE 4 * 64.f
 #define AEC_ECHO_AUDIBILITY_NORMAL_RENDER_LIMIT \
@@ -166,6 +157,9 @@
 #define AEC_ECHO_AUDIBILITY_USE_STATIONARY_PROPERTIES \
 	"echo_audibility:use_stationary_properties"
 #define AEC_ECHO_AUDIBILITY_USE_STATIONARY_PROPERTIES_VALUE 1
+#define AEC_ECHO_AUDIBILITY_USE_STATIONARITY_PROPERTIES_AT_INIT \
+	 "echo_audibility:use_stationarity_properties_at_init"
+#define AEC_ECHO_AUDIBILITY_USE_STATIONARITY_PROPERTIES_AT_INIT_VALUE 1
 
 // Rendering levels
 #define AEC_RENDER_LEVELS_ACTIVE_RENDER_LIMIT \
@@ -231,10 +225,10 @@
 
 #define AEC_SUPPRESSOR_NORMAL_TUNING_MASK_LF_ENR_TRANSPARENT \
 	"suppressor.normal_tuning:mask_lf_enr_transparent"
-#define AEC_SUPPRESSOR_NORMAL_TUNING_MASK_LF_ENR_TRANSPARENT_VALUE .2f
+#define AEC_SUPPRESSOR_NORMAL_TUNING_MASK_LF_ENR_TRANSPARENT_VALUE .3f
 #define AEC_SUPPRESSOR_NORMAL_TUNING_MASK_LF_ENR_SUPPRESS \
 	"suppressor.normal_tuning:mask_lf_enr_suppress"
-#define AEC_SUPPRESSOR_NORMAL_TUNING_MASK_LF_ENR_SUPPRESS_VALUE .3f
+#define AEC_SUPPRESSOR_NORMAL_TUNING_MASK_LF_ENR_SUPPRESS_VALUE .4f
 #define AEC_SUPPRESSOR_NORMAL_TUNING_MASK_LF_EMR_TRANSPARENT \
 	"suppressor.normal_tuning:mask_lf_emr_transparent"
 #define AEC_SUPPRESSOR_NORMAL_TUNING_MASK_LF_EMR_TRANSPARENT_VALUE .3f
@@ -258,20 +252,20 @@
 
 #define AEC_SUPPRESSOR_NEAREND_TUNING_MASK_LF_ENR_TRANSPARENT \
 	"suppressor.nearend_tuning:mask_lf_enr_transparent"
-#define AEC_SUPPRESSOR_NEAREND_TUNING_MASK_LF_ENR_TRANSPARENT_VALUE .2f
+#define AEC_SUPPRESSOR_NEAREND_TUNING_MASK_LF_ENR_TRANSPARENT_VALUE 1.09f
 #define AEC_SUPPRESSOR_NEAREND_TUNING_MASK_LF_ENR_SUPPRESS \
 	"suppressor.nearend_tuning:mask_lf_enr_suppress"
-#define AEC_SUPPRESSOR_NEAREND_TUNING_MASK_LF_ENR_SUPPRESS_VALUE .3f
+#define AEC_SUPPRESSOR_NEAREND_TUNING_MASK_LF_ENR_SUPPRESS_VALUE 1.1f
 #define AEC_SUPPRESSOR_NEAREND_TUNING_MASK_LF_EMR_TRANSPARENT \
 	"suppressor.nearend_tuning:mask_lf_emr_transparent"
 #define AEC_SUPPRESSOR_NEAREND_TUNING_MASK_LF_EMR_TRANSPARENT_VALUE .3f
 
 #define AEC_SUPPRESSOR_NEAREND_TUNING_MASK_HF_ENR_TRANSPARENT \
 	"suppressor.nearend_tuning:mask_hf_enr_transparent"
-#define AEC_SUPPRESSOR_NEAREND_TUNING_MASK_HF_ENR_TRANSPARENT_VALUE .07f
+#define AEC_SUPPRESSOR_NEAREND_TUNING_MASK_HF_ENR_TRANSPARENT_VALUE .1f
 #define AEC_SUPPRESSOR_NEAREND_TUNING_MASK_HF_ENR_SUPPRESS \
 	"suppressor.nearend_tuning:mask_hf_enr_suppress"
-#define AEC_SUPPRESSOR_NEAREND_TUNING_MASK_HF_ENR_SUPPRESS_VALUE .1f
+#define AEC_SUPPRESSOR_NEAREND_TUNING_MASK_HF_ENR_SUPPRESS_VALUE .3f
 #define AEC_SUPPRESSOR_NEAREND_TUNING_MASK_HF_EMR_TRANSPARENT \
 	"suppressor.nearend_tuning:mask_hf_emr_transparent"
 #define AEC_SUPPRESSOR_NEAREND_TUNING_MASK_HF_EMR_TRANSPARENT_VALUE .3f
@@ -285,16 +279,22 @@
 
 #define AEC_SUPPRESSOR_DOMINANT_NEAREND_DETECTION_ENR_THRESHOLD \
 	"suppressor.dominant_nearend_detection:enr_threshold"
-#define AEC_SUPPRESSOR_DOMINANT_NEAREND_DETECTION_ENR_THRESHOLD_VALUE 10.f
+#define AEC_SUPPRESSOR_DOMINANT_NEAREND_DETECTION_ENR_THRESHOLD_VALUE 4.f
+#define AEC_SUPPRESSOR_DOMINANT_NEAREND_DETECTION_ENR_EXIT_THRESHOLD \
+	"suppressor.dominant_nearend_detection:enr_exit_threshold"
+#define AEC_SUPPRESSOR_DOMINANT_NEAREND_DETECTION_ENR_EXIT_THRESHOLD_VALUE .1f
 #define AEC_SUPPRESSOR_DOMINANT_NEAREND_DETECTION_SNR_THRESHOLD \
 	"suppressor.dominant_nearend_detection:snr_threshold"
-#define AEC_SUPPRESSOR_DOMINANT_NEAREND_DETECTION_SNR_THRESHOLD_VALUE 10.f
+#define AEC_SUPPRESSOR_DOMINANT_NEAREND_DETECTION_SNR_THRESHOLD_VALUE 30.f
 #define AEC_SUPPRESSOR_DOMINANT_NEAREND_DETECTION_HOLD_DURATION \
 	"suppressor.dominant_nearend_detection:hold_duration"
-#define AEC_SUPPRESSOR_DOMINANT_NEAREND_DETECTION_HOLD_DURATION_VALUE 25
+#define AEC_SUPPRESSOR_DOMINANT_NEAREND_DETECTION_HOLD_DURATION_VALUE 50
 #define AEC_SUPPRESSOR_DOMINANT_NEAREND_DETECTION_TRIGGER_THRESHOLD \
 	"suppressor.dominant_nearend_detection:trigger_threshold"
-#define AEC_SUPPRESSOR_DOMINANT_NEAREND_DETECTION_TRIGGER_THRESHOLD_VALUE 15
+#define AEC_SUPPRESSOR_DOMINANT_NEAREND_DETECTION_TRIGGER_THRESHOLD_VALUE 12
+#define AEC_SUPPRESSOR_DOMINANT_NEAREND_DETECTION_USE_DURING_INITIAL_PHASE \
+	"suppressor.dominant_nearend_detection:use_during_initial_phase"
+#define AEC_SUPPRESSOR_DOMINANT_NEAREND_DETECTION_USE_DURING_INITIAL_PHASE_VALUE 1
 
 #define AEC_SUPPRESSOR_HIGH_BANDS_SUPPRESSION_ENR_THRESHOLD \
 	"suppressor.high_bands_suppression:enr_threshold"
diff --git a/cras-config/apm_config.cc b/cras-config/apm_config.cc
index bcf1c96..b03f8d5 100644
--- a/cras-config/apm_config.cc
+++ b/cras-config/apm_config.cc
@@ -37,10 +37,12 @@
 			APM_GET_FLOAT(ini, APM_PRE_AMPLIFIER_FIXED_GAIN_FACTOR);
 	config.gain_controller2.enabled =
 			APM_GET_INT(ini, APM_GAIN_CONTROLLER2_ENABLED);
-	config.gain_controller2.fixed_gain_db =
-			APM_GET_FLOAT(ini, APM_GAIN_CONTROLLER2_FIXED_GAIN_DB);
 	config.gain_controller2.adaptive_digital_mode =
-			APM_GET_INT(ini, APM_GAIN_CONTROLLER2_ADAPTIVE_DIGITAL_MODE);
+		APM_GET_INT(ini, APM_GAIN_CONTROLLER2_ADAPTIVE_DIGITAL_MODE);
+	config.gain_controller2.extra_saturation_margin_db =
+		APM_GET_FLOAT(ini, APM_GAIN_CONTROLLER2_EXTRA_SATURATION_MARGIN_DB);
+	config.gain_controller2.fixed_gain_db =
+		APM_GET_FLOAT(ini, APM_GAIN_CONTROLLER2_FIXED_GAIN_DB);
 	apm->ApplyConfig(config);
 
 	apm->gain_control()->set_compression_gain_db(
@@ -71,10 +73,12 @@
 		APM_GET_FLOAT(ini, APM_PRE_AMPLIFIER_FIXED_GAIN_FACTOR));
 	syslog(LOG_ERR, "gain_controller2_enabled %u",
 		APM_GET_INT(ini, APM_GAIN_CONTROLLER2_ENABLED));
-	syslog(LOG_ERR, "gain_controller2_fixed_gain_db %f",
-		APM_GET_FLOAT(ini, APM_GAIN_CONTROLLER2_FIXED_GAIN_DB));
 	syslog(LOG_ERR, "gain_controller2_adaptive_digital_mode %d",
 		APM_GET_INT(ini, APM_GAIN_CONTROLLER2_ADAPTIVE_DIGITAL_MODE));
+	syslog(LOG_ERR, "gain_controller2_extra_saturation_margin_db %f",
+		APM_GET_FLOAT(ini, APM_GAIN_CONTROLLER2_EXTRA_SATURATION_MARGIN_DB));
+	syslog(LOG_ERR, "gain_controller2_fixed_gain_db %f",
+		APM_GET_FLOAT(ini, APM_GAIN_CONTROLLER2_FIXED_GAIN_DB));
 	syslog(LOG_ERR, "gain_control_compression_gain_db %u",
 		APM_GET_INT(ini, APM_GAIN_CONTROL_COMPRESSION_GAIN_DB));
 	syslog(LOG_ERR, "gain_control_mode %u",
diff --git a/cras-config/apm_config.h b/cras-config/apm_config.h
index 30d2b04..a223877 100644
--- a/cras-config/apm_config.h
+++ b/cras-config/apm_config.h
@@ -24,6 +24,9 @@
 #define APM_GAIN_CONTROLLER2_FIXED_GAIN_DB_VALUE 0.f
 #define APM_GAIN_CONTROLLER2_ADAPTIVE_DIGITAL_MODE "apm:gain_controller2_adaptive_digital_mode"
 #define APM_GAIN_CONTROLLER2_ADAPTIVE_DIGITAL_MODE_VALUE 1
+#define APM_GAIN_CONTROLLER2_EXTRA_SATURATION_MARGIN_DB \
+	"apm:gain_controller2_extra_saturation_margin_db"
+#define APM_GAIN_CONTROLLER2_EXTRA_SATURATION_MARGIN_DB_VALUE 2.f
 #define APM_GAIN_CONTROL_COMPRESSION_GAIN_DB "apm:gain_control_compression_gain_db"
 #define APM_GAIN_CONTROL_COMPRESSION_GAIN_DB_VALUE 9
 /* 0: adaptive analog, 1: adaptive digital, 2: fixed digital */
diff --git a/modules/audio_coding/BUILD.gn b/modules/audio_coding/BUILD.gn
index 5889018..ec81697 100644
--- a/modules/audio_coding/BUILD.gn
+++ b/modules/audio_coding/BUILD.gn
@@ -15,7 +15,6 @@
 visibility = [ ":*" ]
 
 audio_codec_deps = [
-  ":cng",
   ":g711",
   ":pcm16b",
 ]
@@ -53,6 +52,7 @@
     "../../rtc_base:checks",
     "../../rtc_base:rtc_base_approved",
     "../../rtc_base:sanitizer",
+    "//third_party/abseil-cpp/absl/strings",
     "//third_party/abseil-cpp/absl/types:optional",
   ]
 }
@@ -74,6 +74,7 @@
   deps = [
            "../../rtc_base:checks",
            "../../api:array_view",
+           "//third_party/abseil-cpp/absl/strings",
            "//third_party/abseil-cpp/absl/types:optional",
            "../../api/audio_codecs:audio_codecs_api",
            "../..:webrtc_common",
@@ -83,6 +84,7 @@
            ":audio_coding_module_typedefs",
            ":isac_common",
            ":isac_fix_c",
+           ":audio_encoder_cng",
            ":neteq_decoder_enum",
          ] + audio_codec_deps
 
@@ -126,6 +128,7 @@
            "../../system_wrappers:metrics",
            "../../api/audio:audio_frame_api",
            "..:module_api",
+           "..:module_api_public",
            "../../common_audio:common_audio_c",
            "../../rtc_base:deprecation",
            "../../rtc_base:checks",
@@ -133,9 +136,11 @@
            "../../api/audio_codecs:audio_codecs_api",
            ":audio_coding_module_typedefs",
            ":neteq",
+           ":neteq_decoder_enum",
            ":rent_a_codec",
            "../../rtc_base:audio_format_to_string",
            "../../rtc_base:rtc_base_approved",
+           "//third_party/abseil-cpp/absl/strings",
            "//third_party/abseil-cpp/absl/types:optional",
            "../../logging:rtc_event_log_api",
          ]
@@ -150,26 +155,41 @@
   deps = [
     "../../api:array_view",
     "../../api/audio_codecs:audio_codecs_api",
+    "../../rtc_base:checks",
     "../../rtc_base:rtc_base_approved",
+    "//third_party/abseil-cpp/absl/types:optional",
   ]
 }
 
-rtc_static_library("cng") {
-  visibility += [ "*" ]
+rtc_static_library("webrtc_cng") {
+  visibility += webrtc_default_visibility
   sources = [
-    "codecs/cng/audio_encoder_cng.cc",
-    "codecs/cng/audio_encoder_cng.h",
     "codecs/cng/webrtc_cng.cc",
     "codecs/cng/webrtc_cng.h",
   ]
 
   deps = [
-    "../..:webrtc_common",
     "../../api:array_view",
+    "../../common_audio:common_audio_c",
+    "../../rtc_base:checks",
+    "../../rtc_base:rtc_base_approved",
+    "../../rtc_base:safe_conversions",
+  ]
+}
+
+rtc_static_library("audio_encoder_cng") {
+  visibility += [ "*" ]
+  sources = [
+    "codecs/cng/audio_encoder_cng.cc",
+    "codecs/cng/audio_encoder_cng.h",
+  ]
+
+  deps = [
+    ":webrtc_cng",
     "../../api/audio_codecs:audio_codecs_api",
     "../../common_audio",
-    "../../common_audio:common_audio_c",
-    "../../rtc_base:rtc_base_approved",
+    "../../rtc_base:checks",
+    "//third_party/abseil-cpp/absl/memory",
   ]
 }
 
@@ -181,10 +201,12 @@
   ]
 
   deps = [
+    "../../api:array_view",
     "../../api/audio_codecs:audio_codecs_api",
     "../../common_audio",
     "../../rtc_base:checks",
     "../../rtc_base:rtc_base_approved",
+    "//third_party/abseil-cpp/absl/types:optional",
   ]
 }
 
@@ -201,6 +223,7 @@
   deps = [
     ":legacy_encoded_audio_frame",
     "../..:webrtc_common",
+    "../../api:array_view",
     "../../api/audio_codecs:audio_codecs_api",
     "../../rtc_base:checks",
     "../../rtc_base:rtc_base_approved",
@@ -235,6 +258,7 @@
   deps = [
     ":legacy_encoded_audio_frame",
     "../..:webrtc_common",
+    "../../api:array_view",
     "../../api/audio_codecs:audio_codecs_api",
     "../../api/audio_codecs/g722:audio_encoder_g722_config",
     "../../rtc_base:checks",
@@ -270,6 +294,7 @@
   deps = [
     ":legacy_encoded_audio_frame",
     "../..:webrtc_common",
+    "../../api:array_view",
     "../../api/audio_codecs:audio_codecs_api",
     "../../api/audio_codecs/ilbc:audio_encoder_ilbc_config",
     "../../common_audio",
@@ -786,6 +811,7 @@
     ":g711",
     ":legacy_encoded_audio_frame",
     "../..:webrtc_common",
+    "../../api:array_view",
     "../../api/audio_codecs:audio_codecs_api",
     "../../rtc_base:checks",
     "../../rtc_base:rtc_base_approved",
@@ -820,6 +846,7 @@
   deps = [
     ":audio_network_adaptor",
     "../..:webrtc_common",
+    "../../api:array_view",
     "../../api/audio_codecs:audio_codecs_api",
     "../../api/audio_codecs/opus:audio_encoder_opus_config",
     "../../common_audio",
@@ -829,6 +856,7 @@
     "../../rtc_base:safe_minmax",
     "../../system_wrappers:field_trial",
     "//third_party/abseil-cpp/absl/memory",
+    "//third_party/abseil-cpp/absl/strings",
     "//third_party/abseil-cpp/absl/types:optional",
   ]
   public_deps = [
@@ -882,6 +910,7 @@
     proto_out_dir = "modules/audio_coding/audio_network_adaptor"
   }
   proto_library("ana_config_proto") {
+    visibility += webrtc_default_visibility
     sources = [
       "audio_network_adaptor/config.proto",
     ]
@@ -1048,9 +1077,10 @@
 
   deps = [
     ":audio_coding_module_typedefs",
-    ":cng",
     ":neteq_decoder_enum",
+    ":webrtc_cng",
     "..:module_api",
+    "..:module_api_public",
     "../..:webrtc_common",
     "../../api:array_view",
     "../../api:libjingle_peerconnection_api",
@@ -1067,6 +1097,7 @@
     "../../rtc_base/system:fallthrough",
     "../../system_wrappers:field_trial",
     "../../system_wrappers:metrics",
+    "//third_party/abseil-cpp/absl/strings",
     "//third_party/abseil-cpp/absl/types:optional",
   ]
 }
@@ -1105,6 +1136,7 @@
     "../rtp_rtcp",
     "//third_party/abseil-cpp/absl/types:optional",
   ]
+  defines = audio_codec_defines
 }
 
 rtc_source_set("neteq_test_tools") {
@@ -1145,6 +1177,7 @@
     "../../test:rtp_test_utils",
     "../rtp_rtcp",
     "../rtp_rtcp:rtp_rtcp_format",
+    "//third_party/abseil-cpp/absl/types:optional",
   ]
 
   public_deps = [
@@ -1238,6 +1271,7 @@
       "../../rtc_base:rtc_base_approved",
       "../rtp_rtcp",
       "../rtp_rtcp:rtp_rtcp_format",
+      "//third_party/abseil-cpp/absl/types:optional",
     ]
     public_deps = [
       "../../logging:rtc_event_log_proto",
@@ -1330,8 +1364,8 @@
     deps = [
       ":audio_coding",
       ":audio_coding_module_typedefs",
+      ":audio_encoder_cng",
       ":audio_format_conversion",
-      ":cng",
       ":pcm16b_c",
       ":red",
       "..:module_api",
@@ -1359,6 +1393,7 @@
       "../../system_wrappers",
       "../../test:fileutils",
       "../../test:test_support",
+      "//third_party/abseil-cpp/absl/strings",
       "//third_party/abseil-cpp/absl/types:optional",
     ]
     defines = audio_coding_defines
@@ -1414,6 +1449,7 @@
              ":neteq_tools",
              "../../rtc_base:rtc_base_approved",
              "../../test:test_support",
+             "//third_party/abseil-cpp/absl/strings",
              "//testing/gtest",
            ]
   }
@@ -1477,6 +1513,7 @@
              "../../rtc_base/system:arch",
              "../../test:test_main",
              "//testing/gtest",
+             "../../test:test_support",
            ] + audio_coding_deps
 
     data = audio_decoder_unittests_resources
@@ -1501,7 +1538,7 @@
     rtc_source_set("neteq_test_factory") {
       testonly = true
       visibility += webrtc_default_visibility
-      defines = []
+      defines = audio_codec_defines
       deps = [
         "../../rtc_base:checks",
         "../../test:fileutils",
@@ -1594,6 +1631,7 @@
       "../../api:libjingle_peerconnection_api",
       "../../rtc_base:rtc_base_approved",
       "../../test:test_main",
+      "../../test:test_support",
       "../audio_processing",
       "//testing/gtest",
     ]
@@ -1661,6 +1699,7 @@
     deps = audio_coding_deps + [
              "//third_party/abseil-cpp/absl/memory",
              ":audio_coding",
+             ":audio_encoder_cng",
              ":neteq_input_audio_tools",
              "../../api/audio:audio_frame_api",
              "../../api/audio_codecs/g711:audio_encoder_g711",
@@ -1955,6 +1994,7 @@
       "../../rtc_base:rtc_base_approved",
       "../../test:fileutils",
       "../../test:test_main",
+      "../../test:test_support",
       "//testing/gtest",
     ]
   }
@@ -2047,9 +2087,9 @@
       ":acm_send_test",
       ":audio_coding",
       ":audio_coding_module_typedefs",
+      ":audio_encoder_cng",
       ":audio_format_conversion",
       ":audio_network_adaptor",
-      ":cng",
       ":g711",
       ":ilbc",
       ":isac",
@@ -2063,6 +2103,7 @@
       ":pcm16b",
       ":red",
       ":rent_a_codec",
+      ":webrtc_cng",
       ":webrtc_opus",
       "..:module_api",
       "../..:webrtc_common",
@@ -2097,6 +2138,7 @@
       "codecs/opus/test:test_unittest",
       "//testing/gtest",
       "//third_party/abseil-cpp/absl/memory",
+      "//third_party/abseil-cpp/absl/types:optional",
     ]
 
     defines = audio_coding_defines
diff --git a/modules/audio_coding/OWNERS b/modules/audio_coding/OWNERS
index c1adc56..46f9958 100644
--- a/modules/audio_coding/OWNERS
+++ b/modules/audio_coding/OWNERS
@@ -4,6 +4,7 @@
 minyue@webrtc.org
 jan.skoglund@webrtc.org
 ossu@webrtc.org
+ivoc@webrtc.org
 
 # These are for the common case of adding or renaming files. If you're doing
 # structural changes, please get a review from a reviewer in this file.
diff --git a/modules/audio_coding/acm2/acm_codec_database.cc b/modules/audio_coding/acm2/acm_codec_database.cc
index 311af2d..879082c 100644
--- a/modules/audio_coding/acm2/acm_codec_database.cc
+++ b/modules/audio_coding/acm2/acm_codec_database.cc
@@ -17,7 +17,9 @@
 // references, where appropriate.
 #include "modules/audio_coding/acm2/acm_codec_database.h"
 
-#include "rtc_base/checks.h"
+#include "absl/strings/match.h"
+#include "api/array_view.h"
+#include "modules/audio_coding/acm2/rent_a_codec.h"
 
 #if ((defined WEBRTC_CODEC_ISAC) && (defined WEBRTC_CODEC_ISACFX))
 #error iSAC and iSACFX codecs cannot be enabled at the same time
@@ -239,12 +241,12 @@
   }
 
   // Comfort Noise is special case, packet-size & rate is not checked.
-  if (STR_CASE_CMP(database_[codec_id].plname, "CN") == 0) {
+  if (absl::EqualsIgnoreCase(database_[codec_id].plname, "CN")) {
     return codec_id;
   }
 
   // RED is special case, packet-size & rate is not checked.
-  if (STR_CASE_CMP(database_[codec_id].plname, "red") == 0) {
+  if (absl::EqualsIgnoreCase(database_[codec_id].plname, "red")) {
     return codec_id;
   }
 
@@ -272,12 +274,12 @@
 
   // Check the validity of rate. Codecs with multiple rates have their own
   // function for this.
-  if (STR_CASE_CMP("isac", codec_inst.plname) == 0) {
+  if (absl::EqualsIgnoreCase("isac", codec_inst.plname)) {
     return IsISACRateValid(codec_inst.rate) ? codec_id : kInvalidRate;
-  } else if (STR_CASE_CMP("ilbc", codec_inst.plname) == 0) {
+  } else if (absl::EqualsIgnoreCase("ilbc", codec_inst.plname)) {
     return IsILBCRateValid(codec_inst.rate, codec_inst.pacsize) ? codec_id
                                                                 : kInvalidRate;
-  } else if (STR_CASE_CMP("opus", codec_inst.plname) == 0) {
+  } else if (absl::EqualsIgnoreCase("opus", codec_inst.plname)) {
     return IsOpusRateValid(codec_inst.rate) ? codec_id : kInvalidRate;
   }
 
@@ -304,10 +306,10 @@
     // Payload name, sampling frequency and number of channels need to match.
     // NOTE! If |frequency| is -1, the frequency is not applicable, and is
     // always treated as true, like for RED.
-    name_match = (STR_CASE_CMP(ci.plname, payload_name) == 0);
+    name_match = absl::EqualsIgnoreCase(ci.plname, payload_name);
     frequency_match = (frequency == ci.plfreq) || (frequency == -1);
     // The number of channels must match for all codecs but Opus.
-    if (STR_CASE_CMP(payload_name, "opus") != 0) {
+    if (!absl::EqualsIgnoreCase(payload_name, "opus")) {
       channels_match = (channels == ci.channels);
     } else {
       // For opus we just check that number of channels is valid.
diff --git a/modules/audio_coding/acm2/acm_receive_test.cc b/modules/audio_coding/acm2/acm_receive_test.cc
index 2d7f296..c149ec1 100644
--- a/modules/audio_coding/acm2/acm_receive_test.cc
+++ b/modules/audio_coding/acm2/acm_receive_test.cc
@@ -14,6 +14,7 @@
 
 #include <memory>
 
+#include "absl/strings/match.h"
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "modules/audio_coding/codecs/audio_format_conversion.h"
 #include "modules/audio_coding/include/audio_coding_module.h"
@@ -30,11 +31,11 @@
 // Returns true if the codec should be registered, otherwise false. Changes
 // the number of channels for the Opus codec to always be 1.
 bool ModifyAndUseThisCodec(CodecInst* codec_param) {
-  if (STR_CASE_CMP(codec_param->plname, "CN") == 0 &&
+  if (absl::EqualsIgnoreCase(codec_param->plname, "CN") &&
       codec_param->plfreq == 48000)
     return false;  // Skip 48 kHz comfort noise.
 
-  if (STR_CASE_CMP(codec_param->plname, "telephone-event") == 0)
+  if (absl::EqualsIgnoreCase(codec_param->plname, "telephone-event"))
     return false;  // Skip DTFM.
 
   return true;
@@ -65,39 +66,43 @@
     return false;  // Don't use non-mono codecs.
 
   // Re-map pltypes to those used in the NetEq test files.
-  if (STR_CASE_CMP(plname, "PCMU") == 0 && plfreq == 8000) {
+  if (absl::EqualsIgnoreCase(plname, "PCMU") && plfreq == 8000) {
     *pltype = 0;
-  } else if (STR_CASE_CMP(plname, "PCMA") == 0 && plfreq == 8000) {
+  } else if (absl::EqualsIgnoreCase(plname, "PCMA") && plfreq == 8000) {
     *pltype = 8;
-  } else if (STR_CASE_CMP(plname, "CN") == 0 && plfreq == 8000) {
+  } else if (absl::EqualsIgnoreCase(plname, "CN") && plfreq == 8000) {
     *pltype = 13;
-  } else if (STR_CASE_CMP(plname, "CN") == 0 && plfreq == 16000) {
+  } else if (absl::EqualsIgnoreCase(plname, "CN") && plfreq == 16000) {
     *pltype = 98;
-  } else if (STR_CASE_CMP(plname, "CN") == 0 && plfreq == 32000) {
+  } else if (absl::EqualsIgnoreCase(plname, "CN") && plfreq == 32000) {
     *pltype = 99;
-  } else if (STR_CASE_CMP(plname, "ILBC") == 0) {
+  } else if (absl::EqualsIgnoreCase(plname, "ILBC")) {
     *pltype = 102;
-  } else if (STR_CASE_CMP(plname, "ISAC") == 0 && plfreq == 16000) {
+  } else if (absl::EqualsIgnoreCase(plname, "ISAC") && plfreq == 16000) {
     *pltype = 103;
-  } else if (STR_CASE_CMP(plname, "ISAC") == 0 && plfreq == 32000) {
+  } else if (absl::EqualsIgnoreCase(plname, "ISAC") && plfreq == 32000) {
     *pltype = 104;
-  } else if (STR_CASE_CMP(plname, "telephone-event") == 0 && plfreq == 8000) {
+  } else if (absl::EqualsIgnoreCase(plname, "telephone-event") &&
+             plfreq == 8000) {
     *pltype = 106;
-  } else if (STR_CASE_CMP(plname, "telephone-event") == 0 && plfreq == 16000) {
+  } else if (absl::EqualsIgnoreCase(plname, "telephone-event") &&
+             plfreq == 16000) {
     *pltype = 114;
-  } else if (STR_CASE_CMP(plname, "telephone-event") == 0 && plfreq == 32000) {
+  } else if (absl::EqualsIgnoreCase(plname, "telephone-event") &&
+             plfreq == 32000) {
     *pltype = 115;
-  } else if (STR_CASE_CMP(plname, "telephone-event") == 0 && plfreq == 48000) {
+  } else if (absl::EqualsIgnoreCase(plname, "telephone-event") &&
+             plfreq == 48000) {
     *pltype = 116;
-  } else if (STR_CASE_CMP(plname, "red") == 0) {
+  } else if (absl::EqualsIgnoreCase(plname, "red")) {
     *pltype = 117;
-  } else if (STR_CASE_CMP(plname, "L16") == 0 && plfreq == 8000) {
+  } else if (absl::EqualsIgnoreCase(plname, "L16") && plfreq == 8000) {
     *pltype = 93;
-  } else if (STR_CASE_CMP(plname, "L16") == 0 && plfreq == 16000) {
+  } else if (absl::EqualsIgnoreCase(plname, "L16") && plfreq == 16000) {
     *pltype = 94;
-  } else if (STR_CASE_CMP(plname, "L16") == 0 && plfreq == 32000) {
+  } else if (absl::EqualsIgnoreCase(plname, "L16") && plfreq == 32000) {
     *pltype = 95;
-  } else if (STR_CASE_CMP(plname, "G722") == 0) {
+  } else if (absl::EqualsIgnoreCase(plname, "G722")) {
     *pltype = 9;
   } else {
     // Don't use any other codecs.
diff --git a/modules/audio_coding/acm2/acm_receiver.cc b/modules/audio_coding/acm2/acm_receiver.cc
index f631746..3411d90 100644
--- a/modules/audio_coding/acm2/acm_receiver.cc
+++ b/modules/audio_coding/acm2/acm_receiver.cc
@@ -10,21 +10,22 @@
 
 #include "modules/audio_coding/acm2/acm_receiver.h"
 
-#include <stdlib.h>  // malloc
-
-#include <algorithm>  // sort
+#include <stdlib.h>
+#include <string.h>
+#include <cstdint>
 #include <vector>
 
+#include "absl/strings/match.h"
+#include "api/audio/audio_frame.h"
 #include "api/audio_codecs/audio_decoder.h"
-#include "common_audio/signal_processing/include/signal_processing_library.h"
-#include "common_types.h"  // NOLINT(build/include)
+#include "common_types.h"
 #include "modules/audio_coding/acm2/acm_resampler.h"
 #include "modules/audio_coding/acm2/call_statistics.h"
 #include "modules/audio_coding/acm2/rent_a_codec.h"
 #include "modules/audio_coding/neteq/include/neteq.h"
+#include "modules/audio_coding/neteq/neteq_decoder_enum.h"
 #include "modules/include/module_common_types.h"
 #include "rtc_base/checks.h"
-#include "rtc_base/format_macros.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/numerics/safe_conversions.h"
 #include "rtc_base/strings/audio_format_to_string.h"
@@ -92,7 +93,7 @@
     }
     receive_timestamp = NowInTimestamp(ci->plfreq);
 
-    if (STR_CASE_CMP(ci->plname, "cn") == 0) {
+    if (absl::EqualsIgnoreCase(ci->plname, "cn")) {
       if (last_audio_decoder_ && last_audio_decoder_->channels > 1) {
         // This is a CNG and the audio codec is not mono, so skip pushing in
         // packets into NetEq.
@@ -391,7 +392,7 @@
     uint8_t first_payload_byte) const {
   const absl::optional<CodecInst> ci =
       neteq_->GetDecoder(rtp_header.payloadType);
-  if (ci && STR_CASE_CMP(ci->plname, "red") == 0) {
+  if (ci && absl::EqualsIgnoreCase(ci->plname, "red")) {
     // This is a RED packet. Get the payload of the audio codec.
     return neteq_->GetDecoder(first_payload_byte & 0x7f);
   } else {
diff --git a/modules/audio_coding/acm2/acm_receiver.h b/modules/audio_coding/acm2/acm_receiver.h
index a2ae723..8e7d839 100644
--- a/modules/audio_coding/acm2/acm_receiver.h
+++ b/modules/audio_coding/acm2/acm_receiver.h
@@ -11,6 +11,7 @@
 #ifndef MODULES_AUDIO_CODING_ACM2_ACM_RECEIVER_H_
 #define MODULES_AUDIO_CODING_ACM2_ACM_RECEIVER_H_
 
+#include <stdint.h>
 #include <map>
 #include <memory>
 #include <string>
@@ -18,19 +19,21 @@
 
 #include "absl/types/optional.h"
 #include "api/array_view.h"
-#include "api/audio/audio_frame.h"
-#include "common_audio/vad/include/webrtc_vad.h"
+#include "api/audio_codecs/audio_decoder.h"
+#include "api/audio_codecs/audio_format.h"
 #include "modules/audio_coding/acm2/acm_resampler.h"
 #include "modules/audio_coding/acm2/call_statistics.h"
 #include "modules/audio_coding/include/audio_coding_module.h"
-#include "modules/audio_coding/neteq/include/neteq.h"
 #include "rtc_base/criticalsection.h"
 #include "rtc_base/thread_annotations.h"
 
 namespace webrtc {
 
+class Clock;
 struct CodecInst;
 class NetEq;
+struct RTPHeader;
+struct WebRtcRTPHeader;
 
 namespace acm2 {
 
diff --git a/modules/audio_coding/acm2/acm_receiver_unittest.cc b/modules/audio_coding/acm2/acm_receiver_unittest.cc
index 29f2a45..46384fe 100644
--- a/modules/audio_coding/acm2/acm_receiver_unittest.cc
+++ b/modules/audio_coding/acm2/acm_receiver_unittest.cc
@@ -73,12 +73,12 @@
     // If we have a compatible CN specification, stack a CNG on top.
     auto it = cng_payload_types.find(info.sample_rate_hz);
     if (it != cng_payload_types.end()) {
-      AudioEncoderCng::Config config;
+      AudioEncoderCngConfig config;
       config.speech_encoder = std::move(enc);
       config.num_channels = 1;
       config.payload_type = it->second;
       config.vad_mode = Vad::kVadNormal;
-      enc = absl::make_unique<AudioEncoderCng>(std::move(config));
+      enc = CreateComfortNoiseEncoder(std::move(config));
     }
 
     // Actually start using the new encoder.
diff --git a/modules/audio_coding/acm2/acm_resampler.cc b/modules/audio_coding/acm2/acm_resampler.cc
index c0b2064..ca3583e 100644
--- a/modules/audio_coding/acm2/acm_resampler.cc
+++ b/modules/audio_coding/acm2/acm_resampler.cc
@@ -13,7 +13,6 @@
 #include <assert.h>
 #include <string.h>
 
-#include "common_audio/resampler/include/resampler.h"
 #include "rtc_base/logging.h"
 
 namespace webrtc {
diff --git a/modules/audio_coding/acm2/acm_resampler.h b/modules/audio_coding/acm2/acm_resampler.h
index 904ea52..96ba93a 100644
--- a/modules/audio_coding/acm2/acm_resampler.h
+++ b/modules/audio_coding/acm2/acm_resampler.h
@@ -11,6 +11,9 @@
 #ifndef MODULES_AUDIO_CODING_ACM2_ACM_RESAMPLER_H_
 #define MODULES_AUDIO_CODING_ACM2_ACM_RESAMPLER_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "common_audio/resampler/include/push_resampler.h"
 
 namespace webrtc {
diff --git a/modules/audio_coding/acm2/audio_coding_module.cc b/modules/audio_coding/acm2/audio_coding_module.cc
index 60afeb6..334c0e0 100644
--- a/modules/audio_coding/acm2/audio_coding_module.cc
+++ b/modules/audio_coding/acm2/audio_coding_module.cc
@@ -10,16 +10,24 @@
 
 #include "modules/audio_coding/include/audio_coding_module.h"
 
+#include <assert.h>
 #include <algorithm>
+#include <cstdint>
 
+#include "absl/strings/match.h"
+#include "api/array_view.h"
 #include "modules/audio_coding/acm2/acm_receiver.h"
 #include "modules/audio_coding/acm2/acm_resampler.h"
 #include "modules/audio_coding/acm2/codec_manager.h"
 #include "modules/audio_coding/acm2/rent_a_codec.h"
 #include "modules/include/module_common_types.h"
+#include "modules/include/module_common_types_public.h"
+#include "rtc_base/buffer.h"
 #include "rtc_base/checks.h"
+#include "rtc_base/criticalsection.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/numerics/safe_conversions.h"
+#include "rtc_base/thread_annotations.h"
 #include "system_wrappers/include/metrics.h"
 
 namespace webrtc {
@@ -990,7 +998,7 @@
   }
 
   AudioDecoder* isac_decoder = nullptr;
-  if (STR_CASE_CMP(codec.plname, "isac") == 0) {
+  if (absl::EqualsIgnoreCase(codec.plname, "isac")) {
     std::unique_ptr<AudioDecoder>& saved_isac_decoder =
         codec.plfreq == 16000 ? isac_decoder_16k_ : isac_decoder_32k_;
     if (!saved_isac_decoder) {
diff --git a/modules/audio_coding/acm2/audio_coding_module_unittest.cc b/modules/audio_coding/acm2/audio_coding_module_unittest.cc
index 5ac6102..b227cfb 100644
--- a/modules/audio_coding/acm2/audio_coding_module_unittest.cc
+++ b/modules/audio_coding/acm2/audio_coding_module_unittest.cc
@@ -35,6 +35,7 @@
 #include "modules/audio_coding/neteq/tools/packet.h"
 #include "modules/audio_coding/neteq/tools/rtp_file_source.h"
 #include "rtc_base/criticalsection.h"
+#include "rtc_base/event.h"
 #include "rtc_base/messagedigest.h"
 #include "rtc_base/numerics/safe_conversions.h"
 #include "rtc_base/platform_thread.h"
@@ -42,7 +43,6 @@
 #include "rtc_base/system/arch.h"
 #include "rtc_base/thread_annotations.h"
 #include "system_wrappers/include/clock.h"
-#include "system_wrappers/include/event_wrapper.h"
 #include "system_wrappers/include/sleep.h"
 #include "test/gtest.h"
 #include "test/mock_audio_decoder.h"
@@ -408,12 +408,12 @@
               acm_->RegisterReceiveCodec(
                   rtp_payload_type, SdpAudioFormat("cn", kSampleRateHz, 1)));
     acm_->ModifyEncoder([&](std::unique_ptr<AudioEncoder>* enc) {
-      AudioEncoderCng::Config config;
+      AudioEncoderCngConfig config;
       config.speech_encoder = std::move(*enc);
       config.num_channels = 1;
       config.payload_type = rtp_payload_type;
       config.vad_mode = Vad::kVadNormal;
-      *enc = absl::make_unique<AudioEncoderCng>(std::move(config));
+      *enc = CreateComfortNoiseEncoder(std::move(config));
     });
   }
 
@@ -481,7 +481,6 @@
         send_thread_(CbSendThread, this, "send"),
         insert_packet_thread_(CbInsertPacketThread, this, "insert_packet"),
         pull_audio_thread_(CbPullAudioThread, this, "pull_audio"),
-        test_complete_(EventWrapper::Create()),
         send_count_(0),
         insert_packet_count_(0),
         pull_audio_count_(0),
@@ -512,8 +511,8 @@
     insert_packet_thread_.Stop();
   }
 
-  EventTypeWrapper RunTest() {
-    return test_complete_->Wait(10 * 60 * 1000);  // 10 minutes' timeout.
+  bool RunTest() {
+    return test_complete_.Wait(10 * 60 * 1000);  // 10 minutes' timeout.
   }
 
   virtual bool TestDone() {
@@ -538,12 +537,12 @@
     SleepMs(1);
     if (HasFatalFailure()) {
       // End the test early if a fatal failure (ASSERT_*) has occurred.
-      test_complete_->Set();
+      test_complete_.Set();
     }
     ++send_count_;
     InsertAudioAndVerifyEncoding();
     if (TestDone()) {
-      test_complete_->Set();
+      test_complete_.Set();
     }
     return true;
   }
@@ -592,7 +591,7 @@
   rtc::PlatformThread send_thread_;
   rtc::PlatformThread insert_packet_thread_;
   rtc::PlatformThread pull_audio_thread_;
-  const std::unique_ptr<EventWrapper> test_complete_;
+  rtc::Event test_complete_;
   int send_count_;
   int insert_packet_count_;
   int pull_audio_count_ RTC_GUARDED_BY(crit_sect_);
@@ -607,7 +606,7 @@
 #define MAYBE_DoTest DoTest
 #endif
 TEST_F(AudioCodingModuleMtTestOldApi, MAYBE_DoTest) {
-  EXPECT_EQ(kEventSignaled, RunTest());
+  EXPECT_TRUE(RunTest());
 }
 
 // This is a multi-threaded ACM test using iSAC. The test encodes audio
@@ -717,7 +716,7 @@
 #endif
 #if defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX)
 TEST_F(AcmIsacMtTestOldApi, MAYBE_DoTest) {
-  EXPECT_EQ(kEventSignaled, RunTest());
+  EXPECT_TRUE(RunTest());
 }
 #endif
 
@@ -734,7 +733,6 @@
         codec_registration_thread_(CbCodecRegistrationThread,
                                    this,
                                    "codec_registration"),
-        test_complete_(EventWrapper::Create()),
         codec_registered_(false),
         receive_packet_count_(0),
         next_insert_packet_time_ms_(0),
@@ -781,8 +779,8 @@
     codec_registration_thread_.Stop();
   }
 
-  EventTypeWrapper RunTest() {
-    return test_complete_->Wait(10 * 60 * 1000);  // 10 minutes' timeout.
+  bool RunTest() {
+    return test_complete_.Wait(10 * 60 * 1000);  // 10 minutes' timeout.
   }
 
   static bool CbReceiveThread(void* context) {
@@ -845,7 +843,7 @@
     SleepMs(1);
     if (HasFatalFailure()) {
       // End the test early if a fatal failure (ASSERT_*) has occurred.
-      test_complete_->Set();
+      test_complete_.Set();
     }
     rtc::CritScope lock(&crit_sect_);
     if (!codec_registered_ &&
@@ -856,14 +854,14 @@
       codec_registered_ = true;
     }
     if (codec_registered_ && receive_packet_count_ > kNumPackets) {
-      test_complete_->Set();
+      test_complete_.Set();
     }
     return true;
   }
 
   rtc::PlatformThread receive_thread_;
   rtc::PlatformThread codec_registration_thread_;
-  const std::unique_ptr<EventWrapper> test_complete_;
+  rtc::Event test_complete_;
   rtc::CriticalSection crit_sect_;
   bool codec_registered_ RTC_GUARDED_BY(crit_sect_);
   int receive_packet_count_ RTC_GUARDED_BY(crit_sect_);
@@ -880,7 +878,7 @@
 #endif
 #if defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX)
 TEST_F(AcmReRegisterIsacMtTestOldApi, MAYBE_DoTest) {
-  EXPECT_EQ(kEventSignaled, RunTest());
+  EXPECT_TRUE(RunTest());
 }
 #endif
 
diff --git a/modules/audio_coding/acm2/codec_manager.cc b/modules/audio_coding/acm2/codec_manager.cc
index f29e0f1..eda6555 100644
--- a/modules/audio_coding/acm2/codec_manager.cc
+++ b/modules/audio_coding/acm2/codec_manager.cc
@@ -10,9 +10,16 @@
 
 #include "modules/audio_coding/acm2/codec_manager.h"
 
-#include "rtc_base/checks.h"
-//#include "rtc_base/format_macros.h"
+#include <string.h>
+#include <map>
+#include <memory>
+#include <utility>
+
+#include "absl/strings/match.h"
+#include "api/array_view.h"
+#include "api/audio_codecs/audio_encoder.h"
 #include "modules/audio_coding/acm2/rent_a_codec.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 
 namespace webrtc {
@@ -35,7 +42,7 @@
   }
 
   // Telephone-event cannot be a send codec.
-  if (!STR_CASE_CMP(send_codec.plname, "telephone-event")) {
+  if (absl::EqualsIgnoreCase(send_codec.plname, "telephone-event")) {
     RTC_LOG(LS_ERROR) << "telephone-event cannot be a send codec";
     return -1;
   }
@@ -53,7 +60,7 @@
 bool IsOpus(const CodecInst& codec) {
   return
 #ifdef WEBRTC_CODEC_OPUS
-      !STR_CASE_CMP(codec.plname, "opus") ||
+      absl::EqualsIgnoreCase(codec.plname, "opus") ||
 #endif
       false;
 }
diff --git a/modules/audio_coding/acm2/codec_manager.h b/modules/audio_coding/acm2/codec_manager.h
index ffbad96..22dbf4e 100644
--- a/modules/audio_coding/acm2/codec_manager.h
+++ b/modules/audio_coding/acm2/codec_manager.h
@@ -11,8 +11,6 @@
 #ifndef MODULES_AUDIO_CODING_ACM2_CODEC_MANAGER_H_
 #define MODULES_AUDIO_CODING_ACM2_CODEC_MANAGER_H_
 
-#include <map>
-
 #include "absl/types/optional.h"
 #include "common_types.h"  // NOLINT(build/include)
 #include "modules/audio_coding/acm2/rent_a_codec.h"
@@ -23,7 +21,6 @@
 
 namespace webrtc {
 
-class AudioDecoder;
 class AudioEncoder;
 
 namespace acm2 {
diff --git a/modules/audio_coding/acm2/rent_a_codec.cc b/modules/audio_coding/acm2/rent_a_codec.cc
index 0a9ce11..7601519 100644
--- a/modules/audio_coding/acm2/rent_a_codec.cc
+++ b/modules/audio_coding/acm2/rent_a_codec.cc
@@ -13,10 +13,11 @@
 #include <memory>
 #include <utility>
 
+#include "absl/strings/match.h"
 #include "modules/audio_coding/codecs/cng/audio_encoder_cng.h"
 #include "modules/audio_coding/codecs/g711/audio_encoder_pcm.h"
-#include "rtc_base/logging.h"
 #include "modules/audio_coding/codecs/g722/audio_encoder_g722.h"
+#include "rtc_base/logging.h"
 #ifdef WEBRTC_CODEC_ILBC
 #include "modules/audio_coding/codecs/ilbc/audio_encoder_ilbc.h"  // nogncheck
 #endif
@@ -109,7 +110,7 @@
 RentACodec::RegistrationResult RentACodec::RegisterCngPayloadType(
     std::map<int, int>* pt_map,
     const CodecInst& codec_inst) {
-  if (STR_CASE_CMP(codec_inst.plname, "CN") != 0)
+  if (!absl::EqualsIgnoreCase(codec_inst.plname, "CN"))
     return RegistrationResult::kSkip;
   switch (codec_inst.plfreq) {
     case 8000:
@@ -126,7 +127,7 @@
 RentACodec::RegistrationResult RentACodec::RegisterRedPayloadType(
     std::map<int, int>* pt_map,
     const CodecInst& codec_inst) {
-  if (STR_CASE_CMP(codec_inst.plname, "RED") != 0)
+  if (!absl::EqualsIgnoreCase(codec_inst.plname, "RED"))
     return RegistrationResult::kSkip;
   switch (codec_inst.plfreq) {
     case 8000:
@@ -145,30 +146,30 @@
     const CodecInst& speech_inst,
     const rtc::scoped_refptr<LockedIsacBandwidthInfo>& bwinfo) {
 #if defined(WEBRTC_CODEC_ISACFX)
-  if (STR_CASE_CMP(speech_inst.plname, "isac") == 0)
+  if (absl::EqualsIgnoreCase(speech_inst.plname, "isac"))
     return std::unique_ptr<AudioEncoder>(
         new AudioEncoderIsacFixImpl(speech_inst, bwinfo));
 #endif
 #if defined(WEBRTC_CODEC_ISAC)
-  if (STR_CASE_CMP(speech_inst.plname, "isac") == 0)
+  if (absl::EqualsIgnoreCase(speech_inst.plname, "isac"))
     return std::unique_ptr<AudioEncoder>(
         new AudioEncoderIsacFloatImpl(speech_inst, bwinfo));
 #endif
 #ifdef WEBRTC_CODEC_OPUS
-  if (STR_CASE_CMP(speech_inst.plname, "opus") == 0)
+  if (absl::EqualsIgnoreCase(speech_inst.plname, "opus"))
     return std::unique_ptr<AudioEncoder>(new AudioEncoderOpusImpl(speech_inst));
 #endif
-  if (STR_CASE_CMP(speech_inst.plname, "pcmu") == 0)
+  if (absl::EqualsIgnoreCase(speech_inst.plname, "pcmu"))
     return std::unique_ptr<AudioEncoder>(new AudioEncoderPcmU(speech_inst));
-  if (STR_CASE_CMP(speech_inst.plname, "pcma") == 0)
+  if (absl::EqualsIgnoreCase(speech_inst.plname, "pcma"))
     return std::unique_ptr<AudioEncoder>(new AudioEncoderPcmA(speech_inst));
-  if (STR_CASE_CMP(speech_inst.plname, "l16") == 0)
+  if (absl::EqualsIgnoreCase(speech_inst.plname, "l16"))
     return std::unique_ptr<AudioEncoder>(new AudioEncoderPcm16B(speech_inst));
 #ifdef WEBRTC_CODEC_ILBC
-  if (STR_CASE_CMP(speech_inst.plname, "ilbc") == 0)
+  if (absl::EqualsIgnoreCase(speech_inst.plname, "ilbc"))
     return std::unique_ptr<AudioEncoder>(new AudioEncoderIlbcImpl(speech_inst));
 #endif
-  if (STR_CASE_CMP(speech_inst.plname, "g722") == 0)
+  if (absl::EqualsIgnoreCase(speech_inst.plname, "g722"))
     return std::unique_ptr<AudioEncoder>(new AudioEncoderG722Impl(speech_inst));
   RTC_LOG_F(LS_ERROR) << "Could not create encoder of type "
                       << speech_inst.plname;
@@ -193,7 +194,7 @@
     std::unique_ptr<AudioEncoder> encoder,
     int payload_type,
     ACMVADMode vad_mode) {
-  AudioEncoderCng::Config config;
+  AudioEncoderCngConfig config;
   config.num_channels = encoder->NumChannels();
   config.payload_type = payload_type;
   config.speech_encoder = std::move(encoder);
@@ -213,7 +214,7 @@
     default:
       FATAL();
   }
-  return std::unique_ptr<AudioEncoder>(new AudioEncoderCng(std::move(config)));
+  return CreateComfortNoiseEncoder(std::move(config));
 }
 
 std::unique_ptr<AudioDecoder> CreateIsacDecoder(
diff --git a/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.cc b/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.cc
index c4832a3..85084c8 100644
--- a/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.cc
+++ b/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.cc
@@ -10,9 +10,14 @@
 
 #include "modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.h"
 
+#include <stdint.h>
 #include <utility>
+#include <vector>
 
-#include "rtc_base/logging.h"
+#include "modules/audio_coding/audio_network_adaptor/controller_manager.h"
+#include "modules/audio_coding/audio_network_adaptor/debug_dump_writer.h"
+#include "modules/audio_coding/audio_network_adaptor/event_log_writer.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/timeutils.h"
 #include "system_wrappers/include/field_trial.h"
 
diff --git a/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.h b/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.h
index e208ed2..d3ecce0 100644
--- a/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.h
+++ b/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.h
@@ -11,17 +11,21 @@
 #ifndef MODULES_AUDIO_CODING_AUDIO_NETWORK_ADAPTOR_AUDIO_NETWORK_ADAPTOR_IMPL_H_
 #define MODULES_AUDIO_CODING_AUDIO_NETWORK_ADAPTOR_AUDIO_NETWORK_ADAPTOR_IMPL_H_
 
+#include <stdio.h>
 #include <memory>
 
+#include "absl/types/optional.h"
+#include "api/audio_codecs/audio_encoder.h"
 #include "modules/audio_coding/audio_network_adaptor/controller.h"
-#include "modules/audio_coding/audio_network_adaptor/controller_manager.h"
 #include "modules/audio_coding/audio_network_adaptor/debug_dump_writer.h"
-#include "modules/audio_coding/audio_network_adaptor/event_log_writer.h"
 #include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
+#include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
 
+class ControllerManager;
+class EventLogWriter;
 class RtcEventLog;
 
 class AudioNetworkAdaptorImpl final : public AudioNetworkAdaptor {
diff --git a/modules/audio_coding/audio_network_adaptor/bitrate_controller.h b/modules/audio_coding/audio_network_adaptor/bitrate_controller.h
index 282f599..6b6330b 100644
--- a/modules/audio_coding/audio_network_adaptor/bitrate_controller.h
+++ b/modules/audio_coding/audio_network_adaptor/bitrate_controller.h
@@ -11,7 +11,11 @@
 #ifndef MODULES_AUDIO_CODING_AUDIO_NETWORK_ADAPTOR_BITRATE_CONTROLLER_H_
 #define MODULES_AUDIO_CODING_AUDIO_NETWORK_ADAPTOR_BITRATE_CONTROLLER_H_
 
+#include <stddef.h>
+
+#include "absl/types/optional.h"
 #include "modules/audio_coding/audio_network_adaptor/controller.h"
+#include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
diff --git a/modules/audio_coding/audio_network_adaptor/channel_controller.h b/modules/audio_coding/audio_network_adaptor/channel_controller.h
index 23cbef6..0d775b1 100644
--- a/modules/audio_coding/audio_network_adaptor/channel_controller.h
+++ b/modules/audio_coding/audio_network_adaptor/channel_controller.h
@@ -11,7 +11,11 @@
 #ifndef MODULES_AUDIO_CODING_AUDIO_NETWORK_ADAPTOR_CHANNEL_CONTROLLER_H_
 #define MODULES_AUDIO_CODING_AUDIO_NETWORK_ADAPTOR_CHANNEL_CONTROLLER_H_
 
+#include <stddef.h>
+
+#include "absl/types/optional.h"
 #include "modules/audio_coding/audio_network_adaptor/controller.h"
+#include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
diff --git a/modules/audio_coding/audio_network_adaptor/debug_dump_writer.cc b/modules/audio_coding/audio_network_adaptor/debug_dump_writer.cc
index 818362e..8e04e8e 100644
--- a/modules/audio_coding/audio_network_adaptor/debug_dump_writer.cc
+++ b/modules/audio_coding/audio_network_adaptor/debug_dump_writer.cc
@@ -10,10 +10,12 @@
 
 #include "modules/audio_coding/audio_network_adaptor/debug_dump_writer.h"
 
+#include "absl/types/optional.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/ignore_wundef.h"
 #include "rtc_base/numerics/safe_conversions.h"
 #include "rtc_base/protobuf_utils.h"
+#include "rtc_base/system/file_wrapper.h"
 
 #if WEBRTC_ENABLE_PROTOBUF
 RTC_PUSH_IGNORING_WUNDEF()
diff --git a/modules/audio_coding/audio_network_adaptor/dtx_controller.h b/modules/audio_coding/audio_network_adaptor/dtx_controller.h
index fb40db2..d3334ec 100644
--- a/modules/audio_coding/audio_network_adaptor/dtx_controller.h
+++ b/modules/audio_coding/audio_network_adaptor/dtx_controller.h
@@ -11,7 +11,9 @@
 #ifndef MODULES_AUDIO_CODING_AUDIO_NETWORK_ADAPTOR_DTX_CONTROLLER_H_
 #define MODULES_AUDIO_CODING_AUDIO_NETWORK_ADAPTOR_DTX_CONTROLLER_H_
 
+#include "absl/types/optional.h"
 #include "modules/audio_coding/audio_network_adaptor/controller.h"
+#include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
diff --git a/modules/audio_coding/audio_network_adaptor/event_log_writer.cc b/modules/audio_coding/audio_network_adaptor/event_log_writer.cc
index 4a92343..7925b89 100644
--- a/modules/audio_coding/audio_network_adaptor/event_log_writer.cc
+++ b/modules/audio_coding/audio_network_adaptor/event_log_writer.cc
@@ -9,13 +9,17 @@
  */
 
 #include <math.h>
-
 #include <algorithm>
+#include <cstdlib>
+#include <utility>
 
 #include "absl/memory/memory.h"
+#include "absl/types/optional.h"
+#include "logging/rtc_event_log/events/rtc_event.h"
 #include "logging/rtc_event_log/events/rtc_event_audio_network_adaptation.h"
 #include "logging/rtc_event_log/rtc_event_log.h"
 #include "modules/audio_coding/audio_network_adaptor/event_log_writer.h"
+#include "rtc_base/checks.h"
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/audio_network_adaptor/event_log_writer.h b/modules/audio_coding/audio_network_adaptor/event_log_writer.h
index fca8e53..72b5245 100644
--- a/modules/audio_coding/audio_network_adaptor/event_log_writer.h
+++ b/modules/audio_coding/audio_network_adaptor/event_log_writer.h
@@ -11,7 +11,7 @@
 #ifndef MODULES_AUDIO_CODING_AUDIO_NETWORK_ADAPTOR_EVENT_LOG_WRITER_H_
 #define MODULES_AUDIO_CODING_AUDIO_NETWORK_ADAPTOR_EVENT_LOG_WRITER_H_
 
-#include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
+#include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
diff --git a/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.cc b/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.cc
index 7ab72c9..936e224 100644
--- a/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.cc
+++ b/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.cc
@@ -10,7 +10,7 @@
 
 #include "modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.h"
 
-#include <limits>
+#include <string>
 #include <utility>
 
 #include "rtc_base/checks.h"
diff --git a/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.h b/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.h
index b66883e..b7d3d56 100644
--- a/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.h
+++ b/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.h
@@ -13,8 +13,10 @@
 
 #include <memory>
 
+#include "absl/types/optional.h"
 #include "common_audio/smoothing_filter.h"
 #include "modules/audio_coding/audio_network_adaptor/controller.h"
+#include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h"
 #include "modules/audio_coding/audio_network_adaptor/util/threshold_curve.h"
 #include "rtc_base/constructormagic.h"
 
diff --git a/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based.cc b/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based.cc
index c8cfd31..6c30b8f 100644
--- a/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based.cc
+++ b/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based.cc
@@ -10,9 +10,6 @@
 
 #include "modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based.h"
 
-#include <limits>
-#include <utility>
-
 #include "rtc_base/checks.h"
 
 namespace webrtc {
diff --git a/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based.h b/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based.h
index 9a3c37c..421cb70 100644
--- a/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based.h
+++ b/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based.h
@@ -11,9 +11,9 @@
 #ifndef MODULES_AUDIO_CODING_AUDIO_NETWORK_ADAPTOR_FEC_CONTROLLER_RPLR_BASED_H_
 #define MODULES_AUDIO_CODING_AUDIO_NETWORK_ADAPTOR_FEC_CONTROLLER_RPLR_BASED_H_
 
-#include <memory>
-
+#include "absl/types/optional.h"
 #include "modules/audio_coding/audio_network_adaptor/controller.h"
+#include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h"
 #include "modules/audio_coding/audio_network_adaptor/util/threshold_curve.h"
 #include "rtc_base/constructormagic.h"
 
diff --git a/modules/audio_coding/audio_network_adaptor/frame_length_controller.cc b/modules/audio_coding/audio_network_adaptor/frame_length_controller.cc
index 40e97cb..b123c7c 100644
--- a/modules/audio_coding/audio_network_adaptor/frame_length_controller.cc
+++ b/modules/audio_coding/audio_network_adaptor/frame_length_controller.cc
@@ -11,10 +11,10 @@
 #include "modules/audio_coding/audio_network_adaptor/frame_length_controller.h"
 
 #include <algorithm>
+#include <iterator>
 #include <utility>
 
 #include "rtc_base/checks.h"
-#include "rtc_base/logging.h"
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/audio_network_adaptor/frame_length_controller.h b/modules/audio_coding/audio_network_adaptor/frame_length_controller.h
index f084fd0..f0a5aab 100644
--- a/modules/audio_coding/audio_network_adaptor/frame_length_controller.h
+++ b/modules/audio_coding/audio_network_adaptor/frame_length_controller.h
@@ -11,10 +11,13 @@
 #ifndef MODULES_AUDIO_CODING_AUDIO_NETWORK_ADAPTOR_FRAME_LENGTH_CONTROLLER_H_
 #define MODULES_AUDIO_CODING_AUDIO_NETWORK_ADAPTOR_FRAME_LENGTH_CONTROLLER_H_
 
+#include <stddef.h>
 #include <map>
 #include <vector>
 
+#include "absl/types/optional.h"
 #include "modules/audio_coding/audio_network_adaptor/controller.h"
+#include "modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
diff --git a/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h b/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h
index 257a79a..94e8ed9 100644
--- a/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h
+++ b/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor_config.h
@@ -11,6 +11,8 @@
 #ifndef MODULES_AUDIO_CODING_AUDIO_NETWORK_ADAPTOR_INCLUDE_AUDIO_NETWORK_ADAPTOR_CONFIG_H_
 #define MODULES_AUDIO_CODING_AUDIO_NETWORK_ADAPTOR_INCLUDE_AUDIO_NETWORK_ADAPTOR_CONFIG_H_
 
+#include <stddef.h>
+
 #include "absl/types/optional.h"
 
 namespace webrtc {
diff --git a/modules/audio_coding/codecs/audio_format_conversion.cc b/modules/audio_coding/codecs/audio_format_conversion.cc
index e38aa33..f068301 100644
--- a/modules/audio_coding/codecs/audio_format_conversion.cc
+++ b/modules/audio_coding/codecs/audio_format_conversion.cc
@@ -11,11 +11,12 @@
 #include "modules/audio_coding/codecs/audio_format_conversion.h"
 
 #include <string.h>
+#include <string>
+#include <utility>
 
-#include "absl/types/optional.h"
+#include "absl/strings/match.h"
 #include "api/array_view.h"
 #include "rtc_base/checks.h"
-#include "rtc_base/numerics/safe_conversions.h"
 #include "rtc_base/sanitizer.h"
 
 namespace webrtc {
@@ -41,11 +42,11 @@
 }  // namespace
 
 SdpAudioFormat CodecInstToSdp(const CodecInst& ci) {
-  if (STR_CASE_CMP(ci.plname, "g722") == 0) {
+  if (absl::EqualsIgnoreCase(ci.plname, "g722")) {
     RTC_CHECK_EQ(16000, ci.plfreq);
     RTC_CHECK(ci.channels == 1 || ci.channels == 2);
     return {"g722", 8000, ci.channels};
-  } else if (STR_CASE_CMP(ci.plname, "opus") == 0) {
+  } else if (absl::EqualsIgnoreCase(ci.plname, "opus")) {
     RTC_CHECK_EQ(48000, ci.plfreq);
     RTC_CHECK(ci.channels == 1 || ci.channels == 2);
     return ci.channels == 1
@@ -57,12 +58,12 @@
 }
 
 CodecInst SdpToCodecInst(int payload_type, const SdpAudioFormat& audio_format) {
-  if (STR_CASE_CMP(audio_format.name.c_str(), "g722") == 0) {
+  if (absl::EqualsIgnoreCase(audio_format.name, "g722")) {
     RTC_CHECK_EQ(8000, audio_format.clockrate_hz);
     RTC_CHECK(audio_format.num_channels == 1 || audio_format.num_channels == 2);
     return MakeCodecInst(payload_type, "g722", 16000,
                          audio_format.num_channels);
-  } else if (STR_CASE_CMP(audio_format.name.c_str(), "opus") == 0) {
+  } else if (absl::EqualsIgnoreCase(audio_format.name, "opus")) {
     RTC_CHECK_EQ(48000, audio_format.clockrate_hz);
     RTC_CHECK_EQ(2, audio_format.num_channels);
     const int num_channels = [&] {
diff --git a/modules/audio_coding/codecs/cng/audio_encoder_cng.cc b/modules/audio_coding/codecs/cng/audio_encoder_cng.cc
index 4cda340..9a29261 100644
--- a/modules/audio_coding/codecs/cng/audio_encoder_cng.cc
+++ b/modules/audio_coding/codecs/cng/audio_encoder_cng.cc
@@ -10,40 +10,72 @@
 
 #include "modules/audio_coding/codecs/cng/audio_encoder_cng.h"
 
-#include <algorithm>
-#include <limits>
+#include <cstdint>
 #include <memory>
 #include <utility>
 
+#include "absl/memory/memory.h"
+#include "modules/audio_coding/codecs/cng/webrtc_cng.h"
+#include "rtc_base/checks.h"
+
 namespace webrtc {
 
 namespace {
 
 const int kMaxFrameSizeMs = 60;
 
-}  // namespace
+class AudioEncoderCng final : public AudioEncoder {
+ public:
+  explicit AudioEncoderCng(AudioEncoderCngConfig&& config);
+  ~AudioEncoderCng() override;
 
-AudioEncoderCng::Config::Config() = default;
-AudioEncoderCng::Config::Config(Config&&) = default;
-AudioEncoderCng::Config::~Config() = default;
+  // Not copyable or moveable.
+  AudioEncoderCng(const AudioEncoderCng&) = delete;
+  AudioEncoderCng(AudioEncoderCng&&) = delete;
+  AudioEncoderCng& operator=(const AudioEncoderCng&) = delete;
+  AudioEncoderCng& operator=(AudioEncoderCng&&) = delete;
 
-bool AudioEncoderCng::Config::IsOk() const {
-  if (num_channels != 1)
-    return false;
-  if (!speech_encoder)
-    return false;
-  if (num_channels != speech_encoder->NumChannels())
-    return false;
-  if (sid_frame_interval_ms <
-      static_cast<int>(speech_encoder->Max10MsFramesInAPacket() * 10))
-    return false;
-  if (num_cng_coefficients > WEBRTC_CNG_MAX_LPC_ORDER ||
-      num_cng_coefficients <= 0)
-    return false;
-  return true;
-}
+  int SampleRateHz() const override;
+  size_t NumChannels() const override;
+  int RtpTimestampRateHz() const override;
+  size_t Num10MsFramesInNextPacket() const override;
+  size_t Max10MsFramesInAPacket() const override;
+  int GetTargetBitrate() const override;
+  EncodedInfo EncodeImpl(uint32_t rtp_timestamp,
+                         rtc::ArrayView<const int16_t> audio,
+                         rtc::Buffer* encoded) override;
+  void Reset() override;
+  bool SetFec(bool enable) override;
+  bool SetDtx(bool enable) override;
+  bool SetApplication(Application application) override;
+  void SetMaxPlaybackRate(int frequency_hz) override;
+  rtc::ArrayView<std::unique_ptr<AudioEncoder>> ReclaimContainedEncoders()
+      override;
+  void OnReceivedUplinkPacketLossFraction(
+      float uplink_packet_loss_fraction) override;
+  void OnReceivedUplinkRecoverablePacketLossFraction(
+      float uplink_recoverable_packet_loss_fraction) override;
+  void OnReceivedUplinkBandwidth(
+      int target_audio_bitrate_bps,
+      absl::optional<int64_t> bwe_period_ms) override;
 
-AudioEncoderCng::AudioEncoderCng(Config&& config)
+ private:
+  EncodedInfo EncodePassive(size_t frames_to_encode, rtc::Buffer* encoded);
+  EncodedInfo EncodeActive(size_t frames_to_encode, rtc::Buffer* encoded);
+  size_t SamplesPer10msFrame() const;
+
+  std::unique_ptr<AudioEncoder> speech_encoder_;
+  const int cng_payload_type_;
+  const int num_cng_coefficients_;
+  const int sid_frame_interval_ms_;
+  std::vector<int16_t> speech_buffer_;
+  std::vector<uint32_t> rtp_timestamps_;
+  bool last_frame_active_;
+  std::unique_ptr<Vad> vad_;
+  std::unique_ptr<ComfortNoiseEncoder> cng_encoder_;
+};
+
+AudioEncoderCng::AudioEncoderCng(AudioEncoderCngConfig&& config)
     : speech_encoder_((static_cast<void>([&] {
                          RTC_CHECK(config.IsOk()) << "Invalid configuration.";
                        }()),
@@ -261,4 +293,31 @@
   return rtc::CheckedDivExact(10 * SampleRateHz(), 1000);
 }
 
+}  // namespace
+
+AudioEncoderCngConfig::AudioEncoderCngConfig() = default;
+AudioEncoderCngConfig::AudioEncoderCngConfig(AudioEncoderCngConfig&&) = default;
+AudioEncoderCngConfig::~AudioEncoderCngConfig() = default;
+
+bool AudioEncoderCngConfig::IsOk() const {
+  if (num_channels != 1)
+    return false;
+  if (!speech_encoder)
+    return false;
+  if (num_channels != speech_encoder->NumChannels())
+    return false;
+  if (sid_frame_interval_ms <
+      static_cast<int>(speech_encoder->Max10MsFramesInAPacket() * 10))
+    return false;
+  if (num_cng_coefficients > WEBRTC_CNG_MAX_LPC_ORDER ||
+      num_cng_coefficients <= 0)
+    return false;
+  return true;
+}
+
+std::unique_ptr<AudioEncoder> CreateComfortNoiseEncoder(
+    AudioEncoderCngConfig&& config) {
+  return absl::make_unique<AudioEncoderCng>(std::move(config));
+}
+
 }  // namespace webrtc
diff --git a/modules/audio_coding/codecs/cng/audio_encoder_cng.h b/modules/audio_coding/codecs/cng/audio_encoder_cng.h
index e4c6507..2ef3236 100644
--- a/modules/audio_coding/codecs/cng/audio_encoder_cng.h
+++ b/modules/audio_coding/codecs/cng/audio_encoder_cng.h
@@ -11,86 +11,38 @@
 #ifndef MODULES_AUDIO_CODING_CODECS_CNG_AUDIO_ENCODER_CNG_H_
 #define MODULES_AUDIO_CODING_CODECS_CNG_AUDIO_ENCODER_CNG_H_
 
+#include <stddef.h>
 #include <memory>
-#include <vector>
 
 #include "api/audio_codecs/audio_encoder.h"
 #include "common_audio/vad/include/vad.h"
-#include "modules/audio_coding/codecs/cng/webrtc_cng.h"
-#include "rtc_base/constructormagic.h"
 
 namespace webrtc {
 
-class Vad;
+struct AudioEncoderCngConfig {
+  // Moveable, not copyable.
+  AudioEncoderCngConfig();
+  AudioEncoderCngConfig(AudioEncoderCngConfig&&);
+  ~AudioEncoderCngConfig();
 
-class AudioEncoderCng final : public AudioEncoder {
- public:
-  struct Config {
-    Config();
-    Config(Config&&);
-    ~Config();
-    bool IsOk() const;
+  bool IsOk() const;
 
-    size_t num_channels = 1;
-    int payload_type = 13;
-    std::unique_ptr<AudioEncoder> speech_encoder;
-    Vad::Aggressiveness vad_mode = Vad::kVadNormal;
-    int sid_frame_interval_ms = 100;
-    int num_cng_coefficients = 8;
-    // The Vad pointer is mainly for testing. If a NULL pointer is passed, the
-    // AudioEncoderCng creates (and destroys) a Vad object internally. If an
-    // object is passed, the AudioEncoderCng assumes ownership of the Vad
-    // object.
-    Vad* vad = nullptr;
-  };
-
-  explicit AudioEncoderCng(Config&& config);
-  ~AudioEncoderCng() override;
-
-  int SampleRateHz() const override;
-  size_t NumChannels() const override;
-  int RtpTimestampRateHz() const override;
-  size_t Num10MsFramesInNextPacket() const override;
-  size_t Max10MsFramesInAPacket() const override;
-  int GetTargetBitrate() const override;
-  EncodedInfo EncodeImpl(uint32_t rtp_timestamp,
-                         rtc::ArrayView<const int16_t> audio,
-                         rtc::Buffer* encoded) override;
-  void Reset() override;
-  bool SetFec(bool enable) override;
-  bool SetDtx(bool enable) override;
-  bool SetApplication(Application application) override;
-  void SetMaxPlaybackRate(int frequency_hz) override;
-  rtc::ArrayView<std::unique_ptr<AudioEncoder>> ReclaimContainedEncoders()
-      override;
-  void OnReceivedUplinkPacketLossFraction(
-      float uplink_packet_loss_fraction) override;
-  void OnReceivedUplinkRecoverablePacketLossFraction(
-      float uplink_recoverable_packet_loss_fraction) override;
-  void OnReceivedUplinkBandwidth(
-      int target_audio_bitrate_bps,
-      absl::optional<int64_t> bwe_period_ms) override;
-
- private:
-  EncodedInfo EncodePassive(size_t frames_to_encode,
-                            rtc::Buffer* encoded);
-  EncodedInfo EncodeActive(size_t frames_to_encode,
-                           rtc::Buffer* encoded);
-  size_t SamplesPer10msFrame() const;
-
-  std::unique_ptr<AudioEncoder> speech_encoder_;
-  const int cng_payload_type_;
-  const int num_cng_coefficients_;
-  const int sid_frame_interval_ms_;
-  std::vector<int16_t> speech_buffer_;
-  std::vector<uint32_t> rtp_timestamps_;
-  bool last_frame_active_;
-  std::unique_ptr<Vad> vad_;
-  std::unique_ptr<ComfortNoiseEncoder> cng_encoder_;
-
-  RTC_DISALLOW_COPY_AND_ASSIGN(AudioEncoderCng);
+  size_t num_channels = 1;
+  int payload_type = 13;
+  std::unique_ptr<AudioEncoder> speech_encoder;
+  Vad::Aggressiveness vad_mode = Vad::kVadNormal;
+  int sid_frame_interval_ms = 100;
+  int num_cng_coefficients = 8;
+  // The Vad pointer is mainly for testing. If a NULL pointer is passed, the
+  // AudioEncoderCng creates (and destroys) a Vad object internally. If an
+  // object is passed, the AudioEncoderCng assumes ownership of the Vad
+  // object.
+  Vad* vad = nullptr;
 };
 
+std::unique_ptr<AudioEncoder> CreateComfortNoiseEncoder(
+    AudioEncoderCngConfig&& config);
+
 }  // namespace webrtc
 
 #endif  // MODULES_AUDIO_CODING_CODECS_CNG_AUDIO_ENCODER_CNG_H_
diff --git a/modules/audio_coding/codecs/cng/audio_encoder_cng_unittest.cc b/modules/audio_coding/codecs/cng/audio_encoder_cng_unittest.cc
index a76dcbd..e3655b4 100644
--- a/modules/audio_coding/codecs/cng/audio_encoder_cng_unittest.cc
+++ b/modules/audio_coding/codecs/cng/audio_encoder_cng_unittest.cc
@@ -50,8 +50,8 @@
     cng_.reset();
   }
 
-  AudioEncoderCng::Config MakeCngConfig() {
-    AudioEncoderCng::Config config;
+  AudioEncoderCngConfig MakeCngConfig() {
+    AudioEncoderCngConfig config;
     config.speech_encoder = std::move(mock_encoder_owner_);
     EXPECT_TRUE(config.speech_encoder);
 
@@ -63,7 +63,7 @@
     return config;
   }
 
-  void CreateCng(AudioEncoderCng::Config&& config) {
+  void CreateCng(AudioEncoderCngConfig&& config) {
     num_audio_samples_10ms_ = static_cast<size_t>(10 * sample_rate_hz_ / 1000);
     ASSERT_LE(num_audio_samples_10ms_, kMaxNumSamples);
     if (config.speech_encoder) {
@@ -75,7 +75,7 @@
       EXPECT_CALL(*mock_encoder_, Max10MsFramesInAPacket())
           .WillOnce(Return(1u));
     }
-    cng_.reset(new AudioEncoderCng(std::move(config)));
+    cng_ = CreateComfortNoiseEncoder(std::move(config));
   }
 
   void Encode() {
@@ -193,7 +193,7 @@
     return encoded_info_.payload_type != kCngPayloadType;
   }
 
-  std::unique_ptr<AudioEncoderCng> cng_;
+  std::unique_ptr<AudioEncoder> cng_;
   std::unique_ptr<MockAudioEncoder> mock_encoder_owner_;
   MockAudioEncoder* mock_encoder_;
   MockVad* mock_vad_;  // Ownership is transferred to |cng_|.
@@ -432,7 +432,7 @@
   // deleted.
   void TearDown() override { cng_.reset(); }
 
-  AudioEncoderCng::Config MakeCngConfig() {
+  AudioEncoderCngConfig MakeCngConfig() {
     // Don't provide a Vad mock object, since it would leak when the test dies.
     auto config = AudioEncoderCngTest::MakeCngConfig();
     config.vad = nullptr;
diff --git a/modules/audio_coding/codecs/cng/webrtc_cng.cc b/modules/audio_coding/codecs/cng/webrtc_cng.cc
index a07b093..f18fb28 100644
--- a/modules/audio_coding/codecs/cng/webrtc_cng.cc
+++ b/modules/audio_coding/codecs/cng/webrtc_cng.cc
@@ -13,6 +13,7 @@
 #include <algorithm>
 
 #include "common_audio/signal_processing/include/signal_processing_library.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/numerics/safe_conversions.h"
 
 namespace webrtc {
diff --git a/modules/audio_coding/codecs/cng/webrtc_cng.h b/modules/audio_coding/codecs/cng/webrtc_cng.h
index 3f8fadc..6ff7529 100644
--- a/modules/audio_coding/codecs/cng/webrtc_cng.h
+++ b/modules/audio_coding/codecs/cng/webrtc_cng.h
@@ -11,6 +11,7 @@
 #ifndef MODULES_AUDIO_CODING_CODECS_CNG_WEBRTC_CNG_H_
 #define MODULES_AUDIO_CODING_CODECS_CNG_WEBRTC_CNG_H_
 
+#include <stdint.h>
 #include <cstddef>
 
 #include "api/array_view.h"
diff --git a/modules/audio_coding/codecs/g711/audio_decoder_pcm.cc b/modules/audio_coding/codecs/g711/audio_decoder_pcm.cc
index 25f495f..d580a05 100644
--- a/modules/audio_coding/codecs/g711/audio_decoder_pcm.cc
+++ b/modules/audio_coding/codecs/g711/audio_decoder_pcm.cc
@@ -10,6 +10,8 @@
 
 #include "modules/audio_coding/codecs/g711/audio_decoder_pcm.h"
 
+#include <utility>
+
 #include "modules/audio_coding/codecs/g711/g711_interface.h"
 #include "modules/audio_coding/codecs/legacy_encoded_audio_frame.h"
 
diff --git a/modules/audio_coding/codecs/g711/audio_decoder_pcm.h b/modules/audio_coding/codecs/g711/audio_decoder_pcm.h
index 29e4fa6..9a01b8a 100644
--- a/modules/audio_coding/codecs/g711/audio_decoder_pcm.h
+++ b/modules/audio_coding/codecs/g711/audio_decoder_pcm.h
@@ -11,7 +11,12 @@
 #ifndef MODULES_AUDIO_CODING_CODECS_G711_AUDIO_DECODER_PCM_H_
 #define MODULES_AUDIO_CODING_CODECS_G711_AUDIO_DECODER_PCM_H_
 
+#include <stddef.h>
+#include <stdint.h>
+#include <vector>
+
 #include "api/audio_codecs/audio_decoder.h"
+#include "rtc_base/buffer.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/constructormagic.h"
 
diff --git a/modules/audio_coding/codecs/g711/audio_encoder_pcm.cc b/modules/audio_coding/codecs/g711/audio_encoder_pcm.cc
index c14287e..dce1635 100644
--- a/modules/audio_coding/codecs/g711/audio_encoder_pcm.cc
+++ b/modules/audio_coding/codecs/g711/audio_encoder_pcm.cc
@@ -10,10 +10,9 @@
 
 #include "modules/audio_coding/codecs/g711/audio_encoder_pcm.h"
 
-#include <algorithm>
-#include <limits>
+#include <cstdint>
 
-#include "common_types.h"  // NOLINT(build/include)
+#include "common_types.h"
 #include "modules/audio_coding/codecs/g711/g711_interface.h"
 #include "rtc_base/checks.h"
 
diff --git a/modules/audio_coding/codecs/g722/audio_decoder_g722.cc b/modules/audio_coding/codecs/g722/audio_decoder_g722.cc
index ea4a721..4de55a0 100644
--- a/modules/audio_coding/codecs/g722/audio_decoder_g722.cc
+++ b/modules/audio_coding/codecs/g722/audio_decoder_g722.cc
@@ -11,6 +11,7 @@
 #include "modules/audio_coding/codecs/g722/audio_decoder_g722.h"
 
 #include <string.h>
+#include <utility>
 
 #include "modules/audio_coding/codecs/g722/g722_interface.h"
 #include "modules/audio_coding/codecs/legacy_encoded_audio_frame.h"
diff --git a/modules/audio_coding/codecs/g722/audio_encoder_g722.cc b/modules/audio_coding/codecs/g722/audio_encoder_g722.cc
index cb96c3c..e63d590 100644
--- a/modules/audio_coding/codecs/g722/audio_encoder_g722.cc
+++ b/modules/audio_coding/codecs/g722/audio_encoder_g722.cc
@@ -10,10 +10,9 @@
 
 #include "modules/audio_coding/codecs/g722/audio_encoder_g722.h"
 
-#include <algorithm>
+#include <cstdint>
 
-#include <limits>
-#include "common_types.h"  // NOLINT(build/include)
+#include "common_types.h"
 #include "modules/audio_coding/codecs/g722/g722_interface.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/numerics/safe_conversions.h"
diff --git a/modules/audio_coding/codecs/ilbc/audio_decoder_ilbc.cc b/modules/audio_coding/codecs/ilbc/audio_decoder_ilbc.cc
index 9e58ce0..57b5abb 100644
--- a/modules/audio_coding/codecs/ilbc/audio_decoder_ilbc.cc
+++ b/modules/audio_coding/codecs/ilbc/audio_decoder_ilbc.cc
@@ -10,6 +10,7 @@
 
 #include "modules/audio_coding/codecs/ilbc/audio_decoder_ilbc.h"
 
+#include <memory>
 #include <utility>
 
 #include "modules/audio_coding/codecs/ilbc/ilbc.h"
diff --git a/modules/audio_coding/codecs/ilbc/audio_decoder_ilbc.h b/modules/audio_coding/codecs/ilbc/audio_decoder_ilbc.h
index edb65d0..fcb2074 100644
--- a/modules/audio_coding/codecs/ilbc/audio_decoder_ilbc.h
+++ b/modules/audio_coding/codecs/ilbc/audio_decoder_ilbc.h
@@ -11,7 +11,12 @@
 #ifndef MODULES_AUDIO_CODING_CODECS_ILBC_AUDIO_DECODER_ILBC_H_
 #define MODULES_AUDIO_CODING_CODECS_ILBC_AUDIO_DECODER_ILBC_H_
 
+#include <stddef.h>
+#include <stdint.h>
+#include <vector>
+
 #include "api/audio_codecs/audio_decoder.h"
+#include "rtc_base/buffer.h"
 #include "rtc_base/constructormagic.h"
 
 typedef struct iLBC_decinst_t_ IlbcDecoderInstance;
diff --git a/modules/audio_coding/codecs/ilbc/audio_encoder_ilbc.cc b/modules/audio_coding/codecs/ilbc/audio_encoder_ilbc.cc
index 84695e3..8801fd5 100644
--- a/modules/audio_coding/codecs/ilbc/audio_encoder_ilbc.cc
+++ b/modules/audio_coding/codecs/ilbc/audio_encoder_ilbc.cc
@@ -11,8 +11,9 @@
 #include "modules/audio_coding/codecs/ilbc/audio_encoder_ilbc.h"
 
 #include <algorithm>
-#include <limits>
-#include "common_types.h"  // NOLINT(build/include)
+#include <cstdint>
+
+#include "common_types.h"
 #include "modules/audio_coding/codecs/ilbc/ilbc.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/numerics/safe_conversions.h"
diff --git a/modules/audio_coding/codecs/legacy_encoded_audio_frame.cc b/modules/audio_coding/codecs/legacy_encoded_audio_frame.cc
index 0bf3b19..d9efc21 100644
--- a/modules/audio_coding/codecs/legacy_encoded_audio_frame.cc
+++ b/modules/audio_coding/codecs/legacy_encoded_audio_frame.cc
@@ -14,6 +14,8 @@
 #include <memory>
 #include <utility>
 
+#include "rtc_base/checks.h"
+
 namespace webrtc {
 
 LegacyEncodedAudioFrame::LegacyEncodedAudioFrame(AudioDecoder* decoder,
diff --git a/modules/audio_coding/codecs/legacy_encoded_audio_frame.h b/modules/audio_coding/codecs/legacy_encoded_audio_frame.h
index 05d4fe4..41b08f7 100644
--- a/modules/audio_coding/codecs/legacy_encoded_audio_frame.h
+++ b/modules/audio_coding/codecs/legacy_encoded_audio_frame.h
@@ -11,10 +11,14 @@
 #ifndef MODULES_AUDIO_CODING_CODECS_LEGACY_ENCODED_AUDIO_FRAME_H_
 #define MODULES_AUDIO_CODING_CODECS_LEGACY_ENCODED_AUDIO_FRAME_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <vector>
 
+#include "absl/types/optional.h"
 #include "api/array_view.h"
 #include "api/audio_codecs/audio_decoder.h"
+#include "rtc_base/buffer.h"
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/codecs/opus/audio_decoder_opus.cc b/modules/audio_coding/codecs/opus/audio_decoder_opus.cc
index 302b714..357cb1a 100644
--- a/modules/audio_coding/codecs/opus/audio_decoder_opus.cc
+++ b/modules/audio_coding/codecs/opus/audio_decoder_opus.cc
@@ -10,8 +10,11 @@
 
 #include "modules/audio_coding/codecs/opus/audio_decoder_opus.h"
 
+#include <memory>
 #include <utility>
 
+#include "absl/types/optional.h"
+#include "api/array_view.h"
 #include "rtc_base/checks.h"
 
 namespace webrtc {
diff --git a/modules/audio_coding/codecs/opus/audio_decoder_opus.h b/modules/audio_coding/codecs/opus/audio_decoder_opus.h
index 70aa40b..8043425 100644
--- a/modules/audio_coding/codecs/opus/audio_decoder_opus.h
+++ b/modules/audio_coding/codecs/opus/audio_decoder_opus.h
@@ -11,8 +11,13 @@
 #ifndef MODULES_AUDIO_CODING_CODECS_OPUS_AUDIO_DECODER_OPUS_H_
 #define MODULES_AUDIO_CODING_CODECS_OPUS_AUDIO_DECODER_OPUS_H_
 
+#include <stddef.h>
+#include <stdint.h>
+#include <vector>
+
 #include "api/audio_codecs/audio_decoder.h"
 #include "modules/audio_coding/codecs/opus/opus_interface.h"
+#include "rtc_base/buffer.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
diff --git a/modules/audio_coding/codecs/opus/audio_encoder_opus.cc b/modules/audio_coding/codecs/opus/audio_encoder_opus.cc
index c07abbe..adc6656 100644
--- a/modules/audio_coding/codecs/opus/audio_encoder_opus.cc
+++ b/modules/audio_coding/codecs/opus/audio_encoder_opus.cc
@@ -15,7 +15,8 @@
 #include <utility>
 
 #include "absl/memory/memory.h"
-#include "common_types.h"  // NOLINT(build/include)
+#include "absl/strings/match.h"
+#include "common_types.h"
 #include "modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.h"
 #include "modules/audio_coding/audio_network_adaptor/controller_manager.h"
 #include "modules/audio_coding/codecs/opus/opus_interface.h"
@@ -316,7 +317,7 @@
 
 absl::optional<AudioCodecInfo> AudioEncoderOpusImpl::QueryAudioEncoder(
     const SdpAudioFormat& format) {
-  if (STR_CASE_CMP(format.name.c_str(), GetPayloadName()) == 0 &&
+  if (absl::EqualsIgnoreCase(format.name, GetPayloadName()) &&
       format.clockrate_hz == 48000 && format.num_channels == 2) {
     const size_t num_channels = GetChannelCount(format);
     const int bitrate =
@@ -348,7 +349,7 @@
 
 absl::optional<AudioEncoderOpusConfig> AudioEncoderOpusImpl::SdpToConfig(
     const SdpAudioFormat& format) {
-  if (STR_CASE_CMP(format.name.c_str(), "opus") != 0 ||
+  if (!absl::EqualsIgnoreCase(format.name, "opus") ||
       format.clockrate_hz != 48000 || format.num_channels != 2) {
     return absl::nullopt;
   }
diff --git a/modules/audio_coding/codecs/pcm16b/audio_decoder_pcm16b.cc b/modules/audio_coding/codecs/pcm16b/audio_decoder_pcm16b.cc
index b07624d..1dd2ff2 100644
--- a/modules/audio_coding/codecs/pcm16b/audio_decoder_pcm16b.cc
+++ b/modules/audio_coding/codecs/pcm16b/audio_decoder_pcm16b.cc
@@ -10,6 +10,8 @@
 
 #include "modules/audio_coding/codecs/pcm16b/audio_decoder_pcm16b.h"
 
+#include <utility>
+
 #include "modules/audio_coding/codecs/legacy_encoded_audio_frame.h"
 #include "modules/audio_coding/codecs/pcm16b/pcm16b.h"
 #include "rtc_base/checks.h"
diff --git a/modules/audio_coding/codecs/pcm16b/audio_decoder_pcm16b.h b/modules/audio_coding/codecs/pcm16b/audio_decoder_pcm16b.h
index 7d23422..9b478d8 100644
--- a/modules/audio_coding/codecs/pcm16b/audio_decoder_pcm16b.h
+++ b/modules/audio_coding/codecs/pcm16b/audio_decoder_pcm16b.h
@@ -11,7 +11,12 @@
 #ifndef MODULES_AUDIO_CODING_CODECS_PCM16B_AUDIO_DECODER_PCM16B_H_
 #define MODULES_AUDIO_CODING_CODECS_PCM16B_AUDIO_DECODER_PCM16B_H_
 
+#include <stddef.h>
+#include <stdint.h>
+#include <vector>
+
 #include "api/audio_codecs/audio_decoder.h"
+#include "rtc_base/buffer.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
diff --git a/modules/audio_coding/codecs/pcm16b/audio_encoder_pcm16b.cc b/modules/audio_coding/codecs/pcm16b/audio_encoder_pcm16b.cc
index 831daed..106ab16 100644
--- a/modules/audio_coding/codecs/pcm16b/audio_encoder_pcm16b.cc
+++ b/modules/audio_coding/codecs/pcm16b/audio_encoder_pcm16b.cc
@@ -10,12 +10,9 @@
 
 #include "modules/audio_coding/codecs/pcm16b/audio_encoder_pcm16b.h"
 
-#include <algorithm>
-
-#include "common_types.h"  // NOLINT(build/include)
+#include "common_types.h"
 #include "modules/audio_coding/codecs/pcm16b/pcm16b.h"
 #include "rtc_base/checks.h"
-#include "rtc_base/numerics/safe_conversions.h"
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/codecs/pcm16b/pcm16b_common.cc b/modules/audio_coding/codecs/pcm16b/pcm16b_common.cc
index 6d0fc2d..8f8bba5 100644
--- a/modules/audio_coding/codecs/pcm16b/pcm16b_common.cc
+++ b/modules/audio_coding/codecs/pcm16b/pcm16b_common.cc
@@ -10,6 +10,9 @@
 
 #include "modules/audio_coding/codecs/pcm16b/pcm16b_common.h"
 
+#include <stdint.h>
+#include <initializer_list>
+
 namespace webrtc {
 
 void Pcm16BAppendSupportedCodecSpecs(std::vector<AudioCodecSpec>* specs) {
diff --git a/modules/audio_coding/codecs/pcm16b/pcm16b_common.h b/modules/audio_coding/codecs/pcm16b/pcm16b_common.h
index 980a996..3fae717 100644
--- a/modules/audio_coding/codecs/pcm16b/pcm16b_common.h
+++ b/modules/audio_coding/codecs/pcm16b/pcm16b_common.h
@@ -13,7 +13,7 @@
 
 #include <vector>
 
-#include "api/audio_codecs/audio_decoder_factory.h"
+#include "api/audio_codecs/audio_format.h"
 
 namespace webrtc {
 void Pcm16BAppendSupportedCodecSpecs(std::vector<AudioCodecSpec>* specs);
diff --git a/modules/audio_coding/codecs/red/audio_encoder_copy_red.cc b/modules/audio_coding/codecs/red/audio_encoder_copy_red.cc
index 2601f26..124e811 100644
--- a/modules/audio_coding/codecs/red/audio_encoder_copy_red.cc
+++ b/modules/audio_coding/codecs/red/audio_encoder_copy_red.cc
@@ -11,8 +11,8 @@
 #include "modules/audio_coding/codecs/red/audio_encoder_copy_red.h"
 
 #include <string.h>
-
 #include <utility>
+#include <vector>
 
 #include "rtc_base/checks.h"
 
diff --git a/modules/audio_coding/codecs/red/audio_encoder_copy_red.h b/modules/audio_coding/codecs/red/audio_encoder_copy_red.h
index 492ee3a..5a68876 100644
--- a/modules/audio_coding/codecs/red/audio_encoder_copy_red.h
+++ b/modules/audio_coding/codecs/red/audio_encoder_copy_red.h
@@ -11,9 +11,12 @@
 #ifndef MODULES_AUDIO_CODING_CODECS_RED_AUDIO_ENCODER_COPY_RED_H_
 #define MODULES_AUDIO_CODING_CODECS_RED_AUDIO_ENCODER_COPY_RED_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <memory>
-#include <vector>
 
+#include "absl/types/optional.h"
+#include "api/array_view.h"
 #include "api/audio_codecs/audio_encoder.h"
 #include "rtc_base/buffer.h"
 #include "rtc_base/constructormagic.h"
diff --git a/modules/audio_coding/neteq/accelerate.cc b/modules/audio_coding/neteq/accelerate.cc
index 18350b0..6161a8f 100644
--- a/modules/audio_coding/neteq/accelerate.cc
+++ b/modules/audio_coding/neteq/accelerate.cc
@@ -10,7 +10,10 @@
 
 #include "modules/audio_coding/neteq/accelerate.h"
 
-#include "common_audio/signal_processing/include/signal_processing_library.h"
+#include <assert.h>
+
+#include "api/array_view.h"
+#include "modules/audio_coding/neteq/audio_multi_vector.h"
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/accelerate.h b/modules/audio_coding/neteq/accelerate.h
index 5609568..1a3af42 100644
--- a/modules/audio_coding/neteq/accelerate.h
+++ b/modules/audio_coding/neteq/accelerate.h
@@ -11,13 +11,15 @@
 #ifndef MODULES_AUDIO_CODING_NETEQ_ACCELERATE_H_
 #define MODULES_AUDIO_CODING_NETEQ_ACCELERATE_H_
 
-#include "modules/audio_coding/neteq/audio_multi_vector.h"
+#include <stddef.h>
+#include <stdint.h>
+
 #include "modules/audio_coding/neteq/time_stretch.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
 
-// Forward declarations.
+class AudioMultiVector;
 class BackgroundNoise;
 
 // This class implements the Accelerate operation. Most of the work is done
diff --git a/modules/audio_coding/neteq/audio_multi_vector.h b/modules/audio_coding/neteq/audio_multi_vector.h
index 86f8282..a2dd3c3 100644
--- a/modules/audio_coding/neteq/audio_multi_vector.h
+++ b/modules/audio_coding/neteq/audio_multi_vector.h
@@ -11,8 +11,8 @@
 #ifndef MODULES_AUDIO_CODING_NETEQ_AUDIO_MULTI_VECTOR_H_
 #define MODULES_AUDIO_CODING_NETEQ_AUDIO_MULTI_VECTOR_H_
 
-#include <string.h>  // Access to size_t.
-
+#include <stdint.h>
+#include <string.h>
 #include <vector>
 
 #include "api/array_view.h"
diff --git a/modules/audio_coding/neteq/audio_vector.h b/modules/audio_coding/neteq/audio_vector.h
index 825a3bc..d0db332 100644
--- a/modules/audio_coding/neteq/audio_vector.h
+++ b/modules/audio_coding/neteq/audio_vector.h
@@ -11,7 +11,8 @@
 #ifndef MODULES_AUDIO_CODING_NETEQ_AUDIO_VECTOR_H_
 #define MODULES_AUDIO_CODING_NETEQ_AUDIO_VECTOR_H_
 
-#include <string.h>  // Access to size_t.
+#include <string.h>
+#include <cstdint>
 #include <memory>
 
 #include "rtc_base/checks.h"
diff --git a/modules/audio_coding/neteq/background_noise.h b/modules/audio_coding/neteq/background_noise.h
index 58eecaa..84d7eb9 100644
--- a/modules/audio_coding/neteq/background_noise.h
+++ b/modules/audio_coding/neteq/background_noise.h
@@ -14,13 +14,12 @@
 #include <string.h>  // size_t
 #include <memory>
 
-#include "modules/audio_coding/neteq/audio_multi_vector.h"
-#include "modules/audio_coding/neteq/include/neteq.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
 
 // Forward declarations.
+class AudioMultiVector;
 class PostDecodeVad;
 
 // This class handles estimation of background noise parameters.
diff --git a/modules/audio_coding/neteq/buffer_level_filter.cc b/modules/audio_coding/neteq/buffer_level_filter.cc
index 6e8da0a..2f96618 100644
--- a/modules/audio_coding/neteq/buffer_level_filter.cc
+++ b/modules/audio_coding/neteq/buffer_level_filter.cc
@@ -10,7 +10,8 @@
 
 #include "modules/audio_coding/neteq/buffer_level_filter.h"
 
-#include <algorithm>  // Provide access to std::max.
+#include <stdint.h>
+#include <algorithm>
 
 #include "rtc_base/numerics/safe_conversions.h"
 
diff --git a/modules/audio_coding/neteq/comfort_noise.cc b/modules/audio_coding/neteq/comfort_noise.cc
index b341acd..cb2b74d 100644
--- a/modules/audio_coding/neteq/comfort_noise.cc
+++ b/modules/audio_coding/neteq/comfort_noise.cc
@@ -11,11 +11,18 @@
 #include "modules/audio_coding/neteq/comfort_noise.h"
 
 #include <assert.h>
+#include <cstdint>
+#include <memory>
 
-#include "api/audio_codecs/audio_decoder.h"
+#include "api/array_view.h"
+#include "modules/audio_coding/codecs/cng/webrtc_cng.h"
+#include "modules/audio_coding/neteq/audio_multi_vector.h"
+#include "modules/audio_coding/neteq/audio_vector.h"
 #include "modules/audio_coding/neteq/decoder_database.h"
 #include "modules/audio_coding/neteq/dsp_helper.h"
 #include "modules/audio_coding/neteq/sync_buffer.h"
+#include "rtc_base/buffer.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 
 namespace webrtc {
diff --git a/modules/audio_coding/neteq/comfort_noise.h b/modules/audio_coding/neteq/comfort_noise.h
index 5169124..3a9bfde 100644
--- a/modules/audio_coding/neteq/comfort_noise.h
+++ b/modules/audio_coding/neteq/comfort_noise.h
@@ -11,12 +11,14 @@
 #ifndef MODULES_AUDIO_CODING_NETEQ_COMFORT_NOISE_H_
 #define MODULES_AUDIO_CODING_NETEQ_COMFORT_NOISE_H_
 
-#include "modules/audio_coding/neteq/audio_multi_vector.h"
+#include <stddef.h>
+
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
 
 // Forward declarations.
+class AudioMultiVector;
 class DecoderDatabase;
 class SyncBuffer;
 struct Packet;
diff --git a/modules/audio_coding/neteq/cross_correlation.h b/modules/audio_coding/neteq/cross_correlation.h
index a747772..9ce8be8 100644
--- a/modules/audio_coding/neteq/cross_correlation.h
+++ b/modules/audio_coding/neteq/cross_correlation.h
@@ -11,7 +11,8 @@
 #ifndef MODULES_AUDIO_CODING_NETEQ_CROSS_CORRELATION_H_
 #define MODULES_AUDIO_CODING_NETEQ_CROSS_CORRELATION_H_
 
-#include "common_types.h"  // NOLINT(build/include)
+#include <stddef.h>
+#include <stdint.h>
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/decision_logic.cc b/modules/audio_coding/neteq/decision_logic.cc
index 349fdab..83c2b3b 100644
--- a/modules/audio_coding/neteq/decision_logic.cc
+++ b/modules/audio_coding/neteq/decision_logic.cc
@@ -11,8 +11,8 @@
 #include "modules/audio_coding/neteq/decision_logic.h"
 
 #include <assert.h>
-#include <algorithm>
-#include <limits>
+#include <stdio.h>
+#include <string>
 
 #include "modules/audio_coding/neteq/buffer_level_filter.h"
 #include "modules/audio_coding/neteq/decoder_database.h"
@@ -20,8 +20,9 @@
 #include "modules/audio_coding/neteq/expand.h"
 #include "modules/audio_coding/neteq/packet_buffer.h"
 #include "modules/audio_coding/neteq/sync_buffer.h"
-#include "modules/include/module_common_types.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
+#include "rtc_base/numerics/safe_conversions.h"
 #include "system_wrappers/include/field_trial.h"
 
 namespace {
diff --git a/modules/audio_coding/neteq/decision_logic.h b/modules/audio_coding/neteq/decision_logic.h
index 39761da..2a53359 100644
--- a/modules/audio_coding/neteq/decision_logic.h
+++ b/modules/audio_coding/neteq/decision_logic.h
@@ -12,7 +12,6 @@
 #define MODULES_AUDIO_CODING_NETEQ_DECISION_LOGIC_H_
 
 #include "modules/audio_coding/neteq/defines.h"
-#include "modules/audio_coding/neteq/include/neteq.h"
 #include "modules/audio_coding/neteq/tick_timer.h"
 #include "rtc_base/constructormagic.h"
 
diff --git a/modules/audio_coding/neteq/decoder_database.cc b/modules/audio_coding/neteq/decoder_database.cc
index 1fd8c03..0890beb 100644
--- a/modules/audio_coding/neteq/decoder_database.cc
+++ b/modules/audio_coding/neteq/decoder_database.cc
@@ -10,9 +10,15 @@
 
 #include "modules/audio_coding/neteq/decoder_database.h"
 
-#include <utility>  // pair
+#include <stddef.h>
+#include <cstdint>
+#include <list>
+#include <type_traits>
+#include <utility>
 
+#include "absl/strings/match.h"
 #include "api/audio_codecs/audio_decoder.h"
+#include "common_types.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/strings/audio_format_to_string.h"
@@ -101,7 +107,7 @@
 }
 
 bool DecoderDatabase::DecoderInfo::IsType(const char* name) const {
-  return STR_CASE_CMP(audio_format_.name.c_str(), name) == 0;
+  return absl::EqualsIgnoreCase(audio_format_.name, name);
 }
 
 bool DecoderDatabase::DecoderInfo::IsType(const std::string& name) const {
@@ -110,7 +116,7 @@
 
 absl::optional<DecoderDatabase::DecoderInfo::CngDecoder>
 DecoderDatabase::DecoderInfo::CngDecoder::Create(const SdpAudioFormat& format) {
-  if (STR_CASE_CMP(format.name.c_str(), "CN") == 0) {
+  if (absl::EqualsIgnoreCase(format.name, "CN")) {
     // CN has a 1:1 RTP clock rate to sample rate ratio.
     const int sample_rate_hz = format.clockrate_hz;
     RTC_DCHECK(sample_rate_hz == 8000 || sample_rate_hz == 16000 ||
@@ -123,11 +129,11 @@
 
 DecoderDatabase::DecoderInfo::Subtype
 DecoderDatabase::DecoderInfo::SubtypeFromFormat(const SdpAudioFormat& format) {
-  if (STR_CASE_CMP(format.name.c_str(), "CN") == 0) {
+  if (absl::EqualsIgnoreCase(format.name, "CN")) {
     return Subtype::kComfortNoise;
-  } else if (STR_CASE_CMP(format.name.c_str(), "telephone-event") == 0) {
+  } else if (absl::EqualsIgnoreCase(format.name, "telephone-event")) {
     return Subtype::kDtmf;
-  } else if (STR_CASE_CMP(format.name.c_str(), "red") == 0) {
+  } else if (absl::EqualsIgnoreCase(format.name, "red")) {
     return Subtype::kRed;
   }
 
diff --git a/modules/audio_coding/neteq/delay_manager.cc b/modules/audio_coding/neteq/delay_manager.cc
index e5eb592..628812a 100644
--- a/modules/audio_coding/neteq/delay_manager.cc
+++ b/modules/audio_coding/neteq/delay_manager.cc
@@ -11,14 +11,15 @@
 #include "modules/audio_coding/neteq/delay_manager.h"
 
 #include <assert.h>
-#include <math.h>
-
-#include <algorithm>  // max, min
+#include <stdio.h>
+#include <stdlib.h>
+#include <algorithm>
 #include <numeric>
+#include <string>
 
-#include "common_audio/signal_processing/include/signal_processing_library.h"
 #include "modules/audio_coding/neteq/delay_peak_detector.h"
-#include "modules/include/module_common_types.h"
+#include "modules/include/module_common_types_public.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/numerics/safe_conversions.h"
 #include "system_wrappers/include/field_trial.h"
diff --git a/modules/audio_coding/neteq/delay_peak_detector.cc b/modules/audio_coding/neteq/delay_peak_detector.cc
index eb9f6d5..893ce3e 100644
--- a/modules/audio_coding/neteq/delay_peak_detector.cc
+++ b/modules/audio_coding/neteq/delay_peak_detector.cc
@@ -10,10 +10,9 @@
 
 #include "modules/audio_coding/neteq/delay_peak_detector.h"
 
-#include <algorithm>  // max
+#include <algorithm>
 
 #include "rtc_base/checks.h"
-#include "rtc_base/numerics/safe_conversions.h"
 #include "system_wrappers/include/field_trial.h"
 
 namespace webrtc {
diff --git a/modules/audio_coding/neteq/delay_peak_detector.h b/modules/audio_coding/neteq/delay_peak_detector.h
index 9defca5..272d50e 100644
--- a/modules/audio_coding/neteq/delay_peak_detector.h
+++ b/modules/audio_coding/neteq/delay_peak_detector.h
@@ -11,8 +11,8 @@
 #ifndef MODULES_AUDIO_CODING_NETEQ_DELAY_PEAK_DETECTOR_H_
 #define MODULES_AUDIO_CODING_NETEQ_DELAY_PEAK_DETECTOR_H_
 
-#include <string.h>  // size_t
-
+#include <stdint.h>
+#include <string.h>
 #include <list>
 #include <memory>
 
diff --git a/modules/audio_coding/neteq/dsp_helper.h b/modules/audio_coding/neteq/dsp_helper.h
index efa2f9c..8379461 100644
--- a/modules/audio_coding/neteq/dsp_helper.h
+++ b/modules/audio_coding/neteq/dsp_helper.h
@@ -11,9 +11,11 @@
 #ifndef MODULES_AUDIO_CODING_NETEQ_DSP_HELPER_H_
 #define MODULES_AUDIO_CODING_NETEQ_DSP_HELPER_H_
 
-#include <string.h>  // Access to size_t.
+#include <stdint.h>
+#include <string.h>
 
 #include "modules/audio_coding/neteq/audio_multi_vector.h"
+#include "modules/audio_coding/neteq/audio_vector.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
diff --git a/modules/audio_coding/neteq/dtmf_buffer.h b/modules/audio_coding/neteq/dtmf_buffer.h
index 6de5127..24b14ec 100644
--- a/modules/audio_coding/neteq/dtmf_buffer.h
+++ b/modules/audio_coding/neteq/dtmf_buffer.h
@@ -11,8 +11,9 @@
 #ifndef MODULES_AUDIO_CODING_NETEQ_DTMF_BUFFER_H_
 #define MODULES_AUDIO_CODING_NETEQ_DTMF_BUFFER_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <list>
-#include <string>  // size_t
 
 #include "rtc_base/constructormagic.h"
 
diff --git a/modules/audio_coding/neteq/dtmf_tone_generator.cc b/modules/audio_coding/neteq/dtmf_tone_generator.cc
index 6fdb95a..6c412e3 100644
--- a/modules/audio_coding/neteq/dtmf_tone_generator.cc
+++ b/modules/audio_coding/neteq/dtmf_tone_generator.cc
@@ -30,6 +30,7 @@
 
 #include "modules/audio_coding/neteq/dtmf_tone_generator.h"
 
+#include "modules/audio_coding/neteq/audio_vector.h"
 #include "rtc_base/arraysize.h"
 #include "rtc_base/checks.h"
 
diff --git a/modules/audio_coding/neteq/dtmf_tone_generator.h b/modules/audio_coding/neteq/dtmf_tone_generator.h
index a773ff3..22e166e 100644
--- a/modules/audio_coding/neteq/dtmf_tone_generator.h
+++ b/modules/audio_coding/neteq/dtmf_tone_generator.h
@@ -11,6 +11,9 @@
 #ifndef MODULES_AUDIO_CODING_NETEQ_DTMF_TONE_GENERATOR_H_
 #define MODULES_AUDIO_CODING_NETEQ_DTMF_TONE_GENERATOR_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "modules/audio_coding/neteq/audio_multi_vector.h"
 #include "rtc_base/constructormagic.h"
 
diff --git a/modules/audio_coding/neteq/expand.cc b/modules/audio_coding/neteq/expand.cc
index 5f671ad..97ce529 100644
--- a/modules/audio_coding/neteq/expand.cc
+++ b/modules/audio_coding/neteq/expand.cc
@@ -17,6 +17,7 @@
 #include <limits>     // numeric_limits<T>
 
 #include "common_audio/signal_processing/include/signal_processing_library.h"
+#include "modules/audio_coding/neteq/audio_multi_vector.h"
 #include "modules/audio_coding/neteq/background_noise.h"
 #include "modules/audio_coding/neteq/cross_correlation.h"
 #include "modules/audio_coding/neteq/dsp_helper.h"
diff --git a/modules/audio_coding/neteq/expand.h b/modules/audio_coding/neteq/expand.h
index 4cfe7b9..30c34a2 100644
--- a/modules/audio_coding/neteq/expand.h
+++ b/modules/audio_coding/neteq/expand.h
@@ -14,12 +14,13 @@
 #include <assert.h>
 #include <memory>
 
-#include "modules/audio_coding/neteq/audio_multi_vector.h"
+#include "modules/audio_coding/neteq/audio_vector.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
 
 // Forward declarations.
+class AudioMultiVector;
 class BackgroundNoise;
 class RandomVector;
 class StatisticsCalculator;
diff --git a/modules/audio_coding/neteq/expand_uma_logger.h b/modules/audio_coding/neteq/expand_uma_logger.h
index 00907d4..bd079c6 100644
--- a/modules/audio_coding/neteq/expand_uma_logger.h
+++ b/modules/audio_coding/neteq/expand_uma_logger.h
@@ -10,6 +10,7 @@
 #ifndef MODULES_AUDIO_CODING_NETEQ_EXPAND_UMA_LOGGER_H_
 #define MODULES_AUDIO_CODING_NETEQ_EXPAND_UMA_LOGGER_H_
 
+#include <stdint.h>
 #include <memory>
 #include <string>
 
diff --git a/modules/audio_coding/neteq/nack_tracker.cc b/modules/audio_coding/neteq/nack_tracker.cc
index c62cdf8..e3ecfea 100644
--- a/modules/audio_coding/neteq/nack_tracker.cc
+++ b/modules/audio_coding/neteq/nack_tracker.cc
@@ -10,9 +10,9 @@
 
 #include "modules/audio_coding/neteq/nack_tracker.h"
 
-#include <assert.h>  // For assert.
-
-#include <algorithm>  // For std::max.
+#include <assert.h>
+#include <cstdint>
+#include <utility>
 
 #include "rtc_base/checks.h"
 
diff --git a/modules/audio_coding/neteq/nack_tracker.h b/modules/audio_coding/neteq/nack_tracker.h
index 1936a94..d7c6b08 100644
--- a/modules/audio_coding/neteq/nack_tracker.h
+++ b/modules/audio_coding/neteq/nack_tracker.h
@@ -11,11 +11,12 @@
 #ifndef MODULES_AUDIO_CODING_NETEQ_NACK_TRACKER_H_
 #define MODULES_AUDIO_CODING_NETEQ_NACK_TRACKER_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <map>
 #include <vector>
 
-#include "modules/audio_coding/include/audio_coding_module_typedefs.h"
-#include "modules/include/module_common_types.h"
+#include "modules/include/module_common_types_public.h"
 #include "rtc_base/gtest_prod_util.h"
 
 //
diff --git a/modules/audio_coding/neteq/neteq.cc b/modules/audio_coding/neteq/neteq.cc
index cf1c6aa..0e6147e 100644
--- a/modules/audio_coding/neteq/neteq.cc
+++ b/modules/audio_coding/neteq/neteq.cc
@@ -10,8 +10,6 @@
 
 #include "modules/audio_coding/neteq/include/neteq.h"
 
-#include <memory>
-
 #include "modules/audio_coding/neteq/neteq_impl.h"
 #include "rtc_base/strings/string_builder.h"
 
diff --git a/modules/audio_coding/neteq/neteq_impl.cc b/modules/audio_coding/neteq/neteq_impl.cc
index f428be1..6a2cbae 100644
--- a/modules/audio_coding/neteq/neteq_impl.cc
+++ b/modules/audio_coding/neteq/neteq_impl.cc
@@ -11,13 +11,16 @@
 #include "modules/audio_coding/neteq/neteq_impl.h"
 
 #include <assert.h>
-
 #include <algorithm>
+#include <cstdint>
+#include <cstring>
+#include <list>
 #include <utility>
 #include <vector>
 
 #include "api/audio_codecs/audio_decoder.h"
 #include "common_audio/signal_processing/include/signal_processing_library.h"
+#include "modules/audio_coding/codecs/cng/webrtc_cng.h"
 #include "modules/audio_coding/neteq/accelerate.h"
 #include "modules/audio_coding/neteq/background_noise.h"
 #include "modules/audio_coding/neteq/buffer_level_filter.h"
@@ -40,15 +43,14 @@
 #include "modules/audio_coding/neteq/red_payload_splitter.h"
 #include "modules/audio_coding/neteq/sync_buffer.h"
 #include "modules/audio_coding/neteq/tick_timer.h"
+#include "modules/audio_coding/neteq/time_stretch.h"
 #include "modules/audio_coding/neteq/timestamp_scaler.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/numerics/safe_conversions.h"
 #include "rtc_base/sanitizer.h"
 #include "rtc_base/strings/audio_format_to_string.h"
-#include "rtc_base/system/fallthrough.h"
 #include "rtc_base/trace_event.h"
-#include "system_wrappers/include/field_trial.h"
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/neteq_impl.h b/modules/audio_coding/neteq/neteq_impl.h
index 8ef97ce..36990fb 100644
--- a/modules/audio_coding/neteq/neteq_impl.h
+++ b/modules/audio_coding/neteq/neteq_impl.h
@@ -17,10 +17,10 @@
 #include "absl/types/optional.h"
 #include "api/audio/audio_frame.h"
 #include "modules/audio_coding/neteq/audio_multi_vector.h"
-#include "modules/audio_coding/neteq/defines.h"
+#include "modules/audio_coding/neteq/defines.h"  // Modes, Operations
 #include "modules/audio_coding/neteq/expand_uma_logger.h"
 #include "modules/audio_coding/neteq/include/neteq.h"
-#include "modules/audio_coding/neteq/packet.h"  // Declare PacketList.
+#include "modules/audio_coding/neteq/packet.h"
 #include "modules/audio_coding/neteq/random_vector.h"
 #include "modules/audio_coding/neteq/rtcp.h"
 #include "modules/audio_coding/neteq/statistics_calculator.h"
diff --git a/modules/audio_coding/neteq/neteq_unittest.cc b/modules/audio_coding/neteq/neteq_unittest.cc
index 3ee0b5b..1c9b9e7 100644
--- a/modules/audio_coding/neteq/neteq_unittest.cc
+++ b/modules/audio_coding/neteq/neteq_unittest.cc
@@ -52,7 +52,7 @@
 RTC_POP_IGNORING_WUNDEF()
 #endif
 
-DEFINE_bool(gen_ref, false, "Generate reference files.");
+WEBRTC_DEFINE_bool(gen_ref, false, "Generate reference files.");
 
 namespace webrtc {
 
@@ -1740,7 +1740,7 @@
       {8, kRtpExtensionVideoTiming}};
   std::unique_ptr<NetEqInput> input(new NetEqRtpDumpInput(
       webrtc::test::ResourcePath("audio_coding/neteq_universal_new", "rtp"),
-      rtp_ext_map));
+      rtp_ext_map, absl::nullopt /*No SSRC filter*/));
   std::unique_ptr<TimeLimitedNetEqInput> input_time_limit(
       new TimeLimitedNetEqInput(std::move(input), 20000));
   std::unique_ptr<AudioSink> output(new VoidAudioSink);
diff --git a/modules/audio_coding/neteq/normal.h b/modules/audio_coding/neteq/normal.h
index b13f16e..80451b5 100644
--- a/modules/audio_coding/neteq/normal.h
+++ b/modules/audio_coding/neteq/normal.h
@@ -11,11 +11,9 @@
 #ifndef MODULES_AUDIO_CODING_NETEQ_NORMAL_H_
 #define MODULES_AUDIO_CODING_NETEQ_NORMAL_H_
 
+#include <stdint.h>
 #include <string.h>  // Access to size_t.
 
-#include <vector>
-
-#include "modules/audio_coding/neteq/audio_multi_vector.h"
 #include "modules/audio_coding/neteq/defines.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/constructormagic.h"
@@ -24,6 +22,7 @@
 namespace webrtc {
 
 // Forward declarations.
+class AudioMultiVector;
 class BackgroundNoise;
 class DecoderDatabase;
 class Expand;
diff --git a/modules/audio_coding/neteq/packet.h b/modules/audio_coding/neteq/packet.h
index 45c56e1..358d8fa 100644
--- a/modules/audio_coding/neteq/packet.h
+++ b/modules/audio_coding/neteq/packet.h
@@ -11,12 +11,14 @@
 #ifndef MODULES_AUDIO_CODING_NETEQ_PACKET_H_
 #define MODULES_AUDIO_CODING_NETEQ_PACKET_H_
 
+#include <stdint.h>
 #include <list>
 #include <memory>
 
 #include "api/audio_codecs/audio_decoder.h"
 #include "modules/audio_coding/neteq/tick_timer.h"
 #include "rtc_base/buffer.h"
+#include "rtc_base/checks.h"
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/packet_buffer.cc b/modules/audio_coding/neteq/packet_buffer.cc
index eba4d3e..7b70dee 100644
--- a/modules/audio_coding/neteq/packet_buffer.cc
+++ b/modules/audio_coding/neteq/packet_buffer.cc
@@ -14,12 +14,17 @@
 
 #include "modules/audio_coding/neteq/packet_buffer.h"
 
-#include <algorithm>  // find_if()
+#include <algorithm>
+#include <list>
+#include <memory>
+#include <type_traits>
+#include <utility>
 
 #include "api/audio_codecs/audio_decoder.h"
 #include "modules/audio_coding/neteq/decoder_database.h"
 #include "modules/audio_coding/neteq/statistics_calculator.h"
 #include "modules/audio_coding/neteq/tick_timer.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 
 namespace webrtc {
diff --git a/modules/audio_coding/neteq/packet_buffer.h b/modules/audio_coding/neteq/packet_buffer.h
index 7e34c1e..269b957 100644
--- a/modules/audio_coding/neteq/packet_buffer.h
+++ b/modules/audio_coding/neteq/packet_buffer.h
@@ -14,7 +14,7 @@
 #include "absl/types/optional.h"
 #include "modules/audio_coding/neteq/decoder_database.h"
 #include "modules/audio_coding/neteq/packet.h"
-#include "modules/include/module_common_types.h"
+#include "modules/include/module_common_types_public.h"  // IsNewerTimestamp
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
diff --git a/modules/audio_coding/neteq/post_decode_vad.h b/modules/audio_coding/neteq/post_decode_vad.h
index ad4f082..27d69a6 100644
--- a/modules/audio_coding/neteq/post_decode_vad.h
+++ b/modules/audio_coding/neteq/post_decode_vad.h
@@ -11,13 +11,11 @@
 #ifndef MODULES_AUDIO_CODING_NETEQ_POST_DECODE_VAD_H_
 #define MODULES_AUDIO_CODING_NETEQ_POST_DECODE_VAD_H_
 
-#include <string>  // size_t
+#include <stddef.h>
+#include <stdint.h>
 
 #include "api/audio_codecs/audio_decoder.h"
 #include "common_audio/vad/include/webrtc_vad.h"
-#include "common_types.h"  // NOLINT(build/include)  // NULL
-#include "modules/audio_coding/neteq/defines.h"
-#include "modules/audio_coding/neteq/packet.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
diff --git a/modules/audio_coding/neteq/preemptive_expand.cc b/modules/audio_coding/neteq/preemptive_expand.cc
index 6159a9c..cad8d6a 100644
--- a/modules/audio_coding/neteq/preemptive_expand.cc
+++ b/modules/audio_coding/neteq/preemptive_expand.cc
@@ -10,9 +10,11 @@
 
 #include "modules/audio_coding/neteq/preemptive_expand.h"
 
-#include <algorithm>  // min, max
+#include <algorithm>
 
-#include "common_audio/signal_processing/include/signal_processing_library.h"
+#include "api/array_view.h"
+#include "modules/audio_coding/neteq/audio_multi_vector.h"
+#include "modules/audio_coding/neteq/time_stretch.h"
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/preemptive_expand.h b/modules/audio_coding/neteq/preemptive_expand.h
index ace648f..0f7b3bc 100644
--- a/modules/audio_coding/neteq/preemptive_expand.h
+++ b/modules/audio_coding/neteq/preemptive_expand.h
@@ -11,13 +11,15 @@
 #ifndef MODULES_AUDIO_CODING_NETEQ_PREEMPTIVE_EXPAND_H_
 #define MODULES_AUDIO_CODING_NETEQ_PREEMPTIVE_EXPAND_H_
 
-#include "modules/audio_coding/neteq/audio_multi_vector.h"
+#include <stddef.h>
+#include <stdint.h>
+
 #include "modules/audio_coding/neteq/time_stretch.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
 
-// Forward declarations.
+class AudioMultiVector;
 class BackgroundNoise;
 
 // This class implements the PreemptiveExpand operation. Most of the work is
diff --git a/modules/audio_coding/neteq/red_payload_splitter.cc b/modules/audio_coding/neteq/red_payload_splitter.cc
index f5435e8..2dfe838 100644
--- a/modules/audio_coding/neteq/red_payload_splitter.cc
+++ b/modules/audio_coding/neteq/red_payload_splitter.cc
@@ -11,10 +11,15 @@
 #include "modules/audio_coding/neteq/red_payload_splitter.h"
 
 #include <assert.h>
+#include <stddef.h>
+#include <cstdint>
+#include <list>
+#include <utility>
 #include <vector>
 
 #include "modules/audio_coding/neteq/decoder_database.h"
-#include "rtc_base/checks.h"
+#include "modules/audio_coding/neteq/packet.h"
+#include "rtc_base/buffer.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/numerics/safe_conversions.h"
 
diff --git a/modules/audio_coding/neteq/red_payload_splitter.h b/modules/audio_coding/neteq/red_payload_splitter.h
index 5e239dd..55063e7 100644
--- a/modules/audio_coding/neteq/red_payload_splitter.h
+++ b/modules/audio_coding/neteq/red_payload_splitter.h
@@ -16,7 +16,6 @@
 
 namespace webrtc {
 
-// Forward declarations.
 class DecoderDatabase;
 
 // This class handles splitting of RED payloads into smaller parts.
diff --git a/modules/audio_coding/neteq/rtcp.cc b/modules/audio_coding/neteq/rtcp.cc
index 551eb5f..6519337 100644
--- a/modules/audio_coding/neteq/rtcp.cc
+++ b/modules/audio_coding/neteq/rtcp.cc
@@ -10,10 +10,12 @@
 
 #include "modules/audio_coding/neteq/rtcp.h"
 
-#include <stdlib.h>
-#include <string.h>
-
 #include <algorithm>
+#include <cstdlib>
+
+#include "api/rtp_headers.h"
+#include "common_types.h"
+#include "rtc_base/checks.h"
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/rtcp.h b/modules/audio_coding/neteq/rtcp.h
index b1de7eb..60c2673 100644
--- a/modules/audio_coding/neteq/rtcp.h
+++ b/modules/audio_coding/neteq/rtcp.h
@@ -11,12 +11,13 @@
 #ifndef MODULES_AUDIO_CODING_NETEQ_RTCP_H_
 #define MODULES_AUDIO_CODING_NETEQ_RTCP_H_
 
-#include "modules/audio_coding/neteq/include/neteq.h"
+#include <stdint.h>
+
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
 
-// Forward declaration.
+struct RtcpStatistics;
 struct RTPHeader;
 
 class Rtcp {
diff --git a/modules/audio_coding/neteq/sync_buffer.h b/modules/audio_coding/neteq/sync_buffer.h
index 72e320c..d645e91 100644
--- a/modules/audio_coding/neteq/sync_buffer.h
+++ b/modules/audio_coding/neteq/sync_buffer.h
@@ -11,8 +11,13 @@
 #ifndef MODULES_AUDIO_CODING_NETEQ_SYNC_BUFFER_H_
 #define MODULES_AUDIO_CODING_NETEQ_SYNC_BUFFER_H_
 
+#include <stddef.h>
+#include <stdint.h>
+#include <vector>
+
 #include "api/audio/audio_frame.h"
 #include "modules/audio_coding/neteq/audio_multi_vector.h"
+#include "modules/audio_coding/neteq/audio_vector.h"
 #include "rtc_base/buffer.h"
 #include "rtc_base/constructormagic.h"
 
diff --git a/modules/audio_coding/neteq/tick_timer.h b/modules/audio_coding/neteq/tick_timer.h
index 520099e..02f083e 100644
--- a/modules/audio_coding/neteq/tick_timer.h
+++ b/modules/audio_coding/neteq/tick_timer.h
@@ -11,6 +11,7 @@
 #ifndef MODULES_AUDIO_CODING_NETEQ_TICK_TIMER_H_
 #define MODULES_AUDIO_CODING_NETEQ_TICK_TIMER_H_
 
+#include <stdint.h>
 #include <memory>
 
 #include "rtc_base/checks.h"
diff --git a/modules/audio_coding/neteq/timestamp_scaler.cc b/modules/audio_coding/neteq/timestamp_scaler.cc
index 07d945e..b0461bb 100644
--- a/modules/audio_coding/neteq/timestamp_scaler.cc
+++ b/modules/audio_coding/neteq/timestamp_scaler.cc
@@ -10,6 +10,7 @@
 
 #include "modules/audio_coding/neteq/timestamp_scaler.h"
 
+#include "api/audio_codecs/audio_format.h"
 #include "modules/audio_coding/neteq/decoder_database.h"
 #include "rtc_base/checks.h"
 
diff --git a/modules/audio_coding/neteq/tools/neteq_event_log_input.cc b/modules/audio_coding/neteq/tools/neteq_event_log_input.cc
index 21c5f9e..9107e5e 100644
--- a/modules/audio_coding/neteq/tools/neteq_event_log_input.cc
+++ b/modules/audio_coding/neteq/tools/neteq_event_log_input.cc
@@ -19,11 +19,8 @@
 namespace test {
 
 NetEqEventLogInput::NetEqEventLogInput(const std::string& file_name,
-                                       const RtpHeaderExtensionMap& hdr_ext_map)
-    : source_(RtcEventLogSource::Create(file_name)) {
-  for (const auto& ext_pair : hdr_ext_map) {
-    source_->RegisterRtpHeaderExtension(ext_pair.second, ext_pair.first);
-  }
+                                       absl::optional<uint32_t> ssrc_filter)
+    : source_(RtcEventLogSource::Create(file_name, ssrc_filter)) {
   LoadNextPacket();
   AdvanceOutputEvent();
 }
diff --git a/modules/audio_coding/neteq/tools/neteq_event_log_input.h b/modules/audio_coding/neteq/tools/neteq_event_log_input.h
index 86cf9f2..e04df16 100644
--- a/modules/audio_coding/neteq/tools/neteq_event_log_input.h
+++ b/modules/audio_coding/neteq/tools/neteq_event_log_input.h
@@ -28,7 +28,7 @@
 class NetEqEventLogInput final : public NetEqPacketSourceInput {
  public:
   NetEqEventLogInput(const std::string& file_name,
-                     const RtpHeaderExtensionMap& hdr_ext_map);
+                     absl::optional<uint32_t> ssrc_filter);
 
   absl::optional<int64_t> NextOutputEventTime() const override;
   void AdvanceOutputEvent() override;
diff --git a/modules/audio_coding/neteq/tools/neteq_packet_source_input.cc b/modules/audio_coding/neteq/tools/neteq_packet_source_input.cc
index a86cf6a..ee02288 100644
--- a/modules/audio_coding/neteq/tools/neteq_packet_source_input.cc
+++ b/modules/audio_coding/neteq/tools/neteq_packet_source_input.cc
@@ -58,15 +58,10 @@
   return packet_data;
 }
 
-void NetEqPacketSourceInput::SelectSsrc(uint32_t ssrc) {
-  source()->SelectSsrc(ssrc);
-  if (packet_ && packet_->header().ssrc != ssrc)
-    LoadNextPacket();
-}
-
 NetEqRtpDumpInput::NetEqRtpDumpInput(const std::string& file_name,
-                                     const RtpHeaderExtensionMap& hdr_ext_map)
-    : source_(RtpFileSource::Create(file_name)) {
+                                     const RtpHeaderExtensionMap& hdr_ext_map,
+                                     absl::optional<uint32_t> ssrc_filter)
+    : source_(RtpFileSource::Create(file_name, ssrc_filter)) {
   for (const auto& ext_pair : hdr_ext_map) {
     source_->RegisterRtpHeaderExtension(ext_pair.second, ext_pair.first);
   }
diff --git a/modules/audio_coding/neteq/tools/neteq_packet_source_input.h b/modules/audio_coding/neteq/tools/neteq_packet_source_input.h
index b32c534..8633d1f 100644
--- a/modules/audio_coding/neteq/tools/neteq_packet_source_input.h
+++ b/modules/audio_coding/neteq/tools/neteq_packet_source_input.h
@@ -12,8 +12,10 @@
 #define MODULES_AUDIO_CODING_NETEQ_TOOLS_NETEQ_PACKET_SOURCE_INPUT_H_
 
 #include <map>
+#include <memory>
 #include <string>
 
+#include "absl/types/optional.h"
 #include "modules/audio_coding/neteq/tools/neteq_input.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 
@@ -32,7 +34,6 @@
   std::unique_ptr<PacketData> PopPacket() override;
   absl::optional<RTPHeader> NextHeader() const override;
   bool ended() const override { return !next_output_event_ms_; }
-  void SelectSsrc(uint32_t);
 
  protected:
   virtual PacketSource* source() = 0;
@@ -48,7 +49,8 @@
 class NetEqRtpDumpInput final : public NetEqPacketSourceInput {
  public:
   NetEqRtpDumpInput(const std::string& file_name,
-                    const RtpHeaderExtensionMap& hdr_ext_map);
+                    const RtpHeaderExtensionMap& hdr_ext_map,
+                    absl::optional<uint32_t> ssrc_filter);
 
   absl::optional<int64_t> NextOutputEventTime() const override;
   void AdvanceOutputEvent() override;
diff --git a/modules/audio_coding/neteq/tools/neteq_quality_test.cc b/modules/audio_coding/neteq/tools/neteq_quality_test.cc
index faca895..2ee6779 100644
--- a/modules/audio_coding/neteq/tools/neteq_quality_test.cc
+++ b/modules/audio_coding/neteq/tools/neteq_quality_test.cc
@@ -47,42 +47,47 @@
   return true;
 }
 
-DEFINE_string(
+WEBRTC_DEFINE_string(
     in_filename,
     DefaultInFilename().c_str(),
     "Filename for input audio (specify sample rate with --input_sample_rate, "
     "and channels with --channels).");
 
-DEFINE_int(input_sample_rate, 16000, "Sample rate of input file in Hz.");
+WEBRTC_DEFINE_int(input_sample_rate, 16000, "Sample rate of input file in Hz.");
 
-DEFINE_int(channels, 1, "Number of channels in input audio.");
+WEBRTC_DEFINE_int(channels, 1, "Number of channels in input audio.");
 
-DEFINE_string(out_filename,
-              DefaultOutFilename().c_str(),
-              "Name of output audio file.");
+WEBRTC_DEFINE_string(out_filename,
+                     DefaultOutFilename().c_str(),
+                     "Name of output audio file.");
 
-DEFINE_int(runtime_ms, 10000, "Simulated runtime (milliseconds).");
+WEBRTC_DEFINE_int(runtime_ms, 10000, "Simulated runtime (milliseconds).");
 
-DEFINE_int(packet_loss_rate, 10, "Percentile of packet loss.");
+WEBRTC_DEFINE_int(packet_loss_rate, 10, "Percentile of packet loss.");
 
-DEFINE_int(random_loss_mode,
-           kUniformLoss,
-           "Random loss mode: 0--no loss, 1--uniform loss, 2--Gilbert Elliot "
-           "loss, 3--fixed loss.");
+WEBRTC_DEFINE_int(
+    random_loss_mode,
+    kUniformLoss,
+    "Random loss mode: 0--no loss, 1--uniform loss, 2--Gilbert Elliot "
+    "loss, 3--fixed loss.");
 
-DEFINE_int(burst_length,
-           30,
-           "Burst length in milliseconds, only valid for Gilbert Elliot loss.");
+WEBRTC_DEFINE_int(
+    burst_length,
+    30,
+    "Burst length in milliseconds, only valid for Gilbert Elliot loss.");
 
-DEFINE_float(drift_factor, 0.0, "Time drift factor.");
+WEBRTC_DEFINE_float(drift_factor, 0.0, "Time drift factor.");
 
-DEFINE_int(preload_packets, 0, "Preload the buffer with this many packets.");
+WEBRTC_DEFINE_int(preload_packets,
+                  0,
+                  "Preload the buffer with this many packets.");
 
-DEFINE_string(loss_events,
-              "",
-              "List of loss events time and duration separated by comma: "
-              "<first_event_time> <first_event_duration>, <second_event_time> "
-              "<second_event_duration>, ...");
+WEBRTC_DEFINE_string(
+    loss_events,
+    "",
+    "List of loss events time and duration separated by comma: "
+    "<first_event_time> <first_event_duration>, <second_event_time> "
+    "<second_event_duration>, ...");
 
 // ProbTrans00Solver() is to calculate the transition probability from no-loss
 // state to itself in a modified Gilbert Elliot packet loss model. The result is
diff --git a/modules/audio_coding/neteq/tools/neteq_rtpplay.cc b/modules/audio_coding/neteq/tools/neteq_rtpplay.cc
index 25e8cd8..c2726eb 100644
--- a/modules/audio_coding/neteq/tools/neteq_rtpplay.cc
+++ b/modules/audio_coding/neteq/tools/neteq_rtpplay.cc
@@ -17,17 +17,17 @@
 #include "system_wrappers/include/field_trial.h"
 #include "test/field_trial.h"
 
-DEFINE_bool(codec_map,
-            false,
-            "Prints the mapping between RTP payload type and "
-            "codec");
-DEFINE_string(
+WEBRTC_DEFINE_bool(codec_map,
+                   false,
+                   "Prints the mapping between RTP payload type and "
+                   "codec");
+WEBRTC_DEFINE_string(
     force_fieldtrials,
     "",
     "Field trials control experimental feature code which can be forced. "
     "E.g. running with --force_fieldtrials=WebRTC-FooFeature/Enable/"
     " will assign the group Enable to field trial WebRTC-FooFeature.");
-DEFINE_bool(help, false, "Prints this message");
+WEBRTC_DEFINE_bool(help, false, "Prints this message");
 
 int main(int argc, char* argv[]) {
   webrtc::test::NetEqTestFactory factory;
diff --git a/modules/audio_coding/neteq/tools/neteq_test_factory.cc b/modules/audio_coding/neteq/tools/neteq_test_factory.cc
index 51077bc..aa956ce 100644
--- a/modules/audio_coding/neteq/tools/neteq_test_factory.cc
+++ b/modules/audio_coding/neteq/tools/neteq_test_factory.cc
@@ -91,47 +91,60 @@
 }
 
 // Define command line flags.
-DEFINE_int(pcmu, 0, "RTP payload type for PCM-u");
-DEFINE_int(pcma, 8, "RTP payload type for PCM-a");
-DEFINE_int(ilbc, 102, "RTP payload type for iLBC");
-DEFINE_int(isac, 103, "RTP payload type for iSAC");
-DEFINE_int(isac_swb, 104, "RTP payload type for iSAC-swb (32 kHz)");
-DEFINE_int(opus, 111, "RTP payload type for Opus");
-DEFINE_int(pcm16b, 93, "RTP payload type for PCM16b-nb (8 kHz)");
-DEFINE_int(pcm16b_wb, 94, "RTP payload type for PCM16b-wb (16 kHz)");
-DEFINE_int(pcm16b_swb32, 95, "RTP payload type for PCM16b-swb32 (32 kHz)");
-DEFINE_int(pcm16b_swb48, 96, "RTP payload type for PCM16b-swb48 (48 kHz)");
-DEFINE_int(g722, 9, "RTP payload type for G.722");
-DEFINE_int(avt, 106, "RTP payload type for AVT/DTMF (8 kHz)");
-DEFINE_int(avt_16, 114, "RTP payload type for AVT/DTMF (16 kHz)");
-DEFINE_int(avt_32, 115, "RTP payload type for AVT/DTMF (32 kHz)");
-DEFINE_int(avt_48, 116, "RTP payload type for AVT/DTMF (48 kHz)");
-DEFINE_int(red, 117, "RTP payload type for redundant audio (RED)");
-DEFINE_int(cn_nb, 13, "RTP payload type for comfort noise (8 kHz)");
-DEFINE_int(cn_wb, 98, "RTP payload type for comfort noise (16 kHz)");
-DEFINE_int(cn_swb32, 99, "RTP payload type for comfort noise (32 kHz)");
-DEFINE_int(cn_swb48, 100, "RTP payload type for comfort noise (48 kHz)");
-DEFINE_string(replacement_audio_file,
-              "",
-              "A PCM file that will be used to populate "
-              "dummy"
-              " RTP packets");
-DEFINE_string(ssrc,
-              "",
-              "Only use packets with this SSRC (decimal or hex, the latter "
-              "starting with 0x)");
-DEFINE_int(audio_level, 1, "Extension ID for audio level (RFC 6464)");
-DEFINE_int(abs_send_time, 3, "Extension ID for absolute sender time");
-DEFINE_int(transport_seq_no, 5, "Extension ID for transport sequence number");
-DEFINE_int(video_content_type, 7, "Extension ID for video content type");
-DEFINE_int(video_timing, 8, "Extension ID for video timing");
-DEFINE_bool(matlabplot,
-            false,
-            "Generates a matlab script for plotting the delay profile");
-DEFINE_bool(pythonplot,
-            false,
-            "Generates a python script for plotting the delay profile");
-DEFINE_bool(concealment_events, false, "Prints concealment events");
+WEBRTC_DEFINE_int(pcmu, 0, "RTP payload type for PCM-u");
+WEBRTC_DEFINE_int(pcma, 8, "RTP payload type for PCM-a");
+WEBRTC_DEFINE_int(ilbc, 102, "RTP payload type for iLBC");
+WEBRTC_DEFINE_int(isac, 103, "RTP payload type for iSAC");
+WEBRTC_DEFINE_int(isac_swb, 104, "RTP payload type for iSAC-swb (32 kHz)");
+WEBRTC_DEFINE_int(opus, 111, "RTP payload type for Opus");
+WEBRTC_DEFINE_int(pcm16b, 93, "RTP payload type for PCM16b-nb (8 kHz)");
+WEBRTC_DEFINE_int(pcm16b_wb, 94, "RTP payload type for PCM16b-wb (16 kHz)");
+WEBRTC_DEFINE_int(pcm16b_swb32,
+                  95,
+                  "RTP payload type for PCM16b-swb32 (32 kHz)");
+WEBRTC_DEFINE_int(pcm16b_swb48,
+                  96,
+                  "RTP payload type for PCM16b-swb48 (48 kHz)");
+WEBRTC_DEFINE_int(g722, 9, "RTP payload type for G.722");
+WEBRTC_DEFINE_int(avt, 106, "RTP payload type for AVT/DTMF (8 kHz)");
+WEBRTC_DEFINE_int(avt_16, 114, "RTP payload type for AVT/DTMF (16 kHz)");
+WEBRTC_DEFINE_int(avt_32, 115, "RTP payload type for AVT/DTMF (32 kHz)");
+WEBRTC_DEFINE_int(avt_48, 116, "RTP payload type for AVT/DTMF (48 kHz)");
+WEBRTC_DEFINE_int(red, 117, "RTP payload type for redundant audio (RED)");
+WEBRTC_DEFINE_int(cn_nb, 13, "RTP payload type for comfort noise (8 kHz)");
+WEBRTC_DEFINE_int(cn_wb, 98, "RTP payload type for comfort noise (16 kHz)");
+WEBRTC_DEFINE_int(cn_swb32, 99, "RTP payload type for comfort noise (32 kHz)");
+WEBRTC_DEFINE_int(cn_swb48, 100, "RTP payload type for comfort noise (48 kHz)");
+WEBRTC_DEFINE_string(replacement_audio_file,
+                     "",
+                     "A PCM file that will be used to populate "
+                     "dummy"
+                     " RTP packets");
+WEBRTC_DEFINE_string(
+    ssrc,
+    "",
+    "Only use packets with this SSRC (decimal or hex, the latter "
+    "starting with 0x)");
+WEBRTC_DEFINE_int(audio_level, 1, "Extension ID for audio level (RFC 6464)");
+WEBRTC_DEFINE_int(abs_send_time, 3, "Extension ID for absolute sender time");
+WEBRTC_DEFINE_int(transport_seq_no,
+                  5,
+                  "Extension ID for transport sequence number");
+WEBRTC_DEFINE_int(video_content_type, 7, "Extension ID for video content type");
+WEBRTC_DEFINE_int(video_timing, 8, "Extension ID for video timing");
+WEBRTC_DEFINE_bool(matlabplot,
+                   false,
+                   "Generates a matlab script for plotting the delay profile");
+WEBRTC_DEFINE_bool(pythonplot,
+                   false,
+                   "Generates a python script for plotting the delay profile");
+WEBRTC_DEFINE_bool(concealment_events, false, "Prints concealment events");
+WEBRTC_DEFINE_int(max_nr_packets_in_buffer,
+                  50,
+                  "Maximum allowed number of packets in the buffer");
+WEBRTC_DEFINE_bool(enable_fast_accelerate,
+                   false,
+                   "Enables jitter buffer fast accelerate");
 
 // Maps a codec type to a printable name string.
 std::string CodecName(NetEqDecoder codec) {
@@ -309,25 +322,27 @@
       {FLAG_video_content_type, kRtpExtensionVideoContentType},
       {FLAG_video_timing, kRtpExtensionVideoTiming}};
 
+  absl::optional<uint32_t> ssrc_filter;
+  // Check if an SSRC value was provided.
+  if (strlen(FLAG_ssrc) > 0) {
+    uint32_t ssrc;
+    RTC_CHECK(ParseSsrc(FLAG_ssrc, &ssrc)) << "Flag verification has failed.";
+    ssrc_filter = ssrc;
+  }
+
   std::unique_ptr<NetEqInput> input;
   if (RtpFileSource::ValidRtpDump(input_file_name) ||
       RtpFileSource::ValidPcap(input_file_name)) {
-    input.reset(new NetEqRtpDumpInput(input_file_name, rtp_ext_map));
+    input.reset(
+        new NetEqRtpDumpInput(input_file_name, rtp_ext_map, ssrc_filter));
   } else {
-    input.reset(new NetEqEventLogInput(input_file_name, rtp_ext_map));
+    input.reset(new NetEqEventLogInput(input_file_name, ssrc_filter));
   }
 
   std::cout << "Input file: " << input_file_name << std::endl;
   RTC_CHECK(input) << "Cannot open input file";
   RTC_CHECK(!input->ended()) << "Input file is empty";
 
-  // Check if an SSRC value was provided.
-  if (strlen(FLAG_ssrc) > 0) {
-    uint32_t ssrc;
-    RTC_CHECK(ParseSsrc(FLAG_ssrc, &ssrc)) << "Flag verification has failed.";
-    static_cast<NetEqPacketSourceInput*>(input.get())->SelectSsrc(ssrc);
-  }
-
   // Check the sample rate.
   absl::optional<int> sample_rate_hz;
   std::set<std::pair<int, uint32_t>> discarded_pt_and_ssrc;
@@ -457,6 +472,8 @@
   callbacks.simulation_ended_callback = stats_plotter_.get();
   NetEq::Config config;
   config.sample_rate_hz = *sample_rate_hz;
+  config.max_packets_in_buffer = FLAG_max_nr_packets_in_buffer;
+  config.enable_fast_accelerate = FLAG_enable_fast_accelerate;
   return absl::make_unique<NetEqTest>(config, codecs, ext_codecs_,
                                       std::move(input), std::move(output),
                                       callbacks);
diff --git a/modules/audio_coding/neteq/tools/packet.cc b/modules/audio_coding/neteq/tools/packet.cc
index b1a9b64..0e7951b 100644
--- a/modules/audio_coding/neteq/tools/packet.cc
+++ b/modules/audio_coding/neteq/tools/packet.cc
@@ -49,6 +49,20 @@
   valid_header_ = ParseHeader(parser);
 }
 
+Packet::Packet(const RTPHeader& header,
+               size_t virtual_packet_length_bytes,
+               size_t virtual_payload_length_bytes,
+               double time_ms)
+    : header_(header),
+      payload_memory_(),
+      payload_(NULL),
+      packet_length_bytes_(0),
+      payload_length_bytes_(0),
+      virtual_packet_length_bytes_(virtual_packet_length_bytes),
+      virtual_payload_length_bytes_(virtual_payload_length_bytes),
+      time_ms_(time_ms),
+      valid_header_(true) {}
+
 Packet::Packet(uint8_t* packet_memory, size_t allocated_bytes, double time_ms)
     : payload_memory_(packet_memory),
       payload_(NULL),
diff --git a/modules/audio_coding/neteq/tools/packet.h b/modules/audio_coding/neteq/tools/packet.h
index 623c5cb..39137aa 100644
--- a/modules/audio_coding/neteq/tools/packet.h
+++ b/modules/audio_coding/neteq/tools/packet.h
@@ -50,7 +50,17 @@
          double time_ms,
          const RtpHeaderParser& parser);
 
-  // The following two constructors are the same as above, but without a
+  // Same as above, but creates the packet from an already parsed RTPHeader.
+  // This is typically used when reading RTP dump files that only contain the
+  // RTP headers, and no payload. The |virtual_packet_length_bytes| tells what
+  // size the packet had on wire, including the now discarded payload,
+  // The |virtual_payload_length_bytes| tells the size of the payload.
+  Packet(const RTPHeader& header,
+         size_t virtual_packet_length_bytes,
+         size_t virtual_payload_length_bytes,
+         double time_ms);
+
+  // The following constructors are the same as the first two, but without a
   // parser. Note that when the object is constructed using any of these
   // methods, the header will be parsed using a default RtpHeaderParser object.
   // In particular, RTP header extensions won't be parsed.
diff --git a/modules/audio_coding/neteq/tools/packet_source.cc b/modules/audio_coding/neteq/tools/packet_source.cc
index 30bf431..598ae6e 100644
--- a/modules/audio_coding/neteq/tools/packet_source.cc
+++ b/modules/audio_coding/neteq/tools/packet_source.cc
@@ -13,7 +13,7 @@
 namespace webrtc {
 namespace test {
 
-PacketSource::PacketSource() : use_ssrc_filter_(false), ssrc_(0) {}
+PacketSource::PacketSource() = default;
 
 PacketSource::~PacketSource() = default;
 
@@ -21,10 +21,5 @@
   filter_.set(payload_type, true);
 }
 
-void PacketSource::SelectSsrc(uint32_t ssrc) {
-  use_ssrc_filter_ = true;
-  ssrc_ = ssrc;
-}
-
 }  // namespace test
 }  // namespace webrtc
diff --git a/modules/audio_coding/neteq/tools/packet_source.h b/modules/audio_coding/neteq/tools/packet_source.h
index fb689e3..cb86a98 100644
--- a/modules/audio_coding/neteq/tools/packet_source.h
+++ b/modules/audio_coding/neteq/tools/packet_source.h
@@ -32,13 +32,8 @@
 
   virtual void FilterOutPayloadType(uint8_t payload_type);
 
-  virtual void SelectSsrc(uint32_t ssrc);
-
  protected:
   std::bitset<128> filter_;  // Payload type is 7 bits in the RFC.
-  // If SSRC filtering discards all packet that do not match the SSRC.
-  bool use_ssrc_filter_;  // True when SSRC filtering is active.
-  uint32_t ssrc_;  // The selected SSRC. All other SSRCs will be discarded.
 
  private:
   RTC_DISALLOW_COPY_AND_ASSIGN(PacketSource);
diff --git a/modules/audio_coding/neteq/tools/rtc_event_log_source.cc b/modules/audio_coding/neteq/tools/rtc_event_log_source.cc
index 9e435c7..582c2f2 100644
--- a/modules/audio_coding/neteq/tools/rtc_event_log_source.cc
+++ b/modules/audio_coding/neteq/tools/rtc_event_log_source.cc
@@ -13,94 +13,115 @@
 #include <string.h>
 #include <iostream>
 #include <limits>
+#include <utility>
 
+#include "logging/rtc_event_log/rtc_event_processor.h"
 #include "modules/audio_coding/neteq/tools/packet.h"
-#include "modules/rtp_rtcp/include/rtp_header_parser.h"
 #include "rtc_base/checks.h"
 
 namespace webrtc {
 namespace test {
 
-RtcEventLogSource* RtcEventLogSource::Create(const std::string& file_name) {
+namespace {
+bool ShouldSkipStream(ParsedRtcEventLogNew::MediaType media_type,
+                      uint32_t ssrc,
+                      absl::optional<uint32_t> ssrc_filter) {
+  if (media_type != ParsedRtcEventLogNew::MediaType::AUDIO)
+    return true;
+  if (ssrc_filter.has_value() && ssrc != *ssrc_filter)
+    return true;
+  return false;
+}
+}  // namespace
+
+RtcEventLogSource* RtcEventLogSource::Create(
+    const std::string& file_name,
+    absl::optional<uint32_t> ssrc_filter) {
   RtcEventLogSource* source = new RtcEventLogSource();
-  RTC_CHECK(source->OpenFile(file_name));
+  RTC_CHECK(source->OpenFile(file_name, ssrc_filter));
   return source;
 }
 
 RtcEventLogSource::~RtcEventLogSource() {}
 
-bool RtcEventLogSource::RegisterRtpHeaderExtension(RTPExtensionType type,
-                                                   uint8_t id) {
-  RTC_CHECK(parser_.get());
-  return parser_->RegisterRtpHeaderExtension(type, id);
-}
-
 std::unique_ptr<Packet> RtcEventLogSource::NextPacket() {
-  for (; rtp_packet_index_ < parsed_stream_.GetNumberOfEvents();
-       rtp_packet_index_++) {
-    if (parsed_stream_.GetEventType(rtp_packet_index_) ==
-        ParsedRtcEventLogNew::EventType::RTP_EVENT) {
-      PacketDirection direction;
-      size_t header_length;
-      size_t packet_length;
-      uint64_t timestamp_us = parsed_stream_.GetTimestamp(rtp_packet_index_);
-      parsed_stream_.GetRtpHeader(rtp_packet_index_, &direction, nullptr,
-                                  &header_length, &packet_length, nullptr);
+  if (rtp_packet_index_ >= rtp_packets_.size())
+    return nullptr;
 
-      if (direction != kIncomingPacket) {
-        continue;
-      }
-
-      uint8_t* packet_header = new uint8_t[header_length];
-      parsed_stream_.GetRtpHeader(rtp_packet_index_, nullptr, packet_header,
-                                  nullptr, nullptr, nullptr);
-      std::unique_ptr<Packet> packet(
-          new Packet(packet_header, header_length, packet_length,
-                     static_cast<double>(timestamp_us) / 1000, *parser_.get()));
-
-      if (!packet->valid_header()) {
-        std::cout << "Warning: Packet with index " << rtp_packet_index_
-                  << " has an invalid header and will be ignored." << std::endl;
-        continue;
-      }
-
-      if (parsed_stream_.GetMediaType(packet->header().ssrc, direction) !=
-          ParsedRtcEventLogNew::MediaType::AUDIO) {
-        continue;
-      }
-
-      // Check if the packet should not be filtered out.
-      if (!filter_.test(packet->header().payloadType) &&
-          !(use_ssrc_filter_ && packet->header().ssrc != ssrc_)) {
-        ++rtp_packet_index_;
-        return packet;
-      }
-    }
-  }
-  return nullptr;
+  std::unique_ptr<Packet> packet = std::move(rtp_packets_[rtp_packet_index_++]);
+  return packet;
 }
 
 int64_t RtcEventLogSource::NextAudioOutputEventMs() {
-  while (audio_output_index_ < parsed_stream_.GetNumberOfEvents()) {
-    if (parsed_stream_.GetEventType(audio_output_index_) ==
-        ParsedRtcEventLogNew::EventType::AUDIO_PLAYOUT_EVENT) {
-      LoggedAudioPlayoutEvent playout_event =
-          parsed_stream_.GetAudioPlayout(audio_output_index_);
-      if (!(use_ssrc_filter_ && playout_event.ssrc != ssrc_)) {
-        audio_output_index_++;
-        return playout_event.timestamp_us / 1000;
-      }
-    }
-    audio_output_index_++;
-  }
-  return std::numeric_limits<int64_t>::max();
+  if (audio_output_index_ >= audio_outputs_.size())
+    return std::numeric_limits<int64_t>::max();
+
+  int64_t output_time_ms = audio_outputs_[audio_output_index_++];
+  return output_time_ms;
 }
 
-RtcEventLogSource::RtcEventLogSource()
-    : PacketSource(), parser_(RtpHeaderParser::Create()) {}
+RtcEventLogSource::RtcEventLogSource() : PacketSource() {}
 
-bool RtcEventLogSource::OpenFile(const std::string& file_name) {
-  return parsed_stream_.ParseFile(file_name);
+bool RtcEventLogSource::OpenFile(const std::string& file_name,
+                                 absl::optional<uint32_t> ssrc_filter) {
+  ParsedRtcEventLogNew parsed_log;
+  if (!parsed_log.ParseFile(file_name))
+    return false;
+
+  const auto first_log_end_time_us =
+      parsed_log.stop_log_events().empty()
+          ? std::numeric_limits<int64_t>::max()
+          : parsed_log.stop_log_events().front().log_time_us();
+
+  auto handle_rtp_packet =
+      [this,
+       first_log_end_time_us](const webrtc::LoggedRtpPacketIncoming& incoming) {
+        if (!filter_.test(incoming.rtp.header.payloadType) &&
+            incoming.log_time_us() < first_log_end_time_us) {
+          rtp_packets_.emplace_back(absl::make_unique<Packet>(
+              incoming.rtp.header, incoming.rtp.total_length,
+              incoming.rtp.total_length - incoming.rtp.header_length,
+              static_cast<double>(incoming.log_time_ms())));
+        }
+      };
+
+  auto handle_audio_playout =
+      [this, first_log_end_time_us](
+          const webrtc::LoggedAudioPlayoutEvent& audio_playout) {
+        if (audio_playout.log_time_us() < first_log_end_time_us) {
+          audio_outputs_.emplace_back(audio_playout.log_time_ms());
+        }
+      };
+
+  // This wouldn't be needed if we knew that there was at most one audio stream.
+  webrtc::RtcEventProcessor event_processor;
+  for (const auto& rtp_packets : parsed_log.incoming_rtp_packets_by_ssrc()) {
+    ParsedRtcEventLogNew::MediaType media_type =
+        parsed_log.GetMediaType(rtp_packets.ssrc, webrtc::kIncomingPacket);
+    if (ShouldSkipStream(media_type, rtp_packets.ssrc, ssrc_filter)) {
+      continue;
+    }
+    auto rtp_view = absl::make_unique<
+        webrtc::ProcessableEventList<webrtc::LoggedRtpPacketIncoming>>(
+        rtp_packets.incoming_packets.begin(),
+        rtp_packets.incoming_packets.end(), handle_rtp_packet);
+    event_processor.AddEvents(std::move(rtp_view));
+  }
+
+  for (const auto& audio_playouts : parsed_log.audio_playout_events()) {
+    if (ssrc_filter.has_value() && audio_playouts.first != *ssrc_filter)
+      continue;
+    auto audio_view = absl::make_unique<
+        webrtc::ProcessableEventList<webrtc::LoggedAudioPlayoutEvent>>(
+        audio_playouts.second.begin(), audio_playouts.second.end(),
+        handle_audio_playout);
+    event_processor.AddEvents(std::move(audio_view));
+  }
+
+  // Fills in rtp_packets_ and audio_outputs_.
+  event_processor.ProcessEventsInOrder();
+
+  return true;
 }
 
 }  // namespace test
diff --git a/modules/audio_coding/neteq/tools/rtc_event_log_source.h b/modules/audio_coding/neteq/tools/rtc_event_log_source.h
index db4eb19..6b761f7 100644
--- a/modules/audio_coding/neteq/tools/rtc_event_log_source.h
+++ b/modules/audio_coding/neteq/tools/rtc_event_log_source.h
@@ -13,7 +13,9 @@
 
 #include <memory>
 #include <string>
+#include <vector>
 
+#include "absl/types/optional.h"
 #include "logging/rtc_event_log/rtc_event_log_parser_new.h"
 #include "modules/audio_coding/neteq/tools/packet_source.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
@@ -31,13 +33,11 @@
  public:
   // Creates an RtcEventLogSource reading from |file_name|. If the file cannot
   // be opened, or has the wrong format, NULL will be returned.
-  static RtcEventLogSource* Create(const std::string& file_name);
+  static RtcEventLogSource* Create(const std::string& file_name,
+                                   absl::optional<uint32_t> ssrc_filter);
 
   virtual ~RtcEventLogSource();
 
-  // Registers an RTP header extension and binds it to |id|.
-  virtual bool RegisterRtpHeaderExtension(RTPExtensionType type, uint8_t id);
-
   std::unique_ptr<Packet> NextPacket() override;
 
   // Returns the timestamp of the next audio output event, in milliseconds. The
@@ -48,14 +48,14 @@
  private:
   RtcEventLogSource();
 
-  bool OpenFile(const std::string& file_name);
+  bool OpenFile(const std::string& file_name,
+                absl::optional<uint32_t> ssrc_filter);
 
+  std::vector<std::unique_ptr<Packet>> rtp_packets_;
   size_t rtp_packet_index_ = 0;
+  std::vector<int64_t> audio_outputs_;
   size_t audio_output_index_ = 0;
 
-  ParsedRtcEventLogNew parsed_stream_;
-  std::unique_ptr<RtpHeaderParser> parser_;
-
   RTC_DISALLOW_COPY_AND_ASSIGN(RtcEventLogSource);
 };
 
diff --git a/modules/audio_coding/neteq/tools/rtp_analyze.cc b/modules/audio_coding/neteq/tools/rtp_analyze.cc
index f939038..9d3041e 100644
--- a/modules/audio_coding/neteq/tools/rtp_analyze.cc
+++ b/modules/audio_coding/neteq/tools/rtp_analyze.cc
@@ -19,16 +19,16 @@
 #include "rtc_base/flags.h"
 
 // Define command line flags.
-DEFINE_int(red, 117, "RTP payload type for RED");
-DEFINE_int(audio_level,
-           -1,
-           "Extension ID for audio level (RFC 6464); "
-           "-1 not to print audio level");
-DEFINE_int(abs_send_time,
-           -1,
-           "Extension ID for absolute sender time; "
-           "-1 not to print absolute send time");
-DEFINE_bool(help, false, "Print this message");
+WEBRTC_DEFINE_int(red, 117, "RTP payload type for RED");
+WEBRTC_DEFINE_int(audio_level,
+                  -1,
+                  "Extension ID for audio level (RFC 6464); "
+                  "-1 not to print audio level");
+WEBRTC_DEFINE_int(abs_send_time,
+                  -1,
+                  "Extension ID for absolute sender time; "
+                  "-1 not to print absolute send time");
+WEBRTC_DEFINE_bool(help, false, "Print this message");
 
 int main(int argc, char* argv[]) {
   std::string program_name = argv[0];
diff --git a/modules/audio_coding/neteq/tools/rtp_encode.cc b/modules/audio_coding/neteq/tools/rtp_encode.cc
index 5065ca1..14c6e58 100644
--- a/modules/audio_coding/neteq/tools/rtp_encode.cc
+++ b/modules/audio_coding/neteq/tools/rtp_encode.cc
@@ -40,20 +40,24 @@
 namespace {
 
 // Define command line flags.
-DEFINE_bool(list_codecs, false, "Enumerate all codecs");
-DEFINE_string(codec, "opus", "Codec to use");
-DEFINE_int(frame_len, 0, "Frame length in ms; 0 indicates codec default value");
-DEFINE_int(bitrate, 0, "Bitrate in kbps; 0 indicates codec default value");
-DEFINE_int(payload_type,
-           -1,
-           "RTP payload type; -1 indicates codec default value");
-DEFINE_int(cng_payload_type,
-           -1,
-           "RTP payload type for CNG; -1 indicates default value");
-DEFINE_int(ssrc, 0, "SSRC to write to the RTP header");
-DEFINE_bool(dtx, false, "Use DTX/CNG");
-DEFINE_int(sample_rate, 48000, "Sample rate of the input file");
-DEFINE_bool(help, false, "Print this message");
+WEBRTC_DEFINE_bool(list_codecs, false, "Enumerate all codecs");
+WEBRTC_DEFINE_string(codec, "opus", "Codec to use");
+WEBRTC_DEFINE_int(frame_len,
+                  0,
+                  "Frame length in ms; 0 indicates codec default value");
+WEBRTC_DEFINE_int(bitrate,
+                  0,
+                  "Bitrate in kbps; 0 indicates codec default value");
+WEBRTC_DEFINE_int(payload_type,
+                  -1,
+                  "RTP payload type; -1 indicates codec default value");
+WEBRTC_DEFINE_int(cng_payload_type,
+                  -1,
+                  "RTP payload type for CNG; -1 indicates default value");
+WEBRTC_DEFINE_int(ssrc, 0, "SSRC to write to the RTP header");
+WEBRTC_DEFINE_bool(dtx, false, "Use DTX/CNG");
+WEBRTC_DEFINE_int(sample_rate, 48000, "Sample rate of the input file");
+WEBRTC_DEFINE_bool(help, false, "Print this message");
 
 // Add new codecs here, and to the map below.
 enum class CodecType {
@@ -242,8 +246,8 @@
   return nullptr;
 }
 
-AudioEncoderCng::Config GetCngConfig(int sample_rate_hz) {
-  AudioEncoderCng::Config cng_config;
+AudioEncoderCngConfig GetCngConfig(int sample_rate_hz) {
+  AudioEncoderCngConfig cng_config;
   const auto default_payload_type = [&] {
     switch (sample_rate_hz) {
       case 8000:
@@ -309,10 +313,10 @@
 
   // Create an external VAD/CNG encoder if needed.
   if (FLAG_dtx && !codec_it->second.internal_dtx) {
-    AudioEncoderCng::Config cng_config = GetCngConfig(codec->SampleRateHz());
+    AudioEncoderCngConfig cng_config = GetCngConfig(codec->SampleRateHz());
     RTC_DCHECK(codec);
     cng_config.speech_encoder = std::move(codec);
-    codec = absl::make_unique<AudioEncoderCng>(std::move(cng_config));
+    codec = CreateComfortNoiseEncoder(std::move(cng_config));
   }
   RTC_DCHECK(codec);
 
diff --git a/modules/audio_coding/neteq/tools/rtp_file_source.cc b/modules/audio_coding/neteq/tools/rtp_file_source.cc
index 806bba7..eda2b3e 100644
--- a/modules/audio_coding/neteq/tools/rtp_file_source.cc
+++ b/modules/audio_coding/neteq/tools/rtp_file_source.cc
@@ -26,8 +26,9 @@
 namespace webrtc {
 namespace test {
 
-RtpFileSource* RtpFileSource::Create(const std::string& file_name) {
-  RtpFileSource* source = new RtpFileSource();
+RtpFileSource* RtpFileSource::Create(const std::string& file_name,
+                                     absl::optional<uint32_t> ssrc_filter) {
+  RtpFileSource* source = new RtpFileSource(ssrc_filter);
   RTC_CHECK(source->OpenFile(file_name));
   return source;
 }
@@ -72,7 +73,7 @@
       continue;
     }
     if (filter_.test(packet->header().payloadType) ||
-        (use_ssrc_filter_ && packet->header().ssrc != ssrc_)) {
+        (ssrc_filter_ && packet->header().ssrc != *ssrc_filter_)) {
       // This payload type should be filtered out. Continue to the next packet.
       continue;
     }
@@ -80,8 +81,10 @@
   }
 }
 
-RtpFileSource::RtpFileSource()
-    : PacketSource(), parser_(RtpHeaderParser::Create()) {}
+RtpFileSource::RtpFileSource(absl::optional<uint32_t> ssrc_filter)
+    : PacketSource(),
+      parser_(RtpHeaderParser::Create()),
+      ssrc_filter_(ssrc_filter) {}
 
 bool RtpFileSource::OpenFile(const std::string& file_name) {
   rtp_reader_.reset(RtpFileReader::Create(RtpFileReader::kRtpDump, file_name));
diff --git a/modules/audio_coding/neteq/tools/rtp_file_source.h b/modules/audio_coding/neteq/tools/rtp_file_source.h
index 013333b..02ab897 100644
--- a/modules/audio_coding/neteq/tools/rtp_file_source.h
+++ b/modules/audio_coding/neteq/tools/rtp_file_source.h
@@ -16,6 +16,7 @@
 #include <memory>
 #include <string>
 
+#include "absl/types/optional.h"
 #include "common_types.h"  // NOLINT(build/include)
 #include "modules/audio_coding/neteq/tools/packet_source.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
@@ -33,7 +34,9 @@
  public:
   // Creates an RtpFileSource reading from |file_name|. If the file cannot be
   // opened, or has the wrong format, NULL will be returned.
-  static RtpFileSource* Create(const std::string& file_name);
+  static RtpFileSource* Create(
+      const std::string& file_name,
+      absl::optional<uint32_t> ssrc_filter = absl::nullopt);
 
   // Checks whether a files is a valid RTP dump or PCAP (Wireshark) file.
   static bool ValidRtpDump(const std::string& file_name);
@@ -51,12 +54,13 @@
   static const int kRtpFileHeaderSize = 4 + 4 + 4 + 2 + 2;
   static const size_t kPacketHeaderSize = 8;
 
-  RtpFileSource();
+  explicit RtpFileSource(absl::optional<uint32_t> ssrc_filter);
 
   bool OpenFile(const std::string& file_name);
 
   std::unique_ptr<RtpFileReader> rtp_reader_;
   std::unique_ptr<RtpHeaderParser> parser_;
+  const absl::optional<uint32_t> ssrc_filter_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(RtpFileSource);
 };
diff --git a/modules/audio_coding/neteq/tools/rtp_jitter.cc b/modules/audio_coding/neteq/tools/rtp_jitter.cc
index 3c49443..92a7a8d 100644
--- a/modules/audio_coding/neteq/tools/rtp_jitter.cc
+++ b/modules/audio_coding/neteq/tools/rtp_jitter.cc
@@ -23,7 +23,7 @@
 namespace test {
 namespace {
 
-DEFINE_bool(help, false, "Print help message");
+WEBRTC_DEFINE_bool(help, false, "Print help message");
 
 constexpr size_t kRtpDumpHeaderLength = 8;
 
diff --git a/modules/audio_processing/BUILD.gn b/modules/audio_processing/BUILD.gn
index dd1569e..a244c84 100644
--- a/modules/audio_processing/BUILD.gn
+++ b/modules/audio_processing/BUILD.gn
@@ -26,6 +26,41 @@
   }
 }
 
+rtc_static_library("config") {
+  visibility = [ ":*" ]
+  sources = [
+    "include/config.cc",
+    "include/config.h",
+  ]
+  deps = [
+    "../../rtc_base:macromagic",
+    "../../rtc_base/system:rtc_export",
+  ]
+}
+
+rtc_source_set("api") {
+  visibility = [ "*" ]
+  sources = [
+    "include/audio_processing.cc",
+    "include/audio_processing.h",
+  ]
+  deps = [
+    ":audio_frame_view",
+    ":audio_generator_interface",
+    ":audio_processing_statistics",
+    ":config",
+    ":gain_control_interface",
+    "../../api/audio:aec3_config",
+    "../../api/audio:echo_control",
+    "../../rtc_base:deprecation",
+    "../../rtc_base:macromagic",
+    "../../rtc_base:ptr_util",
+    "../../rtc_base:rtc_base_approved",
+    "../../rtc_base/system:rtc_export",
+    "//third_party/abseil-cpp/absl/types:optional",
+  ]
+}
+
 rtc_static_library("audio_processing") {
   visibility = [ "*" ]
   configs += [ ":apm_debug_dump" ]
@@ -55,10 +90,6 @@
     "gain_controller2.h",
     "include/aec_dump.cc",
     "include/aec_dump.h",
-    "include/audio_processing.cc",
-    "include/audio_processing.h",
-    "include/config.cc",
-    "include/config.h",
     "level_estimator_impl.cc",
     "level_estimator_impl.h",
     "low_cut_filter.cc",
@@ -95,11 +126,13 @@
 
   defines = []
   deps = [
+    ":api",
     ":apm_logging",
     ":audio_frame_view",
     ":audio_generator_interface",
     ":audio_processing_c",
     ":audio_processing_statistics",
+    ":config",
     ":gain_control_interface",
     "../..:webrtc_common",
     "../../api:array_view",
@@ -309,6 +342,7 @@
       "include/mock_audio_processing.h",
     ]
     deps = [
+      ":api",
       ":audio_processing",
       ":audio_processing_statistics",
       "../../test:test_support",
@@ -360,10 +394,12 @@
 
     deps = [
       ":analog_mic_simulation",
+      ":api",
       ":apm_logging",
       ":audio_frame_view",
       ":audio_processing",
       ":audioproc_test_utils",
+      ":config",
       ":file_audio_generator_unittests",
       ":mocks",
       "../..:webrtc_common",
@@ -393,6 +429,7 @@
       "agc2:biquad_filter_unittests",
       "agc2:fixed_digital_unittests",
       "agc2:noise_estimator_unittests",
+      "agc2:test_utils",
       "agc2/rnn_vad:unittests",
       "test/conversational_speech:unittest",
       "utility:block_mean_calculator_unittest",
@@ -484,6 +521,7 @@
     ]
 
     deps = [
+      ":api",
       ":audio_generator_factory",
       ":audio_processing",
       ":file_audio_generator",
@@ -514,6 +552,7 @@
   if (rtc_enable_protobuf) {
     rtc_source_set("audioproc_f_impl") {
       testonly = true
+      configs += [ ":apm_debug_dump" ]
       sources = [
         "test/aec_dump_based_simulator.cc",
         "test/aec_dump_based_simulator.h",
@@ -527,6 +566,8 @@
 
       deps = [
         ":analog_mic_simulation",
+        ":api",
+        ":apm_logging",
         ":audio_processing",
         ":audioproc_debug_proto",
         ":audioproc_protobuf_utils",
@@ -556,6 +597,7 @@
         "test/audioproc_float_main.cc",
       ]
       deps = [
+        ":api",
         ":audio_processing",
         "../../api:audioproc_f_api",
         "../../rtc_base:rtc_base_approved",
@@ -581,6 +623,7 @@
     ]
 
     deps = [
+      ":api",
       ":audio_processing",
       "../../api:array_view",
       "../../api/audio:audio_frame_api",
@@ -665,6 +708,7 @@
       ]
 
       deps = [
+        ":api",
         ":audio_processing",
         ":audioproc_debug_proto",
         ":audioproc_protobuf_utils",
diff --git a/modules/audio_processing/aec/aec_core.cc b/modules/audio_processing/aec/aec_core.cc
index 5a8cf8f..62b8ad0 100644
--- a/modules/audio_processing/aec/aec_core.cc
+++ b/modules/audio_processing/aec/aec_core.cc
@@ -21,6 +21,7 @@
 #include <algorithm>
 
 #include "rtc_base/checks.h"
+
 extern "C" {
 #include "common_audio/ring_buffer.h"
 }
@@ -29,7 +30,6 @@
 #include "modules/audio_processing/aec/aec_core_optimized_methods.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "modules/audio_processing/utility/delay_estimator_wrapper.h"
-#include "rtc_base/checks.h"
 #include "rtc_base/system/arch.h"
 #include "system_wrappers/include/cpu_features_wrapper.h"
 #include "system_wrappers/include/metrics.h"
diff --git a/modules/audio_processing/aec/aec_resampler.cc b/modules/audio_processing/aec/aec_resampler.cc
index 2851c0b..210c2be 100644
--- a/modules/audio_processing/aec/aec_resampler.cc
+++ b/modules/audio_processing/aec/aec_resampler.cc
@@ -14,7 +14,6 @@
 
 #include "modules/audio_processing/aec/aec_resampler.h"
 
-#include <math.h>
 #include <stdlib.h>
 #include <string.h>
 
diff --git a/modules/audio_processing/aec/aec_resampler.h b/modules/audio_processing/aec/aec_resampler.h
index 130f7ec..a112c43 100644
--- a/modules/audio_processing/aec/aec_resampler.h
+++ b/modules/audio_processing/aec/aec_resampler.h
@@ -11,6 +11,8 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC_AEC_RESAMPLER_H_
 #define MODULES_AUDIO_PROCESSING_AEC_AEC_RESAMPLER_H_
 
+#include <stddef.h>
+
 #include "modules/audio_processing/aec/aec_core.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/aec3/BUILD.gn b/modules/audio_processing/aec3/BUILD.gn
index d1f4595..c3f6dd5 100644
--- a/modules/audio_processing/aec3/BUILD.gn
+++ b/modules/audio_processing/aec3/BUILD.gn
@@ -83,6 +83,8 @@
     "render_delay_controller2.cc",
     "render_delay_controller_metrics.cc",
     "render_delay_controller_metrics.h",
+    "render_reverb_model.cc",
+    "render_reverb_model.h",
     "render_signal_analyzer.cc",
     "render_signal_analyzer.h",
     "residual_echo_estimator.cc",
diff --git a/modules/audio_processing/aec3/adaptive_fir_filter.cc b/modules/audio_processing/aec3/adaptive_fir_filter.cc
index abe68f8..3ab1ebc 100644
--- a/modules/audio_processing/aec3/adaptive_fir_filter.cc
+++ b/modules/audio_processing/aec3/adaptive_fir_filter.cc
@@ -24,7 +24,6 @@
 
 #include "modules/audio_processing/aec3/fft_data.h"
 #include "rtc_base/checks.h"
-#include "rtc_base/logging.h"
 #include "system_wrappers/include/field_trial.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/aec3/adaptive_fir_filter.h b/modules/audio_processing/aec3/adaptive_fir_filter.h
index f9d3f1a..7c832a6 100644
--- a/modules/audio_processing/aec3/adaptive_fir_filter.h
+++ b/modules/audio_processing/aec3/adaptive_fir_filter.h
@@ -11,8 +11,8 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_ADAPTIVE_FIR_FILTER_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_ADAPTIVE_FIR_FILTER_H_
 
+#include <stddef.h>
 #include <array>
-#include <memory>
 #include <vector>
 
 #include "api/array_view.h"
diff --git a/modules/audio_processing/aec3/aec3_common.cc b/modules/audio_processing/aec3/aec3_common.cc
index c374a35..aeb848a 100644
--- a/modules/audio_processing/aec3/aec3_common.cc
+++ b/modules/audio_processing/aec3/aec3_common.cc
@@ -10,10 +10,11 @@
 
 #include "modules/audio_processing/aec3/aec3_common.h"
 
-#include "system_wrappers/include/cpu_features_wrapper.h"
+#include <stdint.h>
 
 #include "rtc_base/checks.h"
 #include "rtc_base/system/arch.h"
+#include "system_wrappers/include/cpu_features_wrapper.h"
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/aec3/aec3_fft.cc b/modules/audio_processing/aec3/aec3_fft.cc
index e29434d..1832101 100644
--- a/modules/audio_processing/aec3/aec3_fft.cc
+++ b/modules/audio_processing/aec3/aec3_fft.cc
@@ -12,6 +12,7 @@
 
 #include <algorithm>
 #include <functional>
+#include <iterator>
 
 #include "rtc_base/checks.h"
 
diff --git a/modules/audio_processing/aec3/aec3_fft.h b/modules/audio_processing/aec3/aec3_fft.h
index b700222..6cd649a 100644
--- a/modules/audio_processing/aec3/aec3_fft.h
+++ b/modules/audio_processing/aec3/aec3_fft.h
@@ -17,6 +17,7 @@
 #include "modules/audio_processing/aec3/aec3_common.h"
 #include "modules/audio_processing/aec3/fft_data.h"
 #include "modules/audio_processing/utility/ooura_fft.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/aec3/aec_state.cc b/modules/audio_processing/aec3/aec_state.cc
index b9cd5ea..0eeb7eb 100644
--- a/modules/audio_processing/aec3/aec_state.cc
+++ b/modules/audio_processing/aec3/aec_state.cc
@@ -11,7 +11,7 @@
 #include "modules/audio_processing/aec3/aec_state.h"
 
 #include <math.h>
-
+#include <algorithm>
 #include <numeric>
 #include <vector>
 
@@ -41,6 +41,10 @@
 bool UseSuppressionGainLimiter() {
   return field_trial::IsEnabled("WebRTC-Aec3GainLimiterDeactivationKillSwitch");
 }
+bool EnableErleUpdatesDuringReverb() {
+  return !field_trial::IsEnabled(
+      "WebRTC-Aec3EnableErleUpdatesDuringReverbKillSwitch");
+}
 
 constexpr size_t kBlocksSinceConvergencedFilterInit = 10000;
 constexpr size_t kBlocksSinceConsistentEstimateInit = 10000;
@@ -64,19 +68,6 @@
 }
 
 absl::optional<float> AecState::ErleUncertainty() const {
-  bool filter_has_had_time_to_converge;
-  if (config_.filter.conservative_initial_phase) {
-    filter_has_had_time_to_converge =
-        strong_not_saturated_render_blocks_ >= 1.5f * kNumBlocksPerSecond;
-  } else {
-    filter_has_had_time_to_converge =
-        strong_not_saturated_render_blocks_ >= 0.8f * kNumBlocksPerSecond;
-  }
-
-  if (!filter_has_had_time_to_converge) {
-    return 1.f;
-  }
-
   if (SaturatedEcho() && use_legacy_saturation_behavior_) {
     return 1.f;
   }
@@ -90,6 +81,7 @@
       config_(config),
       use_legacy_saturation_behavior_(EnableLegacySaturationBehavior()),
       enable_erle_resets_at_gain_changes_(EnableErleResetsAtGainChanges()),
+      enable_erle_updates_during_reverb_(EnableErleUpdatesDuringReverb()),
       use_legacy_filter_quality_(UseLegacyFilterQualityState()),
       use_suppressor_gain_limiter_(UseSuppressionGainLimiter()),
       initial_state_(config_),
@@ -195,22 +187,33 @@
     }
   }
 
+  std::array<float, kFftLengthBy2Plus1> X2_reverb;
+  render_reverb_.Apply(
+      render_buffer.GetSpectrumBuffer(), delay_state_.DirectPathFilterDelay(),
+      config_.ep_strength.reverb_based_on_render ? ReverbDecay() : 0.f,
+      X2_reverb);
+
   if (config_.echo_audibility.use_stationary_properties) {
     // Update the echo audibility evaluator.
-    echo_audibility_.Update(
-        render_buffer, delay_state_.DirectPathFilterDelay(),
-        delay_state_.ExternalDelayReported(),
-        config_.ep_strength.reverb_based_on_render ? ReverbDecay() : 0.f);
+    echo_audibility_.Update(render_buffer,
+                            render_reverb_.GetReverbContributionPowerSpectrum(),
+                            delay_state_.DirectPathFilterDelay(),
+                            delay_state_.ExternalDelayReported());
   }
 
   // Update the ERL and ERLE measures.
   if (initial_state_.TransitionTriggered()) {
     erle_estimator_.Reset(false);
   }
+
   const auto& X2 = render_buffer.Spectrum(delay_state_.DirectPathFilterDelay());
-  erle_estimator_.Update(X2, Y2, E2_main,
+  const auto& X2_input_erle =
+      enable_erle_updates_during_reverb_ ? X2_reverb : X2;
+
+  erle_estimator_.Update(X2_input_erle, Y2, E2_main,
                          subtractor_output_analyzer_.ConvergedFilter(),
                          config_.erle.onset_detection);
+
   erl_estimator_.Update(subtractor_output_analyzer_.ConvergedFilter(), X2, Y2);
 
   // Detect and flag echo saturation.
diff --git a/modules/audio_processing/aec3/aec_state.h b/modules/audio_processing/aec3/aec_state.h
index 9bb8624..c9d9cf3 100644
--- a/modules/audio_processing/aec3/aec_state.h
+++ b/modules/audio_processing/aec3/aec_state.h
@@ -11,9 +11,8 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_AEC_STATE_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_AEC_STATE_H_
 
-#include <math.h>
-
-#include <algorithm>
+#include <stddef.h>
+#include <array>
 #include <memory>
 #include <vector>
 
@@ -28,6 +27,7 @@
 #include "modules/audio_processing/aec3/erle_estimator.h"
 #include "modules/audio_processing/aec3/filter_analyzer.h"
 #include "modules/audio_processing/aec3/render_buffer.h"
+#include "modules/audio_processing/aec3/render_reverb_model.h"
 #include "modules/audio_processing/aec3/reverb_model_estimator.h"
 #include "modules/audio_processing/aec3/subtractor_output.h"
 #include "modules/audio_processing/aec3/subtractor_output_analyzer.h"
@@ -172,6 +172,7 @@
   const EchoCanceller3Config config_;
   const bool use_legacy_saturation_behavior_;
   const bool enable_erle_resets_at_gain_changes_;
+  const bool enable_erle_updates_during_reverb_;
   const bool use_legacy_filter_quality_;
   const bool use_suppressor_gain_limiter_;
 
@@ -383,6 +384,7 @@
   absl::optional<DelayEstimate> external_delay_;
   EchoAudibility echo_audibility_;
   ReverbModelEstimator reverb_model_estimator_;
+  RenderReverbModel render_reverb_;
   SubtractorOutputAnalyzer subtractor_output_analyzer_;
 };
 
diff --git a/modules/audio_processing/aec3/block_delay_buffer.h b/modules/audio_processing/aec3/block_delay_buffer.h
index 6e5fd5c..624e913 100644
--- a/modules/audio_processing/aec3/block_delay_buffer.h
+++ b/modules/audio_processing/aec3/block_delay_buffer.h
@@ -11,6 +11,7 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_BLOCK_DELAY_BUFFER_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_BLOCK_DELAY_BUFFER_H_
 
+#include <stddef.h>
 #include <vector>
 
 #include "modules/audio_processing/audio_buffer.h"
diff --git a/modules/audio_processing/aec3/block_framer.cc b/modules/audio_processing/aec3/block_framer.cc
index 3160624..ca7667c 100644
--- a/modules/audio_processing/aec3/block_framer.cc
+++ b/modules/audio_processing/aec3/block_framer.cc
@@ -12,6 +12,7 @@
 
 #include <algorithm>
 
+#include "modules/audio_processing/aec3/aec3_common.h"
 #include "rtc_base/checks.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/aec3/block_processor.cc b/modules/audio_processing/aec3/block_processor.cc
index 4f4020e..590380f 100644
--- a/modules/audio_processing/aec3/block_processor.cc
+++ b/modules/audio_processing/aec3/block_processor.cc
@@ -9,12 +9,16 @@
  */
 #include "modules/audio_processing/aec3/block_processor.h"
 
+#include <utility>
+
 #include "absl/types/optional.h"
 #include "modules/audio_processing/aec3/aec3_common.h"
 #include "modules/audio_processing/aec3/block_processor_metrics.h"
+#include "modules/audio_processing/aec3/delay_estimate.h"
 #include "modules/audio_processing/aec3/echo_path_variability.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/atomicops.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/logging.h"
 
diff --git a/modules/audio_processing/aec3/block_processor.h b/modules/audio_processing/aec3/block_processor.h
index 8793a03..5f7ec7c 100644
--- a/modules/audio_processing/aec3/block_processor.h
+++ b/modules/audio_processing/aec3/block_processor.h
@@ -11,9 +11,12 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_BLOCK_PROCESSOR_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_BLOCK_PROCESSOR_H_
 
+#include <stddef.h>
 #include <memory>
 #include <vector>
 
+#include "api/audio/echo_canceller3_config.h"
+#include "api/audio/echo_control.h"
 #include "modules/audio_processing/aec3/echo_remover.h"
 #include "modules/audio_processing/aec3/render_delay_buffer.h"
 #include "modules/audio_processing/aec3/render_delay_controller.h"
diff --git a/modules/audio_processing/aec3/block_processor_metrics.cc b/modules/audio_processing/aec3/block_processor_metrics.cc
index c8bdda7..deac1fc 100644
--- a/modules/audio_processing/aec3/block_processor_metrics.cc
+++ b/modules/audio_processing/aec3/block_processor_metrics.cc
@@ -11,6 +11,7 @@
 #include "modules/audio_processing/aec3/block_processor_metrics.h"
 
 #include "modules/audio_processing/aec3/aec3_common.h"
+#include "rtc_base/checks.h"
 #include "system_wrappers/include/metrics.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/aec3/cascaded_biquad_filter.cc b/modules/audio_processing/aec3/cascaded_biquad_filter.cc
index 333d226..5dfd7c5 100644
--- a/modules/audio_processing/aec3/cascaded_biquad_filter.cc
+++ b/modules/audio_processing/aec3/cascaded_biquad_filter.cc
@@ -9,6 +9,8 @@
  */
 #include "modules/audio_processing/aec3/cascaded_biquad_filter.h"
 
+#include <algorithm>
+
 #include "rtc_base/checks.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/aec3/cascaded_biquad_filter.h b/modules/audio_processing/aec3/cascaded_biquad_filter.h
index 1e09fa6..2a3b6d6 100644
--- a/modules/audio_processing/aec3/cascaded_biquad_filter.h
+++ b/modules/audio_processing/aec3/cascaded_biquad_filter.h
@@ -11,6 +11,7 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_CASCADED_BIQUAD_FILTER_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_CASCADED_BIQUAD_FILTER_H_
 
+#include <stddef.h>
 #include <complex>
 #include <vector>
 
diff --git a/modules/audio_processing/aec3/comfort_noise_generator.cc b/modules/audio_processing/aec3/comfort_noise_generator.cc
index a37c67a..766e658 100644
--- a/modules/audio_processing/aec3/comfort_noise_generator.cc
+++ b/modules/audio_processing/aec3/comfort_noise_generator.cc
@@ -16,9 +16,10 @@
 #if defined(WEBRTC_ARCH_X86_FAMILY)
 #include <emmintrin.h>
 #endif
-#include <math.h>
 #include <algorithm>
 #include <array>
+#include <cmath>
+#include <cstdint>
 #include <functional>
 #include <numeric>
 
diff --git a/modules/audio_processing/aec3/comfort_noise_generator.h b/modules/audio_processing/aec3/comfort_noise_generator.h
index 6a47989..3be386b 100644
--- a/modules/audio_processing/aec3/comfort_noise_generator.h
+++ b/modules/audio_processing/aec3/comfort_noise_generator.h
@@ -11,6 +11,7 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_COMFORT_NOISE_GENERATOR_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_COMFORT_NOISE_GENERATOR_H_
 
+#include <stdint.h>
 #include <array>
 #include <memory>
 
diff --git a/modules/audio_processing/aec3/decimator.cc b/modules/audio_processing/aec3/decimator.cc
index d9faa62..bd03237 100644
--- a/modules/audio_processing/aec3/decimator.cc
+++ b/modules/audio_processing/aec3/decimator.cc
@@ -9,6 +9,10 @@
  */
 #include "modules/audio_processing/aec3/decimator.h"
 
+#include <array>
+#include <vector>
+
+#include "modules/audio_processing/aec3/aec3_common.h"
 #include "rtc_base/checks.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/aec3/downsampled_render_buffer.cc b/modules/audio_processing/aec3/downsampled_render_buffer.cc
index df0af6e..c105911 100644
--- a/modules/audio_processing/aec3/downsampled_render_buffer.cc
+++ b/modules/audio_processing/aec3/downsampled_render_buffer.cc
@@ -10,6 +10,8 @@
 
 #include "modules/audio_processing/aec3/downsampled_render_buffer.h"
 
+#include <algorithm>
+
 namespace webrtc {
 
 DownsampledRenderBuffer::DownsampledRenderBuffer(size_t downsampled_buffer_size)
diff --git a/modules/audio_processing/aec3/downsampled_render_buffer.h b/modules/audio_processing/aec3/downsampled_render_buffer.h
index 9439496..c91ea3b 100644
--- a/modules/audio_processing/aec3/downsampled_render_buffer.h
+++ b/modules/audio_processing/aec3/downsampled_render_buffer.h
@@ -11,9 +11,9 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_DOWNSAMPLED_RENDER_BUFFER_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_DOWNSAMPLED_RENDER_BUFFER_H_
 
+#include <stddef.h>
 #include <vector>
 
-#include "modules/audio_processing/aec3/aec3_common.h"
 #include "rtc_base/checks.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/aec3/echo_audibility.cc b/modules/audio_processing/aec3/echo_audibility.cc
index fa123de..e857a7e 100644
--- a/modules/audio_processing/aec3/echo_audibility.cc
+++ b/modules/audio_processing/aec3/echo_audibility.cc
@@ -12,8 +12,10 @@
 
 #include <algorithm>
 #include <cmath>
+#include <utility>
+#include <vector>
 
-#include "modules/audio_processing/aec3/aec3_common.h"
+#include "api/array_view.h"
 #include "modules/audio_processing/aec3/matrix_buffer.h"
 #include "modules/audio_processing/aec3/stationarity_estimator.h"
 #include "modules/audio_processing/aec3/vector_buffer.h"
@@ -27,16 +29,18 @@
 
 EchoAudibility::~EchoAudibility() = default;
 
-void EchoAudibility::Update(const RenderBuffer& render_buffer,
-                            int delay_blocks,
-                            bool external_delay_seen,
-                            float reverb_decay) {
+void EchoAudibility::Update(
+    const RenderBuffer& render_buffer,
+    rtc::ArrayView<const float> render_reverb_contribution_spectrum,
+    int delay_blocks,
+    bool external_delay_seen) {
   UpdateRenderNoiseEstimator(render_buffer.GetSpectrumBuffer(),
                              render_buffer.GetBlockBuffer(),
                              external_delay_seen);
 
   if (external_delay_seen || use_render_stationarity_at_init_) {
-    UpdateRenderStationarityFlags(render_buffer, delay_blocks, reverb_decay);
+    UpdateRenderStationarityFlags(
+        render_buffer, render_reverb_contribution_spectrum, delay_blocks);
   }
 }
 
@@ -48,8 +52,8 @@
 
 void EchoAudibility::UpdateRenderStationarityFlags(
     const RenderBuffer& render_buffer,
-    int delay_blocks,
-    float reverb_decay) {
+    rtc::ArrayView<const float> render_reverb_contribution_spectrum,
+    int delay_blocks) {
   const VectorBuffer& spectrum_buffer = render_buffer.GetSpectrumBuffer();
   int idx_at_delay =
       spectrum_buffer.OffsetIndex(spectrum_buffer.read, delay_blocks);
@@ -57,8 +61,9 @@
   int num_lookahead = render_buffer.Headroom() - delay_blocks + 1;
   num_lookahead = std::max(0, num_lookahead);
 
-  render_stationarity_.UpdateStationarityFlags(spectrum_buffer, idx_at_delay,
-                                               num_lookahead, reverb_decay);
+  render_stationarity_.UpdateStationarityFlags(
+      spectrum_buffer, render_reverb_contribution_spectrum, idx_at_delay,
+      num_lookahead);
 }
 
 void EchoAudibility::UpdateRenderNoiseEstimator(
diff --git a/modules/audio_processing/aec3/echo_audibility.h b/modules/audio_processing/aec3/echo_audibility.h
index 3b252f3..b903ca0 100644
--- a/modules/audio_processing/aec3/echo_audibility.h
+++ b/modules/audio_processing/aec3/echo_audibility.h
@@ -11,11 +11,7 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_ECHO_AUDIBILITY_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_ECHO_AUDIBILITY_H_
 
-#include <algorithm>
-#include <array>
-#include <limits>
-#include <memory>
-#include <vector>
+#include <stddef.h>
 
 #include "absl/types/optional.h"
 #include "api/array_view.h"
@@ -27,8 +23,6 @@
 
 namespace webrtc {
 
-class ApmDataDumper;
-
 class EchoAudibility {
  public:
   explicit EchoAudibility(bool use_render_stationarity_at_init);
@@ -36,9 +30,9 @@
 
   // Feed new render data to the echo audibility estimator.
   void Update(const RenderBuffer& render_buffer,
+              rtc::ArrayView<const float> render_reverb_contribution_spectrum,
               int delay_blocks,
-              bool external_delay_seen,
-              float reverb_decay);
+              bool external_delay_seen);
   // Get the residual echo scaling.
   void GetResidualEchoScaling(bool filter_has_had_time_to_converge,
                               rtc::ArrayView<float> residual_scaling) const {
@@ -62,9 +56,10 @@
   void Reset();
 
   // Updates the render stationarity flags for the current frame.
-  void UpdateRenderStationarityFlags(const RenderBuffer& render_buffer,
-                                     int delay_blocks,
-                                     float reverb_decay);
+  void UpdateRenderStationarityFlags(
+      const RenderBuffer& render_buffer,
+      rtc::ArrayView<const float> render_reverb_contribution_spectrum,
+      int delay_blocks);
 
   // Updates the noise estimator with the new render data since the previous
   // call to this method.
diff --git a/modules/audio_processing/aec3/echo_canceller3.cc b/modules/audio_processing/aec3/echo_canceller3.cc
index 857587a..5debcda 100644
--- a/modules/audio_processing/aec3/echo_canceller3.cc
+++ b/modules/audio_processing/aec3/echo_canceller3.cc
@@ -9,9 +9,12 @@
  */
 #include "modules/audio_processing/aec3/echo_canceller3.h"
 
+#include <algorithm>
+#include <utility>
+
+#include "modules/audio_processing/aec3/aec3_common.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/atomicops.h"
-#include "rtc_base/logging.h"
 #include "system_wrappers/include/field_trial.h"
 
 namespace webrtc {
@@ -41,19 +44,6 @@
   return !field_trial::IsEnabled("WebRTC-Aec3ReverbModellingKillSwitch");
 }
 
-bool EnableSuppressorNearendAveraging() {
-  return !field_trial::IsEnabled(
-      "WebRTC-Aec3SuppressorNearendAveragingKillSwitch");
-}
-
-bool EnableSlowFilterAdaptation() {
-  return !field_trial::IsEnabled("WebRTC-Aec3SlowFilterAdaptationKillSwitch");
-}
-
-bool EnableShadowFilterJumpstart() {
-  return !field_trial::IsEnabled("WebRTC-Aec3ShadowFilterJumpstartKillSwitch");
-}
-
 bool EnableUnityInitialRampupGain() {
   return field_trial::IsEnabled("WebRTC-Aec3EnableUnityInitialRampupGain");
 }
@@ -78,22 +68,24 @@
   return field_trial::IsEnabled("WebRTC-Aec3UseLegacyNormalSuppressorTuning");
 }
 
-bool ActivateStationarityProperties() {
-  return field_trial::IsEnabled("WebRTC-Aec3UseStationarityProperties");
+bool DeactivateStationarityProperties() {
+  return field_trial::IsEnabled(
+      "WebRTC-Aec3UseStationarityPropertiesKillSwitch");
 }
 
-bool ActivateStationarityPropertiesAtInit() {
-  return field_trial::IsEnabled("WebRTC-Aec3UseStationarityPropertiesAtInit");
-}
-
-bool UseEarlyDelayDetection() {
-  return !field_trial::IsEnabled("WebRTC-Aec3EarlyDelayDetectionKillSwitch");
+bool DeactivateStationarityPropertiesAtInit() {
+  return field_trial::IsEnabled(
+      "WebRTC-Aec3UseStationarityPropertiesAtInitKillSwitch");
 }
 
 bool EnableNewRenderBuffering() {
   return !field_trial::IsEnabled("WebRTC-Aec3NewRenderBufferingKillSwitch");
 }
 
+bool UseEarlyDelayDetection() {
+  return !field_trial::IsEnabled("WebRTC-Aec3EarlyDelayDetectionKillSwitch");
+}
+
 // Method for adjusting config parameter dependencies..
 EchoCanceller3Config AdjustConfig(const EchoCanceller3Config& config) {
   EchoCanceller3Config adjusted_cfg = config;
@@ -119,30 +111,6 @@
     adjusted_cfg.ep_strength.reverb_based_on_render = false;
   }
 
-  if (!EnableSuppressorNearendAveraging()) {
-    adjusted_cfg.suppressor.nearend_average_blocks = 1;
-  }
-
-  if (!EnableSlowFilterAdaptation()) {
-    if (!EnableShadowFilterJumpstart()) {
-      adjusted_cfg.filter.main.leakage_converged = 0.005f;
-      adjusted_cfg.filter.main.leakage_diverged = 0.1f;
-    }
-    adjusted_cfg.filter.main_initial.leakage_converged = 0.05f;
-    adjusted_cfg.filter.main_initial.leakage_diverged = 5.f;
-  }
-
-  if (!EnableShadowFilterJumpstart()) {
-    if (EnableSlowFilterAdaptation()) {
-      adjusted_cfg.filter.main.leakage_converged = 0.0005f;
-      adjusted_cfg.filter.main.leakage_diverged = 0.01f;
-    } else {
-      adjusted_cfg.filter.main.leakage_converged = 0.005f;
-      adjusted_cfg.filter.main.leakage_diverged = 0.1f;
-    }
-    adjusted_cfg.filter.main.error_floor = 0.001f;
-  }
-
   if (!EnableNewFilterParams()) {
     adjusted_cfg.filter.main.leakage_diverged = 0.01f;
     adjusted_cfg.filter.main.error_floor = 0.1f;
@@ -186,12 +154,15 @@
     adjusted_cfg.suppressor.dominant_nearend_detection.hold_duration = 25;
   }
 
-  if (ActivateStationarityProperties()) {
-    adjusted_cfg.echo_audibility.use_stationary_properties = true;
+  // TODO(peah): Clean this up once upstream dependencies that forces this to
+  // zero are resolved.
+  adjusted_cfg.echo_audibility.use_stationary_properties = true;
+  if (DeactivateStationarityProperties()) {
+    adjusted_cfg.echo_audibility.use_stationary_properties = false;
   }
 
-  if (ActivateStationarityPropertiesAtInit()) {
-    adjusted_cfg.echo_audibility.use_stationarity_properties_at_init = true;
+  if (DeactivateStationarityPropertiesAtInit()) {
+    adjusted_cfg.echo_audibility.use_stationarity_properties_at_init = false;
   }
 
   if (!UseEarlyDelayDetection()) {
diff --git a/modules/audio_processing/aec3/echo_canceller3.h b/modules/audio_processing/aec3/echo_canceller3.h
index f5520ba..0d07702 100644
--- a/modules/audio_processing/aec3/echo_canceller3.h
+++ b/modules/audio_processing/aec3/echo_canceller3.h
@@ -11,7 +11,13 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_ECHO_CANCELLER3_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_ECHO_CANCELLER3_H_
 
+#include <stddef.h>
+#include <memory>
+#include <vector>
+
+#include "api/array_view.h"
 #include "api/audio/echo_canceller3_config.h"
+#include "api/audio/echo_control.h"
 #include "modules/audio_processing/aec3/block_delay_buffer.h"
 #include "modules/audio_processing/aec3/block_framer.h"
 #include "modules/audio_processing/aec3/block_processor.h"
@@ -19,9 +25,11 @@
 #include "modules/audio_processing/aec3/frame_blocker.h"
 #include "modules/audio_processing/audio_buffer.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/race_checker.h"
 #include "rtc_base/swap_queue.h"
+#include "rtc_base/thread_annotations.h"
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/aec3/echo_path_delay_estimator.cc b/modules/audio_processing/aec3/echo_path_delay_estimator.cc
index 891f15e..5c838ae 100644
--- a/modules/audio_processing/aec3/echo_path_delay_estimator.cc
+++ b/modules/audio_processing/aec3/echo_path_delay_estimator.cc
@@ -9,31 +9,21 @@
  */
 #include "modules/audio_processing/aec3/echo_path_delay_estimator.h"
 
-#include <algorithm>
 #include <array>
 
 #include "api/audio/echo_canceller3_config.h"
 #include "modules/audio_processing/aec3/aec3_common.h"
+#include "modules/audio_processing/aec3/downsampled_render_buffer.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/checks.h"
-#include "system_wrappers/include/field_trial.h"
 
 namespace webrtc {
-namespace {
-size_t GetDownSamplingFactor(const EchoCanceller3Config& config) {
-  // Do not use down sampling factor 8 if kill switch is triggered.
-  return (config.delay.down_sampling_factor == 8 &&
-          field_trial::IsEnabled("WebRTC-Aec3DownSamplingFactor8KillSwitch"))
-             ? 4
-             : config.delay.down_sampling_factor;
-}
-}  // namespace
 
 EchoPathDelayEstimator::EchoPathDelayEstimator(
     ApmDataDumper* data_dumper,
     const EchoCanceller3Config& config)
     : data_dumper_(data_dumper),
-      down_sampling_factor_(GetDownSamplingFactor(config)),
+      down_sampling_factor_(config.delay.down_sampling_factor),
       sub_block_size_(down_sampling_factor_ != 0
                           ? kBlockSize / down_sampling_factor_
                           : kBlockSize),
@@ -45,7 +35,7 @@
           kMatchedFilterWindowSizeSubBlocks,
           config.delay.num_filters,
           kMatchedFilterAlignmentShiftSizeSubBlocks,
-          GetDownSamplingFactor(config) == 8
+          config.delay.down_sampling_factor == 8
               ? config.render_levels.poor_excitation_render_limit_ds8
               : config.render_levels.poor_excitation_render_limit,
           config.delay.delay_estimate_smoothing,
diff --git a/modules/audio_processing/aec3/echo_path_delay_estimator.h b/modules/audio_processing/aec3/echo_path_delay_estimator.h
index 55d82be..060c875 100644
--- a/modules/audio_processing/aec3/echo_path_delay_estimator.h
+++ b/modules/audio_processing/aec3/echo_path_delay_estimator.h
@@ -11,13 +11,12 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_ECHO_PATH_DELAY_ESTIMATOR_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_ECHO_PATH_DELAY_ESTIMATOR_H_
 
-#include <vector>
+#include <stddef.h>
 
 #include "absl/types/optional.h"
-#include "api/audio/echo_canceller3_config.h"
+#include "api/array_view.h"
 #include "modules/audio_processing/aec3/decimator.h"
 #include "modules/audio_processing/aec3/delay_estimate.h"
-#include "modules/audio_processing/aec3/downsampled_render_buffer.h"
 #include "modules/audio_processing/aec3/matched_filter.h"
 #include "modules/audio_processing/aec3/matched_filter_lag_aggregator.h"
 #include "rtc_base/constructormagic.h"
@@ -25,6 +24,8 @@
 namespace webrtc {
 
 class ApmDataDumper;
+struct DownsampledRenderBuffer;
+struct EchoCanceller3Config;
 
 // Estimates the delay of the echo path.
 class EchoPathDelayEstimator {
diff --git a/modules/audio_processing/aec3/echo_remover.cc b/modules/audio_processing/aec3/echo_remover.cc
index 063c476..cfb7395 100644
--- a/modules/audio_processing/aec3/echo_remover.cc
+++ b/modules/audio_processing/aec3/echo_remover.cc
@@ -10,26 +10,29 @@
 #include "modules/audio_processing/aec3/echo_remover.h"
 
 #include <math.h>
+#include <stddef.h>
 #include <algorithm>
+#include <array>
 #include <memory>
-#include <numeric>
-#include <string>
 
 #include "api/array_view.h"
 #include "modules/audio_processing/aec3/aec3_common.h"
+#include "modules/audio_processing/aec3/aec3_fft.h"
 #include "modules/audio_processing/aec3/aec_state.h"
 #include "modules/audio_processing/aec3/comfort_noise_generator.h"
 #include "modules/audio_processing/aec3/echo_path_variability.h"
 #include "modules/audio_processing/aec3/echo_remover_metrics.h"
 #include "modules/audio_processing/aec3/fft_data.h"
 #include "modules/audio_processing/aec3/render_buffer.h"
-#include "modules/audio_processing/aec3/render_delay_buffer.h"
+#include "modules/audio_processing/aec3/render_signal_analyzer.h"
 #include "modules/audio_processing/aec3/residual_echo_estimator.h"
 #include "modules/audio_processing/aec3/subtractor.h"
+#include "modules/audio_processing/aec3/subtractor_output.h"
 #include "modules/audio_processing/aec3/suppression_filter.h"
 #include "modules/audio_processing/aec3/suppression_gain.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/atomicops.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/logging.h"
 #include "system_wrappers/include/field_trial.h"
diff --git a/modules/audio_processing/aec3/echo_remover_metrics.cc b/modules/audio_processing/aec3/echo_remover_metrics.cc
index a04026b..da7a224 100644
--- a/modules/audio_processing/aec3/echo_remover_metrics.cc
+++ b/modules/audio_processing/aec3/echo_remover_metrics.cc
@@ -11,9 +11,11 @@
 #include "modules/audio_processing/aec3/echo_remover_metrics.h"
 
 #include <math.h>
+#include <stddef.h>
 #include <algorithm>
 #include <numeric>
 
+#include "rtc_base/checks.h"
 #include "rtc_base/numerics/safe_minmax.h"
 #include "system_wrappers/include/metrics.h"
 
diff --git a/modules/audio_processing/aec3/echo_remover_metrics.h b/modules/audio_processing/aec3/echo_remover_metrics.h
index 17b803a..0707a5f 100644
--- a/modules/audio_processing/aec3/echo_remover_metrics.h
+++ b/modules/audio_processing/aec3/echo_remover_metrics.h
@@ -11,6 +11,9 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_ECHO_REMOVER_METRICS_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_ECHO_REMOVER_METRICS_H_
 
+#include <array>
+
+#include "modules/audio_processing/aec3/aec3_common.h"
 #include "modules/audio_processing/aec3/aec_state.h"
 #include "rtc_base/constructormagic.h"
 
diff --git a/modules/audio_processing/aec3/erl_estimator.cc b/modules/audio_processing/aec3/erl_estimator.cc
index 2da9cd8..85b1e02 100644
--- a/modules/audio_processing/aec3/erl_estimator.cc
+++ b/modules/audio_processing/aec3/erl_estimator.cc
@@ -13,6 +13,8 @@
 #include <algorithm>
 #include <numeric>
 
+#include "rtc_base/checks.h"
+
 namespace webrtc {
 
 namespace {
diff --git a/modules/audio_processing/aec3/erl_estimator.h b/modules/audio_processing/aec3/erl_estimator.h
index dacd546..29718c3 100644
--- a/modules/audio_processing/aec3/erl_estimator.h
+++ b/modules/audio_processing/aec3/erl_estimator.h
@@ -11,6 +11,7 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_ERL_ESTIMATOR_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_ERL_ESTIMATOR_H_
 
+#include <stddef.h>
 #include <array>
 
 #include "api/array_view.h"
diff --git a/modules/audio_processing/aec3/erle_estimator.cc b/modules/audio_processing/aec3/erle_estimator.cc
index 711085f..539a59b 100644
--- a/modules/audio_processing/aec3/erle_estimator.cc
+++ b/modules/audio_processing/aec3/erle_estimator.cc
@@ -13,6 +13,7 @@
 #include "api/array_view.h"
 #include "modules/audio_processing/aec3/aec3_common.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
+#include "rtc_base/checks.h"
 
 namespace webrtc {
 
@@ -36,15 +37,15 @@
   }
 }
 
-void ErleEstimator::Update(rtc::ArrayView<const float> render_spectrum,
+void ErleEstimator::Update(rtc::ArrayView<const float> reverb_render_spectrum,
                            rtc::ArrayView<const float> capture_spectrum,
                            rtc::ArrayView<const float> subtractor_spectrum,
                            bool converged_filter,
                            bool onset_detection) {
-  RTC_DCHECK_EQ(kFftLengthBy2Plus1, render_spectrum.size());
+  RTC_DCHECK_EQ(kFftLengthBy2Plus1, reverb_render_spectrum.size());
   RTC_DCHECK_EQ(kFftLengthBy2Plus1, capture_spectrum.size());
   RTC_DCHECK_EQ(kFftLengthBy2Plus1, subtractor_spectrum.size());
-  const auto& X2 = render_spectrum;
+  const auto& X2_reverb = reverb_render_spectrum;
   const auto& Y2 = capture_spectrum;
   const auto& E2 = subtractor_spectrum;
 
@@ -52,8 +53,9 @@
     return;
   }
 
-  subband_erle_estimator_.Update(X2, Y2, E2, converged_filter, onset_detection);
-  fullband_erle_estimator_.Update(X2, Y2, E2, converged_filter);
+  subband_erle_estimator_.Update(X2_reverb, Y2, E2, converged_filter,
+                                 onset_detection);
+  fullband_erle_estimator_.Update(X2_reverb, Y2, E2, converged_filter);
 }
 
 void ErleEstimator::Dump(
diff --git a/modules/audio_processing/aec3/erle_estimator.h b/modules/audio_processing/aec3/erle_estimator.h
index 8ca605f..2d2c3ae 100644
--- a/modules/audio_processing/aec3/erle_estimator.h
+++ b/modules/audio_processing/aec3/erle_estimator.h
@@ -11,6 +11,7 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_ERLE_ESTIMATOR_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_ERLE_ESTIMATOR_H_
 
+#include <stddef.h>
 #include <array>
 #include <memory>
 
@@ -37,7 +38,7 @@
   void Reset(bool delay_change);
 
   // Updates the ERLE estimates.
-  void Update(rtc::ArrayView<const float> render_spectrum,
+  void Update(rtc::ArrayView<const float> reverb_render_spectrum,
               rtc::ArrayView<const float> capture_spectrum,
               rtc::ArrayView<const float> subtractor_spectrum,
               bool converged_filter,
diff --git a/modules/audio_processing/aec3/fft_buffer.h b/modules/audio_processing/aec3/fft_buffer.h
index 47ede41..9f81a91 100644
--- a/modules/audio_processing/aec3/fft_buffer.h
+++ b/modules/audio_processing/aec3/fft_buffer.h
@@ -11,6 +11,7 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_FFT_BUFFER_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_FFT_BUFFER_H_
 
+#include <stddef.h>
 #include <vector>
 
 #include "modules/audio_processing/aec3/fft_data.h"
diff --git a/modules/audio_processing/aec3/filter_analyzer.cc b/modules/audio_processing/aec3/filter_analyzer.cc
index 790cb1e..5b890d7 100644
--- a/modules/audio_processing/aec3/filter_analyzer.cc
+++ b/modules/audio_processing/aec3/filter_analyzer.cc
@@ -16,6 +16,7 @@
 #include <numeric>
 
 #include "modules/audio_processing/aec3/aec3_common.h"
+#include "modules/audio_processing/aec3/render_buffer.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/atomicops.h"
 #include "rtc_base/checks.h"
diff --git a/modules/audio_processing/aec3/filter_analyzer.h b/modules/audio_processing/aec3/filter_analyzer.h
index 47e9533..99a0e25 100644
--- a/modules/audio_processing/aec3/filter_analyzer.h
+++ b/modules/audio_processing/aec3/filter_analyzer.h
@@ -11,20 +11,20 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_FILTER_ANALYZER_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_FILTER_ANALYZER_H_
 
+#include <stddef.h>
 #include <array>
+#include <memory>
 #include <vector>
 
-#include "absl/types/optional.h"
 #include "api/array_view.h"
 #include "api/audio/echo_canceller3_config.h"
 #include "modules/audio_processing/aec3/aec3_common.h"
-#include "modules/audio_processing/aec3/cascaded_biquad_filter.h"
-#include "modules/audio_processing/aec3/render_buffer.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
 
 class ApmDataDumper;
+class RenderBuffer;
 
 // Class for analyzing the properties of an adaptive filter.
 class FilterAnalyzer {
diff --git a/modules/audio_processing/aec3/frame_blocker.cc b/modules/audio_processing/aec3/frame_blocker.cc
index 0a0c0e2..ca122e5 100644
--- a/modules/audio_processing/aec3/frame_blocker.cc
+++ b/modules/audio_processing/aec3/frame_blocker.cc
@@ -10,8 +10,7 @@
 
 #include "modules/audio_processing/aec3/frame_blocker.h"
 
-#include <algorithm>
-
+#include "modules/audio_processing/aec3/aec3_common.h"
 #include "rtc_base/checks.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/aec3/fullband_erle_estimator.cc b/modules/audio_processing/aec3/fullband_erle_estimator.cc
index db9be7c..dc74509 100644
--- a/modules/audio_processing/aec3/fullband_erle_estimator.cc
+++ b/modules/audio_processing/aec3/fullband_erle_estimator.cc
@@ -18,6 +18,7 @@
 #include "api/array_view.h"
 #include "modules/audio_processing/aec3/aec3_common.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/numerics/safe_minmax.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/aec3/main_filter_update_gain.cc b/modules/audio_processing/aec3/main_filter_update_gain.cc
index ec5347e..ef87d14 100644
--- a/modules/audio_processing/aec3/main_filter_update_gain.cc
+++ b/modules/audio_processing/aec3/main_filter_update_gain.cc
@@ -13,7 +13,12 @@
 #include <algorithm>
 #include <functional>
 
+#include "modules/audio_processing/aec3/adaptive_fir_filter.h"
 #include "modules/audio_processing/aec3/aec3_common.h"
+#include "modules/audio_processing/aec3/echo_path_variability.h"
+#include "modules/audio_processing/aec3/fft_data.h"
+#include "modules/audio_processing/aec3/render_signal_analyzer.h"
+#include "modules/audio_processing/aec3/subtractor_output.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/atomicops.h"
 #include "rtc_base/checks.h"
diff --git a/modules/audio_processing/aec3/main_filter_update_gain.h b/modules/audio_processing/aec3/main_filter_update_gain.h
index 525b522..892ff68 100644
--- a/modules/audio_processing/aec3/main_filter_update_gain.h
+++ b/modules/audio_processing/aec3/main_filter_update_gain.h
@@ -11,20 +11,22 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_MAIN_FILTER_UPDATE_GAIN_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_MAIN_FILTER_UPDATE_GAIN_H_
 
+#include <stddef.h>
+#include <array>
 #include <memory>
-#include <vector>
 
 #include "api/audio/echo_canceller3_config.h"
-#include "modules/audio_processing/aec3/adaptive_fir_filter.h"
 #include "modules/audio_processing/aec3/aec3_common.h"
-#include "modules/audio_processing/aec3/echo_path_variability.h"
-#include "modules/audio_processing/aec3/render_signal_analyzer.h"
-#include "modules/audio_processing/aec3/subtractor_output.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
 
+class AdaptiveFirFilter;
 class ApmDataDumper;
+struct EchoPathVariability;
+struct FftData;
+class RenderSignalAnalyzer;
+struct SubtractorOutput;
 
 // Provides functionality for  computing the adaptive gain for the main filter.
 class MainFilterUpdateGain {
diff --git a/modules/audio_processing/aec3/matched_filter.cc b/modules/audio_processing/aec3/matched_filter.cc
index 6744bd5..757219d 100644
--- a/modules/audio_processing/aec3/matched_filter.cc
+++ b/modules/audio_processing/aec3/matched_filter.cc
@@ -19,10 +19,14 @@
 #include <emmintrin.h>
 #endif
 #include <algorithm>
+#include <cstddef>
+#include <initializer_list>
+#include <iterator>
 #include <numeric>
 
-#include "api/audio/echo_canceller3_config.h"
+#include "modules/audio_processing/aec3/downsampled_render_buffer.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/aec3/matched_filter.h b/modules/audio_processing/aec3/matched_filter.h
index 2ef4828..2a65339 100644
--- a/modules/audio_processing/aec3/matched_filter.h
+++ b/modules/audio_processing/aec3/matched_filter.h
@@ -11,18 +11,19 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_MATCHED_FILTER_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_MATCHED_FILTER_H_
 
-#include <array>
-#include <memory>
+#include <stddef.h>
 #include <vector>
 
-#include "absl/types/optional.h"
 #include "api/array_view.h"
 #include "modules/audio_processing/aec3/aec3_common.h"
-#include "modules/audio_processing/aec3/downsampled_render_buffer.h"
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/system/arch.h"
 
 namespace webrtc {
+
+class ApmDataDumper;
+struct DownsampledRenderBuffer;
+
 namespace aec3 {
 
 #if defined(WEBRTC_HAS_NEON)
@@ -65,7 +66,6 @@
 
 }  // namespace aec3
 
-class ApmDataDumper;
 
 // Produces recursively updated cross-correlation estimates for several signal
 // shifts where the intra-shift spacing is uniform.
diff --git a/modules/audio_processing/aec3/matched_filter_lag_aggregator.cc b/modules/audio_processing/aec3/matched_filter_lag_aggregator.cc
index 0a73768..f59525e 100644
--- a/modules/audio_processing/aec3/matched_filter_lag_aggregator.cc
+++ b/modules/audio_processing/aec3/matched_filter_lag_aggregator.cc
@@ -9,7 +9,11 @@
  */
 #include "modules/audio_processing/aec3/matched_filter_lag_aggregator.h"
 
+#include <algorithm>
+#include <iterator>
+
 #include "modules/audio_processing/logging/apm_data_dumper.h"
+#include "rtc_base/checks.h"
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/aec3/matrix_buffer.cc b/modules/audio_processing/aec3/matrix_buffer.cc
index f95e7f4..bd6daea 100644
--- a/modules/audio_processing/aec3/matrix_buffer.cc
+++ b/modules/audio_processing/aec3/matrix_buffer.cc
@@ -10,7 +10,7 @@
 
 #include "modules/audio_processing/aec3/matrix_buffer.h"
 
-#include "modules/audio_processing/aec3/aec3_common.h"
+#include <algorithm>
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/aec3/matrix_buffer.h b/modules/audio_processing/aec3/matrix_buffer.h
index 64aac0a..cae3759 100644
--- a/modules/audio_processing/aec3/matrix_buffer.h
+++ b/modules/audio_processing/aec3/matrix_buffer.h
@@ -11,6 +11,7 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_MATRIX_BUFFER_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_MATRIX_BUFFER_H_
 
+#include <stddef.h>
 #include <vector>
 
 #include "rtc_base/checks.h"
diff --git a/modules/audio_processing/aec3/moving_average.cc b/modules/audio_processing/aec3/moving_average.cc
index e9d64e6..7a81ee8 100644
--- a/modules/audio_processing/aec3/moving_average.cc
+++ b/modules/audio_processing/aec3/moving_average.cc
@@ -14,6 +14,8 @@
 #include <algorithm>
 #include <functional>
 
+#include "rtc_base/checks.h"
+
 namespace webrtc {
 namespace aec3 {
 
diff --git a/modules/audio_processing/aec3/moving_average.h b/modules/audio_processing/aec3/moving_average.h
index 94497d7..0f855be 100644
--- a/modules/audio_processing/aec3/moving_average.h
+++ b/modules/audio_processing/aec3/moving_average.h
@@ -11,6 +11,7 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_MOVING_AVERAGE_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_MOVING_AVERAGE_H_
 
+#include <stddef.h>
 #include <vector>
 
 #include "api/array_view.h"
diff --git a/modules/audio_processing/aec3/render_buffer.h b/modules/audio_processing/aec3/render_buffer.h
index dd67268..4c7c60c 100644
--- a/modules/audio_processing/aec3/render_buffer.h
+++ b/modules/audio_processing/aec3/render_buffer.h
@@ -11,14 +11,17 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_RENDER_BUFFER_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_RENDER_BUFFER_H_
 
+#include <stddef.h>
 #include <array>
-#include <memory>
+#include <vector>
 
 #include "api/array_view.h"
+#include "modules/audio_processing/aec3/aec3_common.h"
 #include "modules/audio_processing/aec3/fft_buffer.h"
 #include "modules/audio_processing/aec3/fft_data.h"
 #include "modules/audio_processing/aec3/matrix_buffer.h"
 #include "modules/audio_processing/aec3/vector_buffer.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/aec3/render_delay_buffer.cc b/modules/audio_processing/aec3/render_delay_buffer.cc
index 37a2378..1ec2779 100644
--- a/modules/audio_processing/aec3/render_delay_buffer.cc
+++ b/modules/audio_processing/aec3/render_delay_buffer.cc
@@ -10,17 +10,21 @@
 
 #include "modules/audio_processing/aec3/render_delay_buffer.h"
 
-#include <string.h>
+#include <stdlib.h>
 #include <algorithm>
+#include <memory>
 #include <numeric>
 
+#include "absl/types/optional.h"
+#include "api/array_view.h"
 #include "modules/audio_processing/aec3/aec3_common.h"
 #include "modules/audio_processing/aec3/aec3_fft.h"
-#include "modules/audio_processing/aec3/block_processor.h"
 #include "modules/audio_processing/aec3/decimator.h"
 #include "modules/audio_processing/aec3/fft_buffer.h"
 #include "modules/audio_processing/aec3/fft_data.h"
 #include "modules/audio_processing/aec3/matrix_buffer.h"
+#include "modules/audio_processing/aec3/vector_buffer.h"
+#include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/atomicops.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/constructormagic.h"
@@ -35,14 +39,6 @@
       "WebRTC-Aec3ZeroExternalDelayHeadroomKillSwitch");
 }
 
-size_t GetDownSamplingFactor(const EchoCanceller3Config& config) {
-  // Do not use down sampling factor 8 if kill switch is triggered.
-  return (config.delay.down_sampling_factor == 8 &&
-          field_trial::IsEnabled("WebRTC-Aec3DownSamplingFactor8KillSwitch"))
-             ? 4
-             : config.delay.down_sampling_factor;
-}
-
 class RenderDelayBufferImpl final : public RenderDelayBuffer {
  public:
   RenderDelayBufferImpl(const EchoCanceller3Config& config, size_t num_bands);
@@ -177,7 +173,7 @@
           new ApmDataDumper(rtc::AtomicOps::Increment(&instance_count_))),
       optimization_(DetectOptimization()),
       config_(config),
-      down_sampling_factor_(GetDownSamplingFactor(config)),
+      down_sampling_factor_(config.delay.down_sampling_factor),
       use_zero_external_delay_headroom_(EnableZeroExternalDelayHeadroom()),
       sub_block_size_(static_cast<int>(down_sampling_factor_ > 0
                                            ? kBlockSize / down_sampling_factor_
diff --git a/modules/audio_processing/aec3/render_delay_buffer.h b/modules/audio_processing/aec3/render_delay_buffer.h
index 8c5667e..bd242f7 100644
--- a/modules/audio_processing/aec3/render_delay_buffer.h
+++ b/modules/audio_processing/aec3/render_delay_buffer.h
@@ -12,15 +12,10 @@
 #define MODULES_AUDIO_PROCESSING_AEC3_RENDER_DELAY_BUFFER_H_
 
 #include <stddef.h>
-#include <array>
 #include <vector>
 
-#include "absl/types/optional.h"
-#include "api/array_view.h"
 #include "api/audio/echo_canceller3_config.h"
-#include "modules/audio_processing/aec3/aec3_common.h"
 #include "modules/audio_processing/aec3/downsampled_render_buffer.h"
-#include "modules/audio_processing/aec3/fft_data.h"
 #include "modules/audio_processing/aec3/render_buffer.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/aec3/render_delay_controller.cc b/modules/audio_processing/aec3/render_delay_controller.cc
index 646acde..36e75d9 100644
--- a/modules/audio_processing/aec3/render_delay_controller.cc
+++ b/modules/audio_processing/aec3/render_delay_controller.cc
@@ -9,10 +9,9 @@
  */
 #include "modules/audio_processing/aec3/render_delay_controller.h"
 
+#include <stdlib.h>
 #include <algorithm>
 #include <memory>
-#include <numeric>
-#include <string>
 #include <vector>
 
 #include "api/audio/echo_canceller3_config.h"
@@ -20,7 +19,9 @@
 #include "modules/audio_processing/aec3/echo_path_delay_estimator.h"
 #include "modules/audio_processing/aec3/render_delay_controller_metrics.h"
 #include "modules/audio_processing/aec3/skew_estimator.h"
+#include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/atomicops.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/logging.h"
 #include "system_wrappers/include/field_trial.h"
diff --git a/modules/audio_processing/aec3/render_delay_controller2.cc b/modules/audio_processing/aec3/render_delay_controller2.cc
index e27d5f3..1b7c18d 100644
--- a/modules/audio_processing/aec3/render_delay_controller2.cc
+++ b/modules/audio_processing/aec3/render_delay_controller2.cc
@@ -127,7 +127,7 @@
   delay_samples_ = absl::nullopt;
   delay_estimator_.Reset(reset_delay_confidence);
   delay_change_counter_ = 0;
-  if (reset_delay_confidence) {
+  if (reset_delay_confidence || true) {
     last_delay_estimate_quality_ = DelayEstimate::Quality::kCoarse;
   }
 }
diff --git a/modules/audio_processing/aec3/render_delay_controller_metrics.cc b/modules/audio_processing/aec3/render_delay_controller_metrics.cc
index 09db339..c51d468 100644
--- a/modules/audio_processing/aec3/render_delay_controller_metrics.cc
+++ b/modules/audio_processing/aec3/render_delay_controller_metrics.cc
@@ -13,6 +13,7 @@
 #include <algorithm>
 
 #include "modules/audio_processing/aec3/aec3_common.h"
+#include "rtc_base/checks.h"
 #include "system_wrappers/include/metrics.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/aec3/render_delay_controller_metrics.h b/modules/audio_processing/aec3/render_delay_controller_metrics.h
index 1cfe899..50e60bb 100644
--- a/modules/audio_processing/aec3/render_delay_controller_metrics.h
+++ b/modules/audio_processing/aec3/render_delay_controller_metrics.h
@@ -11,6 +11,8 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_RENDER_DELAY_CONTROLLER_METRICS_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_RENDER_DELAY_CONTROLLER_METRICS_H_
 
+#include <stddef.h>
+
 #include "absl/types/optional.h"
 #include "rtc_base/constructormagic.h"
 
diff --git a/modules/audio_processing/aec3/render_reverb_model.cc b/modules/audio_processing/aec3/render_reverb_model.cc
new file mode 100644
index 0000000..8ad54c0
--- /dev/null
+++ b/modules/audio_processing/aec3/render_reverb_model.cc
@@ -0,0 +1,44 @@
+/*
+ *  Copyright (c) 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.
+ */
+
+#include "modules/audio_processing/aec3/render_reverb_model.h"
+
+#include <algorithm>
+
+#include "api/array_view.h"
+#include "rtc_base/checks.h"
+
+namespace webrtc {
+
+RenderReverbModel::RenderReverbModel() {
+  Reset();
+}
+
+RenderReverbModel::~RenderReverbModel() = default;
+
+void RenderReverbModel::Reset() {
+  render_reverb_.Reset();
+}
+
+void RenderReverbModel::Apply(const VectorBuffer& spectrum_buffer,
+                              int delay_blocks,
+                              float reverb_decay,
+                              rtc::ArrayView<float> reverb_power_spectrum) {
+  int idx_at_delay =
+      spectrum_buffer.OffsetIndex(spectrum_buffer.read, delay_blocks);
+  int idx_past = spectrum_buffer.IncIndex(idx_at_delay);
+  const auto& X2 = spectrum_buffer.buffer[idx_at_delay];
+  RTC_DCHECK_EQ(X2.size(), reverb_power_spectrum.size());
+  std::copy(X2.begin(), X2.end(), reverb_power_spectrum.begin());
+  render_reverb_.AddReverbNoFreqShaping(spectrum_buffer.buffer[idx_past], 1.0f,
+                                        reverb_decay, reverb_power_spectrum);
+}
+
+}  // namespace webrtc
diff --git a/modules/audio_processing/aec3/render_reverb_model.h b/modules/audio_processing/aec3/render_reverb_model.h
new file mode 100644
index 0000000..d404a69
--- /dev/null
+++ b/modules/audio_processing/aec3/render_reverb_model.h
@@ -0,0 +1,49 @@
+/*
+ *  Copyright (c) 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 MODULES_AUDIO_PROCESSING_AEC3_RENDER_REVERB_MODEL_H_
+#define MODULES_AUDIO_PROCESSING_AEC3_RENDER_REVERB_MODEL_H_
+
+#include "api/array_view.h"
+#include "modules/audio_processing/aec3/reverb_model.h"
+#include "modules/audio_processing/aec3/vector_buffer.h"
+
+namespace webrtc {
+
+// The RenderReverbModel class applies an exponential reverberant model over the
+// render spectrum.
+class RenderReverbModel {
+ public:
+  RenderReverbModel();
+  ~RenderReverbModel();
+
+  // Resets the state.
+  void Reset();
+
+  // Applies the reverberation model over the render spectrum. It also returns
+  // the reverberation render power spectrum in the array reverb_power_spectrum.
+  void Apply(const VectorBuffer& spectrum_buffer,
+             int delay_blocks,
+             float reverb_decay,
+             rtc::ArrayView<float> reverb_power_spectrum);
+
+  // Gets the reverberation spectrum that was added to the render spectrum for
+  // computing the reverberation render spectrum.
+  rtc::ArrayView<const float> GetReverbContributionPowerSpectrum() const {
+    return render_reverb_.GetPowerSpectrum();
+  }
+
+ private:
+  ReverbModel render_reverb_;
+};
+
+}  // namespace webrtc.
+
+#endif  // MODULES_AUDIO_PROCESSING_AEC3_RENDER_REVERB_MODEL_H_
diff --git a/modules/audio_processing/aec3/render_signal_analyzer.cc b/modules/audio_processing/aec3/render_signal_analyzer.cc
index 50c34ce..33b04bf 100644
--- a/modules/audio_processing/aec3/render_signal_analyzer.cc
+++ b/modules/audio_processing/aec3/render_signal_analyzer.cc
@@ -12,7 +12,10 @@
 
 #include <math.h>
 #include <algorithm>
+#include <utility>
+#include <vector>
 
+#include "api/array_view.h"
 #include "rtc_base/checks.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/aec3/render_signal_analyzer.h b/modules/audio_processing/aec3/render_signal_analyzer.h
index c603c92..8a44232 100644
--- a/modules/audio_processing/aec3/render_signal_analyzer.h
+++ b/modules/audio_processing/aec3/render_signal_analyzer.h
@@ -11,13 +11,15 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_RENDER_SIGNAL_ANALYZER_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_RENDER_SIGNAL_ANALYZER_H_
 
+#include <algorithm>
 #include <array>
-#include <memory>
+#include <cstddef>
 
 #include "absl/types/optional.h"
 #include "api/audio/echo_canceller3_config.h"
 #include "modules/audio_processing/aec3/aec3_common.h"
 #include "modules/audio_processing/aec3/render_buffer.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/aec3/residual_echo_estimator.cc b/modules/audio_processing/aec3/residual_echo_estimator.cc
index 7b063c1..627dd90 100644
--- a/modules/audio_processing/aec3/residual_echo_estimator.cc
+++ b/modules/audio_processing/aec3/residual_echo_estimator.cc
@@ -11,9 +11,11 @@
 
 #include "modules/audio_processing/aec3/residual_echo_estimator.h"
 
-#include <numeric>
+#include <stddef.h>
+#include <algorithm>
 #include <vector>
 
+#include "api/array_view.h"
 #include "modules/audio_processing/aec3/reverb_model.h"
 #include "modules/audio_processing/aec3/reverb_model_fallback.h"
 #include "rtc_base/checks.h"
diff --git a/modules/audio_processing/aec3/residual_echo_estimator.h b/modules/audio_processing/aec3/residual_echo_estimator.h
index 6dcf24f..52885a5 100644
--- a/modules/audio_processing/aec3/residual_echo_estimator.h
+++ b/modules/audio_processing/aec3/residual_echo_estimator.h
@@ -11,18 +11,18 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_RESIDUAL_ECHO_ESTIMATOR_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_RESIDUAL_ECHO_ESTIMATOR_H_
 
-#include <algorithm>
 #include <array>
 #include <memory>
-#include <vector>
 
-#include "api/array_view.h"
+#include "absl/types/optional.h"
 #include "api/audio/echo_canceller3_config.h"
 #include "modules/audio_processing/aec3/aec3_common.h"
 #include "modules/audio_processing/aec3/aec_state.h"
 #include "modules/audio_processing/aec3/render_buffer.h"
 #include "modules/audio_processing/aec3/reverb_model.h"
 #include "modules/audio_processing/aec3/reverb_model_fallback.h"
+#include "modules/audio_processing/aec3/vector_buffer.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
@@ -39,7 +39,7 @@
                 std::array<float, kFftLengthBy2Plus1>* R2);
 
   // Returns the reverberant power spectrum contributions to the echo residual.
-  const std::array<float, kFftLengthBy2Plus1>& GetReverbPowerSpectrum() const {
+  rtc::ArrayView<const float> GetReverbPowerSpectrum() const {
     if (echo_reverb_) {
       return echo_reverb_->GetPowerSpectrum();
     } else {
@@ -66,7 +66,6 @@
                          const std::array<float, kFftLengthBy2Plus1>& Y2,
                          std::array<float, kFftLengthBy2Plus1>* R2);
 
-
   // Estimates the echo generating signal power as gated maximal power over a
   // time window.
   void EchoGeneratingPower(const VectorBuffer& spectrum_buffer,
diff --git a/modules/audio_processing/aec3/reverb_decay_estimator.cc b/modules/audio_processing/aec3/reverb_decay_estimator.cc
index f80afa2..95fd13a 100644
--- a/modules/audio_processing/aec3/reverb_decay_estimator.cc
+++ b/modules/audio_processing/aec3/reverb_decay_estimator.cc
@@ -10,11 +10,13 @@
 
 #include "modules/audio_processing/aec3/reverb_decay_estimator.h"
 
+#include <stddef.h>
 #include <algorithm>
 #include <cmath>
 #include <numeric>
 
 #include "api/array_view.h"
+#include "api/audio/echo_canceller3_config.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/checks.h"
 #include "system_wrappers/include/field_trial.h"
diff --git a/modules/audio_processing/aec3/reverb_decay_estimator.h b/modules/audio_processing/aec3/reverb_decay_estimator.h
index 67a84ab..4c8d0c6 100644
--- a/modules/audio_processing/aec3/reverb_decay_estimator.h
+++ b/modules/audio_processing/aec3/reverb_decay_estimator.h
@@ -16,12 +16,12 @@
 
 #include "absl/types/optional.h"
 #include "api/array_view.h"
-#include "api/audio/echo_canceller3_config.h"
-#include "modules/audio_processing/aec3/aec3_common.h"
+#include "modules/audio_processing/aec3/aec3_common.h"  // kMaxAdaptiveFilter...
 
 namespace webrtc {
 
 class ApmDataDumper;
+struct EchoCanceller3Config;
 
 // Class for estimating the decay of the late reverb.
 class ReverbDecayEstimator {
diff --git a/modules/audio_processing/aec3/reverb_frequency_response.cc b/modules/audio_processing/aec3/reverb_frequency_response.cc
index 0d82515..d2103d4 100644
--- a/modules/audio_processing/aec3/reverb_frequency_response.cc
+++ b/modules/audio_processing/aec3/reverb_frequency_response.cc
@@ -10,14 +10,12 @@
 
 #include "modules/audio_processing/aec3/reverb_frequency_response.h"
 
+#include <stddef.h>
 #include <algorithm>
 #include <array>
-#include <cmath>
-#include <memory>
 #include <numeric>
 
 #include "api/array_view.h"
-#include "api/audio/echo_canceller3_config.h"
 #include "modules/audio_processing/aec3/aec3_common.h"
 #include "rtc_base/checks.h"
 #include "system_wrappers/include/field_trial.h"
diff --git a/modules/audio_processing/aec3/reverb_frequency_response.h b/modules/audio_processing/aec3/reverb_frequency_response.h
index 23485e0..eb63b8e 100644
--- a/modules/audio_processing/aec3/reverb_frequency_response.h
+++ b/modules/audio_processing/aec3/reverb_frequency_response.h
@@ -11,13 +11,12 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_REVERB_FREQUENCY_RESPONSE_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_REVERB_FREQUENCY_RESPONSE_H_
 
-#include <memory>
+#include <array>
 #include <vector>
 
 #include "absl/types/optional.h"
 #include "api/array_view.h"
 #include "modules/audio_processing/aec3/aec3_common.h"
-#include "modules/audio_processing/logging/apm_data_dumper.h"
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/aec3/reverb_model.cc b/modules/audio_processing/aec3/reverb_model.cc
index 0ca248f..f0a24c0 100644
--- a/modules/audio_processing/aec3/reverb_model.cc
+++ b/modules/audio_processing/aec3/reverb_model.cc
@@ -10,13 +10,11 @@
 
 #include "modules/audio_processing/aec3/reverb_model.h"
 
-#include <math.h>
-
+#include <stddef.h>
 #include <algorithm>
 #include <functional>
 
 #include "api/array_view.h"
-#include "modules/audio_processing/aec3/aec3_common.h"
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/aec3/reverb_model.h b/modules/audio_processing/aec3/reverb_model.h
index d3087a7..56e2266 100644
--- a/modules/audio_processing/aec3/reverb_model.h
+++ b/modules/audio_processing/aec3/reverb_model.h
@@ -11,6 +11,8 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_REVERB_MODEL_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_REVERB_MODEL_H_
 
+#include <array>
+
 #include "api/array_view.h"
 #include "modules/audio_processing/aec3/aec3_common.h"
 
@@ -50,9 +52,7 @@
       float reverb_decay);
 
   // Returns the current power spectrum reverberation contributions.
-  const std::array<float, kFftLengthBy2Plus1>& GetPowerSpectrum() const {
-    return reverb_;
-  }
+  rtc::ArrayView<const float> GetPowerSpectrum() const { return reverb_; }
 
  private:
   // Updates the reverberation contributions.
diff --git a/modules/audio_processing/aec3/reverb_model_estimator.h b/modules/audio_processing/aec3/reverb_model_estimator.h
index b6a3591..1112f93 100644
--- a/modules/audio_processing/aec3/reverb_model_estimator.h
+++ b/modules/audio_processing/aec3/reverb_model_estimator.h
@@ -11,11 +11,13 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_REVERB_MODEL_ESTIMATOR_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_REVERB_MODEL_ESTIMATOR_H_
 
+#include <array>
 #include <vector>
 
 #include "absl/types/optional.h"
 #include "api/array_view.h"
 #include "api/audio/echo_canceller3_config.h"
+#include "modules/audio_processing/aec3/aec3_common.h"  // kFftLengthBy2Plus1
 #include "modules/audio_processing/aec3/reverb_decay_estimator.h"
 #include "modules/audio_processing/aec3/reverb_frequency_response.h"
 
diff --git a/modules/audio_processing/aec3/reverb_model_fallback.h b/modules/audio_processing/aec3/reverb_model_fallback.h
index 1b2a953..1bd2b59 100644
--- a/modules/audio_processing/aec3/reverb_model_fallback.h
+++ b/modules/audio_processing/aec3/reverb_model_fallback.h
@@ -11,6 +11,7 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_REVERB_MODEL_FALLBACK_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_REVERB_MODEL_FALLBACK_H_
 
+#include <stddef.h>
 #include <array>
 #include <vector>
 
diff --git a/modules/audio_processing/aec3/shadow_filter_update_gain.h b/modules/audio_processing/aec3/shadow_filter_update_gain.h
index a92bc3b..05e632f 100644
--- a/modules/audio_processing/aec3/shadow_filter_update_gain.h
+++ b/modules/audio_processing/aec3/shadow_filter_update_gain.h
@@ -11,11 +11,13 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_SHADOW_FILTER_UPDATE_GAIN_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_SHADOW_FILTER_UPDATE_GAIN_H_
 
+#include <stddef.h>
+#include <array>
+
 #include "api/audio/echo_canceller3_config.h"
 #include "modules/audio_processing/aec3/aec3_common.h"
-#include "modules/audio_processing/aec3/render_buffer.h"
+#include "modules/audio_processing/aec3/fft_data.h"
 #include "modules/audio_processing/aec3/render_signal_analyzer.h"
-#include "rtc_base/constructormagic.h"
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/aec3/skew_estimator.cc b/modules/audio_processing/aec3/skew_estimator.cc
index 310e4e9..a2099fc 100644
--- a/modules/audio_processing/aec3/skew_estimator.cc
+++ b/modules/audio_processing/aec3/skew_estimator.cc
@@ -10,7 +10,6 @@
 #include "modules/audio_processing/aec3/skew_estimator.h"
 
 #include <algorithm>
-#include <numeric>
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/aec3/skew_estimator.h b/modules/audio_processing/aec3/skew_estimator.h
index ff25260..b0946d8 100644
--- a/modules/audio_processing/aec3/skew_estimator.h
+++ b/modules/audio_processing/aec3/skew_estimator.h
@@ -11,6 +11,7 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_SKEW_ESTIMATOR_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_SKEW_ESTIMATOR_H_
 
+#include <stddef.h>
 #include <vector>
 
 #include "absl/types/optional.h"
diff --git a/modules/audio_processing/aec3/stationarity_estimator.cc b/modules/audio_processing/aec3/stationarity_estimator.cc
index efeabf1..25100bf 100644
--- a/modules/audio_processing/aec3/stationarity_estimator.cc
+++ b/modules/audio_processing/aec3/stationarity_estimator.cc
@@ -14,6 +14,7 @@
 #include <array>
 #include <vector>
 
+#include "api/array_view.h"
 #include "modules/audio_processing/aec3/aec3_common.h"
 #include "modules/audio_processing/aec3/vector_buffer.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
@@ -40,7 +41,6 @@
   noise_.Reset();
   hangovers_.fill(0);
   stationarity_flags_.fill(false);
-  render_reverb_.Reset();
 }
 
 // Update just the noise estimator. Usefull until the delay is known
@@ -54,9 +54,9 @@
 
 void StationarityEstimator::UpdateStationarityFlags(
     const VectorBuffer& spectrum_buffer,
+    rtc::ArrayView<const float> render_reverb_contribution_spectrum,
     int idx_current,
-    int num_lookahead,
-    float reverb_decay) {
+    int num_lookahead) {
   std::array<int, kWindowLength> indexes;
   int num_lookahead_bounded = std::min(num_lookahead, kWindowLength - 1);
   int idx = idx_current;
@@ -79,12 +79,9 @@
       spectrum_buffer.DecIndex(indexes[kWindowLength - 1]),
       spectrum_buffer.OffsetIndex(idx_current, -(num_lookahead_bounded + 1)));
 
-  int idx_past = spectrum_buffer.IncIndex(idx_current);
-  render_reverb_.UpdateReverbContributionsNoFreqShaping(
-      spectrum_buffer.buffer[idx_past], 1.0f, reverb_decay);
   for (size_t k = 0; k < stationarity_flags_.size(); ++k) {
     stationarity_flags_[k] = EstimateBandStationarity(
-        spectrum_buffer, render_reverb_.GetPowerSpectrum(), indexes, k);
+        spectrum_buffer, render_reverb_contribution_spectrum, indexes, k);
   }
   UpdateHangover();
   SmoothStationaryPerFreq();
@@ -102,7 +99,7 @@
 
 bool StationarityEstimator::EstimateBandStationarity(
     const VectorBuffer& spectrum_buffer,
-    const std::array<float, kFftLengthBy2Plus1>& reverb,
+    rtc::ArrayView<const float> reverb,
     const std::array<int, kWindowLength>& indexes,
     size_t band) const {
   constexpr float kThrStationarity = 10.f;
diff --git a/modules/audio_processing/aec3/stationarity_estimator.h b/modules/audio_processing/aec3/stationarity_estimator.h
index e2c5a62..704859a 100644
--- a/modules/audio_processing/aec3/stationarity_estimator.h
+++ b/modules/audio_processing/aec3/stationarity_estimator.h
@@ -11,18 +11,19 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_STATIONARITY_ESTIMATOR_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_STATIONARITY_ESTIMATOR_H_
 
+#include <stddef.h>
 #include <array>
 #include <memory>
-#include <vector>
 
 #include "api/array_view.h"
-#include "modules/audio_processing/aec3/aec3_common.h"
+#include "modules/audio_processing/aec3/aec3_common.h"  // kFftLengthBy2Plus1...
 #include "modules/audio_processing/aec3/reverb_model.h"
-#include "modules/audio_processing/aec3/vector_buffer.h"
+#include "rtc_base/checks.h"
 
 namespace webrtc {
 
 class ApmDataDumper;
+struct VectorBuffer;
 
 class StationarityEstimator {
  public:
@@ -37,10 +38,11 @@
 
   // Update the flag indicating whether this current frame is stationary. For
   // getting a more robust estimation, it looks at future and/or past frames.
-  void UpdateStationarityFlags(const VectorBuffer& spectrum_buffer,
-                               int idx_current,
-                               int num_lookahead,
-                               float reverb_decay);
+  void UpdateStationarityFlags(
+      const VectorBuffer& spectrum_buffer,
+      rtc::ArrayView<const float> render_reverb_contribution_spectrum,
+      int idx_current,
+      int num_lookahead);
 
   // Returns true if the current band is stationary.
   bool IsBandStationary(size_t band) const {
@@ -57,11 +59,10 @@
 
   // Get an estimation of the stationarity for the current band by looking
   // at the past/present/future available data.
-  bool EstimateBandStationarity(
-      const VectorBuffer& spectrum_buffer,
-      const std::array<float, kFftLengthBy2Plus1>& reverb,
-      const std::array<int, kWindowLength>& indexes,
-      size_t band) const;
+  bool EstimateBandStationarity(const VectorBuffer& spectrum_buffer,
+                                rtc::ArrayView<const float> reverb,
+                                const std::array<int, kWindowLength>& indexes,
+                                size_t band) const;
 
   // True if all bands at the current point are stationary.
   bool AreAllBandsStationary();
@@ -111,7 +112,6 @@
   NoiseSpectrum noise_;
   std::array<int, kFftLengthBy2Plus1> hangovers_;
   std::array<bool, kFftLengthBy2Plus1> stationarity_flags_;
-  ReverbModel render_reverb_;
 };
 
 }  // namespace webrtc
diff --git a/modules/audio_processing/aec3/subband_erle_estimator.cc b/modules/audio_processing/aec3/subband_erle_estimator.cc
index d8cb7a7..2cb5acc 100644
--- a/modules/audio_processing/aec3/subband_erle_estimator.cc
+++ b/modules/audio_processing/aec3/subband_erle_estimator.cc
@@ -17,6 +17,7 @@
 #include "api/array_view.h"
 #include "modules/audio_processing/aec3/aec3_common.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/numerics/safe_minmax.h"
 #include "system_wrappers/include/field_trial.h"
 
diff --git a/modules/audio_processing/aec3/subband_erle_estimator.h b/modules/audio_processing/aec3/subband_erle_estimator.h
index aa5e5cc..7693b6a 100644
--- a/modules/audio_processing/aec3/subband_erle_estimator.h
+++ b/modules/audio_processing/aec3/subband_erle_estimator.h
@@ -11,6 +11,7 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_SUBBAND_ERLE_ESTIMATOR_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_SUBBAND_ERLE_ESTIMATOR_H_
 
+#include <stddef.h>
 #include <array>
 #include <memory>
 
diff --git a/modules/audio_processing/aec3/subtractor.cc b/modules/audio_processing/aec3/subtractor.cc
index 9856a74..90069c7 100644
--- a/modules/audio_processing/aec3/subtractor.cc
+++ b/modules/audio_processing/aec3/subtractor.cc
@@ -11,12 +11,12 @@
 #include "modules/audio_processing/aec3/subtractor.h"
 
 #include <algorithm>
-#include <numeric>
+#include <utility>
 
 #include "api/array_view.h"
+#include "modules/audio_processing/aec3/fft_data.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/checks.h"
-#include "rtc_base/logging.h"
 #include "rtc_base/numerics/safe_minmax.h"
 #include "system_wrappers/include/field_trial.h"
 
diff --git a/modules/audio_processing/aec3/subtractor.h b/modules/audio_processing/aec3/subtractor.h
index c92a971..bec014d 100644
--- a/modules/audio_processing/aec3/subtractor.h
+++ b/modules/audio_processing/aec3/subtractor.h
@@ -11,11 +11,13 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_SUBTRACTOR_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_SUBTRACTOR_H_
 
-#include <algorithm>
+#include <math.h>
+#include <stddef.h>
 #include <array>
 #include <vector>
-#include "math.h"
 
+#include "api/array_view.h"
+#include "api/audio/echo_canceller3_config.h"
 #include "modules/audio_processing/aec3/adaptive_fir_filter.h"
 #include "modules/audio_processing/aec3/aec3_common.h"
 #include "modules/audio_processing/aec3/aec3_fft.h"
@@ -23,10 +25,11 @@
 #include "modules/audio_processing/aec3/echo_path_variability.h"
 #include "modules/audio_processing/aec3/main_filter_update_gain.h"
 #include "modules/audio_processing/aec3/render_buffer.h"
+#include "modules/audio_processing/aec3/render_signal_analyzer.h"
 #include "modules/audio_processing/aec3/shadow_filter_update_gain.h"
 #include "modules/audio_processing/aec3/subtractor_output.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
-#include "modules/audio_processing/utility/ooura_fft.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/aec3/subtractor_output_analyzer.cc b/modules/audio_processing/aec3/subtractor_output_analyzer.cc
index 3cacb45..9374b80 100644
--- a/modules/audio_processing/aec3/subtractor_output_analyzer.cc
+++ b/modules/audio_processing/aec3/subtractor_output_analyzer.cc
@@ -10,9 +10,9 @@
 
 #include "modules/audio_processing/aec3/subtractor_output_analyzer.h"
 
-#include <array>
-#include <numeric>
+#include <algorithm>
 
+#include "modules/audio_processing/aec3/aec3_common.h"
 #include "system_wrappers/include/field_trial.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/aec3/subtractor_output_analyzer.h b/modules/audio_processing/aec3/subtractor_output_analyzer.h
index b59a68e..0e23ad5 100644
--- a/modules/audio_processing/aec3/subtractor_output_analyzer.h
+++ b/modules/audio_processing/aec3/subtractor_output_analyzer.h
@@ -11,7 +11,6 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_SUBTRACTOR_OUTPUT_ANALYZER_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_SUBTRACTOR_OUTPUT_ANALYZER_H_
 
-#include "api/array_view.h"
 #include "modules/audio_processing/aec3/subtractor_output.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/aec3/suppression_filter.cc b/modules/audio_processing/aec3/suppression_filter.cc
index 35b7b8c..6fe296c 100644
--- a/modules/audio_processing/aec3/suppression_filter.cc
+++ b/modules/audio_processing/aec3/suppression_filter.cc
@@ -10,15 +10,13 @@
 
 #include "modules/audio_processing/aec3/suppression_filter.h"
 
-#include <math.h>
 #include <algorithm>
 #include <cmath>
 #include <cstring>
 #include <functional>
-#include <numeric>
+#include <iterator>
 
 #include "modules/audio_processing/aec3/vector_math.h"
-#include "modules/audio_processing/utility/ooura_fft.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/numerics/safe_minmax.h"
 
diff --git a/modules/audio_processing/aec3/suppression_filter.h b/modules/audio_processing/aec3/suppression_filter.h
index 1628e3e..edd1290 100644
--- a/modules/audio_processing/aec3/suppression_filter.h
+++ b/modules/audio_processing/aec3/suppression_filter.h
@@ -16,6 +16,8 @@
 
 #include "modules/audio_processing/aec3/aec3_common.h"
 #include "modules/audio_processing/aec3/aec3_fft.h"
+#include "modules/audio_processing/aec3/fft_data.h"
+#include "modules/audio_processing/utility/ooura_fft.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/aec3/suppression_gain.cc b/modules/audio_processing/aec3/suppression_gain.cc
index ce7ea33..88cfc0a 100644
--- a/modules/audio_processing/aec3/suppression_gain.cc
+++ b/modules/audio_processing/aec3/suppression_gain.cc
@@ -11,8 +11,8 @@
 #include "modules/audio_processing/aec3/suppression_gain.h"
 
 #include <math.h>
+#include <stddef.h>
 #include <algorithm>
-#include <functional>
 #include <numeric>
 
 #include "modules/audio_processing/aec3/moving_average.h"
@@ -20,15 +20,10 @@
 #include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/atomicops.h"
 #include "rtc_base/checks.h"
-#include "system_wrappers/include/field_trial.h"
 
 namespace webrtc {
 namespace {
 
-bool EnableNewSuppression() {
-  return !field_trial::IsEnabled("WebRTC-Aec3NewSuppressionKillSwitch");
-}
-
 // Adjust the gains according to the presence of known external filters.
 void AdjustForExternalFilters(std::array<float, kFftLengthBy2Plus1>* gain) {
   // Limit the low frequency gains to avoid the impact of the high-pass filter
@@ -83,57 +78,6 @@
   weigh(threshold, normalizer, 7, kFftLengthBy2Plus1, echo, weighted_echo);
 }
 
-// Computes the gain to reduce the echo to a non audible level.
-void GainToNoAudibleEchoFallback(
-    const EchoCanceller3Config& config,
-    bool low_noise_render,
-    bool saturated_echo,
-    bool linear_echo_estimate,
-    const std::array<float, kFftLengthBy2Plus1>& nearend,
-    const std::array<float, kFftLengthBy2Plus1>& weighted_echo,
-    const std::array<float, kFftLengthBy2Plus1>& masker,
-    const std::array<float, kFftLengthBy2Plus1>& min_gain,
-    const std::array<float, kFftLengthBy2Plus1>& max_gain,
-    const std::array<float, kFftLengthBy2Plus1>& one_by_weighted_echo,
-    std::array<float, kFftLengthBy2Plus1>* gain) {
-  float nearend_masking_margin = 0.f;
-  if (linear_echo_estimate) {
-    nearend_masking_margin =
-        low_noise_render
-            ? config.gain_mask.m9
-            : (saturated_echo ? config.gain_mask.m2 : config.gain_mask.m3);
-  } else {
-    nearend_masking_margin = config.gain_mask.m7;
-  }
-
-  RTC_DCHECK_LE(0.f, nearend_masking_margin);
-  RTC_DCHECK_GT(1.f, nearend_masking_margin);
-
-  const float masker_margin =
-      linear_echo_estimate ? config.gain_mask.m0 : config.gain_mask.m8;
-
-  for (size_t k = 0; k < gain->size(); ++k) {
-    // TODO(devicentepena): Experiment by removing the reverberation estimation
-    // from the nearend signal before computing the gains.
-    const float unity_gain_masker = std::max(nearend[k], masker[k]);
-    RTC_DCHECK_LE(0.f, nearend_masking_margin * unity_gain_masker);
-    if (weighted_echo[k] <= nearend_masking_margin * unity_gain_masker ||
-        unity_gain_masker <= 0.f) {
-      (*gain)[k] = 1.f;
-    } else {
-      RTC_DCHECK_LT(0.f, unity_gain_masker);
-      (*gain)[k] =
-          std::max(0.f, (1.f - config.gain_mask.gain_curve_slope *
-                                   weighted_echo[k] / unity_gain_masker) *
-                            config.gain_mask.gain_curve_offset);
-      (*gain)[k] = std::max(masker_margin * masker[k] * one_by_weighted_echo[k],
-                            (*gain)[k]);
-    }
-
-    (*gain)[k] = std::min(std::max((*gain)[k], min_gain[k]), max_gain[k]);
-  }
-}
-
 // TODO(peah): Make adaptive to take the actual filter error into account.
 constexpr size_t kUpperAccurateBandPlus1 = 29;
 
@@ -321,30 +265,9 @@
   std::array<float, kFftLengthBy2Plus1> max_gain;
   GetMaxGain(max_gain);
 
-  // Iteratively compute the gain required to attenuate the echo to a non
-  // noticeable level.
-
-  if (enable_new_suppression_) {
     GainToNoAudibleEcho(nearend, weighted_residual_echo, comfort_noise,
                         min_gain, max_gain, gain);
     AdjustForExternalFilters(gain);
-  } else {
-    const bool linear_echo_estimate = aec_state.UsableLinearEstimate();
-    std::array<float, kFftLengthBy2Plus1> masker;
-    std::array<float, kFftLengthBy2Plus1> one_by_weighted_echo;
-    std::transform(weighted_residual_echo.begin(), weighted_residual_echo.end(),
-                   one_by_weighted_echo.begin(),
-                   [](float e) { return e > 0.f ? 1.f / e : 1.f; });
-    gain->fill(0.f);
-    for (int k = 0; k < 2; ++k) {
-      std::copy(comfort_noise.begin(), comfort_noise.end(), masker.begin());
-      GainToNoAudibleEchoFallback(config_, low_noise_render, saturated_echo,
-                                  linear_echo_estimate, nearend,
-                                  weighted_residual_echo, masker, min_gain,
-                                  max_gain, one_by_weighted_echo, gain);
-      AdjustForExternalFilters(gain);
-    }
-  }
 
   // Adjust the gain for frequencies which have not yet converged.
   AdjustNonConvergedFrequencies(gain);
@@ -372,7 +295,6 @@
       config_(config),
       state_change_duration_blocks_(
           static_cast<int>(config_.filter.config_change_duration_blocks)),
-      enable_new_suppression_(EnableNewSuppression()),
       moving_average_(kFftLengthBy2Plus1,
                       config.suppressor.nearend_average_blocks),
       nearend_params_(config_.suppressor.nearend_tuning),
diff --git a/modules/audio_processing/aec3/suppression_gain.h b/modules/audio_processing/aec3/suppression_gain.h
index 836ec51..e74cd96 100644
--- a/modules/audio_processing/aec3/suppression_gain.h
+++ b/modules/audio_processing/aec3/suppression_gain.h
@@ -12,13 +12,18 @@
 #define MODULES_AUDIO_PROCESSING_AEC3_SUPPRESSION_GAIN_H_
 
 #include <array>
+#include <memory>
 #include <vector>
 
+#include "absl/types/optional.h"
+#include "api/array_view.h"
 #include "api/audio/echo_canceller3_config.h"
 #include "modules/audio_processing/aec3/aec3_common.h"
 #include "modules/audio_processing/aec3/aec_state.h"
+#include "modules/audio_processing/aec3/fft_data.h"
 #include "modules/audio_processing/aec3/moving_average.h"
 #include "modules/audio_processing/aec3/render_signal_analyzer.h"
+#include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
@@ -140,7 +145,6 @@
   LowNoiseRenderDetector low_render_detector_;
   bool initial_state_ = true;
   int initial_state_change_counter_ = 0;
-  const bool enable_new_suppression_;
   aec3::MovingAverage moving_average_;
   const GainParameters nearend_params_;
   const GainParameters normal_params_;
diff --git a/modules/audio_processing/aec3/suppression_gain_limiter.cc b/modules/audio_processing/aec3/suppression_gain_limiter.cc
index e3d7a66..6625a77 100644
--- a/modules/audio_processing/aec3/suppression_gain_limiter.cc
+++ b/modules/audio_processing/aec3/suppression_gain_limiter.cc
@@ -14,6 +14,7 @@
 #include <algorithm>
 
 #include "modules/audio_processing/aec3/aec3_common.h"
+#include "rtc_base/checks.h"
 
 namespace webrtc {
 namespace {
diff --git a/modules/audio_processing/aec3/vector_buffer.cc b/modules/audio_processing/aec3/vector_buffer.cc
index f491168..0682885 100644
--- a/modules/audio_processing/aec3/vector_buffer.cc
+++ b/modules/audio_processing/aec3/vector_buffer.cc
@@ -10,7 +10,7 @@
 
 #include "modules/audio_processing/aec3/vector_buffer.h"
 
-#include "modules/audio_processing/aec3/aec3_common.h"
+#include <algorithm>
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/aec3/vector_buffer.h b/modules/audio_processing/aec3/vector_buffer.h
index c7d4f68..4c0257c 100644
--- a/modules/audio_processing/aec3/vector_buffer.h
+++ b/modules/audio_processing/aec3/vector_buffer.h
@@ -11,6 +11,7 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_VECTOR_BUFFER_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_VECTOR_BUFFER_H_
 
+#include <stddef.h>
 #include <vector>
 
 #include "rtc_base/checks.h"
diff --git a/modules/audio_processing/aec_dump/BUILD.gn b/modules/audio_processing/aec_dump/BUILD.gn
index 5b55526..d4262ca 100644
--- a/modules/audio_processing/aec_dump/BUILD.gn
+++ b/modules/audio_processing/aec_dump/BUILD.gn
@@ -43,6 +43,7 @@
 
   deps = [
     ":mock_aec_dump",
+    "..:api",
     "../",
     "../../../rtc_base:rtc_base_approved",
     "//testing/gtest",
diff --git a/modules/audio_processing/aec_dump/aec_dump_impl.cc b/modules/audio_processing/aec_dump/aec_dump_impl.cc
index 2732934..9020f2b 100644
--- a/modules/audio_processing/aec_dump/aec_dump_impl.cc
+++ b/modules/audio_processing/aec_dump/aec_dump_impl.cc
@@ -65,7 +65,7 @@
 
 AecDumpImpl::~AecDumpImpl() {
   // Block until all tasks have finished running.
-  rtc::Event thread_sync_event(false /* manual_reset */, false);
+  rtc::Event thread_sync_event;
   worker_queue_->PostTask([&thread_sync_event] { thread_sync_event.Set(); });
   // Wait until the event has been signaled with .Set(). By then all
   // pending tasks will have finished.
diff --git a/modules/audio_processing/aecm/aecm_core.cc b/modules/audio_processing/aecm/aecm_core.cc
index 0e56b50..67b70bf 100644
--- a/modules/audio_processing/aecm/aecm_core.cc
+++ b/modules/audio_processing/aecm/aecm_core.cc
@@ -12,16 +12,15 @@
 
 #include <stddef.h>
 #include <stdlib.h>
+#include <string.h>
 
 extern "C" {
 #include "common_audio/ring_buffer.h"
 #include "common_audio/signal_processing/include/real_fft.h"
 }
+#include "common_audio/signal_processing/include/signal_processing_library.h"
 #include "modules/audio_processing/aecm/echo_control_mobile.h"
 #include "modules/audio_processing/utility/delay_estimator_wrapper.h"
-extern "C" {
-#include "system_wrappers/include/cpu_features_wrapper.h"
-}
 
 #include "rtc_base/checks.h"
 #include "rtc_base/numerics/safe_conversions.h"
diff --git a/modules/audio_processing/aecm/echo_control_mobile.cc b/modules/audio_processing/aecm/echo_control_mobile.cc
index c947563..257dfbf 100644
--- a/modules/audio_processing/aecm/echo_control_mobile.cc
+++ b/modules/audio_processing/aecm/echo_control_mobile.cc
@@ -14,10 +14,12 @@
 #include <stdio.h>
 #endif
 #include <stdlib.h>
+#include <string.h>
 
 extern "C" {
 #include "common_audio/ring_buffer.h"
 #include "common_audio/signal_processing/include/signal_processing_library.h"
+#include "modules/audio_processing/aecm/aecm_defines.h"
 }
 #include "modules/audio_processing/aecm/aecm_core.h"
 
diff --git a/modules/audio_processing/agc/agc.cc b/modules/audio_processing/agc/agc.cc
index 12c8cfb..c24db0d 100644
--- a/modules/audio_processing/agc/agc.cc
+++ b/modules/audio_processing/agc/agc.cc
@@ -12,8 +12,6 @@
 
 #include <cmath>
 #include <cstdlib>
-
-#include <algorithm>
 #include <vector>
 
 #include "modules/audio_processing/agc/loudness_histogram.h"
diff --git a/modules/audio_processing/agc/agc.h b/modules/audio_processing/agc/agc.h
index 5d34c21..abd68d5 100644
--- a/modules/audio_processing/agc/agc.h
+++ b/modules/audio_processing/agc/agc.h
@@ -17,7 +17,6 @@
 
 namespace webrtc {
 
-class AudioFrame;
 class LoudnessHistogram;
 
 class Agc {
diff --git a/modules/audio_processing/agc/agc_manager_direct.cc b/modules/audio_processing/agc/agc_manager_direct.cc
index dc6d451..5c4deec 100644
--- a/modules/audio_processing/agc/agc_manager_direct.cc
+++ b/modules/audio_processing/agc/agc_manager_direct.cc
@@ -10,6 +10,7 @@
 
 #include "modules/audio_processing/agc/agc_manager_direct.h"
 
+#include <algorithm>
 #include <cmath>
 
 #ifdef WEBRTC_AGC_DEBUG_DUMP
diff --git a/modules/audio_processing/agc/loudness_histogram.cc b/modules/audio_processing/agc/loudness_histogram.cc
index 0ed5850..cd57b82 100644
--- a/modules/audio_processing/agc/loudness_histogram.cc
+++ b/modules/audio_processing/agc/loudness_histogram.cc
@@ -10,8 +10,8 @@
 
 #include "modules/audio_processing/agc/loudness_histogram.h"
 
+#include <string.h>
 #include <cmath>
-#include <cstring>
 
 #include "rtc_base/checks.h"
 
diff --git a/modules/audio_processing/agc/loudness_histogram.h b/modules/audio_processing/agc/loudness_histogram.h
index d8ad751..b210be9 100644
--- a/modules/audio_processing/agc/loudness_histogram.h
+++ b/modules/audio_processing/agc/loudness_histogram.h
@@ -11,8 +11,7 @@
 #ifndef MODULES_AUDIO_PROCESSING_AGC_LOUDNESS_HISTOGRAM_H_
 #define MODULES_AUDIO_PROCESSING_AGC_LOUDNESS_HISTOGRAM_H_
 
-#include <string.h>
-
+#include <stdint.h>
 #include <memory>
 
 namespace webrtc {
diff --git a/modules/audio_processing/agc2/BUILD.gn b/modules/audio_processing/agc2/BUILD.gn
index 1865fde..18f2d78 100644
--- a/modules/audio_processing/agc2/BUILD.gn
+++ b/modules/audio_processing/agc2/BUILD.gn
@@ -96,12 +96,10 @@
   sources = [
     "fixed_digital_level_estimator.cc",
     "fixed_digital_level_estimator.h",
-    "fixed_gain_controller.cc",
-    "fixed_gain_controller.h",
-    "gain_curve_applier.cc",
-    "gain_curve_applier.h",
     "interpolated_gain_curve.cc",
     "interpolated_gain_curve.h",
+    "limiter.cc",
+    "limiter.h",
   ]
 
   configs += [ "..:apm_debug_dump" ]
@@ -128,6 +126,7 @@
   deps = [
     ":common",
     "..:audio_frame_view",
+    "../../../api:array_view",
     "../../../rtc_base:safe_minmax",
   ]
 }
@@ -216,11 +215,10 @@
     "compute_interpolated_gain_curve.cc",
     "compute_interpolated_gain_curve.h",
     "fixed_digital_level_estimator_unittest.cc",
-    "fixed_gain_controller_unittest.cc",
-    "gain_curve_applier_unittest.cc",
     "interpolated_gain_curve_unittest.cc",
-    "limiter.cc",
-    "limiter.h",
+    "limiter_db_gain_curve.cc",
+    "limiter_db_gain_curve.h",
+    "limiter_db_gain_curve_unittest.cc",
     "limiter_unittest.cc",
   ]
   deps = [
@@ -261,7 +259,10 @@
 
 rtc_source_set("test_utils") {
   testonly = true
-  visibility = [ ":*" ]
+  visibility = [
+    ":*",
+    "..:audio_processing_unittests",
+  ]
   sources = [
     "agc2_testing_common.cc",
     "agc2_testing_common.h",
diff --git a/modules/audio_processing/agc2/adaptive_agc.cc b/modules/audio_processing/agc2/adaptive_agc.cc
index c7346c6..795b8b5 100644
--- a/modules/audio_processing/agc2/adaptive_agc.cc
+++ b/modules/audio_processing/agc2/adaptive_agc.cc
@@ -10,12 +10,10 @@
 
 #include "modules/audio_processing/agc2/adaptive_agc.h"
 
-#include <algorithm>
-#include <numeric>
-
 #include "common_audio/include/audio_util.h"
 #include "modules/audio_processing/agc2/vad_with_level.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
+#include "rtc_base/checks.h"
 
 namespace webrtc {
 
@@ -27,6 +25,15 @@
   RTC_DCHECK(apm_data_dumper);
 }
 
+AdaptiveAgc::AdaptiveAgc(ApmDataDumper* apm_data_dumper,
+                         float extra_saturation_margin_db)
+    : speech_level_estimator_(apm_data_dumper, extra_saturation_margin_db),
+      gain_applier_(apm_data_dumper),
+      apm_data_dumper_(apm_data_dumper),
+      noise_level_estimator_(apm_data_dumper) {
+  RTC_DCHECK(apm_data_dumper);
+}
+
 AdaptiveAgc::~AdaptiveAgc() = default;
 
 void AdaptiveAgc::Process(AudioFrameView<float> float_frame,
diff --git a/modules/audio_processing/agc2/adaptive_agc.h b/modules/audio_processing/agc2/adaptive_agc.h
index 792b2bc..6c0917a 100644
--- a/modules/audio_processing/agc2/adaptive_agc.h
+++ b/modules/audio_processing/agc2/adaptive_agc.h
@@ -11,8 +11,6 @@
 #ifndef MODULES_AUDIO_PROCESSING_AGC2_ADAPTIVE_AGC_H_
 #define MODULES_AUDIO_PROCESSING_AGC2_ADAPTIVE_AGC_H_
 
-#include <memory>
-
 #include "modules/audio_processing/agc2/adaptive_digital_gain_applier.h"
 #include "modules/audio_processing/agc2/adaptive_mode_level_estimator.h"
 #include "modules/audio_processing/agc2/noise_level_estimator.h"
@@ -25,6 +23,7 @@
 class AdaptiveAgc {
  public:
   explicit AdaptiveAgc(ApmDataDumper* apm_data_dumper);
+  AdaptiveAgc(ApmDataDumper* apm_data_dumper, float extra_saturation_margin_db);
   ~AdaptiveAgc();
 
   void Process(AudioFrameView<float> float_frame, float last_audio_level);
diff --git a/modules/audio_processing/agc2/adaptive_digital_gain_applier.cc b/modules/audio_processing/agc2/adaptive_digital_gain_applier.cc
index d4560ca..6ece83b 100644
--- a/modules/audio_processing/agc2/adaptive_digital_gain_applier.cc
+++ b/modules/audio_processing/agc2/adaptive_digital_gain_applier.cc
@@ -15,6 +15,7 @@
 #include "common_audio/include/audio_util.h"
 #include "modules/audio_processing/agc2/agc2_common.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/numerics/safe_minmax.h"
 #include "system_wrappers/include/metrics.h"
 
diff --git a/modules/audio_processing/agc2/adaptive_mode_level_estimator.cc b/modules/audio_processing/agc2/adaptive_mode_level_estimator.cc
index b670f4b..138faec 100644
--- a/modules/audio_processing/agc2/adaptive_mode_level_estimator.cc
+++ b/modules/audio_processing/agc2/adaptive_mode_level_estimator.cc
@@ -12,6 +12,7 @@
 
 #include "modules/audio_processing/agc2/agc2_common.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/numerics/safe_minmax.h"
 
 namespace webrtc {
@@ -21,6 +22,12 @@
     : saturation_protector_(apm_data_dumper),
       apm_data_dumper_(apm_data_dumper) {}
 
+AdaptiveModeLevelEstimator::AdaptiveModeLevelEstimator(
+    ApmDataDumper* apm_data_dumper,
+    float extra_saturation_margin_db)
+    : saturation_protector_(apm_data_dumper, extra_saturation_margin_db),
+      apm_data_dumper_(apm_data_dumper) {}
+
 void AdaptiveModeLevelEstimator::UpdateEstimation(
     const VadWithLevel::LevelAndProbability& vad_data) {
   RTC_DCHECK_GT(vad_data.speech_rms_dbfs, -150.f);
diff --git a/modules/audio_processing/agc2/adaptive_mode_level_estimator.h b/modules/audio_processing/agc2/adaptive_mode_level_estimator.h
index 4d4180c..f887268 100644
--- a/modules/audio_processing/agc2/adaptive_mode_level_estimator.h
+++ b/modules/audio_processing/agc2/adaptive_mode_level_estimator.h
@@ -11,6 +11,9 @@
 #ifndef MODULES_AUDIO_PROCESSING_AGC2_ADAPTIVE_MODE_LEVEL_ESTIMATOR_H_
 #define MODULES_AUDIO_PROCESSING_AGC2_ADAPTIVE_MODE_LEVEL_ESTIMATOR_H_
 
+#include <stddef.h>
+
+#include "modules/audio_processing/agc2/agc2_common.h"  // kFullBufferSizeMs...
 #include "modules/audio_processing/agc2/saturation_protector.h"
 #include "modules/audio_processing/agc2/vad_with_level.h"
 
@@ -20,6 +23,8 @@
 class AdaptiveModeLevelEstimator {
  public:
   explicit AdaptiveModeLevelEstimator(ApmDataDumper* apm_data_dumper);
+  AdaptiveModeLevelEstimator(ApmDataDumper* apm_data_dumper,
+                             float extra_saturation_margin_db);
   void UpdateEstimation(const VadWithLevel::LevelAndProbability& vad_data);
   float LatestLevelEstimate() const;
   void Reset();
diff --git a/modules/audio_processing/agc2/adaptive_mode_level_estimator_agc.cc b/modules/audio_processing/agc2/adaptive_mode_level_estimator_agc.cc
index 4cee963..b7c6437 100644
--- a/modules/audio_processing/agc2/adaptive_mode_level_estimator_agc.cc
+++ b/modules/audio_processing/agc2/adaptive_mode_level_estimator_agc.cc
@@ -10,6 +10,10 @@
 
 #include "modules/audio_processing/agc2/adaptive_mode_level_estimator_agc.h"
 
+#include <cmath>
+#include <vector>
+
+#include "modules/audio_processing/agc2/agc2_common.h"
 #include "modules/audio_processing/include/audio_frame_view.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/agc2/adaptive_mode_level_estimator_agc.h b/modules/audio_processing/agc2/adaptive_mode_level_estimator_agc.h
index 484b128..6d12339 100644
--- a/modules/audio_processing/agc2/adaptive_mode_level_estimator_agc.h
+++ b/modules/audio_processing/agc2/adaptive_mode_level_estimator_agc.h
@@ -11,10 +11,12 @@
 #ifndef MODULES_AUDIO_PROCESSING_AGC2_ADAPTIVE_MODE_LEVEL_ESTIMATOR_AGC_H_
 #define MODULES_AUDIO_PROCESSING_AGC2_ADAPTIVE_MODE_LEVEL_ESTIMATOR_AGC_H_
 
-#include <vector>
+#include <stddef.h>
+#include <stdint.h>
 
 #include "modules/audio_processing/agc/agc.h"
 #include "modules/audio_processing/agc2/adaptive_mode_level_estimator.h"
+#include "modules/audio_processing/agc2/saturation_protector.h"
 #include "modules/audio_processing/agc2/vad_with_level.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/agc2/agc2_common.cc b/modules/audio_processing/agc2/agc2_common.cc
index 5da353f..af943df 100644
--- a/modules/audio_processing/agc2/agc2_common.cc
+++ b/modules/audio_processing/agc2/agc2_common.cc
@@ -10,6 +10,7 @@
 
 #include "modules/audio_processing/agc2/agc2_common.h"
 
+#include <stdio.h>
 #include <string>
 
 #include "system_wrappers/include/field_trial.h"
diff --git a/modules/audio_processing/agc2/agc2_common.h b/modules/audio_processing/agc2/agc2_common.h
index 71d33e5..55dd648 100644
--- a/modules/audio_processing/agc2/agc2_common.h
+++ b/modules/audio_processing/agc2/agc2_common.h
@@ -13,8 +13,6 @@
 
 #include <stddef.h>
 
-#include <cmath>
-
 namespace webrtc {
 
 constexpr float kMinFloatS16Value = -32768.f;
diff --git a/modules/audio_processing/agc2/biquad_filter.cc b/modules/audio_processing/agc2/biquad_filter.cc
index 9858d50..da8557c 100644
--- a/modules/audio_processing/agc2/biquad_filter.cc
+++ b/modules/audio_processing/agc2/biquad_filter.cc
@@ -10,6 +10,8 @@
 
 #include "modules/audio_processing/agc2/biquad_filter.h"
 
+#include <stddef.h>
+
 namespace webrtc {
 
 // Transposed direct form I implementation of a bi-quad filter applied to an
diff --git a/modules/audio_processing/agc2/biquad_filter.h b/modules/audio_processing/agc2/biquad_filter.h
index 284930c..3d78c07 100644
--- a/modules/audio_processing/agc2/biquad_filter.h
+++ b/modules/audio_processing/agc2/biquad_filter.h
@@ -11,6 +11,8 @@
 #ifndef MODULES_AUDIO_PROCESSING_AGC2_BIQUAD_FILTER_H_
 #define MODULES_AUDIO_PROCESSING_AGC2_BIQUAD_FILTER_H_
 
+#include <algorithm>
+
 #include "api/array_view.h"
 #include "rtc_base/arraysize.h"
 #include "rtc_base/constructormagic.h"
diff --git a/modules/audio_processing/agc2/compute_interpolated_gain_curve.cc b/modules/audio_processing/agc2/compute_interpolated_gain_curve.cc
index f395bce..bc92613 100644
--- a/modules/audio_processing/agc2/compute_interpolated_gain_curve.cc
+++ b/modules/audio_processing/agc2/compute_interpolated_gain_curve.cc
@@ -19,23 +19,24 @@
 
 #include "modules/audio_processing/agc2/agc2_common.h"
 #include "modules/audio_processing/agc2/agc2_testing_common.h"
-#include "modules/audio_processing/agc2/limiter.h"
+#include "modules/audio_processing/agc2/limiter_db_gain_curve.h"
 #include "rtc_base/checks.h"
 
 namespace webrtc {
 namespace {
 
 std::pair<double, double> ComputeLinearApproximationParams(
-    const Limiter* limiter,
+    const LimiterDbGainCurve* limiter,
     const double x) {
   const double m = limiter->GetGainFirstDerivativeLinear(x);
   const double q = limiter->GetGainLinear(x) - m * x;
   return {m, q};
 }
 
-double ComputeAreaUnderPiecewiseLinearApproximation(const Limiter* limiter,
-                                                    const double x0,
-                                                    const double x1) {
+double ComputeAreaUnderPiecewiseLinearApproximation(
+    const LimiterDbGainCurve* limiter,
+    const double x0,
+    const double x1) {
   RTC_CHECK_LT(x0, x1);
 
   // Linear approximation in x0 and x1.
@@ -60,7 +61,7 @@
 // Computes the approximation error in the limiter region for a given interval.
 // The error is computed as the difference between the areas beneath the limiter
 // curve to approximate and its linear under-approximation.
-double LimiterUnderApproximationNegativeError(const Limiter* limiter,
+double LimiterUnderApproximationNegativeError(const LimiterDbGainCurve* limiter,
                                               const double x0,
                                               const double x1) {
   const double area_limiter = limiter->GetGainIntegralLinear(x0, x1);
@@ -77,7 +78,7 @@
 // are assigned by halving intervals (starting with the whole beyond-knee region
 // as a single interval). However, even if sub-optimal, this algorithm works
 // well in practice and it is efficiently implemented using priority queues.
-std::vector<double> SampleLimiterRegion(const Limiter* limiter) {
+std::vector<double> SampleLimiterRegion(const LimiterDbGainCurve* limiter) {
   static_assert(kInterpolatedGainCurveBeyondKneePoints > 2, "");
 
   struct Interval {
@@ -131,7 +132,7 @@
 // Compute the parameters to over-approximate the knee region via linear
 // interpolation. Over-approximating is saturation-safe since the knee region is
 // convex.
-void PrecomputeKneeApproxParams(const Limiter* limiter,
+void PrecomputeKneeApproxParams(const LimiterDbGainCurve* limiter,
                                 test::InterpolatedParameters* parameters) {
   static_assert(kInterpolatedGainCurveKneePoints > 2, "");
   // Get |kInterpolatedGainCurveKneePoints| - 1 equally spaced points.
@@ -165,7 +166,7 @@
 // interpolation and greedy sampling. Under-approximating is saturation-safe
 // since the beyond-knee region is concave.
 void PrecomputeBeyondKneeApproxParams(
-    const Limiter* limiter,
+    const LimiterDbGainCurve* limiter,
     test::InterpolatedParameters* parameters) {
   // Find points on which the linear pieces are tangent to the gain curve.
   const auto samples = SampleLimiterRegion(limiter);
@@ -216,7 +217,7 @@
 
 InterpolatedParameters ComputeInterpolatedGainCurveApproximationParams() {
   InterpolatedParameters parameters;
-  Limiter limiter;
+  LimiterDbGainCurve limiter;
   parameters.computed_approximation_params_x.fill(0.0f);
   parameters.computed_approximation_params_m.fill(0.0f);
   parameters.computed_approximation_params_q.fill(0.0f);
diff --git a/modules/audio_processing/agc2/fixed_digital_level_estimator.cc b/modules/audio_processing/agc2/fixed_digital_level_estimator.cc
index 39cc764..971f4f6 100644
--- a/modules/audio_processing/agc2/fixed_digital_level_estimator.cc
+++ b/modules/audio_processing/agc2/fixed_digital_level_estimator.cc
@@ -13,6 +13,7 @@
 #include <algorithm>
 #include <cmath>
 
+#include "api/array_view.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/checks.h"
 
diff --git a/modules/audio_processing/agc2/fixed_gain_controller.cc b/modules/audio_processing/agc2/fixed_gain_controller.cc
index 0d7e3a6..ef908dc 100644
--- a/modules/audio_processing/agc2/fixed_gain_controller.cc
+++ b/modules/audio_processing/agc2/fixed_gain_controller.cc
@@ -10,13 +10,9 @@
 
 #include "modules/audio_processing/agc2/fixed_gain_controller.h"
 
-#include <algorithm>
-#include <cmath>
-
 #include "api/array_view.h"
 #include "common_audio/include/audio_util.h"
 #include "modules/audio_processing/agc2/agc2_common.h"
-#include "modules/audio_processing/agc2/interpolated_gain_curve.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
@@ -39,7 +35,7 @@
 FixedGainController::FixedGainController(ApmDataDumper* apm_data_dumper,
                                          std::string histogram_name_prefix)
     : apm_data_dumper_(apm_data_dumper),
-      gain_curve_applier_(48000, apm_data_dumper_, histogram_name_prefix) {
+      limiter_(48000, apm_data_dumper_, histogram_name_prefix) {
   // Do update histograms.xml when adding name prefixes.
   RTC_DCHECK(histogram_name_prefix == "" || histogram_name_prefix == "Test" ||
              histogram_name_prefix == "AudioMixer" ||
@@ -61,12 +57,12 @@
   // Reset the gain curve applier to quickly react on abrupt level changes
   // caused by large changes of the applied gain.
   if (previous_applied_gained != gain_to_apply_) {
-    gain_curve_applier_.Reset();
+    limiter_.Reset();
   }
 }
 
 void FixedGainController::SetSampleRate(size_t sample_rate_hz) {
-  gain_curve_applier_.SetSampleRate(sample_rate_hz);
+  limiter_.SetSampleRate(sample_rate_hz);
 }
 
 void FixedGainController::Process(AudioFrameView<float> signal) {
@@ -84,7 +80,7 @@
   }
 
   // Use the limiter.
-  gain_curve_applier_.Process(signal);
+  limiter_.Process(signal);
 
   // Dump data for debug.
   const auto channel_view = signal.channel(0);
@@ -100,6 +96,6 @@
 }
 
 float FixedGainController::LastAudioLevel() const {
-  return gain_curve_applier_.LastAudioLevel();
+  return limiter_.LastAudioLevel();
 }
 }  // namespace webrtc
diff --git a/modules/audio_processing/agc2/fixed_gain_controller.h b/modules/audio_processing/agc2/fixed_gain_controller.h
deleted file mode 100644
index ff6ab81..0000000
--- a/modules/audio_processing/agc2/fixed_gain_controller.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- *  Copyright (c) 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 MODULES_AUDIO_PROCESSING_AGC2_FIXED_GAIN_CONTROLLER_H_
-#define MODULES_AUDIO_PROCESSING_AGC2_FIXED_GAIN_CONTROLLER_H_
-
-#include "modules/audio_processing/agc2/gain_curve_applier.h"
-#include "modules/audio_processing/include/audio_frame_view.h"
-
-namespace webrtc {
-class ApmDataDumper;
-
-class FixedGainController {
- public:
-  explicit FixedGainController(ApmDataDumper* apm_data_dumper);
-  FixedGainController(ApmDataDumper* apm_data_dumper,
-                      std::string histogram_name_prefix);
-
-  void Process(AudioFrameView<float> signal);
-
-  // Rate and gain may be changed at any time (but not concurrently
-  // with any other method call).
-  void SetGain(float gain_to_apply_db);
-  void SetSampleRate(size_t sample_rate_hz);
-  float LastAudioLevel() const;
-
- private:
-  float gain_to_apply_ = 1.f;
-  ApmDataDumper* apm_data_dumper_ = nullptr;
-  GainCurveApplier gain_curve_applier_;
-};
-
-}  // namespace webrtc
-
-#endif  // MODULES_AUDIO_PROCESSING_AGC2_FIXED_GAIN_CONTROLLER_H_
diff --git a/modules/audio_processing/agc2/fixed_gain_controller_unittest.cc b/modules/audio_processing/agc2/fixed_gain_controller_unittest.cc
deleted file mode 100644
index db1732a..0000000
--- a/modules/audio_processing/agc2/fixed_gain_controller_unittest.cc
+++ /dev/null
@@ -1,258 +0,0 @@
-/*
- *  Copyright (c) 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.
- */
-
-#include "modules/audio_processing/agc2/fixed_gain_controller.h"
-
-#include "absl/memory/memory.h"
-#include "api/array_view.h"
-#include "modules/audio_processing/agc2/agc2_testing_common.h"
-#include "modules/audio_processing/agc2/vector_float_frame.h"
-#include "modules/audio_processing/logging/apm_data_dumper.h"
-#include "rtc_base/gunit.h"
-#include "system_wrappers/include/metrics.h"
-
-namespace webrtc {
-namespace {
-
-constexpr float kInputLevelLinear = 15000.f;
-
-constexpr float kGainToApplyDb = 15.f;
-
-float RunFixedGainControllerWithConstantInput(FixedGainController* fixed_gc,
-                                              const float input_level,
-                                              const size_t num_frames,
-                                              const int sample_rate) {
-  // Give time to the level etimator to converge.
-  for (size_t i = 0; i < num_frames; ++i) {
-    VectorFloatFrame vectors_with_float_frame(
-        1, rtc::CheckedDivExact(sample_rate, 100), input_level);
-    fixed_gc->Process(vectors_with_float_frame.float_frame_view());
-  }
-
-  // Process the last frame with constant input level.
-  VectorFloatFrame vectors_with_float_frame_last(
-      1, rtc::CheckedDivExact(sample_rate, 100), input_level);
-  fixed_gc->Process(vectors_with_float_frame_last.float_frame_view());
-
-  // Return the last sample from the last processed frame.
-  const auto channel =
-      vectors_with_float_frame_last.float_frame_view().channel(0);
-  return channel[channel.size() - 1];
-}
-
-std::unique_ptr<ApmDataDumper> GetApmDataDumper() {
-  return absl::make_unique<ApmDataDumper>(0);
-}
-
-std::unique_ptr<FixedGainController> CreateFixedGainController(
-    float gain_to_apply,
-    size_t rate,
-    std::string histogram_name_prefix,
-    ApmDataDumper* test_data_dumper) {
-  std::unique_ptr<FixedGainController> fgc =
-      absl::make_unique<FixedGainController>(test_data_dumper,
-                                             histogram_name_prefix);
-  fgc->SetGain(gain_to_apply);
-  fgc->SetSampleRate(rate);
-  return fgc;
-}
-
-std::unique_ptr<FixedGainController> CreateFixedGainController(
-    float gain_to_apply,
-    size_t rate,
-    ApmDataDumper* test_data_dumper) {
-  return CreateFixedGainController(gain_to_apply, rate, "", test_data_dumper);
-}
-
-}  // namespace
-
-TEST(AutomaticGainController2FixedDigital, CreateUse) {
-  const int kSampleRate = 44000;
-  auto test_data_dumper = GetApmDataDumper();
-  std::unique_ptr<FixedGainController> fixed_gc = CreateFixedGainController(
-      kGainToApplyDb, kSampleRate, test_data_dumper.get());
-  VectorFloatFrame vectors_with_float_frame(
-      1, rtc::CheckedDivExact(kSampleRate, 100), kInputLevelLinear);
-  auto float_frame = vectors_with_float_frame.float_frame_view();
-  fixed_gc->Process(float_frame);
-  const auto channel = float_frame.channel(0);
-  EXPECT_LT(kInputLevelLinear, channel[0]);
-}
-
-TEST(AutomaticGainController2FixedDigital, CheckSaturationBehaviorWithLimiter) {
-  const float kInputLevel = 32767.f;
-  const size_t kNumFrames = 5;
-  const size_t kSampleRate = 42000;
-
-  auto test_data_dumper = GetApmDataDumper();
-
-  const auto gains_no_saturation =
-      test::LinSpace(0.1, test::kLimiterMaxInputLevelDbFs - 0.01, 10);
-  for (const auto gain_db : gains_no_saturation) {
-    // Since |test::kLimiterMaxInputLevelDbFs| > |gain_db|, the
-    // limiter will not saturate the signal.
-    std::unique_ptr<FixedGainController> fixed_gc_no_saturation =
-        CreateFixedGainController(gain_db, kSampleRate, test_data_dumper.get());
-
-    // Saturation not expected.
-    SCOPED_TRACE(std::to_string(gain_db));
-    EXPECT_LT(
-        RunFixedGainControllerWithConstantInput(
-            fixed_gc_no_saturation.get(), kInputLevel, kNumFrames, kSampleRate),
-        32767.f);
-  }
-
-  const auto gains_saturation =
-      test::LinSpace(test::kLimiterMaxInputLevelDbFs + 0.01, 10, 10);
-  for (const auto gain_db : gains_saturation) {
-    // Since |test::kLimiterMaxInputLevelDbFs| < |gain|, the limiter
-    // will saturate the signal.
-    std::unique_ptr<FixedGainController> fixed_gc_saturation =
-        CreateFixedGainController(gain_db, kSampleRate, test_data_dumper.get());
-
-    // Saturation expected.
-    SCOPED_TRACE(std::to_string(gain_db));
-    EXPECT_FLOAT_EQ(
-        RunFixedGainControllerWithConstantInput(
-            fixed_gc_saturation.get(), kInputLevel, kNumFrames, kSampleRate),
-        32767.f);
-  }
-}
-
-TEST(AutomaticGainController2FixedDigital,
-     CheckSaturationBehaviorWithLimiterSingleSample) {
-  const float kInputLevel = 32767.f;
-  const size_t kNumFrames = 5;
-  const size_t kSampleRate = 8000;
-
-  auto test_data_dumper = GetApmDataDumper();
-
-  const auto gains_no_saturation =
-      test::LinSpace(0.1, test::kLimiterMaxInputLevelDbFs - 0.01, 10);
-  for (const auto gain_db : gains_no_saturation) {
-    // Since |gain| > |test::kLimiterMaxInputLevelDbFs|, the limiter will
-    // not saturate the signal.
-    std::unique_ptr<FixedGainController> fixed_gc_no_saturation =
-        CreateFixedGainController(gain_db, kSampleRate, test_data_dumper.get());
-
-    // Saturation not expected.
-    SCOPED_TRACE(std::to_string(gain_db));
-    EXPECT_LT(
-        RunFixedGainControllerWithConstantInput(
-            fixed_gc_no_saturation.get(), kInputLevel, kNumFrames, kSampleRate),
-        32767.f);
-  }
-
-  const auto gains_saturation =
-      test::LinSpace(test::kLimiterMaxInputLevelDbFs + 0.01, 10, 10);
-  for (const auto gain_db : gains_saturation) {
-    // Singe |gain| < |test::kLimiterMaxInputLevelDbFs|, the limiter will
-    // saturate the signal.
-    std::unique_ptr<FixedGainController> fixed_gc_saturation =
-        CreateFixedGainController(gain_db, kSampleRate, test_data_dumper.get());
-
-    // Saturation expected.
-    SCOPED_TRACE(std::to_string(gain_db));
-    EXPECT_FLOAT_EQ(
-        RunFixedGainControllerWithConstantInput(
-            fixed_gc_saturation.get(), kInputLevel, kNumFrames, kSampleRate),
-        32767.f);
-  }
-}
-
-TEST(AutomaticGainController2FixedDigital, GainShouldChangeOnSetGain) {
-  constexpr float kInputLevel = 1000.f;
-  constexpr size_t kNumFrames = 5;
-  constexpr size_t kSampleRate = 8000;
-  constexpr float kGainDbNoChange = 0.f;
-  constexpr float kGainDbFactor10 = 20.f;
-
-  auto test_data_dumper = GetApmDataDumper();
-  std::unique_ptr<FixedGainController> fixed_gc_no_saturation =
-      CreateFixedGainController(kGainDbNoChange, kSampleRate,
-                                test_data_dumper.get());
-
-  // Signal level is unchanged with 0 db gain.
-  EXPECT_FLOAT_EQ(
-      RunFixedGainControllerWithConstantInput(
-          fixed_gc_no_saturation.get(), kInputLevel, kNumFrames, kSampleRate),
-      kInputLevel);
-
-  fixed_gc_no_saturation->SetGain(kGainDbFactor10);
-
-  // +20db should increase signal by a factor of 10.
-  EXPECT_FLOAT_EQ(
-      RunFixedGainControllerWithConstantInput(
-          fixed_gc_no_saturation.get(), kInputLevel, kNumFrames, kSampleRate),
-      kInputLevel * 10);
-}
-
-TEST(AutomaticGainController2FixedDigital,
-     SetGainShouldBeFastAndTimeInvariant) {
-  // Number of frames required for the fixed gain controller to adapt on the
-  // input signal when the gain changes.
-  constexpr size_t kNumFrames = 5;
-
-  constexpr float kInputLevel = 1000.f;
-  constexpr size_t kSampleRate = 8000;
-  constexpr float kGainDbLow = 0.f;
-  constexpr float kGainDbHigh = 40.f;
-  static_assert(kGainDbLow < kGainDbHigh, "");
-
-  auto test_data_dumper = GetApmDataDumper();
-  std::unique_ptr<FixedGainController> fixed_gc = CreateFixedGainController(
-      kGainDbLow, kSampleRate, test_data_dumper.get());
-
-  fixed_gc->SetGain(kGainDbLow);
-  const float output_level_pre = RunFixedGainControllerWithConstantInput(
-      fixed_gc.get(), kInputLevel, kNumFrames, kSampleRate);
-
-  fixed_gc->SetGain(kGainDbHigh);
-  RunFixedGainControllerWithConstantInput(fixed_gc.get(), kInputLevel,
-                                          kNumFrames, kSampleRate);
-
-  fixed_gc->SetGain(kGainDbLow);
-  const float output_level_post = RunFixedGainControllerWithConstantInput(
-      fixed_gc.get(), kInputLevel, kNumFrames, kSampleRate);
-
-  EXPECT_EQ(output_level_pre, output_level_post);
-}
-
-TEST(AutomaticGainController2FixedDigital, RegionHistogramIsUpdated) {
-  constexpr size_t kSampleRate = 8000;
-  constexpr float kGainDb = 0.f;
-  constexpr float kInputLevel = 1000.f;
-  constexpr size_t kNumFrames = 5;
-
-  metrics::Reset();
-
-  auto test_data_dumper = GetApmDataDumper();
-  std::unique_ptr<FixedGainController> fixed_gc_no_saturation =
-      CreateFixedGainController(kGainDb, kSampleRate, "Test",
-                                test_data_dumper.get());
-
-  static_cast<void>(RunFixedGainControllerWithConstantInput(
-      fixed_gc_no_saturation.get(), kInputLevel, kNumFrames, kSampleRate));
-
-  // Destroying FixedGainController should cause the last limiter region to be
-  // logged.
-  fixed_gc_no_saturation.reset();
-
-  EXPECT_EQ(1, metrics::NumSamples(
-                   "WebRTC.Audio.Test.FixedDigitalGainCurveRegion.Identity"));
-  EXPECT_EQ(0, metrics::NumSamples(
-                   "WebRTC.Audio.Test.FixedDigitalGainCurveRegion.Knee"));
-  EXPECT_EQ(0, metrics::NumSamples(
-                   "WebRTC.Audio.Test.FixedDigitalGainCurveRegion.Limiter"));
-  EXPECT_EQ(0, metrics::NumSamples(
-                   "WebRTC.Audio.Test.FixedDigitalGainCurveRegion.Saturation"));
-}
-
-}  // namespace webrtc
diff --git a/modules/audio_processing/agc2/gain_applier.cc b/modules/audio_processing/agc2/gain_applier.cc
index 38eb1de..8c43717 100644
--- a/modules/audio_processing/agc2/gain_applier.cc
+++ b/modules/audio_processing/agc2/gain_applier.cc
@@ -10,6 +10,7 @@
 
 #include "modules/audio_processing/agc2/gain_applier.h"
 
+#include "api/array_view.h"
 #include "modules/audio_processing/agc2/agc2_common.h"
 #include "rtc_base/numerics/safe_minmax.h"
 
diff --git a/modules/audio_processing/agc2/gain_applier.h b/modules/audio_processing/agc2/gain_applier.h
index e2567b1..7f9f00e 100644
--- a/modules/audio_processing/agc2/gain_applier.h
+++ b/modules/audio_processing/agc2/gain_applier.h
@@ -11,6 +11,8 @@
 #ifndef MODULES_AUDIO_PROCESSING_AGC2_GAIN_APPLIER_H_
 #define MODULES_AUDIO_PROCESSING_AGC2_GAIN_APPLIER_H_
 
+#include <stddef.h>
+
 #include "modules/audio_processing/include/audio_frame_view.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/agc2/gain_curve_applier.cc b/modules/audio_processing/agc2/gain_curve_applier.cc
deleted file mode 100644
index 1eca21b..0000000
--- a/modules/audio_processing/agc2/gain_curve_applier.cc
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- *  Copyright (c) 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.
- */
-
-#include "modules/audio_processing/agc2/gain_curve_applier.h"
-
-#include <algorithm>
-#include <array>
-#include <cmath>
-
-#include "api/array_view.h"
-#include "modules/audio_processing/logging/apm_data_dumper.h"
-#include "rtc_base/checks.h"
-
-namespace webrtc {
-namespace {
-
-// This constant affects the way scaling factors are interpolated for the first
-// sub-frame of a frame. Only in the case in which the first sub-frame has an
-// estimated level which is greater than the that of the previous analyzed
-// sub-frame, linear interpolation is replaced with a power function which
-// reduces the chances of over-shooting (and hence saturation), however reducing
-// the fixed gain effectiveness.
-constexpr float kAttackFirstSubframeInterpolationPower = 8.f;
-
-void InterpolateFirstSubframe(float last_factor,
-                              float current_factor,
-                              rtc::ArrayView<float> subframe) {
-  const auto n = subframe.size();
-  constexpr auto p = kAttackFirstSubframeInterpolationPower;
-  for (size_t i = 0; i < n; ++i) {
-    subframe[i] = std::pow(1.f - i / n, p) * (last_factor - current_factor) +
-                  current_factor;
-  }
-}
-
-void ComputePerSampleSubframeFactors(
-    const std::array<float, kSubFramesInFrame + 1>& scaling_factors,
-    size_t samples_per_channel,
-    rtc::ArrayView<float> per_sample_scaling_factors) {
-  const size_t num_subframes = scaling_factors.size() - 1;
-  const size_t subframe_size =
-      rtc::CheckedDivExact(samples_per_channel, num_subframes);
-
-  // Handle first sub-frame differently in case of attack.
-  const bool is_attack = scaling_factors[0] > scaling_factors[1];
-  if (is_attack) {
-    InterpolateFirstSubframe(
-        scaling_factors[0], scaling_factors[1],
-        rtc::ArrayView<float>(
-            per_sample_scaling_factors.subview(0, subframe_size)));
-  }
-
-  for (size_t i = is_attack ? 1 : 0; i < num_subframes; ++i) {
-    const size_t subframe_start = i * subframe_size;
-    const float scaling_start = scaling_factors[i];
-    const float scaling_end = scaling_factors[i + 1];
-    const float scaling_diff = (scaling_end - scaling_start) / subframe_size;
-    for (size_t j = 0; j < subframe_size; ++j) {
-      per_sample_scaling_factors[subframe_start + j] =
-          scaling_start + scaling_diff * j;
-    }
-  }
-}
-
-void ScaleSamples(rtc::ArrayView<const float> per_sample_scaling_factors,
-                  AudioFrameView<float> signal) {
-  const size_t samples_per_channel = signal.samples_per_channel();
-  RTC_DCHECK_EQ(samples_per_channel, per_sample_scaling_factors.size());
-  for (size_t i = 0; i < signal.num_channels(); ++i) {
-    auto channel = signal.channel(i);
-    for (size_t j = 0; j < samples_per_channel; ++j) {
-      channel[j] *= per_sample_scaling_factors[j];
-    }
-  }
-}
-
-}  // namespace
-
-GainCurveApplier::GainCurveApplier(size_t sample_rate_hz,
-                                   ApmDataDumper* apm_data_dumper,
-                                   std::string histogram_name)
-    : interp_gain_curve_(apm_data_dumper, histogram_name),
-      level_estimator_(sample_rate_hz, apm_data_dumper),
-      apm_data_dumper_(apm_data_dumper) {}
-
-GainCurveApplier::~GainCurveApplier() = default;
-
-void GainCurveApplier::Process(AudioFrameView<float> signal) {
-  const auto level_estimate = level_estimator_.ComputeLevel(signal);
-
-  RTC_DCHECK_EQ(level_estimate.size() + 1, scaling_factors_.size());
-  scaling_factors_[0] = last_scaling_factor_;
-  std::transform(level_estimate.begin(), level_estimate.end(),
-                 scaling_factors_.begin() + 1, [this](float x) {
-                   return interp_gain_curve_.LookUpGainToApply(x);
-                 });
-
-  const size_t samples_per_channel = signal.samples_per_channel();
-  RTC_DCHECK_LE(samples_per_channel, kMaximalNumberOfSamplesPerChannel);
-
-  auto per_sample_scaling_factors = rtc::ArrayView<float>(
-      &per_sample_scaling_factors_[0], samples_per_channel);
-  ComputePerSampleSubframeFactors(scaling_factors_, samples_per_channel,
-                                  per_sample_scaling_factors);
-  ScaleSamples(per_sample_scaling_factors, signal);
-
-  last_scaling_factor_ = scaling_factors_.back();
-
-  // Dump data for debug.
-  apm_data_dumper_->DumpRaw("agc2_gain_curve_applier_scaling_factors",
-                            samples_per_channel,
-                            per_sample_scaling_factors_.data());
-}
-
-InterpolatedGainCurve::Stats GainCurveApplier::GetGainCurveStats() const {
-  return interp_gain_curve_.get_stats();
-}
-
-void GainCurveApplier::SetSampleRate(size_t sample_rate_hz) {
-  level_estimator_.SetSampleRate(sample_rate_hz);
-  // Check that per_sample_scaling_factors_ is large enough.
-  RTC_DCHECK_LE(sample_rate_hz,
-                kMaximalNumberOfSamplesPerChannel * 1000 / kFrameDurationMs);
-}
-
-void GainCurveApplier::Reset() {
-  level_estimator_.Reset();
-}
-
-float GainCurveApplier::LastAudioLevel() const {
-  return level_estimator_.LastAudioLevel();
-}
-
-}  // namespace webrtc
diff --git a/modules/audio_processing/agc2/gain_curve_applier.h b/modules/audio_processing/agc2/gain_curve_applier.h
deleted file mode 100644
index e0be19e..0000000
--- a/modules/audio_processing/agc2/gain_curve_applier.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- *  Copyright (c) 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 MODULES_AUDIO_PROCESSING_AGC2_GAIN_CURVE_APPLIER_H_
-#define MODULES_AUDIO_PROCESSING_AGC2_GAIN_CURVE_APPLIER_H_
-
-#include <vector>
-
-#include "modules/audio_processing/agc2/fixed_digital_level_estimator.h"
-#include "modules/audio_processing/agc2/interpolated_gain_curve.h"
-#include "modules/audio_processing/include/audio_frame_view.h"
-#include "rtc_base/constructormagic.h"
-
-namespace webrtc {
-class ApmDataDumper;
-
-class GainCurveApplier {
- public:
-  GainCurveApplier(size_t sample_rate_hz,
-                   ApmDataDumper* apm_data_dumper,
-                   std::string histogram_name_prefix);
-
-  ~GainCurveApplier();
-
-  void Process(AudioFrameView<float> signal);
-  InterpolatedGainCurve::Stats GetGainCurveStats() const;
-
-  // Supported rates must be
-  // * supported by FixedDigitalLevelEstimator
-  // * below kMaximalNumberOfSamplesPerChannel*1000/kFrameDurationMs
-  //   so that samples_per_channel fit in the
-  //   per_sample_scaling_factors_ array.
-  void SetSampleRate(size_t sample_rate_hz);
-
-  // Resets the internal state.
-  void Reset();
-
-  float LastAudioLevel() const;
-
- private:
-  const InterpolatedGainCurve interp_gain_curve_;
-  FixedDigitalLevelEstimator level_estimator_;
-  ApmDataDumper* const apm_data_dumper_ = nullptr;
-
-  // Work array containing the sub-frame scaling factors to be interpolated.
-  std::array<float, kSubFramesInFrame + 1> scaling_factors_ = {};
-  std::array<float, kMaximalNumberOfSamplesPerChannel>
-      per_sample_scaling_factors_ = {};
-  float last_scaling_factor_ = 1.f;
-
-  RTC_DISALLOW_COPY_AND_ASSIGN(GainCurveApplier);
-};
-
-}  // namespace webrtc
-
-#endif  // MODULES_AUDIO_PROCESSING_AGC2_GAIN_CURVE_APPLIER_H_
diff --git a/modules/audio_processing/agc2/gain_curve_applier_unittest.cc b/modules/audio_processing/agc2/gain_curve_applier_unittest.cc
deleted file mode 100644
index 0f75f62..0000000
--- a/modules/audio_processing/agc2/gain_curve_applier_unittest.cc
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- *  Copyright (c) 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.
- */
-
-#include "modules/audio_processing/agc2/gain_curve_applier.h"
-
-#include "common_audio/include/audio_util.h"
-#include "modules/audio_processing/agc2/agc2_common.h"
-#include "modules/audio_processing/agc2/agc2_testing_common.h"
-#include "modules/audio_processing/agc2/vector_float_frame.h"
-#include "modules/audio_processing/logging/apm_data_dumper.h"
-#include "rtc_base/gunit.h"
-
-namespace webrtc {
-
-TEST(GainCurveApplier, GainCurveApplierShouldConstructAndRun) {
-  const int sample_rate_hz = 48000;
-  ApmDataDumper apm_data_dumper(0);
-
-  GainCurveApplier gain_curve_applier(sample_rate_hz, &apm_data_dumper, "");
-
-  VectorFloatFrame vectors_with_float_frame(1, sample_rate_hz / 100,
-                                            kMaxAbsFloatS16Value);
-  gain_curve_applier.Process(vectors_with_float_frame.float_frame_view());
-}
-
-TEST(GainCurveApplier, OutputVolumeAboveThreshold) {
-  const int sample_rate_hz = 48000;
-  const float input_level =
-      (kMaxAbsFloatS16Value + DbfsToFloatS16(test::kLimiterMaxInputLevelDbFs)) /
-      2.f;
-  ApmDataDumper apm_data_dumper(0);
-
-  GainCurveApplier gain_curve_applier(sample_rate_hz, &apm_data_dumper, "");
-
-  // Give the level estimator time to adapt.
-  for (int i = 0; i < 5; ++i) {
-    VectorFloatFrame vectors_with_float_frame(1, sample_rate_hz / 100,
-                                              input_level);
-    gain_curve_applier.Process(vectors_with_float_frame.float_frame_view());
-  }
-
-  VectorFloatFrame vectors_with_float_frame(1, sample_rate_hz / 100,
-                                            input_level);
-  gain_curve_applier.Process(vectors_with_float_frame.float_frame_view());
-  rtc::ArrayView<const float> channel =
-      vectors_with_float_frame.float_frame_view().channel(0);
-
-  for (const auto& sample : channel) {
-    EXPECT_LT(0.9f * kMaxAbsFloatS16Value, sample);
-  }
-}
-
-}  // namespace webrtc
diff --git a/modules/audio_processing/agc2/interpolated_gain_curve.cc b/modules/audio_processing/agc2/interpolated_gain_curve.cc
index 73e6a8e..f5d6b47 100644
--- a/modules/audio_processing/agc2/interpolated_gain_curve.cc
+++ b/modules/audio_processing/agc2/interpolated_gain_curve.cc
@@ -10,10 +10,12 @@
 
 #include "modules/audio_processing/agc2/interpolated_gain_curve.h"
 
+#include <algorithm>
+#include <iterator>
+
 #include "modules/audio_processing/agc2/agc2_common.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/checks.h"
-#include "rtc_base/logging.h"
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/agc2/interpolated_gain_curve_unittest.cc b/modules/audio_processing/agc2/interpolated_gain_curve_unittest.cc
index dd69631..a8e0f23 100644
--- a/modules/audio_processing/agc2/interpolated_gain_curve_unittest.cc
+++ b/modules/audio_processing/agc2/interpolated_gain_curve_unittest.cc
@@ -9,6 +9,7 @@
  */
 
 #include <array>
+#include <type_traits>
 #include <vector>
 
 #include "api/array_view.h"
@@ -16,7 +17,7 @@
 #include "modules/audio_processing/agc2/agc2_common.h"
 #include "modules/audio_processing/agc2/compute_interpolated_gain_curve.h"
 #include "modules/audio_processing/agc2/interpolated_gain_curve.h"
-#include "modules/audio_processing/agc2/limiter.h"
+#include "modules/audio_processing/agc2/limiter_db_gain_curve.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/gunit.h"
@@ -27,7 +28,8 @@
 constexpr double kLevelEpsilon = 1e-2 * kMaxAbsFloatS16Value;
 constexpr float kInterpolatedGainCurveTolerance = 1.f / 32768.f;
 ApmDataDumper apm_data_dumper(0);
-const Limiter limiter;
+static_assert(std::is_trivially_destructible<LimiterDbGainCurve>::value, "");
+const LimiterDbGainCurve limiter;
 
 }  // namespace
 
diff --git a/modules/audio_processing/agc2/limiter.cc b/modules/audio_processing/agc2/limiter.cc
index d2b9877..1589f07 100644
--- a/modules/audio_processing/agc2/limiter.cc
+++ b/modules/audio_processing/agc2/limiter.cc
@@ -10,128 +10,141 @@
 
 #include "modules/audio_processing/agc2/limiter.h"
 
+#include <algorithm>
+#include <array>
 #include <cmath>
 
-#include "common_audio/include/audio_util.h"
+#include "api/array_view.h"
 #include "modules/audio_processing/agc2/agc2_common.h"
+#include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/checks.h"
+#include "rtc_base/numerics/safe_minmax.h"
 
 namespace webrtc {
 namespace {
 
-double ComputeKneeStart(double max_input_level_db,
-                        double knee_smoothness_db,
-                        double compression_ratio) {
-  RTC_CHECK_LT((compression_ratio - 1.0) * knee_smoothness_db /
-                   (2.0 * compression_ratio),
-               max_input_level_db);
-  return -knee_smoothness_db / 2.0 -
-         max_input_level_db / (compression_ratio - 1.0);
+// This constant affects the way scaling factors are interpolated for the first
+// sub-frame of a frame. Only in the case in which the first sub-frame has an
+// estimated level which is greater than the that of the previous analyzed
+// sub-frame, linear interpolation is replaced with a power function which
+// reduces the chances of over-shooting (and hence saturation), however reducing
+// the fixed gain effectiveness.
+constexpr float kAttackFirstSubframeInterpolationPower = 8.f;
+
+void InterpolateFirstSubframe(float last_factor,
+                              float current_factor,
+                              rtc::ArrayView<float> subframe) {
+  const auto n = subframe.size();
+  constexpr auto p = kAttackFirstSubframeInterpolationPower;
+  for (size_t i = 0; i < n; ++i) {
+    subframe[i] = std::pow(1.f - i / n, p) * (last_factor - current_factor) +
+                  current_factor;
+  }
 }
 
-std::array<double, 3> ComputeKneeRegionPolynomial(double knee_start_dbfs,
-                                                  double knee_smoothness_db,
-                                                  double compression_ratio) {
-  const double a = (1.0 - compression_ratio) /
-                   (2.0 * knee_smoothness_db * compression_ratio);
-  const double b = 1.0 - 2.0 * a * knee_start_dbfs;
-  const double c = a * knee_start_dbfs * knee_start_dbfs;
-  return {{a, b, c}};
+void ComputePerSampleSubframeFactors(
+    const std::array<float, kSubFramesInFrame + 1>& scaling_factors,
+    size_t samples_per_channel,
+    rtc::ArrayView<float> per_sample_scaling_factors) {
+  const size_t num_subframes = scaling_factors.size() - 1;
+  const size_t subframe_size =
+      rtc::CheckedDivExact(samples_per_channel, num_subframes);
+
+  // Handle first sub-frame differently in case of attack.
+  const bool is_attack = scaling_factors[0] > scaling_factors[1];
+  if (is_attack) {
+    InterpolateFirstSubframe(
+        scaling_factors[0], scaling_factors[1],
+        rtc::ArrayView<float>(
+            per_sample_scaling_factors.subview(0, subframe_size)));
+  }
+
+  for (size_t i = is_attack ? 1 : 0; i < num_subframes; ++i) {
+    const size_t subframe_start = i * subframe_size;
+    const float scaling_start = scaling_factors[i];
+    const float scaling_end = scaling_factors[i + 1];
+    const float scaling_diff = (scaling_end - scaling_start) / subframe_size;
+    for (size_t j = 0; j < subframe_size; ++j) {
+      per_sample_scaling_factors[subframe_start + j] =
+          scaling_start + scaling_diff * j;
+    }
+  }
 }
 
-double ComputeLimiterD1(double max_input_level_db, double compression_ratio) {
-  return (std::pow(10.0, -max_input_level_db / (20.0 * compression_ratio)) *
-          (1.0 - compression_ratio) / compression_ratio) /
-         kMaxAbsFloatS16Value;
+void ScaleSamples(rtc::ArrayView<const float> per_sample_scaling_factors,
+                  AudioFrameView<float> signal) {
+  const size_t samples_per_channel = signal.samples_per_channel();
+  RTC_DCHECK_EQ(samples_per_channel, per_sample_scaling_factors.size());
+  for (size_t i = 0; i < signal.num_channels(); ++i) {
+    auto channel = signal.channel(i);
+    for (size_t j = 0; j < samples_per_channel; ++j) {
+      channel[j] = rtc::SafeClamp(channel[j] * per_sample_scaling_factors[j],
+                                  kMinFloatS16Value, kMaxFloatS16Value);
+    }
+  }
 }
 
-constexpr double ComputeLimiterD2(double compression_ratio) {
-  return (1.0 - 2.0 * compression_ratio) / compression_ratio;
-}
-
-double ComputeLimiterI2(double max_input_level_db,
-                        double compression_ratio,
-                        double gain_curve_limiter_i1) {
-  RTC_CHECK_NE(gain_curve_limiter_i1, 0.f);
-  return std::pow(10.0, -max_input_level_db / (20.0 * compression_ratio)) /
-         gain_curve_limiter_i1 /
-         std::pow(kMaxAbsFloatS16Value, gain_curve_limiter_i1 - 1);
+void CheckLimiterSampleRate(size_t sample_rate_hz) {
+  // Check that per_sample_scaling_factors_ is large enough.
+  RTC_DCHECK_LE(sample_rate_hz,
+                kMaximalNumberOfSamplesPerChannel * 1000 / kFrameDurationMs);
 }
 
 }  // namespace
 
-Limiter::Limiter()
-    : max_input_level_linear_(DbfsToFloatS16(max_input_level_db_)),
-      knee_start_dbfs_(ComputeKneeStart(max_input_level_db_,
-                                        knee_smoothness_db_,
-                                        compression_ratio_)),
-      knee_start_linear_(DbfsToFloatS16(knee_start_dbfs_)),
-      limiter_start_dbfs_(knee_start_dbfs_ + knee_smoothness_db_),
-      limiter_start_linear_(DbfsToFloatS16(limiter_start_dbfs_)),
-      knee_region_polynomial_(ComputeKneeRegionPolynomial(knee_start_dbfs_,
-                                                          knee_smoothness_db_,
-                                                          compression_ratio_)),
-      gain_curve_limiter_d1_(
-          ComputeLimiterD1(max_input_level_db_, compression_ratio_)),
-      gain_curve_limiter_d2_(ComputeLimiterD2(compression_ratio_)),
-      gain_curve_limiter_i1_(1.0 / compression_ratio_),
-      gain_curve_limiter_i2_(ComputeLimiterI2(max_input_level_db_,
-                                              compression_ratio_,
-                                              gain_curve_limiter_i1_)) {
-  static_assert(knee_smoothness_db_ > 0.0f, "");
-  static_assert(compression_ratio_ > 1.0f, "");
-  RTC_CHECK_GE(max_input_level_db_, knee_start_dbfs_ + knee_smoothness_db_);
+Limiter::Limiter(size_t sample_rate_hz,
+                 ApmDataDumper* apm_data_dumper,
+                 std::string histogram_name)
+    : interp_gain_curve_(apm_data_dumper, histogram_name),
+      level_estimator_(sample_rate_hz, apm_data_dumper),
+      apm_data_dumper_(apm_data_dumper) {
+  CheckLimiterSampleRate(sample_rate_hz);
 }
 
-constexpr double Limiter::max_input_level_db_;
-constexpr double Limiter::knee_smoothness_db_;
-constexpr double Limiter::compression_ratio_;
+Limiter::~Limiter() = default;
 
-double Limiter::GetOutputLevelDbfs(double input_level_dbfs) const {
-  if (input_level_dbfs < knee_start_dbfs_) {
-    return input_level_dbfs;
-  } else if (input_level_dbfs < limiter_start_dbfs_) {
-    return GetKneeRegionOutputLevelDbfs(input_level_dbfs);
-  }
-  return GetCompressorRegionOutputLevelDbfs(input_level_dbfs);
+void Limiter::Process(AudioFrameView<float> signal) {
+  const auto level_estimate = level_estimator_.ComputeLevel(signal);
+
+  RTC_DCHECK_EQ(level_estimate.size() + 1, scaling_factors_.size());
+  scaling_factors_[0] = last_scaling_factor_;
+  std::transform(level_estimate.begin(), level_estimate.end(),
+                 scaling_factors_.begin() + 1, [this](float x) {
+                   return interp_gain_curve_.LookUpGainToApply(x);
+                 });
+
+  const size_t samples_per_channel = signal.samples_per_channel();
+  RTC_DCHECK_LE(samples_per_channel, kMaximalNumberOfSamplesPerChannel);
+
+  auto per_sample_scaling_factors = rtc::ArrayView<float>(
+      &per_sample_scaling_factors_[0], samples_per_channel);
+  ComputePerSampleSubframeFactors(scaling_factors_, samples_per_channel,
+                                  per_sample_scaling_factors);
+  ScaleSamples(per_sample_scaling_factors, signal);
+
+  last_scaling_factor_ = scaling_factors_.back();
+
+  // Dump data for debug.
+  apm_data_dumper_->DumpRaw("agc2_gain_curve_applier_scaling_factors",
+                            samples_per_channel,
+                            per_sample_scaling_factors_.data());
 }
 
-double Limiter::GetGainLinear(double input_level_linear) const {
-  if (input_level_linear < knee_start_linear_) {
-    return 1.0;
-  }
-  return DbfsToFloatS16(
-             GetOutputLevelDbfs(FloatS16ToDbfs(input_level_linear))) /
-         input_level_linear;
+InterpolatedGainCurve::Stats Limiter::GetGainCurveStats() const {
+  return interp_gain_curve_.get_stats();
 }
 
-// Computes the first derivative of GetGainLinear() in |x|.
-double Limiter::GetGainFirstDerivativeLinear(double x) const {
-  // Beyond-knee region only.
-  RTC_CHECK_GE(x, limiter_start_linear_ - 1e-7 * kMaxAbsFloatS16Value);
-  return gain_curve_limiter_d1_ *
-         std::pow(x / kMaxAbsFloatS16Value, gain_curve_limiter_d2_);
+void Limiter::SetSampleRate(size_t sample_rate_hz) {
+  CheckLimiterSampleRate(sample_rate_hz);
+  level_estimator_.SetSampleRate(sample_rate_hz);
 }
 
-// Computes the integral of GetGainLinear() in the range [x0, x1].
-double Limiter::GetGainIntegralLinear(double x0, double x1) const {
-  RTC_CHECK_LE(x0, x1);                     // Valid interval.
-  RTC_CHECK_GE(x0, limiter_start_linear_);  // Beyond-knee region only.
-  auto limiter_integral = [this](const double& x) {
-    return gain_curve_limiter_i2_ * std::pow(x, gain_curve_limiter_i1_);
-  };
-  return limiter_integral(x1) - limiter_integral(x0);
+void Limiter::Reset() {
+  level_estimator_.Reset();
 }
 
-double Limiter::GetKneeRegionOutputLevelDbfs(double input_level_dbfs) const {
-  return knee_region_polynomial_[0] * input_level_dbfs * input_level_dbfs +
-         knee_region_polynomial_[1] * input_level_dbfs +
-         knee_region_polynomial_[2];
-}
-
-double Limiter::GetCompressorRegionOutputLevelDbfs(
-    double input_level_dbfs) const {
-  return (input_level_dbfs - max_input_level_db_) / compression_ratio_;
+float Limiter::LastAudioLevel() const {
+  return level_estimator_.LastAudioLevel();
 }
 
 }  // namespace webrtc
diff --git a/modules/audio_processing/agc2/limiter.h b/modules/audio_processing/agc2/limiter.h
index f350bae..1e0ab71 100644
--- a/modules/audio_processing/agc2/limiter.h
+++ b/modules/audio_processing/agc2/limiter.h
@@ -11,62 +11,52 @@
 #ifndef MODULES_AUDIO_PROCESSING_AGC2_LIMITER_H_
 #define MODULES_AUDIO_PROCESSING_AGC2_LIMITER_H_
 
-#include <array>
+#include <string>
+#include <vector>
 
-#include "modules/audio_processing/agc2/agc2_testing_common.h"
+#include "modules/audio_processing/agc2/fixed_digital_level_estimator.h"
+#include "modules/audio_processing/agc2/interpolated_gain_curve.h"
+#include "modules/audio_processing/include/audio_frame_view.h"
+#include "rtc_base/constructormagic.h"
 
 namespace webrtc {
+class ApmDataDumper;
 
-// A class for computing gain curve parameters. The gain curve is
-// defined by constants kLimiterMaxInputLevelDbFs, kLimiterKneeSmoothnessDb,
-// kLimiterCompressionRatio. The curve consints of one linear part,
-// one quadratic polynomial part and another linear part. The
-// constants define the parameters of the parts.
 class Limiter {
  public:
-  Limiter();
+  Limiter(size_t sample_rate_hz,
+          ApmDataDumper* apm_data_dumper,
+          std::string histogram_name_prefix);
+  Limiter(const Limiter& limiter) = delete;
+  Limiter& operator=(const Limiter& limiter) = delete;
+  ~Limiter();
 
-  double max_input_level_db() const { return max_input_level_db_; }
-  double max_input_level_linear() const { return max_input_level_linear_; }
-  double knee_start_linear() const { return knee_start_linear_; }
-  double limiter_start_linear() const { return limiter_start_linear_; }
+  // Applies limiter and hard-clipping to |signal|.
+  void Process(AudioFrameView<float> signal);
+  InterpolatedGainCurve::Stats GetGainCurveStats() const;
 
-  // These methods can be marked 'constexpr' in C++ 14.
-  double GetOutputLevelDbfs(double input_level_dbfs) const;
-  double GetGainLinear(double input_level_linear) const;
-  double GetGainFirstDerivativeLinear(double x) const;
-  double GetGainIntegralLinear(double x0, double x1) const;
+  // Supported rates must be
+  // * supported by FixedDigitalLevelEstimator
+  // * below kMaximalNumberOfSamplesPerChannel*1000/kFrameDurationMs
+  //   so that samples_per_channel fit in the
+  //   per_sample_scaling_factors_ array.
+  void SetSampleRate(size_t sample_rate_hz);
+
+  // Resets the internal state.
+  void Reset();
+
+  float LastAudioLevel() const;
 
  private:
-  double GetKneeRegionOutputLevelDbfs(double input_level_dbfs) const;
-  double GetCompressorRegionOutputLevelDbfs(double input_level_dbfs) const;
+  const InterpolatedGainCurve interp_gain_curve_;
+  FixedDigitalLevelEstimator level_estimator_;
+  ApmDataDumper* const apm_data_dumper_ = nullptr;
 
-  static constexpr double max_input_level_db_ = test::kLimiterMaxInputLevelDbFs;
-  static constexpr double knee_smoothness_db_ = test::kLimiterKneeSmoothnessDb;
-  static constexpr double compression_ratio_ = test::kLimiterCompressionRatio;
-
-  const double max_input_level_linear_;
-
-  // Do not modify signal with level <= knee_start_dbfs_.
-  const double knee_start_dbfs_;
-  const double knee_start_linear_;
-
-  // The upper end of the knee region, which is between knee_start_dbfs_ and
-  // limiter_start_dbfs_.
-  const double limiter_start_dbfs_;
-  const double limiter_start_linear_;
-
-  // Coefficients {a, b, c} of the knee region polynomial
-  // ax^2 + bx + c in the DB scale.
-  const std::array<double, 3> knee_region_polynomial_;
-
-  // Parameters for the computation of the first derivative of GetGainLinear().
-  const double gain_curve_limiter_d1_;
-  const double gain_curve_limiter_d2_;
-
-  // Parameters for the computation of the integral of GetGainLinear().
-  const double gain_curve_limiter_i1_;
-  const double gain_curve_limiter_i2_;
+  // Work array containing the sub-frame scaling factors to be interpolated.
+  std::array<float, kSubFramesInFrame + 1> scaling_factors_ = {};
+  std::array<float, kMaximalNumberOfSamplesPerChannel>
+      per_sample_scaling_factors_ = {};
+  float last_scaling_factor_ = 1.f;
 };
 
 }  // namespace webrtc
diff --git a/modules/audio_processing/agc2/limiter_db_gain_curve.cc b/modules/audio_processing/agc2/limiter_db_gain_curve.cc
new file mode 100644
index 0000000..d55ed5d
--- /dev/null
+++ b/modules/audio_processing/agc2/limiter_db_gain_curve.cc
@@ -0,0 +1,138 @@
+/*
+ *  Copyright (c) 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.
+ */
+
+#include "modules/audio_processing/agc2/limiter_db_gain_curve.h"
+
+#include <cmath>
+
+#include "common_audio/include/audio_util.h"
+#include "modules/audio_processing/agc2/agc2_common.h"
+#include "rtc_base/checks.h"
+
+namespace webrtc {
+namespace {
+
+double ComputeKneeStart(double max_input_level_db,
+                        double knee_smoothness_db,
+                        double compression_ratio) {
+  RTC_CHECK_LT((compression_ratio - 1.0) * knee_smoothness_db /
+                   (2.0 * compression_ratio),
+               max_input_level_db);
+  return -knee_smoothness_db / 2.0 -
+         max_input_level_db / (compression_ratio - 1.0);
+}
+
+std::array<double, 3> ComputeKneeRegionPolynomial(double knee_start_dbfs,
+                                                  double knee_smoothness_db,
+                                                  double compression_ratio) {
+  const double a = (1.0 - compression_ratio) /
+                   (2.0 * knee_smoothness_db * compression_ratio);
+  const double b = 1.0 - 2.0 * a * knee_start_dbfs;
+  const double c = a * knee_start_dbfs * knee_start_dbfs;
+  return {{a, b, c}};
+}
+
+double ComputeLimiterD1(double max_input_level_db, double compression_ratio) {
+  return (std::pow(10.0, -max_input_level_db / (20.0 * compression_ratio)) *
+          (1.0 - compression_ratio) / compression_ratio) /
+         kMaxAbsFloatS16Value;
+}
+
+constexpr double ComputeLimiterD2(double compression_ratio) {
+  return (1.0 - 2.0 * compression_ratio) / compression_ratio;
+}
+
+double ComputeLimiterI2(double max_input_level_db,
+                        double compression_ratio,
+                        double gain_curve_limiter_i1) {
+  RTC_CHECK_NE(gain_curve_limiter_i1, 0.f);
+  return std::pow(10.0, -max_input_level_db / (20.0 * compression_ratio)) /
+         gain_curve_limiter_i1 /
+         std::pow(kMaxAbsFloatS16Value, gain_curve_limiter_i1 - 1);
+}
+
+}  // namespace
+
+LimiterDbGainCurve::LimiterDbGainCurve()
+    : max_input_level_linear_(DbfsToFloatS16(max_input_level_db_)),
+      knee_start_dbfs_(ComputeKneeStart(max_input_level_db_,
+                                        knee_smoothness_db_,
+                                        compression_ratio_)),
+      knee_start_linear_(DbfsToFloatS16(knee_start_dbfs_)),
+      limiter_start_dbfs_(knee_start_dbfs_ + knee_smoothness_db_),
+      limiter_start_linear_(DbfsToFloatS16(limiter_start_dbfs_)),
+      knee_region_polynomial_(ComputeKneeRegionPolynomial(knee_start_dbfs_,
+                                                          knee_smoothness_db_,
+                                                          compression_ratio_)),
+      gain_curve_limiter_d1_(
+          ComputeLimiterD1(max_input_level_db_, compression_ratio_)),
+      gain_curve_limiter_d2_(ComputeLimiterD2(compression_ratio_)),
+      gain_curve_limiter_i1_(1.0 / compression_ratio_),
+      gain_curve_limiter_i2_(ComputeLimiterI2(max_input_level_db_,
+                                              compression_ratio_,
+                                              gain_curve_limiter_i1_)) {
+  static_assert(knee_smoothness_db_ > 0.0f, "");
+  static_assert(compression_ratio_ > 1.0f, "");
+  RTC_CHECK_GE(max_input_level_db_, knee_start_dbfs_ + knee_smoothness_db_);
+}
+
+constexpr double LimiterDbGainCurve::max_input_level_db_;
+constexpr double LimiterDbGainCurve::knee_smoothness_db_;
+constexpr double LimiterDbGainCurve::compression_ratio_;
+
+double LimiterDbGainCurve::GetOutputLevelDbfs(double input_level_dbfs) const {
+  if (input_level_dbfs < knee_start_dbfs_) {
+    return input_level_dbfs;
+  } else if (input_level_dbfs < limiter_start_dbfs_) {
+    return GetKneeRegionOutputLevelDbfs(input_level_dbfs);
+  }
+  return GetCompressorRegionOutputLevelDbfs(input_level_dbfs);
+}
+
+double LimiterDbGainCurve::GetGainLinear(double input_level_linear) const {
+  if (input_level_linear < knee_start_linear_) {
+    return 1.0;
+  }
+  return DbfsToFloatS16(
+             GetOutputLevelDbfs(FloatS16ToDbfs(input_level_linear))) /
+         input_level_linear;
+}
+
+// Computes the first derivative of GetGainLinear() in |x|.
+double LimiterDbGainCurve::GetGainFirstDerivativeLinear(double x) const {
+  // Beyond-knee region only.
+  RTC_CHECK_GE(x, limiter_start_linear_ - 1e-7 * kMaxAbsFloatS16Value);
+  return gain_curve_limiter_d1_ *
+         std::pow(x / kMaxAbsFloatS16Value, gain_curve_limiter_d2_);
+}
+
+// Computes the integral of GetGainLinear() in the range [x0, x1].
+double LimiterDbGainCurve::GetGainIntegralLinear(double x0, double x1) const {
+  RTC_CHECK_LE(x0, x1);                     // Valid interval.
+  RTC_CHECK_GE(x0, limiter_start_linear_);  // Beyond-knee region only.
+  auto limiter_integral = [this](const double& x) {
+    return gain_curve_limiter_i2_ * std::pow(x, gain_curve_limiter_i1_);
+  };
+  return limiter_integral(x1) - limiter_integral(x0);
+}
+
+double LimiterDbGainCurve::GetKneeRegionOutputLevelDbfs(
+    double input_level_dbfs) const {
+  return knee_region_polynomial_[0] * input_level_dbfs * input_level_dbfs +
+         knee_region_polynomial_[1] * input_level_dbfs +
+         knee_region_polynomial_[2];
+}
+
+double LimiterDbGainCurve::GetCompressorRegionOutputLevelDbfs(
+    double input_level_dbfs) const {
+  return (input_level_dbfs - max_input_level_db_) / compression_ratio_;
+}
+
+}  // namespace webrtc
diff --git a/modules/audio_processing/agc2/limiter_db_gain_curve.h b/modules/audio_processing/agc2/limiter_db_gain_curve.h
new file mode 100644
index 0000000..9086e26
--- /dev/null
+++ b/modules/audio_processing/agc2/limiter_db_gain_curve.h
@@ -0,0 +1,76 @@
+/*
+ *  Copyright (c) 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 MODULES_AUDIO_PROCESSING_AGC2_LIMITER_DB_GAIN_CURVE_H_
+#define MODULES_AUDIO_PROCESSING_AGC2_LIMITER_DB_GAIN_CURVE_H_
+
+#include <array>
+
+#include "modules/audio_processing/agc2/agc2_testing_common.h"
+
+namespace webrtc {
+
+// A class for computing a limiter gain curve (in dB scale) given a set of
+// hard-coded parameters (namely, kLimiterDbGainCurveMaxInputLevelDbFs,
+// kLimiterDbGainCurveKneeSmoothnessDb, and
+// kLimiterDbGainCurveCompressionRatio). The generated curve consists of four
+// regions: identity (linear), knee (quadratic polynomial), compression
+// (linear), saturation (linear). The aforementioned constants are used to shape
+// the different regions.
+class LimiterDbGainCurve {
+ public:
+  LimiterDbGainCurve();
+
+  double max_input_level_db() const { return max_input_level_db_; }
+  double max_input_level_linear() const { return max_input_level_linear_; }
+  double knee_start_linear() const { return knee_start_linear_; }
+  double limiter_start_linear() const { return limiter_start_linear_; }
+
+  // These methods can be marked 'constexpr' in C++ 14.
+  double GetOutputLevelDbfs(double input_level_dbfs) const;
+  double GetGainLinear(double input_level_linear) const;
+  double GetGainFirstDerivativeLinear(double x) const;
+  double GetGainIntegralLinear(double x0, double x1) const;
+
+ private:
+  double GetKneeRegionOutputLevelDbfs(double input_level_dbfs) const;
+  double GetCompressorRegionOutputLevelDbfs(double input_level_dbfs) const;
+
+  static constexpr double max_input_level_db_ = test::kLimiterMaxInputLevelDbFs;
+  static constexpr double knee_smoothness_db_ = test::kLimiterKneeSmoothnessDb;
+  static constexpr double compression_ratio_ = test::kLimiterCompressionRatio;
+
+  const double max_input_level_linear_;
+
+  // Do not modify signal with level <= knee_start_dbfs_.
+  const double knee_start_dbfs_;
+  const double knee_start_linear_;
+
+  // The upper end of the knee region, which is between knee_start_dbfs_ and
+  // limiter_start_dbfs_.
+  const double limiter_start_dbfs_;
+  const double limiter_start_linear_;
+
+  // Coefficients {a, b, c} of the knee region polynomial
+  // ax^2 + bx + c in the DB scale.
+  const std::array<double, 3> knee_region_polynomial_;
+
+  // Parameters for the computation of the first derivative of GetGainLinear().
+  const double gain_curve_limiter_d1_;
+  const double gain_curve_limiter_d2_;
+
+  // Parameters for the computation of the integral of GetGainLinear().
+  const double gain_curve_limiter_i1_;
+  const double gain_curve_limiter_i2_;
+};
+
+}  // namespace webrtc
+
+#endif  // MODULES_AUDIO_PROCESSING_AGC2_LIMITER_DB_GAIN_CURVE_H_
diff --git a/modules/audio_processing/agc2/limiter_db_gain_curve_unittest.cc b/modules/audio_processing/agc2/limiter_db_gain_curve_unittest.cc
new file mode 100644
index 0000000..049c8d5
--- /dev/null
+++ b/modules/audio_processing/agc2/limiter_db_gain_curve_unittest.cc
@@ -0,0 +1,60 @@
+/*
+ *  Copyright (c) 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.
+ */
+
+#include "modules/audio_processing/agc2/limiter_db_gain_curve.h"
+
+#include "rtc_base/gunit.h"
+
+namespace webrtc {
+
+TEST(FixedDigitalGainController2Limiter, ConstructDestruct) {
+  LimiterDbGainCurve l;
+}
+
+TEST(FixedDigitalGainController2Limiter, GainCurveShouldBeMonotone) {
+  LimiterDbGainCurve l;
+  float last_output_level = 0.f;
+  bool has_last_output_level = false;
+  for (float level = -90.f; level <= l.max_input_level_db(); level += 0.5f) {
+    const float current_output_level = l.GetOutputLevelDbfs(level);
+    if (!has_last_output_level) {
+      last_output_level = current_output_level;
+      has_last_output_level = true;
+    }
+    EXPECT_LE(last_output_level, current_output_level);
+    last_output_level = current_output_level;
+  }
+}
+
+TEST(FixedDigitalGainController2Limiter, GainCurveShouldBeContinuous) {
+  LimiterDbGainCurve l;
+  float last_output_level = 0.f;
+  bool has_last_output_level = false;
+  constexpr float kMaxDelta = 0.5f;
+  for (float level = -90.f; level <= l.max_input_level_db(); level += 0.5f) {
+    const float current_output_level = l.GetOutputLevelDbfs(level);
+    if (!has_last_output_level) {
+      last_output_level = current_output_level;
+      has_last_output_level = true;
+    }
+    EXPECT_LE(current_output_level, last_output_level + kMaxDelta);
+    last_output_level = current_output_level;
+  }
+}
+
+TEST(FixedDigitalGainController2Limiter, OutputGainShouldBeLessThanFullScale) {
+  LimiterDbGainCurve l;
+  for (float level = -90.f; level <= l.max_input_level_db(); level += 0.5f) {
+    const float current_output_level = l.GetOutputLevelDbfs(level);
+    EXPECT_LE(current_output_level, 0.f);
+  }
+}
+
+}  // namespace webrtc
diff --git a/modules/audio_processing/agc2/limiter_unittest.cc b/modules/audio_processing/agc2/limiter_unittest.cc
index 7079812..e662a7f 100644
--- a/modules/audio_processing/agc2/limiter_unittest.cc
+++ b/modules/audio_processing/agc2/limiter_unittest.cc
@@ -10,50 +10,50 @@
 
 #include "modules/audio_processing/agc2/limiter.h"
 
+#include "common_audio/include/audio_util.h"
+#include "modules/audio_processing/agc2/agc2_common.h"
+#include "modules/audio_processing/agc2/agc2_testing_common.h"
+#include "modules/audio_processing/agc2/vector_float_frame.h"
+#include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/gunit.h"
 
 namespace webrtc {
 
-TEST(FixedDigitalGainController2Limiter, ConstructDestruct) {
-  Limiter l;
+TEST(Limiter, LimiterShouldConstructAndRun) {
+  const int sample_rate_hz = 48000;
+  ApmDataDumper apm_data_dumper(0);
+
+  Limiter limiter(sample_rate_hz, &apm_data_dumper, "");
+
+  VectorFloatFrame vectors_with_float_frame(1, sample_rate_hz / 100,
+                                            kMaxAbsFloatS16Value);
+  limiter.Process(vectors_with_float_frame.float_frame_view());
 }
 
-TEST(FixedDigitalGainController2Limiter, GainCurveShouldBeMonotone) {
-  Limiter l;
-  float last_output_level = 0.f;
-  bool has_last_output_level = false;
-  for (float level = -90.f; level <= l.max_input_level_db(); level += 0.5f) {
-    const float current_output_level = l.GetOutputLevelDbfs(level);
-    if (!has_last_output_level) {
-      last_output_level = current_output_level;
-      has_last_output_level = true;
-    }
-    EXPECT_LE(last_output_level, current_output_level);
-    last_output_level = current_output_level;
+TEST(Limiter, OutputVolumeAboveThreshold) {
+  const int sample_rate_hz = 48000;
+  const float input_level =
+      (kMaxAbsFloatS16Value + DbfsToFloatS16(test::kLimiterMaxInputLevelDbFs)) /
+      2.f;
+  ApmDataDumper apm_data_dumper(0);
+
+  Limiter limiter(sample_rate_hz, &apm_data_dumper, "");
+
+  // Give the level estimator time to adapt.
+  for (int i = 0; i < 5; ++i) {
+    VectorFloatFrame vectors_with_float_frame(1, sample_rate_hz / 100,
+                                              input_level);
+    limiter.Process(vectors_with_float_frame.float_frame_view());
   }
-}
 
-TEST(FixedDigitalGainController2Limiter, GainCurveShouldBeContinuous) {
-  Limiter l;
-  float last_output_level = 0.f;
-  bool has_last_output_level = false;
-  constexpr float kMaxDelta = 0.5f;
-  for (float level = -90.f; level <= l.max_input_level_db(); level += 0.5f) {
-    const float current_output_level = l.GetOutputLevelDbfs(level);
-    if (!has_last_output_level) {
-      last_output_level = current_output_level;
-      has_last_output_level = true;
-    }
-    EXPECT_LE(current_output_level, last_output_level + kMaxDelta);
-    last_output_level = current_output_level;
-  }
-}
+  VectorFloatFrame vectors_with_float_frame(1, sample_rate_hz / 100,
+                                            input_level);
+  limiter.Process(vectors_with_float_frame.float_frame_view());
+  rtc::ArrayView<const float> channel =
+      vectors_with_float_frame.float_frame_view().channel(0);
 
-TEST(FixedDigitalGainController2Limiter, OutputGainShouldBeLessThanFullScale) {
-  Limiter l;
-  for (float level = -90.f; level <= l.max_input_level_db(); level += 0.5f) {
-    const float current_output_level = l.GetOutputLevelDbfs(level);
-    EXPECT_LE(current_output_level, 0.f);
+  for (const auto& sample : channel) {
+    EXPECT_LT(0.9f * kMaxAbsFloatS16Value, sample);
   }
 }
 
diff --git a/modules/audio_processing/agc2/noise_level_estimator.cc b/modules/audio_processing/agc2/noise_level_estimator.cc
index d9aaf1f..6e43672 100644
--- a/modules/audio_processing/agc2/noise_level_estimator.cc
+++ b/modules/audio_processing/agc2/noise_level_estimator.cc
@@ -10,13 +10,15 @@
 
 #include "modules/audio_processing/agc2/noise_level_estimator.h"
 
-#include <math.h>
-
+#include <stddef.h>
 #include <algorithm>
+#include <cmath>
 #include <numeric>
 
+#include "api/array_view.h"
 #include "common_audio/include/audio_util.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
+#include "rtc_base/checks.h"
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/agc2/noise_spectrum_estimator.cc b/modules/audio_processing/agc2/noise_spectrum_estimator.cc
index 9e08126..5735faf 100644
--- a/modules/audio_processing/agc2/noise_spectrum_estimator.cc
+++ b/modules/audio_processing/agc2/noise_spectrum_estimator.cc
@@ -16,6 +16,7 @@
 #include "api/array_view.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/arraysize.h"
+#include "rtc_base/checks.h"
 
 namespace webrtc {
 namespace {
diff --git a/modules/audio_processing/agc2/rnn_vad/features_extraction.cc b/modules/audio_processing/agc2/rnn_vad/features_extraction.cc
index 8ab5673..8f472a5 100644
--- a/modules/audio_processing/agc2/rnn_vad/features_extraction.cc
+++ b/modules/audio_processing/agc2/rnn_vad/features_extraction.cc
@@ -10,6 +10,8 @@
 
 #include "modules/audio_processing/agc2/rnn_vad/features_extraction.h"
 
+#include <array>
+
 #include "modules/audio_processing/agc2/rnn_vad/lp_residual.h"
 #include "rtc_base/checks.h"
 
diff --git a/modules/audio_processing/agc2/rnn_vad/features_extraction.h b/modules/audio_processing/agc2/rnn_vad/features_extraction.h
index 1f63885..ce5cce1 100644
--- a/modules/audio_processing/agc2/rnn_vad/features_extraction.h
+++ b/modules/audio_processing/agc2/rnn_vad/features_extraction.h
@@ -11,12 +11,12 @@
 #ifndef MODULES_AUDIO_PROCESSING_AGC2_RNN_VAD_FEATURES_EXTRACTION_H_
 #define MODULES_AUDIO_PROCESSING_AGC2_RNN_VAD_FEATURES_EXTRACTION_H_
 
-#include <memory>
 #include <vector>
 
 #include "api/array_view.h"
 #include "modules/audio_processing/agc2/biquad_filter.h"
 #include "modules/audio_processing/agc2/rnn_vad/common.h"
+#include "modules/audio_processing/agc2/rnn_vad/pitch_info.h"
 #include "modules/audio_processing/agc2/rnn_vad/pitch_search.h"
 #include "modules/audio_processing/agc2/rnn_vad/sequence_buffer.h"
 #include "modules/audio_processing/agc2/rnn_vad/spectral_features.h"
diff --git a/modules/audio_processing/agc2/rnn_vad/fft_util.cc b/modules/audio_processing/agc2/rnn_vad/fft_util.cc
index 1017400..a1c5dac 100644
--- a/modules/audio_processing/agc2/rnn_vad/fft_util.cc
+++ b/modules/audio_processing/agc2/rnn_vad/fft_util.cc
@@ -10,6 +10,7 @@
 
 #include "modules/audio_processing/agc2/rnn_vad/fft_util.h"
 
+#include <stddef.h>
 #include <cmath>
 
 #include "rtc_base/checks.h"
diff --git a/modules/audio_processing/agc2/rnn_vad/lp_residual.h b/modules/audio_processing/agc2/rnn_vad/lp_residual.h
index bffafd2..cddedca 100644
--- a/modules/audio_processing/agc2/rnn_vad/lp_residual.h
+++ b/modules/audio_processing/agc2/rnn_vad/lp_residual.h
@@ -11,6 +11,8 @@
 #ifndef MODULES_AUDIO_PROCESSING_AGC2_RNN_VAD_LP_RESIDUAL_H_
 #define MODULES_AUDIO_PROCESSING_AGC2_RNN_VAD_LP_RESIDUAL_H_
 
+#include <stddef.h>
+
 #include "api/array_view.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/agc2/rnn_vad/pitch_search.cc b/modules/audio_processing/agc2/rnn_vad/pitch_search.cc
index 1f8859d..aa0b751 100644
--- a/modules/audio_processing/agc2/rnn_vad/pitch_search.cc
+++ b/modules/audio_processing/agc2/rnn_vad/pitch_search.cc
@@ -10,6 +10,11 @@
 
 #include "modules/audio_processing/agc2/rnn_vad/pitch_search.h"
 
+#include <array>
+#include <cstddef>
+
+#include "rtc_base/checks.h"
+
 namespace webrtc {
 namespace rnn_vad {
 
diff --git a/modules/audio_processing/agc2/rnn_vad/pitch_search_internal.cc b/modules/audio_processing/agc2/rnn_vad/pitch_search_internal.cc
index b7b44d2..32ee8c0 100644
--- a/modules/audio_processing/agc2/rnn_vad/pitch_search_internal.cc
+++ b/modules/audio_processing/agc2/rnn_vad/pitch_search_internal.cc
@@ -10,10 +10,12 @@
 
 #include "modules/audio_processing/agc2/rnn_vad/pitch_search_internal.h"
 
+#include <stdlib.h>
 #include <algorithm>
 #include <cmath>
+#include <complex>
+#include <cstddef>
 #include <numeric>
-#include <utility>
 
 #include "modules/audio_processing/agc2/rnn_vad/common.h"
 #include "rtc_base/checks.h"
diff --git a/modules/audio_processing/agc2/rnn_vad/pitch_search_internal.h b/modules/audio_processing/agc2/rnn_vad/pitch_search_internal.h
index 75f7f17..bb747bb 100644
--- a/modules/audio_processing/agc2/rnn_vad/pitch_search_internal.h
+++ b/modules/audio_processing/agc2/rnn_vad/pitch_search_internal.h
@@ -11,6 +11,7 @@
 #ifndef MODULES_AUDIO_PROCESSING_AGC2_RNN_VAD_PITCH_SEARCH_INTERNAL_H_
 #define MODULES_AUDIO_PROCESSING_AGC2_RNN_VAD_PITCH_SEARCH_INTERNAL_H_
 
+#include <stddef.h>
 #include <array>
 
 #include "api/array_view.h"
diff --git a/modules/audio_processing/agc2/rnn_vad/rnn.h b/modules/audio_processing/agc2/rnn_vad/rnn.h
index b3a3b9c..a7d057d 100644
--- a/modules/audio_processing/agc2/rnn_vad/rnn.h
+++ b/modules/audio_processing/agc2/rnn_vad/rnn.h
@@ -11,6 +11,8 @@
 #ifndef MODULES_AUDIO_PROCESSING_AGC2_RNN_VAD_RNN_H_
 #define MODULES_AUDIO_PROCESSING_AGC2_RNN_VAD_RNN_H_
 
+#include <stddef.h>
+#include <sys/types.h>
 #include <array>
 
 #include "api/array_view.h"
diff --git a/modules/audio_processing/agc2/rnn_vad/rnn_vad_tool.cc b/modules/audio_processing/agc2/rnn_vad/rnn_vad_tool.cc
index 5fba0bf..b66dfd6 100644
--- a/modules/audio_processing/agc2/rnn_vad/rnn_vad_tool.cc
+++ b/modules/audio_processing/agc2/rnn_vad/rnn_vad_tool.cc
@@ -25,22 +25,22 @@
 namespace test {
 namespace {
 
-DEFINE_string(i, "", "Path to the input wav file");
+WEBRTC_DEFINE_string(i, "", "Path to the input wav file");
 std::string InputWavFile() {
   return static_cast<std::string>(FLAG_i);
 }
 
-DEFINE_string(f, "", "Path to the output features file");
+WEBRTC_DEFINE_string(f, "", "Path to the output features file");
 std::string OutputFeaturesFile() {
   return static_cast<std::string>(FLAG_f);
 }
 
-DEFINE_string(o, "", "Path to the output VAD probabilities file");
+WEBRTC_DEFINE_string(o, "", "Path to the output VAD probabilities file");
 std::string OutputVadProbsFile() {
   return static_cast<std::string>(FLAG_o);
 }
 
-DEFINE_bool(help, false, "Prints this message");
+WEBRTC_DEFINE_bool(help, false, "Prints this message");
 
 }  // namespace
 
diff --git a/modules/audio_processing/agc2/rnn_vad/spectral_features.h b/modules/audio_processing/agc2/rnn_vad/spectral_features.h
index bedd7ab..5c33dcd 100644
--- a/modules/audio_processing/agc2/rnn_vad/spectral_features.h
+++ b/modules/audio_processing/agc2/rnn_vad/spectral_features.h
@@ -13,6 +13,7 @@
 
 #include <array>
 #include <complex>
+#include <cstddef>
 #include <vector>
 
 #include "api/array_view.h"
diff --git a/modules/audio_processing/agc2/rnn_vad/spectral_features_internal.cc b/modules/audio_processing/agc2/rnn_vad/spectral_features_internal.cc
index 9f4e218..74211fe 100644
--- a/modules/audio_processing/agc2/rnn_vad/spectral_features_internal.cc
+++ b/modules/audio_processing/agc2/rnn_vad/spectral_features_internal.cc
@@ -12,6 +12,7 @@
 
 #include <algorithm>
 #include <cmath>
+#include <cstddef>
 
 #include "rtc_base/checks.h"
 
diff --git a/modules/audio_processing/agc2/rnn_vad/spectral_features_internal.h b/modules/audio_processing/agc2/rnn_vad/spectral_features_internal.h
index 45bb382..edfd18c 100644
--- a/modules/audio_processing/agc2/rnn_vad/spectral_features_internal.h
+++ b/modules/audio_processing/agc2/rnn_vad/spectral_features_internal.h
@@ -11,6 +11,7 @@
 #ifndef MODULES_AUDIO_PROCESSING_AGC2_RNN_VAD_SPECTRAL_FEATURES_INTERNAL_H_
 #define MODULES_AUDIO_PROCESSING_AGC2_RNN_VAD_SPECTRAL_FEATURES_INTERNAL_H_
 
+#include <stddef.h>
 #include <array>
 #include <complex>
 
diff --git a/modules/audio_processing/agc2/saturation_protector.cc b/modules/audio_processing/agc2/saturation_protector.cc
index 0895583..94a52ea 100644
--- a/modules/audio_processing/agc2/saturation_protector.cc
+++ b/modules/audio_processing/agc2/saturation_protector.cc
@@ -11,6 +11,7 @@
 #include "modules/audio_processing/agc2/saturation_protector.h"
 
 #include <algorithm>
+#include <iterator>
 
 #include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/numerics/safe_minmax.h"
@@ -56,9 +57,14 @@
 }
 
 SaturationProtector::SaturationProtector(ApmDataDumper* apm_data_dumper)
+    : SaturationProtector(apm_data_dumper, GetExtraSaturationMarginOffsetDb()) {
+}
+
+SaturationProtector::SaturationProtector(ApmDataDumper* apm_data_dumper,
+                                         float extra_saturation_margin_db)
     : apm_data_dumper_(apm_data_dumper),
       last_margin_(GetInitialSaturationMarginDb()),
-      extra_saturation_margin_db_(GetExtraSaturationMarginOffsetDb()) {}
+      extra_saturation_margin_db_(extra_saturation_margin_db) {}
 
 void SaturationProtector::UpdateMargin(
     const VadWithLevel::LevelAndProbability& vad_data,
diff --git a/modules/audio_processing/agc2/saturation_protector.h b/modules/audio_processing/agc2/saturation_protector.h
index 1705f6a..e637469 100644
--- a/modules/audio_processing/agc2/saturation_protector.h
+++ b/modules/audio_processing/agc2/saturation_protector.h
@@ -24,6 +24,9 @@
  public:
   explicit SaturationProtector(ApmDataDumper* apm_data_dumper);
 
+  SaturationProtector(ApmDataDumper* apm_data_dumper,
+                      float extra_saturation_margin_db);
+
   // Update and return margin estimate. This method should be called
   // whenever a frame is reliably classified as 'speech'.
   //
@@ -60,7 +63,7 @@
 
   float last_margin_;
   PeakEnveloper peak_enveloper_;
-  float extra_saturation_margin_db_;
+  const float extra_saturation_margin_db_;
 };
 
 }  // namespace webrtc
diff --git a/modules/audio_processing/agc2/signal_classifier.cc b/modules/audio_processing/agc2/signal_classifier.cc
index 0ec3414..8778c49 100644
--- a/modules/audio_processing/agc2/signal_classifier.cc
+++ b/modules/audio_processing/agc2/signal_classifier.cc
@@ -18,7 +18,7 @@
 #include "modules/audio_processing/agc2/down_sampler.h"
 #include "modules/audio_processing/agc2/noise_spectrum_estimator.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
-#include "rtc_base/constructormagic.h"
+#include "rtc_base/checks.h"
 
 namespace webrtc {
 namespace {
diff --git a/modules/audio_processing/agc2/vad_with_level.cc b/modules/audio_processing/agc2/vad_with_level.cc
index decfacd..52970df 100644
--- a/modules/audio_processing/agc2/vad_with_level.cc
+++ b/modules/audio_processing/agc2/vad_with_level.cc
@@ -11,10 +11,12 @@
 #include "modules/audio_processing/agc2/vad_with_level.h"
 
 #include <algorithm>
+#include <array>
+#include <cmath>
 
+#include "api/array_view.h"
 #include "common_audio/include/audio_util.h"
 #include "modules/audio_processing/agc2/rnn_vad/common.h"
-#include "rtc_base/checks.h"
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/agc2/vad_with_level.h b/modules/audio_processing/agc2/vad_with_level.h
index 67a00ce..b0ad868 100644
--- a/modules/audio_processing/agc2/vad_with_level.h
+++ b/modules/audio_processing/agc2/vad_with_level.h
@@ -11,7 +11,6 @@
 #ifndef MODULES_AUDIO_PROCESSING_AGC2_VAD_WITH_LEVEL_H_
 #define MODULES_AUDIO_PROCESSING_AGC2_VAD_WITH_LEVEL_H_
 
-#include "api/array_view.h"
 #include "common_audio/resampler/include/push_resampler.h"
 #include "modules/audio_processing/agc2/rnn_vad/features_extraction.h"
 #include "modules/audio_processing/agc2/rnn_vad/rnn.h"
diff --git a/modules/audio_processing/audio_buffer.cc b/modules/audio_processing/audio_buffer.cc
index f163f5a..0c38a4f 100644
--- a/modules/audio_processing/audio_buffer.cc
+++ b/modules/audio_processing/audio_buffer.cc
@@ -10,11 +10,13 @@
 
 #include "modules/audio_processing/audio_buffer.h"
 
+#include <string.h>
+#include <cstdint>
+
 #include "common_audio/channel_buffer.h"
 #include "common_audio/include/audio_util.h"
 #include "common_audio/resampler/push_sinc_resampler.h"
-#include "common_audio/signal_processing/include/signal_processing_library.h"
-#include "modules/audio_processing/common.h"
+#include "modules/audio_processing/splitting_filter.h"
 #include "rtc_base/checks.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/audio_buffer.h b/modules/audio_processing/audio_buffer.h
index ade3eec..469646e 100644
--- a/modules/audio_processing/audio_buffer.h
+++ b/modules/audio_processing/audio_buffer.h
@@ -11,18 +11,21 @@
 #ifndef MODULES_AUDIO_PROCESSING_AUDIO_BUFFER_H_
 #define MODULES_AUDIO_PROCESSING_AUDIO_BUFFER_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <memory>
 #include <vector>
 
 #include "api/audio/audio_frame.h"
 #include "common_audio/channel_buffer.h"
 #include "modules/audio_processing/include/audio_processing.h"
-#include "modules/audio_processing/splitting_filter.h"
+#include "rtc_base/gtest_prod_util.h"
 
 namespace webrtc {
 
-class PushSincResampler;
 class IFChannelBuffer;
+class PushSincResampler;
+class SplittingFilter;
 
 enum Band { kBand0To8kHz = 0, kBand8To16kHz = 1, kBand16To24kHz = 2 };
 
diff --git a/modules/audio_processing/audio_processing_impl.cc b/modules/audio_processing/audio_processing_impl.cc
index b9153fa..3764647 100644
--- a/modules/audio_processing/audio_processing_impl.cc
+++ b/modules/audio_processing/audio_processing_impl.cc
@@ -10,15 +10,16 @@
 
 #include "modules/audio_processing/audio_processing_impl.h"
 
-#include <math.h>
 #include <algorithm>
+#include <cstdint>
 #include <string>
+#include <type_traits>
+#include <utility>
 
+#include "absl/types/optional.h"
+#include "api/array_view.h"
 #include "common_audio/audio_converter.h"
-#include "common_audio/channel_buffer.h"
 #include "common_audio/include/audio_util.h"
-#include "common_audio/signal_processing/include/signal_processing_library.h"
-#include "modules/audio_processing/aec/aec_core.h"
 #include "modules/audio_processing/agc/agc_manager_direct.h"
 #include "modules/audio_processing/agc2/gain_applier.h"
 #include "modules/audio_processing/audio_buffer.h"
@@ -28,6 +29,7 @@
 #include "modules/audio_processing/gain_control_for_experimental_agc.h"
 #include "modules/audio_processing/gain_control_impl.h"
 #include "modules/audio_processing/gain_controller2.h"
+#include "modules/audio_processing/include/audio_frame_view.h"
 #include "modules/audio_processing/level_estimator_impl.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "modules/audio_processing/low_cut_filter.h"
@@ -37,10 +39,9 @@
 #include "modules/audio_processing/voice_detection_impl.h"
 #include "rtc_base/atomicops.h"
 #include "rtc_base/checks.h"
+#include "rtc_base/constructormagic.h"
 #include "rtc_base/logging.h"
-#include "rtc_base/platform_file.h"
 #include "rtc_base/refcountedobject.h"
-#include "rtc_base/system/arch.h"
 #include "rtc_base/timeutils.h"
 #include "rtc_base/trace_event.h"
 #include "system_wrappers/include/metrics.h"
@@ -115,29 +116,6 @@
 // TODO(peah): Decrease this once we properly handle hugely unbalanced
 // reverse and forward call numbers.
 static const size_t kMaxNumFramesToBuffer = 100;
-
-class HighPassFilterImpl : public HighPassFilter {
- public:
-  explicit HighPassFilterImpl(AudioProcessingImpl* apm) : apm_(apm) {}
-  ~HighPassFilterImpl() override = default;
-
-  // HighPassFilter implementation.
-  int Enable(bool enable) override {
-    apm_->MutateConfig([enable](AudioProcessing::Config* config) {
-      config->high_pass_filter.enabled = enable;
-    });
-
-    return AudioProcessing::kNoError;
-  }
-
-  bool is_enabled() const override {
-    return apm_->GetConfig().high_pass_filter.enabled;
-  }
-
- private:
-  AudioProcessingImpl* apm_;
-  RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(HighPassFilterImpl);
-};
 }  // namespace
 
 // Throughout webrtc, it's assumed that success is represented by zero.
@@ -249,8 +227,6 @@
 struct AudioProcessingImpl::ApmPublicSubmodules {
   ApmPublicSubmodules() {}
   // Accessed externally of APM without any lock acquired.
-  std::unique_ptr<EchoCancellationImpl> echo_cancellation;
-  std::unique_ptr<EchoControlMobileImpl> echo_control_mobile;
   std::unique_ptr<GainControlImpl> gain_control;
   std::unique_ptr<LevelEstimatorImpl> level_estimator;
   std::unique_ptr<NoiseSuppressionImpl> noise_suppression;
@@ -276,7 +252,9 @@
   std::unique_ptr<GainController2> gain_controller2;
   std::unique_ptr<LowCutFilter> low_cut_filter;
   rtc::scoped_refptr<EchoDetector> echo_detector;
+  std::unique_ptr<EchoCancellationImpl> echo_cancellation;
   std::unique_ptr<EchoControl> echo_controller;
+  std::unique_ptr<EchoControlMobileImpl> echo_control_mobile;
   std::unique_ptr<CustomProcessing> capture_post_processor;
   std::unique_ptr<CustomProcessing> render_pre_processor;
   std::unique_ptr<GainApplier> pre_amplifier;
@@ -352,7 +330,6 @@
       render_runtime_settings_(kRuntimeSettingQueueSize),
       capture_runtime_settings_enqueuer_(&capture_runtime_settings_),
       render_runtime_settings_enqueuer_(&render_runtime_settings_),
-      high_pass_filter_impl_(new HighPassFilterImpl(this)),
       echo_control_factory_(std::move(echo_control_factory)),
       submodule_states_(!!capture_post_processor,
                         !!render_pre_processor,
@@ -390,10 +367,6 @@
     capture_nonlocked_.echo_controller_enabled =
         static_cast<bool>(echo_control_factory_);
 
-    public_submodules_->echo_cancellation.reset(
-        new EchoCancellationImpl(&crit_render_, &crit_capture_));
-    public_submodules_->echo_control_mobile.reset(
-        new EchoControlMobileImpl(&crit_render_, &crit_capture_));
     public_submodules_->gain_control.reset(
         new GainControlImpl(&crit_render_, &crit_capture_));
     public_submodules_->level_estimator.reset(
@@ -412,6 +385,8 @@
           new rtc::RefCountedObject<ResidualEchoDetector>();
     }
 
+    private_submodules_->echo_cancellation.reset(new EchoCancellationImpl());
+    private_submodules_->echo_control_mobile.reset(new EchoControlMobileImpl());
     // TODO(alessiob): Move the injected gain controller once injection is
     // implemented.
     private_submodules_->gain_controller2.reset(new GainController2());
@@ -530,16 +505,16 @@
                       formats_.api_format.output_stream().num_channels(),
                       formats_.api_format.output_stream().num_frames()));
 
-  public_submodules_->echo_cancellation->Initialize(
+  private_submodules_->echo_cancellation->Initialize(
       proc_sample_rate_hz(), num_reverse_channels(), num_output_channels(),
       num_proc_channels());
   AllocateRenderQueue();
 
-  int success = public_submodules_->echo_cancellation->enable_metrics(true);
+  int success = private_submodules_->echo_cancellation->enable_metrics(true);
   RTC_DCHECK_EQ(0, success);
-  success = public_submodules_->echo_cancellation->enable_delay_logging(true);
+  success = private_submodules_->echo_cancellation->enable_delay_logging(true);
   RTC_DCHECK_EQ(0, success);
-  public_submodules_->echo_control_mobile->Initialize(
+  private_submodules_->echo_control_mobile->Initialize(
       proc_split_sample_rate_hz(), num_reverse_channels(),
       num_output_channels());
 
@@ -662,18 +637,18 @@
 }
 
 void AudioProcessingImpl::ApplyConfig(const AudioProcessing::Config& config) {
-  config_ = config;
-
   // Run in a single-threaded manner when applying the settings.
   rtc::CritScope cs_render(&crit_render_);
   rtc::CritScope cs_capture(&crit_capture_);
 
-  public_submodules_->echo_cancellation->Enable(
+  config_ = config;
+
+  private_submodules_->echo_cancellation->Enable(
       config_.echo_canceller.enabled && !config_.echo_canceller.mobile_mode);
-  public_submodules_->echo_control_mobile->Enable(
+  private_submodules_->echo_control_mobile->Enable(
       config_.echo_canceller.enabled && config_.echo_canceller.mobile_mode);
 
-  public_submodules_->echo_cancellation->set_suppression_level(
+  private_submodules_->echo_cancellation->set_suppression_level(
       config.echo_canceller.legacy_moderate_suppression_level
           ? EchoCancellationImpl::SuppressionLevel::kModerateSuppression
           : EchoCancellationImpl::SuppressionLevel::kHighSuppression);
@@ -705,7 +680,7 @@
   rtc::CritScope cs_render(&crit_render_);
   rtc::CritScope cs_capture(&crit_capture_);
 
-  public_submodules_->echo_cancellation->SetExtraOptions(config);
+  private_submodules_->echo_cancellation->SetExtraOptions(config);
 
   if (capture_.transient_suppressor_enabled !=
       config.Get<ExperimentalNs>().enabled) {
@@ -1082,12 +1057,12 @@
 void AudioProcessingImpl::EmptyQueuedRenderAudio() {
   rtc::CritScope cs_capture(&crit_capture_);
   while (aec_render_signal_queue_->Remove(&aec_capture_queue_buffer_)) {
-    public_submodules_->echo_cancellation->ProcessRenderAudio(
+    private_submodules_->echo_cancellation->ProcessRenderAudio(
         aec_capture_queue_buffer_);
   }
 
   while (aecm_render_signal_queue_->Remove(&aecm_capture_queue_buffer_)) {
-    public_submodules_->echo_control_mobile->ProcessRenderAudio(
+    private_submodules_->echo_control_mobile->ProcessRenderAudio(
         aecm_capture_queue_buffer_);
   }
 
@@ -1109,9 +1084,6 @@
     // Acquire the capture lock in order to safely call the function
     // that retrieves the render side data. This function accesses APM
     // getters that need the capture lock held when being called.
-    // The lock needs to be released as
-    // public_submodules_->echo_control_mobile->is_enabled() acquires this lock
-    // as well.
     rtc::CritScope cs_capture(&crit_capture_);
     EmptyQueuedRenderAudio();
   }
@@ -1180,8 +1152,8 @@
   // Ensure that not both the AEC and AECM are active at the same time.
   // TODO(peah): Simplify once the public API Enable functions for these
   // are moved to APM.
-  RTC_DCHECK(!(public_submodules_->echo_cancellation->is_enabled() &&
-               public_submodules_->echo_control_mobile->is_enabled()));
+  RTC_DCHECK(!(private_submodules_->echo_cancellation->is_enabled() &&
+               private_submodules_->echo_control_mobile->is_enabled()));
 
   MaybeUpdateHistograms();
 
@@ -1265,7 +1237,7 @@
 
   // Ensure that the stream delay was set before the call to the
   // AEC ProcessCaptureAudio function.
-  if (public_submodules_->echo_cancellation->is_enabled() &&
+  if (private_submodules_->echo_cancellation->is_enabled() &&
       !private_submodules_->echo_controller && !was_stream_delay_set()) {
     return AudioProcessing::kStreamParameterNotSetError;
   }
@@ -1281,11 +1253,11 @@
     private_submodules_->echo_controller->ProcessCapture(
         capture_buffer, capture_.echo_path_gain_change);
   } else {
-    RETURN_ON_ERR(public_submodules_->echo_cancellation->ProcessCaptureAudio(
+    RETURN_ON_ERR(private_submodules_->echo_cancellation->ProcessCaptureAudio(
         capture_buffer, stream_delay_ms()));
   }
 
-  if (public_submodules_->echo_control_mobile->is_enabled() &&
+  if (private_submodules_->echo_control_mobile->is_enabled() &&
       public_submodules_->noise_suppression->is_enabled()) {
     capture_buffer->CopyLowPassToReference();
   }
@@ -1293,14 +1265,14 @@
 
   // Ensure that the stream delay was set before the call to the
   // AECM ProcessCaptureAudio function.
-  if (public_submodules_->echo_control_mobile->is_enabled() &&
+  if (private_submodules_->echo_control_mobile->is_enabled() &&
       !was_stream_delay_set()) {
     return AudioProcessing::kStreamParameterNotSetError;
   }
 
   if (!(private_submodules_->echo_controller ||
-        public_submodules_->echo_cancellation->is_enabled())) {
-    RETURN_ON_ERR(public_submodules_->echo_control_mobile->ProcessCaptureAudio(
+        private_submodules_->echo_cancellation->is_enabled())) {
+    RETURN_ON_ERR(private_submodules_->echo_control_mobile->ProcessCaptureAudio(
         capture_buffer, stream_delay_ms()));
   }
 
@@ -1315,7 +1287,7 @@
   }
   RETURN_ON_ERR(public_submodules_->gain_control->ProcessCaptureAudio(
       capture_buffer,
-      public_submodules_->echo_cancellation->stream_has_echo()));
+      private_submodules_->echo_cancellation->stream_has_echo()));
 
   if (submodule_states_.CaptureMultiBandProcessingActive() &&
       SampleRateSupportsMultiBand(
@@ -1613,79 +1585,19 @@
   // Delete audio generator, if one is attached.
 }
 
-AudioProcessing::AudioProcessingStatistics::AudioProcessingStatistics() {
-  residual_echo_return_loss.Set(-100.0f, -100.0f, -100.0f, -100.0f);
-  echo_return_loss.Set(-100.0f, -100.0f, -100.0f, -100.0f);
-  echo_return_loss_enhancement.Set(-100.0f, -100.0f, -100.0f, -100.0f);
-  a_nlp.Set(-100.0f, -100.0f, -100.0f, -100.0f);
-}
-
-AudioProcessing::AudioProcessingStatistics::AudioProcessingStatistics(
-    const AudioProcessingStatistics& other) = default;
-
-AudioProcessing::AudioProcessingStatistics::~AudioProcessingStatistics() =
-    default;
-
-// TODO(ivoc): Remove this when GetStatistics() becomes pure virtual.
-AudioProcessing::AudioProcessingStatistics AudioProcessing::GetStatistics()
-    const {
-  return AudioProcessingStatistics();
-}
-
-// TODO(ivoc): Remove this when GetStatistics() becomes pure virtual.
-AudioProcessingStats AudioProcessing::GetStatistics(
-    bool has_remote_tracks) const {
-  return AudioProcessingStats();
-}
-
-AudioProcessing::AudioProcessingStatistics AudioProcessingImpl::GetStatistics()
-    const {
-  AudioProcessingStatistics stats;
-  EchoCancellationImpl::Metrics metrics;
-  if (private_submodules_->echo_controller) {
-    rtc::CritScope cs_capture(&crit_capture_);
-    auto ec_metrics = private_submodules_->echo_controller->GetMetrics();
-    float erl = static_cast<float>(ec_metrics.echo_return_loss);
-    float erle = static_cast<float>(ec_metrics.echo_return_loss_enhancement);
-    // Instant value will also be used for min, max and average.
-    stats.echo_return_loss.Set(erl, erl, erl, erl);
-    stats.echo_return_loss_enhancement.Set(erle, erle, erle, erle);
-  } else if (public_submodules_->echo_cancellation->GetMetrics(&metrics) ==
-             Error::kNoError) {
-    stats.a_nlp.Set(metrics.a_nlp);
-    stats.divergent_filter_fraction = metrics.divergent_filter_fraction;
-    stats.echo_return_loss.Set(metrics.echo_return_loss);
-    stats.echo_return_loss_enhancement.Set(
-        metrics.echo_return_loss_enhancement);
-    stats.residual_echo_return_loss.Set(metrics.residual_echo_return_loss);
-  }
-  {
-    rtc::CritScope cs_capture(&crit_capture_);
-    RTC_DCHECK(private_submodules_->echo_detector);
-    auto ed_metrics = private_submodules_->echo_detector->GetMetrics();
-    stats.residual_echo_likelihood = ed_metrics.echo_likelihood;
-    stats.residual_echo_likelihood_recent_max =
-        ed_metrics.echo_likelihood_recent_max;
-  }
-  public_submodules_->echo_cancellation->GetDelayMetrics(
-      &stats.delay_median, &stats.delay_standard_deviation,
-      &stats.fraction_poor_delays);
-  return stats;
-}
-
 AudioProcessingStats AudioProcessingImpl::GetStatistics(
     bool has_remote_tracks) const {
   AudioProcessingStats stats;
   if (has_remote_tracks) {
     EchoCancellationImpl::Metrics metrics;
+    rtc::CritScope cs_capture(&crit_capture_);
     if (private_submodules_->echo_controller) {
-      rtc::CritScope cs_capture(&crit_capture_);
       auto ec_metrics = private_submodules_->echo_controller->GetMetrics();
       stats.echo_return_loss = ec_metrics.echo_return_loss;
       stats.echo_return_loss_enhancement =
           ec_metrics.echo_return_loss_enhancement;
       stats.delay_ms = ec_metrics.delay_ms;
-    } else if (public_submodules_->echo_cancellation->GetMetrics(&metrics) ==
+    } else if (private_submodules_->echo_cancellation->GetMetrics(&metrics) ==
                Error::kNoError) {
       if (metrics.divergent_filter_fraction != -1.0f) {
         stats.divergent_filter_fraction =
@@ -1701,7 +1613,6 @@
       }
     }
     if (config_.residual_echo_detector.enabled) {
-      rtc::CritScope cs_capture(&crit_capture_);
       RTC_DCHECK(private_submodules_->echo_detector);
       auto ed_metrics = private_submodules_->echo_detector->GetMetrics();
       stats.residual_echo_likelihood = ed_metrics.echo_likelihood;
@@ -1710,7 +1621,7 @@
     }
     int delay_median, delay_std;
     float fraction_poor_delays;
-    if (public_submodules_->echo_cancellation->GetDelayMetrics(
+    if (private_submodules_->echo_cancellation->GetDelayMetrics(
             &delay_median, &delay_std, &fraction_poor_delays) ==
         Error::kNoError) {
       if (delay_median >= 0) {
@@ -1731,10 +1642,6 @@
   return public_submodules_->gain_control.get();
 }
 
-HighPassFilter* AudioProcessingImpl::high_pass_filter() const {
-  return high_pass_filter_impl_.get();
-}
-
 LevelEstimator* AudioProcessingImpl::level_estimator() const {
   return public_submodules_->level_estimator.get();
 }
@@ -1764,8 +1671,8 @@
 bool AudioProcessingImpl::UpdateActiveSubmoduleStates() {
   return submodule_states_.Update(
       config_.high_pass_filter.enabled,
-      public_submodules_->echo_cancellation->is_enabled(),
-      public_submodules_->echo_control_mobile->is_enabled(),
+      private_submodules_->echo_cancellation->is_enabled(),
+      private_submodules_->echo_control_mobile->is_enabled(),
       config_.residual_echo_detector.enabled,
       public_submodules_->noise_suppression->is_enabled(),
       public_submodules_->gain_control->is_enabled(),
@@ -1852,15 +1759,15 @@
 void AudioProcessingImpl::MaybeUpdateHistograms() {
   static const int kMinDiffDelayMs = 60;
 
-  if (public_submodules_->echo_cancellation->is_enabled()) {
+  if (private_submodules_->echo_cancellation->is_enabled()) {
     // Activate delay_jumps_ counters if we know echo_cancellation is running.
     // If a stream has echo we know that the echo_cancellation is in process.
     if (capture_.stream_delay_jumps == -1 &&
-        public_submodules_->echo_cancellation->stream_has_echo()) {
+        private_submodules_->echo_cancellation->stream_has_echo()) {
       capture_.stream_delay_jumps = 0;
     }
     if (capture_.aec_system_delay_jumps == -1 &&
-        public_submodules_->echo_cancellation->stream_has_echo()) {
+        private_submodules_->echo_cancellation->stream_has_echo()) {
       capture_.aec_system_delay_jumps = 0;
     }
 
@@ -1883,7 +1790,7 @@
         rtc::CheckedDivExact(capture_nonlocked_.split_rate, 1000);
     RTC_DCHECK_LT(0, samples_per_ms);
     const int aec_system_delay_ms =
-        public_submodules_->echo_cancellation->GetSystemDelayInSamples() /
+        private_submodules_->echo_cancellation->GetSystemDelayInSamples() /
         samples_per_ms;
     const int diff_aec_system_delay_ms =
         aec_system_delay_ms - capture_.last_aec_system_delay_ms;
@@ -1927,7 +1834,7 @@
     return;
   }
   std::string experiments_description =
-      public_submodules_->echo_cancellation->GetExperimentsDescription();
+      private_submodules_->echo_cancellation->GetExperimentsDescription();
   // TODO(peah): Add semicolon-separated concatenations of experiment
   // descriptions for other submodules.
   if (constants_.agc_clipped_level_min != kClippedLevelMin) {
@@ -1942,22 +1849,22 @@
 
   InternalAPMConfig apm_config;
 
-  apm_config.aec_enabled = public_submodules_->echo_cancellation->is_enabled();
+  apm_config.aec_enabled = private_submodules_->echo_cancellation->is_enabled();
   apm_config.aec_delay_agnostic_enabled =
-      public_submodules_->echo_cancellation->is_delay_agnostic_enabled();
+      private_submodules_->echo_cancellation->is_delay_agnostic_enabled();
   apm_config.aec_drift_compensation_enabled =
-      public_submodules_->echo_cancellation->is_drift_compensation_enabled();
+      private_submodules_->echo_cancellation->is_drift_compensation_enabled();
   apm_config.aec_extended_filter_enabled =
-      public_submodules_->echo_cancellation->is_extended_filter_enabled();
+      private_submodules_->echo_cancellation->is_extended_filter_enabled();
   apm_config.aec_suppression_level = static_cast<int>(
-      public_submodules_->echo_cancellation->suppression_level());
+      private_submodules_->echo_cancellation->suppression_level());
 
   apm_config.aecm_enabled =
-      public_submodules_->echo_control_mobile->is_enabled();
+      private_submodules_->echo_control_mobile->is_enabled();
   apm_config.aecm_comfort_noise_enabled =
-      public_submodules_->echo_control_mobile->is_comfort_noise_enabled();
-  apm_config.aecm_routing_mode =
-      static_cast<int>(public_submodules_->echo_control_mobile->routing_mode());
+      private_submodules_->echo_control_mobile->is_comfort_noise_enabled();
+  apm_config.aecm_routing_mode = static_cast<int>(
+      private_submodules_->echo_control_mobile->routing_mode());
 
   apm_config.agc_enabled = public_submodules_->gain_control->is_enabled();
   apm_config.agc_mode =
@@ -2032,7 +1939,7 @@
   AecDump::AudioProcessingState audio_proc_state;
   audio_proc_state.delay = capture_nonlocked_.stream_delay_ms;
   audio_proc_state.drift =
-      public_submodules_->echo_cancellation->stream_drift_samples();
+      private_submodules_->echo_cancellation->stream_drift_samples();
   audio_proc_state.level = gain_control()->stream_analog_level();
   audio_proc_state.keypress = capture_.key_pressed;
   aec_dump_->AddAudioProcessingState(audio_proc_state);
diff --git a/modules/audio_processing/audio_processing_impl.h b/modules/audio_processing/audio_processing_impl.h
index 50cb82b..e376a74 100644
--- a/modules/audio_processing/audio_processing_impl.h
+++ b/modules/audio_processing/audio_processing_impl.h
@@ -109,7 +109,6 @@
   bool was_stream_delay_set() const override
       RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_capture_);
 
-  AudioProcessingStatistics GetStatistics() const override;
   AudioProcessingStats GetStatistics(bool has_remote_tracks) const override;
 
   // Methods returning pointers to APM submodules.
@@ -118,8 +117,6 @@
   // created only once in a single-treaded manner
   // during APM creation).
   GainControl* gain_control() const override;
-  // TODO(peah): Deprecate this API call.
-  HighPassFilter* high_pass_filter() const override;
   LevelEstimator* level_estimator() const override;
   NoiseSuppression* noise_suppression() const override;
   VoiceDetection* voice_detection() const override;
@@ -164,9 +161,6 @@
   RuntimeSettingEnqueuer capture_runtime_settings_enqueuer_;
   RuntimeSettingEnqueuer render_runtime_settings_enqueuer_;
 
-  // Submodule interface implementations.
-  std::unique_ptr<HighPassFilter> high_pass_filter_impl_;
-
   // EchoControl factory.
   std::unique_ptr<EchoControlFactory> echo_control_factory_;
 
diff --git a/modules/audio_processing/audio_processing_impl_locking_unittest.cc b/modules/audio_processing/audio_processing_impl_locking_unittest.cc
index 0e0a33f..9685ef9 100644
--- a/modules/audio_processing/audio_processing_impl_locking_unittest.cc
+++ b/modules/audio_processing/audio_processing_impl_locking_unittest.cc
@@ -487,10 +487,7 @@
 }
 
 AudioProcessingImplLockTest::AudioProcessingImplLockTest()
-    : test_complete_(false, false),
-      render_call_event_(false, false),
-      capture_call_event_(false, false),
-      render_thread_(RenderProcessorThreadFunc, this, "render"),
+    : render_thread_(RenderProcessorThreadFunc, this, "render"),
       capture_thread_(CaptureProcessorThreadFunc, this, "capture"),
       stats_thread_(StatsProcessorThreadFunc, this, "stats"),
       apm_(AudioProcessingBuilder().Create()),
diff --git a/modules/audio_processing/audio_processing_performance_unittest.cc b/modules/audio_processing/audio_processing_performance_unittest.cc
index 95f736c..84cb574 100644
--- a/modules/audio_processing/audio_processing_performance_unittest.cc
+++ b/modules/audio_processing/audio_processing_performance_unittest.cc
@@ -18,11 +18,11 @@
 #include "api/array_view.h"
 #include "modules/audio_processing/test/test_utils.h"
 #include "rtc_base/atomicops.h"
+#include "rtc_base/event.h"
 #include "rtc_base/numerics/safe_conversions.h"
 #include "rtc_base/platform_thread.h"
 #include "rtc_base/random.h"
 #include "system_wrappers/include/clock.h"
-#include "system_wrappers/include/event_wrapper.h"
 #include "test/gtest.h"
 #include "test/testsupport/perf_test.h"
 
@@ -391,8 +391,7 @@
 class CallSimulator : public ::testing::TestWithParam<SimulationConfig> {
  public:
   CallSimulator()
-      : test_complete_(EventWrapper::Create()),
-        render_thread_(
+      : render_thread_(
             new rtc::PlatformThread(RenderProcessorThreadFunc, this, "render")),
         capture_thread_(new rtc::PlatformThread(CaptureProcessorThreadFunc,
                                                 this,
@@ -401,10 +400,10 @@
         simulation_config_(static_cast<SimulationConfig>(GetParam())) {}
 
   // Run the call simulation with a timeout.
-  EventTypeWrapper Run() {
+  bool Run() {
     StartThreads();
 
-    EventTypeWrapper result = test_complete_->Wait(kTestTimeout);
+    bool result = test_complete_.Wait(kTestTimeout);
 
     StopThreads();
 
@@ -420,7 +419,7 @@
   // done.
   bool MaybeEndTest() {
     if (frame_counters_.BothCountersExceedeThreshold(kMinNumFramesToProcess)) {
-      test_complete_->Set();
+      test_complete_.Set();
       return true;
     }
     return false;
@@ -570,7 +569,7 @@
   }
 
   // Event handler for the test.
-  const std::unique_ptr<EventWrapper> test_complete_;
+  rtc::Event test_complete_;
 
   // Thread related variables.
   std::unique_ptr<rtc::PlatformThread> render_thread_;
@@ -619,7 +618,7 @@
 // TODO(peah): Reactivate once issue 7712 has been resolved.
 TEST_P(CallSimulator, DISABLED_ApiCallDurationTest) {
   // Run test and verify that it did not time out.
-  EXPECT_EQ(kEventSignaled, Run());
+  EXPECT_TRUE(Run());
 }
 
 INSTANTIATE_TEST_CASE_P(
diff --git a/modules/audio_processing/audio_processing_unittest.cc b/modules/audio_processing/audio_processing_unittest.cc
index 3f0decc..18e669f 100644
--- a/modules/audio_processing/audio_processing_unittest.cc
+++ b/modules/audio_processing/audio_processing_unittest.cc
@@ -1278,7 +1278,6 @@
   EXPECT_FALSE(config.echo_canceller.enabled);
   EXPECT_FALSE(config.high_pass_filter.enabled);
   EXPECT_FALSE(apm_->gain_control()->is_enabled());
-  EXPECT_FALSE(apm_->high_pass_filter()->is_enabled());
   EXPECT_FALSE(apm_->level_estimator()->is_enabled());
   EXPECT_FALSE(apm_->noise_suppression()->is_enabled());
   EXPECT_FALSE(apm_->voice_detection()->is_enabled());
diff --git a/modules/audio_processing/echo_cancellation_bit_exact_unittest.cc b/modules/audio_processing/echo_cancellation_bit_exact_unittest.cc
index 7f60c4b..af0741e 100644
--- a/modules/audio_processing/echo_cancellation_bit_exact_unittest.cc
+++ b/modules/audio_processing/echo_cancellation_bit_exact_unittest.cc
@@ -74,9 +74,7 @@
     EchoCancellationImpl::SuppressionLevel suppression_level,
     bool stream_has_echo_reference,
     const rtc::ArrayView<const float>& output_reference) {
-  rtc::CriticalSection crit_render;
-  rtc::CriticalSection crit_capture;
-  EchoCancellationImpl echo_canceller(&crit_render, &crit_capture);
+  EchoCancellationImpl echo_canceller;
   SetupComponent(sample_rate_hz, suppression_level, drift_compensation_enabled,
                  &echo_canceller);
 
diff --git a/modules/audio_processing/echo_cancellation_impl.cc b/modules/audio_processing/echo_cancellation_impl.cc
index e6fe769..73fe51b 100644
--- a/modules/audio_processing/echo_cancellation_impl.cc
+++ b/modules/audio_processing/echo_cancellation_impl.cc
@@ -10,11 +10,13 @@
 
 #include "modules/audio_processing/echo_cancellation_impl.h"
 
+#include <stdint.h>
 #include <string.h>
 
 #include "modules/audio_processing/aec/aec_core.h"
 #include "modules/audio_processing/aec/echo_cancellation.h"
 #include "modules/audio_processing/audio_buffer.h"
+#include "modules/audio_processing/include/config.h"
 #include "rtc_base/checks.h"
 #include "system_wrappers/include/field_trial.h"
 
@@ -103,11 +105,8 @@
   void* state_;
 };
 
-EchoCancellationImpl::EchoCancellationImpl(rtc::CriticalSection* crit_render,
-                                           rtc::CriticalSection* crit_capture)
-    : crit_render_(crit_render),
-      crit_capture_(crit_capture),
-      drift_compensation_enabled_(false),
+EchoCancellationImpl::EchoCancellationImpl()
+    : drift_compensation_enabled_(false),
       metrics_enabled_(true),
       suppression_level_(kHighSuppression),
       stream_drift_samples_(0),
@@ -116,16 +115,12 @@
       delay_logging_enabled_(true),
       extended_filter_enabled_(false),
       delay_agnostic_enabled_(false),
-      enforce_zero_stream_delay_(EnforceZeroStreamDelay()) {
-  RTC_DCHECK(crit_render);
-  RTC_DCHECK(crit_capture);
-}
+      enforce_zero_stream_delay_(EnforceZeroStreamDelay()) {}
 
 EchoCancellationImpl::~EchoCancellationImpl() = default;
 
 void EchoCancellationImpl::ProcessRenderAudio(
     rtc::ArrayView<const float> packed_render_audio) {
-  rtc::CritScope cs_capture(crit_capture_);
   if (!enabled_) {
     return;
   }
@@ -149,7 +144,6 @@
 
 int EchoCancellationImpl::ProcessCaptureAudio(AudioBuffer* audio,
                                               int stream_delay_ms) {
-  rtc::CritScope cs_capture(crit_capture_);
   if (!enabled_) {
     return AudioProcessing::kNoError;
   }
@@ -206,10 +200,6 @@
 }
 
 int EchoCancellationImpl::Enable(bool enable) {
-  // Run in a single-threaded manner.
-  rtc::CritScope cs_render(crit_render_);
-  rtc::CritScope cs_capture(crit_capture_);
-
   if (enable && !enabled_) {
     enabled_ = enable;  // Must be set before Initialize() is called.
 
@@ -227,68 +217,52 @@
 }
 
 bool EchoCancellationImpl::is_enabled() const {
-  rtc::CritScope cs(crit_capture_);
   return enabled_;
 }
 
 int EchoCancellationImpl::set_suppression_level(SuppressionLevel level) {
-  {
-    if (MapSetting(level) == -1) {
-      return AudioProcessing::kBadParameterError;
-    }
-    rtc::CritScope cs(crit_capture_);
-    suppression_level_ = level;
+  if (MapSetting(level) == -1) {
+    return AudioProcessing::kBadParameterError;
   }
+  suppression_level_ = level;
   return Configure();
 }
 
 EchoCancellationImpl::SuppressionLevel EchoCancellationImpl::suppression_level()
     const {
-  rtc::CritScope cs(crit_capture_);
   return suppression_level_;
 }
 
 int EchoCancellationImpl::enable_drift_compensation(bool enable) {
-  {
-    rtc::CritScope cs(crit_capture_);
-    drift_compensation_enabled_ = enable;
-  }
+  drift_compensation_enabled_ = enable;
   return Configure();
 }
 
 bool EchoCancellationImpl::is_drift_compensation_enabled() const {
-  rtc::CritScope cs(crit_capture_);
   return drift_compensation_enabled_;
 }
 
 void EchoCancellationImpl::set_stream_drift_samples(int drift) {
-  rtc::CritScope cs(crit_capture_);
   was_stream_drift_set_ = true;
   stream_drift_samples_ = drift;
 }
 
 int EchoCancellationImpl::stream_drift_samples() const {
-  rtc::CritScope cs(crit_capture_);
   return stream_drift_samples_;
 }
 
 int EchoCancellationImpl::enable_metrics(bool enable) {
-  {
-    rtc::CritScope cs(crit_capture_);
-    metrics_enabled_ = enable;
-  }
+  metrics_enabled_ = enable;
   return Configure();
 }
 
 bool EchoCancellationImpl::are_metrics_enabled() const {
-  rtc::CritScope cs(crit_capture_);
   return enabled_ && metrics_enabled_;
 }
 
 // TODO(ajm): we currently just use the metrics from the first AEC. Think more
 //            aboue the best way to extend this to multi-channel.
 int EchoCancellationImpl::GetMetrics(Metrics* metrics) {
-  rtc::CritScope cs(crit_capture_);
   if (metrics == NULL) {
     return AudioProcessing::kNullPointerError;
   }
@@ -331,46 +305,36 @@
 }
 
 bool EchoCancellationImpl::stream_has_echo() const {
-  rtc::CritScope cs(crit_capture_);
   return stream_has_echo_;
 }
 
 int EchoCancellationImpl::enable_delay_logging(bool enable) {
-  {
-    rtc::CritScope cs(crit_capture_);
-    delay_logging_enabled_ = enable;
-  }
+  delay_logging_enabled_ = enable;
   return Configure();
 }
 
 bool EchoCancellationImpl::is_delay_logging_enabled() const {
-  rtc::CritScope cs(crit_capture_);
   return enabled_ && delay_logging_enabled_;
 }
 
 bool EchoCancellationImpl::is_delay_agnostic_enabled() const {
-  rtc::CritScope cs(crit_capture_);
   return delay_agnostic_enabled_;
 }
 
 std::string EchoCancellationImpl::GetExperimentsDescription() {
-  rtc::CritScope cs(crit_capture_);
   return refined_adaptive_filter_enabled_ ? "RefinedAdaptiveFilter;" : "";
 }
 
 bool EchoCancellationImpl::is_refined_adaptive_filter_enabled() const {
-  rtc::CritScope cs(crit_capture_);
   return refined_adaptive_filter_enabled_;
 }
 
 bool EchoCancellationImpl::is_extended_filter_enabled() const {
-  rtc::CritScope cs(crit_capture_);
   return extended_filter_enabled_;
 }
 
 // TODO(bjornv): How should we handle the multi-channel case?
 int EchoCancellationImpl::GetDelayMetrics(int* median, int* std) {
-  rtc::CritScope cs(crit_capture_);
   float fraction_poor_delays = 0;
   return GetDelayMetrics(median, std, &fraction_poor_delays);
 }
@@ -378,7 +342,6 @@
 int EchoCancellationImpl::GetDelayMetrics(int* median,
                                           int* std,
                                           float* fraction_poor_delays) {
-  rtc::CritScope cs(crit_capture_);
   if (median == NULL) {
     return AudioProcessing::kNullPointerError;
   }
@@ -400,7 +363,6 @@
 }
 
 struct AecCore* EchoCancellationImpl::aec_core() const {
-  rtc::CritScope cs(crit_capture_);
   if (!enabled_) {
     return NULL;
   }
@@ -411,9 +373,6 @@
                                       size_t num_reverse_channels,
                                       size_t num_output_channels,
                                       size_t num_proc_channels) {
-  rtc::CritScope cs_render(crit_render_);
-  rtc::CritScope cs_capture(crit_capture_);
-
   stream_properties_.reset(
       new StreamProperties(sample_rate_hz, num_reverse_channels,
                            num_output_channels, num_proc_channels));
@@ -442,7 +401,6 @@
 }
 
 int EchoCancellationImpl::GetSystemDelayInSamples() const {
-  rtc::CritScope cs(crit_capture_);
   RTC_DCHECK(enabled_);
   // Report the delay for the first AEC component.
   return WebRtcAec_system_delay(WebRtcAec_aec_core(cancellers_[0]->state()));
@@ -471,7 +429,6 @@
 
 void EchoCancellationImpl::SetExtraOptions(const webrtc::Config& config) {
   {
-    rtc::CritScope cs(crit_capture_);
     extended_filter_enabled_ = config.Get<ExtendedFilter>().enabled;
     delay_agnostic_enabled_ = config.Get<DelayAgnostic>().enabled;
     refined_adaptive_filter_enabled_ =
@@ -481,8 +438,6 @@
 }
 
 int EchoCancellationImpl::Configure() {
-  rtc::CritScope cs_render(crit_render_);
-  rtc::CritScope cs_capture(crit_capture_);
   AecConfig config;
   config.metricsMode = metrics_enabled_;
   config.nlpMode = MapSetting(suppression_level_);
diff --git a/modules/audio_processing/echo_cancellation_impl.h b/modules/audio_processing/echo_cancellation_impl.h
index 091a7b5..a8b43a8 100644
--- a/modules/audio_processing/echo_cancellation_impl.h
+++ b/modules/audio_processing/echo_cancellation_impl.h
@@ -11,12 +11,16 @@
 #ifndef MODULES_AUDIO_PROCESSING_ECHO_CANCELLATION_IMPL_H_
 #define MODULES_AUDIO_PROCESSING_ECHO_CANCELLATION_IMPL_H_
 
+#include <stddef.h>
 #include <memory>
+#include <string>
 #include <vector>
 
+#include "api/array_view.h"
 #include "modules/audio_processing/include/audio_processing.h"
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/criticalsection.h"
+#include "rtc_base/thread_annotations.h"
 
 namespace webrtc {
 
@@ -28,8 +32,7 @@
 // for PC and IP phone applications.
 class EchoCancellationImpl {
  public:
-  EchoCancellationImpl(rtc::CriticalSection* crit_render,
-                       rtc::CriticalSection* crit_capture);
+  explicit EchoCancellationImpl();
   ~EchoCancellationImpl();
 
   void ProcessRenderAudio(rtc::ArrayView<const float> packed_render_audio);
@@ -80,17 +83,23 @@
   // P_a:    Internal signal power at the point before the AEC's non-linear
   //         processor.
   struct Metrics {
+    struct Statistic {
+      int instant = 0;  // Instantaneous value.
+      int average = 0;  // Long-term average.
+      int maximum = 0;  // Long-term maximum.
+      int minimum = 0;  // Long-term minimum.
+    };
     // RERL = ERL + ERLE
-    AudioProcessing::Statistic residual_echo_return_loss;
+    Statistic residual_echo_return_loss;
 
     // ERL = 10log_10(P_far / P_echo)
-    AudioProcessing::Statistic echo_return_loss;
+    Statistic echo_return_loss;
 
     // ERLE = 10log_10(P_echo / P_out)
-    AudioProcessing::Statistic echo_return_loss_enhancement;
+    Statistic echo_return_loss_enhancement;
 
     // (Pre non-linear processing suppression) A_NLP = 10log_10(P_echo / P_a)
-    AudioProcessing::Statistic a_nlp;
+    Statistic a_nlp;
 
     // Fraction of time that the AEC linear filter is divergent, in a 1-second
     // non-overlapped aggregation window.
@@ -150,28 +159,23 @@
   void AllocateRenderQueue();
   int Configure();
 
-  rtc::CriticalSection* const crit_render_ RTC_ACQUIRED_BEFORE(crit_capture_);
-  rtc::CriticalSection* const crit_capture_;
-
   bool enabled_ = false;
-  bool drift_compensation_enabled_ RTC_GUARDED_BY(crit_capture_);
-  bool metrics_enabled_ RTC_GUARDED_BY(crit_capture_);
-  SuppressionLevel suppression_level_ RTC_GUARDED_BY(crit_capture_);
-  int stream_drift_samples_ RTC_GUARDED_BY(crit_capture_);
-  bool was_stream_drift_set_ RTC_GUARDED_BY(crit_capture_);
-  bool stream_has_echo_ RTC_GUARDED_BY(crit_capture_);
-  bool delay_logging_enabled_ RTC_GUARDED_BY(crit_capture_);
-  bool extended_filter_enabled_ RTC_GUARDED_BY(crit_capture_);
-  bool delay_agnostic_enabled_ RTC_GUARDED_BY(crit_capture_);
-  bool refined_adaptive_filter_enabled_ RTC_GUARDED_BY(crit_capture_) = false;
+  bool drift_compensation_enabled_;
+  bool metrics_enabled_;
+  SuppressionLevel suppression_level_;
+  int stream_drift_samples_;
+  bool was_stream_drift_set_;
+  bool stream_has_echo_;
+  bool delay_logging_enabled_;
+  bool extended_filter_enabled_;
+  bool delay_agnostic_enabled_;
+  bool refined_adaptive_filter_enabled_ = false;
 
   // Only active on Chrome OS devices.
-  const bool enforce_zero_stream_delay_ RTC_GUARDED_BY(crit_capture_);
+  const bool enforce_zero_stream_delay_;
 
   std::vector<std::unique_ptr<Canceller>> cancellers_;
   std::unique_ptr<StreamProperties> stream_properties_;
-
-  RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(EchoCancellationImpl);
 };
 
 }  // namespace webrtc
diff --git a/modules/audio_processing/echo_cancellation_impl_unittest.cc b/modules/audio_processing/echo_cancellation_impl_unittest.cc
index c50c52f..9d81c1d 100644
--- a/modules/audio_processing/echo_cancellation_impl_unittest.cc
+++ b/modules/audio_processing/echo_cancellation_impl_unittest.cc
@@ -18,9 +18,7 @@
 
 namespace webrtc {
 TEST(EchoCancellationInternalTest, ExtendedFilter) {
-  rtc::CriticalSection crit_render;
-  rtc::CriticalSection crit_capture;
-  EchoCancellationImpl echo_canceller(&crit_render, &crit_capture);
+  EchoCancellationImpl echo_canceller;
   echo_canceller.Initialize(AudioProcessing::kSampleRate32kHz, 2, 2, 2);
 
   EXPECT_TRUE(echo_canceller.aec_core() == nullptr);
@@ -51,9 +49,7 @@
 }
 
 TEST(EchoCancellationInternalTest, DelayAgnostic) {
-  rtc::CriticalSection crit_render;
-  rtc::CriticalSection crit_capture;
-  EchoCancellationImpl echo_canceller(&crit_render, &crit_capture);
+  EchoCancellationImpl echo_canceller;
   echo_canceller.Initialize(AudioProcessing::kSampleRate32kHz, 1, 1, 1);
 
   EXPECT_TRUE(echo_canceller.aec_core() == NULL);
@@ -85,9 +81,7 @@
 }
 
 TEST(EchoCancellationInternalTest, InterfaceConfiguration) {
-  rtc::CriticalSection crit_render;
-  rtc::CriticalSection crit_capture;
-  EchoCancellationImpl echo_canceller(&crit_render, &crit_capture);
+  EchoCancellationImpl echo_canceller;
   echo_canceller.Initialize(AudioProcessing::kSampleRate16kHz, 1, 1, 1);
 
   EXPECT_EQ(0, echo_canceller.enable_drift_compensation(true));
diff --git a/modules/audio_processing/echo_control_mobile_bit_exact_unittest.cc b/modules/audio_processing/echo_control_mobile_bit_exact_unittest.cc
index 8b83692..7844daf 100644
--- a/modules/audio_processing/echo_control_mobile_bit_exact_unittest.cc
+++ b/modules/audio_processing/echo_control_mobile_bit_exact_unittest.cc
@@ -64,9 +64,7 @@
                          EchoControlMobileImpl::RoutingMode routing_mode,
                          bool comfort_noise_enabled,
                          const rtc::ArrayView<const float>& output_reference) {
-  rtc::CriticalSection crit_render;
-  rtc::CriticalSection crit_capture;
-  EchoControlMobileImpl echo_control_mobile(&crit_render, &crit_capture);
+  EchoControlMobileImpl echo_control_mobile;
   SetupComponent(sample_rate_hz, routing_mode, comfort_noise_enabled,
                  &echo_control_mobile);
 
diff --git a/modules/audio_processing/echo_control_mobile_impl.cc b/modules/audio_processing/echo_control_mobile_impl.cc
index bd125c6..b9fbf42 100644
--- a/modules/audio_processing/echo_control_mobile_impl.cc
+++ b/modules/audio_processing/echo_control_mobile_impl.cc
@@ -11,11 +11,13 @@
 #include "modules/audio_processing/echo_control_mobile_impl.h"
 
 #include <string.h>
+#include <cstdint>
 
 #include "modules/audio_processing/aecm/echo_control_mobile.h"
 #include "modules/audio_processing/audio_buffer.h"
+#include "modules/audio_processing/include/audio_processing.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/constructormagic.h"
-#include "rtc_base/logging.h"
 
 namespace webrtc {
 
@@ -55,10 +57,6 @@
 }
 }  // namespace
 
-size_t EchoControlMobileImpl::echo_path_size_bytes() {
-  return WebRtcAecm_echo_path_size_bytes();
-}
-
 struct EchoControlMobileImpl::StreamProperties {
   StreamProperties() = delete;
   StreamProperties(int sample_rate_hz,
@@ -90,17 +88,10 @@
     return state_;
   }
 
-  void Initialize(int sample_rate_hz,
-                  unsigned char* external_echo_path,
-                  size_t echo_path_size_bytes) {
+  void Initialize(int sample_rate_hz) {
     RTC_DCHECK(state_);
     int error = WebRtcAecm_Init(state_, sample_rate_hz);
     RTC_DCHECK_EQ(AudioProcessing::kNoError, error);
-    if (external_echo_path != NULL) {
-      error = WebRtcAecm_InitEchoPath(state_, external_echo_path,
-                                      echo_path_size_bytes);
-      RTC_DCHECK_EQ(AudioProcessing::kNoError, error);
-    }
   }
 
  private:
@@ -108,27 +99,13 @@
   RTC_DISALLOW_COPY_AND_ASSIGN(Canceller);
 };
 
-EchoControlMobileImpl::EchoControlMobileImpl(rtc::CriticalSection* crit_render,
-                                             rtc::CriticalSection* crit_capture)
-    : crit_render_(crit_render),
-      crit_capture_(crit_capture),
-      routing_mode_(kSpeakerphone),
-      comfort_noise_enabled_(false),
-      external_echo_path_(NULL) {
-  RTC_DCHECK(crit_render);
-  RTC_DCHECK(crit_capture);
-}
+EchoControlMobileImpl::EchoControlMobileImpl()
+    : routing_mode_(kSpeakerphone), comfort_noise_enabled_(false) {}
 
-EchoControlMobileImpl::~EchoControlMobileImpl() {
-  if (external_echo_path_ != NULL) {
-    delete[] external_echo_path_;
-    external_echo_path_ = NULL;
-  }
-}
+EchoControlMobileImpl::~EchoControlMobileImpl() {}
 
 void EchoControlMobileImpl::ProcessRenderAudio(
     rtc::ArrayView<const int16_t> packed_render_audio) {
-  rtc::CritScope cs_capture(crit_capture_);
   if (!enabled_) {
     return;
   }
@@ -181,7 +158,6 @@
 
 int EchoControlMobileImpl::ProcessCaptureAudio(AudioBuffer* audio,
                                                int stream_delay_ms) {
-  rtc::CritScope cs_capture(crit_capture_);
   if (!enabled_) {
     return AudioProcessing::kNoError;
   }
@@ -228,8 +204,6 @@
 
 int EchoControlMobileImpl::Enable(bool enable) {
   // Ensure AEC and AECM are not both enabled.
-  rtc::CritScope cs_render(crit_render_);
-  rtc::CritScope cs_capture(crit_capture_);
   RTC_DCHECK(stream_properties_);
 
   if (enable &&
@@ -252,7 +226,6 @@
 }
 
 bool EchoControlMobileImpl::is_enabled() const {
-  rtc::CritScope cs(crit_capture_);
   return enabled_;
 }
 
@@ -260,90 +233,26 @@
   if (MapSetting(mode) == -1) {
     return AudioProcessing::kBadParameterError;
   }
-
-  {
-    rtc::CritScope cs(crit_capture_);
     routing_mode_ = mode;
-  }
   return Configure();
 }
 
 EchoControlMobileImpl::RoutingMode EchoControlMobileImpl::routing_mode() const {
-  rtc::CritScope cs(crit_capture_);
   return routing_mode_;
 }
 
 int EchoControlMobileImpl::enable_comfort_noise(bool enable) {
-  {
-    rtc::CritScope cs(crit_capture_);
     comfort_noise_enabled_ = enable;
-  }
   return Configure();
 }
 
 bool EchoControlMobileImpl::is_comfort_noise_enabled() const {
-  rtc::CritScope cs(crit_capture_);
   return comfort_noise_enabled_;
 }
 
-int EchoControlMobileImpl::SetEchoPath(const void* echo_path,
-                                       size_t size_bytes) {
-  {
-    rtc::CritScope cs_render(crit_render_);
-    rtc::CritScope cs_capture(crit_capture_);
-    if (echo_path == NULL) {
-      return AudioProcessing::kNullPointerError;
-    }
-    if (size_bytes != echo_path_size_bytes()) {
-      // Size mismatch
-      return AudioProcessing::kBadParameterError;
-    }
-
-    if (external_echo_path_ == NULL) {
-      external_echo_path_ = new unsigned char[size_bytes];
-    }
-    memcpy(external_echo_path_, echo_path, size_bytes);
-  }
-
-  // TODO(peah): Simplify once the Enable function has been removed from
-  // the public APM API.
-  RTC_DCHECK(stream_properties_);
-  Initialize(stream_properties_->sample_rate_hz,
-             stream_properties_->num_reverse_channels,
-             stream_properties_->num_output_channels);
-  return AudioProcessing::kNoError;
-}
-
-int EchoControlMobileImpl::GetEchoPath(void* echo_path,
-                                       size_t size_bytes) const {
-  rtc::CritScope cs(crit_capture_);
-  if (echo_path == NULL) {
-    return AudioProcessing::kNullPointerError;
-  }
-  if (size_bytes != echo_path_size_bytes()) {
-    // Size mismatch
-    return AudioProcessing::kBadParameterError;
-  }
-  if (!enabled_) {
-    return AudioProcessing::kNotEnabledError;
-  }
-
-  // Get the echo path from the first channel
-  int32_t err =
-      WebRtcAecm_GetEchoPath(cancellers_[0]->state(), echo_path, size_bytes);
-  if (err != 0) {
-    return MapError(err);
-  }
-
-  return AudioProcessing::kNoError;
-}
-
 void EchoControlMobileImpl::Initialize(int sample_rate_hz,
                                        size_t num_reverse_channels,
                                        size_t num_output_channels) {
-  rtc::CritScope cs_render(crit_render_);
-  rtc::CritScope cs_capture(crit_capture_);
-
   stream_properties_.reset(new StreamProperties(
       sample_rate_hz, num_reverse_channels, num_output_channels));
 
@@ -363,16 +272,12 @@
     if (!canceller) {
       canceller.reset(new Canceller());
     }
-    canceller->Initialize(sample_rate_hz, external_echo_path_,
-                          echo_path_size_bytes());
+    canceller->Initialize(sample_rate_hz);
   }
-
   Configure();
 }
 
 int EchoControlMobileImpl::Configure() {
-  rtc::CritScope cs_render(crit_render_);
-  rtc::CritScope cs_capture(crit_capture_);
   AecmConfig config;
   config.cngMode = comfort_noise_enabled_;
   config.echoMode = MapSetting(routing_mode_);
diff --git a/modules/audio_processing/echo_control_mobile_impl.h b/modules/audio_processing/echo_control_mobile_impl.h
index a5b66c8..d5a8b0b 100644
--- a/modules/audio_processing/echo_control_mobile_impl.h
+++ b/modules/audio_processing/echo_control_mobile_impl.h
@@ -11,14 +11,12 @@
 #ifndef MODULES_AUDIO_PROCESSING_ECHO_CONTROL_MOBILE_IMPL_H_
 #define MODULES_AUDIO_PROCESSING_ECHO_CONTROL_MOBILE_IMPL_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <memory>
 #include <vector>
 
-#include "modules/audio_processing/include/audio_processing.h"
-#include "modules/audio_processing/render_queue_item_verifier.h"
-#include "rtc_base/constructormagic.h"
-#include "rtc_base/criticalsection.h"
-#include "rtc_base/swap_queue.h"
+#include "api/array_view.h"
 
 namespace webrtc {
 
@@ -28,8 +26,7 @@
 // robust option intended for use on mobile devices.
 class EchoControlMobileImpl {
  public:
-  EchoControlMobileImpl(rtc::CriticalSection* crit_render,
-                        rtc::CriticalSection* crit_capture);
+  EchoControlMobileImpl();
 
   ~EchoControlMobileImpl();
 
@@ -57,26 +54,6 @@
   int enable_comfort_noise(bool enable);
   bool is_comfort_noise_enabled() const;
 
-  // A typical use case is to initialize the component with an echo path from a
-  // previous call. The echo path is retrieved using |GetEchoPath()|, typically
-  // at the end of a call. The data can then be stored for later use as an
-  // initializer before the next call, using |SetEchoPath()|.
-  //
-  // Controlling the echo path this way requires the data |size_bytes| to match
-  // the internal echo path size. This size can be acquired using
-  // |echo_path_size_bytes()|. |SetEchoPath()| causes an entire reset, worth
-  // noting if it is to be called during an ongoing call.
-  //
-  // It is possible that version incompatibilities may result in a stored echo
-  // path of the incorrect size. In this case, the stored path should be
-  // discarded.
-  int SetEchoPath(const void* echo_path, size_t size_bytes);
-  int GetEchoPath(void* echo_path, size_t size_bytes) const;
-
-  // The returned path size is guaranteed not to change for the lifetime of
-  // the application.
-  static size_t echo_path_size_bytes();
-
   void ProcessRenderAudio(rtc::ArrayView<const int16_t> packed_render_audio);
   int ProcessCaptureAudio(AudioBuffer* audio, int stream_delay_ms);
 
@@ -98,20 +75,13 @@
 
   int Configure();
 
-  rtc::CriticalSection* const crit_render_ RTC_ACQUIRED_BEFORE(crit_capture_);
-  rtc::CriticalSection* const crit_capture_;
-
   bool enabled_ = false;
 
-  RoutingMode routing_mode_ RTC_GUARDED_BY(crit_capture_);
-  bool comfort_noise_enabled_ RTC_GUARDED_BY(crit_capture_);
-  unsigned char* external_echo_path_ RTC_GUARDED_BY(crit_render_)
-      RTC_GUARDED_BY(crit_capture_);
+  RoutingMode routing_mode_;
+  bool comfort_noise_enabled_;
 
   std::vector<std::unique_ptr<Canceller>> cancellers_;
   std::unique_ptr<StreamProperties> stream_properties_;
-
-  RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(EchoControlMobileImpl);
 };
 }  // namespace webrtc
 
diff --git a/modules/audio_processing/echo_control_mobile_unittest.cc b/modules/audio_processing/echo_control_mobile_unittest.cc
index d7e470c..f0e6048 100644
--- a/modules/audio_processing/echo_control_mobile_unittest.cc
+++ b/modules/audio_processing/echo_control_mobile_unittest.cc
@@ -18,9 +18,7 @@
 
 namespace webrtc {
 TEST(EchoControlMobileTest, InterfaceConfiguration) {
-  rtc::CriticalSection crit_render;
-  rtc::CriticalSection crit_capture;
-  EchoControlMobileImpl aecm(&crit_render, &crit_capture);
+  EchoControlMobileImpl aecm;
   aecm.Initialize(AudioProcessing::kSampleRate16kHz, 2, 2);
 
   // Turn AECM on
@@ -46,28 +44,6 @@
   EXPECT_EQ(0, aecm.enable_comfort_noise(true));
   EXPECT_TRUE(aecm.is_comfort_noise_enabled());
 
-  // Set and get echo path
-  const size_t echo_path_size = aecm.echo_path_size_bytes();
-  std::vector<uint8_t> echo_path_in(echo_path_size);
-  std::vector<uint8_t> echo_path_out(echo_path_size);
-  EXPECT_EQ(AudioProcessing::kNullPointerError,
-            aecm.SetEchoPath(nullptr, echo_path_size));
-  EXPECT_EQ(AudioProcessing::kNullPointerError,
-            aecm.GetEchoPath(nullptr, echo_path_size));
-  EXPECT_EQ(AudioProcessing::kBadParameterError,
-            aecm.GetEchoPath(echo_path_out.data(), 1));
-  EXPECT_EQ(0, aecm.GetEchoPath(echo_path_out.data(), echo_path_size));
-  for (size_t i = 0; i < echo_path_size; i++) {
-    echo_path_in[i] = echo_path_out[i] + 1;
-  }
-  EXPECT_EQ(AudioProcessing::kBadParameterError,
-            aecm.SetEchoPath(echo_path_in.data(), 1));
-  EXPECT_EQ(0, aecm.SetEchoPath(echo_path_in.data(), echo_path_size));
-  EXPECT_EQ(0, aecm.GetEchoPath(echo_path_out.data(), echo_path_size));
-  for (size_t i = 0; i < echo_path_size; i++) {
-    EXPECT_EQ(echo_path_in[i], echo_path_out[i]);
-  }
-
   // Turn AECM off
   EXPECT_EQ(0, aecm.Enable(false));
   EXPECT_FALSE(aecm.is_enabled());
diff --git a/modules/audio_processing/echo_detector/circular_buffer.h b/modules/audio_processing/echo_detector/circular_buffer.h
index 9f5cdfa..c52311f 100644
--- a/modules/audio_processing/echo_detector/circular_buffer.h
+++ b/modules/audio_processing/echo_detector/circular_buffer.h
@@ -11,6 +11,7 @@
 #ifndef MODULES_AUDIO_PROCESSING_ECHO_DETECTOR_CIRCULAR_BUFFER_H_
 #define MODULES_AUDIO_PROCESSING_ECHO_DETECTOR_CIRCULAR_BUFFER_H_
 
+#include <stddef.h>
 #include <vector>
 
 #include "absl/types/optional.h"
diff --git a/modules/audio_processing/gain_control_for_experimental_agc.cc b/modules/audio_processing/gain_control_for_experimental_agc.cc
index 4ab856c..1479d58 100644
--- a/modules/audio_processing/gain_control_for_experimental_agc.cc
+++ b/modules/audio_processing/gain_control_for_experimental_agc.cc
@@ -13,7 +13,6 @@
 #include "modules/audio_processing/include/audio_processing.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/atomicops.h"
-#include "rtc_base/checks.h"
 #include "rtc_base/criticalsection.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/gain_control_impl.cc b/modules/audio_processing/gain_control_impl.cc
index 685a27f..d5118ba 100644
--- a/modules/audio_processing/gain_control_impl.cc
+++ b/modules/audio_processing/gain_control_impl.cc
@@ -10,10 +10,14 @@
 
 #include "modules/audio_processing/gain_control_impl.h"
 
+#include <cstdint>
+
 #include "absl/types/optional.h"
 #include "modules/audio_processing/agc/legacy/gain_control.h"
 #include "modules/audio_processing/audio_buffer.h"
+#include "modules/audio_processing/include/audio_processing.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/gain_control_impl.h b/modules/audio_processing/gain_control_impl.h
index 959422f..c21d911 100644
--- a/modules/audio_processing/gain_control_impl.h
+++ b/modules/audio_processing/gain_control_impl.h
@@ -11,14 +11,16 @@
 #ifndef MODULES_AUDIO_PROCESSING_GAIN_CONTROL_IMPL_H_
 #define MODULES_AUDIO_PROCESSING_GAIN_CONTROL_IMPL_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <memory>
 #include <vector>
 
-#include "modules/audio_processing/include/audio_processing.h"
-#include "modules/audio_processing/render_queue_item_verifier.h"
+#include "absl/types/optional.h"
+#include "api/array_view.h"
+#include "modules/audio_processing/include/gain_control.h"
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/criticalsection.h"
-#include "rtc_base/swap_queue.h"
 #include "rtc_base/thread_annotations.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/gain_controller2.cc b/modules/audio_processing/gain_controller2.cc
index 29af962..f256be0 100644
--- a/modules/audio_processing/gain_controller2.cc
+++ b/modules/audio_processing/gain_controller2.cc
@@ -10,6 +10,7 @@
 
 #include "modules/audio_processing/gain_controller2.h"
 
+#include "common_audio/include/audio_util.h"
 #include "modules/audio_processing/audio_buffer.h"
 #include "modules/audio_processing/include/audio_frame_view.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
@@ -24,8 +25,10 @@
 GainController2::GainController2()
     : data_dumper_(
           new ApmDataDumper(rtc::AtomicOps::Increment(&instance_count_))),
-      fixed_gain_controller_(data_dumper_.get()),
-      adaptive_agc_(data_dumper_.get()) {}
+      gain_applier_(/*hard_clip_samples=*/false,
+                    /*initial_gain_factor=*/0.f),
+      adaptive_agc_(new AdaptiveAgc(data_dumper_.get())),
+      limiter_(static_cast<size_t>(48000), data_dumper_.get(), "Agc2") {}
 
 GainController2::~GainController2() = default;
 
@@ -34,7 +37,7 @@
              sample_rate_hz == AudioProcessing::kSampleRate16kHz ||
              sample_rate_hz == AudioProcessing::kSampleRate32kHz ||
              sample_rate_hz == AudioProcessing::kSampleRate48kHz);
-  fixed_gain_controller_.SetSampleRate(sample_rate_hz);
+  limiter_.SetSampleRate(sample_rate_hz);
   data_dumper_->InitiateNewSetOfRecordings();
   data_dumper_->DumpRaw("sample_rate_hz", sample_rate_hz);
 }
@@ -42,15 +45,17 @@
 void GainController2::Process(AudioBuffer* audio) {
   AudioFrameView<float> float_frame(audio->channels_f(), audio->num_channels(),
                                     audio->num_frames());
+  // Apply fixed gain first, then the adaptive one.
+  gain_applier_.ApplyGain(float_frame);
   if (adaptive_digital_mode_) {
-    adaptive_agc_.Process(float_frame, fixed_gain_controller_.LastAudioLevel());
+    adaptive_agc_->Process(float_frame, limiter_.LastAudioLevel());
   }
-  fixed_gain_controller_.Process(float_frame);
+  limiter_.Process(float_frame);
 }
 
 void GainController2::NotifyAnalogLevel(int level) {
   if (analog_level_ != level && adaptive_digital_mode_) {
-    adaptive_agc_.Reset();
+    adaptive_agc_->Reset();
   }
   analog_level_ = level;
 }
@@ -59,13 +64,22 @@
     const AudioProcessing::Config::GainController2& config) {
   RTC_DCHECK(Validate(config));
   config_ = config;
-  fixed_gain_controller_.SetGain(config_.fixed_gain_db);
+  if (gain_applier_.GetGainFactor() != config_.fixed_gain_db) {
+    // Reset the limiter to quickly react on abrupt level changes caused by
+    // large changes of the fixed gain.
+    limiter_.Reset();
+  }
+  gain_applier_.SetGainFactor(DbToRatio(config_.fixed_gain_db));
   adaptive_digital_mode_ = config_.adaptive_digital_mode;
+  adaptive_agc_.reset(
+      new AdaptiveAgc(data_dumper_.get(), config_.extra_saturation_margin_db));
 }
 
 bool GainController2::Validate(
     const AudioProcessing::Config::GainController2& config) {
-  return config.fixed_gain_db >= 0.f;
+  return config.fixed_gain_db >= 0.f &&
+         config.extra_saturation_margin_db >= 0.f &&
+         config.extra_saturation_margin_db <= 100.f;
 }
 
 std::string GainController2::ToString(
diff --git a/modules/audio_processing/gain_controller2.h b/modules/audio_processing/gain_controller2.h
index b4727d0..013385d 100644
--- a/modules/audio_processing/gain_controller2.h
+++ b/modules/audio_processing/gain_controller2.h
@@ -15,7 +15,8 @@
 #include <string>
 
 #include "modules/audio_processing/agc2/adaptive_agc.h"
-#include "modules/audio_processing/agc2/fixed_gain_controller.h"
+#include "modules/audio_processing/agc2/gain_applier.h"
+#include "modules/audio_processing/agc2/limiter.h"
 #include "modules/audio_processing/include/audio_processing.h"
 #include "rtc_base/constructormagic.h"
 
@@ -43,9 +44,10 @@
  private:
   static int instance_count_;
   std::unique_ptr<ApmDataDumper> data_dumper_;
-  FixedGainController fixed_gain_controller_;
   AudioProcessing::Config::GainController2 config_;
-  AdaptiveAgc adaptive_agc_;
+  GainApplier gain_applier_;
+  std::unique_ptr<AdaptiveAgc> adaptive_agc_;
+  Limiter limiter_;
   int analog_level_ = -1;
   bool adaptive_digital_mode_ = true;
 
diff --git a/modules/audio_processing/gain_controller2_unittest.cc b/modules/audio_processing/gain_controller2_unittest.cc
index 5bedccd..caaefdd 100644
--- a/modules/audio_processing/gain_controller2_unittest.cc
+++ b/modules/audio_processing/gain_controller2_unittest.cc
@@ -10,20 +10,20 @@
 
 #include <algorithm>
 
+#include "absl/memory/memory.h"
 #include "api/array_view.h"
+#include "modules/audio_processing/agc2/agc2_testing_common.h"
 #include "modules/audio_processing/audio_buffer.h"
 #include "modules/audio_processing/gain_controller2.h"
+#include "modules/audio_processing/test/audio_buffer_tools.h"
+#include "modules/audio_processing/test/bitexactness_tools.h"
 #include "rtc_base/checks.h"
 #include "test/gtest.h"
 
 namespace webrtc {
 namespace test {
-
 namespace {
 
-constexpr size_t kFrameSizeMs = 10u;
-constexpr size_t kStereo = 2u;
-
 void SetAudioBufferSamples(float value, AudioBuffer* ab) {
   // Sets all the samples in |ab| to |value|.
   for (size_t k = 0; k < ab->num_channels(); ++k) {
@@ -32,6 +32,75 @@
   }
 }
 
+float RunAgc2WithConstantInput(GainController2* agc2,
+                               float input_level,
+                               size_t num_frames,
+                               int sample_rate) {
+  const int num_samples = rtc::CheckedDivExact(sample_rate, 100);
+  AudioBuffer ab(num_samples, 1, num_samples, 1, num_samples);
+
+  // Give time to the level estimator to converge.
+  for (size_t i = 0; i < num_frames + 1; ++i) {
+    SetAudioBufferSamples(input_level, &ab);
+    agc2->Process(&ab);
+  }
+
+  // Return the last sample from the last processed frame.
+  return ab.channels_f()[0][num_samples - 1];
+}
+
+AudioProcessing::Config::GainController2 CreateAgc2FixedDigitalModeConfig(
+    float fixed_gain_db) {
+  AudioProcessing::Config::GainController2 config;
+  config.adaptive_digital_mode = false;
+  config.fixed_gain_db = fixed_gain_db;
+  // TODO(alessiob): Check why ASSERT_TRUE() below does not compile.
+  EXPECT_TRUE(GainController2::Validate(config));
+  return config;
+}
+
+std::unique_ptr<GainController2> CreateAgc2FixedDigitalMode(
+    float fixed_gain_db,
+    size_t sample_rate_hz) {
+  auto agc2 = absl::make_unique<GainController2>();
+  agc2->ApplyConfig(CreateAgc2FixedDigitalModeConfig(fixed_gain_db));
+  agc2->Initialize(sample_rate_hz);
+  return agc2;
+}
+
+float GainAfterProcessingFile(GainController2* gain_controller) {
+  // Set up an AudioBuffer to be filled from the speech file.
+  constexpr size_t kStereo = 2u;
+  const StreamConfig capture_config(AudioProcessing::kSampleRate48kHz, kStereo,
+                                    false);
+  AudioBuffer ab(capture_config.num_frames(), capture_config.num_channels(),
+                 capture_config.num_frames(), capture_config.num_channels(),
+                 capture_config.num_frames());
+  test::InputAudioFile capture_file(
+      test::GetApmCaptureTestVectorFileName(AudioProcessing::kSampleRate48kHz));
+  std::vector<float> capture_input(capture_config.num_frames() *
+                                   capture_config.num_channels());
+
+  // The file should contain at least this many frames. Every iteration, we put
+  // a frame through the gain controller.
+  const int kNumFramesToProcess = 100;
+  for (int frame_no = 0; frame_no < kNumFramesToProcess; ++frame_no) {
+    ReadFloatSamplesFromStereoFile(capture_config.num_frames(),
+                                   capture_config.num_channels(), &capture_file,
+                                   capture_input);
+
+    test::CopyVectorToAudioBuffer(capture_config, capture_input, &ab);
+    gain_controller->Process(&ab);
+  }
+
+  // Send in a last frame with values constant 1 (It's low enough to detect high
+  // gain, and for ease of computation). The applied gain is the result.
+  constexpr float sample_value = 1.f;
+  SetAudioBufferSamples(sample_value, &ab);
+  gain_controller->Process(&ab);
+  return ab.channels_f()[0][0];
+}
+
 }  // namespace
 
 TEST(GainController2, CreateApplyConfig) {
@@ -69,22 +138,149 @@
             GainController2::ToString(config));
 }
 
-TEST(GainController2, Usage) {
-  // Tests GainController2::Process() on an AudioBuffer instance.
-  std::unique_ptr<GainController2> gain_controller2(new GainController2());
-  gain_controller2->Initialize(AudioProcessing::kSampleRate48kHz);
-  const size_t num_frames = rtc::CheckedDivExact<size_t>(
-      kFrameSizeMs * AudioProcessing::kSampleRate48kHz, 1000);
-  AudioBuffer ab(num_frames, kStereo, num_frames, kStereo, num_frames);
-  constexpr float sample_value = 1000.f;
-  SetAudioBufferSamples(sample_value, &ab);
-  AudioProcessing::Config::GainController2 config;
+TEST(GainController2FixedDigital, GainShouldChangeOnSetGain) {
+  constexpr float kInputLevel = 1000.f;
+  constexpr size_t kNumFrames = 5;
+  constexpr size_t kSampleRateHz = 8000;
+  constexpr float kGain0Db = 0.f;
+  constexpr float kGain20Db = 20.f;
 
-  // Check that samples are amplified when the fixed gain is greater than 0 dB.
-  config.fixed_gain_db = 5.f;
-  gain_controller2->ApplyConfig(config);
-  gain_controller2->Process(&ab);
-  EXPECT_LT(sample_value, ab.channels_f()[0][0]);
+  auto agc2_fixed = CreateAgc2FixedDigitalMode(kGain0Db, kSampleRateHz);
+
+  // Signal level is unchanged with 0 db gain.
+  EXPECT_FLOAT_EQ(RunAgc2WithConstantInput(agc2_fixed.get(), kInputLevel,
+                                           kNumFrames, kSampleRateHz),
+                  kInputLevel);
+
+  // +20 db should increase signal by a factor of 10.
+  agc2_fixed->ApplyConfig(CreateAgc2FixedDigitalModeConfig(kGain20Db));
+  EXPECT_FLOAT_EQ(RunAgc2WithConstantInput(agc2_fixed.get(), kInputLevel,
+                                           kNumFrames, kSampleRateHz),
+                  kInputLevel * 10);
+}
+
+TEST(GainController2FixedDigital, ChangeFixedGainShouldBeFastAndTimeInvariant) {
+  // Number of frames required for the fixed gain controller to adapt on the
+  // input signal when the gain changes.
+  constexpr size_t kNumFrames = 5;
+
+  constexpr float kInputLevel = 1000.f;
+  constexpr size_t kSampleRateHz = 8000;
+  constexpr float kGainDbLow = 0.f;
+  constexpr float kGainDbHigh = 25.f;
+  static_assert(kGainDbLow < kGainDbHigh, "");
+
+  auto agc2_fixed = CreateAgc2FixedDigitalMode(kGainDbLow, kSampleRateHz);
+
+  // Start with a lower gain.
+  const float output_level_pre = RunAgc2WithConstantInput(
+      agc2_fixed.get(), kInputLevel, kNumFrames, kSampleRateHz);
+
+  // Increase gain.
+  agc2_fixed->ApplyConfig(CreateAgc2FixedDigitalModeConfig(kGainDbHigh));
+  static_cast<void>(RunAgc2WithConstantInput(agc2_fixed.get(), kInputLevel,
+                                             kNumFrames, kSampleRateHz));
+
+  // Back to the lower gain.
+  agc2_fixed->ApplyConfig(CreateAgc2FixedDigitalModeConfig(kGainDbLow));
+  const float output_level_post = RunAgc2WithConstantInput(
+      agc2_fixed.get(), kInputLevel, kNumFrames, kSampleRateHz);
+
+  EXPECT_EQ(output_level_pre, output_level_post);
+}
+
+struct FixedDigitalTestParams {
+  FixedDigitalTestParams(float gain_db_min,
+                         float gain_db_max,
+                         size_t sample_rate,
+                         bool saturation_expected)
+      : gain_db_min(gain_db_min),
+        gain_db_max(gain_db_max),
+        sample_rate(sample_rate),
+        saturation_expected(saturation_expected) {}
+  float gain_db_min;
+  float gain_db_max;
+  size_t sample_rate;
+  bool saturation_expected;
+};
+
+class FixedDigitalTest
+    : public testing::Test,
+      public testing::WithParamInterface<FixedDigitalTestParams> {};
+
+TEST_P(FixedDigitalTest, CheckSaturationBehaviorWithLimiter) {
+  const float kInputLevel = 32767.f;
+  const size_t kNumFrames = 5;
+
+  const auto params = GetParam();
+
+  const auto gains_db =
+      test::LinSpace(params.gain_db_min, params.gain_db_max, 10);
+  for (const auto gain_db : gains_db) {
+    SCOPED_TRACE(std::to_string(gain_db));
+    auto agc2_fixed = CreateAgc2FixedDigitalMode(gain_db, params.sample_rate);
+    const float processed_sample = RunAgc2WithConstantInput(
+        agc2_fixed.get(), kInputLevel, kNumFrames, params.sample_rate);
+    if (params.saturation_expected) {
+      EXPECT_FLOAT_EQ(processed_sample, 32767.f);
+    } else {
+      EXPECT_LT(processed_sample, 32767.f);
+    }
+  }
+}
+
+static_assert(test::kLimiterMaxInputLevelDbFs < 10, "");
+INSTANTIATE_TEST_CASE_P(
+    GainController2,
+    FixedDigitalTest,
+    ::testing::Values(
+        // When gain < |test::kLimiterMaxInputLevelDbFs|, the limiter will not
+        // saturate the signal (at any sample rate).
+        FixedDigitalTestParams(0.1f,
+                               test::kLimiterMaxInputLevelDbFs - 0.01f,
+                               8000,
+                               false),
+        FixedDigitalTestParams(0.1,
+                               test::kLimiterMaxInputLevelDbFs - 0.01f,
+                               48000,
+                               false),
+        // When gain > |test::kLimiterMaxInputLevelDbFs|, the limiter will
+        // saturate the signal (at any sample rate).
+        FixedDigitalTestParams(test::kLimiterMaxInputLevelDbFs + 0.01f,
+                               10.f,
+                               8000,
+                               true),
+        FixedDigitalTestParams(test::kLimiterMaxInputLevelDbFs + 0.01f,
+                               10.f,
+                               48000,
+                               true)));
+
+TEST(GainController2, UsageSaturationMargin) {
+  GainController2 gain_controller2;
+  gain_controller2.Initialize(AudioProcessing::kSampleRate48kHz);
+
+  AudioProcessing::Config::GainController2 config;
+  // Check that samples are not amplified as much when extra margin is
+  // high. They should not be amplified at all, but only after convergence. GC2
+  // starts with a gain, and it takes time until it's down to 0 dB.
+  config.extra_saturation_margin_db = 50.f;
+  config.fixed_gain_db = 0.f;
+  gain_controller2.ApplyConfig(config);
+
+  EXPECT_LT(GainAfterProcessingFile(&gain_controller2), 2.f);
+}
+
+TEST(GainController2, UsageNoSaturationMargin) {
+  GainController2 gain_controller2;
+  gain_controller2.Initialize(AudioProcessing::kSampleRate48kHz);
+
+  AudioProcessing::Config::GainController2 config;
+  // Check that some gain is applied if there is no margin.
+  config.extra_saturation_margin_db = 0.f;
+  config.fixed_gain_db = 0.f;
+  gain_controller2.ApplyConfig(config);
+
+  EXPECT_GT(GainAfterProcessingFile(&gain_controller2), 2.f);
 }
 
 }  // namespace test
diff --git a/modules/audio_processing/include/aec_dump.h b/modules/audio_processing/include/aec_dump.h
index 313e9d7..b734adf 100644
--- a/modules/audio_processing/include/aec_dump.h
+++ b/modules/audio_processing/include/aec_dump.h
@@ -11,14 +11,13 @@
 #ifndef MODULES_AUDIO_PROCESSING_INCLUDE_AEC_DUMP_H_
 #define MODULES_AUDIO_PROCESSING_INCLUDE_AEC_DUMP_H_
 
-#include <memory>
+#include <stdint.h>
 #include <string>
-#include <vector>
 
-#include "api/array_view.h"
 #include "api/audio/audio_frame.h"
 #include "modules/audio_processing/include/audio_frame_view.h"
 #include "modules/audio_processing/include/audio_processing.h"
+#include "rtc_base/deprecation.h"
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/include/audio_processing.cc b/modules/audio_processing/include/audio_processing.cc
index 75eedaf..27cd882 100644
--- a/modules/audio_processing/include/audio_processing.cc
+++ b/modules/audio_processing/include/audio_processing.cc
@@ -10,8 +10,6 @@
 
 #include "modules/audio_processing/include/audio_processing.h"
 
-#include "rtc_base/checks.h"
-
 namespace webrtc {
 
 void CustomProcessing::SetRuntimeSetting(
diff --git a/modules/audio_processing/include/audio_processing.h b/modules/audio_processing/include/audio_processing.h
index 8af0cb2..b105ef1 100644
--- a/modules/audio_processing/include/audio_processing.h
+++ b/modules/audio_processing/include/audio_processing.h
@@ -49,7 +49,6 @@
 
 class EchoDetector;
 class GainControl;
-class HighPassFilter;
 class LevelEstimator;
 class NoiseSuppression;
 class CustomAudioAnalyzer;
@@ -241,7 +240,6 @@
   // by changing the default values in the AudioProcessing::Config struct.
   // The config is applied by passing the struct to the ApplyConfig method.
   struct Config {
-    // TODO(bugs.webrtc.org/9535): Currently unused. Use this to determine AEC.
     struct EchoCanceller {
       bool enabled = false;
       bool mobile_mode = false;
@@ -274,6 +272,7 @@
     struct GainController2 {
       bool enabled = false;
       bool adaptive_digital_mode = true;
+      float extra_saturation_margin_db = 2.f;
       float fixed_gain_db = 0.f;
     } gain_controller2;
 
@@ -521,85 +520,17 @@
   // specific member variables are reset.
   virtual void UpdateHistogramsOnCallEnd() = 0;
 
-  // TODO(ivoc): Remove when the calling code no longer uses the old Statistics
-  //             API.
-  struct Statistic {
-    int instant = 0;  // Instantaneous value.
-    int average = 0;  // Long-term average.
-    int maximum = 0;  // Long-term maximum.
-    int minimum = 0;  // Long-term minimum.
-  };
-
-  struct Stat {
-    void Set(const Statistic& other) {
-      Set(other.instant, other.average, other.maximum, other.minimum);
-    }
-    void Set(float instant, float average, float maximum, float minimum) {
-      instant_ = instant;
-      average_ = average;
-      maximum_ = maximum;
-      minimum_ = minimum;
-    }
-    float instant() const { return instant_; }
-    float average() const { return average_; }
-    float maximum() const { return maximum_; }
-    float minimum() const { return minimum_; }
-
-   private:
-    float instant_ = 0.0f;  // Instantaneous value.
-    float average_ = 0.0f;  // Long-term average.
-    float maximum_ = 0.0f;  // Long-term maximum.
-    float minimum_ = 0.0f;  // Long-term minimum.
-  };
-
-  struct RTC_EXPORT AudioProcessingStatistics {
-    AudioProcessingStatistics();
-    AudioProcessingStatistics(const AudioProcessingStatistics& other);
-    ~AudioProcessingStatistics();
-
-    // AEC Statistics.
-    // RERL = ERL + ERLE
-    Stat residual_echo_return_loss;
-    // ERL = 10log_10(P_far / P_echo)
-    Stat echo_return_loss;
-    // ERLE = 10log_10(P_echo / P_out)
-    Stat echo_return_loss_enhancement;
-    // (Pre non-linear processing suppression) A_NLP = 10log_10(P_echo / P_a)
-    Stat a_nlp;
-    // Fraction of time that the AEC linear filter is divergent, in a 1-second
-    // non-overlapped aggregation window.
-    float divergent_filter_fraction = -1.0f;
-
-    // The delay metrics consists of the delay median and standard deviation. It
-    // also consists of the fraction of delay estimates that can make the echo
-    // cancellation perform poorly. The values are aggregated until the first
-    // call to |GetStatistics()| and afterwards aggregated and updated every
-    // second. Note that if there are several clients pulling metrics from
-    // |GetStatistics()| during a session the first call from any of them will
-    // change to one second aggregation window for all.
-    int delay_median = -1;
-    int delay_standard_deviation = -1;
-    float fraction_poor_delays = -1.0f;
-
-    // Residual echo detector likelihood.
-    float residual_echo_likelihood = -1.0f;
-    // Maximum residual echo likelihood from the last time period.
-    float residual_echo_likelihood_recent_max = -1.0f;
-  };
-
-  // TODO(ivoc): Make this pure virtual when all subclasses have been updated.
-  virtual AudioProcessingStatistics GetStatistics() const;
-
-  // This returns the stats as optionals and it will replace the regular
-  // GetStatistics.
-  virtual AudioProcessingStats GetStatistics(bool has_remote_tracks) const;
+  // Get audio processing statistics. The |has_remote_tracks| argument should be
+  // set if there are active remote tracks (this would usually be true during
+  // a call). If there are no remote tracks some of the stats will not be set by
+  // AudioProcessing, because they only make sense if there is at least one
+  // remote track.
+  virtual AudioProcessingStats GetStatistics(bool has_remote_tracks) const = 0;
 
   // These provide access to the component interfaces and should never return
   // NULL. The pointers will be valid for the lifetime of the APM instance.
   // The memory for these objects is entirely managed internally.
   virtual GainControl* gain_control() const = 0;
-  // TODO(peah): Deprecate this API call.
-  virtual HighPassFilter* high_pass_filter() const = 0;
   virtual LevelEstimator* level_estimator() const = 0;
   virtual NoiseSuppression* noise_suppression() const = 0;
   virtual VoiceDetection* voice_detection() const = 0;
@@ -789,17 +720,6 @@
   StreamConfig streams[StreamName::kNumStreamNames];
 };
 
-// TODO(peah): Remove this interface.
-// A filtering component which removes DC offset and low-frequency noise.
-// Recommended to be enabled on the client-side.
-class HighPassFilter {
- public:
-  virtual int Enable(bool enable) = 0;
-  virtual bool is_enabled() const = 0;
-
-  virtual ~HighPassFilter() {}
-};
-
 // An estimation component used to retrieve level metrics.
 class LevelEstimator {
  public:
diff --git a/modules/audio_processing/include/audio_processing_statistics.h b/modules/audio_processing/include/audio_processing_statistics.h
index 2318bad..2ff2009 100644
--- a/modules/audio_processing/include/audio_processing_statistics.h
+++ b/modules/audio_processing/include/audio_processing_statistics.h
@@ -11,6 +11,8 @@
 #ifndef MODULES_AUDIO_PROCESSING_INCLUDE_AUDIO_PROCESSING_STATISTICS_H_
 #define MODULES_AUDIO_PROCESSING_INCLUDE_AUDIO_PROCESSING_STATISTICS_H_
 
+#include <stdint.h>
+
 #include "absl/types/optional.h"
 #include "rtc_base/system/rtc_export.h"
 
diff --git a/modules/audio_processing/include/mock_audio_processing.h b/modules/audio_processing/include/mock_audio_processing.h
index 4a1fe62..f00a16d 100644
--- a/modules/audio_processing/include/mock_audio_processing.h
+++ b/modules/audio_processing/include/mock_audio_processing.h
@@ -42,13 +42,6 @@
   MOCK_CONST_METHOD0(stream_is_saturated, bool());
 };
 
-class MockHighPassFilter : public HighPassFilter {
- public:
-  virtual ~MockHighPassFilter() {}
-  MOCK_METHOD1(Enable, int(bool enable));
-  MOCK_CONST_METHOD0(is_enabled, bool());
-};
-
 class MockLevelEstimator : public LevelEstimator {
  public:
   virtual ~MockLevelEstimator() {}
@@ -114,7 +107,6 @@
  public:
   MockAudioProcessing()
       : gain_control_(new testing::NiceMock<MockGainControl>()),
-        high_pass_filter_(new testing::NiceMock<MockHighPassFilter>()),
         level_estimator_(new testing::NiceMock<MockLevelEstimator>()),
         noise_suppression_(new testing::NiceMock<MockNoiseSuppression>()),
         voice_detection_(new testing::NiceMock<MockVoiceDetection>()) {}
@@ -180,12 +172,8 @@
   MOCK_METHOD0(DetachPlayoutAudioGenerator, void());
 
   MOCK_METHOD0(UpdateHistogramsOnCallEnd, void());
-  MOCK_CONST_METHOD0(GetStatistics, AudioProcessingStatistics());
   MOCK_CONST_METHOD1(GetStatistics, AudioProcessingStats(bool));
   virtual MockGainControl* gain_control() const { return gain_control_.get(); }
-  virtual MockHighPassFilter* high_pass_filter() const {
-    return high_pass_filter_.get();
-  }
   virtual MockLevelEstimator* level_estimator() const {
     return level_estimator_.get();
   }
@@ -200,7 +188,6 @@
 
  private:
   std::unique_ptr<MockGainControl> gain_control_;
-  std::unique_ptr<MockHighPassFilter> high_pass_filter_;
   std::unique_ptr<MockLevelEstimator> level_estimator_;
   std::unique_ptr<MockNoiseSuppression> noise_suppression_;
   std::unique_ptr<MockVoiceDetection> voice_detection_;
diff --git a/modules/audio_processing/level_estimator_impl.cc b/modules/audio_processing/level_estimator_impl.cc
index c937f84..5b49b35 100644
--- a/modules/audio_processing/level_estimator_impl.cc
+++ b/modules/audio_processing/level_estimator_impl.cc
@@ -10,9 +10,13 @@
 
 #include "modules/audio_processing/level_estimator_impl.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "api/array_view.h"
 #include "modules/audio_processing/audio_buffer.h"
 #include "modules/audio_processing/rms_level.h"
+#include "rtc_base/checks.h"
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/logging/apm_data_dumper.cc b/modules/audio_processing/logging/apm_data_dumper.cc
index e2e8602..45d8088 100644
--- a/modules/audio_processing/logging/apm_data_dumper.cc
+++ b/modules/audio_processing/logging/apm_data_dumper.cc
@@ -11,7 +11,6 @@
 #include "modules/audio_processing/logging/apm_data_dumper.h"
 
 #include "rtc_base/strings/string_builder.h"
-#include "rtc_base/stringutils.h"
 
 // Check to verify that the define is properly set.
 #if !defined(WEBRTC_APM_DEBUG_DUMP) || \
@@ -47,6 +46,8 @@
 ApmDataDumper::~ApmDataDumper() {}
 
 #if WEBRTC_APM_DEBUG_DUMP == 1
+bool ApmDataDumper::recording_activated_ = false;
+;
 FILE* ApmDataDumper::GetRawFile(const char* name) {
   std::string filename =
       FormFileName(name, instance_index_, recording_set_index_, ".dat");
diff --git a/modules/audio_processing/logging/apm_data_dumper.h b/modules/audio_processing/logging/apm_data_dumper.h
index d045027..f0c5978 100644
--- a/modules/audio_processing/logging/apm_data_dumper.h
+++ b/modules/audio_processing/logging/apm_data_dumper.h
@@ -11,14 +11,17 @@
 #ifndef MODULES_AUDIO_PROCESSING_LOGGING_APM_DATA_DUMPER_H_
 #define MODULES_AUDIO_PROCESSING_LOGGING_APM_DATA_DUMPER_H_
 
+#include <stdint.h>
 #include <stdio.h>
 
-#include <memory>
-#include <string>
+#if WEBRTC_APM_DEBUG_DUMP == 1
 #include <unordered_map>
+#endif
 
 #include "api/array_view.h"
+#if WEBRTC_APM_DEBUG_DUMP == 1
 #include "common_audio/wav_file.h"
+#endif
 #include "rtc_base/constructormagic.h"
 
 // Check to verify that the define is properly set.
@@ -47,6 +50,13 @@
 
   ~ApmDataDumper();
 
+  // Activates or deactivate the dumping functionality.
+  static void SetActivated(bool activated) {
+#if WEBRTC_APM_DEBUG_DUMP == 1
+    recording_activated_ = activated;
+#endif
+  }
+
   // Reinitializes the data dumping such that new versions
   // of all files being dumped to are created.
   void InitiateNewSetOfRecordings() {
@@ -59,117 +69,151 @@
   // various formats.
   void DumpRaw(const char* name, double v) {
 #if WEBRTC_APM_DEBUG_DUMP == 1
-    FILE* file = GetRawFile(name);
-    fwrite(&v, sizeof(v), 1, file);
+    if (recording_activated_) {
+      FILE* file = GetRawFile(name);
+      fwrite(&v, sizeof(v), 1, file);
+    }
 #endif
   }
 
   void DumpRaw(const char* name, size_t v_length, const double* v) {
 #if WEBRTC_APM_DEBUG_DUMP == 1
-    FILE* file = GetRawFile(name);
-    fwrite(v, sizeof(v[0]), v_length, file);
+    if (recording_activated_) {
+      FILE* file = GetRawFile(name);
+      fwrite(v, sizeof(v[0]), v_length, file);
+    }
 #endif
   }
 
   void DumpRaw(const char* name, rtc::ArrayView<const double> v) {
 #if WEBRTC_APM_DEBUG_DUMP == 1
-    DumpRaw(name, v.size(), v.data());
+    if (recording_activated_) {
+      DumpRaw(name, v.size(), v.data());
+    }
 #endif
   }
 
   void DumpRaw(const char* name, float v) {
 #if WEBRTC_APM_DEBUG_DUMP == 1
-    FILE* file = GetRawFile(name);
-    fwrite(&v, sizeof(v), 1, file);
+    if (recording_activated_) {
+      FILE* file = GetRawFile(name);
+      fwrite(&v, sizeof(v), 1, file);
+    }
 #endif
   }
 
   void DumpRaw(const char* name, size_t v_length, const float* v) {
 #if WEBRTC_APM_DEBUG_DUMP == 1
-    FILE* file = GetRawFile(name);
-    fwrite(v, sizeof(v[0]), v_length, file);
+    if (recording_activated_) {
+      FILE* file = GetRawFile(name);
+      fwrite(v, sizeof(v[0]), v_length, file);
+    }
 #endif
   }
 
   void DumpRaw(const char* name, rtc::ArrayView<const float> v) {
 #if WEBRTC_APM_DEBUG_DUMP == 1
-    DumpRaw(name, v.size(), v.data());
+    if (recording_activated_) {
+      DumpRaw(name, v.size(), v.data());
+    }
 #endif
   }
 
   void DumpRaw(const char* name, bool v) {
 #if WEBRTC_APM_DEBUG_DUMP == 1
-    DumpRaw(name, static_cast<int16_t>(v));
+    if (recording_activated_) {
+      DumpRaw(name, static_cast<int16_t>(v));
+    }
 #endif
   }
 
   void DumpRaw(const char* name, size_t v_length, const bool* v) {
 #if WEBRTC_APM_DEBUG_DUMP == 1
-    FILE* file = GetRawFile(name);
-    for (size_t k = 0; k < v_length; ++k) {
-      int16_t value = static_cast<int16_t>(v[k]);
-      fwrite(&value, sizeof(value), 1, file);
+    if (recording_activated_) {
+      FILE* file = GetRawFile(name);
+      for (size_t k = 0; k < v_length; ++k) {
+        int16_t value = static_cast<int16_t>(v[k]);
+        fwrite(&value, sizeof(value), 1, file);
+      }
     }
 #endif
   }
 
   void DumpRaw(const char* name, rtc::ArrayView<const bool> v) {
 #if WEBRTC_APM_DEBUG_DUMP == 1
-    DumpRaw(name, v.size(), v.data());
+    if (recording_activated_) {
+      DumpRaw(name, v.size(), v.data());
+    }
 #endif
   }
 
   void DumpRaw(const char* name, int16_t v) {
 #if WEBRTC_APM_DEBUG_DUMP == 1
-    FILE* file = GetRawFile(name);
-    fwrite(&v, sizeof(v), 1, file);
+    if (recording_activated_) {
+      FILE* file = GetRawFile(name);
+      fwrite(&v, sizeof(v), 1, file);
+    }
 #endif
   }
 
   void DumpRaw(const char* name, size_t v_length, const int16_t* v) {
 #if WEBRTC_APM_DEBUG_DUMP == 1
-    FILE* file = GetRawFile(name);
-    fwrite(v, sizeof(v[0]), v_length, file);
+    if (recording_activated_) {
+      FILE* file = GetRawFile(name);
+      fwrite(v, sizeof(v[0]), v_length, file);
+    }
 #endif
   }
 
   void DumpRaw(const char* name, rtc::ArrayView<const int16_t> v) {
 #if WEBRTC_APM_DEBUG_DUMP == 1
-    DumpRaw(name, v.size(), v.data());
+    if (recording_activated_) {
+      DumpRaw(name, v.size(), v.data());
+    }
 #endif
   }
 
   void DumpRaw(const char* name, int32_t v) {
 #if WEBRTC_APM_DEBUG_DUMP == 1
-    FILE* file = GetRawFile(name);
-    fwrite(&v, sizeof(v), 1, file);
+    if (recording_activated_) {
+      FILE* file = GetRawFile(name);
+      fwrite(&v, sizeof(v), 1, file);
+    }
 #endif
   }
 
   void DumpRaw(const char* name, size_t v_length, const int32_t* v) {
 #if WEBRTC_APM_DEBUG_DUMP == 1
-    FILE* file = GetRawFile(name);
-    fwrite(v, sizeof(v[0]), v_length, file);
+    if (recording_activated_) {
+      FILE* file = GetRawFile(name);
+      fwrite(v, sizeof(v[0]), v_length, file);
+    }
 #endif
   }
 
   void DumpRaw(const char* name, size_t v) {
 #if WEBRTC_APM_DEBUG_DUMP == 1
-    FILE* file = GetRawFile(name);
-    fwrite(&v, sizeof(v), 1, file);
+    if (recording_activated_) {
+      FILE* file = GetRawFile(name);
+      fwrite(&v, sizeof(v), 1, file);
+    }
 #endif
   }
 
   void DumpRaw(const char* name, size_t v_length, const size_t* v) {
 #if WEBRTC_APM_DEBUG_DUMP == 1
-    FILE* file = GetRawFile(name);
-    fwrite(v, sizeof(v[0]), v_length, file);
+    if (recording_activated_) {
+      FILE* file = GetRawFile(name);
+      fwrite(v, sizeof(v[0]), v_length, file);
+    }
 #endif
   }
 
   void DumpRaw(const char* name, rtc::ArrayView<const int32_t> v) {
 #if WEBRTC_APM_DEBUG_DUMP == 1
-    DumpRaw(name, v.size(), v.data());
+    if (recording_activated_) {
+      DumpRaw(name, v.size(), v.data());
+    }
 #endif
   }
 
@@ -179,8 +223,10 @@
                int sample_rate_hz,
                int num_channels) {
 #if WEBRTC_APM_DEBUG_DUMP == 1
-    WavWriter* file = GetWavFile(name, sample_rate_hz, num_channels);
-    file->WriteSamples(v, v_length);
+    if (recording_activated_) {
+      WavWriter* file = GetWavFile(name, sample_rate_hz, num_channels);
+      file->WriteSamples(v, v_length);
+    }
 #endif
   }
 
@@ -189,12 +235,15 @@
                int sample_rate_hz,
                int num_channels) {
 #if WEBRTC_APM_DEBUG_DUMP == 1
-    DumpWav(name, v.size(), v.data(), sample_rate_hz, num_channels);
+    if (recording_activated_) {
+      DumpWav(name, v.size(), v.data(), sample_rate_hz, num_channels);
+    }
 #endif
   }
 
  private:
 #if WEBRTC_APM_DEBUG_DUMP == 1
+  static bool recording_activated_;
   const int instance_index_;
   int recording_set_index_ = 0;
   std::unordered_map<std::string, std::unique_ptr<FILE, RawFileCloseFunctor>>
diff --git a/modules/audio_processing/low_cut_filter.cc b/modules/audio_processing/low_cut_filter.cc
index 5245c68..581d6bc 100644
--- a/modules/audio_processing/low_cut_filter.cc
+++ b/modules/audio_processing/low_cut_filter.cc
@@ -10,8 +10,13 @@
 
 #include "modules/audio_processing/low_cut_filter.h"
 
+#include <stdint.h>
+#include <cstring>
+
 #include "common_audio/signal_processing/include/signal_processing_library.h"
 #include "modules/audio_processing/audio_buffer.h"
+#include "modules/audio_processing/include/audio_processing.h"
+#include "rtc_base/checks.h"
 
 namespace webrtc {
 namespace {
diff --git a/modules/audio_processing/module.mk b/modules/audio_processing/module.mk
index e7beb84..1b1754f 100644
--- a/modules/audio_processing/module.mk
+++ b/modules/audio_processing/module.mk
@@ -122,6 +122,7 @@
 	modules/audio_processing/aec3/render_delay_controller.o \
 	modules/audio_processing/aec3/render_delay_controller2.o \
 	modules/audio_processing/aec3/render_delay_controller_metrics.o \
+	modules/audio_processing/aec3/render_reverb_model.o \
 	modules/audio_processing/aec3/render_signal_analyzer.o \
 	modules/audio_processing/aec3/residual_echo_estimator.o \
 	modules/audio_processing/aec3/reverb_decay_estimator.o \
@@ -157,11 +158,10 @@
 	modules/audio_processing/agc2/compute_interpolated_gain_curve.o \
 	modules/audio_processing/agc2/down_sampler.o \
 	modules/audio_processing/agc2/fixed_digital_level_estimator.o \
-	modules/audio_processing/agc2/fixed_gain_controller.o \
 	modules/audio_processing/agc2/gain_applier.o \
-	modules/audio_processing/agc2/gain_curve_applier.o \
 	modules/audio_processing/agc2/interpolated_gain_curve.o \
 	modules/audio_processing/agc2/limiter.o \
+	modules/audio_processing/agc2/limiter_db_gain_curve.o \
 	modules/audio_processing/agc2/noise_level_estimator.o \
 	modules/audio_processing/agc2/noise_spectrum_estimator.o \
 	modules/audio_processing/agc2/saturation_protector.o \
diff --git a/modules/audio_processing/noise_suppression_impl.cc b/modules/audio_processing/noise_suppression_impl.cc
index 15d4043..d8d9e32 100644
--- a/modules/audio_processing/noise_suppression_impl.cc
+++ b/modules/audio_processing/noise_suppression_impl.cc
@@ -11,9 +11,11 @@
 #include "modules/audio_processing/noise_suppression_impl.h"
 
 #include "modules/audio_processing/audio_buffer.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/constructormagic.h"
 #if defined(WEBRTC_NS_FLOAT)
 #include "modules/audio_processing/ns/noise_suppression.h"
+
 #define NS_CREATE WebRtcNs_Create
 #define NS_FREE WebRtcNs_Free
 #define NS_INIT WebRtcNs_Init
@@ -21,6 +23,7 @@
 typedef NsHandle NsState;
 #elif defined(WEBRTC_NS_FIXED)
 #include "modules/audio_processing/ns/noise_suppression_x.h"
+
 #define NS_CREATE WebRtcNsx_Create
 #define NS_FREE WebRtcNsx_Free
 #define NS_INIT WebRtcNsx_Init
diff --git a/modules/audio_processing/residual_echo_detector.cc b/modules/audio_processing/residual_echo_detector.cc
index e805013..3454214 100644
--- a/modules/audio_processing/residual_echo_detector.cc
+++ b/modules/audio_processing/residual_echo_detector.cc
@@ -13,9 +13,11 @@
 #include <algorithm>
 #include <numeric>
 
+#include "absl/types/optional.h"
 #include "modules/audio_processing/audio_buffer.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/atomicops.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "system_wrappers/include/metrics.h"
 
diff --git a/modules/audio_processing/rms_level.h b/modules/audio_processing/rms_level.h
index 9aa549a..e6b5849 100644
--- a/modules/audio_processing/rms_level.h
+++ b/modules/audio_processing/rms_level.h
@@ -11,6 +11,9 @@
 #ifndef MODULES_AUDIO_PROCESSING_RMS_LEVEL_H_
 #define MODULES_AUDIO_PROCESSING_RMS_LEVEL_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "absl/types/optional.h"
 #include "api/array_view.h"
 
diff --git a/modules/audio_processing/transient/moving_moments.cc b/modules/audio_processing/transient/moving_moments.cc
index a199bb0..83810bf 100644
--- a/modules/audio_processing/transient/moving_moments.cc
+++ b/modules/audio_processing/transient/moving_moments.cc
@@ -10,7 +10,7 @@
 
 #include "modules/audio_processing/transient/moving_moments.h"
 
-#include <cmath>
+#include <algorithm>
 
 #include "rtc_base/checks.h"
 
diff --git a/modules/audio_processing/transient/transient_detector.cc b/modules/audio_processing/transient/transient_detector.cc
index c3bf282..8997d4c 100644
--- a/modules/audio_processing/transient/transient_detector.cc
+++ b/modules/audio_processing/transient/transient_detector.cc
@@ -13,12 +13,12 @@
 #include <float.h>
 #include <math.h>
 #include <string.h>
-
 #include <algorithm>
 
 #include "modules/audio_processing/transient/common.h"
 #include "modules/audio_processing/transient/daubechies_8_wavelet_coeffs.h"
 #include "modules/audio_processing/transient/moving_moments.h"
+#include "modules/audio_processing/transient/wpd_node.h"
 #include "modules/audio_processing/transient/wpd_tree.h"
 #include "rtc_base/checks.h"
 
diff --git a/modules/audio_processing/transient/transient_detector.h b/modules/audio_processing/transient/transient_detector.h
index 3267b3a..23b88f8 100644
--- a/modules/audio_processing/transient/transient_detector.h
+++ b/modules/audio_processing/transient/transient_detector.h
@@ -11,6 +11,7 @@
 #ifndef MODULES_AUDIO_PROCESSING_TRANSIENT_TRANSIENT_DETECTOR_H_
 #define MODULES_AUDIO_PROCESSING_TRANSIENT_TRANSIENT_DETECTOR_H_
 
+#include <stddef.h>
 #include <deque>
 #include <memory>
 
diff --git a/modules/audio_processing/transient/transient_suppression_test.cc b/modules/audio_processing/transient/transient_suppression_test.cc
index 9e7ecd5..e15f69c 100644
--- a/modules/audio_processing/transient/transient_suppression_test.cc
+++ b/modules/audio_processing/transient/transient_suppression_test.cc
@@ -23,26 +23,28 @@
 #include "test/gtest.h"
 #include "test/testsupport/fileutils.h"
 
-DEFINE_string(in_file_name, "", "PCM file that contains the signal.");
-DEFINE_string(detection_file_name,
-              "",
-              "PCM file that contains the detection signal.");
-DEFINE_string(reference_file_name,
-              "",
-              "PCM file that contains the reference signal.");
+WEBRTC_DEFINE_string(in_file_name, "", "PCM file that contains the signal.");
+WEBRTC_DEFINE_string(detection_file_name,
+                     "",
+                     "PCM file that contains the detection signal.");
+WEBRTC_DEFINE_string(reference_file_name,
+                     "",
+                     "PCM file that contains the reference signal.");
 
-DEFINE_int(chunk_size_ms,
-           10,
-           "Time between each chunk of samples in milliseconds.");
+WEBRTC_DEFINE_int(chunk_size_ms,
+                  10,
+                  "Time between each chunk of samples in milliseconds.");
 
-DEFINE_int(sample_rate_hz, 16000, "Sampling frequency of the signal in Hertz.");
-DEFINE_int(detection_rate_hz,
-           0,
-           "Sampling frequency of the detection signal in Hertz.");
+WEBRTC_DEFINE_int(sample_rate_hz,
+                  16000,
+                  "Sampling frequency of the signal in Hertz.");
+WEBRTC_DEFINE_int(detection_rate_hz,
+                  0,
+                  "Sampling frequency of the detection signal in Hertz.");
 
-DEFINE_int(num_channels, 1, "Number of channels.");
+WEBRTC_DEFINE_int(num_channels, 1, "Number of channels.");
 
-DEFINE_bool(help, false, "Print this message.");
+WEBRTC_DEFINE_bool(help, false, "Print this message.");
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/transient/transient_suppressor.h b/modules/audio_processing/transient/transient_suppressor.h
index 9ae3fc6..ae51966 100644
--- a/modules/audio_processing/transient/transient_suppressor.h
+++ b/modules/audio_processing/transient/transient_suppressor.h
@@ -11,9 +11,9 @@
 #ifndef MODULES_AUDIO_PROCESSING_TRANSIENT_TRANSIENT_SUPPRESSOR_H_
 #define MODULES_AUDIO_PROCESSING_TRANSIENT_TRANSIENT_SUPPRESSOR_H_
 
-#include <deque>
+#include <stddef.h>
+#include <stdint.h>
 #include <memory>
-#include <set>
 
 #include "rtc_base/gtest_prod_util.h"
 
diff --git a/modules/audio_processing/transient/wpd_tree.cc b/modules/audio_processing/transient/wpd_tree.cc
index 72f4d76..c8aa615 100644
--- a/modules/audio_processing/transient/wpd_tree.cc
+++ b/modules/audio_processing/transient/wpd_tree.cc
@@ -10,10 +10,8 @@
 
 #include "modules/audio_processing/transient/wpd_tree.h"
 
-#include <math.h>
 #include <string.h>
 
-#include "modules/audio_processing/transient/dyadic_decimator.h"
 #include "modules/audio_processing/transient/wpd_node.h"
 #include "rtc_base/checks.h"
 
diff --git a/modules/audio_processing/transient/wpd_tree.h b/modules/audio_processing/transient/wpd_tree.h
index 707a89d..b62135d 100644
--- a/modules/audio_processing/transient/wpd_tree.h
+++ b/modules/audio_processing/transient/wpd_tree.h
@@ -11,6 +11,7 @@
 #ifndef MODULES_AUDIO_PROCESSING_TRANSIENT_WPD_TREE_H_
 #define MODULES_AUDIO_PROCESSING_TRANSIENT_WPD_TREE_H_
 
+#include <stddef.h>
 #include <memory>
 
 #include "modules/audio_processing/transient/wpd_node.h"
diff --git a/modules/audio_processing/utility/ooura_fft.cc b/modules/audio_processing/utility/ooura_fft.cc
index c3333ce..8628bd3 100644
--- a/modules/audio_processing/utility/ooura_fft.cc
+++ b/modules/audio_processing/utility/ooura_fft.cc
@@ -23,8 +23,6 @@
 
 #include "modules/audio_processing/utility/ooura_fft.h"
 
-#include <math.h>
-
 #include "modules/audio_processing/utility/ooura_fft_tables_common.h"
 #include "rtc_base/system/arch.h"
 #include "system_wrappers/include/cpu_features_wrapper.h"
diff --git a/modules/audio_processing/utility/ooura_fft_sse2.cc b/modules/audio_processing/utility/ooura_fft_sse2.cc
index 9b5d0f3..0e4a44b 100644
--- a/modules/audio_processing/utility/ooura_fft_sse2.cc
+++ b/modules/audio_processing/utility/ooura_fft_sse2.cc
@@ -8,10 +8,10 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-#include "modules/audio_processing/utility/ooura_fft.h"
-
 #include <emmintrin.h>
+#include <xmmintrin.h>
 
+#include "modules/audio_processing/utility/ooura_fft.h"
 #include "modules/audio_processing/utility/ooura_fft_tables_common.h"
 #include "modules/audio_processing/utility/ooura_fft_tables_neon_sse2.h"
 #include "rtc_base/system/arch.h"
diff --git a/modules/audio_processing/vad/gmm.cc b/modules/audio_processing/vad/gmm.cc
index cd8a1a8..3b8764c 100644
--- a/modules/audio_processing/vad/gmm.cc
+++ b/modules/audio_processing/vad/gmm.cc
@@ -11,7 +11,6 @@
 #include "modules/audio_processing/vad/gmm.h"
 
 #include <math.h>
-#include <stdlib.h>
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/vad/pitch_based_vad.cc b/modules/audio_processing/vad/pitch_based_vad.cc
index 025ef20..68e60dc 100644
--- a/modules/audio_processing/vad/pitch_based_vad.cc
+++ b/modules/audio_processing/vad/pitch_based_vad.cc
@@ -10,7 +10,6 @@
 
 #include "modules/audio_processing/vad/pitch_based_vad.h"
 
-#include <math.h>
 #include <string.h>
 
 #include "modules/audio_processing/vad/common.h"
diff --git a/modules/audio_processing/vad/pitch_based_vad.h b/modules/audio_processing/vad/pitch_based_vad.h
index 4d32765..22bc0f2 100644
--- a/modules/audio_processing/vad/pitch_based_vad.h
+++ b/modules/audio_processing/vad/pitch_based_vad.h
@@ -18,7 +18,6 @@
 
 namespace webrtc {
 
-class AudioFrame;
 class VadCircularBuffer;
 
 // Computes the probability of the input audio frame to be active given
diff --git a/modules/audio_processing/vad/pole_zero_filter.cc b/modules/audio_processing/vad/pole_zero_filter.cc
index b9967d7..4156d7e 100644
--- a/modules/audio_processing/vad/pole_zero_filter.cc
+++ b/modules/audio_processing/vad/pole_zero_filter.cc
@@ -10,7 +10,6 @@
 
 #include "modules/audio_processing/vad/pole_zero_filter.h"
 
-#include <stdlib.h>
 #include <string.h>
 #include <algorithm>
 
diff --git a/modules/audio_processing/vad/standalone_vad.cc b/modules/audio_processing/vad/standalone_vad.cc
index 19a5282..1397668 100644
--- a/modules/audio_processing/vad/standalone_vad.cc
+++ b/modules/audio_processing/vad/standalone_vad.cc
@@ -12,7 +12,7 @@
 
 #include <string.h>
 
-#include "audio/utility/audio_frame_operations.h"
+#include "common_audio/vad/include/webrtc_vad.h"
 #include "rtc_base/checks.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/vad/standalone_vad.h b/modules/audio_processing/vad/standalone_vad.h
index 79650fb..3dff416 100644
--- a/modules/audio_processing/vad/standalone_vad.h
+++ b/modules/audio_processing/vad/standalone_vad.h
@@ -11,13 +11,14 @@
 #ifndef MODULES_AUDIO_PROCESSING_AGC_STANDALONE_VAD_H_
 #define MODULES_AUDIO_PROCESSING_AGC_STANDALONE_VAD_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "common_audio/vad/include/webrtc_vad.h"
 #include "modules/audio_processing/vad/common.h"
 
 namespace webrtc {
 
-class AudioFrame;
-
 class StandaloneVad {
  public:
   static StandaloneVad* Create();
diff --git a/modules/audio_processing/vad/vad_audio_proc.h b/modules/audio_processing/vad/vad_audio_proc.h
index e34091b..9be3467 100644
--- a/modules/audio_processing/vad/vad_audio_proc.h
+++ b/modules/audio_processing/vad/vad_audio_proc.h
@@ -11,13 +11,14 @@
 #ifndef MODULES_AUDIO_PROCESSING_VAD_VAD_AUDIO_PROC_H_
 #define MODULES_AUDIO_PROCESSING_VAD_VAD_AUDIO_PROC_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <memory>
 
-#include "modules/audio_processing/vad/common.h"
+#include "modules/audio_processing/vad/common.h"  // AudioFeatures, kSampleR...
 
 namespace webrtc {
 
-class AudioFrame;
 class PoleZeroFilter;
 
 class VadAudioProc {
diff --git a/modules/audio_processing/vad/voice_activity_detector.h b/modules/audio_processing/vad/voice_activity_detector.h
index e424ac1..d140fe2 100644
--- a/modules/audio_processing/vad/voice_activity_detector.h
+++ b/modules/audio_processing/vad/voice_activity_detector.h
@@ -11,6 +11,8 @@
 #ifndef MODULES_AUDIO_PROCESSING_VAD_VOICE_ACTIVITY_DETECTOR_H_
 #define MODULES_AUDIO_PROCESSING_VAD_VOICE_ACTIVITY_DETECTOR_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <memory>
 #include <vector>
 
diff --git a/modules/audio_processing/voice_detection_impl.cc b/modules/audio_processing/voice_detection_impl.cc
index 9280be1..c55ca4a 100644
--- a/modules/audio_processing/voice_detection_impl.cc
+++ b/modules/audio_processing/voice_detection_impl.cc
@@ -10,8 +10,10 @@
 
 #include "modules/audio_processing/voice_detection_impl.h"
 
+#include "api/audio/audio_frame.h"
 #include "common_audio/vad/include/webrtc_vad.h"
 #include "modules/audio_processing/audio_buffer.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
diff --git a/modules/audio_processing/voice_detection_impl.h b/modules/audio_processing/voice_detection_impl.h
index 4b724bd..c438473 100644
--- a/modules/audio_processing/voice_detection_impl.h
+++ b/modules/audio_processing/voice_detection_impl.h
@@ -11,11 +11,13 @@
 #ifndef MODULES_AUDIO_PROCESSING_VOICE_DETECTION_IMPL_H_
 #define MODULES_AUDIO_PROCESSING_VOICE_DETECTION_IMPL_H_
 
+#include <stddef.h>
 #include <memory>
 
 #include "modules/audio_processing/include/audio_processing.h"
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/criticalsection.h"
+#include "rtc_base/thread_annotations.h"
 
 namespace webrtc {
 
@@ -42,6 +44,7 @@
 
  private:
   class Vad;
+
   rtc::CriticalSection* const crit_;
   bool enabled_ RTC_GUARDED_BY(crit_) = false;
   bool stream_has_voice_ RTC_GUARDED_BY(crit_) = false;
diff --git a/modules/include/module_common_types.cc b/modules/include/module_common_types.cc
index 4ad5d14..80eba2e 100644
--- a/modules/include/module_common_types.cc
+++ b/modules/include/module_common_types.cc
@@ -11,6 +11,7 @@
 #include "modules/include/module_common_types.h"
 
 #include <string.h>
+#include <cstdint>
 #include <utility>
 
 #include "rtc_base/numerics/safe_conversions.h"
diff --git a/modules/include/module_common_types.h b/modules/include/module_common_types.h
index 98ff767..e058cc8 100644
--- a/modules/include/module_common_types.h
+++ b/modules/include/module_common_types.h
@@ -19,6 +19,7 @@
 #include "modules/include/module_common_types_public.h"
 #include "modules/include/module_fec_types.h"
 #include "modules/rtp_rtcp/source/rtp_video_header.h"
+#include "rtc_base/system/rtc_export.h"
 
 namespace webrtc {
 
@@ -33,7 +34,7 @@
   int64_t ntp_time_ms;
 };
 
-class RTPFragmentationHeader {
+class RTC_EXPORT RTPFragmentationHeader {
  public:
   RTPFragmentationHeader();
   RTPFragmentationHeader(const RTPFragmentationHeader&) = delete;
diff --git a/modules/rtp_rtcp/BUILD.gn b/modules/rtp_rtcp/BUILD.gn
index a4774d8..4f62184 100644
--- a/modules/rtp_rtcp/BUILD.gn
+++ b/modules/rtp_rtcp/BUILD.gn
@@ -85,6 +85,7 @@
 
   deps = [
     "..:module_api",
+    "..:module_api_public",
     "../..:webrtc_common",
     "../../api:array_view",
     "../../api:libjingle_peerconnection_api",
@@ -96,6 +97,7 @@
     "../../rtc_base:deprecation",
     "../../rtc_base:rtc_base_approved",
     "../../system_wrappers",
+    "../video_coding:codec_globals_headers",
     "//third_party/abseil-cpp/absl/types:optional",
     "//third_party/abseil-cpp/absl/types:variant",
   ]
@@ -186,7 +188,10 @@
 
   deps = [
     ":rtp_rtcp_format",
+    ":rtp_video_header",
     "..:module_api",
+    "..:module_api_public",
+    "..:module_fec_api",
     "../..:webrtc_common",
     "../../api:array_view",
     "../../api:libjingle_peerconnection_api",
@@ -194,6 +199,7 @@
     "../../api/audio_codecs:audio_codecs_api",
     "../../api/video:video_bitrate_allocation",
     "../../api/video:video_bitrate_allocator",
+    "../../api/video:video_frame",
     "../../api/video_codecs:video_codecs_api",
     "../../call:rtp_interfaces",
     "../../common_video",
@@ -216,9 +222,12 @@
     "../../system_wrappers:metrics",
     "../audio_coding:audio_format_conversion",
     "../remote_bitrate_estimator",
+    "../video_coding:codec_globals_headers",
     "//third_party/abseil-cpp/absl/container:inlined_vector",
     "//third_party/abseil-cpp/absl/memory",
+    "//third_party/abseil-cpp/absl/strings",
     "//third_party/abseil-cpp/absl/types:optional",
+    "//third_party/abseil-cpp/absl/types:variant",
   ]
 }
 
@@ -263,6 +272,7 @@
     "../../api/video:video_frame",
     "../../modules/video_coding:codec_globals_headers",
     "//third_party/abseil-cpp/absl/container:inlined_vector",
+    "//third_party/abseil-cpp/absl/types:optional",
     "//third_party/abseil-cpp/absl/types:variant",
   ]
 }
@@ -321,6 +331,7 @@
       ":rtp_rtcp",
       "../../test:fileutils",
       "../../test:test_main",
+      "../../test:test_support",
       "//testing/gtest",
     ]
   }  # test_packet_masks_metrics
diff --git a/modules/rtp_rtcp/include/flexfec_receiver.h b/modules/rtp_rtcp/include/flexfec_receiver.h
index f006111..f0ed576 100644
--- a/modules/rtp_rtcp/include/flexfec_receiver.h
+++ b/modules/rtp_rtcp/include/flexfec_receiver.h
@@ -11,16 +11,20 @@
 #ifndef MODULES_RTP_RTCP_INCLUDE_FLEXFEC_RECEIVER_H_
 #define MODULES_RTP_RTCP_INCLUDE_FLEXFEC_RECEIVER_H_
 
+#include <stdint.h>
 #include <memory>
 
+#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/rtp_rtcp/include/ulpfec_receiver.h"
 #include "modules/rtp_rtcp/source/forward_error_correction.h"
 #include "modules/rtp_rtcp/source/rtp_packet_received.h"
 #include "rtc_base/sequenced_task_checker.h"
-#include "system_wrappers/include/clock.h"
+#include "rtc_base/thread_annotations.h"
 
 namespace webrtc {
 
+class Clock;
+
 class FlexfecReceiver {
  public:
   FlexfecReceiver(uint32_t ssrc,
diff --git a/modules/rtp_rtcp/include/flexfec_sender.h b/modules/rtp_rtcp/include/flexfec_sender.h
index 12277e1..acee117 100644
--- a/modules/rtp_rtcp/include/flexfec_sender.h
+++ b/modules/rtp_rtcp/include/flexfec_sender.h
@@ -18,17 +18,15 @@
 #include "api/array_view.h"
 #include "api/rtpparameters.h"
 #include "modules/include/module_common_types.h"
-#include "modules/rtp_rtcp/include/flexfec_sender.h"
 #include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/rtp_rtcp/source/rtp_header_extension_size.h"
-#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
 #include "modules/rtp_rtcp/source/ulpfec_generator.h"
 #include "rtc_base/random.h"
-#include "system_wrappers/include/clock.h"
 
 namespace webrtc {
 
+class Clock;
 class RtpPacketToSend;
 
 // Note that this class is not thread safe, and thus requires external
diff --git a/modules/rtp_rtcp/include/remote_ntp_time_estimator.h b/modules/rtp_rtcp/include/remote_ntp_time_estimator.h
index 5195e8a..e6d269c 100644
--- a/modules/rtp_rtcp/include/remote_ntp_time_estimator.h
+++ b/modules/rtp_rtcp/include/remote_ntp_time_estimator.h
@@ -11,7 +11,7 @@
 #ifndef MODULES_RTP_RTCP_INCLUDE_REMOTE_NTP_TIME_ESTIMATOR_H_
 #define MODULES_RTP_RTCP_INCLUDE_REMOTE_NTP_TIME_ESTIMATOR_H_
 
-#include <memory>
+#include <stdint.h>
 
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/numerics/moving_median_filter.h"
diff --git a/modules/rtp_rtcp/include/rtp_header_extension_map.h b/modules/rtp_rtcp/include/rtp_header_extension_map.h
index b8f27a1..391c5be 100644
--- a/modules/rtp_rtcp/include/rtp_header_extension_map.h
+++ b/modules/rtp_rtcp/include/rtp_header_extension_map.h
@@ -11,6 +11,7 @@
 #ifndef MODULES_RTP_RTCP_INCLUDE_RTP_HEADER_EXTENSION_MAP_H_
 #define MODULES_RTP_RTCP_INCLUDE_RTP_HEADER_EXTENSION_MAP_H_
 
+#include <stdint.h>
 #include <string>
 
 #include "api/array_view.h"
@@ -26,6 +27,7 @@
   static constexpr int kInvalidId = 0;
 
   RtpHeaderExtensionMap();
+  explicit RtpHeaderExtensionMap(bool extmap_allow_mixed);
   explicit RtpHeaderExtensionMap(rtc::ArrayView<const RtpExtension> extensions);
 
   template <typename Extension>
@@ -53,18 +55,19 @@
   }
   int32_t Deregister(RTPExtensionType type);
 
-  bool IsMixedOneTwoByteHeaderSupported() const {
-    return mixed_one_two_byte_header_supported_;
-  }
-  void SetMixedOneTwoByteHeaderSupported(bool supported) {
-    mixed_one_two_byte_header_supported_ = supported;
+  // Corresponds to the SDP attribute extmap-allow-mixed, see RFC8285.
+  // Set to true if it's allowed to mix one- and two-byte RTP header extensions
+  // in the same stream.
+  bool ExtmapAllowMixed() const { return extmap_allow_mixed_; }
+  void SetExtmapAllowMixed(bool extmap_allow_mixed) {
+    extmap_allow_mixed_ = extmap_allow_mixed;
   }
 
  private:
   bool Register(int id, RTPExtensionType type, const char* uri);
 
   uint8_t ids_[kRtpExtensionNumberOfExtensions];
-  bool mixed_one_two_byte_header_supported_;
+  bool extmap_allow_mixed_;
 };
 
 }  // namespace webrtc
diff --git a/modules/rtp_rtcp/include/rtp_rtcp.h b/modules/rtp_rtcp/include/rtp_rtcp.h
index a99544c..265046c 100644
--- a/modules/rtp_rtcp/include/rtp_rtcp.h
+++ b/modules/rtp_rtcp/include/rtp_rtcp.h
@@ -28,6 +28,7 @@
 namespace webrtc {
 
 // Forward declarations.
+class FrameEncryptorInterface;
 class OverheadObserver;
 class RateLimiter;
 class ReceiveStatisticsProvider;
@@ -97,6 +98,14 @@
     // Update network2 instead of pacer_exit field of video timing extension.
     bool populate_network2_timestamp = false;
 
+    // E2EE Custom Video Frame Encryption
+    FrameEncryptorInterface* frame_encryptor = nullptr;
+    // Require all outgoing frames to be encrypted with a FrameEncryptor.
+    bool require_frame_encryption = false;
+
+    // Corresponds to extmap-allow-mixed in SDP negotiation.
+    bool extmap_allow_mixed = false;
+
    private:
     RTC_DISALLOW_COPY_AND_ASSIGN(Configuration);
   };
@@ -136,6 +145,8 @@
   // Returns -1 on failure else 0.
   virtual int32_t DeRegisterSendPayload(int8_t payload_type) = 0;
 
+  virtual void SetExtmapAllowMixed(bool extmap_allow_mixed) = 0;
+
   // (De)registers RTP header extension type and id.
   // Returns -1 on failure else 0.
   virtual int32_t RegisterSendRtpHeaderExtension(RTPExtensionType type,
diff --git a/modules/rtp_rtcp/include/rtp_rtcp_defines.cc b/modules/rtp_rtcp/include/rtp_rtcp_defines.cc
index e1dca33..1da8ade 100644
--- a/modules/rtp_rtcp/include/rtp_rtcp_defines.cc
+++ b/modules/rtp_rtcp/include/rtp_rtcp_defines.cc
@@ -10,6 +10,13 @@
 
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 
+#include <ctype.h>
+#include <string.h>
+#include <algorithm>
+#include <type_traits>
+
+#include "api/array_view.h"
+
 namespace webrtc {
 
 StreamDataCounters::StreamDataCounters() : first_packet_time_ms(-1) {}
diff --git a/modules/rtp_rtcp/include/rtp_rtcp_defines.h b/modules/rtp_rtcp/include/rtp_rtcp_defines.h
index e587313..5b9a051 100644
--- a/modules/rtp_rtcp/include/rtp_rtcp_defines.h
+++ b/modules/rtp_rtcp/include/rtp_rtcp_defines.h
@@ -32,9 +32,9 @@
 }
 
 const int kVideoPayloadTypeFrequency = 90000;
-// TODO(solenberg): RTP time stamp rate for RTCP is fixed at 8k, this is legacy
-// and should be fixed.
-// See: https://bugs.chromium.org/p/webrtc/issues/detail?id=6458
+
+// TODO(bugs.webrtc.org/6458): Remove this when all the depending projects are
+// updated to correctly set rtp rate for RtcpSender.
 const int kBogusRtpRateForAudioRtcp = 8000;
 
 // Minimum RTP header size in bytes.
diff --git a/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h b/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
index e95bdd3..9f00654 100644
--- a/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
+++ b/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
@@ -52,6 +52,7 @@
   MOCK_METHOD2(RegisterVideoSendPayload,
                void(int payload_type, const char* payload_name));
   MOCK_METHOD1(DeRegisterSendPayload, int32_t(int8_t payload_type));
+  MOCK_METHOD1(SetExtmapAllowMixed, void(bool extmap_allow_mixed));
   MOCK_METHOD2(RegisterSendRtpHeaderExtension,
                int32_t(RTPExtensionType type, uint8_t id));
   MOCK_METHOD2(RegisterRtpHeaderExtension,
diff --git a/modules/rtp_rtcp/source/contributing_sources.cc b/modules/rtp_rtcp/source/contributing_sources.cc
index 853706c..64dc443 100644
--- a/modules/rtp_rtcp/source/contributing_sources.cc
+++ b/modules/rtp_rtcp/source/contributing_sources.cc
@@ -25,9 +25,11 @@
 ContributingSources::~ContributingSources() = default;
 
 void ContributingSources::Update(int64_t now_ms,
-                                 rtc::ArrayView<const uint32_t> csrcs) {
+                                 rtc::ArrayView<const uint32_t> csrcs,
+                                 absl::optional<uint8_t> audio_level) {
+  Entry entry = { now_ms, audio_level };
   for (uint32_t csrc : csrcs) {
-    last_seen_ms_[csrc] = now_ms;
+    active_csrcs_[csrc] = entry;
   }
   if (!next_pruning_ms_) {
     next_pruning_ms_ = now_ms + kPruningIntervalMs;
@@ -43,9 +45,16 @@
 // non-const.
 std::vector<RtpSource> ContributingSources::GetSources(int64_t now_ms) const {
   std::vector<RtpSource> sources;
-  for (auto& record : last_seen_ms_) {
-    if (record.second >= now_ms - kHistoryMs) {
-      sources.emplace_back(record.second, record.first, RtpSourceType::CSRC);
+  for (auto& record : active_csrcs_) {
+    if (record.second.last_seen_ms >= now_ms - kHistoryMs) {
+      if (record.second.audio_level.has_value()) {
+        sources.emplace_back(record.second.last_seen_ms, record.first,
+                             RtpSourceType::CSRC,
+                             *record.second.audio_level);
+      } else {
+        sources.emplace_back(record.second.last_seen_ms, record.first,
+                             RtpSourceType::CSRC);
+      }
     }
   }
 
@@ -54,15 +63,20 @@
 
 // Delete stale entries.
 void ContributingSources::DeleteOldEntries(int64_t now_ms) {
-  for (auto it = last_seen_ms_.begin(); it != last_seen_ms_.end();) {
-    if (it->second >= now_ms - kHistoryMs) {
+  for (auto it = active_csrcs_.begin(); it != active_csrcs_.end();) {
+    if (it->second.last_seen_ms >= now_ms - kHistoryMs) {
       // Still relevant.
       ++it;
     } else {
-      it = last_seen_ms_.erase(it);
+      it = active_csrcs_.erase(it);
     }
   }
   next_pruning_ms_ = now_ms + kPruningIntervalMs;
 }
 
+ContributingSources::Entry::Entry() = default;
+ContributingSources::Entry::Entry(int64_t timestamp_ms,
+                                  absl::optional<uint8_t> audio_level_arg)
+    : last_seen_ms(timestamp_ms), audio_level(audio_level_arg) {}
+
 }  // namespace webrtc
diff --git a/modules/rtp_rtcp/source/contributing_sources.h b/modules/rtp_rtcp/source/contributing_sources.h
index b6201ce..5e34539 100644
--- a/modules/rtp_rtcp/source/contributing_sources.h
+++ b/modules/rtp_rtcp/source/contributing_sources.h
@@ -32,18 +32,25 @@
   ContributingSources();
   ~ContributingSources();
 
-  // TODO(bugs.webrtc.org/3333): Needs to be extended with audio-level, to
-  // support RFC6465.
-  void Update(int64_t now_ms, rtc::ArrayView<const uint32_t> csrcs);
+  void Update(int64_t now_ms, rtc::ArrayView<const uint32_t> csrcs,
+              absl::optional<uint8_t> audio_level);
 
   // Returns contributing sources seen the last 10 s.
   std::vector<RtpSource> GetSources(int64_t now_ms) const;
 
  private:
+  struct Entry {
+    Entry();
+    Entry(int64_t timestamp_ms, absl::optional<uint8_t> audio_level);
+
+    int64_t last_seen_ms;
+    absl::optional<uint8_t> audio_level;
+  };
+
   void DeleteOldEntries(int64_t now_ms);
 
   // Indexed by csrc.
-  std::map<uint32_t, int64_t> last_seen_ms_;
+  std::map<uint32_t, Entry> active_csrcs_;
   absl::optional<int64_t> next_pruning_ms_;
 };
 
diff --git a/modules/rtp_rtcp/source/contributing_sources_unittest.cc b/modules/rtp_rtcp/source/contributing_sources_unittest.cc
index 8b22d26..5f1d8d3 100644
--- a/modules/rtp_rtcp/source/contributing_sources_unittest.cc
+++ b/modules/rtp_rtcp/source/contributing_sources_unittest.cc
@@ -30,7 +30,7 @@
   ContributingSources csrcs;
   constexpr uint32_t kCsrcs[] = {kCsrc1, kCsrc2};
   constexpr int64_t kTime1 = 10;
-  csrcs.Update(kTime1, kCsrcs);
+  csrcs.Update(kTime1, kCsrcs, absl::nullopt);
   EXPECT_THAT(
       csrcs.GetSources(kTime1),
       UnorderedElementsAre(RtpSource(kTime1, kCsrc1, RtpSourceType::CSRC),
@@ -45,12 +45,12 @@
   constexpr uint32_t kCsrcs2[] = {kCsrc2, kCsrc3};
   constexpr int64_t kTime1 = 10;
   constexpr int64_t kTime2 = kTime1 + 5 * rtc::kNumMillisecsPerSec;
-  csrcs.Update(kTime1, kCsrcs1);
+  csrcs.Update(kTime1, kCsrcs1, absl::nullopt);
   EXPECT_THAT(
       csrcs.GetSources(kTime1),
       UnorderedElementsAre(RtpSource(kTime1, kCsrc1, RtpSourceType::CSRC),
                            RtpSource(kTime1, kCsrc2, RtpSourceType::CSRC)));
-  csrcs.Update(kTime2, kCsrcs2);
+  csrcs.Update(kTime2, kCsrcs2, absl::nullopt);
   EXPECT_THAT(
       csrcs.GetSources(kTime2),
       UnorderedElementsAre(RtpSource(kTime1, kCsrc1, RtpSourceType::CSRC),
@@ -65,12 +65,12 @@
   constexpr int64_t kTime1 = 10;
   constexpr int64_t kTime2 = kTime1 + 5 * rtc::kNumMillisecsPerSec;
   constexpr int64_t kTime3 = kTime1 + 12 * rtc::kNumMillisecsPerSec;
-  csrcs.Update(kTime1, kCsrcs1);
+  csrcs.Update(kTime1, kCsrcs1, absl::nullopt);
   EXPECT_THAT(
       csrcs.GetSources(kTime1),
       UnorderedElementsAre(RtpSource(kTime1, kCsrc1, RtpSourceType::CSRC),
                            RtpSource(kTime1, kCsrc2, RtpSourceType::CSRC)));
-  csrcs.Update(kTime2, kCsrcs2);
+  csrcs.Update(kTime2, kCsrcs2, absl::nullopt);
   EXPECT_THAT(
       csrcs.GetSources(kTime3),
       UnorderedElementsAre(RtpSource(kTime2, kCsrc2, RtpSourceType::CSRC),
@@ -84,18 +84,18 @@
   constexpr int64_t kTime1 = 10;
   constexpr int64_t kTime2 = kTime1 + 10 * rtc::kNumMillisecsPerSec;
   constexpr int64_t kTime3 = kTime1 + 20 * rtc::kNumMillisecsPerSec;
-  csrcs.Update(kTime1, kCsrcs1);
+  csrcs.Update(kTime1, kCsrcs1, absl::nullopt);
   EXPECT_THAT(
       csrcs.GetSources(kTime2),
       UnorderedElementsAre(RtpSource(kTime1, kCsrc1, RtpSourceType::CSRC),
                            RtpSource(kTime1, kCsrc2, RtpSourceType::CSRC)));
-  csrcs.Update(kTime2, kCsrcs2);
+  csrcs.Update(kTime2, kCsrcs2, absl::nullopt);
   EXPECT_THAT(
       csrcs.GetSources(kTime2),
       UnorderedElementsAre(RtpSource(kTime1, kCsrc1, RtpSourceType::CSRC),
                            RtpSource(kTime2, kCsrc2, RtpSourceType::CSRC),
                            RtpSource(kTime2, kCsrc3, RtpSourceType::CSRC)));
-  csrcs.Update(kTime3, kCsrcs2);
+  csrcs.Update(kTime3, kCsrcs2, absl::nullopt);
   EXPECT_THAT(
       csrcs.GetSources(kTime3),
       UnorderedElementsAre(RtpSource(kTime3, kCsrc2, RtpSourceType::CSRC),
@@ -108,4 +108,22 @@
                            RtpSource(kTime3, kCsrc3, RtpSourceType::CSRC)));
 }
 
+TEST(ContributingSourcesTest, AudioLevel) {
+  ContributingSources csrcs;
+  constexpr uint32_t kCsrcs[] = {kCsrc1, kCsrc2};
+  constexpr int64_t kTime1 = 10;
+  csrcs.Update(kTime1, kCsrcs, 47);
+  EXPECT_THAT(
+      csrcs.GetSources(kTime1),
+      UnorderedElementsAre(RtpSource(kTime1, kCsrc1, RtpSourceType::CSRC, 47),
+                           RtpSource(kTime1, kCsrc2, RtpSourceType::CSRC, 47)));
+
+  constexpr uint32_t kCsrcsSubset[] = {kCsrc1};
+  csrcs.Update(kTime1 + 1, kCsrcsSubset, absl::nullopt);
+  EXPECT_THAT(
+      csrcs.GetSources(kTime1 + 1),
+      UnorderedElementsAre(RtpSource(kTime1 + 1, kCsrc1, RtpSourceType::CSRC),
+                           RtpSource(kTime1, kCsrc2, RtpSourceType::CSRC, 47)));
+}
+
 }  // namespace webrtc
diff --git a/modules/rtp_rtcp/source/dtmf_queue.cc b/modules/rtp_rtcp/source/dtmf_queue.cc
index 86ddb10..10e6747 100644
--- a/modules/rtp_rtcp/source/dtmf_queue.cc
+++ b/modules/rtp_rtcp/source/dtmf_queue.cc
@@ -10,6 +10,10 @@
 
 #include "modules/rtp_rtcp/source/dtmf_queue.h"
 
+#include <stddef.h>
+
+#include "rtc_base/checks.h"
+
 namespace {
 constexpr size_t kDtmfOutbandMax = 20;
 }
diff --git a/modules/rtp_rtcp/source/dtmf_queue.h b/modules/rtp_rtcp/source/dtmf_queue.h
index db70c97..e5955a1 100644
--- a/modules/rtp_rtcp/source/dtmf_queue.h
+++ b/modules/rtp_rtcp/source/dtmf_queue.h
@@ -11,6 +11,7 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_DTMF_QUEUE_H_
 #define MODULES_RTP_RTCP_SOURCE_DTMF_QUEUE_H_
 
+#include <stdint.h>
 #include <list>
 
 #include "rtc_base/criticalsection.h"
diff --git a/modules/rtp_rtcp/source/flexfec_header_reader_writer.cc b/modules/rtp_rtcp/source/flexfec_header_reader_writer.cc
index d7666e1..b813340 100644
--- a/modules/rtp_rtcp/source/flexfec_header_reader_writer.cc
+++ b/modules/rtp_rtcp/source/flexfec_header_reader_writer.cc
@@ -12,12 +12,11 @@
 
 #include <string.h>
 
-#include <utility>
-
 #include "modules/rtp_rtcp/source/byte_io.h"
 #include "modules/rtp_rtcp/source/forward_error_correction_internal.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
+#include "rtc_base/scoped_ref_ptr.h"
 
 namespace webrtc {
 
diff --git a/modules/rtp_rtcp/source/flexfec_header_reader_writer.h b/modules/rtp_rtcp/source/flexfec_header_reader_writer.h
index 1d6ddda..d305c4c 100644
--- a/modules/rtp_rtcp/source/flexfec_header_reader_writer.h
+++ b/modules/rtp_rtcp/source/flexfec_header_reader_writer.h
@@ -11,6 +11,9 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_FLEXFEC_HEADER_READER_WRITER_H_
 #define MODULES_RTP_RTCP_SOURCE_FLEXFEC_HEADER_READER_WRITER_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "modules/rtp_rtcp/source/forward_error_correction.h"
 
 namespace webrtc {
diff --git a/modules/rtp_rtcp/source/flexfec_receiver.cc b/modules/rtp_rtcp/source/flexfec_receiver.cc
index c3ed4d5..1a62bce 100644
--- a/modules/rtp_rtcp/source/flexfec_receiver.cc
+++ b/modules/rtp_rtcp/source/flexfec_receiver.cc
@@ -10,6 +10,9 @@
 
 #include "modules/rtp_rtcp/include/flexfec_receiver.h"
 
+#include <string.h>
+
+#include "api/array_view.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/scoped_ref_ptr.h"
diff --git a/modules/rtp_rtcp/source/flexfec_sender.cc b/modules/rtp_rtcp/source/flexfec_sender.cc
index 286f47c..1204b2d 100644
--- a/modules/rtp_rtcp/source/flexfec_sender.cc
+++ b/modules/rtp_rtcp/source/flexfec_sender.cc
@@ -10,11 +10,15 @@
 
 #include "modules/rtp_rtcp/include/flexfec_sender.h"
 
+#include <string.h>
+#include <list>
 #include <utility>
 
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/rtp_rtcp/source/forward_error_correction.h"
 #include "modules/rtp_rtcp/source/rtp_header_extensions.h"
+#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 
 namespace webrtc {
diff --git a/modules/rtp_rtcp/source/forward_error_correction.cc b/modules/rtp_rtcp/source/forward_error_correction.cc
index b743110..a52feca 100644
--- a/modules/rtp_rtcp/source/forward_error_correction.cc
+++ b/modules/rtp_rtcp/source/forward_error_correction.cc
@@ -11,11 +11,10 @@
 #include "modules/rtp_rtcp/source/forward_error_correction.h"
 
 #include <string.h>
-
 #include <algorithm>
-#include <iterator>
 #include <utility>
 
+#include "modules/include/module_common_types_public.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/rtp_rtcp/source/byte_io.h"
 #include "modules/rtp_rtcp/source/flexfec_header_reader_writer.h"
diff --git a/modules/rtp_rtcp/source/forward_error_correction.h b/modules/rtp_rtcp/source/forward_error_correction.h
index 819f6bc..adb7572 100644
--- a/modules/rtp_rtcp/source/forward_error_correction.h
+++ b/modules/rtp_rtcp/source/forward_error_correction.h
@@ -11,16 +11,15 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_FORWARD_ERROR_CORRECTION_H_
 #define MODULES_RTP_RTCP_SOURCE_FORWARD_ERROR_CORRECTION_H_
 
+#include <stddef.h>
 #include <stdint.h>
-
 #include <list>
 #include <memory>
 #include <vector>
 
+#include "modules/include/module_fec_types.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/rtp_rtcp/source/forward_error_correction_internal.h"
-#include "rtc_base/constructormagic.h"
-#include "rtc_base/refcount.h"
 #include "rtc_base/scoped_ref_ptr.h"
 
 namespace webrtc {
diff --git a/modules/rtp_rtcp/source/forward_error_correction_internal.cc b/modules/rtp_rtcp/source/forward_error_correction_internal.cc
index 7e5fd91..9b02026 100644
--- a/modules/rtp_rtcp/source/forward_error_correction_internal.cc
+++ b/modules/rtp_rtcp/source/forward_error_correction_internal.cc
@@ -10,6 +10,7 @@
 
 #include "modules/rtp_rtcp/source/forward_error_correction_internal.h"
 
+#include <string.h>
 #include <algorithm>
 
 #include "modules/rtp_rtcp/source/fec_private_tables_bursty.h"
diff --git a/modules/rtp_rtcp/source/forward_error_correction_internal.h b/modules/rtp_rtcp/source/forward_error_correction_internal.h
index 2e8a202..ed93f52 100644
--- a/modules/rtp_rtcp/source/forward_error_correction_internal.h
+++ b/modules/rtp_rtcp/source/forward_error_correction_internal.h
@@ -11,9 +11,11 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_FORWARD_ERROR_CORRECTION_INTERNAL_H_
 #define MODULES_RTP_RTCP_SOURCE_FORWARD_ERROR_CORRECTION_INTERNAL_H_
 
-#include "modules/include/module_common_types.h"
+#include <stddef.h>
+#include <stdint.h>
 
 #include "api/array_view.h"
+#include "modules/include/module_fec_types.h"
 
 namespace webrtc {
 
diff --git a/modules/rtp_rtcp/source/packet_loss_stats.cc b/modules/rtp_rtcp/source/packet_loss_stats.cc
index 076348d..36f0a63 100644
--- a/modules/rtp_rtcp/source/packet_loss_stats.cc
+++ b/modules/rtp_rtcp/source/packet_loss_stats.cc
@@ -10,6 +10,8 @@
 
 #include "modules/rtp_rtcp/source/packet_loss_stats.h"
 
+#include <cstdint>
+#include <iterator>
 #include <vector>
 
 #include "rtc_base/checks.h"
diff --git a/modules/rtp_rtcp/source/playout_delay_oracle.cc b/modules/rtp_rtcp/source/playout_delay_oracle.cc
index d3a75dd..dc33fad 100644
--- a/modules/rtp_rtcp/source/playout_delay_oracle.cc
+++ b/modules/rtp_rtcp/source/playout_delay_oracle.cc
@@ -13,7 +13,6 @@
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/rtp_rtcp/source/rtp_header_extensions.h"
 #include "rtc_base/checks.h"
-#include "rtc_base/logging.h"
 
 namespace webrtc {
 
diff --git a/modules/rtp_rtcp/source/playout_delay_oracle.h b/modules/rtp_rtcp/source/playout_delay_oracle.h
index 6e6e253..0e3bd39 100644
--- a/modules/rtp_rtcp/source/playout_delay_oracle.h
+++ b/modules/rtp_rtcp/source/playout_delay_oracle.h
@@ -13,8 +13,10 @@
 
 #include <stdint.h>
 
-#include "modules/include/module_common_types.h"
+#include "common_types.h"  // NOLINT(build/include)
+#include "modules/include/module_common_types_public.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
+#include "rtc_base/constructormagic.h"
 #include "rtc_base/criticalsection.h"
 #include "rtc_base/thread_annotations.h"
 
diff --git a/modules/rtp_rtcp/source/remote_ntp_time_estimator.cc b/modules/rtp_rtcp/source/remote_ntp_time_estimator.cc
index fc867a4..fd19b13 100644
--- a/modules/rtp_rtcp/source/remote_ntp_time_estimator.cc
+++ b/modules/rtp_rtcp/source/remote_ntp_time_estimator.cc
@@ -10,8 +10,9 @@
 
 #include "modules/rtp_rtcp/include/remote_ntp_time_estimator.h"
 
+#include <cstdint>
+
 #include "rtc_base/logging.h"
-#include "rtc_base/time/timestamp_extrapolator.h"
 #include "system_wrappers/include/clock.h"
 
 namespace webrtc {
diff --git a/modules/rtp_rtcp/source/rtcp_nack_stats.cc b/modules/rtp_rtcp/source/rtcp_nack_stats.cc
index 24b7085..1d652d0 100644
--- a/modules/rtp_rtcp/source/rtcp_nack_stats.cc
+++ b/modules/rtp_rtcp/source/rtcp_nack_stats.cc
@@ -10,7 +10,7 @@
 
 #include "modules/rtp_rtcp/source/rtcp_nack_stats.h"
 
-#include "modules/include/module_common_types.h"
+#include "modules/include/module_common_types_public.h"
 
 namespace webrtc {
 
diff --git a/modules/rtp_rtcp/source/rtcp_packet.h b/modules/rtp_rtcp/source/rtcp_packet.h
index 11037cb..40e51e8 100644
--- a/modules/rtp_rtcp/source/rtcp_packet.h
+++ b/modules/rtp_rtcp/source/rtcp_packet.h
@@ -11,6 +11,10 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_H_
 #define MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
+#include "api/array_view.h"
 #include "rtc_base/buffer.h"
 #include "rtc_base/function_view.h"
 
diff --git a/modules/rtp_rtcp/source/rtcp_packet/app.cc b/modules/rtp_rtcp/source/rtcp_packet/app.cc
index 4e21bc9..eadd4d9 100644
--- a/modules/rtp_rtcp/source/rtcp_packet/app.cc
+++ b/modules/rtp_rtcp/source/rtcp_packet/app.cc
@@ -10,6 +10,9 @@
 
 #include "modules/rtp_rtcp/source/rtcp_packet/app.h"
 
+#include <string.h>
+#include <cstdint>
+
 #include "modules/rtp_rtcp/source/byte_io.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/common_header.h"
 #include "rtc_base/checks.h"
diff --git a/modules/rtp_rtcp/source/rtcp_packet/app.h b/modules/rtp_rtcp/source/rtcp_packet/app.h
index 19a97e0..a9602a8 100644
--- a/modules/rtp_rtcp/source/rtcp_packet/app.h
+++ b/modules/rtp_rtcp/source/rtcp_packet/app.h
@@ -11,6 +11,9 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_APP_H_
 #define MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_APP_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "modules/rtp_rtcp/source/rtcp_packet.h"
 #include "rtc_base/buffer.h"
 
diff --git a/modules/rtp_rtcp/source/rtcp_packet/bye.cc b/modules/rtp_rtcp/source/rtcp_packet/bye.cc
index 0e2eb9e..23ac35f 100644
--- a/modules/rtp_rtcp/source/rtcp_packet/bye.cc
+++ b/modules/rtp_rtcp/source/rtcp_packet/bye.cc
@@ -10,6 +10,8 @@
 
 #include "modules/rtp_rtcp/source/rtcp_packet/bye.h"
 
+#include <string.h>
+#include <cstdint>
 #include <utility>
 
 #include "modules/rtp_rtcp/source/byte_io.h"
diff --git a/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.cc b/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.cc
index 27ed4cc..5e7dadd 100644
--- a/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.cc
+++ b/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.cc
@@ -10,6 +10,7 @@
 
 #include "modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h"
 
+#include <cstdint>
 #include <utility>
 
 #include "modules/rtp_rtcp/source/byte_io.h"
diff --git a/modules/rtp_rtcp/source/rtcp_packet/extended_reports.cc b/modules/rtp_rtcp/source/rtcp_packet/extended_reports.cc
index 5513f37..2b5f9ca 100644
--- a/modules/rtp_rtcp/source/rtcp_packet/extended_reports.cc
+++ b/modules/rtp_rtcp/source/rtcp_packet/extended_reports.cc
@@ -10,6 +10,8 @@
 
 #include "modules/rtp_rtcp/source/rtcp_packet/extended_reports.h"
 
+#include <vector>
+
 #include "modules/rtp_rtcp/source/byte_io.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/common_header.h"
 #include "rtc_base/checks.h"
diff --git a/modules/rtp_rtcp/source/rtcp_packet/nack.cc b/modules/rtp_rtcp/source/rtcp_packet/nack.cc
index 6a4a0bd..6fe7ead 100644
--- a/modules/rtp_rtcp/source/rtcp_packet/nack.cc
+++ b/modules/rtp_rtcp/source/rtcp_packet/nack.cc
@@ -11,6 +11,7 @@
 #include "modules/rtp_rtcp/source/rtcp_packet/nack.h"
 
 #include <algorithm>
+#include <cstdint>
 #include <utility>
 
 #include "modules/rtp_rtcp/source/byte_io.h"
diff --git a/modules/rtp_rtcp/source/rtcp_packet/psfb.h b/modules/rtp_rtcp/source/rtcp_packet/psfb.h
index ae66a17..46ee291 100644
--- a/modules/rtp_rtcp/source/rtcp_packet/psfb.h
+++ b/modules/rtp_rtcp/source/rtcp_packet/psfb.h
@@ -12,6 +12,9 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_PSFB_H_
 #define MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_PSFB_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "modules/rtp_rtcp/source/rtcp_packet.h"
 
 namespace webrtc {
diff --git a/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h b/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h
index 8f143da..7470d1d 100644
--- a/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h
+++ b/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h
@@ -11,6 +11,8 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_RECEIVER_REPORT_H_
 #define MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_RECEIVER_REPORT_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <vector>
 
 #include "modules/rtp_rtcp/source/rtcp_packet.h"
diff --git a/modules/rtp_rtcp/source/rtcp_packet/remb.cc b/modules/rtp_rtcp/source/rtcp_packet/remb.cc
index 0240611..3ed1fbd 100644
--- a/modules/rtp_rtcp/source/rtcp_packet/remb.cc
+++ b/modules/rtp_rtcp/source/rtcp_packet/remb.cc
@@ -10,6 +10,7 @@
 
 #include "modules/rtp_rtcp/source/rtcp_packet/remb.h"
 
+#include <cstdint>
 #include <utility>
 
 #include "modules/rtp_rtcp/source/byte_io.h"
diff --git a/modules/rtp_rtcp/source/rtcp_packet/rrtr.h b/modules/rtp_rtcp/source/rtcp_packet/rrtr.h
index a470b1a..8eb4ce6 100644
--- a/modules/rtp_rtcp/source/rtcp_packet/rrtr.h
+++ b/modules/rtp_rtcp/source/rtcp_packet/rrtr.h
@@ -12,6 +12,9 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_RRTR_H_
 #define MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_RRTR_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "system_wrappers/include/ntp_time.h"
 
 namespace webrtc {
diff --git a/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h b/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h
index a040741..2197773 100644
--- a/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h
+++ b/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h
@@ -12,6 +12,9 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_RTPFB_H_
 #define MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_RTPFB_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "modules/rtp_rtcp/source/rtcp_packet.h"
 
 namespace webrtc {
diff --git a/modules/rtp_rtcp/source/rtcp_packet/sdes.cc b/modules/rtp_rtcp/source/rtcp_packet/sdes.cc
index 337c8b0..0ef4329 100644
--- a/modules/rtp_rtcp/source/rtcp_packet/sdes.cc
+++ b/modules/rtp_rtcp/source/rtcp_packet/sdes.cc
@@ -10,6 +10,7 @@
 
 #include "modules/rtp_rtcp/source/rtcp_packet/sdes.h"
 
+#include <string.h>
 #include <utility>
 
 #include "modules/rtp_rtcp/source/byte_io.h"
diff --git a/modules/rtp_rtcp/source/rtcp_packet/tmmbn.cc b/modules/rtp_rtcp/source/rtcp_packet/tmmbn.cc
index 4d38b3b..f57e574 100644
--- a/modules/rtp_rtcp/source/rtcp_packet/tmmbn.cc
+++ b/modules/rtp_rtcp/source/rtcp_packet/tmmbn.cc
@@ -10,7 +10,6 @@
 
 #include "modules/rtp_rtcp/source/rtcp_packet/tmmbn.h"
 
-#include "modules/rtp_rtcp/source/byte_io.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/common_header.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
diff --git a/modules/rtp_rtcp/source/rtcp_packet/tmmbr.cc b/modules/rtp_rtcp/source/rtcp_packet/tmmbr.cc
index d8f073b..9dc745e 100644
--- a/modules/rtp_rtcp/source/rtcp_packet/tmmbr.cc
+++ b/modules/rtp_rtcp/source/rtcp_packet/tmmbr.cc
@@ -10,7 +10,6 @@
 
 #include "modules/rtp_rtcp/source/rtcp_packet/tmmbr.h"
 
-#include "modules/rtp_rtcp/source/byte_io.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/common_header.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
diff --git a/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.cc b/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.cc
index 4703d31..2816559 100644
--- a/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.cc
+++ b/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.cc
@@ -11,9 +11,10 @@
 #include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 
 #include <algorithm>
+#include <cstdint>
 #include <utility>
 
-#include "modules/include/module_common_types.h"
+#include "modules/include/module_common_types_public.h"
 #include "modules/rtp_rtcp/source/byte_io.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/common_header.h"
 #include "rtc_base/checks.h"
diff --git a/modules/rtp_rtcp/source/rtcp_receiver.cc b/modules/rtp_rtcp/source/rtcp_receiver.cc
index 4966754..3635c4a 100644
--- a/modules/rtp_rtcp/source/rtcp_receiver.cc
+++ b/modules/rtp_rtcp/source/rtcp_receiver.cc
@@ -280,7 +280,8 @@
   std::vector<rtcp::ReceiveTimeInfo> last_xr_rtis;
   last_xr_rtis.reserve(last_xr_rtis_size);
 
-  const uint32_t now_ntp = CompactNtp(clock_->CurrentNtpTime());
+  const uint32_t now_ntp =
+      CompactNtp(TimeMicrosToNtp(clock_->TimeInMicroseconds()));
 
   for (size_t i = 0; i < last_xr_rtis_size; ++i) {
     RrtrInformation& rrtr = received_rrtrs_.front();
@@ -427,7 +428,7 @@
 
     remote_sender_ntp_time_ = sender_report.ntp();
     remote_sender_rtp_time_ = sender_report.rtp_timestamp();
-    last_received_sr_ntp_ = clock_->CurrentNtpTime();
+    last_received_sr_ntp_ = TimeMicrosToNtp(clock_->TimeInMicroseconds());
   } else {
     // We will only store the send report from one source, but
     // we will store all the receive blocks.
@@ -503,10 +504,18 @@
   // If no SR has been received yet, the field is set to zero.
   // Receiver rtp_rtcp module is not expected to calculate rtt using
   // Sender Reports even if it accidentally can.
-  if (!receiver_only_ && send_time_ntp != 0) {
+
+  // TODO(nisse): Use this way to determine the RTT only when |receiver_only_|
+  // is false. However, that currently breaks the tests of the
+  // googCaptureStartNtpTimeMs stat for audio receive streams. To fix, either
+  // delete all dependencies on RTT measurements for audio receive streams, or
+  // ensure that audio receive streams that need RTT and stats that depend on it
+  // are configured with an associated audio send stream.
+  if (send_time_ntp != 0) {
     uint32_t delay_ntp = report_block.delay_since_last_sr();
     // Local NTP time.
-    uint32_t receive_time_ntp = CompactNtp(clock_->CurrentNtpTime());
+    uint32_t receive_time_ntp =
+        CompactNtp(TimeMicrosToNtp(clock_->TimeInMicroseconds()));
 
     // RTT in 1/(2^16) seconds.
     uint32_t rtt_ntp = receive_time_ntp - delay_ntp - send_time_ntp;
@@ -720,7 +729,8 @@
 void RTCPReceiver::HandleXrReceiveReferenceTime(uint32_t sender_ssrc,
                                                 const rtcp::Rrtr& rrtr) {
   uint32_t received_remote_mid_ntp_time = CompactNtp(rrtr.ntp());
-  uint32_t local_receive_mid_ntp_time = CompactNtp(clock_->CurrentNtpTime());
+  uint32_t local_receive_mid_ntp_time =
+      CompactNtp(TimeMicrosToNtp(clock_->TimeInMicroseconds()));
 
   auto it = received_rrtrs_ssrc_it_.find(sender_ssrc);
   if (it != received_rrtrs_ssrc_it_.end()) {
@@ -754,7 +764,7 @@
     return;
 
   uint32_t delay_ntp = rti.delay_since_last_rr;
-  uint32_t now_ntp = CompactNtp(clock_->CurrentNtpTime());
+  uint32_t now_ntp = CompactNtp(TimeMicrosToNtp(clock_->TimeInMicroseconds()));
 
   uint32_t rtt_ntp = now_ntp - delay_ntp - send_time_ntp;
   xr_rr_rtt_ms_ = CompactNtpRttToMs(rtt_ntp);
diff --git a/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc b/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
index c7708f0..4be8d73 100644
--- a/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
+++ b/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
@@ -208,7 +208,8 @@
   EXPECT_EQ(
       -1, rtcp_receiver_.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr));
 
-  uint32_t sent_ntp = CompactNtp(system_clock_.CurrentNtpTime());
+  uint32_t sent_ntp =
+      CompactNtp(TimeMicrosToNtp(system_clock_.TimeInMicroseconds()));
   system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs);
 
   rtcp::SenderReport sr;
@@ -238,7 +239,8 @@
   EXPECT_EQ(
       -1, rtcp_receiver_.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr));
 
-  uint32_t sent_ntp = CompactNtp(system_clock_.CurrentNtpTime());
+  uint32_t sent_ntp =
+      CompactNtp(TimeMicrosToNtp(system_clock_.TimeInMicroseconds()));
   system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs);
 
   rtcp::SenderReport sr;
@@ -266,7 +268,8 @@
   const uint32_t kDelayNtp = 123000;
   const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp);
 
-  uint32_t sent_ntp = CompactNtp(system_clock_.CurrentNtpTime());
+  uint32_t sent_ntp =
+      CompactNtp(TimeMicrosToNtp(system_clock_.TimeInMicroseconds()));
   system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs);
 
   rtcp::SenderReport sr;
@@ -737,7 +740,8 @@
 
   InjectRtcpPacket(xr);
 
-  uint32_t compact_ntp_now = CompactNtp(system_clock_.CurrentNtpTime());
+  uint32_t compact_ntp_now =
+      CompactNtp(TimeMicrosToNtp(system_clock_.TimeInMicroseconds()));
   EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
   uint32_t rtt_ntp = compact_ntp_now - kDelay - kLastRR;
   EXPECT_NEAR(CompactNtpRttToMs(rtt_ntp), rtt_ms, 1);
@@ -756,7 +760,8 @@
 
   InjectRtcpPacket(xr);
 
-  uint32_t compact_ntp_now = CompactNtp(system_clock_.CurrentNtpTime());
+  uint32_t compact_ntp_now =
+      CompactNtp(TimeMicrosToNtp(system_clock_.TimeInMicroseconds()));
   int64_t rtt_ms = 0;
   EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
   uint32_t rtt_ntp = compact_ntp_now - kDelay - kLastRR;
@@ -818,7 +823,7 @@
   const uint32_t kDelayNtp = rand.Rand(0, 0x7fffffff);
   const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp);
   rtcp_receiver_.SetRtcpXrRrtrStatus(true);
-  NtpTime now = system_clock_.CurrentNtpTime();
+  NtpTime now = TimeMicrosToNtp(system_clock_.TimeInMicroseconds());
   uint32_t sent_ntp = CompactNtp(now);
   system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs);
 
@@ -838,7 +843,7 @@
   const int64_t kRttMs = rand.Rand(-3600 * 1000, -1);
   const uint32_t kDelayNtp = rand.Rand(0, 0x7fffffff);
   const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp);
-  NtpTime now = system_clock_.CurrentNtpTime();
+  NtpTime now = TimeMicrosToNtp(system_clock_.TimeInMicroseconds());
   uint32_t sent_ntp = CompactNtp(now);
   system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs);
   rtcp_receiver_.SetRtcpXrRrtrStatus(true);
diff --git a/modules/rtp_rtcp/source/rtcp_sender.cc b/modules/rtp_rtcp/source/rtcp_sender.cc
index bfddc422..ac50b32 100644
--- a/modules/rtp_rtcp/source/rtcp_sender.cc
+++ b/modules/rtp_rtcp/source/rtcp_sender.cc
@@ -99,16 +99,16 @@
   RtcpContext(const FeedbackState& feedback_state,
               int32_t nack_size,
               const uint16_t* nack_list,
-              NtpTime now)
+              int64_t now_us)
       : feedback_state_(feedback_state),
         nack_size_(nack_size),
         nack_list_(nack_list),
-        now_(now) {}
+        now_us_(now_us) {}
 
   const FeedbackState& feedback_state_;
   const int32_t nack_size_;
   const uint16_t* nack_list_;
-  const NtpTime now_;
+  const int64_t now_us_;
 };
 
 RTCPSender::RTCPSender(
@@ -126,7 +126,6 @@
       event_log_(event_log),
       transport_(outgoing_transport),
       interval_config_(interval_config),
-      using_nack_(false),
       sending_(false),
       next_time_to_send_rtcp_(0),
       timestamp_offset_(0),
@@ -151,7 +150,8 @@
 
       xr_send_receiver_reference_time_enabled_(false),
       packet_type_counter_observer_(packet_type_counter_observer),
-      send_video_bitrate_allocation_(false) {
+      send_video_bitrate_allocation_(false),
+      last_payload_type_(-1) {
   RTC_DCHECK(transport_ != nullptr);
 
   builders_[kRtcpSr] = &RTCPSender::BuildSR;
@@ -254,8 +254,14 @@
 }
 
 void RTCPSender::SetLastRtpTime(uint32_t rtp_timestamp,
-                                int64_t capture_time_ms) {
+                                int64_t capture_time_ms,
+                                int8_t payload_type) {
   rtc::CritScope lock(&critical_section_rtcp_sender_);
+  // For compatibility with clients who don't set payload type correctly on all
+  // calls.
+  if (payload_type != -1) {
+    last_payload_type_ = payload_type;
+  }
   last_rtp_timestamp_ = rtp_timestamp;
   if (capture_time_ms < 0) {
     // We don't currently get a capture time from VoiceEngine.
@@ -265,6 +271,11 @@
   }
 }
 
+void RTCPSender::SetRtpClockRate(int8_t payload_type, int rtp_clock_rate_hz) {
+  rtc::CritScope lock(&critical_section_rtcp_sender_);
+  rtp_clock_rates_khz_[payload_type] = rtp_clock_rate_hz / 1000;
+}
+
 uint32_t RTCPSender::SSRC() const {
   rtc::CritScope lock(&critical_section_rtcp_sender_);
   return ssrc_;
@@ -411,15 +422,21 @@
   // the frame being captured at this moment. We are calculating that
   // timestamp as the last frame's timestamp + the time since the last frame
   // was captured.
-  uint32_t rtp_rate =
-      (audio_ ? kBogusRtpRateForAudioRtcp : kVideoPayloadTypeFrequency) / 1000;
+  int rtp_rate = rtp_clock_rates_khz_[last_payload_type_];
+  if (rtp_rate <= 0) {
+    rtp_rate =
+        (audio_ ? kBogusRtpRateForAudioRtcp : kVideoPayloadTypeFrequency) /
+        1000;
+  }
+  // Round now_us_ to the closest millisecond, because Ntp time is rounded
+  // when converted to milliseconds,
   uint32_t rtp_timestamp =
       timestamp_offset_ + last_rtp_timestamp_ +
-      (clock_->TimeInMilliseconds() - last_frame_capture_time_ms_) * rtp_rate;
+      ((ctx.now_us_ + 500) / 1000 - last_frame_capture_time_ms_) * rtp_rate;
 
   rtcp::SenderReport* report = new rtcp::SenderReport();
   report->SetSenderSsrc(ssrc_);
-  report->SetNtp(ctx.now_);
+  report->SetNtp(TimeMicrosToNtp(ctx.now_us_));
   report->SetRtpTimestamp(rtp_timestamp);
   report->SetPacketCount(ctx.feedback_state_.packets_sent);
   report->SetOctetCount(ctx.feedback_state_.media_bytes_sent);
@@ -600,7 +617,7 @@
 
   if (!sending_ && xr_send_receiver_reference_time_enabled_) {
     rtcp::Rrtr rrtr;
-    rrtr.SetNtp(ctx.now_);
+    rrtr.SetNtp(TimeMicrosToNtp(ctx.now_us_));
     xr->SetRrtr(rrtr);
   }
 
@@ -675,7 +692,7 @@
 
     // We need to send our NTP even if we haven't received any reports.
     RtcpContext context(feedback_state, nack_size, nack_list,
-                        clock_->CurrentNtpTime());
+                        clock_->TimeInMicroseconds());
 
     PrepareReport(feedback_state);
 
@@ -791,7 +808,7 @@
   if (!result.empty() && ((feedback_state.last_rr_ntp_secs != 0) ||
                           (feedback_state.last_rr_ntp_frac != 0))) {
     // Get our NTP as late as possible to avoid a race.
-    uint32_t now = CompactNtp(clock_->CurrentNtpTime());
+    uint32_t now = CompactNtp(TimeMicrosToNtp(clock_->TimeInMicroseconds()));
 
     uint32_t receive_time = feedback_state.last_rr_ntp_secs & 0x0000FFFF;
     receive_time <<= 16;
diff --git a/modules/rtp_rtcp/source/rtcp_sender.h b/modules/rtp_rtcp/source/rtcp_sender.h
index c9220dd..2720e0a 100644
--- a/modules/rtp_rtcp/source/rtcp_sender.h
+++ b/modules/rtp_rtcp/source/rtcp_sender.h
@@ -82,7 +82,13 @@
 
   void SetTimestampOffset(uint32_t timestamp_offset);
 
-  void SetLastRtpTime(uint32_t rtp_timestamp, int64_t capture_time_ms);
+  // TODO(bugs.webrtc.org/6458): Remove default parameter value when all the
+  // depending projects are updated to correctly set payload type.
+  void SetLastRtpTime(uint32_t rtp_timestamp,
+                      int64_t capture_time_ms,
+                      int8_t payload_type = -1);
+
+  void SetRtpClockRate(int8_t payload_type, int rtp_clock_rate_hz);
 
   uint32_t SSRC() const;
 
@@ -187,7 +193,6 @@
   const RtcpIntervalConfig interval_config_;
 
   rtc::CriticalSection critical_section_rtcp_sender_;
-  bool using_nack_ RTC_GUARDED_BY(critical_section_rtcp_sender_);
   bool sending_ RTC_GUARDED_BY(critical_section_rtcp_sender_);
 
   int64_t next_time_to_send_rtcp_ RTC_GUARDED_BY(critical_section_rtcp_sender_);
@@ -244,6 +249,11 @@
       RTC_GUARDED_BY(critical_section_rtcp_sender_);
   bool send_video_bitrate_allocation_
       RTC_GUARDED_BY(critical_section_rtcp_sender_);
+
+  std::map<int8_t, int> rtp_clock_rates_khz_
+      RTC_GUARDED_BY(critical_section_rtcp_sender_);
+  int8_t last_payload_type_ RTC_GUARDED_BY(critical_section_rtcp_sender_);
+
   absl::optional<VideoBitrateAllocation> CheckAndUpdateLayerStructure(
       const VideoBitrateAllocation& bitrate) const
       RTC_EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
diff --git a/modules/rtp_rtcp/source/rtcp_sender_unittest.cc b/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
index bcffc81..3e37cc6 100644
--- a/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
+++ b/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
@@ -11,11 +11,13 @@
 #include <memory>
 
 #include "common_types.h"  // NOLINT(build/include)
+#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/bye.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/common_header.h"
 #include "modules/rtp_rtcp/source/rtcp_sender.h"
 #include "modules/rtp_rtcp/source/rtp_packet_received.h"
 #include "modules/rtp_rtcp/source/rtp_rtcp_impl.h"
+#include "modules/rtp_rtcp/source/time_util.h"
 #include "rtc_base/rate_limiter.h"
 #include "test/gmock.h"
 #include "test/gtest.h"
@@ -90,7 +92,8 @@
     rtcp_sender_->SetSSRC(kSenderSsrc);
     rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
     rtcp_sender_->SetTimestampOffset(kStartRtpTimestamp);
-    rtcp_sender_->SetLastRtpTime(kRtpTimestamp, clock_.TimeInMilliseconds());
+    rtcp_sender_->SetLastRtpTime(kRtpTimestamp, clock_.TimeInMilliseconds(),
+                                 /*paylpad_type=*/0);
   }
 
   void InsertIncomingPacket(uint32_t remote_ssrc, uint16_t seq_num) {
@@ -141,7 +144,7 @@
   rtcp_sender_->SetSendingStatus(feedback_state, true);
   feedback_state.packets_sent = kPacketCount;
   feedback_state.media_bytes_sent = kOctetCount;
-  NtpTime ntp = clock_.CurrentNtpTime();
+  NtpTime ntp = TimeMicrosToNtp(clock_.TimeInMicroseconds());
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr));
   EXPECT_EQ(1, parser()->sender_report()->num_packets());
   EXPECT_EQ(kSenderSsrc, parser()->sender_report()->sender_ssrc());
@@ -153,6 +156,39 @@
   EXPECT_EQ(0U, parser()->sender_report()->report_blocks().size());
 }
 
+TEST_F(RtcpSenderTest, SendConsecutiveSrWithExactSlope) {
+  const uint32_t kPacketCount = 0x12345;
+  const uint32_t kOctetCount = 0x23456;
+  const int kTimeBetweenSRsUs = 10043;  // Not exact value in milliseconds.
+  const int kExtraPackets = 30;
+  // Make sure clock is not exactly at some milliseconds point.
+  clock_.AdvanceTimeMicroseconds(kTimeBetweenSRsUs);
+  rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
+  RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
+  rtcp_sender_->SetSendingStatus(feedback_state, true);
+  feedback_state.packets_sent = kPacketCount;
+  feedback_state.media_bytes_sent = kOctetCount;
+
+  EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr));
+  EXPECT_EQ(1, parser()->sender_report()->num_packets());
+  NtpTime ntp1 = parser()->sender_report()->ntp();
+  uint32_t rtp1 = parser()->sender_report()->rtp_timestamp();
+
+  // Send more SRs to ensure slope is always exact for different offsets
+  for (int packets = 1; packets <= kExtraPackets; ++packets) {
+    clock_.AdvanceTimeMicroseconds(kTimeBetweenSRsUs);
+    EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr));
+    EXPECT_EQ(packets + 1, parser()->sender_report()->num_packets());
+
+    NtpTime ntp2 = parser()->sender_report()->ntp();
+    uint32_t rtp2 = parser()->sender_report()->rtp_timestamp();
+
+    uint32_t ntp_diff_in_rtp_units =
+        (ntp2.ToMs() - ntp1.ToMs()) * (kVideoPayloadTypeFrequency / 1000);
+    EXPECT_EQ(rtp2 - rtp1, ntp_diff_in_rtp_units);
+  }
+}
+
 TEST_F(RtcpSenderTest, DoNotSendSrBeforeRtp) {
   rtcp_sender_.reset(new RTCPSender(false, &clock_, receive_statistics_.get(),
                                     nullptr, nullptr, &test_transport_,
@@ -447,7 +483,7 @@
   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
   EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), false));
   rtcp_sender_->SendRtcpXrReceiverReferenceTime(true);
-  NtpTime ntp = clock_.CurrentNtpTime();
+  NtpTime ntp = TimeMicrosToNtp(clock_.TimeInMicroseconds());
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
   EXPECT_EQ(1, parser()->xr()->num_packets());
   EXPECT_EQ(kSenderSsrc, parser()->xr()->sender_ssrc());
@@ -603,7 +639,8 @@
   rtcp_sender_->SetSSRC(kSenderSsrc);
   rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
   rtcp_sender_->SetTimestampOffset(kStartRtpTimestamp);
-  rtcp_sender_->SetLastRtpTime(kRtpTimestamp, clock_.TimeInMilliseconds());
+  rtcp_sender_->SetLastRtpTime(kRtpTimestamp, clock_.TimeInMilliseconds(),
+                               /*paylpad_type=*/0);
 
   // Set up REMB info to be included with BYE.
   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
diff --git a/modules/rtp_rtcp/source/rtcp_transceiver.cc b/modules/rtp_rtcp/source/rtcp_transceiver.cc
index 77b10ca..57d2142 100644
--- a/modules/rtp_rtcp/source/rtcp_transceiver.cc
+++ b/modules/rtp_rtcp/source/rtcp_transceiver.cc
@@ -39,10 +39,10 @@
   RTC_DCHECK(!rtcp_transceiver_);
 }
 
-void RtcpTransceiver::Stop(std::unique_ptr<rtc::QueuedTask> on_destroyed) {
+void RtcpTransceiver::Stop(std::function<void()> on_destroyed) {
   RTC_DCHECK(rtcp_transceiver_);
-  task_queue_->PostTaskAndReply(Destructor{std::move(rtcp_transceiver_)},
-                                std::move(on_destroyed));
+  task_queue_->PostTask(rtc::NewClosure(
+      Destructor{std::move(rtcp_transceiver_)}, std::move(on_destroyed)));
   RTC_DCHECK(!rtcp_transceiver_);
 }
 
@@ -59,13 +59,14 @@
 void RtcpTransceiver::RemoveMediaReceiverRtcpObserver(
     uint32_t remote_ssrc,
     MediaReceiverRtcpObserver* observer,
-    std::unique_ptr<rtc::QueuedTask> on_removed) {
+    std::function<void()> on_removed) {
   RTC_CHECK(rtcp_transceiver_);
   RtcpTransceiverImpl* ptr = rtcp_transceiver_.get();
   auto remove = [ptr, remote_ssrc, observer] {
     ptr->RemoveMediaReceiverRtcpObserver(remote_ssrc, observer);
   };
-  task_queue_->PostTaskAndReply(std::move(remove), std::move(on_removed));
+  task_queue_->PostTask(
+      rtc::NewClosure(std::move(remove), std::move(on_removed)));
 }
 
 void RtcpTransceiver::SetReadyToSend(bool ready) {
diff --git a/modules/rtp_rtcp/source/rtcp_transceiver.h b/modules/rtp_rtcp/source/rtcp_transceiver.h
index fc9488c..9c96751 100644
--- a/modules/rtp_rtcp/source/rtcp_transceiver.h
+++ b/modules/rtp_rtcp/source/rtcp_transceiver.h
@@ -11,6 +11,7 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_RTCP_TRANSCEIVER_H_
 #define MODULES_RTP_RTCP_SOURCE_RTCP_TRANSCEIVER_H_
 
+#include <functional>
 #include <memory>
 #include <string>
 #include <vector>
@@ -42,18 +43,17 @@
   // Note that interfaces provided in constructor or registered with AddObserver
   // still might be used by the transceiver on the task queue
   // until |on_destroyed| runs.
-  void Stop(std::unique_ptr<rtc::QueuedTask> on_destroyed);
+  void Stop(std::function<void()> on_destroyed);
 
   // Registers observer to be notified about incoming rtcp packets.
   // Calls to observer will be done on the |config.task_queue|.
   void AddMediaReceiverRtcpObserver(uint32_t remote_ssrc,
                                     MediaReceiverRtcpObserver* observer);
   // Deregisters the observer. Might return before observer is deregistered.
-  // Posts |on_removed| task when observer is deregistered.
-  void RemoveMediaReceiverRtcpObserver(
-      uint32_t remote_ssrc,
-      MediaReceiverRtcpObserver* observer,
-      std::unique_ptr<rtc::QueuedTask> on_removed);
+  // Runs |on_removed| when observer is deregistered.
+  void RemoveMediaReceiverRtcpObserver(uint32_t remote_ssrc,
+                                       MediaReceiverRtcpObserver* observer,
+                                       std::function<void()> on_removed);
 
   // Enables/disables sending rtcp packets eventually.
   // Packets may be sent after the SetReadyToSend(false) returns, but no new
diff --git a/modules/rtp_rtcp/source/rtcp_transceiver_impl_unittest.cc b/modules/rtp_rtcp/source/rtcp_transceiver_impl_unittest.cc
index e5db086..1e684a3 100644
--- a/modules/rtp_rtcp/source/rtcp_transceiver_impl_unittest.cc
+++ b/modules/rtp_rtcp/source/rtcp_transceiver_impl_unittest.cc
@@ -77,7 +77,6 @@
 // Helper to wait for an rtcp packet produced on a different thread/task queue.
 class FakeRtcpTransport : public webrtc::Transport {
  public:
-  FakeRtcpTransport() : sent_rtcp_(false, false) {}
   bool SendRtcp(const uint8_t* data, size_t size) override {
     sent_rtcp_.Set();
     return true;
@@ -148,7 +147,7 @@
   // Wait for a periodic packet.
   EXPECT_TRUE(transport.WaitPacket());
 
-  rtc::Event done(false, false);
+  rtc::Event done;
   queue.PostTask([rtcp_transceiver, &done] {
     delete rtcp_transceiver;
     done.Set();
@@ -187,7 +186,7 @@
   EXPECT_GE(rtc::TimeMillis() - started_ms, config.initial_report_delay_ms);
 
   // Cleanup.
-  rtc::Event done(false, false);
+  rtc::Event done;
   queue.PostTask([&] {
     rtcp_transceiver.reset();
     done.Set();
@@ -220,7 +219,7 @@
             config.report_period_ms - 1);
 
   // Cleanup.
-  rtc::Event done(false, false);
+  rtc::Event done;
   queue.PostTask([&] {
     rtcp_transceiver.reset();
     done.Set();
@@ -242,7 +241,7 @@
   // Wait for first packet.
   EXPECT_TRUE(transport.WaitPacket());
   // Send non periodic one after half period.
-  rtc::Event non_periodic(false, false);
+  rtc::Event non_periodic;
   int64_t time_of_non_periodic_packet_ms = 0;
   queue.PostDelayedTask(
       [&] {
@@ -265,7 +264,7 @@
             config.report_period_ms - 1);
 
   // Cleanup.
-  rtc::Event done(false, false);
+  rtc::Event done;
   queue.PostTask([&] {
     rtcp_transceiver.reset();
     done.Set();
@@ -329,7 +328,7 @@
   EXPECT_TRUE(transport.WaitPacket());
 
   // Cleanup.
-  rtc::Event done(false, false);
+  rtc::Event done;
   queue.PostTask([&] {
     rtcp_transceiver.reset();
     done.Set();
diff --git a/modules/rtp_rtcp/source/rtcp_transceiver_unittest.cc b/modules/rtp_rtcp/source/rtcp_transceiver_unittest.cc
index 2ea5bc9..d71918d 100644
--- a/modules/rtp_rtcp/source/rtcp_transceiver_unittest.cc
+++ b/modules/rtp_rtcp/source/rtcp_transceiver_unittest.cc
@@ -41,7 +41,7 @@
 constexpr int kTimeoutMs = 1000;
 
 void WaitPostedTasks(rtc::TaskQueue* queue) {
-  rtc::Event done(false, false);
+  rtc::Event done;
   queue->PostTask([&done] { done.Set(); });
   ASSERT_TRUE(done.Wait(kTimeoutMs));
 }
@@ -108,8 +108,8 @@
   auto* rtcp_transceiver = new RtcpTransceiver(config);
   rtcp_transceiver->SendCompoundPacket();
 
-  rtc::Event done(false, false);
-  rtc::Event heavy_task(false, false);
+  rtc::Event done;
+  rtc::Event heavy_task;
   queue.PostTask([&] {
     EXPECT_TRUE(heavy_task.Wait(kTimeoutMs));
     done.Set();
@@ -128,7 +128,7 @@
   config.task_queue = &queue;
   auto* rtcp_transceiver = new RtcpTransceiver(config);
 
-  rtc::Event heavy_task(false, false);
+  rtc::Event heavy_task;
   queue.PostTask([&] { EXPECT_TRUE(heavy_task.Wait(kTimeoutMs)); });
   rtcp_transceiver->SendCompoundPacket();
   delete rtcp_transceiver;
@@ -158,7 +158,7 @@
   config.outgoing_transport = &null_transport;
   config.task_queue = &queue;
   RtcpTransceiver rtcp_transceiver(config);
-  rtc::Event observer_deleted(false, false);
+  rtc::Event observer_deleted;
 
   auto observer = absl::make_unique<MockMediaReceiverRtcpObserver>();
   EXPECT_CALL(*observer, OnSenderReport(kRemoteSsrc, _, 1));
@@ -166,12 +166,11 @@
 
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, observer.get());
   rtcp_transceiver.ReceivePacket(CreateSenderReport(kRemoteSsrc, 1));
-  rtcp_transceiver.RemoveMediaReceiverRtcpObserver(
-      kRemoteSsrc, observer.get(),
-      /*on_removed=*/rtc::NewClosure([&] {
-        observer.reset();
-        observer_deleted.Set();
-      }));
+  rtcp_transceiver.RemoveMediaReceiverRtcpObserver(kRemoteSsrc, observer.get(),
+                                                   /*on_removed=*/[&] {
+                                                     observer.reset();
+                                                     observer_deleted.Set();
+                                                   });
   rtcp_transceiver.ReceivePacket(CreateSenderReport(kRemoteSsrc, 2));
 
   EXPECT_TRUE(observer_deleted.Wait(kTimeoutMs));
@@ -189,15 +188,14 @@
   auto observer = absl::make_unique<MockMediaReceiverRtcpObserver>();
   rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, observer.get());
 
-  rtc::Event queue_blocker(false, false);
-  rtc::Event observer_deleted(false, false);
+  rtc::Event queue_blocker;
+  rtc::Event observer_deleted;
   queue.PostTask([&] { EXPECT_TRUE(queue_blocker.Wait(kTimeoutMs)); });
-  rtcp_transceiver.RemoveMediaReceiverRtcpObserver(
-      kRemoteSsrc, observer.get(),
-      /*on_removed=*/rtc::NewClosure([&] {
-        observer.reset();
-        observer_deleted.Set();
-      }));
+  rtcp_transceiver.RemoveMediaReceiverRtcpObserver(kRemoteSsrc, observer.get(),
+                                                   /*on_removed=*/[&] {
+                                                     observer.reset();
+                                                     observer_deleted.Set();
+                                                   });
 
   EXPECT_THAT(observer, Not(IsNull()));
   queue_blocker.Set();
@@ -242,12 +240,12 @@
   config.schedule_periodic_compound_packets = true;
 
   auto rtcp_transceiver = absl::make_unique<RtcpTransceiver>(config);
-  rtc::Event done(false, false);
+  rtc::Event done;
   rtcp_transceiver->SendCompoundPacket();
-  rtcp_transceiver->Stop(rtc::NewClosure([&] {
+  rtcp_transceiver->Stop([&] {
     EXPECT_CALL(outgoing_transport, SendRtcp).Times(0);
     done.Set();
-  }));
+  });
   rtcp_transceiver = nullptr;
   EXPECT_TRUE(done.Wait(kTimeoutMs));
 }
diff --git a/modules/rtp_rtcp/source/rtp_format.cc b/modules/rtp_rtcp/source/rtp_format.cc
index 13ec0af..0010d90 100644
--- a/modules/rtp_rtcp/source/rtp_format.cc
+++ b/modules/rtp_rtcp/source/rtp_format.cc
@@ -10,13 +10,15 @@
 
 #include "modules/rtp_rtcp/source/rtp_format.h"
 
-#include <utility>
-
 #include "absl/memory/memory.h"
+#include "absl/types/variant.h"
 #include "modules/rtp_rtcp/source/rtp_format_h264.h"
 #include "modules/rtp_rtcp/source/rtp_format_video_generic.h"
 #include "modules/rtp_rtcp/source/rtp_format_vp8.h"
 #include "modules/rtp_rtcp/source/rtp_format_vp9.h"
+#include "modules/video_coding/codecs/h264/include/h264_globals.h"
+#include "modules/video_coding/codecs/vp8/include/vp8_globals.h"
+#include "modules/video_coding/codecs/vp9/include/vp9_globals.h"
 #include "rtc_base/checks.h"
 
 namespace webrtc {
@@ -63,6 +65,11 @@
   RTC_DCHECK_GE(limits.last_packet_reduction_len, 0);
 
   std::vector<int> result;
+  if (limits.max_payload_len >=
+      limits.single_packet_reduction_len + payload_len) {
+    result.push_back(payload_len);
+    return result;
+  }
   if (limits.max_payload_len - limits.first_packet_reduction_len < 1 ||
       limits.max_payload_len - limits.last_packet_reduction_len < 1) {
     // Capacity is not enough to put a single byte into one of the packets.
@@ -77,6 +84,10 @@
   // Integer divisions with rounding up.
   int num_packets_left =
       (total_bytes + limits.max_payload_len - 1) / limits.max_payload_len;
+  if (num_packets_left == 1) {
+    // Single packet is a special case handled above.
+    num_packets_left = 2;
+  }
 
   if (payload_len < num_packets_left) {
     // Edge case where limits force to have more packets than there are payload
diff --git a/modules/rtp_rtcp/source/rtp_format.h b/modules/rtp_rtcp/source/rtp_format.h
index 9fad4cf..71c7dc5 100644
--- a/modules/rtp_rtcp/source/rtp_format.h
+++ b/modules/rtp_rtcp/source/rtp_format.h
@@ -11,17 +11,17 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_RTP_FORMAT_H_
 #define MODULES_RTP_RTCP_SOURCE_RTP_FORMAT_H_
 
+#include <stdint.h>
 #include <memory>
-#include <string>
 #include <vector>
 
 #include "api/array_view.h"
 #include "common_types.h"  // NOLINT(build/include)
 #include "modules/include/module_common_types.h"
-#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
-#include "rtc_base/constructormagic.h"
+#include "modules/rtp_rtcp/source/rtp_video_header.h"
 
 namespace webrtc {
+
 class RtpPacketToSend;
 
 class RtpPacketizer {
@@ -30,6 +30,8 @@
     int max_payload_len = 1200;
     int first_packet_reduction_len = 0;
     int last_packet_reduction_len = 0;
+    // Reduction len for packet that is first & last at the same time.
+    int single_packet_reduction_len = 0;
   };
   static std::unique_ptr<RtpPacketizer> Create(
       VideoCodecType type,
diff --git a/modules/rtp_rtcp/source/rtp_format_h264.cc b/modules/rtp_rtcp/source/rtp_format_h264.cc
index 9793eba..7a7bcdf 100644
--- a/modules/rtp_rtcp/source/rtp_format_h264.cc
+++ b/modules/rtp_rtcp/source/rtp_format_h264.cc
@@ -11,10 +11,16 @@
 #include "modules/rtp_rtcp/source/rtp_format_h264.h"
 
 #include <string.h>
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
 #include <memory>
 #include <utility>
 #include <vector>
 
+#include "absl/types/optional.h"
+#include "absl/types/variant.h"
+#include "common_types.h"  // NOLINT(build/include)
 #include "common_video/h264/h264_common.h"
 #include "common_video/h264/pps_parser.h"
 #include "common_video/h264/sps_parser.h"
@@ -186,9 +192,11 @@
       case H264PacketizationMode::NonInterleaved:
         int fragment_len = input_fragments_[i].length;
         int single_packet_capacity = limits_.max_payload_len;
-        if (i == 0)
+        if (input_fragments_.size() == 1)
+          single_packet_capacity -= limits_.single_packet_reduction_len;
+        else if (i == 0)
           single_packet_capacity -= limits_.first_packet_reduction_len;
-        if (i + 1 == input_fragments_.size())
+        else if (i + 1 == input_fragments_.size())
           single_packet_capacity -= limits_.last_packet_reduction_len;
 
         if (fragment_len > single_packet_capacity) {
@@ -211,7 +219,10 @@
   PayloadSizeLimits limits = limits_;
   // Leave room for the FU-A header.
   limits.max_payload_len -= kFuAHeaderSize;
-  // Ignore first/last packet reductions unless it is first/last fragment.
+  // Ignore single/first/last packet reductions unless it is single/first/last
+  // fragment.
+  if (input_fragments_.size() != 1)
+    limits.single_packet_reduction_len = 0;
   if (fragment_index != 0)
     limits.first_packet_reduction_len = 0;
   if (fragment_index != input_fragments_.size() - 1)
@@ -243,17 +254,31 @@
 size_t RtpPacketizerH264::PacketizeStapA(size_t fragment_index) {
   // Aggregate fragments into one packet (STAP-A).
   size_t payload_size_left = limits_.max_payload_len;
-  if (fragment_index == 0)
+  if (input_fragments_.size() == 1)
+    payload_size_left -= limits_.single_packet_reduction_len;
+  else if (fragment_index == 0)
     payload_size_left -= limits_.first_packet_reduction_len;
   int aggregated_fragments = 0;
   size_t fragment_headers_length = 0;
   const Fragment* fragment = &input_fragments_[fragment_index];
   RTC_CHECK_GE(payload_size_left, fragment->length);
   ++num_packets_left_;
-  while (payload_size_left >= fragment->length + fragment_headers_length &&
-         (fragment_index + 1 < input_fragments_.size() ||
-          payload_size_left >= fragment->length + fragment_headers_length +
-                                   limits_.last_packet_reduction_len)) {
+
+  auto payload_size_needed = [&] {
+    size_t fragment_size = fragment->length + fragment_headers_length;
+    if (input_fragments_.size() == 1) {
+      // Single fragment, single packet, payload_size_left already adjusted
+      // with limits_.single_packet_reduction_len.
+      return fragment_size;
+    }
+    if (fragment_index == input_fragments_.size() - 1) {
+      // Last fragment, so StrapA might be the last packet.
+      return fragment_size + limits_.last_packet_reduction_len;
+    }
+    return fragment_size;
+  };
+
+  while (payload_size_left >= payload_size_needed()) {
     RTC_CHECK_GT(fragment->length, 0);
     packets_.push(PacketUnit(*fragment, aggregated_fragments == 0, false, true,
                              fragment->buffer[0]));
@@ -282,9 +307,11 @@
 bool RtpPacketizerH264::PacketizeSingleNalu(size_t fragment_index) {
   // Add a single NALU to the queue, no aggregation.
   size_t payload_size_left = limits_.max_payload_len;
-  if (fragment_index == 0)
+  if (input_fragments_.size() == 1)
+    payload_size_left -= limits_.single_packet_reduction_len;
+  else if (fragment_index == 0)
     payload_size_left -= limits_.first_packet_reduction_len;
-  if (fragment_index + 1 == input_fragments_.size())
+  else if (fragment_index + 1 == input_fragments_.size())
     payload_size_left -= limits_.last_packet_reduction_len;
   const Fragment* fragment = &input_fragments_[fragment_index];
   if (payload_size_left < fragment->length) {
diff --git a/modules/rtp_rtcp/source/rtp_format_h264.h b/modules/rtp_rtcp/source/rtp_format_h264.h
index 73e4087..fbd4fd9 100644
--- a/modules/rtp_rtcp/source/rtp_format_h264.h
+++ b/modules/rtp_rtcp/source/rtp_format_h264.h
@@ -11,12 +11,17 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_RTP_FORMAT_H264_H_
 #define MODULES_RTP_RTCP_SOURCE_RTP_FORMAT_H264_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <deque>
 #include <memory>
 #include <queue>
-#include <string>
 
+#include "api/array_view.h"
+#include "modules/include/module_common_types.h"
 #include "modules/rtp_rtcp/source/rtp_format.h"
+#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
+#include "modules/video_coding/codecs/h264/include/h264_globals.h"
 #include "rtc_base/buffer.h"
 #include "rtc_base/constructormagic.h"
 
diff --git a/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc b/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc
index edf907a..aeab813 100644
--- a/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc
@@ -390,7 +390,7 @@
                                NoFragmentation(frame));
   std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
 
-  RTC_CHECK_GE(packets.size(), 2);  // Single packet indicates it is not FuA.
+  EXPECT_GE(packets.size(), 2u);  // Single packet indicates it is not FuA.
   std::vector<uint16_t> fua_header;
   std::vector<int> payload_sizes;
 
@@ -422,6 +422,7 @@
   RtpPacketizer::PayloadSizeLimits limits;
   limits.max_payload_len = 1200;
   limits.first_packet_reduction_len = 4;
+  limits.single_packet_reduction_len = 4;
   EXPECT_THAT(TestFua(1198, limits), ElementsAre(597, 601));
 }
 
@@ -429,14 +430,14 @@
   RtpPacketizer::PayloadSizeLimits limits;
   limits.max_payload_len = 1200;
   limits.last_packet_reduction_len = 4;
+  limits.single_packet_reduction_len = 4;
   EXPECT_THAT(TestFua(1198, limits), ElementsAre(601, 597));
 }
 
-TEST(RtpPacketizerH264Test, FUAWithFirstAndLastPacketReduction) {
+TEST(RtpPacketizerH264Test, FUAWithSinglePacketReduction) {
   RtpPacketizer::PayloadSizeLimits limits;
   limits.max_payload_len = 1199;
-  limits.first_packet_reduction_len = 100;
-  limits.last_packet_reduction_len = 100;
+  limits.single_packet_reduction_len = 200;
   EXPECT_THAT(TestFua(1000, limits), ElementsAre(500, 500));
 }
 
diff --git a/modules/rtp_rtcp/source/rtp_format_unittest.cc b/modules/rtp_rtcp/source/rtp_format_unittest.cc
index a79c434..ae1b5b0 100644
--- a/modules/rtp_rtcp/source/rtp_format_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_format_unittest.cc
@@ -199,21 +199,32 @@
 }
 
 TEST(RtpPacketizerSplitAboutEqually,
-     OnePacketWhenExtraSpaceIsEnoughForSumOfFirstAndLastPacketReductions) {
+     IgnoresFirstAndLastPacketReductionWhenPayloadFitsIntoSinglePacket) {
   RtpPacketizer::PayloadSizeLimits limits;
   limits.max_payload_len = 30;
-  limits.first_packet_reduction_len = 6;
-  limits.last_packet_reduction_len = 4;
+  limits.first_packet_reduction_len = 29;
+  limits.last_packet_reduction_len = 29;
+  limits.single_packet_reduction_len = 10;
 
   EXPECT_THAT(RtpPacketizer::SplitAboutEqually(20, limits), ElementsAre(20));
 }
 
 TEST(RtpPacketizerSplitAboutEqually,
-     TwoPacketsWhenExtraSpaceIsTooSmallForSumOfFirstAndLastPacketReductions) {
+     OnePacketWhenExtraSpaceIsEnoughForSinglePacketReduction) {
+  RtpPacketizer::PayloadSizeLimits limits;
+  limits.max_payload_len = 30;
+  limits.single_packet_reduction_len = 10;
+
+  EXPECT_THAT(RtpPacketizer::SplitAboutEqually(20, limits), ElementsAre(20));
+}
+
+TEST(RtpPacketizerSplitAboutEqually,
+     TwoPacketsWhenExtraSpaceIsTooSmallForSinglePacketReduction) {
   RtpPacketizer::PayloadSizeLimits limits;
   limits.max_payload_len = 29;
-  limits.first_packet_reduction_len = 6;
-  limits.last_packet_reduction_len = 4;
+  limits.first_packet_reduction_len = 3;
+  limits.last_packet_reduction_len = 1;
+  limits.single_packet_reduction_len = 10;
 
   // First packet needs two more extra bytes compared to last one,
   // so should have two less payload bytes.
@@ -246,8 +257,7 @@
 TEST(RtpPacketizerSplitAboutEqually, CantPutSinglePayloadByteInTwoPackets) {
   RtpPacketizer::PayloadSizeLimits limits;
   limits.max_payload_len = 10;
-  limits.first_packet_reduction_len = 6;
-  limits.last_packet_reduction_len = 4;
+  limits.single_packet_reduction_len = 10;
 
   EXPECT_THAT(RtpPacketizer::SplitAboutEqually(1, limits), IsEmpty());
 }
@@ -255,8 +265,7 @@
 TEST(RtpPacketizerSplitAboutEqually, CanPutTwoPayloadBytesInTwoPackets) {
   RtpPacketizer::PayloadSizeLimits limits;
   limits.max_payload_len = 10;
-  limits.first_packet_reduction_len = 6;
-  limits.last_packet_reduction_len = 4;
+  limits.single_packet_reduction_len = 10;
 
   EXPECT_THAT(RtpPacketizer::SplitAboutEqually(2, limits), ElementsAre(1, 1));
 }
@@ -264,8 +273,7 @@
 TEST(RtpPacketizerSplitAboutEqually, CanPutSinglePayloadByteInOnePacket) {
   RtpPacketizer::PayloadSizeLimits limits;
   limits.max_payload_len = 11;
-  limits.first_packet_reduction_len = 6;
-  limits.last_packet_reduction_len = 4;
+  limits.single_packet_reduction_len = 10;
 
   EXPECT_THAT(RtpPacketizer::SplitAboutEqually(1, limits), ElementsAre(1));
 }
diff --git a/modules/rtp_rtcp/source/rtp_format_video_generic.cc b/modules/rtp_rtcp/source/rtp_format_video_generic.cc
index edd1e3c..92aada4 100644
--- a/modules/rtp_rtcp/source/rtp_format_video_generic.cc
+++ b/modules/rtp_rtcp/source/rtp_format_video_generic.cc
@@ -8,11 +8,13 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-#include <string>
+#include <assert.h>
+#include <string.h>
 
-#include "modules/include/module_common_types.h"
+#include "absl/types/optional.h"
 #include "modules/rtp_rtcp/source/rtp_format_video_generic.h"
 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 
 namespace webrtc {
diff --git a/modules/rtp_rtcp/source/rtp_format_video_generic.h b/modules/rtp_rtcp/source/rtp_format_video_generic.h
index 03509f5..3458d49 100644
--- a/modules/rtp_rtcp/source/rtp_format_video_generic.h
+++ b/modules/rtp_rtcp/source/rtp_format_video_generic.h
@@ -10,6 +10,7 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_RTP_FORMAT_VIDEO_GENERIC_H_
 #define MODULES_RTP_RTCP_SOURCE_RTP_FORMAT_VIDEO_GENERIC_H_
 
+#include <stdint.h>
 #include <vector>
 
 #include "api/array_view.h"
@@ -18,6 +19,10 @@
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
+
+class RtpPacketToSend;
+struct RTPVideoHeader;
+
 namespace RtpFormatVideoGeneric {
 static const uint8_t kKeyFrameBit = 0x01;
 static const uint8_t kFirstPacketBit = 0x02;
diff --git a/modules/rtp_rtcp/source/rtp_format_vp8.cc b/modules/rtp_rtcp/source/rtp_format_vp8.cc
index f40434e..a1248cf 100644
--- a/modules/rtp_rtcp/source/rtp_format_vp8.cc
+++ b/modules/rtp_rtcp/source/rtp_format_vp8.cc
@@ -10,13 +10,13 @@
 
 #include "modules/rtp_rtcp/source/rtp_format_vp8.h"
 
+#include <stdint.h>
 #include <string.h>  // memcpy
-
-#include <limits>
-#include <utility>
 #include <vector>
 
+#include "common_types.h"  // NOLINT(build/include)
 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
+#include "modules/video_coding/codecs/interface/common_constants.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 
diff --git a/modules/rtp_rtcp/source/rtp_format_vp8.h b/modules/rtp_rtcp/source/rtp_format_vp8.h
index e4bc36e..444298f 100644
--- a/modules/rtp_rtcp/source/rtp_format_vp8.h
+++ b/modules/rtp_rtcp/source/rtp_format_vp8.h
@@ -25,13 +25,15 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_RTP_FORMAT_VP8_H_
 #define MODULES_RTP_RTCP_SOURCE_RTP_FORMAT_VP8_H_
 
-#include <string>
+#include <stddef.h>
+#include <cstdint>
 #include <vector>
 
 #include "absl/container/inlined_vector.h"
 #include "api/array_view.h"
-#include "modules/include/module_common_types.h"
 #include "modules/rtp_rtcp/source/rtp_format.h"
+#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
+#include "modules/video_coding/codecs/vp8/include/vp8_globals.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
diff --git a/modules/rtp_rtcp/source/rtp_format_vp9.cc b/modules/rtp_rtcp/source/rtp_format_vp9.cc
index 4419d1a..9cd7514 100644
--- a/modules/rtp_rtcp/source/rtp_format_vp9.cc
+++ b/modules/rtp_rtcp/source/rtp_format_vp9.cc
@@ -12,9 +12,9 @@
 
 #include <string.h>
 
-#include <cmath>
-
+#include "common_types.h"  // NOLINT(build/include)
 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
+#include "modules/video_coding/codecs/interface/common_constants.h"
 #include "rtc_base/bitbuffer.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
@@ -451,6 +451,7 @@
       remaining_payload_(payload) {
   limits.max_payload_len -= header_size_;
   limits.first_packet_reduction_len += first_packet_extra_header_size_;
+  limits.single_packet_reduction_len += first_packet_extra_header_size_;
 
   payload_sizes_ = SplitAboutEqually(payload.size(), limits);
   current_packet_ = payload_sizes_.begin();
diff --git a/modules/rtp_rtcp/source/rtp_format_vp9.h b/modules/rtp_rtcp/source/rtp_format_vp9.h
index 8a2a2a6..c3b8f17 100644
--- a/modules/rtp_rtcp/source/rtp_format_vp9.h
+++ b/modules/rtp_rtcp/source/rtp_format_vp9.h
@@ -21,12 +21,14 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_RTP_FORMAT_VP9_H_
 #define MODULES_RTP_RTCP_SOURCE_RTP_FORMAT_VP9_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <vector>
 
 #include "api/array_view.h"
-#include "modules/include/module_common_types.h"
 #include "modules/rtp_rtcp/source/rtp_format.h"
 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
+#include "modules/video_coding/codecs/vp9/include/vp9_globals.h"
 #include "rtc_base/constructormagic.h"
 
 namespace webrtc {
diff --git a/modules/rtp_rtcp/source/rtp_generic_frame_descriptor.cc b/modules/rtp_rtcp/source/rtp_generic_frame_descriptor.cc
index 1b93132..c27fb6e 100644
--- a/modules/rtp_rtcp/source/rtp_generic_frame_descriptor.cc
+++ b/modules/rtp_rtcp/source/rtp_generic_frame_descriptor.cc
@@ -10,6 +10,8 @@
 
 #include "modules/rtp_rtcp/source/rtp_generic_frame_descriptor.h"
 
+#include <cstdint>
+
 #include "rtc_base/checks.h"
 
 namespace webrtc {
@@ -56,6 +58,16 @@
   spatial_layers_ = spatial_layers;
 }
 
+void RtpGenericFrameDescriptor::SetResolution(int width, int height) {
+  RTC_DCHECK(FirstPacketInSubFrame());
+  RTC_DCHECK_GE(width, 0);
+  RTC_DCHECK_LE(width, 0xFFFF);
+  RTC_DCHECK_GE(height, 0);
+  RTC_DCHECK_LE(height, 0xFFFF);
+  width_ = width;
+  height_ = height;
+}
+
 uint16_t RtpGenericFrameDescriptor::FrameId() const {
   RTC_DCHECK(FirstPacketInSubFrame());
   return frame_id_;
diff --git a/modules/rtp_rtcp/source/rtp_generic_frame_descriptor.h b/modules/rtp_rtcp/source/rtp_generic_frame_descriptor.h
index 1bde4fa..3a6c34d 100644
--- a/modules/rtp_rtcp/source/rtp_generic_frame_descriptor.h
+++ b/modules/rtp_rtcp/source/rtp_generic_frame_descriptor.h
@@ -50,6 +50,10 @@
   uint8_t SpatialLayersBitmask() const;
   void SetSpatialLayersBitmask(uint8_t spatial_layers);
 
+  int Width() const { return width_; }
+  int Height() const { return height_; }
+  void SetResolution(int width, int height);
+
   uint16_t FrameId() const;
   void SetFrameId(uint16_t frame_id);
 
@@ -72,6 +76,9 @@
   uint8_t temporal_layer_ = 0;
   size_t num_frame_deps_ = 0;
   uint16_t frame_deps_id_diffs_[kMaxNumFrameDependencies];
+  int width_ = 0;
+  int height_ = 0;
+
   std::vector<uint8_t> byte_representation_;
 };
 
diff --git a/modules/rtp_rtcp/source/rtp_generic_frame_descriptor_extension.cc b/modules/rtp_rtcp/source/rtp_generic_frame_descriptor_extension.cc
index c7b52d5..7cd120d 100644
--- a/modules/rtp_rtcp/source/rtp_generic_frame_descriptor_extension.cc
+++ b/modules/rtp_rtcp/source/rtp_generic_frame_descriptor_extension.cc
@@ -36,6 +36,14 @@
 // B:   +      FID      +
 //      |               |
 //      +-+-+-+-+-+-+-+-+
+//      |               |
+//      +     Width     +
+// B=1  |               |
+// and  +-+-+-+-+-+-+-+-+
+// D=0  |               |
+//      +     Height    +
+//      |               |
+//      +-+-+-+-+-+-+-+-+
 // D:   |    FDIFF  |X|M|
 //      +---------------+
 // X:   |      ...      |
@@ -75,6 +83,12 @@
   descriptor->ClearFrameDependencies();
   size_t offset = 4;
   bool has_more_dependencies = (data[0] & kFlagDependencies) != 0;
+  if (!has_more_dependencies && data.size() >= offset + 4) {
+    uint16_t width = (data[offset] << 8) | data[offset + 1];
+    uint16_t height = (data[offset + 2] << 8) | data[offset + 3];
+    descriptor->SetResolution(width, height);
+    offset += 4;
+  }
   while (has_more_dependencies) {
     if (data.size() == offset)
       return false;
@@ -91,7 +105,7 @@
     if (!descriptor->AddFrameDependencyDiff(fdiff))
       return false;
   }
-  return data.size() == offset;
+  return true;
 }
 
 size_t RtpGenericFrameDescriptorExtension::ValueSize(
@@ -103,6 +117,11 @@
   for (uint16_t fdiff : descriptor.FrameDependenciesDiffs()) {
     size += (fdiff >= (1 << 6)) ? 2 : 1;
   }
+  if (descriptor.FirstPacketInSubFrame() &&
+      descriptor.FrameDependenciesDiffs().empty() && descriptor.Width() > 0 &&
+      descriptor.Height() > 0) {
+    size += 4;
+  }
   return size;
 }
 
@@ -129,6 +148,13 @@
   data[3] = frame_id >> 8;
   rtc::ArrayView<const uint16_t> fdiffs = descriptor.FrameDependenciesDiffs();
   size_t offset = 4;
+  if (descriptor.FirstPacketInSubFrame() && fdiffs.empty() &&
+      descriptor.Width() > 0 && descriptor.Height() > 0) {
+    data[offset++] = (descriptor.Width() >> 8);
+    data[offset++] = (descriptor.Width() & 0xFF);
+    data[offset++] = (descriptor.Height() >> 8);
+    data[offset++] = (descriptor.Height() & 0xFF);
+  }
   for (size_t i = 0; i < fdiffs.size(); i++) {
     bool extended = fdiffs[i] >= (1 << 6);
     bool more = i < fdiffs.size() - 1;
diff --git a/modules/rtp_rtcp/source/rtp_generic_frame_descriptor_extension.h b/modules/rtp_rtcp/source/rtp_generic_frame_descriptor_extension.h
index 2dd9dd4..0d673e0 100644
--- a/modules/rtp_rtcp/source/rtp_generic_frame_descriptor_extension.h
+++ b/modules/rtp_rtcp/source/rtp_generic_frame_descriptor_extension.h
@@ -21,6 +21,7 @@
 
 class RtpGenericFrameDescriptorExtension {
  public:
+  using value_type = RtpGenericFrameDescriptor;
   static constexpr RTPExtensionType kId = kRtpExtensionGenericFrameDescriptor;
   static constexpr char kUri[] =
       "http://www.webrtc.org/experiments/rtp-hdrext/"
diff --git a/modules/rtp_rtcp/source/rtp_generic_frame_descriptor_extension_unittest.cc b/modules/rtp_rtcp/source/rtp_generic_frame_descriptor_extension_unittest.cc
index bb69e14..7f8fa2f 100644
--- a/modules/rtp_rtcp/source/rtp_generic_frame_descriptor_extension_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_generic_frame_descriptor_extension_unittest.cc
@@ -279,5 +279,32 @@
   EXPECT_THAT(buffer, ElementsAreArray(kRaw));
 }
 
+TEST(RtpGenericFrameDescriptorExtensionTest,
+     ParseResolutionOnIndependentFrame) {
+  constexpr int kWidth = 0x2468;
+  constexpr int kHeight = 0x6543;
+  constexpr uint8_t kRaw[] = {0x80, 0x01, 0x00, 0x00, 0x24, 0x68, 0x65, 0x43};
+  RtpGenericFrameDescriptor descriptor;
+
+  ASSERT_TRUE(RtpGenericFrameDescriptorExtension::Parse(kRaw, &descriptor));
+  EXPECT_EQ(descriptor.Width(), kWidth);
+  EXPECT_EQ(descriptor.Height(), kHeight);
+}
+
+TEST(RtpGenericFrameDescriptorExtensionTest,
+     WriteResolutionOnIndependentFrame) {
+  constexpr int kWidth = 0x2468;
+  constexpr int kHeight = 0x6543;
+  constexpr uint8_t kRaw[] = {0x80, 0x01, 0x00, 0x00, 0x24, 0x68, 0x65, 0x43};
+  RtpGenericFrameDescriptor descriptor;
+  descriptor.SetFirstPacketInSubFrame(true);
+  descriptor.SetResolution(kWidth, kHeight);
+
+  ASSERT_EQ(RtpGenericFrameDescriptorExtension::ValueSize(descriptor),
+            sizeof(kRaw));
+  uint8_t buffer[sizeof(kRaw)];
+  EXPECT_TRUE(RtpGenericFrameDescriptorExtension::Write(buffer, descriptor));
+  EXPECT_THAT(buffer, ElementsAreArray(kRaw));
+}
 }  // namespace
 }  // namespace webrtc
diff --git a/modules/rtp_rtcp/source/rtp_header_extension_map.cc b/modules/rtp_rtcp/source/rtp_header_extension_map.cc
index 168665a..dde25e3 100644
--- a/modules/rtp_rtcp/source/rtp_header_extension_map.cc
+++ b/modules/rtp_rtcp/source/rtp_header_extension_map.cc
@@ -56,15 +56,17 @@
 constexpr RTPExtensionType RtpHeaderExtensionMap::kInvalidType;
 constexpr int RtpHeaderExtensionMap::kInvalidId;
 
-RtpHeaderExtensionMap::RtpHeaderExtensionMap()
-    : mixed_one_two_byte_header_supported_(false) {
+RtpHeaderExtensionMap::RtpHeaderExtensionMap() : RtpHeaderExtensionMap(false) {}
+
+RtpHeaderExtensionMap::RtpHeaderExtensionMap(bool extmap_allow_mixed)
+    : extmap_allow_mixed_(extmap_allow_mixed) {
   for (auto& id : ids_)
     id = kInvalidId;
 }
 
 RtpHeaderExtensionMap::RtpHeaderExtensionMap(
     rtc::ArrayView<const RtpExtension> extensions)
-    : RtpHeaderExtensionMap() {
+    : RtpHeaderExtensionMap(false) {
   for (const RtpExtension& extension : extensions)
     RegisterByUri(extension.id, extension.uri);
 }
diff --git a/modules/rtp_rtcp/source/rtp_header_extensions.cc b/modules/rtp_rtcp/source/rtp_header_extensions.cc
index fc4b7ce..082e0e0 100644
--- a/modules/rtp_rtcp/source/rtp_header_extensions.cc
+++ b/modules/rtp_rtcp/source/rtp_header_extensions.cc
@@ -10,10 +10,13 @@
 
 #include "modules/rtp_rtcp/source/rtp_header_extensions.h"
 
+#include <string.h>
+
 #include "modules/rtp_rtcp/include/rtp_cvo.h"
 #include "modules/rtp_rtcp/source/byte_io.h"
+// TODO(bug:9855) Move kNoSpatialIdx from vp9_globals.h to common_constants
+#include "modules/video_coding/codecs/interface/common_constants.h"
 #include "rtc_base/checks.h"
-#include "rtc_base/logging.h"
 
 namespace webrtc {
 // Absolute send time in RTP streams.
diff --git a/modules/rtp_rtcp/source/rtp_header_extensions.h b/modules/rtp_rtcp/source/rtp_header_extensions.h
index 84e9831..808356a 100644
--- a/modules/rtp_rtcp/source/rtp_header_extensions.h
+++ b/modules/rtp_rtcp/source/rtp_header_extensions.h
@@ -10,19 +10,24 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_RTP_HEADER_EXTENSIONS_H_
 #define MODULES_RTP_RTCP_SOURCE_RTP_HEADER_EXTENSIONS_H_
 
+#include <stddef.h>
 #include <stdint.h>
 #include <string>
 
 #include "api/array_view.h"
+#include "api/rtp_headers.h"
 #include "api/video/video_content_type.h"
+#include "api/video/video_frame_marking.h"
 #include "api/video/video_rotation.h"
 #include "api/video/video_timing.h"
+#include "common_types.h"  // NOLINT(build/include)
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 
 namespace webrtc {
 
 class AbsoluteSendTime {
  public:
+  using value_type = uint32_t;
   static constexpr RTPExtensionType kId = kRtpExtensionAbsoluteSendTime;
   static constexpr uint8_t kValueSizeBytes = 3;
   static constexpr const char kUri[] =
@@ -57,6 +62,7 @@
 
 class TransmissionOffset {
  public:
+  using value_type = int32_t;
   static constexpr RTPExtensionType kId = kRtpExtensionTransmissionTimeOffset;
   static constexpr uint8_t kValueSizeBytes = 3;
   static constexpr const char kUri[] = "urn:ietf:params:rtp-hdrext:toffset";
@@ -68,6 +74,7 @@
 
 class TransportSequenceNumber {
  public:
+  using value_type = uint16_t;
   static constexpr RTPExtensionType kId = kRtpExtensionTransportSequenceNumber;
   static constexpr uint8_t kValueSizeBytes = 2;
   static constexpr const char kUri[] =
@@ -80,6 +87,7 @@
 
 class VideoOrientation {
  public:
+  using value_type = VideoRotation;
   static constexpr RTPExtensionType kId = kRtpExtensionVideoRotation;
   static constexpr uint8_t kValueSizeBytes = 1;
   static constexpr const char kUri[] = "urn:3gpp:video-orientation";
@@ -94,6 +102,7 @@
 
 class PlayoutDelayLimits {
  public:
+  using value_type = PlayoutDelay;
   static constexpr RTPExtensionType kId = kRtpExtensionPlayoutDelay;
   static constexpr uint8_t kValueSizeBytes = 3;
   static constexpr const char kUri[] =
@@ -117,6 +126,7 @@
 
 class VideoContentTypeExtension {
  public:
+  using value_type = VideoContentType;
   static constexpr RTPExtensionType kId = kRtpExtensionVideoContentType;
   static constexpr uint8_t kValueSizeBytes = 1;
   static constexpr const char kUri[] =
@@ -133,6 +143,7 @@
 
 class VideoTimingExtension {
  public:
+  using value_type = VideoSendTiming;
   static constexpr RTPExtensionType kId = kRtpExtensionVideoTiming;
   static constexpr uint8_t kValueSizeBytes = 13;
   static constexpr const char kUri[] =
@@ -155,6 +166,7 @@
 
 class FrameMarkingExtension {
  public:
+  using value_type = FrameMarking;
   static constexpr RTPExtensionType kId = kRtpExtensionFrameMarking;
   static constexpr const char kUri[] =
       "http://tools.ietf.org/html/draft-ietf-avtext-framemarking-07";
@@ -173,6 +185,7 @@
 // Subclasses must defined kId and kUri static constexpr members.
 class BaseRtpStringExtension {
  public:
+  using value_type = std::string;
   // String RTP header extensions are limited to 16 bytes because it is the
   // maximum length that can be encoded with one-byte header extensions.
   static constexpr uint8_t kMaxValueSizeBytes = 16;
diff --git a/modules/rtp_rtcp/source/rtp_header_parser.cc b/modules/rtp_rtcp/source/rtp_header_parser.cc
index df68f74..bc05033 100644
--- a/modules/rtp_rtcp/source/rtp_header_parser.cc
+++ b/modules/rtp_rtcp/source/rtp_header_parser.cc
@@ -9,9 +9,12 @@
  */
 #include "modules/rtp_rtcp/include/rtp_header_parser.h"
 
+#include <string.h>
+
 #include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
 #include "modules/rtp_rtcp/source/rtp_utility.h"
 #include "rtc_base/criticalsection.h"
+#include "rtc_base/thread_annotations.h"
 
 namespace webrtc {
 
diff --git a/modules/rtp_rtcp/source/rtp_packet.cc b/modules/rtp_rtcp/source/rtp_packet.cc
index 8cb8fd8..9d4dce4 100644
--- a/modules/rtp_rtcp/source/rtp_packet.cc
+++ b/modules/rtp_rtcp/source/rtp_packet.cc
@@ -10,11 +10,11 @@
 
 #include "modules/rtp_rtcp/source/rtp_packet.h"
 
+#include <cstdint>
 #include <cstring>
 #include <utility>
 
 #include "api/rtpparameters.h"
-#include "common_types.h"  // NOLINT(build/include)
 #include "modules/rtp_rtcp/source/byte_io.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
@@ -211,8 +211,7 @@
   const bool two_byte_header_required =
       id > RtpExtension::kOneByteHeaderExtensionMaxId ||
       length > RtpExtension::kOneByteHeaderExtensionMaxValueSize || length == 0;
-  RTC_CHECK(!two_byte_header_required ||
-            extensions_.IsMixedOneTwoByteHeaderSupported());
+  RTC_CHECK(!two_byte_header_required || extensions_.ExtmapAllowMixed());
 
   uint16_t profile_id;
   if (extensions_size_ > 0) {
@@ -553,7 +552,7 @@
                                                      size_t length) {
   // TODO(webrtc:7990): Add support for empty extensions (length==0).
   if (length == 0 || length > RtpExtension::kMaxValueSize ||
-      (!extensions_.IsMixedOneTwoByteHeaderSupported() &&
+      (!extensions_.ExtmapAllowMixed() &&
        length > RtpExtension::kOneByteHeaderExtensionMaxValueSize)) {
     return nullptr;
   }
@@ -563,7 +562,7 @@
     // Extension not registered.
     return nullptr;
   }
-  if (!extensions_.IsMixedOneTwoByteHeaderSupported() &&
+  if (!extensions_.ExtmapAllowMixed() &&
       id > RtpExtension::kOneByteHeaderExtensionMaxId) {
     return nullptr;
   }
diff --git a/modules/rtp_rtcp/source/rtp_packet.h b/modules/rtp_rtcp/source/rtp_packet.h
index 3d7d90c..76666b7 100644
--- a/modules/rtp_rtcp/source/rtp_packet.h
+++ b/modules/rtp_rtcp/source/rtp_packet.h
@@ -12,6 +12,7 @@
 
 #include <vector>
 
+#include "absl/types/optional.h"
 #include "api/array_view.h"
 #include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
@@ -95,8 +96,11 @@
   template <typename Extension>
   bool HasExtension() const;
 
-  template <typename Extension, typename... Values>
-  bool GetExtension(Values...) const;
+  template <typename Extension, typename FirstValue, typename... Values>
+  bool GetExtension(FirstValue, Values...) const;
+
+  template <typename Extension>
+  absl::optional<typename Extension::value_type> GetExtension() const;
 
   // Returns view of the raw extension or empty view on failure.
   template <typename Extension>
@@ -183,12 +187,21 @@
   return !FindExtension(Extension::kId).empty();
 }
 
-template <typename Extension, typename... Values>
-bool RtpPacket::GetExtension(Values... values) const {
+template <typename Extension, typename FirstValue, typename... Values>
+bool RtpPacket::GetExtension(FirstValue first, Values... values) const {
   auto raw = FindExtension(Extension::kId);
   if (raw.empty())
     return false;
-  return Extension::Parse(raw, values...);
+  return Extension::Parse(raw, first, values...);
+}
+
+template <typename Extension>
+absl::optional<typename Extension::value_type> RtpPacket::GetExtension() const {
+  absl::optional<typename Extension::value_type> result;
+  auto raw = FindExtension(Extension::kId);
+  if (raw.empty() || !Extension::Parse(raw, &result.emplace()))
+    result = absl::nullopt;
+  return result;
 }
 
 template <typename Extension>
diff --git a/modules/rtp_rtcp/source/rtp_packet_history.cc b/modules/rtp_rtcp/source/rtp_packet_history.cc
index 211077b..8c1c8eb 100644
--- a/modules/rtp_rtcp/source/rtp_packet_history.cc
+++ b/modules/rtp_rtcp/source/rtp_packet_history.cc
@@ -125,8 +125,7 @@
 }
 
 std::unique_ptr<RtpPacketToSend> RtpPacketHistory::GetPacketAndSetSendTime(
-    uint16_t sequence_number,
-    bool verify_rtt) {
+    uint16_t sequence_number) {
   rtc::CritScope cs(&lock_);
   if (mode_ == StorageMode::kDisabled) {
     return nullptr;
@@ -139,7 +138,7 @@
   }
 
   StoredPacket& packet = rtp_it->second;
-  if (verify_rtt && !VerifyRtt(rtp_it->second, now_ms)) {
+  if (!VerifyRtt(rtp_it->second, now_ms)) {
     return nullptr;
   }
 
@@ -159,8 +158,7 @@
 }
 
 absl::optional<RtpPacketHistory::PacketState> RtpPacketHistory::GetPacketState(
-    uint16_t sequence_number,
-    bool verify_rtt) const {
+    uint16_t sequence_number) const {
   rtc::CritScope cs(&lock_);
   if (mode_ == StorageMode::kDisabled) {
     return absl::nullopt;
@@ -171,7 +169,7 @@
     return absl::nullopt;
   }
 
-  if (verify_rtt && !VerifyRtt(rtp_it->second, clock_->TimeInMilliseconds())) {
+  if (!VerifyRtt(rtp_it->second, clock_->TimeInMilliseconds())) {
     return absl::nullopt;
   }
 
diff --git a/modules/rtp_rtcp/source/rtp_packet_history.h b/modules/rtp_rtcp/source/rtp_packet_history.h
index 1646ba7..095424e 100644
--- a/modules/rtp_rtcp/source/rtp_packet_history.h
+++ b/modules/rtp_rtcp/source/rtp_packet_history.h
@@ -76,16 +76,13 @@
                     absl::optional<int64_t> send_time_ms);
 
   // Gets stored RTP packet corresponding to the input |sequence number|.
-  // Returns nullptr if packet is not found. If |verify_rtt| is true, doesn't
-  // return packet that was (re)sent too recently.
+  // Returns nullptr if packet is not found or was (re)sent too recently.
   std::unique_ptr<RtpPacketToSend> GetPacketAndSetSendTime(
-      uint16_t sequence_number,
-      bool verify_rtt);
+      uint16_t sequence_number);
 
   // Similar to GetPacketAndSetSendTime(), but only returns a snapshot of the
   // current state for packet, and never updates internal state.
-  absl::optional<PacketState> GetPacketState(uint16_t sequence_number,
-                                             bool verify_rtt) const;
+  absl::optional<PacketState> GetPacketState(uint16_t sequence_number) const;
 
   // Get the packet (if any) from the history, with size closest to
   // |packet_size|. The exact size of the packet is not guaranteed.
diff --git a/modules/rtp_rtcp/source/rtp_packet_history_unittest.cc b/modules/rtp_rtcp/source/rtp_packet_history_unittest.cc
index 85e9eb2..140434c 100644
--- a/modules/rtp_rtcp/source/rtp_packet_history_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_packet_history_unittest.cc
@@ -63,11 +63,11 @@
   // Store a packet, but with send-time. It should then not be removed.
   hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum), kAllowRetransmission,
                      absl::nullopt);
-  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum, false));
+  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum));
 
   // Changing store status, even to the current one, will clear the history.
   hist_.SetStorePacketsStatus(StorageMode::kStore, 10);
-  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum, false));
+  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum));
 }
 
 TEST_F(RtpPacketHistoryTest, StartSeqResetAfterReset) {
@@ -75,16 +75,16 @@
   // Store a packet, but with send-time. It should then not be removed.
   hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum), kAllowRetransmission,
                      absl::nullopt);
-  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum, false));
+  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum));
 
   // Changing store status, to clear the history.
   hist_.SetStorePacketsStatus(StorageMode::kStoreAndCull, 10);
-  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum, false));
+  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum));
 
   // Add a new packet.
   hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum + 1), kAllowRetransmission,
                      absl::nullopt);
-  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum + 1, false));
+  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum + 1));
 
   // Advance time past where packet expires.
   fake_clock_.AdvanceTimeMilliseconds(
@@ -94,9 +94,9 @@
   // Add one more packet and verify no state left from packet before reset.
   hist_.PutRtpPacket(CreateRtpPacket(To16u(kStartSeqNum + 2)),
                      kAllowRetransmission, absl::nullopt);
-  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum, false));
-  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum + 1, false));
-  EXPECT_TRUE(hist_.GetPacketState(To16u(kStartSeqNum + 2), false));
+  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum));
+  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum + 1));
+  EXPECT_TRUE(hist_.GetPacketState(To16u(kStartSeqNum + 2)));
 }
 
 TEST_F(RtpPacketHistoryTest, NoStoreStatus) {
@@ -104,21 +104,21 @@
   std::unique_ptr<RtpPacketToSend> packet = CreateRtpPacket(kStartSeqNum);
   hist_.PutRtpPacket(std::move(packet), kAllowRetransmission, absl::nullopt);
   // Packet should not be stored.
-  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum, false));
+  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum));
 }
 
 TEST_F(RtpPacketHistoryTest, GetRtpPacket_NotStored) {
   hist_.SetStorePacketsStatus(StorageMode::kStore, 10);
-  EXPECT_FALSE(hist_.GetPacketState(0, false));
+  EXPECT_FALSE(hist_.GetPacketState(0));
 }
 
 TEST_F(RtpPacketHistoryTest, PutRtpPacket) {
   hist_.SetStorePacketsStatus(StorageMode::kStore, 10);
   std::unique_ptr<RtpPacketToSend> packet = CreateRtpPacket(kStartSeqNum);
 
-  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum, false));
+  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum));
   hist_.PutRtpPacket(std::move(packet), kAllowRetransmission, absl::nullopt);
-  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum, false));
+  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum));
 }
 
 TEST_F(RtpPacketHistoryTest, GetRtpPacket) {
@@ -130,7 +130,7 @@
   hist_.PutRtpPacket(std::move(packet), kAllowRetransmission, absl::nullopt);
 
   std::unique_ptr<RtpPacketToSend> packet_out =
-      hist_.GetPacketAndSetSendTime(kStartSeqNum, false);
+      hist_.GetPacketAndSetSendTime(kStartSeqNum);
   EXPECT_TRUE(packet_out);
   EXPECT_EQ(buffer, packet_out->Buffer());
   EXPECT_EQ(capture_time_ms, packet_out->capture_time_ms());
@@ -146,7 +146,7 @@
   hist_.PutRtpPacket(std::move(packet), kAllowRetransmission, absl::nullopt);
 
   std::unique_ptr<RtpPacketToSend> packet_out =
-      hist_.GetPacketAndSetSendTime(kStartSeqNum, false);
+      hist_.GetPacketAndSetSendTime(kStartSeqNum);
   EXPECT_TRUE(packet_out);
   EXPECT_EQ(buffer, packet_out->Buffer());
   EXPECT_EQ(capture_time_ms, packet_out->capture_time_ms());
@@ -161,19 +161,21 @@
 
   // Get the packet and verify data.
   std::unique_ptr<RtpPacketToSend> packet_out;
-  packet_out = hist_.GetPacketAndSetSendTime(kStartSeqNum, false);
+  packet_out = hist_.GetPacketAndSetSendTime(kStartSeqNum);
   ASSERT_TRUE(packet_out);
   EXPECT_EQ(buffer.size(), packet_out->size());
   EXPECT_EQ(capture_time_ms, packet_out->capture_time_ms());
 
   // Non-retransmittable packets are immediately removed, so getting in again
   // should fail.
-  EXPECT_FALSE(hist_.GetPacketAndSetSendTime(kStartSeqNum, false));
+  EXPECT_FALSE(hist_.GetPacketAndSetSendTime(kStartSeqNum));
 }
 
 TEST_F(RtpPacketHistoryTest, PacketStateIsCorrect) {
   const uint32_t kSsrc = 92384762;
+  const int64_t kRttMs = 100;
   hist_.SetStorePacketsStatus(StorageMode::kStoreAndCull, 10);
+  hist_.SetRtt(kRttMs);
   std::unique_ptr<RtpPacketToSend> packet = CreateRtpPacket(kStartSeqNum);
   packet->SetSsrc(kSsrc);
   packet->SetPayloadSize(1234);
@@ -183,7 +185,7 @@
                      fake_clock_.TimeInMilliseconds());
 
   absl::optional<RtpPacketHistory::PacketState> state =
-      hist_.GetPacketState(kStartSeqNum, false);
+      hist_.GetPacketState(kStartSeqNum);
   ASSERT_TRUE(state);
   EXPECT_EQ(state->rtp_sequence_number, kStartSeqNum);
   EXPECT_EQ(state->send_time_ms, fake_clock_.TimeInMilliseconds());
@@ -193,9 +195,10 @@
   EXPECT_EQ(state->times_retransmitted, 0u);
 
   fake_clock_.AdvanceTimeMilliseconds(1);
-  EXPECT_TRUE(hist_.GetPacketAndSetSendTime(kStartSeqNum, false));
+  EXPECT_TRUE(hist_.GetPacketAndSetSendTime(kStartSeqNum));
+  fake_clock_.AdvanceTimeMilliseconds(kRttMs + 1);
 
-  state = hist_.GetPacketState(kStartSeqNum, false);
+  state = hist_.GetPacketState(kStartSeqNum);
   ASSERT_TRUE(state);
   EXPECT_EQ(state->times_retransmitted, 1u);
 }
@@ -211,7 +214,7 @@
   hist_.PutRtpPacket(std::move(packet), kAllowRetransmission, absl::nullopt);
 
   // First transmission: TimeToSendPacket() call from pacer.
-  EXPECT_TRUE(hist_.GetPacketAndSetSendTime(kStartSeqNum, false));
+  EXPECT_TRUE(hist_.GetPacketAndSetSendTime(kStartSeqNum));
 
   // First retransmission - allow early retransmission.
   fake_clock_.AdvanceTimeMilliseconds(1);
@@ -221,26 +224,24 @@
   //    packet is there and verify RTT constraints. Then we use the ssrc
   //    and sequence number to enqueue the retransmission in the pacer
   // 2) When the pacer determines that it is time to send the packet, it calls
-  //    GetPacketAndSetSendTime(). This time we do not need to verify RTT as
-  //    has that has already been done.
+  //    GetPacketAndSetSendTime().
   absl::optional<RtpPacketHistory::PacketState> packet_state =
-      hist_.GetPacketState(kStartSeqNum, /*verify_rtt=*/true);
+      hist_.GetPacketState(kStartSeqNum);
   EXPECT_TRUE(packet_state);
   EXPECT_EQ(len, packet_state->payload_size);
   EXPECT_EQ(capture_time_ms, packet_state->capture_time_ms);
 
   // Retransmission was allowed, next send it from pacer.
-  EXPECT_TRUE(hist_.GetPacketAndSetSendTime(kStartSeqNum,
-                                            /*verify_rtt=*/false));
+  EXPECT_TRUE(hist_.GetPacketAndSetSendTime(kStartSeqNum));
 
   // Second retransmission - advance time to just before retransmission OK.
   fake_clock_.AdvanceTimeMilliseconds(kMinRetransmitIntervalMs - 1);
-  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum, /*verify_rtt=*/true));
+  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum));
 
   // Advance time to just after retransmission OK.
   fake_clock_.AdvanceTimeMilliseconds(1);
-  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum, /*verify_rtt=*/true));
-  EXPECT_TRUE(hist_.GetPacketAndSetSendTime(kStartSeqNum, false));
+  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum));
+  EXPECT_TRUE(hist_.GetPacketAndSetSendTime(kStartSeqNum));
 }
 
 TEST_F(RtpPacketHistoryTest, MinResendTimeWithoutPacer) {
@@ -256,18 +257,18 @@
 
   // First retransmission - allow early retransmission.
   fake_clock_.AdvanceTimeMilliseconds(1);
-  packet = hist_.GetPacketAndSetSendTime(kStartSeqNum, true);
+  packet = hist_.GetPacketAndSetSendTime(kStartSeqNum);
   EXPECT_TRUE(packet);
   EXPECT_EQ(len, packet->size());
   EXPECT_EQ(capture_time_ms, packet->capture_time_ms());
 
   // Second retransmission - advance time to just before retransmission OK.
   fake_clock_.AdvanceTimeMilliseconds(kMinRetransmitIntervalMs - 1);
-  EXPECT_FALSE(hist_.GetPacketAndSetSendTime(kStartSeqNum, true));
+  EXPECT_FALSE(hist_.GetPacketAndSetSendTime(kStartSeqNum));
 
   // Advance time to just after retransmission OK.
   fake_clock_.AdvanceTimeMilliseconds(1);
-  EXPECT_TRUE(hist_.GetPacketAndSetSendTime(kStartSeqNum, true));
+  EXPECT_TRUE(hist_.GetPacketAndSetSendTime(kStartSeqNum));
 }
 
 TEST_F(RtpPacketHistoryTest, RemovesOldestSentPacketWhenAtMaxSize) {
@@ -289,7 +290,7 @@
   }
 
   // First packet should still be there.
-  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum, false));
+  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum));
 
   // History is full, oldest one should be overwritten.
   std::unique_ptr<RtpPacketToSend> packet =
@@ -298,8 +299,8 @@
                      fake_clock_.TimeInMilliseconds());
 
   // Oldest packet should be gone, but packet after than one still present.
-  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum, false));
-  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum + 1, false));
+  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum));
+  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum + 1));
 }
 
 TEST_F(RtpPacketHistoryTest, RemovesOldestPacketWhenAtMaxCapacity) {
@@ -317,7 +318,7 @@
   }
 
   // First packet should still be there.
-  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum, false));
+  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum));
 
   // History is full, oldest one should be overwritten.
   std::unique_ptr<RtpPacketToSend> packet =
@@ -326,8 +327,8 @@
                      fake_clock_.TimeInMilliseconds());
 
   // Oldest packet should be gone, but packet after than one still present.
-  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum, false));
-  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum + 1, false));
+  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum));
+  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum + 1));
 }
 
 TEST_F(RtpPacketHistoryTest, DontRemoveUnsentPackets) {
@@ -343,25 +344,25 @@
   fake_clock_.AdvanceTimeMilliseconds(RtpPacketHistory::kMinPacketDurationMs);
 
   // First packet should still be there.
-  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum, false));
+  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum));
 
   // History is full, but old packets not sent, so allow expansion.
   hist_.PutRtpPacket(CreateRtpPacket(To16u(kStartSeqNum + kMaxNumPackets)),
                      kAllowRetransmission, fake_clock_.TimeInMilliseconds());
-  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum, false));
+  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum));
 
   // Set all packet as sent and advance time past min packet duration time,
   // otherwise packets till still be prevented from being removed.
   for (size_t i = 0; i <= kMaxNumPackets; ++i) {
-    EXPECT_TRUE(hist_.GetPacketAndSetSendTime(To16u(kStartSeqNum + i), false));
+    EXPECT_TRUE(hist_.GetPacketAndSetSendTime(To16u(kStartSeqNum + i)));
   }
   fake_clock_.AdvanceTimeMilliseconds(RtpPacketHistory::kMinPacketDurationMs);
   // Add a new packet, this means the two oldest ones will be culled.
   hist_.PutRtpPacket(CreateRtpPacket(To16u(kStartSeqNum + kMaxNumPackets + 1)),
                      kAllowRetransmission, fake_clock_.TimeInMilliseconds());
-  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum, false));
-  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum + 1, false));
-  EXPECT_TRUE(hist_.GetPacketState(To16u(kStartSeqNum + 2), false));
+  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum));
+  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum + 1));
+  EXPECT_TRUE(hist_.GetPacketState(To16u(kStartSeqNum + 2)));
 }
 
 TEST_F(RtpPacketHistoryTest, DontRemoveTooRecentlyTransmittedPackets) {
@@ -378,15 +379,15 @@
   hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum + 1), kAllowRetransmission,
                      fake_clock_.TimeInMilliseconds());
   // First packet should still be there.
-  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum, false));
+  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum));
 
   // Advance time to where packet will be eligible for removal and try again.
   fake_clock_.AdvanceTimeMilliseconds(1);
   hist_.PutRtpPacket(CreateRtpPacket(To16u(kStartSeqNum + 2)),
                      kAllowRetransmission, fake_clock_.TimeInMilliseconds());
   // First packet should no be gone, but next one still there.
-  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum, false));
-  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum + 1, false));
+  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum));
+  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum + 1));
 }
 
 TEST_F(RtpPacketHistoryTest, DontRemoveTooRecentlyTransmittedPacketsHighRtt) {
@@ -407,15 +408,15 @@
   hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum + 1), kAllowRetransmission,
                      fake_clock_.TimeInMilliseconds());
   // First packet should still be there.
-  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum, false));
+  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum));
 
   // Advance time to where packet will be eligible for removal and try again.
   fake_clock_.AdvanceTimeMilliseconds(1);
   hist_.PutRtpPacket(CreateRtpPacket(To16u(kStartSeqNum + 2)),
                      kAllowRetransmission, fake_clock_.TimeInMilliseconds());
   // First packet should no be gone, but next one still there.
-  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum, false));
-  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum + 1, false));
+  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum));
+  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum + 1));
 }
 
 TEST_F(RtpPacketHistoryTest, RemovesOldWithCulling) {
@@ -431,14 +432,14 @@
   fake_clock_.AdvanceTimeMilliseconds(kMaxPacketDurationMs - 1);
 
   // First packet should still be there.
-  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum, false));
+  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum));
 
   // Advance to where packet can be culled, even if buffer is not full.
   fake_clock_.AdvanceTimeMilliseconds(1);
   hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum + 1), kAllowRetransmission,
                      fake_clock_.TimeInMilliseconds());
 
-  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum, false));
+  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum));
 }
 
 TEST_F(RtpPacketHistoryTest, RemovesOldWithCullingHighRtt) {
@@ -457,14 +458,14 @@
   fake_clock_.AdvanceTimeMilliseconds(kMaxPacketDurationMs - 1);
 
   // First packet should still be there.
-  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum, false));
+  EXPECT_TRUE(hist_.GetPacketState(kStartSeqNum));
 
   // Advance to where packet can be culled, even if buffer is not full.
   fake_clock_.AdvanceTimeMilliseconds(1);
   hist_.PutRtpPacket(CreateRtpPacket(kStartSeqNum + 1), kAllowRetransmission,
                      fake_clock_.TimeInMilliseconds());
 
-  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum, false));
+  EXPECT_FALSE(hist_.GetPacketState(kStartSeqNum));
 }
 
 TEST_F(RtpPacketHistoryTest, GetBestFittingPacket) {
@@ -503,7 +504,7 @@
   ASSERT_THAT(packet, ::testing::NotNull());
 
   // Send the packet and advance time past where packet expires.
-  ASSERT_THAT(hist_.GetPacketAndSetSendTime(kStartSeqNum, false),
+  ASSERT_THAT(hist_.GetPacketAndSetSendTime(kStartSeqNum),
               ::testing::NotNull());
   fake_clock_.AdvanceTimeMilliseconds(
       RtpPacketHistory::kPacketCullingDelayFactor *
@@ -513,7 +514,7 @@
   packet->SetPayloadSize(100);
   hist_.PutRtpPacket(std::move(packet), kAllowRetransmission,
                      fake_clock_.TimeInMilliseconds());
-  ASSERT_FALSE(hist_.GetPacketState(kStartSeqNum, false));
+  ASSERT_FALSE(hist_.GetPacketState(kStartSeqNum));
 
   auto best_packet = hist_.GetBestFittingPacket(target_packet_size + 2);
   ASSERT_THAT(best_packet, ::testing::NotNull());
@@ -573,7 +574,7 @@
   hist_.PutRtpPacket(std::move(packet), kDontRetransmit,
                      fake_clock_.TimeInMilliseconds());
   EXPECT_THAT(hist_.GetBestFittingPacket(50), ::testing::IsNull());
-  EXPECT_THAT(hist_.GetPacketAndSetSendTime(kStartSeqNum, false),
+  EXPECT_THAT(hist_.GetPacketAndSetSendTime(kStartSeqNum),
               ::testing::NotNull());
 }
 
diff --git a/modules/rtp_rtcp/source/rtp_packet_received.cc b/modules/rtp_rtcp/source/rtp_packet_received.cc
index c8deb99..93c0a1e 100644
--- a/modules/rtp_rtcp/source/rtp_packet_received.cc
+++ b/modules/rtp_rtcp/source/rtp_packet_received.cc
@@ -10,6 +10,8 @@
 
 #include "modules/rtp_rtcp/source/rtp_packet_received.h"
 
+#include <stddef.h>
+#include <cstdint>
 #include <vector>
 
 #include "modules/rtp_rtcp/source/rtp_header_extensions.h"
diff --git a/modules/rtp_rtcp/source/rtp_packet_received.h b/modules/rtp_rtcp/source/rtp_packet_received.h
index 8690031..566b116 100644
--- a/modules/rtp_rtcp/source/rtp_packet_received.h
+++ b/modules/rtp_rtcp/source/rtp_packet_received.h
@@ -10,9 +10,11 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_RTP_PACKET_RECEIVED_H_
 #define MODULES_RTP_RTCP_SOURCE_RTP_PACKET_RECEIVED_H_
 
+#include <stdint.h>
 #include <vector>
 
-#include "common_types.h"  // NOLINT(build/include)
+#include "api/array_view.h"
+#include "api/rtp_headers.h"
 #include "modules/rtp_rtcp/source/rtp_packet.h"
 #include "system_wrappers/include/ntp_time.h"
 
diff --git a/modules/rtp_rtcp/source/rtp_packet_to_send.cc b/modules/rtp_rtcp/source/rtp_packet_to_send.cc
index 0153bbe..b55e74a 100644
--- a/modules/rtp_rtcp/source/rtp_packet_to_send.cc
+++ b/modules/rtp_rtcp/source/rtp_packet_to_send.cc
@@ -10,6 +10,8 @@
 
 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
 
+#include <cstdint>
+
 namespace webrtc {
 
 RtpPacketToSend::RtpPacketToSend(const ExtensionManager* extensions)
diff --git a/modules/rtp_rtcp/source/rtp_packet_to_send.h b/modules/rtp_rtcp/source/rtp_packet_to_send.h
index 1ed7dda..56b1024 100644
--- a/modules/rtp_rtcp/source/rtp_packet_to_send.h
+++ b/modules/rtp_rtcp/source/rtp_packet_to_send.h
@@ -10,9 +10,12 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_RTP_PACKET_TO_SEND_H_
 #define MODULES_RTP_RTCP_SOURCE_RTP_PACKET_TO_SEND_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <vector>
 
 #include "api/array_view.h"
+#include "api/video/video_timing.h"
 #include "modules/rtp_rtcp/source/rtp_header_extensions.h"
 #include "modules/rtp_rtcp/source/rtp_packet.h"
 
diff --git a/modules/rtp_rtcp/source/rtp_packet_unittest.cc b/modules/rtp_rtcp/source/rtp_packet_unittest.cc
index 648ddc3..b485df6 100644
--- a/modules/rtp_rtcp/source/rtp_packet_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_packet_unittest.cc
@@ -226,8 +226,7 @@
 }
 
 TEST(RtpPacketTest, CreateWithTwoByteHeaderExtensionFirst) {
-  RtpPacketToSend::ExtensionManager extensions;
-  extensions.SetMixedOneTwoByteHeaderSupported(true);
+  RtpPacketToSend::ExtensionManager extensions(true);
   extensions.Register(kRtpExtensionTransmissionTimeOffset,
                       kTransmissionOffsetExtensionId);
   extensions.Register(kRtpExtensionAudioLevel, kAudioLevelExtensionId);
@@ -248,8 +247,7 @@
 
 TEST(RtpPacketTest, CreateWithTwoByteHeaderExtensionLast) {
   // This test will trigger RtpPacket::PromoteToTwoByteHeaderExtension().
-  RtpPacketToSend::ExtensionManager extensions;
-  extensions.SetMixedOneTwoByteHeaderSupported(true);
+  RtpPacketToSend::ExtensionManager extensions(true);
   extensions.Register(kRtpExtensionTransmissionTimeOffset,
                       kTransmissionOffsetExtensionId);
   extensions.Register(kRtpExtensionAudioLevel, kAudioLevelExtensionId);
@@ -468,6 +466,23 @@
   EXPECT_EQ(0u, packet.padding_size());
 }
 
+TEST(RtpPacketTest, GetExtensionWithoutParametersReturnsOptionalValue) {
+  RtpPacket::ExtensionManager extensions;
+  extensions.Register<TransmissionOffset>(kTransmissionOffsetExtensionId);
+  extensions.Register<RtpStreamId>(kRtpStreamIdExtensionId);
+
+  RtpPacketReceived packet(&extensions);
+  EXPECT_TRUE(packet.Parse(kPacketWithTO, sizeof(kPacketWithTO)));
+
+  auto time_offset = packet.GetExtension<TransmissionOffset>();
+  static_assert(
+      std::is_same<decltype(time_offset),
+                   absl::optional<TransmissionOffset::value_type>>::value,
+      "");
+  EXPECT_EQ(time_offset, kTimeOffset);
+  EXPECT_FALSE(packet.GetExtension<RtpStreamId>().has_value());
+}
+
 TEST(RtpPacketTest, GetRawExtensionWhenPresent) {
   constexpr uint8_t kRawPacket[] = {
       // comment for clang-format to align kRawPacket nicer.
diff --git a/modules/rtp_rtcp/source/rtp_rtcp_impl.cc b/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
index 392b91d..5726284 100644
--- a/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
+++ b/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
@@ -11,12 +11,14 @@
 #include "modules/rtp_rtcp/source/rtp_rtcp_impl.h"
 
 #include <string.h>
-
 #include <algorithm>
+#include <cstdint>
 #include <set>
 #include <string>
+#include <utility>
 
-#include "api/rtpparameters.h"
+#include "modules/rtp_rtcp/source/rtcp_packet/dlrr.h"
+#include "modules/rtp_rtcp/source/rtp_rtcp_config.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 
@@ -99,7 +101,9 @@
         configuration.send_packet_observer,
         configuration.retransmission_rate_limiter,
         configuration.overhead_observer,
-        configuration.populate_network2_timestamp));
+        configuration.populate_network2_timestamp,
+        configuration.frame_encryptor, configuration.require_frame_encryption,
+        configuration.extmap_allow_mixed));
     // Make sure rtcp sender use same timestamp offset as rtp sender.
     rtcp_sender_.SetTimestampOffset(rtp_sender_->TimestampOffset());
 
@@ -253,6 +257,7 @@
 }
 
 int32_t ModuleRtpRtcpImpl::RegisterSendPayload(const CodecInst& voice_codec) {
+  rtcp_sender_.SetRtpClockRate(voice_codec.pltype, voice_codec.plfreq);
   return rtp_sender_->RegisterPayload(
       voice_codec.plname, voice_codec.pltype, voice_codec.plfreq,
       voice_codec.channels, (voice_codec.rate < 0) ? 0 : voice_codec.rate);
@@ -260,8 +265,10 @@
 
 void ModuleRtpRtcpImpl::RegisterVideoSendPayload(int payload_type,
                                                  const char* payload_name) {
-  RTC_CHECK_EQ(
-      0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000, 0, 0));
+  rtcp_sender_.SetRtpClockRate(payload_type, kVideoPayloadTypeFrequency);
+  RTC_CHECK_EQ(0,
+               rtp_sender_->RegisterPayload(payload_name, payload_type,
+                                            kVideoPayloadTypeFrequency, 0, 0));
 }
 
 int32_t ModuleRtpRtcpImpl::DeRegisterSendPayload(const int8_t payload_type) {
@@ -407,7 +414,7 @@
     const RTPFragmentationHeader* fragmentation,
     const RTPVideoHeader* rtp_video_header,
     uint32_t* transport_frame_id_out) {
-  rtcp_sender_.SetLastRtpTime(time_stamp, capture_time_ms);
+  rtcp_sender_.SetLastRtpTime(time_stamp, capture_time_ms, payload_type);
   // Make sure an RTCP report isn't queued behind a key frame.
   if (rtcp_sender_.TimeToSendRTCPReport(kVideoFrameKey == frame_type)) {
     rtcp_sender_.SendRTCP(GetFeedbackState(), kRtcpReport);
@@ -609,6 +616,10 @@
   rtcp_sender_.UnsetRemb();
 }
 
+void ModuleRtpRtcpImpl::SetExtmapAllowMixed(bool extmap_allow_mixed) {
+  rtp_sender_->SetExtmapAllowMixed(extmap_allow_mixed);
+}
+
 int32_t ModuleRtpRtcpImpl::RegisterSendRtpHeaderExtension(
     const RTPExtensionType type,
     const uint8_t id) {
diff --git a/modules/rtp_rtcp/source/rtp_rtcp_impl.h b/modules/rtp_rtcp/source/rtp_rtcp_impl.h
index 9c2b085..37516de 100644
--- a/modules/rtp_rtcp/source/rtp_rtcp_impl.h
+++ b/modules/rtp_rtcp/source/rtp_rtcp_impl.h
@@ -11,17 +11,24 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_RTP_RTCP_IMPL_H_
 #define MODULES_RTP_RTCP_SOURCE_RTP_RTCP_IMPL_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <memory>
 #include <set>
 #include <string>
-#include <utility>
 #include <vector>
 
 #include "absl/types/optional.h"
+#include "api/rtp_headers.h"
 #include "api/video/video_bitrate_allocation.h"
+#include "common_types.h"  // NOLINT(build/include)
+#include "modules/include/module_common_types.h"
+#include "modules/include/module_fec_types.h"
+#include "modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp.h"
-#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
+#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"  // RTCPPacketType
 #include "modules/rtp_rtcp/source/packet_loss_stats.h"
+#include "modules/rtp_rtcp/source/rtcp_packet/tmmb_item.h"
 #include "modules/rtp_rtcp/source/rtcp_receiver.h"
 #include "modules/rtp_rtcp/source/rtcp_sender.h"
 #include "modules/rtp_rtcp/source/rtp_sender.h"
@@ -30,6 +37,10 @@
 
 namespace webrtc {
 
+class Clock;
+struct PacedPacketInfo;
+struct RTPVideoHeader;
+
 class ModuleRtpRtcpImpl : public RtpRtcp, public RTCPReceiver::ModuleRtpRtcp {
  public:
   explicit ModuleRtpRtcpImpl(const RtpRtcp::Configuration& configuration);
@@ -59,6 +70,8 @@
 
   int32_t DeRegisterSendPayload(int8_t payload_type) override;
 
+  void SetExtmapAllowMixed(bool extmap_allow_mixed) override;
+
   // Register RTP header extension.
   int32_t RegisterSendRtpHeaderExtension(RTPExtensionType type,
                                          uint8_t id) override;
diff --git a/modules/rtp_rtcp/source/rtp_sender.cc b/modules/rtp_rtcp/source/rtp_sender.cc
index 1678a03..38d6030 100644
--- a/modules/rtp_rtcp/source/rtp_sender.cc
+++ b/modules/rtp_rtcp/source/rtp_sender.cc
@@ -16,6 +16,7 @@
 #include <utility>
 
 #include "absl/memory/memory.h"
+#include "absl/strings/match.h"
 #include "logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h"
 #include "logging/rtc_event_log/rtc_event_log.h"
 #include "modules/remote_bitrate_estimator/test/bwe_test_logging.h"
@@ -119,14 +120,22 @@
     SendPacketObserver* send_packet_observer,
     RateLimiter* retransmission_rate_limiter,
     OverheadObserver* overhead_observer,
-    bool populate_network2_timestamp)
+    bool populate_network2_timestamp,
+    FrameEncryptorInterface* frame_encryptor,
+    bool require_frame_encryption,
+    bool extmap_allow_mixed)
     : clock_(clock),
       // TODO(holmer): Remove this conversion?
       clock_delta_ms_(clock_->TimeInMilliseconds() - rtc::TimeMillis()),
       random_(clock_->TimeInMicroseconds()),
       audio_configured_(audio),
       audio_(audio ? new RTPSenderAudio(clock, this) : nullptr),
-      video_(audio ? nullptr : new RTPSenderVideo(clock, this, flexfec_sender)),
+      video_(audio ? nullptr
+                   : new RTPSenderVideo(clock,
+                                        this,
+                                        flexfec_sender,
+                                        frame_encryptor,
+                                        require_frame_encryption)),
       paced_sender_(paced_sender),
       transport_sequence_number_allocator_(sequence_number_allocator),
       transport_feedback_observer_(transport_feedback_observer),
@@ -137,7 +146,7 @@
       max_packet_size_(IP_PACKET_SIZE - 28),  // Default is IP-v4/UDP.
       last_payload_type_(-1),
       payload_type_map_(),
-      rtp_header_extension_map_(),
+      rtp_header_extension_map_(extmap_allow_mixed),
       packet_history_(clock),
       flexfec_packet_history_(clock),
       // Statistics
@@ -238,6 +247,11 @@
   return nack_bitrate_sent_.Rate(clock_->TimeInMilliseconds()).value_or(0);
 }
 
+void RTPSender::SetExtmapAllowMixed(bool extmap_allow_mixed) {
+  rtc::CritScope lock(&send_critsect_);
+  rtp_header_extension_map_.SetExtmapAllowMixed(extmap_allow_mixed);
+}
+
 int32_t RTPSender::RegisterRtpHeaderExtension(RTPExtensionType type,
                                               uint8_t id) {
   rtc::CritScope lock(&send_critsect_);
@@ -259,13 +273,12 @@
   return rtp_header_extension_map_.Deregister(type);
 }
 
-int32_t RTPSender::RegisterPayload(
-    const char payload_name[RTP_PAYLOAD_NAME_SIZE],
-    int8_t payload_number,
-    uint32_t frequency,
-    size_t channels,
-    uint32_t rate) {
-  RTC_DCHECK_LT(strlen(payload_name), RTP_PAYLOAD_NAME_SIZE);
+int32_t RTPSender::RegisterPayload(absl::string_view payload_name,
+                                   int8_t payload_number,
+                                   uint32_t frequency,
+                                   size_t channels,
+                                   uint32_t rate) {
+  RTC_DCHECK_LT(payload_name.size(), RTP_PAYLOAD_NAME_SIZE);
   rtc::CritScope lock(&send_critsect_);
 
   std::map<int8_t, RtpUtility::Payload*>::iterator it =
@@ -277,8 +290,7 @@
     RTC_DCHECK(payload);
 
     // Check if it's the same as we already have.
-    if (RtpUtility::StringCompare(payload->name, payload_name,
-                                  RTP_PAYLOAD_NAME_SIZE - 1)) {
+    if (absl::EqualsIgnoreCase(payload->name, payload_name)) {
       if (audio_configured_ && payload->typeSpecific.is_audio()) {
         auto& p = payload->typeSpecific.audio_payload();
         if (rtc::SafeEq(p.format.clockrate_hz, frequency) &&
@@ -654,7 +666,7 @@
   // Try to find packet in RTP packet history. Also verify RTT here, so that we
   // don't retransmit too often.
   absl::optional<RtpPacketHistory::PacketState> stored_packet =
-      packet_history_.GetPacketState(packet_id, true);
+      packet_history_.GetPacketState(packet_id);
   if (!stored_packet) {
     // Packet not found.
     return 0;
@@ -685,7 +697,7 @@
   }
 
   std::unique_ptr<RtpPacketToSend> packet =
-      packet_history_.GetPacketAndSetSendTime(packet_id, true);
+      packet_history_.GetPacketAndSetSendTime(packet_id);
   if (!packet) {
     // Packet could theoretically time out between the first check and this one.
     return 0;
@@ -763,17 +775,14 @@
     return true;
 
   std::unique_ptr<RtpPacketToSend> packet;
-  // No need to verify RTT here, it has already been checked before putting the
-  // packet into the pacer. But _do_ update the send time.
   if (ssrc == SSRC()) {
-    packet = packet_history_.GetPacketAndSetSendTime(sequence_number, false);
+    packet = packet_history_.GetPacketAndSetSendTime(sequence_number);
   } else if (ssrc == FlexfecSsrc()) {
-    packet =
-        flexfec_packet_history_.GetPacketAndSetSendTime(sequence_number, false);
+    packet = flexfec_packet_history_.GetPacketAndSetSendTime(sequence_number);
   }
 
   if (!packet) {
-    // Packet cannot be found.
+    // Packet cannot be found or was resend too recently.
     return true;
   }
 
@@ -1149,8 +1158,15 @@
 
 std::unique_ptr<RtpPacketToSend> RTPSender::AllocatePacket() const {
   rtc::CritScope lock(&send_critsect_);
-  std::unique_ptr<RtpPacketToSend> packet(
-      new RtpPacketToSend(&rtp_header_extension_map_, max_packet_size_));
+  // TODO(danilchap): Find better motivator and value for extra capacity.
+  // RtpPacketizer might slightly miscalulate needed size,
+  // SRTP may benefit from extra space in the buffer and do encryption in place
+  // saving reallocation.
+  // While sending slightly oversized packet increase chance of dropped packet,
+  // it is better than crash on drop packet without trying to send it.
+  static constexpr int kExtraCapacity = 16;
+  auto packet = absl::make_unique<RtpPacketToSend>(
+      &rtp_header_extension_map_, max_packet_size_ + kExtraCapacity);
   RTC_DCHECK(ssrc_);
   packet->SetSsrc(*ssrc_);
   packet->SetCsrcs(csrcs_);
diff --git a/modules/rtp_rtcp/source/rtp_sender.h b/modules/rtp_rtcp/source/rtp_sender.h
index e9095d1..f9bbbdd 100644
--- a/modules/rtp_rtcp/source/rtp_sender.h
+++ b/modules/rtp_rtcp/source/rtp_sender.h
@@ -17,6 +17,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 #include "api/array_view.h"
 #include "api/call/transport.h"
@@ -37,6 +38,7 @@
 
 namespace webrtc {
 
+class FrameEncryptorInterface;
 class OverheadObserver;
 class RateLimiter;
 class RtcEventLog;
@@ -62,7 +64,10 @@
             SendPacketObserver* send_packet_observer,
             RateLimiter* nack_rate_limiter,
             OverheadObserver* overhead_observer,
-            bool populate_network2_timestamp);
+            bool populate_network2_timestamp,
+            FrameEncryptorInterface* frame_encryptor,
+            bool require_frame_encryption,
+            bool extmap_allow_mixed);
 
   ~RTPSender();
 
@@ -74,7 +79,7 @@
   uint32_t FecOverheadRate() const;
   uint32_t NackOverheadRate() const;
 
-  int32_t RegisterPayload(const char* payload_name,
+  int32_t RegisterPayload(absl::string_view payload_name,
                           const int8_t payload_type,
                           const uint32_t frequency,
                           const size_t channels,
@@ -115,6 +120,8 @@
                         uint32_t* transport_frame_id_out,
                         int64_t expected_retransmission_time_ms);
 
+  void SetExtmapAllowMixed(bool extmap_allow_mixed);
+
   // RTP header extension
   int32_t RegisterRtpHeaderExtension(RTPExtensionType type, uint8_t id);
   bool RegisterRtpHeaderExtension(const std::string& uri, int id);
diff --git a/modules/rtp_rtcp/source/rtp_sender_audio.cc b/modules/rtp_rtcp/source/rtp_sender_audio.cc
index bf86a39..636cccc 100644
--- a/modules/rtp_rtcp/source/rtp_sender_audio.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_audio.cc
@@ -11,16 +11,18 @@
 #include "modules/rtp_rtcp/source/rtp_sender_audio.h"
 
 #include <string.h>
-
 #include <memory>
 #include <utility>
 
+#include "absl/strings/match.h"
+#include "api/audio_codecs/audio_format.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/rtp_rtcp/source/byte_io.h"
 #include "modules/rtp_rtcp/source/rtp_header_extensions.h"
+#include "modules/rtp_rtcp/source/rtp_packet.h"
 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
-#include "rtc_base/timeutils.h"
 #include "rtc_base/trace_event.h"
 
 namespace webrtc {
@@ -30,14 +32,13 @@
 
 RTPSenderAudio::~RTPSenderAudio() {}
 
-int32_t RTPSenderAudio::RegisterAudioPayload(
-    const char payloadName[RTP_PAYLOAD_NAME_SIZE],
-    const int8_t payload_type,
-    const uint32_t frequency,
-    const size_t channels,
-    const uint32_t rate,
-    RtpUtility::Payload** payload) {
-  if (RtpUtility::StringCompare(payloadName, "cn", 2)) {
+int32_t RTPSenderAudio::RegisterAudioPayload(absl::string_view payload_name,
+                                             const int8_t payload_type,
+                                             const uint32_t frequency,
+                                             const size_t channels,
+                                             const uint32_t rate,
+                                             RtpUtility::Payload** payload) {
+  if (absl::EqualsIgnoreCase(payload_name, "cn")) {
     rtc::CritScope cs(&send_audio_critsect_);
     //  we can have multiple CNG payload types
     switch (frequency) {
@@ -56,7 +57,7 @@
       default:
         return -1;
     }
-  } else if (RtpUtility::StringCompare(payloadName, "telephone-event", 15)) {
+  } else if (absl::EqualsIgnoreCase(payload_name, "telephone-event")) {
     rtc::CritScope cs(&send_audio_critsect_);
     // Don't add it to the list
     // we dont want to allow send with a DTMF payloadtype
@@ -65,9 +66,9 @@
     return 0;
   }
   *payload = new RtpUtility::Payload(
-      payloadName,
+      payload_name,
       PayloadUnion(AudioPayload{
-          SdpAudioFormat(payloadName, frequency, channels), rate}));
+          SdpAudioFormat(payload_name, frequency, channels), rate}));
   return 0;
 }
 
diff --git a/modules/rtp_rtcp/source/rtp_sender_audio.h b/modules/rtp_rtcp/source/rtp_sender_audio.h
index 63dfc2b..1dbe5b5 100644
--- a/modules/rtp_rtcp/source/rtp_sender_audio.h
+++ b/modules/rtp_rtcp/source/rtp_sender_audio.h
@@ -11,14 +11,19 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_RTP_SENDER_AUDIO_H_
 #define MODULES_RTP_RTCP_SOURCE_RTP_SENDER_AUDIO_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
+#include "absl/strings/string_view.h"
 #include "common_types.h"  // NOLINT(build/include)
 #include "modules/rtp_rtcp/source/dtmf_queue.h"
-#include "modules/rtp_rtcp/source/rtp_rtcp_config.h"
 #include "modules/rtp_rtcp/source/rtp_sender.h"
 #include "modules/rtp_rtcp/source/rtp_utility.h"
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/criticalsection.h"
 #include "rtc_base/onetimeevent.h"
+#include "rtc_base/thread_annotations.h"
+#include "system_wrappers/include/clock.h"
 
 namespace webrtc {
 
@@ -27,7 +32,7 @@
   RTPSenderAudio(Clock* clock, RTPSender* rtp_sender);
   ~RTPSenderAudio();
 
-  int32_t RegisterAudioPayload(const char payloadName[RTP_PAYLOAD_NAME_SIZE],
+  int32_t RegisterAudioPayload(absl::string_view payload_name,
                                int8_t payload_type,
                                uint32_t frequency,
                                size_t channels,
diff --git a/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/modules/rtp_rtcp/source/rtp_sender_unittest.cc
index 1b7e992..f30b383 100644
--- a/modules/rtp_rtcp/source/rtp_sender_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_unittest.cc
@@ -184,7 +184,8 @@
         false, &fake_clock_, &transport_, pacer ? &mock_paced_sender_ : nullptr,
         nullptr, &seq_num_allocator_, nullptr, nullptr, nullptr, nullptr,
         &mock_rtc_event_log_, &send_packet_observer_,
-        &retransmission_rate_limiter_, nullptr, populate_network2));
+        &retransmission_rate_limiter_, nullptr, populate_network2, nullptr,
+        false, false));
     rtp_sender_->SetSequenceNumber(kSeqNum);
     rtp_sender_->SetTimestampOffset(0);
     rtp_sender_->SetSSRC(kSsrc);
@@ -276,7 +277,7 @@
   TestRtpSenderVideo(Clock* clock,
                      RTPSender* rtp_sender,
                      FlexfecSender* flexfec_sender)
-      : RTPSenderVideo(clock, rtp_sender, flexfec_sender) {}
+      : RTPSenderVideo(clock, rtp_sender, flexfec_sender, nullptr, false) {}
   ~TestRtpSenderVideo() override {}
 
   StorageType GetStorageType(const RTPVideoHeader& header,
@@ -382,7 +383,8 @@
   rtp_sender_.reset(new RTPSender(
       kEnableAudio, &fake_clock_, &transport, &mock_paced_sender_, nullptr,
       nullptr, nullptr, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
-      nullptr, &retransmission_rate_limiter_, nullptr, false));
+      nullptr, &retransmission_rate_limiter_, nullptr, false, nullptr, false,
+      false));
   rtp_sender_->SetTimestampOffset(0);
   rtp_sender_->SetSSRC(kSsrc);
 
@@ -428,7 +430,8 @@
   rtp_sender_.reset(new RTPSender(
       false, &fake_clock_, &transport_, nullptr, nullptr, &seq_num_allocator_,
       &feedback_observer_, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
-      nullptr, &retransmission_rate_limiter_, &mock_overhead_observer, false));
+      nullptr, &retransmission_rate_limiter_, &mock_overhead_observer, false,
+      nullptr, false, false));
   rtp_sender_->SetSSRC(kSsrc);
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
@@ -455,7 +458,8 @@
   rtp_sender_.reset(new RTPSender(
       false, &fake_clock_, &transport_, nullptr, nullptr, &seq_num_allocator_,
       &feedback_observer_, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
-      &send_packet_observer_, &retransmission_rate_limiter_, nullptr, false));
+      &send_packet_observer_, &retransmission_rate_limiter_, nullptr, false,
+      nullptr, false, false));
   rtp_sender_->SetSSRC(kSsrc);
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
@@ -486,7 +490,8 @@
   rtp_sender_.reset(new RTPSender(
       false, &fake_clock_, &transport_, nullptr, nullptr, &seq_num_allocator_,
       &feedback_observer_, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
-      &send_packet_observer_, &retransmission_rate_limiter_, nullptr, false));
+      &send_packet_observer_, &retransmission_rate_limiter_, nullptr, false,
+      nullptr, false, false));
   rtp_sender_->SetSSRC(kSsrc);
 
   SendGenericPayload();
@@ -537,10 +542,10 @@
 
 TEST_P(RtpSenderTestWithoutPacer, OnSendSideDelayUpdated) {
   testing::StrictMock<MockSendSideDelayObserver> send_side_delay_observer_;
-  rtp_sender_.reset(
-      new RTPSender(false, &fake_clock_, &transport_, nullptr, nullptr, nullptr,
-                    nullptr, nullptr, nullptr, &send_side_delay_observer_,
-                    &mock_rtc_event_log_, nullptr, nullptr, nullptr, false));
+  rtp_sender_.reset(new RTPSender(
+      false, &fake_clock_, &transport_, nullptr, nullptr, nullptr, nullptr,
+      nullptr, nullptr, &send_side_delay_observer_, &mock_rtc_event_log_,
+      nullptr, nullptr, nullptr, false, nullptr, false, false));
   rtp_sender_->SetSSRC(kSsrc);
 
   const uint8_t kPayloadType = 127;
@@ -618,7 +623,7 @@
       false, &fake_clock_, &transport_, &mock_paced_sender_, nullptr,
       &seq_num_allocator_, &feedback_observer_, nullptr, nullptr, nullptr,
       &mock_rtc_event_log_, &send_packet_observer_,
-      &retransmission_rate_limiter_, nullptr, false));
+      &retransmission_rate_limiter_, nullptr, false, nullptr, false, false));
   rtp_sender_->SetSequenceNumber(kSeqNum);
   rtp_sender_->SetSSRC(kSsrc);
   rtp_sender_->SetStorePacketsStatus(true, 10);
@@ -978,7 +983,7 @@
       false, &fake_clock_, &transport_, &mock_paced_sender_, nullptr,
       nullptr /* TransportSequenceNumberAllocator */, nullptr, nullptr, nullptr,
       nullptr, nullptr, &send_packet_observer_, &retransmission_rate_limiter_,
-      nullptr, false));
+      nullptr, false, nullptr, false, false));
   rtp_sender_->SetSequenceNumber(kSeqNum);
   rtp_sender_->SetSSRC(kSsrc);
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
@@ -1004,7 +1009,7 @@
   rtp_sender_.reset(new RTPSender(
       false, &fake_clock_, &transport, &mock_paced_sender_, nullptr, nullptr,
       nullptr, nullptr, nullptr, nullptr, &mock_rtc_event_log_, nullptr,
-      &retransmission_rate_limiter_, nullptr, false));
+      &retransmission_rate_limiter_, nullptr, false, nullptr, false, false));
   rtp_sender_->SetSequenceNumber(kSeqNum);
   rtp_sender_->SetSSRC(kSsrc);
   rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload);
@@ -1128,7 +1133,7 @@
       false, &fake_clock_, &transport_, &mock_paced_sender_, &flexfec_sender,
       &seq_num_allocator_, nullptr, nullptr, nullptr, nullptr,
       &mock_rtc_event_log_, &send_packet_observer_,
-      &retransmission_rate_limiter_, nullptr, false));
+      &retransmission_rate_limiter_, nullptr, false, nullptr, false, false));
   rtp_sender_->SetSSRC(kMediaSsrc);
   rtp_sender_->SetSequenceNumber(kSeqNum);
   rtp_sender_->SetStorePacketsStatus(true, 10);
@@ -1188,7 +1193,7 @@
       false, &fake_clock_, &transport_, &mock_paced_sender_, &flexfec_sender,
       &seq_num_allocator_, nullptr, nullptr, nullptr, nullptr,
       &mock_rtc_event_log_, &send_packet_observer_,
-      &retransmission_rate_limiter_, nullptr, false));
+      &retransmission_rate_limiter_, nullptr, false, nullptr, false, false));
   rtp_sender_->SetSSRC(kMediaSsrc);
   rtp_sender_->SetSequenceNumber(kSeqNum);
   rtp_sender_->SetStorePacketsStatus(true, 10);
@@ -1283,11 +1288,11 @@
                                nullptr /* rtp_state */, &fake_clock_);
 
   // Reset |rtp_sender_| to use FlexFEC.
-  rtp_sender_.reset(
-      new RTPSender(false, &fake_clock_, &transport_, nullptr, &flexfec_sender,
-                    &seq_num_allocator_, nullptr, nullptr, nullptr, nullptr,
-                    &mock_rtc_event_log_, &send_packet_observer_,
-                    &retransmission_rate_limiter_, nullptr, false));
+  rtp_sender_.reset(new RTPSender(
+      false, &fake_clock_, &transport_, nullptr, &flexfec_sender,
+      &seq_num_allocator_, nullptr, nullptr, nullptr, nullptr,
+      &mock_rtc_event_log_, &send_packet_observer_,
+      &retransmission_rate_limiter_, nullptr, false, nullptr, false, false));
   rtp_sender_->SetSSRC(kMediaSsrc);
   rtp_sender_->SetSequenceNumber(kSeqNum);
 
@@ -1351,7 +1356,7 @@
       false, &fake_clock_, &transport_, &mock_paced_sender_, &flexfec_sender,
       &seq_num_allocator_, nullptr, nullptr, nullptr, nullptr,
       &mock_rtc_event_log_, &send_packet_observer_,
-      &retransmission_rate_limiter_, nullptr, false));
+      &retransmission_rate_limiter_, nullptr, false, nullptr, false, false));
   rtp_sender_->SetSSRC(kMediaSsrc);
   rtp_sender_->SetSequenceNumber(kSeqNum);
 
@@ -1403,7 +1408,7 @@
   rtp_sender_.reset(new RTPSender(
       false, &fake_clock_, &transport_, &mock_paced_sender_, nullptr, nullptr,
       nullptr, nullptr, &callback, nullptr, nullptr, nullptr,
-      &retransmission_rate_limiter_, nullptr, false));
+      &retransmission_rate_limiter_, nullptr, false, nullptr, false, false));
   rtp_sender_->SetSSRC(kSsrc);
   char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC";
   const uint8_t payload_type = 127;
@@ -1463,10 +1468,10 @@
     uint32_t total_bitrate_;
     uint32_t retransmit_bitrate_;
   } callback;
-  rtp_sender_.reset(
-      new RTPSender(false, &fake_clock_, &transport_, nullptr, nullptr, nullptr,
-                    nullptr, &callback, nullptr, nullptr, nullptr, nullptr,
-                    &retransmission_rate_limiter_, nullptr, false));
+  rtp_sender_.reset(new RTPSender(
+      false, &fake_clock_, &transport_, nullptr, nullptr, nullptr, nullptr,
+      &callback, nullptr, nullptr, nullptr, nullptr,
+      &retransmission_rate_limiter_, nullptr, false, nullptr, false, false));
   rtp_sender_->SetSSRC(kSsrc);
 
   // Simulate kNumPackets sent with kPacketInterval ms intervals, with the
@@ -1523,10 +1528,10 @@
 
   void SetUp() override {
     payload_ = kAudioPayload;
-    rtp_sender_.reset(
-        new RTPSender(true, &fake_clock_, &transport_, nullptr, nullptr,
-                      nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
-                      nullptr, &retransmission_rate_limiter_, nullptr, false));
+    rtp_sender_.reset(new RTPSender(
+        true, &fake_clock_, &transport_, nullptr, nullptr, nullptr, nullptr,
+        nullptr, nullptr, nullptr, nullptr, nullptr,
+        &retransmission_rate_limiter_, nullptr, false, nullptr, false, false));
     rtp_sender_->SetSSRC(kSsrc);
     rtp_sender_->SetSequenceNumber(kSeqNum);
   }
@@ -2189,10 +2194,11 @@
 
 TEST_P(RtpSenderTest, OnOverheadChanged) {
   MockOverheadObserver mock_overhead_observer;
-  rtp_sender_.reset(new RTPSender(
-      false, &fake_clock_, &transport_, nullptr, nullptr, nullptr, nullptr,
-      nullptr, nullptr, nullptr, nullptr, nullptr,
-      &retransmission_rate_limiter_, &mock_overhead_observer, false));
+  rtp_sender_.reset(
+      new RTPSender(false, &fake_clock_, &transport_, nullptr, nullptr, nullptr,
+                    nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
+                    &retransmission_rate_limiter_, &mock_overhead_observer,
+                    false, nullptr, false, false));
   rtp_sender_->SetSSRC(kSsrc);
 
   // RTP overhead is 12B.
@@ -2210,10 +2216,11 @@
 
 TEST_P(RtpSenderTest, DoesNotUpdateOverheadOnEqualSize) {
   MockOverheadObserver mock_overhead_observer;
-  rtp_sender_.reset(new RTPSender(
-      false, &fake_clock_, &transport_, nullptr, nullptr, nullptr, nullptr,
-      nullptr, nullptr, nullptr, nullptr, nullptr,
-      &retransmission_rate_limiter_, &mock_overhead_observer, false));
+  rtp_sender_.reset(
+      new RTPSender(false, &fake_clock_, &transport_, nullptr, nullptr, nullptr,
+                    nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
+                    &retransmission_rate_limiter_, &mock_overhead_observer,
+                    false, nullptr, false, false));
   rtp_sender_->SetSSRC(kSsrc);
 
   EXPECT_CALL(mock_overhead_observer, OnOverheadChanged(_)).Times(1);
@@ -2223,10 +2230,10 @@
 
 TEST_P(RtpSenderTest, SendsKeepAlive) {
   MockTransport transport;
-  rtp_sender_.reset(
-      new RTPSender(false, &fake_clock_, &transport, nullptr, nullptr, nullptr,
-                    nullptr, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
-                    nullptr, &retransmission_rate_limiter_, nullptr, false));
+  rtp_sender_.reset(new RTPSender(
+      false, &fake_clock_, &transport, nullptr, nullptr, nullptr, nullptr,
+      nullptr, nullptr, nullptr, &mock_rtc_event_log_, nullptr,
+      &retransmission_rate_limiter_, nullptr, false, nullptr, false, false));
   rtp_sender_->SetSequenceNumber(kSeqNum);
   rtp_sender_->SetTimestampOffset(0);
   rtp_sender_->SetSSRC(kSsrc);
diff --git a/modules/rtp_rtcp/source/rtp_sender_video.cc b/modules/rtp_rtcp/source/rtp_sender_video.cc
index e8f0ea5..cb0b665 100644
--- a/modules/rtp_rtcp/source/rtp_sender_video.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_video.cc
@@ -19,6 +19,8 @@
 #include <vector>
 
 #include "absl/memory/memory.h"
+#include "absl/strings/match.h"
+#include "api/crypto/frameencryptorinterface.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/rtp_rtcp/source/byte_io.h"
 #include "modules/rtp_rtcp/source/rtp_format_video_generic.h"
@@ -91,6 +93,11 @@
       generic_descriptor.SetSpatialLayersBitmask(spatial_bimask);
 
       generic_descriptor.SetTemporalLayer(video_header.generic->temporal_index);
+
+      if (frame_type == kVideoFrameKey) {
+        generic_descriptor.SetResolution(video_header.width,
+                                         video_header.height);
+      }
     }
     packet->SetExtension<RtpGenericFrameDescriptorExtension>(
         generic_descriptor);
@@ -115,7 +122,9 @@
 
 RTPSenderVideo::RTPSenderVideo(Clock* clock,
                                RTPSender* rtp_sender,
-                               FlexfecSender* flexfec_sender)
+                               FlexfecSender* flexfec_sender,
+                               FrameEncryptorInterface* frame_encryptor,
+                               bool require_frame_encryption)
     : rtp_sender_(rtp_sender),
       clock_(clock),
       video_type_(kVideoCodecGeneric),
@@ -128,7 +137,9 @@
       delta_fec_params_{0, 1, kFecMaskRandom},
       key_fec_params_{0, 1, kFecMaskRandom},
       fec_bitrate_(1000, RateStatistics::kBpsScale),
-      video_bitrate_(1000, RateStatistics::kBpsScale) {}
+      video_bitrate_(1000, RateStatistics::kBpsScale),
+      frame_encryptor_(frame_encryptor),
+      require_frame_encryption_(require_frame_encryption) {}
 
 RTPSenderVideo::~RTPSenderVideo() {}
 
@@ -142,18 +153,18 @@
 
 // Static.
 RtpUtility::Payload* RTPSenderVideo::CreateVideoPayload(
-    const char payload_name[RTP_PAYLOAD_NAME_SIZE],
+    absl::string_view payload_name,
     int8_t payload_type) {
   enum VideoCodecType video_type = kVideoCodecGeneric;
-  if (RtpUtility::StringCompare(payload_name, "VP8", 3)) {
+  if (absl::EqualsIgnoreCase(payload_name, "VP8")) {
     video_type = kVideoCodecVP8;
-  } else if (RtpUtility::StringCompare(payload_name, "VP9", 3)) {
+  } else if (absl::EqualsIgnoreCase(payload_name, "VP9")) {
     video_type = kVideoCodecVP9;
-  } else if (RtpUtility::StringCompare(payload_name, "H264", 4)) {
+  } else if (absl::EqualsIgnoreCase(payload_name, "H264")) {
     video_type = kVideoCodecH264;
-  } else if (RtpUtility::StringCompare(payload_name, "I420", 4)) {
+  } else if (absl::EqualsIgnoreCase(payload_name, "I420")) {
     video_type = kVideoCodecGeneric;
-  } else if (RtpUtility::StringCompare(payload_name, "stereo", 6)) {
+  } else if (absl::EqualsIgnoreCase(payload_name, "stereo")) {
     video_type = kVideoCodecGeneric;
   } else {
     video_type = kVideoCodecGeneric;
@@ -387,33 +398,37 @@
   int packet_capacity = rtp_sender_->MaxRtpPacketSize() - fec_packet_overhead -
                         (rtp_sender_->RtxStatus() ? kRtxHeaderSize : 0);
 
-  auto create_packet = [&] {
-    std::unique_ptr<RtpPacketToSend> rtp_packet = rtp_sender_->AllocatePacket();
-    RTC_DCHECK_LE(packet_capacity, rtp_packet->capacity());
+  std::unique_ptr<RtpPacketToSend> single_packet =
+      rtp_sender_->AllocatePacket();
+  RTC_DCHECK_LE(packet_capacity, single_packet->capacity());
+  single_packet->SetPayloadType(payload_type);
+  single_packet->SetTimestamp(rtp_timestamp);
+  single_packet->set_capture_time_ms(capture_time_ms);
 
-    rtp_packet->SetPayloadType(payload_type);
-    rtp_packet->SetTimestamp(rtp_timestamp);
-    rtp_packet->set_capture_time_ms(capture_time_ms);
-    return rtp_packet;
-  };
-
-  auto first_packet = create_packet();
-  auto middle_packet = absl::make_unique<RtpPacketToSend>(*first_packet);
-  auto last_packet = absl::make_unique<RtpPacketToSend>(*first_packet);
+  auto first_packet = absl::make_unique<RtpPacketToSend>(*single_packet);
+  auto middle_packet = absl::make_unique<RtpPacketToSend>(*single_packet);
+  auto last_packet = absl::make_unique<RtpPacketToSend>(*single_packet);
   // Simplest way to estimate how much extensions would occupy is to set them.
   AddRtpHeaderExtensions(*video_header, frame_type, set_video_rotation,
+                         /*first=*/true, /*last=*/true, single_packet.get());
+  AddRtpHeaderExtensions(*video_header, frame_type, set_video_rotation,
                          /*first=*/true, /*last=*/false, first_packet.get());
   AddRtpHeaderExtensions(*video_header, frame_type, set_video_rotation,
                          /*first=*/false, /*last=*/false, middle_packet.get());
   AddRtpHeaderExtensions(*video_header, frame_type, set_video_rotation,
                          /*first=*/false, /*last=*/true, last_packet.get());
 
+  RTC_DCHECK_GT(packet_capacity, single_packet->headers_size());
   RTC_DCHECK_GT(packet_capacity, first_packet->headers_size());
   RTC_DCHECK_GT(packet_capacity, middle_packet->headers_size());
   RTC_DCHECK_GT(packet_capacity, last_packet->headers_size());
   RtpPacketizer::PayloadSizeLimits limits;
   limits.max_payload_len = packet_capacity - middle_packet->headers_size();
 
+  RTC_DCHECK_GE(single_packet->headers_size(), middle_packet->headers_size());
+  limits.single_packet_reduction_len =
+      single_packet->headers_size() - middle_packet->headers_size();
+
   RTC_DCHECK_GE(first_packet->headers_size(), middle_packet->headers_size());
   limits.first_packet_reduction_len =
       first_packet->headers_size() - middle_packet->headers_size();
@@ -424,9 +439,42 @@
 
   RTPVideoHeader minimized_video_header;
   const RTPVideoHeader* packetize_video_header = video_header;
-  if (first_packet->HasExtension<RtpGenericFrameDescriptorExtension>() &&
-      MinimizeDescriptor(*video_header, &minimized_video_header)) {
-    packetize_video_header = &minimized_video_header;
+  rtc::ArrayView<const uint8_t> generic_descriptor_raw =
+      first_packet->GetRawExtension<RtpGenericFrameDescriptorExtension>();
+  if (!generic_descriptor_raw.empty()) {
+    if (MinimizeDescriptor(*video_header, &minimized_video_header)) {
+      packetize_video_header = &minimized_video_header;
+    }
+  }
+
+  // TODO(benwright@webrtc.org) - Allocate enough to always encrypt inline.
+  rtc::Buffer encrypted_video_payload;
+  if (frame_encryptor_ != nullptr) {
+    if (generic_descriptor_raw.empty()) {
+      return false;
+    }
+
+    const size_t max_ciphertext_size =
+        frame_encryptor_->GetMaxCiphertextByteSize(cricket::MEDIA_TYPE_VIDEO,
+                                                   payload_size);
+    encrypted_video_payload.SetSize(max_ciphertext_size);
+
+    size_t bytes_written = 0;
+    if (frame_encryptor_->Encrypt(
+            cricket::MEDIA_TYPE_VIDEO, first_packet->Ssrc(),
+            /*additional_data=*/nullptr,
+            rtc::MakeArrayView(payload_data, payload_size),
+            encrypted_video_payload, &bytes_written) != 0) {
+      return false;
+    }
+
+    encrypted_video_payload.SetSize(bytes_written);
+    payload_data = encrypted_video_payload.data();
+    payload_size = encrypted_video_payload.size();
+  } else if (require_frame_encryption_) {
+    RTC_LOG(LS_WARNING)
+        << "No FrameEncryptor is attached to this video sending stream but "
+        << "one is required since require_frame_encryptor is set";
   }
 
   std::unique_ptr<RtpPacketizer> packetizer = RtpPacketizer::Create(
@@ -447,16 +495,9 @@
     int expected_payload_capacity;
     // Choose right packet template:
     if (num_packets == 1) {
-      // No prepared template, create a new packet.
-      packet = create_packet();
-      AddRtpHeaderExtensions(*video_header, frame_type, set_video_rotation,
-                             /*first=*/true, /*last=*/true, packet.get());
-      // TODO(bugs.webrtc.org/7990): Revisit this case when two byte header
-      // extension are implemented because then single packet might need more
-      // space for extensions than sum of first and last packet reductions.
-      expected_payload_capacity = limits.max_payload_len -
-                                  limits.first_packet_reduction_len -
-                                  limits.last_packet_reduction_len;
+      packet = std::move(single_packet);
+      expected_payload_capacity =
+          limits.max_payload_len - limits.single_packet_reduction_len;
     } else if (i == 0) {
       packet = std::move(first_packet);
       expected_payload_capacity =
diff --git a/modules/rtp_rtcp/source/rtp_sender_video.h b/modules/rtp_rtcp/source/rtp_sender_video.h
index ce7be16..d3a898b 100644
--- a/modules/rtp_rtcp/source/rtp_sender_video.h
+++ b/modules/rtp_rtcp/source/rtp_sender_video.h
@@ -14,6 +14,7 @@
 #include <map>
 #include <memory>
 
+#include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 #include "common_types.h"  // NOLINT(build/include)
 #include "modules/rtp_rtcp/include/flexfec_sender.h"
@@ -29,6 +30,8 @@
 #include "rtc_base/thread_annotations.h"
 
 namespace webrtc {
+
+class FrameEncryptorInterface;
 class RtpPacketizer;
 class RtpPacketToSend;
 
@@ -38,14 +41,15 @@
 
   RTPSenderVideo(Clock* clock,
                  RTPSender* rtpSender,
-                 FlexfecSender* flexfec_sender);
+                 FlexfecSender* flexfec_sender,
+                 FrameEncryptorInterface* frame_encryptor,
+                 bool require_frame_encryption);
   virtual ~RTPSenderVideo();
 
   virtual enum VideoCodecType VideoCodecType() const;
 
-  static RtpUtility::Payload* CreateVideoPayload(
-      const char payload_name[RTP_PAYLOAD_NAME_SIZE],
-      int8_t payload_type);
+  static RtpUtility::Payload* CreateVideoPayload(absl::string_view payload_name,
+                                                 int8_t payload_type);
 
   bool SendVideo(enum VideoCodecType video_type,
                  FrameType frame_type,
@@ -158,6 +162,13 @@
       RTC_GUARDED_BY(stats_crit_);
 
   OneTimeEvent first_frame_sent_;
+
+  // E2EE Custom Video Frame Encryptor (optional)
+  FrameEncryptorInterface* const frame_encryptor_ = nullptr;
+  // If set to true will require all outgoing frames to pass through an
+  // initialized frame_encryptor_ before being sent out of the network.
+  // Otherwise these payloads will be dropped.
+  bool require_frame_encryption_;
 };
 
 }  // namespace webrtc
diff --git a/modules/rtp_rtcp/source/rtp_utility.cc b/modules/rtp_rtcp/source/rtp_utility.cc
index 228572f..53a006d 100644
--- a/modules/rtp_rtcp/source/rtp_utility.cc
+++ b/modules/rtp_rtcp/source/rtp_utility.cc
@@ -10,9 +10,19 @@
 
 #include "modules/rtp_rtcp/source/rtp_utility.h"
 
+#include <assert.h>
+#include <stddef.h>
+
+#include "api/array_view.h"
+#include "api/video/video_content_type.h"
+#include "api/video/video_frame_marking.h"
+#include "api/video/video_rotation.h"
+#include "api/video/video_timing.h"
 #include "modules/rtp_rtcp/include/rtp_cvo.h"
 #include "modules/rtp_rtcp/source/byte_io.h"
 #include "modules/rtp_rtcp/source/rtp_header_extensions.h"
+#include "modules/video_coding/codecs/interface/common_constants.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/stringutils.h"
 
@@ -33,10 +43,6 @@
  * Misc utility routines
  */
 
-bool StringCompare(const char* str1, const char* str2, const uint32_t length) {
-  return _strnicmp(str1, str2, length) == 0;
-}
-
 size_t Word32Align(size_t size) {
   uint32_t remainder = size % 4;
   if (remainder != 0)
diff --git a/modules/rtp_rtcp/source/rtp_utility.h b/modules/rtp_rtcp/source/rtp_utility.h
index 762f964..4085174 100644
--- a/modules/rtp_rtcp/source/rtp_utility.h
+++ b/modules/rtp_rtcp/source/rtp_utility.h
@@ -11,14 +11,14 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_RTP_UTILITY_H_
 #define MODULES_RTP_RTCP_SOURCE_RTP_UTILITY_H_
 
-#include <cstring>
-#include <map>
+#include <stdint.h>
+#include <algorithm>
 
-#include "modules/rtp_rtcp/include/receive_statistics.h"
+#include "absl/strings/string_view.h"
+#include "api/rtp_headers.h"
+#include "common_types.h"  // NOLINT(build/include)
 #include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
-#include "modules/rtp_rtcp/source/rtp_rtcp_config.h"
-#include "rtc_base/deprecation.h"
 
 namespace webrtc {
 
@@ -27,16 +27,15 @@
 namespace RtpUtility {
 
 struct Payload {
-  Payload(const char* name, const PayloadUnion& pu) : typeSpecific(pu) {
-    std::strncpy(this->name, name, sizeof(this->name) - 1);
-    this->name[sizeof(this->name) - 1] = '\0';
+  Payload(absl::string_view payload_name, const PayloadUnion& pu)
+      : typeSpecific(pu) {
+    size_t clipped_size = payload_name.copy(name, sizeof(name) - 1);
+    name[clipped_size] = '\0';
   }
   char name[RTP_PAYLOAD_NAME_SIZE];
   PayloadUnion typeSpecific;
 };
 
-bool StringCompare(const char* str1, const char* str2, const uint32_t length);
-
 // Round up to the nearest size that is a multiple of 4.
 size_t Word32Align(size_t size);
 
diff --git a/modules/rtp_rtcp/source/rtp_video_header.h b/modules/rtp_rtcp/source/rtp_video_header.h
index 288b7d0..4426c41 100644
--- a/modules/rtp_rtcp/source/rtp_video_header.h
+++ b/modules/rtp_rtcp/source/rtp_video_header.h
@@ -10,7 +10,10 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_RTP_VIDEO_HEADER_H_
 #define MODULES_RTP_RTCP_SOURCE_RTP_VIDEO_HEADER_H_
 
+#include <cstdint>
+
 #include "absl/container/inlined_vector.h"
+#include "absl/types/optional.h"
 #include "absl/types/variant.h"
 #include "api/video/video_content_type.h"
 #include "api/video/video_frame_marking.h"
diff --git a/modules/rtp_rtcp/source/time_util.cc b/modules/rtp_rtcp/source/time_util.cc
index 6ac280a..e65329d 100644
--- a/modules/rtp_rtcp/source/time_util.cc
+++ b/modules/rtp_rtcp/source/time_util.cc
@@ -12,6 +12,7 @@
 
 #include <algorithm>
 
+#include "rtc_base/checks.h"
 #include "rtc_base/timeutils.h"
 
 namespace webrtc {
@@ -22,20 +23,27 @@
   return (x + y / 2) / y;
 }
 
-int64_t NtpOffsetUs() {
+int64_t NtpOffsetMsCalledOnce() {
   constexpr int64_t kNtpJan1970Sec = 2208988800;
-  int64_t clock_time = rtc::TimeMicros();
-  int64_t utc_time = rtc::TimeUTCMicros();
-  return utc_time - clock_time + kNtpJan1970Sec * rtc::kNumMicrosecsPerSec;
+  int64_t clock_time = rtc::TimeMillis();
+  int64_t utc_time = rtc::TimeUTCMillis();
+  return utc_time - clock_time + kNtpJan1970Sec * rtc::kNumMillisecsPerSec;
 }
 
 }  // namespace
 
-NtpTime TimeMicrosToNtp(int64_t time_us) {
+int64_t NtpOffsetMs() {
   // Calculate the offset once.
-  static int64_t ntp_offset_us = NtpOffsetUs();
+  static int64_t ntp_offset_ms = NtpOffsetMsCalledOnce();
+  return ntp_offset_ms;
+}
 
-  int64_t time_ntp_us = time_us + ntp_offset_us;
+NtpTime TimeMicrosToNtp(int64_t time_us) {
+  // Since this doesn't return a wallclock time, but only NTP representation
+  // of rtc::TimeMillis() clock, the exact offset doesn't matter.
+  // To simplify conversions between NTP and RTP time, this offset is
+  // limited to milliseconds in resolution.
+  int64_t time_ntp_us = time_us + NtpOffsetMs() * 1000;
   RTC_DCHECK_GE(time_ntp_us, 0);  // Time before year 1900 is unsupported.
 
   // TODO(danilchap): Convert both seconds and fraction together using int128
diff --git a/modules/rtp_rtcp/source/time_util.h b/modules/rtp_rtcp/source/time_util.h
index 672722c..1e01c94 100644
--- a/modules/rtp_rtcp/source/time_util.h
+++ b/modules/rtp_rtcp/source/time_util.h
@@ -22,8 +22,15 @@
 // difference of the passed values.
 // As a result TimeMicrosToNtp(rtc::TimeMicros()) doesn't guarantee to match
 // system time.
+// However, TimeMicrosToNtp Guarantees that returned NtpTime will be offsetted
+// from rtc::TimeMicros() by integral number of milliseconds.
+// Use NtpOffsetMs() to get that offset value.
 NtpTime TimeMicrosToNtp(int64_t time_us);
 
+// Difference between Ntp time and local relative time returned by
+// rtc::TimeMicros()
+int64_t NtpOffsetMs();
+
 // Converts NTP timestamp to RTP timestamp.
 inline uint32_t NtpToRtp(NtpTime ntp, uint32_t freq) {
   uint32_t tmp = (static_cast<uint64_t>(ntp.fractions()) * freq) >> 32;
diff --git a/modules/rtp_rtcp/source/tmmbr_help.cc b/modules/rtp_rtcp/source/tmmbr_help.cc
index 8aa4530..315a4c2 100644
--- a/modules/rtp_rtcp/source/tmmbr_help.cc
+++ b/modules/rtp_rtcp/source/tmmbr_help.cc
@@ -10,6 +10,7 @@
 
 #include "modules/rtp_rtcp/source/tmmbr_help.h"
 
+#include <stddef.h>
 #include <algorithm>
 #include <limits>
 
diff --git a/modules/rtp_rtcp/source/tmmbr_help.h b/modules/rtp_rtcp/source/tmmbr_help.h
index 91aeaf4..bf86f65 100644
--- a/modules/rtp_rtcp/source/tmmbr_help.h
+++ b/modules/rtp_rtcp/source/tmmbr_help.h
@@ -11,7 +11,9 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_TMMBR_HELP_H_
 #define MODULES_RTP_RTCP_SOURCE_TMMBR_HELP_H_
 
+#include <stdint.h>
 #include <vector>
+
 #include "modules/rtp_rtcp/source/rtcp_packet/tmmb_item.h"
 
 namespace webrtc {
diff --git a/modules/rtp_rtcp/source/ulpfec_generator.cc b/modules/rtp_rtcp/source/ulpfec_generator.cc
index e5777ed..56dae29 100644
--- a/modules/rtp_rtcp/source/ulpfec_generator.cc
+++ b/modules/rtp_rtcp/source/ulpfec_generator.cc
@@ -10,12 +10,15 @@
 
 #include "modules/rtp_rtcp/source/ulpfec_generator.h"
 
+#include <string.h>
+#include <cstdint>
 #include <memory>
 #include <utility>
 
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/rtp_rtcp/source/byte_io.h"
 #include "modules/rtp_rtcp/source/forward_error_correction.h"
+#include "modules/rtp_rtcp/source/forward_error_correction_internal.h"
 #include "modules/rtp_rtcp/source/rtp_utility.h"
 #include "rtc_base/checks.h"
 
diff --git a/modules/rtp_rtcp/source/ulpfec_generator.h b/modules/rtp_rtcp/source/ulpfec_generator.h
index efc753f..74a1d80 100644
--- a/modules/rtp_rtcp/source/ulpfec_generator.h
+++ b/modules/rtp_rtcp/source/ulpfec_generator.h
@@ -11,10 +11,13 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_ULPFEC_GENERATOR_H_
 #define MODULES_RTP_RTCP_SOURCE_ULPFEC_GENERATOR_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <list>
 #include <memory>
 #include <vector>
 
+#include "modules/include/module_fec_types.h"
 #include "modules/rtp_rtcp/source/forward_error_correction.h"
 
 namespace webrtc {
diff --git a/modules/rtp_rtcp/source/ulpfec_header_reader_writer.cc b/modules/rtp_rtcp/source/ulpfec_header_reader_writer.cc
index c54d3cd..22af7e7 100644
--- a/modules/rtp_rtcp/source/ulpfec_header_reader_writer.cc
+++ b/modules/rtp_rtcp/source/ulpfec_header_reader_writer.cc
@@ -10,11 +10,12 @@
 
 #include "modules/rtp_rtcp/source/ulpfec_header_reader_writer.h"
 
-#include <utility>
+#include <string.h>
 
 #include "modules/rtp_rtcp/source/byte_io.h"
 #include "modules/rtp_rtcp/source/forward_error_correction_internal.h"
 #include "rtc_base/checks.h"
+#include "rtc_base/scoped_ref_ptr.h"
 
 namespace webrtc {
 
diff --git a/modules/rtp_rtcp/source/ulpfec_header_reader_writer.h b/modules/rtp_rtcp/source/ulpfec_header_reader_writer.h
index fc83afd..a8bb737 100644
--- a/modules/rtp_rtcp/source/ulpfec_header_reader_writer.h
+++ b/modules/rtp_rtcp/source/ulpfec_header_reader_writer.h
@@ -11,6 +11,9 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_ULPFEC_HEADER_READER_WRITER_H_
 #define MODULES_RTP_RTCP_SOURCE_ULPFEC_HEADER_READER_WRITER_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "modules/rtp_rtcp/source/forward_error_correction.h"
 
 namespace webrtc {
diff --git a/modules/rtp_rtcp/source/ulpfec_receiver_impl.cc b/modules/rtp_rtcp/source/ulpfec_receiver_impl.cc
index eb09c95..7da6b88 100644
--- a/modules/rtp_rtcp/source/ulpfec_receiver_impl.cc
+++ b/modules/rtp_rtcp/source/ulpfec_receiver_impl.cc
@@ -10,12 +10,13 @@
 
 #include "modules/rtp_rtcp/source/ulpfec_receiver_impl.h"
 
+#include <string.h>
 #include <memory>
 #include <utility>
 
 #include "modules/rtp_rtcp/source/byte_io.h"
-#include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
+#include "rtc_base/scoped_ref_ptr.h"
 #include "system_wrappers/include/clock.h"
 
 namespace webrtc {
diff --git a/modules/rtp_rtcp/source/ulpfec_receiver_impl.h b/modules/rtp_rtcp/source/ulpfec_receiver_impl.h
index 96367dc..0943266 100644
--- a/modules/rtp_rtcp/source/ulpfec_receiver_impl.h
+++ b/modules/rtp_rtcp/source/ulpfec_receiver_impl.h
@@ -11,9 +11,12 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_ULPFEC_RECEIVER_IMPL_H_
 #define MODULES_RTP_RTCP_SOURCE_ULPFEC_RECEIVER_IMPL_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <memory>
 #include <vector>
 
+#include "api/rtp_headers.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/rtp_rtcp/include/ulpfec_receiver.h"
 #include "modules/rtp_rtcp/source/forward_error_correction.h"
diff --git a/modules/video_coding/codecs/h264/include/h264.h b/modules/video_coding/codecs/h264/include/h264.h
index e23818b..f5cebcf 100644
--- a/modules/video_coding/codecs/h264/include/h264.h
+++ b/modules/video_coding/codecs/h264/include/h264.h
@@ -17,6 +17,7 @@
 
 #include "media/base/codec.h"
 #include "modules/video_coding/include/video_codec_interface.h"
+#include "rtc_base/system/rtc_export.h"
 
 namespace webrtc {
 
@@ -26,13 +27,13 @@
 // |rtc_use_h264| build flag is true (if false, this function does nothing).
 // This function should only be called before or during WebRTC initialization
 // and is not thread-safe.
-void DisableRtcUseH264();
+RTC_EXPORT void DisableRtcUseH264();
 
 // Returns a vector with all supported internal H264 profiles that we can
 // negotiate in SDP, in order of preference.
 std::vector<SdpVideoFormat> SupportedH264Codecs();
 
-class H264Encoder : public VideoEncoder {
+class RTC_EXPORT H264Encoder : public VideoEncoder {
  public:
   static std::unique_ptr<H264Encoder> Create(const cricket::VideoCodec& codec);
   // If H.264 is supported (any implementation).
@@ -41,7 +42,7 @@
   ~H264Encoder() override {}
 };
 
-class H264Decoder : public VideoDecoder {
+class RTC_EXPORT H264Decoder : public VideoDecoder {
  public:
   static std::unique_ptr<H264Decoder> Create();
   static bool IsSupported();
diff --git a/modules/video_coding/codecs/vp8/include/temporal_layers_checker.h b/modules/video_coding/codecs/vp8/include/temporal_layers_checker.h
index 9878ac9..ae14f68 100644
--- a/modules/video_coding/codecs/vp8/include/temporal_layers_checker.h
+++ b/modules/video_coding/codecs/vp8/include/temporal_layers_checker.h
@@ -15,7 +15,7 @@
 
 #include <memory>
 
-#include "modules/video_coding/codecs/vp8/include/vp8_temporal_layers.h"
+#include "api/video_codecs/vp8_temporal_layers.h"
 
 namespace webrtc {
 
@@ -29,10 +29,10 @@
 
   virtual bool CheckTemporalConfig(
       bool frame_is_keyframe,
-      const TemporalLayers::FrameConfig& frame_config);
+      const Vp8TemporalLayers::FrameConfig& frame_config);
 
   static std::unique_ptr<TemporalLayersChecker> CreateTemporalLayersChecker(
-      TemporalLayersType type,
+      Vp8TemporalLayersType type,
       int num_temporal_layers);
 
  private:
@@ -46,7 +46,7 @@
                                  bool* need_sync,
                                  bool frame_is_keyframe,
                                  uint8_t temporal_layer,
-                                 webrtc::TemporalLayers::BufferFlags flags,
+                                 webrtc::Vp8TemporalLayers::BufferFlags flags,
                                  uint32_t sequence_number,
                                  uint32_t* lowest_sequence_referenced);
   BufferState last_;
diff --git a/modules/video_coding/codecs/vp8/include/vp8_temporal_layers.h b/modules/video_coding/codecs/vp8/include/vp8_temporal_layers.h
deleted file mode 100644
index b5dbc4e..0000000
--- a/modules/video_coding/codecs/vp8/include/vp8_temporal_layers.h
+++ /dev/null
@@ -1,198 +0,0 @@
-/*
- *  Copyright (c) 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 MODULES_VIDEO_CODING_CODECS_VP8_INCLUDE_VP8_TEMPORAL_LAYERS_H_
-#define MODULES_VIDEO_CODING_CODECS_VP8_INCLUDE_VP8_TEMPORAL_LAYERS_H_
-
-#include <memory>
-#include <vector>
-
-namespace webrtc {
-
-// Some notes on the prerequisites of the TemporalLayers interface.
-// * Implementations of TemporalLayers may not contain internal synchronization
-//   so caller must make sure doing so thread safe.
-// * The encoder is assumed to encode all frames in order, and callbacks to
-//   PopulateCodecSpecific() / FrameEncoded() must happen in the same order.
-//
-// This means that in the case of pipelining encoders, it is OK to have a chain
-// of calls such as this:
-// - UpdateLayerConfig(timestampA)
-// - UpdateLayerConfig(timestampB)
-// - PopulateCodecSpecific(timestampA, ...)
-// - UpdateLayerConfig(timestampC)
-// - OnEncodeDone(timestampA, 1234, ...)
-// - UpdateLayerConfig(timestampC)
-// - OnEncodeDone(timestampB, 0, ...)
-// - OnEncodeDone(timestampC, 1234, ...)
-// Note that UpdateLayerConfig() for a new frame can happen before
-// FrameEncoded() for a previous one, but calls themselves must be both
-// synchronized (e.g. run on a task queue) and in order (per type).
-
-enum class TemporalLayersType { kFixedPattern, kBitrateDynamic };
-
-struct CodecSpecificInfoVP8;
-enum class Vp8BufferReference : uint8_t {
-  kNone = 0,
-  kLast = 1,
-  kGolden = 2,
-  kAltref = 4
-};
-
-struct Vp8EncoderConfig {
-  static constexpr size_t kMaxPeriodicity = 16;
-  static constexpr size_t kMaxLayers = 5;
-
-  // Number of active temporal layers. Set to 0 if not used.
-  uint32_t ts_number_layers;
-  // Arrays of length |ts_number_layers|, indicating (cumulative) target bitrate
-  // and rate decimator (e.g. 4 if every 4th frame is in the given layer) for
-  // each active temporal layer, starting with temporal id 0.
-  uint32_t ts_target_bitrate[kMaxLayers];
-  uint32_t ts_rate_decimator[kMaxLayers];
-
-  // The periodicity of the temporal pattern. Set to 0 if not used.
-  uint32_t ts_periodicity;
-  // Array of length |ts_periodicity| indicating the sequence of temporal id's
-  // to assign to incoming frames.
-  uint32_t ts_layer_id[kMaxPeriodicity];
-
-  // Target bitrate, in bps.
-  uint32_t rc_target_bitrate;
-
-  // Clamp QP to min/max. Use 0 to disable clamping.
-  uint32_t rc_min_quantizer;
-  uint32_t rc_max_quantizer;
-};
-
-// This interface defines a way of getting the encoder settings needed to
-// realize a temporal layer structure of predefined size.
-class TemporalLayers {
- public:
-  enum BufferFlags : int {
-    kNone = 0,
-    kReference = 1,
-    kUpdate = 2,
-    kReferenceAndUpdate = kReference | kUpdate,
-  };
-  enum FreezeEntropy { kFreezeEntropy };
-
-  struct FrameConfig {
-    FrameConfig();
-
-    FrameConfig(BufferFlags last, BufferFlags golden, BufferFlags arf);
-    FrameConfig(BufferFlags last,
-                BufferFlags golden,
-                BufferFlags arf,
-                FreezeEntropy);
-
-    bool drop_frame;
-    BufferFlags last_buffer_flags;
-    BufferFlags golden_buffer_flags;
-    BufferFlags arf_buffer_flags;
-
-    // The encoder layer ID is used to utilize the correct bitrate allocator
-    // inside the encoder. It does not control references nor determine which
-    // "actual" temporal layer this is. The packetizer temporal index determines
-    // which layer the encoded frame should be packetized into.
-    // Normally these are the same, but current temporal-layer strategies for
-    // screenshare use one bitrate allocator for all layers, but attempt to
-    // packetize / utilize references to split a stream into multiple layers,
-    // with different quantizer settings, to hit target bitrate.
-    // TODO(pbos): Screenshare layers are being reconsidered at the time of
-    // writing, we might be able to remove this distinction, and have a temporal
-    // layer imply both (the normal case).
-    int encoder_layer_id;
-    int packetizer_temporal_idx;
-
-    bool layer_sync;
-
-    bool freeze_entropy;
-
-    // Indicates in which order the encoder should search the reference buffers
-    // when doing motion prediction. Set to kNone to use unspecified order. Any
-    // buffer indicated here must not have the corresponding no_ref bit set.
-    // If all three buffers can be reference, the one not listed here should be
-    // searched last.
-    Vp8BufferReference first_reference;
-    Vp8BufferReference second_reference;
-
-    bool operator==(const FrameConfig& o) const;
-    bool operator!=(const FrameConfig& o) const { return !(*this == o); }
-
-   private:
-    FrameConfig(BufferFlags last,
-                BufferFlags golden,
-                BufferFlags arf,
-                bool freeze_entropy);
-  };
-
-  // Factory for TemporalLayer strategy. Default behavior is a fixed pattern
-  // of temporal layers. See default_temporal_layers.cc
-  static std::unique_ptr<TemporalLayers> CreateTemporalLayers(
-      TemporalLayersType type,
-      int num_temporal_layers);
-
-  virtual ~TemporalLayers() = default;
-
-  // If this method returns true, the encoder is free to drop frames for
-  // instance in an effort to uphold encoding bitrate.
-  // If this return false, the encoder must not drop any frames unless:
-  //  1. Requested to do so via FrameConfig.drop_frame
-  //  2. The frame to be encoded is requested to be a keyframe
-  //  3. The encoded detected a large overshoot and decided to drop and then
-  //     re-encode the image at a low bitrate. In this case the encoder should
-  //     call OnEncodeDone() once with size = 0 to indicate drop, and then call
-  //     OnEncodeDone() again when the frame has actually been encoded.
-  virtual bool SupportsEncoderFrameDropping() const = 0;
-
-  // New target bitrate, per temporal layer.
-  virtual void OnRatesUpdated(const std::vector<uint32_t>& bitrates_bps,
-                              int framerate_fps) = 0;
-
-  // Called by the encoder before encoding a frame. |cfg| contains the current
-  // configuration. If the TemporalLayers instance wishes any part of that
-  // to be changed before the encode step, |cfg| should be changed and then
-  // return true. If false is returned, the encoder will proceed without
-  // updating the configuration.
-  virtual bool UpdateConfiguration(Vp8EncoderConfig* cfg) = 0;
-
-  // Returns the recommended VP8 encode flags needed, and moves the temporal
-  // pattern to the next frame.
-  // The timestamp may be used as both a time and a unique identifier, and so
-  // the caller must make sure no two frames use the same timestamp.
-  // The timestamp uses a 90kHz RTP clock.
-  // After calling this method, first call the actual encoder with the provided
-  // frame configuration, and then OnEncodeDone() below.
-  virtual FrameConfig UpdateLayerConfig(uint32_t rtp_timestamp) = 0;
-
-  // Called after the encode step is done. |rtp_timestamp| must match the
-  // parameter use in the UpdateLayerConfig() call.
-  // |is_keyframe| must be true iff the encoder decided to encode this frame as
-  // a keyframe.
-  // If the encoder decided to drop this frame, |size_bytes| must be set to 0,
-  // otherwise it should indicate the size in bytes of the encoded frame.
-  // If |size_bytes| > 0, and |vp8_info| is not null, the TemporalLayers
-  // instance my update |vp8_info| with codec specific data such as temporal id.
-  // Some fields of this struct may have already been populated by the encoder,
-  // check before overwriting.
-  // If |size_bytes| > 0, |qp| should indicate the frame-level QP this frame was
-  // encoded at. If the encoder does not support extracting this, |qp| should be
-  // set to 0.
-  virtual void OnEncodeDone(uint32_t rtp_timestamp,
-                            size_t size_bytes,
-                            bool is_keyframe,
-                            int qp,
-                            CodecSpecificInfoVP8* vp8_info) = 0;
-};
-
-}  // namespace webrtc
-
-#endif  // MODULES_VIDEO_CODING_CODECS_VP8_INCLUDE_VP8_TEMPORAL_LAYERS_H_
diff --git a/rtc_base/BUILD.gn b/rtc_base/BUILD.gn
index f7f5bb8..f970278 100644
--- a/rtc_base/BUILD.gn
+++ b/rtc_base/BUILD.gn
@@ -68,7 +68,7 @@
 }
 
 # The subset of rtc_base approved for use outside of libjingle.
-# TODO(bugs.webrtc.org/9838): Create small and focues build targets and remove
+# TODO(bugs.webrtc.org/9838): Create small and focused build targets and remove
 # the old concept of rtc_base and rtc_base_approved.
 rtc_source_set("rtc_base_approved") {
   visibility = [ "*" ]
@@ -76,9 +76,12 @@
     ":checks",
     ":rtc_task_queue",
     ":safe_compare",
+    ":safe_minmax",
     ":type_traits",
     "..:webrtc_common",
     "../api:array_view",
+    "../system_wrappers:field_trial",
+    "experiments:field_trial_parser",
     "system:arch",
     "system:unused",
     "third_party/base64",
@@ -118,8 +121,6 @@
     "numerics/sample_counter.cc",
     "numerics/sample_counter.h",
     "onetimeevent.h",
-    "pathutils.cc",
-    "pathutils.h",
     "platform_file.cc",
     "platform_file.h",
     "race_checker.cc",
@@ -260,7 +261,6 @@
 rtc_source_set("rtc_event") {
   deps = [
     ":checks",
-    ":macromagic",
   ]
 
   if (build_with_chromium) {
@@ -282,6 +282,7 @@
   visibility = [ "*" ]
   libs = []
   deps = [
+    ":checks",
     ":criticalsection",
     ":macromagic",
     ":platform_thread_types",
@@ -367,6 +368,7 @@
   deps = [
     ":rtc_base_approved",
     "../system_wrappers",
+    "//third_party/abseil-cpp/absl/types:optional",
   ]
 }
 
@@ -651,6 +653,8 @@
   sources = [
     "numerics/exp_filter.cc",
     "numerics/exp_filter.h",
+    "numerics/moving_average.cc",
+    "numerics/moving_average.h",
     "numerics/moving_median_filter.h",
     "numerics/percentile_filter.h",
     "numerics/sequence_number_util.h",
@@ -688,48 +692,23 @@
 
 rtc_static_library("rtc_base") {
   visibility = [ "*" ]
-  public_deps = []
-  if (!build_with_mozilla) {
-    public_deps += [ ":rtc_base_generic" ]
-  }
-  if (is_win) {
-    sources = [
-      "noop.cc",
-    ]
-  }
-  if (is_ios || is_mac) {
-    sources = [
-      "noop.mm",
-    ]
-    public_deps += [ ":rtc_base_objc" ]
-  }
-}
-
-if (is_ios || is_mac) {
-  rtc_source_set("rtc_base_objc") {
-    sources = [
-      "thread_darwin.mm",
-    ]
-    deps = [
-      ":rtc_base_generic",
-    ]
-    visibility = [ ":rtc_base" ]
-  }
-}
-
-rtc_static_library("rtc_base_generic") {
   cflags = []
   cflags_cc = []
   libs = []
   defines = []
   deps = [
     ":checks",
+
+    # For deprecation of rtc::PacketTime, in asyncpacketsocket.h.
+    ":deprecation",
     ":stringutils",
     "..:webrtc_common",
     "../api:array_view",
+    "network:sent_packet",
     "third_party/base64",
     "third_party/sigslot",
     "//third_party/abseil-cpp/absl/memory",
+    "//third_party/abseil-cpp/absl/strings",
     "//third_party/abseil-cpp/absl/types:optional",
   ]
   public_deps = [
@@ -762,8 +741,6 @@
     "dscp.h",
     "filerotatingstream.cc",
     "filerotatingstream.h",
-    "fileutils.cc",
-    "fileutils.h",
     "gunit_prod.h",
     "helpers.cc",
     "helpers.h",
@@ -772,6 +749,8 @@
     "ipaddress.cc",
     "ipaddress.h",
     "keep_ref_until_done.h",
+    "key_derivation.cc",
+    "key_derivation.h",
     "mdns_responder_interface.h",
     "messagedigest.cc",
     "messagedigest.h",
@@ -792,6 +771,8 @@
     "nullsocketserver.cc",
     "nullsocketserver.h",
     "openssl.h",
+    "openssl_key_derivation_hkdf.cc",
+    "openssl_key_derivation_hkdf.h",
     "openssladapter.cc",
     "openssladapter.h",
     "opensslcertificate.cc",
@@ -827,8 +808,6 @@
     "socketaddresspair.h",
     "socketfactory.h",
     "socketserver.h",
-    "socketstream.cc",
-    "socketstream.h",
     "ssladapter.cc",
     "ssladapter.h",
     "sslcertificate.cc",
@@ -845,11 +824,6 @@
     "thread.h",
   ]
 
-  visibility = [
-    ":rtc_base",
-    ":rtc_base_objc",
-  ]
-
   if (build_with_chromium) {
     include_dirs = [ "../../boringssl/src/include" ]
     public_configs += [ ":rtc_base_chromium_config" ]
@@ -859,8 +833,6 @@
       "logsinks.cc",
       "logsinks.h",
       "numerics/mathutils.h",
-      "optionsfile.cc",
-      "optionsfile.h",
       "rollingaccumulator.h",
       "sslroots.h",
     ]
@@ -894,6 +866,7 @@
 
   if (is_ios || is_mac) {
     sources += [ "macifaddrs_converter.cc" ]
+    deps += [ "system:cocoa_threading" ]
   }
 
   if (rtc_use_x11) {
@@ -919,18 +892,12 @@
       "macutils.cc",
       "macutils.h",
     ]
-    libs += [
-      # For ProcessInformationCopyDictionary in unixfilesystem.cc.
-      "ApplicationServices.framework",
-    ]
   }
 
   if (is_win) {
     sources += [
       "win32.cc",
       "win32.h",
-      "win32filesystem.cc",
-      "win32filesystem.h",
       "win32window.cc",
       "win32window.h",
     ]
@@ -948,8 +915,6 @@
     sources += [
       "ifaddrs_converter.cc",
       "ifaddrs_converter.h",
-      "unixfilesystem.cc",
-      "unixfilesystem.h",
     ]
   }
 
@@ -984,6 +949,8 @@
     "firewallsocketserver.h",
     "gunit.cc",
     "gunit.h",
+    "memory_stream.cc",
+    "memory_stream.h",
     "memory_usage.cc",
     "memory_usage.h",
     "natserver.cc",
@@ -996,6 +963,8 @@
     "proxyserver.h",
     "sigslottester.h",
     "sigslottester.h.pump",
+    "socketstream.cc",
+    "socketstream.h",
     "testbase64.h",
     "testcertificateverifier.h",
     "testclient.cc",
@@ -1127,7 +1096,6 @@
       "numerics/safe_minmax_unittest.cc",
       "numerics/sample_counter_unittest.cc",
       "onetimeevent_unittest.cc",
-      "pathutils_unittest.cc",
       "platform_file_unittest.cc",
       "platform_thread_unittest.cc",
       "random_unittest.cc",
@@ -1231,6 +1199,7 @@
 
     sources = [
       "numerics/exp_filter_unittest.cc",
+      "numerics/moving_average_unittest.cc",
       "numerics/moving_median_filter_unittest.cc",
       "numerics/percentile_filter_unittest.cc",
       "numerics/sequence_number_util_unittest.cc",
@@ -1272,7 +1241,6 @@
       "messagequeue_unittest.cc",
       "nat_unittest.cc",
       "network_unittest.cc",
-      "optionsfile_unittest.cc",
       "proxy_unittest.cc",
       "rollingaccumulator_unittest.cc",
       "rtccertificate_unittest.cc",
@@ -1291,6 +1259,7 @@
     }
     if (is_posix || is_fuchsia) {
       sources += [
+        "openssl_key_derivation_hkdf_unittest.cc",
         "openssladapter_unittest.cc",
         "opensslsessioncache_unittest.cc",
         "opensslutility_unittest.cc",
diff --git a/rtc_base/Dummy.java b/rtc_base/Dummy.java
deleted file mode 100644
index d8f02c9..0000000
--- a/rtc_base/Dummy.java
+++ /dev/null
@@ -1,19 +0,0 @@
-/*
- *  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.
- */
-
-/**
- * This class only exists as glue in a transition.
- * TODO(kjellander): Remove.
- * See https://bugs.webrtc.org/7634 for more details.
- */
-class Dummy {
-  Dummy() {
-  }
-}
diff --git a/rtc_base/OWNERS b/rtc_base/OWNERS
index 69ce253..e67e834 100644
--- a/rtc_base/OWNERS
+++ b/rtc_base/OWNERS
@@ -2,7 +2,6 @@
 juberti@webrtc.org
 kwiberg@webrtc.org
 mflodman@webrtc.org
-perkj@webrtc.org
 pthatcher@webrtc.org
 qingsi@webrtc.org
 sergeyu@chromium.org
diff --git a/rtc_base/asyncinvoker.cc b/rtc_base/asyncinvoker.cc
index e255fb9..f0dd188 100644
--- a/rtc_base/asyncinvoker.cc
+++ b/rtc_base/asyncinvoker.cc
@@ -17,7 +17,7 @@
 
 AsyncInvoker::AsyncInvoker()
     : pending_invocations_(0),
-      invocation_complete_(new RefCountedObject<Event>(false, false)),
+      invocation_complete_(new RefCountedObject<Event>()),
       destroying_(false) {}
 
 AsyncInvoker::~AsyncInvoker() {
diff --git a/rtc_base/asyncpacketsocket.cc b/rtc_base/asyncpacketsocket.cc
index e1b1eae..7e0cc8f 100644
--- a/rtc_base/asyncpacketsocket.cc
+++ b/rtc_base/asyncpacketsocket.cc
@@ -9,6 +9,7 @@
  */
 
 #include "rtc_base/asyncpacketsocket.h"
+#include "rtc_base/nethelper.h"
 
 namespace rtc {
 
@@ -33,9 +34,11 @@
                                        bool is_connectionless,
                                        rtc::PacketInfo* info) {
   info->packet_size_bytes = packet_size_bytes;
-  info->local_socket_address = socket_from.GetLocalAddress();
-  if (!is_connectionless) {
-    info->remote_socket_address = socket_from.GetRemoteAddress();
+  // TODO(srte): Make sure that the family of the local socket is always set
+  // in the VirtualSocket implementation and remove this check.
+  int family = socket_from.GetLocalAddress().family();
+  if (family != 0) {
+    info->ip_overhead_bytes = cricket::GetIpOverhead(family);
   }
 }
 
diff --git a/rtc_base/asyncpacketsocket.h b/rtc_base/asyncpacketsocket.h
index bb0b3bc..44d6c67 100644
--- a/rtc_base/asyncpacketsocket.h
+++ b/rtc_base/asyncpacketsocket.h
@@ -12,6 +12,7 @@
 #define RTC_BASE_ASYNCPACKETSOCKET_H_
 
 #include "rtc_base/constructormagic.h"
+#include "rtc_base/deprecation.h"
 #include "rtc_base/dscp.h"
 #include "rtc_base/socket.h"
 #include "rtc_base/third_party/sigslot/sigslot.h"
@@ -50,25 +51,9 @@
   PacketInfo info_signaled_after_sent;
 };
 
-// This structure will have the information about when packet is actually
-// received by socket.
-struct PacketTime {
-  PacketTime() : timestamp(-1), not_before(-1) {}
-  PacketTime(int64_t timestamp, int64_t not_before)
-      : timestamp(timestamp), not_before(not_before) {}
-
-  int64_t timestamp;  // Receive time after socket delivers the data.
-
-  // Earliest possible time the data could have arrived, indicating the
-  // potential error in the |timestamp| value, in case the system, is busy. For
-  // example, the time of the last select() call.
-  // If unknown, this value will be set to zero.
-  int64_t not_before;
-};
-
-inline PacketTime CreatePacketTime(int64_t not_before) {
-  return PacketTime(TimeMicros(), not_before);
-}
+// TODO(bugs.webrtc.org/9584): Compatibility alias, delete as soon as downstream
+// code is updated.
+typedef int64_t PacketTime;
 
 // Provides the ability to receive packets asynchronously. Sends are not
 // buffered since it is acceptable to drop packets under high load.
@@ -120,7 +105,9 @@
                    const char*,
                    size_t,
                    const SocketAddress&,
-                   const PacketTime&>
+                   // TODO(bugs.webrtc.org/9584): Change to passing the int64_t
+                   // timestamp by value.
+                   const int64_t&>
       SignalReadPacket;
 
   // Emitted each time a packet is sent.
diff --git a/rtc_base/asyncresolverinterface.h b/rtc_base/asyncresolverinterface.h
index 5b2303f..f3df884 100644
--- a/rtc_base/asyncresolverinterface.h
+++ b/rtc_base/asyncresolverinterface.h
@@ -22,9 +22,12 @@
   AsyncResolverInterface();
   virtual ~AsyncResolverInterface();
 
-  // Start address resolve process.
+  // Start address resolution of the hostname in |addr|.
   virtual void Start(const SocketAddress& addr) = 0;
-  // Returns top most resolved address of |family|
+  // Returns true iff the address from |Start| was successfully resolved.
+  // If the address was successfully resolved, sets |addr| to a copy of the
+  // address from |Start| with the IP address set to the top most resolved
+  // address of |family| (|addr| will have both hostname and the resolved ip).
   virtual bool GetResolvedAddress(int family, SocketAddress* addr) const = 0;
   // Returns error from resolver.
   virtual int GetError() const = 0;
diff --git a/rtc_base/asynctcpsocket.cc b/rtc_base/asynctcpsocket.cc
index 087a98e..666b335 100644
--- a/rtc_base/asynctcpsocket.cc
+++ b/rtc_base/asynctcpsocket.cc
@@ -321,7 +321,7 @@
       return;
 
     SignalReadPacket(this, data + kPacketLenSize, pkt_len, remote_addr,
-                     CreatePacketTime(0));
+                     TimeMicros());
 
     *len -= kPacketLenSize + pkt_len;
     if (*len > 0) {
diff --git a/rtc_base/asynctcpsocket.h b/rtc_base/asynctcpsocket.h
index c145d6f..9567dd9 100644
--- a/rtc_base/asynctcpsocket.h
+++ b/rtc_base/asynctcpsocket.h
@@ -11,14 +11,15 @@
 #ifndef RTC_BASE_ASYNCTCPSOCKET_H_
 #define RTC_BASE_ASYNCTCPSOCKET_H_
 
+#include <stddef.h>
 #include <memory>
 
-#include "rtc_base/asyncpacketsocket.h"  // for PacketOptions, AsyncPacketSo...
-#include "rtc_base/asyncsocket.h"        // for AsyncSocket
-#include "rtc_base/buffer.h"             // for Buffer
-#include "rtc_base/constructormagic.h"   // for RTC_DISALLOW_COPY_AND_ASSIGN
-#include "rtc_base/socket.h"             // for Socket, Socket::Option
-#include "rtc_base/socketaddress.h"      // for SocketAddress
+#include "rtc_base/asyncpacketsocket.h"
+#include "rtc_base/asyncsocket.h"
+#include "rtc_base/buffer.h"
+#include "rtc_base/constructormagic.h"
+#include "rtc_base/socket.h"
+#include "rtc_base/socketaddress.h"
 
 namespace rtc {
 
diff --git a/rtc_base/asyncudpsocket.cc b/rtc_base/asyncudpsocket.cc
index ba5fa88..2f9011c 100644
--- a/rtc_base/asyncudpsocket.cc
+++ b/rtc_base/asyncudpsocket.cc
@@ -74,7 +74,6 @@
   rtc::SentPacket sent_packet(options.packet_id, rtc::TimeMillis(),
                               options.info_signaled_after_sent);
   CopySocketInformationToPacketInfo(cb, *this, true, &sent_packet.info);
-  sent_packet.info.remote_socket_address = addr;
   int ret = socket_->SendTo(pv, cb, addr);
   SignalSentPacket(this, sent_packet);
   return ret;
@@ -123,9 +122,8 @@
 
   // TODO: Make sure that we got all of the packet.
   // If we did not, then we should resize our buffer to be large enough.
-  SignalReadPacket(
-      this, buf_, static_cast<size_t>(len), remote_addr,
-      (timestamp > -1 ? PacketTime(timestamp, 0) : CreatePacketTime(0)));
+  SignalReadPacket(this, buf_, static_cast<size_t>(len), remote_addr,
+                   (timestamp > -1 ? timestamp : TimeMicros()));
 }
 
 void AsyncUDPSocket::OnWriteEvent(AsyncSocket* socket) {
diff --git a/rtc_base/asyncudpsocket.h b/rtc_base/asyncudpsocket.h
index d814b4b..030946d 100644
--- a/rtc_base/asyncudpsocket.h
+++ b/rtc_base/asyncudpsocket.h
@@ -11,9 +11,13 @@
 #ifndef RTC_BASE_ASYNCUDPSOCKET_H_
 #define RTC_BASE_ASYNCUDPSOCKET_H_
 
+#include <stddef.h>
 #include <memory>
 
 #include "rtc_base/asyncpacketsocket.h"
+#include "rtc_base/asyncsocket.h"
+#include "rtc_base/socket.h"
+#include "rtc_base/socketaddress.h"
 #include "rtc_base/socketfactory.h"
 
 namespace rtc {
diff --git a/rtc_base/base64_unittest.cc b/rtc_base/base64_unittest.cc
index 4b857f1..bdf8559 100644
--- a/rtc_base/base64_unittest.cc
+++ b/rtc_base/base64_unittest.cc
@@ -11,7 +11,6 @@
 #include "rtc_base/third_party/base64/base64.h"
 #include "rtc_base/gunit.h"
 #include "rtc_base/logging.h"
-#include "rtc_base/stringutils.h"
 
 #include "rtc_base/testbase64.h"
 
@@ -430,10 +429,10 @@
 
       // try putting some extra stuff after the equals signs, or in between them
       if (equals == 2) {
-        sprintfn(first_equals, 6, " = = ");
+        snprintf(first_equals, 6, " = = ");
         len = first_equals - encode_buffer + 5;
       } else {
-        sprintfn(first_equals, 6, " = ");
+        snprintf(first_equals, 6, " = ");
         len = first_equals - encode_buffer + 3;
       }
       decoded2.assign("this junk should be ignored");
diff --git a/rtc_base/bitrateallocationstrategy.cc b/rtc_base/bitrateallocationstrategy.cc
index 7c65c12..46e6674 100644
--- a/rtc_base/bitrateallocationstrategy.cc
+++ b/rtc_base/bitrateallocationstrategy.cc
@@ -9,10 +9,31 @@
  */
 
 #include "rtc_base/bitrateallocationstrategy.h"
+
 #include <algorithm>
+#include <cstddef>
+#include <cstdint>
 #include <map>
 #include <utility>
 
+#include "rtc_base/numerics/safe_minmax.h"
+#include "system_wrappers/include/field_trial.h"
+
+namespace webrtc {
+AudioPriorityConfig::AudioPriorityConfig()
+    : min_rate("min"), max_rate("max"), target_rate("target") {
+  std::string trial_string;
+// TODO(bugs.webrtc.org/9889): Remove this when Chromium build has been fixed.
+#if !defined(WEBRTC_CHROMIUM_BUILD)
+  trial_string = field_trial::FindFullName("WebRTC-Bwe-AudioPriority");
+#endif
+  ParseFieldTrial({&min_rate, &max_rate, &target_rate}, trial_string);
+}
+AudioPriorityConfig::AudioPriorityConfig(const AudioPriorityConfig&) = default;
+AudioPriorityConfig::~AudioPriorityConfig() = default;
+
+}  // namespace webrtc
+
 namespace rtc {
 
 // The purpose of this is to allow video streams to use extra bandwidth for FEC.
@@ -22,31 +43,31 @@
 const int kTransmissionMaxBitrateMultiplier = 2;
 
 std::vector<uint32_t> BitrateAllocationStrategy::SetAllBitratesToMinimum(
-    const ArrayView<const TrackConfig*> track_configs) {
+    const std::vector<BitrateAllocationStrategy::TrackConfig>& track_configs) {
   std::vector<uint32_t> track_allocations;
-  for (const auto* track_config : track_configs) {
-    track_allocations.push_back(track_config->min_bitrate_bps);
+  for (const auto& track_config : track_configs) {
+    track_allocations.push_back(track_config.min_bitrate_bps);
   }
   return track_allocations;
 }
 
 std::vector<uint32_t> BitrateAllocationStrategy::DistributeBitratesEvenly(
-    const ArrayView<const TrackConfig*> track_configs,
+    const std::vector<BitrateAllocationStrategy::TrackConfig>& track_configs,
     uint32_t available_bitrate) {
   std::vector<uint32_t> track_allocations =
       SetAllBitratesToMinimum(track_configs);
   uint32_t sum_min_bitrates = 0;
   uint32_t sum_max_bitrates = 0;
-  for (const auto* track_config : track_configs) {
-    sum_min_bitrates += track_config->min_bitrate_bps;
-    sum_max_bitrates += track_config->max_bitrate_bps;
+  for (const auto& track_config : track_configs) {
+    sum_min_bitrates += track_config.min_bitrate_bps;
+    sum_max_bitrates += track_config.max_bitrate_bps;
   }
   if (sum_min_bitrates >= available_bitrate) {
     return track_allocations;
   } else if (available_bitrate >= sum_max_bitrates) {
     auto track_allocations_it = track_allocations.begin();
-    for (const auto* track_config : track_configs) {
-      *track_allocations_it++ = track_config->max_bitrate_bps;
+    for (const auto& track_config : track_configs) {
+      *track_allocations_it++ = track_config.max_bitrate_bps;
     }
     return track_allocations;
   } else {
@@ -55,11 +76,10 @@
     // lowest max_bitrate_bps. Remainder of available bitrate split evenly among
     // remaining tracks.
     std::multimap<uint32_t, size_t> max_bitrate_sorted_configs;
-    for (const TrackConfig** track_configs_it = track_configs.begin();
-         track_configs_it != track_configs.end(); ++track_configs_it) {
+    for (const auto& track_config : track_configs) {
       max_bitrate_sorted_configs.insert(
-          std::make_pair((*track_configs_it)->max_bitrate_bps,
-                         track_configs_it - track_configs.begin()));
+          std::make_pair(track_config.max_bitrate_bps,
+                         &track_config - &track_configs.front()));
     }
     uint32_t total_available_increase = available_bitrate - sum_min_bitrates;
     int processed_configs = 0;
@@ -68,8 +88,8 @@
           total_available_increase /
           (static_cast<uint32_t>(track_configs.size() - processed_configs));
       uint32_t consumed_increase =
-          std::min(track_configs[track_config_pair.second]->max_bitrate_bps -
-                       track_configs[track_config_pair.second]->min_bitrate_bps,
+          std::min(track_configs[track_config_pair.second].max_bitrate_bps -
+                       track_configs[track_config_pair.second].min_bitrate_bps,
                    available_increase);
       track_allocations[track_config_pair.second] += consumed_increase;
       total_available_increase -= consumed_increase;
@@ -78,53 +98,50 @@
     return track_allocations;
   }
 }
-
 AudioPriorityBitrateAllocationStrategy::AudioPriorityBitrateAllocationStrategy(
     std::string audio_track_id,
     uint32_t sufficient_audio_bitrate)
     : audio_track_id_(audio_track_id),
-      sufficient_audio_bitrate_(sufficient_audio_bitrate) {}
+      sufficient_audio_bitrate_(sufficient_audio_bitrate) {
+  if (config_.target_rate) {
+    sufficient_audio_bitrate_ = config_.target_rate->bps();
+  }
+}
 
 std::vector<uint32_t> AudioPriorityBitrateAllocationStrategy::AllocateBitrates(
     uint32_t available_bitrate,
-    const ArrayView<const TrackConfig*> track_configs) {
-  const TrackConfig* audio_track_config = NULL;
+    std::vector<BitrateAllocationStrategy::TrackConfig> track_configs) {
+  TrackConfig* audio_track_config = nullptr;
   size_t audio_config_index = 0;
   uint32_t sum_min_bitrates = 0;
   uint32_t sum_max_bitrates = 0;
 
-  for (const auto*& track_config : track_configs) {
-    sum_min_bitrates += track_config->min_bitrate_bps;
-    sum_max_bitrates += track_config->max_bitrate_bps;
-    if (track_config->track_id == audio_track_id_) {
-      audio_track_config = track_config;
+  for (auto& track_config : track_configs) {
+    if (track_config.track_id == audio_track_id_) {
       audio_config_index = &track_config - &track_configs[0];
+      audio_track_config = &track_config;
+      if (config_.min_rate)
+        audio_track_config->min_bitrate_bps = config_.min_rate->bps();
+      if (config_.max_rate)
+        audio_track_config->max_bitrate_bps = config_.max_rate->bps();
     }
+    sum_min_bitrates += track_config.min_bitrate_bps;
+    sum_max_bitrates += track_config.max_bitrate_bps;
   }
   if (sum_max_bitrates < available_bitrate) {
     // Allow non audio streams to go above max upto
     // kTransmissionMaxBitrateMultiplier * max_bitrate_bps
-    size_t track_configs_size = track_configs.size();
-    std::vector<TrackConfig> increased_track_configs(track_configs_size);
-    std::vector<const TrackConfig*> increased_track_configs_ptr(
-        track_configs_size);
-    for (unsigned long i = 0; i < track_configs_size; i++) {
-      increased_track_configs[i] = (*track_configs[i]);
-      increased_track_configs_ptr[i] = &increased_track_configs[i];
-      if (track_configs[i]->track_id != audio_track_id_) {
-        increased_track_configs[i].max_bitrate_bps =
-            track_configs[i]->max_bitrate_bps *
-            kTransmissionMaxBitrateMultiplier;
-      }
+    for (auto& track_config : track_configs) {
+      if (&track_config != audio_track_config)
+        track_config.max_bitrate_bps *= kTransmissionMaxBitrateMultiplier;
     }
-    return DistributeBitratesEvenly(increased_track_configs_ptr,
-                                    available_bitrate);
-  }
-  if (audio_track_config == nullptr) {
     return DistributeBitratesEvenly(track_configs, available_bitrate);
   }
-  auto safe_sufficient_audio_bitrate = std::min(
-      std::max(audio_track_config->min_bitrate_bps, sufficient_audio_bitrate_),
+  if (!audio_track_config) {
+    return DistributeBitratesEvenly(track_configs, available_bitrate);
+  }
+  auto safe_sufficient_audio_bitrate = rtc::SafeClamp(
+      sufficient_audio_bitrate_, audio_track_config->min_bitrate_bps,
       audio_track_config->max_bitrate_bps);
   if (available_bitrate <= sum_min_bitrates) {
     return SetAllBitratesToMinimum(track_configs);
@@ -140,9 +157,7 @@
       // Setting audio track minimum to safe_sufficient_audio_bitrate will
       // allow using DistributeBitratesEvenly to allocate at least sufficient
       // bitrate for audio and the rest evenly.
-      TrackConfig sufficient_track_config(*track_configs[audio_config_index]);
-      sufficient_track_config.min_bitrate_bps = safe_sufficient_audio_bitrate;
-      track_configs[audio_config_index] = &sufficient_track_config;
+      audio_track_config->min_bitrate_bps = safe_sufficient_audio_bitrate;
       std::vector<uint32_t> track_allocations =
           DistributeBitratesEvenly(track_configs, available_bitrate);
       return track_allocations;
diff --git a/rtc_base/bitrateallocationstrategy.h b/rtc_base/bitrateallocationstrategy.h
index a4a17f8..13a4eee 100644
--- a/rtc_base/bitrateallocationstrategy.h
+++ b/rtc_base/bitrateallocationstrategy.h
@@ -11,9 +11,13 @@
 #ifndef RTC_BASE_BITRATEALLOCATIONSTRATEGY_H_
 #define RTC_BASE_BITRATEALLOCATIONSTRATEGY_H_
 
+#include <stdint.h>
 #include <string>
 #include <vector>
+
 #include "api/array_view.h"
+#include "rtc_base/experiments/field_trial_parser.h"
+#include "rtc_base/experiments/field_trial_units.h"
 
 namespace rtc {
 
@@ -53,10 +57,12 @@
     std::string track_id;
   };
 
+  // These are only used by AudioPriorityBitrateAllocationStrategy. They are
+  // exposed here to they can be unit tested.
   static std::vector<uint32_t> SetAllBitratesToMinimum(
-      const ArrayView<const TrackConfig*> track_configs);
+      const std::vector<BitrateAllocationStrategy::TrackConfig>& track_configs);
   static std::vector<uint32_t> DistributeBitratesEvenly(
-      const ArrayView<const TrackConfig*> track_configs,
+      const std::vector<BitrateAllocationStrategy::TrackConfig>& track_configs,
       uint32_t available_bitrate);
 
   // Strategy is expected to allocate all available_bitrate up to the sum of
@@ -71,11 +77,25 @@
   // available_bitrate decrease.
   virtual std::vector<uint32_t> AllocateBitrates(
       uint32_t available_bitrate,
-      const ArrayView<const TrackConfig*> track_configs) = 0;
+      std::vector<BitrateAllocationStrategy::TrackConfig> track_configs) = 0;
 
   virtual ~BitrateAllocationStrategy() = default;
 };
+}  // namespace rtc
 
+namespace webrtc {
+struct AudioPriorityConfig {
+  FieldTrialOptional<DataRate> min_rate;
+  FieldTrialOptional<DataRate> max_rate;
+  FieldTrialOptional<DataRate> target_rate;
+  AudioPriorityConfig();
+  AudioPriorityConfig(const AudioPriorityConfig&);
+  AudioPriorityConfig& operator=(const AudioPriorityConfig&) = default;
+  ~AudioPriorityConfig();
+};
+}  // namespace webrtc
+
+namespace rtc {
 // Simple allocation strategy giving priority to audio until
 // sufficient_audio_bitrate is reached. Bitrate is distributed evenly between
 // the tracks after sufficient_audio_bitrate is reached. This implementation
@@ -87,9 +107,11 @@
                                          uint32_t sufficient_audio_bitrate);
   std::vector<uint32_t> AllocateBitrates(
       uint32_t available_bitrate,
-      const ArrayView<const TrackConfig*> track_configs) override;
+      std::vector<BitrateAllocationStrategy::TrackConfig> track_configs)
+      override;
 
  private:
+  webrtc::AudioPriorityConfig config_;
   std::string audio_track_id_;
   uint32_t sufficient_audio_bitrate_;
 };
diff --git a/rtc_base/bitrateallocationstrategy_unittest.cc b/rtc_base/bitrateallocationstrategy_unittest.cc
index bfc41f5..f4c7ee7 100644
--- a/rtc_base/bitrateallocationstrategy_unittest.cc
+++ b/rtc_base/bitrateallocationstrategy_unittest.cc
@@ -43,11 +43,8 @@
       BitrateAllocationStrategy::TrackConfig(min_other_bitrate,
                                              max_other_bitrate, false, "")};
 
-  std::vector<const rtc::BitrateAllocationStrategy::TrackConfig*>
-      track_config_ptrs = MakeTrackConfigPtrsVector(track_configs);
-
   std::vector<uint32_t> allocations =
-      BitrateAllocationStrategy::SetAllBitratesToMinimum(track_config_ptrs);
+      BitrateAllocationStrategy::SetAllBitratesToMinimum(track_configs);
   EXPECT_EQ(min_audio_bitrate, allocations[0]);
   EXPECT_EQ(min_video_bitrate, allocations[1]);
   EXPECT_EQ(min_other_bitrate, allocations[2]);
@@ -76,11 +73,8 @@
       BitrateAllocationStrategy::TrackConfig(min_other_bitrate,
                                              max_other_bitrate, false, "")};
 
-  std::vector<const rtc::BitrateAllocationStrategy::TrackConfig*>
-      track_config_ptrs = MakeTrackConfigPtrsVector(track_configs);
-
   std::vector<uint32_t> allocations =
-      BitrateAllocationStrategy::DistributeBitratesEvenly(track_config_ptrs,
+      BitrateAllocationStrategy::DistributeBitratesEvenly(track_configs,
                                                           available_bitrate);
   EXPECT_EQ(min_audio_bitrate + even_bitrate_increase, allocations[0]);
   EXPECT_EQ(min_video_bitrate + even_bitrate_increase, allocations[1]);
@@ -108,11 +102,7 @@
       BitrateAllocationStrategy::TrackConfig(min_other_bitrate,
                                              max_other_bitrate, false, "")};
 
-  std::vector<const rtc::BitrateAllocationStrategy::TrackConfig*>
-      track_config_ptrs = MakeTrackConfigPtrsVector(track_configs);
-
-  return allocation_strategy.AllocateBitrates(available_bitrate,
-                                              track_config_ptrs);
+  return allocation_strategy.AllocateBitrates(available_bitrate, track_configs);
 }
 
 // Test that when the available bitrate is less than the sum of the minimum
diff --git a/rtc_base/buffer.h b/rtc_base/buffer.h
index 9bf96cd..f9291b9 100644
--- a/rtc_base/buffer.h
+++ b/rtc_base/buffer.h
@@ -150,9 +150,12 @@
 
   BufferT& operator=(BufferT&& buf) {
     RTC_DCHECK(buf.IsConsistent());
+    MaybeZeroCompleteBuffer();
     size_ = buf.size_;
     capacity_ = buf.capacity_;
-    data_ = std::move(buf.data_);
+    using std::swap;
+    swap(data_, buf.data_);
+    buf.data_.reset();
     buf.OnMovedFrom();
     return *this;
   }
@@ -373,10 +376,10 @@
 
   // Zero the complete buffer if template argument "ZeroOnFree" is true.
   void MaybeZeroCompleteBuffer() {
-    if (ZeroOnFree && capacity_) {
+    if (ZeroOnFree && capacity_ > 0) {
       // It would be sufficient to only zero "size_" elements, as all other
       // methods already ensure that the unused capacity contains no sensitive
-      // data - but better safe than sorry.
+      // data---but better safe than sorry.
       ExplicitZeroMemory(data_.get(), capacity_ * sizeof(T));
     }
   }
@@ -399,6 +402,7 @@
   // Called when *this has been moved from. Conceptually it's a no-op, but we
   // can mutate the state slightly to help subsequent sanity checks catch bugs.
   void OnMovedFrom() {
+    RTC_DCHECK(!data_);  // Our heap block should have been stolen.
 #if RTC_DCHECK_IS_ON
     // Ensure that *this is always inconsistent, to provoke bugs.
     size_ = 1;
diff --git a/rtc_base/buffer_unittest.cc b/rtc_base/buffer_unittest.cc
index 1c3abfd..b2f47c1 100644
--- a/rtc_base/buffer_unittest.cc
+++ b/rtc_base/buffer_unittest.cc
@@ -185,6 +185,17 @@
   EXPECT_TRUE(buf1.empty());
 }
 
+TEST(BufferTest, TestMoveAssignSelf) {
+  // Move self-assignment isn't required to produce a meaningful state, but
+  // should not leave the object in an inconsistent state. (Such inconsistent
+  // state could be caught by the DCHECKs and/or by the leak checker.) We need
+  // to be sneaky when testing this; if we're doing a too-obvious
+  // move-assign-to-self, clang's -Wself-move triggers at compile time.
+  Buffer buf(kTestData, 3, 40);
+  Buffer* buf_ptr = &buf;
+  buf = std::move(*buf_ptr);
+}
+
 TEST(BufferTest, TestSwap) {
   Buffer buf1(kTestData, 3);
   Buffer buf2(kTestData, 6, 40);
diff --git a/rtc_base/bufferqueue.cc b/rtc_base/bufferqueue.cc
index 48ff2e6..74f7a50 100644
--- a/rtc_base/bufferqueue.cc
+++ b/rtc_base/bufferqueue.cc
@@ -10,6 +10,8 @@
 
 #include "rtc_base/bufferqueue.h"
 
+#include <stdint.h>
+#include <string.h>
 #include <algorithm>
 
 namespace rtc {
diff --git a/rtc_base/bufferqueue.h b/rtc_base/bufferqueue.h
index 94ab0ca..63f5182 100644
--- a/rtc_base/bufferqueue.h
+++ b/rtc_base/bufferqueue.h
@@ -11,12 +11,14 @@
 #ifndef RTC_BASE_BUFFERQUEUE_H_
 #define RTC_BASE_BUFFERQUEUE_H_
 
+#include <stddef.h>
 #include <deque>
 #include <vector>
 
 #include "rtc_base/buffer.h"
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/criticalsection.h"
+#include "rtc_base/thread_annotations.h"
 
 namespace rtc {
 
diff --git a/rtc_base/bytebuffer.h b/rtc_base/bytebuffer.h
index 9e08f02..4d25c21 100644
--- a/rtc_base/bytebuffer.h
+++ b/rtc_base/bytebuffer.h
@@ -11,6 +11,8 @@
 #ifndef RTC_BASE_BYTEBUFFER_H_
 #define RTC_BASE_BYTEBUFFER_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <string>
 
 #include "rtc_base/buffer.h"
diff --git a/rtc_base/cancelable_periodic_task_unittest.cc b/rtc_base/cancelable_periodic_task_unittest.cc
index fe27ea7..badd623 100644
--- a/rtc_base/cancelable_periodic_task_unittest.cc
+++ b/rtc_base/cancelable_periodic_task_unittest.cc
@@ -68,7 +68,7 @@
 }
 
 TEST(CancelablePeriodicTaskTest, CancelTaskBeforeItRuns) {
-  rtc::Event done(false, false);
+  rtc::Event done;
   MockClosure mock;
   EXPECT_CALL(mock, Call).Times(0);
   EXPECT_CALL(mock, Delete).WillOnce(Invoke([&done] { done.Set(); }));
@@ -84,7 +84,7 @@
 }
 
 TEST(CancelablePeriodicTaskTest, CancelDelayedTaskBeforeItRuns) {
-  rtc::Event done(false, false);
+  rtc::Event done;
   MockClosure mock;
   EXPECT_CALL(mock, Call).Times(0);
   EXPECT_CALL(mock, Delete).WillOnce(Invoke([&done] { done.Set(); }));
@@ -100,7 +100,7 @@
 }
 
 TEST(CancelablePeriodicTaskTest, CancelTaskAfterItRuns) {
-  rtc::Event done(false, false);
+  rtc::Event done;
   MockClosure mock;
   EXPECT_CALL(mock, Call).WillOnce(Return(100));
   EXPECT_CALL(mock, Delete).WillOnce(Invoke([&done] { done.Set(); }));
@@ -117,7 +117,7 @@
 
 TEST(CancelablePeriodicTaskTest, ZeroReturnValueRepostsTheTask) {
   NiceMock<MockClosure> closure;
-  rtc::Event done(false, false);
+  rtc::Event done;
   EXPECT_CALL(closure, Call()).WillOnce(Return(0)).WillOnce(Invoke([&done] {
     done.Set();
     return kTimeoutMs;
@@ -130,7 +130,7 @@
 
 TEST(CancelablePeriodicTaskTest, StartPeriodicTask) {
   MockFunction<int()> closure;
-  rtc::Event done(false, false);
+  rtc::Event done;
   EXPECT_CALL(closure, Call())
       .WillOnce(Return(20))
       .WillOnce(Return(20))
@@ -146,7 +146,7 @@
 
 // Validates perfect forwarding doesn't keep reference to deleted copy.
 TEST(CancelablePeriodicTaskTest, CreateWithCopyOfAClosure) {
-  rtc::Event done(false, false);
+  rtc::Event done;
   MockClosure mock;
   EXPECT_CALL(mock, Call).WillOnce(Invoke([&done] {
     done.Set();
@@ -166,7 +166,7 @@
 }
 
 TEST(CancelablePeriodicTaskTest, DeletingHandleDoesntStopTheTask) {
-  rtc::Event run(false, false);
+  rtc::Event run;
   rtc::TaskQueue task_queue("queue");
   auto task = rtc::CreateCancelablePeriodicTask(([&] {
     run.Set();
diff --git a/rtc_base/copyonwritebuffer.cc b/rtc_base/copyonwritebuffer.cc
index 6c48d52..8f5126a 100644
--- a/rtc_base/copyonwritebuffer.cc
+++ b/rtc_base/copyonwritebuffer.cc
@@ -10,6 +10,8 @@
 
 #include "rtc_base/copyonwritebuffer.h"
 
+#include <stddef.h>
+
 namespace rtc {
 
 CopyOnWriteBuffer::CopyOnWriteBuffer() {
diff --git a/rtc_base/copyonwritebuffer.h b/rtc_base/copyonwritebuffer.h
index 177e38f..cc174df 100644
--- a/rtc_base/copyonwritebuffer.h
+++ b/rtc_base/copyonwritebuffer.h
@@ -11,7 +11,11 @@
 #ifndef RTC_BASE_COPYONWRITEBUFFER_H_
 #define RTC_BASE_COPYONWRITEBUFFER_H_
 
+#include <stdint.h>
 #include <algorithm>
+#include <cstring>
+#include <string>
+#include <type_traits>
 #include <utility>
 
 #include "rtc_base/buffer.h"
diff --git a/rtc_base/cpu_time.cc b/rtc_base/cpu_time.cc
index de4a6bd..ad91eca 100644
--- a/rtc_base/cpu_time.cc
+++ b/rtc_base/cpu_time.cc
@@ -65,6 +65,9 @@
   } else {
     RTC_LOG_ERR(LS_ERROR) << "GetProcessTimes() failed.";
   }
+#elif defined(WEBRTC_FUCHSIA)
+  RTC_LOG_ERR(LS_ERROR) << "GetProcessCpuTimeNanos() not implemented";
+  return 0;
 #else
   // Not implemented yet.
   static_assert(
@@ -107,10 +110,13 @@
   } else {
     RTC_LOG_ERR(LS_ERROR) << "GetThreadTimes() failed.";
   }
+#elif defined(WEBRTC_FUCHSIA)
+  RTC_LOG_ERR(LS_ERROR) << "GetThreadCpuTimeNanos() not implemented";
+  return 0;
 #else
   // Not implemented yet.
   static_assert(
-      false, "GetProcessCpuTimeNanos() platform support not yet implemented.");
+      false, "GetThreadCpuTimeNanos() platform support not yet implemented.");
 #endif
   return -1;
 }
diff --git a/rtc_base/criticalsection.cc b/rtc_base/criticalsection.cc
index d8a5b48..4e00be9 100644
--- a/rtc_base/criticalsection.cc
+++ b/rtc_base/criticalsection.cc
@@ -10,6 +10,8 @@
 
 #include "rtc_base/criticalsection.h"
 
+#include <time.h>
+
 #include "rtc_base/atomicops.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/platform_thread_types.h"
diff --git a/rtc_base/criticalsection_unittest.cc b/rtc_base/criticalsection_unittest.cc
index db4f9e7..6016f85 100644
--- a/rtc_base/criticalsection_unittest.cc
+++ b/rtc_base/criticalsection_unittest.cc
@@ -389,7 +389,7 @@
 // The test is disabled by default to avoid unecessarily loading the bots.
 TEST(CriticalSectionTest, DISABLED_Performance) {
   PerfTestThread threads[8];
-  Event event(false, false);
+  Event event;
 
   static const int kThreadRepeats = 10000000;
   static const int kExpectedCount = kThreadRepeats * arraysize(threads);
diff --git a/rtc_base/event.cc b/rtc_base/event.cc
index 6c9639b..42c22a2 100644
--- a/rtc_base/event.cc
+++ b/rtc_base/event.cc
@@ -24,6 +24,8 @@
 
 namespace rtc {
 
+Event::Event() : Event(false, false) {}
+
 #if defined(WEBRTC_WIN)
 
 Event::Event(bool manual_reset, bool initially_signaled) {
diff --git a/rtc_base/event.h b/rtc_base/event.h
index 7e61c4c..2e11002 100644
--- a/rtc_base/event.h
+++ b/rtc_base/event.h
@@ -11,7 +11,6 @@
 #ifndef RTC_BASE_EVENT_H_
 #define RTC_BASE_EVENT_H_
 
-#include "rtc_base/constructormagic.h"
 #if defined(WEBRTC_WIN)
 #include <windows.h>
 #elif defined(WEBRTC_POSIX)
@@ -26,7 +25,10 @@
  public:
   static const int kForever = -1;
 
+  Event();
   Event(bool manual_reset, bool initially_signaled);
+  Event(const Event&) = delete;
+  Event& operator=(const Event&) = delete;
   ~Event();
 
   void Set();
@@ -45,8 +47,6 @@
   const bool is_manual_reset_;
   bool event_status_;
 #endif
-
-  RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(Event);
 };
 
 // This class is provided for compatibility with Chromium.
diff --git a/rtc_base/event_tracer.cc b/rtc_base/event_tracer.cc
index 31f4271..af88c9d 100644
--- a/rtc_base/event_tracer.cc
+++ b/rtc_base/event_tracer.cc
@@ -10,7 +10,9 @@
 #include "rtc_base/event_tracer.h"
 
 #include <inttypes.h>
-
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
 #include <string>
 #include <vector>
 
@@ -20,7 +22,9 @@
 #include "rtc_base/event.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/platform_thread.h"
-#include "rtc_base/stringutils.h"
+#include "rtc_base/platform_thread_types.h"
+#include "rtc_base/thread_annotations.h"
+#include "rtc_base/thread_checker.h"
 #include "rtc_base/timeutils.h"
 #include "rtc_base/trace_event.h"
 
@@ -86,8 +90,7 @@
       : logging_thread_(EventTracingThreadFunc,
                         this,
                         "EventTracingThread",
-                        kLowPriority),
-        shutdown_event_(false, false) {}
+                        kLowPriority) {}
   ~EventLogger() { RTC_DCHECK(thread_checker_.CalledOnValidThread()); }
 
   void AddTraceEvent(const char* name,
@@ -286,19 +289,19 @@
           }
           break;
         case TRACE_VALUE_TYPE_UINT:
-          print_length = sprintfn(&output[0], kTraceArgBufferLength, "%llu",
+          print_length = snprintf(&output[0], kTraceArgBufferLength, "%llu",
                                   arg.value.as_uint);
           break;
         case TRACE_VALUE_TYPE_INT:
-          print_length = sprintfn(&output[0], kTraceArgBufferLength, "%lld",
+          print_length = snprintf(&output[0], kTraceArgBufferLength, "%lld",
                                   arg.value.as_int);
           break;
         case TRACE_VALUE_TYPE_DOUBLE:
-          print_length = sprintfn(&output[0], kTraceArgBufferLength, "%f",
+          print_length = snprintf(&output[0], kTraceArgBufferLength, "%f",
                                   arg.value.as_double);
           break;
         case TRACE_VALUE_TYPE_POINTER:
-          print_length = sprintfn(&output[0], kTraceArgBufferLength, "\"%p\"",
+          print_length = snprintf(&output[0], kTraceArgBufferLength, "\"%p\"",
                                   arg.value.as_pointer);
           break;
       }
diff --git a/rtc_base/event_unittest.cc b/rtc_base/event_unittest.cc
index 050619e..a65111b 100644
--- a/rtc_base/event_unittest.cc
+++ b/rtc_base/event_unittest.cc
@@ -32,7 +32,7 @@
 }
 
 TEST(EventTest, AutoReset) {
-  Event event(false, false);
+  Event event;
   ASSERT_FALSE(event.Wait(0));
 
   event.Set();
@@ -59,7 +59,7 @@
       me->reader_->Wait(Event::kForever);
     }
   }
-  Event stop_event_{false, false};
+  Event stop_event_;
   Event* writer_;
   Event* reader_;
   PlatformThread thread_;
@@ -68,7 +68,7 @@
 // These tests are disabled by default and only intended to be run manually.
 TEST(EventTest, DISABLED_PerformanceSingleThread) {
   static const int kNumIterations = 10000000;
-  Event event(false, false);
+  Event event;
   for (int i = 0; i < kNumIterations; ++i) {
     event.Set();
     event.Wait(0);
@@ -77,8 +77,8 @@
 
 TEST(EventTest, DISABLED_PerformanceMultiThread) {
   static const int kNumIterations = 10000;
-  Event read(false, false);
-  Event write(false, false);
+  Event read;
+  Event write;
   SignalerThread thread;
   thread.Start(&read, &write);
 
diff --git a/rtc_base/experiments/BUILD.gn b/rtc_base/experiments/BUILD.gn
index 044db80..b2e1302 100644
--- a/rtc_base/experiments/BUILD.gn
+++ b/rtc_base/experiments/BUILD.gn
@@ -28,11 +28,11 @@
     "field_trial_units.h",
   ]
   deps = [
-    "../:rtc_base_approved",
     "../../api/units:data_rate",
     "../../api/units:data_size",
     "../../api/units:time_delta",
     "../../rtc_base:checks",
+    "../../rtc_base:logging",
     "//third_party/abseil-cpp/absl/types:optional",
   ]
 }
@@ -63,6 +63,30 @@
   ]
 }
 
+rtc_static_library("normalize_simulcast_size_experiment") {
+  sources = [
+    "normalize_simulcast_size_experiment.cc",
+    "normalize_simulcast_size_experiment.h",
+  ]
+  deps = [
+    "../:rtc_base_approved",
+    "../../system_wrappers:field_trial",
+    "//third_party/abseil-cpp/absl/types:optional",
+  ]
+}
+
+rtc_static_library("cpu_speed_experiment") {
+  sources = [
+    "cpu_speed_experiment.cc",
+    "cpu_speed_experiment.h",
+  ]
+  deps = [
+    "../:rtc_base_approved",
+    "../../system_wrappers:field_trial",
+    "//third_party/abseil-cpp/absl/types:optional",
+  ]
+}
+
 rtc_static_library("rtt_mult_experiment") {
   sources = [
     "rtt_mult_experiment.cc",
@@ -92,20 +116,25 @@
 
     sources = [
       "congestion_controller_experiment_unittest.cc",
+      "cpu_speed_experiment_unittest.cc",
       "field_trial_parser_unittest.cc",
       "field_trial_units_unittest.cc",
+      "normalize_simulcast_size_experiment_unittest.cc",
       "quality_scaling_experiment_unittest.cc",
       "rtt_mult_experiment_unittest.cc",
     ]
     deps = [
       ":congestion_controller_experiment",
+      ":cpu_speed_experiment",
       ":field_trial_parser",
+      ":normalize_simulcast_size_experiment",
       ":quality_scaling_experiment",
       ":rtt_mult_experiment",
       "../:rtc_base_tests_main",
       "../:rtc_base_tests_utils",
       "../../system_wrappers:field_trial",
       "../../test:field_trial",
+      "../../test:test_support",
     ]
   }
 }
diff --git a/rtc_base/experiments/alr_experiment.cc b/rtc_base/experiments/alr_experiment.cc
index dff5ace..25e948d 100644
--- a/rtc_base/experiments/alr_experiment.cc
+++ b/rtc_base/experiments/alr_experiment.cc
@@ -10,9 +10,10 @@
 
 #include "rtc_base/experiments/alr_experiment.h"
 
+#include <inttypes.h>
+#include <stdio.h>
 #include <string>
 
-#include "rtc_base/format_macros.h"
 #include "rtc_base/logging.h"
 #include "system_wrappers/include/field_trial.h"
 
diff --git a/rtc_base/experiments/alr_experiment.h b/rtc_base/experiments/alr_experiment.h
index 4d9fd00..876bd02 100644
--- a/rtc_base/experiments/alr_experiment.h
+++ b/rtc_base/experiments/alr_experiment.h
@@ -11,6 +11,8 @@
 #ifndef RTC_BASE_EXPERIMENTS_ALR_EXPERIMENT_H_
 #define RTC_BASE_EXPERIMENTS_ALR_EXPERIMENT_H_
 
+#include <stdint.h>
+
 #include "absl/types/optional.h"
 
 namespace webrtc {
diff --git a/rtc_base/experiments/cpu_speed_experiment.cc b/rtc_base/experiments/cpu_speed_experiment.cc
new file mode 100644
index 0000000..f39540c
--- /dev/null
+++ b/rtc_base/experiments/cpu_speed_experiment.cc
@@ -0,0 +1,70 @@
+/*
+ *  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.
+ */
+
+#include "rtc_base/experiments/cpu_speed_experiment.h"
+
+#include <string>
+
+#include "rtc_base/logging.h"
+#include "system_wrappers/include/field_trial.h"
+
+namespace webrtc {
+namespace {
+constexpr char kFieldTrial[] = "WebRTC-VP8-CpuSpeed-Arm";
+constexpr int kMinSetting = -16;
+constexpr int kMaxSetting = -1;
+}  // namespace
+
+absl::optional<std::vector<CpuSpeedExperiment::Config>>
+CpuSpeedExperiment::GetConfigs() {
+  if (!webrtc::field_trial::IsEnabled(kFieldTrial))
+    return absl::nullopt;
+
+  const std::string group = webrtc::field_trial::FindFullName(kFieldTrial);
+  if (group.empty())
+    return absl::nullopt;
+
+  std::vector<Config> configs(3);
+  if (sscanf(group.c_str(), "Enabled-%d,%d,%d,%d,%d,%d", &(configs[0].pixels),
+             &(configs[0].cpu_speed), &(configs[1].pixels),
+             &(configs[1].cpu_speed), &(configs[2].pixels),
+             &(configs[2].cpu_speed)) != 6) {
+    RTC_LOG(LS_WARNING) << "Too few parameters provided.";
+    return absl::nullopt;
+  }
+
+  for (const auto& config : configs) {
+    if (config.cpu_speed < kMinSetting || config.cpu_speed > kMaxSetting) {
+      RTC_LOG(LS_WARNING) << "Unsupported cpu speed setting, value ignored.";
+      return absl::nullopt;
+    }
+  }
+
+  for (size_t i = 1; i < configs.size(); ++i) {
+    if (configs[i].pixels < configs[i - 1].pixels ||
+        configs[i].cpu_speed > configs[i - 1].cpu_speed) {
+      RTC_LOG(LS_WARNING) << "Invalid parameter value provided.";
+      return absl::nullopt;
+    }
+  }
+
+  return absl::optional<std::vector<Config>>(configs);
+}
+
+int CpuSpeedExperiment::GetValue(int pixels,
+                                 const std::vector<Config>& configs) {
+  for (const auto& config : configs) {
+    if (pixels <= config.pixels)
+      return config.cpu_speed;
+  }
+  return kMinSetting;
+}
+
+}  // namespace webrtc
diff --git a/rtc_base/experiments/cpu_speed_experiment.h b/rtc_base/experiments/cpu_speed_experiment.h
new file mode 100644
index 0000000..e6c8340
--- /dev/null
+++ b/rtc_base/experiments/cpu_speed_experiment.h
@@ -0,0 +1,41 @@
+/*
+ *  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 RTC_BASE_EXPERIMENTS_CPU_SPEED_EXPERIMENT_H_
+#define RTC_BASE_EXPERIMENTS_CPU_SPEED_EXPERIMENT_H_
+
+#include <vector>
+
+#include "absl/types/optional.h"
+
+namespace webrtc {
+
+class CpuSpeedExperiment {
+ public:
+  struct Config {
+    bool operator==(const Config& o) const {
+      return pixels == o.pixels && cpu_speed == o.cpu_speed;
+    }
+
+    int pixels;     // The video frame size.
+    int cpu_speed;  // The |cpu_speed| to be used if the frame size is less
+                    // than or equal to |pixels|.
+  };
+
+  // Returns the configurations from field trial on success.
+  static absl::optional<std::vector<Config>> GetConfigs();
+
+  // Gets the cpu speed from the |configs| based on |pixels|.
+  static int GetValue(int pixels, const std::vector<Config>& configs);
+};
+
+}  // namespace webrtc
+
+#endif  // RTC_BASE_EXPERIMENTS_CPU_SPEED_EXPERIMENT_H_
diff --git a/rtc_base/experiments/cpu_speed_experiment_unittest.cc b/rtc_base/experiments/cpu_speed_experiment_unittest.cc
new file mode 100644
index 0000000..edc782c
--- /dev/null
+++ b/rtc_base/experiments/cpu_speed_experiment_unittest.cc
@@ -0,0 +1,85 @@
+/*
+ *  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.
+ */
+
+#include "rtc_base/experiments/cpu_speed_experiment.h"
+
+#include "rtc_base/gunit.h"
+#include "test/field_trial.h"
+#include "test/gmock.h"
+
+namespace webrtc {
+
+TEST(CpuSpeedExperimentTest, GetConfigsFailsIfNotEnabled) {
+  EXPECT_FALSE(CpuSpeedExperiment::GetConfigs());
+}
+
+TEST(CpuSpeedExperimentTest, GetConfigsFailsForTooFewParameters) {
+  webrtc::test::ScopedFieldTrials field_trials(
+      "WebRTC-VP8-CpuSpeed-Arm/Enabled-1000,-1,2000,-10,3000/");
+  EXPECT_FALSE(CpuSpeedExperiment::GetConfigs());
+}
+
+TEST(CpuSpeedExperimentTest, GetConfigs) {
+  webrtc::test::ScopedFieldTrials field_trials(
+      "WebRTC-VP8-CpuSpeed-Arm/Enabled-1000,-1,2000,-10,3000,-16/");
+
+  const absl::optional<std::vector<CpuSpeedExperiment::Config>> kConfigs =
+      CpuSpeedExperiment::GetConfigs();
+  ASSERT_TRUE(kConfigs);
+  EXPECT_THAT(*kConfigs,
+              ::testing::ElementsAre(CpuSpeedExperiment::Config{1000, -1},
+                                     CpuSpeedExperiment::Config{2000, -10},
+                                     CpuSpeedExperiment::Config{3000, -16}));
+}
+
+TEST(CpuSpeedExperimentTest, GetValue) {
+  webrtc::test::ScopedFieldTrials field_trials(
+      "WebRTC-VP8-CpuSpeed-Arm/Enabled-1000,-5,2000,-10,3000,-12/");
+
+  const absl::optional<std::vector<CpuSpeedExperiment::Config>> kConfigs =
+      CpuSpeedExperiment::GetConfigs();
+  ASSERT_TRUE(kConfigs);
+  ASSERT_EQ(3u, (*kConfigs).size());
+  EXPECT_EQ(-5, CpuSpeedExperiment::GetValue(1, *kConfigs));
+  EXPECT_EQ(-5, CpuSpeedExperiment::GetValue(1000, *kConfigs));
+  EXPECT_EQ(-10, CpuSpeedExperiment::GetValue(1000 + 1, *kConfigs));
+  EXPECT_EQ(-10, CpuSpeedExperiment::GetValue(2000, *kConfigs));
+  EXPECT_EQ(-12, CpuSpeedExperiment::GetValue(2000 + 1, *kConfigs));
+  EXPECT_EQ(-12, CpuSpeedExperiment::GetValue(3000, *kConfigs));
+  EXPECT_EQ(-16, CpuSpeedExperiment::GetValue(3000 + 1, *kConfigs));
+}
+
+TEST(CpuSpeedExperimentTest, GetConfigsFailsForTooSmallValue) {
+  // Supported range: [-16, -1].
+  webrtc::test::ScopedFieldTrials field_trials(
+      "WebRTC-VP8-CpuSpeed-Arm/Enabled-1000,-1,2000,-10,3000,-17/");
+  EXPECT_FALSE(CpuSpeedExperiment::GetConfigs());
+}
+
+TEST(CpuSpeedExperimentTest, GetConfigsFailsForTooLargeValue) {
+  // Supported range: [-16, -1].
+  webrtc::test::ScopedFieldTrials field_trials(
+      "WebRTC-VP8-CpuSpeed-Arm/Enabled-1000,0,2000,-10,3000,-16/");
+  EXPECT_FALSE(CpuSpeedExperiment::GetConfigs());
+}
+
+TEST(CpuSpeedExperimentTest, GetConfigsFailsIfPixelsDecreasing) {
+  webrtc::test::ScopedFieldTrials field_trials(
+      "WebRTC-VP8-CpuSpeed-Arm/Enabled-1000,-5,999,-10,3000,-16/");
+  EXPECT_FALSE(CpuSpeedExperiment::GetConfigs());
+}
+
+TEST(CpuSpeedExperimentTest, GetConfigsFailsIfCpuSpeedIncreasing) {
+  webrtc::test::ScopedFieldTrials field_trials(
+      "WebRTC-VP8-CpuSpeed-Arm/Enabled-1000,-5,2000,-4,3000,-16/");
+  EXPECT_FALSE(CpuSpeedExperiment::GetConfigs());
+}
+
+}  // namespace webrtc
diff --git a/rtc_base/experiments/field_trial_units.cc b/rtc_base/experiments/field_trial_units.cc
index f53978b..8c201a6 100644
--- a/rtc_base/experiments/field_trial_units.cc
+++ b/rtc_base/experiments/field_trial_units.cc
@@ -9,6 +9,7 @@
  */
 #include "rtc_base/experiments/field_trial_units.h"
 
+#include <stdio.h>
 #include <limits>
 #include <string>
 
diff --git a/rtc_base/experiments/normalize_simulcast_size_experiment.cc b/rtc_base/experiments/normalize_simulcast_size_experiment.cc
new file mode 100644
index 0000000..9ce5f57
--- /dev/null
+++ b/rtc_base/experiments/normalize_simulcast_size_experiment.cc
@@ -0,0 +1,47 @@
+/*
+ *  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.
+ */
+
+#include "rtc_base/experiments/normalize_simulcast_size_experiment.h"
+
+#include <string>
+
+#include "rtc_base/logging.h"
+#include "system_wrappers/include/field_trial.h"
+
+namespace webrtc {
+namespace {
+constexpr char kFieldTrial[] = "WebRTC-NormalizeSimulcastResolution";
+constexpr int kMinSetting = 0;
+constexpr int kMaxSetting = 5;
+}  // namespace
+
+absl::optional<int> NormalizeSimulcastSizeExperiment::GetBase2Exponent() {
+  if (!webrtc::field_trial::IsEnabled(kFieldTrial))
+    return absl::nullopt;
+
+  const std::string group = webrtc::field_trial::FindFullName(kFieldTrial);
+  if (group.empty())
+    return absl::nullopt;
+
+  int exponent;
+  if (sscanf(group.c_str(), "Enabled-%d", &exponent) != 1) {
+    RTC_LOG(LS_WARNING) << "No parameter provided.";
+    return absl::nullopt;
+  }
+
+  if (exponent < kMinSetting || exponent > kMaxSetting) {
+    RTC_LOG(LS_WARNING) << "Unsupported exp value provided, value ignored.";
+    return absl::nullopt;
+  }
+
+  return absl::optional<int>(exponent);
+}
+
+}  // namespace webrtc
diff --git a/rtc_base/experiments/normalize_simulcast_size_experiment.h b/rtc_base/experiments/normalize_simulcast_size_experiment.h
new file mode 100644
index 0000000..6b35820
--- /dev/null
+++ b/rtc_base/experiments/normalize_simulcast_size_experiment.h
@@ -0,0 +1,25 @@
+/*
+ *  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 RTC_BASE_EXPERIMENTS_NORMALIZE_SIMULCAST_SIZE_EXPERIMENT_H_
+#define RTC_BASE_EXPERIMENTS_NORMALIZE_SIMULCAST_SIZE_EXPERIMENT_H_
+
+#include "absl/types/optional.h"
+
+namespace webrtc {
+class NormalizeSimulcastSizeExperiment {
+ public:
+  // Returns the base two exponent from field trial.
+  static absl::optional<int> GetBase2Exponent();
+};
+
+}  // namespace webrtc
+
+#endif  // RTC_BASE_EXPERIMENTS_NORMALIZE_SIMULCAST_SIZE_EXPERIMENT_H_
diff --git a/rtc_base/experiments/normalize_simulcast_size_experiment_unittest.cc b/rtc_base/experiments/normalize_simulcast_size_experiment_unittest.cc
new file mode 100644
index 0000000..c37b809
--- /dev/null
+++ b/rtc_base/experiments/normalize_simulcast_size_experiment_unittest.cc
@@ -0,0 +1,59 @@
+/*
+ *  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.
+ */
+
+#include "rtc_base/experiments/normalize_simulcast_size_experiment.h"
+
+#include "rtc_base/gunit.h"
+#include "test/field_trial.h"
+
+namespace webrtc {
+
+TEST(NormalizeSimulcastSizeExperimentTest, GetExponent) {
+  webrtc::test::ScopedFieldTrials field_trials(
+      "WebRTC-NormalizeSimulcastResolution/Enabled-2/");
+  EXPECT_EQ(2, NormalizeSimulcastSizeExperiment::GetBase2Exponent());
+}
+
+TEST(NormalizeSimulcastSizeExperimentTest, GetExponentWithTwoParameters) {
+  webrtc::test::ScopedFieldTrials field_trials(
+      "WebRTC-NormalizeSimulcastResolution/Enabled-3-4/");
+  EXPECT_EQ(3, NormalizeSimulcastSizeExperiment::GetBase2Exponent());
+}
+
+TEST(NormalizeSimulcastSizeExperimentTest, GetExponentFailsIfNotEnabled) {
+  webrtc::test::ScopedFieldTrials field_trials(
+      "WebRTC-NormalizeSimulcastResolution/Disabled/");
+  EXPECT_FALSE(NormalizeSimulcastSizeExperiment::GetBase2Exponent());
+}
+
+TEST(NormalizeSimulcastSizeExperimentTest,
+     GetExponentFailsForInvalidFieldTrial) {
+  webrtc::test::ScopedFieldTrials field_trials(
+      "WebRTC-NormalizeSimulcastResolution/Enabled-invalid/");
+  EXPECT_FALSE(NormalizeSimulcastSizeExperiment::GetBase2Exponent());
+}
+
+TEST(NormalizeSimulcastSizeExperimentTest,
+     GetExponentFailsForNegativeOutOfBoundValue) {
+  // Supported range: [0, 5].
+  webrtc::test::ScopedFieldTrials field_trials(
+      "WebRTC-NormalizeSimulcastResolution/Enabled--1/");
+  EXPECT_FALSE(NormalizeSimulcastSizeExperiment::GetBase2Exponent());
+}
+
+TEST(NormalizeSimulcastSizeExperimentTest,
+     GetExponentFailsForPositiveOutOfBoundValue) {
+  // Supported range: [0, 5].
+  webrtc::test::ScopedFieldTrials field_trials(
+      "WebRTC-NormalizeSimulcastResolution/Enabled-6/");
+  EXPECT_FALSE(NormalizeSimulcastSizeExperiment::GetBase2Exponent());
+}
+
+}  // namespace webrtc
diff --git a/rtc_base/fake_mdns_responder.h b/rtc_base/fake_mdns_responder.h
index 32d69ba..1e60a5d 100644
--- a/rtc_base/fake_mdns_responder.h
+++ b/rtc_base/fake_mdns_responder.h
@@ -21,10 +21,10 @@
 
 namespace webrtc {
 
-class FakeMDnsResponder : public MDnsResponderInterface {
+class FakeMdnsResponder : public MdnsResponderInterface {
  public:
-  FakeMDnsResponder() = default;
-  ~FakeMDnsResponder() = default;
+  explicit FakeMdnsResponder(rtc::Thread* thread) : thread_(thread) {}
+  ~FakeMdnsResponder() = default;
 
   void CreateNameForAddress(const rtc::IPAddress& addr,
                             NameCreatedCallback callback) override {
@@ -35,7 +35,9 @@
       name = std::to_string(next_available_id_++) + ".local";
       addr_name_map_[addr] = name;
     }
-    callback(addr, name);
+    invoker_.AsyncInvoke<void>(
+        RTC_FROM_HERE, thread_,
+        [callback, addr, name]() { callback(addr, name); });
   }
   void RemoveNameForAddress(const rtc::IPAddress& addr,
                             NameRemovedCallback callback) override {
@@ -43,12 +45,16 @@
     if (it != addr_name_map_.end()) {
       addr_name_map_.erase(it);
     }
-    callback(it != addr_name_map_.end());
+    bool result = it != addr_name_map_.end();
+    invoker_.AsyncInvoke<void>(RTC_FROM_HERE, thread_,
+                               [callback, result]() { callback(result); });
   }
 
  private:
   uint32_t next_available_id_ = 0;
   std::map<rtc::IPAddress, std::string> addr_name_map_;
+  rtc::Thread* thread_;
+  rtc::AsyncInvoker invoker_;
 };
 
 }  // namespace webrtc
diff --git a/rtc_base/fakenetwork.h b/rtc_base/fakenetwork.h
index d5426a3..cb890ec 100644
--- a/rtc_base/fakenetwork.h
+++ b/rtc_base/fakenetwork.h
@@ -82,16 +82,17 @@
   // MessageHandler interface.
   virtual void OnMessage(Message* msg) { DoUpdateNetworks(); }
 
-  void CreateMDnsResponder() {
+  void CreateMdnsResponder() {
     if (mdns_responder_ == nullptr) {
-      mdns_responder_ = absl::make_unique<webrtc::FakeMDnsResponder>();
+      mdns_responder_ =
+          absl::make_unique<webrtc::FakeMdnsResponder>(rtc::Thread::Current());
     }
   }
 
   using NetworkManagerBase::set_enumeration_permission;
   using NetworkManagerBase::set_default_local_addresses;
 
-  webrtc::MDnsResponderInterface* GetMDnsResponder() const override {
+  webrtc::MdnsResponderInterface* GetMdnsResponder() const override {
     return mdns_responder_.get();
   }
 
@@ -131,7 +132,7 @@
   IPAddress default_local_ipv4_address_;
   IPAddress default_local_ipv6_address_;
 
-  std::unique_ptr<webrtc::FakeMDnsResponder> mdns_responder_;
+  std::unique_ptr<webrtc::FakeMdnsResponder> mdns_responder_;
 };
 
 }  // namespace rtc
diff --git a/rtc_base/fakesslidentity.cc b/rtc_base/fakesslidentity.cc
index 80a3e78..62ac9dd 100644
--- a/rtc_base/fakesslidentity.cc
+++ b/rtc_base/fakesslidentity.cc
@@ -29,8 +29,8 @@
 
 FakeSSLCertificate::~FakeSSLCertificate() = default;
 
-FakeSSLCertificate* FakeSSLCertificate::GetReference() const {
-  return new FakeSSLCertificate(*this);
+std::unique_ptr<SSLCertificate> FakeSSLCertificate::Clone() const {
+  return absl::make_unique<FakeSSLCertificate>(*this);
 }
 
 std::string FakeSSLCertificate::ToPEMString() const {
@@ -83,10 +83,10 @@
 }
 
 FakeSSLIdentity::FakeSSLIdentity(const FakeSSLCertificate& cert)
-    : cert_chain_(absl::make_unique<SSLCertChain>(&cert)) {}
+    : cert_chain_(absl::make_unique<SSLCertChain>(cert.Clone())) {}
 
 FakeSSLIdentity::FakeSSLIdentity(const FakeSSLIdentity& o)
-    : cert_chain_(o.cert_chain_->UniqueCopy()) {}
+    : cert_chain_(o.cert_chain_->Clone()) {}
 
 FakeSSLIdentity::~FakeSSLIdentity() = default;
 
diff --git a/rtc_base/fakesslidentity.h b/rtc_base/fakesslidentity.h
index 4494a52..b19cbfb 100644
--- a/rtc_base/fakesslidentity.h
+++ b/rtc_base/fakesslidentity.h
@@ -14,6 +14,7 @@
 #include <memory>
 #include <vector>
 
+#include "rtc_base/sslcertificate.h"
 #include "rtc_base/sslidentity.h"
 
 namespace rtc {
@@ -28,7 +29,7 @@
   ~FakeSSLCertificate() override;
 
   // SSLCertificate implementation.
-  FakeSSLCertificate* GetReference() const override;
+  std::unique_ptr<SSLCertificate> Clone() const override;
   std::string ToPEMString() const override;
   void ToDER(Buffer* der_buffer) const override;
   int64_t CertificateExpirationTime() const override;
diff --git a/rtc_base/file.h b/rtc_base/file.h
index 75fd93d..bc0974a 100644
--- a/rtc_base/file.h
+++ b/rtc_base/file.h
@@ -11,8 +11,8 @@
 #ifndef RTC_BASE_FILE_H_
 #define RTC_BASE_FILE_H_
 
+#include <stddef.h>
 #include <stdint.h>
-
 #include <string>
 
 #include "rtc_base/constructormagic.h"
diff --git a/rtc_base/file_posix.cc b/rtc_base/file_posix.cc
index b0fec9f..4920192 100644
--- a/rtc_base/file_posix.cc
+++ b/rtc_base/file_posix.cc
@@ -8,17 +8,16 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-#include "rtc_base/file.h"
-
 #include <errno.h>
 #include <fcntl.h>
-#include <sys/stat.h>
-#include <sys/types.h>
+#include <stddef.h>
+#include <stdint.h>
 #include <unistd.h>
-
 #include <limits>
 
 #include "rtc_base/checks.h"
+#include "rtc_base/file.h"
+#include "rtc_base/platform_file.h"
 
 namespace rtc {
 
diff --git a/rtc_base/filerotatingstream.cc b/rtc_base/filerotatingstream.cc
index 31b0051..d03ab39 100644
--- a/rtc_base/filerotatingstream.cc
+++ b/rtc_base/filerotatingstream.cc
@@ -13,18 +13,158 @@
 #include <algorithm>
 #include <cstdio>
 #include <string>
+#include <utility>
 
+#if defined(WEBRTC_WIN)
+#include <windows.h>
+#include "rtc_base/stringutils.h"
+#else
+#include <dirent.h>
+#include <sys/stat.h>
+#endif  // WEBRTC_WIN
+
+#include "absl/strings/match.h"
 #include "rtc_base/checks.h"
-#include "rtc_base/fileutils.h"
 #include "rtc_base/logging.h"
-#include "rtc_base/pathutils.h"
-#include "rtc_base/strings/string_builder.h"
 
 // Note: We use fprintf for logging in the write paths of this stream to avoid
 // infinite loops when logging.
 
 namespace rtc {
 
+namespace {
+
+std::string AddTrailingPathDelimiterIfNeeded(std::string directory);
+
+// |dir| must have a trailing delimiter. |prefix| must not include wild card
+// characters.
+std::vector<std::string> GetFilesWithPrefix(const std::string& directory,
+                                            const std::string& prefix);
+bool DeleteFile(const std::string& file);
+bool MoveFile(const std::string& old_file, const std::string& new_file);
+bool IsFile(const std::string& file);
+bool IsFolder(const std::string& file);
+absl::optional<size_t> GetFileSize(const std::string& file);
+
+#if defined(WEBRTC_WIN)
+
+std::string AddTrailingPathDelimiterIfNeeded(std::string directory) {
+  if (absl::EndsWith(directory, "\\")) {
+    return directory;
+  }
+  return directory + "\\";
+}
+
+std::vector<std::string> GetFilesWithPrefix(const std::string& directory,
+                                            const std::string& prefix) {
+  RTC_DCHECK(absl::EndsWith(directory, "\\"));
+  WIN32_FIND_DATA data;
+  HANDLE handle;
+  handle = ::FindFirstFile(ToUtf16(directory + prefix + '*').c_str(), &data);
+  if (handle == INVALID_HANDLE_VALUE)
+    return {};
+
+  std::vector<std::string> file_list;
+  do {
+    file_list.emplace_back(directory + ToUtf8(data.cFileName));
+  } while (::FindNextFile(handle, &data) == TRUE);
+
+  ::FindClose(handle);
+  return file_list;
+}
+
+bool DeleteFile(const std::string& file) {
+  return ::DeleteFile(ToUtf16(file).c_str()) != 0;
+}
+
+bool MoveFile(const std::string& old_file, const std::string& new_file) {
+  return ::MoveFile(ToUtf16(old_file).c_str(), ToUtf16(new_file).c_str()) != 0;
+}
+
+bool IsFile(const std::string& file) {
+  WIN32_FILE_ATTRIBUTE_DATA data = {0};
+  if (0 == ::GetFileAttributesEx(ToUtf16(file).c_str(), GetFileExInfoStandard,
+                                 &data))
+    return false;
+  return (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0;
+}
+
+bool IsFolder(const std::string& file) {
+  WIN32_FILE_ATTRIBUTE_DATA data = {0};
+  if (0 == ::GetFileAttributesEx(ToUtf16(file).c_str(), GetFileExInfoStandard,
+                                 &data))
+    return false;
+  return (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ==
+         FILE_ATTRIBUTE_DIRECTORY;
+}
+
+absl::optional<size_t> GetFileSize(const std::string& file) {
+  WIN32_FILE_ATTRIBUTE_DATA data = {0};
+  if (::GetFileAttributesEx(ToUtf16(file).c_str(), GetFileExInfoStandard,
+                            &data) == 0)
+    return absl::nullopt;
+  return data.nFileSizeLow;
+}
+
+#else  // defined(WEBRTC_WIN)
+
+std::string AddTrailingPathDelimiterIfNeeded(std::string directory) {
+  if (absl::EndsWith(directory, "/")) {
+    return directory;
+  }
+  return directory + "/";
+}
+
+std::vector<std::string> GetFilesWithPrefix(const std::string& directory,
+                                            const std::string& prefix) {
+  RTC_DCHECK(absl::EndsWith(directory, "/"));
+  DIR* dir = ::opendir(directory.c_str());
+  if (dir == nullptr)
+    return {};
+  std::vector<std::string> file_list;
+  for (struct dirent* dirent = ::readdir(dir); dirent;
+       dirent = ::readdir(dir)) {
+    std::string name = dirent->d_name;
+    if (name.compare(0, prefix.size(), prefix) == 0) {
+      file_list.emplace_back(directory + name);
+    }
+  }
+  ::closedir(dir);
+  return file_list;
+}
+
+bool DeleteFile(const std::string& file) {
+  return ::unlink(file.c_str()) == 0;
+}
+
+bool MoveFile(const std::string& old_file, const std::string& new_file) {
+  return ::rename(old_file.c_str(), new_file.c_str()) == 0;
+}
+
+bool IsFile(const std::string& file) {
+  struct stat st;
+  int res = ::stat(file.c_str(), &st);
+  // Treat symlinks, named pipes, etc. all as files.
+  return res == 0 && !S_ISDIR(st.st_mode);
+}
+
+bool IsFolder(const std::string& file) {
+  struct stat st;
+  int res = ::stat(file.c_str(), &st);
+  return res == 0 && S_ISDIR(st.st_mode);
+}
+
+absl::optional<size_t> GetFileSize(const std::string& file) {
+  struct stat st;
+  if (::stat(file.c_str(), &st) != 0)
+    return absl::nullopt;
+  return st.st_size;
+}
+
+#endif
+
+}  // namespace
+
 FileRotatingStream::FileRotatingStream(const std::string& dir_path,
                                        const std::string& file_prefix)
     : FileRotatingStream(dir_path, file_prefix, 0, 0, kRead) {}
@@ -47,7 +187,7 @@
                                        size_t max_file_size,
                                        size_t num_files,
                                        Mode mode)
-    : dir_path_(dir_path),
+    : dir_path_(AddTrailingPathDelimiterIfNeeded(dir_path)),
       file_prefix_(file_prefix),
       mode_(mode),
       file_stream_(nullptr),
@@ -56,7 +196,7 @@
       rotation_index_(0),
       current_bytes_written_(0),
       disable_buffering_(false) {
-  RTC_DCHECK(Filesystem::IsFolder(dir_path));
+  RTC_DCHECK(IsFolder(dir_path));
   switch (mode) {
     case kWrite: {
       file_names_.clear();
@@ -67,7 +207,7 @@
       break;
     }
     case kRead: {
-      file_names_ = GetFilesWithPrefix();
+      file_names_ = GetFilesWithPrefix(dir_path_, file_prefix_);
       std::sort(file_names_.begin(), file_names_.end());
       if (file_names_.size() > 0) {
         // |file_names_| is sorted newest first, so read from the end.
@@ -188,11 +328,7 @@
   *size = 0;
   size_t total_size = 0;
   for (auto file_name : file_names_) {
-    Pathname pathname(file_name);
-    size_t file_size = 0;
-    if (Filesystem::GetFileSize(file_name, &file_size)) {
-      total_size += file_size;
-    }
+    total_size += GetFileSize(file_name).value_or(0);
   }
   *size = total_size;
   return true;
@@ -210,9 +346,10 @@
       return true;
     case kWrite: {
       // Delete existing files when opening for write.
-      std::vector<std::string> matching_files = GetFilesWithPrefix();
-      for (auto matching_file : matching_files) {
-        if (!Filesystem::DeleteFile(matching_file)) {
+      std::vector<std::string> matching_files =
+          GetFilesWithPrefix(dir_path_, file_prefix_);
+      for (const auto& matching_file : matching_files) {
+        if (!DeleteFile(matching_file)) {
           std::fprintf(stderr, "Failed to delete: %s\n", matching_file.c_str());
         }
       }
@@ -283,16 +420,16 @@
   // See header file comments for example.
   RTC_DCHECK_LT(rotation_index_, file_names_.size());
   std::string file_to_delete = file_names_[rotation_index_];
-  if (Filesystem::IsFile(file_to_delete)) {
-    if (!Filesystem::DeleteFile(file_to_delete)) {
+  if (IsFile(file_to_delete)) {
+    if (!DeleteFile(file_to_delete)) {
       std::fprintf(stderr, "Failed to delete: %s\n", file_to_delete.c_str());
     }
   }
   for (auto i = rotation_index_; i > 0; --i) {
     std::string rotated_name = file_names_[i];
     std::string unrotated_name = file_names_[i - 1];
-    if (Filesystem::IsFile(unrotated_name)) {
-      if (!Filesystem::MoveFile(unrotated_name, rotated_name)) {
+    if (IsFile(unrotated_name)) {
+      if (!MoveFile(unrotated_name, rotated_name)) {
         std::fprintf(stderr, "Failed to move: %s to %s\n",
                      unrotated_name.c_str(), rotated_name.c_str());
       }
@@ -303,26 +440,6 @@
   OnRotation();
 }
 
-std::vector<std::string> FileRotatingStream::GetFilesWithPrefix() const {
-  std::vector<std::string> files;
-  // Iterate over the files in the directory.
-  DirectoryIterator it;
-  Pathname dir_path;
-  dir_path.SetFolder(dir_path_);
-  if (!it.Iterate(dir_path)) {
-    return files;
-  }
-  do {
-    std::string current_name = it.Name();
-    if (current_name.size() && !it.IsDirectory() &&
-        current_name.compare(0, file_prefix_.size(), file_prefix_) == 0) {
-      Pathname path(dir_path_, current_name);
-      files.push_back(path.pathname());
-    }
-  } while (it.Next());
-  return files;
-}
-
 std::string FileRotatingStream::GetFilePath(size_t index,
                                             size_t num_files) const {
   RTC_DCHECK_LT(index, num_files);
@@ -334,8 +451,7 @@
   RTC_DCHECK_LT(1 + max_digits, buffer_size);
   std::snprintf(file_postfix, buffer_size, "_%0*zu", max_digits, index);
 
-  Pathname file_path(dir_path_, file_prefix_ + file_postfix);
-  return file_path.pathname();
+  return dir_path_ + file_prefix_ + file_postfix;
 }
 
 CallSessionFileRotatingStream::CallSessionFileRotatingStream(
diff --git a/rtc_base/filerotatingstream.h b/rtc_base/filerotatingstream.h
index 4dab345..c75ee15 100644
--- a/rtc_base/filerotatingstream.h
+++ b/rtc_base/filerotatingstream.h
@@ -11,6 +11,7 @@
 #ifndef RTC_BASE_FILEROTATINGSTREAM_H_
 #define RTC_BASE_FILEROTATINGSTREAM_H_
 
+#include <stddef.h>
 #include <memory>
 #include <string>
 #include <vector>
@@ -101,8 +102,6 @@
   // create new file_0
   void RotateFiles();
 
-  // Returns a list of file names in the directory beginning with the prefix.
-  std::vector<std::string> GetFilesWithPrefix() const;
   // Private version of GetFilePath.
   std::string GetFilePath(size_t index, size_t num_files) const;
 
diff --git a/rtc_base/filerotatingstream_unittest.cc b/rtc_base/filerotatingstream_unittest.cc
index 1905516..172be57 100644
--- a/rtc_base/filerotatingstream_unittest.cc
+++ b/rtc_base/filerotatingstream_unittest.cc
@@ -13,9 +13,7 @@
 #include "rtc_base/arraysize.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/filerotatingstream.h"
-#include "rtc_base/fileutils.h"
 #include "rtc_base/gunit.h"
-#include "rtc_base/pathutils.h"
 #include "test/testsupport/fileutils.h"
 
 namespace rtc {
@@ -46,12 +44,15 @@
   void Init(const std::string& dir_name,
             const std::string& file_prefix,
             size_t max_file_size,
-            size_t num_log_files) {
+            size_t num_log_files,
+            bool ensure_trailing_delimiter = true) {
     dir_path_ = webrtc::test::OutputPath();
 
     // Append per-test output path in order to run within gtest parallel.
     dir_path_.append(dir_name);
-    dir_path_.push_back(Pathname::DefaultFolderDelimiter());
+    if (ensure_trailing_delimiter) {
+      dir_path_.append(webrtc::test::kPathDelimiter);
+    }
     ASSERT_TRUE(webrtc::test::CreateDir(dir_path_));
     stream_.reset(new FileRotatingStream(dir_path_, file_prefix, max_file_size,
                                          num_log_files));
@@ -159,12 +160,12 @@
   }
   // Check that exactly three files exist.
   for (size_t i = 0; i < arraysize(messages); ++i) {
-    EXPECT_TRUE(Filesystem::IsFile(stream_->GetFilePath(i)));
+    EXPECT_TRUE(webrtc::test::FileExists(stream_->GetFilePath(i)));
   }
   std::string message("d");
   WriteAndFlush(message.c_str(), message.size());
   for (size_t i = 0; i < arraysize(messages); ++i) {
-    EXPECT_TRUE(Filesystem::IsFile(stream_->GetFilePath(i)));
+    EXPECT_TRUE(webrtc::test::FileExists(stream_->GetFilePath(i)));
   }
   // TODO(tkchin): Maybe check all the files in the dir.
 
@@ -174,6 +175,53 @@
                    dir_path_, kFilePrefix);
 }
 
+// Tests that a write operation (with dir name without delimiter) followed by a
+// read returns the expected data and writes to the expected files.
+TEST_F(MAYBE_FileRotatingStreamTest, WriteWithoutDelimiterAndRead) {
+  Init("FileRotatingStreamTestWriteWithoutDelimiterAndRead", kFilePrefix,
+       kMaxFileSize, 3,
+       /* ensure_trailing_delimiter*/ false);
+
+  ASSERT_TRUE(stream_->Open());
+  // The test is set up to create three log files of length 2. Write and check
+  // contents.
+  std::string messages[3] = {"aa", "bb", "cc"};
+  for (size_t i = 0; i < arraysize(messages); ++i) {
+    const std::string& message = messages[i];
+    WriteAndFlush(message.c_str(), message.size());
+  }
+  std::string message("d");
+  WriteAndFlush(message.c_str(), message.size());
+
+  // Reopen for read.
+  std::string expected_contents("bbccd");
+  VerifyStreamRead(expected_contents.c_str(), expected_contents.size(),
+                   dir_path_ + webrtc::test::kPathDelimiter, kFilePrefix);
+}
+
+// Tests that a write operation followed by a read (without trailing delimiter)
+// returns the expected data and writes to the expected files.
+TEST_F(MAYBE_FileRotatingStreamTest, WriteAndReadWithoutDelimiter) {
+  Init("FileRotatingStreamTestWriteAndReadWithoutDelimiter", kFilePrefix,
+       kMaxFileSize, 3);
+
+  ASSERT_TRUE(stream_->Open());
+  // The test is set up to create three log files of length 2. Write and check
+  // contents.
+  std::string messages[3] = {"aa", "bb", "cc"};
+  for (size_t i = 0; i < arraysize(messages); ++i) {
+    const std::string& message = messages[i];
+    WriteAndFlush(message.c_str(), message.size());
+  }
+  std::string message("d");
+  WriteAndFlush(message.c_str(), message.size());
+
+  // Reopen for read.
+  std::string expected_contents("bbccd");
+  VerifyStreamRead(expected_contents.c_str(), expected_contents.size(),
+                   dir_path_.substr(0, dir_path_.size() - 1), kFilePrefix);
+}
+
 // Tests that writing data greater than the total capacity of the files
 // overwrites the files correctly and is read correctly after.
 TEST_F(MAYBE_FileRotatingStreamTest, WriteOverflowAndRead) {
@@ -218,7 +266,7 @@
 
     // Append per-test output path in order to run within gtest parallel.
     dir_path_.append(dir_name);
-    dir_path_.push_back(Pathname::DefaultFolderDelimiter());
+    dir_path_.append(webrtc::test::kPathDelimiter);
     ASSERT_TRUE(webrtc::test::CreateDir(dir_path_));
     stream_.reset(
         new CallSessionFileRotatingStream(dir_path_, max_total_log_size));
diff --git a/rtc_base/fileutils.cc b/rtc_base/fileutils.cc
deleted file mode 100644
index 0adbbac..0000000
--- a/rtc_base/fileutils.cc
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- *  Copyright 2004 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 "rtc_base/fileutils.h"
-
-#include "rtc_base/checks.h"
-#include "rtc_base/pathutils.h"
-
-#if defined(WEBRTC_WIN)
-#include "rtc_base/stringutils.h"  // for ToUtf16
-#include "rtc_base/win32filesystem.h"
-#else
-#include "rtc_base/unixfilesystem.h"
-#endif
-
-#if !defined(WEBRTC_WIN)
-#define MAX_PATH 260
-#endif
-
-namespace rtc {
-
-//////////////////////////
-// Directory Iterator   //
-//////////////////////////
-
-// A DirectoryIterator is created with a given directory. It originally points
-// to the first file in the directory, and can be advanecd with Next(). This
-// allows you to get information about each file.
-
-// Constructor
-DirectoryIterator::DirectoryIterator()
-#ifdef WEBRTC_WIN
-    : handle_(INVALID_HANDLE_VALUE) {
-#else
-    : dir_(nullptr),
-      dirent_(nullptr){
-#endif
-}
-
-// Destructor
-DirectoryIterator::~DirectoryIterator() {
-#if defined(WEBRTC_WIN)
-  if (handle_ != INVALID_HANDLE_VALUE)
-    ::FindClose(handle_);
-#else
-  if (dir_)
-    closedir(dir_);
-#endif
-}
-
-// Starts traversing a directory.
-// dir is the directory to traverse
-// returns true if the directory exists and is valid
-bool DirectoryIterator::Iterate(const Pathname& dir) {
-  directory_ = dir.pathname();
-#if defined(WEBRTC_WIN)
-  if (handle_ != INVALID_HANDLE_VALUE)
-    ::FindClose(handle_);
-  std::string d = dir.pathname() + '*';
-  handle_ = ::FindFirstFile(ToUtf16(d).c_str(), &data_);
-  if (handle_ == INVALID_HANDLE_VALUE)
-    return false;
-#else
-  if (dir_ != nullptr)
-    closedir(dir_);
-  dir_ = ::opendir(directory_.c_str());
-  if (dir_ == nullptr)
-    return false;
-  dirent_ = readdir(dir_);
-  if (dirent_ == nullptr)
-    return false;
-
-  if (::stat(std::string(directory_ + Name()).c_str(), &stat_) != 0)
-    return false;
-#endif
-  return true;
-}
-
-// Advances to the next file
-// returns true if there were more files in the directory.
-bool DirectoryIterator::Next() {
-#if defined(WEBRTC_WIN)
-  return ::FindNextFile(handle_, &data_) == TRUE;
-#else
-  dirent_ = ::readdir(dir_);
-  if (dirent_ == nullptr)
-    return false;
-
-  return ::stat(std::string(directory_ + Name()).c_str(), &stat_) == 0;
-#endif
-}
-
-// returns true if the file currently pointed to is a directory
-bool DirectoryIterator::IsDirectory() const {
-#if defined(WEBRTC_WIN)
-  return (data_.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != FALSE;
-#else
-  return S_ISDIR(stat_.st_mode);
-#endif
-}
-
-// returns the name of the file currently pointed to
-std::string DirectoryIterator::Name() const {
-#if defined(WEBRTC_WIN)
-  return ToUtf8(data_.cFileName);
-#else
-  RTC_DCHECK(dirent_);
-  return dirent_->d_name;
-#endif
-}
-
-FilesystemInterface* Filesystem::GetFilesystem() {
-#if defined(WEBRTC_WIN)
-  static FilesystemInterface* const filesystem = new Win32Filesystem();
-#else
-  static FilesystemInterface* const filesystem = new UnixFilesystem();
-#endif
-
-  return filesystem;
-}
-
-}  // namespace rtc
diff --git a/rtc_base/fileutils.h b/rtc_base/fileutils.h
deleted file mode 100644
index f7afaf9..0000000
--- a/rtc_base/fileutils.h
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- *  Copyright 2004 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 RTC_BASE_FILEUTILS_H_
-#define RTC_BASE_FILEUTILS_H_
-
-#include <string>
-
-#if defined(WEBRTC_WIN)
-#include <windows.h>
-#else
-#include <dirent.h>
-#include <stdio.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-#endif  // WEBRTC_WIN
-
-#include "rtc_base/constructormagic.h"
-
-namespace rtc {
-
-class FileStream;
-class Pathname;
-
-//////////////////////////
-// Directory Iterator   //
-//////////////////////////
-
-// A DirectoryIterator is created with a given directory. It originally points
-// to the first file in the directory, and can be advanecd with Next(). This
-// allows you to get information about each file.
-
-class DirectoryIterator {
-  friend class Filesystem;
-
- public:
-  // Constructor
-  DirectoryIterator();
-  // Destructor
-  virtual ~DirectoryIterator();
-
-  // Starts traversing a directory
-  // dir is the directory to traverse
-  // returns true if the directory exists and is valid
-  // The iterator will point to the first entry in the directory
-  virtual bool Iterate(const Pathname& path);
-
-  // Advances to the next file
-  // returns true if there were more files in the directory.
-  virtual bool Next();
-
-  // returns true if the file currently pointed to is a directory
-  virtual bool IsDirectory() const;
-
-  // returns the name of the file currently pointed to
-  virtual std::string Name() const;
-
- private:
-  std::string directory_;
-#if defined(WEBRTC_WIN)
-  WIN32_FIND_DATA data_;
-  HANDLE handle_;
-#else
-  DIR* dir_;
-  struct dirent* dirent_;
-  struct stat stat_;
-#endif
-};
-
-class FilesystemInterface {
- public:
-  virtual ~FilesystemInterface() {}
-
-  // This will attempt to delete the path located at filename.
-  // It DCHECKs and returns false if the path points to a folder or a
-  // non-existent file.
-  virtual bool DeleteFile(const Pathname& filename) = 0;
-
-  // This moves a file from old_path to new_path, where "old_path" is a
-  // plain file. This DCHECKs and returns false if old_path points to a
-  // directory, and returns true if the function succeeds.
-  virtual bool MoveFile(const Pathname& old_path, const Pathname& new_path) = 0;
-
-  // Returns true if pathname refers to a directory
-  virtual bool IsFolder(const Pathname& pathname) = 0;
-
-  // Returns true if pathname refers to a file
-  virtual bool IsFile(const Pathname& pathname) = 0;
-
-  // Determines the size of the file indicated by path.
-  virtual bool GetFileSize(const Pathname& path, size_t* size) = 0;
-};
-
-class Filesystem {
- public:
-  static bool DeleteFile(const Pathname& filename) {
-    return GetFilesystem()->DeleteFile(filename);
-  }
-
-  static bool MoveFile(const Pathname& old_path, const Pathname& new_path) {
-    return GetFilesystem()->MoveFile(old_path, new_path);
-  }
-
-  static bool IsFolder(const Pathname& pathname) {
-    return GetFilesystem()->IsFolder(pathname);
-  }
-
-  static bool IsFile(const Pathname& pathname) {
-    return GetFilesystem()->IsFile(pathname);
-  }
-
-  static bool GetFileSize(const Pathname& path, size_t* size) {
-    return GetFilesystem()->GetFileSize(path, size);
-  }
-
- private:
-  static FilesystemInterface* GetFilesystem();
-  RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(Filesystem);
-};
-
-}  // namespace rtc
-
-#endif  // RTC_BASE_FILEUTILS_H_
diff --git a/rtc_base/flags.h b/rtc_base/flags.h
index 1c476d8..a08bfd2 100644
--- a/rtc_base/flags.h
+++ b/rtc_base/flags.h
@@ -36,7 +36,7 @@
   // bool values ('bool b = "false";' results in b == true!), we pass
   // and int argument to New_BOOL as this appears to be safer - sigh.
   // In particular, it prevents the (not uncommon!) bug where a bool
-  // flag is defined via: DEFINE_bool(flag, "false", "some comment");.
+  // flag is defined via: WEBRTC_DEFINE_bool(flag, "false", "some comment");.
   static FlagValue New_BOOL(int b) {
     FlagValue v;
     v.b = (b != 0);
@@ -155,7 +155,7 @@
 };
 
 // Internal use only.
-#define DEFINE_FLAG(type, c_type, name, default, comment)                   \
+#define WEBRTC_DEFINE_FLAG(type, c_type, name, default, comment)            \
   /* define and initialize the flag */                                      \
   c_type FLAG_##name = (default);                                           \
   /* register the flag */                                                   \
@@ -164,25 +164,25 @@
                                rtc::FlagValue::New_##type(default))
 
 // Internal use only.
-#define DECLARE_FLAG(c_type, name) \
-  /* declare the external flag */  \
+#define WEBRTC_DECLARE_FLAG(c_type, name) \
+  /* declare the external flag */         \
   extern c_type FLAG_##name
 
 // Use the following macros to define a new flag:
-#define DEFINE_bool(name, default, comment) \
-  DEFINE_FLAG(BOOL, bool, name, default, comment)
-#define DEFINE_int(name, default, comment) \
-  DEFINE_FLAG(INT, int, name, default, comment)
-#define DEFINE_float(name, default, comment) \
-  DEFINE_FLAG(FLOAT, double, name, default, comment)
-#define DEFINE_string(name, default, comment) \
-  DEFINE_FLAG(STRING, const char*, name, default, comment)
+#define WEBRTC_DEFINE_bool(name, default, comment) \
+  WEBRTC_DEFINE_FLAG(BOOL, bool, name, default, comment)
+#define WEBRTC_DEFINE_int(name, default, comment) \
+  WEBRTC_DEFINE_FLAG(INT, int, name, default, comment)
+#define WEBRTC_DEFINE_float(name, default, comment) \
+  WEBRTC_DEFINE_FLAG(FLOAT, double, name, default, comment)
+#define WEBRTC_DEFINE_string(name, default, comment) \
+  WEBRTC_DEFINE_FLAG(STRING, const char*, name, default, comment)
 
 // Use the following macros to declare a flag defined elsewhere:
-#define DECLARE_bool(name) DECLARE_FLAG(bool, name)
-#define DECLARE_int(name) DECLARE_FLAG(int, name)
-#define DECLARE_float(name) DECLARE_FLAG(double, name)
-#define DECLARE_string(name) DECLARE_FLAG(const char*, name)
+#define WEBRTC_DECLARE_bool(name) WEBRTC_DECLARE_FLAG(bool, name)
+#define WEBRTC_DECLARE_int(name) WEBRTC_DECLARE_FLAG(int, name)
+#define WEBRTC_DECLARE_float(name) WEBRTC_DECLARE_FLAG(double, name)
+#define WEBRTC_DECLARE_string(name) WEBRTC_DECLARE_FLAG(const char*, name)
 
 // The global list of all flags.
 class FlagList {
diff --git a/rtc_base/helpers.h b/rtc_base/helpers.h
index d3b09cf..a93b321 100644
--- a/rtc_base/helpers.h
+++ b/rtc_base/helpers.h
@@ -11,6 +11,8 @@
 #ifndef RTC_BASE_HELPERS_H_
 #define RTC_BASE_HELPERS_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <string>
 
 namespace rtc {
diff --git a/rtc_base/httpcommon.cc b/rtc_base/httpcommon.cc
index 43831b7..7926f88 100644
--- a/rtc_base/httpcommon.cc
+++ b/rtc_base/httpcommon.cc
@@ -24,6 +24,7 @@
 #include <utility>  // for pair
 #include <vector>
 
+#include "absl/strings/match.h"
 #include "rtc_base/arraysize.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/cryptstring.h"  // for CryptString
@@ -32,7 +33,6 @@
 #include "rtc_base/messagedigest.h"
 #include "rtc_base/socketaddress.h"
 #include "rtc_base/strings/string_builder.h"
-#include "rtc_base/stringutils.h"                // for strcpyn, _stricmp
 #include "rtc_base/third_party/base64/base64.h"  // for Base64
 #include "rtc_base/zero_memory.h"                // for ExplicitZeroMemory
 
@@ -266,7 +266,7 @@
     return HAR_IGNORE;
 
   // BASIC
-  if (_stricmp(auth_method.c_str(), "basic") == 0) {
+  if (absl::EqualsIgnoreCase(auth_method, "basic")) {
     if (context)
       return HAR_CREDENTIALS;  // Bad credentials
     if (username.empty())
@@ -294,7 +294,7 @@
   }
 
   // DIGEST
-  if (_stricmp(auth_method.c_str(), "digest") == 0) {
+  if (absl::EqualsIgnoreCase(auth_method, "digest")) {
     if (context)
       return HAR_CREDENTIALS;  // Bad credentials
     if (username.empty())
@@ -361,8 +361,8 @@
 
 #if defined(WEBRTC_WIN)
 #if 1
-  bool want_negotiate = (_stricmp(auth_method.c_str(), "negotiate") == 0);
-  bool want_ntlm = (_stricmp(auth_method.c_str(), "ntlm") == 0);
+  bool want_negotiate = absl::EqualsIgnoreCase(auth_method, "negotiate");
+  bool want_ntlm = absl::EqualsIgnoreCase(auth_method, "ntlm");
   // SPNEGO & NTLM
   if (want_negotiate || want_ntlm) {
     const size_t MAX_MESSAGE = 12000, MAX_SPN = 256;
@@ -377,7 +377,7 @@
       return HAR_IGNORE;
     }
 #else
-    sprintfn(spn, MAX_SPN, "HTTP/%s", server.ToString().c_str());
+    snprintf(spn, MAX_SPN, "HTTP/%s", server.ToString().c_str());
 #endif
 
     SecBuffer out_sec;
diff --git a/rtc_base/ipaddress.cc b/rtc_base/ipaddress.cc
index c52c9a4..027a7b2 100644
--- a/rtc_base/ipaddress.cc
+++ b/rtc_base/ipaddress.cc
@@ -11,24 +11,17 @@
 #if defined(WEBRTC_POSIX)
 #include <netinet/in.h>
 #include <sys/socket.h>
-#include <sys/types.h>
 #ifdef OPENBSD
 #include <netinet/in_systm.h>
 #endif
 #ifndef __native_client__
 #include <netinet/ip.h>
 #endif
-#include <arpa/inet.h>
 #include <netdb.h>
-#include <unistd.h>
 #endif
 
-#include <stdio.h>
-
 #include "rtc_base/byteorder.h"
-#include "rtc_base/checks.h"
 #include "rtc_base/ipaddress.h"
-#include "rtc_base/logging.h"
 #include "rtc_base/nethelpers.h"
 #include "rtc_base/stringutils.h"
 
@@ -162,11 +155,10 @@
       std::string result;
       result.resize(INET6_ADDRSTRLEN);
       in6_addr addr = ipv6_address();
-      size_t len =
-          rtc::sprintfn(&(result[0]), result.size(), "%x:%x:%x:x:x:x:x:x",
-                        (addr.s6_addr[0] << 8) + addr.s6_addr[1],
-                        (addr.s6_addr[2] << 8) + addr.s6_addr[3],
-                        (addr.s6_addr[4] << 8) + addr.s6_addr[5]);
+      size_t len = snprintf(&(result[0]), result.size(), "%x:%x:%x:x:x:x:x:x",
+                            (addr.s6_addr[0] << 8) + addr.s6_addr[1],
+                            (addr.s6_addr[2] << 8) + addr.s6_addr[3],
+                            (addr.s6_addr[4] << 8) + addr.s6_addr[5]);
       result.resize(len);
       return result;
     }
diff --git a/rtc_base/key_derivation.cc b/rtc_base/key_derivation.cc
new file mode 100644
index 0000000..288e407
--- /dev/null
+++ b/rtc_base/key_derivation.cc
@@ -0,0 +1,31 @@
+/*
+ *  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.
+ */
+
+#include "rtc_base/key_derivation.h"
+
+#include "absl/memory/memory.h"
+#include "rtc_base/openssl_key_derivation_hkdf.h"
+
+namespace rtc {
+
+KeyDerivation::KeyDerivation() = default;
+KeyDerivation::~KeyDerivation() = default;
+
+// static
+std::unique_ptr<KeyDerivation> KeyDerivation::Create(
+    KeyDerivationAlgorithm key_derivation_algorithm) {
+  switch (key_derivation_algorithm) {
+    case KeyDerivationAlgorithm::HKDF_SHA256:
+      return absl::make_unique<OpenSSLKeyDerivationHKDF>();
+  }
+  RTC_NOTREACHED();
+}
+
+}  // namespace rtc
diff --git a/rtc_base/key_derivation.h b/rtc_base/key_derivation.h
new file mode 100644
index 0000000..fa329ae
--- /dev/null
+++ b/rtc_base/key_derivation.h
@@ -0,0 +1,70 @@
+/*
+ *  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 RTC_BASE_KEY_DERIVATION_H_
+#define RTC_BASE_KEY_DERIVATION_H_
+
+#include <memory>
+
+#include "absl/types/optional.h"
+#include "api/array_view.h"
+#include "rtc_base/buffer.h"
+#include "rtc_base/constructormagic.h"
+
+namespace rtc {
+
+// Defines the set of key derivation algorithms that are supported. It is ideal
+// to keep this list as small as possible.
+enum class KeyDerivationAlgorithm {
+  // This algorithm is not suitable to generate a key from a password. Please
+  // only use with a cryptographically random master secret.
+  HKDF_SHA256
+};
+
+// KeyDerivation provides a generic interface for deriving keys in WebRTC. This
+// class should be used over directly accessing openssl or boringssl primitives
+// so that we can maintain seperate implementations.
+// Example:
+//   auto kd = KeyDerivation::Create(KeyDerivationAlgorithm::HDKF_SHA526);
+//   if (kd == nullptr) return;
+//   auto derived_key_or = kd->DeriveKey(secret, salt, label);
+//   if (!derived_key_or.ok()) return;
+//   DoSomethingWithKey(derived_key_or.value());
+class KeyDerivation {
+ public:
+  KeyDerivation();
+  virtual ~KeyDerivation();
+
+  // Derives a new key from existing key material.
+  // secret - The random secret value you wish to derive a key from.
+  // salt - Optional but recommended (non secret) cryptographically random.
+  // label - A non secret but unique label value to determine the derivation.
+  // derived_key_byte_size - This must be at least 128 bits.
+  // return - An optional ZeroOnFreeBuffer containing the derived key or
+  // absl::nullopt. Nullopt indicates a failure in derivation.
+  virtual absl::optional<ZeroOnFreeBuffer<uint8_t>> DeriveKey(
+      rtc::ArrayView<const uint8_t> secret,
+      rtc::ArrayView<const uint8_t> salt,
+      rtc::ArrayView<const uint8_t> label,
+      size_t derived_key_byte_size) = 0;
+
+  // Static factory that will return an implementation that is capable of
+  // handling the key derivation with the requested algorithm. If no
+  // implementation is available nullptr will be returned.
+  static std::unique_ptr<KeyDerivation> Create(
+      KeyDerivationAlgorithm key_derivation_algorithm);
+
+ private:
+  RTC_DISALLOW_COPY_AND_ASSIGN(KeyDerivation);
+};
+
+}  // namespace rtc
+
+#endif  // RTC_BASE_KEY_DERIVATION_H_
diff --git a/rtc_base/location.cc b/rtc_base/location.cc
index 9c90d9e..c95ad9c 100644
--- a/rtc_base/location.cc
+++ b/rtc_base/location.cc
@@ -10,8 +10,6 @@
 
 #include "rtc_base/location.h"
 
-#include "rtc_base/stringutils.h"
-
 namespace rtc {
 
 Location::Location(const char* function_name, const char* file_and_line)
@@ -31,7 +29,7 @@
 
 std::string Location::ToString() const {
   char buf[256];
-  sprintfn(buf, sizeof(buf), "%s@%s", function_name_, file_and_line_);
+  snprintf(buf, sizeof(buf), "%s@%s", function_name_, file_and_line_);
   return buf;
 }
 
diff --git a/rtc_base/logging.cc b/rtc_base/logging.cc
index 53a1ed8..bb4fbfa 100644
--- a/rtc_base/logging.cc
+++ b/rtc_base/logging.cc
@@ -20,24 +20,28 @@
 #include <CoreServices/CoreServices.h>
 #elif defined(WEBRTC_ANDROID)
 #include <android/log.h>
+
 // Android has a 1024 limit on log inputs. We use 60 chars as an
 // approx for the header/tag portion.
 // See android/system/core/liblog/logd_write.c
 static const int kMaxLogLineSize = 1024 - 60;
 #endif  // WEBRTC_MAC && !defined(WEBRTC_IOS) || WEBRTC_ANDROID
 
+#include <stdio.h>
+#include <string.h>
 #include <time.h>
-
 #include <algorithm>
 #include <cstdarg>
 #include <vector>
 
+#include "rtc_base/checks.h"
 #include "rtc_base/criticalsection.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/platform_thread_types.h"
 #include "rtc_base/stringencode.h"
 #include "rtc_base/strings/string_builder.h"
 #include "rtc_base/stringutils.h"
+#include "rtc_base/thread_annotations.h"
 #include "rtc_base/timeutils.h"
 
 namespace rtc {
@@ -69,7 +73,12 @@
 void LogSink::OnLogMessage(const std::string& msg,
                            LoggingSeverity severity,
                            const char* tag) {
-  OnLogMessage(tag + (": " + msg));
+  OnLogMessage(tag + (": " + msg), severity);
+}
+
+void LogSink::OnLogMessage(const std::string& msg,
+                           LoggingSeverity /* severity */) {
+  OnLogMessage(msg);
 }
 
 /////////////////////////////////////////////////////////////////////////////
@@ -202,7 +211,7 @@
 #if defined(WEBRTC_ANDROID)
       kv.first->OnLogMessage(str, severity_, tag_);
 #else
-      kv.first->OnLogMessage(str);
+      kv.first->OnLogMessage(str, severity_);
 #endif
     }
   }
diff --git a/rtc_base/logging.h b/rtc_base/logging.h
index 4292971..c15c37a 100644
--- a/rtc_base/logging.h
+++ b/rtc_base/logging.h
@@ -115,6 +115,8 @@
   virtual void OnLogMessage(const std::string& msg,
                             LoggingSeverity severity,
                             const char* tag);
+  virtual void OnLogMessage(const std::string& message,
+                            LoggingSeverity severity);
   virtual void OnLogMessage(const std::string& message) = 0;
 };
 
diff --git a/rtc_base/logging_unittest.cc b/rtc_base/logging_unittest.cc
index a475e52..4de1cf2 100644
--- a/rtc_base/logging_unittest.cc
+++ b/rtc_base/logging_unittest.cc
@@ -292,7 +292,7 @@
   static void ThreadEntry(void* p) { static_cast<LogThread*>(p)->Run(); }
 
   PlatformThread thread_;
-  Event event_{false, false};
+  Event event_;
 };
 
 // Ensure we don't crash when adding/removing streams while threads are going.
diff --git a/rtc_base/logsinks.cc b/rtc_base/logsinks.cc
index 662b1f2..c01bafb 100644
--- a/rtc_base/logsinks.cc
+++ b/rtc_base/logsinks.cc
@@ -10,10 +10,12 @@
 
 #include "rtc_base/logsinks.h"
 
+#include <string.h>
 #include <cstdio>
 #include <string>
 
 #include "rtc_base/checks.h"
+#include "rtc_base/stream.h"
 
 namespace rtc {
 
diff --git a/rtc_base/logsinks.h b/rtc_base/logsinks.h
index caf4a5f..d0867a2 100644
--- a/rtc_base/logsinks.h
+++ b/rtc_base/logsinks.h
@@ -11,6 +11,7 @@
 #ifndef RTC_BASE_LOGSINKS_H_
 #define RTC_BASE_LOGSINKS_H_
 
+#include <stddef.h>
 #include <memory>
 #include <string>
 
diff --git a/rtc_base/mdns_responder_interface.h b/rtc_base/mdns_responder_interface.h
index 9dbaf56..71938b2 100644
--- a/rtc_base/mdns_responder_interface.h
+++ b/rtc_base/mdns_responder_interface.h
@@ -12,36 +12,35 @@
 #define RTC_BASE_MDNS_RESPONDER_INTERFACE_H_
 
 #include <functional>
-#include <map>
-#include <memory>
-#include <set>
 #include <string>
 
 #include "rtc_base/ipaddress.h"
-#include "rtc_base/socketaddress.h"
 
 namespace webrtc {
 
 // Defines an mDNS responder that can be used in ICE candidate gathering, where
-// the local IP addresses of host candidates are obfuscated by mDNS hostnames.
-class MDnsResponderInterface {
+// the local IP addresses of host candidates are replaced by mDNS hostnames.
+class MdnsResponderInterface {
  public:
   using NameCreatedCallback =
       std::function<void(const rtc::IPAddress&, const std::string&)>;
   using NameRemovedCallback = std::function<void(bool)>;
 
-  MDnsResponderInterface() = default;
-  virtual ~MDnsResponderInterface() = default;
+  MdnsResponderInterface() = default;
+  virtual ~MdnsResponderInterface() = default;
 
-  // Asynchronously creates a type-4 UUID hostname for an IP address. The
-  // created name should be given to |callback| with the address that it
-  // represents.
+  // Asynchronously creates and returns a new name via |callback| for |addr| if
+  // there is no name mapped to it by this responder, and initializes the
+  // reference count of this name to one. Otherwise the existing name mapped to
+  // |addr| is returned and its reference count is incremented by one.
   virtual void CreateNameForAddress(const rtc::IPAddress& addr,
                                     NameCreatedCallback callback) = 0;
-  // Removes the name mapped to the given address if there is such an
-  // name-address mapping previously created via CreateNameForAddress. The
-  // result of whether an associated name-address mapping is removed should be
-  // given to |callback|.
+  // Decrements the reference count of the mapped name of |addr|, if
+  // there is a map created previously via CreateNameForAddress; asynchronously
+  // removes the association between |addr| and its mapped name, and returns
+  // true via |callback| if the decremented reference count reaches zero.
+  // Otherwise no operation is done and false is returned via |callback|
+  // asynchronously.
   virtual void RemoveNameForAddress(const rtc::IPAddress& addr,
                                     NameRemovedCallback callback) = 0;
 };
diff --git a/rtc_base/memory_stream.cc b/rtc_base/memory_stream.cc
new file mode 100644
index 0000000..541de07
--- /dev/null
+++ b/rtc_base/memory_stream.cc
@@ -0,0 +1,143 @@
+/*
+ *  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.
+ */
+
+#include <algorithm>
+
+#include "rtc_base/memory_stream.h"
+
+namespace rtc {
+
+StreamState MemoryStream::GetState() const {
+  return SS_OPEN;
+}
+
+StreamResult MemoryStream::Read(void* buffer,
+                                size_t bytes,
+                                size_t* bytes_read,
+                                int* error) {
+  if (seek_position_ >= data_length_) {
+    return SR_EOS;
+  }
+  size_t available = data_length_ - seek_position_;
+  if (bytes > available) {
+    // Read partial buffer
+    bytes = available;
+  }
+  memcpy(buffer, &buffer_[seek_position_], bytes);
+  seek_position_ += bytes;
+  if (bytes_read) {
+    *bytes_read = bytes;
+  }
+  return SR_SUCCESS;
+}
+
+StreamResult MemoryStream::Write(const void* buffer,
+                                 size_t bytes,
+                                 size_t* bytes_written,
+                                 int* error) {
+  size_t available = buffer_length_ - seek_position_;
+  if (0 == available) {
+    // Increase buffer size to the larger of:
+    // a) new position rounded up to next 256 bytes
+    // b) double the previous length
+    size_t new_buffer_length =
+        std::max(((seek_position_ + bytes) | 0xFF) + 1, buffer_length_ * 2);
+    StreamResult result = DoReserve(new_buffer_length, error);
+    if (SR_SUCCESS != result) {
+      return result;
+    }
+    RTC_DCHECK(buffer_length_ >= new_buffer_length);
+    available = buffer_length_ - seek_position_;
+  }
+
+  if (bytes > available) {
+    bytes = available;
+  }
+  memcpy(&buffer_[seek_position_], buffer, bytes);
+  seek_position_ += bytes;
+  if (data_length_ < seek_position_) {
+    data_length_ = seek_position_;
+  }
+  if (bytes_written) {
+    *bytes_written = bytes;
+  }
+  return SR_SUCCESS;
+}
+
+void MemoryStream::Close() {
+  // nothing to do
+}
+
+bool MemoryStream::SetPosition(size_t position) {
+  if (position > data_length_)
+    return false;
+  seek_position_ = position;
+  return true;
+}
+
+bool MemoryStream::GetPosition(size_t* position) const {
+  if (position)
+    *position = seek_position_;
+  return true;
+}
+
+bool MemoryStream::GetSize(size_t* size) const {
+  if (size)
+    *size = data_length_;
+  return true;
+}
+
+bool MemoryStream::ReserveSize(size_t size) {
+  return (SR_SUCCESS == DoReserve(size, nullptr));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+MemoryStream::MemoryStream() {}
+
+MemoryStream::MemoryStream(const char* data) {
+  SetData(data, strlen(data));
+}
+
+MemoryStream::MemoryStream(const void* data, size_t length) {
+  SetData(data, length);
+}
+
+MemoryStream::~MemoryStream() {
+  delete[] buffer_;
+}
+
+void MemoryStream::SetData(const void* data, size_t length) {
+  data_length_ = buffer_length_ = length;
+  delete[] buffer_;
+  buffer_ = new char[buffer_length_];
+  memcpy(buffer_, data, data_length_);
+  seek_position_ = 0;
+}
+
+StreamResult MemoryStream::DoReserve(size_t size, int* error) {
+  if (buffer_length_ >= size)
+    return SR_SUCCESS;
+
+  if (char* new_buffer = new char[size]) {
+    memcpy(new_buffer, buffer_, data_length_);
+    delete[] buffer_;
+    buffer_ = new_buffer;
+    buffer_length_ = size;
+    return SR_SUCCESS;
+  }
+
+  if (error) {
+    *error = ENOMEM;
+  }
+  return SR_ERROR;
+}
+
+}  // namespace rtc
diff --git a/rtc_base/memory_stream.h b/rtc_base/memory_stream.h
new file mode 100644
index 0000000..936f71b
--- /dev/null
+++ b/rtc_base/memory_stream.h
@@ -0,0 +1,59 @@
+/*
+ *  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 RTC_BASE_MEMORY_STREAM_H_
+#define RTC_BASE_MEMORY_STREAM_H_
+
+#include "rtc_base/stream.h"
+
+namespace rtc {
+
+// MemoryStream dynamically resizes to accomodate written data.
+
+class MemoryStream final : public StreamInterface {
+ public:
+  MemoryStream();
+  explicit MemoryStream(const char* data);  // Calls SetData(data, strlen(data))
+  MemoryStream(const void* data, size_t length);  // Calls SetData(data, length)
+  ~MemoryStream() override;
+
+  StreamState GetState() const override;
+  StreamResult Read(void* buffer,
+                    size_t bytes,
+                    size_t* bytes_read,
+                    int* error) override;
+  StreamResult Write(const void* buffer,
+                     size_t bytes,
+                     size_t* bytes_written,
+                     int* error) override;
+  void Close() override;
+  bool SetPosition(size_t position) override;
+  bool GetPosition(size_t* position) const override;
+  bool GetSize(size_t* size) const override;
+  bool ReserveSize(size_t size) override;
+
+  char* GetBuffer() { return buffer_; }
+  const char* GetBuffer() const { return buffer_; }
+
+  void SetData(const void* data, size_t length);
+
+ private:
+  StreamResult DoReserve(size_t size, int* error);
+
+  // Invariant: 0 <= seek_position <= data_length_ <= buffer_length_
+  char* buffer_ = nullptr;
+  size_t buffer_length_ = 0;
+  size_t data_length_ = 0;
+  size_t seek_position_ = 0;
+};
+
+}  // namespace rtc
+
+#endif  // RTC_BASE_MEMORY_STREAM_H_
diff --git a/rtc_base/memory_usage.cc b/rtc_base/memory_usage.cc
index a70c547..9cd36d3 100644
--- a/rtc_base/memory_usage.cc
+++ b/rtc_base/memory_usage.cc
@@ -61,6 +61,9 @@
     return -1;
   }
   return pmc.WorkingSetSize;
+#elif defined(WEBRTC_FUCHSIA)
+  RTC_LOG_ERR(LS_ERROR) << "GetProcessResidentSizeBytes() not implemented";
+  return 0;
 #else
   // Not implemented yet.
   static_assert(false,
diff --git a/rtc_base/messagedigest.cc b/rtc_base/messagedigest.cc
index 9c10bcd..5a0d16a 100644
--- a/rtc_base/messagedigest.cc
+++ b/rtc_base/messagedigest.cc
@@ -10,9 +10,9 @@
 
 #include "rtc_base/messagedigest.h"
 
-#include <memory>
-
 #include <string.h>
+#include <cstdint>
+#include <memory>
 
 #include "rtc_base/openssldigest.h"
 #include "rtc_base/stringencode.h"
diff --git a/rtc_base/messagedigest.h b/rtc_base/messagedigest.h
index fc82088..757f914 100644
--- a/rtc_base/messagedigest.h
+++ b/rtc_base/messagedigest.h
@@ -11,6 +11,7 @@
 #ifndef RTC_BASE_MESSAGEDIGEST_H_
 #define RTC_BASE_MESSAGEDIGEST_H_
 
+#include <stddef.h>
 #include <string>
 
 namespace rtc {
diff --git a/rtc_base/messagequeue.cc b/rtc_base/messagequeue.cc
index 84d3a96..204952a 100644
--- a/rtc_base/messagequeue.cc
+++ b/rtc_base/messagequeue.cc
@@ -8,14 +8,15 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 #include <algorithm>
-#include <utility>  // for move
+#include <string>
+#include <utility>
 
 #include "rtc_base/atomicops.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/messagequeue.h"
 #include "rtc_base/thread.h"
-#include "rtc_base/timeutils.h"  // for TimeMillis, TimeDiff, TimeUntil
+#include "rtc_base/timeutils.h"
 #include "rtc_base/trace_event.h"
 
 namespace rtc {
@@ -349,8 +350,10 @@
                         uint32_t id,
                         MessageData* pdata,
                         bool time_sensitive) {
-  if (IsQuitting())
+  if (IsQuitting()) {
+    delete pdata;
     return;
+  }
 
   // Keep thread safe
   // Add the message to the end of the queue
@@ -406,6 +409,7 @@
                                uint32_t id,
                                MessageData* pdata) {
   if (IsQuitting()) {
+    delete pdata;
     return;
   }
 
diff --git a/rtc_base/module.mk b/rtc_base/module.mk
index 2a1b9f3..8364fe5 100644
--- a/rtc_base/module.mk
+++ b/rtc_base/module.mk
@@ -17,7 +17,6 @@
 	rtc_base/flags.o \
 	rtc_base/location.o \
 	rtc_base/numerics/histogram_percentile_counter.o \
-	rtc_base/pathutils.o \
 	rtc_base/platform_file.o \
 	rtc_base/platform_thread.o \
 	rtc_base/platform_thread_types.o \
diff --git a/rtc_base/natserver.cc b/rtc_base/natserver.cc
index 8119376..b005eca 100644
--- a/rtc_base/natserver.cc
+++ b/rtc_base/natserver.cc
@@ -158,7 +158,7 @@
                                     const char* buf,
                                     size_t size,
                                     const SocketAddress& addr,
-                                    const PacketTime& packet_time) {
+                                    const int64_t& /* packet_time_us */) {
   // Read the intended destination from the wire.
   SocketAddress dest_addr;
   size_t length = UnpackAddressFromNAT(buf, size, &dest_addr);
@@ -184,7 +184,7 @@
                                     const char* buf,
                                     size_t size,
                                     const SocketAddress& remote_addr,
-                                    const PacketTime& packet_time) {
+                                    const int64_t& /* packet_time_us */) {
   SocketAddress local_addr = socket->GetLocalAddress();
 
   // Find the translation for this addresses.
diff --git a/rtc_base/natserver.h b/rtc_base/natserver.h
index f4cabcf..d16b537 100644
--- a/rtc_base/natserver.h
+++ b/rtc_base/natserver.h
@@ -81,12 +81,12 @@
                            const char* buf,
                            size_t size,
                            const SocketAddress& addr,
-                           const PacketTime& packet_time);
+                           const int64_t& packet_time_us);
   void OnExternalUDPPacket(AsyncPacketSocket* socket,
                            const char* buf,
                            size_t size,
                            const SocketAddress& remote_addr,
-                           const PacketTime& packet_time);
+                           const int64_t& packet_time_us);
 
  private:
   typedef std::set<SocketAddress, AddrCmp> AddressSet;
diff --git a/rtc_base/nethelpers.h b/rtc_base/nethelpers.h
index 429f0c0..138f958 100644
--- a/rtc_base/nethelpers.h
+++ b/rtc_base/nethelpers.h
@@ -12,8 +12,7 @@
 #define RTC_BASE_NETHELPERS_H_
 
 #if defined(WEBRTC_POSIX)
-#include <netdb.h>
-#include <stddef.h>
+#include <sys/socket.h>
 #elif WEBRTC_WIN
 #include <winsock2.h>  // NOLINT
 #endif
@@ -21,7 +20,7 @@
 #include <vector>
 
 #include "rtc_base/asyncresolverinterface.h"
-#include "rtc_base/ipaddress.h"  // for IPAddress
+#include "rtc_base/ipaddress.h"
 #include "rtc_base/signalthread.h"
 #include "rtc_base/socketaddress.h"
 
diff --git a/rtc_base/network.cc b/rtc_base/network.cc
index 67888ed..5c7b019 100644
--- a/rtc_base/network.cc
+++ b/rtc_base/network.cc
@@ -38,7 +38,6 @@
 #include "rtc_base/logging.h"
 #include "rtc_base/networkmonitor.h"
 #include "rtc_base/socket.h"  // includes something that makes windows happy
-#include "rtc_base/stream.h"
 #include "rtc_base/stringencode.h"
 #include "rtc_base/strings/string_builder.h"
 #include "rtc_base/stringutils.h"
@@ -260,7 +259,7 @@
   return false;
 }
 
-webrtc::MDnsResponderInterface* NetworkManager::GetMDnsResponder() const {
+webrtc::MdnsResponderInterface* NetworkManager::GetMdnsResponder() const {
   return nullptr;
 }
 
@@ -286,7 +285,7 @@
         new rtc::Network("any", "any", ipv4_any_address, 0, ADAPTER_TYPE_ANY));
     ipv4_any_address_network_->set_default_local_address_provider(this);
     ipv4_any_address_network_->AddIP(ipv4_any_address);
-    ipv4_any_address_network_->SetMDnsResponder(GetMDnsResponder());
+    ipv4_any_address_network_->SetMdnsResponder(GetMdnsResponder());
   }
   networks->push_back(ipv4_any_address_network_.get());
 
@@ -297,7 +296,7 @@
           "any", "any", ipv6_any_address, 0, ADAPTER_TYPE_ANY));
       ipv6_any_address_network_->set_default_local_address_provider(this);
       ipv6_any_address_network_->AddIP(ipv6_any_address);
-      ipv6_any_address_network_->SetMDnsResponder(GetMDnsResponder());
+      ipv6_any_address_network_->SetMdnsResponder(GetMdnsResponder());
     }
     networks->push_back(ipv6_any_address_network_.get());
   }
@@ -387,7 +386,7 @@
         delete net;
       }
     }
-    networks_map_[key]->SetMDnsResponder(GetMDnsResponder());
+    networks_map_[key]->SetMdnsResponder(GetMdnsResponder());
   }
   // It may still happen that the merged list is a subset of |networks_|.
   // To detect this change, we compare their sizes.
@@ -775,26 +774,28 @@
 
 #if defined(WEBRTC_LINUX)
 bool IsDefaultRoute(const std::string& network_name) {
-  FileStream fs;
-  if (!fs.Open("/proc/net/route", "r", nullptr)) {
+  FILE* f = fopen("/proc/net/route", "r");
+  if (!f) {
     RTC_LOG(LS_WARNING)
         << "Couldn't read /proc/net/route, skipping default "
         << "route check (assuming everything is a default route).";
     return true;
-  } else {
-    std::string line;
-    while (fs.ReadLine(&line) == SR_SUCCESS) {
-      char iface_name[256];
-      unsigned int iface_ip, iface_gw, iface_mask, iface_flags;
-      if (sscanf(line.c_str(), "%255s %8X %8X %4X %*d %*u %*d %8X", iface_name,
-                 &iface_ip, &iface_gw, &iface_flags, &iface_mask) == 5 &&
-          network_name == iface_name && iface_mask == 0 &&
-          (iface_flags & (RTF_UP | RTF_HOST)) == RTF_UP) {
-        return true;
-      }
+  }
+  bool is_default_route = false;
+  char line[500];
+  while (fgets(line, sizeof(line), f)) {
+    char iface_name[256];
+    unsigned int iface_ip, iface_gw, iface_mask, iface_flags;
+    if (sscanf(line, "%255s %8X %8X %4X %*d %*u %*d %8X", iface_name, &iface_ip,
+               &iface_gw, &iface_flags, &iface_mask) == 5 &&
+        network_name == iface_name && iface_mask == 0 &&
+        (iface_flags & (RTF_UP | RTF_HOST)) == RTF_UP) {
+      is_default_route = true;
+      break;
     }
   }
-  return false;
+  fclose(f);
+  return is_default_route;
 }
 #endif
 
diff --git a/rtc_base/network.h b/rtc_base/network.h
index 601e39f..8b1a5fc 100644
--- a/rtc_base/network.h
+++ b/rtc_base/network.h
@@ -141,7 +141,7 @@
 
   // Returns the mDNS responder that can be used to obfuscate the local IP
   // addresses of ICE host candidates by mDNS hostnames.
-  virtual webrtc::MDnsResponderInterface* GetMDnsResponder() const;
+  virtual webrtc::MdnsResponderInterface* GetMdnsResponder() const;
 };
 
 // Base class for NetworkManager implementations.
@@ -367,11 +367,11 @@
   // created name will be resolved by the responder.
   //
   // The mDNS responder, if not null, should outlive this rtc::Network.
-  void SetMDnsResponder(webrtc::MDnsResponderInterface* mdns_responder) {
+  void SetMdnsResponder(webrtc::MdnsResponderInterface* mdns_responder) {
     mdns_responder_ = mdns_responder;
   }
   // Returns the mDNS responder, which is null by default.
-  webrtc::MDnsResponderInterface* GetMDnsResponder() const {
+  webrtc::MdnsResponderInterface* GetMdnsResponder() const {
     return mdns_responder_;
   }
 
@@ -446,7 +446,7 @@
   int prefix_length_;
   std::string key_;
   std::vector<InterfaceAddress> ips_;
-  webrtc::MDnsResponderInterface* mdns_responder_ = nullptr;
+  webrtc::MdnsResponderInterface* mdns_responder_ = nullptr;
   int scope_id_;
   bool ignored_;
   AdapterType type_;
diff --git a/rtc_base/network/BUILD.gn b/rtc_base/network/BUILD.gn
new file mode 100644
index 0000000..0fbdbb1
--- /dev/null
+++ b/rtc_base/network/BUILD.gn
@@ -0,0 +1,19 @@
+# Copyright (c) 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.
+
+import("../../webrtc.gni")
+
+rtc_source_set("sent_packet") {
+  sources = [
+    "sent_packet.cc",
+    "sent_packet.h",
+  ]
+  deps = [
+    "//third_party/abseil-cpp/absl/types:optional",
+  ]
+}
diff --git a/rtc_base/network/sent_packet.cc b/rtc_base/network/sent_packet.cc
new file mode 100644
index 0000000..8cc4973
--- /dev/null
+++ b/rtc_base/network/sent_packet.cc
@@ -0,0 +1,27 @@
+/*
+ *  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.
+ */
+
+#include "rtc_base/network/sent_packet.h"
+
+namespace rtc {
+
+PacketInfo::PacketInfo() = default;
+PacketInfo::PacketInfo(const PacketInfo& info) = default;
+PacketInfo::~PacketInfo() = default;
+
+SentPacket::SentPacket() = default;
+SentPacket::SentPacket(int64_t packet_id, int64_t send_time_ms)
+    : packet_id(packet_id), send_time_ms(send_time_ms) {}
+SentPacket::SentPacket(int64_t packet_id,
+                       int64_t send_time_ms,
+                       const rtc::PacketInfo& info)
+    : packet_id(packet_id), send_time_ms(send_time_ms), info(info) {}
+
+}  // namespace rtc
diff --git a/rtc_base/network/sent_packet.h b/rtc_base/network/sent_packet.h
new file mode 100644
index 0000000..0cad31c
--- /dev/null
+++ b/rtc_base/network/sent_packet.h
@@ -0,0 +1,68 @@
+/*
+ *  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 RTC_BASE_NETWORK_SENT_PACKET_H_
+#define RTC_BASE_NETWORK_SENT_PACKET_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "absl/types/optional.h"
+
+namespace rtc {
+
+enum class PacketType {
+  kUnknown,
+  kData,
+  kIceConnectivityCheck,
+  kIceConnectivityCheckResponse,
+  kStunMessage,
+  kTurnMessage,
+};
+
+enum class PacketInfoProtocolType {
+  kUnknown,
+  kUdp,
+  kTcp,
+  kSsltcp,
+  kTls,
+};
+
+struct PacketInfo {
+  PacketInfo();
+  PacketInfo(const PacketInfo& info);
+  ~PacketInfo();
+
+  bool included_in_feedback = false;
+  bool included_in_allocation = false;
+  PacketType packet_type = PacketType::kUnknown;
+  PacketInfoProtocolType protocol = PacketInfoProtocolType::kUnknown;
+  // A unique id assigned by the network manager, and absl::nullopt if not set.
+  absl::optional<uint16_t> network_id;
+  size_t packet_size_bytes = 0;
+  size_t turn_overhead_bytes = 0;
+  size_t ip_overhead_bytes = 0;
+};
+
+struct SentPacket {
+  SentPacket();
+  SentPacket(int64_t packet_id, int64_t send_time_ms);
+  SentPacket(int64_t packet_id,
+             int64_t send_time_ms,
+             const rtc::PacketInfo& info);
+
+  int64_t packet_id = -1;
+  int64_t send_time_ms = -1;
+  rtc::PacketInfo info;
+};
+
+}  // namespace rtc
+
+#endif  // RTC_BASE_NETWORK_SENT_PACKET_H_
diff --git a/rtc_base/networkmonitor.cc b/rtc_base/networkmonitor.cc
index e3b2efd..0185eab 100644
--- a/rtc_base/networkmonitor.cc
+++ b/rtc_base/networkmonitor.cc
@@ -10,7 +10,10 @@
 
 #include "rtc_base/networkmonitor.h"
 
+#include <stdint.h>
+
 #include "rtc_base/checks.h"
+#include "rtc_base/location.h"
 #include "rtc_base/logging.h"
 
 namespace {
diff --git a/rtc_base/noop.cc b/rtc_base/noop.cc
deleted file mode 100644
index 16a8e6d..0000000
--- a/rtc_base/noop.cc
+++ /dev/null
@@ -1,13 +0,0 @@
-/*
- *  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.
- */
-
-// This file is only needed to make ninja happy on some platforms.
-// On some platforms it is not possible to link an rtc_static_library
-// without any source file listed in the GN target.
diff --git a/rtc_base/noop.mm b/rtc_base/noop.mm
deleted file mode 100644
index 16a8e6d..0000000
--- a/rtc_base/noop.mm
+++ /dev/null
@@ -1,13 +0,0 @@
-/*
- *  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.
- */
-
-// This file is only needed to make ninja happy on some platforms.
-// On some platforms it is not possible to link an rtc_static_library
-// without any source file listed in the GN target.
diff --git a/rtc_base/nullsocketserver.cc b/rtc_base/nullsocketserver.cc
index c890c6f..ec042dd 100644
--- a/rtc_base/nullsocketserver.cc
+++ b/rtc_base/nullsocketserver.cc
@@ -13,7 +13,7 @@
 
 namespace rtc {
 
-NullSocketServer::NullSocketServer() : event_(false, false) {}
+NullSocketServer::NullSocketServer() = default;
 NullSocketServer::~NullSocketServer() {}
 
 bool NullSocketServer::Wait(int cms, bool process_io) {
diff --git a/rtc_base/nullsocketserver.h b/rtc_base/nullsocketserver.h
index 408bcd1..47a7fa6 100644
--- a/rtc_base/nullsocketserver.h
+++ b/rtc_base/nullsocketserver.h
@@ -11,7 +11,9 @@
 #ifndef RTC_BASE_NULLSOCKETSERVER_H_
 #define RTC_BASE_NULLSOCKETSERVER_H_
 
+#include "rtc_base/asyncsocket.h"
 #include "rtc_base/event.h"
+#include "rtc_base/socket.h"
 #include "rtc_base/socketserver.h"
 
 namespace rtc {
diff --git a/rtc_base/numerics/moving_average.cc b/rtc_base/numerics/moving_average.cc
new file mode 100644
index 0000000..c825839
--- /dev/null
+++ b/rtc_base/numerics/moving_average.cc
@@ -0,0 +1,60 @@
+/*
+ *  Copyright (c) 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.
+ */
+
+#include "rtc_base/numerics/moving_average.h"
+
+#include <algorithm>
+
+#include "rtc_base/checks.h"
+
+namespace rtc {
+
+MovingAverage::MovingAverage(size_t window_size) : history_(window_size, 0) {
+  // Limit window size to avoid overflow.
+  RTC_DCHECK_LE(window_size, (int64_t{1} << 32) - 1);
+}
+MovingAverage::~MovingAverage() = default;
+
+void MovingAverage::AddSample(int sample) {
+  count_++;
+  size_t index = count_ % history_.size();
+  if (count_ > history_.size())
+    sum_ -= history_[index];
+  sum_ += sample;
+  history_[index] = sample;
+}
+
+absl::optional<int> MovingAverage::GetAverageRoundedDown() const {
+  if (count_ == 0)
+    return absl::nullopt;
+  return sum_ / Size();
+}
+
+absl::optional<int> MovingAverage::GetAverageRoundedToClosest() const {
+  if (count_ == 0)
+    return absl::nullopt;
+  return (sum_ + Size() / 2) / Size();
+}
+
+absl::optional<double> MovingAverage::GetUnroundedAverage() const {
+  if (count_ == 0)
+    return absl::nullopt;
+  return sum_ / static_cast<double>(Size());
+}
+
+void MovingAverage::Reset() {
+  count_ = 0;
+  sum_ = 0;
+}
+
+size_t MovingAverage::Size() const {
+  return std::min(count_, history_.size());
+}
+}  // namespace rtc
diff --git a/rtc_base/numerics/moving_average.h b/rtc_base/numerics/moving_average.h
new file mode 100644
index 0000000..770e47d
--- /dev/null
+++ b/rtc_base/numerics/moving_average.h
@@ -0,0 +1,63 @@
+/*
+ *  Copyright (c) 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 RTC_BASE_NUMERICS_MOVING_AVERAGE_H_
+#define RTC_BASE_NUMERICS_MOVING_AVERAGE_H_
+
+#include <vector>
+
+#include "absl/types/optional.h"
+
+namespace rtc {
+
+// Calculates average over fixed size window. If there are less than window
+// size elements, calculates average of all inserted so far elements.
+//
+class MovingAverage {
+ public:
+  // Maximum supported window size is 2^32 - 1.
+  explicit MovingAverage(size_t window_size);
+  ~MovingAverage();
+  // MovingAverage is neither copyable nor movable.
+  MovingAverage(const MovingAverage&) = delete;
+  MovingAverage& operator=(const MovingAverage&) = delete;
+
+  // Adds new sample. If the window is full, the oldest element is pushed out.
+  void AddSample(int sample);
+
+  // Returns rounded down average of last |window_size| elements or all
+  // elements if there are not enough of them. Returns nullopt if there were
+  // no elements added.
+  absl::optional<int> GetAverageRoundedDown() const;
+
+  // Same as above but rounded to the closest integer.
+  absl::optional<int> GetAverageRoundedToClosest() const;
+
+  // Returns unrounded average over the window.
+  absl::optional<double> GetUnroundedAverage() const;
+
+  // Resets to the initial state before any elements were added.
+  void Reset();
+
+  // Returns number of elements in the window.
+  size_t Size() const;
+
+ private:
+  // Total number of samples added to the class since last reset.
+  size_t count_ = 0;
+  // Sum of the samples in the moving window.
+  int64_t sum_ = 0;
+  // Circular buffer for all the samples in the moving window.
+  // Size is always |window_size|
+  std::vector<int> history_;
+};
+
+}  // namespace rtc
+#endif  // RTC_BASE_NUMERICS_MOVING_AVERAGE_H_
diff --git a/rtc_base/numerics/moving_average_unittest.cc b/rtc_base/numerics/moving_average_unittest.cc
new file mode 100644
index 0000000..9bc9a1a
--- /dev/null
+++ b/rtc_base/numerics/moving_average_unittest.cc
@@ -0,0 +1,87 @@
+/*
+ *  Copyright (c) 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.
+ */
+
+#include "rtc_base/numerics/moving_average.h"
+
+#include "test/gtest.h"
+
+namespace test {
+
+TEST(MovingAverageTest, EmptyAverage) {
+  rtc::MovingAverage moving_average(1);
+  EXPECT_EQ(0u, moving_average.Size());
+  EXPECT_EQ(absl::nullopt, moving_average.GetAverageRoundedDown());
+}
+
+// Test single value.
+TEST(MovingAverageTest, OneElement) {
+  rtc::MovingAverage moving_average(1);
+  moving_average.AddSample(3);
+  EXPECT_EQ(1u, moving_average.Size());
+  EXPECT_EQ(3, *moving_average.GetAverageRoundedDown());
+}
+
+TEST(MovingAverageTest, GetAverage) {
+  rtc::MovingAverage moving_average(1024);
+  moving_average.AddSample(1);
+  moving_average.AddSample(1);
+  moving_average.AddSample(3);
+  moving_average.AddSample(3);
+  EXPECT_EQ(*moving_average.GetAverageRoundedDown(), 2);
+  EXPECT_EQ(*moving_average.GetAverageRoundedToClosest(), 2);
+}
+
+TEST(MovingAverageTest, GetAverageRoundedDownRounds) {
+  rtc::MovingAverage moving_average(1024);
+  moving_average.AddSample(1);
+  moving_average.AddSample(2);
+  moving_average.AddSample(2);
+  moving_average.AddSample(2);
+  EXPECT_EQ(*moving_average.GetAverageRoundedDown(), 1);
+}
+
+TEST(MovingAverageTest, GetAverageRoundedToClosestRounds) {
+  rtc::MovingAverage moving_average(1024);
+  moving_average.AddSample(1);
+  moving_average.AddSample(2);
+  moving_average.AddSample(2);
+  moving_average.AddSample(2);
+  EXPECT_EQ(*moving_average.GetAverageRoundedToClosest(), 2);
+}
+
+TEST(MovingAverageTest, Reset) {
+  rtc::MovingAverage moving_average(5);
+  moving_average.AddSample(1);
+  EXPECT_EQ(1, *moving_average.GetAverageRoundedDown());
+  EXPECT_EQ(1, *moving_average.GetAverageRoundedToClosest());
+
+  moving_average.Reset();
+
+  EXPECT_FALSE(moving_average.GetAverageRoundedDown());
+  moving_average.AddSample(10);
+  EXPECT_EQ(10, *moving_average.GetAverageRoundedDown());
+  EXPECT_EQ(10, *moving_average.GetAverageRoundedToClosest());
+}
+
+TEST(MovingAverageTest, ManySamples) {
+  rtc::MovingAverage moving_average(10);
+  for (int i = 1; i < 11; i++) {
+    moving_average.AddSample(i);
+  }
+  EXPECT_EQ(*moving_average.GetAverageRoundedDown(), 5);
+  EXPECT_EQ(*moving_average.GetAverageRoundedToClosest(), 6);
+  for (int i = 1; i < 2001; i++) {
+    moving_average.AddSample(i);
+  }
+  EXPECT_EQ(*moving_average.GetAverageRoundedDown(), 1995);
+  EXPECT_EQ(*moving_average.GetAverageRoundedToClosest(), 1996);
+}
+
+}  // namespace test
diff --git a/rtc_base/numerics/sample_counter.h b/rtc_base/numerics/sample_counter.h
index 4fe71d1..18bd36b 100644
--- a/rtc_base/numerics/sample_counter.h
+++ b/rtc_base/numerics/sample_counter.h
@@ -11,6 +11,8 @@
 #ifndef RTC_BASE_NUMERICS_SAMPLE_COUNTER_H_
 #define RTC_BASE_NUMERICS_SAMPLE_COUNTER_H_
 
+#include <stdint.h>
+
 #include "absl/types/optional.h"
 
 namespace rtc {
diff --git a/rtc_base/openssl_key_derivation_hkdf.cc b/rtc_base/openssl_key_derivation_hkdf.cc
new file mode 100644
index 0000000..52af667
--- /dev/null
+++ b/rtc_base/openssl_key_derivation_hkdf.cc
@@ -0,0 +1,70 @@
+/*
+ *  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.
+ */
+
+#include "rtc_base/openssl_key_derivation_hkdf.h"
+
+#include <openssl/digest.h>
+#include <openssl/err.h>
+#include <openssl/hkdf.h>
+#include <openssl/sha.h>
+
+#include <algorithm>
+#include <utility>
+
+#include "rtc_base/buffer.h"
+#include "rtc_base/openssl.h"
+
+namespace rtc {
+
+OpenSSLKeyDerivationHKDF::OpenSSLKeyDerivationHKDF() = default;
+OpenSSLKeyDerivationHKDF::~OpenSSLKeyDerivationHKDF() = default;
+
+const size_t OpenSSLKeyDerivationHKDF::kMinKeyByteSize = 16;
+const size_t OpenSSLKeyDerivationHKDF::kMaxKeyByteSize =
+    255 * SHA256_DIGEST_LENGTH;
+const size_t OpenSSLKeyDerivationHKDF::kMinSecretByteSize = 16;
+
+absl::optional<ZeroOnFreeBuffer<uint8_t>> OpenSSLKeyDerivationHKDF::DeriveKey(
+    rtc::ArrayView<const uint8_t> secret,
+    rtc::ArrayView<const uint8_t> salt,
+    rtc::ArrayView<const uint8_t> label,
+    size_t derived_key_byte_size) {
+  // Prevent deriving less than 128 bits of key material or more than the max.
+  if (derived_key_byte_size < kMinKeyByteSize ||
+      derived_key_byte_size > kMaxKeyByteSize) {
+    return absl::nullopt;
+  }
+  // The secret must reach the minimum number of bits to be secure.
+  if (secret.data() == nullptr || secret.size() < kMinSecretByteSize) {
+    return absl::nullopt;
+  }
+  // Empty labels are always invalid in derivation.
+  if (label.data() == nullptr || label.size() == 0) {
+    return absl::nullopt;
+  }
+  // If a random salt is not provided use all zeros.
+  rtc::Buffer salt_buffer;
+  if (salt.data() == nullptr || salt.size() == 0) {
+    salt_buffer.SetSize(SHA256_DIGEST_LENGTH);
+    std::fill(salt_buffer.begin(), salt_buffer.end(), 0);
+    salt = salt_buffer;
+  }
+  // This buffer will erase itself on release.
+  ZeroOnFreeBuffer<uint8_t> derived_key_buffer(derived_key_byte_size, 0);
+  if (!HKDF(derived_key_buffer.data(), derived_key_buffer.size(), EVP_sha256(),
+            secret.data(), secret.size(), salt.data(), salt.size(),
+            label.data(), label.size())) {
+    return absl::nullopt;
+  }
+  return absl::optional<ZeroOnFreeBuffer<uint8_t>>(
+      std::move(derived_key_buffer));
+}
+
+}  // namespace rtc
diff --git a/rtc_base/openssl_key_derivation_hkdf.h b/rtc_base/openssl_key_derivation_hkdf.h
new file mode 100644
index 0000000..ebf43cf
--- /dev/null
+++ b/rtc_base/openssl_key_derivation_hkdf.h
@@ -0,0 +1,54 @@
+/*
+ *  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 RTC_BASE_OPENSSL_KEY_DERIVATION_HKDF_H_
+#define RTC_BASE_OPENSSL_KEY_DERIVATION_HKDF_H_
+
+#include "rtc_base/constructormagic.h"
+#include "rtc_base/key_derivation.h"
+
+namespace rtc {
+
+// OpenSSLKeyDerivationHKDF provides a concrete implementation of the
+// KeyDerivation interface to support the HKDF algorithm using the
+// OpenSSL/BoringSSL internal implementation.
+class OpenSSLKeyDerivationHKDF final : public KeyDerivation {
+ public:
+  OpenSSLKeyDerivationHKDF();
+  ~OpenSSLKeyDerivationHKDF() override;
+
+  // General users shouldn't be generating keys smaller than 128 bits.
+  static const size_t kMinKeyByteSize;
+  // The maximum available derivation size 255*DIGEST_LENGTH
+  static const size_t kMaxKeyByteSize;
+  // The minimum acceptable secret size.
+  static const size_t kMinSecretByteSize;
+
+  // Derives a new key from existing key material using HKDF.
+  // secret - The random secret value you wish to derive a key from.
+  // salt - Optional (non secret) cryptographically random value.
+  // label - A non secret but unique label value to determine the derivation.
+  // derived_key_byte_size - The size of the derived key.
+  // return - A ZeroOnFreeBuffer containing the derived key or an error
+  // condition. Checking error codes is explicit in the API and error should
+  // never be ignored.
+  absl::optional<ZeroOnFreeBuffer<uint8_t>> DeriveKey(
+      rtc::ArrayView<const uint8_t> secret,
+      rtc::ArrayView<const uint8_t> salt,
+      rtc::ArrayView<const uint8_t> label,
+      size_t derived_key_byte_size) override;
+
+ private:
+  RTC_DISALLOW_COPY_AND_ASSIGN(OpenSSLKeyDerivationHKDF);
+};
+
+}  // namespace rtc
+
+#endif  // RTC_BASE_OPENSSL_KEY_DERIVATION_HKDF_H_
diff --git a/rtc_base/openssl_key_derivation_hkdf_unittest.cc b/rtc_base/openssl_key_derivation_hkdf_unittest.cc
new file mode 100644
index 0000000..92df42f
--- /dev/null
+++ b/rtc_base/openssl_key_derivation_hkdf_unittest.cc
@@ -0,0 +1,107 @@
+/*
+ *  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.
+ */
+
+#include "rtc_base/openssl_key_derivation_hkdf.h"
+
+#include <utility>
+
+#include "test/gmock.h"
+
+namespace rtc {
+namespace {
+
+// Validates that a basic valid call works correctly.
+TEST(OpenSSLKeyDerivationHKDF, DerivationBasicTest) {
+  rtc::Buffer secret(32);
+  rtc::Buffer salt(32);
+  rtc::Buffer label(32);
+  const size_t derived_key_byte_size = 16;
+
+  OpenSSLKeyDerivationHKDF hkdf;
+  auto key_or = hkdf.DeriveKey(secret, salt, label, derived_key_byte_size);
+  EXPECT_TRUE(key_or.has_value());
+  ZeroOnFreeBuffer<uint8_t> key = std::move(key_or.value());
+  EXPECT_EQ(derived_key_byte_size, key.size());
+}
+
+// Derivation fails if output is too small.
+TEST(OpenSSLKeyDerivationHKDF, DerivationFailsIfOutputIsTooSmall) {
+  rtc::Buffer secret(32);
+  rtc::Buffer salt(32);
+  rtc::Buffer label(32);
+  const size_t derived_key_byte_size = 15;
+
+  OpenSSLKeyDerivationHKDF hkdf;
+  auto key_or = hkdf.DeriveKey(secret, salt, label, derived_key_byte_size);
+  EXPECT_FALSE(key_or.has_value());
+}
+
+// Derivation fails if output is too large.
+TEST(OpenSSLKeyDerivationHKDF, DerivationFailsIfOutputIsTooLarge) {
+  rtc::Buffer secret(32);
+  rtc::Buffer salt(32);
+  rtc::Buffer label(32);
+  const size_t derived_key_byte_size = 256 * 32;
+
+  OpenSSLKeyDerivationHKDF hkdf;
+  auto key_or = hkdf.DeriveKey(secret, salt, label, derived_key_byte_size);
+  EXPECT_FALSE(key_or.has_value());
+}
+
+// Validates that too little key material causes a failure.
+TEST(OpenSSLKeyDerivationHKDF, DerivationFailsWithInvalidSecret) {
+  rtc::Buffer secret(15);
+  rtc::Buffer salt(32);
+  rtc::Buffer label(32);
+  const size_t derived_key_byte_size = 16;
+
+  OpenSSLKeyDerivationHKDF hkdf;
+  auto key_or_0 = hkdf.DeriveKey(secret, salt, label, derived_key_byte_size);
+  EXPECT_FALSE(key_or_0.has_value());
+
+  auto key_or_1 = hkdf.DeriveKey(nullptr, salt, label, derived_key_byte_size);
+  EXPECT_FALSE(key_or_1.has_value());
+
+  rtc::Buffer secret_empty;
+  auto key_or_2 =
+      hkdf.DeriveKey(secret_empty, salt, label, derived_key_byte_size);
+  EXPECT_FALSE(key_or_2.has_value());
+}
+
+// Validates that HKDF works without a salt being set.
+TEST(OpenSSLKeyDerivationHKDF, DerivationWorksWithNoSalt) {
+  rtc::Buffer secret(32);
+  rtc::Buffer label(32);
+  const size_t derived_key_byte_size = 16;
+
+  OpenSSLKeyDerivationHKDF hkdf;
+  auto key_or = hkdf.DeriveKey(secret, nullptr, label, derived_key_byte_size);
+  EXPECT_TRUE(key_or.has_value());
+}
+
+// Validates that a label is required to work correctly.
+TEST(OpenSSLKeyDerivationHKDF, DerivationRequiresLabel) {
+  rtc::Buffer secret(32);
+  rtc::Buffer salt(32);
+  rtc::Buffer label(1);
+  const size_t derived_key_byte_size = 16;
+
+  OpenSSLKeyDerivationHKDF hkdf;
+  auto key_or_0 = hkdf.DeriveKey(secret, salt, label, derived_key_byte_size);
+  EXPECT_TRUE(key_or_0.has_value());
+  ZeroOnFreeBuffer<uint8_t> key = std::move(key_or_0.value());
+  EXPECT_EQ(key.size(), derived_key_byte_size);
+
+  auto key_or_1 = hkdf.DeriveKey(secret, salt, nullptr, derived_key_byte_size);
+  EXPECT_FALSE(key_or_1.has_value());
+}
+
+}  // namespace
+}  // namespace rtc
diff --git a/rtc_base/openssladapter.cc b/rtc_base/openssladapter.cc
index b589195..fcfa53b 100644
--- a/rtc_base/openssladapter.cc
+++ b/rtc_base/openssladapter.cc
@@ -10,26 +10,25 @@
 
 #include "rtc_base/openssladapter.h"
 
-#if defined(WEBRTC_POSIX)
-#include <unistd.h>
-#endif
+#include <errno.h>
 
 #include <openssl/bio.h>
-#include <openssl/crypto.h>
 #include <openssl/err.h>
-#include <openssl/opensslv.h>
 #include <openssl/rand.h>
 #include <openssl/x509.h>
-#include <openssl/x509v3.h>
 #include "rtc_base/openssl.h"
 
-#include "absl/memory/memory.h"  // for make_unique
+#include <string.h>
+#include <time.h>
+
+#include "absl/memory/memory.h"
 #include "rtc_base/checks.h"
+#include "rtc_base/location.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/numerics/safe_conversions.h"
+#include "rtc_base/opensslcertificate.h"
 #include "rtc_base/opensslutility.h"
 #include "rtc_base/stringencode.h"
-#include "rtc_base/stringutils.h"
 #include "rtc_base/thread.h"
 
 #ifndef OPENSSL_IS_BORINGSSL
@@ -393,15 +392,17 @@
 
   // Do the connect.
   err = ContinueSSL();
-  if (err != 0)
+  if (err != 0) {
     goto ssl_error;
+  }
 
   return err;
 
 ssl_error:
   Cleanup();
-  if (bio)
+  if (bio) {
     BIO_free(bio);
+  }
 
   return err;
 }
@@ -425,14 +426,13 @@
 
       state_ = SSL_CONNECTED;
       AsyncSocketAdapter::OnConnectEvent(this);
-#if 0  // TODO(benwright): worry about this
-    // Don't let ourselves go away during the callbacks
-    PRefPtr<OpenSSLAdapter> lock(this);
-    RTC_LOG(LS_INFO) << " -- onStreamReadable";
-    AsyncSocketAdapter::OnReadEvent(this);
-    RTC_LOG(LS_INFO) << " -- onStreamWriteable";
-    AsyncSocketAdapter::OnWriteEvent(this);
-#endif
+      // TODO(benwright): Refactor this code path.
+      // Don't let ourselves go away during the callbacks
+      // PRefPtr<OpenSSLAdapter> lock(this);
+      // RTC_LOG(LS_INFO) << " -- onStreamReadable";
+      // AsyncSocketAdapter::OnReadEvent(this);
+      // RTC_LOG(LS_INFO) << " -- onStreamWriteable";
+      // AsyncSocketAdapter::OnWriteEvent(this);
       break;
 
     case SSL_ERROR_WANT_READ:
@@ -463,8 +463,9 @@
                       << ")";
   state_ = SSL_ERROR;
   SetError(err);
-  if (signal)
+  if (signal) {
     AsyncSocketAdapter::OnCloseEvent(this, err);
+  }
 }
 
 void OpenSSLAdapter::Cleanup() {
@@ -529,23 +530,20 @@
   return SOCKET_ERROR;
 }
 
-//
+///////////////////////////////////////////////////////////////////////////////
 // AsyncSocket Implementation
-//
+///////////////////////////////////////////////////////////////////////////////
 
 int OpenSSLAdapter::Send(const void* pv, size_t cb) {
   switch (state_) {
     case SSL_NONE:
       return AsyncSocketAdapter::Send(pv, cb);
-
     case SSL_WAIT:
     case SSL_CONNECTING:
       SetError(ENOTCONN);
       return SOCKET_ERROR;
-
     case SSL_CONNECTED:
       break;
-
     case SSL_ERROR:
     default:
       return SOCKET_ERROR;
@@ -568,8 +566,9 @@
   }
 
   // OpenSSL will return an error if we try to write zero bytes
-  if (cb == 0)
+  if (cb == 0) {
     return 0;
+  }
 
   ret = DoSslWrite(pv, cb, &error);
 
@@ -596,7 +595,6 @@
     // size. The user of this class can consider it sent.
     return rtc::dchecked_cast<int>(cb);
   }
-
   return ret;
 }
 
@@ -609,7 +607,6 @@
   }
 
   SetError(ENOTCONN);
-
   return SOCKET_ERROR;
 }
 
@@ -617,28 +614,26 @@
   switch (state_) {
     case SSL_NONE:
       return AsyncSocketAdapter::Recv(pv, cb, timestamp);
-
     case SSL_WAIT:
     case SSL_CONNECTING:
       SetError(ENOTCONN);
       return SOCKET_ERROR;
-
     case SSL_CONNECTED:
       break;
-
     case SSL_ERROR:
     default:
       return SOCKET_ERROR;
   }
 
   // Don't trust OpenSSL with zero byte reads
-  if (cb == 0)
+  if (cb == 0) {
     return 0;
+  }
 
   ssl_read_needs_write_ = false;
-
   int code = SSL_read(ssl_, pv, checked_cast<int>(cb));
   int error = SSL_get_error(ssl_, code);
+
   switch (error) {
     case SSL_ERROR_NONE:
       return code;
@@ -661,7 +656,6 @@
       Error("SSL_read", (code ? code : -1), false);
       break;
   }
-
   return SOCKET_ERROR;
 }
 
@@ -671,14 +665,11 @@
                              int64_t* timestamp) {
   if (socket_->GetState() == Socket::CS_CONNECTED) {
     int ret = Recv(pv, cb, timestamp);
-
     *paddr = GetRemoteAddress();
-
     return ret;
   }
 
   SetError(ENOTCONN);
-
   return SOCKET_ERROR;
 }
 
@@ -689,12 +680,11 @@
 }
 
 Socket::ConnState OpenSSLAdapter::GetState() const {
-  // if (signal_close_)
-  //  return CS_CONNECTED;
   ConnState state = socket_->GetState();
   if ((state == CS_CONNECTED) &&
-      ((state_ == SSL_WAIT) || (state_ == SSL_CONNECTING)))
+      ((state_ == SSL_WAIT) || (state_ == SSL_CONNECTING))) {
     state = CS_CONNECTING;
+  }
   return state;
 }
 
@@ -737,8 +727,9 @@
     return;
   }
 
-  if (state_ != SSL_CONNECTED)
+  if (state_ != SSL_CONNECTED) {
     return;
+  }
 
   // Don't let ourselves go away during the callbacks
   // PRefPtr<OpenSSLAdapter> lock(this); // TODO(benwright): fix this
@@ -762,8 +753,9 @@
     return;
   }
 
-  if (state_ != SSL_CONNECTED)
+  if (state_ != SSL_CONNECTED) {
     return;
+  }
 
   // Don't let ourselves go away during the callbacks
   // PRefPtr<OpenSSLAdapter> lock(this); // TODO(benwright): fix this
diff --git a/rtc_base/openssladapter.h b/rtc_base/openssladapter.h
index 45ffc6f..2e3a355 100644
--- a/rtc_base/openssladapter.h
+++ b/rtc_base/openssladapter.h
@@ -11,28 +11,28 @@
 #ifndef RTC_BASE_OPENSSLADAPTER_H_
 #define RTC_BASE_OPENSSLADAPTER_H_
 
-#include <openssl/ossl_typ.h>
-
+#include <stddef.h>
+#include <stdint.h>
 #include <memory>
 #include <string>
 #include <vector>
 
-#include "rtc_base/asyncsocket.h"          // for AsyncSocket
-#include "rtc_base/buffer.h"               // for Buffer
-#include "rtc_base/messagehandler.h"       // for MessageHandler
-#include "rtc_base/messagequeue.h"         // for Message
-#include "rtc_base/opensslidentity.h"      // for SSL_CTX, OpenSSLIdentity
-#include "rtc_base/opensslsessioncache.h"  // for OpenSSLSessionCache
-#include "rtc_base/socket.h"               // for Socket::ConnState
-#include "rtc_base/socketaddress.h"        // for SocketAddress
-#include "rtc_base/ssladapter.h"           // for SSLAdapter, SSLAdapterFactory
-#include "rtc_base/sslcertificate.h"       // for SSLCertificateVerifier
-#include "rtc_base/sslidentity.h"          // for SSLIdentity
-#include "rtc_base/sslstreamadapter.h"     // for SSLMode, SSLRole, SSL_MODE...
+#include "rtc_base/asyncsocket.h"
+#include "rtc_base/buffer.h"
+#include "rtc_base/messagehandler.h"
+#include "rtc_base/messagequeue.h"
+#include "rtc_base/opensslidentity.h"
+#include "rtc_base/opensslsessioncache.h"
+#include "rtc_base/socket.h"
+#include "rtc_base/socketaddress.h"
+#include "rtc_base/ssladapter.h"
+#include "rtc_base/sslcertificate.h"
+#include "rtc_base/sslidentity.h"
+#include "rtc_base/sslstreamadapter.h"
 
 namespace rtc {
 
-class OpenSSLAdapter : public SSLAdapter, public MessageHandler {
+class OpenSSLAdapter final : public SSLAdapter, public MessageHandler {
  public:
   static bool InitializeSSL();
   static bool CleanupSSL();
diff --git a/rtc_base/opensslcertificate.cc b/rtc_base/opensslcertificate.cc
index ed67a89..4e61b86 100644
--- a/rtc_base/opensslcertificate.cc
+++ b/rtc_base/opensslcertificate.cc
@@ -10,10 +10,6 @@
 
 #include "rtc_base/opensslcertificate.h"
 
-#include <memory>
-#include <utility>
-#include <vector>
-
 #if defined(WEBRTC_WIN)
 // Must be included first before openssl headers.
 #include "rtc_base/win32.h"  // NOLINT
@@ -21,97 +17,24 @@
 
 #include <openssl/bio.h>
 #include <openssl/bn.h>
-#include <openssl/crypto.h>
-#include <openssl/err.h>
 #include <openssl/pem.h>
-#include <openssl/rsa.h>
+#include <time.h>
 
 #include "absl/memory/memory.h"
-#include "rtc_base/arraysize.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/helpers.h"
 #include "rtc_base/logging.h"
-#include "rtc_base/numerics/safe_conversions.h"
-#include "rtc_base/openssl.h"
+#include "rtc_base/messagedigest.h"
 #include "rtc_base/openssldigest.h"
 #include "rtc_base/opensslidentity.h"
 #include "rtc_base/opensslutility.h"
-#ifndef WEBRTC_EXCLUDE_BUILT_IN_SSL_ROOT_CERTS
-#include "rtc_base/sslroots.h"
-#endif  // WEBRTC_EXCLUDE_BUILT_IN_SSL_ROOT_CERTS
 
 namespace rtc {
-
-//////////////////////////////////////////////////////////////////////
-// OpenSSLCertificate
-//////////////////////////////////////////////////////////////////////
-
-// We could have exposed a myriad of parameters for the crypto stuff,
-// but keeping it simple seems best.
+namespace {
 
 // Random bits for certificate serial number
 static const int SERIAL_RAND_BITS = 64;
 
-// Generate a self-signed certificate, with the public key from the
-// given key pair. Caller is responsible for freeing the returned object.
-static X509* MakeCertificate(EVP_PKEY* pkey, const SSLIdentityParams& params) {
-  RTC_LOG(LS_INFO) << "Making certificate for " << params.common_name;
-  X509* x509 = nullptr;
-  BIGNUM* serial_number = nullptr;
-  X509_NAME* name = nullptr;
-  time_t epoch_off = 0;  // Time offset since epoch.
-
-  if ((x509 = X509_new()) == nullptr)
-    goto error;
-
-  if (!X509_set_pubkey(x509, pkey))
-    goto error;
-
-  // serial number
-  // temporary reference to serial number inside x509 struct
-  ASN1_INTEGER* asn1_serial_number;
-  if ((serial_number = BN_new()) == nullptr ||
-      !BN_pseudo_rand(serial_number, SERIAL_RAND_BITS, 0, 0) ||
-      (asn1_serial_number = X509_get_serialNumber(x509)) == nullptr ||
-      !BN_to_ASN1_INTEGER(serial_number, asn1_serial_number))
-    goto error;
-
-  if (!X509_set_version(x509, 2L))  // version 3
-    goto error;
-
-  // There are a lot of possible components for the name entries. In
-  // our P2P SSL mode however, the certificates are pre-exchanged
-  // (through the secure XMPP channel), and so the certificate
-  // identification is arbitrary. It can't be empty, so we set some
-  // arbitrary common_name. Note that this certificate goes out in
-  // clear during SSL negotiation, so there may be a privacy issue in
-  // putting anything recognizable here.
-  if ((name = X509_NAME_new()) == nullptr ||
-      !X509_NAME_add_entry_by_NID(name, NID_commonName, MBSTRING_UTF8,
-                                  (unsigned char*)params.common_name.c_str(),
-                                  -1, -1, 0) ||
-      !X509_set_subject_name(x509, name) || !X509_set_issuer_name(x509, name))
-    goto error;
-
-  if (!X509_time_adj(X509_get_notBefore(x509), params.not_before, &epoch_off) ||
-      !X509_time_adj(X509_get_notAfter(x509), params.not_after, &epoch_off))
-    goto error;
-
-  if (!X509_sign(x509, pkey, EVP_sha256()))
-    goto error;
-
-  BN_free(serial_number);
-  X509_NAME_free(name);
-  RTC_LOG(LS_INFO) << "Returning certificate";
-  return x509;
-
-error:
-  BN_free(serial_number);
-  X509_NAME_free(name);
-  X509_free(x509);
-  return nullptr;
-}
-
 #if !defined(NDEBUG)
 // Print a certificate to the log, for debugging.
 static void PrintCert(X509* x509) {
@@ -129,11 +52,77 @@
 }
 #endif
 
-OpenSSLCertificate::OpenSSLCertificate(X509* x509) : x509_(x509) {
-  AddReference();
+// Generate a self-signed certificate, with the public key from the
+// given key pair. Caller is responsible for freeing the returned object.
+static X509* MakeCertificate(EVP_PKEY* pkey, const SSLIdentityParams& params) {
+  RTC_LOG(LS_INFO) << "Making certificate for " << params.common_name;
+
+  ASN1_INTEGER* asn1_serial_number = nullptr;
+  BIGNUM* serial_number = nullptr;
+  X509* x509 = nullptr;
+  X509_NAME* name = nullptr;
+  time_t epoch_off = 0;  // Time offset since epoch.
+
+  if ((x509 = X509_new()) == nullptr) {
+    goto error;
+  }
+  if (!X509_set_pubkey(x509, pkey)) {
+    goto error;
+  }
+  // serial number - temporary reference to serial number inside x509 struct
+  if ((serial_number = BN_new()) == nullptr ||
+      !BN_pseudo_rand(serial_number, SERIAL_RAND_BITS, 0, 0) ||
+      (asn1_serial_number = X509_get_serialNumber(x509)) == nullptr ||
+      !BN_to_ASN1_INTEGER(serial_number, asn1_serial_number)) {
+    goto error;
+  }
+  // Set version to X509.V3
+  if (!X509_set_version(x509, 2L)) {
+    goto error;
+  }
+
+  // There are a lot of possible components for the name entries. In
+  // our P2P SSL mode however, the certificates are pre-exchanged
+  // (through the secure XMPP channel), and so the certificate
+  // identification is arbitrary. It can't be empty, so we set some
+  // arbitrary common_name. Note that this certificate goes out in
+  // clear during SSL negotiation, so there may be a privacy issue in
+  // putting anything recognizable here.
+  if ((name = X509_NAME_new()) == nullptr ||
+      !X509_NAME_add_entry_by_NID(name, NID_commonName, MBSTRING_UTF8,
+                                  (unsigned char*)params.common_name.c_str(),
+                                  -1, -1, 0) ||
+      !X509_set_subject_name(x509, name) || !X509_set_issuer_name(x509, name)) {
+    goto error;
+  }
+  if (!X509_time_adj(X509_get_notBefore(x509), params.not_before, &epoch_off) ||
+      !X509_time_adj(X509_get_notAfter(x509), params.not_after, &epoch_off)) {
+    goto error;
+  }
+  if (!X509_sign(x509, pkey, EVP_sha256())) {
+    goto error;
+  }
+
+  BN_free(serial_number);
+  X509_NAME_free(name);
+  RTC_LOG(LS_INFO) << "Returning certificate";
+  return x509;
+
+error:
+  BN_free(serial_number);
+  X509_NAME_free(name);
+  X509_free(x509);
+  return nullptr;
 }
 
-OpenSSLCertificate* OpenSSLCertificate::Generate(
+}  // namespace
+
+OpenSSLCertificate::OpenSSLCertificate(X509* x509) : x509_(x509) {
+  RTC_DCHECK(x509_ != nullptr);
+  X509_up_ref(x509_);
+}
+
+std::unique_ptr<OpenSSLCertificate> OpenSSLCertificate::Generate(
     OpenSSLKeyPair* key_pair,
     const SSLIdentityParams& params) {
   SSLIdentityParams actual_params(params);
@@ -149,25 +138,27 @@
 #if !defined(NDEBUG)
   PrintCert(x509);
 #endif
-  OpenSSLCertificate* ret = new OpenSSLCertificate(x509);
+  auto ret = absl::make_unique<OpenSSLCertificate>(x509);
   X509_free(x509);
   return ret;
 }
 
-OpenSSLCertificate* OpenSSLCertificate::FromPEMString(
+std::unique_ptr<OpenSSLCertificate> OpenSSLCertificate::FromPEMString(
     const std::string& pem_string) {
   BIO* bio = BIO_new_mem_buf(const_cast<char*>(pem_string.c_str()), -1);
-  if (!bio)
+  if (!bio) {
     return nullptr;
+  }
+
   BIO_set_mem_eof_return(bio, 0);
   X509* x509 =
       PEM_read_bio_X509(bio, nullptr, nullptr, const_cast<char*>("\0"));
   BIO_free(bio);  // Frees the BIO, but not the pointed-to string.
 
-  if (!x509)
+  if (!x509) {
     return nullptr;
-
-  OpenSSLCertificate* ret = new OpenSSLCertificate(x509);
+  }
+  auto ret = absl::make_unique<OpenSSLCertificate>(x509);
   X509_free(x509);
   return ret;
 }
@@ -229,19 +220,16 @@
                                        unsigned char* digest,
                                        size_t size,
                                        size_t* length) {
-  const EVP_MD* md;
-  unsigned int n;
-
-  if (!OpenSSLDigest::GetDigestEVP(algorithm, &md))
+  const EVP_MD* md = nullptr;
+  unsigned int n = 0;
+  if (!OpenSSLDigest::GetDigestEVP(algorithm, &md)) {
     return false;
-
-  if (size < static_cast<size_t>(EVP_MD_size(md)))
+  }
+  if (size < static_cast<size_t>(EVP_MD_size(md))) {
     return false;
-
+  }
   X509_digest(x509, md, digest, &n);
-
   *length = n;
-
   return true;
 }
 
@@ -249,18 +237,18 @@
   X509_free(x509_);
 }
 
-OpenSSLCertificate* OpenSSLCertificate::GetReference() const {
-  return new OpenSSLCertificate(x509_);
+std::unique_ptr<SSLCertificate> OpenSSLCertificate::Clone() const {
+  return absl::make_unique<OpenSSLCertificate>(x509_);
 }
 
 std::string OpenSSLCertificate::ToPEMString() const {
   BIO* bio = BIO_new(BIO_s_mem());
   if (!bio) {
-    FATAL() << "unreachable code";
+    FATAL() << "Unreachable code.";
   }
   if (!PEM_write_bio_X509(bio, x509_)) {
     BIO_free(bio);
-    FATAL() << "unreachable code";
+    FATAL() << "Unreachable code.";
   }
   BIO_write(bio, "\0", 1);
   char* buffer;
@@ -273,27 +261,21 @@
 void OpenSSLCertificate::ToDER(Buffer* der_buffer) const {
   // In case of failure, make sure to leave the buffer empty.
   der_buffer->SetSize(0);
-
   // Calculates the DER representation of the certificate, from scratch.
   BIO* bio = BIO_new(BIO_s_mem());
   if (!bio) {
-    FATAL() << "unreachable code";
+    FATAL() << "Unreachable code.";
   }
   if (!i2d_X509_bio(bio, x509_)) {
     BIO_free(bio);
-    FATAL() << "unreachable code";
+    FATAL() << "Unreachable code.";
   }
-  char* data;
+  char* data = nullptr;
   size_t length = BIO_get_mem_data(bio, &data);
   der_buffer->SetData(data, length);
   BIO_free(bio);
 }
 
-void OpenSSLCertificate::AddReference() const {
-  RTC_DCHECK(x509_ != nullptr);
-  X509_up_ref(x509_);
-}
-
 bool OpenSSLCertificate::operator==(const OpenSSLCertificate& other) const {
   return X509_cmp(x509_, other.x509_) == 0;
 }
@@ -302,11 +284,9 @@
   return !(*this == other);
 }
 
-// Documented in sslidentity.h.
 int64_t OpenSSLCertificate::CertificateExpirationTime() const {
   ASN1_TIME* expire_time = X509_get_notAfter(x509_);
   bool long_format;
-
   if (expire_time->type == V_ASN1_UTCTIME) {
     long_format = false;
   } else if (expire_time->type == V_ASN1_GENERALIZEDTIME) {
@@ -314,7 +294,6 @@
   } else {
     return -1;
   }
-
   return ASN1TimeToSec(expire_time->data, expire_time->length, long_format);
 }
 
diff --git a/rtc_base/opensslcertificate.h b/rtc_base/opensslcertificate.h
index b7ecc3b..088725c 100644
--- a/rtc_base/opensslcertificate.h
+++ b/rtc_base/opensslcertificate.h
@@ -11,18 +11,16 @@
 #ifndef RTC_BASE_OPENSSLCERTIFICATE_H_
 #define RTC_BASE_OPENSSLCERTIFICATE_H_
 
-#include <openssl/base.h>  // for X509, ssl_ctx_st
+#include <openssl/ossl_typ.h>
 
-#include <stddef.h>  // for size_t
-#include <stdint.h>  // for int64_t
+#include <stddef.h>
+#include <stdint.h>
 #include <string>
 
-#include "rtc_base/buffer.h"            // for Buffer
-#include "rtc_base/constructormagic.h"  // for RTC_DISALLOW_COPY_AND_ASSIGN
-#include "rtc_base/sslcertificate.h"    // for SSLCertificate
-#include "rtc_base/sslidentity.h"       // for SSLIdentityParams
-
-typedef struct ssl_ctx_st SSL_CTX;
+#include "rtc_base/buffer.h"
+#include "rtc_base/constructormagic.h"
+#include "rtc_base/sslcertificate.h"
+#include "rtc_base/sslidentity.h"
 
 namespace rtc {
 
@@ -30,19 +28,21 @@
 
 // OpenSSLCertificate encapsulates an OpenSSL X509* certificate object,
 // which is also reference counted inside the OpenSSL library.
-class OpenSSLCertificate : public SSLCertificate {
+class OpenSSLCertificate final : public SSLCertificate {
  public:
   // X509 object has its reference count incremented. So the caller and
   // OpenSSLCertificate share ownership.
   explicit OpenSSLCertificate(X509* x509);
 
-  static OpenSSLCertificate* Generate(OpenSSLKeyPair* key_pair,
-                                      const SSLIdentityParams& params);
-  static OpenSSLCertificate* FromPEMString(const std::string& pem_string);
+  static std::unique_ptr<OpenSSLCertificate> Generate(
+      OpenSSLKeyPair* key_pair,
+      const SSLIdentityParams& params);
+  static std::unique_ptr<OpenSSLCertificate> FromPEMString(
+      const std::string& pem_string);
 
   ~OpenSSLCertificate() override;
 
-  OpenSSLCertificate* GetReference() const override;
+  std::unique_ptr<SSLCertificate> Clone() const override;
 
   X509* x509() const { return x509_; }
 
@@ -69,8 +69,6 @@
   int64_t CertificateExpirationTime() const override;
 
  private:
-  void AddReference() const;
-
   X509* x509_;  // NOT OWNED
   RTC_DISALLOW_COPY_AND_ASSIGN(OpenSSLCertificate);
 };
diff --git a/rtc_base/openssldigest.cc b/rtc_base/openssldigest.cc
index 9b644c4..da90b65 100644
--- a/rtc_base/openssldigest.cc
+++ b/rtc_base/openssldigest.cc
@@ -10,7 +10,7 @@
 
 #include "rtc_base/openssldigest.h"
 
-#include "rtc_base/checks.h"
+#include "rtc_base/checks.h"  // RTC_DCHECK, RTC_CHECK
 #include "rtc_base/openssl.h"
 
 namespace rtc {
diff --git a/rtc_base/openssldigest.h b/rtc_base/openssldigest.h
index 1427a94..82dc9a9 100644
--- a/rtc_base/openssldigest.h
+++ b/rtc_base/openssldigest.h
@@ -11,7 +11,8 @@
 #ifndef RTC_BASE_OPENSSLDIGEST_H_
 #define RTC_BASE_OPENSSLDIGEST_H_
 
-#include <openssl/base.h>  // for EVP_MD, EVP_MD_CTX
+#include <openssl/base.h>
+#include <stddef.h>
 #include <string>
 
 #include "rtc_base/messagedigest.h"
@@ -19,7 +20,7 @@
 namespace rtc {
 
 // An implementation of the digest class that uses OpenSSL.
-class OpenSSLDigest : public MessageDigest {
+class OpenSSLDigest final : public MessageDigest {
  public:
   // Creates an OpenSSLDigest with |algorithm| as the hash algorithm.
   explicit OpenSSLDigest(const std::string& algorithm);
diff --git a/rtc_base/opensslidentity.cc b/rtc_base/opensslidentity.cc
index a8c6919..9850c85 100644
--- a/rtc_base/opensslidentity.cc
+++ b/rtc_base/opensslidentity.cc
@@ -21,18 +21,17 @@
 
 #include <openssl/bio.h>
 #include <openssl/bn.h>
-#include <openssl/crypto.h>
 #include <openssl/err.h>
 #include <openssl/pem.h>
 #include <openssl/rsa.h>
 
+#include <stdint.h>
+
 #include "absl/memory/memory.h"
 #include "rtc_base/checks.h"
-#include "rtc_base/helpers.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/numerics/safe_conversions.h"
 #include "rtc_base/openssl.h"
-#include "rtc_base/openssldigest.h"
 #include "rtc_base/opensslutility.h"
 
 namespace rtc {
@@ -316,7 +315,7 @@
 
 OpenSSLIdentity* OpenSSLIdentity::GetReference() const {
   return new OpenSSLIdentity(absl::WrapUnique(key_pair_->GetReference()),
-                             absl::WrapUnique(cert_chain_->Copy()));
+                             cert_chain_->Clone());
 }
 
 bool OpenSSLIdentity::ConfigureIdentity(SSL_CTX* ctx) {
diff --git a/rtc_base/opensslidentity.h b/rtc_base/opensslidentity.h
index b72a4c2..fcf7deb 100644
--- a/rtc_base/opensslidentity.h
+++ b/rtc_base/opensslidentity.h
@@ -11,25 +11,23 @@
 #ifndef RTC_BASE_OPENSSLIDENTITY_H_
 #define RTC_BASE_OPENSSLIDENTITY_H_
 
-#include <openssl/base.h>  // for EVP_PKEY, ssl_ctx_st
+#include <openssl/ossl_typ.h>
 
-#include <ctime>   // for time_t
-#include <memory>  // for unique_ptr
+#include <ctime>
+#include <memory>
 #include <string>
 
-#include "rtc_base/checks.h"              // for RTC_DCHECK
-#include "rtc_base/constructormagic.h"    // for RTC_DISALLOW_COPY_AND_ASSIGN
-#include "rtc_base/opensslcertificate.h"  // for OpenSSLCertificate
-#include "rtc_base/sslcertificate.h"      // for SSLCertChain
-#include "rtc_base/sslidentity.h"         // for SSLIdentity, KeyParams, SSL...
-
-typedef struct ssl_ctx_st SSL_CTX;
+#include "rtc_base/checks.h"
+#include "rtc_base/constructormagic.h"
+#include "rtc_base/opensslcertificate.h"
+#include "rtc_base/sslcertificate.h"
+#include "rtc_base/sslidentity.h"
 
 namespace rtc {
 
 // OpenSSLKeyPair encapsulates an OpenSSL EVP_PKEY* keypair object,
 // which is reference counted inside the OpenSSL library.
-class OpenSSLKeyPair {
+class OpenSSLKeyPair final {
  public:
   explicit OpenSSLKeyPair(EVP_PKEY* pkey) : pkey_(pkey) {
     RTC_DCHECK(pkey_ != nullptr);
@@ -60,7 +58,7 @@
 
 // Holds a keypair and certificate together, and a method to generate
 // them consistently.
-class OpenSSLIdentity : public SSLIdentity {
+class OpenSSLIdentity final : public SSLIdentity {
  public:
   static OpenSSLIdentity* GenerateWithExpiration(const std::string& common_name,
                                                  const KeyParams& key_params,
diff --git a/rtc_base/opensslstreamadapter.cc b/rtc_base/opensslstreamadapter.cc
index fd54a08..727cb84 100644
--- a/rtc_base/opensslstreamadapter.cc
+++ b/rtc_base/opensslstreamadapter.cc
@@ -22,6 +22,7 @@
 #endif
 
 #include <memory>
+#include <utility>
 #include <vector>
 
 #include "rtc_base/checks.h"
@@ -31,6 +32,7 @@
 #include "rtc_base/openssladapter.h"
 #include "rtc_base/openssldigest.h"
 #include "rtc_base/opensslidentity.h"
+#include "rtc_base/sslcertificate.h"
 #include "rtc_base/stream.h"
 #include "rtc_base/stringutils.h"
 #include "rtc_base/thread.h"
@@ -180,8 +182,9 @@
 
 static BIO* BIO_new_stream(StreamInterface* stream) {
   BIO* ret = BIO_new(BIO_stream_method());
-  if (ret == nullptr)
+  if (ret == nullptr) {
     return nullptr;
+  }
   BIO_set_data(ret, stream);
   return ret;
 }
@@ -196,14 +199,16 @@
 }
 
 static int stream_free(BIO* b) {
-  if (b == nullptr)
+  if (b == nullptr) {
     return 0;
+  }
   return 1;
 }
 
 static int stream_read(BIO* b, char* out, int outl) {
-  if (!out)
+  if (!out) {
     return -1;
+  }
   StreamInterface* stream = static_cast<StreamInterface*>(BIO_get_data(b));
   BIO_clear_retry_flags(b);
   size_t read;
@@ -218,8 +223,9 @@
 }
 
 static int stream_write(BIO* b, const char* in, int inl) {
-  if (!in)
+  if (!in) {
     return -1;
+  }
   StreamInterface* stream = static_cast<StreamInterface*>(BIO_get_data(b));
   BIO_clear_retry_flags(b);
   size_t written;
@@ -296,7 +302,7 @@
     size_t digest_len,
     SSLPeerCertificateDigestError* error) {
   RTC_DCHECK(!peer_certificate_verified_);
-  RTC_DCHECK(!has_peer_certificate_digest());
+  RTC_DCHECK(!HasPeerCertificateDigest());
   size_t expected_len;
   if (error) {
     *error = SSLPeerCertificateDigestError::NONE;
@@ -362,8 +368,9 @@
 }
 
 bool OpenSSLStreamAdapter::GetSslCipherSuite(int* cipher_suite) {
-  if (state_ != SSL_CONNECTED)
+  if (state_ != SSL_CONNECTED) {
     return false;
+  }
 
   const SSL_CIPHER* current_cipher = SSL_get_current_cipher(ssl_);
   if (current_cipher == nullptr) {
@@ -380,17 +387,19 @@
 
   int ssl_version = SSL_version(ssl_);
   if (ssl_mode_ == SSL_MODE_DTLS) {
-    if (ssl_version == DTLS1_VERSION)
+    if (ssl_version == DTLS1_VERSION) {
       return SSL_PROTOCOL_DTLS_10;
-    else if (ssl_version == DTLS1_2_VERSION)
+    } else if (ssl_version == DTLS1_2_VERSION) {
       return SSL_PROTOCOL_DTLS_12;
+    }
   } else {
-    if (ssl_version == TLS1_VERSION)
+    if (ssl_version == TLS1_VERSION) {
       return SSL_PROTOCOL_TLS_10;
-    else if (ssl_version == TLS1_1_VERSION)
+    } else if (ssl_version == TLS1_1_VERSION) {
       return SSL_PROTOCOL_TLS_11;
-    else if (ssl_version == TLS1_2_VERSION)
+    } else if (ssl_version == TLS1_2_VERSION) {
       return SSL_PROTOCOL_TLS_12;
+    }
   }
 
   return -1;
@@ -403,15 +412,11 @@
                                                 bool use_context,
                                                 uint8_t* result,
                                                 size_t result_len) {
-  int i;
-
-  i = SSL_export_keying_material(ssl_, result, result_len, label.c_str(),
+  if (SSL_export_keying_material(ssl_, result, result_len, label.c_str(),
                                  label.length(), const_cast<uint8_t*>(context),
-                                 context_len, use_context);
-
-  if (i != 1)
+                                 context_len, use_context) != 1) {
     return false;
-
+  }
   return true;
 }
 
@@ -419,8 +424,9 @@
     const std::vector<int>& ciphers) {
   std::string internal_ciphers;
 
-  if (state_ != SSL_NONE)
+  if (state_ != SSL_NONE) {
     return false;
+  }
 
   for (std::vector<int>::const_iterator cipher = ciphers.begin();
        cipher != ciphers.end(); ++cipher) {
@@ -429,8 +435,9 @@
          ++entry) {
       if (*cipher == entry->id) {
         found = true;
-        if (!internal_ciphers.empty())
+        if (!internal_ciphers.empty()) {
           internal_ciphers += ":";
+        }
         internal_ciphers += entry->internal_name;
         break;
       }
@@ -442,8 +449,9 @@
     }
   }
 
-  if (internal_ciphers.empty())
+  if (internal_ciphers.empty()) {
     return false;
+  }
 
   srtp_ciphers_ = internal_ciphers;
   return true;
@@ -451,14 +459,16 @@
 
 bool OpenSSLStreamAdapter::GetDtlsSrtpCryptoSuite(int* crypto_suite) {
   RTC_DCHECK(state_ == SSL_CONNECTED);
-  if (state_ != SSL_CONNECTED)
+  if (state_ != SSL_CONNECTED) {
     return false;
+  }
 
   const SRTP_PROTECTION_PROFILE* srtp_profile =
       SSL_get_selected_srtp_profile(ssl_);
 
-  if (!srtp_profile)
+  if (!srtp_profile) {
     return false;
+  }
 
   *crypto_suite = srtp_profile->id;
   RTC_DCHECK(!SrtpCryptoSuiteToName(*crypto_suite).empty());
@@ -470,8 +480,8 @@
 }
 
 int OpenSSLStreamAdapter::StartSSL() {
+  // Don't allow StartSSL to be called twice.
   if (state_ != SSL_NONE) {
-    // Don't allow StartSSL to be called twice.
     return -1;
   }
 
@@ -524,7 +534,7 @@
       return SR_BLOCK;
 
     case SSL_CONNECTED:
-      if (waiting_to_verify_peer_certificate()) {
+      if (WaitingToVerifyPeerCertificate()) {
         return SR_BLOCK;
       }
       break;
@@ -532,15 +542,17 @@
     case SSL_ERROR:
     case SSL_CLOSED:
     default:
-      if (error)
+      if (error) {
         *error = ssl_error_code_;
+      }
       return SR_ERROR;
   }
 
   // OpenSSL will return an error if we try to write zero bytes
   if (data_len == 0) {
-    if (written)
+    if (written) {
       *written = 0;
+    }
     return SR_SUCCESS;
   }
 
@@ -567,8 +579,9 @@
     case SSL_ERROR_ZERO_RETURN:
     default:
       Error("SSL_write", (ssl_error ? ssl_error : -1), 0, false);
-      if (error)
+      if (error) {
         *error = ssl_error_code_;
+      }
       return SR_ERROR;
   }
   // not reached
@@ -583,31 +596,29 @@
     case SSL_NONE:
       // pass-through in clear text
       return StreamAdapterInterface::Read(data, data_len, read, error);
-
     case SSL_WAIT:
     case SSL_CONNECTING:
       return SR_BLOCK;
-
     case SSL_CONNECTED:
-      if (waiting_to_verify_peer_certificate()) {
+      if (WaitingToVerifyPeerCertificate()) {
         return SR_BLOCK;
       }
       break;
-
     case SSL_CLOSED:
       return SR_EOS;
-
     case SSL_ERROR:
     default:
-      if (error)
+      if (error) {
         *error = ssl_error_code_;
+      }
       return SR_ERROR;
   }
 
   // Don't trust OpenSSL with zero byte reads
   if (data_len == 0) {
-    if (read)
+    if (read) {
       *read = 0;
+    }
     return SR_SUCCESS;
   }
 
@@ -620,8 +631,9 @@
       RTC_LOG(LS_VERBOSE) << " -- success";
       RTC_DCHECK_GT(code, 0);
       RTC_DCHECK_LE(code, data_len);
-      if (read)
+      if (read) {
         *read = code;
+      }
 
       if (ssl_mode_ == SSL_MODE_DTLS) {
         // Enforce atomic reads -- this is a short read
@@ -630,8 +642,9 @@
         if (pending) {
           RTC_LOG(LS_INFO) << " -- short DTLS read. flushing";
           FlushInput(pending);
-          if (error)
+          if (error) {
             *error = SSE_MSG_TRUNC;
+          }
           return SR_ERROR;
         }
       }
@@ -650,8 +663,9 @@
       break;
     default:
       Error("SSL_read", (ssl_error ? ssl_error : -1), 0, false);
-      if (error)
+      if (error) {
         *error = ssl_error_code_;
+      }
       return SR_ERROR;
   }
   // not reached
@@ -694,13 +708,13 @@
     case SSL_CONNECTING:
       return SS_OPENING;
     case SSL_CONNECTED:
-      if (waiting_to_verify_peer_certificate()) {
+      if (WaitingToVerifyPeerCertificate()) {
         return SS_OPENING;
       }
       return SS_OPEN;
     default:
       return SS_CLOSED;
-  };
+  }
   // not reached
 }
 
@@ -710,6 +724,7 @@
   int events_to_signal = 0;
   int signal_error = 0;
   RTC_DCHECK(stream == this->stream());
+
   if ((events & SE_OPEN)) {
     RTC_LOG(LS_VERBOSE) << "OpenSSLStreamAdapter::OnEvent SE_OPEN";
     if (state_ != SSL_WAIT) {
@@ -723,6 +738,7 @@
       }
     }
   }
+
   if ((events & (SE_READ | SE_WRITE))) {
     RTC_LOG(LS_VERBOSE) << "OpenSSLStreamAdapter::OnEvent"
                         << ((events & SE_READ) ? " SE_READ" : "")
@@ -747,6 +763,7 @@
       }
     }
   }
+
   if ((events & SE_CLOSE)) {
     RTC_LOG(LS_VERBOSE) << "OpenSSLStreamAdapter::OnEvent(SE_CLOSE, " << err
                         << ")";
@@ -756,8 +773,10 @@
     RTC_DCHECK(signal_error == 0);
     signal_error = err;
   }
-  if (events_to_signal)
+
+  if (events_to_signal) {
     StreamAdapterInterface::OnEvent(stream, events_to_signal, signal_error);
+  }
 }
 
 int OpenSSLStreamAdapter::BeginSSL() {
@@ -770,12 +789,14 @@
   // First set up the context.
   RTC_DCHECK(ssl_ctx_ == nullptr);
   ssl_ctx_ = SetupSSLContext();
-  if (!ssl_ctx_)
+  if (!ssl_ctx_) {
     return -1;
+  }
 
   bio = BIO_new_stream(static_cast<StreamInterface*>(stream()));
-  if (!bio)
+  if (!bio) {
     return -1;
+  }
 
   ssl_ = SSL_new(ssl_ctx_);
   if (!ssl_) {
@@ -805,8 +826,9 @@
   // commonly supported. BoringSSL doesn't need explicit configuration and has
   // a reasonable default set.
   EC_KEY* ecdh = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
-  if (ecdh == nullptr)
+  if (ecdh == nullptr) {
     return -1;
+  }
   SSL_set_options(ssl_, SSL_OP_SINGLE_ECDH_USE);
   SSL_set_tmp_ecdh(ssl_, ecdh);
   EC_KEY_free(ecdh);
@@ -830,10 +852,10 @@
       RTC_LOG(LS_VERBOSE) << " -- success";
       // By this point, OpenSSL should have given us a certificate, or errored
       // out if one was missing.
-      RTC_DCHECK(peer_cert_chain_ || !client_auth_enabled());
+      RTC_DCHECK(peer_cert_chain_ || !GetClientAuthEnabled());
 
       state_ = SSL_CONNECTED;
-      if (!waiting_to_verify_peer_certificate()) {
+      if (!WaitingToVerifyPeerCertificate()) {
         // We have everything we need to start the connection, so signal
         // SE_OPEN. If we need a client certificate fingerprint and don't have
         // it yet, we'll instead signal SE_OPEN in SetPeerCertificateDigest.
@@ -886,8 +908,9 @@
   state_ = SSL_ERROR;
   ssl_error_code_ = err;
   Cleanup(alert);
-  if (signal)
+  if (signal) {
     StreamAdapterInterface::OnEvent(stream(), SE_CLOSE, err);
+  }
 }
 
 void OpenSSLStreamAdapter::Cleanup(uint8_t alert) {
@@ -990,8 +1013,9 @@
   ctx = SSL_CTX_new(method);
 #endif  // OPENSSL_IS_BORINGSSL
 
-  if (ctx == nullptr)
+  if (ctx == nullptr) {
     return nullptr;
+  }
 
 #ifdef OPENSSL_IS_BORINGSSL
   SSL_CTX_set_min_proto_version(
@@ -1026,7 +1050,7 @@
 #endif
 
   int mode = SSL_VERIFY_PEER;
-  if (client_auth_enabled()) {
+  if (GetClientAuthEnabled()) {
     // Require a certificate from the client.
     // Note: Normally this is always true in production, but it may be disabled
     // for testing purposes (e.g. SSLAdapter unit tests).
@@ -1058,7 +1082,7 @@
 }
 
 bool OpenSSLStreamAdapter::VerifyPeerCertificate() {
-  if (!has_peer_certificate_digest() || !peer_cert_chain_ ||
+  if (!HasPeerCertificateDigest() || !peer_cert_chain_ ||
       !peer_cert_chain_->GetSize()) {
     RTC_LOG(LS_WARNING) << "Missing digest or peer certificate.";
     return false;
@@ -1091,7 +1115,7 @@
 
 std::unique_ptr<SSLCertChain> OpenSSLStreamAdapter::GetPeerSSLCertChain()
     const {
-  return peer_cert_chain_ ? peer_cert_chain_->UniqueCopy() : nullptr;
+  return peer_cert_chain_ ? peer_cert_chain_->Clone() : nullptr;
 }
 
 int OpenSSLStreamAdapter::SSLVerifyCallback(X509_STORE_CTX* store, void* arg) {
@@ -1176,15 +1200,17 @@
 bool OpenSSLStreamAdapter::IsAcceptableCipher(int cipher, KeyType key_type) {
   if (key_type == KT_RSA) {
     for (const cipher_list& c : OK_RSA_ciphers) {
-      if (cipher == c.cipher)
+      if (cipher == c.cipher) {
         return true;
+      }
     }
   }
 
   if (key_type == KT_ECDSA) {
     for (const cipher_list& c : OK_ECDSA_ciphers) {
-      if (cipher == c.cipher)
+      if (cipher == c.cipher) {
         return true;
+      }
     }
   }
 
@@ -1195,22 +1221,24 @@
                                               KeyType key_type) {
   if (key_type == KT_RSA) {
     for (const cipher_list& c : OK_RSA_ciphers) {
-      if (cipher == c.cipher_str)
+      if (cipher == c.cipher_str) {
         return true;
+      }
     }
   }
 
   if (key_type == KT_ECDSA) {
     for (const cipher_list& c : OK_ECDSA_ciphers) {
-      if (cipher == c.cipher_str)
+      if (cipher == c.cipher_str) {
         return true;
+      }
     }
   }
 
   return false;
 }
 
-void OpenSSLStreamAdapter::enable_time_callback_for_testing() {
+void OpenSSLStreamAdapter::EnableTimeCallbackForTesting() {
   g_use_time_callback_for_testing = true;
 }
 
diff --git a/rtc_base/opensslstreamadapter.h b/rtc_base/opensslstreamadapter.h
index 61ffc3d..e012d17 100644
--- a/rtc_base/opensslstreamadapter.h
+++ b/rtc_base/opensslstreamadapter.h
@@ -13,13 +13,18 @@
 
 #include <openssl/ossl_typ.h>
 
+#include <stddef.h>
+#include <stdint.h>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "rtc_base/buffer.h"
+#include "rtc_base/messagequeue.h"
 #include "rtc_base/opensslidentity.h"
+#include "rtc_base/sslidentity.h"
 #include "rtc_base/sslstreamadapter.h"
+#include "rtc_base/stream.h"
 
 namespace rtc {
 
@@ -47,11 +52,11 @@
 
 // Look in sslstreamadapter.h for documentation of the methods.
 
-class OpenSSLIdentity;
+class SSLCertChain;
 
 ///////////////////////////////////////////////////////////////////////////////
 
-class OpenSSLStreamAdapter : public SSLStreamAdapter {
+class OpenSSLStreamAdapter final : public SSLStreamAdapter {
  public:
   explicit OpenSSLStreamAdapter(StreamInterface* stream);
   ~OpenSSLStreamAdapter() override;
@@ -115,7 +120,7 @@
 
   // Use our timeutils.h source of timing in BoringSSL, allowing us to test
   // using a fake clock.
-  static void enable_time_callback_for_testing();
+  static void EnableTimeCallbackForTesting();
 
  protected:
   void OnEvent(StreamInterface* stream, int events, int err) override;
@@ -170,11 +175,11 @@
   // SSL_CTX_set_cert_verify_callback.
   static int SSLVerifyCallback(X509_STORE_CTX* store, void* arg);
 
-  bool waiting_to_verify_peer_certificate() const {
-    return client_auth_enabled() && !peer_certificate_verified_;
+  bool WaitingToVerifyPeerCertificate() const {
+    return GetClientAuthEnabled() && !peer_certificate_verified_;
   }
 
-  bool has_peer_certificate_digest() const {
+  bool HasPeerCertificateDigest() const {
     return !peer_certificate_digest_algorithm_.empty() &&
            !peer_certificate_digest_value_.empty();
   }
diff --git a/rtc_base/opensslutility.cc b/rtc_base/opensslutility.cc
index 46f4547..a3f3347 100644
--- a/rtc_base/opensslutility.cc
+++ b/rtc_base/opensslutility.cc
@@ -9,29 +9,21 @@
  */
 
 #include "rtc_base/opensslutility.h"
-
-#include <memory>
-
-#if defined(WEBRTC_POSIX)
-#include <unistd.h>
-#endif
-
 #if defined(WEBRTC_WIN)
 // Must be included first before openssl headers.
 #include "rtc_base/win32.h"  // NOLINT
 #endif                       // WEBRTC_WIN
 
-#include <openssl/bio.h>
-#include <openssl/crypto.h>
 #include <openssl/err.h>
 #include <openssl/x509.h>
 #include <openssl/x509v3.h>
+#include "rtc_base/openssl.h"
+
+#include <stddef.h>
 
 #include "rtc_base/arraysize.h"
-#include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/numerics/safe_conversions.h"
-#include "rtc_base/openssl.h"
 #include "rtc_base/opensslcertificate.h"
 #ifndef WEBRTC_EXCLUDE_BUILT_IN_SSL_ROOT_CERTS
 #include "rtc_base/sslroots.h"
diff --git a/rtc_base/optionsfile.cc b/rtc_base/optionsfile.cc
deleted file mode 100644
index 535859b..0000000
--- a/rtc_base/optionsfile.cc
+++ /dev/null
@@ -1,181 +0,0 @@
-/*
- *  Copyright 2008 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 "rtc_base/optionsfile.h"
-
-#include <ctype.h>
-
-#include "rtc_base/logging.h"
-#include "rtc_base/stream.h"
-#include "rtc_base/stringencode.h"
-
-namespace rtc {
-
-OptionsFile::OptionsFile(const std::string& path) : path_(path) {}
-
-OptionsFile::~OptionsFile() = default;
-
-bool OptionsFile::Load() {
-  options_.clear();
-  // Open file.
-  FileStream stream;
-  int err;
-  if (!stream.Open(path_, "r", &err)) {
-    RTC_LOG_F(LS_WARNING) << "Could not open file, err=" << err;
-    // We do not consider this an error because we expect there to be no file
-    // until the user saves a setting.
-    return true;
-  }
-  // Read in all its data.
-  std::string line;
-  StreamResult res;
-  for (;;) {
-    res = stream.ReadLine(&line);
-    if (res != SR_SUCCESS) {
-      break;
-    }
-    size_t equals_pos = line.find('=');
-    if (equals_pos == std::string::npos) {
-      // We do not consider this an error. Instead we ignore the line and
-      // keep going.
-      RTC_LOG_F(LS_WARNING) << "Ignoring malformed line in " << path_;
-      continue;
-    }
-    std::string key(line, 0, equals_pos);
-    std::string value(line, equals_pos + 1, line.length() - (equals_pos + 1));
-    options_[key] = value;
-  }
-  if (res != SR_EOS) {
-    RTC_LOG_F(LS_ERROR) << "Error when reading from file";
-    return false;
-  } else {
-    return true;
-  }
-}
-
-bool OptionsFile::Save() {
-  // Open file.
-  FileStream stream;
-  int err;
-  if (!stream.Open(path_, "w", &err)) {
-    RTC_LOG_F(LS_ERROR) << "Could not open file, err=" << err;
-    return false;
-  }
-  // Write out all the data.
-  StreamResult res = SR_SUCCESS;
-  size_t written;
-  int error;
-  for (OptionsMap::const_iterator i = options_.begin(); i != options_.end();
-       ++i) {
-    res =
-        stream.WriteAll(i->first.c_str(), i->first.length(), &written, &error);
-    if (res != SR_SUCCESS) {
-      break;
-    }
-    res = stream.WriteAll("=", 1, &written, &error);
-    if (res != SR_SUCCESS) {
-      break;
-    }
-    res = stream.WriteAll(i->second.c_str(), i->second.length(), &written,
-                          &error);
-    if (res != SR_SUCCESS) {
-      break;
-    }
-    res = stream.WriteAll("\n", 1, &written, &error);
-    if (res != SR_SUCCESS) {
-      break;
-    }
-  }
-  if (res != SR_SUCCESS) {
-    RTC_LOG_F(LS_ERROR) << "Unable to write to file";
-    return false;
-  } else {
-    return true;
-  }
-}
-
-bool OptionsFile::IsLegalName(const std::string& name) {
-  for (size_t pos = 0; pos < name.length(); ++pos) {
-    if (name[pos] == '\n' || name[pos] == '\\' || name[pos] == '=') {
-      // Illegal character.
-      RTC_LOG(LS_WARNING) << "Ignoring operation for illegal option " << name;
-      return false;
-    }
-  }
-  return true;
-}
-
-bool OptionsFile::IsLegalValue(const std::string& value) {
-  for (size_t pos = 0; pos < value.length(); ++pos) {
-    if (value[pos] == '\n' || value[pos] == '\\') {
-      // Illegal character.
-      RTC_LOG(LS_WARNING) << "Ignoring operation for illegal value " << value;
-      return false;
-    }
-  }
-  return true;
-}
-
-bool OptionsFile::GetStringValue(const std::string& option,
-                                 std::string* out_val) const {
-  RTC_LOG(LS_VERBOSE) << "OptionsFile::GetStringValue " << option;
-  if (!IsLegalName(option)) {
-    return false;
-  }
-  OptionsMap::const_iterator i = options_.find(option);
-  if (i == options_.end()) {
-    return false;
-  }
-  *out_val = i->second;
-  return true;
-}
-
-bool OptionsFile::GetIntValue(const std::string& option, int* out_val) const {
-  RTC_LOG(LS_VERBOSE) << "OptionsFile::GetIntValue " << option;
-  if (!IsLegalName(option)) {
-    return false;
-  }
-  OptionsMap::const_iterator i = options_.find(option);
-  if (i == options_.end()) {
-    return false;
-  }
-  return FromString(i->second, out_val);
-}
-
-bool OptionsFile::SetStringValue(const std::string& option,
-                                 const std::string& value) {
-  RTC_LOG(LS_VERBOSE) << "OptionsFile::SetStringValue " << option << ":"
-                      << value;
-  if (!IsLegalName(option) || !IsLegalValue(value)) {
-    return false;
-  }
-  options_[option] = value;
-  return true;
-}
-
-bool OptionsFile::SetIntValue(const std::string& option, int value) {
-  RTC_LOG(LS_VERBOSE) << "OptionsFile::SetIntValue " << option << ":" << value;
-  if (!IsLegalName(option)) {
-    return false;
-  }
-  options_[option] = ToString(value);
-  return true;
-}
-
-bool OptionsFile::RemoveValue(const std::string& option) {
-  RTC_LOG(LS_VERBOSE) << "OptionsFile::RemoveValue " << option;
-  if (!IsLegalName(option)) {
-    return false;
-  }
-  options_.erase(option);
-  return true;
-}
-
-}  // namespace rtc
diff --git a/rtc_base/optionsfile.h b/rtc_base/optionsfile.h
deleted file mode 100644
index 55660ff..0000000
--- a/rtc_base/optionsfile.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- *  Copyright 2008 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 RTC_BASE_OPTIONSFILE_H_
-#define RTC_BASE_OPTIONSFILE_H_
-
-#include <map>
-#include <string>
-
-namespace rtc {
-
-// Implements storage of simple options in a text file on disk. This is
-// cross-platform, but it is intended mostly for Linux where there is no
-// first-class options storage system.
-class OptionsFile {
- public:
-  OptionsFile(const std::string& path);
-  ~OptionsFile();
-
-  // Loads the file from disk, overwriting the in-memory values.
-  bool Load();
-  // Saves the contents in memory, overwriting the on-disk values.
-  bool Save();
-
-  bool GetStringValue(const std::string& option, std::string* out_val) const;
-  bool GetIntValue(const std::string& option, int* out_val) const;
-  bool SetStringValue(const std::string& option, const std::string& val);
-  bool SetIntValue(const std::string& option, int val);
-  bool RemoveValue(const std::string& option);
-
- private:
-  typedef std::map<std::string, std::string> OptionsMap;
-
-  static bool IsLegalName(const std::string& name);
-  static bool IsLegalValue(const std::string& value);
-
-  std::string path_;
-  OptionsMap options_;
-};
-
-}  // namespace rtc
-
-#endif  // RTC_BASE_OPTIONSFILE_H_
diff --git a/rtc_base/optionsfile_unittest.cc b/rtc_base/optionsfile_unittest.cc
deleted file mode 100644
index fc5bc82..0000000
--- a/rtc_base/optionsfile_unittest.cc
+++ /dev/null
@@ -1,178 +0,0 @@
-/*
- *  Copyright 2008 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 "rtc_base/checks.h"
-#include "rtc_base/gunit.h"
-#include "rtc_base/optionsfile.h"
-#include "test/testsupport/fileutils.h"
-
-namespace rtc {
-
-static const std::string kTestOptionA = "test-option-a";
-static const std::string kTestOptionB = "test-option-b";
-static const std::string kTestString1 = "a string";
-static const std::string kTestString2 = "different string";
-static const std::string kOptionWithEquals = "foo=bar";
-static const std::string kOptionWithNewline = "foo\nbar";
-static const std::string kValueWithEquals = "baz=quux";
-static const std::string kValueWithNewline = "baz\nquux";
-static const std::string kEmptyString = "";
-static const char kOptionWithUtf8[] = {'O',    'p', 't', '\302', '\256',
-                                       'i',    'o', 'n', '\342', '\204',
-                                       '\242', '\0'};  // Opt(R)io(TM).
-static const char kValueWithUtf8[] = {
-    'V', 'a',    'l',    '\302', '\256', 'v',
-    'e', '\342', '\204', '\242', '\0'};  // Val(R)ue(TM).
-static int kTestInt1 = 12345;
-static int kTestInt2 = 67890;
-static int kNegInt = -634;
-static int kZero = 0;
-
-#if defined(WEBRTC_ANDROID)
-// Fails on Android: https://bugs.chromium.org/p/webrtc/issues/detail?id=4364.
-#define MAYBE_OptionsFileTest DISABLED_OptionsFileTest
-#else
-#define MAYBE_OptionsFileTest OptionsFileTest
-#endif
-
-class MAYBE_OptionsFileTest : public testing::Test {
- public:
-  MAYBE_OptionsFileTest() {
-    test_file_ =
-        webrtc::test::TempFilename(webrtc::test::OutputPath(), ".testfile");
-    OpenStore();
-  }
-
-  ~MAYBE_OptionsFileTest() override { webrtc::test::RemoveFile(test_file_); }
-
- protected:
-  void OpenStore() { store_.reset(new OptionsFile(test_file_)); }
-
-  std::unique_ptr<OptionsFile> store_;
-
- private:
-  std::string test_file_;
-};
-
-TEST_F(MAYBE_OptionsFileTest, GetSetString) {
-  // Clear contents of the file on disk.
-  EXPECT_TRUE(store_->Save());
-  std::string out1, out2;
-  EXPECT_FALSE(store_->GetStringValue(kTestOptionA, &out1));
-  EXPECT_FALSE(store_->GetStringValue(kTestOptionB, &out2));
-  EXPECT_TRUE(store_->SetStringValue(kTestOptionA, kTestString1));
-  EXPECT_TRUE(store_->Save());
-  EXPECT_TRUE(store_->Load());
-  EXPECT_TRUE(store_->SetStringValue(kTestOptionB, kTestString2));
-  EXPECT_TRUE(store_->Save());
-  EXPECT_TRUE(store_->Load());
-  EXPECT_TRUE(store_->GetStringValue(kTestOptionA, &out1));
-  EXPECT_TRUE(store_->GetStringValue(kTestOptionB, &out2));
-  EXPECT_EQ(kTestString1, out1);
-  EXPECT_EQ(kTestString2, out2);
-  EXPECT_TRUE(store_->RemoveValue(kTestOptionA));
-  EXPECT_TRUE(store_->Save());
-  EXPECT_TRUE(store_->Load());
-  EXPECT_TRUE(store_->RemoveValue(kTestOptionB));
-  EXPECT_TRUE(store_->Save());
-  EXPECT_TRUE(store_->Load());
-  EXPECT_FALSE(store_->GetStringValue(kTestOptionA, &out1));
-  EXPECT_FALSE(store_->GetStringValue(kTestOptionB, &out2));
-}
-
-TEST_F(MAYBE_OptionsFileTest, GetSetInt) {
-  // Clear contents of the file on disk.
-  EXPECT_TRUE(store_->Save());
-  int out1, out2;
-  EXPECT_FALSE(store_->GetIntValue(kTestOptionA, &out1));
-  EXPECT_FALSE(store_->GetIntValue(kTestOptionB, &out2));
-  EXPECT_TRUE(store_->SetIntValue(kTestOptionA, kTestInt1));
-  EXPECT_TRUE(store_->Save());
-  EXPECT_TRUE(store_->Load());
-  EXPECT_TRUE(store_->SetIntValue(kTestOptionB, kTestInt2));
-  EXPECT_TRUE(store_->Save());
-  EXPECT_TRUE(store_->Load());
-  EXPECT_TRUE(store_->GetIntValue(kTestOptionA, &out1));
-  EXPECT_TRUE(store_->GetIntValue(kTestOptionB, &out2));
-  EXPECT_EQ(kTestInt1, out1);
-  EXPECT_EQ(kTestInt2, out2);
-  EXPECT_TRUE(store_->RemoveValue(kTestOptionA));
-  EXPECT_TRUE(store_->Save());
-  EXPECT_TRUE(store_->Load());
-  EXPECT_TRUE(store_->RemoveValue(kTestOptionB));
-  EXPECT_TRUE(store_->Save());
-  EXPECT_TRUE(store_->Load());
-  EXPECT_FALSE(store_->GetIntValue(kTestOptionA, &out1));
-  EXPECT_FALSE(store_->GetIntValue(kTestOptionB, &out2));
-  EXPECT_TRUE(store_->SetIntValue(kTestOptionA, kNegInt));
-  EXPECT_TRUE(store_->GetIntValue(kTestOptionA, &out1));
-  EXPECT_EQ(kNegInt, out1);
-  EXPECT_TRUE(store_->SetIntValue(kTestOptionA, kZero));
-  EXPECT_TRUE(store_->GetIntValue(kTestOptionA, &out1));
-  EXPECT_EQ(kZero, out1);
-}
-
-TEST_F(MAYBE_OptionsFileTest, Persist) {
-  // Clear contents of the file on disk.
-  EXPECT_TRUE(store_->Save());
-  EXPECT_TRUE(store_->SetStringValue(kTestOptionA, kTestString1));
-  EXPECT_TRUE(store_->SetIntValue(kTestOptionB, kNegInt));
-  EXPECT_TRUE(store_->Save());
-
-  // Load the saved contents from above.
-  OpenStore();
-  EXPECT_TRUE(store_->Load());
-  std::string out1;
-  int out2;
-  EXPECT_TRUE(store_->GetStringValue(kTestOptionA, &out1));
-  EXPECT_TRUE(store_->GetIntValue(kTestOptionB, &out2));
-  EXPECT_EQ(kTestString1, out1);
-  EXPECT_EQ(kNegInt, out2);
-}
-
-TEST_F(MAYBE_OptionsFileTest, SpecialCharacters) {
-  // Clear contents of the file on disk.
-  EXPECT_TRUE(store_->Save());
-  std::string out;
-  EXPECT_FALSE(store_->SetStringValue(kOptionWithEquals, kTestString1));
-  EXPECT_FALSE(store_->GetStringValue(kOptionWithEquals, &out));
-  EXPECT_FALSE(store_->SetStringValue(kOptionWithNewline, kTestString1));
-  EXPECT_FALSE(store_->GetStringValue(kOptionWithNewline, &out));
-  EXPECT_TRUE(store_->SetStringValue(kOptionWithUtf8, kValueWithUtf8));
-  EXPECT_TRUE(store_->SetStringValue(kTestOptionA, kTestString1));
-  EXPECT_TRUE(store_->Save());
-  EXPECT_TRUE(store_->Load());
-  EXPECT_TRUE(store_->GetStringValue(kTestOptionA, &out));
-  EXPECT_EQ(kTestString1, out);
-  EXPECT_TRUE(store_->GetStringValue(kOptionWithUtf8, &out));
-  EXPECT_EQ(kValueWithUtf8, out);
-  EXPECT_FALSE(store_->SetStringValue(kTestOptionA, kValueWithNewline));
-  EXPECT_TRUE(store_->GetStringValue(kTestOptionA, &out));
-  EXPECT_EQ(kTestString1, out);
-  EXPECT_TRUE(store_->SetStringValue(kTestOptionA, kValueWithEquals));
-  EXPECT_TRUE(store_->Save());
-  EXPECT_TRUE(store_->Load());
-  EXPECT_TRUE(store_->GetStringValue(kTestOptionA, &out));
-  EXPECT_EQ(kValueWithEquals, out);
-  EXPECT_TRUE(store_->SetStringValue(kEmptyString, kTestString2));
-  EXPECT_TRUE(store_->Save());
-  EXPECT_TRUE(store_->Load());
-  EXPECT_TRUE(store_->GetStringValue(kEmptyString, &out));
-  EXPECT_EQ(kTestString2, out);
-  EXPECT_TRUE(store_->SetStringValue(kTestOptionB, kEmptyString));
-  EXPECT_TRUE(store_->Save());
-  EXPECT_TRUE(store_->Load());
-  EXPECT_TRUE(store_->GetStringValue(kTestOptionB, &out));
-  EXPECT_EQ(kEmptyString, out);
-}
-
-}  // namespace rtc
diff --git a/rtc_base/pathutils.cc b/rtc_base/pathutils.cc
deleted file mode 100644
index 0764671..0000000
--- a/rtc_base/pathutils.cc
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- *  Copyright 2004 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.
- */
-
-#if defined(WEBRTC_WIN)
-#include <windows.h>
-#include <shellapi.h>
-#include <shlobj.h>
-#include <tchar.h>
-#endif  // WEBRTC_WIN
-
-#include <string.h>  // for strchr
-
-#include "rtc_base/pathutils.h"
-
-namespace rtc {
-
-static const char EMPTY_STR[] = "";
-
-// EXT_DELIM separates a file basename from extension
-const char EXT_DELIM = '.';
-
-// FOLDER_DELIMS separate folder segments and the filename
-const char* const FOLDER_DELIMS = "/\\";
-
-// DEFAULT_FOLDER_DELIM is the preferred delimiter for this platform
-#ifdef WEBRTC_WIN
-const char DEFAULT_FOLDER_DELIM = '\\';
-#else  // !WEBRTC_WIN
-const char DEFAULT_FOLDER_DELIM = '/';
-#endif  // !WEBRTC_WIN
-
-///////////////////////////////////////////////////////////////////////////////
-// Pathname - parsing of pathnames into components, and vice versa
-///////////////////////////////////////////////////////////////////////////////
-
-bool Pathname::IsFolderDelimiter(char ch) {
-  return (nullptr != ::strchr(FOLDER_DELIMS, ch));
-}
-
-char Pathname::DefaultFolderDelimiter() {
-  return DEFAULT_FOLDER_DELIM;
-}
-
-Pathname::Pathname()
-    : folder_delimiter_(DEFAULT_FOLDER_DELIM) {
-}
-
-Pathname::Pathname(const Pathname&) = default;
-Pathname::Pathname(Pathname&&) = default;
-
-Pathname::Pathname(const std::string& pathname)
-    : folder_delimiter_(DEFAULT_FOLDER_DELIM) {
-  SetPathname(pathname);
-}
-
-Pathname::Pathname(const std::string& folder, const std::string& filename)
-    : folder_delimiter_(DEFAULT_FOLDER_DELIM) {
-  SetPathname(folder, filename);
-}
-
-Pathname& Pathname::operator=(const Pathname&) = default;
-Pathname& Pathname::operator=(Pathname&&) = default;
-
-std::string Pathname::pathname() const {
-  std::string pathname(folder_);
-  pathname.append(basename_);
-  pathname.append(extension_);
-  if (pathname.empty()) {
-    // Instead of the empty pathname, return the current working directory.
-    pathname.push_back('.');
-    pathname.push_back(folder_delimiter_);
-  }
-  return pathname;
-}
-
-void Pathname::SetPathname(const std::string& pathname) {
-  std::string::size_type pos = pathname.find_last_of(FOLDER_DELIMS);
-  if (pos != std::string::npos) {
-    SetFolder(pathname.substr(0, pos + 1));
-    SetFilename(pathname.substr(pos + 1));
-  } else {
-    SetFolder(EMPTY_STR);
-    SetFilename(pathname);
-  }
-}
-
-void Pathname::SetPathname(const std::string& folder,
-                           const std::string& filename) {
-  SetFolder(folder);
-  SetFilename(filename);
-}
-
-void Pathname::SetFolder(const std::string& folder) {
-  folder_.assign(folder);
-  // Ensure folder ends in a path delimiter
-  if (!folder_.empty() && !IsFolderDelimiter(folder_[folder_.length()-1])) {
-    folder_.push_back(folder_delimiter_);
-  }
-}
-
-void Pathname::AppendFolder(const std::string& folder) {
-  folder_.append(folder);
-  // Ensure folder ends in a path delimiter
-  if (!folder_.empty() && !IsFolderDelimiter(folder_[folder_.length()-1])) {
-    folder_.push_back(folder_delimiter_);
-  }
-}
-
-bool Pathname::SetBasename(const std::string& basename) {
-  if(basename.find_first_of(FOLDER_DELIMS) != std::string::npos) {
-    return false;
-  }
-  basename_.assign(basename);
-  return true;
-}
-
-bool Pathname::SetExtension(const std::string& extension) {
-  if (extension.find_first_of(FOLDER_DELIMS) != std::string::npos ||
-    extension.find_first_of(EXT_DELIM, 1) != std::string::npos) {
-      return false;
-  }
-  extension_.assign(extension);
-  // Ensure extension begins with the extension delimiter
-  if (!extension_.empty() && (extension_[0] != EXT_DELIM)) {
-    extension_.insert(extension_.begin(), EXT_DELIM);
-  }
-  return true;
-}
-
-std::string Pathname::filename() const {
-  std::string filename(basename_);
-  filename.append(extension_);
-  return filename;
-}
-
-bool Pathname::SetFilename(const std::string& filename) {
-  std::string::size_type pos = filename.rfind(EXT_DELIM);
-  if ((pos == std::string::npos) || (pos == 0)) {
-    return SetExtension(EMPTY_STR) && SetBasename(filename);
-  } else {
-    return SetExtension(filename.substr(pos)) && SetBasename(filename.substr(0, pos));
-  }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-} // namespace rtc
diff --git a/rtc_base/pathutils.h b/rtc_base/pathutils.h
deleted file mode 100644
index 59f2a4a..0000000
--- a/rtc_base/pathutils.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- *  Copyright 2004 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 RTC_BASE_PATHUTILS_H_
-#define RTC_BASE_PATHUTILS_H_
-
-#include <string>
-
-namespace rtc {
-
-///////////////////////////////////////////////////////////////////////////////
-// Pathname - parsing of pathnames into components, and vice versa.
-//
-// To establish consistent terminology, a filename never contains a folder
-// component.  A folder never contains a filename.  A pathname may include
-// a folder and/or filename component.  Here are some examples:
-//
-//   pathname()      /home/john/example.txt
-//   folder()        /home/john/
-//   filename()                 example.txt
-//   parent_folder() /home/
-//   folder_name()         john/
-//   basename()                 example
-//   extension()                       .txt
-//
-// Basename may begin, end, and/or include periods, but no folder delimiters.
-// If extension exists, it consists of a period followed by zero or more
-// non-period/non-delimiter characters, and basename is non-empty.
-///////////////////////////////////////////////////////////////////////////////
-
-class Pathname {
- public:
-  // Folder delimiters are slash and backslash
-  static bool IsFolderDelimiter(char ch);
-  static char DefaultFolderDelimiter();
-
-  Pathname();
-  Pathname(const Pathname&);
-  Pathname(Pathname&&);
-  Pathname(const std::string& pathname);
-  Pathname(const std::string& folder, const std::string& filename);
-
-  Pathname& operator=(const Pathname&);
-  Pathname& operator=(Pathname&&);
-
-  // Returns the folder and filename components.  If the pathname is empty,
-  // returns a string representing the current directory (as a relative path,
-  // i.e., ".").
-  std::string pathname() const;
-  void SetPathname(const std::string& pathname);
-  void SetPathname(const std::string& folder, const std::string& filename);
-
-  // SetFolder and AppendFolder will append a folder delimiter, if needed.
-  void SetFolder(const std::string& folder);
-  void AppendFolder(const std::string& folder);
-
-  bool SetBasename(const std::string& basename);
-
-  // SetExtension will prefix a period, if needed.
-  bool SetExtension(const std::string& extension);
-
-  std::string filename() const;
-  bool SetFilename(const std::string& filename);
-
- private:
-  std::string folder_, basename_, extension_;
-  char folder_delimiter_;
-};
-
-}  // namespace rtc
-
-#endif  // RTC_BASE_PATHUTILS_H_
diff --git a/rtc_base/pathutils_unittest.cc b/rtc_base/pathutils_unittest.cc
deleted file mode 100644
index fae4f0a..0000000
--- a/rtc_base/pathutils_unittest.cc
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- *  Copyright 2007 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 "rtc_base/pathutils.h"
-#include "rtc_base/gunit.h"
-
-TEST(Pathname, ReturnsDotForEmptyPathname) {
-  const std::string kCWD =
-      std::string(".") + rtc::Pathname::DefaultFolderDelimiter();
-
-  rtc::Pathname path("/", "");
-  EXPECT_TRUE (path.filename().empty());
-  EXPECT_FALSE(path.pathname().empty());
-  EXPECT_EQ(std::string("/"), path.pathname());
-
-  path.SetPathname("", "foo");
-  EXPECT_FALSE(path.filename().empty());
-  EXPECT_FALSE(path.pathname().empty());
-  EXPECT_EQ(std::string("foo"), path.pathname());
-
-  path.SetPathname("", "");
-  EXPECT_TRUE (path.filename().empty());
-  EXPECT_FALSE(path.pathname().empty());
-  EXPECT_EQ(kCWD, path.pathname());
-
-  path.SetPathname(kCWD, "");
-  EXPECT_TRUE (path.filename().empty());
-  EXPECT_FALSE(path.pathname().empty());
-  EXPECT_EQ(kCWD, path.pathname());
-}
diff --git a/rtc_base/physicalsocketserver_unittest.cc b/rtc_base/physicalsocketserver_unittest.cc
index 1e046c0..4b36cd5 100644
--- a/rtc_base/physicalsocketserver_unittest.cc
+++ b/rtc_base/physicalsocketserver_unittest.cc
@@ -547,7 +547,13 @@
 
 // Test receiving a synchronous signal while not in Wait() and then entering
 // Wait() afterwards.
-TEST_F(PosixSignalDeliveryTest, RaiseThenWait) {
+// TODO(webrtc:7864): Fails on real iOS devices
+#if defined(WEBRTC_IOS) && defined(WEBRTC_ARCH_ARM_FAMILY)
+#define MAYBE_RaiseThenWait DISABLED_RaiseThenWait
+#else
+#define MAYBE_RaiseThenWait RaiseThenWait
+#endif
+TEST_F(PosixSignalDeliveryTest, MAYBE_RaiseThenWait) {
   ASSERT_TRUE(ss_->SetPosixSignalHandler(SIGTERM, &RecordSignal));
   raise(SIGTERM);
   EXPECT_TRUE(ss_->Wait(0, true));
@@ -557,7 +563,13 @@
 
 // Test that we can handle getting tons of repeated signals and that we see all
 // the different ones.
-TEST_F(PosixSignalDeliveryTest, InsanelyManySignals) {
+// TODO(webrtc:7864): Fails on real iOS devices
+#if defined(WEBRTC_IOS) && defined(WEBRTC_ARCH_ARM_FAMILY)
+#define MAYBE_InsanelyManySignals DISABLED_InsanelyManySignals
+#else
+#define MAYBE_InsanelyManySignals InsanelyManySignals
+#endif
+TEST_F(PosixSignalDeliveryTest, MAYBE_InsanelyManySignals) {
   ss_->SetPosixSignalHandler(SIGTERM, &RecordSignal);
   ss_->SetPosixSignalHandler(SIGINT, &RecordSignal);
   for (int i = 0; i < 10000; ++i) {
@@ -597,7 +609,13 @@
 
 // Test that it works no matter what thread the kernel chooses to give the
 // signal to (since it's not guaranteed to be the one that Wait() runs on).
-TEST_F(PosixSignalDeliveryTest, SignalOnDifferentThread) {
+// TODO(webrtc:7864): Fails on real iOS devices
+#if defined(WEBRTC_IOS) && defined(WEBRTC_ARCH_ARM_FAMILY)
+#define MAYBE_SignalOnDifferentThread DISABLED_SignalOnDifferentThread
+#else
+#define MAYBE_SignalOnDifferentThread SignalOnDifferentThread
+#endif
+TEST_F(PosixSignalDeliveryTest, DISABLED_SignalOnDifferentThread) {
   ss_->SetPosixSignalHandler(SIGTERM, &RecordSignal);
   // Mask out SIGTERM so that it can't be delivered to this thread.
   sigset_t mask;
diff --git a/rtc_base/platform_file.cc b/rtc_base/platform_file.cc
index d74acdd..baefb22 100644
--- a/rtc_base/platform_file.cc
+++ b/rtc_base/platform_file.cc
@@ -12,11 +12,11 @@
 
 #if defined(WEBRTC_WIN)
 #include <io.h>
+
 #include "rtc_base/stringutils.h"  // For ToUtf16
 #else
 #include <fcntl.h>
 #include <sys/stat.h>
-#include <sys/types.h>
 #include <unistd.h>
 #endif
 
diff --git a/rtc_base/platform_thread.cc b/rtc_base/platform_thread.cc
index 79d9d53..ba84b6a 100644
--- a/rtc_base/platform_thread.cc
+++ b/rtc_base/platform_thread.cc
@@ -10,15 +10,17 @@
 
 #include "rtc_base/platform_thread.h"
 
+#if !defined(WEBRTC_WIN)
+#include <sched.h>
+#endif
+#include <stdint.h>
+#include <time.h>
+#include <algorithm>
+
 #include "rtc_base/atomicops.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/timeutils.h"
 
-#if defined(WEBRTC_LINUX)
-#include <sys/prctl.h>
-#include <sys/syscall.h>
-#endif
-
 namespace rtc {
 namespace {
 #if defined(WEBRTC_WIN)
diff --git a/rtc_base/platform_thread.h b/rtc_base/platform_thread.h
index ea67aca..47c23dc 100644
--- a/rtc_base/platform_thread.h
+++ b/rtc_base/platform_thread.h
@@ -11,6 +11,9 @@
 #ifndef RTC_BASE_PLATFORM_THREAD_H_
 #define RTC_BASE_PLATFORM_THREAD_H_
 
+#ifndef WEBRTC_WIN
+#include <pthread.h>
+#endif
 #include <string>
 
 #include "rtc_base/constructormagic.h"
diff --git a/rtc_base/race_checker.h b/rtc_base/race_checker.h
index d6eba08..4d57460 100644
--- a/rtc_base/race_checker.h
+++ b/rtc_base/race_checker.h
@@ -12,7 +12,7 @@
 #define RTC_BASE_RACE_CHECKER_H_
 
 #include "rtc_base/checks.h"
-#include "rtc_base/platform_thread_types.h"  // for PlatformThreadRef
+#include "rtc_base/platform_thread_types.h"
 #include "rtc_base/thread_annotations.h"
 
 namespace rtc {
diff --git a/rtc_base/random.h b/rtc_base/random.h
index 2faa985..e1c3bb7 100644
--- a/rtc_base/random.h
+++ b/rtc_base/random.h
@@ -11,6 +11,7 @@
 #ifndef RTC_BASE_RANDOM_H_
 #define RTC_BASE_RANDOM_H_
 
+#include <stdint.h>
 #include <limits>
 
 #include "rtc_base/checks.h"
diff --git a/rtc_base/rate_limiter.cc b/rtc_base/rate_limiter.cc
index 0343f25..5c7bdef 100644
--- a/rtc_base/rate_limiter.cc
+++ b/rtc_base/rate_limiter.cc
@@ -9,6 +9,10 @@
  */
 
 #include "rtc_base/rate_limiter.h"
+
+#include <limits>
+
+#include "absl/types/optional.h"
 #include "system_wrappers/include/clock.h"
 
 namespace webrtc {
diff --git a/rtc_base/rate_limiter.h b/rtc_base/rate_limiter.h
index 0bfde0d..43ef88d 100644
--- a/rtc_base/rate_limiter.h
+++ b/rtc_base/rate_limiter.h
@@ -11,11 +11,13 @@
 #ifndef RTC_BASE_RATE_LIMITER_H_
 #define RTC_BASE_RATE_LIMITER_H_
 
-#include <limits>
+#include <stddef.h>
+#include <stdint.h>
 
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/criticalsection.h"
 #include "rtc_base/rate_statistics.h"
+#include "rtc_base/thread_annotations.h"
 
 namespace webrtc {
 
diff --git a/rtc_base/rate_limiter_unittest.cc b/rtc_base/rate_limiter_unittest.cc
index 6efea54..ac0625f 100644
--- a/rtc_base/rate_limiter_unittest.cc
+++ b/rtc_base/rate_limiter_unittest.cc
@@ -112,9 +112,7 @@
 class ThreadTask {
  public:
   explicit ThreadTask(RateLimiter* rate_limiter)
-      : rate_limiter_(rate_limiter),
-        start_signal_(false, false),
-        end_signal_(false, false) {}
+      : rate_limiter_(rate_limiter) {}
   virtual ~ThreadTask() {}
 
   void Run() {
diff --git a/rtc_base/rate_statistics.h b/rtc_base/rate_statistics.h
index 68035c9..d4ccc59 100644
--- a/rtc_base/rate_statistics.h
+++ b/rtc_base/rate_statistics.h
@@ -11,6 +11,8 @@
 #ifndef RTC_BASE_RATE_STATISTICS_H_
 #define RTC_BASE_RATE_STATISTICS_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <memory>
 
 #include "absl/types/optional.h"
diff --git a/rtc_base/rtccertificate.cc b/rtc_base/rtccertificate.cc
index 786333f..875068f 100644
--- a/rtc_base/rtccertificate.cc
+++ b/rtc_base/rtccertificate.cc
@@ -14,6 +14,8 @@
 
 #include "rtc_base/checks.h"
 #include "rtc_base/refcountedobject.h"
+#include "rtc_base/sslcertificate.h"
+#include "rtc_base/sslidentity.h"
 #include "rtc_base/timeutils.h"
 
 namespace rtc {
@@ -30,7 +32,7 @@
 RTCCertificate::~RTCCertificate() {}
 
 uint64_t RTCCertificate::Expires() const {
-  int64_t expires = ssl_certificate().CertificateExpirationTime();
+  int64_t expires = GetSSLCertificate().CertificateExpirationTime();
   if (expires != -1)
     return static_cast<uint64_t>(expires) * kNumMillisecsPerSec;
   // If the expiration time could not be retrieved return an expired timestamp.
@@ -41,17 +43,22 @@
   return Expires() <= now;
 }
 
+const SSLCertificate& RTCCertificate::GetSSLCertificate() const {
+  return identity_->certificate();
+}
+
+// Deprecated: TODO(benwright) - Remove once chromium is updated.
 const SSLCertificate& RTCCertificate::ssl_certificate() const {
   return identity_->certificate();
 }
 
-const SSLCertChain& RTCCertificate::ssl_cert_chain() const {
+const SSLCertChain& RTCCertificate::GetSSLCertificateChain() const {
   return identity_->cert_chain();
 }
 
 RTCCertificatePEM RTCCertificate::ToPEM() const {
   return RTCCertificatePEM(identity_->PrivateKeyToPEMString(),
-                           ssl_certificate().ToPEMString());
+                           GetSSLCertificate().ToPEMString());
 }
 
 scoped_refptr<RTCCertificate> RTCCertificate::FromPEM(
diff --git a/rtc_base/rtccertificate.h b/rtc_base/rtccertificate.h
index d5422f8..561ea0f 100644
--- a/rtc_base/rtccertificate.h
+++ b/rtc_base/rtccertificate.h
@@ -12,15 +12,18 @@
 #define RTC_BASE_RTCCERTIFICATE_H_
 
 #include <stdint.h>
-
 #include <memory>
+#include <string>
 
 #include "rtc_base/refcount.h"
 #include "rtc_base/scoped_ref_ptr.h"
-#include "rtc_base/sslidentity.h"
 
 namespace rtc {
 
+class SSLCertChain;
+class SSLCertificate;
+class SSLIdentity;
+
 // This class contains PEM strings of an RTCCertificate's private key and
 // certificate and acts as a text representation of RTCCertificate. Certificates
 // can be serialized and deserialized to and from this format, which allows for
@@ -55,11 +58,15 @@
   // Checks if the certificate has expired, where |now| is expressed in ms
   // relative to epoch, 1970-01-01T00:00:00Z.
   bool HasExpired(uint64_t now) const;
+
+  const SSLCertificate& GetSSLCertificate() const;
+  const SSLCertChain& GetSSLCertificateChain() const;
+
+  // Deprecated: TODO(benwright) - Remove once chromium is updated.
   const SSLCertificate& ssl_certificate() const;
-  const SSLCertChain& ssl_cert_chain() const;
 
   // TODO(hbos): If possible, remove once RTCCertificate and its
-  // ssl_certificate() is used in all relevant places. Should not pass around
+  // GetSSLCertificate() is used in all relevant places. Should not pass around
   // raw SSLIdentity* for the sake of accessing SSLIdentity::certificate().
   // However, some places might need SSLIdentity* for its public/private key...
   SSLIdentity* identity() const { return identity_.get(); }
@@ -77,7 +84,7 @@
 
  private:
   // The SSLIdentity is the owner of the SSLCertificate. To protect our
-  // ssl_certificate() we take ownership of |identity_|.
+  // GetSSLCertificate() we take ownership of |identity_|.
   std::unique_ptr<SSLIdentity> identity_;
 };
 
diff --git a/rtc_base/rtccertificategenerator.cc b/rtc_base/rtccertificategenerator.cc
index 0b51c61..114b35c 100644
--- a/rtc_base/rtccertificategenerator.cc
+++ b/rtc_base/rtccertificategenerator.cc
@@ -10,10 +10,15 @@
 
 #include "rtc_base/rtccertificategenerator.h"
 
+#include <time.h>
 #include <algorithm>
 #include <memory>
+#include <utility>
 
 #include "rtc_base/checks.h"
+#include "rtc_base/location.h"
+#include "rtc_base/messagehandler.h"
+#include "rtc_base/messagequeue.h"
 #include "rtc_base/refcountedobject.h"
 #include "rtc_base/sslidentity.h"
 
@@ -23,7 +28,6 @@
 
 // A certificates' subject and issuer name.
 const char kIdentityName[] = "WebRTC";
-
 const uint64_t kYearInSeconds = 365 * 24 * 60 * 60;
 
 enum {
@@ -60,11 +64,9 @@
     switch (msg->message_id) {
       case MSG_GENERATE:
         RTC_DCHECK(worker_thread_->IsCurrent());
-
         // Perform the certificate generation work here on the worker thread.
         certificate_ = RTCCertificateGenerator::GenerateCertificate(
             key_params_, expires_ms_);
-
         // Handle callbacks on signaling thread. Pass on the |msg->pdata|
         // (which references |this| with ref counting) to that thread.
         signaling_thread_->Post(RTC_FROM_HERE, this, MSG_GENERATE_DONE,
@@ -72,14 +74,12 @@
         break;
       case MSG_GENERATE_DONE:
         RTC_DCHECK(signaling_thread_->IsCurrent());
-
         // Perform callback with result here on the signaling thread.
         if (certificate_) {
           callback_->OnSuccess(certificate_);
         } else {
           callback_->OnFailure();
         }
-
         // Destroy |msg->pdata| which references |this| with ref counting. This
         // may result in |this| being deleted - do not touch member variables
         // after this line.
@@ -105,9 +105,11 @@
 scoped_refptr<RTCCertificate> RTCCertificateGenerator::GenerateCertificate(
     const KeyParams& key_params,
     const absl::optional<uint64_t>& expires_ms) {
-  if (!key_params.IsValid())
+  if (!key_params.IsValid()) {
     return nullptr;
-  SSLIdentity* identity;
+  }
+
+  SSLIdentity* identity = nullptr;
   if (!expires_ms) {
     identity = SSLIdentity::Generate(kIdentityName, key_params);
   } else {
@@ -124,8 +126,9 @@
     identity = SSLIdentity::GenerateWithExpiration(kIdentityName, key_params,
                                                    cert_lifetime_s);
   }
-  if (!identity)
+  if (!identity) {
     return nullptr;
+  }
   std::unique_ptr<SSLIdentity> identity_sptr(identity);
   return RTCCertificate::Create(std::move(identity_sptr));
 }
diff --git a/rtc_base/rtccertificategenerator.h b/rtc_base/rtccertificategenerator.h
index a6c503a..fed075e 100644
--- a/rtc_base/rtccertificategenerator.h
+++ b/rtc_base/rtccertificategenerator.h
@@ -11,6 +11,8 @@
 #ifndef RTC_BASE_RTCCERTIFICATEGENERATOR_H_
 #define RTC_BASE_RTCCERTIFICATEGENERATOR_H_
 
+#include <stdint.h>
+
 #include "absl/types/optional.h"
 #include "rtc_base/refcount.h"
 #include "rtc_base/rtccertificate.h"
diff --git a/rtc_base/sanitizer.h b/rtc_base/sanitizer.h
index 23a748f..a9eccfc 100644
--- a/rtc_base/sanitizer.h
+++ b/rtc_base/sanitizer.h
@@ -123,9 +123,11 @@
 
 template <typename T>
 inline T MsanUninitialized(T t) {
+#if RTC_HAS_MSAN
   // TODO(bugs.webrtc.org/8762): Switch to std::is_trivially_copyable when it
   // becomes available in downstream projects.
   static_assert(sanitizer_impl::IsTriviallyCopyable<T>(), "");
+#endif
   rtc_MsanMarkUninitialized(&t, sizeof(T), 1);
   return t;
 }
diff --git a/rtc_base/sequenced_task_checker_impl.cc b/rtc_base/sequenced_task_checker_impl.cc
index 16069c2..717cb95 100644
--- a/rtc_base/sequenced_task_checker_impl.cc
+++ b/rtc_base/sequenced_task_checker_impl.cc
@@ -14,6 +14,7 @@
 #include <dispatch/dispatch.h>
 #endif
 
+#include "rtc_base/checks.h"
 #include "rtc_base/sequenced_task_checker.h"
 #include "rtc_base/task_queue.h"
 
diff --git a/rtc_base/sequenced_task_checker_unittest.cc b/rtc_base/sequenced_task_checker_unittest.cc
index 83fb14f..7b7247c 100644
--- a/rtc_base/sequenced_task_checker_unittest.cc
+++ b/rtc_base/sequenced_task_checker_unittest.cc
@@ -44,7 +44,6 @@
   CallCalledSequentiallyOnThread(bool expect_true,
                                  SequencedTaskChecker* sequenced_task_checker)
       : expect_true_(expect_true),
-        thread_has_run_event_(false, false),
         thread_(&Run, this, "call_do_stuff_on_thread"),
         sequenced_task_checker_(sequenced_task_checker) {
     thread_.Start();
@@ -78,7 +77,6 @@
   explicit DeleteSequencedCheckerOnThread(
       std::unique_ptr<SequencedTaskChecker> sequenced_task_checker)
       : thread_(&Run, this, "delete_sequenced_task_checker_on_thread"),
-        thread_has_run_event_(false, false),
         sequenced_task_checker_(std::move(sequenced_task_checker)) {
     thread_.Start();
   }
@@ -119,7 +117,7 @@
 
   static const char kQueueName[] = "MethodNotAllowedOnDifferentTq";
   TaskQueue queue(kQueueName);
-  Event done_event(false, false);
+  Event done_event;
   queue.PostTask([&sequenced_task_checker, &done_event, expect_true] {
     if (expect_true)
       EXPECT_TRUE(sequenced_task_checker->CalledSequentially());
@@ -136,7 +134,7 @@
 
   sequenced_task_checker->Detach();
 
-  Event done_event(false, false);
+  Event done_event;
   TaskQueue queue1("DetachThenCallFromDifferentTaskQueueImpl1");
   queue1.PostTask([&sequenced_task_checker, &done_event] {
     EXPECT_TRUE(sequenced_task_checker->CalledSequentially());
@@ -194,7 +192,7 @@
   sequenced_task_checker->Detach();
   static const char kQueueName[] = "DetachFromThreadAndUseOnTaskQueue";
   TaskQueue queue(kQueueName);
-  Event done_event(false, false);
+  Event done_event;
   queue.PostTask([&sequenced_task_checker, &done_event] {
     EXPECT_TRUE(sequenced_task_checker->CalledSequentially());
     done_event.Set();
@@ -204,7 +202,7 @@
 
 TEST(SequencedTaskCheckerTest, DetachFromTaskQueueAndUseOnThread) {
   TaskQueue queue("DetachFromTaskQueueAndUseOnThread");
-  Event done_event(false, false);
+  Event done_event;
   queue.PostTask([&done_event] {
     std::unique_ptr<SequencedTaskChecker> sequenced_task_checker(
         new SequencedTaskChecker());
@@ -272,7 +270,7 @@
   TestAnnotations annotations;
   static const char kQueueName[] = "TestAnnotationsOnWrongQueueDebug";
   TaskQueue queue(kQueueName);
-  Event done_event(false, false);
+  Event done_event;
   queue.PostTask([&annotations, &done_event] {
     annotations.ModifyTestVar();
     done_event.Set();
diff --git a/rtc_base/signalthread.cc b/rtc_base/signalthread.cc
index 2e0fa0c..5dd9387 100644
--- a/rtc_base/signalthread.cc
+++ b/rtc_base/signalthread.cc
@@ -10,9 +10,13 @@
 
 #include "rtc_base/signalthread.h"
 
+#include <memory>
+
 #include "absl/memory/memory.h"
 #include "rtc_base/checks.h"
+#include "rtc_base/location.h"
 #include "rtc_base/nullsocketserver.h"
+#include "rtc_base/socketserver.h"
 
 namespace rtc {
 
diff --git a/rtc_base/signalthread.h b/rtc_base/signalthread.h
index 448b289..9208e2c 100644
--- a/rtc_base/signalthread.h
+++ b/rtc_base/signalthread.h
@@ -14,13 +14,13 @@
 #include <string>
 
 #include "rtc_base/checks.h"
-#include "rtc_base/constructormagic.h"             // for RTC_DISALLOW_IMPLI...
-#include "rtc_base/criticalsection.h"              // for CriticalSection
-#include "rtc_base/messagehandler.h"               // for MessageHandler
-#include "rtc_base/messagequeue.h"                 // for Message
-#include "rtc_base/third_party/sigslot/sigslot.h"  // for has_slots, signal_...
-#include "rtc_base/thread.h"                       // for Thread
-#include "rtc_base/thread_annotations.h"           // for RTC_EXCLUSIVE_LOCK...
+#include "rtc_base/constructormagic.h"
+#include "rtc_base/criticalsection.h"
+#include "rtc_base/messagehandler.h"
+#include "rtc_base/messagequeue.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
+#include "rtc_base/thread.h"
+#include "rtc_base/thread_annotations.h"
 
 namespace rtc {
 
diff --git a/rtc_base/socket.cc b/rtc_base/socket.cc
index a9749a4..f19b344 100644
--- a/rtc_base/socket.cc
+++ b/rtc_base/socket.cc
@@ -12,16 +12,4 @@
 
 namespace rtc {
 
-PacketInfo::PacketInfo() = default;
-PacketInfo::PacketInfo(const PacketInfo& info) = default;
-PacketInfo::~PacketInfo() = default;
-
-SentPacket::SentPacket() = default;
-SentPacket::SentPacket(int64_t packet_id, int64_t send_time_ms)
-    : packet_id(packet_id), send_time_ms(send_time_ms) {}
-SentPacket::SentPacket(int64_t packet_id,
-                       int64_t send_time_ms,
-                       const rtc::PacketInfo& info)
-    : packet_id(packet_id), send_time_ms(send_time_ms), info(info) {}
-
 }  // namespace rtc
diff --git a/rtc_base/socket.h b/rtc_base/socket.h
index 2a3d61d..e7e8210 100644
--- a/rtc_base/socket.h
+++ b/rtc_base/socket.h
@@ -25,8 +25,8 @@
 #include "rtc_base/win32.h"
 #endif
 
-#include "absl/types/optional.h"
 #include "rtc_base/constructormagic.h"
+#include "rtc_base/network/sent_packet.h"
 #include "rtc_base/socketaddress.h"
 
 // Rather than converting errors into a private namespace,
@@ -123,52 +123,6 @@
   return (e == EWOULDBLOCK) || (e == EAGAIN) || (e == EINPROGRESS);
 }
 
-enum class PacketType {
-  kUnknown,
-  kData,
-  kIceConnectivityCheck,
-  kIceConnectivityCheckResponse,
-  kStunMessage,
-  kTurnMessage,
-};
-
-enum class PacketInfoProtocolType {
-  kUnknown,
-  kUdp,
-  kTcp,
-  kSsltcp,
-  kTls,
-};
-
-struct PacketInfo {
-  PacketInfo();
-  PacketInfo(const PacketInfo& info);
-  ~PacketInfo();
-
-  bool included_in_feedback;
-  bool included_in_allocation;
-  PacketType packet_type = PacketType::kUnknown;
-  PacketInfoProtocolType protocol = PacketInfoProtocolType::kUnknown;
-  // A unique id assigned by the network manager, and absl::nullopt if not set.
-  absl::optional<uint16_t> network_id;
-  size_t packet_size_bytes = 0;
-  size_t turn_overhead_bytes = 0;
-  SocketAddress local_socket_address;
-  SocketAddress remote_socket_address;
-};
-
-struct SentPacket {
-  SentPacket();
-  SentPacket(int64_t packet_id, int64_t send_time_ms);
-  SentPacket(int64_t packet_id,
-             int64_t send_time_ms,
-             const rtc::PacketInfo& info);
-
-  int64_t packet_id = -1;
-  int64_t send_time_ms = -1;
-  rtc::PacketInfo info;
-};
-
 // General interface for the socket implementations of various networks.  The
 // methods match those of normal UNIX sockets very closely.
 class Socket {
diff --git a/rtc_base/socketadapters.cc b/rtc_base/socketadapters.cc
index 98be868..9451928 100644
--- a/rtc_base/socketadapters.cc
+++ b/rtc_base/socketadapters.cc
@@ -13,18 +13,24 @@
 #endif
 
 #include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 #include <time.h>
 
 #if defined(WEBRTC_WIN)
 #include <windows.h>
 #include <winsock2.h>
 #include <ws2tcpip.h>
+
 #define SECURITY_WIN32
 #include <security.h>
 #endif
 
 #include <algorithm>
 
+#include "absl/strings/match.h"
+#include "rtc_base/buffer.h"
 #include "rtc_base/bytebuffer.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/httpcommon.h"
@@ -456,7 +462,7 @@
         return;
     }
   } else if ((state_ == PS_AUTHENTICATE) &&
-             (_strnicmp(data, "Proxy-Authenticate:", 19) == 0)) {
+             absl::StartsWithIgnoreCase(data, "Proxy-Authenticate:")) {
     std::string response, auth_method;
     switch (HttpAuthenticate(data + 19, len - 19, proxy_, "CONNECT", "/", user_,
                              pass_, context_, response, auth_method)) {
@@ -484,12 +490,12 @@
         unknown_mechanisms_.clear();
         break;
     }
-  } else if (_strnicmp(data, "Content-Length:", 15) == 0) {
+  } else if (absl::StartsWithIgnoreCase(data, "Content-Length:")) {
     content_length_ = strtoul(data + 15, 0, 0);
-  } else if (_strnicmp(data, "Proxy-Connection: Keep-Alive", 28) == 0) {
+  } else if (absl::StartsWithIgnoreCase(data, "Proxy-Connection: Keep-Alive")) {
     expect_close_ = false;
     /*
-  } else if (_strnicmp(data, "Connection: close", 17) == 0) {
+  } else if (absl::StartsWithIgnoreCase(data, "Connection: close") {
     expect_close_ = true;
     */
   }
diff --git a/rtc_base/socketaddresspair.h b/rtc_base/socketaddresspair.h
index 5ff148a..6691386 100644
--- a/rtc_base/socketaddresspair.h
+++ b/rtc_base/socketaddresspair.h
@@ -11,6 +11,8 @@
 #ifndef RTC_BASE_SOCKETADDRESSPAIR_H_
 #define RTC_BASE_SOCKETADDRESSPAIR_H_
 
+#include <stddef.h>
+
 #include "rtc_base/socketaddress.h"
 
 namespace rtc {
diff --git a/rtc_base/socketstream.cc b/rtc_base/socketstream.cc
index 2ea1cec..8978404 100644
--- a/rtc_base/socketstream.cc
+++ b/rtc_base/socketstream.cc
@@ -11,6 +11,7 @@
 #include "rtc_base/socketstream.h"
 
 #include "rtc_base/checks.h"
+#include "rtc_base/socket.h"
 
 namespace rtc {
 
diff --git a/rtc_base/ssladapter.h b/rtc_base/ssladapter.h
index 4843d26..7ebedca 100644
--- a/rtc_base/ssladapter.h
+++ b/rtc_base/ssladapter.h
@@ -16,6 +16,7 @@
 
 #include "rtc_base/asyncsocket.h"
 #include "rtc_base/sslcertificate.h"
+#include "rtc_base/sslidentity.h"
 #include "rtc_base/sslstreamadapter.h"
 
 namespace rtc {
diff --git a/rtc_base/ssladapter_unittest.cc b/rtc_base/ssladapter_unittest.cc
index 8ed460f..c84c668 100644
--- a/rtc_base/ssladapter_unittest.cc
+++ b/rtc_base/ssladapter_unittest.cc
@@ -267,7 +267,7 @@
     // (e.g. a WebRTC-based application and an RFC 5766 TURN server), where
     // clients are not required to provide a certificate during handshake.
     // Accordingly, we must disable client authentication here.
-    ssl_stream_adapter_->set_client_auth_enabled(false);
+    ssl_stream_adapter_->SetClientAuthEnabledForTesting(false);
 
     ssl_stream_adapter_->SetIdentity(ssl_identity_->GetReference());
 
diff --git a/rtc_base/sslcertificate.cc b/rtc_base/sslcertificate.cc
index e40feec..934848f 100644
--- a/rtc_base/sslcertificate.cc
+++ b/rtc_base/sslcertificate.cc
@@ -10,15 +10,15 @@
 
 #include "rtc_base/sslcertificate.h"
 
-#include <algorithm>  // for transform
+#include <algorithm>
 #include <string>
 #include <utility>
 
-#include "absl/memory/memory.h"                  // for WrapUnique, make_unique
-#include "rtc_base/checks.h"                     // for FatalLogCall, RTC_DC...
-#include "rtc_base/opensslcertificate.h"         // for OpenSSLCertificate
-#include "rtc_base/sslfingerprint.h"             // for SSLFingerprint
-#include "rtc_base/third_party/base64/base64.h"  // for Base64
+#include "absl/memory/memory.h"
+#include "rtc_base/checks.h"
+#include "rtc_base/opensslcertificate.h"
+#include "rtc_base/sslfingerprint.h"
+#include "rtc_base/third_party/base64/base64.h"
 
 namespace rtc {
 
@@ -30,7 +30,7 @@
     std::string&& fingerprint,
     std::string&& fingerprint_algorithm,
     std::string&& base64_certificate,
-    std::unique_ptr<SSLCertificateStats>&& issuer)
+    std::unique_ptr<SSLCertificateStats> issuer)
     : fingerprint(std::move(fingerprint)),
       fingerprint_algorithm(std::move(fingerprint_algorithm)),
       base64_certificate(std::move(base64_certificate)),
@@ -54,8 +54,8 @@
   // |SSLCertificate::GetSignatureDigestAlgorithm| is not supported by the
   // implementation of |SSLCertificate::ComputeDigest|. This currently happens
   // with MD5- and SHA-224-signed certificates when linked to libNSS.
-  std::unique_ptr<SSLFingerprint> ssl_fingerprint(
-      SSLFingerprint::Create(digest_algorithm, this));
+  std::unique_ptr<SSLFingerprint> ssl_fingerprint =
+      SSLFingerprint::Create(digest_algorithm, *this);
   if (!ssl_fingerprint)
     return nullptr;
   std::string fingerprint = ssl_fingerprint->GetRfc4572Fingerprint();
@@ -70,49 +70,30 @@
                                                 std::move(der_base64), nullptr);
 }
 
-std::unique_ptr<SSLCertificate> SSLCertificate::GetUniqueReference() const {
-  return absl::WrapUnique(GetReference());
-}
-
 //////////////////////////////////////////////////////////////////////
 // SSLCertChain
 //////////////////////////////////////////////////////////////////////
 
+SSLCertChain::SSLCertChain(std::unique_ptr<SSLCertificate> single_cert) {
+  certs_.push_back(std::move(single_cert));
+}
+
 SSLCertChain::SSLCertChain(std::vector<std::unique_ptr<SSLCertificate>> certs)
     : certs_(std::move(certs)) {}
 
-SSLCertChain::SSLCertChain(const std::vector<SSLCertificate*>& certs) {
-  RTC_DCHECK(!certs.empty());
-  certs_.resize(certs.size());
-  std::transform(
-      certs.begin(), certs.end(), certs_.begin(),
-      [](const SSLCertificate* cert) -> std::unique_ptr<SSLCertificate> {
-        return cert->GetUniqueReference();
-      });
-}
-
-SSLCertChain::SSLCertChain(const SSLCertificate* cert) {
-  certs_.push_back(cert->GetUniqueReference());
-}
-
 SSLCertChain::SSLCertChain(SSLCertChain&& rhs) = default;
 
 SSLCertChain& SSLCertChain::operator=(SSLCertChain&&) = default;
 
-SSLCertChain::~SSLCertChain() {}
+SSLCertChain::~SSLCertChain() = default;
 
-SSLCertChain* SSLCertChain::Copy() const {
+std::unique_ptr<SSLCertChain> SSLCertChain::Clone() const {
   std::vector<std::unique_ptr<SSLCertificate>> new_certs(certs_.size());
-  std::transform(certs_.begin(), certs_.end(), new_certs.begin(),
-                 [](const std::unique_ptr<SSLCertificate>& cert)
-                     -> std::unique_ptr<SSLCertificate> {
-                   return cert->GetUniqueReference();
-                 });
-  return new SSLCertChain(std::move(new_certs));
-}
-
-std::unique_ptr<SSLCertChain> SSLCertChain::UniqueCopy() const {
-  return absl::WrapUnique(Copy());
+  std::transform(
+      certs_.begin(), certs_.end(), new_certs.begin(),
+      [](const std::unique_ptr<SSLCertificate>& cert)
+          -> std::unique_ptr<SSLCertificate> { return cert->Clone(); });
+  return absl::make_unique<SSLCertChain>(std::move(new_certs));
 }
 
 std::unique_ptr<SSLCertificateStats> SSLCertChain::GetStats() const {
@@ -134,7 +115,8 @@
 }
 
 // static
-SSLCertificate* SSLCertificate::FromPEMString(const std::string& pem_string) {
+std::unique_ptr<SSLCertificate> SSLCertificate::FromPEMString(
+    const std::string& pem_string) {
   return OpenSSLCertificate::FromPEMString(pem_string);
 }
 
diff --git a/rtc_base/sslcertificate.h b/rtc_base/sslcertificate.h
index 029404c..eb81c20 100644
--- a/rtc_base/sslcertificate.h
+++ b/rtc_base/sslcertificate.h
@@ -15,6 +15,8 @@
 #ifndef RTC_BASE_SSLCERTIFICATE_H_
 #define RTC_BASE_SSLCERTIFICATE_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <memory>
 #include <string>
 #include <vector>
@@ -28,7 +30,7 @@
   SSLCertificateStats(std::string&& fingerprint,
                       std::string&& fingerprint_algorithm,
                       std::string&& base64_certificate,
-                      std::unique_ptr<SSLCertificateStats>&& issuer);
+                      std::unique_ptr<SSLCertificateStats> issuer);
   ~SSLCertificateStats();
   std::string fingerprint;
   std::string fingerprint_algorithm;
@@ -51,17 +53,13 @@
   // The length of the string representation of the certificate is
   // stored in *pem_length if it is non-null, and only if
   // parsing was successful.
-  // Caller is responsible for freeing the returned object.
-  static SSLCertificate* FromPEMString(const std::string& pem_string);
-  virtual ~SSLCertificate() {}
+  static std::unique_ptr<SSLCertificate> FromPEMString(
+      const std::string& pem_string);
+  virtual ~SSLCertificate() = default;
 
   // Returns a new SSLCertificate object instance wrapping the same
-  // underlying certificate, including its chain if present.  Caller is
-  // responsible for freeing the returned object. Use GetUniqueReference
-  // instead.
-  virtual SSLCertificate* GetReference() const = 0;
-
-  std::unique_ptr<SSLCertificate> GetUniqueReference() const;
+  // underlying certificate, including its chain if present.
+  virtual std::unique_ptr<SSLCertificate> Clone() const = 0;
 
   // Returns a PEM encoded string representation of the certificate.
   virtual std::string ToPEMString() const = 0;
@@ -92,13 +90,10 @@
 // SSLCertChain is a simple wrapper for a vector of SSLCertificates. It serves
 // primarily to ensure proper memory management (especially deletion) of the
 // SSLCertificate pointers.
-class SSLCertChain {
+class SSLCertChain final {
  public:
+  explicit SSLCertChain(std::unique_ptr<SSLCertificate> single_cert);
   explicit SSLCertChain(std::vector<std::unique_ptr<SSLCertificate>> certs);
-  // These constructors copy the provided SSLCertificate(s), so the caller
-  // retains ownership.
-  explicit SSLCertChain(const std::vector<SSLCertificate*>& certs);
-  explicit SSLCertChain(const SSLCertificate* cert);
   // Allow move semantics for the object.
   SSLCertChain(SSLCertChain&&);
   SSLCertChain& operator=(SSLCertChain&&);
@@ -112,10 +107,8 @@
   const SSLCertificate& Get(size_t pos) const { return *(certs_[pos]); }
 
   // Returns a new SSLCertChain object instance wrapping the same underlying
-  // certificate chain.  Caller is responsible for freeing the returned object.
-  SSLCertChain* Copy() const;
-  // Same as above, but returning a unique_ptr for convenience.
-  std::unique_ptr<SSLCertChain> UniqueCopy() const;
+  // certificate chain.
+  std::unique_ptr<SSLCertChain> Clone() const;
 
   // Gets information (fingerprint, etc.) about this certificate chain. This is
   // used for certificate stats, see
diff --git a/rtc_base/sslfingerprint.cc b/rtc_base/sslfingerprint.cc
index 4f1ae8f..b296d33 100644
--- a/rtc_base/sslfingerprint.cc
+++ b/rtc_base/sslfingerprint.cc
@@ -11,66 +11,82 @@
 #include "rtc_base/sslfingerprint.h"
 
 #include <ctype.h>
+#include <algorithm>
+#include <cstdint>
 #include <string>
 
+#include "absl/memory/memory.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/messagedigest.h"
+#include "rtc_base/rtccertificate.h"
+#include "rtc_base/sslcertificate.h"
+#include "rtc_base/sslidentity.h"
 #include "rtc_base/stringencode.h"
 
 namespace rtc {
 
 SSLFingerprint* SSLFingerprint::Create(const std::string& algorithm,
                                        const rtc::SSLIdentity* identity) {
-  if (!identity) {
-    return nullptr;
-  }
-
-  return Create(algorithm, &(identity->certificate()));
+  return CreateUnique(algorithm, *identity).release();
 }
 
-SSLFingerprint* SSLFingerprint::Create(const std::string& algorithm,
-                                       const rtc::SSLCertificate* cert) {
+std::unique_ptr<SSLFingerprint> SSLFingerprint::CreateUnique(
+    const std::string& algorithm,
+    const rtc::SSLIdentity& identity) {
+  return Create(algorithm, identity.certificate());
+}
+
+std::unique_ptr<SSLFingerprint> SSLFingerprint::Create(
+    const std::string& algorithm,
+    const rtc::SSLCertificate& cert) {
   uint8_t digest_val[64];
   size_t digest_len;
-  bool ret = cert->ComputeDigest(algorithm, digest_val, sizeof(digest_val),
-                                 &digest_len);
+  bool ret = cert.ComputeDigest(algorithm, digest_val, sizeof(digest_val),
+                                &digest_len);
   if (!ret) {
     return nullptr;
   }
-
-  return new SSLFingerprint(algorithm, digest_val, digest_len);
+  return absl::make_unique<SSLFingerprint>(
+      algorithm, ArrayView<const uint8_t>(digest_val, digest_len));
 }
 
 SSLFingerprint* SSLFingerprint::CreateFromRfc4572(
     const std::string& algorithm,
     const std::string& fingerprint) {
+  return CreateUniqueFromRfc4572(algorithm, fingerprint).release();
+}
+
+std::unique_ptr<SSLFingerprint> SSLFingerprint::CreateUniqueFromRfc4572(
+    const std::string& algorithm,
+    const std::string& fingerprint) {
   if (algorithm.empty() || !rtc::IsFips180DigestAlgorithm(algorithm))
     return nullptr;
 
   if (fingerprint.empty())
     return nullptr;
 
-  size_t value_len;
   char value[rtc::MessageDigest::kMaxSize];
-  value_len = rtc::hex_decode_with_delimiter(
+  size_t value_len = rtc::hex_decode_with_delimiter(
       value, sizeof(value), fingerprint.c_str(), fingerprint.length(), ':');
   if (!value_len)
     return nullptr;
 
-  return new SSLFingerprint(algorithm, reinterpret_cast<uint8_t*>(value),
-                            value_len);
+  return absl::make_unique<SSLFingerprint>(
+      algorithm,
+      ArrayView<const uint8_t>(reinterpret_cast<uint8_t*>(value), value_len));
 }
 
-SSLFingerprint* SSLFingerprint::CreateFromCertificate(
-    const RTCCertificate* cert) {
+std::unique_ptr<SSLFingerprint> SSLFingerprint::CreateFromCertificate(
+    const RTCCertificate& cert) {
   std::string digest_alg;
-  if (!cert->ssl_certificate().GetSignatureDigestAlgorithm(&digest_alg)) {
+  if (!cert.GetSSLCertificate().GetSignatureDigestAlgorithm(&digest_alg)) {
     RTC_LOG(LS_ERROR)
         << "Failed to retrieve the certificate's digest algorithm";
     return nullptr;
   }
 
-  SSLFingerprint* fingerprint = Create(digest_alg, cert->identity());
+  std::unique_ptr<SSLFingerprint> fingerprint =
+      CreateUnique(digest_alg, *cert.identity());
   if (!fingerprint) {
     RTC_LOG(LS_ERROR) << "Failed to create identity fingerprint, alg="
                       << digest_alg;
@@ -79,11 +95,13 @@
 }
 
 SSLFingerprint::SSLFingerprint(const std::string& algorithm,
+                               ArrayView<const uint8_t> digest_view)
+    : algorithm(algorithm), digest(digest_view.data(), digest_view.size()) {}
+
+SSLFingerprint::SSLFingerprint(const std::string& algorithm,
                                const uint8_t* digest_in,
                                size_t digest_len)
-    : algorithm(algorithm) {
-  digest.SetData(digest_in, digest_len);
-}
+    : SSLFingerprint(algorithm, MakeArrayView(digest_in, digest_len)) {}
 
 SSLFingerprint::SSLFingerprint(const SSLFingerprint& from)
     : algorithm(from.algorithm), digest(from.digest) {}
diff --git a/rtc_base/sslfingerprint.h b/rtc_base/sslfingerprint.h
index b204bc7..ea10ede 100644
--- a/rtc_base/sslfingerprint.h
+++ b/rtc_base/sslfingerprint.h
@@ -11,31 +11,48 @@
 #ifndef RTC_BASE_SSLFINGERPRINT_H_
 #define RTC_BASE_SSLFINGERPRINT_H_
 
+#include <stddef.h>
+#include <stdint.h>
 #include <string>
 
 #include "rtc_base/copyonwritebuffer.h"
-#include "rtc_base/rtccertificate.h"
-#include "rtc_base/sslidentity.h"
 
 namespace rtc {
 
+class RTCCertificate;
 class SSLCertificate;
+class SSLIdentity;
 
 struct SSLFingerprint {
+  // TODO(steveanton): Remove once downstream projects have moved off of this.
   static SSLFingerprint* Create(const std::string& algorithm,
                                 const rtc::SSLIdentity* identity);
+  // TODO(steveanton): Rename to Create once projects have migrated.
+  static std::unique_ptr<SSLFingerprint> CreateUnique(
+      const std::string& algorithm,
+      const rtc::SSLIdentity& identity);
 
-  static SSLFingerprint* Create(const std::string& algorithm,
-                                const rtc::SSLCertificate* cert);
+  static std::unique_ptr<SSLFingerprint> Create(
+      const std::string& algorithm,
+      const rtc::SSLCertificate& cert);
 
+  // TODO(steveanton): Remove once downstream projects have moved off of this.
   static SSLFingerprint* CreateFromRfc4572(const std::string& algorithm,
                                            const std::string& fingerprint);
+  // TODO(steveanton): Rename to CreateFromRfc4572 once projects have migrated.
+  static std::unique_ptr<SSLFingerprint> CreateUniqueFromRfc4572(
+      const std::string& algorithm,
+      const std::string& fingerprint);
 
   // Creates a fingerprint from a certificate, using the same digest algorithm
   // as the certificate's signature.
-  static SSLFingerprint* CreateFromCertificate(const RTCCertificate* cert);
+  static std::unique_ptr<SSLFingerprint> CreateFromCertificate(
+      const RTCCertificate& cert);
 
   SSLFingerprint(const std::string& algorithm,
+                 ArrayView<const uint8_t> digest_view);
+  // TODO(steveanton): Remove once downstream projects have moved off of this.
+  SSLFingerprint(const std::string& algorithm,
                  const uint8_t* digest_in,
                  size_t digest_len);
 
diff --git a/rtc_base/sslidentity.cc b/rtc_base/sslidentity.cc
index 1d136d7..41eb35d 100644
--- a/rtc_base/sslidentity.cc
+++ b/rtc_base/sslidentity.cc
@@ -11,19 +11,96 @@
 // Handling of certificates and keypairs for SSLStreamAdapter's peer mode.
 #include "rtc_base/sslidentity.h"
 
-#include <string.h>  // for strspn
-#include <ctime>
+#include <string.h>
+#include <time.h>
 #include <string>
 
-#include "rtc_base/checks.h"                     // for FatalLogCall, RTC_DC...
-#include "rtc_base/opensslidentity.h"            // for OpenSSLIdentity
-#include "rtc_base/strings/string_builder.h"     // for StringBuilder
-#include "rtc_base/third_party/base64/base64.h"  // for Base64, Base64::DO_P...
-#include "rtc_base/timeutils.h"                  // for TmToSeconds
+#include "rtc_base/checks.h"
+#include "rtc_base/opensslidentity.h"
+#include "rtc_base/sslcertificate.h"
+#include "rtc_base/strings/string_builder.h"
+#include "rtc_base/third_party/base64/base64.h"
+#include "rtc_base/timeutils.h"
 
 namespace rtc {
 
 //////////////////////////////////////////////////////////////////////
+// Helper Functions
+//////////////////////////////////////////////////////////////////////
+
+namespace {
+// Read |n| bytes from ASN1 number string at *|pp| and return the numeric value.
+// Update *|pp| and *|np| to reflect number of read bytes.
+// TODO(bugs.webrtc.org/9860) - Remove this code.
+inline int ASN1ReadInt(const unsigned char** pp, size_t* np, size_t n) {
+  const unsigned char* p = *pp;
+  int x = 0;
+  for (size_t i = 0; i < n; i++) {
+    x = 10 * x + p[i] - '0';
+  }
+  *pp = p + n;
+  *np = *np - n;
+  return x;
+}
+
+}  // namespace
+
+// TODO(bugs.webrtc.org/9860) - Remove this code.
+int64_t ASN1TimeToSec(const unsigned char* s, size_t length, bool long_format) {
+  size_t bytes_left = length;
+  // Make sure the string ends with Z.  Doing it here protects the strspn call
+  // from running off the end of the string in Z's absense.
+  if (length == 0 || s[length - 1] != 'Z') {
+    return -1;
+  }
+  // Make sure we only have ASCII digits so that we don't need to clutter the
+  // code below and ASN1ReadInt with error checking.
+  size_t n = strspn(reinterpret_cast<const char*>(s), "0123456789");
+  if (n + 1 != length) {
+    return -1;
+  }
+  // Read out ASN1 year, in either 2-char "UTCTIME" or 4-char "GENERALIZEDTIME"
+  // format.  Both format use UTC in this context.
+  int year = 0;
+  if (long_format) {
+    // ASN1 format: yyyymmddhh[mm[ss[.fff]]]Z where the Z is literal, but
+    // RFC 5280 requires us to only support exactly yyyymmddhhmmssZ.
+    if (bytes_left < 11) {
+      return -1;
+    }
+    year = ASN1ReadInt(&s, &bytes_left, 4);
+    year -= 1900;
+  } else {
+    // ASN1 format: yymmddhhmm[ss]Z where the Z is literal, but RFC 5280
+    // requires us to only support exactly yymmddhhmmssZ.
+    if (bytes_left < 9) {
+      return -1;
+    }
+    year = ASN1ReadInt(&s, &bytes_left, 2);
+    // Per RFC 5280 4.1.2.5.1
+    if (year < 50) {
+      year += 100;
+    }
+  }
+
+  // Read out remaining ASN1 time data and store it in |tm| in documented
+  // std::tm format.
+  tm tm;
+  tm.tm_year = year;
+  tm.tm_mon = ASN1ReadInt(&s, &bytes_left, 2) - 1;
+  tm.tm_mday = ASN1ReadInt(&s, &bytes_left, 2);
+  tm.tm_hour = ASN1ReadInt(&s, &bytes_left, 2);
+  tm.tm_min = ASN1ReadInt(&s, &bytes_left, 2);
+  tm.tm_sec = ASN1ReadInt(&s, &bytes_left, 2);
+
+  // Now just Z should remain.  Its existence was asserted above.
+  if (bytes_left != 1) {
+    return -1;
+  }
+  return TmToSeconds(tm);
+}
+
+//////////////////////////////////////////////////////////////////////
 // KeyParams
 //////////////////////////////////////////////////////////////////////
 
@@ -91,22 +168,21 @@
 bool SSLIdentity::PemToDer(const std::string& pem_type,
                            const std::string& pem_string,
                            std::string* der) {
-  // Find the inner body. We need this to fulfill the contract of
-  // returning pem_length.
+  // Find the inner body. We need this to fulfill the contract of returning
+  // pem_length.
   size_t header = pem_string.find("-----BEGIN " + pem_type + "-----");
-  if (header == std::string::npos)
+  if (header == std::string::npos) {
     return false;
-
+  }
   size_t body = pem_string.find("\n", header);
-  if (body == std::string::npos)
+  if (body == std::string::npos) {
     return false;
-
+  }
   size_t trailer = pem_string.find("-----END " + pem_type + "-----");
-  if (trailer == std::string::npos)
+  if (trailer == std::string::npos) {
     return false;
-
+  }
   std::string inner = pem_string.substr(body + 1, trailer - (body + 1));
-
   *der = Base64::Decode(inner, Base64::DO_PARSE_WHITE | Base64::DO_PAD_ANY |
                                    Base64::DO_TERM_BUFFER);
   return true;
@@ -116,14 +192,12 @@
                                   const unsigned char* data,
                                   size_t length) {
   rtc::StringBuilder result;
-
   result << "-----BEGIN " << pem_type << "-----\n";
 
   std::string b64_encoded;
   Base64::EncodeFromArray(data, length, &b64_encoded);
-
-  // Divide the Base-64 encoded data into 64-character chunks, as per
-  // 4.3.2.4 of RFC 1421.
+  // Divide the Base-64 encoded data into 64-character chunks, as per 4.3.2.4
+  // of RFC 1421.
   static const size_t kChunkSize = 64;
   size_t chunks = (b64_encoded.size() + (kChunkSize - 1)) / kChunkSize;
   for (size_t i = 0, chunk_offset = 0; i < chunks;
@@ -131,9 +205,7 @@
     result << b64_encoded.substr(chunk_offset, kChunkSize);
     result << "\n";
   }
-
   result << "-----END " << pem_type << "-----\n";
-
   return result.Release();
 }
 
@@ -184,78 +256,4 @@
   return !(a == b);
 }
 
-//////////////////////////////////////////////////////////////////////
-// Helper Functions
-//////////////////////////////////////////////////////////////////////
-
-// Read |n| bytes from ASN1 number string at *|pp| and return the numeric value.
-// Update *|pp| and *|np| to reflect number of read bytes.
-static inline int ASN1ReadInt(const unsigned char** pp, size_t* np, size_t n) {
-  const unsigned char* p = *pp;
-  int x = 0;
-  for (size_t i = 0; i < n; i++)
-    x = 10 * x + p[i] - '0';
-  *pp = p + n;
-  *np = *np - n;
-  return x;
-}
-
-int64_t ASN1TimeToSec(const unsigned char* s, size_t length, bool long_format) {
-  size_t bytes_left = length;
-
-  // Make sure the string ends with Z.  Doing it here protects the strspn call
-  // from running off the end of the string in Z's absense.
-  if (length == 0 || s[length - 1] != 'Z')
-    return -1;
-
-  // Make sure we only have ASCII digits so that we don't need to clutter the
-  // code below and ASN1ReadInt with error checking.
-  size_t n = strspn(reinterpret_cast<const char*>(s), "0123456789");
-  if (n + 1 != length)
-    return -1;
-
-  int year;
-
-  // Read out ASN1 year, in either 2-char "UTCTIME" or 4-char "GENERALIZEDTIME"
-  // format.  Both format use UTC in this context.
-  if (long_format) {
-    // ASN1 format: yyyymmddhh[mm[ss[.fff]]]Z where the Z is literal, but
-    // RFC 5280 requires us to only support exactly yyyymmddhhmmssZ.
-
-    if (bytes_left < 11)
-      return -1;
-
-    year = ASN1ReadInt(&s, &bytes_left, 4);
-    year -= 1900;
-  } else {
-    // ASN1 format: yymmddhhmm[ss]Z where the Z is literal, but RFC 5280
-    // requires us to only support exactly yymmddhhmmssZ.
-
-    if (bytes_left < 9)
-      return -1;
-
-    year = ASN1ReadInt(&s, &bytes_left, 2);
-    if (year < 50)  // Per RFC 5280 4.1.2.5.1
-      year += 100;
-  }
-
-  std::tm tm;
-  tm.tm_year = year;
-
-  // Read out remaining ASN1 time data and store it in |tm| in documented
-  // std::tm format.
-  tm.tm_mon = ASN1ReadInt(&s, &bytes_left, 2) - 1;
-  tm.tm_mday = ASN1ReadInt(&s, &bytes_left, 2);
-  tm.tm_hour = ASN1ReadInt(&s, &bytes_left, 2);
-  tm.tm_min = ASN1ReadInt(&s, &bytes_left, 2);
-  tm.tm_sec = ASN1ReadInt(&s, &bytes_left, 2);
-
-  if (bytes_left != 1) {
-    // Now just Z should remain.  Its existence was asserted above.
-    return -1;
-  }
-
-  return TmToSeconds(tm);
-}
-
 }  // namespace rtc
diff --git a/rtc_base/sslidentity.h b/rtc_base/sslidentity.h
index d17d38b..39feeab 100644
--- a/rtc_base/sslidentity.h
+++ b/rtc_base/sslidentity.h
@@ -13,13 +13,15 @@
 #ifndef RTC_BASE_SSLIDENTITY_H_
 #define RTC_BASE_SSLIDENTITY_H_
 
+#include <stdint.h>
 #include <ctime>
 #include <string>
 
-#include "rtc_base/sslcertificate.h"
-
 namespace rtc {
 
+class SSLCertChain;
+class SSLCertificate;
+
 // KT_LAST is intended for vector declarations and loops over all key types;
 // it does not represent any key type in itself.
 // KT_DEFAULT is used as the default KeyType for KeyParams.
diff --git a/rtc_base/sslidentity_unittest.cc b/rtc_base/sslidentity_unittest.cc
index 68b5828..ba53d17 100644
--- a/rtc_base/sslidentity_unittest.cc
+++ b/rtc_base/sslidentity_unittest.cc
@@ -180,7 +180,7 @@
   const rtc::SSLCertChain& chain = info.identity->cert_chain();
   std::unique_ptr<rtc::SSLFingerprint> fp;
   for (size_t i = 0; i < chain.GetSize(); i++) {
-    fp.reset(rtc::SSLFingerprint::Create("sha-1", &chain.Get(i)));
+    fp = rtc::SSLFingerprint::Create("sha-1", chain.Get(i));
     EXPECT_TRUE(fp);
     info.fingerprints.push_back(fp->GetRfc4572Fingerprint());
   }
@@ -201,7 +201,7 @@
     ASSERT_TRUE(identity_ecdsa1_);
     ASSERT_TRUE(identity_ecdsa2_);
 
-    test_cert_.reset(rtc::SSLCertificate::FromPEMString(kTestCertificate));
+    test_cert_ = rtc::SSLCertificate::FromPEMString(kTestCertificate);
     ASSERT_TRUE(test_cert_);
   }
 
diff --git a/rtc_base/sslstreamadapter.cc b/rtc_base/sslstreamadapter.cc
index 746ebd5..9c33a9c 100644
--- a/rtc_base/sslstreamadapter.cc
+++ b/rtc_base/sslstreamadapter.cc
@@ -89,40 +89,12 @@
           crypto_suite == CS_AEAD_AES_128_GCM);
 }
 
-// static
-CryptoOptions CryptoOptions::NoGcm() {
-  CryptoOptions options;
-  options.enable_gcm_crypto_suites = false;
-  return options;
-}
-
-std::vector<int> GetSupportedDtlsSrtpCryptoSuites(
-    const rtc::CryptoOptions& crypto_options) {
-  std::vector<int> crypto_suites;
-  if (crypto_options.enable_gcm_crypto_suites) {
-    crypto_suites.push_back(rtc::SRTP_AEAD_AES_256_GCM);
-    crypto_suites.push_back(rtc::SRTP_AEAD_AES_128_GCM);
-  }
-  // Note: SRTP_AES128_CM_SHA1_80 is what is required to be supported (by
-  // draft-ietf-rtcweb-security-arch), but SRTP_AES128_CM_SHA1_32 is allowed as
-  // well, and saves a few bytes per packet if it ends up selected.
-  // As the cipher suite is potentially insecure, it will only be used if
-  // enabled by both peers.
-  if (crypto_options.enable_aes128_sha1_32_crypto_cipher) {
-    crypto_suites.push_back(rtc::SRTP_AES128_CM_SHA1_32);
-  }
-  crypto_suites.push_back(rtc::SRTP_AES128_CM_SHA1_80);
-  return crypto_suites;
-}
-
 SSLStreamAdapter* SSLStreamAdapter::Create(StreamInterface* stream) {
   return new OpenSSLStreamAdapter(stream);
 }
 
 SSLStreamAdapter::SSLStreamAdapter(StreamInterface* stream)
-    : StreamAdapterInterface(stream),
-      ignore_bad_cert_(false),
-      client_auth_enabled_(true) {}
+    : StreamAdapterInterface(stream) {}
 
 SSLStreamAdapter::~SSLStreamAdapter() {}
 
@@ -161,8 +133,13 @@
 std::string SSLStreamAdapter::SslCipherSuiteToName(int cipher_suite) {
   return OpenSSLStreamAdapter::SslCipherSuiteToName(cipher_suite);
 }
-void SSLStreamAdapter::enable_time_callback_for_testing() {
-  OpenSSLStreamAdapter::enable_time_callback_for_testing();
+
+///////////////////////////////////////////////////////////////////////////////
+// Test only settings
+///////////////////////////////////////////////////////////////////////////////
+
+void SSLStreamAdapter::EnableTimeCallbackForTesting() {
+  OpenSSLStreamAdapter::EnableTimeCallbackForTesting();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/rtc_base/sslstreamadapter.h b/rtc_base/sslstreamadapter.h
index 2d4e19f..25f4f33 100644
--- a/rtc_base/sslstreamadapter.h
+++ b/rtc_base/sslstreamadapter.h
@@ -70,34 +70,6 @@
 // Returns true if the given crypto suite name uses a GCM cipher.
 bool IsGcmCryptoSuiteName(const std::string& crypto_suite);
 
-struct CryptoOptions {
-  CryptoOptions() {}
-
-  // Helper method to return an instance of the CryptoOptions with GCM crypto
-  // suites disabled. This method should be used instead of depending on current
-  // default values set by the constructor.
-  static CryptoOptions NoGcm();
-
-  // Enable GCM crypto suites from RFC 7714 for SRTP. GCM will only be used
-  // if both sides enable it.
-  bool enable_gcm_crypto_suites = false;
-
-  // If set to true, the (potentially insecure) crypto cipher
-  // SRTP_AES128_CM_SHA1_32 will be included in the list of supported ciphers
-  // during negotiation. It will only be used if both peers support it and no
-  // other ciphers get preferred.
-  bool enable_aes128_sha1_32_crypto_cipher = false;
-
-  // If set to true, encrypted RTP header extensions as defined in RFC 6904
-  // will be negotiated. They will only be used if both peers support them.
-  bool enable_encrypted_rtp_header_extensions = false;
-};
-
-// Returns supported crypto suites, given |crypto_options|.
-// CS_AES_CM_128_HMAC_SHA1_32 will be preferred by default.
-std::vector<int> GetSupportedDtlsSrtpCryptoSuites(
-    const rtc::CryptoOptions& crypto_options);
-
 // SSLStreamAdapter : A StreamInterfaceAdapter that does SSL/TLS.
 // After SSL has been started, the stream will only open on successful
 // SSL verification of certificates, and the communication is
@@ -144,12 +116,6 @@
   explicit SSLStreamAdapter(StreamInterface* stream);
   ~SSLStreamAdapter() override;
 
-  void set_ignore_bad_cert(bool ignore) { ignore_bad_cert_ = ignore; }
-  bool ignore_bad_cert() const { return ignore_bad_cert_; }
-
-  void set_client_auth_enabled(bool enabled) { client_auth_enabled_ = enabled; }
-  bool client_auth_enabled() const { return client_auth_enabled_; }
-
   // Specify our SSL identity: key and certificate. SSLStream takes ownership
   // of the SSLIdentity object and will free it when appropriate. Should be
   // called no more than once on a given SSLStream instance.
@@ -263,22 +229,32 @@
   // depending on specific SSL implementation.
   static std::string SslCipherSuiteToName(int cipher_suite);
 
+  ////////////////////////////////////////////////////////////////////////////
+  // Testing only member functions
+  ////////////////////////////////////////////////////////////////////////////
+
   // Use our timeutils.h source of timing in BoringSSL, allowing us to test
   // using a fake clock.
-  static void enable_time_callback_for_testing();
+  static void EnableTimeCallbackForTesting();
+
+  // Deprecated. Do not use this API outside of testing.
+  // Do not set this to false outside of testing.
+  void SetClientAuthEnabledForTesting(bool enabled) {
+    client_auth_enabled_ = enabled;
+  }
+
+  // Deprecated. Do not use this API outside of testing.
+  // Returns true by default, else false if explicitly set to disable client
+  // authentication.
+  bool GetClientAuthEnabled() const { return client_auth_enabled_; }
 
   sigslot::signal1<SSLHandshakeError> SignalSSLHandshakeError;
 
  private:
-  // If true, the server certificate need not match the configured
-  // server_name, and in fact missing certificate authority and other
-  // verification errors are ignored.
-  bool ignore_bad_cert_;
-
   // If true (default), the client is required to provide a certificate during
   // handshake. If no certificate is given, handshake fails. This applies to
   // server mode only.
-  bool client_auth_enabled_;
+  bool client_auth_enabled_ = true;
 };
 
 }  // namespace rtc
diff --git a/rtc_base/sslstreamadapter_unittest.cc b/rtc_base/sslstreamadapter_unittest.cc
index 389b0ea..6fbb1d7 100644
--- a/rtc_base/sslstreamadapter_unittest.cc
+++ b/rtc_base/sslstreamadapter_unittest.cc
@@ -17,6 +17,7 @@
 #include "rtc_base/checks.h"
 #include "rtc_base/gunit.h"
 #include "rtc_base/helpers.h"
+#include "rtc_base/memory_stream.h"
 #include "rtc_base/messagedigest.h"
 #include "rtc_base/ssladapter.h"
 #include "rtc_base/sslidentity.h"
@@ -588,8 +589,7 @@
       chain = client_ssl_->GetPeerSSLCertChain();
     else
       chain = server_ssl_->GetPeerSSLCertChain();
-    return (chain && chain->GetSize()) ? chain->Get(0).GetUniqueReference()
-                                       : nullptr;
+    return (chain && chain->GetSize()) ? chain->Get(0).Clone() : nullptr;
   }
 
   bool GetSslCipherSuite(bool client, int* retval) {
diff --git a/rtc_base/stream.cc b/rtc_base/stream.cc
index ea2e47a..783625c 100644
--- a/rtc_base/stream.cc
+++ b/rtc_base/stream.cc
@@ -7,28 +7,23 @@
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
-
-#if defined(WEBRTC_POSIX)
-#include <sys/file.h>
-#endif  // WEBRTC_POSIX
 #include <errno.h>
+#include <string.h>
 #include <sys/stat.h>
-#include <sys/types.h>
-
-#include <string.h>  // for memcpy, memmove, strlen
 #include <algorithm>
 #include <string>
 
 #include "rtc_base/checks.h"
-#include "rtc_base/location.h"  // for RTC_FROM_HERE
+#include "rtc_base/location.h"
 #include "rtc_base/messagequeue.h"
 #include "rtc_base/stream.h"
 #include "rtc_base/thread.h"
 
 #if defined(WEBRTC_WIN)
 #include <windows.h>
+
 #define fileno _fileno
-#include "rtc_base/stringutils.h"  // for ToUtf16
+#include "rtc_base/stringutils.h"
 #endif
 
 namespace rtc {
@@ -74,26 +69,6 @@
   return result;
 }
 
-StreamResult StreamInterface::ReadLine(std::string* line) {
-  line->clear();
-  StreamResult result = SR_SUCCESS;
-  while (true) {
-    char ch;
-    result = Read(&ch, sizeof(ch), nullptr, nullptr);
-    if (result != SR_SUCCESS) {
-      break;
-    }
-    if (ch == '\n') {
-      break;
-    }
-    line->push_back(ch);
-  }
-  if (!line->empty()) {   // give back the line we've collected so far with
-    result = SR_SUCCESS;  // a success code.  Otherwise return the last code
-  }
-  return result;
-}
-
 void StreamInterface::PostEvent(Thread* t, int events, int err) {
   t->Post(RTC_FROM_HERE, this, MSG_POST_EVENT,
           new StreamEventData(events, err));
@@ -103,14 +78,6 @@
   PostEvent(Thread::Current(), events, err);
 }
 
-const void* StreamInterface::GetReadData(size_t* data_len) {
-  return nullptr;
-}
-
-void* StreamInterface::GetWriteBuffer(size_t* buf_len) {
-  return nullptr;
-}
-
 bool StreamInterface::SetPosition(size_t position) {
   return false;
 }
@@ -123,10 +90,6 @@
   return false;
 }
 
-bool StreamInterface::GetWriteRemaining(size_t* size) const {
-  return false;
-}
-
 bool StreamInterface::Flush() {
   return false;
 }
@@ -187,10 +150,6 @@
   return stream_->GetSize(size);
 }
 
-bool StreamAdapterInterface::GetWriteRemaining(size_t* size) const {
-  return stream_->GetWriteRemaining(size);
-}
-
 bool StreamAdapterInterface::ReserveSize(size_t size) {
   return stream_->ReserveSize(size);
 }
@@ -389,143 +348,6 @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// MemoryStream
-///////////////////////////////////////////////////////////////////////////////
-
-MemoryStreamBase::MemoryStreamBase()
-    : buffer_(nullptr), buffer_length_(0), data_length_(0), seek_position_(0) {}
-
-StreamState MemoryStreamBase::GetState() const {
-  return SS_OPEN;
-}
-
-StreamResult MemoryStreamBase::Read(void* buffer,
-                                    size_t bytes,
-                                    size_t* bytes_read,
-                                    int* error) {
-  if (seek_position_ >= data_length_) {
-    return SR_EOS;
-  }
-  size_t available = data_length_ - seek_position_;
-  if (bytes > available) {
-    // Read partial buffer
-    bytes = available;
-  }
-  memcpy(buffer, &buffer_[seek_position_], bytes);
-  seek_position_ += bytes;
-  if (bytes_read) {
-    *bytes_read = bytes;
-  }
-  return SR_SUCCESS;
-}
-
-StreamResult MemoryStreamBase::Write(const void* buffer,
-                                     size_t bytes,
-                                     size_t* bytes_written,
-                                     int* error) {
-  size_t available = buffer_length_ - seek_position_;
-  if (0 == available) {
-    // Increase buffer size to the larger of:
-    // a) new position rounded up to next 256 bytes
-    // b) double the previous length
-    size_t new_buffer_length =
-        std::max(((seek_position_ + bytes) | 0xFF) + 1, buffer_length_ * 2);
-    StreamResult result = DoReserve(new_buffer_length, error);
-    if (SR_SUCCESS != result) {
-      return result;
-    }
-    RTC_DCHECK(buffer_length_ >= new_buffer_length);
-    available = buffer_length_ - seek_position_;
-  }
-
-  if (bytes > available) {
-    bytes = available;
-  }
-  memcpy(&buffer_[seek_position_], buffer, bytes);
-  seek_position_ += bytes;
-  if (data_length_ < seek_position_) {
-    data_length_ = seek_position_;
-  }
-  if (bytes_written) {
-    *bytes_written = bytes;
-  }
-  return SR_SUCCESS;
-}
-
-void MemoryStreamBase::Close() {
-  // nothing to do
-}
-
-bool MemoryStreamBase::SetPosition(size_t position) {
-  if (position > data_length_)
-    return false;
-  seek_position_ = position;
-  return true;
-}
-
-bool MemoryStreamBase::GetPosition(size_t* position) const {
-  if (position)
-    *position = seek_position_;
-  return true;
-}
-
-bool MemoryStreamBase::GetSize(size_t* size) const {
-  if (size)
-    *size = data_length_;
-  return true;
-}
-
-bool MemoryStreamBase::ReserveSize(size_t size) {
-  return (SR_SUCCESS == DoReserve(size, nullptr));
-}
-
-StreamResult MemoryStreamBase::DoReserve(size_t size, int* error) {
-  return (buffer_length_ >= size) ? SR_SUCCESS : SR_EOS;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-MemoryStream::MemoryStream() {}
-
-MemoryStream::MemoryStream(const char* data) {
-  SetData(data, strlen(data));
-}
-
-MemoryStream::MemoryStream(const void* data, size_t length) {
-  SetData(data, length);
-}
-
-MemoryStream::~MemoryStream() {
-  delete[] buffer_;
-}
-
-void MemoryStream::SetData(const void* data, size_t length) {
-  data_length_ = buffer_length_ = length;
-  delete[] buffer_;
-  buffer_ = new char[buffer_length_];
-  memcpy(buffer_, data, data_length_);
-  seek_position_ = 0;
-}
-
-StreamResult MemoryStream::DoReserve(size_t size, int* error) {
-  if (buffer_length_ >= size)
-    return SR_SUCCESS;
-
-  if (char* new_buffer = new char[size]) {
-    memcpy(new_buffer, buffer_, data_length_);
-    delete[] buffer_;
-    buffer_ = new_buffer;
-    buffer_length_ = size;
-    return SR_SUCCESS;
-  }
-
-  if (error) {
-    *error = ENOMEM;
-  }
-  return SR_ERROR;
-}
-
-///////////////////////////////////////////////////////////////////////////////
 // FifoBuffer
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -757,68 +579,4 @@
   return SR_SUCCESS;
 }
 
-
-///////////////////////////////////////////////////////////////////////////////
-
-StreamResult Flow(StreamInterface* source,
-                  char* buffer,
-                  size_t buffer_len,
-                  StreamInterface* sink,
-                  size_t* data_len /* = nullptr */) {
-  RTC_DCHECK(buffer_len > 0);
-
-  StreamResult result;
-  size_t count, read_pos, write_pos;
-  if (data_len) {
-    read_pos = *data_len;
-  } else {
-    read_pos = 0;
-  }
-
-  bool end_of_stream = false;
-  do {
-    // Read until buffer is full, end of stream, or error
-    while (!end_of_stream && (read_pos < buffer_len)) {
-      result = source->Read(buffer + read_pos, buffer_len - read_pos, &count,
-                            nullptr);
-      if (result == SR_EOS) {
-        end_of_stream = true;
-      } else if (result != SR_SUCCESS) {
-        if (data_len) {
-          *data_len = read_pos;
-        }
-        return result;
-      } else {
-        read_pos += count;
-      }
-    }
-
-    // Write until buffer is empty, or error (including end of stream)
-    write_pos = 0;
-    while (write_pos < read_pos) {
-      result = sink->Write(buffer + write_pos, read_pos - write_pos, &count,
-                           nullptr);
-      if (result != SR_SUCCESS) {
-        if (data_len) {
-          *data_len = read_pos - write_pos;
-          if (write_pos > 0) {
-            memmove(buffer, buffer + write_pos, *data_len);
-          }
-        }
-        return result;
-      }
-      write_pos += count;
-    }
-
-    read_pos = 0;
-  } while (!end_of_stream);
-
-  if (data_len) {
-    *data_len = 0;
-  }
-  return SR_SUCCESS;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
 }  // namespace rtc
diff --git a/rtc_base/stream.h b/rtc_base/stream.h
index 7c6e618..43e7f58 100644
--- a/rtc_base/stream.h
+++ b/rtc_base/stream.h
@@ -107,59 +107,6 @@
   // Like the aforementioned method, but posts to the current thread.
   void PostEvent(int events, int err);
 
-  //
-  // OPTIONAL OPERATIONS
-  //
-  // Not all implementations will support the following operations.  In general,
-  // a stream will only support an operation if it reasonably efficient to do
-  // so.  For example, while a socket could buffer incoming data to support
-  // seeking, it will not do so.  Instead, a buffering stream adapter should
-  // be used.
-  //
-  // Even though several of these operations are related, you should
-  // always use whichever operation is most relevant.
-  //
-  // The following four methods are used to avoid copying data multiple times.
-
-  // GetReadData returns a pointer to a buffer which is owned by the stream.
-  // The buffer contains data_len bytes.  null is returned if no data is
-  // available, or if the method fails.  If the caller processes the data, it
-  // must call ConsumeReadData with the number of processed bytes.  GetReadData
-  // does not require a matching call to ConsumeReadData if the data is not
-  // processed.  Read and ConsumeReadData invalidate the buffer returned by
-  // GetReadData.
-  virtual const void* GetReadData(size_t* data_len);
-  virtual void ConsumeReadData(size_t used) {}
-
-  // GetWriteBuffer returns a pointer to a buffer which is owned by the stream.
-  // The buffer has a capacity of buf_len bytes.  null is returned if there is
-  // no buffer available, or if the method fails.  The call may write data to
-  // the buffer, and then call ConsumeWriteBuffer with the number of bytes
-  // written.  GetWriteBuffer does not require a matching call to
-  // ConsumeWriteData if no data is written.  Write, ForceWrite, and
-  // ConsumeWriteData invalidate the buffer returned by GetWriteBuffer.
-  // TODO: Allow the caller to specify a minimum buffer size.  If the specified
-  // amount of buffer is not yet available, return null and Signal SE_WRITE
-  // when it is available.  If the requested amount is too large, return an
-  // error.
-  virtual void* GetWriteBuffer(size_t* buf_len);
-  virtual void ConsumeWriteBuffer(size_t used) {}
-
-  // Write data_len bytes found in data, circumventing any throttling which
-  // would could cause SR_BLOCK to be returned.  Returns true if all the data
-  // was written.  Otherwise, the method is unsupported, or an unrecoverable
-  // error occurred, and the error value is set.  This method should be used
-  // sparingly to write critical data which should not be throttled.  A stream
-  // which cannot circumvent its blocking constraints should not implement this
-  // method.
-  // NOTE: This interface is being considered experimentally at the moment.  It
-  // would be used by JUDP and BandwidthStream as a way to circumvent certain
-  // soft limits in writing.
-  // virtual bool ForceWrite(const void* data, size_t data_len, int* error) {
-  //  if (error) *error = -1;
-  //  return false;
-  //}
-
   // Seek to a byte offset from the beginning of the stream.  Returns false if
   // the stream does not support seeking, or cannot seek to the specified
   // position.
@@ -173,10 +120,6 @@
   // is not known.
   virtual bool GetSize(size_t* size) const;
 
-  // Return the number of Write()-able bytes remaining before end-of-stream.
-  // Returns false if not known.
-  virtual bool GetWriteRemaining(size_t* size) const;
-
   // Return true if flush is successful.
   virtual bool Flush();
 
@@ -213,12 +156,6 @@
                        size_t* read,
                        int* error);
 
-  // ReadLine is a helper function which repeatedly calls Read until it hits
-  // the end-of-line character, or something other than SR_SUCCESS.
-  // TODO: this is too inefficient to keep here.  Break this out into a buffered
-  // readline object or adapter
-  StreamResult ReadLine(std::string* line);
-
  protected:
   StreamInterface();
 
@@ -254,37 +191,9 @@
                      int* error) override;
   void Close() override;
 
-  // Optional Stream Interface
-  /*  Note: Many stream adapters were implemented prior to this Read/Write
-      interface.  Therefore, a simple pass through of data in those cases may
-      be broken.  At a later time, we should do a once-over pass of all
-      adapters, and make them compliant with these interfaces, after which this
-      code can be uncommented.
-  virtual const void* GetReadData(size_t* data_len) {
-    return stream_->GetReadData(data_len);
-  }
-  virtual void ConsumeReadData(size_t used) {
-    stream_->ConsumeReadData(used);
-  }
-
-  virtual void* GetWriteBuffer(size_t* buf_len) {
-    return stream_->GetWriteBuffer(buf_len);
-  }
-  virtual void ConsumeWriteBuffer(size_t used) {
-    stream_->ConsumeWriteBuffer(used);
-  }
-  */
-
-  /*  Note: This interface is currently undergoing evaluation.
-  virtual bool ForceWrite(const void* data, size_t data_len, int* error) {
-    return stream_->ForceWrite(data, data_len, error);
-  }
-  */
-
   bool SetPosition(size_t position) override;
   bool GetPosition(size_t* position) const override;
   bool GetSize(size_t* size) const override;
-  bool GetWriteRemaining(size_t* size) const override;
   bool ReserveSize(size_t size) override;
   bool Flush() override;
 
@@ -352,68 +261,11 @@
   RTC_DISALLOW_COPY_AND_ASSIGN(FileStream);
 };
 
-///////////////////////////////////////////////////////////////////////////////
-// MemoryStream is a simple implementation of a StreamInterface over in-memory
-// data.  Data is read and written at the current seek position.  Reads return
-// end-of-stream when they reach the end of data.  Writes actually extend the
-// end of data mark.
-///////////////////////////////////////////////////////////////////////////////
-
-class MemoryStreamBase : public StreamInterface {
- public:
-  StreamState GetState() const override;
-  StreamResult Read(void* buffer,
-                    size_t bytes,
-                    size_t* bytes_read,
-                    int* error) override;
-  StreamResult Write(const void* buffer,
-                     size_t bytes,
-                     size_t* bytes_written,
-                     int* error) override;
-  void Close() override;
-  bool SetPosition(size_t position) override;
-  bool GetPosition(size_t* position) const override;
-  bool GetSize(size_t* size) const override;
-  bool ReserveSize(size_t size) override;
-
-  char* GetBuffer() { return buffer_; }
-  const char* GetBuffer() const { return buffer_; }
-
- protected:
-  MemoryStreamBase();
-
-  virtual StreamResult DoReserve(size_t size, int* error);
-
-  // Invariant: 0 <= seek_position <= data_length_ <= buffer_length_
-  char* buffer_;
-  size_t buffer_length_;
-  size_t data_length_;
-  size_t seek_position_;
-
- private:
-  RTC_DISALLOW_COPY_AND_ASSIGN(MemoryStreamBase);
-};
-
-// MemoryStream dynamically resizes to accomodate written data.
-
-class MemoryStream : public MemoryStreamBase {
- public:
-  MemoryStream();
-  explicit MemoryStream(const char* data);  // Calls SetData(data, strlen(data))
-  MemoryStream(const void* data, size_t length);  // Calls SetData(data, length)
-  ~MemoryStream() override;
-
-  void SetData(const void* data, size_t length);
-
- protected:
-  StreamResult DoReserve(size_t size, int* error) override;
-};
-
 // FifoBuffer allows for efficient, thread-safe buffering of data between
 // writer and reader. As the data can wrap around the end of the buffer,
 // MemoryStreamBase can't help us here.
 
-class FifoBuffer : public StreamInterface {
+class FifoBuffer final : public StreamInterface {
  public:
   // Creates a FIFO buffer with the specified capacity.
   explicit FifoBuffer(size_t length);
@@ -454,11 +306,28 @@
                      size_t* bytes_written,
                      int* error) override;
   void Close() override;
-  const void* GetReadData(size_t* data_len) override;
-  void ConsumeReadData(size_t used) override;
-  void* GetWriteBuffer(size_t* buf_len) override;
-  void ConsumeWriteBuffer(size_t used) override;
-  bool GetWriteRemaining(size_t* size) const override;
+  // GetReadData returns a pointer to a buffer which is owned by the stream.
+  // The buffer contains data_len bytes.  null is returned if no data is
+  // available, or if the method fails.  If the caller processes the data, it
+  // must call ConsumeReadData with the number of processed bytes.  GetReadData
+  // does not require a matching call to ConsumeReadData if the data is not
+  // processed.  Read and ConsumeReadData invalidate the buffer returned by
+  // GetReadData.
+  const void* GetReadData(size_t* data_len);
+  void ConsumeReadData(size_t used);
+  // GetWriteBuffer returns a pointer to a buffer which is owned by the stream.
+  // The buffer has a capacity of buf_len bytes.  null is returned if there is
+  // no buffer available, or if the method fails.  The call may write data to
+  // the buffer, and then call ConsumeWriteBuffer with the number of bytes
+  // written.  GetWriteBuffer does not require a matching call to
+  // ConsumeWriteData if no data is written.  Write and
+  // ConsumeWriteData invalidate the buffer returned by GetWriteBuffer.
+  void* GetWriteBuffer(size_t* buf_len);
+  void ConsumeWriteBuffer(size_t used);
+
+  // Return the number of Write()-able bytes remaining before end-of-stream.
+  // Returns false if not known.
+  bool GetWriteRemaining(size_t* size) const;
 
  private:
   // Helper method that implements ReadOffset. Caller must acquire a lock
@@ -494,25 +363,6 @@
   RTC_DISALLOW_COPY_AND_ASSIGN(FifoBuffer);
 };
 
-///////////////////////////////////////////////////////////////////////////////
-
-// Flow attempts to move bytes from source to sink via buffer of size
-// buffer_len.  The function returns SR_SUCCESS when source reaches
-// end-of-stream (returns SR_EOS), and all the data has been written successful
-// to sink.  Alternately, if source returns SR_BLOCK or SR_ERROR, or if sink
-// returns SR_BLOCK, SR_ERROR, or SR_EOS, then the function immediately returns
-// with the unexpected StreamResult value.
-// data_len is the length of the valid data in buffer. in case of error
-// this is the data that read from source but can't move to destination.
-// as a pass in parameter, it indicates data in buffer that should move to sink
-StreamResult Flow(StreamInterface* source,
-                  char* buffer,
-                  size_t buffer_len,
-                  StreamInterface* sink,
-                  size_t* data_len = nullptr);
-
-///////////////////////////////////////////////////////////////////////////////
-
 }  // namespace rtc
 
 #endif  // RTC_BASE_STREAM_H_
diff --git a/rtc_base/stream_unittest.cc b/rtc_base/stream_unittest.cc
index 616783c..2ca2526 100644
--- a/rtc_base/stream_unittest.cc
+++ b/rtc_base/stream_unittest.cc
@@ -105,56 +105,52 @@
   const void* q;
   size_t bytes;
   FifoBuffer buf(kSize);
-  StreamInterface* stream = &buf;
 
   // Test assumptions about base state
-  EXPECT_EQ(SS_OPEN, stream->GetState());
-  EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, nullptr));
-  EXPECT_TRUE(nullptr != stream->GetReadData(&bytes));
-  EXPECT_EQ((size_t)0, bytes);
-  stream->ConsumeReadData(0);
-  EXPECT_TRUE(nullptr != stream->GetWriteBuffer(&bytes));
+  EXPECT_EQ(SS_OPEN, buf.GetState());
+  EXPECT_EQ(SR_BLOCK, buf.Read(out, kSize, &bytes, nullptr));
+  EXPECT_TRUE(nullptr != buf.GetWriteBuffer(&bytes));
   EXPECT_EQ(kSize, bytes);
-  stream->ConsumeWriteBuffer(0);
+  buf.ConsumeWriteBuffer(0);
 
   // Try a full write
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize, &bytes, nullptr));
   EXPECT_EQ(kSize, bytes);
 
   // Try a write that should block
-  EXPECT_EQ(SR_BLOCK, stream->Write(in, kSize, &bytes, nullptr));
+  EXPECT_EQ(SR_BLOCK, buf.Write(in, kSize, &bytes, nullptr));
 
   // Try a full read
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize, &bytes, nullptr));
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize));
 
   // Try a read that should block
-  EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, nullptr));
+  EXPECT_EQ(SR_BLOCK, buf.Read(out, kSize, &bytes, nullptr));
 
   // Try a too-big write
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize * 2, &bytes, nullptr));
   EXPECT_EQ(bytes, kSize);
 
   // Try a too-big read
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize * 2, &bytes, nullptr));
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize));
 
   // Try some small writes and reads
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize / 2, &bytes, nullptr));
   EXPECT_EQ(kSize / 2, bytes);
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 2, &bytes, nullptr));
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize / 2, &bytes, nullptr));
   EXPECT_EQ(kSize / 2, bytes);
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize / 2, &bytes, nullptr));
   EXPECT_EQ(kSize / 2, bytes);
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 2, &bytes, nullptr));
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 2, &bytes, nullptr));
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));
 
@@ -166,51 +162,51 @@
   // XXXXWWWWWWWWXXXX 4567012345670123
   // RRRRXXXXXXXXRRRR ....01234567....
   // ....RRRRRRRR.... ................
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 3 / 4, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize * 3 / 4, &bytes, nullptr));
   EXPECT_EQ(kSize * 3 / 4, bytes);
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 2, &bytes, nullptr));
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize / 2, &bytes, nullptr));
   EXPECT_EQ(kSize / 2, bytes);
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 4, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 4, &bytes, nullptr));
   EXPECT_EQ(kSize / 4, bytes);
   EXPECT_EQ(0, memcmp(in + kSize / 2, out, kSize / 4));
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize / 2, &bytes, nullptr));
   EXPECT_EQ(kSize / 2, bytes);
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 2, &bytes, nullptr));
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 2, &bytes, nullptr));
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));
 
   // Use GetWriteBuffer to reset the read_position for the next tests
-  stream->GetWriteBuffer(&bytes);
-  stream->ConsumeWriteBuffer(0);
+  buf.GetWriteBuffer(&bytes);
+  buf.ConsumeWriteBuffer(0);
 
   // Try using GetReadData to do a full read
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, nullptr));
-  q = stream->GetReadData(&bytes);
+  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize, &bytes, nullptr));
+  q = buf.GetReadData(&bytes);
   EXPECT_TRUE(nullptr != q);
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(0, memcmp(q, in, kSize));
-  stream->ConsumeReadData(kSize);
-  EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, nullptr));
+  buf.ConsumeReadData(kSize);
+  EXPECT_EQ(SR_BLOCK, buf.Read(out, kSize, &bytes, nullptr));
 
   // Try using GetReadData to do some small reads
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, nullptr));
-  q = stream->GetReadData(&bytes);
+  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize, &bytes, nullptr));
+  q = buf.GetReadData(&bytes);
   EXPECT_TRUE(nullptr != q);
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(0, memcmp(q, in, kSize / 2));
-  stream->ConsumeReadData(kSize / 2);
-  q = stream->GetReadData(&bytes);
+  buf.ConsumeReadData(kSize / 2);
+  q = buf.GetReadData(&bytes);
   EXPECT_TRUE(nullptr != q);
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(q, in + kSize / 2, kSize / 2));
-  stream->ConsumeReadData(kSize / 2);
-  EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, nullptr));
+  buf.ConsumeReadData(kSize / 2);
+  EXPECT_EQ(SR_BLOCK, buf.Read(out, kSize, &bytes, nullptr));
 
   // Try using GetReadData in a wraparound case
   // WWWWWWWWWWWWWWWW 0123456789ABCDEF
@@ -218,46 +214,46 @@
   // WWWWWWWW....XXXX 01234567....CDEF
   // ............RRRR 01234567........
   // RRRRRRRR........ ................
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, nullptr));
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 3 / 4, &bytes, nullptr));
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, nullptr));
-  q = stream->GetReadData(&bytes);
+  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize * 3 / 4, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize / 2, &bytes, nullptr));
+  q = buf.GetReadData(&bytes);
   EXPECT_TRUE(nullptr != q);
   EXPECT_EQ(kSize / 4, bytes);
   EXPECT_EQ(0, memcmp(q, in + kSize * 3 / 4, kSize / 4));
-  stream->ConsumeReadData(kSize / 4);
-  q = stream->GetReadData(&bytes);
+  buf.ConsumeReadData(kSize / 4);
+  q = buf.GetReadData(&bytes);
   EXPECT_TRUE(nullptr != q);
   EXPECT_EQ(kSize / 2, bytes);
   EXPECT_EQ(0, memcmp(q, in, kSize / 2));
-  stream->ConsumeReadData(kSize / 2);
+  buf.ConsumeReadData(kSize / 2);
 
   // Use GetWriteBuffer to reset the read_position for the next tests
-  stream->GetWriteBuffer(&bytes);
-  stream->ConsumeWriteBuffer(0);
+  buf.GetWriteBuffer(&bytes);
+  buf.ConsumeWriteBuffer(0);
 
   // Try using GetWriteBuffer to do a full write
-  p = stream->GetWriteBuffer(&bytes);
+  p = buf.GetWriteBuffer(&bytes);
   EXPECT_TRUE(nullptr != p);
   EXPECT_EQ(kSize, bytes);
   memcpy(p, in, kSize);
-  stream->ConsumeWriteBuffer(kSize);
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, nullptr));
+  buf.ConsumeWriteBuffer(kSize);
+  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize, &bytes, nullptr));
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize));
 
   // Try using GetWriteBuffer to do some small writes
-  p = stream->GetWriteBuffer(&bytes);
+  p = buf.GetWriteBuffer(&bytes);
   EXPECT_TRUE(nullptr != p);
   EXPECT_EQ(kSize, bytes);
   memcpy(p, in, kSize / 2);
-  stream->ConsumeWriteBuffer(kSize / 2);
-  p = stream->GetWriteBuffer(&bytes);
+  buf.ConsumeWriteBuffer(kSize / 2);
+  p = buf.GetWriteBuffer(&bytes);
   EXPECT_TRUE(nullptr != p);
   EXPECT_EQ(kSize / 2, bytes);
   memcpy(p, in + kSize / 2, kSize / 2);
-  stream->ConsumeWriteBuffer(kSize / 2);
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, nullptr));
+  buf.ConsumeWriteBuffer(kSize / 2);
+  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize, &bytes, nullptr));
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize));
 
@@ -267,53 +263,53 @@
   // ........XXXXWWWW ........89AB0123
   // WWWW....XXXXXXXX 4567....89AB0123
   // RRRR....RRRRRRRR ................
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize * 3 / 4, &bytes, nullptr));
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, nullptr));
-  p = stream->GetWriteBuffer(&bytes);
+  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize * 3 / 4, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 2, &bytes, nullptr));
+  p = buf.GetWriteBuffer(&bytes);
   EXPECT_TRUE(nullptr != p);
   EXPECT_EQ(kSize / 4, bytes);
   memcpy(p, in, kSize / 4);
-  stream->ConsumeWriteBuffer(kSize / 4);
-  p = stream->GetWriteBuffer(&bytes);
+  buf.ConsumeWriteBuffer(kSize / 4);
+  p = buf.GetWriteBuffer(&bytes);
   EXPECT_TRUE(nullptr != p);
   EXPECT_EQ(kSize / 2, bytes);
   memcpy(p, in + kSize / 4, kSize / 4);
-  stream->ConsumeWriteBuffer(kSize / 4);
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 3 / 4, &bytes, nullptr));
+  buf.ConsumeWriteBuffer(kSize / 4);
+  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize * 3 / 4, &bytes, nullptr));
   EXPECT_EQ(kSize * 3 / 4, bytes);
   EXPECT_EQ(0, memcmp(in + kSize / 2, out, kSize / 4));
   EXPECT_EQ(0, memcmp(in, out + kSize / 4, kSize / 4));
 
   // Check that the stream is now empty
-  EXPECT_EQ(SR_BLOCK, stream->Read(out, kSize, &bytes, nullptr));
+  EXPECT_EQ(SR_BLOCK, buf.Read(out, kSize, &bytes, nullptr));
 
   // Try growing the buffer
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize, &bytes, nullptr));
   EXPECT_EQ(kSize, bytes);
   EXPECT_TRUE(buf.SetCapacity(kSize * 2));
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in + kSize, kSize, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Write(in + kSize, kSize, &bytes, nullptr));
   EXPECT_EQ(kSize, bytes);
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize * 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize * 2, &bytes, nullptr));
   EXPECT_EQ(kSize * 2, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize * 2));
 
   // Try shrinking the buffer
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize, &bytes, nullptr));
   EXPECT_EQ(kSize, bytes);
   EXPECT_TRUE(buf.SetCapacity(kSize));
-  EXPECT_EQ(SR_BLOCK, stream->Write(in, kSize, &bytes, nullptr));
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize, &bytes, nullptr));
+  EXPECT_EQ(SR_BLOCK, buf.Write(in, kSize, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize, &bytes, nullptr));
   EXPECT_EQ(kSize, bytes);
   EXPECT_EQ(0, memcmp(in, out, kSize));
 
   // Write to the stream, close it, read the remaining bytes
-  EXPECT_EQ(SR_SUCCESS, stream->Write(in, kSize / 2, &bytes, nullptr));
-  stream->Close();
-  EXPECT_EQ(SS_CLOSED, stream->GetState());
-  EXPECT_EQ(SR_EOS, stream->Write(in, kSize / 2, &bytes, nullptr));
-  EXPECT_EQ(SR_SUCCESS, stream->Read(out, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Write(in, kSize / 2, &bytes, nullptr));
+  buf.Close();
+  EXPECT_EQ(SS_CLOSED, buf.GetState());
+  EXPECT_EQ(SR_EOS, buf.Write(in, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_SUCCESS, buf.Read(out, kSize / 2, &bytes, nullptr));
   EXPECT_EQ(0, memcmp(in, out, kSize / 2));
-  EXPECT_EQ(SR_EOS, stream->Read(out, kSize / 2, &bytes, nullptr));
+  EXPECT_EQ(SR_EOS, buf.Read(out, kSize / 2, &bytes, nullptr));
 }
 
 TEST(FifoBufferTest, FullBufferCheck) {
diff --git a/rtc_base/string_to_number.cc b/rtc_base/string_to_number.cc
index 9201242..634652b 100644
--- a/rtc_base/string_to_number.cc
+++ b/rtc_base/string_to_number.cc
@@ -10,6 +10,7 @@
 
 #include "rtc_base/string_to_number.h"
 
+#include <ctype.h>
 #include <cerrno>
 #include <cstdlib>
 
diff --git a/rtc_base/string_to_number.h b/rtc_base/string_to_number.h
index 7ea9f25..4cb5215 100644
--- a/rtc_base/string_to_number.h
+++ b/rtc_base/string_to_number.h
@@ -13,6 +13,7 @@
 
 #include <limits>
 #include <string>
+#include <type_traits>
 
 #include "absl/types/optional.h"
 
diff --git a/rtc_base/stringencode.cc b/rtc_base/stringencode.cc
index 6a065cb..fc4e3bc 100644
--- a/rtc_base/stringencode.cc
+++ b/rtc_base/stringencode.cc
@@ -10,6 +10,8 @@
 
 #include "rtc_base/stringencode.h"
 
+#include <cstdio>
+
 #include "rtc_base/arraysize.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/stringutils.h"
@@ -48,67 +50,6 @@
   return bufpos;
 }
 
-size_t utf8_decode(const char* source, size_t srclen, unsigned long* value) {
-  const unsigned char* s = reinterpret_cast<const unsigned char*>(source);
-  if ((s[0] & 0x80) == 0x00) {  // Check s[0] == 0xxxxxxx
-    *value = s[0];
-    return 1;
-  }
-  if ((srclen < 2) || ((s[1] & 0xC0) != 0x80)) {  // Check s[1] != 10xxxxxx
-    return 0;
-  }
-  // Accumulate the trailer byte values in value16, and combine it with the
-  // relevant bits from s[0], once we've determined the sequence length.
-  unsigned long value16 = (s[1] & 0x3F);
-  if ((s[0] & 0xE0) == 0xC0) {  // Check s[0] == 110xxxxx
-    *value = ((s[0] & 0x1F) << 6) | value16;
-    return 2;
-  }
-  if ((srclen < 3) || ((s[2] & 0xC0) != 0x80)) {  // Check s[2] != 10xxxxxx
-    return 0;
-  }
-  value16 = (value16 << 6) | (s[2] & 0x3F);
-  if ((s[0] & 0xF0) == 0xE0) {  // Check s[0] == 1110xxxx
-    *value = ((s[0] & 0x0F) << 12) | value16;
-    return 3;
-  }
-  if ((srclen < 4) || ((s[3] & 0xC0) != 0x80)) {  // Check s[3] != 10xxxxxx
-    return 0;
-  }
-  value16 = (value16 << 6) | (s[3] & 0x3F);
-  if ((s[0] & 0xF8) == 0xF0) {  // Check s[0] == 11110xxx
-    *value = ((s[0] & 0x07) << 18) | value16;
-    return 4;
-  }
-  return 0;
-}
-
-size_t utf8_encode(char* buffer, size_t buflen, unsigned long value) {
-  if ((value <= 0x7F) && (buflen >= 1)) {
-    buffer[0] = static_cast<unsigned char>(value);
-    return 1;
-  }
-  if ((value <= 0x7FF) && (buflen >= 2)) {
-    buffer[0] = 0xC0 | static_cast<unsigned char>(value >> 6);
-    buffer[1] = 0x80 | static_cast<unsigned char>(value & 0x3F);
-    return 2;
-  }
-  if ((value <= 0xFFFF) && (buflen >= 3)) {
-    buffer[0] = 0xE0 | static_cast<unsigned char>(value >> 12);
-    buffer[1] = 0x80 | static_cast<unsigned char>((value >> 6) & 0x3F);
-    buffer[2] = 0x80 | static_cast<unsigned char>(value & 0x3F);
-    return 3;
-  }
-  if ((value <= 0x1FFFFF) && (buflen >= 4)) {
-    buffer[0] = 0xF0 | static_cast<unsigned char>(value >> 18);
-    buffer[1] = 0x80 | static_cast<unsigned char>((value >> 12) & 0x3F);
-    buffer[2] = 0x80 | static_cast<unsigned char>((value >> 6) & 0x3F);
-    buffer[3] = 0x80 | static_cast<unsigned char>(value & 0x3F);
-    return 4;
-  }
-  return 0;
-}
-
 static const char HEX[] = "0123456789abcdef";
 
 char hex_encode(unsigned char val) {
@@ -119,9 +60,9 @@
 bool hex_decode(char ch, unsigned char* val) {
   if ((ch >= '0') && (ch <= '9')) {
     *val = ch - '0';
-  } else if ((ch >= 'A') && (ch <= 'Z')) {
+  } else if ((ch >= 'A') && (ch <= 'F')) {
     *val = (ch - 'A') + 10;
-  } else if ((ch >= 'a') && (ch <= 'z')) {
+  } else if ((ch >= 'a') && (ch <= 'f')) {
     *val = (ch - 'a') + 10;
   } else {
     return false;
diff --git a/rtc_base/stringencode.h b/rtc_base/stringencode.h
index 5d436df..09bf77f 100644
--- a/rtc_base/stringencode.h
+++ b/rtc_base/stringencode.h
@@ -11,9 +11,12 @@
 #ifndef RTC_BASE_STRINGENCODE_H_
 #define RTC_BASE_STRINGENCODE_H_
 
+#include <stddef.h>
 #include <string>
+#include <type_traits>
 #include <vector>
 
+#include "absl/types/optional.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/string_to_number.h"
 
diff --git a/rtc_base/stringencode_unittest.cc b/rtc_base/stringencode_unittest.cc
index 9bdc592..f21c4cb 100644
--- a/rtc_base/stringencode_unittest.cc
+++ b/rtc_base/stringencode_unittest.cc
@@ -141,7 +141,8 @@
 
 // Test that decoding non-hex data fails.
 TEST_F(HexEncodeTest, TestDecodeBogusData) {
-  dec_res_ = hex_decode_with_delimiter(decoded_, sizeof(decoded_), "xyz", 3, 0);
+  dec_res_ =
+      hex_decode_with_delimiter(decoded_, sizeof(decoded_), "axyz", 4, 0);
   ASSERT_EQ(0U, dec_res_);
 }
 
diff --git a/rtc_base/strings/audio_format_to_string.cc b/rtc_base/strings/audio_format_to_string.cc
index a149344..7e91c3b 100644
--- a/rtc_base/strings/audio_format_to_string.cc
+++ b/rtc_base/strings/audio_format_to_string.cc
@@ -10,6 +10,8 @@
 
 #include "rtc_base/strings/audio_format_to_string.h"
 
+#include <utility>
+
 #include "rtc_base/strings/string_builder.h"
 
 namespace rtc {
diff --git a/rtc_base/strings/string_builder.cc b/rtc_base/strings/string_builder.cc
index 0dca938..adf4fa9 100644
--- a/rtc_base/strings/string_builder.cc
+++ b/rtc_base/strings/string_builder.cc
@@ -10,11 +10,11 @@
 
 #include "rtc_base/strings/string_builder.h"
 
-#include <stdarg.h>  // for va_end, va_list, va_start
-#include <cstring>   // for strlen
+#include <stdarg.h>
+#include <cstring>
 
-#include "rtc_base/checks.h"                // for FatalLogCall, RTC_DCHECK
-#include "rtc_base/numerics/safe_minmax.h"  // for SafeMin
+#include "rtc_base/checks.h"
+#include "rtc_base/numerics/safe_minmax.h"
 
 namespace rtc {
 
diff --git a/rtc_base/stringutils.cc b/rtc_base/stringutils.cc
index 35153ab..c808eb2 100644
--- a/rtc_base/stringutils.cc
+++ b/rtc_base/stringutils.cc
@@ -10,93 +10,26 @@
 
 #include "rtc_base/stringutils.h"
 
-#include "rtc_base/checks.h"
-
 namespace rtc {
 
-bool memory_check(const void* memory, int c, size_t count) {
-  const char* char_memory = static_cast<const char*>(memory);
-  char char_c = static_cast<char>(c);
-  for (size_t i = 0; i < count; ++i) {
-    if (char_memory[i] != char_c) {
-      return false;
-    }
-  }
-  return true;
-}
-
-bool string_match(const char* target, const char* pattern) {
-  while (*pattern) {
-    if (*pattern == '*') {
-      if (!*++pattern) {
-        return true;
-      }
-      while (*target) {
-        if ((toupper(*pattern) == toupper(*target)) &&
-            string_match(target + 1, pattern + 1)) {
-          return true;
-        }
-        ++target;
-      }
-      return false;
-    } else {
-      if (toupper(*pattern) != toupper(*target)) {
-        return false;
-      }
-      ++target;
-      ++pattern;
-    }
-  }
-  return !*target;
-}
-
-#if defined(WEBRTC_WIN)
-int ascii_string_compare(const wchar_t* s1,
-                         const char* s2,
-                         size_t n,
-                         CharacterTransformation transformation) {
-  wchar_t c1, c2;
-  while (true) {
-    if (n-- == 0)
-      return 0;
-    c1 = transformation(*s1);
-    // Double check that characters are not UTF-8
-    RTC_DCHECK_LT(*s2, 128);
-    // Note: *s2 gets implicitly promoted to wchar_t
-    c2 = transformation(*s2);
-    if (c1 != c2)
-      return (c1 < c2) ? -1 : 1;
-    if (!c1)
-      return 0;
-    ++s1;
-    ++s2;
-  }
-}
-
-size_t asccpyn(wchar_t* buffer,
+size_t strcpyn(char* buffer,
                size_t buflen,
                const char* source,
-               size_t srclen) {
+               size_t srclen /* = SIZE_UNKNOWN */) {
   if (buflen <= 0)
     return 0;
 
   if (srclen == SIZE_UNKNOWN) {
-    srclen = strlenn(source, buflen - 1);
-  } else if (srclen >= buflen) {
+    srclen = strlen(source);
+  }
+  if (srclen >= buflen) {
     srclen = buflen - 1;
   }
-#if RTC_DCHECK_IS_ON
-  // Double check that characters are not UTF-8
-  for (size_t pos = 0; pos < srclen; ++pos)
-    RTC_DCHECK_LT(source[pos], 128);
-#endif
-  std::copy(source, source + srclen, buffer);
+  memcpy(buffer, source, srclen);
   buffer[srclen] = 0;
   return srclen;
 }
 
-#endif  // WEBRTC_WIN
-
 void replace_substrs(const char* search,
                      size_t search_len,
                      const char* replace,
diff --git a/rtc_base/stringutils.h b/rtc_base/stringutils.h
index 5739d21..702bc67 100644
--- a/rtc_base/stringutils.h
+++ b/rtc_base/stringutils.h
@@ -20,6 +20,7 @@
 #include <malloc.h>
 #include <wchar.h>
 #include <windows.h>
+
 #define alloca _alloca
 #endif  // WEBRTC_WIN
 
@@ -29,6 +30,7 @@
 #else  // BSD
 #include <alloca.h>
 #endif  // !BSD
+#include <strings.h>
 #endif  // WEBRTC_POSIX
 
 #include <string>
@@ -40,47 +42,6 @@
 #define STACK_ARRAY(TYPE, LEN) \
   static_cast<TYPE*>(::alloca((LEN) * sizeof(TYPE)))
 
-namespace rtc {
-
-// Determines whether the simple wildcard pattern matches target.
-// Alpha characters in pattern match case-insensitively.
-// Asterisks in pattern match 0 or more characters.
-// Ex: string_match("www.TEST.GOOGLE.COM", "www.*.com") -> true
-bool string_match(const char* target, const char* pattern);
-
-}  // namespace rtc
-
-///////////////////////////////////////////////////////////////////////////////
-// Rename a few common string functions so they are consistent across platforms.
-// tolowercase is like tolower, but not compatible with end-of-file value
-//
-// It's not clear if we will ever use wchar_t strings on unix.  In theory,
-// all strings should be Utf8 all the time, except when interfacing with Win32
-// APIs that require Utf16.
-///////////////////////////////////////////////////////////////////////////////
-inline char tolowercase(char c) {
-  return static_cast<char>(tolower(c));
-}
-
-#if defined(WEBRTC_WIN)
-
-inline wchar_t tolowercase(wchar_t c) {
-  return static_cast<wchar_t>(towlower(c));
-}
-
-#endif  // WEBRTC_WIN
-
-#if defined(WEBRTC_POSIX)
-
-inline int _stricmp(const char* s1, const char* s2) {
-  return strcasecmp(s1, s2);
-}
-inline int _strnicmp(const char* s1, const char* s2, size_t n) {
-  return strncasecmp(s1, s2, n);
-}
-
-#endif  // WEBRTC_POSIX
-
 ///////////////////////////////////////////////////////////////////////////////
 // Traits simplifies porting string functions to be CTYPE-agnostic
 ///////////////////////////////////////////////////////////////////////////////
@@ -89,191 +50,12 @@
 
 const size_t SIZE_UNKNOWN = static_cast<size_t>(-1);
 
-template <class CTYPE>
-struct Traits {
-  // STL string type
-  // typedef XXX string;
-  // Null-terminated string
-  // inline static const CTYPE* empty_str();
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// String utilities which work with char or wchar_t
-///////////////////////////////////////////////////////////////////////////////
-
-template <class CTYPE>
-inline const CTYPE* nonnull(const CTYPE* str, const CTYPE* def_str = nullptr) {
-  return str ? str : (def_str ? def_str : Traits<CTYPE>::empty_str());
-}
-
-template <class CTYPE>
-const CTYPE* strchr(const CTYPE* str, const CTYPE* chs) {
-  for (size_t i = 0; str[i]; ++i) {
-    for (size_t j = 0; chs[j]; ++j) {
-      if (str[i] == chs[j]) {
-        return str + i;
-      }
-    }
-  }
-  return 0;
-}
-
-template <class CTYPE>
-const CTYPE* strchrn(const CTYPE* str, size_t slen, CTYPE ch) {
-  for (size_t i = 0; i < slen && str[i]; ++i) {
-    if (str[i] == ch) {
-      return str + i;
-    }
-  }
-  return 0;
-}
-
-template <class CTYPE>
-size_t strlenn(const CTYPE* buffer, size_t buflen) {
-  size_t bufpos = 0;
-  while (buffer[bufpos] && (bufpos < buflen)) {
-    ++bufpos;
-  }
-  return bufpos;
-}
-
-// Safe versions of strncpy, strncat, snprintf and vsnprintf that always
-// null-terminate.
-
-template <class CTYPE>
-size_t strcpyn(CTYPE* buffer,
-               size_t buflen,
-               const CTYPE* source,
-               size_t srclen = SIZE_UNKNOWN) {
-  if (buflen <= 0)
-    return 0;
-
-  if (srclen == SIZE_UNKNOWN) {
-    srclen = strlenn(source, buflen - 1);
-  } else if (srclen >= buflen) {
-    srclen = buflen - 1;
-  }
-  memcpy(buffer, source, srclen * sizeof(CTYPE));
-  buffer[srclen] = 0;
-  return srclen;
-}
-
-template <class CTYPE>
-size_t strcatn(CTYPE* buffer,
-               size_t buflen,
-               const CTYPE* source,
-               size_t srclen = SIZE_UNKNOWN) {
-  if (buflen <= 0)
-    return 0;
-
-  size_t bufpos = strlenn(buffer, buflen - 1);
-  return bufpos + strcpyn(buffer + bufpos, buflen - bufpos, source, srclen);
-}
-
-// Some compilers (clang specifically) require vsprintfn be defined before
-// sprintfn.
-template <class CTYPE>
-__attribute__ ((__format__ (__printf__, 3, 0)))
-size_t vsprintfn(CTYPE* buffer,
-                 size_t buflen,
-                 const char* format,
-                 va_list args) {
-  int len = vsnprintf(buffer, buflen, format, args);
-  if ((len < 0) || (static_cast<size_t>(len) >= buflen)) {
-    len = static_cast<int>(buflen - 1);
-    buffer[len] = 0;
-  }
-  return len;
-}
-
-template <class CTYPE>
-__attribute__ ((__format__ (__printf__, 3, 0)))
-size_t sprintfn(CTYPE* buffer, size_t buflen, const char* format, ...) {
-  va_list args;
-  va_start(args, format);
-  size_t len = vsprintfn(buffer, buflen, format, args);
-  va_end(args);
-  return len;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Allow safe comparing and copying ascii (not UTF-8) with both wide and
-// non-wide character strings.
-///////////////////////////////////////////////////////////////////////////////
-
-inline int asccmp(const char* s1, const char* s2) {
-  return strcmp(s1, s2);
-}
-inline int ascicmp(const char* s1, const char* s2) {
-  return _stricmp(s1, s2);
-}
-inline int ascncmp(const char* s1, const char* s2, size_t n) {
-  return strncmp(s1, s2, n);
-}
-inline int ascnicmp(const char* s1, const char* s2, size_t n) {
-  return _strnicmp(s1, s2, n);
-}
-inline size_t asccpyn(char* buffer,
-                      size_t buflen,
-                      const char* source,
-                      size_t srclen = SIZE_UNKNOWN) {
-  return strcpyn(buffer, buflen, source, srclen);
-}
-
-#if defined(WEBRTC_WIN)
-
-typedef wchar_t (*CharacterTransformation)(wchar_t);
-inline wchar_t identity(wchar_t c) {
-  return c;
-}
-int ascii_string_compare(const wchar_t* s1,
-                         const char* s2,
-                         size_t n,
-                         CharacterTransformation transformation);
-
-inline int asccmp(const wchar_t* s1, const char* s2) {
-  return ascii_string_compare(s1, s2, static_cast<size_t>(-1), identity);
-}
-inline int ascicmp(const wchar_t* s1, const char* s2) {
-  return ascii_string_compare(s1, s2, static_cast<size_t>(-1), tolowercase);
-}
-inline int ascncmp(const wchar_t* s1, const char* s2, size_t n) {
-  return ascii_string_compare(s1, s2, n, identity);
-}
-inline int ascnicmp(const wchar_t* s1, const char* s2, size_t n) {
-  return ascii_string_compare(s1, s2, n, tolowercase);
-}
-size_t asccpyn(wchar_t* buffer,
+// Safe version of strncpy that always nul-terminate.
+size_t strcpyn(char* buffer,
                size_t buflen,
                const char* source,
                size_t srclen = SIZE_UNKNOWN);
 
-#endif  // WEBRTC_WIN
-
-///////////////////////////////////////////////////////////////////////////////
-// Traits<char> specializations
-///////////////////////////////////////////////////////////////////////////////
-
-template <>
-struct Traits<char> {
-  typedef std::string string;
-  inline static const char* empty_str() { return ""; }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// Traits<wchar_t> specializations (Windows only, currently)
-///////////////////////////////////////////////////////////////////////////////
-
-#if defined(WEBRTC_WIN)
-
-template <>
-struct Traits<wchar_t> {
-  typedef std::wstring string;
-  inline static const wchar_t* empty_str() { return L""; }
-};
-
-#endif  // WEBRTC_WIN
-
 ///////////////////////////////////////////////////////////////////////////////
 // UTF helpers (Windows only)
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/rtc_base/stringutils_unittest.cc b/rtc_base/stringutils_unittest.cc
index a6e6468..663e976 100644
--- a/rtc_base/stringutils_unittest.cc
+++ b/rtc_base/stringutils_unittest.cc
@@ -13,70 +13,6 @@
 
 namespace rtc {
 
-// Tests for string_match().
-
-TEST(string_matchTest, Matches) {
-  EXPECT_TRUE(string_match("A.B.C.D", "a.b.c.d"));
-  EXPECT_TRUE(string_match("www.TEST.GOOGLE.COM", "www.*.com"));
-  EXPECT_TRUE(string_match("127.0.0.1", "12*.0.*1"));
-  EXPECT_TRUE(string_match("127.1.0.21", "12*.0.*1"));
-  EXPECT_FALSE(string_match("127.0.0.0", "12*.0.*1"));
-  EXPECT_FALSE(string_match("127.0.0.0", "12*.0.*1"));
-  EXPECT_FALSE(string_match("127.1.1.21", "12*.0.*1"));
-}
-
-// It's not clear if we will ever use wchar_t strings on unix.  In theory,
-// all strings should be Utf8 all the time, except when interfacing with Win32
-// APIs that require Utf16.
-
-#if defined(WEBRTC_WIN)
-
-// Tests for ascii_string_compare().
-
-// Tests null input.
-TEST(ascii_string_compareTest, NullInput) {
-  // The following results in an access violation in
-  // ascii_string_compare.  Is this a bug or by design?  stringutils.h
-  // should document the expected behavior in this case.
-
-  // EXPECT_EQ(0, ascii_string_compare(nullptr, nullptr, 1, identity));
-}
-
-// Tests comparing two strings of different lengths.
-TEST(ascii_string_compareTest, DifferentLengths) {
-  EXPECT_EQ(-1, ascii_string_compare(L"Test", "Test1", 5, identity));
-}
-
-// Tests the case where the buffer size is smaller than the string
-// lengths.
-TEST(ascii_string_compareTest, SmallBuffer) {
-  EXPECT_EQ(0, ascii_string_compare(L"Test", "Test1", 3, identity));
-}
-
-// Tests the case where the buffer is not full.
-TEST(ascii_string_compareTest, LargeBuffer) {
-  EXPECT_EQ(0, ascii_string_compare(L"Test", "Test", 10, identity));
-}
-
-// Tests comparing two eqaul strings.
-TEST(ascii_string_compareTest, Equal) {
-  EXPECT_EQ(0, ascii_string_compare(L"Test", "Test", 5, identity));
-  EXPECT_EQ(0, ascii_string_compare(L"TeSt", "tEsT", 5, tolowercase));
-}
-
-// Tests comparing a smller string to a larger one.
-TEST(ascii_string_compareTest, LessThan) {
-  EXPECT_EQ(-1, ascii_string_compare(L"abc", "abd", 4, identity));
-  EXPECT_EQ(-1, ascii_string_compare(L"ABC", "abD", 5, tolowercase));
-}
-
-// Tests comparing a larger string to a smaller one.
-TEST(ascii_string_compareTest, GreaterThan) {
-  EXPECT_EQ(1, ascii_string_compare(L"xyz", "xy", 5, identity));
-  EXPECT_EQ(1, ascii_string_compare(L"abc", "ABB", 5, tolowercase));
-}
-#endif  // WEBRTC_WIN
-
 TEST(string_trim_Test, Trimming) {
   EXPECT_EQ("temp", string_trim("\n\r\t temp \n\r\t"));
   EXPECT_EQ("temp\n\r\t temp", string_trim(" temp\n\r\t temp "));
diff --git a/rtc_base/synchronization/rw_lock_posix.cc b/rtc_base/synchronization/rw_lock_posix.cc
index 7e37dc9..15ef3d7 100644
--- a/rtc_base/synchronization/rw_lock_posix.cc
+++ b/rtc_base/synchronization/rw_lock_posix.cc
@@ -10,6 +10,8 @@
 
 #include "rtc_base/synchronization/rw_lock_posix.h"
 
+#include <stddef.h>
+
 namespace webrtc {
 
 RWLockPosix::RWLockPosix() : lock_() {}
diff --git a/rtc_base/system/BUILD.gn b/rtc_base/system/BUILD.gn
index f22efe1..e5aa32b 100644
--- a/rtc_base/system/BUILD.gn
+++ b/rtc_base/system/BUILD.gn
@@ -65,3 +65,15 @@
     "rtc_export.h",
   ]
 }
+
+if (is_mac || is_ios) {
+  rtc_source_set("cocoa_threading") {
+    sources = [
+      "cocoa_threading.h",
+      "cocoa_threading.mm",
+    ]
+    deps = [
+      "..:checks",
+    ]
+  }
+}
diff --git a/rtc_base/system/cocoa_threading.h b/rtc_base/system/cocoa_threading.h
new file mode 100644
index 0000000..518cb71
--- /dev/null
+++ b/rtc_base/system/cocoa_threading.h
@@ -0,0 +1,24 @@
+/*
+ *  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 RTC_BASE_SYSTEM_COCOA_THREADING_H_
+#define RTC_BASE_SYSTEM_COCOA_THREADING_H_
+
+// If Cocoa is to be used on more than one thread, it must know that the
+// application is multithreaded.  Since it's possible to enter Cocoa code
+// from threads created by pthread_thread_create, Cocoa won't necessarily
+// be aware that the application is multithreaded.  Spawning an NSThread is
+// enough to get Cocoa to set up for multithreaded operation, so this is done
+// if necessary before pthread_thread_create spawns any threads.
+//
+// http://developer.apple.com/documentation/Cocoa/Conceptual/Multithreading/CreatingThreads/chapter_4_section_4.html
+void InitCocoaMultiThreading();
+
+#endif  // RTC_BASE_SYSTEM_COCOA_THREADING_H_
diff --git a/rtc_base/system/cocoa_threading.mm b/rtc_base/system/cocoa_threading.mm
new file mode 100644
index 0000000..c09862e
--- /dev/null
+++ b/rtc_base/system/cocoa_threading.mm
@@ -0,0 +1,24 @@
+/*
+ *  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.
+ */
+#include "rtc_base/system/cocoa_threading.h"
+
+#import <Foundation/Foundation.h>
+
+#include "rtc_base/checks.h"
+
+void InitCocoaMultiThreading() {
+  static BOOL is_cocoa_multithreaded = [NSThread isMultiThreaded];
+  if (!is_cocoa_multithreaded) {
+    // +[NSObject class] is idempotent.
+    [NSThread detachNewThreadSelector:@selector(class) toTarget:[NSObject class] withObject:nil];
+    is_cocoa_multithreaded = YES;
+    RTC_DCHECK([NSThread isMultiThreaded]);
+  }
+}
diff --git a/rtc_base/system/file_wrapper.cc b/rtc_base/system/file_wrapper.cc
index 72f5f25..c033a79 100644
--- a/rtc_base/system/file_wrapper.cc
+++ b/rtc_base/system/file_wrapper.cc
@@ -13,14 +13,11 @@
 #ifdef _WIN32
 #include <Windows.h>
 #else
-#include <stdarg.h>
 #include <string.h>
 #endif
 
 #include <utility>
 
-#include "rtc_base/checks.h"
-
 namespace webrtc {
 namespace {
 FILE* FileOpen(const char* file_name_utf8, bool read_only) {
diff --git a/rtc_base/system/file_wrapper.h b/rtc_base/system/file_wrapper.h
index 5411b04..0bb86a3 100644
--- a/rtc_base/system/file_wrapper.h
+++ b/rtc_base/system/file_wrapper.h
@@ -14,7 +14,6 @@
 #include <stddef.h>
 #include <stdio.h>
 
-#include "common_types.h"  // NOLINT(build/include)
 #include "rtc_base/criticalsection.h"
 
 // Implementation that can read (exclusive) or write from/to a file.
diff --git a/rtc_base/task_queue_for_test.h b/rtc_base/task_queue_for_test.h
index 70c58fb..9162e81 100644
--- a/rtc_base/task_queue_for_test.h
+++ b/rtc_base/task_queue_for_test.h
@@ -33,7 +33,7 @@
   template <class Closure>
   void SendTask(Closure* task) {
     RTC_DCHECK(!IsCurrent());
-    rtc::Event event(false, false);
+    rtc::Event event;
     PostTask(rtc::NewClosure(
         [&task]() {
           RTC_CHECK_EQ(false, static_cast<QueuedTask*>(task)->Run());
@@ -47,7 +47,7 @@
   template <class Closure>
   void SendTask(Closure&& task) {
     RTC_DCHECK(!IsCurrent());
-    rtc::Event event(false, false);
+    rtc::Event event;
     PostTask(rtc::NewClosure(std::move(task), [&event]() { event.Set(); }));
     event.Wait(rtc::Event::kForever);
   }
diff --git a/rtc_base/task_queue_libevent.cc b/rtc_base/task_queue_libevent.cc
index 000f463..7588569 100644
--- a/rtc_base/task_queue_libevent.cc
+++ b/rtc_base/task_queue_libevent.cc
@@ -10,17 +10,17 @@
 
 #include "rtc_base/task_queue.h"
 
-#include <errno.h>  // for EAGAIN, errno
+#include <errno.h>
 #include <fcntl.h>
-#include <pthread.h>  // for pthread_getspecific
+#include <pthread.h>
 #include <signal.h>
-#include <stdint.h>  // for uint32_t
-#include <time.h>    // for nanosleep, timespec
+#include <stdint.h>
+#include <time.h>
 #include <unistd.h>
 #include <list>
-#include <memory>       // for unique_ptr, allocator
-#include <type_traits>  // for remove_reference<>::...
-#include <utility>      // for move
+#include <memory>
+#include <type_traits>
+#include <utility>
 
 #include <event.h>
 #include "rtc_base/checks.h"
@@ -28,13 +28,13 @@
 #include "rtc_base/logging.h"
 #include "rtc_base/numerics/safe_conversions.h"
 #include "rtc_base/platform_thread.h"
-#include "rtc_base/platform_thread_types.h"  // for CurrentThreadRef
+#include "rtc_base/platform_thread_types.h"
 #include "rtc_base/refcount.h"
 #include "rtc_base/refcountedobject.h"
-#include "rtc_base/scoped_ref_ptr.h"  // for scoped_refptr
+#include "rtc_base/scoped_ref_ptr.h"
 #include "rtc_base/system/unused.h"
 #include "rtc_base/task_queue_posix.h"
-#include "rtc_base/thread_annotations.h"  // for RTC_GUARDED_BY
+#include "rtc_base/thread_annotations.h"
 #include "rtc_base/timeutils.h"
 
 namespace rtc {
diff --git a/rtc_base/task_queue_unittest.cc b/rtc_base/task_queue_unittest.cc
index cedf68e..0af39a5 100644
--- a/rtc_base/task_queue_unittest.cc
+++ b/rtc_base/task_queue_unittest.cc
@@ -64,7 +64,7 @@
 
 TEST(TaskQueueTest, PostAndCheckCurrent) {
   static const char kQueueName[] = "PostAndCheckCurrent";
-  Event event(false, false);
+  Event event;
   TaskQueue queue(kQueueName);
 
   // We're not running a task, so there shouldn't be a current queue.
@@ -106,7 +106,7 @@
 
 TEST(TaskQueueTest, PostDelayedZero) {
   static const char kQueueName[] = "PostDelayedZero";
-  Event event(false, false);
+  Event event;
   TaskQueue queue(kQueueName);
 
   queue.PostDelayedTask([&event]() { event.Set(); }, 0);
@@ -115,7 +115,7 @@
 
 TEST(TaskQueueTest, PostFromQueue) {
   static const char kQueueName[] = "PostFromQueue";
-  Event event(false, false);
+  Event event;
   TaskQueue queue(kQueueName);
 
   queue.PostTask(
@@ -125,7 +125,7 @@
 
 TEST(TaskQueueTest, PostDelayed) {
   static const char kQueueName[] = "PostDelayed";
-  Event event(false, false);
+  Event event;
   TaskQueue queue(kQueueName, TaskQueue::Priority::HIGH);
 
   uint32_t start = Time();
@@ -145,7 +145,7 @@
   EnableHighResTimers high_res_scope;
 
   static const char kQueueName[] = "PostDelayedHighRes";
-  Event event(false, false);
+  Event event;
   TaskQueue queue(kQueueName, TaskQueue::Priority::HIGH);
 
   uint32_t start = Time();
@@ -165,7 +165,7 @@
 
   std::vector<std::unique_ptr<Event>> events;
   for (int i = 0; i < 100; ++i) {
-    events.push_back(std::unique_ptr<Event>(new Event(false, false)));
+    events.push_back(absl::make_unique<Event>());
     queue.PostDelayedTask(Bind(&CheckCurrent, events.back().get(), &queue), i);
   }
 
@@ -175,8 +175,8 @@
 
 TEST(TaskQueueTest, PostDelayedAfterDestruct) {
   static const char kQueueName[] = "PostDelayedAfterDestruct";
-  Event run(false, false);
-  Event deleted(false, false);
+  Event run;
+  Event deleted;
   {
     TaskQueue queue(kQueueName);
     queue.PostDelayedTask(
@@ -191,7 +191,7 @@
 TEST(TaskQueueTest, PostAndReply) {
   static const char kPostQueue[] = "PostQueue";
   static const char kReplyQueue[] = "ReplyQueue";
-  Event event(false, false);
+  Event event;
   TaskQueue post_queue(kPostQueue);
   TaskQueue reply_queue(kReplyQueue);
 
@@ -204,7 +204,7 @@
 TEST(TaskQueueTest, PostAndReuse) {
   static const char kPostQueue[] = "PostQueue";
   static const char kReplyQueue[] = "ReplyQueue";
-  Event event(false, false);
+  Event event;
   TaskQueue post_queue(kPostQueue);
   TaskQueue reply_queue(kReplyQueue);
 
@@ -251,7 +251,7 @@
 TEST(TaskQueueTest, PostAndReplyLambda) {
   static const char kPostQueue[] = "PostQueue";
   static const char kReplyQueue[] = "ReplyQueue";
-  Event event(false, false);
+  Event event;
   TaskQueue post_queue(kPostQueue);
   TaskQueue reply_queue(kReplyQueue);
 
@@ -287,7 +287,7 @@
 
   int num_copies = 0;
   int num_moves = 0;
-  Event event(false, false);
+  Event event;
 
   static const char kPostQueue[] = "PostCopyableClosure";
   TaskQueue post_queue(kPostQueue);
@@ -323,7 +323,7 @@
   };
 
   int num_moves = 0;
-  Event event(false, false);
+  Event event;
   std::unique_ptr<SomeState> state(new SomeState(&event));
 
   static const char kPostQueue[] = "PostMoveOnlyClosure";
@@ -346,8 +346,8 @@
     std::unique_ptr<SomeState> state;
   };
 
-  Event event_run(false, false);
-  Event event_cleanup(false, false);
+  Event event_run;
+  Event event_cleanup;
   std::unique_ptr<SomeState> state_run(new SomeState(&event_run));
   std::unique_ptr<SomeState> state_cleanup(new SomeState(&event_cleanup));
 
@@ -367,7 +367,7 @@
 // written in a way that makes it likely and by running with --gtest_repeat=1000
 // the bug would occur. Alas, now it should be fixed.
 TEST(TaskQueueTest, PostAndReplyDeadlock) {
-  Event event(false, false);
+  Event event;
   TaskQueue post_queue("PostQueue");
   TaskQueue reply_queue("ReplyQueue");
 
@@ -384,8 +384,8 @@
 #define MAYBE_DeleteTaskQueueAfterPostAndReply DeleteTaskQueueAfterPostAndReply
 #endif
 TEST(TaskQueueTest, MAYBE_DeleteTaskQueueAfterPostAndReply) {
-  Event task_deleted(false, false);
-  Event reply_deleted(false, false);
+  Event task_deleted;
+  Event reply_deleted;
   auto* task_queue = new TaskQueue("Queue");
 
   task_queue->PostTaskAndReply(
@@ -413,7 +413,7 @@
 TEST(TaskQueueTest, PostAndReply2) {
   static const char kQueueName[] = "PostAndReply2";
   static const char kWorkQueueName[] = "PostAndReply2_Worker";
-  Event event(false, false);
+  Event event;
   TaskQueue queue(kQueueName);
   TaskQueue work_queue(kWorkQueueName);
 
@@ -425,7 +425,7 @@
 // In situations like that, tasks will get dropped.
 TEST(TaskQueueTest, PostALot) {
   // To destruct the event after the queue has gone out of scope.
-  Event event(false, false);
+  Event event;
 
   int tasks_executed = 0;
   int tasks_cleaned_up = 0;
diff --git a/rtc_base/testclient.cc b/rtc_base/testclient.cc
index 7c151c7..a5b90dd 100644
--- a/rtc_base/testclient.cc
+++ b/rtc_base/testclient.cc
@@ -97,7 +97,7 @@
   std::unique_ptr<Packet> packet = NextPacket(kTimeoutMs);
   if (packet) {
     res = (packet->size == size && memcmp(packet->buf, buf, size) == 0 &&
-           CheckTimestamp(packet->packet_time.timestamp));
+           CheckTimestamp(packet->packet_time_us));
     if (addr)
       *addr = packet->addr;
   }
@@ -144,10 +144,10 @@
                           const char* buf,
                           size_t size,
                           const SocketAddress& remote_addr,
-                          const PacketTime& packet_time) {
+                          const int64_t& packet_time_us) {
   CritScope cs(&crit_);
   packets_.push_back(
-      absl::make_unique<Packet>(remote_addr, buf, size, packet_time));
+      absl::make_unique<Packet>(remote_addr, buf, size, packet_time_us));
 }
 
 void TestClient::OnReadyToSend(AsyncPacketSocket* socket) {
@@ -157,14 +157,14 @@
 TestClient::Packet::Packet(const SocketAddress& a,
                            const char* b,
                            size_t s,
-                           const PacketTime& packet_time)
-    : addr(a), buf(0), size(s), packet_time(packet_time) {
+                           int64_t packet_time_us)
+    : addr(a), buf(0), size(s), packet_time_us(packet_time_us) {
   buf = new char[size];
   memcpy(buf, b, size);
 }
 
 TestClient::Packet::Packet(const Packet& p)
-    : addr(p.addr), buf(0), size(p.size), packet_time(p.packet_time) {
+    : addr(p.addr), buf(0), size(p.size), packet_time_us(p.packet_time_us) {
   buf = new char[size];
   memcpy(buf, p.buf, size);
 }
diff --git a/rtc_base/testclient.h b/rtc_base/testclient.h
index a0d98b3..16fb6ba 100644
--- a/rtc_base/testclient.h
+++ b/rtc_base/testclient.h
@@ -29,14 +29,14 @@
     Packet(const SocketAddress& a,
            const char* b,
            size_t s,
-           const PacketTime& packet_time);
+           int64_t packet_time_us);
     Packet(const Packet& p);
     virtual ~Packet();
 
     SocketAddress addr;
     char* buf;
     size_t size;
-    PacketTime packet_time;
+    int64_t packet_time_us;
   };
 
   // Default timeout for NextPacket reads.
@@ -97,7 +97,7 @@
                 const char* buf,
                 size_t len,
                 const SocketAddress& remote_addr,
-                const PacketTime& packet_time);
+                const int64_t& packet_time_us);
   void OnReadyToSend(AsyncPacketSocket* socket);
   bool CheckTimestamp(int64_t packet_timestamp);
   void AdvanceTime(int ms);
diff --git a/rtc_base/testechoserver.h b/rtc_base/testechoserver.h
index 5e714eb..9ffd786 100644
--- a/rtc_base/testechoserver.h
+++ b/rtc_base/testechoserver.h
@@ -44,7 +44,7 @@
                 const char* buf,
                 size_t size,
                 const SocketAddress& remote_addr,
-                const PacketTime& packet_time) {
+                const int64_t& /* packet_time_us */) {
     rtc::PacketOptions options;
     socket->Send(buf, size, options);
   }
diff --git a/rtc_base/testutils.cc b/rtc_base/testutils.cc
index b4a7433..f3292fd 100644
--- a/rtc_base/testutils.cc
+++ b/rtc_base/testutils.cc
@@ -14,75 +14,7 @@
 namespace testing {
 
 StreamSink::StreamSink() = default;
-
 StreamSink::~StreamSink() = default;
 
-StreamSource::StreamSource() {
-  Clear();
-}
-
-StreamSource::~StreamSource() = default;
-
-StreamState StreamSource::GetState() const {
-  return state_;
-}
-
-StreamResult StreamSource::Read(void* buffer,
-                                size_t buffer_len,
-                                size_t* read,
-                                int* error) {
-  if (SS_CLOSED == state_) {
-    if (error)
-      *error = -1;
-    return SR_ERROR;
-  }
-  if ((SS_OPENING == state_) || (readable_data_.size() <= read_block_)) {
-    return SR_BLOCK;
-  }
-  size_t count = std::min(buffer_len, readable_data_.size() - read_block_);
-  memcpy(buffer, &readable_data_[0], count);
-  size_t new_size = readable_data_.size() - count;
-  // Avoid undefined access beyond the last element of the vector.
-  // This only happens when new_size is 0.
-  if (count < readable_data_.size()) {
-    memmove(&readable_data_[0], &readable_data_[count], new_size);
-  }
-  readable_data_.resize(new_size);
-  if (read)
-    *read = count;
-  return SR_SUCCESS;
-}
-
-StreamResult StreamSource::Write(const void* data,
-                                 size_t data_len,
-                                 size_t* written,
-                                 int* error) {
-  if (SS_CLOSED == state_) {
-    if (error)
-      *error = -1;
-    return SR_ERROR;
-  }
-  if (SS_OPENING == state_) {
-    return SR_BLOCK;
-  }
-  if (SIZE_UNKNOWN != write_block_) {
-    if (written_data_.size() >= write_block_) {
-      return SR_BLOCK;
-    }
-    if (data_len > (write_block_ - written_data_.size())) {
-      data_len = write_block_ - written_data_.size();
-    }
-  }
-  if (written)
-    *written = data_len;
-  const char* cdata = static_cast<const char*>(data);
-  written_data_.insert(written_data_.end(), cdata, cdata + data_len);
-  return SR_SUCCESS;
-}
-
-void StreamSource::Close() {
-  state_ = SS_CLOSED;
-}
-
 }  // namespace testing
 }  // namespace webrtc
diff --git a/rtc_base/testutils.h b/rtc_base/testutils.h
index 2ab4a35..6b3733f 100644
--- a/rtc_base/testutils.h
+++ b/rtc_base/testutils.h
@@ -21,7 +21,6 @@
 #include "rtc_base/checks.h"
 #include "rtc_base/gunit.h"
 #include "rtc_base/stream.h"
-#include "rtc_base/stringutils.h"
 
 namespace webrtc {
 namespace testing {
@@ -137,91 +136,6 @@
   EventMap events_;
 };
 
-///////////////////////////////////////////////////////////////////////////////
-// StreamSource - Implements stream interface and simulates asynchronous
-// events on the stream, without a network.  Also buffers written data.
-///////////////////////////////////////////////////////////////////////////////
-
-class StreamSource : public StreamInterface {
- public:
-  StreamSource();
-  ~StreamSource() override;
-
-  void Clear() {
-    readable_data_.clear();
-    written_data_.clear();
-    state_ = SS_CLOSED;
-    read_block_ = 0;
-    write_block_ = SIZE_UNKNOWN;
-  }
-  void QueueString(const char* data) { QueueData(data, strlen(data)); }
-#if defined(__GNUC__)
-  // Note: Implicit |this| argument counts as the first argument.
-  __attribute__((__format__(__printf__, 2, 3)))
-#endif
-  void
-  QueueStringF(const char* format, ...) {
-    va_list args;
-    va_start(args, format);
-    char buffer[1024];
-    size_t len = vsprintfn(buffer, sizeof(buffer), format, args);
-    RTC_CHECK(len < sizeof(buffer) - 1);
-    va_end(args);
-    QueueData(buffer, len);
-  }
-  void QueueData(const char* data, size_t len) {
-    readable_data_.insert(readable_data_.end(), data, data + len);
-    if ((SS_OPEN == state_) && (readable_data_.size() == len)) {
-      SignalEvent(this, SE_READ, 0);
-    }
-  }
-  std::string ReadData() {
-    std::string data;
-    // avoid accessing written_data_[0] if it is undefined
-    if (written_data_.size() > 0) {
-      data.insert(0, &written_data_[0], written_data_.size());
-    }
-    written_data_.clear();
-    return data;
-  }
-  void SetState(StreamState state) {
-    int events = 0;
-    if ((SS_OPENING == state_) && (SS_OPEN == state)) {
-      events |= SE_OPEN;
-      if (!readable_data_.empty()) {
-        events |= SE_READ;
-      }
-    } else if ((SS_CLOSED != state_) && (SS_CLOSED == state)) {
-      events |= SE_CLOSE;
-    }
-    state_ = state;
-    if (events) {
-      SignalEvent(this, events, 0);
-    }
-  }
-  // Will cause Read to block when there are pos bytes in the read queue.
-  void SetReadBlock(size_t pos) { read_block_ = pos; }
-  // Will cause Write to block when there are pos bytes in the write queue.
-  void SetWriteBlock(size_t pos) { write_block_ = pos; }
-
-  StreamState GetState() const override;
-  StreamResult Read(void* buffer,
-                    size_t buffer_len,
-                    size_t* read,
-                    int* error) override;
-  StreamResult Write(const void* data,
-                     size_t data_len,
-                     size_t* written,
-                     int* error) override;
-  void Close() override;
-
- private:
-  typedef std::vector<char> Buffer;
-  Buffer readable_data_, written_data_;
-  StreamState state_;
-  size_t read_block_, write_block_;
-};
-
 }  // namespace testing
 }  // namespace webrtc
 
diff --git a/rtc_base/thread.cc b/rtc_base/thread.cc
index 911ac16..4dd5fd2 100644
--- a/rtc_base/thread.cc
+++ b/rtc_base/thread.cc
@@ -24,15 +24,43 @@
 #pragma warning(disable : 4722)
 #endif
 
-#include <utility>  // for move
+#include <stdio.h>
+#include <utility>
 
 #include "rtc_base/checks.h"
+#include "rtc_base/criticalsection.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/nullsocketserver.h"
-#include "rtc_base/stringutils.h"
 #include "rtc_base/timeutils.h"
 #include "rtc_base/trace_event.h"
 
+#if defined(WEBRTC_MAC)
+#include "rtc_base/system/cocoa_threading.h"
+
+/*
+ * These are forward-declarations for methods that are part of the
+ * ObjC runtime. They are declared in the private header objc-internal.h.
+ * These calls are what clang inserts when using @autoreleasepool in ObjC,
+ * but here they are used directly in order to keep this file C++.
+ * https://clang.llvm.org/docs/AutomaticReferenceCounting.html#runtime-support
+ */
+extern "C" {
+void* objc_autoreleasePoolPush(void);
+void objc_autoreleasePoolPop(void* pool);
+}
+
+namespace {
+class ScopedAutoReleasePool {
+ public:
+  ScopedAutoReleasePool() : pool_(objc_autoreleasePoolPush()) {}
+  ~ScopedAutoReleasePool() { objc_autoreleasePoolPop(pool_); }
+
+ private:
+  void* const pool_;
+};
+}  // namespace
+#endif
+
 namespace rtc {
 
 ThreadManager* ThreadManager::Instance() {
@@ -62,11 +90,12 @@
 }
 
 #if defined(WEBRTC_POSIX)
-#if !defined(WEBRTC_MAC)
 ThreadManager::ThreadManager() : main_thread_ref_(CurrentThreadRef()) {
+#if defined(WEBRTC_MAC)
+  InitCocoaMultiThreading();
+#endif
   pthread_key_create(&key_, nullptr);
 }
-#endif
 
 Thread* ThreadManager::CurrentThread() {
   return static_cast<Thread*>(pthread_getspecific(key_));
@@ -194,8 +223,10 @@
 
   name_ = name;
   if (obj) {
-    char buf[16];
-    sprintfn(buf, sizeof(buf), " 0x%p", obj);
+    // The %p specifier typically produce at most 16 hex digits, possibly with a
+    // 0x prefix. But format is implementation defined, so add some margin.
+    char buf[30];
+    snprintf(buf, sizeof(buf), " 0x%p", obj);
     name_ += buf;
   }
   return true;
@@ -301,7 +332,6 @@
 }
 
 // static
-#if !defined(WEBRTC_MAC)
 #if defined(WEBRTC_WIN)
 DWORD WINAPI Thread::PreRun(LPVOID pv) {
 #else
@@ -310,6 +340,9 @@
   ThreadInit* init = static_cast<ThreadInit*>(pv);
   ThreadManager::Instance()->SetCurrentThread(init->thread);
   rtc::SetCurrentThreadName(init->thread->name_.c_str());
+#if defined(WEBRTC_MAC)
+  ScopedAutoReleasePool pool;
+#endif
   if (init->runnable) {
     init->runnable->Run(init->thread);
   } else {
@@ -323,7 +356,6 @@
   return nullptr;
 #endif
 }
-#endif
 
 void Thread::Run() {
   ProcessMessages(kForever);
@@ -486,9 +518,6 @@
   ClearInternal(phandler, id, removed);
 }
 
-#if !defined(WEBRTC_MAC)
-// Note that these methods have a separate implementation for mac and ios
-// defined in webrtc/rtc_base/thread_darwin.mm.
 bool Thread::ProcessMessages(int cmsLoop) {
   // Using ProcessMessages with a custom clock for testing and a time greater
   // than 0 doesn't work, since it's not guaranteed to advance the custom
@@ -499,6 +528,9 @@
   int cmsNext = cmsLoop;
 
   while (true) {
+#if defined(WEBRTC_MAC)
+    ScopedAutoReleasePool pool;
+#endif
     Message msg;
     if (!Get(&msg, cmsNext))
       return !IsQuitting();
@@ -511,7 +543,6 @@
     }
   }
 }
-#endif
 
 bool Thread::WrapCurrentWithThreadManager(ThreadManager* thread_manager,
                                           bool need_synchronize_access) {
diff --git a/rtc_base/thread.h b/rtc_base/thread.h
index fde5e8b..039192c 100644
--- a/rtc_base/thread.h
+++ b/rtc_base/thread.h
@@ -11,16 +11,22 @@
 #ifndef RTC_BASE_THREAD_H_
 #define RTC_BASE_THREAD_H_
 
+#include <stdint.h>
 #include <list>
 #include <memory>
 #include <string>
+#include <type_traits>
 
 #if defined(WEBRTC_POSIX)
 #include <pthread.h>
 #endif
 #include "rtc_base/constructormagic.h"
+#include "rtc_base/location.h"
+#include "rtc_base/messagehandler.h"
 #include "rtc_base/messagequeue.h"
 #include "rtc_base/platform_thread_types.h"
+#include "rtc_base/socketserver.h"
+#include "rtc_base/thread_annotations.h"
 
 #if defined(WEBRTC_WIN)
 #include "rtc_base/win32.h"
diff --git a/rtc_base/thread_darwin.mm b/rtc_base/thread_darwin.mm
deleted file mode 100644
index e64d6eb..0000000
--- a/rtc_base/thread_darwin.mm
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- *  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.
- */
-
-#include "rtc_base/thread.h"
-
-#import <Foundation/Foundation.h>
-
-#include "rtc_base/platform_thread.h"
-#include "rtc_base/timeutils.h"  // for TimeAfter, TimeUntil
-
-/*
- * This file contains platform-specific implementations for several
- * methods in rtc::Thread.
- */
-
-namespace {
-void InitCocoaMultiThreading() {
-  if ([NSThread isMultiThreaded] == NO) {
-    // The sole purpose of this autorelease pool is to avoid a console
-    // message on Leopard that tells us we're autoreleasing the thread
-    // with no autorelease pool in place.
-    @autoreleasepool {
-      [NSThread detachNewThreadSelector:@selector(class)
-                               toTarget:[NSObject class]
-                             withObject:nil];
-    }
-  }
-
-  RTC_DCHECK([NSThread isMultiThreaded]);
-}
-}
-
-namespace rtc {
-
-ThreadManager::ThreadManager() : main_thread_ref_(CurrentThreadRef()) {
-  pthread_key_create(&key_, nullptr);
-  // This is necessary to alert the cocoa runtime of the fact that
-  // we are running in a multithreaded environment.
-  InitCocoaMultiThreading();
-}
-
-// static
-void* Thread::PreRun(void* pv) {
-  ThreadInit* init = static_cast<ThreadInit*>(pv);
-  ThreadManager::Instance()->SetCurrentThread(init->thread);
-  rtc::SetCurrentThreadName(init->thread->name_.c_str());
-  @autoreleasepool {
-    if (init->runnable) {
-      init->runnable->Run(init->thread);
-    } else {
-      init->thread->Run();
-    }
-  }
-  ThreadManager::Instance()->SetCurrentThread(nullptr);
-  delete init;
-  return nullptr;
-}
-
-bool Thread::ProcessMessages(int cmsLoop) {
-  int64_t msEnd = (kForever == cmsLoop) ? 0 : TimeAfter(cmsLoop);
-  int cmsNext = cmsLoop;
-
-  while (true) {
-    @autoreleasepool {
-      Message msg;
-      if (!Get(&msg, cmsNext))
-        return !IsQuitting();
-      Dispatch(&msg);
-
-      if (cmsLoop != kForever) {
-        cmsNext = static_cast<int>(TimeUntil(msEnd));
-        if (cmsNext < 0)
-          return true;
-      }
-    }
-  }
-}
-}  // namespace rtc
diff --git a/rtc_base/thread_unittest.cc b/rtc_base/thread_unittest.cc
index d5c53f8..7e392af 100644
--- a/rtc_base/thread_unittest.cc
+++ b/rtc_base/thread_unittest.cc
@@ -69,7 +69,7 @@
                 const char* buf,
                 size_t size,
                 const SocketAddress& remote_addr,
-                const PacketTime& packet_time) {
+                const int64_t& packet_time_us) {
     EXPECT_EQ(size, sizeof(uint32_t));
     uint32_t prev = reinterpret_cast<const uint32_t*>(buf)[0];
     uint32_t result = Next(prev);
@@ -470,9 +470,9 @@
   // Use these events to get in a state where the functor is in the middle of
   // executing, and then to wait for it to finish, ensuring the "EXPECT_FALSE"
   // is run.
-  Event functor_started(false, false);
-  Event functor_continue(false, false);
-  Event functor_finished(false, false);
+  Event functor_started;
+  Event functor_continue;
+  Event functor_finished;
 
   auto thread = Thread::CreateWithSocketServer();
   thread->Start();
@@ -507,7 +507,7 @@
 // destroyed. This shouldn't deadlock or crash; this second invocation should
 // just be ignored.
 TEST_F(AsyncInvokeTest, KillInvokerDuringExecuteWithReentrantInvoke) {
-  Event functor_started(false, false);
+  Event functor_started;
   // Flag used to verify that the recursively invoked task never actually runs.
   bool reentrant_functor_run = false;
 
diff --git a/rtc_base/timestampaligner.cc b/rtc_base/timestampaligner.cc
index a9bcafb..f2da101 100644
--- a/rtc_base/timestampaligner.cc
+++ b/rtc_base/timestampaligner.cc
@@ -8,6 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <cstdlib>
 #include <limits>
 
 #include "rtc_base/checks.h"
diff --git a/rtc_base/timeutils.cc b/rtc_base/timeutils.cc
index de8fc32..dc5b611 100644
--- a/rtc_base/timeutils.cc
+++ b/rtc_base/timeutils.cc
@@ -14,6 +14,7 @@
 #include <sys/time.h>
 #if defined(WEBRTC_MAC)
 #include <mach/mach_time.h>
+#include "rtc_base/numerics/safe_conversions.h"
 #endif
 #endif
 
@@ -28,7 +29,6 @@
 #endif
 
 #include "rtc_base/checks.h"
-#include "rtc_base/numerics/safe_conversions.h"
 #include "rtc_base/timeutils.h"
 
 namespace rtc {
@@ -154,7 +154,7 @@
   return ts + (num_wrap_ << 32);
 }
 
-int64_t TmToSeconds(const std::tm& tm) {
+int64_t TmToSeconds(const tm& tm) {
   static short int mdays[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
   static short int cumul_mdays[12] = {0,   31,  59,  90,  120, 151,
                                       181, 212, 243, 273, 304, 334};
diff --git a/rtc_base/timeutils.h b/rtc_base/timeutils.h
index 3a412a4..4e38a03 100644
--- a/rtc_base/timeutils.h
+++ b/rtc_base/timeutils.h
@@ -13,8 +13,6 @@
 
 #include <stdint.h>
 #include <time.h>
-
-#include <ctime>
 #include <string>
 
 #include "rtc_base/checks.h"
@@ -110,10 +108,10 @@
   int64_t num_wrap_;
 };
 
-// Convert from std::tm, which is relative to 1900-01-01 00:00 to number of
-// seconds from 1970-01-01 00:00 ("epoch").  Don't return time_t since that
+// Convert from tm, which is relative to 1900-01-01 00:00 to number of
+// seconds from 1970-01-01 00:00 ("epoch"). Don't return time_t since that
 // is still 32 bits on many systems.
-int64_t TmToSeconds(const std::tm& tm);
+int64_t TmToSeconds(const tm& tm);
 
 // Return the number of microseconds since January 1, 1970, UTC.
 // Useful mainly when producing logs to be correlated with other
diff --git a/rtc_base/timeutils_unittest.cc b/rtc_base/timeutils_unittest.cc
index 0e1949a..577efda 100644
--- a/rtc_base/timeutils_unittest.cc
+++ b/rtc_base/timeutils_unittest.cc
@@ -262,7 +262,7 @@
   worker->Start();
 
   // Post an event that won't be executed for 10 seconds.
-  Event message_handler_dispatched(false, false);
+  Event message_handler_dispatched;
   auto functor = [&message_handler_dispatched] {
     message_handler_dispatched.Set();
   };
diff --git a/rtc_base/unittest_main.cc b/rtc_base/unittest_main.cc
index 12543a3..5fd3a99 100644
--- a/rtc_base/unittest_main.cc
+++ b/rtc_base/unittest_main.cc
@@ -31,19 +31,20 @@
 #include "test/ios/test_support.h"
 #endif
 
-DEFINE_bool(help, false, "prints this message");
-DEFINE_string(log, "", "logging options to use");
-DEFINE_string(
+WEBRTC_DEFINE_bool(help, false, "prints this message");
+WEBRTC_DEFINE_string(log, "", "logging options to use");
+WEBRTC_DEFINE_string(
     force_fieldtrials,
     "",
     "Field trials control experimental feature code which can be forced. "
     "E.g. running with --force_fieldtrials=WebRTC-FooFeature/Enable/"
     " will assign the group Enable to field trial WebRTC-FooFeature.");
 #if defined(WEBRTC_WIN)
-DEFINE_int(crt_break_alloc, -1, "memory allocation to break on");
-DEFINE_bool(default_error_handlers,
-            false,
-            "leave the default exception/dbg handler functions in place");
+WEBRTC_DEFINE_int(crt_break_alloc, -1, "memory allocation to break on");
+WEBRTC_DEFINE_bool(
+    default_error_handlers,
+    false,
+    "leave the default exception/dbg handler functions in place");
 
 void TestInvalidParameterHandler(const wchar_t* expression,
                                  const wchar_t* function,
@@ -116,7 +117,7 @@
 
   // Initialize SSL which are used by several tests.
   rtc::InitializeSSL();
-  rtc::SSLStreamAdapter::enable_time_callback_for_testing();
+  rtc::SSLStreamAdapter::EnableTimeCallbackForTesting();
 
 #if defined(WEBRTC_IOS)
   rtc::test::InitTestSuite(RUN_ALL_TESTS, argc, argv, false);
@@ -136,5 +137,13 @@
     _CrtSetReportHook2(_CRT_RPTHOOK_REMOVE, TestCrtReportHandler);
 #endif
 
+#if defined(ADDRESS_SANITIZER) || defined(LEAK_SANITIZER) ||  \
+    defined(MEMORY_SANITIZER) || defined(THREAD_SANITIZER) || \
+    defined(UNDEFINED_SANITIZER)
+  // We want the test flagged as failed only for sanitizer defects,
+  // in which case the sanitizer will override exit code with 66.
+  return 0;
+#endif
+
   return res;
 }
diff --git a/rtc_base/unixfilesystem.cc b/rtc_base/unixfilesystem.cc
deleted file mode 100644
index 818cb8a..0000000
--- a/rtc_base/unixfilesystem.cc
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
- *  Copyright 2004 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 "rtc_base/unixfilesystem.h"
-
-#include <errno.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <sys/stat.h>
-#include <unistd.h>
-
-#if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS)
-#include <CoreServices/CoreServices.h>
-#include <IOKit/IOCFBundle.h>
-#include <sys/statvfs.h>
-#include "rtc_base/macutils.h"
-#endif  // WEBRTC_MAC && !defined(WEBRTC_IOS)
-
-#if defined(WEBRTC_POSIX) && !defined(WEBRTC_MAC) || defined(WEBRTC_IOS)
-#include <sys/types.h>
-#if defined(WEBRTC_ANDROID)
-#include <sys/statfs.h>
-#elif !defined(__native_client__)
-#include <sys/statvfs.h>
-#endif  //  !defined(__native_client__)
-#include <limits.h>
-#include <pwd.h>
-#include <stdio.h>
-#endif  // WEBRTC_POSIX && !WEBRTC_MAC || WEBRTC_IOS
-
-#if defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID)
-#include <ctype.h>
-#include <algorithm>
-#endif
-
-#if defined(__native_client__) && !defined(__GLIBC__)
-#include <sys/syslimits.h>
-#endif
-
-#include "rtc_base/arraysize.h"
-#include "rtc_base/checks.h"
-#include "rtc_base/fileutils.h"
-#include "rtc_base/logging.h"
-#include "rtc_base/pathutils.h"
-#include "rtc_base/stream.h"
-#include "rtc_base/stringutils.h"
-
-namespace rtc {
-
-UnixFilesystem::UnixFilesystem() {}
-
-UnixFilesystem::~UnixFilesystem() {}
-
-bool UnixFilesystem::DeleteFile(const Pathname& filename) {
-  RTC_LOG(LS_INFO) << "Deleting file:" << filename.pathname();
-
-  if (!IsFile(filename)) {
-    RTC_DCHECK(IsFile(filename));
-    return false;
-  }
-  return ::unlink(filename.pathname().c_str()) == 0;
-}
-
-bool UnixFilesystem::MoveFile(const Pathname& old_path,
-                              const Pathname& new_path) {
-  if (!IsFile(old_path)) {
-    RTC_DCHECK(IsFile(old_path));
-    return false;
-  }
-  RTC_LOG(LS_VERBOSE) << "Moving " << old_path.pathname() << " to "
-                      << new_path.pathname();
-  if (rename(old_path.pathname().c_str(), new_path.pathname().c_str()) != 0) {
-    return false;
-  }
-  return true;
-}
-
-bool UnixFilesystem::IsFolder(const Pathname& path) {
-  struct stat st;
-  if (stat(path.pathname().c_str(), &st) < 0)
-    return false;
-  return S_ISDIR(st.st_mode);
-}
-
-bool UnixFilesystem::IsFile(const Pathname& pathname) {
-  struct stat st;
-  int res = ::stat(pathname.pathname().c_str(), &st);
-  // Treat symlinks, named pipes, etc. all as files.
-  return res == 0 && !S_ISDIR(st.st_mode);
-}
-
-bool UnixFilesystem::GetFileSize(const Pathname& pathname, size_t* size) {
-  struct stat st;
-  if (::stat(pathname.pathname().c_str(), &st) != 0)
-    return false;
-  *size = st.st_size;
-  return true;
-}
-
-}  // namespace rtc
-
-#if defined(__native_client__)
-extern "C" int __attribute__((weak))
-link(const char* oldpath, const char* newpath) {
-  errno = EACCES;
-  return -1;
-}
-#endif
diff --git a/rtc_base/unixfilesystem.h b/rtc_base/unixfilesystem.h
deleted file mode 100644
index 711d7b3..0000000
--- a/rtc_base/unixfilesystem.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- *  Copyright 2004 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 RTC_BASE_UNIXFILESYSTEM_H_
-#define RTC_BASE_UNIXFILESYSTEM_H_
-
-#include <sys/types.h>
-
-#include "rtc_base/fileutils.h"
-
-namespace rtc {
-
-class UnixFilesystem : public FilesystemInterface {
- public:
-  UnixFilesystem();
-  ~UnixFilesystem() override;
-
-  // This will attempt to delete the file located at filename.
-  // It will fail with VERIY if you pass it a non-existant file, or a directory.
-  bool DeleteFile(const Pathname& filename) override;
-
-  // This moves a file from old_path to new_path, where "file" can be a plain
-  // file or directory, which will be moved recursively.
-  // Returns true if function succeeds.
-  bool MoveFile(const Pathname& old_path, const Pathname& new_path) override;
-
-  // Returns true if a pathname is a directory
-  bool IsFolder(const Pathname& pathname) override;
-
-  // Returns true of pathname represents an existing file
-  bool IsFile(const Pathname& pathname) override;
-
-  bool GetFileSize(const Pathname& path, size_t* size) override;
-};
-
-}  // namespace rtc
-
-#endif  // RTC_BASE_UNIXFILESYSTEM_H_
diff --git a/rtc_base/virtualsocket_unittest.cc b/rtc_base/virtualsocket_unittest.cc
index d2bff54..d44f46a 100644
--- a/rtc_base/virtualsocket_unittest.cc
+++ b/rtc_base/virtualsocket_unittest.cc
@@ -104,7 +104,7 @@
                     const char* data,
                     size_t size,
                     const SocketAddress& remote_addr,
-                    const PacketTime& packet_time) {
+                    const int64_t& /* packet_time_us */) {
     ASSERT_EQ(socket.get(), s);
     ASSERT_GE(size, 4U);
 
diff --git a/rtc_base/virtualsocketserver.cc b/rtc_base/virtualsocketserver.cc
index 53dad46..7969411 100644
--- a/rtc_base/virtualsocketserver.cc
+++ b/rtc_base/virtualsocketserver.cc
@@ -525,7 +525,6 @@
 
 VirtualSocketServer::VirtualSocketServer(FakeClock* fake_clock)
     : fake_clock_(fake_clock),
-      wakeup_(/*manual_reset=*/false, /*initially_signaled=*/false),
       msg_queue_(nullptr),
       stop_on_idle_(false),
       next_ipv4_(kInitialNextIPv4),
diff --git a/rtc_base/weak_ptr_unittest.cc b/rtc_base/weak_ptr_unittest.cc
index 9541718..66f2b4d 100644
--- a/rtc_base/weak_ptr_unittest.cc
+++ b/rtc_base/weak_ptr_unittest.cc
@@ -202,7 +202,7 @@
 std::unique_ptr<T> NewObjectCreatedOnTaskQueue() {
   std::unique_ptr<T> obj;
   TaskQueue queue("NewObjectCreatedOnTaskQueue");
-  Event event(false, false);
+  Event event;
   queue.PostTask([&event, &obj] {
     obj.reset(new T());
     event.Set();
@@ -229,7 +229,7 @@
   // Create weak ptr on main thread
   WeakPtr<Target> weak_ptr = target->factory.GetWeakPtr();
   rtc::TaskQueue queue("queue");
-  rtc::Event done(false, false);
+  rtc::Event done;
   queue.PostTask([&] {
     // Dereference and invalide weak_ptr on another thread.
     EXPECT_EQ(weak_ptr.get(), target.get());
diff --git a/rtc_base/win32.cc b/rtc_base/win32.cc
index d81d685..e3482e3 100644
--- a/rtc_base/win32.cc
+++ b/rtc_base/win32.cc
@@ -72,9 +72,9 @@
   }
   const struct in_addr* as_in_addr =
       reinterpret_cast<const struct in_addr*>(src);
-  rtc::sprintfn(dst, size, "%d.%d.%d.%d", as_in_addr->S_un.S_un_b.s_b1,
-                as_in_addr->S_un.S_un_b.s_b2, as_in_addr->S_un.S_un_b.s_b3,
-                as_in_addr->S_un.S_un_b.s_b4);
+  snprintf(dst, size, "%d.%d.%d.%d", as_in_addr->S_un.S_un_b.s_b1,
+           as_in_addr->S_un.S_un_b.s_b2, as_in_addr->S_un.S_un_b.s_b3,
+           as_in_addr->S_un.S_un_b.s_b4);
   return dst;
 }
 
@@ -127,7 +127,7 @@
     *cursor++ = ':';
     *cursor++ = ':';
     if (maxpos == 4) {
-      cursor += rtc::sprintfn(cursor, INET6_ADDRSTRLEN - 2, "ffff:");
+      cursor += snprintf(cursor, INET6_ADDRSTRLEN - 2, "ffff:");
     }
     const struct in_addr* as_v4 =
         reinterpret_cast<const struct in_addr*>(&(as_shorts[6]));
@@ -136,8 +136,8 @@
   } else {
     for (int i = 0; i < run_array_size; ++i) {
       if (runpos[i] == -1) {
-        cursor += rtc::sprintfn(cursor, INET6_ADDRSTRLEN - (cursor - dst), "%x",
-                                NetworkToHost16(as_shorts[i]));
+        cursor += snprintf(cursor, INET6_ADDRSTRLEN - (cursor - dst), "%x",
+                           NetworkToHost16(as_shorts[i]));
         if (i != 7 && runpos[i + 1] != 1) {
           *cursor++ = ':';
         }
@@ -224,8 +224,8 @@
       *(readcursor + 2) != 0) {
     // Check for periods, which we'll take as a sign of v4 addresses.
     const char* addrstart = readcursor + 2;
-    if (rtc::strchr(addrstart, ".")) {
-      const char* colon = rtc::strchr(addrstart, "::");
+    if (strchr(addrstart, '.')) {
+      const char* colon = strchr(addrstart, ':');
       if (colon) {
         uint16_t a_short;
         int bytesread = 0;
diff --git a/rtc_base/win32filesystem.cc b/rtc_base/win32filesystem.cc
deleted file mode 100644
index cd43966..0000000
--- a/rtc_base/win32filesystem.cc
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- *  Copyright 2004 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 "rtc_base/win32filesystem.h"
-
-#include <shellapi.h>
-#include <shlobj.h>
-#include <tchar.h>
-#include "rtc_base/win32.h"
-
-#include <memory>
-
-#include "rtc_base/arraysize.h"
-#include "rtc_base/checks.h"
-#include "rtc_base/fileutils.h"
-#include "rtc_base/logging.h"
-#include "rtc_base/pathutils.h"
-#include "rtc_base/stream.h"
-#include "rtc_base/stringutils.h"
-
-// In several places in this file, we test the integrity level of the process
-// before calling GetLongPathName. We do this because calling GetLongPathName
-// when running under protected mode IE (a low integrity process) can result in
-// a virtualized path being returned, which is wrong if you only plan to read.
-// TODO: Waiting to hear back from IE team on whether this is the
-// best approach; IEIsProtectedModeProcess is another possible solution.
-
-namespace rtc {
-
-bool Win32Filesystem::DeleteFile(const Pathname& filename) {
-  RTC_LOG(LS_INFO) << "Deleting file " << filename.pathname();
-  if (!IsFile(filename)) {
-    RTC_DCHECK(IsFile(filename));
-    return false;
-  }
-  return ::DeleteFile(ToUtf16(filename.pathname()).c_str()) != 0;
-}
-
-bool Win32Filesystem::MoveFile(const Pathname& old_path,
-                               const Pathname& new_path) {
-  if (!IsFile(old_path)) {
-    RTC_DCHECK(IsFile(old_path));
-    return false;
-  }
-  RTC_LOG(LS_INFO) << "Moving " << old_path.pathname() << " to "
-                   << new_path.pathname();
-  return ::MoveFile(ToUtf16(old_path.pathname()).c_str(),
-                    ToUtf16(new_path.pathname()).c_str()) != 0;
-}
-
-bool Win32Filesystem::IsFolder(const Pathname& path) {
-  WIN32_FILE_ATTRIBUTE_DATA data = {0};
-  if (0 == ::GetFileAttributesEx(ToUtf16(path.pathname()).c_str(),
-                                 GetFileExInfoStandard, &data))
-    return false;
-  return (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ==
-         FILE_ATTRIBUTE_DIRECTORY;
-}
-
-bool Win32Filesystem::IsFile(const Pathname& path) {
-  WIN32_FILE_ATTRIBUTE_DATA data = {0};
-  if (0 == ::GetFileAttributesEx(ToUtf16(path.pathname()).c_str(),
-                                 GetFileExInfoStandard, &data))
-    return false;
-  return (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0;
-}
-
-bool Win32Filesystem::GetFileSize(const Pathname& pathname, size_t* size) {
-  WIN32_FILE_ATTRIBUTE_DATA data = {0};
-  if (::GetFileAttributesEx(ToUtf16(pathname.pathname()).c_str(),
-                            GetFileExInfoStandard, &data) == 0)
-    return false;
-  *size = data.nFileSizeLow;
-  return true;
-}
-
-}  // namespace rtc
diff --git a/rtc_base/win32filesystem.h b/rtc_base/win32filesystem.h
deleted file mode 100644
index d26741e..0000000
--- a/rtc_base/win32filesystem.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- *  Copyright 2004 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 RTC_BASE_WIN32FILESYSTEM_H_
-#define RTC_BASE_WIN32FILESYSTEM_H_
-
-#include "fileutils.h"
-
-namespace rtc {
-
-class Win32Filesystem : public FilesystemInterface {
- public:
-  // This will attempt to delete the path located at filename.
-  // If the path points to a folder, it will fail with VERIFY
-  bool DeleteFile(const Pathname& filename) override;
-
-  // This moves a file from old_path to new_path. If the new path is on a
-  // different volume than the old, it will attempt to copy and then delete
-  // the folder
-  // Returns true if the file is successfully moved
-  bool MoveFile(const Pathname& old_path, const Pathname& new_path) override;
-
-  // Returns true if a pathname is a directory
-  bool IsFolder(const Pathname& pathname) override;
-
-  // Returns true if a file exists at path
-  bool IsFile(const Pathname& path) override;
-
-  bool GetFileSize(const Pathname& path, size_t* size) override;
-};
-
-}  // namespace rtc
-
-#endif  // RTC_BASE_WIN32FILESYSTEM_H_
diff --git a/rtc_base/zero_memory.h b/rtc_base/zero_memory.h
index cb4646c..f697bcb 100644
--- a/rtc_base/zero_memory.h
+++ b/rtc_base/zero_memory.h
@@ -11,6 +11,7 @@
 #ifndef RTC_BASE_ZERO_MEMORY_H_
 #define RTC_BASE_ZERO_MEMORY_H_
 
+#include <stddef.h>
 #include <type_traits>
 
 #include "api/array_view.h"
diff --git a/system_wrappers/BUILD.gn b/system_wrappers/BUILD.gn
index eb60052..143a347 100644
--- a/system_wrappers/BUILD.gn
+++ b/system_wrappers/BUILD.gn
@@ -105,6 +105,16 @@
   if (rtc_exclude_field_trial_default) {
     defines = [ "WEBRTC_EXCLUDE_FIELD_TRIAL_DEFAULT" ]
   }
+  if (build_with_chromium) {
+    # When WebRTC is built as part of Chromium it should exclude the default
+    # implementation of field_trial unless it is building for NACL or
+    # Chromecast.
+    if (!is_nacl && !is_chromecast) {
+      deps = [
+        "../../webrtc_overrides:field_trial",
+      ]
+    }
+  }
 }
 
 rtc_source_set("metrics") {
@@ -123,6 +133,9 @@
     "../rtc_base:checks",
     "../rtc_base:rtc_base_approved",
   ]
+  if (build_with_chromium) {
+    deps += [ "../../webrtc_overrides:metrics" ]
+  }
 }
 
 if (is_android && !build_with_mozilla) {
@@ -166,6 +179,7 @@
       "..:webrtc_common",
       "../rtc_base:rtc_base_approved",
       "../test:test_main",
+      "../test:test_support",
       "//testing/gtest",
     ]
 
diff --git a/system_wrappers/OWNERS b/system_wrappers/OWNERS
index 13b08a3..a08f611 100644
--- a/system_wrappers/OWNERS
+++ b/system_wrappers/OWNERS
@@ -2,7 +2,6 @@
 mflodman@webrtc.org
 niklas.enbom@webrtc.org
 nisse@webrtc.org
-perkj@webrtc.org
 
 # These are for the common case of adding or renaming files. If you're doing
 # structural changes, please get a review from a reviewer in this file.
diff --git a/system_wrappers/include/clock.h b/system_wrappers/include/clock.h
index 4b6eab8..f1fc11f 100644
--- a/system_wrappers/include/clock.h
+++ b/system_wrappers/include/clock.h
@@ -11,6 +11,7 @@
 #ifndef SYSTEM_WRAPPERS_INCLUDE_CLOCK_H_
 #define SYSTEM_WRAPPERS_INCLUDE_CLOCK_H_
 
+#include <stdint.h>
 #include <memory>
 
 #include "rtc_base/synchronization/rw_lock_wrapper.h"
diff --git a/system_wrappers/include/event_wrapper.h b/system_wrappers/include/event_wrapper.h
index 0531ddb..989e792 100644
--- a/system_wrappers/include/event_wrapper.h
+++ b/system_wrappers/include/event_wrapper.h
@@ -12,11 +12,7 @@
 #define SYSTEM_WRAPPERS_INCLUDE_EVENT_WRAPPER_H_
 
 namespace webrtc {
-enum EventTypeWrapper {
-  kEventSignaled = 1,
-  kEventError = 2,
-  kEventTimeout = 3
-};
+enum EventTypeWrapper { kEventSignaled = 1, kEventTimeout = 2 };
 
 #define WEBRTC_EVENT_INFINITE 0xffffffff
 
diff --git a/system_wrappers/include/rtp_to_ntp_estimator.h b/system_wrappers/include/rtp_to_ntp_estimator.h
index d7009d8..51da4d2 100644
--- a/system_wrappers/include/rtp_to_ntp_estimator.h
+++ b/system_wrappers/include/rtp_to_ntp_estimator.h
@@ -11,10 +11,12 @@
 #ifndef SYSTEM_WRAPPERS_INCLUDE_RTP_TO_NTP_ESTIMATOR_H_
 #define SYSTEM_WRAPPERS_INCLUDE_RTP_TO_NTP_ESTIMATOR_H_
 
+#include <stdint.h>
 #include <list>
 
 #include "absl/types/optional.h"
 #include "modules/include/module_common_types_public.h"
+#include "rtc_base/checks.h"
 #include "rtc_base/numerics/moving_median_filter.h"
 #include "system_wrappers/include/ntp_time.h"
 
diff --git a/system_wrappers/source/clock.cc b/system_wrappers/source/clock.cc
index 35ab5f0..4f5d9cf 100644
--- a/system_wrappers/source/clock.cc
+++ b/system_wrappers/source/clock.cc
@@ -17,6 +17,8 @@
 
 #include <mmsystem.h>
 
+#include "rtc_base/criticalsection.h"
+
 #elif defined(WEBRTC_POSIX)
 
 #include <sys/time.h>
@@ -24,7 +26,6 @@
 
 #endif  // defined(WEBRTC_POSIX)
 
-#include "rtc_base/criticalsection.h"
 #include "rtc_base/synchronization/rw_lock_wrapper.h"
 #include "rtc_base/timeutils.h"
 
diff --git a/system_wrappers/source/event.cc b/system_wrappers/source/event.cc
index d1d2cda..0c4ce10 100644
--- a/system_wrappers/source/event.cc
+++ b/system_wrappers/source/event.cc
@@ -14,9 +14,6 @@
 #include <windows.h>
 #elif defined(WEBRTC_MAC) && !defined(WEBRTC_IOS)
 #include <ApplicationServices/ApplicationServices.h>
-#include <pthread.h>
-#else
-#include <pthread.h>
 #endif
 
 #include "rtc_base/event.h"
@@ -25,7 +22,6 @@
 
 class EventWrapperImpl : public EventWrapper {
  public:
-  EventWrapperImpl() : event_(false, false) {}
   ~EventWrapperImpl() override {}
 
   bool Set() override {
diff --git a/system_wrappers/source/field_trial.cc b/system_wrappers/source/field_trial.cc
index 60158f4..ac71311 100644
--- a/system_wrappers/source/field_trial.cc
+++ b/system_wrappers/source/field_trial.cc
@@ -9,6 +9,7 @@
 
 #include "system_wrappers/include/field_trial.h"
 
+#include <stddef.h>
 #include <string>
 
 // Simple field trial implementation, which allows client to
diff --git a/system_wrappers/source/rtp_to_ntp_estimator.cc b/system_wrappers/source/rtp_to_ntp_estimator.cc
index 730c4f6..aaef4b1 100644
--- a/system_wrappers/source/rtp_to_ntp_estimator.cc
+++ b/system_wrappers/source/rtp_to_ntp_estimator.cc
@@ -10,9 +10,10 @@
 
 #include "system_wrappers/include/rtp_to_ntp_estimator.h"
 
+#include <stddef.h>
+
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
-#include "system_wrappers/include/clock.h"
 
 namespace webrtc {
 namespace {