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

media/cast/net/rtcp/rtcp_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 <stdint.h>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "media/cast/net/cast_transport_config.h"
@@ skipping 125 matching lines @@
   Rtcp rtcp_for_sender_;
   Rtcp rtcp_for_receiver_;
 
   DISALLOW_COPY_AND_ASSIGN(RtcpTest);
 };
 
 TEST_F(RtcpTest, LipSyncGleanedFromSenderReport) {
   // Initially, expect no lip-sync info receiver-side without having first
   // received a RTCP packet.
   base::TimeTicks reference_time;
-  uint32 rtp_timestamp;
+  RtpTimeTicks rtp_timestamp;
   ASSERT_FALSE(rtcp_for_receiver_.GetLatestLipSyncTimes(&rtp_timestamp,
                                                         &reference_time));
 
   // Send a Sender Report to the receiver.
   const base::TimeTicks reference_time_sent = sender_clock_->NowTicks();
-  const uint32 rtp_timestamp_sent = 0xbee5;
+  const RtpTimeTicks rtp_timestamp_sent =
+      RtpTimeTicks().Expand(UINT32_C(0xbee5));
   rtcp_for_sender_.SendRtcpFromRtpSender(
       reference_time_sent, rtp_timestamp_sent, 1, 1);
 
   // Now the receiver should have lip-sync info.  Confirm that the lip-sync
   // reference time is the same as that sent.
   EXPECT_TRUE(rtcp_for_receiver_.GetLatestLipSyncTimes(&rtp_timestamp,
                                                        &reference_time));
   const base::TimeTicks rolled_back_time =
       (reference_time -
        // Roll-back relative clock offset:
@@ skipping 23 matching lines @@
   base::TimeDelta expected_rtt_according_to_sender;
   base::TimeDelta expected_rtt_according_to_receiver;
   for (int i = 0; i < iterations; ++i) {
     const base::TimeDelta one_way_trip_time =
         base::TimeDelta::FromMilliseconds(1 << i);
     sender_to_receiver_.set_packet_delay(one_way_trip_time);
     receiver_to_sender_.set_packet_delay(one_way_trip_time);
 
     // Sender --> Receiver
     base::TimeTicks reference_time_sent = sender_clock_->NowTicks();
-    uint32 rtp_timestamp_sent = 0xbee5 + i;
+    const RtpTimeTicks rtp_timestamp_sent =
+        RtpTimeTicks().Expand<uint32_t>(0xbee5) + RtpTimeDelta::FromTicks(i);
     rtcp_for_sender_.SendRtcpFromRtpSender(
         reference_time_sent, rtp_timestamp_sent, 1, 1);
     EXPECT_EQ(expected_rtt_according_to_sender,
               rtcp_for_sender_.current_round_trip_time());
 #ifdef SENDER_PROVIDES_REPORT_BLOCK
     EXPECT_EQ(expected_rtt_according_to_receiver,
               rtcp_for_receiver_.current_round_trip_time());
 #endif
 
     // Receiver --> Sender
@@ skipping 100 matching lines @@
   base::TimeTicks out_3 = ConvertNtpToTimeTicks(ntp_seconds_3, ntp_fraction_3);
   EXPECT_EQ(input_time, out_3);  // Verify inverse.
 
   // Verify delta.
   EXPECT_EQ((out_3 - out_2), time_delta);
   EXPECT_NEAR((ntp_fraction_3 - ntp_fraction_2), 0xffffffff / 2, 1);
 }
 
 }  // namespace cast
 }  // namespace media