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

webrtc/p2p/base/relayserver.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.
  */
 
 #include "webrtc/p2p/base/relayserver.h"
 
 #ifdef WEBRTC_POSIX
 #include <errno.h>
 #endif  // WEBRTC_POSIX
 
 #include <algorithm>
 
 #include "webrtc/base/asynctcpsocket.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/socketadapters.h"
 
 namespace cricket {
 
 // By default, we require a ping every 90 seconds.
 const int MAX_LIFETIME = 15 * 60 * 1000;
 
 // The number of bytes in each of the usernames we use.
-const uint32 USERNAME_LENGTH = 16;
+const uint32_t USERNAME_LENGTH = 16;
 
 // Calls SendTo on the given socket and logs any bad results.
 void Send(rtc::AsyncPacketSocket* socket, const char* bytes, size_t size,
           const rtc::SocketAddress& addr) {
   rtc::PacketOptions options;
   int result = socket->SendTo(bytes, size, addr, options);
   if (result < static_cast<int>(size)) {
     LOG(LS_ERROR) << "SendTo wrote only " << result << " of " << size
                   << " bytes";
   } else if (result < 0) {
@@ skipping 215 matching lines @@
   }
 
   // The initial packet should have a username (which identifies the binding).
   const StunByteStringAttribute* username_attr =
       msg.GetByteString(STUN_ATTR_USERNAME);
   if (!username_attr) {
     LOG(LS_WARNING) << "Dropping packet: no username";
     return;
   }
 
-  uint32 length =
-      std::min(static_cast<uint32>(username_attr->length()), USERNAME_LENGTH);
+  uint32_t length =
+      std::min(static_cast<uint32_t>(username_attr->length()), USERNAME_LENGTH);
   std::string username(username_attr->bytes(), length);
   // TODO: Check the HMAC.
 
   // The binding should already be present.
   BindingMap::iterator biter = bindings_.find(username);
   if (biter == bindings_.end()) {
     LOG(LS_WARNING) << "Dropping packet: no binding with username";
     return;
   }
 
@@ skipping 70 matching lines @@
   RelayServerBinding* binding;
 
   BindingMap::iterator biter = bindings_.find(username);
   if (biter != bindings_.end()) {
     binding = biter->second;
   } else {
     // NOTE: In the future, bindings will be created by the bot only.  This
     //       else-branch will then disappear.
 
     // Compute the appropriate lifetime for this binding.
-    uint32 lifetime = MAX_LIFETIME;
+    uint32_t lifetime = MAX_LIFETIME;
     const StunUInt32Attribute* lifetime_attr =
         request.GetUInt32(STUN_ATTR_LIFETIME);
     if (lifetime_attr)
       lifetime = std::min(lifetime, lifetime_attr->value() * 1000);
 
     binding = new RelayServerBinding(this, username, "0", lifetime);
     binding->SignalTimeout.connect(this, &RelayServer::OnTimeout);
     bindings_[username] = binding;
 
     if (log_bindings_) {
@@ skipping 154 matching lines @@
   bindings_.erase(iter);
 
   if (log_bindings_) {
     LOG(LS_INFO) << "Removed binding " << binding->username() << ", "
                  << bindings_.size() << " remaining";
   }
 }
 
 void RelayServer::OnMessage(rtc::Message *pmsg) {
 #if ENABLE_DEBUG
-  static const uint32 kMessageAcceptConnection = 1;
+  static const uint32_t kMessageAcceptConnection = 1;
   ASSERT(pmsg->message_id == kMessageAcceptConnection);
 #endif
   rtc::MessageData* data = pmsg->pdata;
   rtc::AsyncSocket* socket =
       static_cast <rtc::TypedMessageData<rtc::AsyncSocket*>*>
       (data)->data();
   AcceptConnection(socket);
   delete data;
 }
 
@@ skipping 65 matching lines @@
 
   StunAddressAttribute* addr_attr =
       StunAttribute::CreateAddress(STUN_ATTR_SOURCE_ADDRESS2);
   addr_attr->SetIP(from_addr.ipaddr());
   addr_attr->SetPort(from_addr.port());
   msg.AddAttribute(addr_attr);
 
   StunByteStringAttribute* data_attr =
       StunAttribute::CreateByteString(STUN_ATTR_DATA);
   ASSERT(size <= 65536);
-  data_attr->CopyBytes(data, uint16(size));
+  data_attr->CopyBytes(data, uint16_t(size));
   msg.AddAttribute(data_attr);
 
   SendStun(msg);
 }
 
 void RelayServerConnection::SendStun(const StunMessage& msg) {
   // Note that the binding has been used again.
   binding_->NoteUsed();
 
   cricket::SendStun(msg, socket_, addr_pair_.source());
@@ skipping 11 matching lines @@
 
 void RelayServerConnection::Lock() {
   locked_ = true;
 }
 
 void RelayServerConnection::Unlock() {
   locked_ = false;
 }
 
 // IDs used for posted messages:
-const uint32 MSG_LIFETIME_TIMER = 1;
+const uint32_t MSG_LIFETIME_TIMER = 1;
 
-RelayServerBinding::RelayServerBinding(
-    RelayServer* server, const std::string& username,
-    const std::string& password, uint32 lifetime)
-  : server_(server), username_(username), password_(password),
-    lifetime_(lifetime) {
+RelayServerBinding::RelayServerBinding(RelayServer* server,
+                                       const std::string& username,
+                                       const std::string& password,
+                                       uint32_t lifetime)
+    : server_(server),
+      username_(username),
+      password_(password),
+      lifetime_(lifetime) {
   // For now, every connection uses the standard magic cookie value.
   magic_cookie_.append(
       reinterpret_cast<const char*>(TURN_MAGIC_COOKIE_VALUE),
       sizeof(TURN_MAGIC_COOKIE_VALUE));
 
   // Initialize the last-used time to now.
   NoteUsed();
 
   // Set the first timeout check.
   server_->thread()->PostDelayed(lifetime_, this, MSG_LIFETIME_TIMER);
@@ skipping 69 matching lines @@
     } else {
       server_->thread()->PostDelayed(lifetime_, this, MSG_LIFETIME_TIMER);
     }
 
   } else {
     ASSERT(false);
   }
 }
 
 }  // namespace cricket