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

media/cast/net/rtcp/rtcp_utility.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_utility.h"
 
 #include <cmath>
 
 #include "base/logging.h"
 #include "media/cast/net/cast_transport_defines.h"
@@ skipping 18 matching lines @@
     remote_ssrc_(remote_ssrc),
     has_sender_report_(false),
     has_last_report_(false),
     has_cast_message_(false),
     has_receiver_reference_time_report_(false) {
 }
 
 RtcpParser::~RtcpParser() {}
 
 bool RtcpParser::Parse(base::BigEndianReader* reader) {
+  // Reset.
+  has_sender_report_ = false;
+  sender_report_ = RtcpSenderInfo();
+  has_last_report_ = false;
+  receiver_log_.clear();
+  has_cast_message_ = false;
+  has_receiver_reference_time_report_ = false;
+
   while (reader->remaining()) {
     RtcpCommonHeader header;
     if (!ParseCommonHeader(reader, &header))
       return false;
 
     base::StringPiece tmp;
     if (!reader->ReadPiece(&tmp, header.length_in_octets - 4))
       return false;
     base::BigEndianReader chunk(tmp.data(), tmp.size());
 
@@ skipping 65 matching lines @@
 
 bool RtcpParser::ParseSR(base::BigEndianReader* reader,
                          const RtcpCommonHeader& header) {
   uint32 sender_ssrc;
   if (!reader->ReadU32(&sender_ssrc))
     return false;
 
   if (sender_ssrc != remote_ssrc_)
     return true;
 
-  uint32 tmp;
+  uint32_t truncated_rtp_timestamp;
+  uint32 send_octet_count;
   if (!reader->ReadU32(&sender_report_.ntp_seconds) ||
       !reader->ReadU32(&sender_report_.ntp_fraction) ||
-      !reader->ReadU32(&sender_report_.rtp_timestamp) ||
+      !reader->ReadU32(&truncated_rtp_timestamp) ||
       !reader->ReadU32(&sender_report_.send_packet_count) ||
-      !reader->ReadU32(&tmp))
+      !reader->ReadU32(&send_octet_count))
     return false;
-  sender_report_.send_octet_count = tmp;
+  sender_report_.rtp_timestamp = last_parsed_sr_rtp_timestamp_ =
+      last_parsed_sr_rtp_timestamp_.Expand(truncated_rtp_timestamp);
+  sender_report_.send_octet_count = send_octet_count;
   has_sender_report_ = true;
 
   for (size_t block = 0; block < header.IC; block++)
     if (!ParseReportBlock(reader))
       return false;
 
   return true;
 }
 
 bool RtcpParser::ParseRR(base::BigEndianReader* reader,
@@ skipping 49 matching lines @@
         return false;
       break;
   }
   return true;
 }
 
 bool RtcpParser::ParseCastReceiverLogFrameItem(
     base::BigEndianReader* reader) {
 
   while (reader->remaining()) {
-    uint32 rtp_timestamp;
+    uint32 truncated_rtp_timestamp;
     uint32 data;
-    if (!reader->ReadU32(&rtp_timestamp) ||
-        !reader->ReadU32(&data))
+    if (!reader->ReadU32(&truncated_rtp_timestamp) || !reader->ReadU32(&data))
       return false;
 
     // We have 24 LSB of the event timestamp base on the wire.
     base::TimeTicks event_timestamp_base = base::TimeTicks() +
         base::TimeDelta::FromMilliseconds(data & 0xffffff);
 
     size_t num_events = 1 + static_cast<uint8>(data >> 24);
 
-    RtcpReceiverFrameLogMessage frame_log(rtp_timestamp);
+    const RtpTimeTicks frame_log_rtp_timestamp =
+        last_parsed_frame_log_rtp_timestamp_.Expand(truncated_rtp_timestamp);
+    RtcpReceiverFrameLogMessage frame_log(frame_log_rtp_timestamp);
     for (size_t event = 0; event < num_events; event++) {
       uint16 delay_delta_or_packet_id;
       uint16 event_type_and_timestamp_delta;
       if (!reader->ReadU16(&delay_delta_or_packet_id) ||
           !reader->ReadU16(&event_type_and_timestamp_delta))
         return false;
 
       RtcpReceiverEventLogMessage event_log;
       event_log.type = TranslateToLogEventFromWireFormat(
           static_cast<uint8>(event_type_and_timestamp_delta >> 12));
       event_log.event_timestamp =
           event_timestamp_base +
           base::TimeDelta::FromMilliseconds(
               event_type_and_timestamp_delta & 0xfff);
       if (event_log.type == PACKET_RECEIVED) {
         event_log.packet_id = delay_delta_or_packet_id;
       } else {
         event_log.delay_delta = base::TimeDelta::FromMilliseconds(
             static_cast<int16>(delay_delta_or_packet_id));
       }
       frame_log.event_log_messages_.push_back(event_log);
     }
 
+    last_parsed_frame_log_rtp_timestamp_ = frame_log_rtp_timestamp;
     receiver_log_.push_back(frame_log);
   }
 
   return true;
 }
 
 // RFC 4585.
 bool RtcpParser::ParseFeedbackCommon(base::BigEndianReader* reader,
                                      const RtcpCommonHeader& header) {
   // See RTC 4585 Section 6.4 for application specific feedback messages.
@@ skipping 188 matching lines @@
       static_cast<int64_t>(std::ceil(ntp_fractions / kMagicFractionalUnit));
 
   base::TimeDelta elapsed_since_unix_epoch = base::TimeDelta::FromMicroseconds(
       ntp_time_us -
       (kUnixEpochInNtpSeconds * base::Time::kMicrosecondsPerSecond));
   return base::TimeTicks::UnixEpoch() + elapsed_since_unix_epoch;
 }
 
 }  // namespace cast
 }  // namespace media