Replace uses of raw uint32's with a type-checked RtpTimeTicks data type.

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 <limits>
 
 #include "base/time/time.h"
 #include "media/cast/cast_environment.h"
@@ skipping 46 matching lines @@
 // A receiver packet event is identified by all of the above plus packet id.
 // The key format is as follows:
 // First uint64_t:
 //   bits 0-11: zeroes (unused).
 //   bits 12-15: event type ID.
 //   bits 16-31: packet ID if packet event, 0 otherwise.
 //   bits 32-63: RTP timestamp.
 // Second uint64_t:
 //   bits 0-63: event TimeTicks internal value.
 std::pair<uint64_t, uint64_t> GetReceiverEventKey(
-    uint32_t frame_rtp_timestamp,
+    RtpTimeTicks frame_rtp_timestamp,
     const base::TimeTicks& event_timestamp,
     uint8_t event_type,
     uint16_t packet_id_or_zero) {
   uint64_t value1 = event_type;
   value1 <<= 16;
   value1 |= packet_id_or_zero;
   value1 <<= 32;
-  value1 |= frame_rtp_timestamp;
+  value1 |= frame_rtp_timestamp.lower_32_bits();
   return std::make_pair(
       value1, static_cast<uint64_t>(event_timestamp.ToInternalValue()));
 }
 
 }  // namespace
 
 Rtcp::Rtcp(const RtcpCastMessageCallback& cast_callback,
            const RtcpRttCallback& rtt_callback,
            const RtcpLogMessageCallback& log_callback,
            base::TickClock* clock,
            PacedPacketSender* packet_sender,
            uint32_t local_ssrc,
            uint32_t remote_ssrc)
     : cast_callback_(cast_callback),
       rtt_callback_(rtt_callback),
       log_callback_(log_callback),
       clock_(clock),
       rtcp_builder_(local_ssrc),
       packet_sender_(packet_sender),
       local_ssrc_(local_ssrc),
       remote_ssrc_(remote_ssrc),
+      parser_(local_ssrc_, remote_ssrc_),
       last_report_truncated_ntp_(0),
       local_clock_ahead_by_(ClockDriftSmoother::GetDefaultTimeConstant()),
-      lip_sync_rtp_timestamp_(0),
       lip_sync_ntp_timestamp_(0),
       largest_seen_timestamp_(base::TimeTicks::FromInternalValue(
           std::numeric_limits<int64_t>::min())),
       ack_frame_id_wrap_helper_(kFirstFrameId - 1) {}
 
 Rtcp::~Rtcp() {}
 
 bool Rtcp::IsRtcpPacket(const uint8_t* packet, size_t length) {
   if (length < kMinLengthOfRtcp) {
     LOG(ERROR) << "Invalid RTCP packet received.";
@@ skipping 23 matching lines @@
     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.
-  RtcpParser parser(local_ssrc_, remote_ssrc_);
   base::BigEndianReader reader(reinterpret_cast<const char*>(data), length);
-  if (parser.Parse(&reader)) {
-    if (parser.has_receiver_reference_time_report()) {
+  if (parser_.Parse(&reader)) {
+    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);
+          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;
       }
 
-      OnReceivedNtp(parser.receiver_reference_time_report().ntp_seconds,
-                    parser.receiver_reference_time_report().ntp_fraction);
+      OnReceivedNtp(parser_.receiver_reference_time_report().ntp_seconds,
+                    parser_.receiver_reference_time_report().ntp_fraction);
     }
-    if (parser.has_sender_report()) {
-      OnReceivedNtp(parser.sender_report().ntp_seconds,
-                    parser.sender_report().ntp_fraction);
-      OnReceivedLipSyncInfo(parser.sender_report().rtp_timestamp,
-                            parser.sender_report().ntp_seconds,
-                            parser.sender_report().ntp_fraction);
+    if (parser_.has_sender_report()) {
+      OnReceivedNtp(parser_.sender_report().ntp_seconds,
+                    parser_.sender_report().ntp_fraction);
+      OnReceivedLipSyncInfo(parser_.sender_report().rtp_timestamp,
+                            parser_.sender_report().ntp_seconds,
+                            parser_.sender_report().ntp_fraction);
     }
-    if (parser.has_receiver_log()) {
-      if (DedupeReceiverLog(parser.mutable_receiver_log())) {
-        OnReceivedReceiverLog(parser.receiver_log());
+    if (parser_.has_receiver_log()) {
+      if (DedupeReceiverLog(parser_.mutable_receiver_log())) {
+        OnReceivedReceiverLog(parser_.receiver_log());
       }
     }
-    if (parser.has_last_report()) {
-      OnReceivedDelaySinceLastReport(parser.last_report(),
-                                     parser.delay_since_last_report());
+    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 =
+    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());
+              parser_.mutable_cast_message()->ack_frame_id);
+      OnReceivedCastFeedback(parser_.cast_message());
     }
   }
   return true;
 }
 
 bool Rtcp::DedupeReceiverLog(RtcpReceiverLogMessage* receiver_log) {
   RtcpReceiverLogMessage::iterator i = receiver_log->begin();
   while (i != receiver_log->end()) {
     RtcpReceiverEventLogMessages* messages = &i->event_log_messages_;
     RtcpReceiverEventLogMessages::iterator j = messages->begin();
@@ skipping 72 matching lines @@
       local_ssrc_,
       rtcp_builder.BuildRtcpFromReceiver(
           rtp_receiver_statistics ? &report_block : NULL,
           &rrtr,
           cast_message,
           rtcp_events,
           target_delay));
 }
 
 void Rtcp::SendRtcpFromRtpSender(base::TimeTicks current_time,
-                                 uint32_t current_time_as_rtp_timestamp,
+                                 RtpTimeTicks current_time_as_rtp_timestamp,
                                  uint32_t send_packet_count,
                                  size_t send_octet_count) {
   uint32_t current_ntp_seconds = 0;
   uint32_t 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;
@@ skipping 28 matching lines @@
     // have been lower than usual, and so some of the error introduced by the
     // transmission time can be eliminated.
     local_clock_ahead_by_.Reset(now, measured_offset);
   }
   VLOG(1) << "Local clock is ahead of the remote clock by: "
           << "measured=" << measured_offset.InMicroseconds() << " usec, "
           << "filtered=" << local_clock_ahead_by_.Current().InMicroseconds()
           << " usec.";
 }
 
-void Rtcp::OnReceivedLipSyncInfo(uint32_t rtp_timestamp,
+void Rtcp::OnReceivedLipSyncInfo(RtpTimeTicks rtp_timestamp,
                                  uint32_t ntp_seconds,
                                  uint32_t ntp_fraction) {
   if (ntp_seconds == 0) {
     NOTREACHED();
     return;
   }
   lip_sync_rtp_timestamp_ = rtp_timestamp;
   lip_sync_ntp_timestamp_ =
       (static_cast<uint64_t>(ntp_seconds) << 32) | ntp_fraction;
 }
 
-bool Rtcp::GetLatestLipSyncTimes(uint32_t* rtp_timestamp,
+bool Rtcp::GetLatestLipSyncTimes(RtpTimeTicks* rtp_timestamp,
                                  base::TimeTicks* reference_time) const {
   if (!lip_sync_ntp_timestamp_)
     return false;
 
   const base::TimeTicks local_reference_time =
       ConvertNtpToTimeTicks(
           static_cast<uint32_t>(lip_sync_ntp_timestamp_ >> 32),
           static_cast<uint32_t>(lip_sync_ntp_timestamp_)) +
       local_clock_ahead_by_.Current();
 
@@ skipping 64 matching lines @@
 }
 
 void Rtcp::OnReceivedReceiverLog(const RtcpReceiverLogMessage& receiver_log) {
   if (log_callback_.is_null())
     return;
   log_callback_.Run(receiver_log);
 }
 
 }  // namespace cast
 }  // namespace media