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

talk/app/webrtc/datachannel.cc

 /*
  * libjingle
  * Copyright 2012 Google Inc.
  *
  * 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 175 matching lines @@
 
 bool DataChannel::reliable() const {
   if (data_channel_type_ == cricket::DCT_RTP) {
     return false;
   } else {
     return config_.maxRetransmits == -1 &&
            config_.maxRetransmitTime == -1;
   }
 }
 
-uint64 DataChannel::buffered_amount() const {
+uint64_t DataChannel::buffered_amount() const {
   return queued_send_data_.byte_count();
 }
 
 void DataChannel::Close() {
   if (state_ == kClosed)
     return;
   send_ssrc_ = 0;
   send_ssrc_set_ = false;
   SetState(kClosing);
   UpdateState();
@@ skipping 25 matching lines @@
 
   bool success = SendDataMessage(buffer, true);
   if (data_channel_type_ == cricket::DCT_RTP) {
     return success;
   }
 
   // Always return true for SCTP DataChannel per the spec.
   return true;
 }
 
-void DataChannel::SetReceiveSsrc(uint32 receive_ssrc) {
+void DataChannel::SetReceiveSsrc(uint32_t receive_ssrc) {
   ASSERT(data_channel_type_ == cricket::DCT_RTP);
 
   if (receive_ssrc_set_) {
     return;
   }
   receive_ssrc_ = receive_ssrc;
   receive_ssrc_set_ = true;
   UpdateState();
 }
 
@@ skipping 16 matching lines @@
   if (!connected_to_provider_) {
     connected_to_provider_ = provider_->ConnectDataChannel(this);
   }
   // The sid may have been unassigned when provider_->ConnectDataChannel was
   // done. So always add the streams even if connected_to_provider_ is true.
   if (config_.id >= 0) {
     provider_->AddSctpDataStream(config_.id);
   }
 }
 
-void DataChannel::SetSendSsrc(uint32 send_ssrc) {
+void DataChannel::SetSendSsrc(uint32_t send_ssrc) {
   ASSERT(data_channel_type_ == cricket::DCT_RTP);
   if (send_ssrc_set_) {
     return;
   }
   send_ssrc_ = send_ssrc;
   send_ssrc_set_ = true;
   UpdateState();
 }
 
 void DataChannel::OnMessage(rtc::Message* msg) {
   switch (msg->message_id) {
     case MSG_CHANNELREADY:
       OnChannelReady(true);
       break;
   }
 }
 
 // The underlaying data engine is closing.
 // This function makes sure the DataChannel is disconnected and changes state to
 // kClosed.
 void DataChannel::OnDataEngineClose() {
   DoClose();
 }
 
 void DataChannel::OnDataReceived(cricket::DataChannel* channel,
                                  const cricket::ReceiveDataParams& params,
                                  const rtc::Buffer& payload) {
-  uint32 expected_ssrc =
+  uint32_t expected_ssrc =
       (data_channel_type_ == cricket::DCT_RTP) ? receive_ssrc_ : config_.id;
   if (params.ssrc != expected_ssrc) {
     return;
   }
 
   if (params.type == cricket::DMT_CONTROL) {
     ASSERT(data_channel_type_ == cricket::DCT_SCTP);
     if (handshake_state_ != kHandshakeWaitingForAck) {
       // Ignore it if we are not expecting an ACK message.
       LOG(LS_WARNING) << "DataChannel received unexpected CONTROL message, "
@@ skipping 151 matching lines @@
   }
 }
 
 void DataChannel::SendQueuedDataMessages() {
   if (queued_send_data_.Empty()) {
     return;
   }
 
   ASSERT(state_ == kOpen || state_ == kClosing);
 
-  uint64 start_buffered_amount = buffered_amount();
+  uint64_t start_buffered_amount = buffered_amount();
   while (!queued_send_data_.Empty()) {
     DataBuffer* buffer = queued_send_data_.Front();
     if (!SendDataMessage(*buffer, false)) {
       // Leave the message in the queue if sending is aborted.
       break;
     }
     queued_send_data_.Pop();
     delete buffer;
   }
 
@@ skipping 108 matching lines @@
     QueueControlMessage(buffer);
   } else {
     LOG(LS_ERROR) << "Closing the DataChannel due to a failure to send"
                   << " the CONTROL message, send_result = " << send_result;
     Close();
   }
   return retval;
 }
 
 }  // namespace webrtc