Replace Clock with timeutils in AudioEncoder.

webrtc/common_audio/smoothing_filter_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 <cmath>
 #include <memory>
 
+#include "webrtc/base/fakeclock.h"
 #include "webrtc/common_audio/smoothing_filter.h"
 #include "webrtc/test/gtest.h"
 
 namespace webrtc {
 
 namespace {
 
 constexpr float kMaxAbsError = 1e-5f;
 constexpr int64_t kClockInitialTime = 123456;
 
 struct SmoothingFilterStates {
-  std::unique_ptr<SimulatedClock> simulated_clock;
+  std::unique_ptr<rtc::ScopedFakeClock> fake_clock;

[kwiberg-webrtc, 2017/04/11 12:18:38]

This doesn't look quite right. IIUC the intention is that you should put
ScopedFakeClock on the stack. (It should work to do it this way too, but it's
more complicated than necessary.)

[michaelt, 2017/04/11 14:11:13]

I think you are right that this class was meant to be on the stack.
But in terms of these tests i think the code would get more complicated when i
created the ScopedFakeClock for each test on the stack.
Because of:
a) I would have to set the init time each time after creating it.
b) I would have to pass it separately to the CheckOutput function.

[kwiberg-webrtc, 2017/04/11 16:46:57]

OK. But could you at least get rid of the unique_ptr and store the
ScopedFakeClock directly in the struct?

[michaelt, 2017/04/12 07:17:57]

Done

   std::unique_ptr<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()));
+  states.fake_clock.reset(new rtc::ScopedFakeClock());
+  states.fake_clock->AdvanceTime(
+      rtc::TimeDelta::FromMilliseconds(kClockInitialTime));
+  states.smoothing_filter.reset(new SmoothingFilterImpl(init_time_ms));
   return states;
 }
 
 // This function does the following:
 //   1. Add a sample to filter at current clock,
 //   2. Advance the clock by |advance_time_ms|,
 //   3. Get the output of both SmoothingFilter and verify that it equals to an
 //      expected value.
 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);
+  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);
 }
 
 }  // namespace
 
 TEST(SmoothingFilterTest, NoOutputWhenNoSampleAdded) {
   constexpr int kInitTimeMs = 100;
   auto states = CreateSmoothingFilter(kInitTimeMs);
@@ skipping 79 matching lines @@
   EXPECT_EQ(rtc::Optional<float>(kFirstSample),
             states.smoothing_filter->GetAverage());
 }
 
 TEST(SmoothingFilterTest, CannotChangeTimeConstantDuringInitialization) {
   constexpr int kInitTimeMs = 100;
   auto states = CreateSmoothingFilter(kInitTimeMs);
   states.smoothing_filter->AddSample(0.0);
 
   // During initialization, |SetTimeConstantMs| does not take effect.
-  states.simulated_clock->AdvanceTimeMilliseconds(kInitTimeMs - 1);
+  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());
 
-  states.simulated_clock->AdvanceTimeMilliseconds(1);
+  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());
 
   // After initialization, |SetTimeConstantMs| takes effect.
   EXPECT_TRUE(states.smoothing_filter->SetTimeConstantMs(kInitTimeMs * 2));
   EXPECT_FLOAT_EQ(exp(-1.0f / (kInitTimeMs * 2)),
                   states.smoothing_filter->alpha());
 }
 
 }  // namespace webrtc