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

media/cast/net/pacing/paced_sender_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 "base/big_endian.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "media/cast/net/pacing/paced_sender.h"
 #include "media/cast/test/fake_single_thread_task_runner.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using testing::_;
 
 namespace media {
 namespace cast {
 namespace {
 
 static const uint8 kValue = 123;
 static const size_t kSize1 = 101;
 static const size_t kSize2 = 102;
 static const size_t kSize3 = 103;
 static const size_t kSize4 = 104;
 static const size_t kNackSize = 105;
 static const int64 kStartMillisecond = INT64_C(12345678900000);
 static const uint32 kVideoSsrc = 0x1234;
 static const uint32 kAudioSsrc = 0x5678;
-static const uint32 kFrameRtpTimestamp = 12345;
+static const uint32_t kVideoFrameRtpTimestamp = 12345;
+static const uint32_t kAudioFrameRtpTimestamp = 23456;
 
 class TestPacketSender : public PacketSender {
  public:
   TestPacketSender() : bytes_sent_(0) {}
 
   bool SendPacket(PacketRef packet, const base::Closure& cb) final {
     EXPECT_FALSE(expected_packet_size_.empty());
     size_t expected_packet_size = expected_packet_size_.front();
     expected_packet_size_.pop_front();
     EXPECT_EQ(expected_packet_size, packet->data.size());
@@ skipping 44 matching lines @@
           audio ? kAudioSsrc : kVideoSsrc,  // ssrc
           i);
 
       PacketRef packet(new base::RefCountedData<Packet>);
       packet->data.resize(packet_size, kValue);
       // Fill-in packet header fields to test the header parsing (for populating
       // the logging events).
       base::BigEndianWriter writer(reinterpret_cast<char*>(&packet->data[0]),
                                    packet_size);
       bool success = writer.Skip(4);
-      success &= writer.WriteU32(kFrameRtpTimestamp);
+      success &= writer.WriteU32(audio ? kAudioFrameRtpTimestamp
+                                       : kVideoFrameRtpTimestamp);
       success &= writer.WriteU32(audio ? kAudioSsrc : kVideoSsrc);
       success &= writer.Skip(2);
       success &= writer.WriteU16(i);
       success &= writer.WriteU16(num_of_packets_in_frame - 1);
       CHECK(success);
       packets.push_back(std::make_pair(key, packet));
     }
     // Increase |frame_id_| so that we don't get the same key next time this
     // function is called.
     ++frame_id_;
@@ skipping 72 matching lines @@
   const base::TimeTicks latest_event_timestamp = testing_clock_.NowTicks();
 
   // Check that packet logging events match expected values.
   EXPECT_EQ(num_of_packets, static_cast<int>(packet_events_.size()));
   uint16 expected_packet_id = 0;
   for (const PacketEvent& e : packet_events_) {
     ASSERT_LE(earliest_event_timestamp, e.timestamp);
     ASSERT_GE(latest_event_timestamp, e.timestamp);
     ASSERT_EQ(PACKET_SENT_TO_NETWORK, e.type);
     ASSERT_EQ(VIDEO_EVENT, e.media_type);
-    ASSERT_EQ(kFrameRtpTimestamp, e.rtp_timestamp);
+    ASSERT_EQ(kVideoFrameRtpTimestamp, e.rtp_timestamp.lower_32_bits());
     ASSERT_EQ(num_of_packets - 1, e.max_packet_id);
     ASSERT_EQ(expected_packet_id++, e.packet_id);
     ASSERT_EQ(kSize1, e.size);
   }
 }
 
 TEST_F(PacedSenderTest, PaceWithNack) {
   // Testing what happen when we get multiple NACK requests for a fully lost
   // frames just as we sent the first packets in a frame.
   int num_of_packets_in_frame = 12;
@@ skipping 255 matching lines @@
   EXPECT_TRUE(paced_sender_->ResendPackets(packets, dedup_info));
   EXPECT_EQ(static_cast<int64>(kSize1), mock_transport_.GetBytesSent());
 
   dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(5);
   EXPECT_TRUE(paced_sender_->ResendPackets(packets, dedup_info));
   EXPECT_EQ(static_cast<int64>(2 * kSize1), mock_transport_.GetBytesSent());
 }
 
 }  // namespace cast
 }  // namespace media