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

media/cast/sender/h264_vt_encoder.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 "media/cast/sender/h264_vt_encoder.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <vector>
 
 #include "base/big_endian.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/synchronization/lock.h"
 #include "build/build_config.h"
 #include "media/base/mac/corevideo_glue.h"
 #include "media/base/mac/video_frame_mac.h"
-#include "media/cast/cast_defines.h"
+#include "media/cast/common/rtp_time.h"
 #include "media/cast/constants.h"
 #include "media/cast/sender/video_frame_factory.h"
 
 namespace media {
 namespace cast {
 
 namespace {
 
 // Container for the associated data of a video frame being processed.
 struct InProgressFrameEncode {
-  const RtpTimestamp rtp_timestamp;
+  const RtpTimeTicks rtp_timestamp;
   const base::TimeTicks reference_time;
   const VideoEncoder::FrameEncodedCallback frame_encoded_callback;
 
-  InProgressFrameEncode(RtpTimestamp rtp,
+  InProgressFrameEncode(RtpTimeTicks rtp,
                         base::TimeTicks r_time,
                         VideoEncoder::FrameEncodedCallback callback)
       : rtp_timestamp(rtp),
         reference_time(r_time),
         frame_encoded_callback(callback) {}
 };
 
 base::ScopedCFTypeRef<CFDictionaryRef>
 DictionaryWithKeysAndValues(CFTypeRef* keys, CFTypeRef* values, size_t size) {
   return base::ScopedCFTypeRef<CFDictionaryRef>(CFDictionaryCreate(
@@ skipping 515 matching lines @@
     return false;
   }
 
   // Convert the frame timestamp to CMTime.
   auto timestamp_cm = CoreMediaGlue::CMTimeMake(
       (reference_time - base::TimeTicks()).InMicroseconds(), USEC_PER_SEC);
 
   // Wrap information we'll need after the frame is encoded in a heap object.
   // We'll get the pointer back from the VideoToolbox completion callback.
   scoped_ptr<InProgressFrameEncode> request(new InProgressFrameEncode(
-      TimeDeltaToRtpDelta(video_frame->timestamp(), kVideoFrequency),
+      RtpTimeTicks::FromTimeDelta(video_frame->timestamp(), kVideoFrequency),
       reference_time, frame_encoded_callback));
 
   // Build a suitable frame properties dictionary for keyframes.
   base::ScopedCFTypeRef<CFDictionaryRef> frame_props;
   if (encode_next_frame_as_keyframe_) {
     frame_props = DictionaryWithKeyValue(
         videotoolbox_glue_->kVTEncodeFrameOptionKey_ForceKeyFrame(),
         kCFBooleanTrue);
     encode_next_frame_as_keyframe_ = false;
   }
@@ skipping 175 matching lines @@
   encoded_frame->encode_completion_time =
       encoder->cast_environment_->Clock()->NowTicks();
   encoder->cast_environment_->PostTask(
       CastEnvironment::MAIN, FROM_HERE,
       base::Bind(request->frame_encoded_callback,
                  base::Passed(&encoded_frame)));
 }
 
 }  // namespace cast
 }  // namespace media