Skip logging RTCP messages of type SDES and APP.

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.h>

[ivoc, 2015/11/02 10:51:18]

Is this used anywhere? 

[terelius, 2015/11/05 18:01:18]

You're right. It was used to access memcpy in a previous version. I've removed
it.

 #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/rtcp_packet.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_sender.h"
 #include "webrtc/system_wrappers/include/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
 #include "external/webrtc/webrtc/call/rtc_event_log.pb.h"
 #else
@@ skipping 97 matching lines @@
   ASSERT_TRUE(receiver_config.has_local_ssrc());
   EXPECT_EQ(config.rtp.local_ssrc, receiver_config.local_ssrc());
   // Check RTCP settings.
   ASSERT_TRUE(receiver_config.has_rtcp_mode());
   if (config.rtp.rtcp_mode == RtcpMode::kCompound)
     EXPECT_EQ(rtclog::VideoReceiveConfig::RTCP_COMPOUND,
               receiver_config.rtcp_mode());
   else
     EXPECT_EQ(rtclog::VideoReceiveConfig::RTCP_REDUCEDSIZE,
               receiver_config.rtcp_mode());
-  ASSERT_TRUE(receiver_config.has_receiver_reference_time_report());
-  EXPECT_EQ(config.rtp.rtcp_xr.receiver_reference_time_report,
-            receiver_config.receiver_reference_time_report());
   ASSERT_TRUE(receiver_config.has_remb());
   EXPECT_EQ(config.rtp.remb, receiver_config.remb());
   // Check RTX map.
   ASSERT_EQ(static_cast<int>(config.rtp.rtx.size()),
             receiver_config.rtx_map_size());
   for (const rtclog::RtxMap& rtx_map : receiver_config.rtx_map()) {
     ASSERT_TRUE(rtx_map.has_payload_type());
     ASSERT_TRUE(rtx_map.has_config());
     EXPECT_EQ(1u, config.rtp.rtx.count(rtx_map.payload_type()));
     const rtclog::RtxConfig& rtx_config = rtx_map.config();
@@ skipping 53 matching lines @@
   // Check RTX settings.
   ASSERT_EQ(static_cast<int>(config.rtp.rtx.ssrcs.size()),
             sender_config.rtx_ssrcs_size());
   for (int i = 0; i < sender_config.rtx_ssrcs_size(); i++) {
     EXPECT_EQ(config.rtp.rtx.ssrcs[i], sender_config.rtx_ssrcs(i));
   }
   if (sender_config.rtx_ssrcs_size() > 0) {
     ASSERT_TRUE(sender_config.has_rtx_payload_type());
     EXPECT_EQ(config.rtp.rtx.payload_type, sender_config.rtx_payload_type());
   }
-  // Check CNAME.
-  ASSERT_TRUE(sender_config.has_c_name());
-  EXPECT_EQ(config.rtp.c_name, sender_config.c_name());
   // Check encoder.
   ASSERT_TRUE(sender_config.has_encoder());
   ASSERT_TRUE(sender_config.encoder().has_name());
   ASSERT_TRUE(sender_config.encoder().has_payload_type());
   EXPECT_EQ(config.encoder_settings.payload_name,
             sender_config.encoder().name());
   EXPECT_EQ(config.encoder_settings.payload_type,
             sender_config.encoder().payload_type());
 }
 
 void VerifyRtpEvent(const rtclog::Event& event,
                     bool incoming,
                     MediaType media_type,
-                    uint8_t* header,
+                    const uint8_t* header,
                     size_t header_size,
                     size_t total_size) {
   ASSERT_TRUE(IsValidBasicEvent(event));
   ASSERT_EQ(rtclog::Event::RTP_EVENT, event.type());
   const rtclog::RtpPacket& rtp_packet = event.rtp_packet();
   ASSERT_TRUE(rtp_packet.has_incoming());
   EXPECT_EQ(incoming, rtp_packet.incoming());
   ASSERT_TRUE(rtp_packet.has_type());
   EXPECT_EQ(media_type, GetRuntimeMediaType(rtp_packet.type()));
   ASSERT_TRUE(rtp_packet.has_packet_length());
   EXPECT_EQ(total_size, rtp_packet.packet_length());
   ASSERT_TRUE(rtp_packet.has_header());
   ASSERT_EQ(header_size, rtp_packet.header().size());
   for (size_t i = 0; i < header_size; i++) {
     EXPECT_EQ(header[i], static_cast<uint8_t>(rtp_packet.header()[i]));
   }
 }
 
 void VerifyRtcpEvent(const rtclog::Event& event,
                      bool incoming,
                      MediaType media_type,
-                     uint8_t* packet,
+                     const uint8_t* packet,
                      size_t total_size) {
   ASSERT_TRUE(IsValidBasicEvent(event));
   ASSERT_EQ(rtclog::Event::RTCP_EVENT, event.type());
   const rtclog::RtcpPacket& rtcp_packet = event.rtcp_packet();
   ASSERT_TRUE(rtcp_packet.has_incoming());
   EXPECT_EQ(incoming, rtcp_packet.incoming());
   ASSERT_TRUE(rtcp_packet.has_type());
   EXPECT_EQ(media_type, GetRuntimeMediaType(rtcp_packet.type()));
   ASSERT_TRUE(rtcp_packet.has_packet_data());
   ASSERT_EQ(total_size, rtcp_packet.packet_data().size());
@@ skipping 64 matching lines @@
       packet, payload_type, marker_bit, capture_timestamp, capture_time_ms,
       timestamp_provided, inc_sequence_number);
 
   for (size_t i = header_size; i < packet_size; i++) {
     packet[i] = rand();
   }
 
   return header_size;
 }
 
-void GenerateRtcpPacket(uint8_t* packet, size_t packet_size) {
-  for (size_t i = 0; i < packet_size; i++) {
-    packet[i] = rand();
-  }
+rtc::scoped_ptr<rtcp::RawPacket> GenerateRtcpPacket() {
+  rtcp::ReportBlock report_block;
+  report_block.To(rand());  // kRemoteSsrc

[åsapersson, 2015/11/02 09:31:12]

// remote SSRC

[terelius, 2015/11/05 18:01:18]

Done.

+  report_block.WithFractionLost(rand()%50);

[åsapersson, 2015/11/02 09:31:12]

nit: add spaces before and after %

[terelius, 2015/11/05 18:01:18]

Done.

+
+  rtcp::SenderReport sender_report;
+  sender_report.From(rand());  // kSenderSsrc

[åsapersson, 2015/11/02 09:31:12]

// sender SSRC

[terelius, 2015/11/05 18:01:18]

Done.

+  sender_report.WithNtpSec(rand());
+  sender_report.WithNtpFrac(rand());
+  sender_report.WithPacketCount(rand());
+  sender_report.WithReportBlock(report_block);
+
+  return sender_report.Build();
 }
 
 void GenerateVideoReceiveConfig(uint32_t extensions_bitvector,
                                 VideoReceiveStream::Config* config) {
   // Create a map from a payload type to an encoder name.
   VideoReceiveStream::Decoder decoder;
   decoder.payload_type = rand();
   decoder.payload_name = (rand() % 2 ? "VP8" : "H264");
   config->decoders.push_back(decoder);
   // Add SSRCs for the stream.
   config->rtp.remote_ssrc = rand();
   config->rtp.local_ssrc = rand();
   // Add extensions and settings for RTCP.
   config->rtp.rtcp_mode =
       rand() % 2 ? RtcpMode::kCompound : RtcpMode::kReducedSize;
-  config->rtp.rtcp_xr.receiver_reference_time_report = (rand() % 2 == 1);
   config->rtp.remb = (rand() % 2 == 1);
   // Add a map from a payload type to a new ssrc and a new payload type for RTX.
   VideoReceiveStream::Config::Rtp::Rtx rtx_pair;
   rtx_pair.ssrc = rand();
   rtx_pair.payload_type = rand();
   config->rtp.rtx.insert(std::make_pair(rand(), rtx_pair));
   // Add header extensions.
   for (unsigned i = 0; i < kNumExtensions; i++) {
     if (extensions_bitvector & (1u << i)) {
       config->rtp.extensions.push_back(
           RtpExtension(kExtensionNames[i], rand()));
     }
   }
 }
 
 void GenerateVideoSendConfig(uint32_t extensions_bitvector,
                              VideoSendStream::Config* config) {
   // Create a map from a payload type to an encoder name.
   config->encoder_settings.payload_type = rand();
   config->encoder_settings.payload_name = (rand() % 2 ? "VP8" : "H264");
   // Add SSRCs for the stream.
   config->rtp.ssrcs.push_back(rand());
   // Add a map from a payload type to new ssrcs and a new payload type for RTX.
   config->rtp.rtx.ssrcs.push_back(rand());
   config->rtp.rtx.payload_type = rand();
-  // Add a CNAME.
-  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 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 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<rtc::scoped_ptr<rtcp::RawPacket> > 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);
 
   srand(random_seed);
 
   // Create rtp_count RTP packets containing random data.
   for (size_t i = 0; i < rtp_count; i++) {
     size_t packet_size = 1000 + rand() % 64;
     rtp_packets.push_back(rtc::Buffer(packet_size));
     size_t header_size = GenerateRtpPacket(extensions_bitvector, csrcs_count,
                                            rtp_packets[i].data(), packet_size);
     rtp_header_sizes.push_back(header_size);
   }
   // Create rtcp_count RTCP packets containing random data.
   for (size_t i = 0; i < rtcp_count; i++) {
-    size_t packet_size = 1000 + rand() % 64;
-    rtcp_packets.push_back(rtc::Buffer(packet_size));
-    GenerateRtcpPacket(rtcp_packets[i].data(), packet_size);
+    rtcp_packets.push_back(GenerateRtcpPacket());
   }
   // Create playout_count random SSRCs to use when logging AudioPlayout events.
   for (size_t i = 0; i < playout_count; i++) {
     playout_ssrcs.push_back(static_cast<uint32_t>(rand()));
   }
   // Create configurations for the video streams.
   GenerateVideoReceiveConfig(extensions_bitvector, &receiver_config);
   GenerateVideoSendConfig(extensions_bitvector, &sender_config);
   const int config_count = 2;
 
@@ skipping 12 matching lines @@
     size_t rtcp_index = 1, playout_index = 1;
     for (size_t i = 1; i <= rtp_count; i++) {
       log_dumper->LogRtpHeader(
           (i % 2 == 0),  // Every second packet is incoming.
           (i % 3 == 0) ? MediaType::AUDIO : MediaType::VIDEO,
           rtp_packets[i - 1].data(), rtp_packets[i - 1].size());
       if (i * rtcp_count >= rtcp_index * rtp_count) {
         log_dumper->LogRtcpPacket(
             rtcp_index % 2 == 0,  // Every second packet is incoming
             rtcp_index % 3 == 0 ? MediaType::AUDIO : MediaType::VIDEO,
-            rtcp_packets[rtcp_index - 1].data(),
-            rtcp_packets[rtcp_index - 1].size());
+            rtcp_packets[rtcp_index - 1]->Buffer(),
+            rtcp_packets[rtcp_index - 1]->Length());
         rtcp_index++;
       }
       if (i * playout_count >= playout_index * rtp_count) {
         log_dumper->LogAudioPlayout(playout_ssrcs[playout_index - 1]);
         playout_index++;
       }
       if (i == rtp_count / 2) {
         log_dumper->StartLogging(temp_filename, 10000000);
       }
     }
@@ skipping 17 matching lines @@
     VerifyRtpEvent(parsed_stream.stream(event_index),
                    (i % 2 == 0),  // Every second packet is incoming.
                    (i % 3 == 0) ? MediaType::AUDIO : MediaType::VIDEO,
                    rtp_packets[i - 1].data(), rtp_header_sizes[i - 1],
                    rtp_packets[i - 1].size());
     event_index++;
     if (i * rtcp_count >= rtcp_index * rtp_count) {
       VerifyRtcpEvent(parsed_stream.stream(event_index),
                       rtcp_index % 2 == 0,  // Every second packet is incoming.
                       rtcp_index % 3 == 0 ? MediaType::AUDIO : MediaType::VIDEO,
-                      rtcp_packets[rtcp_index - 1].data(),
-                      rtcp_packets[rtcp_index - 1].size());
+                      rtcp_packets[rtcp_index - 1]->Buffer(),
+                      rtcp_packets[rtcp_index - 1]->Length());
       event_index++;
       rtcp_index++;
     }
     if (i * playout_count >= playout_index * rtp_count) {
       VerifyPlayoutEvent(parsed_stream.stream(event_index),
                          playout_ssrcs[playout_index - 1]);
       event_index++;
       playout_index++;
     }
     if (i == rtp_count / 2) {
@@ skipping 37 matching lines @@
   }
 }
 
 // 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;
+  rtc::scoped_ptr<rtcp::RawPacket> old_rtcp_packet;
+  rtc::scoped_ptr<rtcp::RawPacket> 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;
   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);
+  old_rtcp_packet = GenerateRtcpPacket();
+  recent_rtcp_packet = GenerateRtcpPacket();
 
   // 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());
+    log_dumper->LogRtcpPacket(true, MediaType::AUDIO, old_rtcp_packet->Buffer(),
+                              old_rtcp_packet->Length());
     // 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());
+                              recent_rtcp_packet->Buffer(),
+                              recent_rtcp_packet->Length());
   }
 
   // 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());
+                  recent_rtcp_packet->Buffer(), recent_rtcp_packet->Length());
 
   // 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