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

media/cast/sender/h264_vt_encoder_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 <queue>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/test/launcher/unit_test_launcher.h"
 #include "base/test/power_monitor_test_base.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/test/test_suite.h"
 #include "media/base/cdm_context.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/media.h"
 #include "media/base/media_switches.h"
 #include "media/base/media_util.h"
-#include "media/cast/cast_defines.h"
+#include "media/cast/common/rtp_time.h"
 #include "media/cast/constants.h"
 #include "media/cast/sender/h264_vt_encoder.h"
 #include "media/cast/sender/video_frame_factory.h"
 #include "media/cast/test/utility/default_config.h"
 #include "media/cast/test/utility/video_utility.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/filters/ffmpeg_glue.h"
 #include "media/filters/ffmpeg_video_decoder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 48 matching lines @@
 }
 
 class MetadataRecorder : public base::RefCountedThreadSafe<MetadataRecorder> {
  public:
   MetadataRecorder() : count_frames_delivered_(0) {}
 
   int count_frames_delivered() const { return count_frames_delivered_; }
 
   void PushExpectation(uint32_t expected_frame_id,
                        uint32_t expected_last_referenced_frame_id,
-                       uint32_t expected_rtp_timestamp,
+                       RtpTimeTicks expected_rtp_timestamp,
                        const base::TimeTicks& expected_reference_time) {
     expectations_.push(Expectation{expected_frame_id,
                                    expected_last_referenced_frame_id,
                                    expected_rtp_timestamp,
                                    expected_reference_time});
   }
 
   void CompareFrameWithExpected(scoped_ptr<SenderEncodedFrame> encoded_frame) {
     ASSERT_LT(0u, expectations_.size());
     auto e = expectations_.front();
@@ skipping 15 matching lines @@
 
  private:
   friend class base::RefCountedThreadSafe<MetadataRecorder>;
   virtual ~MetadataRecorder() {}
 
   int count_frames_delivered_;
 
   struct Expectation {
     uint32_t expected_frame_id;
     uint32_t expected_last_referenced_frame_id;
-    uint32_t expected_rtp_timestamp;
+    RtpTimeTicks expected_rtp_timestamp;
     base::TimeTicks expected_reference_time;
   };
   std::queue<Expectation> expectations_;
 
   DISALLOW_COPY_AND_ASSIGN(MetadataRecorder);
 };
 
 class EndToEndFrameChecker
     : public base::RefCountedThreadSafe<EndToEndFrameChecker> {
  public:
@@ skipping 144 matching lines @@
 // static
 scoped_refptr<media::VideoFrame> H264VideoToolboxEncoderTest::frame_;
 VideoSenderConfig H264VideoToolboxEncoderTest::video_sender_config_;
 
 TEST_F(H264VideoToolboxEncoderTest, CheckFrameMetadataSequence) {
   scoped_refptr<MetadataRecorder> metadata_recorder(new MetadataRecorder());
   VideoEncoder::FrameEncodedCallback cb = base::Bind(
       &MetadataRecorder::CompareFrameWithExpected, metadata_recorder.get());
 
   metadata_recorder->PushExpectation(
-      0, 0, TimeDeltaToRtpDelta(frame_->timestamp(), kVideoFrequency),
+      0, 0, RtpTimeTicks::FromTimeDelta(frame_->timestamp(), kVideoFrequency),
       clock_->NowTicks());
   EXPECT_TRUE(encoder_->EncodeVideoFrame(frame_, clock_->NowTicks(), cb));
   message_loop_.RunUntilIdle();
 
   for (uint32_t frame_id = 1; frame_id < 10; ++frame_id) {
     AdvanceClockAndVideoFrameTimestamp();
     metadata_recorder->PushExpectation(
         frame_id, frame_id - 1,
-        TimeDeltaToRtpDelta(frame_->timestamp(), kVideoFrequency),
+        RtpTimeTicks::FromTimeDelta(frame_->timestamp(), kVideoFrequency),
         clock_->NowTicks());
     EXPECT_TRUE(encoder_->EncodeVideoFrame(frame_, clock_->NowTicks(), cb));
   }
 
   encoder_.reset();
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(10, metadata_recorder->count_frames_delivered());
 }
 
@@ skipping 99 matching lines @@
       gfx::Size(kVideoWidth, kVideoHeight), base::TimeDelta()));
 
   // After a power resume event, the factory should produce frames right away
   // because the encoder re-initializes on its own.
   power_source_->GenerateResumeEvent();
   CreateFrameAndMemsetPlane(video_frame_factory.get());
 }
 
 }  // namespace cast
 }  // namespace media