Changeset 222151 in webkit

Timestamp:

Sep 18, 2017 9:24:59 AM (7 years ago)

Author:

jer.noble@apple.com

Message:

Virtualize ImageDecoder
​https://bugs.webkit.org/show_bug.cgi?id=176118

Reviewed by Eric Carlson.

Add an explicit, abstract base class ImageDecoder, and convert ImageDecoderCG to a true
subclass. This will allow multiple ImageDecoder subclasses to exist simultaneously at
runtime.

• CMakeLists.txt:
• WebCore.xcodeproj/project.pbxproj:
• platform/ImageDecoders.cmake:
• platform/graphics/ImageDecoder.cpp: Added.

(WebCore::ImageDecoder::create):
(WebCore::ImageDecoder::bytesDecodedToDetermineProperties):

• platform/graphics/ImageDecoder.h: Added.

(WebCore::ImageDecoder::isSizeAvailable):
(WebCore::ImageDecoder::isAllDataReceived const):

• platform/graphics/cg/ImageDecoderCG.cpp:

(WebCore::ImageDecoderCG::ImageDecoderCG):
(WebCore::ImageDecoderCG::bytesDecodedToDetermineProperties):
(WebCore::ImageDecoderCG::uti const):
(WebCore::ImageDecoderCG::filenameExtension const):
(WebCore::ImageDecoderCG::encodedDataStatus const):
(WebCore::ImageDecoderCG::frameCount const):
(WebCore::ImageDecoderCG::repetitionCount const):
(WebCore::ImageDecoderCG::hotSpot const):
(WebCore::ImageDecoderCG::frameSizeAtIndex const):
(WebCore::ImageDecoderCG::frameIsCompleteAtIndex const):
(WebCore::ImageDecoderCG::frameOrientationAtIndex const):
(WebCore::ImageDecoderCG::frameDurationAtIndex const):
(WebCore::ImageDecoderCG::frameAllowSubsamplingAtIndex const):
(WebCore::ImageDecoderCG::frameHasAlphaAtIndex const):
(WebCore::ImageDecoderCG::frameBytesAtIndex const):
(WebCore::ImageDecoderCG::createFrameImageAtIndex const):
(WebCore::ImageDecoderCG::setData):
(WebCore::ImageDecoder::ImageDecoder): Deleted.
(WebCore::ImageDecoder::bytesDecodedToDetermineProperties): Deleted.
(WebCore::ImageDecoder::uti const): Deleted.
(WebCore::ImageDecoder::filenameExtension const): Deleted.
(WebCore::ImageDecoder::encodedDataStatus const): Deleted.
(WebCore::ImageDecoder::frameCount const): Deleted.
(WebCore::ImageDecoder::repetitionCount const): Deleted.
(WebCore::ImageDecoder::hotSpot const): Deleted.
(WebCore::ImageDecoder::frameSizeAtIndex const): Deleted.
(WebCore::ImageDecoder::frameIsCompleteAtIndex const): Deleted.
(WebCore::ImageDecoder::frameOrientationAtIndex const): Deleted.
(WebCore::ImageDecoder::frameDurationAtIndex const): Deleted.
(WebCore::ImageDecoder::frameAllowSubsamplingAtIndex const): Deleted.
(WebCore::ImageDecoder::frameHasAlphaAtIndex const): Deleted.
(WebCore::ImageDecoder::frameBytesAtIndex const): Deleted.
(WebCore::ImageDecoder::createFrameImageAtIndex const): Deleted.
(WebCore::ImageDecoder::setData): Deleted.

• platform/graphics/cg/ImageDecoderCG.h:

(WebCore::ImageDecoderCG::create):
(WebCore::ImageDecoder::create): Deleted.
(WebCore::ImageDecoder::isSizeAvailable): Deleted.
(WebCore::ImageDecoder::isAllDataReceived const): Deleted.
(WebCore::ImageDecoder::clearFrameBufferCache): Deleted.

• platform/graphics/win/ImageDecoderDirect2D.cpp:

(WebCore::ImageDecoderDirect2D::ImageDecoderDirect2D):
(WebCore::ImageDecoderDirect2D::systemImagingFactory):
(WebCore::ImageDecoderDirect2D::bytesDecodedToDetermineProperties):
(WebCore::ImageDecoderDirect2D::filenameExtension const):
(WebCore::ImageDecoderDirect2D::isSizeAvailable const):
(WebCore::ImageDecoderDirect2D::encodedDataStatus const):
(WebCore::ImageDecoderDirect2D::size const):
(WebCore::ImageDecoderDirect2D::frameCount const):
(WebCore::ImageDecoderDirect2D::repetitionCount const):
(WebCore::ImageDecoderDirect2D::hotSpot const):
(WebCore::ImageDecoderDirect2D::frameSizeAtIndex const):
(WebCore::ImageDecoderDirect2D::frameIsCompleteAtIndex const):
(WebCore::ImageDecoderDirect2D::frameOrientationAtIndex const):
(WebCore::ImageDecoderDirect2D::frameDurationAtIndex const):
(WebCore::ImageDecoderDirect2D::frameAllowSubsamplingAtIndex const):
(WebCore::ImageDecoderDirect2D::frameHasAlphaAtIndex const):
(WebCore::ImageDecoderDirect2D::frameBytesAtIndex const):
(WebCore::ImageDecoderDirect2D::setTargetContext):
(WebCore::ImageDecoderDirect2D::createFrameImageAtIndex const):
(WebCore::ImageDecoderDirect2D::setData):

• platform/graphics/win/ImageDecoderDirect2D.h:

(WebCore::ImageDecoderDirect2D::create):
(WebCore::ImageDecoder::create): Deleted.
(WebCore::ImageDecoder::isAllDataReceived const): Deleted.
(WebCore::ImageDecoder::clearFrameBufferCache): Deleted.

• platform/image-decoders/ScalableImageDecoder.cpp: Renamed from Source/WebCore/platform/image-decoders/ImageDecoder.cpp.

(WebCore::ScalableImageDecoder::create):
(WebCore::ScalableImageDecoder::frameIsCompleteAtIndex const):
(WebCore::ScalableImageDecoder::frameHasAlphaAtIndex const):
(WebCore::ScalableImageDecoder::frameBytesAtIndex const):
(WebCore::ScalableImageDecoder::frameDurationAtIndex const):
(WebCore::ScalableImageDecoder::createFrameImageAtIndex):
(WebCore::ScalableImageDecoder::prepareScaleDataIfNecessary):
(WebCore::ScalableImageDecoder::upperBoundScaledX):
(WebCore::ScalableImageDecoder::lowerBoundScaledX):
(WebCore::ScalableImageDecoder::upperBoundScaledY):
(WebCore::ScalableImageDecoder::lowerBoundScaledY):
(WebCore::ScalableImageDecoder::scaledY):

• platform/image-decoders/ScalableImageDecoder.h: Renamed from Source/WebCore/platform/image-decoders/ImageDecoder.h.

(WebCore::ScalableImageDecoder::ScalableImageDecoder):
(WebCore::ScalableImageDecoder::~ScalableImageDecoder):
(WebCore::ScalableImageDecoder::premultiplyAlpha const):
(WebCore::ScalableImageDecoder::isAllDataReceived const):
(WebCore::ScalableImageDecoder::size const):
(WebCore::ScalableImageDecoder::scaledSize):
(WebCore::ScalableImageDecoder::setSize):
(WebCore::ScalableImageDecoder::setIgnoreGammaAndColorProfile):
(WebCore::ScalableImageDecoder::ignoresGammaAndColorProfile const):
(WebCore::ScalableImageDecoder::rgbColorProfile):
(WebCore::ScalableImageDecoder::subsamplingLevelForScale):
(WebCore::ScalableImageDecoder::inputDeviceColorProfile):
(WebCore::ScalableImageDecoder::setFailed):
(WebCore::ScalableImageDecoder::failed const):

• platform/image-decoders/bmp/BMPImageDecoder.cpp:

(WebCore::BMPImageDecoder::BMPImageDecoder):
(WebCore::BMPImageDecoder::setData):
(WebCore::BMPImageDecoder::setFailed):

• platform/image-decoders/bmp/BMPImageDecoder.h:
• platform/image-decoders/bmp/BMPImageReader.h:
• platform/image-decoders/gif/GIFImageDecoder.cpp:

(WebCore::GIFImageDecoder::GIFImageDecoder):
(WebCore::GIFImageDecoder::setData):
(WebCore::GIFImageDecoder::setSize):
(WebCore::GIFImageDecoder::setFailed):

• platform/image-decoders/gif/GIFImageDecoder.h:
• platform/image-decoders/ico/ICOImageDecoder.cpp:

(WebCore::ICOImageDecoder::ICOImageDecoder):
(WebCore::ICOImageDecoder::setData):
(WebCore::ICOImageDecoder::size):
(WebCore::ICOImageDecoder::setSize):
(WebCore::ICOImageDecoder::setFailed):

• platform/image-decoders/ico/ICOImageDecoder.h:
• platform/image-decoders/jpeg/JPEGImageDecoder.cpp:

(WebCore::JPEGImageDecoder::JPEGImageDecoder):
(WebCore::JPEGImageDecoder::setSize):
(WebCore::JPEGImageDecoder::setFailed):

• platform/image-decoders/jpeg/JPEGImageDecoder.h:
• platform/image-decoders/png/PNGImageDecoder.cpp:

(WebCore::PNGImageReader::decode):
(WebCore::PNGImageDecoder::PNGImageDecoder):
(WebCore::PNGImageDecoder::setSize):
(WebCore::PNGImageDecoder::frameBufferAtIndex):
(WebCore::PNGImageDecoder::setFailed):

• platform/image-decoders/png/PNGImageDecoder.h:
• platform/image-decoders/webp/WEBPImageDecoder.cpp:

(WebCore::WEBPImageDecoder::WEBPImageDecoder):
(WebCore::WEBPImageDecoder::decode):

• platform/image-decoders/webp/WEBPImageDecoder.h:

Location:

trunk/Source/WebCore

Files:

• CMakeLists.txt (modified) (1 diff)
• ChangeLog (modified) (1 diff)
• WebCore.xcodeproj/project.pbxproj (modified) (5 diffs)
• platform/ImageDecoders.cmake (modified) (1 diff)
• platform/graphics/ImageDecoder.cpp (added)
• platform/graphics/ImageDecoder.h (added)
• platform/graphics/cg/ImageDecoderCG.cpp (modified) (14 diffs)
• platform/graphics/cg/ImageDecoderCG.h (modified) (1 diff)
• platform/graphics/win/ImageDecoderDirect2D.cpp (modified) (15 diffs)
• platform/graphics/win/ImageDecoderDirect2D.h (modified) (3 diffs)
• platform/image-decoders/ScalableImageDecoder.cpp (moved) (moved from trunk/Source/WebCore/platform/image-decoders/ImageDecoder.cpp) (8 diffs)
• platform/image-decoders/ScalableImageDecoder.h (moved) (moved from trunk/Source/WebCore/platform/image-decoders/ImageDecoder.h) (11 diffs)
• platform/image-decoders/bmp/BMPImageDecoder.cpp (modified) (3 diffs)
• platform/image-decoders/bmp/BMPImageDecoder.h (modified) (1 diff)
• platform/image-decoders/bmp/BMPImageReader.cpp (modified) (1 diff)
• platform/image-decoders/bmp/BMPImageReader.h (modified) (1 diff)
• platform/image-decoders/gif/GIFImageDecoder.cpp (modified) (4 diffs)
• platform/image-decoders/gif/GIFImageDecoder.h (modified) (2 diffs)
• platform/image-decoders/ico/ICOImageDecoder.cpp (modified) (5 diffs)
• platform/image-decoders/ico/ICOImageDecoder.h (modified) (1 diff)
• platform/image-decoders/jpeg/JPEGImageDecoder.cpp (modified) (3 diffs)
• platform/image-decoders/jpeg/JPEGImageDecoder.h (modified) (4 diffs)
• platform/image-decoders/png/PNGImageDecoder.cpp (modified) (5 diffs)
• platform/image-decoders/png/PNGImageDecoder.h (modified) (3 diffs)
• platform/image-decoders/webp/WEBPImageDecoder.cpp (modified) (3 diffs)
• platform/image-decoders/webp/WEBPImageDecoder.h (modified) (2 diffs)

trunk/Source/WebCore/CMakeLists.txt

@@ -2449 +2449 @@
     platform/graphics/Image.cpp
     platform/graphics/ImageBuffer.cpp
+    platform/graphics/ImageDecoder.cpp
     platform/graphics/ImageFrame.cpp
     platform/graphics/ImageFrameCache.cpp

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2017-09-18  Jer Noble  <jer.noble@apple.com>
+
+        Virtualize ImageDecoder
+        https://bugs.webkit.org/show_bug.cgi?id=176118
+
+        Reviewed by Eric Carlson.
+
+        Add an explicit, abstract base class ImageDecoder, and convert ImageDecoderCG to a true
+        subclass. This will allow multiple ImageDecoder subclasses to exist simultaneously at
+        runtime.
+
+        * CMakeLists.txt:
+        * WebCore.xcodeproj/project.pbxproj:
+        * platform/ImageDecoders.cmake:
+        * platform/graphics/ImageDecoder.cpp: Added.
+        (WebCore::ImageDecoder::create):
+        (WebCore::ImageDecoder::bytesDecodedToDetermineProperties):
+        * platform/graphics/ImageDecoder.h: Added.
+        (WebCore::ImageDecoder::isSizeAvailable):
+        (WebCore::ImageDecoder::isAllDataReceived const):
+        * platform/graphics/cg/ImageDecoderCG.cpp:
+        (WebCore::ImageDecoderCG::ImageDecoderCG):
+        (WebCore::ImageDecoderCG::bytesDecodedToDetermineProperties):
+        (WebCore::ImageDecoderCG::uti const):
+        (WebCore::ImageDecoderCG::filenameExtension const):
+        (WebCore::ImageDecoderCG::encodedDataStatus const):
+        (WebCore::ImageDecoderCG::frameCount const):
+        (WebCore::ImageDecoderCG::repetitionCount const):
+        (WebCore::ImageDecoderCG::hotSpot const):
+        (WebCore::ImageDecoderCG::frameSizeAtIndex const):
+        (WebCore::ImageDecoderCG::frameIsCompleteAtIndex const):
+        (WebCore::ImageDecoderCG::frameOrientationAtIndex const):
+        (WebCore::ImageDecoderCG::frameDurationAtIndex const):
+        (WebCore::ImageDecoderCG::frameAllowSubsamplingAtIndex const):
+        (WebCore::ImageDecoderCG::frameHasAlphaAtIndex const):
+        (WebCore::ImageDecoderCG::frameBytesAtIndex const):
+        (WebCore::ImageDecoderCG::createFrameImageAtIndex const):
+        (WebCore::ImageDecoderCG::setData):
+        (WebCore::ImageDecoder::ImageDecoder): Deleted.
+        (WebCore::ImageDecoder::bytesDecodedToDetermineProperties): Deleted.
+        (WebCore::ImageDecoder::uti const): Deleted.
+        (WebCore::ImageDecoder::filenameExtension const): Deleted.
+        (WebCore::ImageDecoder::encodedDataStatus const): Deleted.
+        (WebCore::ImageDecoder::frameCount const): Deleted.
+        (WebCore::ImageDecoder::repetitionCount const): Deleted.
+        (WebCore::ImageDecoder::hotSpot const): Deleted.
+        (WebCore::ImageDecoder::frameSizeAtIndex const): Deleted.
+        (WebCore::ImageDecoder::frameIsCompleteAtIndex const): Deleted.
+        (WebCore::ImageDecoder::frameOrientationAtIndex const): Deleted.
+        (WebCore::ImageDecoder::frameDurationAtIndex const): Deleted.
+        (WebCore::ImageDecoder::frameAllowSubsamplingAtIndex const): Deleted.
+        (WebCore::ImageDecoder::frameHasAlphaAtIndex const): Deleted.
+        (WebCore::ImageDecoder::frameBytesAtIndex const): Deleted.
+        (WebCore::ImageDecoder::createFrameImageAtIndex const): Deleted.
+        (WebCore::ImageDecoder::setData): Deleted.
+        * platform/graphics/cg/ImageDecoderCG.h:
+        (WebCore::ImageDecoderCG::create):
+        (WebCore::ImageDecoder::create): Deleted.
+        (WebCore::ImageDecoder::isSizeAvailable): Deleted.
+        (WebCore::ImageDecoder::isAllDataReceived const): Deleted.
+        (WebCore::ImageDecoder::clearFrameBufferCache): Deleted.
+        * platform/graphics/win/ImageDecoderDirect2D.cpp:
+        (WebCore::ImageDecoderDirect2D::ImageDecoderDirect2D):
+        (WebCore::ImageDecoderDirect2D::systemImagingFactory):
+        (WebCore::ImageDecoderDirect2D::bytesDecodedToDetermineProperties):
+        (WebCore::ImageDecoderDirect2D::filenameExtension const):
+        (WebCore::ImageDecoderDirect2D::isSizeAvailable const):
+        (WebCore::ImageDecoderDirect2D::encodedDataStatus const):
+        (WebCore::ImageDecoderDirect2D::size const):
+        (WebCore::ImageDecoderDirect2D::frameCount const):
+        (WebCore::ImageDecoderDirect2D::repetitionCount const):
+        (WebCore::ImageDecoderDirect2D::hotSpot const):
+        (WebCore::ImageDecoderDirect2D::frameSizeAtIndex const):
+        (WebCore::ImageDecoderDirect2D::frameIsCompleteAtIndex const):
+        (WebCore::ImageDecoderDirect2D::frameOrientationAtIndex const):
+        (WebCore::ImageDecoderDirect2D::frameDurationAtIndex const):
+        (WebCore::ImageDecoderDirect2D::frameAllowSubsamplingAtIndex const):
+        (WebCore::ImageDecoderDirect2D::frameHasAlphaAtIndex const):
+        (WebCore::ImageDecoderDirect2D::frameBytesAtIndex const):
+        (WebCore::ImageDecoderDirect2D::setTargetContext):
+        (WebCore::ImageDecoderDirect2D::createFrameImageAtIndex const):
+        (WebCore::ImageDecoderDirect2D::setData):
+        * platform/graphics/win/ImageDecoderDirect2D.h:
+        (WebCore::ImageDecoderDirect2D::create):
+        (WebCore::ImageDecoder::create): Deleted.
+        (WebCore::ImageDecoder::isAllDataReceived const): Deleted.
+        (WebCore::ImageDecoder::clearFrameBufferCache): Deleted.
+        * platform/image-decoders/ScalableImageDecoder.cpp: Renamed from Source/WebCore/platform/image-decoders/ImageDecoder.cpp.
+        (WebCore::ScalableImageDecoder::create):
+        (WebCore::ScalableImageDecoder::frameIsCompleteAtIndex const):
+        (WebCore::ScalableImageDecoder::frameHasAlphaAtIndex const):
+        (WebCore::ScalableImageDecoder::frameBytesAtIndex const):
+        (WebCore::ScalableImageDecoder::frameDurationAtIndex const):
+        (WebCore::ScalableImageDecoder::createFrameImageAtIndex):
+        (WebCore::ScalableImageDecoder::prepareScaleDataIfNecessary):
+        (WebCore::ScalableImageDecoder::upperBoundScaledX):
+        (WebCore::ScalableImageDecoder::lowerBoundScaledX):
+        (WebCore::ScalableImageDecoder::upperBoundScaledY):
+        (WebCore::ScalableImageDecoder::lowerBoundScaledY):
+        (WebCore::ScalableImageDecoder::scaledY):
+        * platform/image-decoders/ScalableImageDecoder.h: Renamed from Source/WebCore/platform/image-decoders/ImageDecoder.h.
+        (WebCore::ScalableImageDecoder::ScalableImageDecoder):
+        (WebCore::ScalableImageDecoder::~ScalableImageDecoder):
+        (WebCore::ScalableImageDecoder::premultiplyAlpha const):
+        (WebCore::ScalableImageDecoder::isAllDataReceived const):
+        (WebCore::ScalableImageDecoder::size const):
+        (WebCore::ScalableImageDecoder::scaledSize):
+        (WebCore::ScalableImageDecoder::setSize):
+        (WebCore::ScalableImageDecoder::setIgnoreGammaAndColorProfile):
+        (WebCore::ScalableImageDecoder::ignoresGammaAndColorProfile const):
+        (WebCore::ScalableImageDecoder::rgbColorProfile):
+        (WebCore::ScalableImageDecoder::subsamplingLevelForScale):
+        (WebCore::ScalableImageDecoder::inputDeviceColorProfile):
+        (WebCore::ScalableImageDecoder::setFailed):
+        (WebCore::ScalableImageDecoder::failed const):
+        * platform/image-decoders/bmp/BMPImageDecoder.cpp:
+        (WebCore::BMPImageDecoder::BMPImageDecoder):
+        (WebCore::BMPImageDecoder::setData):
+        (WebCore::BMPImageDecoder::setFailed):
+        * platform/image-decoders/bmp/BMPImageDecoder.h:
+        * platform/image-decoders/bmp/BMPImageReader.h:
+        * platform/image-decoders/gif/GIFImageDecoder.cpp:
+        (WebCore::GIFImageDecoder::GIFImageDecoder):
+        (WebCore::GIFImageDecoder::setData):
+        (WebCore::GIFImageDecoder::setSize):
+        (WebCore::GIFImageDecoder::setFailed):
+        * platform/image-decoders/gif/GIFImageDecoder.h:
+        * platform/image-decoders/ico/ICOImageDecoder.cpp:
+        (WebCore::ICOImageDecoder::ICOImageDecoder):
+        (WebCore::ICOImageDecoder::setData):
+        (WebCore::ICOImageDecoder::size):
+        (WebCore::ICOImageDecoder::setSize):
+        (WebCore::ICOImageDecoder::setFailed):
+        * platform/image-decoders/ico/ICOImageDecoder.h:
+        * platform/image-decoders/jpeg/JPEGImageDecoder.cpp:
+        (WebCore::JPEGImageDecoder::JPEGImageDecoder):
+        (WebCore::JPEGImageDecoder::setSize):
+        (WebCore::JPEGImageDecoder::setFailed):
+        * platform/image-decoders/jpeg/JPEGImageDecoder.h:
+        * platform/image-decoders/png/PNGImageDecoder.cpp:
+        (WebCore::PNGImageReader::decode):
+        (WebCore::PNGImageDecoder::PNGImageDecoder):
+        (WebCore::PNGImageDecoder::setSize):
+        (WebCore::PNGImageDecoder::frameBufferAtIndex):
+        (WebCore::PNGImageDecoder::setFailed):
+        * platform/image-decoders/png/PNGImageDecoder.h:
+        * platform/image-decoders/webp/WEBPImageDecoder.cpp:
+        (WebCore::WEBPImageDecoder::WEBPImageDecoder):
+        (WebCore::WEBPImageDecoder::decode):
+        * platform/image-decoders/webp/WEBPImageDecoder.h:
+
 2017-09-18  Andy Estes  <aestes@apple.com>
 

trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

@@ -6281 +6281 @@
                 CD127DEE14F3098400E84779 /* WebCoreFullScreenWindow.h in Headers */ = {isa = PBXBuildFile; fileRef = CD127DEA14F3097900E84779 /* WebCoreFullScreenWindow.h */; settings = {ATTRIBUTES = (Private, ); }; };
                 CD19A2681A13E700008D650E /* DiagnosticLoggingClient.h in Headers */ = {isa = PBXBuildFile; fileRef = CD19A2671A13E700008D650E /* DiagnosticLoggingClient.h */; settings = {ATTRIBUTES = (Private, ); }; };
+                CD19FEA81F573972000C42FB /* ImageDecoder.h in Headers */ = {isa = PBXBuildFile; fileRef = CD19FEA61F573972000C42FB /* ImageDecoder.h */; };
+                CD19FEA91F573972000C42FB /* ImageDecoder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = CD19FEA71F573972000C42FB /* ImageDecoder.cpp */; };
                 CD1E7347167BC78E009A885D /* TextTrackRepresentation.cpp in Sources */ = {isa = PBXBuildFile; fileRef = CD1E7346167BC78E009A885D /* TextTrackRepresentation.cpp */; };
                 CD225C0B1C46FBF400140761 /* WebCoreNSURLSession.mm in Sources */ = {isa = PBXBuildFile; fileRef = CD225C091C46FBF400140761 /* WebCoreNSURLSession.mm */; };
@@ -15025 +15027 @@
                 CD127DEB14F3097900E84779 /* WebCoreFullScreenWindow.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WebCoreFullScreenWindow.mm; sourceTree = "<group>"; };
                 CD19A2671A13E700008D650E /* DiagnosticLoggingClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DiagnosticLoggingClient.h; sourceTree = "<group>"; };
+                CD19FEA61F573972000C42FB /* ImageDecoder.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ImageDecoder.h; sourceTree = "<group>"; };
+                CD19FEA71F573972000C42FB /* ImageDecoder.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = ImageDecoder.cpp; sourceTree = "<group>"; };
                 CD1E7346167BC78E009A885D /* TextTrackRepresentation.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = TextTrackRepresentation.cpp; sourceTree = "<group>"; };
                 CD225C091C46FBF400140761 /* WebCoreNSURLSession.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WebCoreNSURLSession.mm; sourceTree = "<group>"; };
@@ -23844 +23848 @@
                                 B2A10B910B3818BD00099AA4 /* ImageBuffer.h */,
                                 22BD9F7D1353625C009BD102 /* ImageBufferData.h */,
+                                CD19FEA61F573972000C42FB /* ImageDecoder.h */,
+                                CD19FEA71F573972000C42FB /* ImageDecoder.cpp */,
                                 5576A5621D88A70800CCC04C /* ImageFrame.cpp */,
                                 5576A5631D88A70800CCC04C /* ImageFrame.h */,
@@ -28480 +28486 @@
                                 9479493A1E0459FA00018D85 /* JSDeprecatedCSSOMValueList.h in Headers */,
                                 31FB1A66120A5D3F00DC02A0 /* JSDeviceMotionEvent.h in Headers */,
+                                CD19FEA81F573972000C42FB /* ImageDecoder.h in Headers */,
                                 59A86008119DAFA100DEF1EF /* JSDeviceOrientationEvent.h in Headers */,
                                 659DDC8309E198BA001BF3C6 /* JSDocument.h in Headers */,
@@ -31456 +31463 @@
                                 E1B533471717D0A100F205F9 /* CachedSVGDocumentReference.cpp in Sources */,
                                 1C0939EA1A13E12900B788E5 /* CachedSVGFont.cpp in Sources */,
+                                CD19FEA91F573972000C42FB /* ImageDecoder.cpp in Sources */,
                                 0753860214489E9800B78452 /* CachedTextTrack.cpp in Sources */,
                                 BCB16C270979C3BD00467741 /* CachedXSLStyleSheet.cpp in Sources */,

trunk/Source/WebCore/platform/ImageDecoders.cmake

@@ -10 +10 @@
 
 list(APPEND WebCore_SOURCES
-    platform/image-decoders/ImageDecoder.cpp
+    platform/image-decoders/ScalableImageDecoder.cpp
 
     platform/image-decoders/bmp/BMPImageDecoder.cpp

trunk/Source/WebCore/platform/graphics/cg/ImageDecoderCG.cpp

@@ -148 +148 @@
 #endif
 
-ImageDecoder::ImageDecoder(SharedBuffer& data, AlphaOption, GammaAndColorProfileOption)
+ImageDecoderCG::ImageDecoderCG(SharedBuffer& data, AlphaOption, GammaAndColorProfileOption)
 {
     RetainPtr<CFStringRef> utiHint;
@@ -163 +163 @@
 }
 
-size_t ImageDecoder::bytesDecodedToDetermineProperties()
+size_t ImageDecoderCG::bytesDecodedToDetermineProperties() const
 {
     // Measured by tracing malloc/calloc calls on Mac OS 10.6.6, x86_64.
@@ -174 +174 @@
 }
     
-String ImageDecoder::uti() const
+String ImageDecoderCG::uti() const
 {
     return CGImageSourceGetType(m_nativeDecoder.get());
 }
 
-String ImageDecoder::filenameExtension() const
+String ImageDecoderCG::filenameExtension() const
 {
     return WebCore::preferredExtensionForImageSourceType(uti());
 }
 
-EncodedDataStatus ImageDecoder::encodedDataStatus() const
+EncodedDataStatus ImageDecoderCG::encodedDataStatus() const
 {
     String uti = this->uti();
@@ -228 +228 @@
 }
 
-size_t ImageDecoder::frameCount() const
+size_t ImageDecoderCG::frameCount() const
 {
     return CGImageSourceGetCount(m_nativeDecoder.get());
 }
 
-RepetitionCount ImageDecoder::repetitionCount() const
+RepetitionCount ImageDecoderCG::repetitionCount() const
 {
     RetainPtr<CFDictionaryRef> properties = adoptCF(CGImageSourceCopyProperties(m_nativeDecoder.get(), imageSourceOptions().get()));
@@ -269 +269 @@
 }
 
-std::optional<IntPoint> ImageDecoder::hotSpot() const
+std::optional<IntPoint> ImageDecoderCG::hotSpot() const
 {
     RetainPtr<CFDictionaryRef> properties = adoptCF(CGImageSourceCopyPropertiesAtIndex(m_nativeDecoder.get(), 0, imageSourceOptions().get()));
@@ -290 +290 @@
 }
 
-IntSize ImageDecoder::frameSizeAtIndex(size_t index, SubsamplingLevel subsamplingLevel) const
+IntSize ImageDecoderCG::frameSizeAtIndex(size_t index, SubsamplingLevel subsamplingLevel) const
 {
     RetainPtr<CFDictionaryRef> properties = adoptCF(CGImageSourceCopyPropertiesAtIndex(m_nativeDecoder.get(), index, imageSourceOptions(subsamplingLevel).get()));
@@ -310 +310 @@
 }
 
-bool ImageDecoder::frameIsCompleteAtIndex(size_t index) const
+bool ImageDecoderCG::frameIsCompleteAtIndex(size_t index) const
 {
     ASSERT(frameCount());
@@ -322 +322 @@
 }
 
-ImageOrientation ImageDecoder::frameOrientationAtIndex(size_t index) const
+ImageOrientation ImageDecoderCG::frameOrientationAtIndex(size_t index) const
 {
     RetainPtr<CFDictionaryRef> properties = adoptCF(CGImageSourceCopyPropertiesAtIndex(m_nativeDecoder.get(), index, imageSourceOptions().get()));
@@ -331 +331 @@
 }
 
-float ImageDecoder::frameDurationAtIndex(size_t index) const
+float ImageDecoderCG::frameDurationAtIndex(size_t index) const
 {
     float duration = 0;
@@ -365 +365 @@
 }
 
-bool ImageDecoder::frameAllowSubsamplingAtIndex(size_t) const
+bool ImageDecoderCG::frameAllowSubsamplingAtIndex(size_t) const
 {
     RetainPtr<CFDictionaryRef> properties = adoptCF(CGImageSourceCopyPropertiesAtIndex(m_nativeDecoder.get(), 0, imageSourceOptions().get()));
@@ -387 +387 @@
 }
 
-bool ImageDecoder::frameHasAlphaAtIndex(size_t index) const
+bool ImageDecoderCG::frameHasAlphaAtIndex(size_t index) const
 {
     if (!frameIsCompleteAtIndex(index))
@@ -405 +405 @@
 }
 
-unsigned ImageDecoder::frameBytesAtIndex(size_t index, SubsamplingLevel subsamplingLevel) const
+unsigned ImageDecoderCG::frameBytesAtIndex(size_t index, SubsamplingLevel subsamplingLevel) const
 {
     IntSize frameSize = frameSizeAtIndex(index, subsamplingLevel);
@@ -411 +411 @@
 }
 
-NativeImagePtr ImageDecoder::createFrameImageAtIndex(size_t index, SubsamplingLevel subsamplingLevel, const DecodingOptions& decodingOptions) const
+NativeImagePtr ImageDecoderCG::createFrameImageAtIndex(size_t index, SubsamplingLevel subsamplingLevel, const DecodingOptions& decodingOptions)
 {
     LOG(Images, "ImageDecoder %p createFrameImageAtIndex %lu", this, index);
@@ -461 +461 @@
 }
 
-void ImageDecoder::setData(SharedBuffer& data, bool allDataReceived)
+void ImageDecoderCG::setData(SharedBuffer& data, bool allDataReceived)
 {
     m_isAllDataReceived = allDataReceived;

trunk/Source/WebCore/platform/graphics/cg/ImageDecoderCG.h

@@ -26 +26 @@
 #pragma once
 
-#include "DecodingOptions.h"
-#include "ImageOrientation.h"
-#include "ImageTypes.h"
-#include "IntPoint.h"
-#include "IntSize.h"
-#include "NativeImage.h"
-#include <wtf/Optional.h>
-#include <wtf/ThreadSafeRefCounted.h>
+#include "ImageDecoder.h"
 
 namespace WebCore {
-    
-class SharedBuffer;
-    
-class ImageDecoder : public ThreadSafeRefCounted<ImageDecoder> {
+
+class ImageDecoderCG final : public ImageDecoder {
     WTF_MAKE_FAST_ALLOCATED;
 public:
-    ImageDecoder(SharedBuffer& data, AlphaOption, GammaAndColorProfileOption);
+    ImageDecoderCG(SharedBuffer& data, AlphaOption, GammaAndColorProfileOption);
 
-    static Ref<ImageDecoder> create(SharedBuffer& data, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
+    static Ref<ImageDecoderCG> create(SharedBuffer& data, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
     {
-        return adoptRef(*new ImageDecoder(data, alphaOption, gammaAndColorProfileOption));
+        return adoptRef(*new ImageDecoderCG(data, alphaOption, gammaAndColorProfileOption));
     }
     
-    static size_t bytesDecodedToDetermineProperties();
+    size_t bytesDecodedToDetermineProperties() const final;
 
-    EncodedDataStatus encodedDataStatus() const;
-    bool isSizeAvailable() { return encodedDataStatus() >= EncodedDataStatus::SizeAvailable; }
-    size_t frameCount() const;
-    RepetitionCount repetitionCount() const;
-    String uti() const;
-    String filenameExtension() const;
-    std::optional<IntPoint> hotSpot() const;
+    EncodedDataStatus encodedDataStatus() const final;
+    IntSize size() const final { return IntSize(); }
+    size_t frameCount() const final;
+    RepetitionCount repetitionCount() const final;
+    String uti() const final;
+    String filenameExtension() const final;
+    std::optional<IntPoint> hotSpot() const final;
 
-    IntSize frameSizeAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default) const;
-    bool frameIsCompleteAtIndex(size_t) const;
-    ImageOrientation frameOrientationAtIndex(size_t) const;
-    
-    float frameDurationAtIndex(size_t) const;
-    bool frameHasAlphaAtIndex(size_t) const;
-    bool frameAllowSubsamplingAtIndex(size_t) const;
-    unsigned frameBytesAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default) const;
-    
-    NativeImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, const DecodingOptions& = DecodingMode::Synchronous) const;
-    
-    void setData(SharedBuffer&, bool allDataReceived);
-    bool isAllDataReceived() const { return m_isAllDataReceived; }
-    void clearFrameBufferCache(size_t) { }
-    
+    IntSize frameSizeAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default) const final;
+    bool frameIsCompleteAtIndex(size_t) const final;
+    ImageOrientation frameOrientationAtIndex(size_t) const final;
+
+    float frameDurationAtIndex(size_t) const final;
+    bool frameHasAlphaAtIndex(size_t) const final;
+    bool frameAllowSubsamplingAtIndex(size_t) const final;
+    unsigned frameBytesAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default) const final;
+
+    NativeImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, const DecodingOptions& = DecodingMode::Synchronous) final;
+
+    void setData(SharedBuffer&, bool allDataReceived) final;
+    bool isAllDataReceived() const final { return m_isAllDataReceived; }
+    void clearFrameBufferCache(size_t) final { }
+
 protected:
     bool m_isAllDataReceived { false };

trunk/Source/WebCore/platform/graphics/win/ImageDecoderDirect2D.cpp

@@ -42 +42 @@
 namespace WebCore {
 
-ImageDecoder::ImageDecoder()
-{
-}
-
-IWICImagingFactory* ImageDecoder::systemImagingFactory()
+ImageDecoderDirect2D::ImageDecoderDirect2D()
+{
+}
+
+IWICImagingFactory* ImageDecoderDirect2D::systemImagingFactory()
 {
     static IWICImagingFactory* wicImagingFactory = nullptr;
@@ -57 +57 @@
 }
 
-size_t ImageDecoder::bytesDecodedToDetermineProperties()
+size_t ImageDecoderDirect2D::bytesDecodedToDetermineProperties()
 {
     // Set to match value used for CoreGraphics.
@@ -63 +63 @@
 }
 
-String ImageDecoder::filenameExtension() const
+String ImageDecoderDirect2D::filenameExtension() const
 {
     notImplemented();
@@ -69 +69 @@
 }
 
-bool ImageDecoder::isSizeAvailable() const
+bool ImageDecoderDirect2D::isSizeAvailable() const
 {
     return m_nativeDecoder ? true : false;
 }
 
-EncodedDataStatus ImageDecoder::encodedDataStatus() const
+EncodedDataStatus ImageDecoderDirect2D::encodedDataStatus() const
 {
     notImplemented();
@@ -80 +80 @@
 }
 
-IntSize ImageDecoder::size() const
+IntSize ImageDecoderDirect2D::size() const
 {
     if (!m_nativeDecoder)
@@ -98 +98 @@
 }
 
-size_t ImageDecoder::frameCount() const
+size_t ImageDecoderDirect2D::frameCount() const
 {
     if (!m_nativeDecoder)
@@ -111 +111 @@
 }
 
-RepetitionCount ImageDecoder::repetitionCount() const
+RepetitionCount ImageDecoderDirect2D::repetitionCount() const
 {
     return RepetitionCountNone;
 }
 
-std::optional<IntPoint> ImageDecoder::hotSpot() const
+std::optional<IntPoint> ImageDecoderDirect2D::hotSpot() const
 {
     return IntPoint();
 }
 
-IntSize ImageDecoder::frameSizeAtIndex(size_t index, SubsamplingLevel subsamplingLevel) const
+IntSize ImageDecoderDirect2D::frameSizeAtIndex(size_t index, SubsamplingLevel subsamplingLevel) const
 {
     if (!m_nativeDecoder)
@@ -139 +139 @@
 }
 
-bool ImageDecoder::frameIsCompleteAtIndex(size_t index) const
+bool ImageDecoderDirect2D::frameIsCompleteAtIndex(size_t index) const
 {
     if (!m_nativeDecoder)
@@ -149 +149 @@
 }
 
-ImageOrientation ImageDecoder::frameOrientationAtIndex(size_t index) const
+ImageOrientation ImageDecoderDirect2D::frameOrientationAtIndex(size_t index) const
 {
     notImplemented();
@@ -155 +155 @@
 }
 
-float ImageDecoder::frameDurationAtIndex(size_t index) const
+float ImageDecoderDirect2D::frameDurationAtIndex(size_t index) const
 {
     notImplemented();
@@ -161 +161 @@
 }
 
-bool ImageDecoder::frameAllowSubsamplingAtIndex(size_t) const
+bool ImageDecoderDirect2D::frameAllowSubsamplingAtIndex(size_t) const
 {
     notImplemented();
@@ -167 +167 @@
 }
 
-bool ImageDecoder::frameHasAlphaAtIndex(size_t index) const
+bool ImageDecoderDirect2D::frameHasAlphaAtIndex(size_t index) const
 {
     notImplemented();
@@ -173 +173 @@
 }
 
-unsigned ImageDecoder::frameBytesAtIndex(size_t index, SubsamplingLevel subsamplingLevel) const
+unsigned ImageDecoderDirect2D::frameBytesAtIndex(size_t index, SubsamplingLevel subsamplingLevel) const
 {
     if (!m_nativeDecoder)
@@ -182 +182 @@
 }
 
-void ImageDecoder::setTargetContext(ID2D1RenderTarget* renderTarget)
+void ImageDecoderDirect2D::setTargetContext(ID2D1RenderTarget* renderTarget)
 {
     m_renderTarget = renderTarget;
 }
 
-NativeImagePtr ImageDecoder::createFrameImageAtIndex(size_t index, SubsamplingLevel subsamplingLevel, const DecodingOptions&) const
+NativeImagePtr ImageDecoderDirect2D::createFrameImageAtIndex(size_t index, SubsamplingLevel subsamplingLevel, const DecodingOptions&) const
 {
     if (!m_nativeDecoder || !m_renderTarget)
@@ -214 +214 @@
 }
 
-void ImageDecoder::setData(SharedBuffer& data, bool allDataReceived)
+void ImageDecoderDirect2D::setData(SharedBuffer& data, bool allDataReceived)
 {
     if (!allDataReceived)

trunk/Source/WebCore/platform/graphics/win/ImageDecoderDirect2D.h

@@ -26 +26 @@
 #pragma once
 
+#if USE(DIRECT2D)
+
 #include "COMPtr.h"
-#include "ImageSource.h"
-#include "IntSize.h"
+#include "ImageDecoder.h"
 #include <wtf/Optional.h>
 
@@ -37 +38 @@
 namespace WebCore {
 
-class ImageDecoder : public ThreadSafeRefCounted<ImageDecoder> {
+class ImageDecoderDirect2D final : public ImageDecoder {
     WTF_MAKE_FAST_ALLOCATED;
 public:
-    ImageDecoder();
-    
-    static Ref<ImageDecoder> create(SharedBuffer&, AlphaOption, GammaAndColorProfileOption)
+    ImageDecoderDirect2D();
+
+    static Ref<ImageDecoderDirect2D> create(SharedBuffer&, AlphaOption, GammaAndColorProfileOption)
     {
-        return adoptRef(*new ImageDecoder());
+        return adoptRef(*new ImageDecoderDirect2D());
     }
-    
+
     static size_t bytesDecodedToDetermineProperties();
-    
-    String filenameExtension() const;
-    EncodedDataStatus encodedDataStatus() const;
-    bool isSizeAvailable() const;
-    
+
+    String filenameExtension() const final;
+    EncodedDataStatus encodedDataStatus() const final;
+    bool isSizeAvailable() const final;
+
     // Always original size, without subsampling.
-    IntSize size() const;
-    size_t frameCount() const;
+    IntSize size() const final;
+    size_t frameCount() const final;
 
-    RepetitionCount repetitionCount() const;
-    std::optional<IntPoint> hotSpot() const;
-    
-    IntSize frameSizeAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default) const;
-    bool frameIsCompleteAtIndex(size_t) const;
-    ImageOrientation frameOrientationAtIndex(size_t) const;
-    
-    float frameDurationAtIndex(size_t) const;
-    bool frameHasAlphaAtIndex(size_t) const;
-    bool frameAllowSubsamplingAtIndex(size_t) const;
-    unsigned frameBytesAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default) const;
-    
-    NativeImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, const DecodingOptions& = DecodingMode::Synchronous) const;
-    
-    void setData(SharedBuffer&, bool allDataReceived);
-    bool isAllDataReceived() const { return m_isAllDataReceived; }
-    void clearFrameBufferCache(size_t) { }
+    RepetitionCount repetitionCount() const final;
+    std::optional<IntPoint> hotSpot() const final;
+
+    IntSize frameSizeAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default) const final;
+    bool frameIsCompleteAtIndex(size_t) const final;
+    ImageOrientation frameOrientationAtIndex(size_t) const final;
+
+    float frameDurationAtIndex(size_t) const final;
+    bool frameHasAlphaAtIndex(size_t) const final;
+    bool frameAllowSubsamplingAtIndex(size_t) const final;
+    unsigned frameBytesAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default) const final;
+
+    NativeImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, const DecodingOptions& = DecodingMode::Synchronous) const final;
+
+    void setData(SharedBuffer&, bool allDataReceived) final;
+    bool isAllDataReceived() const final { return m_isAllDataReceived; }
+    void clearFrameBufferCache(size_t) final { }
 
     void setTargetContext(ID2D1RenderTarget*);
@@ -87 +88 @@
 
 }
+
+#endif

trunk/Source/WebCore/platform/image-decoders/ScalableImageDecoder.cpp

@@ -22 +22 @@
 
 #include "config.h"
-#include "ImageDecoder.h"
+#include "ScalableImageDecoder.h"
 
 #include "BMPImageDecoder.h"
@@ -99 +99 @@
 }
 
-RefPtr<ImageDecoder> ImageDecoder::create(SharedBuffer& data, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
+RefPtr<ScalableImageDecoder> ScalableImageDecoder::create(SharedBuffer& data, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
 {
     static const unsigned lengthOfLongestSignature = 14; // To wit: "RIFF????WEBPVP"
@@ -171 +171 @@
 }
 
-bool ImageDecoder::frameIsCompleteAtIndex(size_t index)
-{
-    ImageFrame* buffer = frameBufferAtIndex(index);
+bool ScalableImageDecoder::frameIsCompleteAtIndex(size_t index) const
+{
+    // FIXME(176089): asking whether enough data has been appended for a decode
+    // operation to succeed should not require decoding the entire frame.
+    // This function should be implementable in a way that allows const.
+    ImageFrame* buffer = const_cast<ScalableImageDecoder*>(this)->frameBufferAtIndex(index);
     return buffer && buffer->isComplete();
 }
 
-bool ImageDecoder::frameHasAlphaAtIndex(size_t index) const
+bool ScalableImageDecoder::frameHasAlphaAtIndex(size_t index) const
 {
     if (m_frameBufferCache.size() <= index)
@@ -186 +189 @@
 }
 
-unsigned ImageDecoder::frameBytesAtIndex(size_t index) const
+unsigned ScalableImageDecoder::frameBytesAtIndex(size_t index, SubsamplingLevel) const
 {
     if (m_frameBufferCache.size() <= index)
@@ -194 +197 @@
 }
 
-float ImageDecoder::frameDurationAtIndex(size_t index)
-{
-    ImageFrame* buffer = frameBufferAtIndex(index);
+float ScalableImageDecoder::frameDurationAtIndex(size_t index) const
+{
+    // FIXME(176089): asking for the duration of a sub-image should not require decoding
+    // the entire frame. This function should be implementable in a way that
+    // allows const.
+    ImageFrame* buffer = const_cast<ScalableImageDecoder*>(this)->frameBufferAtIndex(index);
     if (!buffer || buffer->isInvalid())
         return 0;
@@ -210 +216 @@
 }
 
-NativeImagePtr ImageDecoder::createFrameImageAtIndex(size_t index, SubsamplingLevel, const DecodingOptions&)
+NativeImagePtr ScalableImageDecoder::createFrameImageAtIndex(size_t index, SubsamplingLevel, const DecodingOptions&)
 {
     // Zero-height images can cause problems for some ports. If we have an empty image dimension, just bail.
@@ -225 +231 @@
 }
 
-void ImageDecoder::prepareScaleDataIfNecessary()
+void ScalableImageDecoder::prepareScaleDataIfNecessary()
 {
     m_scaled = false;
@@ -243 +249 @@
 }
 
-int ImageDecoder::upperBoundScaledX(int origX, int searchStart)
+int ScalableImageDecoder::upperBoundScaledX(int origX, int searchStart)
 {
     return getScaledValue<UpperBound>(m_scaledColumns, origX, searchStart);
 }
 
-int ImageDecoder::lowerBoundScaledX(int origX, int searchStart)
+int ScalableImageDecoder::lowerBoundScaledX(int origX, int searchStart)
 {
     return getScaledValue<LowerBound>(m_scaledColumns, origX, searchStart);
 }
 
-int ImageDecoder::upperBoundScaledY(int origY, int searchStart)
+int ScalableImageDecoder::upperBoundScaledY(int origY, int searchStart)
 {
     return getScaledValue<UpperBound>(m_scaledRows, origY, searchStart);
 }
 
-int ImageDecoder::lowerBoundScaledY(int origY, int searchStart)
+int ScalableImageDecoder::lowerBoundScaledY(int origY, int searchStart)
 {
     return getScaledValue<LowerBound>(m_scaledRows, origY, searchStart);
 }
 
-int ImageDecoder::scaledY(int origY, int searchStart)
+int ScalableImageDecoder::scaledY(int origY, int searchStart)
 {
     return getScaledValue<Exact>(m_scaledRows, origY, searchStart);

trunk/Source/WebCore/platform/image-decoders/ScalableImageDecoder.h

@@ -29 +29 @@
 #pragma once
 
+#include "ImageDecoder.h"
 #include "ImageFrame.h"
 #include "IntRect.h"
-#include "IntSize.h"
 #include "SharedBuffer.h"
 #include <wtf/Assertions.h>
-#include <wtf/Optional.h>
 #include <wtf/RefPtr.h>
 #include <wtf/Vector.h>
@@ -41 +40 @@
 namespace WebCore {
 
-// ImageDecoder is a base for all format-specific decoders
+// ScalableImageDecoder is a base for all format-specific decoders
 // (e.g. JPEGImageDecoder). This base manages the ImageFrame cache.
 //
@@ -47 +46 @@
 // at decode time. Image decoders will downsample any images larger than
 // |m_maxNumPixels|. FIXME: Not yet supported by all decoders.
-class ImageDecoder : public ThreadSafeRefCounted<ImageDecoder> {
-    WTF_MAKE_NONCOPYABLE(ImageDecoder); WTF_MAKE_FAST_ALLOCATED;
+class ScalableImageDecoder : public ImageDecoder {
+    WTF_MAKE_NONCOPYABLE(ScalableImageDecoder); WTF_MAKE_FAST_ALLOCATED;
 public:
-    ImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
+    ScalableImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
         : m_premultiplyAlpha(alphaOption == AlphaOption::Premultiplied)
         , m_ignoreGammaAndColorProfile(gammaAndColorProfileOption == GammaAndColorProfileOption::Ignored)
@@ -56 +55 @@
     }
 
-    virtual ~ImageDecoder()
+    virtual ~ScalableImageDecoder()
     {
     }
@@ -62 +61 @@
     // Returns nullptr if we can't sniff a supported type from the provided data (possibly
     // because there isn't enough data yet).
-    static RefPtr<ImageDecoder> create(SharedBuffer& data, AlphaOption, GammaAndColorProfileOption);
-
-    virtual String filenameExtension() const = 0;
+    static RefPtr<ScalableImageDecoder> create(SharedBuffer& data, AlphaOption, GammaAndColorProfileOption);
 
     bool premultiplyAlpha() const { return m_premultiplyAlpha; }
 
-    bool isAllDataReceived() const
+    bool isAllDataReceived() const override
     {
         ASSERT(!m_decodingSizeFromSetData);
@@ -74 +71 @@
     }
 
-    virtual void setData(SharedBuffer& data, bool allDataReceived)
+    void setData(SharedBuffer& data, bool allDataReceived) override
     {
         if (m_encodedDataStatus == EncodedDataStatus::Error)
@@ -95 +92 @@
     }
 
-    EncodedDataStatus encodedDataStatus() const { return m_encodedDataStatus; }
-
-    bool isSizeAvailable() { return m_encodedDataStatus >= EncodedDataStatus::SizeAvailable; }
-
-    virtual IntSize size() { return isSizeAvailable() ? m_size : IntSize(); }
+    EncodedDataStatus encodedDataStatus() const override { return m_encodedDataStatus; }
+
+    bool isSizeAvailable() const override { return m_encodedDataStatus >= EncodedDataStatus::SizeAvailable; }
+
+    IntSize size() const override { return isSizeAvailable() ? m_size : IntSize(); }
 
     IntSize scaledSize()
@@ -111 +108 @@
     // composites any smaller frames against previous frames to create full-
     // size frames.
-    virtual IntSize frameSizeAtIndex(size_t, SubsamplingLevel)
+    IntSize frameSizeAtIndex(size_t, SubsamplingLevel) const override
     {
         return size();
@@ -131 +128 @@
     // FIXME: Right now that has to be done by each subclass; factor the
     // decode call out and use it here.
-    virtual size_t frameCount() const { return 1; }
-
-    virtual RepetitionCount repetitionCount() const { return RepetitionCountNone; }
+    size_t frameCount() const override { return 1; }
+
+    RepetitionCount repetitionCount() const override { return RepetitionCountNone; }
 
     // Decodes as much of the requested frame as possible, and returns an
-    // ImageDecoder-owned pointer.
+    // ScalableImageDecoder-owned pointer.
     virtual ImageFrame* frameBufferAtIndex(size_t) = 0;
 
-    bool frameIsCompleteAtIndex(size_t);
+    bool frameIsCompleteAtIndex(size_t) const override;
 
     // Make the best effort guess to check if the requested frame has alpha channel.
-    bool frameHasAlphaAtIndex(size_t) const;
+    bool frameHasAlphaAtIndex(size_t) const override;
 
     // Number of bytes in the decoded frame requested. Return 0 if not yet decoded.
-    unsigned frameBytesAtIndex(size_t) const;
-    
-    float frameDurationAtIndex(size_t);
-    
-    NativeImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, const DecodingOptions& = DecodingMode::Synchronous);
+    unsigned frameBytesAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default) const override;
+
+    float frameDurationAtIndex(size_t) const override;
+
+    NativeImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, const DecodingOptions& = DecodingMode::Synchronous) override;
 
     void setIgnoreGammaAndColorProfile(bool flag) { m_ignoreGammaAndColorProfile = flag; }
     bool ignoresGammaAndColorProfile() const { return m_ignoreGammaAndColorProfile; }
 
-    ImageOrientation frameOrientationAtIndex(size_t) const { return m_orientation; }
-    
-    bool frameAllowSubsamplingAtIndex(size_t) const { return false; }
+    ImageOrientation frameOrientationAtIndex(size_t) const override { return m_orientation; }
+
+    bool frameAllowSubsamplingAtIndex(size_t) const override { return false; }
 
     enum { ICCColorProfileHeaderLength = 128 };
@@ -167 +164 @@
     }
 
-    static size_t bytesDecodedToDetermineProperties() { return 0; }
-    
+    size_t bytesDecodedToDetermineProperties() const final { return 0; }
+
     static SubsamplingLevel subsamplingLevelForScale(float, SubsamplingLevel) { return SubsamplingLevel::Default; }
 
@@ -193 +190 @@
     // data may be needed to decode future frames (e.g. due to GIF frame
     // compositing).
-    virtual void clearFrameBufferCache(size_t) { }
+    void clearFrameBufferCache(size_t) override { }
 
     // If the image has a cursor hot-spot, stores it in the argument
     // and returns true. Otherwise returns false.
-    virtual std::optional<IntPoint> hotSpot() const { return std::nullopt; }
+    std::optional<IntPoint> hotSpot() const override { return std::nullopt; }
 
 protected:

trunk/Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.cpp

@@ -42 +42 @@
 
 BMPImageDecoder::BMPImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
-    : ImageDecoder(alphaOption, gammaAndColorProfileOption)
+    : ScalableImageDecoder(alphaOption, gammaAndColorProfileOption)
     , m_decodedOffset(0)
 {
@@ -52 +52 @@
         return;
 
-    ImageDecoder::setData(data, allDataReceived);
+    ScalableImageDecoder::setData(data, allDataReceived);
     if (m_reader)
         m_reader->setData(&data);
@@ -74 +74 @@
 {
     m_reader = nullptr;
-    return ImageDecoder::setFailed();
+    return ScalableImageDecoder::setFailed();
 }
 

trunk/Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.h

@@ -35 +35 @@
 namespace WebCore {
 
-    // This class decodes the BMP image format.
-    class BMPImageDecoder final : public ImageDecoder {
-    public:
-        static Ref<ImageDecoder> create(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
-        {
-            return adoptRef(*new BMPImageDecoder(alphaOption, gammaAndColorProfileOption));
-        }
+// This class decodes the BMP image format.
+class BMPImageDecoder final : public ScalableImageDecoder {
+public:
+    static Ref<ScalableImageDecoder> create(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
+    {
+        return adoptRef(*new BMPImageDecoder(alphaOption, gammaAndColorProfileOption));
+    }
 
-        // ImageDecoder
-        String filenameExtension() const override { return ASCIILiteral("bmp"); }
-        void setData(SharedBuffer&, bool allDataReceived) override;
-        ImageFrame* frameBufferAtIndex(size_t index) override;
-        // CAUTION: setFailed() deletes |m_reader|.  Be careful to avoid
-        // accessing deleted memory, especially when calling this from inside
-        // BMPImageReader!
-        bool setFailed() override;
+    // ScalableImageDecoder
+    String filenameExtension() const final { return ASCIILiteral("bmp"); }
+    void setData(SharedBuffer&, bool allDataReceived) final;
+    ImageFrame* frameBufferAtIndex(size_t index) final;
+    // CAUTION: setFailed() deletes |m_reader|. Be careful to avoid
+    // accessing deleted memory, especially when calling this from inside
+    // BMPImageReader!
+    bool setFailed() final;
 
-    private:
-        BMPImageDecoder(AlphaOption, GammaAndColorProfileOption);
-        void tryDecodeSize(bool allDataReceived) override { decode(true, allDataReceived); }
+private:
+    BMPImageDecoder(AlphaOption, GammaAndColorProfileOption);
+    void tryDecodeSize(bool allDataReceived) final { decode(true, allDataReceived); }
 
-        inline uint32_t readUint32(int offset) const
-        {
-            return BMPImageReader::readUint32(m_data.get(), m_decodedOffset + offset);
-        }
+    inline uint32_t readUint32(int offset) const
+    {
+        return BMPImageReader::readUint32(m_data.get(), m_decodedOffset + offset);
+    }
 
-        // Decodes the image.  If |onlySize| is true, stops decoding after
-        // calculating the image size.  If decoding fails but there is no more
-        // data coming, sets the "decode failure" flag.
-        void decode(bool onlySize, bool allDataReceived);
+    // Decodes the image. If |onlySize| is true, stops decoding after
+    // calculating the image size. If decoding fails but there is no more
+    // data coming, sets the "decode failure" flag.
+    void decode(bool onlySize, bool allDataReceived);
 
-        // Decodes the image.  If |onlySize| is true, stops decoding after
-        // calculating the image size.  Returns whether decoding succeeded.
-        bool decodeHelper(bool onlySize);
+    // Decodes the image. If |onlySize| is true, stops decoding after
+    // calculating the image size. Returns whether decoding succeeded.
+    bool decodeHelper(bool onlySize);
 
-        // Processes the file header at the beginning of the data.  Sets
-        // |*imgDataOffset| based on the header contents.  Returns true if the
-        // file header could be decoded.
-        bool processFileHeader(size_t* imgDataOffset);
+    // Processes the file header at the beginning of the data. Sets
+    // |*imgDataOffset| based on the header contents. Returns true if the
+    // file header could be decoded.
+    bool processFileHeader(size_t* imgDataOffset);
 
-        // An index into |m_data| representing how much we've already decoded.
-        // Note that this only tracks data _this_ class decodes; once the
-        // BMPImageReader takes over this will not be updated further.
-        size_t m_decodedOffset;
+    // An index into |m_data| representing how much we've already decoded.
+    // Note that this only tracks data _this_ class decodes; once the
+    // BMPImageReader takes over this will not be updated further.
+    size_t m_decodedOffset;
 
-        // The reader used to do most of the BMP decoding.
-        std::unique_ptr<BMPImageReader> m_reader;
-    };
+    // The reader used to do most of the BMP decoding.
+    std::unique_ptr<BMPImageReader> m_reader;
+};
 
 } // namespace WebCore

trunk/Source/WebCore/platform/image-decoders/bmp/BMPImageReader.cpp

@@ -34 +34 @@
 namespace WebCore {
 
-BMPImageReader::BMPImageReader(ImageDecoder* parent, size_t decodedAndHeaderOffset, size_t imgDataOffset, bool usesAndMask)
+BMPImageReader::BMPImageReader(ScalableImageDecoder* parent, size_t decodedAndHeaderOffset, size_t imgDataOffset, bool usesAndMask)
     : m_parent(parent)
     , m_buffer(0)

trunk/Source/WebCore/platform/image-decoders/bmp/BMPImageReader.h

@@ -29 +29 @@
  */
 
-#ifndef BMPImageReader_h
-#define BMPImageReader_h
-
+#pragma once
+
+#include "ScalableImageDecoder.h"
 #include <stdint.h>
-#include "ImageDecoder.h"
 
 namespace WebCore {
 
-    // This class decodes a BMP image.  It is used in the BMP and ICO decoders,
-    // which wrap it in the appropriate code to read file headers, etc.
-    class BMPImageReader {
-        WTF_MAKE_FAST_ALLOCATED;
-    public:
-        // Read a value from |data[offset]|, converting from little to native
-        // endianness.
-        static inline uint16_t readUint16(SharedBuffer* data, int offset)
-        {
-            uint16_t result;
-            memcpy(&result, &data->data()[offset], 2);
-        #if CPU(BIG_ENDIAN)
-            result = ((result & 0xff) << 8) | ((result & 0xff00) >> 8);
-        #endif
-            return result;
+// This class decodes a BMP image. It is used in the BMP and ICO decoders,
+// which wrap it in the appropriate code to read file headers, etc.
+class BMPImageReader {
+    WTF_MAKE_FAST_ALLOCATED;
+public:
+    // Read a value from |data[offset]|, converting from little to native
+    // endianness.
+    static inline uint16_t readUint16(SharedBuffer* data, int offset)
+    {
+        uint16_t result;
+        memcpy(&result, &data->data()[offset], 2);
+#if CPU(BIG_ENDIAN)
+        result = ((result & 0xff) << 8) | ((result & 0xff00) >> 8);
+#endif
+        return result;
+    }
+
+    static inline uint32_t readUint32(SharedBuffer* data, int offset)
+    {
+        uint32_t result;
+        memcpy(&result, &data->data()[offset], 4);
+#if CPU(BIG_ENDIAN)
+        result = ((result & 0xff) << 24) | ((result & 0xff00) << 8) | ((result & 0xff0000) >> 8) | ((result & 0xff000000) >> 24);
+#endif
+        return result;
+    }
+
+    // |parent| is the decoder that owns us.
+    // |startOffset| points to the start of the BMP within the file.
+    // |buffer| points at an empty ImageFrame that we'll initialize and
+    // fill with decoded data.
+    BMPImageReader(ScalableImageDecoder* parent, size_t decodedAndHeaderOffset, size_t imgDataOffset, bool usesAndMask);
+
+    void setBuffer(ImageFrame* buffer) { m_buffer = buffer; }
+    void setData(SharedBuffer* data) { m_data = data; }
+
+    // Does the actual decoding. If |onlySize| is true, decoding only
+    // progresses as far as necessary to get the image size. Returns
+    // whether decoding succeeded.
+    bool decodeBMP(bool onlySize);
+
+private:
+    // The various BMP compression types. We don't currently decode all
+    // these.
+    enum CompressionType {
+        // Universal types
+        RGB = 0,
+        RLE8 = 1,
+        RLE4 = 2,
+        // Windows V3+ only
+        BITFIELDS = 3,
+        JPEG = 4,
+        PNG = 5,
+        // OS/2 2.x-only
+        HUFFMAN1D, // Stored in file as 3
+        RLE24, // Stored in file as 4
+    };
+    enum AndMaskState {
+        None,
+        NotYetDecoded,
+        Decoding,
+    };
+    enum ProcessingResult {
+        Success,
+        Failure,
+        InsufficientData,
+    };
+
+    // These are based on the Windows BITMAPINFOHEADER and RGBTRIPLE
+    // structs, but with unnecessary entries removed.
+    struct BitmapInfoHeader {
+        uint32_t biSize;
+        int32_t biWidth;
+        int32_t biHeight;
+        uint16_t biBitCount;
+        CompressionType biCompression;
+        uint32_t biClrUsed;
+    };
+    struct RGBTriple {
+        uint8_t rgbBlue;
+        uint8_t rgbGreen;
+        uint8_t rgbRed;
+    };
+
+    inline uint16_t readUint16(int offset) const
+    {
+        return readUint16(m_data.get(), m_decodedOffset + offset);
+    }
+
+    inline uint32_t readUint32(int offset) const
+    {
+        return readUint32(m_data.get(), m_decodedOffset + offset);
+    }
+
+    // Determines the size of the BMP info header. Returns true if the size
+    // is valid.
+    bool readInfoHeaderSize();
+
+    // Processes the BMP info header. Returns true if the info header could
+    // be decoded.
+    bool processInfoHeader();
+
+    // Helper function for processInfoHeader() which does the actual reading
+    // of header values from the byte stream. Returns false on error.
+    bool readInfoHeader();
+
+    // Returns true if this is a Windows V4+ BMP.
+    inline bool isWindowsV4Plus() const
+    {
+        // Windows V4 info header is 108 bytes. V5 is 124 bytes.
+        return (m_infoHeader.biSize == 108) || (m_infoHeader.biSize == 124);
+    }
+
+    // Returns false if consistency errors are found in the info header.
+    bool isInfoHeaderValid() const;
+
+    // For BI_BITFIELDS images, initializes the m_bitMasks[] and
+    // m_bitOffsets[] arrays. processInfoHeader() will initialize these for
+    // other compression types where needed.
+    bool processBitmasks();
+
+    // For paletted images, allocates and initializes the m_colorTable[]
+    // array.
+    bool processColorTable();
+
+    // Processes an RLE-encoded image. Returns true if the entire image was
+    // decoded.
+    bool processRLEData();
+
+    // Processes a set of non-RLE-compressed pixels. Two cases:
+    //   * inRLE = true: the data is inside an RLE-encoded bitmap. Tries to
+    //     process |numPixels| pixels on the current row.
+    //   * inRLE = false: the data is inside a non-RLE-encoded bitmap.
+    //     |numPixels| is ignored. Expects |m_coord| to point at the
+    //     beginning of the next row to be decoded. Tries to process as
+    //     many complete rows as possible. Returns InsufficientData if
+    //     there wasn't enough data to decode the whole image.
+    //
+    // This function returns a ProcessingResult instead of a bool so that it
+    // can avoid calling m_parent->setFailed(), which could lead to memory
+    // corruption since that will delete |this| but some callers still want
+    // to access member variables after this returns.
+    ProcessingResult processNonRLEData(bool inRLE, int numPixels);
+
+    // Returns true if the current y-coordinate plus |numRows| would be past
+    // the end of the image. Here "plus" means "toward the end of the
+    // image", so downwards for m_isTopDown images and upwards otherwise.
+    inline bool pastEndOfImage(int numRows)
+    {
+        return m_isTopDown ? ((m_coord.y() + numRows) >= m_parent->size().height()) : ((m_coord.y() - numRows) < 0);
+    }
+
+    // Returns the pixel data for the current X coordinate in a uint32_t.
+    // Assumes m_decodedOffset has been set to the beginning of the current
+    // row.
+    // NOTE: Only as many bytes of the return value as are needed to hold
+    // the pixel data will actually be set.
+    inline uint32_t readCurrentPixel(int bytesPerPixel) const
+    {
+        const int offset = m_coord.x() * bytesPerPixel;
+        switch (bytesPerPixel) {
+        case 2:
+            return readUint16(offset);
+
+        case 3: {
+            // It doesn't matter that we never set the most significant byte
+            // of the return value here in little-endian mode, the caller
+            // won't read it.
+            uint32_t pixel;
+            memcpy(&pixel, &m_data->data()[m_decodedOffset + offset], 3);
+#if CPU(BIG_ENDIAN)
+            pixel = ((pixel & 0xff00) << 8) | ((pixel & 0xff0000) >> 8) | ((pixel & 0xff000000) >> 24);
+#endif
+            return pixel;
         }
 
-        static inline uint32_t readUint32(SharedBuffer* data, int offset)
-        {
-            uint32_t result;
-            memcpy(&result, &data->data()[offset], 4);
-        #if CPU(BIG_ENDIAN)
-            result = ((result & 0xff) << 24) | ((result & 0xff00) << 8) | ((result & 0xff0000) >> 8) | ((result & 0xff000000) >> 24);
-        #endif
-            return result;
+        case 4:
+            return readUint32(offset);
+
+        default:
+            ASSERT_NOT_REACHED();
+            return 0;
         }
-
-        // |parent| is the decoder that owns us.
-        // |startOffset| points to the start of the BMP within the file.
-        // |buffer| points at an empty ImageFrame that we'll initialize and
-        // fill with decoded data.
-        BMPImageReader(ImageDecoder* parent, size_t decodedAndHeaderOffset, size_t imgDataOffset, bool usesAndMask);
-
-        void setBuffer(ImageFrame* buffer) { m_buffer = buffer; }
-        void setData(SharedBuffer* data) { m_data = data; }
-
-        // Does the actual decoding.  If |onlySize| is true, decoding only
-        // progresses as far as necessary to get the image size.  Returns
-        // whether decoding succeeded.
-        bool decodeBMP(bool onlySize);
-
-    private:
-        // The various BMP compression types.  We don't currently decode all
-        // these.
-        enum CompressionType {
-            // Universal types
-            RGB = 0,
-            RLE8 = 1,
-            RLE4 = 2,
-            // Windows V3+ only
-            BITFIELDS = 3,
-            JPEG = 4,
-            PNG = 5,
-            // OS/2 2.x-only
-            HUFFMAN1D,  // Stored in file as 3
-            RLE24,      // Stored in file as 4
-        };
-        enum AndMaskState {
-            None,
-            NotYetDecoded,
-            Decoding,
-        };
-        enum ProcessingResult {
-            Success,
-            Failure,
-            InsufficientData,
-        };
-
-        // These are based on the Windows BITMAPINFOHEADER and RGBTRIPLE
-        // structs, but with unnecessary entries removed.
-        struct BitmapInfoHeader {
-            uint32_t biSize;
-            int32_t biWidth;
-            int32_t biHeight;
-            uint16_t biBitCount;
-            CompressionType biCompression;
-            uint32_t biClrUsed;
-        };
-        struct RGBTriple {
-            uint8_t rgbBlue;
-            uint8_t rgbGreen;
-            uint8_t rgbRed;
-        };
-
-        inline uint16_t readUint16(int offset) const
-        {
-            return readUint16(m_data.get(), m_decodedOffset + offset);
-        }
-
-        inline uint32_t readUint32(int offset) const
-        {
-            return readUint32(m_data.get(), m_decodedOffset + offset);
-        }
-
-        // Determines the size of the BMP info header.  Returns true if the size
-        // is valid.
-        bool readInfoHeaderSize();
-
-        // Processes the BMP info header.  Returns true if the info header could
-        // be decoded.
-        bool processInfoHeader();
-
-        // Helper function for processInfoHeader() which does the actual reading
-        // of header values from the byte stream.  Returns false on error.
-        bool readInfoHeader();
-
-        // Returns true if this is a Windows V4+ BMP.
-        inline bool isWindowsV4Plus() const
-        {
-            // Windows V4 info header is 108 bytes.  V5 is 124 bytes.
-            return (m_infoHeader.biSize == 108) || (m_infoHeader.biSize == 124);
-        }
-
-        // Returns false if consistency errors are found in the info header.
-        bool isInfoHeaderValid() const;
-
-        // For BI_BITFIELDS images, initializes the m_bitMasks[] and
-        // m_bitOffsets[] arrays.  processInfoHeader() will initialize these for
-        // other compression types where needed.
-        bool processBitmasks();
-
-        // For paletted images, allocates and initializes the m_colorTable[]
-        // array.
-        bool processColorTable();
-
-        // Processes an RLE-encoded image.  Returns true if the entire image was
-        // decoded.
-        bool processRLEData();
-
-        // Processes a set of non-RLE-compressed pixels.  Two cases:
-        //   * inRLE = true: the data is inside an RLE-encoded bitmap.  Tries to
-        //     process |numPixels| pixels on the current row.
-        //   * inRLE = false: the data is inside a non-RLE-encoded bitmap.
-        //     |numPixels| is ignored.  Expects |m_coord| to point at the
-        //     beginning of the next row to be decoded.  Tries to process as
-        //     many complete rows as possible.  Returns InsufficientData if
-        //     there wasn't enough data to decode the whole image.
-        //
-        // This function returns a ProcessingResult instead of a bool so that it
-        // can avoid calling m_parent->setFailed(), which could lead to memory
-        // corruption since that will delete |this| but some callers still want
-        // to access member variables after this returns.
-        ProcessingResult processNonRLEData(bool inRLE, int numPixels);
-
-        // Returns true if the current y-coordinate plus |numRows| would be past
-        // the end of the image.  Here "plus" means "toward the end of the
-        // image", so downwards for m_isTopDown images and upwards otherwise.
-        inline bool pastEndOfImage(int numRows)
-        {
-            return m_isTopDown ? ((m_coord.y() + numRows) >= m_parent->size().height()) : ((m_coord.y() - numRows) < 0);
-        }
-
-        // Returns the pixel data for the current X coordinate in a uint32_t.
-        // Assumes m_decodedOffset has been set to the beginning of the current
-        // row.
-        // NOTE: Only as many bytes of the return value as are needed to hold
-        // the pixel data will actually be set.
-        inline uint32_t readCurrentPixel(int bytesPerPixel) const
-        {
-            const int offset = m_coord.x() * bytesPerPixel;
-            switch (bytesPerPixel) {
-            case 2:
-                return readUint16(offset);
-
-            case 3: {
-                // It doesn't matter that we never set the most significant byte
-                // of the return value here in little-endian mode, the caller
-                // won't read it.
-                uint32_t pixel;
-                memcpy(&pixel, &m_data->data()[m_decodedOffset + offset], 3);
-        #if CPU(BIG_ENDIAN)
-                pixel = ((pixel & 0xff00) << 8) | ((pixel & 0xff0000) >> 8) | ((pixel & 0xff000000) >> 24);
-        #endif
-                return pixel;
-            }
-
-            case 4:
-                return readUint32(offset);
-
-            default:
-                ASSERT_NOT_REACHED();
-                return 0;
-            }
-        }
-
-        // Returns the value of the desired component (0, 1, 2, 3 == R, G, B, A)
-        // in the given pixel data.
-        inline unsigned getComponent(uint32_t pixel, int component) const
-        {
-            return ((pixel & m_bitMasks[component]) >> m_bitShiftsRight[component]) << m_bitShiftsLeft[component];
-        }
-
-        inline unsigned getAlpha(uint32_t pixel) const
-        {
-            // For images without alpha, return alpha of 0xff.
-            return m_bitMasks[3] ? getComponent(pixel, 3) : 0xff;
-        }
-
-        // Sets the current pixel to the color given by |colorIndex|.  This also
-        // increments the relevant local variables to move the current pixel
-        // right by one.
-        inline void setI(size_t colorIndex)
-        {
-            setPixel(m_colorTable[colorIndex].rgbRed, m_colorTable[colorIndex].rgbGreen, m_colorTable[colorIndex].rgbBlue, 0xff);
-        }
-
-        // Like setI(), but with the individual component values specified.
-        inline void setPixel(unsigned red,
-                            unsigned green,
-                            unsigned blue,
-                            unsigned alpha)
-        {
-            m_buffer->backingStore()->setPixel(m_coord.x(), m_coord.y(), red, green, blue, alpha);
-            m_coord.move(1, 0);
-        }
-
-        // Fills pixels from the current X-coordinate up to, but not including,
-        // |endCoord| with the color given by the individual components.  This
-        // also increments the relevant local variables to move the current
-        // pixel right to |endCoord|.
-        inline void fillRGBA(int endCoord,
-                             unsigned red,
-                             unsigned green,
-                             unsigned blue,
-                             unsigned alpha)
-        {
-            if (endCoord <= m_coord.x())
-                return;
-            m_buffer->backingStore()->fillRect(IntRect(m_coord.x(), m_coord.y(), endCoord - m_coord.x(), 1), red, green, blue, alpha);
-            m_coord.setX(endCoord);
-        }
-
-        // Resets the relevant local variables to start drawing at the left edge
-        // of the "next" row, where "next" is above or below the current row
-        // depending on the value of |m_isTopDown|.
-        void moveBufferToNextRow();
-
-        // The decoder that owns us.
-        ImageDecoder* m_parent;
-
-        // The destination for the pixel data.
-        ImageFrame* m_buffer;
-
-        // The file to decode.
-        RefPtr<SharedBuffer> m_data;
-
-        // An index into |m_data| representing how much we've already decoded.
-        size_t m_decodedOffset;
-
-        // The file offset at which the BMP info header starts.
-        size_t m_headerOffset;
-
-        // The file offset at which the actual image bits start.  When decoding
-        // ICO files, this is set to 0, since it's not stored anywhere in a
-        // header; the reader functions expect the image data to start
-        // immediately after the header and (if necessary) color table.
-        size_t m_imgDataOffset;
-
-        // The BMP info header.
-        BitmapInfoHeader m_infoHeader;
-
-        // True if this is an OS/2 1.x (aka Windows 2.x) BMP.  The struct
-        // layouts for this type of BMP are slightly different from the later,
-        // more common formats.
-        bool m_isOS21x;
-
-        // True if this is an OS/2 2.x BMP.  The meanings of compression types 3
-        // and 4 for this type of BMP differ from Windows V3+ BMPs.
-        //
-        // This will be falsely negative in some cases, but only ones where the
-        // way we misinterpret the data is irrelevant.
-        bool m_isOS22x;
-
-        // True if the BMP is not vertically flipped, that is, the first line of
-        // raster data in the file is the top line of the image.
-        bool m_isTopDown;
-
-        // These flags get set to false as we finish each processing stage.
-        bool m_needToProcessBitmasks;
-        bool m_needToProcessColorTable;
-
-        // Masks/offsets for the color values for non-palette formats.  These
-        // are bitwise, with array entries 0, 1, 2, 3 corresponding to R, G, B,
-        // A.
-        //
-        // The right/left shift values are meant to be applied after the masks.
-        // We need to right shift to compensate for the bitfields' offsets into
-        // the 32 bits of pixel data, and left shift to scale the color values
-        // up for fields with less than 8 bits of precision.  Sadly, we can't
-        // just combine these into one shift value because the net shift amount
-        // could go either direction.  (If only "<< -x" were equivalent to
-        // ">> x"...)
-        uint32_t m_bitMasks[4];
-        int m_bitShiftsRight[4];
-        int m_bitShiftsLeft[4];
-
-        // The color palette, for paletted formats.
-        size_t m_tableSizeInBytes;
-        Vector<RGBTriple> m_colorTable;
-
-        // The coordinate to which we've decoded the image.
-        IntPoint m_coord;
-
-        // Variables that track whether we've seen pixels with alpha values != 0
-        // and == 0, respectively.  See comments in processNonRLEData() on how
-        // these are used.
-        bool m_seenNonZeroAlphaPixel;
-        bool m_seenZeroAlphaPixel;
-
-        // ICOs store a 1bpp "mask" immediately after the main bitmap image data
-        // (and, confusingly, add its height to the biHeight value in the info
-        // header, thus doubling it).  This variable tracks whether we have such
-        // a mask and if we've started decoding it yet.
-        AndMaskState m_andMaskState;
-    };
+    }
+
+    // Returns the value of the desired component (0, 1, 2, 3 == R, G, B, A)
+    // in the given pixel data.
+    inline unsigned getComponent(uint32_t pixel, int component) const
+    {
+        return ((pixel & m_bitMasks[component]) >> m_bitShiftsRight[component]) << m_bitShiftsLeft[component];
+    }
+
+    inline unsigned getAlpha(uint32_t pixel) const
+    {
+        // For images without alpha, return alpha of 0xff.
+        return m_bitMasks[3] ? getComponent(pixel, 3) : 0xff;
+    }
+
+    // Sets the current pixel to the color given by |colorIndex|. This also
+    // increments the relevant local variables to move the current pixel
+    // right by one.
+    inline void setI(size_t colorIndex)
+    {
+        setPixel(m_colorTable[colorIndex].rgbRed, m_colorTable[colorIndex].rgbGreen, m_colorTable[colorIndex].rgbBlue, 0xff);
+    }
+
+    // Like setI(), but with the individual component values specified.
+    inline void setPixel(unsigned red, unsigned green, unsigned blue, unsigned alpha)
+    {
+        m_buffer->backingStore()->setPixel(m_coord.x(), m_coord.y(), red, green, blue, alpha);
+        m_coord.move(1, 0);
+    }
+
+    // Fills pixels from the current X-coordinate up to, but not including,
+    // |endCoord| with the color given by the individual components. This
+    // also increments the relevant local variables to move the current
+    // pixel right to |endCoord|.
+    inline void fillRGBA(int endCoord, unsigned red, unsigned green, unsigned blue, unsigned alpha)
+    {
+        if (endCoord <= m_coord.x())
+            return;
+        m_buffer->backingStore()->fillRect(IntRect(m_coord.x(), m_coord.y(), endCoord - m_coord.x(), 1), red, green, blue, alpha);
+        m_coord.setX(endCoord);
+    }
+
+    // Resets the relevant local variables to start drawing at the left edge
+    // of the "next" row, where "next" is above or below the current row
+    // depending on the value of |m_isTopDown|.
+    void moveBufferToNextRow();
+
+    // The decoder that owns us.
+    ScalableImageDecoder* m_parent;
+
+    // The destination for the pixel data.
+    ImageFrame* m_buffer;
+
+    // The file to decode.
+    RefPtr<SharedBuffer> m_data;
+
+    // An index into |m_data| representing how much we've already decoded.
+    size_t m_decodedOffset;
+
+    // The file offset at which the BMP info header starts.
+    size_t m_headerOffset;
+
+    // The file offset at which the actual image bits start. When decoding
+    // ICO files, this is set to 0, since it's not stored anywhere in a
+    // header; the reader functions expect the image data to start
+    // immediately after the header and (if necessary) color table.
+    size_t m_imgDataOffset;
+
+    // The BMP info header.
+    BitmapInfoHeader m_infoHeader;
+
+    // True if this is an OS/2 1.x (aka Windows 2.x) BMP. The struct
+    // layouts for this type of BMP are slightly different from the later,
+    // more common formats.
+    bool m_isOS21x;
+
+    // True if this is an OS/2 2.x BMP. The meanings of compression types 3
+    // and 4 for this type of BMP differ from Windows V3+ BMPs.
+    //
+    // This will be falsely negative in some cases, but only ones where the
+    // way we misinterpret the data is irrelevant.
+    bool m_isOS22x;
+
+    // True if the BMP is not vertically flipped, that is, the first line of
+    // raster data in the file is the top line of the image.
+    bool m_isTopDown;
+
+    // These flags get set to false as we finish each processing stage.
+    bool m_needToProcessBitmasks;
+    bool m_needToProcessColorTable;
+
+    // Masks/offsets for the color values for non-palette formats. These
+    // are bitwise, with array entries 0, 1, 2, 3 corresponding to R, G, B,
+    // A.
+    //
+    // The right/left shift values are meant to be applied after the masks.
+    // We need to right shift to compensate for the bitfields' offsets into
+    // the 32 bits of pixel data, and left shift to scale the color values
+    // up for fields with less than 8 bits of precision. Sadly, we can't
+    // just combine these into one shift value because the net shift amount
+    // could go either direction. (If only "<< -x" were equivalent to
+    // ">> x"...)
+    uint32_t m_bitMasks[4];
+    int m_bitShiftsRight[4];
+    int m_bitShiftsLeft[4];
+
+    // The color palette, for paletted formats.
+    size_t m_tableSizeInBytes;
+    Vector<RGBTriple> m_colorTable;
+
+    // The coordinate to which we've decoded the image.
+    IntPoint m_coord;
+
+    // Variables that track whether we've seen pixels with alpha values != 0
+    // and == 0, respectively. See comments in processNonRLEData() on how
+    // these are used.
+    bool m_seenNonZeroAlphaPixel;
+    bool m_seenZeroAlphaPixel;
+
+    // ICOs store a 1bpp "mask" immediately after the main bitmap image data
+    // (and, confusingly, add its height to the biHeight value in the info
+    // header, thus doubling it). This variable tracks whether we have such
+    // a mask and if we've started decoding it yet.
+    AndMaskState m_andMaskState;
+};
 
 } // namespace WebCore
-
-#endif

trunk/Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.cpp

@@ -33 +33 @@
 
 GIFImageDecoder::GIFImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
-    : ImageDecoder(alphaOption, gammaAndColorProfileOption)
+    : ScalableImageDecoder(alphaOption, gammaAndColorProfileOption)
 {
 }
@@ -46 +46 @@
         return;
 
-    ImageDecoder::setData(data, allDataReceived);
+    ScalableImageDecoder::setData(data, allDataReceived);
     if (m_reader)
         m_reader->setData(&data);
@@ -53 +53 @@
 bool GIFImageDecoder::setSize(const IntSize& size)
 {
-    if (ImageDecoder::encodedDataStatus() >= EncodedDataStatus::SizeAvailable && this->size() == size)
+    if (ScalableImageDecoder::encodedDataStatus() >= EncodedDataStatus::SizeAvailable && this->size() == size)
         return true;
 
-    if (!ImageDecoder::setSize(size))
+    if (!ScalableImageDecoder::setSize(size))
         return false;
 
@@ -116 +116 @@
 {
     m_reader = nullptr;
-    return ImageDecoder::setFailed();
+    return ScalableImageDecoder::setFailed();
 }
 

trunk/Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.h

@@ -26 +26 @@
 #pragma once
 
-#include "ImageDecoder.h"
+#include "ScalableImageDecoder.h"
 #include <wtf/Lock.h>
 
@@ -33 +33 @@
 namespace WebCore {
 
-    // This class decodes the GIF image format.
-    class GIFImageDecoder final : public ImageDecoder {
-    public:
-        static Ref<ImageDecoder> create(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
-        {
-            return adoptRef(*new GIFImageDecoder(alphaOption, gammaAndColorProfileOption));
-        }
+// This class decodes the GIF image format.
+class GIFImageDecoder final : public ScalableImageDecoder {
+public:
+    static Ref<ScalableImageDecoder> create(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
+    {
+        return adoptRef(*new GIFImageDecoder(alphaOption, gammaAndColorProfileOption));
+    }
 
-        virtual ~GIFImageDecoder();
+    virtual ~GIFImageDecoder();
 
-        enum GIFQuery { GIFFullQuery, GIFSizeQuery, GIFFrameCountQuery };
+    enum GIFQuery { GIFFullQuery, GIFSizeQuery, GIFFrameCountQuery };
 
-        // ImageDecoder
-        String filenameExtension() const override { return ASCIILiteral("gif"); }
-        void setData(SharedBuffer& data, bool allDataReceived) override;
-        bool setSize(const IntSize&) override;
-        size_t frameCount() const override;
-        RepetitionCount repetitionCount() const override;
-        ImageFrame* frameBufferAtIndex(size_t index) override;
-        // CAUTION: setFailed() deletes |m_reader|.  Be careful to avoid
-        // accessing deleted memory, especially when calling this from inside
-        // GIFImageReader!
-        bool setFailed() override;
-        void clearFrameBufferCache(size_t clearBeforeFrame) override;
+    // ScalableImageDecoder
+    String filenameExtension() const final { return ASCIILiteral("gif"); }
+    void setData(SharedBuffer& data, bool allDataReceived) final;
+    bool setSize(const IntSize&) final;
+    size_t frameCount() const final;
+    RepetitionCount repetitionCount() const final;
+    ImageFrame* frameBufferAtIndex(size_t index) final;
+    // CAUTION: setFailed() deletes |m_reader|. Be careful to avoid
+    // accessing deleted memory, especially when calling this from inside
+    // GIFImageReader!
+    bool setFailed() final;
+    void clearFrameBufferCache(size_t clearBeforeFrame) final;
 
-        // Callbacks from the GIF reader.
-        bool haveDecodedRow(unsigned frameIndex, const Vector<unsigned char>& rowBuffer, size_t width, size_t rowNumber, unsigned repeatCount, bool writeTransparentPixels);
-        bool frameComplete(unsigned frameIndex, unsigned frameDuration, ImageFrame::DisposalMethod);
-        void gifComplete();
+    // Callbacks from the GIF reader.
+    bool haveDecodedRow(unsigned frameIndex, const Vector<unsigned char>& rowBuffer, size_t width, size_t rowNumber, unsigned repeatCount, bool writeTransparentPixels);
+    bool frameComplete(unsigned frameIndex, unsigned frameDuration, ImageFrame::DisposalMethod);
+    void gifComplete();
 
-    private:
-        GIFImageDecoder(AlphaOption, GammaAndColorProfileOption);
-        void tryDecodeSize(bool allDataReceived) override { decode(0, GIFSizeQuery, allDataReceived); }
+private:
+    GIFImageDecoder(AlphaOption, GammaAndColorProfileOption);
+    void tryDecodeSize(bool allDataReceived) final { decode(0, GIFSizeQuery, allDataReceived); }
 
-        // If the query is GIFFullQuery, decodes the image up to (but not
-        // including) |haltAtFrame|.  Otherwise, decodes as much as is needed to
-        // answer the query, ignoring bitmap data.  If decoding fails but there
-        // is no more data coming, sets the "decode failure" flag.
-        void decode(unsigned haltAtFrame, GIFQuery, bool allDataReceived);
+    // If the query is GIFFullQuery, decodes the image up to (but not
+    // including) |haltAtFrame|. Otherwise, decodes as much as is needed to
+    // answer the query, ignoring bitmap data. If decoding fails but there
+    // is no more data coming, sets the "decode failure" flag.
+    void decode(unsigned haltAtFrame, GIFQuery, bool allDataReceived);
 
-        // Called to initialize the frame buffer with the given index, based on
-        // the previous frame's disposal method. Returns true on success. On
-        // failure, this will mark the image as failed.
-        bool initFrameBuffer(unsigned frameIndex);
+    // Called to initialize the frame buffer with the given index, based on
+    // the previous frame's disposal method. Returns true on success. On
+    // failure, this will mark the image as failed.
+    bool initFrameBuffer(unsigned frameIndex);
 
-        bool m_currentBufferSawAlpha;
-        mutable RepetitionCount m_repetitionCount { RepetitionCountOnce };
-        std::unique_ptr<GIFImageReader> m_reader;
-        Lock m_decodeLock;
-    };
+    bool m_currentBufferSawAlpha;
+    mutable RepetitionCount m_repetitionCount { RepetitionCountOnce };
+    std::unique_ptr<GIFImageReader> m_reader;
+    Lock m_decodeLock;
+};
 
 } // namespace WebCore

trunk/Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.cpp

@@ -46 +46 @@
 
 ICOImageDecoder::ICOImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
-    : ImageDecoder(alphaOption, gammaAndColorProfileOption)
+    : ScalableImageDecoder(alphaOption, gammaAndColorProfileOption)
     , m_decodedOffset(0)
 {
@@ -60 +60 @@
         return;
 
-    ImageDecoder::setData(data, allDataReceived);
+    ScalableImageDecoder::setData(data, allDataReceived);
 
     for (BMPReaders::iterator i(m_bmpReaders.begin()); i != m_bmpReaders.end(); ++i) {
@@ -70 +70 @@
 }
 
-IntSize ICOImageDecoder::size()
-{
-    return m_frameSize.isEmpty() ? ImageDecoder::size() : m_frameSize;
-}
-
-IntSize ICOImageDecoder::frameSizeAtIndex(size_t index, SubsamplingLevel)
+IntSize ICOImageDecoder::size() const
+{
+    return m_frameSize.isEmpty() ? ScalableImageDecoder::size() : m_frameSize;
+}
+
+IntSize ICOImageDecoder::frameSizeAtIndex(size_t index, SubsamplingLevel) const
 {
     return (index && (index < m_dirEntries.size())) ? m_dirEntries[index].m_size : size();
@@ -84 +84 @@
     // The size calculated inside the BMPImageReader had better match the one in
     // the icon directory.
-    return m_frameSize.isEmpty() ? ImageDecoder::setSize(size) : ((size == m_frameSize) || setFailed());
+    return m_frameSize.isEmpty() ? ScalableImageDecoder::setSize(size) : ((size == m_frameSize) || setFailed());
 }
 
@@ -109 +109 @@
     m_bmpReaders.clear();
     m_pngDecoders.clear();
-    return ImageDecoder::setFailed();
+    return ScalableImageDecoder::setFailed();
 }
 

trunk/Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.h

@@ -34 +34 @@
 
 namespace WebCore {
-    // This class decodes the ICO and CUR image formats.
-    class ICOImageDecoder final : public ImageDecoder {
-    public:
-        static Ref<ImageDecoder> create(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
-        {
-            return adoptRef(*new ICOImageDecoder(alphaOption, gammaAndColorProfileOption));
-        }
 
-        virtual ~ICOImageDecoder();
+// This class decodes the ICO and CUR image formats.
+class ICOImageDecoder final : public ScalableImageDecoder {
+public:
+    static Ref<ScalableImageDecoder> create(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
+    {
+        return adoptRef(*new ICOImageDecoder(alphaOption, gammaAndColorProfileOption));
+    }
 
-        // ImageDecoder
-        String filenameExtension() const override { return ASCIILiteral("ico"); }
-        void setData(SharedBuffer&, bool allDataReceived) override;
-        IntSize size() override;
-        IntSize frameSizeAtIndex(size_t, SubsamplingLevel) override;
-        bool setSize(const IntSize&) override;
-        size_t frameCount() const override;
-        ImageFrame* frameBufferAtIndex(size_t) override;
-        // CAUTION: setFailed() deletes all readers and decoders.  Be careful to
-        // avoid accessing deleted memory, especially when calling this from
-        // inside BMPImageReader!
-        bool setFailed() override;
-        std::optional<IntPoint> hotSpot() const override;
+    virtual ~ICOImageDecoder();
 
-    private:
-        enum ImageType {
-            Unknown,
-            BMP,
-            PNG,
-        };
+    // ScalableImageDecoder
+    String filenameExtension() const final { return ASCIILiteral("ico"); }
+    void setData(SharedBuffer&, bool allDataReceived) final;
+    IntSize size() const final;
+    IntSize frameSizeAtIndex(size_t, SubsamplingLevel) const final;
+    bool setSize(const IntSize&) final;
+    size_t frameCount() const final;
+    ImageFrame* frameBufferAtIndex(size_t) final;
+    // CAUTION: setFailed() deletes all readers and decoders. Be careful to
+    // avoid accessing deleted memory, especially when calling this from
+    // inside BMPImageReader!
+    bool setFailed() final;
+    std::optional<IntPoint> hotSpot() const final;
 
-        enum FileType {
-            ICON = 1,
-            CURSOR = 2,
-        };
-
-        struct IconDirectoryEntry {
-            IntSize m_size;
-            uint16_t m_bitCount;
-            IntPoint m_hotSpot;
-            uint32_t m_imageOffset;
-        };
-
-        ICOImageDecoder(AlphaOption, GammaAndColorProfileOption);
-        void tryDecodeSize(bool allDataReceived) override { decode(0, true, allDataReceived); }
-
-        // Returns true if |a| is a preferable icon entry to |b|.
-        // Larger sizes, or greater bitdepths at the same size, are preferable.
-        static bool compareEntries(const IconDirectoryEntry& a, const IconDirectoryEntry& b);
-
-        inline uint16_t readUint16(int offset) const
-        {
-            return BMPImageReader::readUint16(m_data.get(), m_decodedOffset + offset);
-        }
-
-        inline uint32_t readUint32(int offset) const
-        {
-            return BMPImageReader::readUint32(m_data.get(), m_decodedOffset + offset);
-        }
-
-        // If the desired PNGImageDecoder exists, gives it the appropriate data.
-        void setDataForPNGDecoderAtIndex(size_t);
-
-        // Decodes the entry at |index|.  If |onlySize| is true, stops decoding
-        // after calculating the image size.  If decoding fails but there is no
-        // more data coming, sets the "decode failure" flag.
-        void decode(size_t index, bool onlySize, bool allDataReceived);
-
-        // Decodes the directory and directory entries at the beginning of the
-        // data, and initializes members.  Returns true if all decoding
-        // succeeded.  Once this returns true, all entries' sizes are known.
-        bool decodeDirectory();
-
-        // Decodes the specified entry.
-        bool decodeAtIndex(size_t);
-
-        // Processes the ICONDIR at the beginning of the data.  Returns true if
-        // the directory could be decoded.
-        bool processDirectory();
-
-        // Processes the ICONDIRENTRY records after the directory.  Keeps the
-        // "best" entry as the one we'll decode.  Returns true if the entries
-        // could be decoded.
-        bool processDirectoryEntries();
-
-        // Returns the hot-spot for |index|, returns std::nullopt if there is none.
-        std::optional<IntPoint> hotSpotAtIndex(size_t) const;
-
-        // Reads and returns a directory entry from the current offset into
-        // |data|.
-        IconDirectoryEntry readDirectoryEntry();
-
-        // Determines whether the desired entry is a BMP or PNG.  Returns true
-        // if the type could be determined.
-        ImageType imageTypeAtIndex(size_t);
-
-        // An index into |m_data| representing how much we've already decoded.
-        // Note that this only tracks data _this_ class decodes; once the
-        // BMPImageReader takes over this will not be updated further.
-        size_t m_decodedOffset;
-
-        // Which type of file (ICO/CUR) this is.
-        FileType m_fileType;
-
-        // The headers for the ICO.
-        typedef Vector<IconDirectoryEntry> IconDirectoryEntries;
-        IconDirectoryEntries m_dirEntries;
-
-        // The image decoders for the various frames.
-        typedef Vector<std::unique_ptr<BMPImageReader>> BMPReaders;
-        BMPReaders m_bmpReaders;
-        typedef Vector<RefPtr<ImageDecoder>> PNGDecoders;
-        PNGDecoders m_pngDecoders;
-
-        // Valid only while a BMPImageReader is decoding, this holds the size
-        // for the particular entry being decoded.
-        IntSize m_frameSize;
+private:
+    enum ImageType {
+        Unknown,
+        BMP,
+        PNG,
     };
 
+    enum FileType {
+        ICON = 1,
+        CURSOR = 2,
+    };
+
+    struct IconDirectoryEntry {
+        IntSize m_size;
+        uint16_t m_bitCount;
+        IntPoint m_hotSpot;
+        uint32_t m_imageOffset;
+    };
+
+    ICOImageDecoder(AlphaOption, GammaAndColorProfileOption);
+    void tryDecodeSize(bool allDataReceived) final { decode(0, true, allDataReceived); }
+
+    // Returns true if |a| is a preferable icon entry to |b|.
+    // Larger sizes, or greater bitdepths at the same size, are preferable.
+    static bool compareEntries(const IconDirectoryEntry& a, const IconDirectoryEntry& b);
+
+    inline uint16_t readUint16(int offset) const
+    {
+        return BMPImageReader::readUint16(m_data.get(), m_decodedOffset + offset);
+    }
+
+    inline uint32_t readUint32(int offset) const
+    {
+        return BMPImageReader::readUint32(m_data.get(), m_decodedOffset + offset);
+    }
+
+    // If the desired PNGImageDecoder exists, gives it the appropriate data.
+    void setDataForPNGDecoderAtIndex(size_t);
+
+    // Decodes the entry at |index|. If |onlySize| is true, stops decoding
+    // after calculating the image size. If decoding fails but there is no
+    // more data coming, sets the "decode failure" flag.
+    void decode(size_t index, bool onlySize, bool allDataReceived);
+
+    // Decodes the directory and directory entries at the beginning of the
+    // data, and initializes members. Returns true if all decoding
+    // succeeded. Once this returns true, all entries' sizes are known.
+    bool decodeDirectory();
+
+    // Decodes the specified entry.
+    bool decodeAtIndex(size_t);
+
+    // Processes the ICONDIR at the beginning of the data. Returns true if
+    // the directory could be decoded.
+    bool processDirectory();
+
+    // Processes the ICONDIRENTRY records after the directory. Keeps the
+    // "best" entry as the one we'll decode. Returns true if the entries
+    // could be decoded.
+    bool processDirectoryEntries();
+
+    // Returns the hot-spot for |index|, returns std::nullopt if there is none.
+    std::optional<IntPoint> hotSpotAtIndex(size_t) const;
+
+    // Reads and returns a directory entry from the current offset into
+    // |data|.
+    IconDirectoryEntry readDirectoryEntry();
+
+    // Determines whether the desired entry is a BMP or PNG. Returns true
+    // if the type could be determined.
+    ImageType imageTypeAtIndex(size_t);
+
+    // An index into |m_data| representing how much we've already decoded.
+    // Note that this only tracks data _this_ class decodes; once the
+    // BMPImageReader takes over this will not be updated further.
+    size_t m_decodedOffset;
+
+    // Which type of file (ICO/CUR) this is.
+    FileType m_fileType;
+
+    // The headers for the ICO.
+    typedef Vector<IconDirectoryEntry> IconDirectoryEntries;
+    IconDirectoryEntries m_dirEntries;
+
+    // The image decoders for the various frames.
+    typedef Vector<std::unique_ptr<BMPImageReader>> BMPReaders;
+    BMPReaders m_bmpReaders;
+    typedef Vector<RefPtr<ScalableImageDecoder>> PNGDecoders;
+    PNGDecoders m_pngDecoders;
+
+    // Valid only while a BMPImageReader is decoding, this holds the size
+    // for the particular entry being decoded.
+    IntSize m_frameSize;
+};
+
 } // namespace WebCore

trunk/Source/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.cpp

@@ -503 +503 @@
 
 JPEGImageDecoder::JPEGImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
-    : ImageDecoder(alphaOption, gammaAndColorProfileOption)
+    : ScalableImageDecoder(alphaOption, gammaAndColorProfileOption)
 {
 }
@@ -513 +513 @@
 bool JPEGImageDecoder::setSize(const IntSize& size)
 {
-    if (!ImageDecoder::setSize(size))
+    if (!ScalableImageDecoder::setSize(size))
         return false;
 
@@ -537 +537 @@
 {
     m_reader = nullptr;
-    return ImageDecoder::setFailed();
+    return ScalableImageDecoder::setFailed();
 }
 

trunk/Source/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.h

@@ -27 +27 @@
 #pragma once
 
-#include "ImageDecoder.h"
+#include "ScalableImageDecoder.h"
 #include <stdio.h> // Needed by jpeglib.h for FILE.
 
@@ -42 +42 @@
 
     // This class decodes the JPEG image format.
-    class JPEGImageDecoder final : public ImageDecoder {
+    class JPEGImageDecoder final : public ScalableImageDecoder {
     public:
-        static Ref<ImageDecoder> create(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
+        static Ref<ScalableImageDecoder> create(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
         {
             return adoptRef(*new JPEGImageDecoder(alphaOption, gammaAndColorProfileOption));
@@ -51 +51 @@
         virtual ~JPEGImageDecoder();
 
-        // ImageDecoder
+        // ScalableImageDecoder
         String filenameExtension() const override { return ASCIILiteral("jpg"); }
         bool setSize(const IntSize&) override;
@@ -62 +62 @@
         bool willDownSample()
         {
-            ASSERT(ImageDecoder::encodedDataStatus() >= EncodedDataStatus::SizeAvailable);
+            ASSERT(ScalableImageDecoder::encodedDataStatus() >= EncodedDataStatus::SizeAvailable);
             return m_scaled;
         }

trunk/Source/WebCore/platform/image-decoders/png/PNGImageDecoder.cpp

@@ -174 +174 @@
             // merely want to check if we've managed to set the size, not
             // (recursively) trigger additional decoding if we haven't.
-            if (sizeOnly ? decoder->ImageDecoder::encodedDataStatus() >= EncodedDataStatus::SizeAvailable : decoder->isCompleteAtIndex(haltAtFrame))
+            if (sizeOnly ? decoder->ScalableImageDecoder::encodedDataStatus() >= EncodedDataStatus::SizeAvailable : decoder->isCompleteAtIndex(haltAtFrame))
                 return true;
         }
@@ -203 +203 @@
 
 PNGImageDecoder::PNGImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
-    : ImageDecoder(alphaOption, gammaAndColorProfileOption)
+    : ScalableImageDecoder(alphaOption, gammaAndColorProfileOption)
     , m_doNothingOnFailure(false)
     , m_currentFrame(0)
@@ -250 +250 @@
 bool PNGImageDecoder::setSize(const IntSize& size)
 {
-    if (!ImageDecoder::setSize(size))
+    if (!ScalableImageDecoder::setSize(size))
         return false;
 
@@ -260 +260 @@
 {
 #if ENABLE(APNG)
-    if (ImageDecoder::encodedDataStatus() < EncodedDataStatus::SizeAvailable)
+    if (ScalableImageDecoder::encodedDataStatus() < EncodedDataStatus::SizeAvailable)
         return nullptr;
 
@@ -284 +284 @@
         return false;
     m_reader = nullptr;
-    return ImageDecoder::setFailed();
+    return ScalableImageDecoder::setFailed();
 }
 

trunk/Source/WebCore/platform/image-decoders/png/PNGImageDecoder.h

@@ -26 +26 @@
 #pragma once
 
-#include "ImageDecoder.h"
+#include "ScalableImageDecoder.h"
 #if ENABLE(APNG)
 #include <png.h>
@@ -36 +36 @@
 
     // This class decodes the PNG image format.
-    class PNGImageDecoder final : public ImageDecoder {
+    class PNGImageDecoder final : public ScalableImageDecoder {
     public:
-        static Ref<ImageDecoder> create(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
+        static Ref<ScalableImageDecoder> create(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
         {
             return adoptRef(*new PNGImageDecoder(alphaOption, gammaAndColorProfileOption));
@@ -45 +45 @@
         virtual ~PNGImageDecoder();
 
-        // ImageDecoder
+        // ScalableImageDecoder
         String filenameExtension() const override { return ASCIILiteral("png"); }
 #if ENABLE(APNG)

trunk/Source/WebCore/platform/image-decoders/webp/WEBPImageDecoder.cpp

@@ -47 +47 @@
 
 WEBPImageDecoder::WEBPImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
-    : ImageDecoder(alphaOption, gammaAndColorProfileOption)
+    : ScalableImageDecoder(alphaOption, gammaAndColorProfileOption)
     , m_decoder(0)
     , m_hasAlpha(false)
@@ -87 +87 @@
     const size_t dataSize = m_data->size();
 
-    if (ImageDecoder::encodedDataStatus() < EncodedDataStatus::SizeAvailable) {
+    if (ScalableImageDecoder::encodedDataStatus() < EncodedDataStatus::SizeAvailable) {
         static const size_t imageHeaderSize = 30;
         if (dataSize < imageHeaderSize)
@@ -109 +109 @@
     }
 
-    ASSERT(ImageDecoder::encodedDataStatus() >= EncodedDataStatus::SizeAvailable);
+    ASSERT(ScalableImageDecoder::encodedDataStatus() >= EncodedDataStatus::SizeAvailable);
     if (onlySize)
         return true;

trunk/Source/WebCore/platform/image-decoders/webp/WEBPImageDecoder.h

@@ -29 +29 @@
 #pragma once
 
-#include "ImageDecoder.h"
+#include "ScalableImageDecoder.h"
 
 #if USE(WEBP)
@@ -37 +37 @@
 namespace WebCore {
 
-class WEBPImageDecoder final : public ImageDecoder {
+class WEBPImageDecoder final : public ScalableImageDecoder {
 public:
-    static Ref<ImageDecoder> create(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
+    static Ref<ScalableImageDecoder> create(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
     {
         return adoptRef(*new WEBPImageDecoder(alphaOption, gammaAndColorProfileOption));