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

media/cast/sender/video_sender.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/video_sender.h"
 
 #include <stdint.h>
 #include <algorithm>
 #include <cmath>
 #include <cstring>
@@ skipping 27 matching lines @@
 // The target maximum utilization of the encoder and network resources.  This is
 // used to attenuate the actual measured utilization values in order to provide
 // "breathing room" (i.e., to ensure there will be sufficient CPU and bandwidth
 // available to handle the occasional more-complex frames).
 const int kTargetUtilizationPercentage = 75;
 
 // Extract capture begin/end timestamps from |video_frame|'s metadata and log
 // it.
 void LogVideoCaptureTimestamps(CastEnvironment* cast_environment,
                                const media::VideoFrame& video_frame,
-                               RtpTimestamp rtp_timestamp) {
+                               RtpTimeTicks rtp_timestamp) {
   scoped_ptr<FrameEvent> capture_begin_event(new FrameEvent());
   capture_begin_event->type = FRAME_CAPTURE_BEGIN;
   capture_begin_event->media_type = VIDEO_EVENT;
   capture_begin_event->rtp_timestamp = rtp_timestamp;
 
   scoped_ptr<FrameEvent> capture_end_event(new FrameEvent());
   capture_end_event->type = FRAME_CAPTURE_END;
   capture_end_event->media_type = VIDEO_EVENT;
   capture_end_event->rtp_timestamp = rtp_timestamp;
   capture_end_event->width = video_frame.visible_rect().width();
@@ skipping 88 matching lines @@
 void VideoSender::InsertRawVideoFrame(
     const scoped_refptr<media::VideoFrame>& video_frame,
     const base::TimeTicks& reference_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   if (!video_encoder_) {
     NOTREACHED();
     return;
   }
 
-  const RtpTimestamp rtp_timestamp =
-      TimeDeltaToRtpDelta(video_frame->timestamp(), kVideoFrequency);
+  const RtpTimeTicks rtp_timestamp =
+      RtpTimeTicks::FromTimeDelta(video_frame->timestamp(), kVideoFrequency);
   LogVideoCaptureTimestamps(cast_environment_.get(), *video_frame,
                             rtp_timestamp);
 
   // Used by chrome/browser/extension/api/cast_streaming/performance_test.cc
   TRACE_EVENT_INSTANT2(
       "cast_perf_test", "InsertRawVideoFrame",
       TRACE_EVENT_SCOPE_THREAD,
       "timestamp", reference_time.ToInternalValue(),
-      "rtp_timestamp", rtp_timestamp);
+      "rtp_timestamp", rtp_timestamp.lower_32_bits());
 
   bool low_latency_mode;
   if (video_frame->metadata()->GetBoolean(
           VideoFrameMetadata::INTERACTIVE_CONTENT, &low_latency_mode)) {
     if (low_latency_mode && !low_latency_mode_) {
       VLOG(1) << "Interactive mode playout time " << min_playout_delay_;
       playout_delay_change_cb_.Run(min_playout_delay_);
     }
     low_latency_mode_ = low_latency_mode;
   }
 
   // Drop the frame if either its RTP or reference timestamp is not an increase
   // over the last frame's.  This protects: 1) the duration calculations that
   // assume timestamps are monotonically non-decreasing, and 2) assumptions made
   // deeper in the implementation where each frame's RTP timestamp needs to be
   // unique.
   if (!last_enqueued_frame_reference_time_.is_null() &&
-      (!IsNewerRtpTimestamp(rtp_timestamp,
-                            last_enqueued_frame_rtp_timestamp_) ||
+      (rtp_timestamp <= last_enqueued_frame_rtp_timestamp_ ||
        reference_time <= last_enqueued_frame_reference_time_)) {
     VLOG(1) << "Dropping video frame: RTP or reference time did not increase.";
     TRACE_EVENT_INSTANT2("cast.stream", "Video Frame Drop",
-                        TRACE_EVENT_SCOPE_THREAD,
-                        "rtp_timestamp", rtp_timestamp,
-                        "reason", "time did not increase");
+                         TRACE_EVENT_SCOPE_THREAD,
+                         "rtp_timestamp", rtp_timestamp.lower_32_bits(),
+                         "reason", "time did not increase");
     return;
   }
 
   // Two video frames are needed to compute the exact media duration added by
   // the next frame.  If there are no frames in the encoder, compute a guess
   // based on the configured |max_frame_rate_|.  Any error introduced by this
   // guess will be eliminated when |duration_in_encoder_| is updated in
   // OnEncodedVideoFrame().
   const base::TimeDelta duration_added_by_next_frame = frames_in_encoder_ > 0 ?
       reference_time - last_enqueued_frame_reference_time_ :
@@ skipping 21 matching lines @@
     }
 
     // Some encoder implementations have a frame window for analysis. Since we
     // are dropping this frame, unless we instruct the encoder to flush all the
     // frames that have been enqueued for encoding, frames_in_encoder_ and
     // last_enqueued_frame_reference_time_ will never be updated and we will
     // drop every subsequent frame for the rest of the session.
     video_encoder_->EmitFrames();
 
     TRACE_EVENT_INSTANT2("cast.stream", "Video Frame Drop",
-                        TRACE_EVENT_SCOPE_THREAD,
-                        "rtp_timestamp", rtp_timestamp,
-                        "reason", "too much in flight");
+                         TRACE_EVENT_SCOPE_THREAD,
+                         "rtp_timestamp", rtp_timestamp.lower_32_bits(),
+                         "reason", "too much in flight");
     return;
   }
 
   if (video_frame->visible_rect().IsEmpty()) {
     VLOG(1) << "Rejecting empty video frame.";
     return;
   }
 
   const int bitrate = congestion_control_->GetBitrate(
       reference_time + target_playout_delay_, target_playout_delay_,
@@ skipping 14 matching lines @@
                                        video_frame.get());
 
   if (video_encoder_->EncodeVideoFrame(
           video_frame,
           reference_time,
           base::Bind(&VideoSender::OnEncodedVideoFrame,
                      weak_factory_.GetWeakPtr(),
                      video_frame,
                      bitrate))) {
     TRACE_EVENT_ASYNC_BEGIN1("cast.stream", "Video Encode", video_frame.get(),
-                             "rtp_timestamp", rtp_timestamp);
+                             "rtp_timestamp", rtp_timestamp.lower_32_bits());
     frames_in_encoder_++;
     duration_in_encoder_ += duration_added_by_next_frame;
     last_enqueued_frame_rtp_timestamp_ = rtp_timestamp;
     last_enqueued_frame_reference_time_ = reference_time;
   } else {
     VLOG(1) << "Encoder rejected a frame.  Skipping...";
     TRACE_EVENT_INSTANT1("cast.stream", "Video Encode Reject",
-                        TRACE_EVENT_SCOPE_THREAD,
-                        "rtp_timestamp", rtp_timestamp);
+                         TRACE_EVENT_SCOPE_THREAD,
+                         "rtp_timestamp", rtp_timestamp.lower_32_bits());
   }
 }
 
 scoped_ptr<VideoFrameFactory> VideoSender::CreateVideoFrameFactory() {
   return video_encoder_ ? video_encoder_->CreateVideoFrameFactory() : nullptr;
 }
 
 int VideoSender::GetNumberOfFramesInEncoder() const {
   return frames_in_encoder_;
 }
@@ skipping 93 matching lines @@
         media::VideoFrameMetadata::RESOURCE_UTILIZATION,
         encoded_frame->dependency == EncodedFrame::KEY ?
             std::min(1.0, attenuated_utilization) : attenuated_utilization);
   }
 
   SendEncodedFrame(encoder_bitrate, std::move(encoded_frame));
 }
 
 }  // namespace cast
 }  // namespace media