Switch to standard integer types in media/.

media/cast/net/pacing/paced_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/net/pacing/paced_sender.h"
 
 #include "base/big_endian.h"
 #include "base/bind.h"
 #include "base/debug/dump_without_crashing.h"
 #include "base/message_loop/message_loop.h"
 
 namespace media {
 namespace cast {
 
 namespace {
 
-static const int64 kPacingIntervalMs = 10;
+static const int64_t kPacingIntervalMs = 10;
 // Each frame will be split into no more than kPacingMaxBurstsPerFrame
 // bursts of packets.
 static const size_t kPacingMaxBurstsPerFrame = 3;
 static const size_t kMaxDedupeWindowMs = 500;
 
 // "Impossible" upper-bound on the maximum number of packets that should ever be
 // enqueued in the pacer.  This is used to detect bugs, reported as crash dumps.
 static const size_t kHugeQueueLengthSeconds = 10;
 static const size_t kRidiculousNumberOfPackets =
     kHugeQueueLengthSeconds * (kMaxBurstSize * 1000 / kPacingIntervalMs);
 
 }  // namespace
 
 DedupInfo::DedupInfo() : last_byte_acked_for_audio(0) {}
 
 // static
 PacketKey PacedPacketSender::MakePacketKey(PacketKey::PacketType packet_type,
-                                           uint32 frame_id,
-                                           uint32 ssrc,
-                                           uint16 packet_id) {
+                                           uint32_t frame_id,
+                                           uint32_t ssrc,
+                                           uint16_t packet_id) {
   PacketKey key{packet_type, frame_id, ssrc, packet_id};
   return key;
 }
 
 PacedSender::PacketSendRecord::PacketSendRecord()
     : last_byte_sent(0), last_byte_sent_for_audio(0) {}
 
 PacedSender::PacedSender(
     size_t target_burst_size,
     size_t max_burst_size,
@@ skipping 12 matching lines @@
       current_max_burst_size_(target_burst_size_),
       next_max_burst_size_(target_burst_size_),
       next_next_max_burst_size_(target_burst_size_),
       current_burst_size_(0),
       state_(State_Unblocked),
       has_reached_upper_bound_once_(false),
       weak_factory_(this) {}
 
 PacedSender::~PacedSender() {}
 
-void PacedSender::RegisterAudioSsrc(uint32 audio_ssrc) {
+void PacedSender::RegisterAudioSsrc(uint32_t audio_ssrc) {
   audio_ssrc_ = audio_ssrc;
 }
 
-void PacedSender::RegisterVideoSsrc(uint32 video_ssrc) {
+void PacedSender::RegisterVideoSsrc(uint32_t video_ssrc) {
   video_ssrc_ = video_ssrc;
 }
 
-void PacedSender::RegisterPrioritySsrc(uint32 ssrc) {
+void PacedSender::RegisterPrioritySsrc(uint32_t ssrc) {
   priority_ssrcs_.push_back(ssrc);
 }
 
-int64 PacedSender::GetLastByteSentForPacket(const PacketKey& packet_key) {
+int64_t PacedSender::GetLastByteSentForPacket(const PacketKey& packet_key) {
   PacketSendHistory::const_iterator it = send_history_.find(packet_key);
   if (it == send_history_.end())
     return 0;
   return it->second.last_byte_sent;
 }
 
-int64 PacedSender::GetLastByteSentForSsrc(uint32 ssrc) {
-  std::map<uint32, int64>::const_iterator it = last_byte_sent_.find(ssrc);
+int64_t PacedSender::GetLastByteSentForSsrc(uint32_t ssrc) {
+  std::map<uint32_t, int64_t>::const_iterator it = last_byte_sent_.find(ssrc);
   if (it == last_byte_sent_.end())
     return 0;
   return it->second;
 }
 
 bool PacedSender::SendPackets(const SendPacketVector& packets) {
   if (packets.empty()) {
     return true;
   }
   const bool high_priority = IsHighPriority(packets.begin()->first);
@@ skipping 61 matching lines @@
       packet_list_[packets[i].first] =
           make_pair(PacketType_Resend, packets[i].second);
     }
   }
   if (state_ == State_Unblocked) {
     SendStoredPackets();
   }
   return true;
 }
 
-bool PacedSender::SendRtcpPacket(uint32 ssrc, PacketRef packet) {
+bool PacedSender::SendRtcpPacket(uint32_t ssrc, PacketRef packet) {
   if (state_ == State_TransportBlocked) {
     PacketKey key =
         PacedPacketSender::MakePacketKey(PacketKey::RTCP, 0, ssrc, 0);
     priority_packet_list_[key] = make_pair(PacketType_RTCP, packet);
   } else {
     // We pass the RTCP packets straight through.
     if (!transport_->SendPacket(
             packet,
             base::Bind(&PacedSender::SendStoredPackets,
                        weak_factory_.GetWeakPtr()))) {
@@ skipping 146 matching lines @@
 
   // Populate the new PacketEvent by parsing the wire-format |packet|.
   //
   // TODO(miu): This parsing logic belongs in RtpParser.
   event.timestamp = clock_->NowTicks();
   event.type = type;
   base::BigEndianReader reader(reinterpret_cast<const char*>(&packet[0]),
                                packet.size());
   bool success = reader.Skip(4);
   success &= reader.ReadU32(&event.rtp_timestamp);
-  uint32 ssrc;
+  uint32_t ssrc;
   success &= reader.ReadU32(&ssrc);
   if (ssrc == audio_ssrc_) {
     event.media_type = AUDIO_EVENT;
   } else if (ssrc == video_ssrc_) {
     event.media_type = VIDEO_EVENT;
   } else {
     DVLOG(3) << "Got unknown ssrc " << ssrc << " when logging packet event";
     return;
   }
   success &= reader.Skip(2);
   success &= reader.ReadU16(&event.packet_id);
   success &= reader.ReadU16(&event.max_packet_id);
   event.size = packet.size();
   DCHECK(success);
 }
 
 }  // namespace cast
 }  // namespace media