Keep config events in RtcEventLog even if they are old.

webrtc/video/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.
  */
 
 #ifdef ENABLE_RTC_EVENT_LOG
 
 #include <stdio.h>
 #include <string>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/thread.h"
 #include "webrtc/call.h"
 #include "webrtc/system_wrappers/interface/clock.h"
 #include "webrtc/test/test_suite.h"
 #include "webrtc/test/testsupport/fileutils.h"
 #include "webrtc/test/testsupport/gtest_disable.h"
 #include "webrtc/video/rtc_event_log.h"
 
 // Files generated at build-time by the protobuf compiler.
 #ifdef WEBRTC_ANDROID_PLATFORM_BUILD
 #include "external/webrtc/webrtc/video/rtc_event_log.pb.h"
@@ skipping 387 matching lines @@
   // Clean up temporary file - can be pretty slow.
   remove(temp_filename.c_str());
 }
 
 TEST(RtcEventLogTest, LogSessionAndReadBack) {
   LogSessionAndReadBack(5, 321);
   LogSessionAndReadBack(8, 3141592653u);
   LogSessionAndReadBack(9, 2718281828u);
 }
 
+void DropOldEvents(unsigned random_seed) {
+  std::vector<uint8_t> old_rtp_packet;
+  std::vector<uint8_t> recent_rtp_packet;
+  std::vector<uint8_t> old_rtcp_packet;
+  std::vector<uint8_t> recent_rtcp_packet;
+
+  VideoReceiveStream::Config receiver_config;
+  VideoSendStream::Config sender_config;
+
+  srand(random_seed);
+
+  // Create two RTP packets containing random data.
+  const size_t rtp_header_size = 20;
+  size_t packet_size = 1000 + rand() % 64;
+  old_rtp_packet.reserve(packet_size);
+  for (size_t j = 0; j < packet_size; j++) {
+    old_rtp_packet.push_back(rand());
+  }
+  packet_size = 1000 + rand() % 64;
+  recent_rtp_packet.reserve(packet_size);
+  for (size_t j = 0; j < packet_size; j++) {
+    recent_rtp_packet.push_back(rand());
+  }
+  // Create two RTCP packets containing random data.
+  packet_size = 1000 + rand() % 64;
+  old_rtcp_packet.reserve(packet_size);
+  for (size_t j = 0; j < packet_size; j++) {
+    old_rtcp_packet.push_back(rand());
+  }
+  packet_size = 1000 + rand() % 64;
+  recent_rtcp_packet.reserve(packet_size);
+  for (size_t j = 0; j < packet_size; j++) {
+    recent_rtcp_packet.push_back(rand());
+  }
+  // Create configurations for the video streams.
+  GenerateVideoReceiveConfig(&receiver_config);
+  GenerateVideoSendConfig(&sender_config);
+
+  // 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();
+
+  // The log file will be flushed to disk when the log_dumper goes out of scope.
+  {
+    rtc::scoped_ptr<RtcEventLog> log_dumper(RtcEventLog::Create());
+    log_dumper->SetBufferDuration(50000);
+    log_dumper->LogVideoReceiveStreamConfig(receiver_config);
+    log_dumper->LogVideoSendStreamConfig(sender_config);
+    log_dumper->LogRtpHeader(false, MediaType::AUDIO, old_rtp_packet.data(),
+                             rtp_header_size, old_rtp_packet.size());
+    log_dumper->LogRtcpPacket(true, MediaType::AUDIO, old_rtcp_packet.data(),
+                              old_rtcp_packet.size());
+    rtc::Thread::SleepMs(50);

[ivoc, 2015/08/25 08:03:21]

I wonder if the sleep should be a little bit longer than the buffer duration,
what if the 50 ms sleep turns out to be a bit less than 50000 us on the more
accurate clock?

[terelius, 2015/08/25 16:41:44]

On POSIX systems it uses nanosleep() which should sleep for at least that number
of nanoseconds, but on windows it uses some other sleep function. I can change
to 55 ms I suppose.

+    log_dumper->StartLogging(temp_filename, 10000000);
+    log_dumper->LogRtpHeader(true, MediaType::VIDEO, recent_rtp_packet.data(),
+                             rtp_header_size, recent_rtp_packet.size());
+    log_dumper->LogRtcpPacket(false, MediaType::VIDEO,
+                              recent_rtcp_packet.data(),
+                              recent_rtcp_packet.size());
+  }
+
+  // Read the generated file from disk.
+  rtclog::EventStream parsed_stream;
+  ASSERT_TRUE(RtcEventLog::ParseRtcEventLog(temp_filename, &parsed_stream));
+
+  // Verify the result.
+  EXPECT_EQ(5, parsed_stream.stream_size());
+  VerifyReceiveStreamConfig(parsed_stream.stream(0), receiver_config);
+  VerifySendStreamConfig(parsed_stream.stream(1), sender_config);
+  VerifyLogStartEvent(parsed_stream.stream(2));
+  VerifyRtpEvent(parsed_stream.stream(3), true, MediaType::VIDEO,
+                 recent_rtp_packet.data(), rtp_header_size,
+                 recent_rtp_packet.size());
+  VerifyRtcpEvent(parsed_stream.stream(4), false, MediaType::VIDEO,
+                  recent_rtcp_packet.data(), recent_rtcp_packet.size());
+
+  // Clean up temporary file - can be pretty slow.
+  remove(temp_filename.c_str());
+}
+
+TEST(RtcEventLogTest, DropOldEvents) {
+  DropOldEvents(141421356);
+  DropOldEvents(173205080);
+}
+
 }  // namespace webrtc
 
 #endif  // ENABLE_RTC_EVENT_LOG