Split LogRtpHeader and LogRtcpPacket into separate versions for incoming and outgoing packets.

logging/rtc_event_log/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 15 matching lines @@
 #include "modules/rtp_rtcp/source/rtcp_packet/app.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/bye.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/common_header.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/extended_reports.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/psfb.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/rtpfb.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/sdes.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
+#include "modules/rtp_rtcp/source/rtp_packet_received.h"
+#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/constructormagic.h"
 #include "rtc_base/event.h"
 #include "rtc_base/ignore_wundef.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/protobuf_utils.h"
 #include "rtc_base/ptr_util.h"
 #include "rtc_base/sequenced_task_checker.h"
 #include "rtc_base/task_queue.h"
 #include "rtc_base/thread_annotations.h"
@@ skipping 59 matching lines @@
 
   bool StartLogging(const std::string& file_name,
                     int64_t max_size_bytes) override;
   bool StartLogging(rtc::PlatformFile platform_file,
                     int64_t max_size_bytes) override;
   void StopLogging() override;
   void LogVideoReceiveStreamConfig(const rtclog::StreamConfig& config) override;
   void LogVideoSendStreamConfig(const rtclog::StreamConfig& config) override;
   void LogAudioReceiveStreamConfig(const rtclog::StreamConfig& config) override;
   void LogAudioSendStreamConfig(const rtclog::StreamConfig& config) override;
+  // TODO(terelius): This can be removed as soon as the interface has been
+  // updated.
   void LogRtpHeader(PacketDirection direction,
                     const uint8_t* header,
                     size_t packet_length) override;
+  // TODO(terelius): This can be made private, non-virtual as soon as the
+  // interface has been updated.
   void LogRtpHeader(PacketDirection direction,
                     const uint8_t* header,
                     size_t packet_length,
                     int probe_cluster_id) override;
+  void LogIncomingRtpHeader(const RtpPacketReceived& packet) override;
+  void LogOutgoingRtpHeader(const RtpPacketToSend& packet,
+                            int probe_cluster_id) override;
+  // TODO(terelius): This can be made private, non-virtual as soon as the
+  // interface has been updated.
   void LogRtcpPacket(PacketDirection direction,
                      const uint8_t* packet,
                      size_t length) override;
+  void LogIncomingRtcpPacket(rtc::ArrayView<const uint8_t> packet) override;
+  void LogOutgoingRtcpPacket(rtc::ArrayView<const uint8_t> packet) override;
   void LogAudioPlayout(uint32_t ssrc) override;
   void LogLossBasedBweUpdate(int32_t bitrate_bps,
                              uint8_t fraction_loss,
                              int32_t total_packets) override;
   void LogDelayBasedBweUpdate(int32_t bitrate_bps,
                               BandwidthUsage detector_state) override;
   void LogAudioNetworkAdaptation(
       const AudioEncoderRuntimeConfig& config) override;
   void LogProbeClusterCreated(int id,
                               int bitrate_bps,
@@ skipping 276 matching lines @@
   for (const auto& e : config.rtp_extensions) {
     rtclog::RtpHeaderExtension* extension =
         sender_config->add_header_extensions();
     extension->set_name(e.uri);
     extension->set_id(e.id);
   }
 
   StoreEvent(std::move(event));
 }
 
+void RtcEventLogImpl::LogIncomingRtpHeader(const RtpPacketReceived& packet) {
+  LogRtpHeader(kIncomingPacket, packet.data(), packet.size(),
+               PacedPacketInfo::kNotAProbe);
+}
+
+void RtcEventLogImpl::LogOutgoingRtpHeader(const RtpPacketToSend& packet,
+                                           int probe_cluster_id) {
+  LogRtpHeader(kOutgoingPacket, packet.data(), packet.size(), probe_cluster_id);
+}
+
 void RtcEventLogImpl::LogRtpHeader(PacketDirection direction,
                                    const uint8_t* header,
                                    size_t packet_length) {
   LogRtpHeader(direction, header, packet_length, PacedPacketInfo::kNotAProbe);
 }
 
 void RtcEventLogImpl::LogRtpHeader(PacketDirection direction,
                                    const uint8_t* header,
                                    size_t packet_length,
                                    int probe_cluster_id) {
@@ skipping 17 matching lines @@
   rtp_event->set_timestamp_us(rtc::TimeMicros());
   rtp_event->set_type(rtclog::Event::RTP_EVENT);
   rtp_event->mutable_rtp_packet()->set_incoming(direction == kIncomingPacket);
   rtp_event->mutable_rtp_packet()->set_packet_length(packet_length);
   rtp_event->mutable_rtp_packet()->set_header(header, header_length);
   if (probe_cluster_id != PacedPacketInfo::kNotAProbe)
     rtp_event->mutable_rtp_packet()->set_probe_cluster_id(probe_cluster_id);
   StoreEvent(std::move(rtp_event));
 }
 
+void RtcEventLogImpl::LogIncomingRtcpPacket(
+    rtc::ArrayView<const uint8_t> packet) {
+  LogRtcpPacket(kIncomingPacket, packet.data(), packet.size());
+}
+
+void RtcEventLogImpl::LogOutgoingRtcpPacket(
+    rtc::ArrayView<const uint8_t> packet) {
+  LogRtcpPacket(kOutgoingPacket, packet.data(), packet.size());
+}
+
 void RtcEventLogImpl::LogRtcpPacket(PacketDirection direction,
                                     const uint8_t* packet,
                                     size_t length) {
   std::unique_ptr<rtclog::Event> rtcp_event(new rtclog::Event());
   rtcp_event->set_timestamp_us(rtc::TimeMicros());
   rtcp_event->set_type(rtclog::Event::RTCP_EVENT);
   rtcp_event->mutable_rtcp_packet()->set_incoming(direction == kIncomingPacket);
 
   rtcp::CommonHeader header;
   const uint8_t* block_begin = packet;
@@ skipping 346 matching lines @@
 #else
   return CreateNull();
 #endif  // ENABLE_RTC_EVENT_LOG
 }
 
 std::unique_ptr<RtcEventLog> RtcEventLog::CreateNull() {
   return std::unique_ptr<RtcEventLog>(new RtcEventLogNullImpl());
 }
 
 }  // namespace webrtc