Replace Clock with timeutils in AudioEncoder.

webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc

 /*
  *  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 <array>
 #include <memory>
 #include <utility>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/fakeclock.h"
 #include "webrtc/common_audio/mocks/mock_smoothing_filter.h"
 #include "webrtc/common_types.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_audio_network_adaptor.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/field_trial.h"
 #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;
 using ::testing::Return;
 
 namespace {
 
 const CodecInst kDefaultOpusSettings = {105, "opus", 48000, 960, 1, 32000};
 constexpr int64_t kInitialTimeUs = 12345678;
 
@@ skipping 12 matching lines @@
 AudioEncoderOpus::Config CreateConfigWithParameters(
     const SdpAudioFormat::Parameters& params) {
   SdpAudioFormat format("opus", 48000, 2, params);
   return AudioEncoderOpus::CreateConfig(0, format);
 }
 
 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;
 };
 
 AudioEncoderOpusStates CreateCodec(size_t num_channels) {
   AudioEncoderOpusStates states;
   states.mock_audio_network_adaptor =
       std::make_shared<MockAudioNetworkAdaptor*>(nullptr);
 
   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;
   states.config = CreateConfig(codec_inst);
   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.fake_clock.reset(new rtc::ScopedFakeClock());
+  states.fake_clock->SetTimeMicros(kInitialTimeUs);
 
   states.encoder.reset(new AudioEncoderOpus(states.config, std::move(creator),
                                             std::move(bitrate_smoother)));
   return states;
 }
 
 AudioEncoderRuntimeConfig CreateEncoderRuntimeConfig() {
   constexpr int kBitrate = 40000;
   constexpr int kFrameLength = 60;
   constexpr bool kEnableFec = true;
@@ skipping 136 matching lines @@
 // of them.
 void TestSetPacketLossRate(AudioEncoderOpusStates* states,
                            const std::vector<float>& losses,
                            float expected_return) {
   // |kSampleIntervalMs| is chosen to ease the calculation since
   // 0.9999 ^ 184198 = 1e-8. Which minimizes the effect of
   // PacketLossFractionSmoother used in AudioEncoderOpus.
   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());
   }
 }
 
 }  // namespace
 
 TEST(AudioEncoderOpusTest, PacketLossRateOptimized) {
   auto states = CreateCodec(1);
   auto I = [](float a, float b) { return IntervalSteps(a, b, 10); };
   constexpr float eps = 1e-8f;
@@ skipping 26 matching lines @@
   states.encoder->SetReceiverFrameLengthRange(0, 12345);
   states.encoder->SetReceiverFrameLengthRange(21, 60);
   EXPECT_THAT(states.encoder->supported_frame_lengths_ms(), ElementsAre(60));
   states.encoder->SetReceiverFrameLengthRange(20, 59);
   EXPECT_THAT(states.encoder->supported_frame_lengths_ms(), ElementsAre(20));
 }
 
 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())
       .WillOnce(Return(config));
 
   // Since using mock audio network adaptor, any packet loss fraction is fine.
   constexpr float kUplinkPacketLoss = 0.1f;
   EXPECT_CALL(**states.mock_audio_network_adaptor,
               SetUplinkPacketLossFraction(kUplinkPacketLoss));
   states.encoder->OnReceivedUplinkPacketLossFraction(kUplinkPacketLoss);
 
   CheckEncoderRuntimeConfig(states.encoder.get(), config);
 }
 
 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())
       .WillOnce(Return(config));
 
   // Since using mock audio network adaptor, any target audio bitrate is fine.
   constexpr int kTargetAudioBitrate = 30000;
   constexpr int64_t kProbingIntervalMs = 3000;
   EXPECT_CALL(**states.mock_audio_network_adaptor,
               SetTargetAudioBitrate(kTargetAudioBitrate));
   EXPECT_CALL(*states.mock_bitrate_smoother,
               SetTimeConstantMs(kProbingIntervalMs * 4));
   EXPECT_CALL(*states.mock_bitrate_smoother, AddSample(kTargetAudioBitrate));
   states.encoder->OnReceivedUplinkBandwidth(
       kTargetAudioBitrate, rtc::Optional<int64_t>(kProbingIntervalMs));
 
   CheckEncoderRuntimeConfig(states.encoder.get(), config);
 }
 
 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())
       .WillOnce(Return(config));
 
   // Since using mock audio network adaptor, any rtt is fine.
   constexpr int kRtt = 30;
   EXPECT_CALL(**states.mock_audio_network_adaptor, SetRtt(kRtt));
   states.encoder->OnReceivedRtt(kRtt);
 
   CheckEncoderRuntimeConfig(states.encoder.get(), config);
 }
 
 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())
       .WillOnce(Return(config));
 
   // Since using mock audio network adaptor, any overhead is fine.
   constexpr size_t kOverhead = 64;
   EXPECT_CALL(**states.mock_audio_network_adaptor, SetOverhead(kOverhead));
   states.encoder->OnReceivedOverhead(kOverhead);
 
   CheckEncoderRuntimeConfig(states.encoder.get(), config);
 }
 
 TEST(AudioEncoderOpusTest,
      PacketLossFractionSmoothedOnSetUplinkPacketLossFraction) {
   auto states = CreateCodec(2);
 
   // The values are carefully chosen so that if no smoothing is made, the test
   // will fail.
   constexpr float kPacketLossFraction_1 = 0.02f;
   constexpr float kPacketLossFraction_2 = 0.198f;
   // |kSecondSampleTimeMs| is chosen to ease the calculation since
   // 0.9999 ^ 6931 = 0.5.
   constexpr int64_t kSecondSampleTimeMs = 6931;
 
   // First time, no filtering.
   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
   // (0.02 + 0.198) / 2 = 0.109, which reach the threshold for the optimized
   // packet loss rate to increase to 0.05. If no smoothing has been made, the
   // optimized packet loss rate should have been increase to 0.1.
   EXPECT_FLOAT_EQ(0.05f, states.encoder->packet_loss_rate());
 }
 
 TEST(AudioEncoderOpusTest, DoNotInvokeSetTargetBitrateIfOverheadUnknown) {
@@ skipping 78 matching lines @@
   config.bitrate_bps = rtc::Optional<int>(12500);
   EXPECT_EQ(rtc::Optional<int>(), config.GetNewComplexity());
 
   // Bitrate above hysteresis window. Expect lower complexity.
   config.bitrate_bps = rtc::Optional<int>(14001);
   EXPECT_EQ(rtc::Optional<int>(6), config.GetNewComplexity());
 }
 
 TEST(AudioEncoderOpusTest, EmptyConfigDoesNotAffectEncoderSettings) {
   auto states = CreateCodec(2);
-  states.encoder->EnableAudioNetworkAdaptor("", nullptr, nullptr);
+  states.encoder->EnableAudioNetworkAdaptor("", nullptr);
 
   auto config = CreateEncoderRuntimeConfig();
   AudioEncoderRuntimeConfig empty_config;
 
   EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig())
       .WillOnce(Return(config))
       .WillOnce(Return(empty_config));
 
   constexpr size_t kOverhead = 64;
   EXPECT_CALL(**states.mock_audio_network_adaptor, SetOverhead(kOverhead))
       .Times(2);
   states.encoder->OnReceivedOverhead(kOverhead);
   states.encoder->OnReceivedOverhead(kOverhead);
 
   CheckEncoderRuntimeConfig(states.encoder.get(), config);
 }
 
 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;
   EXPECT_CALL(*states.mock_bitrate_smoother, GetAverage())
       .WillOnce(Return(rtc::Optional<float>(50000)));
   EXPECT_CALL(**states.mock_audio_network_adaptor, SetUplinkBandwidth(50000));
   states.encoder->Encode(
       0, rtc::ArrayView<const int16_t>(audio.data(), audio.size()), &encoded);
 
   // 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);
 
     // Update when it is time to update.
     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);
   }
 }
 
 TEST(AudioEncoderOpusTest, EncodeAtMinBitrate) {
   auto states = CreateCodec(1);
   constexpr int kNumPacketsToEncode = 2;
   auto audio_frames =
       Create10msAudioBlocks(states.encoder, kNumPacketsToEncode * 20);
@@ skipping 209 matching lines @@
   EXPECT_EQ(24001, config.max_playback_rate_hz);
   EXPECT_EQ(32000, config.bitrate_bps);
 
   config = CreateConfigWithParameters({{"maxplaybackrate", "24001"},
                                        {"stereo", "1"}});
   EXPECT_EQ(24001, config.max_playback_rate_hz);
   EXPECT_EQ(64000, config.bitrate_bps);
 }
 
 }  // namespace webrtc