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

media/cast/net/rtcp/rtcp_builder_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/test/simple_test_tick_clock.h"
@@ skipping 47 matching lines @@
         EXPECT_EQ((*golden_packet)[x], packet->data[x]) <<
             "x = " << x << " / " << golden_packet->size();
         if ((*golden_packet)[x] != packet->data[x]) {
           if (++diffs > 5)
             break;
         }
       }
     }
   }
 
+  static RtpTimeTicks test_rtp_timestamp() {
+    return RtpTimeTicks().Expand(kRtpTimestamp);
+  }
+
   scoped_ptr<RtcpBuilder> rtcp_builder_;
 
   DISALLOW_COPY_AND_ASSIGN(RtcpBuilderTest);
 };
 
 TEST_F(RtcpBuilderTest, RtcpReceiverReport) {
   // Receiver report with report block.
   TestRtcpPacketBuilder p2;
   p2.AddRr(kSendingSsrc, 1);
   p2.AddRb(kMediaSsrc);
@@ skipping 111 matching lines @@
   ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events;
 
   ExpectPacketEQ(p.GetPacket(), rtcp_builder_->BuildRtcpFromReceiver(
                                     &report_block, &rrtr, &cast_message,
                                     &rtcp_events, kDefaultDelay));
 
   base::SimpleTestTickClock testing_clock;
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 
   p.AddReceiverLog(kSendingSsrc);
-  p.AddReceiverFrameLog(kRtpTimestamp, 2, kTimeBaseMs);
+  p.AddReceiverFrameLog(test_rtp_timestamp().lower_32_bits(), 2, kTimeBaseMs);
   p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0);
   p.AddReceiverEventLog(kLostPacketId1, PACKET_RECEIVED, kTimeDelayMs);
 
   FrameEvent frame_event;
-  frame_event.rtp_timestamp = kRtpTimestamp;
+  frame_event.rtp_timestamp = test_rtp_timestamp();
   frame_event.type = FRAME_ACK_SENT;
   frame_event.media_type = VIDEO_EVENT;
   frame_event.timestamp = testing_clock.NowTicks();
   event_subscriber.OnReceiveFrameEvent(frame_event);
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
 
   PacketEvent packet_event;
-  packet_event.rtp_timestamp = kRtpTimestamp;
+  packet_event.rtp_timestamp = test_rtp_timestamp();
   packet_event.type = PACKET_RECEIVED;
   packet_event.media_type = VIDEO_EVENT;
   packet_event.timestamp = testing_clock.NowTicks();
   packet_event.packet_id = kLostPacketId1;
   event_subscriber.OnReceivePacketEvent(packet_event);
   event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events);
   EXPECT_EQ(2u, rtcp_events.size());
 
   ExpectPacketEQ(p.GetPacket(), rtcp_builder_->BuildRtcpFromReceiver(
                                     &report_block, &rrtr, &cast_message,
@@ skipping 12 matching lines @@
 
   base::SimpleTestTickClock testing_clock;
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 
   p.AddReceiverLog(kSendingSsrc);
 
   int num_events = kMaxEventsPerRTCP;
 
   EXPECT_LE(num_events, static_cast<int>(kRtcpMaxReceiverLogMessages));
   p.AddReceiverFrameLog(
-      kRtpTimestamp + 2345,
+      (test_rtp_timestamp() + RtpTimeDelta::FromTicks(2345)).lower_32_bits(),
       num_events,
       kTimeBaseMs);
   for (int i = 0; i < num_events; i++) {
     p.AddReceiverEventLog(kLostPacketId1, PACKET_RECEIVED,
                           static_cast<uint16_t>(kTimeDelayMs * i));
   }
 
 
   ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT);
 
   for (size_t i = 0; i < kRtcpMaxReceiverLogMessages; ++i) {
     PacketEvent packet_event;
-    packet_event.rtp_timestamp = kRtpTimestamp + 2345;
+    packet_event.rtp_timestamp =
+        test_rtp_timestamp() + RtpTimeDelta::FromTicks(2345);
     packet_event.type = PACKET_RECEIVED;
     packet_event.media_type = VIDEO_EVENT;
     packet_event.timestamp = testing_clock.NowTicks();
     packet_event.packet_id = kLostPacketId1;
     event_subscriber.OnReceivePacketEvent(packet_event);
     testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
   }
 
   ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events;
   event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events);
@@ skipping 14 matching lines @@
   RtcpReportBlock report_block = GetReportBlock();
 
   base::SimpleTestTickClock testing_clock;
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 
   p.AddReceiverLog(kSendingSsrc);
 
   int num_events = kMaxEventsPerRTCP;
 
   for (int i = 0; i < num_events; i++) {
-    p.AddReceiverFrameLog(kRtpTimestamp + i, 1, kTimeBaseMs + i * kTimeDelayMs);
+    p.AddReceiverFrameLog(
+        (test_rtp_timestamp() + RtpTimeDelta::FromTicks(i)).lower_32_bits(),
+        1, kTimeBaseMs + i * kTimeDelayMs);
     p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0);
   }
 
   ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT);
 
   for (size_t i = 0; i < kRtcpMaxReceiverLogMessages; ++i) {
     FrameEvent frame_event;
-    frame_event.rtp_timestamp = kRtpTimestamp + static_cast<int>(i);
+    frame_event.rtp_timestamp =
+        test_rtp_timestamp() + RtpTimeDelta::FromTicks(i);
     frame_event.type = FRAME_ACK_SENT;
     frame_event.media_type = VIDEO_EVENT;
     frame_event.timestamp = testing_clock.NowTicks();
     event_subscriber.OnReceiveFrameEvent(frame_event);
     testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
   }
 
   ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events;
   event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events);
 
@@ skipping 13 matching lines @@
 
   base::SimpleTestTickClock testing_clock;
   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 
   p.AddReceiverLog(kSendingSsrc);
 
   // Log 11 events for a single frame, each |kTimeBetweenEventsMs| apart.
   // Only last 10 events will be sent because the first event is more than
   // 4095 milliseconds away from latest event.
   const int kTimeBetweenEventsMs = 410;
-  p.AddReceiverFrameLog(kRtpTimestamp, 10, kTimeBaseMs + kTimeBetweenEventsMs);
+  p.AddReceiverFrameLog(test_rtp_timestamp().lower_32_bits(), 10,
+                        kTimeBaseMs + kTimeBetweenEventsMs);
   for (int i = 0; i < 10; ++i) {
     p.AddReceiverEventLog(0, FRAME_ACK_SENT, i * kTimeBetweenEventsMs);
   }
 
   ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT);
   for (int i = 0; i < 11; ++i) {
     FrameEvent frame_event;
-    frame_event.rtp_timestamp = kRtpTimestamp;
+    frame_event.rtp_timestamp = test_rtp_timestamp();
     frame_event.type = FRAME_ACK_SENT;
     frame_event.media_type = VIDEO_EVENT;
     frame_event.timestamp = testing_clock.NowTicks();
     event_subscriber.OnReceiveFrameEvent(frame_event);
     testing_clock.Advance(
         base::TimeDelta::FromMilliseconds(kTimeBetweenEventsMs));
   }
 
   ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events;
   event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events);
@@ skipping 16 matching lines @@
   size_t packet_count = kNumResends * kResendDelay + 10;
   for (size_t i = 0; i < packet_count; i++) {
     TestRtcpPacketBuilder p;
     p.AddRr(kSendingSsrc, 1);
     p.AddRb(kMediaSsrc);
 
     p.AddReceiverLog(kSendingSsrc);
 
     int num_events = (i + kResendDelay) / kResendDelay;
     num_events = std::min<int>(num_events, kNumResends);
-    p.AddReceiverFrameLog(kRtpTimestamp, num_events,
+    p.AddReceiverFrameLog(test_rtp_timestamp().lower_32_bits(), num_events,
         time_base_ms - (num_events - 1) * kResendDelay *
         kTimeBetweenEventsMs);
     for (int i = 0; i < num_events; i++) {
       p.AddReceiverEventLog(0, FRAME_ACK_SENT,
                             base::checked_cast<uint16_t>(i * kResendDelay *
                                                          kTimeBetweenEventsMs));
     }
 
     FrameEvent frame_event;
-    frame_event.rtp_timestamp = kRtpTimestamp;
+    frame_event.rtp_timestamp = test_rtp_timestamp();
     frame_event.type = FRAME_ACK_SENT;
     frame_event.media_type = VIDEO_EVENT;
     frame_event.timestamp = testing_clock.NowTicks();
     event_subscriber.OnReceiveFrameEvent(frame_event);
 
     ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events;
     event_subscriber.GetRtcpEventsWithRedundancy(&rtcp_events);
 
     ExpectPacketEQ(p.GetPacket(),
                    rtcp_builder_->BuildRtcpFromReceiver(
                        &report_block, NULL, NULL, &rtcp_events, kDefaultDelay));
 
     testing_clock.Advance(
         base::TimeDelta::FromMilliseconds(kTimeBetweenEventsMs));
     time_base_ms += kTimeBetweenEventsMs;
   }
 }
 
 TEST_F(RtcpBuilderTest, RtcpSenderReport) {
   RtcpSenderInfo sender_info;
   sender_info.ntp_seconds = kNtpHigh;
   sender_info.ntp_fraction = kNtpLow;
-  sender_info.rtp_timestamp = kRtpTimestamp;
+  sender_info.rtp_timestamp = test_rtp_timestamp();
   sender_info.send_packet_count = kSendPacketCount;
   sender_info.send_octet_count = kSendOctetCount;
 
   // Sender report.
   TestRtcpPacketBuilder p;
   p.AddSr(kSendingSsrc, 0);
 
   ExpectPacketEQ(p.GetPacket(),
                  rtcp_builder_->BuildRtcpFromSender(sender_info));
 }
 
 }  // namespace cast
 }  // namespace media