diff --git a/video/receive_statistics_proxy2_unittest.cc b/video/receive_statistics_proxy2_unittest.cc index 0ad02fb194..45adff8eb6 100644 --- a/video/receive_statistics_proxy2_unittest.cc +++ b/video/receive_statistics_proxy2_unittest.cc @@ -18,6 +18,8 @@ #include "absl/types/optional.h" #include "api/scoped_refptr.h" +#include "api/units/frequency.h" +#include "api/units/time_delta.h" #include "api/video/i420_buffer.h" #include "api/video/video_frame.h" #include "api/video/video_frame_buffer.h" @@ -25,14 +27,14 @@ #include "rtc_base/thread.h" #include "system_wrappers/include/metrics.h" #include "test/gtest.h" -#include "test/run_loop.h" #include "test/scoped_key_value_config.h" +#include "test/time_controller/simulated_time_controller.h" #include "video/video_receive_stream2.h" namespace webrtc { namespace internal { namespace { -const int64_t kFreqOffsetProcessIntervalInMs = 40000; +const TimeDelta kFreqOffsetProcessInterval = TimeDelta::Seconds(40); const uint32_t kRemoteSsrc = 456; const int kMinRequiredSamples = 200; const int kWidth = 1280; @@ -42,10 +44,11 @@ const int kHeight = 720; // TODO(sakal): ReceiveStatisticsProxy is lacking unittesting. class ReceiveStatisticsProxy2Test : public ::testing::Test { public: - ReceiveStatisticsProxy2Test() : fake_clock_(1234) { + ReceiveStatisticsProxy2Test() : time_controller_(Timestamp::Millis(1234)) { metrics::Reset(); - statistics_proxy_.reset(new ReceiveStatisticsProxy( - kRemoteSsrc, &fake_clock_, loop_.task_queue())); + statistics_proxy_.reset( + new ReceiveStatisticsProxy(kRemoteSsrc, time_controller_.GetClock(), + time_controller_.GetMainThread())); } ~ReceiveStatisticsProxy2Test() override { statistics_proxy_.reset(); } @@ -53,14 +56,14 @@ class ReceiveStatisticsProxy2Test : public ::testing::Test { protected: // Convenience method to avoid too many explict flushes. VideoReceiveStreamInterface::Stats FlushAndGetStats() { - loop_.Flush(); + time_controller_.AdvanceTime(TimeDelta::Zero()); return statistics_proxy_->GetStats(); } void FlushAndUpdateHistograms(absl::optional fraction_lost, const StreamDataCounters& rtp_stats, const StreamDataCounters* rtx_stats) { - loop_.Flush(); + time_controller_.AdvanceTime(TimeDelta::Zero()); statistics_proxy_->UpdateHistograms(fraction_lost, rtp_stats, rtx_stats); } @@ -84,12 +87,13 @@ class ReceiveStatisticsProxy2Test : public ::testing::Test { .set_timestamp_ms(render_time_ms) .set_rotation(kVideoRotation_0) .build(); - frame.set_ntp_time_ms(fake_clock_.CurrentNtpInMilliseconds()); + frame.set_ntp_time_ms( + time_controller_.GetClock()->CurrentNtpInMilliseconds()); return frame; } // Return the current fake time as a Timestamp. - Timestamp Now() { return fake_clock_.CurrentTime(); } + Timestamp Now() { return time_controller_.GetClock()->CurrentTime(); } // Creates a VideoFrameMetaData instance with a timestamp. VideoFrameMetaData MetaData(const VideoFrame& frame, Timestamp ts) { @@ -102,9 +106,8 @@ class ReceiveStatisticsProxy2Test : public ::testing::Test { } test::ScopedKeyValueConfig field_trials_; - SimulatedClock fake_clock_; + GlobalSimulatedTimeController time_controller_; std::unique_ptr statistics_proxy_; - test::RunLoop loop_; }; TEST_F(ReceiveStatisticsProxy2Test, OnDecodedFrameIncreasesFramesDecoded) { @@ -118,29 +121,31 @@ TEST_F(ReceiveStatisticsProxy2Test, OnDecodedFrameIncreasesFramesDecoded) { } TEST_F(ReceiveStatisticsProxy2Test, DecodedFpsIsReported) { - const int kFps = 20; - const int kRequiredSamples = metrics::kMinRunTimeInSeconds * kFps; + const Frequency kFps = Frequency::Hertz(20); + const int kRequiredSamples = + TimeDelta::Seconds(metrics::kMinRunTimeInSeconds) * kFps; webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight); for (int i = 0; i < kRequiredSamples; ++i) { statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), VideoContentType::UNSPECIFIED); - fake_clock_.AdvanceTimeMilliseconds(1000 / kFps); + time_controller_.AdvanceTime(1 / kFps); } FlushAndUpdateHistograms(absl::nullopt, StreamDataCounters(), nullptr); EXPECT_METRIC_EQ(1, metrics::NumSamples("WebRTC.Video.DecodedFramesPerSecond")); - EXPECT_METRIC_EQ( - 1, metrics::NumEvents("WebRTC.Video.DecodedFramesPerSecond", kFps)); + EXPECT_METRIC_EQ(1, metrics::NumEvents("WebRTC.Video.DecodedFramesPerSecond", + kFps.hertz())); } TEST_F(ReceiveStatisticsProxy2Test, DecodedFpsIsNotReportedForTooFewSamples) { - const int kFps = 20; - const int kRequiredSamples = metrics::kMinRunTimeInSeconds * kFps; + const Frequency kFps = Frequency::Hertz(20); + const int kRequiredSamples = + TimeDelta::Seconds(metrics::kMinRunTimeInSeconds) * kFps; webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight); for (int i = 0; i < kRequiredSamples - 1; ++i) { statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), VideoContentType::UNSPECIFIED); - fake_clock_.AdvanceTimeMilliseconds(1000 / kFps); + time_controller_.AdvanceTime(1 / kFps); } FlushAndUpdateHistograms(absl::nullopt, StreamDataCounters(), nullptr); EXPECT_METRIC_EQ(0, @@ -159,7 +164,7 @@ TEST_F(ReceiveStatisticsProxy2Test, VideoContentType::UNSPECIFIED); expected_total_decode_time += TimeDelta::Millis(1); ++expected_frames_decoded; - loop_.Flush(); + time_controller_.AdvanceTime(TimeDelta::Zero()); EXPECT_EQ(expected_frames_decoded, statistics_proxy_->GetStats().frames_decoded); EXPECT_EQ(expected_total_decode_time, @@ -169,7 +174,7 @@ TEST_F(ReceiveStatisticsProxy2Test, VideoContentType::UNSPECIFIED); ++expected_frames_decoded; expected_total_decode_time += TimeDelta::Millis(3); - loop_.Flush(); + time_controller_.AdvanceTime(TimeDelta::Zero()); EXPECT_EQ(expected_frames_decoded, statistics_proxy_->GetStats().frames_decoded); EXPECT_EQ(expected_total_decode_time, @@ -189,24 +194,24 @@ TEST_F(ReceiveStatisticsProxy2Test, OnDecodedFrameIncreasesProcessingDelay) { RtpPacketInfo({}, {}, {}, {}, {}, Now())}; frame.set_packet_infos(RtpPacketInfos(packet_infos)); for (int i = 1; i <= 3; ++i) { - fake_clock_.AdvanceTime(kProcessingDelay); + time_controller_.AdvanceTime(kProcessingDelay); statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Millis(1), VideoContentType::UNSPECIFIED); expected_total_processing_delay += i * kProcessingDelay; ++expected_frames_decoded; - loop_.Flush(); + time_controller_.AdvanceTime(TimeDelta::Zero()); EXPECT_EQ(expected_frames_decoded, statistics_proxy_->GetStats().frames_decoded); EXPECT_EQ(expected_total_processing_delay, statistics_proxy_->GetStats().total_processing_delay); } - fake_clock_.AdvanceTime(kProcessingDelay); + time_controller_.AdvanceTime(kProcessingDelay); statistics_proxy_->OnDecodedFrame(frame, 1u, TimeDelta::Millis(3), VideoContentType::UNSPECIFIED); ++expected_frames_decoded; expected_total_processing_delay += 4 * kProcessingDelay; - loop_.Flush(); + time_controller_.AdvanceTime(TimeDelta::Zero()); EXPECT_EQ(expected_frames_decoded, statistics_proxy_->GetStats().frames_decoded); EXPECT_EQ(expected_total_processing_delay, @@ -229,7 +234,7 @@ TEST_F(ReceiveStatisticsProxy2Test, OnDecodedFrameIncreasesAssemblyTime) { statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Millis(1), VideoContentType::UNSPECIFIED); ++expected_frames_decoded; - loop_.Flush(); + time_controller_.AdvanceTime(TimeDelta::Zero()); EXPECT_EQ(expected_total_assembly_time, statistics_proxy_->GetStats().total_assembly_time); EXPECT_EQ( @@ -248,7 +253,7 @@ TEST_F(ReceiveStatisticsProxy2Test, OnDecodedFrameIncreasesAssemblyTime) { ++expected_frames_decoded; ++expected_frames_assembled_from_multiple_packets; expected_total_assembly_time += 2 * kAssemblyTime; - loop_.Flush(); + time_controller_.AdvanceTime(TimeDelta::Zero()); EXPECT_EQ(expected_frames_decoded, statistics_proxy_->GetStats().frames_decoded); EXPECT_EQ(expected_total_assembly_time, @@ -269,7 +274,7 @@ TEST_F(ReceiveStatisticsProxy2Test, OnDecodedFrameIncreasesAssemblyTime) { ++expected_frames_decoded; ++expected_frames_assembled_from_multiple_packets; expected_total_assembly_time += 2 * kAssemblyTime; - loop_.Flush(); + time_controller_.AdvanceTime(TimeDelta::Zero()); EXPECT_EQ(expected_frames_decoded, statistics_proxy_->GetStats().frames_decoded); EXPECT_EQ(expected_total_assembly_time, @@ -336,7 +341,7 @@ TEST_F(ReceiveStatisticsProxy2Test, ReportsMaxTotalInterFrameDelay) { EXPECT_DOUBLE_EQ(expected_total_squared_inter_frame_delay, FlushAndGetStats().total_squared_inter_frame_delay); - fake_clock_.AdvanceTime(kInterFrameDelay1); + time_controller_.AdvanceTime(kInterFrameDelay1); statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), VideoContentType::UNSPECIFIED); expected_total_inter_frame_delay += kInterFrameDelay1.seconds(); @@ -348,7 +353,7 @@ TEST_F(ReceiveStatisticsProxy2Test, ReportsMaxTotalInterFrameDelay) { expected_total_squared_inter_frame_delay, statistics_proxy_->GetStats().total_squared_inter_frame_delay); - fake_clock_.AdvanceTime(kInterFrameDelay2); + time_controller_.AdvanceTime(kInterFrameDelay2); statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), VideoContentType::UNSPECIFIED); expected_total_inter_frame_delay += kInterFrameDelay2.seconds(); @@ -360,7 +365,7 @@ TEST_F(ReceiveStatisticsProxy2Test, ReportsMaxTotalInterFrameDelay) { expected_total_squared_inter_frame_delay, statistics_proxy_->GetStats().total_squared_inter_frame_delay); - fake_clock_.AdvanceTime(kInterFrameDelay3); + time_controller_.AdvanceTime(kInterFrameDelay3); statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), VideoContentType::UNSPECIFIED); expected_total_inter_frame_delay += kInterFrameDelay3.seconds(); @@ -375,61 +380,61 @@ TEST_F(ReceiveStatisticsProxy2Test, ReportsMaxTotalInterFrameDelay) { TEST_F(ReceiveStatisticsProxy2Test, ReportsMaxInterframeDelay) { webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight); - const int64_t kInterframeDelayMs1 = 100; - const int64_t kInterframeDelayMs2 = 200; - const int64_t kInterframeDelayMs3 = 100; + const TimeDelta kInterframeDelay1 = TimeDelta::Millis(100); + const TimeDelta kInterframeDelay2 = TimeDelta::Millis(200); + const TimeDelta kInterframeDelay3 = TimeDelta::Millis(100); EXPECT_EQ(-1, statistics_proxy_->GetStats().interframe_delay_max_ms); statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), VideoContentType::UNSPECIFIED); EXPECT_EQ(-1, FlushAndGetStats().interframe_delay_max_ms); - fake_clock_.AdvanceTimeMilliseconds(kInterframeDelayMs1); + time_controller_.AdvanceTime(kInterframeDelay1); statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), VideoContentType::UNSPECIFIED); - EXPECT_EQ(kInterframeDelayMs1, FlushAndGetStats().interframe_delay_max_ms); + EXPECT_EQ(kInterframeDelay1.ms(), FlushAndGetStats().interframe_delay_max_ms); - fake_clock_.AdvanceTimeMilliseconds(kInterframeDelayMs2); + time_controller_.AdvanceTime(kInterframeDelay2); statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), VideoContentType::UNSPECIFIED); - EXPECT_EQ(kInterframeDelayMs2, FlushAndGetStats().interframe_delay_max_ms); + EXPECT_EQ(kInterframeDelay2.ms(), FlushAndGetStats().interframe_delay_max_ms); - fake_clock_.AdvanceTimeMilliseconds(kInterframeDelayMs3); + time_controller_.AdvanceTime(kInterframeDelay3); statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), VideoContentType::UNSPECIFIED); - // kInterframeDelayMs3 is smaller than kInterframeDelayMs2. - EXPECT_EQ(kInterframeDelayMs2, FlushAndGetStats().interframe_delay_max_ms); + // kInterframeDelay3 is smaller than kInterframeDelay2. + EXPECT_EQ(kInterframeDelay2.ms(), FlushAndGetStats().interframe_delay_max_ms); } TEST_F(ReceiveStatisticsProxy2Test, ReportInterframeDelayInWindow) { webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight); - const int64_t kInterframeDelayMs1 = 900; - const int64_t kInterframeDelayMs2 = 750; - const int64_t kInterframeDelayMs3 = 700; + const TimeDelta kInterframeDelay1 = TimeDelta::Millis(900); + const TimeDelta kInterframeDelay2 = TimeDelta::Millis(750); + const TimeDelta kInterframeDelay3 = TimeDelta::Millis(700); EXPECT_EQ(-1, statistics_proxy_->GetStats().interframe_delay_max_ms); statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), VideoContentType::UNSPECIFIED); EXPECT_EQ(-1, FlushAndGetStats().interframe_delay_max_ms); - fake_clock_.AdvanceTimeMilliseconds(kInterframeDelayMs1); + time_controller_.AdvanceTime(kInterframeDelay1); statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), VideoContentType::UNSPECIFIED); - EXPECT_EQ(kInterframeDelayMs1, FlushAndGetStats().interframe_delay_max_ms); + EXPECT_EQ(kInterframeDelay1.ms(), FlushAndGetStats().interframe_delay_max_ms); - fake_clock_.AdvanceTimeMilliseconds(kInterframeDelayMs2); + time_controller_.AdvanceTime(kInterframeDelay2); statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), VideoContentType::UNSPECIFIED); // Still first delay is the maximum - EXPECT_EQ(kInterframeDelayMs1, FlushAndGetStats().interframe_delay_max_ms); + EXPECT_EQ(kInterframeDelay1.ms(), FlushAndGetStats().interframe_delay_max_ms); - fake_clock_.AdvanceTimeMilliseconds(kInterframeDelayMs3); + time_controller_.AdvanceTime(kInterframeDelay3); statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), VideoContentType::UNSPECIFIED); // Now the first sample is out of the window, so the second is the maximum. - EXPECT_EQ(kInterframeDelayMs2, FlushAndGetStats().interframe_delay_max_ms); + EXPECT_EQ(kInterframeDelay2.ms(), FlushAndGetStats().interframe_delay_max_ms); } TEST_F(ReceiveStatisticsProxy2Test, ReportsFreezeMetrics) { - const int64_t kFreezeDurationMs = 1000; + const TimeDelta kFreezeDuration = TimeDelta::Seconds(1); VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats(); EXPECT_EQ(0u, stats.freeze_count); @@ -438,17 +443,17 @@ TEST_F(ReceiveStatisticsProxy2Test, ReportsFreezeMetrics) { webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight); for (size_t i = 0; i < VideoQualityObserver::kMinFrameSamplesToDetectFreeze; ++i) { - fake_clock_.AdvanceTimeMilliseconds(30); + time_controller_.AdvanceTime(TimeDelta::Millis(30)); statistics_proxy_->OnRenderedFrame(MetaData(frame)); } // Freeze. - fake_clock_.AdvanceTimeMilliseconds(kFreezeDurationMs); + time_controller_.AdvanceTime(kFreezeDuration); statistics_proxy_->OnRenderedFrame(MetaData(frame)); stats = statistics_proxy_->GetStats(); EXPECT_EQ(1u, stats.freeze_count); - EXPECT_EQ(kFreezeDurationMs, stats.total_freezes_duration_ms); + EXPECT_EQ(kFreezeDuration.ms(), stats.total_freezes_duration_ms); } TEST_F(ReceiveStatisticsProxy2Test, ReportsPauseMetrics) { @@ -460,7 +465,7 @@ TEST_F(ReceiveStatisticsProxy2Test, ReportsPauseMetrics) { statistics_proxy_->OnRenderedFrame(MetaData(frame)); // Pause. - fake_clock_.AdvanceTimeMilliseconds(5432); + time_controller_.AdvanceTime(TimeDelta::Millis(5432)); statistics_proxy_->OnStreamInactive(); statistics_proxy_->OnRenderedFrame(MetaData(frame)); @@ -477,14 +482,14 @@ TEST_F(ReceiveStatisticsProxy2Test, PauseBeforeFirstAndAfterLastFrameIgnored) { webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight); // Pause -> Frame -> Pause - fake_clock_.AdvanceTimeMilliseconds(5000); + time_controller_.AdvanceTime(TimeDelta::Seconds(5)); statistics_proxy_->OnStreamInactive(); statistics_proxy_->OnRenderedFrame(MetaData(frame)); - fake_clock_.AdvanceTimeMilliseconds(30); + time_controller_.AdvanceTime(TimeDelta::Millis(30)); statistics_proxy_->OnRenderedFrame(MetaData(frame)); - fake_clock_.AdvanceTimeMilliseconds(5000); + time_controller_.AdvanceTime(TimeDelta::Seconds(5)); statistics_proxy_->OnStreamInactive(); stats = statistics_proxy_->GetStats(); @@ -501,10 +506,9 @@ TEST_F(ReceiveStatisticsProxy2Test, ReportsFramesDuration) { // Emulate delay before first frame is rendered. This is needed to ensure // that frame duration only covers time since first frame is rendered and // not the total time. - fake_clock_.AdvanceTimeMilliseconds(5432); - + time_controller_.AdvanceTime(TimeDelta::Millis(5432)); for (int i = 0; i <= 10; ++i) { - fake_clock_.AdvanceTimeMilliseconds(30); + time_controller_.AdvanceTime(TimeDelta::Millis(30)); statistics_proxy_->OnRenderedFrame(MetaData(frame)); } @@ -518,7 +522,7 @@ TEST_F(ReceiveStatisticsProxy2Test, ReportsSumSquaredFrameDurations) { webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight); for (int i = 0; i <= 10; ++i) { - fake_clock_.AdvanceTimeMilliseconds(30); + time_controller_.AdvanceTime(TimeDelta::Millis(30)); statistics_proxy_->OnRenderedFrame(MetaData(frame)); } @@ -564,14 +568,14 @@ TEST_F(ReceiveStatisticsProxy2Test, GetStatsReportsSsrc) { TEST_F(ReceiveStatisticsProxy2Test, GetStatsReportsIncomingPayloadType) { const int kPayloadType = 111; statistics_proxy_->OnIncomingPayloadType(kPayloadType); - loop_.Flush(); + time_controller_.AdvanceTime(TimeDelta::Zero()); EXPECT_EQ(kPayloadType, statistics_proxy_->GetStats().current_payload_type); } TEST_F(ReceiveStatisticsProxy2Test, GetStatsReportsDecoderImplementationName) { const char* kName = "decoderName"; statistics_proxy_->OnDecoderImplementationName(kName); - loop_.Flush(); + time_controller_.AdvanceTime(TimeDelta::Zero()); EXPECT_STREQ( kName, statistics_proxy_->GetStats().decoder_implementation_name.c_str()); } @@ -697,25 +701,25 @@ TEST_F(ReceiveStatisticsProxy2Test, RespectsReportingIntervalForTimingFrames) { TimingFrameInfo info; const int64_t kShortEndToEndDelay = 10; const uint32_t kExpectedRtpTimestamp = 2; - const int64_t kShortDelayMs = 1000; - const int64_t kLongDelayMs = 10000; + const TimeDelta kShortDelay = TimeDelta::Seconds(1); + const TimeDelta kLongDelay = TimeDelta::Seconds(10); absl::optional result; info.rtp_timestamp = kExpectedRtpTimestamp; info.capture_time_ms = 0; info.decode_finish_ms = kShortEndToEndDelay; statistics_proxy_->OnTimingFrameInfoUpdated(info); - fake_clock_.AdvanceTimeMilliseconds(kShortDelayMs); + time_controller_.AdvanceTime(kShortDelay); result = FlushAndGetStats().timing_frame_info; EXPECT_TRUE(result); EXPECT_EQ(kExpectedRtpTimestamp, result->rtp_timestamp); - fake_clock_.AdvanceTimeMilliseconds(kLongDelayMs); + time_controller_.AdvanceTime(kLongDelay); result = statistics_proxy_->GetStats().timing_frame_info; EXPECT_FALSE(result); } TEST_F(ReceiveStatisticsProxy2Test, LifetimeHistogramIsUpdated) { - const int64_t kTimeSec = 3; - fake_clock_.AdvanceTimeMilliseconds(kTimeSec * 1000); + const TimeDelta kLifetime = TimeDelta::Seconds(3); + time_controller_.AdvanceTime(kLifetime); // Need at least one frame to report stream lifetime. statistics_proxy_->OnCompleteFrame(true, 1000, VideoContentType::UNSPECIFIED); statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(), @@ -724,13 +728,13 @@ TEST_F(ReceiveStatisticsProxy2Test, LifetimeHistogramIsUpdated) { 1, metrics::NumSamples("WebRTC.Video.ReceiveStreamLifetimeInSeconds")); EXPECT_METRIC_EQ( 1, metrics::NumEvents("WebRTC.Video.ReceiveStreamLifetimeInSeconds", - kTimeSec)); + kLifetime.seconds())); } TEST_F(ReceiveStatisticsProxy2Test, LifetimeHistogramNotReportedForEmptyStreams) { - const int64_t kTimeSec = 3; - fake_clock_.AdvanceTimeMilliseconds(kTimeSec * 1000); + const TimeDelta kLifetime = TimeDelta::Seconds(3); + time_controller_.AdvanceTime(kLifetime); // No frames received. statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(), nullptr); @@ -744,15 +748,15 @@ TEST_F(ReceiveStatisticsProxy2Test, BadCallHistogramsAreUpdated) { // any histograms are recorded. const int kNumBadSamples = 17; // We only count one sample per second. - const int kBadFameIntervalMs = 1100; + const TimeDelta kBadFameInterval = TimeDelta::Millis(1100); StreamDataCounters counters; - counters.first_packet_time_ms = fake_clock_.TimeInMilliseconds(); + counters.first_packet_time_ms = Now().ms(); webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight); for (int i = 0; i < kNumBadSamples; ++i) { - fake_clock_.AdvanceTimeMilliseconds(kBadFameIntervalMs); + time_controller_.AdvanceTime(kBadFameInterval); statistics_proxy_->OnRenderedFrame(MetaData(frame)); } statistics_proxy_->UpdateHistograms(absl::nullopt, counters, nullptr); @@ -778,7 +782,8 @@ TEST_F(ReceiveStatisticsProxy2Test, PacketLossHistogramIsUpdated) { SetUp(); // Min run time has passed. - fake_clock_.AdvanceTimeMilliseconds(metrics::kMinRunTimeInSeconds * 1000); + time_controller_.AdvanceTime( + TimeDelta::Seconds(metrics::kMinRunTimeInSeconds)); statistics_proxy_->UpdateHistograms(10, StreamDataCounters(), nullptr); EXPECT_METRIC_EQ( 1, metrics::NumSamples("WebRTC.Video.ReceivedPacketsLostInPercent")); @@ -794,10 +799,10 @@ TEST_F(ReceiveStatisticsProxy2Test, GetStatsReportsPlayoutTimestamp) { statistics_proxy_->GetStats().estimated_playout_ntp_timestamp_ms); statistics_proxy_->OnSyncOffsetUpdated(kVideoNtpMs, kSyncOffsetMs, kFreqKhz); EXPECT_EQ(kVideoNtpMs, FlushAndGetStats().estimated_playout_ntp_timestamp_ms); - fake_clock_.AdvanceTimeMilliseconds(13); + time_controller_.AdvanceTime(TimeDelta::Millis(13)); EXPECT_EQ(kVideoNtpMs + 13, statistics_proxy_->GetStats().estimated_playout_ntp_timestamp_ms); - fake_clock_.AdvanceTimeMilliseconds(5); + time_controller_.AdvanceTime(TimeDelta::Millis(5)); EXPECT_EQ(kVideoNtpMs + 13 + 5, statistics_proxy_->GetStats().estimated_playout_ntp_timestamp_ms); } @@ -833,18 +838,16 @@ TEST_F(ReceiveStatisticsProxy2Test, RtpToNtpFrequencyOffsetHistogramIsUpdated) { statistics_proxy_->OnSyncOffsetUpdated(kVideoNtpMs, kSyncOffsetMs, kFreqKhz); statistics_proxy_->OnSyncOffsetUpdated(kVideoNtpMs, kSyncOffsetMs, kFreqKhz + 2.2); - loop_.Flush(); - fake_clock_.AdvanceTimeMilliseconds(kFreqOffsetProcessIntervalInMs); - // Process interval passed, max diff: 2. + time_controller_.AdvanceTime(kFreqOffsetProcessInterval); + //) Process interval passed, max diff: 2. statistics_proxy_->OnSyncOffsetUpdated(kVideoNtpMs, kSyncOffsetMs, kFreqKhz + 1.1); statistics_proxy_->OnSyncOffsetUpdated(kVideoNtpMs, kSyncOffsetMs, kFreqKhz - 4.2); statistics_proxy_->OnSyncOffsetUpdated(kVideoNtpMs, kSyncOffsetMs, kFreqKhz - 0.9); - loop_.Flush(); - fake_clock_.AdvanceTimeMilliseconds(kFreqOffsetProcessIntervalInMs); - // Process interval passed, max diff: 4. + time_controller_.AdvanceTime(kFreqOffsetProcessInterval); + //) Process interval passed, max diff: 4. statistics_proxy_->OnSyncOffsetUpdated(kVideoNtpMs, kSyncOffsetMs, kFreqKhz); FlushAndUpdateHistograms(absl::nullopt, StreamDataCounters(), nullptr); // Average reported: (2 + 4) / 2 = 3. @@ -1007,25 +1010,29 @@ TEST_F(ReceiveStatisticsProxy2Test, TimingHistogramsAreUpdated) { } TEST_F(ReceiveStatisticsProxy2Test, DoesNotReportStaleFramerates) { - const int kDefaultFps = 30; + const Frequency kDefaultFps = Frequency::Hertz(30); webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight); - for (int i = 0; i < kDefaultFps; ++i) { + for (int i = 0; i < kDefaultFps.hertz(); ++i) { // Since OnRenderedFrame is never called the fps in each sample will be 0, // i.e. bad - frame.set_ntp_time_ms(fake_clock_.CurrentNtpInMilliseconds()); + frame.set_ntp_time_ms( + time_controller_.GetClock()->CurrentNtpInMilliseconds()); statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), VideoContentType::UNSPECIFIED); statistics_proxy_->OnRenderedFrame(MetaData(frame)); - fake_clock_.AdvanceTimeMilliseconds(1000 / kDefaultFps); + time_controller_.AdvanceTime(1 / kDefaultFps); } - loop_.Flush(); - EXPECT_EQ(kDefaultFps, statistics_proxy_->GetStats().decode_frame_rate); - EXPECT_EQ(kDefaultFps, statistics_proxy_->GetStats().render_frame_rate); + // Why -1? Because RateStatistics does not consider the first frame in the + // rate as it will appear in the previous bucket. + EXPECT_EQ(kDefaultFps.hertz() - 1, + statistics_proxy_->GetStats().decode_frame_rate); + EXPECT_EQ(kDefaultFps.hertz() - 1, + statistics_proxy_->GetStats().render_frame_rate); // FPS trackers in stats proxy have a 1000ms sliding window. - fake_clock_.AdvanceTimeMilliseconds(1000); + time_controller_.AdvanceTime(TimeDelta::Seconds(1)); EXPECT_EQ(0, statistics_proxy_->GetStats().decode_frame_rate); EXPECT_EQ(0, statistics_proxy_->GetStats().render_frame_rate); } @@ -1091,7 +1098,8 @@ TEST_F(ReceiveStatisticsProxy2Test, ZeroDelayReportedIfFrameNotDelayed) { MetaData(CreateFrameWithRenderTime(Now()))); // Min run time has passed. - fake_clock_.AdvanceTimeMilliseconds((metrics::kMinRunTimeInSeconds * 1000)); + time_controller_.AdvanceTime( + TimeDelta::Seconds((metrics::kMinRunTimeInSeconds))); FlushAndUpdateHistograms(absl::nullopt, StreamDataCounters(), nullptr); EXPECT_METRIC_EQ(1, metrics::NumSamples("WebRTC.Video.DelayedFramesToRenderer")); @@ -1112,8 +1120,8 @@ TEST_F(ReceiveStatisticsProxy2Test, MetaData(CreateFrameWithRenderTime(Now()))); // Min run time has not passed. - fake_clock_.AdvanceTimeMilliseconds((metrics::kMinRunTimeInSeconds * 1000) - - 1); + time_controller_.AdvanceTime( + TimeDelta::Seconds(metrics::kMinRunTimeInSeconds) - TimeDelta::Millis(1)); statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(), nullptr); EXPECT_METRIC_EQ(0, @@ -1129,7 +1137,8 @@ TEST_F(ReceiveStatisticsProxy2Test, VideoContentType::UNSPECIFIED); // Min run time has passed. No rendered frames. - fake_clock_.AdvanceTimeMilliseconds((metrics::kMinRunTimeInSeconds * 1000)); + time_controller_.AdvanceTime( + TimeDelta::Seconds((metrics::kMinRunTimeInSeconds))); statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(), nullptr); EXPECT_METRIC_EQ(0, @@ -1148,7 +1157,8 @@ TEST_F(ReceiveStatisticsProxy2Test, DelayReportedIfFrameIsDelayed) { MetaData(CreateFrameWithRenderTimeMs(Now().ms() - 1))); // Min run time has passed. - fake_clock_.AdvanceTimeMilliseconds((metrics::kMinRunTimeInSeconds * 1000)); + time_controller_.AdvanceTime( + TimeDelta::Seconds(metrics::kMinRunTimeInSeconds)); FlushAndUpdateHistograms(absl::nullopt, StreamDataCounters(), nullptr); EXPECT_METRIC_EQ(1, metrics::NumSamples("WebRTC.Video.DelayedFramesToRenderer")); @@ -1179,7 +1189,8 @@ TEST_F(ReceiveStatisticsProxy2Test, AverageDelayOfDelayedFramesIsReported) { MetaData(CreateFrameWithRenderTimeMs(kNowMs + 1))); // Min run time has passed. - fake_clock_.AdvanceTimeMilliseconds((metrics::kMinRunTimeInSeconds * 1000)); + time_controller_.AdvanceTime( + TimeDelta::Seconds(metrics::kMinRunTimeInSeconds)); FlushAndUpdateHistograms(absl::nullopt, StreamDataCounters(), nullptr); EXPECT_METRIC_EQ(1, metrics::NumSamples("WebRTC.Video.DelayedFramesToRenderer")); @@ -1195,10 +1206,11 @@ TEST_F(ReceiveStatisticsProxy2Test, AverageDelayOfDelayedFramesIsReported) { TEST_F(ReceiveStatisticsProxy2Test, RtcpHistogramsNotUpdatedIfMinRuntimeHasNotPassed) { StreamDataCounters data_counters; - data_counters.first_packet_time_ms = fake_clock_.TimeInMilliseconds(); + data_counters.first_packet_time_ms = + time_controller_.GetClock()->TimeInMilliseconds(); - fake_clock_.AdvanceTimeMilliseconds((metrics::kMinRunTimeInSeconds * 1000) - - 1); + time_controller_.AdvanceTime( + TimeDelta::Seconds(metrics::kMinRunTimeInSeconds) - TimeDelta::Millis(1)); RtcpPacketTypeCounter counter; statistics_proxy_->RtcpPacketTypesCounterUpdated(kRemoteSsrc, counter); @@ -1214,8 +1226,10 @@ TEST_F(ReceiveStatisticsProxy2Test, TEST_F(ReceiveStatisticsProxy2Test, RtcpHistogramsAreUpdated) { StreamDataCounters data_counters; - data_counters.first_packet_time_ms = fake_clock_.TimeInMilliseconds(); - fake_clock_.AdvanceTimeMilliseconds(metrics::kMinRunTimeInSeconds * 1000); + data_counters.first_packet_time_ms = + time_controller_.GetClock()->TimeInMilliseconds(); + time_controller_.AdvanceTime( + TimeDelta::Seconds(metrics::kMinRunTimeInSeconds)); const uint32_t kFirPackets = 100; const uint32_t kPliPackets = 200; @@ -1283,15 +1297,14 @@ TEST_P(ReceiveStatisticsProxy2TestWithFreezeDuration, FreezeDetection) { // duration, which is supposed to be calculated as mean of durations of // last 30 frames, is calculated correctly. statistics_proxy_->OnRenderedFrame(MetaData(frame)); - fake_clock_.AdvanceTimeMilliseconds(2000); - + time_controller_.AdvanceTime(TimeDelta::Seconds(2)); for (size_t i = 0; i <= VideoQualityObserver::kAvgInterframeDelaysWindowSizeFrames; ++i) { - fake_clock_.AdvanceTimeMilliseconds(frame_duration_ms_); + time_controller_.AdvanceTime(TimeDelta::Millis(frame_duration_ms_)); statistics_proxy_->OnRenderedFrame(MetaData(frame)); } - fake_clock_.AdvanceTimeMilliseconds(freeze_duration_ms_); + time_controller_.AdvanceTime(TimeDelta::Millis(freeze_duration_ms_)); statistics_proxy_->OnRenderedFrame(MetaData(frame)); stats = statistics_proxy_->GetStats(); @@ -1311,84 +1324,83 @@ INSTANTIATE_TEST_SUITE_P(ContentTypes, VideoContentType::SCREENSHARE)); TEST_P(ReceiveStatisticsProxy2TestWithContent, InterFrameDelaysAreReported) { - const int kInterFrameDelayMs = 33; + const TimeDelta kInterFrameDelay = TimeDelta::Millis(33); webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight); for (int i = 0; i < kMinRequiredSamples; ++i) { statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), content_type_); - fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs); + time_controller_.AdvanceTime(kInterFrameDelay); } // One extra with double the interval. - fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs); + time_controller_.AdvanceTime(kInterFrameDelay); statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), content_type_); FlushAndUpdateHistograms(absl::nullopt, StreamDataCounters(), nullptr); - const int kExpectedInterFrame = - (kInterFrameDelayMs * (kMinRequiredSamples - 1) + - kInterFrameDelayMs * 2) / + const TimeDelta kExpectedInterFrame = + (kInterFrameDelay * (kMinRequiredSamples - 1) + kInterFrameDelay * 2) / kMinRequiredSamples; if (videocontenttypehelpers::IsScreenshare(content_type_)) { EXPECT_METRIC_EQ( - kExpectedInterFrame, + kExpectedInterFrame.ms(), metrics::MinSample("WebRTC.Video.Screenshare.InterframeDelayInMs")); EXPECT_METRIC_EQ( - kInterFrameDelayMs * 2, + kInterFrameDelay.ms() * 2, metrics::MinSample("WebRTC.Video.Screenshare.InterframeDelayMaxInMs")); } else { - EXPECT_METRIC_EQ(kExpectedInterFrame, + EXPECT_METRIC_EQ(kExpectedInterFrame.ms(), metrics::MinSample("WebRTC.Video.InterframeDelayInMs")); - EXPECT_METRIC_EQ(kInterFrameDelayMs * 2, + EXPECT_METRIC_EQ(kInterFrameDelay.ms() * 2, metrics::MinSample("WebRTC.Video.InterframeDelayMaxInMs")); } } TEST_P(ReceiveStatisticsProxy2TestWithContent, InterFrameDelaysPercentilesAreReported) { - const int kInterFrameDelayMs = 33; + const TimeDelta kInterFrameDelay = TimeDelta::Millis(33); const int kLastFivePercentsSamples = kMinRequiredSamples * 5 / 100; webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight); for (int i = 0; i <= kMinRequiredSamples - kLastFivePercentsSamples; ++i) { - fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs); + time_controller_.AdvanceTime(kInterFrameDelay); statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), content_type_); } // Last 5% of intervals are double in size. for (int i = 0; i < kLastFivePercentsSamples; ++i) { - fake_clock_.AdvanceTimeMilliseconds(2 * kInterFrameDelayMs); + time_controller_.AdvanceTime(2 * kInterFrameDelay); statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), content_type_); } // Final sample is outlier and 10 times as big. - fake_clock_.AdvanceTimeMilliseconds(10 * kInterFrameDelayMs); + time_controller_.AdvanceTime(10 * kInterFrameDelay); statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), content_type_); FlushAndUpdateHistograms(absl::nullopt, StreamDataCounters(), nullptr); - const int kExpectedInterFrame = kInterFrameDelayMs * 2; + const TimeDelta kExpectedInterFrame = kInterFrameDelay * 2; if (videocontenttypehelpers::IsScreenshare(content_type_)) { EXPECT_METRIC_EQ( - kExpectedInterFrame, + kExpectedInterFrame.ms(), metrics::MinSample( "WebRTC.Video.Screenshare.InterframeDelay95PercentileInMs")); } else { EXPECT_METRIC_EQ( - kExpectedInterFrame, + kExpectedInterFrame.ms(), metrics::MinSample("WebRTC.Video.InterframeDelay95PercentileInMs")); } } TEST_P(ReceiveStatisticsProxy2TestWithContent, MaxInterFrameDelayOnlyWithValidAverage) { - const int kInterFrameDelayMs = 33; + const TimeDelta kInterFrameDelay = TimeDelta::Millis(33); webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight); for (int i = 0; i < kMinRequiredSamples; ++i) { statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), content_type_); - fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs); + time_controller_.AdvanceTime(kInterFrameDelay); } // `kMinRequiredSamples` samples, and thereby intervals, is required. That @@ -1406,26 +1418,24 @@ TEST_P(ReceiveStatisticsProxy2TestWithContent, TEST_P(ReceiveStatisticsProxy2TestWithContent, MaxInterFrameDelayOnlyWithPause) { - const int kInterFrameDelayMs = 33; + const TimeDelta kInterFrameDelay = TimeDelta::Millis(33); webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight); for (int i = 0; i <= kMinRequiredSamples; ++i) { statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), content_type_); - fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs); + time_controller_.AdvanceTime(kInterFrameDelay); } - loop_.Flush(); // At this state, we should have a valid inter-frame delay. // Indicate stream paused and make a large jump in time. statistics_proxy_->OnStreamInactive(); - fake_clock_.AdvanceTimeMilliseconds(5000); - + time_controller_.AdvanceTime(TimeDelta::Seconds(5)); // Insert two more frames. The interval during the pause should be // disregarded in the stats. statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), content_type_); - fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs); + time_controller_.AdvanceTime(kInterFrameDelay); statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), content_type_); @@ -1436,28 +1446,28 @@ TEST_P(ReceiveStatisticsProxy2TestWithContent, EXPECT_METRIC_EQ(1, metrics::NumSamples( "WebRTC.Video.Screenshare.InterframeDelayMaxInMs")); EXPECT_METRIC_EQ( - kInterFrameDelayMs, + kInterFrameDelay.ms(), metrics::MinSample("WebRTC.Video.Screenshare.InterframeDelayInMs")); EXPECT_METRIC_EQ( - kInterFrameDelayMs, + kInterFrameDelay.ms(), metrics::MinSample("WebRTC.Video.Screenshare.InterframeDelayMaxInMs")); } else { EXPECT_METRIC_EQ(1, metrics::NumSamples("WebRTC.Video.InterframeDelayInMs")); EXPECT_METRIC_EQ( 1, metrics::NumSamples("WebRTC.Video.InterframeDelayMaxInMs")); - EXPECT_METRIC_EQ(kInterFrameDelayMs, + EXPECT_METRIC_EQ(kInterFrameDelay.ms(), metrics::MinSample("WebRTC.Video.InterframeDelayInMs")); - EXPECT_METRIC_EQ(kInterFrameDelayMs, + EXPECT_METRIC_EQ(kInterFrameDelay.ms(), metrics::MinSample("WebRTC.Video.InterframeDelayMaxInMs")); } } TEST_P(ReceiveStatisticsProxy2TestWithContent, FreezesAreReported) { - const int kInterFrameDelayMs = 33; - const int kFreezeDelayMs = 200; - const int kCallDurationMs = - kMinRequiredSamples * kInterFrameDelayMs + kFreezeDelayMs; + const TimeDelta kInterFrameDelay = TimeDelta::Millis(33); + const TimeDelta kFreezeDelay = TimeDelta::Millis(200); + const TimeDelta kCallDuration = + kMinRequiredSamples * kInterFrameDelay + kFreezeDelay; webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight); for (int i = 0; i < kMinRequiredSamples; ++i) { @@ -1466,10 +1476,10 @@ TEST_P(ReceiveStatisticsProxy2TestWithContent, FreezesAreReported) { TimeDelta::Zero(), TimeDelta::Zero(), content_type_); statistics_proxy_->OnRenderedFrame(meta); - fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs); + time_controller_.AdvanceTime(kInterFrameDelay); } // Add extra freeze. - fake_clock_.AdvanceTimeMilliseconds(kFreezeDelayMs); + time_controller_.AdvanceTime(kFreezeDelay); VideoFrameMetaData meta = MetaData(frame); statistics_proxy_->OnDecodedFrame(meta, absl::nullopt, TimeDelta::Zero(), TimeDelta::Zero(), TimeDelta::Zero(), @@ -1477,24 +1487,24 @@ TEST_P(ReceiveStatisticsProxy2TestWithContent, FreezesAreReported) { statistics_proxy_->OnRenderedFrame(meta); FlushAndUpdateHistograms(absl::nullopt, StreamDataCounters(), nullptr); - const int kExpectedTimeBetweenFreezes = - kInterFrameDelayMs * (kMinRequiredSamples - 1); - const int kExpectedNumberFreezesPerMinute = 60 * 1000 / kCallDurationMs; + const TimeDelta kExpectedTimeBetweenFreezes = + kInterFrameDelay * (kMinRequiredSamples - 1); + const int kExpectedNumberFreezesPerMinute = 60 / kCallDuration.seconds(); if (videocontenttypehelpers::IsScreenshare(content_type_)) { EXPECT_METRIC_EQ( - kFreezeDelayMs + kInterFrameDelayMs, + (kFreezeDelay + kInterFrameDelay).ms(), metrics::MinSample("WebRTC.Video.Screenshare.MeanFreezeDurationMs")); - EXPECT_METRIC_EQ(kExpectedTimeBetweenFreezes, + EXPECT_METRIC_EQ(kExpectedTimeBetweenFreezes.ms(), metrics::MinSample( "WebRTC.Video.Screenshare.MeanTimeBetweenFreezesMs")); EXPECT_METRIC_EQ( kExpectedNumberFreezesPerMinute, metrics::MinSample("WebRTC.Video.Screenshare.NumberFreezesPerMinute")); } else { - EXPECT_METRIC_EQ(kFreezeDelayMs + kInterFrameDelayMs, + EXPECT_METRIC_EQ((kFreezeDelay + kInterFrameDelay).ms(), metrics::MinSample("WebRTC.Video.MeanFreezeDurationMs")); EXPECT_METRIC_EQ( - kExpectedTimeBetweenFreezes, + kExpectedTimeBetweenFreezes.ms(), metrics::MinSample("WebRTC.Video.MeanTimeBetweenFreezesMs")); EXPECT_METRIC_EQ(kExpectedNumberFreezesPerMinute, metrics::MinSample("WebRTC.Video.NumberFreezesPerMinute")); @@ -1502,15 +1512,15 @@ TEST_P(ReceiveStatisticsProxy2TestWithContent, FreezesAreReported) { } TEST_P(ReceiveStatisticsProxy2TestWithContent, HarmonicFrameRateIsReported) { - const int kFrameDurationMs = 33; - const int kFreezeDurationMs = 200; - const int kPauseDurationMs = 10000; - const int kCallDurationMs = kMinRequiredSamples * kFrameDurationMs + - kFreezeDurationMs + kPauseDurationMs; + const TimeDelta kFrameDuration = TimeDelta::Millis(33); + const TimeDelta kFreezeDuration = TimeDelta::Millis(200); + const TimeDelta kPauseDuration = TimeDelta::Seconds(10); + const TimeDelta kCallDuration = + kMinRequiredSamples * kFrameDuration + kFreezeDuration + kPauseDuration; webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight); for (int i = 0; i < kMinRequiredSamples; ++i) { - fake_clock_.AdvanceTimeMilliseconds(kFrameDurationMs); + time_controller_.AdvanceTime(kFrameDuration); statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), content_type_); statistics_proxy_->OnRenderedFrame(MetaData(frame)); @@ -1518,15 +1528,13 @@ TEST_P(ReceiveStatisticsProxy2TestWithContent, HarmonicFrameRateIsReported) { // Freezes and pauses should be included into harmonic frame rate. // Add freeze. - loop_.Flush(); - fake_clock_.AdvanceTimeMilliseconds(kFreezeDurationMs); + time_controller_.AdvanceTime(kFreezeDuration); statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), content_type_); statistics_proxy_->OnRenderedFrame(MetaData(frame)); // Add pause. - loop_.Flush(); - fake_clock_.AdvanceTimeMilliseconds(kPauseDurationMs); + time_controller_.AdvanceTime(kPauseDuration); statistics_proxy_->OnStreamInactive(); statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), content_type_); @@ -1535,13 +1543,13 @@ TEST_P(ReceiveStatisticsProxy2TestWithContent, HarmonicFrameRateIsReported) { FlushAndUpdateHistograms(absl::nullopt, StreamDataCounters(), nullptr); double kSumSquaredFrameDurationSecs = (kMinRequiredSamples - 1) * - (kFrameDurationMs / 1000.0 * kFrameDurationMs / 1000.0); + (kFrameDuration.seconds() * kFrameDuration.seconds()); kSumSquaredFrameDurationSecs += - kFreezeDurationMs / 1000.0 * kFreezeDurationMs / 1000.0; + kFreezeDuration.seconds() * kFreezeDuration.seconds(); kSumSquaredFrameDurationSecs += - kPauseDurationMs / 1000.0 * kPauseDurationMs / 1000.0; - const int kExpectedHarmonicFrameRateFps = - std::round(kCallDurationMs / (1000 * kSumSquaredFrameDurationSecs)); + kPauseDuration.seconds() * kPauseDuration.seconds(); + const int kExpectedHarmonicFrameRateFps = std::round( + kCallDuration.seconds() / kSumSquaredFrameDurationSecs); if (videocontenttypehelpers::IsScreenshare(content_type_)) { EXPECT_METRIC_EQ( kExpectedHarmonicFrameRateFps, @@ -1553,8 +1561,8 @@ TEST_P(ReceiveStatisticsProxy2TestWithContent, HarmonicFrameRateIsReported) { } TEST_P(ReceiveStatisticsProxy2TestWithContent, PausesAreIgnored) { - const int kInterFrameDelayMs = 33; - const int kPauseDurationMs = 10000; + const TimeDelta kInterFrameDelay = TimeDelta::Millis(33); + const TimeDelta kPauseDuration = TimeDelta::Seconds(10); webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight); for (int i = 0; i <= kMinRequiredSamples; ++i) { @@ -1563,10 +1571,10 @@ TEST_P(ReceiveStatisticsProxy2TestWithContent, PausesAreIgnored) { TimeDelta::Zero(), TimeDelta::Zero(), content_type_); statistics_proxy_->OnRenderedFrame(meta); - fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs); + time_controller_.AdvanceTime(kInterFrameDelay); } // Add a pause. - fake_clock_.AdvanceTimeMilliseconds(kPauseDurationMs); + time_controller_.AdvanceTime(kPauseDuration); statistics_proxy_->OnStreamInactive(); // Second playback interval with triple the length. for (int i = 0; i <= kMinRequiredSamples * 3; ++i) { @@ -1575,44 +1583,42 @@ TEST_P(ReceiveStatisticsProxy2TestWithContent, PausesAreIgnored) { TimeDelta::Zero(), TimeDelta::Zero(), content_type_); statistics_proxy_->OnRenderedFrame(meta); - fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs); + time_controller_.AdvanceTime(kInterFrameDelay); } FlushAndUpdateHistograms(absl::nullopt, StreamDataCounters(), nullptr); // Average of two playback intervals. - const int kExpectedTimeBetweenFreezes = - kInterFrameDelayMs * kMinRequiredSamples * 2; + const TimeDelta kExpectedTimeBetweenFreezes = + kInterFrameDelay * kMinRequiredSamples * 2; if (videocontenttypehelpers::IsScreenshare(content_type_)) { EXPECT_METRIC_EQ(-1, metrics::MinSample( "WebRTC.Video.Screenshare.MeanFreezeDurationMs")); - EXPECT_METRIC_EQ(kExpectedTimeBetweenFreezes, + EXPECT_METRIC_EQ(kExpectedTimeBetweenFreezes.ms(), metrics::MinSample( "WebRTC.Video.Screenshare.MeanTimeBetweenFreezesMs")); } else { EXPECT_METRIC_EQ(-1, metrics::MinSample("WebRTC.Video.MeanFreezeDurationMs")); EXPECT_METRIC_EQ( - kExpectedTimeBetweenFreezes, + kExpectedTimeBetweenFreezes.ms(), metrics::MinSample("WebRTC.Video.MeanTimeBetweenFreezesMs")); } } TEST_P(ReceiveStatisticsProxy2TestWithContent, ManyPausesAtTheBeginning) { - const int kInterFrameDelayMs = 33; - const int kPauseDurationMs = 10000; + const TimeDelta kInterFrameDelay = TimeDelta::Millis(33); + const TimeDelta kPauseDuration = TimeDelta::Seconds(10); webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight); for (int i = 0; i <= kMinRequiredSamples; ++i) { statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), content_type_); - fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs); - + time_controller_.AdvanceTime(kInterFrameDelay); statistics_proxy_->OnStreamInactive(); - fake_clock_.AdvanceTimeMilliseconds(kPauseDurationMs); - + time_controller_.AdvanceTime(kPauseDuration); statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), content_type_); - fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs); + time_controller_.AdvanceTime(kInterFrameDelay); } statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(), @@ -1629,7 +1635,7 @@ TEST_P(ReceiveStatisticsProxy2TestWithContent, ManyPausesAtTheBeginning) { } TEST_P(ReceiveStatisticsProxy2TestWithContent, TimeInHdReported) { - const int kInterFrameDelayMs = 20; + const TimeDelta kInterFrameDelay = TimeDelta::Millis(20); webrtc::VideoFrame frame_hd = CreateFrame(1280, 720); webrtc::VideoFrame frame_sd = CreateFrame(640, 360); @@ -1640,7 +1646,7 @@ TEST_P(ReceiveStatisticsProxy2TestWithContent, TimeInHdReported) { TimeDelta::Zero(), TimeDelta::Zero(), content_type_); statistics_proxy_->OnRenderedFrame(meta); - fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs); + time_controller_.AdvanceTime(kInterFrameDelay); } // SD frames. for (int i = 0; i < 2 * kMinRequiredSamples; ++i) { @@ -1649,7 +1655,7 @@ TEST_P(ReceiveStatisticsProxy2TestWithContent, TimeInHdReported) { TimeDelta::Zero(), TimeDelta::Zero(), content_type_); statistics_proxy_->OnRenderedFrame(meta); - fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs); + time_controller_.AdvanceTime(kInterFrameDelay); } // Extra last frame. statistics_proxy_->OnRenderedFrame(MetaData(frame_sd)); @@ -1668,7 +1674,7 @@ TEST_P(ReceiveStatisticsProxy2TestWithContent, TimeInHdReported) { } TEST_P(ReceiveStatisticsProxy2TestWithContent, TimeInBlockyVideoReported) { - const int kInterFrameDelayMs = 20; + const TimeDelta kInterFrameDelay = TimeDelta::Millis(20); const int kHighQp = 80; const int kLowQp = 30; webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight); @@ -1680,7 +1686,7 @@ TEST_P(ReceiveStatisticsProxy2TestWithContent, TimeInBlockyVideoReported) { TimeDelta::Zero(), TimeDelta::Zero(), content_type_); statistics_proxy_->OnRenderedFrame(meta); - fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs); + time_controller_.AdvanceTime(kInterFrameDelay); } // Blocky frames. for (int i = 0; i < 2 * kMinRequiredSamples; ++i) { @@ -1689,7 +1695,7 @@ TEST_P(ReceiveStatisticsProxy2TestWithContent, TimeInBlockyVideoReported) { TimeDelta::Zero(), TimeDelta::Zero(), content_type_); statistics_proxy_->OnRenderedFrame(meta); - fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs); + time_controller_.AdvanceTime(kInterFrameDelay); } // Extra last frame. statistics_proxy_->OnDecodedFrame(frame, kHighQp, TimeDelta::Zero(), @@ -1711,7 +1717,8 @@ TEST_P(ReceiveStatisticsProxy2TestWithContent, TimeInBlockyVideoReported) { } TEST_P(ReceiveStatisticsProxy2TestWithContent, DownscalesReported) { - const int kInterFrameDelayMs = 2000; // To ensure long enough call duration. + // To ensure long enough call duration. + const TimeDelta kInterFrameDelay = TimeDelta::Seconds(2); webrtc::VideoFrame frame_hd = CreateFrame(1280, 720); webrtc::VideoFrame frame_sd = CreateFrame(640, 360); @@ -1721,18 +1728,15 @@ TEST_P(ReceiveStatisticsProxy2TestWithContent, DownscalesReported) { statistics_proxy_->OnDecodedFrame(frame_hd, absl::nullopt, TimeDelta::Zero(), content_type_); - loop_.Flush(); + time_controller_.AdvanceTime(TimeDelta::Zero()); statistics_proxy_->OnRenderedFrame(MetaData(frame_hd)); - fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs); - + time_controller_.AdvanceTime(kInterFrameDelay); // Downscale. statistics_proxy_->OnRenderedFrame(MetaData(frame_sd)); - fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs); - + time_controller_.AdvanceTime(kInterFrameDelay); // Downscale. statistics_proxy_->OnRenderedFrame(MetaData(frame_ld)); - fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs); - + time_controller_.AdvanceTime(kInterFrameDelay); statistics_proxy_->UpdateHistograms(absl::nullopt, StreamDataCounters(), nullptr); const int kExpectedDownscales = 30; // 2 per 4 seconds = 30 per minute. @@ -1749,20 +1753,20 @@ TEST_P(ReceiveStatisticsProxy2TestWithContent, DownscalesReported) { } TEST_P(ReceiveStatisticsProxy2TestWithContent, DecodeTimeReported) { - const int kInterFrameDelayMs = 20; + const TimeDelta kInterFrameDelay = TimeDelta::Millis(20); const int kLowQp = 30; - const int kDecodeMs = 7; + const TimeDelta kDecodeTime = TimeDelta::Millis(7); webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight); for (int i = 0; i < kMinRequiredSamples; ++i) { - statistics_proxy_->OnDecodedFrame( - frame, kLowQp, TimeDelta::Millis(kDecodeMs), content_type_); - fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs); + statistics_proxy_->OnDecodedFrame(frame, kLowQp, kDecodeTime, + content_type_); + time_controller_.AdvanceTime(kInterFrameDelay); } FlushAndUpdateHistograms(absl::nullopt, StreamDataCounters(), nullptr); EXPECT_METRIC_EQ( - 1, metrics::NumEvents("WebRTC.Video.DecodeTimeInMs", kDecodeMs)); + 1, metrics::NumEvents("WebRTC.Video.DecodeTimeInMs", kDecodeTime.ms())); } TEST_P(ReceiveStatisticsProxy2TestWithContent, @@ -1770,20 +1774,20 @@ TEST_P(ReceiveStatisticsProxy2TestWithContent, const uint8_t experiment_id = 1; webrtc::VideoContentType content_type = content_type_; videocontenttypehelpers::SetExperimentId(&content_type, experiment_id); - const int kInterFrameDelayMs1 = 30; - const int kInterFrameDelayMs2 = 50; + const TimeDelta kInterFrameDelay1 = TimeDelta::Millis(30); + const TimeDelta kInterFrameDelay2 = TimeDelta::Millis(50); webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight); videocontenttypehelpers::SetSimulcastId(&content_type, 1); for (int i = 0; i <= kMinRequiredSamples; ++i) { - fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs1); + time_controller_.AdvanceTime(kInterFrameDelay1); statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), content_type); } videocontenttypehelpers::SetSimulcastId(&content_type, 2); for (int i = 0; i <= kMinRequiredSamples; ++i) { - fake_clock_.AdvanceTimeMilliseconds(kInterFrameDelayMs2); + time_controller_.AdvanceTime(kInterFrameDelay2); statistics_proxy_->OnDecodedFrame(frame, absl::nullopt, TimeDelta::Zero(), content_type); } @@ -1811,19 +1815,19 @@ TEST_P(ReceiveStatisticsProxy2TestWithContent, 1, metrics::NumSamples("WebRTC.Video.Screenshare.InterframeDelayMaxInMs" ".ExperimentGroup0")); EXPECT_METRIC_EQ( - kInterFrameDelayMs1, + kInterFrameDelay1.ms(), metrics::MinSample("WebRTC.Video.Screenshare.InterframeDelayInMs.S0")); EXPECT_METRIC_EQ( - kInterFrameDelayMs2, + kInterFrameDelay2.ms(), metrics::MinSample("WebRTC.Video.Screenshare.InterframeDelayInMs.S1")); EXPECT_METRIC_EQ( - (kInterFrameDelayMs1 + kInterFrameDelayMs2) / 2, + ((kInterFrameDelay1 + kInterFrameDelay2) / 2).ms(), metrics::MinSample("WebRTC.Video.Screenshare.InterframeDelayInMs")); EXPECT_METRIC_EQ( - kInterFrameDelayMs2, + kInterFrameDelay2.ms(), metrics::MinSample("WebRTC.Video.Screenshare.InterframeDelayMaxInMs")); EXPECT_METRIC_EQ( - (kInterFrameDelayMs1 + kInterFrameDelayMs2) / 2, + ((kInterFrameDelay1 + kInterFrameDelay2) / 2).ms(), metrics::MinSample( "WebRTC.Video.Screenshare.InterframeDelayInMs.ExperimentGroup0")); } else { @@ -1844,15 +1848,15 @@ TEST_P(ReceiveStatisticsProxy2TestWithContent, EXPECT_METRIC_EQ(1, metrics::NumSamples("WebRTC.Video.InterframeDelayMaxInMs" ".ExperimentGroup0")); - EXPECT_METRIC_EQ(kInterFrameDelayMs1, + EXPECT_METRIC_EQ(kInterFrameDelay1.ms(), metrics::MinSample("WebRTC.Video.InterframeDelayInMs.S0")); - EXPECT_METRIC_EQ(kInterFrameDelayMs2, + EXPECT_METRIC_EQ(kInterFrameDelay2.ms(), metrics::MinSample("WebRTC.Video.InterframeDelayInMs.S1")); - EXPECT_METRIC_EQ((kInterFrameDelayMs1 + kInterFrameDelayMs2) / 2, + EXPECT_METRIC_EQ((kInterFrameDelay1 + kInterFrameDelay2).ms() / 2, metrics::MinSample("WebRTC.Video.InterframeDelayInMs")); - EXPECT_METRIC_EQ(kInterFrameDelayMs2, + EXPECT_METRIC_EQ(kInterFrameDelay2.ms(), metrics::MinSample("WebRTC.Video.InterframeDelayMaxInMs")); - EXPECT_METRIC_EQ((kInterFrameDelayMs1 + kInterFrameDelayMs2) / 2, + EXPECT_METRIC_EQ((kInterFrameDelay1 + kInterFrameDelay2).ms() / 2, metrics::MinSample( "WebRTC.Video.InterframeDelayInMs.ExperimentGroup0")); }