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

webrtc/base/virtualsocketserver.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 19 matching lines @@
 const in_addr kInitialNextIPv4 = { {0x01, 0, 0, 0} };
 #else
 // This value is entirely arbitrary, hence the lack of concern about endianness.
 const in_addr kInitialNextIPv4 = { 0x01000000 };
 #endif
 // Starts at ::2 so as to not cause confusion with ::1.
 const in6_addr kInitialNextIPv6 = { { {
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2
     } } };
 
-const uint16 kFirstEphemeralPort = 49152;
-const uint16 kLastEphemeralPort = 65535;
-const uint16 kEphemeralPortCount = kLastEphemeralPort - kFirstEphemeralPort + 1;
-const uint32 kDefaultNetworkCapacity = 64 * 1024;
-const uint32 kDefaultTcpBufferSize = 32 * 1024;
+const uint16_t kFirstEphemeralPort = 49152;
+const uint16_t kLastEphemeralPort = 65535;
+const uint16_t kEphemeralPortCount =
+    kLastEphemeralPort - kFirstEphemeralPort + 1;
+const uint32_t kDefaultNetworkCapacity = 64 * 1024;
+const uint32_t kDefaultTcpBufferSize = 32 * 1024;
 
-const uint32 UDP_HEADER_SIZE = 28;  // IP + UDP headers
-const uint32 TCP_HEADER_SIZE = 40;  // IP + TCP headers
-const uint32 TCP_MSS = 1400;  // Maximum segment size
+const uint32_t UDP_HEADER_SIZE = 28;  // IP + UDP headers
+const uint32_t TCP_HEADER_SIZE = 40;  // IP + TCP headers
+const uint32_t TCP_MSS = 1400;        // Maximum segment size
 
 // Note: The current algorithm doesn't work for sample sizes smaller than this.
 const int NUM_SAMPLES = 1000;
 
 enum {
   MSG_ID_PACKET,
   MSG_ID_ADDRESS_BOUND,
   MSG_ID_CONNECT,
   MSG_ID_DISCONNECT,
 };
@@ skipping 309 matching lines @@
   }
   *value = it->second;
   return 0;  // 0 is success to emulate getsockopt()
 }
 
 int VirtualSocket::SetOption(Option opt, int value) {
   options_map_[opt] = value;
   return 0;  // 0 is success to emulate setsockopt()
 }
 
-int VirtualSocket::EstimateMTU(uint16* mtu) {
+int VirtualSocket::EstimateMTU(uint16_t* mtu) {
   if (CS_CONNECTED != state_)
     return ENOTCONN;
   else
     return 65536;
 }
 
 void VirtualSocket::OnMessage(Message* pmsg) {
   if (pmsg->message_id == MSG_ID_PACKET) {
     // ASSERT(!local_addr_.IsAny());
     ASSERT(NULL != pmsg->pdata);
@@ skipping 136 matching lines @@
 }
 
 IPAddress VirtualSocketServer::GetNextIP(int family) {
   if (family == AF_INET) {
     IPAddress next_ip(next_ipv4_);
     next_ipv4_.s_addr =
         HostToNetwork32(NetworkToHost32(next_ipv4_.s_addr) + 1);
     return next_ip;
   } else if (family == AF_INET6) {
     IPAddress next_ip(next_ipv6_);
-    uint32* as_ints = reinterpret_cast<uint32*>(&next_ipv6_.s6_addr);
+    uint32_t* as_ints = reinterpret_cast<uint32_t*>(&next_ipv6_.s6_addr);
     as_ints[3] += 1;
     return next_ip;
   }
   return IPAddress();
 }
 
-uint16 VirtualSocketServer::GetNextPort() {
-  uint16 port = next_port_;
+uint16_t VirtualSocketServer::GetNextPort() {
+  uint16_t port = next_port_;
   if (next_port_ < kLastEphemeralPort) {
     ++next_port_;
   } else {
     next_port_ = kFirstEphemeralPort;
   }
   return port;
 }
 
 Socket* VirtualSocketServer::CreateSocket(int type) {
   return CreateSocket(AF_INET, type);
@@ skipping 41 matching lines @@
   while (!msg_queue_->empty()) {
     Message msg;
     if (msg_queue_->Get(&msg, Thread::kForever)) {
       msg_queue_->Dispatch(&msg);
     }
   }
   stop_on_idle_ = false;
   return !msg_queue_->IsQuitting();
 }
 
-void VirtualSocketServer::SetNextPortForTesting(uint16 port) {
+void VirtualSocketServer::SetNextPortForTesting(uint16_t port) {
   next_port_ = port;
 }
 
 bool VirtualSocketServer::CloseTcpConnections(
     const SocketAddress& addr_local,
     const SocketAddress& addr_remote) {
   VirtualSocket* socket = LookupConnection(addr_local, addr_remote);
   if (!socket) {
     return false;
   }
@@ skipping 108 matching lines @@
   connections_->erase(address_pair);
 }
 
 static double Random() {
   return static_cast<double>(rand()) / RAND_MAX;
 }
 
 int VirtualSocketServer::Connect(VirtualSocket* socket,
                                  const SocketAddress& remote_addr,
                                  bool use_delay) {
-  uint32 delay = use_delay ? GetRandomTransitDelay() : 0;
+  uint32_t delay = use_delay ? GetRandomTransitDelay() : 0;
   VirtualSocket* remote = LookupBinding(remote_addr);
   if (!CanInteractWith(socket, remote)) {
     LOG(LS_INFO) << "Address family mismatch between "
                  << socket->GetLocalAddress() << " and " << remote_addr;
     return -1;
   }
   if (remote != NULL) {
     SocketAddress addr = socket->GetLocalAddress();
     msg_queue_->PostDelayed(delay, remote, MSG_ID_CONNECT,
                             new MessageAddress(addr));
@@ skipping 38 matching lines @@
   }
 
   if (!CanInteractWith(socket, recipient)) {
     LOG(LS_VERBOSE) << "Incompatible address families: "
                     << socket->GetLocalAddress() << " and " << remote_addr;
     return -1;
   }
 
   CritScope cs(&socket->crit_);
 
-  uint32 cur_time = Time();
+  uint32_t cur_time = Time();
   PurgeNetworkPackets(socket, cur_time);
 
   // Determine whether we have enough bandwidth to accept this packet.  To do
   // this, we need to update the send queue.  Once we know it's current size,
   // we know whether we can fit this packet.
   //
   // NOTE: There are better algorithms for maintaining such a queue (such as
   // "Derivative Random Drop"); however, this algorithm is a more accurate
   // simulation of what a normal network would do.
 
@@ skipping 19 matching lines @@
   // Lookup the local/remote pair in the connections table.
   VirtualSocket* recipient = LookupConnection(socket->local_addr_,
                                               socket->remote_addr_);
   if (!recipient) {
     LOG(LS_VERBOSE) << "Sending data to no one.";
     return;
   }
 
   CritScope cs(&socket->crit_);
 
-  uint32 cur_time = Time();
+  uint32_t cur_time = Time();
   PurgeNetworkPackets(socket, cur_time);
 
   while (true) {
     size_t available = recv_buffer_capacity_ - recipient->recv_buffer_size_;
     size_t max_data_size =
         std::min<size_t>(available, TCP_MSS - TCP_HEADER_SIZE);
     size_t data_size = std::min(socket->send_buffer_.size(), max_data_size);
     if (0 == data_size)
       break;
 
@@ skipping 14 matching lines @@
 
   if (socket->write_enabled_
       && (socket->send_buffer_.size() < send_buffer_capacity_)) {
     socket->write_enabled_ = false;
     socket->SignalWriteEvent(socket);
   }
 }
 
 void VirtualSocketServer::AddPacketToNetwork(VirtualSocket* sender,
                                              VirtualSocket* recipient,
-                                             uint32 cur_time,
+                                             uint32_t cur_time,
                                              const char* data,
                                              size_t data_size,
                                              size_t header_size,
                                              bool ordered) {
   VirtualSocket::NetworkEntry entry;
   entry.size = data_size + header_size;
 
   sender->network_size_ += entry.size;
-  uint32 send_delay = SendDelay(static_cast<uint32>(sender->network_size_));
+  uint32_t send_delay = SendDelay(static_cast<uint32_t>(sender->network_size_));
   entry.done_time = cur_time + send_delay;
   sender->network_.push_back(entry);
 
   // Find the delay for crossing the many virtual hops of the network.
-  uint32 transit_delay = GetRandomTransitDelay();
+  uint32_t transit_delay = GetRandomTransitDelay();
 
   // When the incoming packet is from a binding of the any address, translate it
   // to the default route here such that the recipient will see the default
   // route.
   SocketAddress sender_addr = sender->local_addr_;
   IPAddress default_ip = GetDefaultRoute(sender_addr.ipaddr().family());
   if (sender_addr.IsAnyIP() && !IPIsUnspec(default_ip)) {
     sender_addr.SetIP(default_ip);
   }
 
   // Post the packet as a message to be delivered (on our own thread)
   Packet* p = new Packet(data, data_size, sender_addr);
 
-  uint32 ts = TimeAfter(send_delay + transit_delay);
+  uint32_t ts = TimeAfter(send_delay + transit_delay);
   if (ordered) {
     // Ensure that new packets arrive after previous ones
     // TODO: consider ordering on a per-socket basis, since this
     // introduces artifical delay.
     ts = TimeMax(ts, network_delay_);
   }
   msg_queue_->PostAt(ts, recipient, MSG_ID_PACKET, p);
   network_delay_ = TimeMax(ts, network_delay_);
 }
 
 void VirtualSocketServer::PurgeNetworkPackets(VirtualSocket* socket,
-                                              uint32 cur_time) {
+                                              uint32_t cur_time) {
   while (!socket->network_.empty() &&
          (socket->network_.front().done_time <= cur_time)) {
     ASSERT(socket->network_size_ >= socket->network_.front().size);
     socket->network_size_ -= socket->network_.front().size;
     socket->network_.pop_front();
   }
 }
 
-uint32 VirtualSocketServer::SendDelay(uint32 size) {
+uint32_t VirtualSocketServer::SendDelay(uint32_t size) {
   if (bandwidth_ == 0)
     return 0;
   else
     return 1000 * size / bandwidth_;
 }
 
 #if 0
 void PrintFunction(std::vector<std::pair<double, double> >* f) {
   return;
   double sum = 0;
-  for (uint32 i = 0; i < f->size(); ++i) {
+  for (uint32_t i = 0; i < f->size(); ++i) {
     std::cout << (*f)[i].first << '\t' << (*f)[i].second << std::endl;
     sum += (*f)[i].second;
   }
   if (!f->empty()) {
     const double mean = sum / f->size();
     double sum_sq_dev = 0;
-    for (uint32 i = 0; i < f->size(); ++i) {
+    for (uint32_t i = 0; i < f->size(); ++i) {
       double dev = (*f)[i].second - mean;
       sum_sq_dev += dev * dev;
     }
     std::cout << "Mean = " << mean << " StdDev = "
               << sqrt(sum_sq_dev / f->size()) << std::endl;
   }
 }
 #endif  // <unused>
 
 void VirtualSocketServer::UpdateDelayDistribution() {
@@ skipping 17 matching lines @@
 #if 0  // static unused gives a warning
 static double Pareto(double x, double min, double k) {
   if (x < min)
     return 0;
   else
     return k * std::pow(min, k) / std::pow(x, k+1);
 }
 #endif
 
 VirtualSocketServer::Function* VirtualSocketServer::CreateDistribution(
-    uint32 mean, uint32 stddev, uint32 samples) {
+    uint32_t mean,
+    uint32_t stddev,
+    uint32_t samples) {
   Function* f = new Function();
 
   if (0 == stddev) {
     f->push_back(Point(mean, 1.0));
   } else {
     double start = 0;
     if (mean >= 4 * static_cast<double>(stddev))
       start = mean - 4 * static_cast<double>(stddev);
     double end = mean + 4 * static_cast<double>(stddev);
 
-    for (uint32 i = 0; i < samples; i++) {
+    for (uint32_t i = 0; i < samples; i++) {
       double x = start + (end - start) * i / (samples - 1);
       double y = Normal(x, mean, stddev);
       f->push_back(Point(x, y));
     }
   }
   return Resample(Invert(Accumulate(f)), 0, 1, samples);
 }
 
-uint32 VirtualSocketServer::GetRandomTransitDelay() {
+uint32_t VirtualSocketServer::GetRandomTransitDelay() {
   size_t index = rand() % delay_dist_->size();
   double delay = (*delay_dist_)[index].second;
   //LOG_F(LS_INFO) << "random[" << index << "] = " << delay;
-  return static_cast<uint32>(delay);
+  return static_cast<uint32_t>(delay);
 }
 
 struct FunctionDomainCmp {
   bool operator()(const VirtualSocketServer::Point& p1,
                    const VirtualSocketServer::Point& p2) {
     return p1.first < p2.first;
   }
   bool operator()(double v1, const VirtualSocketServer::Point& p2) {
     return v1 < p2.first;
   }
@@ skipping 16 matching lines @@
 }
 
 VirtualSocketServer::Function* VirtualSocketServer::Invert(Function* f) {
   for (Function::size_type i = 0; i < f->size(); ++i)
     std::swap((*f)[i].first, (*f)[i].second);
 
   std::sort(f->begin(), f->end(), FunctionDomainCmp());
   return f;
 }
 
-VirtualSocketServer::Function* VirtualSocketServer::Resample(
-    Function* f, double x1, double x2, uint32 samples) {
+VirtualSocketServer::Function* VirtualSocketServer::Resample(Function* f,
+                                                             double x1,
+                                                             double x2,
+                                                             uint32_t samples) {
   Function* g = new Function();
 
   for (size_t i = 0; i < samples; i++) {
     double x = x1 + (x2 - x1) * i / (samples - 1);
     double y = Evaluate(f, x);
     g->push_back(Point(x, y));
   }
 
   delete f;
   return g;
@@ skipping 71 matching lines @@
 void VirtualSocketServer::SetDefaultRoute(const IPAddress& from_addr) {
   RTC_DCHECK(!IPIsAny(from_addr));
   if (from_addr.family() == AF_INET) {
     default_route_v4_ = from_addr;
   } else if (from_addr.family() == AF_INET6) {
     default_route_v6_ = from_addr;
   }
 }
 
 }  // namespace rtc