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

talk/media/webrtc/fakewebrtcvideoengine.h

 /*
  * libjingle
  * Copyright 2010 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 46 matching lines @@
 static const int kViEChannelIdBase = 0;
 static const int kViEChannelIdMax = 1000;
 
 // Fake class for mocking out webrtc::VideoDecoder
 class FakeWebRtcVideoDecoder : public webrtc::VideoDecoder {
  public:
   FakeWebRtcVideoDecoder()
       : num_frames_received_(0) {
   }
 
-  virtual int32 InitDecode(const webrtc::VideoCodec*, int32) {
+  virtual int32_t InitDecode(const webrtc::VideoCodec*, int32_t) {
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
-  virtual int32 Decode(
-      const webrtc::EncodedImage&, bool, const webrtc::RTPFragmentationHeader*,
-      const webrtc::CodecSpecificInfo*, int64_t) {
+  virtual int32_t Decode(const webrtc::EncodedImage&,
+                         bool,
+                         const webrtc::RTPFragmentationHeader*,
+                         const webrtc::CodecSpecificInfo*,
+                         int64_t) {
     num_frames_received_++;
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
-  virtual int32 RegisterDecodeCompleteCallback(
+  virtual int32_t RegisterDecodeCompleteCallback(
       webrtc::DecodedImageCallback*) {
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
-  virtual int32 Release() {
-    return WEBRTC_VIDEO_CODEC_OK;
-  }
+  virtual int32_t Release() { return WEBRTC_VIDEO_CODEC_OK; }
 
-  virtual int32 Reset() {
-    return WEBRTC_VIDEO_CODEC_OK;
-  }
+  virtual int32_t Reset() { return WEBRTC_VIDEO_CODEC_OK; }
 
   int GetNumFramesReceived() const {
     return num_frames_received_;
   }
 
  private:
   int num_frames_received_;
 };
 
 // Fake class for mocking out WebRtcVideoDecoderFactory.
@@ skipping 37 matching lines @@
   std::set<webrtc::VideoCodecType> supported_codec_types_;
   std::vector<FakeWebRtcVideoDecoder*> decoders_;
   int num_created_decoders_;
 };
 
 // Fake class for mocking out webrtc::VideoEnoder
 class FakeWebRtcVideoEncoder : public webrtc::VideoEncoder {
  public:
   FakeWebRtcVideoEncoder() : num_frames_encoded_(0) {}
 
-  virtual int32 InitEncode(const webrtc::VideoCodec* codecSettings,
-                           int32 numberOfCores,
-                           size_t maxPayloadSize) {
+  virtual int32_t InitEncode(const webrtc::VideoCodec* codecSettings,
+                             int32_t numberOfCores,
+                             size_t maxPayloadSize) {
     rtc::CritScope lock(&crit_);
     codec_settings_ = *codecSettings;
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
   webrtc::VideoCodec GetCodecSettings() {
     rtc::CritScope lock(&crit_);
     return codec_settings_;
   }
 
-  virtual int32 Encode(const webrtc::VideoFrame& inputImage,
-                       const webrtc::CodecSpecificInfo* codecSpecificInfo,
-                       const std::vector<webrtc::VideoFrameType>* frame_types) {
+  virtual int32_t Encode(
+      const webrtc::VideoFrame& inputImage,
+      const webrtc::CodecSpecificInfo* codecSpecificInfo,
+      const std::vector<webrtc::VideoFrameType>* frame_types) {
     rtc::CritScope lock(&crit_);
     ++num_frames_encoded_;
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
-  virtual int32 RegisterEncodeCompleteCallback(
+  virtual int32_t RegisterEncodeCompleteCallback(
       webrtc::EncodedImageCallback* callback) {
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
-  virtual int32 Release() {
+  virtual int32_t Release() { return WEBRTC_VIDEO_CODEC_OK; }
+
+  virtual int32_t SetChannelParameters(uint32_t packetLoss, int64_t rtt) {
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
-  virtual int32 SetChannelParameters(uint32 packetLoss,
-                                     int64_t rtt) {
+  virtual int32_t SetRates(uint32_t newBitRate, uint32_t frameRate) {
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
-  virtual int32 SetRates(uint32 newBitRate,
-                         uint32 frameRate) {
-    return WEBRTC_VIDEO_CODEC_OK;
-  }
-
   int GetNumEncodedFrames() {
     rtc::CritScope lock(&crit_);
     return num_frames_encoded_;
   }
 
  private:
   rtc::CriticalSection crit_;
   int num_frames_encoded_ GUARDED_BY(crit_);
   webrtc::VideoCodec codec_settings_ GUARDED_BY(crit_);
 };
@@ skipping 55 matching lines @@
   std::set<webrtc::VideoCodecType> supported_codec_types_;
   std::vector<WebRtcVideoEncoderFactory::VideoCodec> codecs_;
   std::vector<FakeWebRtcVideoEncoder*> encoders_;
   int num_created_encoders_;
   bool encoders_have_internal_sources_;
 };
 
 }  // namespace cricket
 
 #endif  // TALK_MEDIA_WEBRTC_FAKEWEBRTCVIDEOENGINE_H_