WIP: Implement APNG

third_party/WebKit/Source/platform/image-decoders/png/PNGImageDecoder.cpp

 /*
  * Copyright (C) 2006 Apple Computer, Inc.
  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
  *
  * Portions are Copyright (C) 2001 mozilla.org
  *
  * Other contributors:
  *   Stuart Parmenter <stuart@mozilla.com>
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 20 matching lines @@
  * licenses (the MPL or the GPL) and not to allow others to use your
  * version of this file under the LGPL, indicate your decision by
  * deletingthe provisions above and replace them with the notice and
  * other provisions required by the MPL or the GPL, as the case may be.
  * If you do not delete the provisions above, a recipient may use your
  * version of this file under any of the LGPL, the MPL or the GPL.
  */
 
 #include "platform/image-decoders/png/PNGImageDecoder.h"
 
-#include "platform/image-decoders/png/PNGImageReader.h"
 #include "png.h"
-#include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
 
 PNGImageDecoder::PNGImageDecoder(AlphaOption alphaOption,
                                  const ColorBehavior& colorBehavior,
                                  size_t maxDecodedBytes,
                                  size_t offset)
     : ImageDecoder(alphaOption, colorBehavior, maxDecodedBytes),
-      m_offset(offset) {}
+      m_reader(this, offset),
+      m_frameCount(0),
+      m_currentFrame(0),
+      m_repetitionCount(cAnimationLoopOnce),
+      m_hasAlphaChannel(false),
+      m_currentBufferSawAlpha(false),
+      m_isParsing(false) {}
 
 PNGImageDecoder::~PNGImageDecoder() {}
 
+bool PNGImageDecoder::setFailed() {
+  // Update the frame count to make sure it reflects the most up to date number
+  // of frames that were parsed. We don't want to set the decoder to the failed
+  // state if the reader was able to successfully parse some frames.
+  if (m_isParsing)
+    m_frameCount = m_reader.frameCount();
+
+  // There are three cases in which the decoder is invalidated:
+  // 1) No frames are received so far.
+  // 2) The image is not animated.
+  // 3) Decoding for the first frame fails.
+  if (m_frameCount == 0 || (m_reader.parseCompleted() && m_frameCount == 1) ||
+      (!m_isParsing && m_currentFrame == 0))
+    return ImageDecoder::setFailed();
+
+  // If decoding fails for later frames, we still want to show earlier frames,
+  // but the frame count needs to be adjusted. We do not want to shrink
+  // |m_frameBufferCache|, since clients may store pointers to later frames.
+  if (!m_isParsing) {
+    m_frameBufferCache[m_currentFrame].clearPixelData();
+    m_frameBufferCache[m_currentFrame].setStatus(ImageFrame::FrameEmpty);
+    m_frameCount = m_currentFrame;
+  }
+
+  // Set parseCompleted to true, so parse() returns early and thus won't update
+  // |m_frameCount| to the pre-failure value when it is called again.
+  m_reader.setParseCompleted();
+  return false;
+}
+
+size_t PNGImageDecoder::decodeFrameCount() {
+  parse(PNGImageReader::PNGParseQuery::PNGMetaDataQuery);
+  return m_frameCount;
+}
+
+void PNGImageDecoder::decode(size_t index) {
+  if (failed())
+    return;
+
+  updateAggressivePurging(index);
+
+  Vector<size_t> framesToDecode = findFramesToDecode(index);
+  for (auto i = framesToDecode.rbegin(); i != framesToDecode.rend(); i++) {
+    m_currentFrame = *i;
+    m_reader.decode(*m_data, *i);
+    if (failed() || !postDecodeProcessing(*i))
+      return;
+  }
+}
+
+void PNGImageDecoder::clearFrameBuffer(size_t frameIndex) {
+  m_reader.clearDecodeState(frameIndex);
+  ImageDecoder::clearFrameBuffer(frameIndex);
+}
+
+void PNGImageDecoder::onInitFrameBuffer(size_t index) {
+  unsigned colorChannels = m_hasAlphaChannel ? 4 : 3;
+  if (PNG_INTERLACE_ADAM7 ==
+      png_get_interlace_type(m_reader.pngPtr(), m_reader.infoPtr())) {
+    m_reader.createInterlaceBuffer(colorChannels * size().width() *
+                                   size().height());
+    if (!m_reader.interlaceBuffer())
+      setFailed();
+  }
+}
+
+bool PNGImageDecoder::canReusePreviousFrameBuffer(size_t frameIndex) const {
+  DCHECK(frameIndex < m_frameBufferCache.size());
+  return m_frameBufferCache[frameIndex].getDisposalMethod() !=
+         ImageFrame::DisposeOverwritePrevious;
+}
+
+void PNGImageDecoder::parse(PNGImageReader::PNGParseQuery query) {
+  if (failed() || m_reader.parseCompleted())
+    return;
+
+  m_isParsing = true;
+  if (!m_reader.parse(*m_data, query) && isAllDataReceived())
+    setFailed();
+  else if (query == PNGImageReader::PNGParseQuery::PNGMetaDataQuery)
+    m_frameCount = m_reader.frameCount();
+
+  m_isParsing = false;
+}
+
+void PNGImageDecoder::setRepetitionCount(size_t repetitionCount) {
+  m_repetitionCount =
+      (repetitionCount == 0) ? cAnimationLoopInfinite : repetitionCount;
+}
+
+// This matches the existing behavior to loop once if decoding fails, but this
+// should be changed to stick with m_repetitionCount to match other browsers.
+// See crbug.com/267883
+int PNGImageDecoder::repetitionCount() const {
+  if (m_reader.parseCompleted() && m_reader.frameCount() == 1)
+    return cAnimationNone;
+  return failed() ? cAnimationLoopOnce : m_repetitionCount;
+}
+
+static inline ImageFrame::DisposalMethod getDisposalMethod(
+    uint8_t disposalMethod) {
+  switch (disposalMethod) {
+    case kAPNGDisposeKeep:
+      return ImageFrame::DisposalMethod::DisposeKeep;
+    case kAPNGDisposeBgcolor:
+      return ImageFrame::DisposalMethod::DisposeOverwriteBgcolor;
+    case kAPNGDisposePrevious:
+      return ImageFrame::DisposalMethod::DisposeOverwritePrevious;
+    default:
+      return ImageFrame::DisposalMethod::DisposeNotSpecified;
+  }
+}
+
+static inline ImageFrame::AlphaBlendSource getAlphaBlend(uint8_t alphaBlend) {
+  if (alphaBlend == kAPNGAlphaBlendPreviousFrame)
+    return ImageFrame::AlphaBlendSource::BlendAtopPreviousFrame;
+  return ImageFrame::AlphaBlendSource::BlendAtopBgcolor;
+}
+
+void PNGImageDecoder::initializeNewFrame(size_t index) {
+  const PNGImageReader::FrameInfo& frameInfo = m_reader.frameInfo(index);
+  ImageFrame* buffer = &m_frameBufferCache[index];
+
+  IntRect frameRectWithinSize =
+      intersection(frameInfo.frameRect, {IntPoint(), size()});
+  buffer->setOriginalFrameRect(frameRectWithinSize);
+  buffer->setDuration(frameInfo.duration);
+  buffer->setDisposalMethod(getDisposalMethod(frameInfo.disposalMethod));
+  buffer->setAlphaBlendSource(getAlphaBlend(frameInfo.alphaBlend));
+  buffer->setRequiredPreviousFrameIndex(
+      findRequiredPreviousFrame(index, false));
+}
+
 inline float pngFixedToFloat(png_fixed_point x) {
   return ((float)x) * 0.00001f;
 }
 
 inline sk_sp<SkColorSpace> readColorSpace(png_structp png, png_infop info) {
   if (png_get_valid(png, info, PNG_INFO_sRGB)) {
     return SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named);
   }
 
   png_charp name = nullptr;
@@ skipping 35 matching lines @@
       // function.  It's possible that we should guess sRGB transfer
       // function, given that unmarked PNGs should be treated as sRGB.
       // However, the current behavior matches Safari and Firefox.
     }
   }
 
   return nullptr;
 }
 
 void PNGImageDecoder::headerAvailable() {
-  png_structp png = m_reader->pngPtr();
-  png_infop info = m_reader->infoPtr();
-  png_uint_32 width = png_get_image_width(png, info);
-  png_uint_32 height = png_get_image_height(png, info);
+  png_structp png = m_reader.pngPtr();
+  png_infop info = m_reader.infoPtr();
 
-  // Protect against large PNGs. See http://bugzil.la/251381 for more details.
-  const unsigned long maxPNGSize = 1000000UL;
-  if (width > maxPNGSize || height > maxPNGSize) {
-    longjmp(JMPBUF(png), 1);
-    return;
-  }
-
-  // Set the image size now that the image header is available.
-  if (!setSize(width, height)) {
-    longjmp(JMPBUF(png), 1);
-    return;
-  }
-
+  png_uint_32 width, height;
   int bitDepth, colorType, interlaceType, compressionType, filterType, channels;
   png_get_IHDR(png, info, &width, &height, &bitDepth, &colorType,
                &interlaceType, &compressionType, &filterType);
 
   // The options we set here match what Mozilla does.
 
   // Expand to ensure we use 24-bit for RGB and 32-bit for RGBA.
   if (colorType == PNG_COLOR_TYPE_PALETTE ||
       (colorType == PNG_COLOR_TYPE_GRAY && bitDepth < 8))
     png_set_expand(png);
 
   png_bytep trns = 0;
   int trnsCount = 0;
   if (png_get_valid(png, info, PNG_INFO_tRNS)) {
     png_get_tRNS(png, info, &trns, &trnsCount, 0);
     png_set_expand(png);
   }
 
   if (bitDepth == 16)
     png_set_strip_16(png);
 
   if (colorType == PNG_COLOR_TYPE_GRAY ||
       colorType == PNG_COLOR_TYPE_GRAY_ALPHA)
     png_set_gray_to_rgb(png);
 
-  if ((colorType & PNG_COLOR_MASK_COLOR) && !ignoresColorSpace()) {
-    // We only support color profiles for color PALETTE and RGB[A] PNG.
-    // Supporting color profiles for gray-scale images is slightly tricky, at
-    // least using the CoreGraphics ICC library, because we expand gray-scale
-    // images to RGB but we do not similarly transform the color profile. We'd
-    // either need to transform the color profile or we'd need to decode into a
-    // gray-scale image buffer and hand that to CoreGraphics.
-    sk_sp<SkColorSpace> colorSpace = readColorSpace(png, info);
-    if (colorSpace) {
-      setEmbeddedColorSpace(colorSpace);
+  // Only set the size and the color space of the image once. Since non-first
+  // frames also use this method, we don't want them to override the size of
+  // the image to the size of their frame rect. Frames also don't specify their
+  // own color space, so we need to set it only once.
+  if (!isDecodedSizeAvailable()) {
+    // Protect against large PNGs. See http://bugzil.la/251381 for more details.
+    const unsigned long maxPNGSize = 1000000UL;
+    if (width > maxPNGSize || height > maxPNGSize) {
+      longjmp(JMPBUF(png), 1);
+      return;
+    }
+
+    // Set the image size now that the image header is available.
+    if (!setSize(width, height)) {
+      longjmp(JMPBUF(png), 1);
+      return;
+    }
+
+    if ((colorType & PNG_COLOR_MASK_COLOR) && !ignoresColorSpace()) {
+      // We only support color profiles for color PALETTE and RGB[A] PNG.
+      // Supporting color profiles for gray-scale images is slightly tricky, at
+      // least using the CoreGraphics ICC library, because we expand gray-scale
+      // images to RGB but we do not similarly transform the color profile. We'd
+      // either need to transform the color profile or we'd need to decode into
+      // a
+      // gray-scale image buffer and hand that to CoreGraphics.
+      sk_sp<SkColorSpace> colorSpace = readColorSpace(png, info);
+      if (colorSpace) {
+        setEmbeddedColorSpace(colorSpace);
+      }
     }
   }
 
   if (!hasEmbeddedColorSpace()) {
     // TODO (msarett):
     // Applying the transfer function (gamma) should be handled by
     // SkColorSpaceXform.  Here we always convert to a transfer function that
     // is a 2.2 exponential.  This is a little strange given that the dst
     // transfer function is not necessarily a 2.2 exponential.
     // TODO (msarett):
@@ skipping 17 matching lines @@
 
   // Tell libpng to send us rows for interlaced pngs.
   if (interlaceType == PNG_INTERLACE_ADAM7)
     png_set_interlace_handling(png);
 
   // Update our info now.
   png_read_update_info(png, info);
   channels = png_get_channels(png, info);
   ASSERT(channels == 3 || channels == 4);
 
-  m_reader->setHasAlpha(channels == 4);
-
-  if (m_reader->decodingSizeOnly()) {
-// If we only needed the size, halt the reader.
-#if PNG_LIBPNG_VER_MAJOR > 1 || \
-    (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR >= 5)
-    // Passing '0' tells png_process_data_pause() not to cache unprocessed data.
-    m_reader->setReadOffset(m_reader->currentBufferSize() -
-                            png_process_data_pause(png, 0));
-#else
-    m_reader->setReadOffset(m_reader->currentBufferSize() - png->buffer_size);
-    png->buffer_size = 0;
-#endif
-  }
+  m_hasAlphaChannel = (channels == 4);
+  m_currentBufferSawAlpha = false;
 }
 
 void PNGImageDecoder::rowAvailable(unsigned char* rowBuffer,
                                    unsigned rowIndex,
                                    int) {
   if (m_frameBufferCache.isEmpty())
     return;
 
-  // Initialize the framebuffer if needed.
-  ImageFrame& buffer = m_frameBufferCache[0];
-  if (buffer.getStatus() == ImageFrame::FrameEmpty) {
-    png_structp png = m_reader->pngPtr();
-    if (!buffer.setSizeAndColorSpace(size().width(), size().height(),
-                                     colorSpaceForSkImages())) {
-      longjmp(JMPBUF(png), 1);
-      return;
-    }
+  // When a client calls ImageDecoder::setMemoryAllocator *before* decoding the
+  // frame count, the first frame won't get initialized correctly. The call will
+  // resize |m_frameBufferCache| to 1, and therefore ImageDecoder::frameCount
+  // will *not* call initializeNewFrame for the first frame, whether it is a
+  // static image or the first frame of an animated image. Amongst others, the
+  // frame rect will not be set. If this is the case, initialize the frame here.
+  if (m_frameBufferCache[0].originalFrameRect().size() == IntSize(0, 0))
+    initializeNewFrame(0);
 
-    unsigned colorChannels = m_reader->hasAlpha() ? 4 : 3;
-    if (PNG_INTERLACE_ADAM7 ==
-        png_get_interlace_type(png, m_reader->infoPtr())) {
-      m_reader->createInterlaceBuffer(colorChannels * size().width() *
-                                      size().height());
-      if (!m_reader->interlaceBuffer()) {
-        longjmp(JMPBUF(png), 1);
-        return;
-      }
-    }
-
-    buffer.setStatus(ImageFrame::FramePartial);
-    buffer.setHasAlpha(false);
-
-    // For PNGs, the frame always fills the entire image.
-    buffer.setOriginalFrameRect(IntRect(IntPoint(), size()));
+  if (!initFrameBuffer(m_currentFrame)) {
+    setFailed();
+    return;
   }
 
+  // This frameRect is already clipped, so that it fits within the size of the
+  // image. This is done in initializeNewFrame() after a frameCount() call.
+  ImageFrame& buffer = m_frameBufferCache[m_currentFrame];
+  const IntRect& frameRect = buffer.originalFrameRect();
+
   /* libpng comments (here to explain what follows).
-     *
-     * this function is called for every row in the image. If the
-     * image is interlacing, and you turned on the interlace handler,
-     * this function will be called for every row in every pass.
-     * Some of these rows will not be changed from the previous pass.
-     * When the row is not changed, the new_row variable will be NULL.
-     * The rows and passes are called in order, so you don't really
-     * need the row_num and pass, but I'm supplying them because it
-     * may make your life easier.
-     */
+   *
+   * this function is called for every row in the image. If the
+   * image is interlacing, and you turned on the interlace handler,
+   * this function will be called for every row in every pass.
+   * Some of these rows will not be changed from the previous pass.
+   * When the row is not changed, the new_row variable will be NULL.
+   * The rows and passes are called in order, so you don't really
+   * need the row_num and pass, but I'm supplying them because it
+   * may make your life easier.
+   */
 
-  // Nothing to do if the row is unchanged, or the row is outside
-  // the image bounds: libpng may send extra rows, ignore them to
-  // make our lives easier.
+  // Nothing to do if the row is unchanged, or the row is outside the image
+  // bounds.  In the case that a frame presents more data than the indicated
+  // frame size, ignore the extra rows and thus use the frame size as the
+  // source of truth. libpng may also send extra rows. Ignore those as well.
+  // This prevents us from trying to write outside of the image bounds.
   if (!rowBuffer)
     return;
-  int y = rowIndex;
-  if (y < 0 || y >= size().height())
+  int y = rowIndex + frameRect.y();
+  DCHECK_GE(y, 0);
+  if (y >= size().height())
     return;
 
   /* libpng comments (continued).
-     *
-     * For the non-NULL rows of interlaced images, you must call
-     * png_progressive_combine_row() passing in the row and the
-     * old row.  You can call this function for NULL rows (it will
-     * just return) and for non-interlaced images (it just does the
-     * memcpy for you) if it will make the code easier. Thus, you
-     * can just do this for all cases:
-     *
-     *    png_progressive_combine_row(png_ptr, old_row, new_row);
-     *
-     * where old_row is what was displayed for previous rows. Note
-     * that the first pass (pass == 0 really) will completely cover
-     * the old row, so the rows do not have to be initialized. After
-     * the first pass (and only for interlaced images), you will have
-     * to pass the current row, and the function will combine the
-     * old row and the new row.
-     */
+   *
+   * For the non-NULL rows of interlaced images, you must call
+   * png_progressive_combine_row() passing in the row and the
+   * old row.  You can call this function for NULL rows (it will
+   * just return) and for non-interlaced images (it just does the
+   * memcpy for you) if it will make the code easier. Thus, you
+   * can just do this for all cases:
+   *
+   *    png_progressive_combine_row(png_ptr, old_row, new_row);
+   *
+   * where old_row is what was displayed for previous rows. Note
+   * that the first pass (pass == 0 really) will completely cover
+   * the old row, so the rows do not have to be initialized. After
+   * the first pass (and only for interlaced images), you will have
+   * to pass the current row, and the function will combine the
+   * old row and the new row.
+   */
 
-  bool hasAlpha = m_reader->hasAlpha();
+  bool hasAlpha = m_hasAlphaChannel;
   png_bytep row = rowBuffer;
 
-  if (png_bytep interlaceBuffer = m_reader->interlaceBuffer()) {
+  if (png_bytep interlaceBuffer = m_reader.interlaceBuffer()) {
     unsigned colorChannels = hasAlpha ? 4 : 3;
     row = interlaceBuffer + (rowIndex * colorChannels * size().width());
-    png_progressive_combine_row(m_reader->pngPtr(), row, rowBuffer);
+    png_progressive_combine_row(m_reader.pngPtr(), row, rowBuffer);
   }
 
   // Write the decoded row pixels to the frame buffer. The repetitive
   // form of the row write loops is for speed.
-  ImageFrame::PixelData* const dstRow = buffer.getAddr(0, y);
+  ImageFrame::PixelData* const dstRow = buffer.getAddr(frameRect.x(), y);
   unsigned alphaMask = 255;
-  int width = size().width();
+  int width = frameRect.width();
 
   png_bytep srcPtr = row;
   if (hasAlpha) {
     // Here we apply the color space transformation to the dst space.
     // It does not really make sense to transform to a gamma-encoded
     // space and then immediately after, perform a linear premultiply.
     // Ideally we would pass kPremul_SkAlphaType to xform->apply(),
     // instructing SkColorSpaceXform to perform the linear premultiply
     // while the pixels are a linear space.
     // We cannot do this because when we apply the gamma encoding after
     // the premultiply, we will very likely end up with valid pixels
     // where R, G, and/or B are greater than A.  The legacy drawing
     // pipeline does not know how to handle this.
     if (SkColorSpaceXform* xform = colorTransform()) {
       SkColorSpaceXform::ColorFormat colorFormat =
           SkColorSpaceXform::kRGBA_8888_ColorFormat;
       xform->apply(colorFormat, dstRow, colorFormat, srcPtr, size().width(),
                    kUnpremul_SkAlphaType);
       srcPtr = (png_bytep)dstRow;
     }
 
-    if (buffer.premultiplyAlpha()) {
-      for (auto *dstPixel = dstRow; dstPixel < dstRow + width;
-           dstPixel++, srcPtr += 4) {
-        buffer.setRGBAPremultiply(dstPixel, srcPtr[0], srcPtr[1], srcPtr[2],
-                                  srcPtr[3]);
-        alphaMask &= srcPtr[3];
+    if (m_frameBufferCache[m_currentFrame].getAlphaBlendSource() ==
+        ImageFrame::BlendAtopBgcolor) {
+      if (buffer.premultiplyAlpha()) {
+        for (auto *dstPixel = dstRow; dstPixel < dstRow + width;
+             dstPixel++, srcPtr += 4) {
+          buffer.setRGBAPremultiply(dstPixel, srcPtr[0], srcPtr[1], srcPtr[2],
+                                    srcPtr[3]);
+          alphaMask &= srcPtr[3];
+        }
+      } else {
+        for (auto *dstPixel = dstRow; dstPixel < dstRow + width;
+             dstPixel++, srcPtr += 4) {
+          buffer.setRGBARaw(dstPixel, srcPtr[0], srcPtr[1], srcPtr[2],
+                            srcPtr[3]);
+          alphaMask &= srcPtr[3];
+        }
       }
     } else {
-      for (auto *dstPixel = dstRow; dstPixel < dstRow + width;
-           dstPixel++, srcPtr += 4) {
-        buffer.setRGBARaw(dstPixel, srcPtr[0], srcPtr[1], srcPtr[2], srcPtr[3]);
-        alphaMask &= srcPtr[3];
+      // Now, the blend method is ImageFrame::BlendAtopPreviousFrame. Since the
+      // frame data of the previous frame is copied at initFrameBuffer, we can
+      // blend the pixel of this frame, stored in |srcPtr|, over the previous
+      // pixel stored in |dstPixel|.
+      if (buffer.premultiplyAlpha()) {
+        for (auto *dstPixel = dstRow; dstPixel < dstRow + width;
+             dstPixel++, srcPtr += 4) {
+          buffer.blendRGBAPremultiplied(dstPixel, srcPtr[0], srcPtr[1],
+                                        srcPtr[2], srcPtr[3]);
+          alphaMask &= srcPtr[3];
+        }
+      } else {
+        for (auto *dstPixel = dstRow; dstPixel < dstRow + width;
+             dstPixel++, srcPtr += 4) {
+          buffer.blendRGBARaw(dstPixel, srcPtr[0], srcPtr[1], srcPtr[2],
+                              srcPtr[3]);
+          alphaMask &= srcPtr[3];
+        }
       }
     }
+
+    if (alphaMask != 255 && !m_currentBufferSawAlpha)
+      m_currentBufferSawAlpha = true;
+
   } else {
     for (auto *dstPixel = dstRow; dstPixel < dstRow + width;
          dstPixel++, srcPtr += 3) {
       buffer.setRGBARaw(dstPixel, srcPtr[0], srcPtr[1], srcPtr[2], 255);
     }
 
     // We'll apply the color space xform to opaque pixels after they have been
     // written to the ImageFrame, purely because SkColorSpaceXform supports
     // RGBA (and not RGB).
     if (SkColorSpaceXform* xform = colorTransform()) {
       xform->apply(xformColorFormat(), dstRow, xformColorFormat(), dstRow,
                    size().width(), kOpaque_SkAlphaType);
     }
   }
 
-  if (alphaMask != 255 && !buffer.hasAlpha())
-    buffer.setHasAlpha(true);
+  buffer.setPixelsChanged(true);
+}
 
-  buffer.setPixelsChanged(true);
+bool PNGImageDecoder::frameIsCompleteAtIndex(size_t index) const {
+  // For non-animated images, return whether the status of the frame is
+  // ImageFrame::FrameComplete through ImageDecoder::frameIsCompleteAtIndex.
+  // We only know that the frame is fully received when it is successfully
+  // decoded, since there is no explicit check whether the IEND chunk has been
+  // received.
+  if (index == 0 && m_reader.parseCompleted() && m_frameCount == 1)
+    return ImageDecoder::frameIsCompleteAtIndex(index);
+
+  // For first frames of animated images, PNGImageReader exposes whether it is
+  // fully received through firstFrameFullyReceived().  Non-first frames are
+  // reported by |m_reader| once it has parsed all data for that frame, so we
+  // can simply return if the index is below the reported frame count. We have
+  // to use |m_frameCount| here, and not |m_frameBufferCache|.size(), since
+  // |m_frameCount| gets adjusted when decoding or parsing fails, but
+  // |m_frameBufferCache| does not, as explained above at
+  // PNGImageDecoder::setFailed().
+  if (index == 0)
+    return m_reader.firstFrameFullyReceived();
+  return (index < m_frameCount);
+}
+
+float PNGImageDecoder::frameDurationAtIndex(size_t index) const {
+  return (index < m_frameCount ? m_frameBufferCache[index].duration() : 0);
 }
 
 void PNGImageDecoder::complete() {
   if (m_frameBufferCache.isEmpty())
     return;
 
-  m_frameBufferCache[0].setStatus(ImageFrame::FrameComplete);
-}
+  // We don't know for sure at this point if we've received enough pixels to
+  // completely fill the frame. This is not taken into account. The error could
+  // be in the indicated frame size, or in the frame data chunks.
+  //
+  // If the frame size is wrong, we could correct for that, but later frames
+  // may depend on this frame's size when they're initialized in
+  // initFrameBuffer(), in the case the disposal method of this frame is
+  // DisposeOverwriteBgColor. There is no informed decision that can be made
+  // about what the author intended, so we stay with the indicated frame size.
+  //
+  // In the case the data chunk is too small, there's not much we can do. This
+  // method only gets called when the frame end has been received, so the
+  // encoder indicated that all frame data is received. It could be an encoding
+  // error, or it may be an intentional file size reduction.
+  //
+  // Therefore, the frame size and pixels that aren't decoded are left as-is.
 
-inline bool isComplete(const PNGImageDecoder* decoder) {
-  return decoder->frameIsCompleteAtIndex(0);
-}
+  if (m_reader.interlaceBuffer())
+    m_reader.clearInterlaceBuffer();
 
-void PNGImageDecoder::decode(bool onlySize) {
-  if (failed())
-    return;
+  ImageFrame& buffer = m_frameBufferCache[m_currentFrame];
+  buffer.setStatus(ImageFrame::FrameComplete);
 
-  if (!m_reader)
-    m_reader = WTF::makeUnique<PNGImageReader>(this, m_offset);
-
-  // If we couldn't decode the image but have received all the data, decoding
-  // has failed.
-  if (!m_reader->decode(*m_data, onlySize) && isAllDataReceived())
-    setFailed();
-
-  // If decoding is done or failed, we don't need the PNGImageReader anymore.
-  if (isComplete(this) || failed())
-    m_reader.reset();
+  if (!m_currentBufferSawAlpha)
+    correctAlphaWhenFrameBufferSawNoAlpha(m_currentFrame);
 }
 
 }  // namespace blink