Cast:Splitting rtcp sender

media/cast/rtcp/rtcp_defines.h

 // 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.
 
 #ifndef MEDIA_CAST_RTCP_RTCP_DEFINES_H_
 #define MEDIA_CAST_RTCP_RTCP_DEFINES_H_
 
 #include <list>
 #include <map>
 #include <set>
 
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/logging/logging_defines.h"
+#include "media/cast/net/cast_net_defines.h"
 
 namespace media {
 namespace cast {
 
 // Handle the per frame ACK and NACK messages.
 class RtcpCastMessage {
  public:
   explicit RtcpCastMessage(uint32 media_ssrc);
   ~RtcpCastMessage();
 
   uint32 media_ssrc_;
   uint32 ack_frame_id_;
   MissingFramesAndPacketsMap missing_frames_and_packets_;
 };
 
-// Log messages form sender to receiver.
-enum RtcpSenderFrameStatus {
-  kRtcpSenderFrameStatusUnknown = 0,
-  kRtcpSenderFrameStatusDroppedByEncoder = 1,
-  kRtcpSenderFrameStatusDroppedByFlowControl = 2,
-  kRtcpSenderFrameStatusSentToNetwork = 3,
-};
-
-struct RtcpSenderFrameLogMessage {
-  RtcpSenderFrameStatus frame_status;
-  uint32 rtp_timestamp;
-};
-
-typedef std::list<RtcpSenderFrameLogMessage> RtcpSenderLogMessage;
-
 // Log messages from receiver to sender.
 struct RtcpReceiverEventLogMessage {
   CastLoggingEvent type;
   base::TimeTicks event_timestamp;
   base::TimeDelta delay_delta;
   uint16 packet_id;
 };
 
 typedef std::list<RtcpReceiverEventLogMessage> RtcpReceiverEventLogMessages;
 
 class RtcpReceiverFrameLogMessage {
  public:
   explicit RtcpReceiverFrameLogMessage(uint32 rtp_timestamp);
   ~RtcpReceiverFrameLogMessage();
 
   uint32 rtp_timestamp_;
   RtcpReceiverEventLogMessages event_log_messages_;
 };
 
 typedef std::list<RtcpReceiverFrameLogMessage> RtcpReceiverLogMessage;
 
-struct RtcpSenderInfo {
-  // First three members are used for lipsync.
-  // First two members are used for rtt.
-  uint32 ntp_seconds;
-  uint32 ntp_fraction;
-  uint32 rtp_timestamp;
-  uint32 send_packet_count;
-  size_t send_octet_count;
-};
-
-struct RtcpReportBlock {
-  uint32 remote_ssrc;  // SSRC of sender of this report.
-  uint32 media_ssrc;  // SSRC of the RTP packet sender.
-  uint8 fraction_lost;
-  uint32 cumulative_lost;  // 24 bits valid.
-  uint32 extended_high_sequence_number;
-  uint32 jitter;
-  uint32 last_sr;
-  uint32 delay_since_last_sr;
-};
-
 struct RtcpRpsiMessage {
   uint32 remote_ssrc;
   uint8 payload_type;
   uint64 picture_id;
 };
 
 class RtcpNackMessage {
  public:
   RtcpNackMessage();
   ~RtcpNackMessage();
@@ skipping 10 matching lines @@
   uint32 remb_bitrate;
   std::list<uint32> remb_ssrcs;
 };
 
 struct RtcpReceiverReferenceTimeReport {
   uint32 remote_ssrc;
   uint32 ntp_seconds;
   uint32 ntp_fraction;
 };
 
-struct RtcpDlrrReportBlock {
-  uint32 last_rr;
-  uint32 delay_since_last_rr;
-};
-
-inline bool operator==(RtcpReportBlock lhs, RtcpReportBlock rhs) {
-  return lhs.remote_ssrc == rhs.remote_ssrc &&
-      lhs.media_ssrc == rhs.media_ssrc &&
-      lhs.fraction_lost == rhs.fraction_lost &&
-      lhs.cumulative_lost == rhs.cumulative_lost &&
-      lhs.extended_high_sequence_number == rhs.extended_high_sequence_number &&
-      lhs.jitter == rhs.jitter &&
-      lhs.last_sr == rhs.last_sr &&
-      lhs.delay_since_last_sr == rhs.delay_since_last_sr;
-}
-
 inline bool operator==(RtcpSenderInfo lhs, RtcpSenderInfo rhs) {
   return lhs.ntp_seconds == rhs.ntp_seconds &&
       lhs.ntp_fraction == rhs.ntp_fraction &&
       lhs.rtp_timestamp == rhs.rtp_timestamp &&
       lhs.send_packet_count == rhs.send_packet_count &&
       lhs.send_octet_count == rhs.send_octet_count;
 }
 
 inline bool operator==(RtcpReceiverReferenceTimeReport lhs,
                        RtcpReceiverReferenceTimeReport rhs) {
   return lhs.remote_ssrc == rhs.remote_ssrc &&
       lhs.ntp_seconds == rhs.ntp_seconds &&
       lhs.ntp_fraction == rhs.ntp_fraction;
 }
 
 }  // namespace cast
 }  // namespace media
 
 #endif  // MEDIA_CAST_RTCP_RTCP_DEFINES_H_