Pull up initFrameBuffer to ImageDecoder.

third_party/WebKit/Source/platform/image-decoders/gif/GIFImageDecoder.cpp

 /*
  * Copyright (C) 2006 Apple Computer, 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 114 matching lines @@
           ? frameContext->localColorMap().getTable()
           : m_reader->globalColorMap().getTable();
 
   if (colorTable.isEmpty())
     return true;
 
   GIFColorMap::Table::const_iterator colorTableIter = colorTable.begin();
 
   // Initialize the frame if necessary.
   ImageFrame& buffer = m_frameBufferCache[frameIndex];
-  if ((buffer.getStatus() == ImageFrame::FrameEmpty) &&
-      !initFrameBuffer(frameIndex))
+  if (!initFrameBuffer(frameIndex))
     return false;
 
   const size_t transparentPixel = frameContext->transparentPixel();
   GIFRow::const_iterator rowEnd = rowBegin + (xEnd - xBegin);
   ImageFrame::PixelData* currentAddress = buffer.getAddr(xBegin, yBegin);
 
   // We may or may not need to write transparent pixels to the buffer.
   // If we're compositing against a previous image, it's wrong, and if
   // we're writing atop a cleared, fully transparent buffer, it's
   // unnecessary; but if we're decoding an interlaced gif and
@@ skipping 36 matching lines @@
 }
 
 bool GIFImageDecoder::parseCompleted() const {
   return m_reader && m_reader->parseCompleted();
 }
 
 bool GIFImageDecoder::frameComplete(size_t frameIndex) {
   // Initialize the frame if necessary.  Some GIFs insert do-nothing frames,
   // in which case we never reach haveDecodedRow() before getting here.
   ImageFrame& buffer = m_frameBufferCache[frameIndex];
-  if ((buffer.getStatus() == ImageFrame::FrameEmpty) &&
-      !initFrameBuffer(frameIndex))
+  if (!initFrameBuffer(frameIndex))
     return false;  // initFrameBuffer() has already called setFailed().
 
   buffer.setStatus(ImageFrame::FrameComplete);
 
   if (!m_currentBufferSawAlpha) {
     // The whole frame was non-transparent, so it's possible that the entire
     // resulting buffer was non-transparent, and we can setHasAlpha(false).
     if (buffer.originalFrameRect().contains(IntRect(IntPoint(), size()))) {
       buffer.setHasAlpha(false);
       buffer.setRequiredPreviousFrameIndex(kNotFound);
@@ skipping 151 matching lines @@
   if (!m_reader) {
     m_reader = wrapUnique(new GIFImageReader(this));
     m_reader->setData(m_data);
   }
 
   if (!m_reader->parse(query))
     setFailed();
 }
 
 bool GIFImageDecoder::initFrameBuffer(size_t frameIndex) {
-  // Initialize the frame rect in our buffer.
-  ImageFrame* const buffer = &m_frameBufferCache[frameIndex];
+  // ImageDecoder::initFrameBuffer does a DCHECK if |frameIndex| exists.
+  if (!ImageDecoder::initFrameBuffer(frameIndex))

[scroggo_chromium, 2016/11/14 13:51:46]

Since all of the overrides first call ImageDecoder::initFrameBuffer, you could
instead make a separate virtual method:

virtual void ImageDecoder::onInitFrameBuffer(size_t index)
{
  // empty. subclasses will do alpha stuff.
}

(non-virtual) bool ImageDecoder::initFrameBuffer(size_t index)
{
  // ... Same thing it does now
  // possibly return false in here somewhere

  onInitFrameBuffer(size_t frameIndex);
  return true;
}

[joostouwerling, 2016/11/14 16:25:10]

Good suggestion! Done.

+    return false;
 
-  size_t requiredPreviousFrameIndex = buffer->requiredPreviousFrameIndex();
-  if (requiredPreviousFrameIndex == kNotFound) {
-    // This frame doesn't rely on any previous data.
-    if (!buffer->setSizeAndColorSpace(size().width(), size().height(),
-                                      colorSpace())) {
-      return setFailed();
-    }
-  } else {
-    ImageFrame* prevBuffer = &m_frameBufferCache[requiredPreviousFrameIndex];
-    ASSERT(prevBuffer->getStatus() == ImageFrame::FrameComplete);
-
-    // We try to reuse |prevBuffer| as starting state to avoid copying.
-    // For DisposeOverwritePrevious, the next frame will also use
-    // |prevBuffer| as its starting state, so we can't take over its image
-    // data using takeBitmapDataIfWritable.  Copy the data instead.
-    if ((buffer->getDisposalMethod() == ImageFrame::DisposeOverwritePrevious ||
-         !buffer->takeBitmapDataIfWritable(prevBuffer)) &&
-        !buffer->copyBitmapData(*prevBuffer))
-      return setFailed();
-
-    if (prevBuffer->getDisposalMethod() ==
-        ImageFrame::DisposeOverwriteBgcolor) {
-      // We want to clear the previous frame to transparent, without
-      // affecting pixels in the image outside of the frame.
-      const IntRect& prevRect = prevBuffer->originalFrameRect();
-      ASSERT(!prevRect.contains(IntRect(IntPoint(), size())));
-      buffer->zeroFillFrameRect(prevRect);
-    }
-  }
-
-  // Update our status to be partially complete.
-  buffer->setStatus(ImageFrame::FramePartial);
-
-  // Reset the alpha pixel tracker for this frame.
   m_currentBufferSawAlpha = false;
   return true;
 }
+
+bool GIFImageDecoder::canReusePreviousFrameBuffer(size_t frameIndex) const {
+  DCHECK(frameIndex < m_frameBufferCache.size());
+  return m_frameBufferCache[frameIndex].getDisposalMethod() !=
+         ImageFrame::DisposeOverwritePrevious;
+}
+
 }  // namespace blink