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

talk/media/sctp/sctpdataengine_unittest.cc

 /*
  * libjingle
  * Copyright 2013 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 156 matching lines @@
   bool writable_;
 };
 
 class SignalChannelClosedObserver : public sigslot::has_slots<> {
  public:
   SignalChannelClosedObserver() {}
   void BindSelf(cricket::SctpDataMediaChannel* channel) {
     channel->SignalStreamClosedRemotely.connect(
         this, &SignalChannelClosedObserver::OnStreamClosed);
   }
-  void OnStreamClosed(uint32 stream) {
-    streams_.push_back(stream);
-  }
+  void OnStreamClosed(uint32_t stream) { streams_.push_back(stream); }
 
-  int StreamCloseCount(uint32 stream) {
+  int StreamCloseCount(uint32_t stream) {
     return std::count(streams_.begin(), streams_.end(), stream);
   }
 
-  bool WasStreamClosed(uint32 stream) {
+  bool WasStreamClosed(uint32_t stream) {
     return std::find(streams_.begin(), streams_.end(), stream)
         != streams_.end();
   }
 
  private:
-  std::vector<uint32> streams_;
+  std::vector<uint32_t> streams_;
 };
 
 class SignalChannelClosedReopener : public sigslot::has_slots<> {
  public:
   SignalChannelClosedReopener(cricket::SctpDataMediaChannel* channel,
                               cricket::SctpDataMediaChannel* peer)
       : channel_(channel), peer_(peer) {}
 
   void OnStreamClosed(int stream) {
     cricket::StreamParams p(cricket::StreamParams::CreateLegacy(stream));
@@ skipping 94 matching lines @@
     cricket::SctpDataMediaChannel* channel =
         static_cast<cricket::SctpDataMediaChannel*>(engine_->CreateChannel(
             cricket::DCT_SCTP));
     channel->SetInterface(net);
     // When data is received, pass it to the SctpFakeDataReceiver.
     channel->SignalDataReceived.connect(
         recv, &SctpFakeDataReceiver::OnDataReceived);
     return channel;
   }
 
-  bool SendData(cricket::SctpDataMediaChannel* chan, uint32 ssrc,
+  bool SendData(cricket::SctpDataMediaChannel* chan,
+                uint32_t ssrc,
                 const std::string& msg,
                 cricket::SendDataResult* result) {
     cricket::SendDataParams params;
     params.ssrc = ssrc;
 
     return chan->SendData(params, rtc::Buffer(
         &msg[0], msg.length()), result);
   }
 
-  bool ReceivedData(const SctpFakeDataReceiver* recv, uint32 ssrc,
-                    const std::string& msg ) {
+  bool ReceivedData(const SctpFakeDataReceiver* recv,
+                    uint32_t ssrc,
+                    const std::string& msg) {
     return (recv->received() &&
             recv->last_params().ssrc == ssrc &&
             recv->last_data() == msg);
   }
 
   bool ProcessMessagesUntilIdle() {
     rtc::Thread* thread = rtc::Thread::Current();
     while (!thread->empty()) {
       rtc::Message msg;
       if (thread->Get(&msg, rtc::Thread::kForever)) {
@@ skipping 209 matching lines @@
   // Channel 1 is gone now.
 
   // Create a new channel 1.
   AddStream(1);
   ASSERT_TRUE(SendData(channel1(), 1, "hi?", &result));
   EXPECT_EQ(cricket::SDR_SUCCESS, result);
   EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hi?"), 1000);
   channel1()->RemoveSendStream(1);
   EXPECT_TRUE_WAIT(chan_2_sig_receiver.StreamCloseCount(1) == 2, 1000);
 }