Pull up initFrameBuffer to ImageDecoder.

third_party/WebKit/Source/platform/image-decoders/webp/WEBPImageDecoder.cpp

 /*
  * Copyright (C) 2010 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:
  *
  * 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
@@ skipping 220 matching lines @@
 
   ASSERT(isDecodedSizeAvailable());
 
   size_t frameCount = WebPDemuxGetI(m_demux, WEBP_FF_FRAME_COUNT);
   updateAggressivePurging(frameCount);
 
   return true;
 }
 
 bool WEBPImageDecoder::initFrameBuffer(size_t frameIndex) {
+  // ImageDecoder::initFrameBuffer does a DCHECK if |frameIndex| exists.
+  if (!ImageDecoder::initFrameBuffer(frameIndex))
+    return false;
+
   ImageFrame& buffer = m_frameBufferCache[frameIndex];
-  if (buffer.getStatus() != ImageFrame::FrameEmpty)  // Already initialized.
-    return true;
 
   const 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();
     m_frameBackgroundHasAlpha =
         !buffer.originalFrameRect().contains(IntRect(IntPoint(), size()));
   } else {
-    ImageFrame& prevBuffer = m_frameBufferCache[requiredPreviousFrameIndex];
-    ASSERT(prevBuffer.getStatus() == ImageFrame::FrameComplete);
-
-    // Preserve the last frame as the starting state for this frame. We try
-    // to reuse |prevBuffer| as starting state to avoid copying.
-    // For BlendAtopPreviousFrame, both frames are required, so we can't
-    // take over its image data using takeBitmapDataIfWritable.
-    if ((buffer.getAlphaBlendSource() == ImageFrame::BlendAtopPreviousFrame ||
-         !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);
-    }
-
+    const ImageFrame& prevBuffer =
+        m_frameBufferCache[requiredPreviousFrameIndex];
     m_frameBackgroundHasAlpha =
         prevBuffer.hasAlpha() ||
         (prevBuffer.getDisposalMethod() == ImageFrame::DisposeOverwriteBgcolor);
   }
 
-  buffer.setStatus(ImageFrame::FramePartial);
   // The buffer is transparent outside the decoded area while the image is
   // loading. The correct alpha value for the frame will be set when it is fully
   // decoded.
   buffer.setHasAlpha(true);
   return true;
 }
 
+bool WEBPImageDecoder::canReusePreviousFrameBuffer(size_t frameIndex) const {
+  DCHECK(frameIndex < m_frameBufferCache.size());
+  return m_frameBufferCache[frameIndex].getAlphaBlendSource() !=
+         ImageFrame::BlendAtopPreviousFrame;
+}
+
 size_t WEBPImageDecoder::clearCacheExceptFrame(size_t clearExceptFrame) {
   // If |clearExceptFrame| has status FrameComplete, we preserve that frame.
   // Otherwise, we preserve the most recent previous frame with status
   // FrameComplete whose data will be required to decode |clearExceptFrame|,
   // either in initFrameBuffer() or ApplyPostProcessing(). All other frames can
   // be cleared.
   while ((clearExceptFrame < m_frameBufferCache.size()) &&
          (m_frameBufferCache[clearExceptFrame].getStatus() !=
           ImageFrame::FrameComplete))
     clearExceptFrame =
@@ skipping 257 matching lines @@
         return false;
       }
     // FALLTHROUGH
     default:
       clear();
       return setFailed();
   }
 }
 
 }  // namespace blink