Skip logging RTCP messages of type SDES and APP.

webrtc/call/rtc_event_log_unittest.cc

Index: webrtc/call/rtc_event_log_unittest.cc
diff --git a/webrtc/call/rtc_event_log_unittest.cc b/webrtc/call/rtc_event_log_unittest.cc
index cae2a202e0e090835032b99a51ec1ff33d50936d..3e6a863034350d7f31edb14c9c05ad0183bc2a22 100644
--- a/webrtc/call/rtc_event_log_unittest.cc
+++ b/webrtc/call/rtc_event_log_unittest.cc
@@ -11,6 +11,7 @@
 #ifdef ENABLE_RTC_EVENT_LOG
 
 #include <stdio.h>
+#include <string.h>
 #include <string>
 #include <vector>
 
@@ -21,6 +22,7 @@
 #include "webrtc/base/thread.h"
 #include "webrtc/call.h"
 #include "webrtc/call/rtc_event_log.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_sender.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_sender.h"
 #include "webrtc/system_wrappers/interface/clock.h"
 #include "webrtc/test/test_suite.h"
@@ -138,9 +140,6 @@ void VerifyReceiveStreamConfig(const rtclog::Event& event,
   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.
@@ -214,9 +213,6 @@ void VerifySendStreamConfig(const rtclog::Event& event,
     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());
@@ -337,10 +333,61 @@ size_t GenerateRtpPacket(uint32_t extensions_bitvector,
   return header_size;
 }
 
-void GenerateRtcpPacket(uint8_t* packet, size_t packet_size) {
-  for (size_t i = 0; i < packet_size; i++) {
-    packet[i] = rand();
+void GenerateRtcpPacket(rtc::Buffer* packet) {

[åsapersson, 2015/10/28 14:16:43]

To generate rtcp packets, the RtcpPacket class could perhaps be used directly.

For example, could something like this be used?

  ReportBlock rb;
  rb.To(kRemoteSsrc);
  rb.WithFractionLost(55);

  SenderReport sr;
  sr.From(kSenderSsrc);
  sr.WithNtpSec(123);
  sr.WithNtpFrac(456);
  sr.WithReportBlock(rb);
  rtc::scoped_ptr<RawPacket> packet(sr.Build());

[terelius, 2015/10/30 11:17:18]

Thanks for the suggestion; the new code is much cleaner.

+  class OnePacketTransport : public Transport, public NullRtpData {
+   public:
+    OnePacketTransport(rtc::Buffer* packet) { packet_ = packet; }
+
+    bool SendRtp(const uint8_t* /*data*/,
+                 size_t /*len*/,
+                 const PacketOptions& /*options*/) override {
+      return false;
+    }
+    bool SendRtcp(const uint8_t* data, size_t len) override {
+      packet_->AppendData(data, len);
+      return true;
+    }
+    int OnReceivedPayloadData(const uint8_t* /*payload_data*/,
+                              const size_t /*payload_size*/,
+                              const WebRtcRTPHeader* /*rtp_header*/) override {
+      return 0;
+    }
+    rtc::Buffer* packet_;
+  };
+
+  packet->EnsureCapacity(IP_PACKET_SIZE);
+  packet->SetSize(0);
+  OnePacketTransport transport(packet);
+  SimulatedClock clock(1335900000);
+  rtc::scoped_ptr<ReceiveStatistics> receive_statistics(
+      ReceiveStatistics::Create(&clock));
+  RTCPSender::FeedbackState feedback_state;
+  RTCPSender rtcp_sender(false,                     // audio
+                         &clock,                    // clock
+                         receive_statistics.get(),  // Used to generate RR
+                         nullptr,  // packet_type_counter_observer
+                         &transport);
+  rtcp_sender.SetSSRC(rand());        // kSenderSsrc
+  rtcp_sender.SetRemoteSSRC(rand());  // kRemoteSsrc
+
+  // Insert packets in receive statistics
+  for (int i = 0; i < 5; i++) {
+    RTPHeader header;
+    header.ssrc = rand();
+    header.sequenceNumber = rand();
+    header.timestamp = rand();
+    header.headerLength = 12;
+    size_t kPacketLength = 100 + rand() % 100;
+    receive_statistics->IncomingPacket(header, kPacketLength, false);
   }
+
+  rtcp_sender.SetRTCPStatus(RtcpMode::kCompound);
+  rtcp_sender.SendRTCP(feedback_state, kRtcpRr);
+
+  // assert(transport.packet.size() <= packet_size);
+  // packet_size = transport.packet.size();
+  // memcpy(packet, transport.packet.data(), packet_size);
+  // return packet_size;

[stefan-webrtc, 2015/10/28 13:37:12]

Should this code be removed?

[terelius, 2015/10/30 11:17:18]

Yes. Done.

 }
 
 void GenerateVideoReceiveConfig(uint32_t extensions_bitvector,
@@ -356,7 +403,6 @@ void GenerateVideoReceiveConfig(uint32_t extensions_bitvector,
   // 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;
@@ -382,8 +428,6 @@ void GenerateVideoSendConfig(uint32_t extensions_bitvector,
   // 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)) {
@@ -423,9 +467,8 @@ void LogSessionAndReadBack(size_t rtp_count,
   }
   // 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(rtc::Buffer());
+    GenerateRtcpPacket(&(rtcp_packets[i]));
   }
   // Create playout_count random SSRCs to use when logging AudioPlayout events.
   for (size_t i = 0; i < playout_count; i++) {
@@ -575,12 +618,8 @@ void DropOldEvents(uint32_t extensions_bitvector,
       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);
+  GenerateRtcpPacket(&old_rtcp_packet);
+  GenerateRtcpPacket(&recent_rtcp_packet);
 
   // Create configurations for the video streams.
   GenerateVideoReceiveConfig(extensions_bitvector, &receiver_config);