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

media/cast/sender/video_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 <vector>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "media/base/video_frame.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/cast_environment.h"
+#include "media/cast/common/rtp_time.h"
 #include "media/cast/sender/fake_video_encode_accelerator_factory.h"
 #include "media/cast/sender/video_frame_factory.h"
 #include "media/cast/sender/video_encoder.h"
 #include "media/cast/test/fake_single_thread_task_runner.h"
 #include "media/cast/test/utility/default_config.h"
 #include "media/cast/test/utility/video_utility.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_MACOSX)
 #include "media/cast/sender/h264_vt_encoder.h"
@@ skipping 137 matching lines @@
   }
 
   // Requests encoding the |video_frame| and has the resulting frame delivered
   // via a callback that checks for expected results.  Returns false if the
   // encoder rejected the request.
   bool EncodeAndCheckDelivery(
       const scoped_refptr<media::VideoFrame>& video_frame,
       uint32 frame_id,
       uint32 reference_frame_id) {
     return video_encoder_->EncodeVideoFrame(
-        video_frame,
-        Now(),
+        video_frame, Now(),
         base::Bind(&VideoEncoderTest::DeliverEncodedVideoFrame,
-                   base::Unretained(this),
-                   frame_id,
-                   reference_frame_id,
-                   TimeDeltaToRtpDelta(video_frame->timestamp(),
-                                       kVideoFrequency),
+                   base::Unretained(this), frame_id, reference_frame_id,
+                   RtpTimeTicks::FromTimeDelta(video_frame->timestamp(),
+                                               kVideoFrequency),
                    Now()));
   }
 
   // If the implementation of |video_encoder_| is ExternalVideoEncoder, check
   // that the VEA factory has responded (by running the callbacks) a specific
   // number of times.  Otherwise, check that the VEA factory is inactive.
   void ExpectVEAResponsesForExternalVideoEncoder(
       int vea_response_count,
       int shm_response_count) const {
     if (!vea_factory_)
@@ skipping 17 matching lines @@
                 operational_status_ == STATUS_INITIALIZED);
 
     // Create the VideoFrameFactory the first time status changes to
     // STATUS_INITIALIZED.
     if (operational_status_ == STATUS_INITIALIZED && !video_frame_factory_)
       video_frame_factory_ = video_encoder_->CreateVideoFrameFactory().Pass();
   }
 
   // Checks that |encoded_frame| matches expected values.  This is the method
   // bound in the callback returned from EncodeAndCheckDelivery().
-  void DeliverEncodedVideoFrame(
-      uint32 expected_frame_id,
-      uint32 expected_last_referenced_frame_id,
-      uint32 expected_rtp_timestamp,
-      const base::TimeTicks& expected_reference_time,
-      scoped_ptr<SenderEncodedFrame> encoded_frame) {
+  void DeliverEncodedVideoFrame(uint32 expected_frame_id,
+                                uint32 expected_last_referenced_frame_id,
+                                RtpTimeTicks expected_rtp_timestamp,
+                                const base::TimeTicks& expected_reference_time,
+                                scoped_ptr<SenderEncodedFrame> encoded_frame) {
     EXPECT_TRUE(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
     EXPECT_EQ(expected_frame_id, encoded_frame->frame_id);
     EXPECT_EQ(expected_rtp_timestamp, encoded_frame->rtp_timestamp);
     EXPECT_EQ(expected_reference_time, encoded_frame->reference_time);
 
     // The platform encoders are "black boxes" and may choose to vend key frames
     // and/or empty data at any time.  The software encoders, however, should
     // strictly adhere to expected behavior.
     if (is_testing_platform_encoder()) {
@@ skipping 187 matching lines @@
 #endif
   return values;
 }
 }  // namespace
 
 INSTANTIATE_TEST_CASE_P(
     , VideoEncoderTest, ::testing::ValuesIn(DetermineEncodersToTest()));
 
 }  // namespace cast
 }  // namespace media