Decode GIF image frames on demand.

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

 /*
  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
  * Copyright (C) 2008-2009 Torch Mobile, Inc.
  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
  * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies)
  *
  * 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
@@ skipping 99 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 { return m_requiredPreviousFrameIndex; }
 
         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; }
 
         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.
+        // |notFound| if this frame doesn't require any previous frame.
+        size_t m_requiredPreviousFrameIndex;
     };
 
     // ImageDecoder is a base for all format-specific decoders
     // (e.g. JPEGImageDecoder).  This base manages the ImageFrame cache.
     //
     // ENABLE(IMAGE_DECODER_DOWN_SAMPLING) allows image decoders to downsample
     // at decode time.  Image decoders will downsample any images larger than
     // |m_maxNumPixels|.  FIXME: Not yet supported by all decoders.
     class ImageDecoder {
         WTF_MAKE_NONCOPYABLE(ImageDecoder); WTF_MAKE_FAST_ALLOCATED;
@@ skipping 149 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
+        // Clears decoded pixel data except 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) { }
+        void clearFrameBufferCache(size_t clearExceptFrame);
 
 #if ENABLE(IMAGE_DECODER_DOWN_SAMPLING)
         void setMaxNumPixels(int m) { m_maxNumPixels = m; }
 #endif
 
         // 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:
+        // Finds the previous required frame for decoding the given frame.
+        // Returns notFound if this frame doesn't require any previous frame.
+        // Subclasses should call this function and cache the result by calling
+        // ImageFrame::setRequiredPreviousFrame() when a new frame is created.
+        size_t findRequiredPreviousFrame(size_t frameIndex);
+
         void prepareScaleDataIfNecessary();
         int upperBoundScaledX(int origX, int searchStart = 0);
         int lowerBoundScaledX(int origX, int searchStart = 0);
         int upperBoundScaledY(int origY, int searchStart = 0);
         int lowerBoundScaledY(int origY, int searchStart = 0);
         int scaledY(int origY, int searchStart = 0);
 
         RefPtr<SharedBuffer> m_data; // The encoded data.
         Vector<ImageFrame, 1> m_frameBufferCache;
         bool m_scaled;
@@ skipping 16 matching lines @@
         IntSize m_size;
         bool m_sizeAvailable;
         int m_maxNumPixels;
         bool m_isAllDataReceived;
         bool m_failed;
     };
 
 } // namespace WebCore
 
 #endif