Do not consolidate data in BMPImageDecoder

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 51 matching lines @@
     225, 227, 229, 231, 233, 235, 237, 239, 241, 243, 245, 247, 249, 251, 253, 255,
 };
 
 }
 
 namespace blink {
 
 BMPImageReader::BMPImageReader(ImageDecoder* parent, size_t decodedAndHeaderOffset, size_t imgDataOffset, bool isInICO)
     : m_parent(parent)
     , m_buffer(0)
+    , m_fastReader(nullptr)
     , 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)
@@ skipping 77 matching lines @@
         m_buffer->setPixelsChanged(true);
     return (result == Failure) ? m_parent->setFailed() : (result == Success);
 }
 
 bool BMPImageReader::readInfoHeaderSize()
 {
     // Get size of info header.
     ASSERT(m_decodedOffset == m_headerOffset);
     if ((m_decodedOffset > m_data->size()) || ((m_data->size() - m_decodedOffset) < 4))
         return false;
+
     m_infoHeader.biSize = readUint32(0);
     // Don't increment m_decodedOffset here, it just makes the code in
     // processInfoHeader() more confusing.
 
     // Don't allow the header to overflow (which would be harmless here, but
     // problematic or at least confusing in other places), or to overrun the
     // image data.
     const size_t headerEnd = m_headerOffset + m_infoHeader.biSize;
     if ((headerEnd < m_headerOffset) || (m_imgDataOffset && (m_imgDataOffset < headerEnd)))
         return m_parent->setFailed();
@@ skipping 244 matching lines @@
         // Fail if we don't have enough file space for the bitmasks.
         const size_t headerEnd = m_headerOffset + m_infoHeader.biSize;
         const size_t bitmasksSize = 12;
         const size_t bitmasksEnd = headerEnd + bitmasksSize;
         if ((bitmasksEnd < headerEnd) || (m_imgDataOffset && (m_imgDataOffset < bitmasksEnd)))
             return m_parent->setFailed();
 
         // Read bitmasks.
         if ((m_data->size() - m_decodedOffset) < bitmasksSize)
             return false;
+

[Peter Kasting, 2015/09/02 22:08:54]

Nit: I wouldn't add this blank line

[scroggo_chromium, 2015/09/02 23:01:07]

Done.

         m_bitMasks[0] = readUint32(0);
         m_bitMasks[1] = readUint32(4);
         m_bitMasks[2] = readUint32(8);
 
         m_decodedOffset += bitmasksSize;
     }
 
     // Alpha is a poorly-documented and inconsistently-used feature.
     //
     // Windows V4+ has an alpha bitmask in the info header. Unlike the R/G/B
@@ skipping 92 matching lines @@
     const size_t tableSizeInBytes = m_infoHeader.biClrUsed * (m_isOS21x ? 3 : 4);
     const size_t tableEnd = headerEnd + tableSizeInBytes;
     if ((tableEnd < headerEnd) || (m_imgDataOffset && (m_imgDataOffset < tableEnd)))
         return m_parent->setFailed();
 
     // Read color table.
     if ((m_decodedOffset > m_data->size()) || ((m_data->size() - m_decodedOffset) < tableSizeInBytes))
         return false;
     m_colorTable.resize(m_infoHeader.biClrUsed);
     for (size_t i = 0; i < m_infoHeader.biClrUsed; ++i) {
-        m_colorTable[i].rgbBlue = m_data->data()[m_decodedOffset++];
-        m_colorTable[i].rgbGreen = m_data->data()[m_decodedOffset++];
-        m_colorTable[i].rgbRed = m_data->data()[m_decodedOffset++];
+        m_colorTable[i].rgbBlue = getByte(m_decodedOffset++);
+        m_colorTable[i].rgbGreen = getByte(m_decodedOffset++);
+        m_colorTable[i].rgbRed = getByte(m_decodedOffset++);
         // Skip padding byte (not present on OS/2 1.x).
         if (!m_isOS21x)
             ++m_decodedOffset;
     }
 
     // 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_needToProcessColorTable = false;
@@ skipping 29 matching lines @@
     // Impossible to decode row-at-a-time, so just do things as a stream of
     // bytes.
     while (true) {
         // Every entry takes at least two bytes; bail if there isn't enough
         // data.
         if ((m_data->size() - m_decodedOffset) < 2)
             return InsufficientData;
 
         // For every entry except EOF, we'd better not have reached the end of
         // the image.
-        const uint8_t count = m_data->data()[m_decodedOffset];
-        const uint8_t code = m_data->data()[m_decodedOffset + 1];
+        const uint8_t count = getByte(m_decodedOffset);
+        const uint8_t code = getByte(m_decodedOffset + 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);
@@ skipping 13 matching lines @@
                 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 = m_data->data()[m_decodedOffset + 2];
-                const uint8_t dy = m_data->data()[m_decodedOffset + 3];
+                const uint8_t dx = getByte(m_decodedOffset + 2);
+                const uint8_t dy = getByte(m_decodedOffset + 3);
                 if (dx || dy)
                     m_buffer->setHasAlpha(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 19 matching lines @@
             // Strangely, some BMPs seem to specify excessively large counts
             // here; ignore pixels past the end of the row.
             const int endX = std::min(m_coord.x() + count, m_parent->size().width());
 
             if (m_infoHeader.biCompression == RLE24) {
                 // Bail if there isn't enough data.
                 if ((m_data->size() - m_decodedOffset) < 4)
                     return InsufficientData;
 
                 // One BGR triple that we copy |count| times.
-                fillRGBA(endX, m_data->data()[m_decodedOffset + 3], m_data->data()[m_decodedOffset + 2], code, 0xff);
+                fillRGBA(endX, getByte(m_decodedOffset + 3), getByte(m_decodedOffset + 2), code, 0xff);
                 m_decodedOffset += 4;
             } else {
                 // RLE8 has one color index that gets repeated; RLE4 has two
                 // color indexes in the upper and lower 4 bits of the byte,
                 // which are alternated.
                 size_t colorIndexes[2] = {code, code};
                 if (m_infoHeader.biCompression == RLE4) {
                     colorIndexes[0] = (colorIndexes[0] >> 4) & 0xf;
                     colorIndexes[1] &= 0xf;
                 }
@@ skipping 42 matching lines @@
         // Bail if we don't have enough data for the desired number of pixels.
         if ((m_data->size() - m_decodedOffset) < paddedNumBytes)
             return InsufficientData;
 
         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];
+                uint8_t pixelData = getByte(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_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);
@@ skipping 52 matching lines @@
     // Finished decoding whole image.
     return Success;
 }
 
 void BMPImageReader::moveBufferToNextRow()
 {
     m_coord.move(-m_coord.x(), m_isTopDown ? 1 : -1);
 }
 
 } // namespace blink