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

media/cast/test/end2end_unittest.cc

 // Copyright 2013 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.
 //
 // This test generate synthetic data. For audio it's a sinusoid waveform with
 // frequency kSoundFrequency and different amplitudes. For video it's a pattern
 // that is shifting by one pixel per frame, each pixels neighbors right and down
 // is this pixels value +1, since the pixel value is 8 bit it will wrap
 // frequently within the image. Visually this will create diagonally color bands
 // that moves across the screen
@@ skipping 94 matching lines @@
   EXPECT_EQ(STATUS_INITIALIZED, status);
 }
 
 // This is wrapped in a struct because it needs to be put into a std::map.
 typedef struct {
   int counter[kNumOfLoggingEvents+1];
 } LoggingEventCounts;
 
 // Constructs a map from each frame (RTP timestamp) to counts of each event
 // type logged for that frame.
-std::map<RtpTimestamp, LoggingEventCounts> GetEventCountForFrameEvents(
+std::map<RtpTimeTicks, LoggingEventCounts> GetEventCountForFrameEvents(
     const std::vector<FrameEvent>& frame_events) {
-  std::map<RtpTimestamp, LoggingEventCounts> event_counter_for_frame;
-  for (std::vector<FrameEvent>::const_iterator it = frame_events.begin();
-       it != frame_events.end();
-       ++it) {
-    std::map<RtpTimestamp, LoggingEventCounts>::iterator map_it =
-        event_counter_for_frame.find(it->rtp_timestamp);
+  std::map<RtpTimeTicks, LoggingEventCounts> event_counter_for_frame;
+  for (const FrameEvent& frame_event : frame_events) {
+    auto map_it = event_counter_for_frame.find(frame_event.rtp_timestamp);
     if (map_it == event_counter_for_frame.end()) {
       LoggingEventCounts new_counter;
       memset(&new_counter, 0, sizeof(new_counter));
-      ++(new_counter.counter[it->type]);
+      ++(new_counter.counter[frame_event.type]);
       event_counter_for_frame.insert(
-          std::make_pair(it->rtp_timestamp, new_counter));
+          std::make_pair(frame_event.rtp_timestamp, new_counter));
     } else {
-      ++(map_it->second.counter[it->type]);
+      ++(map_it->second.counter[frame_event.type]);
     }
   }
   return event_counter_for_frame;
 }
 
 // Constructs a map from each packet (Packet ID) to counts of each event
 // type logged for that packet.
 std::map<uint16, LoggingEventCounts> GetEventCountForPacketEvents(
     const std::vector<PacketEvent>& packet_events) {
   std::map<uint16, LoggingEventCounts> event_counter_for_packet;
-  for (std::vector<PacketEvent>::const_iterator it = packet_events.begin();
-       it != packet_events.end();
-       ++it) {
-    std::map<uint16, LoggingEventCounts>::iterator map_it =
-        event_counter_for_packet.find(it->packet_id);
+  for (const PacketEvent& packet_event : packet_events) {
+    auto map_it = event_counter_for_packet.find(packet_event.packet_id);
     if (map_it == event_counter_for_packet.end()) {
       LoggingEventCounts new_counter;
       memset(&new_counter, 0, sizeof(new_counter));
-      ++(new_counter.counter[it->type]);
+      ++(new_counter.counter[packet_event.type]);
       event_counter_for_packet.insert(
-          std::make_pair(it->packet_id, new_counter));
+          std::make_pair(packet_event.packet_id, new_counter));
     } else {
-      ++(map_it->second.counter[it->type]);
+      ++(map_it->second.counter[packet_event.type]);
     }
   }
   return event_counter_for_packet;
 }
 
 // Shim that turns forwards packets from a test::PacketPipe to a
 // PacketReceiverCallback.
 class LoopBackPacketPipe : public test::PacketPipe {
  public:
   explicit LoopBackPacketPipe(const PacketReceiverCallback& packet_receiver)
@@ skipping 900 matching lines @@
 
   RunTasks(750);  // Make sure that we send a RTCP message with the log.
 
   // Logging tests.
   // Frame logging.
   // Verify that all frames and all required events were logged.
   event_subscriber_sender_.GetFrameEventsAndReset(&frame_events_);
 
   // For each frame, count the number of events that occurred for each event
   // for that frame.
-  std::map<RtpTimestamp, LoggingEventCounts> event_counter_for_frame =
+  std::map<RtpTimeTicks, LoggingEventCounts> event_counter_for_frame =
       GetEventCountForFrameEvents(frame_events_);
 
   // Verify that there are logs for expected number of frames.
   EXPECT_EQ(num_frames, static_cast<int>(event_counter_for_frame.size()));
 
   // Verify that each frame have the expected types of events logged.
-  for (std::map<RtpTimestamp, LoggingEventCounts>::iterator map_it =
+  for (std::map<RtpTimeTicks, LoggingEventCounts>::iterator map_it =
            event_counter_for_frame.begin();
-       map_it != event_counter_for_frame.end();
-       ++map_it) {
+       map_it != event_counter_for_frame.end(); ++map_it) {
     int total_event_count_for_frame = 0;
     for (int i = 0; i <= kNumOfLoggingEvents; ++i) {
       total_event_count_for_frame += map_it->second.counter[i];
     }
 
     int expected_event_count_for_frame = 0;
 
     EXPECT_EQ(1, map_it->second.counter[FRAME_CAPTURE_BEGIN]);
     expected_event_count_for_frame +=
         map_it->second.counter[FRAME_CAPTURE_BEGIN];
@@ skipping 87 matching lines @@
             test_receiver_audio_callback_->number_times_called());
 
   RunTasks(750);  // Make sure that we send a RTCP message with the log.
 
   // Logging tests.
   // Verify that all frames and all required events were logged.
   event_subscriber_sender_.GetFrameEventsAndReset(&frame_events_);
 
   // Construct a map from each frame (RTP timestamp) to a count of each event
   // type logged for that frame.
-  std::map<RtpTimestamp, LoggingEventCounts> event_counter_for_frame =
+  std::map<RtpTimeTicks, LoggingEventCounts> event_counter_for_frame =
       GetEventCountForFrameEvents(frame_events_);
 
   int encoded_count = 0;
 
   // Verify the right number of events were logged for each event type.
-  for (std::map<RtpTimestamp, LoggingEventCounts>::iterator it =
+  for (std::map<RtpTimeTicks, LoggingEventCounts>::iterator it =
            event_counter_for_frame.begin();
-       it != event_counter_for_frame.end();
-       ++it) {
+       it != event_counter_for_frame.end(); ++it) {
     encoded_count += it->second.counter[FRAME_ENCODED];
   }
 
   EXPECT_EQ(num_audio_frames_requested, encoded_count);
 
   // Verify that each frame have the expected types of events logged.
-  for (std::map<RtpTimestamp, LoggingEventCounts>::const_iterator map_it =
+  for (std::map<RtpTimeTicks, LoggingEventCounts>::const_iterator map_it =
            event_counter_for_frame.begin();
        map_it != event_counter_for_frame.end(); ++map_it) {
     int total_event_count_for_frame = 0;
     for (int j = 0; j <= kNumOfLoggingEvents; ++j)
       total_event_count_for_frame += map_it->second.counter[j];
 
     int expected_event_count_for_frame = 0;
 
     EXPECT_EQ(1, map_it->second.counter[FRAME_ENCODED]);
     expected_event_count_for_frame +=
@@ skipping 225 matching lines @@
   EXPECT_LT(jump, 220u);
 }
 
 // TODO(pwestin): Add repeatable packet loss test.
 // TODO(pwestin): Add test for misaligned send get calls.
 // TODO(pwestin): Add more tests that does not resample.
 // TODO(pwestin): Add test when we have starvation for our RunTask.
 
 }  // namespace cast
 }  // namespace media