Reland again "Decode GIF image frames on demand".

Source/core/platform/image-decoders/gif/GIFImageReader.cpp

 /* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
  * 1.1 (the "License"); you may not use this file except in compliance with
  * the License. You may obtain a copy of the License at
  * http://www.mozilla.org/MPL/
  *
  * Software distributed under the License is distributed on an "AS IS" basis,
@@ skipping 333 matching lines @@
 
     // If this frame is data complete then the previous loop must have completely decoded all LZW blocks.
     // There will be no more decoding for this frame so it's time to cleanup.
     if (isComplete()) {
         *frameDecoded = true;
         m_lzwContext.clear();
     }
     return true;
 }
 
-// Decode all frames before haltAtFrame.
-// This method uses GIFFrameContext:decode() to decode each frame; decoding error is reported to client as a critical failure.
+// Decode a frame.
+// This method uses GIFFrameContext:decode() to decode the frame; decoding error is reported to client as a critical failure.
 // Return true if decoding has progressed. Return false if an error has occurred.
-bool GIFImageReader::decode(GIFImageDecoder::GIFQuery query, unsigned haltAtFrame)
+bool GIFImageReader::decode(size_t frameIndex)
+{
+    bool frameDecoded = false;
+    GIFFrameContext* currentFrame = m_frames[frameIndex].get();
+
+    return currentFrame->decode(data(0), m_data->size(), m_client, &frameDecoded)
+        && (!frameDecoded || m_client->frameComplete(frameIndex));
+}
+
+bool GIFImageReader::parse(GIFImageDecoder::GIFParseQuery query)
 {
     ASSERT(m_bytesRead <= m_data->size());
 
-    if (!parse(m_bytesRead, m_data->size() - m_bytesRead, query == GIFImageDecoder::GIFSizeQuery))
-        return false;
-
-    if (query != GIFImageDecoder::GIFFullQuery)
-        return true;
-
-    while (m_currentDecodingFrame < std::min(m_frames.size(), static_cast<size_t>(haltAtFrame))) {
-        bool frameDecoded = false;
-        GIFFrameContext* currentFrame = m_frames[m_currentDecodingFrame].get();
-
-        if (!currentFrame->decode(data(0), m_data->size(), m_client, &frameDecoded))
-            return false;
-
-        // We need more data to continue decoding.
-        if (!frameDecoded)
-            break;
-
-        if (!m_client->frameComplete(m_currentDecodingFrame, currentFrame->delayTime, currentFrame->disposalMethod))
-            return false;
-        ++m_currentDecodingFrame;
-    }
-
-    // All frames decoded.
-    if (m_currentDecodingFrame == m_frames.size() && m_parseCompleted)
-        m_client->gifComplete();
-    return true;
+    return parseData(m_bytesRead, m_data->size() - m_bytesRead, query);
 }
 
 // Parse incoming GIF data stream into internal data structures.
 // Return true if parsing has progressed or there is not enough data.
 // Return false if a fatal error is encountered.
-bool GIFImageReader::parse(size_t dataPosition, size_t len, bool parseSizeOnly)
+bool GIFImageReader::parseData(size_t dataPosition, size_t len, GIFImageDecoder::GIFParseQuery query)
 {
     if (!len) {
         // No new data has come in since the last call, just ignore this call.
         return true;
     }
 
     if (len < m_bytesToConsume)
         return true;
 
     // This loop reads as many components from |m_data| as possible.
@@ skipping 40 matching lines @@
             // individual images can be smaller than the screen size and located with an origin anywhere
             // within the screen.
             m_screenWidth = GETINT16(currentComponent);
             m_screenHeight = GETINT16(currentComponent + 2);
 
             // CALLBACK: Inform the decoderplugin of our size.
             // Note: A subsequent frame might have dimensions larger than the "screen" dimensions.
             if (m_client && !m_client->setSize(m_screenWidth, m_screenHeight))
                 return false;
 
-            m_screenBgcolor = currentComponent[5];
             m_globalColormapSize = 2 << (currentComponent[4] & 0x07);
 
             if ((currentComponent[4] & 0x80) && m_globalColormapSize > 0) { /* global map */
                 // Get the global colormap
                 const size_t globalColormapBytes = 3 * m_globalColormapSize;
                 m_globalColormapPosition = dataPosition;
 
                 if (len < globalColormapBytes) {
                     // Wait until we have enough bytes to consume the entire colormap at once.
                     GETN(globalColormapBytes, GIFGlobalColormap);
@@ skipping 204 matching lines @@
             }
 
             // Work around more broken GIF files that have zero image width or height
             if (!height || !width) {
                 height = m_screenHeight;
                 width = m_screenWidth;
                 if (!height || !width)
                     return false;
             }
 
-            if (parseSizeOnly) {
+            if (query == GIFImageDecoder::GIFSizeQuery) {
                 // The decoder needs to stop. Hand back the number of bytes we consumed from
                 // buffer minus 9 (the amount we consumed to read the header).
                 setRemainingBytes(len + 9);
                 GETN(9, GIFImageHeader);
                 return true;
             }
 
             addFrameIfNecessary();
             GIFFrameContext* currentFrame = m_frames.last().get();
 
@@ skipping 126 matching lines @@
     rowPosition = 0;
     rowsRemaining = m_frameContext->height;
 
     // Clearing the whole suffix table lets us be more tolerant of bad data.
     suffix.fill(0);
     for (int i = 0; i < clearCode; i++)
         suffix[i] = i;
     stackp = 0;
     return true;
 }