Replace Clock with timeutils in AudioEncoder.

webrtc/modules/audio_coding/audio_network_adaptor/controller_manager_unittest.cc

 /*
  *  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.
  */
 
 #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
 RTC_PUSH_IGNORING_WUNDEF()
 #ifdef WEBRTC_ANDROID_PLATFORM_BUILD
 #include "external/webrtc/webrtc/modules/audio_coding/audio_network_adaptor/config.pb.h"
 #else
 #include "webrtc/modules/audio_coding/audio_network_adaptor/config.pb.h"
 #endif
 RTC_POP_IGNORING_WUNDEF()
@@ skipping 12 matching lines @@
 constexpr int kFactor = 100;
 constexpr float kMinReorderingSquareDistance = 1.0f / kFactor / kFactor;
 
 // |kMinUplinkBandwidthBps| and |kMaxUplinkBandwidthBps| are copied from
 // controller_manager.cc
 constexpr int kMinUplinkBandwidthBps = 0;
 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() {
   ControllerManagerStates states;
   std::vector<std::unique_ptr<Controller>> controllers;
   std::map<const Controller*, std::pair<int, float>> chracteristic_points;
   for (size_t i = 0; i < kNumControllers; ++i) {
     auto controller =
         std::unique_ptr<MockController>(new NiceMock<MockController>());
     EXPECT_CALL(*controller, Die());
     states.mock_controllers.push_back(controller.get());
     controllers.push_back(std::move(controller));
   }
 
   // Assign characteristic points to the last two controllers.
   chracteristic_points[states.mock_controllers[kNumControllers - 2]] =
       std::make_pair(kChracteristicBandwithBps[0],
                      kChracteristicPacketLossFraction[0]);
   chracteristic_points[states.mock_controllers[kNumControllers - 1]] =
       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;
 }
 
 // |expected_order| contains the expected indices of all controllers in the
 // vector of controllers returned by GetSortedControllers(). A negative index
 // means that we do not care about its exact place, but we do check that it
 // exists in the vector.
 void CheckControllersOrder(
     ControllerManagerStates* states,
@@ skipping 47 matching lines @@
 
 TEST(ControllerManagerTest, ControllersWithCharPointDependOnNetworkMetrics) {
   auto states = CreateControllerManager();
   CheckControllersOrder(
       &states, rtc::Optional<int>(kChracteristicBandwithBps[1]),
       rtc::Optional<float>(kChracteristicPacketLossFraction[1]),
       {kNumControllers - 2, kNumControllers - 1, 1, 0});
 }
 
 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.
   CheckControllersOrder(
       &states, rtc::Optional<int>(kChracteristicBandwithBps[1]),
       rtc::Optional<float>(kChracteristicPacketLossFraction[1]),
       {kNumControllers - 2, kNumControllers - 1, 0, 1});
 }
 
 TEST(ControllerManagerTest, ReorderBeyondMinReordingTimeAndMinDistance) {
+  rtc::ScopedFakeClock fake_clock;
   auto states = CreateControllerManager();
   constexpr int kBandwidthBps =
       (kChracteristicBandwithBps[0] + kChracteristicBandwithBps[1]) / 2;
   constexpr float kPacketLossFraction = (kChracteristicPacketLossFraction[0] +
                                          kChracteristicPacketLossFraction[1]) /
                                         2.0f;
   // Set network metrics to be in the middle between the characteristic points
   // of two controllers.
   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),
       rtc::Optional<float>(kPacketLossFraction),
       {kNumControllers - 2, kNumControllers - 1, 1, 0});
 }
 
 TEST(ControllerManagerTest, DoNotReorderIfNetworkMetricsChangeTooSmall) {
+  rtc::ScopedFakeClock fake_clock;
   auto states = CreateControllerManager();
   constexpr int kBandwidthBps =
       (kChracteristicBandwithBps[0] + kChracteristicBandwithBps[1]) / 2;
   constexpr float kPacketLossFraction = (kChracteristicPacketLossFraction[0] +
                                          kChracteristicPacketLossFraction[1]) /
                                         2.0f;
   // Set network metrics to be in the middle between the characteristic points
   // of two controllers.
   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),
       rtc::Optional<float>(kPacketLossFraction),
       {kNumControllers - 2, kNumControllers - 1, 0, 1});
 }
 
 #ifdef WEBRTC_AUDIO_NETWORK_ADAPTOR_DEBUG_DUMP
 
 namespace {
@@ skipping 61 matching lines @@
 constexpr int kInitialBitrateBps = 24000;
 constexpr size_t kIntialChannelsToEncode = 1;
 constexpr bool kInitialDtxEnabled = true;
 constexpr bool kInitialFecEnabled = true;
 constexpr int kInitialFrameLengthMs = 60;
 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;
 }
 
 enum class ControllerType : int8_t {
   FEC,
   CHANNEL,
   DTX,
   FRAME_LENGTH,
   BIT_RATE
 };
@@ skipping 57 matching lines @@
 
   auto controllers = states.controller_manager->GetSortedControllers(metrics);
   CheckControllersOrder(
       controllers,
       std::vector<ControllerType>{
           ControllerType::FEC, ControllerType::CHANNEL, ControllerType::DTX,
           ControllerType::FRAME_LENGTH, ControllerType::BIT_RATE});
 }
 
 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);
 
   AddChannelControllerConfig(&config);
 
   // Internally associated with characteristic point 0.
   AddFecControllerConfig(&config);
 
   AddDtxControllerConfig(&config);
@@ skipping 18 matching lines @@
   CheckControllersOrder(controllers,
                         std::vector<ControllerType>{
                             ControllerType::FEC, ControllerType::FRAME_LENGTH,
                             ControllerType::CHANNEL, ControllerType::DTX,
                             ControllerType::BIT_RATE});
 
   metrics.uplink_bandwidth_bps =
       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,
                         std::vector<ControllerType>{
                             ControllerType::FEC, ControllerType::FRAME_LENGTH,
                             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,
                         std::vector<ControllerType>{
                             ControllerType::FRAME_LENGTH, ControllerType::FEC,
                             ControllerType::CHANNEL, ControllerType::DTX,
                             ControllerType::BIT_RATE});
 }
 #endif  // WEBRTC_AUDIO_NETWORK_ADAPTOR_DEBUG_DUMP
 
 }  // namespace webrtc