Fix ImageDecoder::frameIsCompleteAtIndex - fully received instead of decoded.

third_party/WebKit/Source/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 128 matching lines @@
         m_frames.grow(numFrames);
 
     // We are caching frame snapshots.  This is OK even for partially decoded frames,
     // as they are cleared by dataChanged() when new data arrives.
     RefPtr<SkImage> image = m_source.createFrameAtIndex(index);
     m_cachedFrame = image;
     m_cachedFrameIndex = index;
 
     m_frames[index].m_orientation = m_source.orientationAtIndex(index);
     m_frames[index].m_haveMetadata = true;
-    m_frames[index].m_isComplete = m_source.frameIsCompleteAtIndex(index);
+    m_frames[index].m_isFullyReceived = m_source.frameIsFullyReceivedAtIndex(index);
     if (repetitionCount(false) != cAnimationNone)
         m_frames[index].m_duration = m_source.frameDurationAtIndex(index);
     m_frames[index].m_hasAlpha = m_source.frameHasAlphaAtIndex(index);
     m_frames[index].m_frameBytes = m_source.frameBytesAtIndex(index);
 
     notifyMemoryChanged();
     return image.release();
 }
 
 void BitmapImage::updateSize() const
@@ skipping 38 matching lines @@
     // With ICOs, on the other hand, we may ask for arbitrary frames at
     // different times (e.g. because we're displaying a higher-resolution image
     // in the content area and using a lower-resolution one for the favicon),
     // and the frames aren't even guaranteed to appear in the file in the same
     // order as in the directory, so an arbitrary number of the frames might be
     // incomplete (if we ask for frames for which we've not yet reached the
     // start of the frame data), and any or none of them might be the particular
     // frame affected by appending new data here. Thus we have to clear all the
     // incomplete frames to be safe.
     for (size_t i = 0; i < m_frames.size(); ++i) {
-        // NOTE: Don't call frameIsCompleteAtIndex() here, that will try to
-        // decode any uncached (i.e. never-decoded or
-        // cleared-on-a-previous-pass) frames!
-        if (m_frames[i].m_haveMetadata && !m_frames[i].m_isComplete) {
+        if (m_frames[i].m_haveMetadata && !m_frames[i].m_isFullyReceived) {
             m_frames[i].clear(true);
             if (i == m_cachedFrameIndex)
                 m_cachedFrame.clear();
         }
     }
 
     // Feed all the data we've seen so far to the image decoder.
     m_allDataReceived = allDataReceived;
     ASSERT(data());
     m_source.setData(*data(), allDataReceived);
@@ skipping 97 matching lines @@
 {
     if (index >= frameCount())
         return nullptr;
 
     if (index == m_cachedFrameIndex && m_cachedFrame)
         return m_cachedFrame;
 
     return decodeAndCacheFrame(index);
 }
 
-bool BitmapImage::frameIsCompleteAtIndex(size_t index)
+bool BitmapImage::frameIsFullyReceivedAtIndex(size_t index)
 {
-    if (index < m_frames.size() && m_frames[index].m_haveMetadata && m_frames[index].m_isComplete)
+    if (index < m_frames.size() && m_frames[index].m_haveMetadata && m_frames[index].m_isFullyReceived)
         return true;
 
-    return m_source.frameIsCompleteAtIndex(index);
+    return m_source.frameIsFullyReceivedAtIndex(index);
 }
 
 float BitmapImage::frameDurationAtIndex(size_t index)
 {
     if (index < m_frames.size() && m_frames[index].m_haveMetadata)
         return m_frames[index].m_duration;
 
     return m_source.frameDurationAtIndex(index);
 }
 
@@ skipping 27 matching lines @@
 bool BitmapImage::currentFrameKnownToBeOpaque(MetadataMode metadataMode)
 {
     if (metadataMode == PreCacheMetadata) {
         // frameHasAlphaAtIndex() conservatively returns false for uncached frames. To increase the
         // chance of an accurate answer, pre-cache the current frame metadata.
         frameAtIndex(currentFrame());
     }
     return !frameHasAlphaAtIndex(currentFrame());
 }
 
-bool BitmapImage::currentFrameIsComplete()
+bool BitmapImage::currentFrameIsFullyReceived()
 {
-    return frameIsCompleteAtIndex(currentFrame());
+    return frameIsFullyReceivedAtIndex(currentFrame());
 }
 
 bool BitmapImage::currentFrameIsLazyDecoded()
 {
     RefPtr<SkImage> image = frameAtIndex(currentFrame());
     return image && image->isLazyGenerated();
 }
 
 ImageOrientation BitmapImage::currentFrameOrientation()
 {
@@ skipping 37 matching lines @@
     if (m_frameTimer || !shouldAnimate() || frameCount() <= 1)
         return;
 
     // If we aren't already animating, set now as the animation start time.
     const double time = monotonicallyIncreasingTime();
     if (!m_desiredFrameStartTime)
         m_desiredFrameStartTime = time;
 
     // Don't advance the animation to an incomplete frame.
     size_t nextFrame = (m_currentFrame + 1) % frameCount();
-    if (!m_allDataReceived && !frameIsCompleteAtIndex(nextFrame))
+    if (!m_allDataReceived && !frameIsFullyReceivedAtIndex(nextFrame))
         return;
 
     // Don't advance past the last frame if we haven't decoded the whole image
     // yet and our repetition count is potentially unset.  The repetition count
     // in a GIF can potentially come after all the rest of the image data, so
     // wait on it.
     if (!m_allDataReceived
         && (repetitionCount(false) == cAnimationLoopOnce || m_animationPolicy == ImageAnimationPolicyAnimateOnce)
         && m_currentFrame >= (frameCount() - 1))
         return;
@@ skipping 26 matching lines @@
 
     if (catchUpIfNecessary == DoNotCatchUp || time < m_desiredFrameStartTime) {
         // Haven't yet reached time for next frame to start; delay until then.
         m_frameTimer = adoptPtr(new Timer<BitmapImage>(this, &BitmapImage::advanceAnimation));
         m_frameTimer->startOneShot(std::max(m_desiredFrameStartTime - time, 0.), BLINK_FROM_HERE);
     } else {
         // We've already reached or passed the time for the next frame to start.
         // See if we've also passed the time for frames after that to start, in
         // case we need to skip some frames entirely.  Remember not to advance
         // to an incomplete frame.
-        for (size_t frameAfterNext = (nextFrame + 1) % frameCount(); frameIsCompleteAtIndex(frameAfterNext); frameAfterNext = (nextFrame + 1) % frameCount()) {
+        for (size_t frameAfterNext = (nextFrame + 1) % frameCount(); frameIsFullyReceivedAtIndex(frameAfterNext); frameAfterNext = (nextFrame + 1) % frameCount()) {
             // Should we skip the next frame?
             double frameAfterNextStartTime = m_desiredFrameStartTime + frameDurationAtIndex(nextFrame);
             if (time < frameAfterNextStartTime)
                 break;
 
             // Yes; skip over it without notifying our observers.
             if (!internalAdvanceAnimation(true))
                 return;
             m_desiredFrameStartTime = frameAfterNextStartTime;
             nextFrame = frameAfterNext;
@@ skipping 89 matching lines @@
 
     // 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)
         getImageObserver()->animationAdvanced(this);
 
     return advancedAnimation;
 }
 
 } // namespace blink