Reland again "Decode GIF image frames on demand".

Source/core/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 @@
         // FrameData::clear()).
         PassNativeImagePtr asNewNativeImage() const;
 
         bool hasAlpha() const;
         const IntRect& originalFrameRect() const { return m_originalFrameRect; }
         FrameStatus status() const { return m_status; }
         unsigned duration() const { return m_duration; }
         FrameDisposalMethod disposalMethod() const { return m_disposalMethod; }
         bool premultiplyAlpha() const { return m_premultiplyAlpha; }
         void reportMemoryUsage(MemoryObjectInfo*) const;
+        size_t requiredPreviousFrameIndex() const
+        {
+            ASSERT(m_requiredPreviousFrameIndexValid);
+            return m_requiredPreviousFrameIndex;
+        }
+#if !ASSERT_DISABLED
+        bool requiredPreviousFrameIndexValid() const { return m_requiredPreviousFrameIndexValid; }
+#endif
 
         void setHasAlpha(bool alpha);
         void setOriginalFrameRect(const IntRect& r) { m_originalFrameRect = r; }
         void setStatus(FrameStatus status);
         void setDuration(unsigned duration) { m_duration = duration; }
         void setDisposalMethod(FrameDisposalMethod method) { m_disposalMethod = method; }
         void setPremultiplyAlpha(bool premultiplyAlpha) { m_premultiplyAlpha = premultiplyAlpha; }
+        void setRequiredPreviousFrameIndex(size_t previousFrameIndex)
+        {
+            m_requiredPreviousFrameIndex = previousFrameIndex;
+#if !ASSERT_DISABLED
+            m_requiredPreviousFrameIndexValid = true;
+#endif
+        }
 
         inline void setRGBA(int x, int y, unsigned r, unsigned g, unsigned b, unsigned a)
         {
             setRGBA(getAddr(x, y), r, g, b, a);
         }
 
         inline PixelData* getAddr(int x, int y)
         {
             return m_bitmap->bitmap().getAddr32(x, y);
         }
@@ skipping 58 matching lines @@
         SkBitmap::Allocator* m_allocator;
         bool m_hasAlpha;
         IntRect m_originalFrameRect; // This will always just be the entire
                                      // buffer except for GIF frames whose
                                      // original rect was smaller than the
                                      // overall image size.
         FrameStatus m_status;
         unsigned m_duration;
         FrameDisposalMethod m_disposalMethod;
         bool m_premultiplyAlpha;
+
+        // The frame that must be decoded before this frame can be decoded.
+        // WTF::notFound if this frame doesn't require any previous frame.
+        // This is used by ImageDecoder::clearCacheExceptFrame(), and will never
+        // be read for image formats that do not have multiple frames.
+        size_t m_requiredPreviousFrameIndex;
+#if !ASSERT_DISABLED
+        bool m_requiredPreviousFrameIndexValid;
+#endif
     };
 
     // ImageDecoder is a base for all format-specific decoders
     // (e.g. JPEGImageDecoder). This base manages the ImageFrame cache.
     class ImageDecoder {
         WTF_MAKE_NONCOPYABLE(ImageDecoder); WTF_MAKE_FAST_ALLOCATED;
     public:
         ImageDecoder(ImageSource::AlphaOption alphaOption, ImageSource::GammaAndColorProfileOption gammaAndColorProfileOption)
             : m_premultiplyAlpha(alphaOption == ImageSource::AlphaPremultiplied)
             , m_ignoreGammaAndColorProfile(gammaAndColorProfileOption == ImageSource::GammaAndColorProfileIgnored)
@@ skipping 138 matching lines @@
         // to enable easy tailcalling.  Subclasses may override this to also
         // clean up any local data.
         virtual bool setFailed()
         {
             m_failed = true;
             return false;
         }
 
         bool failed() const { return m_failed; }
 
-        // Clears decoded pixel data from before the provided frame unless that
-        // data may be needed to decode future frames (e.g. due to GIF frame
-        // compositing).
-        virtual void clearFrameBufferCache(size_t) { }
+        // Clears decoded pixel data from all frames except the provided frame,
+        // unless that frame has status FrameEmpty, in which case we instead
+        // preserve the most recent frame whose data is required in order to
+        // decode this frame. Callers may pass WTF::notFound to clear all frames.
+        //
+        // Returns the number of bytes of frame data actually cleared.
+        size_t clearCacheExceptFrame(size_t);
 
         // If the image has a cursor hot-spot, stores it in the argument
         // and returns true. Otherwise returns false.
         virtual bool hotSpot(IntPoint&) const { return false; }
 
         virtual void reportMemoryUsage(MemoryObjectInfo*) const;
 
         virtual void setMemoryAllocator(SkBitmap::Allocator* allocator)
         {
             // FIXME: this doesn't work for images with multiple frames.
             if (m_frameBufferCache.isEmpty())
                 m_frameBufferCache.resize(1);
             m_frameBufferCache[0].setMemoryAllocator(allocator);
         }
 
     protected:
+        // Calculates the most recent frame whose image data may be needed in
+        // order to decode frame |frameIndex|, based on frame disposal methods.
+        // If no previous frame's data is required, returns WTF::notFound.
+        //
+        // This function requires that the previous frame's
+        // |m_requiredPreviousFrameIndex| member has been set correctly. The
+        // easiest way to ensure this is for subclasses to call this method and
+        // store the result on the frame via setRequiredPreviousFrameIndex()
+        // as soon as the frame has been created and parsed sufficiently to
+        // determine the disposal method; assuming this happens for all frames
+        // in order, the required invariant will hold.
+        //
+        // Image formats which do not use more than one frame do not need to
+        // worry about this; see comments on
+        // ImageFrame::m_requiredPreviousFrameIndex.
+        size_t findRequiredPreviousFrame(size_t frameIndex);
+
+        virtual void clearFrameBuffer(size_t frameIndex);
+
         RefPtr<SharedBuffer> m_data; // The encoded data.
         Vector<ImageFrame, 1> m_frameBufferCache;
         bool m_premultiplyAlpha;
         bool m_ignoreGammaAndColorProfile;
         ImageOrientation m_orientation;
 
     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 isOverSize(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_failed;
     };
 
 } // namespace WebCore
 
 #endif