Use suffixed {uint,int}{8,16,32,64}_t types.

talk/media/sctp/sctpdataengine.cc

 /*
  * libjingle
  * Copyright 2012 Google Inc. and Robin Seggelmann
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 70 matching lines @@
       if (!first) result << " | ";
       result << flaginfo[i].name;
       first = false;
     }
   }
   return result.str();
 }
 
 // Returns a comma-separated, human-readable list of the integers in 'array'.
 // All 'num_elems' of them.
-std::string ListArray(const uint16* array, int num_elems) {
+std::string ListArray(const uint16_t* array, int num_elems) {
   std::stringstream result;
   for (int i = 0; i < num_elems; ++i) {
     if (i) {
       result << ", " << array[i];
     } else {
       result << array[i];
     }
   }
   return result.str();
 }
@@ skipping 466 matching lines @@
 }
 
 bool SctpDataMediaChannel::SetRecvParameters(const DataRecvParameters& params) {
   return SetRecvCodecs(params.codecs);
 }
 
 bool SctpDataMediaChannel::AddSendStream(const StreamParams& stream) {
   return AddStream(stream);
 }
 
-bool SctpDataMediaChannel::RemoveSendStream(uint32 ssrc) {
+bool SctpDataMediaChannel::RemoveSendStream(uint32_t ssrc) {
   return ResetStream(ssrc);
 }
 
 bool SctpDataMediaChannel::AddRecvStream(const StreamParams& stream) {
   // SCTP DataChannels are always bi-directional and calling AddSendStream will
   // enable both sending and receiving on the stream. So AddRecvStream is a
   // no-op.
   return true;
 }
 
-bool SctpDataMediaChannel::RemoveRecvStream(uint32 ssrc) {
+bool SctpDataMediaChannel::RemoveRecvStream(uint32_t ssrc) {
   // SCTP DataChannels are always bi-directional and calling RemoveSendStream
   // will disable both sending and receiving on the stream. So RemoveRecvStream
   // is a no-op.
   return true;
 }
 
 bool SctpDataMediaChannel::SendData(
     const SendDataParams& params,
     const rtc::Buffer& payload,
     SendDataResult* result) {
@@ skipping 120 matching lines @@
                     << "Not receiving packet with sid=" << params.ssrc
                     << " len=" << buffer->size() << " before SetReceive(true).";
   }
 }
 
 bool SctpDataMediaChannel::AddStream(const StreamParams& stream) {
   if (!stream.has_ssrcs()) {
     return false;
   }
 
-  const uint32 ssrc = stream.first_ssrc();
+  const uint32_t ssrc = stream.first_ssrc();
   if (open_streams_.find(ssrc) != open_streams_.end()) {
     LOG(LS_WARNING) << debug_name_ << "->Add(Send|Recv)Stream(...): "
                     << "Not adding data stream '" << stream.id
                     << "' with ssrc=" << ssrc
                     << " because stream is already open.";
     return false;
   } else if (queued_reset_streams_.find(ssrc) != queued_reset_streams_.end()
              || sent_reset_streams_.find(ssrc) != sent_reset_streams_.end()) {
     LOG(LS_WARNING) << debug_name_ << "->Add(Send|Recv)Stream(...): "
                     << "Not adding data stream '" << stream.id
                     << "' with ssrc=" << ssrc
                     << " because stream is still closing.";
     return false;
   }
 
   open_streams_.insert(ssrc);
   return true;
 }
 
-bool SctpDataMediaChannel::ResetStream(uint32 ssrc) {
+bool SctpDataMediaChannel::ResetStream(uint32_t ssrc) {
   // We typically get this called twice for the same stream, once each for
   // Send and Recv.
   StreamSet::iterator found = open_streams_.find(ssrc);
 
   if (found == open_streams_.end()) {
     LOG(LS_VERBOSE) << debug_name_ << "->ResetStream(" << ssrc << "): "
                     << "stream not found.";
     return false;
   } else {
     LOG(LS_VERBOSE) << debug_name_ << "->ResetStream(" << ssrc << "): "
@@ skipping 229 matching lines @@
 bool SctpDataMediaChannel::SendQueuedStreamResets() {
   if (!sent_reset_streams_.empty() || queued_reset_streams_.empty())
     return true;
 
   LOG(LS_VERBOSE) << "SendQueuedStreamResets[" << debug_name_ << "]: Sending ["
                   << ListStreams(queued_reset_streams_) << "], Open: ["
                   << ListStreams(open_streams_) << "], Sent: ["
                   << ListStreams(sent_reset_streams_) << "]";
 
   const size_t num_streams = queued_reset_streams_.size();
-  const size_t num_bytes = sizeof(struct sctp_reset_streams)
-    + (num_streams * sizeof(uint16));
+  const size_t num_bytes =
+      sizeof(struct sctp_reset_streams) + (num_streams * sizeof(uint16_t));
 
-  std::vector<uint8> reset_stream_buf(num_bytes, 0);
+  std::vector<uint8_t> reset_stream_buf(num_bytes, 0);
   struct sctp_reset_streams* resetp = reinterpret_cast<sctp_reset_streams*>(
       &reset_stream_buf[0]);
   resetp->srs_assoc_id = SCTP_ALL_ASSOC;
   resetp->srs_flags = SCTP_STREAM_RESET_INCOMING | SCTP_STREAM_RESET_OUTGOING;
   resetp->srs_number_streams = rtc::checked_cast<uint16_t>(num_streams);
   int result_idx = 0;
   for (StreamSet::iterator it = queued_reset_streams_.begin();
        it != queued_reset_streams_.end(); ++it) {
     resetp->srs_stream_list[result_idx++] = *it;
   }
@@ skipping 23 matching lines @@
     }
     case MSG_SCTPOUTBOUNDPACKET: {
       rtc::scoped_ptr<OutboundPacketMessage> pdata(
           static_cast<OutboundPacketMessage*>(msg->pdata));
       OnPacketFromSctpToNetwork(pdata->data().get());
       break;
     }
   }
 }
 }  // namespace cricket