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 66 matching lines @@
 
 bool BitmapImage::hasSingleSecurityOrigin() const
 {
     return true;
 }
 
 
 void BitmapImage::destroyDecodedData(bool destroyAll)
 {
     unsigned frameBytesCleared = 0;
-    const size_t clearBeforeFrame = destroyAll ? m_frames.size() : m_currentFrame;
+    for (size_t i = 0; i < m_frames.size(); ++i) {
+        if (!destroyAll && i == m_currentFrame)
+            continue;
 
-    // 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) {
         // 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;
     }
 
     destroyMetadataAndNotify(frameBytesCleared);
 
-    m_source.clear(destroyAll, clearBeforeFrame, data(), m_allDataReceived);
+    m_source.clear(destroyAll, m_currentFrame, data(), m_allDataReceived);
     return;
 }
 
 void BitmapImage::destroyDecodedDataIfNecessary(bool destroyAll)
 {
     // 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;
     for (size_t i = 0; i < m_frames.size(); ++i)
@@ skipping 381 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);

[Peter Kasting, 2013/05/24 03:15:22]

Since we're resetting m_currentFrame to 0 here, and we're going to want to
display frame 0, we could just as correctly (if not more correctly) pass "false"
to destroyDecodedDataIfNecessary().

The advantage of doing this is that now the only two callers would both pass
"false".  That means we can nuke the argument entirely.

[Xianzhu, 2013/05/28 22:54:21]

Done.

 }
 
 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(false);
 
     // 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;
 }
 
 bool BitmapImage::mayFillWithSolidColor()
 {
@@ skipping 20 matching lines @@
 }
 
 void FrameData::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
 {
     MemoryClassInfo info(memoryObjectInfo, this, PlatformMemoryTypes::Image);
     memoryObjectInfo->setClassName("FrameData");
     info.addMember(m_frame, "frame", WTF::RetainingPointer);
 }
 
 }