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

webrtc/base/x11windowpicker.cc

 /*
  *  Copyright 2010 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 259 matching lines @@
       xev.xclient.data.l[4] = 0;
 
       event_mask = SubstructureRedirectMask | SubstructureNotifyMask;
 
       XSendEvent(display_, root, False, event_mask, &xev);
     }
     XFlush(display_);
     return true;
   }
 
-  uint8* GetWindowIcon(const WindowId& id, int* width, int* height) {
+  uint8_t* GetWindowIcon(const WindowId& id, int* width, int* height) {
     if (!Init()) {
       return NULL;
     }
     XErrorSuppressor error_suppressor(display_);
     Atom ret_type;
     int format;
     unsigned long length, bytes_after, size;
     unsigned char* data = NULL;
 
     // Find out the size of the icon data.
     if (XGetWindowProperty(
             display_, id.id(), net_wm_icon_, 0, 0, False, XA_CARDINAL,
             &ret_type, &format, &length, &size, &data) == Success &&
         data) {
       XFree(data);
     } else {
       LOG(LS_ERROR) << "Failed to get size of the icon.";
       return NULL;
     }
-    // Get the icon data, the format is one uint32 each for width and height,
+    // Get the icon data, the format is one uint32_t each for width and height,
     // followed by the actual pixel data.
     if (size >= 2 &&
         XGetWindowProperty(
             display_, id.id(), net_wm_icon_, 0, size, False, XA_CARDINAL,
             &ret_type, &format, &length, &bytes_after, &data) == Success &&
         data) {
-      uint32* data_ptr = reinterpret_cast<uint32*>(data);
+      uint32_t* data_ptr = reinterpret_cast<uint32_t*>(data);
       int w, h;
       w = data_ptr[0];
       h = data_ptr[1];
       if (size < static_cast<unsigned long>(w * h + 2)) {
         XFree(data);
         LOG(LS_ERROR) << "Not a vaild icon.";
         return NULL;
       }
-      uint8* rgba =
-          ArgbToRgba(&data_ptr[2], 0, 0, w, h, w, h, true);
+      uint8_t* rgba = ArgbToRgba(&data_ptr[2], 0, 0, w, h, w, h, true);
       XFree(data);
       *width = w;
       *height = h;
       return rgba;
     } else {
       LOG(LS_ERROR) << "Failed to get window icon data.";
       return NULL;
     }
   }
 
-  uint8* GetWindowThumbnail(const WindowId& id, int width, int height) {
+  uint8_t* GetWindowThumbnail(const WindowId& id, int width, int height) {
     if (!Init()) {
       return NULL;
     }
 
     if (!has_composite_extension_) {
       // Without the Xcomposite extension we would only get a good thumbnail if
       // the whole window is visible on screen and not covered by any
       // other window. This is not something we want so instead, just
       // bail out.
       LOG(LS_INFO) << "No Xcomposite extension detected.";
@@ skipping 44 matching lines @@
     // If we get to here, then composite is in use for this window and it has a
     // valid backing pixmap.
 
     XWindowAttributes attr;
     if (!XGetWindowAttributes(display_, id.id(), &attr)) {
       LOG(LS_ERROR) << "XGetWindowAttributes() failed";
       XFreePixmap(display_, src_pixmap);
       return NULL;
     }
 
-    uint8* data = GetDrawableThumbnail(src_pixmap,
-                                       attr.visual,
-                                       src_width,
-                                       src_height,
-                                       width,
-                                       height);
+    uint8_t* data = GetDrawableThumbnail(src_pixmap, attr.visual, src_width,
+                                         src_height, width, height);
     XFreePixmap(display_, src_pixmap);
     return data;
   }
 
   int GetNumDesktops() {
     if (!Init()) {
       return -1;
     }
 
     return XScreenCount(display_);
   }
 
-  uint8* GetDesktopThumbnail(const DesktopId& id, int width, int height) {
+  uint8_t* GetDesktopThumbnail(const DesktopId& id, int width, int height) {
     if (!Init()) {
       return NULL;
     }
     XErrorSuppressor error_suppressor(display_);
 
     Window root_window = id.id();
     XWindowAttributes attr;
     if (!XGetWindowAttributes(display_, root_window, &attr)) {
       LOG(LS_ERROR) << "XGetWindowAttributes() failed";
       return NULL;
@@ skipping 16 matching lines @@
     if (!XGetWindowAttributes(display_, id.id(), &attr)) {
       LOG(LS_ERROR) << "XGetWindowAttributes() failed";
       return false;
     }
     *width = attr.width;
     *height = attr.height;
     return true;
   }
 
  private:
-  uint8* GetDrawableThumbnail(Drawable src_drawable,
-                              Visual* visual,
-                              int src_width,
-                              int src_height,
-                              int dst_width,
-                              int dst_height) {
+  uint8_t* GetDrawableThumbnail(Drawable src_drawable,
+                                Visual* visual,
+                                int src_width,
+                                int src_height,
+                                int dst_width,
+                                int dst_height) {
     if (!has_render_extension_) {
       // Without the Xrender extension we would have to read the full window and
       // scale it down in our process. Xrender is over a decade old so we aren't
       // going to expend effort to support that situation. We still need to
       // check though because probably some virtual VNC displays are in this
       // category.
       LOG(LS_INFO) << "No Xrender extension detected.";
       return NULL;
     }
 
@@ skipping 90 matching lines @@
 
     // Get the pixel data from the X server. TODO: XGetImage
     // might be slow here, compare with ShmGetImage.
     XImage* image = XGetImage(display_,
                               dst_pixmap,
                               0,
                               0,
                               dst_width,
                               dst_height,
                               AllPlanes, ZPixmap);
-    uint8* data = ArgbToRgba(reinterpret_cast<uint32*>(image->data),
-                             centered_x,
-                             centered_y,
-                             scaled_width,
-                             scaled_height,
-                             dst_width,
-                             dst_height,
-                             false);
+    uint8_t* data = ArgbToRgba(reinterpret_cast<uint32_t*>(image->data),
+                               centered_x, centered_y, scaled_width,
+                               scaled_height, dst_width, dst_height, false);
     XDestroyImage(image);
     XRenderFreePicture(display_, dst);
     XFreePixmap(display_, dst_pixmap);
     XRenderFreePicture(display_, src);
     return data;
   }
 
-  uint8* ArgbToRgba(uint32* argb_data, int x, int y, int w, int h,
-                    int stride_x, int stride_y, bool has_alpha) {
-    uint8* p;
+  uint8_t* ArgbToRgba(uint32_t* argb_data,
+                      int x,
+                      int y,
+                      int w,
+                      int h,
+                      int stride_x,
+                      int stride_y,
+                      bool has_alpha) {
+    uint8_t* p;
     int len = stride_x * stride_y * 4;
-    uint8* data = new uint8[len];
+    uint8_t* data = new uint8_t[len];
     memset(data, 0, len);
     p = data + 4 * (y * stride_x + x);
     for (int i = 0; i < h; ++i) {
       for (int j = 0; j < w; ++j) {
-        uint32 argb;
-        uint32 rgba;
+        uint32_t argb;
+        uint32_t rgba;
         argb = argb_data[stride_x * (y + i) + x + j];
         rgba = (argb << 8) | (argb >> 24);
         *p = rgba >> 24;
         ++p;
         *p = (rgba >> 16) & 0xff;
         ++p;
         *p = (rgba >> 8) & 0xff;
         ++p;
         *p = has_alpha ? rgba & 0xFF : 0xFF;
         ++p;
@@ skipping 84 matching lines @@
     int ret = XGetWindowProperty(display_, window,
                                  wm_state_, 0L, 2,
                                  False, wm_state_, &type, &format,
                                  &nitems, &after, &data);
     if (ret != Success) {
       LOG(LS_ERROR) << "XGetWindowProperty failed with return code " << ret
                     << " for window " << window << ".";
       return 0;
     }
     if (type != None) {
-      int64 state = static_cast<int64>(*data);
+      int64_t state = static_cast<int64_t>(*data);
       XFree(data);
       return state == NormalState ? window : 0;
     }
     XFree(data);
     if (!XQueryTree(display_, window, &root, &parent, &children,
                     &num_children)) {
       LOG(LS_ERROR) << "Failed to query for child windows although window"
                     << "does not have a valid WM_STATE.";
       return 0;
     }
@@ skipping 77 matching lines @@
 }
 
 bool X11WindowPicker::IsVisible(const WindowId& id) {
   return enumerator_->IsVisible(id);
 }
 
 bool X11WindowPicker::MoveToFront(const WindowId& id) {
   return enumerator_->MoveToFront(id);
 }
 
-
-uint8* X11WindowPicker::GetWindowIcon(const WindowId& id, int* width,
+uint8_t* X11WindowPicker::GetWindowIcon(const WindowId& id,
+                                        int* width,
                                         int* height) {
   return enumerator_->GetWindowIcon(id, width, height);
 }
 
-uint8* X11WindowPicker::GetWindowThumbnail(const WindowId& id, int width,
+uint8_t* X11WindowPicker::GetWindowThumbnail(const WindowId& id,
+                                             int width,
                                              int height) {
   return enumerator_->GetWindowThumbnail(id, width, height);
 }
 
 int X11WindowPicker::GetNumDesktops() {
   return enumerator_->GetNumDesktops();
 }
 
-uint8* X11WindowPicker::GetDesktopThumbnail(const DesktopId& id,
+uint8_t* X11WindowPicker::GetDesktopThumbnail(const DesktopId& id,
                                               int width,
                                               int height) {
   return enumerator_->GetDesktopThumbnail(id, width, height);
 }
 
 bool X11WindowPicker::GetDesktopDimensions(const DesktopId& id, int* width,
                                              int* height) {
   return enumerator_->GetDesktopDimensions(id, width, height);
 }
 
 }  // namespace rtc