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

webrtc/base/physicalsocketserver.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 50 matching lines @@
 #endif  // WEBRTC_POSIX
 
 #if defined(WEBRTC_WIN)
 typedef char* SockOptArg;
 #endif
 
 namespace rtc {
 
 #if defined(WEBRTC_WIN)
 // Standard MTUs, from RFC 1191
-const uint16 PACKET_MAXIMUMS[] = {
-  65535,    // Theoretical maximum, Hyperchannel
-  32000,    // Nothing
-  17914,    // 16Mb IBM Token Ring
-  8166,     // IEEE 802.4
-  //4464,   // IEEE 802.5 (4Mb max)
-  4352,     // FDDI
-  //2048,   // Wideband Network
-  2002,     // IEEE 802.5 (4Mb recommended)
-  //1536,   // Expermental Ethernet Networks
-  //1500,   // Ethernet, Point-to-Point (default)
-  1492,     // IEEE 802.3
-  1006,     // SLIP, ARPANET
-  //576,    // X.25 Networks
-  //544,    // DEC IP Portal
-  //512,    // NETBIOS
-  508,      // IEEE 802/Source-Rt Bridge, ARCNET
-  296,      // Point-to-Point (low delay)
-  68,       // Official minimum
-  0,        // End of list marker
+const uint16_t PACKET_MAXIMUMS[] = {
+    65535,  // Theoretical maximum, Hyperchannel
+    32000,  // Nothing
+    17914,  // 16Mb IBM Token Ring
+    8166,   // IEEE 802.4
+    // 4464,   // IEEE 802.5 (4Mb max)
+    4352,   // FDDI
+    // 2048,   // Wideband Network
+    2002,   // IEEE 802.5 (4Mb recommended)
+    // 1536,   // Expermental Ethernet Networks
+    // 1500,   // Ethernet, Point-to-Point (default)
+    1492,   // IEEE 802.3
+    1006,   // SLIP, ARPANET
+    // 576,    // X.25 Networks
+    // 544,    // DEC IP Portal
+    // 512,    // NETBIOS
+    508,    // IEEE 802/Source-Rt Bridge, ARCNET
+    296,    // Point-to-Point (low delay)
+    68,     // Official minimum
+    0,      // End of list marker
 };
 
 static const int IP_HEADER_SIZE = 20u;
 static const int IPV6_HEADER_SIZE = 40u;
 static const int ICMP_HEADER_SIZE = 8u;
 static const int ICMP_PING_TIMEOUT_MILLIS = 10000u;
 #endif
 
 class PhysicalSocket : public AsyncSocket, public sigslot::has_slots<> {
  public:
@@ skipping 290 matching lines @@
     s_ = INVALID_SOCKET;
     state_ = CS_CLOSED;
     enabled_events_ = 0;
     if (resolver_) {
       resolver_->Destroy(false);
       resolver_ = NULL;
     }
     return err;
   }
 
-  int EstimateMTU(uint16* mtu) override {
+  int EstimateMTU(uint16_t* mtu) override {
     SocketAddress addr = GetRemoteAddress();
     if (addr.IsAny()) {
       SetError(ENOTCONN);
       return -1;
     }
 
 #if defined(WEBRTC_WIN)
     // Gets the interface MTU (TTL=1) for the interface used to reach |addr|.
     WinPing ping;
     if (!ping.IsValid()) {
       SetError(EINVAL);  // can't think of a better error ID
       return -1;
     }
     int header_size = ICMP_HEADER_SIZE;
     if (addr.family() == AF_INET6) {
       header_size += IPV6_HEADER_SIZE;
     } else if (addr.family() == AF_INET) {
       header_size += IP_HEADER_SIZE;
     }
 
     for (int level = 0; PACKET_MAXIMUMS[level + 1] > 0; ++level) {
-      int32 size = PACKET_MAXIMUMS[level] - header_size;
+      int32_t size = PACKET_MAXIMUMS[level] - header_size;
       WinPing::PingResult result = ping.Ping(addr.ipaddr(), size,
                                              ICMP_PING_TIMEOUT_MILLIS,
                                              1, false);
       if (result == WinPing::PING_FAIL) {
         SetError(EINVAL);  // can't think of a better error ID
         return -1;
       } else if (result != WinPing::PING_TOO_LARGE) {
         *mtu = PACKET_MAXIMUMS[level];
         return 0;
       }
@@ skipping 100 matching lines @@
         return -1;  // No logging is necessary as this not a OS socket option.
       default:
         ASSERT(false);
         return -1;
     }
     return 0;
   }
 
   PhysicalSocketServer* ss_;
   SOCKET s_;
-  uint8 enabled_events_;
+  uint8_t enabled_events_;
   bool udp_;
   int error_;
   // Protects |error_| that is accessed from different threads.
   mutable CriticalSection crit_;
   ConnState state_;
   AsyncResolver* resolver_;
 
 #ifdef _DEBUG
   std::string dbg_addr_;
 #endif  // _DEBUG;
@@ skipping 10 matching lines @@
 
   ~EventDispatcher() override {
     ss_->Remove(this);
     close(afd_[0]);
     close(afd_[1]);
   }
 
   virtual void Signal() {
     CritScope cs(&crit_);
     if (!fSignaled_) {
-      const uint8 b[1] = { 0 };
+      const uint8_t b[1] = {0};
       if (VERIFY(1 == write(afd_[1], b, sizeof(b)))) {
         fSignaled_ = true;
       }
     }
   }
 
-  uint32 GetRequestedEvents() override { return DE_READ; }
+  uint32_t GetRequestedEvents() override { return DE_READ; }
 
-  void OnPreEvent(uint32 ff) override {
+  void OnPreEvent(uint32_t ff) override {
     // It is not possible to perfectly emulate an auto-resetting event with
     // pipes.  This simulates it by resetting before the event is handled.
 
     CritScope cs(&crit_);
     if (fSignaled_) {
-      uint8 b[4];  // Allow for reading more than 1 byte, but expect 1.
+      uint8_t b[4];  // Allow for reading more than 1 byte, but expect 1.
       VERIFY(1 == read(afd_[0], b, sizeof(b)));
       fSignaled_ = false;
     }
   }
 
-  void OnEvent(uint32 ff, int err) override { ASSERT(false); }
+  void OnEvent(uint32_t ff, int err) override { ASSERT(false); }
 
   int GetDescriptor() override { return afd_[0]; }
 
   bool IsDescriptorClosed() override { return false; }
 
  private:
   PhysicalSocketServer *ss_;
   int afd_[2];
   bool fSignaled_;
   CriticalSection crit_;
@@ skipping 47 matching lines @@
   // user-level state of the process, since the handler could be executed at any
   // time on any thread.
   void OnPosixSignalReceived(int signum) {
     if (signum >= ARRAY_SIZE(received_signal_)) {
       // We don't have space in our array for this.
       return;
     }
     // Set a flag saying we've seen this signal.
     received_signal_[signum] = true;
     // Notify application code that we got a signal.
-    const uint8 b[1] = { 0 };
+    const uint8_t b[1] = {0};
     if (-1 == write(afd_[1], b, sizeof(b))) {
       // Nothing we can do here. If there's an error somehow then there's
       // nothing we can safely do from a signal handler.
       // No, we can't even safely log it.
       // But, we still have to check the return value here. Otherwise,
       // GCC 4.4.1 complains ignoring return value. Even (void) doesn't help.
       return;
     }
   }
 
@@ skipping 36 matching lines @@
   // These are boolean flags that will be set in our signal handler and read
   // and cleared from Wait(). There is a race involved in this, but it is
   // benign. The signal handler sets the flag before signaling the pipe, so
   // we'll never end up blocking in select() while a flag is still true.
   // However, if two of the same signal arrive close to each other then it's
   // possible that the second time the handler may set the flag while it's still
   // true, meaning that signal will be missed. But the first occurrence of it
   // will still be handled, so this isn't a problem.
   // Volatile is not necessary here for correctness, but this data _is_ volatile
   // so I've marked it as such.
-  volatile uint8 received_signal_[kNumPosixSignals];
+  volatile uint8_t received_signal_[kNumPosixSignals];
 };
 
 class PosixSignalDispatcher : public Dispatcher {
  public:
   PosixSignalDispatcher(PhysicalSocketServer *owner) : owner_(owner) {
     owner_->Add(this);
   }
 
   ~PosixSignalDispatcher() override {
     owner_->Remove(this);
   }
 
-  uint32 GetRequestedEvents() override { return DE_READ; }
+  uint32_t GetRequestedEvents() override { return DE_READ; }
 
-  void OnPreEvent(uint32 ff) override {
+  void OnPreEvent(uint32_t ff) override {
     // Events might get grouped if signals come very fast, so we read out up to
     // 16 bytes to make sure we keep the pipe empty.
-    uint8 b[16];
+    uint8_t b[16];
     ssize_t ret = read(GetDescriptor(), b, sizeof(b));
     if (ret < 0) {
       LOG_ERR(LS_WARNING) << "Error in read()";
     } else if (ret == 0) {
       LOG(LS_WARNING) << "Should have read at least one byte";
     }
   }
 
-  void OnEvent(uint32 ff, int err) override {
+  void OnEvent(uint32_t ff, int err) override {
     for (int signum = 0; signum < PosixSignalHandler::kNumPosixSignals;
          ++signum) {
       if (PosixSignalHandler::Instance()->IsSignalSet(signum)) {
         PosixSignalHandler::Instance()->ClearSignal(signum);
         HandlerMap::iterator i = handlers_.find(signum);
         if (i == handlers_.end()) {
           // This can happen if a signal is delivered to our process at around
           // the same time as we unset our handler for it. It is not an error
           // condition, but it's unusual enough to be worth logging.
           LOG(LS_INFO) << "Received signal with no handler: " << signum;
@@ skipping 90 matching lines @@
           // it's not necessary a problem if we spuriously interpret a
           // "connection lost"-type error as a blocking error, because typically
           // the next recv() will get EOF, so we'll still eventually notice that
           // the socket is closed.
           LOG_ERR(LS_WARNING) << "Assuming benign blocking error";
           return false;
       }
     }
   }
 
-  uint32 GetRequestedEvents() override { return enabled_events_; }
+  uint32_t GetRequestedEvents() override { return enabled_events_; }
 
-  void OnPreEvent(uint32 ff) override {
+  void OnPreEvent(uint32_t ff) override {
     if ((ff & DE_CONNECT) != 0)
       state_ = CS_CONNECTED;
     if ((ff & DE_CLOSE) != 0)
       state_ = CS_CLOSED;
   }
 
-  void OnEvent(uint32 ff, int err) override {
+  void OnEvent(uint32_t ff, int err) override {
     // Make sure we deliver connect/accept first. Otherwise, consumers may see
     // something like a READ followed by a CONNECT, which would be odd.
     if ((ff & DE_CONNECT) != 0) {
       enabled_events_ &= ~DE_CONNECT;
       SignalConnectEvent(this);
     }
     if ((ff & DE_ACCEPT) != 0) {
       enabled_events_ &= ~DE_ACCEPT;
       SignalReadEvent(this);
     }
@@ skipping 34 matching lines @@
   ~FileDispatcher() override {
     ss_->Remove(this);
   }
 
   SocketServer* socketserver() { return ss_; }
 
   int GetDescriptor() override { return fd_; }
 
   bool IsDescriptorClosed() override { return false; }
 
-  uint32 GetRequestedEvents() override { return flags_; }
+  uint32_t GetRequestedEvents() override { return flags_; }
 
-  void OnPreEvent(uint32 ff) override {}
+  void OnPreEvent(uint32_t ff) override {}
 
-  void OnEvent(uint32 ff, int err) override {
+  void OnEvent(uint32_t ff, int err) override {
     if ((ff & DE_READ) != 0)
       SignalReadEvent(this);
     if ((ff & DE_WRITE) != 0)
       SignalWriteEvent(this);
     if ((ff & DE_CLOSE) != 0)
       SignalCloseEvent(this, err);
   }
 
   bool readable() override { return (flags_ & DE_READ) != 0; }
 
@@ skipping 13 matching lines @@
   int flags_;
 };
 
 AsyncFile* PhysicalSocketServer::CreateFile(int fd) {
   return new FileDispatcher(fd, this);
 }
 
 #endif // WEBRTC_POSIX
 
 #if defined(WEBRTC_WIN)
-static uint32 FlagsToEvents(uint32 events) {
-  uint32 ffFD = FD_CLOSE;
+static uint32_t FlagsToEvents(uint32_t events) {
+  uint32_t ffFD = FD_CLOSE;
   if (events & DE_READ)
     ffFD |= FD_READ;
   if (events & DE_WRITE)
     ffFD |= FD_WRITE;
   if (events & DE_CONNECT)
     ffFD |= FD_CONNECT;
   if (events & DE_ACCEPT)
     ffFD |= FD_ACCEPT;
   return ffFD;
 }
@@ skipping 13 matching lines @@
       WSACloseEvent(hev_);
       hev_ = NULL;
     }
   }
 
   virtual void Signal() {
     if (hev_ != NULL)
       WSASetEvent(hev_);
   }
 
-  virtual uint32 GetRequestedEvents() {
-    return 0;
-  }
+  virtual uint32_t GetRequestedEvents() { return 0; }
 
-  virtual void OnPreEvent(uint32 ff) {
-    WSAResetEvent(hev_);
-  }
+  virtual void OnPreEvent(uint32_t ff) { WSAResetEvent(hev_); }
 
-  virtual void OnEvent(uint32 ff, int err) {
-  }
+  virtual void OnEvent(uint32_t ff, int err) {}
 
   virtual WSAEVENT GetWSAEvent() {
     return hev_;
   }
 
   virtual SOCKET GetSocket() {
     return INVALID_SOCKET;
   }
 
   virtual bool CheckSignalClose() { return false; }
@@ skipping 54 matching lines @@
   virtual int Close() {
     if (s_ == INVALID_SOCKET)
       return 0;
 
     id_ = 0;
     signal_close_ = false;
     ss_->Remove(this);
     return PhysicalSocket::Close();
   }
 
-  virtual uint32 GetRequestedEvents() {
-    return enabled_events_;
-  }
+  virtual uint32_t GetRequestedEvents() { return enabled_events_; }
 
-  virtual void OnPreEvent(uint32 ff) {
+  virtual void OnPreEvent(uint32_t ff) {
     if ((ff & DE_CONNECT) != 0)
       state_ = CS_CONNECTED;
     // We set CS_CLOSED from CheckSignalClose.
   }
 
-  virtual void OnEvent(uint32 ff, int err) {
+  virtual void OnEvent(uint32_t ff, int err) {
     int cache_id = id_;
     // Make sure we deliver connect/accept first. Otherwise, consumers may see
     // something like a READ followed by a CONNECT, which would be odd.
     if (((ff & DE_CONNECT) != 0) && (id_ == cache_id)) {
       if (ff != DE_CONNECT)
         LOG(LS_VERBOSE) << "Signalled with DE_CONNECT: " << ff;
       enabled_events_ &= ~DE_CONNECT;
 #ifdef _DEBUG
       dbg_addr_ = "Connected @ ";
       dbg_addr_.append(GetRemoteAddress().ToString());
@@ skipping 46 matching lines @@
 #endif  // WEBRTC_WIN 
 
 // Sets the value of a boolean value to false when signaled.
 class Signaler : public EventDispatcher {
  public:
   Signaler(PhysicalSocketServer* ss, bool* pf)
       : EventDispatcher(ss), pf_(pf) {
   }
   ~Signaler() override { }
 
-  void OnEvent(uint32 ff, int err) override {
+  void OnEvent(uint32_t ff, int err) override {
     if (pf_)
       *pf_ = false;
   }
 
  private:
   bool *pf_;
 };
 
 PhysicalSocketServer::PhysicalSocketServer()
     : fWait_(false) {
@@ skipping 137 matching lines @@
       for (size_t i = 0; i < dispatchers_.size(); ++i) {
         // Query dispatchers for read and write wait state
         Dispatcher *pdispatcher = dispatchers_[i];
         ASSERT(pdispatcher);
         if (!process_io && (pdispatcher != signal_wakeup_))
           continue;
         int fd = pdispatcher->GetDescriptor();
         if (fd > fdmax)
           fdmax = fd;
 
-        uint32 ff = pdispatcher->GetRequestedEvents();
+        uint32_t ff = pdispatcher->GetRequestedEvents();
         if (ff & (DE_READ | DE_ACCEPT))
           FD_SET(fd, &fdsRead);
         if (ff & (DE_WRITE | DE_CONNECT))
           FD_SET(fd, &fdsWrite);
       }
     }
 
     // Wait then call handlers as appropriate
     // < 0 means error
     // 0 means timeout
@@ skipping 12 matching lines @@
       // iteration.
     } else if (n == 0) {
       // If timeout, return success
       return true;
     } else {
       // We have signaled descriptors
       CritScope cr(&crit_);
       for (size_t i = 0; i < dispatchers_.size(); ++i) {
         Dispatcher *pdispatcher = dispatchers_[i];
         int fd = pdispatcher->GetDescriptor();
-        uint32 ff = 0;
+        uint32_t ff = 0;
         int errcode = 0;
 
         // Reap any error code, which can be signaled through reads or writes.
         // TODO: Should we set errcode if getsockopt fails?
         if (FD_ISSET(fd, &fdsRead) || FD_ISSET(fd, &fdsWrite)) {
           socklen_t len = sizeof(errcode);
           ::getsockopt(fd, SOL_SOCKET, SO_ERROR, &errcode, &len);
         }
 
         // Check readable descriptors. If we're waiting on an accept, signal
@@ skipping 113 matching lines @@
     return false;
   }
   return true;
 }
 #endif  // WEBRTC_POSIX
 
 #if defined(WEBRTC_WIN)
 bool PhysicalSocketServer::Wait(int cmsWait, bool process_io) {
   int cmsTotal = cmsWait;
   int cmsElapsed = 0;
-  uint32 msStart = Time();
+  uint32_t msStart = Time();
 
   fWait_ = true;
   while (fWait_) {
     std::vector<WSAEVENT> events;
     std::vector<Dispatcher *> event_owners;
 
     events.push_back(socket_ev_);
 
     {
       CritScope cr(&crit_);
@@ skipping 90 matching lines @@
                 LOG(WARNING) << "PhysicalSocketServer got FD_ACCEPT_BIT error "
                              << wsaEvents.iErrorCode[FD_ACCEPT_BIT];
               }
               if ((wsaEvents.lNetworkEvents & FD_CLOSE) &&
                   wsaEvents.iErrorCode[FD_CLOSE_BIT] != 0) {
                 LOG(WARNING) << "PhysicalSocketServer got FD_CLOSE_BIT error "
                              << wsaEvents.iErrorCode[FD_CLOSE_BIT];
               }
             }
 #endif
-            uint32 ff = 0;
+            uint32_t ff = 0;
             int errcode = 0;
             if (wsaEvents.lNetworkEvents & FD_READ)
               ff |= DE_READ;
             if (wsaEvents.lNetworkEvents & FD_WRITE)
               ff |= DE_WRITE;
             if (wsaEvents.lNetworkEvents & FD_CONNECT) {
               if (wsaEvents.iErrorCode[FD_CONNECT_BIT] == 0) {
                 ff |= DE_CONNECT;
               } else {
                 ff |= DE_CLOSE;
@@ skipping 30 matching lines @@
        break;
     }
   }
 
   // Done
   return true;
 }
 #endif  // WEBRTC_WIN 
 
 }  // namespace rtc