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

media/cast/receiver/frame_receiver_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 <deque>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 71 matching lines @@
 
   void SetUp() final {
     payload_.assign(kPacketSize, 0);
 
     // Always start with a key frame.
     rtp_header_.is_key_frame = true;
     rtp_header_.frame_id = kFirstFrameId;
     rtp_header_.packet_id = 0;
     rtp_header_.max_packet_id = 0;
     rtp_header_.reference_frame_id = rtp_header_.frame_id;
-    rtp_header_.rtp_timestamp = 0;
+    rtp_header_.rtp_timestamp = RtpTimeTicks();
   }
 
   void CreateFrameReceiverOfAudio() {
     config_ = GetDefaultAudioReceiverConfig();
     config_.rtp_max_delay_ms = kPlayoutDelayMillis;
 
     receiver_.reset(new FrameReceiver(
         cast_environment_, config_, AUDIO_EVENT, &mock_transport_));
   }
 
   void CreateFrameReceiverOfVideo() {
     config_ = GetDefaultVideoReceiverConfig();
     config_.rtp_max_delay_ms = kPlayoutDelayMillis;
     // Note: Frame rate must divide 1000 without remainder so the test code
     // doesn't have to account for rounding errors.
     config_.target_frame_rate = 25;
 
     receiver_.reset(new FrameReceiver(
         cast_environment_, config_, VIDEO_EVENT, &mock_transport_));
   }
 
   void FeedOneFrameIntoReceiver() {
     // Note: For testing purposes, a frame consists of only a single packet.
     receiver_->ProcessParsedPacket(
         rtp_header_, &payload_[0], payload_.size());
   }
 
   void FeedLipSyncInfoIntoReceiver() {
     const base::TimeTicks now = testing_clock_->NowTicks();
-    const int64 rtp_timestamp = (now - start_time_) *
-        config_.rtp_timebase / base::TimeDelta::FromSeconds(1);
-    CHECK_LE(0, rtp_timestamp);
+    const RtpTimeTicks rtp_timestamp =
+        RtpTimeTicks::FromTimeDelta(now - start_time_, config_.rtp_timebase);
+    CHECK_LE(RtpTimeTicks(), rtp_timestamp);
     uint32 ntp_seconds;
     uint32 ntp_fraction;
     ConvertTimeTicksToNtp(now, &ntp_seconds, &ntp_fraction);
     TestRtcpPacketBuilder rtcp_packet;
-    rtcp_packet.AddSrWithNtp(config_.sender_ssrc,
-                             ntp_seconds, ntp_fraction,
-                             static_cast<uint32>(rtp_timestamp));
+    rtcp_packet.AddSrWithNtp(config_.sender_ssrc, ntp_seconds, ntp_fraction,
+                             rtp_timestamp.lower_32_bits());
     ASSERT_TRUE(receiver_->ProcessPacket(rtcp_packet.GetPacket().Pass()));
   }
 
   FrameReceiverConfig config_;
   std::vector<uint8> payload_;
   RtpCastHeader rtp_header_;
   base::SimpleTestTickClock* testing_clock_;  // Owned by CastEnvironment.
   base::TimeTicks start_time_;
   MockCastTransportSender mock_transport_;
   scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
@@ skipping 68 matching lines @@
 
 TEST_F(FrameReceiverTest, ReceivesFramesSkippingWhenAppropriate) {
   CreateFrameReceiverOfAudio();
 
   SimpleEventSubscriber event_subscriber;
   cast_environment_->logger()->Subscribe(&event_subscriber);
 
   EXPECT_CALL(mock_transport_, SendRtcpFromRtpReceiver(_, _, _, _, _, _, _))
       .WillRepeatedly(testing::Return());
 
-  const uint32 rtp_advance_per_frame =
-      config_.rtp_timebase / config_.target_frame_rate;
   const base::TimeDelta time_advance_per_frame =
       base::TimeDelta::FromSeconds(1) / config_.target_frame_rate;
+  const RtpTimeDelta rtp_advance_per_frame =
+      RtpTimeDelta::FromTimeDelta(time_advance_per_frame, config_.rtp_timebase);
 
   // Feed and process lip sync in receiver.
   FeedLipSyncInfoIntoReceiver();
   task_runner_->RunTasks();
   const base::TimeTicks first_frame_capture_time = testing_clock_->NowTicks();
 
   // Enqueue a request for a frame.
   const ReceiveEncodedFrameCallback frame_encoded_callback =
       base::Bind(&FakeFrameClient::DeliverEncodedFrame,
                  base::Unretained(&frame_client_));
   receiver_->RequestEncodedFrame(frame_encoded_callback);
   task_runner_->RunTasks();
   EXPECT_EQ(0, frame_client_.number_times_called());
 
   // Receive one frame and expect to see the first request satisfied.
   const base::TimeDelta target_playout_delay =
       base::TimeDelta::FromMilliseconds(kPlayoutDelayMillis);
   frame_client_.AddExpectedResult(
       kFirstFrameId, first_frame_capture_time + target_playout_delay);
-  rtp_header_.rtp_timestamp = 0;
+  rtp_header_.rtp_timestamp = RtpTimeTicks();
   FeedOneFrameIntoReceiver();  // Frame 1
   task_runner_->RunTasks();
   EXPECT_EQ(1, frame_client_.number_times_called());
 
   // Enqueue a second request for a frame, but it should not be fulfilled yet.
   receiver_->RequestEncodedFrame(frame_encoded_callback);
   task_runner_->RunTasks();
   EXPECT_EQ(1, frame_client_.number_times_called());
 
   // Receive one frame out-of-order: Make sure that we are not continuous and
   // that the RTP timestamp represents a time in the future.
   rtp_header_.frame_id = kFirstFrameId + 2;  // "Frame 3"
   rtp_header_.reference_frame_id = rtp_header_.frame_id;
-  rtp_header_.rtp_timestamp += 2 * rtp_advance_per_frame;
+  rtp_header_.rtp_timestamp += rtp_advance_per_frame * 2;
   frame_client_.AddExpectedResult(
       kFirstFrameId + 2,
       first_frame_capture_time + 2 * time_advance_per_frame +
           target_playout_delay);
   FeedOneFrameIntoReceiver();  // Frame 3
 
   // Frame 2 should not come out at this point in time.
   task_runner_->RunTasks();
   EXPECT_EQ(1, frame_client_.number_times_called());
 
@@ skipping 30 matching lines @@
   std::vector<FrameEvent> frame_events;
   event_subscriber.GetFrameEventsAndReset(&frame_events);
   ASSERT_TRUE(!frame_events.empty());
   for (size_t i = 0; i < frame_events.size(); ++i) {
     EXPECT_EQ(FRAME_ACK_SENT, frame_events[i].type);
     EXPECT_EQ(AUDIO_EVENT, frame_events[i].media_type);
     EXPECT_LE(kFirstFrameId, frame_events[i].frame_id);
     EXPECT_GE(kFirstFrameId + 4, frame_events[i].frame_id);
     const int frame_offset = frame_events[i].frame_id - kFirstFrameId;
     EXPECT_NE(frame_offset, 1);  // Frame 2 never received.
-    EXPECT_EQ(frame_offset * rtp_advance_per_frame,
+    EXPECT_EQ(RtpTimeTicks() + (rtp_advance_per_frame * frame_offset),
               frame_events[i].rtp_timestamp);
   }
   cast_environment_->logger()->Unsubscribe(&event_subscriber);
 }
 
 TEST_F(FrameReceiverTest, ReceivesFramesRefusingToSkipAny) {
   CreateFrameReceiverOfVideo();
 
   SimpleEventSubscriber event_subscriber;
   cast_environment_->logger()->Subscribe(&event_subscriber);
 
   EXPECT_CALL(mock_transport_, SendRtcpFromRtpReceiver(_, _, _, _, _, _, _))
       .WillRepeatedly(testing::Return());
 
-  const uint32 rtp_advance_per_frame =
-      config_.rtp_timebase / config_.target_frame_rate;
   const base::TimeDelta time_advance_per_frame =
       base::TimeDelta::FromSeconds(1) / config_.target_frame_rate;
+  const RtpTimeDelta rtp_advance_per_frame =
+      RtpTimeDelta::FromTimeDelta(time_advance_per_frame, config_.rtp_timebase);
 
   // Feed and process lip sync in receiver.
   FeedLipSyncInfoIntoReceiver();
   task_runner_->RunTasks();
   const base::TimeTicks first_frame_capture_time = testing_clock_->NowTicks();
 
   // Enqueue a request for a frame.
   const ReceiveEncodedFrameCallback frame_encoded_callback =
       base::Bind(&FakeFrameClient::DeliverEncodedFrame,
                  base::Unretained(&frame_client_));
   receiver_->RequestEncodedFrame(frame_encoded_callback);
   task_runner_->RunTasks();
   EXPECT_EQ(0, frame_client_.number_times_called());
 
   // Receive one frame and expect to see the first request satisfied.
   const base::TimeDelta target_playout_delay =
       base::TimeDelta::FromMilliseconds(kPlayoutDelayMillis);
   frame_client_.AddExpectedResult(
       kFirstFrameId, first_frame_capture_time + target_playout_delay);
-  rtp_header_.rtp_timestamp = 0;
+  rtp_header_.rtp_timestamp = RtpTimeTicks();
   FeedOneFrameIntoReceiver();  // Frame 1
   task_runner_->RunTasks();
   EXPECT_EQ(1, frame_client_.number_times_called());
 
   // Enqueue a second request for a frame, but it should not be fulfilled yet.
   receiver_->RequestEncodedFrame(frame_encoded_callback);
   task_runner_->RunTasks();
   EXPECT_EQ(1, frame_client_.number_times_called());
 
   // Receive one frame out-of-order: Make sure that we are not continuous and
   // that the RTP timestamp represents a time in the future.
   rtp_header_.is_key_frame = false;
   rtp_header_.frame_id = kFirstFrameId + 2;  // "Frame 3"
   rtp_header_.reference_frame_id = kFirstFrameId + 1;  // "Frame 2"
-  rtp_header_.rtp_timestamp += 2 * rtp_advance_per_frame;
+  rtp_header_.rtp_timestamp += rtp_advance_per_frame * 2;
   FeedOneFrameIntoReceiver();  // Frame 3
 
   // Frame 2 should not come out at this point in time.
   task_runner_->RunTasks();
   EXPECT_EQ(1, frame_client_.number_times_called());
 
   // Enqueue a third request for a frame.
   receiver_->RequestEncodedFrame(frame_encoded_callback);
   task_runner_->RunTasks();
   EXPECT_EQ(1, frame_client_.number_times_called());
@@ skipping 32 matching lines @@
   // Sanity-check logging results.
   std::vector<FrameEvent> frame_events;
   event_subscriber.GetFrameEventsAndReset(&frame_events);
   ASSERT_TRUE(!frame_events.empty());
   for (size_t i = 0; i < frame_events.size(); ++i) {
     EXPECT_EQ(FRAME_ACK_SENT, frame_events[i].type);
     EXPECT_EQ(VIDEO_EVENT, frame_events[i].media_type);
     EXPECT_LE(kFirstFrameId, frame_events[i].frame_id);
     EXPECT_GE(kFirstFrameId + 3, frame_events[i].frame_id);
     const int frame_offset = frame_events[i].frame_id - kFirstFrameId;
-    EXPECT_EQ(frame_offset * rtp_advance_per_frame,
+    EXPECT_EQ(RtpTimeTicks() + (rtp_advance_per_frame * frame_offset),
               frame_events[i].rtp_timestamp);
   }
   cast_environment_->logger()->Unsubscribe(&event_subscriber);
 }
 
 }  // namespace cast
 }  // namespace media