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

webrtc/p2p/client/basicportallocator.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 41 matching lines @@
 const int SHAKE_MAX_DELAY = 90 * 1000;  // 90 seconds
 
 int ShakeDelay() {
   int range = SHAKE_MAX_DELAY - SHAKE_MIN_DELAY + 1;
   return SHAKE_MIN_DELAY + CreateRandomId() % range;
 }
 
 }  // namespace
 
 namespace cricket {
-const uint32 DISABLE_ALL_PHASES =
+const uint32_t DISABLE_ALL_PHASES =
     PORTALLOCATOR_DISABLE_UDP | PORTALLOCATOR_DISABLE_TCP |
     PORTALLOCATOR_DISABLE_STUN | PORTALLOCATOR_DISABLE_RELAY;
 
 // BasicPortAllocator
 BasicPortAllocator::BasicPortAllocator(
     rtc::NetworkManager* network_manager,
     rtc::PacketSocketFactory* socket_factory)
     : network_manager_(network_manager),
       socket_factory_(socket_factory),
       stun_servers_() {
@@ skipping 77 matching lines @@
   allocator_->network_manager()->SignalNetworksChanged.connect(
       this, &BasicPortAllocatorSession::OnNetworksChanged);
   allocator_->network_manager()->StartUpdating();
 }
 
 BasicPortAllocatorSession::~BasicPortAllocatorSession() {
   allocator_->network_manager()->StopUpdating();
   if (network_thread_ != NULL)
     network_thread_->Clear(this);
 
-  for (uint32 i = 0; i < sequences_.size(); ++i) {
+  for (uint32_t i = 0; i < sequences_.size(); ++i) {
     // AllocationSequence should clear it's map entry for turn ports before
     // ports are destroyed.
     sequences_[i]->Clear();
   }
 
   std::vector<PortData>::iterator it;
   for (it = ports_.begin(); it != ports_.end(); it++)
     delete it->port();
 
-  for (uint32 i = 0; i < configs_.size(); ++i)
+  for (uint32_t i = 0; i < configs_.size(); ++i)
     delete configs_[i];
 
-  for (uint32 i = 0; i < sequences_.size(); ++i)
+  for (uint32_t i = 0; i < sequences_.size(); ++i)
     delete sequences_[i];
 }
 
 void BasicPortAllocatorSession::StartGettingPorts() {
   network_thread_ = rtc::Thread::Current();
   if (!socket_factory_) {
     owned_socket_factory_.reset(
         new rtc::BasicPacketSocketFactory(network_thread_));
     socket_factory_ = owned_socket_factory_.get();
   }
 
   running_ = true;
   network_thread_->Post(this, MSG_CONFIG_START);
 
   if (flags() & PORTALLOCATOR_ENABLE_SHAKER)
     network_thread_->PostDelayed(ShakeDelay(), this, MSG_SHAKE);
 }
 
 void BasicPortAllocatorSession::StopGettingPorts() {
   ASSERT(rtc::Thread::Current() == network_thread_);
   running_ = false;
   network_thread_->Clear(this, MSG_ALLOCATE);
-  for (uint32 i = 0; i < sequences_.size(); ++i)
+  for (uint32_t i = 0; i < sequences_.size(); ++i)
     sequences_[i]->Stop();
   network_thread_->Post(this, MSG_CONFIG_STOP);
 }
 
 void BasicPortAllocatorSession::OnMessage(rtc::Message *message) {
   switch (message->message_id) {
   case MSG_CONFIG_START:
     ASSERT(rtc::Thread::Current() == network_thread_);
     GetPortConfigurations();
     break;
@@ skipping 110 matching lines @@
   // during stun process.
   if (flags() & PORTALLOCATOR_DISABLE_ADAPTER_ENUMERATION) {
     allocator_->network_manager()->GetAnyAddressNetworks(&networks);
   } else {
     allocator_->network_manager()->GetNetworks(&networks);
   }
   if (networks.empty()) {
     LOG(LS_WARNING) << "Machine has no networks; no ports will be allocated";
     done_signal_needed = true;
   } else {
-    for (uint32 i = 0; i < networks.size(); ++i) {
+    for (uint32_t i = 0; i < networks.size(); ++i) {
       PortConfiguration* config = NULL;
       if (configs_.size() > 0)
         config = configs_.back();
 
-      uint32 sequence_flags = flags();
+      uint32_t sequence_flags = flags();
       if ((sequence_flags & DISABLE_ALL_PHASES) == DISABLE_ALL_PHASES) {
         // If all the ports are disabled we should just fire the allocation
         // done event and return.
         done_signal_needed = true;
         break;
       }
 
       if (!config || config->relays.empty()) {
         // No relay ports specified in this config.
         sequence_flags |= PORTALLOCATOR_DISABLE_RELAY;
@@ skipping 33 matching lines @@
   }
 }
 
 void BasicPortAllocatorSession::OnNetworksChanged() {
   network_manager_started_ = true;
   if (allocation_started_)
     DoAllocate();
 }
 
 void BasicPortAllocatorSession::DisableEquivalentPhases(
-    rtc::Network* network, PortConfiguration* config, uint32* flags) {
-  for (uint32 i = 0; i < sequences_.size() &&
-      (*flags & DISABLE_ALL_PHASES) != DISABLE_ALL_PHASES; ++i) {
+    rtc::Network* network,
+    PortConfiguration* config,
+    uint32_t* flags) {
+  for (uint32_t i = 0; i < sequences_.size() &&
+                           (*flags & DISABLE_ALL_PHASES) != DISABLE_ALL_PHASES;
+       ++i) {
     sequences_[i]->DisableEquivalentPhases(network, config, flags);
   }
 }
 
 void BasicPortAllocatorSession::AddAllocatedPort(Port* port,
                                                  AllocationSequence * seq,
                                                  bool prepare_address) {
   if (!port)
     return;
 
   LOG(LS_INFO) << "Adding allocated port for " << content_name();
   port->set_content_name(content_name());
   port->set_component(component_);
   port->set_generation(generation());
   if (allocator_->proxy().type != rtc::PROXY_NONE)
     port->set_proxy(allocator_->user_agent(), allocator_->proxy());
   port->set_send_retransmit_count_attribute((allocator_->flags() &
       PORTALLOCATOR_ENABLE_STUN_RETRANSMIT_ATTRIBUTE) != 0);
 
   // Push down the candidate_filter to individual port.
-  uint32 candidate_filter = allocator_->candidate_filter();
+  uint32_t candidate_filter = allocator_->candidate_filter();
 
   // When adapter enumeration is disabled, disable CF_HOST at port level so
   // local address is not leaked by stunport in the candidate's related address.
   if (flags() & PORTALLOCATOR_DISABLE_ADAPTER_ENUMERATION) {
     candidate_filter &= ~CF_HOST;
   }
   port->set_candidate_filter(candidate_filter);
 
   PortData data(port, seq);
   ports_.push_back(data);
@@ skipping 110 matching lines @@
       }
     }
   }
 
   if (!candidates.empty()) {
     SignalCandidatesReady(this, candidates);
   }
 }
 
 bool BasicPortAllocatorSession::CheckCandidateFilter(const Candidate& c) {
-  uint32 filter = allocator_->candidate_filter();
+  uint32_t filter = allocator_->candidate_filter();
 
   // When binding to any address, before sending packets out, the getsockname
   // returns all 0s, but after sending packets, it'll be the NIC used to
   // send. All 0s is not a valid ICE candidate address and should be filtered
   // out.
   if (c.address().IsAnyIP()) {
     return false;
   }
 
   if (c.type() == RELAY_PORT_TYPE) {
@@ skipping 121 matching lines @@
     }
   }
   return NULL;
 }
 
 // AllocationSequence
 
 AllocationSequence::AllocationSequence(BasicPortAllocatorSession* session,
                                        rtc::Network* network,
                                        PortConfiguration* config,
-                                       uint32 flags)
+                                       uint32_t flags)
     : session_(session),
       network_(network),
       ip_(network->GetBestIP()),
       config_(config),
       state_(kInit),
       flags_(flags),
       udp_socket_(),
       udp_port_(NULL),
       phase_(0) {
 }
@@ skipping 16 matching lines @@
 void AllocationSequence::Clear() {
   udp_port_ = NULL;
   turn_ports_.clear();
 }
 
 AllocationSequence::~AllocationSequence() {
   session_->network_thread()->Clear(this);
 }
 
 void AllocationSequence::DisableEquivalentPhases(rtc::Network* network,
-    PortConfiguration* config, uint32* flags) {
+                                                 PortConfiguration* config,
+                                                 uint32_t* flags) {
   if (!((network == network_) && (ip_ == network->GetBestIP()))) {
     // Different network setup; nothing is equivalent.
     return;
   }
 
   // Else turn off the stuff that we've already got covered.
 
   // Every config implicitly specifies local, so turn that off right away.
   *flags |= PORTALLOCATOR_DISABLE_UDP;
   *flags |= PORTALLOCATOR_DISABLE_TCP;
@@ skipping 410 matching lines @@
   ServerAddresses servers;
   for (size_t i = 0; i < relays.size(); ++i) {
     if (relays[i].type == turn_type && SupportsProtocol(relays[i], type)) {
       servers.insert(relays[i].ports.front().address);
     }
   }
   return servers;
 }
 
 }  // namespace cricket