Reland again "Decode GIF image frames on demand".

Source/core/platform/graphics/BitmapImage.cpp

 /*
  * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2008 Apple 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 94 matching lines @@
 {
     return true;
 }
 
 bool BitmapImage::hasSingleSecurityOrigin() const
 {
     return true;
 }
 
 
-void BitmapImage::destroyDecodedData(bool destroyAll)
+void BitmapImage::destroyDecodedData()
 {
-    unsigned frameBytesCleared = 0;
-    const size_t clearBeforeFrame = destroyAll ? m_frames.size() : m_currentFrame;
-
-    // Because we can advance frames without always needing to decode the actual
-    // bitmap data, |m_currentFrame| may be larger than m_frames.size();
-    // make sure not to walk off the end of the container in this case.
-    for (size_t i = 0; i < std::min(clearBeforeFrame, m_frames.size()); ++i) {
+    for (size_t i = 0; i < m_frames.size(); ++i) {
         // The underlying frame isn't actually changing (we're just trying to
         // save the memory for the framebuffer data), so we don't need to clear
         // the metadata.
-        unsigned frameBytes = m_frames[i].m_frameBytes;
-        if (m_frames[i].clear(false))
-            frameBytesCleared += frameBytes;
+        m_frames[i].clear(false);
     }
 
-    destroyMetadataAndNotify(frameBytesCleared);
-
-    m_source.clear(destroyAll, clearBeforeFrame, data(), m_allDataReceived);
-    return;
+    destroyMetadataAndNotify(m_source.clearCacheExceptFrame(m_currentFrame));
 }
 
-void BitmapImage::destroyDecodedDataIfNecessary(bool destroyAll)
+void BitmapImage::destroyDecodedDataIfNecessary()
 {
     // Animated images >5MB are considered large enough that we'll only hang on
     // to one frame at a time.
-    static const unsigned cLargeAnimationCutoff = 5242880;
-    unsigned allFrameBytes = 0;
+    static const size_t cLargeAnimationCutoff = 5242880;
+    size_t allFrameBytes = 0;
     for (size_t i = 0; i < m_frames.size(); ++i)
         allFrameBytes += m_frames[i].m_frameBytes;
 
     if (allFrameBytes > cLargeAnimationCutoff)
-        destroyDecodedData(destroyAll);
+        destroyDecodedData();
 }
 
-void BitmapImage::destroyMetadataAndNotify(unsigned frameBytesCleared)
+void BitmapImage::destroyMetadataAndNotify(size_t frameBytesCleared)
 {
     m_isSolidColor = false;
     m_checkedForSolidColor = false;
 
     ASSERT(m_decodedSize >= frameBytesCleared);
     m_decodedSize -= frameBytesCleared;
     if (frameBytesCleared > 0) {
         frameBytesCleared += m_decodedPropertiesSize;
         m_decodedPropertiesSize = 0;
     }
     if (frameBytesCleared && imageObserver())
         imageObserver()->decodedSizeChanged(this, -safeCast<int>(frameBytesCleared));
 }
 
 void BitmapImage::cacheFrame(size_t index)
 {
     size_t numFrames = frameCount();
-    ASSERT(m_decodedSize == 0 || numFrames > 1);
-    
     if (m_frames.size() < numFrames)
         m_frames.grow(numFrames);
 
     m_frames[index].m_frame = m_source.createFrameAtIndex(index);
     if (numFrames == 1 && m_frames[index].m_frame)
         checkForSolidColor();
 
     m_frames[index].m_orientation = m_source.orientationAtIndex(index);
     m_frames[index].m_haveMetadata = true;
     m_frames[index].m_isComplete = m_source.frameIsCompleteAtIndex(index);
@@ skipping 394 matching lines @@
 
 void BitmapImage::resetAnimation()
 {
     stopAnimation();
     m_currentFrame = 0;
     m_repetitionsComplete = 0;
     m_desiredFrameStartTime = 0;
     m_animationFinished = false;
     
     // For extremely large animations, when the animation is reset, we just throw everything away.
-    destroyDecodedDataIfNecessary(true);
+    destroyDecodedDataIfNecessary();
 }
 
 unsigned BitmapImage::decodedSize() const
 {
     return m_decodedSize;
 }
 
 
 
 void BitmapImage::advanceAnimation(Timer<BitmapImage>*)
 {
     internalAdvanceAnimation(false);
     // At this point the image region has been marked dirty, and if it's
     // onscreen, we'll soon make a call to draw(), which will call
     // startAnimation() again to keep the animation moving.
 }
 
 bool BitmapImage::internalAdvanceAnimation(bool skippingFrames)
 {
     // Stop the animation.
     stopAnimation();
     
     // See if anyone is still paying attention to this animation.  If not, we don't
     // advance and will remain suspended at the current frame until the animation is resumed.
     if (!skippingFrames && imageObserver()->shouldPauseAnimation(this))
         return false;
 
     ++m_currentFrame;
     bool advancedAnimation = true;
-    bool destroyAll = false;
     if (m_currentFrame >= frameCount()) {
         ++m_repetitionsComplete;
 
         // Get the repetition count again.  If we weren't able to get a
         // repetition count before, we should have decoded the whole image by
         // now, so it should now be available.
         // Note that we don't need to special-case cAnimationLoopOnce here
         // because it is 0 (see comments on its declaration in ImageSource.h).
         if (repetitionCount(true) != cAnimationLoopInfinite && m_repetitionsComplete > m_repetitionCount) {
             m_animationFinished = true;
             m_desiredFrameStartTime = 0;
             --m_currentFrame;
             advancedAnimation = false;
-        } else {
+        } else
             m_currentFrame = 0;
-            destroyAll = true;
-        }
     }
-    destroyDecodedDataIfNecessary(destroyAll);
+    destroyDecodedDataIfNecessary();
 
     // We need to draw this frame if we advanced to it while not skipping, or if
     // while trying to skip frames we hit the last frame and thus had to stop.
     if (skippingFrames != advancedAnimation)
         imageObserver()->animationAdvanced(this);
     return advancedAnimation;
 }
 
 void BitmapImage::checkForSolidColor()
 {
@@ skipping 40 matching lines @@
 }
 
 void FrameData::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
 {
     MemoryClassInfo info(memoryObjectInfo, this, PlatformMemoryTypes::Image);
     memoryObjectInfo->setClassName("FrameData");
     info.addMember(m_frame, "frame", WTF::RetainingPointer);
 }
 
 }