Cast: Make receiver use cast_transport

media/cast/net/rtcp/rtcp.cc

 // Copyright 2014 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/net/rtcp/rtcp.h"
 
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/net/cast_transport_defines.h"
@@ skipping 35 matching lines @@
   value1 <<= 16;
   value1 |= packet_id_or_zero;
   value1 <<= 32;
   value1 |= frame_rtp_timestamp;
   return std::make_pair(
       value1, static_cast<uint64>(event_timestamp.ToInternalValue()));
 }
 
 }  // namespace
 
-RtpReceiverStatistics::RtpReceiverStatistics() :
-    fraction_lost(0),
-    cumulative_lost(0),
-    extended_high_sequence_number(0),
-    jitter(0) {
-}
-
 Rtcp::Rtcp(const RtcpCastMessageCallback& cast_callback,
            const RtcpRttCallback& rtt_callback,
            const RtcpLogMessageCallback& log_callback,
            base::TickClock* clock,
            PacedPacketSender* packet_sender,
            uint32 local_ssrc,
            uint32 remote_ssrc)
     : cast_callback_(cast_callback),
       rtt_callback_(rtt_callback),
       log_callback_(log_callback),
@@ skipping 118 matching lines @@
 
     RtcpReceiverLogMessage::iterator tmp = i;
     ++i;
     if (messages->empty()) {
       receiver_log->erase(tmp);
     }
   }
   return !receiver_log->empty();
 }
 
-void Rtcp::SendRtcpFromRtpReceiver(
-    const RtcpCastMessage* cast_message,
-    base::TimeDelta target_delay,
-    const ReceiverRtcpEventSubscriber::RtcpEventMultiMap* rtcp_events,
-    RtpReceiverStatistics* rtp_receiver_statistics) {
-  base::TimeTicks now = clock_->NowTicks();
-  RtcpReportBlock report_block;
-  RtcpReceiverReferenceTimeReport rrtr;
+RtcpTimeData Rtcp::ConvertToNTPAndSave(base::TimeTicks now) {
+  RtcpTimeData ret;
+  ret.timestamp = now;
 
   // Attach our NTP to all RTCP packets; with this information a "smart" sender
   // can make decisions based on how old the RTCP message is.
-  ConvertTimeTicksToNtp(now, &rrtr.ntp_seconds, &rrtr.ntp_fraction);
-  SaveLastSentNtpTime(now, rrtr.ntp_seconds, rrtr.ntp_fraction);
+  ConvertTimeTicksToNtp(now, &ret.ntp_seconds, &ret.ntp_fraction);
+  SaveLastSentNtpTime(now, ret.ntp_seconds, ret.ntp_fraction);
+  return ret;
+}
+
+void Rtcp::SendRtcpFromRtpReceiver(
+    RtcpTimeData time_data,
+    const RtcpCastMessage* cast_message,
+    base::TimeDelta target_delay,
+    const ReceiverRtcpEventSubscriber::RtcpEvents* rtcp_events,
+    const RtpReceiverStatistics* rtp_receiver_statistics) const {
+  RtcpReportBlock report_block;
+  RtcpReceiverReferenceTimeReport rrtr;
+  rrtr.ntp_seconds = time_data.ntp_seconds;
+  rrtr.ntp_fraction = time_data.ntp_fraction;
 
   if (rtp_receiver_statistics) {
     report_block.remote_ssrc = 0;            // Not needed to set send side.
     report_block.media_ssrc = remote_ssrc_;  // SSRC of the RTP packet sender.
     report_block.fraction_lost = rtp_receiver_statistics->fraction_lost;
     report_block.cumulative_lost = rtp_receiver_statistics->cumulative_lost;
     report_block.extended_high_sequence_number =
         rtp_receiver_statistics->extended_high_sequence_number;
     report_block.jitter = rtp_receiver_statistics->jitter;
     report_block.last_sr = last_report_truncated_ntp_;
     if (!time_last_report_received_.is_null()) {
       uint32 delay_seconds = 0;
       uint32 delay_fraction = 0;
-      base::TimeDelta delta = now - time_last_report_received_;
+      base::TimeDelta delta = time_data.timestamp - time_last_report_received_;
       ConvertTimeToFractions(delta.InMicroseconds(), &delay_seconds,
                              &delay_fraction);
       report_block.delay_since_last_sr =
           ConvertToNtpDiff(delay_seconds, delay_fraction);
     } else {
       report_block.delay_since_last_sr = 0;
     }
   }
+  RtcpBuilder rtcp_builder(local_ssrc_);
   packet_sender_->SendRtcpPacket(
       local_ssrc_,
-      rtcp_builder_.BuildRtcpFromReceiver(
+      rtcp_builder.BuildRtcpFromReceiver(
           rtp_receiver_statistics ? &report_block : NULL,
           &rrtr,
           cast_message,
           rtcp_events,
           target_delay));
 }
 
 void Rtcp::SendRtcpFromRtpSender(base::TimeTicks current_time,
                                  uint32 current_time_as_rtp_timestamp,
                                  uint32 send_packet_count,
@@ skipping 131 matching lines @@
 }
 
 void Rtcp::OnReceivedReceiverLog(const RtcpReceiverLogMessage& receiver_log) {
   if (log_callback_.is_null())
     return;
   log_callback_.Run(receiver_log);
 }
 
 }  // namespace cast
 }  // namespace media