Attachment 273847 Details for Bug 155322 – Patch

[patch] Patch

bug-155322-20160312133434.patch (text/plain), 151.13 KB, created by Said Abou-Hallawa on 2016-03-12 13:34:46 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Said Abou-Hallawa

Created: 2016-03-12 13:34:46 PST

Size: 151.13 KB

patch

obsolete

>Subversion Revision: 198066
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index cac98fc61fb8fe1e01a691cc7849346e5a907250..89caa2cc50b86895f80441aa366fd0b0a4c4595e 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,184 @@
>+2016-03-12  Said Abou-Hallawa  <sabouhallawa@apple,com>
>+
>+        Tracking bug for CG asynchronous image decoding
>+        https://bugs.webkit.org/show_bug.cgi?id=155322
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * PlatformAppleWin.cmake:
>+        * PlatformEfl.cmake:
>+        * PlatformGTK.cmake:
>+        * PlatformMac.cmake:
>+        * PlatformWinCairo.cmake:
>+        * WebCore.xcodeproj/project.pbxproj:
>+        * loader/cache/MemoryCache.cpp:
>+        (WebCore::MemoryCache::addImageToCache): Deleted.
>+        * platform/graphics/BitmapImage.cpp:
>+        (WebCore::BitmapImage::BitmapImage):
>+        (WebCore::BitmapImage::haveFrameAtIndex):
>+        (WebCore::BitmapImage::destroyDecodedDataIfNecessary):
>+        (WebCore::BitmapImage::destroyDecodedData):
>+        (WebCore::BitmapImage::destroyMetadataAndNotify):
>+        (WebCore::BitmapImage::updateSize):
>+        (WebCore::BitmapImage::getHotSpot):
>+        (WebCore::BitmapImage::dataChanged):
>+        (WebCore::BitmapImage::frameCount):
>+        (WebCore::BitmapImage::frameAtIndex):
>+        (WebCore::BitmapImage::isSolidColor):
>+        (WebCore::BitmapImage::mayFillWithSolidColor):
>+        (WebCore::BitmapImage::solidColor):
>+        (WebCore::BitmapImage::dump):
>+        (WebCore::BitmapImage::cacheFrame): Deleted.
>+        (WebCore::BitmapImage::didDecodeProperties): Deleted.
>+        (WebCore::BitmapImage::filenameExtension): Deleted.
>+        (WebCore::BitmapImage::isSizeAvailable): Deleted.
>+        (WebCore::BitmapImage::ensureFrameIsCached): Deleted.
>+        (WebCore::BitmapImage::frameIsCompleteAtIndex): Deleted.
>+        (WebCore::BitmapImage::frameDurationAtIndex): Deleted.
>+        (WebCore::BitmapImage::nativeImageForCurrentFrame): Deleted.
>+        (WebCore::BitmapImage::frameHasAlphaAtIndex): Deleted.
>+        (WebCore::BitmapImage::currentFrameKnownToBeOpaque): Deleted.
>+        (WebCore::BitmapImage::frameOrientationAtIndex): Deleted.
>+        (WebCore::BitmapImage::repetitionCount): Deleted.
>+        * platform/graphics/BitmapImage.h:
>+        (WebCore::FrameData::FrameData): Deleted.
>+        (WebCore::FrameData::~FrameData): Deleted.
>+        * platform/graphics/Icon.h:
>+        * platform/graphics/Image.h:
>+        (WebCore::Image::solidColor):
>+        * platform/graphics/ImageFrameData.cpp: Added.
>+        (WebCore::ImageFrameData::ImageFrameData):
>+        (WebCore::ImageFrameData::~ImageFrameData):
>+        (WebCore::ImageFrameData::status):
>+        (WebCore::ImageFrameDataBuffer::ImageFrameDataBuffer):
>+        (WebCore::ImageFrameDataBuffer::operator[]):
>+        (WebCore::ImageFrameDataBuffer::isImageAvailable):
>+        (WebCore::ImageFrameDataBuffer::isFrameAvailable):
>+        (WebCore::ImageFrameDataBuffer::isFrameInvalid):
>+        (WebCore::ImageFrameDataBuffer::framesBytes):
>+        (WebCore::ImageFrameDataBuffer::partialFramesBytes):
>+        (WebCore::ImageFrameDataBuffer::clearFrames):
>+        (WebCore::ImageFrameDataBuffer::clearPartialFrames):
>+        * platform/graphics/ImageFrameData.h: Added.
>+        (WebCore::ImageFrameDataBuffer::size):
>+        * platform/graphics/ImageSource.cpp:
>+        (WebCore::ImageSource::ImageSource):
>+        (WebCore::ImageSource::~ImageSource):
>+        (WebCore::ImageSource::clear):
>+        (WebCore::ImageSource::clearFrames):
>+        (WebCore::ImageSource::clearPartialFrames):
>+        (WebCore::ImageSource::ensureDecoderIsCreated):
>+        (WebCore::ImageSource::decodedSizeIncremented):
>+        (WebCore::ImageSource::decodedSizeDecremented):
>+        (WebCore::ImageSource::decodedSizeChanged):
>+        (WebCore::ImageSource::didDecodeProperties):
>+        (WebCore::ImageSource::setData):
>+        (WebCore::ImageSource::subsamplingLevelForScale):
>+        (WebCore::ImageSource::bytesDecodedToDetermineProperties):
>+        (WebCore::ImageSource::isSizeAvailable):
>+        (WebCore::ImageSource::size):
>+        (WebCore::ImageSource::sizeRespectingOrientation):
>+        (WebCore::ImageSource::frameCount):
>+        (WebCore::ImageSource::repetitionCount):
>+        (WebCore::ImageSource::getHotSpot):
>+        (WebCore::ImageSource::filenameExtension):
>+        (WebCore::ImageSource::allowSubsamplingOfFrameAtIndex):
>+        (WebCore::ImageSource::frameSizeAtIndex):
>+        (WebCore::ImageSource::createFrameImageAtIndex):
>+        (WebCore::ImageSource::cacheFrameAtIndex):
>+        (WebCore::ImageSource::ensureFrameAtIndexIsCached):
>+        (WebCore::ImageSource::cachedframeAtIndex):
>+        (WebCore::ImageSource::frameAtIndex):
>+        (WebCore::ImageSource::frameIsCompleteAtIndex):
>+        (WebCore::ImageSource::frameDurationAtIndex):
>+        (WebCore::ImageSource::frameHasAlphaAtIndex):
>+        (WebCore::ImageSource::frameOrientationAtIndex):
>+        (WebCore::ImageSource::initialized): Deleted.
>+        (WebCore::ImageSource::createFrameAtIndex): Deleted.
>+        (WebCore::ImageSource::orientationAtIndex): Deleted.
>+        (WebCore::ImageSource::frameBytesAtIndex): Deleted.
>+        * platform/graphics/ImageSource.h:
>+        (WebCore::ImageSource::isDecoderInitialized):
>+        (WebCore::ImageSource::maxPixelsPerDecodedImage): Deleted.
>+        (WebCore::ImageSource::setMaxPixelsPerDecodedImage): Deleted.
>+        * platform/graphics/NativeImagePtr.h:
>+        * platform/graphics/ca/GraphicsLayerCA.cpp:
>+        (WebCore::GraphicsLayerCA::setContentsToImage):
>+        * platform/graphics/cairo/BitmapImageCairo.cpp:
>+        (WebCore::BitmapImage::BitmapImage):
>+        (WebCore::BitmapImage::determineMaximumSubsamplingLevel):
>+        (WebCore::BitmapImage::checkForSolidColor):
>+        (WebCore::ImageFrameData::ImageFrameData):
>+        (WebCore::ImageFrameData::clear):
>+        (WebCore::BitmapImage::determineMinimumSubsamplingLevel): Deleted.
>+        (WebCore::FrameData::clear): Deleted.
>+        * platform/graphics/cairo/GraphicsContext3DCairo.cpp:
>+        (WebCore::GraphicsContext3D::ImageExtractor::extractImage):
>+        * platform/graphics/cg/BitmapImageCG.cpp:
>+        (WebCore::ImageFrameData::ImageFrameData):
>+        (WebCore::ImageFrameData::clear):
>+        (WebCore::ImageFrameData::solidColor):
>+        (WebCore::BitmapImage::BitmapImage):
>+        (WebCore::BitmapImage::determineMaximumSubsamplingLevel):
>+        (WebCore::BitmapImage::checkForSolidColor):
>+        (WebCore::BitmapImage::getCGImageRef):
>+        (WebCore::BitmapImage::getFirstCGImageRefOfSize):
>+        (WebCore::BitmapImage::getCGImageArray):
>+        (WebCore::BitmapImage::draw):
>+        (WebCore::BitmapImage::copyUnscaledFrameAtIndex):
>+        (WebCore::FrameData::clear): Deleted.
>+        (WebCore::BitmapImage::determineMinimumSubsamplingLevel): Deleted.
>+        * platform/graphics/cg/GraphicsContext3DCG.cpp:
>+        (WebCore::GraphicsContext3D::ImageExtractor::extractImage):
>+        (WebCore::GraphicsContext3D::paintToCanvas):
>+        * platform/graphics/cg/GraphicsContextCG.cpp:
>+        (WebCore::GraphicsContext::drawPattern):
>+        * platform/graphics/cg/ImageDecoder.cpp: Renamed from Source/WebCore/platform/graphics/cg/ImageSourceCG.cpp.
>+        (WebCore::createImageSourceOptions):
>+        (WebCore::imageSourceOptions):
>+        (WebCore::orientationFromProperties):
>+        (WebCore::ImageDecoder::ImageDecoder):
>+        (WebCore::ImageDecoder::subsamplingLevelForScale):
>+        (WebCore::ImageDecoder::bytesDecodedToDetermineProperties):
>+        (WebCore::ImageDecoder::filenameExtension):
>+        (WebCore::ImageDecoder::isSizeAvailable):
>+        (WebCore::ImageDecoder::size):
>+        (WebCore::ImageDecoder::frameCount):
>+        (WebCore::ImageDecoder::repetitionCount):
>+        (WebCore::ImageDecoder::getHotSpot):
>+        (WebCore::ImageDecoder::frameSizeAtIndex):
>+        (WebCore::ImageDecoder::frameIsCompleteAtIndex):
>+        (WebCore::ImageDecoder::orientationAtIndex):
>+        (WebCore::ImageDecoder::frameDurationAtIndex):
>+        (WebCore::ImageDecoder::allowSubsamplingOfFrameAtIndex):
>+        (WebCore::ImageDecoder::frameHasAlphaAtIndex):
>+        (WebCore::ImageDecoder::frameBytesAtIndex):
>+        (WebCore::ImageDecoder::createFrameImageAtIndex):
>+        * platform/graphics/cg/ImageDecoder.h: Added.
>+        (WebCore::ImageDecoder::~ImageDecoder):
>+        (WebCore::ImageDecoder::isDecoding):
>+        * platform/graphics/cg/ImageFrameDecoder.cpp: Added.
>+        (WebCore::ImageFrameDecoder::ImageFrameDecoder):
>+        (WebCore::ImageFrameDecoder::decodeQueue):
>+        (WebCore::ImageFrameDecoder::frames):
>+        (WebCore::sharedBufferGetBytesAtPosition):
>+        (WebCore::sharedBufferRelease):
>+        (WebCore::ImageFrameDecoder::updateData):
>+        (WebCore::ImageFrameDecoder::setData):
>+        (WebCore::ImageFrameDecoder::startDecodingIfNeeded):
>+        (WebCore::ImageFrameDecoder::pushData):
>+        (WebCore::ImageFrameDecoder::decode):
>+        (WebCore::ImageFrameDecoder::cacheCurrentFrame):
>+        (WebCore::ImageFrameDecoder::frameAtIndex):
>+        * platform/graphics/cg/ImageFrameDecoder.h: Added.
>+        * platform/graphics/ios/IconIOS.mm:
>+        (WebCore::Icon::Icon):
>+        * platform/graphics/mac/ImageMac.mm:
>+        (WebCore::BitmapImage::invalidatePlatformData):
>+        (WebCore::BitmapImage::getTIFFRepresentation):
>+        * platform/graphics/win/ImageCGWin.cpp:
>+        (WebCore::BitmapImage::drawFrameMatchingSourceSize):
>+
> 2016-03-12  Zalan Bujtas  <zalan@apple.com>
> 
>         [Forms: focus] focus rings around text fields do not follow contour (border-radius)
>diff --git a/Source/WebCore/PlatformAppleWin.cmake b/Source/WebCore/PlatformAppleWin.cmake
>index e5209cb20cf03387a252643df4e0b215149204f7..dfe3fa172d4d649d4b3598966baf0eed5d619044 100644
>--- a/Source/WebCore/PlatformAppleWin.cmake
>+++ b/Source/WebCore/PlatformAppleWin.cmake
>@@ -71,7 +71,8 @@ list(APPEND WebCore_SOURCES
>     platform/graphics/cg/ImageBufferCG.cpp
>     platform/graphics/cg/ImageBufferDataCG.cpp
>     platform/graphics/cg/ImageCG.cpp
>-    platform/graphics/cg/ImageSourceCG.cpp
>+    platform/graphics/cg/ImageDecoder.cpp
>+    platform/graphics/cg/ImageFrameDecoder.cpp
>     platform/graphics/cg/ImageSourceCGWin.cpp
>     platform/graphics/cg/IntPointCG.cpp
>     platform/graphics/cg/IntRectCG.cpp
>diff --git a/Source/WebCore/PlatformEfl.cmake b/Source/WebCore/PlatformEfl.cmake
>index ece2c53091a56cd93306e5babfa4886634f259f9..ad7c7f4cc27664e5ce5b51868ac9742a78d99c80 100644
>--- a/Source/WebCore/PlatformEfl.cmake
>+++ b/Source/WebCore/PlatformEfl.cmake
>@@ -123,6 +123,7 @@ list(APPEND WebCore_SOURCES
>     platform/glib/KeyedDecoderGlib.cpp
>     platform/glib/KeyedEncoderGlib.cpp
> 
>+    platform/graphics/ImageFrameData.cpp
>     platform/graphics/ImageSource.cpp
>     platform/graphics/PlatformDisplay.cpp
>     platform/graphics/WOFFFileFormat.cpp
>diff --git a/Source/WebCore/PlatformGTK.cmake b/Source/WebCore/PlatformGTK.cmake
>index e6c87b2d7e941e349a67aa6c683aa34dc60adc1f..94984953d39a8b5e7ebb0ce9b52222f852c3f2e3 100644
>--- a/Source/WebCore/PlatformGTK.cmake
>+++ b/Source/WebCore/PlatformGTK.cmake
>@@ -94,6 +94,7 @@ list(APPEND WebCore_SOURCES
> 
>     platform/graphics/GLContext.cpp
>     platform/graphics/GraphicsContext3DPrivate.cpp
>+    platform/graphics/ImageFrameData.cpp
>     platform/graphics/ImageSource.cpp
>     platform/graphics/WOFFFileFormat.cpp
> 
>diff --git a/Source/WebCore/PlatformMac.cmake b/Source/WebCore/PlatformMac.cmake
>index 835b9aa224aa9eaaee04623397e99016e9f7eebf..d00e2d7bbf55deccbc426f7142549513e7a14673 100644
>--- a/Source/WebCore/PlatformMac.cmake
>+++ b/Source/WebCore/PlatformMac.cmake
>@@ -400,7 +400,8 @@ list(APPEND WebCore_SOURCES
>     platform/graphics/cg/ImageBufferCG.cpp
>     platform/graphics/cg/ImageBufferDataCG.cpp
>     platform/graphics/cg/ImageCG.cpp
>-    platform/graphics/cg/ImageSourceCG.cpp
>+    platform/graphics/cg/ImageDecoder.cpp
>+    platform/graphics/cg/ImageFrameDecoder.cpp
>     platform/graphics/cg/ImageSourceCGMac.mm
>     platform/graphics/cg/IntPointCG.cpp
>     platform/graphics/cg/IntRectCG.cpp
>diff --git a/Source/WebCore/PlatformWinCairo.cmake b/Source/WebCore/PlatformWinCairo.cmake
>index 38a028c5b891bcb1fdde2ddeb2a31bf813d538cd..248c89a0b057d1e5d6e441eebc4c38ff824f221d 100644
>--- a/Source/WebCore/PlatformWinCairo.cmake
>+++ b/Source/WebCore/PlatformWinCairo.cmake
>@@ -39,6 +39,7 @@ list(APPEND WebCore_SOURCES
> 
>     platform/graphics/GLContext.cpp
>     platform/graphics/GraphicsLayer.cpp
>+    platform/graphics/ImageFrameData.cpp
>     platform/graphics/ImageSource.cpp
>     platform/graphics/PlatformDisplay.cpp
>     platform/graphics/ShadowBlur.cpp
>diff --git a/Source/WebCore/WebCore.xcodeproj/project.pbxproj b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>index 0307ba38ff0f3a4c471b9d429146162a959ee766..f2733c95e3f54e1fd0a37622caefb4f0022c9e6b 100644
>--- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>+++ b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>@@ -2291,6 +2291,12 @@
> 		53EF766C16531994004CBE49 /* SettingsMacros.h in Copy Generated Headers */ = {isa = PBXBuildFile; fileRef = 53EF766A16530A61004CBE49 /* SettingsMacros.h */; };
> 		550A0BC9085F6039007353D6 /* QualifiedName.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 550A0BC7085F6039007353D6 /* QualifiedName.cpp */; };
> 		550A0BCA085F6039007353D6 /* QualifiedName.h in Headers */ = {isa = PBXBuildFile; fileRef = 550A0BC8085F6039007353D6 /* QualifiedName.h */; settings = {ATTRIBUTES = (Private, ); }; };
>+		551991B01C8ACB290041E52C /* ImageFrameData.h in Headers */ = {isa = PBXBuildFile; fileRef = 554B75351C891B8100F4B405 /* ImageFrameData.h */; settings = {ATTRIBUTES = (Private, ); }; };
>+		554B75361C891B8100F4B405 /* ImageFrameData.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 554B75341C891B8100F4B405 /* ImageFrameData.cpp */; };
>+		554CB90B1C80E9EA0005D248 /* ImageFrameDecoder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 554CB9091C80E9EA0005D248 /* ImageFrameDecoder.cpp */; };
>+		554CB90C1C80E9EA0005D248 /* ImageFrameDecoder.h in Headers */ = {isa = PBXBuildFile; fileRef = 554CB90A1C80E9EA0005D248 /* ImageFrameDecoder.h */; };
>+		5579BECD1C81312900536C3E /* ImageDecoder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5579BECB1C81312900536C3E /* ImageDecoder.cpp */; };
>+		5579BECE1C81312900536C3E /* ImageDecoder.h in Headers */ = {isa = PBXBuildFile; fileRef = 5579BECC1C81312900536C3E /* ImageDecoder.h */; };
> 		572A7F211C6E5719009C6149 /* SimulatedClick.h in Headers */ = {isa = PBXBuildFile; fileRef = 572A7F201C6E5719009C6149 /* SimulatedClick.h */; };
> 		572A7F231C6E5A66009C6149 /* SimulatedClick.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 572A7F221C6E5A66009C6149 /* SimulatedClick.cpp */; };
> 		580371611A66F00A00BAF519 /* ClipRect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5803715F1A66F00A00BAF519 /* ClipRect.cpp */; };
>@@ -5002,7 +5008,6 @@
> 		B275355A0B053814002CE64F /* FloatRectCG.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B275352C0B053814002CE64F /* FloatRectCG.cpp */; };
> 		B275355B0B053814002CE64F /* FloatSizeCG.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B275352D0B053814002CE64F /* FloatSizeCG.cpp */; };
> 		B275355E0B053814002CE64F /* ImageCG.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B27535300B053814002CE64F /* ImageCG.cpp */; };
>-		B275355F0B053814002CE64F /* ImageSourceCG.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B27535310B053814002CE64F /* ImageSourceCG.cpp */; };
> 		B27535600B053814002CE64F /* IntPointCG.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B27535320B053814002CE64F /* IntPointCG.cpp */; };
> 		B27535610B053814002CE64F /* IntRectCG.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B27535330B053814002CE64F /* IntRectCG.cpp */; };
> 		B27535620B053814002CE64F /* IntSizeCG.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B27535340B053814002CE64F /* IntSizeCG.cpp */; };
>@@ -9875,6 +9880,12 @@
> 		53EF766A16530A61004CBE49 /* SettingsMacros.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SettingsMacros.h; sourceTree = "<group>"; };
> 		550A0BC7085F6039007353D6 /* QualifiedName.cpp */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.cpp.cpp; path = QualifiedName.cpp; sourceTree = "<group>"; tabWidth = 8; usesTabs = 0; };
> 		550A0BC8085F6039007353D6 /* QualifiedName.h */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = QualifiedName.h; sourceTree = "<group>"; tabWidth = 8; usesTabs = 0; };
>+		554B75341C891B8100F4B405 /* ImageFrameData.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ImageFrameData.cpp; sourceTree = "<group>"; };
>+		554B75351C891B8100F4B405 /* ImageFrameData.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ImageFrameData.h; sourceTree = "<group>"; };
>+		554CB9091C80E9EA0005D248 /* ImageFrameDecoder.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ImageFrameDecoder.cpp; sourceTree = "<group>"; };
>+		554CB90A1C80E9EA0005D248 /* ImageFrameDecoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ImageFrameDecoder.h; sourceTree = "<group>"; };
>+		5579BECB1C81312900536C3E /* ImageDecoder.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ImageDecoder.cpp; sourceTree = "<group>"; };
>+		5579BECC1C81312900536C3E /* ImageDecoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ImageDecoder.h; sourceTree = "<group>"; };
> 		55D408F71A7C631800C78450 /* SVGImageClients.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SVGImageClients.h; sourceTree = "<group>"; };
> 		572A7F201C6E5719009C6149 /* SimulatedClick.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SimulatedClick.h; sourceTree = "<group>"; };
> 		572A7F221C6E5A66009C6149 /* SimulatedClick.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SimulatedClick.cpp; sourceTree = "<group>"; };
>@@ -12905,7 +12916,6 @@
> 		B275352C0B053814002CE64F /* FloatRectCG.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = FloatRectCG.cpp; sourceTree = "<group>"; };
> 		B275352D0B053814002CE64F /* FloatSizeCG.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = FloatSizeCG.cpp; sourceTree = "<group>"; };
> 		B27535300B053814002CE64F /* ImageCG.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = ImageCG.cpp; sourceTree = "<group>"; };
>-		B27535310B053814002CE64F /* ImageSourceCG.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = ImageSourceCG.cpp; sourceTree = "<group>"; };
> 		B27535320B053814002CE64F /* IntPointCG.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = IntPointCG.cpp; sourceTree = "<group>"; };
> 		B27535330B053814002CE64F /* IntRectCG.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = IntRectCG.cpp; sourceTree = "<group>"; };
> 		B27535340B053814002CE64F /* IntSizeCG.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = IntSizeCG.cpp; sourceTree = "<group>"; };
>@@ -21833,7 +21843,10 @@
> 				2292B27B1356669400CF11EF /* ImageBufferDataCG.cpp */,
> 				22BD9F80135364FE009BD102 /* ImageBufferDataCG.h */,
> 				B27535300B053814002CE64F /* ImageCG.cpp */,
>-				B27535310B053814002CE64F /* ImageSourceCG.cpp */,
>+				5579BECB1C81312900536C3E /* ImageDecoder.cpp */,
>+				5579BECC1C81312900536C3E /* ImageDecoder.h */,
>+				554CB9091C80E9EA0005D248 /* ImageFrameDecoder.cpp */,
>+				554CB90A1C80E9EA0005D248 /* ImageFrameDecoder.h */,
> 				4B3480920EEF50D400AC1B41 /* ImageSourceCG.h */,
> 				4B3480910EEF50D400AC1B41 /* ImageSourceCGMac.mm */,
> 				B27535320B053814002CE64F /* IntPointCG.cpp */,
>@@ -21964,6 +21977,8 @@
> 				B2C3DA5A0D006CD600EF6F26 /* FontSelector.h */,
> 				7CE6CBFC187F394900D46BF5 /* FormatConverter.cpp */,
> 				7CE6CBFA187F370700D46BF5 /* FormatConverter.h */,
>+				554B75341C891B8100F4B405 /* ImageFrameData.cpp */,
>+				554B75351C891B8100F4B405 /* ImageFrameData.h */,
> 				4FB390AC15EF61F3007AD51F /* GeneratedImage.cpp */,
> 				BC23F0DA0DAFF4A4009FDC91 /* GeneratedImage.h */,
> 				0FB6252C18DE1B1500A07C05 /* GeometryUtilities.cpp */,
>@@ -25077,6 +25092,7 @@
> 				FD31607F12B026F700C1A359 /* AudioDestination.h in Headers */,
> 				070F549E17F2402700169E04 /* AudioDestinationConsumer.h in Headers */,
> 				FD3160BD12B0272A00C1A359 /* AudioDestinationMac.h in Headers */,
>+				551991B01C8ACB290041E52C /* ImageFrameData.h in Headers */,
> 				FD31600812B0267600C1A359 /* AudioDestinationNode.h in Headers */,
> 				FD31608012B026F700C1A359 /* AudioDSPKernel.h in Headers */,
> 				FD31608212B026F700C1A359 /* AudioDSPKernelProcessor.h in Headers */,
>@@ -27408,6 +27424,7 @@
> 				9377ABA015DEFEEF0031FD04 /* Pagination.h in Headers */,
> 				0885067F11DA045B00182B98 /* PaintInfo.h in Headers */,
> 				0885068011DA045B00182B98 /* PaintPhase.h in Headers */,
>+				5579BECE1C81312900536C3E /* ImageDecoder.h in Headers */,
> 				A80E6CFB0A1989CA007FB8C5 /* Pair.h in Headers */,
> 				FD3160A312B026F700C1A359 /* Panner.h in Headers */,
> 				FD31601A12B0267600C1A359 /* PannerNode.h in Headers */,
>@@ -28399,6 +28416,7 @@
> 				854FE7370A2297BE0058D7AD /* Traversal.h in Headers */,
> 				37FD4298118368460093C029 /* TreeDepthLimit.h in Headers */,
> 				14D64B5D134A5B6B00E58FDA /* TreeScope.h in Headers */,
>+				554CB90C1C80E9EA0005D248 /* ImageFrameDecoder.h in Headers */,
> 				A77E1FF014AACB6E005B7CB6 /* TreeScopeAdopter.h in Headers */,
> 				854FE7390A2297BE0058D7AD /* TreeWalker.h in Headers */,
> 				2D232C001A326F02006BF2DB /* TUCallSPI.h in Headers */,
>@@ -29982,6 +30000,7 @@
> 				977B37251228721700B81FF8 /* HTMLTreeBuilder.cpp in Sources */,
> 				A8EA79F30A1916DF00A8EF5F /* HTMLUListElement.cpp in Sources */,
> 				E44613AA0CD6331000FADA75 /* HTMLVideoElement.cpp in Sources */,
>+				554CB90B1C80E9EA0005D248 /* ImageFrameDecoder.cpp in Sources */,
> 				839AAFEC1A0C0C8D00605F99 /* HTMLWBRElement.cpp in Sources */,
> 				0B8C56D40F28627F000502E1 /* HTTPHeaderMap.cpp in Sources */,
> 				1AC900C31943C0FC008625B5 /* HTTPHeaderNames.cpp in Sources */,
>@@ -30060,7 +30079,6 @@
> 				2D5A592F152525230036EE51 /* ImageOrientation.cpp in Sources */,
> 				B51A2F4117D7D5DE0072517A /* ImageQualityController.cpp in Sources */,
> 				0F3C725E1974874B00AEDD0C /* ImageSource.cpp in Sources */,
>-				B275355F0B053814002CE64F /* ImageSourceCG.cpp in Sources */,
> 				4B3480930EEF50D400AC1B41 /* ImageSourceCGMac.mm in Sources */,
> 				316FE1170E6E1DA700BF6088 /* ImplicitAnimation.cpp in Sources */,
> 				BE961C5418AD338500D07DC5 /* InbandDataTextTrack.cpp in Sources */,
>@@ -30943,6 +30961,7 @@
> 				4E1959210A39DABA00220FE5 /* MediaFeatureNames.cpp in Sources */,
> 				07A6D1EB1491137700051D0C /* MediaFragmentURIParser.cpp in Sources */,
> 				CDB859F7160D48A400E5B07F /* MediaKeyEvent.cpp in Sources */,
>+				5579BECD1C81312900536C3E /* ImageDecoder.cpp in Sources */,
> 				CDA98DD816025BEF00FEA3B1 /* MediaKeyMessageEvent.cpp in Sources */,
> 				CD1B4A65160786AE00282DF9 /* MediaKeyNeededEvent.cpp in Sources */,
> 				CDA98E0D1603FE4A00FEA3B1 /* MediaKeys.cpp in Sources */,
>@@ -31258,6 +31277,7 @@
> 				50D10D991545F5760096D288 /* RenderLayerFilterInfo.cpp in Sources */,
> 				3C244FEBA375AC633F88BE6F /* RenderLayerModelObject.cpp in Sources */,
> 				BC33FB1B0F30EE85002CDD7C /* RenderLineBoxList.cpp in Sources */,
>+				554B75361C891B8100F4B405 /* ImageFrameData.cpp in Sources */,
> 				BCEA4863097D93020094C9E4 /* RenderLineBreak.cpp in Sources */,
> 				ABB5419E0ACDDFE4002820EB /* RenderListBox.cpp in Sources */,
> 				A8EA7A4E0A191A5200A8EF5F /* RenderListItem.cpp in Sources */,
>diff --git a/Source/WebCore/loader/cache/MemoryCache.cpp b/Source/WebCore/loader/cache/MemoryCache.cpp
>index 999465ea390697cbe00fe6fa8838c138e5447a17..846c0dc9384e75dba0820c280fb641ce8a08f160 100644
>--- a/Source/WebCore/loader/cache/MemoryCache.cpp
>+++ b/Source/WebCore/loader/cache/MemoryCache.cpp
>@@ -225,8 +225,6 @@ bool MemoryCache::addImageToCache(NativeImagePtr image, const URL& url, const St
> 
>     std::unique_ptr<CachedImage> cachedImage = std::make_unique<CachedImage>(url, bitmapImage.get(), CachedImage::ManuallyCached, sessionID);
> 
>-    // Actual release of the CGImageRef is done in BitmapImage.
>-    CFRetain(image);
>     cachedImage->addClient(&dummyCachedImageClient());
>     cachedImage->setDecodedSize(bitmapImage->decodedSize());
> #if ENABLE(CACHE_PARTITIONING)
>diff --git a/Source/WebCore/platform/graphics/BitmapImage.cpp b/Source/WebCore/platform/graphics/BitmapImage.cpp
>index faf0f86962c3fb6577745bfaf75b4c84d80cc060..0f9a1ffbea12f4eb594fdd0295965a0e012ce32a 100644
>--- a/Source/WebCore/platform/graphics/BitmapImage.cpp
>+++ b/Source/WebCore/platform/graphics/BitmapImage.cpp
>@@ -47,17 +47,14 @@ namespace WebCore {
> 
> BitmapImage::BitmapImage(ImageObserver* observer)
>     : Image(observer)
>-    , m_minimumSubsamplingLevel(0)
>+    , m_source(this)
>+    , m_maximumSubsamplingLevel(0)
>     , m_imageOrientation(OriginTopLeft)
>-    , m_shouldRespectImageOrientation(false)
>     , m_currentFrame(0)
>     , m_repetitionCount(cAnimationNone)
>     , m_repetitionCountStatus(Unknown)
>     , m_repetitionsComplete(0)
>     , m_desiredFrameStartTime(0)
>-    , m_decodedSize(0)
>-    , m_decodedPropertiesSize(0)
>-    , m_frameCount(0)
> #if PLATFORM(IOS)
>     // FIXME: We should expose a setting to enable/disable progressive loading remove the PLATFORM(IOS)-guard.
>     , m_progressiveLoadChunkTime(0)
>@@ -66,14 +63,9 @@ BitmapImage::BitmapImage(ImageObserver* observer)
> #else
>     , m_allowSubsampling(false)
> #endif
>-    , m_isSolidColor(false)
>-    , m_checkedForSolidColor(false)
>     , m_animationFinished(false)
>     , m_allDataReceived(false)
>     , m_haveSize(false)
>-    , m_sizeAvailable(false)
>-    , m_hasUniformFrameSize(true)
>-    , m_haveFrameCount(false)
>     , m_animationFinishedWhenCatchingUp(false)
> {
> }
>@@ -98,13 +90,7 @@ void BitmapImage::startTimer(double delay)
> 
> bool BitmapImage::haveFrameAtIndex(size_t index)
> {
>-    if (index >= frameCount())
>-        return false;
>-
>-    if (index >= m_frames.size())
>-        return false;
>-
>-    return m_frames[index].m_frame;
>+    return index < frameCount() && m_source.m_frames.isImageAvailable(index);
> }
> 
> bool BitmapImage::hasSingleSecurityOrigin() const
>@@ -112,27 +98,6 @@ bool BitmapImage::hasSingleSecurityOrigin() const
>     return true;
> }
> 
>-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.
>-        unsigned frameBytes = m_frames[i].m_frameBytes;
>-        if (m_frames[i].clear(false))
>-            frameBytesCleared += frameBytes;
>-    }
>-
>-    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
>@@ -145,112 +110,37 @@ void BitmapImage::destroyDecodedDataIfNecessary(bool destroyAll)
> 
>     // 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())
>+    if (!data() && m_source.m_frames.size())
>         return;
> 
>-    unsigned allFrameBytes = 0;
>-    for (size_t i = 0; i < m_frames.size(); ++i)
>-        allFrameBytes += m_frames[i].m_frameBytes;
>-
>-    if (allFrameBytes > largeAnimationCutoff)
>+    if (m_source.m_frames.framesBytes() > largeAnimationCutoff)
>         destroyDecodedData(destroyAll);
> }
> 
>-void BitmapImage::destroyMetadataAndNotify(unsigned frameBytesCleared, ClearedSource clearedSource)
>-{
>-    m_isSolidColor = false;
>-    m_checkedForSolidColor = false;
>-    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, ImageFrameCaching frameCaching)
>+void BitmapImage::destroyDecodedData(bool destroyAll)
> {
>-    size_t numFrames = frameCount();
>-    ASSERT(m_decodedSize == 0 || numFrames > 1);
>-    
>-    if (m_frames.size() < numFrames)
>-        m_frames.grow(numFrames);
>-
>-    if (frameCaching == CacheMetadataAndFrame) {
>-        m_frames[index].m_frame = m_source.createFrameAtIndex(index, subsamplingLevel);
>-        m_frames[index].m_subsamplingLevel = subsamplingLevel;
>-        if (numFrames == 1 && m_frames[index].m_frame)
>-            checkForSolidColor();
>-    }
>-
>-    m_frames[index].m_orientation = m_source.orientationAtIndex(index);
>-    m_frames[index].m_haveMetadata = true;
>-    m_frames[index].m_isComplete = m_source.frameIsCompleteAtIndex(index);
>-
>-    if (repetitionCount(false) != cAnimationNone)
>-        m_frames[index].m_duration = m_source.frameDurationAtIndex(index);
>-
>-    m_frames[index].m_hasAlpha = m_source.frameHasAlphaAtIndex(index);
>-    m_frames[index].m_frameBytes = m_source.frameBytesAtIndex(index, subsamplingLevel);
>-
>-    const IntSize frameSize(index ? m_source.frameSizeAtIndex(index, subsamplingLevel) : m_size);
>-    if (!subsamplingLevel && frameSize != m_size)
>-        m_hasUniformFrameSize = false;
>-
>-    if (m_frames[index].m_frame) {
>-        int deltaBytes = safeCast<int>(m_frames[index].m_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);
>-    }
>+    const size_t clearBeforeFrame = destroyAll ? m_source.m_frames.size() : m_currentFrame;
>+    m_source.clearFrames(clearBeforeFrame, data(), m_allDataReceived);
>+    destroyMetadataAndNotify();
> }
> 
>-void BitmapImage::didDecodeProperties() const
>+void BitmapImage::destroyMetadataAndNotify()
> {
>-    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);
>+    m_solidColorValue = TriState::Unchecked;
>+    invalidatePlatformData();
> }
> 
> void BitmapImage::updateSize(ImageOrientationDescription description) const
> {
>-    if (!m_sizeAvailable || m_haveSize)
>+    if (!isSizeAvailable() || m_haveSize)
>         return;
> 
>-    m_size = m_source.size(description);
>-    m_sizeRespectingOrientation = m_source.size(ImageOrientationDescription(RespectImageOrientation, description.imageOrientation()));
>-
>+    m_size = m_source.size();
>+    m_sizeRespectingOrientation = m_source.sizeRespectingOrientation();
>     m_imageOrientation = static_cast<unsigned>(description.imageOrientation());
>-    m_shouldRespectImageOrientation = static_cast<unsigned>(description.respectImageOrientation());
> 
>     m_haveSize = true;
>-
>-    determineMinimumSubsamplingLevel();
>-    didDecodeProperties();
>+    determineMaximumSubsamplingLevel();
> }
> 
> FloatSize BitmapImage::size() const
>@@ -267,16 +157,13 @@ IntSize BitmapImage::sizeRespectingOrientation(ImageOrientationDescription descr
> 
> bool BitmapImage::getHotSpot(IntPoint& hotSpot) const
> {
>-    bool result = m_source.getHotSpot(hotSpot);
>-    didDecodeProperties();
>-    return result;
>+    return m_source.getHotSpot(hotSpot);
> }
> 
> 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
>@@ -294,29 +181,8 @@ bool BitmapImage::dataChanged(bool allDataReceived)
>     // 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 (size_t i = 0; i < m_frames.size(); ++i) {
>-        // NOTE: Don't call frameIsCompleteAtIndex() here, that will try to
>-        // decode any uncached (i.e. never-decoded or
>-        // cleared-on-a-previous-pass) frames!
>-        unsigned frameBytes = m_frames[i].m_frameBytes;
>-        if (m_frames[i].m_haveMetadata && !m_frames[i].m_isComplete)
>-            frameBytesCleared += (m_frames[i].clear(true) ? frameBytes : 0);
>-    }
>-    destroyMetadataAndNotify(frameBytesCleared, ClearedSource::No);
>-#else
>-    // FIXME: why is this different for iOS?
>-    int deltaBytes = 0;
>-    if (!m_frames.isEmpty()) {
>-        int bytes = m_frames[m_frames.size() - 1].m_frameBytes;
>-        if (m_frames[m_frames.size() - 1].clear(true)) {
>-            deltaBytes += bytes;
>-            deltaBytes += m_decodedPropertiesSize;
>-            m_decodedPropertiesSize = 0;
>-        }
>-    }
>-    destroyMetadataAndNotify(deltaBytes, ClearedSource::No);
>-#endif
>+    m_source.clearPartialFrames();
>+    destroyMetadataAndNotify();
>     
>     // Feed all the data we've seen so far to the image decoder.
>     m_allDataReceived = allDataReceived;
>@@ -339,125 +205,27 @@ bool BitmapImage::dataChanged(bool allDataReceived)
>     m_source.setData(data(), allDataReceived);
> #endif
> 
>-    m_haveFrameCount = false;
>-    m_hasUniformFrameSize = true;
>     return isSizeAvailable();
> }
> 
>-String BitmapImage::filenameExtension() const
>+size_t BitmapImage::frameCount() const
> {
>-    return m_source.filenameExtension();
>-}
>-
>-size_t BitmapImage::frameCount()
>-{
>-    if (!m_haveFrameCount) {
>+    if (!m_frameCount)
>         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;
>-}
>-
>-bool BitmapImage::ensureFrameIsCached(size_t index, ImageFrameCaching frameCaching)
>-{
>-    if (index >= frameCount())
>-        return false;
>-
>-    if (index >= m_frames.size()
>-        || (frameCaching == CacheMetadataAndFrame && !m_frames[index].m_frame)
>-        || (frameCaching == CacheMetadataOnly && !m_frames[index].m_haveMetadata))
>-        cacheFrame(index, 0, frameCaching);
>-
>-    return true;
>-}
>-
> PassNativeImagePtr BitmapImage::frameAtIndex(size_t index, float presentationScaleHint)
> {
>     if (index >= frameCount())
>         return nullptr;
> 
>-    SubsamplingLevel subsamplingLevel = std::min(m_source.subsamplingLevelForScale(presentationScaleHint), m_minimumSubsamplingLevel);
>-
>-    // 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].m_frame && subsamplingLevel < m_frames[index].m_subsamplingLevel) {
>-        // If the image is already cached, but at too small a size, re-decode a larger version.
>-        int sizeChange = -m_frames[index].m_frameBytes;
>-        m_frames[index].clear(true);
>-        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].m_frame)
>-        cacheFrame(index, subsamplingLevel, CacheMetadataAndFrame);
>-
>-    return m_frames[index].m_frame;
>-}
>-
>-bool BitmapImage::frameIsCompleteAtIndex(size_t index)
>-{
>-    if (!ensureFrameIsCached(index, CacheMetadataOnly))
>-        return false;
>-
>-    return m_frames[index].m_isComplete;
>-}
>-
>-float BitmapImage::frameDurationAtIndex(size_t index)
>-{
>-    if (!ensureFrameIsCached(index, CacheMetadataOnly))
>-        return 0;
>-
>-    return m_frames[index].m_duration;
>-}
>-
>-PassNativeImagePtr BitmapImage::nativeImageForCurrentFrame()
>-{
>-    return frameAtIndex(currentFrame());
>-}
>-
>-bool BitmapImage::frameHasAlphaAtIndex(size_t index)
>-{
>-    if (!ensureFrameIsCached(index, CacheMetadataOnly))
>-        return true;
>-
>-    if (m_frames[index].m_haveMetadata)
>-        return m_frames[index].m_hasAlpha;
>-
>-    return m_source.frameHasAlphaAtIndex(index);
>-}
>-
>-bool BitmapImage::currentFrameKnownToBeOpaque()
>-{
>-    return !frameHasAlphaAtIndex(currentFrame());
>-}
>-
>-ImageOrientation BitmapImage::frameOrientationAtIndex(size_t index)
>-{
>-    if (!ensureFrameIsCached(index, CacheMetadataOnly))
>-        return DefaultImageOrientation;
>-
>-    if (m_frames[index].m_haveMetadata)
>-        return m_frames[index].m_orientation;
>+    SubsamplingLevel subsamplingLevel = m_source.subsamplingLevelForScale(presentationScaleHint, m_maximumSubsamplingLevel);
>+    const ImageFrameData* frame = m_source.frameAtIndex(index, subsamplingLevel);
>+    if (!frame)
>+        return nullptr;
> 
>-    return m_source.orientationAtIndex(index);
>+    return frame->m_image;
> }
> 
> #if !ASSERT_DISABLED
>@@ -475,7 +243,6 @@ int BitmapImage::repetitionCount(bool imageKnownToBeComplete)
>         // decoder will default to cAnimationLoopOnce, 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 == cAnimationNone) ? Certain : Uncertain;
>     }
>     return m_repetitionCount;
>@@ -679,18 +446,23 @@ bool BitmapImage::internalAdvanceAnimation(AnimationAdvancement advancement)
>     return advancedAnimation;
> }
> 
>-bool BitmapImage::mayFillWithSolidColor()
>+bool BitmapImage::isSolidColor()
> {
>-    if (!m_checkedForSolidColor && frameCount() > 0) {
>+    if (m_solidColorValue == TriState::Unchecked && frameCount()) {
>         checkForSolidColor();
>-        ASSERT(m_checkedForSolidColor);
>+        ASSERT(m_solidColorValue != TriState::Unchecked);
>     }
>-    return m_isSolidColor && !m_currentFrame;
>+    return m_solidColorValue == TriState::Yes;
>+}
>+
>+bool BitmapImage::mayFillWithSolidColor()
>+{
>+    return isSolidColor() && !m_currentFrame;
> }
> 
>-Color BitmapImage::solidColor() const
>+Color BitmapImage::solidColor()
> {
>-    return m_solidColor;
>+    return isSolidColor() ? m_solidColor : Color();
> }
>     
> bool BitmapImage::canAnimate()
>@@ -705,15 +477,14 @@ void BitmapImage::dump(TextStream& ts) const
>     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 (allowSubsampling())
>         ts.dumpProperty("allow-subsampling", allowSubsampling());
>-    if (m_isSolidColor)
>-        ts.dumpProperty("solid-color", m_isSolidColor);
>+    if (m_solidColorValue != TriState::Unchecked)
>+        ts.dumpProperty("solid-color", m_solidColor);
>     
>     if (m_imageOrientation != OriginTopLeft)
>         ts.dumpProperty("orientation", m_imageOrientation);
>diff --git a/Source/WebCore/platform/graphics/BitmapImage.h b/Source/WebCore/platform/graphics/BitmapImage.h
>index 7493c6a4bfb863d97637c49c464cc37ae78e0a04..40e6066ce8f9acd0eb8402af56bf8cc447610115 100644
>--- a/Source/WebCore/platform/graphics/BitmapImage.h
>+++ b/Source/WebCore/platform/graphics/BitmapImage.h
>@@ -30,6 +30,7 @@
> 
> #include "Image.h"
> #include "Color.h"
>+#include "ImageFrameData.h"
> #include "ImageOrientation.h"
> #include "ImageSource.h"
> #include "IntSize.h"
>@@ -47,57 +48,9 @@ typedef struct HBITMAP__ *HBITMAP;
> #endif
> 
> namespace WebCore {
>-    struct FrameData;
>-}
>-
>-namespace WTF {
>-    template<> struct VectorTraits<WebCore::FrameData> : public SimpleClassVectorTraits {
>-        static const bool canInitializeWithMemset = false; // Not all FrameData members initialize to 0.
>-    };
>-}
>-
>-namespace WebCore {
> 
> class Timer;
> 
>-// ================================================
>-// FrameData Class
>-// ================================================
>-
>-struct FrameData {
>-    WTF_MAKE_NONCOPYABLE(FrameData);
>-public:
>-    FrameData()
>-        : m_frame(0)
>-        , m_orientation(DefaultImageOrientation)
>-        , m_subsamplingLevel(0)
>-        , m_duration(0)
>-        , m_haveMetadata(false)
>-        , m_isComplete(false)
>-        , m_hasAlpha(true) 
>-        , m_frameBytes(0)
>-    {
>-    }
>-
>-    ~FrameData()
>-    { 
>-        clear(true);
>-    }
>-
>-    // Clear the cached image data on the frame, and (optionally) the metadata.
>-    // Returns whether there was cached image data to clear.
>-    bool clear(bool clearMetadata);
>-
>-    NativeImagePtr m_frame;
>-    ImageOrientation m_orientation;
>-    SubsamplingLevel m_subsamplingLevel;
>-    float m_duration;
>-    bool m_haveMetadata : 1;
>-    bool m_isComplete : 1;
>-    bool m_hasAlpha : 1;
>-    unsigned m_frameBytes;
>-};
>-
> // =================================================
> // BitmapImage Class
> // =================================================
>@@ -129,10 +82,10 @@ public:
> 
>     bool getHotSpot(IntPoint&) const override;
> 
>-    unsigned decodedSize() const { return m_decodedSize; }
>+    unsigned decodedSize() const { return m_source.m_frames.framesBytes(); }
> 
>     bool dataChanged(bool allDataReceived) override;
>-    String filenameExtension() const 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
>@@ -172,12 +125,11 @@ public:
>     Evas_Object* getEvasObject(Evas*) override;
> #endif
> 
>-    PassNativeImagePtr nativeImageForCurrentFrame() override;
>+    PassNativeImagePtr nativeImageForCurrentFrame() override { return frameAtIndex(currentFrame()); }
>     ImageOrientation orientationForCurrentFrame() override { return frameOrientationAtIndex(currentFrame()); }
>+    bool currentFrameKnownToBeOpaque() override { return !frameHasAlphaAtIndex(currentFrame()); }
> 
>-    bool currentFrameKnownToBeOpaque() override;
>-
>-    bool isAnimated() const override { return m_frameCount > 1; }
>+    bool isAnimated() const override { return frameCount() > 1; }
>     
>     bool canAnimate();
> 
>@@ -190,7 +142,7 @@ private:
>     bool isBitmapImage() const override { return true; }
> 
>     void updateSize(ImageOrientationDescription = ImageOrientationDescription()) const;
>-    void determineMinimumSubsamplingLevel() const;
>+    void determineMaximumSubsamplingLevel() const;
> 
> protected:
>     enum RepetitionCountStatus {
>@@ -212,24 +164,18 @@ protected:
>         const FloatPoint& phase, const FloatSize& spacing, CompositeOperator, const FloatRect& destRect);
> #endif
> 
>-    size_t frameCount();
>+    size_t frameCount() const;
> 
>     PassNativeImagePtr frameAtIndex(size_t, float presentationScaleHint = 1);
>     PassNativeImagePtr copyUnscaledFrameAtIndex(size_t);
> 
>-    bool haveFrameAtIndex(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.
>-    enum ImageFrameCaching { CacheMetadataOnly, CacheMetadataAndFrame };
>-    void cacheFrame(size_t index, SubsamplingLevel, ImageFrameCaching = CacheMetadataAndFrame);
>+    bool haveFrameAtIndex(size_t);
> 
>-    // Called before accessing m_frames[index] for info without decoding. Returns false on index out of bounds.
>-    bool ensureFrameIsCached(size_t index, ImageFrameCaching = CacheMetadataAndFrame);
>+    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); }
> 
>     // Called to invalidate cached data. When |destroyAll| is true, we wipe out
>     // the entire frame buffer cache and tell the image source to destroy
>@@ -246,17 +192,10 @@ protected:
>     // 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);
>+    void destroyMetadataAndNotify();
> 
>     // 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;
>+    bool isSizeAvailable() const { return m_source.isSizeAvailable(); }
> 
>     // Animation.
>     int repetitionCount(bool imageKnownToBeComplete);  // |imageKnownToBeComplete| should be set if the caller knows the entire image has been decoded.
>@@ -280,8 +219,9 @@ protected:
>     // changed.
>     void checkForSolidColor();
> 
>+    bool isSolidColor();
>     bool mayFillWithSolidColor() override;
>-    Color solidColor() const override;
>+    Color solidColor() override;
> 
> #if !ASSERT_DISABLED
>     bool notSolidColor() override;
>@@ -297,13 +237,11 @@ private:
>     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;
> 
>-    mutable SubsamplingLevel m_minimumSubsamplingLevel;
>+    mutable SubsamplingLevel m_maximumSubsamplingLevel;
> 
>     mutable unsigned m_imageOrientation : 4; // ImageOrientationEnum
>-    mutable unsigned m_shouldRespectImageOrientation : 1; // RespectImageOrientationEnum
> 
>     size_t m_currentFrame; // The index of the current frame of animation.
>-    Vector<FrameData, 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;
>     int m_repetitionCount; // How many total animation loops we should do. This will be cAnimationNone if this image type is incapable of animation.
>@@ -319,10 +257,7 @@ private:
> #endif
> 
>     Color m_solidColor;  // If we're a 1x1 solid color, this is the color to use to fill.
>-
>-    unsigned m_decodedSize; // The current size of all decoded frames.
>-    mutable unsigned m_decodedPropertiesSize; // The size of data decoded by the source to determine image properties (e.g. size, frame count, etc).
>-    size_t m_frameCount;
>+    mutable size_t m_frameCount { 0 };
> 
> #if PLATFORM(IOS)
>     // FIXME: We should expose a setting to enable/disable progressive loading remove the PLATFORM(IOS)-guard.
>@@ -330,17 +265,14 @@ private:
>     uint16_t m_progressiveLoadChunkCount;
> #endif
> 
>-    bool m_allowSubsampling : 1; // Whether we should attempt subsampling if this image is very large.
>-    bool m_isSolidColor : 1; // Whether or not we are a 1x1 solid image.
>-    bool m_checkedForSolidColor : 1; // Whether we've checked the frame for solid color.
>+    enum class TriState { Unchecked, No, Yes };
>+    TriState m_solidColorValue { TriState::Unchecked };
> 
>+    bool m_allowSubsampling : 1; // Whether we should attempt subsampling if this image is very large.
>     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_hasUniformFrameSize : 1;
>-    mutable bool m_haveFrameCount : 1;
>     bool m_animationFinishedWhenCatchingUp : 1;
> 
>     RefPtr<Image> m_cachedImage;
>diff --git a/Source/WebCore/platform/graphics/Icon.h b/Source/WebCore/platform/graphics/Icon.h
>index d95e7deb810fc24f7f61b1b23a4b9aef3f3c17b7..28c137d29b118a9cf1b6161ede4de491d0488308 100644
>--- a/Source/WebCore/platform/graphics/Icon.h
>+++ b/Source/WebCore/platform/graphics/Icon.h
>@@ -68,8 +68,8 @@ public:
> 
> private:
> #if PLATFORM(IOS)
>-    Icon(CGImageRef);
>-    RetainPtr<CGImageRef> m_cgImage;
>+    Icon(NativeImagePtr);
>+    NativeImagePtr m_cgImage;
> #elif PLATFORM(MAC)
>     Icon(NSImage*);
>     RetainPtr<NSImage> m_nsImage;
>diff --git a/Source/WebCore/platform/graphics/Image.h b/Source/WebCore/platform/graphics/Image.h
>index 41fef2a2b03170e3b03fd6c52a2fdf283e562758..b12c0c1ee2ff814145dad0a346d1c7a774b6a78c 100644
>--- a/Source/WebCore/platform/graphics/Image.h
>+++ b/Source/WebCore/platform/graphics/Image.h
>@@ -194,7 +194,7 @@ protected:
> 
>     // Supporting tiled drawing
>     virtual bool mayFillWithSolidColor() { return false; }
>-    virtual Color solidColor() const { return Color(); }
>+    virtual Color solidColor() { return Color(); }
>     
> private:
>     RefPtr<SharedBuffer> m_encodedImageData;
>diff --git a/Source/WebCore/platform/graphics/ImageFrameData.cpp b/Source/WebCore/platform/graphics/ImageFrameData.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..da08de619705d740611696494b1c0bb3d4090385
>--- /dev/null
>+++ b/Source/WebCore/platform/graphics/ImageFrameData.cpp
>@@ -0,0 +1,156 @@
>+/*
>+ * 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 "ImageFrameData.h"
>+
>+#include "ImageDecoder.h"
>+
>+namespace WebCore {
>+
>+ImageFrameData::ImageFrameData()
>+{
>+}
>+
>+ImageFrameData::ImageFrameData(ImageDecoder& decoder, size_t index, SubsamplingLevel subsamplingLevel, const NativeImagePtr& image)
>+    : m_image(image)
>+    , m_subsamplingLevel(subsamplingLevel)
>+    , m_haveMetadata(true)
>+{
>+#if USE(CG)
>+    m_orientation = decoder.orientationAtIndex(index);
>+    m_hasAlpha = decoder.frameHasAlphaAtIndex(index);
>+    m_frameBytes = decoder.frameBytesAtIndex(index, subsamplingLevel);
>+
>+    m_allowSubsampling = decoder.allowSubsamplingOfFrameAtIndex(index);
>+
>+    m_isComplete = decoder.frameIsCompleteAtIndex(index);
>+    if (decoder.repetitionCount() != cAnimationNone)
>+        m_duration = decoder.frameDurationAtIndex(index);
>+#else
>+    m_orientation = decoder.orientation();
>+    m_hasAlpha = decoder.frameHasAlphaAtIndex(index);
>+    m_frameBytes = decoder.frameBytesAtIndex(index);
>+
>+    ImageFrame* buffer = decoder.frameBufferAtIndex(index);
>+    if (buffer && buffer->status() != ImageFrame::FrameEmpty) {
>+        m_isComplete = buffer->status() == ImageFrame::FrameComplete;
>+        if (decoder.repetitionCount() != cAnimationNone) {
>+            // Many annoying ads specify a 0 duration to make an image flash as quickly as possible.
>+            // We follow Firefox's behavior and use a duration of 100 ms for any frames that specify
>+            // a duration of <= 10 ms. See <rdar://problem/7689300> and <http://webkit.org/b/36082>
>+            // for more information.
>+            m_duration = std::max(buffer->duration() / 1000.0f, 0.100f);
>+        }
>+    }
>+#endif
>+}
>+
>+ImageFrameData::~ImageFrameData()
>+{
>+    clear(ImageFrameCaching::None);
>+}
>+
>+ImageFrameStatus ImageFrameData::status() const
>+{
>+    if (!m_image)
>+        return ImageFrameStatus::Empty;
>+
>+    return m_isComplete ? ImageFrameStatus::Complete : ImageFrameStatus::Partial;
>+}
>+
>+ImageFrameDataBuffer::ImageFrameDataBuffer()
>+{
>+}
>+
>+ImageFrameData& ImageFrameDataBuffer::operator[](ImageFrameIndex index)
>+{
>+    if (index >= size())
>+        m_frames.grow(index + 1);
>+    return m_frames[index];
>+}
>+
>+const ImageFrameData& ImageFrameDataBuffer::operator[](ImageFrameIndex index) const
>+{
>+    if (index >= size())
>+        m_frames.grow(index + 1);
>+    return m_frames[index];
>+}
>+
>+bool ImageFrameDataBuffer::isImageAvailable(ImageFrameIndex index) const
>+{
>+    if (index >= size())
>+        return false;
>+    return m_frames[index].m_image;
>+}
>+
>+bool ImageFrameDataBuffer::isFrameAvailable(ImageFrameIndex index, ImageFrameCaching frameCaching) const
>+{
>+    if (index >= m_frames.size())
>+        return false;
>+    return (frameCaching == ImageFrameCaching::MetadataAndFrame && m_frames[index].m_image)
>+        || (frameCaching == ImageFrameCaching::Metadata && m_frames[index].m_haveMetadata);
>+}
>+
>+bool ImageFrameDataBuffer::isFrameInvalid(ImageFrameIndex index, SubsamplingLevel subsamplingLevel) const
>+{
>+    return isImageAvailable(index) && subsamplingLevel != m_frames[index].m_subsamplingLevel;
>+}
>+
>+unsigned ImageFrameDataBuffer::framesBytes(ImageFrameIndex beforeIndex) const
>+{
>+    unsigned totalFrameBytes = 0;
>+    for (size_t i = 0; i < std::min(beforeIndex, size()); ++i) {
>+        if (m_frames[i].status() == ImageFrameStatus::Partial || m_frames[i].status() == ImageFrameStatus::Complete)
>+            totalFrameBytes += m_frames[i].m_frameBytes;
>+    }
>+    return totalFrameBytes;
>+}
>+
>+unsigned ImageFrameDataBuffer::partialFramesBytes(ImageFrameIndex beforeIndex) const
>+{
>+    unsigned totalFrameBytes = 0;
>+    for (size_t i = 0; i < std::min(beforeIndex, size()); ++i) {
>+        if (m_frames[i].status() == ImageFrameStatus::Partial)
>+            totalFrameBytes += m_frames[i].m_frameBytes;
>+    }
>+    return totalFrameBytes;
>+}
>+
>+void ImageFrameDataBuffer::clearFrames(ImageFrameIndex beforeIndex, ImageFrameCaching frameCaching)
>+{
>+    for (size_t i = 0; i < std::min(beforeIndex, size()); ++i)
>+        m_frames[i].clear(frameCaching);
>+}
>+
>+void ImageFrameDataBuffer::clearPartialFrames(ImageFrameIndex beforeIndex, ImageFrameCaching frameCaching)
>+{
>+    for (size_t i = 0; i < std::min(beforeIndex, size()); ++i) {
>+        if (m_frames[i].status() == ImageFrameStatus::Partial)
>+            m_frames[i].clear(frameCaching);
>+    }
>+}
>+
>+}
>diff --git a/Source/WebCore/platform/graphics/ImageFrameData.h b/Source/WebCore/platform/graphics/ImageFrameData.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..527495078c5923e4cc67635df21fc88abeb76fee
>--- /dev/null
>+++ b/Source/WebCore/platform/graphics/ImageFrameData.h
>@@ -0,0 +1,114 @@
>+/*
>+ * 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.
>+ */
>+
>+#ifndef ImageFrameData_h
>+#define ImageFrameData_h
>+
>+#include "Color.h"
>+#include "ImageOrientation.h"
>+#include "IntSize.h"
>+#include "NativeImagePtr.h"
>+
>+#include <wtf/Optional.h>
>+#include <wtf/Vector.h>
>+
>+namespace WebCore {
>+
>+// SubsamplingLevel. 0 is no subsampling, 1 is half dimensions on each axis etc.
>+typedef short SubsamplingLevel;
>+typedef size_t ImageFrameIndex;
>+
>+static const ImageFrameIndex MaxImageFrameIndex = std::numeric_limits<ImageFrameIndex>::max();
>+
>+enum class ImageFrameCaching {
>+    None,
>+    Metadata,
>+    Frame,
>+    MetadataAndFrame
>+};
>+
>+enum class ImageFrameStatus {
>+    Empty,
>+    Partial,
>+    Complete
>+};
>+
>+class ImageDecoder;
>+
>+struct ImageFrameData {
>+public:
>+    ImageFrameData();
>+    ImageFrameData(const NativeImagePtr&);
>+    ImageFrameData(ImageDecoder&, ImageFrameIndex, SubsamplingLevel, const NativeImagePtr& = nullptr);
>+    ~ImageFrameData();
>+
>+    ImageFrameStatus status() const;
>+
>+    bool clear(ImageFrameCaching);
>+    Optional<Color> solidColor() const;
>+
>+    NativeImagePtr m_image { nullptr };
>+    ImageOrientation m_orientation { DefaultImageOrientation };
>+    SubsamplingLevel m_subsamplingLevel { 0 };
>+    float m_duration { 0 };
>+    union {
>+        struct {
>+            bool m_haveMetadata : 1;
>+            bool m_isComplete : 1;
>+            bool m_hasAlpha : 1;
>+            bool m_allowSubsampling : 1;
>+        };
>+        uint8_t m_flags[sizeof(bool)] { 0 };
>+    };
>+    unsigned m_frameBytes { 0 };
>+    IntSize m_size;
>+};
>+
>+class ImageFrameDataBuffer {
>+public:
>+    ImageFrameDataBuffer();
>+
>+    size_t size() const { return m_frames.size(); }
>+    ImageFrameData& operator[](ImageFrameIndex);
>+    const ImageFrameData& operator[](ImageFrameIndex) const;
>+
>+    bool isImageAvailable(ImageFrameIndex) const;
>+    bool isFrameAvailable(ImageFrameIndex, ImageFrameCaching) const;
>+    bool isFrameInvalid(ImageFrameIndex, SubsamplingLevel) const;
>+
>+    unsigned framesBytes(ImageFrameIndex = MaxImageFrameIndex) const;
>+    unsigned partialFramesBytes(ImageFrameIndex = MaxImageFrameIndex) const;
>+
>+    void clearFrames(ImageFrameIndex = MaxImageFrameIndex, ImageFrameCaching = ImageFrameCaching::Metadata);
>+    void clearPartialFrames(ImageFrameIndex = MaxImageFrameIndex, ImageFrameCaching = ImageFrameCaching::None);
>+
>+private:
>+    using ImageFrames = Vector<ImageFrameData, 1>;
>+    mutable ImageFrames m_frames;
>+};
>+
>+} // namespace WebCore
>+
>+#endif // ImageFrameData_h
>diff --git a/Source/WebCore/platform/graphics/ImageSource.cpp b/Source/WebCore/platform/graphics/ImageSource.cpp
>index 74ef053a333ff5fc578e81800cc6fc9755efbab8..6d62f84e410151d4994233fc7dcd2819489b4fa3 100644
>--- a/Source/WebCore/platform/graphics/ImageSource.cpp
>+++ b/Source/WebCore/platform/graphics/ImageSource.cpp
>@@ -1,5 +1,5 @@
> /*
>- * Copyright (C) 2006 Apple Inc.  All rights reserved.
>+ * Copyright (C) 2006, 2016 Apple Inc.  All rights reserved.
>  * Copyright (C) 2007 Alp Toker <alp.toker@collabora.co.uk>
>  * Copyright (C) 2008, Google Inc. All rights reserved.
>  * Copyright (C) 2007-2009 Torch Mobile, Inc
>@@ -29,191 +29,359 @@
> #include "config.h"
> #include "ImageSource.h"
> 
>-#if !USE(CG)
>-
>+#include "Image.h"
> #include "ImageDecoder.h"
>+#include "ImageObserver.h"
> 
> #include "ImageOrientation.h"
> #include "NotImplemented.h"
> 
>-namespace WebCore {
>-
>-#if ENABLE(IMAGE_DECODER_DOWN_SAMPLING)
>-unsigned ImageSource::s_maxPixelsPerDecodedImage = 1024 * 1024;
>+#if USE(CG)
>+#include "ImageFrameDecoder.h"
> #endif
> 
>-ImageSource::ImageSource(ImageSource::AlphaOption alphaOption, ImageSource::GammaAndColorProfileOption gammaAndColorProfileOption)
>-    : m_decoder(0)
>+namespace WebCore {
>+
>+ImageSource::ImageSource(Image* image, ImageSource::AlphaOption alphaOption, ImageSource::GammaAndColorProfileOption gammaAndColorProfileOption)
>+    : m_image(image)
>+#if !USE(CG)
>     , m_alphaOption(alphaOption)
>     , m_gammaAndColorProfileOption(gammaAndColorProfileOption)
>+#endif
>+{
>+#if USE(CG)
>+    UNUSED_PARAM(alphaOption);
>+    UNUSED_PARAM(gammaAndColorProfileOption);
>+#endif
>+}
>+
>+ImageSource::ImageSource(NativeImagePtr image)
>+    : m_frameCount(1)
> {
>+    m_frames[0] = ImageFrameData(image);
>+    m_size = m_frames[0].m_size;
> }
> 
> ImageSource::~ImageSource()
> {
>-    clear(true);
>+    clear();
> }
> 
>-void ImageSource::clear(bool destroyAll, size_t clearBeforeFrame, SharedBuffer* data, bool allDataReceived)
>+void ImageSource::clear(ImageFrameIndex clearBeforeFrame, SharedBuffer* data, bool allDataReceived)
> {
>-    if (!destroyAll) {
>+    // Recent versions of ImageIO discard previously decoded image frames if the client
>+    // application no longer holds references to them, so there's no need to throw away
>+    // the decoder unless we're explicitly asked to destroy all of the frames.
>+    if (clearBeforeFrame < m_frames.size()) {
>+#if !USE(CG)
>         if (m_decoder)
>             m_decoder->clearFrameBufferCache(clearBeforeFrame);
>+#endif
>         return;
>     }
> 
>-    delete m_decoder;
>-    m_decoder = 0;
>-    if (data)
>-        setData(data, allDataReceived);
>+    if (m_decoder) {
>+        delete m_decoder;
>+        m_decoder = nullptr;
>+    }
>+    
>+    setData(data, allDataReceived);
> }
> 
>-bool ImageSource::initialized() const
>+void ImageSource::clearFrames(ImageFrameIndex clearBeforeFrame, SharedBuffer* data, bool allDataReceived)
> {
>-    return m_decoder;
>+    unsigned frameBytes = m_frames.framesBytes(clearBeforeFrame);
>+    m_frames.clearFrames(clearBeforeFrame);
>+    clear(clearBeforeFrame, data, allDataReceived);
>+    decodedSizeDecremented(frameBytes, ClearedFrames::All);
> }
> 
>-void ImageSource::setData(SharedBuffer* data, bool allDataReceived)
>+void ImageSource::clearPartialFrames(ImageFrameIndex clearBeforeFrame)
>+{
>+    unsigned frameBytes = m_frames.partialFramesBytes(clearBeforeFrame);
>+    m_frames.clearPartialFrames();
>+    decodedSizeDecremented(frameBytes);
>+}
>+
>+void ImageSource::ensureDecoderIsCreated(SharedBuffer* data)
> {
>+    if (m_decoder)
>+        return;
>+#if USE(CG)
>+    UNUSED_PARAM(data);
>+    m_decoder = new ImageFrameDecoder(*this, 0);
>+#else
>     // Make the decoder by sniffing the bytes.
>     // This method will examine the data and instantiate an instance of the appropriate decoder plugin.
>     // If insufficient bytes are available to determine the image type, no decoder plugin will be
>     // made.
>-    if (!m_decoder) {
>-        m_decoder = static_cast<NativeImageDecoderPtr>(NativeImageDecoder::create(*data, m_alphaOption, m_gammaAndColorProfileOption));
>+    m_decoder = static_cast<NativeImageDecoderPtr>(NativeImageDecoder::create(*data, m_alphaOption, m_gammaAndColorProfileOption));
> #if ENABLE(IMAGE_DECODER_DOWN_SAMPLING)
>-        if (m_decoder && s_maxPixelsPerDecodedImage)
>-            m_decoder->setMaxNumPixels(s_maxPixelsPerDecodedImage);
>+    if (m_decoder)
>+        m_decoder->setMaxNumPixels(s_maxPixelsPerDecodedImage);
>+#endif
> #endif
>+}
>+
>+void ImageSource::decodedSizeIncremented(unsigned decodedSize) const
>+{
>+    // 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 ImageSource::decodedSizeDecremented(unsigned decodedSize, ClearedFrames clearedFrames) const
>+{
>+    // Clearing the ImageSource destroys the extra decoded data used for determining image properties.
>+    if (clearedFrames == ClearedFrames::All) {
>+        decodedSize += m_decodedPropertiesSize;
>+        m_decodedPropertiesSize = 0;
>     }
>+    decodedSizeChanged(-safeCast<int>(decodedSize));
>+}
> 
>-    if (m_decoder)
>-        m_decoder->setData(data, allDataReceived);
>+void ImageSource::decodedSizeChanged(int decodedSize) const
>+{
>+    if (!m_image || !m_image->imageObserver())
>+        return;
>+
>+    m_image->imageObserver()->decodedSizeChanged(m_image, decodedSize);
> }
> 
>-String ImageSource::filenameExtension() const
>+void ImageSource::didDecodeProperties() const
> {
>-    return m_decoder ? m_decoder->filenameExtension() : String();
>+    // This check will prevent calls from proceeding if the first frame was fully decoded.
>+    if (m_frames.framesBytes() || m_decodedPropertiesSize)
>+        return;
>+
>+    m_decodedPropertiesSize = bytesDecodedToDetermineProperties();
>+    decodedSizeChanged(m_decodedPropertiesSize);
>+}
>+
>+void ImageSource::setData(SharedBuffer* data, bool allDataReceived)
>+{
>+    if (!data)
>+        return;
>+
>+    ensureDecoderIsCreated(data);
>+    if (!m_decoder) {
>+        ASSERT_NOT_REACHED();
>+        return;
>+    }
>+    m_decoder->setData(data, allDataReceived);
> }
> 
>-SubsamplingLevel ImageSource::subsamplingLevelForScale(float) const
>+SubsamplingLevel ImageSource::subsamplingLevelForScale(float scale, SubsamplingLevel maximumSubsamplingLevel) const
> {
>+#if USE(CG)
>+    return ImageDecoder::subsamplingLevelForScale(scale, maximumSubsamplingLevel);
>+#else
>+    UNUSED_PARAM(scale);
>+    UNUSED_PARAM(maximumSubsamplingLevel);
>     return 0;
>+#endif
> }
> 
>-bool ImageSource::allowSubsamplingOfFrameAtIndex(size_t) const
>+size_t ImageSource::bytesDecodedToDetermineProperties() const
> {
>-    return false;
>+#if USE(CG)
>+    return ImageDecoder::bytesDecodedToDetermineProperties();
>+#else
>+    return 0;
>+#endif
> }
> 
>-bool ImageSource::isSizeAvailable()
>+bool ImageSource::isSizeAvailable() const
> {
>-    return m_decoder && m_decoder->isSizeAvailable();
>+    if (!m_size.isEmpty() || !isDecoderInitialized())
>+        return true;
>+    if (!m_decoder->isSizeAvailable())
>+        return false;
>+    didDecodeProperties();
>+    return true;
> }
> 
>-IntSize ImageSource::size(ImageOrientationDescription description) const
>+IntSize ImageSource::size() const
> {
>-    return frameSizeAtIndex(0, 0, description);
>+    if (!m_size.isEmpty() || !isDecoderInitialized())
>+        return m_size;
>+    if (!(m_size = frameSizeAtIndex(0, 0)).isEmpty())
>+        didDecodeProperties();
>+    return m_size;
> }
> 
>-IntSize ImageSource::frameSizeAtIndex(size_t index, SubsamplingLevel, ImageOrientationDescription description) const
>+IntSize ImageSource::sizeRespectingOrientation() const
> {
>-    if (!m_decoder)
>-        return IntSize();
>+    if (!m_sizeRespectingOrientation.isEmpty() || !isDecoderInitialized())
>+        return m_sizeRespectingOrientation;
>+    if (!(m_sizeRespectingOrientation = frameSizeAtIndex(0, 0, RespectImageOrientation)).isEmpty())
>+        didDecodeProperties();
>+    return m_sizeRespectingOrientation;
>+}
> 
>-    IntSize size = m_decoder->frameSizeAtIndex(index);
>-    if ((description.respectImageOrientation() == RespectImageOrientation) && m_decoder->orientation().usesWidthAsHeight())
>-        return IntSize(size.height(), size.width());
>+size_t ImageSource::frameCount() const
>+{
>+    if (m_frameCount || !isDecoderInitialized())
>+        return m_frameCount;
>+    if ((m_frameCount = m_decoder->frameCount()))
>+        didDecodeProperties();
>+    return m_frameCount;
>+}
> 
>-    return size;
>+int ImageSource::repetitionCount()
>+{
>+    if (!isDecoderInitialized())
>+#if USE(CG)
>+        return cAnimationLoopOnce;
>+#else
>+        return cAnimationNone;
>+#endif
>+    int result = m_decoder->repetitionCount();
>+    didDecodeProperties();
>+    return result;
> }
> 
> bool ImageSource::getHotSpot(IntPoint& hotSpot) const
> {
>-    return m_decoder ? m_decoder->hotSpot(hotSpot) : false;
>+    if (!isDecoderInitialized())
>+        return false;
>+#if USE(CG)
>+    bool result = m_decoder->getHotSpot(hotSpot);
>+#else
>+    bool result = m_decoder->hotSpot(hotSpot);
>+#endif
>+    didDecodeProperties();
>+    return result;
> }
> 
>-size_t ImageSource::bytesDecodedToDetermineProperties() const
>+String ImageSource::filenameExtension() const
> {
>-    return 0;
>+    return isDecoderInitialized() ? m_decoder->filenameExtension() : String();
> }
> 
>-int ImageSource::repetitionCount()
>+bool ImageSource::allowSubsamplingOfFrameAtIndex(ImageFrameIndex index) const
> {
>-    return m_decoder ? m_decoder->repetitionCount() : cAnimationNone;
>+#if USE(CG)
>+    return isDecoderInitialized() && m_decoder->allowSubsamplingOfFrameAtIndex(index);
>+#else
>+    UNUSED_PARAM(index);
>+    return false;
>+#endif
> }
> 
>-size_t ImageSource::frameCount() const
>+IntSize ImageSource::frameSizeAtIndex(ImageFrameIndex index, SubsamplingLevel subsamplingLevel, RespectImageOrientationEnum shouldRespectImageOrientation) const
> {
>-    return m_decoder ? m_decoder->frameCount() : 0;
>+    if (!isDecoderInitialized())
>+        return IntSize();
>+#if USE(CG)
>+    IntSize size = m_decoder->frameSizeAtIndex(index, subsamplingLevel);
>+    ImageOrientation orientation = m_decoder->orientationAtIndex(index);
>+#else
>+    UNUSED_PARAM(subsamplingLevel);
>+
>+    IntSize size = m_decoder->frameSizeAtIndex(index);
>+    ImageOrientation orientation = m_decoder->orientation();
>+#endif
>+    return shouldRespectImageOrientation == RespectImageOrientation && orientation.usesWidthAsHeight() ? size.transposedSize() : size;
> }
> 
>-PassNativeImagePtr ImageSource::createFrameAtIndex(size_t index, SubsamplingLevel)
>+PassNativeImagePtr ImageSource::createFrameImageAtIndex(ImageFrameIndex index, SubsamplingLevel subsamplingLevel)
> {
>-    if (!m_decoder)
>-        return 0;
>+    if (!isDecoderInitialized())
>+        return nullptr;
>+#if USE(CG)
>+    return m_decoder->createFrameImageAtIndex(index, subsamplingLevel);
>+#else
>+    UNUSED_PARAM(subsamplingLevel);
> 
>     ImageFrame* buffer = m_decoder->frameBufferAtIndex(index);
>     if (!buffer || buffer->status() == ImageFrame::FrameEmpty)
>-        return 0;
>+        return nullptr;
> 
>     // Zero-height images can cause problems for some ports.  If we have an
>     // empty image dimension, just bail.
>     if (size().isEmpty())
>-        return 0;
>+        return nullptr;
> 
>     // Return the buffer contents as a native image.  For some ports, the data
>     // is already in a native container, and this just increments its refcount.
>     return buffer->asNewNativeImage();
>+#endif
> }
> 
>-float ImageSource::frameDurationAtIndex(size_t index)
>+void ImageSource::cacheFrameAtIndex(ImageFrameIndex index, SubsamplingLevel subsamplingLevel, ImageFrameCaching frameCaching)
> {
>-    if (!m_decoder)
>-        return 0;
>+    NativeImagePtr image = nullptr;
>+    if (frameCaching == ImageFrameCaching::MetadataAndFrame)
>+        image = createFrameImageAtIndex(index, subsamplingLevel);
>+    
>+    m_frames[index] = ImageFrameData(*m_decoder, index, subsamplingLevel, image);
>+    if (m_frames[index].m_image)
>+        decodedSizeIncremented(m_frames[index].m_frameBytes);
>+}
> 
>-    ImageFrame* buffer = m_decoder->frameBufferAtIndex(index);
>-    if (!buffer || buffer->status() == ImageFrame::FrameEmpty)
>-        return 0;
>+bool ImageSource::ensureFrameAtIndexIsCached(ImageFrameIndex index, SubsamplingLevel subsamplingLevel, ImageFrameCaching frameCaching)
>+{
>+    if (index >= frameCount())
>+        return false;
>+
>+    if (!m_frames.isFrameAvailable(index, frameCaching))
>+        cacheFrameAtIndex(index, subsamplingLevel, frameCaching);
> 
>-    // Many annoying ads specify a 0 duration to make an image flash as quickly as possible.
>-    // We follow Firefox's behavior and use a duration of 100 ms for any frames that specify
>-    // a duration of <= 10 ms. See <rdar://problem/7689300> and <http://webkit.org/b/36082>
>-    // for more information.
>-    const float duration = buffer->duration() / 1000.0f;
>-    if (duration < 0.011f)
>-        return 0.100f;
>-    return duration;
>+    return true;
> }
> 
>-ImageOrientation ImageSource::orientationAtIndex(size_t) const
>+const ImageFrameData* ImageSource::cachedframeAtIndex(ImageFrameIndex index, SubsamplingLevel subsamplingLevel, ImageFrameCaching frameCaching)
> {
>-    return m_decoder ? m_decoder->orientation() : DefaultImageOrientation;
>+    return ensureFrameAtIndexIsCached(index, subsamplingLevel, frameCaching) ? &m_frames[index] : nullptr;
> }
> 
>-bool ImageSource::frameHasAlphaAtIndex(size_t index)
>+const ImageFrameData* ImageSource::frameAtIndex(ImageFrameIndex index, SubsamplingLevel subsamplingLevel, ImageFrameCaching frameCaching)
> {
>-    if (!m_decoder)
>-        return true;
>-    return m_decoder->frameHasAlphaAtIndex(index);
>+    if (index >= frameCount())
>+        return nullptr;
>+
>+#if USE(CG)
>+    if (isDecoderInitialized() && m_decoder->isDecoding())
>+        return m_decoder->frameAtIndex(index, subsamplingLevel, frameCaching);
>+#endif
>+    // We may have cached a frame with a higher subsampling level, in which case we need to
>+    // re-decode with a lower level.
>+    if (m_frames.isFrameInvalid(index, subsamplingLevel)) {
>+        // If the image is already cached, but at too small a size, re-decode a larger version.
>+        unsigned frameBytes = -m_frames[index].m_frameBytes;
>+        m_frames[index].clear(ImageFrameCaching::None);
>+        decodedSizeIncremented(frameBytes);
>+    }
>+
>+    return cachedframeAtIndex(index, subsamplingLevel, frameCaching);
> }
> 
> bool ImageSource::frameIsCompleteAtIndex(size_t index)
> {
>-    if (!m_decoder)
>-        return false;
>+    const ImageFrameData* frame = frameAtIndex(index, 0, ImageFrameCaching::Metadata);
>+    return frame && frame->m_isComplete;
>+}
> 
>-    ImageFrame* buffer = m_decoder->frameBufferAtIndex(index);
>-    return buffer && buffer->status() == ImageFrame::FrameComplete;
>+float ImageSource::frameDurationAtIndex(size_t index)
>+{
>+    const ImageFrameData* frame = frameAtIndex(index, 0, ImageFrameCaching::Metadata);
>+    return frame ? frame->m_duration : 0;
>+}
>+
>+bool ImageSource::frameHasAlphaAtIndex(size_t index)
>+{
>+    const ImageFrameData* frame = frameAtIndex(index, 0, ImageFrameCaching::Metadata);
>+    return !frame || frame->m_hasAlpha;
> }
> 
>-unsigned ImageSource::frameBytesAtIndex(size_t index, SubsamplingLevel) const
>+ImageOrientation ImageSource::frameOrientationAtIndex(size_t index)
> {
>-    if (!m_decoder)
>-        return 0;
>-    return m_decoder->frameBytesAtIndex(index);
>+    const ImageFrameData* frame = frameAtIndex(index, 0, ImageFrameCaching::Metadata);
>+    return frame ? frame->m_orientation : DefaultImageOrientation;
> }
> 
> }
> 
>-#endif // USE(CG)
>diff --git a/Source/WebCore/platform/graphics/ImageSource.h b/Source/WebCore/platform/graphics/ImageSource.h
>index acdd1ce4ce300de81c9e062eee7607bf472a70af..49ef51b139adddd4f1bd1b2ab7778890ed99b25b 100644
>--- a/Source/WebCore/platform/graphics/ImageSource.h
>+++ b/Source/WebCore/platform/graphics/ImageSource.h
>@@ -27,7 +27,9 @@
> #ifndef ImageSource_h
> #define ImageSource_h
> 
>+#include "ImageFrameData.h"
> #include "ImageOrientation.h"
>+#include "IntSize.h"
> #include "NativeImagePtr.h"
> 
> #include <wtf/Forward.h>
>@@ -41,23 +43,15 @@ typedef const struct __CFData* CFDataRef;
> 
> namespace WebCore {
> 
>+class Image;
> class ImageOrientation;
> class IntPoint;
> class IntSize;
> class SharedBuffer;
> 
>-#if USE(CG)
>-typedef CGImageSourceRef NativeImageDecoderPtr;
>-#else
> class ImageDecoder;
> typedef ImageDecoder* NativeImageDecoderPtr;
>-#endif
>-
>-#if USE(CG)
>-#define NativeImageDecoder ImageDecoder
>-#else
> typedef ImageDecoder NativeImageDecoder;
>-#endif
> 
> // Right now GIFs are the only recognized image format that supports animation.
> // The animation system and the constants below are designed with this in mind.
>@@ -77,9 +71,6 @@ const int cAnimationLoopOnce = 0;
> const int cAnimationLoopInfinite = -1;
> const int cAnimationNone = -2;
> 
>-// SubsamplingLevel. 0 is no subsampling, 1 is half dimensions on each axis etc.
>-typedef short SubsamplingLevel;
>-
> class ImageSource {
>     WTF_MAKE_NONCOPYABLE(ImageSource);
> public:
>@@ -93,7 +84,8 @@ public:
>         GammaAndColorProfileIgnored
>     };
> 
>-    ImageSource(AlphaOption alphaOption = AlphaPremultiplied, GammaAndColorProfileOption gammaAndColorProfileOption = GammaAndColorProfileApplied);
>+    ImageSource(Image*, AlphaOption = AlphaPremultiplied, GammaAndColorProfileOption = GammaAndColorProfileApplied);
>+    ImageSource(NativeImagePtr);
>     ~ImageSource();
> 
>     // Tells the ImageSource that the Image no longer cares about decoded frame
>@@ -117,60 +109,68 @@ public:
>     // 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 = NULL,
>-               bool allDataReceived = false);
>+    void clear(ImageFrameIndex = MaxImageFrameIndex, SharedBuffer* = nullptr, bool allDataReceived = false);
>+    void clearFrames(ImageFrameIndex = MaxImageFrameIndex, SharedBuffer* = nullptr, bool allDataReceived = false);
>+    void clearPartialFrames(ImageFrameIndex = MaxImageFrameIndex);
> 
>-    bool initialized() const;
>+    bool isDecoderInitialized() const { return m_decoder; }
> 
>     void setData(SharedBuffer* data, bool allDataReceived);
>-    String filenameExtension() const;
>-
>-    SubsamplingLevel subsamplingLevelForScale(float) const;
>-    bool allowSubsamplingOfFrameAtIndex(size_t) const;
>-
>-    bool isSizeAvailable();
>-    // Always original size, without subsampling.
>-    IntSize size(ImageOrientationDescription = ImageOrientationDescription()) const;
>-    // Size of optionally subsampled frame.
>-    IntSize frameSizeAtIndex(size_t, SubsamplingLevel = 0, ImageOrientationDescription = ImageOrientationDescription()) const;
>-
>-    bool getHotSpot(IntPoint&) const;
> 
>+    SubsamplingLevel subsamplingLevelForScale(float, SubsamplingLevel) const;
>     size_t bytesDecodedToDetermineProperties() const;
> 
>-    int repetitionCount();
>-
>+    bool isSizeAvailable() const;
>+    IntSize size() const;
>+    IntSize sizeRespectingOrientation() const;
>     size_t frameCount() const;
>+    int repetitionCount();
>+    String filenameExtension() const;
>+    bool getHotSpot(IntPoint&) const;
> 
>     // Callers should not call this after calling clear() with a higher index;
>     // see comments on clear() above.
>-    PassNativeImagePtr createFrameAtIndex(size_t, SubsamplingLevel = 0);
>+    PassNativeImagePtr createFrameImageAtIndex(ImageFrameIndex, SubsamplingLevel = 0);
>+    const ImageFrameData* frameAtIndex(ImageFrameIndex, SubsamplingLevel = 0, ImageFrameCaching = ImageFrameCaching::MetadataAndFrame);
> 
>-    float frameDurationAtIndex(size_t);
>-    bool frameHasAlphaAtIndex(size_t); // Whether or not the frame actually used any alpha.
>-    bool frameIsCompleteAtIndex(size_t); // Whether or not the frame is completely decoded.
>-    ImageOrientation orientationAtIndex(size_t) const; // EXIF image orientation
>+    bool frameIsCompleteAtIndex(ImageFrameIndex);
>+    float frameDurationAtIndex(ImageFrameIndex);
>+    bool frameHasAlphaAtIndex(ImageFrameIndex);
>+    ImageOrientation frameOrientationAtIndex(ImageFrameIndex);
> 
>-    // Return the number of bytes in the decoded frame. If the frame is not yet
>-    // decoded then return 0.
>-    unsigned frameBytesAtIndex(size_t, SubsamplingLevel = 0) const;
>+    bool allowSubsamplingOfFrameAtIndex(ImageFrameIndex) const;
>+    IntSize frameSizeAtIndex(ImageFrameIndex, SubsamplingLevel = 0, RespectImageOrientationEnum = DoNotRespectImageOrientation) const;
> 
>-#if ENABLE(IMAGE_DECODER_DOWN_SAMPLING)
>-    static unsigned maxPixelsPerDecodedImage() { return s_maxPixelsPerDecodedImage; }
>-    static void setMaxPixelsPerDecodedImage(unsigned maxPixels) { s_maxPixelsPerDecodedImage = maxPixels; }
>-#endif
>+    ImageFrameDataBuffer m_frames;
> 
> private:
>-    NativeImageDecoderPtr m_decoder;
>+    friend class ImageFrameDecoder;
>+
>+    void ensureDecoderIsCreated(SharedBuffer*);
>+
>+    enum class ClearedFrames { Partial, All };
>+    void decodedSizeIncremented(unsigned decodedSize) const;
>+    void decodedSizeDecremented(unsigned decodedSize, ClearedFrames = ClearedFrames::Partial) const;
>+    void decodedSizeChanged(int decodedSize) const;
>+    void didDecodeProperties() const;
>+
>+    void cacheFrameAtIndex(ImageFrameIndex, SubsamplingLevel, ImageFrameCaching);
>+    bool ensureFrameAtIndexIsCached(ImageFrameIndex, SubsamplingLevel, ImageFrameCaching);
>+    const ImageFrameData* cachedframeAtIndex(ImageFrameIndex, SubsamplingLevel, ImageFrameCaching);
>+
>+    Image* m_image { nullptr };
>+    NativeImageDecoderPtr m_decoder { nullptr };
>+    mutable IntSize m_size;
>+    mutable IntSize m_sizeRespectingOrientation;
>+    mutable size_t m_frameCount { 0 };
>+    mutable unsigned m_decodedPropertiesSize { 0 };
> 
> #if !USE(CG)
>-    AlphaOption m_alphaOption;
>-    GammaAndColorProfileOption m_gammaAndColorProfileOption;
>-#endif
>+    AlphaOption m_alphaOption { AlphaPremultiplied };
>+    GammaAndColorProfileOption m_gammaAndColorProfileOption { GammaAndColorProfileApplied };
> #if ENABLE(IMAGE_DECODER_DOWN_SAMPLING)
>-    static unsigned s_maxPixelsPerDecodedImage;
>+    static const unsigned s_maxPixelsPerDecodedImage = 1024 * 1024;
>+#endif
> #endif
> };
> 
>diff --git a/Source/WebCore/platform/graphics/NativeImagePtr.h b/Source/WebCore/platform/graphics/NativeImagePtr.h
>index df941a566a9e46927727ba1ec6848f216803a45b..eca1b92c41ee1828e310d5bedbb2b5aca595f543 100644
>--- a/Source/WebCore/platform/graphics/NativeImagePtr.h
>+++ b/Source/WebCore/platform/graphics/NativeImagePtr.h
>@@ -29,6 +29,7 @@
> #define NativeImagePtr_h
> 
> #if USE(CG)
>+#include <wtf/RetainPtr.h>
> typedef struct CGImage* CGImageRef;
> #elif USE(CAIRO)
> #include "RefPtrCairo.h"
>@@ -41,7 +42,7 @@ namespace WebCore {
> // FIXME: NativeImagePtr and PassNativeImagePtr should be smart
> // pointers (see SVGImage::nativeImageForCurrentFrame()).
> #if USE(CG)
>-typedef CGImageRef NativeImagePtr;
>+typedef RetainPtr<CGImageRef> NativeImagePtr;
> #elif USE(CAIRO)
> typedef RefPtr<cairo_surface_t> NativeImagePtr;
> typedef PassRefPtr<cairo_surface_t> PassNativeImagePtr;
>diff --git a/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp b/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp
>index 63dcf0a253e2340f67f1c81d85fc270dd230e86d..a4c65bdff32a92f9c1df26d4bf53080f05ab9614 100644
>--- a/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp
>+++ b/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp
>@@ -1037,7 +1037,7 @@ void GraphicsLayerCA::setContentsToSolidColor(const Color& color)
> void GraphicsLayerCA::setContentsToImage(Image* image)
> {
>     if (image) {
>-        CGImageRef newImage = image->nativeImageForCurrentFrame();
>+        CGImageRef newImage = image->nativeImageForCurrentFrame().get();
>         if (!newImage)
>             return;
> 
>diff --git a/Source/WebCore/platform/graphics/cairo/BitmapImageCairo.cpp b/Source/WebCore/platform/graphics/cairo/BitmapImageCairo.cpp
>index cd57ee485ea80c6cf347ab3bd9737d5999e10282..7eb4c9f89828e8a14b90c44a6fa7a83ae31e1adb 100644
>--- a/Source/WebCore/platform/graphics/cairo/BitmapImageCairo.cpp
>+++ b/Source/WebCore/platform/graphics/cairo/BitmapImageCairo.cpp
>@@ -31,6 +31,7 @@
> #if USE(CAIRO)
> 
> #include "CairoUtilities.h"
>+#include "ImageFrameData.h"
> #include "ImageObserver.h"
> #include "PlatformContextCairo.h"
> #include "Timer.h"
>@@ -40,27 +41,18 @@ namespace WebCore {
> 
> BitmapImage::BitmapImage(PassRefPtr<cairo_surface_t> nativeImage, ImageObserver* observer)
>     : Image(observer)
>+    , m_source(nativeImage)
>     , m_size(cairoSurfaceSize(nativeImage.get()))
>-    , m_minimumSubsamplingLevel(0)
>+    , m_maximumSubsamplingLevel(0)
>     , m_currentFrame(0)
>     , m_repetitionCount(cAnimationNone)
>     , m_repetitionCountStatus(Unknown)
>     , m_repetitionsComplete(0)
>-    , m_decodedSize(m_size.width() * m_size.height() * 4)
>     , m_frameCount(1)
>-    , m_isSolidColor(false)
>-    , m_checkedForSolidColor(false)
>     , m_animationFinished(true)
>     , m_allDataReceived(true)
>     , m_haveSize(true)
>-    , m_sizeAvailable(true)
>-    , m_haveFrameCount(true)
> {
>-    m_frames.grow(1);
>-    m_frames[0].m_hasAlpha = cairo_surface_get_content(nativeImage.get()) != CAIRO_CONTENT_COLOR;
>-    m_frames[0].m_frame = nativeImage;
>-    m_frames[0].m_haveMetadata = true;
>-
>     checkForSolidColor();
> }
> 
>@@ -122,15 +114,14 @@ void BitmapImage::draw(GraphicsContext& context, const FloatRect& dst, const Flo
>         imageObserver()->didDraw(this);
> }
> 
>-void BitmapImage::determineMinimumSubsamplingLevel() const
>+void BitmapImage::determineMaximumSubsamplingLevel() const
> {
>-    m_minimumSubsamplingLevel = 0;
>+    m_maximumSubsamplingLevel = 0;
> }
> 
> void BitmapImage::checkForSolidColor()
> {
>-    m_isSolidColor = false;
>-    m_checkedForSolidColor = true;
>+    m_solidColorValue = TriState::No;
> 
>     if (frameCount() > 1)
>         return;
>@@ -150,16 +141,26 @@ void BitmapImage::checkForSolidColor()
>     unsigned* pixelColor = reinterpret_cast_ptr<unsigned*>(cairo_image_surface_get_data(surface.get()));
>     m_solidColor = colorFromPremultipliedARGB(*pixelColor);
> 
>-    m_isSolidColor = true;
>+    m_solidColorValue = TriState::Yes;
>+}
>+
>+ImageFrameData::ImageFrameData(const NativeImagePtr& image)
>+    : m_image(image)
>+    , m_haveMetadata(true)
>+    , m_isComplete(true)
>+{
>+    ASSERT(m_image);
>+    m_size = cairoSurfaceSize(m_image.get());
>+    m_hasAlpha = cairo_surface_get_content(m_image.get()) != CAIRO_CONTENT_COLOR;
> }
> 
>-bool FrameData::clear(bool clearMetadata)
>+bool ImageFrameData::clear(ImageFrameCaching frameCaching)
> {
>-    if (clearMetadata)
>+    if (frameCaching == ImageFrameCaching::None)
>         m_haveMetadata = false;
> 
>-    if (m_frame) {
>-        m_frame = nullptr;
>+    if (m_image) {
>+        m_image = nullptr;
>         return true;
>     }
>     return false;
>diff --git a/Source/WebCore/platform/graphics/cairo/GraphicsContext3DCairo.cpp b/Source/WebCore/platform/graphics/cairo/GraphicsContext3DCairo.cpp
>index cc7046147ae81f1fadaa6d841624980c6fdfcbf1..bb13350c86cc64abc60413cdae2081eec10eef14 100644
>--- a/Source/WebCore/platform/graphics/cairo/GraphicsContext3DCairo.cpp
>+++ b/Source/WebCore/platform/graphics/cairo/GraphicsContext3DCairo.cpp
>@@ -205,7 +205,7 @@ bool GraphicsContext3D::ImageExtractor::extractImage(bool premultiplyAlpha, bool
>     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);
>+    m_decoder = new ImageSource(nullptr, premultiplyAlpha ? ImageSource::AlphaPremultiplied : ImageSource::AlphaNotPremultiplied, ignoreGammaAndColorProfile ? ImageSource::GammaAndColorProfileIgnored : ImageSource::GammaAndColorProfileApplied);
>     if (!m_decoder)
>         return false;
>     ImageSource& decoder = *m_decoder;
>@@ -215,7 +215,7 @@ bool GraphicsContext3D::ImageExtractor::extractImage(bool premultiplyAlpha, bool
>         decoder.setData(m_image->data(), true);
>         if (!decoder.frameCount() || !decoder.frameIsCompleteAtIndex(0))
>             return false;
>-        m_imageSurface = decoder.createFrameAtIndex(0);
>+        m_imageSurface = decoder.createFrameImageAtIndex(0);
>     } else {
>         m_imageSurface = m_image->nativeImageForCurrentFrame();
>         // 1. For texImage2D with HTMLVideoElment input, assume no PremultiplyAlpha had been applied and the alpha value is 0xFF for each pixel,
>diff --git a/Source/WebCore/platform/graphics/cg/BitmapImageCG.cpp b/Source/WebCore/platform/graphics/cg/BitmapImageCG.cpp
>index 01b7d692cdbd7ab4d22bbc1399c10328f57e5e47..0733238327778767a213c9d1bf1d6abf25ebf35e 100644
>--- a/Source/WebCore/platform/graphics/cg/BitmapImageCG.cpp
>+++ b/Source/WebCore/platform/graphics/cg/BitmapImageCG.cpp
>@@ -50,63 +50,85 @@
> 
> namespace WebCore {
> 
>-bool FrameData::clear(bool clearMetadata)
>+ImageFrameData::ImageFrameData(const NativeImagePtr& image)
>+    : m_image(image)
>+    , m_haveMetadata(true)
>+    , m_isComplete(true)
>+    , m_hasAlpha(true)
> {
>-    if (clearMetadata)
>+    ASSERT(m_image);
>+    CGFloat width = CGImageGetWidth(m_image.get());
>+    CGFloat height = CGImageGetHeight(m_image.get());
>+    m_frameBytes = width * height * 4;
>+    m_size = IntSize(width, height);
>+}
>+
>+bool ImageFrameData::clear(ImageFrameCaching frameCaching)
>+{
>+    if (frameCaching == ImageFrameCaching::None)
>         m_haveMetadata = false;
> 
>     m_orientation = DefaultImageOrientation;
>     m_subsamplingLevel = 0;
> 
>-    if (m_frame) {
>+    if (m_image) {
> #if CACHE_SUBIMAGES
>-        subimageCache().clearImage(m_frame);
>+        subimageCache().clearImage(m_image.get());
> #endif
>-        CGImageRelease(m_frame);
>-        m_frame = 0;
>+        m_image = nullptr;
>         return true;
>     }
>     return false;
> }
> 
>-BitmapImage::BitmapImage(CGImageRef cgImage, ImageObserver* observer)
>+Optional<Color> ImageFrameData::solidColor() const
>+{
>+    if (!m_image)
>+        return Nullopt;
>+
>+    // Currently we only check for solid color in the important special case of a 1x1 image.
>+    if (CGImageGetWidth(m_image.get()) != 1 || CGImageGetHeight(m_image.get()) != 1)
>+        return Nullopt;
>+
>+    unsigned char pixel[4]; // RGBA
>+    RetainPtr<CGContextRef> bitmapContext = adoptCF(CGBitmapContextCreate(pixel, 1, 1, 8, sizeof(pixel), sRGBColorSpaceRef(), kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big));
>+    if (!bitmapContext)
>+        return Nullopt;
>+
>+    GraphicsContext(bitmapContext.get()).setCompositeOperation(CompositeCopy);
>+    CGRect destinationRect = CGRectMake(0, 0, 1, 1);
>+    CGContextDrawImage(bitmapContext.get(), destinationRect, m_image.get());
>+    if (!pixel[3])
>+        return Color(0, 0, 0, 0);
>+
>+    return Color(pixel[0] * 255 / pixel[3], pixel[1] * 255 / pixel[3], pixel[2] * 255 / pixel[3], pixel[3]);
>+}
>+
>+BitmapImage::BitmapImage(NativeImagePtr image, ImageObserver* observer)
>     : Image(observer)
>-    , m_minimumSubsamplingLevel(0)
>+    , m_source(image)
>+    , m_maximumSubsamplingLevel(0)
>     , m_imageOrientation(OriginTopLeft)
>-    , m_shouldRespectImageOrientation(false)
>     , m_currentFrame(0)
>     , m_repetitionCount(cAnimationNone)
>     , m_repetitionCountStatus(Unknown)
>     , m_repetitionsComplete(0)
>-    , m_decodedSize(0)
>-    , m_decodedPropertiesSize(0)
>     , m_frameCount(1)
>-    , m_isSolidColor(false)
>-    , m_checkedForSolidColor(false)
>     , m_animationFinished(true)
>     , m_allDataReceived(true)
>     , m_haveSize(true)
>-    , m_sizeAvailable(true)
>-    , m_haveFrameCount(true)
> {
>-    CGFloat width = CGImageGetWidth(cgImage);
>-    CGFloat height = CGImageGetHeight(cgImage);
>-    m_decodedSize = width * height * 4;
>+    CGFloat width = CGImageGetWidth(image.get());
>+    CGFloat height = CGImageGetHeight(image.get());
>     m_size = IntSize(width, height);
> 
>     // 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_sizeRespectingOrientation = m_size;
> 
>-    m_frames.grow(1);
>-    m_frames[0].m_frame = CGImageRetain(cgImage);
>-    m_frames[0].m_hasAlpha = true;
>-    m_frames[0].m_haveMetadata = true;
>-
>-    checkForSolidColor();
> }
> 
>-void BitmapImage::determineMinimumSubsamplingLevel() const
>+void BitmapImage::determineMaximumSubsamplingLevel() const
> {
>     if (!m_allowSubsampling)
>         return;
>@@ -125,13 +147,12 @@ void BitmapImage::determineMinimumSubsamplingLevel() const
>             break;
>     }
> 
>-    m_minimumSubsamplingLevel = currentLevel;
>+    m_maximumSubsamplingLevel = currentLevel;
> }
> 
> void BitmapImage::checkForSolidColor()
> {
>-    m_checkedForSolidColor = true;
>-    m_isSolidColor = false;
>+    m_solidColorValue = TriState::No;
> 
>     if (frameCount() > 1)
>         return;
>@@ -140,49 +161,30 @@ void BitmapImage::checkForSolidColor()
>         IntSize size = m_source.frameSizeAtIndex(0, 0);
>         if (size.width() != 1 || size.height() != 1)
>             return;
>-
>-        if (!ensureFrameIsCached(0))
>-            return;
>+        m_source.frameAtIndex(0);
>     }
> 
>-    CGImageRef image = nullptr;
>-    if (m_frames.size())
>-        image = m_frames[0].m_frame;
>-
>-    if (!image)
>+    if (!m_source.m_frames.size())
>         return;
> 
>-    // Currently we only check for solid color in the important special case of a 1x1 image.
>-    if (CGImageGetWidth(image) == 1 && CGImageGetHeight(image) == 1) {
>-        unsigned char pixel[4]; // RGBA
>-        RetainPtr<CGContextRef> bitmapContext = adoptCF(CGBitmapContextCreate(pixel, 1, 1, 8, sizeof(pixel), sRGBColorSpaceRef(),
>-            kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big));
>-        if (!bitmapContext)
>-            return;
>-        GraphicsContext(bitmapContext.get()).setCompositeOperation(CompositeCopy);
>-        CGRect destinationRect = CGRectMake(0, 0, 1, 1);
>-        CGContextDrawImage(bitmapContext.get(), destinationRect, image);
>-        if (!pixel[3])
>-            m_solidColor = Color(0, 0, 0, 0);
>-        else
>-            m_solidColor = Color(pixel[0] * 255 / pixel[3], pixel[1] * 255 / pixel[3], pixel[2] * 255 / pixel[3], pixel[3]);
>-
>-        m_isSolidColor = true;
>+    if (Optional<Color> color = m_source.m_frames[0].solidColor()) {
>+        m_solidColor = color.value();
>+        m_solidColorValue = TriState::Yes;
>     }
> }
> 
> CGImageRef BitmapImage::getCGImageRef()
> {
>-    return frameAtIndex(0);
>+    return frameAtIndex(0).get();
> }
> 
> CGImageRef BitmapImage::getFirstCGImageRefOfSize(const IntSize& size)
> {
>     size_t count = frameCount();
>     for (size_t i = 0; i < count; ++i) {
>-        CGImageRef cgImage = frameAtIndex(i);
>-        if (cgImage && IntSize(CGImageGetWidth(cgImage), CGImageGetHeight(cgImage)) == size)
>-            return cgImage;
>+        PassNativeImagePtr image = frameAtIndex(i);
>+        if (image && IntSize(CGImageGetWidth(image.get()), CGImageGetHeight(image.get())) == size)
>+            return image.get();
>     }
> 
>     // Fallback to the default CGImageRef if we can't find the right size
>@@ -197,8 +199,8 @@ RetainPtr<CFArrayRef> BitmapImage::getCGImageArray()
>     
>     CFMutableArrayRef array = CFArrayCreateMutable(NULL, count, &kCFTypeArrayCallBacks);
>     for (size_t i = 0; i < count; ++i) {
>-        if (CGImageRef currFrame = frameAtIndex(i))
>-            CFArrayAppendValue(array, currFrame);
>+        if (PassNativeImagePtr currFrame = frameAtIndex(i))
>+            CFArrayAppendValue(array, currFrame.get());
>     }
>     return adoptCF(array);
> }
>@@ -214,7 +216,7 @@ void BitmapImage::draw(GraphicsContext& ctxt, const FloatRect& destRect, const F
>     RetainPtr<CGImageRef> image;
>     // Never use subsampled images for drawing into PDF contexts.
>     if (wkCGContextIsPDFContext(ctxt.platformContext()))
>-        image = adoptCF(copyUnscaledFrameAtIndex(m_currentFrame));
>+        image = copyUnscaledFrameAtIndex(m_currentFrame);
>     else {
>         CGRect transformedDestinationRect = CGRectApplyAffineTransform(destRect, CGContextGetCTM(ctxt.platformContext()));
>         float subsamplingScale = std::min<float>(1, std::max(transformedDestinationRect.size.width / srcRect.width(), transformedDestinationRect.size.height / srcRect.height()));
>@@ -256,13 +258,10 @@ PassNativeImagePtr BitmapImage::copyUnscaledFrameAtIndex(size_t index)
>     if (index >= frameCount())
>         return nullptr;
> 
>-    if (index >= m_frames.size() || !m_frames[index].m_frame)
>-        cacheFrame(index, 0);
>-
>-    if (!m_frames[index].m_subsamplingLevel)
>-        return CGImageRetain(m_frames[index].m_frame);
>+    if (!m_source.m_frames[index].m_subsamplingLevel)
>+        return m_source.frameAtIndex(index)->m_image;
> 
>-    return m_source.createFrameAtIndex(index);
>+    return m_source.createFrameImageAtIndex(index);
> }
> 
> }
>diff --git a/Source/WebCore/platform/graphics/cg/GraphicsContext3DCG.cpp b/Source/WebCore/platform/graphics/cg/GraphicsContext3DCG.cpp
>index 6c03a2cef84606561ea07eb928f1cf295f9f5e36..d4d03482d506f5cb5b2ff2fe319cbc82f84025f1 100644
>--- a/Source/WebCore/platform/graphics/cg/GraphicsContext3DCG.cpp
>+++ b/Source/WebCore/platform/graphics/cg/GraphicsContext3DCG.cpp
>@@ -327,16 +327,16 @@ bool GraphicsContext3D::ImageExtractor::extractImage(bool premultiplyAlpha, bool
>         return false;
>     bool hasAlpha = !m_image->currentFrameKnownToBeOpaque();
>     if ((ignoreGammaAndColorProfile || (hasAlpha && !premultiplyAlpha)) && m_image->data()) {
>-        ImageSource decoder(ImageSource::AlphaNotPremultiplied,
>+        ImageSource decoder(nullptr, ImageSource::AlphaNotPremultiplied,
>                             ignoreGammaAndColorProfile ? ImageSource::GammaAndColorProfileIgnored : ImageSource::GammaAndColorProfileApplied);
>         decoder.setData(m_image->data(), true);
>         if (!decoder.frameCount())
>             return false;
> 
>-        m_decodedImage = adoptCF(decoder.createFrameAtIndex(0));
>+        m_decodedImage = decoder.createFrameImageAtIndex(0);
>         m_cgImage = m_decodedImage.get();
>     } else
>-        m_cgImage = m_image->nativeImageForCurrentFrame();
>+        m_cgImage = m_image->nativeImageForCurrentFrame().get();
>     if (!m_cgImage)
>         return false;
> 
>@@ -536,7 +536,7 @@ void GraphicsContext3D::paintToCanvas(const unsigned char* imagePixels, int imag
>     context.scale(FloatSize(1, -1));
>     context.translate(0, -imageHeight);
>     context.setImageInterpolationQuality(InterpolationNone);
>-    context.drawNativeImage(cgImage.get(), imageSize, canvasRect, FloatRect(FloatPoint(), imageSize), CompositeCopy);
>+    context.drawNativeImage(cgImage, imageSize, canvasRect, FloatRect(FloatPoint(), imageSize), CompositeCopy);
> }
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/platform/graphics/cg/GraphicsContextCG.cpp b/Source/WebCore/platform/graphics/cg/GraphicsContextCG.cpp
>index a449654046ae8f10abad16415e6460adbbbb8e88..16209af534481db4cddd8b423ce7bf2a40b0dbef 100644
>--- a/Source/WebCore/platform/graphics/cg/GraphicsContextCG.cpp
>+++ b/Source/WebCore/platform/graphics/cg/GraphicsContextCG.cpp
>@@ -311,8 +311,8 @@ void GraphicsContext::drawPattern(Image& image, const FloatRect& tileRect, const
>     float adjustedX = phase.x() - destRect.x() + tileRect.x() * narrowPrecisionToFloat(patternTransform.a()); // We translated the context so that destRect.x() is the origin, so subtract it out.
>     float adjustedY = destRect.height() - (phase.y() - destRect.y() + tileRect.y() * narrowPrecisionToFloat(patternTransform.d()) + scaledTileHeight);
> 
>-    CGImageRef tileImage = image.nativeImageForCurrentFrame();
>-    float h = CGImageGetHeight(tileImage);
>+    RetainPtr<CGImageRef> tileImage = image.nativeImageForCurrentFrame();
>+    float h = CGImageGetHeight(tileImage.get());
> 
>     RetainPtr<CGImageRef> subImage;
> #if PLATFORM(IOS)
>@@ -326,13 +326,13 @@ void GraphicsContext::drawPattern(Image& image, const FloatRect& tileRect, const
>         // Copying a sub-image out of a partially-decoded image stops the decoding of the original image. It should never happen
>         // because sub-images are only used for border-image, which only renders when the image is fully decoded.
>         ASSERT(h == image.height());
>-        subImage = adoptCF(CGImageCreateWithImageInRect(tileImage, tileRect));
>+        subImage = adoptCF(CGImageCreateWithImageInRect(tileImage.get(), tileRect));
>     }
> 
>     // If we need to paint gaps between tiles because we have a partially loaded image or non-zero spacing,
>     // fall back to the less efficient CGPattern-based mechanism.
>     float scaledTileWidth = tileRect.width() * narrowPrecisionToFloat(patternTransform.a());
>-    float w = CGImageGetWidth(tileImage);
>+    float w = CGImageGetWidth(tileImage.get());
>     if (w == image.size().width() && h == image.size().height() && !spacing.width() && !spacing.height()) {
>         // FIXME: CG seems to snap the images to integral sizes. When we care (e.g. with border-image-repeat: round),
>         // we should tile all but the last, and stetch the last image to fit.
>diff --git a/Source/WebCore/platform/graphics/cg/ImageDecoder.cpp b/Source/WebCore/platform/graphics/cg/ImageDecoder.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..0adb84a88a2db3867f5beedf2943fe5c19a7f655
>--- /dev/null
>+++ b/Source/WebCore/platform/graphics/cg/ImageDecoder.cpp
>@@ -0,0 +1,372 @@
>+/*
>+ * 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 "ImageDecoder.h"
>+
>+#if USE(CG)
>+
>+#include "CoreGraphicsSPI.h"
>+#include "ImageOrientation.h"
>+#include "IntPoint.h"
>+#include "IntSize.h"
>+#include "MIMETypeRegistry.h"
>+#include "SharedBuffer.h"
>+#include <wtf/NeverDestroyed.h>
>+
>+#if !PLATFORM(IOS)
>+#include <ApplicationServices/ApplicationServices.h>
>+#else
>+#include <ImageIO/ImageIO.h>
>+#include <wtf/RetainPtr.h>
>+#endif
>+
>+#if USE(APPLE_INTERNAL_SDK)
>+#import <ImageIO/CGImageSourcePrivate.h>
>+#else
>+const CFStringRef kCGImageSourceSubsampleFactor = CFSTR("kCGImageSourceSubsampleFactor");
>+#endif
>+
>+namespace WebCore {
>+
>+const CFStringRef WebCoreCGImagePropertyAPNGUnclampedDelayTime = CFSTR("UnclampedDelayTime");
>+const CFStringRef WebCoreCGImagePropertyAPNGDelayTime = CFSTR("DelayTime");
>+const CFStringRef WebCoreCGImagePropertyAPNGLoopCount = CFSTR("LoopCount");
>+
>+const CFStringRef kCGImageSourceShouldPreferRGB32 = CFSTR("kCGImageSourceShouldPreferRGB32");
>+const CFStringRef kCGImageSourceSkipMetadata = CFSTR("kCGImageSourceSkipMetadata");
>+
>+static RetainPtr<CFDictionaryRef> createImageSourceOptions(SubsamplingLevel subsamplingLevel, DecodeMode decodeMode)
>+{
>+    const CFIndex basicOptions = 3;
>+    const void* keys[basicOptions + 2] = { kCGImageSourceShouldCache, kCGImageSourceShouldPreferRGB32, kCGImageSourceSkipMetadata };
>+    const void* values[basicOptions + 2] = { kCFBooleanTrue, kCFBooleanTrue, kCFBooleanTrue };
>+    CFIndex numOptions = basicOptions;
>+
>+    if (subsamplingLevel > 0) {
>+        short constrainedSubsamplingLevel = std::min<short>(3, std::max<short>(0, subsamplingLevel));
>+        int subsampleInt = 1 << constrainedSubsamplingLevel; // [0..3] => [1, 2, 4, 8]
>+        RetainPtr<CFNumberRef> subsampleNumber = adoptCF(CFNumberCreate(nullptr,  kCFNumberIntType,  &subsampleInt));
>+
>+        keys[numOptions] = kCGImageSourceSubsampleFactor;
>+        values[numOptions++] = kCGImageSourceSubsampleFactor;
>+    }
>+
>+    if (decodeMode == DecodeMode::Immediate) {
>+        keys[numOptions] = kCGImageSourceShouldCacheImmediately;
>+        values[numOptions++] = kCFBooleanTrue;
>+    }
>+
>+    return adoptCF(CFDictionaryCreate(nullptr, keys, values, numOptions, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks));
>+}
>+
>+static RetainPtr<CFDictionaryRef> imageSourceOptions(SubsamplingLevel subsamplingLevel = 0, DecodeMode decodeMode = DecodeMode::Lazy)
>+{
>+    if (subsamplingLevel || decodeMode == DecodeMode::Immediate)
>+        return createImageSourceOptions(subsamplingLevel, decodeMode);
>+
>+    static NeverDestroyed<RetainPtr<CFDictionaryRef>> options = createImageSourceOptions(0, DecodeMode::Lazy);
>+    return options;
>+}
>+
>+static ImageOrientation orientationFromProperties(CFDictionaryRef imageProperties)
>+{
>+    ASSERT(imageProperties);
>+    CFNumberRef orientationProperty = (CFNumberRef)CFDictionaryGetValue(imageProperties, kCGImagePropertyOrientation);
>+    if (!orientationProperty)
>+        return DefaultImageOrientation;
>+
>+    int exifValue;
>+    CFNumberGetValue(orientationProperty, kCFNumberIntType, &exifValue);
>+    return ImageOrientation::fromEXIFValue(exifValue);
>+}
>+
>+ImageDecoder::ImageDecoder()
>+{
>+    m_nativeDecoder = CGImageSourceCreateIncremental(0);
>+}
>+
>+SubsamplingLevel ImageDecoder::subsamplingLevelForScale(float scale, SubsamplingLevel maximumSubsamplingLevel)
>+{
>+    // There are four subsampling levels: 0 = 1x, 1 = 0.5x, 2 = 0.25x, 3 = 0.125x.
>+    float clampedScale = std::max<float>(0.125, std::min<float>(1, scale));
>+    SubsamplingLevel result = ceilf(log2f(1 / clampedScale));
>+    ASSERT(result >=0 && result <= 3);
>+    return std::min(result, maximumSubsamplingLevel);
>+}
>+
>+size_t ImageDecoder::bytesDecodedToDetermineProperties()
>+{
>+    // Measured by tracing malloc/calloc calls on Mac OS 10.6.6, x86_64.
>+    // A non-zero value ensures cached images with no decoded frames still enter
>+    // the live decoded resources list when the CGImageSource decodes image
>+    // properties, allowing the cache to prune the partially decoded image.
>+    // This value is likely to be inaccurate on other platforms, but the overall
>+    // behavior is unchanged.
>+    return 13088;
>+}
>+
>+String ImageDecoder::filenameExtension() const
>+{
>+    CFStringRef imageSourceType = CGImageSourceGetType(m_nativeDecoder);
>+    return WebCore::preferredExtensionForImageSourceType(imageSourceType);
>+}
>+
>+bool ImageDecoder::isSizeAvailable() const
>+{
>+    // Ragnaros yells: TOO SOON! You have awakened me TOO SOON, Executus!
>+    if (CGImageSourceGetStatus(m_nativeDecoder) < kCGImageStatusIncomplete)
>+        return false;
>+
>+    RetainPtr<CFDictionaryRef> image0Properties = adoptCF(CGImageSourceCopyPropertiesAtIndex(m_nativeDecoder, 0, imageSourceOptions().get()));
>+    if (!image0Properties)
>+        return false;
>+
>+    return CFDictionaryContainsKey(image0Properties.get(), kCGImagePropertyPixelWidth)
>+        && CFDictionaryContainsKey(image0Properties.get(), kCGImagePropertyPixelHeight);
>+}
>+
>+IntSize ImageDecoder::size() const
>+{
>+    if (m_size.isEmpty())
>+        m_size = frameSizeAtIndex(0, 0);
>+    return m_size;
>+}
>+
>+size_t ImageDecoder::frameCount() const
>+{
>+    return CGImageSourceGetCount(m_nativeDecoder);
>+}
>+
>+int ImageDecoder::repetitionCount() const
>+{
>+    RetainPtr<CFDictionaryRef> properties = adoptCF(CGImageSourceCopyProperties(m_nativeDecoder, imageSourceOptions().get()));
>+    if (!properties)
>+        return cAnimationLoopOnce;
>+
>+    CFDictionaryRef gifProperties = (CFDictionaryRef)CFDictionaryGetValue(properties.get(), kCGImagePropertyGIFDictionary);
>+    if (gifProperties) {
>+        CFNumberRef num = (CFNumberRef)CFDictionaryGetValue(gifProperties, kCGImagePropertyGIFLoopCount);
>+
>+        // No property means loop once.
>+        if (!num)
>+            return cAnimationLoopOnce;
>+
>+        int loopCount;
>+        CFNumberGetValue(num, kCFNumberIntType, &loopCount);
>+
>+        // A property with value 0 means loop forever.
>+        return loopCount ? loopCount : cAnimationLoopInfinite;
>+    }
>+
>+    CFDictionaryRef pngProperties = (CFDictionaryRef)CFDictionaryGetValue(properties.get(), kCGImagePropertyPNGDictionary);
>+    if (pngProperties) {
>+        CFNumberRef num = (CFNumberRef)CFDictionaryGetValue(pngProperties, WebCoreCGImagePropertyAPNGLoopCount);
>+        if (!num)
>+            return cAnimationLoopOnce;
>+
>+        int loopCount;
>+        CFNumberGetValue(num, kCFNumberIntType, &loopCount);
>+        return loopCount ? loopCount : cAnimationLoopInfinite;
>+    }
>+    
>+    // Turns out we're not an animated image after all, so we don't animate.
>+    return cAnimationNone;
>+}
>+
>+bool ImageDecoder::getHotSpot(IntPoint& hotSpot) const
>+{
>+    RetainPtr<CFDictionaryRef> properties = adoptCF(CGImageSourceCopyPropertiesAtIndex(m_nativeDecoder, 0, imageSourceOptions().get()));
>+    if (!properties)
>+        return false;
>+
>+    int x = -1, y = -1;
>+    CFNumberRef num = (CFNumberRef)CFDictionaryGetValue(properties.get(), CFSTR("hotspotX"));
>+    if (!num || !CFNumberGetValue(num, kCFNumberIntType, &x))
>+        return false;
>+
>+    num = (CFNumberRef)CFDictionaryGetValue(properties.get(), CFSTR("hotspotY"));
>+    if (!num || !CFNumberGetValue(num, kCFNumberIntType, &y))
>+        return false;
>+
>+    if (x < 0 || y < 0)
>+        return false;
>+    
>+    hotSpot = IntPoint(x, y);
>+    return true;
>+}
>+
>+IntSize ImageDecoder::frameSizeAtIndex(ImageFrameIndex index, SubsamplingLevel subsamplingLevel) const
>+{
>+    RetainPtr<CFDictionaryRef> properties = adoptCF(CGImageSourceCopyPropertiesAtIndex(m_nativeDecoder, index, imageSourceOptions(subsamplingLevel).get()));
>+
>+    if (!properties)
>+        return { };
>+
>+    int width = 0;
>+    int height = 0;
>+    CFNumberRef num = (CFNumberRef)CFDictionaryGetValue(properties.get(), kCGImagePropertyPixelWidth);
>+    if (num)
>+        CFNumberGetValue(num, kCFNumberIntType, &width);
>+
>+    num = (CFNumberRef)CFDictionaryGetValue(properties.get(), kCGImagePropertyPixelHeight);
>+    if (num)
>+        CFNumberGetValue(num, kCFNumberIntType, &height);
>+
>+    return IntSize(width, height);
>+}
>+
>+bool ImageDecoder::frameIsCompleteAtIndex(ImageFrameIndex index) const
>+{
>+    ASSERT(frameCount());
>+    return CGImageSourceGetStatusAtIndex(m_nativeDecoder, index) == kCGImageStatusComplete;
>+}
>+
>+ImageOrientation ImageDecoder::orientationAtIndex(ImageFrameIndex index) const
>+{
>+    RetainPtr<CFDictionaryRef> properties = adoptCF(CGImageSourceCopyPropertiesAtIndex(m_nativeDecoder, index, imageSourceOptions().get()));
>+    if (!properties)
>+        return DefaultImageOrientation;
>+    
>+    return orientationFromProperties(properties.get());
>+}
>+
>+float ImageDecoder::frameDurationAtIndex(ImageFrameIndex index) const
>+{
>+    float duration = 0;
>+    RetainPtr<CFDictionaryRef> properties = adoptCF(CGImageSourceCopyPropertiesAtIndex(m_nativeDecoder, index, imageSourceOptions().get()));
>+    if (properties) {
>+        CFDictionaryRef gifProperties = (CFDictionaryRef)CFDictionaryGetValue(properties.get(), kCGImagePropertyGIFDictionary);
>+        if (gifProperties) {
>+            if (CFNumberRef num = (CFNumberRef)CFDictionaryGetValue(gifProperties, kCGImagePropertyGIFUnclampedDelayTime)) {
>+                // Use the unclamped frame delay if it exists.
>+                CFNumberGetValue(num, kCFNumberFloatType, &duration);
>+            } else if (CFNumberRef num = (CFNumberRef)CFDictionaryGetValue(gifProperties, kCGImagePropertyGIFDelayTime)) {
>+                // Fall back to the clamped frame delay if the unclamped frame delay does not exist.
>+                CFNumberGetValue(num, kCFNumberFloatType, &duration);
>+            }
>+        }
>+
>+        CFDictionaryRef pngProperties = (CFDictionaryRef)CFDictionaryGetValue(properties.get(), kCGImagePropertyPNGDictionary);
>+        if (pngProperties) {
>+            if (CFNumberRef num = (CFNumberRef)CFDictionaryGetValue(pngProperties, WebCoreCGImagePropertyAPNGUnclampedDelayTime))
>+                CFNumberGetValue(num, kCFNumberFloatType, &duration);
>+            else if (CFNumberRef num = (CFNumberRef)CFDictionaryGetValue(pngProperties, WebCoreCGImagePropertyAPNGDelayTime))
>+                CFNumberGetValue(num, kCFNumberFloatType, &duration);
>+        }
>+    }
>+
>+    // Many annoying ads specify a 0 duration to make an image flash as quickly as possible.
>+    // We follow Firefox's behavior and use a duration of 100 ms for any frames that specify
>+    // a duration of <= 10 ms. See <rdar://problem/7689300> and <http://webkit.org/b/36082>
>+    // for more information.
>+    if (duration < 0.011f)
>+        return 0.1f;
>+    return duration;
>+}
>+
>+bool ImageDecoder::allowSubsamplingOfFrameAtIndex(ImageFrameIndex) const
>+{
>+    RetainPtr<CFDictionaryRef> properties = adoptCF(CGImageSourceCopyPropertiesAtIndex(m_nativeDecoder, 0, imageSourceOptions().get()));
>+    if (!properties)
>+        return false;
>+
>+    CFDictionaryRef jfifProperties = static_cast<CFDictionaryRef>(CFDictionaryGetValue(properties.get(), kCGImagePropertyJFIFDictionary));
>+    if (jfifProperties) {
>+        CFBooleanRef isProgCFBool = static_cast<CFBooleanRef>(CFDictionaryGetValue(jfifProperties, kCGImagePropertyJFIFIsProgressive));
>+        if (isProgCFBool) {
>+            bool isProgressive = CFBooleanGetValue(isProgCFBool);
>+            // Workaround for <rdar://problem/5184655> - Hang rendering very large progressive JPEG. Decoding progressive
>+            // images hangs for a very long time right now. Until this is fixed, don't sub-sample progressive images. This
>+            // will cause them to fail our large image check and they won't be decoded.
>+            // FIXME: Remove once underlying issue is fixed (<rdar://problem/5191418>)
>+            return !isProgressive;
>+        }
>+    }
>+
>+    return true;
>+}
>+
>+bool ImageDecoder::frameHasAlphaAtIndex(ImageFrameIndex index) const
>+{
>+    if (!frameIsCompleteAtIndex(index))
>+        return true;
>+
>+    CFStringRef imageType = CGImageSourceGetType(m_nativeDecoder);
>+
>+    // Return false if there is no image type or the image type is JPEG, because
>+    // JPEG does not support alpha transparency.
>+    if (!imageType || CFEqual(imageType, CFSTR("public.jpeg")))
>+        return false;
>+
>+    // FIXME: Could return false for other non-transparent image formats.
>+    // FIXME: Could maybe return false for a GIF Frame if we have enough info in the GIF properties dictionary
>+    // to determine whether or not a transparent color was defined.
>+    return true;
>+}
>+
>+unsigned ImageDecoder::frameBytesAtIndex(ImageFrameIndex index, SubsamplingLevel subsamplingLevel) const
>+{
>+    IntSize frameSize = frameSizeAtIndex(index, subsamplingLevel);
>+    return frameSize.width() * frameSize.height() * 4;
>+}
>+
>+PassNativeImagePtr ImageDecoder::createFrameImageAtIndex(ImageFrameIndex index, SubsamplingLevel subsamplingLevel, DecodeMode decodeMode) const
>+{
>+    RetainPtr<CGImageRef> image = adoptCF(CGImageSourceCreateImageAtIndex(m_nativeDecoder, index, imageSourceOptions(subsamplingLevel, decodeMode).get()));
>+
>+#if PLATFORM(IOS)
>+    // <rdar://problem/7371198> - CoreGraphics changed the default caching behaviour in iOS 4.0 to kCGImageCachingTransient
>+    // which caused a performance regression for us since the images had to be resampled/recreated every time we called
>+    // CGContextDrawImage. We now tell CG to cache the drawn images. See also <rdar://problem/14366755> -
>+    // CoreGraphics needs to un-deprecate kCGImageCachingTemporary since it's still not the default.
>+#if COMPILER(CLANG)
>+#pragma clang diagnostic push
>+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
>+#endif
>+    CGImageSetCachingFlags(image.get(), kCGImageCachingTemporary);
>+#if COMPILER(CLANG)
>+#pragma clang diagnostic pop
>+#endif
>+#endif // PLATFORM(IOS)
>+
>+    CFStringRef imageUTI = CGImageSourceGetType(m_nativeDecoder);
>+    static const CFStringRef xbmUTI = CFSTR("public.xbitmap-image");
>+
>+    if (!imageUTI)
>+        return image;
>+
>+    if (!CFEqual(imageUTI, xbmUTI))
>+        return image;
>+
>+    // If it is an xbm image, mask out all the white areas to render them transparent.
>+    const CGFloat maskingColors[6] = {255, 255,  255, 255, 255, 255};
>+    RetainPtr<CGImageRef> maskedImage = adoptCF(CGImageCreateWithMaskingColors(image.get(), maskingColors));
>+    return maskedImage ? maskedImage : image;
>+}
>+
>+}
>+
>+#endif // USE(CG)
>diff --git a/Source/WebCore/platform/graphics/cg/ImageDecoder.h b/Source/WebCore/platform/graphics/cg/ImageDecoder.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..5ff0ab9dee94d364b2f660e93689353b1165a284
>--- /dev/null
>+++ b/Source/WebCore/platform/graphics/cg/ImageDecoder.h
>@@ -0,0 +1,76 @@
>+/*
>+ * 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.
>+ */
>+
>+#ifndef ImageDecoder_h
>+#define ImageDecoder_h
>+
>+#include "ImageSource.h"
>+
>+namespace WebCore {
>+
>+String preferredExtensionForImageSourceType(const String& type);
>+
>+enum class DecodeMode { Immediate, Lazy };
>+
>+class SharedBuffer;
>+
>+class ImageDecoder {
>+public:
>+    ImageDecoder();
>+    virtual ~ImageDecoder() { }
>+
>+    static size_t bytesDecodedToDetermineProperties();
>+    static SubsamplingLevel subsamplingLevelForScale(float scale, SubsamplingLevel maximumSubsamplingLevel);
>+
>+    String filenameExtension() const;
>+    bool isSizeAvailable() const;
>+    IntSize size() const;
>+    size_t frameCount() const;
>+    int repetitionCount() const;
>+    bool getHotSpot(IntPoint& hotSpot) const;
>+
>+    IntSize frameSizeAtIndex(ImageFrameIndex, SubsamplingLevel) const;
>+    bool frameIsCompleteAtIndex(ImageFrameIndex) const;
>+    ImageOrientation orientationAtIndex(ImageFrameIndex) const;
>+
>+    float frameDurationAtIndex(ImageFrameIndex) const;
>+    bool frameHasAlphaAtIndex(ImageFrameIndex) const;
>+    bool allowSubsamplingOfFrameAtIndex(ImageFrameIndex) const;
>+    unsigned frameBytesAtIndex(ImageFrameIndex, SubsamplingLevel = 0) const;
>+
>+    PassNativeImagePtr createFrameImageAtIndex(ImageFrameIndex, SubsamplingLevel, DecodeMode = DecodeMode::Lazy) const;
>+
>+    virtual bool isDecoding() { return false; }
>+    virtual void setData(SharedBuffer*, bool allDataReceived) = 0;
>+    virtual const ImageFrameData* frameAtIndex(ImageFrameIndex, SubsamplingLevel, ImageFrameCaching) = 0;
>+
>+protected:
>+    mutable IntSize m_size;
>+    CGImageSourceRef m_nativeDecoder;
>+};
>+    
>+}
>+
>+#endif // ImageDecoder_h
>diff --git a/Source/WebCore/platform/graphics/cg/ImageFrameDecoder.cpp b/Source/WebCore/platform/graphics/cg/ImageFrameDecoder.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..511f6f41f7583e5bc6f44e54038ab29c6a90ab32
>--- /dev/null
>+++ b/Source/WebCore/platform/graphics/cg/ImageFrameDecoder.cpp
>@@ -0,0 +1,223 @@
>+/*
>+ * 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"
>+
>+#if USE(CG)
>+
>+#include "ImageFrameData.h"
>+#include "ImageSource.h"
>+#include "SharedBuffer.h"
>+
>+#if !PLATFORM(IOS)
>+#include <ApplicationServices/ApplicationServices.h>
>+#else
>+#include <ImageIO/ImageIO.h>
>+#include <wtf/RetainPtr.h>
>+#endif
>+
>+#include <wtf/MainThread.h>
>+#include <wtf/RunLoop.h>
>+
>+namespace WebCore {
>+
>+ImageFrameDecoder::ImageFrameDecoder(ImageSource& source, SubsamplingLevel subsamplingLevel)
>+    : m_source(source)
>+    , m_subsamplingLevel(subsamplingLevel)
>+{
>+}
>+
>+WorkQueue& ImageFrameDecoder::decodeQueue()
>+{
>+    static auto& queue = WorkQueue::create("org.webkit.ImageDecoder").leakRef();
>+    return queue;
>+}
>+
>+const ImageFrameDataBuffer& ImageFrameDecoder::frames() const
>+{
>+    return m_source.m_frames;
>+}
>+
>+ImageFrameDataBuffer& ImageFrameDecoder::frames()
>+{
>+    return m_source.m_frames;
>+}
>+
>+#if !PLATFORM(COCOA)
>+static size_t sharedBufferGetBytesAtPosition(void* info, void* buffer, off_t position, size_t count)
>+{
>+    SharedBuffer* sharedBuffer = static_cast<SharedBuffer*>(info);
>+    size_t sourceSize = sharedBuffer->size();
>+    if (position >= sourceSize)
>+        return 0;
>+
>+    const char* source = sharedBuffer->data() + position;
>+    size_t amount = std::min<size_t>(count, sourceSize - position);
>+    memcpy(buffer, source, amount);
>+    return amount;
>+}
>+
>+static void sharedBufferRelease(void* info)
>+{
>+    SharedBuffer* sharedBuffer = static_cast<SharedBuffer*>(info);
>+    sharedBuffer->deref();
>+}
>+#endif
>+
>+void ImageFrameDecoder::updateData(CFDataRef data, bool allDataReceived)
>+{
>+    CGImageSourceUpdateData(m_nativeDecoder, data, allDataReceived);
>+}
>+
>+void ImageFrameDecoder::updateData(SharedBuffer* data, bool 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.
>+    CGImageSourceUpdateData(m_nativeDecoder, data->createCFData().get(), allDataReceived);
>+#else
>+    // Create a CGDataProvider to wrap the SharedBuffer.
>+    data->ref();
>+    // We use the GetBytesAtPosition callback rather than the GetBytePointer one because SharedBuffer
>+    // does not provide a way to lock down the byte pointer and guarantee that it won't move, which
>+    // is a requirement for using the GetBytePointer callback.
>+    CGDataProviderDirectCallbacks providerCallbacks = { 0, 0, 0, sharedBufferGetBytesAtPosition, sharedBufferRelease };
>+    RetainPtr<CGDataProviderRef> dataProvider = adoptCF(CGDataProviderCreateDirect(data, data->size(), &providerCallbacks));
>+    CGImageSourceUpdateDataProvider(m_nativeDecoder, dataProvider.get(), allDataReceived);
>+#endif
>+}
>+
>+void ImageFrameDecoder::setData(SharedBuffer* data, bool allDataReceived)
>+{
>+    if (!data)
>+        return;
>+
>+    if (!isSizeAvailable()) {
>+        updateData(data, allDataReceived);
>+        if (!isSizeAvailable())
>+            return;
>+        
>+        m_source.didDecodeProperties();
>+        startDecodingIfNeeded(allDataReceived);
>+        return;
>+    }
>+
>+    if (m_decoding)
>+        pushData(data, allDataReceived);
>+    else
>+        updateData(data, allDataReceived);
>+}
>+
>+void ImageFrameDecoder::startDecodingIfNeeded(bool allDataReceived)
>+{
>+    if (allDataReceived)
>+        return;
>+#if OS(UNIX)
>+    ASSERT(isSizeAvailable());
>+    IntSize size = this->size();
>+    if (size.width() * size.height() < 1000 * 1000)
>+        return;
>+    
>+    m_decoding = true;
>+    decode();
>+#endif
>+}
>+
>+void ImageFrameDecoder::pushData(SharedBuffer* data, bool allDataReceived)
>+{
>+#if OS(UNIX)
>+    while ((m_produceCount - m_consumeCount) == BufferSize)
>+        sched_yield(); // buffer is full
>+    
>+    m_allDataReceived = allDataReceived;
>+    m_buffer[m_produceCount % BufferSize] = data->createCFData();
>+    ++m_produceCount;
>+#else
>+    UNUSED_PARAM(data);
>+    UNUSED_PARAM(allDataReceived);
>+#endif
>+}
>+
>+#if OS(UNIX)
>+void ImageFrameDecoder::decode()
>+{
>+    decodeQueue().dispatch([this] {
>+        bool allDataReceived = false;
>+
>+        while (!allDataReceived) {
>+            while (m_consumeCount == m_produceCount)
>+                sched_yield(); // buffer is empty
>+
>+            CFDataRef data = m_buffer[m_consumeCount % BufferSize].get();
>+            allDataReceived = m_allDataReceived && (m_produceCount - m_consumeCount == 1);
>+
>+            updateData(data, allDataReceived);
>+            cacheCurrentFrame();
>+
>+            ++m_consumeCount;
>+        }
>+        
>+        for (size_t frameCount = this->frameCount(); m_currentFrame < frameCount;)
>+            cacheCurrentFrame();
>+    });
>+}
>+
>+void ImageFrameDecoder::cacheCurrentFrame()
>+{
>+    if (frames()[m_currentFrame].status() == ImageFrameStatus::Partial) {
>+        unsigned frameBytes = frames()[m_currentFrame].m_frameBytes;
>+        callOnMainThread([this, frameBytes] {
>+            m_source.decodedSizeDecremented(frameBytes);
>+        });
>+    }
>+
>+    NativeImagePtr image = ImageDecoder::createFrameImageAtIndex(m_currentFrame, m_subsamplingLevel, DecodeMode::Immediate);
>+    frames()[m_currentFrame] = ImageFrameData(*this, m_currentFrame, m_subsamplingLevel, image);
>+
>+    if (frames()[m_currentFrame].status() != ImageFrameStatus::Empty) {
>+        unsigned frameBytes = frames()[m_currentFrame].m_frameBytes;
>+        callOnMainThread([this, frameBytes] {
>+            m_source.decodedSizeIncremented(frameBytes);
>+        });
>+    }
>+
>+    if (frames()[m_currentFrame].status() == ImageFrameStatus::Complete)
>+        ++m_currentFrame;
>+}
>+#endif
>+
>+const ImageFrameData* ImageFrameDecoder::frameAtIndex(size_t index, SubsamplingLevel, ImageFrameCaching)
>+{
>+    if (index >= frames().size())
>+        return nullptr;
>+    
>+    return &frames()[index];
>+}
>+
>+}
>+
>+#endif // USE(CG)
>diff --git a/Source/WebCore/platform/graphics/cg/ImageFrameDecoder.h b/Source/WebCore/platform/graphics/cg/ImageFrameDecoder.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..6015ef50ecf1ce181c9f0de967c9fb522f17f43d
>--- /dev/null
>+++ b/Source/WebCore/platform/graphics/cg/ImageFrameDecoder.h
>@@ -0,0 +1,77 @@
>+/*
>+ * 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.
>+ */
>+
>+#ifndef ImageFrameDecoder_h
>+#define ImageFrameDecoder_h
>+
>+#include "ImageDecoder.h"
>+
>+#include <wtf/RetainPtr.h>
>+#include <wtf/Vector.h>
>+#include <wtf/WorkQueue.h>
>+
>+namespace WebCore {
>+
>+class ImageFrameDataBuffer;
>+class ImageSource;
>+class SharedBuffer;
>+
>+class ImageFrameDecoder : public ImageDecoder {
>+public:
>+    ImageFrameDecoder(ImageSource&, SubsamplingLevel);
>+    ImageFrameDecoder();
>+
>+    bool isDecoding() override { return m_decoding; }
>+    void setData(SharedBuffer*, bool allDataReceived) override;
>+    const ImageFrameData* frameAtIndex(size_t index, SubsamplingLevel, ImageFrameCaching) override;
>+
>+private:
>+    static const int BufferSize = 10;
>+
>+    static WorkQueue& decodeQueue();
>+    const ImageFrameDataBuffer& frames() const;
>+    ImageFrameDataBuffer& frames();
>+    void updateData(CFDataRef, bool allDataReceived);
>+    void updateData(SharedBuffer*, bool allDataReceived);
>+    void pushData(SharedBuffer*, bool allDataReceived);
>+    void startDecodingIfNeeded(bool allDataReceived);
>+    void decode();
>+    void cacheCurrentFrame();
>+
>+    volatile unsigned m_produceCount { 0 };
>+    volatile unsigned m_consumeCount { 0 };
>+    volatile ImageFrameIndex m_currentFrame { 0 };
>+
>+    ImageSource& m_source;
>+    SubsamplingLevel m_subsamplingLevel;
>+
>+    bool m_allDataReceived { false };
>+    bool m_decoding { false };
>+    RetainPtr<CFDataRef> m_buffer[BufferSize];
>+};
>+    
>+}
>+
>+#endif // ImageFrameDecoder_h
>diff --git a/Source/WebCore/platform/graphics/cg/ImageSourceCG.cpp b/Source/WebCore/platform/graphics/cg/ImageSourceCG.cpp
>deleted file mode 100644
>index d4a012b6f57bf5393064777b6c109366b24c445c..0000000000000000000000000000000000000000
>--- a/Source/WebCore/platform/graphics/cg/ImageSourceCG.cpp
>+++ /dev/null
>@@ -1,455 +0,0 @@
>-/*
>- * Copyright (C) 2004, 2005, 2006, 2008 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 "ImageSource.h"
>-
>-#if USE(CG)
>-#include "ImageSourceCG.h"
>-
>-#include "CoreGraphicsSPI.h"
>-#include "ImageOrientation.h"
>-#include "IntPoint.h"
>-#include "IntSize.h"
>-#include "MIMETypeRegistry.h"
>-#include "SharedBuffer.h"
>-#include <wtf/NeverDestroyed.h>
>-
>-#if !PLATFORM(IOS)
>-#include <ApplicationServices/ApplicationServices.h>
>-#else
>-#include <ImageIO/ImageIO.h>
>-#include <wtf/RetainPtr.h>
>-#endif
>-
>-#if USE(APPLE_INTERNAL_SDK)
>-#import <ImageIO/CGImageSourcePrivate.h>
>-#else
>-const CFStringRef kCGImageSourceSubsampleFactor = CFSTR("kCGImageSourceSubsampleFactor");
>-#endif
>-
>-namespace WebCore {
>-
>-const CFStringRef WebCoreCGImagePropertyAPNGUnclampedDelayTime = CFSTR("UnclampedDelayTime");
>-const CFStringRef WebCoreCGImagePropertyAPNGDelayTime = CFSTR("DelayTime");
>-const CFStringRef WebCoreCGImagePropertyAPNGLoopCount = CFSTR("LoopCount");
>-
>-const CFStringRef kCGImageSourceShouldPreferRGB32 = CFSTR("kCGImageSourceShouldPreferRGB32");
>-const CFStringRef kCGImageSourceSkipMetadata = CFSTR("kCGImageSourceSkipMetadata");
>-
>-#if !PLATFORM(COCOA)
>-size_t sharedBufferGetBytesAtPosition(void* info, void* buffer, off_t position, size_t count)
>-{
>-    SharedBuffer* sharedBuffer = static_cast<SharedBuffer*>(info);
>-    size_t sourceSize = sharedBuffer->size();
>-    if (position >= sourceSize)
>-        return 0;
>-
>-    const char* source = sharedBuffer->data() + position;
>-    size_t amount = std::min<size_t>(count, sourceSize - position);
>-    memcpy(buffer, source, amount);
>-    return amount;
>-}
>-
>-void sharedBufferRelease(void* info)
>-{
>-    SharedBuffer* sharedBuffer = static_cast<SharedBuffer*>(info);
>-    sharedBuffer->deref();
>-}
>-#endif
>-
>-ImageSource::ImageSource(ImageSource::AlphaOption, ImageSource::GammaAndColorProfileOption)
>-    : m_decoder(0)
>-{
>-    // FIXME: AlphaOption and GammaAndColorProfileOption are ignored.
>-}
>-
>-ImageSource::~ImageSource()
>-{
>-    clear(true);
>-}
>-
>-void ImageSource::clear(bool destroyAllFrames, size_t, SharedBuffer* data, bool allDataReceived)
>-{
>-    // Recent versions of ImageIO discard previously decoded image frames if the client
>-    // application no longer holds references to them, so there's no need to throw away
>-    // the decoder unless we're explicitly asked to destroy all of the frames.
>-    if (!destroyAllFrames)
>-        return;
>-
>-    if (m_decoder) {
>-        CFRelease(m_decoder);
>-        m_decoder = 0;
>-    }
>-    if (data)
>-        setData(data, allDataReceived);
>-}
>-
>-static RetainPtr<CFDictionaryRef> createImageSourceOptions(SubsamplingLevel subsamplingLevel)
>-{
>-    if (!subsamplingLevel) {
>-        const unsigned numOptions = 3;
>-        const void* keys[numOptions] = { kCGImageSourceShouldCache, kCGImageSourceShouldPreferRGB32, kCGImageSourceSkipMetadata };
>-        const void* values[numOptions] = { kCFBooleanTrue, kCFBooleanTrue, kCFBooleanTrue };
>-        return CFDictionaryCreate(nullptr, keys, values, numOptions, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
>-    }
>-
>-    short constrainedSubsamplingLevel = std::min<short>(3, std::max<short>(0, subsamplingLevel));
>-    int subsampleInt = 1 << constrainedSubsamplingLevel; // [0..3] => [1, 2, 4, 8]
>-
>-    RetainPtr<CFNumberRef> subsampleNumber = adoptCF(CFNumberCreate(nullptr,  kCFNumberIntType,  &subsampleInt));
>-    const CFIndex numOptions = 4;
>-    const void* keys[numOptions] = { kCGImageSourceShouldCache, kCGImageSourceShouldPreferRGB32, kCGImageSourceSkipMetadata, kCGImageSourceSubsampleFactor };
>-    const void* values[numOptions] = { kCFBooleanTrue, kCFBooleanTrue, kCFBooleanTrue, subsampleNumber.get() };
>-    return adoptCF(CFDictionaryCreate(nullptr, keys, values, numOptions, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks));
>-}
>-
>-static RetainPtr<CFDictionaryRef> imageSourceOptions(SubsamplingLevel subsamplingLevel = 0)
>-{
>-    if (subsamplingLevel)
>-        return createImageSourceOptions(subsamplingLevel);
>-
>-    static NeverDestroyed<RetainPtr<CFDictionaryRef>> options = createImageSourceOptions(0);
>-    return options;
>-}
>-
>-bool ImageSource::initialized() const
>-{
>-    return m_decoder;
>-}
>-
>-void ImageSource::setData(SharedBuffer* data, bool allDataReceived)
>-{
>-#if PLATFORM(COCOA)
>-    if (!m_decoder)
>-        m_decoder = CGImageSourceCreateIncremental(0);
>-    // 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.
>-    CGImageSourceUpdateData(m_decoder, data->createCFData().get(), allDataReceived);
>-#else
>-    if (!m_decoder)
>-        m_decoder = CGImageSourceCreateIncremental(0);
>-    // Create a CGDataProvider to wrap the SharedBuffer.
>-    data->ref();
>-    // We use the GetBytesAtPosition callback rather than the GetBytePointer one because SharedBuffer
>-    // does not provide a way to lock down the byte pointer and guarantee that it won't move, which
>-    // is a requirement for using the GetBytePointer callback.
>-    CGDataProviderDirectCallbacks providerCallbacks = { 0, 0, 0, sharedBufferGetBytesAtPosition, sharedBufferRelease };
>-    RetainPtr<CGDataProviderRef> dataProvider = adoptCF(CGDataProviderCreateDirect(data, data->size(), &providerCallbacks));
>-    CGImageSourceUpdateDataProvider(m_decoder, dataProvider.get(), allDataReceived);
>-#endif
>-}
>-
>-String ImageSource::filenameExtension() const
>-{
>-    if (!m_decoder)
>-        return String();
>-    CFStringRef imageSourceType = CGImageSourceGetType(m_decoder);
>-    return WebCore::preferredExtensionForImageSourceType(imageSourceType);
>-}
>-
>-SubsamplingLevel ImageSource::subsamplingLevelForScale(float scale) const
>-{
>-    // There are four subsampling levels: 0 = 1x, 1 = 0.5x, 2 = 0.25x, 3 = 0.125x.
>-    float clampedScale = std::max<float>(0.125, std::min<float>(1, scale));
>-    int result = ceilf(log2f(1 / clampedScale));
>-    ASSERT(result >=0 && result <= 3);
>-    return result;
>-}
>-
>-bool ImageSource::isSizeAvailable()
>-{
>-    // Ragnaros yells: TOO SOON! You have awakened me TOO SOON, Executus!
>-    if (CGImageSourceGetStatus(m_decoder) < kCGImageStatusIncomplete)
>-        return false;
>-
>-    RetainPtr<CFDictionaryRef> image0Properties = adoptCF(CGImageSourceCopyPropertiesAtIndex(m_decoder, 0, imageSourceOptions().get()));
>-    if (!image0Properties)
>-        return false;
>-
>-    return CFDictionaryContainsKey(image0Properties.get(), kCGImagePropertyPixelWidth)
>-        && CFDictionaryContainsKey(image0Properties.get(), kCGImagePropertyPixelHeight);
>-}
>-
>-static ImageOrientation orientationFromProperties(CFDictionaryRef imageProperties)
>-{
>-    ASSERT(imageProperties);
>-    CFNumberRef orientationProperty = (CFNumberRef)CFDictionaryGetValue(imageProperties, kCGImagePropertyOrientation);
>-    if (!orientationProperty)
>-        return DefaultImageOrientation;
>-
>-    int exifValue;
>-    CFNumberGetValue(orientationProperty, kCFNumberIntType, &exifValue);
>-    return ImageOrientation::fromEXIFValue(exifValue);
>-}
>-
>-bool ImageSource::allowSubsamplingOfFrameAtIndex(size_t) const
>-{
>-    RetainPtr<CFDictionaryRef> properties = adoptCF(CGImageSourceCopyPropertiesAtIndex(m_decoder, 0, imageSourceOptions().get()));
>-    if (!properties)
>-        return false;
>-
>-    CFDictionaryRef jfifProperties = static_cast<CFDictionaryRef>(CFDictionaryGetValue(properties.get(), kCGImagePropertyJFIFDictionary));
>-    if (jfifProperties) {
>-        CFBooleanRef isProgCFBool = static_cast<CFBooleanRef>(CFDictionaryGetValue(jfifProperties, kCGImagePropertyJFIFIsProgressive));
>-        if (isProgCFBool) {
>-            bool isProgressive = CFBooleanGetValue(isProgCFBool);
>-            // Workaround for <rdar://problem/5184655> - Hang rendering very large progressive JPEG. Decoding progressive
>-            // images hangs for a very long time right now. Until this is fixed, don't sub-sample progressive images. This
>-            // will cause them to fail our large image check and they won't be decoded.
>-            // FIXME: Remove once underlying issue is fixed (<rdar://problem/5191418>)
>-            return !isProgressive;
>-        }
>-    }
>-
>-    return true;
>-}
>-
>-IntSize ImageSource::frameSizeAtIndex(size_t index, SubsamplingLevel subsamplingLevel, ImageOrientationDescription description) const
>-{
>-    RetainPtr<CFDictionaryRef> properties = adoptCF(CGImageSourceCopyPropertiesAtIndex(m_decoder, index, imageSourceOptions(subsamplingLevel).get()));
>-
>-    if (!properties)
>-        return IntSize();
>-
>-    int width = 0;
>-    int height = 0;
>-    CFNumberRef num = (CFNumberRef)CFDictionaryGetValue(properties.get(), kCGImagePropertyPixelWidth);
>-    if (num)
>-        CFNumberGetValue(num, kCFNumberIntType, &width);
>-    num = (CFNumberRef)CFDictionaryGetValue(properties.get(), kCGImagePropertyPixelHeight);
>-    if (num)
>-        CFNumberGetValue(num, kCFNumberIntType, &height);
>-
>-    if ((description.respectImageOrientation() == RespectImageOrientation) && orientationFromProperties(properties.get()).usesWidthAsHeight())
>-        return IntSize(height, width);
>-
>-    return IntSize(width, height);
>-}
>-
>-ImageOrientation ImageSource::orientationAtIndex(size_t index) const
>-{
>-    RetainPtr<CFDictionaryRef> properties = adoptCF(CGImageSourceCopyPropertiesAtIndex(m_decoder, index, imageSourceOptions().get()));
>-    if (!properties)
>-        return DefaultImageOrientation;
>-
>-    return orientationFromProperties(properties.get());
>-}
>-
>-IntSize ImageSource::size(ImageOrientationDescription description) const
>-{
>-    return frameSizeAtIndex(0, 0, description);
>-}
>-
>-bool ImageSource::getHotSpot(IntPoint& hotSpot) const
>-{
>-    RetainPtr<CFDictionaryRef> properties = adoptCF(CGImageSourceCopyPropertiesAtIndex(m_decoder, 0, imageSourceOptions().get()));
>-    if (!properties)
>-        return false;
>-
>-    int x = -1, y = -1;
>-    CFNumberRef num = (CFNumberRef)CFDictionaryGetValue(properties.get(), CFSTR("hotspotX"));
>-    if (!num || !CFNumberGetValue(num, kCFNumberIntType, &x))
>-        return false;
>-
>-    num = (CFNumberRef)CFDictionaryGetValue(properties.get(), CFSTR("hotspotY"));
>-    if (!num || !CFNumberGetValue(num, kCFNumberIntType, &y))
>-        return false;
>-
>-    if (x < 0 || y < 0)
>-        return false;
>-
>-    hotSpot = IntPoint(x, y);
>-    return true;
>-}
>-
>-size_t ImageSource::bytesDecodedToDetermineProperties() const
>-{
>-    // Measured by tracing malloc/calloc calls on Mac OS 10.6.6, x86_64.
>-    // A non-zero value ensures cached images with no decoded frames still enter
>-    // the live decoded resources list when the CGImageSource decodes image
>-    // properties, allowing the cache to prune the partially decoded image.
>-    // This value is likely to be inaccurate on other platforms, but the overall
>-    // behavior is unchanged.
>-    return 13088;
>-}
>-    
>-int ImageSource::repetitionCount()
>-{
>-    if (!initialized())
>-        return cAnimationLoopOnce;
>-
>-    RetainPtr<CFDictionaryRef> properties = adoptCF(CGImageSourceCopyProperties(m_decoder, imageSourceOptions().get()));
>-    if (!properties)
>-        return cAnimationLoopOnce;
>-
>-    CFDictionaryRef gifProperties = (CFDictionaryRef)CFDictionaryGetValue(properties.get(), kCGImagePropertyGIFDictionary);
>-    if (gifProperties) {
>-        CFNumberRef num = (CFNumberRef)CFDictionaryGetValue(gifProperties, kCGImagePropertyGIFLoopCount);
>-
>-        // No property means loop once.
>-        if (!num)
>-            return cAnimationLoopOnce;
>-
>-        int loopCount;
>-        CFNumberGetValue(num, kCFNumberIntType, &loopCount);
>-
>-        // A property with value 0 means loop forever.
>-        return loopCount ? loopCount : cAnimationLoopInfinite;
>-    }
>-
>-    CFDictionaryRef pngProperties = (CFDictionaryRef)CFDictionaryGetValue(properties.get(), kCGImagePropertyPNGDictionary);
>-    if (pngProperties) {
>-        CFNumberRef num = (CFNumberRef)CFDictionaryGetValue(pngProperties, WebCoreCGImagePropertyAPNGLoopCount);
>-        if (!num)
>-            return cAnimationLoopOnce;
>-
>-        int loopCount;
>-        CFNumberGetValue(num, kCFNumberIntType, &loopCount);
>-        return loopCount ? loopCount : cAnimationLoopInfinite;
>-    }
>-
>-    // Turns out we're not an animated image after all, so we don't animate.
>-    return cAnimationNone;
>-}
>-
>-size_t ImageSource::frameCount() const
>-{
>-    return m_decoder ? CGImageSourceGetCount(m_decoder) : 0;
>-}
>-
>-CGImageRef ImageSource::createFrameAtIndex(size_t index, SubsamplingLevel subsamplingLevel)
>-{
>-    if (!initialized())
>-        return nullptr;
>-
>-    RetainPtr<CGImageRef> image = adoptCF(CGImageSourceCreateImageAtIndex(m_decoder, index, imageSourceOptions(subsamplingLevel).get()));
>-
>-#if PLATFORM(IOS)
>-    // <rdar://problem/7371198> - CoreGraphics changed the default caching behaviour in iOS 4.0 to kCGImageCachingTransient
>-    // which caused a performance regression for us since the images had to be resampled/recreated every time we called
>-    // CGContextDrawImage. We now tell CG to cache the drawn images. See also <rdar://problem/14366755> -
>-    // CoreGraphics needs to un-deprecate kCGImageCachingTemporary since it's still not the default.
>-#if COMPILER(CLANG)
>-#pragma clang diagnostic push
>-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
>-#endif
>-    CGImageSetCachingFlags(image.get(), kCGImageCachingTemporary);
>-#if COMPILER(CLANG)
>-#pragma clang diagnostic pop
>-#endif
>-#endif // PLATFORM(IOS)
>-
>-    CFStringRef imageUTI = CGImageSourceGetType(m_decoder);
>-    static const CFStringRef xbmUTI = CFSTR("public.xbitmap-image");
>-
>-    if (!imageUTI)
>-        return image.leakRef();
>-
>-    if (!CFEqual(imageUTI, xbmUTI))
>-        return image.leakRef();
>-    
>-    // If it is an xbm image, mask out all the white areas to render them transparent.
>-    const CGFloat maskingColors[6] = {255, 255,  255, 255, 255, 255};
>-    RetainPtr<CGImageRef> maskedImage = adoptCF(CGImageCreateWithMaskingColors(image.get(), maskingColors));
>-    if (!maskedImage)
>-        return image.leakRef();
>-
>-    return maskedImage.leakRef();
>-}
>-
>-bool ImageSource::frameIsCompleteAtIndex(size_t index)
>-{
>-    ASSERT(frameCount());
>-    return CGImageSourceGetStatusAtIndex(m_decoder, index) == kCGImageStatusComplete;
>-}
>-
>-float ImageSource::frameDurationAtIndex(size_t index)
>-{
>-    if (!initialized())
>-        return 0;
>-
>-    float duration = 0;
>-    RetainPtr<CFDictionaryRef> properties = adoptCF(CGImageSourceCopyPropertiesAtIndex(m_decoder, index, imageSourceOptions().get()));
>-    if (properties) {
>-        CFDictionaryRef gifProperties = (CFDictionaryRef)CFDictionaryGetValue(properties.get(), kCGImagePropertyGIFDictionary);
>-        if (gifProperties) {
>-            if (CFNumberRef num = (CFNumberRef)CFDictionaryGetValue(gifProperties, kCGImagePropertyGIFUnclampedDelayTime)) {
>-                // Use the unclamped frame delay if it exists.
>-                CFNumberGetValue(num, kCFNumberFloatType, &duration);
>-            } else if (CFNumberRef num = (CFNumberRef)CFDictionaryGetValue(gifProperties, kCGImagePropertyGIFDelayTime)) {
>-                // Fall back to the clamped frame delay if the unclamped frame delay does not exist.
>-                CFNumberGetValue(num, kCFNumberFloatType, &duration);
>-            }
>-        }
>-
>-        CFDictionaryRef pngProperties = (CFDictionaryRef)CFDictionaryGetValue(properties.get(), kCGImagePropertyPNGDictionary);
>-        if (pngProperties) {
>-            if (CFNumberRef num = (CFNumberRef)CFDictionaryGetValue(pngProperties, WebCoreCGImagePropertyAPNGUnclampedDelayTime))
>-                CFNumberGetValue(num, kCFNumberFloatType, &duration);
>-            else if (CFNumberRef num = (CFNumberRef)CFDictionaryGetValue(pngProperties, WebCoreCGImagePropertyAPNGDelayTime))
>-                CFNumberGetValue(num, kCFNumberFloatType, &duration);
>-        }
>-    }
>-
>-    // Many annoying ads specify a 0 duration to make an image flash as quickly as possible.
>-    // We follow Firefox's behavior and use a duration of 100 ms for any frames that specify
>-    // a duration of <= 10 ms. See <rdar://problem/7689300> and <http://webkit.org/b/36082>
>-    // for more information.
>-    if (duration < 0.011f)
>-        return 0.1f;
>-    return duration;
>-}
>-
>-bool ImageSource::frameHasAlphaAtIndex(size_t index)
>-{
>-    if (!m_decoder)
>-        return false; // FIXME: why doesn't this return true?
>-
>-    if (!frameIsCompleteAtIndex(index))
>-        return true;
>-
>-    CFStringRef imageType = CGImageSourceGetType(m_decoder);
>-
>-    // Return false if there is no image type or the image type is JPEG, because
>-    // JPEG does not support alpha transparency.
>-    if (!imageType || CFEqual(imageType, CFSTR("public.jpeg")))
>-        return false;
>-
>-    // FIXME: Could return false for other non-transparent image formats.
>-    // FIXME: Could maybe return false for a GIF Frame if we have enough info in the GIF properties dictionary
>-    // to determine whether or not a transparent color was defined.
>-    return true;
>-}
>-
>-unsigned ImageSource::frameBytesAtIndex(size_t index, SubsamplingLevel subsamplingLevel) const
>-{
>-    IntSize frameSize = frameSizeAtIndex(index, subsamplingLevel, ImageOrientationDescription(RespectImageOrientation));
>-    return frameSize.width() * frameSize.height() * 4;
>-}
>-
>-}
>-
>-#endif // USE(CG)
>diff --git a/Source/WebCore/platform/graphics/ios/IconIOS.mm b/Source/WebCore/platform/graphics/ios/IconIOS.mm
>index 215915f28a192172396d46f086d2249b81d9d76a..e1833d19830b107663664b612844597f83fc0a88 100644
>--- a/Source/WebCore/platform/graphics/ios/IconIOS.mm
>+++ b/Source/WebCore/platform/graphics/ios/IconIOS.mm
>@@ -33,7 +33,7 @@
> 
> namespace WebCore {
>     
>-Icon::Icon(CGImageRef image)
>+Icon::Icon(NativeImagePtr image)
>     : m_cgImage(image)
> {
> }
>diff --git a/Source/WebCore/platform/graphics/mac/ImageMac.mm b/Source/WebCore/platform/graphics/mac/ImageMac.mm
>index ff07131a61fced04586b372d9ba2079a9873c38b..88162cb2817ce53ab7706cc3355d91a47fe119fa 100644
>--- a/Source/WebCore/platform/graphics/mac/ImageMac.mm
>+++ b/Source/WebCore/platform/graphics/mac/ImageMac.mm
>@@ -53,7 +53,7 @@ namespace WebCore {
> 
> void BitmapImage::invalidatePlatformData()
> {
>-    if (m_frames.size() != 1)
>+    if (m_source.m_frames.size() != 1)
>         return;
> 
> #if USE(APPKIT)
>@@ -95,7 +95,7 @@ CFDataRef BitmapImage::getTIFFRepresentation()
> 
>     Vector<CGImageRef> images;
>     for (unsigned i = 0; i < numFrames; ++i ) {
>-        CGImageRef cgImage = frameAtIndex(i);
>+        CGImageRef cgImage = frameAtIndex(i).get();
>         if (cgImage)
>             images.append(cgImage);
>     }
>diff --git a/Source/WebCore/platform/graphics/win/ImageCGWin.cpp b/Source/WebCore/platform/graphics/win/ImageCGWin.cpp
>index 835ecf3f4feeeb8a0dfa8d36973128f3b807b926..7677a1c25e1a22bc8b7ec47565f3c6d06ae5bcf5 100644
>--- a/Source/WebCore/platform/graphics/win/ImageCGWin.cpp
>+++ b/Source/WebCore/platform/graphics/win/ImageCGWin.cpp
>@@ -90,7 +90,7 @@ void BitmapImage::drawFrameMatchingSourceSize(GraphicsContext& ctxt, const Float
> {
>     size_t frames = frameCount();
>     for (size_t i = 0; i < frames; ++i) {
>-        CGImageRef image = frameAtIndex(i);
>+        CGImageRef image = frameAtIndex(i).get();
>         if (image && CGImageGetHeight(image) == static_cast<size_t>(srcSize.height()) && CGImageGetWidth(image) == static_cast<size_t>(srcSize.width())) {
>             size_t currentFrame = m_currentFrame;
>             m_currentFrame = i;

Actions: View | Formatted Diff | Diff

Attachments on bug 155322: 273794 | 273795 | 273797 | 273799 | 273800 | 273801 | 273802 | 273805 | 273810 | 273816 | 273820 | 273826 | 273828 | 273831 | 273834 | 273838 | 273841 | 273842 | 273847 | 273851 | 273855 | 273866 | 273867 | 273869 | 273870 | 273871 | 273872 | 273873 | 273877 | 273878 | 273880 | 273883 | 273888