Keep config events in RtcEventLog even if they are old.

webrtc/call/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/buffer.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/thread.h"
 #include "webrtc/call.h"
 #include "webrtc/call/rtc_event_log.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_sender.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"
 
 // Files generated at build-time by the protobuf compiler.
 #ifdef WEBRTC_ANDROID_PLATFORM_BUILD
@@ skipping 354 matching lines @@
   config->rtp.c_name = "some.user@some.host";
   // Add header extensions.
   for (unsigned i = 0; i < kNumExtensions; i++) {
     if (extensions_bitvector & (1u << i)) {
       config->rtp.extensions.push_back(
           RtpExtension(kExtensionNames[i], rand()));
     }
   }
 }
 
-// Test for the RtcEventLog class. Dumps some RTP packets to disk, then reads
-// them back to see if they match.
+// Test for the RtcEventLog class. Dumps some RTP packets and other events
+// to disk, then reads them back to see if they match.
 void LogSessionAndReadBack(size_t rtp_count,
                            size_t rtcp_count,
                            size_t playout_count,
                            uint32_t extensions_bitvector,
                            uint32_t csrcs_count,
-                           unsigned random_seed) {
+                           unsigned int random_seed) {
   ASSERT_LE(rtcp_count, rtp_count);
   ASSERT_LE(playout_count, rtp_count);
   std::vector<rtc::Buffer> rtp_packets;
   std::vector<rtc::Buffer> rtcp_packets;
   std::vector<size_t> rtp_header_sizes;
   std::vector<uint32_t> playout_ssrcs;
 
   VideoReceiveStream::Config receiver_config(nullptr);
   VideoSendStream::Config sender_config(nullptr);
 
@@ skipping 56 matching lines @@
         log_dumper->StartLogging(temp_filename, 10000000);
       }
     }
   }
 
   // Read the generated file from disk.
   rtclog::EventStream parsed_stream;
 
   ASSERT_TRUE(RtcEventLog::ParseRtcEventLog(temp_filename, &parsed_stream));
 
-  // Verify the result.
+  // Verify that what we read back from the event log is the same as
+  // what we wrote down. For RTCP we log the full packets, but for
+  // RTP we should only log the header.
   const int event_count =
       config_count + playout_count + rtcp_count + rtp_count + 1;
   EXPECT_EQ(event_count, parsed_stream.stream_size());
   VerifyReceiveStreamConfig(parsed_stream.stream(0), receiver_config);
   VerifySendStreamConfig(parsed_stream.stream(1), sender_config);
   size_t event_index = config_count, rtcp_index = 1, playout_index = 1;
   for (size_t i = 1; i <= rtp_count; i++) {
     VerifyRtpEvent(parsed_stream.stream(event_index),
                    (i % 2 == 0),  // Every second packet is incoming.
                    (i % 3 == 0) ? MediaType::AUDIO : MediaType::VIDEO,
@@ skipping 49 matching lines @@
       LogSessionAndReadBack(5 + extensions,   // Number of RTP packets.
                             2 + csrcs_count,  // Number of RTCP packets.
                             3 + csrcs_count,  // Number of playout events
                             extensions,       // Bit vector choosing extensions
                             csrcs_count,      // Number of contributing sources
                             rand());
     }
   }
 }
 
+// Tests that the event queue works correctly, i.e. drops old RTP, RTCP and
+// debug events, but keeps config events even if they are older than the limit.
+void DropOldEvents(uint32_t extensions_bitvector,
+                   uint32_t csrcs_count,
+                   unsigned int random_seed) {
+  rtc::Buffer old_rtp_packet;
+  rtc::Buffer recent_rtp_packet;
+  rtc::Buffer old_rtcp_packet;
+  rtc::Buffer recent_rtcp_packet;
+
+  VideoReceiveStream::Config receiver_config(nullptr);
+  VideoSendStream::Config sender_config(nullptr);
+
+  srand(random_seed);
+
+  // Create two RTP packets containing random data.
+  size_t packet_size = 1000 + rand() % 64;

[the sun, 2015/10/16 21:47:01]

Avoid rand() in unit tests; it accesses global state, so if used from multiple
threads, your random sequence may differ between test runs.

Here's a simple PRNG you can use instead: 
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/webrtc...

+  old_rtp_packet.SetSize(packet_size);
+  GenerateRtpPacket(extensions_bitvector, csrcs_count, old_rtp_packet.data(),
+                    packet_size);
+  packet_size = 1000 + rand() % 64;
+  recent_rtp_packet.SetSize(packet_size);
+  size_t recent_header_size = GenerateRtpPacket(
+      extensions_bitvector, csrcs_count, recent_rtp_packet.data(), packet_size);
+
+  // Create two RTCP packets containing random data.
+  packet_size = 1000 + rand() % 64;
+  old_rtcp_packet.SetSize(packet_size);
+  GenerateRtcpPacket(old_rtcp_packet.data(), packet_size);
+  packet_size = 1000 + rand() % 64;
+  recent_rtcp_packet.SetSize(packet_size);
+  GenerateRtcpPacket(recent_rtcp_packet.data(), packet_size);
+
+  // Create configurations for the video streams.
+  GenerateVideoReceiveConfig(extensions_bitvector, &receiver_config);
+  GenerateVideoSendConfig(extensions_bitvector, &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());
+    // Reduce the time old events are stored to 50 ms.
+    log_dumper->SetBufferDuration(50000);
+    log_dumper->LogVideoReceiveStreamConfig(receiver_config);
+    log_dumper->LogVideoSendStreamConfig(sender_config);
+    log_dumper->LogRtpHeader(false, MediaType::AUDIO, old_rtp_packet.data(),
+                             old_rtp_packet.size());
+    log_dumper->LogRtcpPacket(true, MediaType::AUDIO, old_rtcp_packet.data(),
+                              old_rtcp_packet.size());
+    // Sleep 55 ms to let old events be removed from the queue.
+    rtc::Thread::SleepMs(55);
+    log_dumper->StartLogging(temp_filename, 10000000);
+    log_dumper->LogRtpHeader(true, MediaType::VIDEO, recent_rtp_packet.data(),
+                             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 that what we read back from the event log is the same as
+  // what we wrote. Old RTP and RTCP events should have been discarded,
+  // but old configuration events should still be available.
+  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(), recent_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) {
+  // Enable all header extensions
+  uint32_t extensions = (1u << kNumExtensions) - 1;
+  uint32_t csrcs_count = 2;
+  DropOldEvents(extensions, csrcs_count, 141421356);
+  DropOldEvents(extensions, csrcs_count, 173205080);
+}
+
 }  // namespace webrtc
 
 #endif  // ENABLE_RTC_EVENT_LOG