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

webrtc/p2p/client/basicportallocator.h

 /*
  *  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 152 matching lines @@
   };
 
   void OnConfigReady(PortConfiguration* config);
   void OnConfigStop();
   void AllocatePorts();
   void OnAllocate();
   void DoAllocate();
   void OnNetworksChanged();
   void OnAllocationSequenceObjectsCreated();
   void DisableEquivalentPhases(rtc::Network* network,
-                               PortConfiguration* config, uint32* flags);
+                               PortConfiguration* config,
+                               uint32_t* flags);
   void AddAllocatedPort(Port* port, AllocationSequence* seq,
                         bool prepare_address);
   void OnCandidateReady(Port* port, const Candidate& c);
   void OnPortComplete(Port* port);
   void OnPortError(Port* port);
   void OnProtocolEnabled(AllocationSequence* seq, ProtocolType proto);
   void OnPortDestroyed(PortInterface* port);
   void OnShake();
   void MaybeSignalCandidatesAllocationDone();
   void OnPortAllocationComplete(AllocationSequence* seq);
@@ skipping 65 matching lines @@
     kInit,       // Initial state.
     kRunning,    // Started allocating ports.
     kStopped,    // Stopped from running.
     kCompleted,  // All ports are allocated.
 
     // kInit --> kRunning --> {kCompleted|kStopped}
   };
   AllocationSequence(BasicPortAllocatorSession* session,
                      rtc::Network* network,
                      PortConfiguration* config,
-                     uint32 flags);
+                     uint32_t flags);
   ~AllocationSequence();
   bool Init();
   void Clear();
 
   State state() const { return state_; }
 
   // Disables the phases for a new sequence that this one already covers for an
   // equivalent network setup.
   void DisableEquivalentPhases(rtc::Network* network,
                                PortConfiguration* config,
-                               uint32* flags);
+                               uint32_t* flags);
 
   // Starts and stops the sequence.  When started, it will continue allocating
   // new ports on its own timed schedule.
   void Start();
   void Stop();
 
   // MessageHandler
   void OnMessage(rtc::Message* msg);
 
   void EnableProtocol(ProtocolType proto);
   bool ProtocolEnabled(ProtocolType proto) const;
 
   // Signal from AllocationSequence, when it's done with allocating ports.
   // This signal is useful, when port allocation fails which doesn't result
   // in any candidates. Using this signal BasicPortAllocatorSession can send
   // its candidate discovery conclusion signal. Without this signal,
   // BasicPortAllocatorSession doesn't have any event to trigger signal. This
   // can also be achieved by starting timer in BPAS.
   sigslot::signal1<AllocationSequence*> SignalPortAllocationComplete;
 
  protected:
   // For testing.
   void CreateTurnPort(const RelayServerConfig& config);
 
  private:
   typedef std::vector<ProtocolType> ProtocolList;
 
-  bool IsFlagSet(uint32 flag) { return ((flags_ & flag) != 0); }
+  bool IsFlagSet(uint32_t flag) { return ((flags_ & flag) != 0); }
   void CreateUDPPorts();
   void CreateTCPPorts();
   void CreateStunPorts();
   void CreateRelayPorts();
   void CreateGturnPort(const RelayServerConfig& config);
 
   void OnReadPacket(rtc::AsyncPacketSocket* socket,
                     const char* data,
                     size_t size,
                     const rtc::SocketAddress& remote_addr,
                     const rtc::PacketTime& packet_time);
 
   void OnPortDestroyed(PortInterface* port);
 
   BasicPortAllocatorSession* session_;
   rtc::Network* network_;
   rtc::IPAddress ip_;
   PortConfiguration* config_;
   State state_;
-  uint32 flags_;
+  uint32_t flags_;
   ProtocolList protocols_;
   rtc::scoped_ptr<rtc::AsyncPacketSocket> udp_socket_;
   // There will be only one udp port per AllocationSequence.
   UDPPort* udp_port_;
   std::vector<TurnPort*> turn_ports_;
   int phase_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_CLIENT_BASICPORTALLOCATOR_H_