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

media/cast/logging/encoding_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/encoding_event_subscriber.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <cstring>
@@ skipping 33 matching lines @@
 }
 
 }
 
 namespace media {
 namespace cast {
 
 EncodingEventSubscriber::EncodingEventSubscriber(
     EventMediaType event_media_type,
     size_t max_frames)
-    : event_media_type_(event_media_type),
-      max_frames_(max_frames),
-      frame_event_storage_index_(0),
-      packet_event_storage_index_(0),
-      seen_first_rtp_timestamp_(false),
-      first_rtp_timestamp_(0u) {}
+    : event_media_type_(event_media_type), max_frames_(max_frames) {
+  Reset();
+}
 
 EncodingEventSubscriber::~EncodingEventSubscriber() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void EncodingEventSubscriber::OnReceiveFrameEvent(
     const FrameEvent& frame_event) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (event_media_type_ != frame_event.media_type)
     return;
 
-  RtpTimestamp relative_rtp_timestamp =
+  const RtpTimeDelta relative_rtp_timestamp =
       GetRelativeRtpTimestamp(frame_event.rtp_timestamp);
   FrameEventMap::iterator it = frame_event_map_.find(relative_rtp_timestamp);
   linked_ptr<AggregatedFrameEvent> event_proto;
 
   // Look up existing entry. If not found, create a new entry and add to map.
   if (it == frame_event_map_.end()) {
     event_proto.reset(new AggregatedFrameEvent);
-    event_proto->set_relative_rtp_timestamp(relative_rtp_timestamp);
+    event_proto->set_relative_rtp_timestamp(
+        relative_rtp_timestamp.lower_32_bits());
     frame_event_map_.insert(
         std::make_pair(relative_rtp_timestamp, event_proto));
   } else {
     event_proto = it->second;
     if (event_proto->event_type_size() >= kMaxEventsPerProto) {
       DVLOG(2) << "Too many events in frame " << frame_event.rtp_timestamp
                << ". Using new frame event proto.";
       AddFrameEventToStorage(event_proto);
       event_proto.reset(new AggregatedFrameEvent);
-      event_proto->set_relative_rtp_timestamp(relative_rtp_timestamp);
+      event_proto->set_relative_rtp_timestamp(
+          relative_rtp_timestamp.lower_32_bits());
       it->second = event_proto;
     }
   }
 
   event_proto->add_event_type(ToProtoEventType(frame_event.type));
   event_proto->add_event_timestamp_ms(
       (frame_event.timestamp - base::TimeTicks()).InMilliseconds());
 
   if (frame_event.type == FRAME_CAPTURE_END) {
     if (frame_event.media_type == VIDEO_EVENT &&
@@ skipping 28 matching lines @@
   DCHECK(frame_event_storage_.size() <= max_frames_);
 }
 
 void EncodingEventSubscriber::OnReceivePacketEvent(
     const PacketEvent& packet_event) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (event_media_type_ != packet_event.media_type)
     return;
 
-  RtpTimestamp relative_rtp_timestamp =
+  const RtpTimeDelta relative_rtp_timestamp =
       GetRelativeRtpTimestamp(packet_event.rtp_timestamp);
   PacketEventMap::iterator it =
       packet_event_map_.find(relative_rtp_timestamp);
   linked_ptr<AggregatedPacketEvent> event_proto;
   BasePacketEvent* base_packet_event_proto = NULL;
 
   // Look up existing entry. If not found, create a new entry and add to map.
   if (it == packet_event_map_.end()) {
     event_proto.reset(new AggregatedPacketEvent);
-    event_proto->set_relative_rtp_timestamp(relative_rtp_timestamp);
+    event_proto->set_relative_rtp_timestamp(
+        relative_rtp_timestamp.lower_32_bits());
     packet_event_map_.insert(
         std::make_pair(relative_rtp_timestamp, event_proto));
     base_packet_event_proto = GetNewBasePacketEvent(
         event_proto.get(), packet_event.packet_id, packet_event.size);
   } else {
     // Found existing entry, now look up existing BasePacketEvent using packet
     // ID. If not found, create a new entry and add to proto.
     event_proto = it->second;
     RepeatedPtrField<BasePacketEvent>* field =
         event_proto->mutable_base_packet_event();
     for (RepeatedPtrField<BasePacketEvent>::pointer_iterator base_it =
              field->pointer_begin();
          base_it != field->pointer_end();
          ++base_it) {
       if ((*base_it)->packet_id() == packet_event.packet_id) {
         base_packet_event_proto = *base_it;
         break;
       }
     }
     if (!base_packet_event_proto) {
       if (event_proto->base_packet_event_size() >= kMaxPacketsPerFrame) {
         DVLOG(3) << "Too many packets in AggregatedPacketEvent "
                  << packet_event.rtp_timestamp << ". "
                  << "Using new packet event proto.";
         AddPacketEventToStorage(event_proto);
         event_proto.reset(new AggregatedPacketEvent);
-        event_proto->set_relative_rtp_timestamp(relative_rtp_timestamp);
+        event_proto->set_relative_rtp_timestamp(
+            relative_rtp_timestamp.lower_32_bits());
         it->second = event_proto;
       }
 
       base_packet_event_proto = GetNewBasePacketEvent(
           event_proto.get(), packet_event.packet_id, packet_event.size);
     } else if (base_packet_event_proto->event_type_size() >=
                kMaxEventsPerProto) {
       DVLOG(3) << "Too many events in packet "
                << packet_event.rtp_timestamp << ", "
                << packet_event.packet_id << ". Using new packet event proto.";
       AddPacketEventToStorage(event_proto);
       event_proto.reset(new AggregatedPacketEvent);
-      event_proto->set_relative_rtp_timestamp(relative_rtp_timestamp);
+      event_proto->set_relative_rtp_timestamp(
+          relative_rtp_timestamp.lower_32_bits());
       it->second = event_proto;
       base_packet_event_proto = GetNewBasePacketEvent(
           event_proto.get(), packet_event.packet_id, packet_event.size);
     }
   }
 
   base_packet_event_proto->add_event_type(
       ToProtoEventType(packet_event.type));
   base_packet_event_proto->add_event_timestamp_ms(
       (packet_event.timestamp - base::TimeTicks()).InMilliseconds());
@@ skipping 18 matching lines @@
 
   // Flush all events.
   TransferFrameEvents(frame_event_map_.size());
   TransferPacketEvents(packet_event_map_.size());
   std::sort(frame_event_storage_.begin(), frame_event_storage_.end(),
             &IsRtpTimestampLessThan<linked_ptr<AggregatedFrameEvent> >);
   std::sort(packet_event_storage_.begin(), packet_event_storage_.end(),
             &IsRtpTimestampLessThan<linked_ptr<AggregatedPacketEvent> >);
 
   metadata->set_is_audio(event_media_type_ == AUDIO_EVENT);
-  metadata->set_first_rtp_timestamp(first_rtp_timestamp_);
+  metadata->set_first_rtp_timestamp(first_rtp_timestamp_.lower_32_bits());
   metadata->set_num_frame_events(frame_event_storage_.size());
   metadata->set_num_packet_events(packet_event_storage_.size());
   metadata->set_reference_timestamp_ms_at_unix_epoch(
       (base::TimeTicks::UnixEpoch() - base::TimeTicks()).InMilliseconds());
   frame_events->swap(frame_event_storage_);
   packet_events->swap(packet_event_storage_);
   Reset();
 }
 
 void EncodingEventSubscriber::TransferFrameEvents(size_t max_num_entries) {
@@ skipping 34 matching lines @@
 void EncodingEventSubscriber::AddPacketEventToStorage(
     const linked_ptr<AggregatedPacketEvent>& packet_event_proto) {
   if (packet_event_storage_.size() >= max_frames_)
     packet_event_storage_[packet_event_storage_index_] = packet_event_proto;
   else
     packet_event_storage_.push_back(packet_event_proto);
 
   packet_event_storage_index_ = (packet_event_storage_index_ + 1) % max_frames_;
 }
 
-RtpTimestamp EncodingEventSubscriber::GetRelativeRtpTimestamp(
-    RtpTimestamp rtp_timestamp) {
+RtpTimeDelta EncodingEventSubscriber::GetRelativeRtpTimestamp(
+    RtpTimeTicks rtp_timestamp) {
   if (!seen_first_rtp_timestamp_) {
     seen_first_rtp_timestamp_ = true;
     first_rtp_timestamp_ = rtp_timestamp;
   }
 
   return rtp_timestamp - first_rtp_timestamp_;
 }
 
 void EncodingEventSubscriber::Reset() {
   frame_event_map_.clear();
   frame_event_storage_.clear();
   frame_event_storage_index_ = 0;
   packet_event_map_.clear();
   packet_event_storage_.clear();
   packet_event_storage_index_ = 0;
   seen_first_rtp_timestamp_ = false;
-  first_rtp_timestamp_ = 0u;
+  first_rtp_timestamp_ = RtpTimeTicks();
 }
 
 }  // namespace cast
 }  // namespace media