Attachment 289597 Details for Bug 155498 – Patch

[patch] Patch

bug-155498-20160922141950.patch (text/plain), 120.32 KB, created by Said Abou-Hallawa on 2016-09-22 14:22:40 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Said Abou-Hallawa

Created: 2016-09-22 14:22:40 PDT

Size: 120.32 KB

patch

obsolete

>Index: Source/WebCore/ChangeLog
>===================================================================
>--- Source/WebCore/ChangeLog	(revision 206274)
>+++ Source/WebCore/ChangeLog	(working copy)
>@@ -1,3 +1,194 @@
>+2016-09-22  Said Abou-Hallawa  <sabouhallawa@apple.com>
>+
>+        Move caching the ImageFrame from BitmapImage to ImageSource
>+        https://bugs.webkit.org/show_bug.cgi?id=155498
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        BitmapImage has two modes of operation regarding the cached ImageFrames.
>+        The first mode happens when a remote image is loaded as encoded data and
>+        which requires an ImageDecoder to generate the metadata and NativeImages
>+        of the ImageFrames. The second mode happens when a BitmapImage is created
>+        with a memory image. In this case, no ImageDecoder is needed.
>+
>+        To remove this burden from BitmapImage the member 'm_frames' is removed
>+        from BitmapImage. A new member named 'm_frameCache' of type ImageFrameCache
>+        is added to ImageSource. When the ImageSource creates its ImageFrameDecoder
>+        it hands off m_frameCache to fill it. For the the memory image mode,
>+        ImageSource appends a new frame for that image to m_frameCache.
>+
>+        When replying ImageFrame queries, ImageSource will ask the ImageFrameDecoder
>+        to ensure the request ImageFrame is first cached before calling a method in
>+        that ImageFrame.
>+
>+        * CMakeLists.txt:
>+        * WebCore.xcodeproj/project.pbxproj:
>+        * platform/graphics/BitmapImage.cpp:
>+        (WebCore::BitmapImage::BitmapImage):
>+        (WebCore::BitmapImage::destroyDecodedData):
>+        (WebCore::BitmapImage::destroyDecodedDataIfNecessary):
>+        (WebCore::BitmapImage::dataChanged):
>+        (WebCore::BitmapImage::frameImageAtIndex):
>+        (WebCore::BitmapImage::nativeImageOfSize):
>+        (WebCore::BitmapImage::framesNativeImages):
>+        (WebCore::BitmapImage::draw):
>+        (WebCore::BitmapImage::drawPattern):
>+        (WebCore::BitmapImage::shouldAnimate):
>+        (WebCore::BitmapImage::startAnimation):
>+        (WebCore::BitmapImage::internalAdvanceAnimation):
>+        (WebCore::BitmapImage::resetAnimation):
>+        (WebCore::BitmapImage::dump):
>+        (WebCore::BitmapImage::haveFrameImageAtIndex): Deleted.
>+        (WebCore::BitmapImage::destroyMetadataAndNotify): Deleted.
>+        (WebCore::BitmapImage::cacheFrame): Deleted.
>+        (WebCore::BitmapImage::didDecodeProperties): Deleted.
>+        (WebCore::BitmapImage::updateSize): Deleted.
>+        (WebCore::BitmapImage::size): Deleted.
>+        (WebCore::BitmapImage::sizeRespectingOrientation): Deleted.
>+        (WebCore::BitmapImage::hotSpot): Deleted.
>+        (WebCore::BitmapImage::frameCount): Deleted.
>+        (WebCore::BitmapImage::isSizeAvailable): Deleted.
>+        (WebCore::BitmapImage::ensureFrameAtIndexIsCached): Deleted.
>+        (WebCore::BitmapImage::frameIsCompleteAtIndex): Deleted.
>+        (WebCore::BitmapImage::frameDurationAtIndex): Deleted.
>+        (WebCore::BitmapImage::frameHasAlphaAtIndex): Deleted.
>+        (WebCore::BitmapImage::currentFrameKnownToBeOpaque): Deleted.
>+        (WebCore::BitmapImage::frameOrientationAtIndex): Deleted.
>+        (WebCore::BitmapImage::singlePixelSolidColor): Deleted.
>+        (WebCore::BitmapImage::repetitionCount): Deleted.
>+        * platform/graphics/BitmapImage.h:
>+        * platform/graphics/ImageFrame.cpp:
>+        (WebCore::ImageFrame::defaultFrame):
>+        (WebCore::ImageFrame::fillMetadata): Deleted.
>+        (WebCore::ImageFrame::initialize): Deleted.
>+        * platform/graphics/ImageFrame.h:
>+        (WebCore::ImageFrame::setSize):
>+        (WebCore::ImageFrame::setSubsamplingLevel):
>+        (WebCore::ImageFrame::setNativeImage):
>+        (WebCore::ImageFrame::setDuration):
>+        (WebCore::ImageFrame::hasAlpha):
>+        (WebCore::ImageFrame::frameBytes): Deleted.
>+        * platform/graphics/ImageFrameCache.cpp: Added.
>+        (WebCore::ImageFrameCache::ImageFrameCache):
>+        (WebCore::ImageFrameCache::grow):
>+        (WebCore::ImageFrameCache::destroyDecodedData):
>+        (WebCore::ImageFrameCache::destroyDecodedDataIfNecessary):
>+        (WebCore::ImageFrameCache::destroyIncompleteDecodedData):
>+        (WebCore::ImageFrameCache::decodedSizeChanged):
>+        (WebCore::ImageFrameCache::decodedSizeIncremented):
>+        (WebCore::ImageFrameCache::decodedSizeDecremented):
>+        (WebCore::ImageFrameCache::decodedSizeReset):
>+        (WebCore::ImageFrameCache::didDecodeProperties):
>+        * platform/graphics/ImageFrameCache.h: Added.
>+        (WebCore::ImageFrameCache::operator[]):
>+        (WebCore::ImageFrameCache::size):
>+        (WebCore::ImageFrameCache::decodedSize):
>+        * platform/graphics/ImageFrameDecoder.cpp: Added.
>+        (WebCore::ImageFrameDecoder::ImageFrameDecoder):
>+        (WebCore::ImageFrameDecoder::clearMetadata):
>+        (WebCore::ImageFrameDecoder::setFrameMetadata):
>+        (WebCore::ImageFrameDecoder::setFrameImageAndMetadata):
>+        (WebCore::ImageFrameDecoder::frameAtIndex):
>+        * platform/graphics/ImageFrameDecoder.h: Added.
>+        (WebCore::ImageFrameDecoder::create):
>+        (WebCore::ImageFrameDecoder::metadata):
>+        (WebCore::ImageFrameDecoder::isSizeAvailable):
>+        (WebCore::ImageFrameDecoder::frameCount):
>+        (WebCore::ImageFrameDecoder::repetitionCount):
>+        (WebCore::ImageFrameDecoder::filenameExtension):
>+        (WebCore::ImageFrameDecoder::hotSpot):
>+        * platform/graphics/ImageSource.cpp:
>+        (WebCore::ImageSource::ImageSource):
>+        (WebCore::ImageSource::clearFrameBufferCache):
>+        (WebCore::ImageSource::clearMetadata):
>+        (WebCore::ImageSource::clear):
>+        (WebCore::ImageSource::destroyDecodedData):
>+        (WebCore::ImageSource::destroyDecodedDataIfNecessary):
>+        (WebCore::ImageSource::ensureDecoderAvailable):
>+        (WebCore::ImageSource::setData):
>+        (WebCore::ImageSource::dataChanged):
>+        (WebCore::ImageSource::frameMetadataAtIndex):
>+        (WebCore::ImageSource::isAllDataReceived):
>+        (WebCore::ImageSource::isSizeAvailable):
>+        (WebCore::ImageSource::frameCount):
>+        (WebCore::ImageSource::repetitionCount):
>+        (WebCore::ImageSource::filenameExtension):
>+        (WebCore::ImageSource::hotSpot):
>+        (WebCore::ImageSource::size):
>+        (WebCore::ImageSource::sizeRespectingOrientation):
>+        (WebCore::ImageSource::maximumSubsamplingLevel):
>+        (WebCore::ImageSource::subsamplingLevelForScale):
>+        (WebCore::ImageSource::singlePixelSolidColor):
>+        (WebCore::ImageSource::frameIsCompleteAtIndex):
>+        (WebCore::ImageSource::frameHasAlphaAtIndex):
>+        (WebCore::ImageSource::frameHasImageAtIndex):
>+        (WebCore::ImageSource::frameHasInvalidNativeImageAtIndex):
>+        (WebCore::ImageSource::frameSubsamplingLevelAtIndex):
>+        (WebCore::ImageSource::frameSizeAtIndex):
>+        (WebCore::ImageSource::frameBytesAtIndex):
>+        (WebCore::ImageSource::frameDurationAtIndex):
>+        (WebCore::ImageSource::frameOrientationAtIndex):
>+        (WebCore::ImageSource::frameImageAtIndex):
>+        (WebCore::ImageSource::createFrameImageAtIndex):
>+        (WebCore::ImageSource::dump):
>+        (WebCore::ImageSource::calculateMaximumSubsamplingLevel): Deleted.
>+        (WebCore::ImageSource::updateMetadata): Deleted.
>+        (WebCore::ImageSource::bytesDecodedToDetermineProperties): Deleted.
>+        (WebCore::ImageSource::frameAllowSubsamplingAtIndex): Deleted.
>+        * platform/graphics/ImageSource.h:
>+        (WebCore::ImageSource::isDecoderAvailable):
>+        (WebCore::ImageSource::decodedSize):
>+        (WebCore::ImageSource::setAllowSubsampling):
>+        (WebCore::ImageSource::decoder): Deleted.
>+        (WebCore::ImageSource::initialized): Deleted.
>+        (WebCore::ImageSource::setNeedsUpdateMetadata): Deleted.
>+        * platform/graphics/cairo/GraphicsContext3DCairo.cpp:
>+        (WebCore::GraphicsContext3D::ImageExtractor::extractImage):
>+        * platform/graphics/cg/GraphicsContext3DCG.cpp:
>+        (WebCore::GraphicsContext3D::ImageExtractor::extractImage):
>+        * platform/graphics/cg/ImageDecoderCG.cpp:
>+        (WebCore::ImageDecoder::ImageDecoder):
>+        (WebCore::ImageDecoder::setData):
>+        (WebCore::ImageDecoder::size): Deleted.
>+        * platform/graphics/cg/ImageDecoderCG.h:
>+        (WebCore::ImageDecoder::create):
>+        (WebCore::ImageDecoder::isAllDataReceived):
>+        * platform/graphics/efl/GraphicsContext3DEfl.cpp:
>+        (WebCore::GraphicsContext3D::ImageExtractor::extractImage):
>+        * platform/graphics/mac/ImageMac.mm:
>+        (WebCore::BitmapImage::invalidatePlatformData):
>+        * platform/image-decoders/ImageDecoder.cpp:
>+        (WebCore::ImageDecoder::create):
>+        * platform/image-decoders/ImageDecoder.h:
>+        (WebCore::ImageDecoder::ImageDecoder):
>+        (WebCore::ImageDecoder::filenameExtension):
>+        (WebCore::ImageDecoder::frameCount):
>+        (WebCore::ImageDecoder::frameBufferAtIndex):
>+        * platform/image-decoders/bmp/BMPImageDecoder.cpp:
>+        (WebCore::BMPImageDecoder::BMPImageDecoder):
>+        * platform/image-decoders/bmp/BMPImageDecoder.h:
>+        * platform/image-decoders/gif/GIFImageDecoder.cpp:
>+        (WebCore::GIFImageDecoder::GIFImageDecoder):
>+        (WebCore::GIFImageDecoder::frameCount):
>+        * platform/image-decoders/gif/GIFImageDecoder.h:
>+        * platform/image-decoders/gif/GIFImageReader.cpp:
>+        * platform/image-decoders/gif/GIFImageReader.h:
>+        * platform/image-decoders/ico/ICOImageDecoder.cpp:
>+        (WebCore::ICOImageDecoder::ICOImageDecoder):
>+        (WebCore::ICOImageDecoder::frameCount):
>+        (WebCore::ICOImageDecoder::decode):
>+        (WebCore::ICOImageDecoder::decodeAtIndex):
>+        * platform/image-decoders/ico/ICOImageDecoder.h:
>+        * platform/image-decoders/jpeg/JPEGImageDecoder.cpp:
>+        (WebCore::JPEGImageDecoder::JPEGImageDecoder):
>+        * platform/image-decoders/jpeg/JPEGImageDecoder.h:
>+        * platform/image-decoders/png/PNGImageDecoder.cpp:
>+        (WebCore::PNGImageDecoder::PNGImageDecoder):
>+        * platform/image-decoders/png/PNGImageDecoder.h:
>+        * platform/image-decoders/webp/WEBPImageDecoder.cpp:
>+        (WebCore::WEBPImageDecoder::WEBPImageDecoder):
>+        * platform/image-decoders/webp/WEBPImageDecoder.h:
>+
> 2016-09-22  Jer Noble  <jer.noble@apple.com>
> 
>         Fullscreen controls inoperative in WebKitLegacy web views
>Index: Source/WebCore/CMakeLists.txt
>===================================================================
>--- Source/WebCore/CMakeLists.txt	(revision 206259)
>+++ Source/WebCore/CMakeLists.txt	(working copy)
>@@ -2221,6 +2221,8 @@ set(WebCore_SOURCES
>     platform/graphics/Image.cpp
>     platform/graphics/ImageBuffer.cpp
>     platform/graphics/ImageFrame.cpp
>+    platform/graphics/ImageFrameCache.cpp
>+    platform/graphics/ImageFrameDecoder.cpp
>     platform/graphics/ImageOrientation.cpp
>     platform/graphics/ImageSource.cpp
>     platform/graphics/IntPoint.cpp
>Index: Source/WebCore/WebCore.xcodeproj/project.pbxproj
>===================================================================
>--- Source/WebCore/WebCore.xcodeproj/project.pbxproj	(revision 206259)
>+++ Source/WebCore/WebCore.xcodeproj/project.pbxproj	(working copy)
>@@ -2271,6 +2271,10 @@
> 		555B87ED1CAAF0AB00349425 /* ImageDecoderCG.h in Headers */ = {isa = PBXBuildFile; fileRef = 555B87EB1CAAF0AB00349425 /* ImageDecoderCG.h */; };
> 		5576A5641D88A70800CCC04C /* ImageFrame.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5576A5621D88A70800CCC04C /* ImageFrame.cpp */; };
> 		5576A5651D88A70800CCC04C /* ImageFrame.h in Headers */ = {isa = PBXBuildFile; fileRef = 5576A5631D88A70800CCC04C /* ImageFrame.h */; settings = {ATTRIBUTES = (Private, ); }; };
>+		5597F8261D91C3130066BC21 /* ImageFrameCache.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5597F8241D91C3130066BC21 /* ImageFrameCache.cpp */; };
>+		5597F8271D91C3130066BC21 /* ImageFrameCache.h in Headers */ = {isa = PBXBuildFile; fileRef = 5597F8251D91C3130066BC21 /* ImageFrameCache.h */; settings = {ATTRIBUTES = (Private, ); }; };
>+		5597F82A1D91C6680066BC21 /* ImageFrameDecoder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5597F8281D91C6680066BC21 /* ImageFrameDecoder.cpp */; };
>+		5597F82B1D91C6680066BC21 /* ImageFrameDecoder.h in Headers */ = {isa = PBXBuildFile; fileRef = 5597F8291D91C6680066BC21 /* ImageFrameDecoder.h */; };
> 		55A336F71D8209F40022C4C7 /* NativeImage.h in Headers */ = {isa = PBXBuildFile; fileRef = 55A336F61D8209F40022C4C7 /* NativeImage.h */; };
> 		55A336F91D821E3C0022C4C7 /* ImageBackingStore.h in Headers */ = {isa = PBXBuildFile; fileRef = 55A336F81D821E3C0022C4C7 /* ImageBackingStore.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		5709E8CD1D413D47003244AC /* WebKitSubtleCrypto.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5709E8CA1D413CE3003244AC /* WebKitSubtleCrypto.cpp */; };
>@@ -9302,6 +9306,10 @@
> 		555B87EB1CAAF0AB00349425 /* ImageDecoderCG.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ImageDecoderCG.h; sourceTree = "<group>"; };
> 		5576A5621D88A70800CCC04C /* ImageFrame.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ImageFrame.cpp; sourceTree = "<group>"; };
> 		5576A5631D88A70800CCC04C /* ImageFrame.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ImageFrame.h; sourceTree = "<group>"; };
>+		5597F8241D91C3130066BC21 /* ImageFrameCache.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ImageFrameCache.cpp; sourceTree = "<group>"; };
>+		5597F8251D91C3130066BC21 /* ImageFrameCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ImageFrameCache.h; sourceTree = "<group>"; };
>+		5597F8281D91C6680066BC21 /* ImageFrameDecoder.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ImageFrameDecoder.cpp; sourceTree = "<group>"; };
>+		5597F8291D91C6680066BC21 /* ImageFrameDecoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ImageFrameDecoder.h; sourceTree = "<group>"; };
> 		55A336F61D8209F40022C4C7 /* NativeImage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NativeImage.h; sourceTree = "<group>"; };
> 		55A336F81D821E3C0022C4C7 /* ImageBackingStore.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ImageBackingStore.h; sourceTree = "<group>"; };
> 		55D408F71A7C631800C78450 /* SVGImageClients.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SVGImageClients.h; sourceTree = "<group>"; };
>@@ -20730,6 +20738,10 @@
> 				22BD9F7D1353625C009BD102 /* ImageBufferData.h */,
> 				5576A5621D88A70800CCC04C /* ImageFrame.cpp */,
> 				5576A5631D88A70800CCC04C /* ImageFrame.h */,
>+				5597F8241D91C3130066BC21 /* ImageFrameCache.cpp */,
>+				5597F8251D91C3130066BC21 /* ImageFrameCache.h */,
>+				5597F8281D91C6680066BC21 /* ImageFrameDecoder.cpp */,
>+				5597F8291D91C6680066BC21 /* ImageFrameDecoder.h */,
> 				BC7F44A70B9E324E00A9D081 /* ImageObserver.h */,
> 				A8748D7412CC3F89001FBA41 /* ImageOrientation.cpp */,
> 				A8748D6612CC3763001FBA41 /* ImageOrientation.h */,
>@@ -24507,6 +24519,7 @@
> 				0FD723820EC8BD9300CA5DD7 /* FloatQuad.h in Headers */,
> 				B275356B0B053814002CE64F /* FloatRect.h in Headers */,
> 				6E0E569C183BFFE600E0E8D5 /* FloatRoundedRect.h in Headers */,
>+				5597F8271D91C3130066BC21 /* ImageFrameCache.h in Headers */,
> 				B275356D0B053814002CE64F /* FloatSize.h in Headers */,
> 				58CD35CB18EB4C3900B9F3AC /* FloatSizeHash.h in Headers */,
> 				D72F6D7A153159A3001EE44E /* FlowThreadController.h in Headers */,
>@@ -25922,6 +25935,7 @@
> 				8AF4E55C11DC5A63000ED3DE /* PerformanceTiming.h in Headers */,
> 				FD581FB51520F93B003A7A75 /* PeriodicWave.h in Headers */,
> 				49D5DC2E0F423A73008F20FD /* PerspectiveTransformOperation.h in Headers */,
>+				5597F82B1D91C6680066BC21 /* ImageFrameDecoder.h in Headers */,
> 				51B454EA1B4DAE7D0085EAA6 /* PingHandle.h in Headers */,
> 				D0FF2A5E11F8C45A007E74E0 /* PingLoader.h in Headers */,
> 				37B327D31D17096A005737FA /* PIPSPI.h in Headers */,
>@@ -27629,6 +27643,7 @@
> 				514C764D0CE9234E007EF3CD /* AuthenticationMac.mm in Sources */,
> 				E461D65D1BB0C7F000CB5645 /* AuthorStyleSheets.cpp in Sources */,
> 				A5F6E16B132ED46E008EDAE3 /* Autocapitalize.cpp in Sources */,
>+				5597F8261D91C3130066BC21 /* ImageFrameCache.cpp in Sources */,
> 				7C1843FD1C8B7283002EB973 /* Autofill.cpp in Sources */,
> 				7C1E97271A9F9834007BF0FB /* AutoFillButtonElement.cpp in Sources */,
> 				45830D4D1679B4F800ACF8C3 /* AutoscrollController.cpp in Sources */,
>@@ -30319,6 +30334,7 @@
> 				97AABD1814FA09D5007457AE /* ThreadableWebSocketChannelClientWrapper.cpp in Sources */,
> 				51DF6D800B92A18E00C2DC85 /* ThreadCheck.mm in Sources */,
> 				0F6383DD18615B29003E5DB5 /* ThreadedScrollingTree.cpp in Sources */,
>+				5597F82A1D91C6680066BC21 /* ImageFrameDecoder.cpp in Sources */,
> 				E1FF57A60F01256B00891EBB /* ThreadGlobalData.cpp in Sources */,
> 				185BCF280F3279CE000EA262 /* ThreadTimers.cpp in Sources */,
> 				7AA3A699194A64E7001CBD24 /* TileController.cpp in Sources */,
>Index: Source/WebCore/platform/graphics/BitmapImage.cpp
>===================================================================
>--- Source/WebCore/platform/graphics/BitmapImage.cpp	(revision 206259)
>+++ Source/WebCore/platform/graphics/BitmapImage.cpp	(working copy)
>@@ -21,7 +21,7 @@
>  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>  */
> 
> #include "config.h"
>@@ -48,32 +48,14 @@ namespace WebCore {
> 
> BitmapImage::BitmapImage(ImageObserver* observer)
>     : Image(observer)
>-    , m_animationFinished(false)
>-    , m_allDataReceived(false)
>-    , m_haveSize(false)
>-    , m_sizeAvailable(false)
>-    , m_haveFrameCount(false)
>-    , m_animationFinishedWhenCatchingUp(false)
>+    , m_source(this)
> {
> }
> 
> BitmapImage::BitmapImage(NativeImagePtr&& image, ImageObserver* observer)
>     : Image(observer)
>-    , m_source(image)
>-    , m_frameCount(1)
>-    , m_animationFinished(true)
>-    , m_allDataReceived(true)
>-    , m_haveSize(true)
>-    , m_sizeAvailable(true)
>-    , m_haveFrameCount(true)
>-    , m_animationFinishedWhenCatchingUp(false)
>-{
>-    m_frames.grow(1);
>-    m_frames[0].initialize(WTFMove(image));
>-
>-    m_size = m_frames[0].size();
>-    m_sizeRespectingOrientation = m_size;
>-    m_decodedSize = m_size.area() * 4;
>+    , m_source(WTFMove(image))
>+{
> }
> 
> BitmapImage::~BitmapImage()
>@@ -82,294 +64,30 @@ BitmapImage::~BitmapImage()
>     stopAnimation();
> }
> 
>-bool BitmapImage::haveFrameImageAtIndex(size_t index)
>-{
>-    if (index >= frameCount())
>-        return false;
>-
>-    if (index >= m_frames.size())
>-        return false;
>-
>-    return m_frames[index].hasNativeImage();
>-}
>-
> void BitmapImage::destroyDecodedData(bool destroyAll)
> {
>-    unsigned frameBytesCleared = 0;
>-    const size_t clearBeforeFrame = destroyAll ? m_frames.size() : m_currentFrame;
>-
>-    // Because we can advance frames without always needing to decode the actual
>-    // bitmap data, |m_currentFrame| may be larger than m_frames.size();
>-    // make sure not to walk off the end of the container in this case.
>-    for (size_t i = 0; i <  std::min(clearBeforeFrame, m_frames.size()); ++i) {
>-        // The underlying frame isn't actually changing (we're just trying to
>-        // save the memory for the framebuffer data), so we don't need to clear
>-        // the metadata.
>-        frameBytesCleared += m_frames[i].clearImage();
>-    }
>-
>-    m_source.clear(destroyAll, clearBeforeFrame, data(), m_allDataReceived);
>-    destroyMetadataAndNotify(frameBytesCleared, ClearedSource::Yes);
>-}
>-
>-void BitmapImage::destroyDecodedDataIfNecessary(bool destroyAll)
>-{
>-    // Animated images over a certain size are considered large enough that we'll only hang on
>-    // to one frame at a time.
>-#if PLATFORM(IOS)
>-    const unsigned largeAnimationCutoff = 2097152;
>-#else
>-    const unsigned largeAnimationCutoff = 5242880;
>-#endif
>-
>-    // If we have decoded frames but there is no encoded data, we shouldn't destroy
>-    // the decoded image since we won't be able to reconstruct it later.
>-    if (!data() && m_frames.size())
>-        return;
>-
>-    unsigned allFrameBytes = 0;
>-    for (auto& frame : m_frames)
>-        allFrameBytes += frame.frameBytes();
>-
>-    if (allFrameBytes > largeAnimationCutoff) {
>-        LOG(Images, "BitmapImage %p destroyDecodedDataIfNecessary destroyingData: allFrameBytes=%u cutoff=%u", this, allFrameBytes, largeAnimationCutoff);
>-        destroyDecodedData(destroyAll);
>-    }
>-}
>-
>-void BitmapImage::destroyMetadataAndNotify(unsigned frameBytesCleared, ClearedSource clearedSource)
>-{
>-    m_solidColor = Nullopt;
>+    m_source.destroyDecodedData(destroyAll, m_currentFrame, data());
>     invalidatePlatformData();
>-
>-    ASSERT(m_decodedSize >= frameBytesCleared);
>-    m_decodedSize -= frameBytesCleared;
>-
>-    // Clearing the ImageSource destroys the extra decoded data used for determining image properties.
>-    if (clearedSource == ClearedSource::Yes) {
>-        frameBytesCleared += m_decodedPropertiesSize;
>-        m_decodedPropertiesSize = 0;
>-    }
>-
>-    if (frameBytesCleared && imageObserver())
>-        imageObserver()->decodedSizeChanged(this, -safeCast<int>(frameBytesCleared));
>-}
>-
>-void BitmapImage::cacheFrame(size_t index, SubsamplingLevel subsamplingLevel, ImageFrame::Caching caching)
>-{
>-    size_t numFrames = frameCount();
>-    ASSERT(m_decodedSize == 0 || numFrames > 1);
>-    
>-    if (m_frames.size() < numFrames)
>-        m_frames.grow(numFrames);
>-
>-    if (caching == ImageFrame::Caching::MetadataAndImage) {
>-        NativeImagePtr image = m_source.createFrameImageAtIndex(index, subsamplingLevel);
>-        m_frames[index].initialize(WTFMove(image), *m_source.decoder(), index, subsamplingLevel, repetitionCount(false));
>-    } else
>-        m_frames[index].initialize(nullptr, *m_source.decoder(), index, subsamplingLevel, repetitionCount(false));
>-
>-    LOG(Images, "BitmapImage %p cacheFrame %lu (%s%u bytes, complete %d)", this, index, caching == ImageFrame::Caching::Metadata ? "metadata only, " : "", m_frames[index].frameBytes(), m_frames[index].isComplete());
>-
>-    if (m_frames[index].hasNativeImage()) {
>-        int deltaBytes = safeCast<int>(m_frames[index].frameBytes());
>-        m_decodedSize += deltaBytes;
>-        // The fully-decoded frame will subsume the partially decoded data used
>-        // to determine image properties.
>-        deltaBytes -= m_decodedPropertiesSize;
>-        m_decodedPropertiesSize = 0;
>-        if (imageObserver())
>-            imageObserver()->decodedSizeChanged(this, deltaBytes);
>-    }
> }
> 
>-void BitmapImage::didDecodeProperties() const
>-{
>-    if (m_decodedSize)
>-        return;
>-
>-    size_t updatedSize = m_source.bytesDecodedToDetermineProperties();
>-    if (m_decodedPropertiesSize == updatedSize)
>-        return;
>-
>-    int deltaBytes = updatedSize - m_decodedPropertiesSize;
>-#if !ASSERT_DISABLED
>-    bool overflow = updatedSize > m_decodedPropertiesSize && deltaBytes < 0;
>-    bool underflow = updatedSize < m_decodedPropertiesSize && deltaBytes > 0;
>-    ASSERT(!overflow && !underflow);
>-#endif
>-    m_decodedPropertiesSize = updatedSize;
>-    if (imageObserver())
>-        imageObserver()->decodedSizeChanged(this, deltaBytes);
>-}
>-
>-void BitmapImage::updateSize() const
>-{
>-    if (!m_sizeAvailable || m_haveSize)
>-        return;
>-
>-    m_size = m_source.size();
>-    m_sizeRespectingOrientation = m_source.sizeRespectingOrientation();
>-
>-    m_haveSize = true;
>-    didDecodeProperties();
>-}
>-
>-FloatSize BitmapImage::size() const
>-{
>-    updateSize();
>-    return m_size;
>-}
>-
>-IntSize BitmapImage::sizeRespectingOrientation() const
>-{
>-    updateSize();
>-    return m_sizeRespectingOrientation;
>-}
>-
>-Optional<IntPoint> BitmapImage::hotSpot() const
>+void BitmapImage::destroyDecodedDataIfNecessary(bool destroyAll)
> {
>-    auto result = m_source.hotSpot();
>-    didDecodeProperties();
>-    return result;
>+    m_source.destroyDecodedDataIfNecessary(destroyAll, m_currentFrame, data());
> }
> 
> bool BitmapImage::dataChanged(bool allDataReceived)
> {
>-    // Because we're modifying the current frame, clear its (now possibly
>-    // inaccurate) metadata as well.
>-#if !PLATFORM(IOS)
>-    // Clear all partially-decoded frames. For most image formats, there is only
>-    // one frame, but at least GIF and ICO can have more. With GIFs, the frames
>-    // come in order and we ask to decode them in order, waiting to request a
>-    // subsequent frame until the prior one is complete. Given that we clear
>-    // incomplete frames here, this means there is at most one incomplete frame
>-    // (even if we use destroyDecodedData() -- since it doesn't reset the
>-    // metadata), and it is after all the complete frames.
>-    //
>-    // 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.
>-    unsigned frameBytesCleared = 0;
>-    for (auto& frame : m_frames) {
>-        // NOTE: Don't call frameIsCompleteAtIndex() here, that will try to
>-        // decode any uncached (i.e. never-decoded or
>-        // cleared-on-a-previous-pass) frames!
>-        if (frame.hasMetadata() && !frame.isComplete())
>-            frameBytesCleared += frame.clear();
>-    }
>-    destroyMetadataAndNotify(frameBytesCleared, ClearedSource::No);
>-#else
>-    // FIXME: why is this different for iOS?
>-    int deltaBytes = 0;
>-    if (!m_frames.isEmpty()) {
>-        if (int bytes = m_frames[m_frames.size() - 1].clear()) {
>-            deltaBytes += bytes;
>-            deltaBytes += m_decodedPropertiesSize;
>-            m_decodedPropertiesSize = 0;
>-        }
>-    }
>-    destroyMetadataAndNotify(deltaBytes, ClearedSource::No);
>-#endif
>-    
>-    // Feed all the data we've seen so far to the image decoder.
>-    m_allDataReceived = allDataReceived;
>-#if PLATFORM(IOS)
>-    // FIXME: We should expose a setting to enable/disable progressive loading and make this
>-    // code conditional on it. Then we can remove the PLATFORM(IOS)-guard.
>-    static const double chunkLoadIntervals[] = {0, 1, 3, 6, 15};
>-    double interval = chunkLoadIntervals[std::min(m_progressiveLoadChunkCount, static_cast<uint16_t>(4))];
>-
>-    bool needsUpdate = false;
>-    if (currentTime() - m_progressiveLoadChunkTime > interval) { // The first time through, the chunk time will be 0 and the image will get an update.
>-        needsUpdate = true;
>-        m_progressiveLoadChunkTime = currentTime();
>-        ASSERT(m_progressiveLoadChunkCount <= std::numeric_limits<uint16_t>::max());
>-        ++m_progressiveLoadChunkCount;
>-    }
>-    if (needsUpdate || allDataReceived)
>-        m_source.setData(data(), allDataReceived);
>-#else
>-    m_source.setData(data(), allDataReceived);
>-#endif
>-
>-    m_haveFrameCount = false;
>-    m_source.setNeedsUpdateMetadata();
>-    return isSizeAvailable();
>-}
>-
>-size_t BitmapImage::frameCount()
>-{
>-    if (!m_haveFrameCount) {
>-        m_frameCount = m_source.frameCount();
>-        // If decoder is not initialized yet, m_source.frameCount() returns 0.
>-        if (m_frameCount) {
>-            didDecodeProperties();
>-            m_haveFrameCount = true;
>-        }
>-    }
>-    return m_frameCount;
>-}
>-
>-bool BitmapImage::isSizeAvailable()
>-{
>-    if (m_sizeAvailable)
>-        return true;
>-
>-    m_sizeAvailable = m_source.isSizeAvailable();
>-    didDecodeProperties();
>-
>-    return m_sizeAvailable;
>+    return m_source.dataChanged(data(), allDataReceived);
> }
> 
>-bool BitmapImage::ensureFrameAtIndexIsCached(size_t index, ImageFrame::Caching caching)
>+NativeImagePtr BitmapImage::frameImageAtIndex(size_t index, SubsamplingLevel subsamplingLevel)
> {
>-    if (index >= frameCount())
>-        return false;
>-
>-    if (index >= m_frames.size()
>-        || (caching == ImageFrame::Caching::MetadataAndImage && !m_frames[index].hasNativeImage())
>-        || (caching == ImageFrame::Caching::Metadata && !m_frames[index].hasMetadata()))
>-        cacheFrame(index, SubsamplingLevel::Default, caching);
>-
>-    return true;
>-}
>-
>-NativeImagePtr BitmapImage::frameImageAtIndex(size_t index, float presentationScaleHint)
>-{
>-    if (index >= frameCount())
>-        return nullptr;
>-
>-    SubsamplingLevel subsamplingLevel = m_source.subsamplingLevelForScale(presentationScaleHint);
>-    
>-    LOG(Images, "BitmapImage %p frameImageAtIndex - subsamplingLevel %d at scale %.4f", this, subsamplingLevel, presentationScaleHint);
>-
>-    // We may have cached a frame with a higher subsampling level, in which case we need to
>-    // re-decode with a lower level.
>-    if (index < m_frames.size() && m_frames[index].hasInvalidNativeImage(subsamplingLevel)) {
>-        LOG(Images, "  subsamplingLevel was %d, resampling", m_frames[index].subsamplingLevel());
>-
>-        // If the image is already cached, but at too small a size, re-decode a larger version.
>-        int sizeChange = -m_frames[index].clear();
>+    if (m_source.frameHasInvalidNativeImageAtIndex(index, subsamplingLevel))
>         invalidatePlatformData();
>-        m_decodedSize += sizeChange;
>-        if (imageObserver())
>-            imageObserver()->decodedSizeChanged(this, sizeChange);
>-    }
>-
>-    // If we haven't fetched a frame yet, do so.
>-    if (index >= m_frames.size() || !m_frames[index].hasNativeImage())
>-        cacheFrame(index, subsamplingLevel, ImageFrame::Caching::MetadataAndImage);
> 
>-    return m_frames[index].nativeImage();
>+    return m_source.frameImageAtIndex(index, subsamplingLevel);
> }
>-    
>+
> NativeImagePtr BitmapImage::nativeImage()
> {
>     return frameImageAtIndex(0);
>@@ -379,104 +97,36 @@ NativeImagePtr BitmapImage::nativeImageF
> {
>     return frameImageAtIndex(m_currentFrame);
> }
>-    
>+
> #if USE(CG)
> NativeImagePtr BitmapImage::nativeImageOfSize(const IntSize& size)
> {
>     size_t count = frameCount();
>-    
>+
>     for (size_t i = 0; i < count; ++i) {
>         auto image = frameImageAtIndex(i);
>         if (image && nativeImageSize(image) == size)
>             return image;
>     }
>-    
>+
>     // Fallback to the first frame image if we can't find the right size
>     return frameImageAtIndex(0);
> }
>-    
>+
> Vector<NativeImagePtr> BitmapImage::framesNativeImages()
> {
>     Vector<NativeImagePtr> images;
>     size_t count = frameCount();
>-    
>+
>     for (size_t i = 0; i < count; ++i) {
>         if (auto image = frameImageAtIndex(i))
>             images.append(image);
>     }
>-    
>-    return images;
>-}
>-#endif
>-
>-bool BitmapImage::frameIsCompleteAtIndex(size_t index)
>-{
>-    if (!ensureFrameAtIndexIsCached(index, ImageFrame::Caching::Metadata))
>-        return false;
>-
>-    return m_frames[index].isComplete();
>-}
>-
>-float BitmapImage::frameDurationAtIndex(size_t index)
>-{
>-    if (!ensureFrameAtIndexIsCached(index, ImageFrame::Caching::Metadata))
>-        return 0;
>-
>-    return m_frames[index].duration();
>-}
>-
>-bool BitmapImage::frameHasAlphaAtIndex(size_t index)
>-{
>-    if (!ensureFrameAtIndexIsCached(index, ImageFrame::Caching::Metadata))
>-        return true;
> 
>-    if (m_frames[index].hasMetadata())
>-        return m_frames[index].hasAlpha();
>-
>-    return m_source.frameHasAlphaAtIndex(index);
>-}
>-
>-bool BitmapImage::currentFrameKnownToBeOpaque()
>-{
>-    return !frameHasAlphaAtIndex(currentFrame());
>-}
>-
>-ImageOrientation BitmapImage::frameOrientationAtIndex(size_t index)
>-{
>-    if (!ensureFrameAtIndexIsCached(index, ImageFrame::Caching::Metadata))
>-        return ImageOrientation();
>-
>-    if (m_frames[index].hasMetadata())
>-        return m_frames[index].orientation();
>-
>-    return m_source.frameOrientationAtIndex(index);
>+    return images;
> }
> 
>-Color BitmapImage::singlePixelSolidColor()
>-{
>-    // If the image size is not available yet or if the image will be animating don't use the solid color optimization.
>-    if (frameCount() != 1)
>-        return Color();
>-
>-    if (m_solidColor)
>-        return m_solidColor.value();
>-
>-    // If the frame image is not loaded, first use the decoder to get the size of the image.
>-    if (!haveFrameImageAtIndex(0) && m_source.frameSizeAtIndex(0) != IntSize(1, 1)) {
>-        m_solidColor = Color();
>-        return m_solidColor.value();
>-    }
>-
>-    // Cache the frame image. The size will be calculated from the NativeImagePtr.
>-    if (!ensureFrameAtIndexIsCached(0))
>-        return Color();
>-
>-    ASSERT(m_frames.size());
>-    m_solidColor = nativeImageSinglePixelSolidColor(m_frames[0].nativeImage());
>-    
>-    ASSERT(m_solidColor);
>-    return m_solidColor.value();
>-}
>+#endif
> 
> #if !ASSERT_DISABLED
> bool BitmapImage::notSolidColor()
>@@ -485,20 +135,6 @@ bool BitmapImage::notSolidColor()
> }
> #endif
> 
>-RepetitionCount BitmapImage::repetitionCount(bool imageKnownToBeComplete)
>-{
>-    if ((m_repetitionCountStatus == Unknown) || ((m_repetitionCountStatus == Uncertain) && imageKnownToBeComplete)) {
>-        // Snag the repetition count. If |imageKnownToBeComplete| is false, the
>-        // repetition count may not be accurate yet for GIFs; in this case the
>-        // decoder will default to RepetitionCountOnce, and we'll try and read
>-        // the count again once the whole image is decoded.
>-        m_repetitionCount = m_source.repetitionCount();
>-        didDecodeProperties();
>-        m_repetitionCountStatus = (imageKnownToBeComplete || m_repetitionCount == RepetitionCountNone) ? Certain : Uncertain;
>-    }
>-    return m_repetitionCount;
>-}
>-
> void BitmapImage::draw(GraphicsContext& context, const FloatRect& destRect, const FloatRect& srcRect, CompositeOperator op, BlendMode mode, ImageOrientationDescription description)
> {
>     if (destRect.isEmpty() || srcRect.isEmpty())
>@@ -516,7 +152,10 @@ void BitmapImage::draw(GraphicsContext& 
>         return;
>     }
> 
>-    auto image = frameImageAtIndex(m_currentFrame, subsamplingScale(context, destRect, srcRect));
>+    float scale = subsamplingScale(context, destRect, srcRect);
>+    SubsamplingLevel subsamplingLevel = m_source.subsamplingLevelForScale(scale);
>+
>+    auto image = frameImageAtIndex(m_currentFrame, subsamplingLevel);
>     if (!image) // If it's too early we won't have an image yet.
>         return;
> 
>@@ -524,12 +163,12 @@ void BitmapImage::draw(GraphicsContext& 
>     if (description.respectImageOrientation() == RespectImageOrientation)
>         orientation = frameOrientationAtIndex(m_currentFrame);
> 
>-    drawNativeImage(image, context, destRect, srcRect, m_size, op, mode, orientation);
>+    drawNativeImage(image, context, destRect, srcRect, IntSize(size()), op, mode, orientation);
> 
>     if (imageObserver())
>         imageObserver()->didDraw(this);
> }
>-    
>+
> void BitmapImage::drawPattern(GraphicsContext& ctxt, const FloatRect& tileRect, const AffineTransform& transform, const FloatPoint& phase, const FloatSize& spacing, CompositeOperator op, const FloatRect& destRect, BlendMode blendMode)
> {
>     if (tileRect.isEmpty())
>@@ -559,14 +198,14 @@ void BitmapImage::drawPattern(GraphicsCo
>         if (!m_cachedImage)
>             return;
>     }
>-    
>+
>     ctxt.setDrawLuminanceMask(false);
>     m_cachedImage->drawPattern(ctxt, tileRect, transform, phase, spacing, op, destRect, blendMode);
> }
> 
> bool BitmapImage::shouldAnimate()
> {
>-    return repetitionCount(false) && !m_animationFinished && imageObserver();
>+    return repetitionCount() && !m_animationFinished && imageObserver();
> }
> 
> bool BitmapImage::canAnimate()
>@@ -598,14 +237,14 @@ void BitmapImage::startAnimation(CatchUp
> 
>     // Don't advance the animation to an incomplete frame.
>     size_t nextFrame = (m_currentFrame + 1) % frameCount();
>-    if (!m_allDataReceived && !frameIsCompleteAtIndex(nextFrame))
>+    if (!m_source.isAllDataReceived() && !frameIsCompleteAtIndex(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) == RepetitionCountOnce && m_currentFrame >= (frameCount() - 1))
>+    if (!m_source.isAllDataReceived() && repetitionCount() == RepetitionCountOnce && m_currentFrame >= (frameCount() - 1))
>         return;
> 
>     // Determine time for next frame to start. By ignoring paint and timer lag
>@@ -656,7 +295,7 @@ void BitmapImage::startAnimation(CatchUp
> #if !LOG_DISABLED
>     size_t startCatchupFrameIndex = nextFrame;
> #endif
>-    
>+
>     for (size_t frameAfterNext = (nextFrame + 1) % frameCount(); frameIsCompleteAtIndex(frameAfterNext); frameAfterNext = (nextFrame + 1) % frameCount()) {
>         // Should we skip the next frame?
>         double frameAfterNextStartTime = m_desiredFrameStartTime + frameDurationAtIndex(nextFrame);
>@@ -700,7 +339,7 @@ bool BitmapImage::internalAdvanceAnimati
>         m_animationFinishedWhenCatchingUp = false;
>         return false;
>     }
>-    
>+
>     ++m_currentFrame;
>     bool advancedAnimation = true;
>     bool destroyAll = false;
>@@ -710,7 +349,7 @@ bool BitmapImage::internalAdvanceAnimati
>         // Get the repetition count again. If we weren't able to get a
>         // repetition count before, we should have decoded the whole image by
>         // now, so it should now be available.
>-        if (repetitionCount(true) != RepetitionCountInfinite && m_repetitionsComplete > m_repetitionCount) {
>+        if (repetitionCount() != RepetitionCountInfinite && m_repetitionsComplete > repetitionCount()) {
>             m_animationFinished = true;
>             m_desiredFrameStartTime = 0;
>             --m_currentFrame;
>@@ -744,7 +383,7 @@ void BitmapImage::resetAnimation()
>     m_repetitionsComplete = 0;
>     m_desiredFrameStartTime = 0;
>     m_animationFinished = false;
>-
>+    
>     // For extremely large animations, when the animation is reset, we just throw everything away.
>     destroyDecodedDataIfNecessary(true);
> }
>@@ -752,19 +391,11 @@ void BitmapImage::resetAnimation()
> void BitmapImage::dump(TextStream& ts) const
> {
>     Image::dump(ts);
>-
>-    ts.dumpProperty("type", m_source.filenameExtension());
>-
>-    if (isAnimated()) {
>-        ts.dumpProperty("frame-count", m_frameCount);
>-        ts.dumpProperty("repetitions", m_repetitionCount);
>-        ts.dumpProperty("current-frame", m_currentFrame);
>-    }
>     
>-    if (m_solidColor)
>-        ts.dumpProperty("solid-color", m_solidColor.value());
>+    if (isAnimated())
>+        ts.dumpProperty("current-frame", m_currentFrame);
>     
>-    m_source.dump(ts);
>+    const_cast<ImageSource&>(m_source).dump(ts);
> }
> 
> }
>Index: Source/WebCore/platform/graphics/BitmapImage.h
>===================================================================
>--- Source/WebCore/platform/graphics/BitmapImage.h	(revision 206259)
>+++ Source/WebCore/platform/graphics/BitmapImage.h	(working copy)
>@@ -25,8 +25,7 @@
>  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
>  */
> 
>-#ifndef BitmapImage_h
>-#define BitmapImage_h
>+#pragma once
> 
> #include "Image.h"
> #include "Color.h"
>@@ -67,28 +66,27 @@ public:
>     
>     bool hasSingleSecurityOrigin() const override { return true; }
> 
>-    // FloatSize due to override.
>-    FloatSize size() const override;
>-    IntSize sizeRespectingOrientation() const;
>+    bool isSizeAvailable() { return m_source.isSizeAvailable(); }
>+    size_t frameCount() { return m_source.frameCount(); }
> 
>-    Optional<IntPoint> hotSpot() const override;
>+    // FloatSize due to override.
>+    FloatSize size() const override { return const_cast<ImageSource&>(m_source).size(); }
>+    IntSize sizeRespectingOrientation() const { return const_cast<ImageSource&>(m_source).sizeRespectingOrientation(); }
>+    Optional<IntPoint> hotSpot() const override { return const_cast<ImageSource&>(m_source).hotSpot(); }
>+    Color singlePixelSolidColor() override { return m_source.singlePixelSolidColor(); }
>+    String filenameExtension() const override { return const_cast<ImageSource&>(m_source).filenameExtension(); }
>+    RepetitionCount repetitionCount() { return m_source.repetitionCount(); }
>+
>+    bool frameIsCompleteAtIndex(size_t index) { return m_source.frameIsCompleteAtIndex(index); }
>+    float frameDurationAtIndex(size_t index) { return m_source.frameDurationAtIndex(index); }
>+    bool frameHasAlphaAtIndex(size_t index) { return m_source.frameHasAlphaAtIndex(index); }
>+    ImageOrientation frameOrientationAtIndex(size_t index) { return m_source.frameOrientationAtIndex(index); }
> 
>-    unsigned decodedSize() const { return m_decodedSize; }
>+    unsigned decodedSize() const { return m_source.decodedSize(); }
> 
>     bool dataChanged(bool allDataReceived) override;
>-    String filenameExtension() const override { return m_source.filenameExtension(); }
>-
>-    // It may look unusual that there is no start animation call as public API. This is because
>-    // we start and stop animating lazily. Animation begins whenever someone draws the image. It will
>-    // automatically pause once all observers no longer want to render the image anywhere.
>-    void stopAnimation() override;
>-    void resetAnimation() override;
>-
>-    void drawPattern(GraphicsContext&, const FloatRect& srcRect, const AffineTransform& patternTransform,
>-        const FloatPoint& phase, const FloatSize& spacing, CompositeOperator, const FloatRect& destRect, BlendMode = BlendModeNormal) override;
> 
>     // Accessors for native image formats.
>-
> #if USE(APPKIT)
>     NSImage* getNSImage() override;
> #endif
>@@ -118,15 +116,11 @@ public:
> #endif
>     ImageOrientation orientationForCurrentFrame() override { return frameOrientationAtIndex(currentFrame()); }
> 
>-    bool currentFrameKnownToBeOpaque() override;
>+    size_t currentFrame() const { return m_currentFrame; }
> 
>-    bool isAnimated() const override { return m_frameCount > 1; }
>-    
>-    bool canAnimate();
>+    bool currentFrameKnownToBeOpaque() override { return !frameHasAlphaAtIndex(currentFrame()); }
> 
>     void setAllowSubsampling(bool allowSubsampling) { m_source.setAllowSubsampling(allowSubsampling); }
>-
>-    size_t currentFrame() const { return m_currentFrame; }
>     
> private:
>     bool isBitmapImage() const override { return true; }
>@@ -134,41 +128,10 @@ private:
>     void updateSize() const;
> 
> protected:
>-    enum RepetitionCountStatus {
>-      Unknown,    // We haven't checked the source's repetition count.
>-      Uncertain,  // We have a repetition count, but it might be wrong (some GIFs have a count after the image data, and will report "loop once" until all data has been decoded).
>-      Certain     // The repetition count is known to be correct.
>-    };
>-
>     WEBCORE_EXPORT BitmapImage(NativeImagePtr&&, ImageObserver* = nullptr);
>     WEBCORE_EXPORT BitmapImage(ImageObserver* = nullptr);
> 
>-#if PLATFORM(WIN)
>-    void drawFrameMatchingSourceSize(GraphicsContext&, const FloatRect& dstRect, const IntSize& srcSize, CompositeOperator) override;
>-#endif
>-    void draw(GraphicsContext&, const FloatRect& dstRect, const FloatRect& srcRect, CompositeOperator, BlendMode, ImageOrientationDescription) override;
>-
>-#if USE(WINGDI)
>-    virtual void drawPattern(GraphicsContext&, const FloatRect& srcRect, const AffineTransform& patternTransform,
>-        const FloatPoint& phase, const FloatSize& spacing, CompositeOperator, const FloatRect& destRect);
>-#endif
>-
>-    size_t frameCount();
>-
>-    NativeImagePtr frameImageAtIndex(size_t, float presentationScaleHint = 1);
>-
>-    bool haveFrameImageAtIndex(size_t);
>-
>-    bool frameIsCompleteAtIndex(size_t);
>-    float frameDurationAtIndex(size_t);
>-    bool frameHasAlphaAtIndex(size_t);
>-    ImageOrientation frameOrientationAtIndex(size_t);
>-
>-    // Decodes and caches a frame. Never accessed except internally.
>-    void cacheFrame(size_t index, SubsamplingLevel, ImageFrame::Caching = ImageFrame::Caching::MetadataAndImage);
>-
>-    // Called before accessing m_frames[index] for info without decoding. Returns false on index out of bounds.
>-    bool ensureFrameAtIndexIsCached(size_t index, ImageFrame::Caching = ImageFrame::Caching::MetadataAndImage);
>+    NativeImagePtr frameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default);
> 
>     // Called to invalidate cached data. When |destroyAll| is true, we wipe out
>     // the entire frame buffer cache and tell the image source to destroy
>@@ -182,24 +145,22 @@ protected:
>     // |destroyAll| along.
>     void destroyDecodedDataIfNecessary(bool destroyAll);
> 
>-    // Generally called by destroyDecodedData(), destroys whole-image metadata
>-    // and notifies observers that the memory footprint has (hopefully)
>-    // decreased by |frameBytesCleared|.
>-    enum class ClearedSource { No, Yes };
>-    void destroyMetadataAndNotify(unsigned frameBytesCleared, ClearedSource);
>-
>-    // Whether or not size is available yet.
>-    bool isSizeAvailable();
>-
>     // Called after asking the source for any information that may require
>     // decoding part of the image (e.g., the image size). We need to report
>     // the partially decoded data to our observer so it has an accurate
>     // account of the BitmapImage's memory usage.
>     void didDecodeProperties() const;
> 
>+    void draw(GraphicsContext&, const FloatRect& dstRect, const FloatRect& srcRect, CompositeOperator, BlendMode, ImageOrientationDescription) override;
>+    void drawPattern(GraphicsContext&, const FloatRect& srcRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize& spacing, CompositeOperator, const FloatRect& destRect, BlendMode = BlendModeNormal) override;
>+#if PLATFORM(WIN)
>+    void drawFrameMatchingSourceSize(GraphicsContext&, const FloatRect& dstRect, const IntSize& srcSize, CompositeOperator) override;
>+#endif
>+
>     // Animation.
>-    RepetitionCount repetitionCount(bool imageKnownToBeComplete); // |imageKnownToBeComplete| should be set if the caller knows the entire image has been decoded.
>+    bool isAnimated() const override { return const_cast<BitmapImage*>(this)->frameCount() > 1; }
>     bool shouldAnimate();
>+    bool canAnimate();
>     void startAnimation(CatchUpAnimation = CatchUp) override;
>     void advanceAnimation();
> 
>@@ -211,11 +172,15 @@ protected:
>     enum AnimationAdvancement { Normal, SkippingFramesToCatchUp };
>     bool internalAdvanceAnimation(AnimationAdvancement = Normal);
> 
>+    // It may look unusual that there is no start animation call as public API. This is because
>+    // we start and stop animating lazily. Animation begins whenever someone draws the image. It will
>+    // automatically pause once all observers no longer want to render the image anywhere.
>+    void stopAnimation() override;
>+    void resetAnimation() override;
>+
>     // Handle platform-specific data
>     void invalidatePlatformData();
> 
>-    Color singlePixelSolidColor() override;
>-
> #if !ASSERT_DISABLED
>     bool notSolidColor() override;
> #endif
>@@ -223,21 +188,16 @@ protected:
> private:
>     void clearTimer();
>     void startTimer(double delay);
>-
>     void dump(TextStream&) const override;
> 
>     ImageSource m_source;
>-    mutable IntSize m_size; // The size to use for the overall image (will just be the size of the first image).
>-    mutable IntSize m_sizeRespectingOrientation;
> 
>     size_t m_currentFrame { 0 }; // The index of the current frame of animation.
>-    Vector<ImageFrame, 1> m_frames; // An array of the cached frames of the animation. We have to ref frames to pin them in the cache.
>-
>     std::unique_ptr<Timer> m_frameTimer;
>-    RepetitionCount m_repetitionCount { RepetitionCountNone }; // How many total animation loops we should do. This will be cAnimationNone if this image type is incapable of animation.
>-    RepetitionCountStatus m_repetitionCountStatus { Unknown };
>     RepetitionCount m_repetitionsComplete { RepetitionCountNone }; // How many repetitions we've finished.
>     double m_desiredFrameStartTime { 0 }; // The system time at which we hope to see the next call to startAnimation().
>+    bool m_animationFinished { false };
>+    bool m_animationFinishedWhenCatchingUp { false };
> 
> #if USE(APPKIT)
>     mutable RetainPtr<NSImage> m_nsImage; // A cached NSImage of frame 0. Only built lazily if someone actually queries for one.
>@@ -245,34 +205,9 @@ private:
> #if USE(CG)
>     mutable RetainPtr<CFDataRef> m_tiffRep; // Cached TIFF rep for frame 0. Only built lazily if someone queries for one.
> #endif
>-
>-    // The value of this data member is a missing value if we havenât analyzed to check for a solid color or not, but an invalid
>-    // color if we have analyzed and decided itâs not a solid color, and a valid color if we have analyzed and decide that the
>-    // solid color optimization applies. The analysis, we do, handles only the case of 1x1 solid color images.
>-    Optional<Color> m_solidColor;
>-
>-    unsigned m_decodedSize { 0 }; // The current size of all decoded frames.
>-    mutable unsigned m_decodedPropertiesSize { 0 }; // The size of data decoded by the source to determine image properties (e.g. size, frame count, etc).
>-    size_t m_frameCount;
>-
>-#if PLATFORM(IOS)
>-    // FIXME: We should expose a setting to enable/disable progressive loading remove the PLATFORM(IOS)-guard.
>-    double m_progressiveLoadChunkTime { 0 };
>-    uint16_t m_progressiveLoadChunkCount { 0 };
>-#endif
>-    bool m_animationFinished : 1; // Whether or not we've completed the entire animation.
>-
>-    bool m_allDataReceived : 1; // Whether or not we've received all our data.
>-    mutable bool m_haveSize : 1; // Whether or not our |m_size| member variable has the final overall image size yet.
>-    bool m_sizeAvailable : 1; // Whether or not we can obtain the size of the first image frame yet from ImageIO.
>-    mutable bool m_haveFrameCount : 1;
>-    bool m_animationFinishedWhenCatchingUp : 1;
>-
>     RefPtr<Image> m_cachedImage;
> };
> 
> } // namespace WebCore
> 
> SPECIALIZE_TYPE_TRAITS_IMAGE(BitmapImage)
>-
>-#endif // BitmapImage_h
>Index: Source/WebCore/platform/graphics/ImageFrame.cpp
>===================================================================
>--- Source/WebCore/platform/graphics/ImageFrame.cpp	(revision 206259)
>+++ Source/WebCore/platform/graphics/ImageFrame.cpp	(working copy)
>@@ -26,11 +26,7 @@
> #include "config.h"
> #include "ImageFrame.h"
> 
>-#if USE(CG)
>-#include "ImageDecoderCG.h"
>-#else
>-#include "ImageDecoder.h"
>-#endif
>+#include <wtf/NeverDestroyed.h>
> 
> namespace WebCore {
> 
>@@ -43,6 +39,12 @@ ImageFrame::~ImageFrame()
>     clearImage();
> }
> 
>+const ImageFrame& ImageFrame::defaultFrame()
>+{
>+    static NeverDestroyed<ImageFrame> sharedInstance;
>+    return sharedInstance;
>+}
>+
> ImageFrame& ImageFrame::operator=(const ImageFrame& other)
> {
>     if (this == &other)
>@@ -68,19 +70,6 @@ ImageFrame& ImageFrame::operator=(const 
>     return *this;
> }
> 
>-void ImageFrame::fillMetadata(ImageDecoder& decoder, size_t index, SubsamplingLevel subsamplingLevel, bool animating)
>-{
>-    m_decoding = decoder.frameIsCompleteAtIndex(index) ? Decoding::Complete : Decoding::Partial;
>-    m_size = decoder.frameSizeAtIndex(index, subsamplingLevel);
>-
>-    m_subsamplingLevel = subsamplingLevel;
>-
>-    m_orientation = decoder.frameOrientationAtIndex(index);
>-    if (animating)
>-        m_duration = decoder.frameDurationAtIndex(index);
>-    m_hasAlpha = decoder.frameHasAlphaAtIndex(index);
>-}
>-
> unsigned ImageFrame::clearImage()
> {
> #if !USE(CG)
>@@ -106,16 +95,6 @@ unsigned ImageFrame::clear()
>     return frameBytes;
> }
> 
>-void ImageFrame::initialize(NativeImagePtr&& nativeImage, ImageDecoder& decoder, size_t index, SubsamplingLevel subsamplingLevel, bool animating)
>-{
>-    m_nativeImage = WTFMove(nativeImage);
>-
>-    if (!hasMetadata())
>-        fillMetadata(decoder, index, subsamplingLevel, animating);
>-    else if (!isComplete())
>-        m_decoding = decoder.frameIsCompleteAtIndex(index) ? Decoding::Complete : Decoding::Partial;
>-}
>-
> void ImageFrame::initialize(NativeImagePtr&& nativeImage)
> {
>     m_nativeImage = WTFMove(nativeImage);
>Index: Source/WebCore/platform/graphics/ImageFrame.h
>===================================================================
>--- Source/WebCore/platform/graphics/ImageFrame.h	(revision 206259)
>+++ Source/WebCore/platform/graphics/ImageFrame.h	(working copy)
>@@ -34,7 +34,6 @@
> namespace WebCore {
> 
> class Color;
>-class ImageDecoder;
> 
> // There are four subsampling levels: 0 = 1x, 1 = 0.5x, 2 = 0.25x, 3 = 0.125x.
> enum class SubsamplingLevel {
>@@ -64,26 +63,33 @@ enum {
>     RepetitionCountInfinite = -1,
> };
> 
>+enum class AlphaOption {
>+    Premultiplied,
>+    NotPremultiplied
>+};
>+
>+enum class GammaAndColorProfileOption {
>+    Applied,
>+    Ignored
>+};
>+
> class ImageFrame {
> public:
>     enum class Caching { Empty, Metadata, MetadataAndImage };
>     enum class Decoding { Empty, Partial, Complete };
> 
>     ImageFrame();
>-    ImageFrame(NativeImagePtr&&);
>     ImageFrame(const ImageFrame& other) { operator=(other); }
> 
>     ~ImageFrame();
> 
>+    static const ImageFrame& defaultFrame();
>+
>     ImageFrame& operator=(const ImageFrame& other);
> 
>     unsigned clearImage();
>     unsigned clear();
> 
>-    // FIXME: Calling ImageDecoder::repetitionCount() is expensive to be done for every frame.
>-    // Remove the 'animating' flag from this function when calling repetitionCount() is cheap
>-    // because it will be cached by ImageDecoder or a sub-class of it.
>-    void initialize(NativeImagePtr&&, ImageDecoder&, size_t, SubsamplingLevel, bool animating);
>     void initialize(NativeImagePtr&&);
> #if !USE(CG)
>     bool initialize(const ImageBackingStore&);
>@@ -96,9 +102,12 @@ public:
>     bool isPartial() const { return m_decoding == Decoding::Partial; }
>     bool isComplete() const { return m_decoding == Decoding::Complete; }
> 
>+    void setSize(const IntSize& size) { m_size = size; }
>     IntSize size() const;
>     IntSize sizeRespectingOrientation() const { return !m_orientation.usesWidthAsHeight() ? size() : size().transposedSize(); }
>     unsigned frameBytes() const { return hasNativeImage() ? size().area() * sizeof(RGBA32) : 0; }
>+
>+    void setSubsamplingLevel(SubsamplingLevel subsamplingLevel) { m_subsamplingLevel = subsamplingLevel; }
>     SubsamplingLevel subsamplingLevel() const { return m_subsamplingLevel; }
> 
> #if !USE(CG)
>@@ -107,16 +116,17 @@ public:
>     DisposalMethod disposalMethod() const { return m_disposalMethod; }
> #endif
> 
>+    void setNativeImage(NativeImagePtr&& nativeImage) { m_nativeImage = WTFMove(nativeImage); }
>     NativeImagePtr nativeImage() const { return m_nativeImage; }
> 
>     void setOrientation(ImageOrientation orientation) { m_orientation = orientation; };
>     ImageOrientation orientation() const { return m_orientation; }
> 
>-    void setDuration(unsigned duration) { m_duration = duration; }
>+    void setDuration(float duration) { m_duration = duration; }
>     float duration() const { return m_duration; }
> 
>     void setHasAlpha(bool hasAlpha) { m_hasAlpha = hasAlpha; }
>-    bool hasAlpha() const { return m_hasAlpha; }
>+    bool hasAlpha() const { return !hasMetadata() || m_hasAlpha; }
> 
>     bool hasNativeImage() const { return m_nativeImage; }
>     bool hasInvalidNativeImage(SubsamplingLevel subsamplingLevel) const { return hasNativeImage() && subsamplingLevel < m_subsamplingLevel; }
>@@ -130,8 +140,6 @@ public:
>     Color singlePixelSolidColor() const;
> 
> private:
>-    void fillMetadata(ImageDecoder&, size_t, SubsamplingLevel, bool animating);
>-
>     Decoding m_decoding { Decoding::Empty };
>     IntSize m_size;
> 
>Index: Source/WebCore/platform/graphics/ImageFrameCache.cpp
>===================================================================
>--- Source/WebCore/platform/graphics/ImageFrameCache.cpp	(nonexistent)
>+++ Source/WebCore/platform/graphics/ImageFrameCache.cpp	(working copy)
>@@ -0,0 +1,146 @@
>+/*
>+ * Copyright (C) 2016 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
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#include "config.h"
>+#include "ImageFrameCache.h"
>+
>+#include "Image.h"
>+#include "ImageObserver.h"
>+
>+namespace WebCore {
>+
>+ImageFrameCache::ImageFrameCache(Image* image)
>+    : m_image(image)
>+{
>+}
>+
>+ImageFrameCache::ImageFrameCache(NativeImagePtr&& nativeImage)
>+{
>+    m_frames.grow(1);
>+    m_frames[0].initialize(WTFMove(nativeImage));
>+    m_decodedSize = m_frames[0].frameBytes();
>+}
>+
>+void ImageFrameCache::grow(size_t size)
>+{
>+    if (m_frames.size() < size)
>+        m_frames.grow(size);
>+}
>+
>+void ImageFrameCache::destroyDecodedData(bool destroyAll, size_t count)
>+{
>+    if (destroyAll)
>+        count = m_frames.size();
>+
>+    unsigned decodedSize = 0;
>+    for (size_t i = 0; i <  count; ++i)
>+        decodedSize += m_frames[i].clearImage();
>+
>+    decodedSizeReset(decodedSize);
>+}
>+
>+bool ImageFrameCache::destroyDecodedDataIfNecessary(bool destroyAll, size_t count)
>+{
>+    unsigned decodedSize = 0;
>+    for (auto& frame : m_frames)
>+        decodedSize += frame.frameBytes();
>+
>+    if (decodedSize < LargeAnimationCutoff)
>+        return false;
>+
>+    destroyDecodedData(destroyAll, count);
>+    return true;
>+}
>+
>+void ImageFrameCache::destroyIncompleteDecodedData()
>+{
>+    unsigned decodedSize = 0;
>+
>+    for (auto& frame : m_frames) {
>+        if (!frame.hasMetadata() || frame.isComplete())
>+            continue;
>+
>+        decodedSize += frame.clear();
>+    }
>+
>+    decodedSizeDecremented(decodedSize);
>+}
>+
>+
>+void ImageFrameCache::decodedSizeChanged(int decodedSize)
>+{
>+    if (!decodedSize || !m_image || !m_image->imageObserver())
>+        return;
>+
>+    m_image->imageObserver()->decodedSizeChanged(m_image, decodedSize);
>+}
>+
>+void ImageFrameCache::decodedSizeIncremented(unsigned decodedSize)
>+{
>+    if (!decodedSize)
>+        return;
>+
>+    m_decodedSize += decodedSize;
>+
>+    // The fully-decoded frame will subsume the partially decoded data used
>+    // to determine image properties.
>+    int changeSize = decodedSize - m_decodedPropertiesSize;
>+    m_decodedPropertiesSize = 0;
>+    decodedSizeChanged(changeSize);
>+}
>+
>+void ImageFrameCache::decodedSizeDecremented(unsigned decodedSize)
>+{
>+    if (!decodedSize)
>+        return;
>+
>+    ASSERT(m_decodedSize >= decodedSize);
>+    m_decodedSize -= decodedSize;
>+    decodedSizeChanged(-safeCast<int>(decodedSize));
>+}
>+
>+void ImageFrameCache::decodedSizeReset(unsigned decodedSize)
>+{
>+    ASSERT(m_decodedSize >= decodedSize);
>+    m_decodedSize -= decodedSize;
>+
>+    // Clearing the ImageSource destroys the extra decoded data used for
>+    // determining image properties.
>+    decodedSize += m_decodedPropertiesSize;
>+    m_decodedPropertiesSize = 0;
>+    decodedSizeChanged(-safeCast<int>(decodedSize));
>+}
>+
>+void ImageFrameCache::didDecodeProperties(unsigned decodedPropertiesSize)
>+{
>+    if (m_decodedSize)
>+        return;
>+    
>+    int decodedSize = decodedPropertiesSize - m_decodedPropertiesSize;
>+    m_decodedPropertiesSize = decodedPropertiesSize;
>+    decodedSizeChanged(decodedSize);
>+}
>+    
>+}
>Index: Source/WebCore/platform/graphics/ImageFrameCache.h
>===================================================================
>--- Source/WebCore/platform/graphics/ImageFrameCache.h	(nonexistent)
>+++ Source/WebCore/platform/graphics/ImageFrameCache.h	(working copy)
>@@ -0,0 +1,73 @@
>+/*
>+ * Copyright (C) 2016 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
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#include "ImageFrame.h"
>+
>+namespace WebCore {
>+
>+class Image;
>+
>+class ImageFrameCache {
>+public:
>+    ImageFrameCache(Image*);
>+    ImageFrameCache(NativeImagePtr&&);
>+
>+    ImageFrame& operator[](size_t i) { return m_frames[i]; }
>+    const ImageFrame& operator[](size_t i) const { return m_frames[i]; }
>+
>+    void grow(size_t);
>+    size_t size() const { return m_frames.size(); }
>+
>+    unsigned decodedSize() const { return m_decodedSize; }
>+
>+    void destroyDecodedData(bool destroyAll, size_t count);
>+    bool destroyDecodedDataIfNecessary(bool destroyAll, size_t count);
>+
>+    void destroyIncompleteDecodedData();
>+
>+    void didDecodeProperties(unsigned decodedPropertiesSize);
>+    void decodedSizeIncremented(unsigned decodedSize);
>+    void decodedSizeDecremented(unsigned decodedSize);
>+    void decodedSizeReset(unsigned decodedSize);
>+
>+private:
>+    void decodedSizeChanged(int decodedSize);
>+
>+    // Animated images over a certain size are considered large enough that we'll only hang on to one frame at a time.
>+#if !PLATFORM(IOS)
>+    static const unsigned LargeAnimationCutoff = 5242880;
>+#else
>+    static const unsigned LargeAnimationCutoff = 2097152;
>+#endif
>+        
>+    Vector<ImageFrame, 1> m_frames;
>+    unsigned m_decodedSize { 0 };
>+    unsigned m_decodedPropertiesSize { 0 };
>+    Image* m_image;
>+};
>+    
>+}
>Index: Source/WebCore/platform/graphics/ImageFrameDecoder.cpp
>===================================================================
>--- Source/WebCore/platform/graphics/ImageFrameDecoder.cpp	(nonexistent)
>+++ Source/WebCore/platform/graphics/ImageFrameDecoder.cpp	(working copy)
>@@ -0,0 +1,96 @@
>+/*
>+ * Copyright (C) 2016 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
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#include "config.h"
>+#include "ImageFrameDecoder.h"
>+
>+#include "Image.h"
>+
>+namespace WebCore {
>+
>+ImageFrameDecoder::ImageFrameDecoder(ImageFrameCache& frameCache, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
>+    : ImageDecoder(alphaOption, gammaAndColorProfileOption)
>+    , m_frameCache(frameCache)
>+{
>+}
>+
>+void ImageFrameDecoder::clearMetadata()
>+{
>+    m_frameCount = Nullopt;
>+}
>+
>+void ImageFrameDecoder::setFrameMetadata(size_t index, SubsamplingLevel subsamplingLevel)
>+{
>+    ASSERT(index < m_frameCache.size());
>+    ImageFrame& frame = m_frameCache[index];
>+
>+    frame.setDecoding(frameIsCompleteAtIndex(index) ? ImageFrame::Decoding::Complete : ImageFrame::Decoding::Partial);
>+    if (frame.hasMetadata())
>+        return;
>+
>+    frame.setSubsamplingLevel(subsamplingLevel);
>+    frame.setSize(frameSizeAtIndex(index, subsamplingLevel));
>+    frame.setOrientation(frameOrientationAtIndex(index));
>+    frame.setHasAlpha(frameHasAlphaAtIndex(index));
>+
>+    if (repetitionCount())
>+        frame.setDuration(frameDurationAtIndex(index));
>+}
>+
>+void ImageFrameDecoder::setFrameImageAndMetadata(NativeImagePtr&& nativeImage, size_t index, SubsamplingLevel subsamplingLevel)
>+{
>+    ASSERT(index < m_frameCache.size());
>+    ImageFrame& frame = m_frameCache[index];
>+
>+    frame.setNativeImage(WTFMove(nativeImage));
>+    setFrameMetadata(index, subsamplingLevel);
>+}
>+
>+const ImageFrame* ImageFrameDecoder::frameAtIndex(size_t index, SubsamplingLevel subsamplingLevel, ImageFrame::Caching caching)
>+{
>+    ImageFrame* frame = index < m_frameCache.size() ? &m_frameCache[index] : nullptr;
>+    if (!frame || caching == ImageFrame::Caching::Empty)
>+        return frame;
>+
>+    if (subsamplingLevel == SubsamplingLevel::Undefinded)
>+        subsamplingLevel = frame->subsamplingLevel();
>+
>+    if (frame->hasInvalidNativeImage(subsamplingLevel)) {
>+        unsigned decodedSize = frame->clear();
>+        m_frameCache.decodedSizeDecremented(decodedSize);
>+    }
>+
>+    if (caching == ImageFrame::Caching::Metadata && !frame->isComplete())
>+        setFrameMetadata(index, subsamplingLevel);
>+
>+    if (caching == ImageFrame::Caching::MetadataAndImage && !frame->hasNativeImage()) {
>+        setFrameImageAndMetadata(createFrameImageAtIndex(index, subsamplingLevel), index, subsamplingLevel);
>+        m_frameCache.decodedSizeIncremented(frame->frameBytes());
>+    }
>+
>+    return frame;
>+}
>+    
>+}
>Index: Source/WebCore/platform/graphics/ImageFrameDecoder.h
>===================================================================
>--- Source/WebCore/platform/graphics/ImageFrameDecoder.h	(nonexistent)
>+++ Source/WebCore/platform/graphics/ImageFrameDecoder.h	(working copy)
>@@ -0,0 +1,97 @@
>+/*
>+ * Copyright (C) 2016 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
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#if USE(CG)
>+#include "ImageDecoderCG.h"
>+#else
>+#include "ImageDecoder.h"
>+#endif
>+
>+#include "ImageFrame.h"
>+#include "ImageFrameCache.h"
>+
>+namespace WebCore {
>+
>+class ImageFrameDecoder : public ImageDecoder {
>+public:
>+    static std::unique_ptr<ImageFrameDecoder> create(ImageFrameCache& frameCache, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
>+    {
>+        return std::unique_ptr<ImageFrameDecoder>(new ImageFrameDecoder(frameCache, alphaOption, gammaAndColorProfileOption));
>+    }
>+
>+    void clearMetadata();
>+
>+    template<typename T, T (ImageDecoder::*functor)() const>
>+    T metadata(const T& defaultValue, Optional<T>& cachedValue) const
>+    {
>+        if (cachedValue)
>+            return cachedValue.value();
>+
>+        if (!isSizeAvailable())
>+            return defaultValue;
>+
>+        cachedValue = (this->*functor)();
>+        m_frameCache.didDecodeProperties(bytesDecodedToDetermineProperties());
>+        return cachedValue.value();
>+    }
>+    
>+    bool isSizeAvailable() const
>+    {
>+        if (m_isSizeAvailable)
>+            return m_isSizeAvailable.value();
>+
>+        if (!ImageDecoder::isSizeAvailable())
>+            return false;
>+
>+        m_frameCache.didDecodeProperties(bytesDecodedToDetermineProperties());
>+        m_isSizeAvailable = true;
>+        return true;
>+    }
>+
>+    size_t frameCount() const { return metadata<size_t, (&ImageDecoder::frameCount)>(0, m_frameCount); }
>+    RepetitionCount repetitionCount() const { return metadata<RepetitionCount, (&ImageDecoder::repetitionCount)>(RepetitionCountNone, m_repetitionCount); }
>+    String filenameExtension() const { return metadata<String, (&ImageDecoder::filenameExtension)>(String(), m_filenameExtension); }
>+    Optional<IntPoint> hotSpot() const { return metadata<Optional<IntPoint>, (&ImageDecoder::hotSpot)>(Nullopt, m_hotSpot); }
>+
>+    const ImageFrame* frameAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Undefinded, ImageFrame::Caching = ImageFrame::Caching::Empty);
>+
>+private:
>+    ImageFrameDecoder(ImageFrameCache&, AlphaOption, GammaAndColorProfileOption);
>+
>+    void setFrameMetadata(size_t, SubsamplingLevel);
>+    void setFrameImageAndMetadata(NativeImagePtr&&, size_t, SubsamplingLevel);
>+    
>+    ImageFrameCache& m_frameCache;
>+
>+    mutable Optional<bool> m_isSizeAvailable;
>+    mutable Optional<size_t> m_frameCount;
>+    mutable Optional<RepetitionCount> m_repetitionCount;
>+    mutable Optional<String> m_filenameExtension;
>+    mutable Optional<Optional<IntPoint>> m_hotSpot;
>+};
>+    
>+}
>Index: Source/WebCore/platform/graphics/ImageSource.cpp
>===================================================================
>--- Source/WebCore/platform/graphics/ImageSource.cpp	(revision 206259)
>+++ Source/WebCore/platform/graphics/ImageSource.cpp	(working copy)
>@@ -29,23 +29,24 @@
> #include "config.h"
> #include "ImageSource.h"
> 
>-#if USE(CG)
>-#include "ImageDecoderCG.h"
>-#else
>-#include "ImageDecoder.h"
>-#endif
>-
>+#include "ImageFrameDecoder.h"
> #include "ImageOrientation.h"
> 
>+#include <wtf/CurrentTime.h>
>+
> namespace WebCore {
> 
>-ImageSource::ImageSource(const NativeImagePtr&)
>+ImageSource::ImageSource(NativeImagePtr&& nativeImage)
>+    : m_frameCache(WTFMove(nativeImage))
> {
>+    // Since we don't have a decoder, we can't figure out the image orientation.
>+    // Set m_sizeRespectingOrientation to be the same as m_size so it's not 0x0.
>+    m_size = m_frameCache[0].size();
>+    m_sizeRespectingOrientation = m_size;
> }
>     
>-ImageSource::ImageSource(ImageSource::AlphaOption alphaOption, ImageSource::GammaAndColorProfileOption gammaAndColorProfileOption)
>-    : m_needsUpdateMetadata(true)
>-    , m_maximumSubsamplingLevel(Nullopt)
>+ImageSource::ImageSource(Image* image, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
>+    : m_frameCache(image)
>     , m_alphaOption(alphaOption)
>     , m_gammaAndColorProfileOption(gammaAndColorProfileOption)
> {
>@@ -57,175 +58,276 @@ ImageSource::~ImageSource()
> 
> void ImageSource::clearFrameBufferCache(size_t clearBeforeFrame)
> {
>-    if (!initialized())
>+    if (!isDecoderAvailable())
>         return;
>     m_decoder->clearFrameBufferCache(clearBeforeFrame);
> }
> 
>-void ImageSource::clear(bool destroyAllFrames, size_t clearBeforeFrame, SharedBuffer* data, bool allDataReceived)
>+void ImageSource::clearMetadata()
>+{
>+    m_singlePixelSolidColor = Nullopt;
>+    m_maximumSubsamplingLevel = Nullopt;
>+    m_decoder->clearMetadata();
>+}
>+
>+void ImageSource::clear(bool destroyAll, size_t count, SharedBuffer* data)
> {
>     // There's no need to throw away the decoder unless we're explicitly asked
>     // to destroy all of the frames.
>-    if (!destroyAllFrames) {
>-        clearFrameBufferCache(clearBeforeFrame);
>+    if (!destroyAll) {
>+        clearFrameBufferCache(count);
>         return;
>     }
> 
>     m_decoder = nullptr;
>+    setData(data, isAllDataReceived());
>+}
> 
>-    if (data)
>-        setData(data, allDataReceived);
>+void ImageSource::destroyDecodedData(bool destroyAll, size_t count, SharedBuffer* data)
>+{
>+    ASSERT(isDecoderAvailable());
>+    m_frameCache.destroyDecodedData(destroyAll, count);
>+    clear(destroyAll, count, data);
>+}
>+
>+bool ImageSource::destroyDecodedDataIfNecessary(bool destroyAll, size_t count, SharedBuffer* data)
>+{
>+    // If we have decoded frames but there is no encoded data, we shouldn't destroy
>+    // the decoded image since we won't be able to reconstruct it later.
>+    if (!data && m_frameCache.size())
>+        return false;
>+
>+    if (!m_frameCache.destroyDecodedDataIfNecessary(destroyAll, count))
>+        return false;
>+
>+    clear(destroyAll, count, data);
>+    return true;
>+}
>+
>+bool ImageSource::ensureDecoderAvailable()
>+{
>+    if (isDecoderAvailable())
>+        return true;
>+
>+    m_decoder = ImageFrameDecoder::create(m_frameCache, m_alphaOption, m_gammaAndColorProfileOption);
>+    return isDecoderAvailable();
> }
> 
> void ImageSource::setData(SharedBuffer* data, bool allDataReceived)
> {
>-    if (!data)
>+    if (!data || !ensureDecoderAvailable())
>         return;
> 
>-    if (!initialized()) {
>-        m_decoder = ImageDecoder::create(*data, m_alphaOption, m_gammaAndColorProfileOption);
>-        if (!m_decoder)
>-            return;
>-    }
>-
>     m_decoder->setData(*data, allDataReceived);
> }
> 
>-SubsamplingLevel ImageSource::calculateMaximumSubsamplingLevel() const
>+bool ImageSource::dataChanged(SharedBuffer* data, bool allDataReceived)
> {
>-    if (!m_allowSubsampling || !frameAllowSubsamplingAtIndex(0))
>-        return SubsamplingLevel::Default;
>-    
>-    // FIXME: this value was chosen to be appropriate for iOS since the image
>-    // subsampling is only enabled by default on iOS. Choose a different value
>-    // if image subsampling is enabled on other platform.
>-    const int maximumImageAreaBeforeSubsampling = 5 * 1024 * 1024;
>+    if (!ensureDecoderAvailable())
>+        return false;
> 
>-    for (SubsamplingLevel level = SubsamplingLevel::First; level <= SubsamplingLevel::Last; ++level) {
>-        if (frameSizeAtIndex(0, level).area() < maximumImageAreaBeforeSubsampling)
>-            return level;
>+    m_frameCache.destroyIncompleteDecodedData();
>+
>+#if PLATFORM(IOS)
>+    // FIXME: We should expose a setting to enable/disable progressive loading and make this
>+    // code conditional on it. Then we can remove the PLATFORM(IOS)-guard.
>+    static const double chunkLoadIntervals[] = {0, 1, 3, 6, 15};
>+    double interval = chunkLoadIntervals[std::min(m_progressiveLoadChunkCount, static_cast<uint16_t>(4))];
>+
>+    bool needsUpdate = false;
>+
>+    // The first time through, the chunk time will be 0 and the image will get an update.
>+    if (currentTime() - m_progressiveLoadChunkTime > interval) {
>+        needsUpdate = true;
>+        m_progressiveLoadChunkTime = currentTime();
>+        ASSERT(m_progressiveLoadChunkCount <= std::numeric_limits<uint16_t>::max());
>+        ++m_progressiveLoadChunkCount;
>     }
>-    
>-    return SubsamplingLevel::Last;
>+
>+    if (needsUpdate || allDataReceived)
>+        setData(data, allDataReceived);
>+#else
>+    setData(data, allDataReceived);
>+#endif
>+
>+    clearMetadata();
>+    if (!isSizeAvailable())
>+        return false;
>+
>+    m_frameCache.grow(frameCount());
>+    return true;
> }
> 
>-void ImageSource::updateMetadata()
>+template<typename T, T (ImageFrame::*functor)() const>
>+T ImageSource::frameMetadataAtIndex(size_t index, SubsamplingLevel subsamplingLevel, ImageFrame::Caching caching, Optional<T>* cachedValue)
> {
>-    if (!(m_needsUpdateMetadata && isSizeAvailable()))
>-        return;
>+    if (cachedValue && *cachedValue)
>+        return cachedValue->value();
>+
>+    const ImageFrame* frame = nullptr;
>+
>+    if (isDecoderAvailable())
>+        frame = m_decoder->frameAtIndex(index, subsamplingLevel, caching);
>+    else if (index < m_frameCache.size())
>+        frame = &m_frameCache[index];
> 
>-    m_frameCount = m_decoder->frameCount();
>-    if (!m_maximumSubsamplingLevel)
>-        m_maximumSubsamplingLevel = calculateMaximumSubsamplingLevel();
>+    // Use defaultFrame to get the default values for all the farme metadata.
>+    if (!frame)
>+        frame = &ImageFrame::defaultFrame();
> 
>-    m_needsUpdateMetadata = false;
>+    // Don't cache any unavailable frame metadata.
>+    if (!frame->hasMetadata() || !cachedValue)
>+        return (frame->*functor)();
>+
>+    *cachedValue = (frame->*functor)();
>+    return cachedValue->value();
> }
>-    
>-SubsamplingLevel ImageSource::subsamplingLevelForScale(float scale)
>+
>+bool ImageSource::isAllDataReceived() const
> {
>-    if (!(scale > 0 && scale <= 1))
>-        return SubsamplingLevel::Default;
>+    return isDecoderAvailable() ? m_decoder->isAllDataReceived() : m_frameCache.size();
>+}
> 
>-    updateMetadata();
>-    if (!m_maximumSubsamplingLevel)
>-        return SubsamplingLevel::Default;
>+bool ImageSource::isSizeAvailable()
>+{
>+    return isDecoderAvailable() ? m_decoder->isSizeAvailable() : m_frameCache.size();
>+}
> 
>-    int result = std::ceil(std::log2(1 / scale));
>-    return static_cast<SubsamplingLevel>(std::min(result, static_cast<int>(m_maximumSubsamplingLevel.value())));
>+size_t ImageSource::frameCount()
>+{
>+    return isDecoderAvailable() ? m_decoder->frameCount() : m_frameCache.size();
> }
> 
>-size_t ImageSource::bytesDecodedToDetermineProperties()
>+RepetitionCount ImageSource::repetitionCount()
> {
>-    return ImageDecoder::bytesDecodedToDetermineProperties();
>+    return isDecoderAvailable() ? m_decoder->repetitionCount() : RepetitionCountNone;
> }
> 
>-bool ImageSource::isSizeAvailable() const
>+String ImageSource::filenameExtension()
> {
>-    return initialized() && m_decoder->isSizeAvailable();
>+    return isDecoderAvailable() ? m_decoder->filenameExtension() : String();
> }
> 
>-IntSize ImageSource::size() const
>+Optional<IntPoint> ImageSource::hotSpot()
> {
>-    return frameSizeAtIndex(0, SubsamplingLevel::Default);
>+    return isDecoderAvailable() ? m_decoder->hotSpot() : Nullopt;
> }
> 
>-IntSize ImageSource::sizeRespectingOrientation() const
>+IntSize ImageSource::size()
> {
>-    return frameSizeAtIndex(0, SubsamplingLevel::Default, RespectImageOrientation);
>+    return frameMetadataAtIndex<IntSize, (&ImageFrame::size)>(0, SubsamplingLevel::Default, ImageFrame::Caching::Metadata, &m_size);
> }
> 
>-size_t ImageSource::frameCount()
>+IntSize ImageSource::sizeRespectingOrientation()
> {
>-    updateMetadata();
>-    return m_frameCount;
>+    return frameMetadataAtIndex<IntSize, (&ImageFrame::sizeRespectingOrientation)>(0, SubsamplingLevel::Default, ImageFrame::Caching::Metadata, &m_sizeRespectingOrientation);
> }
> 
>-RepetitionCount ImageSource::repetitionCount()
>+SubsamplingLevel ImageSource::maximumSubsamplingLevel()
> {
>-    return initialized() ? m_decoder->repetitionCount() : RepetitionCountNone;
>+    if (m_maximumSubsamplingLevel)
>+        return m_maximumSubsamplingLevel.value();
>+
>+    if (!m_allowSubsampling || !m_decoder->frameAllowSubsamplingAtIndex(0))
>+        return SubsamplingLevel::Default;
>+
>+    // FIXME: this value was chosen to be appropriate for iOS since the image
>+    // subsampling is only enabled by default on iOS. Choose a different value
>+    // if image subsampling is enabled on other platform.
>+    const int maximumImageAreaBeforeSubsampling = 5 * 1024 * 1024;
>+    SubsamplingLevel level = SubsamplingLevel::First;
>+
>+    for (; level < SubsamplingLevel::Last; ++level) {
>+        if (frameSizeAtIndex(0, level).area() < maximumImageAreaBeforeSubsampling)
>+            break;
>+    }
>+
>+    m_maximumSubsamplingLevel = level;
>+    return m_maximumSubsamplingLevel.value();
> }
> 
>-String ImageSource::filenameExtension() const
>+SubsamplingLevel ImageSource::subsamplingLevelForScale(float scale)
> {
>-    return initialized() ? m_decoder->filenameExtension() : String();
>+    if (!(scale > 0 && scale <= 1))
>+        return SubsamplingLevel::Default;
>+
>+    int result = std::ceil(std::log2(1 / scale));
>+    return static_cast<SubsamplingLevel>(std::min(result, static_cast<int>(maximumSubsamplingLevel())));
> }
> 
>-Optional<IntPoint> ImageSource::hotSpot() const
>+Color ImageSource::singlePixelSolidColor()
> {
>-    return initialized() ? m_decoder->hotSpot() : Nullopt;
>+    return frameCount() == 1 ? frameMetadataAtIndex<Color, (&ImageFrame::singlePixelSolidColor)>(0, SubsamplingLevel::Undefinded, ImageFrame::Caching::MetadataAndImage, &m_singlePixelSolidColor) : Color();
> }
> 
> bool ImageSource::frameIsCompleteAtIndex(size_t index)
> {
>-    return initialized() && m_decoder->frameIsCompleteAtIndex(index);
>+    return frameMetadataAtIndex<bool, (&ImageFrame::isComplete)>(index);
> }
> 
> bool ImageSource::frameHasAlphaAtIndex(size_t index)
> {
>-    return !initialized() || m_decoder->frameHasAlphaAtIndex(index);
>+    return frameMetadataAtIndex<bool, (&ImageFrame::hasAlpha)>(index);
> }
> 
>-bool ImageSource::frameAllowSubsamplingAtIndex(size_t index) const
>+bool ImageSource::frameHasImageAtIndex(size_t index)
> {
>-    return initialized() && m_decoder->frameAllowSubsamplingAtIndex(index);
>+    return frameMetadataAtIndex<bool, (&ImageFrame::hasNativeImage)>(index);
> }
> 
>-IntSize ImageSource::frameSizeAtIndex(size_t index, SubsamplingLevel subsamplingLevel, RespectImageOrientationEnum shouldRespectImageOrientation) const
>+bool ImageSource::frameHasInvalidNativeImageAtIndex(size_t index, SubsamplingLevel subsamplingLevel)
> {
>-    if (!initialized())
>-        return { };
>+    return frameHasImageAtIndex(index) && subsamplingLevel < frameSubsamplingLevelAtIndex(index);
>+}
> 
>-    IntSize size = m_decoder->frameSizeAtIndex(index, subsamplingLevel);
>-    if (shouldRespectImageOrientation != RespectImageOrientation)
>-        return size;
>+SubsamplingLevel ImageSource::frameSubsamplingLevelAtIndex(size_t index)
>+{
>+    return frameMetadataAtIndex<SubsamplingLevel, (&ImageFrame::subsamplingLevel)>(index);
>+}
> 
>-    return frameOrientationAtIndex(index).usesWidthAsHeight() ? size.transposedSize() : size;
>+IntSize ImageSource::frameSizeAtIndex(size_t index, SubsamplingLevel subsamplingLevel)
>+{
>+    return frameMetadataAtIndex<IntSize, (&ImageFrame::size)>(index, subsamplingLevel, ImageFrame::Caching::Metadata);
> }
> 
>-unsigned ImageSource::frameBytesAtIndex(size_t index, SubsamplingLevel subsamplingLevel) const
>+unsigned ImageSource::frameBytesAtIndex(size_t index, SubsamplingLevel subsamplingLevel)
> {
>-    return frameSizeAtIndex(index, subsamplingLevel).area() * 4;
>+    return frameMetadataAtIndex<unsigned, (&ImageFrame::frameBytes)>(index, subsamplingLevel, ImageFrame::Caching::Metadata);
> }
> 
> float ImageSource::frameDurationAtIndex(size_t index)
> {
>-    return initialized() ? m_decoder->frameDurationAtIndex(index) : 0;
>+    return frameMetadataAtIndex<float, (&ImageFrame::duration)>(index, SubsamplingLevel::Undefinded, ImageFrame::Caching::Metadata);
> }
> 
>-ImageOrientation ImageSource::frameOrientationAtIndex(size_t index) const
>+ImageOrientation ImageSource::frameOrientationAtIndex(size_t index)
> {
>-    return initialized() ? m_decoder->frameOrientationAtIndex(index) : ImageOrientation();
>+    return frameMetadataAtIndex<ImageOrientation, (&ImageFrame::orientation)>(index, SubsamplingLevel::Undefinded, ImageFrame::Caching::Metadata);
> }
>-    
>+
>+NativeImagePtr ImageSource::frameImageAtIndex(size_t index, SubsamplingLevel subsamplingLevel)
>+{
>+    const ImageFrame* frame;
>+    if (isDecoderAvailable())
>+        frame = m_decoder->frameAtIndex(index, subsamplingLevel, ImageFrame::Caching::MetadataAndImage);
>+    else
>+        frame = index < m_frameCache.size() ? &m_frameCache[index] : nullptr;
>+
>+    return frame ? frame->nativeImage() : nullptr;
>+}
>+
> NativeImagePtr ImageSource::createFrameImageAtIndex(size_t index, SubsamplingLevel subsamplingLevel)
> {
>-    return initialized() ? m_decoder->createFrameImageAtIndex(index, subsamplingLevel) : nullptr;
>+    return isDecoderAvailable() ? m_decoder->createFrameImageAtIndex(index, subsamplingLevel) : nullptr;
> }
> 
>-void ImageSource::dump(TextStream& ts) const
>+void ImageSource::dump(TextStream& ts)
> {
>-    if (m_allowSubsampling)
>-        ts.dumpProperty("allow-subsampling", m_allowSubsampling);
>+    ts.dumpProperty("type", filenameExtension());
>+    ts.dumpProperty("frame-count", frameCount());
>+    ts.dumpProperty("repetitions", repetitionCount());
>+
>+    ts.dumpProperty("solid-color", singlePixelSolidColor());
>     
>     ImageOrientation orientation = frameOrientationAtIndex(0);
>     if (orientation != OriginTopLeft)
>Index: Source/WebCore/platform/graphics/ImageSource.h
>===================================================================
>--- Source/WebCore/platform/graphics/ImageSource.h	(revision 206259)
>+++ Source/WebCore/platform/graphics/ImageSource.h	(working copy)
>@@ -24,10 +24,10 @@
>  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
>  */
> 
>-#ifndef ImageSource_h
>-#define ImageSource_h
>+#pragma once
> 
> #include "ImageFrame.h"
>+#include "ImageFrameCache.h"
> #include "ImageOrientation.h"
> #include "IntPoint.h"
> #include "NativeImage.h"
>@@ -38,104 +38,76 @@
> 
> namespace WebCore {
> 
>+class ImageFrameDecoder;
> class ImageOrientation;
> class IntPoint;
> class IntSize;
> class SharedBuffer;
>-class ImageDecoder;
> 
> class ImageSource {
>     WTF_MAKE_NONCOPYABLE(ImageSource);
>     friend class BitmapImage;
> public:
>-    enum AlphaOption {
>-        AlphaPremultiplied,
>-        AlphaNotPremultiplied
>-    };
>-
>-    enum GammaAndColorProfileOption {
>-        GammaAndColorProfileApplied,
>-        GammaAndColorProfileIgnored
>-    };
>-
>-    ImageSource(const NativeImagePtr&);
>-    ImageSource(AlphaOption = AlphaPremultiplied, GammaAndColorProfileOption = GammaAndColorProfileApplied);
>+    ImageSource(NativeImagePtr&&);
>+    ImageSource(Image*, AlphaOption = AlphaOption::Premultiplied, GammaAndColorProfileOption = GammaAndColorProfileOption::Applied);
>     ~ImageSource();
> 
>-    // Tells the ImageSource that the Image no longer cares about decoded frame
>-    // data -- at all (if |destroyAll| is true), or before frame
>-    // |clearBeforeFrame| (if |destroyAll| is false).  The ImageSource should
>-    // delete cached decoded data for these frames where possible to keep memory
>-    // usage low.  When |destroyAll| is true, the ImageSource should also reset
>-    // any local state so that decoding can begin again.
>-    //
>-    // Implementations that delete less than what's specified above waste
>-    // memory.  Implementations that delete more may burn CPU re-decoding frames
>-    // that could otherwise have been cached, or encounter errors if they're
>-    // asked to decode frames they can't decode due to the loss of previous
>-    // decoded frames.
>-    //
>-    // Callers should not call clear(false, n) and subsequently call
>-    // createFrameImageAtIndex(m) with m < n, unless they first call clear(true).
>-    // This ensures that stateful ImageSources/decoders will work properly.
>-    //
>-    // The |data| and |allDataReceived| parameters should be supplied by callers
>-    // who set |destroyAll| to true if they wish to be able to continue using
>-    // the ImageSource.  This way implementations which choose to destroy their
>-    // decoders in some cases can reconstruct them correctly.
>-    void clear(bool destroyAll, size_t clearBeforeFrame = 0, SharedBuffer* data = nullptr, bool allDataReceived = false);
>-
>-    // FIXME: Remove the decoder() function from this class when caching the ImageFrame is moved outside BitmapImage.
>-    ImageDecoder* decoder() const { return m_decoder.get(); }
>-    bool initialized() const { return m_decoder.get(); }
>+    void destroyDecodedData(bool destroyAll, size_t count, SharedBuffer* data);
>+    bool destroyDecodedDataIfNecessary(bool destroyAll, size_t count, SharedBuffer* data);
>+
>+    bool ensureDecoderAvailable();
>+    bool isDecoderAvailable() const { return m_decoder.get(); }
> 
>     void setData(SharedBuffer* data, bool allDataReceived);
>-    
>-    void setNeedsUpdateMetadata() { m_needsUpdateMetadata = true; }
>+    bool dataChanged(SharedBuffer* data, bool allDataReceived);
> 
>-    SubsamplingLevel subsamplingLevelForScale(float);
>-    void setAllowSubsampling(bool allowSubsampling) { m_allowSubsampling = allowSubsampling; }
>-    static size_t bytesDecodedToDetermineProperties();
>-    
>-    bool isSizeAvailable() const;
>-    // Always original size, without subsampling.
>-    IntSize size() const;
>-    IntSize sizeRespectingOrientation() const;
>+    unsigned decodedSize() const { return m_frameCache.decodedSize(); }
>+    bool isAllDataReceived() const;
>+
>+    template<typename T, T (ImageFrame::*functor)() const>
>+    T frameMetadataAtIndex(size_t index, SubsamplingLevel = SubsamplingLevel::Undefinded, ImageFrame::Caching = ImageFrame::Caching::Empty, Optional<T>* = nullptr);
> 
>+    // Image metadata which is calculated by the decoder or can deduced by the case of the memory NativeImage.
>+    bool isSizeAvailable();
>     size_t frameCount();
>     RepetitionCount repetitionCount();
>-    String filenameExtension() const;
>-    Optional<IntPoint> hotSpot() const;
>+    String filenameExtension();
>+    Optional<IntPoint> hotSpot();
> 
>-    bool frameIsCompleteAtIndex(size_t); // Whether or not the frame is completely decoded.
>-    bool frameHasAlphaAtIndex(size_t); // Whether or not the frame actually used any alpha.
>-    bool frameAllowSubsamplingAtIndex(size_t) const;
>-    
>-    // Size of optionally subsampled frame.
>-    IntSize frameSizeAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, RespectImageOrientationEnum = DoNotRespectImageOrientation) const;
>-    
>-    // Return the number of bytes in the decoded frame. If the frame is not yet
>-    // decoded then return 0.
>-    unsigned frameBytesAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default) const;
>-    
>+    // Image metadata which is calculated from the first ImageFrame.
>+    IntSize size();
>+    IntSize sizeRespectingOrientation();
>+
>+    SubsamplingLevel maximumSubsamplingLevel();
>+    SubsamplingLevel subsamplingLevelForScale(float);
>+    void setAllowSubsampling(bool allowSubsampling) { m_allowSubsampling = allowSubsampling; }
>+
>+    Color singlePixelSolidColor();
>+
>+    // ImageFrame metadata which does not require caching the ImageFrame.
>+    bool frameIsCompleteAtIndex(size_t);
>+    bool frameHasAlphaAtIndex(size_t);
>+    bool frameHasImageAtIndex(size_t);
>+    bool frameHasInvalidNativeImageAtIndex(size_t, SubsamplingLevel);
>+    SubsamplingLevel frameSubsamplingLevelAtIndex(size_t);
>+
>+    // ImageFrame metadata which forces caching or re-caching the ImageFrame.
>+    IntSize frameSizeAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default);
>+    unsigned frameBytesAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default);
>     float frameDurationAtIndex(size_t);
>-    ImageOrientation frameOrientationAtIndex(size_t) const; // EXIF image orientation
>-    
>-    // Callers should not call this after calling clear() with a higher index;
>-    // see comments on clear() above.
>+    ImageOrientation frameOrientationAtIndex(size_t);
>+
>+    NativeImagePtr frameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default);
>     NativeImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default);
>-    
>+
> private:
>     void clearFrameBufferCache(size_t);
>-    SubsamplingLevel calculateMaximumSubsamplingLevel() const;
>-    void updateMetadata();
>-    void dump(TextStream&) const;
>-    
>-    std::unique_ptr<ImageDecoder> m_decoder;
>+    void clearMetadata();
>+    void clear(bool destroyAll, size_t count, SharedBuffer* data);
>+    void dump(TextStream&);
>     
>-    bool m_needsUpdateMetadata { false };
>-    size_t m_frameCount { 0 };
>-    Optional<SubsamplingLevel> m_maximumSubsamplingLevel { SubsamplingLevel::Default };
>+    ImageFrameCache m_frameCache;
>+    std::unique_ptr<ImageFrameDecoder> m_decoder;
> 
>     // The default value of m_allowSubsampling should be the same as defaultImageSubsamplingEnabled in Settings.cpp
> #if PLATFORM(IOS)
>@@ -144,10 +116,20 @@ private:
>     bool m_allowSubsampling { false };
> #endif
> 
>-    AlphaOption m_alphaOption { AlphaPremultiplied };
>-    GammaAndColorProfileOption m_gammaAndColorProfileOption { GammaAndColorProfileApplied };
>+#if PLATFORM(IOS)
>+    // FIXME: We should expose a setting to enable/disable progressive loading remove the PLATFORM(IOS)-guard.
>+    double m_progressiveLoadChunkTime { 0 };
>+    uint16_t m_progressiveLoadChunkCount { 0 };
>+#endif
>+
>+    AlphaOption m_alphaOption { AlphaOption::Premultiplied };
>+    GammaAndColorProfileOption m_gammaAndColorProfileOption { GammaAndColorProfileOption::Applied };
>+    
>+    // Image metadata which is calculated from the first ImageFrame.
>+    Optional<IntSize> m_size;
>+    Optional<IntSize> m_sizeRespectingOrientation;
>+    Optional<SubsamplingLevel> m_maximumSubsamplingLevel;
>+    Optional<Color> m_singlePixelSolidColor;
> };
> 
> }
>-
>-#endif
>Index: Source/WebCore/platform/graphics/cairo/GraphicsContext3DCairo.cpp
>===================================================================
>--- Source/WebCore/platform/graphics/cairo/GraphicsContext3DCairo.cpp	(revision 206259)
>+++ Source/WebCore/platform/graphics/cairo/GraphicsContext3DCairo.cpp	(working copy)
>@@ -211,12 +211,16 @@ bool GraphicsContext3D::ImageExtractor::
>     if (!m_image)
>         return false;
>     // We need this to stay in scope because the native image is just a shallow copy of the data.
>-    m_decoder = new ImageSource(premultiplyAlpha ? ImageSource::AlphaPremultiplied : ImageSource::AlphaNotPremultiplied, ignoreGammaAndColorProfile ? ImageSource::GammaAndColorProfileIgnored : ImageSource::GammaAndColorProfileApplied);
>+    AlphaOption alphaOption = premultiplyAlpha ? AlphaOption::Premultiplied : AlphaOption::NotPremultiplied;
>+    GammaAndColorProfileOption gammaAndColorProfileOption = ignoreGammaAndColorProfile ? GammaAndColorProfileOption::Ignored : GammaAndColorProfileOption::Applied;
>+    m_decoder = new ImageSource(nullptr, alphaOption, gammaAndColorProfileOption);
>+    
>     if (!m_decoder)
>         return false;
>-    ImageSource& decoder = *m_decoder;
> 
>+    ImageSource& decoder = *m_decoder;
>     m_alphaOp = AlphaDoNothing;
>+
>     if (m_image->data()) {
>         decoder.setData(m_image->data(), true);
>         if (!decoder.frameCount() || !decoder.frameIsCompleteAtIndex(0))
>Index: Source/WebCore/platform/graphics/cg/GraphicsContext3DCG.cpp
>===================================================================
>--- Source/WebCore/platform/graphics/cg/GraphicsContext3DCG.cpp	(revision 206259)
>+++ Source/WebCore/platform/graphics/cg/GraphicsContext3DCG.cpp	(working copy)
>@@ -327,8 +327,7 @@ bool GraphicsContext3D::ImageExtractor::
>         return false;
>     bool hasAlpha = !m_image->currentFrameKnownToBeOpaque();
>     if ((ignoreGammaAndColorProfile || (hasAlpha && !premultiplyAlpha)) && m_image->data()) {
>-        ImageSource decoder(ImageSource::AlphaNotPremultiplied,
>-                            ignoreGammaAndColorProfile ? ImageSource::GammaAndColorProfileIgnored : ImageSource::GammaAndColorProfileApplied);
>+        ImageSource decoder(nullptr, AlphaOption::NotPremultiplied, ignoreGammaAndColorProfile ? GammaAndColorProfileOption::Ignored : GammaAndColorProfileOption::Applied);
>         decoder.setData(m_image->data(), true);
>         if (!decoder.frameCount())
>             return false;
>Index: Source/WebCore/platform/graphics/cg/ImageDecoderCG.cpp
>===================================================================
>--- Source/WebCore/platform/graphics/cg/ImageDecoderCG.cpp	(revision 206259)
>+++ Source/WebCore/platform/graphics/cg/ImageDecoderCG.cpp	(working copy)
>@@ -118,7 +118,7 @@ void sharedBufferRelease(void* info)
> }
> #endif
> 
>-ImageDecoder::ImageDecoder()
>+ImageDecoder::ImageDecoder(AlphaOption, GammaAndColorProfileOption)
> {
>     m_nativeDecoder = adoptCF(CGImageSourceCreateIncremental(nullptr));
> }
>@@ -154,13 +154,6 @@ bool ImageDecoder::isSizeAvailable() con
>     && CFDictionaryContainsKey(image0Properties.get(), kCGImagePropertyPixelHeight);
> }
> 
>-IntSize ImageDecoder::size() const
>-{
>-    if (m_size.isEmpty())
>-        m_size = frameSizeAtIndex(0);
>-    return m_size;
>-}
>-
> size_t ImageDecoder::frameCount() const
> {
>     return CGImageSourceGetCount(m_nativeDecoder.get());
>@@ -374,18 +367,15 @@ NativeImagePtr ImageDecoder::createFrame
>     return maskedImage ? maskedImage : image;
> }
> 
>-void ImageDecoder::setData(CFDataRef data, bool allDataReceived)
>-{
>-    CGImageSourceUpdateData(m_nativeDecoder.get(), data, allDataReceived);
>-}
>-
> void ImageDecoder::setData(SharedBuffer& data, bool allDataReceived)
> {
>+    m_isAllDataReceived = allDataReceived;
>+
> #if PLATFORM(COCOA)
>     // On Mac the NSData inside the SharedBuffer can be secretly appended to without the SharedBuffer's knowledge.
>     // We use SharedBuffer's ability to wrap itself inside CFData to get around this, ensuring that ImageIO is
>     // really looking at the SharedBuffer.
>-    setData(data.createCFData().get(), allDataReceived);
>+    CGImageSourceUpdateData(m_nativeDecoder.get(), data.createCFData().get(), allDataReceived);
> #else
>     // Create a CGDataProvider to wrap the SharedBuffer.
>     data.ref();
>Index: Source/WebCore/platform/graphics/cg/ImageDecoderCG.h
>===================================================================
>--- Source/WebCore/platform/graphics/cg/ImageDecoderCG.h	(revision 206259)
>+++ Source/WebCore/platform/graphics/cg/ImageDecoderCG.h	(working copy)
>@@ -23,8 +23,7 @@
>  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>  */
> 
>-#ifndef ImageDecoderCG_h
>-#define ImageDecoderCG_h
>+#pragma once
> 
> #include "ImageSourceCG.h"
> #include "IntSize.h"
>@@ -39,25 +38,21 @@ namespace WebCore {
> class ImageDecoder {
>     WTF_MAKE_FAST_ALLOCATED;
> public:
>-    ImageDecoder();
>-    
>-    static std::unique_ptr<ImageDecoder> create(const SharedBuffer&, ImageSource::AlphaOption, ImageSource::GammaAndColorProfileOption)
>+    ImageDecoder(AlphaOption, GammaAndColorProfileOption);
>+
>+    static std::unique_ptr<ImageDecoder> create(const SharedBuffer&, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
>     {
>-        return std::make_unique<ImageDecoder>();
>+        return std::make_unique<ImageDecoder>(alphaOption, gammaAndColorProfileOption);
>     }
>     
>     static size_t bytesDecodedToDetermineProperties();
>-    
>-    String filenameExtension() const;
>+
>     bool isSizeAvailable() const;
>-    
>-    // Always original size, without subsampling.
>-    IntSize size() const;
>     size_t frameCount() const;
>-
>     RepetitionCount repetitionCount() const;
>+    String filenameExtension() const;
>     Optional<IntPoint> hotSpot() const;
>-    
>+
>     IntSize frameSizeAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default) const;
>     bool frameIsCompleteAtIndex(size_t) const;
>     ImageOrientation frameOrientationAtIndex(size_t) const;
>@@ -69,16 +64,13 @@ public:
>     
>     NativeImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default) const;
>     
>-    void setData(CFDataRef, bool allDataReceived);
>     void setData(SharedBuffer&, bool allDataReceived);
>-    
>+    bool isAllDataReceived() const { return m_isAllDataReceived; }
>     void clearFrameBufferCache(size_t) { }
>     
> protected:
>-    mutable IntSize m_size;
>+    bool m_isAllDataReceived { false };
>     RetainPtr<CGImageSourceRef> m_nativeDecoder;
> };
> 
> }
>-
>-#endif // ImageDecoderCG_h
>Index: Source/WebCore/platform/graphics/efl/GraphicsContext3DEfl.cpp
>===================================================================
>--- Source/WebCore/platform/graphics/efl/GraphicsContext3DEfl.cpp	(revision 206259)
>+++ Source/WebCore/platform/graphics/efl/GraphicsContext3DEfl.cpp	(working copy)
>@@ -249,7 +249,9 @@ bool GraphicsContext3D::ImageExtractor::
>         return false;
> 
>     // We need this to stay in scope because the native image is just a shallow copy of the data.
>-    m_decoder = new ImageSource(premultiplyAlpha ? ImageSource::AlphaPremultiplied : ImageSource::AlphaNotPremultiplied, ignoreGammaAndColorProfile ? ImageSource::GammaAndColorProfileIgnored : ImageSource::GammaAndColorProfileApplied);
>+    AlphaOption alphaOption = premultiplyAlpha ? AlphaOption::Premultiplied : AlphaOption::NotPremultiplied;
>+    GammaAndColorProfileOption gammaAndColorProfileOption = ignoreGammaAndColorProfile ? GammaAndColorProfileOption::Ignored : GammaAndColorProfileOption::Applied;
>+    m_decoder = new ImageSource(nullptr, alphaOption, gammaAndColorProfileOption);
> 
>     if (!m_decoder)
>         return false;
>Index: Source/WebCore/platform/graphics/mac/ImageMac.mm
>===================================================================
>--- Source/WebCore/platform/graphics/mac/ImageMac.mm	(revision 206259)
>+++ Source/WebCore/platform/graphics/mac/ImageMac.mm	(working copy)
>@@ -47,7 +47,7 @@ namespace WebCore {
> 
> void BitmapImage::invalidatePlatformData()
> {
>-    if (m_frames.size() != 1)
>+    if (frameCount() != 1)
>         return;
> 
> #if USE(APPKIT)
>Index: Source/WebCore/platform/image-decoders/ImageDecoder.cpp
>===================================================================
>--- Source/WebCore/platform/image-decoders/ImageDecoder.cpp	(revision 206259)
>+++ Source/WebCore/platform/image-decoders/ImageDecoder.cpp	(working copy)
>@@ -96,7 +96,7 @@ bool matchesCURSignature(char* contents)
> 
> }
> 
>-std::unique_ptr<ImageDecoder> ImageDecoder::create(const SharedBuffer& data, ImageSource::AlphaOption alphaOption, ImageSource::GammaAndColorProfileOption gammaAndColorProfileOption)
>+std::unique_ptr<ImageDecoder> ImageDecoder::create(const SharedBuffer& data, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
> {
>     static const unsigned lengthOfLongestSignature = 14; // To wit: "RIFF????WEBPVP"
>     char contents[lengthOfLongestSignature];
>Index: Source/WebCore/platform/image-decoders/ImageDecoder.h
>===================================================================
>--- Source/WebCore/platform/image-decoders/ImageDecoder.h	(revision 206259)
>+++ Source/WebCore/platform/image-decoders/ImageDecoder.h	(working copy)
>@@ -28,8 +28,7 @@
> 
> #pragma once
> 
>-#include "ImageBackingStore.h"
>-#include "ImageSource.h"
>+#include "ImageFrame.h"
> #include "IntRect.h"
> #include "IntSize.h"
> #include "PlatformScreen.h"
>@@ -42,8 +41,6 @@
> 
> namespace WebCore {
> 
>-using ColorProfile = Vector<char>;
>-
>     // ImageDecoder is a base for all format-specific decoders
>     // (e.g. JPEGImageDecoder).  This base manages the ImageFrame cache.
>     //
>@@ -53,9 +50,9 @@ using ColorProfile = Vector<char>;
>     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)
>+        ImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
>+            : m_premultiplyAlpha(alphaOption == AlphaOption::Premultiplied)
>+            , m_ignoreGammaAndColorProfile(gammaAndColorProfileOption == GammaAndColorProfileOption::Ignored)
>         {
>         }
> 
>@@ -66,9 +63,9 @@ using ColorProfile = Vector<char>;
>         // 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).
>-        static std::unique_ptr<ImageDecoder> create(const SharedBuffer& data, ImageSource::AlphaOption, ImageSource::GammaAndColorProfileOption);
>+        static std::unique_ptr<ImageDecoder> create(const SharedBuffer& data, AlphaOption, GammaAndColorProfileOption);
> 
>-        virtual String filenameExtension() const = 0;
>+        virtual String filenameExtension() const { return String(); }
>         
>         bool premultiplyAlpha() const { return m_premultiplyAlpha; }
> 
>@@ -122,13 +119,13 @@ using ColorProfile = Vector<char>;
>         // possible), without decoding the individual frames.
>         // FIXME: Right now that has to be done by each subclass; factor the
>         // decode call out and use it here.
>-        virtual size_t frameCount() { return 1; }
>+        virtual size_t frameCount() const { return 1; }
> 
>         virtual RepetitionCount repetitionCount() const { return RepetitionCountNone; }
> 
>         // Decodes as much of the requested frame as possible, and returns an
>         // ImageDecoder-owned pointer.
>-        virtual ImageFrame* frameBufferAtIndex(size_t) = 0;
>+        virtual ImageFrame* frameBufferAtIndex(size_t) { return nullptr; }
> 
>         bool frameIsCompleteAtIndex(size_t);
> 
>Index: Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.cpp
>===================================================================
>--- Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.cpp	(revision 206259)
>+++ Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.cpp	(working copy)
>@@ -40,8 +40,7 @@ namespace WebCore {
> // don't pack).
> static const size_t sizeOfFileHeader = 14;
> 
>-BMPImageDecoder::BMPImageDecoder(ImageSource::AlphaOption alphaOption,
>-                                 ImageSource::GammaAndColorProfileOption gammaAndColorProfileOption)
>+BMPImageDecoder::BMPImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
>     : ImageDecoder(alphaOption, gammaAndColorProfileOption)
>     , m_decodedOffset(0)
> {
>Index: Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.h
>===================================================================
>--- Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.h	(revision 206259)
>+++ Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.h	(working copy)
>@@ -28,8 +28,7 @@
>  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>  */
> 
>-#ifndef BMPImageDecoder_h
>-#define BMPImageDecoder_h
>+#pragma once
> 
> #include "BMPImageReader.h"
> 
>@@ -38,7 +37,7 @@ namespace WebCore {
>     // This class decodes the BMP image format.
>     class BMPImageDecoder final : public ImageDecoder {
>     public:
>-        BMPImageDecoder(ImageSource::AlphaOption, ImageSource::GammaAndColorProfileOption);
>+        BMPImageDecoder(AlphaOption, GammaAndColorProfileOption);
> 
>         // ImageDecoder
>         String filenameExtension() const override { return "bmp"; }
>@@ -80,5 +79,3 @@ namespace WebCore {
>     };
> 
> } // namespace WebCore
>-
>-#endif
>Index: Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.cpp
>===================================================================
>--- Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.cpp	(revision 206259)
>+++ Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.cpp	(working copy)
>@@ -31,7 +31,7 @@
> 
> namespace WebCore {
> 
>-GIFImageDecoder::GIFImageDecoder(ImageSource::AlphaOption alphaOption, ImageSource::GammaAndColorProfileOption gammaAndColorProfileOption)
>+GIFImageDecoder::GIFImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
>     : ImageDecoder(alphaOption, gammaAndColorProfileOption)
> {
> }
>@@ -70,9 +70,9 @@ bool GIFImageDecoder::setSize(const IntS
>     return true;
> }
> 
>-size_t GIFImageDecoder::frameCount()
>+size_t GIFImageDecoder::frameCount() const
> {
>-    decode(std::numeric_limits<unsigned>::max(), GIFFrameCountQuery);
>+    const_cast<GIFImageDecoder*>(this)->decode(std::numeric_limits<unsigned>::max(), GIFFrameCountQuery);
>     return m_frameBufferCache.size();
> }
> 
>Index: Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.h
>===================================================================
>--- Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.h	(revision 206259)
>+++ Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.h	(working copy)
>@@ -23,8 +23,7 @@
>  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>  */
> 
>-#ifndef GIFImageDecoder_h
>-#define GIFImageDecoder_h
>+#pragma once
> 
> #include "ImageDecoder.h"
> 
>@@ -35,7 +34,7 @@ namespace WebCore {
>     // This class decodes the GIF image format.
>     class GIFImageDecoder final : public ImageDecoder {
>     public:
>-        GIFImageDecoder(ImageSource::AlphaOption, ImageSource::GammaAndColorProfileOption);
>+        GIFImageDecoder(AlphaOption, GammaAndColorProfileOption);
>         virtual ~GIFImageDecoder();
> 
>         enum GIFQuery { GIFFullQuery, GIFSizeQuery, GIFFrameCountQuery };
>@@ -45,7 +44,7 @@ namespace WebCore {
>         void setData(SharedBuffer& data, bool allDataReceived) override;
>         bool isSizeAvailable() override;
>         bool setSize(const IntSize&) override;
>-        size_t frameCount() override;
>+        size_t frameCount() const override;
>         RepetitionCount repetitionCount() const override;
>         ImageFrame* frameBufferAtIndex(size_t index) override;
>         // CAUTION: setFailed() deletes |m_reader|.  Be careful to avoid
>@@ -77,5 +76,3 @@ namespace WebCore {
>     };
> 
> } // namespace WebCore
>-
>-#endif
>Index: Source/WebCore/platform/image-decoders/gif/GIFImageReader.cpp
>===================================================================
>--- Source/WebCore/platform/image-decoders/gif/GIFImageReader.cpp	(revision 206259)
>+++ Source/WebCore/platform/image-decoders/gif/GIFImageReader.cpp	(working copy)
>@@ -77,7 +77,6 @@ mailing address.
> 
> #include <string.h>
> #include "GIFImageDecoder.h"
>-#include "ImageSource.h"
> 
> using WebCore::GIFImageDecoder;
> 
>Index: Source/WebCore/platform/image-decoders/gif/GIFImageReader.h
>===================================================================
>--- Source/WebCore/platform/image-decoders/gif/GIFImageReader.h	(revision 206259)
>+++ Source/WebCore/platform/image-decoders/gif/GIFImageReader.h	(working copy)
>@@ -35,8 +35,7 @@
>  *
>  * ***** END LICENSE BLOCK ***** */
> 
>-#ifndef GIFImageReader_h
>-#define GIFImageReader_h
>+#pragma once
> 
> // Define ourselves as the clientPtr.  Mozilla just hacked their C++ callback class into this old C decoder,
> // so we will too.
>@@ -323,5 +322,3 @@ private:
>     RefPtr<WebCore::SharedBuffer> m_data;
>     bool m_parseCompleted;
> };
>-
>-#endif
>Index: Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.cpp
>===================================================================
>--- Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.cpp	(revision 206259)
>+++ Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.cpp	(working copy)
>@@ -44,8 +44,7 @@ namespace WebCore {
> static const size_t sizeOfDirectory = 6;
> static const size_t sizeOfDirEntry = 16;
> 
>-ICOImageDecoder::ICOImageDecoder(ImageSource::AlphaOption alphaOption,
>-                                 ImageSource::GammaAndColorProfileOption gammaAndColorProfileOption)
>+ICOImageDecoder::ICOImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
>     : ImageDecoder(alphaOption, gammaAndColorProfileOption)
>     , m_decodedOffset(0)
> {
>@@ -95,14 +94,9 @@ bool ICOImageDecoder::setSize(const IntS
>     return m_frameSize.isEmpty() ? ImageDecoder::setSize(size) : ((size == m_frameSize) || setFailed());
> }
> 
>-size_t ICOImageDecoder::frameCount()
>+size_t ICOImageDecoder::frameCount() const
> {
>-    decode(0, true);
>-    if (m_frameBufferCache.isEmpty())
>-        m_frameBufferCache.resize(m_dirEntries.size());
>-    // CAUTION: We must not resize m_frameBufferCache again after this, as
>-    // decodeAtIndex() may give a BMPImageReader a pointer to one of the
>-    // entries.
>+    const_cast<ICOImageDecoder*>(this)->decode(0, true);
>     return m_frameBufferCache.size();
> }
> 
>@@ -180,6 +174,12 @@ void ICOImageDecoder::decode(size_t inde
>         m_bmpReaders[index] = nullptr;
>         m_pngDecoders[index] = nullptr;
>     }
>+    
>+    if (m_frameBufferCache.isEmpty())
>+        m_frameBufferCache.resize(m_dirEntries.size());
>+    // CAUTION: We must not resize m_frameBufferCache again after this, as
>+    // decodeAtIndex() may give a BMPImageReader a pointer to one of the
>+    // entries.
> }
> 
> bool ICOImageDecoder::decodeDirectory()
>@@ -217,8 +217,8 @@ bool ICOImageDecoder::decodeAtIndex(size
> 
>     if (!m_pngDecoders[index]) {
>         m_pngDecoders[index] = std::make_unique<
>-            PNGImageDecoder>(m_premultiplyAlpha ? ImageSource::AlphaPremultiplied : ImageSource::AlphaNotPremultiplied,
>-                m_ignoreGammaAndColorProfile ? ImageSource::GammaAndColorProfileIgnored : ImageSource::GammaAndColorProfileApplied);
>+            PNGImageDecoder>(m_premultiplyAlpha ? AlphaOption::Premultiplied : AlphaOption::NotPremultiplied,
>+                m_ignoreGammaAndColorProfile ? GammaAndColorProfileOption::Ignored : GammaAndColorProfileOption::Applied);
>         setDataForPNGDecoderAtIndex(index);
>     }
>     // Fail if the size the PNGImageDecoder calculated does not match the size
>Index: Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.h
>===================================================================
>--- Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.h	(revision 206259)
>+++ Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.h	(working copy)
>@@ -28,8 +28,7 @@
>  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>  */
> 
>-#ifndef ICOImageDecoder_h
>-#define ICOImageDecoder_h
>+#pragma once
> 
> #include "BMPImageReader.h"
> 
>@@ -40,7 +39,7 @@ namespace WebCore {
>     // This class decodes the ICO and CUR image formats.
>     class ICOImageDecoder final : public ImageDecoder {
>     public:
>-        ICOImageDecoder(ImageSource::AlphaOption, ImageSource::GammaAndColorProfileOption);
>+        ICOImageDecoder(AlphaOption, GammaAndColorProfileOption);
>         virtual ~ICOImageDecoder();
> 
>         // ImageDecoder
>@@ -50,7 +49,7 @@ namespace WebCore {
>         IntSize size() override;
>         IntSize frameSizeAtIndex(size_t, SubsamplingLevel) override;
>         bool setSize(const IntSize&) override;
>-        size_t frameCount() override;
>+        size_t frameCount() const override;
>         ImageFrame* frameBufferAtIndex(size_t) override;
>         // CAUTION: setFailed() deletes all readers and decoders.  Be careful to
>         // avoid accessing deleted memory, especially when calling this from
>@@ -151,5 +150,3 @@ namespace WebCore {
>     };
> 
> } // namespace WebCore
>-
>-#endif
>Index: Source/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.cpp
>===================================================================
>--- Source/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.cpp	(revision 206259)
>+++ Source/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.cpp	(working copy)
>@@ -501,8 +501,7 @@ void term_source(j_decompress_ptr jd)
>     src->decoder->decoder()->jpegComplete();
> }
> 
>-JPEGImageDecoder::JPEGImageDecoder(ImageSource::AlphaOption alphaOption,
>-                                   ImageSource::GammaAndColorProfileOption gammaAndColorProfileOption)
>+JPEGImageDecoder::JPEGImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
>     : ImageDecoder(alphaOption, gammaAndColorProfileOption)
> {
> }
>Index: Source/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.h
>===================================================================
>--- Source/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.h	(revision 206259)
>+++ Source/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.h	(working copy)
>@@ -24,8 +24,7 @@
>  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
>  */
> 
>-#ifndef JPEGImageDecoder_h
>-#define JPEGImageDecoder_h
>+#pragma once
> 
> #include "ImageDecoder.h"
> #include <stdio.h> // Needed by jpeglib.h for FILE.
>@@ -44,7 +43,7 @@ namespace WebCore {
>     // This class decodes the JPEG image format.
>     class JPEGImageDecoder final : public ImageDecoder {
>     public:
>-        JPEGImageDecoder(ImageSource::AlphaOption, ImageSource::GammaAndColorProfileOption);
>+        JPEGImageDecoder(AlphaOption, GammaAndColorProfileOption);
>         virtual ~JPEGImageDecoder();
> 
>         // ImageDecoder
>@@ -84,5 +83,3 @@ namespace WebCore {
>     };
> 
> } // namespace WebCore
>-
>-#endif
>Index: Source/WebCore/platform/image-decoders/png/PNGImageDecoder.cpp
>===================================================================
>--- Source/WebCore/platform/image-decoders/png/PNGImageDecoder.cpp	(revision 206259)
>+++ Source/WebCore/platform/image-decoders/png/PNGImageDecoder.cpp	(working copy)
>@@ -193,7 +193,7 @@ private:
>     png_bytep m_interlaceBuffer;
> };
> 
>-PNGImageDecoder::PNGImageDecoder(ImageSource::AlphaOption alphaOption, ImageSource::GammaAndColorProfileOption gammaAndColorProfileOption)
>+PNGImageDecoder::PNGImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
>     : ImageDecoder(alphaOption, gammaAndColorProfileOption)
>     , m_doNothingOnFailure(false)
>     , m_currentFrame(0)
>Index: Source/WebCore/platform/image-decoders/png/PNGImageDecoder.h
>===================================================================
>--- Source/WebCore/platform/image-decoders/png/PNGImageDecoder.h	(revision 206259)
>+++ Source/WebCore/platform/image-decoders/png/PNGImageDecoder.h	(working copy)
>@@ -23,8 +23,7 @@
>  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
>  */
> 
>-#ifndef PNGImageDecoder_h
>-#define PNGImageDecoder_h
>+#pragma once
> 
> #include "ImageDecoder.h"
> #if ENABLE(APNG)
>@@ -38,13 +37,13 @@ namespace WebCore {
>     // This class decodes the PNG image format.
>     class PNGImageDecoder final : public ImageDecoder {
>     public:
>-        PNGImageDecoder(ImageSource::AlphaOption, ImageSource::GammaAndColorProfileOption);
>+        PNGImageDecoder(AlphaOption, GammaAndColorProfileOption);
>         virtual ~PNGImageDecoder();
> 
>         // ImageDecoder
>         String filenameExtension() const override { return "png"; }
> #if ENABLE(APNG)
>-        size_t frameCount() override { return m_frameCount; }
>+        size_t frameCount() const override { return m_frameCount; }
>         RepetitionCount repetitionCount() const override { return m_playCount-1; }
> #endif
>         bool isSizeAvailable() override;
>@@ -130,5 +129,3 @@ namespace WebCore {
>     };
> 
> } // namespace WebCore
>-
>-#endif
>Index: Source/WebCore/platform/image-decoders/webp/WEBPImageDecoder.cpp
>===================================================================
>--- Source/WebCore/platform/image-decoders/webp/WEBPImageDecoder.cpp	(revision 206259)
>+++ Source/WebCore/platform/image-decoders/webp/WEBPImageDecoder.cpp	(working copy)
>@@ -45,8 +45,7 @@ inline WEBP_CSP_MODE outputMode(bool has
> 
> namespace WebCore {
> 
>-WEBPImageDecoder::WEBPImageDecoder(ImageSource::AlphaOption alphaOption,
>-                                   ImageSource::GammaAndColorProfileOption gammaAndColorProfileOption)
>+WEBPImageDecoder::WEBPImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
>     : ImageDecoder(alphaOption, gammaAndColorProfileOption)
>     , m_decoder(0)
>     , m_hasAlpha(false)
>Index: Source/WebCore/platform/image-decoders/webp/WEBPImageDecoder.h
>===================================================================
>--- Source/WebCore/platform/image-decoders/webp/WEBPImageDecoder.h	(revision 206259)
>+++ Source/WebCore/platform/image-decoders/webp/WEBPImageDecoder.h	(working copy)
>@@ -26,8 +26,7 @@
>  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>  */
> 
>-#ifndef WEBPImageDecoder_h
>-#define WEBPImageDecoder_h
>+#pragma once
> 
> #include "ImageDecoder.h"
> 
>@@ -39,7 +38,7 @@ namespace WebCore {
> 
> class WEBPImageDecoder final : public ImageDecoder {
> public:
>-    WEBPImageDecoder(ImageSource::AlphaOption, ImageSource::GammaAndColorProfileOption);
>+    WEBPImageDecoder(AlphaOption, GammaAndColorProfileOption);
>     virtual ~WEBPImageDecoder();
> 
>     String filenameExtension() const override { return "webp"; }
>@@ -59,5 +58,3 @@ private:
> } // namespace WebCore
> 
> #endif
>-
>-#endif

Actions: View | Formatted Diff | Diff

Attachments on bug 155498: 274105 | 274108 | 274111 | 274115 | 274118 | 274124 | 285774 | 285778 | 285780 | 285781 | 285789 | 285791 | 285796 | 285800 | 285802 | 285806 | 285808 | 285809 | 285810 | 285815 | 285816 | 285818 | 285819 | 285820 | 285829 | 285831 | 285832 | 285834 | 285837 | 285846 | 285862 | 285867 | 285869 | 285879 | 285917 | 285923 | 289492 | 289494 | 289497 | 289498 | 289503 | 289504 | 289505 | 289507 | 289566 | 289568 | 289571 | 289572 | 289573 | 289574 | 289597 | 289605 | 289615 | 289617 | 289623 | 289625 | 289633 | 289863 | 289871 | 289882 | 289889 | 289899 | 289957 | 289981 | 289985 | 290017 | 290033