Remove kint64max.

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 <limits>
+
 #include "base/trace_event/trace_event.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/constants.h"
 #include "media/cast/sender/sender_encoded_frame.h"
 
 namespace media {
 namespace cast {
 namespace {
 
 const int kMinSchedulingDelayMs = 1;
 const int kNumAggressiveReportsSentAtStart = 100;
 
 // The additional number of frames that can be in-flight when input exceeds the
 // maximum frame rate.
 const int kMaxFrameBurst = 5;
 
 }  // namespace
 
 // Convenience macro used in logging statements throughout this file.
 #define SENDER_SSRC (is_audio_ ? "AUDIO[" : "VIDEO[") << ssrc_ << "] "
 
 FrameSender::FrameSender(scoped_refptr<CastEnvironment> cast_environment,
                          bool is_audio,
                          CastTransportSender* const transport_sender,
                          int rtp_timebase,
-                         uint32 ssrc,
+                         uint32_t ssrc,
                          double max_frame_rate,
                          base::TimeDelta min_playout_delay,
                          base::TimeDelta max_playout_delay,
                          CongestionControl* congestion_control)
     : cast_environment_(cast_environment),
       transport_sender_(transport_sender),
       ssrc_(ssrc),
-      min_playout_delay_(min_playout_delay == base::TimeDelta() ?
-                         max_playout_delay : min_playout_delay),
+      min_playout_delay_(min_playout_delay == base::TimeDelta()
+                             ? max_playout_delay
+                             : min_playout_delay),
       max_playout_delay_(max_playout_delay),
       send_target_playout_delay_(false),
       max_frame_rate_(max_frame_rate),
       num_aggressive_rtcp_reports_sent_(0),
       last_sent_frame_id_(0),
       latest_acked_frame_id_(0),
       duplicate_ack_counter_(0),
       congestion_control_(congestion_control),
       rtp_timebase_(rtp_timebase),
       is_audio_(is_audio),
@@ skipping 27 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 rtp_delta = TimeDeltaToRtpDelta(time_delta, rtp_timebase_);
-  const uint32 now_as_rtp_timestamp =
+  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>(rtp_delta);
+      static_cast<uint32_t>(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 50 matching lines @@
 
 void FrameSender::ResendForKickstart() {
   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 frame_id,
+void FrameSender::RecordLatestFrameTimestamps(uint32_t frame_id,
                                               base::TimeTicks reference_time,
                                               RtpTimestamp 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 frame_id) const {
+base::TimeTicks FrameSender::GetRecordedReferenceTime(uint32_t frame_id) const {
   return frame_reference_times_[frame_id % arraysize(frame_reference_times_)];
 }
 
-RtpTimestamp FrameSender::GetRecordedRtpTimestamp(uint32 frame_id) const {
+RtpTimestamp 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>(last_sent_frame_id_ - latest_acked_frame_id_);
+      static_cast<int32_t>(last_sent_frame_id_ - latest_acked_frame_id_);
   DCHECK_GE(count, 0);
   return count;
 }
 
 base::TimeDelta FrameSender::GetAllowedInFlightMediaDuration() const {
   // The total amount allowed in-flight media should equal the amount that fits
   // within the entire playout delay window, plus the amount of time it takes to
   // receive an ACK from the receiver.
   // TODO(miu): Research is needed, but there is likely a better formula.
   return target_playout_delay_ + (current_round_trip_time_ / 2);
 }
 
 void FrameSender::SendEncodedFrame(
     int requested_bitrate_before_encode,
     scoped_ptr<SenderEncodedFrame> encoded_frame) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   VLOG(2) << SENDER_SSRC << "About to send another frame: last_sent="
           << last_sent_frame_id_ << ", latest_acked=" << latest_acked_frame_id_;
 
-  const uint32 frame_id = encoded_frame->frame_id;
+  const uint32_t frame_id = encoded_frame->frame_id;
 
   const bool is_first_frame_to_be_sent = last_send_time_.is_null();
   last_send_time_ = cast_environment_->Clock()->NowTicks();
   last_sent_frame_id_ = frame_id;
   // If this is the first frame about to be sent, fake the value of
   // |latest_acked_frame_id_| to indicate the receiver starts out all caught up.
   // Also, schedule the periodic frame re-send checks.
   if (is_first_frame_to_be_sent) {
     latest_acked_frame_id_ = frame_id - 1;
     ScheduleNextResendCheck();
@@ skipping 113 matching lines @@
   scoped_ptr<FrameEvent> ack_event(new FrameEvent());
   ack_event->timestamp = now;
   ack_event->type = FRAME_ACK_RECEIVED;
   ack_event->media_type = is_audio_ ? AUDIO_EVENT : VIDEO_EVENT;
   ack_event->rtp_timestamp =
       GetRecordedRtpTimestamp(cast_feedback.ack_frame_id);
   ack_event->frame_id = cast_feedback.ack_frame_id;
   cast_environment_->logger()->DispatchFrameEvent(ack_event.Pass());
 
   const bool is_acked_out_of_order =
-      static_cast<int32>(cast_feedback.ack_frame_id -
-                             latest_acked_frame_id_) < 0;
+      static_cast<int32_t>(cast_feedback.ack_frame_id -
+                           latest_acked_frame_id_) < 0;
   VLOG(2) << SENDER_SSRC
           << "Received ACK" << (is_acked_out_of_order ? " out-of-order" : "")
           << " for frame " << cast_feedback.ack_frame_id;
   if (is_acked_out_of_order) {
     TRACE_EVENT_INSTANT2(
         "cast.stream", "ACK out of order", TRACE_EVENT_SCOPE_THREAD,
         "ack_frame_id", cast_feedback.ack_frame_id,
         "latest_acked_frame_id", latest_acked_frame_id_);
   } else {
     // Cancel resends of acked frames.
-    std::vector<uint32> cancel_sending_frames;
+    std::vector<uint32_t> cancel_sending_frames;
     while (latest_acked_frame_id_ != cast_feedback.ack_frame_id) {
       latest_acked_frame_id_++;
       cancel_sending_frames.push_back(latest_acked_frame_id_);
       // This is a good place to match the trace for frame ids
       // since this ensures we not only track frame ids that are
       // implicitly ACKed, but also handles duplicate ACKs
       TRACE_EVENT_ASYNC_END1("cast.stream",
           is_audio_ ? "Audio Transport" : "Video Transport",
           cast_feedback.ack_frame_id,
           "RTT_usecs", current_round_trip_time_.InMicroseconds());
@@ skipping 22 matching lines @@
     VLOG(1) << SENDER_SSRC << "Dropping: Burst threshold would be exceeded.";
     return true;
   }
 
   // Check that accepting the next frame won't exceed the allowed in-flight
   // media duration.
   const base::TimeDelta duration_would_be_in_flight =
       duration_in_flight + frame_duration;
   const base::TimeDelta allowed_in_flight = GetAllowedInFlightMediaDuration();
   if (VLOG_IS_ON(1)) {
-    const int64 percent = allowed_in_flight > base::TimeDelta() ?
-        100 * duration_would_be_in_flight / allowed_in_flight : kint64max;
+    const int64_t percent =
+        allowed_in_flight > base::TimeDelta()
+            ? 100 * duration_would_be_in_flight / allowed_in_flight
+            : std::numeric_limits<int64_t>::max();
     VLOG_IF(1, percent > 50)
         << SENDER_SSRC
         << duration_in_flight.InMicroseconds() << " usec in-flight + "
         << frame_duration.InMicroseconds() << " usec for next frame --> "
         << percent << "% of allowed in-flight.";
   }
   if (duration_would_be_in_flight > allowed_in_flight) {
     VLOG(1) << SENDER_SSRC << "Dropping: In-flight duration would be too high.";
     return true;
   }
 
   // Next frame is accepted.
   return false;
 }
 
 }  // namespace cast
 }  // namespace media