diff --git a/absl/BUILD.bazel b/absl/BUILD.bazel
index 439addb..edd0274 100644
--- a/absl/BUILD.bazel
+++ b/absl/BUILD.bazel
@@ -18,11 +18,10 @@
 
 licenses(["notice"])  # Apache 2.0
 
-config_setting(
+load(":compiler_config_setting.bzl", "create_llvm_config")
+
+create_llvm_config(
     name = "llvm_compiler",
-    values = {
-        "compiler": "llvm",
-    },
     visibility = [":__subpackages__"],
 )
 
diff --git a/absl/algorithm/container.h b/absl/algorithm/container.h
index acddec4..6af8c09 100644
--- a/absl/algorithm/container.h
+++ b/absl/algorithm/container.h
@@ -314,7 +314,7 @@
 
 // c_mismatch()
 //
-// Container-based version of the <algorithm> `std::mismatchf()` function to
+// Container-based version of the <algorithm> `std::mismatch()` function to
 // return the first element where two ordered containers differ.
 template <typename C1, typename C2>
 container_algorithm_internal::ContainerIterPairType<C1, C2>
diff --git a/absl/base/BUILD.bazel b/absl/base/BUILD.bazel
index 35414a2..06d092e 100644
--- a/absl/base/BUILD.bazel
+++ b/absl/base/BUILD.bazel
@@ -362,6 +362,7 @@
     copts = ABSL_TEST_COPTS,
     deps = [
         ":base",
+        "//absl/strings",
         "@com_google_googletest//:gtest_main",
     ],
 )
diff --git a/absl/base/CMakeLists.txt b/absl/base/CMakeLists.txt
index 303533e..01d2af0 100644
--- a/absl/base/CMakeLists.txt
+++ b/absl/base/CMakeLists.txt
@@ -310,7 +310,7 @@
 
 # test raw_logging_test
 set(RAW_LOGGING_TEST_SRC "raw_logging_test.cc")
-set(RAW_LOGGING_TEST_PUBLIC_LIBRARIES absl::base)
+set(RAW_LOGGING_TEST_PUBLIC_LIBRARIES absl::base absl::strings)
 
 absl_test(
   TARGET
diff --git a/absl/base/config.h b/absl/base/config.h
index 2f5f159..6890e31 100644
--- a/absl/base/config.h
+++ b/absl/base/config.h
@@ -268,7 +268,7 @@
 #error ABSL_HAVE_MMAP cannot be directly set
 #elif defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) ||   \
     defined(__ros__) || defined(__native_client__) || defined(__asmjs__) || \
-    defined(__wasm__) || defined(__Fuchsia__)
+    defined(__wasm__) || defined(__Fuchsia__) || defined(__sun)
 #define ABSL_HAVE_MMAP 1
 #endif
 
diff --git a/absl/base/internal/endian_test.cc b/absl/base/internal/endian_test.cc
index f3ff4b3..e276915 100644
--- a/absl/base/internal/endian_test.cc
+++ b/absl/base/internal/endian_test.cc
@@ -33,32 +33,16 @@
 const int kNumValuesToTest = 1000000;
 const int kRandomSeed = 12345;
 
-#ifdef ABSL_IS_BIG_ENDIAN
+#if defined(ABSL_IS_BIG_ENDIAN)
 const uint64_t kInitialInNetworkOrder{kInitialNumber};
 const uint64_t k64ValueLE{0xefcdab8967452301};
 const uint32_t k32ValueLE{0x67452301};
 const uint16_t k16ValueLE{0x2301};
-const uint8_t k8ValueLE{k8Value};
-const uint64_t k64IValueLE{0xefcdab89674523a1};
-const uint32_t k32IValueLE{0x67452391};
-const uint16_t k16IValueLE{0x85ff};
-const uint8_t k8IValueLE{0xff};
-const uint64_t kDoubleValueLE{0x6e861bf0f9210940};
-const uint32_t kFloatValueLE{0xd00f4940};
-const uint8_t kBoolValueLE{0x1};
 
 const uint64_t k64ValueBE{kInitialNumber};
 const uint32_t k32ValueBE{k32Value};
 const uint16_t k16ValueBE{k16Value};
-const uint8_t k8ValueBE{k8Value};
-const uint64_t k64IValueBE{0xa123456789abcdef};
-const uint32_t k32IValueBE{0x91234567};
-const uint16_t k16IValueBE{0xff85};
-const uint8_t k8IValueBE{0xff};
-const uint64_t kDoubleValueBE{0x400921f9f01b866e};
-const uint32_t kFloatValueBE{0x40490fd0};
-const uint8_t kBoolValueBE{0x1};
-#elif defined ABSL_IS_LITTLE_ENDIAN
+#elif defined(ABSL_IS_LITTLE_ENDIAN)
 const uint64_t kInitialInNetworkOrder{0xefcdab8967452301};
 const uint64_t k64ValueLE{kInitialNumber};
 const uint32_t k32ValueLE{k32Value};
diff --git a/absl/base/internal/exception_testing.h b/absl/base/internal/exception_testing.h
index fd89a3f..0cf7918 100644
--- a/absl/base/internal/exception_testing.h
+++ b/absl/base/internal/exception_testing.h
@@ -35,7 +35,7 @@
   EXPECT_DEATH(expr, ".*")
 #else
 #define ABSL_BASE_INTERNAL_EXPECT_FAIL(expr, exception_t, text) \
-  EXPECT_DEATH(expr, text)
+  EXPECT_DEATH_IF_SUPPORTED(expr, text)
 
 #endif
 
diff --git a/absl/base/internal/raw_logging.cc b/absl/base/internal/raw_logging.cc
index 1ce1388..d9485a6 100644
--- a/absl/base/internal/raw_logging.cc
+++ b/absl/base/internal/raw_logging.cc
@@ -139,7 +139,7 @@
 #endif
 
 #ifdef ABSL_MIN_LOG_LEVEL
-  if (static_cast<int>(severity) < ABSL_MIN_LOG_LEVEL &&
+  if (severity < static_cast<absl::LogSeverity>(ABSL_MIN_LOG_LEVEL) &&
       severity < absl::LogSeverity::kFatal) {
     enabled = false;
   }
@@ -206,6 +206,15 @@
   va_end(ap);
 }
 
+// Non-formatting version of RawLog().
+//
+// TODO(gfalcon): When string_view no longer depends on base, change this
+// interface to take its message as a string_view instead.
+static void DefaultInternalLog(absl::LogSeverity severity, const char* file,
+                               int line, const std::string& message) {
+  RawLog(severity, file, line, "%s", message.c_str());
+}
+
 bool RawLoggingFullySupported() {
 #ifdef ABSL_LOW_LEVEL_WRITE_SUPPORTED
   return true;
@@ -214,5 +223,12 @@
 #endif  // !ABSL_LOW_LEVEL_WRITE_SUPPORTED
 }
 
+ABSL_CONST_INIT absl::base_internal::AtomicHook<InternalLogFunction>
+    internal_log_function(DefaultInternalLog);
+
+void RegisterInternalLogFunction(InternalLogFunction func) {
+  internal_log_function.Store(func);
+}
+
 }  // namespace raw_logging_internal
 }  // namespace absl
diff --git a/absl/base/internal/raw_logging.h b/absl/base/internal/raw_logging.h
index a2b7207..67abfd3 100644
--- a/absl/base/internal/raw_logging.h
+++ b/absl/base/internal/raw_logging.h
@@ -19,7 +19,10 @@
 #ifndef ABSL_BASE_INTERNAL_RAW_LOGGING_H_
 #define ABSL_BASE_INTERNAL_RAW_LOGGING_H_
 
+#include <string>
+
 #include "absl/base/attributes.h"
+#include "absl/base/internal/atomic_hook.h"
 #include "absl/base/log_severity.h"
 #include "absl/base/macros.h"
 #include "absl/base/port.h"
@@ -57,6 +60,34 @@
     }                                                                  \
   } while (0)
 
+// ABSL_INTERNAL_LOG and ABSL_INTERNAL_CHECK work like the RAW variants above,
+// except that if the richer log library is linked into the binary, we dispatch
+// to that instead.  This is potentially useful for internal logging and
+// assertions, where we are using RAW_LOG neither for its async-signal-safety
+// nor for its non-allocating nature, but rather because raw logging has very
+// few other dependencies.
+//
+// The API is a subset of the above: each macro only takes two arguments.  Use
+// StrCat if you need to build a richer message.
+#define ABSL_INTERNAL_LOG(severity, message)                          \
+  do {                                                                \
+    constexpr const char* absl_raw_logging_internal_basename =        \
+        ::absl::raw_logging_internal::Basename(__FILE__,              \
+                                               sizeof(__FILE__) - 1); \
+    ::absl::raw_logging_internal::internal_log_function(              \
+        ABSL_RAW_LOGGING_INTERNAL_##severity,                         \
+        absl_raw_logging_internal_basename, __LINE__, message);       \
+  } while (0)
+
+#define ABSL_INTERNAL_CHECK(condition, message)               \
+  do {                                                        \
+    if (ABSL_PREDICT_FALSE(!(condition))) {                   \
+      std::string death_message = "Check " #condition " failed: "; \
+      death_message += std::string(message);                       \
+      ABSL_INTERNAL_LOG(FATAL, death_message);                \
+    }                                                         \
+  } while (0)
+
 #define ABSL_RAW_LOGGING_INTERNAL_INFO ::absl::LogSeverity::kInfo
 #define ABSL_RAW_LOGGING_INTERNAL_WARNING ::absl::LogSeverity::kWarning
 #define ABSL_RAW_LOGGING_INTERNAL_ERROR ::absl::LogSeverity::kError
@@ -131,6 +162,18 @@
 using AbortHook = void (*)(const char* file, int line, const char* buf_start,
                            const char* prefix_end, const char* buf_end);
 
+// Internal logging function for ABSL_INTERNAL_LOG to dispatch to.
+//
+// TODO(gfalcon): When string_view no longer depends on base, change this
+// interface to take its message as a string_view instead.
+using InternalLogFunction = void (*)(absl::LogSeverity severity,
+                                     const char* file, int line,
+                                     const std::string& message);
+
+extern base_internal::AtomicHook<InternalLogFunction> internal_log_function;
+
+void RegisterInternalLogFunction(InternalLogFunction func);
+
 }  // namespace raw_logging_internal
 }  // namespace absl
 
diff --git a/absl/base/internal/unaligned_access.h b/absl/base/internal/unaligned_access.h
index c572436..5c7517a 100644
--- a/absl/base/internal/unaligned_access.h
+++ b/absl/base/internal/unaligned_access.h
@@ -103,6 +103,47 @@
 #define ABSL_INTERNAL_UNALIGNED_STORE64(_p, _val) \
   (absl::UnalignedStore64(_p, _val))
 
+#elif defined(UNDEFINED_BEHAVIOR_SANITIZER)
+
+namespace absl {
+
+inline uint16_t UnalignedLoad16(const void *p) {
+  uint16_t t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline uint32_t UnalignedLoad32(const void *p) {
+  uint32_t t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline uint64_t UnalignedLoad64(const void *p) {
+  uint64_t t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline void UnalignedStore16(void *p, uint16_t v) { memcpy(p, &v, sizeof v); }
+
+inline void UnalignedStore32(void *p, uint32_t v) { memcpy(p, &v, sizeof v); }
+
+inline void UnalignedStore64(void *p, uint64_t v) { memcpy(p, &v, sizeof v); }
+
+}  // namespace absl
+
+#define ABSL_INTERNAL_UNALIGNED_LOAD16(_p) (absl::UnalignedLoad16(_p))
+#define ABSL_INTERNAL_UNALIGNED_LOAD32(_p) (absl::UnalignedLoad32(_p))
+#define ABSL_INTERNAL_UNALIGNED_LOAD64(_p) (absl::UnalignedLoad64(_p))
+
+#define ABSL_INTERNAL_UNALIGNED_STORE16(_p, _val) \
+  (absl::UnalignedStore16(_p, _val))
+#define ABSL_INTERNAL_UNALIGNED_STORE32(_p, _val) \
+  (absl::UnalignedStore32(_p, _val))
+#define ABSL_INTERNAL_UNALIGNED_STORE64(_p, _val) \
+  (absl::UnalignedStore64(_p, _val))
+
 #elif defined(__x86_64__) || defined(_M_X64) || defined(__i386) || \
     defined(_M_IX86) || defined(__ppc__) || defined(__PPC__) ||    \
     defined(__ppc64__) || defined(__PPC64__)
diff --git a/absl/base/raw_logging_test.cc b/absl/base/raw_logging_test.cc
index dae4b35..ebbc5db 100644
--- a/absl/base/raw_logging_test.cc
+++ b/absl/base/raw_logging_test.cc
@@ -18,12 +18,20 @@
 
 #include "absl/base/internal/raw_logging.h"
 
+#include <tuple>
+
 #include "gtest/gtest.h"
+#include "absl/strings/str_cat.h"
 
 namespace {
 
 TEST(RawLoggingCompilationTest, Log) {
   ABSL_RAW_LOG(INFO, "RAW INFO: %d", 1);
+  ABSL_RAW_LOG(INFO, "RAW INFO: %d %d", 1, 2);
+  ABSL_RAW_LOG(INFO, "RAW INFO: %d %d %d", 1, 2, 3);
+  ABSL_RAW_LOG(INFO, "RAW INFO: %d %d %d %d", 1, 2, 3, 4);
+  ABSL_RAW_LOG(INFO, "RAW INFO: %d %d %d %d %d", 1, 2, 3, 4, 5);
+  ABSL_RAW_LOG(WARNING, "RAW WARNING: %d", 1);
   ABSL_RAW_LOG(ERROR, "RAW ERROR: %d", 1);
 }
 
@@ -47,4 +55,25 @@
                             kExpectedDeathOutput);
 }
 
+TEST(InternalLog, CompilationTest) {
+  ABSL_INTERNAL_LOG(INFO, "Internal Log");
+  std::string log_msg = "Internal Log";
+  ABSL_INTERNAL_LOG(INFO, log_msg);
+
+  ABSL_INTERNAL_LOG(INFO, log_msg + " 2");
+
+  float d = 1.1f;
+  ABSL_INTERNAL_LOG(INFO, absl::StrCat("Internal log ", 3, " + ", d));
+}
+
+TEST(InternalLogDeathTest, FailingCheck) {
+  EXPECT_DEATH_IF_SUPPORTED(ABSL_INTERNAL_CHECK(1 == 0, "explanation"),
+                            kExpectedDeathOutput);
+}
+
+TEST(InternalLogDeathTest, LogFatal) {
+  EXPECT_DEATH_IF_SUPPORTED(ABSL_INTERNAL_LOG(FATAL, "my dog has fleas"),
+                            kExpectedDeathOutput);
+}
+
 }  // namespace
diff --git a/absl/compiler_config_setting.bzl b/absl/compiler_config_setting.bzl
new file mode 100644
index 0000000..b77c4f5
--- /dev/null
+++ b/absl/compiler_config_setting.bzl
@@ -0,0 +1,39 @@
+#
+# Copyright 2018 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""Creates config_setting that allows selecting based on 'compiler' value."""
+
+def create_llvm_config(name, visibility):
+  # The "do_not_use_tools_cpp_compiler_present" attribute exists to
+  # distinguish between older versions of Bazel that do not support
+  # "@bazel_tools//tools/cpp:compiler" flag_value, and newer ones that do.
+  # In the future, the only way to select on the compiler will be through
+  # flag_values{"@bazel_tools//tools/cpp:compiler"} and the else branch can
+  # be removed.
+  if hasattr(cc_common, "do_not_use_tools_cpp_compiler_present"):
+    native.config_setting(
+      name = name,
+      flag_values = {
+          "@bazel_tools//tools/cpp:compiler": "llvm",
+      },
+      visibility = visibility,
+    )
+  else:
+    native.config_setting(
+        name = name,
+        values = {"compiler": "llvm"},
+        visibility = visibility,
+    )
diff --git a/absl/container/BUILD.bazel b/absl/container/BUILD.bazel
index 07df367..6d5c958 100644
--- a/absl/container/BUILD.bazel
+++ b/absl/container/BUILD.bazel
@@ -26,10 +26,30 @@
 licenses(["notice"])  # Apache 2.0
 
 cc_library(
+    name = "compressed_tuple",
+    hdrs = ["internal/compressed_tuple.h"],
+    copts = ABSL_DEFAULT_COPTS,
+    deps = [
+        "//absl/utility",
+    ],
+)
+
+cc_test(
+    name = "compressed_tuple_test",
+    srcs = ["internal/compressed_tuple_test.cc"],
+    copts = ABSL_TEST_COPTS,
+    deps = [
+        ":compressed_tuple",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_library(
     name = "fixed_array",
     hdrs = ["fixed_array.h"],
     copts = ABSL_DEFAULT_COPTS,
     deps = [
+        ":compressed_tuple",
         "//absl/algorithm",
         "//absl/base:core_headers",
         "//absl/base:dynamic_annotations",
diff --git a/absl/container/BUILD.gn b/absl/container/BUILD.gn
index a00eaf4..001a2a3 100644
--- a/absl/container/BUILD.gn
+++ b/absl/container/BUILD.gn
@@ -14,6 +14,21 @@
   visibility = [ "*" ]
 }
 
+source_set("compressed_tuple") {
+  configs -= [ "//build/config/compiler:chromium_code" ]
+  configs += [
+    "//build/config/compiler:no_chromium_code",
+    "//third_party/abseil-cpp:absl_default_cflags_cc",
+  ]
+  public_configs = [ "//third_party/abseil-cpp:absl_include_config" ]
+  public = [
+    "internal/compressed_tuple.h",
+  ]
+  deps = [
+    "../utility",
+  ]
+}
+
 source_set("fixed_array") {
   configs -= [ "//build/config/compiler:chromium_code" ]
   configs += [
@@ -25,6 +40,7 @@
     "fixed_array.h",
   ]
   deps = [
+    ":compressed_tuple",
     "../algorithm",
     "../base:core_headers",
     "../base:dynamic_annotations",
diff --git a/absl/container/CMakeLists.txt b/absl/container/CMakeLists.txt
index d580b48..123e4c4 100644
--- a/absl/container/CMakeLists.txt
+++ b/absl/container/CMakeLists.txt
@@ -52,7 +52,6 @@
     ${TEST_INSTANCE_TRACKER_LIB_SRC}
   PUBLIC_LIBRARIES
     absl::container
-  DISABLE_INSTALL
 )
 
 
diff --git a/absl/container/fixed_array.h b/absl/container/fixed_array.h
index 708c615..182258f 100644
--- a/absl/container/fixed_array.h
+++ b/absl/container/fixed_array.h
@@ -47,6 +47,7 @@
 #include "absl/base/macros.h"
 #include "absl/base/optimization.h"
 #include "absl/base/port.h"
+#include "absl/container/internal/compressed_tuple.h"
 #include "absl/memory/memory.h"
 
 namespace absl {
@@ -76,73 +77,99 @@
 // heap allocation, it will do so with global `::operator new[]()` and
 // `::operator delete[]()`, even if T provides class-scope overrides for these
 // operators.
-template <typename T, size_t inlined = kFixedArrayUseDefault>
+template <typename T, size_t N = kFixedArrayUseDefault,
+          typename A = std::allocator<T>>
 class FixedArray {
   static_assert(!std::is_array<T>::value || std::extent<T>::value > 0,
                 "Arrays with unknown bounds cannot be used with FixedArray.");
+
   static constexpr size_t kInlineBytesDefault = 256;
 
+  using AllocatorTraits = std::allocator_traits<A>;
   // std::iterator_traits isn't guaranteed to be SFINAE-friendly until C++17,
   // but this seems to be mostly pedantic.
   template <typename Iterator>
   using EnableIfForwardIterator = absl::enable_if_t<std::is_convertible<
       typename std::iterator_traits<Iterator>::iterator_category,
       std::forward_iterator_tag>::value>;
+  static constexpr bool NoexceptCopyable() {
+    return std::is_nothrow_copy_constructible<StorageElement>::value &&
+           absl::allocator_is_nothrow<allocator_type>::value;
+  }
+  static constexpr bool NoexceptMovable() {
+    return std::is_nothrow_move_constructible<StorageElement>::value &&
+           absl::allocator_is_nothrow<allocator_type>::value;
+  }
+  static constexpr bool DefaultConstructorIsNonTrivial() {
+    return !absl::is_trivially_default_constructible<StorageElement>::value;
+  }
 
  public:
-  using value_type = T;
-  using iterator = T*;
-  using const_iterator = const T*;
+  using allocator_type = typename AllocatorTraits::allocator_type;
+  using value_type = typename allocator_type::value_type;
+  using pointer = typename allocator_type::pointer;
+  using const_pointer = typename allocator_type::const_pointer;
+  using reference = typename allocator_type::reference;
+  using const_reference = typename allocator_type::const_reference;
+  using size_type = typename allocator_type::size_type;
+  using difference_type = typename allocator_type::difference_type;
+  using iterator = pointer;
+  using const_iterator = const_pointer;
   using reverse_iterator = std::reverse_iterator<iterator>;
   using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-  using reference = T&;
-  using const_reference = const T&;
-  using pointer = T*;
-  using const_pointer = const T*;
-  using difference_type = ptrdiff_t;
-  using size_type = size_t;
 
   static constexpr size_type inline_elements =
-      inlined == kFixedArrayUseDefault
-          ? kInlineBytesDefault / sizeof(value_type)
-          : inlined;
+      (N == kFixedArrayUseDefault ? kInlineBytesDefault / sizeof(value_type)
+                                  : static_cast<size_type>(N));
 
-  FixedArray(const FixedArray& other)
-      : FixedArray(other.begin(), other.end()) {}
+  FixedArray(
+      const FixedArray& other,
+      const allocator_type& a = allocator_type()) noexcept(NoexceptCopyable())
+      : FixedArray(other.begin(), other.end(), a) {}
 
-  FixedArray(FixedArray&& other) noexcept(
-      absl::conjunction<absl::allocator_is_nothrow<std::allocator<value_type>>,
-                        std::is_nothrow_move_constructible<value_type>>::value)
+  FixedArray(
+      FixedArray&& other,
+      const allocator_type& a = allocator_type()) noexcept(NoexceptMovable())
       : FixedArray(std::make_move_iterator(other.begin()),
-                   std::make_move_iterator(other.end())) {}
+                   std::make_move_iterator(other.end()), a) {}
 
   // Creates an array object that can store `n` elements.
   // Note that trivially constructible elements will be uninitialized.
-  explicit FixedArray(size_type n) : storage_(n) {
-    absl::memory_internal::uninitialized_default_construct_n(storage_.begin(),
-                                                             size());
+  explicit FixedArray(size_type n, const allocator_type& a = allocator_type())
+      : storage_(n, a) {
+    if (DefaultConstructorIsNonTrivial()) {
+      memory_internal::ConstructStorage(storage_.alloc(), storage_.begin(),
+                                        storage_.end());
+    }
   }
 
   // Creates an array initialized with `n` copies of `val`.
-  FixedArray(size_type n, const value_type& val) : storage_(n) {
-    std::uninitialized_fill_n(data(), size(), val);
+  FixedArray(size_type n, const value_type& val,
+             const allocator_type& a = allocator_type())
+      : storage_(n, a) {
+    memory_internal::ConstructStorage(storage_.alloc(), storage_.begin(),
+                                      storage_.end(), val);
   }
 
+  // Creates an array initialized with the size and contents of `init_list`.
+  FixedArray(std::initializer_list<value_type> init_list,
+             const allocator_type& a = allocator_type())
+      : FixedArray(init_list.begin(), init_list.end(), a) {}
+
   // Creates an array initialized with the elements from the input
   // range. The array's size will always be `std::distance(first, last)`.
   // REQUIRES: Iterator must be a forward_iterator or better.
   template <typename Iterator, EnableIfForwardIterator<Iterator>* = nullptr>
-  FixedArray(Iterator first, Iterator last)
-      : storage_(std::distance(first, last)) {
-    std::uninitialized_copy(first, last, data());
+  FixedArray(Iterator first, Iterator last,
+             const allocator_type& a = allocator_type())
+      : storage_(std::distance(first, last), a) {
+    memory_internal::CopyToStorageFromRange(storage_.alloc(), storage_.begin(),
+                                            first, last);
   }
 
-  FixedArray(std::initializer_list<value_type> init_list)
-      : FixedArray(init_list.begin(), init_list.end()) {}
-
   ~FixedArray() noexcept {
-    for (const StorageElement& cur : storage_) {
-      cur.~StorageElement();
+    for (auto* cur = storage_.begin(); cur != storage_.end(); ++cur) {
+      AllocatorTraits::destroy(*storage_.alloc(), cur);
     }
   }
 
@@ -332,7 +359,6 @@
   friend bool operator>=(const FixedArray& lhs, const FixedArray& rhs) {
     return !(lhs < rhs);
   }
-
  private:
   // StorageElement
   //
@@ -364,6 +390,8 @@
   using StorageElement =
       absl::conditional_t<std::is_array<value_type>::value,
                           StorageElementWrapper<value_type>, value_type>;
+  using StorageElementBuffer =
+      absl::aligned_storage_t<sizeof(StorageElement), alignof(StorageElement)>;
 
   static pointer AsValueType(pointer ptr) { return ptr; }
   static pointer AsValueType(StorageElementWrapper<value_type>* ptr) {
@@ -374,9 +402,6 @@
   static_assert(alignof(StorageElement) == alignof(value_type), "");
 
   struct NonEmptyInlinedStorage {
-    using StorageElementBuffer =
-        absl::aligned_storage_t<sizeof(StorageElement),
-                                alignof(StorageElement)>;
     StorageElement* data() {
       return reinterpret_cast<StorageElement*>(inlined_storage_.data());
     }
@@ -386,8 +411,8 @@
     void* RedzoneEnd() { return &redzone_end_ + 1; }
 #endif  // ADDRESS_SANITIZER
 
-    void AnnotateConstruct(size_t);
-    void AnnotateDestruct(size_t);
+    void AnnotateConstruct(size_type);
+    void AnnotateDestruct(size_type);
 
     ABSL_ADDRESS_SANITIZER_REDZONE(redzone_begin_);
     std::array<StorageElementBuffer, inline_elements> inlined_storage_;
@@ -396,8 +421,8 @@
 
   struct EmptyInlinedStorage {
     StorageElement* data() { return nullptr; }
-    void AnnotateConstruct(size_t) {}
-    void AnnotateDestruct(size_t) {}
+    void AnnotateConstruct(size_type) {}
+    void AnnotateDestruct(size_type) {}
   };
 
   using InlinedStorage =
@@ -414,48 +439,57 @@
   //
   class Storage : public InlinedStorage {
    public:
-    explicit Storage(size_type n) : data_(CreateStorage(n)), size_(n) {}
+    Storage(size_type n, const allocator_type& a)
+        : size_alloc_(n, a), data_(InitializeData()) {}
+
     ~Storage() noexcept {
       if (UsingInlinedStorage(size())) {
-        this->AnnotateDestruct(size());
+        InlinedStorage::AnnotateDestruct(size());
       } else {
-        std::allocator<StorageElement>().deallocate(begin(), size());
+        AllocatorTraits::deallocate(*alloc(), AsValueType(begin()), size());
       }
     }
 
-    size_type size() const { return size_; }
+    size_type size() const { return size_alloc_.template get<0>(); }
     StorageElement* begin() const { return data_; }
     StorageElement* end() const { return begin() + size(); }
+    allocator_type* alloc() {
+      return std::addressof(size_alloc_.template get<1>());
+    }
 
    private:
     static bool UsingInlinedStorage(size_type n) {
       return n <= inline_elements;
     }
 
-    StorageElement* CreateStorage(size_type n) {
-      if (UsingInlinedStorage(n)) {
-        this->AnnotateConstruct(n);
+    StorageElement* InitializeData() {
+      if (UsingInlinedStorage(size())) {
+        InlinedStorage::AnnotateConstruct(size());
         return InlinedStorage::data();
       } else {
-        return std::allocator<StorageElement>().allocate(n);
+        return reinterpret_cast<StorageElement*>(
+            AllocatorTraits::allocate(*alloc(), size()));
       }
     }
 
-    StorageElement* const data_;
-    const size_type size_;
+    // `CompressedTuple` takes advantage of EBCO for stateless `allocator_type`s
+    container_internal::CompressedTuple<size_type, allocator_type> size_alloc_;
+    StorageElement* data_;
   };
 
-  const Storage storage_;
+  Storage storage_;
 };
 
-template <typename T, size_t N>
-constexpr size_t FixedArray<T, N>::inline_elements;
+template <typename T, size_t N, typename A>
+constexpr size_t FixedArray<T, N, A>::kInlineBytesDefault;
 
-template <typename T, size_t N>
-constexpr size_t FixedArray<T, N>::kInlineBytesDefault;
+template <typename T, size_t N, typename A>
+constexpr typename FixedArray<T, N, A>::size_type
+    FixedArray<T, N, A>::inline_elements;
 
-template <typename T, size_t N>
-void FixedArray<T, N>::NonEmptyInlinedStorage::AnnotateConstruct(size_t n) {
+template <typename T, size_t N, typename A>
+void FixedArray<T, N, A>::NonEmptyInlinedStorage::AnnotateConstruct(
+    typename FixedArray<T, N, A>::size_type n) {
 #ifdef ADDRESS_SANITIZER
   if (!n) return;
   ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(data(), RedzoneEnd(), RedzoneEnd(), data() + n);
@@ -464,8 +498,9 @@
   static_cast<void>(n);  // Mark used when not in asan mode
 }
 
-template <typename T, size_t N>
-void FixedArray<T, N>::NonEmptyInlinedStorage::AnnotateDestruct(size_t n) {
+template <typename T, size_t N, typename A>
+void FixedArray<T, N, A>::NonEmptyInlinedStorage::AnnotateDestruct(
+    typename FixedArray<T, N, A>::size_type n) {
 #ifdef ADDRESS_SANITIZER
   if (!n) return;
   ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(data(), RedzoneEnd(), data() + n, RedzoneEnd());
@@ -473,6 +508,5 @@
 #endif                   // ADDRESS_SANITIZER
   static_cast<void>(n);  // Mark used when not in asan mode
 }
-
 }  // namespace absl
 #endif  // ABSL_CONTAINER_FIXED_ARRAY_H_
diff --git a/absl/container/fixed_array_test.cc b/absl/container/fixed_array_test.cc
index 2142132..b07ebcb 100644
--- a/absl/container/fixed_array_test.cc
+++ b/absl/container/fixed_array_test.cc
@@ -15,9 +15,11 @@
 #include "absl/container/fixed_array.h"
 
 #include <stdio.h>
+#include <cstring>
 #include <list>
 #include <memory>
 #include <numeric>
+#include <scoped_allocator>
 #include <stdexcept>
 #include <string>
 #include <vector>
@@ -607,6 +609,216 @@
   empty.fill(fill_val);
 }
 
+// TODO(johnsoncj): Investigate InlinedStorage default initialization in GCC 4.x
+#ifndef __GNUC__
+TEST(FixedArrayTest, DefaultCtorDoesNotValueInit) {
+  using T = char;
+  constexpr auto capacity = 10;
+  using FixedArrType = absl::FixedArray<T, capacity>;
+  using FixedArrBuffType =
+      absl::aligned_storage_t<sizeof(FixedArrType), alignof(FixedArrType)>;
+  constexpr auto scrubbed_bits = 0x95;
+  constexpr auto length = capacity / 2;
+
+  FixedArrBuffType buff;
+  std::memset(std::addressof(buff), scrubbed_bits, sizeof(FixedArrBuffType));
+
+  FixedArrType* arr =
+      ::new (static_cast<void*>(std::addressof(buff))) FixedArrType(length);
+  EXPECT_THAT(*arr, testing::Each(scrubbed_bits));
+  arr->~FixedArrType();
+}
+#endif  // __GNUC__
+
+// This is a stateful allocator, but the state lives outside of the
+// allocator (in whatever test is using the allocator). This is odd
+// but helps in tests where the allocator is propagated into nested
+// containers - that chain of allocators uses the same state and is
+// thus easier to query for aggregate allocation information.
+template <typename T>
+class CountingAllocator : public std::allocator<T> {
+ public:
+  using Alloc = std::allocator<T>;
+  using pointer = typename Alloc::pointer;
+  using size_type = typename Alloc::size_type;
+
+  CountingAllocator() : bytes_used_(nullptr), instance_count_(nullptr) {}
+  explicit CountingAllocator(int64_t* b)
+      : bytes_used_(b), instance_count_(nullptr) {}
+  CountingAllocator(int64_t* b, int64_t* a)
+      : bytes_used_(b), instance_count_(a) {}
+
+  template <typename U>
+  explicit CountingAllocator(const CountingAllocator<U>& x)
+      : Alloc(x),
+        bytes_used_(x.bytes_used_),
+        instance_count_(x.instance_count_) {}
+
+  pointer allocate(size_type n, const void* const hint = nullptr) {
+    assert(bytes_used_ != nullptr);
+    *bytes_used_ += n * sizeof(T);
+    return Alloc::allocate(n, hint);
+  }
+
+  void deallocate(pointer p, size_type n) {
+    Alloc::deallocate(p, n);
+    assert(bytes_used_ != nullptr);
+    *bytes_used_ -= n * sizeof(T);
+  }
+
+  template <typename... Args>
+  void construct(pointer p, Args&&... args) {
+    Alloc::construct(p, absl::forward<Args>(args)...);
+    if (instance_count_) {
+      *instance_count_ += 1;
+    }
+  }
+
+  void destroy(pointer p) {
+    Alloc::destroy(p);
+    if (instance_count_) {
+      *instance_count_ -= 1;
+    }
+  }
+
+  template <typename U>
+  class rebind {
+   public:
+    using other = CountingAllocator<U>;
+  };
+
+  int64_t* bytes_used_;
+  int64_t* instance_count_;
+};
+
+TEST(AllocatorSupportTest, CountInlineAllocations) {
+  constexpr size_t inlined_size = 4;
+  using Alloc = CountingAllocator<int>;
+  using AllocFxdArr = absl::FixedArray<int, inlined_size, Alloc>;
+
+  int64_t allocated = 0;
+  int64_t active_instances = 0;
+
+  {
+    const int ia[] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+    Alloc alloc(&allocated, &active_instances);
+
+    AllocFxdArr arr(ia, ia + inlined_size, alloc);
+    static_cast<void>(arr);
+  }
+
+  EXPECT_EQ(allocated, 0);
+  EXPECT_EQ(active_instances, 0);
+}
+
+TEST(AllocatorSupportTest, CountOutoflineAllocations) {
+  constexpr size_t inlined_size = 4;
+  using Alloc = CountingAllocator<int>;
+  using AllocFxdArr = absl::FixedArray<int, inlined_size, Alloc>;
+
+  int64_t allocated = 0;
+  int64_t active_instances = 0;
+
+  {
+    const int ia[] = {0, 1, 2, 3, 4, 5, 6, 7};
+    Alloc alloc(&allocated, &active_instances);
+
+    AllocFxdArr arr(ia, ia + ABSL_ARRAYSIZE(ia), alloc);
+
+    EXPECT_EQ(allocated, arr.size() * sizeof(int));
+    static_cast<void>(arr);
+  }
+
+  EXPECT_EQ(active_instances, 0);
+}
+
+TEST(AllocatorSupportTest, CountCopyInlineAllocations) {
+  constexpr size_t inlined_size = 4;
+  using Alloc = CountingAllocator<int>;
+  using AllocFxdArr = absl::FixedArray<int, inlined_size, Alloc>;
+
+  int64_t allocated1 = 0;
+  int64_t allocated2 = 0;
+  int64_t active_instances = 0;
+  Alloc alloc(&allocated1, &active_instances);
+  Alloc alloc2(&allocated2, &active_instances);
+
+  {
+    int initial_value = 1;
+
+    AllocFxdArr arr1(inlined_size / 2, initial_value, alloc);
+
+    EXPECT_EQ(allocated1, 0);
+
+    AllocFxdArr arr2(arr1, alloc2);
+
+    EXPECT_EQ(allocated2, 0);
+    static_cast<void>(arr1);
+    static_cast<void>(arr2);
+  }
+
+  EXPECT_EQ(active_instances, 0);
+}
+
+TEST(AllocatorSupportTest, CountCopyOutoflineAllocations) {
+  constexpr size_t inlined_size = 4;
+  using Alloc = CountingAllocator<int>;
+  using AllocFxdArr = absl::FixedArray<int, inlined_size, Alloc>;
+
+  int64_t allocated1 = 0;
+  int64_t allocated2 = 0;
+  int64_t active_instances = 0;
+  Alloc alloc(&allocated1, &active_instances);
+  Alloc alloc2(&allocated2, &active_instances);
+
+  {
+    int initial_value = 1;
+
+    AllocFxdArr arr1(inlined_size * 2, initial_value, alloc);
+
+    EXPECT_EQ(allocated1, arr1.size() * sizeof(int));
+
+    AllocFxdArr arr2(arr1, alloc2);
+
+    EXPECT_EQ(allocated2, inlined_size * 2 * sizeof(int));
+    static_cast<void>(arr1);
+    static_cast<void>(arr2);
+  }
+
+  EXPECT_EQ(active_instances, 0);
+}
+
+TEST(AllocatorSupportTest, SizeValAllocConstructor) {
+  using testing::AllOf;
+  using testing::Each;
+  using testing::SizeIs;
+
+  constexpr size_t inlined_size = 4;
+  using Alloc = CountingAllocator<int>;
+  using AllocFxdArr = absl::FixedArray<int, inlined_size, Alloc>;
+
+  {
+    auto len = inlined_size / 2;
+    auto val = 0;
+    int64_t allocated = 0;
+    AllocFxdArr arr(len, val, Alloc(&allocated));
+
+    EXPECT_EQ(allocated, 0);
+    EXPECT_THAT(arr, AllOf(SizeIs(len), Each(0)));
+  }
+
+  {
+    auto len = inlined_size * 2;
+    auto val = 0;
+    int64_t allocated = 0;
+    AllocFxdArr arr(len, val, Alloc(&allocated));
+
+    EXPECT_EQ(allocated, len * sizeof(int));
+    EXPECT_THAT(arr, AllOf(SizeIs(len), Each(0)));
+  }
+}
+
 #ifdef ADDRESS_SANITIZER
 TEST(FixedArrayTest, AddressSanitizerAnnotations1) {
   absl::FixedArray<int, 32> a(10);
@@ -655,5 +867,4 @@
   EXPECT_DEATH(raw[21] = ThreeInts(), "container-overflow");
 }
 #endif  // ADDRESS_SANITIZER
-
 }  // namespace
diff --git a/absl/container/inlined_vector.h b/absl/container/inlined_vector.h
index 03660f1..ca36fd3 100644
--- a/absl/container/inlined_vector.h
+++ b/absl/container/inlined_vector.h
@@ -626,14 +626,18 @@
   // It holds whether the vector is allocated or not in the lowest bit.
   // The size is held in the high bits:
   //   size_ = (size << 1) | is_allocated;
+  //
+  // Maintainer's Note: size_type is user defined. The contract is limited to
+  // arithmetic operators to avoid depending on compliant overloaded bitwise
+  // operators.
   class Tag {
    public:
     Tag() : size_(0) {}
-    size_type size() const { return size_ >> 1; }
-    void add_size(size_type n) { size_ += n << 1; }
-    void set_inline_size(size_type n) { size_ = n << 1; }
-    void set_allocated_size(size_type n) { size_ = (n << 1) | 1; }
-    bool allocated() const { return size_ & 1; }
+    size_type size() const { return size_ / 2; }
+    void add_size(size_type n) { size_ += n * 2; }
+    void set_inline_size(size_type n) { size_ = n * 2; }
+    void set_allocated_size(size_type n) { size_ = (n * 2) + 1; }
+    bool allocated() const { return size_ % 2; }
 
    private:
     size_type size_;
@@ -689,11 +693,14 @@
     new (&rep_.allocation_storage.allocation) Allocation(allocation);
   }
 
+  // TODO(absl-team): investigate whether the reinterpret_cast is appropriate.
   value_type* inlined_space() {
-    return reinterpret_cast<value_type*>(&rep_.inlined_storage.inlined);
+    return reinterpret_cast<value_type*>(
+        std::addressof(rep_.inlined_storage.inlined[0]));
   }
   const value_type* inlined_space() const {
-    return reinterpret_cast<const value_type*>(&rep_.inlined_storage.inlined);
+    return reinterpret_cast<const value_type*>(
+        std::addressof(rep_.inlined_storage.inlined[0]));
   }
 
   value_type* allocated_space() { return allocation().buffer(); }
diff --git a/absl/container/inlined_vector_test.cc b/absl/container/inlined_vector_test.cc
index f81fad5..196a1be 100644
--- a/absl/container/inlined_vector_test.cc
+++ b/absl/container/inlined_vector_test.cc
@@ -1788,5 +1788,4 @@
     EXPECT_THAT(v, AllOf(SizeIs(len), Each(0)));
   }
 }
-
 }  // anonymous namespace
diff --git a/absl/container/internal/compressed_tuple.h b/absl/container/internal/compressed_tuple.h
new file mode 100644
index 0000000..cc52614
--- /dev/null
+++ b/absl/container/internal/compressed_tuple.h
@@ -0,0 +1,175 @@
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Helper class to perform the Empty Base Optimization.
+// Ts can contain classes and non-classes, empty or not. For the ones that
+// are empty classes, we perform the optimization. If all types in Ts are empty
+// classes, then CompressedTuple<Ts...> is itself an empty class.
+//
+// To access the members, use member get<N>() function.
+//
+// Eg:
+//   absl::container_internal::CompressedTuple<int, T1, T2, T3> value(7, t1, t2,
+//                                                                    t3);
+//   assert(value.get<0>() == 7);
+//   T1& t1 = value.get<1>();
+//   const T2& t2 = value.get<2>();
+//   ...
+//
+// http://en.cppreference.com/w/cpp/language/ebo
+
+#ifndef ABSL_CONTAINER_INTERNAL_COMPRESSED_TUPLE_H_
+#define ABSL_CONTAINER_INTERNAL_COMPRESSED_TUPLE_H_
+
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include "absl/utility/utility.h"
+
+#ifdef _MSC_VER
+// We need to mark these classes with this declspec to ensure that
+// CompressedTuple happens.
+#define ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC __declspec(empty_bases)
+#else  // _MSC_VER
+#define ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC
+#endif  // _MSC_VER
+
+namespace absl {
+namespace container_internal {
+
+template <typename... Ts>
+class CompressedTuple;
+
+namespace internal_compressed_tuple {
+
+template <typename D, size_t I>
+struct Elem;
+template <typename... B, size_t I>
+struct Elem<CompressedTuple<B...>, I>
+    : std::tuple_element<I, std::tuple<B...>> {};
+template <typename D, size_t I>
+using ElemT = typename Elem<D, I>::type;
+
+// Use the __is_final intrinsic if available. Where it's not available, classes
+// declared with the 'final' specifier cannot be used as CompressedTuple
+// elements.
+// TODO(sbenza): Replace this with std::is_final in C++14.
+template <typename T>
+constexpr bool IsFinal() {
+#if defined(__clang__) || defined(__GNUC__)
+  return __is_final(T);
+#else
+  return false;
+#endif
+}
+
+template <typename T>
+constexpr bool ShouldUseBase() {
+  return std::is_class<T>::value && std::is_empty<T>::value && !IsFinal<T>();
+}
+
+// The storage class provides two specializations:
+//  - For empty classes, it stores T as a base class.
+//  - For everything else, it stores T as a member.
+template <typename D, size_t I, bool = ShouldUseBase<ElemT<D, I>>()>
+struct Storage {
+  using T = ElemT<D, I>;
+  T value;
+  constexpr Storage() = default;
+  explicit constexpr Storage(T&& v) : value(absl::forward<T>(v)) {}
+  constexpr const T& get() const { return value; }
+  T& get() { return value; }
+};
+
+template <typename D, size_t I>
+struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC Storage<D, I, true>
+    : ElemT<D, I> {
+  using T = internal_compressed_tuple::ElemT<D, I>;
+  constexpr Storage() = default;
+  explicit constexpr Storage(T&& v) : T(absl::forward<T>(v)) {}
+  constexpr const T& get() const { return *this; }
+  T& get() { return *this; }
+};
+
+template <typename D, typename I>
+struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl;
+
+template <typename... Ts, size_t... I>
+struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC
+    CompressedTupleImpl<CompressedTuple<Ts...>, absl::index_sequence<I...>>
+    // We use the dummy identity function through std::integral_constant to
+    // convince MSVC of accepting and expanding I in that context. Without it
+    // you would get:
+    //   error C3548: 'I': parameter pack cannot be used in this context
+    : Storage<CompressedTuple<Ts...>,
+              std::integral_constant<size_t, I>::value>... {
+  constexpr CompressedTupleImpl() = default;
+  explicit constexpr CompressedTupleImpl(Ts&&... args)
+      : Storage<CompressedTuple<Ts...>, I>(absl::forward<Ts>(args))... {}
+};
+
+}  // namespace internal_compressed_tuple
+
+// Helper class to perform the Empty Base Class Optimization.
+// Ts can contain classes and non-classes, empty or not. For the ones that
+// are empty classes, we perform the CompressedTuple. If all types in Ts are
+// empty classes, then CompressedTuple<Ts...> is itself an empty class.
+//
+// To access the members, use member .get<N>() function.
+//
+// Eg:
+//   absl::container_internal::CompressedTuple<int, T1, T2, T3> value(7, t1, t2,
+//                                                                    t3);
+//   assert(value.get<0>() == 7);
+//   T1& t1 = value.get<1>();
+//   const T2& t2 = value.get<2>();
+//   ...
+//
+// http://en.cppreference.com/w/cpp/language/ebo
+template <typename... Ts>
+class ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple
+    : private internal_compressed_tuple::CompressedTupleImpl<
+          CompressedTuple<Ts...>, absl::index_sequence_for<Ts...>> {
+ private:
+  template <int I>
+  using ElemT = internal_compressed_tuple::ElemT<CompressedTuple, I>;
+
+ public:
+  constexpr CompressedTuple() = default;
+  explicit constexpr CompressedTuple(Ts... base)
+      : CompressedTuple::CompressedTupleImpl(absl::forward<Ts>(base)...) {}
+
+  template <int I>
+  ElemT<I>& get() {
+    return internal_compressed_tuple::Storage<CompressedTuple, I>::get();
+  }
+
+  template <int I>
+  constexpr const ElemT<I>& get() const {
+    return internal_compressed_tuple::Storage<CompressedTuple, I>::get();
+  }
+};
+
+// Explicit specialization for a zero-element tuple
+// (needed to avoid ambiguous overloads for the default constructor).
+template <>
+class ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple<> {};
+
+}  // namespace container_internal
+}  // namespace absl
+
+#undef ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC
+
+#endif  // ABSL_CONTAINER_INTERNAL_COMPRESSED_TUPLE_H_
diff --git a/absl/container/internal/compressed_tuple_test.cc b/absl/container/internal/compressed_tuple_test.cc
new file mode 100644
index 0000000..45030c6
--- /dev/null
+++ b/absl/container/internal/compressed_tuple_test.cc
@@ -0,0 +1,166 @@
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/container/internal/compressed_tuple.h"
+
+#include <string>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace absl {
+namespace container_internal {
+namespace {
+
+template <int>
+struct Empty {};
+
+template <typename T>
+struct NotEmpty {
+  T value;
+};
+
+template <typename T, typename U>
+struct TwoValues {
+  T value1;
+  U value2;
+};
+
+TEST(CompressedTupleTest, Sizeof) {
+  EXPECT_EQ(sizeof(int), sizeof(CompressedTuple<int>));
+  EXPECT_EQ(sizeof(int), sizeof(CompressedTuple<int, Empty<0>>));
+  EXPECT_EQ(sizeof(int), sizeof(CompressedTuple<int, Empty<0>, Empty<1>>));
+  EXPECT_EQ(sizeof(int),
+            sizeof(CompressedTuple<int, Empty<0>, Empty<1>, Empty<2>>));
+
+  EXPECT_EQ(sizeof(TwoValues<int, double>),
+            sizeof(CompressedTuple<int, NotEmpty<double>>));
+  EXPECT_EQ(sizeof(TwoValues<int, double>),
+            sizeof(CompressedTuple<int, Empty<0>, NotEmpty<double>>));
+  EXPECT_EQ(sizeof(TwoValues<int, double>),
+            sizeof(CompressedTuple<int, Empty<0>, NotEmpty<double>, Empty<1>>));
+}
+
+TEST(CompressedTupleTest, Access) {
+  struct S {
+    std::string x;
+  };
+  CompressedTuple<int, Empty<0>, S> x(7, {}, S{"ABC"});
+  EXPECT_EQ(sizeof(x), sizeof(TwoValues<int, S>));
+  EXPECT_EQ(7, x.get<0>());
+  EXPECT_EQ("ABC", x.get<2>().x);
+}
+
+TEST(CompressedTupleTest, NonClasses) {
+  CompressedTuple<int, const char*> x(7, "ABC");
+  EXPECT_EQ(7, x.get<0>());
+  EXPECT_STREQ("ABC", x.get<1>());
+}
+
+TEST(CompressedTupleTest, MixClassAndNonClass) {
+  CompressedTuple<int, const char*, Empty<0>, NotEmpty<double>> x(7, "ABC", {},
+                                                                  {1.25});
+  struct Mock {
+    int v;
+    const char* p;
+    double d;
+  };
+  EXPECT_EQ(sizeof(x), sizeof(Mock));
+  EXPECT_EQ(7, x.get<0>());
+  EXPECT_STREQ("ABC", x.get<1>());
+  EXPECT_EQ(1.25, x.get<3>().value);
+}
+
+TEST(CompressedTupleTest, Nested) {
+  CompressedTuple<int, CompressedTuple<int>,
+                  CompressedTuple<int, CompressedTuple<int>>>
+      x(1, CompressedTuple<int>(2),
+        CompressedTuple<int, CompressedTuple<int>>(3, CompressedTuple<int>(4)));
+  EXPECT_EQ(1, x.get<0>());
+  EXPECT_EQ(2, x.get<1>().get<0>());
+  EXPECT_EQ(3, x.get<2>().get<0>());
+  EXPECT_EQ(4, x.get<2>().get<1>().get<0>());
+
+  CompressedTuple<Empty<0>, Empty<0>,
+                  CompressedTuple<Empty<0>, CompressedTuple<Empty<0>>>>
+      y;
+  std::set<Empty<0>*> empties{&y.get<0>(), &y.get<1>(), &y.get<2>().get<0>(),
+                              &y.get<2>().get<1>().get<0>()};
+#ifdef _MSC_VER
+  // MSVC has a bug where many instances of the same base class are layed out in
+  // the same address when using __declspec(empty_bases).
+  // This will be fixed in a future version of MSVC.
+  int expected = 1;
+#else
+  int expected = 4;
+#endif
+  EXPECT_EQ(expected, sizeof(y));
+  EXPECT_EQ(expected, empties.size());
+  EXPECT_EQ(sizeof(y), sizeof(Empty<0>) * empties.size());
+
+  EXPECT_EQ(4 * sizeof(char),
+            sizeof(CompressedTuple<CompressedTuple<char, char>,
+                                   CompressedTuple<char, char>>));
+  EXPECT_TRUE(
+      (std::is_empty<CompressedTuple<CompressedTuple<Empty<0>>,
+                                     CompressedTuple<Empty<1>>>>::value));
+}
+
+TEST(CompressedTupleTest, Reference) {
+  int i = 7;
+  std::string s = "Very long std::string that goes in the heap";
+  CompressedTuple<int, int&, std::string, std::string&> x(i, i, s, s);
+
+  // Sanity check. We should have not moved from `s`
+  EXPECT_EQ(s, "Very long std::string that goes in the heap");
+
+  EXPECT_EQ(x.get<0>(), x.get<1>());
+  EXPECT_NE(&x.get<0>(), &x.get<1>());
+  EXPECT_EQ(&x.get<1>(), &i);
+
+  EXPECT_EQ(x.get<2>(), x.get<3>());
+  EXPECT_NE(&x.get<2>(), &x.get<3>());
+  EXPECT_EQ(&x.get<3>(), &s);
+}
+
+TEST(CompressedTupleTest, NoElements) {
+  CompressedTuple<> x;
+  static_cast<void>(x);  // Silence -Wunused-variable.
+  EXPECT_TRUE(std::is_empty<CompressedTuple<>>::value);
+}
+
+TEST(CompressedTupleTest, Constexpr) {
+  constexpr CompressedTuple<int, double, CompressedTuple<int>> x(
+      7, 1.25, CompressedTuple<int>(5));
+  constexpr int x0 = x.get<0>();
+  constexpr double x1 = x.get<1>();
+  constexpr int x2 = x.get<2>().get<0>();
+  EXPECT_EQ(x0, 7);
+  EXPECT_EQ(x1, 1.25);
+  EXPECT_EQ(x2, 5);
+}
+
+#if defined(__clang__) || defined(__GNUC__)
+TEST(CompressedTupleTest, EmptyFinalClass) {
+  struct S final {
+    int f() const { return 5; }
+  };
+  CompressedTuple<S> x;
+  EXPECT_EQ(x.get<0>().f(), 5);
+}
+#endif
+
+}  // namespace
+}  // namespace container_internal
+}  // namespace absl
diff --git a/absl/copts.bzl b/absl/copts.bzl
index 20c9b61..0168ac5 100644
--- a/absl/copts.bzl
+++ b/absl/copts.bzl
@@ -31,7 +31,6 @@
     "-Wno-unused-private-field",
 ]
 
-
 # Docs on single flags is preceded by a comment.
 # Docs on groups of flags is preceded by ###.
 
diff --git a/absl/debugging/failure_signal_handler.cc b/absl/debugging/failure_signal_handler.cc
index 4c131fe..d4b957b 100644
--- a/absl/debugging/failure_signal_handler.cc
+++ b/absl/debugging/failure_signal_handler.cc
@@ -252,7 +252,7 @@
       depth, min_dropped_frames, symbolize_stacktrace, writerfn, writerfn_arg);
 }
 
-// Called by FailureSignalHandler() to write the failure info. It is
+// Called by AbslFailureSignalHandler() to write the failure info. It is
 // called once with writerfn set to WriteToStderr() and then possibly
 // with writerfn set to the user provided function.
 static void WriteFailureInfo(int signo, void* ucontext,
@@ -278,9 +278,9 @@
 }
 
 #ifdef ABSL_HAVE_ALARM
-// FailureSignalHandler() installs this as a signal handler for
+// AbslFailureSignalHandler() installs this as a signal handler for
 // SIGALRM, then sets an alarm to be delivered to the program after a
-// set amount of time. If FailureSignalHandler() hangs for more than
+// set amount of time. If AbslFailureSignalHandler() hangs for more than
 // the alarm timeout, ImmediateAbortSignalHandler() will abort the
 // program.
 static void ImmediateAbortSignalHandler(int) {
@@ -294,11 +294,10 @@
 ABSL_CONST_INIT static std::atomic<GetTidType> failed_tid(0);
 
 #ifndef ABSL_HAVE_SIGACTION
-static void FailureSignalHandler(int signo) {
+static void AbslFailureSignalHandler(int signo) {
   void* ucontext = nullptr;
 #else
-static void FailureSignalHandler(int signo, siginfo_t*,
-                                 void* ucontext) {
+static void AbslFailureSignalHandler(int signo, siginfo_t*, void* ucontext) {
 #endif
 
   const GetTidType this_tid = absl::base_internal::GetTID();
@@ -308,10 +307,10 @@
           std::memory_order_acq_rel, std::memory_order_relaxed)) {
     ABSL_RAW_LOG(
         ERROR,
-        "Signal %d raised at PC=%p while already in FailureSignalHandler()",
+        "Signal %d raised at PC=%p while already in AbslFailureSignalHandler()",
         signo, absl::debugging_internal::GetProgramCounter(ucontext));
     if (this_tid != previous_failed_tid) {
-      // Another thread is already in FailureSignalHandler(), so wait
+      // Another thread is already in AbslFailureSignalHandler(), so wait
       // a bit for it to finish. If the other thread doesn't kill us,
       // we do so after sleeping.
       PortableSleepForSeconds(3);
@@ -349,7 +348,7 @@
 void InstallFailureSignalHandler(const FailureSignalHandlerOptions& options) {
   fsh_options = options;
   for (auto& it : failure_signal_data) {
-    InstallOneFailureHandler(&it, FailureSignalHandler);
+    InstallOneFailureHandler(&it, AbslFailureSignalHandler);
   }
 }
 
diff --git a/absl/debugging/internal/examine_stack.cc b/absl/debugging/internal/examine_stack.cc
index 8434709..faf8883 100644
--- a/absl/debugging/internal/examine_stack.cc
+++ b/absl/debugging/internal/examine_stack.cc
@@ -52,6 +52,10 @@
     return reinterpret_cast<void*>(context->uc_mcontext.gp_regs[32]);
 #elif defined(__powerpc__)
     return reinterpret_cast<void*>(context->uc_mcontext.regs->nip);
+#elif defined(__s390__) && !defined(__s390x__)
+    return reinterpret_cast<void*>(context->uc_mcontext.psw.addr & 0x7fffffff);
+#elif defined(__s390__) && defined(__s390x__)
+    return reinterpret_cast<void*>(context->uc_mcontext.psw.addr);
 #elif defined(__x86_64__)
     if (16 < ABSL_ARRAYSIZE(context->uc_mcontext.gregs))
       return reinterpret_cast<void*>(context->uc_mcontext.gregs[16]);
diff --git a/absl/debugging/internal/stacktrace_config.h b/absl/debugging/internal/stacktrace_config.h
index 48adfcc..dd713da 100644
--- a/absl/debugging/internal/stacktrace_config.h
+++ b/absl/debugging/internal/stacktrace_config.h
@@ -21,26 +21,16 @@
 #ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_CONFIG_H_
 #define ABSL_DEBUGGING_INTERNAL_STACKTRACE_CONFIG_H_
 
-// First, test platforms which only support a stub.
-#if ABSL_STACKTRACE_INL_HEADER
+#if defined(ABSL_STACKTRACE_INL_HEADER)
 #error ABSL_STACKTRACE_INL_HEADER cannot be directly set
-#elif defined(__native_client__) || defined(__APPLE__) || \
-    defined(__FreeBSD__) || defined(__ANDROID__) || defined(__myriad2__) || \
-    defined(__asmjs__) || defined(__wasm__) || defined(__Fuchsia__)
-#define ABSL_STACKTRACE_INL_HEADER \
-    "absl/debugging/internal/stacktrace_unimplemented-inl.inc"
 
-// Next, test for Mips and Windows.
-// TODO(marmstrong): Mips case, remove the check for ABSL_STACKTRACE_INL_HEADER
-#elif defined(__mips__) && !defined(ABSL_STACKTRACE_INL_HEADER)
-#define ABSL_STACKTRACE_INL_HEADER \
-    "absl/debugging/internal/stacktrace_unimplemented-inl.inc"
-#elif defined(_WIN32)  // windows
+#elif defined(_WIN32)
 #define ABSL_STACKTRACE_INL_HEADER \
     "absl/debugging/internal/stacktrace_win32-inl.inc"
 
-// Finally, test NO_FRAME_POINTER.
-#elif !defined(NO_FRAME_POINTER)
+#elif defined(__linux__) && !defined(__ANDROID__)
+
+#if !defined(NO_FRAME_POINTER)
 # if defined(__i386__) || defined(__x86_64__)
 #define ABSL_STACKTRACE_INL_HEADER \
     "absl/debugging/internal/stacktrace_x86-inl.inc"
@@ -53,22 +43,27 @@
 # elif defined(__arm__)
 #define ABSL_STACKTRACE_INL_HEADER \
     "absl/debugging/internal/stacktrace_arm-inl.inc"
+# else
+#define ABSL_STACKTRACE_INL_HEADER \
+   "absl/debugging/internal/stacktrace_unimplemented-inl.inc"
 # endif
 #else  // defined(NO_FRAME_POINTER)
 # if defined(__i386__) || defined(__x86_64__) || defined(__aarch64__)
 #define ABSL_STACKTRACE_INL_HEADER \
-    "absl/debugging/internal/stacktrace_unimplemented-inl.inc"
+    "absl/debugging/internal/stacktrace_generic-inl.inc"
 # elif defined(__ppc__) || defined(__PPC__)
-//  Use glibc's backtrace.
 #define ABSL_STACKTRACE_INL_HEADER \
     "absl/debugging/internal/stacktrace_generic-inl.inc"
-# elif defined(__arm__)
-#   error stacktrace without frame pointer is not supported on ARM
+# else
+#define ABSL_STACKTRACE_INL_HEADER \
+   "absl/debugging/internal/stacktrace_unimplemented-inl.inc"
 # endif
 #endif  // NO_FRAME_POINTER
 
-#if !defined(ABSL_STACKTRACE_INL_HEADER)
-#error Not supported yet
+#else
+#define ABSL_STACKTRACE_INL_HEADER \
+  "absl/debugging/internal/stacktrace_unimplemented-inl.inc"
+
 #endif
 
 #endif  // ABSL_DEBUGGING_INTERNAL_STACKTRACE_CONFIG_H_
diff --git a/absl/debugging/internal/stacktrace_powerpc-inl.inc b/absl/debugging/internal/stacktrace_powerpc-inl.inc
index 297bdad..860ac2b 100644
--- a/absl/debugging/internal/stacktrace_powerpc-inl.inc
+++ b/absl/debugging/internal/stacktrace_powerpc-inl.inc
@@ -31,6 +31,8 @@
 #include <cstdint>
 #include <cstdio>
 
+#include "absl/base/attributes.h"
+#include "absl/base/optimization.h"
 #include "absl/base/port.h"
 #include "absl/debugging/stacktrace.h"
 #include "absl/debugging/internal/address_is_readable.h"
@@ -150,8 +152,9 @@
 }
 
 // This ensures that absl::GetStackTrace sets up the Link Register properly.
-void StacktracePowerPCDummyFunction() __attribute__((noinline));
-void StacktracePowerPCDummyFunction() { __asm__ volatile(""); }
+ABSL_ATTRIBUTE_NOINLINE static void AbslStacktracePowerPCDummyFunction() {
+  ABSL_BLOCK_TAIL_CALL_OPTIMIZATION();
+}
 
 template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
 ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
@@ -176,7 +179,7 @@
   // want here.  While the compiler will always(?) set up LR for
   // subroutine calls, it may not for leaf functions (such as this one).
   // This routine forces the compiler (at least gcc) to push it anyway.
-  StacktracePowerPCDummyFunction();
+  AbslStacktracePowerPCDummyFunction();
 
   // The LR save area is used by the callee, so the top entry is bogus.
   skip_count++;
diff --git a/absl/memory/memory.h b/absl/memory/memory.h
index c43e156..c7caf8b 100644
--- a/absl/memory/memory.h
+++ b/absl/memory/memory.h
@@ -83,7 +83,11 @@
 
 }  // namespace memory_internal
 
-#if __cplusplus >= 201402L || defined(_MSC_VER)
+// gcc 4.8 has __cplusplus at 201301 but doesn't define make_unique.  Other
+// supported compilers either just define __cplusplus as 201103 but have
+// make_unique (msvc), or have make_unique whenever __cplusplus > 201103 (clang)
+#if (__cplusplus > 201103L || defined(_MSC_VER)) && \
+    !(defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 8)
 using std::make_unique;
 #else
 // -----------------------------------------------------------------------------
@@ -637,38 +641,56 @@
 #endif
 
 namespace memory_internal {
-// TODO(b110200014): Implement proper backports
-template <typename ForwardIt>
-void DefaultConstruct(ForwardIt it) {
-  using value_type = typename std::iterator_traits<ForwardIt>::value_type;
-  ::new (static_cast<void*>(std::addressof(*it))) value_type;
-}  // namespace memory_internal
-
 #ifdef ABSL_HAVE_EXCEPTIONS
-template <typename ForwardIt, typename Size>
-void uninitialized_default_construct_n(ForwardIt first, Size size) {
-  for (ForwardIt cur = first; size > 0; static_cast<void>(++cur), --size) {
+template <typename Allocator, typename StorageElement, typename... Args>
+void ConstructStorage(Allocator* alloc, StorageElement* first,
+                      StorageElement* last, const Args&... args) {
+  for (StorageElement* cur = first; cur != last; ++cur) {
     try {
-      absl::memory_internal::DefaultConstruct(cur);
+      std::allocator_traits<Allocator>::construct(*alloc, cur, args...);
     } catch (...) {
-      using value_type = typename std::iterator_traits<ForwardIt>::value_type;
-      for (; first != cur; ++first) {
-        first->~value_type();
+      while (cur != first) {
+        --cur;
+        std::allocator_traits<Allocator>::destroy(*alloc, cur);
+      }
+      throw;
+    }
+  }
+}
+template <typename Allocator, typename StorageElement, typename Iterator>
+void CopyToStorageFromRange(Allocator* alloc, StorageElement* destination,
+                            Iterator first, Iterator last) {
+  for (StorageElement* cur = destination; first != last;
+       static_cast<void>(++cur), static_cast<void>(++first)) {
+    try {
+      std::allocator_traits<Allocator>::construct(*alloc, cur, *first);
+    } catch (...) {
+      while (cur != destination) {
+        --cur;
+        std::allocator_traits<Allocator>::destroy(*alloc, cur);
       }
       throw;
     }
   }
 }
 #else   // ABSL_HAVE_EXCEPTIONS
-template <typename ForwardIt, typename Size>
-void uninitialized_default_construct_n(ForwardIt first, Size size) {
-  for (; size > 0; static_cast<void>(++first), --size) {
-    absl::memory_internal::DefaultConstruct(first);
+template <typename Allocator, typename StorageElement, typename... Args>
+void ConstructStorage(Allocator* alloc, StorageElement* first,
+                      StorageElement* last, const Args&... args) {
+  for (; first != last; ++first) {
+    std::allocator_traits<Allocator>::construct(*alloc, first, args...);
+  }
+}
+template <typename Allocator, typename StorageElement, typename Iterator>
+void CopyToStorageFromRange(Allocator* alloc, StorageElement* destination,
+                            Iterator first, Iterator last) {
+  for (; first != last;
+       static_cast<void>(++destination), static_cast<void>(++first)) {
+    std::allocator_traits<Allocator>::construct(*alloc, destination, *first);
   }
 }
 #endif  // ABSL_HAVE_EXCEPTIONS
 }  // namespace memory_internal
-
 }  // namespace absl
 
 #endif  // ABSL_MEMORY_MEMORY_H_
diff --git a/absl/memory/memory_exception_safety_test.cc b/absl/memory/memory_exception_safety_test.cc
index fb8b561..d1f6e84 100644
--- a/absl/memory/memory_exception_safety_test.cc
+++ b/absl/memory/memory_exception_safety_test.cc
@@ -48,16 +48,5 @@
   }));
 }
 
-TEST(MemoryInternal, UninitDefaultConstructNNonTrivial) {
-  EXPECT_TRUE(testing::MakeExceptionSafetyTester()
-                  .WithInitialValue(ThrowerList{})
-                  .WithOperation([&](ThrowerList* list_ptr) {
-                    absl::memory_internal::uninitialized_default_construct_n(
-                        list_ptr->data(), kLength);
-                  })
-                  .WithInvariants([&](...) { return true; })
-                  .Test());
-}
-
 }  // namespace
 }  // namespace absl
diff --git a/absl/memory/memory_test.cc b/absl/memory/memory_test.cc
index 8ff1945..dee9b48 100644
--- a/absl/memory/memory_test.cc
+++ b/absl/memory/memory_test.cc
@@ -611,47 +611,4 @@
   EXPECT_FALSE(absl::allocator_is_nothrow<UnspecifiedAllocator>::value);
 }
 
-TEST(MemoryInternal, UninitDefaultConstructNTrivial) {
-  constexpr int kInitialValue = 123;
-  constexpr int kExpectedValue = kInitialValue;  // Expect no-op behavior
-  constexpr int len = 5;
-
-  struct TestObj {
-    int val;
-  };
-  static_assert(absl::is_trivially_default_constructible<TestObj>::value, "");
-  static_assert(absl::is_trivially_destructible<TestObj>::value, "");
-
-  TestObj objs[len];
-  for (auto& obj : objs) {
-    obj.val = kInitialValue;
-  }
-
-  absl::memory_internal::uninitialized_default_construct_n(objs, len);
-  for (auto& obj : objs) {
-    EXPECT_EQ(obj.val, kExpectedValue);
-  }
-}
-
-TEST(MemoryInternal, UninitDefaultConstructNNonTrivial) {
-  constexpr int kInitialValue = 123;
-  constexpr int kExpectedValue = 0;  // Expect value-construction behavior
-  constexpr int len = 5;
-
-  struct TestObj {
-    int val{kExpectedValue};
-  };
-  static_assert(absl::is_trivially_destructible<TestObj>::value, "");
-
-  TestObj objs[len];
-  for (auto& obj : objs) {
-    obj.val = kInitialValue;
-  }
-
-  absl::memory_internal::uninitialized_default_construct_n(objs, len);
-  for (auto& obj : objs) {
-    EXPECT_EQ(obj.val, kExpectedValue);
-  }
-}
-
 }  // namespace
diff --git a/absl/meta/type_traits.h b/absl/meta/type_traits.h
index c3e01fe..457b890 100644
--- a/absl/meta/type_traits.h
+++ b/absl/meta/type_traits.h
@@ -44,6 +44,7 @@
 namespace absl {
 
 namespace type_traits_internal {
+
 template <typename... Ts>
 struct VoidTImpl {
   using type = void;
@@ -61,6 +62,49 @@
   static constexpr size_t value = Align;
 };
 
+////////////////////////////////
+// Library Fundamentals V2 TS //
+////////////////////////////////
+
+// NOTE: The `is_detected` family of templates here differ from the library
+// fundamentals specification in that for library fundamentals, `Op<Args...>` is
+// evaluated as soon as the type `is_detected<Op, Args...>` undergoes
+// substitution, regardless of whether or not the `::value` is accessed. That
+// is inconsistent with all other standard traits and prevents lazy evaluation
+// in larger contexts (such as if the `is_detected` check is a trailing argument
+// of a `conjunction`. This implementation opts to instead be lazy in the same
+// way that the standard traits are (this "defect" of the detection idiom
+// specifications has been reported).
+
+template <class Enabler, template <class...> class Op, class... Args>
+struct is_detected_impl {
+  using type = std::false_type;
+};
+
+template <template <class...> class Op, class... Args>
+struct is_detected_impl<typename VoidTImpl<Op<Args...>>::type, Op, Args...> {
+  using type = std::true_type;
+};
+
+template <template <class...> class Op, class... Args>
+struct is_detected : is_detected_impl<void, Op, Args...>::type {};
+
+template <class Enabler, class To, template <class...> class Op, class... Args>
+struct is_detected_convertible_impl {
+  using type = std::false_type;
+};
+
+template <class To, template <class...> class Op, class... Args>
+struct is_detected_convertible_impl<
+    typename std::enable_if<std::is_convertible<Op<Args...>, To>::value>::type,
+    To, Op, Args...> {
+  using type = std::true_type;
+};
+
+template <class To, template <class...> class Op, class... Args>
+struct is_detected_convertible
+    : is_detected_convertible_impl<void, To, Op, Args...>::type {};
+
 }  // namespace type_traits_internal
 
 // void_t()
@@ -263,8 +307,9 @@
 // `is_trivially_assignable<T&, const T&>`.
 template <typename T>
 struct is_trivially_copy_assignable
-    : std::integral_constant<bool, __has_trivial_assign(T) &&
-                                   std::is_copy_assignable<T>::value> {
+    : std::integral_constant<
+          bool, __has_trivial_assign(typename std::remove_reference<T>::type) &&
+                    std::is_copy_assignable<T>::value> {
 #ifdef ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
  private:
   static constexpr bool compliant =
diff --git a/absl/meta/type_traits_test.cc b/absl/meta/type_traits_test.cc
index c44d1c5..81b4bd3 100644
--- a/absl/meta/type_traits_test.cc
+++ b/absl/meta/type_traits_test.cc
@@ -34,6 +34,83 @@
 
 struct Dummy {};
 
+struct ReturnType {};
+struct ConvertibleToReturnType {
+  operator ReturnType() const;  // NOLINT
+};
+
+// Unique types used as parameter types for testing the detection idiom.
+struct StructA {};
+struct StructB {};
+struct StructC {};
+
+struct TypeWithBarFunction {
+  template <class T,
+            absl::enable_if_t<std::is_same<T&&, StructA&>::value, int> = 0>
+  ReturnType bar(T&&, const StructB&, StructC&&) &&;  // NOLINT
+};
+
+struct TypeWithBarFunctionAndConvertibleReturnType {
+  template <class T,
+            absl::enable_if_t<std::is_same<T&&, StructA&>::value, int> = 0>
+  ConvertibleToReturnType bar(T&&, const StructB&, StructC&&) &&;  // NOLINT
+};
+
+template <class Class, class... Ts>
+using BarIsCallableImpl =
+    decltype(std::declval<Class>().bar(std::declval<Ts>()...));
+
+template <class Class, class... T>
+using BarIsCallable =
+    absl::type_traits_internal::is_detected<BarIsCallableImpl, Class, T...>;
+
+template <class Class, class... T>
+using BarIsCallableConv = absl::type_traits_internal::is_detected_convertible<
+    ReturnType, BarIsCallableImpl, Class, T...>;
+
+// NOTE: Test of detail type_traits_internal::is_detected.
+TEST(IsDetectedTest, BasicUsage) {
+  EXPECT_TRUE((BarIsCallable<TypeWithBarFunction, StructA&, const StructB&,
+                             StructC>::value));
+  EXPECT_TRUE(
+      (BarIsCallable<TypeWithBarFunction, StructA&, StructB&, StructC>::value));
+  EXPECT_TRUE(
+      (BarIsCallable<TypeWithBarFunction, StructA&, StructB, StructC>::value));
+
+  EXPECT_FALSE((BarIsCallable<int, StructA&, const StructB&, StructC>::value));
+  EXPECT_FALSE((BarIsCallable<TypeWithBarFunction&, StructA&, const StructB&,
+                              StructC>::value));
+  EXPECT_FALSE((BarIsCallable<TypeWithBarFunction, StructA, const StructB&,
+                              StructC>::value));
+}
+
+// NOTE: Test of detail type_traits_internal::is_detected_convertible.
+TEST(IsDetectedConvertibleTest, BasicUsage) {
+  EXPECT_TRUE((BarIsCallableConv<TypeWithBarFunction, StructA&, const StructB&,
+                                 StructC>::value));
+  EXPECT_TRUE((BarIsCallableConv<TypeWithBarFunction, StructA&, StructB&,
+                                 StructC>::value));
+  EXPECT_TRUE((BarIsCallableConv<TypeWithBarFunction, StructA&, StructB,
+                                 StructC>::value));
+  EXPECT_TRUE((BarIsCallableConv<TypeWithBarFunctionAndConvertibleReturnType,
+                                 StructA&, const StructB&, StructC>::value));
+  EXPECT_TRUE((BarIsCallableConv<TypeWithBarFunctionAndConvertibleReturnType,
+                                 StructA&, StructB&, StructC>::value));
+  EXPECT_TRUE((BarIsCallableConv<TypeWithBarFunctionAndConvertibleReturnType,
+                                 StructA&, StructB, StructC>::value));
+
+  EXPECT_FALSE(
+      (BarIsCallableConv<int, StructA&, const StructB&, StructC>::value));
+  EXPECT_FALSE((BarIsCallableConv<TypeWithBarFunction&, StructA&,
+                                  const StructB&, StructC>::value));
+  EXPECT_FALSE((BarIsCallableConv<TypeWithBarFunction, StructA, const StructB&,
+                                  StructC>::value));
+  EXPECT_FALSE((BarIsCallableConv<TypeWithBarFunctionAndConvertibleReturnType&,
+                                  StructA&, const StructB&, StructC>::value));
+  EXPECT_FALSE((BarIsCallableConv<TypeWithBarFunctionAndConvertibleReturnType,
+                                  StructA, const StructB&, StructC>::value));
+}
+
 TEST(VoidTTest, BasicUsage) {
   StaticAssertTypeEq<void, absl::void_t<Dummy>>();
   StaticAssertTypeEq<void, absl::void_t<Dummy, Dummy, Dummy>>();
@@ -528,6 +605,10 @@
   // Verify that arrays are not trivially copy assignable
   using int10 = int[10];
   EXPECT_FALSE(absl::is_trivially_copy_assignable<int10>::value);
+
+  // Verify that references are handled correctly
+  EXPECT_TRUE(absl::is_trivially_copy_assignable<Trivial&&>::value);
+  EXPECT_TRUE(absl::is_trivially_copy_assignable<Trivial&>::value);
 }
 
 #define ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(trait_name, ...)          \
@@ -714,8 +795,8 @@
   ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int[][1]);
 
   ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int());
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int(float));
-  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int(char, ...));
+  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int(float));  // NOLINT
+  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int(char, ...));  // NOLINT
 }
 
 struct TypeA {};
diff --git a/absl/numeric/int128.h b/absl/numeric/int128.h
index e4f39c3..2d131b8 100644
--- a/absl/numeric/int128.h
+++ b/absl/numeric/int128.h
@@ -31,6 +31,7 @@
 #include <cstring>
 #include <iosfwd>
 #include <limits>
+#include <utility>
 
 #include "absl/base/config.h"
 #include "absl/base/macros.h"
diff --git a/absl/strings/BUILD.bazel b/absl/strings/BUILD.bazel
index 3b1e067..3a5f133 100644
--- a/absl/strings/BUILD.bazel
+++ b/absl/strings/BUILD.bazel
@@ -159,6 +159,18 @@
 )
 
 cc_test(
+    name = "ascii_benchmark",
+    srcs = ["ascii_benchmark.cc"],
+    copts = ABSL_TEST_COPTS,
+    tags = ["benchmark"],
+    visibility = ["//visibility:private"],
+    deps = [
+        ":strings",
+        "@com_github_google_benchmark//:benchmark_main",
+    ],
+)
+
+cc_test(
     name = "memutil_benchmark",
     srcs = [
         "internal/memutil.h",
diff --git a/absl/strings/ascii_benchmark.cc b/absl/strings/ascii_benchmark.cc
new file mode 100644
index 0000000..8dea4b8
--- /dev/null
+++ b/absl/strings/ascii_benchmark.cc
@@ -0,0 +1,120 @@
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/strings/ascii.h"
+
+#include <cctype>
+#include <string>
+#include <array>
+#include <random>
+
+#include "benchmark/benchmark.h"
+
+namespace {
+
+std::array<unsigned char, 256> MakeShuffledBytes() {
+  std::array<unsigned char, 256> bytes;
+  for (size_t i = 0; i < 256; ++i) bytes[i] = static_cast<unsigned char>(i);
+  std::random_device rd;
+  std::seed_seq seed({rd(), rd(), rd(), rd(), rd(), rd(), rd(), rd()});
+  std::mt19937 g(seed);
+  std::shuffle(bytes.begin(), bytes.end(), g);
+  return bytes;
+}
+
+template <typename Function>
+void AsciiBenchmark(benchmark::State& state, Function f) {
+  std::array<unsigned char, 256> bytes = MakeShuffledBytes();
+  size_t sum = 0;
+  for (auto _ : state) {
+    for (unsigned char b : bytes) sum += f(b) ? 1 : 0;
+  }
+  // Make a copy of `sum` before calling `DoNotOptimize` to make sure that `sum`
+  // can be put in a CPU register and not degrade performance in the loop above.
+  size_t sum2 = sum;
+  benchmark::DoNotOptimize(sum2);
+  state.SetBytesProcessed(state.iterations() * bytes.size());
+}
+
+using StdAsciiFunction = int (*)(int);
+template <StdAsciiFunction f>
+void BM_Ascii(benchmark::State& state) {
+  AsciiBenchmark(state, f);
+}
+
+using AbslAsciiIsFunction = bool (*)(unsigned char);
+template <AbslAsciiIsFunction f>
+void BM_Ascii(benchmark::State& state) {
+  AsciiBenchmark(state, f);
+}
+
+using AbslAsciiToFunction = char (*)(unsigned char);
+template <AbslAsciiToFunction f>
+void BM_Ascii(benchmark::State& state) {
+  AsciiBenchmark(state, f);
+}
+
+inline char Noop(unsigned char b) { return static_cast<char>(b); }
+
+BENCHMARK_TEMPLATE(BM_Ascii, Noop);
+BENCHMARK_TEMPLATE(BM_Ascii, std::isalpha);
+BENCHMARK_TEMPLATE(BM_Ascii, absl::ascii_isalpha);
+BENCHMARK_TEMPLATE(BM_Ascii, std::isdigit);
+BENCHMARK_TEMPLATE(BM_Ascii, absl::ascii_isdigit);
+BENCHMARK_TEMPLATE(BM_Ascii, std::isalnum);
+BENCHMARK_TEMPLATE(BM_Ascii, absl::ascii_isalnum);
+BENCHMARK_TEMPLATE(BM_Ascii, std::isspace);
+BENCHMARK_TEMPLATE(BM_Ascii, absl::ascii_isspace);
+BENCHMARK_TEMPLATE(BM_Ascii, std::ispunct);
+BENCHMARK_TEMPLATE(BM_Ascii, absl::ascii_ispunct);
+BENCHMARK_TEMPLATE(BM_Ascii, std::isblank);
+BENCHMARK_TEMPLATE(BM_Ascii, absl::ascii_isblank);
+BENCHMARK_TEMPLATE(BM_Ascii, std::iscntrl);
+BENCHMARK_TEMPLATE(BM_Ascii, absl::ascii_iscntrl);
+BENCHMARK_TEMPLATE(BM_Ascii, std::isxdigit);
+BENCHMARK_TEMPLATE(BM_Ascii, absl::ascii_isxdigit);
+BENCHMARK_TEMPLATE(BM_Ascii, std::isprint);
+BENCHMARK_TEMPLATE(BM_Ascii, absl::ascii_isprint);
+BENCHMARK_TEMPLATE(BM_Ascii, std::isgraph);
+BENCHMARK_TEMPLATE(BM_Ascii, absl::ascii_isgraph);
+BENCHMARK_TEMPLATE(BM_Ascii, std::isupper);
+BENCHMARK_TEMPLATE(BM_Ascii, absl::ascii_isupper);
+BENCHMARK_TEMPLATE(BM_Ascii, std::islower);
+BENCHMARK_TEMPLATE(BM_Ascii, absl::ascii_islower);
+BENCHMARK_TEMPLATE(BM_Ascii, isascii);
+BENCHMARK_TEMPLATE(BM_Ascii, absl::ascii_isascii);
+BENCHMARK_TEMPLATE(BM_Ascii, std::tolower);
+BENCHMARK_TEMPLATE(BM_Ascii, absl::ascii_tolower);
+BENCHMARK_TEMPLATE(BM_Ascii, std::toupper);
+BENCHMARK_TEMPLATE(BM_Ascii, absl::ascii_toupper);
+
+static void BM_StrToLower(benchmark::State& state) {
+  const int size = state.range(0);
+  std::string s(size, 'X');
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(absl::AsciiStrToLower(s));
+  }
+}
+BENCHMARK(BM_StrToLower)->Range(1, 1 << 20);
+
+static void BM_StrToUpper(benchmark::State& state) {
+  const int size = state.range(0);
+  std::string s(size, 'x');
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(absl::AsciiStrToUpper(s));
+  }
+}
+BENCHMARK(BM_StrToUpper)->Range(1, 1 << 20);
+
+}  // namespace
diff --git a/absl/strings/escaping.h b/absl/strings/escaping.h
index 1af0afa..7f1ab96 100644
--- a/absl/strings/escaping.h
+++ b/absl/strings/escaping.h
@@ -139,7 +139,7 @@
 
 // WebSafeBase64Escape()
 //
-// Encodes a `src` std::string into a `dest` buffer using uses '-' instead of '+' and
+// Encodes a `src` std::string into a `dest` buffer using '-' instead of '+' and
 // '_' instead of '/', and without padding. This function conforms with RFC 4648
 // section 5 (base64url).
 void WebSafeBase64Escape(absl::string_view src, std::string* dest);
diff --git a/absl/strings/internal/str_format/float_conversion.cc b/absl/strings/internal/str_format/float_conversion.cc
index 37952b4..6176db9 100644
--- a/absl/strings/internal/str_format/float_conversion.cc
+++ b/absl/strings/internal/str_format/float_conversion.cc
@@ -153,7 +153,14 @@
 
 template <typename Float, typename Int>
 constexpr bool CanFitMantissa() {
-  return std::numeric_limits<Float>::digits <= std::numeric_limits<Int>::digits;
+  return
+#if defined(__clang__) && !defined(__SSE3__)
+      // Workaround for clang bug: https://bugs.llvm.org/show_bug.cgi?id=38289
+      // Casting from long double to uint64_t is miscompiled and drops bits.
+      (!std::is_same<Float, long double>::value ||
+       !std::is_same<Int, uint64_t>::value) &&
+#endif
+      std::numeric_limits<Float>::digits <= std::numeric_limits<Int>::digits;
 }
 
 template <typename Float>
diff --git a/absl/strings/numbers_test.cc b/absl/strings/numbers_test.cc
index 24e7138..27cc047 100644
--- a/absl/strings/numbers_test.cc
+++ b/absl/strings/numbers_test.cc
@@ -56,16 +56,11 @@
 using testing::MatchesRegex;
 
 // Number of floats to test with.
-// 10,000,000 is a reasonable default for a test that only takes a few seconds.
+// 5,000,000 is a reasonable default for a test that only takes a few seconds.
 // 1,000,000,000+ triggers checking for all possible mantissa values for
 // double-precision tests. 2,000,000,000+ triggers checking for every possible
 // single-precision float.
-#ifdef _MSC_VER
-// Use a smaller number on MSVC to avoid test time out (1 min)
 const int kFloatNumCases = 5000000;
-#else
-const int kFloatNumCases = 10000000;
-#endif
 
 // This is a slow, brute-force routine to compute the exact base-10
 // representation of a double-precision floating-point number.  It
@@ -716,8 +711,9 @@
   }
 }
 
-// feenableexcept() and fedisableexcept() are missing on Mac OS X, MSVC.
-#if defined(_MSC_VER) || defined(__APPLE__)
+// feenableexcept() and fedisableexcept() are missing on Mac OS X, MSVC,
+// and WebAssembly.
+#if defined(_MSC_VER) || defined(__APPLE__) || defined(__EMSCRIPTEN__)
 #define ABSL_MISSING_FEENABLEEXCEPT 1
 #define ABSL_MISSING_FEDISABLEEXCEPT 1
 #endif
diff --git a/absl/strings/str_format_test.cc b/absl/strings/str_format_test.cc
index fe742bf..fed75fa 100644
--- a/absl/strings/str_format_test.cc
+++ b/absl/strings/str_format_test.cc
@@ -384,8 +384,8 @@
   EXPECT_EQ(StrFormat("%G", 1e10), "1E+10");
   //     a/A - lower,upper case hex    Eg: -3.0 -> "-0x1.8p+1"/"-0X1.8P+1"
 
-// On NDK r16, there is a regression in hexfloat formatting.
-#if !defined(__NDK_MAJOR__) || __NDK_MAJOR__ != 16
+// On Android platform <=21, there is a regression in hexfloat formatting.
+#if !defined(__ANDROID_API__) || __ANDROID_API__ > 21
   EXPECT_EQ(StrFormat("%.1a", -3.0), "-0x1.8p+1");  // .1 to fix MSVC output
   EXPECT_EQ(StrFormat("%.1A", -3.0), "-0X1.8P+1");  // .1 to fix MSVC output
 #endif
diff --git a/absl/strings/str_split.h b/absl/strings/str_split.h
index 1f089b9..9a7be2b 100644
--- a/absl/strings/str_split.h
+++ b/absl/strings/str_split.h
@@ -373,11 +373,11 @@
 
 // StrSplit()
 //
-// Splits a given `std::string` based on the provided `Delimiter` object,
-// returning the elements within the type specified by the caller. Optionally,
-// you may also pass a `Predicate` to `StrSplit()` indicating whether to include
-// or exclude the resulting element within the final result set. (See the
-// overviews for Delimiters and Predicates above.)
+// Splits a given std::string based on the provided `Delimiter` object, returning the
+// elements within the type specified by the caller. Optionally, you may pass a
+// `Predicate` to `StrSplit()` indicating whether to include or exclude the
+// resulting element within the final result set. (See the overviews for
+// Delimiters and Predicates above.)
 //
 // Example:
 //
diff --git a/absl/synchronization/CMakeLists.txt b/absl/synchronization/CMakeLists.txt
index c19f572..de0d7b7 100644
--- a/absl/synchronization/CMakeLists.txt
+++ b/absl/synchronization/CMakeLists.txt
@@ -34,7 +34,7 @@
 
 
 # synchronization library
-list(APPEND SYNCHRONIZATION_SRC 
+list(APPEND SYNCHRONIZATION_SRC
   "barrier.cc"
   "blocking_counter.cc"
   "internal/create_thread_identity.cc"
diff --git a/absl/synchronization/internal/kernel_timeout.h b/absl/synchronization/internal/kernel_timeout.h
index 0d132d9..bb70800 100644
--- a/absl/synchronization/internal/kernel_timeout.h
+++ b/absl/synchronization/internal/kernel_timeout.h
@@ -25,9 +25,6 @@
 #ifndef ABSL_SYNCHRONIZATION_INTERNAL_KERNEL_TIMEOUT_H_
 #define ABSL_SYNCHRONIZATION_INTERNAL_KERNEL_TIMEOUT_H_
 
-#ifdef _WIN32
-#include <intsafe.h>
-#endif
 #include <time.h>
 #include <algorithm>
 #include <limits>
@@ -117,9 +114,14 @@
   // Windows. Callers should recognize that the return value is a
   // relative duration (it should be recomputed by calling this method
   // in the case of a spurious wakeup).
-  DWORD InMillisecondsFromNow() const {
+  // This header file may be included transitively by public header files,
+  // so we define our own DWORD and INFINITE instead of getting them from
+  // <intsafe.h> and <WinBase.h>.
+  typedef unsigned long DWord;  // NOLINT
+  DWord InMillisecondsFromNow() const {
+    constexpr DWord kInfinite = std::numeric_limits<DWord>::max();
     if (!has_timeout()) {
-      return INFINITE;
+      return kInfinite;
     }
     // The use of absl::Now() to convert from absolute time to
     // relative time means that absl::Now() cannot use anything that
@@ -131,10 +133,10 @@
           std::numeric_limits<int64_t>::max() - 999999u;
       uint64_t ms_from_now =
           (std::min<uint64_t>(max_nanos, ns_ - now) + 999999u) / 1000000u;
-      if (ms_from_now > std::numeric_limits<DWORD>::max()) {
-        return INFINITE;
+      if (ms_from_now > kInfinite) {
+        return kInfinite;
       }
-      return static_cast<DWORD>(ms_from_now);
+      return static_cast<DWord>(ms_from_now);
     }
     return 0;
   }
diff --git a/absl/synchronization/mutex.h b/absl/synchronization/mutex.h
index 840b9d6..83c2148 100644
--- a/absl/synchronization/mutex.h
+++ b/absl/synchronization/mutex.h
@@ -24,7 +24,7 @@
 // Unlike a `std::mutex`, the Abseil `Mutex` provides the following additional
 // features:
 //   * Conditional predicates intrinsic to the `Mutex` object
-//   * Reader/writer locks, in addition to standard exclusive/writer locks
+//   * Shared/reader locks, in addition to standard exclusive/writer locks
 //   * Deadlock detection and debug support.
 //
 // The following helper classes are also defined within this file:
@@ -290,7 +290,7 @@
   // Mutex::ReaderLockWhen()
   // Mutex::WriterLockWhen()
   //
-  // Blocks until simultaneously both `cond` is `true` and this` Mutex` can
+  // Blocks until simultaneously both `cond` is `true` and this `Mutex` can
   // be acquired, then atomically acquires this `Mutex`. `LockWhen()` is
   // logically equivalent to `*Lock(); Await();` though they may have different
   // performance characteristics.
@@ -558,7 +558,7 @@
 // WriterMutexLock
 //
 // The `WriterMutexLock` is a helper class, like `MutexLock`, which acquires and
-// releases a write (exclusive) lock on a `Mutex` va RAII.
+// releases a write (exclusive) lock on a `Mutex` via RAII.
 class SCOPED_LOCKABLE WriterMutexLock {
  public:
   explicit WriterMutexLock(Mutex *mu) EXCLUSIVE_LOCK_FUNCTION(mu)
diff --git a/absl/synchronization/mutex_benchmark.cc b/absl/synchronization/mutex_benchmark.cc
index 30a5235..1e019e0 100644
--- a/absl/synchronization/mutex_benchmark.cc
+++ b/absl/synchronization/mutex_benchmark.cc
@@ -74,11 +74,11 @@
   mu.Unlock();
 }
 
-#ifdef THREAD_SANITIZER
-// ThreadSanitizer can't handle 8192 threads.
-constexpr int kMaxConditionWaiters = 2048;
-#else
+// Some configurations have higher thread limits than others.
+#if defined(__linux__) && !defined(THREAD_SANITIZER)
 constexpr int kMaxConditionWaiters = 8192;
+#else
+constexpr int kMaxConditionWaiters = 1024;
 #endif
 BENCHMARK(BM_ConditionWaiters)->RangePair(0, 2, 1, kMaxConditionWaiters);
 
diff --git a/absl/synchronization/mutex_test.cc b/absl/synchronization/mutex_test.cc
index 53b9378..b2820e2 100644
--- a/absl/synchronization/mutex_test.cc
+++ b/absl/synchronization/mutex_test.cc
@@ -29,6 +29,7 @@
 #include <vector>
 
 #include "gtest/gtest.h"
+#include "absl/base/attributes.h"
 #include "absl/base/internal/raw_logging.h"
 #include "absl/base/internal/sysinfo.h"
 #include "absl/memory/memory.h"
@@ -54,8 +55,8 @@
 // Hack to schedule a function to run on a thread pool thread after a
 // duration has elapsed.
 static void ScheduleAfter(absl::synchronization_internal::ThreadPool *tp,
-                          const std::function<void()> &func,
-                          absl::Duration after) {
+                          absl::Duration after,
+                          const std::function<void()> &func) {
   tp->Schedule([func, after] {
     absl::SleepFor(after);
     func();
@@ -1150,249 +1151,369 @@
 // and so never expires/passes, and one that will expire/pass in the near
 // future.
 
-// Encapsulate a Mutex-protected bool with its associated Condition/CondVar.
-class Cond {
- public:
-  explicit Cond(bool use_deadline) : use_deadline_(use_deadline), c_(&b_) {}
+static absl::Duration TimeoutTestAllowedSchedulingDelay() {
+  // Note: we use a function here because Microsoft Visual Studio fails to
+  // properly initialize constexpr static absl::Duration variables.
+  return absl::Milliseconds(150);
+}
 
-  void Set(bool v) {
-    absl::MutexLock lock(&mu_);
-    b_ = v;
+// Returns true if `actual_delay` is close enough to `expected_delay` to pass
+// the timeouts/deadlines test.  Otherwise, logs warnings and returns false.
+ABSL_MUST_USE_RESULT
+static bool DelayIsWithinBounds(absl::Duration expected_delay,
+                                absl::Duration actual_delay) {
+  bool pass = true;
+  // Do not allow the observed delay to be less than expected.  This may occur
+  // in practice due to clock skew or when the synchronization primitives use a
+  // different clock than absl::Now(), but these cases should be handled by the
+  // the retry mechanism in each TimeoutTest.
+  if (actual_delay < expected_delay) {
+    ABSL_RAW_LOG(WARNING,
+                 "Actual delay %s was too short, expected %s (difference %s)",
+                 absl::FormatDuration(actual_delay).c_str(),
+                 absl::FormatDuration(expected_delay).c_str(),
+                 absl::FormatDuration(actual_delay - expected_delay).c_str());
+    pass = false;
   }
-
-  bool AwaitWithTimeout(absl::Duration timeout) {
-    absl::MutexLock lock(&mu_);
-    return use_deadline_ ? mu_.AwaitWithDeadline(c_, absl::Now() + timeout)
-                         : mu_.AwaitWithTimeout(c_, timeout);
+  // If the expected delay is <= zero then allow a small error tolerance, since
+  // we do not expect context switches to occur during test execution.
+  // Otherwise, thread scheduling delays may be substantial in rare cases, so
+  // tolerate up to kTimeoutTestAllowedSchedulingDelay of error.
+  absl::Duration tolerance = expected_delay <= absl::ZeroDuration()
+                                 ? absl::Milliseconds(10)
+                                 : TimeoutTestAllowedSchedulingDelay();
+  if (actual_delay > expected_delay + tolerance) {
+    ABSL_RAW_LOG(WARNING,
+                 "Actual delay %s was too long, expected %s (difference %s)",
+                 absl::FormatDuration(actual_delay).c_str(),
+                 absl::FormatDuration(expected_delay).c_str(),
+                 absl::FormatDuration(actual_delay - expected_delay).c_str());
+    pass = false;
   }
+  return pass;
+}
 
-  bool LockWhenWithTimeout(absl::Duration timeout) {
-    bool b = use_deadline_ ? mu_.LockWhenWithDeadline(c_, absl::Now() + timeout)
-                           : mu_.LockWhenWithTimeout(c_, timeout);
-    mu_.Unlock();
-    return b;
-  }
+// Parameters for TimeoutTest, below.
+struct TimeoutTestParam {
+  // The file and line number (used for logging purposes only).
+  const char *from_file;
+  int from_line;
 
-  bool ReaderLockWhenWithTimeout(absl::Duration timeout) {
-    bool b = use_deadline_
-                 ? mu_.ReaderLockWhenWithDeadline(c_, absl::Now() + timeout)
-                 : mu_.ReaderLockWhenWithTimeout(c_, timeout);
-    mu_.ReaderUnlock();
-    return b;
-  }
+  // Should the absolute deadline API based on absl::Time be tested?  If false,
+  // the relative deadline API based on absl::Duration is tested.
+  bool use_absolute_deadline;
 
-  void Await() {
-    absl::MutexLock lock(&mu_);
-    mu_.Await(c_);
-  }
+  // The deadline/timeout used when calling the API being tested
+  // (e.g. Mutex::LockWhenWithDeadline).
+  absl::Duration wait_timeout;
 
-  void Signal(bool v) {
-    absl::MutexLock lock(&mu_);
-    b_ = v;
-    cv_.Signal();
-  }
+  // The delay before the condition will be set true by the test code.  If zero
+  // or negative, the condition is set true immediately (before calling the API
+  // being tested).  Otherwise, if infinite, the condition is never set true.
+  // Otherwise a closure is scheduled for the future that sets the condition
+  // true.
+  absl::Duration satisfy_condition_delay;
 
-  bool WaitWithTimeout(absl::Duration timeout) {
-    absl::MutexLock lock(&mu_);
-    absl::Time deadline = absl::Now() + timeout;
-    if (use_deadline_) {
-      while (!b_ && !cv_.WaitWithDeadline(&mu_, deadline)) {
-      }
-    } else {
-      while (!b_ && !cv_.WaitWithTimeout(&mu_, timeout)) {
-        timeout = deadline - absl::Now();  // recompute timeout
-      }
-    }
-    return b_;
-  }
+  // The expected result of the condition after the call to the API being
+  // tested. Generally `true` means the condition was true when the API returns,
+  // `false` indicates an expected timeout.
+  bool expected_result;
 
-  void Wait() {
-    absl::MutexLock lock(&mu_);
-    while (!b_) cv_.Wait(&mu_);
-  }
-
- private:
-  const bool use_deadline_;
-
-  bool b_;
-  absl::Condition c_;
-  absl::CondVar cv_;
-  absl::Mutex mu_;
+  // The expected delay before the API under test returns.  This is inherently
+  // flaky, so some slop is allowed (see `DelayIsWithinBounds` above), and the
+  // test keeps trying indefinitely until this constraint passes.
+  absl::Duration expected_delay;
 };
 
-class OperationTimer {
- public:
-  OperationTimer() : start_(absl::Now()) {}
-  absl::Duration Get() const { return absl::Now() - start_; }
+// Print a `TimeoutTestParam` to a debug log.
+std::ostream &operator<<(std::ostream &os, const TimeoutTestParam &param) {
+  return os << "from: " << param.from_file << ":" << param.from_line
+            << " use_absolute_deadline: "
+            << (param.use_absolute_deadline ? "true" : "false")
+            << " wait_timeout: " << param.wait_timeout
+            << " satisfy_condition_delay: " << param.satisfy_condition_delay
+            << " expected_result: "
+            << (param.expected_result ? "true" : "false")
+            << " expected_delay: " << param.expected_delay;
+}
 
- private:
-  const absl::Time start_;
-};
+std::string FormatString(const TimeoutTestParam &param) {
+  std::ostringstream os;
+  os << param;
+  return os.str();
+}
 
-static void CheckResults(bool exp_result, bool act_result,
-                         absl::Duration exp_duration,
-                         absl::Duration act_duration) {
-  ABSL_RAW_CHECK(exp_result == act_result, "CheckResults failed");
-  // Allow for some worse-case scheduling delay and clock skew.
-  if ((exp_duration - absl::Milliseconds(40) > act_duration) ||
-      (exp_duration + absl::Milliseconds(150) < act_duration)) {
-    ABSL_RAW_LOG(FATAL, "CheckResults failed: operation took %s, expected %s",
-                 absl::FormatDuration(act_duration).c_str(),
-                 absl::FormatDuration(exp_duration).c_str());
+// Like `thread::Executor::ScheduleAt` except:
+// a) Delays zero or negative are executed immediately in the current thread.
+// b) Infinite delays are never scheduled.
+// c) Calls this test's `ScheduleAt` helper instead of using `pool` directly.
+static void RunAfterDelay(absl::Duration delay,
+                          absl::synchronization_internal::ThreadPool *pool,
+                          const std::function<void()> &callback) {
+  if (delay <= absl::ZeroDuration()) {
+    callback();  // immediate
+  } else if (delay != absl::InfiniteDuration()) {
+    ScheduleAfter(pool, delay, callback);
   }
 }
 
-static void TestAwaitTimeout(Cond *cp, absl::Duration timeout, bool exp_result,
-                             absl::Duration exp_duration) {
-  OperationTimer t;
-  bool act_result = cp->AwaitWithTimeout(timeout);
-  CheckResults(exp_result, act_result, exp_duration, t.Get());
-}
+class TimeoutTest : public ::testing::Test,
+                    public ::testing::WithParamInterface<TimeoutTestParam> {};
 
-static void TestLockWhenTimeout(Cond *cp, absl::Duration timeout,
-                                bool exp_result, absl::Duration exp_duration) {
-  OperationTimer t;
-  bool act_result = cp->LockWhenWithTimeout(timeout);
-  CheckResults(exp_result, act_result, exp_duration, t.Get());
-}
-
-static void TestReaderLockWhenTimeout(Cond *cp, absl::Duration timeout,
-                                      bool exp_result,
-                                      absl::Duration exp_duration) {
-  OperationTimer t;
-  bool act_result = cp->ReaderLockWhenWithTimeout(timeout);
-  CheckResults(exp_result, act_result, exp_duration, t.Get());
-}
-
-static void TestWaitTimeout(Cond *cp, absl::Duration timeout, bool exp_result,
-                            absl::Duration exp_duration) {
-  OperationTimer t;
-  bool act_result = cp->WaitWithTimeout(timeout);
-  CheckResults(exp_result, act_result, exp_duration, t.Get());
-}
-
-// Tests with a negative timeout (deadline in the past), which should
-// immediately return the current state of the condition.
-static void TestNegativeTimeouts(absl::synchronization_internal::ThreadPool *tp,
-                                 Cond *cp) {
+std::vector<TimeoutTestParam> MakeTimeoutTestParamValues() {
+  // The `finite` delay is a finite, relatively short, delay.  We make it larger
+  // than our allowed scheduling delay (slop factor) to avoid confusion when
+  // diagnosing test failures.  The other constants here have clear meanings.
+  const absl::Duration finite = 3 * TimeoutTestAllowedSchedulingDelay();
+  const absl::Duration never = absl::InfiniteDuration();
   const absl::Duration negative = -absl::InfiniteDuration();
   const absl::Duration immediate = absl::ZeroDuration();
 
-  // The condition is already true:
-  cp->Set(true);
-  TestAwaitTimeout(cp, negative, true, immediate);
-  TestLockWhenTimeout(cp, negative, true, immediate);
-  TestReaderLockWhenTimeout(cp, negative, true, immediate);
-  TestWaitTimeout(cp, negative, true, immediate);
+  // Every test case is run twice; once using the absolute deadline API and once
+  // using the relative timeout API.
+  std::vector<TimeoutTestParam> values;
+  for (bool use_absolute_deadline : {false, true}) {
+    // Tests with a negative timeout (deadline in the past), which should
+    // immediately return current state of the condition.
 
-  // The condition becomes true, but the timeout has already expired:
-  const absl::Duration delay = absl::Milliseconds(200);
-  cp->Set(false);
-  ScheduleAfter(tp, std::bind(&Cond::Set, cp, true), 3 * delay);
-  TestAwaitTimeout(cp, negative, false, immediate);
-  TestLockWhenTimeout(cp, negative, false, immediate);
-  TestReaderLockWhenTimeout(cp, negative, false, immediate);
-  cp->Await();  // wait for the scheduled Set() to complete
-  cp->Set(false);
-  ScheduleAfter(tp, std::bind(&Cond::Signal, cp, true), delay);
-  TestWaitTimeout(cp, negative, false, immediate);
-  cp->Wait();  // wait for the scheduled Signal() to complete
+    // The condition is already true:
+    values.push_back(TimeoutTestParam{
+        __FILE__, __LINE__, use_absolute_deadline,
+        negative,   // wait_timeout
+        immediate,  // satisfy_condition_delay
+        true,       // expected_result
+        immediate,  // expected_delay
+    });
 
-  // The condition never becomes true:
-  cp->Set(false);
-  TestAwaitTimeout(cp, negative, false, immediate);
-  TestLockWhenTimeout(cp, negative, false, immediate);
-  TestReaderLockWhenTimeout(cp, negative, false, immediate);
-  TestWaitTimeout(cp, negative, false, immediate);
+    // The condition becomes true, but the timeout has already expired:
+    values.push_back(TimeoutTestParam{
+        __FILE__, __LINE__, use_absolute_deadline,
+        negative,  // wait_timeout
+        finite,    // satisfy_condition_delay
+        false,     // expected_result
+        immediate  // expected_delay
+    });
+
+    // The condition never becomes true:
+    values.push_back(TimeoutTestParam{
+        __FILE__, __LINE__, use_absolute_deadline,
+        negative,  // wait_timeout
+        never,     // satisfy_condition_delay
+        false,     // expected_result
+        immediate  // expected_delay
+    });
+
+    // Tests with an infinite timeout (deadline in the infinite future), which
+    // should only return when the condition becomes true.
+
+    // The condition is already true:
+    values.push_back(TimeoutTestParam{
+        __FILE__, __LINE__, use_absolute_deadline,
+        never,      // wait_timeout
+        immediate,  // satisfy_condition_delay
+        true,       // expected_result
+        immediate   // expected_delay
+    });
+
+    // The condition becomes true before the (infinite) expiry:
+    values.push_back(TimeoutTestParam{
+        __FILE__, __LINE__, use_absolute_deadline,
+        never,   // wait_timeout
+        finite,  // satisfy_condition_delay
+        true,    // expected_result
+        finite,  // expected_delay
+    });
+
+    // Tests with a (small) finite timeout (deadline soon), with the condition
+    // becoming true both before and after its expiry.
+
+    // The condition is already true:
+    values.push_back(TimeoutTestParam{
+        __FILE__, __LINE__, use_absolute_deadline,
+        never,      // wait_timeout
+        immediate,  // satisfy_condition_delay
+        true,       // expected_result
+        immediate   // expected_delay
+    });
+
+    // The condition becomes true before the expiry:
+    values.push_back(TimeoutTestParam{
+        __FILE__, __LINE__, use_absolute_deadline,
+        finite * 2,  // wait_timeout
+        finite,      // satisfy_condition_delay
+        true,        // expected_result
+        finite       // expected_delay
+    });
+
+    // The condition becomes true, but the timeout has already expired:
+    values.push_back(TimeoutTestParam{
+        __FILE__, __LINE__, use_absolute_deadline,
+        finite,      // wait_timeout
+        finite * 2,  // satisfy_condition_delay
+        false,       // expected_result
+        finite       // expected_delay
+    });
+
+    // The condition never becomes true:
+    values.push_back(TimeoutTestParam{
+        __FILE__, __LINE__, use_absolute_deadline,
+        finite,  // wait_timeout
+        never,   // satisfy_condition_delay
+        false,   // expected_result
+        finite   // expected_delay
+    });
+  }
+  return values;
 }
 
-// Tests with an infinite timeout (deadline in the infinite future), which
-// should only return when the condition becomes true.
-static void TestInfiniteTimeouts(absl::synchronization_internal::ThreadPool *tp,
-                                 Cond *cp) {
-  const absl::Duration infinite = absl::InfiniteDuration();
-  const absl::Duration immediate = absl::ZeroDuration();
+// Instantiate `TimeoutTest` with `MakeTimeoutTestParamValues()`.
+INSTANTIATE_TEST_CASE_P(All, TimeoutTest,
+                        testing::ValuesIn(MakeTimeoutTestParamValues()));
 
-  // The condition is already true:
-  cp->Set(true);
-  TestAwaitTimeout(cp, infinite, true, immediate);
-  TestLockWhenTimeout(cp, infinite, true, immediate);
-  TestReaderLockWhenTimeout(cp, infinite, true, immediate);
-  TestWaitTimeout(cp, infinite, true, immediate);
+TEST_P(TimeoutTest, Await) {
+  const TimeoutTestParam params = GetParam();
+  ABSL_RAW_LOG(INFO, "Params: %s", FormatString(params).c_str());
 
-  // The condition becomes true before the (infinite) expiry:
-  const absl::Duration delay = absl::Milliseconds(200);
-  cp->Set(false);
-  ScheduleAfter(tp, std::bind(&Cond::Set, cp, true), delay);
-  TestAwaitTimeout(cp, infinite, true, delay);
-  cp->Set(false);
-  ScheduleAfter(tp, std::bind(&Cond::Set, cp, true), delay);
-  TestLockWhenTimeout(cp, infinite, true, delay);
-  cp->Set(false);
-  ScheduleAfter(tp, std::bind(&Cond::Set, cp, true), delay);
-  TestReaderLockWhenTimeout(cp, infinite, true, delay);
-  cp->Set(false);
-  ScheduleAfter(tp, std::bind(&Cond::Signal, cp, true), delay);
-  TestWaitTimeout(cp, infinite, true, delay);
+  // Because this test asserts bounds on scheduling delays it is flaky.  To
+  // compensate it loops forever until it passes.  Failures express as test
+  // timeouts, in which case the test log can be used to diagnose the issue.
+  for (int attempt = 1;; ++attempt) {
+    ABSL_RAW_LOG(INFO, "Attempt %d", attempt);
+
+    absl::Mutex mu;
+    bool value = false;  // condition value (under mu)
+
+    std::unique_ptr<absl::synchronization_internal::ThreadPool> pool =
+        CreateDefaultPool();
+    RunAfterDelay(params.satisfy_condition_delay, pool.get(), [&] {
+      absl::MutexLock l(&mu);
+      value = true;
+    });
+
+    absl::MutexLock lock(&mu);
+    absl::Time start_time = absl::Now();
+    absl::Condition cond(&value);
+    bool result =
+        params.use_absolute_deadline
+            ? mu.AwaitWithDeadline(cond, start_time + params.wait_timeout)
+            : mu.AwaitWithTimeout(cond, params.wait_timeout);
+    if (DelayIsWithinBounds(params.expected_delay, absl::Now() - start_time)) {
+      EXPECT_EQ(params.expected_result, result);
+      break;
+    }
+  }
 }
 
-// Tests with a (small) finite timeout (deadline soon), with the condition
-// becoming true both before and after its expiry.
-static void TestFiniteTimeouts(absl::synchronization_internal::ThreadPool *tp,
-                               Cond *cp) {
-  const absl::Duration finite = absl::Milliseconds(400);
-  const absl::Duration immediate = absl::ZeroDuration();
+TEST_P(TimeoutTest, LockWhen) {
+  const TimeoutTestParam params = GetParam();
+  ABSL_RAW_LOG(INFO, "Params: %s", FormatString(params).c_str());
 
-  // The condition is already true:
-  cp->Set(true);
-  TestAwaitTimeout(cp, finite, true, immediate);
-  TestLockWhenTimeout(cp, finite, true, immediate);
-  TestReaderLockWhenTimeout(cp, finite, true, immediate);
-  TestWaitTimeout(cp, finite, true, immediate);
+  // Because this test asserts bounds on scheduling delays it is flaky.  To
+  // compensate it loops forever until it passes.  Failures express as test
+  // timeouts, in which case the test log can be used to diagnose the issue.
+  for (int attempt = 1;; ++attempt) {
+    ABSL_RAW_LOG(INFO, "Attempt %d", attempt);
 
-  // The condition becomes true before the expiry:
-  const absl::Duration delay1 = finite / 2;
-  cp->Set(false);
-  ScheduleAfter(tp, std::bind(&Cond::Set, cp, true), delay1);
-  TestAwaitTimeout(cp, finite, true, delay1);
-  cp->Set(false);
-  ScheduleAfter(tp, std::bind(&Cond::Set, cp, true), delay1);
-  TestLockWhenTimeout(cp, finite, true, delay1);
-  cp->Set(false);
-  ScheduleAfter(tp, std::bind(&Cond::Set, cp, true), delay1);
-  TestReaderLockWhenTimeout(cp, finite, true, delay1);
-  cp->Set(false);
-  ScheduleAfter(tp, std::bind(&Cond::Signal, cp, true), delay1);
-  TestWaitTimeout(cp, finite, true, delay1);
+    absl::Mutex mu;
+    bool value = false;  // condition value (under mu)
 
-  // The condition becomes true, but the timeout has already expired:
-  const absl::Duration delay2 = finite * 2;
-  cp->Set(false);
-  ScheduleAfter(tp, std::bind(&Cond::Set, cp, true), 3 * delay2);
-  TestAwaitTimeout(cp, finite, false, finite);
-  TestLockWhenTimeout(cp, finite, false, finite);
-  TestReaderLockWhenTimeout(cp, finite, false, finite);
-  cp->Await();  // wait for the scheduled Set() to complete
-  cp->Set(false);
-  ScheduleAfter(tp, std::bind(&Cond::Signal, cp, true), delay2);
-  TestWaitTimeout(cp, finite, false, finite);
-  cp->Wait();  // wait for the scheduled Signal() to complete
+    std::unique_ptr<absl::synchronization_internal::ThreadPool> pool =
+        CreateDefaultPool();
+    RunAfterDelay(params.satisfy_condition_delay, pool.get(), [&] {
+      absl::MutexLock l(&mu);
+      value = true;
+    });
 
-  // The condition never becomes true:
-  cp->Set(false);
-  TestAwaitTimeout(cp, finite, false, finite);
-  TestLockWhenTimeout(cp, finite, false, finite);
-  TestReaderLockWhenTimeout(cp, finite, false, finite);
-  TestWaitTimeout(cp, finite, false, finite);
+    absl::Time start_time = absl::Now();
+    absl::Condition cond(&value);
+    bool result =
+        params.use_absolute_deadline
+            ? mu.LockWhenWithDeadline(cond, start_time + params.wait_timeout)
+            : mu.LockWhenWithTimeout(cond, params.wait_timeout);
+    mu.Unlock();
+
+    if (DelayIsWithinBounds(params.expected_delay, absl::Now() - start_time)) {
+      EXPECT_EQ(params.expected_result, result);
+      break;
+    }
+  }
 }
 
-TEST(Mutex, Timeouts) {
-  auto tp = CreateDefaultPool();
-  for (bool use_deadline : {false, true}) {
-    Cond cond(use_deadline);
-    TestNegativeTimeouts(tp.get(), &cond);
-    TestInfiniteTimeouts(tp.get(), &cond);
-    TestFiniteTimeouts(tp.get(), &cond);
+TEST_P(TimeoutTest, ReaderLockWhen) {
+  const TimeoutTestParam params = GetParam();
+  ABSL_RAW_LOG(INFO, "Params: %s", FormatString(params).c_str());
+
+  // Because this test asserts bounds on scheduling delays it is flaky.  To
+  // compensate it loops forever until it passes.  Failures express as test
+  // timeouts, in which case the test log can be used to diagnose the issue.
+  for (int attempt = 0;; ++attempt) {
+    ABSL_RAW_LOG(INFO, "Attempt %d", attempt);
+
+    absl::Mutex mu;
+    bool value = false;  // condition value (under mu)
+
+    std::unique_ptr<absl::synchronization_internal::ThreadPool> pool =
+        CreateDefaultPool();
+    RunAfterDelay(params.satisfy_condition_delay, pool.get(), [&] {
+      absl::MutexLock l(&mu);
+      value = true;
+    });
+
+    absl::Time start_time = absl::Now();
+    bool result =
+        params.use_absolute_deadline
+            ? mu.ReaderLockWhenWithDeadline(absl::Condition(&value),
+                                            start_time + params.wait_timeout)
+            : mu.ReaderLockWhenWithTimeout(absl::Condition(&value),
+                                           params.wait_timeout);
+    mu.ReaderUnlock();
+
+    if (DelayIsWithinBounds(params.expected_delay, absl::Now() - start_time)) {
+      EXPECT_EQ(params.expected_result, result);
+      break;
+    }
+  }
+}
+
+TEST_P(TimeoutTest, Wait) {
+  const TimeoutTestParam params = GetParam();
+  ABSL_RAW_LOG(INFO, "Params: %s", FormatString(params).c_str());
+
+  // Because this test asserts bounds on scheduling delays it is flaky.  To
+  // compensate it loops forever until it passes.  Failures express as test
+  // timeouts, in which case the test log can be used to diagnose the issue.
+  for (int attempt = 0;; ++attempt) {
+    ABSL_RAW_LOG(INFO, "Attempt %d", attempt);
+
+    absl::Mutex mu;
+    bool value = false;  // condition value (under mu)
+    absl::CondVar cv;    // signals a change of `value`
+
+    std::unique_ptr<absl::synchronization_internal::ThreadPool> pool =
+        CreateDefaultPool();
+    RunAfterDelay(params.satisfy_condition_delay, pool.get(), [&] {
+      absl::MutexLock l(&mu);
+      value = true;
+      cv.Signal();
+    });
+
+    absl::MutexLock lock(&mu);
+    absl::Time start_time = absl::Now();
+    absl::Duration timeout = params.wait_timeout;
+    absl::Time deadline = start_time + timeout;
+    while (!value) {
+      if (params.use_absolute_deadline ? cv.WaitWithDeadline(&mu, deadline)
+                                       : cv.WaitWithTimeout(&mu, timeout)) {
+        break;  // deadline/timeout exceeded
+      }
+      timeout = deadline - absl::Now();  // recompute
+    }
+    bool result = value;  // note: `mu` is still held
+
+    if (DelayIsWithinBounds(params.expected_delay, absl::Now() - start_time)) {
+      EXPECT_EQ(params.expected_result, result);
+      break;
+    }
   }
 }
 
diff --git a/absl/time/BUILD.bazel b/absl/time/BUILD.bazel
index e793da8..c7c16d4 100644
--- a/absl/time/BUILD.bazel
+++ b/absl/time/BUILD.bazel
@@ -30,9 +30,8 @@
         "clock.cc",
         "duration.cc",
         "format.cc",
-        "internal/get_current_time_ios.inc",
+        "internal/get_current_time_chrono.inc",
         "internal/get_current_time_posix.inc",
-        "internal/get_current_time_windows.inc",
         "time.cc",
     ],
     hdrs = [
diff --git a/absl/time/BUILD.gn b/absl/time/BUILD.gn
index 24de31c..9927af8 100644
--- a/absl/time/BUILD.gn
+++ b/absl/time/BUILD.gn
@@ -14,30 +14,19 @@
   visibility = [ "*" ]
 }
 
-config("suppress_unguarded_availability") {
-  # TODO(bugs.webrtc.org/9557): Remove -Wno-unguarded-availability when
-  # abseil will support Xcode 9.0+ (it currently supports Xcode 7.3.1+
-  # which doesn't have -Wunguarded-availability and __builtin_available).
-  cflags = [
-    "-Wno-unguarded-availability",
-  ]
-}
-
 source_set("time") {
   configs -= [ "//build/config/compiler:chromium_code" ]
   configs += [
     "//build/config/compiler:no_chromium_code",
     "//third_party/abseil-cpp:absl_default_cflags_cc",
-    ":suppress_unguarded_availability",
   ]
   public_configs = [ "//third_party/abseil-cpp:absl_include_config" ]
   sources = [
     "clock.cc",
     "duration.cc",
     "format.cc",
-    "internal/get_current_time_ios.inc",
+    "internal/get_current_time_chrono.inc",
     "internal/get_current_time_posix.inc",
-    "internal/get_current_time_windows.inc",
     "time.cc",
   ]
   public = [
diff --git a/absl/time/clock.cc b/absl/time/clock.cc
index 772f852..74ee140 100644
--- a/absl/time/clock.cc
+++ b/absl/time/clock.cc
@@ -57,10 +57,8 @@
 #endif
 #endif
 
-#if defined(__APPLE__)
-#include "absl/time/internal/get_current_time_ios.inc"
-#elif defined(_WIN32)
-#include "absl/time/internal/get_current_time_windows.inc"
+#if defined(__APPLE__) || defined(_WIN32)
+#include "absl/time/internal/get_current_time_chrono.inc"
 #else
 #include "absl/time/internal/get_current_time_posix.inc"
 #endif
diff --git a/absl/time/clock_test.cc b/absl/time/clock_test.cc
index f143c03..707166d 100644
--- a/absl/time/clock_test.cc
+++ b/absl/time/clock_test.cc
@@ -35,36 +35,84 @@
   EXPECT_GE(after, now);
 }
 
-TEST(SleepForTest, BasicSanity) {
-  absl::Duration sleep_time = absl::Milliseconds(2500);
-  absl::Time start = absl::Now();
-  absl::SleepFor(sleep_time);
-  absl::Time end = absl::Now();
-  EXPECT_LE(sleep_time - absl::Milliseconds(100), end - start);
-  EXPECT_GE(sleep_time + absl::Milliseconds(200), end - start);
-}
+enum class AlarmPolicy { kWithoutAlarm, kWithAlarm };
 
-#ifdef ABSL_HAVE_ALARM
-// Helper for test SleepFor.
+#if defined(ABSL_HAVE_ALARM)
 bool alarm_handler_invoked = false;
+
 void AlarmHandler(int signo) {
   ASSERT_EQ(signo, SIGALRM);
   alarm_handler_invoked = true;
 }
+#endif
 
-TEST(SleepForTest, AlarmSupport) {
-  alarm_handler_invoked = false;
-  sig_t old_alarm = signal(SIGALRM, AlarmHandler);
-  alarm(2);
-  absl::Duration sleep_time = absl::Milliseconds(3500);
-  absl::Time start = absl::Now();
-  absl::SleepFor(sleep_time);
-  absl::Time end = absl::Now();
-  EXPECT_TRUE(alarm_handler_invoked);
-  EXPECT_LE(sleep_time - absl::Milliseconds(100), end - start);
-  EXPECT_GE(sleep_time + absl::Milliseconds(200), end - start);
-  signal(SIGALRM, old_alarm);
+// Does SleepFor(d) take between lower_bound and upper_bound at least
+// once between now and (now + timeout)?  If requested (and supported),
+// add an alarm for the middle of the sleep period and expect it to fire.
+bool SleepForBounded(absl::Duration d, absl::Duration lower_bound,
+                     absl::Duration upper_bound, absl::Duration timeout,
+                     AlarmPolicy alarm_policy, int* attempts) {
+  const absl::Time deadline = absl::Now() + timeout;
+  while (absl::Now() < deadline) {
+#if defined(ABSL_HAVE_ALARM)
+    sig_t old_alarm = SIG_DFL;
+    if (alarm_policy == AlarmPolicy::kWithAlarm) {
+      alarm_handler_invoked = false;
+      old_alarm = signal(SIGALRM, AlarmHandler);
+      alarm(absl::ToInt64Seconds(d / 2));
+    }
+#else
+    EXPECT_EQ(alarm_policy, AlarmPolicy::kWithoutAlarm);
+#endif
+    ++*attempts;
+    absl::Time start = absl::Now();
+    absl::SleepFor(d);
+    absl::Duration actual = absl::Now() - start;
+#if defined(ABSL_HAVE_ALARM)
+    if (alarm_policy == AlarmPolicy::kWithAlarm) {
+      signal(SIGALRM, old_alarm);
+      if (!alarm_handler_invoked) continue;
+    }
+#endif
+    if (lower_bound <= actual && actual <= upper_bound) {
+      return true;  // yes, the SleepFor() was correctly bounded
+    }
+  }
+  return false;
 }
-#endif  // ABSL_HAVE_ALARM
+
+testing::AssertionResult AssertSleepForBounded(absl::Duration d,
+                                               absl::Duration early,
+                                               absl::Duration late,
+                                               absl::Duration timeout,
+                                               AlarmPolicy alarm_policy) {
+  const absl::Duration lower_bound = d - early;
+  const absl::Duration upper_bound = d + late;
+  int attempts = 0;
+  if (SleepForBounded(d, lower_bound, upper_bound, timeout, alarm_policy,
+                      &attempts)) {
+    return testing::AssertionSuccess();
+  }
+  return testing::AssertionFailure()
+         << "SleepFor(" << d << ") did not return within [" << lower_bound
+         << ":" << upper_bound << "] in " << attempts << " attempt"
+         << (attempts == 1 ? "" : "s") << " over " << timeout
+         << (alarm_policy == AlarmPolicy::kWithAlarm ? " with" : " without")
+         << " an alarm";
+}
+
+// Tests that SleepFor() returns neither too early nor too late.
+TEST(SleepFor, Bounded) {
+  const absl::Duration d = absl::Milliseconds(2500);
+  const absl::Duration early = absl::Milliseconds(100);
+  const absl::Duration late = absl::Milliseconds(300);
+  const absl::Duration timeout = 48 * d;
+  EXPECT_TRUE(AssertSleepForBounded(d, early, late, timeout,
+                                    AlarmPolicy::kWithoutAlarm));
+#if defined(ABSL_HAVE_ALARM)
+  EXPECT_TRUE(AssertSleepForBounded(d, early, late, timeout,
+                                    AlarmPolicy::kWithAlarm));
+#endif
+}
 
 }  // namespace
diff --git a/absl/time/duration.cc b/absl/time/duration.cc
index c13fa79..f402137 100644
--- a/absl/time/duration.cc
+++ b/absl/time/duration.cc
@@ -895,13 +895,10 @@
   *d = dur;
   return true;
 }
-
 bool ParseFlag(const std::string& text, Duration* dst, std::string* ) {
   return ParseDuration(text, dst);
 }
 
-std::string UnparseFlag(Duration d) {
-  return FormatDuration(d);
-}
+std::string UnparseFlag(Duration d) { return FormatDuration(d); }
 
 }  // namespace absl
diff --git a/absl/time/duration_benchmark.cc b/absl/time/duration_benchmark.cc
index 54f89a1..d5657bd 100644
--- a/absl/time/duration_benchmark.cc
+++ b/absl/time/duration_benchmark.cc
@@ -27,47 +27,113 @@
 //
 
 void BM_Duration_Factory_Nanoseconds(benchmark::State& state) {
+  int64_t i = 0;
   while (state.KeepRunning()) {
-    benchmark::DoNotOptimize(absl::Nanoseconds(1));
+    benchmark::DoNotOptimize(absl::Nanoseconds(i));
+    i += 314159;
   }
 }
 BENCHMARK(BM_Duration_Factory_Nanoseconds);
 
 void BM_Duration_Factory_Microseconds(benchmark::State& state) {
+  int64_t i = 0;
   while (state.KeepRunning()) {
-    benchmark::DoNotOptimize(absl::Microseconds(1));
+    benchmark::DoNotOptimize(absl::Microseconds(i));
+    i += 314;
   }
 }
 BENCHMARK(BM_Duration_Factory_Microseconds);
 
 void BM_Duration_Factory_Milliseconds(benchmark::State& state) {
+  int64_t i = 0;
   while (state.KeepRunning()) {
-    benchmark::DoNotOptimize(absl::Milliseconds(1));
+    benchmark::DoNotOptimize(absl::Milliseconds(i));
+    i += 1;
   }
 }
 BENCHMARK(BM_Duration_Factory_Milliseconds);
 
 void BM_Duration_Factory_Seconds(benchmark::State& state) {
+  int64_t i = 0;
   while (state.KeepRunning()) {
-    benchmark::DoNotOptimize(absl::Seconds(1));
+    benchmark::DoNotOptimize(absl::Seconds(i));
+    i += 1;
   }
 }
 BENCHMARK(BM_Duration_Factory_Seconds);
 
 void BM_Duration_Factory_Minutes(benchmark::State& state) {
+  int64_t i = 0;
   while (state.KeepRunning()) {
-    benchmark::DoNotOptimize(absl::Minutes(1));
+    benchmark::DoNotOptimize(absl::Minutes(i));
+    i += 1;
   }
 }
 BENCHMARK(BM_Duration_Factory_Minutes);
 
 void BM_Duration_Factory_Hours(benchmark::State& state) {
+  int64_t i = 0;
   while (state.KeepRunning()) {
-    benchmark::DoNotOptimize(absl::Hours(1));
+    benchmark::DoNotOptimize(absl::Hours(i));
+    i += 1;
   }
 }
 BENCHMARK(BM_Duration_Factory_Hours);
 
+void BM_Duration_Factory_DoubleNanoseconds(benchmark::State& state) {
+  double d = 1;
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(absl::Nanoseconds(d));
+    d = d * 1.00000001 + 1;
+  }
+}
+BENCHMARK(BM_Duration_Factory_DoubleNanoseconds);
+
+void BM_Duration_Factory_DoubleMicroseconds(benchmark::State& state) {
+  double d = 1e-3;
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(absl::Microseconds(d));
+    d = d * 1.00000001 + 1e-3;
+  }
+}
+BENCHMARK(BM_Duration_Factory_DoubleMicroseconds);
+
+void BM_Duration_Factory_DoubleMilliseconds(benchmark::State& state) {
+  double d = 1e-6;
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(absl::Milliseconds(d));
+    d = d * 1.00000001 + 1e-6;
+  }
+}
+BENCHMARK(BM_Duration_Factory_DoubleMilliseconds);
+
+void BM_Duration_Factory_DoubleSeconds(benchmark::State& state) {
+  double d = 1e-9;
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(absl::Seconds(d));
+    d = d * 1.00000001 + 1e-9;
+  }
+}
+BENCHMARK(BM_Duration_Factory_DoubleSeconds);
+
+void BM_Duration_Factory_DoubleMinutes(benchmark::State& state) {
+  double d = 1e-9;
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(absl::Minutes(d));
+    d = d * 1.00000001 + 1e-9;
+  }
+}
+BENCHMARK(BM_Duration_Factory_DoubleMinutes);
+
+void BM_Duration_Factory_DoubleHours(benchmark::State& state) {
+  double d = 1e-9;
+  while (state.KeepRunning()) {
+    benchmark::DoNotOptimize(absl::Hours(d));
+    d = d * 1.00000001 + 1e-9;
+  }
+}
+BENCHMARK(BM_Duration_Factory_DoubleHours);
+
 //
 // Arithmetic
 //
diff --git a/absl/time/duration_test.cc b/absl/time/duration_test.cc
index 704684e..7ae25dc 100644
--- a/absl/time/duration_test.cc
+++ b/absl/time/duration_test.cc
@@ -16,7 +16,9 @@
 #include <cmath>
 #include <cstdint>
 #include <ctime>
+#include <iomanip>
 #include <limits>
+#include <random>
 #include <string>
 
 #include "gmock/gmock.h"
@@ -105,22 +107,22 @@
 }
 
 TEST(Duration, ToConversion) {
-#define TEST_DURATION_CONVERSION(UNIT)                              \
-  do {                                                              \
-    const absl::Duration d = absl::UNIT(1.5);                       \
-    const absl::Duration z = absl::ZeroDuration();                  \
-    const absl::Duration inf = absl::InfiniteDuration();            \
-    const double dbl_inf = std::numeric_limits<double>::infinity(); \
-    EXPECT_EQ(kint64min, absl::ToInt64##UNIT(-inf));                \
-    EXPECT_EQ(-1, absl::ToInt64##UNIT(-d));                         \
-    EXPECT_EQ(0, absl::ToInt64##UNIT(z));                           \
-    EXPECT_EQ(1, absl::ToInt64##UNIT(d));                           \
-    EXPECT_EQ(kint64max, absl::ToInt64##UNIT(inf));                 \
-    EXPECT_EQ(-dbl_inf, absl::ToDouble##UNIT(-inf));                \
-    EXPECT_EQ(-1.5, absl::ToDouble##UNIT(-d));                      \
-    EXPECT_EQ(0, absl::ToDouble##UNIT(z));                          \
-    EXPECT_EQ(1.5, absl::ToDouble##UNIT(d));                        \
-    EXPECT_EQ(dbl_inf, absl::ToDouble##UNIT(inf));                  \
+#define TEST_DURATION_CONVERSION(UNIT)                                  \
+  do {                                                                  \
+    const absl::Duration d = absl::UNIT(1.5);                           \
+    constexpr absl::Duration z = absl::ZeroDuration();                  \
+    constexpr absl::Duration inf = absl::InfiniteDuration();            \
+    constexpr double dbl_inf = std::numeric_limits<double>::infinity(); \
+    EXPECT_EQ(kint64min, absl::ToInt64##UNIT(-inf));                    \
+    EXPECT_EQ(-1, absl::ToInt64##UNIT(-d));                             \
+    EXPECT_EQ(0, absl::ToInt64##UNIT(z));                               \
+    EXPECT_EQ(1, absl::ToInt64##UNIT(d));                               \
+    EXPECT_EQ(kint64max, absl::ToInt64##UNIT(inf));                     \
+    EXPECT_EQ(-dbl_inf, absl::ToDouble##UNIT(-inf));                    \
+    EXPECT_EQ(-1.5, absl::ToDouble##UNIT(-d));                          \
+    EXPECT_EQ(0, absl::ToDouble##UNIT(z));                              \
+    EXPECT_EQ(1.5, absl::ToDouble##UNIT(d));                            \
+    EXPECT_EQ(dbl_inf, absl::ToDouble##UNIT(inf));                      \
   } while (0)
 
   TEST_DURATION_CONVERSION(Nanoseconds);
@@ -1284,6 +1286,16 @@
   EXPECT_EQ(absl::Nanoseconds(1), absl::Seconds(0.875e-9));
   EXPECT_EQ(absl::Nanoseconds(1), absl::Seconds(1.000e-9));
 
+  EXPECT_EQ(absl::ZeroDuration(), absl::Seconds(-0.124999999e-9));
+  EXPECT_EQ(-absl::Nanoseconds(1) / 4, absl::Seconds(-0.125e-9));
+  EXPECT_EQ(-absl::Nanoseconds(1) / 4, absl::Seconds(-0.250e-9));
+  EXPECT_EQ(-absl::Nanoseconds(1) / 2, absl::Seconds(-0.375e-9));
+  EXPECT_EQ(-absl::Nanoseconds(1) / 2, absl::Seconds(-0.500e-9));
+  EXPECT_EQ(-absl::Nanoseconds(3) / 4, absl::Seconds(-0.625e-9));
+  EXPECT_EQ(-absl::Nanoseconds(3) / 4, absl::Seconds(-0.750e-9));
+  EXPECT_EQ(-absl::Nanoseconds(1), absl::Seconds(-0.875e-9));
+  EXPECT_EQ(-absl::Nanoseconds(1), absl::Seconds(-1.000e-9));
+
   timespec ts;
   ts.tv_sec = 0;
   ts.tv_nsec = 0;
@@ -1313,6 +1325,86 @@
   EXPECT_THAT(ToTimeval(absl::Nanoseconds(2000)), TimevalMatcher(tv));
 }
 
+void VerifySameAsMul(double time_as_seconds, int* const misses) {
+  auto direct_seconds = absl::Seconds(time_as_seconds);
+  auto mul_by_one_second = time_as_seconds * absl::Seconds(1);
+  if (direct_seconds != mul_by_one_second) {
+    if (*misses > 10) return;
+    ASSERT_LE(++(*misses), 10) << "Too many errors, not reporting more.";
+    EXPECT_EQ(direct_seconds, mul_by_one_second)
+        << "given double time_as_seconds = " << std::setprecision(17)
+        << time_as_seconds;
+  }
+}
+
+// For a variety of interesting durations, we find the exact point
+// where one double converts to that duration, and the very next double
+// converts to the next duration.  For both of those points, verify that
+// Seconds(point) returns the same duration as point * Seconds(1.0)
+TEST(Duration, ToDoubleSecondsCheckEdgeCases) {
+  constexpr uint32_t kTicksPerSecond = absl::time_internal::kTicksPerSecond;
+  constexpr auto duration_tick = absl::time_internal::MakeDuration(0, 1u);
+  int misses = 0;
+  for (int64_t seconds = 0; seconds < 99; ++seconds) {
+    uint32_t tick_vals[] = {0, +999, +999999, +999999999, kTicksPerSecond - 1,
+                            0, 1000, 1000000, 1000000000, kTicksPerSecond,
+                            1, 1001, 1000001, 1000000001, kTicksPerSecond + 1,
+                            2, 1002, 1000002, 1000000002, kTicksPerSecond + 2,
+                            3, 1003, 1000003, 1000000003, kTicksPerSecond + 3,
+                            4, 1004, 1000004, 1000000004, kTicksPerSecond + 4,
+                            5, 6,    7,       8,          9};
+    for (uint32_t ticks : tick_vals) {
+      absl::Duration s_plus_t = absl::Seconds(seconds) + ticks * duration_tick;
+      for (absl::Duration d : {s_plus_t, -s_plus_t}) {
+        absl::Duration after_d = d + duration_tick;
+        EXPECT_NE(d, after_d);
+        EXPECT_EQ(after_d - d, duration_tick);
+
+        double low_edge = ToDoubleSeconds(d);
+        EXPECT_EQ(d, absl::Seconds(low_edge));
+
+        double high_edge = ToDoubleSeconds(after_d);
+        EXPECT_EQ(after_d, absl::Seconds(high_edge));
+
+        for (;;) {
+          double midpoint = low_edge + (high_edge - low_edge) / 2;
+          if (midpoint == low_edge || midpoint == high_edge) break;
+          absl::Duration mid_duration = absl::Seconds(midpoint);
+          if (mid_duration == d) {
+            low_edge = midpoint;
+          } else {
+            EXPECT_EQ(mid_duration, after_d);
+            high_edge = midpoint;
+          }
+        }
+        // Now low_edge is the highest double that converts to Duration d,
+        // and high_edge is the lowest double that converts to Duration after_d.
+        VerifySameAsMul(low_edge, &misses);
+        VerifySameAsMul(high_edge, &misses);
+      }
+    }
+  }
+}
+
+TEST(Duration, ToDoubleSecondsCheckRandom) {
+  std::random_device rd;
+  std::seed_seq seed({rd(), rd(), rd(), rd(), rd(), rd(), rd(), rd()});
+  std::mt19937_64 gen(seed);
+  // We want doubles distributed from 1/8ns up to 2^63, where
+  // as many values are tested from 1ns to 2ns as from 1sec to 2sec,
+  // so even distribute along a log-scale of those values, and
+  // exponentiate before using them.  (9.223377e+18 is just slightly
+  // out of bounds for absl::Duration.)
+  std::uniform_real_distribution<double> uniform(std::log(0.125e-9),
+                                                 std::log(9.223377e+18));
+  int misses = 0;
+  for (int i = 0; i < 1000000; ++i) {
+    double d = std::exp(uniform(gen));
+    VerifySameAsMul(d, &misses);
+    VerifySameAsMul(-d, &misses);
+  }
+}
+
 TEST(Duration, ConversionSaturation) {
   absl::Duration d;
 
diff --git a/absl/time/internal/get_current_time_chrono.inc b/absl/time/internal/get_current_time_chrono.inc
new file mode 100644
index 0000000..cf884a1
--- /dev/null
+++ b/absl/time/internal/get_current_time_chrono.inc
@@ -0,0 +1,29 @@
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <chrono>
+#include <cstdint>
+
+namespace absl {
+namespace time_internal {
+
+static int64_t GetCurrentTimeNanosFromSystem() {
+  return std::chrono::duration_cast<std::chrono::nanoseconds>(
+             std::chrono::system_clock::now() -
+             std::chrono::system_clock::from_time_t(0))
+      .count();
+}
+
+}  // namespace time_internal
+}  // namespace absl
diff --git a/absl/time/internal/get_current_time_ios.inc b/absl/time/internal/get_current_time_ios.inc
deleted file mode 100644
index f3db32b..0000000
--- a/absl/time/internal/get_current_time_ios.inc
+++ /dev/null
@@ -1,80 +0,0 @@
-#include "absl/time/clock.h"
-
-#include <sys/time.h>
-#include <ctime>
-#include <cstdint>
-
-#include "absl/base/internal/raw_logging.h"
-
-// These are not defined in the Xcode 7.3.1 SDK Headers.
-// Once we are no longer supporting Xcode 7.3.1 we can
-// remove these.
-#ifndef __WATCHOS_3_0
-#define __WATCHOS_3_0 30000
-#endif
-
-#ifndef __TVOS_10_0
-#define __TVOS_10_0 100000
-#endif
-
-#ifndef __IPHONE_10_0
-#define __IPHONE_10_0 100000
-#endif
-
-#ifndef __MAC_10_12
-#define __MAC_10_12 101200
-#endif
-
-namespace absl {
-namespace time_internal {
-
-static int64_t GetCurrentTimeNanosFromSystem() {
-#if (__MAC_OS_X_VERSION_MAX_ALLOWED >= __MAC_10_12) ||    \
-    (__IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_10_0) || \
-    (__WATCH_OS_VERSION_MAX_ALLOWED >= __WATCHOS_3_0) ||  \
-    (__TV_OS_VERSION_MAX_ALLOWED >= __TVOS_10_0)
-  // clock_gettime_nsec_np is not defined on SDKs before Xcode 8.0.
-  // This preprocessor logic is based upon __CLOCK_AVAILABILITY in
-  // usr/include/time.h. Once we are no longer supporting Xcode 7.3.1 we can
-  // remove this #if.
-  // We must continue to check if it is defined until we are sure that ALL the
-  // platforms we are shipping on support it.
-  // clock_gettime_nsec_np is preferred because it may give higher accuracy than
-  // gettimeofday in future Apple operating systems.
-  // Currently (macOS 10.12/iOS 10.2) clock_gettime_nsec_np accuracy is
-  // microsecond accuracy (i.e. equivalent to gettimeofday).
-  if (&clock_gettime_nsec_np != nullptr) {
-    return clock_gettime_nsec_np(CLOCK_REALTIME);
-  }
-#endif
-#if (defined(__MAC_OS_X_VERSION_MIN_REQUIRED) &&            \
-     (__MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_12)) ||    \
-    (defined(__IPHONE_OS_VERSION_MIN_REQUIRED) &&           \
-     (__IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_10_0)) || \
-    (defined(__WATCH_OS_VERSION_MIN_REQUIRED) &&            \
-     (__WATCH_OS_VERSION_MIN_REQUIRED < __WATCHOS_3_0)) ||  \
-    (defined(__TV_OS_VERSION_MIN_REQUIRED) &&               \
-     (__TV_OS_VERSION_MIN_REQUIRED < __TVOS_10_0))
-  // We need this block in 2 different cases:
-  // a) where we are compiling with Xcode 7 in which case the block above
-  //    will not be compiled in, and this is the only block executed.
-  // b) where we are compiling with Xcode 8+ but supporting operating systems
-  //    that do not define clock_gettime_nsec_np, so this is in effect
-  //    an else block to the block above.
-  // This block will not be compiled if the min supported version is
-  // guaranteed to supply clock_gettime_nsec_np.
-  //
-  // Once we know that clock_gettime_nsec_np is in the SDK *AND* exists on
-  // all the platforms we support, we can remove both this block and alter the
-  // block above to just call clock_gettime_nsec_np directly.
-  const int64_t kNanosPerSecond = 1000 * 1000 * 1000;
-  const int64_t kNanosPerMicrosecond = 1000;
-  struct timeval tp;
-  ABSL_RAW_CHECK(gettimeofday(&tp, nullptr) == 0, "Failed gettimeofday");
-  return (int64_t{tp.tv_sec} * kNanosPerSecond +
-          int64_t{tp.tv_usec} * kNanosPerMicrosecond);
-#endif
-}
-
-}  // namespace time_internal
-}  // namespace absl
diff --git a/absl/time/internal/get_current_time_windows.inc b/absl/time/internal/get_current_time_windows.inc
deleted file mode 100644
index b22a9c9..0000000
--- a/absl/time/internal/get_current_time_windows.inc
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "absl/time/clock.h"
-
-#include <chrono>
-#include <cstdint>
-
-namespace absl {
-namespace time_internal {
-
-static int64_t GetCurrentTimeNanosFromSystem() {
-  return std::chrono::duration_cast<std::chrono::nanoseconds>(
-             std::chrono::system_clock::now() -
-             std::chrono::system_clock::from_time_t(0))
-      .count();
-}
-
-}  // namespace time_internal
-}  // namespace absl
diff --git a/absl/time/time.h b/absl/time/time.h
index ceec2de..c41cb89 100644
--- a/absl/time/time.h
+++ b/absl/time/time.h
@@ -50,7 +50,7 @@
 #ifndef ABSL_TIME_TIME_H_
 #define ABSL_TIME_TIME_H_
 
-#if !defined(_WIN32)
+#if !defined(_MSC_VER)
 #include <sys/time.h>
 #else
 #include <winsock2.h>
@@ -81,6 +81,7 @@
 constexpr uint32_t GetRepLo(Duration d);
 constexpr Duration MakeDuration(int64_t hi, uint32_t lo);
 constexpr Duration MakeDuration(int64_t hi, int64_t lo);
+inline Duration MakePosDoubleDuration(double n);
 constexpr int64_t kTicksPerNanosecond = 4;
 constexpr int64_t kTicksPerSecond = 1000 * 1000 * 1000 * kTicksPerNanosecond;
 template <std::intmax_t N>
@@ -295,6 +296,39 @@
 //   absl::Duration c = absl::Ceil(d, absl::Microseconds(1));   // 123457us
 Duration Ceil(Duration d, Duration unit);
 
+// InfiniteDuration()
+//
+// Returns an infinite `Duration`.  To get a `Duration` representing negative
+// infinity, use `-InfiniteDuration()`.
+//
+// Duration arithmetic overflows to +/- infinity and saturates. In general,
+// arithmetic with `Duration` infinities is similar to IEEE 754 infinities
+// except where IEEE 754 NaN would be involved, in which case +/-
+// `InfiniteDuration()` is used in place of a "nan" Duration.
+//
+// Examples:
+//
+//   constexpr absl::Duration inf = absl::InfiniteDuration();
+//   const absl::Duration d = ... any finite duration ...
+//
+//   inf == inf + inf
+//   inf == inf + d
+//   inf == inf - inf
+//   -inf == d - inf
+//
+//   inf == d * 1e100
+//   inf == inf / 2
+//   0 == d / inf
+//   INT64_MAX == inf / d
+//
+//   // Division by zero returns infinity, or INT64_MIN/MAX where appropriate.
+//   inf == d / 0
+//   INT64_MAX == d / absl::ZeroDuration()
+//
+// The examples involving the `/` operator above also apply to `IDivDuration()`
+// and `FDivDuration()`.
+constexpr Duration InfiniteDuration();
+
 // Nanoseconds()
 // Microseconds()
 // Milliseconds()
@@ -344,7 +378,13 @@
 }
 template <typename T, time_internal::EnableIfFloat<T> = 0>
 Duration Seconds(T n) {
-  return n * Seconds(1);
+  if (n >= 0) {
+    if (n >= std::numeric_limits<int64_t>::max()) return InfiniteDuration();
+    return time_internal::MakePosDoubleDuration(n);
+  } else {
+    if (n <= std::numeric_limits<int64_t>::min()) return -InfiniteDuration();
+    return -time_internal::MakePosDoubleDuration(-n);
+  }
 }
 template <typename T, time_internal::EnableIfFloat<T> = 0>
 Duration Minutes(T n) {
@@ -439,39 +479,6 @@
 std::chrono::minutes ToChronoMinutes(Duration d);
 std::chrono::hours ToChronoHours(Duration d);
 
-// InfiniteDuration()
-//
-// Returns an infinite `Duration`.  To get a `Duration` representing negative
-// infinity, use `-InfiniteDuration()`.
-//
-// Duration arithmetic overflows to +/- infinity and saturates. In general,
-// arithmetic with `Duration` infinities is similar to IEEE 754 infinities
-// except where IEEE 754 NaN would be involved, in which case +/-
-// `InfiniteDuration()` is used in place of a "nan" Duration.
-//
-// Examples:
-//
-//   constexpr absl::Duration inf = absl::InfiniteDuration();
-//   const absl::Duration d = ... any finite duration ...
-//
-//   inf == inf + inf
-//   inf == inf + d
-//   inf == inf - inf
-//   -inf == d - inf
-//
-//   inf == d * 1e100
-//   inf == inf / 2
-//   0 == d / inf
-//   INT64_MAX == inf / d
-//
-//   // Division by zero returns infinity, or INT64_MIN/MAX where appropriate.
-//   inf == d / 0
-//   INT64_MAX == d / absl::ZeroDuration()
-//
-// The examples involving the `/` operator above also apply to `IDivDuration()`
-// and `FDivDuration()`.
-constexpr Duration InfiniteDuration();
-
 // FormatDuration()
 //
 // Returns a std::string representing the duration in the form "72h3m0.5s".
@@ -492,12 +499,9 @@
 // `ZeroDuration()`.  Parses "inf" and "-inf" as +/- `InfiniteDuration()`.
 bool ParseDuration(const std::string& dur_string, Duration* d);
 
-// ParseFlag()
-//
+// Support for flag values of type Duration. Duration flags must be specified
+// in a format that is valid input for absl::ParseDuration().
 bool ParseFlag(const std::string& text, Duration* dst, std::string* error);
-
-// UnparseFlag()
-//
 std::string UnparseFlag(Duration d);
 
 // Time
@@ -991,9 +995,6 @@
 bool ParseTime(const std::string& format, const std::string& input, TimeZone tz,
                Time* time, std::string* err);
 
-// ParseFlag()
-// UnparseFlag()
-//
 // Support for flag values of type Time. Time flags must be specified in a
 // format that matches absl::RFC3339_full. For example:
 //
@@ -1114,6 +1115,18 @@
   return MakeDuration(hi, static_cast<uint32_t>(lo));
 }
 
+// Make a Duration value from a floating-point number, as long as that number
+// is in the range [ 0 .. numeric_limits<int64_t>::max ), that is, as long as
+// it's positive and can be converted to int64_t without risk of UB.
+inline Duration MakePosDoubleDuration(double n) {
+  const int64_t int_secs = static_cast<int64_t>(n);
+  const uint32_t ticks =
+      static_cast<uint32_t>((n - int_secs) * kTicksPerSecond + 0.5);
+  return ticks < kTicksPerSecond
+             ? MakeDuration(int_secs, ticks)
+             : MakeDuration(int_secs + 1, ticks - kTicksPerSecond);
+}
+
 // Creates a normalized Duration from an almost-normalized (sec,ticks)
 // pair. sec may be positive or negative.  ticks must be in the range
 // -kTicksPerSecond < *ticks < kTicksPerSecond.  If ticks is negative it
diff --git a/absl/types/internal/variant.h b/absl/types/internal/variant.h
index 7db5e05..7708e67 100644
--- a/absl/types/internal/variant.h
+++ b/absl/types/internal/variant.h
@@ -1062,32 +1062,6 @@
   static void Overload(...);
 };
 
-////////////////////////////////
-// Library Fundamentals V2 TS //
-////////////////////////////////
-
-// TODO(calabrese): Consider moving this to absl/meta/type_traits.h
-
-// The following is a rough implementation of parts of the detection idiom.
-// It is used for the comparison operator checks.
-
-template <class Enabler, class To, template <class...> class Op, class... Args>
-struct is_detected_convertible_impl {
-  using type = std::false_type;
-};
-
-template <class To, template <class...> class Op, class... Args>
-struct is_detected_convertible_impl<
-    absl::enable_if_t<std::is_convertible<Op<Args...>, To>::value>, To, Op,
-    Args...> {
-  using type = std::true_type;
-};
-
-// NOTE: This differs from library fundamentals by being lazy.
-template <class To, template <class...> class Op, class... Args>
-struct is_detected_convertible
-    : is_detected_convertible_impl<void, To, Op, Args...>::type {};
-
 template <class T>
 using LessThanResult = decltype(std::declval<T>() < std::declval<T>());
 
@@ -1107,6 +1081,8 @@
 template <class T>
 using NotEqualResult = decltype(std::declval<T>() != std::declval<T>());
 
+using type_traits_internal::is_detected_convertible;
+
 template <class... T>
 using RequireAllHaveEqualT = absl::enable_if_t<
     absl::conjunction<is_detected_convertible<bool, EqualResult, T>...>::value,
diff --git a/absl/types/span_test.cc b/absl/types/span_test.cc
index 5a4f001..fbce7e8 100644
--- a/absl/types/span_test.cc
+++ b/absl/types/span_test.cc
@@ -288,7 +288,7 @@
 #ifdef ABSL_HAVE_EXCEPTIONS
   EXPECT_THROW(absl::MakeSpan(ramp).subspan(11, 5), std::out_of_range);
 #else
-  EXPECT_DEATH(absl::MakeSpan(ramp).subspan(11, 5), "");
+  EXPECT_DEATH_IF_SUPPORTED(absl::MakeSpan(ramp).subspan(11, 5), "");
 #endif
 }
 
diff --git a/absl/types/variant.h b/absl/types/variant.h
index fd1d49a..17e0634 100644
--- a/absl/types/variant.h
+++ b/absl/types/variant.h
@@ -248,7 +248,7 @@
 //
 // Example:
 //
-//   absl::variant<int, std::string> bar = 42;
+//   absl::variant<int, std::string> foo = 42;
 //   if (absl::holds_alternative<int>(foo)) {
 //       std::cout << "The variant holds an integer";
 //   }
@@ -449,14 +449,19 @@
 //------------------------------------------------------------------------------
 template <typename T0, typename... Tn>
 class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> {
+  static_assert(absl::conjunction<std::is_object<T0>,
+                                  std::is_object<Tn>...>::value,
+                "Attempted to instantiate a variant containing a non-object "
+                "type.");
   // Intentionally not qualifing `negation` with `absl::` to work around a bug
   // in MSVC 2015 with inline namespace and variadic template.
-  static_assert(absl::conjunction<std::is_object<T0>, std::is_object<Tn>...,
-                                  negation<std::is_array<T0> >,
-                                  negation<std::is_array<Tn> >...,
-                                  std::is_nothrow_destructible<T0>,
+  static_assert(absl::conjunction<negation<std::is_array<T0> >,
+                                  negation<std::is_array<Tn> >...>::value,
+                "Attempted to instantiate a variant containing an array type.");
+  static_assert(absl::conjunction<std::is_nothrow_destructible<T0>,
                                   std::is_nothrow_destructible<Tn>...>::value,
-                "Attempted to instantiate a variant with an unsupported type.");
+                "Attempted to instantiate a variant containing a non-nothrow "
+                "destructible type.");
 
   friend struct variant_internal::VariantCoreAccess;
 
diff --git a/api/asyncresolverfactory.h b/api/asyncresolverfactory.h
new file mode 100644
index 0000000..96abee4
--- /dev/null
+++ b/api/asyncresolverfactory.h
@@ -0,0 +1,32 @@
+/*
+ *  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 API_ASYNCRESOLVERFACTORY_H_
+#define API_ASYNCRESOLVERFACTORY_H_
+
+#include "rtc_base/asyncresolverinterface.h"
+
+namespace webrtc {
+
+// An abstract factory for creating AsyncResolverInterfaces. This allows
+// client applications to provide WebRTC with their own mechanism for
+// performing DNS resolution.
+class AsyncResolverFactory {
+ public:
+  AsyncResolverFactory() = default;
+  virtual ~AsyncResolverFactory() = default;
+
+  // The caller should call Destroy on the returned object to delete it.
+  virtual rtc::AsyncResolverInterface* Create() = 0;
+};
+
+}  // namespace webrtc
+
+#endif  // API_ASYNCRESOLVERFACTORY_H_
diff --git a/api/audio/audio_frame.h b/api/audio/audio_frame.h
index 4c9aa9c..dd6ac02 100644
--- a/api/audio/audio_frame.h
+++ b/api/audio/audio_frame.h
@@ -12,13 +12,13 @@
 #define API_AUDIO_AUDIO_FRAME_H_
 
 #include <stddef.h>
+#include <stdint.h>
 
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
-/* This class holds up to 60 ms of super-wideband (32 kHz) stereo audio. It
+/* This class holds up to 120 ms of super-wideband (32 kHz) stereo audio. It
  * allows for adding and subtracting frames while keeping track of the resulting
  * states.
  *
@@ -38,8 +38,9 @@
   // variables which should allow us to switch to constexpr and keep this a
   // header-only class.
   enum : size_t {
-    // Stereo, 32 kHz, 60 ms (2 * 32 * 60)
-    kMaxDataSizeSamples = 3840,
+    // Stereo, 32 kHz, 120 ms (2 * 32 * 120)
+    // Stereo, 192 kHz, 20 ms (2 * 192 * 20)
+    kMaxDataSizeSamples = 7680,
     kMaxDataSizeBytes = kMaxDataSizeSamples * sizeof(int16_t),
   };
 
diff --git a/api/audio/echo_canceller3_config.cc b/api/audio/echo_canceller3_config.cc
index 9af7f11..3b03d13 100644
--- a/api/audio/echo_canceller3_config.cc
+++ b/api/audio/echo_canceller3_config.cc
@@ -14,6 +14,10 @@
 EchoCanceller3Config::EchoCanceller3Config() = default;
 EchoCanceller3Config::EchoCanceller3Config(const EchoCanceller3Config& e) =
     default;
+EchoCanceller3Config::Delay::Delay() = default;
+EchoCanceller3Config::Delay::Delay(const EchoCanceller3Config::Delay& e) =
+    default;
+
 EchoCanceller3Config::Mask::Mask() = default;
 EchoCanceller3Config::Mask::Mask(const EchoCanceller3Config::Mask& m) = default;
 
@@ -21,4 +25,30 @@
 EchoCanceller3Config::EchoModel::EchoModel(
     const EchoCanceller3Config::EchoModel& e) = default;
 
+EchoCanceller3Config::Suppressor::Suppressor() = default;
+EchoCanceller3Config::Suppressor::Suppressor(
+    const EchoCanceller3Config::Suppressor& e) = default;
+
+EchoCanceller3Config::Suppressor::MaskingThresholds::MaskingThresholds(
+    float enr_transparent,
+    float enr_suppress,
+    float emr_transparent)
+    : enr_transparent(enr_transparent),
+      enr_suppress(enr_suppress),
+      emr_transparent(emr_transparent) {}
+EchoCanceller3Config::Suppressor::Suppressor::MaskingThresholds::
+    MaskingThresholds(
+        const EchoCanceller3Config::Suppressor::MaskingThresholds& e) = default;
+
+EchoCanceller3Config::Suppressor::Tuning::Tuning(MaskingThresholds mask_lf,
+                                                 MaskingThresholds mask_hf,
+                                                 float max_inc_factor,
+                                                 float max_dec_factor_lf)
+    : mask_lf(mask_lf),
+      mask_hf(mask_hf),
+      max_inc_factor(max_inc_factor),
+      max_dec_factor_lf(max_dec_factor_lf) {}
+EchoCanceller3Config::Suppressor::Tuning::Tuning(
+    const EchoCanceller3Config::Suppressor::Tuning& e) = default;
+
 }  // namespace webrtc
diff --git a/api/audio/echo_canceller3_config.h b/api/audio/echo_canceller3_config.h
index d633d04..f4ba8e9 100644
--- a/api/audio/echo_canceller3_config.h
+++ b/api/audio/echo_canceller3_config.h
@@ -20,6 +20,8 @@
   EchoCanceller3Config();
   EchoCanceller3Config(const EchoCanceller3Config& e);
   struct Delay {
+    Delay();
+    Delay(const Delay& e);
     size_t default_delay = 5;
     size_t down_sampling_factor = 4;
     size_t num_filters = 6;
@@ -29,6 +31,7 @@
     size_t hysteresis_limit_1_blocks = 1;
     size_t hysteresis_limit_2_blocks = 1;
     size_t skew_hysteresis_blocks = 3;
+    size_t fixed_capture_delay_samples = 0;
   } delay;
 
   struct Filter {
@@ -53,12 +56,16 @@
     ShadowConfiguration shadow_initial = {12, 0.9f, 20075344.f};
 
     size_t config_change_duration_blocks = 250;
+    float initial_state_seconds = 2.5f;
+    bool conservative_initial_phase = false;
+    bool enable_shadow_filter_output_usage = true;
   } filter;
 
   struct Erle {
     float min = 1.f;
     float max_l = 4.f;
     float max_h = 1.5f;
+    bool onset_detection = true;
   } erle;
 
   struct EpStrength {
@@ -107,27 +114,6 @@
     float poor_excitation_render_limit_ds8 = 20.f;
   } render_levels;
 
-  struct GainUpdates {
-    struct GainChanges {
-      float max_inc;
-      float max_dec;
-      float rate_inc;
-      float rate_dec;
-      float min_inc;
-      float min_dec;
-    };
-
-    GainChanges low_noise = {2.f, 2.f, 1.4f, 1.4f, 1.1f, 1.1f};
-    GainChanges initial = {2.f, 2.f, 1.5f, 1.5f, 1.2f, 1.2f};
-    GainChanges normal = {2.f, 2.f, 1.5f, 1.5f, 1.2f, 1.2f};
-    GainChanges saturation = {1.2f, 1.2f, 1.5f, 1.5f, 1.f, 1.f};
-    GainChanges nonlinear = {1.5f, 1.5f, 1.2f, 1.2f, 1.1f, 1.1f};
-
-    float max_inc_factor = 2.0f;
-    float max_dec_factor_lf = 0.25f;
-    float floor_first_increase = 0.00001f;
-  } gain_updates;
-
   struct EchoRemovalControl {
     struct GainRampup {
       float initial_gain = 0.0f;
@@ -156,16 +142,57 @@
   } echo_model;
 
   struct Suppressor {
-    size_t bands_with_reliable_coherence = 5;
+    Suppressor();
+    Suppressor(const Suppressor& e);
+
     size_t nearend_average_blocks = 4;
 
     struct MaskingThresholds {
+      MaskingThresholds(float enr_transparent,
+                        float enr_suppress,
+                        float emr_transparent);
+      MaskingThresholds(const MaskingThresholds& e);
       float enr_transparent;
       float enr_suppress;
       float emr_transparent;
     };
-    MaskingThresholds mask_lf = {.2f, .3f, .3f};
-    MaskingThresholds mask_hf = {.07f, .1f, .3f};
+
+    struct Tuning {
+      Tuning(MaskingThresholds mask_lf,
+             MaskingThresholds mask_hf,
+             float max_inc_factor,
+             float max_dec_factor_lf);
+      Tuning(const Tuning& e);
+      MaskingThresholds mask_lf;
+      MaskingThresholds mask_hf;
+      float max_inc_factor;
+      float max_dec_factor_lf;
+    };
+
+    Tuning normal_tuning = Tuning(MaskingThresholds(.2f, .3f, .3f),
+                                  MaskingThresholds(.07f, .1f, .3f),
+                                  2.0f,
+                                  0.25f);
+    Tuning nearend_tuning = Tuning(MaskingThresholds(.2f, .3f, .3f),
+                                   MaskingThresholds(.07f, .1f, .3f),
+                                   2.0f,
+                                   0.25f);
+
+    struct DominantNearendDetection {
+      float enr_threshold = 10.f;
+      float snr_threshold = 10.f;
+      int hold_duration = 25;
+      int trigger_threshold = 15;
+    } dominant_nearend_detection;
+
+    struct HighBandsSuppression {
+      float enr_threshold = 1.f;
+      float max_gain_during_echo = 1.f;
+    } high_bands_suppression;
+
+    float floor_first_increase = 0.00001f;
+    bool enforce_transparent = false;
+    bool enforce_empty_higher_bands = false;
   } suppressor;
 };
 }  // namespace webrtc
diff --git a/api/audio_options.h b/api/audio_options.h
index df66d36..aefc7a1 100644
--- a/api/audio_options.h
+++ b/api/audio_options.h
@@ -44,7 +44,6 @@
     SetFrom(&extended_filter_aec, change.extended_filter_aec);
     SetFrom(&delay_agnostic_aec, change.delay_agnostic_aec);
     SetFrom(&experimental_ns, change.experimental_ns);
-    SetFrom(&intelligibility_enhancer, change.intelligibility_enhancer);
     SetFrom(&residual_echo_detector, change.residual_echo_detector);
     SetFrom(&tx_agc_target_dbov, change.tx_agc_target_dbov);
     SetFrom(&tx_agc_digital_compression_gain,
@@ -74,7 +73,6 @@
            extended_filter_aec == o.extended_filter_aec &&
            delay_agnostic_aec == o.delay_agnostic_aec &&
            experimental_ns == o.experimental_ns &&
-           intelligibility_enhancer == o.intelligibility_enhancer &&
            residual_echo_detector == o.residual_echo_detector &&
            tx_agc_target_dbov == o.tx_agc_target_dbov &&
            tx_agc_digital_compression_gain ==
@@ -108,7 +106,6 @@
     ost << ToStringIfSet("extended_filter_aec", extended_filter_aec);
     ost << ToStringIfSet("delay_agnostic_aec", delay_agnostic_aec);
     ost << ToStringIfSet("experimental_ns", experimental_ns);
-    ost << ToStringIfSet("intelligibility_enhancer", intelligibility_enhancer);
     ost << ToStringIfSet("residual_echo_detector", residual_echo_detector);
     ost << ToStringIfSet("tx_agc_target_dbov", tx_agc_target_dbov);
     ost << ToStringIfSet("tx_agc_digital_compression_gain",
@@ -153,7 +150,6 @@
   absl::optional<bool> extended_filter_aec;
   absl::optional<bool> delay_agnostic_aec;
   absl::optional<bool> experimental_ns;
-  absl::optional<bool> intelligibility_enhancer;
   // Note that tx_agc_* only applies to non-experimental AGC.
   absl::optional<bool> residual_echo_detector;
   absl::optional<uint16_t> tx_agc_target_dbov;
diff --git a/api/datachannelinterface.cc b/api/datachannelinterface.cc
new file mode 100644
index 0000000..141462d
--- /dev/null
+++ b/api/datachannelinterface.cc
@@ -0,0 +1,35 @@
+/*
+ *  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 "api/datachannelinterface.h"
+
+namespace webrtc {
+
+bool DataChannelInterface::ordered() const {
+  return false;
+}
+
+uint16_t DataChannelInterface::maxRetransmitTime() const {
+  return 0;
+}
+
+uint16_t DataChannelInterface::maxRetransmits() const {
+  return 0;
+}
+
+std::string DataChannelInterface::protocol() const {
+  return std::string();
+}
+
+bool DataChannelInterface::negotiated() const {
+  return false;
+}
+
+}  // namespace webrtc
diff --git a/api/datachannelinterface.h b/api/datachannelinterface.h
index 5cbe717..a0d2b3b 100644
--- a/api/datachannelinterface.h
+++ b/api/datachannelinterface.h
@@ -88,7 +88,7 @@
   virtual void OnBufferedAmountChange(uint64_t previous_amount) {}
 
  protected:
-  virtual ~DataChannelObserver() {}
+  virtual ~DataChannelObserver() = default;
 };
 
 class DataChannelInterface : public rtc::RefCountInterface {
@@ -134,11 +134,11 @@
   // TODO(deadbeef): Remove these dummy implementations when all classes have
   // implemented these APIs. They should all just return the values the
   // DataChannel was created with.
-  virtual bool ordered() const { return false; }
-  virtual uint16_t maxRetransmitTime() const { return 0; }
-  virtual uint16_t maxRetransmits() const { return 0; }
-  virtual std::string protocol() const { return std::string(); }
-  virtual bool negotiated() const { return false; }
+  virtual bool ordered() const;
+  virtual uint16_t maxRetransmitTime() const;
+  virtual uint16_t maxRetransmits() const;
+  virtual std::string protocol() const;
+  virtual bool negotiated() const;
 
   // Returns the ID from the DataChannelInit, if it was negotiated out-of-band.
   // If negotiated in-band, this ID will be populated once the DTLS role is
@@ -170,7 +170,7 @@
   virtual bool Send(const DataBuffer& buffer) = 0;
 
  protected:
-  virtual ~DataChannelInterface() {}
+  ~DataChannelInterface() override = default;
 };
 
 }  // namespace webrtc
diff --git a/api/dtmfsenderinterface.h b/api/dtmfsenderinterface.h
index 217f9d2..b79bb31 100644
--- a/api/dtmfsenderinterface.h
+++ b/api/dtmfsenderinterface.h
@@ -29,7 +29,7 @@
   virtual void OnToneChange(const std::string& tone) = 0;
 
  protected:
-  virtual ~DtmfSenderObserverInterface() {}
+  virtual ~DtmfSenderObserverInterface() = default;
 };
 
 // The interface of native implementation of the RTCDTMFSender defined by the
@@ -85,7 +85,7 @@
   virtual int inter_tone_gap() const = 0;
 
  protected:
-  virtual ~DtmfSenderInterface() {}
+  ~DtmfSenderInterface() override = default;
 };
 
 }  // namespace webrtc
diff --git a/api/jsep.cc b/api/jsep.cc
index 1f4afba..52a60f9 100644
--- a/api/jsep.cc
+++ b/api/jsep.cc
@@ -21,4 +21,21 @@
   return 0;
 }
 
+void CreateSessionDescriptionObserver::OnFailure(RTCError error) {
+  OnFailure(error.message());
+}
+
+void CreateSessionDescriptionObserver::OnFailure(const std::string& error) {
+  OnFailure(RTCError(RTCErrorType::INTERNAL_ERROR, std::string(error)));
+}
+
+void SetSessionDescriptionObserver::OnFailure(RTCError error) {
+  std::string message(error.message());
+  OnFailure(message);
+}
+
+void SetSessionDescriptionObserver::OnFailure(const std::string& error) {
+  OnFailure(RTCError(RTCErrorType::INTERNAL_ERROR, std::string(error)));
+}
+
 }  // namespace webrtc
diff --git a/api/jsep.h b/api/jsep.h
index dbf97f6..4d4bcc0 100644
--- a/api/jsep.h
+++ b/api/jsep.h
@@ -78,6 +78,12 @@
                                           const std::string& sdp,
                                           SdpParseError* error);
 
+// Creates an IceCandidateInterface based on a parsed candidate structure.
+std::unique_ptr<IceCandidateInterface> CreateIceCandidate(
+    const std::string& sdp_mid,
+    int sdp_mline_index,
+    const cricket::Candidate& candidate);
+
 // This class represents a collection of candidates for a specific m= section.
 // Used in SessionDescriptionInterface.
 class IceCandidateCollection {
@@ -191,6 +197,14 @@
     const std::string& sdp,
     SdpParseError* error_out);
 
+// Creates a SessionDescriptionInterface based on a parsed SDP structure and the
+// given type, ID and version.
+std::unique_ptr<SessionDescriptionInterface> CreateSessionDescription(
+    SdpType type,
+    const std::string& session_id,
+    const std::string& session_version,
+    std::unique_ptr<cricket::SessionDescription> description);
+
 // CreateOffer and CreateAnswer callback interface.
 class CreateSessionDescriptionObserver : public rtc::RefCountInterface {
  public:
@@ -205,10 +219,8 @@
   // is deprecated; in order to let clients remove the old version, it has a
   // default implementation. If both versions are unimplemented, the
   // result will be a runtime error (stack overflow). This is intentional.
-  virtual void OnFailure(RTCError error) { OnFailure(error.message()); }
-  virtual void OnFailure(const std::string& error) {
-    OnFailure(RTCError(RTCErrorType::INTERNAL_ERROR, std::string(error)));
-  }
+  virtual void OnFailure(RTCError error);
+  virtual void OnFailure(const std::string& error);
 
  protected:
   ~CreateSessionDescriptionObserver() override = default;
@@ -219,13 +231,9 @@
  public:
   virtual void OnSuccess() = 0;
   // See description in CreateSessionDescriptionObserver for OnFailure.
-  virtual void OnFailure(RTCError error) {
-    std::string message(error.message());
-    OnFailure(message);
-  }
-  virtual void OnFailure(const std::string& error) {
-    OnFailure(RTCError(RTCErrorType::INTERNAL_ERROR, std::string(error)));
-  }
+  virtual void OnFailure(RTCError error);
+
+  virtual void OnFailure(const std::string& error);
 
  protected:
   ~SetSessionDescriptionObserver() override = default;
diff --git a/api/jsepicecandidate.cc b/api/jsepicecandidate.cc
new file mode 100644
index 0000000..b9ba2fe
--- /dev/null
+++ b/api/jsepicecandidate.cc
@@ -0,0 +1,83 @@
+/*
+ *  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 "api/jsepicecandidate.h"
+
+namespace webrtc {
+
+std::string JsepIceCandidate::sdp_mid() const {
+  return sdp_mid_;
+}
+
+int JsepIceCandidate::sdp_mline_index() const {
+  return sdp_mline_index_;
+}
+
+const cricket::Candidate& JsepIceCandidate::candidate() const {
+  return candidate_;
+}
+
+std::string JsepIceCandidate::server_url() const {
+  return candidate_.url();
+}
+
+JsepCandidateCollection::JsepCandidateCollection() = default;
+
+JsepCandidateCollection::JsepCandidateCollection(JsepCandidateCollection&& o)
+    : candidates_(std::move(o.candidates_)) {}
+
+size_t JsepCandidateCollection::count() const {
+  return candidates_.size();
+}
+
+void JsepCandidateCollection::add(JsepIceCandidate* candidate) {
+  candidates_.push_back(candidate);
+}
+
+const IceCandidateInterface* JsepCandidateCollection::at(size_t index) const {
+  return candidates_[index];
+}
+
+JsepCandidateCollection::~JsepCandidateCollection() {
+  for (std::vector<JsepIceCandidate*>::iterator it = candidates_.begin();
+       it != candidates_.end(); ++it) {
+    delete *it;
+  }
+}
+
+bool JsepCandidateCollection::HasCandidate(
+    const IceCandidateInterface* candidate) const {
+  bool ret = false;
+  for (std::vector<JsepIceCandidate*>::const_iterator it = candidates_.begin();
+       it != candidates_.end(); ++it) {
+    if ((*it)->sdp_mid() == candidate->sdp_mid() &&
+        (*it)->sdp_mline_index() == candidate->sdp_mline_index() &&
+        (*it)->candidate().IsEquivalent(candidate->candidate())) {
+      ret = true;
+      break;
+    }
+  }
+  return ret;
+}
+
+size_t JsepCandidateCollection::remove(const cricket::Candidate& candidate) {
+  auto iter = std::find_if(candidates_.begin(), candidates_.end(),
+                           [candidate](JsepIceCandidate* c) {
+                             return candidate.MatchesForRemoval(c->candidate());
+                           });
+  if (iter != candidates_.end()) {
+    delete *iter;
+    candidates_.erase(iter);
+    return 1;
+  }
+  return 0;
+}
+
+}  // namespace webrtc
diff --git a/api/jsepicecandidate.h b/api/jsepicecandidate.h
index 4801a04..50520fe 100644
--- a/api/jsepicecandidate.h
+++ b/api/jsepicecandidate.h
@@ -31,20 +31,20 @@
   JsepIceCandidate(const std::string& sdp_mid,
                    int sdp_mline_index,
                    const cricket::Candidate& candidate);
-  ~JsepIceCandidate();
+  ~JsepIceCandidate() override;
   // |err| may be null.
   bool Initialize(const std::string& sdp, SdpParseError* err);
   void SetCandidate(const cricket::Candidate& candidate) {
     candidate_ = candidate;
   }
 
-  virtual std::string sdp_mid() const { return sdp_mid_; }
-  virtual int sdp_mline_index() const { return sdp_mline_index_; }
-  virtual const cricket::Candidate& candidate() const { return candidate_; }
+  std::string sdp_mid() const override;
+  int sdp_mline_index() const override;
+  const cricket::Candidate& candidate() const override;
 
-  virtual std::string server_url() const { return candidate_.url(); }
+  std::string server_url() const override;
 
-  virtual bool ToString(std::string* out) const;
+  bool ToString(std::string* out) const override;
 
  private:
   std::string sdp_mid_;
@@ -57,23 +57,18 @@
 // Implementation of IceCandidateCollection which stores JsepIceCandidates.
 class JsepCandidateCollection : public IceCandidateCollection {
  public:
-  JsepCandidateCollection() {}
+  JsepCandidateCollection();
   // Move constructor is defined so that a vector of JsepCandidateCollections
   // can be resized.
-  JsepCandidateCollection(JsepCandidateCollection&& o)
-      : candidates_(std::move(o.candidates_)) {}
-  ~JsepCandidateCollection();
-  virtual size_t count() const { return candidates_.size(); }
-  virtual bool HasCandidate(const IceCandidateInterface* candidate) const;
+  JsepCandidateCollection(JsepCandidateCollection&& o);
+  ~JsepCandidateCollection() override;
+  size_t count() const override;
+  bool HasCandidate(const IceCandidateInterface* candidate) const override;
   // Adds and takes ownership of the JsepIceCandidate.
   // TODO(deadbeef): Make this use an std::unique_ptr<>, so ownership logic is
   // more clear.
-  virtual void add(JsepIceCandidate* candidate) {
-    candidates_.push_back(candidate);
-  }
-  virtual const IceCandidateInterface* at(size_t index) const {
-    return candidates_[index];
-  }
+  virtual void add(JsepIceCandidate* candidate);
+  const IceCandidateInterface* at(size_t index) const override;
   // Removes the candidate that has a matching address and protocol.
   //
   // Returns the number of candidates that were removed.
diff --git a/api/mediaconstraintsinterface.cc b/api/mediaconstraintsinterface.cc
index fb4481f..5567786 100644
--- a/api/mediaconstraintsinterface.cc
+++ b/api/mediaconstraintsinterface.cc
@@ -104,8 +104,6 @@
     "googNoiseSuppression";
 const char MediaConstraintsInterface::kExperimentalNoiseSuppression[] =
     "googNoiseSuppression2";
-const char MediaConstraintsInterface::kIntelligibilityEnhancer[] =
-    "intelligibilityEnhancer";
 const char MediaConstraintsInterface::kHighpassFilter[] = "googHighpassFilter";
 const char MediaConstraintsInterface::kTypingNoiseDetection[] =
     "googTypingNoiseDetection";
@@ -146,6 +144,9 @@
     "googCpuOveruseDetection";
 const char MediaConstraintsInterface::kPayloadPadding[] = "googPayloadPadding";
 
+const char MediaConstraintsInterface::kNumSimulcastLayers[] =
+    "googNumSimulcastLayers";
+
 // Set |value| to the value associated with the first appearance of |key|, or
 // return false if |key| is not found.
 bool MediaConstraintsInterface::Constraints::FindFirst(
@@ -238,9 +239,6 @@
   ConstraintToOptional<bool>(
       constraints, MediaConstraintsInterface::kExperimentalNoiseSuppression,
       &options->experimental_ns);
-  ConstraintToOptional<bool>(
-      constraints, MediaConstraintsInterface::kIntelligibilityEnhancer,
-      &options->intelligibility_enhancer);
   ConstraintToOptional<bool>(constraints,
                              MediaConstraintsInterface::kHighpassFilter,
                              &options->highpass_filter);
@@ -260,4 +258,55 @@
   }
 }
 
+bool CopyConstraintsIntoOfferAnswerOptions(
+    const MediaConstraintsInterface* constraints,
+    PeerConnectionInterface::RTCOfferAnswerOptions* offer_answer_options) {
+  if (!constraints) {
+    return true;
+  }
+
+  bool value = false;
+  size_t mandatory_constraints_satisfied = 0;
+
+  if (FindConstraint(constraints,
+                     MediaConstraintsInterface::kOfferToReceiveAudio, &value,
+                     &mandatory_constraints_satisfied)) {
+    offer_answer_options->offer_to_receive_audio =
+        value ? PeerConnectionInterface::RTCOfferAnswerOptions::
+                    kOfferToReceiveMediaTrue
+              : 0;
+  }
+
+  if (FindConstraint(constraints,
+                     MediaConstraintsInterface::kOfferToReceiveVideo, &value,
+                     &mandatory_constraints_satisfied)) {
+    offer_answer_options->offer_to_receive_video =
+        value ? PeerConnectionInterface::RTCOfferAnswerOptions::
+                    kOfferToReceiveMediaTrue
+              : 0;
+  }
+  if (FindConstraint(constraints,
+                     MediaConstraintsInterface::kVoiceActivityDetection, &value,
+                     &mandatory_constraints_satisfied)) {
+    offer_answer_options->voice_activity_detection = value;
+  }
+  if (FindConstraint(constraints, MediaConstraintsInterface::kUseRtpMux, &value,
+                     &mandatory_constraints_satisfied)) {
+    offer_answer_options->use_rtp_mux = value;
+  }
+  if (FindConstraint(constraints, MediaConstraintsInterface::kIceRestart,
+                     &value, &mandatory_constraints_satisfied)) {
+    offer_answer_options->ice_restart = value;
+  }
+
+  int layers;
+  if (FindConstraint(constraints,
+                     MediaConstraintsInterface::kNumSimulcastLayers,
+                     &layers, &mandatory_constraints_satisfied)) {
+    offer_answer_options->num_simulcast_layers = layers;
+  }
+
+  return mandatory_constraints_satisfied == constraints->GetMandatory().size();
+}
+
 }  // namespace webrtc
diff --git a/api/mediaconstraintsinterface.h b/api/mediaconstraintsinterface.h
index 54ab706..c6a914a 100644
--- a/api/mediaconstraintsinterface.h
+++ b/api/mediaconstraintsinterface.h
@@ -13,9 +13,10 @@
 // http://www.w3.org/TR/mediacapture-streams/#mediastreamconstraints and also
 // used in WebRTC: http://dev.w3.org/2011/webrtc/editor/webrtc.html#constraints.
 
-// This interface is being deprecated in Chrome, and may be removed
-// from WebRTC too.
-// https://bugs.chromium.org/p/webrtc/issues/detail?id=5617
+// Implementation of the w3c constraints spec is the responsibility of the
+// browser. Chrome no longer uses the constraints api declared here, and it will
+// be removed from WebRTC.
+// https://bugs.chromium.org/p/webrtc/issues/detail?id=9239
 
 #ifndef API_MEDIACONSTRAINTSINTERFACE_H_
 #define API_MEDIACONSTRAINTSINTERFACE_H_
@@ -72,7 +73,6 @@
   static const char kExperimentalAutoGainControl[];   // googAutoGainControl2
   static const char kNoiseSuppression[];              // googNoiseSuppression
   static const char kExperimentalNoiseSuppression[];  // googNoiseSuppression2
-  static const char kIntelligibilityEnhancer[];       // intelligibilityEnhancer
   static const char kHighpassFilter[];                // googHighpassFilter
   static const char kTypingNoiseDetection[];  // googTypingNoiseDetection
   static const char kAudioMirroring[];        // googAudioMirroring
@@ -118,6 +118,11 @@
   // stripped by Chrome before passed down to Libjingle.
   static const char kInternalConstraintPrefix[];
 
+  // Specifies number of simulcast layers for all video tracks
+  // with a Plan B offer/answer
+  // (see RTCOfferAnswerOptions::num_simulcast_layers).
+  static const char kNumSimulcastLayers[];
+
   virtual ~MediaConstraintsInterface() = default;
 
   virtual const Constraints& GetMandatory() const = 0;
@@ -144,6 +149,10 @@
     const MediaConstraintsInterface* constraints,
     cricket::AudioOptions* options);
 
+bool CopyConstraintsIntoOfferAnswerOptions(
+    const MediaConstraintsInterface* constraints,
+    PeerConnectionInterface::RTCOfferAnswerOptions* offer_answer_options);
+
 }  // namespace webrtc
 
 #endif  // API_MEDIACONSTRAINTSINTERFACE_H_
diff --git a/api/peerconnectionfactoryproxy.h b/api/peerconnectionfactoryproxy.h
index db52083..d885cc1 100644
--- a/api/peerconnectionfactoryproxy.h
+++ b/api/peerconnectionfactoryproxy.h
@@ -31,13 +31,6 @@
 // removed.
 using PeerConnectionFactoryInterface::CreateVideoSource;
 PROXY_METHOD1(void, SetOptions, const Options&)
-PROXY_METHOD5(rtc::scoped_refptr<PeerConnectionInterface>,
-              CreatePeerConnection,
-              const PeerConnectionInterface::RTCConfiguration&,
-              const MediaConstraintsInterface*,
-              std::unique_ptr<cricket::PortAllocator>,
-              std::unique_ptr<rtc::RTCCertificateGeneratorInterface>,
-              PeerConnectionObserver*);
 PROXY_METHOD4(rtc::scoped_refptr<PeerConnectionInterface>,
               CreatePeerConnection,
               const PeerConnectionInterface::RTCConfiguration&,
diff --git a/api/peerconnectioninterface.cc b/api/peerconnectioninterface.cc
new file mode 100644
index 0000000..05aa53f
--- /dev/null
+++ b/api/peerconnectioninterface.cc
@@ -0,0 +1,250 @@
+/*
+ *  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 "api/peerconnectioninterface.h"
+
+namespace webrtc {
+
+PeerConnectionInterface::IceServer::IceServer() = default;
+PeerConnectionInterface::IceServer::IceServer(const IceServer& rhs) = default;
+PeerConnectionInterface::IceServer::~IceServer() = default;
+
+PeerConnectionInterface::RTCConfiguration::RTCConfiguration() = default;
+
+PeerConnectionInterface::RTCConfiguration::RTCConfiguration(
+    const RTCConfiguration& rhs) = default;
+
+PeerConnectionInterface::RTCConfiguration::RTCConfiguration(
+    RTCConfigurationType type) {
+  if (type == RTCConfigurationType::kAggressive) {
+    // These parameters are also defined in Java and IOS configurations,
+    // so their values may be overwritten by the Java or IOS configuration.
+    bundle_policy = kBundlePolicyMaxBundle;
+    rtcp_mux_policy = kRtcpMuxPolicyRequire;
+    ice_connection_receiving_timeout = kAggressiveIceConnectionReceivingTimeout;
+
+    // These parameters are not defined in Java or IOS configuration,
+    // so their values will not be overwritten.
+    enable_ice_renomination = true;
+    redetermine_role_on_ice_restart = false;
+  }
+}
+
+PeerConnectionInterface::RTCConfiguration::~RTCConfiguration() = default;
+
+RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>>
+PeerConnectionInterface::AddTrack(
+    rtc::scoped_refptr<MediaStreamTrackInterface> track,
+    const std::vector<std::string>& stream_ids) {
+  return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
+}
+
+bool PeerConnectionInterface::RemoveTrack(RtpSenderInterface* sender) {
+  return RemoveTrackNew(sender).ok();
+}
+
+RTCError PeerConnectionInterface::RemoveTrackNew(
+    rtc::scoped_refptr<RtpSenderInterface> sender) {
+  return RTCError(RemoveTrack(sender) ? RTCErrorType::NONE
+                                      : RTCErrorType::INTERNAL_ERROR);
+}
+
+RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
+PeerConnectionInterface::AddTransceiver(
+    rtc::scoped_refptr<MediaStreamTrackInterface> track) {
+  return RTCError(RTCErrorType::INTERNAL_ERROR, "not implemented");
+}
+
+RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
+PeerConnectionInterface::AddTransceiver(
+    rtc::scoped_refptr<MediaStreamTrackInterface> track,
+    const RtpTransceiverInit& init) {
+  return RTCError(RTCErrorType::INTERNAL_ERROR, "not implemented");
+}
+
+RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
+PeerConnectionInterface::AddTransceiver(cricket::MediaType media_type) {
+  return RTCError(RTCErrorType::INTERNAL_ERROR, "not implemented");
+}
+
+RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
+PeerConnectionInterface::AddTransceiver(cricket::MediaType media_type,
+                                        const RtpTransceiverInit& init) {
+  return RTCError(RTCErrorType::INTERNAL_ERROR, "not implemented");
+}
+
+rtc::scoped_refptr<RtpSenderInterface> PeerConnectionInterface::CreateSender(
+    const std::string& kind,
+    const std::string& stream_id) {
+  return rtc::scoped_refptr<RtpSenderInterface>();
+}
+
+std::vector<rtc::scoped_refptr<RtpSenderInterface>>
+PeerConnectionInterface::GetSenders() const {
+  return std::vector<rtc::scoped_refptr<RtpSenderInterface>>();
+}
+
+std::vector<rtc::scoped_refptr<RtpReceiverInterface>>
+PeerConnectionInterface::GetReceivers() const {
+  return std::vector<rtc::scoped_refptr<RtpReceiverInterface>>();
+}
+
+std::vector<rtc::scoped_refptr<RtpTransceiverInterface>>
+PeerConnectionInterface::GetTransceivers() const {
+  return std::vector<rtc::scoped_refptr<RtpTransceiverInterface>>();
+}
+
+const SessionDescriptionInterface*
+PeerConnectionInterface::current_local_description() const {
+  return nullptr;
+}
+
+const SessionDescriptionInterface*
+PeerConnectionInterface::current_remote_description() const {
+  return nullptr;
+}
+
+const SessionDescriptionInterface*
+PeerConnectionInterface::pending_local_description() const {
+  return nullptr;
+}
+
+const SessionDescriptionInterface*
+PeerConnectionInterface::pending_remote_description() const {
+  return nullptr;
+}
+
+PeerConnectionInterface::RTCConfiguration
+PeerConnectionInterface::GetConfiguration() {
+  return PeerConnectionInterface::RTCConfiguration();
+}
+
+bool PeerConnectionInterface::SetConfiguration(
+    const PeerConnectionInterface::RTCConfiguration& config,
+    RTCError* error) {
+  return false;
+}
+
+bool PeerConnectionInterface::SetConfiguration(
+    const PeerConnectionInterface::RTCConfiguration& config) {
+  return false;
+}
+
+bool PeerConnectionInterface::RemoveIceCandidates(
+    const std::vector<cricket::Candidate>& candidates) {
+  return false;
+}
+
+RTCError PeerConnectionInterface::SetBitrate(const BitrateSettings& bitrate) {
+  BitrateParameters bitrate_parameters;
+  bitrate_parameters.min_bitrate_bps = bitrate.min_bitrate_bps;
+  bitrate_parameters.current_bitrate_bps = bitrate.start_bitrate_bps;
+  bitrate_parameters.max_bitrate_bps = bitrate.max_bitrate_bps;
+  return SetBitrate(bitrate_parameters);
+}
+
+RTCError PeerConnectionInterface::SetBitrate(
+    const BitrateParameters& bitrate_parameters) {
+  BitrateSettings bitrate;
+  bitrate.min_bitrate_bps = bitrate_parameters.min_bitrate_bps;
+  bitrate.start_bitrate_bps = bitrate_parameters.current_bitrate_bps;
+  bitrate.max_bitrate_bps = bitrate_parameters.max_bitrate_bps;
+  return SetBitrate(bitrate);
+}
+
+bool PeerConnectionInterface::StartRtcEventLog(rtc::PlatformFile file,
+                                               int64_t max_size_bytes) {
+  return false;
+}
+
+bool PeerConnectionInterface::StartRtcEventLog(
+    std::unique_ptr<RtcEventLogOutput> output,
+    int64_t output_period_ms) {
+  return false;
+}
+
+PeerConnectionInterface::BitrateParameters::BitrateParameters() = default;
+
+PeerConnectionInterface::BitrateParameters::~BitrateParameters() = default;
+
+PeerConnectionDependencies::PeerConnectionDependencies(
+    PeerConnectionObserver* observer_in)
+    : observer(observer_in) {}
+
+PeerConnectionDependencies::PeerConnectionDependencies(
+    PeerConnectionDependencies&&) = default;
+
+PeerConnectionDependencies::~PeerConnectionDependencies() = default;
+
+PeerConnectionFactoryDependencies::PeerConnectionFactoryDependencies() =
+    default;
+
+PeerConnectionFactoryDependencies::PeerConnectionFactoryDependencies(
+    PeerConnectionFactoryDependencies&&) = default;
+
+PeerConnectionFactoryDependencies::~PeerConnectionFactoryDependencies() =
+    default;
+
+rtc::scoped_refptr<PeerConnectionInterface>
+PeerConnectionFactoryInterface::CreatePeerConnection(
+    const PeerConnectionInterface::RTCConfiguration& configuration,
+    const MediaConstraintsInterface* constraints,
+    std::unique_ptr<cricket::PortAllocator> allocator,
+    std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
+    PeerConnectionObserver* observer) {
+  return nullptr;
+}
+
+rtc::scoped_refptr<PeerConnectionInterface>
+PeerConnectionFactoryInterface::CreatePeerConnection(
+    const PeerConnectionInterface::RTCConfiguration& configuration,
+    std::unique_ptr<cricket::PortAllocator> allocator,
+    std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
+    PeerConnectionObserver* observer) {
+  return nullptr;
+}
+
+rtc::scoped_refptr<PeerConnectionInterface>
+PeerConnectionFactoryInterface::CreatePeerConnection(
+    const PeerConnectionInterface::RTCConfiguration& configuration,
+    PeerConnectionDependencies dependencies) {
+  return nullptr;
+}
+
+RtpCapabilities PeerConnectionFactoryInterface::GetRtpSenderCapabilities(
+    cricket::MediaType kind) const {
+  return {};
+}
+
+RtpCapabilities PeerConnectionFactoryInterface::GetRtpReceiverCapabilities(
+    cricket::MediaType kind) const {
+  return {};
+}
+
+rtc::scoped_refptr<VideoTrackSourceInterface>
+PeerConnectionFactoryInterface::CreateVideoSource(
+    std::unique_ptr<cricket::VideoCapturer> capturer) {
+  return nullptr;
+}
+
+rtc::scoped_refptr<VideoTrackSourceInterface>
+PeerConnectionFactoryInterface::CreateVideoSource(
+    std::unique_ptr<cricket::VideoCapturer> capturer,
+    const MediaConstraintsInterface* constraints) {
+  return nullptr;
+}
+
+rtc::scoped_refptr<VideoTrackSourceInterface>
+PeerConnectionFactoryInterface::CreateVideoSource(
+    cricket::VideoCapturer* capturer) {
+  return CreateVideoSource(std::unique_ptr<cricket::VideoCapturer>(capturer));
+}
+
+}  // namespace webrtc
diff --git a/api/peerconnectioninterface.h b/api/peerconnectioninterface.h
index 90a99a6..2b94ee8 100644
--- a/api/peerconnectioninterface.h
+++ b/api/peerconnectioninterface.h
@@ -72,6 +72,7 @@
 #include <utility>
 #include <vector>
 
+#include "api/asyncresolverfactory.h"
 #include "api/audio/audio_mixer.h"
 #include "api/audio_codecs/audio_decoder_factory.h"
 #include "api/audio_codecs/audio_encoder_factory.h"
@@ -102,6 +103,7 @@
 // TODO(bugs.webrtc.org/7447): We plan to provide a way to let applications
 // inject a PacketSocketFactory and/or NetworkManager, and not expose
 // PortAllocator in the PeerConnection api.
+#include "media/base/mediaengine.h"  // nogncheck
 #include "p2p/base/portallocator.h"  // nogncheck
 // TODO(nisse): The interface for bitrate allocation strategy belongs in api/.
 #include "rtc_base/bitrateallocationstrategy.h"
@@ -119,7 +121,6 @@
 }  // namespace rtc
 
 namespace cricket {
-class MediaEngineInterface;
 class WebRtcVideoDecoderFactory;
 class WebRtcVideoEncoderFactory;
 }  // namespace cricket
@@ -144,7 +145,7 @@
 
  protected:
   // Dtor protected as objects shouldn't be deleted via this interface.
-  ~StreamCollectionInterface() {}
+  ~StreamCollectionInterface() override = default;
 };
 
 class StatsObserver : public rtc::RefCountInterface {
@@ -152,7 +153,7 @@
   virtual void OnComplete(const StatsReports& reports) = 0;
 
  protected:
-  virtual ~StatsObserver() {}
+  ~StatsObserver() override = default;
 };
 
 enum class SdpSemantics { kPlanB, kUnifiedPlan };
@@ -198,6 +199,10 @@
   };
 
   struct IceServer {
+    IceServer();
+    IceServer(const IceServer&);
+    ~IceServer();
+
     // TODO(jbauch): Remove uri when all code using it has switched to urls.
     // List of URIs associated with this server. Valid formats are described
     // in RFC7064 and RFC7065, and more may be added in the future. The "host"
@@ -284,22 +289,10 @@
     // methods for all settings which are of interest to applications,
     // Chrome in particular.
 
-    RTCConfiguration() = default;
-    explicit RTCConfiguration(RTCConfigurationType type) {
-      if (type == RTCConfigurationType::kAggressive) {
-        // These parameters are also defined in Java and IOS configurations,
-        // so their values may be overwritten by the Java or IOS configuration.
-        bundle_policy = kBundlePolicyMaxBundle;
-        rtcp_mux_policy = kRtcpMuxPolicyRequire;
-        ice_connection_receiving_timeout =
-            kAggressiveIceConnectionReceivingTimeout;
-
-        // These parameters are not defined in Java or IOS configuration,
-        // so their values will not be overwritten.
-        enable_ice_renomination = true;
-        redetermine_role_on_ice_restart = false;
-      }
-    }
+    RTCConfiguration();
+    RTCConfiguration(const RTCConfiguration&);
+    explicit RTCConfiguration(RTCConfigurationType type);
+    ~RTCConfiguration();
 
     bool operator==(const RTCConfiguration& o) const;
     bool operator!=(const RTCConfiguration& o) const;
@@ -603,6 +596,9 @@
     // confused with RTCP mux (multiplexing RTP and RTCP together).
     bool use_rtp_mux = true;
 
+    // This will apply to all video tracks with a Plan B SDP offer/answer.
+    int num_simulcast_layers = 1;
+
     RTCOfferAnswerOptions() = default;
 
     RTCOfferAnswerOptions(int offer_to_receive_video,
@@ -668,11 +664,25 @@
   // - INVALID_STATE: The PeerConnection is closed.
   virtual RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> AddTrack(
       rtc::scoped_refptr<MediaStreamTrackInterface> track,
-      const std::vector<std::string>& stream_ids) = 0;
+      const std::vector<std::string>& stream_ids);
 
   // Remove an RtpSender from this PeerConnection.
   // Returns true on success.
-  virtual bool RemoveTrack(RtpSenderInterface* sender) = 0;
+  // TODO(steveanton): Replace with signature that returns RTCError.
+  virtual bool RemoveTrack(RtpSenderInterface* sender);
+
+  // Plan B semantics: Removes the RtpSender from this PeerConnection.
+  // Unified Plan semantics: Stop sending on the RtpSender and mark the
+  // corresponding RtpTransceiver direction as no longer sending.
+  //
+  // Errors:
+  // - INVALID_PARAMETER: |sender| is null or (Plan B only) the sender is not
+  //       associated with this PeerConnection.
+  // - INVALID_STATE: PeerConnection is closed.
+  // TODO(bugs.webrtc.org/9534): Rename to RemoveTrack once the other signature
+  // is removed.
+  virtual RTCError RemoveTrackNew(
+      rtc::scoped_refptr<RtpSenderInterface> sender);
 
   // AddTransceiver creates a new RtpTransceiver and adds it to the set of
   // transceivers. Adding a transceiver will cause future calls to CreateOffer
@@ -701,14 +711,10 @@
   // Errors:
   // - INVALID_PARAMETER: |track| is null.
   virtual RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
-  AddTransceiver(rtc::scoped_refptr<MediaStreamTrackInterface> track) {
-    return RTCError(RTCErrorType::INTERNAL_ERROR, "not implemented");
-  }
+  AddTransceiver(rtc::scoped_refptr<MediaStreamTrackInterface> track);
   virtual RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
   AddTransceiver(rtc::scoped_refptr<MediaStreamTrackInterface> track,
-                 const RtpTransceiverInit& init) {
-    return RTCError(RTCErrorType::INTERNAL_ERROR, "not implemented");
-  }
+                 const RtpTransceiverInit& init);
 
   // Adds a transceiver with the given kind. Can either be MEDIA_TYPE_AUDIO or
   // MEDIA_TYPE_VIDEO.
@@ -716,14 +722,9 @@
   // - INVALID_PARAMETER: |media_type| is not MEDIA_TYPE_AUDIO or
   //                      MEDIA_TYPE_VIDEO.
   virtual RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
-  AddTransceiver(cricket::MediaType media_type) {
-    return RTCError(RTCErrorType::INTERNAL_ERROR, "not implemented");
-  }
+  AddTransceiver(cricket::MediaType media_type);
   virtual RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
-  AddTransceiver(cricket::MediaType media_type,
-                 const RtpTransceiverInit& init) {
-    return RTCError(RTCErrorType::INTERNAL_ERROR, "not implemented");
-  }
+  AddTransceiver(cricket::MediaType media_type, const RtpTransceiverInit& init);
 
   // TODO(deadbeef): Make these pure virtual once all subclasses implement them.
 
@@ -743,9 +744,7 @@
   // AddTransceiver instead.
   virtual rtc::scoped_refptr<RtpSenderInterface> CreateSender(
       const std::string& kind,
-      const std::string& stream_id) {
-    return rtc::scoped_refptr<RtpSenderInterface>();
-  }
+      const std::string& stream_id);
 
   // If Plan B semantics are specified, gets all RtpSenders, created either
   // through AddStream, AddTrack, or CreateSender. All senders of a specific
@@ -754,9 +753,7 @@
   // If Unified Plan semantics are specified, gets the RtpSender for each
   // RtpTransceiver.
   virtual std::vector<rtc::scoped_refptr<RtpSenderInterface>> GetSenders()
-      const {
-    return std::vector<rtc::scoped_refptr<RtpSenderInterface>>();
-  }
+      const;
 
   // If Plan B semantics are specified, gets all RtpReceivers created when a
   // remote description is applied. All receivers of a specific media type share
@@ -767,9 +764,7 @@
   // If Unified Plan semantics are specified, gets the RtpReceiver for each
   // RtpTransceiver.
   virtual std::vector<rtc::scoped_refptr<RtpReceiverInterface>> GetReceivers()
-      const {
-    return std::vector<rtc::scoped_refptr<RtpReceiverInterface>>();
-  }
+      const;
 
   // Get all RtpTransceivers, created either through AddTransceiver, AddTrack or
   // by a remote description applied with SetRemoteDescription.
@@ -777,9 +772,7 @@
   // Note: This method is only available when Unified Plan is enabled (see
   // RTCConfiguration).
   virtual std::vector<rtc::scoped_refptr<RtpTransceiverInterface>>
-  GetTransceivers() const {
-    return {};
-  }
+  GetTransceivers() const;
 
   // The legacy non-compliant GetStats() API. This correspond to the
   // callback-based version of getStats() in JavaScript. The returned metrics
@@ -844,44 +837,24 @@
 
   // A "current" description the one currently negotiated from a complete
   // offer/answer exchange.
-  virtual const SessionDescriptionInterface* current_local_description() const {
-    return nullptr;
-  }
-  virtual const SessionDescriptionInterface* current_remote_description()
-      const {
-    return nullptr;
-  }
+  virtual const SessionDescriptionInterface* current_local_description() const;
+  virtual const SessionDescriptionInterface* current_remote_description() const;
 
   // A "pending" description is one that's part of an incomplete offer/answer
   // exchange (thus, either an offer or a pranswer). Once the offer/answer
   // exchange is finished, the "pending" description will become "current".
-  virtual const SessionDescriptionInterface* pending_local_description() const {
-    return nullptr;
-  }
-  virtual const SessionDescriptionInterface* pending_remote_description()
-      const {
-    return nullptr;
-  }
+  virtual const SessionDescriptionInterface* pending_local_description() const;
+  virtual const SessionDescriptionInterface* pending_remote_description() const;
 
   // Create a new offer.
   // The CreateSessionDescriptionObserver callback will be called when done.
   virtual void CreateOffer(CreateSessionDescriptionObserver* observer,
-                           const MediaConstraintsInterface* constraints) {}
-
-  // TODO(jiayl): remove the default impl and the old interface when chromium
-  // code is updated.
-  virtual void CreateOffer(CreateSessionDescriptionObserver* observer,
-                           const RTCOfferAnswerOptions& options) {}
+                           const RTCOfferAnswerOptions& options) = 0;
 
   // Create an answer to an offer.
   // The CreateSessionDescriptionObserver callback will be called when done.
   virtual void CreateAnswer(CreateSessionDescriptionObserver* observer,
-                            const RTCOfferAnswerOptions& options) {}
-  // Deprecated - use version above.
-  // TODO(hta): Remove and remove default implementations when all callers
-  // are updated.
-  virtual void CreateAnswer(CreateSessionDescriptionObserver* observer,
-                            const MediaConstraintsInterface* constraints) {}
+                            const RTCOfferAnswerOptions& options) = 0;
 
   // Sets the local session description.
   // The PeerConnection takes the ownership of |desc| even if it fails.
@@ -903,9 +876,7 @@
 
   // TODO(deadbeef): Make this pure virtual once all Chrome subclasses of
   // PeerConnectionInterface implement it.
-  virtual PeerConnectionInterface::RTCConfiguration GetConfiguration() {
-    return PeerConnectionInterface::RTCConfiguration();
-  }
+  virtual PeerConnectionInterface::RTCConfiguration GetConfiguration();
 
   // Sets the PeerConnection's global configuration to |config|.
   //
@@ -932,15 +903,12 @@
   // PeerConnectionInterface implement it.
   virtual bool SetConfiguration(
       const PeerConnectionInterface::RTCConfiguration& config,
-      RTCError* error) {
-    return false;
-  }
+      RTCError* error);
+
   // Version without error output param for backwards compatibility.
   // TODO(deadbeef): Remove once chromium is updated.
   virtual bool SetConfiguration(
-      const PeerConnectionInterface::RTCConfiguration& config) {
-    return false;
-  }
+      const PeerConnectionInterface::RTCConfiguration& config);
 
   // Provides a remote candidate to the ICE Agent.
   // A copy of the |candidate| will be created and added to the remote
@@ -952,21 +920,13 @@
   // continual gathering, to avoid an ever-growing list of candidates as
   // networks come and go.
   virtual bool RemoveIceCandidates(
-      const std::vector<cricket::Candidate>& candidates) {
-    return false;
-  }
-
-  // Register a metric observer (used by chromium). It's reference counted, and
-  // this method takes a reference. RegisterUMAObserver(nullptr) will release
-  // the reference.
-  // TODO(deadbeef): Take argument as scoped_refptr?
-  //
-  // This method is soon to be deprecated. This no-op default implementation
-  // allows the implementations of the interface to remove this method.
-  virtual void RegisterUMAObserver(UMAObserver* observer) {}
+      const std::vector<cricket::Candidate>& candidates);
 
   // 0 <= min <= current <= max should hold for set parameters.
   struct BitrateParameters {
+    BitrateParameters();
+    ~BitrateParameters();
+
     absl::optional<int> min_bitrate_bps;
     absl::optional<int> current_bitrate_bps;
     absl::optional<int> max_bitrate_bps;
@@ -978,24 +938,12 @@
   //
   // Setting |current_bitrate_bps| will reset the current bitrate estimate
   // to the provided value.
-  virtual RTCError SetBitrate(const BitrateSettings& bitrate) {
-    BitrateParameters bitrate_parameters;
-    bitrate_parameters.min_bitrate_bps = bitrate.min_bitrate_bps;
-    bitrate_parameters.current_bitrate_bps = bitrate.start_bitrate_bps;
-    bitrate_parameters.max_bitrate_bps = bitrate.max_bitrate_bps;
-    return SetBitrate(bitrate_parameters);
-  }
+  virtual RTCError SetBitrate(const BitrateSettings& bitrate);
 
   // TODO(nisse): Deprecated - use version above. These two default
   // implementations require subclasses to implement one or the other
   // of the methods.
-  virtual RTCError SetBitrate(const BitrateParameters& bitrate_parameters) {
-    BitrateSettings bitrate;
-    bitrate.min_bitrate_bps = bitrate_parameters.min_bitrate_bps;
-    bitrate.start_bitrate_bps = bitrate_parameters.current_bitrate_bps;
-    bitrate.max_bitrate_bps = bitrate_parameters.max_bitrate_bps;
-    return SetBitrate(bitrate);
-  }
+  virtual RTCError SetBitrate(const BitrateParameters& bitrate_parameters);
 
   // Sets current strategy. If not set default WebRTC allocator will be used.
   // May be changed during an active session. The strategy
@@ -1037,19 +985,14 @@
   // automatically after 10 minutes have passed, or when the StopRtcEventLog
   // function is called.
   // TODO(eladalon): Deprecate and remove this.
-  virtual bool StartRtcEventLog(rtc::PlatformFile file,
-                                int64_t max_size_bytes) {
-    return false;
-  }
+  virtual bool StartRtcEventLog(rtc::PlatformFile file, int64_t max_size_bytes);
 
   // Start RtcEventLog using an existing output-sink. Takes ownership of
   // |output| and passes it on to Call, which will take the ownership. If the
   // operation fails the output will be closed and deallocated. The event log
   // will send serialized events to the output object every |output_period_ms|.
   virtual bool StartRtcEventLog(std::unique_ptr<RtcEventLogOutput> output,
-                                int64_t output_period_ms) {
-    return false;
-  }
+                                int64_t output_period_ms);
 
   // Stops logging the RtcEventLog.
   // TODO(ivoc): Make this pure virtual when Chrome is updated.
@@ -1065,7 +1008,7 @@
 
  protected:
   // Dtor protected as objects shouldn't be deleted via this interface.
-  ~PeerConnectionInterface() {}
+  ~PeerConnectionInterface() override = default;
 };
 
 // PeerConnection callback interface, used for RTCPeerConnection events.
@@ -1149,6 +1092,14 @@
   // TODO(hbos,deadbeef): Make pure virtual when all subclasses implement it.
   virtual void OnRemoveTrack(
       rtc::scoped_refptr<RtpReceiverInterface> receiver) {}
+
+  // Called when an interesting usage is detected by WebRTC.
+  // An appropriate action is to add information about the context of the
+  // PeerConnection and write the event to some kind of "interesting events"
+  // log function.
+  // The heuristics for defining what constitutes "interesting" are
+  // implementation-defined.
+  virtual void OnInterestingUsage(int usage_pattern) {}
 };
 
 // PeerConnectionDependencies holds all of PeerConnections dependencies.
@@ -1159,19 +1110,20 @@
 // PeerConnection object to be the definitive owner of the dependencies
 // lifetime making injection safer.
 struct PeerConnectionDependencies final {
-  explicit PeerConnectionDependencies(PeerConnectionObserver* observer_in)
-      : observer(observer_in) {}
+  explicit PeerConnectionDependencies(PeerConnectionObserver* observer_in);
   // This object is not copyable or assignable.
   PeerConnectionDependencies(const PeerConnectionDependencies&) = delete;
   PeerConnectionDependencies& operator=(const PeerConnectionDependencies&) =
       delete;
   // This object is only moveable.
-  PeerConnectionDependencies(PeerConnectionDependencies&&) = default;
+  PeerConnectionDependencies(PeerConnectionDependencies&&);
   PeerConnectionDependencies& operator=(PeerConnectionDependencies&&) = default;
+  ~PeerConnectionDependencies();
   // Mandatory dependencies
   PeerConnectionObserver* observer = nullptr;
   // Optional dependencies
   std::unique_ptr<cricket::PortAllocator> allocator;
+  std::unique_ptr<webrtc::AsyncResolverFactory> async_resolver_factory;
   std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator;
   std::unique_ptr<rtc::SSLCertificateVerifier> tls_cert_verifier;
 };
@@ -1183,17 +1135,17 @@
 // connection factory to take ownership of the dependency by adding a unique_ptr
 // to this structure.
 struct PeerConnectionFactoryDependencies final {
-  PeerConnectionFactoryDependencies() = default;
+  PeerConnectionFactoryDependencies();
   // This object is not copyable or assignable.
   PeerConnectionFactoryDependencies(const PeerConnectionFactoryDependencies&) =
       delete;
   PeerConnectionFactoryDependencies& operator=(
       const PeerConnectionFactoryDependencies&) = delete;
   // This object is only moveable.
-  PeerConnectionFactoryDependencies(PeerConnectionFactoryDependencies&&) =
-      default;
+  PeerConnectionFactoryDependencies(PeerConnectionFactoryDependencies&&);
   PeerConnectionFactoryDependencies& operator=(
       PeerConnectionFactoryDependencies&&) = default;
+  ~PeerConnectionFactoryDependencies();
 
   // Optional dependencies
   rtc::Thread* network_thread = nullptr;
@@ -1264,9 +1216,7 @@
   // are updated.
   virtual rtc::scoped_refptr<PeerConnectionInterface> CreatePeerConnection(
       const PeerConnectionInterface::RTCConfiguration& configuration,
-      PeerConnectionDependencies dependencies) {
-    return nullptr;
-  }
+      PeerConnectionDependencies dependencies);
 
   // Deprecated; |allocator| and |cert_generator| may be null, in which case
   // default implementations will be used.
@@ -1281,9 +1231,8 @@
       const PeerConnectionInterface::RTCConfiguration& configuration,
       std::unique_ptr<cricket::PortAllocator> allocator,
       std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
-      PeerConnectionObserver* observer) {
-    return nullptr;
-  }
+      PeerConnectionObserver* observer);
+
   // Deprecated; should use RTCConfiguration for everything that previously
   // used constraints.
   virtual rtc::scoped_refptr<PeerConnectionInterface> CreatePeerConnection(
@@ -1291,25 +1240,19 @@
       const MediaConstraintsInterface* constraints,
       std::unique_ptr<cricket::PortAllocator> allocator,
       std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
-      PeerConnectionObserver* observer) {
-    return nullptr;
-  }
+      PeerConnectionObserver* observer);
 
   // Returns the capabilities of an RTP sender of type |kind|.
   // If for some reason you pass in MEDIA_TYPE_DATA, returns an empty structure.
   // TODO(orphis): Make pure virtual when all subclasses implement it.
   virtual RtpCapabilities GetRtpSenderCapabilities(
-      cricket::MediaType kind) const {
-    return {};
-  }
+      cricket::MediaType kind) const;
 
   // Returns the capabilities of an RTP receiver of type |kind|.
   // If for some reason you pass in MEDIA_TYPE_DATA, returns an empty structure.
   // TODO(orphis): Make pure virtual when all subclasses implement it.
   virtual RtpCapabilities GetRtpReceiverCapabilities(
-      cricket::MediaType kind) const {
-    return {};
-  }
+      cricket::MediaType kind) const;
 
   virtual rtc::scoped_refptr<MediaStreamInterface> CreateLocalMediaStream(
       const std::string& stream_id) = 0;
@@ -1327,9 +1270,7 @@
   // TODO(deadbeef): Make pure virtual once downstream mock PC factory classes
   // are updated.
   virtual rtc::scoped_refptr<VideoTrackSourceInterface> CreateVideoSource(
-      std::unique_ptr<cricket::VideoCapturer> capturer) {
-    return nullptr;
-  }
+      std::unique_ptr<cricket::VideoCapturer> capturer);
 
   // A video source creator that allows selection of resolution and frame rate.
   // |constraints| decides video resolution and frame rate but can be null.
@@ -1339,23 +1280,12 @@
   // safely be destroyed afterwards.
   virtual rtc::scoped_refptr<VideoTrackSourceInterface> CreateVideoSource(
       std::unique_ptr<cricket::VideoCapturer> capturer,
-      const MediaConstraintsInterface* constraints) {
-    return nullptr;
-  }
+      const MediaConstraintsInterface* constraints);
 
   // Deprecated; please use the versions that take unique_ptrs above.
   // TODO(deadbeef): Remove these once safe to do so.
   virtual rtc::scoped_refptr<VideoTrackSourceInterface> CreateVideoSource(
-      cricket::VideoCapturer* capturer) {
-    return CreateVideoSource(std::unique_ptr<cricket::VideoCapturer>(capturer));
-  }
-  virtual rtc::scoped_refptr<VideoTrackSourceInterface> CreateVideoSource(
-      cricket::VideoCapturer* capturer,
-      const MediaConstraintsInterface* constraints) {
-    return CreateVideoSource(std::unique_ptr<cricket::VideoCapturer>(capturer),
-                             constraints);
-  }
-
+      cricket::VideoCapturer* capturer);
   // Creates a new local VideoTrack. The same |source| can be used in several
   // tracks.
   virtual rtc::scoped_refptr<VideoTrackInterface> CreateVideoTrack(
@@ -1383,9 +1313,10 @@
   // Dtor and ctor protected as objects shouldn't be created or deleted via
   // this interface.
   PeerConnectionFactoryInterface() {}
-  ~PeerConnectionFactoryInterface() {}  // NOLINT
+  ~PeerConnectionFactoryInterface() override = default;
 };
 
+#if defined(USE_BUILTIN_SW_CODECS)
 // Create a new instance of PeerConnectionFactoryInterface.
 //
 // This method relies on the thread it's called on as the "signaling thread"
@@ -1462,6 +1393,7 @@
     std::unique_ptr<FecControllerFactoryInterface> fec_controller_factory,
     std::unique_ptr<NetworkControllerFactoryInterface>
         network_controller_factory = nullptr);
+#endif
 
 // Create a new instance of PeerConnectionFactoryInterface with optional video
 // codec factories. These video factories represents all video codecs, i.e. no
@@ -1480,6 +1412,7 @@
     rtc::scoped_refptr<AudioMixer> audio_mixer,
     rtc::scoped_refptr<AudioProcessing> audio_processing);
 
+#if defined(USE_BUILTIN_SW_CODECS)
 // Create a new instance of PeerConnectionFactoryInterface with external audio
 // mixer.
 //
@@ -1512,6 +1445,7 @@
       default_adm, audio_encoder_factory, audio_decoder_factory,
       video_encoder_factory, video_decoder_factory);
 }
+#endif
 
 // This is a lower-level version of the CreatePeerConnectionFactory functions
 // above. It's implemented in the "peerconnection" build target, whereas the
diff --git a/api/peerconnectionproxy.h b/api/peerconnectionproxy.h
index 6855975..6b66bcc 100644
--- a/api/peerconnectionproxy.h
+++ b/api/peerconnectionproxy.h
@@ -88,14 +88,6 @@
 PROXY_METHOD2(void,
               CreateOffer,
               CreateSessionDescriptionObserver*,
-              const MediaConstraintsInterface*)
-PROXY_METHOD2(void,
-              CreateAnswer,
-              CreateSessionDescriptionObserver*,
-              const MediaConstraintsInterface*)
-PROXY_METHOD2(void,
-              CreateOffer,
-              CreateSessionDescriptionObserver*,
               const RTCOfferAnswerOptions&)
 PROXY_METHOD2(void,
               CreateAnswer,
@@ -127,7 +119,6 @@
               const std::vector<cricket::Candidate>&);
 PROXY_METHOD1(void, SetAudioPlayout, bool)
 PROXY_METHOD1(void, SetAudioRecording, bool)
-PROXY_METHOD1(void, RegisterUMAObserver, UMAObserver*)
 PROXY_METHOD1(RTCError, SetBitrate, const BitrateSettings&);
 PROXY_METHOD1(void,
               SetBitrateAllocationStrategy,
diff --git a/api/rtp_headers.h b/api/rtp_headers.h
index ded6c4b..c762534 100644
--- a/api/rtp_headers.h
+++ b/api/rtp_headers.h
@@ -25,7 +25,6 @@
 #include "common_types.h"  // NOLINT(build/include)
 #include "rtc_base/checks.h"
 #include "rtc_base/deprecation.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
@@ -40,7 +39,14 @@
   // maximum length that can be encoded with one-byte header extensions.
   static constexpr size_t kMaxSize = 16;
 
-  static bool IsLegalName(rtc::ArrayView<const char> name);
+  static bool IsLegalMidName(rtc::ArrayView<const char> name);
+  static bool IsLegalRsidName(rtc::ArrayView<const char> name);
+
+  // TODO(bugs.webrtc.org/9537): Deprecate and remove when third parties have
+  // migrated to "IsLegalRsidName".
+  static bool IsLegalName(rtc::ArrayView<const char> name) {
+    return IsLegalRsidName(name);
+  }
 
   StringRtpHeaderExtension() { value_[0] = 0; }
   explicit StringRtpHeaderExtension(rtc::ArrayView<const char> value) {
diff --git a/api/rtpparameters.cc b/api/rtpparameters.cc
index 5a873de..62ca3fc 100644
--- a/api/rtpparameters.cc
+++ b/api/rtpparameters.cc
@@ -19,17 +19,18 @@
 
 const double kDefaultBitratePriority = 1.0;
 
-RtcpFeedback::RtcpFeedback() {}
+RtcpFeedback::RtcpFeedback() = default;
 RtcpFeedback::RtcpFeedback(RtcpFeedbackType type) : type(type) {}
 RtcpFeedback::RtcpFeedback(RtcpFeedbackType type,
                            RtcpFeedbackMessageType message_type)
     : type(type), message_type(message_type) {}
-RtcpFeedback::~RtcpFeedback() {}
+RtcpFeedback::RtcpFeedback(const RtcpFeedback& rhs) = default;
+RtcpFeedback::~RtcpFeedback() = default;
 
-RtpCodecCapability::RtpCodecCapability() {}
-RtpCodecCapability::~RtpCodecCapability() {}
+RtpCodecCapability::RtpCodecCapability() = default;
+RtpCodecCapability::~RtpCodecCapability() = default;
 
-RtpHeaderExtensionCapability::RtpHeaderExtensionCapability() {}
+RtpHeaderExtensionCapability::RtpHeaderExtensionCapability() = default;
 RtpHeaderExtensionCapability::RtpHeaderExtensionCapability(
     const std::string& uri)
     : uri(uri) {}
@@ -37,39 +38,46 @@
     const std::string& uri,
     int preferred_id)
     : uri(uri), preferred_id(preferred_id) {}
-RtpHeaderExtensionCapability::~RtpHeaderExtensionCapability() {}
+RtpHeaderExtensionCapability::~RtpHeaderExtensionCapability() = default;
 
-RtpExtension::RtpExtension() {}
+RtpExtension::RtpExtension() = default;
 RtpExtension::RtpExtension(const std::string& uri, int id) : uri(uri), id(id) {}
 RtpExtension::RtpExtension(const std::string& uri, int id, bool encrypt)
     : uri(uri), id(id), encrypt(encrypt) {}
-RtpExtension::~RtpExtension() {}
+RtpExtension::~RtpExtension() = default;
 
-RtpFecParameters::RtpFecParameters() {}
+RtpFecParameters::RtpFecParameters() = default;
 RtpFecParameters::RtpFecParameters(FecMechanism mechanism)
     : mechanism(mechanism) {}
 RtpFecParameters::RtpFecParameters(FecMechanism mechanism, uint32_t ssrc)
     : ssrc(ssrc), mechanism(mechanism) {}
-RtpFecParameters::~RtpFecParameters() {}
+RtpFecParameters::RtpFecParameters(const RtpFecParameters& rhs) = default;
+RtpFecParameters::~RtpFecParameters() = default;
 
-RtpRtxParameters::RtpRtxParameters() {}
+RtpRtxParameters::RtpRtxParameters() = default;
 RtpRtxParameters::RtpRtxParameters(uint32_t ssrc) : ssrc(ssrc) {}
-RtpRtxParameters::~RtpRtxParameters() {}
+RtpRtxParameters::RtpRtxParameters(const RtpRtxParameters& rhs) = default;
+RtpRtxParameters::~RtpRtxParameters() = default;
 
-RtpEncodingParameters::RtpEncodingParameters() {}
-RtpEncodingParameters::~RtpEncodingParameters() {}
+RtpEncodingParameters::RtpEncodingParameters() = default;
+RtpEncodingParameters::RtpEncodingParameters(const RtpEncodingParameters& rhs) =
+    default;
+RtpEncodingParameters::~RtpEncodingParameters() = default;
 
-RtpCodecParameters::RtpCodecParameters() {}
-RtpCodecParameters::~RtpCodecParameters() {}
+RtpCodecParameters::RtpCodecParameters() = default;
+RtpCodecParameters::RtpCodecParameters(const RtpCodecParameters& rhs) = default;
+RtpCodecParameters::~RtpCodecParameters() = default;
 
-RtpCapabilities::RtpCapabilities() {}
-RtpCapabilities::~RtpCapabilities() {}
+RtpCapabilities::RtpCapabilities() = default;
+RtpCapabilities::~RtpCapabilities() = default;
 
-RtcpParameters::RtcpParameters() {}
-RtcpParameters::~RtcpParameters() {}
+RtcpParameters::RtcpParameters() = default;
+RtcpParameters::RtcpParameters(const RtcpParameters& rhs) = default;
+RtcpParameters::~RtcpParameters() = default;
 
-RtpParameters::RtpParameters() {}
-RtpParameters::~RtpParameters() {}
+RtpParameters::RtpParameters() = default;
+RtpParameters::RtpParameters(const RtpParameters& rhs) = default;
+RtpParameters::~RtpParameters() = default;
 
 std::string RtpExtension::ToString() const {
   char buf[256];
diff --git a/api/rtpparameters.h b/api/rtpparameters.h
index ba318ca..9a29c08 100644
--- a/api/rtpparameters.h
+++ b/api/rtpparameters.h
@@ -100,6 +100,7 @@
   RtcpFeedback();
   explicit RtcpFeedback(RtcpFeedbackType type);
   RtcpFeedback(RtcpFeedbackType type, RtcpFeedbackMessageType message_type);
+  RtcpFeedback(const RtcpFeedback&);
   ~RtcpFeedback();
 
   bool operator==(const RtcpFeedback& o) const {
@@ -321,6 +322,7 @@
   RtpFecParameters();
   explicit RtpFecParameters(FecMechanism mechanism);
   RtpFecParameters(FecMechanism mechanism, uint32_t ssrc);
+  RtpFecParameters(const RtpFecParameters&);
   ~RtpFecParameters();
 
   bool operator==(const RtpFecParameters& o) const {
@@ -337,6 +339,7 @@
   // Constructors for convenience.
   RtpRtxParameters();
   explicit RtpRtxParameters(uint32_t ssrc);
+  RtpRtxParameters(const RtpRtxParameters&);
   ~RtpRtxParameters();
 
   bool operator==(const RtpRtxParameters& o) const { return ssrc == o.ssrc; }
@@ -345,6 +348,7 @@
 
 struct RtpEncodingParameters {
   RtpEncodingParameters();
+  RtpEncodingParameters(const RtpEncodingParameters&);
   ~RtpEncodingParameters();
 
   // If unset, a value is chosen by the implementation.
@@ -460,6 +464,7 @@
 
 struct RtpCodecParameters {
   RtpCodecParameters();
+  RtpCodecParameters(const RtpCodecParameters&);
   ~RtpCodecParameters();
 
   // Build MIME "type/subtype" string from |name| and |kind|.
@@ -545,6 +550,7 @@
 
 struct RtcpParameters final {
   RtcpParameters();
+  RtcpParameters(const RtcpParameters&);
   ~RtcpParameters();
 
   // The SSRC to be used in the "SSRC of packet sender" field. If not set, one
@@ -579,6 +585,7 @@
 
 struct RtpParameters {
   RtpParameters();
+  RtpParameters(const RtpParameters&);
   ~RtpParameters();
 
   // Used when calling getParameters/setParameters with a PeerConnection
@@ -602,7 +609,9 @@
   // abstraction on which RTCP parameters are set.
   RtcpParameters rtcp;
 
-  // TODO(deadbeef): Not implemented.
+  // When bandwidth is constrained and the RtpSender needs to choose between
+  // degrading resolution or degrading framerate, degradationPreference
+  // indicates which is preferred. Only for video tracks.
   DegradationPreference degradation_preference =
       DegradationPreference::BALANCED;
 
diff --git a/api/rtpreceiverinterface.cc b/api/rtpreceiverinterface.cc
index fcdca69..216ed2e 100644
--- a/api/rtpreceiverinterface.cc
+++ b/api/rtpreceiverinterface.cc
@@ -45,4 +45,12 @@
   return {};
 }
 
+void RtpReceiverInterface::SetFrameDecryptor(
+    rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor) {}
+
+rtc::scoped_refptr<FrameDecryptorInterface>
+RtpReceiverInterface::GetFrameDecryptor() const {
+  return nullptr;
+}
+
 }  // namespace webrtc
diff --git a/api/rtpreceiverinterface.h b/api/rtpreceiverinterface.h
index b2499b4..266f6ac 100644
--- a/api/rtpreceiverinterface.h
+++ b/api/rtpreceiverinterface.h
@@ -17,6 +17,7 @@
 #include <string>
 #include <vector>
 
+#include "api/crypto/framedecryptorinterface.h"
 #include "api/mediastreaminterface.h"
 #include "api/mediatypes.h"
 #include "api/proxy.h"
@@ -124,6 +125,17 @@
   // content::FakeRtpReceiver in Chromium.
   virtual std::vector<RtpSource> GetSources() const;
 
+  // Sets a user defined frame decryptor that will decrypt the entire frame
+  // before it is sent across the network. This will decrypt the entire frame
+  // using the user provided decryption mechanism regardless of whether SRTP is
+  // enabled or not.
+  virtual void SetFrameDecryptor(
+      rtc::scoped_refptr<FrameDecryptorInterface> frame_decryptor);
+
+  // Returns a pointer to the frame decryptor set previously by the
+  // user. This can be used to update the state of the object.
+  virtual rtc::scoped_refptr<FrameDecryptorInterface> GetFrameDecryptor() const;
+
  protected:
   ~RtpReceiverInterface() override = default;
 };
@@ -142,6 +154,11 @@
 PROXY_METHOD1(bool, SetParameters, const RtpParameters&)
 PROXY_METHOD1(void, SetObserver, RtpReceiverObserverInterface*);
 PROXY_CONSTMETHOD0(std::vector<RtpSource>, GetSources);
+PROXY_METHOD1(void,
+              SetFrameDecryptor,
+              rtc::scoped_refptr<FrameDecryptorInterface>);
+PROXY_CONSTMETHOD0(rtc::scoped_refptr<FrameDecryptorInterface>,
+                   GetFrameDecryptor);
 END_PROXY_MAP()
 
 }  // namespace webrtc
diff --git a/api/rtpsenderinterface.cc b/api/rtpsenderinterface.cc
new file mode 100644
index 0000000..bbf3901
--- /dev/null
+++ b/api/rtpsenderinterface.cc
@@ -0,0 +1,23 @@
+/*
+ *  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 "api/rtpsenderinterface.h"
+
+namespace webrtc {
+
+void RtpSenderInterface::SetFrameEncryptor(
+    rtc::scoped_refptr<FrameEncryptorInterface> frame_encryptor) {}
+
+rtc::scoped_refptr<FrameEncryptorInterface>
+RtpSenderInterface::GetFrameEncryptor() const {
+  return nullptr;
+}
+
+}  // namespace webrtc
diff --git a/api/rtpsenderinterface.h b/api/rtpsenderinterface.h
index 6003aa0..96c2669 100644
--- a/api/rtpsenderinterface.h
+++ b/api/rtpsenderinterface.h
@@ -17,6 +17,7 @@
 #include <string>
 #include <vector>
 
+#include "api/crypto/frameencryptorinterface.h"
 #include "api/dtmfsenderinterface.h"
 #include "api/mediastreaminterface.h"
 #include "api/mediatypes.h"
@@ -63,8 +64,19 @@
   // Returns null for a video sender.
   virtual rtc::scoped_refptr<DtmfSenderInterface> GetDtmfSender() const = 0;
 
+  // Sets a user defined frame encryptor that will encrypt the entire frame
+  // before it is sent across the network. This will encrypt the entire frame
+  // using the user provided encryption mechanism regardless of whether SRTP is
+  // enabled or not.
+  virtual void SetFrameEncryptor(
+      rtc::scoped_refptr<FrameEncryptorInterface> frame_encryptor);
+
+  // Returns a pointer to the frame encryptor set previously by the
+  // user. This can be used to update the state of the object.
+  virtual rtc::scoped_refptr<FrameEncryptorInterface> GetFrameEncryptor() const;
+
  protected:
-  virtual ~RtpSenderInterface() {}
+  ~RtpSenderInterface() override = default;
 };
 
 // Define proxy for RtpSenderInterface.
@@ -81,6 +93,11 @@
 PROXY_METHOD0(RtpParameters, GetParameters);
 PROXY_METHOD1(RTCError, SetParameters, const RtpParameters&)
 PROXY_CONSTMETHOD0(rtc::scoped_refptr<DtmfSenderInterface>, GetDtmfSender);
+PROXY_METHOD1(void,
+              SetFrameEncryptor,
+              rtc::scoped_refptr<FrameEncryptorInterface>);
+PROXY_CONSTMETHOD0(rtc::scoped_refptr<FrameEncryptorInterface>,
+                   GetFrameEncryptor);
 END_PROXY_MAP()
 
 }  // namespace webrtc
diff --git a/api/rtptransceiverinterface.cc b/api/rtptransceiverinterface.cc
new file mode 100644
index 0000000..065ac04
--- /dev/null
+++ b/api/rtptransceiverinterface.cc
@@ -0,0 +1,26 @@
+/*
+ *  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 "api/rtptransceiverinterface.h"
+
+namespace webrtc {
+
+RtpTransceiverInit::RtpTransceiverInit() = default;
+
+RtpTransceiverInit::RtpTransceiverInit(const RtpTransceiverInit& rhs) = default;
+
+RtpTransceiverInit::~RtpTransceiverInit() = default;
+
+absl::optional<RtpTransceiverDirection>
+RtpTransceiverInterface::fired_direction() const {
+  return absl::nullopt;
+}
+
+}  // namespace webrtc
diff --git a/api/rtptransceiverinterface.h b/api/rtptransceiverinterface.h
index 26f1fdf..4c22957 100644
--- a/api/rtptransceiverinterface.h
+++ b/api/rtptransceiverinterface.h
@@ -34,6 +34,9 @@
 // PeerConnectionInterface::AddTransceiver.
 // https://w3c.github.io/webrtc-pc/#dom-rtcrtptransceiverinit
 struct RtpTransceiverInit final {
+  RtpTransceiverInit();
+  RtpTransceiverInit(const RtpTransceiverInit&);
+  ~RtpTransceiverInit();
   // Direction of the RtpTransceiver. See RtpTransceiverInterface::direction().
   RtpTransceiverDirection direction = RtpTransceiverDirection::kSendRecv;
 
@@ -112,9 +115,7 @@
   // OnAddTrack only get fired once even if the same session description is
   // applied again.
   // Exposed in the public interface for use by Chromium.
-  virtual absl::optional<RtpTransceiverDirection> fired_direction() const {
-    return absl::nullopt;
-  }
+  virtual absl::optional<RtpTransceiverDirection> fired_direction() const;
 
   // The Stop method irreversibly stops the RtpTransceiver. The sender of this
   // transceiver will no longer send, the receiver will no longer receive.
@@ -129,7 +130,7 @@
       rtc::ArrayView<RtpCodecCapability> codecs) = 0;
 
  protected:
-  virtual ~RtpTransceiverInterface() = default;
+  ~RtpTransceiverInterface() override = default;
 };
 
 }  // namespace webrtc
diff --git a/api/statstypes.cc b/api/statstypes.cc
index ceba28d..ad68894 100644
--- a/api/statstypes.cc
+++ b/api/statstypes.cc
@@ -99,7 +99,7 @@
 
   std::string ToString() const override {
     return std::string(InternalTypeToString(type_)) + kSeparator +
-           rtc::ToString<int>(id_);
+           rtc::ToString(id_);
   }
 
  protected:
@@ -165,7 +165,7 @@
     std::string ret(prefix);
     ret += content_name_;
     ret += '-';
-    ret += rtc::ToString<>(component_);
+    ret += rtc::ToString(component_);
     return ret;
   }
 
@@ -190,7 +190,7 @@
   std::string ToString() const override {
     std::string ret(ComponentId::ToString("Conn-"));
     ret += '-';
-    ret += rtc::ToString<>(index_);
+    ret += rtc::ToString(index_);
     return ret;
   }
 
diff --git a/api/transport/network_types.h b/api/transport/network_types.h
index a389716..8e9526b 100644
--- a/api/transport/network_types.h
+++ b/api/transport/network_types.h
@@ -45,6 +45,7 @@
   Timestamp at_time = Timestamp::Infinity();
   absl::optional<DataRate> min_data_rate;
   absl::optional<DataRate> max_data_rate;
+  absl::optional<DataRate> starting_rate;
 };
 
 // Send side information
@@ -62,7 +63,6 @@
   // The TargetRateConstraints are set here so they can be changed synchronously
   // when network route changes.
   TargetRateConstraints constraints;
-  absl::optional<DataRate> starting_rate;
 };
 
 struct PacedPacketInfo {
diff --git a/api/umametrics.h b/api/umametrics.h
index b999b64..88ab08c 100644
--- a/api/umametrics.h
+++ b/api/umametrics.h
@@ -17,38 +17,6 @@
 
 namespace webrtc {
 
-// Used to specify which enum counter type we're incrementing in
-// MetricsObserverInterface::IncrementEnumCounter.
-enum PeerConnectionEnumCounterType {
-  kEnumCounterAddressFamily,
-  // For the next 2 counters, we track them separately based on the "first hop"
-  // protocol used by the local candidate. "First hop" means the local candidate
-  // type in the case of non-TURN candidates, and the protocol used to connect
-  // to the TURN server in the case of TURN candidates.
-  kEnumCounterIceCandidatePairTypeUdp,
-  kEnumCounterIceCandidatePairTypeTcp,
-
-  kEnumCounterAudioSrtpCipher,
-  kEnumCounterAudioSslCipher,
-  kEnumCounterVideoSrtpCipher,
-  kEnumCounterVideoSslCipher,
-  kEnumCounterDataSrtpCipher,
-  kEnumCounterDataSslCipher,
-  kEnumCounterDtlsHandshakeError,
-  kEnumCounterIceRegathering,
-  kEnumCounterIceRestart,
-  kEnumCounterKeyProtocol,
-  kEnumCounterSdpSemanticRequested,
-  kEnumCounterSdpSemanticNegotiated,
-  kEnumCounterKeyProtocolMediaType,
-  kEnumCounterSdpFormatReceived,
-  // The next 2 counters log the value of srtp_err_status_t defined in libsrtp.
-  kEnumCounterSrtpUnprotectError,
-  kEnumCounterSrtcpUnprotectError,
-  kEnumCounterUsagePattern,
-  kPeerConnectionEnumCounterMax
-};
-
 // Currently this contains information related to WebRTC network/transport
 // information.
 
@@ -169,27 +137,19 @@
   kSdpFormatReceivedMax
 };
 
-class MetricsObserverInterface : public rtc::RefCountInterface {
- public:
-  // |type| is the type of the enum counter to be incremented. |counter|
-  // is the particular counter in that type. |counter_max| is the next sequence
-  // number after the highest counter.
-  virtual void IncrementEnumCounter(PeerConnectionEnumCounterType type,
-                                    int counter,
-                                    int counter_max) = 0;
-
-  // This is used to handle sparse counters like SSL cipher suites.
-  // TODO(guoweis): Remove the implementation once the dependency's interface
-  // definition is updated.
-  virtual void IncrementSparseEnumCounter(PeerConnectionEnumCounterType type,
-                                          int counter) = 0;
-
-  virtual void AddHistogramSample(PeerConnectionMetricsName type,
-                                  int value) = 0;
+// Metric for counting the outcome of adding an ICE candidate
+enum AddIceCandidateResult {
+  kAddIceCandidateSuccess,
+  kAddIceCandidateFailClosed,
+  kAddIceCandidateFailNoRemoteDescription,
+  kAddIceCandidateFailNullCandidate,
+  kAddIceCandidateFailNotValid,
+  kAddIceCandidateFailNotReady,
+  kAddIceCandidateFailInAddition,
+  kAddIceCandidateFailNotUsable,
+  kAddIceCandidateMax
 };
 
-typedef MetricsObserverInterface UMAObserver;
-
 }  // namespace webrtc
 
 #endif  // API_UMAMETRICS_H_
diff --git a/api/units/data_rate.cc b/api/units/data_rate.cc
index 4e31d51..9170627 100644
--- a/api/units/data_rate.cc
+++ b/api/units/data_rate.cc
@@ -20,7 +20,11 @@
   if (value.IsInfinite()) {
     sb << "inf bps";
   } else {
-    sb << value.bps() << " bps";
+    if (value.bps() == 0 || value.bps() % 1000 != 0) {
+      sb << value.bps() << " bps";
+    } else {
+      sb << value.kbps() << " kbps";
+    }
   }
   return sb.str();
 }
diff --git a/api/units/data_rate.h b/api/units/data_rate.h
index c7164e3..5c421d4 100644
--- a/api/units/data_rate.h
+++ b/api/units/data_rate.h
@@ -10,6 +10,11 @@
 
 #ifndef API_UNITS_DATA_RATE_H_
 #define API_UNITS_DATA_RATE_H_
+
+#ifdef UNIT_TEST
+#include <ostream>  // no-presubmit-check TODO(webrtc:8982)
+#endif              // UNIT_TEST
+
 #include <stdint.h>
 #include <cmath>
 #include <limits>
@@ -40,10 +45,22 @@
 class DataRate {
  public:
   DataRate() = delete;
-  static DataRate Zero() { return DataRate(0); }
-  static DataRate Infinity() {
+  static constexpr DataRate Zero() { return DataRate(0); }
+  static constexpr DataRate Infinity() {
     return DataRate(data_rate_impl::kPlusInfinityVal);
   }
+  template <int64_t bps>
+  static constexpr DataRate BitsPerSec() {
+    static_assert(bps >= 0, "");
+    static_assert(bps < data_rate_impl::kPlusInfinityVal, "");
+    return DataRate(bps);
+  }
+  template <int64_t kbps>
+  static constexpr DataRate KilobitsPerSec() {
+    static_assert(kbps >= 0, "");
+    static_assert(kbps < data_rate_impl::kPlusInfinityVal / 1000, "");
+    return DataRate(kbps * 1000);
+  }
 
   template <
       typename T,
@@ -89,56 +106,64 @@
   }
   template <typename T = int64_t>
   typename std::enable_if<std::is_integral<T>::value, T>::type kbps() const {
-    return rtc::dchecked_cast<T>((bps() + 500) / 1000);
+    RTC_DCHECK(IsFinite());
+    return rtc::dchecked_cast<T>(UnsafeKilobitsPerSec());
   }
 
   template <typename T>
-  typename std::enable_if<std::is_floating_point<T>::value, T>::type bps()
-      const {
-    if (IsInfinite()) {
-      return std::numeric_limits<T>::infinity();
-    } else {
-      return bits_per_sec_;
-    }
+  typename std::enable_if<std::is_floating_point<T>::value,
+                          T>::type constexpr bps() const {
+    return IsInfinite() ? std::numeric_limits<T>::infinity() : bits_per_sec_;
   }
   template <typename T>
-  typename std::enable_if<std::is_floating_point<T>::value, T>::type kbps()
-      const {
+  typename std::enable_if<std::is_floating_point<T>::value,
+                          T>::type constexpr kbps() const {
     return bps<T>() * 1e-3;
   }
 
-  bool IsZero() const { return bits_per_sec_ == 0; }
-  bool IsInfinite() const {
+  constexpr int64_t bps_or(int64_t fallback_value) const {
+    return IsFinite() ? bits_per_sec_ : fallback_value;
+  }
+  constexpr int64_t kbps_or(int64_t fallback_value) const {
+    return IsFinite() ? UnsafeKilobitsPerSec() : fallback_value;
+  }
+
+  constexpr bool IsZero() const { return bits_per_sec_ == 0; }
+  constexpr bool IsInfinite() const {
     return bits_per_sec_ == data_rate_impl::kPlusInfinityVal;
   }
-  bool IsFinite() const { return !IsInfinite(); }
+  constexpr bool IsFinite() const { return !IsInfinite(); }
 
-  double operator/(const DataRate& other) const {
+  constexpr double operator/(const DataRate& other) const {
     return bps<double>() / other.bps<double>();
   }
-  bool operator==(const DataRate& other) const {
+  constexpr bool operator==(const DataRate& other) const {
     return bits_per_sec_ == other.bits_per_sec_;
   }
-  bool operator!=(const DataRate& other) const {
+  constexpr bool operator!=(const DataRate& other) const {
     return bits_per_sec_ != other.bits_per_sec_;
   }
-  bool operator<=(const DataRate& other) const {
+  constexpr bool operator<=(const DataRate& other) const {
     return bits_per_sec_ <= other.bits_per_sec_;
   }
-  bool operator>=(const DataRate& other) const {
+  constexpr bool operator>=(const DataRate& other) const {
     return bits_per_sec_ >= other.bits_per_sec_;
   }
-  bool operator>(const DataRate& other) const {
+  constexpr bool operator>(const DataRate& other) const {
     return bits_per_sec_ > other.bits_per_sec_;
   }
-  bool operator<(const DataRate& other) const {
+  constexpr bool operator<(const DataRate& other) const {
     return bits_per_sec_ < other.bits_per_sec_;
   }
 
  private:
   // Bits per second used internally to simplify debugging by making the value
   // more recognizable.
-  explicit DataRate(int64_t bits_per_second) : bits_per_sec_(bits_per_second) {}
+  explicit constexpr DataRate(int64_t bits_per_second)
+      : bits_per_sec_(bits_per_second) {}
+  constexpr int64_t UnsafeKilobitsPerSec() const {
+    return (bits_per_sec_ + 500) / 1000;
+  }
   int64_t bits_per_sec_;
 };
 
@@ -177,6 +202,14 @@
 
 std::string ToString(const DataRate& value);
 
+#ifdef UNIT_TEST
+inline std::ostream& operator<<(  // no-presubmit-check TODO(webrtc:8982)
+    std::ostream& stream,         // no-presubmit-check TODO(webrtc:8982)
+    DataRate value) {
+  return stream << ToString(value);
+}
+#endif  // UNIT_TEST
+
 }  // namespace webrtc
 
 #endif  // API_UNITS_DATA_RATE_H_
diff --git a/api/units/data_rate_unittest.cc b/api/units/data_rate_unittest.cc
index 073e80e..9c91fd6 100644
--- a/api/units/data_rate_unittest.cc
+++ b/api/units/data_rate_unittest.cc
@@ -13,6 +13,23 @@
 
 namespace webrtc {
 namespace test {
+
+TEST(DataRateTest, ConstExpr) {
+  constexpr int64_t kValue = 12345;
+  constexpr DataRate kDataRateZero = DataRate::Zero();
+  constexpr DataRate kDataRateInf = DataRate::Infinity();
+  static_assert(kDataRateZero.IsZero(), "");
+  static_assert(kDataRateInf.IsInfinite(), "");
+  static_assert(kDataRateInf.bps_or(-1) == -1, "");
+  static_assert(kDataRateInf > kDataRateZero, "");
+
+  constexpr DataRate kDataRateBps = DataRate::BitsPerSec<kValue>();
+  constexpr DataRate kDataRateKbps = DataRate::KilobitsPerSec<kValue>();
+  static_assert(kDataRateBps.bps<double>() == kValue, "");
+  static_assert(kDataRateBps.bps_or(0) == kValue, "");
+  static_assert(kDataRateKbps.kbps_or(0) == kValue, "");
+}
+
 TEST(DataRateTest, GetBackSameValues) {
   const int64_t kValue = 123 * 8;
   EXPECT_EQ(DataRate::bps(kValue).bps(), kValue);
diff --git a/api/units/data_size.h b/api/units/data_size.h
index 8c35766..ac61a6f 100644
--- a/api/units/data_size.h
+++ b/api/units/data_size.h
@@ -11,6 +11,10 @@
 #ifndef API_UNITS_DATA_SIZE_H_
 #define API_UNITS_DATA_SIZE_H_
 
+#ifdef UNIT_TEST
+#include <ostream>  // no-presubmit-check TODO(webrtc:8982)
+#endif              // UNIT_TEST
+
 #include <stdint.h>
 #include <cmath>
 #include <limits>
@@ -29,10 +33,16 @@
 class DataSize {
  public:
   DataSize() = delete;
-  static DataSize Zero() { return DataSize(0); }
-  static DataSize Infinity() {
+  static constexpr DataSize Zero() { return DataSize(0); }
+  static constexpr DataSize Infinity() {
     return DataSize(data_size_impl::kPlusInfinityVal);
   }
+  template <int64_t bytes>
+  static constexpr DataSize Bytes() {
+    static_assert(bytes >= 0, "");
+    static_assert(bytes < data_size_impl::kPlusInfinityVal, "");
+    return DataSize(bytes);
+  }
 
   template <
       typename T,
@@ -64,18 +74,20 @@
   }
 
   template <typename T>
-  typename std::enable_if<std::is_floating_point<T>::value, T>::type bytes()
-      const {
-    if (IsInfinite()) {
-      return std::numeric_limits<T>::infinity();
-    } else {
-      return bytes_;
-    }
+  constexpr typename std::enable_if<std::is_floating_point<T>::value, T>::type
+  bytes() const {
+    return IsInfinite() ? std::numeric_limits<T>::infinity() : bytes_;
   }
 
-  bool IsZero() const { return bytes_ == 0; }
-  bool IsInfinite() const { return bytes_ == data_size_impl::kPlusInfinityVal; }
-  bool IsFinite() const { return !IsInfinite(); }
+  constexpr int64_t bytes_or(int64_t fallback_value) const {
+    return IsFinite() ? bytes_ : fallback_value;
+  }
+
+  constexpr bool IsZero() const { return bytes_ == 0; }
+  constexpr bool IsInfinite() const {
+    return bytes_ == data_size_impl::kPlusInfinityVal;
+  }
+  constexpr bool IsFinite() const { return !IsInfinite(); }
   DataSize operator-(const DataSize& other) const {
     return DataSize::bytes(bytes() - other.bytes());
   }
@@ -90,26 +102,30 @@
     bytes_ += other.bytes();
     return *this;
   }
-  double operator/(const DataSize& other) const {
+  constexpr double operator/(const DataSize& other) const {
     return bytes<double>() / other.bytes<double>();
   }
-  bool operator==(const DataSize& other) const {
+  constexpr bool operator==(const DataSize& other) const {
     return bytes_ == other.bytes_;
   }
-  bool operator!=(const DataSize& other) const {
+  constexpr bool operator!=(const DataSize& other) const {
     return bytes_ != other.bytes_;
   }
-  bool operator<=(const DataSize& other) const {
+  constexpr bool operator<=(const DataSize& other) const {
     return bytes_ <= other.bytes_;
   }
-  bool operator>=(const DataSize& other) const {
+  constexpr bool operator>=(const DataSize& other) const {
     return bytes_ >= other.bytes_;
   }
-  bool operator>(const DataSize& other) const { return bytes_ > other.bytes_; }
-  bool operator<(const DataSize& other) const { return bytes_ < other.bytes_; }
+  constexpr bool operator>(const DataSize& other) const {
+    return bytes_ > other.bytes_;
+  }
+  constexpr bool operator<(const DataSize& other) const {
+    return bytes_ < other.bytes_;
+  }
 
  private:
-  explicit DataSize(int64_t bytes) : bytes_(bytes) {}
+  explicit constexpr DataSize(int64_t bytes) : bytes_(bytes) {}
   int64_t bytes_;
 };
 
@@ -137,6 +153,14 @@
 
 std::string ToString(const DataSize& value);
 
+#ifdef UNIT_TEST
+inline std::ostream& operator<<(  // no-presubmit-check TODO(webrtc:8982)
+    std::ostream& stream,         // no-presubmit-check TODO(webrtc:8982)
+    DataSize value) {
+  return stream << ToString(value);
+}
+#endif  // UNIT_TEST
+
 }  // namespace webrtc
 
 #endif  // API_UNITS_DATA_SIZE_H_
diff --git a/api/units/data_size_unittest.cc b/api/units/data_size_unittest.cc
index 7747258..fe7f591 100644
--- a/api/units/data_size_unittest.cc
+++ b/api/units/data_size_unittest.cc
@@ -14,6 +14,21 @@
 namespace webrtc {
 namespace test {
 
+TEST(DataSizeTest, ConstExpr) {
+  constexpr int64_t kValue = 12345;
+  constexpr DataSize kDataSizeZero = DataSize::Zero();
+  constexpr DataSize kDataSizeInf = DataSize::Infinity();
+  static_assert(kDataSizeZero.IsZero(), "");
+  static_assert(kDataSizeInf.IsInfinite(), "");
+  static_assert(kDataSizeInf.bytes_or(-1) == -1, "");
+  static_assert(kDataSizeInf > kDataSizeZero, "");
+
+  constexpr DataSize kDataSize = DataSize::Bytes<kValue>();
+  static_assert(kDataSize.bytes_or(-1) == kValue, "");
+
+  EXPECT_EQ(kDataSize.bytes(), kValue);
+}
+
 TEST(DataSizeTest, GetBackSameValues) {
   const int64_t kValue = 123 * 8;
   EXPECT_EQ(DataSize::bytes(kValue).bytes(), kValue);
diff --git a/api/units/time_delta.cc b/api/units/time_delta.cc
index 398df77..d38387a 100644
--- a/api/units/time_delta.cc
+++ b/api/units/time_delta.cc
@@ -22,7 +22,12 @@
   } else if (value.IsMinusInfinity()) {
     sb << "-inf ms";
   } else {
-    sb << value.ms() << " ms";
+    if (value.us() == 0 || (value.us() % 1000) != 0)
+      sb << value.us() << " us";
+    else if (value.ms() % 1000 != 0)
+      sb << value.ms() << " ms";
+    else
+      sb << value.seconds() << " s";
   }
   return sb.str();
 }
diff --git a/api/units/time_delta.h b/api/units/time_delta.h
index 0f99e80..b820472 100644
--- a/api/units/time_delta.h
+++ b/api/units/time_delta.h
@@ -11,6 +11,10 @@
 #ifndef API_UNITS_TIME_DELTA_H_
 #define API_UNITS_TIME_DELTA_H_
 
+#ifdef UNIT_TEST
+#include <ostream>  // no-presubmit-check TODO(webrtc:8982)
+#endif              // UNIT_TEST
+
 #include <stdint.h>
 #include <cmath>
 #include <limits>
@@ -35,13 +39,31 @@
 class TimeDelta {
  public:
   TimeDelta() = delete;
-  static TimeDelta Zero() { return TimeDelta(0); }
-  static TimeDelta PlusInfinity() {
+  static constexpr TimeDelta Zero() { return TimeDelta(0); }
+  static constexpr TimeDelta PlusInfinity() {
     return TimeDelta(timedelta_impl::kPlusInfinityVal);
   }
-  static TimeDelta MinusInfinity() {
+  static constexpr TimeDelta MinusInfinity() {
     return TimeDelta(timedelta_impl::kMinusInfinityVal);
   }
+  template <int64_t seconds>
+  static constexpr TimeDelta Seconds() {
+    static_assert(seconds > timedelta_impl::kMinusInfinityVal / 1000000, "");
+    static_assert(seconds < timedelta_impl::kPlusInfinityVal / 1000000, "");
+    return TimeDelta(seconds * 1000000);
+  }
+  template <int64_t ms>
+  static constexpr TimeDelta Millis() {
+    static_assert(ms > timedelta_impl::kMinusInfinityVal / 1000, "");
+    static_assert(ms < timedelta_impl::kPlusInfinityVal / 1000, "");
+    return TimeDelta(ms * 1000);
+  }
+  template <int64_t us>
+  static constexpr TimeDelta Micros() {
+    static_assert(us > timedelta_impl::kMinusInfinityVal, "");
+    static_assert(us < timedelta_impl::kPlusInfinityVal, "");
+    return TimeDelta(us);
+  }
 
   template <
       typename T,
@@ -98,12 +120,13 @@
 
   template <typename T = int64_t>
   typename std::enable_if<std::is_integral<T>::value, T>::type seconds() const {
-    return rtc::dchecked_cast<T>((us() + (us() >= 0 ? 500000 : -500000)) /
-                                 1000000);
+    RTC_DCHECK(IsFinite());
+    return rtc::dchecked_cast<T>(UnsafeSeconds());
   }
   template <typename T = int64_t>
   typename std::enable_if<std::is_integral<T>::value, T>::type ms() const {
-    return rtc::dchecked_cast<T>((us() + (us() >= 0 ? 500 : -500)) / 1000);
+    RTC_DCHECK(IsFinite());
+    return rtc::dchecked_cast<T>(UnsafeMillis());
   }
   template <typename T = int64_t>
   typename std::enable_if<std::is_integral<T>::value, T>::type us() const {
@@ -118,43 +141,50 @@
   }
 
   template <typename T>
-  typename std::enable_if<std::is_floating_point<T>::value, T>::type seconds()
-      const {
+  constexpr typename std::enable_if<std::is_floating_point<T>::value, T>::type
+  seconds() const {
     return us<T>() * 1e-6;
   }
   template <typename T>
-  typename std::enable_if<std::is_floating_point<T>::value, T>::type ms()
-      const {
+  constexpr typename std::enable_if<std::is_floating_point<T>::value, T>::type
+  ms() const {
     return us<T>() * 1e-3;
   }
   template <typename T>
-  typename std::enable_if<std::is_floating_point<T>::value, T>::type us()
-      const {
-    if (IsPlusInfinity()) {
-      return std::numeric_limits<T>::infinity();
-    } else if (IsMinusInfinity()) {
-      return -std::numeric_limits<T>::infinity();
-    } else {
-      return microseconds_;
-    }
+  constexpr typename std::enable_if<std::is_floating_point<T>::value, T>::type
+  us() const {
+    return IsPlusInfinity()
+               ? std::numeric_limits<T>::infinity()
+               : IsMinusInfinity() ? -std::numeric_limits<T>::infinity()
+                                   : microseconds_;
   }
   template <typename T>
-  typename std::enable_if<std::is_floating_point<T>::value, T>::type ns()
-      const {
+  constexpr typename std::enable_if<std::is_floating_point<T>::value, T>::type
+  ns() const {
     return us<T>() * 1e3;
   }
 
+  constexpr int64_t seconds_or(int64_t fallback_value) const {
+    return IsFinite() ? UnsafeSeconds() : fallback_value;
+  }
+  constexpr int64_t ms_or(int64_t fallback_value) const {
+    return IsFinite() ? UnsafeMillis() : fallback_value;
+  }
+  constexpr int64_t us_or(int64_t fallback_value) const {
+    return IsFinite() ? microseconds_ : fallback_value;
+  }
+
   TimeDelta Abs() const { return TimeDelta::us(std::abs(us())); }
-  bool IsZero() const { return microseconds_ == 0; }
-  bool IsFinite() const { return !IsInfinite(); }
-  bool IsInfinite() const {
+  constexpr bool IsZero() const { return microseconds_ == 0; }
+  constexpr bool IsFinite() const { return !IsInfinite(); }
+  constexpr bool IsInfinite() const {
     return microseconds_ == timedelta_impl::kPlusInfinityVal ||
            microseconds_ == timedelta_impl::kMinusInfinityVal;
   }
-  bool IsPlusInfinity() const {
+  constexpr bool IsPlusInfinity() const {
     return microseconds_ == timedelta_impl::kPlusInfinityVal;
   }
-  bool IsMinusInfinity() const {
+  constexpr bool IsMinusInfinity() const {
     return microseconds_ == timedelta_impl::kMinusInfinityVal;
   }
   TimeDelta operator+(const TimeDelta& other) const {
@@ -171,30 +201,36 @@
     microseconds_ += other.us();
     return *this;
   }
-  double operator/(const TimeDelta& other) const {
+  constexpr double operator/(const TimeDelta& other) const {
     return us<double>() / other.us<double>();
   }
-  bool operator==(const TimeDelta& other) const {
+  constexpr bool operator==(const TimeDelta& other) const {
     return microseconds_ == other.microseconds_;
   }
-  bool operator!=(const TimeDelta& other) const {
+  constexpr bool operator!=(const TimeDelta& other) const {
     return microseconds_ != other.microseconds_;
   }
-  bool operator<=(const TimeDelta& other) const {
+  constexpr bool operator<=(const TimeDelta& other) const {
     return microseconds_ <= other.microseconds_;
   }
-  bool operator>=(const TimeDelta& other) const {
+  constexpr bool operator>=(const TimeDelta& other) const {
     return microseconds_ >= other.microseconds_;
   }
-  bool operator>(const TimeDelta& other) const {
+  constexpr bool operator>(const TimeDelta& other) const {
     return microseconds_ > other.microseconds_;
   }
-  bool operator<(const TimeDelta& other) const {
+  constexpr bool operator<(const TimeDelta& other) const {
     return microseconds_ < other.microseconds_;
   }
 
  private:
-  explicit TimeDelta(int64_t us) : microseconds_(us) {}
+  explicit constexpr TimeDelta(int64_t us) : microseconds_(us) {}
+  constexpr int64_t UnsafeSeconds() const {
+    return (microseconds_ + (microseconds_ >= 0 ? 500000 : -500000)) / 1000000;
+  }
+  constexpr int64_t UnsafeMillis() const {
+    return (microseconds_ + (microseconds_ >= 0 ? 500 : -500)) / 1000;
+  }
   int64_t microseconds_;
 };
 
@@ -220,8 +256,16 @@
 inline TimeDelta operator/(const TimeDelta& delta, const int64_t& scalar) {
   return TimeDelta::us(delta.us() / scalar);
 }
-
 std::string ToString(const TimeDelta& value);
+
+#ifdef UNIT_TEST
+inline std::ostream& operator<<(  // no-presubmit-check TODO(webrtc:8982)
+    std::ostream& stream,         // no-presubmit-check TODO(webrtc:8982)
+    TimeDelta value) {
+  return stream << ToString(value);
+}
+#endif  // UNIT_TEST
+
 }  // namespace webrtc
 
 #endif  // API_UNITS_TIME_DELTA_H_
diff --git a/api/units/time_delta_unittest.cc b/api/units/time_delta_unittest.cc
index 94a27f2..9eddee7 100644
--- a/api/units/time_delta_unittest.cc
+++ b/api/units/time_delta_unittest.cc
@@ -14,6 +14,26 @@
 
 namespace webrtc {
 namespace test {
+TEST(TimeDeltaTest, ConstExpr) {
+  constexpr int64_t kValue = -12345;
+  constexpr TimeDelta kTimeDeltaZero = TimeDelta::Zero();
+  constexpr TimeDelta kTimeDeltaPlusInf = TimeDelta::PlusInfinity();
+  constexpr TimeDelta kTimeDeltaMinusInf = TimeDelta::MinusInfinity();
+  static_assert(kTimeDeltaZero.IsZero(), "");
+  static_assert(kTimeDeltaPlusInf.IsPlusInfinity(), "");
+  static_assert(kTimeDeltaMinusInf.IsMinusInfinity(), "");
+  static_assert(kTimeDeltaPlusInf.ms_or(-1) == -1, "");
+
+  static_assert(kTimeDeltaPlusInf > kTimeDeltaZero, "");
+
+  constexpr TimeDelta kTimeDeltaSeconds = TimeDelta::Seconds<kValue>();
+  constexpr TimeDelta kTimeDeltaMs = TimeDelta::Millis<kValue>();
+  constexpr TimeDelta kTimeDeltaUs = TimeDelta::Micros<kValue>();
+
+  static_assert(kTimeDeltaSeconds.seconds_or(0) == kValue, "");
+  static_assert(kTimeDeltaMs.ms_or(0) == kValue, "");
+  static_assert(kTimeDeltaUs.us_or(0) == kValue, "");
+}
 
 TEST(TimeDeltaTest, GetBackSameValues) {
   const int64_t kValue = 499;
diff --git a/api/units/timestamp.cc b/api/units/timestamp.cc
index 4b2c44b..feb1447 100644
--- a/api/units/timestamp.cc
+++ b/api/units/timestamp.cc
@@ -19,7 +19,10 @@
   if (value.IsInfinite()) {
     sb << "inf ms";
   } else {
-    sb << value.ms() << " ms";
+    if (value.ms() % 1000 == 0)
+      sb << value.seconds() << " s";
+    else
+      sb << value.ms() << " ms";
   }
   return sb.str();
 }
diff --git a/api/units/timestamp.h b/api/units/timestamp.h
index a66e061..6e5e392 100644
--- a/api/units/timestamp.h
+++ b/api/units/timestamp.h
@@ -11,6 +11,10 @@
 #ifndef API_UNITS_TIMESTAMP_H_
 #define API_UNITS_TIMESTAMP_H_
 
+#ifdef UNIT_TEST
+#include <ostream>  // no-presubmit-check TODO(webrtc:8982)
+#endif              // UNIT_TEST
+
 #include <stdint.h>
 #include <limits>
 #include <string>
@@ -32,9 +36,27 @@
 class Timestamp {
  public:
   Timestamp() = delete;
-  static Timestamp Infinity() {
+  static constexpr Timestamp Infinity() {
     return Timestamp(timestamp_impl::kPlusInfinityVal);
   }
+  template <int64_t seconds>
+  static constexpr Timestamp Seconds() {
+    static_assert(seconds >= 0, "");
+    static_assert(seconds < timestamp_impl::kPlusInfinityVal / 1000000, "");
+    return Timestamp(seconds * 1000000);
+  }
+  template <int64_t ms>
+  static constexpr Timestamp Millis() {
+    static_assert(ms >= 0, "");
+    static_assert(ms < timestamp_impl::kPlusInfinityVal / 1000, "");
+    return Timestamp(ms * 1000);
+  }
+  template <int64_t us>
+  static constexpr Timestamp Micros() {
+    static_assert(us >= 0, "");
+    static_assert(us < timestamp_impl::kPlusInfinityVal, "");
+    return Timestamp(us);
+  }
 
   template <
       typename T,
@@ -92,11 +114,13 @@
 
   template <typename T = int64_t>
   typename std::enable_if<std::is_integral<T>::value, T>::type seconds() const {
-    return rtc::dchecked_cast<T>((us() + 500000) / 1000000);
+    RTC_DCHECK(IsFinite());
+    return rtc::dchecked_cast<T>(UnsafeSeconds());
   }
   template <typename T = int64_t>
   typename std::enable_if<std::is_integral<T>::value, T>::type ms() const {
-    return rtc::dchecked_cast<T>((us() + 500) / 1000);
+    RTC_DCHECK(IsFinite());
+    return rtc::dchecked_cast<T>(UnsafeMillis());
   }
   template <typename T = int64_t>
   typename std::enable_if<std::is_integral<T>::value, T>::type us() const {
@@ -105,29 +129,35 @@
   }
 
   template <typename T>
-  typename std::enable_if<std::is_floating_point<T>::value, T>::type seconds()
-      const {
+  constexpr typename std::enable_if<std::is_floating_point<T>::value, T>::type
+  seconds() const {
     return us<T>() * 1e-6;
   }
   template <typename T>
-  typename std::enable_if<std::is_floating_point<T>::value, T>::type ms()
-      const {
+  constexpr typename std::enable_if<std::is_floating_point<T>::value, T>::type
+  ms() const {
     return us<T>() * 1e-3;
   }
   template <typename T>
-  typename std::enable_if<std::is_floating_point<T>::value, T>::type us()
-      const {
-    if (IsInfinite()) {
-      return std::numeric_limits<T>::infinity();
-    } else {
-      return microseconds_;
-    }
+  constexpr typename std::enable_if<std::is_floating_point<T>::value, T>::type
+  us() const {
+    return IsInfinite() ? std::numeric_limits<T>::infinity() : microseconds_;
   }
 
-  bool IsInfinite() const {
+  constexpr int64_t seconds_or(int64_t fallback_value) const {
+    return IsFinite() ? UnsafeSeconds() : fallback_value;
+  }
+  constexpr int64_t ms_or(int64_t fallback_value) const {
+    return IsFinite() ? UnsafeMillis() : fallback_value;
+  }
+  constexpr int64_t us_or(int64_t fallback_value) const {
+    return IsFinite() ? microseconds_ : fallback_value;
+  }
+
+  constexpr bool IsInfinite() const {
     return microseconds_ == timestamp_impl::kPlusInfinityVal;
   }
-  bool IsFinite() const { return !IsInfinite(); }
+  constexpr bool IsFinite() const { return !IsInfinite(); }
   TimeDelta operator-(const Timestamp& other) const {
     return TimeDelta::us(us() - other.us());
   }
@@ -145,32 +175,46 @@
     microseconds_ += other.us();
     return *this;
   }
-  bool operator==(const Timestamp& other) const {
+  constexpr bool operator==(const Timestamp& other) const {
     return microseconds_ == other.microseconds_;
   }
-  bool operator!=(const Timestamp& other) const {
+  constexpr bool operator!=(const Timestamp& other) const {
     return microseconds_ != other.microseconds_;
   }
-  bool operator<=(const Timestamp& other) const {
+  constexpr bool operator<=(const Timestamp& other) const {
     return microseconds_ <= other.microseconds_;
   }
-  bool operator>=(const Timestamp& other) const {
+  constexpr bool operator>=(const Timestamp& other) const {
     return microseconds_ >= other.microseconds_;
   }
-  bool operator>(const Timestamp& other) const {
+  constexpr bool operator>(const Timestamp& other) const {
     return microseconds_ > other.microseconds_;
   }
-  bool operator<(const Timestamp& other) const {
+  constexpr bool operator<(const Timestamp& other) const {
     return microseconds_ < other.microseconds_;
   }
 
  private:
-  explicit Timestamp(int64_t us) : microseconds_(us) {}
+  explicit constexpr Timestamp(int64_t us) : microseconds_(us) {}
+  constexpr int64_t UnsafeSeconds() const {
+    return (microseconds_ + 500000) / 1000000;
+  }
+  constexpr int64_t UnsafeMillis() const {
+    return (microseconds_ + 500) / 1000;
+  }
   int64_t microseconds_;
 };
 
 std::string ToString(const Timestamp& value);
 
+#ifdef UNIT_TEST
+inline std::ostream& operator<<(  // no-presubmit-check TODO(webrtc:8982)
+    std::ostream& stream,         // no-presubmit-check TODO(webrtc:8982)
+    Timestamp value) {
+  return stream << ToString(value);
+}
+#endif  // UNIT_TEST
+
 }  // namespace webrtc
 
 #endif  // API_UNITS_TIMESTAMP_H_
diff --git a/api/units/timestamp_unittest.cc b/api/units/timestamp_unittest.cc
index eecfe02..db894cc 100644
--- a/api/units/timestamp_unittest.cc
+++ b/api/units/timestamp_unittest.cc
@@ -13,6 +13,27 @@
 
 namespace webrtc {
 namespace test {
+TEST(TimestampTest, ConstExpr) {
+  constexpr int64_t kValue = 12345;
+  constexpr Timestamp kTimestampInf = Timestamp::Infinity();
+  static_assert(kTimestampInf.IsInfinite(), "");
+  static_assert(kTimestampInf.ms_or(-1) == -1, "");
+
+  constexpr Timestamp kTimestampSeconds = Timestamp::Seconds<kValue>();
+  constexpr Timestamp kTimestampMs = Timestamp::Millis<kValue>();
+  constexpr Timestamp kTimestampUs = Timestamp::Micros<kValue>();
+
+  static_assert(kTimestampSeconds.seconds_or(0) == kValue, "");
+  static_assert(kTimestampMs.ms_or(0) == kValue, "");
+  static_assert(kTimestampUs.us_or(0) == kValue, "");
+
+  static_assert(kTimestampMs > kTimestampUs, "");
+
+  EXPECT_EQ(kTimestampSeconds.seconds(), kValue);
+  EXPECT_EQ(kTimestampMs.ms(), kValue);
+  EXPECT_EQ(kTimestampUs.us(), kValue);
+}
+
 TEST(TimestampTest, GetBackSameValues) {
   const int64_t kValue = 499;
   EXPECT_EQ(Timestamp::ms(kValue).ms(), kValue);
diff --git a/api/video/color_space.h b/api/video/color_space.h
index 736a170..8102647 100644
--- a/api/video/color_space.h
+++ b/api/video/color_space.h
@@ -30,27 +30,50 @@
   enum class PrimaryID {
     kInvalid,
     kBT709,
+    kBT470M,
+    kBT470BG,
     kSMPTE170M,  // Identical to BT601
     kSMPTE240M,
+    kFILM,
     kBT2020,
+    kSMPTEST428,
+    kSMPTEST431,
+    kSMPTEST432,
+    kJEDECP22,
   };
 
   enum class TransferID {
     kInvalid,
     kBT709,
+    kGAMMA22,
+    kGAMMA28,
     kSMPTE170M,
     kSMPTE240M,
-    kBT2020,
-    kBT2020_10,
+    kLINEAR,
+    kLOG,
+    kLOG_SQRT,
+    kIEC61966_2_4,
+    kBT1361_ECG,
     kIEC61966_2_1,
+    kBT2020_10,
+    kBT2020_12,
+    kSMPTEST2084,
+    kSMPTEST428,
+    kARIB_STD_B67,
   };
 
   enum class MatrixID {
     kInvalid,
+    kRGB,
     kBT709,
+    kFCC,
+    kBT470BG,
     kSMPTE170M,
     kSMPTE240M,
+    kYCOCG,
     kBT2020_NCL,
+    kBT2020_CL,
+    kSMPTE2085,
   };
 
   enum class RangeID {
diff --git a/api/video/encoded_frame.cc b/api/video/encoded_frame.cc
index f9152b2..26a794e 100644
--- a/api/video/encoded_frame.cc
+++ b/api/video/encoded_frame.cc
@@ -17,13 +17,5 @@
   return 0;
 }
 
-uint32_t EncodedFrame::Timestamp() const {
-  return timestamp;
-}
-
-void EncodedFrame::SetTimestamp(uint32_t rtp_timestamp) {
-  timestamp = rtp_timestamp;
-}
-
 }  // namespace video_coding
 }  // namespace webrtc
diff --git a/api/video/encoded_frame.h b/api/video/encoded_frame.h
index 1b0a26a..b8462c6 100644
--- a/api/video/encoded_frame.h
+++ b/api/video/encoded_frame.h
@@ -58,10 +58,6 @@
 
   virtual bool GetBitstream(uint8_t* destination) const = 0;
 
-  // The capture timestamp of this frame, using the 90 kHz RTP clock.
-  virtual uint32_t Timestamp() const;
-  virtual void SetTimestamp(uint32_t rtp_timestamp);
-
   // When this frame was received.
   virtual int64_t ReceivedTime() const = 0;
 
@@ -78,7 +74,6 @@
   bool is_keyframe() const { return num_references == 0; }
 
   VideoLayerFrameId id;
-  uint32_t timestamp = 0;
 
   // TODO(philipel): Add simple modify/access functions to prevent adding too
   // many |references|.
diff --git a/api/video/video_bitrate_allocation.h b/api/video/video_bitrate_allocation.h
index ce61734..9e2501d 100644
--- a/api/video/video_bitrate_allocation.h
+++ b/api/video/video_bitrate_allocation.h
@@ -16,7 +16,6 @@
 #include <vector>
 
 #include "absl/types/optional.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/api/video/video_bitrate_allocator.h b/api/video/video_bitrate_allocator.h
new file mode 100644
index 0000000..f85c633
--- /dev/null
+++ b/api/video/video_bitrate_allocator.h
@@ -0,0 +1,38 @@
+/*
+ *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef API_VIDEO_VIDEO_BITRATE_ALLOCATOR_H_
+#define API_VIDEO_VIDEO_BITRATE_ALLOCATOR_H_
+
+#include "api/video/video_bitrate_allocation.h"
+
+namespace webrtc {
+
+class VideoBitrateAllocator {
+ public:
+  VideoBitrateAllocator() {}
+  virtual ~VideoBitrateAllocator() {}
+
+  virtual VideoBitrateAllocation GetAllocation(uint32_t total_bitrate_bps,
+                                               uint32_t framerate) = 0;
+};
+
+class VideoBitrateAllocationObserver {
+ public:
+  VideoBitrateAllocationObserver() {}
+  virtual ~VideoBitrateAllocationObserver() {}
+
+  virtual void OnBitrateAllocationUpdated(
+      const VideoBitrateAllocation& allocation) = 0;
+};
+
+}  // namespace webrtc
+
+#endif  // API_VIDEO_VIDEO_BITRATE_ALLOCATOR_H_
diff --git a/api/video/video_bitrate_allocator_factory.h b/api/video/video_bitrate_allocator_factory.h
new file mode 100644
index 0000000..897c34f
--- /dev/null
+++ b/api/video/video_bitrate_allocator_factory.h
@@ -0,0 +1,32 @@
+/*
+ *  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_VIDEO_BITRATE_ALLOCATOR_FACTORY_H_
+#define API_VIDEO_VIDEO_BITRATE_ALLOCATOR_FACTORY_H_
+
+#include <memory>
+#include "api/video/video_bitrate_allocator.h"
+#include "api/video_codecs/video_codec.h"
+
+namespace webrtc {
+
+// A factory that creates VideoBitrateAllocator.
+// NOTE: This class is still under development and may change without notice.
+class VideoBitrateAllocatorFactory {
+ public:
+  virtual ~VideoBitrateAllocatorFactory() = default;
+  // Creates a VideoBitrateAllocator for a specific video codec.
+  virtual std::unique_ptr<VideoBitrateAllocator> CreateVideoBitrateAllocator(
+      const VideoCodec& codec) = 0;
+};
+
+}  // namespace webrtc
+
+#endif  // API_VIDEO_VIDEO_BITRATE_ALLOCATOR_FACTORY_H_
diff --git a/api/video/video_stream_encoder_create.cc b/api/video/video_stream_encoder_create.cc
new file mode 100644
index 0000000..3147d34
--- /dev/null
+++ b/api/video/video_stream_encoder_create.cc
@@ -0,0 +1,27 @@
+/*
+ *  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/video_stream_encoder_create.h"
+
+#include "absl/memory/memory.h"
+#include "video/video_stream_encoder.h"
+
+namespace webrtc {
+std::unique_ptr<VideoStreamEncoderInterface> CreateVideoStreamEncoder(
+    uint32_t number_of_cores,
+    VideoStreamEncoderObserver* encoder_stats_observer,
+    const VideoStreamEncoderSettings& settings,
+    // Deprecated, used for tests only.
+    rtc::VideoSinkInterface<VideoFrame>* pre_encode_callback) {
+  return absl::make_unique<VideoStreamEncoder>(
+      number_of_cores, encoder_stats_observer, settings, pre_encode_callback,
+      absl::make_unique<OveruseFrameDetector>(encoder_stats_observer));
+}
+}  // namespace webrtc
diff --git a/api/video/video_stream_encoder_create.h b/api/video/video_stream_encoder_create.h
new file mode 100644
index 0000000..9117273
--- /dev/null
+++ b/api/video/video_stream_encoder_create.h
@@ -0,0 +1,41 @@
+/*
+ *  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_VIDEO_STREAM_ENCODER_CREATE_H_
+#define API_VIDEO_VIDEO_STREAM_ENCODER_CREATE_H_
+
+#include <map>
+#include <memory>
+#include <utility>
+
+#include "api/video/video_stream_encoder_interface.h"
+#include "api/video/video_stream_encoder_observer.h"
+#include "api/video/video_stream_encoder_settings.h"
+
+namespace webrtc {
+
+std::unique_ptr<VideoStreamEncoderInterface> CreateVideoStreamEncoder(
+    uint32_t number_of_cores,
+    VideoStreamEncoderObserver* encoder_stats_observer,
+    const VideoStreamEncoderSettings& settings,
+    // Deprecated, used for tests only.
+    rtc::VideoSinkInterface<VideoFrame>* pre_encode_callback);
+
+inline std::unique_ptr<VideoStreamEncoderInterface> CreateVideoStreamEncoder(
+    uint32_t number_of_cores,
+    VideoStreamEncoderObserver* encoder_stats_observer,
+    const VideoStreamEncoderSettings& settings) {
+  return CreateVideoStreamEncoder(number_of_cores, encoder_stats_observer,
+                                  settings, nullptr);
+}
+
+}  // namespace webrtc
+
+#endif  // API_VIDEO_VIDEO_STREAM_ENCODER_CREATE_H_
diff --git a/api/video/video_stream_encoder_interface.h b/api/video/video_stream_encoder_interface.h
index 44dc6f4..2f95e58 100644
--- a/api/video/video_stream_encoder_interface.h
+++ b/api/video/video_stream_encoder_interface.h
@@ -47,8 +47,6 @@
         int min_transmit_bitrate_bps) = 0;
   };
 
-  ~VideoStreamEncoderInterface() override = default;
-
   // Sets the source that will provide video frames to the VideoStreamEncoder's
   // OnFrame method. |degradation_preference| control whether or not resolution
   // or frame rate may be reduced. The VideoStreamEncoder registers itself with
diff --git a/api/video/video_stream_encoder_observer.cc b/api/video/video_stream_encoder_observer.cc
new file mode 100644
index 0000000..3b9bd52
--- /dev/null
+++ b/api/video/video_stream_encoder_observer.cc
@@ -0,0 +1,17 @@
+/*
+ *  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/video_stream_encoder_observer.h"
+
+namespace webrtc {
+
+VideoStreamEncoderObserver::AdaptationSteps::AdaptationSteps() = default;
+
+}  // namespace webrtc
diff --git a/api/video/video_stream_encoder_observer.h b/api/video/video_stream_encoder_observer.h
new file mode 100644
index 0000000..b940efd
--- /dev/null
+++ b/api/video/video_stream_encoder_observer.h
@@ -0,0 +1,95 @@
+/*
+ *  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_VIDEO_STREAM_ENCODER_OBSERVER_H_
+#define API_VIDEO_VIDEO_STREAM_ENCODER_OBSERVER_H_
+
+#include <vector>
+
+#include "absl/types/optional.h"
+#include "api/video_codecs/video_encoder.h"
+#include "api/video_codecs/video_encoder_config.h"
+
+namespace webrtc {
+
+// TODO(nisse): Used for the OnSendEncodedImage callback below. The callback
+// wants metadata such as size, encode timing, qp, but doesn't need actual
+// encoded data. So use some other type to represent that.
+class EncodedImage;
+
+// Broken out into a base class, with public inheritance below, only to ease
+// unit testing of the internal class OveruseFrameDetector.
+class CpuOveruseMetricsObserver {
+ public:
+  virtual ~CpuOveruseMetricsObserver() = default;
+  virtual void OnEncodedFrameTimeMeasured(int encode_duration_ms,
+                                          int encode_usage_percent) = 0;
+};
+
+class VideoStreamEncoderObserver : public CpuOveruseMetricsObserver {
+ public:
+  // Number of resolution and framerate reductions (unset if disabled).
+  struct AdaptationSteps {
+    AdaptationSteps();
+    absl::optional<int> num_resolution_reductions = 0;
+    absl::optional<int> num_framerate_reductions = 0;
+  };
+
+  // TODO(nisse): There are too many enums to represent this. Besides
+  // this one, see AdaptationObserverInterface::AdaptReason and
+  // WebRtcVideoChannel::AdaptReason.
+  enum class AdaptationReason {
+    kNone,  // Used for reset of counters.
+    kCpu,
+    kQuality,
+  };
+
+  // TODO(nisse): Duplicates enum EncodedImageCallback::DropReason.
+  enum class DropReason {
+    kSource,
+    kEncoderQueue,
+    kEncoder,
+    kMediaOptimization
+  };
+
+  ~VideoStreamEncoderObserver() override = default;
+
+  virtual void OnIncomingFrame(int width, int height) = 0;
+
+  // TODO(nisse): Merge into one callback per encoded frame.
+  using CpuOveruseMetricsObserver::OnEncodedFrameTimeMeasured;
+  virtual void OnSendEncodedImage(const EncodedImage& encoded_image,
+                                  const CodecSpecificInfo* codec_info) = 0;
+
+  virtual void OnFrameDropped(DropReason reason) = 0;
+
+  // Used to indicate change in content type, which may require a change in
+  // how stats are collected and set the configured preferred media bitrate.
+  virtual void OnEncoderReconfigured(
+      const VideoEncoderConfig& encoder_config,
+      const std::vector<VideoStream>& streams) = 0;
+
+  virtual void OnAdaptationChanged(AdaptationReason reason,
+                                   const AdaptationSteps& cpu_steps,
+                                   const AdaptationSteps& quality_steps) = 0;
+  virtual void OnMinPixelLimitReached() = 0;
+  virtual void OnInitialQualityResolutionAdaptDown() = 0;
+
+  virtual void OnSuspendChange(bool is_suspended) = 0;
+
+  // TODO(nisse): VideoStreamEncoder wants to query the stats, which makes this
+  // not a pure observer. GetInputFrameRate is needed for the cpu adaptation, so
+  // can be deleted if that responsibility is moved out to a VideoStreamAdaptor
+  // class.
+  virtual int GetInputFrameRate() const = 0;
+};
+
+}  // namespace webrtc
+#endif  // API_VIDEO_VIDEO_STREAM_ENCODER_OBSERVER_H_
diff --git a/api/video/video_stream_encoder_settings.h b/api/video/video_stream_encoder_settings.h
new file mode 100644
index 0000000..b67f33c
--- /dev/null
+++ b/api/video/video_stream_encoder_settings.h
@@ -0,0 +1,31 @@
+/*
+ *  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_VIDEO_STREAM_ENCODER_SETTINGS_H_
+#define API_VIDEO_VIDEO_STREAM_ENCODER_SETTINGS_H_
+
+#include "api/video_codecs/video_encoder_factory.h"
+
+namespace webrtc {
+
+struct VideoStreamEncoderSettings {
+  VideoStreamEncoderSettings() = default;
+
+  // Enables the new method to estimate the cpu load from encoding, used for
+  // cpu adaptation.
+  bool experiment_cpu_load_estimator = false;
+
+  // Ownership stays with WebrtcVideoEngine (delegated from PeerConnection).
+  VideoEncoderFactory* encoder_factory = nullptr;
+};
+
+}  // namespace webrtc
+
+#endif  // API_VIDEO_VIDEO_STREAM_ENCODER_SETTINGS_H_
diff --git a/audio/BUILD.gn b/audio/BUILD.gn
index 22ceeb6..ae4c67e 100644
--- a/audio/BUILD.gn
+++ b/audio/BUILD.gn
@@ -54,7 +54,6 @@
     "../api/audio:audio_frame_api",
     "../api/audio:audio_mixer_api",
     "../api/audio_codecs:audio_codecs_api",
-    "../api/audio_codecs:builtin_audio_encoder_factory",
     "../call:bitrate_allocator",
     "../call:call_interfaces",
     "../call:rtp_interfaces",
@@ -100,6 +99,9 @@
     ]
     deps = [
       ":audio",
+      "../api:simulated_network_api",
+      "../call:fake_network",
+      "../call:simulated_network",
       "../system_wrappers:system_wrappers",
       "../test:test_common",
       "../test:test_support",
@@ -121,6 +123,7 @@
       "audio_state_unittest.cc",
       "mock_voe_channel_proxy.h",
       "remix_resample_unittest.cc",
+      "test/audio_stats_test.cc",
       "time_interval_unittest.cc",
       "transport_feedback_packet_loss_tracker_unittest.cc",
     ]
@@ -159,11 +162,6 @@
       "//third_party/abseil-cpp/absl/memory",
     ]
 
-    if (!rtc_use_memcheck) {
-      # This test is timing dependent, which rules out running on memcheck bots.
-      sources += [ "test/audio_stats_test.cc" ]
-    }
-
     if (!build_with_chromium && is_clang) {
       # Suppress warnings from the Chromium Clang plugin (bugs.webrtc.org/163).
       suppressed_configs += [ "//build/config/clang:find_bad_constructs" ]
@@ -180,6 +178,7 @@
 
       deps = [
         ":audio_end_to_end_test",
+        "../api:simulated_network_api",
         "../common_audio",
         "../rtc_base:rtc_base_approved",
         "../system_wrappers",
@@ -251,6 +250,9 @@
       "test/audio_bwe_integration_test.h",
     ]
     deps = [
+      "../api:simulated_network_api",
+      "../call:fake_network",
+      "../call:simulated_network",
       "../common_audio",
       "../rtc_base:rtc_base_approved",
       "../system_wrappers",
diff --git a/audio/audio_receive_stream.cc b/audio/audio_receive_stream.cc
index 6f43576..b507afc 100644
--- a/audio/audio_receive_stream.cc
+++ b/audio/audio_receive_stream.cc
@@ -20,7 +20,6 @@
 #include "audio/conversion.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_receiver.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
@@ -66,16 +65,16 @@
 std::unique_ptr<voe::ChannelProxy> CreateChannelAndProxy(
     webrtc::AudioState* audio_state,
     ProcessThread* module_process_thread,
-    const webrtc::AudioReceiveStream::Config& config) {
+    const webrtc::AudioReceiveStream::Config& config,
+    RtcEventLog* event_log) {
   RTC_DCHECK(audio_state);
   internal::AudioState* internal_audio_state =
       static_cast<internal::AudioState*>(audio_state);
-  return std::unique_ptr<voe::ChannelProxy>(
-      new voe::ChannelProxy(std::unique_ptr<voe::Channel>(new voe::Channel(
-          module_process_thread, internal_audio_state->audio_device_module(),
-          nullptr /* RtcpRttStats */, config.jitter_buffer_max_packets,
-          config.jitter_buffer_fast_accelerate, config.decoder_factory,
-          config.codec_pair_id))));
+  return absl::make_unique<voe::ChannelProxy>(absl::make_unique<voe::Channel>(
+      module_process_thread, internal_audio_state->audio_device_module(),
+      nullptr /* RtcpRttStats */, event_log, config.rtp.remote_ssrc,
+      config.jitter_buffer_max_packets, config.jitter_buffer_fast_accelerate,
+      config.decoder_factory, config.codec_pair_id));
 }
 }  // namespace
 
@@ -93,7 +92,8 @@
                          event_log,
                          CreateChannelAndProxy(audio_state.get(),
                                                module_process_thread,
-                                               config)) {}
+                                               config,
+                                               event_log)) {}
 
 AudioReceiveStream::AudioReceiveStream(
     RtpStreamReceiverControllerInterface* receiver_controller,
@@ -112,7 +112,6 @@
 
   module_process_thread_checker_.DetachFromThread();
 
-  channel_proxy_->SetRtcEventLog(event_log);
   channel_proxy_->RegisterTransport(config.rtcp_send_transport);
 
   // Configure bandwidth estimation.
@@ -132,7 +131,6 @@
   channel_proxy_->DisassociateSendChannel();
   channel_proxy_->RegisterTransport(nullptr);
   channel_proxy_->ResetReceiverCongestionControlObjects();
-  channel_proxy_->SetRtcEventLog(nullptr);
 }
 
 void AudioReceiveStream::Reconfigure(
@@ -257,26 +255,12 @@
 
 absl::optional<Syncable::Info> AudioReceiveStream::GetInfo() const {
   RTC_DCHECK_RUN_ON(&module_process_thread_checker_);
-  Syncable::Info info;
+  absl::optional<Syncable::Info> info = channel_proxy_->GetSyncInfo();
 
-  RtpRtcp* rtp_rtcp = nullptr;
-  RtpReceiver* rtp_receiver = nullptr;
-  channel_proxy_->GetRtpRtcp(&rtp_rtcp, &rtp_receiver);
-  RTC_DCHECK(rtp_rtcp);
-  RTC_DCHECK(rtp_receiver);
-
-  if (!rtp_receiver->GetLatestTimestamps(
-          &info.latest_received_capture_timestamp,
-          &info.latest_receive_time_ms)) {
+  if (!info)
     return absl::nullopt;
-  }
-  if (rtp_rtcp->RemoteNTP(&info.capture_time_ntp_secs,
-                          &info.capture_time_ntp_frac, nullptr, nullptr,
-                          &info.capture_time_source_clock) != 0) {
-    return absl::nullopt;
-  }
 
-  info.current_delay_ms = channel_proxy_->GetDelayEstimate();
+  info->current_delay_ms = channel_proxy_->GetDelayEstimate();
   return info;
 }
 
@@ -360,9 +344,7 @@
     channel_proxy->SetLocalSSRC(new_config.rtp.local_ssrc);
   }
 
-  if (first_time) {
-    channel_proxy->SetRemoteSSRC(new_config.rtp.remote_ssrc);
-  } else {
+  if (!first_time) {
     // Remote ssrc can't be changed mid-stream.
     RTC_DCHECK_EQ(old_config.rtp.remote_ssrc, new_config.rtp.remote_ssrc);
   }
diff --git a/audio/audio_receive_stream_unittest.cc b/audio/audio_receive_stream_unittest.cc
index 51635f6..eb93bd0 100644
--- a/audio/audio_receive_stream_unittest.cc
+++ b/audio/audio_receive_stream_unittest.cc
@@ -83,7 +83,6 @@
 
     channel_proxy_ = new testing::StrictMock<MockVoEChannelProxy>();
     EXPECT_CALL(*channel_proxy_, SetLocalSSRC(kLocalSsrc)).Times(1);
-    EXPECT_CALL(*channel_proxy_, SetRemoteSSRC(kRemoteSsrc)).Times(1);
     EXPECT_CALL(*channel_proxy_, SetNACKStatus(true, 15)).Times(1);
     EXPECT_CALL(*channel_proxy_,
                 RegisterReceiverCongestionControlObjects(&packet_router_))
@@ -91,11 +90,6 @@
     EXPECT_CALL(*channel_proxy_, ResetReceiverCongestionControlObjects())
         .Times(1);
     EXPECT_CALL(*channel_proxy_, RegisterTransport(nullptr)).Times(2);
-    testing::Expectation expect_set =
-        EXPECT_CALL(*channel_proxy_, SetRtcEventLog(&event_log_)).Times(1);
-    EXPECT_CALL(*channel_proxy_, SetRtcEventLog(testing::IsNull()))
-        .Times(1)
-        .After(expect_set);
     EXPECT_CALL(*channel_proxy_, DisassociateSendChannel()).Times(1);
     EXPECT_CALL(*channel_proxy_, SetReceiveCodecs(_))
         .WillRepeatedly(Invoke([](const std::map<int, SdpAudioFormat>& codecs) {
@@ -236,11 +230,11 @@
   const int kTransportSequenceNumberValue = 1234;
   std::vector<uint8_t> rtp_packet = CreateRtpHeaderWithOneByteExtension(
       kTransportSequenceNumberId, kTransportSequenceNumberValue, 2);
-  PacketTime packet_time(5678000, 0);
+  constexpr int64_t packet_time_us = 5678000;
 
   RtpPacketReceived parsed_packet;
   ASSERT_TRUE(parsed_packet.Parse(&rtp_packet[0], rtp_packet.size()));
-  parsed_packet.set_arrival_time_ms((packet_time.timestamp + 500) / 1000);
+  parsed_packet.set_arrival_time_ms((packet_time_us + 500) / 1000);
 
   EXPECT_CALL(*helper.channel_proxy(),
               OnRtpPacket(testing::Ref(parsed_packet)));
diff --git a/audio/audio_send_stream.cc b/audio/audio_send_stream.cc
index de1be2c..0f725c4 100644
--- a/audio/audio_send_stream.cc
+++ b/audio/audio_send_stream.cc
@@ -14,6 +14,8 @@
 #include <utility>
 #include <vector>
 
+#include "absl/memory/memory.h"
+
 #include "audio/audio_state.h"
 #include "audio/channel_proxy.h"
 #include "audio/conversion.h"
@@ -48,14 +50,14 @@
     webrtc::AudioState* audio_state,
     rtc::TaskQueue* worker_queue,
     ProcessThread* module_process_thread,
-    RtcpRttStats* rtcp_rtt_stats) {
+    RtcpRttStats* rtcp_rtt_stats,
+    RtcEventLog* event_log) {
   RTC_DCHECK(audio_state);
   internal::AudioState* internal_audio_state =
       static_cast<internal::AudioState*>(audio_state);
-  return std::unique_ptr<voe::ChannelProxy>(
-      new voe::ChannelProxy(std::unique_ptr<voe::Channel>(new voe::Channel(
-          worker_queue, module_process_thread,
-          internal_audio_state->audio_device_module(), rtcp_rtt_stats))));
+  return absl::make_unique<voe::ChannelProxy>(absl::make_unique<voe::Channel>(
+      worker_queue, module_process_thread,
+      internal_audio_state->audio_device_module(), rtcp_rtt_stats, event_log));
 }
 }  // namespace
 
@@ -105,7 +107,8 @@
                       CreateChannelAndProxy(audio_state.get(),
                                             worker_queue,
                                             module_process_thread,
-                                            rtcp_rtt_stats)) {}
+                                            rtcp_rtt_stats,
+                                            event_log)) {}
 
 AudioSendStream::AudioSendStream(
     const webrtc::AudioSendStream::Config& config,
@@ -139,10 +142,8 @@
   RTC_DCHECK(transport);
   RTC_DCHECK(overall_call_lifetime_);
 
-  channel_proxy_->SetRtcEventLog(event_log_);
   channel_proxy_->SetRTCPStatus(true);
-  RtpReceiver* rtpReceiver = nullptr;  // Unused, but required for call.
-  channel_proxy_->GetRtpRtcp(&rtp_rtcp_module_, &rtpReceiver);
+  rtp_rtcp_module_ = channel_proxy_->GetRtpRtcp();
   RTC_DCHECK(rtp_rtcp_module_);
 
   ConfigureStream(this, config, true);
@@ -159,7 +160,6 @@
   transport_->DeRegisterPacketFeedbackObserver(this);
   channel_proxy_->RegisterTransport(nullptr);
   channel_proxy_->ResetSenderCongestionControlObjects();
-  channel_proxy_->SetRtcEventLog(nullptr);
   // Lifetime can only be updated after deregistering
   // |timed_send_transport_adapter_| in the underlying channel object to avoid
   // data races in |active_lifetime_|.
diff --git a/audio/audio_send_stream_unittest.cc b/audio/audio_send_stream_unittest.cc
index 2341d4e..f5d6796 100644
--- a/audio/audio_send_stream_unittest.cc
+++ b/audio/audio_send_stream_unittest.cc
@@ -189,12 +189,9 @@
   void SetupDefaultChannelProxy(bool audio_bwe_enabled) {
     EXPECT_TRUE(channel_proxy_ == nullptr);
     channel_proxy_ = new testing::StrictMock<MockVoEChannelProxy>();
-    EXPECT_CALL(*channel_proxy_, GetRtpRtcp(_, _))
-        .WillRepeatedly(Invoke(
-            [this](RtpRtcp** rtp_rtcp_module, RtpReceiver** rtp_receiver) {
-              *rtp_rtcp_module = &this->rtp_rtcp_;
-              *rtp_receiver = nullptr;  // Not deemed necessary for tests yet.
-            }));
+    EXPECT_CALL(*channel_proxy_, GetRtpRtcp()).WillRepeatedly(Invoke([this]() {
+      return &this->rtp_rtcp_;
+    }));
     EXPECT_CALL(*channel_proxy_, SetRTCPStatus(true)).Times(1);
     EXPECT_CALL(*channel_proxy_, SetLocalSSRC(kSsrc)).Times(1);
     EXPECT_CALL(*channel_proxy_, SetRTCP_CNAME(StrEq(kCName))).Times(1);
@@ -224,9 +221,6 @@
       EXPECT_CALL(*channel_proxy_, RegisterTransport(_)).Times(1);
       EXPECT_CALL(*channel_proxy_, RegisterTransport(nullptr)).Times(1);
     }
-    EXPECT_CALL(*channel_proxy_, SetRtcEventLog(testing::NotNull())).Times(1);
-    EXPECT_CALL(*channel_proxy_, SetRtcEventLog(testing::IsNull()))
-        .Times(1);  // Destructor resets the event log
   }
 
   void SetupMockForSetupSendCodec(bool expect_set_encoder_call) {
@@ -385,8 +379,7 @@
   EXPECT_EQ(kSsrc, stats.local_ssrc);
   EXPECT_EQ(static_cast<int64_t>(kCallStats.bytesSent), stats.bytes_sent);
   EXPECT_EQ(kCallStats.packetsSent, stats.packets_sent);
-  EXPECT_EQ(static_cast<int32_t>(kReportBlock.cumulative_num_packets_lost),
-            stats.packets_lost);
+  EXPECT_EQ(kReportBlock.cumulative_num_packets_lost, stats.packets_lost);
   EXPECT_EQ(Q8ToFloat(kReportBlock.fraction_lost), stats.fraction_lost);
   EXPECT_EQ(std::string(kIsacCodec.plname), stats.codec_name);
   EXPECT_EQ(static_cast<int32_t>(kReportBlock.extended_highest_sequence_number),
diff --git a/audio/audio_state.cc b/audio/audio_state.cc
index 35ea03d..7d473ae 100644
--- a/audio/audio_state.cc
+++ b/audio/audio_state.cc
@@ -39,6 +39,15 @@
   RTC_DCHECK(sending_streams_.empty());
 }
 
+AudioProcessing* AudioState::audio_processing() {
+  RTC_DCHECK(config_.audio_processing);
+  return config_.audio_processing.get();
+}
+
+AudioTransport* AudioState::audio_transport() {
+  return &audio_transport_;
+}
+
 bool AudioState::typing_noise_detected() const {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   return audio_transport_.typing_noise_detected();
diff --git a/audio/audio_state.h b/audio/audio_state.h
index 689534b..9e302c4 100644
--- a/audio/audio_state.h
+++ b/audio/audio_state.h
@@ -35,11 +35,8 @@
   explicit AudioState(const AudioState::Config& config);
   ~AudioState() override;
 
-  AudioProcessing* audio_processing() override {
-    RTC_DCHECK(config_.audio_processing);
-    return config_.audio_processing.get();
-  }
-  AudioTransport* audio_transport() override { return &audio_transport_; }
+  AudioProcessing* audio_processing() override;
+  AudioTransport* audio_transport() override;
 
   void SetPlayout(bool enabled) override;
   void SetRecording(bool enabled) override;
diff --git a/audio/channel.cc b/audio/channel.cc
index 6acc65e..d884e03 100644
--- a/audio/channel.cc
+++ b/audio/channel.cc
@@ -29,8 +29,6 @@
 #include "modules/audio_processing/include/audio_processing.h"
 #include "modules/pacing/packet_router.h"
 #include "modules/rtp_rtcp/include/receive_statistics.h"
-#include "modules/rtp_rtcp/include/rtp_payload_registry.h"
-#include "modules/rtp_rtcp/include/rtp_receiver.h"
 #include "modules/rtp_rtcp/source/rtp_packet_received.h"
 #include "modules/rtp_rtcp/source/rtp_receiver_strategy.h"
 #include "modules/utility/include/process_thread.h"
@@ -63,36 +61,6 @@
 
 const int kTelephoneEventAttenuationdB = 10;
 
-class RtcEventLogProxy final : public webrtc::RtcEventLog {
- public:
-  RtcEventLogProxy() : event_log_(nullptr) {}
-
-  bool StartLogging(std::unique_ptr<RtcEventLogOutput> output,
-                    int64_t output_period_ms) override {
-    RTC_NOTREACHED();
-    return false;
-  }
-
-  void StopLogging() override { RTC_NOTREACHED(); }
-
-  void Log(std::unique_ptr<RtcEvent> event) override {
-    rtc::CritScope lock(&crit_);
-    if (event_log_) {
-      event_log_->Log(std::move(event));
-    }
-  }
-
-  void SetEventLog(RtcEventLog* event_log) {
-    rtc::CritScope lock(&crit_);
-    event_log_ = event_log;
-  }
-
- private:
-  rtc::CriticalSection crit_;
-  RtcEventLog* event_log_ RTC_GUARDED_BY(crit_);
-  RTC_DISALLOW_COPY_AND_ASSIGN(RtcEventLogProxy);
-};
-
 class TransportFeedbackProxy : public TransportFeedbackObserver {
  public:
   TransportFeedbackProxy() : feedback_observer_(nullptr) {
@@ -374,8 +342,7 @@
   }
 
   int64_t round_trip_time = 0;
-  _rtpRtcpModule->RTT(rtp_receiver_->SSRC(), &round_trip_time, NULL, NULL,
-                      NULL);
+  _rtpRtcpModule->RTT(remote_ssrc_, &round_trip_time, NULL, NULL, NULL);
 
   std::vector<uint16_t> nack_list = audio_coding_->GetNackList(round_trip_time);
   if (!nack_list.empty()) {
@@ -393,7 +360,7 @@
 
   unsigned int ssrc;
   RTC_CHECK_EQ(GetRemoteSSRC(ssrc), 0);
-  event_log_proxy_->Log(absl::make_unique<RtcEventAudioPlayout>(ssrc));
+  event_log_->Log(absl::make_unique<RtcEventAudioPlayout>(ssrc));
   // Get 10ms raw PCM data from the ACM (mixer limits output frequency)
   bool muted;
   if (audio_coding_->PlayoutData10Ms(audio_frame->sample_rate_hz_, audio_frame,
@@ -502,10 +469,13 @@
 Channel::Channel(rtc::TaskQueue* encoder_queue,
                  ProcessThread* module_process_thread,
                  AudioDeviceModule* audio_device_module,
-                 RtcpRttStats* rtcp_rtt_stats)
+                 RtcpRttStats* rtcp_rtt_stats,
+                 RtcEventLog* rtc_event_log)
     : Channel(module_process_thread,
               audio_device_module,
               rtcp_rtt_stats,
+              rtc_event_log,
+              0,
               0,
               false,
               rtc::scoped_refptr<AudioDecoderFactory>(),
@@ -517,19 +487,16 @@
 Channel::Channel(ProcessThread* module_process_thread,
                  AudioDeviceModule* audio_device_module,
                  RtcpRttStats* rtcp_rtt_stats,
+                 RtcEventLog* rtc_event_log,
+                 uint32_t remote_ssrc,
                  size_t jitter_buffer_max_packets,
                  bool jitter_buffer_fast_playout,
                  rtc::scoped_refptr<AudioDecoderFactory> decoder_factory,
                  absl::optional<AudioCodecPairId> codec_pair_id)
-    : event_log_proxy_(new RtcEventLogProxy()),
-      rtp_payload_registry_(new RTPPayloadRegistry()),
+    : event_log_(rtc_event_log),
       rtp_receive_statistics_(
           ReceiveStatistics::Create(Clock::GetRealTimeClock())),
-      rtp_receiver_(
-          RtpReceiver::CreateAudioReceiver(Clock::GetRealTimeClock(),
-                                           this,
-                                           rtp_payload_registry_.get())),
-      telephone_event_handler_(rtp_receiver_->GetTelephoneEventHandler()),
+      remote_ssrc_(remote_ssrc),
       _outputAudioLevel(),
       _timeStamp(0),  // This is just an offset, RTP module will add it's own
                       // random offset
@@ -570,6 +537,7 @@
 
   _outputAudioLevel.Clear();
 
+  rtp_receive_statistics_->EnableRetransmitDetection(remote_ssrc_, true);
   RtpRtcp::Configuration configuration;
   configuration.audio = true;
   configuration.outgoing_transport = this;
@@ -582,14 +550,14 @@
         seq_num_allocator_proxy_.get();
     configuration.transport_feedback_callback = feedback_observer_proxy_.get();
   }
-  configuration.event_log = &(*event_log_proxy_);
+  configuration.event_log = event_log_;
   configuration.rtt_stats = rtcp_rtt_stats;
   configuration.retransmission_rate_limiter =
       retransmission_rate_limiter_.get();
 
   _rtpRtcpModule.reset(RtpRtcp::CreateRtpRtcp(configuration));
   _rtpRtcpModule->SetSendingMediaStatus(false);
-
+  _rtpRtcpModule->SetRemoteSSRC(remote_ssrc_);
   Init();
 }
 
@@ -616,7 +584,6 @@
   // disabled by the user.
   // After StopListen (when no sockets exists), RTCP packets will no longer
   // be transmitted since the Transport object will then be invalid.
-  telephone_event_handler_->SetTelephoneEventForwardToDecoder(true);
   // RTCP is enabled by default.
   _rtpRtcpModule->SetRTCPStatus(RtcpMode::kCompound);
 
@@ -814,6 +781,22 @@
   });
 }
 
+std::vector<webrtc::RtpSource> Channel::GetSources() const {
+  int64_t now_ms = rtc::TimeMillis();
+  std::vector<RtpSource> sources;
+  {
+    rtc::CritScope cs(&rtp_sources_lock_);
+    sources = contributing_sources_.GetSources(now_ms);
+    if (last_received_rtp_system_time_ms_ >=
+        now_ms - ContributingSources::kHistoryMs) {
+      sources.emplace_back(*last_received_rtp_system_time_ms_, remote_ssrc_,
+                           RtpSourceType::SSRC);
+      sources.back().set_audio_level(last_received_rtp_audio_level_);
+    }
+  }
+  return sources;
+}
+
 void Channel::OnUplinkPacketLossRate(float packet_loss_rate) {
   if (use_twcc_plr_for_ana_)
     return;
@@ -825,7 +808,10 @@
 }
 
 void Channel::SetReceiveCodecs(const std::map<int, SdpAudioFormat>& codecs) {
-  rtp_payload_registry_->SetAudioReceivePayloads(codecs);
+  for (const auto& kv : codecs) {
+    RTC_DCHECK_GE(kv.second.clockrate_hz, 1000);
+    payload_type_frequencies_[kv.first] = kv.second.clockrate_hz;
+  }
   audio_coding_->SetReceiveCodecs(codecs);
 }
 
@@ -833,8 +819,8 @@
   bool success = false;
   audio_coding_->ModifyEncoder([&](std::unique_ptr<AudioEncoder>* encoder) {
     if (*encoder) {
-      success = (*encoder)->EnableAudioNetworkAdaptor(config_string,
-                                                      event_log_proxy_.get());
+      success =
+          (*encoder)->EnableAudioNetworkAdaptor(config_string, event_log_);
     }
   });
   return success;
@@ -862,21 +848,38 @@
   _transportPtr = transport;
 }
 
+// TODO(nisse): Move receive logic up to AudioReceiveStream.
 void Channel::OnRtpPacket(const RtpPacketReceived& packet) {
+  int64_t now_ms = rtc::TimeMillis();
+  uint8_t audio_level;
+  bool voice_activity;
+  bool has_audio_level =
+      packet.GetExtension<::webrtc::AudioLevel>(&voice_activity, &audio_level);
+
+  {
+    rtc::CritScope cs(&rtp_sources_lock_);
+    last_received_rtp_timestamp_ = packet.Timestamp();
+    last_received_rtp_system_time_ms_ = now_ms;
+    if (has_audio_level)
+      last_received_rtp_audio_level_ = audio_level;
+    std::vector<uint32_t> csrcs = packet.Csrcs();
+    contributing_sources_.Update(now_ms, csrcs);
+  }
+
   RTPHeader header;
   packet.GetHeader(&header);
 
   // Store playout timestamp for the received RTP packet
   UpdatePlayoutTimestamp(false);
 
-  header.payload_type_frequency =
-      rtp_payload_registry_->GetPayloadTypeFrequency(header.payloadType);
-  if (header.payload_type_frequency >= 0) {
-    rtp_receive_statistics_->IncomingPacket(header, packet.size(),
-                                            IsPacketRetransmitted(header));
+  const auto& it = payload_type_frequencies_.find(header.payloadType);
+  if (it == payload_type_frequencies_.end())
+    return;
+  header.payload_type_frequency = it->second;
 
-    ReceivePacket(packet.data(), packet.size(), header);
-  }
+  rtp_receive_statistics_->IncomingPacket(header, packet.size());
+
+  ReceivePacket(packet.data(), packet.size(), header);
 }
 
 bool Channel::ReceivePacket(const uint8_t* packet,
@@ -885,22 +888,16 @@
   const uint8_t* payload = packet + header.headerLength;
   assert(packet_length >= header.headerLength);
   size_t payload_length = packet_length - header.headerLength;
-  const auto pl =
-      rtp_payload_registry_->PayloadTypeToPayload(header.payloadType);
-  if (!pl) {
-    return false;
-  }
-  return rtp_receiver_->IncomingRtpPacket(header, payload, payload_length,
-                                          pl->typeSpecific);
-}
+  WebRtcRTPHeader webrtc_rtp_header = {};
+  webrtc_rtp_header.header = header;
 
-bool Channel::IsPacketRetransmitted(const RTPHeader& header) const {
-  StreamStatistician* statistician =
-      rtp_receive_statistics_->GetStatistician(header.ssrc);
-  if (!statistician)
-    return false;
-  // Check if this is a retransmission.
-  return statistician->IsRetransmitOfOldPacket(header);
+  const size_t payload_data_length = payload_length - header.paddingLength;
+  if (payload_data_length == 0) {
+    webrtc_rtp_header.frameType = kEmptyFrame;
+    return OnReceivedPayloadData(nullptr, 0, &webrtc_rtp_header);
+  }
+  return OnReceivedPayloadData(payload, payload_data_length,
+                               &webrtc_rtp_header);
 }
 
 int32_t Channel::ReceivedRTCPPacket(const uint8_t* data, size_t length) {
@@ -1018,19 +1015,15 @@
   return 0;
 }
 
-void Channel::SetRemoteSSRC(uint32_t ssrc) {
-  // Update ssrc so that NTP for AV sync can be updated.
-  _rtpRtcpModule->SetRemoteSSRC(ssrc);
-}
-
 void Channel::SetMid(const std::string& mid, int extension_id) {
   int ret = SetSendRtpHeaderExtension(true, kRtpExtensionMid, extension_id);
   RTC_DCHECK_EQ(0, ret);
   _rtpRtcpModule->SetMid(mid);
 }
 
+// TODO(nisse): Pass ssrc in return value instead.
 int Channel::GetRemoteSSRC(unsigned int& ssrc) {
-  ssrc = rtp_receiver_->SSRC();
+  ssrc = remote_ssrc_;
   return 0;
 }
 
@@ -1148,7 +1141,7 @@
   // based on received packets.
   RtcpStatistics statistics;
   StreamStatistician* statistician =
-      rtp_receive_statistics_->GetStatistician(rtp_receiver_->SSRC());
+      rtp_receive_statistics_->GetStatistician(remote_ssrc_);
   if (statistician) {
     statistician->GetStatistics(&statistics,
                                 _rtpRtcpModule->RTCP() == RtcpMode::kOff);
@@ -1270,10 +1263,6 @@
   associated_send_channel_ = channel;
 }
 
-void Channel::SetRtcEventLog(RtcEventLog* event_log) {
-  event_log_proxy_->SetEventLog(event_log);
-}
-
 void Channel::UpdateOverheadForEncoder() {
   size_t overhead_per_packet =
       transport_overhead_per_packet_ + rtp_overhead_per_packet_;
@@ -1342,11 +1331,26 @@
   return 0;
 }
 
-int Channel::GetRtpRtcp(RtpRtcp** rtpRtcpModule,
-                        RtpReceiver** rtp_receiver) const {
-  *rtpRtcpModule = _rtpRtcpModule.get();
-  *rtp_receiver = rtp_receiver_.get();
-  return 0;
+RtpRtcp* Channel::GetRtpRtcp() const {
+  return _rtpRtcpModule.get();
+}
+
+absl::optional<Syncable::Info> Channel::GetSyncInfo() const {
+  Syncable::Info info;
+  if (_rtpRtcpModule->RemoteNTP(&info.capture_time_ntp_secs,
+                                &info.capture_time_ntp_frac, nullptr, nullptr,
+                                &info.capture_time_source_clock) != 0) {
+    return absl::nullopt;
+  }
+  {
+    rtc::CritScope cs(&rtp_sources_lock_);
+    if (!last_received_rtp_timestamp_ || !last_received_rtp_system_time_ms_) {
+      return absl::nullopt;
+    }
+    info.latest_received_capture_timestamp = *last_received_rtp_timestamp_;
+    info.latest_receive_time_ms = *last_received_rtp_system_time_ms_;
+  }
+  return info;
 }
 
 void Channel::UpdatePlayoutTimestamp(bool rtcp) {
@@ -1426,25 +1430,23 @@
     return rtt;
   }
 
-  uint32_t remoteSSRC = rtp_receiver_->SSRC();
   std::vector<RTCPReportBlock>::const_iterator it = report_blocks.begin();
   for (; it != report_blocks.end(); ++it) {
-    if (it->sender_ssrc == remoteSSRC)
+    if (it->sender_ssrc == remote_ssrc_)
       break;
   }
-  if (it == report_blocks.end()) {
-    // We have not received packets with SSRC matching the report blocks.
-    // To calculate RTT we try with the SSRC of the first report block.
-    // This is very important for send-only channels where we don't know
-    // the SSRC of the other end.
-    remoteSSRC = report_blocks[0].sender_ssrc;
-  }
+
+  // If we have not received packets with SSRC matching the report blocks, use
+  // the SSRC of the first report block for calculating the RTT. This is very
+  // important for send-only channels where we don't know the SSRC of the other
+  // end.
+  uint32_t ssrc =
+      (it == report_blocks.end()) ? report_blocks[0].sender_ssrc : remote_ssrc_;
 
   int64_t avg_rtt = 0;
   int64_t max_rtt = 0;
   int64_t min_rtt = 0;
-  if (_rtpRtcpModule->RTT(remoteSSRC, &rtt, &avg_rtt, &min_rtt, &max_rtt) !=
-      0) {
+  if (_rtpRtcpModule->RTT(ssrc, &rtt, &avg_rtt, &min_rtt, &max_rtt) != 0) {
     return 0;
   }
   return rtt;
diff --git a/audio/channel.h b/audio/channel.h
index 8d1a26b..562e79e 100644
--- a/audio/channel.h
+++ b/audio/channel.h
@@ -21,14 +21,16 @@
 #include "api/audio_codecs/audio_encoder.h"
 #include "api/call/audio_sink.h"
 #include "api/call/transport.h"
+#include "api/rtpreceiverinterface.h"
 #include "audio/audio_level.h"
+#include "call/syncable.h"
 #include "common_types.h"  // NOLINT(build/include)
 #include "modules/audio_coding/include/audio_coding_module.h"
 #include "modules/audio_processing/rms_level.h"
 #include "modules/rtp_rtcp/include/remote_ntp_time_estimator.h"
 #include "modules/rtp_rtcp/include/rtp_header_parser.h"
-#include "modules/rtp_rtcp/include/rtp_receiver.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp.h"
+#include "modules/rtp_rtcp/source/contributing_sources.h"
 #include "rtc_base/criticalsection.h"
 #include "rtc_base/event.h"
 #include "rtc_base/task_queue.h"
@@ -51,12 +53,9 @@
 class ReceiveStatistics;
 class RemoteNtpTimeEstimator;
 class RtcEventLog;
-class RTPPayloadRegistry;
-class RTPReceiverAudio;
 class RtpPacketReceived;
 class RtpRtcp;
 class RtpTransportControllerSendInterface;
-class TelephoneEventHandler;
 
 struct SenderInfo;
 
@@ -80,7 +79,7 @@
   uint32_t sender_SSRC;  // SSRC of sender
   uint32_t source_SSRC;
   uint8_t fraction_lost;
-  uint32_t cumulative_num_packets_lost;
+  int32_t cumulative_num_packets_lost;
   uint32_t extended_highest_sequence_number;
   uint32_t interarrival_jitter;
   uint32_t last_SR_timestamp;
@@ -89,7 +88,6 @@
 
 namespace voe {
 
-class RtcEventLogProxy;
 class RtpPacketSenderProxy;
 class TransportFeedbackProxy;
 class TransportSequenceNumberProxy;
@@ -150,11 +148,14 @@
   Channel(rtc::TaskQueue* encoder_queue,
           ProcessThread* module_process_thread,
           AudioDeviceModule* audio_device_module,
-          RtcpRttStats* rtcp_rtt_stats);
+          RtcpRttStats* rtcp_rtt_stats,
+          RtcEventLog* rtc_event_log);
   // Used for receive streams.
   Channel(ProcessThread* module_process_thread,
           AudioDeviceModule* audio_device_module,
           RtcpRttStats* rtcp_rtt_stats,
+          RtcEventLog* rtc_event_log,
+          uint32_t remote_ssrc,
           size_t jitter_buffer_max_packets,
           bool jitter_buffer_fast_playout,
           rtc::scoped_refptr<AudioDecoderFactory> decoder_factory,
@@ -210,15 +211,18 @@
   uint32_t GetDelayEstimate() const;
   int SetMinimumPlayoutDelay(int delayMs);
   int GetPlayoutTimestamp(unsigned int& timestamp);  // NOLINT
-  int GetRtpRtcp(RtpRtcp** rtpRtcpModule, RtpReceiver** rtp_receiver) const;
 
+  // Used by AudioSendStream.
+  RtpRtcp* GetRtpRtcp() const;
+
+  // Produces the transport-related timestamps; current_delay_ms is left unset.
+  absl::optional<Syncable::Info> GetSyncInfo() const;
   // DTMF.
   int SendTelephoneEventOutband(int event, int duration_ms);
   int SetSendTelephoneEventPayloadType(int payload_type, int payload_frequency);
 
   // RTP+RTCP
   int SetLocalSSRC(unsigned int ssrc);
-  void SetRemoteSSRC(uint32_t ssrc);
 
   void SetMid(const std::string& mid, int extension_id);
   int SetSendAudioLevelIndicationStatus(bool enable, unsigned char id);
@@ -281,9 +285,6 @@
   // Used for obtaining RTT for a receive-only channel.
   void SetAssociatedSendChannel(Channel* channel);
 
-  // Set a RtcEventLog logging object.
-  void SetRtcEventLog(RtcEventLog* event_log);
-
   void SetTransportOverhead(size_t transport_overhead_per_packet);
 
   // From OverheadObserver in the RTP/RTCP module
@@ -297,9 +298,7 @@
 
   void OnRecoverableUplinkPacketLossRate(float recoverable_packet_loss_rate);
 
-  std::vector<RtpSource> GetSources() const {
-    return rtp_receiver_->GetSources();
-  }
+  std::vector<RtpSource> GetSources() const;
 
  private:
   class ProcessAndEncodeAudioTask;
@@ -314,7 +313,6 @@
   bool ReceivePacket(const uint8_t* packet,
                      size_t packet_length,
                      const RTPHeader& header);
-  bool IsPacketRetransmitted(const RTPHeader& header) const;
   int ResendPackets(const uint16_t* sequence_numbers, int length);
   void UpdatePlayoutTimestamp(bool rtcp);
 
@@ -337,13 +335,26 @@
 
   ChannelState channel_state_;
 
-  std::unique_ptr<voe::RtcEventLogProxy> event_log_proxy_;
+  RtcEventLog* const event_log_;
 
-  std::unique_ptr<RTPPayloadRegistry> rtp_payload_registry_;
+  // Indexed by payload type.
+  std::map<uint8_t, int> payload_type_frequencies_;
+
   std::unique_ptr<ReceiveStatistics> rtp_receive_statistics_;
-  std::unique_ptr<RtpReceiver> rtp_receiver_;
-  TelephoneEventHandler* telephone_event_handler_;
   std::unique_ptr<RtpRtcp> _rtpRtcpModule;
+  const uint32_t remote_ssrc_;
+
+  // Info for GetSources and GetSyncInfo is updated on network or worker thread,
+  // queried on the worker thread.
+  rtc::CriticalSection rtp_sources_lock_;
+  ContributingSources contributing_sources_ RTC_GUARDED_BY(&rtp_sources_lock_);
+  absl::optional<uint32_t> last_received_rtp_timestamp_
+      RTC_GUARDED_BY(&rtp_sources_lock_);
+  absl::optional<int64_t> last_received_rtp_system_time_ms_
+      RTC_GUARDED_BY(&rtp_sources_lock_);
+  absl::optional<uint8_t> last_received_rtp_audio_level_
+      RTC_GUARDED_BY(&rtp_sources_lock_);
+
   std::unique_ptr<AudioCodingModule> audio_coding_;
   AudioSinkInterface* audio_sink_ = nullptr;
   AudioLevel _outputAudioLevel;
diff --git a/audio/channel_proxy.cc b/audio/channel_proxy.cc
index bac681f..5e8181a 100644
--- a/audio/channel_proxy.cc
+++ b/audio/channel_proxy.cc
@@ -53,11 +53,6 @@
   RTC_DCHECK_EQ(0, error);
 }
 
-void ChannelProxy::SetRemoteSSRC(uint32_t ssrc) {
-  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  channel_->SetRemoteSSRC(ssrc);
-}
-
 void ChannelProxy::SetMid(const std::string& mid, int extension_id) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   channel_->SetMid(mid, extension_id);
@@ -226,11 +221,6 @@
   channel_->SetChannelOutputVolumeScaling(scaling);
 }
 
-void ChannelProxy::SetRtcEventLog(RtcEventLog* event_log) {
-  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  channel_->SetRtcEventLog(event_log);
-}
-
 AudioMixer::Source::AudioFrameInfo ChannelProxy::GetAudioFrameWithInfo(
     int sample_rate_hz,
     AudioFrame* audio_frame) {
@@ -265,13 +255,14 @@
   channel_->SetAssociatedSendChannel(nullptr);
 }
 
-void ChannelProxy::GetRtpRtcp(RtpRtcp** rtp_rtcp,
-                              RtpReceiver** rtp_receiver) const {
+RtpRtcp* ChannelProxy::GetRtpRtcp() const {
   RTC_DCHECK(module_process_thread_checker_.CalledOnValidThread());
-  RTC_DCHECK(rtp_rtcp);
-  RTC_DCHECK(rtp_receiver);
-  int error = channel_->GetRtpRtcp(rtp_rtcp, rtp_receiver);
-  RTC_DCHECK_EQ(0, error);
+  return channel_->GetRtpRtcp();
+}
+
+absl::optional<Syncable::Info> ChannelProxy::GetSyncInfo() const {
+  RTC_DCHECK(module_process_thread_checker_.CalledOnValidThread());
+  return channel_->GetSyncInfo();
 }
 
 uint32_t ChannelProxy::GetPlayoutTimestamp() const {
diff --git a/audio/channel_proxy.h b/audio/channel_proxy.h
index 0029851..f82c1fd 100644
--- a/audio/channel_proxy.h
+++ b/audio/channel_proxy.h
@@ -34,7 +34,6 @@
 class RtcpRttStats;
 class RtpPacketSender;
 class RtpPacketReceived;
-class RtpReceiver;
 class RtpRtcp;
 class RtpTransportControllerSendInterface;
 class Transport;
@@ -62,7 +61,6 @@
 
   virtual void SetRTCPStatus(bool enable);
   virtual void SetLocalSSRC(uint32_t ssrc);
-  virtual void SetRemoteSSRC(uint32_t ssrc);
   virtual void SetMid(const std::string& mid, int extension_id);
   virtual void SetRTCP_CNAME(const std::string& c_name);
   virtual void SetNACKStatus(bool enable, int max_packets);
@@ -99,7 +97,6 @@
   void OnRtpPacket(const RtpPacketReceived& packet) override;
   virtual bool ReceivedRTCPPacket(const uint8_t* packet, size_t length);
   virtual void SetChannelOutputVolumeScaling(float scaling);
-  virtual void SetRtcEventLog(RtcEventLog* event_log);
   virtual AudioMixer::Source::AudioFrameInfo GetAudioFrameWithInfo(
       int sample_rate_hz,
       AudioFrame* audio_frame);
@@ -108,7 +105,10 @@
   virtual void SetTransportOverhead(int transport_overhead_per_packet);
   virtual void AssociateSendChannel(const ChannelProxy& send_channel_proxy);
   virtual void DisassociateSendChannel();
-  virtual void GetRtpRtcp(RtpRtcp** rtp_rtcp, RtpReceiver** rtp_receiver) const;
+  virtual RtpRtcp* GetRtpRtcp() const;
+
+  // Produces the transport-related timestamps; current_delay_ms is left unset.
+  absl::optional<Syncable::Info> GetSyncInfo() const;
   virtual uint32_t GetPlayoutTimestamp() const;
   virtual void SetMinimumPlayoutDelay(int delay_ms);
   virtual bool GetRecCodec(CodecInst* codec_inst) const;
diff --git a/audio/mock_voe_channel_proxy.h b/audio/mock_voe_channel_proxy.h
index 7396dd1..f6a2637 100644
--- a/audio/mock_voe_channel_proxy.h
+++ b/audio/mock_voe_channel_proxy.h
@@ -37,7 +37,6 @@
       void(rtc::FunctionView<void(std::unique_ptr<AudioEncoder>*)> modifier));
   MOCK_METHOD1(SetRTCPStatus, void(bool enable));
   MOCK_METHOD1(SetLocalSSRC, void(uint32_t ssrc));
-  MOCK_METHOD1(SetRemoteSSRC, void(uint32_t ssrc));
   MOCK_METHOD1(SetRTCP_CNAME, void(const std::string& c_name));
   MOCK_METHOD2(SetNACKStatus, void(bool enable, int max_packets));
   MOCK_METHOD2(SetSendAudioLevelIndicationStatus, void(bool enable, int id));
@@ -68,7 +67,6 @@
   MOCK_METHOD1(OnRtpPacket, void(const RtpPacketReceived& packet));
   MOCK_METHOD2(ReceivedRTCPPacket, bool(const uint8_t* packet, size_t length));
   MOCK_METHOD1(SetChannelOutputVolumeScaling, void(float scaling));
-  MOCK_METHOD1(SetRtcEventLog, void(RtcEventLog* event_log));
   MOCK_METHOD2(GetAudioFrameWithInfo,
                AudioMixer::Source::AudioFrameInfo(int sample_rate_hz,
                                                   AudioFrame* audio_frame));
@@ -83,8 +81,7 @@
   MOCK_METHOD1(AssociateSendChannel,
                void(const ChannelProxy& send_channel_proxy));
   MOCK_METHOD0(DisassociateSendChannel, void());
-  MOCK_CONST_METHOD2(GetRtpRtcp,
-                     void(RtpRtcp** rtp_rtcp, RtpReceiver** rtp_receiver));
+  MOCK_CONST_METHOD0(GetRtpRtcp, RtpRtcp*());
   MOCK_CONST_METHOD0(GetPlayoutTimestamp, uint32_t());
   MOCK_METHOD1(SetMinimumPlayoutDelay, void(int delay_ms));
   MOCK_CONST_METHOD1(GetRecCodec, bool(CodecInst* codec_inst));
diff --git a/audio/null_audio_poller.h b/audio/null_audio_poller.h
index b6ddf17..afb6edb 100644
--- a/audio/null_audio_poller.h
+++ b/audio/null_audio_poller.h
@@ -21,7 +21,7 @@
 class NullAudioPoller final : public rtc::MessageHandler {
  public:
   explicit NullAudioPoller(AudioTransport* audio_transport);
-  ~NullAudioPoller();
+  ~NullAudioPoller() override;
 
  protected:
   void OnMessage(rtc::Message* msg) override;
diff --git a/audio/transport_feedback_packet_loss_tracker.cc b/audio/transport_feedback_packet_loss_tracker.cc
index 7e0c5c5..c7acd76 100644
--- a/audio/transport_feedback_packet_loss_tracker.cc
+++ b/audio/transport_feedback_packet_loss_tracker.cc
@@ -47,6 +47,9 @@
   Reset();
 }
 
+TransportFeedbackPacketLossTracker::~TransportFeedbackPacketLossTracker() =
+    default;
+
 void TransportFeedbackPacketLossTracker::Reset() {
   acked_packets_ = 0;
   plr_state_.Reset();
diff --git a/audio/transport_feedback_packet_loss_tracker.h b/audio/transport_feedback_packet_loss_tracker.h
index 7d58d6c..180b64a 100644
--- a/audio/transport_feedback_packet_loss_tracker.h
+++ b/audio/transport_feedback_packet_loss_tracker.h
@@ -35,6 +35,7 @@
   TransportFeedbackPacketLossTracker(int64_t max_window_size_ms,
                                      size_t plr_min_num_acked_packets,
                                      size_t rplr_min_num_acked_pairs);
+  ~TransportFeedbackPacketLossTracker();
 
   void OnPacketAdded(uint16_t seq_num, int64_t send_time_ms);
 
diff --git a/audio/utility/BUILD.gn b/audio/utility/BUILD.gn
index fe39b7f..76c09a5 100644
--- a/audio/utility/BUILD.gn
+++ b/audio/utility/BUILD.gn
@@ -22,7 +22,6 @@
 
   deps = [
     "../..:webrtc_common",
-    "../../:typedefs",
     "../../api/audio:audio_frame_api",
     "../../rtc_base:checks",
     "../../rtc_base:rtc_base_approved",
diff --git a/audio/utility/audio_frame_operations.h b/audio/utility/audio_frame_operations.h
index 65a2bad..5993523 100644
--- a/audio/utility/audio_frame_operations.h
+++ b/audio/utility/audio_frame_operations.h
@@ -14,7 +14,6 @@
 #include <stddef.h>
 
 #include "api/audio/audio_frame.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/common_audio/BUILD.gn b/common_audio/BUILD.gn
index 57cf699..50bd0f4 100644
--- a/common_audio/BUILD.gn
+++ b/common_audio/BUILD.gn
@@ -10,14 +10,6 @@
 
 visibility = [ ":*" ]
 
-config("common_audio_config") {
-  include_dirs = [
-    "resampler/include",
-    "signal_processing/include",
-    "vad/include",
-  ]
-}
-
 rtc_static_library("common_audio") {
   visibility += [ "*" ]
   sources = [
@@ -60,17 +52,17 @@
 
   deps = [
     ":common_audio_c",
-    ":fft4g",
     ":sinc_resampler",
     "..:webrtc_common",
-    "../:typedefs",
     "../rtc_base:checks",
     "../rtc_base:gtest_prod",
     "../rtc_base:rtc_base_approved",
     "../rtc_base/memory:aligned_array",
     "../rtc_base/memory:aligned_malloc",
+    "../rtc_base/system:arch",
     "../system_wrappers",
     "../system_wrappers:cpu_features_api",
+    "third_party/fft4g:fft4g",
     "//third_party/abseil-cpp/absl/types:optional",
   ]
 
@@ -80,8 +72,6 @@
     deps += [ ":common_audio_neon" ]
   }
 
-  public_configs = [ ":common_audio_config" ]
-
   if (current_cpu == "x86" || current_cpu == "x64") {
     deps += [ ":common_audio_sse2" ]
   }
@@ -104,10 +94,7 @@
   sources = []
   deps = []
   if (current_cpu == "arm") {
-    sources += [
-      "signal_processing/complex_bit_reverse_arm.S",
-      "signal_processing/spl_sqrt_floor_arm.S",
-    ]
+    sources += [ "signal_processing/complex_bit_reverse_arm.S" ]
 
     if (arm_version >= 7) {
       sources += [ "signal_processing/filter_ar_fast_q12_armv7.S" ]
@@ -180,7 +167,6 @@
       "signal_processing/include/spl_inl_mips.h",
       "signal_processing/min_max_operations_mips.c",
       "signal_processing/resample_by_2_mips.c",
-      "signal_processing/spl_sqrt_floor_mips.c",
     ]
     if (mips_dsp_rev > 0) {
       sources += [ "signal_processing/vector_scaling_operations_mips.c" ]
@@ -193,31 +179,22 @@
     sources += [
       "signal_processing/complex_bit_reverse.c",
       "signal_processing/filter_ar_fast_q12.c",
-      "signal_processing/spl_sqrt_floor.c",
     ]
   }
 
-  public_configs = [ ":common_audio_config" ]
   deps = [
     ":common_audio_c_arm_asm",
     ":common_audio_cc",
-    ":fft4g",
     "..:webrtc_common",
-    "../:typedefs",
     "../rtc_base:checks",
     "../rtc_base:compile_assert_c",
     "../rtc_base:rtc_base_approved",
     "../rtc_base:sanitizer",
+    "../rtc_base/system:arch",
     "../system_wrappers",
     "../system_wrappers:cpu_features_api",
-  ]
-}
-
-rtc_source_set("fft4g") {
-  visibility += webrtc_default_visibility
-  sources = [
-    "fft4g.c",
-    "fft4g.h",
+    "third_party/fft4g:fft4g",
+    "third_party/spl_sqrt_floor",
   ]
 }
 
@@ -227,10 +204,8 @@
     "signal_processing/dot_product_with_scale.h",
   ]
 
-  public_configs = [ ":common_audio_config" ]
   deps = [
     "..:webrtc_common",
-    "../:typedefs",
     "../rtc_base:rtc_base_approved",
     "../system_wrappers",
   ]
@@ -242,10 +217,10 @@
   ]
   deps = [
     "..:webrtc_common",
-    "../:typedefs",
     "../rtc_base:gtest_prod",
     "../rtc_base:rtc_base_approved",
     "../rtc_base/memory:aligned_malloc",
+    "../rtc_base/system:arch",
     "../system_wrappers",
   ]
 }
@@ -269,6 +244,7 @@
     ":fir_filter",
     "../rtc_base:checks",
     "../rtc_base:rtc_base_approved",
+    "../rtc_base/system:arch",
     "../system_wrappers:cpu_features_api",
   ]
   if (current_cpu == "x86" || current_cpu == "x64") {
@@ -310,9 +286,7 @@
     ]
 
     if (current_cpu != "arm64") {
-      # Enable compilation for the NEON instruction set. This is needed
-      # since //build/config/arm.gni only enables NEON for iOS, not Android.
-      # This provides the same functionality as webrtc/build/arm_neon.gypi.
+      # Enable compilation for the NEON instruction set.
       suppressed_configs += [ "//build/config/compiler:compiler_arm_fpu" ]
       cflags = [ "-mfpu=neon" ]
     }
@@ -345,9 +319,7 @@
     ]
 
     if (current_cpu != "arm64") {
-      # Enable compilation for the NEON instruction set. This is needed
-      # since //build/config/arm.gni only enables NEON for iOS, not Android.
-      # This provides the same functionality as webrtc/build/arm_neon.gypi.
+      # Enable compilation for the NEON instruction set.
       suppressed_configs += [ "//build/config/compiler:compiler_arm_fpu" ]
       cflags = [ "-mfpu=neon" ]
     }
@@ -365,6 +337,7 @@
       ":common_audio_c",
       "../rtc_base:checks",
       "../rtc_base:rtc_base_approved",
+      "../rtc_base/system:arch",
     ]
   }
 }
@@ -416,10 +389,10 @@
       ":fir_filter_factory",
       ":sinc_resampler",
       "..:webrtc_common",
-      "../:typedefs",
       "../rtc_base:checks",
       "../rtc_base:rtc_base_approved",
       "../rtc_base:rtc_base_tests_utils",
+      "../rtc_base/system:arch",
       "../system_wrappers:cpu_features_api",
       "../test:fileutils",
       "../test:test_main",
diff --git a/common_audio/audio_util.cc b/common_audio/audio_util.cc
index b442a14..735ba5f 100644
--- a/common_audio/audio_util.cc
+++ b/common_audio/audio_util.cc
@@ -10,8 +10,6 @@
 
 #include "common_audio/include/audio_util.h"
 
-#include "typedefs.h"  // NOLINT(build/include)
-
 namespace webrtc {
 
 void FloatToS16(const float* src, size_t size, int16_t* dest) {
diff --git a/common_audio/audio_util_unittest.cc b/common_audio/audio_util_unittest.cc
index 230669e..cf85a2d 100644
--- a/common_audio/audio_util_unittest.cc
+++ b/common_audio/audio_util_unittest.cc
@@ -13,7 +13,6 @@
 #include "rtc_base/arraysize.h"
 #include "test/gmock.h"
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 namespace {
diff --git a/common_audio/fir_filter_factory.cc b/common_audio/fir_filter_factory.cc
index c15c2e0..3243b27 100644
--- a/common_audio/fir_filter_factory.cc
+++ b/common_audio/fir_filter_factory.cc
@@ -12,6 +12,7 @@
 
 #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)
diff --git a/common_audio/include/audio_util.h b/common_audio/include/audio_util.h
index e4ea9a1..de242a4 100644
--- a/common_audio/include/audio_util.h
+++ b/common_audio/include/audio_util.h
@@ -17,7 +17,6 @@
 #include <limits>
 
 #include "rtc_base/checks.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/common_audio/module.mk b/common_audio/module.mk
index 65acd74..dab66c1 100644
--- a/common_audio/module.mk
+++ b/common_audio/module.mk
@@ -32,7 +32,7 @@
 # TODO(hychao): figure out if common_audio/real_fourier_openmax.o
 # is needed. Build it requires linking openmax dl library.
 common_audio_c_C_OBJECTS = \
-	common_audio/fft4g.o \
+	common_audio/third_party/fft4g/fft4g.o \
 	common_audio/ring_buffer.o \
 	common_audio/signal_processing/auto_corr_to_refl_coef.o \
 	common_audio/signal_processing/auto_correlation.o \
@@ -71,7 +71,7 @@
 	common_audio/signal_processing/complex_fft.o \
 	common_audio/signal_processing/complex_bit_reverse.o \
 	common_audio/signal_processing/filter_ar_fast_q12.o \
-	common_audio/signal_processing/spl_sqrt_floor.o
+	common_audio/third_party/spl_sqrt_floor/spl_sqrt_floor.o
 
 ifeq (${USE_NEON},1)
 common_audio_CXX_OBJECTS += \
diff --git a/common_audio/real_fourier_ooura.cc b/common_audio/real_fourier_ooura.cc
index db65d26..89694c1 100644
--- a/common_audio/real_fourier_ooura.cc
+++ b/common_audio/real_fourier_ooura.cc
@@ -13,7 +13,7 @@
 #include <algorithm>
 #include <cmath>
 
-#include "common_audio/fft4g.h"
+#include "common_audio/third_party/fft4g/fft4g.h"
 #include "rtc_base/checks.h"
 
 namespace webrtc {
diff --git a/common_audio/resampler/include/push_resampler.h b/common_audio/resampler/include/push_resampler.h
index 05b93d1..082cdc6 100644
--- a/common_audio/resampler/include/push_resampler.h
+++ b/common_audio/resampler/include/push_resampler.h
@@ -13,8 +13,6 @@
 
 #include <memory>
 
-#include "typedefs.h"  // NOLINT(build/include)
-
 namespace webrtc {
 
 class PushSincResampler;
diff --git a/common_audio/resampler/include/resampler.h b/common_audio/resampler/include/resampler.h
index f923b46..04c487b 100644
--- a/common_audio/resampler/include/resampler.h
+++ b/common_audio/resampler/include/resampler.h
@@ -16,8 +16,7 @@
 #define COMMON_AUDIO_RESAMPLER_INCLUDE_RESAMPLER_H_
 
 #include <stddef.h>
-
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 namespace webrtc {
 
diff --git a/common_audio/resampler/push_sinc_resampler.h b/common_audio/resampler/push_sinc_resampler.h
index ad51471..1ffe73f 100644
--- a/common_audio/resampler/push_sinc_resampler.h
+++ b/common_audio/resampler/push_sinc_resampler.h
@@ -15,7 +15,6 @@
 
 #include "common_audio/resampler/sinc_resampler.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/common_audio/resampler/push_sinc_resampler_unittest.cc b/common_audio/resampler/push_sinc_resampler_unittest.cc
index 487a09f..2f53a74 100644
--- a/common_audio/resampler/push_sinc_resampler_unittest.cc
+++ b/common_audio/resampler/push_sinc_resampler_unittest.cc
@@ -19,7 +19,6 @@
 #include "rtc_base/timeutils.h"
 #include "test/gmock.h"
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 namespace {
diff --git a/common_audio/resampler/sinc_resampler.cc b/common_audio/resampler/sinc_resampler.cc
index c3d1ea4..5aa2061 100644
--- a/common_audio/resampler/sinc_resampler.cc
+++ b/common_audio/resampler/sinc_resampler.cc
@@ -93,8 +93,8 @@
 #include <limits>
 
 #include "rtc_base/checks.h"
+#include "rtc_base/system/arch.h"
 #include "system_wrappers/include/cpu_features_wrapper.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/common_audio/resampler/sinc_resampler.h b/common_audio/resampler/sinc_resampler.h
index 6306bc9..8a833ce 100644
--- a/common_audio/resampler/sinc_resampler.h
+++ b/common_audio/resampler/sinc_resampler.h
@@ -19,7 +19,7 @@
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/gtest_prod_util.h"
 #include "rtc_base/memory/aligned_malloc.h"
-#include "typedefs.h"  // NOLINT(build/include)
+#include "rtc_base/system/arch.h"
 
 namespace webrtc {
 
diff --git a/common_audio/resampler/sinc_resampler_unittest.cc b/common_audio/resampler/sinc_resampler_unittest.cc
index 90bdf31..eb5424d 100644
--- a/common_audio/resampler/sinc_resampler_unittest.cc
+++ b/common_audio/resampler/sinc_resampler_unittest.cc
@@ -23,6 +23,7 @@
 #include "common_audio/resampler/sinc_resampler.h"
 #include "common_audio/resampler/sinusoidal_linear_chirp_source.h"
 #include "rtc_base/stringize_macros.h"
+#include "rtc_base/system/arch.h"
 #include "rtc_base/timeutils.h"
 #include "system_wrappers/include/cpu_features_wrapper.h"
 #include "test/gmock.h"
diff --git a/common_audio/signal_processing/complex_fft.c b/common_audio/signal_processing/complex_fft.c
index e2ac206..ddc9a97 100644
--- a/common_audio/signal_processing/complex_fft.c
+++ b/common_audio/signal_processing/complex_fft.c
@@ -17,6 +17,7 @@
 
 #include "common_audio/signal_processing/complex_fft_tables.h"
 #include "common_audio/signal_processing/include/signal_processing_library.h"
+#include "rtc_base/system/arch.h"
 
 #define CFFTSFT 14
 #define CFFTRND 1
diff --git a/common_audio/signal_processing/complex_fft_tables.h b/common_audio/signal_processing/complex_fft_tables.h
index 5171040..90fac07 100644
--- a/common_audio/signal_processing/complex_fft_tables.h
+++ b/common_audio/signal_processing/complex_fft_tables.h
@@ -11,7 +11,7 @@
 #ifndef COMMON_AUDIO_SIGNAL_PROCESSING_COMPLEX_FFT_TABLES_H_
 #define COMMON_AUDIO_SIGNAL_PROCESSING_COMPLEX_FFT_TABLES_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 static const int16_t kSinTable1024[] = {
     0,      201,    402,    603,    804,    1005,   1206,   1406,   1607,
diff --git a/common_audio/signal_processing/cross_correlation_neon.c b/common_audio/signal_processing/cross_correlation_neon.c
index fdd03f1..f2afbdf 100644
--- a/common_audio/signal_processing/cross_correlation_neon.c
+++ b/common_audio/signal_processing/cross_correlation_neon.c
@@ -9,6 +9,7 @@
  */
 
 #include "common_audio/signal_processing/include/signal_processing_library.h"
+#include "rtc_base/system/arch.h"
 
 #include <arm_neon.h>
 
diff --git a/common_audio/signal_processing/dot_product_with_scale.h b/common_audio/signal_processing/dot_product_with_scale.h
index ff3c525..bb892d4 100644
--- a/common_audio/signal_processing/dot_product_with_scale.h
+++ b/common_audio/signal_processing/dot_product_with_scale.h
@@ -11,10 +11,9 @@
 #ifndef COMMON_AUDIO_SIGNAL_PROCESSING_DOT_PRODUCT_WITH_SCALE_H_
 #define COMMON_AUDIO_SIGNAL_PROCESSING_DOT_PRODUCT_WITH_SCALE_H_
 
+#include <stdint.h>
 #include <string.h>
 
-#include "typedefs.h"  // NOLINT(build/include)
-
 #ifdef __cplusplus
 extern "C" {
 #endif
diff --git a/common_audio/signal_processing/include/real_fft.h b/common_audio/signal_processing/include/real_fft.h
index 8da243d..8445066 100644
--- a/common_audio/signal_processing/include/real_fft.h
+++ b/common_audio/signal_processing/include/real_fft.h
@@ -11,7 +11,7 @@
 #ifndef COMMON_AUDIO_SIGNAL_PROCESSING_INCLUDE_REAL_FFT_H_
 #define COMMON_AUDIO_SIGNAL_PROCESSING_INCLUDE_REAL_FFT_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 // For ComplexFFT(), the maximum fft order is 10;
 // WebRTC APM uses orders of only 7 and 8.
diff --git a/common_audio/signal_processing/include/signal_processing_library.h b/common_audio/signal_processing/include/signal_processing_library.h
index 4d6edbf..33469d4 100644
--- a/common_audio/signal_processing/include/signal_processing_library.h
+++ b/common_audio/signal_processing/include/signal_processing_library.h
@@ -19,7 +19,6 @@
 
 #include <string.h>
 #include "common_audio/signal_processing/dot_product_with_scale.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 // Macros specific for the fixed point implementation
 #define WEBRTC_SPL_WORD16_MAX 32767
@@ -97,6 +96,9 @@
 // inline functions:
 #include "common_audio/signal_processing/include/spl_inl.h"
 
+// third party math functions
+#include "common_audio/third_party/spl_sqrt_floor/spl_sqrt_floor.h"
+
 // Initialize SPL. Currently it contains only function pointer initialization.
 // If the underlying platform is known to be ARM-Neon (WEBRTC_HAS_NEON defined),
 // the pointers will be assigned to code optimized for Neon; otherwise, generic
@@ -574,7 +576,6 @@
 
 // Math functions
 int32_t WebRtcSpl_Sqrt(int32_t value);
-int32_t WebRtcSpl_SqrtFloor(int32_t value);
 
 // Divisions. Implementations collected in division_operations.c and
 // descriptions at bottom of this file.
@@ -1336,23 +1337,6 @@
 //
 
 //
-// WebRtcSpl_SqrtFloor(...)
-//
-// Returns the square root of the input value |value|. The precision of this
-// function is rounding down integer precision, i.e., sqrt(8) gives 2 as answer.
-// If |value| is a negative number then 0 is returned.
-//
-// Algorithm:
-//
-// An iterative 4 cylce/bit routine
-//
-// Input:
-//      - value     : Value to calculate sqrt of
-//
-// Return value     : Result of the sqrt calculation
-//
-
-//
 // WebRtcSpl_DivU32U16(...)
 //
 // Divides a uint32_t |num| by a uint16_t |den|.
diff --git a/common_audio/signal_processing/real_fft_unittest.cc b/common_audio/signal_processing/real_fft_unittest.cc
index 2d6b7d1..3b43123 100644
--- a/common_audio/signal_processing/real_fft_unittest.cc
+++ b/common_audio/signal_processing/real_fft_unittest.cc
@@ -11,7 +11,6 @@
 #include "common_audio/signal_processing/include/real_fft.h"
 #include "common_audio/signal_processing/include/signal_processing_library.h"
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 namespace {
diff --git a/common_audio/signal_processing/resample_by_2_internal.h b/common_audio/signal_processing/resample_by_2_internal.h
index 5483e2e..145395a 100644
--- a/common_audio/signal_processing/resample_by_2_internal.h
+++ b/common_audio/signal_processing/resample_by_2_internal.h
@@ -16,7 +16,7 @@
 #ifndef COMMON_AUDIO_SIGNAL_PROCESSING_RESAMPLE_BY_2_INTERNAL_H_
 #define COMMON_AUDIO_SIGNAL_PROCESSING_RESAMPLE_BY_2_INTERNAL_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 /*******************************************************************
  * resample_by_2_fast.c
diff --git a/common_audio/third_party/fft4g/BUILD.gn b/common_audio/third_party/fft4g/BUILD.gn
new file mode 100644
index 0000000..ae0d5f6
--- /dev/null
+++ b/common_audio/third_party/fft4g/BUILD.gn
@@ -0,0 +1,16 @@
+# 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("fft4g") {
+  sources = [
+    "fft4g.c",
+    "fft4g.h",
+  ]
+}
diff --git a/common_audio/third_party/fft4g/LICENSE b/common_audio/third_party/fft4g/LICENSE
new file mode 100644
index 0000000..3bf870a
--- /dev/null
+++ b/common_audio/third_party/fft4g/LICENSE
@@ -0,0 +1,8 @@
+/*
+ * http://www.kurims.kyoto-u.ac.jp/~ooura/fft.html
+ * Copyright Takuya OOURA, 1996-2001
+ *
+ * You may use, copy, modify and distribute this code for any purpose (include
+ * commercial use) and without fee. Please refer to this package when you modify
+ * this code.
+ */
diff --git a/common_audio/third_party/fft4g/README.chromium b/common_audio/third_party/fft4g/README.chromium
new file mode 100644
index 0000000..9df2ddb
--- /dev/null
+++ b/common_audio/third_party/fft4g/README.chromium
@@ -0,0 +1,13 @@
+Name: General Purpose FFT (Fast Fourier/Cosine/Sine Transform) Package
+Short Name: fft4g
+URL: http://www.kurims.kyoto-u.ac.jp/~ooura/fft.html
+Version: 0
+Date: 2018-06-19
+License: Custome license
+License File: LICENSE
+Security Critical: yes
+
+Description:
+This is a package to calculate Discrete Fourier/Cosine/Sine Transforms of
+1-dimensional sequences of length 2^N. This package contains C and Fortran
+FFT codes.
diff --git a/common_audio/fft4g.c b/common_audio/third_party/fft4g/fft4g.c
similarity index 100%
rename from common_audio/fft4g.c
rename to common_audio/third_party/fft4g/fft4g.c
diff --git a/common_audio/fft4g.h b/common_audio/third_party/fft4g/fft4g.h
similarity index 61%
rename from common_audio/fft4g.h
rename to common_audio/third_party/fft4g/fft4g.h
index 1750e27..f1f31a1 100644
--- a/common_audio/fft4g.h
+++ b/common_audio/third_party/fft4g/fft4g.h
@@ -1,15 +1,15 @@
 /*
- *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+ *  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
+ *  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 COMMON_AUDIO_FFT4G_H_
-#define COMMON_AUDIO_FFT4G_H_
+#ifndef COMMON_AUDIO_THIRD_PARTY_FFT4G_FFT4G_H_
+#define COMMON_AUDIO_THIRD_PARTY_FFT4G_FFT4G_H_
 
 #if defined(__cplusplus)
 extern "C" {
@@ -22,4 +22,4 @@
 }
 #endif
 
-#endif  // COMMON_AUDIO_FFT4G_H_
+#endif  /* COMMON_AUDIO_THIRD_PARTY_FFT4G_FFT4G_H_ */
diff --git a/common_audio/third_party/fft4g/module.mk b/common_audio/third_party/fft4g/module.mk
new file mode 100644
index 0000000..37c23f4
--- /dev/null
+++ b/common_audio/third_party/fft4g/module.mk
@@ -0,0 +1,5 @@
+# Copyright 2018 The Chromium OS Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+include common.mk
diff --git a/common_audio/third_party/module.mk b/common_audio/third_party/module.mk
new file mode 100644
index 0000000..37c23f4
--- /dev/null
+++ b/common_audio/third_party/module.mk
@@ -0,0 +1,5 @@
+# Copyright 2018 The Chromium OS Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+include common.mk
diff --git a/common_audio/third_party/spl_sqrt_floor/BUILD.gn b/common_audio/third_party/spl_sqrt_floor/BUILD.gn
new file mode 100644
index 0000000..194899e
--- /dev/null
+++ b/common_audio/third_party/spl_sqrt_floor/BUILD.gn
@@ -0,0 +1,26 @@
+# 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("spl_sqrt_floor") {
+  visibility = [ "../..:common_audio_c" ]
+  sources = [
+    "spl_sqrt_floor.h",
+  ]
+  deps = []
+  if (current_cpu == "arm") {
+    sources += [ "spl_sqrt_floor_arm.S" ]
+
+    deps += [ "../../../rtc_base/system:asm_defines" ]
+  } else if (current_cpu == "mipsel") {
+    sources += [ "spl_sqrt_floor_mips.c" ]
+  } else {
+    sources += [ "spl_sqrt_floor.c" ]
+  }
+}
diff --git a/common_audio/third_party/spl_sqrt_floor/LICENSE b/common_audio/third_party/spl_sqrt_floor/LICENSE
new file mode 100644
index 0000000..fdf17a2
--- /dev/null
+++ b/common_audio/third_party/spl_sqrt_floor/LICENSE
@@ -0,0 +1,27 @@
+/*
+ * Written by Wilco Dijkstra, 1996. The following email exchange establishes the
+ * license.
+ *
+ * From: Wilco Dijkstra <Wilco.Dijkstra@ntlworld.com>
+ * Date: Fri, Jun 24, 2011 at 3:20 AM
+ * Subject: Re: sqrt routine
+ * To: Kevin Ma <kma@google.com>
+ * Hi Kevin,
+ * Thanks for asking. Those routines are public domain (originally posted to
+ * comp.sys.arm a long time ago), so you can use them freely for any purpose.
+ * Cheers,
+ * Wilco
+ *
+ * ----- Original Message -----
+ * From: "Kevin Ma" <kma@google.com>
+ * To: <Wilco.Dijkstra@ntlworld.com>
+ * Sent: Thursday, June 23, 2011 11:44 PM
+ * Subject: Fwd: sqrt routine
+ * Hi Wilco,
+ * I saw your sqrt routine from several web sites, including
+ * http://www.finesse.demon.co.uk/steven/sqrt.html.
+ * Just wonder if there's any copyright information with your Successive
+ * approximation routines, or if I can freely use it for any purpose.
+ * Thanks.
+ * Kevin
+ */
diff --git a/common_audio/third_party/spl_sqrt_floor/README.chromium b/common_audio/third_party/spl_sqrt_floor/README.chromium
new file mode 100644
index 0000000..b226490
--- /dev/null
+++ b/common_audio/third_party/spl_sqrt_floor/README.chromium
@@ -0,0 +1,12 @@
+Name: sql sqrt floor
+Short Name: sql_sqrt_floor
+URL: http://www.pertinentdetail.org/sqrt
+Version: 0
+Date: 2018-03-22
+License: Custom license
+License File: LICENSE
+Security Critical: yes
+
+Description:
+Sqrt routine, originally was posted to the USENET group comp.sys.arm on
+20 Jun 1996.
diff --git a/common_audio/third_party/spl_sqrt_floor/module.mk b/common_audio/third_party/spl_sqrt_floor/module.mk
new file mode 100644
index 0000000..37c23f4
--- /dev/null
+++ b/common_audio/third_party/spl_sqrt_floor/module.mk
@@ -0,0 +1,5 @@
+# Copyright 2018 The Chromium OS Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+include common.mk
diff --git a/common_audio/signal_processing/spl_sqrt_floor.c b/common_audio/third_party/spl_sqrt_floor/spl_sqrt_floor.c
similarity index 96%
rename from common_audio/signal_processing/spl_sqrt_floor.c
rename to common_audio/third_party/spl_sqrt_floor/spl_sqrt_floor.c
index 7141386..b478a41 100644
--- a/common_audio/signal_processing/spl_sqrt_floor.c
+++ b/common_audio/third_party/spl_sqrt_floor/spl_sqrt_floor.c
@@ -28,7 +28,7 @@
 
 // Minor modifications in code style for WebRTC, 2012.
 
-#include "common_audio/signal_processing/include/signal_processing_library.h"
+#include "common_audio/third_party/spl_sqrt_floor/spl_sqrt_floor.h"
 
 /*
  * Algorithm:
diff --git a/common_audio/third_party/spl_sqrt_floor/spl_sqrt_floor.h b/common_audio/third_party/spl_sqrt_floor/spl_sqrt_floor.h
new file mode 100644
index 0000000..eaa58e3
--- /dev/null
+++ b/common_audio/third_party/spl_sqrt_floor/spl_sqrt_floor.h
@@ -0,0 +1,29 @@
+/*
+ *  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 <stdint.h>
+
+//
+// WebRtcSpl_SqrtFloor(...)
+//
+// Returns the square root of the input value |value|. The precision of this
+// function is rounding down integer precision, i.e., sqrt(8) gives 2 as answer.
+// If |value| is a negative number then 0 is returned.
+//
+// Algorithm:
+//
+// An iterative 4 cylce/bit routine
+//
+// Input:
+//      - value     : Value to calculate sqrt of
+//
+// Return value     : Result of the sqrt calculation
+//
+int32_t WebRtcSpl_SqrtFloor(int32_t value);
diff --git a/common_audio/signal_processing/spl_sqrt_floor_arm.S b/common_audio/third_party/spl_sqrt_floor/spl_sqrt_floor_arm.S
similarity index 100%
rename from common_audio/signal_processing/spl_sqrt_floor_arm.S
rename to common_audio/third_party/spl_sqrt_floor/spl_sqrt_floor_arm.S
diff --git a/common_audio/signal_processing/spl_sqrt_floor_mips.c b/common_audio/third_party/spl_sqrt_floor/spl_sqrt_floor_mips.c
similarity index 98%
rename from common_audio/signal_processing/spl_sqrt_floor_mips.c
rename to common_audio/third_party/spl_sqrt_floor/spl_sqrt_floor_mips.c
index 7128fbd..04033c1 100644
--- a/common_audio/signal_processing/spl_sqrt_floor_mips.c
+++ b/common_audio/third_party/spl_sqrt_floor/spl_sqrt_floor_mips.c
@@ -29,7 +29,7 @@
 // Minor modifications in code style for WebRTC, 2012.
 // Code optimizations for MIPS, 2013.
 
-#include "common_audio/signal_processing/include/signal_processing_library.h"
+#include "common_audio/third_party/spl_sqrt_floor/spl_sqrt_floor.h"
 
 /*
  * Algorithm:
diff --git a/common_audio/vad/include/vad.h b/common_audio/vad/include/vad.h
index bd10756..b15275b 100644
--- a/common_audio/vad/include/vad.h
+++ b/common_audio/vad/include/vad.h
@@ -15,7 +15,6 @@
 
 #include "common_audio/vad/include/webrtc_vad.h"
 #include "rtc_base/checks.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/common_audio/vad/include/webrtc_vad.h b/common_audio/vad/include/webrtc_vad.h
index a6c539c..f5bbadf 100644
--- a/common_audio/vad/include/webrtc_vad.h
+++ b/common_audio/vad/include/webrtc_vad.h
@@ -17,8 +17,7 @@
 #define COMMON_AUDIO_VAD_INCLUDE_WEBRTC_VAD_H_
 
 #include <stddef.h>
-
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 typedef struct WebRtcVadInst VadInst;
 
diff --git a/common_audio/vad/vad_core.c b/common_audio/vad/vad_core.c
index 7316b45..55927ce 100644
--- a/common_audio/vad/vad_core.c
+++ b/common_audio/vad/vad_core.c
@@ -15,7 +15,6 @@
 #include "common_audio/vad/vad_filterbank.h"
 #include "common_audio/vad/vad_gmm.h"
 #include "common_audio/vad/vad_sp.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 // Spectrum Weighting
 static const int16_t kSpectrumWeight[kNumChannels] = { 6, 8, 10, 12, 14, 16 };
diff --git a/common_audio/vad/vad_core.h b/common_audio/vad/vad_core.h
index 0eb8de3..e79696c 100644
--- a/common_audio/vad/vad_core.h
+++ b/common_audio/vad/vad_core.h
@@ -16,7 +16,6 @@
 #define COMMON_AUDIO_VAD_VAD_CORE_H_
 
 #include "common_audio/signal_processing/include/signal_processing_library.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 enum { kNumChannels = 6 };   // Number of frequency bands (named channels).
 enum { kNumGaussians = 2 };  // Number of Gaussians per channel in the GMM.
diff --git a/common_audio/vad/vad_core_unittest.cc b/common_audio/vad/vad_core_unittest.cc
index 0587878..3131a86 100644
--- a/common_audio/vad/vad_core_unittest.cc
+++ b/common_audio/vad/vad_core_unittest.cc
@@ -12,7 +12,6 @@
 
 #include "common_audio/vad/vad_unittest.h"
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 extern "C" {
 #include "common_audio/vad/vad_core.h"
diff --git a/common_audio/vad/vad_filterbank.c b/common_audio/vad/vad_filterbank.c
index 82cff25..1513153 100644
--- a/common_audio/vad/vad_filterbank.c
+++ b/common_audio/vad/vad_filterbank.c
@@ -12,7 +12,6 @@
 
 #include "rtc_base/checks.h"
 #include "common_audio/signal_processing/include/signal_processing_library.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 // Constants used in LogOfEnergy().
 static const int16_t kLogConst = 24660;  // 160*log10(2) in Q9.
diff --git a/common_audio/vad/vad_filterbank.h b/common_audio/vad/vad_filterbank.h
index 60b785b..53bbbe1 100644
--- a/common_audio/vad/vad_filterbank.h
+++ b/common_audio/vad/vad_filterbank.h
@@ -16,7 +16,6 @@
 #define COMMON_AUDIO_VAD_VAD_FILTERBANK_H_
 
 #include "common_audio/vad/vad_core.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 // Takes |data_length| samples of |data_in| and calculates the logarithm of the
 // energy of each of the |kNumChannels| = 6 frequency bands used by the VAD:
diff --git a/common_audio/vad/vad_filterbank_unittest.cc b/common_audio/vad/vad_filterbank_unittest.cc
index b800044..51d8d0f 100644
--- a/common_audio/vad/vad_filterbank_unittest.cc
+++ b/common_audio/vad/vad_filterbank_unittest.cc
@@ -12,7 +12,6 @@
 
 #include "common_audio/vad/vad_unittest.h"
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 extern "C" {
 #include "common_audio/vad/vad_core.h"
diff --git a/common_audio/vad/vad_gmm.c b/common_audio/vad/vad_gmm.c
index b746fd5..ddc87b6 100644
--- a/common_audio/vad/vad_gmm.c
+++ b/common_audio/vad/vad_gmm.c
@@ -11,7 +11,6 @@
 #include "common_audio/vad/vad_gmm.h"
 
 #include "common_audio/signal_processing/include/signal_processing_library.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 static const int32_t kCompVar = 22005;
 static const int16_t kLog2Exp = 5909;  // log2(exp(1)) in Q12.
diff --git a/common_audio/vad/vad_gmm.h b/common_audio/vad/vad_gmm.h
index 79f15c8..6b2d11b 100644
--- a/common_audio/vad/vad_gmm.h
+++ b/common_audio/vad/vad_gmm.h
@@ -13,7 +13,7 @@
 #ifndef COMMON_AUDIO_VAD_VAD_GMM_H_
 #define COMMON_AUDIO_VAD_VAD_GMM_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 // Calculates the probability for |input|, given that |input| comes from a
 // normal distribution with mean and standard deviation (|mean|, |std|).
diff --git a/common_audio/vad/vad_gmm_unittest.cc b/common_audio/vad/vad_gmm_unittest.cc
index e77603d..be61f7f 100644
--- a/common_audio/vad/vad_gmm_unittest.cc
+++ b/common_audio/vad/vad_gmm_unittest.cc
@@ -10,7 +10,6 @@
 
 #include "common_audio/vad/vad_unittest.h"
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 extern "C" {
 #include "common_audio/vad/vad_gmm.h"
diff --git a/common_audio/vad/vad_sp.c b/common_audio/vad/vad_sp.c
index 915fb37..d367c8b 100644
--- a/common_audio/vad/vad_sp.c
+++ b/common_audio/vad/vad_sp.c
@@ -13,7 +13,6 @@
 #include "rtc_base/checks.h"
 #include "common_audio/signal_processing/include/signal_processing_library.h"
 #include "common_audio/vad/vad_core.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 // Allpass filter coefficients, upper and lower, in Q13.
 // Upper: 0.64, Lower: 0.17.
diff --git a/common_audio/vad/vad_sp.h b/common_audio/vad/vad_sp.h
index 8586ccd..ff36760 100644
--- a/common_audio/vad/vad_sp.h
+++ b/common_audio/vad/vad_sp.h
@@ -14,7 +14,6 @@
 #define COMMON_AUDIO_VAD_VAD_SP_H_
 
 #include "common_audio/vad/vad_core.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 // Downsamples the signal by a factor 2, eg. 32->16 or 16->8.
 //
diff --git a/common_audio/vad/vad_sp_unittest.cc b/common_audio/vad/vad_sp_unittest.cc
index ebe25cf..cdde56d 100644
--- a/common_audio/vad/vad_sp_unittest.cc
+++ b/common_audio/vad/vad_sp_unittest.cc
@@ -12,7 +12,6 @@
 
 #include "common_audio/vad/vad_unittest.h"
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 extern "C" {
 #include "common_audio/vad/vad_core.h"
diff --git a/common_audio/vad/vad_unittest.cc b/common_audio/vad/vad_unittest.cc
index 1cef8e9..c54014e 100644
--- a/common_audio/vad/vad_unittest.cc
+++ b/common_audio/vad/vad_unittest.cc
@@ -17,7 +17,6 @@
 #include "rtc_base/arraysize.h"
 #include "rtc_base/checks.h"
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 VadTest::VadTest() {}
 
diff --git a/common_audio/vad/vad_unittest.h b/common_audio/vad/vad_unittest.h
index 5521983..ee64206 100644
--- a/common_audio/vad/vad_unittest.h
+++ b/common_audio/vad/vad_unittest.h
@@ -14,7 +14,6 @@
 #include <stddef.h>  // size_t
 
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 namespace test {
diff --git a/common_audio/vad/webrtc_vad.c b/common_audio/vad/webrtc_vad.c
index 7fc4d65..d8457ee 100644
--- a/common_audio/vad/webrtc_vad.c
+++ b/common_audio/vad/webrtc_vad.c
@@ -15,7 +15,6 @@
 
 #include "common_audio/signal_processing/include/signal_processing_library.h"
 #include "common_audio/vad/vad_core.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 static const int kInitCheck = 42;
 static const int kValidRates[] = { 8000, 16000, 32000, 48000 };
diff --git a/common_audio/wav_file.cc b/common_audio/wav_file.cc
index 21b64a8..008891f 100644
--- a/common_audio/wav_file.cc
+++ b/common_audio/wav_file.cc
@@ -19,6 +19,7 @@
 #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 {
 
diff --git a/common_audio/wav_header.cc b/common_audio/wav_header.cc
index d093fa0..8fc5fef 100644
--- a/common_audio/wav_header.cc
+++ b/common_audio/wav_header.cc
@@ -21,6 +21,7 @@
 
 #include "common_audio/include/audio_util.h"
 #include "rtc_base/checks.h"
+#include "rtc_base/system/arch.h"
 
 namespace webrtc {
 namespace {
diff --git a/common_types.h b/common_types.h
index 919a947..60d88b3 100644
--- a/common_types.h
+++ b/common_types.h
@@ -21,7 +21,6 @@
 #include "api/video/video_bitrate_allocation.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/deprecation.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 #if defined(_MSC_VER)
 // Disable "new behavior: elements of array will be default initialized"
@@ -60,14 +59,8 @@
         jitter(0) {}
 
   uint8_t fraction_lost;
-  union {
-    int32_t packets_lost;  // Defined as a 24 bit signed integer in RTCP
-    RTC_DEPRECATED uint32_t cumulative_lost;
-  };
-  union {
-    uint32_t extended_highest_sequence_number;
-    RTC_DEPRECATED uint32_t extended_max_sequence_number;
-  };
+  int32_t packets_lost;  // Defined as a 24 bit signed integer in RTCP
+  uint32_t extended_highest_sequence_number;
   uint32_t jitter;
 };
 
@@ -340,21 +333,13 @@
 // Video codec types
 enum VideoCodecType {
   // There are various memset(..., 0, ...) calls in the code that rely on
-  // kVideoCodecUnknown being zero.
-  kVideoCodecUnknown = 0,
+  // kVideoCodecGeneric being zero.
+  kVideoCodecGeneric = 0,
   kVideoCodecVP8,
   kVideoCodecVP9,
   kVideoCodecH264,
   kVideoCodecI420,
-  kVideoCodecGeneric,
   kVideoCodecMultiplex,
-
-  // TODO(nisse): Deprecated aliases, for code expecting RtpVideoCodecTypes.
-  kRtpVideoNone = kVideoCodecUnknown,
-  kRtpVideoGeneric = kVideoCodecGeneric,
-  kRtpVideoVp8 = kVideoCodecVP8,
-  kRtpVideoVp9 = kVideoCodecVP9,
-  kRtpVideoH264 = kVideoCodecH264,
 };
 
 // Translates from name of codec to codec type and vice versa.
@@ -367,6 +352,7 @@
 
   unsigned short width;
   unsigned short height;
+  float maxFramerate;  // fps.
   unsigned char numberOfTemporalLayers;
   unsigned int maxBitrate;     // kilobits/sec.
   unsigned int targetBitrate;  // kilobits/sec.
@@ -410,21 +396,6 @@
   double initial_var_noise;
 };
 
-// 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.
-  int64_t not_before;  // 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.
-};
-
 // Minimum and maximum playout delay values from capture to render.
 // These are best effort values.
 //
diff --git a/modules/audio_coding/BUILD.gn b/modules/audio_coding/BUILD.gn
index 82cde8e..de2aeb7 100644
--- a/modules/audio_coding/BUILD.gn
+++ b/modules/audio_coding/BUILD.gn
@@ -66,7 +66,6 @@
     "acm2/rent_a_codec.h",
   ]
   deps = [
-           "../..:typedefs",
            "../../rtc_base:checks",
            "../../api:array_view",
            "//third_party/abseil-cpp/absl/types:optional",
@@ -84,19 +83,11 @@
   defines = audio_codec_defines
 }
 
-config("audio_coding_config") {
-  include_dirs = [
-    "include",
-    "../include",
-  ]
-}
-
 rtc_source_set("audio_coding_module_typedefs") {
   sources = [
     "include/audio_coding_module_typedefs.h",
   ]
   deps = [
-    "../..:typedefs",
     "../..:webrtc_common",
   ]
 }
@@ -119,8 +110,6 @@
 
   defines = []
 
-  public_configs = [ ":audio_coding_config" ]
-
   if (rtc_include_opus) {
     public_deps = [
       ":webrtc_opus",
@@ -131,7 +120,6 @@
            "../../api/audio:audio_frame_api",
            "..:module_api",
            "../../common_audio:common_audio_c",
-           "../..:typedefs",
            "../../rtc_base:deprecation",
            "../../rtc_base:checks",
            "../../system_wrappers:metrics_api",
@@ -160,10 +148,6 @@
   ]
 }
 
-config("cng_config") {
-  include_dirs = [ "codecs/cng/include" ]
-}
-
 rtc_static_library("cng") {
   visibility += [ "*" ]
   sources = [
@@ -173,10 +157,7 @@
     "codecs/cng/webrtc_cng.h",
   ]
 
-  public_configs = [ ":cng_config" ]
-
   deps = [
-    "../..:typedefs",
     "../..:webrtc_common",
     "../../api:array_view",
     "../../api/audio_codecs:audio_codecs_api",
@@ -186,10 +167,6 @@
   ]
 }
 
-config("red_config") {
-  include_dirs = [ "codecs/red" ]
-}
-
 rtc_static_library("red") {
   visibility += [ "*" ]
   sources = [
@@ -197,8 +174,6 @@
     "codecs/red/audio_encoder_copy_red.h",
   ]
 
-  public_configs = [ ":red_config" ]
-
   deps = [
     "../../api/audio_codecs:audio_codecs_api",
     "../../common_audio",
@@ -207,10 +182,6 @@
   ]
 }
 
-config("g711_config") {
-  include_dirs = [ "codecs/g711/include" ]
-}
-
 rtc_static_library("g711") {
   visibility += [ "*" ]
   poisonous = [ "audio_codecs" ]
@@ -221,8 +192,6 @@
     "codecs/g711/audio_encoder_pcm.h",
   ]
 
-  public_configs = [ ":g711_config" ]
-
   deps = [
     ":legacy_encoded_audio_frame",
     "../..:webrtc_common",
@@ -242,24 +211,11 @@
     "codecs/g711/g711_interface.h",
   ]
   deps = [
-    ":g711_3p",
-    "../..:typedefs",
     "../..:webrtc_common",
+    "../third_party/g711:g711_3p",
   ]
 }
 
-rtc_source_set("g711_3p") {
-  poisonous = [ "audio_codecs" ]
-  sources = [
-    "codecs/g711/g711.c",
-    "codecs/g711/g711.h",
-  ]
-}
-
-config("g722_config") {
-  include_dirs = [ "codecs/g722/include" ]
-}
-
 rtc_static_library("g722") {
   visibility += [ "*" ]
   poisonous = [ "audio_codecs" ]
@@ -270,8 +226,6 @@
     "codecs/g722/audio_encoder_g722.h",
   ]
 
-  public_configs = [ ":g722_config" ]
-
   deps = [
     ":legacy_encoded_audio_frame",
     "../..:webrtc_common",
@@ -292,25 +246,11 @@
     "codecs/g722/g722_interface.h",
   ]
   deps = [
-    ":g722_3p",
-    "../..:typedefs",
     "../..:webrtc_common",
+    "../third_party/g722:g722_3p",
   ]
 }
 
-rtc_source_set("g722_3p") {
-  poisonous = [ "audio_codecs" ]
-  sources = [
-    "codecs/g722/g722_decode.c",
-    "codecs/g722/g722_enc_dec.h",
-    "codecs/g722/g722_encode.c",
-  ]
-}
-
-config("ilbc_config") {
-  include_dirs = [ "codecs/ilbc/include" ]
-}
-
 rtc_static_library("ilbc") {
   visibility += webrtc_default_visibility
   poisonous = [ "audio_codecs" ]
@@ -321,8 +261,6 @@
     "codecs/ilbc/audio_encoder_ilbc.h",
   ]
 
-  public_configs = [ ":ilbc_config" ]
-
   deps = [
     ":legacy_encoded_audio_frame",
     "../..:webrtc_common",
@@ -481,10 +419,7 @@
     "codecs/ilbc/xcorr_coef.h",
   ]
 
-  public_configs = [ ":ilbc_config" ]
-
   deps = [
-    "../..:typedefs",
     "../..:webrtc_common",
     "../../api/audio_codecs:audio_codecs_api",
     "../../common_audio",
@@ -492,6 +427,8 @@
     "../../rtc_base:checks",
     "../../rtc_base:rtc_base_approved",
     "../../rtc_base:sanitizer",
+    "../../rtc_base/system:arch",
+    "../../rtc_base/system:unused",
   ]
 }
 
@@ -507,7 +444,6 @@
   ]
   deps = [
     ":isac_bwinfo",
-    "../..:typedefs",
     "../..:webrtc_common",
     "../../api/audio_codecs:audio_codecs_api",
     "../../rtc_base:checks",
@@ -516,10 +452,6 @@
   ]
 }
 
-config("isac_config") {
-  include_dirs = [ "codecs/isac/main/include" ]
-}
-
 rtc_static_library("isac") {
   visibility += [ "*" ]
   poisonous = [ "audio_codecs" ]
@@ -543,9 +475,7 @@
   sources = [
     "codecs/isac/bandwidth_info.h",
   ]
-  deps = [
-    "../..:typedefs",
-  ]
+  deps = []
 }
 
 rtc_source_set("isac_vad") {
@@ -565,9 +495,10 @@
   ]
   deps = [
     ":isac_bwinfo",
-    "../..:typedefs",
     "../../rtc_base:compile_assert_c",
+    "../../rtc_base/system:arch",
     "../../rtc_base/system:ignore_warnings",
+    "../third_party/fft",
   ]
 }
 
@@ -619,37 +550,20 @@
     libs = [ "m" ]
   }
 
-  public_configs = [ ":isac_config" ]
-
   deps = [
-    ":fft",
     ":isac_bwinfo",
     ":isac_vad",
-    "../..:typedefs",
     "../..:webrtc_common",
     "../../common_audio",
     "../../common_audio:common_audio_c",
     "../../rtc_base:checks",
     "../../rtc_base:compile_assert_c",
     "../../rtc_base:rtc_base_approved",
+    "../../rtc_base/system:arch",
+    "../third_party/fft",
   ]
 }
 
-rtc_source_set("fft") {
-  poisonous = [ "audio_codecs" ]
-  sources = [
-    "codecs/isac/main/source/fft.c",
-    "codecs/isac/main/source/fft.h",
-  ]
-  deps = [
-    ":isac_vad",
-  ]
-}
-
-config("isac_fix_config") {
-  include_dirs = [ "codecs/isac/fix/include" ]
-}
-
 rtc_static_library("isac_fix") {
   visibility += [ "*" ]
   poisonous = [ "audio_codecs" ]
@@ -658,8 +572,6 @@
     "codecs/isac/fix/source/audio_encoder_isacfix.cc",
   ]
 
-  public_configs = [ ":isac_fix_config" ]
-
   deps = [
     ":isac_common",
     "../../api/audio_codecs:audio_codecs_api",
@@ -687,10 +599,8 @@
     "codecs/isac/fix/source/structs.h",
     "codecs/isac/fix/source/transform_tables.c",
   ]
-  public_configs = [ ":isac_fix_config" ]
   deps = [
     ":isac_bwinfo",
-    "../..:typedefs",
     "../../common_audio",
     "../../common_audio:common_audio_c",
   ]
@@ -755,12 +665,9 @@
     "codecs/isac/fix/source/transform.c",
   ]
 
-  public_configs = [ ":isac_fix_config" ]
-
   deps = [
     ":isac_bwinfo",
     ":isac_common",
-    "../..:typedefs",
     "../..:webrtc_common",
     "../../api/audio_codecs:audio_codecs_api",
     "../../common_audio",
@@ -770,6 +677,7 @@
     "../../rtc_base:rtc_base_approved",
     "../../rtc_base:sanitizer",
     "../../system_wrappers:cpu_features_api",
+    "../third_party/fft",
   ]
 
   public_deps = [
@@ -778,6 +686,13 @@
 
   if (rtc_build_with_neon) {
     deps += [ ":isac_neon" ]
+
+    # TODO(bugs.webrtc.org/9579): Consider moving the usage of NEON from
+    # pitch_estimator_c.c into the "isac_neon" target and delete this flag:
+    if (current_cpu != "arm64") {
+      suppressed_configs += [ "//build/config/compiler:compiler_arm_fpu" ]
+      cflags = [ "-mfpu=neon" ]
+    }
   }
 
   if (current_cpu == "arm" && arm_version >= 7) {
@@ -825,9 +740,7 @@
     ]
 
     if (current_cpu != "arm64") {
-      # Enable compilation for the NEON instruction set. This is needed
-      # since //build/config/arm.gni only enables NEON for iOS, not Android.
-      # This provides the same functionality as webrtc/build/arm_neon.gypi.
+      # Enable compilation for the NEON instruction set.
       suppressed_configs += [ "//build/config/compiler:compiler_arm_fpu" ]
       cflags = [ "-mfpu=neon" ]
     }
@@ -851,10 +764,6 @@
   }
 }
 
-config("pcm16b_config") {
-  include_dirs = [ "codecs/pcm16b/include" ]
-}
-
 rtc_static_library("pcm16b") {
   visibility += [ "*" ]
   poisonous = [ "audio_codecs" ]
@@ -878,7 +787,6 @@
   public_deps = [
     ":pcm16b_c",
   ]
-  public_configs = [ ":pcm16b_config" ]
 }
 
 rtc_source_set("pcm16b_c") {
@@ -888,9 +796,7 @@
     "codecs/pcm16b/pcm16b.h",
   ]
 
-  public_configs = [ ":pcm16b_config" ]
   deps = [
-    "../..:typedefs",
     "../..:webrtc_common",
   ]
 }
@@ -952,7 +858,6 @@
   }
 
   deps = [
-    "../..:typedefs",
     "../..:webrtc_common",
     "../../rtc_base:checks",
     "../../rtc_base:rtc_base_approved",
@@ -1140,7 +1045,6 @@
     ":cng",
     ":neteq_decoder_enum",
     "..:module_api",
-    "../..:typedefs",
     "../..:webrtc_common",
     "../../api:libjingle_peerconnection_api",
     "../../api/audio:audio_frame_api",
@@ -1181,14 +1085,8 @@
     "neteq/tools/packet_source.h",
   ]
 
-  if (!build_with_chromium && is_clang) {
-    # Suppress warnings from the Chromium Clang plugin (bugs.webrtc.org/163).
-    suppressed_configs += [ "//build/config/clang:find_bad_constructs" ]
-  }
-
   deps = [
     ":neteq",
-    "../..:typedefs",
     "../..:webrtc_common",
     "../../api:libjingle_peerconnection_api",
     "../../api/audio:audio_frame_api",
@@ -1220,8 +1118,6 @@
     "neteq/tools/rtp_generator.h",
   ]
 
-  public_configs = [ ":neteq_tools_config" ]
-
   if (!build_with_chromium && is_clang) {
     # Suppress warnings from the Chromium Clang plugin (bugs.webrtc.org/163).
     suppressed_configs += [ "//build/config/clang:find_bad_constructs" ]
@@ -1229,7 +1125,6 @@
 
   deps = [
     ":pcm16b",
-    "../..:typedefs",
     "../..:webrtc_common",
     "../../api:array_view",
     "../../api:libjingle_peerconnection_api",
@@ -1238,6 +1133,7 @@
     "../../rtc_base:rtc_base",
     "../../rtc_base:rtc_base_approved",
     "../../rtc_base:rtc_base_tests_utils",
+    "../../rtc_base/system:arch",
     "../../test:rtp_test_utils",
     "../rtp_rtcp",
     "../rtp_rtcp:rtp_rtcp_format",
@@ -1257,10 +1153,6 @@
   }
 }
 
-config("neteq_tools_config") {
-  include_dirs = [ "tools" ]
-}
-
 rtc_source_set("neteq_tools") {
   visibility += webrtc_default_visibility
   sources = [
@@ -1274,8 +1166,6 @@
     "neteq/tools/neteq_stats_getter.h",
   ]
 
-  public_configs = [ ":neteq_tools_config" ]
-
   if (!build_with_chromium && is_clang) {
     # Suppress warnings from the Chromium Clang plugin (bugs.webrtc.org/163).
     suppressed_configs += [ "//build/config/clang:find_bad_constructs" ]
@@ -1283,7 +1173,6 @@
 
   deps = [
     "..:module_api",
-    "../..:typedefs",
     "../..:webrtc_common",
     "../../api:array_view",
     "../../api/audio_codecs:audio_codecs_api",
@@ -1310,7 +1199,6 @@
   ]
 
   deps = [
-    "../..:typedefs",
     "../..:webrtc_common",
     "../../common_audio",
     "../../rtc_base:checks",
@@ -1436,10 +1324,10 @@
       ":audio_format_conversion",
       ":pcm16b_c",
       "..:module_api",
-      "../..:typedefs",
       "../..:webrtc_common",
       "../../api/audio:audio_frame_api",
       "../../api/audio_codecs:builtin_audio_decoder_factory",
+      "../../api/audio_codecs:builtin_audio_encoder_factory",
       "../../rtc_base:checks",
       "../../rtc_base:rtc_base_approved",
       "../../rtc_base/synchronization:rw_lock_wrapper",
@@ -1466,7 +1354,6 @@
     deps = [
       ":neteq_test_support",
       ":neteq_test_tools",
-      "../..:typedefs",
       "../..:webrtc_common",
       "../../api/audio_codecs/opus:audio_encoder_opus",
       "../../rtc_base:protobuf_utils",
@@ -1519,8 +1406,10 @@
              "../../api/audio:audio_frame_api",
              "../../rtc_base:checks",
              ":audio_coding",
+             ":audio_format_conversion",
              ":neteq_tools",
              "../../api/audio_codecs:builtin_audio_decoder_factory",
+             "../../api/audio_codecs:builtin_audio_encoder_factory",
              "../../api/audio_codecs:audio_codecs_api",
              "../../rtc_base:rtc_base_approved",
              "../../test:test_support",
@@ -1545,7 +1434,6 @@
       ":audio_coding_module_typedefs",
       ":audio_format_conversion",
       "..:module_api",
-      "../..:typedefs",
       "../../:webrtc_common",
       "../../api/audio:audio_frame_api",
       "../../api/audio_codecs:builtin_audio_decoder_factory",
@@ -1580,31 +1468,23 @@
       "neteq/audio_decoder_unittest.cc",
     ]
 
-    if (!build_with_chromium && is_clang) {
-      # Suppress warnings from the Chromium Clang plugin (bugs.webrtc.org/163).
-      suppressed_configs += [ "//build/config/clang:find_bad_constructs" ]
-    }
-
-    deps = [
-      "../../test:fileutils",
-    ]
-
     defines = neteq_defines
 
-    deps += audio_coding_deps
-    deps += [
-      ":ilbc",
-      ":isac",
-      ":isac_fix",
-      ":neteq",
-      ":neteq_tools",
-      "../../api/audio_codecs:audio_codecs_api",
-      "../../api/audio_codecs/opus:audio_encoder_opus",
-      "../../common_audio",
-      "../../rtc_base:protobuf_utils",
-      "../../test:test_main",
-      "//testing/gtest",
-    ]
+    deps = [
+             ":ilbc",
+             ":isac",
+             ":isac_fix",
+             ":neteq",
+             ":neteq_tools",
+             "../../test:fileutils",
+             "../../api/audio_codecs:audio_codecs_api",
+             "../../api/audio_codecs/opus:audio_encoder_opus",
+             "../../common_audio",
+             "../../rtc_base:protobuf_utils",
+             "../../rtc_base/system:arch",
+             "../../test:test_main",
+             "//testing/gtest",
+           ] + audio_coding_deps
 
     data = audio_decoder_unittests_resources
 
@@ -1615,7 +1495,7 @@
     if (is_ios) {
       deps += [ ":audio_decoder_unittests_bundle_data" ]
     }
-  }  # audio_decoder_unittests
+  }
 
   if (rtc_enable_protobuf) {
     proto_library("neteq_unittest_proto") {
@@ -1629,8 +1509,8 @@
       testonly = true
       defines = []
       deps = [
-        "../..:typedefs",
         "../../rtc_base:checks",
+        "../../test:field_trial",
         "../../test:fileutils",
       ]
       sources = [
@@ -1673,7 +1553,6 @@
     testonly = true
     defines = []
     deps = [
-      "../..:typedefs",
       "../../test:fileutils",
     ]
     sources = [
@@ -1732,7 +1611,6 @@
       ":neteq",
       ":neteq_test_tools",
       ":pcm16b",
-      "../..:typedefs",
       "../..:webrtc_common",
       "../../api/audio:audio_frame_api",
       "../../api/audio_codecs:audio_codecs_api",
@@ -1761,7 +1639,6 @@
     deps = [
       ":neteq",
       ":neteq_test_tools",
-      "../..:typedefs",
       "../..:webrtc_common",
       "../../api/audio_codecs:builtin_audio_decoder_factory",
       "../../rtc_base:checks",
@@ -1777,7 +1654,6 @@
 
     deps = audio_coding_deps + [
              "//third_party/abseil-cpp/absl/memory",
-             "../..:typedefs",
              ":audio_coding",
              ":neteq_input_audio_tools",
              "../../api/audio:audio_frame_api",
@@ -1802,7 +1678,6 @@
     testonly = true
 
     deps = audio_coding_deps + [
-             "../..:typedefs",
              "../../system_wrappers:system_wrappers_default",
              "../rtp_rtcp:rtp_rtcp_format",
              "../../api:array_view",
@@ -1847,11 +1722,6 @@
       "../../system_wrappers:system_wrappers_default",
       "//testing/gtest",
     ]
-
-    if (!build_with_chromium && is_clang) {
-      # Suppress warnings from the Chromium Clang plugin (bugs.webrtc.org/163).
-      suppressed_configs += [ "//build/config/clang:find_bad_constructs" ]
-    }
   }
 
   rtc_executable("neteq_opus_quality_test") {
@@ -1882,7 +1752,6 @@
     deps = [
       ":neteq",
       ":neteq_test_support",
-      "../..:typedefs",
       "../..:webrtc_common",
       "../../rtc_base:rtc_base_approved",
       "../../system_wrappers:system_wrappers_default",
@@ -2001,12 +1870,6 @@
       "codecs/isac/main/test/simpleKenny.c",
     ]
 
-    include_dirs = [
-      "codecs/isac/main/include",
-      "codecs/isac/main/test",
-      "codecs/isac/main/util",
-    ]
-
     deps = [
       ":isac",
       ":isac_test_util",
@@ -2035,7 +1898,6 @@
 
     deps = [
       ":g722",
-      "../..:typedefs",
       "../..:webrtc_common",
     ]
   }
@@ -2052,12 +1914,6 @@
       ":isac_test_util",
       "../../rtc_base:rtc_base_approved",
     ]
-
-    include_dirs = [
-      "codecs/isac/main/include",
-      "codecs/isac/main/test",
-      "codecs/isac/main/util",
-    ]
   }
 
   rtc_executable("isac_switch_samprate_test") {
@@ -2073,13 +1929,6 @@
       "../../common_audio",
       "../../common_audio:common_audio_c",
     ]
-
-    include_dirs = [
-      "codecs/isac/main/include",
-      "codecs/isac/main/test",
-      "codecs/isac/main/util",
-      "../../common_audio/signal_processing/include",
-    ]
   }
 
   rtc_executable("ilbc_test") {
@@ -2109,11 +1958,6 @@
       "../../test:test_main",
       "//testing/gtest",
     ]
-
-    if (!build_with_chromium && is_clang) {
-      # Suppress warnings from the Chromium Clang plugin (bugs.webrtc.org/163).
-      suppressed_configs += [ "//build/config/clang:find_bad_constructs" ]
-    }
   }
 
   rtc_source_set("audio_coding_unittests") {
@@ -2221,7 +2065,6 @@
       ":rent_a_codec",
       ":webrtc_opus",
       "..:module_api",
-      "../..:typedefs",
       "../..:webrtc_common",
       "../../api/audio:audio_frame_api",
       "../../api/audio_codecs:audio_codecs_api",
@@ -2241,6 +2084,7 @@
       "../../rtc_base:rtc_base_approved",
       "../../rtc_base:rtc_base_tests_utils",
       "../../rtc_base:sanitizer",
+      "../../rtc_base/system:arch",
       "../../system_wrappers",
       "../../system_wrappers:cpu_features_api",
       "../../test:audio_codec_mocks",
diff --git a/modules/audio_coding/acm2/acm_codec_database.h b/modules/audio_coding/acm2/acm_codec_database.h
index 8b7c68a..ee6bb46 100644
--- a/modules/audio_coding/acm2/acm_codec_database.h
+++ b/modules/audio_coding/acm2/acm_codec_database.h
@@ -18,7 +18,6 @@
 
 #include "common_types.h"  // NOLINT(build/include)
 #include "modules/audio_coding/acm2/rent_a_codec.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/acm2/acm_receiver.cc b/modules/audio_coding/acm2/acm_receiver.cc
index 0a88e70..892abe5 100644
--- a/modules/audio_coding/acm2/acm_receiver.cc
+++ b/modules/audio_coding/acm2/acm_receiver.cc
@@ -60,10 +60,6 @@
   return -1;
 }
 
-int AcmReceiver::LeastRequiredDelayMs() const {
-  return neteq_->LeastRequiredDelayMs();
-}
-
 absl::optional<int> AcmReceiver::last_packet_sample_rate_hz() const {
   rtc::CritScope lock(&crit_sect_);
   return last_packet_sample_rate_hz_;
diff --git a/modules/audio_coding/acm2/acm_receiver.h b/modules/audio_coding/acm2/acm_receiver.h
index c0afbb1..0731677 100644
--- a/modules/audio_coding/acm2/acm_receiver.h
+++ b/modules/audio_coding/acm2/acm_receiver.h
@@ -26,7 +26,6 @@
 #include "modules/audio_coding/neteq/include/neteq.h"
 #include "rtc_base/criticalsection.h"
 #include "rtc_base/thread_annotations.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
@@ -144,13 +143,6 @@
   int SetMaximumDelay(int delay_ms);
 
   //
-  // Get least required delay computed based on channel conditions. Note that
-  // this is before applying any user-defined limits (specified by calling
-  // (SetMinimumDelay() and/or SetMaximumDelay()).
-  //
-  int LeastRequiredDelayMs() const;
-
-  //
   // Resets the initial delay to zero.
   //
   void ResetInitialDelay();
diff --git a/modules/audio_coding/acm2/acm_resampler.h b/modules/audio_coding/acm2/acm_resampler.h
index d7d7bcf..904ea52 100644
--- a/modules/audio_coding/acm2/acm_resampler.h
+++ b/modules/audio_coding/acm2/acm_resampler.h
@@ -12,7 +12,6 @@
 #define MODULES_AUDIO_CODING_ACM2_ACM_RESAMPLER_H_
 
 #include "common_audio/resampler/include/push_resampler.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 namespace acm2 {
diff --git a/modules/audio_coding/acm2/acm_send_test.cc b/modules/audio_coding/acm2/acm_send_test.cc
index b1a3e98..c5e010c 100644
--- a/modules/audio_coding/acm2/acm_send_test.cc
+++ b/modules/audio_coding/acm2/acm_send_test.cc
@@ -16,10 +16,13 @@
 
 #include "api/audio_codecs/audio_encoder.h"
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
+#include "api/audio_codecs/builtin_audio_encoder_factory.h"
+#include "modules/audio_coding/codecs/audio_format_conversion.h"
 #include "modules/audio_coding/include/audio_coding_module.h"
 #include "modules/audio_coding/neteq/tools/input_audio_file.h"
 #include "modules/audio_coding/neteq/tools/packet.h"
 #include "rtc_base/checks.h"
+#include "rtc_base/stringencode.h"
 #include "test/gtest.h"
 
 namespace webrtc {
@@ -65,20 +68,26 @@
                                            sampling_freq_hz, channels));
   codec.pltype = payload_type;
   codec.pacsize = frame_size_samples;
-  codec_registered_ = (acm_->RegisterSendCodec(codec) == 0);
+  auto factory = CreateBuiltinAudioEncoderFactory();
+  SdpAudioFormat format = CodecInstToSdp(codec);
+  format.parameters["ptime"] = rtc::ToString(rtc::CheckedDivExact(
+      frame_size_samples, rtc::CheckedDivExact(sampling_freq_hz, 1000)));
+  acm_->SetEncoder(
+      factory->MakeAudioEncoder(payload_type, format, absl::nullopt));
+  codec_registered_ = true;
   input_frame_.num_channels_ = channels;
   assert(input_block_size_samples_ * input_frame_.num_channels_ <=
          AudioFrame::kMaxDataSizeSamples);
   return codec_registered_;
 }
 
-bool AcmSendTestOldApi::RegisterExternalCodec(
-    AudioEncoder* external_speech_encoder) {
-  acm_->RegisterExternalSendCodec(external_speech_encoder);
+void AcmSendTestOldApi::RegisterExternalCodec(
+    std::unique_ptr<AudioEncoder> external_speech_encoder) {
   input_frame_.num_channels_ = external_speech_encoder->NumChannels();
+  acm_->SetEncoder(std::move(external_speech_encoder));
   assert(input_block_size_samples_ * input_frame_.num_channels_ <=
          AudioFrame::kMaxDataSizeSamples);
-  return codec_registered_ = true;
+  codec_registered_ = true;
 }
 
 std::unique_ptr<Packet> AcmSendTestOldApi::NextPacket() {
diff --git a/modules/audio_coding/acm2/acm_send_test.h b/modules/audio_coding/acm2/acm_send_test.h
index 68ba9e1..3479de0 100644
--- a/modules/audio_coding/acm2/acm_send_test.h
+++ b/modules/audio_coding/acm2/acm_send_test.h
@@ -42,8 +42,9 @@
                      int payload_type,
                      int frame_size_samples);
 
-  // Registers an external send codec. Returns true on success, false otherwise.
-  bool RegisterExternalCodec(AudioEncoder* external_speech_encoder);
+  // Registers an external send codec.
+  void RegisterExternalCodec(
+      std::unique_ptr<AudioEncoder> external_speech_encoder);
 
   // Inherited from PacketSource.
   std::unique_ptr<Packet> NextPacket() override;
diff --git a/modules/audio_coding/acm2/audio_coding_module.cc b/modules/audio_coding/acm2/audio_coding_module.cc
index 7f652a2..f0b35ca 100644
--- a/modules/audio_coding/acm2/audio_coding_module.cc
+++ b/modules/audio_coding/acm2/audio_coding_module.cc
@@ -50,15 +50,9 @@
   void ModifyEncoder(rtc::FunctionView<void(std::unique_ptr<AudioEncoder>*)>
                          modifier) override;
 
-  void QueryEncoder(
-      rtc::FunctionView<void(const AudioEncoder*)> query) override;
-
   // Get current send codec.
   absl::optional<CodecInst> SendCodec() const override;
 
-  // Get current send frequency.
-  int SendFrequency() const override;
-
   // Sets the bitrate to the specified value in bits/sec. In case the codec does
   // not support the requested value it will choose an appropriate value
   // instead.
@@ -155,11 +149,6 @@
   // Maximum playout delay.
   int SetMaximumPlayoutDelay(int time_ms) override;
 
-  // Smallest latency NetEq will maintain.
-  int LeastRequiredDelayMs() const override;
-
-  RTC_DEPRECATED int32_t PlayoutTimestamp(uint32_t* timestamp) override;
-
   absl::optional<uint32_t> PlayoutTimestamp() override;
 
   int FilteredCurrentDelayMs() const override;
@@ -171,7 +160,6 @@
   int PlayoutData10Ms(int desired_freq_hz,
                       AudioFrame* audio_frame,
                       bool* muted) override;
-  int PlayoutData10Ms(int desired_freq_hz, AudioFrame* audio_frame) override;
 
   /////////////////////////////////////////
   //   Statistics
@@ -598,12 +586,6 @@
   modifier(&encoder_stack_);
 }
 
-void AudioCodingModuleImpl::QueryEncoder(
-    rtc::FunctionView<void(const AudioEncoder*)> query) {
-  rtc::CritScope lock(&acm_crit_sect_);
-  query(encoder_stack_.get());
-}
-
 // Get current send codec.
 absl::optional<CodecInst> AudioCodingModuleImpl::SendCodec() const {
   rtc::CritScope lock(&acm_crit_sect_);
@@ -627,18 +609,6 @@
   }
 }
 
-// Get current send frequency.
-int AudioCodingModuleImpl::SendFrequency() const {
-  rtc::CritScope lock(&acm_crit_sect_);
-
-  if (!encoder_stack_) {
-    RTC_LOG(LS_ERROR) << "SendFrequency Failed, no codec is registered";
-    return -1;
-  }
-
-  return encoder_stack_->SampleRateHz();
-}
-
 void AudioCodingModuleImpl::SetBitRate(int bitrate_bps) {
   rtc::CritScope lock(&acm_crit_sect_);
   if (encoder_stack_) {
@@ -1109,14 +1079,6 @@
   return 0;
 }
 
-int AudioCodingModuleImpl::PlayoutData10Ms(int desired_freq_hz,
-                                           AudioFrame* audio_frame) {
-  bool muted;
-  int ret = PlayoutData10Ms(desired_freq_hz, audio_frame, &muted);
-  RTC_DCHECK(!muted);
-  return ret;
-}
-
 /////////////////////////////////////////
 //   Statistics
 //
@@ -1181,14 +1143,6 @@
   return encoder_stack_->SetDtx(false) ? 0 : -1;
 }
 
-int32_t AudioCodingModuleImpl::PlayoutTimestamp(uint32_t* timestamp) {
-  absl::optional<uint32_t> ts = PlayoutTimestamp();
-  if (!ts)
-    return -1;
-  *timestamp = *ts;
-  return 0;
-}
-
 absl::optional<uint32_t> AudioCodingModuleImpl::PlayoutTimestamp() {
   return receiver_.GetPlayoutTimestamp();
 }
@@ -1226,10 +1180,6 @@
   return receiver_.GetNackList(round_trip_time_ms);
 }
 
-int AudioCodingModuleImpl::LeastRequiredDelayMs() const {
-  return receiver_.LeastRequiredDelayMs();
-}
-
 void AudioCodingModuleImpl::GetDecodingCallStatistics(
     AudioDecodingCallStats* call_stats) const {
   receiver_.GetDecodingCallStatistics(call_stats);
@@ -1310,12 +1260,4 @@
   return i ? *i : -1;
 }
 
-// Checks the validity of the parameters of the given codec
-bool AudioCodingModule::IsCodecValid(const CodecInst& codec) {
-  bool valid = acm2::RentACodec::IsCodecValid(codec);
-  if (!valid)
-    RTC_LOG(LS_ERROR) << "Invalid codec setting";
-  return valid;
-}
-
 }  // namespace webrtc
diff --git a/modules/audio_coding/acm2/audio_coding_module_unittest.cc b/modules/audio_coding/acm2/audio_coding_module_unittest.cc
index ce2832a..924a4a6 100644
--- a/modules/audio_coding/acm2/audio_coding_module_unittest.cc
+++ b/modules/audio_coding/acm2/audio_coding_module_unittest.cc
@@ -37,6 +37,7 @@
 #include "rtc_base/numerics/safe_conversions.h"
 #include "rtc_base/platform_thread.h"
 #include "rtc_base/refcountedobject.h"
+#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"
@@ -1147,13 +1148,14 @@
                                      payload_type, frame_size_samples);
   }
 
-  bool RegisterExternalSendCodec(AudioEncoder* external_speech_encoder,
-                                 int payload_type) {
+  void RegisterExternalSendCodec(
+      std::unique_ptr<AudioEncoder> external_speech_encoder,
+      int payload_type) {
     payload_type_ = payload_type;
     frame_size_rtp_timestamps_ = rtc::checked_cast<uint32_t>(
         external_speech_encoder->Num10MsFramesInNextPacket() *
         external_speech_encoder->RtpTimestampRateHz() / 100);
-    return send_test_->RegisterExternalCodec(external_speech_encoder);
+    send_test_->RegisterExternalCodec(std::move(external_speech_encoder));
   }
 
   // Runs the test. SetUpSender() and RegisterSendCodec() must have been called
@@ -1248,11 +1250,11 @@
                                   codec_frame_size_rtp_timestamps));
   }
 
-  void SetUpTestExternalEncoder(AudioEncoder* external_speech_encoder,
-                                int payload_type) {
+  void SetUpTestExternalEncoder(
+      std::unique_ptr<AudioEncoder> external_speech_encoder,
+      int payload_type) {
     ASSERT_TRUE(SetUpSender());
-    ASSERT_TRUE(
-        RegisterExternalSendCodec(external_speech_encoder, payload_type));
+    RegisterExternalSendCodec(std::move(external_speech_encoder), payload_type);
   }
 
   std::unique_ptr<test::AcmSendTestOldApi> send_test_;
@@ -1459,8 +1461,8 @@
 TEST_F(AcmSenderBitExactnessNewApi, MAYBE_OpusFromFormat_stereo_20ms) {
   const auto config = AudioEncoderOpus::SdpToConfig(
       SdpAudioFormat("opus", 48000, 2, {{"stereo", "1"}}));
-  const auto encoder = AudioEncoderOpus::MakeAudioEncoder(*config, 120);
-  ASSERT_NO_FATAL_FAILURE(SetUpTestExternalEncoder(encoder.get(), 120));
+  ASSERT_NO_FATAL_FAILURE(SetUpTestExternalEncoder(
+      AudioEncoderOpus::MakeAudioEncoder(*config, 120), 120));
   Run(AcmReceiverBitExactnessOldApi::PlatformChecksum(
           "3e285b74510e62062fbd8142dacd16e9",
           "3e285b74510e62062fbd8142dacd16e9",
@@ -1498,8 +1500,8 @@
 TEST_F(AcmSenderBitExactnessNewApi, OpusFromFormat_stereo_20ms_voip) {
   const auto config = AudioEncoderOpus::SdpToConfig(
       SdpAudioFormat("opus", 48000, 2, {{"stereo", "1"}}));
-  const auto encoder = AudioEncoderOpus::MakeAudioEncoder(*config, 120);
-  ASSERT_NO_FATAL_FAILURE(SetUpTestExternalEncoder(encoder.get(), 120));
+  ASSERT_NO_FATAL_FAILURE(SetUpTestExternalEncoder(
+      AudioEncoderOpus::MakeAudioEncoder(*config, 120), 120));
   // If not set, default will be kAudio in case of stereo.
   EXPECT_EQ(0, send_test_->acm()->SetOpusApplication(kVoip));
   Run(AcmReceiverBitExactnessOldApi::PlatformChecksum(
@@ -1549,9 +1551,10 @@
                                      payload_type, frame_size_samples);
   }
 
-  bool RegisterExternalSendCodec(AudioEncoder* external_speech_encoder,
-                                 int payload_type) {
-    return send_test_->RegisterExternalCodec(external_speech_encoder);
+  void RegisterExternalSendCodec(
+      std::unique_ptr<AudioEncoder> external_speech_encoder,
+      int payload_type) {
+    send_test_->RegisterExternalCodec(std::move(external_speech_encoder));
   }
 
   void RunInner(int min_expected_total_bits, int max_expected_total_bits) {
@@ -1610,9 +1613,9 @@
 TEST_F(AcmSetBitRateNewApi, OpusFromFormat_48khz_20ms_10kbps) {
   const auto config = AudioEncoderOpus::SdpToConfig(
       SdpAudioFormat("opus", 48000, 2, {{"maxaveragebitrate", "10000"}}));
-  const auto encoder = AudioEncoderOpus::MakeAudioEncoder(*config, 107);
   ASSERT_TRUE(SetUpSender());
-  ASSERT_TRUE(RegisterExternalSendCodec(encoder.get(), 107));
+  RegisterExternalSendCodec(AudioEncoderOpus::MakeAudioEncoder(*config, 107),
+                            107);
   RunInner(8000, 12000);
 }
 
@@ -1624,9 +1627,9 @@
 TEST_F(AcmSetBitRateNewApi, OpusFromFormat_48khz_20ms_50kbps) {
   const auto config = AudioEncoderOpus::SdpToConfig(
       SdpAudioFormat("opus", 48000, 2, {{"maxaveragebitrate", "50000"}}));
-  const auto encoder = AudioEncoderOpus::MakeAudioEncoder(*config, 107);
   ASSERT_TRUE(SetUpSender());
-  ASSERT_TRUE(RegisterExternalSendCodec(encoder.get(), 107));
+  RegisterExternalSendCodec(AudioEncoderOpus::MakeAudioEncoder(*config, 107),
+                            107);
   RunInner(40000, 60000);
 }
 
@@ -1649,9 +1652,9 @@
 TEST_F(AcmSetBitRateNewApi, MAYBE_OpusFromFormat_48khz_20ms_100kbps) {
   const auto config = AudioEncoderOpus::SdpToConfig(
       SdpAudioFormat("opus", 48000, 2, {{"maxaveragebitrate", "100000"}}));
-  const auto encoder = AudioEncoderOpus::MakeAudioEncoder(*config, 107);
   ASSERT_TRUE(SetUpSender());
-  ASSERT_TRUE(RegisterExternalSendCodec(encoder.get(), 107));
+  RegisterExternalSendCodec(AudioEncoderOpus::MakeAudioEncoder(*config, 107),
+                            107);
   RunInner(80000, 120000);
 }
 
@@ -1723,17 +1726,17 @@
 
 TEST_F(AcmChangeBitRateOldApi, Opus_48khz_20ms_10kbps_2) {
   ASSERT_NO_FATAL_FAILURE(SetUpTest("opus", 48000, 1, 107, 960, 960));
-  Run(10000, 32200, 5208);
+  Run(10000, 14096, 4232);
 }
 
 TEST_F(AcmChangeBitRateOldApi, Opus_48khz_20ms_50kbps_2) {
   ASSERT_NO_FATAL_FAILURE(SetUpTest("opus", 48000, 1, 107, 960, 960));
-  Run(50000, 32200, 23928);
+  Run(50000, 14096, 22552);
 }
 
 TEST_F(AcmChangeBitRateOldApi, Opus_48khz_20ms_100kbps_2) {
   ASSERT_NO_FATAL_FAILURE(SetUpTest("opus", 48000, 1, 107, 960, 960));
-  Run(100000, 32200, 50448);
+  Run(100000, 14096, 49472);
 }
 
 // These next 2 tests ensure that the SetBitRate function has no effect on PCM
@@ -1753,36 +1756,33 @@
   codec_inst.pacsize = 160;
   codec_inst.pltype = 0;
   AudioEncoderPcmU encoder(codec_inst);
-  MockAudioEncoder mock_encoder;
+  auto mock_encoder = absl::make_unique<MockAudioEncoder>();
   // Set expectations on the mock encoder and also delegate the calls to the
   // real encoder.
-  EXPECT_CALL(mock_encoder, SampleRateHz())
+  EXPECT_CALL(*mock_encoder, SampleRateHz())
       .Times(AtLeast(1))
       .WillRepeatedly(Invoke(&encoder, &AudioEncoderPcmU::SampleRateHz));
-  EXPECT_CALL(mock_encoder, NumChannels())
+  EXPECT_CALL(*mock_encoder, NumChannels())
       .Times(AtLeast(1))
       .WillRepeatedly(Invoke(&encoder, &AudioEncoderPcmU::NumChannels));
-  EXPECT_CALL(mock_encoder, RtpTimestampRateHz())
+  EXPECT_CALL(*mock_encoder, RtpTimestampRateHz())
       .Times(AtLeast(1))
       .WillRepeatedly(Invoke(&encoder, &AudioEncoderPcmU::RtpTimestampRateHz));
-  EXPECT_CALL(mock_encoder, Num10MsFramesInNextPacket())
+  EXPECT_CALL(*mock_encoder, Num10MsFramesInNextPacket())
       .Times(AtLeast(1))
       .WillRepeatedly(
           Invoke(&encoder, &AudioEncoderPcmU::Num10MsFramesInNextPacket));
-  EXPECT_CALL(mock_encoder, GetTargetBitrate())
+  EXPECT_CALL(*mock_encoder, GetTargetBitrate())
       .Times(AtLeast(1))
       .WillRepeatedly(Invoke(&encoder, &AudioEncoderPcmU::GetTargetBitrate));
-  EXPECT_CALL(mock_encoder, EncodeImpl(_, _, _))
+  EXPECT_CALL(*mock_encoder, EncodeImpl(_, _, _))
       .Times(AtLeast(1))
       .WillRepeatedly(Invoke(
           &encoder, static_cast<AudioEncoder::EncodedInfo (AudioEncoder::*)(
                         uint32_t, rtc::ArrayView<const int16_t>, rtc::Buffer*)>(
                         &AudioEncoderPcmU::Encode)));
-  EXPECT_CALL(mock_encoder, SetFec(_))
-      .Times(AtLeast(1))
-      .WillRepeatedly(Invoke(&encoder, &AudioEncoderPcmU::SetFec));
   ASSERT_NO_FATAL_FAILURE(
-      SetUpTestExternalEncoder(&mock_encoder, codec_inst.pltype));
+      SetUpTestExternalEncoder(std::move(mock_encoder), codec_inst.pltype));
   Run("81a9d4c0bb72e9becc43aef124c981e9", "8f9b8750bd80fe26b6cbf6659b89f0f9",
       50, test::AcmReceiveTestOldApi::kMonoOutput);
 }
diff --git a/modules/audio_coding/acm2/codec_manager.cc b/modules/audio_coding/acm2/codec_manager.cc
index a101d3d..f29e0f1 100644
--- a/modules/audio_coding/acm2/codec_manager.cc
+++ b/modules/audio_coding/acm2/codec_manager.cc
@@ -14,7 +14,6 @@
 //#include "rtc_base/format_macros.h"
 #include "modules/audio_coding/acm2/rent_a_codec.h"
 #include "rtc_base/logging.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 namespace acm2 {
diff --git a/modules/audio_coding/acm2/rent_a_codec.cc b/modules/audio_coding/acm2/rent_a_codec.cc
index 818e17f..264c2a8 100644
--- a/modules/audio_coding/acm2/rent_a_codec.cc
+++ b/modules/audio_coding/acm2/rent_a_codec.cc
@@ -80,10 +80,6 @@
   return ci;
 }
 
-bool RentACodec::IsCodecValid(const CodecInst& codec_inst) {
-  return ACMCodecDB::CodecNumber(codec_inst) >= 0;
-}
-
 absl::optional<bool> RentACodec::IsSupportedNumChannels(CodecId codec_id,
                                                         size_t num_channels) {
   auto i = CodecIndexFromId(codec_id);
diff --git a/modules/audio_coding/acm2/rent_a_codec.h b/modules/audio_coding/acm2/rent_a_codec.h
index 02f9d03..b0ad382 100644
--- a/modules/audio_coding/acm2/rent_a_codec.h
+++ b/modules/audio_coding/acm2/rent_a_codec.h
@@ -23,7 +23,6 @@
 #include "modules/audio_coding/neteq/neteq_decoder_enum.h"
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/scoped_ref_ptr.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
@@ -129,7 +128,6 @@
   static absl::optional<CodecInst> CodecInstByParams(const char* payload_name,
                                                      int sampling_freq_hz,
                                                      size_t channels);
-  static bool IsCodecValid(const CodecInst& codec_inst);
 
   static inline bool IsPayloadTypeValid(int payload_type) {
     return payload_type >= 0 && payload_type <= 127;
diff --git a/modules/audio_coding/audio_network_adaptor/parse_ana_dump.py b/modules/audio_coding/audio_network_adaptor/parse_ana_dump.py
index a52b065..1bd5f0c 100755
--- a/modules/audio_coding/audio_network_adaptor/parse_ana_dump.py
+++ b/modules/audio_coding/audio_network_adaptor/parse_ana_dump.py
@@ -66,9 +66,9 @@
     first_time_stamp = None
     while True:
       event = GetNextMessageFromFile(file_to_parse)
-      if event == None:
+      if event is None:
         break
-      if first_time_stamp == None:
+      if first_time_stamp is None:
         first_time_stamp = event.timestamp
       if event.type == debug_dump_pb2.Event.ENCODER_RUNTIME_CONFIG:
         for decision in event.encoder_runtime_config.DESCRIPTOR.fields:
@@ -110,7 +110,7 @@
       action='append')
 
   options = parser.parse_args()[0]
-  if options.dump_file_to_parse == None:
+  if options.dump_file_to_parse is None:
     print "No dump file to parse is set.\n"
     parser.print_help()
     exit()
diff --git a/modules/audio_coding/codecs/cng/webrtc_cng.h b/modules/audio_coding/codecs/cng/webrtc_cng.h
index 684480a..3f8fadc 100644
--- a/modules/audio_coding/codecs/cng/webrtc_cng.h
+++ b/modules/audio_coding/codecs/cng/webrtc_cng.h
@@ -15,7 +15,6 @@
 
 #include "api/array_view.h"
 #include "rtc_base/buffer.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 #define WEBRTC_CNG_MAX_LPC_ORDER 12
 
diff --git a/modules/audio_coding/codecs/g711/g711_interface.c b/modules/audio_coding/codecs/g711/g711_interface.c
index 9c31cbc..5fe1692 100644
--- a/modules/audio_coding/codecs/g711/g711_interface.c
+++ b/modules/audio_coding/codecs/g711/g711_interface.c
@@ -10,9 +10,8 @@
 
 #include <string.h>
 
-#include "modules/audio_coding/codecs/g711/g711.h"
+#include "modules/third_party/g711/g711.h"
 #include "modules/audio_coding/codecs/g711/g711_interface.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 size_t WebRtcG711_EncodeA(const int16_t* speechIn,
                           size_t len,
diff --git a/modules/audio_coding/codecs/g711/g711_interface.h b/modules/audio_coding/codecs/g711/g711_interface.h
index f206f30..83f9d37 100644
--- a/modules/audio_coding/codecs/g711/g711_interface.h
+++ b/modules/audio_coding/codecs/g711/g711_interface.h
@@ -11,7 +11,7 @@
 #ifndef MODULES_AUDIO_CODING_CODECS_G711_G711_INTERFACE_H_
 #define MODULES_AUDIO_CODING_CODECS_G711_G711_INTERFACE_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 // Comfort noise constants
 #define G711_WEBRTC_SPEECH 1
diff --git a/modules/audio_coding/codecs/g722/g722_interface.c b/modules/audio_coding/codecs/g722/g722_interface.c
index fb25049..36ee6d9 100644
--- a/modules/audio_coding/codecs/g722/g722_interface.c
+++ b/modules/audio_coding/codecs/g722/g722_interface.c
@@ -11,9 +11,8 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "modules/audio_coding/codecs/g722/g722_enc_dec.h"
 #include "modules/audio_coding/codecs/g722/g722_interface.h"
-#include "typedefs.h"  // NOLINT(build/include)
+#include "modules/third_party/g722/g722_enc_dec.h"
 
 int16_t WebRtcG722_CreateEncoder(G722EncInst **G722enc_inst)
 {
diff --git a/modules/audio_coding/codecs/g722/g722_interface.h b/modules/audio_coding/codecs/g722/g722_interface.h
index 3b73f85..85c1cd0 100644
--- a/modules/audio_coding/codecs/g722/g722_interface.h
+++ b/modules/audio_coding/codecs/g722/g722_interface.h
@@ -11,7 +11,7 @@
 #ifndef MODULES_AUDIO_CODING_CODECS_G722_G722_INTERFACE_H_
 #define MODULES_AUDIO_CODING_CODECS_G722_G722_INTERFACE_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 /*
  * Solution to support multiple instances
diff --git a/modules/audio_coding/codecs/ilbc/cb_construct.h b/modules/audio_coding/codecs/ilbc/cb_construct.h
index b200990..f4df387 100644
--- a/modules/audio_coding/codecs/ilbc/cb_construct.h
+++ b/modules/audio_coding/codecs/ilbc/cb_construct.h
@@ -20,7 +20,10 @@
 #define MODULES_AUDIO_CODING_CODECS_ILBC_MAIN_SOURCE_CB_CONSTRUCT_H_
 
 #include <stdbool.h>
+#include <stdint.h>
+
 #include "modules/audio_coding/codecs/ilbc/defines.h"
+#include "rtc_base/system/unused.h"
 
 /*----------------------------------------------------------------*
  *  Construct decoded vector from codebook and gains.
diff --git a/modules/audio_coding/codecs/ilbc/constants.h b/modules/audio_coding/codecs/ilbc/constants.h
index 3c32c62..07369a3 100644
--- a/modules/audio_coding/codecs/ilbc/constants.h
+++ b/modules/audio_coding/codecs/ilbc/constants.h
@@ -20,7 +20,6 @@
 #define MODULES_AUDIO_CODING_CODECS_ILBC_MAIN_SOURCE_CONSTANTS_H_
 
 #include "modules/audio_coding/codecs/ilbc/defines.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 /* high pass filters */
 
diff --git a/modules/audio_coding/codecs/ilbc/decode.c b/modules/audio_coding/codecs/ilbc/decode.c
index 7cba418..3848bc7 100644
--- a/modules/audio_coding/codecs/ilbc/decode.c
+++ b/modules/audio_coding/codecs/ilbc/decode.c
@@ -16,6 +16,9 @@
 
 ******************************************************************/
 
+// Defines WEBRTC_ARCH_BIG_ENDIAN, used below.
+#include "rtc_base/system/arch.h"
+
 #include "modules/audio_coding/codecs/ilbc/defines.h"
 #include "modules/audio_coding/codecs/ilbc/simple_lsf_dequant.h"
 #include "modules/audio_coding/codecs/ilbc/decoder_interpolate_lsf.h"
diff --git a/modules/audio_coding/codecs/ilbc/decode.h b/modules/audio_coding/codecs/ilbc/decode.h
index c5f35f4..d73f798 100644
--- a/modules/audio_coding/codecs/ilbc/decode.h
+++ b/modules/audio_coding/codecs/ilbc/decode.h
@@ -19,7 +19,10 @@
 #ifndef MODULES_AUDIO_CODING_CODECS_ILBC_MAIN_SOURCE_DECODE_H_
 #define MODULES_AUDIO_CODING_CODECS_ILBC_MAIN_SOURCE_DECODE_H_
 
+#include <stdint.h>
+
 #include "modules/audio_coding/codecs/ilbc/defines.h"
+#include "rtc_base/system/unused.h"
 
 /*----------------------------------------------------------------*
  *  main decoder function
diff --git a/modules/audio_coding/codecs/ilbc/decode_residual.h b/modules/audio_coding/codecs/ilbc/decode_residual.h
index 7468e5f..d54aada 100644
--- a/modules/audio_coding/codecs/ilbc/decode_residual.h
+++ b/modules/audio_coding/codecs/ilbc/decode_residual.h
@@ -20,7 +20,10 @@
 #define MODULES_AUDIO_CODING_CODECS_ILBC_MAIN_SOURCE_DECODE_RESIDUAL_H_
 
 #include <stdbool.h>
+#include <stdint.h>
+
 #include "modules/audio_coding/codecs/ilbc/defines.h"
+#include "rtc_base/system/unused.h"
 
 /*----------------------------------------------------------------*
  *  frame residual decoder function (subrutine to iLBC_decode)
diff --git a/modules/audio_coding/codecs/ilbc/defines.h b/modules/audio_coding/codecs/ilbc/defines.h
index 9a4a196..43948a2 100644
--- a/modules/audio_coding/codecs/ilbc/defines.h
+++ b/modules/audio_coding/codecs/ilbc/defines.h
@@ -21,7 +21,6 @@
 #include <string.h>
 
 #include "common_audio/signal_processing/include/signal_processing_library.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 /* general codec settings */
 
diff --git a/modules/audio_coding/codecs/ilbc/encode.c b/modules/audio_coding/codecs/ilbc/encode.c
index 3631c65..912e23c 100644
--- a/modules/audio_coding/codecs/ilbc/encode.c
+++ b/modules/audio_coding/codecs/ilbc/encode.c
@@ -18,6 +18,9 @@
 
 #include <string.h>
 
+// Defines WEBRTC_ARCH_BIG_ENDIAN, used below.
+#include "rtc_base/system/arch.h"
+
 #include "modules/audio_coding/codecs/ilbc/defines.h"
 #include "modules/audio_coding/codecs/ilbc/lpc_encode.h"
 #include "modules/audio_coding/codecs/ilbc/frame_classify.h"
diff --git a/modules/audio_coding/codecs/ilbc/get_cd_vec.h b/modules/audio_coding/codecs/ilbc/get_cd_vec.h
index 76e1a56..647b063 100644
--- a/modules/audio_coding/codecs/ilbc/get_cd_vec.h
+++ b/modules/audio_coding/codecs/ilbc/get_cd_vec.h
@@ -20,8 +20,11 @@
 #define MODULES_AUDIO_CODING_CODECS_ILBC_MAIN_SOURCE_GET_CD_VEC_H_
 
 #include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
 
 #include "modules/audio_coding/codecs/ilbc/defines.h"
+#include "rtc_base/system/unused.h"
 
 // Returns true on success, false on failure. In case of failure, the decoder
 // state may be corrupted and needs resetting.
diff --git a/modules/audio_coding/codecs/ilbc/ilbc.h b/modules/audio_coding/codecs/ilbc/ilbc.h
index 4c12665..de8cfde 100644
--- a/modules/audio_coding/codecs/ilbc/ilbc.h
+++ b/modules/audio_coding/codecs/ilbc/ilbc.h
@@ -19,12 +19,7 @@
 #define MODULES_AUDIO_CODING_CODECS_ILBC_ILBC_H_
 
 #include <stddef.h>
-
-/*
- * Define the fixpoint numeric formats
- */
-
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 /*
  * Solution to support multiple instances
diff --git a/modules/audio_coding/codecs/ilbc/vq3.h b/modules/audio_coding/codecs/ilbc/vq3.h
index ceaff8d..c946478 100644
--- a/modules/audio_coding/codecs/ilbc/vq3.h
+++ b/modules/audio_coding/codecs/ilbc/vq3.h
@@ -19,7 +19,7 @@
 #ifndef MODULES_AUDIO_CODING_CODECS_ILBC_MAIN_SOURCE_VQ3_H_
 #define MODULES_AUDIO_CODING_CODECS_ILBC_MAIN_SOURCE_VQ3_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 /*----------------------------------------------------------------*
  *  Vector quantization of order 3 (based on MSE)
diff --git a/modules/audio_coding/codecs/ilbc/vq4.h b/modules/audio_coding/codecs/ilbc/vq4.h
index 8dbedc9..6d14830 100644
--- a/modules/audio_coding/codecs/ilbc/vq4.h
+++ b/modules/audio_coding/codecs/ilbc/vq4.h
@@ -19,7 +19,7 @@
 #ifndef MODULES_AUDIO_CODING_CODECS_ILBC_MAIN_SOURCE_VQ4_H_
 #define MODULES_AUDIO_CODING_CODECS_ILBC_MAIN_SOURCE_VQ4_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 /*----------------------------------------------------------------*
  *  Vector quantization of order 4 (based on MSE)
diff --git a/modules/audio_coding/codecs/isac/bandwidth_info.h b/modules/audio_coding/codecs/isac/bandwidth_info.h
index 0539780..c3830a5 100644
--- a/modules/audio_coding/codecs/isac/bandwidth_info.h
+++ b/modules/audio_coding/codecs/isac/bandwidth_info.h
@@ -11,7 +11,7 @@
 #ifndef MODULES_AUDIO_CODING_CODECS_ISAC_BANDWIDTH_INFO_H_
 #define MODULES_AUDIO_CODING_CODECS_ISAC_BANDWIDTH_INFO_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 typedef struct {
   int in_use;
diff --git a/modules/audio_coding/codecs/isac/fix/include/isacfix.h b/modules/audio_coding/codecs/isac/fix/include/isacfix.h
index 626b3c7..8fcfebb 100644
--- a/modules/audio_coding/codecs/isac/fix/include/isacfix.h
+++ b/modules/audio_coding/codecs/isac/fix/include/isacfix.h
@@ -14,7 +14,6 @@
 #include <stddef.h>
 
 #include "modules/audio_coding/codecs/isac/bandwidth_info.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 typedef struct { void* dummy; } ISACFIX_MainStruct;
 
diff --git a/modules/audio_coding/codecs/isac/fix/source/filterbank_internal.h b/modules/audio_coding/codecs/isac/fix/source/filterbank_internal.h
index 8d97347..6b99914 100644
--- a/modules/audio_coding/codecs/isac/fix/source/filterbank_internal.h
+++ b/modules/audio_coding/codecs/isac/fix/source/filterbank_internal.h
@@ -11,7 +11,7 @@
 #ifndef MODULES_AUDIO_CODING_CODECS_ISAC_FIX_SOURCE_FILTERBANK_INTERNAL_H_
 #define MODULES_AUDIO_CODING_CODECS_ISAC_FIX_SOURCE_FILTERBANK_INTERNAL_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
diff --git a/modules/audio_coding/codecs/isac/fix/source/filterbank_tables.h b/modules/audio_coding/codecs/isac/fix/source/filterbank_tables.h
index 55e1f44..01e5a7b 100644
--- a/modules/audio_coding/codecs/isac/fix/source/filterbank_tables.h
+++ b/modules/audio_coding/codecs/isac/fix/source/filterbank_tables.h
@@ -19,7 +19,7 @@
 #ifndef MODULES_AUDIO_CODING_CODECS_ISAC_FIX_SOURCE_FILTERBANK_TABLES_H_
 #define MODULES_AUDIO_CODING_CODECS_ISAC_FIX_SOURCE_FILTERBANK_TABLES_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
diff --git a/modules/audio_coding/codecs/isac/fix/source/filterbanks_unittest.cc b/modules/audio_coding/codecs/isac/fix/source/filterbanks_unittest.cc
index 0727d58..b7456a7 100644
--- a/modules/audio_coding/codecs/isac/fix/source/filterbanks_unittest.cc
+++ b/modules/audio_coding/codecs/isac/fix/source/filterbanks_unittest.cc
@@ -15,7 +15,6 @@
 #include "rtc_base/sanitizer.h"
 #include "system_wrappers/include/cpu_features_wrapper.h"
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 class FilterBanksTest : public testing::Test {
  protected:
diff --git a/modules/audio_coding/codecs/isac/fix/source/filters_unittest.cc b/modules/audio_coding/codecs/isac/fix/source/filters_unittest.cc
index 2ab8d6a..471fa57 100644
--- a/modules/audio_coding/codecs/isac/fix/source/filters_unittest.cc
+++ b/modules/audio_coding/codecs/isac/fix/source/filters_unittest.cc
@@ -11,7 +11,6 @@
 #include "modules/audio_coding/codecs/isac/fix/source/codec.h"
 #include "system_wrappers/include/cpu_features_wrapper.h"
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 class FiltersTest : public testing::Test {
  protected:
diff --git a/modules/audio_coding/codecs/isac/fix/source/lattice_c.c b/modules/audio_coding/codecs/isac/fix/source/lattice_c.c
index d9849d6..4340661 100644
--- a/modules/audio_coding/codecs/isac/fix/source/lattice_c.c
+++ b/modules/audio_coding/codecs/isac/fix/source/lattice_c.c
@@ -16,7 +16,6 @@
 
 #include "common_audio/signal_processing/include/signal_processing_library.h"
 #include "modules/audio_coding/codecs/isac/fix/source/settings.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 /* Filter ar_g_Q0[] and ar_f_Q0[] through an AR filter with coefficients
  * cth_Q15[] and sth_Q15[].
diff --git a/modules/audio_coding/codecs/isac/fix/source/lattice_mips.c b/modules/audio_coding/codecs/isac/fix/source/lattice_mips.c
index 613c07c..3189726 100644
--- a/modules/audio_coding/codecs/isac/fix/source/lattice_mips.c
+++ b/modules/audio_coding/codecs/isac/fix/source/lattice_mips.c
@@ -9,9 +9,9 @@
  */
 
 #include <stddef.h>
+#include <stdint.h>
 
 #include "modules/audio_coding/codecs/isac/fix/source/settings.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 // Filter ar_g_Q0[] and ar_f_Q0[] through an AR filter with coefficients
 // cth_Q15[] and sth_Q15[].
diff --git a/modules/audio_coding/codecs/isac/fix/source/lpc_masking_model_unittest.cc b/modules/audio_coding/codecs/isac/fix/source/lpc_masking_model_unittest.cc
index dbcf420..fab0a04 100644
--- a/modules/audio_coding/codecs/isac/fix/source/lpc_masking_model_unittest.cc
+++ b/modules/audio_coding/codecs/isac/fix/source/lpc_masking_model_unittest.cc
@@ -11,7 +11,6 @@
 #include "modules/audio_coding/codecs/isac/fix/source/lpc_masking_model.h"
 #include "system_wrappers/include/cpu_features_wrapper.h"
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 class LpcMaskingModelTest : public testing::Test {
  protected:
diff --git a/modules/audio_coding/codecs/isac/fix/source/lpc_tables.h b/modules/audio_coding/codecs/isac/fix/source/lpc_tables.h
index c51f2ca..2d68fa6 100644
--- a/modules/audio_coding/codecs/isac/fix/source/lpc_tables.h
+++ b/modules/audio_coding/codecs/isac/fix/source/lpc_tables.h
@@ -18,7 +18,7 @@
 #ifndef MODULES_AUDIO_CODING_CODECS_ISAC_FIX_SOURCE_LPC_TABLES_H_
 #define MODULES_AUDIO_CODING_CODECS_ISAC_FIX_SOURCE_LPC_TABLES_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 /* indices of KLT coefficients used */
 extern const uint16_t WebRtcIsacfix_kSelIndGain[12];
diff --git a/modules/audio_coding/codecs/isac/fix/source/pitch_gain_tables.h b/modules/audio_coding/codecs/isac/fix/source/pitch_gain_tables.h
index 2b5f54e..59e1738 100644
--- a/modules/audio_coding/codecs/isac/fix/source/pitch_gain_tables.h
+++ b/modules/audio_coding/codecs/isac/fix/source/pitch_gain_tables.h
@@ -19,7 +19,7 @@
 #ifndef MODULES_AUDIO_CODING_CODECS_ISAC_FIX_SOURCE_PITCH_GAIN_TABLES_H_
 #define MODULES_AUDIO_CODING_CODECS_ISAC_FIX_SOURCE_PITCH_GAIN_TABLES_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 /********************* Pitch Filter Gain Coefficient Tables
  * ************************/
diff --git a/modules/audio_coding/codecs/isac/fix/source/pitch_lag_tables.h b/modules/audio_coding/codecs/isac/fix/source/pitch_lag_tables.h
index f834eab..228da26 100644
--- a/modules/audio_coding/codecs/isac/fix/source/pitch_lag_tables.h
+++ b/modules/audio_coding/codecs/isac/fix/source/pitch_lag_tables.h
@@ -19,7 +19,7 @@
 #ifndef MODULES_AUDIO_CODING_CODECS_ISAC_FIX_SOURCE_PITCH_LAG_TABLES_H_
 #define MODULES_AUDIO_CODING_CODECS_ISAC_FIX_SOURCE_PITCH_LAG_TABLES_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 /********************* Pitch Filter Lag Coefficient Tables
  * ************************/
diff --git a/modules/audio_coding/codecs/isac/fix/source/spectrum_ar_model_tables.h b/modules/audio_coding/codecs/isac/fix/source/spectrum_ar_model_tables.h
index 4ac5c0b..2282a36 100644
--- a/modules/audio_coding/codecs/isac/fix/source/spectrum_ar_model_tables.h
+++ b/modules/audio_coding/codecs/isac/fix/source/spectrum_ar_model_tables.h
@@ -19,8 +19,9 @@
 #ifndef MODULES_AUDIO_CODING_CODECS_ISAC_FIX_SOURCE_SPECTRUM_AR_MODEL_TABLES_H_
 #define MODULES_AUDIO_CODING_CODECS_ISAC_FIX_SOURCE_SPECTRUM_AR_MODEL_TABLES_H_
 
+#include <stdint.h>
+
 #include "modules/audio_coding/codecs/isac/fix/source/settings.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 /********************* AR Coefficient Tables ************************/
 /* cdf for quantized reflection coefficient 1 */
diff --git a/modules/audio_coding/codecs/isac/fix/source/structs.h b/modules/audio_coding/codecs/isac/fix/source/structs.h
index 352eef0..59226ac 100644
--- a/modules/audio_coding/codecs/isac/fix/source/structs.h
+++ b/modules/audio_coding/codecs/isac/fix/source/structs.h
@@ -21,7 +21,6 @@
 #include "common_audio/signal_processing/include/signal_processing_library.h"
 #include "modules/audio_coding/codecs/isac/bandwidth_info.h"
 #include "modules/audio_coding/codecs/isac/fix/source/settings.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 /* Bitstream struct for decoder */
 typedef struct Bitstreamstruct_dec {
diff --git a/modules/audio_coding/codecs/isac/fix/source/transform.c b/modules/audio_coding/codecs/isac/fix/source/transform.c
index 2f1275d..80b244b 100644
--- a/modules/audio_coding/codecs/isac/fix/source/transform.c
+++ b/modules/audio_coding/codecs/isac/fix/source/transform.c
@@ -18,6 +18,7 @@
 #include "modules/audio_coding/codecs/isac/fix/source/codec.h"
 #include "modules/audio_coding/codecs/isac/fix/source/fft.h"
 #include "modules/audio_coding/codecs/isac/fix/source/settings.h"
+#include "modules/third_party/fft/fft.h"
 
 /* Tables are defined in transform_tables.c file or ARM assembly files. */
 /* Cosine table 1 in Q14 */
diff --git a/modules/audio_coding/codecs/isac/fix/source/transform_tables.c b/modules/audio_coding/codecs/isac/fix/source/transform_tables.c
index eed88e4..e661eff 100644
--- a/modules/audio_coding/codecs/isac/fix/source/transform_tables.c
+++ b/modules/audio_coding/codecs/isac/fix/source/transform_tables.c
@@ -13,8 +13,9 @@
  * transform functions WebRtcIsacfix_Time2Spec and WebRtcIsacfix_Spec2Time.
  */
 
+#include <stdint.h>
+
 #include "modules/audio_coding/codecs/isac/fix/source/settings.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 /* Cosine table 1 in Q14. */
 const int16_t WebRtcIsacfix_kCosTab1[FRAMESAMPLES/2] = {
diff --git a/modules/audio_coding/codecs/isac/main/include/isac.h b/modules/audio_coding/codecs/isac/main/include/isac.h
index 1d7e075..6cd70a6 100644
--- a/modules/audio_coding/codecs/isac/main/include/isac.h
+++ b/modules/audio_coding/codecs/isac/main/include/isac.h
@@ -14,7 +14,6 @@
 #include <stddef.h>
 
 #include "modules/audio_coding/codecs/isac/bandwidth_info.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 typedef struct WebRtcISACStruct ISACStruct;
 
diff --git a/modules/audio_coding/codecs/isac/main/source/codec.h b/modules/audio_coding/codecs/isac/main/source/codec.h
index c386704..a7c7ddc 100644
--- a/modules/audio_coding/codecs/isac/main/source/codec.h
+++ b/modules/audio_coding/codecs/isac/main/source/codec.h
@@ -22,6 +22,7 @@
 #include <stddef.h>
 
 #include "modules/audio_coding/codecs/isac/main/source/structs.h"
+#include "modules/third_party/fft/fft.h"
 
 void WebRtcIsac_ResetBitstream(Bitstr* bit_stream);
 
diff --git a/modules/audio_coding/codecs/isac/main/source/crc.h b/modules/audio_coding/codecs/isac/main/source/crc.h
index 19adbda..f031019 100644
--- a/modules/audio_coding/codecs/isac/main/source/crc.h
+++ b/modules/audio_coding/codecs/isac/main/source/crc.h
@@ -18,7 +18,7 @@
 #ifndef MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_CRC_H_
 #define MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_CRC_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 /****************************************************************************
  * WebRtcIsac_GetCrc(...)
diff --git a/modules/audio_coding/codecs/isac/main/source/encode_lpc_swb.c b/modules/audio_coding/codecs/isac/main/source/encode_lpc_swb.c
index 0ab2dc1..7b02e64 100644
--- a/modules/audio_coding/codecs/isac/main/source/encode_lpc_swb.c
+++ b/modules/audio_coding/codecs/isac/main/source/encode_lpc_swb.c
@@ -25,7 +25,6 @@
 #include "modules/audio_coding/codecs/isac/main/source/lpc_shape_swb12_tables.h"
 #include "modules/audio_coding/codecs/isac/main/source/lpc_shape_swb16_tables.h"
 #include "modules/audio_coding/codecs/isac/main/source/settings.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 /******************************************************************************
  * WebRtcIsac_RemoveLarMean()
diff --git a/modules/audio_coding/codecs/isac/main/source/encode_lpc_swb.h b/modules/audio_coding/codecs/isac/main/source/encode_lpc_swb.h
index b8d918b..8bc3d75 100644
--- a/modules/audio_coding/codecs/isac/main/source/encode_lpc_swb.h
+++ b/modules/audio_coding/codecs/isac/main/source/encode_lpc_swb.h
@@ -21,7 +21,6 @@
 
 #include "modules/audio_coding/codecs/isac/main/source/settings.h"
 #include "modules/audio_coding/codecs/isac/main/source/structs.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 /******************************************************************************
  * WebRtcIsac_RemoveLarMean()
diff --git a/modules/audio_coding/codecs/isac/main/source/isac.c b/modules/audio_coding/codecs/isac/main/source/isac.c
index 45eb598..8669596 100644
--- a/modules/audio_coding/codecs/isac/main/source/isac.c
+++ b/modules/audio_coding/codecs/isac/main/source/isac.c
@@ -32,6 +32,7 @@
 #include "modules/audio_coding/codecs/isac/main/source/os_specific_inline.h"
 #include "modules/audio_coding/codecs/isac/main/source/structs.h"
 #include "modules/audio_coding/codecs/isac/main/source/isac_vad.h"
+#include "rtc_base/system/arch.h"
 
 #define BIT_MASK_DEC_INIT 0x0001
 #define BIT_MASK_ENC_INIT 0x0002
diff --git a/modules/audio_coding/codecs/isac/main/source/lpc_gain_swb_tables.c b/modules/audio_coding/codecs/isac/main/source/lpc_gain_swb_tables.c
index d6e65f3..6707540 100644
--- a/modules/audio_coding/codecs/isac/main/source/lpc_gain_swb_tables.c
+++ b/modules/audio_coding/codecs/isac/main/source/lpc_gain_swb_tables.c
@@ -18,7 +18,6 @@
 
 #include "modules/audio_coding/codecs/isac/main/source/lpc_gain_swb_tables.h"
 #include "modules/audio_coding/codecs/isac/main/source/settings.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 const double WebRtcIsac_kQSizeLpcGain = 0.100000;
 
diff --git a/modules/audio_coding/codecs/isac/main/source/lpc_gain_swb_tables.h b/modules/audio_coding/codecs/isac/main/source/lpc_gain_swb_tables.h
index 84913dd..39c4a24 100644
--- a/modules/audio_coding/codecs/isac/main/source/lpc_gain_swb_tables.h
+++ b/modules/audio_coding/codecs/isac/main/source/lpc_gain_swb_tables.h
@@ -19,8 +19,9 @@
 #ifndef MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_LPC_GAIN_SWB_TABLES_H_
 #define MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_LPC_GAIN_SWB_TABLES_H_
 
+#include <stdint.h>
+
 #include "modules/audio_coding/codecs/isac/main/source/settings.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 extern const double WebRtcIsac_kQSizeLpcGain;
 
diff --git a/modules/audio_coding/codecs/isac/main/source/lpc_shape_swb12_tables.c b/modules/audio_coding/codecs/isac/main/source/lpc_shape_swb12_tables.c
index 490866c..e3600a7 100644
--- a/modules/audio_coding/codecs/isac/main/source/lpc_shape_swb12_tables.c
+++ b/modules/audio_coding/codecs/isac/main/source/lpc_shape_swb12_tables.c
@@ -18,7 +18,6 @@
 
 #include "modules/audio_coding/codecs/isac/main/source/lpc_shape_swb12_tables.h"
 #include "modules/audio_coding/codecs/isac/main/source/settings.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 /*
 * Mean value of LAR
diff --git a/modules/audio_coding/codecs/isac/main/source/lpc_shape_swb12_tables.h b/modules/audio_coding/codecs/isac/main/source/lpc_shape_swb12_tables.h
index e21e15a..7448a1e 100644
--- a/modules/audio_coding/codecs/isac/main/source/lpc_shape_swb12_tables.h
+++ b/modules/audio_coding/codecs/isac/main/source/lpc_shape_swb12_tables.h
@@ -19,8 +19,9 @@
 #ifndef MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_LPC_SHAPE_SWB12_TABLES_H_
 #define MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_LPC_SHAPE_SWB12_TABLES_H_
 
+#include <stdint.h>
+
 #include "modules/audio_coding/codecs/isac/main/source/settings.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 extern const double WebRtcIsac_kMeanLarUb12[UB_LPC_ORDER];
 
diff --git a/modules/audio_coding/codecs/isac/main/source/lpc_shape_swb16_tables.c b/modules/audio_coding/codecs/isac/main/source/lpc_shape_swb16_tables.c
index d03c7b7..59617fd 100644
--- a/modules/audio_coding/codecs/isac/main/source/lpc_shape_swb16_tables.c
+++ b/modules/audio_coding/codecs/isac/main/source/lpc_shape_swb16_tables.c
@@ -18,7 +18,6 @@
 
 #include "modules/audio_coding/codecs/isac/main/source/lpc_shape_swb16_tables.h"
 #include "modules/audio_coding/codecs/isac/main/source/settings.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 /*
 * Mean value of LAR
diff --git a/modules/audio_coding/codecs/isac/main/source/lpc_shape_swb16_tables.h b/modules/audio_coding/codecs/isac/main/source/lpc_shape_swb16_tables.h
index 4d5403d..51101db 100644
--- a/modules/audio_coding/codecs/isac/main/source/lpc_shape_swb16_tables.h
+++ b/modules/audio_coding/codecs/isac/main/source/lpc_shape_swb16_tables.h
@@ -19,8 +19,9 @@
 #ifndef MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_LPC_SHAPE_SWB16_TABLES_H_
 #define MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_LPC_SHAPE_SWB16_TABLES_H_
 
+#include <stdint.h>
+
 #include "modules/audio_coding/codecs/isac/main/source/settings.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 extern const double WebRtcIsac_kMeanLarUb16[UB_LPC_ORDER];
 
diff --git a/modules/audio_coding/codecs/isac/main/source/os_specific_inline.h b/modules/audio_coding/codecs/isac/main/source/os_specific_inline.h
index f72236d..fe9afa4 100644
--- a/modules/audio_coding/codecs/isac/main/source/os_specific_inline.h
+++ b/modules/audio_coding/codecs/isac/main/source/os_specific_inline.h
@@ -12,7 +12,8 @@
 #define MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_OS_SPECIFIC_INLINE_H_
 
 #include <math.h>
-#include "typedefs.h"  // NOLINT(build/include)
+
+#include "rtc_base/system/arch.h"
 
 #if defined(WEBRTC_POSIX)
 #define WebRtcIsac_lrint lrint
diff --git a/modules/audio_coding/codecs/isac/main/source/pitch_gain_tables.h b/modules/audio_coding/codecs/isac/main/source/pitch_gain_tables.h
index 891bcef..145fd4e 100644
--- a/modules/audio_coding/codecs/isac/main/source/pitch_gain_tables.h
+++ b/modules/audio_coding/codecs/isac/main/source/pitch_gain_tables.h
@@ -19,7 +19,7 @@
 #ifndef MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_PITCH_GAIN_TABLES_H_
 #define MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_PITCH_GAIN_TABLES_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 /* header file for coding tables for the pitch filter side-info in the entropy
  * coder */
diff --git a/modules/audio_coding/codecs/isac/main/source/pitch_lag_tables.h b/modules/audio_coding/codecs/isac/main/source/pitch_lag_tables.h
index b662ab5..b48e358 100644
--- a/modules/audio_coding/codecs/isac/main/source/pitch_lag_tables.h
+++ b/modules/audio_coding/codecs/isac/main/source/pitch_lag_tables.h
@@ -19,7 +19,8 @@
 #ifndef MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_PITCH_LAG_TABLES_H_
 #define MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_PITCH_LAG_TABLES_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
+
 /* header file for coding tables for the pitch filter side-info in the entropy
  * coder */
 /********************* Pitch Filter Lag Coefficient Tables
diff --git a/modules/audio_coding/codecs/isac/main/source/settings.h b/modules/audio_coding/codecs/isac/main/source/settings.h
index 14a5be8..abce90c 100644
--- a/modules/audio_coding/codecs/isac/main/source/settings.h
+++ b/modules/audio_coding/codecs/isac/main/source/settings.h
@@ -24,9 +24,6 @@
 /* number of samples per frame (either 320 (20ms), 480 (30ms) or 960 (60ms)) */
 #define INITIAL_FRAMESAMPLES 960
 
-#define MAXFFTSIZE 2048
-#define NFACTOR 11
-
 /* do not modify the following; this will have to be modified if we
  * have a 20ms framesize option */
 /**********************************************************************/
diff --git a/modules/audio_coding/codecs/isac/main/source/structs.h b/modules/audio_coding/codecs/isac/main/source/structs.h
index f8ac9c7..1255d5b 100644
--- a/modules/audio_coding/codecs/isac/main/source/structs.h
+++ b/modules/audio_coding/codecs/isac/main/source/structs.h
@@ -20,7 +20,7 @@
 
 #include "modules/audio_coding/codecs/isac/bandwidth_info.h"
 #include "modules/audio_coding/codecs/isac/main/source/settings.h"
-#include "typedefs.h"  // NOLINT(build/include)
+#include "modules/third_party/fft/fft.h"
 
 typedef struct Bitstreamstruct {
   uint8_t stream[STREAM_SIZE_MAX];
@@ -229,18 +229,6 @@
 
 } RateModel;
 
-typedef struct {
-  unsigned int SpaceAlloced;
-  unsigned int MaxPermAlloced;
-  double Tmp0[MAXFFTSIZE];
-  double Tmp1[MAXFFTSIZE];
-  double Tmp2[MAXFFTSIZE];
-  double Tmp3[MAXFFTSIZE];
-  int Perm[MAXFFTSIZE];
-  int factor[NFACTOR];
-
-} FFTstr;
-
 /* The following strutc is used to store data from encoding, to make it
    fast and easy to construct a new bitstream with a different Bandwidth
    estimate. All values (except framelength and minBytes) is double size to
diff --git a/modules/audio_coding/codecs/isac/main/source/transform.c b/modules/audio_coding/codecs/isac/main/source/transform.c
index bfbfecb..082ad94 100644
--- a/modules/audio_coding/codecs/isac/main/source/transform.c
+++ b/modules/audio_coding/codecs/isac/main/source/transform.c
@@ -11,9 +11,9 @@
 #include <math.h>
 
 #include "modules/audio_coding/codecs/isac/main/source/settings.h"
-#include "modules/audio_coding/codecs/isac/main/source/fft.h"
 #include "modules/audio_coding/codecs/isac/main/source/codec.h"
 #include "modules/audio_coding/codecs/isac/main/source/os_specific_inline.h"
+#include "modules/third_party/fft/fft.h"
 
 void WebRtcIsac_InitTransform(TransformTables* tables) {
   int k;
diff --git a/modules/audio_coding/codecs/opus/opus_fec_test.cc b/modules/audio_coding/codecs/opus/opus_fec_test.cc
index f1983ae..4fab8a7 100644
--- a/modules/audio_coding/codecs/opus/opus_fec_test.cc
+++ b/modules/audio_coding/codecs/opus/opus_fec_test.cc
@@ -38,8 +38,8 @@
  protected:
   OpusFecTest();
 
-  virtual void SetUp();
-  virtual void TearDown();
+  void SetUp() override;
+  void TearDown() override;
 
   virtual void EncodeABlock();
 
diff --git a/modules/audio_coding/codecs/opus/opus_interface.h b/modules/audio_coding/codecs/opus/opus_interface.h
index 0b1c64d..ddb4ff9 100644
--- a/modules/audio_coding/codecs/opus/opus_interface.h
+++ b/modules/audio_coding/codecs/opus/opus_interface.h
@@ -12,9 +12,9 @@
 #define MODULES_AUDIO_CODING_CODECS_OPUS_OPUS_INTERFACE_H_
 
 #include <stddef.h>
+#include <stdint.h>
 
 #include "modules/audio_coding/codecs/opus/opus_inst.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/modules/audio_coding/codecs/pcm16b/pcm16b.c b/modules/audio_coding/codecs/pcm16b/pcm16b.c
index abcff4f..2f6dce5 100644
--- a/modules/audio_coding/codecs/pcm16b/pcm16b.c
+++ b/modules/audio_coding/codecs/pcm16b/pcm16b.c
@@ -10,8 +10,6 @@
 
 #include "modules/audio_coding/codecs/pcm16b/pcm16b.h"
 
-#include "typedefs.h"  // NOLINT(build/include)
-
 size_t WebRtcPcm16b_Encode(const int16_t* speech,
                            size_t len,
                            uint8_t* encoded) {
diff --git a/modules/audio_coding/codecs/pcm16b/pcm16b.h b/modules/audio_coding/codecs/pcm16b/pcm16b.h
index 9a3bfe9..75d1efd 100644
--- a/modules/audio_coding/codecs/pcm16b/pcm16b.h
+++ b/modules/audio_coding/codecs/pcm16b/pcm16b.h
@@ -15,8 +15,7 @@
  */
 
 #include <stddef.h>
-
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/modules/audio_coding/codecs/tools/audio_codec_speed_test.h b/modules/audio_coding/codecs/tools/audio_codec_speed_test.h
index 0214a7d..c626bfa 100644
--- a/modules/audio_coding/codecs/tools/audio_codec_speed_test.h
+++ b/modules/audio_coding/codecs/tools/audio_codec_speed_test.h
@@ -15,7 +15,6 @@
 #include <string>
 
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/include/audio_coding_module.h b/modules/audio_coding/include/audio_coding_module.h
index a5ad4ff..840a719 100644
--- a/modules/audio_coding/include/audio_coding_module.h
+++ b/modules/audio_coding/include/audio_coding_module.h
@@ -21,10 +21,8 @@
 #include "common_types.h"  // NOLINT(build/include)
 #include "modules/audio_coding/include/audio_coding_module_typedefs.h"
 #include "modules/audio_coding/neteq/include/neteq.h"
-#include "rtc_base/deprecation.h"
 #include "rtc_base/function_view.h"
 #include "system_wrappers/include/clock.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
@@ -153,20 +151,6 @@
                    size_t channels);
 
   ///////////////////////////////////////////////////////////////////////////
-  // bool IsCodecValid()
-  // Checks the validity of the parameters of the given codec.
-  //
-  // Input:
-  //   -codec              : the structure which keeps the parameters of the
-  //                         codec.
-  //
-  // Return value:
-  //   true if the parameters are valid,
-  //   false if any parameter is not valid.
-  //
-  static bool IsCodecValid(const CodecInst& codec);
-
-  ///////////////////////////////////////////////////////////////////////////
   //   Sender
   //
 
@@ -212,11 +196,6 @@
   virtual void ModifyEncoder(
       rtc::FunctionView<void(std::unique_ptr<AudioEncoder>*)> modifier) = 0;
 
-  // |modifier| is called exactly once with one argument: a const pointer to the
-  // current encoder (which is null if there is no current encoder).
-  virtual void QueryEncoder(
-      rtc::FunctionView<void(AudioEncoder const*)> query) = 0;
-
   // Utility method for simply replacing the existing encoder with a new one.
   void SetEncoder(std::unique_ptr<AudioEncoder> new_encoder) {
     ModifyEncoder([&](std::unique_ptr<AudioEncoder>* encoder) {
@@ -234,16 +213,6 @@
   virtual absl::optional<CodecInst> SendCodec() const = 0;
 
   ///////////////////////////////////////////////////////////////////////////
-  // int32_t SendFrequency()
-  // Get the sampling frequency of the current encoder in Hertz.
-  //
-  // Return value:
-  //   positive; sampling frequency [Hz] of the current encoder.
-  //   -1 if an error has happened.
-  //
-  virtual int32_t SendFrequency() const = 0;
-
-  ///////////////////////////////////////////////////////////////////////////
   // Sets the bitrate to the specified value in bits/sec. If the value is not
   // supported by the codec, it will choose another appropriate value.
   //
@@ -604,29 +573,6 @@
   //
   virtual int SetMaximumPlayoutDelay(int time_ms) = 0;
 
-  // TODO(kwiberg): Consider if this is needed anymore, now that voe::Channel
-  //                doesn't use it.
-  // The shortest latency, in milliseconds, required by jitter buffer. This
-  // is computed based on inter-arrival times and playout mode of NetEq. The
-  // actual delay is the maximum of least-required-delay and the minimum-delay
-  // specified by SetMinumumPlayoutDelay() API.
-  //
-  virtual int LeastRequiredDelayMs() const = 0;
-
-  // int32_t PlayoutTimestamp()
-  // The send timestamp of an RTP packet is associated with the decoded
-  // audio of the packet in question. This function returns the timestamp of
-  // the latest audio obtained by calling PlayoutData10ms().
-  //
-  // Input:
-  //   -timestamp          : a reference to a uint32_t to receive the
-  //                         timestamp.
-  // Return value:
-  //    0 if the output is a correct timestamp.
-  //   -1 if failed to output the correct timestamp.
-  //
-  RTC_DEPRECATED virtual int32_t PlayoutTimestamp(uint32_t* timestamp) = 0;
-
   ///////////////////////////////////////////////////////////////////////////
   // int32_t PlayoutTimestamp()
   // The send timestamp of an RTP packet is associated with the decoded
@@ -675,14 +621,6 @@
                                   AudioFrame* audio_frame,
                                   bool* muted) = 0;
 
-  /////////////////////////////////////////////////////////////////////////////
-  // Same as above, but without the muted parameter. This methods should not be
-  // used if enable_fast_accelerate was set to true in NetEq::Config.
-  // TODO(henrik.lundin) Remove this method when downstream dependencies are
-  // ready.
-  virtual int32_t PlayoutData10Ms(int32_t desired_freq_hz,
-                                  AudioFrame* audio_frame) = 0;
-
   ///////////////////////////////////////////////////////////////////////////
   //   Codec specific
   //
diff --git a/modules/audio_coding/include/audio_coding_module_typedefs.h b/modules/audio_coding/include/audio_coding_module_typedefs.h
index e8f80dc..cd4351b 100644
--- a/modules/audio_coding/include/audio_coding_module_typedefs.h
+++ b/modules/audio_coding/include/audio_coding_module_typedefs.h
@@ -13,8 +13,6 @@
 
 #include <map>
 
-#include "typedefs.h"  // NOLINT(build/include)
-
 namespace webrtc {
 
 ///////////////////////////////////////////////////////////////////////////
diff --git a/modules/audio_coding/module.mk b/modules/audio_coding/module.mk
index b49e8aa..02f2a06 100644
--- a/modules/audio_coding/module.mk
+++ b/modules/audio_coding/module.mk
@@ -22,7 +22,6 @@
 	modules/audio_coding/codecs/isac/main/source/encode.o \
 	modules/audio_coding/codecs/isac/main/source/encode_lpc_swb.o \
 	modules/audio_coding/codecs/isac/main/source/entropy_coding.o \
-	modules/audio_coding/codecs/isac/main/source/fft.o \
 	modules/audio_coding/codecs/isac/main/source/filterbanks.o \
 	modules/audio_coding/codecs/isac/main/source/intialize.o \
 	modules/audio_coding/codecs/isac/main/source/isac.o \
@@ -35,7 +34,8 @@
 	modules/audio_coding/codecs/isac/main/source/pitch_gain_tables.o \
 	modules/audio_coding/codecs/isac/main/source/pitch_lag_tables.o \
 	modules/audio_coding/codecs/isac/main/source/spectrum_ar_model_tables.o \
-	modules/audio_coding/codecs/isac/main/source/transform.o
+	modules/audio_coding/codecs/isac/main/source/transform.o \
+	modules/third_party/fft/fft.o
 
 CC_STATIC_LIBRARY(modules/audio_coding/libaudio_coding.pic.a): \
 	$(isac_c_C_OBJECTS) $(isac_vad_c_OBJECTS)
diff --git a/modules/audio_coding/neteq/accelerate.h b/modules/audio_coding/neteq/accelerate.h
index 6d5b115..b0bab32 100644
--- a/modules/audio_coding/neteq/accelerate.h
+++ b/modules/audio_coding/neteq/accelerate.h
@@ -16,7 +16,6 @@
 #include "modules/audio_coding/neteq/audio_multi_vector.h"
 #include "modules/audio_coding/neteq/time_stretch.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/audio_decoder_unittest.cc b/modules/audio_coding/neteq/audio_decoder_unittest.cc
index 54ede6f..1ad4835 100644
--- a/modules/audio_coding/neteq/audio_decoder_unittest.cc
+++ b/modules/audio_coding/neteq/audio_decoder_unittest.cc
@@ -100,16 +100,16 @@
         payload_type_(17),
         decoder_(NULL) {}
 
-  virtual ~AudioDecoderTest() {}
+  ~AudioDecoderTest() override {}
 
-  virtual void SetUp() {
+  void SetUp() override {
     if (audio_encoder_)
       codec_input_rate_hz_ = audio_encoder_->SampleRateHz();
     // Create arrays.
     ASSERT_GT(data_length_, 0u) << "The test must set data_length_ > 0";
   }
 
-  virtual void TearDown() {
+  void TearDown() override {
     delete decoder_;
     decoder_ = NULL;
   }
diff --git a/modules/audio_coding/neteq/audio_multi_vector.cc b/modules/audio_coding/neteq/audio_multi_vector.cc
index fee37cb..874633f 100644
--- a/modules/audio_coding/neteq/audio_multi_vector.cc
+++ b/modules/audio_coding/neteq/audio_multi_vector.cc
@@ -15,7 +15,6 @@
 #include <algorithm>
 
 #include "rtc_base/checks.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/audio_multi_vector.h b/modules/audio_coding/neteq/audio_multi_vector.h
index f54c98b..4a9ed48 100644
--- a/modules/audio_coding/neteq/audio_multi_vector.h
+++ b/modules/audio_coding/neteq/audio_multi_vector.h
@@ -17,7 +17,6 @@
 
 #include "modules/audio_coding/neteq/audio_vector.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/audio_multi_vector_unittest.cc b/modules/audio_coding/neteq/audio_multi_vector_unittest.cc
index 7272dc2..3f3283e 100644
--- a/modules/audio_coding/neteq/audio_multi_vector_unittest.cc
+++ b/modules/audio_coding/neteq/audio_multi_vector_unittest.cc
@@ -17,7 +17,6 @@
 
 #include "rtc_base/numerics/safe_conversions.h"
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/audio_vector.cc b/modules/audio_coding/neteq/audio_vector.cc
index 0486416..b3ad48f 100644
--- a/modules/audio_coding/neteq/audio_vector.cc
+++ b/modules/audio_coding/neteq/audio_vector.cc
@@ -16,7 +16,6 @@
 #include <memory>
 
 #include "rtc_base/checks.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/audio_vector.h b/modules/audio_coding/neteq/audio_vector.h
index 65939ce..825a3bc 100644
--- a/modules/audio_coding/neteq/audio_vector.h
+++ b/modules/audio_coding/neteq/audio_vector.h
@@ -16,7 +16,6 @@
 
 #include "rtc_base/checks.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/audio_vector_unittest.cc b/modules/audio_coding/neteq/audio_vector_unittest.cc
index e70178c..1a16bb3 100644
--- a/modules/audio_coding/neteq/audio_vector_unittest.cc
+++ b/modules/audio_coding/neteq/audio_vector_unittest.cc
@@ -17,7 +17,6 @@
 
 #include "rtc_base/numerics/safe_conversions.h"
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/background_noise.h b/modules/audio_coding/neteq/background_noise.h
index 26d42b5..58eecaa 100644
--- a/modules/audio_coding/neteq/background_noise.h
+++ b/modules/audio_coding/neteq/background_noise.h
@@ -17,7 +17,6 @@
 #include "modules/audio_coding/neteq/audio_multi_vector.h"
 #include "modules/audio_coding/neteq/include/neteq.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/comfort_noise.h b/modules/audio_coding/neteq/comfort_noise.h
index c8cc64a..5169124 100644
--- a/modules/audio_coding/neteq/comfort_noise.h
+++ b/modules/audio_coding/neteq/comfort_noise.h
@@ -13,7 +13,6 @@
 
 #include "modules/audio_coding/neteq/audio_multi_vector.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/decision_logic.h b/modules/audio_coding/neteq/decision_logic.h
index 20ba8af..00b8620 100644
--- a/modules/audio_coding/neteq/decision_logic.h
+++ b/modules/audio_coding/neteq/decision_logic.h
@@ -15,7 +15,6 @@
 #include "modules/audio_coding/neteq/include/neteq.h"
 #include "modules/audio_coding/neteq/tick_timer.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/decoder_database.h b/modules/audio_coding/neteq/decoder_database.h
index 107d2f3..131e769 100644
--- a/modules/audio_coding/neteq/decoder_database.h
+++ b/modules/audio_coding/neteq/decoder_database.h
@@ -23,7 +23,6 @@
 #include "modules/audio_coding/neteq/packet.h"
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/scoped_ref_ptr.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/delay_manager.cc b/modules/audio_coding/neteq/delay_manager.cc
index a945cdc..84d457c 100644
--- a/modules/audio_coding/neteq/delay_manager.cc
+++ b/modules/audio_coding/neteq/delay_manager.cc
@@ -40,7 +40,6 @@
       last_seq_no_(0),
       last_timestamp_(0),
       minimum_delay_ms_(0),
-      least_required_delay_ms_(target_level_),
       maximum_delay_ms_(target_level_),
       iat_cumulative_sum_(0),
       max_iat_cumulative_sum_(0),
@@ -234,8 +233,6 @@
 // |least_required_level_| while the above limits are applied.
 // TODO(hlundin): Move this check to the buffer logistics class.
 void DelayManager::LimitTargetLevel() {
-  least_required_delay_ms_ = (target_level_ * packet_len_ms_) >> 8;
-
   if (packet_len_ms_ > 0 && minimum_delay_ms_ > 0) {
     int minimum_delay_packet_q8 = (minimum_delay_ms_ << 8) / packet_len_ms_;
     target_level_ = std::max(target_level_, minimum_delay_packet_q8);
@@ -467,10 +464,6 @@
   return true;
 }
 
-int DelayManager::least_required_delay_ms() const {
-  return least_required_delay_ms_;
-}
-
 int DelayManager::base_target_level() const {
   return base_target_level_;
 }
diff --git a/modules/audio_coding/neteq/delay_manager.h b/modules/audio_coding/neteq/delay_manager.h
index 08004ea..00e39af 100644
--- a/modules/audio_coding/neteq/delay_manager.h
+++ b/modules/audio_coding/neteq/delay_manager.h
@@ -18,7 +18,6 @@
 
 #include "modules/audio_coding/neteq/tick_timer.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
@@ -110,7 +109,6 @@
   // Assuming |delay| is in valid range.
   virtual bool SetMinimumDelay(int delay_ms);
   virtual bool SetMaximumDelay(int delay_ms);
-  virtual int least_required_delay_ms() const;
   virtual int base_target_level() const;
   virtual void set_streaming_mode(bool value);
   virtual int last_pack_cng_or_dtmf() const;
@@ -162,10 +160,6 @@
   uint16_t last_seq_no_;         // Sequence number for last received packet.
   uint32_t last_timestamp_;      // Timestamp for the last received packet.
   int minimum_delay_ms_;         // Externally set minimum delay.
-  int least_required_delay_ms_;  // Smallest preferred buffer level (same unit
-                                 // as |target_level_|), before applying
-                                 // |minimum_delay_ms_| and/or
-                                 // |maximum_delay_ms_|.
   int maximum_delay_ms_;         // Externally set maximum allowed delay.
   int iat_cumulative_sum_;       // Cumulative sum of delta inter-arrival times.
   int max_iat_cumulative_sum_;   // Max of |iat_cumulative_sum_|.
diff --git a/modules/audio_coding/neteq/delay_manager_unittest.cc b/modules/audio_coding/neteq/delay_manager_unittest.cc
index f9c5680..6afed66 100644
--- a/modules/audio_coding/neteq/delay_manager_unittest.cc
+++ b/modules/audio_coding/neteq/delay_manager_unittest.cc
@@ -200,7 +200,7 @@
   EXPECT_EQ(lower + (20 << 8) / kFrameSizeMs, higher);
 }
 
-TEST_F(DelayManagerTest, MaxAndRequiredDelay) {
+TEST_F(DelayManagerTest, MaxDelay) {
   const int kExpectedTarget = 5;
   const int kTimeIncrement = kExpectedTarget * kFrameSizeMs;
   SetPacketAudioLength(kFrameSizeMs);
@@ -224,14 +224,13 @@
   EXPECT_TRUE(dm_->SetMaximumDelay(kMaxDelayMs));
   IncreaseTime(kTimeIncrement);
   InsertNextPacket();
-  EXPECT_EQ(kExpectedTarget * kFrameSizeMs, dm_->least_required_delay_ms());
   EXPECT_EQ(kMaxDelayPackets << 8, dm_->TargetLevel());
 
   // Target level at least should be one packet.
   EXPECT_FALSE(dm_->SetMaximumDelay(kFrameSizeMs - 1));
 }
 
-TEST_F(DelayManagerTest, MinAndRequiredDelay) {
+TEST_F(DelayManagerTest, MinDelay) {
   const int kExpectedTarget = 5;
   const int kTimeIncrement = kExpectedTarget * kFrameSizeMs;
   SetPacketAudioLength(kFrameSizeMs);
@@ -255,7 +254,6 @@
   dm_->SetMinimumDelay(kMinDelayMs);
   IncreaseTime(kTimeIncrement);
   InsertNextPacket();
-  EXPECT_EQ(kExpectedTarget * kFrameSizeMs, dm_->least_required_delay_ms());
   EXPECT_EQ(kMinDelayPackets << 8, dm_->TargetLevel());
 }
 
diff --git a/modules/audio_coding/neteq/dsp_helper.h b/modules/audio_coding/neteq/dsp_helper.h
index 8940acd..efa2f9c 100644
--- a/modules/audio_coding/neteq/dsp_helper.h
+++ b/modules/audio_coding/neteq/dsp_helper.h
@@ -15,7 +15,6 @@
 
 #include "modules/audio_coding/neteq/audio_multi_vector.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/dsp_helper_unittest.cc b/modules/audio_coding/neteq/dsp_helper_unittest.cc
index 9d5da5d..ec434a4 100644
--- a/modules/audio_coding/neteq/dsp_helper_unittest.cc
+++ b/modules/audio_coding/neteq/dsp_helper_unittest.cc
@@ -12,7 +12,6 @@
 
 #include "modules/audio_coding/neteq/audio_multi_vector.h"
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/dtmf_buffer.h b/modules/audio_coding/neteq/dtmf_buffer.h
index 1035e87..6de5127 100644
--- a/modules/audio_coding/neteq/dtmf_buffer.h
+++ b/modules/audio_coding/neteq/dtmf_buffer.h
@@ -15,7 +15,6 @@
 #include <string>  // size_t
 
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/dtmf_tone_generator.h b/modules/audio_coding/neteq/dtmf_tone_generator.h
index b91d221..a773ff3 100644
--- a/modules/audio_coding/neteq/dtmf_tone_generator.h
+++ b/modules/audio_coding/neteq/dtmf_tone_generator.h
@@ -13,7 +13,6 @@
 
 #include "modules/audio_coding/neteq/audio_multi_vector.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/expand.h b/modules/audio_coding/neteq/expand.h
index 2fd4fae..4cfe7b9 100644
--- a/modules/audio_coding/neteq/expand.h
+++ b/modules/audio_coding/neteq/expand.h
@@ -16,7 +16,6 @@
 
 #include "modules/audio_coding/neteq/audio_multi_vector.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/include/neteq.h b/modules/audio_coding/neteq/include/neteq.h
index ce1448a..fdb73c5 100644
--- a/modules/audio_coding/neteq/include/neteq.h
+++ b/modules/audio_coding/neteq/include/neteq.h
@@ -24,7 +24,6 @@
 #include "modules/audio_coding/neteq/neteq_decoder_enum.h"
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/scoped_ref_ptr.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
@@ -97,7 +96,7 @@
     bool for_test_no_time_stretching = false;  // Use only for testing.
   };
 
-  enum ReturnCodes { kOK = 0, kFail = -1, kNotImplemented = -2 };
+  enum ReturnCodes { kOK = 0, kFail = -1 };
 
   // Creates a new NetEq object, with parameters set in |config|. The |config|
   // object will only have to be valid for the duration of the call to this
@@ -181,15 +180,6 @@
   // the |max_delay_ms| value in the NetEq::Config struct.
   virtual bool SetMaximumDelay(int delay_ms) = 0;
 
-  // The smallest latency required. This is computed bases on inter-arrival
-  // time and internal NetEq logic. Note that in computing this latency none of
-  // the user defined limits (applied by calling setMinimumDelay() and/or
-  // SetMaximumDelay()) are applied.
-  virtual int LeastRequiredDelayMs() const = 0;
-
-  // Not implemented.
-  virtual int SetTargetDelay() = 0;
-
   // Returns the current target delay in ms. This includes any extra delay
   // requested through SetMinimumDelay.
   virtual int TargetDelayMs() const = 0;
@@ -242,12 +232,6 @@
   virtual absl::optional<SdpAudioFormat> GetDecoderFormat(
       int payload_type) const = 0;
 
-  // Not implemented.
-  virtual int SetTargetNumberOfChannels() = 0;
-
-  // Not implemented.
-  virtual int SetTargetSampleRate() = 0;
-
   // Flushes both the packet buffer and the sync buffer.
   virtual void FlushBuffers() = 0;
 
diff --git a/modules/audio_coding/neteq/merge.h b/modules/audio_coding/neteq/merge.h
index 017e824..235c07f 100644
--- a/modules/audio_coding/neteq/merge.h
+++ b/modules/audio_coding/neteq/merge.h
@@ -15,7 +15,6 @@
 
 #include "modules/audio_coding/neteq/audio_multi_vector.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/mock/mock_external_decoder_pcm16b.h b/modules/audio_coding/neteq/mock/mock_external_decoder_pcm16b.h
index 5aed6a9..1fb3db5 100644
--- a/modules/audio_coding/neteq/mock/mock_external_decoder_pcm16b.h
+++ b/modules/audio_coding/neteq/mock/mock_external_decoder_pcm16b.h
@@ -15,7 +15,6 @@
 #include "modules/audio_coding/codecs/pcm16b/pcm16b.h"
 #include "rtc_base/constructormagic.h"
 #include "test/gmock.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/nack_tracker_unittest.cc b/modules/audio_coding/neteq/nack_tracker_unittest.cc
index 19adf30..a44f41b 100644
--- a/modules/audio_coding/neteq/nack_tracker_unittest.cc
+++ b/modules/audio_coding/neteq/nack_tracker_unittest.cc
@@ -17,7 +17,6 @@
 
 #include "modules/audio_coding/include/audio_coding_module_typedefs.h"
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 namespace {
diff --git a/modules/audio_coding/neteq/neteq_impl.cc b/modules/audio_coding/neteq/neteq_impl.cc
index 0ef3263..ddcd221 100644
--- a/modules/audio_coding/neteq/neteq_impl.cc
+++ b/modules/audio_coding/neteq/neteq_impl.cc
@@ -307,16 +307,6 @@
   return false;
 }
 
-int NetEqImpl::LeastRequiredDelayMs() const {
-  rtc::CritScope lock(&crit_sect_);
-  assert(delay_manager_.get());
-  return delay_manager_->least_required_delay_ms();
-}
-
-int NetEqImpl::SetTargetDelay() {
-  return kNotImplemented;
-}
-
 int NetEqImpl::TargetDelayMs() const {
   rtc::CritScope lock(&crit_sect_);
   RTC_DCHECK(delay_manager_.get());
@@ -454,14 +444,6 @@
   return di->GetFormat();
 }
 
-int NetEqImpl::SetTargetNumberOfChannels() {
-  return kNotImplemented;
-}
-
-int NetEqImpl::SetTargetSampleRate() {
-  return kNotImplemented;
-}
-
 void NetEqImpl::FlushBuffers() {
   rtc::CritScope lock(&crit_sect_);
   RTC_LOG(LS_VERBOSE) << "FlushBuffers";
diff --git a/modules/audio_coding/neteq/neteq_impl.h b/modules/audio_coding/neteq/neteq_impl.h
index 6b8764d..68fdf3c 100644
--- a/modules/audio_coding/neteq/neteq_impl.h
+++ b/modules/audio_coding/neteq/neteq_impl.h
@@ -28,7 +28,6 @@
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/criticalsection.h"
 #include "rtc_base/thread_annotations.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
@@ -158,10 +157,6 @@
 
   bool SetMaximumDelay(int delay_ms) override;
 
-  int LeastRequiredDelayMs() const override;
-
-  int SetTargetDelay() override;
-
   int TargetDelayMs() const override;
 
   int CurrentDelayMs() const override;
@@ -197,10 +192,6 @@
   absl::optional<SdpAudioFormat> GetDecoderFormat(
       int payload_type) const override;
 
-  int SetTargetNumberOfChannels() override;
-
-  int SetTargetSampleRate() override;
-
   // Flushes both the packet buffer and the sync buffer.
   void FlushBuffers() override;
 
diff --git a/modules/audio_coding/neteq/neteq_unittest.cc b/modules/audio_coding/neteq/neteq_unittest.cc
index 5d43fdb..96a392b 100644
--- a/modules/audio_coding/neteq/neteq_unittest.cc
+++ b/modules/audio_coding/neteq/neteq_unittest.cc
@@ -33,10 +33,10 @@
 #include "rtc_base/numerics/safe_conversions.h"
 #include "rtc_base/protobuf_utils.h"
 #include "rtc_base/stringencode.h"
+#include "rtc_base/system/arch.h"
 #include "test/field_trial.h"
 #include "test/gtest.h"
 #include "test/testsupport/fileutils.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 // This must come after test/gtest.h
 #include "rtc_base/flags.h"  // NOLINT(build/include)
diff --git a/modules/audio_coding/neteq/normal.h b/modules/audio_coding/neteq/normal.h
index 41bd30a..b13f16e 100644
--- a/modules/audio_coding/neteq/normal.h
+++ b/modules/audio_coding/neteq/normal.h
@@ -20,7 +20,6 @@
 #include "rtc_base/checks.h"
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/numerics/safe_conversions.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/packet.h b/modules/audio_coding/neteq/packet.h
index 61b0144..45c56e1 100644
--- a/modules/audio_coding/neteq/packet.h
+++ b/modules/audio_coding/neteq/packet.h
@@ -17,7 +17,6 @@
 #include "api/audio_codecs/audio_decoder.h"
 #include "modules/audio_coding/neteq/tick_timer.h"
 #include "rtc_base/buffer.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/packet_buffer.h b/modules/audio_coding/neteq/packet_buffer.h
index 74f36a5..7e34c1e 100644
--- a/modules/audio_coding/neteq/packet_buffer.h
+++ b/modules/audio_coding/neteq/packet_buffer.h
@@ -16,7 +16,6 @@
 #include "modules/audio_coding/neteq/packet.h"
 #include "modules/include/module_common_types.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/post_decode_vad.h b/modules/audio_coding/neteq/post_decode_vad.h
index dac95f0..ad4f082 100644
--- a/modules/audio_coding/neteq/post_decode_vad.h
+++ b/modules/audio_coding/neteq/post_decode_vad.h
@@ -19,7 +19,6 @@
 #include "modules/audio_coding/neteq/defines.h"
 #include "modules/audio_coding/neteq/packet.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/preemptive_expand.h b/modules/audio_coding/neteq/preemptive_expand.h
index 197d3f1..4d72616 100644
--- a/modules/audio_coding/neteq/preemptive_expand.h
+++ b/modules/audio_coding/neteq/preemptive_expand.h
@@ -16,7 +16,6 @@
 #include "modules/audio_coding/neteq/audio_multi_vector.h"
 #include "modules/audio_coding/neteq/time_stretch.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/random_vector.h b/modules/audio_coding/neteq/random_vector.h
index 2c6e06c..e8c7ba8 100644
--- a/modules/audio_coding/neteq/random_vector.h
+++ b/modules/audio_coding/neteq/random_vector.h
@@ -11,10 +11,10 @@
 #ifndef MODULES_AUDIO_CODING_NETEQ_RANDOM_VECTOR_H_
 #define MODULES_AUDIO_CODING_NETEQ_RANDOM_VECTOR_H_
 
-#include <string.h>  // size_t
+#include <stddef.h>
+#include <stdint.h>
 
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/rtcp.h b/modules/audio_coding/neteq/rtcp.h
index 45bb058..b1de7eb 100644
--- a/modules/audio_coding/neteq/rtcp.h
+++ b/modules/audio_coding/neteq/rtcp.h
@@ -13,7 +13,6 @@
 
 #include "modules/audio_coding/neteq/include/neteq.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/statistics_calculator.h b/modules/audio_coding/neteq/statistics_calculator.h
index 42fd4c9..5f7d06a 100644
--- a/modules/audio_coding/neteq/statistics_calculator.h
+++ b/modules/audio_coding/neteq/statistics_calculator.h
@@ -16,7 +16,6 @@
 
 #include "modules/audio_coding/neteq/include/neteq.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/sync_buffer.h b/modules/audio_coding/neteq/sync_buffer.h
index 8a35326..3833cb2 100644
--- a/modules/audio_coding/neteq/sync_buffer.h
+++ b/modules/audio_coding/neteq/sync_buffer.h
@@ -14,7 +14,6 @@
 #include "api/audio/audio_frame.h"
 #include "modules/audio_coding/neteq/audio_multi_vector.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/tick_timer.h b/modules/audio_coding/neteq/tick_timer.h
index 4a9ade5..520099e 100644
--- a/modules/audio_coding/neteq/tick_timer.h
+++ b/modules/audio_coding/neteq/tick_timer.h
@@ -15,7 +15,6 @@
 
 #include "rtc_base/checks.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/time_stretch.h b/modules/audio_coding/neteq/time_stretch.h
index 606d1d0..13ad2c8 100644
--- a/modules/audio_coding/neteq/time_stretch.h
+++ b/modules/audio_coding/neteq/time_stretch.h
@@ -16,7 +16,6 @@
 
 #include "modules/audio_coding/neteq/audio_multi_vector.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/timestamp_scaler.h b/modules/audio_coding/neteq/timestamp_scaler.h
index f0b05d6..62f535c 100644
--- a/modules/audio_coding/neteq/timestamp_scaler.h
+++ b/modules/audio_coding/neteq/timestamp_scaler.h
@@ -13,7 +13,6 @@
 
 #include "modules/audio_coding/neteq/packet.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/tools/audio_checksum.h b/modules/audio_coding/neteq/tools/audio_checksum.h
index db67edf..ee8c582 100644
--- a/modules/audio_coding/neteq/tools/audio_checksum.h
+++ b/modules/audio_coding/neteq/tools/audio_checksum.h
@@ -19,7 +19,7 @@
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/messagedigest.h"
 #include "rtc_base/stringencode.h"
-#include "typedefs.h"  // NOLINT(build/include)
+#include "rtc_base/system/arch.h"
 
 namespace webrtc {
 namespace test {
diff --git a/modules/audio_coding/neteq/tools/audio_loop.h b/modules/audio_coding/neteq/tools/audio_loop.h
index 876c2d7..c7788a6 100644
--- a/modules/audio_coding/neteq/tools/audio_loop.h
+++ b/modules/audio_coding/neteq/tools/audio_loop.h
@@ -16,7 +16,6 @@
 
 #include "api/array_view.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 namespace test {
diff --git a/modules/audio_coding/neteq/tools/audio_sink.h b/modules/audio_coding/neteq/tools/audio_sink.h
index 05e6fe8..be2a315 100644
--- a/modules/audio_coding/neteq/tools/audio_sink.h
+++ b/modules/audio_coding/neteq/tools/audio_sink.h
@@ -13,7 +13,6 @@
 
 #include "api/audio/audio_frame.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 namespace test {
diff --git a/modules/audio_coding/neteq/tools/encode_neteq_input.cc b/modules/audio_coding/neteq/tools/encode_neteq_input.cc
index f0d5b6f..c576670 100644
--- a/modules/audio_coding/neteq/tools/encode_neteq_input.cc
+++ b/modules/audio_coding/neteq/tools/encode_neteq_input.cc
@@ -27,6 +27,8 @@
   CreatePacket();
 }
 
+EncodeNetEqInput::~EncodeNetEqInput() = default;
+
 absl::optional<int64_t> EncodeNetEqInput::NextPacketTime() const {
   RTC_DCHECK(packet_data_);
   return static_cast<int64_t>(packet_data_->time_ms);
@@ -50,6 +52,10 @@
   next_output_event_ms_ += kOutputPeriodMs;
 }
 
+bool EncodeNetEqInput::ended() const {
+  return next_output_event_ms_ <= input_duration_ms_;
+}
+
 absl::optional<RTPHeader> EncodeNetEqInput::NextHeader() const {
   RTC_DCHECK(packet_data_);
   return packet_data_->header;
diff --git a/modules/audio_coding/neteq/tools/encode_neteq_input.h b/modules/audio_coding/neteq/tools/encode_neteq_input.h
index a75262b..caa9ac7 100644
--- a/modules/audio_coding/neteq/tools/encode_neteq_input.h
+++ b/modules/audio_coding/neteq/tools/encode_neteq_input.h
@@ -35,6 +35,7 @@
   EncodeNetEqInput(std::unique_ptr<Generator> generator,
                    std::unique_ptr<AudioEncoder> encoder,
                    int64_t input_duration_ms);
+  ~EncodeNetEqInput() override;
 
   absl::optional<int64_t> NextPacketTime() const override;
 
@@ -44,9 +45,7 @@
 
   void AdvanceOutputEvent() override;
 
-  bool ended() const override {
-    return next_output_event_ms_ <= input_duration_ms_;
-  }
+  bool ended() const override;
 
   absl::optional<RTPHeader> NextHeader() const override;
 
diff --git a/modules/audio_coding/neteq/tools/input_audio_file.h b/modules/audio_coding/neteq/tools/input_audio_file.h
index db5a944..b36dc24 100644
--- a/modules/audio_coding/neteq/tools/input_audio_file.h
+++ b/modules/audio_coding/neteq/tools/input_audio_file.h
@@ -16,7 +16,6 @@
 #include <string>
 
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 namespace test {
diff --git a/modules/audio_coding/neteq/tools/neteq_delay_analyzer.h b/modules/audio_coding/neteq/tools/neteq_delay_analyzer.h
index 5099e03..f6b895a 100644
--- a/modules/audio_coding/neteq/tools/neteq_delay_analyzer.h
+++ b/modules/audio_coding/neteq/tools/neteq_delay_analyzer.h
@@ -19,7 +19,6 @@
 #include "absl/types/optional.h"
 #include "modules/audio_coding/neteq/tools/neteq_input.h"
 #include "modules/audio_coding/neteq/tools/neteq_test.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 namespace test {
diff --git a/modules/audio_coding/neteq/tools/neteq_input.cc b/modules/audio_coding/neteq/tools/neteq_input.cc
index fed3ecc..bb2a01e 100644
--- a/modules/audio_coding/neteq/tools/neteq_input.cc
+++ b/modules/audio_coding/neteq/tools/neteq_input.cc
@@ -15,6 +15,9 @@
 namespace webrtc {
 namespace test {
 
+NetEqInput::PacketData::PacketData() = default;
+NetEqInput::PacketData::~PacketData() = default;
+
 std::string NetEqInput::PacketData::ToString() const {
   std::stringstream ss;
   ss << "{"
@@ -34,6 +37,8 @@
       start_time_ms_(input_->NextEventTime()),
       duration_ms_(duration_ms) {}
 
+TimeLimitedNetEqInput::~TimeLimitedNetEqInput() = default;
+
 absl::optional<int64_t> TimeLimitedNetEqInput::NextPacketTime() const {
   return ended_ ? absl::nullopt : input_->NextPacketTime();
 }
diff --git a/modules/audio_coding/neteq/tools/neteq_input.h b/modules/audio_coding/neteq/tools/neteq_input.h
index 1691585..b9cba09 100644
--- a/modules/audio_coding/neteq/tools/neteq_input.h
+++ b/modules/audio_coding/neteq/tools/neteq_input.h
@@ -28,6 +28,8 @@
 class NetEqInput {
  public:
   struct PacketData {
+    PacketData();
+    ~PacketData();
     std::string ToString() const;
 
     RTPHeader header;
@@ -84,6 +86,7 @@
 class TimeLimitedNetEqInput : public NetEqInput {
  public:
   TimeLimitedNetEqInput(std::unique_ptr<NetEqInput> input, int64_t duration_ms);
+  ~TimeLimitedNetEqInput() override;
   absl::optional<int64_t> NextPacketTime() const override;
   absl::optional<int64_t> NextOutputEventTime() const override;
   std::unique_ptr<PacketData> PopPacket() override;
diff --git a/modules/audio_coding/neteq/tools/neteq_performance_test.cc b/modules/audio_coding/neteq/tools/neteq_performance_test.cc
index e0dfebf..52524fe 100644
--- a/modules/audio_coding/neteq/tools/neteq_performance_test.cc
+++ b/modules/audio_coding/neteq/tools/neteq_performance_test.cc
@@ -20,7 +20,6 @@
 #include "rtc_base/checks.h"
 #include "system_wrappers/include/clock.h"
 #include "test/testsupport/fileutils.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 using webrtc::NetEq;
 using webrtc::test::AudioLoop;
diff --git a/modules/audio_coding/neteq/tools/neteq_performance_test.h b/modules/audio_coding/neteq/tools/neteq_performance_test.h
index dcf0314..d2212f0 100644
--- a/modules/audio_coding/neteq/tools/neteq_performance_test.h
+++ b/modules/audio_coding/neteq/tools/neteq_performance_test.h
@@ -11,7 +11,7 @@
 #ifndef MODULES_AUDIO_CODING_NETEQ_TOOLS_NETEQ_PERFORMANCE_TEST_H_
 #define MODULES_AUDIO_CODING_NETEQ_TOOLS_NETEQ_PERFORMANCE_TEST_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 namespace webrtc {
 namespace test {
diff --git a/modules/audio_coding/neteq/tools/neteq_quality_test.h b/modules/audio_coding/neteq/tools/neteq_quality_test.h
index b19460c..3d7760e 100644
--- a/modules/audio_coding/neteq/tools/neteq_quality_test.h
+++ b/modules/audio_coding/neteq/tools/neteq_quality_test.h
@@ -21,7 +21,6 @@
 #include "modules/audio_coding/neteq/tools/rtp_generator.h"
 #include "rtc_base/flags.h"
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 namespace test {
diff --git a/modules/audio_coding/neteq/tools/neteq_replacement_input.cc b/modules/audio_coding/neteq/tools/neteq_replacement_input.cc
index 6aa7581..362eb89 100644
--- a/modules/audio_coding/neteq/tools/neteq_replacement_input.cc
+++ b/modules/audio_coding/neteq/tools/neteq_replacement_input.cc
@@ -28,7 +28,6 @@
   RTC_CHECK(source_);
   packet_ = source_->PopPacket();
   ReplacePacket();
-  RTC_CHECK(packet_);
 }
 
 absl::optional<int64_t> NetEqReplacementInput::NextPacketTime() const {
diff --git a/modules/audio_coding/neteq/tools/neteq_rtpplay.cc b/modules/audio_coding/neteq/tools/neteq_rtpplay.cc
index 7f1263c..bf782bf 100644
--- a/modules/audio_coding/neteq/tools/neteq_rtpplay.cc
+++ b/modules/audio_coding/neteq/tools/neteq_rtpplay.cc
@@ -31,8 +31,8 @@
 #include "modules/audio_coding/neteq/tools/rtp_file_source.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/flags.h"
+#include "test/field_trial.h"
 #include "test/testsupport/fileutils.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 namespace test {
@@ -133,6 +133,12 @@
             "Generates a python script for plotting the delay profile");
 DEFINE_bool(help, false, "Prints this message");
 DEFINE_bool(concealment_events, false, "Prints concealment events");
+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.");
 
 // Maps a codec type to a printable name string.
 std::string CodecName(NetEqDecoder codec) {
@@ -293,6 +299,10 @@
     std::cout << usage;
     return 0;
   }
+
+  ValidateFieldTrialsStringOrDie(FLAG_force_fieldtrials);
+  ScopedFieldTrials field_trials(FLAG_force_fieldtrials);
+
   RTC_CHECK(ValidatePayloadType(FLAG_pcmu));
   RTC_CHECK(ValidatePayloadType(FLAG_pcma));
   RTC_CHECK(ValidatePayloadType(FLAG_ilbc));
@@ -398,32 +408,38 @@
   std::cout << "Output file: " << output_file_name << std::endl;
 
   NetEqTest::DecoderMap codecs = {
-      {FLAG_pcmu, std::make_pair(NetEqDecoder::kDecoderPCMu, "pcmu")},
-      {FLAG_pcma, std::make_pair(NetEqDecoder::kDecoderPCMa, "pcma")},
-      {FLAG_ilbc, std::make_pair(NetEqDecoder::kDecoderILBC, "ilbc")},
-      {FLAG_isac, std::make_pair(NetEqDecoder::kDecoderISAC, "isac")},
-      {FLAG_isac_swb,
-       std::make_pair(NetEqDecoder::kDecoderISACswb, "isac-swb")},
-      {FLAG_opus, std::make_pair(NetEqDecoder::kDecoderOpus, "opus")},
-      {FLAG_pcm16b, std::make_pair(NetEqDecoder::kDecoderPCM16B, "pcm16-nb")},
-      {FLAG_pcm16b_wb,
-       std::make_pair(NetEqDecoder::kDecoderPCM16Bwb, "pcm16-wb")},
-      {FLAG_pcm16b_swb32,
-       std::make_pair(NetEqDecoder::kDecoderPCM16Bswb32kHz, "pcm16-swb32")},
-      {FLAG_pcm16b_swb48,
-       std::make_pair(NetEqDecoder::kDecoderPCM16Bswb48kHz, "pcm16-swb48")},
-      {FLAG_g722, std::make_pair(NetEqDecoder::kDecoderG722, "g722")},
-      {FLAG_avt, std::make_pair(NetEqDecoder::kDecoderAVT, "avt")},
-      {FLAG_avt_16, std::make_pair(NetEqDecoder::kDecoderAVT16kHz, "avt-16")},
-      {FLAG_avt_32, std::make_pair(NetEqDecoder::kDecoderAVT32kHz, "avt-32")},
-      {FLAG_avt_48, std::make_pair(NetEqDecoder::kDecoderAVT48kHz, "avt-48")},
-      {FLAG_red, std::make_pair(NetEqDecoder::kDecoderRED, "red")},
-      {FLAG_cn_nb, std::make_pair(NetEqDecoder::kDecoderCNGnb, "cng-nb")},
-      {FLAG_cn_wb, std::make_pair(NetEqDecoder::kDecoderCNGwb, "cng-wb")},
-      {FLAG_cn_swb32,
-       std::make_pair(NetEqDecoder::kDecoderCNGswb32kHz, "cng-swb32")},
-      {FLAG_cn_swb48,
-       std::make_pair(NetEqDecoder::kDecoderCNGswb48kHz, "cng-swb48")}};
+    {FLAG_pcmu, std::make_pair(NetEqDecoder::kDecoderPCMu, "pcmu")},
+    {FLAG_pcma, std::make_pair(NetEqDecoder::kDecoderPCMa, "pcma")},
+#ifdef WEBRTC_CODEC_ILBC
+    {FLAG_ilbc, std::make_pair(NetEqDecoder::kDecoderILBC, "ilbc")},
+#endif
+    {FLAG_isac, std::make_pair(NetEqDecoder::kDecoderISAC, "isac")},
+#if !defined(WEBRTC_ANDROID)
+    {FLAG_isac_swb, std::make_pair(NetEqDecoder::kDecoderISACswb, "isac-swb")},
+#endif
+#ifdef WEBRTC_CODEC_OPUS
+    {FLAG_opus, std::make_pair(NetEqDecoder::kDecoderOpus, "opus")},
+#endif
+    {FLAG_pcm16b, std::make_pair(NetEqDecoder::kDecoderPCM16B, "pcm16-nb")},
+    {FLAG_pcm16b_wb,
+     std::make_pair(NetEqDecoder::kDecoderPCM16Bwb, "pcm16-wb")},
+    {FLAG_pcm16b_swb32,
+     std::make_pair(NetEqDecoder::kDecoderPCM16Bswb32kHz, "pcm16-swb32")},
+    {FLAG_pcm16b_swb48,
+     std::make_pair(NetEqDecoder::kDecoderPCM16Bswb48kHz, "pcm16-swb48")},
+    {FLAG_g722, std::make_pair(NetEqDecoder::kDecoderG722, "g722")},
+    {FLAG_avt, std::make_pair(NetEqDecoder::kDecoderAVT, "avt")},
+    {FLAG_avt_16, std::make_pair(NetEqDecoder::kDecoderAVT16kHz, "avt-16")},
+    {FLAG_avt_32, std::make_pair(NetEqDecoder::kDecoderAVT32kHz, "avt-32")},
+    {FLAG_avt_48, std::make_pair(NetEqDecoder::kDecoderAVT48kHz, "avt-48")},
+    {FLAG_red, std::make_pair(NetEqDecoder::kDecoderRED, "red")},
+    {FLAG_cn_nb, std::make_pair(NetEqDecoder::kDecoderCNGnb, "cng-nb")},
+    {FLAG_cn_wb, std::make_pair(NetEqDecoder::kDecoderCNGwb, "cng-wb")},
+    {FLAG_cn_swb32,
+     std::make_pair(NetEqDecoder::kDecoderCNGswb32kHz, "cng-swb32")},
+    {FLAG_cn_swb48,
+     std::make_pair(NetEqDecoder::kDecoderCNGswb48kHz, "cng-swb48")}
+  };
 
   // Check if a replacement audio file was provided.
   std::unique_ptr<AudioDecoder> replacement_decoder;
diff --git a/modules/audio_coding/neteq/tools/neteq_test.cc b/modules/audio_coding/neteq/tools/neteq_test.cc
index e2bed56..3448f4e 100644
--- a/modules/audio_coding/neteq/tools/neteq_test.cc
+++ b/modules/audio_coding/neteq/tools/neteq_test.cc
@@ -46,6 +46,8 @@
   RegisterExternalDecoders(ext_codecs);
 }
 
+NetEqTest::~NetEqTest() = default;
+
 int64_t NetEqTest::Run() {
   const int64_t start_time_ms = *input_->NextEventTime();
   int64_t time_now_ms = start_time_ms;
diff --git a/modules/audio_coding/neteq/tools/neteq_test.h b/modules/audio_coding/neteq/tools/neteq_test.h
index 9c05fc4..ada6bab 100644
--- a/modules/audio_coding/neteq/tools/neteq_test.h
+++ b/modules/audio_coding/neteq/tools/neteq_test.h
@@ -82,7 +82,7 @@
             std::unique_ptr<AudioSink> output,
             Callbacks callbacks);
 
-  ~NetEqTest() = default;
+  ~NetEqTest();
 
   // Runs the test. Returns the duration of the produced audio in ms.
   int64_t Run();
diff --git a/modules/audio_coding/neteq/tools/packet.h b/modules/audio_coding/neteq/tools/packet.h
index 2c9a26f..623c5cb 100644
--- a/modules/audio_coding/neteq/tools/packet.h
+++ b/modules/audio_coding/neteq/tools/packet.h
@@ -17,7 +17,6 @@
 #include "api/rtp_headers.h"  // NOLINT(build/include)
 #include "common_types.h"     // NOLINT(build/include)
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_coding/neteq/tools/packet_source.h b/modules/audio_coding/neteq/tools/packet_source.h
index 3f98ba1..fb689e3 100644
--- a/modules/audio_coding/neteq/tools/packet_source.h
+++ b/modules/audio_coding/neteq/tools/packet_source.h
@@ -16,7 +16,6 @@
 
 #include "modules/audio_coding/neteq/tools/packet.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 namespace test {
diff --git a/modules/audio_coding/neteq/tools/resample_input_audio_file.h b/modules/audio_coding/neteq/tools/resample_input_audio_file.h
index 13c419d..4e2e9b0 100644
--- a/modules/audio_coding/neteq/tools/resample_input_audio_file.h
+++ b/modules/audio_coding/neteq/tools/resample_input_audio_file.h
@@ -16,7 +16,6 @@
 #include "common_audio/resampler/include/resampler.h"
 #include "modules/audio_coding/neteq/tools/input_audio_file.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 namespace test {
diff --git a/modules/audio_coding/neteq/tools/rtp_encode.cc b/modules/audio_coding/neteq/tools/rtp_encode.cc
index abbb621..5065ca1 100644
--- a/modules/audio_coding/neteq/tools/rtp_encode.cc
+++ b/modules/audio_coding/neteq/tools/rtp_encode.cc
@@ -34,7 +34,6 @@
 #include "modules/audio_coding/neteq/tools/input_audio_file.h"
 #include "rtc_base/flags.h"
 #include "rtc_base/numerics/safe_conversions.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 namespace test {
diff --git a/modules/audio_coding/neteq/tools/rtp_file_source.h b/modules/audio_coding/neteq/tools/rtp_file_source.h
index b44bc64..013333b 100644
--- a/modules/audio_coding/neteq/tools/rtp_file_source.h
+++ b/modules/audio_coding/neteq/tools/rtp_file_source.h
@@ -39,7 +39,7 @@
   static bool ValidRtpDump(const std::string& file_name);
   static bool ValidPcap(const std::string& file_name);
 
-  virtual ~RtpFileSource();
+  ~RtpFileSource() override;
 
   // Registers an RTP header extension and binds it to |id|.
   virtual bool RegisterRtpHeaderExtension(RTPExtensionType type, uint8_t id);
diff --git a/modules/audio_coding/neteq/tools/rtp_generator.h b/modules/audio_coding/neteq/tools/rtp_generator.h
index 04fdbdd..ca7b04f 100644
--- a/modules/audio_coding/neteq/tools/rtp_generator.h
+++ b/modules/audio_coding/neteq/tools/rtp_generator.h
@@ -14,7 +14,6 @@
 #include "api/rtp_headers.h"
 #include "common_types.h"  // NOLINT(build/include)
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 namespace test {
diff --git a/modules/audio_coding/neteq/tools/rtp_jitter.cc b/modules/audio_coding/neteq/tools/rtp_jitter.cc
index d92fed0..3c49443 100644
--- a/modules/audio_coding/neteq/tools/rtp_jitter.cc
+++ b/modules/audio_coding/neteq/tools/rtp_jitter.cc
@@ -18,7 +18,6 @@
 #include "modules/rtp_rtcp/source/byte_io.h"
 #include "rtc_base/buffer.h"
 #include "rtc_base/flags.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 namespace test {
diff --git a/modules/audio_processing/BUILD.gn b/modules/audio_processing/BUILD.gn
index 4be7d8f..052bb47 100644
--- a/modules/audio_processing/BUILD.gn
+++ b/modules/audio_processing/BUILD.gn
@@ -37,8 +37,12 @@
     "common.h",
     "echo_cancellation_impl.cc",
     "echo_cancellation_impl.h",
+    "echo_cancellation_proxy.cc",
+    "echo_cancellation_proxy.h",
     "echo_control_mobile_impl.cc",
     "echo_control_mobile_impl.h",
+    "echo_control_mobile_proxy.cc",
+    "echo_control_mobile_proxy.h",
     "echo_detector/circular_buffer.cc",
     "echo_detector/circular_buffer.h",
     "echo_detector/mean_variance_estimator.cc",
@@ -101,7 +105,6 @@
     ":audio_processing_c",
     ":audio_processing_statistics",
     ":gain_control_interface",
-    "../..:typedefs",
     "../..:webrtc_common",
     "../../api:array_view",
     "../../api/audio:aec3_config",
@@ -109,12 +112,13 @@
     "../../api/audio:echo_control",
     "../../audio/utility:audio_frame_operations",
     "../../common_audio:common_audio_c",
-    "../../common_audio:fft4g",
+    "../../common_audio/third_party/fft4g:fft4g",
     "../../rtc_base:checks",
     "../../rtc_base:deprecation",
     "../../rtc_base:gtest_prod",
     "../../rtc_base:safe_minmax",
     "../../rtc_base:sanitizer",
+    "../../rtc_base/system:arch",
     "../../system_wrappers:cpu_features_api",
     "../../system_wrappers:field_trial_api",
     "../../system_wrappers:metrics_api",
@@ -134,18 +138,6 @@
     defines += [ "WEBRTC_UNTRUSTED_DELAY" ]
   }
 
-  if (rtc_enable_intelligibility_enhancer) {
-    defines += [ "WEBRTC_INTELLIGIBILITY_ENHANCER=1" ]
-    sources += [
-      "intelligibility/intelligibility_enhancer.cc",
-      "intelligibility/intelligibility_enhancer.h",
-      "intelligibility/intelligibility_utils.cc",
-      "intelligibility/intelligibility_utils.h",
-    ]
-  } else {
-    defines += [ "WEBRTC_INTELLIGIBILITY_ENHANCER=0" ]
-  }
-
   if (rtc_prefer_fixed_point) {
     defines += [ "WEBRTC_NS_FIXED" ]
   } else {
@@ -257,11 +249,10 @@
   }
 
   deps = [
-    "../..:typedefs",
     "../..:webrtc_common",
     "../../common_audio",
     "../../common_audio:common_audio_c",
-    "../../common_audio:fft4g",
+    "../../common_audio/third_party/fft4g:fft4g",
     "../../rtc_base:checks",
     "../../rtc_base:rtc_base_approved",
     "../../system_wrappers:cpu_features_api",
@@ -272,9 +263,7 @@
     sources += [ "ns/nsx_core_neon.c" ]
 
     if (current_cpu != "arm64") {
-      # Enable compilation for the NEON instruction set. This is needed
-      # since //build/config/arm.gni only enables NEON for iOS, not Android.
-      # This provides the same functionality as webrtc/build/arm_neon.gypi.
+      # Enable compilation for the NEON instruction set.
       suppressed_configs += [ "//build/config/compiler:compiler_arm_fpu" ]
       cflags = [ "-mfpu=neon" ]
     }
@@ -336,10 +325,6 @@
       ":transient_suppression_test",
     ]
 
-    if (rtc_enable_intelligibility_enhancer) {
-      deps += [ ":intelligibility_proc" ]
-    }
-
     if (rtc_enable_protobuf) {
       deps += [
         ":audioproc_f",
@@ -382,7 +367,6 @@
       ":audioproc_test_utils",
       ":file_audio_generator_unittests",
       ":mocks",
-      "../..:typedefs",
       "../..:webrtc_common",
       "../../api:array_view",
       "../../api/audio:aec3_config",
@@ -395,6 +379,7 @@
       "../../rtc_base:rtc_base",
       "../../rtc_base:rtc_base_approved",
       "../../rtc_base:safe_minmax",
+      "../../rtc_base/system:arch",
       "../../rtc_base/system:file_wrapper",
       "../../system_wrappers",
       "../../system_wrappers:cpu_features_api",
@@ -421,16 +406,6 @@
 
     defines = []
 
-    if (rtc_enable_intelligibility_enhancer) {
-      defines += [ "WEBRTC_INTELLIGIBILITY_ENHANCER=1" ]
-      sources += [
-        "intelligibility/intelligibility_enhancer_unittest.cc",
-        "intelligibility/intelligibility_utils_unittest.cc",
-      ]
-    } else {
-      defines += [ "WEBRTC_INTELLIGIBILITY_ENHANCER=0" ]
-    }
-
     if (rtc_prefer_fixed_point) {
       defines += [ "WEBRTC_AUDIOPROC_FIXED_PROFILE" ]
     } else {
@@ -445,6 +420,7 @@
         ":audioproc_test_utils",
         ":audioproc_unittest_proto",
         "../../api/audio:audio_frame_api",
+        "../../rtc_base:rtc_base_tests_utils",
         "../../rtc_base:rtc_task_queue",
         "aec_dump",
         "aec_dump:aec_dump_unittests",
@@ -498,12 +474,6 @@
       "../../test:perf_test",
       "../../test:test_support",
     ]
-
-    if (rtc_enable_intelligibility_enhancer) {
-      defines = [ "WEBRTC_INTELLIGIBILITY_ENHANCER=1" ]
-    } else {
-      defines = [ "WEBRTC_INTELLIGIBILITY_ENHANCER=0" ]
-    }
   }
 
   rtc_source_set("file_audio_generator_unittests") {
@@ -616,6 +586,7 @@
       "../../common_audio",
       "../../rtc_base:checks",
       "../../rtc_base:rtc_base_approved",
+      "../../rtc_base/system:arch",
       "../../system_wrappers",
       "../../test:fileutils",
       "../../test:test_support",
@@ -634,7 +605,6 @@
     ]
     deps = [
       ":audio_processing",
-      "../..:typedefs",
       "../..:webrtc_common",
       "../../common_audio:common_audio",
       "../../rtc_base:rtc_base_approved",
@@ -657,7 +627,6 @@
     ]
     deps = [
       ":audio_processing",
-      "../..:typedefs",
       "../..:webrtc_common",
       "../../rtc_base/system:file_wrapper",
       "../../system_wrappers",
@@ -665,24 +634,6 @@
     ]
   }
 
-  if (rtc_enable_intelligibility_enhancer) {
-    rtc_executable("intelligibility_proc") {
-      testonly = true
-      sources = [
-        "intelligibility/test/intelligibility_proc.cc",
-      ]
-      deps = [
-        ":audio_processing",
-        ":audioproc_test_utils",
-        "../../common_audio",
-        "../../rtc_base:rtc_base_approved",
-        "../../system_wrappers:metrics_default",
-        "../../test:test_support",
-        "//testing/gtest",
-      ]
-    }
-  }
-
   if (rtc_enable_protobuf) {
     proto_library("audioproc_unittest_proto") {
       sources = [
@@ -699,10 +650,10 @@
 
       deps = [
         ":audioproc_debug_proto",
-        "../..:typedefs",
         "../..:webrtc_common",
         "../../rtc_base:protobuf_utils",
         "../../rtc_base:rtc_base_approved",
+        "../../rtc_base/system:arch",
       ]
     }
   }
diff --git a/modules/audio_processing/aec/BUILD.gn b/modules/audio_processing/aec/BUILD.gn
index 5a858f5..52441d7 100644
--- a/modules/audio_processing/aec/BUILD.gn
+++ b/modules/audio_processing/aec/BUILD.gn
@@ -19,7 +19,6 @@
   deps = [
     ":aec_core",
     "..:apm_logging",
-    "../../..:typedefs",
     "../../../common_audio:common_audio_c",
     "../../../rtc_base:checks",
     "../../../rtc_base:rtc_base_approved",
@@ -36,10 +35,10 @@
   ]
   deps = [
     "..:apm_logging",
-    "../../..:typedefs",
     "../../../common_audio:common_audio_c",
     "../../../rtc_base:checks",
     "../../../rtc_base:rtc_base_approved",
+    "../../../rtc_base/system:arch",
     "../../../system_wrappers:cpu_features_api",
     "../../../system_wrappers:metrics_api",
     "../utility:block_mean_calculator",
@@ -59,9 +58,7 @@
     sources += [ "aec_core_neon.cc" ]
 
     if (current_cpu != "arm64") {
-      # Enable compilation for the NEON instruction set. This is needed
-      # since //build/config/arm.gni only enables NEON for iOS, not Android.
-      # This provides the same functionality as webrtc/build/arm_neon.gypi.
+      # Enable compilation for the NEON instruction set.
       suppressed_configs += [ "//build/config/compiler:compiler_arm_fpu" ]
       cflags += [ "-mfpu=neon" ]
     }
@@ -94,7 +91,6 @@
     deps = [
       ":aec",
       ":aec_core",
-      "../../..:typedefs",
       "../../../rtc_base:checks",
       "../../../rtc_base:rtc_base_approved",
       "../../../test:test_support",
diff --git a/modules/audio_processing/aec/aec_common.h b/modules/audio_processing/aec/aec_common.h
index 80c5c14..ac1f339 100644
--- a/modules/audio_processing/aec/aec_common.h
+++ b/modules/audio_processing/aec/aec_common.h
@@ -11,8 +11,6 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC_AEC_COMMON_H_
 #define MODULES_AUDIO_PROCESSING_AEC_AEC_COMMON_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
-
 #ifdef _MSC_VER /* visual c++ */
 #define ALIGN16_BEG __declspec(align(16))
 #define ALIGN16_END
diff --git a/modules/audio_processing/aec/aec_core.cc b/modules/audio_processing/aec/aec_core.cc
index 95ed595..5a8cf8f 100644
--- a/modules/audio_processing/aec/aec_core.cc
+++ b/modules/audio_processing/aec/aec_core.cc
@@ -30,9 +30,9 @@
 #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"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 namespace {
diff --git a/modules/audio_processing/aec/aec_core.h b/modules/audio_processing/aec/aec_core.h
index 9e25292..35a6c9b 100644
--- a/modules/audio_processing/aec/aec_core.h
+++ b/modules/audio_processing/aec/aec_core.h
@@ -26,7 +26,6 @@
 #include "modules/audio_processing/utility/block_mean_calculator.h"
 #include "modules/audio_processing/utility/ooura_fft.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/aec/aec_core_optimized_methods.h b/modules/audio_processing/aec/aec_core_optimized_methods.h
index a8a20e9..03c027d 100644
--- a/modules/audio_processing/aec/aec_core_optimized_methods.h
+++ b/modules/audio_processing/aec/aec_core_optimized_methods.h
@@ -14,7 +14,6 @@
 #include <memory>
 
 #include "modules/audio_processing/aec/aec_core.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/aec/echo_cancellation.cc b/modules/audio_processing/aec/echo_cancellation.cc
index c8382ec..fd1aec4 100644
--- a/modules/audio_processing/aec/echo_cancellation.cc
+++ b/modules/audio_processing/aec/echo_cancellation.cc
@@ -24,7 +24,6 @@
 #include "modules/audio_processing/aec/aec_core.h"
 #include "modules/audio_processing/aec/aec_resampler.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/aec/echo_cancellation.h b/modules/audio_processing/aec/echo_cancellation.h
index d5c703e..2039347 100644
--- a/modules/audio_processing/aec/echo_cancellation.h
+++ b/modules/audio_processing/aec/echo_cancellation.h
@@ -19,7 +19,6 @@
 #include "common_audio/ring_buffer.h"
 }
 #include "modules/audio_processing/aec/aec_core.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/aec/system_delay_unittest.cc b/modules/audio_processing/aec/system_delay_unittest.cc
index 01119db..9c57e8b 100644
--- a/modules/audio_processing/aec/system_delay_unittest.cc
+++ b/modules/audio_processing/aec/system_delay_unittest.cc
@@ -12,7 +12,6 @@
 #include "modules/audio_processing/aec/echo_cancellation.h"
 #include "rtc_base/numerics/safe_conversions.h"
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 namespace webrtc {
 namespace {
 
diff --git a/modules/audio_processing/aec3/BUILD.gn b/modules/audio_processing/aec3/BUILD.gn
index f27168d..75ee372 100644
--- a/modules/audio_processing/aec3/BUILD.gn
+++ b/modules/audio_processing/aec3/BUILD.gn
@@ -20,6 +20,8 @@
     "aec3_fft.h",
     "aec_state.cc",
     "aec_state.h",
+    "block_delay_buffer.cc",
+    "block_delay_buffer.h",
     "block_framer.cc",
     "block_framer.h",
     "block_processor.cc",
@@ -28,8 +30,6 @@
     "block_processor_metrics.h",
     "cascaded_biquad_filter.cc",
     "cascaded_biquad_filter.h",
-    "coherence_gain.cc",
-    "coherence_gain.h",
     "comfort_noise_generator.cc",
     "comfort_noise_generator.h",
     "decimator.cc",
@@ -82,6 +82,10 @@
     "render_signal_analyzer.h",
     "residual_echo_estimator.cc",
     "residual_echo_estimator.h",
+    "reverb_decay_estimator.cc",
+    "reverb_decay_estimator.h",
+    "reverb_frequency_response.cc",
+    "reverb_frequency_response.h",
     "reverb_model.cc",
     "reverb_model.h",
     "reverb_model_estimator.cc",
@@ -112,10 +116,14 @@
   ]
 
   defines = []
+  if (rtc_build_with_neon && current_cpu != "arm64") {
+    suppressed_configs += [ "//build/config/compiler:compiler_arm_fpu" ]
+    cflags = [ "-mfpu=neon" ]
+  }
+
   deps = [
     "..:apm_logging",
     "..:audio_processing",
-    "../../..:typedefs",
     "../../../api:array_view",
     "../../../api/audio:aec3_config",
     "../../../api/audio:echo_control",
@@ -123,6 +131,7 @@
     "../../../rtc_base:checks",
     "../../../rtc_base:rtc_base_approved",
     "../../../rtc_base:safe_minmax",
+    "../../../rtc_base/system:arch",
     "../../../system_wrappers:cpu_features_api",
     "../../../system_wrappers:field_trial_api",
     "../../../system_wrappers:metrics_api",
@@ -152,12 +161,12 @@
       "..:apm_logging",
       "..:audio_processing",
       "..:audio_processing_unittests",
-      "../../..:typedefs",
       "../../../api:array_view",
       "../../../api/audio:aec3_config",
       "../../../rtc_base:checks",
       "../../../rtc_base:rtc_base_approved",
       "../../../rtc_base:safe_minmax",
+      "../../../rtc_base/system:arch",
       "../../../system_wrappers:cpu_features_api",
       "../../../test:test_support",
       "//third_party/abseil-cpp/absl/types:optional",
@@ -170,6 +179,7 @@
         "adaptive_fir_filter_unittest.cc",
         "aec3_fft_unittest.cc",
         "aec_state_unittest.cc",
+        "block_delay_buffer_unittest.cc",
         "block_framer_unittest.cc",
         "block_processor_metrics_unittest.cc",
         "block_processor_unittest.cc",
diff --git a/modules/audio_processing/aec3/adaptive_fir_filter.cc b/modules/audio_processing/aec3/adaptive_fir_filter.cc
index 377436c..9a1e811 100644
--- a/modules/audio_processing/aec3/adaptive_fir_filter.cc
+++ b/modules/audio_processing/aec3/adaptive_fir_filter.cc
@@ -10,10 +10,12 @@
 
 #include "modules/audio_processing/aec3/adaptive_fir_filter.h"
 
+// Defines WEBRTC_ARCH_X86_FAMILY, used below.
+#include "rtc_base/system/arch.h"
+
 #if defined(WEBRTC_HAS_NEON)
 #include <arm_neon.h>
 #endif
-#include "typedefs.h"  // NOLINT(build/include)
 #if defined(WEBRTC_ARCH_X86_FAMILY)
 #include <emmintrin.h>
 #endif
diff --git a/modules/audio_processing/aec3/adaptive_fir_filter.h b/modules/audio_processing/aec3/adaptive_fir_filter.h
index 9b6ca90..5dfb466 100644
--- a/modules/audio_processing/aec3/adaptive_fir_filter.h
+++ b/modules/audio_processing/aec3/adaptive_fir_filter.h
@@ -22,6 +22,7 @@
 #include "modules/audio_processing/aec3/render_buffer.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/constructormagic.h"
+#include "rtc_base/system/arch.h"
 
 namespace webrtc {
 namespace aec3 {
diff --git a/modules/audio_processing/aec3/adaptive_fir_filter_unittest.cc b/modules/audio_processing/aec3/adaptive_fir_filter_unittest.cc
index 6c441f3..077586e 100644
--- a/modules/audio_processing/aec3/adaptive_fir_filter_unittest.cc
+++ b/modules/audio_processing/aec3/adaptive_fir_filter_unittest.cc
@@ -10,11 +10,13 @@
 
 #include "modules/audio_processing/aec3/adaptive_fir_filter.h"
 
+// Defines WEBRTC_ARCH_X86_FAMILY, used below.
+#include "rtc_base/system/arch.h"
+
 #include <math.h>
 #include <algorithm>
 #include <numeric>
 #include <string>
-#include "typedefs.h"  // NOLINT(build/include)
 #if defined(WEBRTC_ARCH_X86_FAMILY)
 #include <emmintrin.h>
 #endif
diff --git a/modules/audio_processing/aec3/aec3_common.cc b/modules/audio_processing/aec3/aec3_common.cc
index 3e60b46..c374a35 100644
--- a/modules/audio_processing/aec3/aec3_common.cc
+++ b/modules/audio_processing/aec3/aec3_common.cc
@@ -11,9 +11,9 @@
 #include "modules/audio_processing/aec3/aec3_common.h"
 
 #include "system_wrappers/include/cpu_features_wrapper.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 #include "rtc_base/checks.h"
+#include "rtc_base/system/arch.h"
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/aec3/aec3_common.h b/modules/audio_processing/aec3/aec3_common.h
index 6422a52..56c7a90 100644
--- a/modules/audio_processing/aec3/aec3_common.h
+++ b/modules/audio_processing/aec3/aec3_common.h
@@ -12,7 +12,6 @@
 #define MODULES_AUDIO_PROCESSING_AEC3_AEC3_COMMON_H_
 
 #include <stddef.h>
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
@@ -37,6 +36,7 @@
 constexpr size_t kFftLengthBy2Plus1 = kFftLengthBy2 + 1;
 constexpr size_t kFftLengthBy2Minus1 = kFftLengthBy2 - 1;
 constexpr size_t kFftLength = 2 * kFftLengthBy2;
+constexpr size_t kFftLengthBy2Log2 = 6;
 
 constexpr int kMaxAdaptiveFilterLength = 50;
 constexpr int kRenderTransferQueueSizeFrames = 100;
@@ -45,7 +45,7 @@
 constexpr size_t kSubFrameLength = 80;
 
 constexpr size_t kBlockSize = kFftLengthBy2;
-constexpr size_t kBlockSizeLog2 = 6;
+constexpr size_t kBlockSizeLog2 = kFftLengthBy2Log2;
 
 constexpr size_t kExtendedBlockSize = 2 * kFftLengthBy2;
 constexpr size_t kMatchedFilterWindowSizeSubBlocks = 32;
@@ -97,6 +97,9 @@
 static_assert(1 << kBlockSizeLog2 == kBlockSize,
               "Proper number of shifts for blocksize");
 
+static_assert(1 << kFftLengthBy2Log2 == kFftLengthBy2,
+              "Proper number of shifts for the fft length");
+
 static_assert(1 == NumBandsForRate(8000), "Number of bands for 8 kHz");
 static_assert(1 == NumBandsForRate(16000), "Number of bands for 16 kHz");
 static_assert(2 == NumBandsForRate(32000), "Number of bands for 32 kHz");
diff --git a/modules/audio_processing/aec3/aec_state.cc b/modules/audio_processing/aec3/aec_state.cc
index d470611..62232ac 100644
--- a/modules/audio_processing/aec3/aec_state.cc
+++ b/modules/audio_processing/aec3/aec_state.cc
@@ -40,11 +40,6 @@
       "WebRTC-Aec3EnforceDelayAfterRealignmentKillSwitch");
 }
 
-bool EnableLinearModeWithDivergedFilter() {
-  return !field_trial::IsEnabled(
-      "WebRTC-Aec3LinearModeWithDivergedFilterKillSwitch");
-}
-
 bool EnableEarlyFilterUsage() {
   return !field_trial::IsEnabled("WebRTC-Aec3EarlyLinearFilterUsageKillSwitch");
 }
@@ -53,25 +48,11 @@
   return !field_trial::IsEnabled("WebRTC-Aec3ShortInitialStateKillSwitch");
 }
 
-bool EnableNoWaitForAlignment() {
-  return !field_trial::IsEnabled("WebRTC-Aec3NoAlignmentWaitKillSwitch");
-}
-
-bool EnableConvergenceTriggeredLinearMode() {
-  return !field_trial::IsEnabled(
-      "WebRTC-Aec3ConvergenceTriggingLinearKillSwitch");
-}
-
 bool EnableUncertaintyUntilSufficientAdapted() {
   return !field_trial::IsEnabled(
       "WebRTC-Aec3ErleUncertaintyUntilSufficientlyAdaptedKillSwitch");
 }
 
-bool TreatTransparentModeAsNonlinear() {
-  return !field_trial::IsEnabled(
-      "WebRTC-Aec3TreatTransparentModeAsNonlinearKillSwitch");
-}
-
 bool LowUncertaintyBeforeConvergence() {
   return !field_trial::IsEnabled(
       "WebRTC-Aec3LowUncertaintyBeforeConvergenceKillSwitch");
@@ -87,16 +68,16 @@
       "WebRTC-Aec3EarlyEntryToConvergedModeKillSwitch");
 }
 
-bool ConservativeFilterDivergence() {
-  return !field_trial::IsEnabled(
-      "WebRTC-Aec3ConservativeFilterDivergenceKillSwitch");
-}
-
 bool UseEarlyLimiterDeactivation() {
   return !field_trial::IsEnabled(
       "WebRTC-Aec3EarlyLimiterDeactivationKillSwitch");
 }
 
+bool ResetErleAfterEchoPathChanges() {
+  return !field_trial::IsEnabled(
+      "WebRTC-Aec3ResetErleAfterEchoPathChangesKillSwitch");
+}
+
 float UncertaintyBeforeConvergence() {
   if (LowUncertaintyBeforeConvergence()) {
     return 1.f;
@@ -128,20 +109,20 @@
           EnableStationaryRenderImprovements() &&
           config_.echo_audibility.use_stationary_properties),
       enforce_delay_after_realignment_(EnableEnforcingDelayAfterRealignment()),
-      allow_linear_mode_with_diverged_filter_(
-          EnableLinearModeWithDivergedFilter()),
-      early_filter_usage_activated_(EnableEarlyFilterUsage()),
-      use_short_initial_state_(EnableShortInitialState()),
-      convergence_trigger_linear_mode_(EnableConvergenceTriggeredLinearMode()),
-      no_alignment_required_for_linear_mode_(EnableNoWaitForAlignment()),
+      early_filter_usage_activated_(EnableEarlyFilterUsage() &&
+                                    !config.filter.conservative_initial_phase),
+      use_short_initial_state_(EnableShortInitialState() &&
+                               !config.filter.conservative_initial_phase),
+      convergence_trigger_linear_mode_(
+          !config.filter.conservative_initial_phase),
+      no_alignment_required_for_linear_mode_(
+          !config.filter.conservative_initial_phase),
       use_uncertainty_until_sufficiently_adapted_(
           EnableUncertaintyUntilSufficientAdapted()),
-      transparent_mode_enforces_nonlinear_mode_(
-          TreatTransparentModeAsNonlinear()),
       uncertainty_before_convergence_(UncertaintyBeforeConvergence()),
       early_entry_to_converged_mode_(EarlyEntryToConvergedMode()),
-      conservative_filter_divergence_(ConservativeFilterDivergence()),
       early_limiter_deactivation_(UseEarlyLimiterDeactivation()),
+      reset_erle_after_echo_path_changes_(ResetErleAfterEchoPathChanges()),
       erle_estimator_(config.erle.min, config.erle.max_l, config.erle.max_h),
       max_render_(config_.filter.main.length_blocks, 0.f),
       gain_rampup_increase_(ComputeGainRampupIncrease(config_)),
@@ -160,7 +141,6 @@
     filter_analyzer_.Reset();
     blocks_since_last_saturation_ = 0;
     usable_linear_estimate_ = false;
-    diverged_linear_filter_ = false;
     capture_signal_saturation_ = false;
     echo_saturation_ = false;
     std::fill(max_render_.begin(), max_render_.end(), 0.f);
@@ -173,6 +153,9 @@
     suppression_gain_limiter_.Reset();
     blocks_since_converged_filter_ = kBlocksSinceConvergencedFilterInit;
     diverged_blocks_ = 0;
+    if (reset_erle_after_echo_path_changes_) {
+      erle_estimator_.Reset();
+    }
   };
 
   // TODO(peah): Refine the reset scheme according to the type of gain and
@@ -252,9 +235,13 @@
   }
 
   // Update the ERL and ERLE measures.
+  if (reset_erle_after_echo_path_changes_ && transition_triggered_) {
+    erle_estimator_.Reset();
+  }
   if (blocks_since_reset_ >= 2 * kNumBlocksPerSecond) {
     const auto& X2 = render_buffer.Spectrum(filter_delay_blocks_);
-    erle_estimator_.Update(X2, Y2, E2_main, converged_filter);
+    erle_estimator_.Update(X2, Y2, E2_main, converged_filter,
+                           config_.erle.onset_detection);
     if (converged_filter) {
       erl_estimator_.Update(X2, Y2);
     }
@@ -283,13 +270,15 @@
   }
 
   // Flag whether the initial state is still active.
+  bool prev_initial_state = initial_state_;
   if (use_short_initial_state_) {
-    initial_state_ =
-        blocks_with_proper_filter_adaptation_ < 2.5f * kNumBlocksPerSecond;
+    initial_state_ = blocks_with_proper_filter_adaptation_ <
+                     config_.filter.initial_state_seconds * kNumBlocksPerSecond;
   } else {
     initial_state_ =
         blocks_with_proper_filter_adaptation_ < 5 * kNumBlocksPerSecond;
   }
+  transition_triggered_ = !initial_state_ && prev_initial_state;
 
   // Update counters for the filter divergence and convergence.
   diverged_blocks_ = diverged_filter ? diverged_blocks_ + 1 : 0;
@@ -372,32 +361,21 @@
   if (!config_.echo_removal_control.linear_and_stable_echo_path) {
     usable_linear_estimate_ =
         usable_linear_estimate_ && recently_converged_filter;
-    if (!allow_linear_mode_with_diverged_filter_) {
-      usable_linear_estimate_ = usable_linear_estimate_ && !diverged_filter;
-    }
   }
-  if (transparent_mode_enforces_nonlinear_mode_) {
-    usable_linear_estimate_ = usable_linear_estimate_ && !TransparentMode();
-  }
+  usable_linear_estimate_ = usable_linear_estimate_ && !TransparentMode();
 
   use_linear_filter_output_ = usable_linear_estimate_ && !TransparentMode();
 
-  if (conservative_filter_divergence_) {
-    diverged_linear_filter_ =
-        subtractor_output_analyzer_.SeverelyDivergedFilter() &&
-        active_render_block;
-  } else {
-    diverged_linear_filter_ = diverged_filter;
-  }
+  const bool stationary_block =
+      use_stationary_properties_ && echo_audibility_.IsBlockStationary();
 
   reverb_model_estimator_.Update(
-      adaptive_filter_impulse_response, adaptive_filter_frequency_response,
+      filter_analyzer_.GetAdjustedFilter(), adaptive_filter_frequency_response,
       erle_estimator_.GetInstLinearQualityEstimate(), filter_delay_blocks_,
-      usable_linear_estimate_, config_.ep_strength.default_len,
-      IsBlockStationary());
+      usable_linear_estimate_, stationary_block);
 
   erle_estimator_.Dump(data_dumper_);
-  reverb_model_estimator_.Dump(data_dumper_);
+  reverb_model_estimator_.Dump(data_dumper_.get());
   data_dumper_->DumpRaw("aec3_erl", Erl());
   data_dumper_->DumpRaw("aec3_erl_time_domain", ErlTimeDomain());
   data_dumper_->DumpRaw("aec3_usable_linear_estimate", UsableLinearEstimate());
@@ -409,7 +387,7 @@
   data_dumper_->DumpRaw("aec3_consistent_filter",
                         filter_analyzer_.Consistent());
   data_dumper_->DumpRaw("aec3_suppression_gain_limit", SuppressionGainLimit());
-  data_dumper_->DumpRaw("aec3_initial_state", InitialState());
+  data_dumper_->DumpRaw("aec3_initial_state", initial_state_);
   data_dumper_->DumpRaw("aec3_capture_saturation", SaturatedCapture());
   data_dumper_->DumpRaw("aec3_echo_saturation", echo_saturation_);
   data_dumper_->DumpRaw("aec3_converged_filter", converged_filter);
@@ -427,8 +405,8 @@
                         recently_converged_filter);
   data_dumper_->DumpRaw("aec3_suppresion_gain_limiter_running",
                         IsSuppressionGainLimitActive());
-  data_dumper_->DumpRaw("aec3_filter_tail_freq_resp_est", GetFreqRespTail());
-
+  data_dumper_->DumpRaw("aec3_filter_tail_freq_resp_est",
+                        GetReverbFrequencyResponse());
 }
 
 bool AecState::DetectActiveRender(rtc::ArrayView<const float> x) const {
diff --git a/modules/audio_processing/aec3/aec_state.h b/modules/audio_processing/aec3/aec_state.h
index 408f9b8..ea30daf 100644
--- a/modules/audio_processing/aec3/aec_state.h
+++ b/modules/audio_processing/aec3/aec_state.h
@@ -67,17 +67,6 @@
   // aec.
   bool UseStationaryProperties() const { return use_stationary_properties_; }
 
-  // Returns true if the current render block is estimated as stationary.
-  bool IsBlockStationary() const {
-    if (UseStationaryProperties()) {
-      return echo_audibility_.IsBlockStationary();
-    } else {
-      // Assume that a non stationary block when the use of
-      // stationary properties are not enabled.
-      return false;
-    }
-  }
-
   // Returns the ERLE.
   const std::array<float, kFftLengthBy2Plus1>& Erle() const {
     return erle_estimator_.Erle();
@@ -85,10 +74,6 @@
 
   // Returns any uncertainty in the ERLE estimate.
   absl::optional<float> ErleUncertainty() const {
-    if (allow_linear_mode_with_diverged_filter_ && diverged_linear_filter_) {
-      return 10.f;
-    }
-
     if (!filter_has_had_time_to_converge_ &&
         use_uncertainty_until_sufficiently_adapted_) {
       return uncertainty_before_convergence_;
@@ -135,6 +120,11 @@
   // Returns the decay factor for the echo reverberation.
   float ReverbDecay() const { return reverb_model_estimator_.ReverbDecay(); }
 
+  // Return the frequency response of the reverberant echo.
+  rtc::ArrayView<const float> GetReverbFrequencyResponse() const {
+    return reverb_model_estimator_.GetReverbFrequencyResponse();
+  }
+
   // Returns the upper limit for the echo suppression gain.
   float SuppressionGainLimit() const {
     return suppression_gain_limiter_.Limit();
@@ -150,8 +140,9 @@
     return filter_has_had_time_to_converge_;
   }
 
-  // Returns whether the filter adaptation is still in the initial state.
-  bool InitialState() const { return initial_state_; }
+  // Returns whether the transition for going out of the initial stated has
+  // been triggered.
+  bool TransitionTriggered() const { return transition_triggered_; }
 
   // Updates the aec state.
   void Update(const absl::optional<DelayEstimate>& external_delay,
@@ -164,11 +155,6 @@
               const SubtractorOutput& subtractor_output,
               rtc::ArrayView<const float> y);
 
-  // Returns the tail freq. response of the linear filter.
-  rtc::ArrayView<const float> GetFreqRespTail() const {
-    return reverb_model_estimator_.GetFreqRespTail();
-  }
-
   // Returns filter length in blocks.
   int FilterLengthBlocks() const {
     return filter_analyzer_.FilterLengthBlocks();
@@ -186,17 +172,15 @@
   const bool allow_transparent_mode_;
   const bool use_stationary_properties_;
   const bool enforce_delay_after_realignment_;
-  const bool allow_linear_mode_with_diverged_filter_;
   const bool early_filter_usage_activated_;
   const bool use_short_initial_state_;
   const bool convergence_trigger_linear_mode_;
   const bool no_alignment_required_for_linear_mode_;
   const bool use_uncertainty_until_sufficiently_adapted_;
-  const bool transparent_mode_enforces_nonlinear_mode_;
   const float uncertainty_before_convergence_;
   const bool early_entry_to_converged_mode_;
-  const bool conservative_filter_divergence_;
   const bool early_limiter_deactivation_;
+  const bool reset_erle_after_echo_path_changes_;
   ErlEstimator erl_estimator_;
   ErleEstimator erle_estimator_;
   size_t capture_block_counter_ = 0;
@@ -204,7 +188,6 @@
   size_t blocks_with_proper_filter_adaptation_ = 0;
   size_t blocks_with_active_render_ = 0;
   bool usable_linear_estimate_ = false;
-  bool diverged_linear_filter_ = false;
   bool capture_signal_saturation_ = false;
   bool echo_saturation_ = false;
   bool transparent_mode_ = false;
@@ -215,6 +198,7 @@
   std::vector<float> max_render_;
   bool filter_has_had_time_to_converge_ = false;
   bool initial_state_ = true;
+  bool transition_triggered_ = false;
   const float gain_rampup_increase_;
   SuppressionGainUpperLimiter suppression_gain_limiter_;
   FilterAnalyzer filter_analyzer_;
diff --git a/modules/audio_processing/aec3/block_delay_buffer.cc b/modules/audio_processing/aec3/block_delay_buffer.cc
new file mode 100644
index 0000000..0a242ee
--- /dev/null
+++ b/modules/audio_processing/aec3/block_delay_buffer.cc
@@ -0,0 +1,47 @@
+/*
+ *  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/block_delay_buffer.h"
+
+#include "rtc_base/checks.h"
+
+namespace webrtc {
+
+BlockDelayBuffer::BlockDelayBuffer(size_t num_bands,
+                                   size_t frame_length,
+                                   size_t delay_samples)
+    : frame_length_(frame_length),
+      delay_(delay_samples),
+      buf_(num_bands, std::vector<float>(delay_, 0.f)) {}
+
+BlockDelayBuffer::~BlockDelayBuffer() = default;
+
+void BlockDelayBuffer::DelaySignal(AudioBuffer* frame) {
+  RTC_DCHECK_EQ(1, frame->num_channels());
+  RTC_DCHECK_EQ(buf_.size(), frame->num_bands());
+  if (delay_ == 0) {
+    return;
+  }
+
+  const size_t i_start = last_insert_;
+  size_t i = 0;
+  for (size_t j = 0; j < buf_.size(); ++j) {
+    i = i_start;
+    for (size_t k = 0; k < frame_length_; ++k) {
+      const float tmp = buf_[j][i];
+      buf_[j][i] = frame->split_bands_f(0)[j][k];
+      frame->split_bands_f(0)[j][k] = tmp;
+      i = i < buf_[0].size() - 1 ? i + 1 : 0;
+    }
+  }
+
+  last_insert_ = i;
+}
+
+}  // namespace webrtc
diff --git a/modules/audio_processing/aec3/block_delay_buffer.h b/modules/audio_processing/aec3/block_delay_buffer.h
new file mode 100644
index 0000000..6e5fd5c
--- /dev/null
+++ b/modules/audio_processing/aec3/block_delay_buffer.h
@@ -0,0 +1,38 @@
+/*
+ *  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_BLOCK_DELAY_BUFFER_H_
+#define MODULES_AUDIO_PROCESSING_AEC3_BLOCK_DELAY_BUFFER_H_
+
+#include <vector>
+
+#include "modules/audio_processing/audio_buffer.h"
+
+namespace webrtc {
+
+// Class for applying a fixed delay to the samples in a signal partitioned using
+// the audiobuffer band-splitting scheme.
+class BlockDelayBuffer {
+ public:
+  BlockDelayBuffer(size_t num_bands, size_t frame_length, size_t delay_samples);
+  ~BlockDelayBuffer();
+
+  // Delays the samples by the specified delay.
+  void DelaySignal(AudioBuffer* frame);
+
+ private:
+  const size_t frame_length_;
+  const size_t delay_;
+  std::vector<std::vector<float>> buf_;
+  size_t last_insert_ = 0;
+};
+}  // namespace webrtc
+
+#endif  // MODULES_AUDIO_PROCESSING_AEC3_BLOCK_DELAY_BUFFER_H_
diff --git a/modules/audio_processing/aec3/block_delay_buffer_unittest.cc b/modules/audio_processing/aec3/block_delay_buffer_unittest.cc
new file mode 100644
index 0000000..778d43d
--- /dev/null
+++ b/modules/audio_processing/aec3/block_delay_buffer_unittest.cc
@@ -0,0 +1,91 @@
+/*
+ *  Copyright (c) 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 "modules/audio_processing/aec3/block_delay_buffer.h"
+
+#include <string>
+
+#include "modules/audio_processing/aec3/aec3_common.h"
+#include "modules/audio_processing/audio_buffer.h"
+#include "rtc_base/strings/string_builder.h"
+#include "test/gtest.h"
+
+namespace webrtc {
+
+namespace {
+
+float SampleValue(size_t sample_index) {
+  return sample_index % 32768;
+}
+
+// Populates the frame with linearly increasing sample values for each band.
+void PopulateInputFrame(size_t frame_length,
+                        size_t num_bands,
+                        size_t first_sample_index,
+                        float* const* frame) {
+  for (size_t k = 0; k < num_bands; ++k) {
+    for (size_t i = 0; i < frame_length; ++i) {
+      frame[k][i] = SampleValue(first_sample_index + i);
+    }
+  }
+}
+
+std::string ProduceDebugText(int sample_rate_hz, size_t delay) {
+  char log_stream_buffer[8 * 1024];
+  rtc::SimpleStringBuilder ss(log_stream_buffer);
+  ss << "Sample rate: " << sample_rate_hz;
+  ss << ", Delay: " << delay;
+  return ss.str();
+}
+
+}  // namespace
+
+// Verifies that the correct signal delay is achived.
+TEST(BlockDelayBuffer, CorrectDelayApplied) {
+  for (size_t delay : {0, 1, 27, 160, 4321, 7021}) {
+    for (auto rate : {8000, 16000, 32000, 48000}) {
+      SCOPED_TRACE(ProduceDebugText(rate, delay));
+      size_t num_bands = NumBandsForRate(rate);
+      size_t fullband_frame_length = rate / 100;
+      size_t subband_frame_length = rate == 8000 ? 80 : 160;
+
+      BlockDelayBuffer delay_buffer(num_bands, subband_frame_length, delay);
+
+      static constexpr size_t kNumFramesToProcess = 20;
+      for (size_t frame_index = 0; frame_index < kNumFramesToProcess;
+           ++frame_index) {
+        AudioBuffer audio_buffer(fullband_frame_length, 1,
+                                 fullband_frame_length, 1,
+                                 fullband_frame_length);
+        if (rate > 16000) {
+          audio_buffer.SplitIntoFrequencyBands();
+        }
+        size_t first_sample_index = frame_index * subband_frame_length;
+        PopulateInputFrame(subband_frame_length, num_bands, first_sample_index,
+                           &audio_buffer.split_bands_f(0)[0]);
+        delay_buffer.DelaySignal(&audio_buffer);
+
+        for (size_t k = 0; k < num_bands; ++k) {
+          size_t sample_index = first_sample_index;
+          for (size_t i = 0; i < subband_frame_length; ++i, ++sample_index) {
+            if (sample_index < delay) {
+              EXPECT_EQ(0.f, audio_buffer.split_bands_f(0)[k][i]);
+            } else {
+              EXPECT_EQ(SampleValue(sample_index - delay),
+                        audio_buffer.split_bands_f(0)[k][i]);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+}  // namespace webrtc
diff --git a/modules/audio_processing/aec3/coherence_gain.cc b/modules/audio_processing/aec3/coherence_gain.cc
deleted file mode 100644
index ad33382..0000000
--- a/modules/audio_processing/aec3/coherence_gain.cc
+++ /dev/null
@@ -1,257 +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/aec3/coherence_gain.h"
-
-#include <math.h>
-
-#include <algorithm>
-
-#include "rtc_base/checks.h"
-
-namespace webrtc {
-
-namespace {
-
-// Matlab code to produce table:
-// overDriveCurve = [sqrt(linspace(0,1,65))' + 1];
-// fprintf(1, '\t%.4f, %.4f, %.4f, %.4f, %.4f, %.4f,\n', overDriveCurve);
-const float kOverDriveCurve[kFftLengthBy2Plus1] = {
-    1.0000f, 1.1250f, 1.1768f, 1.2165f, 1.2500f, 1.2795f, 1.3062f, 1.3307f,
-    1.3536f, 1.3750f, 1.3953f, 1.4146f, 1.4330f, 1.4507f, 1.4677f, 1.4841f,
-    1.5000f, 1.5154f, 1.5303f, 1.5449f, 1.5590f, 1.5728f, 1.5863f, 1.5995f,
-    1.6124f, 1.6250f, 1.6374f, 1.6495f, 1.6614f, 1.6731f, 1.6847f, 1.6960f,
-    1.7071f, 1.7181f, 1.7289f, 1.7395f, 1.7500f, 1.7603f, 1.7706f, 1.7806f,
-    1.7906f, 1.8004f, 1.8101f, 1.8197f, 1.8292f, 1.8385f, 1.8478f, 1.8570f,
-    1.8660f, 1.8750f, 1.8839f, 1.8927f, 1.9014f, 1.9100f, 1.9186f, 1.9270f,
-    1.9354f, 1.9437f, 1.9520f, 1.9601f, 1.9682f, 1.9763f, 1.9843f, 1.9922f,
-    2.0000f};
-
-// Matlab code to produce table:
-// weightCurve = [0 ; 0.3 * sqrt(linspace(0,1,64))' + 0.1];
-// fprintf(1, '\t%.4f, %.4f, %.4f, %.4f, %.4f, %.4f,\n', weightCurve);
-const float kWeightCurve[kFftLengthBy2Plus1] = {
-    0.0000f, 0.1000f, 0.1378f, 0.1535f, 0.1655f, 0.1756f, 0.1845f, 0.1926f,
-    0.2000f, 0.2069f, 0.2134f, 0.2195f, 0.2254f, 0.2309f, 0.2363f, 0.2414f,
-    0.2464f, 0.2512f, 0.2558f, 0.2604f, 0.2648f, 0.2690f, 0.2732f, 0.2773f,
-    0.2813f, 0.2852f, 0.2890f, 0.2927f, 0.2964f, 0.3000f, 0.3035f, 0.3070f,
-    0.3104f, 0.3138f, 0.3171f, 0.3204f, 0.3236f, 0.3268f, 0.3299f, 0.3330f,
-    0.3360f, 0.3390f, 0.3420f, 0.3449f, 0.3478f, 0.3507f, 0.3535f, 0.3563f,
-    0.3591f, 0.3619f, 0.3646f, 0.3673f, 0.3699f, 0.3726f, 0.3752f, 0.3777f,
-    0.3803f, 0.3828f, 0.3854f, 0.3878f, 0.3903f, 0.3928f, 0.3952f, 0.3976f,
-    0.4000f};
-
-int CmpFloat(const void* a, const void* b) {
-  const float* da = static_cast<const float*>(a);
-  const float* db = static_cast<const float*>(b);
-  return (*da > *db) - (*da < *db);
-}
-
-}  // namespace
-
-CoherenceGain::CoherenceGain(int sample_rate_hz, size_t num_bands_to_compute)
-    : num_bands_to_compute_(num_bands_to_compute),
-      sample_rate_scaler_(sample_rate_hz >= 16000 ? 2 : 1) {
-  spectra_.Cye.Clear();
-  spectra_.Cxy.Clear();
-  spectra_.Pe.fill(0.f);
-  // Initialize to 1 in order to prevent numerical instability in the first
-  // block.
-  spectra_.Py.fill(1.f);
-  spectra_.Px.fill(1.f);
-}
-
-CoherenceGain::~CoherenceGain() = default;
-
-void CoherenceGain::ComputeGain(const FftData& E,
-                                const FftData& X,
-                                const FftData& Y,
-                                rtc::ArrayView<float> gain) {
-  std::array<float, kFftLengthBy2Plus1> coherence_ye;
-  std::array<float, kFftLengthBy2Plus1> coherence_xy;
-
-  UpdateCoherenceSpectra(E, X, Y);
-  ComputeCoherence(coherence_ye, coherence_xy);
-  FormSuppressionGain(coherence_ye, coherence_xy, gain);
-}
-
-// Updates the following smoothed Power Spectral Densities (PSD):
-//  - sd  : near-end
-//  - se  : residual echo
-//  - sx  : far-end
-//  - sde : cross-PSD of near-end and residual echo
-//  - sxd : cross-PSD of near-end and far-end
-//
-void CoherenceGain::UpdateCoherenceSpectra(const FftData& E,
-                                           const FftData& X,
-                                           const FftData& Y) {
-  const float s = sample_rate_scaler_ == 1 ? 0.9f : 0.92f;
-  const float one_minus_s = 1.f - s;
-  auto& c = spectra_;
-
-  for (size_t i = 0; i < c.Py.size(); i++) {
-    c.Py[i] =
-        s * c.Py[i] + one_minus_s * (Y.re[i] * Y.re[i] + Y.im[i] * Y.im[i]);
-    c.Pe[i] =
-        s * c.Pe[i] + one_minus_s * (E.re[i] * E.re[i] + E.im[i] * E.im[i]);
-    // We threshold here to protect against the ill-effects of a zero farend.
-    // The threshold is not arbitrarily chosen, but balances protection and
-    // adverse interaction with the algorithm's tuning.
-
-    // Threshold to protect against the ill-effects of a zero far-end.
-    c.Px[i] =
-        s * c.Px[i] +
-        one_minus_s * std::max(X.re[i] * X.re[i] + X.im[i] * X.im[i], 15.f);
-
-    c.Cye.re[i] =
-        s * c.Cye.re[i] + one_minus_s * (Y.re[i] * E.re[i] + Y.im[i] * E.im[i]);
-    c.Cye.im[i] =
-        s * c.Cye.im[i] + one_minus_s * (Y.re[i] * E.im[i] - Y.im[i] * E.re[i]);
-
-    c.Cxy.re[i] =
-        s * c.Cxy.re[i] + one_minus_s * (Y.re[i] * X.re[i] + Y.im[i] * X.im[i]);
-    c.Cxy.im[i] =
-        s * c.Cxy.im[i] + one_minus_s * (Y.re[i] * X.im[i] - Y.im[i] * X.re[i]);
-  }
-}
-
-void CoherenceGain::FormSuppressionGain(
-    rtc::ArrayView<const float> coherence_ye,
-    rtc::ArrayView<const float> coherence_xy,
-    rtc::ArrayView<float> gain) {
-  RTC_DCHECK_EQ(kFftLengthBy2Plus1, coherence_ye.size());
-  RTC_DCHECK_EQ(kFftLengthBy2Plus1, coherence_xy.size());
-  RTC_DCHECK_EQ(kFftLengthBy2Plus1, gain.size());
-  constexpr int kPrefBandSize = 24;
-  auto& gs = gain_state_;
-  std::array<float, kPrefBandSize> h_nl_pref;
-  float h_nl_fb = 0;
-  float h_nl_fb_low = 0;
-  const int pref_band_size = kPrefBandSize / sample_rate_scaler_;
-  const int min_pref_band = 4 / sample_rate_scaler_;
-
-  float h_nl_de_avg = 0.f;
-  float h_nl_xd_avg = 0.f;
-  for (int i = min_pref_band; i < pref_band_size + min_pref_band; ++i) {
-    h_nl_xd_avg += coherence_xy[i];
-    h_nl_de_avg += coherence_ye[i];
-  }
-  h_nl_xd_avg /= pref_band_size;
-  h_nl_xd_avg = 1 - h_nl_xd_avg;
-  h_nl_de_avg /= pref_band_size;
-
-  if (h_nl_xd_avg < 0.75f && h_nl_xd_avg < gs.h_nl_xd_avg_min) {
-    gs.h_nl_xd_avg_min = h_nl_xd_avg;
-  }
-
-  if (h_nl_de_avg > 0.98f && h_nl_xd_avg > 0.9f) {
-    gs.near_state = true;
-  } else if (h_nl_de_avg < 0.95f || h_nl_xd_avg < 0.8f) {
-    gs.near_state = false;
-  }
-
-  std::array<float, kFftLengthBy2Plus1> h_nl;
-  if (gs.h_nl_xd_avg_min == 1) {
-    gs.overdrive = 15.f;
-
-    if (gs.near_state) {
-      std::copy(coherence_ye.begin(), coherence_ye.end(), h_nl.begin());
-      h_nl_fb = h_nl_de_avg;
-      h_nl_fb_low = h_nl_de_avg;
-    } else {
-      for (size_t i = 0; i < h_nl.size(); ++i) {
-        h_nl[i] = 1 - coherence_xy[i];
-        h_nl[i] = std::max(h_nl[i], 0.f);
-      }
-      h_nl_fb = h_nl_xd_avg;
-      h_nl_fb_low = h_nl_xd_avg;
-    }
-  } else {
-    if (gs.near_state) {
-      std::copy(coherence_ye.begin(), coherence_ye.end(), h_nl.begin());
-      h_nl_fb = h_nl_de_avg;
-      h_nl_fb_low = h_nl_de_avg;
-    } else {
-      for (size_t i = 0; i < h_nl.size(); ++i) {
-        h_nl[i] = std::min(coherence_ye[i], 1 - coherence_xy[i]);
-        h_nl[i] = std::max(h_nl[i], 0.f);
-      }
-
-      // Select an order statistic from the preferred bands.
-      // TODO(peah): Using quicksort now, but a selection algorithm may be
-      // preferred.
-      std::copy(h_nl.begin() + min_pref_band,
-                h_nl.begin() + min_pref_band + pref_band_size,
-                h_nl_pref.begin());
-      std::qsort(h_nl_pref.data(), pref_band_size, sizeof(float), CmpFloat);
-
-      constexpr float kPrefBandQuant = 0.75f;
-      h_nl_fb = h_nl_pref[static_cast<int>(
-          floor(kPrefBandQuant * (pref_band_size - 1)))];
-      constexpr float kPrefBandQuantLow = 0.5f;
-      h_nl_fb_low = h_nl_pref[static_cast<int>(
-          floor(kPrefBandQuantLow * (pref_band_size - 1)))];
-    }
-  }
-
-  // Track the local filter minimum to determine suppression overdrive.
-  if (h_nl_fb_low < 0.6f && h_nl_fb_low < gs.h_nl_fb_local_min) {
-    gs.h_nl_fb_local_min = h_nl_fb_low;
-    gs.h_nl_fb_min = h_nl_fb_low;
-    gs.h_nl_new_min = 1;
-    gs.h_nl_min_ctr = 0;
-  }
-  gs.h_nl_fb_local_min =
-      std::min(gs.h_nl_fb_local_min + 0.0008f / sample_rate_scaler_, 1.f);
-  gs.h_nl_xd_avg_min =
-      std::min(gs.h_nl_xd_avg_min + 0.0006f / sample_rate_scaler_, 1.f);
-
-  if (gs.h_nl_new_min == 1) {
-    ++gs.h_nl_min_ctr;
-  }
-  if (gs.h_nl_min_ctr == 2) {
-    gs.h_nl_new_min = 0;
-    gs.h_nl_min_ctr = 0;
-    constexpr float epsilon = 1e-10f;
-    gs.overdrive = std::max(
-        -18.4f / static_cast<float>(log(gs.h_nl_fb_min + epsilon) + epsilon),
-        15.f);
-  }
-
-  // Smooth the overdrive.
-  if (gs.overdrive < gs.overdrive_scaling) {
-    gs.overdrive_scaling = 0.99f * gs.overdrive_scaling + 0.01f * gs.overdrive;
-  } else {
-    gs.overdrive_scaling = 0.9f * gs.overdrive_scaling + 0.1f * gs.overdrive;
-  }
-
-  // Apply the overdrive.
-  RTC_DCHECK_LE(num_bands_to_compute_, gain.size());
-  for (size_t i = 0; i < num_bands_to_compute_; ++i) {
-    if (h_nl[i] > h_nl_fb) {
-      h_nl[i] = kWeightCurve[i] * h_nl_fb + (1 - kWeightCurve[i]) * h_nl[i];
-    }
-    gain[i] = powf(h_nl[i], gs.overdrive_scaling * kOverDriveCurve[i]);
-  }
-}
-
-void CoherenceGain::ComputeCoherence(rtc::ArrayView<float> coherence_ye,
-                                     rtc::ArrayView<float> coherence_xy) const {
-  const auto& c = spectra_;
-  constexpr float epsilon = 1e-10f;
-  for (size_t i = 0; i < coherence_ye.size(); ++i) {
-    coherence_ye[i] = (c.Cye.re[i] * c.Cye.re[i] + c.Cye.im[i] * c.Cye.im[i]) /
-                      (c.Py[i] * c.Pe[i] + epsilon);
-    coherence_xy[i] = (c.Cxy.re[i] * c.Cxy.re[i] + c.Cxy.im[i] * c.Cxy.im[i]) /
-                      (c.Px[i] * c.Py[i] + epsilon);
-  }
-}
-
-}  // namespace webrtc
diff --git a/modules/audio_processing/aec3/coherence_gain.h b/modules/audio_processing/aec3/coherence_gain.h
deleted file mode 100644
index b6e22fd..0000000
--- a/modules/audio_processing/aec3/coherence_gain.h
+++ /dev/null
@@ -1,77 +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_AEC3_COHERENCE_GAIN_H_
-#define MODULES_AUDIO_PROCESSING_AEC3_COHERENCE_GAIN_H_
-
-#include <array>
-
-#include "modules/audio_processing/aec3/aec3_common.h"
-#include "modules/audio_processing/aec3/aec3_fft.h"
-#include "rtc_base/constructormagic.h"
-
-namespace webrtc {
-
-// Class for computing an echo suppression gain based on the coherence measure.
-class CoherenceGain {
- public:
-  CoherenceGain(int sample_rate_hz, size_t num_bands_to_compute);
-  ~CoherenceGain();
-
-  // Computes the gain based on the FFTs of the filter error output signal, the
-  // render signal and the capture signal.
-  void ComputeGain(const FftData& E,
-                   const FftData& X,
-                   const FftData& Y,
-                   rtc::ArrayView<float> gain);
-
- private:
-  struct {
-    FftData Cye;
-    FftData Cxy;
-    std::array<float, kFftLengthBy2Plus1> Px;
-    std::array<float, kFftLengthBy2Plus1> Py;
-    std::array<float, kFftLengthBy2Plus1> Pe;
-  } spectra_;
-
-  struct {
-    float h_nl_fb_min = 1;
-    float h_nl_fb_local_min = 1;
-    float h_nl_xd_avg_min = 1.f;
-    int h_nl_new_min = 0;
-    float h_nl_min_ctr = 0;
-    float overdrive = 2;
-    float overdrive_scaling = 2;
-    bool near_state = false;
-  } gain_state_;
-
-  const Aec3Fft fft_;
-  const size_t num_bands_to_compute_;
-  const int sample_rate_scaler_;
-
-  // Updates the spectral estimates used for the coherence computation.
-  void UpdateCoherenceSpectra(const FftData& E,
-                              const FftData& X,
-                              const FftData& Y);
-
-  // Compute the suppression gain based on the coherence.
-  void FormSuppressionGain(rtc::ArrayView<const float> coherence_ye,
-                           rtc::ArrayView<const float> coherence_xy,
-                           rtc::ArrayView<float> h_nl);
-
-  // Compute the coherence.
-  void ComputeCoherence(rtc::ArrayView<float> coherence_ye,
-                        rtc::ArrayView<float> coherence_xy) const;
-
-  RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(CoherenceGain);
-};
-}  // namespace webrtc
-
-#endif  // MODULES_AUDIO_PROCESSING_AEC3_COHERENCE_GAIN_H_
diff --git a/modules/audio_processing/aec3/comfort_noise_generator.cc b/modules/audio_processing/aec3/comfort_noise_generator.cc
index dab40a9..55faf4b 100644
--- a/modules/audio_processing/aec3/comfort_noise_generator.cc
+++ b/modules/audio_processing/aec3/comfort_noise_generator.cc
@@ -10,7 +10,9 @@
 
 #include "modules/audio_processing/aec3/comfort_noise_generator.h"
 
-#include "typedefs.h"  // NOLINT(build/include)
+// Defines WEBRTC_ARCH_X86_FAMILY, used below.
+#include "rtc_base/system/arch.h"
+
 #if defined(WEBRTC_ARCH_X86_FAMILY)
 #include <emmintrin.h>
 #endif
diff --git a/modules/audio_processing/aec3/comfort_noise_generator.h b/modules/audio_processing/aec3/comfort_noise_generator.h
index 2d998be..6a47989 100644
--- a/modules/audio_processing/aec3/comfort_noise_generator.h
+++ b/modules/audio_processing/aec3/comfort_noise_generator.h
@@ -18,6 +18,7 @@
 #include "modules/audio_processing/aec3/aec_state.h"
 #include "modules/audio_processing/aec3/fft_data.h"
 #include "rtc_base/constructormagic.h"
+#include "rtc_base/system/arch.h"
 
 namespace webrtc {
 namespace aec3 {
diff --git a/modules/audio_processing/aec3/comfort_noise_generator_unittest.cc b/modules/audio_processing/aec3/comfort_noise_generator_unittest.cc
index d7e9407..77a09ed 100644
--- a/modules/audio_processing/aec3/comfort_noise_generator_unittest.cc
+++ b/modules/audio_processing/aec3/comfort_noise_generator_unittest.cc
@@ -14,9 +14,9 @@
 #include <numeric>
 
 #include "rtc_base/random.h"
+#include "rtc_base/system/arch.h"
 #include "system_wrappers/include/cpu_features_wrapper.h"
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 namespace aec3 {
diff --git a/modules/audio_processing/aec3/echo_canceller3.cc b/modules/audio_processing/aec3/echo_canceller3.cc
index c02bc14..e5219c7 100644
--- a/modules/audio_processing/aec3/echo_canceller3.cc
+++ b/modules/audio_processing/aec3/echo_canceller3.cc
@@ -342,6 +342,7 @@
                                std::unique_ptr<BlockProcessor> block_processor)
     : data_dumper_(
           new ApmDataDumper(rtc::AtomicOps::Increment(&instance_count_))),
+      config_(config),
       sample_rate_hz_(sample_rate_hz),
       num_bands_(NumBandsForRate(sample_rate_hz_)),
       frame_length_(rtc::CheckedDivExact(LowestBandRate(sample_rate_hz_), 100)),
@@ -358,7 +359,10 @@
       render_queue_output_frame_(num_bands_,
                                  std::vector<float>(frame_length_, 0.f)),
       block_(num_bands_, std::vector<float>(kBlockSize, 0.f)),
-      sub_frame_view_(num_bands_) {
+      sub_frame_view_(num_bands_),
+      block_delay_buffer_(num_bands_,
+                          frame_length_,
+                          config_.delay.fixed_capture_delay_samples) {
   RTC_DCHECK(ValidFullBandRate(sample_rate_hz_));
 
   std::unique_ptr<CascadedBiQuadFilter> render_highpass_filter;
@@ -421,6 +425,11 @@
   data_dumper_->DumpRaw("aec3_call_order",
                         static_cast<int>(EchoCanceller3ApiCall::kCapture));
 
+  // Optionally delay the capture signal.
+  if (config_.delay.fixed_capture_delay_samples > 0) {
+    block_delay_buffer_.DelaySignal(capture);
+  }
+
   rtc::ArrayView<float> capture_lower_band =
       rtc::ArrayView<float>(&capture->split_bands_f(0)[0][0], frame_length_);
 
diff --git a/modules/audio_processing/aec3/echo_canceller3.h b/modules/audio_processing/aec3/echo_canceller3.h
index b66b8b1..f5520ba 100644
--- a/modules/audio_processing/aec3/echo_canceller3.h
+++ b/modules/audio_processing/aec3/echo_canceller3.h
@@ -12,6 +12,7 @@
 #define MODULES_AUDIO_PROCESSING_AEC3_ECHO_CANCELLER3_H_
 
 #include "api/audio/echo_canceller3_config.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"
 #include "modules/audio_processing/aec3/cascaded_biquad_filter.h"
@@ -110,6 +111,7 @@
   // State that may be accessed by the capture thread.
   static int instance_count_;
   std::unique_ptr<ApmDataDumper> data_dumper_;
+  const EchoCanceller3Config config_;
   const int sample_rate_hz_;
   const int num_bands_;
   const size_t frame_length_;
@@ -129,6 +131,7 @@
   std::vector<std::vector<float>> block_ RTC_GUARDED_BY(capture_race_checker_);
   std::vector<rtc::ArrayView<float>> sub_frame_view_
       RTC_GUARDED_BY(capture_race_checker_);
+  BlockDelayBuffer block_delay_buffer_ RTC_GUARDED_BY(capture_race_checker_);
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(EchoCanceller3);
 };
diff --git a/modules/audio_processing/aec3/echo_remover.cc b/modules/audio_processing/aec3/echo_remover.cc
index 5394eaf..9b6677e 100644
--- a/modules/audio_processing/aec3/echo_remover.cc
+++ b/modules/audio_processing/aec3/echo_remover.cc
@@ -141,7 +141,6 @@
   bool echo_leakage_detected_ = false;
   AecState aec_state_;
   EchoRemoverMetrics metrics_;
-  bool initial_state_ = true;
   std::array<float, kFftLengthBy2> e_old_;
   std::array<float, kFftLengthBy2> x_old_;
   std::array<float, kFftLengthBy2> y_old_;
@@ -163,7 +162,9 @@
           new ApmDataDumper(rtc::AtomicOps::Increment(&instance_count_))),
       optimization_(DetectOptimization()),
       sample_rate_hz_(sample_rate_hz),
-      use_shadow_filter_output_(UseShadowFilterOutput()),
+      use_shadow_filter_output_(
+          UseShadowFilterOutput() &&
+          config_.filter.enable_shadow_filter_output_usage),
       use_smooth_signal_transitions_(UseSmoothSignalTransitions()),
       subtractor_(config, data_dumper_.get(), optimization_),
       suppression_gain_(config_, optimization_, sample_rate_hz),
@@ -233,7 +234,6 @@
     if (echo_path_variability.delay_change !=
         EchoPathVariability::DelayAdjustment::kNone) {
       suppression_gain_.SetInitialState(true);
-      initial_state_ = true;
     }
   }
   if (gain_change_hangover_ > 0) {
@@ -257,10 +257,9 @@
                                  aec_state_.FilterDelayBlocks());
 
   // Perform linear echo cancellation.
-  if (initial_state_ && !aec_state_.InitialState()) {
+  if (aec_state_.TransitionTriggered()) {
     subtractor_.ExitInitialState();
     suppression_gain_.SetInitialState(false);
-    initial_state_ = false;
   }
 
   // If the delay is known, use the echo subtractor.
@@ -281,17 +280,6 @@
                     subtractor_.FilterImpulseResponse(), *render_buffer, E2, Y2,
                     subtractor_output, y0);
 
-  // Compute spectra.
-  const bool suppression_gain_uses_ffts =
-      config_.suppressor.bands_with_reliable_coherence > 0;
-  FftData X;
-  if (suppression_gain_uses_ffts) {
-    auto& x_aligned = render_buffer->Block(-aec_state_.FilterDelayBlocks())[0];
-    WindowedPaddedFft(fft_, x_aligned, x_old_, &X);
-  } else {
-    X.Clear();
-  }
-
   // Choose the linear output.
   data_dumper_->DumpWav("aec3_output_linear2", kBlockSize, &e[0],
                         LowestBandRate(sample_rate_hz_), 1);
@@ -321,7 +309,9 @@
   cng_.Compute(aec_state_, Y2, &comfort_noise, &high_band_comfort_noise);
 
   // Compute and apply the suppression gain.
-  suppression_gain_.GetGain(E2, R2, cng_.NoiseSpectrum(), E, X, Y,
+  const auto& echo_spectrum =
+      aec_state_.UsableLinearEstimate() ? S2_linear : R2;
+  suppression_gain_.GetGain(E2, echo_spectrum, R2, cng_.NoiseSpectrum(), E, Y,
                             render_signal_analyzer_, aec_state_, x,
                             &high_bands_gain, &G);
 
@@ -366,9 +356,9 @@
   RTC_DCHECK_EQ(subtractor_output.e_shadow.size(), output.size());
   bool use_main_output = true;
   if (use_shadow_filter_output_) {
-    // As the output of the main adaptive filter generally should be better than
-    // the shadow filter output, add a margin and threshold for when choosing
-    // the shadow filter output.
+    // As the output of the main adaptive filter generally should be better
+    // than the shadow filter output, add a margin and threshold for when
+    // choosing the shadow filter output.
     if (subtractor_output.e2_shadow < 0.9f * subtractor_output.e2_main &&
         subtractor_output.y2 > 30.f * 30.f * kBlockSize &&
         (subtractor_output.s2_main > 60.f * 60.f * kBlockSize ||
diff --git a/modules/audio_processing/aec3/erle_estimator.cc b/modules/audio_processing/aec3/erle_estimator.cc
index 52ef8ed..b02245c 100644
--- a/modules/audio_processing/aec3/erle_estimator.cc
+++ b/modules/audio_processing/aec3/erle_estimator.cc
@@ -35,6 +35,13 @@
       max_erle_hf_(max_erle_hf),
       erle_freq_inst_(kPointsToAccumulate),
       erle_time_inst_(kPointsToAccumulate) {
+  Reset();
+}
+
+ErleEstimator::~ErleEstimator() = default;
+
+void ErleEstimator::Reset() {
+  erle_time_inst_.Reset();
   erle_.fill(min_erle_);
   erle_onsets_.fill(min_erle_);
   hold_counters_.fill(0);
@@ -43,8 +50,6 @@
   hold_counter_time_domain_ = 0;
 }
 
-ErleEstimator::~ErleEstimator() = default;
-
 ErleEstimator::ErleTimeInstantaneous::ErleTimeInstantaneous(
     int points_to_accumulate)
     : points_to_accumulate_(points_to_accumulate) {
@@ -167,7 +172,8 @@
 void ErleEstimator::Update(rtc::ArrayView<const float> render_spectrum,
                            rtc::ArrayView<const float> capture_spectrum,
                            rtc::ArrayView<const float> subtractor_spectrum,
-                           bool converged_filter) {
+                           bool converged_filter,
+                           bool onset_detection) {
   RTC_DCHECK_EQ(kFftLengthBy2Plus1, render_spectrum.size());
   RTC_DCHECK_EQ(kFftLengthBy2Plus1, capture_spectrum.size());
   RTC_DCHECK_EQ(kFftLengthBy2Plus1, subtractor_spectrum.size());
@@ -191,19 +197,22 @@
   };
 
   // Update the estimates in a clamped minimum statistics manner.
-  auto erle_update = [&](size_t start, size_t stop, float max_erle) {
+  auto erle_update = [&](size_t start, size_t stop, float max_erle,
+                         bool onset_detection) {
     for (size_t k = start; k < stop; ++k) {
       if (X2[k] > kX2Min) {
         absl::optional<float> new_erle =
             erle_freq_inst_.Update(Y2[k], E2[k], k);
         if (new_erle) {
-          if (coming_onset_[k]) {
-            coming_onset_[k] = false;
-            erle_onsets_[k] =
-                erle_band_update(erle_onsets_[k], new_erle.value(), 0.15f, 0.3f,
-                                 min_erle_, max_erle);
+          if (onset_detection) {
+            if (coming_onset_[k]) {
+              coming_onset_[k] = false;
+              erle_onsets_[k] =
+                  erle_band_update(erle_onsets_[k], new_erle.value(), 0.15f,
+                                   0.3f, min_erle_, max_erle);
+            }
+            hold_counters_[k] = kBlocksForOnsetDetection;
           }
-          hold_counters_[k] = kBlocksForOnsetDetection;
           erle_[k] = erle_band_update(erle_[k], new_erle.value(), 0.05f, 0.1f,
                                       min_erle_, max_erle);
         }
@@ -216,20 +225,22 @@
     // a minimum of the erle that can be estimated as that flag would
     // be false if the filter is performing poorly.
     constexpr size_t kFftLengthBy4 = kFftLengthBy2 / 2;
-    erle_update(1, kFftLengthBy4, max_erle_lf_);
-    erle_update(kFftLengthBy4, kFftLengthBy2, max_erle_hf_);
+    erle_update(1, kFftLengthBy4, max_erle_lf_, onset_detection);
+    erle_update(kFftLengthBy4, kFftLengthBy2, max_erle_hf_, onset_detection);
   }
 
-  for (size_t k = 1; k < kFftLengthBy2; ++k) {
-    hold_counters_[k]--;
-    if (hold_counters_[k] <= (kBlocksForOnsetDetection - kErleHold)) {
-      if (erle_[k] > erle_onsets_[k]) {
-        erle_[k] = std::max(erle_onsets_[k], 0.97f * erle_[k]);
-        RTC_DCHECK_LE(min_erle_, erle_[k]);
-      }
-      if (hold_counters_[k] <= 0) {
-        coming_onset_[k] = true;
-        hold_counters_[k] = 0;
+  if (onset_detection) {
+    for (size_t k = 1; k < kFftLengthBy2; ++k) {
+      hold_counters_[k]--;
+      if (hold_counters_[k] <= (kBlocksForOnsetDetection - kErleHold)) {
+        if (erle_[k] > erle_onsets_[k]) {
+          erle_[k] = std::max(erle_onsets_[k], 0.97f * erle_[k]);
+          RTC_DCHECK_LE(min_erle_, erle_[k]);
+        }
+        if (hold_counters_[k] <= 0) {
+          coming_onset_[k] = true;
+          hold_counters_[k] = 0;
+        }
       }
     }
   }
diff --git a/modules/audio_processing/aec3/erle_estimator.h b/modules/audio_processing/aec3/erle_estimator.h
index 19bc7b4..8160dbe 100644
--- a/modules/audio_processing/aec3/erle_estimator.h
+++ b/modules/audio_processing/aec3/erle_estimator.h
@@ -27,11 +27,15 @@
   ErleEstimator(float min_erle, float max_erle_lf, float max_erle_hf);
   ~ErleEstimator();
 
+  // Reset the ERLE estimator.
+  void Reset();
+
   // Updates the ERLE estimate.
   void Update(rtc::ArrayView<const float> render_spectrum,
               rtc::ArrayView<const float> capture_spectrum,
               rtc::ArrayView<const float> subtractor_spectrum,
-              bool converged_filter);
+              bool converged_filter,
+              bool onset_detection);
 
   // Returns the most recent ERLE estimate.
   const std::array<float, kFftLengthBy2Plus1>& Erle() const { return erle_; }
diff --git a/modules/audio_processing/aec3/erle_estimator_unittest.cc b/modules/audio_processing/aec3/erle_estimator_unittest.cc
index 86ac5df..1687568 100644
--- a/modules/audio_processing/aec3/erle_estimator_unittest.cc
+++ b/modules/audio_processing/aec3/erle_estimator_unittest.cc
@@ -10,8 +10,8 @@
 
 #include <cmath>
 
-#include "modules/audio_processing/aec3/erle_estimator.h"
 #include "api/array_view.h"
+#include "modules/audio_processing/aec3/erle_estimator.h"
 #include "test/gtest.h"
 
 namespace webrtc {
@@ -74,7 +74,7 @@
   FormFarendFrame(&X2, &E2, &Y2, kTrueErle);
 
   for (size_t k = 0; k < 200; ++k) {
-    estimator.Update(X2, Y2, E2, true);
+    estimator.Update(X2, Y2, E2, true, true);
   }
   VerifyErle(estimator.Erle(), std::pow(2.f, estimator.ErleTimeDomainLog2()),
              kMaxErleLf, kMaxErleHf);
@@ -83,7 +83,7 @@
   // Verifies that the ERLE is not immediately decreased during nearend
   // activity.
   for (size_t k = 0; k < 50; ++k) {
-    estimator.Update(X2, Y2, E2, true);
+    estimator.Update(X2, Y2, E2, true, true);
   }
   VerifyErle(estimator.Erle(), std::pow(2.f, estimator.ErleTimeDomainLog2()),
              kMaxErleLf, kMaxErleHf);
@@ -99,21 +99,21 @@
   for (size_t burst = 0; burst < 20; ++burst) {
     FormFarendFrame(&X2, &E2, &Y2, kTrueErleOnsets);
     for (size_t k = 0; k < 10; ++k) {
-      estimator.Update(X2, Y2, E2, true);
+      estimator.Update(X2, Y2, E2, true, true);
     }
     FormFarendFrame(&X2, &E2, &Y2, kTrueErle);
     for (size_t k = 0; k < 200; ++k) {
-      estimator.Update(X2, Y2, E2, true);
+      estimator.Update(X2, Y2, E2, true, true);
     }
     FormNearendFrame(&X2, &E2, &Y2);
     for (size_t k = 0; k < 300; ++k) {
-      estimator.Update(X2, Y2, E2, true);
+      estimator.Update(X2, Y2, E2, true, true);
     }
   }
   VerifyErleBands(estimator.ErleOnsets(), kMinErle, kMinErle);
   FormNearendFrame(&X2, &E2, &Y2);
   for (size_t k = 0; k < 1000; k++) {
-    estimator.Update(X2, Y2, E2, true);
+    estimator.Update(X2, Y2, E2, true, true);
   }
   // Verifies that during ne activity, Erle converges to the Erle for onsets.
   VerifyErle(estimator.Erle(), std::pow(2.f, estimator.ErleTimeDomainLog2()),
@@ -131,7 +131,7 @@
   X2.fill(1000.f * 1000.f);
   Y2.fill(10 * E2[0]);
   for (size_t k = 0; k < 200; ++k) {
-    estimator.Update(X2, Y2, E2, true);
+    estimator.Update(X2, Y2, E2, true, true);
   }
   VerifyErle(estimator.Erle(), std::pow(2.f, estimator.ErleTimeDomainLog2()),
              kMinErle, kMinErle);
diff --git a/modules/audio_processing/aec3/fft_data.h b/modules/audio_processing/aec3/fft_data.h
index 59511b5..5e5adb6 100644
--- a/modules/audio_processing/aec3/fft_data.h
+++ b/modules/audio_processing/aec3/fft_data.h
@@ -11,7 +11,9 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_FFT_DATA_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_FFT_DATA_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
+// Defines WEBRTC_ARCH_X86_FAMILY, used below.
+#include "rtc_base/system/arch.h"
+
 #if defined(WEBRTC_ARCH_X86_FAMILY)
 #include <emmintrin.h>
 #endif
diff --git a/modules/audio_processing/aec3/fft_data_unittest.cc b/modules/audio_processing/aec3/fft_data_unittest.cc
index 8fc5ca7..0812fd6 100644
--- a/modules/audio_processing/aec3/fft_data_unittest.cc
+++ b/modules/audio_processing/aec3/fft_data_unittest.cc
@@ -10,9 +10,9 @@
 
 #include "modules/audio_processing/aec3/fft_data.h"
 
+#include "rtc_base/system/arch.h"
 #include "system_wrappers/include/cpu_features_wrapper.h"
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/aec3/filter_analyzer.cc b/modules/audio_processing/aec3/filter_analyzer.cc
index ab2c4f2..790cb1e 100644
--- a/modules/audio_processing/aec3/filter_analyzer.cc
+++ b/modules/audio_processing/aec3/filter_analyzer.cc
@@ -95,10 +95,9 @@
     const RenderBuffer& render_buffer) {
   // Preprocess the filter to avoid issues with low-frequency components in the
   // filter.
-  if (use_preprocessed_filter_) {
-    PreProcessFilter(filter_time_domain);
-    data_dumper_->DumpRaw("aec3_linear_filter_processed_td", h_highpass_);
-  }
+  PreProcessFilter(filter_time_domain);
+  data_dumper_->DumpRaw("aec3_linear_filter_processed_td", h_highpass_);
+
   const auto& filter_to_analyze =
       use_preprocessed_filter_ ? h_highpass_ : filter_time_domain;
   RTC_DCHECK_EQ(filter_to_analyze.size(), filter_time_domain.size());
diff --git a/modules/audio_processing/aec3/filter_analyzer.h b/modules/audio_processing/aec3/filter_analyzer.h
index 627341d..47e9533 100644
--- a/modules/audio_processing/aec3/filter_analyzer.h
+++ b/modules/audio_processing/aec3/filter_analyzer.h
@@ -54,16 +54,14 @@
   // Returns the number of blocks for the current used filter.
   float FilterLengthBlocks() const { return filter_length_blocks_; }
 
+  // Returns the preprocessed filter.
+  rtc::ArrayView<const float> GetAdjustedFilter() const { return h_highpass_; }
+
  private:
   void UpdateFilterGain(rtc::ArrayView<const float> filter_time_domain,
                         size_t max_index);
   void PreProcessFilter(rtc::ArrayView<const float> filter_time_domain);
 
-  // Updates the estimation of the frequency response at the filter tails.
-  void UpdateFreqRespTail(
-      const std::vector<std::array<float, kFftLengthBy2Plus1>>&
-          filter_freq_response);
-
   static int instance_count_;
   std::unique_ptr<ApmDataDumper> data_dumper_;
   const bool use_preprocessed_filter_;
diff --git a/modules/audio_processing/aec3/main_filter_update_gain.cc b/modules/audio_processing/aec3/main_filter_update_gain.cc
index 6d31ed0..4f48cd4 100644
--- a/modules/audio_processing/aec3/main_filter_update_gain.cc
+++ b/modules/audio_processing/aec3/main_filter_update_gain.cc
@@ -22,7 +22,6 @@
 namespace {
 
 constexpr float kHErrorInitial = 10000.f;
-constexpr float kHErrorGainChange = 10000.f;
 constexpr int kPoorExcitationCounterInitial = 1000;
 
 }  // namespace
@@ -48,7 +47,7 @@
 void MainFilterUpdateGain::HandleEchoPathChange(
     const EchoPathVariability& echo_path_variability) {
   if (echo_path_variability.gain_change) {
-    H_error_.fill(kHErrorGainChange);
+    // TODO(bugs.webrtc.org/9526) Handle gain changes.
   }
 
   if (echo_path_variability.delay_change !=
diff --git a/modules/audio_processing/aec3/matched_filter.cc b/modules/audio_processing/aec3/matched_filter.cc
index 466acd4..7486ddf 100644
--- a/modules/audio_processing/aec3/matched_filter.cc
+++ b/modules/audio_processing/aec3/matched_filter.cc
@@ -9,10 +9,12 @@
  */
 #include "modules/audio_processing/aec3/matched_filter.h"
 
+// Defines WEBRTC_ARCH_X86_FAMILY, used below.
+#include "rtc_base/system/arch.h"
+
 #if defined(WEBRTC_HAS_NEON)
 #include <arm_neon.h>
 #endif
-#include "typedefs.h"  // NOLINT(build/include)
 #if defined(WEBRTC_ARCH_X86_FAMILY)
 #include <emmintrin.h>
 #endif
diff --git a/modules/audio_processing/aec3/matched_filter.h b/modules/audio_processing/aec3/matched_filter.h
index 8add6fe..1c06b5e 100644
--- a/modules/audio_processing/aec3/matched_filter.h
+++ b/modules/audio_processing/aec3/matched_filter.h
@@ -20,6 +20,7 @@
 #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 {
 namespace aec3 {
diff --git a/modules/audio_processing/aec3/matched_filter_unittest.cc b/modules/audio_processing/aec3/matched_filter_unittest.cc
index fd878ff..c7dc211 100644
--- a/modules/audio_processing/aec3/matched_filter_unittest.cc
+++ b/modules/audio_processing/aec3/matched_filter_unittest.cc
@@ -10,7 +10,9 @@
 
 #include "modules/audio_processing/aec3/matched_filter.h"
 
-#include "typedefs.h"  // NOLINT(build/include)
+// Defines WEBRTC_ARCH_X86_FAMILY, used below.
+#include "rtc_base/system/arch.h"
+
 #if defined(WEBRTC_ARCH_X86_FAMILY)
 #include <emmintrin.h>
 #endif
diff --git a/modules/audio_processing/aec3/render_buffer.cc b/modules/audio_processing/aec3/render_buffer.cc
index 6e224be..235e3e3 100644
--- a/modules/audio_processing/aec3/render_buffer.cc
+++ b/modules/audio_processing/aec3/render_buffer.cc
@@ -47,4 +47,28 @@
   }
 }
 
+void RenderBuffer::SpectralSums(
+    size_t num_spectra_shorter,
+    size_t num_spectra_longer,
+    std::array<float, kFftLengthBy2Plus1>* X2_shorter,
+    std::array<float, kFftLengthBy2Plus1>* X2_longer) const {
+  RTC_DCHECK_LE(num_spectra_shorter, num_spectra_longer);
+  X2_shorter->fill(0.f);
+  int position = spectrum_buffer_->read;
+  size_t j = 0;
+  for (; j < num_spectra_shorter; ++j) {
+    std::transform(X2_shorter->begin(), X2_shorter->end(),
+                   spectrum_buffer_->buffer[position].begin(),
+                   X2_shorter->begin(), std::plus<float>());
+    position = spectrum_buffer_->IncIndex(position);
+  }
+  std::copy(X2_shorter->begin(), X2_shorter->end(), X2_longer->begin());
+  for (; j < num_spectra_longer; ++j) {
+    std::transform(X2_longer->begin(), X2_longer->end(),
+                   spectrum_buffer_->buffer[position].begin(),
+                   X2_longer->begin(), std::plus<float>());
+    position = spectrum_buffer_->IncIndex(position);
+  }
+}
+
 }  // namespace webrtc
diff --git a/modules/audio_processing/aec3/render_buffer.h b/modules/audio_processing/aec3/render_buffer.h
index 34e7edf..dd67268 100644
--- a/modules/audio_processing/aec3/render_buffer.h
+++ b/modules/audio_processing/aec3/render_buffer.h
@@ -61,6 +61,12 @@
   void SpectralSum(size_t num_spectra,
                    std::array<float, kFftLengthBy2Plus1>* X2) const;
 
+  // Returns the sums of the spectrums for two numbers of FFTs.
+  void SpectralSums(size_t num_spectra_shorter,
+                    size_t num_spectra_longer,
+                    std::array<float, kFftLengthBy2Plus1>* X2_shorter,
+                    std::array<float, kFftLengthBy2Plus1>* X2_longer) const;
+
   // Gets the recent activity seen in the render signal.
   bool GetRenderActivity() const { return render_activity_; }
 
diff --git a/modules/audio_processing/aec3/residual_echo_estimator.cc b/modules/audio_processing/aec3/residual_echo_estimator.cc
index 43002e3..2e3ad9f 100644
--- a/modules/audio_processing/aec3/residual_echo_estimator.cc
+++ b/modules/audio_processing/aec3/residual_echo_estimator.cc
@@ -113,7 +113,7 @@
     if (echo_reverb_) {
       echo_reverb_->AddReverb(
           render_buffer.Spectrum(aec_state.FilterLengthBlocks() + 1),
-          aec_state.GetFreqRespTail(), aec_state.ReverbDecay(), *R2);
+          aec_state.GetReverbFrequencyResponse(), aec_state.ReverbDecay(), *R2);
 
     } else {
       RTC_DCHECK(echo_reverb_fallback);
diff --git a/modules/audio_processing/aec3/reverb_decay_estimator.cc b/modules/audio_processing/aec3/reverb_decay_estimator.cc
new file mode 100644
index 0000000..f80afa2
--- /dev/null
+++ b/modules/audio_processing/aec3/reverb_decay_estimator.cc
@@ -0,0 +1,413 @@
+/*
+ *  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/reverb_decay_estimator.h"
+
+#include <algorithm>
+#include <cmath>
+#include <numeric>
+
+#include "api/array_view.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 {
+
+bool EnforceAdaptiveEchoReverbEstimation() {
+  return field_trial::IsEnabled(
+      "WebRTC-Aec3EnableAdaptiveEchoReverbEstimation");
+}
+
+constexpr int kEarlyReverbMinSizeBlocks = 3;
+constexpr int kBlocksPerSection = 6;
+// Linear regression approach assumes symmetric index around 0.
+constexpr float kEarlyReverbFirstPointAtLinearRegressors =
+    -0.5f * kBlocksPerSection * kFftLengthBy2 + 0.5f;
+
+// Averages the values in a block of size kFftLengthBy2;
+float BlockAverage(rtc::ArrayView<const float> v, size_t block_index) {
+  constexpr float kOneByFftLengthBy2 = 1.f / kFftLengthBy2;
+  const int i = block_index * kFftLengthBy2;
+  RTC_DCHECK_GE(v.size(), i + kFftLengthBy2);
+  const float sum =
+      std::accumulate(v.begin() + i, v.begin() + i + kFftLengthBy2, 0.f);
+  return sum * kOneByFftLengthBy2;
+}
+
+// Analyzes the gain in a block.
+void AnalyzeBlockGain(const std::array<float, kFftLengthBy2>& h2,
+                      float floor_gain,
+                      float* previous_gain,
+                      bool* block_adapting,
+                      bool* decaying_gain) {
+  float gain = std::max(BlockAverage(h2, 0), 1e-32f);
+  *block_adapting =
+      *previous_gain > 1.1f * gain || *previous_gain < 0.9f * gain;
+  *decaying_gain = gain > floor_gain;
+  *previous_gain = gain;
+}
+
+// Arithmetic sum of $2 \sum_{i=0.5}^{(N-1)/2}i^2$ calculated directly.
+constexpr float SymmetricArithmetricSum(int N) {
+  return N * (N * N - 1.0f) * (1.f / 12.f);
+}
+
+// Returns the peak energy of an impulse response.
+float BlockEnergyPeak(rtc::ArrayView<const float> h, int peak_block) {
+  RTC_DCHECK_LE((peak_block + 1) * kFftLengthBy2, h.size());
+  RTC_DCHECK_GE(peak_block, 0);
+  float peak_value =
+      *std::max_element(h.begin() + peak_block * kFftLengthBy2,
+                        h.begin() + (peak_block + 1) * kFftLengthBy2,
+                        [](float a, float b) { return a * a < b * b; });
+  return peak_value * peak_value;
+}
+
+// Returns the average energy of an impulse response block.
+float BlockEnergyAverage(rtc::ArrayView<const float> h, int block_index) {
+  RTC_DCHECK_LE((block_index + 1) * kFftLengthBy2, h.size());
+  RTC_DCHECK_GE(block_index, 0);
+  constexpr float kOneByFftLengthBy2 = 1.f / kFftLengthBy2;
+  const auto sum_of_squares = [](float a, float b) { return a + b * b; };
+  return std::accumulate(h.begin() + block_index * kFftLengthBy2,
+                         h.begin() + (block_index + 1) * kFftLengthBy2, 0.f,
+                         sum_of_squares) *
+         kOneByFftLengthBy2;
+}
+
+}  // namespace
+
+ReverbDecayEstimator::ReverbDecayEstimator(const EchoCanceller3Config& config)
+    : filter_length_blocks_(config.filter.main.length_blocks),
+      filter_length_coefficients_(GetTimeDomainLength(filter_length_blocks_)),
+      use_adaptive_echo_decay_(config.ep_strength.default_len < 0.f ||
+                               EnforceAdaptiveEchoReverbEstimation()),
+      early_reverb_estimator_(config.filter.main.length_blocks -
+                              kEarlyReverbMinSizeBlocks),
+      late_reverb_start_(kEarlyReverbMinSizeBlocks),
+      late_reverb_end_(kEarlyReverbMinSizeBlocks),
+      decay_(std::fabs(config.ep_strength.default_len)) {
+  previous_gains_.fill(0.f);
+  RTC_DCHECK_GT(config.filter.main.length_blocks,
+                static_cast<size_t>(kEarlyReverbMinSizeBlocks));
+}
+
+ReverbDecayEstimator::~ReverbDecayEstimator() = default;
+
+void ReverbDecayEstimator::Update(rtc::ArrayView<const float> filter,
+                                  const absl::optional<float>& filter_quality,
+                                  int filter_delay_blocks,
+                                  bool usable_linear_filter,
+                                  bool stationary_signal) {
+  const int filter_size = static_cast<int>(filter.size());
+
+  if (stationary_signal) {
+    return;
+  }
+
+  bool estimation_feasible =
+      filter_delay_blocks <=
+      filter_length_blocks_ - kEarlyReverbMinSizeBlocks - 1;
+  estimation_feasible =
+      estimation_feasible && filter_size == filter_length_coefficients_;
+  estimation_feasible = estimation_feasible && filter_delay_blocks > 0;
+  estimation_feasible = estimation_feasible && usable_linear_filter;
+
+  if (!estimation_feasible) {
+    ResetDecayEstimation();
+    return;
+  }
+
+  if (!use_adaptive_echo_decay_) {
+    return;
+  }
+
+  const float new_smoothing = filter_quality ? *filter_quality * 0.2f : 0.f;
+  smoothing_constant_ = std::max(new_smoothing, smoothing_constant_);
+  if (smoothing_constant_ == 0.f) {
+    return;
+  }
+
+  if (block_to_analyze_ < filter_length_blocks_) {
+    // Analyze the filter and accumulate data for reverb estimation.
+    AnalyzeFilter(filter);
+    ++block_to_analyze_;
+  } else {
+    // When the filter is fully analyzed, estimate the reverb decay and reset
+    // the block_to_analyze_ counter.
+    EstimateDecay(filter, filter_delay_blocks);
+  }
+}
+
+void ReverbDecayEstimator::ResetDecayEstimation() {
+  early_reverb_estimator_.Reset();
+  late_reverb_decay_estimator_.Reset(0);
+  block_to_analyze_ = 0;
+  estimation_region_candidate_size_ = 0;
+  estimation_region_identified_ = false;
+  smoothing_constant_ = 0.f;
+  late_reverb_start_ = 0;
+  late_reverb_end_ = 0;
+}
+
+void ReverbDecayEstimator::EstimateDecay(rtc::ArrayView<const float> filter,
+                                         int peak_block) {
+  auto& h = filter;
+  RTC_DCHECK_EQ(0, h.size() % kFftLengthBy2);
+
+  // Reset the block analysis counter.
+  block_to_analyze_ =
+      std::min(peak_block + kEarlyReverbMinSizeBlocks, filter_length_blocks_);
+
+  // To estimate the reverb decay, the energy of the first filter section must
+  // be substantially larger than the last. Also, the first filter section
+  // energy must not deviate too much from the max peak.
+  const float first_reverb_gain = BlockEnergyAverage(h, block_to_analyze_);
+  const size_t h_size_blocks = h.size() >> kFftLengthBy2Log2;
+  tail_gain_ = BlockEnergyAverage(h, h_size_blocks - 1);
+  float peak_energy = BlockEnergyPeak(h, peak_block);
+  const bool sufficient_reverb_decay = first_reverb_gain > 4.f * tail_gain_;
+  const bool valid_filter =
+      first_reverb_gain > 2.f * tail_gain_ && peak_energy < 100.f;
+
+  // Estimate the size of the regions with early and late reflections.
+  const int size_early_reverb = early_reverb_estimator_.Estimate();
+  const int size_late_reverb =
+      std::max(estimation_region_candidate_size_ - size_early_reverb, 0);
+
+  // Only update the reverb decay estimate if the size of the identified late
+  // reverb is sufficiently large.
+  if (size_late_reverb >= 5) {
+    if (valid_filter && late_reverb_decay_estimator_.EstimateAvailable()) {
+      float decay = std::pow(
+          2.0f, late_reverb_decay_estimator_.Estimate() * kFftLengthBy2);
+      constexpr float kMaxDecay = 0.95f;  // ~1 sec min RT60.
+      constexpr float kMinDecay = 0.02f;  // ~15 ms max RT60.
+      decay = std::max(.97f * decay_, decay);
+      decay = std::min(decay, kMaxDecay);
+      decay = std::max(decay, kMinDecay);
+      decay_ += smoothing_constant_ * (decay - decay_);
+    }
+
+    // Update length of decay. Must have enough data (number of sections) in
+    // order to estimate decay rate.
+    late_reverb_decay_estimator_.Reset(size_late_reverb * kFftLengthBy2);
+    late_reverb_start_ =
+        peak_block + kEarlyReverbMinSizeBlocks + size_early_reverb;
+    late_reverb_end_ =
+        block_to_analyze_ + estimation_region_candidate_size_ - 1;
+  } else {
+    late_reverb_decay_estimator_.Reset(0);
+    late_reverb_start_ = 0;
+    late_reverb_end_ = 0;
+  }
+
+  // Reset variables for the identification of the region for reverb decay
+  // estimation.
+  estimation_region_identified_ = !(valid_filter && sufficient_reverb_decay);
+  estimation_region_candidate_size_ = 0;
+
+  // Stop estimation of the decay until another good filter is received.
+  smoothing_constant_ = 0.f;
+
+  // Reset early reflections detector.
+  early_reverb_estimator_.Reset();
+}
+
+void ReverbDecayEstimator::AnalyzeFilter(rtc::ArrayView<const float> filter) {
+  auto h = rtc::ArrayView<const float>(
+      filter.begin() + block_to_analyze_ * kFftLengthBy2, kFftLengthBy2);
+
+  // Compute squared filter coeffiecients for the block to analyze_;
+  std::array<float, kFftLengthBy2> h2;
+  std::transform(h.begin(), h.end(), h2.begin(), [](float a) { return a * a; });
+
+  // Map out the region for estimating the reverb decay.
+  bool adapting;
+  bool above_noise_floor;
+  AnalyzeBlockGain(h2, tail_gain_, &previous_gains_[block_to_analyze_],
+                   &adapting, &above_noise_floor);
+
+  // Count consecutive number of "good" filter sections, where "good" means:
+  // 1) energy is above noise floor.
+  // 2) energy of current section has not changed too much from last check.
+  estimation_region_identified_ =
+      estimation_region_identified_ || adapting || !above_noise_floor;
+  if (!estimation_region_identified_) {
+    ++estimation_region_candidate_size_;
+  }
+
+  // Accumulate data for reverb decay estimation and for the estimation of early
+  // reflections.
+  if (block_to_analyze_ <= late_reverb_end_) {
+    if (block_to_analyze_ >= late_reverb_start_) {
+      for (float h2_k : h2) {
+        float h2_log2 = FastApproxLog2f(h2_k + 1e-10);
+        late_reverb_decay_estimator_.Accumulate(h2_log2);
+        early_reverb_estimator_.Accumulate(h2_log2, smoothing_constant_);
+      }
+    } else {
+      for (float h2_k : h2) {
+        float h2_log2 = FastApproxLog2f(h2_k + 1e-10);
+        early_reverb_estimator_.Accumulate(h2_log2, smoothing_constant_);
+      }
+    }
+  }
+}
+
+void ReverbDecayEstimator::Dump(ApmDataDumper* data_dumper) const {
+  data_dumper->DumpRaw("aec3_reverb_decay", decay_);
+  data_dumper->DumpRaw("aec3_reverb_tail_energy", tail_gain_);
+  data_dumper->DumpRaw("aec3_reverb_alpha", smoothing_constant_);
+  data_dumper->DumpRaw("aec3_num_reverb_decay_blocks",
+                       late_reverb_end_ - late_reverb_start_);
+  data_dumper->DumpRaw("aec3_late_reverb_start", late_reverb_start_);
+  data_dumper->DumpRaw("aec3_late_reverb_end", late_reverb_end_);
+  early_reverb_estimator_.Dump(data_dumper);
+}
+
+void ReverbDecayEstimator::LateReverbLinearRegressor::Reset(
+    int num_data_points) {
+  RTC_DCHECK_LE(0, num_data_points);
+  RTC_DCHECK_EQ(0, num_data_points % 2);
+  const int N = num_data_points;
+  nz_ = 0.f;
+  // Arithmetic sum of $2 \sum_{i=0.5}^{(N-1)/2}i^2$ calculated directly.
+  nn_ = SymmetricArithmetricSum(N);
+  // The linear regression approach assumes symmetric index around 0.
+  count_ = N > 0 ? count_ = -N * 0.5f + 0.5f : 0.f;
+  N_ = N;
+  n_ = 0;
+}
+
+void ReverbDecayEstimator::LateReverbLinearRegressor::Accumulate(float z) {
+  nz_ += count_ * z;
+  ++count_;
+  ++n_;
+}
+
+float ReverbDecayEstimator::LateReverbLinearRegressor::Estimate() {
+  RTC_DCHECK(EstimateAvailable());
+  if (nn_ == 0.f) {
+    RTC_NOTREACHED();
+    return 0.f;
+  }
+  return nz_ / nn_;
+}
+
+ReverbDecayEstimator::EarlyReverbLengthEstimator::EarlyReverbLengthEstimator(
+    int max_blocks)
+    : numerators_smooth_(max_blocks - kBlocksPerSection, 0.f),
+      numerators_(numerators_smooth_.size(), 0.f),
+      coefficients_counter_(0) {
+  RTC_DCHECK_LE(0, max_blocks);
+}
+
+ReverbDecayEstimator::EarlyReverbLengthEstimator::
+    ~EarlyReverbLengthEstimator() = default;
+
+void ReverbDecayEstimator::EarlyReverbLengthEstimator::Reset() {
+  coefficients_counter_ = 0;
+  std::fill(numerators_.begin(), numerators_.end(), 0.f);
+  block_counter_ = 0;
+}
+
+void ReverbDecayEstimator::EarlyReverbLengthEstimator::Accumulate(
+    float value,
+    float smoothing) {
+  // Each section is composed by kBlocksPerSection blocks and each section
+  // overlaps with the next one in (kBlocksPerSection - 1) blocks. For example,
+  // the first section covers the blocks [0:5], the second covers the blocks
+  // [1:6] and so on. As a result, for each value, kBlocksPerSection sections
+  // need to be updated.
+  int first_section_index = std::max(block_counter_ - kBlocksPerSection + 1, 0);
+  int last_section_index =
+      std::min(block_counter_, static_cast<int>(numerators_.size() - 1));
+  float x_value = static_cast<float>(coefficients_counter_) +
+                  kEarlyReverbFirstPointAtLinearRegressors;
+  const float value_to_inc = kFftLengthBy2 * value;
+  float value_to_add =
+      x_value * value + (block_counter_ - last_section_index) * value_to_inc;
+  for (int section = last_section_index; section >= first_section_index;
+       --section, value_to_add += value_to_inc) {
+    numerators_[section] += value_to_add;
+  }
+
+  // Check if this update was the last coefficient of the current block. In that
+  // case, check if we are at the end of one of the sections and update the
+  // numerator of the linear regressor that is computed in such section.
+  if (++coefficients_counter_ == kFftLengthBy2) {
+    if (block_counter_ >= (kBlocksPerSection - 1)) {
+      size_t section = block_counter_ - (kBlocksPerSection - 1);
+      RTC_DCHECK_GT(numerators_.size(), section);
+      RTC_DCHECK_GT(numerators_smooth_.size(), section);
+      numerators_smooth_[section] +=
+          smoothing * (numerators_[section] - numerators_smooth_[section]);
+      n_sections_ = section + 1;
+    }
+    ++block_counter_;
+    coefficients_counter_ = 0;
+  }
+}
+
+// Estimates the size in blocks of the early reverb. The estimation is done by
+// comparing the tilt that is estimated in each section. As an optimization
+// detail and due to the fact that all the linear regressors that are computed
+// shared the same denominator, the comparison of the tilts is done by a
+// comparison of the numerator of the linear regressors.
+int ReverbDecayEstimator::EarlyReverbLengthEstimator::Estimate() {
+  constexpr float N = kBlocksPerSection * kFftLengthBy2;
+  constexpr float nn = SymmetricArithmetricSum(N);
+  // numerator_11 refers to the quantity that the linear regressor needs in the
+  // numerator for getting a decay equal to 1.1 (which is not a decay).
+  // log2(1.1) * nn / kFftLengthBy2.
+  constexpr float numerator_11 = 0.13750352374993502f * nn / kFftLengthBy2;
+  // log2(0.8) *  nn / kFftLengthBy2.
+  constexpr float numerator_08 = -0.32192809488736229f * nn / kFftLengthBy2;
+  constexpr int kNumSectionsToAnalyze = 9;
+
+  if (n_sections_ < kNumSectionsToAnalyze) {
+    return 0;
+  }
+
+  // Estimation of the blocks that correspond to early reverberations. The
+  // estimation is done by analyzing the impulse response. The portions of the
+  // impulse response whose energy is not decreasing over its coefficients are
+  // considered to be part of the early reverberations. Furthermore, the blocks
+  // where the energy is decreasing faster than what it does at the end of the
+  // impulse response are also considered to be part of the early
+  // reverberations. The estimation is limited to the first
+  // kNumSectionsToAnalyze sections.
+
+  RTC_DCHECK_LE(n_sections_, numerators_smooth_.size());
+  const float min_numerator_tail =
+      *std::min_element(numerators_smooth_.begin() + kNumSectionsToAnalyze,
+                        numerators_smooth_.begin() + n_sections_);
+  int early_reverb_size_minus_1 = 0;
+  for (int k = 0; k < kNumSectionsToAnalyze; ++k) {
+    if ((numerators_smooth_[k] > numerator_11) ||
+        (numerators_smooth_[k] < numerator_08 &&
+         numerators_smooth_[k] < 0.9f * min_numerator_tail)) {
+      early_reverb_size_minus_1 = k;
+    }
+  }
+
+  return early_reverb_size_minus_1 == 0 ? 0 : early_reverb_size_minus_1 + 1;
+}
+
+void ReverbDecayEstimator::EarlyReverbLengthEstimator::Dump(
+    ApmDataDumper* data_dumper) const {
+  data_dumper->DumpRaw("aec3_er_acum_numerator", numerators_smooth_);
+}
+
+}  // namespace webrtc
diff --git a/modules/audio_processing/aec3/reverb_decay_estimator.h b/modules/audio_processing/aec3/reverb_decay_estimator.h
new file mode 100644
index 0000000..67a84ab
--- /dev/null
+++ b/modules/audio_processing/aec3/reverb_decay_estimator.h
@@ -0,0 +1,112 @@
+/*
+ *  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_REVERB_DECAY_ESTIMATOR_H_
+#define MODULES_AUDIO_PROCESSING_AEC3_REVERB_DECAY_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"
+
+namespace webrtc {
+
+class ApmDataDumper;
+
+// Class for estimating the decay of the late reverb.
+class ReverbDecayEstimator {
+ public:
+  explicit ReverbDecayEstimator(const EchoCanceller3Config& config);
+  ~ReverbDecayEstimator();
+  // Updates the decay estimate.
+  void Update(rtc::ArrayView<const float> filter,
+              const absl::optional<float>& filter_quality,
+              int filter_delay_blocks,
+              bool usable_linear_filter,
+              bool stationary_signal);
+  // Returns the decay for the exponential model.
+  float Decay() const { return decay_; }
+  // Dumps debug data.
+  void Dump(ApmDataDumper* data_dumper) const;
+
+ private:
+  void EstimateDecay(rtc::ArrayView<const float> filter, int peak_block);
+  void AnalyzeFilter(rtc::ArrayView<const float> filter);
+
+  void ResetDecayEstimation();
+
+  // Class for estimating the decay of the late reverb from the linear filter.
+  class LateReverbLinearRegressor {
+   public:
+    // Resets the estimator to receive a specified number of data points.
+    void Reset(int num_data_points);
+    // Accumulates estimation data.
+    void Accumulate(float z);
+    // Estimates the decay.
+    float Estimate();
+    // Returns whether an estimate is available.
+    bool EstimateAvailable() const { return n_ == N_ && N_ != 0; }
+
+   public:
+    float nz_ = 0.f;
+    float nn_ = 0.f;
+    float count_ = 0.f;
+    int N_ = 0;
+    int n_ = 0;
+  };
+
+  // Class for identifying the length of the early reverb from the linear
+  // filter. For identifying the early reverberations, the impulse response is
+  // divided in sections and the tilt of each section is computed by a linear
+  // regressor.
+  class EarlyReverbLengthEstimator {
+   public:
+    explicit EarlyReverbLengthEstimator(int max_blocks);
+    ~EarlyReverbLengthEstimator();
+
+    // Resets the estimator.
+    void Reset();
+    // Accumulates estimation data.
+    void Accumulate(float value, float smoothing);
+    // Estimates the size in blocks of the early reverb.
+    int Estimate();
+    // Dumps debug data.
+    void Dump(ApmDataDumper* data_dumper) const;
+
+   private:
+    std::vector<float> numerators_smooth_;
+    std::vector<float> numerators_;
+    int coefficients_counter_;
+    int block_counter_ = 0;
+    int n_sections_ = 0;
+  };
+
+  const int filter_length_blocks_;
+  const int filter_length_coefficients_;
+  const bool use_adaptive_echo_decay_;
+  LateReverbLinearRegressor late_reverb_decay_estimator_;
+  EarlyReverbLengthEstimator early_reverb_estimator_;
+  int late_reverb_start_;
+  int late_reverb_end_;
+  int block_to_analyze_ = 0;
+  int estimation_region_candidate_size_ = 0;
+  bool estimation_region_identified_ = false;
+  std::array<float, kMaxAdaptiveFilterLength> previous_gains_;
+  float decay_;
+  float tail_gain_ = 0.f;
+  float smoothing_constant_ = 0.f;
+};
+
+}  // namespace webrtc
+
+#endif  // MODULES_AUDIO_PROCESSING_AEC3_REVERB_DECAY_ESTIMATOR_H_
diff --git a/modules/audio_processing/aec3/reverb_frequency_response.cc b/modules/audio_processing/aec3/reverb_frequency_response.cc
new file mode 100644
index 0000000..0d82515
--- /dev/null
+++ b/modules/audio_processing/aec3/reverb_frequency_response.cc
@@ -0,0 +1,111 @@
+/*
+ *  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/reverb_frequency_response.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"
+
+namespace webrtc {
+
+namespace {
+
+bool EnableSmoothUpdatesTailFreqResp() {
+  return !field_trial::IsEnabled(
+      "WebRTC-Aec3SmoothUpdatesTailFreqRespKillSwitch");
+}
+
+// Computes the ratio of the energies between the direct path and the tail. The
+// energy is computed in the power spectrum domain discarding the DC
+// contributions.
+float AverageDecayWithinFilter(
+    rtc::ArrayView<const float> freq_resp_direct_path,
+    rtc::ArrayView<const float> freq_resp_tail) {
+  // Skipping the DC for the ratio computation
+  constexpr size_t kSkipBins = 1;
+  RTC_CHECK_EQ(freq_resp_direct_path.size(), freq_resp_tail.size());
+
+  float direct_path_energy =
+      std::accumulate(freq_resp_direct_path.begin() + kSkipBins,
+                      freq_resp_direct_path.end(), 0.f);
+
+  if (direct_path_energy == 0.f) {
+    return 0.f;
+  }
+
+  float tail_energy = std::accumulate(freq_resp_tail.begin() + kSkipBins,
+                                      freq_resp_tail.end(), 0.f);
+  return tail_energy / direct_path_energy;
+}
+
+}  // namespace
+
+ReverbFrequencyResponse::ReverbFrequencyResponse()
+    : enable_smooth_tail_response_updates_(EnableSmoothUpdatesTailFreqResp()) {
+  tail_response_.fill(0.f);
+}
+ReverbFrequencyResponse::~ReverbFrequencyResponse() = default;
+
+void ReverbFrequencyResponse::Update(
+    const std::vector<std::array<float, kFftLengthBy2Plus1>>&
+        frequency_response,
+    int filter_delay_blocks,
+    const absl::optional<float>& linear_filter_quality,
+    bool stationary_block) {
+  if (!enable_smooth_tail_response_updates_) {
+    Update(frequency_response, filter_delay_blocks, 0.5f);
+    return;
+  }
+
+  if (stationary_block || !linear_filter_quality) {
+    return;
+  }
+
+  Update(frequency_response, filter_delay_blocks, *linear_filter_quality);
+}
+
+void ReverbFrequencyResponse::Update(
+    const std::vector<std::array<float, kFftLengthBy2Plus1>>&
+        frequency_response,
+    int filter_delay_blocks,
+    float linear_filter_quality) {
+  rtc::ArrayView<const float> freq_resp_tail(
+      frequency_response[frequency_response.size() - 1]);
+
+  rtc::ArrayView<const float> freq_resp_direct_path(
+      frequency_response[filter_delay_blocks]);
+
+  float average_decay =
+      AverageDecayWithinFilter(freq_resp_direct_path, freq_resp_tail);
+
+  const float smoothing = 0.2f * linear_filter_quality;
+  average_decay_ += smoothing * (average_decay - average_decay_);
+
+  for (size_t k = 0; k < kFftLengthBy2Plus1; ++k) {
+    tail_response_[k] = freq_resp_direct_path[k] * average_decay_;
+  }
+
+  for (size_t k = 1; k < kFftLengthBy2; ++k) {
+    const float avg_neighbour =
+        0.5f * (tail_response_[k - 1] + tail_response_[k + 1]);
+    tail_response_[k] = std::max(tail_response_[k], avg_neighbour);
+  }
+}
+
+}  // namespace webrtc
diff --git a/modules/audio_processing/aec3/reverb_frequency_response.h b/modules/audio_processing/aec3/reverb_frequency_response.h
new file mode 100644
index 0000000..23485e0
--- /dev/null
+++ b/modules/audio_processing/aec3/reverb_frequency_response.h
@@ -0,0 +1,55 @@
+/*
+ *  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_REVERB_FREQUENCY_RESPONSE_H_
+#define MODULES_AUDIO_PROCESSING_AEC3_REVERB_FREQUENCY_RESPONSE_H_
+
+#include <memory>
+#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 {
+
+// Class for updating the frequency response for the reverb.
+class ReverbFrequencyResponse {
+ public:
+  ReverbFrequencyResponse();
+  ~ReverbFrequencyResponse();
+
+  // Updates the frequency response estimate of the reverb.
+  void Update(const std::vector<std::array<float, kFftLengthBy2Plus1>>&
+                  frequency_response,
+              int filter_delay_blocks,
+              const absl::optional<float>& linear_filter_quality,
+              bool stationary_block);
+
+  // Returns the estimated frequency response for the reverb.
+  rtc::ArrayView<const float> FrequencyResponse() const {
+    return tail_response_;
+  }
+
+ private:
+  void Update(const std::vector<std::array<float, kFftLengthBy2Plus1>>&
+                  frequency_response,
+              int filter_delay_blocks,
+              float linear_filter_quality);
+
+  const bool enable_smooth_tail_response_updates_;
+  float average_decay_ = 0.f;
+  std::array<float, kFftLengthBy2Plus1> tail_response_;
+};
+
+}  // namespace webrtc
+
+#endif  // MODULES_AUDIO_PROCESSING_AEC3_REVERB_FREQUENCY_RESPONSE_H_
diff --git a/modules/audio_processing/aec3/reverb_model_estimator.cc b/modules/audio_processing/aec3/reverb_model_estimator.cc
index 84e8e48..ce3e2be 100644
--- a/modules/audio_processing/aec3/reverb_model_estimator.cc
+++ b/modules/audio_processing/aec3/reverb_model_estimator.cc
@@ -10,313 +10,28 @@
 
 #include "modules/audio_processing/aec3/reverb_model_estimator.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"
-
 namespace webrtc {
 
-namespace {
-
-bool EnableSmoothUpdatesTailFreqResp() {
-  return !field_trial::IsEnabled(
-      "WebRTC-Aec3SmoothUpdatesTailFreqRespKillSwitch");
-}
-
-// Computes the ratio of the energies between the direct path and the tail. The
-// energy is computed in the power spectrum domain discarding the DC
-// contributions.
-float ComputeRatioEnergies(
-    const rtc::ArrayView<const float>& freq_resp_direct_path,
-    const rtc::ArrayView<const float>& freq_resp_tail) {
-  // Skipping the DC for the ratio computation
-  constexpr size_t n_skip_bins = 1;
-  RTC_CHECK_EQ(freq_resp_direct_path.size(), freq_resp_tail.size());
-
-  float direct_path_energy =
-      std::accumulate(freq_resp_direct_path.begin() + n_skip_bins,
-                      freq_resp_direct_path.end(), 0.f);
-
-  float tail_energy = std::accumulate(freq_resp_tail.begin() + n_skip_bins,
-                                      freq_resp_tail.end(), 0.f);
-
-  if (direct_path_energy > 0) {
-    return tail_energy / direct_path_energy;
-  } else {
-    return 0.f;
-  }
-}
-
-}  // namespace
-
 ReverbModelEstimator::ReverbModelEstimator(const EchoCanceller3Config& config)
-    : filter_main_length_blocks_(config.filter.main.length_blocks),
-      reverb_decay_(std::fabs(config.ep_strength.default_len)),
-      enable_smooth_freq_resp_tail_updates_(EnableSmoothUpdatesTailFreqResp()) {
-  block_energies_.fill(0.f);
-  freq_resp_tail_.fill(0.f);
-}
+    : reverb_decay_estimator_(config) {}
 
 ReverbModelEstimator::~ReverbModelEstimator() = default;
 
-bool ReverbModelEstimator::IsAGoodFilterForDecayEstimation(
-    int filter_delay_blocks,
-    bool usable_linear_estimate,
-    size_t length_filter) {
-  if ((filter_delay_blocks && usable_linear_estimate) &&
-      (filter_delay_blocks <=
-       static_cast<int>(filter_main_length_blocks_) - 4) &&
-      (length_filter >=
-       static_cast<size_t>(GetTimeDomainLength(filter_main_length_blocks_)))) {
-    return true;
-  } else {
-    return false;
-  }
-}
-
 void ReverbModelEstimator::Update(
-    const std::vector<float>& impulse_response,
+    rtc::ArrayView<const float> impulse_response,
     const std::vector<std::array<float, kFftLengthBy2Plus1>>&
-        filter_freq_response,
-    const absl::optional<float>& quality_linear,
+        frequency_response,
+    const absl::optional<float>& linear_filter_quality,
     int filter_delay_blocks,
     bool usable_linear_estimate,
-    float default_decay,
     bool stationary_block) {
-  if (enable_smooth_freq_resp_tail_updates_) {
-    if (!stationary_block) {
-      float alpha = 0;
-      if (quality_linear) {
-        alpha = 0.2f * quality_linear.value();
-        UpdateFreqRespTail(filter_freq_response, filter_delay_blocks, alpha);
-      }
-      if (IsAGoodFilterForDecayEstimation(filter_delay_blocks,
-                                          usable_linear_estimate,
-                                          impulse_response.size())) {
-        alpha_ = std::max(alpha, alpha_);
-        if ((alpha_ > 0.f) && (default_decay < 0.f)) {
-          // Echo tail decay estimation if default_decay is negative.
-          UpdateReverbDecay(impulse_response);
-        }
-      } else {
-        ResetDecayEstimation();
-      }
-    }
-  } else {
-    UpdateFreqRespTail(filter_freq_response, filter_delay_blocks, 0.1f);
-  }
+  // Estimate the frequency response for the reverb.
+  reverb_frequency_response_.Update(frequency_response, filter_delay_blocks,
+                                    linear_filter_quality, stationary_block);
+
+  // Estimate the reverb decay,
+  reverb_decay_estimator_.Update(impulse_response, linear_filter_quality,
+                                 filter_delay_blocks, usable_linear_estimate,
+                                 stationary_block);
 }
-
-void ReverbModelEstimator::ResetDecayEstimation() {
-  accumulated_nz_ = 0.f;
-  accumulated_nn_ = 0.f;
-  accumulated_count_ = 0.f;
-  current_reverb_decay_section_ = 0;
-  num_reverb_decay_sections_ = 0;
-  num_reverb_decay_sections_next_ = 0;
-  found_end_of_reverb_decay_ = false;
-  alpha_ = 0.f;
-}
-
-void ReverbModelEstimator::UpdateReverbDecay(
-    const std::vector<float>& impulse_response) {
-  constexpr float kOneByFftLengthBy2 = 1.f / kFftLengthBy2;
-
-  // Form the data to match against by squaring the impulse response
-  // coefficients.
-  std::array<float, GetTimeDomainLength(kMaxAdaptiveFilterLength)>
-      matching_data_data;
-  RTC_DCHECK_LE(GetTimeDomainLength(filter_main_length_blocks_),
-                matching_data_data.size());
-  rtc::ArrayView<float> matching_data(
-      matching_data_data.data(),
-      GetTimeDomainLength(filter_main_length_blocks_));
-  std::transform(
-      impulse_response.begin(), impulse_response.end(), matching_data.begin(),
-      [](float a) { return a * a; });  // TODO(devicentepena) check if focusing
-                                       // on one block would be enough.
-
-  if (current_reverb_decay_section_ < filter_main_length_blocks_) {
-    // Update accumulated variables for the current filter section.
-
-    const size_t start_index = current_reverb_decay_section_ * kFftLengthBy2;
-
-    RTC_DCHECK_GT(matching_data.size(), start_index);
-    RTC_DCHECK_GE(matching_data.size(), start_index + kFftLengthBy2);
-    float section_energy =
-        std::accumulate(matching_data.begin() + start_index,
-                        matching_data.begin() + start_index + kFftLengthBy2,
-                        0.f) *
-        kOneByFftLengthBy2;
-
-    section_energy = std::max(
-        section_energy, 1e-32f);  // Regularization to avoid division by 0.
-
-    RTC_DCHECK_LT(current_reverb_decay_section_, block_energies_.size());
-    const float energy_ratio =
-        block_energies_[current_reverb_decay_section_] / section_energy;
-
-    found_end_of_reverb_decay_ = found_end_of_reverb_decay_ ||
-                                 (energy_ratio > 1.1f || energy_ratio < 0.9f);
-
-    // Count consecutive number of "good" filter sections, where "good" means:
-    // 1) energy is above noise floor.
-    // 2) energy of current section has not changed too much from last check.
-    if (!found_end_of_reverb_decay_ && section_energy > tail_energy_) {
-      ++num_reverb_decay_sections_next_;
-    } else {
-      found_end_of_reverb_decay_ = true;
-    }
-
-    block_energies_[current_reverb_decay_section_] = section_energy;
-
-    if (num_reverb_decay_sections_ > 0) {
-      // Linear regression of log squared magnitude of impulse response.
-      for (size_t i = 0; i < kFftLengthBy2; i++) {
-        RTC_DCHECK_GT(matching_data.size(), start_index + i);
-        float z = FastApproxLog2f(matching_data[start_index + i] + 1e-10);
-        accumulated_nz_ += accumulated_count_ * z;
-        ++accumulated_count_;
-      }
-    }
-
-    num_reverb_decay_sections_ =
-        num_reverb_decay_sections_ > 0 ? num_reverb_decay_sections_ - 1 : 0;
-    ++current_reverb_decay_section_;
-
-  } else {
-    constexpr float kMaxDecay = 0.95f;  // ~1 sec min RT60.
-    constexpr float kMinDecay = 0.02f;  // ~15 ms max RT60.
-
-    // Accumulated variables throughout whole filter.
-
-    // Solve for decay rate.
-
-    float decay = reverb_decay_;
-
-    if (accumulated_nn_ != 0.f) {
-      const float exp_candidate = -accumulated_nz_ / accumulated_nn_;
-      decay = std::pow(2.0f, -exp_candidate * kFftLengthBy2);
-      decay = std::min(decay, kMaxDecay);
-      decay = std::max(decay, kMinDecay);
-    }
-
-    // Filter tail energy (assumed to be noise).
-    constexpr size_t kTailLength = kFftLengthBy2;
-
-    constexpr float k1ByTailLength = 1.f / kTailLength;
-    const size_t tail_index =
-        GetTimeDomainLength(filter_main_length_blocks_) - kTailLength;
-
-    RTC_DCHECK_GT(matching_data.size(), tail_index);
-
-    tail_energy_ = std::accumulate(matching_data.begin() + tail_index,
-                                   matching_data.end(), 0.f) *
-                   k1ByTailLength;
-
-    // Update length of decay.
-    num_reverb_decay_sections_ = num_reverb_decay_sections_next_;
-    num_reverb_decay_sections_next_ = 0;
-    // Must have enough data (number of sections) in order
-    // to estimate decay rate.
-    if (num_reverb_decay_sections_ < 5) {
-      num_reverb_decay_sections_ = 0;
-    }
-
-    const float N = num_reverb_decay_sections_ * kFftLengthBy2;
-    accumulated_nz_ = 0.f;
-    const float k1By12 = 1.f / 12.f;
-    // Arithmetic sum $2 \sum_{i=0.5}^{(N-1)/2}i^2$ calculated directly.
-    accumulated_nn_ = N * (N * N - 1.0f) * k1By12;
-    accumulated_count_ = -N * 0.5f;
-    // Linear regression approach assumes symmetric index around 0.
-    accumulated_count_ += 0.5f;
-
-    // Identify the peak index of the impulse response.
-    const size_t peak_index = std::distance(
-        matching_data.begin(),
-        std::max_element(matching_data.begin(), matching_data.end()));
-
-    current_reverb_decay_section_ = peak_index * kOneByFftLengthBy2 + 3;
-    // Make sure we're not out of bounds.
-    if (current_reverb_decay_section_ + 1 >= filter_main_length_blocks_) {
-      current_reverb_decay_section_ = filter_main_length_blocks_;
-    }
-    size_t start_index = current_reverb_decay_section_ * kFftLengthBy2;
-    float first_section_energy =
-        std::accumulate(matching_data.begin() + start_index,
-                        matching_data.begin() + start_index + kFftLengthBy2,
-                        0.f) *
-        kOneByFftLengthBy2;
-
-    // To estimate the reverb decay, the energy of the first filter section
-    // must be substantially larger than the last.
-    // Also, the first filter section energy must not deviate too much
-    // from the max peak.
-    bool main_filter_has_reverb = first_section_energy > 4.f * tail_energy_;
-    bool main_filter_is_sane = first_section_energy > 2.f * tail_energy_ &&
-                               matching_data[peak_index] < 100.f;
-
-    // Not detecting any decay, but tail is over noise - assume max decay.
-    if (num_reverb_decay_sections_ == 0 && main_filter_is_sane &&
-        main_filter_has_reverb) {
-      decay = kMaxDecay;
-    }
-
-    if (main_filter_is_sane && num_reverb_decay_sections_ > 0) {
-      decay = std::max(.97f * reverb_decay_, decay);
-      reverb_decay_ -= alpha_ * (reverb_decay_ - decay);
-    }
-
-    found_end_of_reverb_decay_ =
-        !(main_filter_is_sane && main_filter_has_reverb);
-    alpha_ = 0.f;  // Stop estimation of the decay until another good filter is
-                   // received
-  }
-}
-
-// Updates the estimation of the frequency response at the filter tail.
-void ReverbModelEstimator::UpdateFreqRespTail(
-    const std::vector<std::array<float, kFftLengthBy2Plus1>>&
-        filter_freq_response,
-    int filter_delay_blocks,
-    float alpha) {
-  size_t num_blocks = filter_freq_response.size();
-  rtc::ArrayView<const float> freq_resp_tail(
-      filter_freq_response[num_blocks - 1]);
-  rtc::ArrayView<const float> freq_resp_direct_path(
-      filter_freq_response[filter_delay_blocks]);
-  float ratio_energies =
-      ComputeRatioEnergies(freq_resp_direct_path, freq_resp_tail);
-  ratio_tail_to_direct_path_ +=
-      alpha * (ratio_energies - ratio_tail_to_direct_path_);
-
-  for (size_t k = 0; k < kFftLengthBy2Plus1; ++k) {
-    freq_resp_tail_[k] = freq_resp_direct_path[k] * ratio_tail_to_direct_path_;
-  }
-
-  for (size_t k = 1; k < kFftLengthBy2; ++k) {
-    float avg_neighbour =
-        0.5f * (freq_resp_tail_[k - 1] + freq_resp_tail_[k + 1]);
-    freq_resp_tail_[k] = std::max(freq_resp_tail_[k], avg_neighbour);
-  }
-}
-
-void ReverbModelEstimator::Dump(
-    const std::unique_ptr<ApmDataDumper>& data_dumper) {
-  data_dumper->DumpRaw("aec3_reverb_decay", reverb_decay_);
-  data_dumper->DumpRaw("aec3_reverb_tail_energy", tail_energy_);
-  data_dumper->DumpRaw("aec3_reverb_alpha", alpha_);
-  data_dumper->DumpRaw("aec3_num_reverb_decay_sections",
-                       static_cast<int>(num_reverb_decay_sections_));
-}
-
 }  // namespace webrtc
diff --git a/modules/audio_processing/aec3/reverb_model_estimator.h b/modules/audio_processing/aec3/reverb_model_estimator.h
index d2015aa..b6a3591 100644
--- a/modules/audio_processing/aec3/reverb_model_estimator.h
+++ b/modules/audio_processing/aec3/reverb_model_estimator.h
@@ -11,72 +11,49 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_REVERB_MODEL_ESTIMATOR_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_REVERB_MODEL_ESTIMATOR_H_
 
-#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/logging/apm_data_dumper.h"
+#include "modules/audio_processing/aec3/reverb_decay_estimator.h"
+#include "modules/audio_processing/aec3/reverb_frequency_response.h"
 
 namespace webrtc {
 
-// The ReverbModelEstimator class describes an estimator of the parameters
-// that are used for the reverberant model.
+class ApmDataDumper;
+
+// Class for estimating the model parameters for the reverberant echo.
 class ReverbModelEstimator {
  public:
   explicit ReverbModelEstimator(const EchoCanceller3Config& config);
   ~ReverbModelEstimator();
-  // Updates the model.
-  void Update(const std::vector<float>& impulse_response,
+
+  // Updates the estimates based on new data.
+  void Update(rtc::ArrayView<const float> impulse_response,
               const std::vector<std::array<float, kFftLengthBy2Plus1>>&
-                  filter_freq_response,
-              const absl::optional<float>& quality_linear,
+                  frequency_response,
+              const absl::optional<float>& linear_filter_quality,
               int filter_delay_blocks,
               bool usable_linear_estimate,
-              float default_decay,
               bool stationary_block);
-  // Returns the decay for the exponential model.
-  float ReverbDecay() const { return reverb_decay_; }
 
-  void Dump(const std::unique_ptr<ApmDataDumper>& data_dumper);
+  // Returns the exponential decay of the reverberant echo.
+  float ReverbDecay() const { return reverb_decay_estimator_.Decay(); }
 
-  // Return the estimated freq. response of the tail of the filter.
-  rtc::ArrayView<const float> GetFreqRespTail() const {
-    return freq_resp_tail_;
+  // Return the frequency response of the reverberant echo.
+  rtc::ArrayView<const float> GetReverbFrequencyResponse() const {
+    return reverb_frequency_response_.FrequencyResponse();
+  }
+
+  // Dumps debug data.
+  void Dump(ApmDataDumper* data_dumper) const {
+    reverb_decay_estimator_.Dump(data_dumper);
   }
 
  private:
-  bool IsAGoodFilterForDecayEstimation(int filter_delay_blocks,
-                                       bool usable_linear_estimate,
-                                       size_t length_filter);
-  void UpdateReverbDecay(const std::vector<float>& impulse_response);
-
-  void UpdateFreqRespTail(
-      const std::vector<std::array<float, kFftLengthBy2Plus1>>&
-          filter_freq_response,
-      int filter_delay_blocks,
-      float alpha);
-
-  void ResetDecayEstimation();
-
-  const size_t filter_main_length_blocks_;
-
-  float accumulated_nz_ = 0.f;
-  float accumulated_nn_ = 0.f;
-  float accumulated_count_ = 0.f;
-  size_t current_reverb_decay_section_ = 0;
-  size_t num_reverb_decay_sections_ = 0;
-  size_t num_reverb_decay_sections_next_ = 0;
-  bool found_end_of_reverb_decay_ = false;
-  std::array<float, kMaxAdaptiveFilterLength> block_energies_;
-  float reverb_decay_;
-  float tail_energy_ = 0.f;
-  float alpha_ = 0.f;
-  std::array<float, kFftLengthBy2Plus1> freq_resp_tail_;
-  float ratio_tail_to_direct_path_ = 0.f;
-  bool enable_smooth_freq_resp_tail_updates_;
+  ReverbDecayEstimator reverb_decay_estimator_;
+  ReverbFrequencyResponse reverb_frequency_response_;
 };
 
 }  // namespace webrtc
diff --git a/modules/audio_processing/aec3/reverb_model_estimator_unittest.cc b/modules/audio_processing/aec3/reverb_model_estimator_unittest.cc
index 9667f4f..aa5e96f 100644
--- a/modules/audio_processing/aec3/reverb_model_estimator_unittest.cc
+++ b/modules/audio_processing/aec3/reverb_model_estimator_unittest.cc
@@ -29,16 +29,16 @@
 class ReverbModelEstimatorTest {
  public:
   explicit ReverbModelEstimatorTest(float default_decay)
-      : default_decay_(default_decay),
-        estimated_decay_(default_decay),
-        h_(aec3_config_.filter.main.length_blocks * kBlockSize, 0.f),
-        H2_(aec3_config_.filter.main.length_blocks) {
+      : default_decay_(default_decay), estimated_decay_(default_decay) {
     aec3_config_.ep_strength.default_len = default_decay_;
+    aec3_config_.filter.main.length_blocks = 40;
+    h_.resize(aec3_config_.filter.main.length_blocks * kBlockSize);
+    H2_.resize(aec3_config_.filter.main.length_blocks);
     CreateImpulseResponseWithDecay();
   }
   void RunEstimator();
   float GetDecay() { return estimated_decay_; }
-  float GetTrueDecay() { return true_power_decay_; }
+  float GetTrueDecay() { return kTruePowerDecay; }
   float GetPowerTailDb() { return 10.f * log10(estimated_power_tail_); }
   float GetTruePowerTailDb() { return 10.f * log10(true_power_tail_); }
 
@@ -46,10 +46,10 @@
   void CreateImpulseResponseWithDecay();
 
   absl::optional<float> quality_linear_ = 1.0f;
-  static constexpr int filter_delay_blocks_ = 2;
-  static constexpr bool usable_linear_estimate_ = true;
-  static constexpr bool stationary_block_ = false;
-  static constexpr float true_power_decay_ = 0.5f;
+  static constexpr int kFilterDelayBlocks = 2;
+  static constexpr bool kUsableLinearEstimate = true;
+  static constexpr bool kStationaryBlock = false;
+  static constexpr float kTruePowerDecay = 0.5f;
   EchoCanceller3Config aec3_config_;
   float default_decay_;
   float estimated_decay_;
@@ -63,43 +63,35 @@
   const Aec3Fft fft;
   RTC_DCHECK_EQ(h_.size(), aec3_config_.filter.main.length_blocks * kBlockSize);
   RTC_DCHECK_EQ(H2_.size(), aec3_config_.filter.main.length_blocks);
-  RTC_DCHECK_EQ(filter_delay_blocks_, 2);
-  const float peak = 1.0f;
-  float decay_power_sample = std::sqrt(true_power_decay_);
-  for (size_t k = 1; k < kBlockSizeLog2; k++) {
-    decay_power_sample = std::sqrt(decay_power_sample);
-  }
-  h_[filter_delay_blocks_ * kBlockSize] = peak;
-  for (size_t k = filter_delay_blocks_ * kBlockSize + 1; k < h_.size(); ++k) {
-    h_[k] = h_[k - 1] * std::sqrt(decay_power_sample);
+  RTC_DCHECK_EQ(kFilterDelayBlocks, 2);
+
+  float decay_sample = std::sqrt(powf(kTruePowerDecay, 1.f / kBlockSize));
+  const size_t filter_delay_coefficients = kFilterDelayBlocks * kBlockSize;
+  std::fill(h_.begin(), h_.end(), 0.f);
+  h_[filter_delay_coefficients] = 1.f;
+  for (size_t k = filter_delay_coefficients + 1; k < h_.size(); ++k) {
+    h_[k] = h_[k - 1] * decay_sample;
   }
 
-  for (size_t block = 0; block < H2_.size(); ++block) {
-    std::array<float, kFftLength> h_block;
-    h_block.fill(0.f);
-    FftData H_block;
-    rtc::ArrayView<float> H2_block(H2_[block]);
-    std::copy(h_.begin() + block * kBlockSize,
-              h_.begin() + block * (kBlockSize + 1), h_block.begin());
-
-    fft.Fft(&h_block, &H_block);
-    for (size_t k = 0; k < H2_block.size(); ++k) {
-      H2_block[k] =
-          H_block.re[k] * H_block.re[k] + H_block.im[k] * H_block.im[k];
-    }
+  std::array<float, kFftLength> fft_data;
+  FftData H_j;
+  for (size_t j = 0, k = 0; j < H2_.size(); ++j, k += kBlockSize) {
+    fft_data.fill(0.f);
+    std::copy(h_.begin() + k, h_.begin() + k + kBlockSize, fft_data.begin());
+    fft.Fft(&fft_data, &H_j);
+    H_j.Spectrum(Aec3Optimization::kNone, H2_[j]);
   }
   rtc::ArrayView<float> H2_tail(H2_[H2_.size() - 1]);
   true_power_tail_ = std::accumulate(H2_tail.begin(), H2_tail.end(), 0.f);
 }
 void ReverbModelEstimatorTest::RunEstimator() {
   ReverbModelEstimator estimator(aec3_config_);
-  for (size_t k = 0; k < 1000; ++k) {
-    estimator.Update(h_, H2_, quality_linear_, filter_delay_blocks_,
-                     usable_linear_estimate_, default_decay_,
-                     stationary_block_);
+  for (size_t k = 0; k < 3000; ++k) {
+    estimator.Update(h_, H2_, quality_linear_, kFilterDelayBlocks,
+                     kUsableLinearEstimate, kStationaryBlock);
   }
   estimated_decay_ = estimator.ReverbDecay();
-  rtc::ArrayView<const float> freq_resp_tail = estimator.GetFreqRespTail();
+  auto freq_resp_tail = estimator.GetReverbFrequencyResponse();
   estimated_power_tail_ =
       std::accumulate(freq_resp_tail.begin(), freq_resp_tail.end(), 0.f);
 }
diff --git a/modules/audio_processing/aec3/subtractor.cc b/modules/audio_processing/aec3/subtractor.cc
index 614034b..609e8ac 100644
--- a/modules/audio_processing/aec3/subtractor.cc
+++ b/modules/audio_processing/aec3/subtractor.cc
@@ -128,12 +128,6 @@
       G_shadow_(config_.filter.shadow_initial,
                 config.filter.config_change_duration_blocks) {
   RTC_DCHECK(data_dumper_);
-  // Currently, the rest of AEC3 requires the main and shadow filter lengths to
-  // be identical.
-  RTC_DCHECK_EQ(config_.filter.main.length_blocks,
-                config_.filter.shadow.length_blocks);
-  RTC_DCHECK_EQ(config_.filter.main_initial.length_blocks,
-                config_.filter.shadow_initial.length_blocks);
 }
 
 Subtractor::~Subtractor() = default;
@@ -159,8 +153,6 @@
   }
 
   if (echo_path_variability.gain_change && enable_agc_gain_change_response_) {
-    RTC_LOG(LS_WARNING) << "Resetting main filter adaptation speed due to "
-                           "microphone gain change";
     G_main_.HandleEchoPathChange(echo_path_variability);
   }
 }
@@ -222,11 +214,28 @@
   E_shadow.Spectrum(optimization_, output->E2_shadow);
   E_main.Spectrum(optimization_, output->E2_main);
 
+  // Compute the render powers.
+  std::array<float, kFftLengthBy2Plus1> X2_main;
+  std::array<float, kFftLengthBy2Plus1> X2_shadow_data;
+  std::array<float, kFftLengthBy2Plus1>& X2_shadow =
+      main_filter_.SizePartitions() == shadow_filter_.SizePartitions()
+          ? X2_main
+          : X2_shadow_data;
+  if (main_filter_.SizePartitions() == shadow_filter_.SizePartitions()) {
+    render_buffer.SpectralSum(main_filter_.SizePartitions(), &X2_main);
+  } else if (main_filter_.SizePartitions() > shadow_filter_.SizePartitions()) {
+    render_buffer.SpectralSums(shadow_filter_.SizePartitions(),
+                               main_filter_.SizePartitions(), &X2_shadow,
+                               &X2_main);
+  } else {
+    render_buffer.SpectralSums(main_filter_.SizePartitions(),
+                               shadow_filter_.SizePartitions(), &X2_main,
+                               &X2_shadow);
+  }
+
   // Update the main filter.
-  std::array<float, kFftLengthBy2Plus1> X2;
-  render_buffer.SpectralSum(main_filter_.SizePartitions(), &X2);
   if (!main_filter_adjusted) {
-    G_main_.Compute(X2, render_signal_analyzer, *output, main_filter_,
+    G_main_.Compute(X2_main, render_signal_analyzer, *output, main_filter_,
                     aec_state.SaturatedCapture() || main_saturation, &G);
   } else {
     G.re.fill(0.f);
@@ -244,19 +253,15 @@
        (poor_shadow_filter_counter_ < 10 &&
         !enable_early_shadow_filter_jumpstart_)) ||
       !enable_shadow_filter_jumpstart_) {
-    if (shadow_filter_.SizePartitions() != main_filter_.SizePartitions()) {
-      render_buffer.SpectralSum(shadow_filter_.SizePartitions(), &X2);
-    }
-    G_shadow_.Compute(X2, render_signal_analyzer, E_shadow,
+    G_shadow_.Compute(X2_shadow, render_signal_analyzer, E_shadow,
                       shadow_filter_.SizePartitions(),
                       aec_state.SaturatedCapture() || shadow_saturation, &G);
     shadow_filter_.Adapt(render_buffer, G);
   } else {
     poor_shadow_filter_counter_ = 0;
-
     if (enable_shadow_filter_boosted_jumpstart_) {
       shadow_filter_.SetFilter(main_filter_.GetFilter());
-      G_shadow_.Compute(X2, render_signal_analyzer, E_main,
+      G_shadow_.Compute(X2_shadow, render_signal_analyzer, E_main,
                         shadow_filter_.SizePartitions(),
                         aec_state.SaturatedCapture() || main_saturation, &G);
       shadow_filter_.Adapt(render_buffer, G);
@@ -277,6 +282,11 @@
     std::for_each(e_main.begin(), e_main.end(),
                   [](float& a) { a = rtc::SafeClamp(a, -32768.f, 32767.f); });
   }
+
+  data_dumper_->DumpWav("aec3_main_filter_output", kBlockSize, &e_main[0],
+                        16000, 1);
+  data_dumper_->DumpWav("aec3_shadow_filter_output", kBlockSize, &e_shadow[0],
+                        16000, 1);
 }
 
 void Subtractor::FilterMisadjustmentEstimator::Update(
diff --git a/modules/audio_processing/aec3/subtractor_output_analyzer.cc b/modules/audio_processing/aec3/subtractor_output_analyzer.cc
index 93675f5..3cacb45 100644
--- a/modules/audio_processing/aec3/subtractor_output_analyzer.cc
+++ b/modules/audio_processing/aec3/subtractor_output_analyzer.cc
@@ -36,19 +36,16 @@
   constexpr float kConvergenceThreshold = 50 * 50 * kBlockSize;
   main_filter_converged_ = e2_main < 0.5f * y2 && y2 > kConvergenceThreshold;
   shadow_filter_converged_ =
-      e2_shadow < 0.05 * y2 && y2 > kConvergenceThreshold;
+      e2_shadow < 0.05f * y2 && y2 > kConvergenceThreshold;
   float min_e2 =
       strict_divergence_check_ ? std::min(e2_main, e2_shadow) : e2_main;
   filter_diverged_ = min_e2 > 1.5f * y2 && y2 > 30.f * 30.f * kBlockSize;
-  filter_severely_diverged_ =
-      min_e2 > 1.5f * y2 && y2 > 200.f * 200.f * kBlockSize;
 }
 
 void SubtractorOutputAnalyzer::HandleEchoPathChange() {
   shadow_filter_converged_ = false;
   main_filter_converged_ = false;
   filter_diverged_ = false;
-  filter_severely_diverged_ = false;
 }
 
 }  // namespace webrtc
diff --git a/modules/audio_processing/aec3/subtractor_output_analyzer.h b/modules/audio_processing/aec3/subtractor_output_analyzer.h
index b9a2445..b59a68e 100644
--- a/modules/audio_processing/aec3/subtractor_output_analyzer.h
+++ b/modules/audio_processing/aec3/subtractor_output_analyzer.h
@@ -30,7 +30,6 @@
   }
 
   bool DivergedFilter() const { return filter_diverged_; }
-  bool SeverelyDivergedFilter() const { return filter_severely_diverged_; }
 
   // Handle echo path change.
   void HandleEchoPathChange();
@@ -40,7 +39,6 @@
   bool shadow_filter_converged_ = false;
   bool main_filter_converged_ = false;
   bool filter_diverged_ = false;
-  bool filter_severely_diverged_ = false;
 };
 
 }  // namespace webrtc
diff --git a/modules/audio_processing/aec3/subtractor_unittest.cc b/modules/audio_processing/aec3/subtractor_unittest.cc
index 35abf1c..7791805 100644
--- a/modules/audio_processing/aec3/subtractor_unittest.cc
+++ b/modules/audio_processing/aec3/subtractor_unittest.cc
@@ -25,13 +25,15 @@
 
 float RunSubtractorTest(int num_blocks_to_process,
                         int delay_samples,
-                        int filter_length_blocks,
+                        int main_filter_length_blocks,
+                        int shadow_filter_length_blocks,
                         bool uncorrelated_inputs,
                         const std::vector<int>& blocks_with_echo_path_changes) {
   ApmDataDumper data_dumper(42);
   EchoCanceller3Config config;
-  config.filter.main.length_blocks = config.filter.shadow.length_blocks =
-      filter_length_blocks;
+  config.filter.main.length_blocks = main_filter_length_blocks;
+  config.filter.shadow.length_blocks = shadow_filter_length_blocks;
+
   Subtractor subtractor(config, &data_dumper, DetectOptimization());
   absl::optional<DelayEstimate> delay_estimate;
   std::vector<std::vector<float>> x(3, std::vector<float>(kBlockSize, 0.f));
@@ -160,9 +162,9 @@
     for (size_t delay_samples : {0, 64, 150, 200, 301}) {
       SCOPED_TRACE(ProduceDebugText(delay_samples, filter_length_blocks));
 
-      float echo_to_nearend_power =
-          RunSubtractorTest(400, delay_samples, filter_length_blocks, false,
-                            blocks_with_echo_path_changes);
+      float echo_to_nearend_power = RunSubtractorTest(
+          400, delay_samples, filter_length_blocks, filter_length_blocks, false,
+          blocks_with_echo_path_changes);
 
       // Use different criteria to take overmodelling into account.
       if (filter_length_blocks == 12) {
@@ -174,6 +176,24 @@
   }
 }
 
+// Verifies that the subtractor is able to handle the case when the main filter
+// is longer than the shadow filter.
+TEST(Subtractor, MainFilterLongerThanShadowFilter) {
+  std::vector<int> blocks_with_echo_path_changes;
+  float echo_to_nearend_power =
+      RunSubtractorTest(400, 64, 20, 15, false, blocks_with_echo_path_changes);
+  EXPECT_GT(0.5f, echo_to_nearend_power);
+}
+
+// Verifies that the subtractor is able to handle the case when the shadow
+// filter is longer than the main filter.
+TEST(Subtractor, ShadowFilterLongerThanMainFilter) {
+  std::vector<int> blocks_with_echo_path_changes;
+  float echo_to_nearend_power =
+      RunSubtractorTest(400, 64, 15, 20, false, blocks_with_echo_path_changes);
+  EXPECT_GT(0.5f, echo_to_nearend_power);
+}
+
 // Verifies that the subtractor does not converge on uncorrelated signals.
 TEST(Subtractor, NonConvergenceOnUncorrelatedSignals) {
   std::vector<int> blocks_with_echo_path_changes;
@@ -181,9 +201,9 @@
     for (size_t delay_samples : {0, 64, 150, 200, 301}) {
       SCOPED_TRACE(ProduceDebugText(delay_samples, filter_length_blocks));
 
-      float echo_to_nearend_power =
-          RunSubtractorTest(300, delay_samples, filter_length_blocks, true,
-                            blocks_with_echo_path_changes);
+      float echo_to_nearend_power = RunSubtractorTest(
+          300, delay_samples, filter_length_blocks, filter_length_blocks, true,
+          blocks_with_echo_path_changes);
       EXPECT_NEAR(1.f, echo_to_nearend_power, 0.1);
     }
   }
@@ -198,9 +218,9 @@
     for (size_t delay_samples : {0, 64, 150, 200, 301}) {
       SCOPED_TRACE(ProduceDebugText(delay_samples, filter_length_blocks));
 
-      float echo_to_nearend_power =
-          RunSubtractorTest(100, delay_samples, filter_length_blocks, false,
-                            blocks_with_echo_path_changes);
+      float echo_to_nearend_power = RunSubtractorTest(
+          100, delay_samples, filter_length_blocks, filter_length_blocks, false,
+          blocks_with_echo_path_changes);
       EXPECT_NEAR(1.f, echo_to_nearend_power, 0.0000001f);
     }
   }
diff --git a/modules/audio_processing/aec3/suppression_gain.cc b/modules/audio_processing/aec3/suppression_gain.cc
index 846836d..c389a6a 100644
--- a/modules/audio_processing/aec3/suppression_gain.cc
+++ b/modules/audio_processing/aec3/suppression_gain.cc
@@ -1,4 +1,3 @@
-
 /*
  *  Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
  *
@@ -11,10 +10,6 @@
 
 #include "modules/audio_processing/aec3/suppression_gain.h"
 
-#include "typedefs.h"  // NOLINT(build/include)
-#if defined(WEBRTC_ARCH_X86_FAMILY)
-#include <emmintrin.h>
-#endif
 #include <math.h>
 #include <algorithm>
 #include <functional>
@@ -30,11 +25,6 @@
 namespace webrtc {
 namespace {
 
-bool EnableTransparencyImprovements() {
-  return !field_trial::IsEnabled(
-      "WebRTC-Aec3TransparencyImprovementsKillSwitch");
-}
-
 bool EnableNewSuppression() {
   return !field_trial::IsEnabled("WebRTC-Aec3NewSuppressionKillSwitch");
 }
@@ -57,60 +47,6 @@
   (*gain)[kFftLengthBy2] = (*gain)[kFftLengthBy2Minus1];
 }
 
-// Computes the gain to apply for the bands beyond the first band.
-float UpperBandsGain(
-    const absl::optional<int>& narrow_peak_band,
-    bool saturated_echo,
-    const std::vector<std::vector<float>>& render,
-    const std::array<float, kFftLengthBy2Plus1>& low_band_gain) {
-  RTC_DCHECK_LT(0, render.size());
-  if (render.size() == 1) {
-    return 1.f;
-  }
-
-  if (narrow_peak_band &&
-      (*narrow_peak_band > static_cast<int>(kFftLengthBy2Plus1 - 10))) {
-    return 0.001f;
-  }
-
-  constexpr size_t kLowBandGainLimit = kFftLengthBy2 / 2;
-  const float gain_below_8_khz = *std::min_element(
-      low_band_gain.begin() + kLowBandGainLimit, low_band_gain.end());
-
-  // Always attenuate the upper bands when there is saturated echo.
-  if (saturated_echo) {
-    return std::min(0.001f, gain_below_8_khz);
-  }
-
-  // Compute the upper and lower band energies.
-  const auto sum_of_squares = [](float a, float b) { return a + b * b; };
-  const float low_band_energy =
-      std::accumulate(render[0].begin(), render[0].end(), 0.f, sum_of_squares);
-  float high_band_energy = 0.f;
-  for (size_t k = 1; k < render.size(); ++k) {
-    const float energy = std::accumulate(render[k].begin(), render[k].end(),
-                                         0.f, sum_of_squares);
-    high_band_energy = std::max(high_band_energy, energy);
-  }
-
-  // If there is more power in the lower frequencies than the upper frequencies,
-  // or if the power in upper frequencies is low, do not bound the gain in the
-  // upper bands.
-  float anti_howling_gain;
-  constexpr float kThreshold = kBlockSize * 10.f * 10.f / 4.f;
-  if (high_band_energy < std::max(low_band_energy, kThreshold)) {
-    anti_howling_gain = 1.f;
-  } else {
-    // In all other cases, bound the gain for upper frequencies.
-    RTC_DCHECK_LE(low_band_energy, high_band_energy);
-    RTC_DCHECK_NE(0.f, high_band_energy);
-    anti_howling_gain = 0.01f * sqrtf(low_band_energy / high_band_energy);
-  }
-
-  // Choose the gain as the minimum of the lower and upper gains.
-  return std::min(gain_below_8_khz, anti_howling_gain);
-}
-
 // Scales the echo according to assessed audibility at the other end.
 void WeightEchoForAudibility(const EchoCanceller3Config& config,
                              rtc::ArrayView<const float> echo,
@@ -159,7 +95,6 @@
     bool low_noise_render,
     bool saturated_echo,
     bool linear_echo_estimate,
-    bool enable_transparency_improvements,
     const std::array<float, kFftLengthBy2Plus1>& nearend,
     const std::array<float, kFftLengthBy2Plus1>& weighted_echo,
     const std::array<float, kFftLengthBy2Plus1>& masker,
@@ -181,10 +116,7 @@
   RTC_DCHECK_GT(1.f, nearend_masking_margin);
 
   const float masker_margin =
-      linear_echo_estimate
-          ? (enable_transparency_improvements ? config.gain_mask.m0
-                                              : config.gain_mask.m1)
-          : config.gain_mask.m8;
+      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
@@ -211,54 +143,6 @@
 // TODO(peah): Make adaptive to take the actual filter error into account.
 constexpr size_t kUpperAccurateBandPlus1 = 29;
 
-// Computes the signal output power that masks the echo signal.
-void MaskingPower(const EchoCanceller3Config& config,
-                  bool enable_transparency_improvements,
-                  const std::array<float, kFftLengthBy2Plus1>& nearend,
-                  const std::array<float, kFftLengthBy2Plus1>& comfort_noise,
-                  const std::array<float, kFftLengthBy2Plus1>& last_masker,
-                  const std::array<float, kFftLengthBy2Plus1>& gain,
-                  std::array<float, kFftLengthBy2Plus1>* masker) {
-  if (enable_transparency_improvements) {
-    std::copy(comfort_noise.begin(), comfort_noise.end(), masker->begin());
-    return;
-  }
-
-  // Apply masking over time.
-  float masking_factor = config.gain_mask.temporal_masking_lf;
-  auto limit = config.gain_mask.temporal_masking_lf_bands;
-  std::transform(
-      comfort_noise.begin(), comfort_noise.begin() + limit, last_masker.begin(),
-      masker->begin(),
-      [masking_factor](float a, float b) { return a + masking_factor * b; });
-  masking_factor = config.gain_mask.temporal_masking_hf;
-  std::transform(
-      comfort_noise.begin() + limit, comfort_noise.end(),
-      last_masker.begin() + limit, masker->begin() + limit,
-      [masking_factor](float a, float b) { return a + masking_factor * b; });
-
-  // Apply masking only between lower frequency bands.
-  std::array<float, kFftLengthBy2Plus1> side_band_masker;
-  float max_nearend_after_gain = 0.f;
-  for (size_t k = 0; k < gain.size(); ++k) {
-    const float nearend_after_gain = nearend[k] * gain[k];
-    max_nearend_after_gain =
-        std::max(max_nearend_after_gain, nearend_after_gain);
-    side_band_masker[k] = nearend_after_gain + comfort_noise[k];
-  }
-
-  RTC_DCHECK_LT(kUpperAccurateBandPlus1, gain.size());
-  for (size_t k = 1; k < kUpperAccurateBandPlus1; ++k) {
-    (*masker)[k] += config.gain_mask.m5 *
-                    (side_band_masker[k - 1] + side_band_masker[k + 1]);
-  }
-
-  // Add full-band masking as a minimum value for the masker.
-  const float min_masker = max_nearend_after_gain * config.gain_mask.m6;
-  std::for_each(masker->begin(), masker->end(),
-                [min_masker](float& a) { a = std::max(a, min_masker); });
-}
-
 // Limits the gain in the frequencies for which the adaptive filter has not
 // converged. Currently, these frequencies are not hardcoded to the frequencies
 // which are typically not excited by speech.
@@ -280,6 +164,75 @@
 
 int SuppressionGain::instance_count_ = 0;
 
+float SuppressionGain::UpperBandsGain(
+    const std::array<float, kFftLengthBy2Plus1>& echo_spectrum,
+    const std::array<float, kFftLengthBy2Plus1>& comfort_noise_spectrum,
+    const absl::optional<int>& narrow_peak_band,
+    bool saturated_echo,
+    const std::vector<std::vector<float>>& render,
+    const std::array<float, kFftLengthBy2Plus1>& low_band_gain) const {
+  RTC_DCHECK_LT(0, render.size());
+  if (render.size() == 1) {
+    return 1.f;
+  }
+
+  if (narrow_peak_band &&
+      (*narrow_peak_band > static_cast<int>(kFftLengthBy2Plus1 - 10))) {
+    return 0.001f;
+  }
+
+  constexpr size_t kLowBandGainLimit = kFftLengthBy2 / 2;
+  const float gain_below_8_khz = *std::min_element(
+      low_band_gain.begin() + kLowBandGainLimit, low_band_gain.end());
+
+  // Always attenuate the upper bands when there is saturated echo.
+  if (saturated_echo) {
+    return std::min(0.001f, gain_below_8_khz);
+  }
+
+  // Compute the upper and lower band energies.
+  const auto sum_of_squares = [](float a, float b) { return a + b * b; };
+  const float low_band_energy =
+      std::accumulate(render[0].begin(), render[0].end(), 0.f, sum_of_squares);
+  float high_band_energy = 0.f;
+  for (size_t k = 1; k < render.size(); ++k) {
+    const float energy = std::accumulate(render[k].begin(), render[k].end(),
+                                         0.f, sum_of_squares);
+    high_band_energy = std::max(high_band_energy, energy);
+  }
+
+  // If there is more power in the lower frequencies than the upper frequencies,
+  // or if the power in upper frequencies is low, do not bound the gain in the
+  // upper bands.
+  float anti_howling_gain;
+  constexpr float kThreshold = kBlockSize * 10.f * 10.f / 4.f;
+  if (high_band_energy < std::max(low_band_energy, kThreshold)) {
+    anti_howling_gain = 1.f;
+  } else {
+    // In all other cases, bound the gain for upper frequencies.
+    RTC_DCHECK_LE(low_band_energy, high_band_energy);
+    RTC_DCHECK_NE(0.f, high_band_energy);
+    anti_howling_gain = 0.01f * sqrtf(low_band_energy / high_band_energy);
+  }
+
+  // Bound the upper gain during significant echo activity.
+  auto low_frequency_energy = [](rtc::ArrayView<const float> spectrum) {
+    RTC_DCHECK_LE(16, spectrum.size());
+    return std::accumulate(spectrum.begin() + 1, spectrum.begin() + 16, 0.f);
+  };
+  const float echo_sum = low_frequency_energy(echo_spectrum);
+  const float noise_sum = low_frequency_energy(comfort_noise_spectrum);
+  const auto& cfg = config_.suppressor.high_bands_suppression;
+  float gain_bound = 1.f;
+  if (echo_sum > cfg.enr_threshold * noise_sum &&
+      !dominant_nearend_detector_.IsNearendState()) {
+    gain_bound = cfg.max_gain_during_echo;
+  }
+
+  // Choose the gain as the minimum of the lower and upper gains.
+  return std::min(std::min(gain_below_8_khz, anti_howling_gain), gain_bound);
+}
+
 // Computes the gain to reduce the echo to a non audible level.
 void SuppressionGain::GainToNoAudibleEcho(
     const std::array<float, kFftLengthBy2Plus1>& nearend,
@@ -288,13 +241,16 @@
     const std::array<float, kFftLengthBy2Plus1>& min_gain,
     const std::array<float, kFftLengthBy2Plus1>& max_gain,
     std::array<float, kFftLengthBy2Plus1>* gain) const {
+  const auto& p = dominant_nearend_detector_.IsNearendState() ? nearend_params_
+                                                              : normal_params_;
   for (size_t k = 0; k < gain->size(); ++k) {
     float enr = echo[k] / (nearend[k] + 1.f);  // Echo-to-nearend ratio.
     float emr = echo[k] / (masker[k] + 1.f);   // Echo-to-masker (noise) ratio.
     float g = 1.0f;
-    if (enr > enr_transparent_[k] && emr > emr_transparent_[k]) {
-      g = (enr_suppress_[k] - enr) / (enr_suppress_[k] - enr_transparent_[k]);
-      g = std::max(g, emr_transparent_[k] / emr);
+    if (enr > p.enr_transparent_[k] && emr > p.emr_transparent_[k]) {
+      g = (p.enr_suppress_[k] - enr) /
+          (p.enr_suppress_[k] - p.enr_transparent_[k]);
+      g = std::max(g, p.emr_transparent_[k] / emr);
     }
     (*gain)[k] = std::max(std::min(g, max_gain[k]), min_gain[k]);
   }
@@ -310,6 +266,9 @@
     std::array<float, kFftLengthBy2Plus1>* gain) {
   const bool saturated_echo = aec_state.SaturatedEcho();
   const bool linear_echo_estimate = aec_state.UsableLinearEstimate();
+  const auto& params = dominant_nearend_detector_.IsNearendState()
+                           ? nearend_params_
+                           : normal_params_;
 
   // Weight echo power in terms of audibility. // Precompute 1/weighted echo
   // (note that when the echo is zero, the precomputed value is never used).
@@ -329,16 +288,13 @@
       min_gain[k] = denom > 0.f ? min_echo_power / denom : 1.f;
       min_gain[k] = std::min(min_gain[k], 1.f);
     }
-    if (enable_transparency_improvements_) {
-      for (size_t k = 0; k < 6; ++k) {
-        // Make sure the gains of the low frequencies do not decrease too
-        // quickly after strong nearend.
-        if (last_nearend_[k] > last_echo_[k]) {
-          min_gain[k] =
-              std::max(min_gain[k],
-                       last_gain_[k] * config_.gain_updates.max_dec_factor_lf);
-          min_gain[k] = std::min(min_gain[k], 1.f);
-        }
+    for (size_t k = 0; k < 6; ++k) {
+      // Make sure the gains of the low frequencies do not decrease too
+      // quickly after strong nearend.
+      if (last_nearend_[k] > last_echo_[k]) {
+        min_gain[k] =
+            std::max(min_gain[k], last_gain_[k] * params.max_dec_factor_lf);
+        min_gain[k] = std::min(min_gain[k], 1.f);
       }
     }
   } else {
@@ -348,20 +304,10 @@
   // Compute the maximum gain by limiting the gain increase from the previous
   // gain.
   std::array<float, kFftLengthBy2Plus1> max_gain;
-  if (enable_transparency_improvements_) {
-    for (size_t k = 0; k < gain->size(); ++k) {
-      max_gain[k] =
-          std::min(std::max(last_gain_[k] * config_.gain_updates.max_inc_factor,
-                            config_.gain_updates.floor_first_increase),
-                   1.f);
-    }
-  } else {
-    for (size_t k = 0; k < gain->size(); ++k) {
-      max_gain[k] =
-          std::min(std::max(last_gain_[k] * gain_increase_[k],
-                            config_.gain_updates.floor_first_increase),
-                   1.f);
-    }
+  for (size_t k = 0; k < gain->size(); ++k) {
+    max_gain[k] = std::min(std::max(last_gain_[k] * params.max_inc_factor,
+                                    config_.suppressor.floor_first_increase),
+                           1.f);
   }
 
   // Iteratively compute the gain required to attenuate the echo to a non
@@ -374,12 +320,11 @@
   } else {
     gain->fill(0.f);
     for (int k = 0; k < 2; ++k) {
-      MaskingPower(config_, enable_transparency_improvements_, nearend,
-                   comfort_noise, last_masker_, *gain, &masker);
-      GainToNoAudibleEchoFallback(
-          config_, low_noise_render, saturated_echo, linear_echo_estimate,
-          enable_transparency_improvements_, nearend, weighted_echo, masker,
-          min_gain, max_gain, one_by_weighted_echo, gain);
+      std::copy(comfort_noise.begin(), comfort_noise.end(), masker.begin());
+      GainToNoAudibleEchoFallback(config_, low_noise_render, saturated_echo,
+                                  linear_echo_estimate, nearend, weighted_echo,
+                                  masker, min_gain, max_gain,
+                                  one_by_weighted_echo, gain);
       AdjustForExternalFilters(gain);
     }
   }
@@ -387,23 +332,16 @@
   // Adjust the gain for frequencies which have not yet converged.
   AdjustNonConvergedFrequencies(gain);
 
-  // Update the allowed maximum gain increase.
-  UpdateGainIncrease(low_noise_render, linear_echo_estimate, saturated_echo,
-                     weighted_echo, *gain);
-
   // Store data required for the gain computation of the next block.
   std::copy(nearend.begin(), nearend.end(), last_nearend_.begin());
   std::copy(weighted_echo.begin(), weighted_echo.end(), last_echo_.begin());
   std::copy(gain->begin(), gain->end(), last_gain_.begin());
-  MaskingPower(config_, enable_transparency_improvements_, nearend,
-               comfort_noise, last_masker_, *gain, &last_masker_);
   aec3::VectorMath(optimization_).Sqrt(*gain);
 
   // Debug outputs for the purpose of development and analysis.
   data_dumper_->DumpRaw("aec3_suppressor_min_gain", min_gain);
   data_dumper_->DumpRaw("aec3_suppressor_max_gain", max_gain);
   data_dumper_->DumpRaw("aec3_suppressor_masker", masker);
-  data_dumper_->DumpRaw("aec3_suppressor_last_masker", last_masker_);
 }
 
 SuppressionGain::SuppressionGain(const EchoCanceller3Config& config,
@@ -415,41 +353,18 @@
       config_(config),
       state_change_duration_blocks_(
           static_cast<int>(config_.filter.config_change_duration_blocks)),
-      coherence_gain_(sample_rate_hz,
-                      config_.suppressor.bands_with_reliable_coherence),
-      enable_transparency_improvements_(EnableTransparencyImprovements()),
       enable_new_suppression_(EnableNewSuppression()),
       moving_average_(kFftLengthBy2Plus1,
-                      config.suppressor.nearend_average_blocks) {
+                      config.suppressor.nearend_average_blocks),
+      nearend_params_(config_.suppressor.nearend_tuning),
+      normal_params_(config_.suppressor.normal_tuning),
+      dominant_nearend_detector_(
+          config_.suppressor.dominant_nearend_detection) {
   RTC_DCHECK_LT(0, state_change_duration_blocks_);
   one_by_state_change_duration_blocks_ = 1.f / state_change_duration_blocks_;
   last_gain_.fill(1.f);
-  last_masker_.fill(0.f);
-  gain_increase_.fill(1.f);
   last_nearend_.fill(0.f);
   last_echo_.fill(0.f);
-
-  // Compute per-band masking thresholds.
-  constexpr size_t kLastLfBand = 5;
-  constexpr size_t kFirstHfBand = 8;
-  RTC_DCHECK_LT(kLastLfBand, kFirstHfBand);
-  auto& lf = config.suppressor.mask_lf;
-  auto& hf = config.suppressor.mask_hf;
-  RTC_DCHECK_LT(lf.enr_transparent, lf.enr_suppress);
-  RTC_DCHECK_LT(hf.enr_transparent, hf.enr_suppress);
-  for (size_t k = 0; k < kFftLengthBy2Plus1; k++) {
-    float a;
-    if (k <= kLastLfBand) {
-      a = 0.f;
-    } else if (k < kFirstHfBand) {
-      a = (k - kLastLfBand) / static_cast<float>(kFirstHfBand - kLastLfBand);
-    } else {
-      a = 1.f;
-    }
-    enr_transparent_[k] = (1 - a) * lf.enr_transparent + a * hf.enr_transparent;
-    enr_suppress_[k] = (1 - a) * lf.enr_suppress + a * hf.enr_suppress;
-    emr_transparent_[k] = (1 - a) * lf.emr_transparent + a * hf.emr_transparent;
-  }
 }
 
 SuppressionGain::~SuppressionGain() = default;
@@ -457,9 +372,9 @@
 void SuppressionGain::GetGain(
     const std::array<float, kFftLengthBy2Plus1>& nearend_spectrum,
     const std::array<float, kFftLengthBy2Plus1>& echo_spectrum,
+    const std::array<float, kFftLengthBy2Plus1>& residual_echo_spectrum,
     const std::array<float, kFftLengthBy2Plus1>& comfort_noise_spectrum,
     const FftData& linear_aec_fft,
-    const FftData& render_fft,
     const FftData& capture_fft,
     const RenderSignalAnalyzer& render_signal_analyzer,
     const AecState& aec_state,
@@ -468,28 +383,27 @@
     std::array<float, kFftLengthBy2Plus1>* low_band_gain) {
   RTC_DCHECK(high_bands_gain);
   RTC_DCHECK(low_band_gain);
+  const auto& cfg = config_.suppressor;
+
+  if (cfg.enforce_transparent) {
+    low_band_gain->fill(1.f);
+    *high_bands_gain = cfg.enforce_empty_higher_bands ? 0.f : 1.f;
+    return;
+  }
 
   std::array<float, kFftLengthBy2Plus1> nearend_average;
   moving_average_.Average(nearend_spectrum, nearend_average);
 
+  // Update the state selection.
+  dominant_nearend_detector_.Update(nearend_spectrum, residual_echo_spectrum,
+                                    comfort_noise_spectrum);
+
   // Compute gain for the lower band.
   bool low_noise_render = low_render_detector_.Detect(render);
   const absl::optional<int> narrow_peak_band =
       render_signal_analyzer.NarrowPeakBand();
-  LowerBandGain(low_noise_render, aec_state, nearend_average, echo_spectrum,
-                comfort_noise_spectrum, low_band_gain);
-
-  // Adjust the gain for bands where the coherence indicates not echo.
-  if (config_.suppressor.bands_with_reliable_coherence > 0 &&
-      !enable_transparency_improvements_) {
-    std::array<float, kFftLengthBy2Plus1> G_coherence;
-    coherence_gain_.ComputeGain(linear_aec_fft, render_fft, capture_fft,
-                                G_coherence);
-    for (size_t k = 0; k < config_.suppressor.bands_with_reliable_coherence;
-         ++k) {
-      (*low_band_gain)[k] = std::max((*low_band_gain)[k], G_coherence[k]);
-    }
-  }
+  LowerBandGain(low_noise_render, aec_state, nearend_average,
+                residual_echo_spectrum, comfort_noise_spectrum, low_band_gain);
 
   // Limit the gain of the lower bands during start up and after resets.
   const float gain_upper_bound = aec_state.SuppressionGainLimit();
@@ -500,8 +414,12 @@
   }
 
   // Compute the gain for the upper bands.
-  *high_bands_gain = UpperBandsGain(narrow_peak_band, aec_state.SaturatedEcho(),
-                                    render, *low_band_gain);
+  *high_bands_gain =
+      UpperBandsGain(echo_spectrum, comfort_noise_spectrum, narrow_peak_band,
+                     aec_state.SaturatedEcho(), render, *low_band_gain);
+  if (cfg.enforce_empty_higher_bands) {
+    *high_bands_gain = 0.f;
+  }
 }
 
 void SuppressionGain::SetInitialState(bool state) {
@@ -513,102 +431,6 @@
   }
 }
 
-void SuppressionGain::UpdateGainIncrease(
-    bool low_noise_render,
-    bool linear_echo_estimate,
-    bool saturated_echo,
-    const std::array<float, kFftLengthBy2Plus1>& echo,
-    const std::array<float, kFftLengthBy2Plus1>& new_gain) {
-  float max_inc;
-  float max_dec;
-  float rate_inc;
-  float rate_dec;
-  float min_inc;
-  float min_dec;
-
-  RTC_DCHECK_GE(state_change_duration_blocks_, initial_state_change_counter_);
-  if (initial_state_change_counter_ > 0) {
-    if (--initial_state_change_counter_ == 0) {
-      initial_state_ = false;
-    }
-  }
-  RTC_DCHECK_LE(0, initial_state_change_counter_);
-
-  // EchoCanceller3Config::GainUpdates
-  auto& p = config_.gain_updates;
-  if (!linear_echo_estimate) {
-    max_inc = p.nonlinear.max_inc;
-    max_dec = p.nonlinear.max_dec;
-    rate_inc = p.nonlinear.rate_inc;
-    rate_dec = p.nonlinear.rate_dec;
-    min_inc = p.nonlinear.min_inc;
-    min_dec = p.nonlinear.min_dec;
-  } else if (initial_state_ && !saturated_echo) {
-    if (initial_state_change_counter_ > 0) {
-      float change_factor =
-          initial_state_change_counter_ * one_by_state_change_duration_blocks_;
-
-      auto average = [](float from, float to, float from_weight) {
-        return from * from_weight + to * (1.f - from_weight);
-      };
-
-      max_inc = average(p.initial.max_inc, p.normal.max_inc, change_factor);
-      max_dec = average(p.initial.max_dec, p.normal.max_dec, change_factor);
-      rate_inc = average(p.initial.rate_inc, p.normal.rate_inc, change_factor);
-      rate_dec = average(p.initial.rate_dec, p.normal.rate_dec, change_factor);
-      min_inc = average(p.initial.min_inc, p.normal.min_inc, change_factor);
-      min_dec = average(p.initial.min_dec, p.normal.min_dec, change_factor);
-    } else {
-      max_inc = p.initial.max_inc;
-      max_dec = p.initial.max_dec;
-      rate_inc = p.initial.rate_inc;
-      rate_dec = p.initial.rate_dec;
-      min_inc = p.initial.min_inc;
-      min_dec = p.initial.min_dec;
-    }
-  } else if (low_noise_render) {
-    max_inc = p.low_noise.max_inc;
-    max_dec = p.low_noise.max_dec;
-    rate_inc = p.low_noise.rate_inc;
-    rate_dec = p.low_noise.rate_dec;
-    min_inc = p.low_noise.min_inc;
-    min_dec = p.low_noise.min_dec;
-  } else if (!saturated_echo) {
-    max_inc = p.normal.max_inc;
-    max_dec = p.normal.max_dec;
-    rate_inc = p.normal.rate_inc;
-    rate_dec = p.normal.rate_dec;
-    min_inc = p.normal.min_inc;
-    min_dec = p.normal.min_dec;
-  } else {
-    max_inc = p.saturation.max_inc;
-    max_dec = p.saturation.max_dec;
-    rate_inc = p.saturation.rate_inc;
-    rate_dec = p.saturation.rate_dec;
-    min_inc = p.saturation.min_inc;
-    min_dec = p.saturation.min_dec;
-  }
-
-  for (size_t k = 0; k < new_gain.size(); ++k) {
-    auto increase_update = [](float new_gain, float last_gain,
-                              float current_inc, float max_inc, float min_inc,
-                              float change_rate) {
-      return new_gain > last_gain ? std::min(max_inc, current_inc * change_rate)
-                                  : min_inc;
-    };
-
-    if (echo[k] > last_echo_[k]) {
-      gain_increase_[k] =
-          increase_update(new_gain[k], last_gain_[k], gain_increase_[k],
-                          max_inc, min_inc, rate_inc);
-    } else {
-      gain_increase_[k] =
-          increase_update(new_gain[k], last_gain_[k], gain_increase_[k],
-                          max_dec, min_dec, rate_dec);
-    }
-  }
-}
-
 // Detects when the render signal can be considered to have low power and
 // consist of stationary noise.
 bool SuppressionGain::LowNoiseRenderDetector::Detect(
@@ -628,4 +450,69 @@
   return low_noise_render;
 }
 
+SuppressionGain::DominantNearendDetector::DominantNearendDetector(
+    const EchoCanceller3Config::Suppressor::DominantNearendDetection config)
+    : enr_threshold_(config.enr_threshold),
+      snr_threshold_(config.snr_threshold),
+      hold_duration_(config.hold_duration),
+      trigger_threshold_(config.trigger_threshold) {}
+
+void SuppressionGain::DominantNearendDetector::Update(
+    rtc::ArrayView<const float> nearend_spectrum,
+    rtc::ArrayView<const float> residual_echo_spectrum,
+    rtc::ArrayView<const float> comfort_noise_spectrum) {
+  auto low_frequency_energy = [](rtc::ArrayView<const float> spectrum) {
+    RTC_DCHECK_LE(16, spectrum.size());
+    return std::accumulate(spectrum.begin() + 1, spectrum.begin() + 16, 0.f);
+  };
+  const float ne_sum = low_frequency_energy(nearend_spectrum);
+  const float echo_sum = low_frequency_energy(residual_echo_spectrum);
+  const float noise_sum = low_frequency_energy(comfort_noise_spectrum);
+
+  // Detect strong active nearend if the nearend is sufficiently stronger than
+  // the echo and the nearend noise.
+  if (ne_sum > enr_threshold_ * echo_sum &&
+      ne_sum > snr_threshold_ * noise_sum) {
+    if (++trigger_counter_ >= trigger_threshold_) {
+      // After a period of strong active nearend activity, flag nearend mode.
+      hold_counter_ = hold_duration_;
+      trigger_counter_ = trigger_threshold_;
+    }
+  } else {
+    // Forget previously detected strong active nearend activity.
+    trigger_counter_ = std::max(0, trigger_counter_ - 1);
+  }
+
+  // Remain in any nearend mode for a certain duration.
+  hold_counter_ = std::max(0, hold_counter_ - 1);
+  nearend_state_ = hold_counter_ > 0;
+}
+
+SuppressionGain::GainParameters::GainParameters(
+    const EchoCanceller3Config::Suppressor::Tuning& tuning)
+    : max_inc_factor(tuning.max_inc_factor),
+      max_dec_factor_lf(tuning.max_dec_factor_lf) {
+  // Compute per-band masking thresholds.
+  constexpr size_t kLastLfBand = 5;
+  constexpr size_t kFirstHfBand = 8;
+  RTC_DCHECK_LT(kLastLfBand, kFirstHfBand);
+  auto& lf = tuning.mask_lf;
+  auto& hf = tuning.mask_hf;
+  RTC_DCHECK_LT(lf.enr_transparent, lf.enr_suppress);
+  RTC_DCHECK_LT(hf.enr_transparent, hf.enr_suppress);
+  for (size_t k = 0; k < kFftLengthBy2Plus1; k++) {
+    float a;
+    if (k <= kLastLfBand) {
+      a = 0.f;
+    } else if (k < kFirstHfBand) {
+      a = (k - kLastLfBand) / static_cast<float>(kFirstHfBand - kLastLfBand);
+    } else {
+      a = 1.f;
+    }
+    enr_transparent_[k] = (1 - a) * lf.enr_transparent + a * hf.enr_transparent;
+    enr_suppress_[k] = (1 - a) * lf.enr_suppress + a * hf.enr_suppress;
+    emr_transparent_[k] = (1 - a) * lf.emr_transparent + a * hf.emr_transparent;
+  }
+}
+
 }  // namespace webrtc
diff --git a/modules/audio_processing/aec3/suppression_gain.h b/modules/audio_processing/aec3/suppression_gain.h
index 4c0c85d..b851930 100644
--- a/modules/audio_processing/aec3/suppression_gain.h
+++ b/modules/audio_processing/aec3/suppression_gain.h
@@ -17,7 +17,6 @@
 #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/coherence_gain.h"
 #include "modules/audio_processing/aec3/moving_average.h"
 #include "modules/audio_processing/aec3/render_signal_analyzer.h"
 #include "rtc_base/constructormagic.h"
@@ -33,9 +32,9 @@
   void GetGain(
       const std::array<float, kFftLengthBy2Plus1>& nearend_spectrum,
       const std::array<float, kFftLengthBy2Plus1>& echo_spectrum,
+      const std::array<float, kFftLengthBy2Plus1>& residual_echo_spectrum,
       const std::array<float, kFftLengthBy2Plus1>& comfort_noise_spectrum,
       const FftData& linear_aec_fft,
-      const FftData& render_fft,
       const FftData& capture_fft,
       const RenderSignalAnalyzer& render_signal_analyzer,
       const AecState& aec_state,
@@ -47,6 +46,15 @@
   void SetInitialState(bool state);
 
  private:
+  // Computes the gain to apply for the bands beyond the first band.
+  float UpperBandsGain(
+      const std::array<float, kFftLengthBy2Plus1>& echo_spectrum,
+      const std::array<float, kFftLengthBy2Plus1>& comfort_noise_spectrum,
+      const absl::optional<int>& narrow_peak_band,
+      bool saturated_echo,
+      const std::vector<std::vector<float>>& render,
+      const std::array<float, kFftLengthBy2Plus1>& low_band_gain) const;
+
   void GainToNoAudibleEcho(
       const std::array<float, kFftLengthBy2Plus1>& nearend,
       const std::array<float, kFftLengthBy2Plus1>& echo,
@@ -62,14 +70,6 @@
                      const std::array<float, kFftLengthBy2Plus1>& comfort_noise,
                      std::array<float, kFftLengthBy2Plus1>* gain);
 
-  // Limits the gain increase.
-  void UpdateGainIncrease(
-      bool low_noise_render,
-      bool linear_echo_estimate,
-      bool saturated_echo,
-      const std::array<float, kFftLengthBy2Plus1>& echo,
-      const std::array<float, kFftLengthBy2Plus1>& new_gain);
-
   class LowNoiseRenderDetector {
    public:
     bool Detect(const std::vector<std::vector<float>>& render);
@@ -78,6 +78,42 @@
     float average_power_ = 32768.f * 32768.f;
   };
 
+  // Class for selecting whether the suppressor is in the nearend or echo state.
+  class DominantNearendDetector {
+   public:
+    explicit DominantNearendDetector(
+        const EchoCanceller3Config::Suppressor::DominantNearendDetection
+            config);
+
+    // Returns whether the current state is the nearend state.
+    bool IsNearendState() const { return nearend_state_; }
+
+    // Updates the state selection based on latest spectral estimates.
+    void Update(rtc::ArrayView<const float> nearend_spectrum,
+                rtc::ArrayView<const float> residual_echo_spectrum,
+                rtc::ArrayView<const float> comfort_noise_spectrum);
+
+   private:
+    const float enr_threshold_;
+    const float snr_threshold_;
+    const int hold_duration_;
+    const int trigger_threshold_;
+
+    bool nearend_state_ = false;
+    int trigger_counter_ = 0;
+    int hold_counter_ = 0;
+  };
+
+  struct GainParameters {
+    explicit GainParameters(
+        const EchoCanceller3Config::Suppressor::Tuning& tuning);
+    const float max_inc_factor;
+    const float max_dec_factor_lf;
+    std::array<float, kFftLengthBy2Plus1> enr_transparent_;
+    std::array<float, kFftLengthBy2Plus1> enr_suppress_;
+    std::array<float, kFftLengthBy2Plus1> emr_transparent_;
+  };
+
   static int instance_count_;
   std::unique_ptr<ApmDataDumper> data_dumper_;
   const Aec3Optimization optimization_;
@@ -85,20 +121,16 @@
   const int state_change_duration_blocks_;
   float one_by_state_change_duration_blocks_;
   std::array<float, kFftLengthBy2Plus1> last_gain_;
-  std::array<float, kFftLengthBy2Plus1> last_masker_;
-  std::array<float, kFftLengthBy2Plus1> gain_increase_;
   std::array<float, kFftLengthBy2Plus1> last_nearend_;
   std::array<float, kFftLengthBy2Plus1> last_echo_;
-  std::array<float, kFftLengthBy2Plus1> enr_transparent_;
-  std::array<float, kFftLengthBy2Plus1> enr_suppress_;
-  std::array<float, kFftLengthBy2Plus1> emr_transparent_;
   LowNoiseRenderDetector low_render_detector_;
   bool initial_state_ = true;
   int initial_state_change_counter_ = 0;
-  CoherenceGain coherence_gain_;
-  const bool enable_transparency_improvements_;
   const bool enable_new_suppression_;
   aec3::MovingAverage moving_average_;
+  const GainParameters nearend_params_;
+  const GainParameters normal_params_;
+  DominantNearendDetector dominant_nearend_detector_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(SuppressionGain);
 };
diff --git a/modules/audio_processing/aec3/suppression_gain_unittest.cc b/modules/audio_processing/aec3/suppression_gain_unittest.cc
index 2eeb68b..ef31371 100644
--- a/modules/audio_processing/aec3/suppression_gain_unittest.cc
+++ b/modules/audio_processing/aec3/suppression_gain_unittest.cc
@@ -18,7 +18,6 @@
 #include "rtc_base/checks.h"
 #include "system_wrappers/include/cpu_features_wrapper.h"
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 namespace aec3 {
@@ -29,17 +28,16 @@
 TEST(SuppressionGain, NullOutputGains) {
   std::array<float, kFftLengthBy2Plus1> E2;
   std::array<float, kFftLengthBy2Plus1> R2;
+  std::array<float, kFftLengthBy2Plus1> S2;
   std::array<float, kFftLengthBy2Plus1> N2;
   FftData E;
-  FftData X;
   FftData Y;
   E2.fill(0.f);
   R2.fill(0.f);
+  S2.fill(0.1f);
   N2.fill(0.f);
   E.re.fill(0.f);
   E.im.fill(0.f);
-  X.re.fill(0.f);
-  X.im.fill(0.f);
   Y.re.fill(0.f);
   Y.im.fill(0.f);
 
@@ -47,7 +45,7 @@
   AecState aec_state(EchoCanceller3Config{});
   EXPECT_DEATH(
       SuppressionGain(EchoCanceller3Config{}, DetectOptimization(), 16000)
-          .GetGain(E2, R2, N2, E, X, Y,
+          .GetGain(E2, S2, R2, N2, E, Y,
                    RenderSignalAnalyzer((EchoCanceller3Config{})), aec_state,
                    std::vector<std::vector<float>>(
                        3, std::vector<float>(kBlockSize, 0.f)),
@@ -64,6 +62,7 @@
   RenderSignalAnalyzer analyzer(EchoCanceller3Config{});
   float high_bands_gain;
   std::array<float, kFftLengthBy2Plus1> E2;
+  std::array<float, kFftLengthBy2Plus1> S2;
   std::array<float, kFftLengthBy2Plus1> Y2;
   std::array<float, kFftLengthBy2Plus1> R2;
   std::array<float, kFftLengthBy2Plus1> N2;
@@ -71,7 +70,6 @@
   SubtractorOutput output;
   std::array<float, kBlockSize> y;
   FftData E;
-  FftData X;
   FftData Y;
   std::vector<std::vector<float>> x(1, std::vector<float>(kBlockSize, 0.f));
   EchoCanceller3Config config;
@@ -86,13 +84,12 @@
   E2.fill(10.f);
   Y2.fill(10.f);
   R2.fill(0.1f);
+  S2.fill(0.1f);
   N2.fill(100.f);
   output.Reset();
   y.fill(0.f);
   E.re.fill(sqrtf(E2[0]));
   E.im.fill(0.f);
-  X.re.fill(sqrtf(R2[0]));
-  X.im.fill(0.f);
   Y.re.fill(sqrtf(Y2[0]));
   Y.im.fill(0.f);
 
@@ -109,7 +106,7 @@
                      subtractor.FilterImpulseResponse(),
                      *render_delay_buffer->GetRenderBuffer(), E2, Y2, output,
                      y);
-    suppression_gain.GetGain(E2, R2, N2, E, X, Y, analyzer, aec_state, x,
+    suppression_gain.GetGain(E2, S2, R2, N2, E, Y, analyzer, aec_state, x,
                              &high_bands_gain, &g);
   }
   std::for_each(g.begin(), g.end(),
@@ -119,9 +116,9 @@
   E2.fill(100.f);
   Y2.fill(100.f);
   R2.fill(0.1f);
+  S2.fill(0.1f);
   N2.fill(0.f);
   E.re.fill(sqrtf(E2[0]));
-  X.re.fill(sqrtf(R2[0]));
   Y.re.fill(sqrtf(Y2[0]));
 
   for (int k = 0; k < 100; ++k) {
@@ -129,7 +126,7 @@
                      subtractor.FilterImpulseResponse(),
                      *render_delay_buffer->GetRenderBuffer(), E2, Y2, output,
                      y);
-    suppression_gain.GetGain(E2, R2, N2, E, X, Y, analyzer, aec_state, x,
+    suppression_gain.GetGain(E2, S2, R2, N2, E, Y, analyzer, aec_state, x,
                              &high_bands_gain, &g);
   }
   std::for_each(g.begin(), g.end(),
@@ -139,10 +136,9 @@
   E2.fill(1000000000.f);
   R2.fill(10000000000000.f);
   E.re.fill(sqrtf(E2[0]));
-  X.re.fill(sqrtf(R2[0]));
 
   for (int k = 0; k < 10; ++k) {
-    suppression_gain.GetGain(E2, R2, N2, E, X, Y, analyzer, aec_state, x,
+    suppression_gain.GetGain(E2, S2, R2, N2, E, Y, analyzer, aec_state, x,
                              &high_bands_gain, &g);
   }
   std::for_each(g.begin(), g.end(),
diff --git a/modules/audio_processing/aec3/vector_math.h b/modules/audio_processing/aec3/vector_math.h
index 0672b51..255331b 100644
--- a/modules/audio_processing/aec3/vector_math.h
+++ b/modules/audio_processing/aec3/vector_math.h
@@ -11,7 +11,9 @@
 #ifndef MODULES_AUDIO_PROCESSING_AEC3_VECTOR_MATH_H_
 #define MODULES_AUDIO_PROCESSING_AEC3_VECTOR_MATH_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
+// Defines WEBRTC_ARCH_X86_FAMILY, used below.
+#include "rtc_base/system/arch.h"
+
 #if defined(WEBRTC_HAS_NEON)
 #include <arm_neon.h>
 #endif
diff --git a/modules/audio_processing/aec3/vector_math_unittest.cc b/modules/audio_processing/aec3/vector_math_unittest.cc
index 6bf60ec..fdab2e5 100644
--- a/modules/audio_processing/aec3/vector_math_unittest.cc
+++ b/modules/audio_processing/aec3/vector_math_unittest.cc
@@ -12,9 +12,9 @@
 
 #include <math.h>
 
+#include "rtc_base/system/arch.h"
 #include "system_wrappers/include/cpu_features_wrapper.h"
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/aec_dump/aec_dump_impl.cc b/modules/audio_processing/aec_dump/aec_dump_impl.cc
index 1b8df40..9e07367 100644
--- a/modules/audio_processing/aec_dump/aec_dump_impl.cc
+++ b/modules/audio_processing/aec_dump/aec_dump_impl.cc
@@ -45,8 +45,6 @@
 
   pb_cfg->set_transient_suppression_enabled(
       config.transient_suppression_enabled);
-  pb_cfg->set_intelligibility_enhancer_enabled(
-      config.intelligibility_enhancer_enabled);
 
   pb_cfg->set_pre_amplifier_enabled(config.pre_amplifier_enabled);
   pb_cfg->set_pre_amplifier_fixed_gain_factor(
@@ -74,7 +72,8 @@
   thread_sync_event.Wait(rtc::Event::kForever);
 }
 
-void AecDumpImpl::WriteInitMessage(const ProcessingConfig& api_format) {
+void AecDumpImpl::WriteInitMessage(const ProcessingConfig& api_format,
+                                   int64_t time_now_ms) {
   auto task = CreateWriteToFileTask();
   auto* event = task->GetEvent();
   event->set_type(audioproc::Event::INIT);
@@ -95,6 +94,7 @@
       static_cast<int32_t>(api_format.reverse_input_stream().num_channels()));
   msg->set_num_reverse_output_channels(
       api_format.reverse_output_stream().num_channels());
+  msg->set_timestamp_ms(time_now_ms);
 
   worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(std::move(task)));
 }
diff --git a/modules/audio_processing/aec_dump/aec_dump_impl.h b/modules/audio_processing/aec_dump/aec_dump_impl.h
index 1ad4fc8..a5416a0 100644
--- a/modules/audio_processing/aec_dump/aec_dump_impl.h
+++ b/modules/audio_processing/aec_dump/aec_dump_impl.h
@@ -52,8 +52,8 @@
 
   ~AecDumpImpl() override;
 
-  void WriteInitMessage(const ProcessingConfig& api_format) override;
-
+  void WriteInitMessage(const ProcessingConfig& api_format,
+                        int64_t time_now_ms) override;
   void AddCaptureStreamInput(const AudioFrameView<const float>& src) override;
   void AddCaptureStreamOutput(const AudioFrameView<const float>& src) override;
   void AddCaptureStreamInput(const AudioFrame& frame) override;
diff --git a/modules/audio_processing/aec_dump/aec_dump_integration_test.cc b/modules/audio_processing/aec_dump/aec_dump_integration_test.cc
index 53e731a..b6d8756 100644
--- a/modules/audio_processing/aec_dump/aec_dump_integration_test.cc
+++ b/modules/audio_processing/aec_dump/aec_dump_integration_test.cc
@@ -33,7 +33,7 @@
   auto mock_aec_dump =
       absl::make_unique<testing::StrictMock<webrtc::test::MockAecDump>>();
   EXPECT_CALL(*mock_aec_dump.get(), WriteConfig(_)).Times(AtLeast(1));
-  EXPECT_CALL(*mock_aec_dump.get(), WriteInitMessage(_)).Times(AtLeast(1));
+  EXPECT_CALL(*mock_aec_dump.get(), WriteInitMessage(_, _)).Times(AtLeast(1));
   return std::unique_ptr<webrtc::test::MockAecDump>(std::move(mock_aec_dump));
 }
 
diff --git a/modules/audio_processing/aec_dump/aec_dump_unittest.cc b/modules/audio_processing/aec_dump/aec_dump_unittest.cc
index dea149d..75ed529 100644
--- a/modules/audio_processing/aec_dump/aec_dump_unittest.cc
+++ b/modules/audio_processing/aec_dump/aec_dump_unittest.cc
@@ -40,7 +40,8 @@
     aec_dump->WriteConfig(apm_config);
 
     webrtc::ProcessingConfig api_format;
-    aec_dump->WriteInitMessage(api_format);
+    constexpr int64_t kTimeNowMs = 123456789ll;
+    aec_dump->WriteInitMessage(api_format, kTimeNowMs);
   }
   // Remove file after the AecDump d-tor has finished.
   ASSERT_EQ(0, remove(filename.c_str()));
diff --git a/modules/audio_processing/aec_dump/mock_aec_dump.h b/modules/audio_processing/aec_dump/mock_aec_dump.h
index 95f912f..c01de51 100644
--- a/modules/audio_processing/aec_dump/mock_aec_dump.h
+++ b/modules/audio_processing/aec_dump/mock_aec_dump.h
@@ -25,7 +25,8 @@
   MockAecDump();
   virtual ~MockAecDump();
 
-  MOCK_METHOD1(WriteInitMessage, void(const ProcessingConfig& api_format));
+  MOCK_METHOD2(WriteInitMessage,
+               void(const ProcessingConfig& api_format, int64_t time_now_ms));
 
   MOCK_METHOD1(AddCaptureStreamInput,
                void(const AudioFrameView<const float>& src));
diff --git a/modules/audio_processing/aecm/BUILD.gn b/modules/audio_processing/aecm/BUILD.gn
index 54d839e..8250173 100644
--- a/modules/audio_processing/aecm/BUILD.gn
+++ b/modules/audio_processing/aecm/BUILD.gn
@@ -17,7 +17,6 @@
     "echo_control_mobile.h",
   ]
   deps = [
-    "../../..:typedefs",
     "../../../common_audio:common_audio_c",
     "../../../rtc_base:checks",
     "../../../rtc_base:rtc_base_approved",
@@ -31,9 +30,7 @@
     sources += [ "aecm_core_neon.cc" ]
 
     if (current_cpu != "arm64") {
-      # Enable compilation for the NEON instruction set. This is needed
-      # since //build/config/arm.gni only enables NEON for iOS, not Android.
-      # This provides the same functionality as webrtc/build/arm_neon.gypi.
+      # Enable compilation for the NEON instruction set.
       suppressed_configs += [ "//build/config/compiler:compiler_arm_fpu" ]
       cflags += [ "-mfpu=neon" ]
     }
diff --git a/modules/audio_processing/aecm/aecm_core.cc b/modules/audio_processing/aecm/aecm_core.cc
index 21a2ba1..0e56b50 100644
--- a/modules/audio_processing/aecm/aecm_core.cc
+++ b/modules/audio_processing/aecm/aecm_core.cc
@@ -25,7 +25,6 @@
 
 #include "rtc_base/checks.h"
 #include "rtc_base/numerics/safe_conversions.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 #ifdef AEC_DEBUG
 FILE* dfile;
diff --git a/modules/audio_processing/aecm/aecm_core.h b/modules/audio_processing/aecm/aecm_core.h
index 3da3bca..1681d2a 100644
--- a/modules/audio_processing/aecm/aecm_core.h
+++ b/modules/audio_processing/aecm/aecm_core.h
@@ -18,7 +18,6 @@
 #include "common_audio/signal_processing/include/signal_processing_library.h"
 }
 #include "modules/audio_processing/aecm/aecm_defines.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 #ifdef _MSC_VER  // visual c++
 #define ALIGN8_BEG __declspec(align(8))
diff --git a/modules/audio_processing/aecm/aecm_core_c.cc b/modules/audio_processing/aecm/aecm_core_c.cc
index b640f1a..905274f 100644
--- a/modules/audio_processing/aecm/aecm_core_c.cc
+++ b/modules/audio_processing/aecm/aecm_core_c.cc
@@ -26,7 +26,6 @@
 #include "rtc_base/checks.h"
 #include "rtc_base/numerics/safe_conversions.h"
 #include "rtc_base/sanitizer.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 // Square root of Hanning window in Q14.
 static const ALIGN8_BEG int16_t WebRtcAecm_kSqrtHanning[] ALIGN8_END = {
diff --git a/modules/audio_processing/aecm/echo_control_mobile.h b/modules/audio_processing/aecm/echo_control_mobile.h
index 576cf19..cea13b8 100644
--- a/modules/audio_processing/aecm/echo_control_mobile.h
+++ b/modules/audio_processing/aecm/echo_control_mobile.h
@@ -11,9 +11,8 @@
 #ifndef MODULES_AUDIO_PROCESSING_AECM_ECHO_CONTROL_MOBILE_H_
 #define MODULES_AUDIO_PROCESSING_AECM_ECHO_CONTROL_MOBILE_H_
 
-#include <stdlib.h>
-
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stddef.h>
+#include <stdint.h>
 
 enum { AecmFalse = 0, AecmTrue };
 
diff --git a/modules/audio_processing/agc/BUILD.gn b/modules/audio_processing/agc/BUILD.gn
index fe2f107..65653a0 100644
--- a/modules/audio_processing/agc/BUILD.gn
+++ b/modules/audio_processing/agc/BUILD.gn
@@ -19,9 +19,9 @@
     ":level_estimation",
     "..:apm_logging",
     "..:gain_control_interface",
-    "../../..:typedefs",
     "../../..:webrtc_common",
     "../../../rtc_base:checks",
+    "../../../rtc_base:gtest_prod",
     "../../../rtc_base:logging",
     "../../../rtc_base:macromagic",
     "../../../rtc_base:safe_minmax",
@@ -41,7 +41,6 @@
     "utility.h",
   ]
   deps = [
-    "../../..:typedefs",
     "../../..:webrtc_common",
     "../../../rtc_base:checks",
     "../../../rtc_base:macromagic",
@@ -66,11 +65,10 @@
   ]
 
   deps = [
-    "../../..:typedefs",
     "../../..:webrtc_common",
     "../../../common_audio",
     "../../../common_audio:common_audio_c",
-    "../../../common_audio:fft4g",
+    "../../../common_audio/third_party/fft4g",
     "../../../rtc_base:checks",
     "../../../rtc_base:rtc_base_approved",
     "../../../system_wrappers:cpu_features_api",
@@ -78,9 +76,7 @@
 
   if (rtc_build_with_neon) {
     if (current_cpu != "arm64") {
-      # Enable compilation for the NEON instruction set. This is needed
-      # since //build/config/arm.gni only enables NEON for iOS, not Android.
-      # This provides the same functionality as webrtc/build/arm_neon.gypi.
+      # Enable compilation for the NEON instruction set.
       suppressed_configs += [ "//build/config/compiler:compiler_arm_fpu" ]
       cflags = [ "-mfpu=neon" ]
     }
diff --git a/modules/audio_processing/agc/agc.h b/modules/audio_processing/agc/agc.h
index 98bbf1f..5d34c21 100644
--- a/modules/audio_processing/agc/agc.h
+++ b/modules/audio_processing/agc/agc.h
@@ -14,7 +14,6 @@
 #include <memory>
 
 #include "modules/audio_processing/vad/voice_activity_detector.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/agc/agc_manager_direct.cc b/modules/audio_processing/agc/agc_manager_direct.cc
index 132cf82..dc6d451 100644
--- a/modules/audio_processing/agc/agc_manager_direct.cc
+++ b/modules/audio_processing/agc/agc_manager_direct.cc
@@ -84,6 +84,31 @@
   return new_level;
 }
 
+int InitializeGainControl(GainControl* gain_control,
+                          bool disable_digital_adaptive) {
+  if (gain_control->set_mode(GainControl::kFixedDigital) != 0) {
+    RTC_LOG(LS_ERROR) << "set_mode(GainControl::kFixedDigital) failed.";
+    return -1;
+  }
+  const int target_level_dbfs = disable_digital_adaptive ? 0 : 2;
+  if (gain_control->set_target_level_dbfs(target_level_dbfs) != 0) {
+    RTC_LOG(LS_ERROR) << "set_target_level_dbfs() failed.";
+    return -1;
+  }
+  const int compression_gain_db =
+      disable_digital_adaptive ? 0 : kDefaultCompressionGain;
+  if (gain_control->set_compression_gain_db(compression_gain_db) != 0) {
+    RTC_LOG(LS_ERROR) << "set_compression_gain_db() failed.";
+    return -1;
+  }
+  const bool enable_limiter = !disable_digital_adaptive;
+  if (gain_control->enable_limiter(enable_limiter) != 0) {
+    RTC_LOG(LS_ERROR) << "enable_limiter() failed.";
+    return -1;
+  }
+  return 0;
+}
+
 }  // namespace
 
 // Facility for dumping debug audio files. All methods are no-ops in the
@@ -114,14 +139,16 @@
                                    int startup_min_level,
                                    int clipped_level_min,
                                    bool use_agc2_level_estimation,
-                                   bool use_agc2_digital_adaptive)
-    : AgcManagerDirect(new Agc(),
+                                   bool disable_digital_adaptive)
+    : AgcManagerDirect(use_agc2_level_estimation ? nullptr : new Agc(),
                        gctrl,
                        volume_callbacks,
                        startup_min_level,
                        clipped_level_min,
                        use_agc2_level_estimation,
-                       use_agc2_digital_adaptive) {}
+                       disable_digital_adaptive) {
+  RTC_DCHECK(agc_);
+}
 
 AgcManagerDirect::AgcManagerDirect(Agc* agc,
                                    GainControl* gctrl,
@@ -134,7 +161,9 @@
                        startup_min_level,
                        clipped_level_min,
                        false,
-                       false) {}
+                       false) {
+  RTC_DCHECK(agc_);
+}
 
 AgcManagerDirect::AgcManagerDirect(Agc* agc,
                                    GainControl* gctrl,
@@ -142,7 +171,7 @@
                                    int startup_min_level,
                                    int clipped_level_min,
                                    bool use_agc2_level_estimation,
-                                   bool use_agc2_digital_adaptive)
+                                   bool disable_digital_adaptive)
     : data_dumper_(new ApmDataDumper(instance_counter_)),
       agc_(agc),
       gctrl_(gctrl),
@@ -158,7 +187,7 @@
       check_volume_on_next_process_(true),  // Check at startup.
       startup_(true),
       use_agc2_level_estimation_(use_agc2_level_estimation),
-      use_agc2_digital_adaptive_(use_agc2_digital_adaptive),
+      disable_digital_adaptive_(disable_digital_adaptive),
       startup_min_level_(ClampLevel(startup_min_level)),
       clipped_level_min_(clipped_level_min),
       file_preproc_(new DebugFile("agc_preproc.pcm")),
@@ -170,9 +199,6 @@
   } else {
     RTC_DCHECK(agc);
   }
-  if (use_agc2_digital_adaptive_) {
-    RTC_NOTREACHED() << "Agc2 digital adaptive not implemented.";
-  }
 }
 
 AgcManagerDirect::~AgcManagerDirect() {}
@@ -180,8 +206,8 @@
 int AgcManagerDirect::Initialize() {
   max_level_ = kMaxMicLevel;
   max_compression_gain_ = kMaxCompressionGain;
-  target_compression_ = kDefaultCompressionGain;
-  compression_ = target_compression_;
+  target_compression_ = disable_digital_adaptive_ ? 0 : kDefaultCompressionGain;
+  compression_ = disable_digital_adaptive_ ? 0 : target_compression_;
   compression_accumulator_ = compression_;
   capture_muted_ = false;
   check_volume_on_next_process_ = true;
@@ -190,24 +216,7 @@
 
   data_dumper_->InitiateNewSetOfRecordings();
 
-  if (gctrl_->set_mode(GainControl::kFixedDigital) != 0) {
-    RTC_LOG(LS_ERROR) << "set_mode(GainControl::kFixedDigital) failed.";
-    return -1;
-  }
-  if (gctrl_->set_target_level_dbfs(2) != 0) {
-    RTC_LOG(LS_ERROR) << "set_target_level_dbfs(2) failed.";
-    return -1;
-  }
-  if (gctrl_->set_compression_gain_db(kDefaultCompressionGain) != 0) {
-    RTC_LOG(LS_ERROR)
-        << "set_compression_gain_db(kDefaultCompressionGain) failed.";
-    return -1;
-  }
-  if (gctrl_->enable_limiter(true) != 0) {
-    RTC_LOG(LS_ERROR) << "enable_limiter(true) failed.";
-    return -1;
-  }
-  return 0;
+  return InitializeGainControl(gctrl_, disable_digital_adaptive_);
 }
 
 void AgcManagerDirect::AnalyzePreProcess(int16_t* audio,
@@ -272,7 +281,9 @@
   agc_->Process(audio, length, sample_rate_hz);
 
   UpdateGain();
-  UpdateCompressor();
+  if (!disable_digital_adaptive_) {
+    UpdateCompressor();
+  }
 
   file_postproc_->Write(audio, length);
 
@@ -437,10 +448,19 @@
     // level_ was updated by SetLevel; log the new value.
     RTC_HISTOGRAM_COUNTS_LINEAR("WebRTC.Audio.AgcSetLevel", level_, 1,
                                 kMaxMicLevel, 50);
+    // Reset the AGC since the level has changed.
+    agc_->Reset();
   }
 }
 
 void AgcManagerDirect::UpdateCompressor() {
+  calls_since_last_gain_log_++;
+  if (calls_since_last_gain_log_ == 100) {
+    calls_since_last_gain_log_ = 0;
+    RTC_HISTOGRAM_COUNTS_LINEAR("WebRTC.Audio.Agc.DigitalGainApplied",
+                                compression_, 0, kMaxCompressionGain,
+                                kMaxCompressionGain + 1);
+  }
   if (compression_ == target_compression_) {
     return;
   }
@@ -465,6 +485,9 @@
 
   // Set the new compression gain.
   if (new_compression != compression_) {
+    RTC_HISTOGRAM_COUNTS_LINEAR("WebRTC.Audio.Agc.DigitalGainUpdated",
+                                new_compression, 0, kMaxCompressionGain,
+                                kMaxCompressionGain + 1);
     compression_ = new_compression;
     compression_accumulator_ = new_compression;
     if (gctrl_->set_compression_gain_db(compression_) != 0) {
diff --git a/modules/audio_processing/agc/agc_manager_direct.h b/modules/audio_processing/agc/agc_manager_direct.h
index de3d1cb..cbfd6a1 100644
--- a/modules/audio_processing/agc/agc_manager_direct.h
+++ b/modules/audio_processing/agc/agc_manager_direct.h
@@ -16,6 +16,7 @@
 #include "modules/audio_processing/agc/agc.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/constructormagic.h"
+#include "rtc_base/gtest_prod_util.h"
 
 namespace webrtc {
 
@@ -50,7 +51,7 @@
                    int startup_min_level,
                    int clipped_level_min,
                    bool use_agc2_level_estimation,
-                   bool use_agc2_digital_adaptive);
+                   bool disable_digital_adaptive);
 
   ~AgcManagerDirect();
 
@@ -71,6 +72,9 @@
  private:
   friend class AgcManagerDirectTest;
 
+  FRIEND_TEST_ALL_PREFIXES(AgcManagerDirectStandaloneTest,
+                           DisableDigitalDisablesDigital);
+
   // Dependency injection for testing. Don't delete |agc| as the memory is owned
   // by the manager.
   AgcManagerDirect(Agc* agc,
@@ -86,7 +90,7 @@
                    int startup_min_level,
                    int clipped_level_min,
                    bool use_agc2_level_estimation,
-                   bool use_agc2_digital_adaptive);
+                   bool disable_digital_adaptive);
 
   // Sets a new microphone level, after first checking that it hasn't been
   // updated by the user, in which case no action is taken.
@@ -119,9 +123,10 @@
   bool check_volume_on_next_process_;
   bool startup_;
   const bool use_agc2_level_estimation_;
-  const bool use_agc2_digital_adaptive_;
+  const bool disable_digital_adaptive_;
   int startup_min_level_;
   const int clipped_level_min_;
+  int calls_since_last_gain_log_ = 0;
 
   std::unique_ptr<DebugFile> file_preproc_;
   std::unique_ptr<DebugFile> file_postproc_;
diff --git a/modules/audio_processing/agc/agc_manager_direct_unittest.cc b/modules/audio_processing/agc/agc_manager_direct_unittest.cc
index 1a03402..73ea55d 100644
--- a/modules/audio_processing/agc/agc_manager_direct_unittest.cc
+++ b/modules/audio_processing/agc/agc_manager_direct_unittest.cc
@@ -17,6 +17,7 @@
 #include "test/gtest.h"
 
 using ::testing::_;
+using ::testing::AtLeast;
 using ::testing::DoAll;
 using ::testing::Return;
 using ::testing::SetArgPointee;
@@ -53,7 +54,7 @@
   }
 
   void FirstProcess() {
-    EXPECT_CALL(*agc_, Reset());
+    EXPECT_CALL(*agc_, Reset()).Times(AtLeast(1));
     EXPECT_CALL(*agc_, GetRmsErrorDb(_)).WillOnce(Return(false));
     CallProcess(1);
   }
@@ -366,11 +367,14 @@
   // to SetMicVolume.
   EXPECT_CALL(*agc_, GetRmsErrorDb(_))
       .WillOnce(DoAll(SetArgPointee<0>(11), Return(true)));
+
+  // When the analog volume changes, the gain controller is reset.
+  EXPECT_CALL(*agc_, Reset()).Times(AtLeast(1));
+
   // GetMicVolume returns a value outside of the quantization slack, indicating
   // a manual volume change.
+  ASSERT_NE(volume_.GetMicVolume(), 154);
   volume_.SetMicVolume(154);
-  // SetMicVolume should not be called.
-  EXPECT_CALL(*agc_, Reset()).Times(1);
   CallProcess(1);
   EXPECT_EQ(154, volume_.GetMicVolume());
 
@@ -378,7 +382,7 @@
   EXPECT_CALL(*agc_, GetRmsErrorDb(_))
       .WillOnce(DoAll(SetArgPointee<0>(-1), Return(true)));
   volume_.SetMicVolume(100);
-  EXPECT_CALL(*agc_, Reset()).Times(1);
+  EXPECT_CALL(*agc_, Reset()).Times(AtLeast(1));
   CallProcess(1);
   EXPECT_EQ(100, volume_.GetMicVolume());
 
@@ -407,7 +411,7 @@
   EXPECT_CALL(*agc_, GetRmsErrorDb(_))
       .WillOnce(DoAll(SetArgPointee<0>(-1), Return(true)));
   volume_.SetMicVolume(50);
-  EXPECT_CALL(*agc_, Reset()).Times(1);
+  EXPECT_CALL(*agc_, Reset()).Times(AtLeast(1));
   CallProcess(1);
   EXPECT_EQ(50, volume_.GetMicVolume());
 
@@ -426,7 +430,7 @@
       .WillOnce(DoAll(SetArgPointee<0>(-1), Return(true)));
   // Don't set to zero, which will cause AGC to take no action.
   volume_.SetMicVolume(1);
-  EXPECT_CALL(*agc_, Reset()).Times(1);
+  EXPECT_CALL(*agc_, Reset()).Times(AtLeast(1));
   CallProcess(1);
   EXPECT_EQ(1, volume_.GetMicVolume());
 
@@ -467,7 +471,7 @@
   SetVolumeAndProcess(255);
 
   EXPECT_CALL(*agc_, AnalyzePreproc(_, _)).WillOnce(Return(0.101));
-  EXPECT_CALL(*agc_, Reset()).Times(1);
+  EXPECT_CALL(*agc_, Reset()).Times(AtLeast(1));
   CallPreProc(1);
   EXPECT_EQ(240, volume_.GetMicVolume());
 }
@@ -477,7 +481,7 @@
 
   EXPECT_CALL(*agc_, AnalyzePreproc(_, _))
       .WillOnce(Return(kAboveClippedThreshold));
-  EXPECT_CALL(*agc_, Reset()).Times(1);
+  EXPECT_CALL(*agc_, Reset()).Times(AtLeast(1));
   CallPreProc(1);
   EXPECT_EQ(240, volume_.GetMicVolume());
 
@@ -489,7 +493,7 @@
 
   EXPECT_CALL(*agc_, AnalyzePreproc(_, _))
       .WillOnce(Return(kAboveClippedThreshold));
-  EXPECT_CALL(*agc_, Reset()).Times(1);
+  EXPECT_CALL(*agc_, Reset()).Times(AtLeast(1));
   CallPreProc(1);
   EXPECT_EQ(225, volume_.GetMicVolume());
 }
@@ -499,7 +503,7 @@
 
   EXPECT_CALL(*agc_, AnalyzePreproc(_, _))
       .WillOnce(Return(kAboveClippedThreshold));
-  EXPECT_CALL(*agc_, Reset()).Times(1);
+  EXPECT_CALL(*agc_, Reset()).Times(AtLeast(1));
   CallPreProc(1);
   EXPECT_EQ(kClippedMin, volume_.GetMicVolume());
 
@@ -515,7 +519,7 @@
 
   EXPECT_CALL(*agc_, AnalyzePreproc(_, _))
       .WillOnce(Return(kAboveClippedThreshold));
-  EXPECT_CALL(*agc_, Reset()).Times(1);
+  EXPECT_CALL(*agc_, Reset()).Times(AtLeast(1));
   CallPreProc(1);
   EXPECT_EQ(240, volume_.GetMicVolume());
 
@@ -530,7 +534,7 @@
 
   EXPECT_CALL(*agc_, AnalyzePreproc(_, _))
       .WillOnce(Return(kAboveClippedThreshold));
-  EXPECT_CALL(*agc_, Reset()).Times(1);
+  EXPECT_CALL(*agc_, Reset()).Times(AtLeast(1));
   CallPreProc(1);
   EXPECT_EQ(185, volume_.GetMicVolume());
 
@@ -547,7 +551,7 @@
 
   EXPECT_CALL(*agc_, AnalyzePreproc(_, _))
       .WillOnce(Return(kAboveClippedThreshold));
-  EXPECT_CALL(*agc_, Reset()).Times(1);
+  EXPECT_CALL(*agc_, Reset()).Times(AtLeast(1));
   CallPreProc(1);
   EXPECT_EQ(195, volume_.GetMicVolume());
 
@@ -576,14 +580,14 @@
   CallPreProc(300);
   EXPECT_CALL(*agc_, AnalyzePreproc(_, _))
       .WillOnce(Return(kAboveClippedThreshold));
-  EXPECT_CALL(*agc_, Reset()).Times(1);
+  EXPECT_CALL(*agc_, Reset()).Times(AtLeast(1));
   CallPreProc(1);
   EXPECT_EQ(180, volume_.GetMicVolume());
 
   CallPreProc(300);
   EXPECT_CALL(*agc_, AnalyzePreproc(_, _))
       .WillOnce(Return(kAboveClippedThreshold));
-  EXPECT_CALL(*agc_, Reset()).Times(1);
+  EXPECT_CALL(*agc_, Reset()).Times(AtLeast(1));
   CallPreProc(1);
   EXPECT_EQ(kClippedMin, volume_.GetMicVolume());
 
@@ -628,7 +632,7 @@
 
   EXPECT_CALL(*agc_, AnalyzePreproc(_, _))
       .WillOnce(Return(kAboveClippedThreshold));
-  EXPECT_CALL(*agc_, Reset()).Times(1);
+  EXPECT_CALL(*agc_, Reset()).Times(AtLeast(1));
   CallPreProc(1);
   EXPECT_EQ(210, volume_.GetMicVolume());
 
@@ -637,7 +641,7 @@
       .WillOnce(DoAll(SetArgPointee<0>(14), Return(true)));
   // User changed the volume.
   volume_.SetMicVolume(250);
-  EXPECT_CALL(*agc_, Reset()).Times(1);
+  EXPECT_CALL(*agc_, Reset()).Times(AtLeast(1));
   CallProcess(1);
   EXPECT_EQ(250, volume_.GetMicVolume());
 
@@ -679,4 +683,22 @@
   EXPECT_EQ(0, volume_.GetMicVolume());
 }
 
+TEST(AgcManagerDirectStandaloneTest, DisableDigitalDisablesDigital) {
+  auto agc = std::unique_ptr<Agc>(new testing::NiceMock<MockAgc>());
+  test::MockGainControl gctrl;
+  TestVolumeCallbacks volume;
+
+  AgcManagerDirect manager(agc.release(), &gctrl, &volume, kInitialVolume,
+                           kClippedMin,
+                           /* use agc2 level estimation */ false,
+                           /* disable digital adaptive */ true);
+
+  EXPECT_CALL(gctrl, set_mode(GainControl::kFixedDigital));
+  EXPECT_CALL(gctrl, set_target_level_dbfs(0));
+  EXPECT_CALL(gctrl, set_compression_gain_db(0));
+  EXPECT_CALL(gctrl, enable_limiter(false));
+
+  manager.Initialize();
+}
+
 }  // namespace webrtc
diff --git a/modules/audio_processing/agc/legacy/analog_agc.h b/modules/audio_processing/agc/legacy/analog_agc.h
index 1fed377..619d95a 100644
--- a/modules/audio_processing/agc/legacy/analog_agc.h
+++ b/modules/audio_processing/agc/legacy/analog_agc.h
@@ -18,7 +18,6 @@
 
 #include "modules/audio_processing/agc/legacy/digital_agc.h"
 #include "modules/audio_processing/agc/legacy/gain_control.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 /* Analog Automatic Gain Control variables:
  * Constant declarations (inner limits inside which no changes are done)
diff --git a/modules/audio_processing/agc/legacy/digital_agc.c b/modules/audio_processing/agc/legacy/digital_agc.c
index 7801196..d1c30bd 100644
--- a/modules/audio_processing/agc/legacy/digital_agc.c
+++ b/modules/audio_processing/agc/legacy/digital_agc.c
@@ -583,6 +583,7 @@
   int16_t buf2[4];
   int16_t HPstate;
   int16_t zeros, dB;
+  int64_t tmp64;
 
   // process in 10 sub frames of 1 ms (to save on memory)
   nrg = 0;
@@ -688,17 +689,17 @@
   tmp32 = WebRtcSpl_DivW32W16(tmp32, state->stdLongTerm);
   tmpU16 = (13 << 12);
   tmp32b = WEBRTC_SPL_MUL_16_U16(state->logRatio, tmpU16);
-  tmp32 += tmp32b >> 10;
-
-  state->logRatio = (int16_t)(tmp32 >> 6);
+  tmp64 = tmp32;
+  tmp64 += tmp32b >> 10;
+  tmp64 >>= 6;
 
   // limit
-  if (state->logRatio > 2048) {
-    state->logRatio = 2048;
+  if (tmp64 > 2048) {
+    tmp64 = 2048;
+  } else if (tmp64 < -2048) {
+    tmp64 = -2048;
   }
-  if (state->logRatio < -2048) {
-    state->logRatio = -2048;
-  }
+  state->logRatio = (int16_t)tmp64;
 
   return state->logRatio;  // Q10
 }
diff --git a/modules/audio_processing/agc/legacy/digital_agc.h b/modules/audio_processing/agc/legacy/digital_agc.h
index af6cf48..f086294 100644
--- a/modules/audio_processing/agc/legacy/digital_agc.h
+++ b/modules/audio_processing/agc/legacy/digital_agc.h
@@ -15,7 +15,6 @@
 #include <stdio.h>
 #endif
 #include "common_audio/signal_processing/include/signal_processing_library.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 // the 32 most significant bits of A(19) * B(26) >> 13
 #define AGC_MUL32(A, B) (((B) >> 13) * (A) + (((0x00001FFF & (B)) * (A)) >> 13))
diff --git a/modules/audio_processing/agc/legacy/gain_control.h b/modules/audio_processing/agc/legacy/gain_control.h
index 05b7ff6..a0ac96d 100644
--- a/modules/audio_processing/agc/legacy/gain_control.h
+++ b/modules/audio_processing/agc/legacy/gain_control.h
@@ -11,8 +11,6 @@
 #ifndef MODULES_AUDIO_PROCESSING_AGC_LEGACY_GAIN_CONTROL_H_
 #define MODULES_AUDIO_PROCESSING_AGC_LEGACY_GAIN_CONTROL_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
-
 // Errors
 #define AGC_UNSPECIFIED_ERROR 18000
 #define AGC_UNSUPPORTED_FUNCTION_ERROR 18001
diff --git a/modules/audio_processing/agc/loudness_histogram.h b/modules/audio_processing/agc/loudness_histogram.h
index ab45276..d8ad751 100644
--- a/modules/audio_processing/agc/loudness_histogram.h
+++ b/modules/audio_processing/agc/loudness_histogram.h
@@ -15,8 +15,6 @@
 
 #include <memory>
 
-#include "typedefs.h"  // NOLINT(build/include)
-
 namespace webrtc {
 
 // This class implements the histogram of loudness with circular buffers so that
diff --git a/modules/audio_processing/agc/mock_agc.h b/modules/audio_processing/agc/mock_agc.h
index ff1e9fd..4297e2a 100644
--- a/modules/audio_processing/agc/mock_agc.h
+++ b/modules/audio_processing/agc/mock_agc.h
@@ -19,6 +19,7 @@
 
 class MockAgc : public Agc {
  public:
+  virtual ~MockAgc() {}
   MOCK_METHOD2(AnalyzePreproc, float(const int16_t* audio, size_t length));
   MOCK_METHOD3(Process,
                void(const int16_t* audio, size_t length, int sample_rate_hz));
diff --git a/modules/audio_processing/agc2/BUILD.gn b/modules/audio_processing/agc2/BUILD.gn
index dcdc7fa..45ef968 100644
--- a/modules/audio_processing/agc2/BUILD.gn
+++ b/modules/audio_processing/agc2/BUILD.gn
@@ -29,7 +29,6 @@
     ":rnn_vad_with_level",
     "..:apm_logging",
     "..:audio_frame_view",
-    "../../..:typedefs",
     "../../../api:array_view",
     "../../../common_audio",
     "../../../rtc_base:checks",
@@ -66,6 +65,7 @@
     "../../../rtc_base:checks",
     "../../../rtc_base:rtc_base_approved",
     "../../../rtc_base:safe_minmax",
+    "../../../system_wrappers:metrics_api",
   ]
 }
 
@@ -165,7 +165,7 @@
     "../../../api:array_view",
     "../../../common_audio",
     "../../../rtc_base:checks",
-    "rnn_vad:lib",
+    "rnn_vad",
   ]
 }
 
@@ -232,6 +232,7 @@
     "../../../rtc_base:checks",
     "../../../rtc_base:rtc_base_approved",
     "../../../rtc_base:rtc_base_tests_utils",
+    "../../../system_wrappers:metrics_default",
     "//third_party/abseil-cpp/absl/memory",
   ]
 }
diff --git a/modules/audio_processing/agc2/adaptive_agc.cc b/modules/audio_processing/agc2/adaptive_agc.cc
index 7b24244..805be0c 100644
--- a/modules/audio_processing/agc2/adaptive_agc.cc
+++ b/modules/audio_processing/agc2/adaptive_agc.cc
@@ -30,14 +30,6 @@
 AdaptiveAgc::~AdaptiveAgc() = default;
 
 void AdaptiveAgc::Process(AudioFrameView<float> float_frame) {
-  // TODO(webrtc:7494): Remove this loop. Remove the vectors from
-  // VadWithData after we move to a VAD that outputs an estimate every
-  // kFrameDurationMs ms.
-  //
-  // Some VADs are 'bursty'. They return several estimates for some
-  // frames, and no estimates for other frames. We want to feed all to
-  // the level estimator, but only care about the last level it
-  // produces.
   const VadWithLevel::LevelAndProbability vad_result =
       vad_.AnalyzeFrame(float_frame);
   apm_data_dumper_->DumpRaw("agc2_vad_probability",
@@ -58,4 +50,8 @@
                         float_frame);
 }
 
+void AdaptiveAgc::Reset() {
+  speech_level_estimator_.Reset();
+}
+
 }  // namespace webrtc
diff --git a/modules/audio_processing/agc2/adaptive_agc.h b/modules/audio_processing/agc2/adaptive_agc.h
index dabe783..8f5efec 100644
--- a/modules/audio_processing/agc2/adaptive_agc.h
+++ b/modules/audio_processing/agc2/adaptive_agc.h
@@ -25,9 +25,11 @@
 class AdaptiveAgc {
  public:
   explicit AdaptiveAgc(ApmDataDumper* apm_data_dumper);
-  void Process(AudioFrameView<float> float_frame);
   ~AdaptiveAgc();
 
+  void Process(AudioFrameView<float> float_frame);
+  void Reset();
+
  private:
   AdaptiveModeLevelEstimator speech_level_estimator_;
   VadWithLevel vad_;
diff --git a/modules/audio_processing/agc2/adaptive_digital_gain_applier.cc b/modules/audio_processing/agc2/adaptive_digital_gain_applier.cc
index ca6ec5d..f5342df 100644
--- a/modules/audio_processing/agc2/adaptive_digital_gain_applier.cc
+++ b/modules/audio_processing/agc2/adaptive_digital_gain_applier.cc
@@ -16,6 +16,7 @@
 #include "modules/audio_processing/agc2/agc2_common.h"
 #include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/numerics/safe_minmax.h"
+#include "system_wrappers/include/metrics.h"
 
 namespace webrtc {
 namespace {
@@ -76,6 +77,15 @@
     float input_noise_level_dbfs,
     const VadWithLevel::LevelAndProbability vad_result,
     AudioFrameView<float> float_frame) {
+  calls_since_last_gain_log_++;
+  if (calls_since_last_gain_log_ == 100) {
+    calls_since_last_gain_log_ = 0;
+    RTC_HISTOGRAM_COUNTS_LINEAR("WebRTC.Audio.Agc2.DigitalGainApplied",
+                                last_gain_db_, 0, kMaxGainDb, kMaxGainDb + 1);
+    RTC_HISTOGRAM_COUNTS_LINEAR("WebRTC.Audio.Agc2.EstimatedNoiseLevel",
+                                input_noise_level_dbfs, 0, 100, 101);
+  }
+
   input_level_dbfs = std::min(input_level_dbfs, 0.f);
 
   RTC_DCHECK_GE(input_level_dbfs, -150.f);
diff --git a/modules/audio_processing/agc2/adaptive_digital_gain_applier.h b/modules/audio_processing/agc2/adaptive_digital_gain_applier.h
index 31f87f1..a3a1ff5 100644
--- a/modules/audio_processing/agc2/adaptive_digital_gain_applier.h
+++ b/modules/audio_processing/agc2/adaptive_digital_gain_applier.h
@@ -32,6 +32,7 @@
  private:
   float last_gain_db_ = kInitialAdaptiveDigitalGainDb;
   GainApplier gain_applier_;
+  int calls_since_last_gain_log_ = 0;
 
   // For some combinations of noise and speech probability, increasing
   // the level is not allowed. Since we may get VAD results in bursts,
diff --git a/modules/audio_processing/agc2/fixed_digital_level_estimator.cc b/modules/audio_processing/agc2/fixed_digital_level_estimator.cc
index 9a1fd28..39cc764 100644
--- a/modules/audio_processing/agc2/fixed_digital_level_estimator.cc
+++ b/modules/audio_processing/agc2/fixed_digital_level_estimator.cc
@@ -17,11 +17,17 @@
 #include "rtc_base/checks.h"
 
 namespace webrtc {
+namespace {
+
+constexpr float kInitialFilterStateLevel = 0.f;
+
+}  // namespace
 
 FixedDigitalLevelEstimator::FixedDigitalLevelEstimator(
     size_t sample_rate_hz,
     ApmDataDumper* apm_data_dumper)
-    : apm_data_dumper_(apm_data_dumper) {
+    : apm_data_dumper_(apm_data_dumper),
+      filter_state_level_(kInitialFilterStateLevel) {
   SetSampleRate(sample_rate_hz);
   CheckParameterCombination();
   RTC_DCHECK(apm_data_dumper_);
@@ -97,4 +103,9 @@
       rtc::CheckedDivExact(samples_in_frame_, kSubFramesInFrame);
   CheckParameterCombination();
 }
+
+void FixedDigitalLevelEstimator::Reset() {
+  filter_state_level_ = kInitialFilterStateLevel;
+}
+
 }  // namespace webrtc
diff --git a/modules/audio_processing/agc2/fixed_digital_level_estimator.h b/modules/audio_processing/agc2/fixed_digital_level_estimator.h
index b0e7a6d..4907ec7 100644
--- a/modules/audio_processing/agc2/fixed_digital_level_estimator.h
+++ b/modules/audio_processing/agc2/fixed_digital_level_estimator.h
@@ -45,11 +45,14 @@
   // value passed to the constructor. The class is not thread safe.
   void SetSampleRate(size_t sample_rate_hz);
 
+  // Resets the level estimator internal state.
+  void Reset();
+
  private:
   void CheckParameterCombination();
 
   ApmDataDumper* const apm_data_dumper_ = nullptr;
-  float filter_state_level_ = 0.f;
+  float filter_state_level_;
   size_t samples_in_frame_;
   size_t samples_in_sub_frame_;
 
diff --git a/modules/audio_processing/agc2/fixed_gain_controller.cc b/modules/audio_processing/agc2/fixed_gain_controller.cc
index e59ae34..d49d181 100644
--- a/modules/audio_processing/agc2/fixed_gain_controller.cc
+++ b/modules/audio_processing/agc2/fixed_gain_controller.cc
@@ -34,8 +34,17 @@
 }  // namespace
 
 FixedGainController::FixedGainController(ApmDataDumper* apm_data_dumper)
+    : FixedGainController(apm_data_dumper, "Agc2") {}
+
+FixedGainController::FixedGainController(ApmDataDumper* apm_data_dumper,
+                                         std::string histogram_name_prefix)
     : apm_data_dumper_(apm_data_dumper),
-      gain_curve_applier_(48000, apm_data_dumper_) {}
+      gain_curve_applier_(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" ||
+             histogram_name_prefix == "Agc2");
+}
 
 void FixedGainController::SetGain(float gain_to_apply_db) {
   // Changes in gain_to_apply_ cause discontinuities. We assume
@@ -45,9 +54,15 @@
   // The gain
   RTC_DCHECK_LE(-50.f, gain_to_apply_db);
   RTC_DCHECK_LE(gain_to_apply_db, 50.f);
+  const float previous_applied_gained = gain_to_apply_;
   gain_to_apply_ = DbToRatio(gain_to_apply_db);
   RTC_DCHECK_LT(0.f, gain_to_apply_);
   RTC_DLOG(LS_INFO) << "Gain to apply: " << gain_to_apply_db << " db.";
+  // 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();
+  }
 }
 
 void FixedGainController::SetSampleRate(size_t sample_rate_hz) {
diff --git a/modules/audio_processing/agc2/fixed_gain_controller.h b/modules/audio_processing/agc2/fixed_gain_controller.h
index 2b92cfc..a41a13f 100644
--- a/modules/audio_processing/agc2/fixed_gain_controller.h
+++ b/modules/audio_processing/agc2/fixed_gain_controller.h
@@ -20,6 +20,8 @@
 class FixedGainController {
  public:
   explicit FixedGainController(ApmDataDumper* apm_data_dumper);
+  FixedGainController(ApmDataDumper* apm_data_dumper,
+                      std::string histogram_name_prefix);
 
   void Process(AudioFrameView<float> signal);
 
diff --git a/modules/audio_processing/agc2/fixed_gain_controller_unittest.cc b/modules/audio_processing/agc2/fixed_gain_controller_unittest.cc
index 72bb409..bd7c356 100644
--- a/modules/audio_processing/agc2/fixed_gain_controller_unittest.cc
+++ b/modules/audio_processing/agc2/fixed_gain_controller_unittest.cc
@@ -16,6 +16,7 @@
 #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_default.h"
 
 namespace webrtc {
 namespace {
@@ -45,24 +46,38 @@
       vectors_with_float_frame_last.float_frame_view().channel(0);
   return channel[channel.size() - 1];
 }
-ApmDataDumper test_data_dumper(0);
+
+std::unique_ptr<ApmDataDumper> GetApmDataDumper() {
+  return absl::make_unique<ApmDataDumper>(0);
+}
 
 std::unique_ptr<FixedGainController> CreateFixedGainController(
     float gain_to_apply,
-    size_t rate) {
+    size_t rate,
+    std::string histogram_name_prefix,
+    ApmDataDumper* test_data_dumper) {
   std::unique_ptr<FixedGainController> fgc =
-      absl::make_unique<FixedGainController>(&test_data_dumper);
+      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;
-  std::unique_ptr<FixedGainController> fixed_gc =
-      CreateFixedGainController(kGainToApplyDb, kSampleRate);
+  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();
@@ -76,13 +91,15 @@
   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);
+        CreateFixedGainController(gain_db, kSampleRate, test_data_dumper.get());
 
     // Saturation not expected.
     SCOPED_TRACE(std::to_string(gain_db));
@@ -98,7 +115,7 @@
     // Since |test::kLimiterMaxInputLevelDbFs| < |gain|, the limiter
     // will saturate the signal.
     std::unique_ptr<FixedGainController> fixed_gc_saturation =
-        CreateFixedGainController(gain_db, kSampleRate);
+        CreateFixedGainController(gain_db, kSampleRate, test_data_dumper.get());
 
     // Saturation expected.
     SCOPED_TRACE(std::to_string(gain_db));
@@ -115,13 +132,15 @@
   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);
+        CreateFixedGainController(gain_db, kSampleRate, test_data_dumper.get());
 
     // Saturation not expected.
     SCOPED_TRACE(std::to_string(gain_db));
@@ -137,7 +156,7 @@
     // Singe |gain| < |test::kLimiterMaxInputLevelDbFs|, the limiter will
     // saturate the signal.
     std::unique_ptr<FixedGainController> fixed_gc_saturation =
-        CreateFixedGainController(gain_db, kSampleRate);
+        CreateFixedGainController(gain_db, kSampleRate, test_data_dumper.get());
 
     // Saturation expected.
     SCOPED_TRACE(std::to_string(gain_db));
@@ -155,8 +174,10 @@
   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);
+      CreateFixedGainController(kGainDbNoChange, kSampleRate,
+                                test_data_dumper.get());
 
   // Signal level is unchanged with 0 db gain.
   EXPECT_FLOAT_EQ(
@@ -173,4 +194,65 @@
       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_curve_applier.cc b/modules/audio_processing/agc2/gain_curve_applier.cc
index 122839a..b52e0d7 100644
--- a/modules/audio_processing/agc2/gain_curve_applier.cc
+++ b/modules/audio_processing/agc2/gain_curve_applier.cc
@@ -84,8 +84,9 @@
 }  // namespace
 
 GainCurveApplier::GainCurveApplier(size_t sample_rate_hz,
-                                   ApmDataDumper* apm_data_dumper)
-    : interp_gain_curve_(apm_data_dumper),
+                                   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) {}
 
@@ -129,4 +130,8 @@
                 kMaximalNumberOfSamplesPerChannel * 1000 / kFrameDurationMs);
 }
 
+void GainCurveApplier::Reset() {
+  level_estimator_.Reset();
+}
+
 }  // namespace webrtc
diff --git a/modules/audio_processing/agc2/gain_curve_applier.h b/modules/audio_processing/agc2/gain_curve_applier.h
index 86ca251..a7ffa36 100644
--- a/modules/audio_processing/agc2/gain_curve_applier.h
+++ b/modules/audio_processing/agc2/gain_curve_applier.h
@@ -23,7 +23,9 @@
 
 class GainCurveApplier {
  public:
-  GainCurveApplier(size_t sample_rate_hz, ApmDataDumper* apm_data_dumper);
+  GainCurveApplier(size_t sample_rate_hz,
+                   ApmDataDumper* apm_data_dumper,
+                   std::string histogram_name_prefix);
 
   ~GainCurveApplier();
 
@@ -37,6 +39,9 @@
   //   per_sample_scaling_factors_ array.
   void SetSampleRate(size_t sample_rate_hz);
 
+  // Resets the internal state.
+  void Reset();
+
  private:
   const InterpolatedGainCurve interp_gain_curve_;
   FixedDigitalLevelEstimator level_estimator_;
diff --git a/modules/audio_processing/agc2/gain_curve_applier_unittest.cc b/modules/audio_processing/agc2/gain_curve_applier_unittest.cc
index d9179a4..0f75f62 100644
--- a/modules/audio_processing/agc2/gain_curve_applier_unittest.cc
+++ b/modules/audio_processing/agc2/gain_curve_applier_unittest.cc
@@ -23,7 +23,7 @@
   const int sample_rate_hz = 48000;
   ApmDataDumper apm_data_dumper(0);
 
-  GainCurveApplier gain_curve_applier(sample_rate_hz, &apm_data_dumper);
+  GainCurveApplier gain_curve_applier(sample_rate_hz, &apm_data_dumper, "");
 
   VectorFloatFrame vectors_with_float_frame(1, sample_rate_hz / 100,
                                             kMaxAbsFloatS16Value);
@@ -37,7 +37,7 @@
       2.f;
   ApmDataDumper apm_data_dumper(0);
 
-  GainCurveApplier gain_curve_applier(sample_rate_hz, &apm_data_dumper);
+  GainCurveApplier gain_curve_applier(sample_rate_hz, &apm_data_dumper, "");
 
   // Give the level estimator time to adapt.
   for (int i = 0; i < 5; ++i) {
diff --git a/modules/audio_processing/agc2/interpolated_gain_curve.cc b/modules/audio_processing/agc2/interpolated_gain_curve.cc
index 7f1f16c..73e6a8e 100644
--- a/modules/audio_processing/agc2/interpolated_gain_curve.cc
+++ b/modules/audio_processing/agc2/interpolated_gain_curve.cc
@@ -14,41 +14,8 @@
 #include "modules/audio_processing/logging/apm_data_dumper.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
-#include "system_wrappers/include/metrics.h"
 
 namespace webrtc {
-namespace {
-void LogRegionStats(const InterpolatedGainCurve::Stats& stats) {
-  using Region = InterpolatedGainCurve::GainCurveRegion;
-  const int duration_s =
-      stats.region_duration_frames / (1000 / kFrameDurationMs);
-
-  switch (stats.region) {
-    case Region::kIdentity: {
-      RTC_HISTOGRAM_COUNTS_10000(
-          "WebRTC.Audio.Agc2.FixedDigitalGainCurveRegion.Identity", duration_s);
-      break;
-    }
-    case Region::kKnee: {
-      RTC_HISTOGRAM_COUNTS_10000(
-          "WebRTC.Audio.Agc2.FixedDigitalGainCurveRegion.Knee", duration_s);
-      break;
-    }
-    case Region::kLimiter: {
-      RTC_HISTOGRAM_COUNTS_10000(
-          "WebRTC.Audio.Agc2.FixedDigitalGainCurveRegion.Limiter", duration_s);
-      break;
-    }
-    case Region::kSaturation: {
-      RTC_HISTOGRAM_COUNTS_10000(
-          "WebRTC.Audio.Agc2.FixedDigitalGainCurveRegion.Saturation",
-          duration_s);
-      break;
-    }
-    default: { RTC_NOTREACHED(); }
-  }
-}
-}  // namespace
 
 constexpr std::array<float, kInterpolatedGainCurveTotalPoints>
     InterpolatedGainCurve::approximation_params_x_;
@@ -59,8 +26,17 @@
 constexpr std::array<float, kInterpolatedGainCurveTotalPoints>
     InterpolatedGainCurve::approximation_params_q_;
 
-InterpolatedGainCurve::InterpolatedGainCurve(ApmDataDumper* apm_data_dumper)
-    : apm_data_dumper_(apm_data_dumper) {}
+InterpolatedGainCurve::InterpolatedGainCurve(ApmDataDumper* apm_data_dumper,
+                                             std::string histogram_name_prefix)
+    : region_logger_("WebRTC.Audio." + histogram_name_prefix +
+                         ".FixedDigitalGainCurveRegion.Identity",
+                     "WebRTC.Audio." + histogram_name_prefix +
+                         ".FixedDigitalGainCurveRegion.Knee",
+                     "WebRTC.Audio." + histogram_name_prefix +
+                         ".FixedDigitalGainCurveRegion.Limiter",
+                     "WebRTC.Audio." + histogram_name_prefix +
+                         ".FixedDigitalGainCurveRegion.Saturation"),
+      apm_data_dumper_(apm_data_dumper) {}
 
 InterpolatedGainCurve::~InterpolatedGainCurve() {
   if (stats_.available) {
@@ -73,7 +49,69 @@
                               stats_.look_ups_limiter_region);
     apm_data_dumper_->DumpRaw("agc2_interp_gain_curve_lookups_saturation",
                               stats_.look_ups_saturation_region);
-    LogRegionStats(stats_);
+    region_logger_.LogRegionStats(stats_);
+  }
+}
+
+InterpolatedGainCurve::RegionLogger::RegionLogger(
+    std::string identity_histogram_name,
+    std::string knee_histogram_name,
+    std::string limiter_histogram_name,
+    std::string saturation_histogram_name)
+    : identity_histogram(
+          metrics::HistogramFactoryGetCounts(identity_histogram_name,
+                                             1,
+                                             10000,
+                                             50)),
+      knee_histogram(metrics::HistogramFactoryGetCounts(knee_histogram_name,
+                                                        1,
+                                                        10000,
+                                                        50)),
+      limiter_histogram(
+          metrics::HistogramFactoryGetCounts(limiter_histogram_name,
+                                             1,
+                                             10000,
+                                             50)),
+      saturation_histogram(
+          metrics::HistogramFactoryGetCounts(saturation_histogram_name,
+                                             1,
+                                             10000,
+                                             50)) {}
+
+InterpolatedGainCurve::RegionLogger::~RegionLogger() = default;
+
+void InterpolatedGainCurve::RegionLogger::LogRegionStats(
+    const InterpolatedGainCurve::Stats& stats) const {
+  using Region = InterpolatedGainCurve::GainCurveRegion;
+  const int duration_s =
+      stats.region_duration_frames / (1000 / kFrameDurationMs);
+
+  switch (stats.region) {
+    case Region::kIdentity: {
+      if (identity_histogram) {
+        metrics::HistogramAdd(identity_histogram, duration_s);
+      }
+      break;
+    }
+    case Region::kKnee: {
+      if (knee_histogram) {
+        metrics::HistogramAdd(knee_histogram, duration_s);
+      }
+      break;
+    }
+    case Region::kLimiter: {
+      if (limiter_histogram) {
+        metrics::HistogramAdd(limiter_histogram, duration_s);
+      }
+      break;
+    }
+    case Region::kSaturation: {
+      if (saturation_histogram) {
+        metrics::HistogramAdd(saturation_histogram, duration_s);
+      }
+      break;
+    }
+    default: { RTC_NOTREACHED(); }
   }
 }
 
@@ -100,7 +138,7 @@
   if (region == stats_.region) {
     ++stats_.region_duration_frames;
   } else {
-    LogRegionStats(stats_);
+    region_logger_.LogRegionStats(stats_);
 
     stats_.region_duration_frames = 0;
     stats_.region = region;
diff --git a/modules/audio_processing/agc2/interpolated_gain_curve.h b/modules/audio_processing/agc2/interpolated_gain_curve.h
index fc5842b..68d4532 100644
--- a/modules/audio_processing/agc2/interpolated_gain_curve.h
+++ b/modules/audio_processing/agc2/interpolated_gain_curve.h
@@ -12,11 +12,13 @@
 #define MODULES_AUDIO_PROCESSING_AGC2_INTERPOLATED_GAIN_CURVE_H_
 
 #include <array>
+#include <string>
 
 #include "modules/audio_processing/agc2/agc2_common.h"
 
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/gtest_prod_util.h"
+#include "system_wrappers/include/metrics.h"
 
 namespace webrtc {
 
@@ -59,8 +61,8 @@
     int64_t region_duration_frames = 0;
   };
 
-  // InterpolatedGainCurve(InterpolatedGainCurve&&);
-  explicit InterpolatedGainCurve(ApmDataDumper* apm_data_dumper);
+  InterpolatedGainCurve(ApmDataDumper* apm_data_dumper,
+                        std::string histogram_name_prefix);
   ~InterpolatedGainCurve();
 
   Stats get_stats() const { return stats_; }
@@ -76,6 +78,23 @@
   // ComputeInterpolatedGainCurve.
   FRIEND_TEST_ALL_PREFIXES(AutomaticGainController2InterpolatedGainCurve,
                            CheckApproximationParams);
+
+  struct RegionLogger {
+    metrics::Histogram* identity_histogram;
+    metrics::Histogram* knee_histogram;
+    metrics::Histogram* limiter_histogram;
+    metrics::Histogram* saturation_histogram;
+
+    RegionLogger(std::string identity_histogram_name,
+                 std::string knee_histogram_name,
+                 std::string limiter_histogram_name,
+                 std::string saturation_histogram_name);
+
+    ~RegionLogger();
+
+    void LogRegionStats(const InterpolatedGainCurve::Stats& stats) const;
+  } region_logger_;
+
   void UpdateStats(float input_level) const;
 
   ApmDataDumper* const apm_data_dumper_;
diff --git a/modules/audio_processing/agc2/interpolated_gain_curve_unittest.cc b/modules/audio_processing/agc2/interpolated_gain_curve_unittest.cc
index d75ddbd..dd69631 100644
--- a/modules/audio_processing/agc2/interpolated_gain_curve_unittest.cc
+++ b/modules/audio_processing/agc2/interpolated_gain_curve_unittest.cc
@@ -32,7 +32,7 @@
 }  // namespace
 
 TEST(AutomaticGainController2InterpolatedGainCurve, CreateUse) {
-  InterpolatedGainCurve igc(&apm_data_dumper);
+  InterpolatedGainCurve igc(&apm_data_dumper, "");
 
   const auto levels = test::LinSpace(
       kLevelEpsilon, DbfsToFloatS16(limiter.max_input_level_db() + 1), 500);
@@ -42,7 +42,7 @@
 }
 
 TEST(AutomaticGainController2InterpolatedGainCurve, CheckValidOutput) {
-  InterpolatedGainCurve igc(&apm_data_dumper);
+  InterpolatedGainCurve igc(&apm_data_dumper, "");
 
   const auto levels = test::LinSpace(
       kLevelEpsilon, limiter.max_input_level_linear() * 2.0, 500);
@@ -55,7 +55,7 @@
 }
 
 TEST(AutomaticGainController2InterpolatedGainCurve, CheckMonotonicity) {
-  InterpolatedGainCurve igc(&apm_data_dumper);
+  InterpolatedGainCurve igc(&apm_data_dumper, "");
 
   const auto levels = test::LinSpace(
       kLevelEpsilon, limiter.max_input_level_linear() + kLevelEpsilon + 0.5,
@@ -69,7 +69,7 @@
 }
 
 TEST(AutomaticGainController2InterpolatedGainCurve, CheckApproximation) {
-  InterpolatedGainCurve igc(&apm_data_dumper);
+  InterpolatedGainCurve igc(&apm_data_dumper, "");
 
   const auto levels = test::LinSpace(
       kLevelEpsilon, limiter.max_input_level_linear() - kLevelEpsilon, 500);
@@ -82,7 +82,7 @@
 }
 
 TEST(AutomaticGainController2InterpolatedGainCurve, CheckRegionBoundaries) {
-  InterpolatedGainCurve igc(&apm_data_dumper);
+  InterpolatedGainCurve igc(&apm_data_dumper, "");
 
   const std::vector<double> levels{
       {kLevelEpsilon, limiter.knee_start_linear() + kLevelEpsilon,
@@ -101,7 +101,7 @@
 
 TEST(AutomaticGainController2InterpolatedGainCurve, CheckIdentityRegion) {
   constexpr size_t kNumSteps = 10;
-  InterpolatedGainCurve igc(&apm_data_dumper);
+  InterpolatedGainCurve igc(&apm_data_dumper, "");
 
   const auto levels =
       test::LinSpace(kLevelEpsilon, limiter.knee_start_linear(), kNumSteps);
@@ -120,7 +120,7 @@
 TEST(AutomaticGainController2InterpolatedGainCurve,
      CheckNoOverApproximationKnee) {
   constexpr size_t kNumSteps = 10;
-  InterpolatedGainCurve igc(&apm_data_dumper);
+  InterpolatedGainCurve igc(&apm_data_dumper, "");
 
   const auto levels =
       test::LinSpace(limiter.knee_start_linear() + kLevelEpsilon,
@@ -142,7 +142,7 @@
 TEST(AutomaticGainController2InterpolatedGainCurve,
      CheckNoOverApproximationBeyondKnee) {
   constexpr size_t kNumSteps = 10;
-  InterpolatedGainCurve igc(&apm_data_dumper);
+  InterpolatedGainCurve igc(&apm_data_dumper, "");
 
   const auto levels = test::LinSpace(
       limiter.limiter_start_linear() + kLevelEpsilon,
@@ -164,7 +164,7 @@
 TEST(AutomaticGainController2InterpolatedGainCurve,
      CheckNoOverApproximationWithSaturation) {
   constexpr size_t kNumSteps = 3;
-  InterpolatedGainCurve igc(&apm_data_dumper);
+  InterpolatedGainCurve igc(&apm_data_dumper, "");
 
   const auto levels = test::LinSpace(
       limiter.max_input_level_linear() + kLevelEpsilon,
@@ -185,7 +185,7 @@
   test::InterpolatedParameters parameters =
       test::ComputeInterpolatedGainCurveApproximationParams();
 
-  InterpolatedGainCurve igc(&apm_data_dumper);
+  InterpolatedGainCurve igc(&apm_data_dumper, "");
 
   for (size_t i = 0; i < kInterpolatedGainCurveTotalPoints; ++i) {
     // The tolerance levels are chosen to account for deviations due
diff --git a/modules/audio_processing/agc2/rnn_vad/BUILD.gn b/modules/audio_processing/agc2/rnn_vad/BUILD.gn
index 41521df..d1edece 100644
--- a/modules/audio_processing/agc2/rnn_vad/BUILD.gn
+++ b/modules/audio_processing/agc2/rnn_vad/BUILD.gn
@@ -8,13 +8,7 @@
 
 import("../../../../webrtc.gni")
 
-group("rnn_vad") {
-  deps = [
-    ":lib",
-  ]
-}
-
-rtc_source_set("lib") {
+rtc_source_set("rnn_vad") {
   sources = [
     "common.h",
     "features_extraction.cc",
@@ -50,7 +44,7 @@
 }
 
 if (rtc_include_tests) {
-  rtc_source_set("lib_test") {
+  rtc_source_set("test_utils") {
     testonly = true
     sources = [
       "test_utils.cc",
@@ -104,8 +98,8 @@
       "symmetric_matrix_buffer_unittest.cc",
     ]
     deps = [
-      ":lib",
-      ":lib_test",
+      ":rnn_vad",
+      ":test_utils",
       "../..:audioproc_test_utils",
       "../../../../api:array_view",
       "../../../../common_audio/",
@@ -126,7 +120,7 @@
       "rnn_vad_tool.cc",
     ]
     deps = [
-      ":lib",
+      ":rnn_vad",
       "../../../../api:array_view",
       "../../../../common_audio:common_audio",
       "../../../../rtc_base:rtc_base_approved",
diff --git a/modules/audio_processing/audio_buffer.h b/modules/audio_processing/audio_buffer.h
index 3d7c4a8..ade3eec 100644
--- a/modules/audio_processing/audio_buffer.h
+++ b/modules/audio_processing/audio_buffer.h
@@ -18,7 +18,6 @@
 #include "common_audio/channel_buffer.h"
 #include "modules/audio_processing/include/audio_processing.h"
 #include "modules/audio_processing/splitting_filter.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/audio_processing_impl.cc b/modules/audio_processing/audio_processing_impl.cc
index 7e5955a..8848b73 100644
--- a/modules/audio_processing/audio_processing_impl.cc
+++ b/modules/audio_processing/audio_processing_impl.cc
@@ -24,7 +24,9 @@
 #include "modules/audio_processing/audio_buffer.h"
 #include "modules/audio_processing/common.h"
 #include "modules/audio_processing/echo_cancellation_impl.h"
+#include "modules/audio_processing/echo_cancellation_proxy.h"
 #include "modules/audio_processing/echo_control_mobile_impl.h"
+#include "modules/audio_processing/echo_control_mobile_proxy.h"
 #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"
@@ -33,10 +35,9 @@
 #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"
-#if WEBRTC_INTELLIGIBILITY_ENHANCER
-#include "modules/audio_processing/intelligibility/intelligibility_enhancer.h"
-#endif
 #include "modules/audio_processing/level_estimator_impl.h"
 #include "modules/audio_processing/low_cut_filter.h"
 #include "modules/audio_processing/noise_suppression_impl.h"
@@ -46,14 +47,6 @@
 #include "rtc_base/atomicops.h"
 #include "system_wrappers/include/metrics.h"
 
-// Check to verify that the define for the intelligibility enhancer is properly
-// set.
-#if !defined(WEBRTC_INTELLIGIBILITY_ENHANCER) || \
-    (WEBRTC_INTELLIGIBILITY_ENHANCER != 0 &&     \
-     WEBRTC_INTELLIGIBILITY_ENHANCER != 1)
-#error "Set WEBRTC_INTELLIGIBILITY_ENHANCER to either 0 or 1"
-#endif
-
 #define RETURN_ON_ERR(expr) \
   do {                      \
     int err = (expr);       \
@@ -154,9 +147,11 @@
 
 AudioProcessingImpl::ApmSubmoduleStates::ApmSubmoduleStates(
     bool capture_post_processor_enabled,
-    bool render_pre_processor_enabled)
+    bool render_pre_processor_enabled,
+    bool capture_analyzer_enabled)
     : capture_post_processor_enabled_(capture_post_processor_enabled),
-      render_pre_processor_enabled_(render_pre_processor_enabled) {}
+      render_pre_processor_enabled_(render_pre_processor_enabled),
+      capture_analyzer_enabled_(capture_analyzer_enabled) {}
 
 bool AudioProcessingImpl::ApmSubmoduleStates::Update(
     bool low_cut_filter_enabled,
@@ -164,7 +159,6 @@
     bool mobile_echo_controller_enabled,
     bool residual_echo_detector_enabled,
     bool noise_suppressor_enabled,
-    bool intelligibility_enhancer_enabled,
     bool adaptive_gain_controller_enabled,
     bool gain_controller2_enabled,
     bool pre_amplifier_enabled,
@@ -181,8 +175,6 @@
       (residual_echo_detector_enabled != residual_echo_detector_enabled_);
   changed |= (noise_suppressor_enabled != noise_suppressor_enabled_);
   changed |=
-      (intelligibility_enhancer_enabled != intelligibility_enhancer_enabled_);
-  changed |=
       (adaptive_gain_controller_enabled != adaptive_gain_controller_enabled_);
   changed |=
       (gain_controller2_enabled != gain_controller2_enabled_);
@@ -198,7 +190,6 @@
     mobile_echo_controller_enabled_ = mobile_echo_controller_enabled;
     residual_echo_detector_enabled_ = residual_echo_detector_enabled;
     noise_suppressor_enabled_ = noise_suppressor_enabled;
-    intelligibility_enhancer_enabled_ = intelligibility_enhancer_enabled;
     adaptive_gain_controller_enabled_ = adaptive_gain_controller_enabled;
     gain_controller2_enabled_ = gain_controller2_enabled;
     pre_amplifier_enabled_ = pre_amplifier_enabled;
@@ -215,12 +206,7 @@
 
 bool AudioProcessingImpl::ApmSubmoduleStates::CaptureMultiBandSubModulesActive()
     const {
-#if WEBRTC_INTELLIGIBILITY_ENHANCER
-  return CaptureMultiBandProcessingActive() ||
-         intelligibility_enhancer_enabled_ || voice_activity_detector_enabled_;
-#else
   return CaptureMultiBandProcessingActive() || voice_activity_detector_enabled_;
-#endif
 }
 
 bool AudioProcessingImpl::ApmSubmoduleStates::CaptureMultiBandProcessingActive()
@@ -236,6 +222,10 @@
          pre_amplifier_enabled_;
 }
 
+bool AudioProcessingImpl::ApmSubmoduleStates::CaptureAnalyzerActive() const {
+  return capture_analyzer_enabled_;
+}
+
 bool AudioProcessingImpl::ApmSubmoduleStates::RenderMultiBandSubModulesActive()
     const {
   return RenderMultiBandProcessingActive() || echo_canceller_enabled_ ||
@@ -250,11 +240,7 @@
 
 bool AudioProcessingImpl::ApmSubmoduleStates::RenderMultiBandProcessingActive()
     const {
-#if WEBRTC_INTELLIGIBILITY_ENHANCER
-  return intelligibility_enhancer_enabled_;
-#else
   return false;
-#endif
 }
 
 struct AudioProcessingImpl::ApmPublicSubmodules {
@@ -262,6 +248,8 @@
   // Accessed externally of APM without any lock acquired.
   std::unique_ptr<EchoCancellationImpl> echo_cancellation;
   std::unique_ptr<EchoControlMobileImpl> echo_control_mobile;
+  std::unique_ptr<EchoCancellationProxy> echo_cancellation_proxy;
+  std::unique_ptr<EchoControlMobileProxy> echo_control_mobile_proxy;
   std::unique_ptr<GainControlImpl> gain_control;
   std::unique_ptr<LevelEstimatorImpl> level_estimator;
   std::unique_ptr<NoiseSuppressionImpl> noise_suppression;
@@ -271,18 +259,17 @@
 
   // Accessed internally from both render and capture.
   std::unique_ptr<TransientSuppressor> transient_suppressor;
-#if WEBRTC_INTELLIGIBILITY_ENHANCER
-  std::unique_ptr<IntelligibilityEnhancer> intelligibility_enhancer;
-#endif
 };
 
 struct AudioProcessingImpl::ApmPrivateSubmodules {
   ApmPrivateSubmodules(std::unique_ptr<CustomProcessing> capture_post_processor,
                        std::unique_ptr<CustomProcessing> render_pre_processor,
-                       rtc::scoped_refptr<EchoDetector> echo_detector)
+                       rtc::scoped_refptr<EchoDetector> echo_detector,
+                       std::unique_ptr<CustomAudioAnalyzer> capture_analyzer)
       : echo_detector(std::move(echo_detector)),
         capture_post_processor(std::move(capture_post_processor)),
-        render_pre_processor(std::move(render_pre_processor)) {}
+        render_pre_processor(std::move(render_pre_processor)),
+        capture_analyzer(std::move(capture_analyzer)) {}
   // Accessed internally from capture or during initialization
   std::unique_ptr<AgcManagerDirect> agc_manager;
   std::unique_ptr<GainController2> gain_controller2;
@@ -292,6 +279,7 @@
   std::unique_ptr<CustomProcessing> capture_post_processor;
   std::unique_ptr<CustomProcessing> render_pre_processor;
   std::unique_ptr<GainApplier> pre_amplifier;
+  std::unique_ptr<CustomAudioAnalyzer> capture_analyzer;
 };
 
 AudioProcessingBuilder::AudioProcessingBuilder() = default;
@@ -309,6 +297,12 @@
   return *this;
 }
 
+AudioProcessingBuilder& AudioProcessingBuilder::SetCaptureAnalyzer(
+    std::unique_ptr<CustomAudioAnalyzer> capture_analyzer) {
+  capture_analyzer_ = std::move(capture_analyzer);
+  return *this;
+}
+
 AudioProcessingBuilder& AudioProcessingBuilder::SetEchoControlFactory(
     std::unique_ptr<EchoControlFactory> echo_control_factory) {
   echo_control_factory_ = std::move(echo_control_factory);
@@ -330,7 +324,7 @@
   AudioProcessingImpl* apm = new rtc::RefCountedObject<AudioProcessingImpl>(
       config, std::move(capture_post_processing_),
       std::move(render_pre_processing_), std::move(echo_control_factory_),
-      std::move(echo_detector_));
+      std::move(echo_detector_), std::move(capture_analyzer_));
   if (apm->Initialize() != AudioProcessing::kNoError) {
     delete apm;
     apm = nullptr;
@@ -339,7 +333,8 @@
 }
 
 AudioProcessingImpl::AudioProcessingImpl(const webrtc::Config& config)
-    : AudioProcessingImpl(config, nullptr, nullptr, nullptr, nullptr) {}
+    : AudioProcessingImpl(config, nullptr, nullptr, nullptr, nullptr, nullptr) {
+}
 
 int AudioProcessingImpl::instance_count_ = 0;
 
@@ -348,7 +343,8 @@
     std::unique_ptr<CustomProcessing> capture_post_processor,
     std::unique_ptr<CustomProcessing> render_pre_processor,
     std::unique_ptr<EchoControlFactory> echo_control_factory,
-    rtc::scoped_refptr<EchoDetector> echo_detector)
+    rtc::scoped_refptr<EchoDetector> echo_detector,
+    std::unique_ptr<CustomAudioAnalyzer> capture_analyzer)
     : data_dumper_(
           new ApmDataDumper(rtc::AtomicOps::Increment(&instance_count_))),
       capture_runtime_settings_(kRuntimeSettingQueueSize),
@@ -357,12 +353,15 @@
       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),
+      submodule_states_(!!capture_post_processor,
+                        !!render_pre_processor,
+                        !!capture_analyzer),
       public_submodules_(new ApmPublicSubmodules()),
       private_submodules_(
           new ApmPrivateSubmodules(std::move(capture_post_processor),
                                    std::move(render_pre_processor),
-                                   std::move(echo_detector))),
+                                   std::move(echo_detector),
+                                   std::move(capture_analyzer))),
       constants_(config.Get<ExperimentalAgc>().startup_min_volume,
                  config.Get<ExperimentalAgc>().clipped_level_min,
 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS)
@@ -372,14 +371,14 @@
 #else
                  config.Get<ExperimentalAgc>().enabled,
                  config.Get<ExperimentalAgc>().enabled_agc2_level_estimator,
-                 config.Get<ExperimentalAgc>().enabled_agc2_digital_adaptive),
+                 config.Get<ExperimentalAgc>().digital_adaptive_disabled),
 #endif
 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS)
       capture_(false),
 #else
       capture_(config.Get<ExperimentalNs>().enabled),
 #endif
-      capture_nonlocked_(config.Get<Intelligibility>().enabled) {
+      capture_nonlocked_() {
   {
     rtc::CritScope cs_render(&crit_render_);
     rtc::CritScope cs_capture(&crit_capture_);
@@ -392,6 +391,11 @@
         new EchoCancellationImpl(&crit_render_, &crit_capture_));
     public_submodules_->echo_control_mobile.reset(
         new EchoControlMobileImpl(&crit_render_, &crit_capture_));
+    public_submodules_->echo_cancellation_proxy.reset(new EchoCancellationProxy(
+        this, public_submodules_->echo_cancellation.get()));
+    public_submodules_->echo_control_mobile_proxy.reset(
+        new EchoControlMobileProxy(
+            this, public_submodules_->echo_control_mobile.get()));
     public_submodules_->gain_control.reset(
         new GainControlImpl(&crit_render_, &crit_capture_));
     public_submodules_->level_estimator.reset(
@@ -414,7 +418,9 @@
     // implemented.
     private_submodules_->gain_controller2.reset(new GainController2());
 
-    RTC_LOG(LS_INFO) << "Capture post processor activated: "
+    RTC_LOG(LS_INFO) << "Capture analyzer activated: "
+                     << !!private_submodules_->capture_analyzer
+                     << "\nCapture post processor activated: "
                      << !!private_submodules_->capture_post_processor
                      << "\nRender pre processor activated: "
                      << !!private_submodules_->render_pre_processor;
@@ -556,9 +562,6 @@
     public_submodules_->gain_control_for_experimental_agc->Initialize();
   }
   InitializeTransient();
-#if WEBRTC_INTELLIGIBILITY_ENHANCER
-  InitializeIntelligibility();
-#endif
   InitializeLowCutFilter();
   public_submodules_->noise_suppression->Initialize(num_proc_channels(),
                                                     proc_sample_rate_hz());
@@ -567,11 +570,12 @@
   InitializeResidualEchoDetector();
   InitializeEchoController();
   InitializeGainController2();
+  InitializeAnalyzer();
   InitializePostProcessor();
   InitializePreProcessor();
 
   if (aec_dump_) {
-    aec_dump_->WriteInitMessage(formats_.api_format);
+    aec_dump_->WriteInitMessage(formats_.api_format, rtc::TimeUTCMillis());
   }
   return kNoError;
 }
@@ -666,6 +670,13 @@
   rtc::CritScope cs_render(&crit_render_);
   rtc::CritScope cs_capture(&crit_capture_);
 
+  static_cast<EchoCancellation*>(public_submodules_->echo_cancellation.get())
+      ->Enable(config_.echo_canceller.enabled &&
+               !config_.echo_canceller.mobile_mode);
+  static_cast<EchoControlMobile*>(public_submodules_->echo_control_mobile.get())
+      ->Enable(config_.echo_canceller.enabled &&
+               config_.echo_canceller.mobile_mode);
+
   InitializeLowCutFilter();
 
   RTC_LOG(LS_INFO) << "Highpass filter activated: "
@@ -701,15 +712,6 @@
         config.Get<ExperimentalNs>().enabled;
     InitializeTransient();
   }
-
-#if WEBRTC_INTELLIGIBILITY_ENHANCER
-  if (capture_nonlocked_.intelligibility_enabled !=
-     config.Get<Intelligibility>().enabled) {
-    capture_nonlocked_.intelligibility_enabled =
-        config.Get<Intelligibility>().enabled;
-    InitializeIntelligibility();
-  }
-#endif
 }
 
 int AudioProcessingImpl::proc_sample_rate_hz() const {
@@ -1098,10 +1100,10 @@
   TRACE_EVENT0("webrtc", "AudioProcessing::ProcessStream_AudioFrame");
   {
     // Acquire the capture lock in order to safely call the function
-    // that retrieves the render side data. This function accesses apm
+    // 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() aquires this lock
+    // public_submodules_->echo_control_mobile->is_enabled() acquires this lock
     // as well.
     rtc::CritScope cs_capture(&crit_capture_);
     EmptyQueuedRenderAudio();
@@ -1265,18 +1267,6 @@
     capture_buffer->CopyLowPassToReference();
   }
   public_submodules_->noise_suppression->ProcessCaptureAudio(capture_buffer);
-#if WEBRTC_INTELLIGIBILITY_ENHANCER
-  if (capture_nonlocked_.intelligibility_enabled) {
-    RTC_DCHECK(public_submodules_->noise_suppression->is_enabled());
-    const int gain_db =
-        public_submodules_->gain_control->is_enabled()
-            ? public_submodules_->gain_control->compression_gain_db()
-            : 0;
-    const float gain = DbToRatio(gain_db);
-    public_submodules_->intelligibility_enhancer->SetCaptureNoiseEstimate(
-        public_submodules_->noise_suppression->NoiseEstimate(), gain);
-  }
-#endif
 
   // Ensure that the stream delay was set before the call to the
   // AECM ProcessCaptureAudio function.
@@ -1332,7 +1322,14 @@
         capture_.key_pressed);
   }
 
+  // Experimental APM sub-module that analyzes |capture_buffer|.
+  if (private_submodules_->capture_analyzer) {
+    private_submodules_->capture_analyzer->Analyze(capture_buffer);
+  }
+
   if (config_.gain_controller2.enabled) {
+    private_submodules_->gain_controller2->NotifyAnalogLevel(
+        gain_control()->stream_analog_level());
     private_submodules_->gain_controller2->Process(capture_buffer);
   }
 
@@ -1478,32 +1475,25 @@
 int AudioProcessingImpl::ProcessRenderStreamLocked() {
   AudioBuffer* render_buffer = render_.render_audio.get();  // For brevity.
 
-  QueueNonbandedRenderAudio(render_buffer);
-
   HandleRenderRuntimeSettings();
 
   if (private_submodules_->render_pre_processor) {
     private_submodules_->render_pre_processor->Process(render_buffer);
   }
 
+  QueueNonbandedRenderAudio(render_buffer);
+
   if (submodule_states_.RenderMultiBandSubModulesActive() &&
       SampleRateSupportsMultiBand(
           formats_.render_processing_format.sample_rate_hz())) {
     render_buffer->SplitIntoFrequencyBands();
   }
 
-#if WEBRTC_INTELLIGIBILITY_ENHANCER
-  if (capture_nonlocked_.intelligibility_enabled) {
-    public_submodules_->intelligibility_enhancer->ProcessRenderAudio(
-        render_buffer);
-  }
-#endif
-
   if (submodule_states_.RenderMultiBandSubModulesActive()) {
     QueueBandedRenderAudio(render_buffer);
   }
 
-  // TODO(peah): Perform the queueing ínside QueueRenderAudiuo().
+  // TODO(peah): Perform the queuing inside QueueRenderAudiuo().
   if (private_submodules_->echo_controller) {
     private_submodules_->echo_controller->AnalyzeRender(render_buffer);
   }
@@ -1572,7 +1562,7 @@
   // 'aec_dump' parameter, which is after locks are released.
   aec_dump_.swap(aec_dump);
   WriteAecDumpConfigMessage(true);
-  aec_dump_->WriteInitMessage(formats_.api_format);
+  aec_dump_->WriteInitMessage(formats_.api_format, rtc::TimeUTCMillis());
 }
 
 void AudioProcessingImpl::DetachAecDump() {
@@ -1710,11 +1700,11 @@
 }
 
 EchoCancellation* AudioProcessingImpl::echo_cancellation() const {
-  return public_submodules_->echo_cancellation.get();
+  return public_submodules_->echo_cancellation_proxy.get();
 }
 
 EchoControlMobile* AudioProcessingImpl::echo_control_mobile() const {
-  return public_submodules_->echo_control_mobile.get();
+  return public_submodules_->echo_control_mobile_proxy.get();
 }
 
 GainControl* AudioProcessingImpl::gain_control() const {
@@ -1761,7 +1751,6 @@
       public_submodules_->echo_control_mobile->is_enabled(),
       config_.residual_echo_detector.enabled,
       public_submodules_->noise_suppression->is_enabled(),
-      capture_nonlocked_.intelligibility_enabled,
       public_submodules_->gain_control->is_enabled(),
       config_.gain_controller2.enabled, config_.pre_amplifier.enabled,
       capture_nonlocked_.echo_controller_enabled,
@@ -1782,18 +1771,6 @@
   }
 }
 
-void AudioProcessingImpl::InitializeIntelligibility() {
-#if WEBRTC_INTELLIGIBILITY_ENHANCER
-  if (capture_nonlocked_.intelligibility_enabled) {
-    public_submodules_->intelligibility_enhancer.reset(
-        new IntelligibilityEnhancer(capture_nonlocked_.split_rate,
-                                    render_.render_audio->num_channels(),
-                                    render_.render_audio->num_bands(),
-                                    NoiseSuppressionImpl::num_noise_bins()));
-  }
-#endif
-}
-
 void AudioProcessingImpl::InitializeLowCutFilter() {
   if (config_.high_pass_filter.enabled) {
     private_submodules_->low_cut_filter.reset(
@@ -1834,6 +1811,13 @@
       formats_.render_processing_format.sample_rate_hz(), 1);
 }
 
+void AudioProcessingImpl::InitializeAnalyzer() {
+  if (private_submodules_->capture_analyzer) {
+    private_submodules_->capture_analyzer->Initialize(proc_sample_rate_hz(),
+                                                      num_proc_channels());
+  }
+}
+
 void AudioProcessingImpl::InitializePostProcessor() {
   if (private_submodules_->capture_post_processor) {
     private_submodules_->capture_post_processor->Initialize(
@@ -1974,8 +1958,6 @@
 
   apm_config.transient_suppression_enabled =
       capture_.transient_suppressor_enabled;
-  apm_config.intelligibility_enhancer_enabled =
-      capture_nonlocked_.intelligibility_enabled;
   apm_config.experiments_description = experiments_description;
   apm_config.pre_amplifier_enabled = config_.pre_amplifier.enabled;
   apm_config.pre_amplifier_fixed_gain_factor =
diff --git a/modules/audio_processing/audio_processing_impl.h b/modules/audio_processing/audio_processing_impl.h
index 44d0d08..a95e150 100644
--- a/modules/audio_processing/audio_processing_impl.h
+++ b/modules/audio_processing/audio_processing_impl.h
@@ -42,7 +42,8 @@
                       std::unique_ptr<CustomProcessing> capture_post_processor,
                       std::unique_ptr<CustomProcessing> render_pre_processor,
                       std::unique_ptr<EchoControlFactory> echo_control_factory,
-                      rtc::scoped_refptr<EchoDetector> echo_detector);
+                      rtc::scoped_refptr<EchoDetector> echo_detector,
+                      std::unique_ptr<CustomAudioAnalyzer> capture_analyzer);
   ~AudioProcessingImpl() override;
   int Initialize() override;
   int Initialize(int capture_input_sample_rate_hz,
@@ -174,14 +175,14 @@
   class ApmSubmoduleStates {
    public:
     ApmSubmoduleStates(bool capture_post_processor_enabled,
-                       bool render_pre_processor_enabled);
+                       bool render_pre_processor_enabled,
+                       bool capture_analyzer_enabled);
     // Updates the submodule state and returns true if it has changed.
     bool Update(bool low_cut_filter_enabled,
                 bool echo_canceller_enabled,
                 bool mobile_echo_controller_enabled,
                 bool residual_echo_detector_enabled,
                 bool noise_suppressor_enabled,
-                bool intelligibility_enhancer_enabled,
                 bool adaptive_gain_controller_enabled,
                 bool gain_controller2_enabled,
                 bool pre_amplifier_enabled,
@@ -192,6 +193,7 @@
     bool CaptureMultiBandSubModulesActive() const;
     bool CaptureMultiBandProcessingActive() const;
     bool CaptureFullBandProcessingActive() const;
+    bool CaptureAnalyzerActive() const;
     bool RenderMultiBandSubModulesActive() const;
     bool RenderFullBandProcessingActive() const;
     bool RenderMultiBandProcessingActive() const;
@@ -199,12 +201,12 @@
    private:
     const bool capture_post_processor_enabled_ = false;
     const bool render_pre_processor_enabled_ = false;
+    const bool capture_analyzer_enabled_ = false;
     bool low_cut_filter_enabled_ = false;
     bool echo_canceller_enabled_ = false;
     bool mobile_echo_controller_enabled_ = false;
     bool residual_echo_detector_enabled_ = false;
     bool noise_suppressor_enabled_ = false;
-    bool intelligibility_enhancer_enabled_ = false;
     bool adaptive_gain_controller_enabled_ = false;
     bool gain_controller2_enabled_ = false;
     bool pre_amplifier_enabled_ = false;
@@ -241,8 +243,6 @@
   // acquired.
   void InitializeTransient()
       RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_render_, crit_capture_);
-  void InitializeIntelligibility()
-      RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_render_, crit_capture_);
   int InitializeLocked(const ProcessingConfig& config)
       RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_render_, crit_capture_);
   void InitializeResidualEchoDetector()
@@ -252,6 +252,7 @@
   void InitializeGainController2() RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_capture_);
   void InitializePreAmplifier() RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_capture_);
   void InitializePostProcessor() RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_capture_);
+  void InitializeAnalyzer() RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_capture_);
   void InitializePreProcessor() RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_render_);
 
   // Empties and handles the respective RuntimeSetting queues.
@@ -394,18 +395,16 @@
   } capture_ RTC_GUARDED_BY(crit_capture_);
 
   struct ApmCaptureNonLockedState {
-    ApmCaptureNonLockedState(bool intelligibility_enabled)
+    ApmCaptureNonLockedState()
         : capture_processing_format(kSampleRate16kHz),
           split_rate(kSampleRate16kHz),
-          stream_delay_ms(0),
-          intelligibility_enabled(intelligibility_enabled) {}
+          stream_delay_ms(0) {}
     // Only the rate and samples fields of capture_processing_format_ are used
     // because the forward processing number of channels is mutable and is
     // tracked by the capture_audio_.
     StreamConfig capture_processing_format;
     int split_rate;
     int stream_delay_ms;
-    bool intelligibility_enabled;
     bool echo_controller_enabled = false;
   } capture_nonlocked_;
 
diff --git a/modules/audio_processing/audio_processing_impl_unittest.cc b/modules/audio_processing/audio_processing_impl_unittest.cc
index 3ac5e71..8926f02 100644
--- a/modules/audio_processing/audio_processing_impl_unittest.cc
+++ b/modules/audio_processing/audio_processing_impl_unittest.cc
@@ -10,7 +10,10 @@
 
 #include "modules/audio_processing/audio_processing_impl.h"
 
+#include "modules/audio_processing/include/audio_processing.h"
 #include "modules/audio_processing/test/test_utils.h"
+#include "rtc_base/refcountedobject.h"
+#include "rtc_base/scoped_ref_ptr.h"
 #include "test/gmock.h"
 #include "test/gtest.h"
 
@@ -33,24 +36,83 @@
   MOCK_CONST_METHOD0(Release, rtc::RefCountReleaseStatus());
 };
 
-void GenerateFixedFrame(int16_t audio_level,
-                        size_t input_rate,
-                        size_t num_channels,
-                        AudioFrame* fixed_frame) {
+void InitializeAudioFrame(size_t input_rate,
+                          size_t num_channels,
+                          AudioFrame* frame) {
   const size_t samples_per_input_channel = rtc::CheckedDivExact(
       input_rate, static_cast<size_t>(rtc::CheckedDivExact(
                       1000, AudioProcessing::kChunkSizeMs)));
-  fixed_frame->samples_per_channel_ = samples_per_input_channel;
-  fixed_frame->sample_rate_hz_ = input_rate;
-  fixed_frame->num_channels_ = num_channels;
-
   RTC_DCHECK_LE(samples_per_input_channel * num_channels,
                 AudioFrame::kMaxDataSizeSamples);
-  for (size_t i = 0; i < samples_per_input_channel * num_channels; ++i) {
-    fixed_frame->mutable_data()[i] = audio_level;
+  frame->samples_per_channel_ = samples_per_input_channel;
+  frame->sample_rate_hz_ = input_rate;
+  frame->num_channels_ = num_channels;
+}
+
+void FillFixedFrame(int16_t audio_level, AudioFrame* frame) {
+  const size_t num_samples = frame->samples_per_channel_ * frame->num_channels_;
+  for (size_t i = 0; i < num_samples; ++i) {
+    frame->mutable_data()[i] = audio_level;
   }
 }
 
+// Mocks EchoDetector and records the first samples of the last analyzed render
+// stream frame. Used to check what data is read by an EchoDetector
+// implementation injected into an APM.
+class TestEchoDetector : public EchoDetector {
+ public:
+  TestEchoDetector()
+      : analyze_render_audio_called_(false),
+        last_render_audio_first_sample_(0.f) {}
+  ~TestEchoDetector() override = default;
+  void AnalyzeRenderAudio(rtc::ArrayView<const float> render_audio) override {
+    last_render_audio_first_sample_ = render_audio[0];
+    analyze_render_audio_called_ = true;
+  }
+  void AnalyzeCaptureAudio(rtc::ArrayView<const float> capture_audio) override {
+  }
+  void Initialize(int capture_sample_rate_hz,
+                  int num_capture_channels,
+                  int render_sample_rate_hz,
+                  int num_render_channels) override {}
+  EchoDetector::Metrics GetMetrics() const override { return {}; }
+  // Returns true if AnalyzeRenderAudio() has been called at least once.
+  bool analyze_render_audio_called() const {
+    return analyze_render_audio_called_;
+  }
+  // Returns the first sample of the last analyzed render frame.
+  float last_render_audio_first_sample() const {
+    return last_render_audio_first_sample_;
+  }
+
+ private:
+  bool analyze_render_audio_called_;
+  float last_render_audio_first_sample_;
+};
+
+// Mocks CustomProcessing and applies ProcessSample() to all the samples.
+// Meant to be injected into an APM to modify samples in a known and detectable
+// way.
+class TestRenderPreProcessor : public CustomProcessing {
+ public:
+  TestRenderPreProcessor() = default;
+  ~TestRenderPreProcessor() = default;
+  void Initialize(int sample_rate_hz, int num_channels) override {}
+  void Process(AudioBuffer* audio) override {
+    for (size_t k = 0; k < audio->num_channels(); ++k) {
+      rtc::ArrayView<float> channel_view(audio->channels_f()[k],
+                                         audio->num_frames());
+      std::transform(channel_view.begin(), channel_view.end(),
+                     channel_view.begin(), ProcessSample);
+    }
+  };
+  std::string ToString() const override { return "TestRenderPreProcessor"; }
+  void SetRuntimeSetting(AudioProcessing::RuntimeSetting setting) override {}
+  // Modifies a sample. This member is used in Process() to modify a frame and
+  // it is publicly visible to enable tests.
+  static constexpr float ProcessSample(float x) { return 2.f * x; }
+};
+
 }  // namespace
 
 TEST(AudioProcessingImplTest, AudioParameterChangeTriggersInit) {
@@ -98,26 +160,74 @@
   apm->ApplyConfig(apm_config);
 
   AudioFrame frame;
-  constexpr int16_t audio_level = 10000;
-  constexpr size_t input_rate = 48000;
-  constexpr size_t num_channels = 2;
+  constexpr int16_t kAudioLevel = 10000;
+  constexpr size_t kSampleRateHz = 48000;
+  constexpr size_t kNumChannels = 2;
+  InitializeAudioFrame(kSampleRateHz, kNumChannels, &frame);
 
-  GenerateFixedFrame(audio_level, input_rate, num_channels, &frame);
+  FillFixedFrame(kAudioLevel, &frame);
   apm->ProcessStream(&frame);
-  EXPECT_EQ(frame.data()[100], audio_level)
+  EXPECT_EQ(frame.data()[100], kAudioLevel)
       << "With factor 1, frame shouldn't be modified.";
 
-  constexpr float gain_factor = 2.f;
+  constexpr float kGainFactor = 2.f;
   apm->SetRuntimeSetting(
-      AudioProcessing::RuntimeSetting::CreateCapturePreGain(gain_factor));
+      AudioProcessing::RuntimeSetting::CreateCapturePreGain(kGainFactor));
 
   // Process for two frames to have time to ramp up gain.
   for (int i = 0; i < 2; ++i) {
-    GenerateFixedFrame(audio_level, input_rate, num_channels, &frame);
+    FillFixedFrame(kAudioLevel, &frame);
     apm->ProcessStream(&frame);
   }
-  EXPECT_EQ(frame.data()[100], gain_factor * audio_level)
+  EXPECT_EQ(frame.data()[100], kGainFactor * kAudioLevel)
       << "Frame should be amplified.";
 }
 
+TEST(AudioProcessingImplTest, RenderPreProcessorBeforeEchoDetector) {
+  // Make sure that signal changes caused by a render pre-processing sub-module
+  // take place before any echo detector analysis.
+  rtc::scoped_refptr<TestEchoDetector> test_echo_detector(
+      new rtc::RefCountedObject<TestEchoDetector>());
+  std::unique_ptr<CustomProcessing> test_render_pre_processor(
+      new TestRenderPreProcessor());
+  // Create APM injecting the test echo detector and render pre-processor.
+  std::unique_ptr<AudioProcessing> apm(
+      AudioProcessingBuilder()
+          .SetEchoDetector(test_echo_detector)
+          .SetRenderPreProcessing(std::move(test_render_pre_processor))
+          .Create());
+  webrtc::AudioProcessing::Config apm_config;
+  apm_config.pre_amplifier.enabled = true;
+  apm_config.residual_echo_detector.enabled = true;
+  apm->ApplyConfig(apm_config);
+
+  constexpr int16_t kAudioLevel = 1000;
+  constexpr int kSampleRateHz = 16000;
+  constexpr size_t kNumChannels = 1;
+  AudioFrame frame;
+  InitializeAudioFrame(kSampleRateHz, kNumChannels, &frame);
+
+  constexpr float kAudioLevelFloat = static_cast<float>(kAudioLevel);
+  constexpr float kExpectedPreprocessedAudioLevel =
+      TestRenderPreProcessor::ProcessSample(kAudioLevelFloat);
+  ASSERT_NE(kAudioLevelFloat, kExpectedPreprocessedAudioLevel);
+
+  // Analyze a render stream frame.
+  FillFixedFrame(kAudioLevel, &frame);
+  ASSERT_EQ(AudioProcessing::Error::kNoError,
+            apm->ProcessReverseStream(&frame));
+  // Trigger a call to in EchoDetector::AnalyzeRenderAudio() via
+  // ProcessStream().
+  FillFixedFrame(kAudioLevel, &frame);
+  ASSERT_EQ(AudioProcessing::Error::kNoError, apm->ProcessStream(&frame));
+  // Regardless of how the call to in EchoDetector::AnalyzeRenderAudio() is
+  // triggered, the line below checks that the call has occurred. If not, the
+  // APM implementation may have changed and this test might need to be adapted.
+  ASSERT_TRUE(test_echo_detector->analyze_render_audio_called());
+  // Check that the data read in EchoDetector::AnalyzeRenderAudio() is that
+  // produced by the render pre-processor.
+  EXPECT_EQ(kExpectedPreprocessedAudioLevel,
+            test_echo_detector->last_render_audio_first_sample());
+}
+
 }  // namespace webrtc
diff --git a/modules/audio_processing/audio_processing_performance_unittest.cc b/modules/audio_processing/audio_processing_performance_unittest.cc
index 56615cb..df8d5fe 100644
--- a/modules/audio_processing/audio_processing_performance_unittest.cc
+++ b/modules/audio_processing/audio_processing_performance_unittest.cc
@@ -26,14 +26,6 @@
 #include "test/gtest.h"
 #include "test/testsupport/perf_test.h"
 
-// Check to verify that the define for the intelligibility enhancer is properly
-// set.
-#if !defined(WEBRTC_INTELLIGIBILITY_ENHANCER) || \
-    (WEBRTC_INTELLIGIBILITY_ENHANCER != 0 &&     \
-     WEBRTC_INTELLIGIBILITY_ENHANCER != 1)
-#error "Set WEBRTC_INTELLIGIBILITY_ENHANCER to either 0 or 1"
-#endif
-
 namespace webrtc {
 
 namespace {
@@ -49,7 +41,6 @@
 enum class SettingsType {
   kDefaultApmDesktop,
   kDefaultApmMobile,
-  kDefaultApmDesktopAndIntelligibilityEnhancer,
   kAllSubmodulesTurnedOff,
   kDefaultApmDesktopWithoutDelayAgnostic,
   kDefaultApmDesktopWithoutExtendedFilter
@@ -99,20 +90,6 @@
         simulation_configs.push_back(SimulationConfig(sample_rate, settings));
       }
     }
-
-#if WEBRTC_INTELLIGIBILITY_ENHANCER == 1
-    const SettingsType intelligibility_enhancer_settings[] = {
-        SettingsType::kDefaultApmDesktopAndIntelligibilityEnhancer};
-
-    const int intelligibility_enhancer_sample_rates[] = {8000, 16000, 32000,
-                                                         48000};
-
-    for (auto sample_rate : intelligibility_enhancer_sample_rates) {
-      for (auto settings : intelligibility_enhancer_settings) {
-        simulation_configs.push_back(SimulationConfig(sample_rate, settings));
-      }
-    }
-#endif
 #endif
 
     const SettingsType mobile_settings[] = {SettingsType::kDefaultApmMobile};
@@ -137,9 +114,6 @@
       case SettingsType::kDefaultApmDesktop:
         description = "DefaultApmDesktop";
         break;
-      case SettingsType::kDefaultApmDesktopAndIntelligibilityEnhancer:
-        description = "DefaultApmDesktopAndIntelligibilityEnhancer";
-        break;
       case SettingsType::kAllSubmodulesTurnedOff:
         description = "AllSubmodulesOff";
         break;
@@ -538,16 +512,6 @@
         apm_->SetExtraOptions(config);
         break;
       }
-      case SettingsType::kDefaultApmDesktopAndIntelligibilityEnhancer: {
-        Config config;
-        config.Set<Intelligibility>(new Intelligibility(true));
-        add_default_desktop_config(&config);
-        apm_.reset(AudioProcessingBuilder().Create(config));
-        ASSERT_TRUE(!!apm_);
-        set_default_desktop_apm_runtime_settings(apm_.get());
-        apm_->SetExtraOptions(config);
-        break;
-      }
       case SettingsType::kAllSubmodulesTurnedOff: {
         apm_.reset(AudioProcessingBuilder().Create());
         ASSERT_TRUE(!!apm_);
diff --git a/modules/audio_processing/audio_processing_unittest.cc b/modules/audio_processing/audio_processing_unittest.cc
index 4b244fc..b04f89a 100644
--- a/modules/audio_processing/audio_processing_unittest.cc
+++ b/modules/audio_processing/audio_processing_unittest.cc
@@ -28,6 +28,7 @@
 #include "modules/audio_processing/test/test_utils.h"
 #include "rtc_base/arraysize.h"
 #include "rtc_base/checks.h"
+#include "rtc_base/fakeclock.h"
 #include "rtc_base/gtest_prod_util.h"
 #include "rtc_base/ignore_wundef.h"
 #include "rtc_base/numerics/safe_conversions.h"
@@ -35,6 +36,7 @@
 #include "rtc_base/protobuf_utils.h"
 #include "rtc_base/refcountedobject.h"
 #include "rtc_base/swap_queue.h"
+#include "rtc_base/system/arch.h"
 #include "rtc_base/task_queue.h"
 #include "rtc_base/thread.h"
 #include "system_wrappers/include/event_wrapper.h"
@@ -176,23 +178,26 @@
 }
 
 void EnableAllAPComponents(AudioProcessing* ap) {
+  AudioProcessing::Config apm_config = ap->GetConfig();
+  apm_config.echo_canceller.enabled = true;
 #if defined(WEBRTC_AUDIOPROC_FIXED_PROFILE)
-  EXPECT_NOERR(ap->echo_control_mobile()->Enable(true));
+  apm_config.echo_canceller.mobile_mode = true;
 
   EXPECT_NOERR(ap->gain_control()->set_mode(GainControl::kAdaptiveDigital));
   EXPECT_NOERR(ap->gain_control()->Enable(true));
 #elif defined(WEBRTC_AUDIOPROC_FLOAT_PROFILE)
+  apm_config.echo_canceller.mobile_mode = false;
   EXPECT_NOERR(ap->echo_cancellation()->enable_drift_compensation(true));
   EXPECT_NOERR(ap->echo_cancellation()->enable_metrics(true));
   EXPECT_NOERR(ap->echo_cancellation()->enable_delay_logging(true));
-  EXPECT_NOERR(ap->echo_cancellation()->Enable(true));
+  EXPECT_NOERR(ap->echo_cancellation()->set_suppression_level(
+      EchoCancellation::SuppressionLevel::kModerateSuppression));
 
   EXPECT_NOERR(ap->gain_control()->set_mode(GainControl::kAdaptiveAnalog));
   EXPECT_NOERR(ap->gain_control()->set_analog_level_limits(0, 255));
   EXPECT_NOERR(ap->gain_control()->Enable(true));
 #endif
 
-  AudioProcessing::Config apm_config;
   apm_config.high_pass_filter.enabled = true;
   ap->ApplyConfig(apm_config);
 
@@ -1729,6 +1734,7 @@
 }
 
 void ApmTest::VerifyDebugDumpTest(Format format) {
+  rtc::ScopedFakeClock fake_clock;
   const std::string in_filename = test::ResourcePath("ref03", "aecdump");
   std::string format_string;
   switch (format) {
@@ -2182,9 +2188,9 @@
       // or generate a separate android reference.
 #if defined(WEBRTC_ANDROID)
       const int kHasVoiceCountOffset = 3;
-      const int kHasVoiceCountNear = 4;
+      const int kHasVoiceCountNear = 8;
       const int kMaxOutputAverageOffset = 9;
-      const int kMaxOutputAverageNear = 9;
+      const int kMaxOutputAverageNear = 26;
 #else
       const int kHasVoiceCountOffset = 0;
       const int kHasVoiceCountNear = kIntNear;
@@ -2796,6 +2802,25 @@
   apm->ProcessReverseStream(&audio);
 }
 
+TEST(ApmConfiguration, EnableCaptureAnalyzer) {
+  // Verify that apm uses a capture analyzer if one is provided.
+  auto mock_capture_analyzer_ptr =
+      new testing::NiceMock<test::MockCustomAudioAnalyzer>();
+  auto mock_capture_analyzer =
+      std::unique_ptr<CustomAudioAnalyzer>(mock_capture_analyzer_ptr);
+  rtc::scoped_refptr<AudioProcessing> apm =
+      AudioProcessingBuilder()
+          .SetCaptureAnalyzer(std::move(mock_capture_analyzer))
+          .Create();
+
+  AudioFrame audio;
+  audio.num_channels_ = 1;
+  SetFrameSampleRate(&audio, AudioProcessing::NativeRate::kSampleRate16kHz);
+
+  EXPECT_CALL(*mock_capture_analyzer_ptr, Analyze(testing::_)).Times(1);
+  apm->ProcessStream(&audio);
+}
+
 TEST(ApmConfiguration, PreProcessingReceivesRuntimeSettings) {
   auto mock_pre_processor_ptr =
       new testing::NiceMock<test::MockCustomProcessing>();
diff --git a/modules/audio_processing/debug.proto b/modules/audio_processing/debug.proto
index f7f8d10..b19f7fe 100644
--- a/modules/audio_processing/debug.proto
+++ b/modules/audio_processing/debug.proto
@@ -14,6 +14,7 @@
   optional int32 output_sample_rate = 7;
   optional int32 reverse_output_sample_rate = 8;
   optional int32 num_reverse_output_channels = 9;
+  optional int64 timestamp_ms = 10;
 }
 
 // May contain interleaved or deinterleaved data, but don't store both formats.
@@ -46,7 +47,6 @@
 // Contains the configurations of various APM component. A Config message is
 // added when any of the fields are changed.
 message Config {
-  // Next field number 19.
   // Acoustic echo canceler.
   optional bool aec_enabled = 1;
   optional bool aec_delay_agnostic_enabled = 2;
@@ -72,11 +72,12 @@
   // Semicolon-separated string containing experimental feature
   // descriptions.
   optional string experiments_description = 17;
-  // Intelligibility Enhancer.
-  optional bool intelligibility_enhancer_enabled = 18;
+  reserved 18;  // Intelligibility enhancer enabled (deprecated).
   // Pre amplifier.
   optional bool pre_amplifier_enabled = 19;
   optional float pre_amplifier_fixed_gain_factor = 20;
+
+  // Next field number 21.
 }
 
 message Event {
diff --git a/modules/audio_processing/echo_cancellation_impl.cc b/modules/audio_processing/echo_cancellation_impl.cc
index 15cd0db..9feaea7 100644
--- a/modules/audio_processing/echo_cancellation_impl.cc
+++ b/modules/audio_processing/echo_cancellation_impl.cc
@@ -109,7 +109,7 @@
       crit_capture_(crit_capture),
       drift_compensation_enabled_(false),
       metrics_enabled_(false),
-      suppression_level_(kModerateSuppression),
+      suppression_level_(kHighSuppression),
       stream_drift_samples_(0),
       was_stream_drift_set_(false),
       stream_has_echo_(false),
diff --git a/modules/audio_processing/echo_cancellation_proxy.cc b/modules/audio_processing/echo_cancellation_proxy.cc
new file mode 100644
index 0000000..e8b1fbd
--- /dev/null
+++ b/modules/audio_processing/echo_cancellation_proxy.cc
@@ -0,0 +1,100 @@
+/*
+ *  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/echo_cancellation_proxy.h"
+
+namespace webrtc {
+
+EchoCancellationProxy::EchoCancellationProxy(
+    AudioProcessing* audio_processing,
+    EchoCancellation* echo_cancellation)
+    : audio_processing_(audio_processing),
+      echo_cancellation_(echo_cancellation) {}
+
+EchoCancellationProxy::~EchoCancellationProxy() = default;
+
+int EchoCancellationProxy::Enable(bool enable) {
+  // Change the config in APM to mirror the applied settings.
+  // TODO(bugs.webrtc.org/9535): Remove the call to EchoCancellation::Enable
+  // when APM starts taking the config into account.
+  AudioProcessing::Config apm_config = audio_processing_->GetConfig();
+  bool aec2_enabled = apm_config.echo_canceller.enabled &&
+                      !apm_config.echo_canceller.mobile_mode;
+  if ((aec2_enabled && !enable) || (!aec2_enabled && enable)) {
+    apm_config.echo_canceller.enabled = enable;
+    apm_config.echo_canceller.mobile_mode = false;
+    audio_processing_->ApplyConfig(apm_config);
+  }
+  echo_cancellation_->Enable(enable);
+  return AudioProcessing::kNoError;
+}
+
+bool EchoCancellationProxy::is_enabled() const {
+  return echo_cancellation_->is_enabled();
+}
+
+int EchoCancellationProxy::enable_drift_compensation(bool enable) {
+  return echo_cancellation_->enable_drift_compensation(enable);
+}
+
+bool EchoCancellationProxy::is_drift_compensation_enabled() const {
+  return echo_cancellation_->is_drift_compensation_enabled();
+}
+
+void EchoCancellationProxy::set_stream_drift_samples(int drift) {
+  echo_cancellation_->set_stream_drift_samples(drift);
+}
+
+int EchoCancellationProxy::stream_drift_samples() const {
+  return echo_cancellation_->stream_drift_samples();
+}
+
+int EchoCancellationProxy::set_suppression_level(
+    EchoCancellation::SuppressionLevel level) {
+  return echo_cancellation_->set_suppression_level(level);
+}
+
+EchoCancellation::SuppressionLevel EchoCancellationProxy::suppression_level()
+    const {
+  return echo_cancellation_->suppression_level();
+}
+
+bool EchoCancellationProxy::stream_has_echo() const {
+  return echo_cancellation_->stream_has_echo();
+}
+int EchoCancellationProxy::enable_metrics(bool enable) {
+  return echo_cancellation_->enable_metrics(enable);
+}
+bool EchoCancellationProxy::are_metrics_enabled() const {
+  return echo_cancellation_->are_metrics_enabled();
+}
+int EchoCancellationProxy::GetMetrics(Metrics* metrics) {
+  return echo_cancellation_->GetMetrics(metrics);
+}
+int EchoCancellationProxy::enable_delay_logging(bool enable) {
+  return echo_cancellation_->enable_delay_logging(enable);
+}
+bool EchoCancellationProxy::is_delay_logging_enabled() const {
+  return echo_cancellation_->is_delay_logging_enabled();
+}
+int EchoCancellationProxy::GetDelayMetrics(int* median, int* std) {
+  return echo_cancellation_->GetDelayMetrics(median, std);
+}
+int EchoCancellationProxy::GetDelayMetrics(int* median,
+                                           int* std,
+                                           float* fraction_poor_delays) {
+  return echo_cancellation_->GetDelayMetrics(median, std, fraction_poor_delays);
+}
+
+struct AecCore* EchoCancellationProxy::aec_core() const {
+  return echo_cancellation_->aec_core();
+}
+
+}  // namespace webrtc
diff --git a/modules/audio_processing/echo_cancellation_proxy.h b/modules/audio_processing/echo_cancellation_proxy.h
new file mode 100644
index 0000000..f2d3017
--- /dev/null
+++ b/modules/audio_processing/echo_cancellation_proxy.h
@@ -0,0 +1,55 @@
+/*
+ *  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_ECHO_CANCELLATION_PROXY_H_
+#define MODULES_AUDIO_PROCESSING_ECHO_CANCELLATION_PROXY_H_
+
+#include "modules/audio_processing/include/audio_processing.h"
+#include "rtc_base/constructormagic.h"
+#include "rtc_base/scoped_ref_ptr.h"
+
+namespace webrtc {
+
+// Class for temporarily redirecting AEC2 configuration to a new API.
+class EchoCancellationProxy : public EchoCancellation {
+ public:
+  EchoCancellationProxy(AudioProcessing* audio_processing,
+                        EchoCancellation* echo_cancellation);
+  ~EchoCancellationProxy() override;
+
+  int Enable(bool enable) override;
+  bool is_enabled() const override;
+  int enable_drift_compensation(bool enable) override;
+  bool is_drift_compensation_enabled() const override;
+  void set_stream_drift_samples(int drift) override;
+  int stream_drift_samples() const override;
+  int set_suppression_level(SuppressionLevel level) override;
+  SuppressionLevel suppression_level() const override;
+  bool stream_has_echo() const override;
+  int enable_metrics(bool enable) override;
+  bool are_metrics_enabled() const override;
+  int GetMetrics(Metrics* metrics) override;
+  int enable_delay_logging(bool enable) override;
+  bool is_delay_logging_enabled() const override;
+  int GetDelayMetrics(int* median, int* std) override;
+  int GetDelayMetrics(int* median,
+                      int* std,
+                      float* fraction_poor_delays) override;
+  struct AecCore* aec_core() const override;
+
+ private:
+  AudioProcessing* audio_processing_;
+  EchoCancellation* echo_cancellation_;
+
+  RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(EchoCancellationProxy);
+};
+}  // namespace webrtc
+
+#endif  // MODULES_AUDIO_PROCESSING_ECHO_CANCELLATION_PROXY_H_
diff --git a/modules/audio_processing/echo_control_mobile_impl.cc b/modules/audio_processing/echo_control_mobile_impl.cc
index 841364f..272da7a 100644
--- a/modules/audio_processing/echo_control_mobile_impl.cc
+++ b/modules/audio_processing/echo_control_mobile_impl.cc
@@ -113,7 +113,7 @@
     : crit_render_(crit_render),
       crit_capture_(crit_capture),
       routing_mode_(kSpeakerphone),
-      comfort_noise_enabled_(true),
+      comfort_noise_enabled_(false),
       external_echo_path_(NULL) {
   RTC_DCHECK(crit_render);
   RTC_DCHECK(crit_capture);
diff --git a/modules/audio_processing/echo_control_mobile_proxy.cc b/modules/audio_processing/echo_control_mobile_proxy.cc
new file mode 100644
index 0000000..fd29834
--- /dev/null
+++ b/modules/audio_processing/echo_control_mobile_proxy.cc
@@ -0,0 +1,69 @@
+/*
+ *  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/echo_control_mobile_proxy.h"
+
+namespace webrtc {
+
+EchoControlMobileProxy::EchoControlMobileProxy(
+    AudioProcessing* audio_processing,
+    EchoControlMobile* echo_control_mobile)
+    : audio_processing_(audio_processing),
+      echo_control_mobile_(echo_control_mobile) {}
+
+EchoControlMobileProxy::~EchoControlMobileProxy() = default;
+
+int EchoControlMobileProxy::Enable(bool enable) {
+  // Change the config in APM to mirror the applied settings.
+  // TODO(bugs.webrtc.org/9535): Remove the call to EchoControlMobile::Enable
+  // when APM starts taking the config into account.
+  AudioProcessing::Config apm_config = audio_processing_->GetConfig();
+  bool aecm_enabled = apm_config.echo_canceller.enabled &&
+                      apm_config.echo_canceller.mobile_mode;
+  if ((aecm_enabled && !enable) || (!aecm_enabled && enable)) {
+    apm_config.echo_canceller.enabled = enable;
+    apm_config.echo_canceller.mobile_mode = true;
+    audio_processing_->ApplyConfig(apm_config);
+  }
+  echo_control_mobile_->Enable(enable);
+  return AudioProcessing::kNoError;
+}
+
+bool EchoControlMobileProxy::is_enabled() const {
+  return echo_control_mobile_->is_enabled();
+}
+
+int EchoControlMobileProxy::set_routing_mode(RoutingMode mode) {
+  return echo_control_mobile_->set_routing_mode(mode);
+}
+
+EchoControlMobile::RoutingMode EchoControlMobileProxy::routing_mode() const {
+  return echo_control_mobile_->routing_mode();
+}
+
+int EchoControlMobileProxy::enable_comfort_noise(bool enable) {
+  return echo_control_mobile_->enable_comfort_noise(enable);
+}
+
+bool EchoControlMobileProxy::is_comfort_noise_enabled() const {
+  return echo_control_mobile_->is_comfort_noise_enabled();
+}
+
+int EchoControlMobileProxy::SetEchoPath(const void* echo_path,
+                                        size_t size_bytes) {
+  return echo_control_mobile_->SetEchoPath(echo_path, size_bytes);
+}
+
+int EchoControlMobileProxy::GetEchoPath(void* echo_path,
+                                        size_t size_bytes) const {
+  return echo_control_mobile_->GetEchoPath(echo_path, size_bytes);
+}
+
+}  // namespace webrtc
diff --git a/modules/audio_processing/echo_control_mobile_proxy.h b/modules/audio_processing/echo_control_mobile_proxy.h
new file mode 100644
index 0000000..eb5908a
--- /dev/null
+++ b/modules/audio_processing/echo_control_mobile_proxy.h
@@ -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.
+ */
+
+#ifndef MODULES_AUDIO_PROCESSING_ECHO_CONTROL_MOBILE_PROXY_H_
+#define MODULES_AUDIO_PROCESSING_ECHO_CONTROL_MOBILE_PROXY_H_
+
+#include "modules/audio_processing/include/audio_processing.h"
+#include "rtc_base/constructormagic.h"
+#include "rtc_base/scoped_ref_ptr.h"
+
+namespace webrtc {
+
+// Class for temporarily redirecting AECM configuration to a new API.
+class EchoControlMobileProxy : public EchoControlMobile {
+ public:
+  EchoControlMobileProxy(AudioProcessing* audio_processing,
+                         EchoControlMobile* echo_control_mobile);
+  ~EchoControlMobileProxy() override;
+
+  bool is_enabled() const override;
+  RoutingMode routing_mode() const override;
+  bool is_comfort_noise_enabled() const override;
+  int Enable(bool enable) override;
+  int set_routing_mode(RoutingMode mode) override;
+  int enable_comfort_noise(bool enable) override;
+  int SetEchoPath(const void* echo_path, size_t size_bytes) override;
+  int GetEchoPath(void* echo_path, size_t size_bytes) const override;
+
+ private:
+  AudioProcessing* audio_processing_;
+  EchoControlMobile* echo_control_mobile_;
+
+  RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(EchoControlMobileProxy);
+};
+}  // namespace webrtc
+
+#endif  // MODULES_AUDIO_PROCESSING_ECHO_CONTROL_MOBILE_PROXY_H_
diff --git a/modules/audio_processing/gain_control_for_experimental_agc.cc b/modules/audio_processing/gain_control_for_experimental_agc.cc
index d5d978c..4ab856c 100644
--- a/modules/audio_processing/gain_control_for_experimental_agc.cc
+++ b/modules/audio_processing/gain_control_for_experimental_agc.cc
@@ -12,6 +12,7 @@
 
 #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"
 
@@ -22,12 +23,11 @@
 GainControlForExperimentalAgc::GainControlForExperimentalAgc(
     GainControl* gain_control,
     rtc::CriticalSection* crit_capture)
-    : data_dumper_(new ApmDataDumper(instance_counter_)),
+    : data_dumper_(
+          new ApmDataDumper(rtc::AtomicOps::Increment(&instance_counter_))),
       real_gain_control_(gain_control),
       volume_(0),
-      crit_capture_(crit_capture) {
-  instance_counter_++;
-}
+      crit_capture_(crit_capture) {}
 
 GainControlForExperimentalAgc::~GainControlForExperimentalAgc() = default;
 
@@ -43,14 +43,18 @@
   rtc::CritScope cs_capture(crit_capture_);
   data_dumper_->DumpRaw("experimental_gain_control_set_stream_analog_level", 1,
                         &level);
+  do_log_level_ = true;
   volume_ = level;
   return AudioProcessing::kNoError;
 }
 
 int GainControlForExperimentalAgc::stream_analog_level() {
   rtc::CritScope cs_capture(crit_capture_);
-  data_dumper_->DumpRaw("experimental_gain_control_stream_analog_level", 1,
-                        &volume_);
+  if (do_log_level_) {
+    data_dumper_->DumpRaw("experimental_gain_control_stream_analog_level", 1,
+                          &volume_);
+    do_log_level_ = false;
+  }
   return volume_;
 }
 
diff --git a/modules/audio_processing/gain_control_for_experimental_agc.h b/modules/audio_processing/gain_control_for_experimental_agc.h
index 0894a0e..b20fbc9 100644
--- a/modules/audio_processing/gain_control_for_experimental_agc.h
+++ b/modules/audio_processing/gain_control_for_experimental_agc.h
@@ -68,6 +68,7 @@
   GainControl* real_gain_control_;
   int volume_;
   rtc::CriticalSection* crit_capture_;
+  bool do_log_level_ = true;
   static int instance_counter_;
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(GainControlForExperimentalAgc);
 };
diff --git a/modules/audio_processing/gain_controller2.cc b/modules/audio_processing/gain_controller2.cc
index 6c0149a..fd4b411 100644
--- a/modules/audio_processing/gain_controller2.cc
+++ b/modules/audio_processing/gain_controller2.cc
@@ -41,15 +41,25 @@
 void GainController2::Process(AudioBuffer* audio) {
   AudioFrameView<float> float_frame(audio->channels_f(), audio->num_channels(),
                                     audio->num_frames());
-  adaptive_agc_.Process(float_frame);
+  if (adaptive_digital_mode_) {
+    adaptive_agc_.Process(float_frame);
+  }
   fixed_gain_controller_.Process(float_frame);
 }
 
+void GainController2::NotifyAnalogLevel(int level) {
+  if (analog_level_ != level && adaptive_digital_mode_) {
+    adaptive_agc_.Reset();
+  }
+  analog_level_ = level;
+}
+
 void GainController2::ApplyConfig(
     const AudioProcessing::Config::GainController2& config) {
   RTC_DCHECK(Validate(config));
   config_ = config;
   fixed_gain_controller_.SetGain(config_.fixed_gain_db);
+  adaptive_digital_mode_ = config_.adaptive_digital_mode;
 }
 
 bool GainController2::Validate(
diff --git a/modules/audio_processing/gain_controller2.h b/modules/audio_processing/gain_controller2.h
index e2ca05e..b4727d0 100644
--- a/modules/audio_processing/gain_controller2.h
+++ b/modules/audio_processing/gain_controller2.h
@@ -33,6 +33,7 @@
 
   void Initialize(int sample_rate_hz);
   void Process(AudioBuffer* audio);
+  void NotifyAnalogLevel(int level);
 
   void ApplyConfig(const AudioProcessing::Config::GainController2& config);
   static bool Validate(const AudioProcessing::Config::GainController2& config);
@@ -45,6 +46,8 @@
   FixedGainController fixed_gain_controller_;
   AudioProcessing::Config::GainController2 config_;
   AdaptiveAgc adaptive_agc_;
+  int analog_level_ = -1;
+  bool adaptive_digital_mode_ = true;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(GainController2);
 };
diff --git a/modules/audio_processing/include/aec_dump.cc b/modules/audio_processing/include/aec_dump.cc
index c243b52..67809d0 100644
--- a/modules/audio_processing/include/aec_dump.cc
+++ b/modules/audio_processing/include/aec_dump.cc
@@ -32,8 +32,6 @@
          hpf_enabled == other.hpf_enabled && ns_enabled == other.ns_enabled &&
          ns_level == other.ns_level &&
          transient_suppression_enabled == other.transient_suppression_enabled &&
-         intelligibility_enhancer_enabled ==
-             other.intelligibility_enhancer_enabled &&
          noise_robust_agc_enabled == other.noise_robust_agc_enabled &&
          pre_amplifier_enabled == other.pre_amplifier_enabled &&
          pre_amplifier_fixed_gain_factor ==
diff --git a/modules/audio_processing/include/aec_dump.h b/modules/audio_processing/include/aec_dump.h
index 25c08b8..e32fa67 100644
--- a/modules/audio_processing/include/aec_dump.h
+++ b/modules/audio_processing/include/aec_dump.h
@@ -49,7 +49,6 @@
   bool ns_enabled = false;
   int ns_level = 0;
   bool transient_suppression_enabled = false;
-  bool intelligibility_enhancer_enabled = false;
   bool noise_robust_agc_enabled = false;
   bool pre_amplifier_enabled = false;
   float pre_amplifier_fixed_gain_factor = 1.f;
@@ -76,7 +75,11 @@
   virtual ~AecDump() = default;
 
   // Logs Event::Type INIT message.
-  virtual void WriteInitMessage(const ProcessingConfig& api_format) = 0;
+  virtual void WriteInitMessage(const ProcessingConfig& api_format,
+                                int64_t time_now_ms) = 0;
+  RTC_DEPRECATED void WriteInitMessage(const ProcessingConfig& api_format) {
+    WriteInitMessage(api_format, 0);
+  }
 
   // Logs Event::Type STREAM message. To log an input/output pair,
   // call the AddCapture* and AddAudioProcessingState methods followed
diff --git a/modules/audio_processing/include/audio_processing.h b/modules/audio_processing/include/audio_processing.h
index 9d27f16..f05d7b6 100644
--- a/modules/audio_processing/include/audio_processing.h
+++ b/modules/audio_processing/include/audio_processing.h
@@ -34,7 +34,6 @@
 #include "rtc_base/platform_file.h"
 #include "rtc_base/refcount.h"
 #include "rtc_base/scoped_ref_ptr.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
@@ -54,12 +53,10 @@
 class HighPassFilter;
 class LevelEstimator;
 class NoiseSuppression;
+class CustomAudioAnalyzer;
 class CustomProcessing;
 class VoiceDetection;
 
-// webrtc:8665, addedd temporarily to avoid breaking dependencies.
-typedef CustomProcessing PostProcessing;
-
 // Use to enable the extended filter mode in the AEC, along with robustness
 // measures around the reported system delays. It comes with a significant
 // increase in AEC complexity, but is much more robust to unreliable reported
@@ -125,10 +122,10 @@
   explicit ExperimentalAgc(bool enabled) : enabled(enabled) {}
   ExperimentalAgc(bool enabled,
                   bool enabled_agc2_level_estimator,
-                  bool enabled_agc2_digital_adaptive)
+                  bool digital_adaptive_disabled)
       : enabled(enabled),
         enabled_agc2_level_estimator(enabled_agc2_level_estimator),
-        enabled_agc2_digital_adaptive(enabled_agc2_digital_adaptive) {}
+        digital_adaptive_disabled(digital_adaptive_disabled) {}
 
   ExperimentalAgc(bool enabled, int startup_min_volume)
       : enabled(enabled), startup_min_volume(startup_min_volume) {}
@@ -142,7 +139,7 @@
   // Lowest microphone level that will be applied in response to clipping.
   int clipped_level_min = kClippedLevelMin;
   bool enabled_agc2_level_estimator = false;
-  bool enabled_agc2_digital_adaptive = false;
+  bool digital_adaptive_disabled = false;
 };
 
 // Use to enable experimental noise suppression. It can be set in the
@@ -154,17 +151,6 @@
   bool enabled;
 };
 
-// Use to enable intelligibility enhancer in audio processing.
-//
-// Note: If enabled and the reverse stream has more than one output channel,
-// the reverse stream will become an upmixed mono signal.
-struct Intelligibility {
-  Intelligibility() : enabled(false) {}
-  explicit Intelligibility(bool enabled) : enabled(enabled) {}
-  static const ConfigOptionID identifier = ConfigOptionID::kIntelligibility;
-  bool enabled;
-};
-
 // The Audio Processing Module (APM) provides a collection of voice processing
 // components designed for real-time communications software.
 //
@@ -253,6 +239,15 @@
   // 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;
+      // Recommended not to use. Will be removed in the future.
+      // APM components are not fine-tuned for legacy suppression levels.
+      bool legacy_moderate_suppression_level = false;
+    } echo_canceller;
+
     struct ResidualEchoDetector {
       bool enabled = true;
     } residual_echo_detector;
@@ -268,12 +263,15 @@
       float fixed_gain_factor = 1.f;
     } pre_amplifier;
 
-    // Enables the next generation AGC functionality. This feature
-    // replaces the standard methods of gain control in the previous
-    // AGC. This functionality is currently only partially
-    // implemented.
+    // Enables the next generation AGC functionality. This feature replaces the
+    // standard methods of gain control in the previous AGC. Enabling this
+    // submodule enables an adaptive digital AGC followed by a limiter. By
+    // setting |fixed_gain_db|, the limiter can be turned into a compressor that
+    // first applies a fixed gain. The adaptive digital AGC can be turned off by
+    // setting |adaptive_digital_mode=false|.
     struct GainController2 {
       bool enabled = false;
+      bool adaptive_digital_mode = true;
       float fixed_gain_db = 0.f;
     } gain_controller2;
 
@@ -667,6 +665,9 @@
   // The AudioProcessingBuilder takes ownership of the echo_detector.
   AudioProcessingBuilder& SetEchoDetector(
       rtc::scoped_refptr<EchoDetector> echo_detector);
+  // The AudioProcessingBuilder takes ownership of the capture_analyzer.
+  AudioProcessingBuilder& SetCaptureAnalyzer(
+      std::unique_ptr<CustomAudioAnalyzer> capture_analyzer);
   // This creates an APM instance using the previously set components. Calling
   // the Create function resets the AudioProcessingBuilder to its initial state.
   AudioProcessing* Create();
@@ -677,6 +678,7 @@
   std::unique_ptr<CustomProcessing> capture_post_processing_;
   std::unique_ptr<CustomProcessing> render_pre_processing_;
   rtc::scoped_refptr<EchoDetector> echo_detector_;
+  std::unique_ptr<CustomAudioAnalyzer> capture_analyzer_;
   RTC_DISALLOW_COPY_AND_ASSIGN(AudioProcessingBuilder);
 };
 
@@ -1010,6 +1012,19 @@
   virtual ~NoiseSuppression() {}
 };
 
+// Experimental interface for a custom analysis submodule.
+class CustomAudioAnalyzer {
+ public:
+  // (Re-) Initializes the submodule.
+  virtual void Initialize(int sample_rate_hz, int num_channels) = 0;
+  // Analyzes the given capture or render signal.
+  virtual void Analyze(const AudioBuffer* audio) = 0;
+  // Returns a string representation of the module state.
+  virtual std::string ToString() const = 0;
+
+  virtual ~CustomAudioAnalyzer() {}
+};
+
 // Interface for a custom processing submodule.
 class CustomProcessing {
  public:
diff --git a/modules/audio_processing/include/config.h b/modules/audio_processing/include/config.h
index 9232b2e..398aab6 100644
--- a/modules/audio_processing/include/config.h
+++ b/modules/audio_processing/include/config.h
@@ -30,9 +30,9 @@
   kDelayAgnostic,
   kExperimentalAgc,
   kExperimentalNs,
-  kBeamforming,  // Deprecated
-  kIntelligibility,
-  kEchoCanceller3,  // Deprecated
+  kBeamforming,      // Deprecated
+  kIntelligibility,  // Deprecated
+  kEchoCanceller3,   // Deprecated
   kAecRefinedAdaptiveFilter,
   kLevelControl  // Deprecated
 };
diff --git a/modules/audio_processing/include/mock_audio_processing.h b/modules/audio_processing/include/mock_audio_processing.h
index 9ceee10..2864e48 100644
--- a/modules/audio_processing/include/mock_audio_processing.h
+++ b/modules/audio_processing/include/mock_audio_processing.h
@@ -115,6 +115,14 @@
   MOCK_CONST_METHOD0(ToString, std::string());
 };
 
+class MockCustomAudioAnalyzer : public CustomAudioAnalyzer {
+ public:
+  virtual ~MockCustomAudioAnalyzer() {}
+  MOCK_METHOD2(Initialize, void(int sample_rate_hz, int num_channels));
+  MOCK_METHOD1(Analyze, void(const AudioBuffer* audio));
+  MOCK_CONST_METHOD0(ToString, std::string());
+};
+
 class MockEchoControl : public EchoControl {
  public:
   virtual ~MockEchoControl() {}
diff --git a/modules/audio_processing/intelligibility/intelligibility_enhancer.cc b/modules/audio_processing/intelligibility/intelligibility_enhancer.cc
deleted file mode 100644
index 0f7b118..0000000
--- a/modules/audio_processing/intelligibility/intelligibility_enhancer.cc
+++ /dev/null
@@ -1,390 +0,0 @@
-/*
- *  Copyright (c) 2014 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/intelligibility/intelligibility_enhancer.h"
-
-#include <math.h>
-#include <stdlib.h>
-#include <algorithm>
-#include <limits>
-#include <numeric>
-
-#include "common_audio/include/audio_util.h"
-#include "common_audio/window_generator.h"
-#include "rtc_base/checks.h"
-#include "rtc_base/logging.h"
-#include "rtc_base/numerics/safe_minmax.h"
-
-namespace webrtc {
-
-namespace {
-
-const size_t kErbResolution = 2;
-const int kWindowSizeMs = 16;
-const int kChunkSizeMs = 10;  // Size provided by APM.
-const float kClipFreqKhz = 0.2f;
-const float kKbdAlpha = 1.5f;
-const float kLambdaBot = -1.f;    // Extreme values in bisection
-const float kLambdaTop = -1e-5f;  // search for lamda.
-const float kVoiceProbabilityThreshold = 0.5f;
-// Number of chunks after voice activity which is still considered speech.
-const size_t kSpeechOffsetDelay = 10;
-const float kDecayRate = 0.995f;  // Power estimation decay rate.
-const float kMaxRelativeGainChange = 0.005f;
-const float kRho = 0.0004f;  // Default production and interpretation SNR.
-const float kPowerNormalizationFactor = 1.f / (1 << 30);
-const float kMaxActiveSNR = 128.f;   // 21dB
-const float kMinInactiveSNR = 32.f;  // 15dB
-const size_t kGainUpdatePeriod = 10u;
-
-// Returns dot product of vectors |a| and |b| with size |length|.
-float DotProduct(const float* a, const float* b, size_t length) {
-  float ret = 0.f;
-  for (size_t i = 0; i < length; ++i) {
-    ret += a[i] * b[i];
-  }
-  return ret;
-}
-
-// Computes the power across ERB bands from the power spectral density |pow|.
-// Stores it in |result|.
-void MapToErbBands(const float* pow,
-                   const std::vector<std::vector<float>>& filter_bank,
-                   float* result) {
-  for (size_t i = 0; i < filter_bank.size(); ++i) {
-    RTC_DCHECK_GT(filter_bank[i].size(), 0);
-    result[i] = kPowerNormalizationFactor *
-                DotProduct(filter_bank[i].data(), pow, filter_bank[i].size());
-  }
-}
-
-}  // namespace
-
-IntelligibilityEnhancer::IntelligibilityEnhancer(int sample_rate_hz,
-                                                 size_t num_render_channels,
-                                                 size_t num_bands,
-                                                 size_t num_noise_bins)
-    : freqs_(RealFourier::ComplexLength(
-          RealFourier::FftOrder(sample_rate_hz * kWindowSizeMs / 1000))),
-      num_noise_bins_(num_noise_bins),
-      chunk_length_(static_cast<size_t>(sample_rate_hz * kChunkSizeMs / 1000)),
-      bank_size_(GetBankSize(sample_rate_hz, kErbResolution)),
-      sample_rate_hz_(sample_rate_hz),
-      num_render_channels_(num_render_channels),
-      clear_power_estimator_(freqs_, kDecayRate),
-      noise_power_estimator_(num_noise_bins, kDecayRate),
-      filtered_clear_pow_(bank_size_, 0.f),
-      filtered_noise_pow_(num_noise_bins, 0.f),
-      center_freqs_(bank_size_),
-      capture_filter_bank_(CreateErbBank(num_noise_bins)),
-      render_filter_bank_(CreateErbBank(freqs_)),
-      gains_eq_(bank_size_),
-      gain_applier_(freqs_, kMaxRelativeGainChange),
-      audio_s16_(chunk_length_),
-      chunks_since_voice_(kSpeechOffsetDelay),
-      is_speech_(false),
-      snr_(kMaxActiveSNR),
-      is_active_(false),
-      num_chunks_(0u),
-      num_active_chunks_(0u),
-      noise_estimation_buffer_(num_noise_bins),
-      noise_estimation_queue_(kMaxNumNoiseEstimatesToBuffer,
-                              std::vector<float>(num_noise_bins),
-                              RenderQueueItemVerifier<float>(num_noise_bins)) {
-  RTC_DCHECK_LE(kRho, 1.f);
-
-  const size_t erb_index = static_cast<size_t>(
-      ceilf(11.17f * logf((kClipFreqKhz + 0.312f) / (kClipFreqKhz + 14.6575f)) +
-            43.f));
-  start_freq_ = std::max(static_cast<size_t>(1), erb_index * kErbResolution);
-
-  size_t window_size = static_cast<size_t>(1) << RealFourier::FftOrder(freqs_);
-  std::vector<float> kbd_window(window_size);
-  WindowGenerator::KaiserBesselDerived(kKbdAlpha, window_size,
-                                       kbd_window.data());
-  render_mangler_.reset(new LappedTransform(
-      num_render_channels_, num_render_channels_, chunk_length_,
-      kbd_window.data(), window_size, window_size / 2, this));
-
-  const size_t initial_delay = render_mangler_->initial_delay();
-  for (size_t i = 0u; i < num_bands - 1; ++i) {
-    high_bands_buffers_.push_back(std::unique_ptr<intelligibility::DelayBuffer>(
-        new intelligibility::DelayBuffer(initial_delay, num_render_channels_)));
-  }
-}
-
-IntelligibilityEnhancer::~IntelligibilityEnhancer() {
-  // Don't rely on this log, since the destructor isn't called when the
-  // app/tab is killed.
-  if (num_chunks_ > 0) {
-    RTC_LOG(LS_INFO) << "Intelligibility Enhancer was active for "
-                     << 100.f * static_cast<float>(num_active_chunks_) /
-                            num_chunks_
-                     << "% of the call.";
-  } else {
-    RTC_LOG(LS_INFO) << "Intelligibility Enhancer processed no chunk.";
-  }
-}
-
-void IntelligibilityEnhancer::SetCaptureNoiseEstimate(std::vector<float> noise,
-                                                      float gain) {
-  RTC_DCHECK_EQ(noise.size(), num_noise_bins_);
-  for (auto& bin : noise) {
-    bin *= gain;
-  }
-  // Disregarding return value since buffer overflow is acceptable, because it
-  // is not critical to get each noise estimate.
-  if (noise_estimation_queue_.Insert(&noise)) {
-  };
-}
-
-void IntelligibilityEnhancer::ProcessRenderAudio(AudioBuffer* audio) {
-  RTC_DCHECK_EQ(num_render_channels_, audio->num_channels());
-  while (noise_estimation_queue_.Remove(&noise_estimation_buffer_)) {
-    noise_power_estimator_.Step(noise_estimation_buffer_.data());
-  }
-  float* const* low_band = audio->split_channels_f(kBand0To8kHz);
-  is_speech_ = IsSpeech(low_band[0]);
-  render_mangler_->ProcessChunk(low_band, low_band);
-  DelayHighBands(audio);
-}
-
-void IntelligibilityEnhancer::ProcessAudioBlock(
-    const std::complex<float>* const* in_block,
-    size_t in_channels,
-    size_t frames,
-    size_t /* out_channels */,
-    std::complex<float>* const* out_block) {
-  RTC_DCHECK_EQ(freqs_, frames);
-  if (is_speech_) {
-    clear_power_estimator_.Step(in_block[0]);
-  }
-  SnrBasedEffectActivation();
-  ++num_chunks_;
-  if (is_active_) {
-    ++num_active_chunks_;
-    if (num_chunks_ % kGainUpdatePeriod == 0) {
-      MapToErbBands(clear_power_estimator_.power().data(), render_filter_bank_,
-                    filtered_clear_pow_.data());
-      MapToErbBands(noise_power_estimator_.power().data(), capture_filter_bank_,
-                    filtered_noise_pow_.data());
-      SolveForGainsGivenLambda(kLambdaTop, start_freq_, gains_eq_.data());
-      const float power_target =
-          std::accumulate(filtered_clear_pow_.data(),
-                          filtered_clear_pow_.data() + bank_size_, 0.f);
-      const float power_top =
-          DotProduct(gains_eq_.data(), filtered_clear_pow_.data(), bank_size_);
-      SolveForGainsGivenLambda(kLambdaBot, start_freq_, gains_eq_.data());
-      const float power_bot =
-          DotProduct(gains_eq_.data(), filtered_clear_pow_.data(), bank_size_);
-      if (power_target >= power_bot && power_target <= power_top) {
-        SolveForLambda(power_target);
-        UpdateErbGains();
-      }  // Else experiencing power underflow, so do nothing.
-    }
-  }
-  for (size_t i = 0; i < in_channels; ++i) {
-    gain_applier_.Apply(in_block[i], out_block[i]);
-  }
-}
-
-void IntelligibilityEnhancer::SnrBasedEffectActivation() {
-  const float* clear_psd = clear_power_estimator_.power().data();
-  const float* noise_psd = noise_power_estimator_.power().data();
-  const float clear_power = std::accumulate(clear_psd, clear_psd + freqs_, 0.f);
-  const float noise_power = std::accumulate(noise_psd, noise_psd + freqs_, 0.f);
-  snr_ = kDecayRate * snr_ +
-         (1.f - kDecayRate) * clear_power /
-             (noise_power + std::numeric_limits<float>::epsilon());
-  if (is_active_) {
-    if (snr_ > kMaxActiveSNR) {
-      RTC_LOG(LS_INFO) << "Intelligibility Enhancer was deactivated at chunk "
-                       << num_chunks_;
-      is_active_ = false;
-      // Set the target gains to unity.
-      float* gains = gain_applier_.target();
-      for (size_t i = 0; i < freqs_; ++i) {
-        gains[i] = 1.f;
-      }
-    }
-  } else {
-    if (snr_ < kMinInactiveSNR) {
-      RTC_LOG(LS_INFO) << "Intelligibility Enhancer was activated at chunk "
-                       << num_chunks_;
-      is_active_ = true;
-    }
-  }
-}
-
-void IntelligibilityEnhancer::SolveForLambda(float power_target) {
-  const float kConvergeThresh = 0.001f;  // TODO(ekmeyerson): Find best values
-  const int kMaxIters = 100;             // for these, based on experiments.
-
-  const float reciprocal_power_target =
-      1.f / (power_target + std::numeric_limits<float>::epsilon());
-  float lambda_bot = kLambdaBot;
-  float lambda_top = kLambdaTop;
-  float power_ratio = 2.f;  // Ratio of achieved power to target power.
-  int iters = 0;
-  while (std::fabs(power_ratio - 1.f) > kConvergeThresh && iters <= kMaxIters) {
-    const float lambda = (lambda_bot + lambda_top) / 2.f;
-    SolveForGainsGivenLambda(lambda, start_freq_, gains_eq_.data());
-    const float power =
-        DotProduct(gains_eq_.data(), filtered_clear_pow_.data(), bank_size_);
-    if (power < power_target) {
-      lambda_bot = lambda;
-    } else {
-      lambda_top = lambda;
-    }
-    power_ratio = std::fabs(power * reciprocal_power_target);
-    ++iters;
-  }
-}
-
-void IntelligibilityEnhancer::UpdateErbGains() {
-  // (ERB gain) = filterbank' * (freq gain)
-  float* gains = gain_applier_.target();
-  for (size_t i = 0; i < freqs_; ++i) {
-    gains[i] = 0.f;
-    for (size_t j = 0; j < bank_size_; ++j) {
-      gains[i] += render_filter_bank_[j][i] * gains_eq_[j];
-    }
-  }
-}
-
-size_t IntelligibilityEnhancer::GetBankSize(int sample_rate,
-                                            size_t erb_resolution) {
-  float freq_limit = sample_rate / 2000.f;
-  size_t erb_scale = static_cast<size_t>(ceilf(
-      11.17f * logf((freq_limit + 0.312f) / (freq_limit + 14.6575f)) + 43.f));
-  return erb_scale * erb_resolution;
-}
-
-std::vector<std::vector<float>> IntelligibilityEnhancer::CreateErbBank(
-    size_t num_freqs) {
-  std::vector<std::vector<float>> filter_bank(bank_size_);
-  size_t lf = 1, rf = 4;
-
-  for (size_t i = 0; i < bank_size_; ++i) {
-    float abs_temp = fabsf((i + 1.f) / static_cast<float>(kErbResolution));
-    center_freqs_[i] = 676170.4f / (47.06538f - expf(0.08950404f * abs_temp));
-    center_freqs_[i] -= 14678.49f;
-  }
-  float last_center_freq = center_freqs_[bank_size_ - 1];
-  for (size_t i = 0; i < bank_size_; ++i) {
-    center_freqs_[i] *= 0.5f * sample_rate_hz_ / last_center_freq;
-  }
-
-  for (size_t i = 0; i < bank_size_; ++i) {
-    filter_bank[i].resize(num_freqs);
-  }
-
-  for (size_t i = 1; i <= bank_size_; ++i) {
-    size_t lll = static_cast<size_t>(
-        round(center_freqs_[rtc::SafeMax<size_t>(1, i - lf) - 1] * num_freqs /
-              (0.5f * sample_rate_hz_)));
-    size_t ll = static_cast<size_t>(
-        round(center_freqs_[rtc::SafeMax<size_t>(1, i) - 1] * num_freqs /
-              (0.5f * sample_rate_hz_)));
-    lll = rtc::SafeClamp<size_t>(lll, 1, num_freqs) - 1;
-    ll = rtc::SafeClamp<size_t>(ll, 1, num_freqs) - 1;
-
-    size_t rrr = static_cast<size_t>(
-        round(center_freqs_[rtc::SafeMin<size_t>(bank_size_, i + rf) - 1] *
-              num_freqs / (0.5f * sample_rate_hz_)));
-    size_t rr = static_cast<size_t>(
-        round(center_freqs_[rtc::SafeMin<size_t>(bank_size_, i + 1) - 1] *
-              num_freqs / (0.5f * sample_rate_hz_)));
-    rrr = rtc::SafeClamp<size_t>(rrr, 1, num_freqs) - 1;
-    rr = rtc::SafeClamp<size_t>(rr, 1, num_freqs) - 1;
-
-    float step = ll == lll ? 0.f : 1.f / (ll - lll);
-    float element = 0.f;
-    for (size_t j = lll; j <= ll; ++j) {
-      filter_bank[i - 1][j] = element;
-      element += step;
-    }
-    step = rr == rrr ? 0.f : 1.f / (rrr - rr);
-    element = 1.f;
-    for (size_t j = rr; j <= rrr; ++j) {
-      filter_bank[i - 1][j] = element;
-      element -= step;
-    }
-    for (size_t j = ll; j <= rr; ++j) {
-      filter_bank[i - 1][j] = 1.f;
-    }
-  }
-
-  for (size_t i = 0; i < num_freqs; ++i) {
-    float sum = 0.f;
-    for (size_t j = 0; j < bank_size_; ++j) {
-      sum += filter_bank[j][i];
-    }
-    for (size_t j = 0; j < bank_size_; ++j) {
-      filter_bank[j][i] /= sum;
-    }
-  }
-  return filter_bank;
-}
-
-void IntelligibilityEnhancer::SolveForGainsGivenLambda(float lambda,
-                                                       size_t start_freq,
-                                                       float* sols) {
-  const float kMinPower = 1e-5f;
-
-  const float* pow_x0 = filtered_clear_pow_.data();
-  const float* pow_n0 = filtered_noise_pow_.data();
-
-  for (size_t n = 0; n < start_freq; ++n) {
-    sols[n] = 1.f;
-  }
-
-  // Analytic solution for optimal gains. See paper for derivation.
-  for (size_t n = start_freq; n < bank_size_; ++n) {
-    if (pow_x0[n] < kMinPower || pow_n0[n] < kMinPower) {
-      sols[n] = 1.f;
-    } else {
-      const float gamma0 = 0.5f * kRho * pow_x0[n] * pow_n0[n] +
-                           lambda * pow_x0[n] * pow_n0[n] * pow_n0[n];
-      const float beta0 =
-          lambda * pow_x0[n] * (2.f - kRho) * pow_x0[n] * pow_n0[n];
-      const float alpha0 =
-          lambda * pow_x0[n] * (1.f - kRho) * pow_x0[n] * pow_x0[n];
-      RTC_DCHECK_LT(alpha0, 0.f);
-      // The quadratic equation should always have real roots, but to guard
-      // against numerical errors we limit it to a minimum of zero.
-      sols[n] = std::max(
-          0.f, (-beta0 - std::sqrt(std::max(
-                             0.f, beta0 * beta0 - 4.f * alpha0 * gamma0))) /
-                   (2.f * alpha0));
-    }
-  }
-}
-
-bool IntelligibilityEnhancer::IsSpeech(const float* audio) {
-  FloatToS16(audio, chunk_length_, audio_s16_.data());
-  vad_.ProcessChunk(audio_s16_.data(), chunk_length_, sample_rate_hz_);
-  if (vad_.last_voice_probability() > kVoiceProbabilityThreshold) {
-    chunks_since_voice_ = 0;
-  } else if (chunks_since_voice_ < kSpeechOffsetDelay) {
-    ++chunks_since_voice_;
-  }
-  return chunks_since_voice_ < kSpeechOffsetDelay;
-}
-
-void IntelligibilityEnhancer::DelayHighBands(AudioBuffer* audio) {
-  RTC_DCHECK_EQ(audio->num_bands(), high_bands_buffers_.size() + 1);
-  for (size_t i = 0u; i < high_bands_buffers_.size(); ++i) {
-    Band band = static_cast<Band>(i + 1);
-    high_bands_buffers_[i]->Delay(audio->split_channels_f(band), chunk_length_);
-  }
-}
-
-}  // namespace webrtc
diff --git a/modules/audio_processing/intelligibility/intelligibility_enhancer.h b/modules/audio_processing/intelligibility/intelligibility_enhancer.h
deleted file mode 100644
index 3513092..0000000
--- a/modules/audio_processing/intelligibility/intelligibility_enhancer.h
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
- *  Copyright (c) 2014 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_INTELLIGIBILITY_INTELLIGIBILITY_ENHANCER_H_
-#define MODULES_AUDIO_PROCESSING_INTELLIGIBILITY_INTELLIGIBILITY_ENHANCER_H_
-
-#include <complex>
-#include <memory>
-#include <vector>
-
-#include "common_audio/channel_buffer.h"
-#include "common_audio/lapped_transform.h"
-#include "modules/audio_processing/audio_buffer.h"
-#include "modules/audio_processing/intelligibility/intelligibility_utils.h"
-#include "modules/audio_processing/render_queue_item_verifier.h"
-#include "modules/audio_processing/vad/voice_activity_detector.h"
-#include "rtc_base/swap_queue.h"
-
-namespace webrtc {
-
-// Speech intelligibility enhancement module. Reads render and capture
-// audio streams and modifies the render stream with a set of gains per
-// frequency bin to enhance speech against the noise background.
-// Details of the model and algorithm can be found in the original paper:
-// http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=6882788
-class IntelligibilityEnhancer : public LappedTransform::Callback {
- public:
-  IntelligibilityEnhancer(int sample_rate_hz,
-                          size_t num_render_channels,
-                          size_t num_bands,
-                          size_t num_noise_bins);
-
-  ~IntelligibilityEnhancer() override;
-
-  // Sets the capture noise magnitude spectrum estimate.
-  void SetCaptureNoiseEstimate(std::vector<float> noise, float gain);
-
-  // Reads chunk of speech in time domain and updates with modified signal.
-  void ProcessRenderAudio(AudioBuffer* audio);
-  bool active() const;
-
- protected:
-  // All in frequency domain, receives input |in_block|, applies
-  // intelligibility enhancement, and writes result to |out_block|.
-  void ProcessAudioBlock(const std::complex<float>* const* in_block,
-                         size_t in_channels,
-                         size_t frames,
-                         size_t out_channels,
-                         std::complex<float>* const* out_block) override;
-
- private:
-  FRIEND_TEST_ALL_PREFIXES(IntelligibilityEnhancerTest, TestRenderUpdate);
-  FRIEND_TEST_ALL_PREFIXES(IntelligibilityEnhancerTest, TestErbCreation);
-  FRIEND_TEST_ALL_PREFIXES(IntelligibilityEnhancerTest, TestSolveForGains);
-  FRIEND_TEST_ALL_PREFIXES(IntelligibilityEnhancerTest,
-                           TestNoiseGainHasExpectedResult);
-  FRIEND_TEST_ALL_PREFIXES(IntelligibilityEnhancerTest,
-                           TestAllBandsHaveSameDelay);
-
-  // Updates the SNR estimation and enables or disables this component using a
-  // hysteresis.
-  void SnrBasedEffectActivation();
-
-  // Bisection search for optimal |lambda|.
-  void SolveForLambda(float power_target);
-
-  // Transforms freq gains to ERB gains.
-  void UpdateErbGains();
-
-  // Returns number of ERB filters.
-  static size_t GetBankSize(int sample_rate, size_t erb_resolution);
-
-  // Initializes ERB filterbank.
-  std::vector<std::vector<float>> CreateErbBank(size_t num_freqs);
-
-  // Analytically solves quadratic for optimal gains given |lambda|.
-  // Negative gains are set to 0. Stores the results in |sols|.
-  void SolveForGainsGivenLambda(float lambda, size_t start_freq, float* sols);
-
-  // Returns true if the audio is speech.
-  bool IsSpeech(const float* audio);
-
-  // Delays the high bands to compensate for the processing delay in the low
-  // band.
-  void DelayHighBands(AudioBuffer* audio);
-
-  static const size_t kMaxNumNoiseEstimatesToBuffer = 5;
-
-  const size_t freqs_;  // Num frequencies in frequency domain.
-  const size_t num_noise_bins_;
-  const size_t chunk_length_;  // Chunk size in samples.
-  const size_t bank_size_;     // Num ERB filters.
-  const int sample_rate_hz_;
-  const size_t num_render_channels_;
-
-  intelligibility::PowerEstimator<std::complex<float>> clear_power_estimator_;
-  intelligibility::PowerEstimator<float> noise_power_estimator_;
-  std::vector<float> filtered_clear_pow_;
-  std::vector<float> filtered_noise_pow_;
-  std::vector<float> center_freqs_;
-  std::vector<std::vector<float>> capture_filter_bank_;
-  std::vector<std::vector<float>> render_filter_bank_;
-  size_t start_freq_;
-
-  std::vector<float> gains_eq_;  // Pre-filter modified gains.
-  intelligibility::GainApplier gain_applier_;
-
-  std::unique_ptr<LappedTransform> render_mangler_;
-
-  VoiceActivityDetector vad_;
-  std::vector<int16_t> audio_s16_;
-  size_t chunks_since_voice_;
-  bool is_speech_;
-  float snr_;
-  bool is_active_;
-
-  unsigned long int num_chunks_;
-  unsigned long int num_active_chunks_;
-
-  std::vector<float> noise_estimation_buffer_;
-  SwapQueue<std::vector<float>, RenderQueueItemVerifier<float>>
-      noise_estimation_queue_;
-
-  std::vector<std::unique_ptr<intelligibility::DelayBuffer>>
-      high_bands_buffers_;
-};
-
-}  // namespace webrtc
-
-#endif  // MODULES_AUDIO_PROCESSING_INTELLIGIBILITY_INTELLIGIBILITY_ENHANCER_H_
diff --git a/modules/audio_processing/intelligibility/intelligibility_enhancer_unittest.cc b/modules/audio_processing/intelligibility/intelligibility_enhancer_unittest.cc
deleted file mode 100644
index 98a8dae..0000000
--- a/modules/audio_processing/intelligibility/intelligibility_enhancer_unittest.cc
+++ /dev/null
@@ -1,536 +0,0 @@
-/*
- *  Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS.  All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#include <math.h>
-#include <stdlib.h>
-
-#include <algorithm>
-#include <memory>
-#include <vector>
-
-#include "api/array_view.h"
-#include "common_audio/signal_processing/include/signal_processing_library.h"
-#include "modules/audio_processing/audio_buffer.h"
-#include "modules/audio_processing/intelligibility/intelligibility_enhancer.h"
-#include "modules/audio_processing/noise_suppression_impl.h"
-#include "modules/audio_processing/test/audio_buffer_tools.h"
-#include "modules/audio_processing/test/bitexactness_tools.h"
-#include "rtc_base/arraysize.h"
-#include "test/gtest.h"
-
-namespace webrtc {
-
-namespace {
-
-// Target output for ERB create test. Generated with matlab.
-const float kTestCenterFreqs[] = {
-    14.5213f, 29.735f,  45.6781f, 62.3884f, 79.9058f, 98.2691f, 117.521f,
-    137.708f, 158.879f, 181.084f, 204.378f, 228.816f, 254.459f, 281.371f,
-    309.618f, 339.273f, 370.411f, 403.115f, 437.469f, 473.564f, 511.497f,
-    551.371f, 593.293f, 637.386f, 683.77f,  732.581f, 783.96f,  838.06f,
-    895.046f, 955.09f,  1018.38f, 1085.13f, 1155.54f, 1229.85f, 1308.32f,
-    1391.22f, 1478.83f, 1571.5f,  1669.55f, 1773.37f, 1883.37f, 2000.f};
-const float kTestFilterBank[][33] = {
-    {0.2f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f,  0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f,  0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f},
-    {0.2f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f,  0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f,  0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f},
-    {0.2f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f,  0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f,  0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f},
-    {0.2f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f,  0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f,  0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f},
-    {0.2f, 0.25f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f,  0.f,   0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f,  0.f,   0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f},
-    {0.f, 0.25f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f,   0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f,   0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f},
-    {0.f, 0.25f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f,   0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f,   0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f},
-    {0.f, 0.25f, 0.25f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f,   0.f,   0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f,   0.f,   0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f},
-    {0.f, 0.f, 0.25f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f, 0.f,   0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f, 0.f,   0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f},
-    {0.f, 0.f, 0.25f, 0.142857f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f, 0.f,   0.f,       0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f, 0.f,   0.f,       0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f},
-    {0.f, 0.f, 0.25f, 0.285714f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f, 0.f,   0.f,       0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f, 0.f,   0.f,       0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f},
-    {0.f, 0.f, 0.f, 0.285714f, 0.142857f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f, 0.f, 0.f,       0.f,       0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f, 0.f, 0.f,       0.f,       0.f, 0.f, 0.f, 0.f, 0.f, 0.f},
-    {0.f, 0.f, 0.f, 0.285714f, 0.285714f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f, 0.f, 0.f,       0.f,       0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f, 0.f, 0.f,       0.f,       0.f, 0.f, 0.f, 0.f, 0.f, 0.f},
-    {0.f, 0.f, 0.f, 0.f, 0.285714f, 0.142857f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f, 0.f, 0.f, 0.f,       0.f,       0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f, 0.f, 0.f, 0.f,       0.f,       0.f, 0.f, 0.f, 0.f, 0.f},
-    {0.f, 0.f, 0.f, 0.f, 0.285714f, 0.285714f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f, 0.f, 0.f, 0.f,       0.f,       0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f, 0.f, 0.f, 0.f,       0.f,       0.f, 0.f, 0.f, 0.f, 0.f},
-    {0.f, 0.f, 0.f, 0.f, 0.f, 0.285714f, 0.142857f, 0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f, 0.f, 0.f, 0.f, 0.f,       0.f,       0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f, 0.f, 0.f, 0.f, 0.f,       0.f,       0.f, 0.f, 0.f, 0.f},
-    {0.f, 0.f, 0.f, 0.f, 0.f, 0.285714f, 0.285714f, 0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f, 0.f, 0.f, 0.f, 0.f,       0.f,       0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f, 0.f, 0.f, 0.f, 0.f,       0.f,       0.f, 0.f, 0.f, 0.f},
-    {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.285714f, 0.142857f, 0.f, 0.f, 0.f,
-     0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,       0.f,       0.f, 0.f, 0.f,
-     0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,       0.f,       0.f, 0.f, 0.f},
-    {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.285714f, 0.285714f, 0.157895f, 0.f, 0.f,
-     0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,       0.f,       0.f,       0.f, 0.f,
-     0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,       0.f,       0.f,       0.f, 0.f},
-    {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.285714f, 0.210526f, 0.117647f, 0.f,
-     0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,       0.f,       0.f,       0.f,
-     0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,       0.f,       0.f,       0.f},
-    {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.285714f, 0.315789f, 0.176471f, 0.f,
-     0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,       0.f,       0.f,       0.f,
-     0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,       0.f,       0.f,       0.f},
-    {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.315789f, 0.352941f, 0.142857f,
-     0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,       0.f,       0.f,
-     0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,       0.f,       0.f},
-    {0.f,       0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.352941f, 0.285714f,
-     0.157895f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,       0.f,
-     0.f,       0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,       0.f},
-    {0.f,       0.f,       0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.285714f,
-     0.210526f, 0.111111f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f,       0.f,       0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f},
-    {0.f, 0.f,       0.f,       0.f,       0.f,       0.f, 0.f, 0.f, 0.f,
-     0.f, 0.285714f, 0.315789f, 0.222222f, 0.111111f, 0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f,       0.f,       0.f,       0.f,       0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f,       0.f,       0.f,       0.f,       0.f},
-    {0.f, 0.f, 0.f,       0.f,       0.f,       0.f,       0.f, 0.f, 0.f,
-     0.f, 0.f, 0.315789f, 0.333333f, 0.222222f, 0.111111f, 0.f, 0.f, 0.f,
-     0.f, 0.f, 0.f,       0.f,       0.f,       0.f,       0.f, 0.f, 0.f,
-     0.f, 0.f, 0.f,       0.f,       0.f,       0.f},
-    {0.f, 0.f, 0.f, 0.f,       0.f,       0.f,       0.f,       0.f, 0.f,
-     0.f, 0.f, 0.f, 0.333333f, 0.333333f, 0.222222f, 0.111111f, 0.f, 0.f,
-     0.f, 0.f, 0.f, 0.f,       0.f,       0.f,       0.f,       0.f, 0.f,
-     0.f, 0.f, 0.f, 0.f,       0.f,       0.f},
-    {0.f, 0.f, 0.f, 0.f, 0.f,       0.f,       0.f,       0.f,       0.f,
-     0.f, 0.f, 0.f, 0.f, 0.333333f, 0.333333f, 0.222222f, 0.111111f, 0.f,
-     0.f, 0.f, 0.f, 0.f, 0.f,       0.f,       0.f,       0.f,       0.f,
-     0.f, 0.f, 0.f, 0.f, 0.f,       0.f},
-    {0.f, 0.f, 0.f, 0.f, 0.f, 0.f,       0.f,       0.f,       0.f,
-     0.f, 0.f, 0.f, 0.f, 0.f, 0.333333f, 0.333333f, 0.222222f, 0.111111f,
-     0.f, 0.f, 0.f, 0.f, 0.f, 0.f,       0.f,       0.f,       0.f,
-     0.f, 0.f, 0.f, 0.f, 0.f, 0.f},
-    {0.f,       0.f, 0.f, 0.f, 0.f, 0.f, 0.f,       0.f,       0.f,
-     0.f,       0.f, 0.f, 0.f, 0.f, 0.f, 0.333333f, 0.333333f, 0.222222f,
-     0.108108f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,       0.f,       0.f,
-     0.f,       0.f, 0.f, 0.f, 0.f, 0.f},
-    {0.f,       0.f,       0.f,        0.f, 0.f, 0.f, 0.f, 0.f,       0.f,
-     0.f,       0.f,       0.f,        0.f, 0.f, 0.f, 0.f, 0.333333f, 0.333333f,
-     0.243243f, 0.153846f, 0.0833333f, 0.f, 0.f, 0.f, 0.f, 0.f,       0.f,
-     0.f,       0.f,       0.f,        0.f, 0.f, 0.f},
-    {0.f,       0.f,       0.f,       0.f,        0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f,       0.f,       0.f,       0.f,        0.f, 0.f, 0.f, 0.f, 0.333333f,
-     0.324324f, 0.230769f, 0.166667f, 0.0909091f, 0.f, 0.f, 0.f, 0.f, 0.f,
-     0.f,       0.f,       0.f,       0.f,        0.f, 0.f},
-    {0.f,       0.f,       0.f,   0.f,       0.f,        0.f, 0.f, 0.f, 0.f,
-     0.f,       0.f,       0.f,   0.f,       0.f,        0.f, 0.f, 0.f, 0.f,
-     0.324324f, 0.307692f, 0.25f, 0.181818f, 0.0833333f, 0.f, 0.f, 0.f, 0.f,
-     0.f,       0.f,       0.f,   0.f,       0.f,        0.f},
-    {0.f,       0.f,   0.f,       0.f,        0.f, 0.f,       0.f,
-     0.f,       0.f,   0.f,       0.f,        0.f, 0.f,       0.f,
-     0.f,       0.f,   0.f,       0.f,        0.f, 0.307692f, 0.333333f,
-     0.363636f, 0.25f, 0.151515f, 0.0793651f, 0.f, 0.f,       0.f,
-     0.f,       0.f,   0.f,       0.f,        0.f},
-    {0.f,       0.f,       0.f,        0.f,       0.f,       0.f,
-     0.f,       0.f,       0.f,        0.f,       0.f,       0.f,
-     0.f,       0.f,       0.f,        0.f,       0.f,       0.f,
-     0.f,       0.f,       0.166667f,  0.363636f, 0.333333f, 0.242424f,
-     0.190476f, 0.133333f, 0.0689655f, 0.f,       0.f,       0.f,
-     0.f,       0.f,       0.f},
-    {0.f,        0.f, 0.f, 0.f, 0.f,       0.f,      0.f,       0.f,  0.f,
-     0.f,        0.f, 0.f, 0.f, 0.f,       0.f,      0.f,       0.f,  0.f,
-     0.f,        0.f, 0.f, 0.f, 0.333333f, 0.30303f, 0.253968f, 0.2f, 0.137931f,
-     0.0714286f, 0.f, 0.f, 0.f, 0.f,       0.f},
-    {0.f,    0.f,        0.f,      0.f,      0.f,       0.f,       0.f,
-     0.f,    0.f,        0.f,      0.f,      0.f,       0.f,       0.f,
-     0.f,    0.f,        0.f,      0.f,      0.f,       0.f,       0.f,
-     0.f,    0.f,        0.30303f, 0.31746f, 0.333333f, 0.275862f, 0.214286f,
-     0.125f, 0.0655738f, 0.f,      0.f,      0.f},
-    {0.f,   0.f,       0.f,       0.f,        0.f,       0.f,       0.f,
-     0.f,   0.f,       0.f,       0.f,        0.f,       0.f,       0.f,
-     0.f,   0.f,       0.f,       0.f,        0.f,       0.f,       0.f,
-     0.f,   0.f,       0.f,       0.15873f,   0.333333f, 0.344828f, 0.357143f,
-     0.25f, 0.196721f, 0.137931f, 0.0816327f, 0.f},
-    {0.f,     0.f,       0.f,       0.f,       0.f, 0.f,       0.f,
-     0.f,     0.f,       0.f,       0.f,       0.f, 0.f,       0.f,
-     0.f,     0.f,       0.f,       0.f,       0.f, 0.f,       0.f,
-     0.f,     0.f,       0.f,       0.f,       0.f, 0.172414f, 0.357143f,
-     0.3125f, 0.245902f, 0.172414f, 0.102041f, 0.f},
-    {0.f, 0.f,     0.f,       0.f,       0.f,       0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f,     0.f,       0.f,       0.f,       0.f, 0.f, 0.f, 0.f,
-     0.f, 0.f,     0.f,       0.f,       0.f,       0.f, 0.f, 0.f, 0.f,
-     0.f, 0.3125f, 0.327869f, 0.344828f, 0.204082f, 0.f},
-    {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,       0.f,       0.f,       0.f,
-     0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,       0.f,       0.f,       0.f,
-     0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.163934f, 0.344828f, 0.408163f, 0.5f},
-    {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,       0.f,
-     0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,       0.f,
-     0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.204082f, 0.5f}};
-static_assert(arraysize(kTestCenterFreqs) == arraysize(kTestFilterBank),
-              "Test filterbank badly initialized.");
-
-// Target output for gain solving test. Generated with matlab.
-const size_t kTestStartFreq = 12;  // Lowest integral frequency for ERBs.
-const float kTestZeroVar = 1.f;
-const float kTestNonZeroVarLambdaTop[] = {
-    1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 0.f, 0.f,
-    0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
-    0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};
-static_assert(arraysize(kTestCenterFreqs) ==
-                  arraysize(kTestNonZeroVarLambdaTop),
-              "Power test data badly initialized.");
-const float kMaxTestError = 0.005f;
-
-// Enhancer initialization parameters.
-const int kSamples = 10000;
-const int kSampleRate = 4000;
-const int kNumChannels = 1;
-const int kFragmentSize = kSampleRate / 100;
-const size_t kNumNoiseBins = 129;
-const size_t kNumBands = 1;
-
-// Number of frames to process in the bitexactness tests.
-const size_t kNumFramesToProcess = 1000;
-
-int IntelligibilityEnhancerSampleRate(int sample_rate_hz) {
-  return (sample_rate_hz > AudioProcessing::kSampleRate16kHz
-              ? AudioProcessing::kSampleRate16kHz
-              : sample_rate_hz);
-}
-
-// Process one frame of data and produce the output.
-void ProcessOneFrame(int sample_rate_hz,
-                     AudioBuffer* render_audio_buffer,
-                     AudioBuffer* capture_audio_buffer,
-                     NoiseSuppressionImpl* noise_suppressor,
-                     IntelligibilityEnhancer* intelligibility_enhancer) {
-  if (sample_rate_hz > AudioProcessing::kSampleRate16kHz) {
-    render_audio_buffer->SplitIntoFrequencyBands();
-    capture_audio_buffer->SplitIntoFrequencyBands();
-  }
-
-  intelligibility_enhancer->ProcessRenderAudio(render_audio_buffer);
-
-  noise_suppressor->AnalyzeCaptureAudio(capture_audio_buffer);
-  noise_suppressor->ProcessCaptureAudio(capture_audio_buffer);
-
-  intelligibility_enhancer->SetCaptureNoiseEstimate(
-      noise_suppressor->NoiseEstimate(), 0);
-
-  if (sample_rate_hz > AudioProcessing::kSampleRate16kHz) {
-    render_audio_buffer->MergeFrequencyBands();
-  }
-}
-
-// Processes a specified amount of frames, verifies the results and reports
-// any errors.
-void RunBitexactnessTest(int sample_rate_hz,
-                         size_t num_channels,
-                         rtc::ArrayView<const float> output_reference) {
-  const StreamConfig render_config(sample_rate_hz, num_channels, false);
-  AudioBuffer render_buffer(
-      render_config.num_frames(), render_config.num_channels(),
-      render_config.num_frames(), render_config.num_channels(),
-      render_config.num_frames());
-  test::InputAudioFile render_file(
-      test::GetApmRenderTestVectorFileName(sample_rate_hz));
-  std::vector<float> render_input(render_buffer.num_frames() *
-                                  render_buffer.num_channels());
-
-  const StreamConfig capture_config(sample_rate_hz, num_channels, false);
-  AudioBuffer capture_buffer(
-      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(sample_rate_hz));
-  std::vector<float> capture_input(render_buffer.num_frames() *
-                                   capture_buffer.num_channels());
-
-  rtc::CriticalSection crit_capture;
-  NoiseSuppressionImpl noise_suppressor(&crit_capture);
-  noise_suppressor.Initialize(capture_config.num_channels(), sample_rate_hz);
-  noise_suppressor.Enable(true);
-
-  IntelligibilityEnhancer intelligibility_enhancer(
-      IntelligibilityEnhancerSampleRate(sample_rate_hz),
-      render_config.num_channels(), kNumBands,
-      NoiseSuppressionImpl::num_noise_bins());
-
-  for (size_t frame_no = 0u; frame_no < kNumFramesToProcess; ++frame_no) {
-    ReadFloatSamplesFromStereoFile(render_buffer.num_frames(),
-                                   render_buffer.num_channels(), &render_file,
-                                   render_input);
-    ReadFloatSamplesFromStereoFile(capture_buffer.num_frames(),
-                                   capture_buffer.num_channels(), &capture_file,
-                                   capture_input);
-
-    test::CopyVectorToAudioBuffer(render_config, render_input, &render_buffer);
-    test::CopyVectorToAudioBuffer(capture_config, capture_input,
-                                  &capture_buffer);
-
-    ProcessOneFrame(sample_rate_hz, &render_buffer, &capture_buffer,
-                    &noise_suppressor, &intelligibility_enhancer);
-  }
-
-  // Extract and verify the test results.
-  std::vector<float> render_output;
-  test::ExtractVectorFromAudioBuffer(render_config, &render_buffer,
-                                     &render_output);
-
-  const float kElementErrorBound = 1.f / static_cast<float>(1 << 15);
-
-  // Compare the output with the reference. Only the first values of the output
-  // from last frame processed are compared in order not having to specify all
-  // preceeding frames as testvectors. As the algorithm being tested has a
-  // memory, testing only the last frame implicitly also tests the preceeding
-  // frames.
-  EXPECT_TRUE(test::VerifyDeinterleavedArray(
-      render_buffer.num_frames(), render_config.num_channels(),
-      output_reference, render_output, kElementErrorBound));
-}
-
-float float_rand() {
-  return std::rand() * 2.f / RAND_MAX - 1;
-}
-
-}  // namespace
-
-class IntelligibilityEnhancerTest : public ::testing::Test {
- protected:
-  IntelligibilityEnhancerTest()
-      : clear_buffer_(kFragmentSize,
-                      kNumChannels,
-                      kFragmentSize,
-                      kNumChannels,
-                      kFragmentSize),
-        stream_config_(kSampleRate, kNumChannels),
-        clear_data_(kSamples),
-        noise_data_(kNumNoiseBins),
-        orig_data_(kSamples) {
-    std::srand(1);
-    enh_.reset(new IntelligibilityEnhancer(kSampleRate, kNumChannels, kNumBands,
-                                           kNumNoiseBins));
-  }
-
-  bool CheckUpdate() {
-    enh_.reset(new IntelligibilityEnhancer(kSampleRate, kNumChannels, kNumBands,
-                                           kNumNoiseBins));
-    float* clear_cursor = clear_data_.data();
-    for (int i = 0; i < kSamples; i += kFragmentSize) {
-      enh_->SetCaptureNoiseEstimate(noise_data_, 1);
-      clear_buffer_.CopyFrom(&clear_cursor, stream_config_);
-      enh_->ProcessRenderAudio(&clear_buffer_);
-      clear_buffer_.CopyTo(stream_config_, &clear_cursor);
-      clear_cursor += kFragmentSize;
-    }
-    for (int i = initial_delay_; i < kSamples; i++) {
-      if (std::fabs(clear_data_[i] - orig_data_[i - initial_delay_]) >
-          kMaxTestError) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  std::unique_ptr<IntelligibilityEnhancer> enh_;
-  // Render clean speech buffer.
-  AudioBuffer clear_buffer_;
-  StreamConfig stream_config_;
-  std::vector<float> clear_data_;
-  std::vector<float> noise_data_;
-  std::vector<float> orig_data_;
-  size_t initial_delay_;
-};
-
-// For each class of generated data, tests that render stream is updated when
-// it should be.
-TEST_F(IntelligibilityEnhancerTest, TestRenderUpdate) {
-  initial_delay_ = enh_->render_mangler_->initial_delay();
-  std::fill(noise_data_.begin(), noise_data_.end(), 0.f);
-  std::fill(orig_data_.begin(), orig_data_.end(), 0.f);
-  std::fill(clear_data_.begin(), clear_data_.end(), 0.f);
-  EXPECT_FALSE(CheckUpdate());
-  std::generate(clear_data_.begin(), clear_data_.end(), float_rand);
-  orig_data_ = clear_data_;
-  EXPECT_FALSE(CheckUpdate());
-  std::generate(clear_data_.begin(), clear_data_.end(), float_rand);
-  orig_data_ = clear_data_;
-  std::generate(noise_data_.begin(), noise_data_.end(), float_rand);
-  FloatToFloatS16(noise_data_.data(), noise_data_.size(), noise_data_.data());
-  EXPECT_TRUE(CheckUpdate());
-}
-
-// Tests ERB bank creation, comparing against matlab output.
-TEST_F(IntelligibilityEnhancerTest, TestErbCreation) {
-  ASSERT_EQ(arraysize(kTestCenterFreqs), enh_->bank_size_);
-  for (size_t i = 0; i < enh_->bank_size_; ++i) {
-    EXPECT_NEAR(kTestCenterFreqs[i], enh_->center_freqs_[i], kMaxTestError);
-    ASSERT_EQ(arraysize(kTestFilterBank[0]), enh_->freqs_);
-    for (size_t j = 0; j < enh_->freqs_; ++j) {
-      EXPECT_NEAR(kTestFilterBank[i][j], enh_->render_filter_bank_[i][j],
-                  kMaxTestError);
-    }
-  }
-}
-
-// Tests analytic solution for optimal gains, comparing
-// against matlab output.
-TEST_F(IntelligibilityEnhancerTest, TestSolveForGains) {
-  ASSERT_EQ(kTestStartFreq, enh_->start_freq_);
-  std::vector<float> sols(enh_->bank_size_);
-  float lambda = -0.001f;
-  for (size_t i = 0; i < enh_->bank_size_; i++) {
-    enh_->filtered_clear_pow_[i] = 0.f;
-    enh_->filtered_noise_pow_[i] = 0.f;
-  }
-  enh_->SolveForGainsGivenLambda(lambda, enh_->start_freq_, sols.data());
-  for (size_t i = 0; i < enh_->bank_size_; i++) {
-    EXPECT_NEAR(kTestZeroVar, sols[i], kMaxTestError);
-  }
-  for (size_t i = 0; i < enh_->bank_size_; i++) {
-    enh_->filtered_clear_pow_[i] = static_cast<float>(i + 1);
-    enh_->filtered_noise_pow_[i] = static_cast<float>(enh_->bank_size_ - i);
-  }
-  enh_->SolveForGainsGivenLambda(lambda, enh_->start_freq_, sols.data());
-  for (size_t i = 0; i < enh_->bank_size_; i++) {
-    EXPECT_NEAR(kTestNonZeroVarLambdaTop[i], sols[i], kMaxTestError);
-  }
-  lambda = -1.f;
-  enh_->SolveForGainsGivenLambda(lambda, enh_->start_freq_, sols.data());
-  for (size_t i = 0; i < enh_->bank_size_; i++) {
-    EXPECT_NEAR(kTestNonZeroVarLambdaTop[i], sols[i], kMaxTestError);
-  }
-}
-
-TEST_F(IntelligibilityEnhancerTest, TestNoiseGainHasExpectedResult) {
-  const float kGain = 2.f;
-  const float kTolerance = 0.007f;
-  std::vector<float> noise(kNumNoiseBins);
-  std::vector<float> noise_psd(kNumNoiseBins);
-  std::generate(noise.begin(), noise.end(), float_rand);
-  for (size_t i = 0; i < kNumNoiseBins; ++i) {
-    noise_psd[i] = kGain * kGain * noise[i] * noise[i];
-  }
-  float* clear_cursor = clear_data_.data();
-  for (size_t i = 0; i < kNumFramesToProcess; ++i) {
-    enh_->SetCaptureNoiseEstimate(noise, kGain);
-    clear_buffer_.CopyFrom(&clear_cursor, stream_config_);
-    enh_->ProcessRenderAudio(&clear_buffer_);
-  }
-  const std::vector<float>& estimated_psd =
-      enh_->noise_power_estimator_.power();
-  for (size_t i = 0; i < kNumNoiseBins; ++i) {
-    EXPECT_LT(std::abs(estimated_psd[i] - noise_psd[i]) / noise_psd[i],
-              kTolerance);
-  }
-}
-
-TEST_F(IntelligibilityEnhancerTest, TestAllBandsHaveSameDelay) {
-  const int kTestSampleRate = AudioProcessing::kSampleRate32kHz;
-  const int kTestSplitRate = AudioProcessing::kSampleRate16kHz;
-  const size_t kTestNumBands =
-      rtc::CheckedDivExact(kTestSampleRate, kTestSplitRate);
-  const size_t kTestFragmentSize = rtc::CheckedDivExact(kTestSampleRate, 100);
-  const size_t kTestSplitFragmentSize =
-      rtc::CheckedDivExact(kTestSplitRate, 100);
-  enh_.reset(new IntelligibilityEnhancer(kTestSplitRate, kNumChannels,
-                                         kTestNumBands, kNumNoiseBins));
-  size_t initial_delay = enh_->render_mangler_->initial_delay();
-  std::vector<float> rand_gen_buf(kTestFragmentSize);
-  AudioBuffer original_buffer(kTestFragmentSize, kNumChannels,
-                              kTestFragmentSize, kNumChannels,
-                              kTestFragmentSize);
-  AudioBuffer audio_buffer(kTestFragmentSize, kNumChannels, kTestFragmentSize,
-                           kNumChannels, kTestFragmentSize);
-  for (size_t i = 0u; i < kTestNumBands; ++i) {
-    std::generate(rand_gen_buf.begin(), rand_gen_buf.end(), float_rand);
-    original_buffer.split_data_f()->SetDataForTesting(rand_gen_buf.data(),
-                                                      rand_gen_buf.size());
-    audio_buffer.split_data_f()->SetDataForTesting(rand_gen_buf.data(),
-                                                   rand_gen_buf.size());
-  }
-  enh_->ProcessRenderAudio(&audio_buffer);
-  for (size_t i = 0u; i < kTestNumBands; ++i) {
-    const float* original_ptr = original_buffer.split_bands_const_f(0)[i];
-    const float* audio_ptr = audio_buffer.split_bands_const_f(0)[i];
-    for (size_t j = initial_delay; j < kTestSplitFragmentSize; ++j) {
-      EXPECT_LT(std::fabs(original_ptr[j - initial_delay] - audio_ptr[j]),
-                kMaxTestError);
-    }
-  }
-}
-
-TEST(IntelligibilityEnhancerBitExactnessTest, DISABLED_Mono8kHz) {
-  const float kOutputReference[] = {-0.001892f, -0.003296f, -0.001953f};
-
-  RunBitexactnessTest(AudioProcessing::kSampleRate8kHz, 1, kOutputReference);
-}
-
-TEST(IntelligibilityEnhancerBitExactnessTest, DISABLED_Mono16kHz) {
-  const float kOutputReference[] = {-0.000977f, -0.003296f, -0.002441f};
-
-  RunBitexactnessTest(AudioProcessing::kSampleRate16kHz, 1, kOutputReference);
-}
-
-TEST(IntelligibilityEnhancerBitExactnessTest, DISABLED_Mono32kHz) {
-  const float kOutputReference[] = {0.003021f, -0.011780f, -0.008209f};
-
-  RunBitexactnessTest(AudioProcessing::kSampleRate32kHz, 1, kOutputReference);
-}
-
-TEST(IntelligibilityEnhancerBitExactnessTest, DISABLED_Mono48kHz) {
-  const float kOutputReference[] = {-0.027696f, -0.026253f, -0.018001f};
-
-  RunBitexactnessTest(AudioProcessing::kSampleRate48kHz, 1, kOutputReference);
-}
-
-TEST(IntelligibilityEnhancerBitExactnessTest, DISABLED_Stereo8kHz) {
-  const float kOutputReference[] = {0.021454f,  0.035919f, 0.026428f,
-                                    -0.000641f, 0.000366f, 0.000641f};
-
-  RunBitexactnessTest(AudioProcessing::kSampleRate8kHz, 2, kOutputReference);
-}
-
-TEST(IntelligibilityEnhancerBitExactnessTest, DISABLED_Stereo16kHz) {
-  const float kOutputReference[] = {0.021362f,  0.035736f,  0.023895f,
-                                    -0.001404f, -0.001465f, 0.000549f};
-
-  RunBitexactnessTest(AudioProcessing::kSampleRate16kHz, 2, kOutputReference);
-}
-
-TEST(IntelligibilityEnhancerBitExactnessTest, DISABLED_Stereo32kHz) {
-  const float kOutputReference[] = {0.030641f,  0.027406f,  0.028321f,
-                                    -0.001343f, -0.004578f, 0.000977f};
-
-  RunBitexactnessTest(AudioProcessing::kSampleRate32kHz, 2, kOutputReference);
-}
-
-TEST(IntelligibilityEnhancerBitExactnessTest, DISABLED_Stereo48kHz) {
-  const float kOutputReference[] = {-0.009276f, -0.001601f, -0.008255f,
-                                    -0.012975f, -0.015940f, -0.017820f};
-
-  RunBitexactnessTest(AudioProcessing::kSampleRate48kHz, 2, kOutputReference);
-}
-
-}  // namespace webrtc
diff --git a/modules/audio_processing/intelligibility/intelligibility_utils.cc b/modules/audio_processing/intelligibility/intelligibility_utils.cc
deleted file mode 100644
index b606d95..0000000
--- a/modules/audio_processing/intelligibility/intelligibility_utils.cc
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- *  Copyright (c) 2014 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/intelligibility/intelligibility_utils.h"
-
-#include <math.h>
-#include <stdlib.h>
-#include <string.h>
-#include <algorithm>
-#include <limits>
-
-#include "rtc_base/numerics/safe_minmax.h"
-
-namespace webrtc {
-
-namespace intelligibility {
-
-namespace {
-
-const float kMinFactor = 0.01f;
-const float kMaxFactor = 100.f;
-
-// Return |current| changed towards |target|, with the relative change being at
-// most |limit|.
-float UpdateFactor(float target, float current, float limit) {
-  const float gain = target / (current + std::numeric_limits<float>::epsilon());
-  const float clamped_gain = rtc::SafeClamp(gain, 1 - limit, 1 + limit);
-  return rtc::SafeClamp(current * clamped_gain, kMinFactor, kMaxFactor);
-}
-
-}  // namespace
-
-template <typename T>
-PowerEstimator<T>::PowerEstimator(size_t num_freqs, float decay)
-    : power_(num_freqs, 0.f), decay_(decay) {}
-
-template <typename T>
-void PowerEstimator<T>::Step(const T* data) {
-  for (size_t i = 0; i < power_.size(); ++i) {
-    power_[i] = decay_ * power_[i] +
-                (1.f - decay_) * std::abs(data[i]) * std::abs(data[i]);
-  }
-}
-
-template class PowerEstimator<float>;
-template class PowerEstimator<std::complex<float>>;
-
-GainApplier::GainApplier(size_t freqs, float relative_change_limit)
-    : num_freqs_(freqs),
-      relative_change_limit_(relative_change_limit),
-      target_(freqs, 1.f),
-      current_(freqs, 1.f) {}
-
-GainApplier::~GainApplier() {}
-
-void GainApplier::Apply(const std::complex<float>* in_block,
-                        std::complex<float>* out_block) {
-  for (size_t i = 0; i < num_freqs_; ++i) {
-    current_[i] = UpdateFactor(target_[i], current_[i], relative_change_limit_);
-    out_block[i] = sqrtf(fabsf(current_[i])) * in_block[i];
-  }
-}
-
-DelayBuffer::DelayBuffer(size_t delay, size_t num_channels)
-    : buffer_(num_channels, std::vector<float>(delay, 0.f)), read_index_(0u) {}
-
-DelayBuffer::~DelayBuffer() {}
-
-void DelayBuffer::Delay(float* const* data, size_t length) {
-  size_t sample_index = read_index_;
-  for (size_t i = 0u; i < buffer_.size(); ++i) {
-    sample_index = read_index_;
-    for (size_t j = 0u; j < length; ++j) {
-      float swap = data[i][j];
-      data[i][j] = buffer_[i][sample_index];
-      buffer_[i][sample_index] = swap;
-      if (++sample_index == buffer_.size()) {
-        sample_index = 0u;
-      }
-    }
-  }
-  read_index_ = sample_index;
-}
-
-}  // namespace intelligibility
-
-}  // namespace webrtc
diff --git a/modules/audio_processing/intelligibility/intelligibility_utils.h b/modules/audio_processing/intelligibility/intelligibility_utils.h
deleted file mode 100644
index 4dc17d5..0000000
--- a/modules/audio_processing/intelligibility/intelligibility_utils.h
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- *  Copyright (c) 2014 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_INTELLIGIBILITY_INTELLIGIBILITY_UTILS_H_
-#define MODULES_AUDIO_PROCESSING_INTELLIGIBILITY_INTELLIGIBILITY_UTILS_H_
-
-#include <complex>
-#include <vector>
-
-namespace webrtc {
-
-namespace intelligibility {
-
-// Internal helper for computing the power of a stream of arrays.
-// The result is an array of power per position: the i-th power is the power of
-// the stream of data on the i-th positions in the input arrays.
-template <typename T>
-class PowerEstimator {
- public:
-  // Construct an instance for the given input array length (|freqs|), with the
-  // appropriate parameters. |decay| is the forgetting factor.
-  PowerEstimator(size_t freqs, float decay);
-
-  // Add a new data point to the series.
-  void Step(const T* data);
-
-  // The current power array.
-  const std::vector<float>& power() { return power_; };
-
- private:
-  // The current power array.
-  std::vector<float> power_;
-
-  const float decay_;
-};
-
-// Helper class for smoothing gain changes. On each application step, the
-// currently used gains are changed towards a set of settable target gains,
-// constrained by a limit on the relative changes.
-class GainApplier {
- public:
-  GainApplier(size_t freqs, float relative_change_limit);
-
-  ~GainApplier();
-
-  // Copy |in_block| to |out_block|, multiplied by the current set of gains,
-  // and step the current set of gains towards the target set.
-  void Apply(const std::complex<float>* in_block,
-             std::complex<float>* out_block);
-
-  // Return the current target gain set. Modify this array to set the targets.
-  float* target() { return target_.data(); }
-
- private:
-  const size_t num_freqs_;
-  const float relative_change_limit_;
-  std::vector<float> target_;
-  std::vector<float> current_;
-};
-
-// Helper class to delay a signal by an integer number of samples.
-class DelayBuffer {
- public:
-  DelayBuffer(size_t delay, size_t num_channels);
-
-  ~DelayBuffer();
-
-  void Delay(float* const* data, size_t length);
-
- private:
-  std::vector<std::vector<float>> buffer_;
-  size_t read_index_;
-};
-
-}  // namespace intelligibility
-
-}  // namespace webrtc
-
-#endif  // MODULES_AUDIO_PROCESSING_INTELLIGIBILITY_INTELLIGIBILITY_UTILS_H_
diff --git a/modules/audio_processing/intelligibility/intelligibility_utils_unittest.cc b/modules/audio_processing/intelligibility/intelligibility_utils_unittest.cc
deleted file mode 100644
index fea394c..0000000
--- a/modules/audio_processing/intelligibility/intelligibility_utils_unittest.cc
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- *  Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS.  All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#include <cmath>
-#include <complex>
-#include <vector>
-
-#include "modules/audio_processing/intelligibility/intelligibility_utils.h"
-#include "rtc_base/arraysize.h"
-#include "test/gtest.h"
-
-namespace webrtc {
-
-namespace intelligibility {
-
-std::vector<std::vector<std::complex<float>>> GenerateTestData(size_t freqs,
-                                                               size_t samples) {
-  std::vector<std::vector<std::complex<float>>> data(samples);
-  for (size_t i = 0; i < samples; ++i) {
-    for (size_t j = 0; j < freqs; ++j) {
-      const float val = 0.99f / ((i + 1) * (j + 1));
-      data[i].push_back(std::complex<float>(val, val));
-    }
-  }
-  return data;
-}
-
-// Tests PowerEstimator, for all power step types.
-TEST(IntelligibilityUtilsTest, TestPowerEstimator) {
-  const size_t kFreqs = 10;
-  const size_t kSamples = 100;
-  const float kDecay = 0.5f;
-  const std::vector<std::vector<std::complex<float>>> test_data(
-      GenerateTestData(kFreqs, kSamples));
-  PowerEstimator<std::complex<float>> power_estimator(kFreqs, kDecay);
-  EXPECT_EQ(0, power_estimator.power()[0]);
-
-  // Makes sure Step is doing something.
-  power_estimator.Step(test_data[0].data());
-  for (size_t i = 1; i < kSamples; ++i) {
-    power_estimator.Step(test_data[i].data());
-    for (size_t j = 0; j < kFreqs; ++j) {
-      EXPECT_GE(power_estimator.power()[j], 0.f);
-      EXPECT_LE(power_estimator.power()[j], 1.f);
-    }
-  }
-}
-
-// Tests gain applier.
-TEST(IntelligibilityUtilsTest, TestGainApplier) {
-  const size_t kFreqs = 10;
-  const size_t kSamples = 100;
-  const float kChangeLimit = 0.1f;
-  GainApplier gain_applier(kFreqs, kChangeLimit);
-  const std::vector<std::vector<std::complex<float>>> in_data(
-      GenerateTestData(kFreqs, kSamples));
-  std::vector<std::vector<std::complex<float>>> out_data(
-      GenerateTestData(kFreqs, kSamples));
-  for (size_t i = 0; i < kSamples; ++i) {
-    gain_applier.Apply(in_data[i].data(), out_data[i].data());
-    for (size_t j = 0; j < kFreqs; ++j) {
-      EXPECT_GT(out_data[i][j].real(), 0.f);
-      EXPECT_LT(out_data[i][j].real(), 1.f);
-      EXPECT_GT(out_data[i][j].imag(), 0.f);
-      EXPECT_LT(out_data[i][j].imag(), 1.f);
-    }
-  }
-}
-
-}  // namespace intelligibility
-
-}  // namespace webrtc
diff --git a/modules/audio_processing/module.mk b/modules/audio_processing/module.mk
index d45b414..7d8b360 100644
--- a/modules/audio_processing/module.mk
+++ b/modules/audio_processing/module.mk
@@ -14,7 +14,9 @@
 	modules/audio_processing/audio_buffer.o \
 	modules/audio_processing/audio_processing_impl.o \
 	modules/audio_processing/echo_cancellation_impl.o \
+	modules/audio_processing/echo_cancellation_proxy.o \
 	modules/audio_processing/echo_control_mobile_impl.o \
+	modules/audio_processing/echo_control_mobile_proxy.o \
 	modules/audio_processing/echo_detector/circular_buffer.o \
 	modules/audio_processing/echo_detector/mean_variance_estimator.o \
 	modules/audio_processing/echo_detector/moving_max.o \
@@ -90,11 +92,11 @@
 	modules/audio_processing/aec3/aec3_common.o \
 	modules/audio_processing/aec3/aec3_fft.o \
 	modules/audio_processing/aec3/aec_state.o \
+	modules/audio_processing/aec3/block_delay_buffer.o \
 	modules/audio_processing/aec3/block_framer.o \
 	modules/audio_processing/aec3/block_processor.o \
 	modules/audio_processing/aec3/block_processor_metrics.o \
 	modules/audio_processing/aec3/cascaded_biquad_filter.o \
-	modules/audio_processing/aec3/coherence_gain.o \
 	modules/audio_processing/aec3/comfort_noise_generator.o \
 	modules/audio_processing/aec3/decimator.o \
 	modules/audio_processing/aec3/downsampled_render_buffer.o \
@@ -120,6 +122,8 @@
 	modules/audio_processing/aec3/render_delay_controller_metrics.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 \
+	modules/audio_processing/aec3/reverb_frequency_response.o \
 	modules/audio_processing/aec3/reverb_model.o \
 	modules/audio_processing/aec3/reverb_model_estimator.o \
 	modules/audio_processing/aec3/reverb_model_fallback.o \
diff --git a/modules/audio_processing/ns/noise_suppression.h b/modules/audio_processing/ns/noise_suppression.h
index fd6aa96..0775ffa 100644
--- a/modules/audio_processing/ns/noise_suppression.h
+++ b/modules/audio_processing/ns/noise_suppression.h
@@ -12,8 +12,7 @@
 #define MODULES_AUDIO_PROCESSING_NS_NOISE_SUPPRESSION_H_
 
 #include <stddef.h>
-
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 typedef struct NsHandleT NsHandle;
 
diff --git a/modules/audio_processing/ns/noise_suppression_x.h b/modules/audio_processing/ns/noise_suppression_x.h
index f25fb7a..972784e 100644
--- a/modules/audio_processing/ns/noise_suppression_x.h
+++ b/modules/audio_processing/ns/noise_suppression_x.h
@@ -12,8 +12,7 @@
 #define MODULES_AUDIO_PROCESSING_NS_NOISE_SUPPRESSION_X_H_
 
 #include <stddef.h>
-
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 typedef struct NsxHandleT NsxHandle;
 
diff --git a/modules/audio_processing/ns/ns_core.c b/modules/audio_processing/ns/ns_core.c
index c87713a..bc5dd6d 100644
--- a/modules/audio_processing/ns/ns_core.c
+++ b/modules/audio_processing/ns/ns_core.c
@@ -13,8 +13,8 @@
 #include <stdlib.h>
 
 #include "rtc_base/checks.h"
-#include "common_audio/fft4g.h"
 #include "common_audio/signal_processing/include/signal_processing_library.h"
+#include "common_audio/third_party/fft4g/fft4g.h"
 #include "modules/audio_processing/ns/noise_suppression.h"
 #include "modules/audio_processing/ns/ns_core.h"
 #include "modules/audio_processing/ns/windows_private.h"
diff --git a/modules/audio_processing/ns/nsx_core.h b/modules/audio_processing/ns/nsx_core.h
index 479e90c..9e9d142 100644
--- a/modules/audio_processing/ns/nsx_core.h
+++ b/modules/audio_processing/ns/nsx_core.h
@@ -17,7 +17,6 @@
 
 #include "common_audio/signal_processing/include/signal_processing_library.h"
 #include "modules/audio_processing/ns/nsx_defines.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 typedef struct NoiseSuppressionFixedC_ {
   uint32_t fs;
diff --git a/modules/audio_processing/rms_level.h b/modules/audio_processing/rms_level.h
index ae45a45..9aa549a 100644
--- a/modules/audio_processing/rms_level.h
+++ b/modules/audio_processing/rms_level.h
@@ -13,7 +13,6 @@
 
 #include "absl/types/optional.h"
 #include "api/array_view.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/transient/dyadic_decimator.h b/modules/audio_processing/transient/dyadic_decimator.h
index e5b1961..fcb56b7 100644
--- a/modules/audio_processing/transient/dyadic_decimator.h
+++ b/modules/audio_processing/transient/dyadic_decimator.h
@@ -13,8 +13,6 @@
 
 #include <cstdlib>
 
-#include "typedefs.h"  // NOLINT(build/include)
-
 // Provides a set of static methods to perform dyadic decimations.
 
 namespace webrtc {
diff --git a/modules/audio_processing/transient/file_utils.cc b/modules/audio_processing/transient/file_utils.cc
index 40732b9..58f9932 100644
--- a/modules/audio_processing/transient/file_utils.cc
+++ b/modules/audio_processing/transient/file_utils.cc
@@ -13,7 +13,6 @@
 #include <memory>
 
 #include "rtc_base/system/file_wrapper.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/transient/file_utils.h b/modules/audio_processing/transient/file_utils.h
index 4b04fac..6184017 100644
--- a/modules/audio_processing/transient/file_utils.h
+++ b/modules/audio_processing/transient/file_utils.h
@@ -14,7 +14,6 @@
 #include <string.h>
 
 #include "rtc_base/system/file_wrapper.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/transient/file_utils_unittest.cc b/modules/audio_processing/transient/file_utils_unittest.cc
index 05f8341..89902ec 100644
--- a/modules/audio_processing/transient/file_utils_unittest.cc
+++ b/modules/audio_processing/transient/file_utils_unittest.cc
@@ -18,7 +18,6 @@
 #include "rtc_base/system/file_wrapper.h"
 #include "test/gtest.h"
 #include "test/testsupport/fileutils.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/transient/moving_moments.cc b/modules/audio_processing/transient/moving_moments.cc
index 4be4d6a..a199bb0 100644
--- a/modules/audio_processing/transient/moving_moments.cc
+++ b/modules/audio_processing/transient/moving_moments.cc
@@ -10,8 +10,7 @@
 
 #include "modules/audio_processing/transient/moving_moments.h"
 
-#include <math.h>
-#include <string.h>
+#include <cmath>
 
 #include "rtc_base/checks.h"
 
@@ -44,7 +43,7 @@
     sum_ += in[i] - old_value;
     sum_of_squares_ += in[i] * in[i] - old_value * old_value;
     first[i] = sum_ / length_;
-    second[i] = sum_of_squares_ / length_;
+    second[i] = std::max(0.f, sum_of_squares_ / length_);
   }
 }
 
diff --git a/modules/audio_processing/transient/transient_detector_unittest.cc b/modules/audio_processing/transient/transient_detector_unittest.cc
index 69a669f..d1eb7af 100644
--- a/modules/audio_processing/transient/transient_detector_unittest.cc
+++ b/modules/audio_processing/transient/transient_detector_unittest.cc
@@ -19,7 +19,6 @@
 #include "rtc_base/system/file_wrapper.h"
 #include "test/gtest.h"
 #include "test/testsupport/fileutils.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/transient/transient_suppression_test.cc b/modules/audio_processing/transient/transient_suppression_test.cc
index 00e1989..9e7ecd5 100644
--- a/modules/audio_processing/transient/transient_suppression_test.cc
+++ b/modules/audio_processing/transient/transient_suppression_test.cc
@@ -22,7 +22,6 @@
 #include "rtc_base/flags.h"
 #include "test/gtest.h"
 #include "test/testsupport/fileutils.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 DEFINE_string(in_file_name, "", "PCM file that contains the signal.");
 DEFINE_string(detection_file_name,
diff --git a/modules/audio_processing/transient/transient_suppressor.cc b/modules/audio_processing/transient/transient_suppressor.cc
index 28eb666..1a5ed56 100644
--- a/modules/audio_processing/transient/transient_suppressor.cc
+++ b/modules/audio_processing/transient/transient_suppressor.cc
@@ -17,15 +17,14 @@
 #include <deque>
 #include <set>
 
-#include "common_audio/fft4g.h"
 #include "common_audio/include/audio_util.h"
 #include "common_audio/signal_processing/include/signal_processing_library.h"
+#include "common_audio/third_party/fft4g/fft4g.h"
 #include "modules/audio_processing/ns/windows_private.h"
 #include "modules/audio_processing/transient/common.h"
 #include "modules/audio_processing/transient/transient_detector.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/transient/transient_suppressor.h b/modules/audio_processing/transient/transient_suppressor.h
index 27b096c..9ae3fc6 100644
--- a/modules/audio_processing/transient/transient_suppressor.h
+++ b/modules/audio_processing/transient/transient_suppressor.h
@@ -16,7 +16,6 @@
 #include <set>
 
 #include "rtc_base/gtest_prod_util.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/transient/wpd_node.h b/modules/audio_processing/transient/wpd_node.h
index 117a633..6a52fb7 100644
--- a/modules/audio_processing/transient/wpd_node.h
+++ b/modules/audio_processing/transient/wpd_node.h
@@ -13,8 +13,6 @@
 
 #include <memory>
 
-#include "typedefs.h"  // NOLINT(build/include)
-
 namespace webrtc {
 
 class FIRFilter;
diff --git a/modules/audio_processing/typing_detection.h b/modules/audio_processing/typing_detection.h
index 14dfe1d..70fd903 100644
--- a/modules/audio_processing/typing_detection.h
+++ b/modules/audio_processing/typing_detection.h
@@ -11,8 +11,6 @@
 #ifndef MODULES_AUDIO_PROCESSING_TYPING_DETECTION_H_
 #define MODULES_AUDIO_PROCESSING_TYPING_DETECTION_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
-
 namespace webrtc {
 
 class TypingDetection {
diff --git a/modules/audio_processing/utility/BUILD.gn b/modules/audio_processing/utility/BUILD.gn
index cd23d01..6a4304d 100644
--- a/modules/audio_processing/utility/BUILD.gn
+++ b/modules/audio_processing/utility/BUILD.gn
@@ -28,7 +28,6 @@
     "delay_estimator_wrapper.h",
   ]
   deps = [
-    "../../..:typedefs",
     "../../../rtc_base:checks",
   ]
 }
@@ -40,7 +39,7 @@
     "ooura_fft_tables_common.h",
   ]
   deps = [
-    "../../..:typedefs",
+    "../../../rtc_base/system:arch",
     "../../../system_wrappers:cpu_features_api",
   ]
   cflags = []
@@ -64,9 +63,7 @@
     deps += [ "../../../common_audio" ]
 
     if (current_cpu != "arm64") {
-      # Enable compilation for the NEON instruction set. This is needed
-      # since //build/config/arm.gni only enables NEON for iOS, not Android.
-      # This provides the same functionality as webrtc/build/arm_neon.gypi.
+      # Enable compilation for the NEON instruction set.
       suppressed_configs += [ "//build/config/compiler:compiler_arm_fpu" ]
       cflags += [ "-mfpu=neon" ]
     }
@@ -109,7 +106,6 @@
     ]
     deps = [
       ":legacy_delay_estimator",
-      "../../..:typedefs",
       "../../../rtc_base:rtc_base_approved",
       "../../../test:test_support",
       "//testing/gtest",
diff --git a/modules/audio_processing/utility/delay_estimator.h b/modules/audio_processing/utility/delay_estimator.h
index 11483ec..2f47e26 100644
--- a/modules/audio_processing/utility/delay_estimator.h
+++ b/modules/audio_processing/utility/delay_estimator.h
@@ -14,7 +14,7 @@
 #ifndef MODULES_AUDIO_PROCESSING_UTILITY_DELAY_ESTIMATOR_H_
 #define MODULES_AUDIO_PROCESSING_UTILITY_DELAY_ESTIMATOR_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 static const int32_t kMaxBitCountsQ9 = (32 << 9);  // 32 matching bits in Q9.
 
diff --git a/modules/audio_processing/utility/delay_estimator_internal.h b/modules/audio_processing/utility/delay_estimator_internal.h
index 46eea3e..e99fe21 100644
--- a/modules/audio_processing/utility/delay_estimator_internal.h
+++ b/modules/audio_processing/utility/delay_estimator_internal.h
@@ -14,7 +14,6 @@
 #define MODULES_AUDIO_PROCESSING_UTILITY_DELAY_ESTIMATOR_INTERNAL_H_
 
 #include "modules/audio_processing/utility/delay_estimator.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 typedef union {
   float float_;
diff --git a/modules/audio_processing/utility/delay_estimator_unittest.cc b/modules/audio_processing/utility/delay_estimator_unittest.cc
index 8d65cb9..324bc37 100644
--- a/modules/audio_processing/utility/delay_estimator_unittest.cc
+++ b/modules/audio_processing/utility/delay_estimator_unittest.cc
@@ -12,7 +12,6 @@
 #include "modules/audio_processing/utility/delay_estimator_internal.h"
 #include "modules/audio_processing/utility/delay_estimator_wrapper.h"
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace {
 
diff --git a/modules/audio_processing/utility/delay_estimator_wrapper.h b/modules/audio_processing/utility/delay_estimator_wrapper.h
index 6b6e51f..995470f 100644
--- a/modules/audio_processing/utility/delay_estimator_wrapper.h
+++ b/modules/audio_processing/utility/delay_estimator_wrapper.h
@@ -14,7 +14,7 @@
 #ifndef MODULES_AUDIO_PROCESSING_UTILITY_DELAY_ESTIMATOR_WRAPPER_H_
 #define MODULES_AUDIO_PROCESSING_UTILITY_DELAY_ESTIMATOR_WRAPPER_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 // Releases the memory allocated by WebRtc_CreateDelayEstimatorFarend(...)
 void WebRtc_FreeDelayEstimatorFarend(void* handle);
diff --git a/modules/audio_processing/utility/ooura_fft.cc b/modules/audio_processing/utility/ooura_fft.cc
index 2add4eb..c3333ce 100644
--- a/modules/audio_processing/utility/ooura_fft.cc
+++ b/modules/audio_processing/utility/ooura_fft.cc
@@ -26,8 +26,8 @@
 #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"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/utility/ooura_fft.h b/modules/audio_processing/utility/ooura_fft.h
index 96d57dc..0cdd6aa 100644
--- a/modules/audio_processing/utility/ooura_fft.h
+++ b/modules/audio_processing/utility/ooura_fft.h
@@ -11,7 +11,7 @@
 #ifndef MODULES_AUDIO_PROCESSING_UTILITY_OOURA_FFT_H_
 #define MODULES_AUDIO_PROCESSING_UTILITY_OOURA_FFT_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
+#include "rtc_base/system/arch.h"
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/utility/ooura_fft_mips.cc b/modules/audio_processing/utility/ooura_fft_mips.cc
index c782ee7..9fe577d 100644
--- a/modules/audio_processing/utility/ooura_fft_mips.cc
+++ b/modules/audio_processing/utility/ooura_fft_mips.cc
@@ -11,7 +11,6 @@
 #include "modules/audio_processing/utility/ooura_fft.h"
 
 #include "modules/audio_processing/utility/ooura_fft_tables_common.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/utility/ooura_fft_sse2.cc b/modules/audio_processing/utility/ooura_fft_sse2.cc
index b44458e..9b5d0f3 100644
--- a/modules/audio_processing/utility/ooura_fft_sse2.cc
+++ b/modules/audio_processing/utility/ooura_fft_sse2.cc
@@ -14,6 +14,7 @@
 
 #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"
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/utility/ooura_fft_tables_neon_sse2.h b/modules/audio_processing/utility/ooura_fft_tables_neon_sse2.h
index 1c44ae7..b6e4a07 100644
--- a/modules/audio_processing/utility/ooura_fft_tables_neon_sse2.h
+++ b/modules/audio_processing/utility/ooura_fft_tables_neon_sse2.h
@@ -12,6 +12,7 @@
 #define MODULES_AUDIO_PROCESSING_UTILITY_OOURA_FFT_TABLES_NEON_SSE2_H_
 
 #include "modules/audio_processing/utility/ooura_fft.h"
+#include "rtc_base/system/arch.h"
 
 #ifdef _MSC_VER /* visual c++ */
 #define ALIGN16_BEG __declspec(align(16))
diff --git a/modules/audio_processing/vad/BUILD.gn b/modules/audio_processing/vad/BUILD.gn
index e16b57f..6c64e94 100644
--- a/modules/audio_processing/vad/BUILD.gn
+++ b/modules/audio_processing/vad/BUILD.gn
@@ -35,11 +35,10 @@
     "voice_gmm_tables.h",
   ]
   deps = [
-    "../../..:typedefs",
     "../../../audio/utility:audio_frame_operations",
     "../../../common_audio",
     "../../../common_audio:common_audio_c",
-    "../../../common_audio:fft4g",
+    "../../../common_audio/third_party/fft4g:fft4g",
     "../../../rtc_base:checks",
     "../../audio_coding:isac_vad",
   ]
diff --git a/modules/audio_processing/vad/gmm.cc b/modules/audio_processing/vad/gmm.cc
index 266ca44..cd8a1a8 100644
--- a/modules/audio_processing/vad/gmm.cc
+++ b/modules/audio_processing/vad/gmm.cc
@@ -13,8 +13,6 @@
 #include <math.h>
 #include <stdlib.h>
 
-#include "typedefs.h"  // NOLINT(build/include)
-
 namespace webrtc {
 
 static const int kMaxDimension = 10;
diff --git a/modules/audio_processing/vad/pitch_based_vad.h b/modules/audio_processing/vad/pitch_based_vad.h
index 584dcc7..4d32765 100644
--- a/modules/audio_processing/vad/pitch_based_vad.h
+++ b/modules/audio_processing/vad/pitch_based_vad.h
@@ -15,7 +15,6 @@
 
 #include "modules/audio_processing/vad/common.h"
 #include "modules/audio_processing/vad/gmm.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/vad/pole_zero_filter.h b/modules/audio_processing/vad/pole_zero_filter.h
index 283deec..11a0511 100644
--- a/modules/audio_processing/vad/pole_zero_filter.h
+++ b/modules/audio_processing/vad/pole_zero_filter.h
@@ -11,9 +11,8 @@
 #ifndef MODULES_AUDIO_PROCESSING_VAD_POLE_ZERO_FILTER_H_
 #define MODULES_AUDIO_PROCESSING_VAD_POLE_ZERO_FILTER_H_
 
-#include <cstddef>
-
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stddef.h>
+#include <stdint.h>
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/vad/standalone_vad.cc b/modules/audio_processing/vad/standalone_vad.cc
index 813d375..19a5282 100644
--- a/modules/audio_processing/vad/standalone_vad.cc
+++ b/modules/audio_processing/vad/standalone_vad.cc
@@ -14,7 +14,6 @@
 
 #include "audio/utility/audio_frame_operations.h"
 #include "rtc_base/checks.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/vad/standalone_vad.h b/modules/audio_processing/vad/standalone_vad.h
index 3f6eb7f..79650fb 100644
--- a/modules/audio_processing/vad/standalone_vad.h
+++ b/modules/audio_processing/vad/standalone_vad.h
@@ -13,7 +13,6 @@
 
 #include "common_audio/vad/include/webrtc_vad.h"
 #include "modules/audio_processing/vad/common.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/audio_processing/vad/vad_audio_proc.cc b/modules/audio_processing/vad/vad_audio_proc.cc
index e9007c6..53eb6de 100644
--- a/modules/audio_processing/vad/vad_audio_proc.cc
+++ b/modules/audio_processing/vad/vad_audio_proc.cc
@@ -14,7 +14,7 @@
 #include <stdio.h>
 #include <string.h>
 
-#include "common_audio/fft4g.h"
+#include "common_audio/third_party/fft4g/fft4g.h"
 #include "modules/audio_processing/vad/pitch_internal.h"
 #include "modules/audio_processing/vad/pole_zero_filter.h"
 #include "modules/audio_processing/vad/vad_audio_proc_internal.h"
diff --git a/modules/audio_processing/vad/vad_audio_proc.h b/modules/audio_processing/vad/vad_audio_proc.h
index b1441a0..e34091b 100644
--- a/modules/audio_processing/vad/vad_audio_proc.h
+++ b/modules/audio_processing/vad/vad_audio_proc.h
@@ -14,7 +14,6 @@
 #include <memory>
 
 #include "modules/audio_processing/vad/common.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/include/module.h b/modules/include/module.h
index fc2a1b5..3b1e046 100644
--- a/modules/include/module.h
+++ b/modules/include/module.h
@@ -11,7 +11,7 @@
 #ifndef MODULES_INCLUDE_MODULE_H_
 #define MODULES_INCLUDE_MODULE_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 namespace webrtc {
 
diff --git a/modules/include/module_common_types.h b/modules/include/module_common_types.h
index 47fd3c2..8ee2369 100644
--- a/modules/include/module_common_types.h
+++ b/modules/include/module_common_types.h
@@ -29,13 +29,9 @@
 #include "rtc_base/deprecation.h"
 #include "rtc_base/numerics/safe_conversions.h"
 #include "rtc_base/timeutils.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
-// TODO(nisse): Deprecated, use webrtc::VideoCodecType instead.
-using RtpVideoCodecTypes = VideoCodecType;
-
 struct WebRtcRTPHeader {
   RTPVideoHeader& video_header() { return video; }
   const RTPVideoHeader& video_header() const { return video; }
diff --git a/modules/include/module_common_types_public.h b/modules/include/module_common_types_public.h
index 2afd9af..345e45c 100644
--- a/modules/include/module_common_types_public.h
+++ b/modules/include/module_common_types_public.h
@@ -14,7 +14,6 @@
 #include <limits>
 
 #include "absl/types/optional.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
@@ -84,11 +83,15 @@
 using SequenceNumberUnwrapper = Unwrapper<uint16_t>;
 using TimestampUnwrapper = Unwrapper<uint32_t>;
 
+// NB: Doesn't fulfill strict weak ordering requirements.
+//     Mustn't be used as std::map Compare function.
 inline bool IsNewerSequenceNumber(uint16_t sequence_number,
                                   uint16_t prev_sequence_number) {
   return IsNewer(sequence_number, prev_sequence_number);
 }
 
+// NB: Doesn't fulfill strict weak ordering requirements.
+//     Mustn't be used as std::map Compare function.
 inline bool IsNewerTimestamp(uint32_t timestamp, uint32_t prev_timestamp) {
   return IsNewer(timestamp, prev_timestamp);
 }
diff --git a/modules/rtp_rtcp/BUILD.gn b/modules/rtp_rtcp/BUILD.gn
index da546cd..055d712 100644
--- a/modules/rtp_rtcp/BUILD.gn
+++ b/modules/rtp_rtcp/BUILD.gn
@@ -87,7 +87,6 @@
   deps = [
     "..:module_api",
     "../..:webrtc_common",
-    "../../:typedefs",
     "../../api:array_view",
     "../../api:libjingle_peerconnection_api",
     "../../api/audio_codecs:audio_codecs_api",
@@ -114,6 +113,8 @@
     "include/rtp_receiver.h",
     "include/rtp_rtcp.h",
     "include/ulpfec_receiver.h",
+    "source/contributing_sources.cc",
+    "source/contributing_sources.h",
     "source/dtmf_queue.cc",
     "source/dtmf_queue.h",
     "source/fec_private_tables_bursty.cc",
@@ -196,12 +197,13 @@
     ":rtp_rtcp_format",
     "..:module_api",
     "../..:webrtc_common",
-    "../../:typedefs",
     "../../api:array_view",
     "../../api:libjingle_peerconnection_api",
     "../../api:transport_api",
     "../../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",
     "../../common_video",
     "../../logging:rtc_event_audio",
@@ -268,6 +270,7 @@
     "../../:webrtc_common",
     "../../api/video:video_frame",
     "../../modules/video_coding:codec_globals_headers",
+    "//third_party/abseil-cpp/absl/container:inlined_vector",
     "//third_party/abseil-cpp/absl/types:variant",
   ]
 }
@@ -350,6 +353,7 @@
 
     sources = [
       "source/byte_io_unittest.cc",
+      "source/contributing_sources_unittest.cc",
       "source/fec_private_tables_bursty_unittest.cc",
       "source/flexfec_header_reader_writer_unittest.cc",
       "source/flexfec_receiver_unittest.cc",
@@ -421,11 +425,11 @@
       ":rtp_rtcp_format",
       "..:module_api",
       "../..:webrtc_common",
-      "../../:typedefs",
       "../../api:array_view",
       "../../api:libjingle_peerconnection_api",
       "../../api:transport_api",
       "../../api/video:video_bitrate_allocation",
+      "../../api/video:video_bitrate_allocator",
       "../../api/video:video_frame",
       "../../api/video_codecs:video_codecs_api",
       "../../call:rtp_receiver",
diff --git a/modules/rtp_rtcp/include/receive_statistics.h b/modules/rtp_rtcp/include/receive_statistics.h
index a3b4798..fe72ada 100644
--- a/modules/rtp_rtcp/include/receive_statistics.h
+++ b/modules/rtp_rtcp/include/receive_statistics.h
@@ -18,7 +18,7 @@
 #include "modules/include/module_common_types.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/report_block.h"
-#include "typedefs.h"  // NOLINT(build/include)
+#include "rtc_base/deprecation.h"
 
 namespace webrtc {
 
@@ -46,10 +46,6 @@
       StreamDataCounters* data_counters) const = 0;
 
   virtual uint32_t BitrateReceived() const = 0;
-
-  // Returns true if the packet with RTP header |header| is likely to be a
-  // retransmitted packet, false otherwise.
-  virtual bool IsRetransmitOfOldPacket(const RTPHeader& header) const = 0;
 };
 
 class ReceiveStatistics : public ReceiveStatisticsProvider {
@@ -60,8 +56,16 @@
 
   // Updates the receive statistics with this packet.
   virtual void IncomingPacket(const RTPHeader& rtp_header,
-                              size_t packet_length,
-                              bool retransmitted) = 0;
+                              size_t packet_length) = 0;
+
+  // TODO(nisse): Wrapper for backwards compatibility. Delete as soon as
+  // downstream callers are updated.
+  RTC_DEPRECATED
+  void IncomingPacket(const RTPHeader& rtp_header,
+                      size_t packet_length,
+                      bool retransmitted) {
+    IncomingPacket(rtp_header, packet_length);
+  }
 
   // Increment counter for number of FEC packets received.
   virtual void FecPacketReceived(const RTPHeader& header,
@@ -72,6 +76,9 @@
 
   // Sets the max reordering threshold in number of packets.
   virtual void SetMaxReorderingThreshold(int max_reordering_threshold) = 0;
+  // Detect retransmissions, enabling updates of the retransmitted counters. The
+  // default is false.
+  virtual void EnableRetransmitDetection(uint32_t ssrc, bool enable) = 0;
 
   // Called on new RTCP stats creation.
   virtual void RegisterRtcpStatisticsCallback(
diff --git a/modules/rtp_rtcp/include/rtp_header_parser.h b/modules/rtp_rtcp/include/rtp_header_parser.h
index 59012ce..2d84fc1 100644
--- a/modules/rtp_rtcp/include/rtp_header_parser.h
+++ b/modules/rtp_rtcp/include/rtp_header_parser.h
@@ -11,7 +11,6 @@
 #define MODULES_RTP_RTCP_INCLUDE_RTP_HEADER_PARSER_H_
 
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/rtp_rtcp/include/rtp_payload_registry.h b/modules/rtp_rtcp/include/rtp_payload_registry.h
index be296da..229c71b 100644
--- a/modules/rtp_rtcp/include/rtp_payload_registry.h
+++ b/modules/rtp_rtcp/include/rtp_payload_registry.h
@@ -45,20 +45,6 @@
   absl::optional<RtpUtility::Payload> PayloadTypeToPayload(
       uint8_t payload_type) const;
 
-  void ResetLastReceivedPayloadTypes() {
-    rtc::CritScope cs(&crit_sect_);
-    last_received_payload_type_ = -1;
-  }
-
-  int8_t last_received_payload_type() const {
-    rtc::CritScope cs(&crit_sect_);
-    return last_received_payload_type_;
-  }
-  void set_last_received_payload_type(int8_t last_received_payload_type) {
-    rtc::CritScope cs(&crit_sect_);
-    last_received_payload_type_ = last_received_payload_type;
-  }
-
  private:
   // Prunes the payload type map of the specific payload type, if it exists.
   void DeregisterAudioCodecOrRedTypeRegardlessOfPayloadType(
@@ -66,7 +52,6 @@
 
   rtc::CriticalSection crit_sect_;
   std::map<int, RtpUtility::Payload> payload_type_map_;
-  int8_t last_received_payload_type_;
 
 // As a first step in splitting this class up in separate cases for audio and
 // video, DCHECK that no instance is used for both audio and video.
diff --git a/modules/rtp_rtcp/include/rtp_receiver.h b/modules/rtp_rtcp/include/rtp_receiver.h
index d2d73b4..d93d656 100644
--- a/modules/rtp_rtcp/include/rtp_receiver.h
+++ b/modules/rtp_rtcp/include/rtp_receiver.h
@@ -15,28 +15,12 @@
 
 #include "api/rtpreceiverinterface.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
 class RTPPayloadRegistry;
 class VideoCodec;
 
-class TelephoneEventHandler {
- public:
-  virtual ~TelephoneEventHandler() {}
-
-  // The following three methods implement the TelephoneEventHandler interface.
-  // Forward DTMFs to decoder for playout.
-  virtual void SetTelephoneEventForwardToDecoder(bool forward_to_decoder) = 0;
-
-  // Is forwarding of outband telephone events turned on/off?
-  virtual bool TelephoneEventForwardToDecoder() const = 0;
-
-  // Is TelephoneEvent configured with payload type payload_type
-  virtual bool TelephoneEventPayloadType(const int8_t payload_type) const = 0;
-};
-
 class RtpReceiver {
  public:
   // Creates a video-enabled RTP receiver.
@@ -53,9 +37,6 @@
 
   virtual ~RtpReceiver() {}
 
-  // Returns a TelephoneEventHandler if available.
-  virtual TelephoneEventHandler* GetTelephoneEventHandler() = 0;
-
   // Registers a receive payload in the payload registry and notifies the media
   // receiver strategy.
   virtual int32_t RegisterReceivePayload(
@@ -98,9 +79,6 @@
   // Returns the remote SSRC of the currently received RTP stream.
   virtual uint32_t SSRC() const = 0;
 
-  // Returns the current remote CSRCs.
-  virtual int32_t CSRCs(uint32_t array_of_csrc[kRtpCsrcSize]) const = 0;
-
   virtual std::vector<RtpSource> GetSources() const = 0;
 };
 }  // namespace webrtc
diff --git a/modules/rtp_rtcp/include/rtp_rtcp.h b/modules/rtp_rtcp/include/rtp_rtcp.h
index 94237e0..f982a9b 100644
--- a/modules/rtp_rtcp/include/rtp_rtcp.h
+++ b/modules/rtp_rtcp/include/rtp_rtcp.h
@@ -33,7 +33,6 @@
 class ReceiveStatisticsProvider;
 class RemoteBitrateEstimator;
 class RtcEventLog;
-class RtpReceiver;
 class Transport;
 class VideoBitrateAllocationObserver;
 
diff --git a/modules/rtp_rtcp/include/rtp_rtcp_defines.cc b/modules/rtp_rtcp/include/rtp_rtcp_defines.cc
index ad9bd45..f86b238 100644
--- a/modules/rtp_rtcp/include/rtp_rtcp_defines.cc
+++ b/modules/rtp_rtcp/include/rtp_rtcp_defines.cc
@@ -16,7 +16,19 @@
 
 constexpr size_t StreamId::kMaxSize;
 
-bool StreamId::IsLegalName(rtc::ArrayView<const char> name) {
+// Check if passed character is a "token-char" from RFC 4566.
+static bool IsTokenChar(char ch) {
+  return ch == 0x21 || (ch >= 0x23 && ch <= 0x27) || ch == 0x2a || ch == 0x2b ||
+         ch == 0x2d || ch == 0x2e || (ch >= 0x30 && ch <= 0x39) ||
+         (ch >= 0x41 && ch <= 0x5a) || (ch >= 0x5e && ch <= 0x7e);
+}
+
+bool StreamId::IsLegalMidName(rtc::ArrayView<const char> name) {
+  return (name.size() <= kMaxSize && name.size() > 0 &&
+          std::all_of(name.data(), name.data() + name.size(), IsTokenChar));
+}
+
+bool StreamId::IsLegalRsidName(rtc::ArrayView<const char> name) {
   return (name.size() <= kMaxSize && name.size() > 0 &&
           std::all_of(name.data(), name.data() + name.size(), isalnum));
 }
diff --git a/modules/rtp_rtcp/include/rtp_rtcp_defines.h b/modules/rtp_rtcp/include/rtp_rtcp_defines.h
index cfd9030..34c7428 100644
--- a/modules/rtp_rtcp/include/rtp_rtcp_defines.h
+++ b/modules/rtp_rtcp/include/rtp_rtcp_defines.h
@@ -21,11 +21,9 @@
 #include "common_types.h"  // NOLINT(build/include)
 #include "modules/include/module_common_types.h"
 #include "system_wrappers/include/clock.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 #define RTCP_CNAME_SIZE 256  // RFC 3550 page 44, including null termination
 #define IP_PACKET_SIZE 1500  // we assume ethernet
-#define MAX_NUMBER_OF_PARALLEL_TELEPHONE_EVENTS 10
 
 namespace webrtc {
 namespace rtcp {
@@ -91,8 +89,6 @@
   absl::variant<AudioPayload, VideoPayload> payload_;
 };
 
-enum RTPAliveType { kRtpDead = 0, kRtpNoRtp = 1, kRtpAlive = 2 };
-
 enum ProtectionType { kUnprotectedPacket, kProtectedPacket };
 
 enum StorageType { kDontRetransmit, kAllowRetransmission };
@@ -197,7 +193,7 @@
   uint32_t sender_ssrc;  // SSRC of sender of this report.
   uint32_t source_ssrc;  // SSRC of the RTP packet sender.
   uint8_t fraction_lost;
-  uint32_t packets_lost;  // 24 bits valid.
+  int32_t packets_lost;  // 24 bits valid.
   uint32_t extended_highest_sequence_number;
   uint32_t jitter;
   uint32_t last_sender_report_timestamp;
diff --git a/modules/rtp_rtcp/include/ulpfec_receiver.h b/modules/rtp_rtcp/include/ulpfec_receiver.h
index 6ea8496..fce6e88 100644
--- a/modules/rtp_rtcp/include/ulpfec_receiver.h
+++ b/modules/rtp_rtcp/include/ulpfec_receiver.h
@@ -12,7 +12,6 @@
 #define MODULES_RTP_RTCP_INCLUDE_ULPFEC_RECEIVER_H_
 
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/rtp_rtcp/source/byte_io.h b/modules/rtp_rtcp/source/byte_io.h
index f9d973b..955bce7 100644
--- a/modules/rtp_rtcp/source/byte_io.h
+++ b/modules/rtp_rtcp/source/byte_io.h
@@ -34,10 +34,9 @@
 // These classes are implemented as recursive templetizations, inteded to make
 // it easy for the compiler to completely inline the reading/writing.
 
+#include <stdint.h>
 #include <limits>
 
-#include "typedefs.h"  // NOLINT(build/include)
-
 namespace webrtc {
 
 // According to ISO C standard ISO/IEC 9899, section 6.2.6.2 (2), the three
diff --git a/modules/rtp_rtcp/source/contributing_sources.cc b/modules/rtp_rtcp/source/contributing_sources.cc
new file mode 100644
index 0000000..853706c
--- /dev/null
+++ b/modules/rtp_rtcp/source/contributing_sources.cc
@@ -0,0 +1,68 @@
+/*
+ *  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/rtp_rtcp/source/contributing_sources.h"
+
+namespace webrtc {
+
+namespace {
+
+// Allow some stale records to accumulate before cleaning.
+constexpr int64_t kPruningIntervalMs = 15 * rtc::kNumMillisecsPerSec;
+
+}  // namespace
+
+constexpr int64_t ContributingSources::kHistoryMs;
+
+ContributingSources::ContributingSources() = default;
+ContributingSources::~ContributingSources() = default;
+
+void ContributingSources::Update(int64_t now_ms,
+                                 rtc::ArrayView<const uint32_t> csrcs) {
+  for (uint32_t csrc : csrcs) {
+    last_seen_ms_[csrc] = now_ms;
+  }
+  if (!next_pruning_ms_) {
+    next_pruning_ms_ = now_ms + kPruningIntervalMs;
+  } else if (now_ms > next_pruning_ms_) {
+    // To prevent unlimited growth, prune it every 15 seconds.
+    DeleteOldEntries(now_ms);
+  }
+}
+
+// Return contributing sources seen the last 10 s.
+// TODO(nisse): It would be more efficient to delete any stale entries while
+// iterating over the mapping, but then we'd have to make the method
+// 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);
+    }
+  }
+
+  return sources;
+}
+
+// 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) {
+      // Still relevant.
+      ++it;
+    } else {
+      it = last_seen_ms_.erase(it);
+    }
+  }
+  next_pruning_ms_ = now_ms + kPruningIntervalMs;
+}
+
+}  // namespace webrtc
diff --git a/modules/rtp_rtcp/source/contributing_sources.h b/modules/rtp_rtcp/source/contributing_sources.h
new file mode 100644
index 0000000..1a4a572
--- /dev/null
+++ b/modules/rtp_rtcp/source/contributing_sources.h
@@ -0,0 +1,51 @@
+/*
+ *  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_RTP_RTCP_SOURCE_CONTRIBUTING_SOURCES_H_
+#define MODULES_RTP_RTCP_SOURCE_CONTRIBUTING_SOURCES_H_
+
+#include <stdint.h>
+
+#include <map>
+#include <vector>
+
+#include "absl/types/optional.h"
+#include "api/array_view.h"
+#include "api/rtpreceiverinterface.h"
+
+namespace webrtc {
+
+class ContributingSources {
+ public:
+  // Set by the spec, see
+  // https://www.w3.org/TR/webrtc/#dom-rtcrtpreceiver-getcontributingsources
+  static constexpr int64_t kHistoryMs = 10 * rtc::kNumMillisecsPerSec;
+
+  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);
+
+  // Returns contributing sources seen the last 10 s.
+  std::vector<RtpSource> GetSources(int64_t now_ms) const;
+
+ private:
+  void DeleteOldEntries(int64_t now_ms);
+
+  // Indexed by csrc.
+  std::map<uint32_t, int64_t> last_seen_ms_;
+  absl::optional<int64_t> next_pruning_ms_;
+};
+
+}  // namespace webrtc
+
+#endif  // MODULES_RTP_RTCP_SOURCE_CONTRIBUTING_SOURCES_H_
diff --git a/modules/rtp_rtcp/source/contributing_sources_unittest.cc b/modules/rtp_rtcp/source/contributing_sources_unittest.cc
new file mode 100644
index 0000000..8b22d26
--- /dev/null
+++ b/modules/rtp_rtcp/source/contributing_sources_unittest.cc
@@ -0,0 +1,111 @@
+/*
+ *  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/rtp_rtcp/source/contributing_sources.h"
+
+#include "rtc_base/timeutils.h"
+
+#include "test/gmock.h"
+#include "test/gtest.h"
+
+namespace webrtc {
+namespace {
+
+using ::testing::UnorderedElementsAre;
+
+constexpr uint32_t kCsrc1 = 111;
+constexpr uint32_t kCsrc2 = 222;
+constexpr uint32_t kCsrc3 = 333;
+
+}  // namespace
+
+TEST(ContributingSourcesTest, RecordSources) {
+  ContributingSources csrcs;
+  constexpr uint32_t kCsrcs[] = {kCsrc1, kCsrc2};
+  constexpr int64_t kTime1 = 10;
+  csrcs.Update(kTime1, kCsrcs);
+  EXPECT_THAT(
+      csrcs.GetSources(kTime1),
+      UnorderedElementsAre(RtpSource(kTime1, kCsrc1, RtpSourceType::CSRC),
+                           RtpSource(kTime1, kCsrc2, RtpSourceType::CSRC)));
+}
+
+TEST(ContributingSourcesTest, UpdateSources) {
+  ContributingSources csrcs;
+  // TODO(nisse): When migrating to absl::Span, the named constant arrays should
+  // be replaced by unnamed literals where they are passed to csrcs.Update(...).
+  constexpr uint32_t kCsrcs1[] = {kCsrc1, kCsrc2};
+  constexpr uint32_t kCsrcs2[] = {kCsrc2, kCsrc3};
+  constexpr int64_t kTime1 = 10;
+  constexpr int64_t kTime2 = kTime1 + 5 * rtc::kNumMillisecsPerSec;
+  csrcs.Update(kTime1, kCsrcs1);
+  EXPECT_THAT(
+      csrcs.GetSources(kTime1),
+      UnorderedElementsAre(RtpSource(kTime1, kCsrc1, RtpSourceType::CSRC),
+                           RtpSource(kTime1, kCsrc2, RtpSourceType::CSRC)));
+  csrcs.Update(kTime2, kCsrcs2);
+  EXPECT_THAT(
+      csrcs.GetSources(kTime2),
+      UnorderedElementsAre(RtpSource(kTime1, kCsrc1, RtpSourceType::CSRC),
+                           RtpSource(kTime2, kCsrc2, RtpSourceType::CSRC),
+                           RtpSource(kTime2, kCsrc3, RtpSourceType::CSRC)));
+}
+
+TEST(ContributingSourcesTest, ReturnRecentOnly) {
+  ContributingSources csrcs;
+  constexpr uint32_t kCsrcs1[] = {kCsrc1, kCsrc2};
+  constexpr uint32_t kCsrcs2[] = {kCsrc2, kCsrc3};
+  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);
+  EXPECT_THAT(
+      csrcs.GetSources(kTime1),
+      UnorderedElementsAre(RtpSource(kTime1, kCsrc1, RtpSourceType::CSRC),
+                           RtpSource(kTime1, kCsrc2, RtpSourceType::CSRC)));
+  csrcs.Update(kTime2, kCsrcs2);
+  EXPECT_THAT(
+      csrcs.GetSources(kTime3),
+      UnorderedElementsAre(RtpSource(kTime2, kCsrc2, RtpSourceType::CSRC),
+                           RtpSource(kTime2, kCsrc3, RtpSourceType::CSRC)));
+}
+
+TEST(ContributingSourcesTest, PurgeOldSources) {
+  ContributingSources csrcs;
+  constexpr uint32_t kCsrcs1[] = {kCsrc1, kCsrc2};
+  constexpr uint32_t kCsrcs2[] = {kCsrc2, kCsrc3};
+  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);
+  EXPECT_THAT(
+      csrcs.GetSources(kTime2),
+      UnorderedElementsAre(RtpSource(kTime1, kCsrc1, RtpSourceType::CSRC),
+                           RtpSource(kTime1, kCsrc2, RtpSourceType::CSRC)));
+  csrcs.Update(kTime2, kCsrcs2);
+  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);
+  EXPECT_THAT(
+      csrcs.GetSources(kTime3),
+      UnorderedElementsAre(RtpSource(kTime3, kCsrc2, RtpSourceType::CSRC),
+                           RtpSource(kTime3, kCsrc3, RtpSourceType::CSRC)));
+  // Query at an earlier time; check that old sources really have been purged
+  // and don't reappear.
+  EXPECT_THAT(
+      csrcs.GetSources(kTime2),
+      UnorderedElementsAre(RtpSource(kTime3, kCsrc2, RtpSourceType::CSRC),
+                           RtpSource(kTime3, kCsrc3, RtpSourceType::CSRC)));
+}
+
+}  // namespace webrtc
diff --git a/modules/rtp_rtcp/source/fec_private_tables_bursty.h b/modules/rtp_rtcp/source/fec_private_tables_bursty.h
index 4120cf9..5d67292 100644
--- a/modules/rtp_rtcp/source/fec_private_tables_bursty.h
+++ b/modules/rtp_rtcp/source/fec_private_tables_bursty.h
@@ -25,9 +25,7 @@
 // (i.e., more packets/symbols in the code, so larger (k,m), i.e.,  k > 4,
 // m > 3).
 
-#include <cstddef>
-
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 namespace webrtc {
 namespace fec_private_tables {
diff --git a/modules/rtp_rtcp/source/fec_private_tables_random.h b/modules/rtp_rtcp/source/fec_private_tables_random.h
index 96c3cef..cc7b929 100644
--- a/modules/rtp_rtcp/source/fec_private_tables_random.h
+++ b/modules/rtp_rtcp/source/fec_private_tables_random.h
@@ -15,9 +15,7 @@
 // this table are specifically designed to favor recovery to random loss.
 // These packet masks are defined to protect up to maximum of 48 media packets.
 
-#include <cstddef>
-
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 namespace webrtc {
 namespace fec_private_tables {
diff --git a/modules/rtp_rtcp/source/nack_rtx_unittest.cc b/modules/rtp_rtcp/source/nack_rtx_unittest.cc
index 53ff5d5..7ecec76 100644
--- a/modules/rtp_rtcp/source/nack_rtx_unittest.cc
+++ b/modules/rtp_rtcp/source/nack_rtx_unittest.cc
@@ -202,9 +202,10 @@
     uint32_t timestamp = 3000;
     uint16_t nack_list[kVideoNackListSize];
     for (int frame = 0; frame < kNumFrames; ++frame) {
+      RTPVideoHeader video_header;
       EXPECT_TRUE(rtp_rtcp_module_->SendOutgoingData(
           webrtc::kVideoFrameDelta, kPayloadType, timestamp, timestamp / 90,
-          payload_data, payload_data_length, nullptr, nullptr, nullptr));
+          payload_data, payload_data_length, nullptr, &video_header, nullptr));
       // Min required delay until retransmit = 5 + RTT ms (RTT = 0).
       fake_clock.AdvanceTimeMilliseconds(5);
       int length = BuildNackList(nack_list);
@@ -250,9 +251,10 @@
   // Send 30 frames which at the default size is roughly what we need to get
   // enough packets.
   for (int frame = 0; frame < kNumFrames; ++frame) {
+    RTPVideoHeader video_header;
     EXPECT_TRUE(rtp_rtcp_module_->SendOutgoingData(
         webrtc::kVideoFrameDelta, kPayloadType, timestamp, timestamp / 90,
-        payload_data, payload_data_length, nullptr, nullptr, nullptr));
+        payload_data, payload_data_length, nullptr, &video_header, nullptr));
     // Prepare next frame.
     timestamp += 3000;
     fake_clock.AdvanceTimeMilliseconds(33);
diff --git a/modules/rtp_rtcp/source/receive_statistics_impl.cc b/modules/rtp_rtcp/source/receive_statistics_impl.cc
index 362a7cf..80b8c9b 100644
--- a/modules/rtp_rtcp/source/receive_statistics_impl.cc
+++ b/modules/rtp_rtcp/source/receive_statistics_impl.cc
@@ -31,6 +31,7 @@
 StreamStatisticianImpl::StreamStatisticianImpl(
     uint32_t ssrc,
     Clock* clock,
+    bool enable_retransmit_detection,
     RtcpStatisticsCallback* rtcp_callback,
     StreamDataCountersCallback* rtp_callback)
     : ssrc_(ssrc),
@@ -38,6 +39,7 @@
       incoming_bitrate_(kStatisticsProcessIntervalMs,
                         RateStatistics::kBpsScale),
       max_reordering_threshold_(kDefaultMaxReorderingThreshold),
+      enable_retransmit_detection_(enable_retransmit_detection),
       jitter_q4_(0),
       cumulative_loss_(0),
       last_receive_time_ms_(0),
@@ -55,9 +57,15 @@
 StreamStatisticianImpl::~StreamStatisticianImpl() = default;
 
 void StreamStatisticianImpl::IncomingPacket(const RTPHeader& header,
-                                            size_t packet_length,
-                                            bool retransmitted) {
-  auto counters = UpdateCounters(header, packet_length, retransmitted);
+                                            size_t packet_length) {
+  StreamDataCounters counters;
+  {
+    rtc::CritScope cs(&stream_lock_);
+
+    bool retransmitted =
+        enable_retransmit_detection_ && IsRetransmitOfOldPacket(header);
+    counters = UpdateCounters(header, packet_length, retransmitted);
+  }
   rtp_callback_->DataCountersUpdated(counters, ssrc_);
 }
 
@@ -65,7 +73,6 @@
     const RTPHeader& header,
     size_t packet_length,
     bool retransmitted) {
-  rtc::CritScope cs(&stream_lock_);
   bool in_order = InOrderPacketInternal(header.sequenceNumber);
   RTC_DCHECK_EQ(ssrc_, header.ssrc);
   incoming_bitrate_.Update(packet_length, clock_->TimeInMilliseconds());
@@ -152,6 +159,11 @@
   max_reordering_threshold_ = max_reordering_threshold;
 }
 
+void StreamStatisticianImpl::EnableRetransmitDetection(bool enable) {
+  rtc::CritScope cs(&stream_lock_);
+  enable_retransmit_detection_ = enable;
+}
+
 bool StreamStatisticianImpl::GetStatistics(RtcpStatistics* statistics,
                                            bool reset) {
   {
@@ -300,7 +312,6 @@
 
 bool StreamStatisticianImpl::IsRetransmitOfOldPacket(
     const RTPHeader& header) const {
-  rtc::CritScope cs(&stream_lock_);
   if (InOrderPacketInternal(header.sequenceNumber)) {
     return false;
   }
@@ -362,8 +373,7 @@
 }
 
 void ReceiveStatisticsImpl::IncomingPacket(const RTPHeader& header,
-                                           size_t packet_length,
-                                           bool retransmitted) {
+                                           size_t packet_length) {
   StreamStatisticianImpl* impl;
   {
     rtc::CritScope cs(&receive_statistics_lock_);
@@ -371,7 +381,9 @@
     if (it != statisticians_.end()) {
       impl = it->second;
     } else {
-      impl = new StreamStatisticianImpl(header.ssrc, clock_, this, this);
+      impl = new StreamStatisticianImpl(
+          header.ssrc, clock_, /* enable_retransmit_detection = */ false, this,
+          this);
       statisticians_[header.ssrc] = impl;
     }
   }
@@ -379,7 +391,7 @@
   // this whole ReceiveStatisticsImpl is destroyed. StreamStatisticianImpl has
   // it's own locking so don't hold receive_statistics_lock_ (potential
   // deadlock).
-  impl->IncomingPacket(header, packet_length, retransmitted);
+  impl->IncomingPacket(header, packet_length);
 }
 
 void ReceiveStatisticsImpl::FecPacketReceived(const RTPHeader& header,
@@ -413,6 +425,21 @@
   }
 }
 
+void ReceiveStatisticsImpl::EnableRetransmitDetection(uint32_t ssrc,
+                                                      bool enable) {
+  StreamStatisticianImpl* impl;
+  {
+    rtc::CritScope cs(&receive_statistics_lock_);
+    StreamStatisticianImpl*& impl_ref = statisticians_[ssrc];
+    if (impl_ref == nullptr) {  // new element
+      impl_ref = new StreamStatisticianImpl(ssrc, clock_, enable, this, this);
+      return;
+    }
+    impl = impl_ref;
+  }
+  impl->EnableRetransmitDetection(enable);
+}
+
 void ReceiveStatisticsImpl::RegisterRtcpStatisticsCallback(
     RtcpStatisticsCallback* callback) {
   rtc::CritScope cs(&receive_statistics_lock_);
diff --git a/modules/rtp_rtcp/source/receive_statistics_impl.h b/modules/rtp_rtcp/source/receive_statistics_impl.h
index 5559b7c..f94256a 100644
--- a/modules/rtp_rtcp/source/receive_statistics_impl.h
+++ b/modules/rtp_rtcp/source/receive_statistics_impl.h
@@ -27,6 +27,7 @@
  public:
   StreamStatisticianImpl(uint32_t ssrc,
                          Clock* clock,
+                         bool enable_retransmit_detection,
                          RtcpStatisticsCallback* rtcp_callback,
                          StreamDataCountersCallback* rtp_callback);
   ~StreamStatisticianImpl() override;
@@ -39,49 +40,54 @@
   void GetReceiveStreamDataCounters(
       StreamDataCounters* data_counters) const override;
   uint32_t BitrateReceived() const override;
-  bool IsRetransmitOfOldPacket(const RTPHeader& header) const override;
 
-  void IncomingPacket(const RTPHeader& rtp_header,
-                      size_t packet_length,
-                      bool retransmitted);
+  void IncomingPacket(const RTPHeader& rtp_header, size_t packet_length);
   void FecPacketReceived(const RTPHeader& header, size_t packet_length);
   void SetMaxReorderingThreshold(int max_reordering_threshold);
+  void EnableRetransmitDetection(bool enable);
 
  private:
-  bool InOrderPacketInternal(uint16_t sequence_number) const;
+  bool IsRetransmitOfOldPacket(const RTPHeader& header) const
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(stream_lock_);
+  bool InOrderPacketInternal(uint16_t sequence_number) const
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(stream_lock_);
   RtcpStatistics CalculateRtcpStatistics()
       RTC_EXCLUSIVE_LOCKS_REQUIRED(stream_lock_);
-  void UpdateJitter(const RTPHeader& header, NtpTime receive_time);
+  void UpdateJitter(const RTPHeader& header, NtpTime receive_time)
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(stream_lock_);
   StreamDataCounters UpdateCounters(const RTPHeader& rtp_header,
                                     size_t packet_length,
-                                    bool retransmitted);
+                                    bool retransmitted)
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(stream_lock_);
 
   const uint32_t ssrc_;
   Clock* const clock_;
   rtc::CriticalSection stream_lock_;
-  RateStatistics incoming_bitrate_;
-  int max_reordering_threshold_;  // In number of packets or sequence numbers.
+  RateStatistics incoming_bitrate_ RTC_GUARDED_BY(&stream_lock_);
+  // In number of packets or sequence numbers.
+  int max_reordering_threshold_ RTC_GUARDED_BY(&stream_lock_);
+  bool enable_retransmit_detection_ RTC_GUARDED_BY(&stream_lock_);
 
   // Stats on received RTP packets.
-  uint32_t jitter_q4_;
-  uint32_t cumulative_loss_;
+  uint32_t jitter_q4_ RTC_GUARDED_BY(&stream_lock_);
+  uint32_t cumulative_loss_ RTC_GUARDED_BY(&stream_lock_);
 
-  int64_t last_receive_time_ms_;
-  NtpTime last_receive_time_ntp_;
-  uint32_t last_received_timestamp_;
-  uint16_t received_seq_first_;
-  uint16_t received_seq_max_;
-  uint16_t received_seq_wraps_;
+  int64_t last_receive_time_ms_ RTC_GUARDED_BY(&stream_lock_);
+  NtpTime last_receive_time_ntp_ RTC_GUARDED_BY(&stream_lock_);
+  uint32_t last_received_timestamp_ RTC_GUARDED_BY(&stream_lock_);
+  uint16_t received_seq_first_ RTC_GUARDED_BY(&stream_lock_);
+  uint16_t received_seq_max_ RTC_GUARDED_BY(&stream_lock_);
+  uint16_t received_seq_wraps_ RTC_GUARDED_BY(&stream_lock_);
 
   // Current counter values.
-  size_t received_packet_overhead_;
-  StreamDataCounters receive_counters_;
+  size_t received_packet_overhead_ RTC_GUARDED_BY(&stream_lock_);
+  StreamDataCounters receive_counters_ RTC_GUARDED_BY(&stream_lock_);
 
   // Counter values when we sent the last report.
-  uint32_t last_report_inorder_packets_;
-  uint32_t last_report_old_packets_;
-  uint16_t last_report_seq_max_;
-  RtcpStatistics last_reported_statistics_;
+  uint32_t last_report_inorder_packets_ RTC_GUARDED_BY(&stream_lock_);
+  uint32_t last_report_old_packets_ RTC_GUARDED_BY(&stream_lock_);
+  uint16_t last_report_seq_max_ RTC_GUARDED_BY(&stream_lock_);
+  RtcpStatistics last_reported_statistics_ RTC_GUARDED_BY(&stream_lock_);
 
   // stream_lock_ shouldn't be held when calling callbacks.
   RtcpStatisticsCallback* const rtcp_callback_;
@@ -100,13 +106,12 @@
   std::vector<rtcp::ReportBlock> RtcpReportBlocks(size_t max_blocks) override;
 
   // Implement ReceiveStatistics.
-  void IncomingPacket(const RTPHeader& header,
-                      size_t packet_length,
-                      bool retransmitted) override;
+  void IncomingPacket(const RTPHeader& header, size_t packet_length) override;
   void FecPacketReceived(const RTPHeader& header,
                          size_t packet_length) override;
   StreamStatistician* GetStatistician(uint32_t ssrc) const override;
   void SetMaxReorderingThreshold(int max_reordering_threshold) override;
+  void EnableRetransmitDetection(uint32_t ssrc, bool enable) override;
 
   void RegisterRtcpStatisticsCallback(
       RtcpStatisticsCallback* callback) override;
diff --git a/modules/rtp_rtcp/source/receive_statistics_unittest.cc b/modules/rtp_rtcp/source/receive_statistics_unittest.cc
index 29fc88d..b721b03 100644
--- a/modules/rtp_rtcp/source/receive_statistics_unittest.cc
+++ b/modules/rtp_rtcp/source/receive_statistics_unittest.cc
@@ -34,6 +34,7 @@
   memset(&header, 0, sizeof(header));
   header.ssrc = ssrc;
   header.sequenceNumber = 100;
+  header.payload_type_frequency = 90000;
   return header;
 }
 
@@ -53,14 +54,14 @@
 };
 
 TEST_F(ReceiveStatisticsTest, TwoIncomingSsrcs) {
-  receive_statistics_->IncomingPacket(header1_, kPacketSize1, false);
+  receive_statistics_->IncomingPacket(header1_, kPacketSize1);
   ++header1_.sequenceNumber;
-  receive_statistics_->IncomingPacket(header2_, kPacketSize2, false);
+  receive_statistics_->IncomingPacket(header2_, kPacketSize2);
   ++header2_.sequenceNumber;
   clock_.AdvanceTimeMilliseconds(100);
-  receive_statistics_->IncomingPacket(header1_, kPacketSize1, false);
+  receive_statistics_->IncomingPacket(header1_, kPacketSize1);
   ++header1_.sequenceNumber;
-  receive_statistics_->IncomingPacket(header2_, kPacketSize2, false);
+  receive_statistics_->IncomingPacket(header2_, kPacketSize2);
   ++header2_.sequenceNumber;
 
   StreamStatistician* statistician =
@@ -83,9 +84,9 @@
   EXPECT_EQ(2u, receive_statistics_->RtcpReportBlocks(3).size());
   // Add more incoming packets and verify that they are registered in both
   // access methods.
-  receive_statistics_->IncomingPacket(header1_, kPacketSize1, false);
+  receive_statistics_->IncomingPacket(header1_, kPacketSize1);
   ++header1_.sequenceNumber;
-  receive_statistics_->IncomingPacket(header2_, kPacketSize2, false);
+  receive_statistics_->IncomingPacket(header2_, kPacketSize2);
   ++header2_.sequenceNumber;
 
   receive_statistics_->GetStatistician(kSsrc1)->GetDataCounters(
@@ -103,9 +104,9 @@
   RTPHeader header1 = CreateRtpHeader(kSsrc1);
   RTPHeader header2 = CreateRtpHeader(kSsrc2);
   RTPHeader header3 = CreateRtpHeader(kSsrc3);
-  receive_statistics_->IncomingPacket(header1, kPacketSize1, false);
-  receive_statistics_->IncomingPacket(header2, kPacketSize1, false);
-  receive_statistics_->IncomingPacket(header3, kPacketSize1, false);
+  receive_statistics_->IncomingPacket(header1, kPacketSize1);
+  receive_statistics_->IncomingPacket(header2, kPacketSize1);
+  receive_statistics_->IncomingPacket(header3, kPacketSize1);
 
   EXPECT_THAT(receive_statistics_->RtcpReportBlocks(2), SizeIs(2));
   EXPECT_THAT(receive_statistics_->RtcpReportBlocks(2), SizeIs(2));
@@ -118,10 +119,10 @@
   RTPHeader header2 = CreateRtpHeader(kSsrc2);
   RTPHeader header3 = CreateRtpHeader(kSsrc3);
   RTPHeader header4 = CreateRtpHeader(kSsrc4);
-  receive_statistics_->IncomingPacket(header1, kPacketSize1, false);
-  receive_statistics_->IncomingPacket(header2, kPacketSize1, false);
-  receive_statistics_->IncomingPacket(header3, kPacketSize1, false);
-  receive_statistics_->IncomingPacket(header4, kPacketSize1, false);
+  receive_statistics_->IncomingPacket(header1, kPacketSize1);
+  receive_statistics_->IncomingPacket(header2, kPacketSize1);
+  receive_statistics_->IncomingPacket(header3, kPacketSize1);
+  receive_statistics_->IncomingPacket(header4, kPacketSize1);
 
   std::vector<uint32_t> observed_ssrcs;
   std::vector<rtcp::ReportBlock> report_blocks =
@@ -140,10 +141,10 @@
 }
 
 TEST_F(ReceiveStatisticsTest, ActiveStatisticians) {
-  receive_statistics_->IncomingPacket(header1_, kPacketSize1, false);
+  receive_statistics_->IncomingPacket(header1_, kPacketSize1);
   ++header1_.sequenceNumber;
   clock_.AdvanceTimeMilliseconds(1000);
-  receive_statistics_->IncomingPacket(header2_, kPacketSize2, false);
+  receive_statistics_->IncomingPacket(header2_, kPacketSize2);
   ++header2_.sequenceNumber;
   // Nothing should time out since only 1000 ms has passed since the first
   // packet came in.
@@ -157,7 +158,7 @@
   // kSsrc2 should have timed out.
   EXPECT_EQ(0u, receive_statistics_->RtcpReportBlocks(3).size());
 
-  receive_statistics_->IncomingPacket(header1_, kPacketSize1, false);
+  receive_statistics_->IncomingPacket(header1_, kPacketSize1);
   ++header1_.sequenceNumber;
   // kSsrc1 should be active again and the data counters should have survived.
   EXPECT_EQ(1u, receive_statistics_->RtcpReportBlocks(3).size());
@@ -171,8 +172,19 @@
   EXPECT_EQ(2u, packets_received);
 }
 
+TEST_F(ReceiveStatisticsTest,
+       DoesntCreateRtcpReportBlockUntilFirstReceivedPacketForSsrc) {
+  // Creates a statistician object for the ssrc.
+  receive_statistics_->EnableRetransmitDetection(kSsrc1, true);
+  EXPECT_TRUE(receive_statistics_->GetStatistician(kSsrc1) != nullptr);
+  EXPECT_EQ(0u, receive_statistics_->RtcpReportBlocks(3).size());
+  // Receive first packet
+  receive_statistics_->IncomingPacket(header1_, kPacketSize1);
+  EXPECT_EQ(1u, receive_statistics_->RtcpReportBlocks(3).size());
+}
+
 TEST_F(ReceiveStatisticsTest, GetReceiveStreamDataCounters) {
-  receive_statistics_->IncomingPacket(header1_, kPacketSize1, false);
+  receive_statistics_->IncomingPacket(header1_, kPacketSize1);
   StreamStatistician* statistician =
       receive_statistics_->GetStatistician(kSsrc1);
   ASSERT_TRUE(statistician != NULL);
@@ -182,7 +194,7 @@
   EXPECT_GT(counters.first_packet_time_ms, -1);
   EXPECT_EQ(1u, counters.transmitted.packets);
 
-  receive_statistics_->IncomingPacket(header1_, kPacketSize1, false);
+  receive_statistics_->IncomingPacket(header1_, kPacketSize1);
   statistician->GetReceiveStreamDataCounters(&counters);
   EXPECT_GT(counters.first_packet_time_ms, -1);
   EXPECT_EQ(2u, counters.transmitted.packets);
@@ -210,24 +222,25 @@
   } callback;
 
   receive_statistics_->RegisterRtcpStatisticsCallback(&callback);
+  receive_statistics_->EnableRetransmitDetection(kSsrc1, true);
 
   // Add some arbitrary data, with loss and jitter.
   header1_.sequenceNumber = 1;
   clock_.AdvanceTimeMilliseconds(7);
   header1_.timestamp += 3;
-  receive_statistics_->IncomingPacket(header1_, kPacketSize1, false);
+  receive_statistics_->IncomingPacket(header1_, kPacketSize1);
   header1_.sequenceNumber += 2;
   clock_.AdvanceTimeMilliseconds(9);
   header1_.timestamp += 9;
-  receive_statistics_->IncomingPacket(header1_, kPacketSize1, false);
+  receive_statistics_->IncomingPacket(header1_, kPacketSize1);
   --header1_.sequenceNumber;
   clock_.AdvanceTimeMilliseconds(13);
   header1_.timestamp += 47;
-  receive_statistics_->IncomingPacket(header1_, kPacketSize1, true);
+  receive_statistics_->IncomingPacket(header1_, kPacketSize1);
   header1_.sequenceNumber += 3;
   clock_.AdvanceTimeMilliseconds(11);
   header1_.timestamp += 17;
-  receive_statistics_->IncomingPacket(header1_, kPacketSize1, false);
+  receive_statistics_->IncomingPacket(header1_, kPacketSize1);
   ++header1_.sequenceNumber;
 
   EXPECT_EQ(0u, callback.num_calls_);
@@ -247,7 +260,7 @@
   EXPECT_EQ(51, statistics.fraction_lost);
   EXPECT_EQ(1, statistics.packets_lost);
   EXPECT_EQ(5u, statistics.extended_highest_sequence_number);
-  EXPECT_EQ(4u, statistics.jitter);
+  EXPECT_EQ(177u, statistics.jitter);
 
   receive_statistics_->RegisterRtcpStatisticsCallback(NULL);
 
@@ -255,19 +268,19 @@
   header1_.sequenceNumber = 1;
   clock_.AdvanceTimeMilliseconds(7);
   header1_.timestamp += 3;
-  receive_statistics_->IncomingPacket(header1_, kPacketSize1, false);
+  receive_statistics_->IncomingPacket(header1_, kPacketSize1);
   header1_.sequenceNumber += 2;
   clock_.AdvanceTimeMilliseconds(9);
   header1_.timestamp += 9;
-  receive_statistics_->IncomingPacket(header1_, kPacketSize1, false);
+  receive_statistics_->IncomingPacket(header1_, kPacketSize1);
   --header1_.sequenceNumber;
   clock_.AdvanceTimeMilliseconds(13);
   header1_.timestamp += 47;
-  receive_statistics_->IncomingPacket(header1_, kPacketSize1, true);
+  receive_statistics_->IncomingPacket(header1_, kPacketSize1);
   header1_.sequenceNumber += 3;
   clock_.AdvanceTimeMilliseconds(11);
   header1_.timestamp += 17;
-  receive_statistics_->IncomingPacket(header1_, kPacketSize1, false);
+  receive_statistics_->IncomingPacket(header1_, kPacketSize1);
   ++header1_.sequenceNumber;
 
   receive_statistics_->GetStatistician(kSsrc1)->GetStatistics(&statistics,
@@ -316,14 +329,14 @@
 TEST_F(ReceiveStatisticsTest, RtpCallbacks) {
   RtpTestCallback callback;
   receive_statistics_->RegisterRtpStatisticsCallback(&callback);
+  receive_statistics_->EnableRetransmitDetection(kSsrc1, true);
 
   const size_t kHeaderLength = 20;
   const size_t kPaddingLength = 9;
 
   // One packet of size kPacketSize1.
   header1_.headerLength = kHeaderLength;
-  receive_statistics_->IncomingPacket(header1_, kPacketSize1 + kHeaderLength,
-                                      false);
+  receive_statistics_->IncomingPacket(header1_, kPacketSize1 + kHeaderLength);
   StreamDataCounters expected;
   expected.transmitted.payload_bytes = kPacketSize1;
   expected.transmitted.header_bytes = kHeaderLength;
@@ -341,7 +354,7 @@
   header1_.paddingLength = 9;
   // Another packet of size kPacketSize1 with 9 bytes padding.
   receive_statistics_->IncomingPacket(
-      header1_, kPacketSize1 + kHeaderLength + kPaddingLength, false);
+      header1_, kPacketSize1 + kHeaderLength + kPaddingLength);
   expected.transmitted.payload_bytes = kPacketSize1 * 2;
   expected.transmitted.header_bytes = kHeaderLength * 2;
   expected.transmitted.padding_bytes = kPaddingLength;
@@ -351,7 +364,7 @@
   clock_.AdvanceTimeMilliseconds(5);
   // Retransmit last packet.
   receive_statistics_->IncomingPacket(
-      header1_, kPacketSize1 + kHeaderLength + kPaddingLength, true);
+      header1_, kPacketSize1 + kHeaderLength + kPaddingLength);
   expected.transmitted.payload_bytes = kPacketSize1 * 3;
   expected.transmitted.header_bytes = kHeaderLength * 3;
   expected.transmitted.padding_bytes = kPaddingLength * 2;
@@ -366,8 +379,7 @@
   ++header1_.sequenceNumber;
   clock_.AdvanceTimeMilliseconds(5);
   // One FEC packet.
-  receive_statistics_->IncomingPacket(header1_, kPacketSize1 + kHeaderLength,
-                                      false);
+  receive_statistics_->IncomingPacket(header1_, kPacketSize1 + kHeaderLength);
   receive_statistics_->FecPacketReceived(header1_,
                                          kPacketSize1 + kHeaderLength);
   expected.transmitted.payload_bytes = kPacketSize1 * 4;
@@ -383,8 +395,7 @@
   // New stats, but callback should not be called.
   ++header1_.sequenceNumber;
   clock_.AdvanceTimeMilliseconds(5);
-  receive_statistics_->IncomingPacket(header1_, kPacketSize1 + kHeaderLength,
-                                      true);
+  receive_statistics_->IncomingPacket(header1_, kPacketSize1 + kHeaderLength);
   callback.Matches(5, kSsrc1, expected);
 }
 
@@ -400,8 +411,7 @@
                                          kPacketSize1 + kHeaderLength);
   EXPECT_EQ(0u, callback.num_calls_);
 
-  receive_statistics_->IncomingPacket(header1_, kPacketSize1 + kHeaderLength,
-                                      false);
+  receive_statistics_->IncomingPacket(header1_, kPacketSize1 + kHeaderLength);
   StreamDataCounters expected;
   expected.transmitted.payload_bytes = kPacketSize1;
   expected.transmitted.header_bytes = kHeaderLength;
diff --git a/modules/rtp_rtcp/source/rtcp_packet/report_block.cc b/modules/rtp_rtcp/source/rtcp_packet/report_block.cc
index 4f98963..d4579fc 100644
--- a/modules/rtp_rtcp/source/rtcp_packet/report_block.cc
+++ b/modules/rtp_rtcp/source/rtcp_packet/report_block.cc
@@ -54,7 +54,7 @@
 
   source_ssrc_ = ByteReader<uint32_t>::ReadBigEndian(&buffer[0]);
   fraction_lost_ = buffer[4];
-  cumulative_lost_ = ByteReader<uint32_t, 3>::ReadBigEndian(&buffer[5]);
+  cumulative_lost_ = ByteReader<int32_t, 3>::ReadBigEndian(&buffer[5]);
   extended_high_seq_num_ = ByteReader<uint32_t>::ReadBigEndian(&buffer[8]);
   jitter_ = ByteReader<uint32_t>::ReadBigEndian(&buffer[12]);
   last_sr_ = ByteReader<uint32_t>::ReadBigEndian(&buffer[16]);
diff --git a/modules/rtp_rtcp/source/rtcp_packet/report_block_unittest.cc b/modules/rtp_rtcp/source/rtcp_packet/report_block_unittest.cc
index a074a2f..5cc102f 100644
--- a/modules/rtp_rtcp/source/rtcp_packet/report_block_unittest.cc
+++ b/modules/rtp_rtcp/source/rtcp_packet/report_block_unittest.cc
@@ -91,5 +91,20 @@
   EXPECT_EQ(0u, rb.cumulative_lost());
 }
 
+TEST(RtcpPacketReportBlockTest, ParseNegativeCumulativeLost) {
+  // CumulativeLost is a signed 24-bit integer.
+  const int32_t kNegativeCumulativeLost = -123;
+  ReportBlock rb;
+  EXPECT_TRUE(rb.SetCumulativeLost(kNegativeCumulativeLost));
+
+  uint8_t buffer[kBufferLength];
+  rb.Create(buffer);
+
+  ReportBlock parsed;
+  EXPECT_TRUE(parsed.Parse(buffer, kBufferLength));
+
+  EXPECT_EQ(kNegativeCumulativeLost, parsed.cumulative_lost_signed());
+}
+
 }  // namespace
 }  // namespace webrtc
diff --git a/modules/rtp_rtcp/source/rtcp_receiver.cc b/modules/rtp_rtcp/source/rtcp_receiver.cc
index 491bd45..4966754 100644
--- a/modules/rtp_rtcp/source/rtcp_receiver.cc
+++ b/modules/rtp_rtcp/source/rtcp_receiver.cc
@@ -19,8 +19,8 @@
 #include <vector>
 
 #include "api/video/video_bitrate_allocation.h"
+#include "api/video/video_bitrate_allocator.h"
 #include "common_types.h"  // NOLINT(build/include)
-#include "common_video/include/video_bitrate_allocator.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_packet/compound_packet.h"
diff --git a/modules/rtp_rtcp/source/rtcp_receiver.h b/modules/rtp_rtcp/source/rtcp_receiver.h
index c868837..a863cae 100644
--- a/modules/rtp_rtcp/source/rtcp_receiver.h
+++ b/modules/rtp_rtcp/source/rtcp_receiver.h
@@ -23,7 +23,6 @@
 #include "rtc_base/criticalsection.h"
 #include "rtc_base/thread_annotations.h"
 #include "system_wrappers/include/ntp_time.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 class VideoBitrateAllocationObserver;
diff --git a/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc b/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
index 41d4725..6cd953c 100644
--- a/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
+++ b/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
@@ -12,8 +12,8 @@
 
 #include "api/array_view.h"
 #include "api/video/video_bitrate_allocation.h"
+#include "api/video/video_bitrate_allocator.h"
 #include "common_types.h"  // NOLINT(build/include)
-#include "common_video/include/video_bitrate_allocator.h"
 #include "modules/rtp_rtcp/mocks/mock_rtcp_bandwidth_observer.h"
 #include "modules/rtp_rtcp/source/byte_io.h"
 #include "modules/rtp_rtcp/source/rtcp_packet.h"
@@ -441,7 +441,7 @@
 TEST_F(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) {
   const uint32_t kSenderSsrc2 = 0x20304;
   const uint16_t kSequenceNumbers[] = {10, 12423};
-  const uint32_t kCumLost[] = {13, 555};
+  const int32_t kCumLost[] = {13, 555};
   const uint8_t kFracLost[] = {20, 11};
 
   rtcp::ReportBlock rb1;
diff --git a/modules/rtp_rtcp/source/rtcp_sender.h b/modules/rtp_rtcp/source/rtcp_sender.h
index e274915..133bf68 100644
--- a/modules/rtp_rtcp/source/rtcp_sender.h
+++ b/modules/rtp_rtcp/source/rtcp_sender.h
@@ -33,7 +33,6 @@
 #include "rtc_base/criticalsection.h"
 #include "rtc_base/random.h"
 #include "rtc_base/thread_annotations.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/rtp_rtcp/source/rtcp_sender_unittest.cc b/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
index 974f19f..bccf96d 100644
--- a/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
+++ b/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
@@ -99,7 +99,7 @@
     header.timestamp = 12345;
     header.headerLength = 12;
     size_t kPacketLength = 100;
-    receive_statistics_->IncomingPacket(header, kPacketLength, false);
+    receive_statistics_->IncomingPacket(header, kPacketLength);
   }
 
   test::RtcpPacketParser* parser() { return &test_transport_.parser_; }
diff --git a/modules/rtp_rtcp/source/rtp_format.cc b/modules/rtp_rtcp/source/rtp_format.cc
index 8bd27a7..72beb17 100644
--- a/modules/rtp_rtcp/source/rtp_format.cc
+++ b/modules/rtp_rtcp/source/rtp_format.cc
@@ -12,37 +12,53 @@
 
 #include <utility>
 
+#include "absl/memory/memory.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"
 
 namespace webrtc {
-RtpPacketizer* RtpPacketizer::Create(VideoCodecType type,
-                                     size_t max_payload_len,
-                                     size_t last_packet_reduction_len,
-                                     const RTPVideoHeader* rtp_video_header,
-                                     FrameType frame_type) {
+
+std::unique_ptr<RtpPacketizer> RtpPacketizer::Create(
+    VideoCodecType type,
+    rtc::ArrayView<const uint8_t> payload,
+    PayloadSizeLimits limits,
+    // Codec-specific details.
+    const RTPVideoHeader& rtp_video_header,
+    FrameType frame_type,
+    const RTPFragmentationHeader* fragmentation) {
   switch (type) {
-    case kVideoCodecH264:
-      RTC_CHECK(rtp_video_header);
-      return new RtpPacketizerH264(max_payload_len, last_packet_reduction_len,
-                                   rtp_video_header->h264().packetization_mode);
-    case kVideoCodecVP8:
-      RTC_CHECK(rtp_video_header);
-      return new RtpPacketizerVp8(rtp_video_header->vp8(), max_payload_len,
-                                  last_packet_reduction_len);
-    case kVideoCodecVP9:
-      RTC_CHECK(rtp_video_header);
-      return new RtpPacketizerVp9(rtp_video_header->vp9(), max_payload_len,
-                                  last_packet_reduction_len);
-    case kVideoCodecGeneric:
-      return new RtpPacketizerGeneric(frame_type, max_payload_len,
-                                      last_packet_reduction_len);
-    default:
-      RTC_NOTREACHED();
+    case kVideoCodecH264: {
+      const auto& h264 =
+          absl::get<RTPVideoHeaderH264>(rtp_video_header.video_type_header);
+      auto packetizer = absl::make_unique<RtpPacketizerH264>(
+          limits.max_payload_len, limits.last_packet_reduction_len,
+          h264.packetization_mode);
+      packetizer->SetPayloadData(payload.data(), payload.size(), fragmentation);
+      return std::move(packetizer);
+    }
+    case kVideoCodecVP8: {
+      const auto& vp8 =
+          absl::get<RTPVideoHeaderVP8>(rtp_video_header.video_type_header);
+      return absl::make_unique<RtpPacketizerVp8>(payload, limits, vp8);
+    }
+    case kVideoCodecVP9: {
+      const auto& vp9 =
+          absl::get<RTPVideoHeaderVP9>(rtp_video_header.video_type_header);
+      auto packetizer = absl::make_unique<RtpPacketizerVp9>(
+          vp9, limits.max_payload_len, limits.last_packet_reduction_len);
+      packetizer->SetPayloadData(payload.data(), payload.size(), nullptr);
+      return std::move(packetizer);
+    }
+    default: {
+      auto packetizer = absl::make_unique<RtpPacketizerGeneric>(
+          rtp_video_header, frame_type, limits.max_payload_len,
+          limits.last_packet_reduction_len);
+      packetizer->SetPayloadData(payload.data(), payload.size(), nullptr);
+      return std::move(packetizer);
+    }
   }
-  return nullptr;
 }
 
 RtpDepacketizer* RtpDepacketizer::Create(VideoCodecType type) {
@@ -53,11 +69,8 @@
       return new RtpDepacketizerVp8();
     case kVideoCodecVP9:
       return new RtpDepacketizerVp9();
-    case kVideoCodecGeneric:
-      return new RtpDepacketizerGeneric();
     default:
-      RTC_NOTREACHED();
+      return new RtpDepacketizerGeneric();
   }
-  return nullptr;
 }
 }  // namespace webrtc
diff --git a/modules/rtp_rtcp/source/rtp_format.h b/modules/rtp_rtcp/source/rtp_format.h
index 76d7f47..007ddbc 100644
--- a/modules/rtp_rtcp/source/rtp_format.h
+++ b/modules/rtp_rtcp/source/rtp_format.h
@@ -11,8 +11,10 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_RTP_FORMAT_H_
 #define MODULES_RTP_RTCP_SOURCE_RTP_FORMAT_H_
 
+#include <memory>
 #include <string>
 
+#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"
@@ -23,26 +25,28 @@
 
 class RtpPacketizer {
  public:
-  static RtpPacketizer* Create(VideoCodecType type,
-                               size_t max_payload_len,
-                               size_t last_packet_reduction_len,
-                               const RTPVideoHeader* rtp_video_header,
-                               FrameType frame_type);
+  struct PayloadSizeLimits {
+    size_t max_payload_len = 1200;
+    size_t last_packet_reduction_len = 0;
+  };
+  static std::unique_ptr<RtpPacketizer> Create(
+      VideoCodecType type,
+      rtc::ArrayView<const uint8_t> payload,
+      PayloadSizeLimits limits,
+      // Codec-specific details.
+      const RTPVideoHeader& rtp_video_header,
+      FrameType frame_type,
+      const RTPFragmentationHeader* fragmentation);
 
-  virtual ~RtpPacketizer() {}
+  virtual ~RtpPacketizer() = default;
 
-  // Returns total number of packets which would be produced by the packetizer.
-  virtual size_t SetPayloadData(
-      const uint8_t* payload_data,
-      size_t payload_size,
-      const RTPFragmentationHeader* fragmentation) = 0;
+  // Returns number of remaining packets to produce by the packetizer.
+  virtual size_t NumPackets() const = 0;
 
   // Get the next payload with payload header.
   // Write payload and set marker bit of the |packet|.
   // Returns true on success, false otherwise.
   virtual bool NextPacket(RtpPacketToSend* packet) = 0;
-
-  virtual std::string ToString() = 0;
 };
 
 // TODO(sprang): Update the depacketizer to return a std::unqie_ptr with a copy
diff --git a/modules/rtp_rtcp/source/rtp_format_h264.cc b/modules/rtp_rtcp/source/rtp_format_h264.cc
index 0b8c15f..373cce9 100644
--- a/modules/rtp_rtcp/source/rtp_format_h264.cc
+++ b/modules/rtp_rtcp/source/rtp_format_h264.cc
@@ -182,6 +182,10 @@
   return num_packets_left_;
 }
 
+size_t RtpPacketizerH264::NumPackets() const {
+  return num_packets_left_;
+}
+
 bool RtpPacketizerH264::GeneratePackets() {
   for (size_t i = 0; i < input_fragments_.size();) {
     switch (packetization_mode_) {
@@ -408,10 +412,6 @@
   packets_.pop();
 }
 
-std::string RtpPacketizerH264::ToString() {
-  return "RtpPacketizerH264";
-}
-
 RtpDepacketizerH264::RtpDepacketizerH264() : offset_(0), length_(0) {}
 RtpDepacketizerH264::~RtpDepacketizerH264() {}
 
@@ -429,7 +429,8 @@
   modified_buffer_.reset();
 
   uint8_t nal_type = payload_data[0] & kTypeMask;
-  parsed_payload->video_header().h264().nalus_length = 0;
+  parsed_payload->video_header()
+      .video_type_header.emplace<RTPVideoHeaderH264>();
   if (nal_type == H264::NaluType::kFuA) {
     // Fragmented NAL units (FU-A).
     if (!ParseFuaNalu(parsed_payload, payload_data))
@@ -458,7 +459,8 @@
   parsed_payload->video_header().codec = kVideoCodecH264;
   parsed_payload->video_header().simulcastIdx = 0;
   parsed_payload->video_header().is_first_packet_in_frame = true;
-  RTPVideoHeaderH264* h264_header = &parsed_payload->video_header().h264();
+  auto& h264_header = absl::get<RTPVideoHeaderH264>(
+      parsed_payload->video_header().video_type_header);
 
   const uint8_t* nalu_start = payload_data + kNalHeaderSize;
   const size_t nalu_length = length_ - kNalHeaderSize;
@@ -476,13 +478,13 @@
       return false;
     }
 
-    h264_header->packetization_type = kH264StapA;
+    h264_header.packetization_type = kH264StapA;
     nal_type = payload_data[kStapAHeaderSize] & kTypeMask;
   } else {
-    h264_header->packetization_type = kH264SingleNalu;
+    h264_header.packetization_type = kH264SingleNalu;
     nalu_start_offsets.push_back(0);
   }
-  h264_header->nalu_type = nal_type;
+  h264_header.nalu_type = nal_type;
   parsed_payload->frame_type = kVideoFrameDelta;
 
   nalu_start_offsets.push_back(length_ + kLengthFieldSize);  // End offset.
@@ -528,7 +530,7 @@
             }
 
             // Rewrite length field to new SPS size.
-            if (h264_header->packetization_type == kH264StapA) {
+            if (h264_header.packetization_type == kH264StapA) {
               size_t length_field_offset =
                   start_offset - (H264::kNaluTypeSize + kLengthFieldSize);
               // Stap-A Length includes payload data and type header.
@@ -617,13 +619,13 @@
         RTC_LOG(LS_WARNING) << "Unexpected STAP-A or FU-A received.";
         return false;
     }
-    RTPVideoHeaderH264* h264 = &parsed_payload->video_header().h264();
-    if (h264->nalus_length == kMaxNalusPerPacket) {
+
+    if (h264_header.nalus_length == kMaxNalusPerPacket) {
       RTC_LOG(LS_WARNING)
           << "Received packet containing more than " << kMaxNalusPerPacket
           << " NAL units. Will not keep track sps and pps ids for all of them.";
     } else {
-      h264->nalus[h264->nalus_length++] = nalu;
+      h264_header.nalus[h264_header.nalus_length++] = nalu;
     }
   }
 
@@ -676,12 +678,13 @@
   parsed_payload->video_header().codec = kVideoCodecH264;
   parsed_payload->video_header().simulcastIdx = 0;
   parsed_payload->video_header().is_first_packet_in_frame = first_fragment;
-  RTPVideoHeaderH264* h264 = &parsed_payload->video_header().h264();
-  h264->packetization_type = kH264FuA;
-  h264->nalu_type = original_nal_type;
+  auto& h264_header = absl::get<RTPVideoHeaderH264>(
+      parsed_payload->video_header().video_type_header);
+  h264_header.packetization_type = kH264FuA;
+  h264_header.nalu_type = original_nal_type;
   if (first_fragment) {
-    h264->nalus[h264->nalus_length] = nalu;
-    h264->nalus_length = 1;
+    h264_header.nalus[h264_header.nalus_length] = nalu;
+    h264_header.nalus_length = 1;
   }
   return true;
 }
diff --git a/modules/rtp_rtcp/source/rtp_format_h264.h b/modules/rtp_rtcp/source/rtp_format_h264.h
index 99b080b..1f6702a 100644
--- a/modules/rtp_rtcp/source/rtp_format_h264.h
+++ b/modules/rtp_rtcp/source/rtp_format_h264.h
@@ -34,15 +34,15 @@
 
   size_t SetPayloadData(const uint8_t* payload_data,
                         size_t payload_size,
-                        const RTPFragmentationHeader* fragmentation) override;
+                        const RTPFragmentationHeader* fragmentation);
+
+  size_t NumPackets() const override;
 
   // Get the next payload with H264 payload header.
   // Write payload and set marker bit of the |packet|.
   // Returns true on success, false otherwise.
   bool NextPacket(RtpPacketToSend* rtp_packet) override;
 
-  std::string ToString() override;
-
  private:
   // Input fragments (NAL units), with an optionally owned temporary buffer,
   // used in case the fragment gets modified.
diff --git a/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc b/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc
index dc17b4f..0183a6a 100644
--- a/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc
@@ -16,7 +16,7 @@
 #include "modules/include/module_common_types.h"
 #include "modules/rtp_rtcp/mocks/mock_rtp_rtcp.h"
 #include "modules/rtp_rtcp/source/byte_io.h"
-#include "modules/rtp_rtcp/source/rtp_format.h"
+#include "modules/rtp_rtcp/source/rtp_format_h264.h"
 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
 #include "test/gmock.h"
 #include "test/gtest.h"
@@ -26,6 +26,12 @@
 
 using ::testing::ElementsAreArray;
 
+struct H264ParsedPayload : public RtpDepacketizer::ParsedPayload {
+  RTPVideoHeaderH264& h264() {
+    return absl::get<RTPVideoHeaderH264>(video.video_type_header);
+  }
+};
+
 constexpr RtpPacketToSend::ExtensionManager* kNoExtensions = nullptr;
 const size_t kMaxPayloadSize = 1200;
 const size_t kLengthFieldLength = 2;
@@ -62,13 +68,12 @@
       kNalHeaderSize + frameSize - payloadOffset;
 }
 
-RtpPacketizer* CreateH264Packetizer(H264PacketizationMode mode,
-                                    size_t max_payload_size,
-                                    size_t last_packet_reduction) {
-  RTPVideoHeader header;
-  header.h264().packetization_mode = mode;
-  return RtpPacketizer::Create(kVideoCodecH264, max_payload_size,
-                               last_packet_reduction, &header, kEmptyFrame);
+std::unique_ptr<RtpPacketizerH264> CreateH264Packetizer(
+    H264PacketizationMode mode,
+    size_t max_payload_size,
+    size_t last_packet_reduction) {
+  return absl::make_unique<RtpPacketizerH264>(max_payload_size,
+                                              last_packet_reduction, mode);
 }
 
 void VerifyFua(size_t fua_index,
@@ -111,7 +116,7 @@
   fragmentation.VerifyAndAllocateFragmentationHeader(1);
   fragmentation.fragmentationOffset[0] = 0;
   fragmentation.fragmentationLength[0] = frame_size;
-  std::unique_ptr<RtpPacketizer> packetizer(
+  std::unique_ptr<RtpPacketizerH264> packetizer(
       CreateH264Packetizer(H264PacketizationMode::NonInterleaved,
                            max_payload_size, last_packet_reduction));
   EXPECT_EQ(
@@ -184,7 +189,7 @@
   fragmentation.VerifyAndAllocateFragmentationHeader(1);
   fragmentation.fragmentationOffset[0] = 0;
   fragmentation.fragmentationLength[0] = sizeof(frame);
-  std::unique_ptr<RtpPacketizer> packetizer(
+  std::unique_ptr<RtpPacketizerH264> packetizer(
       CreateH264Packetizer(GetParam(), kMaxPayloadSize, 0));
   ASSERT_EQ(1u,
             packetizer->SetPayloadData(frame, sizeof(frame), &fragmentation));
@@ -211,7 +216,7 @@
   frame[fragmentation.fragmentationOffset[0]] = 0x01;
   frame[fragmentation.fragmentationOffset[1]] = 0x01;
 
-  std::unique_ptr<RtpPacketizer> packetizer(
+  std::unique_ptr<RtpPacketizerH264> packetizer(
       CreateH264Packetizer(GetParam(), kMaxPayloadSize, 0));
   ASSERT_EQ(2u, packetizer->SetPayloadData(frame, kFrameSize, &fragmentation));
 
@@ -244,7 +249,7 @@
     frame[i + kPayloadOffset] = i;
   RTPFragmentationHeader fragmentation;
   CreateThreeFragments(&fragmentation, kFrameSize, kPayloadOffset);
-  std::unique_ptr<RtpPacketizer> packetizer(CreateH264Packetizer(
+  std::unique_ptr<RtpPacketizerH264> packetizer(CreateH264Packetizer(
       H264PacketizationMode::NonInterleaved, kMaxPayloadSize, 0));
   ASSERT_EQ(1u, packetizer->SetPayloadData(frame, kFrameSize, &fragmentation));
 
@@ -279,7 +284,7 @@
   fragmentation.fragmentationOffset[2] = 4;
   fragmentation.fragmentationLength[2] =
       kNalHeaderSize + kFrameSize - kPayloadOffset;
-  std::unique_ptr<RtpPacketizer> packetizer(
+  std::unique_ptr<RtpPacketizerH264> packetizer(
       CreateH264Packetizer(H264PacketizationMode::NonInterleaved,
                            kMaxPayloadSize, kLastPacketReduction));
   ASSERT_EQ(2u, packetizer->SetPayloadData(frame, kFrameSize, &fragmentation));
@@ -316,7 +321,7 @@
     frame[i + kPayloadOffset] = i;
   RTPFragmentationHeader fragmentation;
   CreateThreeFragments(&fragmentation, kFrameSize, kPayloadOffset);
-  std::unique_ptr<RtpPacketizer> packetizer(CreateH264Packetizer(
+  std::unique_ptr<RtpPacketizerH264> packetizer(CreateH264Packetizer(
       H264PacketizationMode::SingleNalUnit, kMaxPayloadSize, 0));
   packetizer->SetPayloadData(frame, kFrameSize, &fragmentation);
 
@@ -345,7 +350,7 @@
   fragmentation.fragmentationOffset[2] = 4;
   fragmentation.fragmentationLength[2] =
       kNalHeaderSize + kFrameSize - kPayloadOffset;
-  std::unique_ptr<RtpPacketizer> packetizer(CreateH264Packetizer(
+  std::unique_ptr<RtpPacketizerH264> packetizer(CreateH264Packetizer(
       H264PacketizationMode::NonInterleaved, kMaxPayloadSize, 0));
   ASSERT_EQ(2u, packetizer->SetPayloadData(frame, kFrameSize, &fragmentation));
 
@@ -390,7 +395,7 @@
       frame[nalu_offset + j] = i + j;
     }
   }
-  std::unique_ptr<RtpPacketizer> packetizer(CreateH264Packetizer(
+  std::unique_ptr<RtpPacketizerH264> packetizer(CreateH264Packetizer(
       H264PacketizationMode::NonInterleaved, kMaxPayloadSize, 0));
   ASSERT_EQ(3u, packetizer->SetPayloadData(frame, kFrameSize, &fragmentation));
 
@@ -479,7 +484,7 @@
   // Set NAL headers.
   frame[fragmentation.fragmentationOffset[0]] = 0x01;
 
-  std::unique_ptr<RtpPacketizer> packetizer(CreateH264Packetizer(
+  std::unique_ptr<RtpPacketizerH264> packetizer(CreateH264Packetizer(
       H264PacketizationMode::SingleNalUnit, kMaxPayloadSize, 0));
   EXPECT_EQ(0u, packetizer->SetPayloadData(frame, kFrameSize, &fragmentation));
 }
@@ -517,16 +522,16 @@
  protected:
   rtc::Buffer in_buffer_;
   RTPFragmentationHeader fragmentation_header_;
-  std::unique_ptr<RtpPacketizer> packetizer_;
+  std::unique_ptr<RtpPacketizerH264> packetizer_;
 };
 
 TEST_F(RtpPacketizerH264TestSpsRewriting, FuASps) {
   const size_t kHeaderOverhead = kFuAHeaderSize + 1;
 
   // Set size to fragment SPS into two FU-A packets.
-  packetizer_.reset(
+  packetizer_ =
       CreateH264Packetizer(H264PacketizationMode::NonInterleaved,
-                           sizeof(kOriginalSps) - 2 + kHeaderOverhead, 0));
+                           sizeof(kOriginalSps) - 2 + kHeaderOverhead, 0);
 
   packetizer_->SetPayloadData(in_buffer_.data(), in_buffer_.size(),
                               &fragmentation_header_);
@@ -557,9 +562,8 @@
                                     sizeof(kIdrTwo) + (kLengthFieldLength * 3);
 
   // Set size to include SPS and the rest of the packets in a Stap-A package.
-  packetizer_.reset(CreateH264Packetizer(H264PacketizationMode::NonInterleaved,
-                                         kExpectedTotalSize + kHeaderOverhead,
-                                         0));
+  packetizer_ = CreateH264Packetizer(H264PacketizationMode::NonInterleaved,
+                                     kExpectedTotalSize + kHeaderOverhead, 0);
 
   packetizer_->SetPayloadData(in_buffer_.data(), in_buffer_.size(),
                               &fragmentation_header_);
@@ -579,7 +583,7 @@
   RtpDepacketizerH264Test()
       : depacketizer_(RtpDepacketizer::Create(kVideoCodecH264)) {}
 
-  void ExpectPacket(RtpDepacketizer::ParsedPayload* parsed_payload,
+  void ExpectPacket(H264ParsedPayload* parsed_payload,
                     const uint8_t* data,
                     size_t length) {
     ASSERT_TRUE(parsed_payload != NULL);
@@ -594,29 +598,29 @@
 
 TEST_F(RtpDepacketizerH264Test, TestSingleNalu) {
   uint8_t packet[2] = {0x05, 0xFF};  // F=0, NRI=0, Type=5 (IDR).
-  RtpDepacketizer::ParsedPayload payload;
+  H264ParsedPayload payload;
 
   ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet)));
   ExpectPacket(&payload, packet, sizeof(packet));
   EXPECT_EQ(kVideoFrameKey, payload.frame_type);
   EXPECT_EQ(kVideoCodecH264, payload.video_header().codec);
   EXPECT_TRUE(payload.video_header().is_first_packet_in_frame);
-  EXPECT_EQ(kH264SingleNalu, payload.video_header().h264().packetization_type);
-  EXPECT_EQ(kIdr, payload.video_header().h264().nalu_type);
+  EXPECT_EQ(kH264SingleNalu, payload.h264().packetization_type);
+  EXPECT_EQ(kIdr, payload.h264().nalu_type);
 }
 
 TEST_F(RtpDepacketizerH264Test, TestSingleNaluSpsWithResolution) {
   uint8_t packet[] = {kSps, 0x7A, 0x00, 0x1F, 0xBC, 0xD9, 0x40, 0x50,
                       0x05, 0xBA, 0x10, 0x00, 0x00, 0x03, 0x00, 0xC0,
                       0x00, 0x00, 0x03, 0x2A, 0xE0, 0xF1, 0x83, 0x25};
-  RtpDepacketizer::ParsedPayload payload;
+  H264ParsedPayload payload;
 
   ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet)));
   ExpectPacket(&payload, packet, sizeof(packet));
   EXPECT_EQ(kVideoFrameKey, payload.frame_type);
   EXPECT_EQ(kVideoCodecH264, payload.video_header().codec);
   EXPECT_TRUE(payload.video_header().is_first_packet_in_frame);
-  EXPECT_EQ(kH264SingleNalu, payload.video_header().h264().packetization_type);
+  EXPECT_EQ(kH264SingleNalu, payload.h264().packetization_type);
   EXPECT_EQ(1280u, payload.video_header().width);
   EXPECT_EQ(720u, payload.video_header().height);
 }
@@ -639,13 +643,13 @@
                         0x85, 0xB8, 0x0, 0x4, 0x0, 0x0, 0x13, 0x93, 0x12, 0x0};
   // clang-format on
 
-  RtpDepacketizer::ParsedPayload payload;
+  H264ParsedPayload payload;
   ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet)));
   ExpectPacket(&payload, packet, sizeof(packet));
   EXPECT_EQ(kVideoFrameKey, payload.frame_type);
   EXPECT_EQ(kVideoCodecH264, payload.video_header().codec);
   EXPECT_TRUE(payload.video_header().is_first_packet_in_frame);
-  const RTPVideoHeaderH264& h264 = payload.video_header().h264();
+  const RTPVideoHeaderH264& h264 = payload.h264();
   EXPECT_EQ(kH264StapA, h264.packetization_type);
   // NALU type for aggregated packets is the type of the first packet only.
   EXPECT_EQ(kSps, h264.nalu_type);
@@ -669,14 +673,14 @@
                       0x00, 0x03, kIdr, 0xFF, 0x00, 0x00, 0x04, kIdr, 0xFF,
                       0x00, 0x11};
 
-  RtpDepacketizer::ParsedPayload payload;
+  H264ParsedPayload payload;
 
   ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet)));
   ExpectPacket(&payload, packet, sizeof(packet));
   EXPECT_EQ(kVideoFrameKey, payload.frame_type);
   EXPECT_EQ(kVideoCodecH264, payload.video_header().codec);
   EXPECT_TRUE(payload.video_header().is_first_packet_in_frame);
-  EXPECT_EQ(kH264StapA, payload.video_header().h264().packetization_type);
+  EXPECT_EQ(kH264StapA, payload.h264().packetization_type);
   EXPECT_EQ(1280u, payload.video_header().width);
   EXPECT_EQ(720u, payload.video_header().height);
 }
@@ -693,7 +697,7 @@
   uint8_t trailing_empty_packet[] = {kStapA, 0x00, 0x03, kIdr,
                                      0xFF,   0x00, 0x00, 0x00};
 
-  RtpDepacketizer::ParsedPayload payload;
+  H264ParsedPayload payload;
 
   EXPECT_FALSE(depacketizer_->Parse(&payload, lone_empty_packet,
                                     sizeof(lone_empty_packet)));
@@ -732,7 +736,7 @@
   out_buffer.AppendData(kHeader, 2);
   out_buffer.AppendData(kIdrTwo);
 
-  RtpDepacketizer::ParsedPayload payload;
+  H264ParsedPayload payload;
   EXPECT_TRUE(
       depacketizer_->Parse(&payload, in_buffer.data(), in_buffer.size()));
 
@@ -779,7 +783,7 @@
   out_buffer.AppendData(kHeader, 2);
   out_buffer.AppendData(kIdrTwo);
 
-  RtpDepacketizer::ParsedPayload payload;
+  H264ParsedPayload payload;
   EXPECT_TRUE(
       depacketizer_->Parse(&payload, in_buffer.data(), in_buffer.size()));
 
@@ -796,16 +800,16 @@
                                  // Length, nal header, payload.
                         0, 0x02, kSlice, 0xFF, 0, 0x03, kSlice, 0xFF, 0x00, 0,
                         0x04, kSlice, 0xFF, 0x00, 0x11};
-  RtpDepacketizer::ParsedPayload payload;
+  H264ParsedPayload payload;
 
   ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet)));
   ExpectPacket(&payload, packet, sizeof(packet));
   EXPECT_EQ(kVideoFrameDelta, payload.frame_type);
   EXPECT_EQ(kVideoCodecH264, payload.video_header().codec);
   EXPECT_TRUE(payload.video_header().is_first_packet_in_frame);
-  EXPECT_EQ(kH264StapA, payload.video_header().h264().packetization_type);
+  EXPECT_EQ(kH264StapA, payload.h264().packetization_type);
   // NALU type for aggregated packets is the type of the first packet only.
-  EXPECT_EQ(kSlice, payload.video_header().h264().nalu_type);
+  EXPECT_EQ(kSlice, payload.h264().nalu_type);
 }
 
 TEST_F(RtpDepacketizerH264Test, TestFuA) {
@@ -833,7 +837,7 @@
   };
   const uint8_t kExpected3[] = {0x03};
 
-  RtpDepacketizer::ParsedPayload payload;
+  H264ParsedPayload payload;
 
   // We expect that the first packet is one byte shorter since the FU-A header
   // has been replaced by the original nal header.
@@ -842,7 +846,7 @@
   EXPECT_EQ(kVideoFrameKey, payload.frame_type);
   EXPECT_EQ(kVideoCodecH264, payload.video_header().codec);
   EXPECT_TRUE(payload.video_header().is_first_packet_in_frame);
-  const RTPVideoHeaderH264& h264 = payload.video_header().h264();
+  const RTPVideoHeaderH264& h264 = payload.h264();
   EXPECT_EQ(kH264FuA, h264.packetization_type);
   EXPECT_EQ(kIdr, h264.nalu_type);
   ASSERT_EQ(1u, h264.nalus_length);
@@ -852,28 +856,28 @@
 
   // Following packets will be 2 bytes shorter since they will only be appended
   // onto the first packet.
-  payload = RtpDepacketizer::ParsedPayload();
+  payload = H264ParsedPayload();
   ASSERT_TRUE(depacketizer_->Parse(&payload, packet2, sizeof(packet2)));
   ExpectPacket(&payload, kExpected2, sizeof(kExpected2));
   EXPECT_EQ(kVideoFrameKey, payload.frame_type);
   EXPECT_EQ(kVideoCodecH264, payload.video_header().codec);
   EXPECT_FALSE(payload.video_header().is_first_packet_in_frame);
   {
-    const RTPVideoHeaderH264& h264 = payload.video_header().h264();
+    const RTPVideoHeaderH264& h264 = payload.h264();
     EXPECT_EQ(kH264FuA, h264.packetization_type);
     EXPECT_EQ(kIdr, h264.nalu_type);
     // NALU info is only expected for the first FU-A packet.
     EXPECT_EQ(0u, h264.nalus_length);
   }
 
-  payload = RtpDepacketizer::ParsedPayload();
+  payload = H264ParsedPayload();
   ASSERT_TRUE(depacketizer_->Parse(&payload, packet3, sizeof(packet3)));
   ExpectPacket(&payload, kExpected3, sizeof(kExpected3));
   EXPECT_EQ(kVideoFrameKey, payload.frame_type);
   EXPECT_EQ(kVideoCodecH264, payload.video_header().codec);
   EXPECT_FALSE(payload.video_header().is_first_packet_in_frame);
   {
-    const RTPVideoHeaderH264& h264 = payload.video_header().h264();
+    const RTPVideoHeaderH264& h264 = payload.h264();
     EXPECT_EQ(kH264FuA, h264.packetization_type);
     EXPECT_EQ(kIdr, h264.nalu_type);
     // NALU info is only expected for the first FU-A packet.
@@ -884,37 +888,37 @@
 TEST_F(RtpDepacketizerH264Test, TestEmptyPayload) {
   // Using a wild pointer to crash on accesses from inside the depacketizer.
   uint8_t* garbage_ptr = reinterpret_cast<uint8_t*>(0x4711);
-  RtpDepacketizer::ParsedPayload payload;
+  H264ParsedPayload payload;
   EXPECT_FALSE(depacketizer_->Parse(&payload, garbage_ptr, 0));
 }
 
 TEST_F(RtpDepacketizerH264Test, TestTruncatedFuaNalu) {
   const uint8_t kPayload[] = {0x9c};
-  RtpDepacketizer::ParsedPayload payload;
+  H264ParsedPayload payload;
   EXPECT_FALSE(depacketizer_->Parse(&payload, kPayload, sizeof(kPayload)));
 }
 
 TEST_F(RtpDepacketizerH264Test, TestTruncatedSingleStapANalu) {
   const uint8_t kPayload[] = {0xd8, 0x27};
-  RtpDepacketizer::ParsedPayload payload;
+  H264ParsedPayload payload;
   EXPECT_FALSE(depacketizer_->Parse(&payload, kPayload, sizeof(kPayload)));
 }
 
 TEST_F(RtpDepacketizerH264Test, TestStapAPacketWithTruncatedNalUnits) {
   const uint8_t kPayload[] = {0x58, 0xCB, 0xED, 0xDF};
-  RtpDepacketizer::ParsedPayload payload;
+  H264ParsedPayload payload;
   EXPECT_FALSE(depacketizer_->Parse(&payload, kPayload, sizeof(kPayload)));
 }
 
 TEST_F(RtpDepacketizerH264Test, TestTruncationJustAfterSingleStapANalu) {
   const uint8_t kPayload[] = {0x38, 0x27, 0x27};
-  RtpDepacketizer::ParsedPayload payload;
+  H264ParsedPayload payload;
   EXPECT_FALSE(depacketizer_->Parse(&payload, kPayload, sizeof(kPayload)));
 }
 
 TEST_F(RtpDepacketizerH264Test, TestShortSpsPacket) {
   const uint8_t kPayload[] = {0x27, 0x80, 0x00};
-  RtpDepacketizer::ParsedPayload payload;
+  H264ParsedPayload payload;
   EXPECT_TRUE(depacketizer_->Parse(&payload, kPayload, sizeof(kPayload)));
 }
 
@@ -923,9 +927,9 @@
       kSei,                   // F=0, NRI=0, Type=6.
       0x03, 0x03, 0x03, 0x03  // Payload.
   };
-  RtpDepacketizer::ParsedPayload payload;
+  H264ParsedPayload payload;
   ASSERT_TRUE(depacketizer_->Parse(&payload, kPayload, sizeof(kPayload)));
-  const RTPVideoHeaderH264& h264 = payload.video_header().h264();
+  const RTPVideoHeaderH264& h264 = payload.h264();
   EXPECT_EQ(kVideoFrameDelta, payload.frame_type);
   EXPECT_EQ(kH264SingleNalu, h264.packetization_type);
   EXPECT_EQ(kSei, h264.nalu_type);
diff --git a/modules/rtp_rtcp/source/rtp_format_video_generic.cc b/modules/rtp_rtcp/source/rtp_format_video_generic.cc
index a2a3ad1..1731237 100644
--- a/modules/rtp_rtcp/source/rtp_format_video_generic.cc
+++ b/modules/rtp_rtcp/source/rtp_format_video_generic.cc
@@ -18,13 +18,21 @@
 namespace webrtc {
 
 static const size_t kGenericHeaderLength = 1;
+static const size_t kExtendedHeaderLength = 2;
 
-RtpPacketizerGeneric::RtpPacketizerGeneric(FrameType frame_type,
-                                           size_t max_payload_len,
-                                           size_t last_packet_reduction_len)
-    : payload_data_(NULL),
+RtpPacketizerGeneric::RtpPacketizerGeneric(
+    const RTPVideoHeader& rtp_video_header,
+    FrameType frame_type,
+    size_t max_payload_len,
+    size_t last_packet_reduction_len)
+    : picture_id_(rtp_video_header.generic
+                      ? absl::optional<uint16_t>(
+                            rtp_video_header.generic->frame_id & 0x7FFF)
+                      : absl::nullopt),
+      payload_data_(nullptr),
       payload_size_(0),
-      max_payload_len_(max_payload_len - kGenericHeaderLength),
+      max_payload_len_(max_payload_len - kGenericHeaderLength -
+                       (picture_id_.has_value() ? kExtendedHeaderLength : 0)),
       last_packet_reduction_len_(last_packet_reduction_len),
       frame_type_(frame_type),
       num_packets_left_(0),
@@ -62,6 +70,14 @@
   if (frame_type_ == kVideoFrameKey) {
     generic_header_ |= RtpFormatVideoGeneric::kKeyFrameBit;
   }
+  if (picture_id_.has_value()) {
+    generic_header_ |= RtpFormatVideoGeneric::kExtendedHeaderBit;
+  }
+
+  return num_packets_left_;
+}
+
+size_t RtpPacketizerGeneric::NumPackets() const {
   return num_packets_left_;
 }
 
@@ -86,16 +102,24 @@
   }
   RTC_DCHECK_LE(next_packet_payload_len, max_payload_len_);
 
-  uint8_t* out_ptr =
-      packet->AllocatePayload(kGenericHeaderLength + next_packet_payload_len);
+  size_t total_length = next_packet_payload_len + kGenericHeaderLength +
+                        (picture_id_.has_value() ? kExtendedHeaderLength : 0);
+  uint8_t* out_ptr = packet->AllocatePayload(total_length);
+
   // Put generic header in packet.
   out_ptr[0] = generic_header_;
+  out_ptr += kGenericHeaderLength;
+
+  if (picture_id_.has_value()) {
+    WriteExtendedHeader(out_ptr);
+    out_ptr += kExtendedHeaderLength;
+  }
+
   // Remove first-packet bit, following packets are intermediate.
   generic_header_ &= ~RtpFormatVideoGeneric::kFirstPacketBit;
 
   // Put payload in packet.
-  memcpy(out_ptr + kGenericHeaderLength, payload_data_,
-         next_packet_payload_len);
+  memcpy(out_ptr, payload_data_, next_packet_payload_len);
   payload_data_ += next_packet_payload_len;
   payload_size_ -= next_packet_payload_len;
   --num_packets_left_;
@@ -107,8 +131,11 @@
   return true;
 }
 
-std::string RtpPacketizerGeneric::ToString() {
-  return "RtpPacketizerGeneric";
+void RtpPacketizerGeneric::WriteExtendedHeader(uint8_t* out_ptr) {
+  // Store bottom 15 bits of the the sequence number. Only 15 bits are used for
+  // compatibility with other packetizer implemenetations that also use 15 bits.
+  out_ptr[0] = (*picture_id_ >> 8) & 0x7F;
+  out_ptr[1] = *picture_id_ & 0xFF;
 }
 
 RtpDepacketizerGeneric::~RtpDepacketizerGeneric() = default;
@@ -118,7 +145,7 @@
                                    size_t payload_data_length) {
   assert(parsed_payload != NULL);
   if (payload_data_length == 0) {
-    RTC_LOG(LS_ERROR) << "Empty payload.";
+    RTC_LOG(LS_WARNING) << "Empty payload.";
     return false;
   }
 
@@ -135,6 +162,18 @@
   parsed_payload->video_header().width = 0;
   parsed_payload->video_header().height = 0;
 
+  if (generic_header & RtpFormatVideoGeneric::kExtendedHeaderBit) {
+    if (payload_data_length < kExtendedHeaderLength) {
+      RTC_LOG(LS_WARNING) << "Too short payload for generic header.";
+      return false;
+    }
+    parsed_payload->video_header().generic.emplace();
+    parsed_payload->video_header().generic->frame_id =
+        ((payload_data[0] & 0x7F) << 8) | payload_data[1];
+    payload_data += kExtendedHeaderLength;
+    payload_data_length -= kExtendedHeaderLength;
+  }
+
   parsed_payload->payload = payload_data;
   parsed_payload->payload_length = payload_data_length;
   return true;
diff --git a/modules/rtp_rtcp/source/rtp_format_video_generic.h b/modules/rtp_rtcp/source/rtp_format_video_generic.h
index 9a916bf..293b6e9 100644
--- a/modules/rtp_rtcp/source/rtp_format_video_generic.h
+++ b/modules/rtp_rtcp/source/rtp_format_video_generic.h
@@ -15,19 +15,22 @@
 #include "common_types.h"  // NOLINT(build/include)
 #include "modules/rtp_rtcp/source/rtp_format.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 namespace RtpFormatVideoGeneric {
 static const uint8_t kKeyFrameBit = 0x01;
 static const uint8_t kFirstPacketBit = 0x02;
+// If this bit is set, there will be an extended header contained in this
+// packet. This was added later so old clients will not send this.
+static const uint8_t kExtendedHeaderBit = 0x04;
 }  // namespace RtpFormatVideoGeneric
 
 class RtpPacketizerGeneric : public RtpPacketizer {
  public:
   // Initialize with payload from encoder.
   // The payload_data must be exactly one encoded generic frame.
-  RtpPacketizerGeneric(FrameType frametype,
+  RtpPacketizerGeneric(const RTPVideoHeader& rtp_video_header,
+                       FrameType frametype,
                        size_t max_payload_len,
                        size_t last_packet_reduction_len);
 
@@ -36,16 +39,17 @@
   // Returns total number of packets to be generated.
   size_t SetPayloadData(const uint8_t* payload_data,
                         size_t payload_size,
-                        const RTPFragmentationHeader* fragmentation) override;
+                        const RTPFragmentationHeader* fragmentation);
+
+  size_t NumPackets() const override;
 
   // Get the next payload with generic payload header.
   // Write payload and set marker bit of the |packet|.
   // Returns true on success, false otherwise.
   bool NextPacket(RtpPacketToSend* packet) override;
 
-  std::string ToString() override;
-
  private:
+  const absl::optional<uint16_t> picture_id_;
   const uint8_t* payload_data_;
   size_t payload_size_;
   const size_t max_payload_len_;
@@ -58,6 +62,8 @@
   // Number of packets, which will be 1 byte more than the rest.
   size_t num_larger_packets_;
 
+  void WriteExtendedHeader(uint8_t* out_ptr);
+
   RTC_DISALLOW_COPY_AND_ASSIGN(RtpPacketizerGeneric);
 };
 
diff --git a/modules/rtp_rtcp/source/rtp_format_video_generic_unittest.cc b/modules/rtp_rtcp/source/rtp_format_video_generic_unittest.cc
index 983bd8f..e77dabf 100644
--- a/modules/rtp_rtcp/source/rtp_format_video_generic_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_format_video_generic_unittest.cc
@@ -63,8 +63,8 @@
   const size_t kMaxPayloadLen = 6;
   const size_t kLastPacketReductionLen = 2;
   const size_t kPayloadSize = 13;
-  RtpPacketizerGeneric packetizer(kVideoFrameKey, kMaxPayloadLen,
-                                  kLastPacketReductionLen);
+  RtpPacketizerGeneric packetizer(RTPVideoHeader(), kVideoFrameKey,
+                                  kMaxPayloadLen, kLastPacketReductionLen);
   size_t num_packets =
       packetizer.SetPayloadData(kTestPayload, kPayloadSize, nullptr);
   std::vector<size_t> payload_sizes = NextPacketFillPayloadSizes(&packetizer);
@@ -78,8 +78,8 @@
   const size_t kMaxPayloadLen = 6;
   const size_t kLastPacketReductionLen = 2;
   const size_t kPayloadSize = 13;
-  RtpPacketizerGeneric packetizer(kVideoFrameKey, kMaxPayloadLen,
-                                  kLastPacketReductionLen);
+  RtpPacketizerGeneric packetizer(RTPVideoHeader(), kVideoFrameKey,
+                                  kMaxPayloadLen, kLastPacketReductionLen);
   size_t num_packets =
       packetizer.SetPayloadData(kTestPayload, kPayloadSize, nullptr);
   std::vector<size_t> payload_sizes = NextPacketFillPayloadSizes(&packetizer);
@@ -93,8 +93,8 @@
   const size_t kMaxPayloadLen = 6;
   const size_t kLastPacketReductionLen = 2;
   const size_t kPayloadSize = 13;
-  RtpPacketizerGeneric packetizer(kVideoFrameKey, kMaxPayloadLen,
-                                  kLastPacketReductionLen);
+  RtpPacketizerGeneric packetizer(RTPVideoHeader(), kVideoFrameKey,
+                                  kMaxPayloadLen, kLastPacketReductionLen);
   size_t num_packets =
       packetizer.SetPayloadData(kTestPayload, kPayloadSize, nullptr);
   std::vector<size_t> payload_sizes = NextPacketFillPayloadSizes(&packetizer);
@@ -114,8 +114,8 @@
   // generic header lengh for each packet minus last packet reduction).
   // 4 packets is enough for kPayloadSize.
   const size_t kMinNumPackets = 4;
-  RtpPacketizerGeneric packetizer(kVideoFrameKey, kMaxPayloadLen,
-                                  kLastPacketReductionLen);
+  RtpPacketizerGeneric packetizer(RTPVideoHeader(), kVideoFrameKey,
+                                  kMaxPayloadLen, kLastPacketReductionLen);
   size_t num_packets =
       packetizer.SetPayloadData(kTestPayload, kPayloadSize, nullptr);
   std::vector<size_t> payload_sizes = NextPacketFillPayloadSizes(&packetizer);
@@ -128,8 +128,8 @@
   const size_t kMaxPayloadLen = 8;
   const size_t kLastPacketReductionLen = 5;
   const size_t kPayloadSize = 28;
-  RtpPacketizerGeneric packetizer(kVideoFrameKey, kMaxPayloadLen,
-                                  kLastPacketReductionLen);
+  RtpPacketizerGeneric packetizer(RTPVideoHeader(), kVideoFrameKey,
+                                  kMaxPayloadLen, kLastPacketReductionLen);
   size_t num_packets =
       packetizer.SetPayloadData(kTestPayload, kPayloadSize, nullptr);
   std::vector<size_t> payload_sizes = NextPacketFillPayloadSizes(&packetizer);
@@ -143,8 +143,8 @@
   const size_t kMaxPayloadLen = 8;
   const size_t kLastPacketReductionLen = 5;
   const size_t kPayloadSize = 28;
-  RtpPacketizerGeneric packetizer(kVideoFrameKey, kMaxPayloadLen,
-                                  kLastPacketReductionLen);
+  RtpPacketizerGeneric packetizer(RTPVideoHeader(), kVideoFrameKey,
+                                  kMaxPayloadLen, kLastPacketReductionLen);
   size_t num_packets =
       packetizer.SetPayloadData(kTestPayload, kPayloadSize, nullptr);
   std::vector<size_t> payload_sizes = NextPacketFillPayloadSizes(&packetizer);
@@ -158,8 +158,8 @@
   const size_t kMaxPayloadLen = 8;
   const size_t kLastPacketReductionLen = 5;
   const size_t kPayloadSize = 28;
-  RtpPacketizerGeneric packetizer(kVideoFrameKey, kMaxPayloadLen,
-                                  kLastPacketReductionLen);
+  RtpPacketizerGeneric packetizer(RTPVideoHeader(), kVideoFrameKey,
+                                  kMaxPayloadLen, kLastPacketReductionLen);
   size_t num_packets =
       packetizer.SetPayloadData(kTestPayload, kPayloadSize, nullptr);
   std::vector<size_t> payload_sizes = NextPacketFillPayloadSizes(&packetizer);
@@ -179,8 +179,8 @@
   // generic header lengh for each packet minus last packet reduction).
   // 5 packets is enough for kPayloadSize.
   const size_t kMinNumPackets = 5;
-  RtpPacketizerGeneric packetizer(kVideoFrameKey, kMaxPayloadLen,
-                                  kLastPacketReductionLen);
+  RtpPacketizerGeneric packetizer(RTPVideoHeader(), kVideoFrameKey,
+                                  kMaxPayloadLen, kLastPacketReductionLen);
   size_t num_packets =
       packetizer.SetPayloadData(kTestPayload, kPayloadSize, nullptr);
   std::vector<size_t> payload_sizes = NextPacketFillPayloadSizes(&packetizer);
@@ -189,4 +189,85 @@
   EXPECT_EQ(num_packets, kMinNumPackets);
 }
 
+TEST(RtpPacketizerVideoGeneric, HasFrameIdWritesExtendedHeader) {
+  const size_t kMaxPayloadLen = 6;
+  const size_t kLastPacketReductionLen = 2;
+  const size_t kPayloadSize = 13;
+
+  RTPVideoHeader rtp_video_header;
+  rtp_video_header.generic.emplace().frame_id = 37;
+  RtpPacketizerGeneric packetizer(rtp_video_header, kVideoFrameKey,
+                                  kMaxPayloadLen, kLastPacketReductionLen);
+  packetizer.SetPayloadData(kTestPayload, kPayloadSize, nullptr);
+
+  RtpPacketToSend packet(nullptr);
+  packetizer.NextPacket(&packet);
+
+  rtc::ArrayView<const uint8_t> payload = packet.payload();
+  EXPECT_TRUE(payload[0] & 0x04);  // Extended header bit is set.
+  // Frame id is 37.
+  EXPECT_EQ(0u, payload[1]);
+  EXPECT_EQ(37u, payload[2]);
+}
+
+TEST(RtpPacketizerVideoGeneric, FrameIdOver15bitsWrapsAround) {
+  const size_t kMaxPayloadLen = 6;
+  const size_t kLastPacketReductionLen = 2;
+  const size_t kPayloadSize = 13;
+
+  RTPVideoHeader rtp_video_header;
+  rtp_video_header.generic.emplace().frame_id = 0x8137;
+  RtpPacketizerGeneric packetizer(rtp_video_header, kVideoFrameKey,
+                                  kMaxPayloadLen, kLastPacketReductionLen);
+  packetizer.SetPayloadData(kTestPayload, kPayloadSize, nullptr);
+
+  RtpPacketToSend packet(nullptr);
+  packetizer.NextPacket(&packet);
+
+  rtc::ArrayView<const uint8_t> payload = packet.payload();
+  EXPECT_TRUE(payload[0] & 0x04);  // Extended header bit is set.
+  // Frame id is 0x137.
+  EXPECT_EQ(0x01u, payload[1]);
+  EXPECT_EQ(0x37u, payload[2]);
+}
+
+TEST(RtpPacketizerVideoGeneric, NoFrameIdDoesNotWriteExtendedHeader) {
+  const size_t kMaxPayloadLen = 6;
+  const size_t kLastPacketReductionLen = 2;
+  const size_t kPayloadSize = 13;
+
+  RtpPacketizerGeneric packetizer(RTPVideoHeader(), kVideoFrameKey,
+                                  kMaxPayloadLen, kLastPacketReductionLen);
+  packetizer.SetPayloadData(kTestPayload, kPayloadSize, nullptr);
+
+  RtpPacketToSend packet(nullptr);
+  packetizer.NextPacket(&packet);
+
+  rtc::ArrayView<const uint8_t> payload = packet.payload();
+  EXPECT_FALSE(payload[0] & 0x04);
+}
+
+TEST(RtpDepacketizerVideoGeneric, NonExtendedHeaderNoFrameId) {
+  const size_t kPayloadLen = 1;
+  uint8_t payload[kPayloadLen] = {0x01};
+
+  RtpDepacketizerGeneric depacketizer;
+  RtpDepacketizer::ParsedPayload parsed_payload;
+  depacketizer.Parse(&parsed_payload, payload, kPayloadLen);
+
+  EXPECT_FALSE(parsed_payload.video_header().generic);
+}
+
+TEST(RtpDepacketizerVideoGeneric, ExtendedHeaderParsesFrameId) {
+  const size_t kPayloadLen = 3;
+  uint8_t payload[kPayloadLen] = {0x05, 0x13, 0x37};
+
+  RtpDepacketizerGeneric depacketizer;
+  RtpDepacketizer::ParsedPayload parsed_payload;
+  depacketizer.Parse(&parsed_payload, payload, kPayloadLen);
+
+  ASSERT_TRUE(parsed_payload.video_header().generic);
+  EXPECT_EQ(0x1337, parsed_payload.video_header().generic->frame_id);
+}
+
 }  // namespace webrtc
diff --git a/modules/rtp_rtcp/source/rtp_format_vp8.cc b/modules/rtp_rtcp/source/rtp_format_vp8.cc
index 48c7351..4a511fc 100644
--- a/modules/rtp_rtcp/source/rtp_format_vp8.cc
+++ b/modules/rtp_rtcp/source/rtp_format_vp8.cc
@@ -22,6 +22,10 @@
 
 namespace webrtc {
 namespace {
+
+// Length of VP8 payload descriptors' fixed part.
+constexpr int kVp8FixedPayloadDescriptorSize = 1;
+
 int ParseVP8PictureID(RTPVideoHeaderVP8* vp8,
                       const uint8_t** data,
                       size_t* data_length,
@@ -158,29 +162,17 @@
 
 }  // namespace
 
-RtpPacketizerVp8::RtpPacketizerVp8(const RTPVideoHeaderVP8& hdr_info,
-                                   size_t max_payload_len,
-                                   size_t last_packet_reduction_len)
-    : payload_data_(NULL),
-      payload_size_(0),
-      vp8_fixed_payload_descriptor_bytes_(1),
-      hdr_info_(hdr_info),
-      max_payload_len_(max_payload_len),
-      last_packet_reduction_len_(last_packet_reduction_len) {
+RtpPacketizerVp8::RtpPacketizerVp8(rtc::ArrayView<const uint8_t> payload,
+                                   PayloadSizeLimits limits,
+                                   const RTPVideoHeaderVP8& hdr_info)
+    : payload_data_(payload.data()), hdr_info_(hdr_info), limits_(limits) {
   RTC_DCHECK(ValidateHeader(hdr_info));
+  GeneratePackets(payload.size());
 }
 
-RtpPacketizerVp8::~RtpPacketizerVp8() {}
+RtpPacketizerVp8::~RtpPacketizerVp8() = default;
 
-size_t RtpPacketizerVp8::SetPayloadData(
-    const uint8_t* payload_data,
-    size_t payload_size,
-    const RTPFragmentationHeader* /* fragmentation */) {
-  payload_data_ = payload_data;
-  payload_size_ = payload_size;
-  if (GeneratePackets() < 0) {
-    return 0;
-  }
+size_t RtpPacketizerVp8::NumPackets() const {
   return packets_.size();
 }
 
@@ -192,10 +184,12 @@
   InfoStruct packet_info = packets_.front();
   packets_.pop();
 
-  uint8_t* buffer = packet->AllocatePayload(
-      packets_.empty() ? max_payload_len_ - last_packet_reduction_len_
-                       : max_payload_len_);
-  int bytes = WriteHeaderAndPayload(packet_info, buffer, max_payload_len_);
+  size_t packet_payload_len =
+      packets_.empty()
+          ? limits_.max_payload_len - limits_.last_packet_reduction_len
+          : limits_.max_payload_len;
+  uint8_t* buffer = packet->AllocatePayload(packet_payload_len);
+  int bytes = WriteHeaderAndPayload(packet_info, buffer, packet_payload_len);
   if (bytes < 0) {
     return false;
   }
@@ -204,33 +198,20 @@
   return true;
 }
 
-std::string RtpPacketizerVp8::ToString() {
-  return "RtpPacketizerVp8";
-}
-
-int RtpPacketizerVp8::GeneratePackets() {
-  if (max_payload_len_ < vp8_fixed_payload_descriptor_bytes_ +
-                             PayloadDescriptorExtraLength() + 1 +
-                             last_packet_reduction_len_) {
+void RtpPacketizerVp8::GeneratePackets(size_t payload_len) {
+  if (limits_.max_payload_len - limits_.last_packet_reduction_len <
+      kVp8FixedPayloadDescriptorSize + PayloadDescriptorExtraLength() + 1) {
     // The provided payload length is not long enough for the payload
     // descriptor and one payload byte in the last packet.
-    // Return an error.
-    return -1;
+    return;
   }
 
-  size_t per_packet_capacity =
-      max_payload_len_ -
-      (vp8_fixed_payload_descriptor_bytes_ + PayloadDescriptorExtraLength());
+  size_t capacity = limits_.max_payload_len - (kVp8FixedPayloadDescriptorSize +
+                                               PayloadDescriptorExtraLength());
 
-  GeneratePacketsSplitPayloadBalanced(payload_size_, per_packet_capacity);
-  return 0;
-}
-
-void RtpPacketizerVp8::GeneratePacketsSplitPayloadBalanced(size_t payload_len,
-                                                           size_t capacity) {
   // Last packet of the last partition is smaller. Pretend that it's the same
   // size, but we must write more payload to it.
-  size_t total_bytes = payload_len + last_packet_reduction_len_;
+  size_t total_bytes = payload_len + limits_.last_packet_reduction_len;
   // Integer divisions with rounding up.
   size_t num_packets_left = (total_bytes + capacity - 1) / capacity;
   size_t bytes_per_packet = total_bytes / num_packets_left;
@@ -251,7 +232,7 @@
       --current_packet_bytes;
     }
     QueuePacket(payload_len - remaining_data, current_packet_bytes,
-                remaining_data == payload_len);
+                /*first_packet=*/remaining_data == payload_len);
     remaining_data -= current_packet_bytes;
     --num_packets_left;
   }
@@ -299,19 +280,18 @@
   if (extension_length < 0)
     return -1;
 
-  memcpy(&buffer[vp8_fixed_payload_descriptor_bytes_ + extension_length],
+  memcpy(&buffer[kVp8FixedPayloadDescriptorSize + extension_length],
          &payload_data_[packet_info.payload_start_pos], packet_info.size);
 
   // Return total length of written data.
-  return packet_info.size + vp8_fixed_payload_descriptor_bytes_ +
-         extension_length;
+  return packet_info.size + kVp8FixedPayloadDescriptorSize + extension_length;
 }
 
 int RtpPacketizerVp8::WriteExtensionFields(uint8_t* buffer,
                                            size_t buffer_length) const {
   size_t extension_length = 0;
   if (XFieldPresent()) {
-    uint8_t* x_field = buffer + vp8_fixed_payload_descriptor_bytes_;
+    uint8_t* x_field = buffer + kVp8FixedPayloadDescriptorSize;
     *x_field = 0;
     extension_length = 1;  // One octet for the X field.
     if (PictureIdPresent()) {
@@ -343,10 +323,10 @@
                                            size_t* extension_length) const {
   *x_field |= kIBit;
   RTC_DCHECK_GE(buffer_length,
-                vp8_fixed_payload_descriptor_bytes_ + *extension_length);
+                kVp8FixedPayloadDescriptorSize + *extension_length);
   const int pic_id_length = WritePictureID(
-      buffer + vp8_fixed_payload_descriptor_bytes_ + *extension_length,
-      buffer_length - vp8_fixed_payload_descriptor_bytes_ - *extension_length);
+      buffer + kVp8FixedPayloadDescriptorSize + *extension_length,
+      buffer_length - kVp8FixedPayloadDescriptorSize - *extension_length);
   if (pic_id_length < 0)
     return -1;
   *extension_length += pic_id_length;
@@ -372,12 +352,11 @@
                                            uint8_t* buffer,
                                            size_t buffer_length,
                                            size_t* extension_length) const {
-  if (buffer_length <
-      vp8_fixed_payload_descriptor_bytes_ + *extension_length + 1) {
+  if (buffer_length < kVp8FixedPayloadDescriptorSize + *extension_length + 1) {
     return -1;
   }
   *x_field |= kLBit;
-  buffer[vp8_fixed_payload_descriptor_bytes_ + *extension_length] =
+  buffer[kVp8FixedPayloadDescriptorSize + *extension_length] =
       hdr_info_.tl0PicIdx;
   ++*extension_length;
   return 0;
@@ -387,12 +366,11 @@
                                               uint8_t* buffer,
                                               size_t buffer_length,
                                               size_t* extension_length) const {
-  if (buffer_length <
-      vp8_fixed_payload_descriptor_bytes_ + *extension_length + 1) {
+  if (buffer_length < kVp8FixedPayloadDescriptorSize + *extension_length + 1) {
     return -1;
   }
   uint8_t* data_field =
-      &buffer[vp8_fixed_payload_descriptor_bytes_ + *extension_length];
+      &buffer[kVp8FixedPayloadDescriptorSize + *extension_length];
   *data_field = 0;
   if (TIDFieldPresent()) {
     *x_field |= kTBit;
diff --git a/modules/rtp_rtcp/source/rtp_format_vp8.h b/modules/rtp_rtcp/source/rtp_format_vp8.h
index 3f0d7e5..dd66762 100644
--- a/modules/rtp_rtcp/source/rtp_format_vp8.h
+++ b/modules/rtp_rtcp/source/rtp_format_vp8.h
@@ -32,7 +32,6 @@
 #include "modules/include/module_common_types.h"
 #include "modules/rtp_rtcp/source/rtp_format.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
@@ -41,23 +40,19 @@
  public:
   // Initialize with payload from encoder.
   // The payload_data must be exactly one encoded VP8 frame.
-  RtpPacketizerVp8(const RTPVideoHeaderVP8& hdr_info,
-                   size_t max_payload_len,
-                   size_t last_packet_reduction_len);
+  RtpPacketizerVp8(rtc::ArrayView<const uint8_t> payload,
+                   PayloadSizeLimits limits,
+                   const RTPVideoHeaderVP8& hdr_info);
 
   ~RtpPacketizerVp8() override;
 
-  size_t SetPayloadData(const uint8_t* payload_data,
-                        size_t payload_size,
-                        const RTPFragmentationHeader* fragmentation) override;
+  size_t NumPackets() const override;
 
   // Get the next payload with VP8 payload header.
   // Write payload and set marker bit of the |packet|.
   // Returns true on success, false otherwise.
   bool NextPacket(RtpPacketToSend* packet) override;
 
-  std::string ToString() override;
-
  private:
   typedef struct {
     size_t payload_start_pos;
@@ -78,11 +73,7 @@
   static const int kYBit = 0x20;
 
   // Calculate all packet sizes and load to packet info queue.
-  int GeneratePackets();
-
-  // Splits given part of payload to packets with a given capacity. The last
-  // packet should be reduced by last_packet_reduction_len_.
-  void GeneratePacketsSplitPayloadBalanced(size_t payload_len, size_t capacity);
+  void GeneratePackets(size_t payload_len);
 
   // Insert packet into packet queue.
   void QueuePacket(size_t start_pos, size_t packet_size, bool first_packet);
@@ -142,12 +133,8 @@
   bool PictureIdPresent() const { return (PictureIdLength() > 0); }
 
   const uint8_t* payload_data_;
-  size_t payload_size_;
-  const size_t vp8_fixed_payload_descriptor_bytes_;  // Length of VP8 payload
-                                                     // descriptors' fixed part.
   const RTPVideoHeaderVP8 hdr_info_;
-  const size_t max_payload_len_;
-  const size_t last_packet_reduction_len_;
+  const PayloadSizeLimits limits_;
   InfoQueue packets_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(RtpPacketizerVp8);
diff --git a/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.cc b/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.cc
index 8dc7ba0..abc0c89 100644
--- a/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.cc
+++ b/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.cc
@@ -22,7 +22,6 @@
     : packet_(kNoExtensions),
       payload_data_(NULL),
       data_ptr_(NULL),
-      fragmentation_(NULL),
       hdr_info_(hdr),
       payload_start_(0),
       payload_size_(0),
@@ -30,7 +29,6 @@
       inited_(false) {}
 
 RtpFormatVp8TestHelper::~RtpFormatVp8TestHelper() {
-  delete fragmentation_;
   delete[] payload_data_;
 }
 
@@ -38,8 +36,6 @@
                                   size_t num_partitions) {
   if (inited_)
     return false;
-  fragmentation_ = new RTPFragmentationHeader;
-  fragmentation_->VerifyAndAllocateFragmentationHeader(num_partitions);
   payload_size_ = 0;
   // Calculate sum payload size.
   for (size_t p = 0; p < num_partitions; ++p) {
@@ -49,8 +45,6 @@
   size_t j = 0;
   // Loop through the partitions again.
   for (size_t p = 0; p < num_partitions; ++p) {
-    fragmentation_->fragmentationLength[p] = partition_sizes[p];
-    fragmentation_->fragmentationOffset[p] = j;
     for (size_t i = 0; i < partition_sizes[p]; ++i) {
       assert(j < payload_size_);
       payload_data_[j++] = p;  // Set the payload value to the partition index.
@@ -124,6 +118,7 @@
   payload_start_ = 1;
   rtc::ArrayView<const uint8_t> buffer = packet_.payload();
   EXPECT_BIT_EQ(buffer[0], 6, 0);  // Check reserved bit.
+  EXPECT_PART_ID_EQ(buffer[0], 0);  // In equal size mode, PartID is always 0.
 
   if (hdr_info_->pictureId != kNoPictureId ||
       hdr_info_->temporalIdx != kNoTemporalIdx ||
diff --git a/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.h b/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.h
index 1ed63ab..7d5a090 100644
--- a/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.h
+++ b/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.h
@@ -22,7 +22,6 @@
 #include "modules/rtp_rtcp/source/rtp_format_vp8.h"
 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
@@ -39,9 +38,10 @@
                              const bool* expected_frag_start,
                              size_t expected_num_packets);
 
-  uint8_t* payload_data() const { return payload_data_; }
+  rtc::ArrayView<const uint8_t> payload() const {
+    return rtc::ArrayView<const uint8_t>(payload_data_, payload_size_);
+  }
   size_t payload_size() const { return payload_size_; }
-  RTPFragmentationHeader* fragmentation() const { return fragmentation_; }
   size_t buffer_size() const {
     static constexpr size_t kVp8PayloadDescriptorMaxSize = 6;
     return payload_size_ + kVp8PayloadDescriptorMaxSize;
@@ -60,7 +60,6 @@
   RtpPacketToSend packet_;
   uint8_t* payload_data_;
   uint8_t* data_ptr_;
-  RTPFragmentationHeader* fragmentation_;
   const RTPVideoHeaderVP8* hdr_info_;
   int payload_start_;
   size_t payload_size_;
diff --git a/modules/rtp_rtcp/source/rtp_format_vp8_unittest.cc b/modules/rtp_rtcp/source/rtp_format_vp8_unittest.cc
index adcc5a2..b1096d8 100644
--- a/modules/rtp_rtcp/source/rtp_format_vp8_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_format_vp8_unittest.cc
@@ -15,7 +15,6 @@
 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
 #include "test/gmock.h"
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 #define CHECK_ARRAY_SIZE(expected_size, array)                     \
   static_assert(expected_size == sizeof(array) / sizeof(array[0]), \
@@ -107,10 +106,10 @@
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
   hdr_info_.pictureId = 200;          // > 0x7F should produce 2-byte PictureID
-  const size_t kMaxPayloadSize = 12;  // Small enough to produce 4 packets.
-  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, 0);
-  size_t num_packets = packetizer.SetPayloadData(
-      helper_->payload_data(), helper_->payload_size(), nullptr);
+  RtpPacketizer::PayloadSizeLimits limits;
+  limits.max_payload_len = 12;  // Small enough to produce 4 packets.
+  RtpPacketizerVp8 packetizer(helper_->payload(), limits, hdr_info_);
+  size_t num_packets = packetizer.NumPackets();
 
   // Expecting three full packets, and one with the remainder.
   const size_t kExpectedSizes[] = {11, 11, 12, 12};
@@ -133,11 +132,11 @@
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
   hdr_info_.pictureId = 200;
-  const size_t kMaxPayloadSize = 15;  // Small enough to produce 5 packets.
-  const size_t kLastPacketReduction = 5;
-  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, kLastPacketReduction);
-  size_t num_packets = packetizer.SetPayloadData(
-      helper_->payload_data(), helper_->payload_size(), nullptr);
+  RtpPacketizer::PayloadSizeLimits limits;
+  limits.max_payload_len = 15;  // Small enough to produce 5 packets.
+  limits.last_packet_reduction_len = 5;
+  RtpPacketizerVp8 packetizer(helper_->payload(), limits, hdr_info_);
+  size_t num_packets = packetizer.NumPackets();
 
   // Calculated by hand. VP8 payload descriptors are 4 byte each. 5 packets is
   // minimum possible to fit 43 payload bytes into packets with capacity of
@@ -165,10 +164,10 @@
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
   hdr_info_.nonReference = true;
-  const size_t kMaxPayloadSize = 25;  // Small enough to produce two packets.
-  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, 0);
-  size_t num_packets = packetizer.SetPayloadData(
-      helper_->payload_data(), helper_->payload_size(), nullptr);
+  RtpPacketizer::PayloadSizeLimits limits;
+  limits.max_payload_len = 25;  // Small enough to produce two packets.
+  RtpPacketizerVp8 packetizer(helper_->payload(), limits, hdr_info_);
+  size_t num_packets = packetizer.NumPackets();
 
   // EqualSize mode => First packet full; other not.
   const size_t kExpectedSizes[] = {16, 16};
@@ -194,12 +193,11 @@
   hdr_info_.tl0PicIdx = 117;
   hdr_info_.temporalIdx = 2;
   hdr_info_.layerSync = true;
-  // kMaxPayloadSize is only limited by allocated buffer size.
-  const size_t kMaxPayloadSize = helper_->buffer_size();
-  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, 0);
-  size_t num_packets = packetizer.SetPayloadData(helper_->payload_data(),
-                                                 helper_->payload_size(),
-                                                 helper_->fragmentation());
+  RtpPacketizer::PayloadSizeLimits limits;
+  // max_payload_len is only limited by allocated buffer size.
+  limits.max_payload_len = helper_->buffer_size();
+  RtpPacketizerVp8 packetizer(helper_->payload(), limits, hdr_info_);
+  size_t num_packets = packetizer.NumPackets();
 
   // Expect one single packet of payload_size() + 4 bytes header.
   const size_t kExpectedSizes[1] = {helper_->payload_size() + 4};
@@ -221,12 +219,11 @@
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
   hdr_info_.keyIdx = 17;
-  // kMaxPayloadSize is only limited by allocated buffer size.
-  const size_t kMaxPayloadSize = helper_->buffer_size();
-  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, 0);
-  size_t num_packets = packetizer.SetPayloadData(helper_->payload_data(),
-                                                 helper_->payload_size(),
-                                                 helper_->fragmentation());
+  RtpPacketizer::PayloadSizeLimits limits;
+  // max payload len is only limited by allocated buffer size.
+  limits.max_payload_len = helper_->buffer_size();
+  RtpPacketizerVp8 packetizer(helper_->payload(), limits, hdr_info_);
+  size_t num_packets = packetizer.NumPackets();
 
   // Expect one single packet of payload_size() + 3 bytes header.
   const size_t kExpectedSizes[1] = {helper_->payload_size() + 3};
@@ -249,12 +246,11 @@
 
   hdr_info_.temporalIdx = 1;
   hdr_info_.keyIdx = 5;
-  // kMaxPayloadSize is only limited by allocated buffer size.
-  const size_t kMaxPayloadSize = helper_->buffer_size();
-  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, 0);
-  size_t num_packets = packetizer.SetPayloadData(helper_->payload_data(),
-                                                 helper_->payload_size(),
-                                                 helper_->fragmentation());
+  RtpPacketizer::PayloadSizeLimits limits;
+  // max_payload_len is only limited by allocated buffer size.
+  limits.max_payload_len = helper_->buffer_size();
+  RtpPacketizerVp8 packetizer(helper_->payload(), limits, hdr_info_);
+  size_t num_packets = packetizer.NumPackets();
 
   // Expect one single packet of payload_size() + 3 bytes header.
   const size_t kExpectedSizes[1] = {helper_->payload_size() + 3};
@@ -436,8 +432,10 @@
   input_header.layerSync = false;
   input_header.tl0PicIdx = kNoTl0PicIdx;  // Disable.
   input_header.keyIdx = 31;
-  RtpPacketizerVp8 packetizer(input_header, 20, 0);
-  EXPECT_EQ(packetizer.SetPayloadData(data, 10, NULL), 1u);
+  RtpPacketizer::PayloadSizeLimits limits;
+  limits.max_payload_len = 20;
+  RtpPacketizerVp8 packetizer(data, limits, input_header);
+  EXPECT_EQ(packetizer.NumPackets(), 1u);
   ASSERT_TRUE(packetizer.NextPacket(&packet));
   EXPECT_TRUE(packet.Marker());
 
diff --git a/modules/rtp_rtcp/source/rtp_format_vp9.cc b/modules/rtp_rtcp/source/rtp_format_vp9.cc
index 8fd1be8..f800ff8 100644
--- a/modules/rtp_rtcp/source/rtp_format_vp9.cc
+++ b/modules/rtp_rtcp/source/rtp_format_vp9.cc
@@ -471,10 +471,6 @@
 
 RtpPacketizerVp9::~RtpPacketizerVp9() {}
 
-std::string RtpPacketizerVp9::ToString() {
-  return "RtpPacketizerVp9";
-}
-
 size_t RtpPacketizerVp9::SetPayloadData(
     const uint8_t* payload,
     size_t payload_size,
@@ -485,6 +481,10 @@
   return packets_.size();
 }
 
+size_t RtpPacketizerVp9::NumPackets() const {
+  return packets_.size();
+}
+
 // Splits payload in minimal number of roughly equal in size packets.
 void RtpPacketizerVp9::GeneratePackets() {
   if (max_payload_length_ < PayloadDescriptorLength(hdr_) + 1) {
@@ -719,41 +719,42 @@
 
   parsed_payload->frame_type = p_bit ? kVideoFrameDelta : kVideoFrameKey;
 
-  RTPVideoHeaderVP9* vp9 = &parsed_payload->video_header().vp9();
-  vp9->InitRTPVideoHeaderVP9();
-  vp9->inter_pic_predicted = p_bit ? true : false;
-  vp9->flexible_mode = f_bit ? true : false;
-  vp9->beginning_of_frame = b_bit ? true : false;
-  vp9->end_of_frame = e_bit ? true : false;
-  vp9->ss_data_available = v_bit ? true : false;
-  vp9->non_ref_for_inter_layer_pred = z_bit ? true : false;
+  auto& vp9_header = parsed_payload->video_header()
+                         .video_type_header.emplace<RTPVideoHeaderVP9>();
+  vp9_header.InitRTPVideoHeaderVP9();
+  vp9_header.inter_pic_predicted = p_bit ? true : false;
+  vp9_header.flexible_mode = f_bit ? true : false;
+  vp9_header.beginning_of_frame = b_bit ? true : false;
+  vp9_header.end_of_frame = e_bit ? true : false;
+  vp9_header.ss_data_available = v_bit ? true : false;
+  vp9_header.non_ref_for_inter_layer_pred = z_bit ? true : false;
 
   // Parse fields that are present.
-  if (i_bit && !ParsePictureId(&parser, vp9)) {
+  if (i_bit && !ParsePictureId(&parser, &vp9_header)) {
     RTC_LOG(LS_ERROR) << "Failed parsing VP9 picture id.";
     return false;
   }
-  if (l_bit && !ParseLayerInfo(&parser, vp9)) {
+  if (l_bit && !ParseLayerInfo(&parser, &vp9_header)) {
     RTC_LOG(LS_ERROR) << "Failed parsing VP9 layer info.";
     return false;
   }
-  if (p_bit && f_bit && !ParseRefIndices(&parser, vp9)) {
+  if (p_bit && f_bit && !ParseRefIndices(&parser, &vp9_header)) {
     RTC_LOG(LS_ERROR) << "Failed parsing VP9 ref indices.";
     return false;
   }
   if (v_bit) {
-    if (!ParseSsData(&parser, vp9)) {
+    if (!ParseSsData(&parser, &vp9_header)) {
       RTC_LOG(LS_ERROR) << "Failed parsing VP9 SS data.";
       return false;
     }
-    if (vp9->spatial_layer_resolution_present) {
+    if (vp9_header.spatial_layer_resolution_present) {
       // TODO(asapersson): Add support for spatial layers.
-      parsed_payload->video_header().width = vp9->width[0];
-      parsed_payload->video_header().height = vp9->height[0];
+      parsed_payload->video_header().width = vp9_header.width[0];
+      parsed_payload->video_header().height = vp9_header.height[0];
     }
   }
   parsed_payload->video_header().is_first_packet_in_frame =
-      b_bit && (!l_bit || !vp9->inter_layer_predicted);
+      b_bit && (!l_bit || !vp9_header.inter_layer_predicted);
 
   uint64_t rem_bits = parser.RemainingBitCount();
   assert(rem_bits % 8 == 0);
diff --git a/modules/rtp_rtcp/source/rtp_format_vp9.h b/modules/rtp_rtcp/source/rtp_format_vp9.h
index 9017864..61f04d4 100644
--- a/modules/rtp_rtcp/source/rtp_format_vp9.h
+++ b/modules/rtp_rtcp/source/rtp_format_vp9.h
@@ -27,7 +27,6 @@
 #include "modules/include/module_common_types.h"
 #include "modules/rtp_rtcp/source/rtp_format.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
@@ -39,12 +38,12 @@
 
   ~RtpPacketizerVp9() override;
 
-  std::string ToString() override;
-
   // The payload data must be one encoded VP9 layer frame.
   size_t SetPayloadData(const uint8_t* payload,
                         size_t payload_size,
-                        const RTPFragmentationHeader* fragmentation) override;
+                        const RTPFragmentationHeader* fragmentation);
+
+  size_t NumPackets() const override;
 
   // Gets the next payload with VP9 payload header.
   // Write payload and set marker bit of the |packet|.
diff --git a/modules/rtp_rtcp/source/rtp_format_vp9_unittest.cc b/modules/rtp_rtcp/source/rtp_format_vp9_unittest.cc
index b9480ef..66c6091 100644
--- a/modules/rtp_rtcp/source/rtp_format_vp9_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_format_vp9_unittest.cc
@@ -15,7 +15,6 @@
 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
 #include "test/gmock.h"
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 namespace {
@@ -83,7 +82,9 @@
   RtpDepacketizer::ParsedPayload parsed;
   ASSERT_TRUE(depacketizer->Parse(&parsed, packet, expected_length));
   EXPECT_EQ(kVideoCodecVP9, parsed.video_header().codec);
-  VerifyHeader(expected, parsed.video_header().vp9());
+  auto& vp9_header =
+      absl::get<RTPVideoHeaderVP9>(parsed.video_header().video_type_header);
+  VerifyHeader(expected, vp9_header);
   const size_t kExpectedPayloadLength = expected_length - expected_hdr_length;
   VerifyPayload(parsed, packet + expected_hdr_length, kExpectedPayloadLength);
 }
diff --git a/modules/rtp_rtcp/source/rtp_generic_frame_descriptor.cc b/modules/rtp_rtcp/source/rtp_generic_frame_descriptor.cc
index 080cac7..b5b8ce5 100644
--- a/modules/rtp_rtcp/source/rtp_generic_frame_descriptor.cc
+++ b/modules/rtp_rtcp/source/rtp_generic_frame_descriptor.cc
@@ -14,7 +14,9 @@
 
 namespace webrtc {
 
-constexpr size_t RtpGenericFrameDescriptor::kMaxNumFrameDependencies;
+constexpr int RtpGenericFrameDescriptor::kMaxNumFrameDependencies;
+constexpr int RtpGenericFrameDescriptor::kMaxTemporalLayers;
+constexpr int RtpGenericFrameDescriptor::kMaxSpatialLayers;
 
 RtpGenericFrameDescriptor::RtpGenericFrameDescriptor() = default;
 
@@ -25,7 +27,7 @@
 
 void RtpGenericFrameDescriptor::SetTemporalLayer(int temporal_layer) {
   RTC_DCHECK_GE(temporal_layer, 0);
-  RTC_DCHECK_LE(temporal_layer, 7);
+  RTC_DCHECK_LT(temporal_layer, kMaxTemporalLayers);
   temporal_layer_ = temporal_layer;
 }
 
diff --git a/modules/rtp_rtcp/source/rtp_generic_frame_descriptor.h b/modules/rtp_rtcp/source/rtp_generic_frame_descriptor.h
index 51a9ac0..e4b775e 100644
--- a/modules/rtp_rtcp/source/rtp_generic_frame_descriptor.h
+++ b/modules/rtp_rtcp/source/rtp_generic_frame_descriptor.h
@@ -20,6 +20,10 @@
 // Data to put on the wire for FrameDescriptor rtp header extension.
 class RtpGenericFrameDescriptor {
  public:
+  static constexpr int kMaxNumFrameDependencies = 8;
+  static constexpr int kMaxTemporalLayers = 8;
+  static constexpr int kMaxSpatialLayers = 8;
+
   RtpGenericFrameDescriptor();
 
   bool FirstPacketInSubFrame() const { return beginning_of_subframe_; }
@@ -51,8 +55,6 @@
   bool AddFrameDependencyDiff(uint16_t fdiff);
 
  private:
-  static constexpr size_t kMaxNumFrameDependencies = 8;
-
   bool beginning_of_subframe_ = false;
   bool end_of_subframe_ = false;
   bool beginning_of_frame_ = false;
diff --git a/modules/rtp_rtcp/source/rtp_header_extension_map_unittest.cc b/modules/rtp_rtcp/source/rtp_header_extension_map_unittest.cc
index 5eb8f1a..ad9f79c 100644
--- a/modules/rtp_rtcp/source/rtp_header_extension_map_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_header_extension_map_unittest.cc
@@ -14,7 +14,6 @@
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/rtp_rtcp/source/rtp_header_extensions.h"
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/rtp_rtcp/source/rtp_packet.cc b/modules/rtp_rtcp/source/rtp_packet.cc
index 878942b..4387fe7 100644
--- a/modules/rtp_rtcp/source/rtp_packet.cc
+++ b/modules/rtp_rtcp/source/rtp_packet.cc
@@ -107,32 +107,6 @@
   return true;
 }
 
-bool RtpPacket::Marker() const {
-  RTC_DCHECK_EQ(marker_, (data()[1] & 0x80) != 0);
-  return marker_;
-}
-
-uint8_t RtpPacket::PayloadType() const {
-  RTC_DCHECK_EQ(payload_type_, data()[1] & 0x7f);
-  return payload_type_;
-}
-
-uint16_t RtpPacket::SequenceNumber() const {
-  RTC_DCHECK_EQ(sequence_number_,
-                ByteReader<uint16_t>::ReadBigEndian(data() + 2));
-  return sequence_number_;
-}
-
-uint32_t RtpPacket::Timestamp() const {
-  RTC_DCHECK_EQ(timestamp_, ByteReader<uint32_t>::ReadBigEndian(data() + 4));
-  return timestamp_;
-}
-
-uint32_t RtpPacket::Ssrc() const {
-  RTC_DCHECK_EQ(ssrc_, ByteReader<uint32_t>::ReadBigEndian(data() + 8));
-  return ssrc_;
-}
-
 std::vector<uint32_t> RtpPacket::Csrcs() const {
   size_t num_csrc = data()[0] & 0x0F;
   RTC_DCHECK_GE(capacity(), kFixedHeaderSize + num_csrc * 4);
@@ -144,48 +118,6 @@
   return csrcs;
 }
 
-size_t RtpPacket::headers_size() const {
-  return payload_offset_;
-}
-
-size_t RtpPacket::payload_size() const {
-  return payload_size_;
-}
-
-size_t RtpPacket::padding_size() const {
-  return padding_size_;
-}
-
-rtc::ArrayView<const uint8_t> RtpPacket::payload() const {
-  return rtc::MakeArrayView(data() + payload_offset_, payload_size_);
-}
-
-rtc::CopyOnWriteBuffer RtpPacket::Buffer() const {
-  return buffer_;
-}
-
-size_t RtpPacket::capacity() const {
-  return buffer_.capacity();
-}
-
-size_t RtpPacket::size() const {
-  size_t ret = payload_offset_ + payload_size_ + padding_size_;
-  RTC_DCHECK_EQ(buffer_.size(), ret);
-  return ret;
-}
-
-const uint8_t* RtpPacket::data() const {
-  return buffer_.cdata();
-}
-
-size_t RtpPacket::FreeCapacity() const {
-  return capacity() - size();
-}
-
-size_t RtpPacket::MaxPayloadSize() const {
-  return capacity() - payload_offset_;
-}
-
 void RtpPacket::CopyHeaderFrom(const RtpPacket& packet) {
   RTC_DCHECK_GE(capacity(), packet.headers_size());
 
@@ -235,7 +167,7 @@
   ByteWriter<uint32_t>::WriteBigEndian(WriteAt(8), ssrc);
 }
 
-void RtpPacket::SetCsrcs(const std::vector<uint32_t>& csrcs) {
+void RtpPacket::SetCsrcs(rtc::ArrayView<const uint32_t> csrcs) {
   RTC_DCHECK_EQ(extensions_size_, 0);
   RTC_DCHECK_EQ(payload_size_, 0);
   RTC_DCHECK_EQ(padding_size_, 0);
@@ -251,37 +183,7 @@
   buffer_.SetSize(payload_offset_);
 }
 
-bool RtpPacket::HasRawExtension(int id) const {
-  if (id == ExtensionManager::kInvalidId)
-    return false;
-  RTC_DCHECK_GE(id, kMinExtensionId);
-  RTC_DCHECK_LE(id, kMaxExtensionId);
-  return extension_entries_[id - 1].offset != 0;
-}
-
-rtc::ArrayView<const uint8_t> RtpPacket::GetRawExtension(int id) const {
-  if (id == ExtensionManager::kInvalidId)
-    return nullptr;
-  RTC_DCHECK_GE(id, kMinExtensionId);
-  RTC_DCHECK_LE(id, kMaxExtensionId);
-  const ExtensionInfo& extension = extension_entries_[id - 1];
-  if (extension.offset == 0)
-    return nullptr;
-  return rtc::MakeArrayView(data() + extension.offset, extension.length);
-}
-
-bool RtpPacket::SetRawExtension(int id, rtc::ArrayView<const uint8_t> data) {
-  auto buffer = AllocateRawExtension(id, data.size());
-  if (buffer.empty())
-    return false;
-  RTC_DCHECK_EQ(buffer.size(), data.size());
-  memcpy(buffer.data(), data.data(), data.size());
-  return true;
-}
-
 rtc::ArrayView<uint8_t> RtpPacket::AllocateRawExtension(int id, size_t length) {
-  if (id == ExtensionManager::kInvalidId)
-    return nullptr;
   RTC_DCHECK_GE(id, kMinExtensionId);
   RTC_DCHECK_LE(id, kMaxExtensionId);
   RTC_DCHECK_GE(length, 1);
@@ -547,12 +449,4 @@
   return nullptr;
 }
 
-uint8_t* RtpPacket::WriteAt(size_t offset) {
-  return buffer_.data() + offset;
-}
-
-void RtpPacket::WriteAt(size_t offset, uint8_t byte) {
-  buffer_.data()[offset] = byte;
-}
-
 }  // namespace webrtc
diff --git a/modules/rtp_rtcp/source/rtp_packet.h b/modules/rtp_rtcp/source/rtp_packet.h
index 2f0ef75..21adf62 100644
--- a/modules/rtp_rtcp/source/rtp_packet.h
+++ b/modules/rtp_rtcp/source/rtp_packet.h
@@ -51,27 +51,31 @@
   void IdentifyExtensions(const ExtensionManager& extensions);
 
   // Header.
-  bool Marker() const;
-  uint8_t PayloadType() const;
-  uint16_t SequenceNumber() const;
-  uint32_t Timestamp() const;
-  uint32_t Ssrc() const;
+  bool Marker() const { return marker_; }
+  uint8_t PayloadType() const { return payload_type_; }
+  uint16_t SequenceNumber() const { return sequence_number_; }
+  uint32_t Timestamp() const { return timestamp_; }
+  uint32_t Ssrc() const { return ssrc_; }
   std::vector<uint32_t> Csrcs() const;
 
-  size_t headers_size() const;
+  size_t headers_size() const { return payload_offset_; }
 
   // Payload.
-  size_t payload_size() const;
-  size_t padding_size() const;
-  rtc::ArrayView<const uint8_t> payload() const;
+  size_t payload_size() const { return payload_size_; }
+  size_t padding_size() const { return padding_size_; }
+  rtc::ArrayView<const uint8_t> payload() const {
+    return rtc::MakeArrayView(data() + payload_offset_, payload_size_);
+  }
 
   // Buffer.
-  rtc::CopyOnWriteBuffer Buffer() const;
-  size_t capacity() const;
-  size_t size() const;
-  const uint8_t* data() const;
-  size_t FreeCapacity() const;
-  size_t MaxPayloadSize() const;
+  rtc::CopyOnWriteBuffer Buffer() const { return buffer_; }
+  size_t capacity() const { return buffer_.capacity(); }
+  size_t size() const {
+    return payload_offset_ + payload_size_ + padding_size_;
+  }
+  const uint8_t* data() const { return buffer_.cdata(); }
+  size_t FreeCapacity() const { return capacity() - size(); }
+  size_t MaxPayloadSize() const { return capacity() - headers_size(); }
 
   // Reset fields and buffer.
   void Clear();
@@ -87,7 +91,7 @@
   // Writes csrc list. Assumes:
   // a) There is enough room left in buffer.
   // b) Extension headers, payload or padding data has not already been added.
-  void SetCsrcs(const std::vector<uint32_t>& csrcs);
+  void SetCsrcs(rtc::ArrayView<const uint32_t> csrcs);
 
   // Header extensions.
   template <typename Extension>
@@ -102,21 +106,6 @@
   template <typename Extension>
   bool ReserveExtension();
 
-  // Following 4 helpers identify rtp header extension by |id| negotiated with
-  // remote peer and written in an rtp packet.
-  bool HasRawExtension(int id) const;
-
-  // Returns place where extension with |id| is stored.
-  // Returns empty arrayview if extension is not present.
-  rtc::ArrayView<const uint8_t> GetRawExtension(int id) const;
-
-  // Allocates and store header extension. Returns true on success.
-  bool SetRawExtension(int id, rtc::ArrayView<const uint8_t> data);
-
-  // Allocates and returns place to store rtp header extension.
-  // Returns empty arrayview on failure.
-  rtc::ArrayView<uint8_t> AllocateRawExtension(int id, size_t length);
-
   // Reserve size_bytes for payload. Returns nullptr on failure.
   uint8_t* SetPayloadSize(size_t size_bytes);
   // Same as SetPayloadSize but doesn't guarantee to keep current payload.
@@ -138,12 +127,16 @@
   // Returns view of the raw extension or empty view on failure.
   rtc::ArrayView<const uint8_t> FindExtension(ExtensionType type) const;
 
+  // Allocates and returns place to store rtp header extension.
+  // Returns empty arrayview on failure.
+  rtc::ArrayView<uint8_t> AllocateRawExtension(int id, size_t length);
+
   // Find or allocate an extension |type|. Returns view of size |length|
   // to write raw extension to or an empty view on failure.
   rtc::ArrayView<uint8_t> AllocateExtension(ExtensionType type, size_t length);
 
-  uint8_t* WriteAt(size_t offset);
-  void WriteAt(size_t offset, uint8_t byte);
+  uint8_t* WriteAt(size_t offset) { return buffer_.data() + offset; }
+  void WriteAt(size_t offset, uint8_t byte) { buffer_.data()[offset] = byte; }
 
   // Header.
   bool marker_;
diff --git a/modules/rtp_rtcp/source/rtp_packet_history.h b/modules/rtp_rtcp/source/rtp_packet_history.h
index 03527ff..433da0e 100644
--- a/modules/rtp_rtcp/source/rtp_packet_history.h
+++ b/modules/rtp_rtcp/source/rtp_packet_history.h
@@ -19,7 +19,6 @@
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/criticalsection.h"
 #include "rtc_base/thread_annotations.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/rtp_rtcp/source/rtp_packet_history_unittest.cc b/modules/rtp_rtcp/source/rtp_packet_history_unittest.cc
index 026c187..ab5aeb0 100644
--- a/modules/rtp_rtcp/source/rtp_packet_history_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_packet_history_unittest.cc
@@ -17,7 +17,6 @@
 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
 #include "system_wrappers/include/clock.h"
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 namespace {
diff --git a/modules/rtp_rtcp/source/rtp_packet_unittest.cc b/modules/rtp_rtcp/source/rtp_packet_unittest.cc
index 60d23d8..e19f191 100644
--- a/modules/rtp_rtcp/source/rtp_packet_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_packet_unittest.cc
@@ -196,50 +196,27 @@
   EXPECT_FALSE(packet.SetExtension<RtpMid>(kLongMid));
 }
 
-TEST(RtpPacketTest, CreateWithExtensionsWithoutManager) {
-  RtpPacketToSend packet(nullptr);
-  packet.SetPayloadType(kPayloadType);
-  packet.SetSequenceNumber(kSeqNum);
-  packet.SetTimestamp(kTimestamp);
-  packet.SetSsrc(kSsrc);
-
-  auto raw = packet.AllocateRawExtension(kTransmissionOffsetExtensionId,
-                                         TransmissionOffset::kValueSizeBytes);
-  EXPECT_EQ(raw.size(), TransmissionOffset::kValueSizeBytes);
-  TransmissionOffset::Write(raw, kTimeOffset);
-
-  raw = packet.AllocateRawExtension(kAudioLevelExtensionId,
-                                    AudioLevel::kValueSizeBytes);
-  EXPECT_EQ(raw.size(), AudioLevel::kValueSizeBytes);
-  AudioLevel::Write(raw, kVoiceActive, kAudioLevel);
-
-  EXPECT_THAT(kPacketWithTOAndAL,
-              ElementsAreArray(packet.data(), packet.size()));
-}
-
 TEST(RtpPacketTest, CreateWithMaxSizeHeaderExtension) {
-  const size_t kMaxExtensionSize = 16;
-  const int kId = 1;
-  const uint8_t kValue[16] = "123456789abcdef";
+  const std::string kValue = "123456789abcdef";
+  RtpPacket::ExtensionManager extensions;
+  extensions.Register<RtpMid>(1);
+  extensions.Register<RtpStreamId>(2);
 
-  // Write packet with a custom extension.
-  RtpPacketToSend packet(nullptr);
-  packet.SetRawExtension(kId, kValue);
-  // Using different size for same id is not allowed.
-  EXPECT_TRUE(packet.AllocateRawExtension(kId, kMaxExtensionSize - 1).empty());
+  RtpPacket packet(&extensions);
+  EXPECT_TRUE(packet.SetExtension<RtpMid>(kValue));
 
   packet.SetPayloadSize(42);
   // Rewriting allocated extension is allowed.
-  EXPECT_EQ(packet.AllocateRawExtension(kId, kMaxExtensionSize).size(),
-            kMaxExtensionSize);
+  EXPECT_TRUE(packet.SetExtension<RtpMid>(kValue));
   // Adding another extension after payload is set is not allowed.
-  EXPECT_TRUE(packet.AllocateRawExtension(kId + 1, kMaxExtensionSize).empty());
+  EXPECT_FALSE(packet.SetExtension<RtpStreamId>(kValue));
 
-  // Read packet with the custom extension.
-  RtpPacketReceived parsed;
+  // Read packet with the extension.
+  RtpPacketReceived parsed(&extensions);
   EXPECT_TRUE(parsed.Parse(packet.Buffer()));
-  auto read_raw = parsed.GetRawExtension(kId);
-  EXPECT_THAT(read_raw, ElementsAreArray(kValue, kMaxExtensionSize));
+  std::string read;
+  EXPECT_TRUE(parsed.GetExtension<RtpMid>(&read));
+  EXPECT_EQ(read, kValue);
 }
 
 TEST(RtpPacketTest, SetReservedExtensionsAfterPayload) {
@@ -426,23 +403,6 @@
   EXPECT_EQ(0u, packet.padding_size());
 }
 
-TEST(RtpPacketTest, ParseWithoutExtensionManager) {
-  RtpPacketReceived packet;
-  EXPECT_TRUE(packet.Parse(kPacketWithTO, sizeof(kPacketWithTO)));
-
-  EXPECT_FALSE(packet.HasRawExtension(kAudioLevelExtensionId));
-  EXPECT_TRUE(packet.GetRawExtension(kAudioLevelExtensionId).empty());
-
-  EXPECT_TRUE(packet.HasRawExtension(kTransmissionOffsetExtensionId));
-
-  int32_t time_offset = 0;
-  auto raw_extension = packet.GetRawExtension(kTransmissionOffsetExtensionId);
-  EXPECT_EQ(raw_extension.size(), TransmissionOffset::kValueSizeBytes);
-  EXPECT_TRUE(TransmissionOffset::Parse(raw_extension, &time_offset));
-
-  EXPECT_EQ(time_offset, kTimeOffset);
-}
-
 TEST(RtpPacketTest, ParseDynamicSizeExtension) {
   // clang-format off
   const uint8_t kPacket1[] = {
@@ -493,23 +453,6 @@
   EXPECT_EQ(mid, kMid);
 }
 
-TEST(RtpPacketTest, RawExtensionFunctionsAcceptZeroIdAndReturnFalse) {
-  RtpPacketReceived::ExtensionManager extensions;
-  RtpPacketReceived packet(&extensions);
-  // Use ExtensionManager to set kInvalidId to 0 to demonstrate natural way for
-  // using zero value as a parameter to Packet::*RawExtension functions.
-  const int kInvalidId = extensions.GetId(TransmissionOffset::kId);
-  ASSERT_EQ(kInvalidId, 0);
-
-  ASSERT_TRUE(packet.Parse(kPacket, sizeof(kPacket)));
-
-  EXPECT_FALSE(packet.HasRawExtension(kInvalidId));
-  EXPECT_THAT(packet.GetRawExtension(kInvalidId), IsEmpty());
-  const uint8_t kExtension[] = {'e', 'x', 't'};
-  EXPECT_FALSE(packet.SetRawExtension(kInvalidId, kExtension));
-  EXPECT_THAT(packet.AllocateRawExtension(kInvalidId, 3), IsEmpty());
-}
-
 TEST(RtpPacketTest, CreateAndParseTimingFrameExtension) {
   // Create a packet with video frame timing extension populated.
   RtpPacketToSend::ExtensionManager send_extensions;
diff --git a/modules/rtp_rtcp/source/rtp_payload_registry.cc b/modules/rtp_rtcp/source/rtp_payload_registry.cc
index f69940a..4bbb03a 100644
--- a/modules/rtp_rtcp/source/rtp_payload_registry.cc
+++ b/modules/rtp_rtcp/source/rtp_payload_registry.cc
@@ -47,20 +47,9 @@
           PayloadUnion(AudioPayload{audio_format, 0})};
 }
 
-RtpVideoCodecTypes ConvertToRtpVideoCodecType(VideoCodecType type) {
-  switch (type) {
-    case kVideoCodecVP8:
-    case kVideoCodecVP9:
-    case kVideoCodecH264:
-      return type;
-    default:
-      return kVideoCodecGeneric;
-  }
-}
-
 RtpUtility::Payload CreatePayloadType(const VideoCodec& video_codec) {
   VideoPayload p;
-  p.videoCodecType = ConvertToRtpVideoCodecType(video_codec.codecType);
+  p.videoCodecType = video_codec.codecType;
   if (video_codec.codecType == kVideoCodecH264)
     p.h264_profile = video_codec.H264().profile;
   return {CodecTypeToPayloadString(video_codec.codecType), PayloadUnion(p)};
@@ -91,7 +80,7 @@
 
 }  // namespace
 
-RTPPayloadRegistry::RTPPayloadRegistry() : last_received_payload_type_(-1) {}
+RTPPayloadRegistry::RTPPayloadRegistry() = default;
 
 RTPPayloadRegistry::~RTPPayloadRegistry() = default;
 
@@ -112,10 +101,6 @@
     payload_type_map_.emplace(rtp_payload_type,
                               CreatePayloadType(audio_format));
   }
-
-  // Clear the value of last received payload type since it might mean
-  // something else now.
-  last_received_payload_type_ = -1;
 }
 
 int32_t RTPPayloadRegistry::RegisterReceivePayload(
@@ -153,9 +138,7 @@
   RTC_DCHECK(insert_status.second);  // Insertion succeeded.
   *created_new_payload = true;
 
-  // Successful set of payload type, clear the value of last received payload
-  // type since it might mean something else.
-  last_received_payload_type_ = -1;
+  // Successful set of payload type.
   return 0;
 }
 
@@ -186,9 +169,7 @@
       video_codec.plType, CreatePayloadType(video_codec));
   RTC_DCHECK(insert_status.second);  // Insertion succeeded.
 
-  // Successful set of payload type, clear the value of last received payload
-  // type since it might mean something else.
-  last_received_payload_type_ = -1;
+  // Successful set of payload type.
   return 0;
 }
 
diff --git a/modules/rtp_rtcp/source/rtp_payload_registry_unittest.cc b/modules/rtp_rtcp/source/rtp_payload_registry_unittest.cc
index e7362c7..9ae6aef 100644
--- a/modules/rtp_rtcp/source/rtp_payload_registry_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_payload_registry_unittest.cc
@@ -149,21 +149,6 @@
       << "Not compatible; both payloads should be kept.";
 }
 
-TEST(RtpPayloadRegistryTest,
-     LastReceivedCodecTypesAreResetWhenRegisteringNewPayloadTypes) {
-  RTPPayloadRegistry rtp_payload_registry;
-  rtp_payload_registry.set_last_received_payload_type(17);
-  EXPECT_EQ(17, rtp_payload_registry.last_received_payload_type());
-
-  bool ignored;
-  constexpr int payload_type = 34;
-  const SdpAudioFormat audio_format("name", 44000, 1);
-  EXPECT_EQ(0, rtp_payload_registry.RegisterReceivePayload(
-                   payload_type, audio_format, &ignored));
-
-  EXPECT_EQ(-1, rtp_payload_registry.last_received_payload_type());
-}
-
 class ParameterizedRtpPayloadRegistryTest
     : public ::testing::TestWithParam<int> {};
 
diff --git a/modules/rtp_rtcp/source/rtp_receiver_audio.cc b/modules/rtp_rtcp/source/rtp_receiver_audio.cc
index ac57138..030c79f 100644
--- a/modules/rtp_rtcp/source/rtp_receiver_audio.cc
+++ b/modules/rtp_rtcp/source/rtp_receiver_audio.cc
@@ -25,47 +25,10 @@
 }
 
 RTPReceiverAudio::RTPReceiverAudio(RtpData* data_callback)
-    : RTPReceiverStrategy(data_callback),
-      TelephoneEventHandler(),
-      telephone_event_forward_to_decoder_(false),
-      telephone_event_payload_type_(-1),
-      cng_nb_payload_type_(-1),
-      cng_wb_payload_type_(-1),
-      cng_swb_payload_type_(-1),
-      cng_fb_payload_type_(-1) {}
+    : RTPReceiverStrategy(data_callback) {}
 
 RTPReceiverAudio::~RTPReceiverAudio() = default;
 
-// Outband TelephoneEvent(DTMF) detection
-void RTPReceiverAudio::SetTelephoneEventForwardToDecoder(
-    bool forward_to_decoder) {
-  rtc::CritScope lock(&crit_sect_);
-  telephone_event_forward_to_decoder_ = forward_to_decoder;
-}
-
-// Is forwarding of outband telephone events turned on/off?
-bool RTPReceiverAudio::TelephoneEventForwardToDecoder() const {
-  rtc::CritScope lock(&crit_sect_);
-  return telephone_event_forward_to_decoder_;
-}
-
-bool RTPReceiverAudio::TelephoneEventPayloadType(int8_t payload_type) const {
-  rtc::CritScope lock(&crit_sect_);
-  return telephone_event_payload_type_ == payload_type;
-}
-
-TelephoneEventHandler* RTPReceiverAudio::GetTelephoneEventHandler() {
-  return this;
-}
-
-bool RTPReceiverAudio::CNGPayloadType(int8_t payload_type) {
-  rtc::CritScope lock(&crit_sect_);
-  return payload_type == cng_nb_payload_type_ ||
-         payload_type == cng_wb_payload_type_ ||
-         payload_type == cng_swb_payload_type_ ||
-         payload_type == cng_fb_payload_type_;
-}
-
 // -   Sample based or frame based codecs based on RFC 3551
 // -
 // -   NOTE! There is one error in the RFC, stating G.722 uses 8 bits/samples.
@@ -98,32 +61,6 @@
 // -   MPA       frame         N/A              var.      var.
 // -
 // -   G7221     frame         N/A
-int32_t RTPReceiverAudio::OnNewPayloadTypeCreated(
-    int payload_type,
-    const SdpAudioFormat& audio_format) {
-  rtc::CritScope lock(&crit_sect_);
-
-  if (RtpUtility::StringCompare(audio_format.name.c_str(), "telephone-event",
-                                15)) {
-    telephone_event_payload_type_ = payload_type;
-  }
-  if (RtpUtility::StringCompare(audio_format.name.c_str(), "cn", 2)) {
-    // We support comfort noise at four different frequencies.
-    if (audio_format.clockrate_hz == 8000) {
-      cng_nb_payload_type_ = payload_type;
-    } else if (audio_format.clockrate_hz == 16000) {
-      cng_wb_payload_type_ = payload_type;
-    } else if (audio_format.clockrate_hz == 32000) {
-      cng_swb_payload_type_ = payload_type;
-    } else if (audio_format.clockrate_hz == 48000) {
-      cng_fb_payload_type_ = payload_type;
-    } else {
-      assert(false);
-      return -1;
-    }
-  }
-  return 0;
-}
 
 int32_t RTPReceiverAudio::ParseRtpPacket(WebRtcRTPHeader* rtp_header,
                                          const PayloadUnion& specific_payload,
@@ -138,24 +75,6 @@
                                  specific_payload.audio_payload());
 }
 
-RTPAliveType RTPReceiverAudio::ProcessDeadOrAlive(
-    uint16_t last_payload_length) const {
-  // Our CNG is 9 bytes; if it's a likely CNG the receiver needs to check
-  // kRtpNoRtp against NetEq speech_type kOutputPLCtoCNG.
-  if (last_payload_length < 10) {  // our CNG is 9 bytes
-    return kRtpNoRtp;
-  } else {
-    return kRtpDead;
-  }
-}
-
-void RTPReceiverAudio::CheckPayloadChanged(int8_t payload_type,
-                                           PayloadUnion* /* specific_payload */,
-                                           bool* should_discard_changes) {
-  *should_discard_changes =
-      TelephoneEventPayloadType(payload_type) || CNGPayloadType(payload_type);
-}
-
 // We are not allowed to have any critsects when calling data_callback.
 int32_t RTPReceiverAudio::ParseAudioCodecSpecific(
     WebRtcRTPHeader* rtp_header,
@@ -170,71 +89,6 @@
     return data_callback_->OnReceivedPayloadData(nullptr, 0, rtp_header);
   }
 
-  bool telephone_event_packet =
-      TelephoneEventPayloadType(rtp_header->header.payloadType);
-  if (telephone_event_packet) {
-    rtc::CritScope lock(&crit_sect_);
-
-    // RFC 4733 2.3
-    // 0                   1                   2                   3
-    // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
-    // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-    // |     event     |E|R| volume    |          duration             |
-    // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-    //
-    if (payload_data_length % 4 != 0) {
-      return -1;
-    }
-    size_t number_of_events = payload_data_length / 4;
-
-    // sanity
-    if (number_of_events >= MAX_NUMBER_OF_PARALLEL_TELEPHONE_EVENTS) {
-      number_of_events = MAX_NUMBER_OF_PARALLEL_TELEPHONE_EVENTS;
-    }
-    for (size_t n = 0; n < number_of_events; ++n) {
-      RTC_DCHECK_GE(payload_data_length, (4 * n) + 2);
-      bool end = (payload_data[(4 * n) + 1] & 0x80) ? true : false;
-
-      std::set<uint8_t>::iterator event =
-          telephone_event_reported_.find(payload_data[4 * n]);
-
-      if (event != telephone_event_reported_.end()) {
-        // we have already seen this event
-        if (end) {
-          telephone_event_reported_.erase(payload_data[4 * n]);
-        }
-      } else {
-        if (end) {
-          // don't add if it's a end of a tone
-        } else {
-          telephone_event_reported_.insert(payload_data[4 * n]);
-        }
-      }
-    }
-
-    // RFC 4733 2.5.1.3 & 2.5.2.3 Long-Duration Events
-    // should not be a problem since we don't care about the duration
-
-    // RFC 4733 See 2.5.1.5. & 2.5.2.4.  Multiple Events in a Packet
-  }
-
-  {
-    rtc::CritScope lock(&crit_sect_);
-
-    // check if it's a DTMF event, hence something we can playout
-    if (telephone_event_packet) {
-      if (!telephone_event_forward_to_decoder_) {
-        // don't forward event to decoder
-        return 0;
-      }
-      std::set<uint8_t>::iterator first = telephone_event_reported_.begin();
-      if (first != telephone_event_reported_.end() && *first > 15) {
-        // don't forward non DTMF events
-        return 0;
-      }
-    }
-  }
-
   return data_callback_->OnReceivedPayloadData(payload_data,
                                                payload_data_length, rtp_header);
 }
diff --git a/modules/rtp_rtcp/source/rtp_receiver_audio.h b/modules/rtp_rtcp/source/rtp_receiver_audio.h
index d88acfd..5d97a1f 100644
--- a/modules/rtp_rtcp/source/rtp_receiver_audio.h
+++ b/modules/rtp_rtcp/source/rtp_receiver_audio.h
@@ -18,64 +18,27 @@
 #include "modules/rtp_rtcp/source/rtp_receiver_strategy.h"
 #include "modules/rtp_rtcp/source/rtp_utility.h"
 #include "rtc_base/onetimeevent.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
 // Handles audio RTP packets. This class is thread-safe.
-class RTPReceiverAudio : public RTPReceiverStrategy,
-                         public TelephoneEventHandler {
+class RTPReceiverAudio : public RTPReceiverStrategy {
  public:
   explicit RTPReceiverAudio(RtpData* data_callback);
   ~RTPReceiverAudio() override;
 
-  // The following three methods implement the TelephoneEventHandler interface.
-  // Forward DTMFs to decoder for playout.
-  void SetTelephoneEventForwardToDecoder(bool forward_to_decoder) override;
-
-  // Is forwarding of outband telephone events turned on/off?
-  bool TelephoneEventForwardToDecoder() const override;
-
-  // Is TelephoneEvent configured with |payload_type|.
-  bool TelephoneEventPayloadType(const int8_t payload_type) const override;
-
-  TelephoneEventHandler* GetTelephoneEventHandler() override;
-
-  // Returns true if CNG is configured with |payload_type|.
-  bool CNGPayloadType(const int8_t payload_type);
-
   int32_t ParseRtpPacket(WebRtcRTPHeader* rtp_header,
                          const PayloadUnion& specific_payload,
                          const uint8_t* packet,
                          size_t payload_length,
                          int64_t timestamp_ms) override;
 
-  RTPAliveType ProcessDeadOrAlive(uint16_t last_payload_length) const override;
-
-  int32_t OnNewPayloadTypeCreated(int payload_type,
-                                  const SdpAudioFormat& audio_format) override;
-
-  // We need to look out for special payload types here and sometimes reset
-  // statistics. In addition we sometimes need to tweak the frequency.
-  void CheckPayloadChanged(int8_t payload_type,
-                           PayloadUnion* specific_payload,
-                           bool* should_discard_changes) override;
-
  private:
   int32_t ParseAudioCodecSpecific(WebRtcRTPHeader* rtp_header,
                                   const uint8_t* payload_data,
                                   size_t payload_length,
                                   const AudioPayload& audio_specific);
 
-  bool telephone_event_forward_to_decoder_;
-  int8_t telephone_event_payload_type_;
-  std::set<uint8_t> telephone_event_reported_;
-
-  int8_t cng_nb_payload_type_;
-  int8_t cng_wb_payload_type_;
-  int8_t cng_swb_payload_type_;
-  int8_t cng_fb_payload_type_;
-
   ThreadUnsafeOneTimeEvent first_packet_received_;
 };
 }  // namespace webrtc
diff --git a/modules/rtp_rtcp/source/rtp_receiver_impl.cc b/modules/rtp_rtcp/source/rtp_receiver_impl.cc
index ac18688..ea63e5e 100644
--- a/modules/rtp_rtcp/source/rtp_receiver_impl.cc
+++ b/modules/rtp_rtcp/source/rtp_receiver_impl.cc
@@ -85,12 +85,8 @@
       rtp_payload_registry_(rtp_payload_registry),
       rtp_media_receiver_(rtp_media_receiver),
       ssrc_(0),
-      num_csrcs_(0),
-      current_remote_csrc_(),
       last_received_timestamp_(0),
-      last_received_frame_time_ms_(-1) {
-  memset(current_remote_csrc_, 0, sizeof(current_remote_csrc_));
-}
+      last_received_frame_time_ms_(-1) {}
 
 RtpReceiverImpl::~RtpReceiverImpl() {}
 
@@ -105,14 +101,6 @@
   bool created_new_payload = false;
   int32_t result = rtp_payload_registry_->RegisterReceivePayload(
       payload_type, audio_format, &created_new_payload);
-  if (created_new_payload) {
-    if (rtp_media_receiver_->OnNewPayloadTypeCreated(payload_type,
-                                                     audio_format) != 0) {
-      RTC_LOG(LS_ERROR) << "Failed to register payload: " << audio_format.name
-                        << "/" << payload_type;
-      return -1;
-    }
-  }
   return result;
 }
 
@@ -131,18 +119,6 @@
   return ssrc_;
 }
 
-// Get remote CSRC.
-int32_t RtpReceiverImpl::CSRCs(uint32_t array_of_csrcs[kRtpCsrcSize]) const {
-  rtc::CritScope lock(&critical_section_rtp_receiver_);
-
-  assert(num_csrcs_ <= kRtpCsrcSize);
-
-  if (num_csrcs_ > 0) {
-    memcpy(array_of_csrcs, current_remote_csrc_, sizeof(uint32_t) * num_csrcs_);
-  }
-  return num_csrcs_;
-}
-
 bool RtpReceiverImpl::IncomingRtpPacket(const RTPHeader& rtp_header,
                                         const uint8_t* payload,
                                         size_t payload_length,
@@ -150,18 +126,21 @@
   // Trigger our callbacks.
   CheckSSRCChanged(rtp_header);
 
-  if (CheckPayloadChanged(rtp_header, &payload_specific) == -1) {
-    if (payload_length == 0) {
-      // OK, keep-alive packet.
-      return true;
-    }
-    RTC_LOG(LS_WARNING) << "Receiving invalid payload type.";
-    return false;
+  if (payload_length == 0) {
+    // OK, keep-alive packet.
+    return true;
+  }
+  int64_t now_ms = clock_->TimeInMilliseconds();
+
+  {
+    rtc::CritScope lock(&critical_section_rtp_receiver_);
+
+    csrcs_.Update(
+        now_ms, rtc::MakeArrayView(rtp_header.arrOfCSRCs, rtp_header.numCSRCs));
   }
 
   WebRtcRTPHeader webrtc_rtp_header{};
   webrtc_rtp_header.header = rtp_header;
-  CheckCSRC(webrtc_rtp_header);
 
   auto audio_level =
       rtp_header.extension.hasAudioLevel
@@ -170,8 +149,7 @@
   UpdateSources(audio_level);
 
   int32_t ret_val = rtp_media_receiver_->ParseRtpPacket(
-      &webrtc_rtp_header, payload_specific, payload, payload_length,
-      clock_->TimeInMilliseconds());
+      &webrtc_rtp_header, payload_specific, payload, payload_length, now_ms);
 
   if (ret_val < 0) {
     return false;
@@ -195,24 +173,15 @@
   return true;
 }
 
-TelephoneEventHandler* RtpReceiverImpl::GetTelephoneEventHandler() {
-  return rtp_media_receiver_->GetTelephoneEventHandler();
-}
-
 std::vector<RtpSource> RtpReceiverImpl::GetSources() const {
   rtc::CritScope lock(&critical_section_rtp_receiver_);
 
   int64_t now_ms = clock_->TimeInMilliseconds();
-  std::vector<RtpSource> sources;
-
   RTC_DCHECK(std::is_sorted(ssrc_sources_.begin(), ssrc_sources_.end(),
                             [](const RtpSource& lhs, const RtpSource& rhs) {
                               return lhs.timestamp_ms() < rhs.timestamp_ms();
                             }));
-  RTC_DCHECK(std::is_sorted(csrc_sources_.begin(), csrc_sources_.end(),
-                            [](const RtpSource& lhs, const RtpSource& rhs) {
-                              return lhs.timestamp_ms() < rhs.timestamp_ms();
-                            }));
+  std::vector<RtpSource> sources = csrcs_.GetSources(now_ms);
 
   std::set<uint32_t> selected_ssrcs;
   for (auto rit = ssrc_sources_.rbegin(); rit != ssrc_sources_.rend(); ++rit) {
@@ -223,13 +192,6 @@
       sources.push_back(*rit);
     }
   }
-
-  for (auto rit = csrc_sources_.rbegin(); rit != csrc_sources_.rend(); ++rit) {
-    if ((now_ms - rit->timestamp_ms()) > kGetSourcesTimeoutMs) {
-      break;
-    }
-    sources.push_back(*rit);
-  }
   return sources;
 }
 
@@ -252,85 +214,11 @@
   ssrc_ = rtp_header.ssrc;
 }
 
-// Implementation note: must not hold critsect when called.
-// TODO(phoglund): Move as much as possible of this code path into the media
-// specific receivers. Basically this method goes through a lot of trouble to
-// compute something which is only used by the media specific parts later. If
-// this code path moves we can get rid of some of the rtp_receiver ->
-// media_specific interface (such as CheckPayloadChange, possibly get/set
-// last known payload).
-int32_t RtpReceiverImpl::CheckPayloadChanged(const RTPHeader& rtp_header,
-                                             PayloadUnion* specific_payload) {
-  int8_t payload_type = rtp_header.payloadType;
-
-  {
-    rtc::CritScope lock(&critical_section_rtp_receiver_);
-
-    int8_t last_received_payload_type =
-        rtp_payload_registry_->last_received_payload_type();
-    // TODO(holmer): Remove this code when RED parsing has been broken out from
-    // RtpReceiverAudio.
-    if (payload_type != last_received_payload_type) {
-      bool should_discard_changes = false;
-
-      rtp_media_receiver_->CheckPayloadChanged(payload_type, specific_payload,
-                                               &should_discard_changes);
-
-      if (should_discard_changes) {
-        return 0;
-      }
-
-      const auto payload =
-          rtp_payload_registry_->PayloadTypeToPayload(payload_type);
-      if (!payload) {
-        // Not a registered payload type.
-        return -1;
-      }
-      rtp_payload_registry_->set_last_received_payload_type(payload_type);
-    }
-  }  // End critsect.
-
-  return 0;
-}
-
-// Implementation note: must not hold critsect when called.
-void RtpReceiverImpl::CheckCSRC(const WebRtcRTPHeader& rtp_header) {
-  const uint8_t num_csrcs = rtp_header.header.numCSRCs;
-  if (num_csrcs > kRtpCsrcSize) {
-    // Ignore.
-    return;
-  }
-  {
-    rtc::CritScope lock(&critical_section_rtp_receiver_);
-
-    // Copy new.
-    memcpy(current_remote_csrc_, rtp_header.header.arrOfCSRCs,
-           num_csrcs * sizeof(uint32_t));
-
-    num_csrcs_ = num_csrcs;
-  }  // End critsect.
-}
-
 void RtpReceiverImpl::UpdateSources(
     const absl::optional<uint8_t>& ssrc_audio_level) {
   rtc::CritScope lock(&critical_section_rtp_receiver_);
   int64_t now_ms = clock_->TimeInMilliseconds();
 
-  for (size_t i = 0; i < num_csrcs_; ++i) {
-    auto map_it = iterator_by_csrc_.find(current_remote_csrc_[i]);
-    if (map_it == iterator_by_csrc_.end()) {
-      // If it is a new CSRC, append a new object to the end of the list.
-      csrc_sources_.emplace_back(now_ms, current_remote_csrc_[i],
-                                 RtpSourceType::CSRC);
-    } else {
-      // If it is an existing CSRC, move the object to the end of the list.
-      map_it->second->update_timestamp_ms(now_ms);
-      csrc_sources_.splice(csrc_sources_.end(), csrc_sources_, map_it->second);
-    }
-    // Update the unordered_map.
-    iterator_by_csrc_[current_remote_csrc_[i]] = std::prev(csrc_sources_.end());
-  }
-
   // If this is the first packet or the SSRC is changed, insert a new
   // contributing source that uses the SSRC.
   if (ssrc_sources_.empty() || ssrc_sources_.rbegin()->source_id() != ssrc_) {
@@ -345,15 +233,6 @@
 }
 
 void RtpReceiverImpl::RemoveOutdatedSources(int64_t now_ms) {
-  std::list<RtpSource>::iterator it;
-  for (it = csrc_sources_.begin(); it != csrc_sources_.end(); ++it) {
-    if ((now_ms - it->timestamp_ms()) <= kGetSourcesTimeoutMs) {
-      break;
-    }
-    iterator_by_csrc_.erase(it->source_id());
-  }
-  csrc_sources_.erase(csrc_sources_.begin(), it);
-
   std::vector<RtpSource>::iterator vec_it;
   for (vec_it = ssrc_sources_.begin(); vec_it != ssrc_sources_.end();
        ++vec_it) {
diff --git a/modules/rtp_rtcp/source/rtp_receiver_impl.h b/modules/rtp_rtcp/source/rtp_receiver_impl.h
index ec218d3..66265f5 100644
--- a/modules/rtp_rtcp/source/rtp_receiver_impl.h
+++ b/modules/rtp_rtcp/source/rtp_receiver_impl.h
@@ -11,7 +11,6 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_RTP_RECEIVER_IMPL_H_
 #define MODULES_RTP_RTCP_SOURCE_RTP_RECEIVER_IMPL_H_
 
-#include <list>
 #include <memory>
 #include <unordered_map>
 #include <vector>
@@ -19,9 +18,9 @@
 #include "absl/types/optional.h"
 #include "modules/rtp_rtcp/include/rtp_receiver.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
+#include "modules/rtp_rtcp/source/contributing_sources.h"
 #include "modules/rtp_rtcp/source/rtp_receiver_strategy.h"
 #include "rtc_base/criticalsection.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
@@ -52,25 +51,10 @@
 
   uint32_t SSRC() const override;
 
-  int32_t CSRCs(uint32_t array_of_csrc[kRtpCsrcSize]) const override;
-
-  TelephoneEventHandler* GetTelephoneEventHandler() override;
-
   std::vector<RtpSource> GetSources() const override;
 
-  const std::vector<RtpSource>& ssrc_sources_for_testing() const {
-    return ssrc_sources_;
-  }
-
-  const std::list<RtpSource>& csrc_sources_for_testing() const {
-    return csrc_sources_;
-  }
-
  private:
   void CheckSSRCChanged(const RTPHeader& rtp_header);
-  void CheckCSRC(const WebRtcRTPHeader& rtp_header);
-  int32_t CheckPayloadChanged(const RTPHeader& rtp_header,
-                              PayloadUnion* payload);
 
   void UpdateSources(const absl::optional<uint8_t>& ssrc_audio_level);
   void RemoveOutdatedSources(int64_t now_ms);
@@ -84,9 +68,8 @@
 
   // SSRCs.
   uint32_t ssrc_ RTC_GUARDED_BY(critical_section_rtp_receiver_);
-  uint8_t num_csrcs_ RTC_GUARDED_BY(critical_section_rtp_receiver_);
-  uint32_t current_remote_csrc_[kRtpCsrcSize] RTC_GUARDED_BY(
-      critical_section_rtp_receiver_);
+
+  ContributingSources csrcs_ RTC_GUARDED_BY(critical_section_rtp_receiver_);
 
   // Sequence number and timestamps for the latest in-order packet.
   absl::optional<uint16_t> last_received_sequence_number_
@@ -96,10 +79,7 @@
   int64_t last_received_frame_time_ms_
       RTC_GUARDED_BY(critical_section_rtp_receiver_);
 
-  std::unordered_map<uint32_t, std::list<RtpSource>::iterator>
-      iterator_by_csrc_;
   // The RtpSource objects are sorted chronologically.
-  std::list<RtpSource> csrc_sources_;
   std::vector<RtpSource> ssrc_sources_;
 };
 }  // namespace webrtc
diff --git a/modules/rtp_rtcp/source/rtp_receiver_strategy.cc b/modules/rtp_rtcp/source/rtp_receiver_strategy.cc
index bcce3e3..647ecea 100644
--- a/modules/rtp_rtcp/source/rtp_receiver_strategy.cc
+++ b/modules/rtp_rtcp/source/rtp_receiver_strategy.cc
@@ -19,11 +19,4 @@
 
 RTPReceiverStrategy::~RTPReceiverStrategy() = default;
 
-void RTPReceiverStrategy::CheckPayloadChanged(int8_t payload_type,
-                                              PayloadUnion* specific_payload,
-                                              bool* should_discard_changes) {
-  // Default: Keep changes.
-  *should_discard_changes = false;
-}
-
 }  // namespace webrtc
diff --git a/modules/rtp_rtcp/source/rtp_receiver_strategy.h b/modules/rtp_rtcp/source/rtp_receiver_strategy.h
index 8b13f18..987af7c 100644
--- a/modules/rtp_rtcp/source/rtp_receiver_strategy.h
+++ b/modules/rtp_rtcp/source/rtp_receiver_strategy.h
@@ -15,14 +15,11 @@
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/rtp_rtcp/source/rtp_utility.h"
 #include "rtc_base/criticalsection.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
 struct CodecInst;
 
-class TelephoneEventHandler;
-
 // This strategy deals with media-specific RTP packet processing.
 // This class is not thread-safe and must be protected by its caller.
 class RTPReceiverStrategy {
@@ -43,24 +40,6 @@
                                  size_t payload_length,
                                  int64_t timestamp_ms) = 0;
 
-  virtual TelephoneEventHandler* GetTelephoneEventHandler() = 0;
-
-  // Computes the current dead-or-alive state.
-  virtual RTPAliveType ProcessDeadOrAlive(
-      uint16_t last_payload_length) const = 0;
-
-  // Notifies the strategy that we have created a new non-RED audio payload type
-  // in the payload registry.
-  virtual int32_t OnNewPayloadTypeCreated(
-      int payload_type,
-      const SdpAudioFormat& audio_format) = 0;
-
-  // Checks if the payload type has changed, and returns whether we should
-  // reset statistics and/or discard this packet.
-  virtual void CheckPayloadChanged(int8_t payload_type,
-                                   PayloadUnion* specific_payload,
-                                   bool* should_discard_changes);
-
  protected:
   // The data callback is where we should send received payload data.
   // See ParseRtpPacket. This class does not claim ownership of the callback.
diff --git a/modules/rtp_rtcp/source/rtp_receiver_unittest.cc b/modules/rtp_rtcp/source/rtp_receiver_unittest.cc
index e8dccf4..1400288 100644
--- a/modules/rtp_rtcp/source/rtp_receiver_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_receiver_unittest.cc
@@ -16,7 +16,6 @@
 #include "modules/rtp_rtcp/include/rtp_receiver.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/rtp_rtcp/mocks/mock_rtp_rtcp.h"
-#include "modules/rtp_rtcp/source/rtp_receiver_impl.h"
 #include "test/gmock.h"
 #include "test/gtest.h"
 
@@ -235,20 +234,11 @@
   header.arrOfCSRCs[0] = kCsrc1;
   EXPECT_TRUE(rtp_receiver_->IncomingRtpPacket(
       header, kTestPayload, sizeof(kTestPayload), payload_specific));
-  auto* rtp_receiver_impl = static_cast<RtpReceiverImpl*>(rtp_receiver_.get());
-  auto ssrc_sources = rtp_receiver_impl->ssrc_sources_for_testing();
-  ASSERT_EQ(1u, ssrc_sources.size());
-  EXPECT_EQ(kSsrc1, ssrc_sources.begin()->source_id());
-  EXPECT_EQ(RtpSourceType::SSRC, ssrc_sources.begin()->source_type());
-  EXPECT_EQ(fake_clock_.TimeInMilliseconds(),
-            ssrc_sources.begin()->timestamp_ms());
-
-  auto csrc_sources = rtp_receiver_impl->csrc_sources_for_testing();
-  ASSERT_EQ(1u, csrc_sources.size());
-  EXPECT_EQ(kCsrc1, csrc_sources.begin()->source_id());
-  EXPECT_EQ(RtpSourceType::CSRC, csrc_sources.begin()->source_type());
-  EXPECT_EQ(fake_clock_.TimeInMilliseconds(),
-            csrc_sources.begin()->timestamp_ms());
+  now_ms = fake_clock_.TimeInMilliseconds();
+  sources = rtp_receiver_->GetSources();
+  EXPECT_THAT(sources, UnorderedElementsAre(
+                           RtpSource(now_ms, kSsrc1, RtpSourceType::SSRC),
+                           RtpSource(now_ms, kCsrc1, RtpSourceType::CSRC)));
 }
 
 // The audio level from the RTPHeader extension should be stored in the
diff --git a/modules/rtp_rtcp/source/rtp_receiver_video.cc b/modules/rtp_rtcp/source/rtp_receiver_video.cc
index 5e6bf3e..1101bec 100644
--- a/modules/rtp_rtcp/source/rtp_receiver_video.cc
+++ b/modules/rtp_rtcp/source/rtp_receiver_video.cc
@@ -36,13 +36,6 @@
 
 RTPReceiverVideo::~RTPReceiverVideo() {}
 
-int32_t RTPReceiverVideo::OnNewPayloadTypeCreated(
-    int payload_type,
-    const SdpAudioFormat& audio_format) {
-  RTC_NOTREACHED();
-  return 0;
-}
-
 int32_t RTPReceiverVideo::ParseRtpPacket(WebRtcRTPHeader* rtp_header,
                                          const PayloadUnion& specific_payload,
                                          const uint8_t* payload,
@@ -108,13 +101,4 @@
              : -1;
 }
 
-TelephoneEventHandler* RTPReceiverVideo::GetTelephoneEventHandler() {
-  return nullptr;
-}
-
-RTPAliveType RTPReceiverVideo::ProcessDeadOrAlive(
-    uint16_t last_payload_length) const {
-  return kRtpDead;
-}
-
 }  // namespace webrtc
diff --git a/modules/rtp_rtcp/source/rtp_receiver_video.h b/modules/rtp_rtcp/source/rtp_receiver_video.h
index d9404d1..46b97f5 100644
--- a/modules/rtp_rtcp/source/rtp_receiver_video.h
+++ b/modules/rtp_rtcp/source/rtp_receiver_video.h
@@ -15,7 +15,6 @@
 #include "modules/rtp_rtcp/source/rtp_receiver_strategy.h"
 #include "modules/rtp_rtcp/source/rtp_utility.h"
 #include "rtc_base/onetimeevent.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
@@ -31,13 +30,6 @@
                          size_t packet_length,
                          int64_t timestamp) override;
 
-  TelephoneEventHandler* GetTelephoneEventHandler() override;
-
-  RTPAliveType ProcessDeadOrAlive(uint16_t last_payload_length) const override;
-
-  int32_t OnNewPayloadTypeCreated(int payload_type,
-                                  const SdpAudioFormat& audio_format) override;
-
   void SetPacketOverHead(uint16_t packet_over_head);
 
  private:
diff --git a/modules/rtp_rtcp/source/rtp_rtcp_config.h b/modules/rtp_rtcp/source/rtp_rtcp_config.h
index a24bcdf..6863c4c 100644
--- a/modules/rtp_rtcp/source/rtp_rtcp_config.h
+++ b/modules/rtp_rtcp/source/rtp_rtcp_config.h
@@ -13,31 +13,11 @@
 
 // Configuration file for RTP utilities (RTPSender, RTPReceiver ...)
 namespace webrtc {
-enum { NACK_BYTECOUNT_SIZE = 60 };  // size of our NACK history
-// A sanity for the NACK list parsing at the send-side.
-enum { kSendSideNackListSizeSanity = 20000 };
 enum { kDefaultMaxReorderingThreshold = 50 };  // In sequence numbers.
 enum { kRtcpMaxNackFields = 253 };
 
 enum { RTCP_SEND_BEFORE_KEY_FRAME_MS = 100 };
 enum { RTCP_MAX_REPORT_BLOCKS = 31 };  // RFC 3550 page 37
-enum {
-  kRtcpAppCode_DATA_SIZE = 32 * 4
-};  // multiple of 4, this is not a limitation of the size
-enum { RTCP_NUMBER_OF_SR = 60 };
-
-enum { MAX_NUMBER_OF_TEMPORAL_ID = 8 };              // RFC
-enum { MAX_NUMBER_OF_DEPENDENCY_QUALITY_ID = 128 };  // RFC
-enum { MAX_NUMBER_OF_REMB_FEEDBACK_SSRCS = 255 };
-
-enum { BW_HISTORY_SIZE = 35 };
-
-#define MIN_AUDIO_BW_MANAGEMENT_BITRATE 6
-#define MIN_VIDEO_BW_MANAGEMENT_BITRATE 30
-
-enum { RTP_MAX_BURST_SLEEP_TIME = 500 };
-enum { RTP_AUDIO_LEVEL_UNIQUE_ID = 0xbede };
-enum { RTP_MAX_PACKETS_PER_FRAME = 512 };  // must be multiple of 32
 }  // namespace webrtc
 
 #endif  // MODULES_RTP_RTCP_SOURCE_RTP_RTCP_CONFIG_H_
diff --git a/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc b/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
index 5071eee..2de6175 100644
--- a/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
@@ -327,7 +327,7 @@
   header.sequenceNumber = 123;
   header.ssrc = kSenderSsrc;
   header.headerLength = 12;
-  receiver_.receive_statistics_->IncomingPacket(header, 100, false);
+  receiver_.receive_statistics_->IncomingPacket(header, 100);
 
   // Send Frame before sending an SR.
   SendFrame(&sender_, kBaseLayerTid);
diff --git a/modules/rtp_rtcp/source/rtp_sender.cc b/modules/rtp_rtcp/source/rtp_sender.cc
index e0347f0..ba04b5c 100644
--- a/modules/rtp_rtcp/source/rtp_sender.cc
+++ b/modules/rtp_rtcp/source/rtp_sender.cc
@@ -160,7 +160,9 @@
       overhead_observer_(overhead_observer),
       populate_network2_timestamp_(populate_network2_timestamp),
       send_side_bwe_with_overhead_(
-          webrtc::field_trial::IsEnabled("WebRTC-SendSideBwe-WithOverhead")) {
+          webrtc::field_trial::IsEnabled("WebRTC-SendSideBwe-WithOverhead")),
+      unlimited_retransmission_experiment_(
+          field_trial::IsEnabled("WebRTC-UnlimitedScreenshareRetransmission")) {
   // This random initialization is not intended to be cryptographic strong.
   timestamp_offset_ = random_.Rand<uint32_t>();
   // Random start, 16 bits. Can't be 0.
@@ -412,6 +414,11 @@
       *transport_frame_id_out = rtp_timestamp;
     if (!sending_media_)
       return true;
+
+    // Cache video content type.
+    if (!audio_configured_ && rtp_header) {
+      video_content_type_ = rtp_header->content_type;
+    }
   }
   VideoCodecType video_type = kVideoCodecGeneric;
   if (CheckPayloadType(payload_type, &video_type) != 0) {
@@ -643,10 +650,21 @@
 
   const int32_t packet_size = static_cast<int32_t>(stored_packet->payload_size);
 
+  // Skip retransmission rate check if sending screenshare and the experiment
+  // is on.
+  bool skip_retransmission_rate_limit;
+  {
+    rtc::CritScope lock(&send_critsect_);
+    skip_retransmission_rate_limit =
+        unlimited_retransmission_experiment_ && video_content_type_ &&
+        videocontenttypehelpers::IsScreenshare(*video_content_type_);
+  }
+
   RTC_DCHECK(retransmission_rate_limiter_);
   // Check if we're overusing retransmission bitrate.
   // TODO(sprang): Add histograms for nack success or failure reasons.
-  if (!retransmission_rate_limiter_->TryUseRate(packet_size)) {
+  if (!skip_retransmission_rate_limit &&
+      !retransmission_rate_limiter_->TryUseRate(packet_size)) {
     return -1;
   }
 
diff --git a/modules/rtp_rtcp/source/rtp_sender.h b/modules/rtp_rtcp/source/rtp_sender.h
index 5ff4a0f..7f66d24 100644
--- a/modules/rtp_rtcp/source/rtp_sender.h
+++ b/modules/rtp_rtcp/source/rtp_sender.h
@@ -20,6 +20,7 @@
 #include "absl/types/optional.h"
 #include "api/array_view.h"
 #include "api/call/transport.h"
+#include "api/video/video_content_type.h"
 #include "common_types.h"  // NOLINT(build/include)
 #include "modules/rtp_rtcp/include/flexfec_sender.h"
 #include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
@@ -338,6 +339,11 @@
 
   const bool send_side_bwe_with_overhead_;
 
+  const bool unlimited_retransmission_experiment_;
+
+  absl::optional<VideoContentType> video_content_type_
+      RTC_GUARDED_BY(send_critsect_);
+
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(RTPSender);
 };
 
diff --git a/modules/rtp_rtcp/source/rtp_sender_audio.h b/modules/rtp_rtcp/source/rtp_sender_audio.h
index 16648cd..63dfc2b 100644
--- a/modules/rtp_rtcp/source/rtp_sender_audio.h
+++ b/modules/rtp_rtcp/source/rtp_sender_audio.h
@@ -19,7 +19,6 @@
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/criticalsection.h"
 #include "rtc_base/onetimeevent.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/modules/rtp_rtcp/source/rtp_sender_unittest.cc
index 1d0ddaf..d143c87 100644
--- a/modules/rtp_rtcp/source/rtp_sender_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_unittest.cc
@@ -34,7 +34,6 @@
 #include "test/gmock.h"
 #include "test/gtest.h"
 #include "test/mock_transport.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
@@ -245,9 +244,10 @@
     EXPECT_EQ(0, rtp_sender_->RegisterPayload(payload_name, kPayloadType, 90000,
                                               0, 1500));
 
+    RTPVideoHeader video_header;
     EXPECT_TRUE(rtp_sender_->SendOutgoingData(
         kVideoFrameKey, kPayloadType, kTimestamp, kCaptureTimeMs, kPayloadData,
-        sizeof(kPayloadData), nullptr, nullptr, nullptr,
+        sizeof(kPayloadData), nullptr, &video_header, nullptr,
         kDefaultExpectedRetransmissionTimeMs));
   }
 };
@@ -969,9 +969,10 @@
   uint8_t payload[] = {47, 11, 32, 93, 89};
 
   // Send keyframe
+  RTPVideoHeader video_header;
   ASSERT_TRUE(rtp_sender_->SendOutgoingData(
       kVideoFrameKey, payload_type, 1234, 4321, payload, sizeof(payload),
-      nullptr, nullptr, nullptr, kDefaultExpectedRetransmissionTimeMs));
+      nullptr, &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
 
   auto sent_payload = transport_.last_sent_packet().payload();
   uint8_t generic_header = sent_payload[0];
@@ -986,7 +987,7 @@
 
   ASSERT_TRUE(rtp_sender_->SendOutgoingData(
       kVideoFrameDelta, payload_type, 1234, 4321, payload, sizeof(payload),
-      nullptr, nullptr, nullptr, kDefaultExpectedRetransmissionTimeMs));
+      nullptr, &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
 
   sent_payload = transport_.last_sent_packet().payload();
   generic_header = sent_payload[0];
@@ -1102,7 +1103,6 @@
   EXPECT_EQ(0, rtp_sender_->RegisterPayload(payload_name, kPayloadType, 90000,
                                             0, 1500));
   RTPVideoHeader video_header;
-  memset(&video_header, 0, sizeof(RTPVideoHeader));
   video_header.video_timing.flags = VideoSendTiming::kTriggeredByTimer;
   EXPECT_TRUE(rtp_sender_->SendOutgoingData(
       kVideoFrameKey, kPayloadType, kTimestamp, kCaptureTimeMs, kPayloadData,
@@ -1301,9 +1301,10 @@
   EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _))
       .Times(::testing::AtLeast(2));
 
+  RTPVideoHeader video_header;
   ASSERT_TRUE(rtp_sender_->SendOutgoingData(
       kVideoFrameKey, payload_type, 1234, 4321, payload, sizeof(payload),
-      nullptr, nullptr, nullptr, kDefaultExpectedRetransmissionTimeMs));
+      nullptr, &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
 
   EXPECT_EQ(1U, callback.num_calls_);
   EXPECT_EQ(ssrc, callback.ssrc_);
@@ -1312,7 +1313,7 @@
 
   ASSERT_TRUE(rtp_sender_->SendOutgoingData(
       kVideoFrameDelta, payload_type, 1234, 4321, payload, sizeof(payload),
-      nullptr, nullptr, nullptr, kDefaultExpectedRetransmissionTimeMs));
+      nullptr, &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
 
   EXPECT_EQ(2U, callback.num_calls_);
   EXPECT_EQ(ssrc, callback.ssrc_);
@@ -1375,10 +1376,11 @@
   rtp_sender_->ProcessBitrate();
 
   // Send a few frames.
+  RTPVideoHeader video_header;
   for (uint32_t i = 0; i < kNumPackets; ++i) {
     ASSERT_TRUE(rtp_sender_->SendOutgoingData(
         kVideoFrameKey, payload_type, 1234, 4321, payload, sizeof(payload),
-        nullptr, nullptr, nullptr, kDefaultExpectedRetransmissionTimeMs));
+        nullptr, &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
     fake_clock_.AdvanceTimeMilliseconds(kPacketInterval);
   }
 
@@ -1459,9 +1461,10 @@
   rtp_sender_->RegisterRtpStatisticsCallback(&callback);
 
   // Send a frame.
+  RTPVideoHeader video_header;
   ASSERT_TRUE(rtp_sender_->SendOutgoingData(
       kVideoFrameKey, payload_type, 1234, 4321, payload, sizeof(payload),
-      nullptr, nullptr, nullptr, kDefaultExpectedRetransmissionTimeMs));
+      nullptr, &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
   StreamDataCounters expected;
   expected.transmitted.payload_bytes = 6;
   expected.transmitted.header_bytes = 12;
@@ -1503,7 +1506,7 @@
   rtp_sender_->SetFecParameters(fec_params, fec_params);
   ASSERT_TRUE(rtp_sender_->SendOutgoingData(
       kVideoFrameDelta, payload_type, 1234, 4321, payload, sizeof(payload),
-      nullptr, nullptr, nullptr, kDefaultExpectedRetransmissionTimeMs));
+      nullptr, &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
   expected.transmitted.payload_bytes = 40;
   expected.transmitted.header_bytes = 60;
   expected.transmitted.packets = 5;
@@ -1520,9 +1523,10 @@
                                             0, 1500));
   uint8_t payload[] = {47, 11, 32, 93, 89};
 
+  RTPVideoHeader video_header;
   ASSERT_TRUE(rtp_sender_->SendOutgoingData(
       kAudioFrameCN, payload_type, 1234, 4321, payload, sizeof(payload),
-      nullptr, nullptr, nullptr, kDefaultExpectedRetransmissionTimeMs));
+      nullptr, &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
 
   auto sent_payload = transport_.last_sent_packet().payload();
   EXPECT_THAT(sent_payload, ElementsAreArray(payload));
@@ -1539,9 +1543,10 @@
                                             0, 1500));
   uint8_t payload[] = {47, 11, 32, 93, 89};
 
+  RTPVideoHeader video_header;
   ASSERT_TRUE(rtp_sender_->SendOutgoingData(
       kAudioFrameCN, payload_type, 1234, 4321, payload, sizeof(payload),
-      nullptr, nullptr, nullptr, kDefaultExpectedRetransmissionTimeMs));
+      nullptr, &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
 
   auto sent_payload = transport_.last_sent_packet().payload();
   EXPECT_THAT(sent_payload, ElementsAreArray(payload));
@@ -1578,22 +1583,23 @@
   // During start, it takes the starting timestamp as last sent timestamp.
   // The duration is calculated as the difference of current and last sent
   // timestamp. So for first call it will skip since the duration is zero.
+  RTPVideoHeader video_header;
   ASSERT_TRUE(rtp_sender_->SendOutgoingData(
       kEmptyFrame, kPayloadType, capture_time_ms, 0, nullptr, 0, nullptr,
-      nullptr, nullptr, kDefaultExpectedRetransmissionTimeMs));
+      &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
   // DTMF Sample Length is (Frequency/1000) * Duration.
   // So in this case, it is (8000/1000) * 500 = 4000.
   // Sending it as two packets.
   ASSERT_TRUE(rtp_sender_->SendOutgoingData(
       kEmptyFrame, kPayloadType, capture_time_ms + 2000, 0, nullptr, 0, nullptr,
-      nullptr, nullptr, kDefaultExpectedRetransmissionTimeMs));
+      &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
 
   // Marker Bit should be set to 1 for first packet.
   EXPECT_TRUE(transport_.last_sent_packet().Marker());
 
   ASSERT_TRUE(rtp_sender_->SendOutgoingData(
       kEmptyFrame, kPayloadType, capture_time_ms + 4000, 0, nullptr, 0, nullptr,
-      nullptr, nullptr, kDefaultExpectedRetransmissionTimeMs));
+      &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
   // Marker Bit should be set to 0 for rest of the packets.
   EXPECT_FALSE(transport_.last_sent_packet().Marker());
 }
@@ -1610,9 +1616,10 @@
                                             0, 1500));
   uint8_t payload[] = {47, 11, 32, 93, 89};
 
+  RTPVideoHeader video_header;
   ASSERT_TRUE(rtp_sender_->SendOutgoingData(
       kVideoFrameKey, kPayloadType, 1234, 4321, payload, sizeof(payload),
-      nullptr, nullptr, nullptr, kDefaultExpectedRetransmissionTimeMs));
+      nullptr, &video_header, nullptr, kDefaultExpectedRetransmissionTimeMs));
 
   // Will send 2 full-size padding packets.
   rtp_sender_->TimeToSendPadding(1, PacedPacketInfo());
@@ -1810,8 +1817,9 @@
 
 TEST_P(RtpSenderVideoTest, RetransmissionTypesH264) {
   RTPVideoHeader header;
+  header.video_type_header.emplace<RTPVideoHeaderH264>().packetization_mode =
+      H264PacketizationMode::NonInterleaved;
   header.codec = kVideoCodecH264;
-  header.h264().packetization_mode = H264PacketizationMode::NonInterleaved;
 
   EXPECT_EQ(kDontRetransmit,
             rtp_sender_video_->GetStorageType(
@@ -1892,8 +1900,9 @@
   RTPVideoHeader header;
   header.codec = kVideoCodecVP9;
 
+  auto& vp9_header = header.video_type_header.emplace<RTPVideoHeaderVP9>();
   for (int tid = 1; tid <= kMaxTemporalStreams; ++tid) {
-    header.vp9().temporal_idx = tid;
+    vp9_header.temporal_idx = tid;
 
     EXPECT_EQ(kDontRetransmit, rtp_sender_video_->GetStorageType(
                                    header, kRetransmitOff,
diff --git a/modules/rtp_rtcp/source/rtp_sender_video.cc b/modules/rtp_rtcp/source/rtp_sender_video.cc
index a7f3df0..bf8150d 100644
--- a/modules/rtp_rtcp/source/rtp_sender_video.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_video.cc
@@ -280,6 +280,7 @@
                                int64_t expected_retransmission_time_ms) {
   if (payload_size == 0)
     return false;
+  RTC_CHECK(video_header);
 
   // Create header that will be reused in all packets.
   std::unique_ptr<RtpPacketToSend> rtp_header = rtp_sender_->AllocatePacket();
@@ -303,24 +304,22 @@
     // packet in each group of packets which make up another type of frame
     // (e.g. a P-Frame) only if the current value is different from the previous
     // value sent.
-    if (video_header) {
-      // Set rotation when key frame or when changed (to follow standard).
-      // Or when different from 0 (to follow current receiver implementation).
-      VideoRotation current_rotation = video_header->rotation;
-      if (frame_type == kVideoFrameKey || current_rotation != last_rotation_ ||
-          current_rotation != kVideoRotation_0)
-        last_packet->SetExtension<VideoOrientation>(current_rotation);
-      last_rotation_ = current_rotation;
-      // Report content type only for key frames.
-      if (frame_type == kVideoFrameKey &&
-          video_header->content_type != VideoContentType::UNSPECIFIED) {
-        last_packet->SetExtension<VideoContentTypeExtension>(
-            video_header->content_type);
-      }
-      if (video_header->video_timing.flags != VideoSendTiming::kInvalid) {
-        last_packet->SetExtension<VideoTimingExtension>(
-            video_header->video_timing);
-      }
+    // Set rotation when key frame or when changed (to follow standard).
+    // Or when different from 0 (to follow current receiver implementation).
+    VideoRotation current_rotation = video_header->rotation;
+    if (frame_type == kVideoFrameKey || current_rotation != last_rotation_ ||
+        current_rotation != kVideoRotation_0)
+      last_packet->SetExtension<VideoOrientation>(current_rotation);
+    last_rotation_ = current_rotation;
+    // Report content type only for key frames.
+    if (frame_type == kVideoFrameKey &&
+        video_header->content_type != VideoContentType::UNSPECIFIED) {
+      last_packet->SetExtension<VideoContentTypeExtension>(
+          video_header->content_type);
+    }
+    if (video_header->video_timing.flags != VideoSendTiming::kInvalid) {
+      last_packet->SetExtension<VideoTimingExtension>(
+          video_header->video_timing);
     }
 
     // FEC settings.
@@ -347,16 +346,17 @@
   size_t last_packet_reduction_len =
       last_packet->headers_size() - rtp_header->headers_size();
 
-  std::unique_ptr<RtpPacketizer> packetizer(RtpPacketizer::Create(
-      video_type, max_data_payload_length, last_packet_reduction_len,
-      video_header, frame_type));
+  RtpPacketizer::PayloadSizeLimits limits;
+  limits.max_payload_len = max_data_payload_length;
+  limits.last_packet_reduction_len = last_packet_reduction_len;
+  std::unique_ptr<RtpPacketizer> packetizer = RtpPacketizer::Create(
+      video_type, rtc::MakeArrayView(payload_data, payload_size), limits,
+      *video_header, frame_type, fragmentation);
 
-  const uint8_t temporal_id =
-      video_header ? GetTemporalId(*video_header) : kNoTemporalIdx;
+  const uint8_t temporal_id = GetTemporalId(*video_header);
   StorageType storage = GetStorageType(temporal_id, retransmission_settings,
                                        expected_retransmission_time_ms);
-  size_t num_packets =
-      packetizer->SetPayloadData(payload_data, payload_size, fragmentation);
+  size_t num_packets = packetizer->NumPackets();
 
   if (num_packets == 0)
     return false;
@@ -471,7 +471,8 @@
     case kVideoCodecVP8:
       return header.vp8().temporalIdx;
     case kVideoCodecVP9:
-      return header.vp9().temporal_idx;
+      return absl::get<RTPVideoHeaderVP9>(header.video_type_header)
+          .temporal_idx;
     default:
       return kNoTemporalIdx;
   }
diff --git a/modules/rtp_rtcp/source/rtp_sender_video.h b/modules/rtp_rtcp/source/rtp_sender_video.h
index 08724c7..ce7be16 100644
--- a/modules/rtp_rtcp/source/rtp_sender_video.h
+++ b/modules/rtp_rtcp/source/rtp_sender_video.h
@@ -27,7 +27,6 @@
 #include "rtc_base/rate_statistics.h"
 #include "rtc_base/sequenced_task_checker.h"
 #include "rtc_base/thread_annotations.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 class RtpPacketizer;
diff --git a/modules/rtp_rtcp/source/rtp_utility.h b/modules/rtp_rtcp/source/rtp_utility.h
index 51732df..762f964 100644
--- a/modules/rtp_rtcp/source/rtp_utility.h
+++ b/modules/rtp_rtcp/source/rtp_utility.h
@@ -19,7 +19,6 @@
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/rtp_rtcp/source/rtp_rtcp_config.h"
 #include "rtc_base/deprecation.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/rtp_rtcp/source/rtp_video_header.cc b/modules/rtp_rtcp/source/rtp_video_header.cc
index 020a52e..a3ee8ba 100644
--- a/modules/rtp_rtcp/source/rtp_video_header.cc
+++ b/modules/rtp_rtcp/source/rtp_video_header.cc
@@ -12,16 +12,13 @@
 
 namespace webrtc {
 
-RTPVideoHeader::RTPVideoHeader()
-    : width(),
-      height(),
-      rotation(),
-      playout_delay(),
-      content_type(),
-      video_timing(),
-      is_first_packet_in_frame(),
-      simulcastIdx(),
-      codec() {}
+RTPVideoHeader::RTPVideoHeader() : playout_delay(), video_timing() {}
 RTPVideoHeader::RTPVideoHeader(const RTPVideoHeader& other) = default;
+RTPVideoHeader::~RTPVideoHeader() = default;
+
+RTPVideoHeader::GenericDescriptorInfo::GenericDescriptorInfo() = default;
+RTPVideoHeader::GenericDescriptorInfo::GenericDescriptorInfo(
+    const GenericDescriptorInfo& other) = default;
+RTPVideoHeader::GenericDescriptorInfo::~GenericDescriptorInfo() = default;
 
 }  // namespace webrtc
diff --git a/modules/rtp_rtcp/source/rtp_video_header.h b/modules/rtp_rtcp/source/rtp_video_header.h
index 49e2d29..520f4d4 100644
--- a/modules/rtp_rtcp/source/rtp_video_header.h
+++ b/modules/rtp_rtcp/source/rtp_video_header.h
@@ -10,6 +10,7 @@
 #ifndef MODULES_RTP_RTCP_SOURCE_RTP_VIDEO_HEADER_H_
 #define MODULES_RTP_RTCP_SOURCE_RTP_VIDEO_HEADER_H_
 
+#include "absl/container/inlined_vector.h"
 #include "absl/types/variant.h"
 #include "api/video/video_content_type.h"
 #include "api/video/video_rotation.h"
@@ -24,9 +25,23 @@
     absl::variant<RTPVideoHeaderVP8, RTPVideoHeaderVP9, RTPVideoHeaderH264>;
 
 struct RTPVideoHeader {
+  struct GenericDescriptorInfo {
+    GenericDescriptorInfo();
+    GenericDescriptorInfo(const GenericDescriptorInfo& other);
+    ~GenericDescriptorInfo();
+
+    int64_t frame_id = 0;
+    int spatial_index = 0;
+    int temporal_index = 0;
+    absl::InlinedVector<int64_t, 5> dependencies;
+    absl::InlinedVector<int, 5> higher_spatial_layers;
+  };
+
   RTPVideoHeader();
   RTPVideoHeader(const RTPVideoHeader& other);
 
+  ~RTPVideoHeader();
+
   // TODO(philipel): Remove when downstream projects have been updated.
   RTPVideoHeaderVP8& vp8() {
     if (!absl::holds_alternative<RTPVideoHeaderVP8>(video_type_header))
@@ -41,44 +56,19 @@
 
     return absl::get<RTPVideoHeaderVP8>(video_type_header);
   }
-  // TODO(philipel): Remove when downstream projects have been updated.
-  RTPVideoHeaderVP9& vp9() {
-    if (!absl::holds_alternative<RTPVideoHeaderVP9>(video_type_header))
-      video_type_header.emplace<RTPVideoHeaderVP9>();
 
-    return absl::get<RTPVideoHeaderVP9>(video_type_header);
-  }
-  // TODO(philipel): Remove when downstream projects have been updated.
-  const RTPVideoHeaderVP9& vp9() const {
-    if (!absl::holds_alternative<RTPVideoHeaderVP9>(video_type_header))
-      video_type_header.emplace<RTPVideoHeaderVP9>();
+  absl::optional<GenericDescriptorInfo> generic;
 
-    return absl::get<RTPVideoHeaderVP9>(video_type_header);
-  }
-  // TODO(philipel): Remove when downstream projects have been updated.
-  RTPVideoHeaderH264& h264() {
-    if (!absl::holds_alternative<RTPVideoHeaderH264>(video_type_header))
-      video_type_header.emplace<RTPVideoHeaderH264>();
+  uint16_t width = 0;
+  uint16_t height = 0;
+  VideoRotation rotation = VideoRotation::kVideoRotation_0;
+  VideoContentType content_type = VideoContentType::UNSPECIFIED;
+  bool is_first_packet_in_frame = false;
+  uint8_t simulcastIdx = 0;
+  VideoCodecType codec = VideoCodecType::kVideoCodecGeneric;
 
-    return absl::get<RTPVideoHeaderH264>(video_type_header);
-  }
-  // TODO(philipel): Remove when downstream projects have been updated.
-  const RTPVideoHeaderH264& h264() const {
-    if (!absl::holds_alternative<RTPVideoHeaderH264>(video_type_header))
-      video_type_header.emplace<RTPVideoHeaderH264>();
-
-    return absl::get<RTPVideoHeaderH264>(video_type_header);
-  }
-
-  uint16_t width;
-  uint16_t height;
-  VideoRotation rotation;
   PlayoutDelay playout_delay;
-  VideoContentType content_type;
   VideoSendTiming video_timing;
-  bool is_first_packet_in_frame;
-  uint8_t simulcastIdx;
-  VideoCodecType codec;
   // TODO(philipel): remove mutable when downstream projects have been updated.
   mutable RTPVideoTypeHeader video_type_header;
 };
diff --git a/modules/rtp_rtcp/source/tmmbr_help.h b/modules/rtp_rtcp/source/tmmbr_help.h
index 46ce845..91aeaf4 100644
--- a/modules/rtp_rtcp/source/tmmbr_help.h
+++ b/modules/rtp_rtcp/source/tmmbr_help.h
@@ -13,7 +13,6 @@
 
 #include <vector>
 #include "modules/rtp_rtcp/source/rtcp_packet/tmmb_item.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/rtp_rtcp/source/ulpfec_receiver_impl.h b/modules/rtp_rtcp/source/ulpfec_receiver_impl.h
index 7dbc7dd..96367dc 100644
--- a/modules/rtp_rtcp/source/ulpfec_receiver_impl.h
+++ b/modules/rtp_rtcp/source/ulpfec_receiver_impl.h
@@ -18,7 +18,6 @@
 #include "modules/rtp_rtcp/include/ulpfec_receiver.h"
 #include "modules/rtp_rtcp/source/forward_error_correction.h"
 #include "rtc_base/criticalsection.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/modules/third_party/fft/BUILD.gn b/modules/third_party/fft/BUILD.gn
new file mode 100644
index 0000000..ad51341
--- /dev/null
+++ b/modules/third_party/fft/BUILD.gn
@@ -0,0 +1,16 @@
+# 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("fft") {
+  sources = [
+    "fft.c",
+    "fft.h",
+  ]
+}
diff --git a/modules/third_party/fft/LICENSE b/modules/third_party/fft/LICENSE
new file mode 100644
index 0000000..c0a7805
--- /dev/null
+++ b/modules/third_party/fft/LICENSE
@@ -0,0 +1,25 @@
+/*
+ * Copyright(c)1995,97 Mark Olesen <olesen@me.QueensU.CA>
+ *    Queen's Univ at Kingston (Canada)
+ *
+ * Permission to use, copy, modify, and distribute this software for
+ * any purpose without fee is hereby granted, provided that this
+ * entire notice is included in all copies of any software which is
+ * or includes a copy or modification of this software and in all
+ * copies of the supporting documentation for such software.
+ *
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTY.  IN PARTICULAR, NEITHER THE AUTHOR NOR QUEEN'S
+ * UNIVERSITY AT KINGSTON MAKES ANY REPRESENTATION OR WARRANTY OF ANY
+ * KIND CONCERNING THE MERCHANTABILITY OF THIS SOFTWARE OR ITS
+ * FITNESS FOR ANY PARTICULAR PURPOSE.
+ *
+ * All of which is to say that you can do what you like with this
+ * source code provided you don't try to sell it as your own and you
+ * include an unaltered copy of this message (including the
+ * copyright).
+ *
+ * It is also implicitly understood that bug fixes and improvements
+ * should make their way back to the general Internet community so
+ * that everyone benefits.
+ */
diff --git a/modules/third_party/fft/README.chromium b/modules/third_party/fft/README.chromium
new file mode 100644
index 0000000..94d20d4
--- /dev/null
+++ b/modules/third_party/fft/README.chromium
@@ -0,0 +1,12 @@
+Name: fft
+Short Name: fft
+URL:
+Version: 0
+Date: 2018-07-26
+License: Custom license
+License File: LICENSE
+Security Critical: yes
+
+Description:
+Multivariate complex Fourier transform, computed in place
+using mixed-radix Fast Fourier Transform algorithm.
diff --git a/modules/audio_coding/codecs/isac/main/source/fft.c b/modules/third_party/fft/fft.c
similarity index 99%
rename from modules/audio_coding/codecs/isac/main/source/fft.c
rename to modules/third_party/fft/fft.c
index a3cbd5e..7260462 100644
--- a/modules/audio_coding/codecs/isac/main/source/fft.c
+++ b/modules/third_party/fft/fft.c
@@ -127,7 +127,7 @@
 #include <stdlib.h>
 #include <math.h>
 
-#include "modules/audio_coding/codecs/isac/main/source/fft.h"
+#include "modules/third_party/fft/fft.h"
 
 /* double precision routine */
 static int
@@ -211,7 +211,7 @@
     {
       max_factors = (int)nSpan;
     }
-    if ((int)nSpan > max_perm) 
+    if ((int)nSpan > max_perm)
     {
       max_perm = (int)nSpan;
     }
@@ -415,7 +415,7 @@
   }
 
   /* test that mfactors is in range */
-  if (mfactor > NFACTOR)
+  if (mfactor > FFT_NFACTOR)
   {
     return -1;
   }
diff --git a/modules/audio_coding/codecs/isac/main/source/fft.h b/modules/third_party/fft/fft.h
similarity index 73%
rename from modules/audio_coding/codecs/isac/main/source/fft.h
rename to modules/third_party/fft/fft.h
index 34e5f94..f8f8b6f 100644
--- a/modules/audio_coding/codecs/isac/main/source/fft.h
+++ b/modules/third_party/fft/fft.h
@@ -2,7 +2,7 @@
  *  Copyright (c) 2011 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
+ *  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.
@@ -27,10 +27,23 @@
  * See the comments in the code for correct usage!
  */
 
-#ifndef MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_FFT_H_
-#define MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_FFT_H_
+#ifndef MODULES_THIRD_PARTY_FFT_FFT_H_
+#define MODULES_THIRD_PARTY_FFT_FFT_H_
 
-#include "modules/audio_coding/codecs/isac/main/source/structs.h"
+#define FFT_MAXFFTSIZE 2048
+#define FFT_NFACTOR 11
+
+typedef struct {
+  unsigned int SpaceAlloced;
+  unsigned int MaxPermAlloced;
+  double Tmp0[FFT_MAXFFTSIZE];
+  double Tmp1[FFT_MAXFFTSIZE];
+  double Tmp2[FFT_MAXFFTSIZE];
+  double Tmp3[FFT_MAXFFTSIZE];
+  int Perm[FFT_MAXFFTSIZE];
+  int factor[FFT_NFACTOR];
+
+} FFTstr;
 
 /* double precision routine */
 
@@ -42,4 +55,4 @@
                      double scaling,
                      FFTstr* fftstate);
 
-#endif /* MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_FFT_H_ */
+#endif /* MODULES_THIRD_PARTY_FFT_FFT_H_ */
diff --git a/modules/third_party/fft/module.mk b/modules/third_party/fft/module.mk
new file mode 100644
index 0000000..37c23f4
--- /dev/null
+++ b/modules/third_party/fft/module.mk
@@ -0,0 +1,5 @@
+# Copyright 2018 The Chromium OS Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+include common.mk
diff --git a/modules/third_party/g711/BUILD.gn b/modules/third_party/g711/BUILD.gn
new file mode 100644
index 0000000..ca1ccf3
--- /dev/null
+++ b/modules/third_party/g711/BUILD.gn
@@ -0,0 +1,17 @@
+# 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("g711_3p") {
+  poisonous = [ "audio_codecs" ]
+  sources = [
+    "g711.c",
+    "g711.h",
+  ]
+}
diff --git a/modules/third_party/g711/LICENSE b/modules/third_party/g711/LICENSE
new file mode 100644
index 0000000..3cdf910
--- /dev/null
+++ b/modules/third_party/g711/LICENSE
@@ -0,0 +1,14 @@
+/*
+ * SpanDSP - a series of DSP components for telephony
+ *
+ * g711.h - In line A-law and u-law conversion routines
+ *
+ * Written by Steve Underwood <steveu@coppice.org>
+ *
+ * Copyright (C) 2001 Steve Underwood
+ *
+ *  Despite my general liking of the GPL, I place this code in the
+ *  public domain for the benefit of all mankind - even the slimy
+ *  ones who might try to proprietize my work and use it to my
+ *  detriment.
+ */
diff --git a/modules/third_party/g711/README.chromium b/modules/third_party/g711/README.chromium
new file mode 100644
index 0000000..1baa263
--- /dev/null
+++ b/modules/third_party/g711/README.chromium
@@ -0,0 +1,11 @@
+Name: In line A-law and u-law conversion routines
+Short Name: g711
+URL:
+Version: 0
+Date: 2018-06-25
+License: Custom license
+License File: LICENSE
+Security Critical: yes
+
+Description:
+In line A-law and u-law conversion routines
diff --git a/modules/audio_coding/codecs/g711/g711.c b/modules/third_party/g711/g711.c
similarity index 98%
rename from modules/audio_coding/codecs/g711/g711.c
rename to modules/third_party/g711/g711.c
index 46a21f4..b7ae6bb 100644
--- a/modules/audio_coding/codecs/g711/g711.c
+++ b/modules/third_party/g711/g711.c
@@ -20,7 +20,7 @@
  * -Added option to run encoder bitexact with ITU-T reference implementation
  */
 
-#include "modules/audio_coding/codecs/g711/g711.h"
+#include "modules/third_party/g711/g711.h"
 
 /* Copied from the CCITT G.711 specification */
 static const uint8_t ulaw_to_alaw_table[256] = {
diff --git a/modules/audio_coding/codecs/g711/g711.h b/modules/third_party/g711/g711.h
similarity index 98%
rename from modules/audio_coding/codecs/g711/g711.h
rename to modules/third_party/g711/g711.h
index ac43377..4eef42c 100644
--- a/modules/audio_coding/codecs/g711/g711.h
+++ b/modules/third_party/g711/g711.h
@@ -43,8 +43,8 @@
 specification by other means.
 */
 
-#if !defined(_G711_H_)
-#define _G711_H_
+#ifndef MODULES_THIRD_PARTY_G711_G711_H_
+#define MODULES_THIRD_PARTY_G711_G711_H_
 
 #ifdef __cplusplus
 extern "C" {
@@ -347,4 +347,4 @@
 }
 #endif
 
-#endif
+#endif /* MODULES_THIRD_PARTY_G711_G711_H_ */
diff --git a/modules/third_party/g722/BUILD.gn b/modules/third_party/g722/BUILD.gn
new file mode 100644
index 0000000..a1bfe89
--- /dev/null
+++ b/modules/third_party/g722/BUILD.gn
@@ -0,0 +1,18 @@
+# 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("g722_3p") {
+  poisonous = [ "audio_codecs" ]
+  sources = [
+    "g722_decode.c",
+    "g722_enc_dec.h",
+    "g722_encode.c",
+  ]
+}
diff --git a/modules/third_party/g722/LICENSE b/modules/third_party/g722/LICENSE
new file mode 100644
index 0000000..ea6308f
--- /dev/null
+++ b/modules/third_party/g722/LICENSE
@@ -0,0 +1,20 @@
+/*
+ * SpanDSP - a series of DSP components for telephony
+ *
+ * g722_decode.c - The ITU G.722 codec, decode part.
+ *
+ * Written by Steve Underwood <steveu@coppice.org>
+ *
+ * Copyright (C) 2005 Steve Underwood
+ *
+ *  Despite my general liking of the GPL, I place my own contributions
+ *  to this code in the public domain for the benefit of all mankind -
+ *  even the slimy ones who might try to proprietize my work and use it
+ *  to my detriment.
+ *
+ * Based in part on a single channel G.722 codec which is:
+ *
+ * Copyright (c) CMU 1993
+ * Computer Science, Speech Group
+ * Chengxiang Lu and Alex Hauptmann
+ */
diff --git a/modules/third_party/g722/README.chromium b/modules/third_party/g722/README.chromium
new file mode 100644
index 0000000..c427ed8
--- /dev/null
+++ b/modules/third_party/g722/README.chromium
@@ -0,0 +1,11 @@
+Name: The ITU G.722 codec, encode and decode part.
+Short Name: g722
+URL:
+Version: 0
+Date: 2018-06-25
+License: Custom license
+License File: LICENSE
+Security Critical: yes
+
+Description:
+The ITU G.722 codec, encode and decode part.
diff --git a/modules/audio_coding/codecs/g722/g722_decode.c b/modules/third_party/g722/g722_decode.c
similarity index 99%
rename from modules/audio_coding/codecs/g722/g722_decode.c
rename to modules/third_party/g722/g722_decode.c
index d638f50..012aeb5 100644
--- a/modules/audio_coding/codecs/g722/g722_decode.c
+++ b/modules/third_party/g722/g722_decode.c
@@ -34,7 +34,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "modules/audio_coding/codecs/g722/g722_enc_dec.h"
+#include "modules/third_party/g722/g722_enc_dec.h"
 
 #if !defined(FALSE)
 #define FALSE 0
diff --git a/modules/audio_coding/codecs/g722/g722_enc_dec.h b/modules/third_party/g722/g722_enc_dec.h
similarity index 96%
rename from modules/audio_coding/codecs/g722/g722_enc_dec.h
rename to modules/third_party/g722/g722_enc_dec.h
index cc3aa98..898fa27 100644
--- a/modules/audio_coding/codecs/g722/g722_enc_dec.h
+++ b/modules/third_party/g722/g722_enc_dec.h
@@ -27,8 +27,8 @@
 
 /*! \file */
 
-#if !defined(_G722_ENC_DEC_H_)
-#define _G722_ENC_DEC_H_
+#ifndef MODULES_THIRD_PARTY_G722_G722_H_
+#define MODULES_THIRD_PARTY_G722_G722_H_
 
 #include <stdint.h>
 
@@ -150,4 +150,4 @@
 }
 #endif
 
-#endif
+#endif /* MODULES_THIRD_PARTY_G722_G722_H_ */
diff --git a/modules/audio_coding/codecs/g722/g722_encode.c b/modules/third_party/g722/g722_encode.c
similarity index 99%
rename from modules/audio_coding/codecs/g722/g722_encode.c
rename to modules/third_party/g722/g722_encode.c
index cd19252..10a5bcf 100644
--- a/modules/audio_coding/codecs/g722/g722_encode.c
+++ b/modules/third_party/g722/g722_encode.c
@@ -34,7 +34,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "modules/audio_coding/codecs/g722/g722_enc_dec.h"
+#include "modules/third_party/g722/g722_enc_dec.h"
 
 #if !defined(FALSE)
 #define FALSE 0
diff --git a/modules/third_party/module.mk b/modules/third_party/module.mk
new file mode 100644
index 0000000..37c23f4
--- /dev/null
+++ b/modules/third_party/module.mk
@@ -0,0 +1,5 @@
+# Copyright 2018 The Chromium OS Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+include common.mk
diff --git a/modules/third_party/portaudio/BUILD.gn b/modules/third_party/portaudio/BUILD.gn
new file mode 100644
index 0000000..1f701db
--- /dev/null
+++ b/modules/third_party/portaudio/BUILD.gn
@@ -0,0 +1,18 @@
+# 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("mac_portaudio") {
+  visibility = [ "../../audio_device:*" ]
+  sources = [
+    "pa_memorybarrier.h",
+    "pa_ringbuffer.c",
+    "pa_ringbuffer.h",
+  ]
+}
diff --git a/modules/third_party/portaudio/LICENSE b/modules/third_party/portaudio/LICENSE
new file mode 100644
index 0000000..6ccaca2
--- /dev/null
+++ b/modules/third_party/portaudio/LICENSE
@@ -0,0 +1,91 @@
+/*
+ * $Id: pa_memorybarrier.h 1240 2007-07-17 13:05:07Z bjornroche $
+ * Portable Audio I/O Library
+ * Memory barrier utilities
+ *
+ * Author: Bjorn Roche, XO Audio, LLC
+ *
+ * This program uses the PortAudio Portable Audio Library.
+ * For more information see: http://www.portaudio.com
+ * Copyright (c) 1999-2000 Ross Bencina and Phil Burk
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * The text above constitutes the entire PortAudio license; however,
+ * the PortAudio community also makes the following non-binding requests:
+ *
+ * Any person wishing to distribute modifications to the Software is
+ * requested to send the modifications to the original developer so that
+ * they can be incorporated into the canonical version. It is also
+ * requested that these non-binding requests be included along with the
+ * license above.
+ */
+
+/*
+ * $Id: pa_ringbuffer.c 1421 2009-11-18 16:09:05Z bjornroche $
+ * Portable Audio I/O Library
+ * Ring Buffer utility.
+ *
+ * Author: Phil Burk, http://www.softsynth.com
+ * modified for SMP safety on Mac OS X by Bjorn Roche
+ * modified for SMP safety on Linux by Leland Lucius
+ * also, allowed for const where possible
+ * modified for multiple-byte-sized data elements by Sven Fischer
+ *
+ * Note that this is safe only for a single-thread reader and a
+ * single-thread writer.
+ *
+ * This program uses the PortAudio Portable Audio Library.
+ * For more information see: http://www.portaudio.com
+ * Copyright (c) 1999-2000 Ross Bencina and Phil Burk
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * The text above constitutes the entire PortAudio license; however,
+ * the PortAudio community also makes the following non-binding requests:
+ *
+ * Any person wishing to distribute modifications to the Software is
+ * requested to send the modifications to the original developer so that
+ * they can be incorporated into the canonical version. It is also
+ * requested that these non-binding requests be included along with the
+ * license above.
+ */
+
diff --git a/modules/third_party/portaudio/README.chromium b/modules/third_party/portaudio/README.chromium
new file mode 100644
index 0000000..7a15b2e
--- /dev/null
+++ b/modules/third_party/portaudio/README.chromium
@@ -0,0 +1,12 @@
+Name: Portaudio library for mac
+Short Name: portaudio
+URL: https://app.assembla.com/spaces/portaudio/git/source/master/src/common
+Version: 0
+Date: 2018-02-01
+License: Custom license
+License File: LICENSE
+Security Critical: yes
+
+Description:
+Part of portaudio library to operate with memory barriers and ring buffer.
+
diff --git a/modules/third_party/portaudio/pa_memorybarrier.h b/modules/third_party/portaudio/pa_memorybarrier.h
new file mode 100644
index 0000000..c1040d1
--- /dev/null
+++ b/modules/third_party/portaudio/pa_memorybarrier.h
@@ -0,0 +1,132 @@
+/*
+ * $Id: pa_memorybarrier.h 1240 2007-07-17 13:05:07Z bjornroche $
+ * Portable Audio I/O Library
+ * Memory barrier utilities
+ *
+ * Author: Bjorn Roche, XO Audio, LLC
+ *
+ * This program uses the PortAudio Portable Audio Library.
+ * For more information see: http://www.portaudio.com
+ * Copyright (c) 1999-2000 Ross Bencina and Phil Burk
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * The text above constitutes the entire PortAudio license; however,
+ * the PortAudio community also makes the following non-binding requests:
+ *
+ * Any person wishing to distribute modifications to the Software is
+ * requested to send the modifications to the original developer so that
+ * they can be incorporated into the canonical version. It is also
+ * requested that these non-binding requests be included along with the
+ * license above.
+ */
+
+/**
+ @file pa_memorybarrier.h
+ @ingroup common_src
+*/
+
+/****************
+ * Some memory barrier primitives based on the system.
+ * right now only OS X, FreeBSD, and Linux are supported. In addition to
+ *providing memory barriers, these functions should ensure that data cached in
+ *registers is written out to cache where it can be snooped by other CPUs. (ie,
+ *the volatile keyword should not be required)
+ *
+ * the primitives that must be defined are:
+ *
+ * PaUtil_FullMemoryBarrier()
+ * PaUtil_ReadMemoryBarrier()
+ * PaUtil_WriteMemoryBarrier()
+ *
+ ****************/
+
+#ifndef MODULES_THIRD_PARTY_PORTAUDIO_PA_MEMORYBARRIER_H_
+#define MODULES_THIRD_PARTY_PORTAUDIO_PA_MEMORYBARRIER_H_
+
+#if defined(__APPLE__)
+#include <libkern/OSAtomic.h>
+/* Here are the memory barrier functions. Mac OS X only provides
+   full memory barriers, so the three types of barriers are the same,
+   however, these barriers are superior to compiler-based ones. */
+#define PaUtil_FullMemoryBarrier() OSMemoryBarrier()
+#define PaUtil_ReadMemoryBarrier() OSMemoryBarrier()
+#define PaUtil_WriteMemoryBarrier() OSMemoryBarrier()
+#elif defined(__GNUC__)
+/* GCC >= 4.1 has built-in intrinsics. We'll use those */
+#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)
+#define PaUtil_FullMemoryBarrier() __sync_synchronize()
+#define PaUtil_ReadMemoryBarrier() __sync_synchronize()
+#define PaUtil_WriteMemoryBarrier() __sync_synchronize()
+/* as a fallback, GCC understands volatile asm and "memory" to mean it
+ * should not reorder memory read/writes */
+/* Note that it is not clear that any compiler actually defines __PPC__,
+ * it can probably removed safely. */
+#elif defined(__ppc__) || defined(__powerpc__) || defined(__PPC__)
+#define PaUtil_FullMemoryBarrier() asm volatile("sync" ::: "memory")
+#define PaUtil_ReadMemoryBarrier() asm volatile("sync" ::: "memory")
+#define PaUtil_WriteMemoryBarrier() asm volatile("sync" ::: "memory")
+#elif defined(__i386__) || defined(__i486__) || defined(__i586__) || \
+    defined(__i686__) || defined(__x86_64__)
+#define PaUtil_FullMemoryBarrier() asm volatile("mfence" ::: "memory")
+#define PaUtil_ReadMemoryBarrier() asm volatile("lfence" ::: "memory")
+#define PaUtil_WriteMemoryBarrier() asm volatile("sfence" ::: "memory")
+#else
+#ifdef ALLOW_SMP_DANGERS
+#warning Memory barriers not defined on this system or system unknown
+#warning For SMP safety, you should fix this.
+#define PaUtil_FullMemoryBarrier()
+#define PaUtil_ReadMemoryBarrier()
+#define PaUtil_WriteMemoryBarrier()
+#else
+#         error Memory barriers are not defined on this system. You can still compile by defining ALLOW_SMP_DANGERS, but SMP safety will not be guaranteed.
+#endif
+#endif
+#elif (_MSC_VER >= 1400) && !defined(_WIN32_WCE)
+#include <intrin.h>
+#pragma intrinsic(_ReadWriteBarrier)
+#pragma intrinsic(_ReadBarrier)
+#pragma intrinsic(_WriteBarrier)
+#define PaUtil_FullMemoryBarrier() _ReadWriteBarrier()
+#define PaUtil_ReadMemoryBarrier() _ReadBarrier()
+#define PaUtil_WriteMemoryBarrier() _WriteBarrier()
+#elif defined(_WIN32_WCE)
+#define PaUtil_FullMemoryBarrier()
+#define PaUtil_ReadMemoryBarrier()
+#define PaUtil_WriteMemoryBarrier()
+#elif defined(_MSC_VER) || defined(__BORLANDC__)
+#define PaUtil_FullMemoryBarrier() _asm { lock add    [esp], 0}
+#define PaUtil_ReadMemoryBarrier() _asm { lock add    [esp], 0}
+#define PaUtil_WriteMemoryBarrier() _asm { lock add    [esp], 0}
+#else
+#ifdef ALLOW_SMP_DANGERS
+#warning Memory barriers not defined on this system or system unknown
+#warning For SMP safety, you should fix this.
+#define PaUtil_FullMemoryBarrier()
+#define PaUtil_ReadMemoryBarrier()
+#define PaUtil_WriteMemoryBarrier()
+#else
+#      error Memory barriers are not defined on this system. You can still compile by defining ALLOW_SMP_DANGERS, but SMP safety will not be guaranteed.
+#endif
+#endif
+
+#endif /* MODULES_THIRD_PARTY_PORTAUDIO_PA_MEMORYBARRIER_H_ */
diff --git a/modules/third_party/portaudio/pa_ringbuffer.c b/modules/third_party/portaudio/pa_ringbuffer.c
new file mode 100644
index 0000000..fc1053c
--- /dev/null
+++ b/modules/third_party/portaudio/pa_ringbuffer.c
@@ -0,0 +1,237 @@
+/*
+ * $Id: pa_ringbuffer.c 1421 2009-11-18 16:09:05Z bjornroche $
+ * Portable Audio I/O Library
+ * Ring Buffer utility.
+ *
+ * Author: Phil Burk, http://www.softsynth.com
+ * modified for SMP safety on Mac OS X by Bjorn Roche
+ * modified for SMP safety on Linux by Leland Lucius
+ * also, allowed for const where possible
+ * modified for multiple-byte-sized data elements by Sven Fischer 
+ *
+ * Note that this is safe only for a single-thread reader and a
+ * single-thread writer.
+ *
+ * This program uses the PortAudio Portable Audio Library.
+ * For more information see: http://www.portaudio.com
+ * Copyright (c) 1999-2000 Ross Bencina and Phil Burk
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * The text above constitutes the entire PortAudio license; however, 
+ * the PortAudio community also makes the following non-binding requests:
+ *
+ * Any person wishing to distribute modifications to the Software is
+ * requested to send the modifications to the original developer so that
+ * they can be incorporated into the canonical version. It is also 
+ * requested that these non-binding requests be included along with the 
+ * license above.
+ */
+
+/**
+ @file
+ @ingroup common_src
+*/
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "modules/third_party/portaudio/pa_memorybarrier.h"
+#include "modules/third_party/portaudio/pa_ringbuffer.h"
+
+/***************************************************************************
+ * Initialize FIFO.
+ * elementCount must be power of 2, returns -1 if not.
+ */
+PaRingBufferSize PaUtil_InitializeRingBuffer(PaUtilRingBuffer* rbuf,
+                                             PaRingBufferSize elementSizeBytes,
+                                             PaRingBufferSize elementCount,
+                                             void* dataPtr) {
+    if( ((elementCount-1) & elementCount) != 0) return -1; /* Not Power of two. */
+    rbuf->bufferSize = elementCount;
+    rbuf->buffer = (char *)dataPtr;
+    PaUtil_FlushRingBuffer( rbuf );
+    rbuf->bigMask = (elementCount*2)-1;
+    rbuf->smallMask = (elementCount)-1;
+    rbuf->elementSizeBytes = elementSizeBytes;
+    return 0;
+}
+
+/***************************************************************************
+** Return number of elements available for reading. */
+PaRingBufferSize PaUtil_GetRingBufferReadAvailable( PaUtilRingBuffer *rbuf )
+{
+    PaUtil_ReadMemoryBarrier();
+    return ( (rbuf->writeIndex - rbuf->readIndex) & rbuf->bigMask );
+}
+/***************************************************************************
+** Return number of elements available for writing. */
+PaRingBufferSize PaUtil_GetRingBufferWriteAvailable( PaUtilRingBuffer *rbuf )
+{
+    /* Since we are calling PaUtil_GetRingBufferReadAvailable, we don't need an aditional MB */
+    return ( rbuf->bufferSize - PaUtil_GetRingBufferReadAvailable(rbuf));
+}
+
+/***************************************************************************
+** Clear buffer. Should only be called when buffer is NOT being read. */
+void PaUtil_FlushRingBuffer( PaUtilRingBuffer *rbuf )
+{
+    rbuf->writeIndex = rbuf->readIndex = 0;
+}
+
+/***************************************************************************
+** Get address of region(s) to which we can write data.
+** If the region is contiguous, size2 will be zero.
+** If non-contiguous, size2 will be the size of second region.
+** Returns room available to be written or elementCount, whichever is smaller.
+*/
+PaRingBufferSize PaUtil_GetRingBufferWriteRegions(PaUtilRingBuffer* rbuf,
+                                                  PaRingBufferSize elementCount,
+                                                  void** dataPtr1,
+                                                  PaRingBufferSize* sizePtr1,
+                                                  void** dataPtr2,
+                                                  PaRingBufferSize* sizePtr2) {
+    PaRingBufferSize   index;
+    PaRingBufferSize   available = PaUtil_GetRingBufferWriteAvailable( rbuf );
+    if( elementCount > available ) elementCount = available;
+    /* Check to see if write is not contiguous. */
+    index = rbuf->writeIndex & rbuf->smallMask;
+    if( (index + elementCount) > rbuf->bufferSize )
+    {
+        /* Write data in two blocks that wrap the buffer. */
+        PaRingBufferSize   firstHalf = rbuf->bufferSize - index;
+        *dataPtr1 = &rbuf->buffer[index*rbuf->elementSizeBytes];
+        *sizePtr1 = firstHalf;
+        *dataPtr2 = &rbuf->buffer[0];
+        *sizePtr2 = elementCount - firstHalf;
+    }
+    else
+    {
+        *dataPtr1 = &rbuf->buffer[index*rbuf->elementSizeBytes];
+        *sizePtr1 = elementCount;
+        *dataPtr2 = NULL;
+        *sizePtr2 = 0;
+    }
+    return elementCount;
+}
+
+
+/***************************************************************************
+*/
+PaRingBufferSize PaUtil_AdvanceRingBufferWriteIndex(
+    PaUtilRingBuffer* rbuf,
+    PaRingBufferSize elementCount) {
+    /* we need to ensure that previous writes are seen before we update the write index */
+    PaUtil_WriteMemoryBarrier();
+    return rbuf->writeIndex = (rbuf->writeIndex + elementCount) & rbuf->bigMask;
+}
+
+/***************************************************************************
+** Get address of region(s) from which we can read data.
+** If the region is contiguous, size2 will be zero.
+** If non-contiguous, size2 will be the size of second region.
+** Returns room available to be written or elementCount, whichever is smaller.
+*/
+PaRingBufferSize PaUtil_GetRingBufferReadRegions(PaUtilRingBuffer* rbuf,
+                                                 PaRingBufferSize elementCount,
+                                                 void** dataPtr1,
+                                                 PaRingBufferSize* sizePtr1,
+                                                 void** dataPtr2,
+                                                 PaRingBufferSize* sizePtr2) {
+    PaRingBufferSize   index;
+    PaRingBufferSize   available = PaUtil_GetRingBufferReadAvailable( rbuf );
+    if( elementCount > available ) elementCount = available;
+    /* Check to see if read is not contiguous. */
+    index = rbuf->readIndex & rbuf->smallMask;
+    if( (index + elementCount) > rbuf->bufferSize )
+    {
+        /* Write data in two blocks that wrap the buffer. */
+        PaRingBufferSize firstHalf = rbuf->bufferSize - index;
+        *dataPtr1 = &rbuf->buffer[index*rbuf->elementSizeBytes];
+        *sizePtr1 = firstHalf;
+        *dataPtr2 = &rbuf->buffer[0];
+        *sizePtr2 = elementCount - firstHalf;
+    }
+    else
+    {
+        *dataPtr1 = &rbuf->buffer[index*rbuf->elementSizeBytes];
+        *sizePtr1 = elementCount;
+        *dataPtr2 = NULL;
+        *sizePtr2 = 0;
+    }
+    return elementCount;
+}
+/***************************************************************************
+*/
+PaRingBufferSize PaUtil_AdvanceRingBufferReadIndex(
+    PaUtilRingBuffer* rbuf,
+    PaRingBufferSize elementCount) {
+    /* we need to ensure that previous writes are always seen before updating the index. */
+    PaUtil_WriteMemoryBarrier();
+    return rbuf->readIndex = (rbuf->readIndex + elementCount) & rbuf->bigMask;
+}
+
+/***************************************************************************
+** Return elements written. */
+PaRingBufferSize PaUtil_WriteRingBuffer(PaUtilRingBuffer* rbuf,
+                                        const void* data,
+                                        PaRingBufferSize elementCount) {
+    PaRingBufferSize size1, size2, numWritten;
+    void *data1, *data2;
+    numWritten = PaUtil_GetRingBufferWriteRegions( rbuf, elementCount, &data1, &size1, &data2, &size2 );
+    if( size2 > 0 )
+    {
+
+        memcpy( data1, data, size1*rbuf->elementSizeBytes );
+        data = ((char *)data) + size1*rbuf->elementSizeBytes;
+        memcpy( data2, data, size2*rbuf->elementSizeBytes );
+    }
+    else
+    {
+        memcpy( data1, data, size1*rbuf->elementSizeBytes );
+    }
+    PaUtil_AdvanceRingBufferWriteIndex( rbuf, numWritten );
+    return numWritten;
+}
+
+/***************************************************************************
+** Return elements read. */
+PaRingBufferSize PaUtil_ReadRingBuffer(PaUtilRingBuffer* rbuf,
+                                       void* data,
+                                       PaRingBufferSize elementCount) {
+    PaRingBufferSize size1, size2, numRead;
+    void *data1, *data2;
+    numRead = PaUtil_GetRingBufferReadRegions( rbuf, elementCount, &data1, &size1, &data2, &size2 );
+    if( size2 > 0 )
+    {
+        memcpy( data, data1, size1*rbuf->elementSizeBytes );
+        data = ((char *)data) + size1*rbuf->elementSizeBytes;
+        memcpy( data, data2, size2*rbuf->elementSizeBytes );
+    }
+    else
+    {
+        memcpy( data, data1, size1*rbuf->elementSizeBytes );
+    }
+    PaUtil_AdvanceRingBufferReadIndex( rbuf, numRead );
+    return numRead;
+}
diff --git a/modules/third_party/portaudio/pa_ringbuffer.h b/modules/third_party/portaudio/pa_ringbuffer.h
new file mode 100644
index 0000000..3ad8216
--- /dev/null
+++ b/modules/third_party/portaudio/pa_ringbuffer.h
@@ -0,0 +1,251 @@
+#ifndef MODULES_THIRD_PARTY_PORTAUDIO_PA_RINGBUFFER_H_
+#define MODULES_THIRD_PARTY_PORTAUDIO_PA_RINGBUFFER_H_
+/*
+ * $Id: pa_ringbuffer.h 1421 2009-11-18 16:09:05Z bjornroche $
+ * Portable Audio I/O Library
+ * Ring Buffer utility.
+ *
+ * Author: Phil Burk, http://www.softsynth.com
+ * modified for SMP safety on OS X by Bjorn Roche.
+ * also allowed for const where possible.
+ * modified for multiple-byte-sized data elements by Sven Fischer
+ *
+ * Note that this is safe only for a single-thread reader
+ * and a single-thread writer.
+ *
+ * This program is distributed with the PortAudio Portable Audio Library.
+ * For more information see: http://www.portaudio.com
+ * Copyright (c) 1999-2000 Ross Bencina and Phil Burk
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * The text above constitutes the entire PortAudio license; however,
+ * the PortAudio community also makes the following non-binding requests:
+ *
+ * Any person wishing to distribute modifications to the Software is
+ * requested to send the modifications to the original developer so that
+ * they can be incorporated into the canonical version. It is also
+ * requested that these non-binding requests be included along with the
+ * license above.
+ */
+
+/** @file
+ @ingroup common_src
+ @brief Single-reader single-writer lock-free ring buffer
+
+ PaUtilRingBuffer is a ring buffer used to transport samples between
+ different execution contexts (threads, OS callbacks, interrupt handlers)
+ without requiring the use of any locks. This only works when there is
+ a single reader and a single writer (ie. one thread or callback writes
+ to the ring buffer, another thread or callback reads from it).
+
+ The PaUtilRingBuffer structure manages a ring buffer containing N
+ elements, where N must be a power of two. An element may be any size
+ (specified in bytes).
+
+ The memory area used to store the buffer elements must be allocated by
+ the client prior to calling PaUtil_InitializeRingBuffer() and must outlive
+ the use of the ring buffer.
+*/
+
+#if defined(__APPLE__)
+#include <sys/types.h>
+typedef int32_t PaRingBufferSize;
+#elif defined(__GNUC__)
+typedef long PaRingBufferSize;
+#elif (_MSC_VER >= 1400)
+typedef long PaRingBufferSize;
+#elif defined(_MSC_VER) || defined(__BORLANDC__)
+typedef long PaRingBufferSize;
+#else
+typedef long PaRingBufferSize;
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+typedef struct PaUtilRingBuffer {
+  PaRingBufferSize
+      bufferSize;                    /**< Number of elements in FIFO. Power of 2. Set by
+                                        PaUtil_InitRingBuffer. */
+  PaRingBufferSize writeIndex;       /**< Index of next writable element. Set by
+                                        PaUtil_AdvanceRingBufferWriteIndex. */
+  PaRingBufferSize readIndex;        /**< Index of next readable element. Set by
+                                        PaUtil_AdvanceRingBufferReadIndex. */
+  PaRingBufferSize bigMask;          /**< Used for wrapping indices with extra bit to
+                                        distinguish full/empty. */
+  PaRingBufferSize smallMask;        /**< Used for fitting indices to buffer. */
+  PaRingBufferSize elementSizeBytes; /**< Number of bytes per element. */
+  char* buffer; /**< Pointer to the buffer containing the actual data. */
+} PaUtilRingBuffer;
+
+/** Initialize Ring Buffer.
+
+ @param rbuf The ring buffer.
+
+ @param elementSizeBytes The size of a single data element in bytes.
+
+ @param elementCount The number of elements in the buffer (must be power of 2).
+
+ @param dataPtr A pointer to a previously allocated area where the data
+ will be maintained.  It must be elementCount*elementSizeBytes long.
+
+ @return -1 if elementCount is not a power of 2, otherwise 0.
+*/
+PaRingBufferSize PaUtil_InitializeRingBuffer(PaUtilRingBuffer* rbuf,
+                                             PaRingBufferSize elementSizeBytes,
+                                             PaRingBufferSize elementCount,
+                                             void* dataPtr);
+
+/** Clear buffer. Should only be called when buffer is NOT being read.
+
+ @param rbuf The ring buffer.
+*/
+void PaUtil_FlushRingBuffer(PaUtilRingBuffer* rbuf);
+
+/** Retrieve the number of elements available in the ring buffer for writing.
+
+ @param rbuf The ring buffer.
+
+ @return The number of elements available for writing.
+*/
+PaRingBufferSize PaUtil_GetRingBufferWriteAvailable(PaUtilRingBuffer* rbuf);
+
+/** Retrieve the number of elements available in the ring buffer for reading.
+
+ @param rbuf The ring buffer.
+
+ @return The number of elements available for reading.
+*/
+PaRingBufferSize PaUtil_GetRingBufferReadAvailable(PaUtilRingBuffer* rbuf);
+
+/** Write data to the ring buffer.
+
+ @param rbuf The ring buffer.
+
+ @param data The address of new data to write to the buffer.
+
+ @param elementCount The number of elements to be written.
+
+ @return The number of elements written.
+*/
+PaRingBufferSize PaUtil_WriteRingBuffer(PaUtilRingBuffer* rbuf,
+                                        const void* data,
+                                        PaRingBufferSize elementCount);
+
+/** Read data from the ring buffer.
+
+ @param rbuf The ring buffer.
+
+ @param data The address where the data should be stored.
+
+ @param elementCount The number of elements to be read.
+
+ @return The number of elements read.
+*/
+PaRingBufferSize PaUtil_ReadRingBuffer(PaUtilRingBuffer* rbuf,
+                                       void* data,
+                                       PaRingBufferSize elementCount);
+
+/** Get address of region(s) to which we can write data.
+
+ @param rbuf The ring buffer.
+
+ @param elementCount The number of elements desired.
+
+ @param dataPtr1 The address where the first (or only) region pointer will be
+ stored.
+
+ @param sizePtr1 The address where the first (or only) region length will be
+ stored.
+
+ @param dataPtr2 The address where the second region pointer will be stored if
+ the first region is too small to satisfy elementCount.
+
+ @param sizePtr2 The address where the second region length will be stored if
+ the first region is too small to satisfy elementCount.
+
+ @return The room available to be written or elementCount, whichever is smaller.
+*/
+PaRingBufferSize PaUtil_GetRingBufferWriteRegions(PaUtilRingBuffer* rbuf,
+                                                  PaRingBufferSize elementCount,
+                                                  void** dataPtr1,
+                                                  PaRingBufferSize* sizePtr1,
+                                                  void** dataPtr2,
+                                                  PaRingBufferSize* sizePtr2);
+
+/** Advance the write index to the next location to be written.
+
+ @param rbuf The ring buffer.
+
+ @param elementCount The number of elements to advance.
+
+ @return The new position.
+*/
+PaRingBufferSize PaUtil_AdvanceRingBufferWriteIndex(
+    PaUtilRingBuffer* rbuf,
+    PaRingBufferSize elementCount);
+
+/** Get address of region(s) from which we can write data.
+
+ @param rbuf The ring buffer.
+
+ @param elementCount The number of elements desired.
+
+ @param dataPtr1 The address where the first (or only) region pointer will be
+ stored.
+
+ @param sizePtr1 The address where the first (or only) region length will be
+ stored.
+
+ @param dataPtr2 The address where the second region pointer will be stored if
+ the first region is too small to satisfy elementCount.
+
+ @param sizePtr2 The address where the second region length will be stored if
+ the first region is too small to satisfy elementCount.
+
+ @return The number of elements available for reading.
+*/
+PaRingBufferSize PaUtil_GetRingBufferReadRegions(PaUtilRingBuffer* rbuf,
+                                                 PaRingBufferSize elementCount,
+                                                 void** dataPtr1,
+                                                 PaRingBufferSize* sizePtr1,
+                                                 void** dataPtr2,
+                                                 PaRingBufferSize* sizePtr2);
+
+/** Advance the read index to the next location to be read.
+
+ @param rbuf The ring buffer.
+
+ @param elementCount The number of elements to advance.
+
+ @return The new position.
+*/
+PaRingBufferSize PaUtil_AdvanceRingBufferReadIndex(
+    PaUtilRingBuffer* rbuf,
+    PaRingBufferSize elementCount);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* MODULES_THIRD_PARTY_PORTAUDIO_PA_RINGBUFFER_H_ */
diff --git a/rtc_base/BUILD.gn b/rtc_base/BUILD.gn
index 982d5c4..2ef79fa 100644
--- a/rtc_base/BUILD.gn
+++ b/rtc_base/BUILD.gn
@@ -15,18 +15,6 @@
   import("//build/config/android/rules.gni")
 }
 
-group("base") {
-  public_deps = [
-    ":rtc_base",
-    ":rtc_base_approved",
-    ":rtc_task_queue",
-    ":weak_ptr",
-  ]
-  if (is_android) {
-    public_deps += [ ":base_java" ]
-  }
-}
-
 config("rtc_base_chromium_config") {
   defines = [ "NO_MAIN_THREAD_WRAPPING" ]
 }
@@ -66,7 +54,8 @@
     "protobuf_utils.h",
   ]
   if (rtc_enable_protobuf) {
-    public_deps = [
+    public_configs = [ "//third_party/protobuf:protobuf_config" ]
+    deps = [
       "//third_party/protobuf:protobuf_lite",
     ]
   }
@@ -102,6 +91,8 @@
 }
 
 rtc_source_set("macromagic") {
+  # TODO(bugs.webrtc.org/9606): This should not be public.
+  visibility = [ "*" ]
   sources = [
     "arraysize.h",
     "constructormagic.h",
@@ -109,6 +100,9 @@
     "stringize_macros.h",
     "thread_annotations.h",
   ]
+  deps = [
+    "system:arch",
+  ]
 }
 
 rtc_source_set("platform_thread_types") {
@@ -119,16 +113,14 @@
 }
 
 rtc_source_set("ptr_util") {
+  visibility = [ "*" ]
   sources = [
-    "ptr_util.h",
     "scoped_ref_ptr.h",
   ]
-  deps = [
-    "//third_party/abseil-cpp/absl/memory",
-  ]
 }
 
 rtc_source_set("refcount") {
+  visibility = [ "*" ]
   sources = [
     "refcount.h",
     "refcountedobject.h",
@@ -150,7 +142,7 @@
     ":checks",
     ":macromagic",
     ":platform_thread_types",
-    "..:typedefs",
+    "system:unused",
   ]
 }
 
@@ -174,7 +166,6 @@
     ":rtc_event",
     ":thread_checker",
     ":timeutils",
-    "..:typedefs",
   ]
 }
 
@@ -200,6 +191,7 @@
 }
 
 rtc_source_set("logging") {
+  visibility = [ "*" ]
   deps = [
     ":criticalsection",
     ":macromagic",
@@ -239,7 +231,6 @@
     ":criticalsection",
     ":macromagic",
     ":platform_thread_types",
-    "..:typedefs",
   ]
 }
 
@@ -250,13 +241,14 @@
 }
 
 rtc_source_set("checks") {
+  # TODO(bugs.webrtc.org/9607): This should not be public.
+  visibility = [ "*" ]
   sources = [
     "checks.cc",
     "checks.h",
   ]
   deps = [
     ":safe_compare",
-    "..:typedefs",
     "system:inline",
   ]
 }
@@ -309,6 +301,7 @@
 }
 
 rtc_source_set("timeutils") {
+  visibility = [ "*" ]
   sources = [
     "timeutils.cc",
     "timeutils.h",
@@ -321,6 +314,8 @@
 
 rtc_source_set("stringutils") {
   sources = [
+    "string_to_number.cc",
+    "string_to_number.h",
     "stringencode.cc",
     "stringencode.h",
     "strings/string_builder.cc",
@@ -330,8 +325,10 @@
   ]
   deps = [
     ":checks",
+    ":macromagic",
     ":safe_minmax",
     "../api:array_view",
+    "//third_party/abseil-cpp/absl/types:optional",
   ]
 }
 
@@ -371,7 +368,6 @@
   data_deps = []
   deps = [
     ":atomicops",
-    ":base64",
     ":checks",
     ":criticalsection",
     ":logging",
@@ -388,8 +384,9 @@
     ":thread_checker",
     ":timeutils",
     ":type_traits",
-    "../:typedefs",
     "system:arch",
+    "system:unused",
+    "third_party/base64",
   ]
 
   sources = [
@@ -416,6 +413,7 @@
     "ignore_wundef.h",
     "location.cc",
     "location.h",
+    "message_buffer_reader.h",
     "numerics/histogram_percentile_counter.cc",
     "numerics/histogram_percentile_counter.h",
     "numerics/mod_ops.h",
@@ -435,8 +433,6 @@
     "rate_statistics.h",
     "ratetracker.cc",
     "ratetracker.h",
-    "string_to_number.cc",
-    "string_to_number.h",
     "swap_queue.h",
     "template_util.h",
     "timestampaligner.cc",
@@ -449,6 +445,7 @@
   deps += [
     "..:webrtc_common",
     "../api:array_view",
+    "//third_party/abseil-cpp/absl/memory:memory",
     "//third_party/abseil-cpp/absl/types:optional",
   ]
 
@@ -492,14 +489,6 @@
   }
 }
 
-rtc_source_set("base64") {
-  visibility = [ "*" ]
-  sources = [
-    "base64.cc",
-    "base64.h",
-  ]
-}
-
 rtc_source_set("rtc_task_queue") {
   visibility = [ "*" ]
   deps = []
@@ -555,6 +544,7 @@
       ":rtc_task_queue_api",
       ":safe_conversions",
       ":timeutils",
+      "system:unused",
     ]
     if (rtc_build_libevent) {
       deps += [ "//base/third_party/libevent" ]
@@ -723,11 +713,12 @@
   libs = []
   defines = []
   deps = [
-    ":base64",
     ":checks",
     ":stringutils",
     "..:webrtc_common",
     "../api:array_view",
+    "third_party/base64",
+    "third_party/sigslot",
     "//third_party/abseil-cpp/absl/memory",
     "//third_party/abseil-cpp/absl/types:optional",
   ]
@@ -815,8 +806,6 @@
     "rtccertificategenerator.h",
     "signalthread.cc",
     "signalthread.h",
-    "sigslot.cc",
-    "sigslot.h",
     "sigslotrepeater.h",
     "socket.cc",
     "socket.h",
@@ -885,10 +874,6 @@
     configs += [ ":external_ssl_library" ]
   }
 
-  if (rtc_builtin_ssl_root_certificates) {
-    defines += [ "WEBRTC_BUILT_IN_SSL_ROOT_CERTIFICATES" ]
-  }
-
   if (is_android) {
     sources += [
       "ifaddrs-android.cc",
@@ -976,10 +961,6 @@
   ]
 }
 
-config("rtc_base_tests_utils_exported_config") {
-  defines = [ "GTEST_RELATIVE_PATH" ]
-}
-
 rtc_source_set("rtc_base_tests_utils") {
   testonly = true
   sources = [
@@ -1023,7 +1004,6 @@
     "virtualsocketserver.cc",
     "virtualsocketserver.h",
   ]
-  public_configs = [ ":rtc_base_tests_utils_exported_config" ]
   deps = [
     ":checks",
     ":rtc_base",
@@ -1032,6 +1012,7 @@
     "../test:field_trial",
     "../test:test_support",
     "system:fallthrough",
+    "third_party/sigslot",
     "//third_party/abseil-cpp/absl/memory",
   ]
   public_deps = [
@@ -1055,12 +1036,23 @@
 }
 
 if (rtc_include_tests) {
+  rtc_source_set("sigslot_unittest") {
+    testonly = true
+    sources = [
+      "sigslot_unittest.cc",
+    ]
+    deps = [
+      ":rtc_base",
+      ":rtc_base_tests_utils",
+      "third_party/sigslot",
+    ]
+  }
+
   rtc_source_set("rtc_base_tests_main") {
     testonly = true
     sources = [
       "unittest_main.cc",
     ]
-    public_configs = [ ":rtc_base_tests_utils_exported_config" ]
     deps = [
       ":rtc_base",
       ":rtc_base_approved",
@@ -1160,7 +1152,6 @@
       sources += [ "win/windows_version_unittest.cc" ]
     }
     deps = [
-      ":base64",
       ":checks",
       ":rate_limiter",
       ":rtc_base",
@@ -1177,6 +1168,7 @@
       "../test:fileutils",
       "../test:test_support",
       "memory:unittests",
+      "third_party/base64",
       "//third_party/abseil-cpp/absl/memory",
     ]
   }
@@ -1268,12 +1260,10 @@
       "network_unittest.cc",
       "optionsfile_unittest.cc",
       "proxy_unittest.cc",
-      "ptr_util_unittest.cc",
       "rollingaccumulator_unittest.cc",
       "rtccertificate_unittest.cc",
       "rtccertificategenerator_unittest.cc",
       "signalthread_unittest.cc",
-      "sigslot_unittest.cc",
       "sigslottester_unittest.cc",
       "stream_unittest.cc",
       "testclient_unittest.cc",
@@ -1303,6 +1293,7 @@
       "../api:array_view",
       "../test:fileutils",
       "../test:test_support",
+      "third_party/sigslot",
       "//third_party/abseil-cpp/absl/memory",
       "//third_party/abseil-cpp/absl/types:optional",
     ]
@@ -1317,9 +1308,6 @@
     } else {
       configs += [ ":external_ssl_library" ]
     }
-    if (rtc_builtin_ssl_root_certificates) {
-      defines += [ "WEBRTC_BUILT_IN_SSL_ROOT_CERTIFICATES" ]
-    }
   }
 }
 
diff --git a/rtc_base/OWNERS b/rtc_base/OWNERS
index 6355075..69ce253 100644
--- a/rtc_base/OWNERS
+++ b/rtc_base/OWNERS
@@ -4,7 +4,9 @@
 mflodman@webrtc.org
 perkj@webrtc.org
 pthatcher@webrtc.org
+qingsi@webrtc.org
 sergeyu@chromium.org
+steveanton@webrtc.org
 tommi@webrtc.org
 
 # These are for the common case of adding or renaming files. If you're doing
diff --git a/rtc_base/asyncinvoker-inl.h b/rtc_base/asyncinvoker-inl.h
index 3ae2430..0dadc0f 100644
--- a/rtc_base/asyncinvoker-inl.h
+++ b/rtc_base/asyncinvoker-inl.h
@@ -17,7 +17,7 @@
 #include "rtc_base/messagehandler.h"
 #include "rtc_base/refcountedobject.h"
 #include "rtc_base/scoped_ref_ptr.h"
-#include "rtc_base/sigslot.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
 #include "rtc_base/thread.h"
 #include "rtc_base/thread_annotations.h"
 
diff --git a/rtc_base/asyncinvoker.h b/rtc_base/asyncinvoker.h
index 74e8689..474ec7c 100644
--- a/rtc_base/asyncinvoker.h
+++ b/rtc_base/asyncinvoker.h
@@ -21,7 +21,7 @@
 #include "rtc_base/event.h"
 #include "rtc_base/refcountedobject.h"
 #include "rtc_base/scoped_ref_ptr.h"
-#include "rtc_base/sigslot.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
 #include "rtc_base/thread.h"
 
 namespace rtc {
diff --git a/rtc_base/asyncpacketsocket.h b/rtc_base/asyncpacketsocket.h
index 820fe94..bb0b3bc 100644
--- a/rtc_base/asyncpacketsocket.h
+++ b/rtc_base/asyncpacketsocket.h
@@ -13,8 +13,8 @@
 
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/dscp.h"
-#include "rtc_base/sigslot.h"
 #include "rtc_base/socket.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
 #include "rtc_base/timeutils.h"
 
 namespace rtc {
diff --git a/rtc_base/asyncresolverinterface.h b/rtc_base/asyncresolverinterface.h
index 96b5ec1..5b2303f 100644
--- a/rtc_base/asyncresolverinterface.h
+++ b/rtc_base/asyncresolverinterface.h
@@ -11,8 +11,8 @@
 #ifndef RTC_BASE_ASYNCRESOLVERINTERFACE_H_
 #define RTC_BASE_ASYNCRESOLVERINTERFACE_H_
 
-#include "rtc_base/sigslot.h"
 #include "rtc_base/socketaddress.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
 
 namespace rtc {
 
diff --git a/rtc_base/asyncsocket.h b/rtc_base/asyncsocket.h
index bf9c282..0abdc27 100644
--- a/rtc_base/asyncsocket.h
+++ b/rtc_base/asyncsocket.h
@@ -11,8 +11,8 @@
 #ifndef RTC_BASE_ASYNCSOCKET_H_
 #define RTC_BASE_ASYNCSOCKET_H_
 
-#include "rtc_base/sigslot.h"
 #include "rtc_base/socket.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
 
 namespace rtc {
 
diff --git a/rtc_base/base64_unittest.cc b/rtc_base/base64_unittest.cc
index f73b396..4b857f1 100644
--- a/rtc_base/base64_unittest.cc
+++ b/rtc_base/base64_unittest.cc
@@ -8,7 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-#include "rtc_base/base64.h"
+#include "rtc_base/third_party/base64/base64.h"
 #include "rtc_base/gunit.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/stringutils.h"
diff --git a/rtc_base/buffer.h b/rtc_base/buffer.h
index 64974d3..22f8937 100644
--- a/rtc_base/buffer.h
+++ b/rtc_base/buffer.h
@@ -87,7 +87,7 @@
   BufferT(size_t size, size_t capacity)
       : size_(size),
         capacity_(std::max(size, capacity)),
-        data_(new T[capacity_]) {
+        data_(capacity_ > 0 ? new T[capacity_] : nullptr) {
     RTC_DCHECK(IsConsistent());
   }
 
diff --git a/rtc_base/bytebuffer.h b/rtc_base/bytebuffer.h
index 9036bcd..9e08f02 100644
--- a/rtc_base/bytebuffer.h
+++ b/rtc_base/bytebuffer.h
@@ -185,7 +185,7 @@
   // after this call.
   bool Consume(size_t size);
 
- private:
+ protected:
   void Construct(const char* bytes, size_t size);
 
   const char* bytes_;
@@ -193,6 +193,7 @@
   size_t start_;
   size_t end_;
 
+ private:
   RTC_DISALLOW_COPY_AND_ASSIGN(ByteBufferReader);
 };
 
diff --git a/rtc_base/copyonwritebuffer.cc b/rtc_base/copyonwritebuffer.cc
index 8874ea9..6c48d52 100644
--- a/rtc_base/copyonwritebuffer.cc
+++ b/rtc_base/copyonwritebuffer.cc
@@ -22,6 +22,9 @@
 CopyOnWriteBuffer::CopyOnWriteBuffer(CopyOnWriteBuffer&& buf)
     : buffer_(std::move(buf.buffer_)) {}
 
+CopyOnWriteBuffer::CopyOnWriteBuffer(const std::string& s)
+    : CopyOnWriteBuffer(s.data(), s.length()) {}
+
 CopyOnWriteBuffer::CopyOnWriteBuffer(size_t size)
     : buffer_(size > 0 ? new RefCountedObject<Buffer>(size) : nullptr) {
   RTC_DCHECK(IsConsistent());
diff --git a/rtc_base/copyonwritebuffer.h b/rtc_base/copyonwritebuffer.h
index 467baad..0514e2f 100644
--- a/rtc_base/copyonwritebuffer.h
+++ b/rtc_base/copyonwritebuffer.h
@@ -31,6 +31,9 @@
   // Move contents from an existing buffer.
   CopyOnWriteBuffer(CopyOnWriteBuffer&& buf);
 
+  // Construct a buffer from a string, convenient for unittests.
+  CopyOnWriteBuffer(const std::string& s);
+
   // Construct a buffer with the specified number of uninitialized bytes.
   explicit CopyOnWriteBuffer(size_t size);
   CopyOnWriteBuffer(size_t size, size_t capacity);
diff --git a/rtc_base/criticalsection.cc b/rtc_base/criticalsection.cc
index c786a40..d8a5b48 100644
--- a/rtc_base/criticalsection.cc
+++ b/rtc_base/criticalsection.cc
@@ -13,6 +13,7 @@
 #include "rtc_base/atomicops.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/platform_thread_types.h"
+#include "rtc_base/system/unused.h"
 
 // TODO(tommi): Split this file up to per-platform implementation files.
 
diff --git a/rtc_base/criticalsection.h b/rtc_base/criticalsection.h
index ce6fca1..f25e7d0 100644
--- a/rtc_base/criticalsection.h
+++ b/rtc_base/criticalsection.h
@@ -15,7 +15,6 @@
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/platform_thread_types.h"
 #include "rtc_base/thread_annotations.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 #if defined(WEBRTC_WIN)
 // clang-format off
diff --git a/rtc_base/experiments/BUILD.gn b/rtc_base/experiments/BUILD.gn
index a95e258..c0e1049 100644
--- a/rtc_base/experiments/BUILD.gn
+++ b/rtc_base/experiments/BUILD.gn
@@ -63,6 +63,17 @@
   ]
 }
 
+rtc_static_library("rtt_mult_experiment") {
+  sources = [
+    "rtt_mult_experiment.cc",
+    "rtt_mult_experiment.h",
+  ]
+  deps = [
+    "../:rtc_base_approved",
+    "../../system_wrappers:field_trial_api",
+  ]
+}
+
 if (rtc_include_tests) {
   rtc_source_set("experiments_unittests") {
     testonly = true
@@ -72,11 +83,13 @@
       "field_trial_parser_unittest.cc",
       "field_trial_units_unittest.cc",
       "quality_scaling_experiment_unittest.cc",
+      "rtt_mult_experiment_unittest.cc",
     ]
     deps = [
       ":congestion_controller_experiment",
       ":field_trial_parser",
       ":quality_scaling_experiment",
+      ":rtt_mult_experiment",
       "../:rtc_base_tests_main",
       "../:rtc_base_tests_utils",
       "../../system_wrappers:field_trial_api",
diff --git a/rtc_base/experiments/rtt_mult_experiment.cc b/rtc_base/experiments/rtt_mult_experiment.cc
new file mode 100644
index 0000000..f8f7f2a
--- /dev/null
+++ b/rtc_base/experiments/rtt_mult_experiment.cc
@@ -0,0 +1,49 @@
+/*
+ *  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/rtt_mult_experiment.h"
+
+#include <algorithm>
+#include <string>
+
+#include "rtc_base/logging.h"
+#include "system_wrappers/include/field_trial.h"
+
+namespace webrtc {
+
+namespace {
+const char kRttMultExperiment[] = "WebRTC-RttMult";
+const float max_rtt_mult_setting = 1.0;
+const float min_rtt_mult_setting = 0.0;
+}  // namespace
+
+bool RttMultExperiment::RttMultEnabled() {
+  return field_trial::IsEnabled(kRttMultExperiment);
+}
+
+float RttMultExperiment::GetRttMultValue() {
+  const std::string group =
+      webrtc::field_trial::FindFullName(kRttMultExperiment);
+  if (group.empty()) {
+    RTC_LOG(LS_WARNING) << "Could not find rtt_mult_experiment.";
+    return 0.0;
+  }
+
+  float rtt_mult_setting;
+  if (sscanf(group.c_str(), "Enabled-%f", &rtt_mult_setting) != 1) {
+    RTC_LOG(LS_WARNING) << "Invalid number of parameters provided.";
+    return 0.0;
+  }
+  // Bounds check rtt_mult_setting value.
+  rtt_mult_setting = std::min(rtt_mult_setting, max_rtt_mult_setting);
+  rtt_mult_setting = std::max(rtt_mult_setting, min_rtt_mult_setting);
+  return rtt_mult_setting;
+}
+
+}  // namespace webrtc
diff --git a/rtc_base/experiments/rtt_mult_experiment.h b/rtc_base/experiments/rtt_mult_experiment.h
new file mode 100644
index 0000000..d431af6
--- /dev/null
+++ b/rtc_base/experiments/rtt_mult_experiment.h
@@ -0,0 +1,26 @@
+/*
+ *  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_RTT_MULT_EXPERIMENT_H_
+#define RTC_BASE_EXPERIMENTS_RTT_MULT_EXPERIMENT_H_
+
+namespace webrtc {
+
+class RttMultExperiment {
+ public:
+  // Returns true if the experiment is enabled.
+  static bool RttMultEnabled();
+
+  // Returns rtt_mult value from field trial.
+  static float GetRttMultValue();
+};
+
+}  // namespace webrtc
+
+#endif  // RTC_BASE_EXPERIMENTS_RTT_MULT_EXPERIMENT_H_
diff --git a/rtc_base/experiments/rtt_mult_experiment_unittest.cc b/rtc_base/experiments/rtt_mult_experiment_unittest.cc
new file mode 100644
index 0000000..0cd86d1
--- /dev/null
+++ b/rtc_base/experiments/rtt_mult_experiment_unittest.cc
@@ -0,0 +1,51 @@
+/*
+ *  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/rtt_mult_experiment.h"
+#include "rtc_base/gunit.h"
+#include "test/field_trial.h"
+
+namespace webrtc {
+
+TEST(RttMultExperimentTest, RttMultDisabledByDefault) {
+  EXPECT_FALSE(RttMultExperiment::RttMultEnabled());
+}
+
+TEST(RttMultExperimentTest, RttMultEnabledByFieldTrial) {
+  webrtc::test::ScopedFieldTrials field_trials("WebRTC-RttMult/Enabled-0.25/");
+  EXPECT_TRUE(RttMultExperiment::RttMultEnabled());
+}
+
+TEST(RttMultExperimentTest, RttMultTestValue) {
+  webrtc::test::ScopedFieldTrials field_trials("WebRTC-RttMult/Enabled-0.25/");
+  EXPECT_EQ(0.25, RttMultExperiment::GetRttMultValue());
+}
+
+TEST(RttMultExperimentTest, RttMultTestMalformedEnabled) {
+  webrtc::test::ScopedFieldTrials field_trials("WebRTC-RttMult/Enable-0.25/");
+  EXPECT_FALSE(RttMultExperiment::RttMultEnabled());
+}
+
+TEST(RttMultExperimentTest, RttMultTestValueOutOfBoundsPositive) {
+  webrtc::test::ScopedFieldTrials field_trials("WebRTC-RttMult/Enabled-1.5/");
+  EXPECT_EQ(1.0, RttMultExperiment::GetRttMultValue());
+}
+
+TEST(RttMultExperimentTest, RttMultTestValueOutOfBoundsNegative) {
+  webrtc::test::ScopedFieldTrials field_trials("WebRTC-RttMult/Enabled--0.5/");
+  EXPECT_EQ(0.0, RttMultExperiment::GetRttMultValue());
+}
+
+TEST(RttMultExperimentTest, RttMultTestMalformedValue) {
+  webrtc::test::ScopedFieldTrials field_trials("WebRTC-RttMult/Enabled-0.2a5/");
+  EXPECT_NE(0.25, RttMultExperiment::GetRttMultValue());
+}
+
+}  // namespace webrtc
diff --git a/rtc_base/format_macros.h b/rtc_base/format_macros.h
index 48127e1..7252f2e 100644
--- a/rtc_base/format_macros.h
+++ b/rtc_base/format_macros.h
@@ -37,6 +37,8 @@
 
 #include <inttypes.h>
 
+#include "rtc_base/system/arch.h"
+
 #if !defined(PRIuS)
 #define PRIuS "zu"
 #endif
diff --git a/rtc_base/gunit.h b/rtc_base/gunit.h
index 145b466..910fbf3 100644
--- a/rtc_base/gunit.h
+++ b/rtc_base/gunit.h
@@ -14,11 +14,7 @@
 #include "rtc_base/fakeclock.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/thread.h"
-#if defined(GTEST_RELATIVE_PATH)
 #include "test/gtest.h"
-#else
-#include "testing/base/public/gunit.h"
-#endif
 
 // Wait until "ex" is true, or "timeout" expires.
 #define WAIT(ex, timeout)                                       \
diff --git a/rtc_base/gunit_prod.h b/rtc_base/gunit_prod.h
index bf4f9a1..dae2084 100644
--- a/rtc_base/gunit_prod.h
+++ b/rtc_base/gunit_prod.h
@@ -15,10 +15,8 @@
 // Android doesn't use gtest at all, so anything that relies on gtest should
 // check this define first.
 #define NO_GTEST
-#elif defined(GTEST_RELATIVE_PATH)
-#include "gtest/gtest_prod.h"
 #else
-#include "testing/base/gunit_prod.h"
+#include "gtest/gtest_prod.h"
 #endif
 
 #endif  // RTC_BASE_GUNIT_PROD_H_
diff --git a/rtc_base/helpers.cc b/rtc_base/helpers.cc
index 0260665..b9372b9 100644
--- a/rtc_base/helpers.cc
+++ b/rtc_base/helpers.cc
@@ -15,9 +15,9 @@
 
 #include <openssl/rand.h>
 
-#include "rtc_base/base64.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
+#include "rtc_base/third_party/base64/base64.h"
 #include "rtc_base/timeutils.h"
 
 // Protect against max macro inclusion.
diff --git a/rtc_base/httpbase.cc b/rtc_base/httpbase.cc
index 3e2f376..8f2869d 100644
--- a/rtc_base/httpbase.cc
+++ b/rtc_base/httpbase.cc
@@ -224,149 +224,11 @@
 }
 
 //////////////////////////////////////////////////////////////////////
-// HttpBase::DocumentStream
-//////////////////////////////////////////////////////////////////////
-
-class BlockingMemoryStream : public ExternalMemoryStream {
- public:
-  BlockingMemoryStream(char* buffer, size_t size)
-      : ExternalMemoryStream(buffer, size) {}
-
-  StreamResult DoReserve(size_t size, int* error) override {
-    return (buffer_length_ >= size) ? SR_SUCCESS : SR_BLOCK;
-  }
-};
-
-class HttpBase::DocumentStream : public StreamInterface {
- public:
-  DocumentStream(HttpBase* base) : base_(base), error_(HE_DEFAULT) {}
-
-  StreamState GetState() const override {
-    if (nullptr == base_)
-      return SS_CLOSED;
-    if (HM_RECV == base_->mode_)
-      return SS_OPEN;
-    return SS_OPENING;
-  }
-
-  StreamResult Read(void* buffer,
-                    size_t buffer_len,
-                    size_t* read,
-                    int* error) override {
-    if (!base_) {
-      if (error)
-        *error = error_;
-      return (HE_NONE == error_) ? SR_EOS : SR_ERROR;
-    }
-
-    if (HM_RECV != base_->mode_) {
-      return SR_BLOCK;
-    }
-
-    // DoReceiveLoop writes http document data to the StreamInterface* document
-    // member of HttpData.  In this case, we want this data to be written
-    // directly to our buffer.  To accomplish this, we wrap our buffer with a
-    // StreamInterface, and replace the existing document with our wrapper.
-    // When the method returns, we restore the old document.  Ideally, we would
-    // pass our StreamInterface* to DoReceiveLoop, but due to the callbacks
-    // of HttpParser, we would still need to store the pointer temporarily.
-    std::unique_ptr<StreamInterface> stream(
-        new BlockingMemoryStream(reinterpret_cast<char*>(buffer), buffer_len));
-
-    // Replace the existing document with our wrapped buffer.
-    base_->data_->document.swap(stream);
-
-    // Pump the I/O loop.  DoReceiveLoop is guaranteed not to attempt to
-    // complete the I/O process, which means that our wrapper is not in danger
-    // of being deleted.  To ensure this, DoReceiveLoop returns true when it
-    // wants complete to be called.  We make sure to uninstall our wrapper
-    // before calling complete().
-    HttpError http_error;
-    bool complete = base_->DoReceiveLoop(&http_error);
-
-    // Reinstall the original output document.
-    base_->data_->document.swap(stream);
-
-    // If we reach the end of the receive stream, we disconnect our stream
-    // adapter from the HttpBase, and further calls to read will either return
-    // EOS or ERROR, appropriately.  Finally, we call complete().
-    StreamResult result = SR_BLOCK;
-    if (complete) {
-      HttpBase* base = Disconnect(http_error);
-      if (error)
-        *error = error_;
-      result = (HE_NONE == error_) ? SR_EOS : SR_ERROR;
-      base->complete(http_error);
-    }
-
-    // Even if we are complete, if some data was read we must return SUCCESS.
-    // Future Reads will return EOS or ERROR based on the error_ variable.
-    size_t position;
-    stream->GetPosition(&position);
-    if (position > 0) {
-      if (read)
-        *read = position;
-      result = SR_SUCCESS;
-    }
-    return result;
-  }
-
-  StreamResult Write(const void* data,
-                     size_t data_len,
-                     size_t* written,
-                     int* error) override {
-    if (error)
-      *error = -1;
-    return SR_ERROR;
-  }
-
-  void Close() override {
-    if (base_) {
-      HttpBase* base = Disconnect(HE_NONE);
-      if (HM_RECV == base->mode_ && base->http_stream_) {
-        // Read I/O could have been stalled on the user of this DocumentStream,
-        // so restart the I/O process now that we've removed ourselves.
-        base->http_stream_->PostEvent(SE_READ, 0);
-      }
-    }
-  }
-
-  bool GetAvailable(size_t* size) const override {
-    if (!base_ || HM_RECV != base_->mode_)
-      return false;
-    size_t data_size = base_->GetDataRemaining();
-    if (SIZE_UNKNOWN == data_size)
-      return false;
-    if (size)
-      *size = data_size;
-    return true;
-  }
-
-  HttpBase* Disconnect(HttpError error) {
-    RTC_DCHECK(nullptr != base_);
-    RTC_DCHECK(nullptr != base_->doc_stream_);
-    HttpBase* base = base_;
-    base_->doc_stream_ = nullptr;
-    base_ = nullptr;
-    error_ = error;
-    return base;
-  }
-
- private:
-  HttpBase* base_;
-  HttpError error_;
-};
-
-//////////////////////////////////////////////////////////////////////
 // HttpBase
 //////////////////////////////////////////////////////////////////////
 
 HttpBase::HttpBase()
-    : mode_(HM_NONE),
-      data_(nullptr),
-      notify_(nullptr),
-      http_stream_(nullptr),
-      doc_stream_(nullptr) {}
+    : mode_(HM_NONE), data_(nullptr), notify_(nullptr), http_stream_(nullptr) {}
 
 HttpBase::~HttpBase() {
   RTC_DCHECK(HM_NONE == mode_);
@@ -451,11 +313,7 @@
   ignore_data_ = chunk_data_ = false;
 
   reset();
-  if (doc_stream_) {
-    doc_stream_->SignalEvent(doc_stream_, SE_OPEN | SE_READ, 0);
-  } else {
-    read_and_process_data();
-  }
+  read_and_process_data();
 }
 
 void HttpBase::abort(HttpError err) {
@@ -467,13 +325,6 @@
   }
 }
 
-StreamInterface* HttpBase::GetDocumentStream() {
-  if (doc_stream_)
-    return nullptr;
-  doc_stream_ = new DocumentStream(this);
-  return doc_stream_;
-}
-
 HttpError HttpBase::HandleStreamClose(int error) {
   if (http_stream_ != nullptr) {
     http_stream_->Close();
@@ -730,13 +581,6 @@
     data_->document->SignalEvent.disconnect(this);
   }
   data_ = nullptr;
-  if ((HM_RECV == mode) && doc_stream_) {
-    RTC_DCHECK(HE_NONE !=
-               err);  // We should have Disconnected doc_stream_ already.
-    DocumentStream* ds = doc_stream_;
-    ds->Disconnect(err);
-    ds->SignalEvent(ds, SE_CLOSE, err);
-  }
   if (notify_) {
     notify_->onHttpComplete(mode, err);
   }
@@ -761,11 +605,7 @@
   }
 
   if ((events & SE_READ) && (mode_ == HM_RECV)) {
-    if (doc_stream_) {
-      doc_stream_->SignalEvent(doc_stream_, SE_READ, 0);
-    } else {
-      read_and_process_data();
-    }
+    read_and_process_data();
     return;
   }
 
@@ -825,7 +665,6 @@
 HttpParser::ProcessResult HttpBase::ProcessHeaderComplete(bool chunked,
                                                           size_t& data_size,
                                                           HttpError* error) {
-  StreamInterface* old_docstream = doc_stream_;
   if (notify_) {
     *error = notify_->onHttpHeaderComplete(chunked, data_size);
     // The request must not be aborted as a result of this callback.
@@ -837,10 +676,6 @@
   if (HE_NONE != *error) {
     return PR_COMPLETE;
   }
-  if (old_docstream != doc_stream_) {
-    // Break out of Process loop, since our I/O model just changed.
-    return PR_BLOCK;
-  }
   return PR_CONTINUE;
 }
 
diff --git a/rtc_base/httpbase.h b/rtc_base/httpbase.h
index 25a11ab..b0e2425 100644
--- a/rtc_base/httpbase.h
+++ b/rtc_base/httpbase.h
@@ -119,11 +119,6 @@
   void set_ignore_data(bool ignore) { ignore_data_ = ignore; }
   bool ignore_data() const { return ignore_data_; }
 
-  // Obtaining this stream puts HttpBase into stream mode until the stream
-  // is closed.  HttpBase can only expose one open stream interface at a time.
-  // Further calls will return null.
-  StreamInterface* GetDocumentStream();
-
  protected:
   // Do cleanup when the http stream closes (error may be 0 for a clean
   // shutdown), and return the error code to signal.
@@ -180,7 +175,6 @@
   HttpData* data_;
   IHttpNotify* notify_;
   StreamInterface* http_stream_;
-  DocumentStream* doc_stream_;
   char buffer_[kBufferSize];
   size_t len_;
 
diff --git a/rtc_base/httpbase_unittest.cc b/rtc_base/httpbase_unittest.cc
index 260fb9b..35321da 100644
--- a/rtc_base/httpbase_unittest.cc
+++ b/rtc_base/httpbase_unittest.cc
@@ -34,16 +34,6 @@
     "Proxy-Authorization: 42\r\n"
     "\r\n";
 
-const char* const kHttpResponsePrefix =
-    "HTTP/1.1 200\r\n"
-    "Connection: Keep-Alive\r\n"
-    "Content-Type: text/plain\r\n"
-    "Proxy-Authorization: 42\r\n"
-    "Transfer-Encoding: chunked\r\n"
-    "\r\n"
-    "8\r\n"
-    "Goodbye!\r\n";
-
 class HttpBaseTest : public testing::Test, public IHttpNotify {
  public:
   enum EventType { E_HEADER_COMPLETE, E_COMPLETE, E_CLOSED };
@@ -54,7 +44,7 @@
     HttpMode mode;
     HttpError err;
   };
-  HttpBaseTest() : mem(nullptr), obtain_stream(false), http_stream(nullptr) {}
+  HttpBaseTest() : mem(nullptr), http_stream(nullptr) {}
 
   void TearDown() override {
     delete http_stream;
@@ -66,9 +56,6 @@
     RTC_LOG_F(LS_VERBOSE) << "chunked: " << chunked << " size: " << data_size;
     Event e = {E_HEADER_COMPLETE, chunked, data_size, HM_NONE, HE_NONE};
     events.push_back(e);
-    if (obtain_stream) {
-      ObtainDocumentStream();
-    }
     return HE_NONE;
   }
   void onHttpComplete(HttpMode mode, HttpError err) override {
@@ -88,7 +75,6 @@
   void VerifyDocumentContents(const char* expected_data,
                               size_t expected_length = SIZE_UNKNOWN);
 
-  void ObtainDocumentStream();
   void VerifyDocumentStreamIsOpening();
   void VerifyDocumentStreamOpenEvent();
   void ReadDocumentStreamData(const char* expected_data);
@@ -108,8 +94,7 @@
   webrtc::testing::StreamSource src;
   std::vector<Event> events;
 
-  // Document stream, and stream events
-  bool obtain_stream;
+  // Stream events
   StreamInterface* http_stream;
   webrtc::testing::StreamSink sink;
 };
@@ -184,15 +169,6 @@
   RTC_LOG_F(LS_VERBOSE) << "Exit";
 }
 
-void HttpBaseTest::ObtainDocumentStream() {
-  RTC_LOG_F(LS_VERBOSE) << "Enter";
-  EXPECT_FALSE(http_stream);
-  http_stream = base.GetDocumentStream();
-  ASSERT_TRUE(nullptr != http_stream);
-  sink.Monitor(http_stream);
-  RTC_LOG_F(LS_VERBOSE) << "Exit";
-}
-
 void HttpBaseTest::VerifyDocumentStreamIsOpening() {
   RTC_LOG_F(LS_VERBOSE) << "Enter";
   ASSERT_TRUE(nullptr != http_stream);
@@ -379,145 +355,4 @@
   VerifyDocumentContents("Goodbye!");
 }
 
-TEST_F(HttpBaseTest, SupportsReceiveViaStreamPull) {
-  // Switch to pull mode
-  ObtainDocumentStream();
-  VerifyDocumentStreamIsOpening();
-
-  // Queue response document
-  SetupSource(kHttpResponse);
-  VerifyDocumentStreamIsOpening();
-
-  // Begin receive
-  base.recv(&data);
-
-  // Pull document data
-  VerifyDocumentStreamOpenEvent();
-  ReadDocumentStreamData("Goodbye!");
-  VerifyDocumentStreamIsEOS();
-
-  // Document completed successfully
-  VerifyHeaderComplete(2, false);
-  VerifyTransferComplete(HM_RECV, HE_NONE);
-  VerifyDocumentContents("");
-}
-
-TEST_F(HttpBaseTest, DISABLED_AllowsCloseStreamBeforeDocumentIsComplete) {
-  // TODO: Remove extra logging once test failure is understood
-  LoggingSeverity old_sev = rtc::LogMessage::GetLogToDebug();
-  rtc::LogMessage::LogToDebug(LS_VERBOSE);
-
-  // Switch to pull mode
-  ObtainDocumentStream();
-  VerifyDocumentStreamIsOpening();
-
-  // Queue response document
-  SetupSource(kHttpResponse);
-  VerifyDocumentStreamIsOpening();
-
-  // Begin receive
-  base.recv(&data);
-
-  // Pull some of the data
-  VerifyDocumentStreamOpenEvent();
-  ReadDocumentStreamData("Goodb");
-
-  // We've seen the header by now
-  VerifyHeaderComplete(1, false);
-
-  // Close the pull stream, this will transition back to push I/O.
-  http_stream->Close();
-  Thread::Current()->ProcessMessages(0);
-
-  // Remainder of document completed successfully
-  VerifyTransferComplete(HM_RECV, HE_NONE);
-  VerifyDocumentContents("ye!");
-
-  rtc::LogMessage::LogToDebug(old_sev);
-}
-
-TEST_F(HttpBaseTest, AllowsGetDocumentStreamInResponseToHttpHeader) {
-  // Queue response document
-  SetupSource(kHttpResponse);
-
-  // Switch to pull mode in response to header arrival
-  obtain_stream = true;
-
-  // Begin receive
-  base.recv(&data);
-
-  // We've already seen the header, but not data has arrived
-  VerifyHeaderComplete(1, false);
-  VerifyDocumentContents("");
-
-  // Pull the document data
-  ReadDocumentStreamData("Goodbye!");
-  VerifyDocumentStreamIsEOS();
-
-  // Document completed successfully
-  VerifyTransferComplete(HM_RECV, HE_NONE);
-  VerifyDocumentContents("");
-}
-
-TEST_F(HttpBaseTest, AllowsGetDocumentStreamWithEmptyDocumentBody) {
-  // Queue empty response document
-  SetupSource(kHttpEmptyResponse);
-
-  // Switch to pull mode in response to header arrival
-  obtain_stream = true;
-
-  // Begin receive
-  base.recv(&data);
-
-  // We've already seen the header, but not data has arrived
-  VerifyHeaderComplete(1, true);
-  VerifyDocumentContents("");
-
-  // The document is still open, until we attempt to read
-  ASSERT_TRUE(nullptr != http_stream);
-  EXPECT_EQ(SS_OPEN, http_stream->GetState());
-
-  // Attempt to read data, and discover EOS
-  VerifyDocumentStreamIsEOS();
-
-  // Document completed successfully
-  VerifyTransferComplete(HM_RECV, HE_NONE);
-  VerifyDocumentContents("");
-}
-
-TEST_F(HttpBaseTest, SignalsDocumentStreamCloseOnUnexpectedClose) {
-  // Switch to pull mode
-  ObtainDocumentStream();
-  VerifyDocumentStreamIsOpening();
-
-  // Queue response document
-  SetupSource(kHttpResponsePrefix);
-  VerifyDocumentStreamIsOpening();
-
-  // Begin receive
-  base.recv(&data);
-
-  // Pull document data
-  VerifyDocumentStreamOpenEvent();
-  ReadDocumentStreamData("Goodbye!");
-
-  // Simulate unexpected close
-  src.SetState(SS_CLOSED);
-
-  // Observe error event on document stream
-  EXPECT_EQ(webrtc::testing::SSE_ERROR, sink.Events(http_stream));
-
-  // Future reads give an error
-  int error = 0;
-  char buffer[5] = {0};
-  EXPECT_EQ(SR_ERROR,
-            http_stream->Read(buffer, sizeof(buffer), nullptr, &error));
-  EXPECT_EQ(HE_DISCONNECTED, error);
-
-  // Document completed with error
-  VerifyHeaderComplete(2, false);
-  VerifyTransferComplete(HM_RECV, HE_DISCONNECTED);
-  VerifyDocumentContents("");
-}
-
 }  // namespace rtc
diff --git a/rtc_base/httpcommon.cc b/rtc_base/httpcommon.cc
index 5ac1e42..4ecb393 100644
--- a/rtc_base/httpcommon.cc
+++ b/rtc_base/httpcommon.cc
@@ -21,13 +21,13 @@
 #include <algorithm>
 
 #include "rtc_base/arraysize.h"
-#include "rtc_base/base64.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/cryptstring.h"
 #include "rtc_base/httpcommon-inl.h"
 #include "rtc_base/httpcommon.h"
 #include "rtc_base/messagedigest.h"
 #include "rtc_base/socketaddress.h"
+#include "rtc_base/third_party/base64/base64.h"
 #include "rtc_base/zero_memory.h"
 
 namespace rtc {
@@ -169,10 +169,6 @@
 static const char* kHttpVersions[HVER_LAST + 1] = {"1.0", "1.1", "Unknown"};
 ENUM(HttpVersion, kHttpVersions);
 
-static const char* kHttpVerbs[HV_LAST + 1] = {"GET",    "POST",    "PUT",
-                                              "DELETE", "CONNECT", "HEAD"};
-ENUM(HttpVerb, kHttpVerbs);
-
 static const char* kHttpHeaders[HH_LAST + 1] = {
     "Age",
     "Cache-Control",
@@ -213,14 +209,6 @@
   return Enum<HttpVersion>::Parse(version, str);
 }
 
-const char* ToString(HttpVerb verb) {
-  return Enum<HttpVerb>::Name(verb);
-}
-
-bool FromString(HttpVerb& verb, const std::string& str) {
-  return Enum<HttpVerb>::Parse(verb, str);
-}
-
 const char* ToString(HttpHeader header) {
   return Enum<HttpHeader>::Name(header);
 }
@@ -229,25 +217,6 @@
   return Enum<HttpHeader>::Parse(header, str);
 }
 
-bool HttpCodeHasBody(uint32_t code) {
-  return !HttpCodeIsInformational(code) && (code != HC_NO_CONTENT) &&
-         (code != HC_NOT_MODIFIED);
-}
-
-bool HttpCodeIsCacheable(uint32_t code) {
-  switch (code) {
-    case HC_OK:
-    case HC_NON_AUTHORITATIVE:
-    case HC_PARTIAL_CONTENT:
-    case HC_MULTIPLE_CHOICES:
-    case HC_MOVED_PERMANENTLY:
-    case HC_GONE:
-      return true;
-    default:
-      return false;
-  }
-}
-
 bool HttpHeaderIsEndToEnd(HttpHeader header) {
   switch (header) {
     case HH_CONNECTION:
@@ -494,10 +463,6 @@
   }
 }
 
-void HttpData::copy(const HttpData& src) {
-  headers_ = src.headers_;
-}
-
 void HttpData::changeHeader(const std::string& name,
                             const std::string& value,
                             HeaderCombine combine) {
@@ -572,21 +537,14 @@
 //
 
 void HttpRequestData::clear(bool release_document) {
-  verb = HV_GET;
   path.clear();
   HttpData::clear(release_document);
 }
 
-void HttpRequestData::copy(const HttpRequestData& src) {
-  verb = src.verb;
-  path = src.path;
-  HttpData::copy(src);
-}
-
 size_t HttpRequestData::formatLeader(char* buffer, size_t size) const {
   RTC_DCHECK(path.find(' ') == std::string::npos);
-  return sprintfn(buffer, size, "%s %.*s HTTP/%s", ToString(verb), path.size(),
-                  path.data(), ToString(version));
+  return sprintfn(buffer, size, "GET %.*s HTTP/%s", path.size(), path.data(),
+                  ToString(version));
 }
 
 HttpError HttpRequestData::parseLeader(const char* line, size_t len) {
@@ -608,8 +566,7 @@
   } else {
     return HE_PROTOCOL;
   }
-  std::string sverb(line, vend);
-  if (!FromString(verb, sverb.c_str())) {
+  if (vend != 3 || memcmp(line, "GET", 3)) {
     return HE_PROTOCOL;  // !?! HC_METHOD_NOT_SUPPORTED?
   }
   path.assign(line + dstart, line + dend);
@@ -617,8 +574,6 @@
 }
 
 bool HttpRequestData::getAbsoluteUri(std::string* uri) const {
-  if (HV_CONNECT == verb)
-    return false;
   Url<char> url(path);
   if (url.valid()) {
     uri->assign(path);
@@ -635,8 +590,6 @@
 
 bool HttpRequestData::getRelativeUri(std::string* host,
                                      std::string* path) const {
-  if (HV_CONNECT == verb)
-    return false;
   Url<char> url(this->path);
   if (url.valid()) {
     host->assign(url.address());
@@ -659,34 +612,12 @@
   HttpData::clear(release_document);
 }
 
-void HttpResponseData::copy(const HttpResponseData& src) {
-  scode = src.scode;
-  message = src.message;
-  HttpData::copy(src);
-}
-
 void HttpResponseData::set_success(uint32_t scode) {
   this->scode = scode;
   message.clear();
   setHeader(HH_CONTENT_LENGTH, "0", false);
 }
 
-void HttpResponseData::set_success(const std::string& content_type,
-                                   StreamInterface* document,
-                                   uint32_t scode) {
-  this->scode = scode;
-  message.erase(message.begin(), message.end());
-  setContent(content_type, document);
-}
-
-void HttpResponseData::set_redirect(const std::string& location,
-                                    uint32_t scode) {
-  this->scode = scode;
-  message.clear();
-  setHeader(HH_LOCATION, location);
-  setHeader(HH_CONTENT_LENGTH, "0", false);
-}
-
 void HttpResponseData::set_error(uint32_t scode) {
   this->scode = scode;
   message.clear();
diff --git a/rtc_base/httpcommon.h b/rtc_base/httpcommon.h
index 1b8768d..11c01ca 100644
--- a/rtc_base/httpcommon.h
+++ b/rtc_base/httpcommon.h
@@ -31,41 +31,11 @@
 
 enum HttpCode {
   HC_OK = 200,
-  HC_NON_AUTHORITATIVE = 203,
-  HC_NO_CONTENT = 204,
-  HC_PARTIAL_CONTENT = 206,
-
-  HC_MULTIPLE_CHOICES = 300,
-  HC_MOVED_PERMANENTLY = 301,
-  HC_FOUND = 302,
-  HC_SEE_OTHER = 303,
-  HC_NOT_MODIFIED = 304,
-  HC_MOVED_TEMPORARILY = 307,
-
-  HC_BAD_REQUEST = 400,
-  HC_UNAUTHORIZED = 401,
-  HC_FORBIDDEN = 403,
-  HC_NOT_FOUND = 404,
-  HC_PROXY_AUTHENTICATION_REQUIRED = 407,
-  HC_GONE = 410,
-
   HC_INTERNAL_SERVER_ERROR = 500,
-  HC_NOT_IMPLEMENTED = 501,
-  HC_SERVICE_UNAVAILABLE = 503,
 };
 
 enum HttpVersion { HVER_1_0, HVER_1_1, HVER_UNKNOWN, HVER_LAST = HVER_UNKNOWN };
 
-enum HttpVerb {
-  HV_GET,
-  HV_POST,
-  HV_PUT,
-  HV_DELETE,
-  HV_CONNECT,
-  HV_HEAD,
-  HV_LAST = HV_HEAD
-};
-
 enum HttpError {
   HE_NONE,
   HE_PROTOCOL,             // Received non-valid HTTP data
@@ -121,37 +91,12 @@
 // Utility Functions
 //////////////////////////////////////////////////////////////////////
 
-inline HttpError mkerr(HttpError err, HttpError def_err = HE_DEFAULT) {
-  return (err != HE_NONE) ? err : def_err;
-}
-
 const char* ToString(HttpVersion version);
 bool FromString(HttpVersion& version, const std::string& str);
 
-const char* ToString(HttpVerb verb);
-bool FromString(HttpVerb& verb, const std::string& str);
-
 const char* ToString(HttpHeader header);
 bool FromString(HttpHeader& header, const std::string& str);
 
-inline bool HttpCodeIsInformational(uint32_t code) {
-  return ((code / 100) == 1);
-}
-inline bool HttpCodeIsSuccessful(uint32_t code) {
-  return ((code / 100) == 2);
-}
-inline bool HttpCodeIsRedirection(uint32_t code) {
-  return ((code / 100) == 3);
-}
-inline bool HttpCodeIsClientError(uint32_t code) {
-  return ((code / 100) == 4);
-}
-inline bool HttpCodeIsServerError(uint32_t code) {
-  return ((code / 100) == 5);
-}
-
-bool HttpCodeHasBody(uint32_t code);
-bool HttpCodeIsCacheable(uint32_t code);
 bool HttpHeaderIsEndToEnd(HttpHeader header);
 bool HttpHeaderIsCollapsible(HttpHeader header);
 
@@ -382,20 +327,17 @@
  protected:
   virtual ~HttpData();
   void clear(bool release_document);
-  void copy(const HttpData& src);
 
  private:
   HeaderMap headers_;
 };
 
 struct HttpRequestData : public HttpData {
-  HttpVerb verb;
   std::string path;
 
-  HttpRequestData() : verb(HV_GET) {}
+  HttpRequestData() {}
 
   void clear(bool release_document);
-  void copy(const HttpRequestData& src);
 
   size_t formatLeader(char* buffer, size_t size) const override;
   HttpError parseLeader(const char* line, size_t len) override;
@@ -410,15 +352,9 @@
 
   HttpResponseData() : scode(HC_INTERNAL_SERVER_ERROR) {}
   void clear(bool release_document);
-  void copy(const HttpResponseData& src);
 
   // Convenience methods
   void set_success(uint32_t scode = HC_OK);
-  void set_success(const std::string& content_type,
-                   StreamInterface* document,
-                   uint32_t scode = HC_OK);
-  void set_redirect(const std::string& location,
-                    uint32_t scode = HC_MOVED_TEMPORARILY);
   void set_error(uint32_t scode);
 
   size_t formatLeader(char* buffer, size_t size) const override;
diff --git a/rtc_base/memory/BUILD.gn b/rtc_base/memory/BUILD.gn
index e24b8ce..05fd7ab 100644
--- a/rtc_base/memory/BUILD.gn
+++ b/rtc_base/memory/BUILD.gn
@@ -27,9 +27,7 @@
     "aligned_malloc.cc",
     "aligned_malloc.h",
   ]
-  deps = [
-    "../..:typedefs",
-  ]
+  deps = []
 }
 
 rtc_source_set("unittests") {
@@ -41,7 +39,6 @@
   deps = [
     ":aligned_array",
     ":aligned_malloc",
-    "../..:typedefs",
     "../../test:test_support",
   ]
 }
diff --git a/rtc_base/memory/aligned_malloc.cc b/rtc_base/memory/aligned_malloc.cc
index 4e1e85c..2943a64 100644
--- a/rtc_base/memory/aligned_malloc.cc
+++ b/rtc_base/memory/aligned_malloc.cc
@@ -19,8 +19,6 @@
 #include <stdint.h>
 #endif
 
-#include "typedefs.h"  // NOLINT(build/include)
-
 // Reference on memory alignment:
 // http://stackoverflow.com/questions/227897/solve-the-memory-alignment-in-c-interview-question-that-stumped-me
 namespace webrtc {
diff --git a/rtc_base/memory/aligned_malloc_unittest.cc b/rtc_base/memory/aligned_malloc_unittest.cc
index 742a772..572af5a 100644
--- a/rtc_base/memory/aligned_malloc_unittest.cc
+++ b/rtc_base/memory/aligned_malloc_unittest.cc
@@ -19,7 +19,6 @@
 #endif
 
 #include "test/gtest.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/rtc_base/message_buffer_reader.h b/rtc_base/message_buffer_reader.h
new file mode 100644
index 0000000..baba89e
--- /dev/null
+++ b/rtc_base/message_buffer_reader.h
@@ -0,0 +1,37 @@
+/*
+ *  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_MESSAGE_BUFFER_READER_H_
+#define RTC_BASE_MESSAGE_BUFFER_READER_H_
+
+#include "rtc_base/bytebuffer.h"
+
+namespace webrtc {
+
+// A simple subclass of the ByteBufferReader that exposes the starting address
+// of the message and its length, so that we can recall previously parsed data.
+class MessageBufferReader : public rtc::ByteBufferReader {
+ public:
+  MessageBufferReader(const char* bytes, size_t len)
+      : rtc::ByteBufferReader(bytes, len) {}
+  ~MessageBufferReader() = default;
+
+  // Starting address of the message.
+  const char* MessageData() const { return bytes_; }
+  // Total length of the message. Note that this is different from Length(),
+  // which is the length of the remaining message from the current offset.
+  size_t MessageLength() const { return size_; }
+  // Current offset in the message.
+  size_t CurrentOffset() const { return start_; }
+};
+
+}  // namespace webrtc
+
+#endif  // RTC_BASE_MESSAGE_BUFFER_READER_H_
diff --git a/rtc_base/messagequeue.h b/rtc_base/messagequeue.h
index c156d15..fe64c9c 100644
--- a/rtc_base/messagequeue.h
+++ b/rtc_base/messagequeue.h
@@ -25,8 +25,8 @@
 #include "rtc_base/location.h"
 #include "rtc_base/messagehandler.h"
 #include "rtc_base/scoped_ref_ptr.h"
-#include "rtc_base/sigslot.h"
 #include "rtc_base/socketserver.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
 #include "rtc_base/thread_annotations.h"
 #include "rtc_base/timeutils.h"
 
diff --git a/rtc_base/module.mk b/rtc_base/module.mk
index 0f8f8ca..2a1b9f3 100644
--- a/rtc_base/module.mk
+++ b/rtc_base/module.mk
@@ -5,7 +5,7 @@
 include common.mk
 
 rtc_base_approved_generic_CXX_OBJECTS = \
-	rtc_base/base64.o \
+	rtc_base/third_party/base64/base64.o \
 	rtc_base/bitbuffer.o \
 	rtc_base/bitrateallocationstrategy.o \
 	rtc_base/bufferqueue.o \
diff --git a/rtc_base/nethelpers.h b/rtc_base/nethelpers.h
index de14a06..f9d188f 100644
--- a/rtc_base/nethelpers.h
+++ b/rtc_base/nethelpers.h
@@ -22,8 +22,8 @@
 
 #include "rtc_base/asyncresolverinterface.h"
 #include "rtc_base/signalthread.h"
-#include "rtc_base/sigslot.h"
 #include "rtc_base/socketaddress.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
 
 namespace rtc {
 
diff --git a/rtc_base/network.cc b/rtc_base/network.cc
index 0f42d6f..34da828 100644
--- a/rtc_base/network.cc
+++ b/rtc_base/network.cc
@@ -95,6 +95,7 @@
 std::string AdapterTypeToString(AdapterType type) {
   switch (type) {
     case ADAPTER_TYPE_ANY:
+      return "Wildcard";
     case ADAPTER_TYPE_UNKNOWN:
       return "Unknown";
     case ADAPTER_TYPE_ETHERNET:
diff --git a/rtc_base/network.h b/rtc_base/network.h
index 03a0978..ad932d0 100644
--- a/rtc_base/network.h
+++ b/rtc_base/network.h
@@ -22,7 +22,7 @@
 #include "rtc_base/ipaddress.h"
 #include "rtc_base/messagehandler.h"
 #include "rtc_base/networkmonitor.h"
-#include "rtc_base/sigslot.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
 
 #if defined(WEBRTC_POSIX)
 struct ifaddrs;
diff --git a/rtc_base/networkmonitor.h b/rtc_base/networkmonitor.h
index a174473..a84a30a 100644
--- a/rtc_base/networkmonitor.h
+++ b/rtc_base/networkmonitor.h
@@ -13,7 +13,7 @@
 
 #include "rtc_base/logging.h"
 #include "rtc_base/network_constants.h"
-#include "rtc_base/sigslot.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
 #include "rtc_base/thread.h"
 
 namespace rtc {
diff --git a/rtc_base/networkroute.h b/rtc_base/networkroute.h
index 5800ef8..31c0831 100644
--- a/rtc_base/networkroute.h
+++ b/rtc_base/networkroute.h
@@ -20,30 +20,13 @@
 namespace rtc {
 
 struct NetworkRoute {
-  bool connected;
-  uint16_t local_network_id;
-  uint16_t remote_network_id;
-  int last_sent_packet_id;  // Last packet id sent on the PREVIOUS route.
-  int packet_overhead;      // The overhead in bytes from IP layer and above.
-
-  NetworkRoute()
-      : connected(false),
-        local_network_id(0),
-        remote_network_id(0),
-        last_sent_packet_id(-1),
-        packet_overhead(0) {}
-
-  // The route is connected if the local and remote network ids are provided.
-  // TODO(zhihuang): Remove this and let the caller set the fields explicitly.
-  NetworkRoute(bool connected,
-               uint16_t local_net_id,
-               uint16_t remote_net_id,
-               int last_packet_id)
-      : connected(connected),
-        local_network_id(local_net_id),
-        remote_network_id(remote_net_id),
-        last_sent_packet_id(last_packet_id),
-        packet_overhead(0) {}
+  bool connected = false;
+  uint16_t local_network_id = 0;
+  uint16_t remote_network_id = 0;
+  // Last packet id sent on the PREVIOUS route.
+  int last_sent_packet_id = -1;
+  // The overhead in bytes from IP layer and above.
+  int packet_overhead = 0;
 
   // |last_sent_packet_id| and |packet_overhead| do not affect the NetworkRoute
   // comparison.
diff --git a/rtc_base/onetimeevent.h b/rtc_base/onetimeevent.h
index 8c55e26..f649f15 100644
--- a/rtc_base/onetimeevent.h
+++ b/rtc_base/onetimeevent.h
@@ -12,7 +12,6 @@
 #define RTC_BASE_ONETIMEEVENT_H_
 
 #include "rtc_base/criticalsection.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 // Provides a simple way to perform an operation (such as logging) one
diff --git a/rtc_base/openssladapter.cc b/rtc_base/openssladapter.cc
index 05de6d0..50284a6 100644
--- a/rtc_base/openssladapter.cc
+++ b/rtc_base/openssladapter.cc
@@ -907,14 +907,14 @@
     return nullptr;
   }
 
-#ifdef WEBRTC_BUILT_IN_SSL_ROOT_CERTIFICATES
+#ifndef WEBRTC_EXCLUDE_BUILT_IN_SSL_ROOT_CERTS
   if (!openssl::LoadBuiltinSSLRootCertificates(ctx)) {
     RTC_LOG(LS_ERROR) << "SSL_CTX creation failed: Failed to load any trusted "
                          "ssl root certificates.";
     SSL_CTX_free(ctx);
     return nullptr;
   }
-#endif  // WEBRTC_BUILT_IN_SSL_ROOT_CERTIFICATES
+#endif  // WEBRTC_EXCLUDE_BUILT_IN_SSL_ROOT_CERTS
 
 #if !defined(NDEBUG)
   SSL_CTX_set_info_callback(ctx, SSLInfoCallback);
diff --git a/rtc_base/opensslcertificate.cc b/rtc_base/opensslcertificate.cc
index 15fc303..ed67a89 100644
--- a/rtc_base/opensslcertificate.cc
+++ b/rtc_base/opensslcertificate.cc
@@ -36,9 +36,9 @@
 #include "rtc_base/openssldigest.h"
 #include "rtc_base/opensslidentity.h"
 #include "rtc_base/opensslutility.h"
-#ifdef WEBRTC_BUILT_IN_SSL_ROOT_CERTIFICATES
+#ifndef WEBRTC_EXCLUDE_BUILT_IN_SSL_ROOT_CERTS
 #include "rtc_base/sslroots.h"
-#endif
+#endif  // WEBRTC_EXCLUDE_BUILT_IN_SSL_ROOT_CERTS
 
 namespace rtc {
 
diff --git a/rtc_base/opensslutility.cc b/rtc_base/opensslutility.cc
index 2b4ffb6..46f4547 100644
--- a/rtc_base/opensslutility.cc
+++ b/rtc_base/opensslutility.cc
@@ -23,6 +23,7 @@
 
 #include <openssl/bio.h>
 #include <openssl/crypto.h>
+#include <openssl/err.h>
 #include <openssl/x509.h>
 #include <openssl/x509v3.h>
 
@@ -32,9 +33,9 @@
 #include "rtc_base/numerics/safe_conversions.h"
 #include "rtc_base/openssl.h"
 #include "rtc_base/opensslcertificate.h"
-#ifdef WEBRTC_BUILT_IN_SSL_ROOT_CERTIFICATES
+#ifndef WEBRTC_EXCLUDE_BUILT_IN_SSL_ROOT_CERTS
 #include "rtc_base/sslroots.h"
-#endif  // WEBRTC_BUILT_IN_SSL_ROOT_CERTIFICATES
+#endif  // WEBRTC_EXCLUDE_BUILT_IN_SSL_ROOT_CERTS
 
 namespace rtc {
 namespace openssl {
@@ -109,7 +110,7 @@
   }
 }
 
-#ifdef WEBRTC_BUILT_IN_SSL_ROOT_CERTIFICATES
+#ifndef WEBRTC_EXCLUDE_BUILT_IN_SSL_ROOT_CERTS
 bool LoadBuiltinSSLRootCertificates(SSL_CTX* ctx) {
   int count_of_added_certs = 0;
   for (size_t i = 0; i < arraysize(kSSLCertCertificateList); i++) {
@@ -129,7 +130,7 @@
   }
   return count_of_added_certs > 0;
 }
-#endif  // WEBRTC_BUILT_IN_SSL_ROOT_CERTIFICATES
+#endif  // WEBRTC_EXCLUDE_BUILT_IN_SSL_ROOT_CERTS
 
 }  // namespace openssl
 }  // namespace rtc
diff --git a/rtc_base/opensslutility.h b/rtc_base/opensslutility.h
index f579f50..7cb38b5 100644
--- a/rtc_base/opensslutility.h
+++ b/rtc_base/opensslutility.h
@@ -28,12 +28,12 @@
 // prefix can be provided for context.
 void LogSSLErrors(const std::string& prefix);
 
-#ifdef WEBRTC_BUILT_IN_SSL_ROOT_CERTIFICATES
+#ifndef WEBRTC_EXCLUDE_BUILT_IN_SSL_ROOT_CERTS
 // Attempt to add the certificates from the loader into the SSL_CTX. False is
 // returned only if there are no certificates returned from the loader or none
 // of them can be added to the TrustStore for the provided context.
 bool LoadBuiltinSSLRootCertificates(SSL_CTX* ssl_ctx);
-#endif  // WEBRTC_BUILT_IN_SSL_ROOT_CERTIFICATES
+#endif  // WEBRTC_EXCLUDE_BUILT_IN_SSL_ROOT_CERTS
 
 }  // namespace openssl
 }  // namespace rtc
diff --git a/rtc_base/optionsfile.cc b/rtc_base/optionsfile.cc
index 8d2d2e0..535859b 100644
--- a/rtc_base/optionsfile.cc
+++ b/rtc_base/optionsfile.cc
@@ -165,7 +165,8 @@
   if (!IsLegalName(option)) {
     return false;
   }
-  return ToString(value, &options_[option]);
+  options_[option] = ToString(value);
+  return true;
 }
 
 bool OptionsFile::RemoveValue(const std::string& option) {
diff --git a/rtc_base/ptr_util.h b/rtc_base/ptr_util.h
deleted file mode 100644
index 56d8da3..0000000
--- a/rtc_base/ptr_util.h
+++ /dev/null
@@ -1,38 +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 file contains rtc::MakeUnique and rtc::WrapUnique, which are backwards
-// compatibility aliases for absl::make_unique and absl::WrapUnique,
-// respectively. This file will go away soon; use the Abseil types directly in
-// new code.
-
-#ifndef RTC_BASE_PTR_UTIL_H_
-#define RTC_BASE_PTR_UTIL_H_
-
-#include "absl/memory/memory.h"
-
-namespace rtc {
-
-template <typename T, typename... Args>
-auto MakeUnique(Args&&... args)
-    -> decltype(absl::make_unique<T, Args...>(std::forward<Args>(args)...)) {
-  return absl::make_unique<T, Args...>(std::forward<Args>(args)...);
-}
-
-template <typename T>
-auto MakeUnique(size_t n) -> decltype(absl::make_unique<T>(n)) {
-  return absl::make_unique<T>(n);
-}
-
-using absl::WrapUnique;
-
-}  // namespace rtc
-
-#endif  // RTC_BASE_PTR_UTIL_H_
diff --git a/rtc_base/ptr_util_unittest.cc b/rtc_base/ptr_util_unittest.cc
deleted file mode 100644
index 6497fda..0000000
--- a/rtc_base/ptr_util_unittest.cc
+++ /dev/null
@@ -1,69 +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/ptr_util.h"
-
-#include <stddef.h>
-#include <string>
-
-#include "rtc_base/gunit.h"
-
-namespace rtc {
-
-namespace {
-
-class DeleteCounter {
- public:
-  DeleteCounter() { ++count_; }
-  ~DeleteCounter() { --count_; }
-
-  static size_t count() { return count_; }
-
- private:
-  static size_t count_;
-};
-
-size_t DeleteCounter::count_ = 0;
-
-}  // namespace
-
-TEST(PtrUtilTest, WrapUnique) {
-  EXPECT_EQ(0u, DeleteCounter::count());
-  DeleteCounter* counter = new DeleteCounter;
-  EXPECT_EQ(1u, DeleteCounter::count());
-  std::unique_ptr<DeleteCounter> owned_counter = WrapUnique(counter);
-  EXPECT_EQ(1u, DeleteCounter::count());
-  owned_counter.reset();
-  EXPECT_EQ(0u, DeleteCounter::count());
-}
-
-TEST(PtrUtilTest, MakeUniqueScalar) {
-  auto s = MakeUnique<std::string>();
-  EXPECT_EQ("", *s);
-
-  auto s2 = MakeUnique<std::string>("test");
-  EXPECT_EQ("test", *s2);
-}
-
-TEST(PtrUtilTest, MakeUniqueScalarWithMoveOnlyType) {
-  using MoveOnly = std::unique_ptr<std::string>;
-  auto p = MakeUnique<MoveOnly>(MakeUnique<std::string>("test"));
-  EXPECT_EQ("test", **p);
-}
-
-TEST(PtrUtilTest, MakeUniqueArray) {
-  EXPECT_EQ(0u, DeleteCounter::count());
-  auto a = MakeUnique<DeleteCounter[]>(5);
-  EXPECT_EQ(5u, DeleteCounter::count());
-  a.reset();
-  EXPECT_EQ(0u, DeleteCounter::count());
-}
-
-}  // namespace rtc
diff --git a/rtc_base/random.h b/rtc_base/random.h
index 7c103cc..2faa985 100644
--- a/rtc_base/random.h
+++ b/rtc_base/random.h
@@ -15,7 +15,6 @@
 
 #include "rtc_base/checks.h"
 #include "rtc_base/constructormagic.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/rtc_base/rate_statistics.cc b/rtc_base/rate_statistics.cc
index 9b1ff8f..bb506aa 100644
--- a/rtc_base/rate_statistics.cc
+++ b/rtc_base/rate_statistics.cc
@@ -12,6 +12,7 @@
 
 #include <algorithm>
 
+#include "absl/memory/memory.h"
 #include "rtc_base/checks.h"
 
 namespace webrtc {
@@ -26,6 +27,21 @@
       max_window_size_ms_(window_size_ms),
       current_window_size_ms_(max_window_size_ms_) {}
 
+RateStatistics::RateStatistics(const RateStatistics& other)
+    : accumulated_count_(other.accumulated_count_),
+      num_samples_(other.num_samples_),
+      oldest_time_(other.oldest_time_),
+      oldest_index_(other.oldest_index_),
+      scale_(other.scale_),
+      max_window_size_ms_(other.max_window_size_ms_),
+      current_window_size_ms_(other.current_window_size_ms_) {
+  buckets_ = absl::make_unique<Bucket[]>(other.max_window_size_ms_);
+  std::copy(other.buckets_.get(),
+            other.buckets_.get() + other.max_window_size_ms_, buckets_.get());
+}
+
+RateStatistics::RateStatistics(RateStatistics&& other) = default;
+
 RateStatistics::~RateStatistics() {}
 
 void RateStatistics::Reset() {
diff --git a/rtc_base/rate_statistics.h b/rtc_base/rate_statistics.h
index fe5ae82..68035c9 100644
--- a/rtc_base/rate_statistics.h
+++ b/rtc_base/rate_statistics.h
@@ -14,7 +14,6 @@
 #include <memory>
 
 #include "absl/types/optional.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
@@ -28,6 +27,11 @@
   // scale = coefficient to convert counts/ms to desired unit
   //         ex: kBpsScale (8000) for bits/s if count represents bytes.
   RateStatistics(int64_t max_window_size_ms, float scale);
+
+  RateStatistics(const RateStatistics& other);
+
+  RateStatistics(RateStatistics&& other);
+
   ~RateStatistics();
 
   // Reset instance to original state.
diff --git a/rtc_base/signalthread.h b/rtc_base/signalthread.h
index 9d140c0..be54d9c 100644
--- a/rtc_base/signalthread.h
+++ b/rtc_base/signalthread.h
@@ -16,7 +16,7 @@
 #include "rtc_base/checks.h"
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/nullsocketserver.h"
-#include "rtc_base/sigslot.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
 #include "rtc_base/thread.h"
 
 namespace rtc {
diff --git a/rtc_base/sigslot_unittest.cc b/rtc_base/sigslot_unittest.cc
index 114a59f..2f3de40 100644
--- a/rtc_base/sigslot_unittest.cc
+++ b/rtc_base/sigslot_unittest.cc
@@ -8,7 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-#include "rtc_base/sigslot.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
 #include "rtc_base/gunit.h"
 #include "rtc_base/sigslotrepeater.h"
 
diff --git a/rtc_base/sigslotrepeater.h b/rtc_base/sigslotrepeater.h
index ca44854..724e624 100644
--- a/rtc_base/sigslotrepeater.h
+++ b/rtc_base/sigslotrepeater.h
@@ -21,7 +21,7 @@
 // TODO(deadbeef): Actually use this, after we decide on some style points on
 // using signals, so it doesn't get deleted again.
 
-#include "rtc_base/sigslot.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
 
 namespace sigslot {
 
diff --git a/rtc_base/sigslottester.h b/rtc_base/sigslottester.h
index 646ba22..73f4365 100644
--- a/rtc_base/sigslottester.h
+++ b/rtc_base/sigslottester.h
@@ -39,7 +39,7 @@
 //   /* See unit-tests for more examples */
 
 #include "rtc_base/constructormagic.h"
-#include "rtc_base/sigslot.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
 
 namespace rtc {
 
diff --git a/rtc_base/sigslottester.h.pump b/rtc_base/sigslottester.h.pump
index 1029a0f..0c7c693 100755
--- a/rtc_base/sigslottester.h.pump
+++ b/rtc_base/sigslottester.h.pump
@@ -36,7 +36,7 @@
 //   /* See unit-tests for more examples */
 
 #include "rtc_base/constructormagic.h"
-#include "rtc_base/sigslot.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
 
 namespace rtc {
 
diff --git a/rtc_base/sigslottester_unittest.cc b/rtc_base/sigslottester_unittest.cc
index c8e87e5..8fde268 100644
--- a/rtc_base/sigslottester_unittest.cc
+++ b/rtc_base/sigslottester_unittest.cc
@@ -13,7 +13,7 @@
 #include <string>
 
 #include "rtc_base/gunit.h"
-#include "rtc_base/sigslot.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
 
 namespace rtc {
 
diff --git a/rtc_base/sslcertificate.cc b/rtc_base/sslcertificate.cc
index d99da60..9a38fc0 100644
--- a/rtc_base/sslcertificate.cc
+++ b/rtc_base/sslcertificate.cc
@@ -15,11 +15,11 @@
 #include <utility>
 
 #include "absl/memory/memory.h"
-#include "rtc_base/base64.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/opensslcertificate.h"
 #include "rtc_base/sslfingerprint.h"
+#include "rtc_base/third_party/base64/base64.h"
 
 namespace rtc {
 
diff --git a/rtc_base/sslidentity.cc b/rtc_base/sslidentity.cc
index 94944f9..f286884 100644
--- a/rtc_base/sslidentity.cc
+++ b/rtc_base/sslidentity.cc
@@ -16,11 +16,11 @@
 #include <utility>
 
 #include "absl/memory/memory.h"
-#include "rtc_base/base64.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/opensslidentity.h"
 #include "rtc_base/sslfingerprint.h"
+#include "rtc_base/third_party/base64/base64.h"
 
 namespace rtc {
 
diff --git a/rtc_base/stream.cc b/rtc_base/stream.cc
index b9691c5..3f4d3dc 100644
--- a/rtc_base/stream.cc
+++ b/rtc_base/stream.cc
@@ -553,22 +553,6 @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-
-ExternalMemoryStream::ExternalMemoryStream() {}
-
-ExternalMemoryStream::ExternalMemoryStream(void* data, size_t length) {
-  SetData(data, length);
-}
-
-ExternalMemoryStream::~ExternalMemoryStream() {}
-
-void ExternalMemoryStream::SetData(void* data, size_t length) {
-  data_length_ = buffer_length_ = length;
-  buffer_ = static_cast<char*>(data);
-  seek_position_ = 0;
-}
-
-///////////////////////////////////////////////////////////////////////////////
 // FifoBuffer
 ///////////////////////////////////////////////////////////////////////////////
 
diff --git a/rtc_base/stream.h b/rtc_base/stream.h
index ee0f149..ac8193b 100644
--- a/rtc_base/stream.h
+++ b/rtc_base/stream.h
@@ -21,7 +21,7 @@
 #include "rtc_base/logging.h"
 #include "rtc_base/messagehandler.h"
 #include "rtc_base/messagequeue.h"
-#include "rtc_base/sigslot.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
 
 namespace rtc {
 
@@ -421,18 +421,6 @@
   StreamResult DoReserve(size_t size, int* error) override;
 };
 
-// ExternalMemoryStream adapts an external memory buffer, so writes which would
-// extend past the end of the buffer will return end-of-stream.
-
-class ExternalMemoryStream : public MemoryStreamBase {
- public:
-  ExternalMemoryStream();
-  ExternalMemoryStream(void* data, size_t length);
-  ~ExternalMemoryStream() override;
-
-  void SetData(void* data, size_t length);
-};
-
 // 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.
diff --git a/rtc_base/string_to_number.cc b/rtc_base/string_to_number.cc
index 06ac9e9..9201242 100644
--- a/rtc_base/string_to_number.cc
+++ b/rtc_base/string_to_number.cc
@@ -48,5 +48,41 @@
   return absl::nullopt;
 }
 
+template <typename T>
+T StrToT(const char* str, char** str_end);
+
+template <>
+inline float StrToT(const char* str, char** str_end) {
+  return std::strtof(str, str_end);
+}
+
+template <>
+inline double StrToT(const char* str, char** str_end) {
+  return std::strtod(str, str_end);
+}
+
+template <>
+inline long double StrToT(const char* str, char** str_end) {
+  return std::strtold(str, str_end);
+}
+
+template <typename T>
+absl::optional<T> ParseFloatingPoint(const char* str) {
+  RTC_DCHECK(str);
+  if (*str == '\0')
+    return absl::nullopt;
+  char* end = nullptr;
+  errno = 0;
+  const T value = StrToT<T>(str, &end);
+  if (end && *end == '\0' && errno == 0) {
+    return value;
+  }
+  return absl::nullopt;
+}
+
+template absl::optional<float> ParseFloatingPoint(const char* str);
+template absl::optional<double> ParseFloatingPoint(const char* str);
+template absl::optional<long double> ParseFloatingPoint(const char* str);
+
 }  // namespace string_to_number_internal
 }  // namespace rtc
diff --git a/rtc_base/string_to_number.h b/rtc_base/string_to_number.h
index 9b4fa67..7ea9f25 100644
--- a/rtc_base/string_to_number.h
+++ b/rtc_base/string_to_number.h
@@ -48,6 +48,9 @@
 
 absl::optional<signed_type> ParseSigned(const char* str, int base);
 absl::optional<unsigned_type> ParseUnsigned(const char* str, int base);
+
+template <typename T>
+absl::optional<T> ParseFloatingPoint(const char* str);
 }  // namespace string_to_number_internal
 
 template <typename T>
@@ -88,6 +91,17 @@
   return absl::nullopt;
 }
 
+template <typename T>
+typename std::enable_if<std::is_floating_point<T>::value,
+                        absl::optional<T>>::type
+StringToNumber(const char* str, int base = 10) {
+  static_assert(
+      std::numeric_limits<T>::max() <= std::numeric_limits<long double>::max(),
+      "StringToNumber only supports floating-point numbers as large "
+      "as long double");
+  return string_to_number_internal::ParseFloatingPoint<T>(str);
+}
+
 // The std::string overloads only exists if there is a matching const char*
 // version.
 template <typename T>
diff --git a/rtc_base/stringencode.cc b/rtc_base/stringencode.cc
index 8e7c6d7..b410477 100644
--- a/rtc_base/stringencode.cc
+++ b/rtc_base/stringencode.cc
@@ -13,6 +13,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#include "rtc_base/arraysize.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/stringutils.h"
 
@@ -410,4 +411,90 @@
   return fields->size();
 }
 
+std::string ToString(const bool b) {
+  return b ? "true" : "false";
+}
+
+std::string ToString(const char* const s) {
+  return std::string(s);
+}
+std::string ToString(const std::string s) {
+  return s;
+}
+
+std::string ToString(const short s) {
+  char buf[32];
+  const int len = std::snprintf(&buf[0], arraysize(buf), "%hd", s);
+  RTC_DCHECK_LE(len, arraysize(buf));
+  return std::string(&buf[0], len);
+}
+std::string ToString(const unsigned short s) {
+  char buf[32];
+  const int len = std::snprintf(&buf[0], arraysize(buf), "%hu", s);
+  RTC_DCHECK_LE(len, arraysize(buf));
+  return std::string(&buf[0], len);
+}
+std::string ToString(const int s) {
+  char buf[32];
+  const int len = std::snprintf(&buf[0], arraysize(buf), "%d", s);
+  RTC_DCHECK_LE(len, arraysize(buf));
+  return std::string(&buf[0], len);
+}
+std::string ToString(const unsigned int s) {
+  char buf[32];
+  const int len = std::snprintf(&buf[0], arraysize(buf), "%u", s);
+  RTC_DCHECK_LE(len, arraysize(buf));
+  return std::string(&buf[0], len);
+}
+std::string ToString(const long int s) {
+  char buf[32];
+  const int len = std::snprintf(&buf[0], arraysize(buf), "%ld", s);
+  RTC_DCHECK_LE(len, arraysize(buf));
+  return std::string(&buf[0], len);
+}
+std::string ToString(const unsigned long int s) {
+  char buf[32];
+  const int len = std::snprintf(&buf[0], arraysize(buf), "%lu", s);
+  RTC_DCHECK_LE(len, arraysize(buf));
+  return std::string(&buf[0], len);
+}
+std::string ToString(const long long int s) {
+  char buf[32];
+  const int len = std::snprintf(&buf[0], arraysize(buf), "%lld", s);
+  RTC_DCHECK_LE(len, arraysize(buf));
+  return std::string(&buf[0], len);
+}
+std::string ToString(const unsigned long long int s) {
+  char buf[32];
+  const int len = std::snprintf(&buf[0], arraysize(buf), "%llu", s);
+  RTC_DCHECK_LE(len, arraysize(buf));
+  return std::string(&buf[0], len);
+}
+
+std::string ToString(const double d) {
+  char buf[32];
+  const int len = std::snprintf(&buf[0], arraysize(buf), "%g", d);
+  RTC_DCHECK_LE(len, arraysize(buf));
+  return std::string(&buf[0], len);
+}
+
+std::string ToString(const void* const p) {
+  char buf[32];
+  const int len = std::snprintf(&buf[0], arraysize(buf), "%p", p);
+  RTC_DCHECK_LE(len, arraysize(buf));
+  return std::string(&buf[0], len);
+}
+
+bool FromString(const std::string& s, bool* b) {
+  if (s == "false") {
+    *b = false;
+    return true;
+  }
+  if (s == "true") {
+    *b = true;
+    return true;
+  }
+  return false;
+}
+
 }  // namespace rtc
diff --git a/rtc_base/stringencode.h b/rtc_base/stringencode.h
index 7042c4a..830ea77 100644
--- a/rtc_base/stringencode.h
+++ b/rtc_base/stringencode.h
@@ -16,6 +16,7 @@
 #include <vector>
 
 #include "rtc_base/checks.h"
+#include "rtc_base/string_to_number.h"
 
 namespace rtc {
 
@@ -147,32 +148,40 @@
                     std::string* rest);
 
 // Convert arbitrary values to/from a string.
+// TODO(jonasolsson): Remove these when absl::StrCat becomes available.
+std::string ToString(bool b);
 
-template <class T>
-static bool ToString(const T& t, std::string* s) {
-  RTC_DCHECK(s);
-  std::ostringstream oss;
-  oss << std::boolalpha << t;
-  *s = oss.str();
-  return !oss.fail();
-}
+std::string ToString(const char* s);
+std::string ToString(std::string t);
 
-template <class T>
+std::string ToString(short s);
+std::string ToString(unsigned short s);
+std::string ToString(int s);
+std::string ToString(unsigned int s);
+std::string ToString(long int s);
+std::string ToString(unsigned long int s);
+std::string ToString(long long int s);
+std::string ToString(unsigned long long int s);
+
+std::string ToString(double t);
+
+std::string ToString(const void* p);
+
+template <typename T,
+          typename std::enable_if<std::is_arithmetic<T>::value &&
+                                      !std::is_same<T, bool>::value,
+                                  int>::type = 0>
 static bool FromString(const std::string& s, T* t) {
   RTC_DCHECK(t);
-  std::istringstream iss(s);
-  iss >> std::boolalpha >> *t;
-  return !iss.fail();
+  absl::optional<T> result = StringToNumber<T>(s);
+
+  if (result)
+    *t = *result;
+
+  return result.has_value();
 }
 
-// Inline versions of the string conversion routines.
-
-template <typename T>
-static inline std::string ToString(const T& val) {
-  std::string str;
-  ToString(val, &str);
-  return str;
-}
+bool FromString(const std::string& s, bool* b);
 
 template <typename T>
 static inline T FromString(const std::string& str) {
@@ -181,13 +190,6 @@
   return val;
 }
 
-template <typename T>
-static inline T FromString(const T& defaultValue, const std::string& str) {
-  T val(defaultValue);
-  FromString(str, &val);
-  return val;
-}
-
 //////////////////////////////////////////////////////////////////////
 
 }  // namespace rtc
diff --git a/rtc_base/stringencode_unittest.cc b/rtc_base/stringencode_unittest.cc
index ffb90b2..9bdc592 100644
--- a/rtc_base/stringencode_unittest.cc
+++ b/rtc_base/stringencode_unittest.cc
@@ -13,6 +13,8 @@
 #include "rtc_base/gunit.h"
 #include "rtc_base/stringutils.h"
 
+#include <sstream>  // no-presubmit-check TODO(webrtc:8982)
+
 namespace rtc {
 
 class HexEncodeTest : public testing::Test {
@@ -351,53 +353,79 @@
   ASSERT_STREQ("", fields.at(0).c_str());
 }
 
-TEST(BoolTest, DecodeValid) {
-  bool value;
-  EXPECT_TRUE(FromString("true", &value));
-  EXPECT_TRUE(value);
-  EXPECT_TRUE(FromString("true,", &value));
-  EXPECT_TRUE(value);
-  EXPECT_TRUE(FromString("true , true", &value));
-  EXPECT_TRUE(value);
-  EXPECT_TRUE(FromString("true ,\n false", &value));
-  EXPECT_TRUE(value);
-  EXPECT_TRUE(FromString("  true  \n", &value));
-  EXPECT_TRUE(value);
+TEST(ToString, SanityCheck) {
+  EXPECT_EQ(ToString(true), "true");
+  EXPECT_EQ(ToString(false), "false");
 
-  EXPECT_TRUE(FromString("false", &value));
-  EXPECT_FALSE(value);
-  EXPECT_TRUE(FromString("  false ", &value));
-  EXPECT_FALSE(value);
-  EXPECT_TRUE(FromString("  false, ", &value));
-  EXPECT_FALSE(value);
+  const char* c = "message";
+  EXPECT_EQ(ToString(c), c);
+  EXPECT_EQ(ToString(std::string(c)), c);
 
-  EXPECT_TRUE(FromString<bool>("true\n"));
-  EXPECT_FALSE(FromString<bool>("false\n"));
+  EXPECT_EQ(ToString(short{-123}), "-123");
+  EXPECT_EQ(ToString((unsigned short)123), "123");
+  EXPECT_EQ(ToString(int{-123}), "-123");
+  EXPECT_EQ(ToString((unsigned int)123), "123");
+  EXPECT_EQ(ToString((long int)-123), "-123");
+  EXPECT_EQ(ToString((unsigned long int)123), "123");
+  EXPECT_EQ(ToString((long long int)-123), "-123");
+  EXPECT_EQ(ToString((unsigned long long int)123), "123");
+
+  int i = 10;
+  int* p = &i;
+  std::ostringstream s;  // no-presubmit-check TODO(webrtc:8982)
+  s << p;
+  EXPECT_EQ(s.str(), ToString(p));
+
+  EXPECT_EQ(ToString(0.5), "0.5");
 }
 
-TEST(BoolTest, DecodeInvalid) {
-  bool value;
-  EXPECT_FALSE(FromString("True", &value));
-  EXPECT_FALSE(FromString("TRUE", &value));
-  EXPECT_FALSE(FromString("False", &value));
-  EXPECT_FALSE(FromString("FALSE", &value));
-  EXPECT_FALSE(FromString("0", &value));
-  EXPECT_FALSE(FromString("1", &value));
-  EXPECT_FALSE(FromString("0,", &value));
-  EXPECT_FALSE(FromString("1,", &value));
-  EXPECT_FALSE(FromString("1,0", &value));
-  EXPECT_FALSE(FromString("1.", &value));
-  EXPECT_FALSE(FromString("1.0", &value));
-  EXPECT_FALSE(FromString("", &value));
-  EXPECT_FALSE(FromString<bool>("false\nfalse"));
+template <typename T>
+void ParsesTo(std::string s, T t) {
+  T value;
+  EXPECT_TRUE(FromString(s, &value));
+  EXPECT_EQ(value, t);
 }
 
-TEST(BoolTest, RoundTrip) {
-  bool value;
-  EXPECT_TRUE(FromString(ToString(true), &value));
-  EXPECT_TRUE(value);
-  EXPECT_TRUE(FromString(ToString(false), &value));
-  EXPECT_FALSE(value);
+TEST(FromString, DecodeValid) {
+  ParsesTo("true", true);
+  ParsesTo("false", false);
+
+  ParsesTo("105", 105);
+  ParsesTo("0.25", 0.25);
+}
+
+template <typename T>
+void FailsToParse(std::string s) {
+  T value;
+  EXPECT_FALSE(FromString(s, &value)) << "[" << s << "]";
+}
+
+TEST(FromString, DecodeInvalid) {
+  FailsToParse<bool>("True");
+  FailsToParse<bool>("0");
+  FailsToParse<bool>("yes");
+
+  FailsToParse<int>("0.5");
+  FailsToParse<int>("XIV");
+  FailsToParse<double>("");
+  FailsToParse<double>("  ");
+  FailsToParse<int>("1 2");
+}
+
+template <typename T>
+void RoundTrip(T t) {
+  std::string s = ToString(t);
+  T value;
+  EXPECT_TRUE(FromString(s, &value));
+  EXPECT_EQ(value, t);
+}
+
+TEST(FromString, RoundTrip) {
+  RoundTrip<int>(123);
+  RoundTrip(false);
+  RoundTrip(true);
+  RoundTrip(0.5);
+  RoundTrip(-15l);
 }
 
 }  // namespace rtc
diff --git a/rtc_base/swap_queue.h b/rtc_base/swap_queue.h
index f794ad9..172f2f5 100644
--- a/rtc_base/swap_queue.h
+++ b/rtc_base/swap_queue.h
@@ -18,6 +18,7 @@
 #include "rtc_base/checks.h"
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/criticalsection.h"
+#include "rtc_base/system/unused.h"
 
 namespace webrtc {
 
diff --git a/rtc_base/synchronization/BUILD.gn b/rtc_base/synchronization/BUILD.gn
index 9d9ea6f..447be38 100644
--- a/rtc_base/synchronization/BUILD.gn
+++ b/rtc_base/synchronization/BUILD.gn
@@ -21,7 +21,6 @@
   ]
   deps = [
     "..:macromagic",
-    "../..:typedefs",
   ]
   if (is_win) {
     sources += [
diff --git a/rtc_base/synchronization/rw_lock_posix.h b/rtc_base/synchronization/rw_lock_posix.h
index 9a92bcd..a103fe7 100644
--- a/rtc_base/synchronization/rw_lock_posix.h
+++ b/rtc_base/synchronization/rw_lock_posix.h
@@ -14,7 +14,6 @@
 #include <pthread.h>
 
 #include "rtc_base/synchronization/rw_lock_wrapper.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/rtc_base/system/BUILD.gn b/rtc_base/system/BUILD.gn
index 9d3fa2c..64df84f 100644
--- a/rtc_base/system/BUILD.gn
+++ b/rtc_base/system/BUILD.gn
@@ -38,7 +38,6 @@
   deps = [
     "..:checks",
     "..:criticalsection",
-    "../..:typedefs",
     "../..:webrtc_common",
   ]
 }
diff --git a/rtc_base/system/file_wrapper.h b/rtc_base/system/file_wrapper.h
index 4672cc4..5411b04 100644
--- a/rtc_base/system/file_wrapper.h
+++ b/rtc_base/system/file_wrapper.h
@@ -16,7 +16,6 @@
 
 #include "common_types.h"  // NOLINT(build/include)
 #include "rtc_base/criticalsection.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 // Implementation that can read (exclusive) or write from/to a file.
 
diff --git a/rtc_base/task_queue_libevent.cc b/rtc_base/task_queue_libevent.cc
index 4db4827..8dc9b15 100644
--- a/rtc_base/task_queue_libevent.cc
+++ b/rtc_base/task_queue_libevent.cc
@@ -24,6 +24,7 @@
 #include "rtc_base/platform_thread.h"
 #include "rtc_base/refcount.h"
 #include "rtc_base/refcountedobject.h"
+#include "rtc_base/system/unused.h"
 #include "rtc_base/task_queue.h"
 #include "rtc_base/task_queue_posix.h"
 #include "rtc_base/timeutils.h"
diff --git a/rtc_base/third_party/base64/BUILD.gn b/rtc_base/third_party/base64/BUILD.gn
new file mode 100644
index 0000000..dca47e0
--- /dev/null
+++ b/rtc_base/third_party/base64/BUILD.gn
@@ -0,0 +1,17 @@
+# 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("base64") {
+  visibility = [ "*" ]
+  sources = [
+    "base64.cc",
+    "base64.h",
+  ]
+}
diff --git a/rtc_base/third_party/base64/LICENSE b/rtc_base/third_party/base64/LICENSE
new file mode 100644
index 0000000..4ad21d1
--- /dev/null
+++ b/rtc_base/third_party/base64/LICENSE
@@ -0,0 +1,14 @@
+//*********************************************************************
+//* Base64 - a simple base64 encoder and decoder.
+//*
+//*     Copyright (c) 1999, Bob Withers - bwit@pobox.com
+//*
+//* This code may be freely used for any purpose, either personal
+//* or commercial, provided the authors copyright notice remains
+//* intact.
+//*
+//* Enhancements by Stanley Yamane:
+//*     o reverse lookup table for the decode function
+//*     o reserve string buffer space in advance
+//*
+//*********************************************************************
diff --git a/rtc_base/third_party/base64/README.chromium b/rtc_base/third_party/base64/README.chromium
new file mode 100644
index 0000000..92ba0d3
--- /dev/null
+++ b/rtc_base/third_party/base64/README.chromium
@@ -0,0 +1,11 @@
+Name: A simple base64 encoder and decoder
+Short Name: base64
+URL:
+Version: 0
+Date: 2018-06-20
+License: Custom license
+License File: LICENSE
+Security Critical: yes
+
+Description:
+A simple base64 encoder and decoder
diff --git a/rtc_base/base64.cc b/rtc_base/third_party/base64/base64.cc
similarity index 99%
rename from rtc_base/base64.cc
rename to rtc_base/third_party/base64/base64.cc
index 6add993..53ff6b9 100644
--- a/rtc_base/base64.cc
+++ b/rtc_base/third_party/base64/base64.cc
@@ -14,10 +14,10 @@
 //*
 //*********************************************************************
 
-#include "rtc_base/base64.h"
+#include "rtc_base/third_party/base64/base64.h"
 
-#include <string.h>
 #include <assert.h>
+#include <string.h>
 
 using std::vector;
 
diff --git a/rtc_base/base64.h b/rtc_base/third_party/base64/base64.h
similarity index 96%
rename from rtc_base/base64.h
rename to rtc_base/third_party/base64/base64.h
index bfe2fe6..bbc93c8 100644
--- a/rtc_base/base64.h
+++ b/rtc_base/third_party/base64/base64.h
@@ -9,8 +9,8 @@
 //* intact.
 //*********************************************************************
 
-#ifndef RTC_BASE_BASE64_H_
-#define RTC_BASE_BASE64_H_
+#ifndef RTC_BASE_THIRD_PARTY_BASE64_BASE64_H_
+#define RTC_BASE_THIRD_PARTY_BASE64_BASE64_H_
 
 #include <string>
 #include <vector>
@@ -120,4 +120,4 @@
 
 }  // namespace rtc
 
-#endif  // RTC_BASE_BASE64_H_
+#endif  /* RTC_BASE_THIRD_PARTY_BASE64_BASE64_H_ */
diff --git a/rtc_base/third_party/base64/module.mk b/rtc_base/third_party/base64/module.mk
new file mode 100644
index 0000000..37c23f4
--- /dev/null
+++ b/rtc_base/third_party/base64/module.mk
@@ -0,0 +1,5 @@
+# Copyright 2018 The Chromium OS Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+include common.mk
diff --git a/rtc_base/third_party/module.mk b/rtc_base/third_party/module.mk
new file mode 100644
index 0000000..37c23f4
--- /dev/null
+++ b/rtc_base/third_party/module.mk
@@ -0,0 +1,5 @@
+# Copyright 2018 The Chromium OS Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+include common.mk
diff --git a/rtc_base/third_party/sigslot/BUILD.gn b/rtc_base/third_party/sigslot/BUILD.gn
new file mode 100644
index 0000000..aea748e
--- /dev/null
+++ b/rtc_base/third_party/sigslot/BUILD.gn
@@ -0,0 +1,17 @@
+# 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("sigslot") {
+  visibility = [ "*" ]
+  sources = [
+    "sigslot.cc",
+    "sigslot.h",
+  ]
+}
diff --git a/rtc_base/third_party/sigslot/LICENSE b/rtc_base/third_party/sigslot/LICENSE
new file mode 100644
index 0000000..d1c66c7
--- /dev/null
+++ b/rtc_base/third_party/sigslot/LICENSE
@@ -0,0 +1,7 @@
+// sigslot.h: Signal/Slot classes
+//
+// Written by Sarah Thompson (sarah@telergy.com) 2002.
+//
+// License: Public domain. You are free to use this code however you like, with
+// the proviso that the author takes on no responsibility or liability for any
+// use.
diff --git a/rtc_base/third_party/sigslot/README.chromium b/rtc_base/third_party/sigslot/README.chromium
new file mode 100644
index 0000000..e0575cf
--- /dev/null
+++ b/rtc_base/third_party/sigslot/README.chromium
@@ -0,0 +1,20 @@
+Name: C++ Signal/Slot Library
+Short Name: sigslot
+URL: http://sigslot.sourceforge.net/
+Version: 0
+Date: 2018-07-09
+License: Custom license
+License File: LICENSE
+Security Critical: yes
+
+Description:
+C++ Signal/Slot Library
+
+This file has been modified such that has_slots and signalx do not have to be
+using the same threading requirements. E.g. it is possible to connect a
+has_slots<single_threaded> and signal0<multi_threaded_local> or
+has_slots<multi_threaded_local> and signal0<single_threaded>.
+If has_slots is single threaded the user must ensure that it is not trying
+to connect or disconnect to signalx concurrently or data race may occur.
+If signalx is single threaded the user must ensure that disconnect, connect
+or signal is not happening concurrently or data race may occur.
diff --git a/rtc_base/sigslot.cc b/rtc_base/third_party/sigslot/sigslot.cc
similarity index 90%
rename from rtc_base/sigslot.cc
rename to rtc_base/third_party/sigslot/sigslot.cc
index 9d792cb..d852a2b 100644
--- a/rtc_base/sigslot.cc
+++ b/rtc_base/third_party/sigslot/sigslot.cc
@@ -6,7 +6,7 @@
 // the proviso that the author takes on no responsibility or liability for any
 // use.
 
-#include "rtc_base/sigslot.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
 
 namespace sigslot {
 
diff --git a/rtc_base/sigslot.h b/rtc_base/third_party/sigslot/sigslot.h
similarity index 98%
rename from rtc_base/sigslot.h
rename to rtc_base/third_party/sigslot/sigslot.h
index 15abdca..c77e4e6 100644
--- a/rtc_base/sigslot.h
+++ b/rtc_base/third_party/sigslot/sigslot.h
@@ -93,8 +93,8 @@
 // If signalx is single threaded the user must ensure that disconnect, connect
 // or signal is not happening concurrently or data race may occur.
 
-#ifndef RTC_BASE_SIGSLOT_H_
-#define RTC_BASE_SIGSLOT_H_
+#ifndef RTC_BASE_THIRD_PARTY_SIGSLOT_SIGSLOT_H_
+#define RTC_BASE_THIRD_PARTY_SIGSLOT_SIGSLOT_H_
 
 #include <stdlib.h>
 #include <cstring>
@@ -110,7 +110,7 @@
 #define _SIGSLOT_SINGLE_THREADED
 #elif defined(WEBRTC_WIN)
 #define _SIGSLOT_HAS_WIN32_THREADS
-#include "rtc_base/win32.h"
+#include "windows.h"
 #elif defined(__GNUG__) || defined(SIGSLOT_USE_POSIX_THREADS)
 #define _SIGSLOT_HAS_POSIX_THREADS
 #include <pthread.h>
@@ -641,4 +641,4 @@
 
 }  // namespace sigslot
 
-#endif  // RTC_BASE_SIGSLOT_H_
+#endif  /* RTC_BASE_THIRD_PARTY_SIGSLOT_SIGSLOT_H_ */
diff --git a/rtc_base/thread_unittest.cc b/rtc_base/thread_unittest.cc
index 74f62eb..d5c53f8 100644
--- a/rtc_base/thread_unittest.cc
+++ b/rtc_base/thread_unittest.cc
@@ -16,8 +16,8 @@
 #include "rtc_base/gunit.h"
 #include "rtc_base/nullsocketserver.h"
 #include "rtc_base/physicalsocketserver.h"
-#include "rtc_base/sigslot.h"
 #include "rtc_base/socketaddress.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
 #include "rtc_base/thread.h"
 
 #if defined(WEBRTC_WIN)
diff --git a/rtc_base/time/BUILD.gn b/rtc_base/time/BUILD.gn
index f8f6244..7b298ce 100644
--- a/rtc_base/time/BUILD.gn
+++ b/rtc_base/time/BUILD.gn
@@ -18,7 +18,6 @@
     "timestamp_extrapolator.h",
   ]
   deps = [
-    "../..:typedefs",
     "../synchronization:rw_lock_wrapper",
   ]
 }
diff --git a/rtc_base/time/timestamp_extrapolator.h b/rtc_base/time/timestamp_extrapolator.h
index 6638184..63af57b 100644
--- a/rtc_base/time/timestamp_extrapolator.h
+++ b/rtc_base/time/timestamp_extrapolator.h
@@ -11,8 +11,9 @@
 #ifndef RTC_BASE_TIME_TIMESTAMP_EXTRAPOLATOR_H_
 #define RTC_BASE_TIME_TIMESTAMP_EXTRAPOLATOR_H_
 
+#include <stdint.h>
+
 #include "rtc_base/synchronization/rw_lock_wrapper.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/rtc_base/timeutils.cc b/rtc_base/timeutils.cc
index f65bd15..de8fc32 100644
--- a/rtc_base/timeutils.cc
+++ b/rtc_base/timeutils.cc
@@ -201,6 +201,9 @@
 }
 
 int64_t TimeUTCMicros() {
+  if (g_clock) {
+    return g_clock->TimeNanos() / kNumNanosecsPerMicrosec;
+  }
 #if defined(WEBRTC_POSIX)
   struct timeval time;
   gettimeofday(&time, nullptr);
@@ -217,4 +220,8 @@
 #endif
 }
 
+int64_t TimeUTCMillis() {
+  return TimeUTCMicros() / kNumMicrosecsPerMillisec;
+}
+
 }  // namespace rtc
diff --git a/rtc_base/timeutils.h b/rtc_base/timeutils.h
index 48b5c8d..20b1dac 100644
--- a/rtc_base/timeutils.h
+++ b/rtc_base/timeutils.h
@@ -126,6 +126,10 @@
 // measuring time intervals and timeouts.
 int64_t TimeUTCMicros();
 
+// Return the number of milliseconds since January 1, 1970, UTC.
+// See above.
+int64_t TimeUTCMillis();
+
 // Interval of time from the range [min, max] inclusive.
 class IntervalRange {
  public:
diff --git a/script/sync-apm.sh b/script/sync-apm.sh
index ab645f9..47eccdd 100755
--- a/script/sync-apm.sh
+++ b/script/sync-apm.sh
@@ -24,6 +24,7 @@
 rsync "${OPTIONS[@]}" ${FROM}/modules/audio_processing ${TO}/modules
 rsync "${OPTIONS[@]}" ${FROM}/modules/include ${TO}/modules
 rsync "${OPTIONS[@]}" ${FROM}/modules/rtp_rtcp ${TO}/modules
+rsync "${OPTIONS[@]}" ${FROM}/modules/third_party ${TO}/modules
 
 # Add video codecs headers for common includes to work.
 mkdir -p ${TO}/modules/video_coding/codecs
diff --git a/system_wrappers/BUILD.gn b/system_wrappers/BUILD.gn
index 4c09164..106c63b 100644
--- a/system_wrappers/BUILD.gn
+++ b/system_wrappers/BUILD.gn
@@ -39,10 +39,10 @@
     ":metrics_api",
     ":runtime_enabled_features_api",
     "..:webrtc_common",
-    "../:typedefs",
     "../modules:module_api_public",
     "../rtc_base:checks",
     "../rtc_base/synchronization:rw_lock_wrapper",
+    "../rtc_base/system:arch",
     "//third_party/abseil-cpp/absl/types:optional",
   ]
 
@@ -103,7 +103,6 @@
   ]
   deps = [
     "..:webrtc_common",
-    "../:typedefs",
   ]
 }
 
@@ -194,6 +193,7 @@
     ]
     deps = [
       ":cpu_features_api",
+      "../rtc_base/system:arch",
     ]
   }
 }
@@ -218,7 +218,6 @@
       ":metrics_default",
       ":system_wrappers",
       "..:webrtc_common",
-      "../:typedefs",
       "../rtc_base:rtc_base_approved",
       "../test:test_main",
       "//testing/gtest",
diff --git a/system_wrappers/include/clock.h b/system_wrappers/include/clock.h
index 0164288..4b6eab8 100644
--- a/system_wrappers/include/clock.h
+++ b/system_wrappers/include/clock.h
@@ -15,7 +15,6 @@
 
 #include "rtc_base/synchronization/rw_lock_wrapper.h"
 #include "system_wrappers/include/ntp_time.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 
diff --git a/system_wrappers/include/cpu_features_wrapper.h b/system_wrappers/include/cpu_features_wrapper.h
index 07ee912..739161a 100644
--- a/system_wrappers/include/cpu_features_wrapper.h
+++ b/system_wrappers/include/cpu_features_wrapper.h
@@ -11,12 +11,12 @@
 #ifndef SYSTEM_WRAPPERS_INCLUDE_CPU_FEATURES_WRAPPER_H_
 #define SYSTEM_WRAPPERS_INCLUDE_CPU_FEATURES_WRAPPER_H_
 
+#include <stdint.h>
+
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
 #endif
 
-#include "typedefs.h"  // NOLINT(build/include)
-
 // List of features in x86.
 typedef enum { kSSE2, kSSE3 } CPUFeature;
 
diff --git a/system_wrappers/include/cpu_info.h b/system_wrappers/include/cpu_info.h
index dbd5d60..ab546c7 100644
--- a/system_wrappers/include/cpu_info.h
+++ b/system_wrappers/include/cpu_info.h
@@ -11,7 +11,7 @@
 #ifndef SYSTEM_WRAPPERS_INCLUDE_CPU_INFO_H_
 #define SYSTEM_WRAPPERS_INCLUDE_CPU_INFO_H_
 
-#include "typedefs.h"  // NOLINT(build/include)
+#include <stdint.h>
 
 namespace webrtc {
 
diff --git a/system_wrappers/include/rtp_to_ntp_estimator.h b/system_wrappers/include/rtp_to_ntp_estimator.h
index 62a79a5..d7009d8 100644
--- a/system_wrappers/include/rtp_to_ntp_estimator.h
+++ b/system_wrappers/include/rtp_to_ntp_estimator.h
@@ -17,7 +17,6 @@
 #include "modules/include/module_common_types_public.h"
 #include "rtc_base/numerics/moving_median_filter.h"
 #include "system_wrappers/include/ntp_time.h"
-#include "typedefs.h"  // NOLINT(build/include)
 
 namespace webrtc {
 // Class for converting an RTP timestamp to the NTP domain in milliseconds.
diff --git a/system_wrappers/source/cpu_features.cc b/system_wrappers/source/cpu_features.cc
index 7417f53..d433a77 100644
--- a/system_wrappers/source/cpu_features.cc
+++ b/system_wrappers/source/cpu_features.cc
@@ -10,13 +10,13 @@
 
 // Parts of this file derived from Chromium's base/cpu.cc.
 
+#include "rtc_base/system/arch.h"
 #include "system_wrappers/include/cpu_features_wrapper.h"
 
 #if defined(WEBRTC_ARCH_X86_FAMILY) && defined(_MSC_VER)
 #include <intrin.h>
 #endif
 
-#include "typedefs.h"  // NOLINT(build/include)
 
 // No CPU feature is available => straight C path.
 int GetCPUInfoNoASM(CPUFeature feature) {
diff --git a/system_wrappers/source/cpu_features_linux.c b/system_wrappers/source/cpu_features_linux.c
index 9c56450..004de5a 100644
--- a/system_wrappers/source/cpu_features_linux.c
+++ b/system_wrappers/source/cpu_features_linux.c
@@ -22,6 +22,7 @@
 #include <errno.h>
 #include <link.h>
 #endif
+#include "rtc_base/system/arch.h"
 #include "system_wrappers/include/cpu_features_wrapper.h"
 
 #if defined(WEBRTC_ARCH_ARM_FAMILY)
diff --git a/system_wrappers/source/event_timer_win.h b/system_wrappers/source/event_timer_win.h
index 0b4dff6..c99f8c6 100644
--- a/system_wrappers/source/event_timer_win.h
+++ b/system_wrappers/source/event_timer_win.h
@@ -11,12 +11,12 @@
 #ifndef SYSTEM_WRAPPERS_SOURCE_EVENT_WIN_H_
 #define SYSTEM_WRAPPERS_SOURCE_EVENT_WIN_H_
 
+#include <stdint.h>
+
 #include <windows.h>
 
 #include "system_wrappers/include/event_wrapper.h"
 
-#include "typedefs.h"  // NOLINT(build/include)
-
 namespace webrtc {
 
 class EventTimerWin : public EventTimerWrapper {
diff --git a/webrtc_apm.cc b/webrtc_apm.cc
index 4985ac1..beba356 100644
--- a/webrtc_apm.cc
+++ b/webrtc_apm.cc
@@ -17,17 +17,27 @@
 		const struct aec_config *config,
 		webrtc::EchoCanceller3Config *aec3_config)
 {
-	aec3_config->delay = {
-		config->delay.default_delay,
-		config->delay.down_sampling_factor,
-		config->delay.num_filters,
-		config->delay.api_call_jitter_blocks,
+	aec3_config->delay.default_delay =
+		config->delay.default_delay;
+	aec3_config->delay.down_sampling_factor =
+		config->delay.down_sampling_factor;
+	aec3_config->delay.num_filters =
+		config->delay.num_filters;
+	aec3_config->delay.api_call_jitter_blocks =
+		config->delay.api_call_jitter_blocks;
+	aec3_config->delay.min_echo_path_delay_blocks =
 		config->delay.min_echo_path_delay_blocks,
-		config->delay.delay_headroom_blocks,
-		config->delay.hysteresis_limit_1_blocks,
+	aec3_config->delay.delay_headroom_blocks =
+		config->delay.delay_headroom_blocks;
+	aec3_config->delay.hysteresis_limit_1_blocks =
+		config->delay.hysteresis_limit_1_blocks;
+	aec3_config->delay.hysteresis_limit_2_blocks =
 		config->delay.hysteresis_limit_2_blocks,
-		config->delay.skew_hysteresis_blocks
-	};
+	aec3_config->delay.skew_hysteresis_blocks =
+		config->delay.skew_hysteresis_blocks;
+	aec3_config->delay.fixed_capture_delay_samples =
+		config->delay.fixed_capture_delay_samples;
+
 	aec3_config->filter.main = {
 		config->filter.main.length_blocks,
 		config->filter.main.leakage_converged,
@@ -54,20 +64,30 @@
 	};
 	aec3_config->filter.config_change_duration_blocks =
 		config->filter.config_change_duration_blocks;
+	aec3_config->filter.initial_state_seconds =
+		config->filter.initial_state_seconds;
+	aec3_config->filter.conservative_initial_phase =
+		static_cast<bool>(config->filter.conservative_initial_phase);
+	aec3_config->filter.enable_shadow_filter_output_usage =
+		static_cast<bool>(
+			config->filter.enable_shadow_filter_output_usage);
 	aec3_config->erle = {
 		config->erle.min,
 		config->erle.max_l,
 		config->erle.max_h,
+		static_cast<bool>(config->erle.onset_detection)
 	};
 	aec3_config->ep_strength = {
 		config->ep_strength.lf,
 		config->ep_strength.mf,
 		config->ep_strength.hf,
 		config->ep_strength.default_len,
+		static_cast<bool>(config->ep_strength.reverb_based_on_render),
 		static_cast<bool>(config->ep_strength.echo_can_saturate),
 		static_cast<bool>(config->ep_strength.bounded_erl)
 	};
 
+	aec3_config->gain_mask.m0 = config->gain_mask.m0;
 	aec3_config->gain_mask.m1 = config->gain_mask.m1;
 	aec3_config->gain_mask.m2 = config->gain_mask.m2;
 	aec3_config->gain_mask.m3 = config->gain_mask.m3;
@@ -100,49 +120,8 @@
 	aec3_config->render_levels = {
 		config->render_levels.active_render_limit,
 		config->render_levels.poor_excitation_render_limit,
+		config->render_levels.poor_excitation_render_limit_ds8,
 	};
-	aec3_config->gain_updates.low_noise = {
-		config->gain_updates.low_noise.max_inc,
-		config->gain_updates.low_noise.max_dec,
-		config->gain_updates.low_noise.rate_inc,
-		config->gain_updates.low_noise.rate_dec,
-		config->gain_updates.low_noise.min_inc,
-		config->gain_updates.low_noise.min_dec,
-	};
-	aec3_config->gain_updates.initial = {
-		config->gain_updates.initial.max_inc,
-		config->gain_updates.initial.max_dec,
-		config->gain_updates.initial.rate_inc,
-		config->gain_updates.initial.rate_dec,
-		config->gain_updates.initial.min_inc,
-		config->gain_updates.initial.min_dec,
-	};
-	aec3_config->gain_updates.normal = {
-		config->gain_updates.normal.max_inc,
-		config->gain_updates.normal.max_dec,
-		config->gain_updates.normal.rate_inc,
-		config->gain_updates.normal.rate_dec,
-		config->gain_updates.normal.min_inc,
-		config->gain_updates.normal.min_dec,
-	};
-	aec3_config->gain_updates.saturation = {
-		config->gain_updates.saturation.max_inc,
-		config->gain_updates.saturation.max_dec,
-		config->gain_updates.saturation.rate_inc,
-		config->gain_updates.saturation.rate_dec,
-		config->gain_updates.saturation.min_inc,
-		config->gain_updates.saturation.min_dec,
-	};
-	aec3_config->gain_updates.nonlinear = {
-		config->gain_updates.nonlinear.max_inc,
-		config->gain_updates.nonlinear.max_dec,
-		config->gain_updates.nonlinear.rate_inc,
-		config->gain_updates.nonlinear.rate_dec,
-		config->gain_updates.nonlinear.min_inc,
-		config->gain_updates.nonlinear.min_dec,
-	};
-	aec3_config->gain_updates.floor_first_increase =
-		config->gain_updates.floor_first_increase;
 
 	aec3_config->echo_removal_control = {
 		{
@@ -169,11 +148,69 @@
 			config->echo_model.render_pre_window_size;
 	echo_model.render_post_window_size =
 			config->echo_model.render_post_window_size;
+	echo_model.render_pre_window_size_init =
+			config->echo_model.render_pre_window_size_init;
+	echo_model.render_post_window_size_init =
+			config->echo_model.render_post_window_size_init;
 	echo_model.nonlinear_hold = config->echo_model.nonlinear_hold;
 	echo_model.nonlinear_release = config->echo_model.nonlinear_release;
 
 	aec3_config->echo_model = echo_model;
 
+	aec3_config->suppressor.normal_tuning.mask_lf.enr_transparent =
+		config->suppressor.normal_tuning.mask_lf.enr_transparent;
+	aec3_config->suppressor.normal_tuning.mask_lf.enr_suppress =
+		config->suppressor.normal_tuning.mask_lf.enr_suppress;
+	aec3_config->suppressor.normal_tuning.mask_lf.emr_transparent =
+		config->suppressor.normal_tuning.mask_lf.emr_transparent;
+	aec3_config->suppressor.normal_tuning.mask_hf.enr_transparent =
+		config->suppressor.normal_tuning.mask_hf.enr_transparent;
+	aec3_config->suppressor.normal_tuning.mask_hf.enr_suppress =
+		config->suppressor.normal_tuning.mask_hf.enr_suppress;
+	aec3_config->suppressor.normal_tuning.mask_hf.emr_transparent =
+		config->suppressor.normal_tuning.mask_hf.emr_transparent;
+	aec3_config->suppressor.normal_tuning.max_inc_factor =
+		config->suppressor.normal_tuning.max_inc_factor;
+	aec3_config->suppressor.normal_tuning.max_dec_factor_lf =
+		config->suppressor.normal_tuning.max_dec_factor_lf;
+
+	aec3_config->suppressor.nearend_tuning.mask_lf.enr_transparent =
+		config->suppressor.nearend_tuning.mask_lf.enr_transparent;
+	aec3_config->suppressor.nearend_tuning.mask_lf.enr_suppress =
+		config->suppressor.nearend_tuning.mask_lf.enr_suppress;
+	aec3_config->suppressor.nearend_tuning.mask_lf.emr_transparent =
+		config->suppressor.nearend_tuning.mask_lf.emr_transparent;
+	aec3_config->suppressor.nearend_tuning.mask_hf.enr_transparent =
+		config->suppressor.nearend_tuning.mask_hf.enr_transparent;
+	aec3_config->suppressor.nearend_tuning.mask_hf.enr_suppress =
+		config->suppressor.nearend_tuning.mask_hf.enr_suppress,
+	aec3_config->suppressor.nearend_tuning.mask_hf.emr_transparent =
+		config->suppressor.nearend_tuning.mask_hf.emr_transparent;
+	aec3_config->suppressor.nearend_tuning.max_inc_factor =
+		config->suppressor.nearend_tuning.max_inc_factor;
+	aec3_config->suppressor.nearend_tuning.max_dec_factor_lf =
+		config->suppressor.nearend_tuning.max_dec_factor_lf;
+
+	aec3_config->suppressor.dominant_nearend_detection.enr_threshold =
+		config->suppressor.dominant_nearend_detection.enr_threshold;
+	aec3_config->suppressor.dominant_nearend_detection.snr_threshold =
+		config->suppressor.dominant_nearend_detection.snr_threshold;
+	aec3_config->suppressor.dominant_nearend_detection.hold_duration =
+		config->suppressor.dominant_nearend_detection.hold_duration;
+	aec3_config->suppressor.dominant_nearend_detection.trigger_threshold =
+		config->suppressor.dominant_nearend_detection.trigger_threshold;
+
+	aec3_config->suppressor.high_bands_suppression.enr_threshold =
+		config->suppressor.high_bands_suppression.enr_threshold;
+	aec3_config->suppressor.high_bands_suppression.max_gain_during_echo =
+		config->suppressor.high_bands_suppression.max_gain_during_echo;
+
+	aec3_config->suppressor.floor_first_increase =
+		config->suppressor.floor_first_increase;
+	aec3_config->suppressor.enforce_transparent =
+		config->suppressor.enforce_transparent;
+	aec3_config->suppressor.enforce_empty_higher_bands =
+		config->suppressor.enforce_empty_higher_bands;
 
 	return 0;
 }
diff --git a/webrtc_apm.h b/webrtc_apm.h
index 31761fa..d32060b 100644
--- a/webrtc_apm.h
+++ b/webrtc_apm.h
@@ -27,6 +27,7 @@
 	size_t hysteresis_limit_1_blocks;
 	size_t hysteresis_limit_2_blocks;
 	size_t skew_hysteresis_blocks;
+	size_t fixed_capture_delay_samples;
 };
 
 struct MainConfiguration {
@@ -49,12 +50,16 @@
 	struct MainConfiguration main_initial;
 	struct ShadowConfiguration shadow_initial;
 	int config_change_duration_blocks;
+	float initial_state_seconds;
+	int conservative_initial_phase;
+	int enable_shadow_filter_output_usage;
 };
 
 struct erle {
 	float min;
 	float max_l;
 	float max_h;
+	int onset_detection;
 };
 
 struct ep_strength {
@@ -101,26 +106,6 @@
 	float poor_excitation_render_limit_ds8;
 };
 
-struct GainChanges {
-	float max_inc;
-	float max_dec;
-	float rate_inc;
-	float rate_dec;
-	float min_inc;
-	float min_dec;
-};
-
-struct gain_updates {
-	struct GainChanges low_noise;
-	struct GainChanges initial;
-	struct GainChanges normal;
-	struct GainChanges saturation;
-	struct GainChanges nonlinear;
-	float max_inc_factor;
-	float max_dec_factor_lf;
-	float floor_first_increase;
-};
-
 struct GainRampup {
 	float initial_gain;
 	float first_non_zero_gain;
@@ -148,16 +133,41 @@
 	float nonlinear_release;
 };
 
+struct masking_thresholds {
+	float enr_transparent;
+	float enr_suppress;
+	float emr_transparent;
+};
+
+struct tuning {
+	struct masking_thresholds mask_lf;
+	struct masking_thresholds mask_hf;
+	float max_inc_factor;
+	float max_dec_factor_lf;
+};
+
+struct dominant_nearend_detection {
+	float enr_threshold;
+	float snr_threshold;
+	int hold_duration;
+	int trigger_threshold;
+};
+
+struct high_bands_suppression {
+	float enr_threshold;
+	float max_gain_during_echo;
+};
+
 struct suppressor {
-	size_t bands_with_reliable_coherence;
 	size_t nearend_average_blocks;
-	float mask_lf_enr_transparent;
-	float mask_lf_enr_suppress;
-	float mask_lf_emr_transparent;
-	float mask_hf_enr_transparent;
-	float mask_hf_enr_suppress;
-	float mask_hf_emr_transparent;
- };
+	struct tuning normal_tuning;
+	struct tuning nearend_tuning;
+	struct dominant_nearend_detection dominant_nearend_detection;
+	struct high_bands_suppression high_bands_suppression;
+	float floor_first_increase;
+	int enforce_transparent;
+	int enforce_empty_higher_bands;
+};
 
 struct aec_config {
 	struct delay delay;
@@ -167,7 +177,6 @@
 	struct mask gain_mask;
 	struct echo_audibility echo_audibility;
 	struct render_levels render_levels;
-	struct gain_updates gain_updates;
 	struct echo_removal_control echo_removal_control;
 	struct echo_model echo_model;
 	struct suppressor suppressor;