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

webrtc/p2p/base/pseudotcp_unittest.cc

 /*
  *  Copyright 2011 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <algorithm>
 #include <vector>
 
 #include "webrtc/p2p/base/pseudotcp.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/messagehandler.h"
 #include "webrtc/base/stream.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/timeutils.h"
 
 using cricket::PseudoTcp;
 
 static const int kConnectTimeoutMs = 10000;  // ~3 * default RTO of 3000ms
 static const int kTransferTimeoutMs = 15000;
 static const int kBlockSize = 4096;
 
 class PseudoTcpForTest : public cricket::PseudoTcp {
  public:
-  PseudoTcpForTest(cricket::IPseudoTcpNotify* notify, uint32 conv)
-      : PseudoTcp(notify, conv) {
-  }
+  PseudoTcpForTest(cricket::IPseudoTcpNotify* notify, uint32_t conv)
+      : PseudoTcp(notify, conv) {}
 
   bool isReceiveBufferFull() const {
     return PseudoTcp::isReceiveBufferFull();
   }
 
   void disableWindowScale() {
     PseudoTcp::disableWindowScale();
   }
 };
 
@@ skipping 77 matching lines @@
     LOG(LS_VERBOSE) << "Opened";
     if (tcp == &local_) {
       have_connected_ = true;
       OnTcpWriteable(tcp);
     }
   }
   // Test derived from the base should override
   //   virtual void OnTcpReadable(PseudoTcp* tcp)
   // and
   //   virtual void OnTcpWritable(PseudoTcp* tcp)
-  virtual void OnTcpClosed(PseudoTcp* tcp, uint32 error) {
+  virtual void OnTcpClosed(PseudoTcp* tcp, uint32_t error) {
     // Consider ourselves closed when the remote side gets OnTcpClosed.
     // TODO: OnTcpClosed is only ever notified in case of error in
     // the current implementation.  Solicited close is not (yet) supported.
     LOG(LS_VERBOSE) << "Closed";
     EXPECT_EQ(0U, error);
     if (tcp == &remote_) {
       have_disconnected_ = true;
     }
   }
   virtual WriteResult TcpWritePacket(PseudoTcp* tcp,
                                      const char* buffer, size_t len) {
     // Randomly drop the desired percentage of packets.
     // Also drop packets that are larger than the configured MTU.
-    if (rtc::CreateRandomId() % 100 < static_cast<uint32>(loss_)) {
+    if (rtc::CreateRandomId() % 100 < static_cast<uint32_t>(loss_)) {
       LOG(LS_VERBOSE) << "Randomly dropping packet, size=" << len;
     } else if (len > static_cast<size_t>(std::min(local_mtu_, remote_mtu_))) {
       LOG(LS_VERBOSE) << "Dropping packet that exceeds path MTU, size=" << len;
     } else {
       int id = (tcp == &local_) ? MSG_RPACKET : MSG_LPACKET;
       std::string packet(buffer, len);
       rtc::Thread::Current()->PostDelayed(delay_, this, id,
           rtc::WrapMessageData(packet));
     }
     return WR_SUCCESS;
   }
 
   void UpdateLocalClock() { UpdateClock(&local_, MSG_LCLOCK); }
   void UpdateRemoteClock() { UpdateClock(&remote_, MSG_RCLOCK); }
-  void UpdateClock(PseudoTcp* tcp, uint32 message) {
+  void UpdateClock(PseudoTcp* tcp, uint32_t message) {
     long interval = 0;  // NOLINT
     tcp->GetNextClock(PseudoTcp::Now(), interval);
     interval = std::max<int>(interval, 0L);  // sometimes interval is < 0
     rtc::Thread::Current()->Clear(this, message);
     rtc::Thread::Current()->PostDelayed(interval, this, message);
   }
 
   virtual void OnMessage(rtc::Message* message) {
     switch (message->message_id) {
       case MSG_LPACKET: {
@@ skipping 32 matching lines @@
   bool have_disconnected_;
   int local_mtu_;
   int remote_mtu_;
   int delay_;
   int loss_;
 };
 
 class PseudoTcpTest : public PseudoTcpTestBase {
  public:
   void TestTransfer(int size) {
-    uint32 start, elapsed;
+    uint32_t start, elapsed;
     size_t received;
     // Create some dummy data to send.
     send_stream_.ReserveSize(size);
     for (int i = 0; i < size; ++i) {
       char ch = static_cast<char>(i);
       send_stream_.Write(&ch, 1, NULL, NULL);
     }
     send_stream_.Rewind();
     // Prepare the receive stream.
     recv_stream_.ReserveSize(size);
@@ skipping 96 matching lines @@
   PseudoTcpTestPingPong()
       : iterations_remaining_(0),
         sender_(NULL),
         receiver_(NULL),
         bytes_per_send_(0) {
   }
   void SetBytesPerSend(int bytes) {
     bytes_per_send_ = bytes;
   }
   void TestPingPong(int size, int iterations) {
-    uint32 start, elapsed;
+    uint32_t start, elapsed;
     iterations_remaining_ = iterations;
     receiver_ = &remote_;
     sender_ = &local_;
     // Create some dummy data to send.
     send_stream_.ReserveSize(size);
     for (int i = 0; i < size; ++i) {
       char ch = static_cast<char>(i);
       send_stream_.Write(&ch, 1, NULL, NULL);
     }
     send_stream_.Rewind();
@@ skipping 142 matching lines @@
     switch (message_id) {
       case MSG_WRITE: {
         WriteData();
         break;
       }
       default:
         break;
     }
   }
 
-  uint32 EstimateReceiveWindowSize() const {
-    return static_cast<uint32>(recv_position_[0]);
+  uint32_t EstimateReceiveWindowSize() const {
+    return static_cast<uint32_t>(recv_position_[0]);
   }
 
-  uint32 EstimateSendWindowSize() const {
-    return static_cast<uint32>(send_position_[0] - recv_position_[0]);
+  uint32_t EstimateSendWindowSize() const {
+    return static_cast<uint32_t>(send_position_[0] - recv_position_[0]);
   }
 
  private:
   // IPseudoTcpNotify interface
   virtual void OnTcpReadable(PseudoTcp* tcp) {
   }
 
   virtual void OnTcpWriteable(PseudoTcp* tcp) {
   }
 
@@ skipping 324 matching lines @@
 /* Test sending data with mismatched MTUs. We should detect this and reduce
 // our packet size accordingly.
 // TODO: This doesn't actually work right now. The current code
 // doesn't detect if the MTU is set too high on either side.
 TEST_F(PseudoTcpTest, TestSendWithMismatchedMtus) {
   SetLocalMtu(1500);
   SetRemoteMtu(1280);
   TestTransfer(1000000);
 }
 */