Checking if frame is complete and access duration doesn't need a decode

Source/core/platform/image-decoders/ImageDecoder.cpp

 /*
  * Copyright (C) 2008-2009 Torch Mobile, Inc.
  * 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,
@@ skipping 109 matching lines @@
 
 bool ImageDecoder::frameHasAlphaAtIndex(size_t index) const
 {
     if (m_frameBufferCache.size() <= index)
         return true;
     if (m_frameBufferCache[index].status() == ImageFrame::FrameComplete)
         return m_frameBufferCache[index].hasAlpha();
     return true;
 }
 
+bool ImageDecoder::frameIsCompleteAtIndex(size_t) const
+{
+    return isAllDataReceived();

[Peter Kasting, 2013/04/27 00:51:01]

It seems like this should be:

    return ((index < m_frameBufferCache.size()) &&
(m_frameBufferCache[index].status() == ImageFrame::FrameComplete);

This will work better for e.g. ICO or other formats besides GIF that have
multiple frames.

Not including a trailing "|| isAllDataReceived()" part also lets us go ahead and
simplify frameHasAlphaAtIndex(), and is exactly equivalent to what the code did
before your patch, so it won't regress anything.  It will be slightly more
pessimistic in cases where we've gotten the data but hadn't decoded yet, but I
think it's actually safer.

The reason for this is that BitmapImage::cacheFrame() used to force us to decode
as much as possible, so the information we got was as accurate as possible, and
the "frame complete" flag would tell us if the information was reliable.  Now,
however, with anything other than GIF, cacheFrame() won't trigger any decoding,
and we'll store whatever the ImageDecoder base functions return for the various
values.  This can lead to us claiming a frame is complete when the other
metadata is inaccurate, which could cause problems.  I'm not sure whether it
_will_ cause problems as I haven't sufficiently audited all the codepaths, but
it definitely feels safer.

Long-term, if we want to support e.g. animated WebP, we'll want to do something
like you did for GIF and override these functions to be able to return accurate
answers while having only parsed the data, not decoded the framebuffer.  We also
may want to audit how the metadata is used more thoroughly, and perhaps plumb
the idea of "data available" versus "data parsed" versus "frame decoded" more
clearly to the ImageSource.  But I'd hope that can be a separate patch.

+}
+
 unsigned ImageDecoder::frameBytesAtIndex(size_t index) const
 {
     if (m_frameBufferCache.size() <= index)
         return 0;
     // FIXME: Use the dimension of the requested frame.
     return m_size.area() * sizeof(ImageFrame::PixelData);
 }
 
 void ImageDecoder::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
 {
@@ skipping 79 matching lines @@
 {
     return getScaledValue<LowerBound>(m_scaledRows, origY, searchStart);
 }
 
 int ImageDecoder::scaledY(int origY, int searchStart)
 {
     return getScaledValue<Exact>(m_scaledRows, origY, searchStart);
 }
 
 } // namespace WebCore