Fix ImageDecoder::frameIsCompleteAtIndex - fully received instead of decoded.

third_party/WebKit/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 61 matching lines @@
     , 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_hasPixelsWithAlpha(false)
     , 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)
 {
     // Defensively clear the FastSharedBufferReader's cache, as another caller
@@ skipping 19 matching lines @@
 
     // Read and process the color table, if needed.
     if (m_needToProcessColorTable && !processColorTable())
         return false;
 
     // Initialize the framebuffer if needed.
     ASSERT(m_buffer);  // Parent should set this before asking us to decode!
     if (m_buffer->getStatus() == ImageFrame::FrameEmpty) {
         if (!m_buffer->setSize(m_parent->size().width(), m_parent->size().height()))
             return m_parent->setFailed(); // Unable to allocate.
         m_buffer->setStatus(ImageFrame::FramePartial);

[scroggo_chromium, 2016/05/16 20:32:08]

Previously, this set the alpha to false for a partially decoded BMP. Please add
a test for this behavior change.

-        // setSize() calls eraseARGB(), which resets the alpha flag, so we force
-        // it back to false here.  We'll set it true below in all cases where
-        // these 0s could actually show through.
-        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_decodingAndMask && !pastEndOfImage(0) && !decodePixelData((m_infoHeader.biCompression != RLE4) && (m_infoHeader.biCompression != RLE8) && (m_infoHeader.biCompression != RLE24)))
         return false;
 
     // If the image has an AND mask and there was no alpha data, process the
     // mask.
     if (m_isInICO && !m_decodingAndMask && ((m_infoHeader.biBitCount < 16) || !m_bitMasks[3] || !m_seenNonZeroAlphaPixel)) {
         // 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_decodingAndMask = true;
     }
     if (m_decodingAndMask && !decodePixelData(true))
         return false;
 
     // Done!
+    m_buffer->setHasAlpha(m_hasPixelsWithAlpha);
     m_buffer->setStatus(ImageFrame::FrameComplete);
     return true;
 }
 
 bool BMPImageReader::decodePixelData(bool nonRLE)
 {
     const IntPoint coord(m_coord);
     const ProcessingResult result = nonRLE ? processNonRLEData(false, 0) : processRLEData();
     if (m_coord != coord)
         m_buffer->setPixelsChanged(true);
@@ skipping 439 matching lines @@
         const uint8_t code = readUint8(1);
         if ((count || (code != 1)) && pastEndOfImage(0))
             return Failure;
 
         // Decode.
         if (!count) {
             switch (code) {
             case 0:  // Magic token: EOL
                 // Skip any remaining pixels in this row.
                 if (m_coord.x() < m_parent->size().width())
-                    m_buffer->setHasAlpha(true);
+                    m_hasPixelsWithAlpha = true;
                 moveBufferToNextRow();
 
                 m_decodedOffset += 2;
                 break;
 
             case 1:  // Magic token: EOF
                 // Skip any remaining pixels in the image.
                 if ((m_coord.x() < m_parent->size().width()) || (m_isTopDown ? (m_coord.y() < (m_parent->size().height() - 1)) : (m_coord.y() > 0)))
-                    m_buffer->setHasAlpha(true);
+                    m_hasPixelsWithAlpha = true;
                 // There's no need to move |m_coord| here to trigger the caller
                 // to call setPixelsChanged().  If the only thing that's changed
                 // is the alpha state, that will be properly written into the
                 // underlying SkBitmap when we mark the frame complete.
                 return Success;
 
             case 2: {  // Magic token: Delta
                 // The next two bytes specify dx and dy.  Bail if there isn't
                 // enough data.
                 if ((m_data->size() - m_decodedOffset) < 4)
                     return InsufficientData;
 
                 // Fail if this takes us past the end of the desired row or
                 // past the end of the image.
                 const uint8_t dx = readUint8(2);
                 const uint8_t dy = readUint8(3);
                 if (dx || dy)
-                    m_buffer->setHasAlpha(true);
+                    m_hasPixelsWithAlpha = true;
                 if (((m_coord.x() + dx) > m_parent->size().width()) || pastEndOfImage(dy))
                     return Failure;
 
                 // Skip intervening pixels.
                 m_coord.move(dx, m_isTopDown ? dy : -dy);
 
                 m_decodedOffset += 4;
                 break;
             }
 
@@ skipping 91 matching lines @@
                 for (size_t pixel = 0; (pixel < pixelsPerByte) && (m_coord.x() < endX); ++pixel) {
                     const size_t colorIndex = (pixelData >> (8 - m_infoHeader.biBitCount)) & mask;
                     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);
+                            m_hasPixelsWithAlpha = true;
                         } else
                             m_coord.move(1, 0);
                     } else {
                         // See comments near the end of processRLEData().
                         if (colorIndex < m_infoHeader.biClrUsed)
                             setI(colorIndex);
                         else
                             setRGBA(0, 0, 0, 255);
                     }
                     pixelData <<= m_infoHeader.biBitCount;
@@ skipping 15 matching lines @@
                 // faster to draw.
                 int alpha = getAlpha(pixel);
                 if (!m_seenNonZeroAlphaPixel && !alpha) {
                     m_seenZeroAlphaPixel = true;
                     alpha = 255;
                 } else {
                     m_seenNonZeroAlphaPixel = true;
                     if (m_seenZeroAlphaPixel) {
                         m_buffer->zeroFillPixelData();
                         m_seenZeroAlphaPixel = false;
-                    } else if (alpha != 255)
-                        m_buffer->setHasAlpha(true);
+                    } else if (alpha != 255) {
+                        m_hasPixelsWithAlpha = true;
+                    }
                 }
 
                 setRGBA(getComponent(pixel, 0), getComponent(pixel, 1),
                         getComponent(pixel, 2), alpha);
             }
         }
 
         // Success, keep going.
         m_decodedOffset += paddedNumBytes;
         if (inRLE)
             return Success;
         moveBufferToNextRow();
     }
 
     // Finished decoding whole image.
     return Success;
 }
 
 void BMPImageReader::moveBufferToNextRow()
 {
     m_coord.move(-m_coord.x(), m_isTopDown ? 1 : -1);
 }
 
 } // namespace blink