Switch to standard integer types in ui/gfx/.

ui/gfx/skbitmap_operations.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/gfx/skbitmap_operations.h"
 
+#include <stddef.h>
+#include <stdint.h>
 #include <string.h>
 #include <algorithm>
 
 #include "base/logging.h"
 #include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
 #include "third_party/skia/include/core/SkColorPriv.h"
 #include "third_party/skia/include/core/SkUnPreMultiply.h"
 #include "third_party/skia/include/effects/SkBlurImageFilter.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/size.h"
 
 // static
 SkBitmap SkBitmapOperations::CreateInvertedBitmap(const SkBitmap& image) {
   DCHECK(image.colorType() == kN32_SkColorType);
 
   SkAutoLockPixels lock_image(image);
 
   SkBitmap inverted;
   inverted.allocN32Pixels(image.width(), image.height());
 
   for (int y = 0; y < image.height(); ++y) {
-    uint32* image_row = image.getAddr32(0, y);
-    uint32* dst_row = inverted.getAddr32(0, y);
+    uint32_t* image_row = image.getAddr32(0, y);
+    uint32_t* dst_row = inverted.getAddr32(0, y);
 
     for (int x = 0; x < image.width(); ++x) {
-      uint32 image_pixel = image_row[x];
+      uint32_t image_pixel = image_row[x];
       dst_row[x] = (image_pixel & 0xFF000000) |
                    (0x00FFFFFF - (image_pixel & 0x00FFFFFF));
     }
   }
 
   return inverted;
 }
 
 // static
 SkBitmap SkBitmapOperations::CreateBlendedBitmap(const SkBitmap& first,
@@ skipping 15 matching lines @@
 
   SkAutoLockPixels lock_first(first);
   SkAutoLockPixels lock_second(second);
 
   SkBitmap blended;
   blended.allocN32Pixels(first.width(), first.height());
 
   double first_alpha = 1 - alpha;
 
   for (int y = 0; y < first.height(); ++y) {
-    uint32* first_row = first.getAddr32(0, y);
-    uint32* second_row = second.getAddr32(0, y);
-    uint32* dst_row = blended.getAddr32(0, y);
+    uint32_t* first_row = first.getAddr32(0, y);
+    uint32_t* second_row = second.getAddr32(0, y);
+    uint32_t* dst_row = blended.getAddr32(0, y);
 
     for (int x = 0; x < first.width(); ++x) {
-      uint32 first_pixel = first_row[x];
-      uint32 second_pixel = second_row[x];
+      uint32_t first_pixel = first_row[x];
+      uint32_t second_pixel = second_row[x];
 
       int a = static_cast<int>((SkColorGetA(first_pixel) * first_alpha) +
                                (SkColorGetA(second_pixel) * alpha));
       int r = static_cast<int>((SkColorGetR(first_pixel) * first_alpha) +
                                (SkColorGetR(second_pixel) * alpha));
       int g = static_cast<int>((SkColorGetG(first_pixel) * first_alpha) +
                                (SkColorGetG(second_pixel) * alpha));
       int b = static_cast<int>((SkColorGetB(first_pixel) * first_alpha) +
                                (SkColorGetB(second_pixel) * alpha));
 
@@ skipping 14 matching lines @@
   DCHECK(alpha.colorType() == kN32_SkColorType);
 
   SkBitmap masked;
   masked.allocN32Pixels(rgb.width(), rgb.height());
 
   SkAutoLockPixels lock_rgb(rgb);
   SkAutoLockPixels lock_alpha(alpha);
   SkAutoLockPixels lock_masked(masked);
 
   for (int y = 0; y < masked.height(); ++y) {
-    uint32* rgb_row = rgb.getAddr32(0, y);
-    uint32* alpha_row = alpha.getAddr32(0, y);
-    uint32* dst_row = masked.getAddr32(0, y);
+    uint32_t* rgb_row = rgb.getAddr32(0, y);
+    uint32_t* alpha_row = alpha.getAddr32(0, y);
+    uint32_t* dst_row = masked.getAddr32(0, y);
 
     for (int x = 0; x < masked.width(); ++x) {
       unsigned alpha = SkGetPackedA32(alpha_row[x]);
       unsigned scale = SkAlpha255To256(alpha);
       dst_row[x] = SkAlphaMulQ(rgb_row[x], scale);
     }
   }
 
   return masked;
 }
@@ skipping 11 matching lines @@
   double bg_a = SkColorGetA(color);
   double bg_r = SkColorGetR(color);
   double bg_g = SkColorGetG(color);
   double bg_b = SkColorGetB(color);
 
   SkAutoLockPixels lock_mask(mask);
   SkAutoLockPixels lock_image(image);
   SkAutoLockPixels lock_background(background);
 
   for (int y = 0; y < mask.height(); ++y) {
-    uint32* dst_row = background.getAddr32(0, y);
-    uint32* image_row = image.getAddr32(0, y % image.height());
-    uint32* mask_row = mask.getAddr32(0, y);
+    uint32_t* dst_row = background.getAddr32(0, y);
+    uint32_t* image_row = image.getAddr32(0, y % image.height());
+    uint32_t* mask_row = mask.getAddr32(0, y);
 
     for (int x = 0; x < mask.width(); ++x) {
-      uint32 image_pixel = image_row[x % image.width()];
+      uint32_t image_pixel = image_row[x % image.width()];
 
       double img_a = SkColorGetA(image_pixel);
       double img_r = SkColorGetR(image_pixel);
       double img_g = SkColorGetG(image_pixel);
       double img_b = SkColorGetB(image_pixel);
 
       double img_alpha = static_cast<double>(img_a) / 255.0;
       double img_inv = 1 - img_alpha;
 
       double mask_a = static_cast<double>(SkColorGetA(mask_row[x])) / 255.0;
@@ skipping 375 matching lines @@
 
   SkAutoLockPixels lock_source(source);
   SkAutoLockPixels lock_cropped(cropped);
 
   // Loop through the pixels of the original bitmap.
   for (int y = 0; y < dst_h; ++y) {
     int y_pix = (src_y + y) % source.height();
     while (y_pix < 0)
       y_pix += source.height();
 
-    uint32* source_row = source.getAddr32(0, y_pix);
-    uint32* dst_row = cropped.getAddr32(0, y);
+    uint32_t* source_row = source.getAddr32(0, y_pix);
+    uint32_t* dst_row = cropped.getAddr32(0, y);
 
     for (int x = 0; x < dst_w; ++x) {
       int x_pix = (src_x + x) % source.width();
       while (x_pix < 0)
         x_pix += source.width();
 
       dst_row[x] = source_row[x_pix];
     }
   }
 
@@ skipping 92 matching lines @@
       SkImageInfo::Make(info.width(), info.height(), info.colorType(),
                         kOpaque_SkAlphaType, info.profileType());
   SkBitmap opaque_bitmap;
   opaque_bitmap.allocPixels(opaque_info);
 
   {
     SkAutoLockPixels bitmap_lock(bitmap);
     SkAutoLockPixels opaque_bitmap_lock(opaque_bitmap);
     for (int y = 0; y < opaque_bitmap.height(); y++) {
       for (int x = 0; x < opaque_bitmap.width(); x++) {
-        uint32 src_pixel = *bitmap.getAddr32(x, y);
-        uint32* dst_pixel = opaque_bitmap.getAddr32(x, y);
+        uint32_t src_pixel = *bitmap.getAddr32(x, y);
+        uint32_t* dst_pixel = opaque_bitmap.getAddr32(x, y);
         SkColor unmultiplied = SkUnPreMultiply::PMColorToColor(src_pixel);
         *dst_pixel = unmultiplied;
       }
     }
   }
 
   return opaque_bitmap;
 }
 
 // static
 SkBitmap SkBitmapOperations::CreateTransposedBitmap(const SkBitmap& image) {
   DCHECK(image.colorType() == kN32_SkColorType);
 
   SkBitmap transposed;
   transposed.allocN32Pixels(image.height(), image.width());
 
   SkAutoLockPixels lock_image(image);
   SkAutoLockPixels lock_transposed(transposed);
 
   for (int y = 0; y < image.height(); ++y) {
-    uint32* image_row = image.getAddr32(0, y);
+    uint32_t* image_row = image.getAddr32(0, y);
     for (int x = 0; x < image.width(); ++x) {
-      uint32* dst = transposed.getAddr32(y, x);
+      uint32_t* dst = transposed.getAddr32(y, x);
       *dst = image_row[x];
     }
   }
 
   return transposed;
 }
 
 // static
 SkBitmap SkBitmapOperations::CreateColorMask(const SkBitmap& bitmap,
                                              SkColor c) {
@@ skipping 87 matching lines @@
   canvas.translate(SkFloatToScalar(result.width() * 0.5f),
                    SkFloatToScalar(result.height() * 0.5f));
   canvas.rotate(angle);
   canvas.translate(-SkFloatToScalar(source.width() * 0.5f),
                    -SkFloatToScalar(source.height() * 0.5f));
   canvas.drawBitmap(source, 0, 0);
   canvas.flush();
 
   return result;
 }