ChangeLog

2020-11-01  Said Abou-Hallawa  <said@apple.com>

        [GPU Process] Control the life cycle of the platform image by a new class named NativeImage

        https://bugs.webkit.org/show_bug.cgi?id=218427

        Reviewed by NOBODY (OOPS!).

        * Headers.cmake:

        * Sources.txt:

        * WebCore.xcodeproj/project.pbxproj:

        * html/HTMLVideoElement.cpp:

        (WebCore::HTMLVideoElement::nativeImageForCurrentTime):

        * html/HTMLVideoElement.h:

        * html/canvas/CanvasRenderingContext2DBase.cpp:

        (WebCore::CanvasRenderingContext2DBase::drawImage):

        * page/mac/TextIndicatorWindow.mm:

        (-[WebTextIndicatorView initWithFrame:textIndicator:margin:offset:]):

        (createContentCrossfadeAnimation):

        * platform/graphics/BitmapImage.cpp:

        (WebCore::BitmapImage::BitmapImage):

        (WebCore::BitmapImage::frameImageAtIndexCacheIfNeeded):

        (WebCore::BitmapImage::nativeImage):

        (WebCore::BitmapImage::nativeImageForCurrentFrame):

        (WebCore::BitmapImage::preTransformedNativeImageForCurrentFrame):

        (WebCore::BitmapImage::nativeImageOfSize):

        (WebCore::BitmapImage::framesNativeImages):

        (WebCore::drawNativeImage):

        (WebCore::BitmapImage::draw):

        * platform/graphics/BitmapImage.h:

        * platform/graphics/ConcreteImageBuffer.h:

        * platform/graphics/GraphicsContext.cpp:

        (WebCore::GraphicsContext::drawNativeImage):

        * platform/graphics/GraphicsContext.h:

        (WebCore::GraphicsContext::drawNativeImage):

        (WebCore::GraphicsContext::drawPlatformImage):

        * platform/graphics/GraphicsContextGLImageExtractor.h:

        * platform/graphics/GraphicsContextImpl.h:

        * platform/graphics/Icon.h:

        * platform/graphics/Image.h:

        (WebCore::Image::nativeImage):

        (WebCore::Image::nativeImageForCurrentFrame):

        (WebCore::Image::preTransformedNativeImageForCurrentFrame):

        (WebCore::Image::nativeImageOfSize):

        * platform/graphics/ImageBackingStore.h:

        * platform/graphics/ImageBuffer.cpp:

        (WebCore::ImageBuffer::sinkIntoNativeImage):

        * platform/graphics/ImageBuffer.h:

        * platform/graphics/ImageBufferBackend.cpp:

        (WebCore::ImageBufferBackend::sinkIntoNativeImage):

        * platform/graphics/ImageBufferBackend.h:

        * platform/graphics/ImageDecoder.h:

        * platform/graphics/ImageFrame.cpp:

        (WebCore::ImageFrame::clearImage):

        (WebCore::ImageFrame::singlePixelSolidColor const):

        * platform/graphics/ImageFrame.h:

        (WebCore::ImageFrame::nativeImage const):

        * platform/graphics/ImageSource.cpp:

        (WebCore::ImageSource::ImageSource):

        (WebCore::ImageSource::setNativeImage):

        (WebCore::ImageSource::cacheMetadataAtIndex):

        (WebCore::ImageSource::cachePlatformImageAtIndex):

        (WebCore::ImageSource::cachePlatformImageAtIndexAsync):

        (WebCore::ImageSource::startAsyncDecodingQueue):

        (WebCore::ImageSource::frameAtIndexCacheIfNeeded):

        (WebCore::ImageSource::createFrameImageAtIndex):

        (WebCore::ImageSource::frameImageAtIndex):

        (WebCore::ImageSource::frameImageAtIndexCacheIfNeeded):

        (WebCore::ImageSource::cacheNativeImageAtIndex): Deleted.

        (WebCore::ImageSource::cacheNativeImageAtIndexAsync): Deleted.

        * platform/graphics/ImageSource.h:

        (WebCore::ImageSource::create):

        * platform/graphics/MediaPlayer.cpp:

        (WebCore::MediaPlayer::nativeImageForCurrentTime):

        * platform/graphics/MediaPlayer.h:

        * platform/graphics/MediaPlayerPrivate.h:

        (WebCore::MediaPlayerPrivateInterface::nativeImageForCurrentTime):

        * platform/graphics/NativeImage.cpp: Copied from Source/WebCore/platform/graphics/NativeImagePtr.h.

        (WebCore::NativeImage::create):

        (WebCore::NativeImage::NativeImage):

        (WebCore::NativeImage::~NativeImage):

        * platform/graphics/NativeImage.h:

        (WebCore::NativeImage::renderingResourceIdentifier const):

        (WebCore::NativeImage::isNull const):

        (WebCore::NativeImage::platformImage):

        (WebCore::NativeImage::platformImage const):

        (WebCore::NativeImage::size const):

        (WebCore::NativeImage::setObserver):

        * platform/graphics/PlatformImagePtr.h: Renamed from Source/WebCore/platform/graphics/NativeImagePtr.h.

        * platform/graphics/VideoLayerManager.h:

        * platform/graphics/avfoundation/objc/ImageDecoderAVFObjC.h:

        * platform/graphics/avfoundation/objc/ImageDecoderAVFObjC.mm:

        (WebCore::ImageDecoderAVFObjC::createFrameImageAtIndex):

        * platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.h:

        * platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.mm:

        (WebCore::MediaPlayerPrivateAVFoundationObjC::updateVideoFullscreenInlineImage):

        (WebCore::MediaPlayerPrivateAVFoundationObjC::setVideoFullscreenLayer):

        (WebCore::MediaPlayerPrivateAVFoundationObjC::updateLastImage):

        (WebCore::MediaPlayerPrivateAVFoundationObjC::paintWithVideoOutput):

        (WebCore::MediaPlayerPrivateAVFoundationObjC::nativeImageForCurrentTime):

        * platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h:

        * platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm:

        (WebCore::MediaPlayerPrivateMediaSourceAVFObjC::nativeImageForCurrentTime):

        (WebCore::MediaPlayerPrivateMediaSourceAVFObjC::updateLastImage):

        (WebCore::MediaPlayerPrivateMediaSourceAVFObjC::paintCurrentFrameInContext):

        (WebCore::MediaPlayerPrivateMediaSourceAVFObjC::setVideoFullscreenLayer):

        * platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.h:

        * platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.mm:

        (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::setVideoFullscreenLayer):

        (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::updateCurrentFrameImage):

        (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::paintCurrentFrameInContext):

        * platform/graphics/avfoundation/objc/VideoLayerManagerObjC.h:

        * platform/graphics/avfoundation/objc/VideoLayerManagerObjC.mm:

        (WebCore::VideoLayerManagerObjC::setVideoFullscreenLayer):

        (WebCore::VideoLayerManagerObjC::updateVideoFullscreenInlineImage):

        * platform/graphics/ca/GraphicsLayerCA.cpp:

        (WebCore::GraphicsLayerCA::updateContentsImage):

        * platform/graphics/ca/GraphicsLayerCA.h:

        * platform/graphics/cairo/GraphicsContextCairo.cpp:

        (WebCore::GraphicsContext::drawPlatformImage):

        (WebCore::GraphicsContext::platformDrawNativeImage): Deleted.

        * platform/graphics/cairo/GraphicsContextImplCairo.cpp:

        (WebCore::GraphicsContextImplCairo::drawNativeImage):

        (WebCore::GraphicsContextImplCairo::drawPlatformImage):

        (WebCore::GraphicsContextImplCairo::drawPattern):

        (WebCore::GraphicsContextImplCairo::clipToImageBuffer):

        * platform/graphics/cairo/GraphicsContextImplCairo.h:

        * platform/graphics/cairo/ImageBufferCairoSurfaceBackend.cpp:

        (WebCore::ImageBufferCairoSurfaceBackend::copyNativeImage const):

        (WebCore::ImageBufferCairoSurfaceBackend::cairoSurfaceCoerceToImage const):

        * platform/graphics/cairo/ImageBufferCairoSurfaceBackend.h:

        * platform/graphics/cairo/NativeImageCairo.cpp:

        (WebCore::NativeImage::size):

        (WebCore::NativeImage::hasAlpha const):

        (WebCore::NativeImage::singlePixelSolidColor const):

        (WebCore::NativeImage::clearSubimages):

        (WebCore::nativeImageSize): Deleted.

        (WebCore::nativeImageHasAlpha): Deleted.

        (WebCore::nativeImageSinglePixelSolidColor): Deleted.

        (WebCore::drawNativeImage): Deleted.

        (WebCore::clearNativeImageSubimages): Deleted.

        * platform/graphics/cg/GraphicsContextCG.cpp:

        (WebCore::GraphicsContext::drawPlatformImage):

        (WebCore::GraphicsContext::drawPattern):

        (WebCore::GraphicsContext::clipToImageBuffer):

        (WebCore::GraphicsContext::platformDrawNativeImage): Deleted.

        * platform/graphics/cg/GraphicsContextGLCG.cpp:

        (WebCore::GraphicsContextGLImageExtractor::extractImage):

        (WebCore::GraphicsContextGLOpenGL::paintToCanvas):

        * platform/graphics/cg/ImageBufferCGBackend.cpp:

        (WebCore::createCroppedImageIfNecessary):

        (WebCore::createBitmapImageAfterScalingIfNeeded):

        (WebCore::ImageBufferCGBackend::copyImage const):

        (WebCore::ImageBufferCGBackend::draw):

        (WebCore::ImageBufferCGBackend::toCFData const):

        * platform/graphics/cg/ImageBufferCGBitmapBackend.cpp:

        (WebCore::ImageBufferCGBitmapBackend::copyNativeImage const):

        * platform/graphics/cg/ImageBufferCGBitmapBackend.h:

        * platform/graphics/cg/ImageBufferIOSurfaceBackend.cpp:

        (WebCore::ImageBufferIOSurfaceBackend::copyNativeImage const):

        (WebCore::ImageBufferIOSurfaceBackend::sinkIntoNativeImage):

        (WebCore::ImageBufferIOSurfaceBackend::drawConsuming):

        * platform/graphics/cg/ImageBufferIOSurfaceBackend.h:

        * platform/graphics/cg/ImageDecoderCG.cpp:

        (WebCore::ImageDecoderCG::createFrameImageAtIndex):

        * platform/graphics/cg/ImageDecoderCG.h:

        * platform/graphics/cg/NativeImageCG.cpp:

        (WebCore::NativeImage::size):

        (WebCore::NativeImage::hasAlpha const):

        (WebCore::NativeImage::singlePixelSolidColor const):

        (WebCore::NativeImage::clearSubimages):

        (WebCore::nativeImageSize): Deleted.

        (WebCore::nativeImageHasAlpha): Deleted.

        (WebCore::nativeImageSinglePixelSolidColor): Deleted.

        (WebCore::clearNativeImageSubimages): Deleted.

        * platform/graphics/cg/PatternCG.cpp:

        (WebCore::Pattern::createPlatformPattern const):

        * platform/graphics/coreimage/FilterEffectRendererCoreImage.mm:

        (WebCore::FilterEffectRendererCoreImage::imageForSourceGraphic):

        * platform/graphics/displaylists/DisplayList.h:

        * platform/graphics/displaylists/DisplayListItems.cpp:

        (WebCore::DisplayList::Item::sizeInBytes):

        (WebCore::DisplayList::DrawNativeImage::DrawNativeImage):

        (WebCore::DisplayList::DrawNativeImage::apply const):

        (WebCore::DisplayList::operator<<):

        (WebCore::DisplayList::DrawPlatformImage::DrawPlatformImage):

        (WebCore::DisplayList::DrawPlatformImage::apply const):

        * platform/graphics/displaylists/DisplayListItems.h:

        (WebCore::DisplayList::DrawNativeImage::create):

        (WebCore::DisplayList::DrawNativeImage::renderingResourceIdentifier const):

        (WebCore::DisplayList::DrawNativeImage::imageSize const):

        (WebCore::DisplayList::DrawNativeImage::options const):

        (WebCore::DisplayList::DrawNativeImage::encode const):

        (WebCore::DisplayList::DrawNativeImage::decode):

        (WebCore::DisplayList::DrawPlatformImage::create):

        (WebCore::DisplayList::DrawPlatformImage::source const):

        (WebCore::DisplayList::DrawPlatformImage::destinationRect const):

        (WebCore::DisplayList::DrawPlatformImage::encode const):

        (WebCore::DisplayList::DrawPlatformImage::decode):

        (WebCore::DisplayList::Item::encode const):

        (WebCore::DisplayList::Item::decode):

        * platform/graphics/displaylists/DisplayListRecorder.cpp:

        (WebCore::DisplayList::Recorder::drawNativeImage):

        (WebCore::DisplayList::Recorder::drawPlatformImage):

        * platform/graphics/displaylists/DisplayListRecorder.h:

        (WebCore::DisplayList::Recorder::Delegate::lockRemoteNativeImage):

        * platform/graphics/gstreamer/ImageDecoderGStreamer.cpp:

        (WebCore::ImageDecoderGStreamer::createFrameImageAtIndex):

        * platform/graphics/gstreamer/ImageDecoderGStreamer.h:

        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:

        (WebCore::MediaPlayerPrivateGStreamer::nativeImageForCurrentTime):

        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h:

        * platform/graphics/ios/IconIOS.mm:

        (WebCore::Icon::Icon):

        (WebCore::Icon::createIconForImage):

        (WebCore::Icon::paint):

        * platform/graphics/mac/ImageMac.mm:

        (WebCore::BitmapImage::tiffRepresentation):

        * platform/graphics/nicosia/NicosiaImageBufferPipe.cpp:

        (Nicosia::NicosiaImageBufferPipeSource::handle):

        * platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp:

        (Nicosia::CairoOperationRecorder::drawNativeImage):

        (Nicosia::CairoOperationRecorder::drawPlatformImage):

        (Nicosia::CairoOperationRecorder::drawPattern):

        (Nicosia::CairoOperationRecorder::clipToImageBuffer):

        * platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h:

        * platform/graphics/texmap/BitmapTextureGL.cpp:

        (WebCore::BitmapTextureGL::updateContents):

        * platform/graphics/texmap/GraphicsLayerTextureMapper.cpp:

        (WebCore::GraphicsLayerTextureMapper::GraphicsLayerTextureMapper):

        (WebCore::GraphicsLayerTextureMapper::setContentsToImage):

        * platform/graphics/texmap/GraphicsLayerTextureMapper.h:

        * platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.cpp:

        (WebCore::CoordinatedGraphicsLayer::CoordinatedGraphicsLayer):

        (WebCore::CoordinatedGraphicsLayer::setContentsToImage):

        (WebCore::CoordinatedGraphicsLayer::flushCompositingStateForThisLayerOnly):

        * platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.h:

        * platform/graphics/win/GraphicsContextDirect2D.cpp:

        (WebCore::GraphicsContext::drawPlatformImage):

        (WebCore::GraphicsContext::platformDrawNativeImage): Deleted.

        * platform/graphics/win/GraphicsContextImplDirect2D.cpp:

        (WebCore::GraphicsContextImplDirect2D::drawNativeImage):

        (WebCore::GraphicsContextImplDirect2D::drawPlatformImage):

        * platform/graphics/win/GraphicsContextImplDirect2D.h:

        * platform/graphics/win/ImageBufferDirect2DBackend.cpp:

        (WebCore::ImageBufferDirect2DBackend::create):

        (WebCore::ImageBufferDirect2DBackend::ImageBufferDirect2DBackend):

        (WebCore::ImageBufferDirect2DBackend::copyNativeImage const):

        (WebCore::createCroppedImageIfNecessary):

        (WebCore::ImageBufferDirect2DBackend::copyImage const):

        (WebCore::ImageBufferDirect2DBackend::sinkIntoImage):

        (WebCore::ImageBufferDirect2DBackend::compatibleBitmap):

        * platform/graphics/win/ImageBufferDirect2DBackend.h:

        * platform/graphics/win/ImageCGWin.cpp:

        (WebCore::BitmapImage::drawFrameMatchingSourceSize):

        * platform/graphics/win/ImageCairoWin.cpp:

        (WebCore::BitmapImage::drawFrameMatchingSourceSize):

        * platform/graphics/win/ImageDecoderDirect2D.cpp:

        (WebCore::ImageDecoderDirect2D::createFrameImageAtIndex):

        * platform/graphics/win/ImageDecoderDirect2D.h:

        * platform/graphics/win/NativeImageDirect2D.cpp:

        (WebCore::NativeImage::size):

        (WebCore::NativeImage::hasAlpha const):

        (WebCore::NativeImage::singlePixelSolidColor const):

        (WebCore::NativeImage::clearSubimages):

        (WebCore::nativeImageSize): Deleted.

        (WebCore::nativeImageHasAlpha): Deleted.

        (WebCore::nativeImageSinglePixelSolidColor): Deleted.

        (WebCore::drawNativeImage): Deleted.

        (WebCore::clearNativeImageSubimages): Deleted.

        * platform/image-decoders/ScalableImageDecoder.cpp:

        (WebCore::ScalableImageDecoder::createFrameImageAtIndex):

        * platform/image-decoders/ScalableImageDecoder.h:

        * platform/image-decoders/cairo/ImageBackingStoreCairo.cpp:

        (WebCore::ImageBackingStore::image const):

        * platform/mediastream/mac/DisplayCaptureSourceCocoa.cpp:

        (WebCore::DisplayCaptureSourceCocoa::emitFrame):

        * platform/mediastream/mac/DisplayCaptureSourceCocoa.h:

        * platform/mediastream/mac/MockRealtimeVideoSourceMac.mm:

        (WebCore::MockRealtimeVideoSourceMac::updateSampleBuffer):

        * platform/win/DragImageCGWin.cpp:

        (WebCore::createDragImageFromImage):

        * rendering/RenderThemeIOS.mm:

        (WebCore::RenderThemeIOS::paintSystemPreviewBadge):

        * svg/graphics/SVGImage.cpp:

        (WebCore::SVGImage::nativeImageForCurrentFrame):

        (WebCore::SVGImage::nativeImage):

        * svg/graphics/SVGImage.h:

        * svg/graphics/SVGImageForContainer.cpp:

        (WebCore::SVGImageForContainer::nativeImageForCurrentFrame):

        * svg/graphics/SVGImageForContainer.h:

2020-11-01  Mason Xiao  <me@masonx.ca>

        REGRESSION (r252689): box-shadow with inset and negative spread renders incorrectly

Source/WebKit/ChangeLog

2020-11-01  Said Abou-Hallawa  <said@apple.com>

        [GPU Process] Control the life cycle of the platform image by a new class named NativeImage

        https://bugs.webkit.org/show_bug.cgi?id=218427

        Reviewed by NOBODY (OOPS!).

        * Scripts/webkit/messages.py:

        * Shared/API/c/cg/WKImageCG.cpp:

        (WKImageCreateFromCGImage):

        * Shared/WebCoreArgumentCoders.cpp:

        (IPC::encodePlatformImage):

        (IPC::decodePlatformImage):

        (IPC::encodeOptionalPlatformImage):

        (IPC::decodeOptionalPlatformImage):

        (IPC::ArgumentCoder<PlatformImagePtr>::encode):

        (IPC::ArgumentCoder<PlatformImagePtr>::decode):

        (IPC::encodeNativeImage): Deleted.

        (IPC::decodeNativeImage): Deleted.

        (IPC::encodeOptionalNativeImage): Deleted.

        (IPC::decodeOptionalNativeImage): Deleted.

        (IPC::ArgumentCoder<NativeImagePtr>::encode): Deleted.

        (IPC::ArgumentCoder<NativeImagePtr>::decode): Deleted.

        * Shared/WebCoreArgumentCoders.h:

        * Shared/cg/ShareableBitmapCG.cpp:

        (WebKit::ShareableBitmap::createImage):

        * UIProcess/API/glib/IconDatabase.cpp:

        (WebKit::IconDatabase::loadIconForPageURL):

        (WebKit::IconDatabase::setIconForPageURL):

        * UIProcess/API/glib/IconDatabase.h:

        * UIProcess/ios/DragDropInteractionState.mm:

        (WebKit::uiImageForImage):

        * UIProcess/ios/WKContentViewInteraction.mm:

        (-[WKContentView _deliverDelayedDropPreviewIfPossible:]):

        (uiImageForImage):

        (-[WKContentView _handleDropByInsertingImagePlaceholders:session:]):

        (-[WKContentView _presentationSnapshotForPreviewItemController:]):

        * WebProcess/GPU/graphics/ImageBufferShareableBitmapBackend.cpp:

        (WebKit::ImageBufferShareableBitmapBackend::copyNativeImage const):

        * WebProcess/GPU/graphics/ImageBufferShareableBitmapBackend.h:

        * WebProcess/GPU/media/MediaPlayerPrivateRemote.cpp:

        (WebKit::MediaPlayerPrivateRemote::nativeImageForCurrentTime):

        * WebProcess/GPU/media/MediaPlayerPrivateRemote.h:

        * WebProcess/Plugins/PluginView.cpp:

        (WebKit::isAlmostSolidColor):

2020-11-01  Sam Weinig  <weinig@apple.com>

        Remove remaining alternative preference setting mechanisms from LayoutTests

Source/WebKitLegacy/mac/ChangeLog

2020-11-01  Said Abou-Hallawa  <said@apple.com>

        [GPU Process] Control the life cycle of the platform image by a new class named NativeImage

        https://bugs.webkit.org/show_bug.cgi?id=218427

        Reviewed by NOBODY (OOPS!).

        * DOM/DOM.mm:

        (-[DOMNode getPreviewSnapshotImage:andRects:]):

        * Misc/WebCache.mm:

        (+[WebCache imageForURL:]):

        * WebView/WebView.mm:

        (-[WebUITextIndicatorData initWithImage:textIndicatorData:scale:]):

2020-10-28  Sam Weinig  <weinig@apple.com>

        [Testing] Remove requirement of adding new SPI for each preference that needs testing

Source/WebCore/Headers.cmake

@@set(WebCore_PRIVATE_FRAMEWORK_HEADERS

    platform/graphics/MediaPlayerPrivate.h

    platform/graphics/MediaUsageInfo.h

    platform/graphics/NativeImage.h

1207 platform/graphics/NativeImagePtr.h

    platform/graphics/OpenGLESShims.h

    platform/graphics/OpenGLShims.h

    platform/graphics/Path.h

@@set(WebCore_PRIVATE_FRAMEWORK_HEADERS

    platform/graphics/PlatformDisplay.h

    platform/graphics/PlatformImageBuffer.h

    platform/graphics/PlatformImageBufferBackend.h

1215 platform/graphics/PlatformImagePtr.h

    platform/graphics/PlatformLayer.h

    platform/graphics/PlatformMediaResourceLoader.h

    platform/graphics/PlatformTextTrack.h

Source/WebCore/Sources.txt

@@platform/graphics/LayoutSize.cpp

platform/graphics/MIMETypeCache.cpp

platform/graphics/MediaPlayer.cpp

platform/graphics/NamedImageGeneratedImage.cpp

1942platform/graphics/NativeImage.cpp

platform/graphics/Path.cpp

platform/graphics/PathTraversalState.cpp

platform/graphics/PathUtilities.cpp

Source/WebCore/WebCore.xcodeproj/project.pbxproj

		724ED3321A3A8B2300F5F13C /* JSEXTBlendMinMax.h in Headers */ = {isa = PBXBuildFile; fileRef = 724ED3301A3A8B2300F5F13C /* JSEXTBlendMinMax.h */; };

		724EE5501DC80D7F00A91FFB /* ActivityState.h in Headers */ = {isa = PBXBuildFile; fileRef = 724EE54E1DC7F25B00A91FFB /* ActivityState.h */; settings = {ATTRIBUTES = (Private, ); }; };

		724EE5511DC80D8400A91FFB /* ActivityStateChangeObserver.h in Headers */ = {isa = PBXBuildFile; fileRef = 724EE54F1DC7F25B00A91FFB /* ActivityStateChangeObserver.h */; settings = {ATTRIBUTES = (Private, ); }; };

2160 726D56E2253AE28D0002EF90 /* N~~ative~~ImagePtr.h in Headers */ = {isa = PBXBuildFile; fileRef = 726D56E1253AE0430002EF90 /* N~~ative~~ImagePtr.h */; settings = {ATTRIBUTES = (Private, ); }; };

2160 726D56E2253AE28D0002EF90 /* PlatformImagePtr.h in Headers */ = {isa = PBXBuildFile; fileRef = 726D56E1253AE0430002EF90 /* PlatformImagePtr.h */; settings = {ATTRIBUTES = (Private, ); }; };

		726D56E3253AE3660002EF90 /* NativeImage.h in Headers */ = {isa = PBXBuildFile; fileRef = 55A336F61D8209F40022C4C7 /* NativeImage.h */; settings = {ATTRIBUTES = (Private, ); }; };

		727A7F3A24078B84004D2931 /* ImageBufferIOSurfaceBackend.h in Headers */ = {isa = PBXBuildFile; fileRef = 72BAC3AB23E1E544008D741C /* ImageBufferIOSurfaceBackend.h */; settings = {ATTRIBUTES = (Private, ); }; };

		7299BC6723D6A53200CC6883 /* AlphaPremultiplication.h in Headers */ = {isa = PBXBuildFile; fileRef = 7299BC6423D686A600CC6883 /* AlphaPremultiplication.h */; settings = {ATTRIBUTES = (Private, ); }; };

		724ED3301A3A8B2300F5F13C /* JSEXTBlendMinMax.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSEXTBlendMinMax.h; sourceTree = "<group>"; };

		724EE54E1DC7F25B00A91FFB /* ActivityState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ActivityState.h; sourceTree = "<group>"; };

		724EE54F1DC7F25B00A91FFB /* ActivityStateChangeObserver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ActivityStateChangeObserver.h; sourceTree = "<group>"; };

9939 7252396B254CADC200F5FB15 /* NativeImage.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = NativeImage.cpp; sourceTree = "<group>"; };

		7266F0132241BCE200833975 /* SVGPropertyAnimatorFactory.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SVGPropertyAnimatorFactory.h; sourceTree = "<group>"; };

		7266F0142241BFB200833975 /* SVGPrimitivePropertyAnimatorImpl.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SVGPrimitivePropertyAnimatorImpl.h; sourceTree = "<group>"; };

		7266F0152241C09800833975 /* SVGPrimitivePropertyAnimator.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SVGPrimitivePropertyAnimator.h; sourceTree = "<group>"; };

		7266F0282243120300833975 /* SVGAnimationAdditiveListFunctionImpl.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SVGAnimationAdditiveListFunctionImpl.h; sourceTree = "<group>"; };

		7266F029224312B100833975 /* SVGAnimationAdditiveListFunction.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SVGAnimationAdditiveListFunction.h; sourceTree = "<group>"; };

		7266F02A2243149B00833975 /* SVGAnimatedPropertyList.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SVGAnimatedPropertyList.h; sourceTree = "<group>"; };

9949 726D56E1253AE0430002EF90 /* N~~ative~~ImagePtr.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = N~~ative~~ImagePtr.h; sourceTree = "<group>"; };

9950 726D56E1253AE0430002EF90 /* PlatformImagePtr.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = PlatformImagePtr.h; sourceTree = "<group>"; };

		727AFED11A2EA6A0000442E8 /* EXTsRGB.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = EXTsRGB.cpp; sourceTree = "<group>"; };

		727AFED21A2EA6A0000442E8 /* EXTsRGB.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = EXTsRGB.h; sourceTree = "<group>"; };

		727AFED31A2EA6A0000442E8 /* EXTsRGB.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = EXTsRGB.idl; sourceTree = "<group>"; };

				07B93FF923B92AAA0036F8EA /* MIMETypeCache.h */,

				314BE3A41B3103FB00141982 /* NamedImageGeneratedImage.cpp */,

				314BE3A51B3103FB00141982 /* NamedImageGeneratedImage.h */,

26365 7252396B254CADC200F5FB15 /* NativeImage.cpp */,

2636426366 55A336F61D8209F40022C4C7 /* NativeImage.h */,

26365 726D56E1253AE0430002EF90 /* NativeImagePtr.h */,

				B27535520B053814002CE64F /* Path.cpp */,

				B27535530B053814002CE64F /* Path.h */,

				A88DD4880B4629B000C02990 /* PathTraversalState.cpp */,

				A8FA6E5B0E4CFDED00D5CF49 /* Pattern.h */,

				72BAC3A623E17328008D741C /* PlatformImageBuffer.h */,

				550640AD240756DA00AAE045 /* PlatformImageBufferBackend.h */,

26377 726D56E1253AE0430002EF90 /* PlatformImagePtr.h */,

				0562F9601573F88F0031CA16 /* PlatformLayer.h */,

				CEEFCD7B19DB33DC003876D7 /* PlatformMediaResourceLoader.h */,

				072847E216EBC5B00043CFA4 /* PlatformTextTrack.h */,

				A81872230977D3C0005826D9 /* NamedNodeMap.h in Headers */,

				A818721E0977D3C0005826D9 /* NameNodeList.h in Headers */,

				726D56E3253AE3660002EF90 /* NativeImage.h in Headers */,

33387 726D56E2253AE28D0002EF90 /* NativeImagePtr.h in Headers */,

				83B2D1751B8BCD6A00A02E47 /* NativeNodeFilter.h in Headers */,

				E10B9B6C0B747599003ED890 /* NativeXPathNSResolver.h in Headers */,

				93CCF0270AF6C52900018E89 /* NavigationAction.h in Headers */,

				A723F77B1484CA4C008C6DBE /* PlatformExportMacros.h in Headers */,

				515BE1951D54F5FB00DD7C68 /* PlatformGamepad.h in Headers */,

				550640AF2407582D00AAE045 /* PlatformImageBufferBackend.h in Headers */,

33614 726D56E2253AE28D0002EF90 /* PlatformImagePtr.h in Headers */,

				935C476809AC4D4300A6AAB4 /* PlatformKeyboardEvent.h in Headers */,

				0562F9611573F88F0031CA16 /* PlatformLayer.h in Headers */,

				F544F78915CFB2A800AF33A8 /* PlatformLocale.h in Headers */,

Source/WebCore/html/HTMLVideoElement.cpp

@@bool HTMLVideoElement::hasAvailableVideoFrame() const

    return player()->hasVideo() && player()->hasAvailableVideoFrame();

}

326 NativeImage~~Ptr~~ HTMLVideoElement::nativeImageForCurrentTime()

326RefPtr<NativeImage> HTMLVideoElement::nativeImageForCurrentTime()

{

    if (!player())

        return nullptr;

Source/WebCore/html/HTMLVideoElement.h

@@public:

    // Used by canvas to gain raw pixel access

    void paintCurrentFrameInContext(GraphicsContext&, const FloatRect&);

78 NativeImage~~Ptr~~ nativeImageForCurrentTime();

78 RefPtr<NativeImage> nativeImageForCurrentTime();

    // Used by WebGL to do GPU-GPU textures copy if possible.

    // See more details at MediaPlayer::copyVideoTextureToPlatformTexture() defined in Source/WebCore/platform/graphics/MediaPlayer.h.

Source/WebCore/html/canvas/CanvasRenderingContext2DBase.cpp

@@ExceptionOr<void> CanvasRenderingContext2DBase::drawImage(HTMLVideoElement& vide

    checkOrigin(&video);

#if USE(CG)

1638 if (Na~~tiveImagePtr~~ image = video.nativeImageForCurrentTime()) {

1639 c->drawNativeImage(image, FloatSize(video.videoWidth(), video.videoHeight()), dstRect, srcRect);

1638 if (auto image = video.nativeImageForCurrentTime()) {

1639 c->drawNativeImage(*image, FloatSize(video.videoWidth(), video.videoHeight()), dstRect, srcRect);

        if (rectContainsCanvas(dstRect))

            didDrawEntireCanvas();

        else

Source/WebCore/page/mac/TextIndicatorWindow.mm

@@static bool indicatorWantsManualAnimation(const TextIndicator& indicator)

    FloatSize contentsImageLogicalSize = _textIndicator->contentImage()->size();

    contentsImageLogicalSize.scale(1 / _textIndicator->contentImageScaleFactor());

164 Re~~tain~~Ptr<CGImage~~Ref~~> contentsImage;

164 RefPtr<NativeImage> contentsImage;

    if (indicatorWantsContentCrossfade(*_textIndicator))

        contentsImage = _textIndicator->contentImageWithHighlight()->nativeImage();

    else

@@static RetainPtr<CAKeyframeAnimation> createBounceAnimation(CFTimeInterval durat

static RetainPtr<CABasicAnimation> createContentCrossfadeAnimation(CFTimeInterval duration, TextIndicator& textIndicator)

{

    RetainPtr<CABasicAnimation> crossfadeAnimation = [CABasicAnimation animationWithKeyPath:@"contents"];

269 RetainPtr<CGImageRef> contentsImage = textIndicator.contentImage()->nativeImage();

269 RetainPtr<CGImageRef> contentsImage = textIndicator.contentImage()->nativeImage()->platformImage();

    [crossfadeAnimation setToValue:(__bridge id)contentsImage.get()];

    [crossfadeAnimation setFillMode:kCAFillModeForwards];

    [crossfadeAnimation setRemovedOnCompletion:NO];

Source/WebCore/platform/graphics/BitmapImage.cpp

@@BitmapImage::BitmapImage(ImageObserver* observer)

{

}

55 BitmapImage::BitmapImage(NativeImage~~Ptr~~&& image, ImageObserver* observer)

55BitmapImage::BitmapImage(RefPtr<NativeImage>&& image, ImageObserver* observer)

    : Image(observer)

    , m_source(ImageSource::create(WTFMove(image)))

{

@@void BitmapImage::setCurrentFrameDecodingStatusIfNecessary(DecodingStatus decodi

    m_currentFrameDecodingStatus = decodingStatus;

}

131 NativeImage~~Ptr~~ BitmapImage::frameImageAtIndexCacheIfNeeded(size_t index, SubsamplingLevel subsamplingLevel, const GraphicsContext* targetContext)

131RefPtr<NativeImage> BitmapImage::frameImageAtIndexCacheIfNeeded(size_t index, SubsamplingLevel subsamplingLevel, const GraphicsContext* targetContext)

{

    if (!frameHasFullSizeNativeImageAtIndex(index, subsamplingLevel)) {

        LOG(Images, "BitmapImage::%s - %p - url: %s [subsamplingLevel was %d, resampling]", __FUNCTION__, this, sourceURL().string().utf8().data(), static_cast<int>(frameSubsamplingLevelAtIndex(index)));

@@NativeImagePtr BitmapImage::frameImageAtIndexCacheIfNeeded(size_t index, Subsamp

    return m_source->frameImageAtIndexCacheIfNeeded(index, subsamplingLevel);

}

145 NativeImage~~Ptr~~ BitmapImage::nativeImage(const GraphicsContext* targetContext)

145RefPtr<NativeImage> BitmapImage::nativeImage(const GraphicsContext* targetContext)

{

    return frameImageAtIndexCacheIfNeeded(0, SubsamplingLevel::Default, targetContext);

}

150 NativeImage~~Ptr~~ BitmapImage::nativeImageForCurrentFrame(const GraphicsContext* targetContext)

150RefPtr<NativeImage> BitmapImage::nativeImageForCurrentFrame(const GraphicsContext* targetContext)

{

    return frameImageAtIndexCacheIfNeeded(m_currentFrame, SubsamplingLevel::Default, targetContext);

}

155 NativeImage~~Ptr~~ BitmapImage::preTransformedNativeImageForCurrentFrame(bool respectOrientation, const GraphicsContext* targetContext)

155RefPtr<NativeImage> BitmapImage::preTransformedNativeImageForCurrentFrame(bool respectOrientation, const GraphicsContext* targetContext)

{

    auto image = nativeImageForCurrentFrame(targetContext);

@@NativeImagePtr BitmapImage::preTransformedNativeImageForCurrentFrame(bool respec

    FloatRect destRect(FloatPoint(), correctedSizeFloat);

    FloatRect sourceRect(FloatPoint(), sourceSize);

174 buffer->context().drawNativeImage(image, sourceSize, destRect, sourceRect, { orientation });

174 buffer->context().drawNativeImage(*image, sourceSize, destRect, sourceRect, { orientation });

    return ImageBuffer::sinkIntoNativeImage(WTFMove(buffer));

}

#if USE(CG)

179 NativeImage~~Ptr~~ BitmapImage::nativeImageOfSize(const IntSize& size, const GraphicsContext* targetContext)

179RefPtr<NativeImage> BitmapImage::nativeImageOfSize(const IntSize& size, const GraphicsContext* targetContext)

{

    size_t count = frameCount();

    for (size_t i = 0; i < count; ++i) {

        auto image = frameImageAtIndexCacheIfNeeded(i, SubsamplingLevel::Default, targetContext);

185 if (image && ~~nativeImageSize(~~image) == size)

185 if (image && image->size() == size)

            return image;

    }

@@NativeImagePtr BitmapImage::nativeImageOfSize(const IntSize& size, const Graphic

    return frameImageAtIndexCacheIfNeeded(0, SubsamplingLevel::Default, targetContext);

}

193 Vector<NativeImage~~Ptr~~> BitmapImage::framesNativeImages()

193Vector<RefPtr<NativeImage>> BitmapImage::framesNativeImages()

194194{

195 Vector<NativeImage~~Ptr~~> images;

195 Vector<RefPtr<NativeImage>> images;

    size_t count = frameCount();

    for (size_t i = 0; i < count; ++i) {

        if (auto image = frameImageAtIndexCacheIfNeeded(i))

200 images.append(image);

200 images.append(WTFMove(image));

    }

    return images;

@@bool BitmapImage::notSolidColor()

}

#endif // ASSERT_ENABLED

214 static inline void drawNativeImage(~~const~~ NativeImage~~Ptr~~& image, GraphicsContext& context, const FloatRect& destRect, const FloatRect& srcRect, const IntSize& srcSize, const ImagePaintingOptions& options)

214static inline void drawNativeImage(NativeImage& image, GraphicsContext& context, const FloatRect& destRect, const FloatRect& srcRect, const IntSize& srcSize, const ImagePaintingOptions& options)

215215{

216216 // Subsampling may have given us an image that is smaller than size().

217 IntSize subsampledImageSize = ~~nativeImageSize(~~image);

217 IntSize subsampledImageSize = image.size();

    if (options.orientation().usesWidthAsHeight())

        subsampledImageSize = subsampledImageSize.transposedSize();

@@ImageDrawResult BitmapImage::draw(GraphicsContext& context, const FloatRect& des

    m_currentSubsamplingLevel = m_allowSubsampling ? subsamplingLevelForScaleFactor(context, scaleFactorForDrawing) : SubsamplingLevel::Default;

    LOG(Images, "BitmapImage::%s - %p - url: %s [subsamplingLevel = %d scaleFactorForDrawing = (%.4f, %.4f)]", __FUNCTION__, this, sourceURL().string().utf8().data(), static_cast<int>(m_currentSubsamplingLevel), scaleFactorForDrawing.width(), scaleFactorForDrawing.height());

249 NativeImage~~Ptr~~ image;

249 RefPtr<NativeImage> image;

    if (options.decodingMode() == DecodingMode::Asynchronous) {

        ASSERT(!canAnimate());

        ASSERT(!m_currentFrame || m_animationFinished);

@@ImageDrawResult BitmapImage::draw(GraphicsContext& context, const FloatRect& des

    auto orientation = options.orientation();

    if (orientation == ImageOrientation::FromImage) {

        orientation = frameOrientationAtIndex(m_currentFrame);

325 drawNativeImage(image, context, destRect, srcRect, IntSize(sourceSize(orientation)), { options, orientation });

325 drawNativeImage(*image, context, destRect, srcRect, IntSize(sourceSize(orientation)), { options, orientation });

326326 } else

327 drawNativeImage(image, context, destRect, srcRect, IntSize(sourceSize(orientation)), options);

327 drawNativeImage(*image, context, destRect, srcRect, IntSize(sourceSize(orientation)), options);

    m_currentFrameDecodingStatus = frameDecodingStatusAtIndex(m_currentFrame);

Source/WebCore/platform/graphics/BitmapImage.h

@@class Timer;

class BitmapImage final : public Image {

public:

56 static Ref<BitmapImage> create(NativeImagePtr&& nativeImage, ImageObserver* observer = nullptr)

    static Ref<BitmapImage> create(PlatformImagePtr&& platformImage, ImageObserver* observer = nullptr)

    {

        return adoptRef(*new BitmapImage(NativeImage::create(WTFMove(platformImage)), observer));

    }

    static Ref<BitmapImage> create(RefPtr<NativeImage>&& nativeImage, ImageObserver* observer = nullptr)

    {

        return adoptRef(*new BitmapImage(WTFMove(nativeImage), observer));

    }

@@public:

#endif

#endif

    WEBCORE_EXPORT NativeImagePtr nativeImage(const GraphicsContext* = nullptr) override;

    NativeImagePtr nativeImageForCurrentFrame(const GraphicsContext* = nullptr) override;

    NativeImagePtr preTransformedNativeImageForCurrentFrame(bool respectOrientation, const GraphicsContext* = nullptr) override;

    WEBCORE_EXPORT RefPtr<NativeImage> nativeImage(const GraphicsContext* = nullptr) override;

    RefPtr<NativeImage> nativeImageForCurrentFrame(const GraphicsContext* = nullptr) override;

    RefPtr<NativeImage> preTransformedNativeImageForCurrentFrame(bool respectOrientation, const GraphicsContext* = nullptr) override;

141145#if USE(CG)

142 NativeImage~~Ptr~~ nativeImageOfSize(const IntSize&, const GraphicsContext* = nullptr) override;

143 Vector<NativeImage~~Ptr~~> framesNativeImages();

146 RefPtr<NativeImage> nativeImageOfSize(const IntSize&, const GraphicsContext* = nullptr) override;

147 Vector<RefPtr<NativeImage>> framesNativeImages();

#endif

    void imageFrameAvailableAtIndex(size_t);

    void decode(Function<void()>&&);

private:

150 WEBCORE_EXPORT BitmapImage(NativeImage~~Ptr~~&&, ImageObserver* = nullptr);

154 WEBCORE_EXPORT BitmapImage(RefPtr<NativeImage>&&, ImageObserver* = nullptr);

151155 WEBCORE_EXPORT BitmapImage(ImageObserver* = nullptr);

152156

153 NativeImage~~Ptr~~ frameImageAtIndex(size_t index) { return m_source->frameImageAtIndex(index); }

154 NativeImage~~Ptr~~ frameImageAtIndexCacheIfNeeded(size_t, SubsamplingLevel = SubsamplingLevel::Default, const GraphicsContext* = nullptr);

157 RefPtr<NativeImage> frameImageAtIndex(size_t index) { return m_source->frameImageAtIndex(index); }

158 RefPtr<NativeImage> frameImageAtIndexCacheIfNeeded(size_t, SubsamplingLevel = SubsamplingLevel::Default, const GraphicsContext* = nullptr);

    // Called to invalidate cached data. When |destroyAll| is true, we wipe out

    // the entire frame buffer cache and tell the image source to destroy

@@private:

#endif

#if PLATFORM(COCOA)

201 RetainPtr<CFDataRef> tiffRepresentation(const Vector<NativeImage~~Ptr~~>&);

205 RetainPtr<CFDataRef> tiffRepresentation(const Vector<RefPtr<NativeImage>>&);

#endif

    void clearTimer();

Source/WebCore/platform/graphics/ConcreteImageBuffer.h

@@protected:

        return m_backend ? m_backend->externalMemoryCost() : 0;

    }

118 NativeImage~~Ptr~~ copyNativeImage(BackingStoreCopy copyBehavior = CopyBackingStore) const override

118 RefPtr<NativeImage> copyNativeImage(BackingStoreCopy copyBehavior = CopyBackingStore) const override

    {

        if (auto* backend = ensureBackendCreated()) {

            const_cast<ConcreteImageBuffer&>(*this).flushDrawingContext();

@@protected:

        }

    }

152 NativeImage~~Ptr~~ sinkIntoNativeImage() override

152 RefPtr<NativeImage> sinkIntoNativeImage() override

    {

        if (auto* backend = ensureBackendCreated()) {

            flushDrawingContext();

Source/WebCore/platform/graphics/GraphicsContext.cpp

@@void GraphicsContext::drawBidiText(const FontCascade& font, const TextRun& run,

    bidiRuns.clear();

}

734 void GraphicsContext::drawNativeImage(~~const~~ NativeImage~~Ptr~~& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

734void GraphicsContext::drawNativeImage(NativeImage& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

{

    if (paintingDisabled())

        return;

739 if (m_impl) {

740 m_impl->drawNativeImage(image, imageSize, destRect, srcRect, options);

739 if (m_impl && m_impl->drawNativeImage(image, imageSize, destRect, srcRect, options))

741740 return;

742 }

743741

744 platform~~DrawNative~~Image(image, imageSize, destRect, srcRect, options);

742 drawPlatformImage(image.platformImage(), imageSize, destRect, srcRect, options);

}

ImageDrawResult GraphicsContext::drawImage(Image& image, const FloatPoint& destination, const ImagePaintingOptions& imagePaintingOptions)

Source/WebCore/platform/graphics/GraphicsContext.h

@@public:

    WEBCORE_EXPORT void strokeRect(const FloatRect&, float lineWidth);

382 WEBCORE_EXPORT void drawNativeImage(const NativeImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& = { });

382 WEBCORE_EXPORT void drawNativeImage(NativeImage&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& = { });

383 WEBCORE_EXPORT void drawPlatformImage(const PlatformImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& = { });

    WEBCORE_EXPORT ImageDrawResult drawImage(Image&, const FloatPoint& destination, const ImagePaintingOptions& = { ImageOrientation::FromImage });

    WEBCORE_EXPORT ImageDrawResult drawImage(Image&, const FloatRect& destination, const ImagePaintingOptions& = { ImageOrientation::FromImage });

@@private:

    void platformFillRoundedRect(const FloatRoundedRect&, const Color&);

653 void platformDrawNativeImage(const NativeImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&);

654

    FloatRect computeLineBoundsAndAntialiasingModeForText(const FloatRect&, bool printing, Color&);

    float dashedLineCornerWidthForStrokeWidth(float) const;

Source/WebCore/platform/graphics/GraphicsContextGLImageExtractor.h

@@private:

#if USE(CAIRO)

    RefPtr<cairo_surface_t> m_imageSurface;

#elif USE(CG)

62 Re~~tain~~Ptr<CGImage~~Ref~~> m_cgImage;

63 Re~~tain~~Ptr<CGImage~~Ref~~> m_decodedImage;

62 RefPtr<NativeImage> m_cgImage;

63 RefPtr<NativeImage> m_decodedImage;

    RetainPtr<CFDataRef> m_pixelData;

    UniqueArray<uint8_t> m_formalizedRGBA8Data;

#endif

Source/WebCore/platform/graphics/GraphicsContextImpl.h

@@public:

    virtual ImageDrawResult drawTiledImage(Image&, const FloatRect& destination, const FloatRect& source, const FloatSize& tileScaleFactor, Image::TileRule hRule, Image::TileRule vRule, const ImagePaintingOptions&) = 0;

    virtual bool drawImageBuffer(ImageBuffer&, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions&) = 0;

77 virtual void drawNativeImage(const NativeImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&) = 0;

77 virtual bool drawNativeImage(NativeImage&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&) = 0;

78 virtual void drawPlatformImage(const PlatformImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&) = 0;

    virtual void drawPattern(Image&, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform&, const FloatPoint& phase, const FloatSize& spacing, const ImagePaintingOptions&) = 0;

    virtual void drawRect(const FloatRect&, float borderThickness) = 0;

Source/WebCore/platform/graphics/Icon.h

#include <wtf/RetainPtr.h>

#if PLATFORM(IOS_FAMILY)

30 #include "N~~ative~~Image.h"

30#include "PlatformImagePtr.h"

#include <CoreGraphics/CoreGraphics.h>

#elif PLATFORM(MAC)

OBJC_CLASS NSImage;

@@public:

#if PLATFORM(IOS_FAMILY)

    // FIXME: Make this work for non-iOS ports and remove the PLATFORM(IOS_FAMILY)-guard.

57 WEBCORE_EXPORT static RefPtr<Icon> createIconForImage(const N~~ative~~ImagePtr&);

57 WEBCORE_EXPORT static RefPtr<Icon> createIconForImage(const PlatformImagePtr&);

#endif

#if PLATFORM(MAC)

@@public:

private:

#if PLATFORM(IOS_FAMILY)

67 Icon(const Re~~tainPtr<CG~~Image~~Ref>~~&);

67 Icon(const PlatformImagePtr&);

    RetainPtr<CGImageRef> m_cgImage;

#elif PLATFORM(MAC)

    Icon(NSImage*);

Source/WebCore/platform/graphics/Image.h

#include "ImageOrientation.h"

#include "ImagePaintingOptions.h"

#include "ImageTypes.h"

37 #include "NativeImage~~Ptr~~.h"

37#include "NativeImage.h"

#include "Timer.h"

#include <wtf/EnumTraits.h>

#include <wtf/Optional.h>

@@public:

    enum TileRule { StretchTile, RoundTile, SpaceTile, RepeatTile };

    virtual NativeImagePtr nativeImage(const GraphicsContext* = nullptr) { return nullptr; }

    virtual NativeImagePtr nativeImageForCurrentFrame(const GraphicsContext* = nullptr) { return nullptr; }

    virtual NativeImagePtr preTransformedNativeImageForCurrentFrame(bool = true, const GraphicsContext* = nullptr) { return nullptr; }

    virtual NativeImagePtr nativeImageOfSize(const IntSize&, const GraphicsContext* = nullptr) { return nullptr; }

    virtual RefPtr<NativeImage> nativeImage(const GraphicsContext* = nullptr) { return nullptr; }

    virtual RefPtr<NativeImage> nativeImageForCurrentFrame(const GraphicsContext* = nullptr) { return nullptr; }

    virtual RefPtr<NativeImage> preTransformedNativeImageForCurrentFrame(bool = true, const GraphicsContext* = nullptr) { return nullptr; }

    virtual RefPtr<NativeImage> nativeImageOfSize(const IntSize&, const GraphicsContext* = nullptr) { return nullptr; }

    // Accessors for native image formats.

Source/WebCore/platform/graphics/ImageBackingStore.h

@@public:

        return std::unique_ptr<ImageBackingStore>(new ImageBackingStore(other));

    }

55 N~~ative~~ImagePtr image() const;

55 PlatformImagePtr image() const;

    bool setSize(const IntSize& size)

    {

Source/WebCore/platform/graphics/ImageBuffer.cpp

@@std::unique_ptr<ImageBuffer> ImageBuffer::copyRectToBuffer(const FloatRect& rect

    return buffer;

}

191 NativeImage~~Ptr~~ ImageBuffer::sinkIntoNativeImage(std::unique_ptr<ImageBuffer> imageBuffer)

191RefPtr<NativeImage> ImageBuffer::sinkIntoNativeImage(std::unique_ptr<ImageBuffer> imageBuffer)

{

    return imageBuffer->sinkIntoNativeImage();

}

Source/WebCore/platform/graphics/ImageBuffer.h

@@public:

    virtual size_t memoryCost() const = 0;

    virtual size_t externalMemoryCost() const = 0;

82 virtual NativeImage~~Ptr~~ copyNativeImage(BackingStoreCopy = CopyBackingStore) const = 0;

82 virtual RefPtr<NativeImage> copyNativeImage(BackingStoreCopy = CopyBackingStore) const = 0;

    virtual RefPtr<Image> copyImage(BackingStoreCopy = CopyBackingStore, PreserveResolution = PreserveResolution::No) const = 0;

    // Create an image buffer compatible with the context and copy rect from this buffer into this new one.

@@public:

    virtual void draw(GraphicsContext&, const FloatRect& destRect, const FloatRect& srcRect = FloatRect(0, 0, -1, -1), const ImagePaintingOptions& = { }) = 0;

    virtual void drawPattern(GraphicsContext&, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize& spacing, const ImagePaintingOptions& = { }) = 0;

91 static NativeImage~~Ptr~~ sinkIntoNativeImage(std::unique_ptr<ImageBuffer>);

91 static RefPtr<NativeImage> sinkIntoNativeImage(std::unique_ptr<ImageBuffer>);

    WEBCORE_EXPORT static RefPtr<Image> sinkIntoImage(std::unique_ptr<ImageBuffer>, PreserveResolution = PreserveResolution::No);

    static void drawConsuming(std::unique_ptr<ImageBuffer>, GraphicsContext&, const FloatRect& destRect, const FloatRect& srcRect = FloatRect(0, 0, -1, -1), const ImagePaintingOptions& = { });

@@public:

protected:

    ImageBuffer() = default;

114 virtual NativeImage~~Ptr~~ sinkIntoNativeImage() = 0;

114 virtual RefPtr<NativeImage> sinkIntoNativeImage() = 0;

    virtual RefPtr<Image> sinkIntoImage(PreserveResolution = PreserveResolution::No) = 0;

    virtual void drawConsuming(GraphicsContext&, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&) = 0;

};

Source/WebCore/platform/graphics/ImageBufferBackend.cpp

@@IntSize ImageBufferBackend::calculateBackendSize(const FloatSize& size, float re

    return backendSize;

}

61 NativeImage~~Ptr~~ ImageBufferBackend::sinkIntoNativeImage()

61RefPtr<NativeImage> ImageBufferBackend::sinkIntoNativeImage()

{

    return copyNativeImage(DontCopyBackingStore);

}

Source/WebCore/platform/graphics/ImageBufferBackend.h

#include "GraphicsTypesGL.h"

#include "ImagePaintingOptions.h"

#include "IntRect.h"

34 #include "NativeImage~~Ptr~~.h"

34#include "NativeImage.h"

#include "PlatformLayer.h"

#include <wtf/RefPtr.h>

#include <wtf/Vector.h>

@@public:

    virtual size_t memoryCost() const { return 4 * m_backendSize.area().unsafeGet(); }

    virtual size_t externalMemoryCost() const { return 0; }

80 virtual NativeImage~~Ptr~~ copyNativeImage(BackingStoreCopy) const = 0;

80 virtual RefPtr<NativeImage> copyNativeImage(BackingStoreCopy) const = 0;

    virtual RefPtr<Image> copyImage(BackingStoreCopy, PreserveResolution) const = 0;

    WEBCORE_EXPORT virtual void draw(GraphicsContext&, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&) = 0;

    WEBCORE_EXPORT virtual void drawPattern(GraphicsContext&, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize& spacing, const ImagePaintingOptions&) = 0;

86 WEBCORE_EXPORT virtual NativeImage~~Ptr~~ sinkIntoNativeImage();

86 WEBCORE_EXPORT virtual RefPtr<NativeImage> sinkIntoNativeImage();

    WEBCORE_EXPORT virtual RefPtr<Image> sinkIntoImage(PreserveResolution);

    WEBCORE_EXPORT virtual void drawConsuming(GraphicsContext& destContext, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&);

Source/WebCore/platform/graphics/ImageDecoder.h

#include "ImageTypes.h"

#include "IntPoint.h"

#include "IntSize.h"

33 #include "N~~ative~~Image.h"

33#include "PlatformImagePtr.h"

#include <wtf/Optional.h>

#include <wtf/Seconds.h>

#include <wtf/text/WTFString.h>

@@public:

    virtual bool frameAllowSubsamplingAtIndex(size_t) const = 0;

    virtual unsigned frameBytesAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default) const = 0;

77 virtual N~~ative~~ImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, const DecodingOptions& = DecodingOptions(DecodingMode::Synchronous)) = 0;

77 virtual PlatformImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, const DecodingOptions& = DecodingOptions(DecodingMode::Synchronous)) = 0;

    virtual void setExpectedContentSize(long long) { }

    virtual void setData(SharedBuffer&, bool allDataReceived) = 0;

Source/WebCore/platform/graphics/ImageFrame.cpp

@@unsigned ImageFrame::clearImage()

    unsigned frameBytes = this->frameBytes();

85 ~~clearNativeImageSubimages(~~m_nativeImage);

85 m_nativeImage->clearSubimages();

    m_nativeImage = nullptr;

    m_decodingOptions = DecodingOptions();

@@Color ImageFrame::singlePixelSolidColor() const

    if (!hasNativeImage() || m_size != IntSize(1, 1))

        return Color();

124 return nativeImageSinglePixelSolidColor(~~m_nativeImage~~);

124 return m_nativeImage->singlePixelSolidColor();

}

}

Source/WebCore/platform/graphics/ImageFrame.h

@@public:

    unsigned frameBytes() const { return hasNativeImage() ? (size().area() * sizeof(uint32_t)).unsafeGet() : 0; }

    SubsamplingLevel subsamplingLevel() const { return m_subsamplingLevel; }

66 NativeImage~~Ptr~~ nativeImage() const { return m_nativeImage; }

66 RefPtr<NativeImage> nativeImage() const { return m_nativeImage; }

    void setOrientation(ImageOrientation orientation) { m_orientation = orientation; };

    ImageOrientation orientation() const { return m_orientation; }

@@private:

    DecodingStatus m_decodingStatus { DecodingStatus::Invalid };

    IntSize m_size;

91 NativeImage~~Ptr~~ m_nativeImage;

91 RefPtr<NativeImage> m_nativeImage;

    SubsamplingLevel m_subsamplingLevel { SubsamplingLevel::Default };

    DecodingOptions m_decodingOptions;

Source/WebCore/platform/graphics/ImageSource.cpp

@@ImageSource::ImageSource(BitmapImage* image, AlphaOption alphaOption, GammaAndCo

{

}

52 ImageSource::ImageSource(NativeImage~~Ptr~~&& nativeImage)

52ImageSource::ImageSource(RefPtr<NativeImage>&& nativeImage)

    : m_runLoop(RunLoop::current())

{

    m_frameCount = 1;

@@void ImageSource::growFrames()

        m_frames.grow(newSize);

}

238 void ImageSource::setNativeImage(NativeImage~~Ptr~~&& nativeImage)

238void ImageSource::setNativeImage(RefPtr<NativeImage>&& nativeImage)

{

    ASSERT(m_frames.size() == 1);

    ImageFrame& frame = m_frames[0];

@@void ImageSource::setNativeImage(NativeImagePtr&& nativeImage)

    frame.m_nativeImage = WTFMove(nativeImage);

    frame.m_decodingStatus = DecodingStatus::Complete;

248 frame.m_size = ~~nativeImageSize(~~frame.m_nativeImage);

249 frame.m_hasAlpha = ~~nativeImageHasAlpha(~~frame.m_nativeImage);

248 frame.m_size = frame.m_nativeImage->size();

249 frame.m_hasAlpha = frame.m_nativeImage->hasAlpha();

}

void ImageSource::cacheMetadataAtIndex(size_t index, SubsamplingLevel subsamplingLevel, DecodingStatus decodingStatus)

@@void ImageSource::cacheMetadataAtIndex(size_t index, SubsamplingLevel subsamplin

    if (frame.m_decodingOptions.hasSizeForDrawing()) {

        ASSERT(frame.hasNativeImage());

270 frame.m_size = ~~nativeImageSize(~~frame.nativeImage());

270 frame.m_size = frame.nativeImage()->size();

    } else

        frame.m_size = m_decoder->frameSizeAtIndex(index, subsamplingLevel);

@@void ImageSource::cacheMetadataAtIndex(size_t index, SubsamplingLevel subsamplin

        frame.m_duration = m_decoder->frameDurationAtIndex(index);

}

282 void ImageSource::cacheN~~ative~~ImageAtIndex(N~~ative~~ImagePtr&& n~~ative~~Image, size_t index, SubsamplingLevel subsamplingLevel, const DecodingOptions& decodingOptions, DecodingStatus decodingStatus)

282void ImageSource::cachePlatformImageAtIndex(PlatformImagePtr&& platformImage, size_t index, SubsamplingLevel subsamplingLevel, const DecodingOptions& decodingOptions, DecodingStatus decodingStatus)

{

    ASSERT(index < m_frames.size());

    ImageFrame& frame = m_frames[index];

@@void ImageSource::cacheNativeImageAtIndex(NativeImagePtr&& nativeImage, size_t i

        return;

    // Move the new image to the cache.

296 frame.m_nativeImage = ~~WTFMove(n~~ativeImage);

296 frame.m_nativeImage = NativeImage::create(WTFMove(platformImage));

    frame.m_decodingOptions = decodingOptions;

    cacheMetadataAtIndex(index, subsamplingLevel, decodingStatus);

@@void ImageSource::cacheNativeImageAtIndex(NativeImagePtr&& nativeImage, size_t i

    decodedSizeIncreased(frame.frameBytes());

}

304 void ImageSource::cacheN~~ative~~ImageAtIndexAsync(N~~ative~~ImagePtr&& n~~ative~~Image, size_t index, SubsamplingLevel subsamplingLevel, const DecodingOptions& decodingOptions, DecodingStatus decodingStatus)

304void ImageSource::cachePlatformImageAtIndexAsync(PlatformImagePtr&& platformImage, size_t index, SubsamplingLevel subsamplingLevel, const DecodingOptions& decodingOptions, DecodingStatus decodingStatus)

{

    if (!isDecoderAvailable())

        return;

@@void ImageSource::cacheNativeImageAtIndexAsync(NativeImagePtr&& nativeImage, siz

    ASSERT(index < m_frames.size());

    // Clean the old native image and set a new one

312 cacheN~~ative~~ImageAtIndex(WTFMove(n~~ative~~Image), index, subsamplingLevel, decodingOptions, decodingStatus);

312 cachePlatformImageAtIndex(WTFMove(platformImage), index, subsamplingLevel, decodingOptions, decodingStatus);

    LOG(Images, "ImageSource::%s - %p - url: %s [frame %ld has been cached]", __FUNCTION__, this, sourceURL().string().utf8().data(), index);

    // Notify the image with the readiness of the new frame NativeImage.

@@void ImageSource::startAsyncDecodingQueue()

                startingTime = MonotonicTime::now();

            // Get the frame NativeImage on the decoding thread.

365 N~~ativeImagePtr native~~Image = protectedDecoder->createFrameImageAtIndex(frameRequest.index, frameRequest.subsamplingLevel, frameRequest.decodingOptions);

366 if (n~~ative~~Image)

365 auto platformImage = protectedDecoder->createFrameImageAtIndex(frameRequest.index, frameRequest.subsamplingLevel, frameRequest.decodingOptions);

366 if (platformImage)

                LOG(Images, "ImageSource::%s - %p - url: %s [frame %ld has been decoded]", __FUNCTION__, protectedThis.ptr(), sourceURL.utf8().data(), frameRequest.index);

            else {

                LOG(Images, "ImageSource::%s - %p - url: %s [decoding for frame %ld has failed]", __FUNCTION__, protectedThis.ptr(), sourceURL.utf8().data(), frameRequest.index);

@@void ImageSource::startAsyncDecodingQueue()

                sleep(minDecodingDuration - (MonotonicTime::now() - startingTime));

            // Update the cached frames on the creation thread to avoid updating the MemoryCache from a different thread.

378 callOnMainThread([protectedThis, protectedDecodingQueue, protectedDecoder, sourceURL = sourceURL.isolatedCopy(), n~~ative~~Image = WTFMove(n~~ative~~Image), frameRequest] () mutable {

378 callOnMainThread([protectedThis, protectedDecodingQueue, protectedDecoder, sourceURL = sourceURL.isolatedCopy(), platformImage = WTFMove(platformImage), frameRequest] () mutable {

                // The queue may have been closed if after we got the frame NativeImage, stopAsyncDecodingQueue() was called.

                if (protectedDecodingQueue.ptr() == protectedThis->m_decodingQueue && protectedDecoder.ptr() == protectedThis->m_decoder) {

                    ASSERT(protectedThis->m_frameCommitQueue.first() == frameRequest);

                    protectedThis->m_frameCommitQueue.removeFirst();

383 protectedThis->cacheN~~ative~~ImageAtIndexAsync(WTFMove(n~~ative~~Image), frameRequest.index, frameRequest.subsamplingLevel, frameRequest.decodingOptions, frameRequest.decodingStatus);

383 protectedThis->cachePlatformImageAtIndexAsync(WTFMove(platformImage), frameRequest.index, frameRequest.subsamplingLevel, frameRequest.decodingOptions, frameRequest.decodingStatus);

                } else

                    LOG(Images, "ImageSource::%s - %p - url: %s [frame %ld will not cached]", __FUNCTION__, protectedThis.ptr(), sourceURL.utf8().data(), frameRequest.index);

            });

@@const ImageFrame& ImageSource::frameAtIndexCacheIfNeeded(size_t index, ImageFram

        if (frame.hasFullSizeNativeImage(subsamplingLevel))

            break;

        // We have to perform synchronous image decoding in this code.

457 N~~ativeImagePtr native~~Image = m_decoder->createFrameImageAtIndex(index, subsamplingLevelValue);

457 auto platformImage = m_decoder->createFrameImageAtIndex(index, subsamplingLevelValue);

458458 // Clean the old native image and set a new one.

459 cacheN~~ative~~ImageAtIndex(WTFMove(n~~ative~~Image), index, subsamplingLevelValue, DecodingOptions(DecodingMode::Synchronous));

459 cachePlatformImageAtIndex(WTFMove(platformImage), index, subsamplingLevelValue, DecodingOptions(DecodingMode::Synchronous));

        break;

    }

@@void ImageSource::setTargetContext(const GraphicsContext* targetContext)

}

#endif

700 NativeImage~~Ptr~~ ImageSource::createFrameImageAtIndex(size_t index, SubsamplingLevel subsamplingLevel)

700RefPtr<NativeImage> ImageSource::createFrameImageAtIndex(size_t index, SubsamplingLevel subsamplingLevel)

701701{

702 return isDecoderAvailable() ? m_decoder->createFrameImageAtIndex(index, subsamplingLevel) : nullptr;

    if (!isDecoderAvailable())

        return nullptr;

    return NativeImage::create(m_decoder->createFrameImageAtIndex(index, subsamplingLevel));

703705}

704706

705 NativeImage~~Ptr~~ ImageSource::frameImageAtIndex(size_t index)

707RefPtr<NativeImage> ImageSource::frameImageAtIndex(size_t index)

706708{

707 return frameMetadataAtIndex<NativeImage~~Ptr~~>(index, (&ImageFrame::nativeImage));

709 return frameMetadataAtIndex<RefPtr<NativeImage>>(index, (&ImageFrame::nativeImage));

708710}

709711

710 NativeImage~~Ptr~~ ImageSource::frameImageAtIndexCacheIfNeeded(size_t index, SubsamplingLevel subsamplingLevel)

712RefPtr<NativeImage> ImageSource::frameImageAtIndexCacheIfNeeded(size_t index, SubsamplingLevel subsamplingLevel)

711713{

712 return frameMetadataAtIndexCacheIfNeeded<NativeImage~~Ptr~~>(index, (&ImageFrame::nativeImage), nullptr, ImageFrame::Caching::MetadataAndImage, subsamplingLevel);

714 return frameMetadataAtIndexCacheIfNeeded<RefPtr<NativeImage>>(index, (&ImageFrame::nativeImage), nullptr, ImageFrame::Caching::MetadataAndImage, subsamplingLevel);

}

void ImageSource::dump(TextStream& ts)

Source/WebCore/platform/graphics/ImageSource.h

@@public:

        return adoptRef(*new ImageSource(image, alphaOption, gammaAndColorProfileOption));

    }

55 static Ref<ImageSource> create(NativeImage~~Ptr~~&& nativeImage)

55 static Ref<ImageSource> create(RefPtr<NativeImage>&& nativeImage)

    {

        return adoptRef(*new ImageSource(WTFMove(nativeImage)));

    }

@@public:

#if USE(DIRECT2D)

    void setTargetContext(const GraphicsContext*);

#endif

    NativeImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default);

    NativeImagePtr frameImageAtIndex(size_t);

    NativeImagePtr frameImageAtIndexCacheIfNeeded(size_t, SubsamplingLevel = SubsamplingLevel::Default);

    RefPtr<NativeImage> createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default);

    RefPtr<NativeImage> frameImageAtIndex(size_t);

    RefPtr<NativeImage> frameImageAtIndexCacheIfNeeded(size_t, SubsamplingLevel = SubsamplingLevel::Default);

private:

    ImageSource(BitmapImage*, AlphaOption = AlphaOption::Premultiplied, GammaAndColorProfileOption = GammaAndColorProfileOption::Applied);

134 ImageSource(NativeImage~~Ptr~~&&);

134 ImageSource(RefPtr<NativeImage>&&);

    template<typename T, T (ImageDecoder::*functor)() const>

    T metadata(const T& defaultValue, Optional<T>* cachedValue = nullptr);

@@private:

    void decodedSizeReset(unsigned decodedSize);

    void encodedDataStatusChanged(EncodedDataStatus);

155 void setNativeImage(NativeImage~~Ptr~~&&);

155 void setNativeImage(RefPtr<NativeImage>&&);

156156 void cacheMetadataAtIndex(size_t, SubsamplingLevel, DecodingStatus = DecodingStatus::Invalid);

157 void cacheN~~ative~~ImageAtIndex(N~~ative~~ImagePtr&&, size_t, SubsamplingLevel, const DecodingOptions&, DecodingStatus = DecodingStatus::Invalid);

158 void cacheN~~ative~~ImageAtIndexAsync(N~~ative~~ImagePtr&&, size_t, SubsamplingLevel, const DecodingOptions&, DecodingStatus);

157 void cachePlatformImageAtIndex(PlatformImagePtr&&, size_t, SubsamplingLevel, const DecodingOptions&, DecodingStatus = DecodingStatus::Invalid);

158 void cachePlatformImageAtIndexAsync(PlatformImagePtr&&, size_t, SubsamplingLevel, const DecodingOptions&, DecodingStatus);

    struct ImageFrameRequest;

    static const int BufferSize = 8;

Source/WebCore/platform/graphics/MediaPlayer.cpp

@@bool MediaPlayer::copyVideoTextureToPlatformTexture(GraphicsContextGLOpenGL* con

    return m_private->copyVideoTextureToPlatformTexture(context, texture, target, level, internalFormat, format, type, premultiplyAlpha, flipY);

}

988 NativeImage~~Ptr~~ MediaPlayer::nativeImageForCurrentTime()

988RefPtr<NativeImage> MediaPlayer::nativeImageForCurrentTime()

{

    return m_private->nativeImageForCurrentTime();

}

Source/WebCore/platform/graphics/MediaPlayer.h

@@public:

    bool copyVideoTextureToPlatformTexture(GraphicsContextGLOpenGL*, PlatformGLObject texture, GCGLenum target, GCGLint level, GCGLenum internalFormat, GCGLenum format, GCGLenum type, bool premultiplyAlpha, bool flipY);

433 NativeImage~~Ptr~~ nativeImageForCurrentTime();

433 RefPtr<NativeImage> nativeImageForCurrentTime();

    using MediaPlayerEnums::NetworkState;

    NetworkState networkState();

Source/WebCore/platform/graphics/MediaPlayerPrivate.h

@@public:

    virtual void paintCurrentFrameInContext(GraphicsContext& c, const FloatRect& r) { paint(c, r); }

    virtual bool copyVideoTextureToPlatformTexture(GraphicsContextGLOpenGL*, PlatformGLObject, GCGLenum, GCGLint, GCGLenum, GCGLenum, GCGLenum, bool, bool) { return false; }

164 virtual NativeImage~~Ptr~~ nativeImageForCurrentTime() { return nullptr; }

164 virtual RefPtr<NativeImage> nativeImageForCurrentTime() { return nullptr; }

    virtual void setPreload(MediaPlayer::Preload) { }

Source/WebCore/platform/graphics/NativeImage.cpp

/*

 * Copyright (C) 2020 Apple Inc.  All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "config.h"

#include "NativeImage.h"

#include <wtf/NeverDestroyed.h>

namespace WebCore {

Ref<NativeImage> NativeImage::create(PlatformImagePtr& platformImage)

{

    return adoptRef(*new NativeImage(platformImage));

}

Ref<NativeImage> NativeImage::create(PlatformImagePtr&& platformImage)

{

    return adoptRef(*new NativeImage(WTFMove(platformImage)));

}

NativeImage::NativeImage(PlatformImagePtr& platformImage)

    : m_platformImage(platformImage)

{

}

NativeImage::NativeImage(PlatformImagePtr&& platformImage)

    : m_platformImage(WTFMove(platformImage))

{

}

NativeImage::~NativeImage()

{

    if (m_observer && m_platformImage)

        m_observer->nativeImageWillBeDeleted(m_renderingResourceIdentifier);

}

} // namespace WebCore

Source/WebCore/platform/graphics/NativeImage.h

#pragma once

30 #include "NativeImagePtr.h"

#include "IntSize.h"

#include "PlatformImagePtr.h"

#include "RenderingResourceIdentifier.h"    

#include <wtf/RefCounted.h>

namespace WebCore {

class Color;

35 class IntSize;

3638

WEBCORE_EXPORT IntSize nativeImageSize(const NativeImagePtr&);

bool nativeImageHasAlpha(const NativeImagePtr&);

Color nativeImageSinglePixelSolidColor(const NativeImagePtr&);

void clearNativeImageSubimages(const NativeImagePtr&);

class NativeImage : public RefCounted<NativeImage> {

public:

    class Observer {

    public:

        virtual ~Observer() = default;

        virtual void nativeImageWillBeDeleted(RenderingResourceIdentifier) = 0;

    protected:

        Observer() = default;

    };

4148

42 }

    static WEBCORE_EXPORT Ref<NativeImage> create(PlatformImagePtr&);

    static WEBCORE_EXPORT Ref<NativeImage> create(PlatformImagePtr&&);

    static WEBCORE_EXPORT IntSize size(const PlatformImagePtr&);

    WEBCORE_EXPORT ~NativeImage();

    RenderingResourceIdentifier renderingResourceIdentifier() const { return m_renderingResourceIdentifier; }

    bool isNull() const { return !m_platformImage; }

    PlatformImagePtr& platformImage() { return m_platformImage; }

    const PlatformImagePtr& platformImage() const { return m_platformImage; }

    IntSize size() const { return size(m_platformImage); }

    bool hasAlpha() const;

    Color singlePixelSolidColor() const;

    void setObserver(Observer* observer) { m_observer = observer; }

    void clearSubimages();

private:

    NativeImage(PlatformImagePtr&);

    NativeImage(PlatformImagePtr&&);

    PlatformImagePtr m_platformImage;

    Observer* m_observer { nullptr };

    RenderingResourceIdentifier m_renderingResourceIdentifier { RenderingResourceIdentifier::generate() };

};

} // namespace WebCore

Source/WebCore/platform/graphics/NativeImagePtr.h

/*

 * Copyright (C) 2020 Apple Inc.  All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#pragma once

#if USE(CG)

#include <wtf/RetainPtr.h>

typedef struct CGImage* CGImageRef;

#elif USE(CAIRO)

#include "RefPtrCairo.h"

#elif USE(WINGDI)

#include "SharedBitmap.h"

#endif

namespace WebCore {

#if USE(CG)

typedef RetainPtr<CGImageRef> NativeImagePtr;

#elif USE(DIRECT2D)

typedef COMPtr<ID2D1Bitmap> NativeImagePtr;

#elif USE(CAIRO)

typedef RefPtr<cairo_surface_t> NativeImagePtr;

#elif USE(WINGDI)

typedef RefPtr<SharedBitmap> NativeImagePtr;

#endif

}

Source/WebCore/platform/graphics/PlatformImagePtr.h

/*

 * Copyright (C) 2020 Apple Inc.  All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#pragma once

#if USE(CG)

#include <wtf/RetainPtr.h>

typedef struct CGImage* CGImageRef;

#elif USE(CAIRO)

#include "RefPtrCairo.h"

#elif USE(WINGDI)

#include "SharedBitmap.h"

#endif

namespace WebCore {

#if USE(CG)

using PlatformImagePtr = RetainPtr<CGImageRef>;

#elif USE(DIRECT2D)

using PlatformImagePtr = COMPtr<ID2D1Bitmap>;

#elif USE(CAIRO)

using PlatformImagePtr = RefPtr<cairo_surface_t>;

#elif USE(WINGDI)

using PlatformImagePtr = RefPtr<SharedBitmap>;

#endif

}

Source/WebCore/platform/graphics/VideoLayerManager.h

@@public:

#if ENABLE(VIDEO_PRESENTATION_MODE)

    virtual PlatformLayer* videoFullscreenLayer() const = 0;

47 virtual void setVideoFullscreenLayer(PlatformLayer*, WTF::Function<void()>&& completionHandler, N~~ative~~ImagePtr) = 0;

47 virtual void setVideoFullscreenLayer(PlatformLayer*, WTF::Function<void()>&& completionHandler, PlatformImagePtr) = 0;

4848 virtual FloatRect videoFullscreenFrame() const = 0;

4949 virtual void setVideoFullscreenFrame(FloatRect) = 0;

50 virtual void updateVideoFullscreenInlineImage(N~~ative~~ImagePtr) = 0;

50 virtual void updateVideoFullscreenInlineImage(PlatformImagePtr) = 0;

#endif

    virtual bool requiresTextTrackRepresentation() const = 0;

Source/WebCore/platform/graphics/avfoundation/objc/ImageDecoderAVFObjC.h

@@public:

    bool frameAllowSubsamplingAtIndex(size_t) const final;

    unsigned frameBytesAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default) const final;

85 N~~ative~~ImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, const DecodingOptions& = DecodingOptions(DecodingMode::Synchronous)) final;

85 PlatformImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, const DecodingOptions& = DecodingOptions(DecodingMode::Synchronous)) final;

    void setExpectedContentSize(long long) final;

    void setData(SharedBuffer&, bool allDataReceived) final;

Source/WebCore/platform/graphics/avfoundation/objc/ImageDecoderAVFObjC.mm

@@unsigned ImageDecoderAVFObjC::frameBytesAtIndex(size_t index, SubsamplingLevel s

    return (frameSize.area() * 4).unsafeGet();

}

570 N~~ative~~ImagePtr ImageDecoderAVFObjC::createFrameImageAtIndex(size_t index, SubsamplingLevel, const DecodingOptions&)

570PlatformImagePtr ImageDecoderAVFObjC::createFrameImageAtIndex(size_t index, SubsamplingLevel, const DecodingOptions&)

{

    LockHolder holder { m_sampleGeneratorLock };

Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.h

@@private:

    bool updateLastPixelBuffer();

    bool videoOutputHasAvailableFrame();

    void paintWithVideoOutput(GraphicsContext&, const FloatRect&);

255 NativeImage~~Ptr~~ nativeImageForCurrentTime() final;

255 RefPtr<NativeImage> nativeImageForCurrentTime() final;

    void waitForVideoOutputMediaDataWillChange();

    bool copyVideoTextureToPlatformTexture(GraphicsContextGLOpenGL*, PlatformGLObject, GCGLenum target, GCGLint level, GCGLenum internalFormat, GCGLenum format, GCGLenum type, bool premultiplyAlpha, bool flipY) final;

@@private:

    RetainPtr<AVPlayerItemVideoOutput> m_videoOutput;

    RetainPtr<WebCoreAVFPullDelegate> m_videoOutputDelegate;

    RetainPtr<CVPixelBufferRef> m_lastPixelBuffer;

346 Re~~tain~~Ptr<CGImage~~Ref~~> m_lastImage;

346 RefPtr<NativeImage> m_lastImage;

    std::unique_ptr<ImageRotationSessionVT> m_imageRotationSession;

    std::unique_ptr<VideoTextureCopierCV> m_videoTextureCopier;

    std::unique_ptr<PixelBufferConformerCV> m_pixelBufferConformer;

Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.mm

@@PlatformLayer* MediaPlayerPrivateAVFoundationObjC::platformLayer() const

void MediaPlayerPrivateAVFoundationObjC::updateVideoFullscreenInlineImage()

{

    updateLastImage(UpdateType::UpdateSynchronously);

1130 m_videoLayerManager->updateVideoFullscreenInlineImage(m_lastImage);

1130 m_videoLayerManager->updateVideoFullscreenInlineImage(m_lastImage ? m_lastImage->platformImage() : nullptr);

}

RetainPtr<PlatformLayer> MediaPlayerPrivateAVFoundationObjC::createVideoFullscreenLayer()

@@void MediaPlayerPrivateAVFoundationObjC::setVideoFullscreenLayer(PlatformLayer*

{

    if (videoFullscreenLayer)

        updateLastImage(UpdateType::UpdateSynchronously);

1142 m_videoLayerManager->setVideoFullscreenLayer(videoFullscreenLayer, WTFMove(completionHandler), m_lastImage);

1142 m_videoLayerManager->setVideoFullscreenLayer(videoFullscreenLayer, WTFMove(completionHandler), m_lastImage ? m_lastImage->platformImage() : nullptr);

    updateDisableExternalPlayback();

}

@@void MediaPlayerPrivateAVFoundationObjC::updateLastImage(UpdateType type)

    MonotonicTime start = MonotonicTime::now();

2296 m_lastImage = m_pixelBufferConformer->createImageFromPixelBuffer(m_lastPixelBuffer.get());

2296 m_lastImage = NativeImage::create(m_pixelBufferConformer->createImageFromPixelBuffer(m_lastPixelBuffer.get()));

    INFO_LOG(LOGIDENTIFIER, "creating buffer took ", (MonotonicTime::now() - start).seconds());

}

@@void MediaPlayerPrivateAVFoundationObjC::paintWithVideoOutput(GraphicsContext& c

    INFO_LOG(LOGIDENTIFIER);

2317 FloatRect imageRect(0, 0~~, CGImageGetWidth(~~m_lastImage.get())~~, CGImageGetHeight(m_lastImage.get()))~~;

2318 context.drawNativeImage(m_lastImage~~.get()~~, imageRect.size(), outputRect, imageRect);

2317 FloatRect imageRect({ 0, 0 }, m_lastImage->size());

2318 context.drawNativeImage(*m_lastImage, imageRect.size(), outputRect, imageRect);

    // If we have created an AVAssetImageGenerator in the past due to m_videoOutput not having an available

    // video frame, destroy it now that it is no longer needed.

@@bool MediaPlayerPrivateAVFoundationObjC::copyVideoTextureToPlatformTexture(Graph

    return m_videoTextureCopier->copyImageToPlatformTexture(m_lastPixelBuffer.get(), width, height, outputTexture, outputTarget, level, internalFormat, format, type, premultiplyAlpha, flipY);

}

2344 NativeImage~~Ptr~~ MediaPlayerPrivateAVFoundationObjC::nativeImageForCurrentTime()

2344RefPtr<NativeImage> MediaPlayerPrivateAVFoundationObjC::nativeImageForCurrentTime()

{

    updateLastImage();

    return m_lastImage;

Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h

@@private:

    bool didLoadingProgress() const override;

218 NativeImage~~Ptr~~ nativeImageForCurrentTime() override;

218 RefPtr<NativeImage> nativeImageForCurrentTime() override;

    bool updateLastPixelBuffer();

    bool updateLastImage();

    void paint(GraphicsContext&, const FloatRect&) override;

@@private:

    RetainPtr<id> m_performTaskObserver;

    RetainPtr<AVStreamSession> m_streamSession;

    RetainPtr<CVPixelBufferRef> m_lastPixelBuffer;

304 Re~~tain~~Ptr<CGImage~~Ref~~> m_lastImage;

304 RefPtr<NativeImage> m_lastImage;

    std::unique_ptr<PixelBufferConformerCV> m_rgbConformer;

    RefPtr<WebCoreDecompressionSession> m_decompressionSession;

    Deque<RetainPtr<id>> m_sizeChangeObservers;

Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm

@@bool MediaPlayerPrivateMediaSourceAVFObjC::didLoadingProgress() const

    return loadingProgressed;

}

567 NativeImage~~Ptr~~ MediaPlayerPrivateMediaSourceAVFObjC::nativeImageForCurrentTime()

567RefPtr<NativeImage> MediaPlayerPrivateMediaSourceAVFObjC::nativeImageForCurrentTime()

568568{

569569 updateLastImage();

570 return m_lastImage~~.get()~~;

570 return m_lastImage;

}

bool MediaPlayerPrivateMediaSourceAVFObjC::updateLastPixelBuffer()

@@bool MediaPlayerPrivateMediaSourceAVFObjC::updateLastImage()

        m_rgbConformer = makeUnique<PixelBufferConformerCV>((__bridge CFDictionaryRef)attributes);

    }

610 m_lastImage = m_rgbConformer->createImageFromPixelBuffer(m_lastPixelBuffer.get());

610 m_lastImage = NativeImage::create(m_rgbConformer->createImageFromPixelBuffer(m_lastPixelBuffer.get()));

    return true;

}

@@void MediaPlayerPrivateMediaSourceAVFObjC::paintCurrentFrameInContext(GraphicsCo

        return;

    GraphicsContextStateSaver stateSaver(context);

629 FloatRect imageRect(0, 0~~, CGImageGetWidth(~~image.get())~~, CGImageGetHeight(image.get()))~~;

630 context.drawNativeImage(image, imageRect.size(), outputRect, imageRect);

629 FloatRect imageRect({ 0, 0 }, image->size());

630 context.drawNativeImage(*image, imageRect.size(), outputRect, imageRect);

}

bool MediaPlayerPrivateMediaSourceAVFObjC::copyVideoTextureToPlatformTexture(GraphicsContextGLOpenGL* context, PlatformGLObject outputTexture, GCGLenum outputTarget, GCGLint level, GCGLenum internalFormat, GCGLenum format, GCGLenum type, bool premultiplyAlpha, bool flipY)

@@RetainPtr<PlatformLayer> MediaPlayerPrivateMediaSourceAVFObjC::createVideoFullsc

void MediaPlayerPrivateMediaSourceAVFObjC::setVideoFullscreenLayer(PlatformLayer *videoFullscreenLayer, WTF::Function<void()>&& completionHandler)

{

    updateLastImage();

1222 m_videoLayerManager->setVideoFullscreenLayer(videoFullscreenLayer, WTFMove(completionHandler), m_lastImage);

1222 m_videoLayerManager->setVideoFullscreenLayer(videoFullscreenLayer, WTFMove(completionHandler), m_lastImage ? m_lastImage->platformImage() : nullptr);

}

void MediaPlayerPrivateMediaSourceAVFObjC::setVideoFullscreenFrame(FloatRect frame)

Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.h

@@private:

        CurrentFramePainter() = default;

        void reset();

235 Re~~tain~~Ptr<CGImage~~Ref~~> cgImage;

235 RefPtr<NativeImage> cgImage;

        RefPtr<MediaSample> mediaSample;

        std::unique_ptr<PixelBufferConformerCV> pixelBufferConformer;

    };

Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.mm

@@RetainPtr<PlatformLayer> MediaPlayerPrivateMediaStreamAVFObjC::createVideoFullsc

void MediaPlayerPrivateMediaStreamAVFObjC::setVideoFullscreenLayer(PlatformLayer* videoFullscreenLayer, WTF::Function<void()>&& completionHandler)

{

    updateCurrentFrameImage();

765 m_videoLayerManager->setVideoFullscreenLayer(videoFullscreenLayer, WTFMove(completionHandler), m_imagePainter.cgImage);

765 m_videoLayerManager->setVideoFullscreenLayer(videoFullscreenLayer, WTFMove(completionHandler), m_imagePainter.cgImage ? m_imagePainter.cgImage->platformImage() : nullptr);

}

void MediaPlayerPrivateMediaStreamAVFObjC::setVideoFullscreenFrame(FloatRect frame)

@@void MediaPlayerPrivateMediaStreamAVFObjC::updateCurrentFrameImage()

        return;

    auto pixelBuffer = static_cast<CVPixelBufferRef>(CMSampleBufferGetImageBuffer(m_imagePainter.mediaSample->platformSample().sample.cmSampleBuffer));

958 m_imagePainter.cgImage = m_imagePainter.pixelBufferConformer->createImageFromPixelBuffer(pixelBuffer);

958 m_imagePainter.cgImage = NativeImage::create(m_imagePainter.pixelBufferConformer->createImageFromPixelBuffer(pixelBuffer));

}

void MediaPlayerPrivateMediaStreamAVFObjC::paintCurrentFrameInContext(GraphicsContext& context, const FloatRect& destRect)

@@void MediaPlayerPrivateMediaStreamAVFObjC::paintCurrentFrameInContext(GraphicsCo

    if (!m_imagePainter.cgImage || !m_imagePainter.mediaSample)

        return;

978 auto image = m_imagePainter.cgImage~~.get()~~;

979 FloatRect imageRect(0, 0~~, CGImageGetWidth(~~image~~), CGImageGetHeight(image~~));

978 auto& image = m_imagePainter.cgImage;

979 FloatRect imageRect({ 0, 0 }, image->size());

    if (!m_videoTransform)

        m_videoTransform = videoTransformationMatrix(*m_imagePainter.mediaSample);

    AffineTransform videoTransform = *m_videoTransform;

    FloatRect transformedDestRect = videoTransform.inverse().valueOr(AffineTransform()).mapRect(destRect);

    context.concatCTM(videoTransform);

985 context.drawNativeImage(image, imageRect.size(), transformedDestRect, imageRect);

985 context.drawNativeImage(*image, imageRect.size(), transformedDestRect, imageRect);

}

void MediaPlayerPrivateMediaStreamAVFObjC::acceleratedRenderingStateChanged()

Source/WebCore/platform/graphics/avfoundation/objc/VideoLayerManagerObjC.h

@@public:

#if ENABLE(VIDEO_PRESENTATION_MODE)

    WEBCORE_EXPORT PlatformLayer* videoFullscreenLayer() const final;

66 WEBCORE_EXPORT void setVideoFullscreenLayer(PlatformLayer*, WTF::Function<void()>&& completionHandler, N~~ative~~ImagePtr) final;

66 WEBCORE_EXPORT void setVideoFullscreenLayer(PlatformLayer*, WTF::Function<void()>&& completionHandler, PlatformImagePtr) final;

6767 WEBCORE_EXPORT FloatRect videoFullscreenFrame() const final;

6868 WEBCORE_EXPORT void setVideoFullscreenFrame(FloatRect) final;

69 WEBCORE_EXPORT void updateVideoFullscreenInlineImage(N~~ative~~ImagePtr) final;

69 WEBCORE_EXPORT void updateVideoFullscreenInlineImage(PlatformImagePtr) final;

#endif

    WEBCORE_EXPORT bool requiresTextTrackRepresentation() const final;

Source/WebCore/platform/graphics/avfoundation/objc/VideoLayerManagerObjC.mm

@@PlatformLayer* VideoLayerManagerObjC::videoFullscreenLayer() const

    return m_videoFullscreenLayer.get();

}

106 void VideoLayerManagerObjC::setVideoFullscreenLayer(PlatformLayer *videoFullscreenLayer, WTF::Function<void()>&& completionHandler, N~~ative~~ImagePtr currentImage)

106void VideoLayerManagerObjC::setVideoFullscreenLayer(PlatformLayer *videoFullscreenLayer, WTF::Function<void()>&& completionHandler, PlatformImagePtr currentImage)

{

    if (m_videoFullscreenLayer == videoFullscreenLayer) {

        completionHandler();

@@void VideoLayerManagerObjC::setVideoFullscreenFrame(FloatRect videoFullscreenFra

    syncTextTrackBounds();

}

170 void VideoLayerManagerObjC::updateVideoFullscreenInlineImage(N~~ative~~ImagePtr image)

170void VideoLayerManagerObjC::updateVideoFullscreenInlineImage(PlatformImagePtr image)

{

    if (m_videoInlineLayer)

        [m_videoInlineLayer setContents:(__bridge id)image.get()];

Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp

@@void GraphicsLayerCA::updateContentsImage()

        // FIXME: maybe only do trilinear if the image is being scaled down,

        // but then what if the layer size changes?

        m_contentsLayer->setMinificationFilter(PlatformCALayer::Trilinear);

2596 m_contentsLayer->setContents(m_pendingContentsImage.get());

2596 m_contentsLayer->setContents(m_pendingContentsImage->platformImage().get());

        m_pendingContentsImage = nullptr;

        if (m_layerClones) {

Source/WebCore/platform/graphics/ca/GraphicsLayerCA.h

@@class DisplayList;

class FloatRoundedRect;

class Image;

49class NativeImage;

class TransformState;

class GraphicsLayerCA : public GraphicsLayer, public PlatformCALayerClient {

@@private:

    Color m_contentsSolidColor;

603 Re~~tain~~Ptr<CGImage~~Ref~~> m_uncorrectedContentsImage;

604 Re~~tain~~Ptr<CGImage~~Ref~~> m_pendingContentsImage;

604 RefPtr<NativeImage> m_uncorrectedContentsImage;

605 RefPtr<NativeImage> m_pendingContentsImage;

    
    Vector<LayerPropertyAnimation> m_animations;

    Vector<LayerPropertyAnimation> m_baseValueTransformAnimations;

Source/WebCore/platform/graphics/cairo/CairoOperations.cpp

#include "GraphicsContextPlatformPrivateCairo.h"

#include "Image.h"

#include "ImageBuffer.h"

48#include "NativeImage.h"

#include "Path.h"

#include "PlatformContextCairo.h"

#include "ShadowBlur.h"

@@enum PathDrawingStyle {

static void drawShadowLayerBuffer(PlatformContextCairo& platformContext, ImageBuffer& layerImage, const FloatPoint& layerOrigin, const FloatSize& layerSize, const ShadowState& shadowState)

{

177 if (auto ~~surf~~ace = layerImage.copyNativeImage(DontCopyBackingStore)) {

178 drawNativeImage(platformContext, ~~surf~~ace.~~get()~~, FloatRect(roundedIntPoint(layerOrigin), layerSize), FloatRect(FloatPoint(), layerSize), { shadowState.globalCompositeOperator }, shadowState.globalAlpha, ShadowState());

178 if (auto nativeImage = layerImage.copyNativeImage(DontCopyBackingStore)) {

179 drawNativeImage(platformContext, *nativeImage, FloatRect(roundedIntPoint(layerOrigin), layerSize), FloatRect(FloatPoint(), layerSize), { shadowState.globalCompositeOperator }, shadowState.globalAlpha, ShadowState());

    }

}

// FIXME: This is mostly same as drawShadowLayerBuffer, so we should merge two.

static void drawShadowImage(PlatformContextCairo& platformContext, ImageBuffer& layerImage, const FloatRect& destRect, const FloatRect& srcRect, const ShadowState& shadowState)

{

185 if (auto ~~surf~~ace = layerImage.copyNativeImage(DontCopyBackingStore)) {

186 drawNativeImage(platformContext, ~~surf~~ace.~~get()~~, destRect, srcRect, { shadowState.globalCompositeOperator }, shadowState.globalAlpha, ShadowState());

186 if (auto nativeImage = layerImage.copyNativeImage(DontCopyBackingStore)) {

187 drawNativeImage(platformContext, *nativeImage, destRect, srcRect, { shadowState.globalCompositeOperator }, shadowState.globalAlpha, ShadowState());

    }

}

@@static void fillShadowBuffer(PlatformContextCairo& platformContext, ImageBuffer&

{

    save(platformContext);

194 if (auto ~~surf~~ace = layerImage.copyNativeImage(DontCopyBackingStore))

195 clipToImageBuffer(platformContext, surface.get(), FloatRect(layerOrigin, expandedIntSize(layerSize)));

195 if (auto nativeImage = layerImage.copyNativeImage(DontCopyBackingStore))

196 clipToImageBuffer(platformContext, nativeImage->platformImage().get(), FloatRect(layerOrigin, expandedIntSize(layerSize)));

    FillSource fillSource;

    fillSource.globalAlpha = shadowState.globalAlpha;

@@void drawGlyphs(PlatformContextCairo& platformContext, const FillSource& fillSou

    cairo_restore(cr);

}

863 void drawNativeImage(PlatformContextCairo& platformContext, cairo_surface_t* surface, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options, float globalAlpha, const ShadowState& shadowState)

void drawNativeImage(PlatformContextCairo& platformContext, NativeImage& nativeImage, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options, float globalAlpha, const ShadowState& shadowState)

{

    if (auto surface = nativeImage.platformImage())

        drawPlatformImage(platformContext, surface.get(), destRect, srcRect, options, globalAlpha, shadowState);

}

void drawPlatformImage(PlatformContextCairo& platformContext, cairo_surface_t* surface, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options, float globalAlpha, const ShadowState& shadowState)

{

    platformContext.save();

Source/WebCore/platform/graphics/cairo/CairoOperations.h

@@void clearRect(PlatformContextCairo&, const FloatRect&);

void drawGlyphs(PlatformContextCairo&, const FillSource&, const StrokeSource&, const ShadowState&, const FloatPoint&, cairo_scaled_font_t*, double, const Vector<cairo_glyph_t>&, float, TextDrawingModeFlags, float, const FloatSize&, const Color&, FontSmoothingMode);

146 void drawNativeImage(PlatformContextCairo&, cairo_surface_t*, const FloatRect&, const FloatRect&, const ImagePaintingOptions&, float, const ShadowState&);

146void drawNativeImage(PlatformContextCairo&, NativeImage&, const FloatRect&, const FloatRect&, const ImagePaintingOptions&, float, const ShadowState&);

147void drawPlatformImage(PlatformContextCairo&, cairo_surface_t*, const FloatRect&, const FloatRect&, const ImagePaintingOptions&, float, const ShadowState&);

void drawPattern(PlatformContextCairo&, cairo_surface_t*, const IntSize&, const FloatRect&, const FloatRect&, const AffineTransform&, const FloatPoint&, const ImagePaintingOptions&);

WEBCORE_EXPORT void drawSurface(PlatformContextCairo&, cairo_surface_t*, const FloatRect&, const FloatRect&, InterpolationQuality, float, const ShadowState&, OrientationSizing operationSizing = OrientationSizing::Normal);

Source/WebCore/platform/graphics/cairo/GraphicsContextCairo.cpp

@@void GraphicsContext::drawRect(const FloatRect& rect, float borderThickness)

    Cairo::drawRect(*platformContext(), rect, borderThickness, state.fillColor, state.strokeStyle, state.strokeColor);

}

126 void GraphicsContext::platform~~DrawNative~~Image(const N~~ative~~ImagePtr& image, const FloatSize&, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

126void GraphicsContext::drawPlatformImage(const PlatformImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

{

    if (paintingDisabled())

        return;

    if (m_impl) {

        m_impl->drawPlatformImage(image, imageSize, destRect, srcRect, options);

        return;

    }

131136 ASSERT(hasPlatformContext());

132137 auto& state = this->state();

133 Cairo::drawN~~ative~~Image(*platformContext(), image.get(), destRect, srcRect, { options, state.imageInterpolationQuality }, state.alpha, Cairo::ShadowState(state));

138 Cairo::drawPlatformImage(*platformContext(), image.get(), destRect, srcRect, { options, state.imageInterpolationQuality }, state.alpha, Cairo::ShadowState(state));

}

// This is only used to draw borders, so we should not draw shadows.

@@void GraphicsContext::clipToImageBuffer(ImageBuffer& buffer, const FloatRect& de

    }

    ASSERT(hasPlatformContext());

269 if (auto ~~surf~~ace = buffer.copyNativeImage(DontCopyBackingStore))

270 Cairo::clipToImageBuffer(*platformContext(), surface.get(), destRect);

274 if (auto nativeImage = buffer.copyNativeImage(DontCopyBackingStore))

275 Cairo::clipToImageBuffer(*platformContext(), nativeImage->platformImage().get(), destRect);

}

IntRect GraphicsContext::clipBounds() const

@@void GraphicsContext::drawPattern(Image& image, const FloatRect& destRect, const

    }

    ASSERT(hasPlatformContext());

684 if (auto ~~surf~~ace = image.nativeImageForCurrentFrame())

685 Cairo::drawPattern(*platformContext(), surface.get(), IntSize(image.size()), destRect, tileRect, patternTransform, phase, options);

689 if (auto nativeImage = image.nativeImageForCurrentFrame())

690 Cairo::drawPattern(*platformContext(), nativeImage->platformImage().get(), IntSize(image.size()), destRect, tileRect, patternTransform, phase, options);

}

void GraphicsContext::setPlatformShouldAntialias(bool enable)

Source/WebCore/platform/graphics/cairo/GraphicsContextGLCairo.cpp

@@bool GraphicsContextGLImageExtractor::extractImage(bool premultiplyAlpha, bool i

        source->setData(m_image->data(), true);

        if (!source->frameCount())

            return false;

59 m_imageSurface = source->createFrameImageAtIndex(0);

59 m_imageSurface = source->createFrameImageAtIndex(0)->platformImage();

6060 } else {

61 m_imageSurface = m_image->nativeImageForCurrentFrame();

61 m_imageSurface = m_image->nativeImageForCurrentFrame()->platformImage();

        // 1. For texImage2D with HTMLVideoElment input, assume no PremultiplyAlpha had been applied and the alpha value is 0xFF for each pixel,

        // which is true at present and may be changed in the future and needs adjustment accordingly.

        // 2. For texImage2D with HTMLCanvasElement input in which Alpha is already Premultiplied in this port, 

Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.cpp

@@bool GraphicsContextImplCairo::drawImageBuffer(ImageBuffer&, const FloatRect&, c

    return false;

}

288 void GraphicsContextImplCairo::drawNativeImage(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

bool GraphicsContextImplCairo::drawNativeImage(NativeImage&, const FloatSize&, const FloatRect&, const FloatRect&, const ImagePaintingOptions&)

{

    // FIXME: Not implemented.

    return false;

}

void GraphicsContextImplCairo::drawPlatformImage(const PlatformImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

{

    UNUSED_PARAM(imageSize);

    auto& state = graphicsContext().state();

292 Cairo::drawN~~ative~~Image(m_platformContext, image.get(), destRect, srcRect, { options, state.imageInterpolationQuality }, state.alpha, Cairo::ShadowState(state));

298 Cairo::drawPlatformImage(m_platformContext, image.get(), destRect, srcRect, { options, state.imageInterpolationQuality }, state.alpha, Cairo::ShadowState(state));

}

void GraphicsContextImplCairo::drawPattern(Image& image, const FloatRect& destRect, const FloatRect& tileRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize&, const ImagePaintingOptions& options)

{

    if (auto surface = image.nativeImageForCurrentFrame())

298 Cairo::drawPattern(m_platformContext, surface.get(), IntSize(image.size()), destRect, tileRect, patternTransform, phase, options);

304 Cairo::drawPattern(m_platformContext, surface->platformImage().get(), IntSize(image.size()), destRect, tileRect, patternTransform, phase, options);

}

void GraphicsContextImplCairo::drawRect(const FloatRect& rect, float borderThickness)

@@IntRect GraphicsContextImplCairo::clipBounds()

void GraphicsContextImplCairo::clipToImageBuffer(ImageBuffer& buffer, const FloatRect& destRect)

{

    if (auto surface = buffer.copyNativeImage(DontCopyBackingStore))

424 Cairo::clipToImageBuffer(m_platformContext, surface.get(), destRect);

430 Cairo::clipToImageBuffer(m_platformContext, surface->platformImage().get(), destRect);

}

void GraphicsContextImplCairo::applyDeviceScaleFactor(float)

Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.h

@@public:

    ImageDrawResult drawTiledImage(Image&, const FloatRect&, const FloatRect&, const FloatSize&, Image::TileRule, Image::TileRule, const ImagePaintingOptions&) override;

    bool drawImageBuffer(ImageBuffer&, const FloatRect&, const FloatRect&, const ImagePaintingOptions&) override;

79 void drawNativeImage(const NativeImagePtr&, const FloatSize&, const FloatRect&, const FloatRect&, const ImagePaintingOptions&) override;

79 bool drawNativeImage(NativeImage&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&) override;

80 void drawPlatformImage(const PlatformImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&) override;

    void drawPattern(Image&, const FloatRect&, const FloatRect&, const AffineTransform&, const FloatPoint&, const FloatSize&, const ImagePaintingOptions&) override;

    void drawRect(const FloatRect&, float) override;

Source/WebCore/platform/graphics/cairo/ImageBufferCairoBackend.cpp

@@void ImageBufferCairoBackend::draw(GraphicsContext& destContext, const FloatRect

    const auto& destinationContextState = destContext.state();

    if (auto image = copyNativeImage(&destContext == &context() ? CopyBackingStore : DontCopyBackingStore))

69 drawNativeImage(*destContext.platformContext(), image~~.get()~~, destRect, srcRect, { options, destinationContextState.imageInterpolationQuality }, destinationContextState.alpha, WebCore::Cairo::ShadowState(destinationContextState));

69 drawNativeImage(*destContext.platformContext(), *image, destRect, srcRect, { options, destinationContextState.imageInterpolationQuality }, destinationContextState.alpha, WebCore::Cairo::ShadowState(destinationContextState));

}

void ImageBufferCairoBackend::drawPattern(GraphicsContext& destContext, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize& spacing, const ImagePaintingOptions& options)

@@void ImageBufferCairoBackend::drawPattern(GraphicsContext& destContext, const Fl

    }

    if (auto image = copyNativeImage(&destContext == &context() ? CopyBackingStore : DontCopyBackingStore))

83 Cairo::drawPattern(*destContext.platformContext(), image.get(), m_logicalSize, destRect, srcRect, patternTransform, phase, options);

83 Cairo::drawPattern(*destContext.platformContext(), image->platformImage().get(), m_logicalSize, destRect, srcRect, patternTransform, phase, options);

}

void ImageBufferCairoBackend::transformColorSpace(ColorSpace srcColorSpace, ColorSpace destColorSpace)

Source/WebCore/platform/graphics/cairo/ImageBufferCairoSurfaceBackend.cpp

@@unsigned ImageBufferCairoSurfaceBackend::bytesPerRow() const

    return cairo_image_surface_get_stride(m_surface.get());

}

67 NativeImage~~Ptr~~ ImageBufferCairoSurfaceBackend::copyNativeImage(BackingStoreCopy copyBehavior) const

67RefPtr<NativeImage> ImageBufferCairoSurfaceBackend::copyNativeImage(BackingStoreCopy copyBehavior) const

{

    switch (copyBehavior) {

    case CopyBackingStore: {

@@NativeImagePtr ImageBufferCairoSurfaceBackend::copyNativeImage(BackingStoreCopy

        cairo_set_source_surface(cr.get(), m_surface.get(), 0, 0);

        cairo_paint(cr.get());

80 return copy;

80 return NativeImage::create(WTFMove(copy));

    }

    case DontCopyBackingStore:

84 return m_surface;

84 return NativeImage::create(m_surface);

    }

    ASSERT_NOT_REACHED();

    return nullptr;

}

91 NativeImage~~Ptr~~ ImageBufferCairoSurfaceBackend::cairoSurfaceCoerceToImage() const

91RefPtr<NativeImage> ImageBufferCairoSurfaceBackend::cairoSurfaceCoerceToImage() const

{

    BackingStoreCopy copyBehavior;

    if (cairo_surface_get_type(m_surface.get()) == CAIRO_SURFACE_TYPE_IMAGE && cairo_surface_get_content(m_surface.get()) == CAIRO_CONTENT_COLOR_ALPHA)

@@NativeImagePtr ImageBufferCairoSurfaceBackend::cairoSurfaceCoerceToImage() const

Vector<uint8_t> ImageBufferCairoSurfaceBackend::toBGRAData() const

{

103 auto surface = cairoSurfaceCoerceToImage();

103 auto nativeImage = cairoSurfaceCoerceToImage();

104 auto surface = nativeImage ? nativeImage->platformImage() : nullptr;

    cairo_surface_flush(surface.get());

    Vector<uint8_t> imageData;

Source/WebCore/platform/graphics/cairo/ImageBufferCairoSurfaceBackend.h

@@class ImageBufferCairoSurfaceBackend : public ImageBufferCairoBackend {

public:

    GraphicsContext& context() const override;

43 NativeImage~~Ptr~~ copyNativeImage(BackingStoreCopy) const override;

43 RefPtr<NativeImage> copyNativeImage(BackingStoreCopy) const override;

    Vector<uint8_t> toBGRAData() const override;

    RefPtr<ImageData> getImageData(AlphaPremultiplication outputFormat, const IntRect&) const override;

@@public:

protected:

    ImageBufferCairoSurfaceBackend(const FloatSize& logicalSize, const IntSize& backendSize, float resolutionScale, ColorSpace, RefPtr<cairo_surface_t>&&);

52 NativeImage~~Ptr~~ cairoSurfaceCoerceToImage() const;

52 RefPtr<NativeImage> cairoSurfaceCoerceToImage() const;

    unsigned bytesPerRow() const override;

    mutable RefPtr<cairo_surface_t> m_surface;

Source/WebCore/platform/graphics/cairo/NativeImageCairo.cpp

namespace WebCore {

38 IntSize ~~nativeImageSize(const~~ NativeImagePtr& image)

38IntSize NativeImage::size(const PlatformImagePtr& platformImage)

3939{

40 return image ? cairoSurfaceSize(image.get()) : IntSize();

40 return platformImage ? cairoSurfaceSize(platformImage.get()) : IntSize();

4141}

4242

43 bool ~~nativeImageHasAlpha(const~~ NativeImageP~~tr& image)~~

43bool NativeImage::hasAlpha() const

4444{

45 return !image || cairo_surface_get_content(image.get()) != CAIRO_CONTENT_COLOR;

45 return !m_platformImage || cairo_surface_get_content(m_platformImage.get()) != CAIRO_CONTENT_COLOR;

4646}

4747

48 Color nativeImageSinglePixelSolidColor(const ~~NativeImagePtr& image)~~

48Color NativeImage::singlePixelSolidColor() const

4949{

50 if (!image || ~~nativeImageS~~ize(~~image~~) != IntSize(1, 1))

50 if (!m_platformImage || size() != IntSize(1, 1))

5151 return Color();

5252

53 if (cairo_surface_get_type(image.get()) != CAIRO_SURFACE_TYPE_IMAGE)

53 if (cairo_surface_get_type(m_platformImage.get()) != CAIRO_SURFACE_TYPE_IMAGE)

5454 return Color();

5555

56 unsigned* pixel = reinterpret_cast_ptr<unsigned*>(cairo_image_surface_get_data(image.get()));

56 unsigned* pixel = reinterpret_cast_ptr<unsigned*>(cairo_image_surface_get_data(m_platformImage.get()));

    return unpremultiplied(asSRGBA(PackedColor::ARGB { *pixel }));

}

void drawNativeImage(const NativeImagePtr& image, GraphicsContext& context, const FloatRect& destRect, const FloatRect& srcRect, const IntSize& imageSize, const ImagePaintingOptions& options)

{

    context.drawNativeImage(image, imageSize, destRect, srcRect, options);

}

void clearNativeImageSubimages(const NativeImagePtr&)

60void NativeImage::clearSubimages()

{

}

Source/WebCore/platform/graphics/cairo/PatternCairo.cpp

@@namespace WebCore {

cairo_pattern_t* Pattern::createPlatformPattern(const AffineTransform&) const

{

38 R~~efPtr<cairo_surface_t> surfac~~e = tileImage().nativeImageForCurrentFrame();

39 if (!s~~urface~~)

38 auto nativeImage = tileImage().nativeImageForCurrentFrame();

39 if (!nativeImage || nativeImage->isNull())

4040 return nullptr;

4141

42 auto& surface = nativeImage->platformImage();

43

    cairo_pattern_t* pattern = cairo_pattern_create_for_surface(surface.get());

    // cairo merges patter space and user space itself

Source/WebCore/platform/graphics/cg/GraphicsContextCG.cpp

@@void GraphicsContext::restorePlatformState()

    m_data->m_userToDeviceTransformKnownToBeIdentity = false;

}

283 void GraphicsContext::platform~~DrawNative~~Image(const Re~~tainPtr<CG~~Image~~Ref>~~& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

283void GraphicsContext::drawPlatformImage(const PlatformImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

{

    if (paintingDisabled())

        return;

    if (m_impl) {

        m_impl->drawPlatformImage(image, imageSize, destRect, srcRect, options);

        return;

    }

#if !LOG_DISABLED

    MonotonicTime startTime = MonotonicTime::now();

#endif

@@void GraphicsContext::drawPattern(Image& image, const FloatRect& destRect, const

    auto tileImage = image.preTransformedNativeImageForCurrentFrame(options.orientation() == ImageOrientation::FromImage);

450 float h = CGImageGetHeight(tileImage.get());

455 float h = CGImageGetHeight(tileImage->platformImage().get());

    RetainPtr<CGImageRef> subImage;

    FloatSize imageSize = image.size();

    if (tileRect.size() == imageSize)

455 subImage = tileImage;

460 subImage = tileImage->platformImage();

    else {

        // Copying a sub-image out of a partially-decoded image stops the decoding of the original image. It should never happen

        // because sub-images are only used for border-image, which only renders when the image is fully decoded.

        ASSERT(h == image.height());

460 subImage = adoptCF(CGImageCreateWithImageInRect(tileImage.get(), tileRect));

465 subImage = adoptCF(CGImageCreateWithImageInRect(tileImage->platformImage().get(), tileRect));

    }

    // If we need to paint gaps between tiles because we have a partially loaded image or non-zero spacing,

    // fall back to the less efficient CGPattern-based mechanism.

    float scaledTileWidth = tileRect.width() * narrowPrecisionToFloat(patternTransform.a());

466 float w = CGImageGetWidth(tileImage.get());

471 float w = CGImageGetWidth(tileImage->platformImage().get());

    if (w == image.size().width() && h == image.size().height() && !spacing.width() && !spacing.height()) {

        // FIXME: CG seems to snap the images to integral sizes. When we care (e.g. with border-image-repeat: round),

        // we should tile all but the last, and stetch the last image to fit.

@@void GraphicsContext::clipToImageBuffer(ImageBuffer& buffer, const FloatRect& de

    }

    FloatSize bufferDestinationSize = destinationRect.size();

515 RetainPtr<CGImageRef> image = buffer.copyNativeImage(DontCopyBackingStore);

520 auto nativeImage = buffer.copyNativeImage(DontCopyBackingStore);

521 RetainPtr<CGImageRef> image = nativeImage ? nativeImage->platformImage() : nullptr;

    CGContextRef context = platformContext();

    // FIXME: This image needs to be grayscale to be used as an alpha mask here.

Source/WebCore/platform/graphics/cg/GraphicsContextGLCG.cpp

@@bool GraphicsContextGLImageExtractor::extractImage(bool premultiplyAlpha, bool i

    if (!m_cgImage)

        return false;

341 m_imageWidth = CGImageGetWidth(m_cgImage.get());

342 m_imageHeight = CGImageGetHeight(m_cgImage.get());

    RetainPtr<CGImageRef> image = m_cgImage->platformImage();

    m_imageWidth = CGImageGetWidth(image.get());

    m_imageHeight = CGImageGetHeight(image.get());

    if (!m_imageWidth || !m_imageHeight)

        return false;

@@bool GraphicsContextGLImageExtractor::extractImage(bool premultiplyAlpha, bool i

    // so, re-render it into an RGB color space. The image re-packing

    // code requires color data, not color table indices, for the

    // image data.

350 CGColorSpaceRef colorSpace = CGImageGetColorSpace(~~m_cgI~~mage.get());

351 CGColorSpaceRef colorSpace = CGImageGetColorSpace(image.get());

    CGColorSpaceModel model = CGColorSpaceGetModel(colorSpace);

    if (model == kCGColorSpaceModelIndexed) {

        RetainPtr<CGContextRef> bitmapContext;

@@bool GraphicsContextGLImageExtractor::extractImage(bool premultiplyAlpha, bool i

        CGContextSetBlendMode(bitmapContext.get(), kCGBlendModeCopy);

        CGContextSetInterpolationQuality(bitmapContext.get(), kCGInterpolationNone);

365 CGContextDrawImage(bitmapContext.get(), CGRectMake(0, 0, m_imageWidth, m_imageHeight), ~~m_cgI~~mage.get());

366 CGContextDrawImage(bitmapContext.get(), CGRectMake(0, 0, m_imageWidth, m_imageHeight), image.get());

366367

367368 // Now discard the original CG image and replace it with a copy from the bitmap context.

368 m_decodedImage = ~~adoptCF~~(CGBitmapContextCreateImage(bitmapContext.get()));

369 m_cgImage = m_decodedImage~~.get()~~;

369 m_decodedImage = NativeImage::create(CGBitmapContextCreateImage(bitmapContext.get()));

370 m_cgImage = m_decodedImage;

370371 }

371372

372 size_t bitsPerComponent = CGImageGetBitsPerComponent(m_cgImage.get());

373 size_t bitsPerPixel = CGImageGetBitsPerPixel(m_cgImage.get());

    if (!m_cgImage)

        return false;

    image = m_cgImage->platformImage();

    size_t bitsPerComponent = CGImageGetBitsPerComponent(image.get());

    size_t bitsPerPixel = CGImageGetBitsPerPixel(image.get());

    if (bitsPerComponent != 8 && bitsPerComponent != 16)

        return false;

    if (bitsPerPixel % bitsPerComponent)

        return false;

    size_t componentsPerPixel = bitsPerPixel / bitsPerComponent;

380 CGBitmapInfo bitInfo = CGImageGetBitmapInfo(~~m_cgI~~mage.get());

385 CGBitmapInfo bitInfo = CGImageGetBitmapInfo(image.get());

    bool bigEndianSource = false;

    // These could technically be combined into one large switch

    // statement, but we prefer not to so that we fail fast if we

@@bool GraphicsContextGLImageExtractor::extractImage(bool premultiplyAlpha, bool i

    m_alphaOp = AlphaOp::DoNothing;

    AlphaFormat alphaFormat = AlphaFormatNone;

422 switch (CGImageGetAlphaInfo(~~m_cgI~~mage.get())) {

427 switch (CGImageGetAlphaInfo(image.get())) {

    case kCGImageAlphaPremultipliedFirst:

        if (!premultiplyAlpha)

            m_alphaOp = AlphaOp::DoUnmultiply;

@@bool GraphicsContextGLImageExtractor::extractImage(bool premultiplyAlpha, bool i

    if (m_imageSourceFormat == DataFormat::NumFormats)

        return false;

466 m_pixelData = adoptCF(CGDataProviderCopyData(CGImageGetDataProvider(~~m_cgI~~mage.get())));

471 m_pixelData = adoptCF(CGDataProviderCopyData(CGImageGetDataProvider(image.get())));

    if (!m_pixelData)

        return false;

    m_imagePixelData = reinterpret_cast<const void*>(CFDataGetBytePtr(m_pixelData.get()));

    unsigned srcUnpackAlignment = 0;

473 size_t bytesPerRow = CGImageGetBytesPerRow(~~m_cgI~~mage.get());

478 size_t bytesPerRow = CGImageGetBytesPerRow(image.get());

    unsigned padding = bytesPerRow - bitsPerPixel / 8 * m_imageWidth;

    if (padding) {

        srcUnpackAlignment = padding + 1;

@@void GraphicsContextGLOpenGL::paintToCanvas(const unsigned char* imagePixels, co

    context.scale(FloatSize(1, -1));

    context.translate(0, -imageSize.height());

    context.setImageInterpolationQuality(InterpolationQuality::DoNotInterpolate);

546 context.drawN~~ative~~Image(cgImage, imageSize, canvasRect, FloatRect(FloatPoint(), imageSize), { CompositeOperator::Copy });

551 context.drawPlatformImage(cgImage, imageSize, canvasRect, FloatRect(FloatPoint(), imageSize), { CompositeOperator::Copy });

}

} // namespace WebCore

Source/WebCore/platform/graphics/cg/ImageBufferCGBackend.cpp

@@void ImageBufferCGBackend::setupContext()

    context().applyDeviceScaleFactor(m_resolutionScale);

}

70 static Re~~tain~~Ptr<CGImage~~Ref~~> createCroppedImageIfNecessary(CGImage~~Ref~~ image, const IntSize& backendSize)

70static RefPtr<NativeImage> createCroppedImageIfNecessary(RefPtr<NativeImage>&& image, const IntSize& backendSize)

7171{

    if (image && (CGImageGetWidth(image) != static_cast<size_t>(backendSize.width()) || CGImageGetHeight(image) != static_cast<size_t>(backendSize.height())))

        return adoptCF(CGImageCreateWithImageInRect(image, CGRectMake(0, 0, backendSize.width(), backendSize.height())));

    return image;

    if (image && image->size() != backendSize)

        return NativeImage::create(CGImageCreateWithImageInRect(image->platformImage().get(), CGRectMake(0, 0, backendSize.width(), backendSize.height())));

    return WTFMove(image);

7575}

7676

77 static RefPtr<Image> createBitmapImageAfterScalingIfNeeded(Re~~tain~~Ptr<CGImage~~Ref~~>&& image, const IntSize& logicalSize, const IntSize& backendSize, float resolutionScale, PreserveResolution preserveResolution)

77static RefPtr<Image> createBitmapImageAfterScalingIfNeeded(RefPtr<NativeImage>&& image, const IntSize& logicalSize, const IntSize& backendSize, float resolutionScale, PreserveResolution preserveResolution)

7878{

7979 if (resolutionScale == 1 || preserveResolution == PreserveResolution::Yes)

80 image = createCroppedImageIfNecessary(image~~.get(~~), backendSize);

80 image = createCroppedImageIfNecessary(WTFMove(image), backendSize);

    else {

        auto context = adoptCF(CGBitmapContextCreate(0, logicalSize.width(), logicalSize.height(), 8, 4 * logicalSize.width(), sRGBColorSpaceRef(), kCGImageAlphaPremultipliedLast));

        CGContextSetBlendMode(context.get(), kCGBlendModeCopy);

        CGContextClipToRect(context.get(), FloatRect(FloatPoint::zero(), logicalSize));

        FloatSize imageSizeInUserSpace = logicalSize;

86 CGContextDrawImage(context.get(), FloatRect(FloatPoint::zero(), imageSizeInUserSpace), image.get());

87 image = ~~adoptCF~~(CGBitmapContextCreateImage(context.get()));

86 CGContextDrawImage(context.get(), FloatRect(FloatPoint::zero(), imageSizeInUserSpace), image->platformImage().get());

87 image = NativeImage::create(CGBitmapContextCreateImage(context.get()));

    }

    if (!image)

@@static RefPtr<Image> createBitmapImageAfterScalingIfNeeded(RetainPtr<CGImageRef>

RefPtr<Image> ImageBufferCGBackend::copyImage(BackingStoreCopy copyBehavior, PreserveResolution preserveResolution) const

{

98 NativeImage~~Ptr~~ image;

98 RefPtr<NativeImage> image;

    if (m_resolutionScale == 1 || preserveResolution == PreserveResolution::Yes)

        image = copyNativeImage(copyBehavior);

    else

@@void ImageBufferCGBackend::draw(GraphicsContext& destContext, const FloatRect& d

    srcRectScaled.scale(m_resolutionScale);

    if (auto image = copyNativeImage(&destContext == &context() ? CopyBackingStore : DontCopyBackingStore))

117 destContext.drawNativeImage(image~~.get()~~, m_backendSize, destRect, srcRectScaled, options);

117 destContext.drawNativeImage(*image, m_backendSize, destRect, srcRectScaled, options);

}

void ImageBufferCGBackend::drawPattern(GraphicsContext& destContext, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize& spacing, const ImagePaintingOptions& options)

@@RetainPtr<CFDataRef> ImageBufferCGBackend::toCFData(const String& mimeType, Opti

    auto uti = utiFromImageBufferMIMEType(mimeType);

    ASSERT(uti);

141 Re~~tain~~Ptr<CGImage~~Ref~~> image;

141 RefPtr<NativeImage> image;

    RefPtr<Uint8ClampedArray> protectedPixelArray;

    if (CFEqual(uti.get(), jpegUTI())) {

@@RetainPtr<CFDataRef> ImageBufferCGBackend::toCFData(const String& mimeType, Opti

        if (!dataProvider)

            return nullptr;

159 image = ~~adoptCF~~(CGImageCreate(pixelArrayDimensions.width(), pixelArrayDimensions.height(), 8, 32, 4 * pixelArrayDimensions.width(), sRGBColorSpaceRef(), kCGBitmapByteOrderDefault | kCGImageAlphaNoneSkipLast, dataProvider.get(), 0, false, kCGRenderingIntentDefault));

159 image = NativeImage::create(CGImageCreate(pixelArrayDimensions.width(), pixelArrayDimensions.height(), 8, 32, 4 * pixelArrayDimensions.width(), sRGBColorSpaceRef(), kCGBitmapByteOrderDefault | kCGImageAlphaNoneSkipLast, dataProvider.get(), 0, false, kCGRenderingIntentDefault));

    } else if (m_resolutionScale == 1 || preserveResolution == PreserveResolution::Yes) {

        image = copyNativeImage(CopyBackingStore);

        image = createCroppedImageIfNecessary(image.get(), backendSize());

@@RetainPtr<CFDataRef> ImageBufferCGBackend::toCFData(const String& mimeType, Opti

        auto context = adoptCF(CGBitmapContextCreate(0, backendSize().width(), backendSize().height(), 8, 4 * backendSize().width(), sRGBColorSpaceRef(), kCGImageAlphaPremultipliedLast));

        CGContextSetBlendMode(context.get(), kCGBlendModeCopy);

        CGContextClipToRect(context.get(), CGRectMake(0, 0, backendSize().width(), backendSize().height()));

168 CGContextDrawImage(context.get(), CGRectMake(0, 0, backendSize().width(), backendSize().height()), image.get());

169 image = ~~adoptCF~~(CGBitmapContextCreateImage(context.get()));

168 CGContextDrawImage(context.get(), CGRectMake(0, 0, backendSize().width(), backendSize().height()), image->platformImage().get());

169 image = NativeImage::create(CGBitmapContextCreateImage(context.get()));

    }

    auto cfData = adoptCF(CFDataCreateMutable(kCFAllocatorDefault, 0));

173 if (!encodeImage(image.get(), uti.get(), quality, cfData.get()))

173 if (!encodeImage(image->platformImage().get(), uti.get(), quality, cfData.get()))

        return nullptr;

    return WTFMove(cfData);

Source/WebCore/platform/graphics/cg/ImageBufferCGBitmapBackend.cpp

@@GraphicsContext& ImageBufferCGBitmapBackend::context() const

    return *m_context;

}

110 NativeImage~~Ptr~~ ImageBufferCGBitmapBackend::copyNativeImage(BackingStoreCopy copyBehavior) const

110RefPtr<NativeImage> ImageBufferCGBitmapBackend::copyNativeImage(BackingStoreCopy copyBehavior) const

{

    switch (copyBehavior) {

    case CopyBackingStore:

114 return ~~adoptCF~~(CGBitmapContextCreateImage(context().platformContext()));

114 return NativeImage::create(CGBitmapContextCreateImage(context().platformContext()));

115115

116116 case DontCopyBackingStore:

117 return ~~adoptCF~~(CGImageCreate(

117 return NativeImage::create(CGImageCreate(

            m_backendSize.width(), m_backendSize.height(), 8, 32, bytesPerRow(),

            cachedCGColorSpace(m_colorSpace), DefaultBitmapInfo, m_dataProvider.get(),

            0, true, kCGRenderingIntentDefault));

Source/WebCore/platform/graphics/cg/ImageBufferCGBitmapBackend.h

@@public:

    GraphicsContext& context() const override;

45 NativeImage~~Ptr~~ copyNativeImage(BackingStoreCopy = CopyBackingStore) const override;

45 RefPtr<NativeImage> copyNativeImage(BackingStoreCopy = CopyBackingStore) const override;

    Vector<uint8_t> toBGRAData() const override;

Source/WebCore/platform/graphics/cg/ImageBufferIOSurfaceBackend.cpp

@@ColorFormat ImageBufferIOSurfaceBackend::backendColorFormat() const

    return ColorFormat::BGRA;

}

138 NativeImage~~Ptr~~ ImageBufferIOSurfaceBackend::copyNativeImage(BackingStoreCopy) const

138RefPtr<NativeImage> ImageBufferIOSurfaceBackend::copyNativeImage(BackingStoreCopy) const

139139{

140 return m_surface->createImage();

140 return NativeImage::create(m_surface->createImage());

141141}

142142

143 NativeImage~~Ptr~~ ImageBufferIOSurfaceBackend::sinkIntoNativeImage()

143RefPtr<NativeImage> ImageBufferIOSurfaceBackend::sinkIntoNativeImage()

144144{

145 return IOSurface::sinkIntoImage(WTFMove(m_surface));

145 return NativeImage::create(IOSurface::sinkIntoImage(WTFMove(m_surface)));

}

void ImageBufferIOSurfaceBackend::drawConsuming(GraphicsContext& destContext, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

@@void ImageBufferIOSurfaceBackend::drawConsuming(GraphicsContext& destContext, co

    adjustedSrcRect.scale(m_resolutionScale);

    if (auto image = sinkIntoNativeImage())

154 destContext.drawNativeImage(image~~.get()~~, m_backendSize, destRect, adjustedSrcRect, options);

154 destContext.drawNativeImage(*image, m_backendSize, destRect, adjustedSrcRect, options);

}

RetainPtr<CFDataRef> ImageBufferIOSurfaceBackend::toCFData(const String& mimeType, Optional<double> quality, PreserveResolution preserveResolution) const

Source/WebCore/platform/graphics/cg/ImageBufferIOSurfaceBackend.h

@@public:

    size_t memoryCost() const override;

    size_t externalMemoryCost() const override;

54 NativeImage~~Ptr~~ copyNativeImage(BackingStoreCopy = CopyBackingStore) const override;

55 NativeImage~~Ptr~~ sinkIntoNativeImage() override;

54 RefPtr<NativeImage> copyNativeImage(BackingStoreCopy = CopyBackingStore) const override;

55 RefPtr<NativeImage> sinkIntoNativeImage() override;

    void drawConsuming(GraphicsContext&, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&) override;

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

@@unsigned ImageDecoderCG::frameBytesAtIndex(size_t index, SubsamplingLevel subsam

    return (frameSize.area() * 4).unsafeGet();

}

495 N~~ative~~ImagePtr ImageDecoderCG::createFrameImageAtIndex(size_t index, SubsamplingLevel subsamplingLevel, const DecodingOptions& decodingOptions)

495PlatformImagePtr ImageDecoderCG::createFrameImageAtIndex(size_t index, SubsamplingLevel subsamplingLevel, const DecodingOptions& decodingOptions)

{

    LOG(Images, "ImageDecoder %p createFrameImageAtIndex %lu", this, index);

    RetainPtr<CFDictionaryRef> options;

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

@@public:

    bool frameAllowSubsamplingAtIndex(size_t) const final;

    unsigned frameBytesAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default) const final;

65 N~~ative~~ImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, const DecodingOptions& = DecodingOptions(DecodingMode::Synchronous)) final;

65 PlatformImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, const DecodingOptions& = DecodingOptions(DecodingMode::Synchronous)) final;

    void setData(SharedBuffer&, bool allDataReceived) final;

    bool isAllDataReceived() const final { return m_isAllDataReceived; }

Source/WebCore/platform/graphics/cg/NativeImageCG.cpp

namespace WebCore {

40 IntSize ~~nativeImageSize(const~~ NativeImagePtr& image)

40IntSize NativeImage::size(const PlatformImagePtr& platformImage)

4141{

42 return image ? IntSize(CGImageGetWidth(image.get()), CGImageGetHeight(image.get())) : IntSize();

42 return platformImage ? IntSize(CGImageGetWidth(platformImage.get()), CGImageGetHeight(platformImage.get())) : IntSize();

4343}

4444

45 bool ~~nativeImageHasAlpha(const~~ NativeImageP~~tr& image)~~

45bool NativeImage::hasAlpha() const

4646{

47 CGImageAlphaInfo info = CGImageGetAlphaInfo(image.get());

47 CGImageAlphaInfo info = CGImageGetAlphaInfo(m_platformImage.get());

    return (info >= kCGImageAlphaPremultipliedLast) && (info <= kCGImageAlphaFirst);

}

51 Color nativeImageSinglePixelSolidColor(const ~~NativeImagePtr& image)~~

51Color NativeImage::singlePixelSolidColor() const

5252{

53 if (!image || ~~nativeImageS~~ize(~~image~~) != IntSize(1, 1))

53 if (!m_platformImage || size() != IntSize(1, 1))

        return Color();

    unsigned char pixel[4]; // RGBA

@@Color nativeImageSinglePixelSolidColor(const NativeImagePtr& image)

        return Color();

    CGContextSetBlendMode(bitmapContext.get(), kCGBlendModeCopy);

63 CGContextDrawImage(bitmapContext.get(), CGRectMake(0, 0, 1, 1), image.get());

63 CGContextDrawImage(bitmapContext.get(), CGRectMake(0, 0, 1, 1), m_platformImage.get());

    if (!pixel[3])

        return Color::transparentBlack;

@@Color nativeImageSinglePixelSolidColor(const NativeImagePtr& image)

    return clampToComponentBytes<SRGBA>(pixel[0] * 255 / pixel[3], pixel[1] * 255 / pixel[3], pixel[2] * 255 / pixel[3], pixel[3]);

}

71 void ~~clearNativeImageSubimages(const~~ NativeImagePtr& image)

71void NativeImage::clearSubimages()

7272{

7373#if CACHE_SUBIMAGES

74 if (image)

75 SubimageCacheWithTimer::clearImage(image.get());

74 if (m_platformImage)

75 SubimageCacheWithTimer::clearImage(m_platformImage.get());

#endif

}

Source/WebCore/platform/graphics/cg/PatternCG.cpp

@@CGPatternRef Pattern::createPlatformPattern(const AffineTransform& userSpaceTran

    patternTransform.scaleNonUniform(1, -1);

    patternTransform.translate(0, -tileRect.height());

    PlatformImagePtr platformImage;

    if (auto nativeImage = tileImage().nativeImage())

        platformImage = nativeImage->platformImage();

    if (!platformImage)

        return nullptr;

    // If we're repeating in both directions, we can use image-backed patterns

    // instead of custom patterns, and avoid tiling-edge pixel cracks.

    if (m_repeatX && m_repeatY)

69 return CGPatternCreateWithImage2(~~tile~~Image~~().nativeImage()~~.get(), patternTransform, kCGPatternTilingConstantSpacing);

76 return CGPatternCreateWithImage2(platformImage.get(), patternTransform, kCGPatternTilingConstantSpacing);

    // If FLT_MAX should also be used for xStep or yStep, nothing is rendered. Using fractions of FLT_MAX also

    // result in nothing being rendered.

@@CGPatternRef Pattern::createPlatformPattern(const AffineTransform& userSpaceTran

    CGFloat yStep = m_repeatY ? tileRect.height() : (1 << 22);

    // The pattern will release the CGImageRef when it's done rendering in patternReleaseCallback

80 CGImageRef platformImage ~~= tileImage().nativeImage()~~.leakRef();

87 CGImageRef image = platformImage.leakRef();

8188

8289 const CGPatternCallbacks patternCallbacks = { 0, patternCallback, patternReleaseCallback };

83 return CGPatternCreate(~~platformI~~mage, tileRect, patternTransform, xStep, yStep, kCGPatternTilingConstantSpacing, TRUE, &patternCallbacks);

90 return CGPatternCreate(image, tileRect, patternTransform, xStep, yStep, kCGPatternTilingConstantSpacing, TRUE, &patternCallbacks);

}

}

Source/WebCore/platform/graphics/coreimage/FilterEffectRendererCoreImage.mm

@@RetainPtr<CIImage> FilterEffectRendererCoreImage::imageForSourceGraphic(SourceGr

    if (is<AcceleratedImageBuffer>(*sourceImage))

        return [CIImage imageWithIOSurface:downcast<AcceleratedImageBuffer>(*sourceImage).surface().surface()];

180 return [CIImage imageWithCGImage:sourceImage->copyNativeImage().get()];

180 return [CIImage imageWithCGImage:sourceImage->copyNativeImage()->platformImage().get()];

}

RetainPtr<CIImage> FilterEffectRendererCoreImage::imageForFEColorMatrix(const FEColorMatrix& effect, const Vector<RetainPtr<CIImage>>& inputImages)

Source/WebCore/platform/graphics/displaylists/DisplayList.h

@@enum class ItemType : uint8_t {

    DrawTiledScaledImage,

    DrawImageBuffer,

    DrawNativeImage,

71 DrawPlatformImage,

    DrawPattern,

    DrawRect,

    DrawLine,

Source/WebCore/platform/graphics/displaylists/DisplayListItems.cpp

@@size_t Item::sizeInBytes(const Item& item)

        return sizeof(downcast<DrawImageBuffer>(item));

    case ItemType::DrawNativeImage:

        return sizeof(downcast<DrawNativeImage>(item));

121 case ItemType::DrawPlatformImage:

122 return sizeof(downcast<DrawPlatformImage>(item));

    case ItemType::DrawPattern:

        return sizeof(downcast<DrawPattern>(item));

    case ItemType::DrawRect:

@@static TextStream& operator<<(TextStream& ts, const DrawImageBuffer& item)

    return ts;

}

862 DrawNativeImage::DrawNativeImage(co~~nst NativeImag~~ePt~~r& image~~, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

864DrawNativeImage::DrawNativeImage(RenderingResourceIdentifier renderingResourceIdentifier, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

863865 : DrawingItem(ItemType::DrawNativeImage)

864 , m_~~ima~~ge(~~ima~~ge)

866 , m_renderingResourceIdentifier(renderingResourceIdentifier)

    , m_imageSize(imageSize)

    , m_destinationRect(destRect)

    , m_srcRect(srcRect)

@@DrawNativeImage::DrawNativeImage(const NativeImagePtr& image, const FloatSize& i

DrawNativeImage::~DrawNativeImage() = default;

874 void DrawNativeImage::apply(GraphicsContext& ~~context~~) const

876void DrawNativeImage::apply(GraphicsContext&) const

875877{

876 context.drawNativeImage(m_image, m_imageSize, m_destinationRect, m_srcRect, m_options);

878 // Should be handled by the delegate.

879 ASSERT_NOT_REACHED();

}

static TextStream& operator<<(TextStream& ts, const DrawNativeImage& item)

{

    ts << static_cast<const DrawingItem&>(item);

    // FIXME: dump more stuff.

    ts.dumpProperty("remote-resource-identifier", item.renderingResourceIdentifier());

    ts.dumpProperty("source-rect", item.source());

    ts.dumpProperty("dest-rect", item.destinationRect());

    return ts;

}

DrawPlatformImage::DrawPlatformImage(const PlatformImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

    : DrawingItem(ItemType::DrawPlatformImage)

    , m_image(image)

    , m_imageSize(imageSize)

    , m_destinationRect(destRect)

    , m_srcRect(srcRect)

    , m_options(options)

{

}

DrawPlatformImage::~DrawPlatformImage() = default;

void DrawPlatformImage::apply(GraphicsContext& context) const

{

    context.drawPlatformImage(m_image, m_imageSize, m_destinationRect, m_srcRect, m_options);

}

static TextStream& operator<<(TextStream& ts, const DrawPlatformImage& item)

{

    ts << static_cast<const DrawingItem&>(item);

    // FIXME: dump more stuff.

@@static TextStream& operator<<(TextStream& ts, const ItemType& type)

    case ItemType::DrawTiledScaledImage: ts << "draw-tiled-scaled-image"; break;

    case ItemType::DrawImageBuffer: ts << "draw-image-buffer"; break;

    case ItemType::DrawNativeImage: ts << "draw-native-image"; break;

1710 case ItemType::DrawPlatformImage: ts << "draw-platform-image"; break;

    case ItemType::DrawPattern: ts << "draw-pattern"; break;

    case ItemType::DrawRect: ts << "draw-rect"; break;

    case ItemType::DrawLine: ts << "draw-line"; break;

@@TextStream& operator<<(TextStream& ts, const Item& item)

    case ItemType::DrawNativeImage:

        ts << downcast<DrawNativeImage>(item);

        break;

    case ItemType::DrawPlatformImage:

        ts << downcast<DrawPlatformImage>(item);

        break;

    case ItemType::DrawPattern:

        ts << downcast<DrawPattern>(item);

        break;

Source/WebCore/platform/graphics/displaylists/DisplayListItems.h

@@Optional<Ref<DrawImageBuffer>> DrawImageBuffer::decode(Decoder& decoder)

class DrawNativeImage : public DrawingItem {

public:

1704 static Ref<DrawNativeImage> create(co~~nst NativeImag~~ePt~~r& image~~, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

1704 static Ref<DrawNativeImage> create(RenderingResourceIdentifier renderingResourceIdentifier, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

17051705 {

1706 return adoptRef(*new DrawNativeImage(~~ima~~ge, imageSize, destRect, srcRect, options));

1706 return adoptRef(*new DrawNativeImage(renderingResourceIdentifier, imageSize, destRect, srcRect, options));

    }

    WEBCORE_EXPORT virtual ~DrawNativeImage();

1711 RenderingResourceIdentifier renderingResourceIdentifier() const { return m_renderingResourceIdentifier; }

1712 FloatSize imageSize() const { return m_imageSize; }

17111713 FloatRect source() const { return m_srcRect; }

17121714 FloatRect destinationRect() const { return m_destinationRect; }

1715 ImagePaintingOptions options() const { return m_options; }

    template<class Encoder> void encode(Encoder&) const;

    template<class Decoder> static Optional<Ref<DrawNativeImage>> decode(Decoder&);

private:

1718 WEBCORE_EXPORT DrawNativeImage(co~~nst NativeImagePt~~r&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&);

1721 WEBCORE_EXPORT DrawNativeImage(RenderingResourceIdentifier, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&);

    void apply(GraphicsContext&) const override;

    Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_destinationRect; }

1724 Na~~tiveImagePt~~r m_~~ima~~ge;

1727 RenderingResourceIdentifier m_renderingResourceIdentifier;

    FloatSize m_imageSize;

    FloatRect m_destinationRect;

    FloatRect m_srcRect;

@@private:

template<class Encoder>

void DrawNativeImage::encode(Encoder& encoder) const

{

1734 encoder << m_~~ima~~ge;

1737 encoder << m_renderingResourceIdentifier;

    encoder << m_imageSize;

    encoder << m_destinationRect;

    encoder << m_srcRect;

@@void DrawNativeImage::encode(Encoder& encoder) const

template<class Decoder>

Optional<Ref<DrawNativeImage>> DrawNativeImage::decode(Decoder& decoder)

{

1744 Optional<NativeImagePtr> image;

    Optional<RenderingResourceIdentifier> renderingResourceIdentifier;

    decoder >> renderingResourceIdentifier;

    if (!renderingResourceIdentifier)

        return WTF::nullopt;

    Optional<FloatSize> imageSize;

    decoder >> imageSize;

    if (!imageSize)

        return WTF::nullopt;

    Optional<FloatRect> destinationRect;

    decoder >> destinationRect;

    if (!destinationRect)

        return WTF::nullopt;

    Optional<FloatRect> srcRect;

    decoder >> srcRect;

    if (!srcRect)

        return WTF::nullopt;

    Optional<ImagePaintingOptions> options;

    decoder >> options;

    if (!options)

        return WTF::nullopt;

    return DrawNativeImage::create(*renderingResourceIdentifier, *imageSize, *destinationRect, *srcRect, *options);

}

class DrawPlatformImage : public DrawingItem {

public:

    static Ref<DrawPlatformImage> create(const PlatformImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

    {

        return adoptRef(*new DrawPlatformImage(image, imageSize, destRect, srcRect, options));

    }

    WEBCORE_EXPORT virtual ~DrawPlatformImage();

    FloatRect source() const { return m_srcRect; }

    FloatRect destinationRect() const { return m_destinationRect; }

    template<class Encoder> void encode(Encoder&) const;

    template<class Decoder> static Optional<Ref<DrawPlatformImage>> decode(Decoder&);

private:

    WEBCORE_EXPORT DrawPlatformImage(const PlatformImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&);

    void apply(GraphicsContext&) const override;

    Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_destinationRect; }

    PlatformImagePtr m_image;

    FloatSize m_imageSize;

    FloatRect m_destinationRect;

    FloatRect m_srcRect;

    ImagePaintingOptions m_options;

};

template<class Encoder>

void DrawPlatformImage::encode(Encoder& encoder) const

{

    encoder << m_image;

    encoder << m_imageSize;

    encoder << m_destinationRect;

    encoder << m_srcRect;

    encoder << m_options;

}

template<class Decoder>

Optional<Ref<DrawPlatformImage>> DrawPlatformImage::decode(Decoder& decoder)

{

    Optional<PlatformImagePtr> image;

    decoder >> image;

    if (!image)

        return WTF::nullopt;

@@Optional<Ref<DrawNativeImage>> DrawNativeImage::decode(Decoder& decoder)

    if (!options)

        return WTF::nullopt;

1769 return DrawN~~ative~~Image::create(*image, *imageSize, *destinationRect, *srcRect, *options);

1842 return DrawPlatformImage::create(*image, *imageSize, *destinationRect, *srcRect, *options);

}

class DrawPattern : public DrawingItem {

@@void Item::encode(Encoder& encoder) const

    case ItemType::DrawNativeImage:

        encoder << downcast<DrawNativeImage>(*this);

        break;

    case ItemType::DrawPlatformImage:

        encoder << downcast<DrawPlatformImage>(*this);

        break;

    case ItemType::DrawPattern:

        encoder << downcast<DrawPattern>(*this);

        break;

@@Optional<Ref<Item>> Item::decode(Decoder& decoder)

        if (auto item = DrawNativeImage::decode(decoder))

            return static_reference_cast<Item>(WTFMove(*item));

        break;

    case ItemType::DrawPlatformImage:

        if (auto item = DrawPlatformImage::decode(decoder))

            return static_reference_cast<Item>(WTFMove(*item));

        break;

    case ItemType::DrawPattern:

        if (auto item = DrawPattern::decode(decoder))

            return static_reference_cast<Item>(WTFMove(*item));

@@SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawTiledImage)

SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawTiledScaledImage)

SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawImageBuffer)

SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawNativeImage)

3810SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawPlatformImage)

SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawPattern)

SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawRect)

SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawLine)

@@template<> struct EnumTraits<WebCore::DisplayList::ItemType> {

    WebCore::DisplayList::ItemType::DrawTiledScaledImage,

    WebCore::DisplayList::ItemType::DrawImageBuffer,

    WebCore::DisplayList::ItemType::DrawNativeImage,

3882 WebCore::DisplayList::ItemType::DrawPlatformImage,

    WebCore::DisplayList::ItemType::DrawPattern,

    WebCore::DisplayList::ItemType::DrawRect,

    WebCore::DisplayList::ItemType::DrawLine,

Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.cpp

@@bool Recorder::drawImageBuffer(WebCore::ImageBuffer& imageBuffer, const FloatRec

    return true;

}

197 v~~oid~~ Recorder::drawNativeImage(~~const~~ NativeImage~~Ptr~~& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

197bool Recorder::drawNativeImage(NativeImage& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

198198{

199 appendItemAndUpdateExtent(DrawNativeImage::create(image, imageSize, destRect, srcRect, options));

    if (!m_delegate || !m_delegate->lockRemoteNativeImage(image))

        return false;

    appendItemAndUpdateExtent(DrawNativeImage::create(image.renderingResourceIdentifier(), imageSize, destRect, srcRect, options));

    return true;

}

void Recorder::drawPlatformImage(const PlatformImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

{

    appendItemAndUpdateExtent(DrawPlatformImage::create(image, imageSize, destRect, srcRect, options));

}

void Recorder::drawPattern(Image& image, const FloatRect& destRect, const FloatRect& tileRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize& spacing, const ImagePaintingOptions& options)

Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.h

@@public:

    public:

        virtual ~Delegate() { }

        virtual bool lockRemoteImageBuffer(WebCore::ImageBuffer&) { return false; }

69 virtual bool lockRemoteNativeImage(NativeImage&) { return false; }

        virtual void willAppendItem(const Item&) { };

        virtual void didAppendItem(const Item&) { };

    };

@@private:

    ImageDrawResult drawTiledImage(Image&, const FloatRect& destination, const FloatRect& source, const FloatSize& tileScaleFactor, Image::TileRule hRule, Image::TileRule vRule, const ImagePaintingOptions&) override;

    bool drawImageBuffer(WebCore::ImageBuffer&, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions&) override;

111 void drawNativeImage(const NativeImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&) override;

112 bool drawNativeImage(NativeImage&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&) override;

113 void drawPlatformImage(const PlatformImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&) override;

    void drawPattern(Image&, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform&, const FloatPoint& phase, const FloatSize& spacing, const ImagePaintingOptions&) override;

    void drawRect(const FloatRect&, float borderThickness) override;

Source/WebCore/platform/graphics/gstreamer/ImageDecoderGStreamer.cpp

@@public:

        return adoptRef(*new ImageDecoderGStreamerSample(WTFMove(sample), presentationSize));

    }

49 N~~ative~~ImagePtr image() const

49 PlatformImagePtr image() const

    {

        if (!m_image)

            return nullptr;

53 return m_image->image().nativeImage();

53 return m_image->image().nativeImage()->platformImage();

    }

    void dropImage() { m_image = nullptr; }

@@unsigned ImageDecoderGStreamer::frameBytesAtIndex(size_t index, SubsamplingLevel

    return (frameSize.area() * 4).unsafeGet();

}

182 N~~ative~~ImagePtr ImageDecoderGStreamer::createFrameImageAtIndex(size_t index, SubsamplingLevel, const DecodingOptions&)

182PlatformImagePtr ImageDecoderGStreamer::createFrameImageAtIndex(size_t index, SubsamplingLevel, const DecodingOptions&)

{

    LockHolder holder { m_sampleGeneratorLock };

Source/WebCore/platform/graphics/gstreamer/ImageDecoderGStreamer.h

@@public:

    bool frameAllowSubsamplingAtIndex(size_t index) const final { return index <= m_sampleData.size(); }

    unsigned frameBytesAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default) const final;

70 N~~ative~~ImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, const DecodingOptions& = DecodingOptions(DecodingMode::Synchronous)) final;

70 PlatformImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, const DecodingOptions& = DecodingOptions(DecodingMode::Synchronous)) final;

    void setExpectedContentSize(long long) final { }

    void setData(SharedBuffer&, bool allDataReceived) final;

Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp

@@bool MediaPlayerPrivateGStreamer::copyVideoTextureToPlatformTexture(GraphicsCont

    return m_videoTextureCopier->copyVideoTextureToPlatformTexture(*layerBuffer.get(), size, outputTexture, outputTarget, level, internalFormat, format, type, flipY, m_videoSourceOrientation);

}

3218 NativeImage~~Ptr~~ MediaPlayerPrivateGStreamer::nativeImageForCurrentTime()

3218RefPtr<NativeImage> MediaPlayerPrivateGStreamer::nativeImageForCurrentTime()

{

    return nullptr;

}

Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h

@@public:

#if USE(GSTREAMER_GL)

    bool copyVideoTextureToPlatformTexture(GraphicsContextGLOpenGL*, PlatformGLObject, GCGLenum, GCGLint, GCGLenum, GCGLenum, GCGLenum, bool, bool) override;

219 NativeImage~~Ptr~~ nativeImageForCurrentTime() override;

219 RefPtr<NativeImage> nativeImageForCurrentTime() override;

#endif

    void updateEnabledVideoTrack();

Source/WebCore/platform/graphics/gtk/ImageGtk.cpp

@@Ref<Image> Image::loadPlatformResource(const char* name)

GdkPixbuf* BitmapImage::getGdkPixbuf()

{

59 RefPtr<cairo_surface_t> surface = nativeImageForCurrentFrame();

    auto nativeImage = nativeImageForCurrentFrame();

    if (!nativeImage || nativeImage->isNull())

        return nullptr;

    auto& surface = nativeImage->platformImage();

    return surface ? cairoSurfaceToGdkPixbuf(surface.get()) : 0;

}

Source/WebCore/platform/graphics/ios/IconIOS.mm

namespace WebCore {

    

36 Icon::Icon(const N~~ative~~ImagePtr& image)

36Icon::Icon(const PlatformImagePtr& image)

    : m_cgImage(image)

{

}

@@RefPtr<Icon> Icon::createIconForFiles(const Vector<String>& /*filenames*/)

    return nullptr;

}

50 RefPtr<Icon> Icon::createIconForImage(const Re~~tainPtr<CG~~Image~~Ref>~~& image)

50RefPtr<Icon> Icon::createIconForImage(const PlatformImagePtr& image)

{

    if (!image)

        return nullptr;

@@void Icon::paint(GraphicsContext& context, const FloatRect& destRect)

    FloatRect srcRect(FloatPoint(), size);

    context.setImageInterpolationQuality(InterpolationQuality::High);

71 context.drawN~~ative~~Image(m_cgImage~~.get()~~, size, destRect, srcRect);

71 context.drawPlatformImage(m_cgImage, size, destRect, srcRect);

}

}

Source/WebCore/platform/graphics/mac/ImageMac.mm

@@Ref<Image> Image::loadPlatformResource(const char *name)

    return Image::nullImage();

}

77 RetainPtr<CFDataRef> BitmapImage::tiffRepresentation(const Vector<NativeImage~~Ptr~~>& nativeImages)

77RetainPtr<CFDataRef> BitmapImage::tiffRepresentation(const Vector<RefPtr<NativeImage>>& nativeImages)

{

    // If nativeImages.size() is zero, we know for certain this image doesn't have valid data

    // Even though the call to CGImageDestinationCreateWithData will fail and we'll handle it gracefully,

@@RetainPtr<CFDataRef> BitmapImage::tiffRepresentation(const Vector<NativeImagePtr

        return nullptr;

    for (const auto& nativeImage : nativeImages)

92 CGImageDestinationAddImage(destination.get(), nativeImage.get(), 0);

92 CGImageDestinationAddImage(destination.get(), nativeImage->platformImage().get(), 0);

    CGImageDestinationFinalize(destination.get());

    return data;

Source/WebCore/platform/graphics/nicosia/NicosiaImageBufferPipe.cpp

@@void NicosiaImageBufferPipeSource::handle(std::unique_ptr<ImageBuffer>&& buffer)

                        return;

                    auto nativeImage = ImageBuffer::sinkIntoNativeImage(WTFMove(m_imageBuffer));

112 auto size = nativeImageSize(nativeImage);

                    if (!nativeImage)

                        return;

                    auto size = nativeImage->size();

113116

114 texture->reset(size, nativeImageHasAlpha(~~nativeImage~~) ? BitmapTexture::SupportsAlpha : BitmapTexture::NoFlag);

117 texture->reset(size, nativeImage->hasAlpha() ? BitmapTexture::SupportsAlpha : BitmapTexture::NoFlag);

115118#if USE(CAIRO)

116 auto* surface = nativeImage.get();

119 auto* surface = nativeImage->platformImage().get();

                    auto* imageData = reinterpret_cast<const char*>(cairo_image_surface_get_data(surface));

                    texture->updateContents(imageData, IntRect(IntPoint(), size), IntPoint(), cairo_image_surface_get_stride(surface));

#else

Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp

@@bool CairoOperationRecorder::drawImageBuffer(ImageBuffer&, const FloatRect&, con

    return false;

}

558 v~~oid~~ CairoOperationRecorder::drawNativeImage(~~const~~ NativeImage~~Ptr& image~~, const FloatSize& ~~imageSize~~, const FloatRect& ~~destRect~~, const FloatRect& ~~srcRect~~, const ImagePaintingOptions& ~~options~~)

558bool CairoOperationRecorder::drawNativeImage(NativeImage&, const FloatSize&, const FloatRect&, const FloatRect&, const ImagePaintingOptions&)

559559{

560 struct DrawNativeImage final : PaintingOperation, OperationData<RefPtr<cairo_surface_t>, FloatRect, FloatRect, ImagePaintingOptions, float, Cairo::ShadowState> {

561 virtual ~DrawNativeImage() = default;

    // FIXME: Not implemented.

    return false;

}

void CairoOperationRecorder::drawPlatformImage(const PlatformImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

{

    struct DrawPlatformImage final : PaintingOperation, OperationData<RefPtr<cairo_surface_t>, FloatRect, FloatRect, ImagePaintingOptions, float, Cairo::ShadowState> {

        virtual ~DrawPlatformImage() = default;

        void execute(PaintingOperationReplay& replayer) override

        {

565 Cairo::drawN~~ative~~Image(contextForReplay(replayer), arg<0>().get(), arg<1>(), arg<2>(), arg<3>(), arg<4>(), arg<5>());

571 Cairo::drawPlatformImage(contextForReplay(replayer), arg<0>().get(), arg<1>(), arg<2>(), arg<3>(), arg<4>(), arg<5>());

        }

        void dump(TextStream& ts) override

        {

570 ts << indent << "DrawN~~ative~~Image<>\n";

576 ts << indent << "DrawPlatformImage<>\n";

        }

    };

    UNUSED_PARAM(imageSize);

    auto& state = graphicsContext().state();

576 append(createCommand<DrawN~~ative~~Image>(RefPtr<cairo_surface_t>(image.get()), destRect, srcRect, ImagePaintingOptions(options, state.imageInterpolationQuality), state.alpha, Cairo::ShadowState(state)));

582 append(createCommand<DrawPlatformImage>(RefPtr<cairo_surface_t>(image.get()), destRect, srcRect, ImagePaintingOptions(options, state.imageInterpolationQuality), state.alpha, Cairo::ShadowState(state)));

}

void CairoOperationRecorder::drawPattern(Image& image, const FloatRect& destRect, const FloatRect& tileRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize& spacing, const ImagePaintingOptions& options)

@@void CairoOperationRecorder::drawPattern(Image& image, const FloatRect& destRect

    UNUSED_PARAM(spacing);

    if (auto surface = image.nativeImageForCurrentFrame())

597 append(createCommand<DrawPattern>(WTFMove(surface), IntSize(image.size()), destRect, tileRect, patternTransform, phase, options));

603 append(createCommand<DrawPattern>(WTFMove(surface->platformImage()), IntSize(image.size()), destRect, tileRect, patternTransform, phase, options));

}

void CairoOperationRecorder::drawRect(const FloatRect& rect, float borderThickness)

@@void CairoOperationRecorder::clipToImageBuffer(ImageBuffer& buffer, const FloatR

        return;

    if (auto surface = image->nativeImageForCurrentFrame())

1082 append(createCommand<ClipToImageBuffer>(RefPtr<cairo_surface_t>(surface.get()), destRect));

1088 append(createCommand<ClipToImageBuffer>(RefPtr<cairo_surface_t>(surface->platformImage().get()), destRect));

}

void CairoOperationRecorder::applyDeviceScaleFactor(float)

Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h

@@private:

    WebCore::ImageDrawResult drawTiledImage(WebCore::Image&, const WebCore::FloatRect&, const WebCore::FloatRect&, const WebCore::FloatSize&, WebCore::Image::TileRule, WebCore::Image::TileRule, const WebCore::ImagePaintingOptions&) override;

    bool drawImageBuffer(WebCore::ImageBuffer&, const WebCore::FloatRect& destination, const WebCore::FloatRect& source, const WebCore::ImagePaintingOptions&) override;

72 void drawNativeImage(const WebCore::NativeImagePtr&, const WebCore::FloatSize&, const WebCore::FloatRect&, const WebCore::FloatRect&, const WebCore::ImagePaintingOptions&) override;

72 bool drawNativeImage(WebCore::NativeImage&, const WebCore::FloatSize& selfSize, const WebCore::FloatRect& destRect, const WebCore::FloatRect& srcRect, const WebCore::ImagePaintingOptions&) override;

73 void drawPlatformImage(const WebCore::PlatformImagePtr&, const WebCore::FloatSize& selfSize, const WebCore::FloatRect& destRect, const WebCore::FloatRect& srcRect, const WebCore::ImagePaintingOptions&) override;

    void drawPattern(WebCore::Image&, const WebCore::FloatRect&, const WebCore::FloatRect&, const WebCore::AffineTransform&, const WebCore::FloatPoint&, const WebCore::FloatSize&, const WebCore::ImagePaintingOptions&) override;

    void drawRect(const WebCore::FloatRect&, float) override;

Source/WebCore/platform/graphics/texmap/BitmapTextureGL.cpp

@@void BitmapTextureGL::updateContents(Image* image, const IntRect& targetRect, co

{

    if (!image)

        return;

154 Na~~tiveImagePtr~~ frameImage = image->nativeImageForCurrentFrame();

154 auto frameImage = image->nativeImageForCurrentFrame();

    if (!frameImage)

        return;

@@void BitmapTextureGL::updateContents(Image* image, const IntRect& targetRect, co

    const char* imageData;

#if USE(CAIRO)

162 cairo_surface_t* surface = frameImage.get();

162 cairo_surface_t* surface = frameImage->platformImage().get();

    imageData = reinterpret_cast<const char*>(cairo_image_surface_get_data(surface));

    bytesPerLine = cairo_image_surface_get_stride(surface);

#elif USE(DIRECT2D)

Source/WebCore/platform/graphics/texmap/GraphicsLayerTextureMapper.cpp

@@Ref<GraphicsLayer> GraphicsLayer::create(GraphicsLayerFactory* factory, Graphics

GraphicsLayerTextureMapper::GraphicsLayerTextureMapper(Type layerType, GraphicsLayerClient& client)

    : GraphicsLayer(layerType, client)

42 , m_compositedNativeImagePtr(0)

    , m_changeMask(NoChanges)

    , m_needsDisplay(false)

    , m_debugBorderWidth(0)

@@void GraphicsLayerTextureMapper::setContentsToImage(Image* image)

{

    if (image) {

        // Make the decision about whether the image has changed.

297 // This code makes the assumption that pointer equality on a N~~ative~~ImagePtr is a valid way to tell if the image is changed.

296 // This code makes the assumption that pointer equality on a PlatformImagePtr is a valid way to tell if the image is changed.

298297 // This assumption is true for the GTK+ port.

299 Na~~tiveImagePtr~~ newNativeImage~~Ptr~~ = image->nativeImageForCurrentFrame();

300 if (!newNativeImage~~Ptr~~)

298 auto newNativeImage = image->nativeImageForCurrentFrame();

299 if (!newNativeImage)

301300 return;

302301

303 if (newNativeImage~~Ptr~~ == m_compositedNativeImage~~Ptr~~)

302 if (newNativeImage == m_compositedNativeImage)

304303 return;

305304

306 m_compositedNativeImage~~Ptr~~ = newNativeImage~~Ptr~~;

305 m_compositedNativeImage = newNativeImage;

        if (!m_compositedImage)

            m_compositedImage = TextureMapperTiledBackingStore::create();

        m_compositedImage->setContentsToImage(image);

        m_compositedImage->updateContentsScale(pageScaleFactor() * deviceScaleFactor());

    } else {

312 m_compositedNativeImage~~Ptr~~ = nullptr;

311 m_compositedNativeImage = nullptr;

        m_compositedImage = nullptr;

    }

Source/WebCore/platform/graphics/texmap/GraphicsLayerTextureMapper.h

#include "GraphicsLayer.h"

#include "GraphicsLayerClient.h"

#include "Image.h"

28#include "NativeImage.h"

#include "TextureMapperLayer.h"

#include "TextureMapperPlatformLayer.h"

#include "TextureMapperTiledBackingStore.h"

@@private:

    TextureMapperLayer m_layer;

    std::unique_ptr<TextureMapperLayer> m_backdropLayer;

    RefPtr<TextureMapperTiledBackingStore> m_compositedImage;

158 NativeImage~~Ptr~~ m_compositedNativeImage~~Ptr~~;

159 RefPtr<NativeImage> m_compositedNativeImage;

    RefPtr<TextureMapperTiledBackingStore> m_backingStore;

    int m_changeMask;

Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.cpp

@@CoordinatedGraphicsLayer::CoordinatedGraphicsLayer(Type layerType, GraphicsLayer

    , m_pendingVisibleRectAdjustment(false)

    , m_shouldUpdatePlatformLayer(false)

    , m_coordinator(0)

141 , m_compositedNativeImagePtr(0)

    , m_animationStartedTimer(*this, &CoordinatedGraphicsLayer::animationStartedTimerFired)

    , m_requestPendingTileCreationTimer(RunLoop::main(), this, &CoordinatedGraphicsLayer::requestPendingTileCreationTimerFired)

{

@@void CoordinatedGraphicsLayer::setShowRepaintCounter(bool show)

void CoordinatedGraphicsLayer::setContentsToImage(Image* image)

{

588 Na~~tiveImagePtr~~ nativeImage~~Ptr~~ = image ? image->nativeImageForCurrentFrame() : nullptr;

589 if (m_compositedImage == image && m_compositedNativeImage~~Ptr~~ == nativeImage~~Ptr~~)

587 auto nativeImage = image ? image->nativeImageForCurrentFrame() : nullptr;

588 if (m_compositedImage == image && m_compositedNativeImage == nativeImage)

        return;

    m_compositedImage = image;

593 m_compositedNativeImage~~Ptr~~ = nativeImage~~Ptr~~;

592 m_compositedNativeImage = nativeImage;

    GraphicsLayer::setContentsToImage(image);

    notifyFlushRequired();

@@void CoordinatedGraphicsLayer::flushCompositingStateForThisLayerOnly()

    m_nicosia.delta.animatedBackingStoreClientChanged = true;

    // Determine image backing presence according to the composited image source.

852 if (m_compositedNativeImage~~Ptr~~) {

851 if (m_compositedNativeImage) {

        ASSERT(m_compositedImage);

        auto& image = *m_compositedImage;

        uintptr_t imageID = reinterpret_cast<uintptr_t>(&image);

856 uintptr_t nativeImageID = reinterpret_cast<uintptr_t>(m_compositedNativeImagePtr.get());

855 uintptr_t nativeImageID = reinterpret_cast<uintptr_t>(m_compositedNativeImage->platformImage().get());

        // Respawn the ImageBacking object if the underlying image changed.

        if (m_nicosia.imageBacking) {

Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.h

@@private:

    } m_needsDisplay;

    RefPtr<Image> m_compositedImage;

226 NativeImage~~Ptr~~ m_compositedNativeImage~~Ptr~~;

226 RefPtr<NativeImage> m_compositedNativeImage;

    Timer m_animationStartedTimer;

    RunLoop::Timer<CoordinatedGraphicsLayer> m_requestPendingTileCreationTimer;

Source/WebCore/platform/graphics/win/GraphicsContextDirect2D.cpp

@@void GraphicsContext::restorePlatformState()

    Direct2D::restore(*platformContext());

}

210 void GraphicsContext::platform~~DrawNative~~Image(const COMPtr<ID2D1Bitmap>& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

210void GraphicsContext::drawPlatformImage(const COMPtr<ID2D1Bitmap>& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

{

    if (paintingDisabled())

        return;

    if (m_impl) {

        m_impl->drawPlatformImage(image, imageSize, destRect, srcRect, options);

        return;

    }

    ASSERT(hasPlatformContext());

    auto& state = this->state();

    Direct2D::drawNativeImage(*platformContext(), image.get(), imageSize, destRect, srcRect, options, state.alpha, Direct2D::ShadowState(state));

Source/WebCore/platform/graphics/win/GraphicsContextImplDirect2D.cpp

@@ImageDrawResult GraphicsContextImplDirect2D::drawTiledImage(Image& image, const

    return GraphicsContextImpl::drawTiledImageImpl(graphicsContext(), image, destination, source, tileScaleFactor, hRule, vRule, imagePaintingOptions);

}

286 void GraphicsContextImplDirect2D::drawNativeImage(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

void GraphicsContextImplDirect2D::drawNativeImage(const NativeImage& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

{

    drawPlatformImage(image.platformImage(), imageSize, destRect, srcRect, options);

}

void GraphicsContextImplDirect2D::drawPlatformImage(const PlatformImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

{

    auto& state = graphicsContext().state();

    Direct2D::drawNativeImage(m_platformContext, image.get(), imageSize, destRect, srcRect, options, state.alpha, Direct2D::ShadowState(state));

Source/WebCore/platform/graphics/win/GraphicsContextImplDirect2D.h

@@public:

    ImageDrawResult drawImage(Image&, const FloatRect&, const FloatRect&, const ImagePaintingOptions&) override;

    ImageDrawResult drawTiledImage(Image&, const FloatRect&, const FloatPoint&, const FloatSize&, const FloatSize&, const ImagePaintingOptions&) override;

    ImageDrawResult drawTiledImage(Image&, const FloatRect&, const FloatRect&, const FloatSize&, Image::TileRule, Image::TileRule, const ImagePaintingOptions&) override;

74 void drawNativeImage(const NativeImagePtr&, const FloatSize&, const FloatRect&, const FloatRect&, const ImagePaintingOptions&) override;

    
    bool drawImageBuffer(ImageBuffer&, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions&) override;

    bool drawNativeImage(NativeImage&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&) override;

    void drawPlatformImage(const PlatformImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&) override;

    void drawPattern(Image&, const FloatRect&, const FloatRect&, const AffineTransform&, const FloatPoint&, const FloatSize&, const ImagePaintingOptions&) override;

    void drawRect(const FloatRect&, float) override;

Source/WebCore/platform/graphics/win/ImageBufferDirect2DBackend.cpp

@@std::unique_ptr<ImageBufferDirect2DBackend> ImageBufferDirect2DBackend::create(c

    if (!bitmapContext)

        return;

67 N~~ative~~ImagePtr bitmap;

67 PlatformImagePtr bitmap;

    HRESULT hr = bitmapContext->GetBitmap(&bitmap);

    if (!SUCCEEDED(hr))

        return;

@@std::unique_ptr<ImageBufferDirect2DBackend> ImageBufferDirect2DBackend::create(c

    return ImageBufferDirect2DBackend::create(size, 1, ColorSpace::SRGB, nullptr);

}

93 ImageBufferDirect2DBackend::ImageBufferDirect2DBackend(const FloatSize& logicalSize, const IntSize& backendSize, float resolutionScale, ColorSpace colorSpace, std::unique_ptr<PlatformContextDirect2D>&& platformContext, std::unique_ptr<GraphicsContext>&& context, N~~ative~~ImagePtr&& bitmap)

93ImageBufferDirect2DBackend::ImageBufferDirect2DBackend(const FloatSize& logicalSize, const IntSize& backendSize, float resolutionScale, ColorSpace colorSpace, std::unique_ptr<PlatformContextDirect2D>&& platformContext, std::unique_ptr<GraphicsContext>&& context, PlatformImagePtr&& bitmap)

    : ImageBufferCGBackend(logicalSize, backendSize, resolutionScale, colorSpace)

    , m_platformContext(WTFMove(platformContext))

    , m_context(WTFMove(context))

@@void ImageBufferDirect2DBackend::flushContext()

    context().flush();

}

111 NativeImage~~Ptr~~ ImageBufferDirect2DBackend::copyNativeImage(BackingStoreCopy copyBehavior) const

111RefPtr<NativeImage> ImageBufferDirect2DBackend::copyNativeImage(BackingStoreCopy copyBehavior) const

{

    COMPtr<ID2D1BitmapRenderTarget> bitmapTarget;

    HRESULT hr = context().platformContext()->renderTarget()->QueryInterface(&bitmapTarget);

@@NativeImagePtr ImageBufferDirect2DBackend::copyNativeImage(BackingStoreCopy copy

}

136 return image;

136 return NativeImage::create(WTFMove(image));

137137}

138138

139 static N~~ative~~ImagePtr createCroppedImageIfNecessary(ID2D1BitmapRenderTarget* bitmapTarget, ID2D1Bitmap* image, const IntSize& bounds)

139static PlatformImagePtr createCroppedImageIfNecessary(ID2D1BitmapRenderTarget* bitmapTarget, ID2D1Bitmap* image, const IntSize& bounds)

{

    FloatSize imageSize = image ? nativeImageSize(image) : FloatSize();

@@static RefPtr<Image> createBitmapImageAfterScalingIfNeeded(ID2D1BitmapRenderTarg

RefPtr<Image> ImageBufferDirect2DBackend::copyImage(BackingStoreCopy copyBehavior, PreserveResolution preserveResolution) const

{

173 N~~ative~~ImagePtr image;

173 PlatformImagePtr image;

174174 if (m_resolutionScale == 1 || preserveResolution == PreserveResolution::Yes)

175 image = copyNativeImage(copyBehavior);

175 image = copyNativeImage(copyBehavior)->platformImage();

176176 else

177 image = copyNativeImage(DontCopyBackingStore);

177 image = copyNativeImage(DontCopyBackingStore)->platformImage();

    auto bitmapTarget = reinterpret_cast<ID2D1BitmapRenderTarget*>(context().platformContext());

    return createBitmapImageAfterScalingIfNeeded(bitmapTarget, WTFMove(image), internalSize(), resolutionScale(), preserveResolution);

@@RefPtr<Image> ImageBufferDirect2DBackend::sinkIntoImage(PreserveResolution prese

    if (!SUCCEEDED(hr))

        return nullptr;

190 N~~ative~~ImagePtr image = copyNativeImage(DontCopyBackingStore);

190 PlatformImagePtr image = copyNativeImage(DontCopyBackingStore)->platformImage();

    return createBitmapImageAfterScalingIfNeeded(bitmapTarget.get(), WTFMove(image), internalSize(), resolutionScale(), preserveResolution);

}

194 N~~ative~~ImagePtr ImageBufferDirect2DBackend::compatibleBitmap(ID2D1RenderTarget* renderTarget)

194PlatformImagePtr ImageBufferDirect2DBackend::compatibleBitmap(ID2D1RenderTarget* renderTarget)

{

    loadDataToBitmapIfNeeded();

Source/WebCore/platform/graphics/win/ImageBufferDirect2DBackend.h

@@public:

    GraphicsContext& context() const override;

    void flushContext() override;

45 NativeImage~~Ptr~~ copyNativeImage(BackingStoreCopy = CopyBackingStore) const override;

45 RefPtr<NativeImage> copyNativeImage(BackingStoreCopy = CopyBackingStore) const override;

    RefPtr<Image> copyImage(BackingStoreCopy, PreserveResolution) const override;

    RefPtr<Image> sinkIntoImage(PreserveResolution) override;

@@protected:

    std::unique_ptr<PlatformContextDirect2D> m_platformContext;

    std::unique_ptr<GraphicsContext> m_context;

62 N~~ative~~ImagePtr m_bitmap;

62 PlatformImagePtr m_bitmap;

};

} // namespace WebCore

Source/WebCore/platform/graphics/win/ImageCGWin.cpp

@@RefPtr<BitmapImage> BitmapImage::create(HBITMAP hBitmap)

    // The BitmapImage takes ownership of this.

    RetainPtr<CGImageRef> cgImage = adoptCF(CGBitmapContextCreateImage(bitmapContext.get()));

60 return ~~adoptRef(new~~ BitmapImage(WTFMove(cgImage)));

60 return BitmapImage::create(WTFMove(cgImage));

}

bool BitmapImage::getHBITMAPOfSize(HBITMAP bmp, const IntSize* size)

@@void BitmapImage::drawFrameMatchingSourceSize(GraphicsContext& ctxt, const Float

{

    size_t frames = frameCount();

    for (size_t i = 0; i < frames; ++i) {

94 ~~CGImageRef~~ image = frameImageAtIndex(i)~~.get()~~;

95 if (image && ~~CGImageGetHeight(~~image) == ~~static_cast<size_t>(~~srcSize~~.height()) && CGImageGetWidth(image) == static_cast<size_t>(srcSize.width())~~) {

94 auto image = frameImageAtIndex(i);

95 if (image && image->size() == srcSize) {

            size_t currentFrame = m_currentFrame;

            m_currentFrame = i;

            draw(ctxt, dstRect, FloatRect(0.0f, 0.0f, srcSize.width(), srcSize.height()), { compositeOp });

Source/WebCore/platform/graphics/win/ImageCairoWin.cpp

@@void BitmapImage::drawFrameMatchingSourceSize(GraphicsContext& ctxt, const Float

{

    size_t frames = frameCount();

    for (size_t i = 0; i < frames; ++i) {

96 auto ~~surf~~ace = frameImageAtIndex(i);

97 if (!su~~rfa~~ce)

96 auto nativeImage = frameImageAtIndex(i);

97 if (!nativeImage || nativeImage->size() != srcSize)

9898 continue;

9999

        if (cairo_image_surface_get_height(surface.get()) == static_cast<size_t>(srcSize.height()) && cairo_image_surface_get_width(surface.get()) == static_cast<size_t>(srcSize.width())) {

            size_t currentFrame = m_currentFrame;

            m_currentFrame = i;

            draw(ctxt, dstRect, FloatRect(0.0f, 0.0f, srcSize.width(), srcSize.height()), { compositeOp });

            m_currentFrame = currentFrame;

            return;

        }

        size_t currentFrame = m_currentFrame;

        m_currentFrame = i;

        draw(ctxt, dstRect, FloatRect(0.0f, 0.0f, srcSize.width(), srcSize.height()), { compositeOp });

        m_currentFrame = currentFrame;

        return;

    }

    // No image of the correct size was found, fallback to drawing the current frame

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

@@void ImageDecoderDirect2D::setTargetContext(ID2D1RenderTarget* renderTarget)

    m_renderTarget = renderTarget;

}

243 N~~ative~~ImagePtr ImageDecoderDirect2D::createFrameImageAtIndex(size_t index, SubsamplingLevel subsamplingLevel, const DecodingOptions&)

243PlatformImagePtr ImageDecoderDirect2D::createFrameImageAtIndex(size_t index, SubsamplingLevel subsamplingLevel, const DecodingOptions&)

{

    if (!m_nativeDecoder)

        return nullptr;

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

@@public:

    bool frameAllowSubsamplingAtIndex(size_t) const final;

    unsigned frameBytesAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default) const final;

73 N~~ative~~ImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, const DecodingOptions& = DecodingOptions(DecodingMode::Synchronous)) final;

73 PlatformImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, const DecodingOptions& = DecodingOptions(DecodingMode::Synchronous)) final;

    void setData(SharedBuffer&, bool allDataReceived) final;

    bool isAllDataReceived() const final { return m_isAllDataReceived; }

Source/WebCore/platform/graphics/win/NativeImageDirect2D.cpp

@@static IWICImagingFactory* imagingFactory()

    return imagingFactory;

}

53 IntSize ~~nativeImageSize(const~~ NativeImagePtr& image)

53IntSize NativeImage::size(const PlatformImagePtr& platformImage)

5454{

    UINT width = 0;

    UINT height = 0;

    if (!image)

        return { };

    return image->GetPixelSize();

55 return platformImage ? platformImage->GetPixelSize() : IntSize();

6156}

6257

63 bool ~~nativeImageHasAlpha(const~~ NativeImageP~~tr& image)~~

58bool NativeImage::hasAlpha() const

6459{

65 if (!image)

60 if (!m_platformImage)

6661 return false;

6762

68 D2D1_PIXEL_FORMAT pixelFormat = image->GetPixelFormat();

63 D2D1_PIXEL_FORMAT pixelFormat = m_platformImage->GetPixelFormat();

    return pixelFormat.alphaMode != D2D1_ALPHA_MODE_IGNORE;

}

72 Color nativeImageSinglePixelSolidColor(const ~~NativeImagePtr& image)~~

67Color NativeImage::singlePixelSolidColor() const

7368{

74 if (!image || ~~nativeImageS~~ize(~~image~~) != IntSize(1, 1))

69 if (!m_platformImage || size() != IntSize(1, 1))

        return Color();

    notImplemented();

78

    return Color();

}

void drawNativeImage(const NativeImagePtr& image, GraphicsContext& context, const FloatRect& destRect, const FloatRect& srcRect, const IntSize& srcSize, const ImagePaintingOptions& options)

{

    auto* platformContext = context.platformContext();

    // Subsampling may have given us an image that is smaller than size().

    IntSize subsampledImageSize = nativeImageSize(image);

    // srcRect is in the coordinates of the unsubsampled image, so we have to map it to the subsampled image.

    FloatRect adjustedSrcRect = srcRect;

    if (subsampledImageSize != srcSize)

        adjustedSrcRect = mapRect(srcRect, FloatRect({ }, srcSize), FloatRect({ }, subsampledImageSize));

    auto& state = context.state();

    Direct2D::drawNativeImage(*platformContext, image.get(), subsampledImageSize, destRect, adjustedSrcRect, options, state.alpha, Direct2D::ShadowState(state));

}

void clearNativeImageSubimages(const NativeImagePtr& image)

76void NativeImage::clearSubimages()

9977{

10078 notImplemented();

101

10279#if CACHE_SUBIMAGES

103 if (image)

104 subimageCache~~().~~clearImage(image.get());

80 if (m_platformImage)

81 SubimageCacheWithTimer::clearImage(m_platformImage.get());

#endif

}

108

10985}

Source/WebCore/platform/gtk/CursorGtk.cpp

@@static GRefPtr<GdkCursor> createCustomCursor(Image* image, const IntPoint& hotSp

    IntPoint effectiveHotSpot = determineHotSpot(image, hotSpot);

    return adoptGRef(gdk_cursor_new_from_texture(texture.get(), effectiveHotSpot.x(), effectiveHotSpot.y(), fallbackCursor().get()));

#else

66 R~~efPtr<cairo_surface_t> surfac~~e = image->nativeImageForCurrentFrame();

67 if (!s~~urface~~)

66 auto nativeImage = image->nativeImageForCurrentFrame();

67 if (!nativeImage || nativeImage->isNull())

6868 return nullptr;

6969

70 auto& surface = nativeImage->platformImage();

    IntPoint effectiveHotSpot = determineHotSpot(image, hotSpot);

    return adoptGRef(gdk_cursor_new_from_surface(gdk_display_get_default(), surface.get(), effectiveHotSpot.x(), effectiveHotSpot.y()));

#endif // USE(GTK4)

Source/WebCore/platform/gtk/DragImageGtk.cpp

@@DragImageRef dissolveDragImageToFraction(DragImageRef image, float fraction)

DragImageRef createDragImageFromImage(Image* image, ImageOrientation)

{

89 return image->nativeImageForCurrentFrame();

89 return image->nativeImageForCurrentFrame()->platformImage();

}

DragImageRef createDragImageIconForCachedImageFilename(const String&)

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

@@Seconds ScalableImageDecoder::frameDurationAtIndex(size_t index) const

    return duration;

}

207 N~~ative~~ImagePtr ScalableImageDecoder::createFrameImageAtIndex(size_t index, SubsamplingLevel, const DecodingOptions&)

207PlatformImagePtr ScalableImageDecoder::createFrameImageAtIndex(size_t index, SubsamplingLevel, const DecodingOptions&)

{

    LockHolder lockHolder(m_mutex);

    // Zero-height images can cause problems for some ports. If we have an empty image dimension, just bail.

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

@@public:

    Seconds frameDurationAtIndex(size_t) const final;

147 N~~ative~~ImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, const DecodingOptions& = DecodingOptions(DecodingMode::Synchronous)) override;

147 PlatformImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, const DecodingOptions& = DecodingOptions(DecodingMode::Synchronous)) override;

    void setIgnoreGammaAndColorProfile(bool flag) { m_ignoreGammaAndColorProfile = flag; }

    bool ignoresGammaAndColorProfile() const { return m_ignoreGammaAndColorProfile; }

Source/WebCore/platform/image-decoders/cairo/ImageBackingStoreCairo.cpp

namespace WebCore {

33 N~~ative~~ImagePtr ImageBackingStore::image() const

33PlatformImagePtr ImageBackingStore::image() const

{

    m_pixels->ref();

    RefPtr<cairo_surface_t> surface = adoptRef(cairo_image_surface_create_for_data(

Source/WebCore/platform/mediastream/mac/DisplayCaptureSourceCocoa.cpp

@@void DisplayCaptureSourceCocoa::emitFrame()

            return IntSize(IOSurfaceGetWidth(surface.get()), IOSurfaceGetHeight(surface.get()));

        },

242 [](Re~~tain~~Ptr<CGImage~~Ref~~> image) -> IntSize {

242 [](RefPtr<NativeImage> image) -> IntSize {

            if (!image)

                return { };

246 return ~~IntSize(CGImageGetWidth(~~image.get~~()), CGImageGetHeight(image.get()))~~;

246 return image->size();

        }

    );

@@void DisplayCaptureSourceCocoa::emitFrame()

            return m_imageTransferSession->createMediaSample(surface.get(), sampleTime, size());

        },

266 [this, sampleTime](Re~~tain~~Ptr<CGImage~~Ref~~> image) -> RefPtr<MediaSample> {

266 [this, sampleTime](RefPtr<NativeImage> image) -> RefPtr<MediaSample> {

            if (!image)

                return nullptr;

270 return m_imageTransferSession->createMediaSample(image.get(), sampleTime, size());

270 return m_imageTransferSession->createMediaSample(image->platformImage().get(), sampleTime, size());

        }

    );

Source/WebCore/platform/mediastream/mac/DisplayCaptureSourceCocoa.h

@@class PixelBufferConformerCV;

class DisplayCaptureSourceCocoa final : public RealtimeMediaSource {

public:

55 using DisplayFrameType = WTF::Variant<Re~~tain~~Ptr<CGImage~~Ref~~>, RetainPtr<IOSurfaceRef>>;

55 using DisplayFrameType = WTF::Variant<RefPtr<NativeImage>, RetainPtr<IOSurfaceRef>>;

    class Capturer

#if !RELEASE_LOG_DISABLED

        : public LoggerHelper

Source/WebCore/platform/mediastream/mac/MockRealtimeVideoSourceMac.mm

@@void MockRealtimeVideoSourceMac::updateSampleBuffer()

    if (!m_imageTransferSession)

        m_imageTransferSession = ImageTransferSessionVT::create(preferedPixelBufferFormat());

    PlatformImagePtr platformImage;

    if (auto nativeImage = imageBuffer->copyImage()->nativeImage())

        platformImage = nativeImage->platformImage();

9498 auto sampleTime = MediaTime::createWithDouble((elapsedTime() + 100_ms).seconds());

95 auto sampleBuffer = m_imageTransferSession->createMediaSample(i~~mageBuffer->copy~~Image~~()->nativeImage()~~.get(), sampleTime, size(), sampleRotation());

99 auto sampleBuffer = m_imageTransferSession->createMediaSample(platformImage.get(), sampleTime, size(), sampleRotation());

    if (!sampleBuffer)

        return;

Source/WebCore/platform/win/DragImageCGWin.cpp

@@DragImageRef createDragImageFromImage(Image* img, ImageOrientation)

    CGContextSetFillColor(drawContext, white);

    CGContextFillRect(drawContext, rect);

    if (auto srcImage = img->nativeImage()) {

142 CGContextSetBlendMode(drawContext, kCGBlendModeNormal);

143 CGContextDrawImage(drawContext, rect, srcImage.get());

        if (auto platformImage = srcImage->platformImage()) {

            CGContextSetBlendMode(drawContext, kCGBlendModeNormal);

            CGContextDrawImage(drawContext, rect, platformImage.get());

        }

    }

    CGContextRelease(drawContext);

Source/WebCore/platform/win/DragImageCairoWin.cpp

@@DragImageRef createDragImageFromImage(Image* img, ImageOrientation)

    cairo_set_source_rgb(cr, 1.0, 0.0, 1.0);

    cairo_fill_preserve(cr);

165 RefPtr<cairo_surface_t> surface = img->nativeImageForCurrentFrame();

166 if (surface) {

    auto nativeImage = img->nativeImageForCurrentFrame();

    if (nativeImage && !nativeImage->isNull()) {

        auto& surface = nativeImage->platformImage();

        // Draw the image.

        cairo_set_source_surface(cr, surface.get(), 0.0, 0.0);

        cairo_paint(cr);

Source/WebCore/rendering/RenderThemeIOS.mm

@@void RenderThemeIOS::paintSystemPreviewBadge(Image& image, const PaintInfo& pain

    CGRect insetBadgeRect = CGRectMake(rect.width() - badgeDimension - badgeOffset, badgeOffset, badgeDimension, badgeDimension);

    CGRect badgeRect = CGRectMake(0, 0, badgeDimension, badgeDimension);

1843 CIImage *inputImage = [CIImage imageWithCGImage:image.nativeImage().get()];

1843 CIImage *inputImage = [CIImage imageWithCGImage:image.nativeImage()->platformImage().get()];

    // Create a circle to be used for the clipping path in the badge, as well as the drop shadow.

    RetainPtr<CGPathRef> circle = adoptCF(CGPathCreateWithRoundedRect(absoluteBadgeRect, badgeDimension / 2, badgeDimension / 2, nullptr));

Source/WebCore/svg/graphics/SVGImage.cpp

@@ImageDrawResult SVGImage::drawForContainer(GraphicsContext& context, const Float

}

#if USE(CAIRO)

212 // Passes ownership of the native image to the caller so NativeImage~~Ptr~~ needs

212// Passes ownership of the native image to the caller so NativeImage needs

213213// to be a smart pointer type.

214 NativeImage~~Ptr~~ SVGImage::nativeImageForCurrentFrame(const GraphicsContext*)

214RefPtr<NativeImage> SVGImage::nativeImageForCurrentFrame(const GraphicsContext*)

{

    if (!m_page)

        return nullptr;

@@NativeImagePtr SVGImage::nativeImageForCurrentFrame(const GraphicsContext*)

#endif

#if USE(DIRECT2D)

232 NativeImage~~Ptr~~ SVGImage::nativeImage(const GraphicsContext* targetContext)

232RefPtr<NativeImage> SVGImage::nativeImage(const GraphicsContext* targetContext)

{

    ASSERT(targetContext);

    if (!m_page || !targetContext)

Source/WebCore/svg/graphics/SVGImage.h

@@public:

    void scheduleStartAnimation();

#if USE(CAIRO)

66 NativeImage~~Ptr~~ nativeImageForCurrentFrame(const GraphicsContext* = nullptr) final;

66 RefPtr<NativeImage> nativeImageForCurrentFrame(const GraphicsContext* = nullptr) final;

6767#endif

6868#if USE(DIRECT2D)

69 NativeImage~~Ptr~~ nativeImage(const GraphicsContext* = nullptr) final;

69 RefPtr<NativeImage> nativeImage(const GraphicsContext* = nullptr) final;

#endif

    Page* internalPage() { return m_page.get(); }

Source/WebCore/svg/graphics/SVGImageForContainer.cpp

@@void SVGImageForContainer::drawPattern(GraphicsContext& context, const FloatRect

    m_image->drawPatternForContainer(context, m_containerSize, m_containerZoom, m_initialFragmentURL, srcRect, patternTransform, phase, spacing, dstRect, options);

}

48 NativeImage~~Ptr~~ SVGImageForContainer::nativeImageForCurrentFrame(const GraphicsContext* targetContext)

48RefPtr<NativeImage> SVGImageForContainer::nativeImageForCurrentFrame(const GraphicsContext* targetContext)

{

    return m_image->nativeImageForCurrentFrame(targetContext);

}

Source/WebCore/svg/graphics/SVGImageForContainer.h

@@public:

    // FIXME: Implement this to be less conservative.

    bool currentFrameKnownToBeOpaque() const final { return false; }

63 NativeImage~~Ptr~~ nativeImageForCurrentFrame(const GraphicsContext* = nullptr) final;

63 RefPtr<NativeImage> nativeImageForCurrentFrame(const GraphicsContext* = nullptr) final;

private:

    SVGImageForContainer(SVGImage* image, const FloatSize& containerSize, float containerZoom, const URL& initialFragmentURL)

Source/WebKit/Scripts/webkit/messages.py

@@def types_that_cannot_be_forward_declared():

        'WebCore::PlaybackTargetClientContextIdentifier',

        'WebCore::MediaPlayerIdentifier',

        'WebCore::MediaSessionIdentifier',

220 'WebCore::N~~ative~~ImagePtr',

220 'WebCore::PlatformImagePtr',

        'WebCore::PageIdentifier',

        'WebCore::PluginLoadClientPolicy',

        'WebCore::PointerID',

Source/WebKit/Shared/API/c/cg/WKImageCG.cpp

@@WKImageRef WKImageCreateFromCGImage(CGImageRef imageRef, WKImageOptions options)

    WebCore::FloatRect rect(WebCore::FloatPoint(0, 0), imageSize);

    graphicsContext->clearRect(rect);

58 graphicsContext->drawN~~ative~~Image(imageRef, imageSize, rect, rect);

58 graphicsContext->drawPlatformImage(imageRef, imageSize, rect, rect);

    return toAPI(webImage.leakRef());

}

Source/WebKit/Shared/WebCoreArgumentCoders.cpp

@@bool ArgumentCoder<ImageHandle>::decode(Decoder& decoder, ImageHandle& imageHand

    return true;

}

1103 static void encodeN~~ative~~Image(Encoder& encoder, const N~~ative~~ImagePtr& image)

1103static void encodePlatformImage(Encoder& encoder, const PlatformImagePtr& platformImage)

11041104{

1105 auto imageSize = nativeImageSize(image);

1105 auto imageSize = NativeImage::size(platformImage);

    auto bitmap = ShareableBitmap::createShareable(imageSize, { });

    auto graphicsContext = bitmap->createGraphicsContext();

    encoder << !!graphicsContext;

    if (!graphicsContext)

        return;

1112 graphicsContext->drawN~~ative~~Image(image, imageSize, FloatRect({ }, imageSize), FloatRect({ }, imageSize));

1112 graphicsContext->drawPlatformImage(platformImage, imageSize, FloatRect({ }, imageSize), FloatRect({ }, imageSize));

    ShareableBitmap::Handle handle;

    bitmap->createHandle(handle);

@@static void encodeNativeImage(Encoder& encoder, const NativeImagePtr& image)

    encoder << handle;

}

1120 static WARN_UNUSED_RETURN bool decodeN~~ative~~Image(Decoder& decoder, N~~ative~~ImagePtr& n~~ative~~Image)

1120static WARN_UNUSED_RETURN bool decodePlatformImage(Decoder& decoder, PlatformImagePtr& platformImage)

{

    Optional<bool> didCreateGraphicsContext;

    decoder >> didCreateGraphicsContext;

@@static WARN_UNUSED_RETURN bool decodeNativeImage(Decoder& decoder, NativeImagePt

    if (!image)

        return false;

1139 n~~ative~~Image = image->nativeImage();

1140 if (!n~~ative~~Image)

1139 platformImage = image->nativeImage()->platformImage();

1140 if (!platformImage)

        return false;

    return true;

}

1146 static void encodeOptionalN~~ative~~Image(Encoder& encoder, const N~~ative~~ImagePtr& image)

1146static void encodeOptionalPlatformImage(Encoder& encoder, const PlatformImagePtr& platformImage)

11471147{

1148 bool hasImage = !!image;

1148 bool hasImage = !!platformImage;

    encoder << hasImage;

    if (hasImage)

1152 encodeN~~ative~~Image(encoder, image);

1152 encodePlatformImage(encoder, platformImage);

11531153}

11541154

1155 static WARN_UNUSED_RETURN bool decodeOptionalN~~ative~~Image(Decoder& decoder, N~~ative~~ImagePtr& image)

1155static WARN_UNUSED_RETURN bool decodeOptionalPlatformImage(Decoder& decoder, PlatformImagePtr& platformImage)

11561156{

1157 image = nullptr;

1157 platformImage = nullptr;

    bool hasImage;

    if (!decoder.decode(hasImage))

@@static WARN_UNUSED_RETURN bool decodeOptionalNativeImage(Decoder& decoder, Nativ

    if (!hasImage)

        return true;

1166 return decodeN~~ative~~Image(decoder, image);

1166 return decodePlatformImage(decoder, platformImage);

11671167}

11681168

1169 void ArgumentCoder<N~~ative~~ImagePtr>::encode(Encoder& encoder, const N~~ative~~ImagePtr& image)

1169void ArgumentCoder<PlatformImagePtr>::encode(Encoder& encoder, const PlatformImagePtr& platformImage)

11701170{

1171 encodeOptionalN~~ative~~Image(encoder, image);

1171 encodeOptionalPlatformImage(encoder, platformImage);

11721172}

11731173

1174 bool ArgumentCoder<N~~ative~~ImagePtr>::decode(Decoder& decoder, N~~ative~~ImagePtr& image)

1174bool ArgumentCoder<PlatformImagePtr>::decode(Decoder& decoder, PlatformImagePtr& platformImage)

11751175{

1176 return decodeOptionalN~~ative~~Image(decoder, image);

1176 return decodeOptionalPlatformImage(decoder, platformImage);

}

void ArgumentCoder<Ref<Font>>::encode(Encoder& encoder, const Ref<WebCore::Font>& font)

Source/WebKit/Shared/WebCoreArgumentCoders.h

#include <WebCore/IndexedDB.h>

#include <WebCore/InputMode.h>

#include <WebCore/MediaSelectionOption.h>

37 #include <WebCore/NativeImage~~Ptr~~.h>

37#include <WebCore/NativeImage.h>

#include <WebCore/NetworkLoadMetrics.h>

#include <WebCore/NotificationDirection.h>

#include <WebCore/RealtimeMediaSource.h>

@@template<> struct ArgumentCoder<WebCore::ImageHandle> {

    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::ImageHandle&);

};

template<> struct ArgumentCoder<WebCore::NativeImagePtr> {

    static void encode(Encoder&, const WebCore::NativeImagePtr&);

    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::NativeImagePtr&);

template<> struct ArgumentCoder<WebCore::PlatformImagePtr> {

    static void encode(Encoder&, const WebCore::PlatformImagePtr&);

    static WARN_UNUSED_RETURN bool decode(Decoder&, WebCore::PlatformImagePtr&);

};

template<> struct ArgumentCoder<WebCore::ResourceRequest> {

Source/WebKit/Shared/cg/ShareableBitmapCG.cpp

@@void ShareableBitmap::releaseDataProviderData(void* typelessBitmap, const void*

RefPtr<Image> ShareableBitmap::createImage()

{

    RetainPtr<CGImageRef> platformImage = makeCGImage();

    if (!platformImage)

        return nullptr;

    return BitmapImage::create(WTFMove(platformImage));

    if (auto platformImage = makeCGImage())

        return BitmapImage::create(WTFMove(platformImage));

    return nullptr;

}

} // namespace WebKit

Source/WebKit/UIProcess/API/glib/IconDatabase.cpp

@@void IconDatabase::checkIconURLAndSetPageURLIfNeeded(const String& iconURL, cons

    });

}

546 void IconDatabase::loadIconForPageURL(const String& pageURL, AllowDatabaseWrite allowDatabaseWrite, CompletionHandler<void(N~~ative~~ImagePtr&&)>&& completionHandler)

546void IconDatabase::loadIconForPageURL(const String& pageURL, AllowDatabaseWrite allowDatabaseWrite, CompletionHandler<void(PlatformImagePtr&&)>&& completionHandler)

{

    ASSERT(isMainThread());

@@void IconDatabase::loadIconForPageURL(const String& pageURL, AllowDatabaseWrite

                LockHolder lockHolder(m_loadedIconsLock);

                if (!m_loadedIcons.contains(iconURL)) {

                    iconData = this->iconData(iconID.value());

565 m_loadedIcons.set(iconURL, std::make_pair<N~~ative~~ImagePtr, MonotonicTime>(nullptr, { }));

565 m_loadedIcons.set(iconURL, std::make_pair<PlatformImagePtr, MonotonicTime>(nullptr, { }));

                }

            }

            bool canWriteToDatabase = m_allowDatabaseWrite == AllowDatabaseWrite::Yes && allowDatabaseWrite == AllowDatabaseWrite::Yes;

@@void IconDatabase::loadIconForPageURL(const String& pageURL, AllowDatabaseWrite

                return;

            }

590 auto addResult = m_loadedIcons.set(iconURL, std::make_pair<N~~ative~~ImagePtr, MonotonicTime>(nullptr, MonotonicTime::now()));

590 auto addResult = m_loadedIcons.set(iconURL, std::make_pair<PlatformImagePtr, MonotonicTime>(nullptr, MonotonicTime::now()));

            if (!iconData.isEmpty()) {

                auto image = BitmapImage::create();

                if (image->setData(SharedBuffer::create(WTFMove(iconData)), true) < EncodedDataStatus::SizeAvailable) {

                    completionHandler(nullptr);

                    return;

                }

597 addResult.iterator->value.first = image->nativeImageForCurrentFrame();

597 addResult.iterator->value.first = image->nativeImageForCurrentFrame()->platformImage();

            }

            auto icon = addResult.iterator->value.first;

@@void IconDatabase::setIconForPageURL(const String& iconURL, const unsigned char*

        bool result = true;

        {

            LockHolder lockHolder(m_loadedIconsLock);

625 auto addResult = m_loadedIcons.set(iconURL, std::make_pair<N~~ative~~ImagePtr, MonotonicTime>(nullptr, { }));

625 auto addResult = m_loadedIcons.set(iconURL, std::make_pair<PlatformImagePtr, MonotonicTime>(nullptr, { }));

            if (iconDataSize) {

                auto image = BitmapImage::create();

                if (image->setData(SharedBuffer::create(iconData, iconDataSize), true) < EncodedDataStatus::SizeAvailable)

                    result = false;

                else

631 addResult.iterator->value.first = image->nativeImageForCurrentFrame();

631 addResult.iterator->value.first = image->nativeImageForCurrentFrame()->platformImage();

            }

        }

        startClearLoadedIconsTimer();

Source/WebKit/UIProcess/API/glib/IconDatabase.h

@@public:

    void invalidate();

    void checkIconURLAndSetPageURLIfNeeded(const String& iconURL, const String& pageURL, AllowDatabaseWrite, CompletionHandler<void(bool, bool)>&&);

47 void loadIconForPageURL(const String&, AllowDatabaseWrite, CompletionHandler<void(WebCore::N~~ative~~ImagePtr&&)>&&);

47 void loadIconForPageURL(const String&, AllowDatabaseWrite, CompletionHandler<void(WebCore::PlatformImagePtr&&)>&&);

    String iconURLForPageURL(const String&);

    void setIconForPageURL(const String& iconURL, const unsigned char*, size_t, const String& pageURL, AllowDatabaseWrite, CompletionHandler<void(bool)>&&);

    void clear(CompletionHandler<void()>&&);

@@private:

    WebCore::SQLiteDatabase m_db;

    HashMap<String, String> m_pageURLToIconURLMap;

    Lock m_pageURLToIconURLMapLock;

74 HashMap<String, std::pair<WebCore::N~~ative~~ImagePtr, MonotonicTime>> m_loadedIcons;

74 HashMap<String, std::pair<WebCore::PlatformImagePtr, MonotonicTime>> m_loadedIcons;

    Lock m_loadedIconsLock;

    std::unique_ptr<WebCore::SQLiteStatement> m_iconIDForIconURLStatement;

Source/WebKit/UIProcess/ios/DragDropInteractionState.mm

@@static RetainPtr<UIImage> uiImageForImage(Image* image)

    if (!image)

        return nullptr;

89 auto cgImage = image->nativeImage();

90 if (!cgImage)

89 auto nativeImage = image->nativeImage();

90 if (!nativeImage || nativeImage->isNull())

9191 return nullptr;

9292

93 return adoptNS([[UIImage alloc] initWithCGImage:cgImage.get()]);

93 return adoptNS([[UIImage alloc] initWithCGImage:nativeImage->platformImage().get()]);

}

static bool shouldUseDragImageToCreatePreviewForDragSource(const DragSourceState& source)

Source/WebKit/UIProcess/ios/WKContentViewInteraction.mm

@@static NSArray<NSItemProvider *> *extractItemProvidersFromDropSession(id <UIDrop

        return;

    auto unselectedSnapshotImage = snapshotWithoutSelection->nativeImage();

7506 if (!unselectedSnapshotImage)

7506 if (!unselectedSnapshotImage || unselectedSnapshotImage->isNull())

        return;

    if (!_dropAnimationCount)

        return;

7512 auto unselectedContentImageForEditDrag = adoptNS([[UIImage alloc] initWithCGImage:unselectedSnapshotImage.get() scale:_page->deviceScaleFactor() orientation:UIImageOrientationUp]);

7512 auto unselectedContentImageForEditDrag = adoptNS([[UIImage alloc] initWithCGImage:unselectedSnapshotImage->platformImage().get() scale:_page->deviceScaleFactor() orientation:UIImageOrientationUp]);

    _unselectedContentSnapshot = adoptNS([[UIImageView alloc] initWithImage:unselectedContentImageForEditDrag.get()]);

    [_unselectedContentSnapshot setFrame:data->contentImageWithoutSelectionRectInRootViewCoordinates];

@@static RetainPtr<UIImage> uiImageForImage(WebCore::Image* image)

    if (!image)

        return nil;

7735 auto cgImage = image->nativeImage();

7736 if (!cgImage)

7735 auto nativeImage = image->nativeImage();

7736 if (!nativeImage || nativeImage->isNull())

77377737 return nil;

77387738

7739 return adoptNS([[UIImage alloc] initWithCGImage:cgImage.get()]);

7739 return adoptNS([[UIImage alloc] initWithCGImage:nativeImage->platformImage().get()]);

}

// FIXME: This should be merged with createTargetedDragPreview in DragDropInteractionState.

@@static Vector<WebCore::IntSize> sizesOfPlaceholderElementsToInsertWhenDroppingIt

        }

        auto unselectedSnapshotImage = snapshotWithoutSelection->nativeImage();

7994 if (!unselectedSnapshotImage) {

7994 if (!unselectedSnapshotImage || unselectedSnapshotImage->isNull()) {

            RELEASE_LOG(DragAndDrop, "Failed to animate image placeholders: could not decode unselected content image.");

            state.clearAllDelayedItemPreviewProviders();

            return;

        }

8000 auto unselectedContentImageForEditDrag = adoptNS([[UIImage alloc] initWithCGImage:unselectedSnapshotImage.get() scale:protectedSelf->_page->deviceScaleFactor() orientation:UIImageOrientationUp]);

8000 auto unselectedContentImageForEditDrag = adoptNS([[UIImage alloc] initWithCGImage:unselectedSnapshotImage->platformImage().get() scale:protectedSelf->_page->deviceScaleFactor() orientation:UIImageOrientationUp]);

        auto snapshotView = adoptNS([[UIImageView alloc] initWithImage:unselectedContentImageForEditDrag.get()]);

        [snapshotView setFrame:data->contentImageWithoutSelectionRectInRootViewCoordinates];

        [protectedSelf addSubview:snapshotView.get()];

@@static UIMenu *menuFromLegacyPreviewOrDefaultActions(UIViewController *previewVi

{

    if (!_positionInformation.linkIndicator.contentImage)

        return nullptr;

10044 return [[[UIImage alloc] initWithCGImage:_positionInformation.linkIndicator.contentImage->nativeImage().get()] autorelease];

    
    auto nativeImage = _positionInformation.linkIndicator.contentImage->nativeImage();

    if (!nativeImage || nativeImage->isNull())

        return nullptr;

    return [[[UIImage alloc] initWithCGImage:nativeImage->platformImage().get()] autorelease];

}

- (NSArray *)_presentationRectsForPreviewItemController:(UIPreviewItemController *)controller

Source/WebKit/WebProcess/GPU/graphics/ImageBufferShareableBitmapBackend.cpp

@@ImageBufferBackendHandle ImageBufferShareableBitmapBackend::createImageBufferBac

    return ImageBufferBackendHandle(WTFMove(handle));

}

99 NativeImage~~Ptr~~ ImageBufferShareableBitmapBackend::copyNativeImage(BackingStoreCopy) const

99RefPtr<NativeImage> ImageBufferShareableBitmapBackend::copyNativeImage(BackingStoreCopy) const

100100{

101101#if USE(CG)

102 return m_bitmap->makeCGImageCopy();

102 return NativeImage::create(m_bitmap->makeCGImageCopy());

#elif USE(DIRECT2D)

    return nullptr;

#elif USE(CAIRO)

106 return m_bitmap->createCairoSurface();

106 return NativeImage::create(m_bitmap->createCairoSurface());

#endif

}

Source/WebKit/WebProcess/GPU/graphics/ImageBufferShareableBitmapBackend.h

@@public:

    WebCore::GraphicsContext& context() const override { return *m_context; }

55 WebCore::NativeImage~~Ptr~~ copyNativeImage(WebCore::BackingStoreCopy = WebCore::CopyBackingStore) const override;

55 RefPtr<WebCore::NativeImage> copyNativeImage(WebCore::BackingStoreCopy = WebCore::CopyBackingStore) const override;

    RefPtr<WebCore::Image> copyImage(WebCore::BackingStoreCopy = WebCore::CopyBackingStore, WebCore::PreserveResolution = WebCore::PreserveResolution::No) const override;

    Vector<uint8_t> toBGRAData() const override;

Source/WebKit/WebProcess/GPU/media/MediaPlayerPrivateRemote.cpp

@@bool MediaPlayerPrivateRemote::copyVideoTextureToPlatformTexture(GraphicsContext

    return false;

}

814 NativeImage~~Ptr~~ MediaPlayerPrivateRemote::nativeImageForCurrentTime()

814RefPtr<NativeImage> MediaPlayerPrivateRemote::nativeImageForCurrentTime()

{

    notImplemented();

    return nullptr;

Source/WebKit/WebProcess/GPU/media/MediaPlayerPrivateRemote.h

@@private:

    void paint(WebCore::GraphicsContext&, const WebCore::FloatRect&) final;

    void paintCurrentFrameInContext(WebCore::GraphicsContext&, const WebCore::FloatRect&) final;

    bool copyVideoTextureToPlatformTexture(WebCore::GraphicsContextGLOpenGL*, PlatformGLObject, GCGLenum, GCGLint, GCGLenum, GCGLenum, GCGLenum, bool, bool) final;

266 WebCore::NativeImage~~Ptr~~ nativeImageForCurrentTime() final;

266 RefPtr<WebCore::NativeImage> nativeImageForCurrentTime() final;

    WebCore::MediaPlayerIdentifier identifier() const final;

Source/WebKit/WebProcess/Plugins/PluginView.cpp

@@void PluginView::didFailLoad(WebFrame* webFrame, bool wasCancelled)

#if PLATFORM(COCOA)

static bool isAlmostSolidColor(BitmapImage* bitmap)

{

1686 CGImageRef image = bitmap->nativeImage().get();

1686 CGImageRef image = bitmap->nativeImage()->platformImage().get();

    ASSERT(CGImageGetBitsPerComponent(image) == 8);

    CGBitmapInfo imageInfo = CGImageGetBitmapInfo(image);

Source/WebKitLegacy/mac/DOM/DOM.mm

@@id <DOMEventTarget> kit(EventTarget* target)

    if (textIndicator) {

        if (Image* image = textIndicator->contentImage())

539 *cgImage = image->nativeImage().autorelease();

539 *cgImage = image->nativeImage()->platformImage().autorelease();

    }

    if (!*cgImage) {

Source/WebKitLegacy/mac/Misc/WebCache.mm

@@class DefaultStorageSessionProvider : public WebCore::StorageSessionProvider {

    WebCore::CachedResource* cachedResource = WebCore::MemoryCache::singleton().resourceForRequest(request, PAL::SessionID::defaultSessionID());

    if (!is<WebCore::CachedImage>(cachedResource))

        return nullptr;

174 WebCore::CachedImage& cachedImage = downcast<WebCore::CachedImage>(*cachedResource);

174

175 auto& cachedImage = downcast<WebCore::CachedImage>(*cachedResource);

175176 if (!cachedImage.hasImage())

176177 return nullptr;

177 return cachedImage.image()->nativeImage().get();

    
    auto nativeImage = cachedImage.image()->nativeImage();

    if (!nativeImage)

        return nullptr;

    return nativeImage->platformImage().get();

}

#endif // PLATFORM(IOS_FAMILY)

Source/WebKitLegacy/mac/WebView/WebView.mm

@@private:

    _textRectsInBoundingRectCoordinates = createNSArray(indicatorData.textRectsInBoundingRectCoordinates).leakRef();

    _contentImageScaleFactor = indicatorData.contentImageScaleFactor;

    if (indicatorData.contentImageWithHighlight)

848 _contentImageWithHighlight = [PAL::allocUIImageInstance() initWithCGImage:indicatorData.contentImageWithHighlight.get()->nativeImage().get() scale:scale orientation:UIImageOrientationDownMirrored];

848 _contentImageWithHighlight = [PAL::allocUIImageInstance() initWithCGImage:indicatorData.contentImageWithHighlight.get()->nativeImage()->platformImage().get() scale:scale orientation:UIImageOrientationDownMirrored];

849849 if (indicatorData.contentImage)

850 _contentImage = [PAL::allocUIImageInstance() initWithCGImage:indicatorData.contentImage.get()->nativeImage().get() scale:scale orientation:UIImageOrientationUp];

850 _contentImage = [PAL::allocUIImageInstance() initWithCGImage:indicatorData.contentImage.get()->nativeImage()->platformImage().get() scale:scale orientation:UIImageOrientationUp];

    if (indicatorData.contentImageWithoutSelection) {

        auto nativeImage = indicatorData.contentImageWithoutSelection.get()->nativeImage();

        if (nativeImage) {

855 _contentImageWithoutSelection = [PAL::allocUIImageInstance() initWithCGImage:nativeImage.get() scale:scale orientation:UIImageOrientationUp];

855 _contentImageWithoutSelection = [PAL::allocUIImageInstance() initWithCGImage:nativeImage->platformImage().get() scale:scale orientation:UIImageOrientationUp];

            _contentImageWithoutSelectionRectInRootViewCoordinates = indicatorData.contentImageWithoutSelectionRectInRootViewCoordinates;

        }

    }