Pull up initFrameBuffer to ImageDecoder.

third_party/WebKit/Source/platform/image-decoders/ImageDecoder.h

 /*
  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
  * Copyright (C) Research In Motion Limited 2009-2010. 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 283 matching lines @@
 
   virtual void clearFrameBuffer(size_t frameIndex);
 
   // Decodes the image sufficiently to determine the image size.
   virtual void decodeSize() = 0;
 
   // Decodes the image sufficiently to determine the number of frames and
   // returns that number.
   virtual size_t decodeFrameCount() { return 1; }
 
+  // Called to initialize the frame buffer with the given index, based on the
+  // provided and previous frame's characteristics. Returns true on success. On
+  // failure, this will mark the image as failed. Before calling this method,
+  // the caller must verify that the frame exists.
+  bool initFrameBuffer(size_t);
+
   // Performs any additional setup of the requested frame after it has been
   // initially created, e.g. setting a duration or disposal method.
   virtual void initializeNewFrame(size_t) {}
 
   // Decodes the requested frame.
   virtual void decode(size_t) = 0;
 
   RefPtr<SegmentReader> m_data;  // The encoded data.
   Vector<ImageFrame, 1> m_frameBufferCache;
   const bool m_premultiplyAlpha;
@@ skipping 20 matching lines @@
   static SniffResult determineImageType(const char* data, size_t length);
 
   // Some code paths compute the size of the image as "width * height * 4"
   // and return it as a (signed) int.  Avoid overflow.
   static bool sizeCalculationMayOverflow(unsigned width, unsigned height) {
     unsigned long long total_size = static_cast<unsigned long long>(width) *
                                     static_cast<unsigned long long>(height);
     return total_size > ((1 << 29) - 1);
   }
 
+  // This methods gets called at the end of initFrameBuffer. Subclasses can do
+  // format specific initialization, for e.g. alpha settings, here.
+  virtual void onInitFrameBuffer(size_t){};
+
+  // Called by initFrameBuffer to determine if it can take the bitmap of the
+  // previous frame. This condition is different for GIF and WEBP.
+  virtual bool canReusePreviousFrameBuffer(size_t) const { return false; }

[scroggo_chromium, 2016/11/14 16:44:12]

I think this will only get called by WEBP, GIF, and PNG (once you add it), all
of which will override this. So a default implementation may not matter (we need
to pick one, since the others won't implement it), but my expectation would be
that the default returns true. (I guess false is safer, in some sense, so maybe
this is better as is.)

[joostouwerling, 2016/11/14 16:54:13]

I picked false for the last reason you mentioned. We could pick the GIF
condition since it is shared by both GIF and APNG but I think it is better to
explicitly state the condition in the specific decoder, with a comment
explaining why. 

+
   IntSize m_size;
   bool m_sizeAvailable = false;
   bool m_isAllDataReceived = false;
   bool m_failed = false;
 
   sk_sp<SkColorSpace> m_embeddedColorSpace = nullptr;
   std::unique_ptr<SkColorSpaceXform> m_sourceToOutputDeviceColorTransform;
 };
 
 }  // namespace blink
 
 #endif