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

talk/media/base/videocapturer.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 50 matching lines @@
   CS_RUNNING,    // The capturer has been started successfully and is now
                  // capturing.
   CS_PAUSED,     // The capturer has been paused.
   CS_FAILED,     // The capturer failed to start.
   CS_NO_DEVICE,  // The capturer has no device and consequently failed to start.
 };
 
 class VideoFrame;
 
 struct CapturedFrame {
-  static const uint32 kFrameHeaderSize = 40;  // Size from width to data_size.
-  static const uint32 kUnknownDataSize = 0xFFFFFFFF;
+  static const uint32_t kFrameHeaderSize = 40;  // Size from width to data_size.
+  static const uint32_t kUnknownDataSize = 0xFFFFFFFF;
 
   CapturedFrame();
 
   // Get the number of bytes of the frame data. If data_size is known, return
   // it directly. Otherwise, calculate the size based on width, height, and
   // fourcc. Return true if succeeded.
-  bool GetDataSize(uint32* size) const;
+  bool GetDataSize(uint32_t* size) const;
 
   // TODO(guoweis): Change the type of |rotation| from int to
   // webrtc::VideoRotation once chromium gets the code.
   webrtc::VideoRotation GetRotation() const;
 
   // The width and height of the captured frame could be different from those
   // of VideoFormat. Once the first frame is captured, the width, height,
   // fourcc, pixel_width, and pixel_height should keep the same over frames.
-  int    width;         // in number of pixels
-  int    height;        // in number of pixels
-  uint32 fourcc;        // compression
-  uint32 pixel_width;   // width of a pixel, default is 1
-  uint32 pixel_height;  // height of a pixel, default is 1
+  int width;              // in number of pixels
+  int height;             // in number of pixels
+  uint32_t fourcc;        // compression
+  uint32_t pixel_width;   // width of a pixel, default is 1
+  uint32_t pixel_height;  // height of a pixel, default is 1
   // TODO(magjed): |elapsed_time| is deprecated - remove once not used anymore.
-  int64  elapsed_time;
-  int64  time_stamp;    // timestamp of when the frame was captured, in unix
-                        // time with nanosecond units.
-  uint32 data_size;     // number of bytes of the frame data
+  int64_t elapsed_time;
+  int64_t time_stamp;  // timestamp of when the frame was captured, in unix
+                       // time with nanosecond units.
+  uint32_t data_size;  // number of bytes of the frame data
 
   // TODO(guoweis): This can't be converted to VideoRotation yet as it's
   // used by chrome now.
   int    rotation;      // rotation in degrees of the frame (0, 90, 180, 270)
 
   void*  data;          // pointer to the frame data. This object allocates the
                         // memory or points to an existing memory.
 
  private:
   RTC_DISALLOW_COPY_AND_ASSIGN(CapturedFrame);
@@ skipping 201 matching lines @@
   // Callback attached to SignalFrameCaptured where SignalVideoFrames is called.
   void OnFrameCaptured(VideoCapturer* video_capturer,
                        const CapturedFrame* captured_frame);
   void SetCaptureState(CaptureState state);
 
   // Marshals SignalStateChange onto thread_.
   void OnMessage(rtc::Message* message);
 
   // subclasses override this virtual method to provide a vector of fourccs, in
   // order of preference, that are expected by the media engine.
-  virtual bool GetPreferredFourccs(std::vector<uint32>* fourccs) = 0;
+  virtual bool GetPreferredFourccs(std::vector<uint32_t>* fourccs) = 0;
 
   // mutators to set private attributes
   void SetId(const std::string& id) {
     id_ = id;
   }
 
   void SetCaptureFormat(const VideoFormat* format) {
     capture_format_.reset(format ? new VideoFormat(*format) : NULL);
     if (capture_format_) {
       ASSERT(capture_format_->interval > 0 &&
              "Capture format expected to have positive interval.");
       // Video adapter really only cares about capture format interval.
       video_adapter_.SetInputFormat(*capture_format_);
     }
   }
 
   void SetSupportedFormats(const std::vector<VideoFormat>& formats);
   VideoFrameFactory* frame_factory() { return frame_factory_.get(); }
 
  private:
   void Construct();
   // Get the distance between the desired format and the supported format.
   // Return the max distance if they mismatch. See the implementation for
   // details.
-  int64 GetFormatDistance(const VideoFormat& desired,
-                          const VideoFormat& supported);
+  int64_t GetFormatDistance(const VideoFormat& desired,
+                            const VideoFormat& supported);
 
   // Convert captured frame to readable string for LOG messages.
   std::string ToString(const CapturedFrame* frame) const;
 
   // Updates filtered_supported_formats_ so that it contains the formats in
   // supported_formats_ that fulfill all applied restrictions.
   void UpdateFilteredSupportedFormats();
   // Returns true if format doesn't fulfill all applied restrictions.
   bool ShouldFilterFormat(const VideoFormat& format) const;
 
@@ skipping 40 matching lines @@
 
   // Whether capturer should apply rotation to the frame before signaling it.
   bool apply_rotation_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(VideoCapturer);
 };
 
 }  // namespace cricket
 
 #endif  // TALK_MEDIA_BASE_VIDEOCAPTURER_H_