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 145 matching lines @@
         m_frames.grow(numFrames);
 
     int deltaBytes = totalFrameBytes();
 
     // We are caching frame snapshots.  This is OK even for partially decoded frames,
     // as they are cleared by dataChanged() when new data arrives.
     m_frames[index].m_frame = m_source.createFrameAtIndex(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_isComplete = m_source.frameIsFullyReceivedAtIndex(index);

[Peter Kasting, 2016/05/10 00:00:13]

This field should be renamed m_isFullyReceived.

...although it's not clear to me if we even need this.  Does just always calling
the underlying oracle function slow things appreciably or cause the wrong answer
anywhere?

[aleksandar.stojiljkovic, 2016/05/10 21:59:30]

The reason I left the name is because of work ongoing in the patch (to minimize
merging issues). Anyway, not an issue so renamed it.

Removing FrameData usage in BitmapImage I'm also planning to do after both
patches land - need more time to check the risks; performance and functionality.

     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);
 
     const IntSize frameSize(index ? m_source.frameSizeAtIndex(index) : m_size);
     if (frameSize != m_size)
         m_hasUniformFrameSize = false;
 
     // We need to check the total bytes before and after the decode call, not
@@ skipping 45 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
+        // NOTE: Don't call frameIsFullyReceivedAtIndex() here, that will try to

[scroggo_chromium, 2016/05/09 21:54:33]

Is this comment true?

[Peter Kasting, 2016/05/10 00:00:13]

I don't think so.

[aleksandar.stojiljkovic, 2016/05/10 21:59:30]

Removed.
Seems that it was once the case and that could explain caching metadata in
BitmapImage and ImageSource.

         // 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)
             m_frames[i].clear(true);
     }
 
     // Feed all the data we've seen so far to the image decoder.
     m_allDataReceived = allDataReceived;
     ASSERT(data());
     m_source.setData(*data(), allDataReceived);
@@ skipping 108 matching lines @@
 }
 
 PassRefPtr<SkImage> BitmapImage::frameAtIndex(size_t index)
 {
     if (!ensureFrameIsCached(index))
         return nullptr;
 
     return m_frames[index].m_frame;
 }
 
-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)
         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 102 matching lines @@
     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)
         getImageObserver()->animationAdvanced(this);
     return advancedAnimation;
 }
 
 } // namespace blink