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

webrtc/examples/peerconnection/client/linux/main_wnd.cc

 /*
  *  Copyright 2012 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 376 matching lines @@
   gdk_threads_enter();
 
   VideoRenderer* remote_renderer = remote_renderer_.get();
   if (remote_renderer && remote_renderer->image() != NULL &&
       draw_area_ != NULL) {
     int width = remote_renderer->width();
     int height = remote_renderer->height();
 
     if (!draw_buffer_.get()) {
       draw_buffer_size_ = (width * height * 4) * 4;
-      draw_buffer_.reset(new uint8[draw_buffer_size_]);
+      draw_buffer_.reset(new uint8_t[draw_buffer_size_]);
       gtk_widget_set_size_request(draw_area_, width * 2, height * 2);
     }
 
-    const uint32* image = reinterpret_cast<const uint32*>(
-        remote_renderer->image());
-    uint32* scaled = reinterpret_cast<uint32*>(draw_buffer_.get());
+    const uint32_t* image =
+        reinterpret_cast<const uint32_t*>(remote_renderer->image());
+    uint32_t* scaled = reinterpret_cast<uint32_t*>(draw_buffer_.get());
     for (int r = 0; r < height; ++r) {
       for (int c = 0; c < width; ++c) {
         int x = c * 2;
         scaled[x] = scaled[x + 1] = image[c];
       }
 
-      uint32* prev_line = scaled;
+      uint32_t* prev_line = scaled;
       scaled += width * 2;
       memcpy(scaled, prev_line, (width * 2) * 4);
 
       image += width;
       scaled += width * 2;
     }
 
     VideoRenderer* local_renderer = local_renderer_.get();
     if (local_renderer && local_renderer->image()) {
-      image = reinterpret_cast<const uint32*>(local_renderer->image());
-      scaled = reinterpret_cast<uint32*>(draw_buffer_.get());
+      image = reinterpret_cast<const uint32_t*>(local_renderer->image());
+      scaled = reinterpret_cast<uint32_t*>(draw_buffer_.get());
       // Position the local preview on the right side.
       scaled += (width * 2) - (local_renderer->width() / 2);
       // right margin...
       scaled -= 10;
       // ... towards the bottom.
       scaled += (height * width * 4) -
                 ((local_renderer->height() / 2) *
                  (local_renderer->width() / 2) * 4);
       // bottom margin...
       scaled -= (width * 2) * 5;
@@ skipping 35 matching lines @@
 
 void GtkMainWnd::VideoRenderer::SetSize(int width, int height) {
   gdk_threads_enter();
 
   if (width_ == width && height_ == height) {
     return;
   }
 
   width_ = width;
   height_ = height;
-  image_.reset(new uint8[width * height * 4]);
+  image_.reset(new uint8_t[width * height * 4]);
   gdk_threads_leave();
 }
 
 void GtkMainWnd::VideoRenderer::RenderFrame(
     const cricket::VideoFrame* video_frame) {
   gdk_threads_enter();
 
   const cricket::VideoFrame* frame = video_frame->GetCopyWithRotationApplied();
 
   SetSize(static_cast<int>(frame->GetWidth()),
           static_cast<int>(frame->GetHeight()));
 
   int size = width_ * height_ * 4;
   // TODO: Convert directly to RGBA
   frame->ConvertToRgbBuffer(cricket::FOURCC_ARGB,
                             image_.get(),
                             size,
                             width_ * 4);
   // Convert the B,G,R,A frame to R,G,B,A, which is accepted by GTK.
   // The 'A' is just padding for GTK, so we can use it as temp.
-  uint8* pix = image_.get();
-  uint8* end = image_.get() + size;
+  uint8_t* pix = image_.get();
+  uint8_t* end = image_.get() + size;
   while (pix < end) {
     pix[3] = pix[0];     // Save B to A.
     pix[0] = pix[2];  // Set Red.
     pix[2] = pix[3];  // Set Blue.
     pix[3] = 0xFF;     // Fixed Alpha.
     pix += 4;
   }
 
   gdk_threads_leave();
 
   g_idle_add(Redraw, main_wnd_);
 }