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

webrtc/p2p/stunprober/stunprober.cc

 /*
  *  Copyright 2015 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 26 matching lines @@
 
 }  // namespace
 
 // A requester tracks the requests and responses from a single socket to many
 // STUN servers
 class StunProber::Requester : public sigslot::has_slots<> {
  public:
   // Each Request maps to a request and response.
   struct Request {
     // Actual time the STUN bind request was sent.
-    int64 sent_time_ms = 0;
+    int64_t sent_time_ms = 0;
     // Time the response was received.
-    int64 received_time_ms = 0;
+    int64_t received_time_ms = 0;
 
     // Server reflexive address from STUN response for this given request.
     rtc::SocketAddress srflx_addr;
 
     rtc::IPAddress server_addr;
 
-    int64 rtt() { return received_time_ms - sent_time_ms; }
+    int64_t rtt() { return received_time_ms - sent_time_ms; }
     void ProcessResponse(const char* buf, size_t buf_len);
   };
 
   // StunProber provides |server_ips| for Requester to probe. For shared
   // socket mode, it'll be all the resolved IP addresses. For non-shared mode,
   // it'll just be a single address.
   Requester(StunProber* prober,
             rtc::AsyncPacketSocket* socket,
             const std::vector<rtc::SocketAddress>& server_ips);
   virtual ~Requester();
@@ skipping 23 matching lines @@
 
   // The socket for this session.
   rtc::scoped_ptr<rtc::AsyncPacketSocket> socket_;
 
   // Temporary SocketAddress and buffer for RecvFrom.
   rtc::SocketAddress addr_;
   rtc::scoped_ptr<rtc::ByteBuffer> response_packet_;
 
   std::vector<Request*> requests_;
   std::vector<rtc::SocketAddress> server_ips_;
-  int16 num_request_sent_ = 0;
-  int16 num_response_received_ = 0;
+  int16_t num_request_sent_ = 0;
+  int16_t num_response_received_ = 0;
 
   rtc::ThreadChecker& thread_checker_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(Requester);
 };
 
 StunProber::Requester::Requester(
     StunProber* prober,
     rtc::AsyncPacketSocket* socket,
     const std::vector<rtc::SocketAddress>& server_ips)
@@ skipping 50 matching lines @@
   }
 
   request.sent_time_ms = rtc::Time();
 
   num_request_sent_++;
   RTC_DCHECK(static_cast<size_t>(num_request_sent_) <= server_ips_.size());
 }
 
 void StunProber::Requester::Request::ProcessResponse(const char* buf,
                                                      size_t buf_len) {
-  int64 now = rtc::Time();
+  int64_t now = rtc::Time();
   rtc::ByteBuffer message(buf, buf_len);
   cricket::StunMessage stun_response;
   if (!stun_response.Read(&message)) {
     // Invalid or incomplete STUN packet.
     received_time_ms = 0;
     return;
   }
 
   // Get external address of the socket.
   const cricket::StunAddressAttribute* addr_attr =
@@ skipping 186 matching lines @@
   if (!current_requester_) {
     return false;
   }
   current_requester_->SendStunRequest();
   num_request_sent_++;
   return true;
 }
 
 void StunProber::MaybeScheduleStunRequests() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  uint32 now = rtc::Time();
+  uint32_t now = rtc::Time();
 
   if (Done()) {
     invoker_.AsyncInvokeDelayed<void>(
         thread_, rtc::Bind(&StunProber::End, this, SUCCESS), timeout_ms_);
     return;
   }
   if ((now + (thread_wake_up_interval_ms / 2)) >= next_request_time_ms_) {
     if (!SendNextRequest()) {
       End(GENERIC_FAILURE);
       return;
     }
     next_request_time_ms_ = now + interval_ms_;
   }
   invoker_.AsyncInvokeDelayed<void>(
       thread_, rtc::Bind(&StunProber::MaybeScheduleStunRequests, this),
       thread_wake_up_interval_ms /* ms */);
 }
 
 bool StunProber::GetStats(StunProber::Stats* prob_stats) const {
   // No need to be on the same thread.
   if (!prob_stats) {
     return false;
   }
 
   StunProber::Stats stats;
 
   int rtt_sum = 0;
-  int64 first_sent_time = 0;
-  int64 last_sent_time = 0;
+  int64_t first_sent_time = 0;
+  int64_t last_sent_time = 0;
   NatType nat_type = NATTYPE_INVALID;
 
   // Track of how many srflx IP that we have seen.
   std::set<rtc::IPAddress> srflx_ips;
 
   // If we're not receiving any response on a given IP, all requests sent to
   // that IP should be ignored as this could just be an DNS error.
   std::map<rtc::IPAddress, int> num_response_per_server;
   std::map<rtc::IPAddress, int> num_request_per_server;
 
@@ skipping 106 matching lines @@
   if (!finished_callback_.empty()) {
     AsyncCallback callback = finished_callback_;
     finished_callback_ = AsyncCallback();
 
     // Callback at the last since the prober might be deleted in the callback.
     callback(this, status);
   }
 }
 
 }  // namespace stunprober