Fixes a bug which incorrectly logs incoming RTCP as outgoing.

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.
  */
 
@@ skipping 296 matching lines @@
 
   RTPSender rtp_sender(false,     // bool audio
                        clock,     // Clock* clock
                        nullptr,   // Transport*
                        nullptr,   // RtpAudioFeedback*
                        nullptr,   // PacedSender*
                        nullptr,   // PacketRouter*
                        nullptr,   // SendTimeObserver*
                        nullptr,   // BitrateStatisticsObserver*
                        nullptr,   // FrameCountObserver*
-                       nullptr);  // SendSideDelayObserver*
+                       nullptr,   // SendSideDelayObserver*
+                       nullptr);  // RtcEventLog*
 
   std::vector<uint32_t> csrcs;
   for (unsigned i = 0; i < csrcs_count; i++) {
     csrcs.push_back(prng->Rand<uint32_t>());
   }
   rtp_sender.SetCsrcs(csrcs);
   rtp_sender.SetSSRC(prng->Rand<uint32_t>());
   rtp_sender.SetStartTimestamp(prng->Rand<uint32_t>(), true);
   rtp_sender.SetSequenceNumber(prng->Rand<uint16_t>());
 
@@ skipping 145 matching lines @@
   // to disk.
   {
     rtc::scoped_ptr<RtcEventLog> log_dumper(RtcEventLog::Create());
     log_dumper->LogVideoReceiveStreamConfig(receiver_config);
     log_dumper->LogVideoSendStreamConfig(sender_config);
     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),  // Every second packet is incoming.
+          (i % 2 == 0) ? kIncomingPacket : kOutgoingPacket,
           (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 % 2 == 0) ? kIncomingPacket : kOutgoingPacket,
             rtcp_index % 3 == 0 ? MediaType::AUDIO : MediaType::VIDEO,
             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 * bwe_loss_count >= bwe_loss_index * rtp_count) {
@@ skipping 137 matching lines @@
   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->Buffer(),
+    log_dumper->LogRtpHeader(kOutgoingPacket, MediaType::AUDIO,
+                             old_rtp_packet.data(), old_rtp_packet.size());
+    log_dumper->LogRtcpPacket(kIncomingPacket, 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(),
+    log_dumper->LogRtpHeader(kIncomingPacket, MediaType::VIDEO,
+                             recent_rtp_packet.data(),
                              recent_rtp_packet.size());
-    log_dumper->LogRtcpPacket(false, MediaType::VIDEO,
+    log_dumper->LogRtcpPacket(kOutgoingPacket, MediaType::VIDEO,
                               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,
@@ skipping 16 matching lines @@
   // 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