Fixes a bug which incorrectly logs incoming RTCP as outgoing.

webrtc/call/rtc_event_log.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 29 matching lines @@
 class RtcEventLogImpl final : public RtcEventLog {
  public:
   void SetBufferDuration(int64_t buffer_duration_us) override {}
   void StartLogging(const std::string& file_name, int duration_ms) override {}
   bool StartLogging(rtc::PlatformFile log_file) override { return false; }
   void StopLogging(void) override {}
   void LogVideoReceiveStreamConfig(
       const VideoReceiveStream::Config& config) override {}
   void LogVideoSendStreamConfig(
       const VideoSendStream::Config& config) override {}
-  void LogRtpHeader(bool incoming,
+  void LogRtpHeader(PacketDirection direction,
                     MediaType media_type,
                     const uint8_t* header,
                     size_t packet_length) override {}
-  void LogRtcpPacket(bool incoming,
+  void LogRtcpPacket(PacketDirection direction,
                      MediaType media_type,
                      const uint8_t* packet,
                      size_t length) override {}
   void LogAudioPlayout(uint32_t ssrc) override {}
   void LogBwePacketLossEvent(int32_t bitrate,
                              uint8_t fraction_loss,
                              int32_t total_packets) override {}
 };
 
 #else  // ENABLE_RTC_EVENT_LOG is defined
 
 class RtcEventLogImpl final : public RtcEventLog {
  public:
   RtcEventLogImpl();
 
   void SetBufferDuration(int64_t buffer_duration_us) override;
   void StartLogging(const std::string& file_name, int duration_ms) override;
   bool StartLogging(rtc::PlatformFile log_file) override;
   void StopLogging() override;
   void LogVideoReceiveStreamConfig(
       const VideoReceiveStream::Config& config) override;
   void LogVideoSendStreamConfig(const VideoSendStream::Config& config) override;
-  void LogRtpHeader(bool incoming,
+  void LogRtpHeader(PacketDirection direction,
                     MediaType media_type,
                     const uint8_t* header,
                     size_t packet_length) override;
-  void LogRtcpPacket(bool incoming,
+  void LogRtcpPacket(PacketDirection direction,
                      MediaType media_type,
                      const uint8_t* packet,
                      size_t length) override;
   void LogAudioPlayout(uint32_t ssrc) override;
   void LogBwePacketLossEvent(int32_t bitrate,
                              uint8_t fraction_loss,
                              int32_t total_packets) override;
 
  private:
   // Starts logging. This function assumes the file_ has been opened succesfully
@@ skipping 228 matching lines @@
     sender_config->add_rtx_ssrcs(rtx_ssrc);
   }
   sender_config->set_rtx_payload_type(config.rtp.rtx.payload_type);
 
   rtclog::EncoderConfig* encoder = sender_config->mutable_encoder();
   encoder->set_name(config.encoder_settings.payload_name);
   encoder->set_payload_type(config.encoder_settings.payload_type);
   HandleEvent(&event);
 }
 
-void RtcEventLogImpl::LogRtpHeader(bool incoming,
+void RtcEventLogImpl::LogRtpHeader(PacketDirection direction,
                                    MediaType media_type,
                                    const uint8_t* header,
                                    size_t packet_length) {
   // Read header length (in bytes) from packet data.
   if (packet_length < 12u) {
     return;  // Don't read outside the packet.
   }
   const bool x = (header[0] & 0x10) != 0;
   const uint8_t cc = header[0] & 0x0f;
   size_t header_length = 12u + cc * 4u;
 
   if (x) {
     if (packet_length < 12u + cc * 4u + 4u) {
       return;  // Don't read outside the packet.
     }
     size_t x_len = ByteReader<uint16_t>::ReadBigEndian(header + 14 + cc * 4);
     header_length += (x_len + 1) * 4;
   }
 
   rtc::CritScope lock(&crit_);
   rtclog::Event rtp_event;
   rtp_event.set_timestamp_us(clock_->TimeInMicroseconds());
   rtp_event.set_type(rtclog::Event::RTP_EVENT);
-  rtp_event.mutable_rtp_packet()->set_incoming(incoming);
+  rtp_event.mutable_rtp_packet()->set_incoming(direction == kIncomingPacket);
   rtp_event.mutable_rtp_packet()->set_type(ConvertMediaType(media_type));
   rtp_event.mutable_rtp_packet()->set_packet_length(packet_length);
   rtp_event.mutable_rtp_packet()->set_header(header, header_length);
   HandleEvent(&rtp_event);
 }
 
-void RtcEventLogImpl::LogRtcpPacket(bool incoming,
+void RtcEventLogImpl::LogRtcpPacket(PacketDirection direction,
                                     MediaType media_type,
                                     const uint8_t* packet,
                                     size_t length) {
   rtc::CritScope lock(&crit_);
   rtclog::Event rtcp_event;
   rtcp_event.set_timestamp_us(clock_->TimeInMicroseconds());
   rtcp_event.set_type(rtclog::Event::RTCP_EVENT);
-  rtcp_event.mutable_rtcp_packet()->set_incoming(incoming);
+  rtcp_event.mutable_rtcp_packet()->set_incoming(direction == kIncomingPacket);
   rtcp_event.mutable_rtcp_packet()->set_type(ConvertMediaType(media_type));
 
   RTCPUtility::RtcpCommonHeader header;
   const uint8_t* block_begin = packet;
   const uint8_t* packet_end = packet + length;
   RTC_DCHECK(length <= IP_PACKET_SIZE);
   uint8_t buffer[IP_PACKET_SIZE];
   uint32_t buffer_length = 0;
   while (block_begin < packet_end) {
     if (!RtcpParseCommonHeader(block_begin, packet_end - block_begin,
@@ skipping 134 matching lines @@
 }
 
 #endif  // ENABLE_RTC_EVENT_LOG
 
 // RtcEventLog member functions.
 rtc::scoped_ptr<RtcEventLog> RtcEventLog::Create() {
   return rtc::scoped_ptr<RtcEventLog>(new RtcEventLogImpl());
 }
 
 }  // namespace webrtc