Fixes a bug which incorrectly logs incoming RTCP as outgoing.

webrtc/modules/rtp_rtcp/source/rtp_sender.cc

 /*
  *  Copyright (c) 2012 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.
  */
 
 #include "webrtc/modules/rtp_rtcp/source/rtp_sender.h"
 
 #include <stdlib.h>  // srand
 #include <algorithm>
 #include <utility>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/trace_event.h"
+#include "webrtc/call.h"
+#include "webrtc/call/rtc_event_log.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_cvo.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_sender_audio.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_sender_video.h"
 #include "webrtc/modules/rtp_rtcp/source/time_util.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/tick_util.h"
 
 namespace webrtc {
 
@@ skipping 85 matching lines @@
 RTPSender::RTPSender(
     bool audio,
     Clock* clock,
     Transport* transport,
     RtpAudioFeedback* audio_feedback,
     RtpPacketSender* paced_sender,
     TransportSequenceNumberAllocator* sequence_number_allocator,
     TransportFeedbackObserver* transport_feedback_observer,
     BitrateStatisticsObserver* bitrate_callback,
     FrameCountObserver* frame_count_observer,
-    SendSideDelayObserver* send_side_delay_observer)
+    SendSideDelayObserver* send_side_delay_observer,
+    RtcEventLog* event_log)
     : clock_(clock),
       // TODO(holmer): Remove this conversion when we remove the use of
       // TickTime.
       clock_delta_ms_(clock_->TimeInMilliseconds() -
                       TickTime::MillisecondTimestamp()),
       random_(clock_->TimeInMicroseconds()),
       bitrates_(new BitrateAggregator(bitrate_callback)),
       total_bitrate_sent_(clock, bitrates_->total_bitrate_observer()),
       audio_configured_(audio),
       audio_(audio ? new RTPSenderAudio(clock, this, audio_feedback) : nullptr),
@@ skipping 18 matching lines @@
       // NACK.
       nack_byte_count_times_(),
       nack_byte_count_(),
       nack_bitrate_(clock, bitrates_->retransmit_bitrate_observer()),
       packet_history_(clock),
       // Statistics
       statistics_crit_(CriticalSectionWrapper::CreateCriticalSection()),
       rtp_stats_callback_(NULL),
       frame_count_observer_(frame_count_observer),
       send_side_delay_observer_(send_side_delay_observer),
+      event_log_(event_log),
       // RTP variables
       start_timestamp_forced_(false),
       start_timestamp_(0),
       ssrc_db_(*SSRCDatabase::GetSSRCDatabase()),
       remote_ssrc_(0),
       sequence_number_forced_(false),
       ssrc_forced_(false),
       timestamp_(0),
       capture_time_ms_(0),
       last_timestamp_time_ms_(0),
@@ skipping 574 matching lines @@
 }
 
 bool RTPSender::SendPacketToNetwork(const uint8_t* packet,
                                     size_t size,
                                     const PacketOptions& options) {
   int bytes_sent = -1;
   if (transport_) {
     bytes_sent = transport_->SendRtp(packet, size, options)
                      ? static_cast<int>(size)
                      : -1;
+    if (event_log_ && bytes_sent > 0) {
+      event_log_->LogRtpHeader(kOutgoingPacket, MediaType::ANY, packet, size);
+    }
   }
   TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                        "RTPSender::SendPacketToNetwork", "size", size, "sent",
                        bytes_sent);
   // TODO(pwestin): Add a separate bitrate for sent bitrate after pacer.
   if (bytes_sent <= 0) {
     LOG(LS_WARNING) << "Transport failed to send packet";
     return false;
   }
   return true;
@@ skipping 253 matching lines @@
   return bytes_sent;
 }
 
 // TODO(pwestin): send in the RtpHeaderParser to avoid parsing it again.
 int32_t RTPSender::SendToNetwork(uint8_t* buffer,
                                  size_t payload_length,
                                  size_t rtp_header_length,
                                  int64_t capture_time_ms,
                                  StorageType storage,
                                  RtpPacketSender::Priority priority) {
-  RtpUtility::RtpHeaderParser rtp_parser(buffer,
-                                         payload_length + rtp_header_length);
+  size_t length = payload_length + rtp_header_length;
+  RtpUtility::RtpHeaderParser rtp_parser(buffer, length);
+
   RTPHeader rtp_header;
   rtp_parser.Parse(&rtp_header);
 
   int64_t now_ms = clock_->TimeInMilliseconds();
 
   // |capture_time_ms| <= 0 is considered invalid.
   // TODO(holmer): This should be changed all over Video Engine so that negative
   // time is consider invalid, while 0 is considered a valid time.
   if (capture_time_ms > 0) {
-    UpdateTransmissionTimeOffset(buffer, payload_length + rtp_header_length,
-                                 rtp_header, now_ms - capture_time_ms);
+    UpdateTransmissionTimeOffset(buffer, length, rtp_header,
+                                 now_ms - capture_time_ms);
   }
 
-  UpdateAbsoluteSendTime(buffer, payload_length + rtp_header_length,
-                         rtp_header, now_ms);
+  UpdateAbsoluteSendTime(buffer, length, rtp_header, now_ms);
 
   // Used for NACK and to spread out the transmission of packets.
-  if (packet_history_.PutRTPPacket(buffer, rtp_header_length + payload_length,
-                                   capture_time_ms, storage) != 0) {
+  if (packet_history_.PutRTPPacket(buffer, length, capture_time_ms, storage) !=
+      0) {
     return -1;
   }
 
   if (paced_sender_) {
     // Correct offset between implementations of millisecond time stamps in
     // TickTime and Clock.
     int64_t corrected_time_ms = capture_time_ms + clock_delta_ms_;
     paced_sender_->InsertPacket(priority, rtp_header.ssrc,
                                 rtp_header.sequenceNumber, corrected_time_ms,
                                 payload_length, false);
     if (last_capture_time_ms_sent_ == 0 ||
         corrected_time_ms > last_capture_time_ms_sent_) {
       last_capture_time_ms_sent_ = corrected_time_ms;
       TRACE_EVENT_ASYNC_BEGIN1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                                "PacedSend", corrected_time_ms,
                                "capture_time_ms", corrected_time_ms);
     }
     return 0;
   }
   if (capture_time_ms > 0) {
     UpdateDelayStatistics(capture_time_ms, now_ms);
   }
 
-  size_t length = payload_length + rtp_header_length;
   bool sent = SendPacketToNetwork(buffer, length, PacketOptions());
 
   // Mark the packet as sent in the history even if send failed. Dropping a
   // packet here should be treated as any other packet drop so we should be
   // ready for a retransmission.
   packet_history_.SetSent(rtp_header.sequenceNumber);
 
   if (!sent)
     return -1;
 
@@ skipping 813 matching lines @@
   CriticalSectionScoped lock(send_critsect_.get());
 
   RtpState state;
   state.sequence_number = sequence_number_rtx_;
   state.start_timestamp = start_timestamp_;
 
   return state;
 }
 
 }  // namespace webrtc