some fixes and warning disables in ui/ for building on win x64

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/file_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/win/scoped_gdi_object.h"
@@ skipping 313 matching lines @@
   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);
   ICONDIR* icon_dir = reinterpret_cast<ICONDIR*>(&buffer[0]);
   icon_dir->idType = kResourceTypeIcon;
-  icon_dir->idCount = bitmap_count;
+  icon_dir->idCount = static_cast<WORD>(bitmap_count);
   size_t icon_dir_count = bitmap_count - 1;  // Note DCHECK(!bitmaps.empty())!
 
   // Increment counts if a PNG entry will be added.
   if (png_bytes.get()) {
     icon_dir->idCount++;
     icon_dir_count++;
   }
 
   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);
     size_t icon_image_size = 0;
     SetSingleIconImageInformation(bitmaps[i], i, icon_dir, image, offset,
                                   &icon_image_size);
     DCHECK_GT(icon_image_size, 0U);
     offset += icon_image_size;
   }
 
   // Add the PNG entry, if necessary.
   if (png_bytes.get()) {
     ICONDIRENTRY* entry = &icon_dir->idEntries[bitmap_count];
     entry->bWidth = 0;
     entry->bHeight = 0;
     entry->wPlanes = 1;
     entry->wBitCount = 32;
-    entry->dwBytesInRes = png_bytes->size();
-    entry->dwImageOffset = offset;
+    entry->dwBytesInRes = static_cast<DWORD>(png_bytes->size());

[jschuh, 2013/01/14 21:31:39]

It doesn't look like we validate the size anywhere in here to prevent overflow.
Is it done elsewhere?

[scottmg, 2013/01/14 21:45:00]

No.

I was trying to imagine where a case where it would matter, but I couldn't think
of any... is a CHECK reasonable here?

[jschuh, 2013/01/14 22:14:35]

Sounds good to me. You can convert the DCHECKs on 300 and 301. 

+    entry->dwImageOffset = static_cast<DWORD>(offset);
     memcpy(&buffer[offset], png_bytes->front(), png_bytes->size());
     offset += png_bytes->size();
   }
 
   DCHECK_EQ(offset, buffer_size);
 
   // Finally, write the data to the file.
   DWORD bytes_written;
   bool delete_file = false;
   if (!WriteFile(icon_file.Get(), &buffer[0], buffer_size, &bytes_written,
@@ skipping 204 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);
 }