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

media/cast/sender/frame_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/frame_sender.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
@@ skipping 52 matching lines @@
   DCHECK_GT(rtp_timebase_, 0);
   DCHECK(congestion_control_);
   // We assume animated content to begin with since that is the common use
   // case today.
   VLOG(1) << SENDER_SSRC << "min latency "
           << min_playout_delay_.InMilliseconds() << "max latency "
           << max_playout_delay.InMilliseconds() << "animated latency "
           << animated_playout_delay.InMilliseconds();
   SetTargetPlayoutDelay(animated_playout_delay_);
   send_target_playout_delay_ = false;
-  memset(frame_rtp_timestamps_, 0, sizeof(frame_rtp_timestamps_));
 }
 
 FrameSender::~FrameSender() {
 }
 
 void FrameSender::ScheduleNextRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   cast_environment_->PostDelayedTask(
       CastEnvironment::MAIN, FROM_HERE,
@@ skipping 10 matching lines @@
 
   // Create lip-sync info for the sender report.  The last sent frame's
   // reference time and RTP timestamp are used to estimate an RTP timestamp in
   // terms of "now."  Note that |now| is never likely to be precise to an exact
   // frame boundary; and so the computation here will result in a
   // |now_as_rtp_timestamp| value that is rarely equal to any one emitted by the
   // encoder.
   const base::TimeTicks now = cast_environment_->Clock()->NowTicks();
   const base::TimeDelta time_delta =
       now - GetRecordedReferenceTime(last_sent_frame_id_);
-  const int64_t rtp_delta = TimeDeltaToRtpDelta(time_delta, rtp_timebase_);
-  const uint32_t now_as_rtp_timestamp =
-      GetRecordedRtpTimestamp(last_sent_frame_id_) +
-      static_cast<uint32_t>(rtp_delta);
+  const RtpTimeDelta rtp_delta =
+      RtpTimeDelta::FromTimeDelta(time_delta, rtp_timebase_);
+  const RtpTimeTicks now_as_rtp_timestamp =
+      GetRecordedRtpTimestamp(last_sent_frame_id_) + rtp_delta;
   transport_sender_->SendSenderReport(ssrc_, now, now_as_rtp_timestamp);
 
   if (schedule_future_reports)
     ScheduleNextRtcpReport();
 }
 
 void FrameSender::OnMeasuredRoundTripTime(base::TimeDelta rtt) {
   DCHECK(rtt > base::TimeDelta());
   current_round_trip_time_ = rtt;
 }
@@ skipping 52 matching lines @@
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(!last_send_time_.is_null());
   VLOG(1) << SENDER_SSRC << "Resending last packet of frame "
           << last_sent_frame_id_ << " to kick-start.";
   last_send_time_ = cast_environment_->Clock()->NowTicks();
   transport_sender_->ResendFrameForKickstart(ssrc_, last_sent_frame_id_);
 }
 
 void FrameSender::RecordLatestFrameTimestamps(uint32_t frame_id,
                                               base::TimeTicks reference_time,
-                                              RtpTimestamp rtp_timestamp) {
+                                              RtpTimeTicks rtp_timestamp) {
   DCHECK(!reference_time.is_null());
   frame_reference_times_[frame_id % arraysize(frame_reference_times_)] =
       reference_time;
   frame_rtp_timestamps_[frame_id % arraysize(frame_rtp_timestamps_)] =
       rtp_timestamp;
 }
 
 base::TimeTicks FrameSender::GetRecordedReferenceTime(uint32_t frame_id) const {
   return frame_reference_times_[frame_id % arraysize(frame_reference_times_)];
 }
 
-RtpTimestamp FrameSender::GetRecordedRtpTimestamp(uint32_t frame_id) const {
+RtpTimeTicks FrameSender::GetRecordedRtpTimestamp(uint32_t frame_id) const {
   return frame_rtp_timestamps_[frame_id % arraysize(frame_rtp_timestamps_)];
 }
 
 int FrameSender::GetUnacknowledgedFrameCount() const {
   const int count =
       static_cast<int32_t>(last_sent_frame_id_ - latest_acked_frame_id_);
   DCHECK_GE(count, 0);
   return count;
 }
 
@@ skipping 45 matching lines @@
 
   RecordLatestFrameTimestamps(frame_id,
                               encoded_frame->reference_time,
                               encoded_frame->rtp_timestamp);
 
   if (!is_audio_) {
     // Used by chrome/browser/extension/api/cast_streaming/performance_test.cc
     TRACE_EVENT_INSTANT1(
         "cast_perf_test", "VideoFrameEncoded",
         TRACE_EVENT_SCOPE_THREAD,
-        "rtp_timestamp", encoded_frame->rtp_timestamp);
+        "rtp_timestamp", encoded_frame->rtp_timestamp.lower_32_bits());
   }
 
   // At the start of the session, it's important to send reports before each
   // frame so that the receiver can properly compute playout times.  The reason
   // more than one report is sent is because transmission is not guaranteed,
   // only best effort, so send enough that one should almost certainly get
   // through.
   if (num_aggressive_rtcp_reports_sent_ < kNumAggressiveReportsSentAtStart) {
     // SendRtcpReport() will schedule future reports to be made if this is the
     // last "aggressive report."
     ++num_aggressive_rtcp_reports_sent_;
     const bool is_last_aggressive_report =
         (num_aggressive_rtcp_reports_sent_ == kNumAggressiveReportsSentAtStart);
     VLOG_IF(1, is_last_aggressive_report)
         << SENDER_SSRC << "Sending last aggressive report.";
     SendRtcpReport(is_last_aggressive_report);
   }
 
   congestion_control_->SendFrameToTransport(
       frame_id, encoded_frame->data.size() * 8, last_send_time_);
 
   if (send_target_playout_delay_) {
     encoded_frame->new_playout_delay_ms =
         target_playout_delay_.InMilliseconds();
   }
 
   TRACE_EVENT_ASYNC_BEGIN1("cast.stream",
       is_audio_ ? "Audio Transport" : "Video Transport",
       frame_id,
-      "rtp_timestamp", encoded_frame->rtp_timestamp);
+      "rtp_timestamp", encoded_frame->rtp_timestamp.lower_32_bits());
   transport_sender_->InsertFrame(ssrc_, *encoded_frame);
 }
 
 void FrameSender::OnReceivedCastFeedback(const RtcpCastMessage& cast_feedback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   const bool have_valid_rtt = current_round_trip_time_ > base::TimeDelta();
   if (have_valid_rtt) {
     congestion_control_->UpdateRtt(current_round_trip_time_);
 
@@ skipping 120 matching lines @@
     VLOG(1) << SENDER_SSRC << "Dropping: In-flight duration would be too high.";
     return true;
   }
 
   // Next frame is accepted.
   return false;
 }
 
 }  // namespace cast
 }  // namespace media