Cast: Add capabity to send Receiver and Sender log messages over RTCP.

media/cast/rtcp/rtcp.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/cast/rtcp/rtcp.h"
 
 #include "base/debug/trace_event.h"
 #include "base/rand_util.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_defines.h"
@@ skipping 34 matching lines @@
     : media_ssrc_(media_ssrc) {}
 
 RtcpCastMessage::~RtcpCastMessage() {}
 
 RtcpNackMessage::RtcpNackMessage() {}
 RtcpNackMessage::~RtcpNackMessage() {}
 
 RtcpRembMessage::RtcpRembMessage() {}
 RtcpRembMessage::~RtcpRembMessage() {}
 
-RtcpReceiverFrameLogMessage::RtcpReceiverFrameLogMessage() {}
+RtcpReceiverFrameLogMessage::RtcpReceiverFrameLogMessage(uint32 timestamp)
+    : rtp_timestamp(timestamp) {}

[mikhal, 2013/11/22 21:39:34]

just noticed: here too: rtp_timestamp_

+
 RtcpReceiverFrameLogMessage::~RtcpReceiverFrameLogMessage() {}
 
 class LocalRtcpReceiverFeedback : public RtcpReceiverFeedback {
  public:
   explicit LocalRtcpReceiverFeedback(Rtcp* rtcp)
       : rtcp_(rtcp) {
   }
 
   virtual void OnReceivedSenderReport(
       const RtcpSenderInfo& remote_sender_info) OVERRIDE {
@@ skipping 102 matching lines @@
   RtcpParser rtcp_parser(rtcp_buffer, length);
   if (!rtcp_parser.IsValid()) {
     // Silently ignore packet.
     DLOG(ERROR) << "Received invalid RTCP packet";
     return;
   }
   rtcp_receiver_->IncomingRtcpPacket(&rtcp_parser);
 }
 
 void Rtcp::SendRtcpFromRtpReceiver(const RtcpCastMessage* cast_message,
-                                   const RtcpReceiverLogMessage* receiver_log) {
+                                   RtcpReceiverLogMessage* receiver_log) {
   uint32 packet_type_flags = 0;
 
   base::TimeTicks now = clock_->NowTicks();
   RtcpReportBlock report_block;
   RtcpReceiverReferenceTimeReport rrtr;
 
   if (cast_message) {
     packet_type_flags |= RtcpSender::kRtcpCast;
   }
   if (receiver_log) {
@@ skipping 31 matching lines @@
     SaveLastSentNtpTime(now, rrtr.ntp_seconds, rrtr.ntp_fraction);
     UpdateNextTimeToSendRtcp();
   }
   rtcp_sender_->SendRtcpFromRtpReceiver(packet_type_flags,
                                         &report_block,
                                         &rrtr,
                                         cast_message,
                                         receiver_log);
 }
 
-void Rtcp::SendRtcpFromRtpSender(
-    const RtcpSenderLogMessage* sender_log_message) {
+void Rtcp::SendRtcpFromRtpSender(RtcpSenderLogMessage* sender_log_message) {
   uint32 packet_type_flags = RtcpSender::kRtcpSr;
   base::TimeTicks now = clock_->NowTicks();
 
+  if (sender_log_message) {
+    packet_type_flags |= RtcpSender::kRtcpSenderLog;
+  }
+
   RtcpSenderInfo sender_info;
-  RtcpDlrrReportBlock dlrr;
-
-  if (sender_log_message) packet_type_flags |= RtcpSender::kRtcpSenderLog;
-
   if (rtp_sender_statistics_) {
     rtp_sender_statistics_->GetStatistics(now, &sender_info);
   } else {
     memset(&sender_info, 0, sizeof(sender_info));
   }
   SaveLastSentNtpTime(now, sender_info.ntp_seconds, sender_info.ntp_fraction);
 
+  RtcpDlrrReportBlock dlrr;
   if (!time_last_report_received_.is_null()) {
     packet_type_flags |= RtcpSender::kRtcpDlrr;
     dlrr.last_rr = last_report_received_;
     uint32 delay_seconds = 0;
     uint32 delay_fraction = 0;
     base::TimeDelta delta = now - time_last_report_received_;
     ConvertTimeToFractions(delta.InMicroseconds(),
                            &delay_seconds,
                            &delay_fraction);
 
@@ skipping 156 matching lines @@
   int random = base::RandInt(0, 999);
   base::TimeDelta time_to_next = (rtcp_interval_ / 2) +
       (rtcp_interval_ * random / 1000);
 
   base::TimeTicks now = clock_->NowTicks();
   next_time_to_send_rtcp_ = now + time_to_next;
 }
 
 }  // namespace cast
 }  // namespace media