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

media/cast/logging/log_deserializer.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/logging/log_deserializer.h"
 
 #include <utility>
 
 #include "base/big_endian.h"
 #include "base/memory/scoped_ptr.h"
 #include "third_party/zlib/zlib.h"
 
 using media::cast::FrameEventMap;
 using media::cast::PacketEventMap;
-using media::cast::RtpTimestamp;
+using media::cast::RtpTimeDelta;
+using media::cast::RtpTimeTicks;
 using media::cast::proto::AggregatedFrameEvent;
 using media::cast::proto::AggregatedPacketEvent;
 using media::cast::proto::BasePacketEvent;
 using media::cast::proto::LogMetadata;
 
 namespace {
 
 // Use 60MB of temp buffer to hold uncompressed data if |compress| is true.
 // This is double the size of temp buffer used during compression (30MB)
 // since the there are two streams in the blob.
@@ skipping 38 matching lines @@
   if (!to->has_target_bitrate() && from.has_target_bitrate())
     to->set_target_bitrate(from.target_bitrate());
 }
 
 bool PopulateDeserializedLog(base::BigEndianReader* reader,
                              media::cast::DeserializedLog* log) {
   FrameEventMap frame_event_map;
   PacketEventMap packet_event_map;
 
   int num_frame_events = log->metadata.num_frame_events();
-  RtpTimestamp relative_rtp_timestamp = 0;
+  RtpTimeTicks relative_rtp_timestamp;
   uint16 proto_size = 0;
   for (int i = 0; i < num_frame_events; i++) {
     if (!reader->ReadU16(&proto_size))
       return false;
 
     linked_ptr<AggregatedFrameEvent> frame_event(new AggregatedFrameEvent);
     if (!frame_event->ParseFromArray(reader->ptr(), proto_size))
       return false;
     if (!reader->Skip(proto_size))
       return false;
 
     // During serialization the RTP timestamp in proto is relative to previous
     // frame.
     // Adjust RTP timestamp back to value relative to first RTP timestamp.
+    relative_rtp_timestamp +=
+        RtpTimeDelta::FromTicks(frame_event->relative_rtp_timestamp());
     frame_event->set_relative_rtp_timestamp(
-        frame_event->relative_rtp_timestamp() + relative_rtp_timestamp);
-    relative_rtp_timestamp = frame_event->relative_rtp_timestamp();
+        relative_rtp_timestamp.lower_32_bits());
 
-    FrameEventMap::iterator it = frame_event_map.find(
-        frame_event->relative_rtp_timestamp());
+    FrameEventMap::iterator it = frame_event_map.find(relative_rtp_timestamp);
     if (it == frame_event_map.end()) {
       frame_event_map.insert(
-          std::make_pair(frame_event->relative_rtp_timestamp(), frame_event));
+          std::make_pair(relative_rtp_timestamp, frame_event));
     } else {
       // Events for the same frame might have been split into more than one
       // proto. Merge them.
       MergeFrameEvent(*frame_event, it->second);
     }
   }
 
   log->frame_events.swap(frame_event_map);
 
   int num_packet_events = log->metadata.num_packet_events();
-  relative_rtp_timestamp = 0;
+  relative_rtp_timestamp = RtpTimeTicks();
   for (int i = 0; i < num_packet_events; i++) {
     if (!reader->ReadU16(&proto_size))
       return false;
 
     linked_ptr<AggregatedPacketEvent> packet_event(new AggregatedPacketEvent);
     if (!packet_event->ParseFromArray(reader->ptr(), proto_size))
       return false;
     if (!reader->Skip(proto_size))
       return false;
 
+    relative_rtp_timestamp +=
+        RtpTimeDelta::FromTicks(packet_event->relative_rtp_timestamp());
     packet_event->set_relative_rtp_timestamp(
-        packet_event->relative_rtp_timestamp() + relative_rtp_timestamp);
-    relative_rtp_timestamp = packet_event->relative_rtp_timestamp();
+        relative_rtp_timestamp.lower_32_bits());
 
-    PacketEventMap::iterator it = packet_event_map.find(
-        packet_event->relative_rtp_timestamp());
+    PacketEventMap::iterator it = packet_event_map.find(relative_rtp_timestamp);
     if (it == packet_event_map.end()) {
       packet_event_map.insert(
-          std::make_pair(packet_event->relative_rtp_timestamp(), packet_event));
+          std::make_pair(relative_rtp_timestamp, packet_event));
     } else {
       // Events for the same frame might have been split into more than one
       // proto. Merge them.
       MergePacketEvent(*packet_event, it->second);
     }
   }
 
   log->packet_events.swap(packet_event_map);
 
   return true;
@@ skipping 104 matching lines @@
   } else {
     return DoDeserializeEvents(data, data_bytes, audio_log, video_log);
   }
 }
 
 DeserializedLog::DeserializedLog() {}
 DeserializedLog::~DeserializedLog() {}
 
 }  // namespace cast
 }  // namespace media