Cast: Refactor RTCP handling

media/cast/net/rtcp/rtcp_receiver.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_receiver.h"
 
+#include "base/big_endian.h"
 #include "base/logging.h"
 #include "media/cast/net/cast_transport_defines.h"
 #include "media/cast/net/rtcp/rtcp_utility.h"
 
 namespace {
 
 // A receiver frame event is identified by frame RTP timestamp, event timestamp
 // and event type.
 // A receiver packet event is identified by all of the above plus packet id.
 // The key format is as follows:
@@ skipping 14 matching lines @@
   value1 |= frame_rtp_timestamp;
   return std::make_pair(
       value1, static_cast<uint64>(event_timestamp.ToInternalValue()));
 }
 
 }  // namespace
 
 namespace media {
 namespace cast {
 
-RtcpReceiver::RtcpReceiver(scoped_refptr<CastEnvironment> cast_environment,
-                           RtcpSenderFeedback* sender_feedback,
-                           RtcpReceiverFeedback* receiver_feedback,
-                           RtcpRttFeedback* rtt_feedback,
+RtcpReceiver::RtcpReceiver(RtcpMessageHandler* handler,
                            uint32 local_ssrc)
     : ssrc_(local_ssrc),
       remote_ssrc_(0),
-      sender_feedback_(sender_feedback),
-      receiver_feedback_(receiver_feedback),
-      rtt_feedback_(rtt_feedback),
-      cast_environment_(cast_environment),
-      receiver_event_history_size_(0) {}
+      handler_(handler),
+      receiver_event_history_size_(0) {
+  DCHECK(handler_);
+}
 
 RtcpReceiver::~RtcpReceiver() {}
 
+// static
+bool RtcpReceiver::IsRtcpPacket(const uint8* packet, size_t length) {
+  if (length < kMinLengthOfRtcp) {
+    LOG(ERROR) << "Invalid RTCP packet received.";
+    return false;
+  }
+
+  uint8 packet_type = packet[1];
+  if (packet_type >= kPacketTypeLow &&
+      packet_type <= kPacketTypeHigh) {
+    return true;
+  }
+  return false;
+}
+
+// static
+uint32 RtcpReceiver::GetSsrcOfSender(const uint8* rtcp_buffer, size_t length) {
+  if (length < kMinLengthOfRtcp)
+    return 0;
+  uint32 ssrc_of_sender;
+  base::BigEndianReader big_endian_reader(
+      reinterpret_cast<const char*>(rtcp_buffer), length);
+  big_endian_reader.Skip(4);  // Skip header
+  big_endian_reader.ReadU32(&ssrc_of_sender);
+  return ssrc_of_sender;
+}
+
 void RtcpReceiver::SetRemoteSSRC(uint32 ssrc) { remote_ssrc_ = ssrc; }
 
 void RtcpReceiver::SetCastReceiverEventHistorySize(size_t size) {
   receiver_event_history_size_ = size;
 }
 
 void RtcpReceiver::IncomingRtcpPacket(RtcpParser* rtcp_parser) {
   RtcpFieldTypes field_type = rtcp_parser->Begin();
   while (field_type != kRtcpNotValidCode) {
     // Each "case" is responsible for iterate the parser to the next top
@@ skipping 10 matching lines @@
         break;
       case kRtcpByeCode:
         HandleBYE(rtcp_parser);
         break;
       case kRtcpXrCode:
         HandleXr(rtcp_parser);
         break;
       case kRtcpGenericRtpFeedbackNackCode:
         HandleNACK(rtcp_parser);
         break;
-      case kRtcpGenericRtpFeedbackSrReqCode:
-        HandleSendReportRequest(rtcp_parser);
-        break;
       case kRtcpPayloadSpecificPliCode:
         HandlePLI(rtcp_parser);
         break;
       case kRtcpPayloadSpecificRpsiCode:
         HandleRpsi(rtcp_parser);
         break;
       case kRtcpPayloadSpecificFirCode:
         HandleFIR(rtcp_parser);
         break;
       case kRtcpPayloadSpecificAppCode:
         HandlePayloadSpecificApp(rtcp_parser);
         break;
       case kRtcpApplicationSpecificCastReceiverLogCode:
         HandleApplicationSpecificCastReceiverLog(rtcp_parser);
         break;
       case kRtcpPayloadSpecificRembCode:
       case kRtcpPayloadSpecificRembItemCode:
       case kRtcpPayloadSpecificCastCode:
       case kRtcpPayloadSpecificCastNackItemCode:
       case kRtcpApplicationSpecificCastReceiverLogFrameCode:
       case kRtcpApplicationSpecificCastReceiverLogEventCode:
       case kRtcpNotValidCode:
       case kRtcpReportBlockItemCode:
       case kRtcpSdesChunkCode:
+      case kRtcpGenericRtpFeedbackSrReqCode:
       case kRtcpGenericRtpFeedbackNackItemCode:
       case kRtcpPayloadSpecificFirItemCode:
       case kRtcpXrRrtrCode:
       case kRtcpXrDlrrCode:
       case kRtcpXrUnknownItemCode:
         rtcp_parser->Iterate();
         NOTREACHED() << "Invalid state";
         break;
     }
     field_type = rtcp_parser->FieldType();
@@ skipping 15 matching lines @@
     RtcpSenderInfo remote_sender_info;
     remote_sender_info.ntp_seconds =
         rtcp_field.sender_report.ntp_most_significant;
     remote_sender_info.ntp_fraction =
         rtcp_field.sender_report.ntp_least_significant;
     remote_sender_info.rtp_timestamp = rtcp_field.sender_report.rtp_timestamp;
     remote_sender_info.send_packet_count =
         rtcp_field.sender_report.sender_packet_count;
     remote_sender_info.send_octet_count =
         rtcp_field.sender_report.sender_octet_count;
-    if (receiver_feedback_) {
-      receiver_feedback_->OnReceivedSenderReport(remote_sender_info);
-    }
+    handler_->OnReceivedSenderReport(remote_sender_info);
   }
   rtcp_field_type = rtcp_parser->Iterate();
   while (rtcp_field_type == kRtcpReportBlockItemCode) {
     HandleReportBlock(&rtcp_field, remote_ssrc);
     rtcp_field_type = rtcp_parser->Iterate();
   }
 }
 
 void RtcpReceiver::HandleReceiverReport(RtcpParser* rtcp_parser) {
   RtcpFieldTypes rtcp_field_type = rtcp_parser->FieldType();
@@ skipping 35 matching lines @@
   RtcpReportBlock report_block;
   report_block.remote_ssrc = remote_ssrc;
   report_block.media_ssrc = rb.ssrc;
   report_block.fraction_lost = rb.fraction_lost;
   report_block.cumulative_lost = rb.cumulative_number_of_packets_lost;
   report_block.extended_high_sequence_number =
       rb.extended_highest_sequence_number;
   report_block.jitter = rb.jitter;
   report_block.last_sr = rb.last_sender_report;
   report_block.delay_since_last_sr = rb.delay_last_sender_report;
-
-  if (rtt_feedback_) {
-    rtt_feedback_->OnReceivedDelaySinceLastReport(
-        rb.ssrc, rb.last_sender_report, rb.delay_last_sender_report);
-  }
+  handler_->OnReceivedDelaySinceLastReport(
+      rb.last_sender_report, rb.delay_last_sender_report);
 }
 
 void RtcpReceiver::HandleSDES(RtcpParser* rtcp_parser) {
   RtcpFieldTypes field_type = rtcp_parser->Iterate();
   while (field_type == kRtcpSdesChunkCode) {
     HandleSDESChunk(rtcp_parser);
     field_type = rtcp_parser->Iterate();
   }
 }
 
@@ skipping 26 matching lines @@
 void RtcpReceiver::HandleRrtr(RtcpParser* rtcp_parser, uint32 remote_ssrc) {
   if (remote_ssrc_ != remote_ssrc) {
     // Not to us.
     return;
   }
   const RtcpField& rtcp_field = rtcp_parser->Field();
   RtcpReceiverReferenceTimeReport remote_time_report;
   remote_time_report.remote_ssrc = remote_ssrc;
   remote_time_report.ntp_seconds = rtcp_field.rrtr.ntp_most_significant;
   remote_time_report.ntp_fraction = rtcp_field.rrtr.ntp_least_significant;
-
-  if (receiver_feedback_) {
-    receiver_feedback_->OnReceiverReferenceTimeReport(remote_time_report);
-  }
+  handler_->OnReceiverReferenceTimeReport(remote_time_report);
 }
 
 void RtcpReceiver::HandleDlrr(RtcpParser* rtcp_parser) {
   const RtcpField& rtcp_field = rtcp_parser->Field();
   if (remote_ssrc_ != rtcp_field.dlrr.receivers_ssrc) {
     // Not to us.
     return;
   }
-  if (rtt_feedback_) {
-    rtt_feedback_->OnReceivedDelaySinceLastReport(
-        rtcp_field.dlrr.receivers_ssrc,
-        rtcp_field.dlrr.last_receiver_report,
-        rtcp_field.dlrr.delay_last_receiver_report);
-  }
+  handler_->OnReceivedDelaySinceLastReport(
+      rtcp_field.dlrr.last_receiver_report,
+      rtcp_field.dlrr.delay_last_receiver_report);
 }
 
 void RtcpReceiver::HandleNACK(RtcpParser* rtcp_parser) {
   const RtcpField& rtcp_field = rtcp_parser->Field();
   if (ssrc_ != rtcp_field.nack.media_ssrc) {
     RtcpFieldTypes field_type;
     // Message not to us. Iterate until we have passed this message.
     do {
       field_type = rtcp_parser->Iterate();
     } while (field_type == kRtcpGenericRtpFeedbackNackItemCode);
@@ skipping 34 matching lines @@
 
 void RtcpReceiver::HandlePLI(RtcpParser* rtcp_parser) {
   const RtcpField& rtcp_field = rtcp_parser->Field();
   if (ssrc_ == rtcp_field.pli.media_ssrc) {
     // Received a signal that we need to send a new key frame.
     VLOG(2) << "Cast RTCP received PLI on our SSRC " << ssrc_;
   }
   rtcp_parser->Iterate();
 }
 
-void RtcpReceiver::HandleSendReportRequest(RtcpParser* rtcp_parser) {
-  if (receiver_feedback_) {
-    receiver_feedback_->OnReceivedSendReportRequest();
-  }
-  rtcp_parser->Iterate();
-}
-
 void RtcpReceiver::HandleRpsi(RtcpParser* rtcp_parser) {
   const RtcpField& rtcp_field = rtcp_parser->Field();
   if (rtcp_parser->Iterate() != kRtcpPayloadSpecificRpsiCode) {
     return;
   }
   if (rtcp_field.rpsi.number_of_valid_bits % 8 != 0) {
     // Continue
     return;
   }
   uint64 rpsi_picture_id = 0;
@@ skipping 83 matching lines @@
           rtcp_field.cast_receiver_log.rtp_timestamp,
           rtcp_parser,
           &frame_log.event_log_messages_);
       field_type = rtcp_parser->Iterate();
     }
 
     if (!frame_log.event_log_messages_.empty())
       receiver_log.push_back(frame_log);
   }
 
-  if (receiver_feedback_ && !receiver_log.empty()) {
-    receiver_feedback_->OnReceivedReceiverLog(receiver_log);
-  }
+  if (!receiver_log.empty())
+    handler_->OnReceivedReceiverLog(receiver_log);
 }
 
 void RtcpReceiver::HandleApplicationSpecificCastReceiverEventLog(
     uint32 frame_rtp_timestamp,
     RtcpParser* rtcp_parser,
     RtcpReceiverEventLogMessages* event_log_messages) {
   const RtcpField& rtcp_field = rtcp_parser->Field();
 
   const uint8 event = rtcp_field.cast_receiver_log.event;
   const CastLoggingEvent event_type = TranslateToLogEventFromWireFormat(event);
@@ skipping 32 matching lines @@
   event_log.delay_delta = base::TimeDelta::FromMilliseconds(
       rtcp_field.cast_receiver_log.delay_delta_or_packet_id.delay_delta);
   event_log.packet_id =
       rtcp_field.cast_receiver_log.delay_delta_or_packet_id.packet_id;
   event_log_messages->push_back(event_log);
 }
 
 void RtcpReceiver::HandlePayloadSpecificCastItem(RtcpParser* rtcp_parser) {
   const RtcpField& rtcp_field = rtcp_parser->Field();
   RtcpCastMessage cast_message(remote_ssrc_);
-  cast_message.ack_frame_id_ = ack_frame_id_wrap_helper_.MapTo32bitsFrameId(
+  cast_message.ack_frame_id = ack_frame_id_wrap_helper_.MapTo32bitsFrameId(
       rtcp_field.cast_item.last_frame_id);
-  cast_message.target_delay_ms_ = rtcp_field.cast_item.target_delay_ms;
+  cast_message.target_delay_ms = rtcp_field.cast_item.target_delay_ms;
 
   RtcpFieldTypes packet_type = rtcp_parser->Iterate();
   while (packet_type == kRtcpPayloadSpecificCastNackItemCode) {
     const RtcpField& rtcp_field = rtcp_parser->Field();
     HandlePayloadSpecificCastNackItem(
-        &rtcp_field, &cast_message.missing_frames_and_packets_);
+        &rtcp_field, &cast_message.missing_frames_and_packets);
     packet_type = rtcp_parser->Iterate();
   }
-  if (sender_feedback_) {
-    sender_feedback_->OnReceivedCastFeedback(cast_message);
-  }
+  handler_->OnReceivedCastFeedback(cast_message);
 }
 
 void RtcpReceiver::HandlePayloadSpecificCastNackItem(
     const RtcpField* rtcp_field,
     MissingFramesAndPacketsMap* missing_frames_and_packets) {
 
   MissingFramesAndPacketsMap::iterator frame_it =
       missing_frames_and_packets->find(rtcp_field->cast_nack_item.frame_id);
 
   if (frame_it == missing_frames_and_packets->end()) {
@@ skipping 37 matching lines @@
 void RtcpReceiver::HandleFIRItem(const RtcpField* rtcp_field) {
   // Is it our sender that is requested to generate a new keyframe.
   if (ssrc_ != rtcp_field->fir_item.ssrc)
     return;
 
   VLOG(2) << "Cast RTCP received FIR on our SSRC " << ssrc_;
 }
 
 }  // namespace cast
 }  // namespace media