Refactor: simplify interface of SenderRtcpSession and CastTransport.

media/cast/net/rtcp/sender_rtcp_session.cc

 // Copyright 2015 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 <algorithm>
 #include <limits>
 #include <utility>
 
 #include "base/big_endian.h"
 #include "base/time/time.h"
@@ skipping 50 matching lines @@
   value1 <<= 16;
   value1 |= packet_id_or_zero;
   value1 <<= 32;
   value1 |= frame_rtp_timestamp.lower_32_bits();
   return std::make_pair(
       value1, static_cast<uint64_t>(event_timestamp.ToInternalValue()));
 }
 
 }  // namespace
 
-SenderRtcpSession::SenderRtcpSession(
-    const RtcpCastMessageCallback& cast_callback,
-    const RtcpRttCallback& rtt_callback,
-    const RtcpLogMessageCallback& log_callback,
-    const RtcpPliCallback pli_callback,
-    base::TickClock* clock,
-    PacedPacketSender* packet_sender,
-    uint32_t local_ssrc,
-    uint32_t remote_ssrc)
+SenderRtcpSession::SenderRtcpSession(std::unique_ptr<Client> client,
+                                     base::TickClock* clock,
+                                     PacedPacketSender* packet_sender,
+                                     uint32_t local_ssrc,
+                                     uint32_t remote_ssrc)
     : clock_(clock),
       packet_sender_(packet_sender),
       local_ssrc_(local_ssrc),
       remote_ssrc_(remote_ssrc),
-      cast_callback_(cast_callback),
-      rtt_callback_(rtt_callback),
-      log_callback_(log_callback),
-      pli_callback_(pli_callback),
+      sender_rtcp_client_(std::move(client)),
       largest_seen_timestamp_(base::TimeTicks::FromInternalValue(
           std::numeric_limits<int64_t>::min())),
       parser_(local_ssrc, remote_ssrc),
       ack_frame_id_wrap_helper_(kFirstFrameId - 1) {}
 
 SenderRtcpSession::~SenderRtcpSession() {}
 
 bool SenderRtcpSession::IncomingRtcpPacket(const uint8_t* data, size_t length) {
   // Check if this is a valid RTCP packet.
   if (!IsRtcpPacket(data, length)) {
     VLOG(1) << "Rtcp@" << this << "::IncomingRtcpPacket() -- "
             << "Received an invalid (non-RTCP?) packet.";
     return false;
   }
 
   // Check if this packet is to us.
   uint32_t ssrc_of_sender = GetSsrcOfSender(data, length);
   if (ssrc_of_sender != remote_ssrc_) {
     return false;
   }
 
   // Parse this packet.
   base::BigEndianReader reader(reinterpret_cast<const char*>(data), length);
   if (parser_.Parse(&reader)) {
-    if (parser_.has_picture_loss_indicator()) {
-      if (!pli_callback_.is_null())
-        pli_callback_.Run();
-    }
+    if (parser_.has_picture_loss_indicator())
+      sender_rtcp_client_->OnPliReceived();
     if (parser_.has_receiver_reference_time_report()) {
       base::TimeTicks t = ConvertNtpToTimeTicks(
           parser_.receiver_reference_time_report().ntp_seconds,
           parser_.receiver_reference_time_report().ntp_fraction);
       if (t > largest_seen_timestamp_) {
         largest_seen_timestamp_ = t;
       } else if ((largest_seen_timestamp_ - t).InMilliseconds() >
                  kOutOfOrderMaxAgeMs) {
         // Reject packet, it is too old.
         VLOG(1) << "Rejecting RTCP packet as it is too old ("
                 << (largest_seen_timestamp_ - t).InMilliseconds() << " ms)";
         return true;
       }
     }
     if (parser_.has_receiver_log()) {
       if (DedupeReceiverLog(parser_.mutable_receiver_log())) {
-        OnReceivedReceiverLog(parser_.receiver_log());
+        sender_rtcp_client_->OnReceiverLogReceived(parser_.receiver_log());
       }
     }
     if (parser_.has_last_report()) {
       OnReceivedDelaySinceLastReport(parser_.last_report(),
                                      parser_.delay_since_last_report());
     }
     if (parser_.has_cast_message()) {
       parser_.mutable_cast_message()->ack_frame_id =
           ack_frame_id_wrap_helper_.MapTo32bitsFrameId(
               parser_.mutable_cast_message()->ack_frame_id);
-      OnReceivedCastFeedback(parser_.cast_message());
+      sender_rtcp_client_->OnCastMessageReceived(parser_.cast_message());
     }
   }
   return true;
 }
 
 void SenderRtcpSession::OnReceivedDelaySinceLastReport(
     uint32_t last_report,
     uint32_t delay_since_last_report) {
   RtcpSendTimeMap::iterator it = last_reports_sent_map_.find(last_report);
   if (it == last_reports_sent_map_.end()) {
     return;  // Feedback on another report.
   }
 
   const base::TimeDelta sender_delay = clock_->NowTicks() - it->second;
   const base::TimeDelta receiver_delay =
       ConvertFromNtpDiff(delay_since_last_report);
   current_round_trip_time_ = sender_delay - receiver_delay;
   // If the round trip time was computed as less than 1 ms, assume clock
   // imprecision by one or both peers caused a bad value to be calculated.
   // While plenty of networks do easily achieve less than 1 ms round trip time,
   // such a level of precision cannot be measured with our approach; and 1 ms is
   // good enough to represent "under 1 ms" for our use cases.
   current_round_trip_time_ =
       std::max(current_round_trip_time_, base::TimeDelta::FromMilliseconds(1));
 
-  if (!rtt_callback_.is_null())
-    rtt_callback_.Run(current_round_trip_time_);
+  sender_rtcp_client_->OnRttReceived(current_round_trip_time_);
 }
 
 void SenderRtcpSession::SaveLastSentNtpTime(const base::TimeTicks& now,
                                             uint32_t last_ntp_seconds,
                                             uint32_t last_ntp_fraction) {
   // Make sure |now| is always greater than the last element in
   // |last_reports_sent_queue_|.
   if (!last_reports_sent_queue_.empty()) {
     DCHECK(now >= last_reports_sent_queue_.back().second);
   }
@@ skipping 64 matching lines @@
   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;
 
   RtcpBuilder rtcp_builder(local_ssrc_);
   packet_sender_->SendRtcpPacket(local_ssrc_,
                                  rtcp_builder.BuildRtcpFromSender(sender_info));
 }
 
-void SenderRtcpSession::OnReceivedCastFeedback(
-    const RtcpCastMessage& cast_message) {
-  if (cast_callback_.is_null())
-    return;
-  cast_callback_.Run(cast_message);
-}
-
-void SenderRtcpSession::OnReceivedReceiverLog(
-    const RtcpReceiverLogMessage& receiver_log) {
-  if (log_callback_.is_null())
-    return;
-  log_callback_.Run(receiver_log);
-}
-
 }  // namespace cast
 }  // namespace media