Switch to standard integer types in media/.

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 "base/big_endian.h"
 #include "base/bind.h"
@@ skipping 63 matching lines @@
   EmitAvailableEncodedFrames();
 }
 
 bool FrameReceiver::ProcessPacket(scoped_ptr<Packet> packet) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   if (Rtcp::IsRtcpPacket(&packet->front(), packet->size())) {
     rtcp_.IncomingRtcpPacket(&packet->front(), packet->size());
   } else {
     RtpCastHeader rtp_header;
-    const uint8* payload_data;
+    const uint8_t* payload_data;
     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);
   }
 
   if (!reports_are_scheduled_) {
     ScheduleNextRtcpReport();
     ScheduleNextCastMessage();
     reports_are_scheduled_ = true;
   }
 
   return true;
 }
 
 void FrameReceiver::ProcessParsedPacket(const RtpCastHeader& rtp_header,
-                                        const uint8* payload_data,
+                                        const uint8_t* payload_data,
                                         size_t payload_size) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   const base::TimeTicks now = cast_environment_->Clock()->NowTicks();
 
   frame_id_to_rtp_timestamp_[rtp_header.frame_id & 0xff] =
       rtp_header.rtp_timestamp;
 
   scoped_ptr<PacketEvent> receive_event(new PacketEvent());
   receive_event->timestamp = now;
@@ skipping 29 matching lines @@
       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>(fresh_sync_rtp - lip_sync_rtp_timestamp_),
+          static_cast<int32_t>(fresh_sync_rtp - lip_sync_rtp_timestamp_),
           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)
@@ skipping 126 matching lines @@
   if (!callback.is_null())
     callback.Run(encoded_frame.Pass());
 }
 
 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>(frame.rtp_timestamp - lip_sync_rtp_timestamp_),
-          rtp_timebase_) +
-      target_playout_delay;
+  return lip_sync_reference_time_ + lip_sync_drift_.Current() +
+         RtpDeltaToTimeDelta(static_cast<int32_t>(frame.rtp_timestamp -
+                                                  lip_sync_rtp_timestamp_),
+                             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(
       time_to_send, base::TimeDelta::FromMilliseconds(kMinSchedulingDelayMs));
@@ skipping 30 matching lines @@
                                       rtcp_.ConvertToNTPAndSave(now),
                                       NULL,
                                       base::TimeDelta(),
                                       NULL,
                                       &stats);
   ScheduleNextRtcpReport();
 }
 
 }  // namespace cast
 }  // namespace media