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

third_party/WebKit/Source/platform/image-decoders/ImageDecoder.h

 /*
  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
  * Copyright (C) Research In Motion Limited 2009-2010. 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 97 matching lines @@
         GammaAndColorProfileApplied,
         GammaAndColorProfileIgnored
     };
 
     ImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption colorOptions, size_t maxDecodedBytes)
         : m_premultiplyAlpha(alphaOption == AlphaPremultiplied)
         , m_ignoreGammaAndColorProfile(colorOptions == GammaAndColorProfileIgnored)
         , m_maxDecodedBytes(maxDecodedBytes)
         , m_sizeAvailable(false)
         , m_isAllDataReceived(false)
+        , m_haveUpdatedFrameCount(true)
         , m_failed(false) { }
 
     virtual ~ImageDecoder() { }
 
     // Returns a caller-owned decoder of the appropriate type.  Returns 0 if
     // we can't sniff a supported type from the provided data (possibly
     // because there isn't enough data yet).
     // Sets m_maxDecodedBytes to Platform::maxImageDecodedBytes().
     static PassOwnPtr<ImageDecoder> create(const char* data, size_t length, AlphaOption, GammaAndColorProfileOption);
     static PassOwnPtr<ImageDecoder> create(const SharedBuffer&, AlphaOption, GammaAndColorProfileOption);
     static PassOwnPtr<ImageDecoder> create(const SegmentReader&, AlphaOption, GammaAndColorProfileOption);
 
     virtual String filenameExtension() const = 0;
 
     bool isAllDataReceived() const { return m_isAllDataReceived; }
 
     void setData(PassRefPtr<SegmentReader> data, bool allDataReceived)
     {
         if (m_failed)
             return;
         m_data = data;
         m_isAllDataReceived = allDataReceived;
+        m_haveUpdatedFrameCount = false;
         onSetData(m_data.get());
     }
 
     void setData(PassRefPtr<SharedBuffer> data, bool allDataReceived)
     {
         setData(SegmentReader::createFromSharedBuffer(data), allDataReceived);
     }
 
     virtual void onSetData(SegmentReader* data) { }
 
     bool isSizeAvailable()
     {
         if (m_failed)
             return false;
         if (!m_sizeAvailable)
             decodeSize();
         return isDecodedSizeAvailable();
     }
 
     bool isDecodedSizeAvailable() const
     {
         return !m_failed && m_sizeAvailable;
     }
 
+    // Whether the requested frame is fully decoded.
+    inline bool frameIsCompleteAtIndex(size_t frameIndex) const
+    {
+        return (frameIndex < m_frameBufferCache.size()) && (m_frameBufferCache[frameIndex].getStatus() == ImageFrame::FrameComplete);
+    }
+
     virtual IntSize size() const { return m_size; }
 
     // Decoders which downsample images should override this method to
     // return the actual decoded size.
     virtual IntSize decodedSize() const { return size(); }
 
     // Image decoders that support YUV decoding must override this to
     // provide the size of each component.
     virtual IntSize decodedYUVSize(int component) const
     {
@@ skipping 35 matching lines @@
     // decoding the individual frames.  Resizes m_frameBufferCache to the
     // correct size and returns its size.
     size_t frameCount();
 
     virtual int repetitionCount() const { return cAnimationNone; }
 
     // Decodes as much of the requested frame as possible, and returns an
     // ImageDecoder-owned pointer.
     ImageFrame* frameBufferAtIndex(size_t);
 
-    // Whether the requested frame has alpha.
-    virtual bool frameHasAlphaAtIndex(size_t) const;
-
     // Whether or not the frame is fully received.
-    virtual bool frameIsCompleteAtIndex(size_t) const;
+    virtual bool frameIsFullyReceivedAtIndex(size_t) const;
 
     // Duration for displaying a frame in seconds. This method is only used by
     // animated images.
     virtual float frameDurationAtIndex(size_t) const { return 0; }
 
     // Number of bytes in the decoded frame. Returns 0 if the decoder doesn't
     // have this frame cached (either because it hasn't been decoded, or because
     // it has been cleared).
     virtual size_t frameBytesAtIndex(size_t) const;
 
+    // Whether the requested frame has alpha.
+    bool frameHasAlphaAtIndex(size_t) const;
+
     ImageOrientation orientation() const { return m_orientation; }
 
     static bool deferredImageDecodingEnabled();
 
     void setIgnoreGammaAndColorProfile(bool flag) { m_ignoreGammaAndColorProfile = flag; }
     bool ignoresGammaAndColorProfile() const { return m_ignoreGammaAndColorProfile; }
 
     bool hasColorProfile() const;
 
 #if USE(QCMSLIB)
@@ skipping 80 matching lines @@
     bool m_ignoreGammaAndColorProfile;
     ImageOrientation m_orientation;
 
     // The maximum amount of memory a decoded image should require. Ideally,
     // image decoders should downsample large images to fit under this limit
     // (and then return the downsampled size from decodedSize()). Ignoring
     // this limit can cause excessive memory use or even crashes on low-
     // memory devices.
     size_t m_maxDecodedBytes;
 
+    // Whether frameCount() was called to update frame count after setData().

[Peter Kasting, 2016/06/10 00:10:02]

Nit: update -> update the

+    bool haveUpdatedFrameCount() const { return m_haveUpdatedFrameCount; }
+
 private:
     // Some code paths compute the size of the image as "width * height * 4"
     // and return it as a (signed) int.  Avoid overflow.
     static bool sizeCalculationMayOverflow(unsigned width, unsigned height)
     {
         unsigned long long total_size = static_cast<unsigned long long>(width)
                                       * static_cast<unsigned long long>(height);
         return total_size > ((1 << 29) - 1);
     }
 
     IntSize m_size;
     bool m_sizeAvailable;
     bool m_isAllDataReceived;
+    bool m_haveUpdatedFrameCount;
     bool m_failed;
 
 #if USE(QCMSLIB)
     OwnPtr<qcms_transform> m_sourceToOutputDeviceColorTransform;
 #endif
 };
 
 } // namespace blink
 
 #endif