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

media/cast/logging/stats_event_subscriber.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/stats_event_subscriber.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/format_macros.h"
@@ skipping 466 matching lines @@
   base::TimeDelta receiver_offset_upper_bound;
   if (!offset_estimator_->GetReceiverOffsetBounds(
           &receiver_offset_lower_bound, &receiver_offset_upper_bound)) {
     return false;
   }
 
   *offset = (receiver_offset_lower_bound + receiver_offset_upper_bound) / 2;
   return true;
 }
 
-void StatsEventSubscriber::MaybeInsertFrameInfo(RtpTimestamp rtp_timestamp,
+void StatsEventSubscriber::MaybeInsertFrameInfo(RtpTimeTicks rtp_timestamp,
                                                 const FrameInfo& frame_info) {
   // No need to insert if |rtp_timestamp| is the smaller than every key in the
   // map as it is just going to get erased anyway.
   if (recent_frame_infos_.size() == kMaxFrameInfoMapSize &&
       rtp_timestamp < recent_frame_infos_.begin()->first) {
     return;
   }
 
   recent_frame_infos_.insert(std::make_pair(rtp_timestamp, frame_info));
 
@@ skipping 91 matching lines @@
     base::TimeTicks receiver_time) {
   base::TimeDelta receiver_offset;
   if (!GetReceiverOffset(&receiver_offset))
     return;
   base::TimeTicks sender_time = receiver_time - receiver_offset;
   last_response_received_time_ = sender_time;
 }
 
 void StatsEventSubscriber::ErasePacketSentTime(
     const PacketEvent& packet_event) {
-  std::pair<RtpTimestamp, uint16_t> key(
+  std::pair<RtpTimeTicks, uint16_t> key(
       std::make_pair(packet_event.rtp_timestamp, packet_event.packet_id));
   packet_sent_times_.erase(key);
 }
 
 void StatsEventSubscriber::RecordPacketRelatedLatencies(
     const PacketEvent& packet_event) {
   // Log queueing latency.
   if (packet_event.type == PACKET_SENT_TO_NETWORK) {
     FrameInfoMap::iterator it =
         recent_frame_infos_.find(packet_event.rtp_timestamp);
     if (it != recent_frame_infos_.end()) {
       base::TimeDelta latency =
           packet_event.timestamp - it->second.encode_end_time;
       total_queueing_latency_ += latency;
       queueing_latency_datapoints_++;
       histograms_[QUEUEING_LATENCY_MS_HISTO]->Add(
           latency.InMillisecondsF());
     }
   }
 
   // Log network latency and total packet latency;
   base::TimeDelta receiver_offset;
   if (!GetReceiverOffset(&receiver_offset))
     return;
 
-  std::pair<RtpTimestamp, uint16_t> key(
+  std::pair<RtpTimeTicks, uint16_t> key(
       std::make_pair(packet_event.rtp_timestamp, packet_event.packet_id));
   PacketEventTimeMap::iterator it = packet_sent_times_.find(key);
   if (it == packet_sent_times_.end()) {
     std::pair<base::TimeTicks, CastLoggingEvent> value =
         std::make_pair(packet_event.timestamp, packet_event.type);
     packet_sent_times_.insert(std::make_pair(key, value));
     if (packet_sent_times_.size() > kMaxPacketEventTimeMapSize)
       packet_sent_times_.erase(packet_sent_times_.begin());
   } else {
     std::pair<base::TimeTicks, CastLoggingEvent> value = it->second;
@@ skipping 111 matching lines @@
     : event_counter(0), sum_size(0) {}
 StatsEventSubscriber::PacketLogStats::~PacketLogStats() {}
 
 StatsEventSubscriber::FrameInfo::FrameInfo() : encoded(false) {
 }
 StatsEventSubscriber::FrameInfo::~FrameInfo() {
 }
 
 }  // namespace cast
 }  // namespace media