BMP-in-ICO should respect alpha in Windows V3 32bpp RGB bitmaps.

Source/platform/image-decoders/bmp/BMPImageReader.cpp

 /*
  * Copyright (c) 2008, 2009, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 48 matching lines @@
     129, 131, 133, 135, 137, 139, 141, 143, 145, 147, 149, 151, 153, 155, 157, 159,
     161, 163, 165, 167, 169, 171, 173, 175, 177, 179, 181, 183, 185, 187, 189, 191,
     193, 195, 197, 199, 201, 203, 205, 207, 209, 211, 213, 215, 217, 219, 221, 223,
     225, 227, 229, 231, 233, 235, 237, 239, 241, 243, 245, 247, 249, 251, 253, 255,
 };
 
 }
 
 namespace WebCore {
 
-BMPImageReader::BMPImageReader(ImageDecoder* parent, size_t decodedAndHeaderOffset, size_t imgDataOffset, bool usesAndMask)
+BMPImageReader::BMPImageReader(ImageDecoder* parent, size_t decodedAndHeaderOffset, size_t imgDataOffset, bool isInICO)
     : m_parent(parent)
     , m_buffer(0)
     , m_decodedOffset(decodedAndHeaderOffset)
     , m_headerOffset(decodedAndHeaderOffset)
     , m_imgDataOffset(imgDataOffset)
     , m_isOS21x(false)
     , m_isOS22x(false)
     , m_isTopDown(false)
     , m_needToProcessBitmasks(false)
     , m_needToProcessColorTable(false)
     , m_seenNonZeroAlphaPixel(false)
     , m_seenZeroAlphaPixel(false)
-    , m_andMaskState(usesAndMask ? NotYetDecoded : None)
+    , m_isInICO(isInICO)
+    , m_decodingAndMask(false)
 {
     // Clue-in decodeBMP() that we need to detect the correct info header size.
     memset(&m_infoHeader, 0, sizeof(m_infoHeader));
 }
 
 bool BMPImageReader::decodeBMP(bool onlySize)
 {
     // Calculate size of info header.
     if (!m_infoHeader.biSize && !readInfoHeaderSize())
         return false;
@@ skipping 26 matching lines @@
         m_buffer->setHasAlpha(false);
 
         // For BMPs, the frame always fills the entire image.
         m_buffer->setOriginalFrameRect(IntRect(IntPoint(), m_parent->size()));
 
         if (!m_isTopDown)
             m_coord.setY(m_parent->size().height() - 1);
     }
 
     // Decode the data.
-    if ((m_andMaskState != Decoding) && !pastEndOfImage(0)) {
+    if (!m_decodingAndMask && !pastEndOfImage(0)) {
         if ((m_infoHeader.biCompression != RLE4) && (m_infoHeader.biCompression != RLE8) && (m_infoHeader.biCompression != RLE24)) {
             const ProcessingResult result = processNonRLEData(false, 0);
             if (result != Success)
                 return (result == Failure) ? m_parent->setFailed() : false;
         } else if (!processRLEData())
             return false;
     }
 
     // If the image has an AND mask and there was no alpha data, process the
     // mask.
-    if ((m_andMaskState == NotYetDecoded) && !m_buffer->hasAlpha()) {
+    if (m_isInICO && !m_decodingAndMask && !m_buffer->hasAlpha()) {
         // Reset decoding coordinates to start of image.
         m_coord.setX(0);
         m_coord.setY(m_isTopDown ? 0 : (m_parent->size().height() - 1));
 
         // The AND mask is stored as 1-bit data.
         m_infoHeader.biBitCount = 1;
 
-        m_andMaskState = Decoding;
+        m_decodingAndMask = true;
     }
-    if (m_andMaskState == Decoding) {
+    if (m_decodingAndMask) {
         const ProcessingResult result = processNonRLEData(false, 0);
         if (result != Success)
             return (result == Failure) ? m_parent->setFailed() : false;
     }
 
     // Done!
     m_buffer->setStatus(ImageFrame::FrameComplete);
     return true;
 }
 
@@ skipping 73 matching lines @@
 
 bool BMPImageReader::readInfoHeader()
 {
     // Pre-initialize some fields that not all headers set.
     m_infoHeader.biCompression = RGB;
     m_infoHeader.biClrUsed = 0;
 
     if (m_isOS21x) {
         m_infoHeader.biWidth = readUint16(4);
         m_infoHeader.biHeight = readUint16(6);
-        ASSERT(m_andMaskState == None);  // ICO is a Windows format, not OS/2!
+        ASSERT(!m_isInICO); // ICO is a Windows format, not OS/2!
         m_infoHeader.biBitCount = readUint16(10);
         return true;
     }
 
     m_infoHeader.biWidth = readUint32(4);
     m_infoHeader.biHeight = readUint32(8);
-    if (m_andMaskState != None)
+    if (m_isInICO)
         m_infoHeader.biHeight /= 2;
     m_infoHeader.biBitCount = readUint16(14);
 
     // Read compression type, if present.
     if (m_infoHeader.biSize >= 20) {
         uint32_t biCompression = readUint32(16);
 
         // Detect OS/2 2.x-specific compression types.
         if ((biCompression == 3) && (m_infoHeader.biBitCount == 1)) {
             m_infoHeader.biCompression = HUFFMAN1D;
@@ skipping 171 matching lines @@
     }
 
     // Alpha is a poorly-documented and inconsistently-used feature.
     //
     // Windows V4+ has an alpha bitmask in the info header. Unlike the R/G/B
     // bitmasks, the MSDN docs don't indicate that it is only valid for the
     // BITFIELDS compression format, so we respect it at all times.
     //
     // To complicate things, Windows V3 BMPs, which lack this mask, can specify
     // 32bpp format, which to any sane reader would imply an 8-bit alpha
-    // channel -- and indeed, there exist BMPs in this format which clearly
+    // channel -- and for BMPs-in-ICOs, that's precisely what's intended to
+    // happen. There also exist standalone BMPs in this format which clearly
     // expect the alpha channel to be respected. However, there are many other
     // BMPs which, for example, fill this channel with all 0s, yet clearly
     // expect to not be displayed as a fully-transparent rectangle.
     //
     // If these were the only two types of Windows V3, 32bpp BMPs in the wild,
     // we could distinguish between them by scanning the alpha channel in the
     // image, looking for nonzero values, and only enabling alpha if we found
     // some. (It turns out we have to do this anyway, because, crazily, there
     // are also Windows V4+ BMPs with an explicit, non-zero alpha mask, which
     // then zero-fill their alpha channels! See comments in
     // processNonRLEData().)
     //
     // Unfortunately there are also V3 BMPs -- indeed, probably more than the
     // number of 32bpp, V3 BMPs which intentionally use alpha -- which specify
     // 32bpp format, use nonzero (and non-255) alpha values, and yet expect to
     // be rendered fully-opaque. And other browsers do so.
     //
     // So it's impossible to display every BMP in the way its creators intended,
     // and we have to choose what to break. Given the paragraph above, we match
-    // other browsers and ignore alpha in Windows V3 BMPs.
+    // other browsers and ignore alpha in Windows V3 BMPs except inside ICO
+    // files.
     if (!isWindowsV4Plus())
-        m_bitMasks[3] = 0;
+        m_bitMasks[3] = (m_isInICO && (m_infoHeader.biCompression != BITFIELDS) && (m_infoHeader.biBitCount == 32)) ? static_cast<uint32_t>(0xff000000) : 0;
 
     // We've now decoded all the non-image data we care about.  Skip anything
     // else before the actual raster data.
     if (m_imgDataOffset)
         m_decodedOffset = m_imgDataOffset;
     m_needToProcessBitmasks = false;
 
     // Check masks and set shift and LUT address values.
     for (int i = 0; i < 4; ++i) {
         // Trim the mask to the allowed bit depth.  Some Windows V4+ BMPs
@@ skipping 243 matching lines @@
 
         if (m_infoHeader.biBitCount < 16) {
             // Paletted data.  Pixels are stored little-endian within bytes.
             // Decode pixels one byte at a time, left to right (so, starting at
             // the most significant bits in the byte).
             const uint8_t mask = (1 << m_infoHeader.biBitCount) - 1;
             for (size_t byte = 0; byte < unpaddedNumBytes; ++byte) {
                 uint8_t pixelData = m_data->data()[m_decodedOffset + byte];
                 for (size_t pixel = 0; (pixel < pixelsPerByte) && (m_coord.x() < endX); ++pixel) {
                     const size_t colorIndex = (pixelData >> (8 - m_infoHeader.biBitCount)) & mask;
-                    if (m_andMaskState == Decoding) {
+                    if (m_decodingAndMask) {
                         // There's no way to accurately represent an AND + XOR
                         // operation as an RGBA image, so where the AND values
                         // are 1, we simply set the framebuffer pixels to fully
                         // transparent, on the assumption that most ICOs on the
                         // web will not be doing a lot of inverting.
                         if (colorIndex) {
                             setRGBA(0, 0, 0, 0);
                             m_buffer->setHasAlpha(true);
                         } else
                             m_coord.move(1, 0);
@@ skipping 49 matching lines @@
     // Finished decoding whole image.
     return Success;
 }
 
 void BMPImageReader::moveBufferToNextRow()
 {
     m_coord.move(-m_coord.x(), m_isTopDown ? 1 : -1);
 }
 
 } // namespace WebCore