Pull up clearCacheExceptFrame to ImageDecoder.

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

 /*
  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Library General Public
  *  License as published by the Free Software Foundation; either
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 198 matching lines @@
 
   return ImageSize(frameSizeAtIndex(index)).area *
          sizeof(ImageFrame::PixelData);
 }
 
 size_t ImageDecoder::clearCacheExceptFrame(size_t clearExceptFrame) {
   // Don't clear if there are no frames or only one frame.
   if (m_frameBufferCache.size() <= 1)
     return 0;
 
-  return clearCacheExceptTwoFrames(clearExceptFrame, kNotFound);
+  // We expect that after this call, we'll be asked to decode frames after this
+  // one. So we want to avoid clearing frames such that those requests would
+  // force re-decoding from the beginning of the image. There are two cases in
+  // which preserving |clearCacheExcept| frame is not enough to avoid that:
+  //
+  // 1. |clearExceptFrame| is not yet sufficiently decoded to decode subsequent
+  //    frames. We need the previous frame to sufficiently decode this frame.
+  // 2. The disposal method of |clearExceptFrame| is DisposeOverwritePrevious.
+  //    In that case, we need to keep the required previous frame in the cache
+  //    to prevent re-decoding that frame when |clearExceptFrame| is disposed.
+  //
+  // If either 1 or 2 is true, store the required previous frame in
+  // |clearExceptFrame2| so it won't be cleared.
+  size_t clearExceptFrame2 = kNotFound;
+  if (clearExceptFrame < m_frameBufferCache.size()) {
+    const ImageFrame& frame = m_frameBufferCache[clearExceptFrame];
+    if (!frameStatusSufficientForSuccessors(clearExceptFrame) ||
+        frame.getDisposalMethod() == ImageFrame::DisposeOverwritePrevious)
+      clearExceptFrame2 = frame.requiredPreviousFrameIndex();
+  }
+
+  // Now |clearExceptFrame2| indicates the frame that |clearExceptFrame|
+  // depends on, as described above. But if decoding is skipping forward past
+  // intermediate frames, this frame may be insufficiently decoded. So we need
+  // to keep traversing back through the required previous frames until we find
+  // the nearest ancestor that is sufficiently decoded. Preserving that will
+  // minimize the amount of future decoding needed.
+  while (clearExceptFrame2 < m_frameBufferCache.size() &&
+         !frameStatusSufficientForSuccessors(clearExceptFrame2)) {
+    clearExceptFrame2 =
+        m_frameBufferCache[clearExceptFrame2].requiredPreviousFrameIndex();
+  }
+
+  return clearCacheExceptTwoFrames(clearExceptFrame, clearExceptFrame2);
 }
 
 size_t ImageDecoder::clearCacheExceptTwoFrames(size_t clearExceptFrame1,
                                                size_t clearExceptFrame2) {
   size_t frameBytesCleared = 0;
   for (size_t i = 0; i < m_frameBufferCache.size(); ++i) {
     if (m_frameBufferCache[i].getStatus() != ImageFrame::FrameEmpty &&
         i != clearExceptFrame1 && i != clearExceptFrame2) {
       frameBytesCleared += frameBytesAtIndex(i);
       clearFrameBuffer(i);
@@ skipping 277 matching lines @@
                            m_targetColorSpace.get())) {
     return nullptr;
   }
 
   m_sourceToTargetColorTransform = SkColorSpaceXform::New(
       m_embeddedColorSpace.get(), m_targetColorSpace.get());
   return m_sourceToTargetColorTransform.get();
 }
 
 }  // namespace blink