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

media/cast/receiver/frame_receiver.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/receiver/frame_receiver.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/big_endian.h"
@@ skipping 42 matching lines @@
             config.receiver_ssrc,
             config.sender_ssrc),
       is_waiting_for_consecutive_frame_(false),
       lip_sync_drift_(ClockDriftSmoother::GetDefaultTimeConstant()),
       weak_factory_(this) {
   transport_->AddValidSsrc(config.sender_ssrc);
   DCHECK_GT(config.rtp_max_delay_ms, 0);
   DCHECK_GT(config.target_frame_rate, 0);
   decryptor_.Initialize(config.aes_key, config.aes_iv_mask);
   cast_environment_->logger()->Subscribe(&event_subscriber_);
-  memset(frame_id_to_rtp_timestamp_, 0, sizeof(frame_id_to_rtp_timestamp_));
 }
 
 FrameReceiver::~FrameReceiver() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   cast_environment_->logger()->Unsubscribe(&event_subscriber_);
 }
 
 void FrameReceiver::RequestEncodedFrame(
     const ReceiveEncodedFrameCallback& callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
@@ skipping 12 matching lines @@
     size_t payload_size;
     if (!packet_parser_.ParsePacket(&packet->front(),
                                     packet->size(),
                                     &rtp_header,
                                     &payload_data,
                                     &payload_size)) {
       return false;
     }
 
     ProcessParsedPacket(rtp_header, payload_data, payload_size);
-    stats_.UpdateStatistics(rtp_header);
+    stats_.UpdateStatistics(rtp_header, rtp_timebase_);
   }
 
   if (!reports_are_scheduled_) {
     ScheduleNextRtcpReport();
     ScheduleNextCastMessage();
     reports_are_scheduled_ = true;
   }
 
   return true;
 }
@@ skipping 23 matching lines @@
   const bool complete =
       framer_.InsertPacket(payload_data, payload_size, rtp_header, &duplicate);
 
   // Duplicate packets are ignored.
   if (duplicate)
     return;
 
   // Update lip-sync values upon receiving the first packet of each frame, or if
   // they have never been set yet.
   if (rtp_header.packet_id == 0 || lip_sync_reference_time_.is_null()) {
-    RtpTimestamp fresh_sync_rtp;
+    RtpTimeTicks fresh_sync_rtp;
     base::TimeTicks fresh_sync_reference;
     if (!rtcp_.GetLatestLipSyncTimes(&fresh_sync_rtp, &fresh_sync_reference)) {
       // HACK: The sender should have provided Sender Reports before the first
       // frame was sent.  However, the spec does not currently require this.
       // Therefore, when the data is missing, the local clock is used to
       // generate reference timestamps.
       VLOG(2) << "Lip sync info missing.  Falling-back to local clock.";
       fresh_sync_rtp = rtp_header.rtp_timestamp;
       fresh_sync_reference = now;
     }
     // |lip_sync_reference_time_| is always incremented according to the time
     // delta computed from the difference in RTP timestamps.  Then,
     // |lip_sync_drift_| accounts for clock drift and also smoothes-out any
     // sudden/discontinuous shifts in the series of reference time values.
     if (lip_sync_reference_time_.is_null()) {
       lip_sync_reference_time_ = fresh_sync_reference;
     } else {
-      lip_sync_reference_time_ += RtpDeltaToTimeDelta(
-          static_cast<int32_t>(fresh_sync_rtp - lip_sync_rtp_timestamp_),
-          rtp_timebase_);
+      // Note: It's okay for the conversion ToTimeDelta() to be approximate
+      // because |lip_sync_drift_| will account for accumulated errors.
+      lip_sync_reference_time_ +=
+          (fresh_sync_rtp - lip_sync_rtp_timestamp_).ToTimeDelta(rtp_timebase_);
     }
     lip_sync_rtp_timestamp_ = fresh_sync_rtp;
     lip_sync_drift_.Update(
         now, fresh_sync_reference - lip_sync_reference_time_);
   }
 
   // Another frame is complete from a non-duplicate packet.  Attempt to emit
   // more frames to satisfy enqueued requests.
   if (complete)
     EmitAvailableEncodedFrames();
 }
 
 void FrameReceiver::CastFeedback(const RtcpCastMessage& cast_message) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
-  RtpTimestamp rtp_timestamp =
+  RtpTimeTicks rtp_timestamp =
       frame_id_to_rtp_timestamp_[cast_message.ack_frame_id & 0xff];
 
   scoped_ptr<FrameEvent> ack_sent_event(new FrameEvent());
   ack_sent_event->timestamp = now;
   ack_sent_event->type = FRAME_ACK_SENT;
   ack_sent_event->media_type = event_media_type_;
   ack_sent_event->rtp_timestamp = rtp_timestamp;
   ack_sent_event->frame_id = cast_message.ack_frame_id;
   cast_environment_->logger()->DispatchFrameEvent(std::move(ack_sent_event));
 
@@ skipping 109 matching lines @@
     callback.Run(std::move(encoded_frame));
 }
 
 base::TimeTicks FrameReceiver::GetPlayoutTime(const EncodedFrame& frame) const {
   base::TimeDelta target_playout_delay = target_playout_delay_;
   if (frame.new_playout_delay_ms) {
     target_playout_delay = base::TimeDelta::FromMilliseconds(
         frame.new_playout_delay_ms);
   }
   return lip_sync_reference_time_ + lip_sync_drift_.Current() +
-         RtpDeltaToTimeDelta(static_cast<int32_t>(frame.rtp_timestamp -
-                                                  lip_sync_rtp_timestamp_),
-                             rtp_timebase_) +
+         (frame.rtp_timestamp - lip_sync_rtp_timestamp_)
+             .ToTimeDelta(rtp_timebase_) +
          target_playout_delay;
 }
 
 void FrameReceiver::ScheduleNextCastMessage() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   base::TimeTicks send_time;
   framer_.TimeToSendNextCastMessage(&send_time);
   base::TimeDelta time_to_send =
       send_time - cast_environment_->Clock()->NowTicks();
   time_to_send = std::max(
@@ skipping 31 matching lines @@
                                       rtcp_.ConvertToNTPAndSave(now),
                                       NULL,
                                       base::TimeDelta(),
                                       NULL,
                                       &stats);
   ScheduleNextRtcpReport();
 }
 
 }  // namespace cast
 }  // namespace media