Pull up clearCacheExceptFrame 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 224 matching lines @@
   // many callers want to return false after calling this), returns false
   // to enable easy tailcalling.  Subclasses may override this to also
   // clean up any local data.
   virtual bool setFailed() {
     m_failed = true;
     return false;
   }
 
   bool failed() const { return m_failed; }
 
-  // Clears decoded pixel data from all frames except the provided frame.
+  // Clears decoded pixel data from all frames except the provided frame. If
+  // subsequent frames depend on this frame's required previous frame, then that
+  // frame is also kept in cache to prevent re-decoding from the beginning.
   // Callers may pass WTF::kNotFound to clear all frames.
   // Note: If |m_frameBufferCache| contains only one frame, it won't be cleared.
   // Returns the number of bytes of frame data actually cleared.
+  //
+  // This is a virtual method because MockImageDecoder needs to override it in
+  // order to run the test ImageFrameGenerator::clearMultiFrameDecode.

[scroggo_chromium, 2016/12/01 14:44:07]

Instead of making this virtual, how about making MockImageDecoder override
clearFrameBuffer? MockImageDecoder will have to be a little more complicated;
instead of reporting the index passed to clearCacheExceptFrame, you'll need to
keep track of all the frames that were cleared. But that's probably what we care
about more anyway.

[joostouwerling, 2016/12/01 15:05:06]

Sgtm but I propose to do that in a different CL. In that way, we can keep this
CL a pure refactor and change the behavior of the clearMultiFrameDecode test in
another CL.

[scroggo_chromium, 2016/12/01 15:08:00]

Okay by me, but can you add a TODO? The danger in leaving it to the next CL is
that we might forget about it.

[joostouwerling, 2016/12/01 15:25:21]

Done.

   virtual size_t clearCacheExceptFrame(size_t);
 
   // If the image has a cursor hot-spot, stores it in the argument
   // and returns true. Otherwise returns false.
   virtual bool hotSpot(IntPoint&) const { return false; }
 
   virtual void setMemoryAllocator(SkBitmap::Allocator* allocator) {
     // FIXME: this doesn't work for images with multiple frames.
     if (m_frameBufferCache.isEmpty()) {
       m_frameBufferCache.resize(1);
@@ skipping 85 matching lines @@
   // this limit can cause excessive memory use or even crashes on low-
   // memory devices.
   const size_t m_maxDecodedBytes;
 
   // While decoding, we may learn that there are so many animation frames that
   // we would go beyond our cache budget.
   // If that happens, m_purgeAggressively is set to true. This signals
   // future decodes to purge old frames as it goes.
   void updateAggressivePurging(size_t index);
 
+  // The method is only relevant for multi-frame images.
+  //
+  // This method indicates whether the provided frame has enough data to decode
+  // successive frames that depend on it. It is used by clearCacheExceptFrame
+  // to determine which frame to keep in cache when the indicated frame is not
+  // yet sufficiently decoded.
+  //
+  // The default condition is that the frame status needs to be FramePartial or
+  // FrameComplete, since the data of previous frames is copied in
+  // initFrameBuffer() before setting the status to FramePartial. For WebP,
+  // however, the status needs to be FrameComplete since the complete buffer is
+  // used to do alpha blending in WEBPImageDecoder::applyPostProcessing().
+  //
+  // Before calling this, verify that frame |index| exists by checking that
+  // |index| is smaller than |m_frameBufferCache|.size().
+  virtual bool frameStatusSufficientForSuccessors(size_t index) {
+    DCHECK(index < m_frameBufferCache.size());
+    return m_frameBufferCache[index].getStatus() != ImageFrame::FrameEmpty;
+  }
+
  private:
   enum class SniffResult { JPEG, PNG, GIF, WEBP, ICO, BMP, Invalid };
 
   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);
@@ skipping 18 matching lines @@
 
   sk_sp<SkColorSpace> m_targetColorSpace = nullptr;
   sk_sp<SkColorSpace> m_embeddedColorSpace = nullptr;
   bool m_sourceToTargetColorTransformNeedsUpdate = false;
   std::unique_ptr<SkColorSpaceXform> m_sourceToTargetColorTransform;
 };
 
 }  // namespace blink
 
 #endif