Revert of Cast: Re-factor rtcp_sender.cc into rtcp_builder.cc and do some cleanup

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"
-#include "media/cast/net/pacing/paced_sender.h"
-#include "media/cast/net/rtcp/rtcp_builder.h"
 #include "media/cast/net/rtcp/rtcp_defines.h"
+#include "media/cast/net/rtcp/rtcp_sender.h"
 #include "media/cast/net/rtcp/rtcp_utility.h"
 
 using base::TimeDelta;
 
 namespace media {
 namespace cast {
 
 static const int32 kMaxRttMs = 10000;  // 10 seconds.
 // Reject packets that are older than 0.5 seconds older than
 // the newest packet we've seen so far. This protect internal
@@ skipping 34 matching lines @@
            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),
       clock_(clock),
-      rtcp_builder_(local_ssrc),
-      packet_sender_(packet_sender),
+      rtcp_sender_(new RtcpSender(packet_sender, local_ssrc)),
       local_ssrc_(local_ssrc),
       remote_ssrc_(remote_ssrc),
       last_report_truncated_ntp_(0),
       local_clock_ahead_by_(ClockDriftSmoother::GetDefaultTimeConstant()),
       lip_sync_rtp_timestamp_(0),
       lip_sync_ntp_timestamp_(0),
       min_rtt_(TimeDelta::FromMilliseconds(kMaxRttMs)),
       number_of_rtt_in_avg_(0) {
 }
 
@@ skipping 143 matching lines @@
       uint32 delay_fraction = 0;
       base::TimeDelta delta = now - 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;
     }
   }
-  packet_sender_->SendRtcpPacket(
-      local_ssrc_,
-      rtcp_builder_.BuildRtcpFromReceiver(
-          rtp_receiver_statistics ? &report_block : NULL,
-          &rrtr,
-          cast_message,
-          rtcp_events,
-          target_delay));
+  rtcp_sender_->SendRtcpFromRtpReceiver(
+      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,
                                  size_t send_octet_count) {
   uint32 current_ntp_seconds = 0;
   uint32 current_ntp_fractions = 0;
   ConvertTimeTicksToNtp(current_time, &current_ntp_seconds,
                         &current_ntp_fractions);
   SaveLastSentNtpTime(current_time, current_ntp_seconds,
                       current_ntp_fractions);
 
   RtcpSenderInfo sender_info;
   sender_info.ntp_seconds = current_ntp_seconds;
   sender_info.ntp_fraction = current_ntp_fractions;
   sender_info.rtp_timestamp = current_time_as_rtp_timestamp;
   sender_info.send_packet_count = send_packet_count;
   sender_info.send_octet_count = send_octet_count;
 
-  packet_sender_->SendRtcpPacket(
-      local_ssrc_,
-      rtcp_builder_.BuildRtcpFromSender(sender_info));
+  rtcp_sender_->SendRtcpFromRtpSender(sender_info);
 }
 
 void Rtcp::OnReceivedNtp(uint32 ntp_seconds, uint32 ntp_fraction) {
   last_report_truncated_ntp_ = ConvertToNtpDiff(ntp_seconds, ntp_fraction);
 
   const base::TimeTicks now = clock_->NowTicks();
   time_last_report_received_ = now;
 
   // TODO(miu): This clock offset calculation does not account for packet
   // transit time over the network.  End2EndTest.EvilNetwork confirms that this
@@ 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