Convert rtc_event_log from webrtc::Clock to rtc::TimeMicros.

webrtc/logging/rtc_event_log/rtc_event_log_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 <map>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "webrtc/base/buffer.h"
 #include "webrtc/base/checks.h"
+#include "webrtc/base/fakeclock.h"
 #include "webrtc/base/random.h"
 #include "webrtc/call.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log_parser.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_header_extension.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_packet_to_send.h"
-#include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/test/test_suite.h"
 #include "webrtc/test/testsupport/fileutils.h"
 
 // Files generated at build-time by the protobuf compiler.
 #ifdef WEBRTC_ANDROID_PLATFORM_BUILD
 #include "external/webrtc/webrtc/logging/rtc_event_log/rtc_event_log.pb.h"
 #else
 #include "webrtc/logging/rtc_event_log/rtc_event_log.pb.h"
 #endif
@@ skipping 244 matching lines @@
 
   // Find the name of the current test, in order to use it as a temporary
   // filename.
   auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
   const std::string temp_filename =
       test::OutputPath() + test_info->test_case_name() + test_info->name();
 
   // When log_dumper goes out of scope, it causes the log file to be flushed
   // to disk.
   {
-    SimulatedClock fake_clock(prng.Rand<uint32_t>());
-    std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create(&fake_clock));
+    rtc::ScopedFakeClock fake_clock;
+    fake_clock.SetTimeNanos(rtc::kNumNanosecsPerMicrosec *
+                            prng.Rand<uint32_t>());
+    std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create());
     log_dumper->LogVideoReceiveStreamConfig(receiver_config);
-    fake_clock.AdvanceTimeMicroseconds(prng.Rand(1, 1000));
+    fake_clock.AdvanceTime(
+        rtc::TimeDelta::FromMicroseconds(prng.Rand(1, 1000)));
     log_dumper->LogVideoSendStreamConfig(sender_config);
-    fake_clock.AdvanceTimeMicroseconds(prng.Rand(1, 1000));
+    fake_clock.AdvanceTime(

[terelius, 2016/11/18 13:44:28]

Could we make a convenience function for this? A lot of the test code advance
the clock by a certain number of microseconds (or milliseconds) for each
"action".

[nisse-webrtc, 2016/11/18 15:03:43]

What precisely do you suggest to make this more convenient? I also find the
TimeDelta abstraction a bit clumsy.

[terelius, 2016/11/18 15:55:33]

A function AdvanceTimeMicroseconds(int64_t) comes to mind. :) 

[nisse-webrtc, 2016/11/21 07:58:02]

Hmm. I can add AdvanceTimeMicros and SetTimeMicros. Not sure why Taylor choose
to copy Chrome's TimeDelta class just for this.

[nisse-webrtc, 2016/11/28 14:26:42]

Done.

+        rtc::TimeDelta::FromMicroseconds(prng.Rand(1, 1000)));
     size_t rtcp_index = 1;
     size_t playout_index = 1;
     size_t bwe_loss_index = 1;
     for (size_t i = 1; i <= rtp_count; i++) {
       log_dumper->LogRtpHeader(
           (i % 2 == 0) ? kIncomingPacket : kOutgoingPacket,
           (i % 3 == 0) ? MediaType::AUDIO : MediaType::VIDEO,
           rtp_packets[i - 1].data(), rtp_packets[i - 1].size());
-      fake_clock.AdvanceTimeMicroseconds(prng.Rand(1, 1000));
+      fake_clock.AdvanceTime(
+          rtc::TimeDelta::FromMicroseconds(prng.Rand(1, 1000)));
       if (i * rtcp_count >= rtcp_index * rtp_count) {
         log_dumper->LogRtcpPacket(
             (rtcp_index % 2 == 0) ? kIncomingPacket : kOutgoingPacket,
             rtcp_index % 3 == 0 ? MediaType::AUDIO : MediaType::VIDEO,
             rtcp_packets[rtcp_index - 1].data(),
             rtcp_packets[rtcp_index - 1].size());
         rtcp_index++;
-        fake_clock.AdvanceTimeMicroseconds(prng.Rand(1, 1000));
+        fake_clock.AdvanceTime(
+            rtc::TimeDelta::FromMicroseconds(prng.Rand(1, 1000)));
       }
       if (i * playout_count >= playout_index * rtp_count) {
         log_dumper->LogAudioPlayout(playout_ssrcs[playout_index - 1]);
         playout_index++;
-        fake_clock.AdvanceTimeMicroseconds(prng.Rand(1, 1000));
+        fake_clock.AdvanceTime(
+            rtc::TimeDelta::FromMicroseconds(prng.Rand(1, 1000)));
       }
       if (i * bwe_loss_count >= bwe_loss_index * rtp_count) {
         log_dumper->LogBwePacketLossEvent(
             bwe_loss_updates[bwe_loss_index - 1].first,
             bwe_loss_updates[bwe_loss_index - 1].second, i);
         bwe_loss_index++;
-        fake_clock.AdvanceTimeMicroseconds(prng.Rand(1, 1000));
+        fake_clock.AdvanceTime(
+            rtc::TimeDelta::FromMicroseconds(prng.Rand(1, 1000)));
       }
       if (i == rtp_count / 2) {
         log_dumper->StartLogging(temp_filename, 10000000);
-        fake_clock.AdvanceTimeMicroseconds(prng.Rand(1, 1000));
+        fake_clock.AdvanceTime(
+            rtc::TimeDelta::FromMicroseconds(prng.Rand(1, 1000)));
       }
     }
     log_dumper->StopLogging();
   }
 
   // Read the generated file from disk.
   ParsedRtcEventLog parsed_log;
 
   ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
 
@@ skipping 97 matching lines @@
       GenerateRtpPacket(nullptr, 0, packet_size, &prng);
   rtc::Buffer rtcp_packet = GenerateRtcpPacket(&prng);
 
   // Find the name of the current test, in order to use it as a temporary
   // filename.
   auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
   const std::string temp_filename =
       test::OutputPath() + test_info->test_case_name() + test_info->name();
 
   // Add RTP, start logging, add RTCP and then stop logging
-  SimulatedClock fake_clock(prng.Rand<uint32_t>());
-  std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create(&fake_clock));
+  rtc::ScopedFakeClock fake_clock;
+  fake_clock.SetTimeNanos(rtc::kNumNanosecsPerMicrosec * prng.Rand<uint32_t>());

[terelius, 2016/11/18 13:44:28]

Same thing here; could we add a convenience function to set the fake clock
without having to do unit conversions?

[nisse-webrtc, 2016/11/18 15:03:43]

Maybe a constructor taking a TimeDelta (or some int type, but we should maintain
some consistency with AdvanceTime).

+  std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create());
 
   log_dumper->LogRtpHeader(kIncomingPacket, MediaType::VIDEO, rtp_packet.data(),
                            rtp_packet.size());
-  fake_clock.AdvanceTimeMicroseconds(prng.Rand(1, 1000));
+  fake_clock.AdvanceTime(rtc::TimeDelta::FromMicroseconds(prng.Rand(1, 1000)));
 
   log_dumper->StartLogging(temp_filename, 10000000);
-  fake_clock.AdvanceTimeMicroseconds(prng.Rand(1, 1000));
+  fake_clock.AdvanceTime(rtc::TimeDelta::FromMicroseconds(prng.Rand(1, 1000)));
 
   log_dumper->LogRtcpPacket(kOutgoingPacket, MediaType::VIDEO,
                             rtcp_packet.data(), rtcp_packet.size());
-  fake_clock.AdvanceTimeMicroseconds(prng.Rand(1, 1000));
+  fake_clock.AdvanceTime(rtc::TimeDelta::FromMicroseconds(prng.Rand(1, 1000)));
 
   log_dumper->StopLogging();
 
   // Read the generated file from disk.
   ParsedRtcEventLog parsed_log;
   ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
 
   // Verify that what we read back from the event log is the same as
   // what we wrote down.
   EXPECT_EQ(4u, parsed_log.GetNumberOfEvents());
@@ skipping 28 matching lines @@
     // filename.
     auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
     const std::string temp_filename =
         test::OutputPath() + test_info->test_case_name() + test_info->name();
 
     // Use all extensions.
     uint32_t extensions_bitvector = (1u << kNumExtensions) - 1;
     GenerateConfig(extensions_bitvector);
 
     // Log a single config event and stop logging.
-    SimulatedClock fake_clock(prng.Rand<uint32_t>());
-    std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create(&fake_clock));
+    rtc::ScopedFakeClock fake_clock;
+    fake_clock.SetTimeNanos(rtc::kNumNanosecsPerMicrosec *
+                            prng.Rand<uint32_t>());
+    std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create());
 
     log_dumper->StartLogging(temp_filename, 10000000);
     LogConfig(log_dumper.get());
     log_dumper->StopLogging();
 
     // Read the generated file from disk.
     ParsedRtcEventLog parsed_log;
     ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
 
     // Check the generated number of events.
@@ skipping 92 matching lines @@
 TEST(RtcEventLogTest, LogVideoReceiveConfig) {
   VideoReceiveConfigReadWriteTest test;
   test.DoTest();
 }
 
 TEST(RtcEventLogTest, LogVideoSendConfig) {
   VideoSendConfigReadWriteTest test;
   test.DoTest();
 }
 }  // namespace webrtc