Switch to standard integer types in ui/gfx/.

ui/gfx/icon_util.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/icon_util.h"
 
 #include "base/files/file_util.h"
 #include "base/files/important_file_writer.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/trace_event/trace_event.h"
 #include "base/win/resource_util.h"
 #include "base/win/scoped_gdi_object.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/scoped_hdc.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/gdi_util.h"
 #include "ui/gfx/geometry/size.h"
@@ skipping 172 matching lines @@
   memcpy(bits, bitmap.getPixels(), bitmap.width() * bitmap.height() * 4);
 
   // Icons are generally created using an AND and XOR masks where the AND
   // specifies boolean transparency (the pixel is either opaque or
   // transparent) and the XOR mask contains the actual image pixels. If the XOR
   // mask bitmap has an alpha channel, the AND monochrome bitmap won't
   // actually be used for computing the pixel transparency. Even though all our
   // bitmap has an alpha channel, Windows might not agree when all alpha values
   // are zero. So the monochrome bitmap is created with all pixels transparent
   // for this case. Otherwise, it is created with all pixels opaque.
-  bool bitmap_has_alpha_channel = PixelsHaveAlpha(
-      static_cast<const uint32*>(bitmap.getPixels()),
-      bitmap.width() * bitmap.height());
+  bool bitmap_has_alpha_channel =
+      PixelsHaveAlpha(static_cast<const uint32_t*>(bitmap.getPixels()),
+                      bitmap.width() * bitmap.height());
 
-  scoped_ptr<uint8[]> mask_bits;
+  scoped_ptr<uint8_t[]> mask_bits;
   if (!bitmap_has_alpha_channel) {
     // Bytes per line with paddings to make it word alignment.
     size_t bytes_per_line = (bitmap.width() + 0xF) / 16 * 2;
     size_t mask_bits_size = bytes_per_line * bitmap.height();
 
-    mask_bits.reset(new uint8[mask_bits_size]);
+    mask_bits.reset(new uint8_t[mask_bits_size]);
     DCHECK(mask_bits.get());
 
     // Make all pixels transparent.
     memset(mask_bits.get(), 0xFF, mask_bits_size);
   }
 
   HBITMAP mono_bitmap = ::CreateBitmap(bitmap.width(), bitmap.height(), 1, 1,
       reinterpret_cast<LPVOID>(mask_bits.get()));
   DCHECK(mono_bitmap);
 
@@ skipping 150 matching lines @@
   SkBitmap bitmap;
   bitmap.allocN32Pixels(s.width(), s.height());
   bitmap.eraseARGB(0, 0, 0, 0);
   SkAutoLockPixels bitmap_lock(bitmap);
 
   // Now we should create a DIB so that we can use ::DrawIconEx in order to
   // obtain the icon's image.
   BITMAPV5HEADER h;
   InitializeBitmapHeader(&h, s.width(), s.height());
   HDC hdc = ::GetDC(NULL);
-  uint32* bits;
+  uint32_t* bits;
   HBITMAP dib = ::CreateDIBSection(hdc, reinterpret_cast<BITMAPINFO*>(&h),
       DIB_RGB_COLORS, reinterpret_cast<void**>(&bits), NULL, 0);
   DCHECK(dib);
   HDC dib_dc = CreateCompatibleDC(hdc);
   ::ReleaseDC(NULL, hdc);
   DCHECK(dib_dc);
   HGDIOBJ old_obj = ::SelectObject(dib_dc, dib);
 
   // Windows icons are defined using two different masks. The XOR mask, which
   // represents the icon image and an AND mask which is a monochrome bitmap
@@ skipping 21 matching lines @@
   for (size_t i = 0; i < num_pixels; ++i)
     opaque[i] = !bits[i];
 
   // Then draw the image itself which is really the XOR mask.
   memset(bits, 0, num_pixels * 4);
   ::DrawIconEx(dib_dc, 0, 0, icon, s.width(), s.height(), 0, NULL, DI_NORMAL);
   memcpy(bitmap.getPixels(), static_cast<void*>(bits), num_pixels * 4);
 
   // Finding out whether the bitmap has an alpha channel.
   bool bitmap_has_alpha_channel = PixelsHaveAlpha(
-      static_cast<const uint32*>(bitmap.getPixels()), num_pixels);
+      static_cast<const uint32_t*>(bitmap.getPixels()), num_pixels);
 
   // If the bitmap does not have an alpha channel, we need to build it using
   // the previously captured AND mask. Otherwise, we are done.
   if (!bitmap_has_alpha_channel) {
-    uint32* p = static_cast<uint32*>(bitmap.getPixels());
+    uint32_t* p = static_cast<uint32_t*>(bitmap.getPixels());
     for (size_t i = 0; i < num_pixels; ++p, ++i) {
       DCHECK_EQ((*p & 0xff000000), 0u);
       if (opaque[i])
         *p |= 0xff000000;
       else
         *p &= 0x00ffffff;
     }
   }
 
   ::SelectObject(dib_dc, old_obj);
@@ skipping 31 matching lines @@
   // images in the desired icon format.
   size_t buffer_size = ComputeIconFileBufferSize(bitmaps);
   // Account for the bytes needed for the PNG entry.
   if (png_bytes.get())
     buffer_size += sizeof(ICONDIRENTRY) + png_bytes->size();
 
   // Setting the information in the structures residing within the buffer.
   // First, we set the information which doesn't require iterating through the
   // bitmap set and then we set the bitmap specific structures. In the latter
   // step we also copy the actual bits.
-  std::vector<uint8> buffer(buffer_size);
+  std::vector<uint8_t> buffer(buffer_size);
   ICONDIR* icon_dir = reinterpret_cast<ICONDIR*>(&buffer[0]);
   icon_dir->idType = kResourceTypeIcon;
   icon_dir->idCount = static_cast<WORD>(image_count);
   // - 1 because there is already one ICONDIRENTRY in ICONDIR.
   size_t icon_dir_count = image_count - 1;
 
   size_t offset = sizeof(ICONDIR) + (sizeof(ICONDIRENTRY) * icon_dir_count);
   for (size_t i = 0; i < bitmap_count; i++) {
     ICONIMAGE* image = reinterpret_cast<ICONIMAGE*>(&buffer[offset]);
     DCHECK_LT(offset, buffer_size);
@@ skipping 27 matching lines @@
       return true;
     bool delete_success = base::DeleteFile(icon_path, false);
     DCHECK(delete_success);
     return false;
   } else {
     std::string data(buffer.begin(), buffer.end());
     return base::ImportantFileWriter::WriteFileAtomically(icon_path, data);
   }
 }
 
-bool IconUtil::PixelsHaveAlpha(const uint32* pixels, size_t num_pixels) {
-  for (const uint32* end = pixels + num_pixels; pixels != end; ++pixels) {
+bool IconUtil::PixelsHaveAlpha(const uint32_t* pixels, size_t num_pixels) {
+  for (const uint32_t* end = pixels + num_pixels; pixels != end; ++pixels) {
     if ((*pixels & 0xff000000) != 0)
       return true;
   }
 
   return false;
 }
 
 void IconUtil::InitializeBitmapHeader(BITMAPV5HEADER* header, int width,
                                       int height) {
   DCHECK(header);
@@ skipping 146 matching lines @@
   // Once we compute the size for a singe AND mask scan line, we multiply that
   // number by the image height in order to get the total number of bytes for
   // the AND mask. Thus, for a 15X15 image, we need 15 * 4 which is 60 bytes
   // for the monochrome bitmap representing the AND mask.
   size_t and_line_length = (bitmap.width() + 7) >> 3;
   and_line_length = (and_line_length + 3) & ~3;
   size_t and_mask_size = and_line_length * bitmap.height();
   size_t masks_size = *xor_mask_size + and_mask_size;
   *bytes_in_resource = masks_size + sizeof(BITMAPINFOHEADER);
 }