diff --git a/webrtc/common_audio/BUILD.gn b/webrtc/common_audio/BUILD.gn
index 4367a0b242..0b94f716a1 100644
--- a/webrtc/common_audio/BUILD.gn
+++ b/webrtc/common_audio/BUILD.gn
@@ -396,6 +396,7 @@ if (rtc_include_tests) {
       ":sinc_resampler",
       "..:webrtc_common",
       "../base:rtc_base_approved",
+      "../base:rtc_base_tests_utils",
       "../system_wrappers",
       "../test:test_main",
       "//testing/gmock",
diff --git a/webrtc/common_audio/smoothing_filter.cc b/webrtc/common_audio/smoothing_filter.cc
index 2ab25981f1..91bcb22a25 100644
--- a/webrtc/common_audio/smoothing_filter.cc
+++ b/webrtc/common_audio/smoothing_filter.cc
@@ -12,30 +12,32 @@
 
 #include <cmath>
 
+#include "webrtc/base/timeutils.h"
+
 namespace webrtc {
 
-SmoothingFilterImpl::SmoothingFilterImpl(int init_time_ms, const Clock* clock)
+SmoothingFilterImpl::SmoothingFilterImpl(int init_time_ms)
     : init_time_ms_(init_time_ms),
       // Duing the initalization time, we use an increasing alpha. Specifically,
       //   alpha(n) = exp(-powf(init_factor_, n)),
       // where |init_factor_| is chosen such that
       //   alpha(init_time_ms_) = exp(-1.0f / init_time_ms_),
-      init_factor_(init_time_ms_ == 0 ? 0.0f : powf(init_time_ms_,
-                                                    -1.0f / init_time_ms_)),
+      init_factor_(init_time_ms_ == 0
+                       ? 0.0f
+                       : powf(init_time_ms_, -1.0f / init_time_ms_)),
       // |init_const_| is to a factor to help the calculation during
       // initialization phase.
       init_const_(init_time_ms_ == 0
                       ? 0.0f
                       : init_time_ms_ -
-                            powf(init_time_ms_, 1.0f - 1.0f / init_time_ms_)),
-      clock_(clock) {
+                            powf(init_time_ms_, 1.0f - 1.0f / init_time_ms_)) {
   UpdateAlpha(init_time_ms_);
 }
 
 SmoothingFilterImpl::~SmoothingFilterImpl() = default;
 
 void SmoothingFilterImpl::AddSample(float sample) {
-  const int64_t now_ms = clock_->TimeInMilliseconds();
+  const int64_t now_ms = rtc::TimeMillis();
 
   if (!init_end_time_ms_) {
     // This is equivalent to assuming the filter has been receiving the same
@@ -55,7 +57,7 @@ rtc::Optional<float> SmoothingFilterImpl::GetAverage() {
     // |init_end_time_ms_| undefined since we have not received any sample.
     return rtc::Optional<float>();
   }
-  ExtrapolateLastSample(clock_->TimeInMilliseconds());
+  ExtrapolateLastSample(rtc::TimeMillis());
   return rtc::Optional<float>(state_);
 }
 
diff --git a/webrtc/common_audio/smoothing_filter.h b/webrtc/common_audio/smoothing_filter.h
index 4a0efd99b6..39bc56a48d 100644
--- a/webrtc/common_audio/smoothing_filter.h
+++ b/webrtc/common_audio/smoothing_filter.h
@@ -40,7 +40,7 @@ class SmoothingFilterImpl final : public SmoothingFilter {
   // earlier samples quickly. After the initialization period, the time constant
   // will be set to |init_time_ms| first and can be changed through
   // |SetTimeConstantMs|.
-  SmoothingFilterImpl(int init_time_ms, const Clock* clock);
+  explicit SmoothingFilterImpl(int init_time_ms);
   ~SmoothingFilterImpl() override;
 
   void AddSample(float sample) override;
@@ -57,7 +57,6 @@ class SmoothingFilterImpl final : public SmoothingFilter {
   const int init_time_ms_;
   const float init_factor_;
   const float init_const_;
-  const Clock* const clock_;
 
   rtc::Optional<int64_t> init_end_time_ms_;
   float last_sample_;
diff --git a/webrtc/common_audio/smoothing_filter_unittest.cc b/webrtc/common_audio/smoothing_filter_unittest.cc
index 9ffbf3c5f5..5075545f13 100644
--- a/webrtc/common_audio/smoothing_filter_unittest.cc
+++ b/webrtc/common_audio/smoothing_filter_unittest.cc
@@ -11,6 +11,7 @@
 #include <cmath>
 #include <memory>
 
+#include "webrtc/base/fakeclock.h"
 #include "webrtc/common_audio/smoothing_filter.h"
 #include "webrtc/test/gtest.h"
 
@@ -22,18 +23,14 @@ constexpr float kMaxAbsError = 1e-5f;
 constexpr int64_t kClockInitialTime = 123456;
 
 struct SmoothingFilterStates {
-  std::unique_ptr<SimulatedClock> simulated_clock;
-  std::unique_ptr<SmoothingFilterImpl> smoothing_filter;
+  explicit SmoothingFilterStates(int init_time_ms)
+      : smoothing_filter(init_time_ms) {
+    fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kClockInitialTime));
+  }
+  rtc::ScopedFakeClock fake_clock;
+  SmoothingFilterImpl smoothing_filter;
 };
 
-SmoothingFilterStates CreateSmoothingFilter(int init_time_ms) {
-  SmoothingFilterStates states;
-  states.simulated_clock.reset(new SimulatedClock(kClockInitialTime));
-  states.smoothing_filter.reset(
-      new SmoothingFilterImpl(init_time_ms, states.simulated_clock.get()));
-  return states;
-}
-
 // This function does the following:
 //   1. Add a sample to filter at current clock,
 //   2. Advance the clock by |advance_time_ms|,
@@ -43,9 +40,10 @@ void CheckOutput(SmoothingFilterStates* states,
                  float sample,
                  int advance_time_ms,
                  float expected_ouput) {
-  states->smoothing_filter->AddSample(sample);
-  states->simulated_clock->AdvanceTimeMilliseconds(advance_time_ms);
-  auto output = states->smoothing_filter->GetAverage();
+  states->smoothing_filter.AddSample(sample);
+  states->fake_clock.AdvanceTime(
+      rtc::TimeDelta::FromMilliseconds(advance_time_ms));
+  auto output = states->smoothing_filter.GetAverage();
   EXPECT_TRUE(output);
   EXPECT_NEAR(expected_ouput, *output, kMaxAbsError);
 }
@@ -54,8 +52,8 @@ void CheckOutput(SmoothingFilterStates* states,
 
 TEST(SmoothingFilterTest, NoOutputWhenNoSampleAdded) {
   constexpr int kInitTimeMs = 100;
-  auto states = CreateSmoothingFilter(kInitTimeMs);
-  EXPECT_FALSE(states.smoothing_filter->GetAverage());
+  SmoothingFilterStates states(kInitTimeMs);
+  EXPECT_FALSE(states.smoothing_filter.GetAverage());
 }
 
 // Python script to calculate the reference values used in this test.
@@ -104,7 +102,7 @@ TEST(SmoothingFilterTest, NoOutputWhenNoSampleAdded) {
 //   print filter.state
 TEST(SmoothingFilterTest, CheckBehaviorAroundInitTime) {
   constexpr int kInitTimeMs = 795;
-  auto states = CreateSmoothingFilter(kInitTimeMs);
+  SmoothingFilterStates states(kInitTimeMs);
   CheckOutput(&states, 1.0f, 500, 1.0f);
   CheckOutput(&states, 0.5f, 100, 0.680562264029f);
   CheckOutput(&states, 1.0f, 100, 0.794207139813f);
@@ -116,50 +114,51 @@ TEST(SmoothingFilterTest, CheckBehaviorAroundInitTime) {
 
 TEST(SmoothingFilterTest, InitTimeEqualsZero) {
   constexpr int kInitTimeMs = 0;
-  auto states = CreateSmoothingFilter(kInitTimeMs);
+  SmoothingFilterStates states(kInitTimeMs);
   CheckOutput(&states, 1.0f, 1, 1.0f);
   CheckOutput(&states, 0.5f, 1, 0.5f);
 }
 
 TEST(SmoothingFilterTest, InitTimeEqualsOne) {
   constexpr int kInitTimeMs = 1;
-  auto states = CreateSmoothingFilter(kInitTimeMs);
+  SmoothingFilterStates states(kInitTimeMs);
   CheckOutput(&states, 1.0f, 1, 1.0f);
   CheckOutput(&states, 0.5f, 1, 1.0f * exp(-1.0f) + (1.0f - exp(-1.0f)) * 0.5f);
 }
 
 TEST(SmoothingFilterTest, GetAverageOutputsEmptyBeforeFirstSample) {
   constexpr int kInitTimeMs = 100;
-  auto states = CreateSmoothingFilter(kInitTimeMs);
-  EXPECT_FALSE(states.smoothing_filter->GetAverage());
+  SmoothingFilterStates states(kInitTimeMs);
+  EXPECT_FALSE(states.smoothing_filter.GetAverage());
   constexpr float kFirstSample = 1.2345f;
-  states.smoothing_filter->AddSample(kFirstSample);
+  states.smoothing_filter.AddSample(kFirstSample);
   EXPECT_EQ(rtc::Optional<float>(kFirstSample),
-            states.smoothing_filter->GetAverage());
+            states.smoothing_filter.GetAverage());
 }
 
 TEST(SmoothingFilterTest, CannotChangeTimeConstantDuringInitialization) {
   constexpr int kInitTimeMs = 100;
-  auto states = CreateSmoothingFilter(kInitTimeMs);
-  states.smoothing_filter->AddSample(0.0);
+  SmoothingFilterStates states(kInitTimeMs);
+  states.smoothing_filter.AddSample(0.0);
 
   // During initialization, |SetTimeConstantMs| does not take effect.
-  states.simulated_clock->AdvanceTimeMilliseconds(kInitTimeMs - 1);
-  states.smoothing_filter->AddSample(0.0);
+  states.fake_clock.AdvanceTime(
+      rtc::TimeDelta::FromMilliseconds(kInitTimeMs - 1));
+  states.smoothing_filter.AddSample(0.0);
 
-  EXPECT_FALSE(states.smoothing_filter->SetTimeConstantMs(kInitTimeMs * 2));
-  EXPECT_NE(exp(-1.0f / (kInitTimeMs * 2)), states.smoothing_filter->alpha());
+  EXPECT_FALSE(states.smoothing_filter.SetTimeConstantMs(kInitTimeMs * 2));
+  EXPECT_NE(exp(-1.0f / (kInitTimeMs * 2)), states.smoothing_filter.alpha());
 
-  states.simulated_clock->AdvanceTimeMilliseconds(1);
-  states.smoothing_filter->AddSample(0.0);
+  states.fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(1));
+  states.smoothing_filter.AddSample(0.0);
   // When initialization finishes, the time constant should be come
   // |kInitTimeConstantMs|.
-  EXPECT_FLOAT_EQ(exp(-1.0f / kInitTimeMs), states.smoothing_filter->alpha());
+  EXPECT_FLOAT_EQ(exp(-1.0f / kInitTimeMs), states.smoothing_filter.alpha());
 
   // After initialization, |SetTimeConstantMs| takes effect.
-  EXPECT_TRUE(states.smoothing_filter->SetTimeConstantMs(kInitTimeMs * 2));
+  EXPECT_TRUE(states.smoothing_filter.SetTimeConstantMs(kInitTimeMs * 2));
   EXPECT_FLOAT_EQ(exp(-1.0f / (kInitTimeMs * 2)),
-                  states.smoothing_filter->alpha());
+                  states.smoothing_filter.alpha());
 }
 
 }  // namespace webrtc
diff --git a/webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.cc b/webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.cc
index 7408df2c17..d41a0381fc 100644
--- a/webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.cc
+++ b/webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.cc
@@ -13,6 +13,7 @@
 #include <utility>
 
 #include "webrtc/base/logging.h"
+#include "webrtc/base/timeutils.h"
 
 namespace webrtc {
 
@@ -22,8 +23,7 @@ constexpr float kEventLogMinBitrateChangeFraction = 0.25;
 constexpr float kEventLogMinPacketLossChangeFraction = 0.5;
 }  // namespace
 
-AudioNetworkAdaptorImpl::Config::Config()
-    : event_log(nullptr), clock(nullptr){};
+AudioNetworkAdaptorImpl::Config::Config() : event_log(nullptr){};
 
 AudioNetworkAdaptorImpl::Config::~Config() = default;
 
@@ -119,8 +119,7 @@ AudioEncoderRuntimeConfig AudioNetworkAdaptorImpl::GetEncoderRuntimeConfig() {
     controller->MakeDecision(&config);
 
   if (debug_dump_writer_)
-    debug_dump_writer_->DumpEncoderRuntimeConfig(
-        config, config_.clock->TimeInMilliseconds());
+    debug_dump_writer_->DumpEncoderRuntimeConfig(config, rtc::TimeMillis());
 
   if (event_log_writer_)
     event_log_writer_->MaybeLogEncoderConfig(config);
@@ -138,8 +137,7 @@ void AudioNetworkAdaptorImpl::StopDebugDump() {
 
 void AudioNetworkAdaptorImpl::DumpNetworkMetrics() {
   if (debug_dump_writer_)
-    debug_dump_writer_->DumpNetworkMetrics(last_metrics_,
-                                           config_.clock->TimeInMilliseconds());
+    debug_dump_writer_->DumpNetworkMetrics(last_metrics_, rtc::TimeMillis());
 }
 
 void AudioNetworkAdaptorImpl::UpdateNetworkMetrics(
diff --git a/webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.h b/webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.h
index f7bf70d21e..358a01472b 100644
--- a/webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.h
+++ b/webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.h
@@ -19,7 +19,6 @@
 #include "webrtc/modules/audio_coding/audio_network_adaptor/debug_dump_writer.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/event_log_writer.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
-#include "webrtc/system_wrappers/include/clock.h"
 
 namespace webrtc {
 
@@ -31,7 +30,6 @@ class AudioNetworkAdaptorImpl final : public AudioNetworkAdaptor {
     Config();
     ~Config();
     RtcEventLog* event_log;
-    const Clock* clock;
   };
 
   AudioNetworkAdaptorImpl(
diff --git a/webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc b/webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc
index 53334c6250..a8cecb334b 100644
--- a/webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc
+++ b/webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc
@@ -11,6 +11,7 @@
 #include <utility>
 #include <vector>
 
+#include "webrtc/base/fakeclock.h"
 #include "webrtc/logging/rtc_event_log/mock/mock_rtc_event_log.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_controller.h"
@@ -55,7 +56,6 @@ MATCHER_P(EncoderRuntimeConfigIs, config, "") {
 struct AudioNetworkAdaptorStates {
   std::unique_ptr<AudioNetworkAdaptorImpl> audio_network_adaptor;
   std::vector<std::unique_ptr<MockController>> mock_controllers;
-  std::unique_ptr<SimulatedClock> simulated_clock;
   std::unique_ptr<MockRtcEventLog> event_log;
   MockDebugDumpWriter* mock_debug_dump_writer;
 };
@@ -80,7 +80,6 @@ AudioNetworkAdaptorStates CreateAudioNetworkAdaptor() {
   EXPECT_CALL(*controller_manager, GetSortedControllers(_))
       .WillRepeatedly(Return(controllers));
 
-  states.simulated_clock.reset(new SimulatedClock(kClockInitialTimeMs * 1000));
   states.event_log.reset(new NiceMock<MockRtcEventLog>());
 
   auto debug_dump_writer =
@@ -89,7 +88,6 @@ AudioNetworkAdaptorStates CreateAudioNetworkAdaptor() {
   states.mock_debug_dump_writer = debug_dump_writer.get();
 
   AudioNetworkAdaptorImpl::Config config;
-  config.clock = states.simulated_clock.get();
   config.event_log = states.event_log.get();
   // AudioNetworkAdaptorImpl governs the lifetime of controller manager.
   states.audio_network_adaptor.reset(new AudioNetworkAdaptorImpl(
@@ -180,8 +178,9 @@ TEST(AudioNetworkAdaptorImplTest,
 
 TEST(AudioNetworkAdaptorImplTest,
      DumpEncoderRuntimeConfigIsCalledOnGetEncoderRuntimeConfig) {
+  rtc::ScopedFakeClock fake_clock;
+  fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kClockInitialTimeMs));
   auto states = CreateAudioNetworkAdaptor();
-
   AudioEncoderRuntimeConfig config;
   config.bitrate_bps = rtc::Optional<int>(32000);
   config.enable_fec = rtc::Optional<bool>(true);
@@ -197,6 +196,9 @@ TEST(AudioNetworkAdaptorImplTest,
 
 TEST(AudioNetworkAdaptorImplTest,
      DumpNetworkMetricsIsCalledOnSetNetworkMetrics) {
+  rtc::ScopedFakeClock fake_clock;
+  fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kClockInitialTimeMs));
+
   auto states = CreateAudioNetworkAdaptor();
 
   constexpr int kBandwidth = 16000;
@@ -214,14 +216,14 @@ TEST(AudioNetworkAdaptorImplTest,
               DumpNetworkMetrics(NetworkMetricsIs(check), timestamp_check));
   states.audio_network_adaptor->SetUplinkBandwidth(kBandwidth);
 
-  states.simulated_clock->AdvanceTimeMilliseconds(100);
+  fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(100));
   timestamp_check += 100;
   check.uplink_packet_loss_fraction = rtc::Optional<float>(kPacketLoss);
   EXPECT_CALL(*states.mock_debug_dump_writer,
               DumpNetworkMetrics(NetworkMetricsIs(check), timestamp_check));
   states.audio_network_adaptor->SetUplinkPacketLossFraction(kPacketLoss);
 
-  states.simulated_clock->AdvanceTimeMilliseconds(50);
+  fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(50));
   timestamp_check += 50;
   check.uplink_recoverable_packet_loss_fraction =
       rtc::Optional<float>(kRecoverablePacketLoss);
@@ -230,21 +232,21 @@ TEST(AudioNetworkAdaptorImplTest,
   states.audio_network_adaptor->SetUplinkRecoverablePacketLossFraction(
       kRecoverablePacketLoss);
 
-  states.simulated_clock->AdvanceTimeMilliseconds(200);
+  fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(200));
   timestamp_check += 200;
   check.rtt_ms = rtc::Optional<int>(kRtt);
   EXPECT_CALL(*states.mock_debug_dump_writer,
               DumpNetworkMetrics(NetworkMetricsIs(check), timestamp_check));
   states.audio_network_adaptor->SetRtt(kRtt);
 
-  states.simulated_clock->AdvanceTimeMilliseconds(150);
+  fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(150));
   timestamp_check += 150;
   check.target_audio_bitrate_bps = rtc::Optional<int>(kTargetAudioBitrate);
   EXPECT_CALL(*states.mock_debug_dump_writer,
               DumpNetworkMetrics(NetworkMetricsIs(check), timestamp_check));
   states.audio_network_adaptor->SetTargetAudioBitrate(kTargetAudioBitrate);
 
-  states.simulated_clock->AdvanceTimeMilliseconds(50);
+  fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(50));
   timestamp_check += 50;
   check.overhead_bytes_per_packet = rtc::Optional<size_t>(kOverhead);
   EXPECT_CALL(*states.mock_debug_dump_writer,
diff --git a/webrtc/modules/audio_coding/audio_network_adaptor/controller_manager.cc b/webrtc/modules/audio_coding/audio_network_adaptor/controller_manager.cc
index 1e6aff1746..ce4e2f984a 100644
--- a/webrtc/modules/audio_coding/audio_network_adaptor/controller_manager.cc
+++ b/webrtc/modules/audio_coding/audio_network_adaptor/controller_manager.cc
@@ -14,6 +14,7 @@
 #include <utility>
 
 #include "webrtc/base/ignore_wundef.h"
+#include "webrtc/base/timeutils.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/bitrate_controller.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/channel_controller.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/dtx_controller.h"
@@ -21,7 +22,6 @@
 #include "webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/frame_length_controller.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/util/threshold_curve.h"
-#include "webrtc/system_wrappers/include/clock.h"
 
 #ifdef WEBRTC_AUDIO_NETWORK_ADAPTOR_DEBUG_DUMP
 RTC_PUSH_IGNORING_WUNDEF()
@@ -41,8 +41,7 @@ namespace {
 
 std::unique_ptr<FecControllerPlrBased> CreateFecControllerPlrBased(
     const audio_network_adaptor::config::FecController& config,
-    bool initial_fec_enabled,
-    const Clock* clock) {
+    bool initial_fec_enabled) {
   RTC_CHECK(config.has_fec_enabling_threshold());
   RTC_CHECK(config.has_fec_disabling_threshold());
   RTC_CHECK(config.has_time_constant_ms());
@@ -70,7 +69,7 @@ std::unique_ptr<FecControllerPlrBased> CreateFecControllerPlrBased(
                          fec_disabling_threshold.low_bandwidth_packet_loss(),
                          fec_disabling_threshold.high_bandwidth_bps(),
                          fec_disabling_threshold.high_bandwidth_packet_loss()),
-          config.time_constant_ms(), clock)));
+          config.time_constant_ms())));
 }
 
 std::unique_ptr<FecControllerRplrBased> CreateFecControllerRplrBased(
@@ -186,11 +185,9 @@ std::unique_ptr<BitrateController> CreateBitrateController(
 }  // namespace
 
 ControllerManagerImpl::Config::Config(int min_reordering_time_ms,
-                                      float min_reordering_squared_distance,
-                                      const Clock* clock)
+                                      float min_reordering_squared_distance)
     : min_reordering_time_ms(min_reordering_time_ms),
-      min_reordering_squared_distance(min_reordering_squared_distance),
-      clock(clock) {}
+      min_reordering_squared_distance(min_reordering_squared_distance) {}
 
 ControllerManagerImpl::Config::~Config() = default;
 
@@ -203,8 +200,7 @@ std::unique_ptr<ControllerManager> ControllerManagerImpl::Create(
     int initial_frame_length_ms,
     int initial_bitrate_bps,
     bool initial_fec_enabled,
-    bool initial_dtx_enabled,
-    const Clock* clock) {
+    bool initial_dtx_enabled) {
 #ifdef WEBRTC_AUDIO_NETWORK_ADAPTOR_DEBUG_DUMP
   audio_network_adaptor::config::ControllerManager controller_manager_config;
   controller_manager_config.ParseFromString(config_string);
@@ -218,7 +214,7 @@ std::unique_ptr<ControllerManager> ControllerManagerImpl::Create(
     switch (controller_config.controller_case()) {
       case audio_network_adaptor::config::Controller::kFecController:
         controller = CreateFecControllerPlrBased(
-            controller_config.fec_controller(), initial_fec_enabled, clock);
+            controller_config.fec_controller(), initial_fec_enabled);
         break;
       case audio_network_adaptor::config::Controller::kFecControllerRplrBased:
         controller = CreateFecControllerRplrBased(
@@ -262,7 +258,7 @@ std::unique_ptr<ControllerManager> ControllerManagerImpl::Create(
   return std::unique_ptr<ControllerManagerImpl>(new ControllerManagerImpl(
       ControllerManagerImpl::Config(
           controller_manager_config.min_reordering_time_ms(),
-          controller_manager_config.min_reordering_squared_distance(), clock),
+          controller_manager_config.min_reordering_squared_distance()),
       std::move(controllers), chracteristic_points));
 #else
   RTC_NOTREACHED();
@@ -299,7 +295,7 @@ ControllerManagerImpl::~ControllerManagerImpl() = default;
 
 std::vector<Controller*> ControllerManagerImpl::GetSortedControllers(
     const Controller::NetworkMetrics& metrics) {
-  int64_t now_ms = config_.clock->TimeInMilliseconds();
+  int64_t now_ms = rtc::TimeMillis();
 
   if (!metrics.uplink_bandwidth_bps || !metrics.uplink_packet_loss_fraction)
     return sorted_controllers_;
diff --git a/webrtc/modules/audio_coding/audio_network_adaptor/controller_manager.h b/webrtc/modules/audio_coding/audio_network_adaptor/controller_manager.h
index 0124cc2fcc..81abe24d89 100644
--- a/webrtc/modules/audio_coding/audio_network_adaptor/controller_manager.h
+++ b/webrtc/modules/audio_coding/audio_network_adaptor/controller_manager.h
@@ -21,8 +21,6 @@
 
 namespace webrtc {
 
-class Clock;
-
 class ControllerManager {
  public:
   virtual ~ControllerManager() = default;
@@ -37,16 +35,13 @@ class ControllerManager {
 class ControllerManagerImpl final : public ControllerManager {
  public:
   struct Config {
-    Config(int min_reordering_time_ms,
-           float min_reordering_squared_distance,
-           const Clock* clock);
+    Config(int min_reordering_time_ms, float min_reordering_squared_distance);
     ~Config();
     // Least time since last reordering for a new reordering to be made.
     int min_reordering_time_ms;
     // Least squared distance from last scoring point for a new reordering to be
     // made.
     float min_reordering_squared_distance;
-    const Clock* clock;
   };
 
   static std::unique_ptr<ControllerManager> Create(
@@ -58,8 +53,7 @@ class ControllerManagerImpl final : public ControllerManager {
       int initial_frame_length_ms,
       int initial_bitrate_bps,
       bool initial_fec_enabled,
-      bool initial_dtx_enabled,
-      const Clock* clock);
+      bool initial_dtx_enabled);
 
   explicit ControllerManagerImpl(const Config& config);
 
diff --git a/webrtc/modules/audio_coding/audio_network_adaptor/controller_manager_unittest.cc b/webrtc/modules/audio_coding/audio_network_adaptor/controller_manager_unittest.cc
index 6d1434a80f..2e8625484a 100644
--- a/webrtc/modules/audio_coding/audio_network_adaptor/controller_manager_unittest.cc
+++ b/webrtc/modules/audio_coding/audio_network_adaptor/controller_manager_unittest.cc
@@ -10,11 +10,11 @@
 
 #include <utility>
 
+#include "webrtc/base/fakeclock.h"
 #include "webrtc/base/ignore_wundef.h"
 #include "webrtc/base/protobuf_utils.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/controller_manager.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_controller.h"
-#include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/test/gtest.h"
 
 #ifdef WEBRTC_AUDIO_NETWORK_ADAPTOR_DEBUG_DUMP
@@ -47,12 +47,9 @@ constexpr int kMaxUplinkBandwidthBps = 120000;
 constexpr int kMinBandwithChangeBps =
     (kMaxUplinkBandwidthBps - kMinUplinkBandwidthBps) / kFactor;
 
-constexpr int64_t kClockInitialTime = 123456789;
-
 struct ControllerManagerStates {
   std::unique_ptr<ControllerManager> controller_manager;
   std::vector<MockController*> mock_controllers;
-  std::unique_ptr<SimulatedClock> simulated_clock;
 };
 
 ControllerManagerStates CreateControllerManager() {
@@ -75,11 +72,9 @@ ControllerManagerStates CreateControllerManager() {
       std::make_pair(kChracteristicBandwithBps[1],
                      kChracteristicPacketLossFraction[1]);
 
-  states.simulated_clock.reset(new SimulatedClock(kClockInitialTime));
   states.controller_manager.reset(new ControllerManagerImpl(
       ControllerManagerImpl::Config(kMinReorderingTimeMs,
-                                    kMinReorderingSquareDistance,
-                                    states.simulated_clock.get()),
+                                    kMinReorderingSquareDistance),
       std::move(controllers), chracteristic_points));
   return states;
 }
@@ -147,12 +142,14 @@ TEST(ControllerManagerTest, ControllersWithCharPointDependOnNetworkMetrics) {
 }
 
 TEST(ControllerManagerTest, DoNotReorderBeforeMinReordingTime) {
+  rtc::ScopedFakeClock fake_clock;
   auto states = CreateControllerManager();
   CheckControllersOrder(
       &states, rtc::Optional<int>(kChracteristicBandwithBps[0]),
       rtc::Optional<float>(kChracteristicPacketLossFraction[0]),
       {kNumControllers - 2, kNumControllers - 1, 0, 1});
-  states.simulated_clock->AdvanceTimeMilliseconds(kMinReorderingTimeMs - 1);
+  fake_clock.AdvanceTime(
+      rtc::TimeDelta::FromMilliseconds(kMinReorderingTimeMs - 1));
   // Move uplink bandwidth and packet loss fraction to the other controller's
   // characteristic point, which would cause controller manager to reorder the
   // controllers if time had reached min reordering time.
@@ -163,6 +160,7 @@ TEST(ControllerManagerTest, DoNotReorderBeforeMinReordingTime) {
 }
 
 TEST(ControllerManagerTest, ReorderBeyondMinReordingTimeAndMinDistance) {
+  rtc::ScopedFakeClock fake_clock;
   auto states = CreateControllerManager();
   constexpr int kBandwidthBps =
       (kChracteristicBandwithBps[0] + kChracteristicBandwithBps[1]) / 2;
@@ -174,7 +172,8 @@ TEST(ControllerManagerTest, ReorderBeyondMinReordingTimeAndMinDistance) {
   CheckControllersOrder(&states, rtc::Optional<int>(kBandwidthBps),
                         rtc::Optional<float>(kPacketLossFraction),
                         {kNumControllers - 2, kNumControllers - 1, 0, 1});
-  states.simulated_clock->AdvanceTimeMilliseconds(kMinReorderingTimeMs);
+  fake_clock.AdvanceTime(
+      rtc::TimeDelta::FromMilliseconds(kMinReorderingTimeMs));
   // Then let network metrics move a little towards the other controller.
   CheckControllersOrder(
       &states, rtc::Optional<int>(kBandwidthBps - kMinBandwithChangeBps - 1),
@@ -183,6 +182,7 @@ TEST(ControllerManagerTest, ReorderBeyondMinReordingTimeAndMinDistance) {
 }
 
 TEST(ControllerManagerTest, DoNotReorderIfNetworkMetricsChangeTooSmall) {
+  rtc::ScopedFakeClock fake_clock;
   auto states = CreateControllerManager();
   constexpr int kBandwidthBps =
       (kChracteristicBandwithBps[0] + kChracteristicBandwithBps[1]) / 2;
@@ -194,7 +194,8 @@ TEST(ControllerManagerTest, DoNotReorderIfNetworkMetricsChangeTooSmall) {
   CheckControllersOrder(&states, rtc::Optional<int>(kBandwidthBps),
                         rtc::Optional<float>(kPacketLossFraction),
                         {kNumControllers - 2, kNumControllers - 1, 0, 1});
-  states.simulated_clock->AdvanceTimeMilliseconds(kMinReorderingTimeMs);
+  fake_clock.AdvanceTime(
+      rtc::TimeDelta::FromMilliseconds(kMinReorderingTimeMs));
   // Then let network metrics move a little towards the other controller.
   CheckControllersOrder(
       &states, rtc::Optional<int>(kBandwidthBps - kMinBandwithChangeBps + 1),
@@ -276,14 +277,12 @@ constexpr int kMinBitrateBps = 6000;
 ControllerManagerStates CreateControllerManager(
     const ProtoString& config_string) {
   ControllerManagerStates states;
-  states.simulated_clock.reset(new SimulatedClock(kClockInitialTime));
   constexpr size_t kNumEncoderChannels = 2;
   const std::vector<int> encoder_frame_lengths_ms = {20, 60};
   states.controller_manager = ControllerManagerImpl::Create(
       config_string, kNumEncoderChannels, encoder_frame_lengths_ms,
       kMinBitrateBps, kIntialChannelsToEncode, kInitialFrameLengthMs,
-      kInitialBitrateBps, kInitialFecEnabled, kInitialDtxEnabled,
-      states.simulated_clock.get());
+      kInitialBitrateBps, kInitialFecEnabled, kInitialDtxEnabled);
   return states;
 }
 
@@ -361,6 +360,7 @@ TEST(ControllerManagerTest, CreateFromConfigStringAndCheckDefaultOrder) {
 }
 
 TEST(ControllerManagerTest, CreateFromConfigStringAndCheckReordering) {
+  rtc::ScopedFakeClock fake_clock;
   audio_network_adaptor::config::ControllerManager config;
   config.set_min_reordering_time_ms(kMinReorderingTimeMs);
   config.set_min_reordering_squared_distance(kMinReorderingSquareDistance);
@@ -399,7 +399,8 @@ TEST(ControllerManagerTest, CreateFromConfigStringAndCheckReordering) {
       rtc::Optional<int>(kChracteristicBandwithBps[1]);
   metrics.uplink_packet_loss_fraction =
       rtc::Optional<float>(kChracteristicPacketLossFraction[1]);
-  states.simulated_clock->AdvanceTimeMilliseconds(kMinReorderingTimeMs - 1);
+  fake_clock.AdvanceTime(
+      rtc::TimeDelta::FromMilliseconds(kMinReorderingTimeMs - 1));
   controllers = states.controller_manager->GetSortedControllers(metrics);
   // Should not reorder since min reordering time is not met.
   CheckControllersOrder(controllers,
@@ -408,7 +409,7 @@ TEST(ControllerManagerTest, CreateFromConfigStringAndCheckReordering) {
                             ControllerType::CHANNEL, ControllerType::DTX,
                             ControllerType::BIT_RATE});
 
-  states.simulated_clock->AdvanceTimeMilliseconds(1);
+  fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(1));
   controllers = states.controller_manager->GetSortedControllers(metrics);
   // Reorder now.
   CheckControllersOrder(controllers,
diff --git a/webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.cc b/webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.cc
index c39457dc5a..d9b259b350 100644
--- a/webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.cc
+++ b/webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.cc
@@ -41,13 +41,11 @@ FecControllerPlrBased::Config::Config(
     bool initial_fec_enabled,
     const ThresholdCurve& fec_enabling_threshold,
     const ThresholdCurve& fec_disabling_threshold,
-    int time_constant_ms,
-    const Clock* clock)
+    int time_constant_ms)
     : initial_fec_enabled(initial_fec_enabled),
       fec_enabling_threshold(fec_enabling_threshold),
       fec_disabling_threshold(fec_disabling_threshold),
-      time_constant_ms(time_constant_ms),
-      clock(clock) {}
+      time_constant_ms(time_constant_ms) {}
 
 FecControllerPlrBased::FecControllerPlrBased(
     const Config& config,
@@ -64,8 +62,7 @@ FecControllerPlrBased::FecControllerPlrBased(const Config& config)
           webrtc::field_trial::FindFullName("UseTwccPlrForAna") == "Enabled"
               ? std::unique_ptr<NullSmoothingFilter>(new NullSmoothingFilter())
               : std::unique_ptr<SmoothingFilter>(
-                    new SmoothingFilterImpl(config.time_constant_ms,
-                                            config.clock))) {}
+                    new SmoothingFilterImpl(config.time_constant_ms))) {}
 
 FecControllerPlrBased::~FecControllerPlrBased() = default;
 
diff --git a/webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.h b/webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.h
index 52d026589f..3913abbdaa 100644
--- a/webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.h
+++ b/webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.h
@@ -36,13 +36,11 @@ class FecControllerPlrBased final : public Controller {
     Config(bool initial_fec_enabled,
            const ThresholdCurve& fec_enabling_threshold,
            const ThresholdCurve& fec_disabling_threshold,
-           int time_constant_ms,
-           const Clock* clock);
+           int time_constant_ms);
     bool initial_fec_enabled;
     ThresholdCurve fec_enabling_threshold;
     ThresholdCurve fec_disabling_threshold;
     int time_constant_ms;
-    const Clock* clock;
   };
 
   // Dependency injection for testing.
diff --git a/webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based_unittest.cc b/webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based_unittest.cc
index 0830479e08..fceae874f3 100644
--- a/webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based_unittest.cc
+++ b/webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based_unittest.cc
@@ -63,7 +63,7 @@ FecControllerPlrBasedTestStates CreateFecControllerPlrBased(
                          kEnablingBandwidthHigh, kEnablingPacketLossAtHighBw),
           ThresholdCurve(kDisablingBandwidthLow, kDisablingPacketLossAtLowBw,
                          kDisablingBandwidthHigh, kDisablingPacketLossAtHighBw),
-          0, nullptr),
+          0),
       std::move(mock_smoothing_filter)));
   return states;
 }
@@ -319,7 +319,7 @@ TEST(FecControllerPlrBasedTest, CheckBehaviorOnSpecialCurves) {
                          kEnablingBandwidthHigh, kEnablingPacketLossAtHighBw),
           ThresholdCurve(kDisablingBandwidthLow, kDisablingPacketLossAtLowBw,
                          kDisablingBandwidthHigh, kDisablingPacketLossAtHighBw),
-          0, nullptr),
+          0),
       std::move(mock_smoothing_filter)));
 
   UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthLow - 1),
@@ -361,7 +361,7 @@ TEST(FecControllerPlrBasedDeathTest, InvalidConfig) {
               ThresholdCurve(
                   kDisablingBandwidthLow, kDisablingPacketLossAtLowBw,
                   kDisablingBandwidthHigh, kDisablingPacketLossAtHighBw),
-              0, nullptr),
+              0),
           std::move(mock_smoothing_filter))),
       "Check failed");
 }
diff --git a/webrtc/modules/audio_coding/codecs/audio_encoder.cc b/webrtc/modules/audio_coding/codecs/audio_encoder.cc
index c9d85f8605..92d1b253e0 100644
--- a/webrtc/modules/audio_coding/codecs/audio_encoder.cc
+++ b/webrtc/modules/audio_coding/codecs/audio_encoder.cc
@@ -66,8 +66,7 @@ rtc::ArrayView<std::unique_ptr<AudioEncoder>>
 AudioEncoder::ReclaimContainedEncoders() { return nullptr; }
 
 bool AudioEncoder::EnableAudioNetworkAdaptor(const std::string& config_string,
-                                             RtcEventLog* event_log,
-                                             const Clock* clock) {
+                                             RtcEventLog* event_log) {
   return false;
 }
 
diff --git a/webrtc/modules/audio_coding/codecs/audio_encoder.h b/webrtc/modules/audio_coding/codecs/audio_encoder.h
index b58f964f52..bdbbf2d45b 100644
--- a/webrtc/modules/audio_coding/codecs/audio_encoder.h
+++ b/webrtc/modules/audio_coding/codecs/audio_encoder.h
@@ -164,8 +164,7 @@ class AudioEncoder {
 
   // Enables audio network adaptor. Returns true if successful.
   virtual bool EnableAudioNetworkAdaptor(const std::string& config_string,
-                                         RtcEventLog* event_log,
-                                         const Clock* clock);
+                                         RtcEventLog* event_log);
 
   // Disables audio network adaptor.
   virtual void DisableAudioNetworkAdaptor();
diff --git a/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.cc b/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.cc
index 6f6e39e327..4c9ab6db62 100644
--- a/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.cc
+++ b/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.cc
@@ -284,9 +284,8 @@ AudioEncoderOpus::Config AudioEncoderOpus::CreateConfig(
 
 class AudioEncoderOpus::PacketLossFractionSmoother {
  public:
-  explicit PacketLossFractionSmoother(const Clock* clock)
-      : clock_(clock),
-        last_sample_time_ms_(clock_->TimeInMilliseconds()),
+  explicit PacketLossFractionSmoother()
+      : last_sample_time_ms_(rtc::TimeMillis()),
         smoother_(kAlphaForPacketLossFractionSmoother) {}
 
   // Gets the smoothed packet loss fraction.
@@ -297,14 +296,13 @@ class AudioEncoderOpus::PacketLossFractionSmoother {
 
   // Add new observation to the packet loss fraction smoother.
   void AddSample(float packet_loss_fraction) {
-    int64_t now_ms = clock_->TimeInMilliseconds();
+    int64_t now_ms = rtc::TimeMillis();
     smoother_.Apply(static_cast<float>(now_ms - last_sample_time_ms_),
                     packet_loss_fraction);
     last_sample_time_ms_ = now_ms;
   }
 
  private:
-  const Clock* const clock_;
   int64_t last_sample_time_ms_;
 
   // An exponential filter is used to smooth the packet loss fraction.
@@ -366,21 +364,19 @@ AudioEncoderOpus::AudioEncoderOpus(
           "WebRTC-SendSideBwe-WithOverhead")),
       packet_loss_rate_(0.0),
       inst_(nullptr),
-      packet_loss_fraction_smoother_(new PacketLossFractionSmoother(
-          config.clock)),
+      packet_loss_fraction_smoother_(new PacketLossFractionSmoother()),
       audio_network_adaptor_creator_(
           audio_network_adaptor_creator
               ? std::move(audio_network_adaptor_creator)
               : [this](const ProtoString& config_string,
-                       RtcEventLog* event_log,
-                       const Clock* clock) {
+                       RtcEventLog* event_log) {
                   return DefaultAudioNetworkAdaptorCreator(config_string,
-                                                           event_log, clock);
+                                                           event_log);
               }),
       bitrate_smoother_(bitrate_smoother
           ? std::move(bitrate_smoother) : std::unique_ptr<SmoothingFilter>(
               // We choose 5sec as initial time constant due to empirical data.
-              new SmoothingFilterImpl(5000, config.clock))) {
+              new SmoothingFilterImpl(5000))) {
   RTC_CHECK(RecreateEncoderInstance(config));
 }
 
@@ -464,10 +460,9 @@ void AudioEncoderOpus::SetMaxPlaybackRate(int frequency_hz) {
 
 bool AudioEncoderOpus::EnableAudioNetworkAdaptor(
     const std::string& config_string,
-    RtcEventLog* event_log,
-    const Clock* clock) {
+    RtcEventLog* event_log) {
   audio_network_adaptor_ =
-      audio_network_adaptor_creator_(config_string, event_log, clock);
+      audio_network_adaptor_creator_(config_string, event_log);
   return audio_network_adaptor_.get() != nullptr;
 }
 
@@ -723,17 +718,15 @@ void AudioEncoderOpus::ApplyAudioNetworkAdaptor() {
 std::unique_ptr<AudioNetworkAdaptor>
 AudioEncoderOpus::DefaultAudioNetworkAdaptorCreator(
     const ProtoString& config_string,
-    RtcEventLog* event_log,
-    const Clock* clock) const {
+    RtcEventLog* event_log) const {
   AudioNetworkAdaptorImpl::Config config;
-  config.clock = clock;
   config.event_log = event_log;
   return std::unique_ptr<AudioNetworkAdaptor>(new AudioNetworkAdaptorImpl(
       config,
       ControllerManagerImpl::Create(
           config_string, NumChannels(), supported_frame_lengths_ms(),
           kOpusMinBitrateBps, num_channels_to_encode_, next_frame_length_ms_,
-          GetTargetBitrate(), config_.fec_enabled, GetDtx(), clock)));
+          GetTargetBitrate(), config_.fec_enabled, GetDtx())));
 }
 
 void AudioEncoderOpus::MaybeUpdateUplinkBandwidth() {
diff --git a/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.h b/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.h
index e9672ed120..6ea9aede81 100644
--- a/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.h
+++ b/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.h
@@ -69,7 +69,6 @@ class AudioEncoderOpus final : public AudioEncoder {
     int complexity_threshold_window_bps = 1500;
     bool dtx_enabled = false;
     std::vector<int> supported_frame_lengths_ms;
-    const Clock* clock = Clock::GetRealTimeClock();
     int uplink_bandwidth_update_interval_ms = 200;
 
    private:
@@ -87,8 +86,7 @@ class AudioEncoderOpus final : public AudioEncoder {
 
   using AudioNetworkAdaptorCreator =
       std::function<std::unique_ptr<AudioNetworkAdaptor>(const std::string&,
-                                                         RtcEventLog*,
-                                                         const Clock*)>;
+                                                         RtcEventLog*)>;
   AudioEncoderOpus(
       const Config& config,
       AudioNetworkAdaptorCreator&& audio_network_adaptor_creator = nullptr,
@@ -121,8 +119,7 @@ class AudioEncoderOpus final : public AudioEncoder {
   bool SetApplication(Application application) override;
   void SetMaxPlaybackRate(int frequency_hz) override;
   bool EnableAudioNetworkAdaptor(const std::string& config_string,
-                                 RtcEventLog* event_log,
-                                 const Clock* clock) override;
+                                 RtcEventLog* event_log) override;
   void DisableAudioNetworkAdaptor() override;
   void OnReceivedUplinkPacketLossFraction(
       float uplink_packet_loss_fraction) override;
@@ -169,8 +166,7 @@ class AudioEncoderOpus final : public AudioEncoder {
   void ApplyAudioNetworkAdaptor();
   std::unique_ptr<AudioNetworkAdaptor> DefaultAudioNetworkAdaptorCreator(
       const ProtoString& config_string,
-      RtcEventLog* event_log,
-      const Clock* clock) const;
+      RtcEventLog* event_log) const;
 
   void MaybeUpdateUplinkBandwidth();
 
diff --git a/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc b/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc
index 55d3c9204b..788d799a11 100644
--- a/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc
+++ b/webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc
@@ -23,7 +23,6 @@
 #include "webrtc/test/gmock.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/test/testsupport/fileutils.h"
-#include "webrtc/system_wrappers/include/clock.h"
 
 namespace webrtc {
 using ::testing::NiceMock;
@@ -56,7 +55,7 @@ struct AudioEncoderOpusStates {
   std::shared_ptr<MockAudioNetworkAdaptor*> mock_audio_network_adaptor;
   MockSmoothingFilter* mock_bitrate_smoother;
   std::unique_ptr<AudioEncoderOpus> encoder;
-  std::unique_ptr<SimulatedClock> simulated_clock;
+  std::unique_ptr<rtc::ScopedFakeClock> fake_clock;
   AudioEncoderOpus::Config config;
 };
 
@@ -64,21 +63,22 @@ AudioEncoderOpusStates CreateCodec(size_t num_channels) {
   AudioEncoderOpusStates states;
   states.mock_audio_network_adaptor =
       std::make_shared<MockAudioNetworkAdaptor*>(nullptr);
-
+  states.fake_clock.reset(new rtc::ScopedFakeClock());
+  states.fake_clock->SetTimeMicros(kInitialTimeUs);
   std::weak_ptr<MockAudioNetworkAdaptor*> mock_ptr(
       states.mock_audio_network_adaptor);
-  AudioEncoderOpus::AudioNetworkAdaptorCreator creator = [mock_ptr](
-      const std::string&, RtcEventLog* event_log, const Clock*) {
-    std::unique_ptr<MockAudioNetworkAdaptor> adaptor(
-        new NiceMock<MockAudioNetworkAdaptor>());
-    EXPECT_CALL(*adaptor, Die());
-    if (auto sp = mock_ptr.lock()) {
-      *sp = adaptor.get();
-    } else {
-      RTC_NOTREACHED();
-    }
-    return adaptor;
-  };
+  AudioEncoderOpus::AudioNetworkAdaptorCreator creator =
+      [mock_ptr](const std::string&, RtcEventLog* event_log) {
+        std::unique_ptr<MockAudioNetworkAdaptor> adaptor(
+            new NiceMock<MockAudioNetworkAdaptor>());
+        EXPECT_CALL(*adaptor, Die());
+        if (auto sp = mock_ptr.lock()) {
+          *sp = adaptor.get();
+        } else {
+          RTC_NOTREACHED();
+        }
+        return adaptor;
+      };
 
   CodecInst codec_inst = kDefaultOpusSettings;
   codec_inst.channels = num_channels;
@@ -86,8 +86,6 @@ AudioEncoderOpusStates CreateCodec(size_t num_channels) {
   std::unique_ptr<MockSmoothingFilter> bitrate_smoother(
       new MockSmoothingFilter());
   states.mock_bitrate_smoother = bitrate_smoother.get();
-  states.simulated_clock.reset(new SimulatedClock(kInitialTimeUs));
-  states.config.clock = states.simulated_clock.get();
 
   states.encoder.reset(new AudioEncoderOpus(states.config, std::move(creator),
                                             std::move(bitrate_smoother)));
@@ -244,7 +242,8 @@ void TestSetPacketLossRate(AudioEncoderOpusStates* states,
   constexpr int64_t kSampleIntervalMs = 184198;
   for (float loss : losses) {
     states->encoder->OnReceivedUplinkPacketLossFraction(loss);
-    states->simulated_clock->AdvanceTimeMilliseconds(kSampleIntervalMs);
+    states->fake_clock->AdvanceTime(
+        rtc::TimeDelta::FromMilliseconds(kSampleIntervalMs));
     EXPECT_FLOAT_EQ(expected_return, states->encoder->packet_loss_rate());
   }
 }
@@ -291,7 +290,7 @@ TEST(AudioEncoderOpusTest, SetReceiverFrameLengthRange) {
 TEST(AudioEncoderOpusTest,
      InvokeAudioNetworkAdaptorOnReceivedUplinkPacketLossFraction) {
   auto states = CreateCodec(2);
-  states.encoder->EnableAudioNetworkAdaptor("", nullptr, nullptr);
+  states.encoder->EnableAudioNetworkAdaptor("", nullptr);
 
   auto config = CreateEncoderRuntimeConfig();
   EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig())
@@ -308,7 +307,7 @@ TEST(AudioEncoderOpusTest,
 
 TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedUplinkBandwidth) {
   auto states = CreateCodec(2);
-  states.encoder->EnableAudioNetworkAdaptor("", nullptr, nullptr);
+  states.encoder->EnableAudioNetworkAdaptor("", nullptr);
 
   auto config = CreateEncoderRuntimeConfig();
   EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig())
@@ -330,7 +329,7 @@ TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedUplinkBandwidth) {
 
 TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedRtt) {
   auto states = CreateCodec(2);
-  states.encoder->EnableAudioNetworkAdaptor("", nullptr, nullptr);
+  states.encoder->EnableAudioNetworkAdaptor("", nullptr);
 
   auto config = CreateEncoderRuntimeConfig();
   EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig())
@@ -346,7 +345,7 @@ TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedRtt) {
 
 TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedOverhead) {
   auto states = CreateCodec(2);
-  states.encoder->EnableAudioNetworkAdaptor("", nullptr, nullptr);
+  states.encoder->EnableAudioNetworkAdaptor("", nullptr);
 
   auto config = CreateEncoderRuntimeConfig();
   EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig())
@@ -376,7 +375,8 @@ TEST(AudioEncoderOpusTest,
   states.encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_1);
   EXPECT_FLOAT_EQ(0.01f, states.encoder->packet_loss_rate());
 
-  states.simulated_clock->AdvanceTimeMilliseconds(kSecondSampleTimeMs);
+  states.fake_clock->AdvanceTime(
+      rtc::TimeDelta::FromMilliseconds(kSecondSampleTimeMs));
   states.encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_2);
 
   // Now the output of packet loss fraction smoother should be
@@ -475,7 +475,7 @@ TEST(AudioEncoderOpusTest, ConfigComplexityAdaptation) {
 
 TEST(AudioEncoderOpusTest, EmptyConfigDoesNotAffectEncoderSettings) {
   auto states = CreateCodec(2);
-  states.encoder->EnableAudioNetworkAdaptor("", nullptr, nullptr);
+  states.encoder->EnableAudioNetworkAdaptor("", nullptr);
 
   auto config = CreateEncoderRuntimeConfig();
   AudioEncoderRuntimeConfig empty_config;
@@ -494,9 +494,8 @@ TEST(AudioEncoderOpusTest, EmptyConfigDoesNotAffectEncoderSettings) {
 }
 
 TEST(AudioEncoderOpusTest, UpdateUplinkBandwidthInAudioNetworkAdaptor) {
-  rtc::ScopedFakeClock fake_clock;
   auto states = CreateCodec(2);
-  states.encoder->EnableAudioNetworkAdaptor("", nullptr, nullptr);
+  states.encoder->EnableAudioNetworkAdaptor("", nullptr);
   std::array<int16_t, 480 * 2> audio;
   audio.fill(0);
   rtc::Buffer encoded;
@@ -509,7 +508,7 @@ TEST(AudioEncoderOpusTest, UpdateUplinkBandwidthInAudioNetworkAdaptor) {
   // Repeat update uplink bandwidth tests.
   for (int i = 0; i < 5; i++) {
     // Don't update till it is time to update again.
-    fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(
+    states.fake_clock->AdvanceTime(rtc::TimeDelta::FromMilliseconds(
         states.config.uplink_bandwidth_update_interval_ms - 1));
     states.encoder->Encode(
         0, rtc::ArrayView<const int16_t>(audio.data(), audio.size()), &encoded);
@@ -518,7 +517,7 @@ TEST(AudioEncoderOpusTest, UpdateUplinkBandwidthInAudioNetworkAdaptor) {
     EXPECT_CALL(*states.mock_bitrate_smoother, GetAverage())
         .WillOnce(Return(rtc::Optional<float>(40000)));
     EXPECT_CALL(**states.mock_audio_network_adaptor, SetUplinkBandwidth(40000));
-    fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(1));
+    states.fake_clock->AdvanceTime(rtc::TimeDelta::FromMilliseconds(1));
     states.encoder->Encode(
         0, rtc::ArrayView<const int16_t>(audio.data(), audio.size()), &encoded);
   }
diff --git a/webrtc/modules/audio_coding/codecs/opus/opus_complexity_unittest.cc b/webrtc/modules/audio_coding/codecs/opus/opus_complexity_unittest.cc
index f242aa48c7..b19991251b 100644
--- a/webrtc/modules/audio_coding/codecs/opus/opus_complexity_unittest.cc
+++ b/webrtc/modules/audio_coding/codecs/opus/opus_complexity_unittest.cc
@@ -9,12 +9,12 @@
  */
 
 #include "webrtc/base/format_macros.h"
+#include "webrtc/base/timeutils.h"
 #include "webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.h"
 #include "webrtc/modules/audio_coding/neteq/tools/audio_loop.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/test/testsupport/fileutils.h"
 #include "webrtc/test/testsupport/perf_test.h"
-#include "webrtc/system_wrappers/include/clock.h"
 
 namespace webrtc {
 
@@ -35,8 +35,7 @@ int64_t RunComplexityTest(const AudioEncoderOpus::Config& config) {
   EXPECT_TRUE(audio_loop.Init(kInputFileName, kMaxLoopLengthSamples,
                               kInputBlockSizeSamples));
   // Encode.
-  webrtc::Clock* clock = webrtc::Clock::GetRealTimeClock();
-  const int64_t start_time_ms = clock->TimeInMilliseconds();
+  const int64_t start_time_ms = rtc::TimeMillis();
   AudioEncoder::EncodedInfo info;
   rtc::Buffer encoded(500);
   uint32_t rtp_timestamp = 0u;
@@ -45,7 +44,7 @@ int64_t RunComplexityTest(const AudioEncoderOpus::Config& config) {
     info = encoder.Encode(rtp_timestamp, audio_loop.GetNextBlock(), &encoded);
     rtp_timestamp += kInputBlockSizeSamples;
   }
-  return clock->TimeInMilliseconds() - start_time_ms;
+  return rtc::TimeMillis() - start_time_ms;
 }
 }  // namespace
 
diff --git a/webrtc/voice_engine/channel.cc b/webrtc/voice_engine/channel.cc
index a7a45e67a7..b5e1cad73b 100644
--- a/webrtc/voice_engine/channel.cc
+++ b/webrtc/voice_engine/channel.cc
@@ -1611,8 +1611,8 @@ bool Channel::EnableAudioNetworkAdaptor(const std::string& config_string) {
   bool success = false;
   audio_coding_->ModifyEncoder([&](std::unique_ptr<AudioEncoder>* encoder) {
     if (*encoder) {
-      success = (*encoder)->EnableAudioNetworkAdaptor(
-          config_string, event_log_proxy_.get(), Clock::GetRealTimeClock());
+      success = (*encoder)->EnableAudioNetworkAdaptor(config_string,
+                                                      event_log_proxy_.get());
     }
   });
   return success;