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

webrtc/p2p/base/port_unittest.cc

 /*
  *  Copyright 2004 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.
  */
 
@@ skipping 44 matching lines @@
 static const SocketAddress kRelayTcpIntAddr("99.99.99.2", 5002);
 static const SocketAddress kRelayTcpExtAddr("99.99.99.3", 5003);
 static const SocketAddress kRelaySslTcpIntAddr("99.99.99.2", 5004);
 static const SocketAddress kRelaySslTcpExtAddr("99.99.99.3", 5005);
 static const SocketAddress kTurnUdpIntAddr("99.99.99.4", STUN_SERVER_PORT);
 static const SocketAddress kTurnUdpExtAddr("99.99.99.5", 0);
 static const RelayCredentials kRelayCredentials("test", "test");
 
 // TODO: Update these when RFC5245 is completely supported.
 // Magic value of 30 is from RFC3484, for IPv4 addresses.
-static const uint32 kDefaultPrflxPriority = ICE_TYPE_PREFERENCE_PRFLX << 24 |
-             30 << 8 | (256 - ICE_CANDIDATE_COMPONENT_DEFAULT);
+static const uint32_t kDefaultPrflxPriority =
+    ICE_TYPE_PREFERENCE_PRFLX << 24 | 30 << 8 |
+    (256 - ICE_CANDIDATE_COMPONENT_DEFAULT);
 
 static const int kTiebreaker1 = 11111;
 static const int kTiebreaker2 = 22222;
 
 static const char* data = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
 
 static Candidate GetCandidate(Port* port) {
   assert(port->Candidates().size() >= 1);
   return port->Candidates()[0];
 }
@@ skipping 16 matching lines @@
 }
 
 // Stub port class for testing STUN generation and processing.
 class TestPort : public Port {
  public:
   TestPort(rtc::Thread* thread,
            const std::string& type,
            rtc::PacketSocketFactory* factory,
            rtc::Network* network,
            const rtc::IPAddress& ip,
-           uint16 min_port,
-           uint16 max_port,
+           uint16_t min_port,
+           uint16_t max_port,
            const std::string& username_fragment,
            const std::string& password)
-      : Port(thread, type, factory, network, ip, min_port, max_port,
-             username_fragment, password) {
-  }
+      : Port(thread,
+             type,
+             factory,
+             network,
+             ip,
+             min_port,
+             max_port,
+             username_fragment,
+             password) {}
   ~TestPort() {}
 
   // Expose GetStunMessage so that we can test it.
   using cricket::Port::GetStunMessage;
 
   // The last StunMessage that was sent on this Port.
   // TODO: Make these const; requires changes to SendXXXXResponse.
   ByteBuffer* last_stun_buf() { return last_stun_buf_.get(); }
   IceMessage* last_stun_msg() { return last_stun_msg_.get(); }
   int last_stun_error_code() {
@@ skipping 122 matching lines @@
     Candidate c = remote_candidate;
     c.set_address(remote_address_);
     conn_ = port_->CreateConnection(c, Port::ORIGIN_MESSAGE);
     conn_->SignalDestroyed.connect(this, &TestChannel::OnDestroyed);
     port_->SendBindingResponse(remote_request_.get(), remote_address_);
     remote_request_.reset();
   }
   void Ping() {
     Ping(0);
   }
-  void Ping(uint32 now) {
-    conn_->Ping(now);
-  }
+  void Ping(uint32_t now) { conn_->Ping(now); }
   void Stop() {
     if (conn_) {
       conn_->Destroy();
     }
   }
 
   void OnPortComplete(Port* port) {
     complete_count_++;
   }
   void SetIceMode(IceMode ice_mode) {
@@ skipping 632 matching lines @@
 class FakePacketSocketFactory : public rtc::PacketSocketFactory {
  public:
   FakePacketSocketFactory()
       : next_udp_socket_(NULL),
         next_server_tcp_socket_(NULL),
         next_client_tcp_socket_(NULL) {
   }
   ~FakePacketSocketFactory() override { }
 
   AsyncPacketSocket* CreateUdpSocket(const SocketAddress& address,
-                                     uint16 min_port,
-                                     uint16 max_port) override {
+                                     uint16_t min_port,
+                                     uint16_t max_port) override {
     EXPECT_TRUE(next_udp_socket_ != NULL);
     AsyncPacketSocket* result = next_udp_socket_;
     next_udp_socket_ = NULL;
     return result;
   }
 
   AsyncPacketSocket* CreateServerTcpSocket(const SocketAddress& local_address,
-                                           uint16 min_port,
-                                           uint16 max_port,
+                                           uint16_t min_port,
+                                           uint16_t max_port,
                                            int opts) override {
     EXPECT_TRUE(next_server_tcp_socket_ != NULL);
     AsyncPacketSocket* result = next_server_tcp_socket_;
     next_server_tcp_socket_ = NULL;
     return result;
   }
 
   // TODO: |proxy_info| and |user_agent| should be set
   // per-factory and not when socket is created.
   AsyncPacketSocket* CreateClientTcpSocket(const SocketAddress& local_address,
@@ skipping 1032 matching lines @@
 
   ASSERT_TRUE_WAIT(rport->last_stun_msg() != NULL, 1000);
   IceMessage* msg = rport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   // Send rport binding request to lport.
   lconn->OnReadPacket(rport->last_stun_buf()->Data(),
                       rport->last_stun_buf()->Length(),
                       rtc::PacketTime());
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
   EXPECT_EQ(STUN_BINDING_RESPONSE, lport->last_stun_msg()->type());
-  uint32 last_ping_received1 = lconn->last_ping_received();
+  uint32_t last_ping_received1 = lconn->last_ping_received();
 
   // Adding a delay of 100ms.
   rtc::Thread::Current()->ProcessMessages(100);
   // Pinging lconn using stun indication message.
   lconn->OnReadPacket(buf->Data(), buf->Length(), rtc::PacketTime());
-  uint32 last_ping_received2 = lconn->last_ping_received();
+  uint32_t last_ping_received2 = lconn->last_ping_received();
   EXPECT_GT(last_ping_received2, last_ping_received1);
 }
 
 TEST_F(PortTest, TestComputeCandidatePriority) {
   rtc::scoped_ptr<TestPort> port(
       CreateTestPort(kLocalAddr1, "name", "pass"));
   port->set_type_preference(90);
   port->set_component(177);
   port->AddCandidateAddress(SocketAddress("192.168.1.4", 1234));
   port->AddCandidateAddress(SocketAddress("2001:db8::1234", 1234));
   port->AddCandidateAddress(SocketAddress("fc12:3456::1234", 1234));
   port->AddCandidateAddress(SocketAddress("::ffff:192.168.1.4", 1234));
   port->AddCandidateAddress(SocketAddress("::192.168.1.4", 1234));
   port->AddCandidateAddress(SocketAddress("2002::1234:5678", 1234));
   port->AddCandidateAddress(SocketAddress("2001::1234:5678", 1234));
   port->AddCandidateAddress(SocketAddress("fecf::1234:5678", 1234));
   port->AddCandidateAddress(SocketAddress("3ffe::1234:5678", 1234));
   // These should all be:
   // (90 << 24) | ([rfc3484 pref value] << 8) | (256 - 177)
-  uint32 expected_priority_v4 = 1509957199U;
-  uint32 expected_priority_v6 = 1509959759U;
-  uint32 expected_priority_ula = 1509962319U;
-  uint32 expected_priority_v4mapped = expected_priority_v4;
-  uint32 expected_priority_v4compat = 1509949775U;
-  uint32 expected_priority_6to4 = 1509954639U;
-  uint32 expected_priority_teredo = 1509952079U;
-  uint32 expected_priority_sitelocal = 1509949775U;
-  uint32 expected_priority_6bone = 1509949775U;
+  uint32_t expected_priority_v4 = 1509957199U;
+  uint32_t expected_priority_v6 = 1509959759U;
+  uint32_t expected_priority_ula = 1509962319U;
+  uint32_t expected_priority_v4mapped = expected_priority_v4;
+  uint32_t expected_priority_v4compat = 1509949775U;
+  uint32_t expected_priority_6to4 = 1509954639U;
+  uint32_t expected_priority_teredo = 1509952079U;
+  uint32_t expected_priority_sitelocal = 1509949775U;
+  uint32_t expected_priority_6bone = 1509949775U;
   ASSERT_EQ(expected_priority_v4, port->Candidates()[0].priority());
   ASSERT_EQ(expected_priority_v6, port->Candidates()[1].priority());
   ASSERT_EQ(expected_priority_ula, port->Candidates()[2].priority());
   ASSERT_EQ(expected_priority_v4mapped, port->Candidates()[3].priority());
   ASSERT_EQ(expected_priority_v4compat, port->Candidates()[4].priority());
   ASSERT_EQ(expected_priority_6to4, port->Candidates()[5].priority());
   ASSERT_EQ(expected_priority_teredo, port->Candidates()[6].priority());
   ASSERT_EQ(expected_priority_sitelocal, port->Candidates()[7].priority());
   ASSERT_EQ(expected_priority_6bone, port->Candidates()[8].priority());
 }
@@ skipping 211 matching lines @@
   // Accept the connection to return the binding response, transition to
   // writable, and allow data to be sent.
   ch2.AcceptConnection(GetCandidate(port1));
   EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch1.conn()->write_state(),
                  kTimeout);
   EXPECT_EQ(data_size, ch1.conn()->Send(data, data_size, options));
 
   // Ask the connection to update state as if enough time has passed to lose
   // full writability and 5 pings went unresponded to. We'll accomplish the
   // latter by sending pings but not pumping messages.
-  for (uint32 i = 1; i <= CONNECTION_WRITE_CONNECT_FAILURES; ++i) {
+  for (uint32_t i = 1; i <= CONNECTION_WRITE_CONNECT_FAILURES; ++i) {
     ch1.Ping(i);
   }
-  uint32 unreliable_timeout_delay = CONNECTION_WRITE_CONNECT_TIMEOUT + 500u;
+  uint32_t unreliable_timeout_delay = CONNECTION_WRITE_CONNECT_TIMEOUT + 500u;
   ch1.conn()->UpdateState(unreliable_timeout_delay);
   EXPECT_EQ(Connection::STATE_WRITE_UNRELIABLE, ch1.conn()->write_state());
 
   // Data should be able to be sent in this state.
   EXPECT_EQ(data_size, ch1.conn()->Send(data, data_size, options));
 
   // And now allow the other side to process the pings and send binding
   // responses.
   EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch1.conn()->write_state(),
                  kTimeout);
 
   // Wait long enough for a full timeout (past however long we've already
   // waited).
-  for (uint32 i = 1; i <= CONNECTION_WRITE_CONNECT_FAILURES; ++i) {
+  for (uint32_t i = 1; i <= CONNECTION_WRITE_CONNECT_FAILURES; ++i) {
     ch1.Ping(unreliable_timeout_delay + i);
   }
   ch1.conn()->UpdateState(unreliable_timeout_delay + CONNECTION_WRITE_TIMEOUT +
                           500u);
   EXPECT_EQ(Connection::STATE_WRITE_TIMEOUT, ch1.conn()->write_state());
 
   // Now that the connection has completely timed out, data send should fail.
   EXPECT_EQ(SOCKET_ERROR, ch1.conn()->Send(data, data_size, options));
 
   ch1.Stop();
@@ skipping 12 matching lines @@
 
   // Acquire addresses.
   ch1.Start();
   ch2.Start();
 
   ch1.CreateConnection(GetCandidate(port2));
   ASSERT_TRUE(ch1.conn() != NULL);
   EXPECT_EQ(Connection::STATE_WRITE_INIT, ch1.conn()->write_state());
 
   // Attempt to go directly to write timeout.
-  for (uint32 i = 1; i <= CONNECTION_WRITE_CONNECT_FAILURES; ++i) {
+  for (uint32_t i = 1; i <= CONNECTION_WRITE_CONNECT_FAILURES; ++i) {
     ch1.Ping(i);
   }
   ch1.conn()->UpdateState(CONNECTION_WRITE_TIMEOUT + 500u);
   EXPECT_EQ(Connection::STATE_WRITE_TIMEOUT, ch1.conn()->write_state());
 }
 
 // This test verifies the connection setup between ICEMODE_FULL
 // and ICEMODE_LITE.
 // In this test |ch1| behaves like FULL mode client and we have created
 // port which responds to the ping message just like LITE client.
@@ skipping 106 matching lines @@
   // Set up channels and ensure both ports will be deleted.
   TestChannel ch1(port1);
   TestChannel ch2(port2);
 
   // Simulate a connection that succeeds, and then is destroyed.
   StartConnectAndStopChannels(&ch1, &ch2);
 
   // The controlled port should be destroyed after 10 milliseconds.
   EXPECT_TRUE_WAIT(destroyed(), kTimeout);
 }