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 22 matching lines @@
  * 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,
                                  ColorSpaceOption colorOptions,
                                  sk_sp<SkColorSpace> targetColorSpace,
                                  size_t maxDecodedBytes,
                                  size_t offset)
-    : ImageDecoder(alphaOption,
-                   colorOptions,
-                   std::move(targetColorSpace),
+    : ImageDecoder(alphaOption, colorOptions, std::move(targetColorSpace),
                    maxDecodedBytes),
-      m_offset(offset) {}
+      m_frameCount(0),
+      m_currentFrame(0),
+      m_repetitionCount(cAnimationLoopOnce),
+      m_hasAlphaChannel(false),
+      m_currentBufferSawAlpha(false),
+      m_isParsing(false)
+{
+  m_reader = wrapUnique(new PNGImageReader(this, offset));

[scroggo_chromium, 2016/12/08 13:59:09]

Now that m_reader has the same lifetime as PNGImageDecoder, why not make it a
full member, instead of holding a pointer to it?

[joostouwerling, 2016/12/08 16:28:39]

That's difficult since they cross reference each other, so you can't include
each others header files. PNGImageReader uses PNGImageDecoder as a pointer but I
can't forward declare it since it specifies PNGImageDecoder::PNGParseQuery in
the header file. 

[scroggo_chromium, 2016/12/08 16:33:25]

What about if you move PNGParseQuery to PNGImageReader? That is probably more
appropriate anyway.

[joostouwerling, 2016/12/08 21:33:20]

Done.

+}
 
 PNGImageDecoder::~PNGImageDecoder() {}
 
+bool PNGImageDecoder::setFailed() {
+  // Update the frame count to make sure it reflects the most up to date number
+  // of frames there were parsed. We don't want to set the decoder to the failed

[scroggo_chromium, 2016/12/08 13:59:09]

nit: I think this sounds better if you switch "there" to "that"

[joostouwerling, 2016/12/08 16:28:39]

Done.

+  // 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(true);
+  return false;
+}
+
+size_t PNGImageDecoder::decodeFrameCount() {
+  parse(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);
+  m_frameBufferCache[frameIndex].clearPixelData();

[scroggo_chromium, 2016/12/08 13:59:09]

For consistency with the other decoders, you might call
ImageDecoder::clearFrameBuffer(frameIndex) instead of this call. It does the
exact same thing. I don't have a strong preference though.

[joostouwerling, 2016/12/08 16:28:39]

Calling ImageDecoder::clearFrameBuffer may be the better option, in the case
code or requirements change later on, so we don't need to make modifications in
multiple places.

+}
+
+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(PNGParseQuery query) {
+  if (failed() || m_reader->parseCompleted())
+    return;
+
+  m_isParsing = true;
+  if (!m_reader->parse(*m_data, query) && isAllDataReceived())
+    setFailed();
+  else if (query == 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;
+}
+
+// These are mapped according to:
+// https://wiki.mozilla.org/APNG_Specification#.60fcTL.60:_The_Frame_Control_Chunk
+static inline ImageFrame::DisposalMethod getDisposalMethod(
+    uint8_t disposalMethod) {
+  switch (disposalMethod) {
+    case 0:
+      return ImageFrame::DisposalMethod::DisposeKeep;
+    case 1:
+      return ImageFrame::DisposalMethod::DisposeOverwriteBgcolor;
+    case 2:
+      return ImageFrame::DisposalMethod::DisposeOverwritePrevious;
+    default:
+      return ImageFrame::DisposalMethod::DisposeNotSpecified;
+  }
+}
+
+// These are mapped according to:
+// https://wiki.mozilla.org/APNG_Specification#.60fcTL.60:_The_Frame_Control_Chunk
+static inline ImageFrame::AlphaBlendSource getAlphaBlend(uint8_t alphaBlend) {
+  if (alphaBlend == 1)
+    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 37 matching lines @@
       // 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);
 
-  // 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;
-    }
-
-    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()) {
     unsigned colorChannels = hasAlpha ? 4 : 3;
     row = interlaceBuffer + (rowIndex * colorChannels * size().width());
     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;
+    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 {
+  if (failed())

[scroggo_chromium, 2016/12/08 13:59:09]

I just noticed that the other implementations do not check for failure, although
GIF indirectly checks for it (it checks whether it has an m_reader, which it
deletes in setFailed). Why is this one different?

[joostouwerling, 2016/12/08 16:28:39]

I'm not entirely sure why it was there in the first place, and I don't think it
is necessary. The implementation in the base class does not check for failed(),
and since the current implementation of setFailed only invalidates the decoder
when the image is not animated or when there are no frames to show, this is
check has merely the same effect.

That is, ImageDecoder::frameIsCompleteAtIndex only returns false when the frame
is not successfully decoded, and if that happens through a failure, it would
also return false. But since we're already calling
ImageDecoder::frameIsCompleteAtIndex for non-animated images, the net effect is
equivalent when failed() returns true.

+    return false;
+
+  // 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 = 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