Attachment #446155 for bug #233923

View Details Raw Unified Return to Bug 233923

| Differences between



2021-12-02  Jean-Yves Avenard  <jya@apple.com>

        Distinguish contiguous SharedBuffer from non-contiguous one and guarantee immutability: part 3
        https://bugs.webkit.org/show_bug.cgi?id=233677

        Reviewed by NOBODY (OOPS!).

        * DecoderTest/DecoderTest/main.mm:
        (main):

2021-11-21  Cathie Chen  <cathiechen@igalia.com>

        [Performance test][css-contain] Add case to test contain: layout inside a complex document



2021-12-03  Jean-Yves Avenard  <jya@apple.com>

        Rename SharedBuffer classes.
        https://bugs.webkit.org/show_bug.cgi?id=233677
        rdar://problem/85963900

        Reviewed by NOBODY (OOPS!).

        SharedBuffer are renamed FragmentedSharedBuffer and
        ContiguousSharedBuffer to SharedBuffer to better reflect their actual
        types.

        * runtime/ArrayBuffer.h:

2021-12-03  Keith Miller  <keith_miller@apple.com>

        Remove StructureIDBlob

Lines 129-135 public: a/Source/JavaScriptCore/runtime/ArrayBuffer.h_sec1
- a/Source/JavaScriptCore/runtime/ArrayBuffer.h -1 / +1 lines
129	JS_EXPORT_PRIVATE static RefPtr<ArrayBuffer> tryCreate(ArrayBuffer&);	129	JS_EXPORT_PRIVATE static RefPtr<ArrayBuffer> tryCreate(ArrayBuffer&);
130	JS_EXPORT_PRIVATE static RefPtr<ArrayBuffer> tryCreate(const void* source, size_t byteLength);	130	JS_EXPORT_PRIVATE static RefPtr<ArrayBuffer> tryCreate(const void* source, size_t byteLength);
131		131
132	// Only for use by Uint8ClampedArray::tryCreateUninitialized and SharedBuffer::tryCreateArrayBuffer.	132	// Only for use by Uint8ClampedArray::tryCreateUninitialized and FragmentedSharedBuffer::tryCreateArrayBuffer.
133	JS_EXPORT_PRIVATE static Ref<ArrayBuffer> createUninitialized(size_t numElements, unsigned elementByteSize);	133	JS_EXPORT_PRIVATE static Ref<ArrayBuffer> createUninitialized(size_t numElements, unsigned elementByteSize);
134	JS_EXPORT_PRIVATE static RefPtr<ArrayBuffer> tryCreateUninitialized(size_t numElements, unsigned elementByteSize);	134	JS_EXPORT_PRIVATE static RefPtr<ArrayBuffer> tryCreateUninitialized(size_t numElements, unsigned elementByteSize);
135		135



2021-12-07  Jean-Yves Avenard  <jya@apple.com>

        Make PreviewConverterProvider not modify the SharedBuffer once returned
        https://bugs.webkit.org/show_bug.cgi?id=233923

        Reviewed by NOBODY (OOPS!).

        No new tests (OOPS!).

        * loader/ios/LegacyPreviewLoader.h:
        * loader/ios/LegacyPreviewLoader.mm:
        (WebCore::LegacyPreviewLoader::previewConverterDidStartConverting):
        (WebCore::LegacyPreviewLoader::provideMainResourceForPreviewConverter):
        * platform/PreviewConverter.cpp:
        (WebCore::PreviewConverter::updateMainResource):
        * platform/PreviewConverterProvider.h:

2021-12-05  Jean-Yves Avenard  <jya@apple.com>

        SourceBufferParser should be using contiguous SharedBuffer
        https://bugs.webkit.org/show_bug.cgi?id=233865
        rdar://problem/86085253

        Reviewed by NOBODY (OOPS!).

        Covered by existing tests, no observable differences.

        * Modules/mediasource/SourceBuffer.cpp:
        (WebCore::SourceBuffer::appendBufferTimerFired):
        * Modules/mediasource/SourceBuffer.h:
        * platform/audio/cocoa/AudioFileReaderCocoa.cpp:
        * platform/graphics/SourceBufferPrivate.cpp:
        (WebCore::SourceBufferPrivate::append):
        * platform/graphics/SourceBufferPrivate.h:
        * platform/graphics/avfoundation/objc/SourceBufferPrivateAVFObjC.h:
        * platform/graphics/avfoundation/objc/SourceBufferPrivateAVFObjC.mm:
        (WebCore::SourceBufferPrivateAVFObjC::append):
        * platform/graphics/cocoa/SourceBufferParser.cpp:
        (WebCore::SourceBufferParser::Segment::Segment):
        (WebCore::SourceBufferParser::Segment::size const):
        (WebCore::SourceBufferParser::Segment::read const):
        (WebCore::SourceBufferParser::Segment::takeSharedBuffer):
        (WebCore::SourceBufferParser::Segment::getSharedBuffer const):
        * platform/graphics/cocoa/SourceBufferParser.h:
        * platform/graphics/cocoa/SourceBufferParserWebM.cpp:

2021-12-03  Jean-Yves Avenard  <jya@apple.com>

        Rename SharedBuffer classes.
        https://bugs.webkit.org/show_bug.cgi?id=233677
        rdar://problem/85963900

        Reviewed by NOBODY (OOPS!).

        SharedBuffer are renamed FragmentedSharedBuffer and
        ContiguousSharedBuffer to SharedBuffer to better reflect their actual
        types.

        Rename only, no change in behaviour.

        * Modules/async-clipboard/ClipboardImageReader.cpp:
        * Modules/async-clipboard/ClipboardImageReader.h:
        * Modules/async-clipboard/ClipboardItemBindingsDataSource.cpp:
        * Modules/async-clipboard/ClipboardItemBindingsDataSource.h:
        * Modules/async-clipboard/ios/ClipboardImageReaderIOS.mm:
        * Modules/async-clipboard/mac/ClipboardImageReaderMac.mm:
        * Modules/cache/CacheStorageConnection.cpp:
        * Modules/cache/DOMCache.cpp:
        * Modules/cache/DOMCache.h:
        * Modules/cache/DOMCacheEngine.cpp:
        * Modules/cache/DOMCacheEngine.h:
        * Modules/encryptedmedia/CDM.cpp:
        * Modules/encryptedmedia/CDM.h:
        * Modules/encryptedmedia/CDMClient.h:
        * Modules/encryptedmedia/InitDataRegistry.cpp:
        * Modules/encryptedmedia/InitDataRegistry.h:
        * Modules/encryptedmedia/MediaKeySession.cpp:
        * Modules/encryptedmedia/MediaKeySession.h:
        * Modules/encryptedmedia/MediaKeyStatusMap.cpp:
        * Modules/encryptedmedia/MediaKeyStatusMap.h:
        * Modules/encryptedmedia/MediaKeys.cpp:
        * Modules/encryptedmedia/MediaKeys.h:
        * Modules/fetch/FetchBody.cpp:
        * Modules/fetch/FetchBody.h:
        * Modules/fetch/FetchBodyConsumer.cpp:
        * Modules/fetch/FetchBodyConsumer.h:
        * Modules/fetch/FetchLoader.cpp:
        * Modules/fetch/FetchLoader.h:
        * Modules/fetch/FetchResponse.cpp:
        * Modules/fetch/FetchResponse.h:
        * Modules/highlight/AppHighlight.h:
        * Modules/highlight/AppHighlightRangeData.cpp:
        * Modules/highlight/AppHighlightRangeData.h:
        * Modules/highlight/AppHighlightStorage.cpp:
        * Modules/highlight/AppHighlightStorage.h:
        * Modules/indexeddb/server/IDBSerialization.cpp:
        * Modules/indexeddb/server/IDBSerialization.h:
        * Modules/mediarecorder/MediaRecorder.cpp:
        * Modules/mediarecorder/MediaRecorder.h:
        * Modules/mediasession/MediaMetadata.cpp:
        * Modules/mediasource/SourceBuffer.cpp:
        * Modules/mediasource/SourceBuffer.h:
        * Modules/mediastream/RTCDataChannelRemoteHandler.h:
        * Modules/mediastream/libwebrtc/LibWebRTCDataChannelHandler.cpp:
        * Modules/mediastream/libwebrtc/LibWebRTCDataChannelHandler.h:
        * Modules/streams/ReadableStreamSink.h:
        * bindings/js/JSDOMGlobalObject.cpp:
        * bindings/js/ScriptBufferSourceProvider.h:
        * bindings/js/SerializedScriptValue.h:
        * css/CSSFontFaceSource.cpp:
        * css/CSSFontFaceSource.h:
        * dom/DataTransfer.cpp:
        * editing/Editor.cpp:
        * editing/Editor.h:
        * editing/SerializedAttachmentData.h:
        * editing/WebContentReader.h:
        * editing/WebCorePasteboardFileReader.cpp:
        * editing/WebCorePasteboardFileReader.h:
        * editing/cocoa/EditorCocoa.mm:
        * editing/cocoa/HTMLConverter.mm:
        * editing/cocoa/WebContentReaderCocoa.mm:
        * editing/gtk/WebContentReaderGtk.cpp:
        * editing/mac/EditorMac.mm:
        * fileapi/Blob.h:
        * fileapi/NetworkSendQueue.cpp:
        * fileapi/NetworkSendQueue.h:
        * html/FTPDirectoryDocument.cpp:
        * html/HTMLAttachmentElement.cpp:
        * html/HTMLAttachmentElement.h:
        * html/HTMLMediaElement.cpp:
        * html/HTMLMediaElement.h:
        * html/ImageDocument.cpp:
        * inspector/InspectorInstrumentation.cpp:
        * inspector/InspectorInstrumentation.h:
        * inspector/InspectorInstrumentationWebKit.cpp:
        * inspector/InspectorInstrumentationWebKit.h:
        * inspector/NetworkResourcesData.cpp:
        * inspector/NetworkResourcesData.h:
        * inspector/agents/InspectorNetworkAgent.cpp:
        * inspector/agents/InspectorNetworkAgent.h:
        * inspector/agents/InspectorPageAgent.cpp:
        * inspector/agents/InspectorPageAgent.h:
        * loader/ContentFilter.cpp:
        * loader/CrossOriginPreflightChecker.cpp:
        * loader/DocumentLoader.cpp:
        * loader/DocumentLoader.h:
        * loader/DocumentThreadableLoader.cpp:
        * loader/EmptyClients.cpp:
        * loader/FrameLoader.cpp:
        * loader/FrameLoader.h:
        * loader/FrameLoaderClient.h:
        * loader/LoaderStrategy.h:
        * loader/NetscapePlugInStreamLoader.cpp:
        * loader/NetscapePlugInStreamLoader.h:
        * loader/ResourceCryptographicDigest.cpp:
        * loader/ResourceCryptographicDigest.h:
        * loader/ResourceLoader.cpp:
        * loader/ResourceLoader.h:
        * loader/SubresourceLoader.cpp:
        * loader/SubresourceLoader.h:
        * loader/SubstituteData.h:
        * loader/SubstituteResource.h:
        * loader/appcache/ApplicationCacheHost.cpp:
        * loader/appcache/ApplicationCacheHost.h:
        * loader/appcache/ApplicationCacheResource.cpp:
        * loader/appcache/ApplicationCacheResource.h:
        * loader/appcache/ApplicationCacheStorage.cpp:
        * loader/appcache/ApplicationCacheStorage.h:
        * loader/archive/ArchiveFactory.cpp:
        * loader/archive/ArchiveFactory.h:
        * loader/archive/ArchiveResource.cpp:
        * loader/archive/ArchiveResource.h:
        * loader/archive/cf/LegacyWebArchive.cpp:
        * loader/archive/cf/LegacyWebArchive.h:
        * loader/archive/mhtml/MHTMLArchive.cpp:
        * loader/archive/mhtml/MHTMLArchive.h:
        * loader/archive/mhtml/MHTMLParser.cpp:
        * loader/archive/mhtml/MHTMLParser.h:
        * loader/cache/CachedApplicationManifest.cpp:
        * loader/cache/CachedApplicationManifest.h:
        * loader/cache/CachedCSSStyleSheet.cpp:
        * loader/cache/CachedCSSStyleSheet.h:
        * loader/cache/CachedFont.cpp:
        * loader/cache/CachedFont.h:
        * loader/cache/CachedImage.cpp:
        * loader/cache/CachedImage.h:
        * loader/cache/CachedRawResource.cpp:
        * loader/cache/CachedRawResource.h:
        * loader/cache/CachedResource.cpp:
        * loader/cache/CachedResource.h:
        * loader/cache/CachedSVGDocument.cpp:
        * loader/cache/CachedSVGDocument.h:
        * loader/cache/CachedSVGFont.cpp:
        * loader/cache/CachedSVGFont.h:
        * loader/cache/CachedScript.cpp:
        * loader/cache/CachedScript.h:
        * loader/cache/CachedTextTrack.cpp:
        * loader/cache/CachedTextTrack.h:
        * loader/cache/CachedXSLStyleSheet.cpp:
        * loader/cache/CachedXSLStyleSheet.h:
        * loader/cocoa/DiskCacheMonitorCocoa.h:
        * loader/cocoa/DiskCacheMonitorCocoa.mm:
        * loader/ios/LegacyPreviewLoader.h:
        * loader/ios/LegacyPreviewLoader.mm:
        * page/EditorClient.h:
        * page/Page.cpp:
        * page/PageSerializer.cpp:
        * page/PageSerializer.h:
        * page/ShareData.h:
        * page/ShareDataReader.cpp:
        * platform/KeyedCoding.h:
        * platform/NowPlayingManager.h:
        * platform/Pasteboard.cpp:
        * platform/Pasteboard.h:
        * platform/PasteboardCustomData.cpp:
        * platform/PasteboardCustomData.h:
        * platform/PasteboardStrategy.h:
        * platform/PasteboardWriterData.h:
        * platform/PlatformContentFilter.h:
        * platform/PlatformPasteboard.h:
        * platform/PreviewConverter.cpp:
        * platform/PreviewConverter.h:
        * platform/PreviewConverterClient.h:
        * platform/PreviewConverterProvider.h:
        * platform/PromisedAttachmentInfo.h:
        * platform/SharedBuffer.cpp:
        * platform/SharedBuffer.h:
        * platform/SharedBufferChunkReader.cpp:
        * platform/SharedBufferChunkReader.h:
        * platform/StaticPasteboard.cpp:
        * platform/StaticPasteboard.h:
        * platform/audio/NowPlayingInfo.h:
        * platform/audio/cocoa/AudioFileReaderCocoa.cpp:
        * platform/cf/KeyedEncoderCF.cpp:
        * platform/cf/KeyedEncoderCF.h:
        * platform/cf/SharedBufferCF.cpp:
        * platform/cocoa/NetworkExtensionContentFilter.h:
        * platform/cocoa/NetworkExtensionContentFilter.mm:
        * platform/cocoa/ParentalControlsContentFilter.h:
        * platform/cocoa/ParentalControlsContentFilter.mm:
        * platform/cocoa/PasteboardCocoa.mm:
        * platform/cocoa/SharedBufferCocoa.mm:
        * platform/encryptedmedia/CDMInstance.h:
        * platform/encryptedmedia/CDMInstanceSession.h:
        * platform/encryptedmedia/CDMPrivate.h:
        * platform/encryptedmedia/CDMProxy.cpp:
        * platform/encryptedmedia/CDMProxy.h:
        * platform/encryptedmedia/CDMUtilities.cpp:
        * platform/encryptedmedia/CDMUtilities.h:
        * platform/encryptedmedia/clearkey/CDMClearKey.cpp:
        * platform/encryptedmedia/clearkey/CDMClearKey.h:
        * platform/generic/KeyedEncoderGeneric.cpp:
        * platform/generic/KeyedEncoderGeneric.h:
        * platform/glib/KeyedEncoderGlib.cpp:
        * platform/glib/KeyedEncoderGlib.h:
        * platform/glib/SharedBufferGlib.cpp:
        * platform/graphics/Font.cpp:
        * platform/graphics/Font.h:
        * platform/graphics/FontPlatformData.h:
        * platform/graphics/Image.cpp:
        * platform/graphics/Image.h:
        * platform/graphics/ImageBackingStore.h:
        * platform/graphics/ImageDecoder.cpp:
        * platform/graphics/ImageDecoder.h:
        * platform/graphics/ImageSource.cpp:
        * platform/graphics/ImageSource.h:
        * platform/graphics/Model.cpp:
        * platform/graphics/Model.h:
        * platform/graphics/PlatformMediaResourceLoader.h:
        * platform/graphics/SourceBufferPrivate.cpp:
        * platform/graphics/SourceBufferPrivate.h:
        * platform/graphics/WOFFFileFormat.cpp:
        * platform/graphics/WOFFFileFormat.h:
        * platform/graphics/avfoundation/CDMFairPlayStreaming.cpp:
        * platform/graphics/avfoundation/CDMFairPlayStreaming.h:
        * platform/graphics/avfoundation/objc/CDMInstanceFairPlayStreamingAVFObjC.h:
        * platform/graphics/avfoundation/objc/CDMInstanceFairPlayStreamingAVFObjC.mm:
        * platform/graphics/avfoundation/objc/ImageDecoderAVFObjC.h:
        * platform/graphics/avfoundation/objc/ImageDecoderAVFObjC.mm:
        * platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.h:
        * platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.mm:
        * platform/graphics/avfoundation/objc/SourceBufferPrivateAVFObjC.h:
        * platform/graphics/avfoundation/objc/SourceBufferPrivateAVFObjC.mm:
        * platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.h:
        * platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm:
        * platform/graphics/cairo/FontCustomPlatformData.h:
        * platform/graphics/cg/ImageDecoderCG.cpp:
        * platform/graphics/cg/ImageDecoderCG.h:
        * platform/graphics/cocoa/FontPlatformDataCocoa.mm:
        * platform/graphics/cocoa/SourceBufferParser.cpp:
        * platform/graphics/cocoa/SourceBufferParser.h:
        * platform/graphics/cocoa/SourceBufferParserWebM.cpp:
        * platform/graphics/coretext/FontPlatformDataCoreText.cpp:
        * platform/graphics/displaylists/DisplayListItemBuffer.cpp:
        * platform/graphics/displaylists/DisplayListItemBuffer.h:
        * platform/graphics/freetype/FontCustomPlatformDataFreeType.cpp:
        * platform/graphics/freetype/FontPlatformDataFreeType.cpp:
        * platform/graphics/gstreamer/GStreamerCommon.cpp:
        * platform/graphics/gstreamer/GStreamerCommon.h:
        * platform/graphics/gstreamer/ImageDecoderGStreamer.cpp:
        * platform/graphics/gstreamer/ImageDecoderGStreamer.h:
        * platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:
        * platform/graphics/gstreamer/eme/CDMProxyClearKey.h:
        * platform/graphics/gstreamer/eme/CDMThunder.cpp:
        * platform/graphics/gstreamer/eme/CDMThunder.h:
        * platform/graphics/gstreamer/eme/GStreamerEMEUtilities.cpp:
        * platform/graphics/gstreamer/eme/GStreamerEMEUtilities.h:
        * platform/graphics/mac/FontCustomPlatformData.cpp:
        * platform/graphics/mac/FontCustomPlatformData.h:
        * platform/graphics/opentype/OpenTypeMathData.cpp:
        * platform/graphics/opentype/OpenTypeMathData.h:
        * platform/graphics/opentype/OpenTypeTypes.h:
        * platform/graphics/opentype/OpenTypeUtilities.cpp:
        * platform/graphics/opentype/OpenTypeUtilities.h:
        * platform/graphics/opentype/OpenTypeVerticalData.cpp:
        * platform/graphics/win/DirectWriteUtilities.h:
        * platform/graphics/win/FontCustomPlatformData.cpp:
        * platform/graphics/win/FontCustomPlatformData.h:
        * platform/graphics/win/FontCustomPlatformDataCairo.cpp:
        * platform/graphics/win/FontPlatformDataCairoWin.cpp:
        * platform/graphics/win/FontPlatformDataWin.cpp:
        * platform/graphics/win/ImageDecoderDirect2D.cpp:
        * platform/graphics/win/ImageDecoderDirect2D.h:
        * platform/graphics/win/ImageWin.cpp:
        * platform/gtk/SelectionData.h:
        * platform/image-decoders/ScalableImageDecoder.cpp:
        * platform/image-decoders/ScalableImageDecoder.h:
        * platform/image-decoders/avif/AVIFImageReader.cpp:
        * platform/image-decoders/avif/AVIFImageReader.h:
        * platform/image-decoders/bmp/BMPImageDecoder.cpp:
        * platform/image-decoders/bmp/BMPImageDecoder.h:
        * platform/image-decoders/bmp/BMPImageReader.h:
        * platform/image-decoders/cairo/ImageBackingStoreCairo.cpp:
        * platform/image-decoders/gif/GIFImageDecoder.cpp:
        * platform/image-decoders/gif/GIFImageDecoder.h:
        * platform/image-decoders/gif/GIFImageReader.h:
        * platform/image-decoders/ico/ICOImageDecoder.cpp:
        * platform/image-decoders/ico/ICOImageDecoder.h:
        * platform/image-decoders/jpeg/JPEGImageDecoder.cpp:
        * platform/image-decoders/jpeg/JPEGImageDecoder.h:
        * platform/image-decoders/jpeg2000/JPEG2000ImageDecoder.cpp:
        * platform/image-decoders/png/PNGImageDecoder.cpp:
        * platform/image-decoders/webp/WEBPImageDecoder.cpp:
        * platform/image-decoders/webp/WEBPImageDecoder.h:
        * platform/ios/PasteboardIOS.mm:
        * platform/ios/PlatformPasteboardIOS.mm:
        * platform/mac/PasteboardMac.mm:
        * platform/mac/PlatformPasteboardMac.mm:
        * platform/mediarecorder/MediaRecorderPrivate.h:
        * platform/mediarecorder/MediaRecorderPrivateMock.cpp:
        * platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.h:
        * platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.mm:
        * platform/network/DataURLDecoder.h:
        * platform/network/FormData.cpp:
        * platform/network/FormData.h:
        * platform/network/ResourceHandle.h:
        * platform/network/ResourceHandleClient.cpp:
        * platform/network/ResourceHandleClient.h:
        * platform/network/cf/ResourceHandleCFURLConnectionDelegateWithOperationQueue.cpp:
        * platform/network/cocoa/RangeResponseGenerator.mm:
        * platform/network/cocoa/WebCoreNSURLSession.h:
        * platform/network/cocoa/WebCoreNSURLSession.mm:
        * platform/network/curl/CurlDownload.cpp:
        * platform/network/curl/CurlDownload.h:
        * platform/network/curl/CurlMultipartHandle.cpp:
        * platform/network/curl/CurlMultipartHandle.h:
        * platform/network/curl/CurlMultipartHandleClient.h:
        * platform/network/curl/CurlRequest.cpp:
        * platform/network/curl/CurlRequest.h:
        * platform/network/curl/CurlRequestClient.h:
        * platform/network/curl/CurlResourceHandleDelegate.cpp:
        * platform/network/curl/CurlResourceHandleDelegate.h:
        * platform/network/ios/LegacyPreviewLoaderClient.h:
        * platform/posix/SharedBufferPOSIX.cpp:
        * platform/win/PasteboardWin.cpp:
        * platform/win/SharedBufferWin.cpp:
        * testing/MockCDMFactory.cpp:
        * testing/MockCDMFactory.h:
        * testing/MockContentFilter.cpp:
        * testing/MockContentFilter.h:
        * workers/ScriptBuffer.h:
        * workers/WorkerFontLoadRequest.cpp:
        * workers/service/context/ServiceWorkerFetch.cpp:
        * workers/service/context/ServiceWorkerFetch.h:
        * workers/service/server/SWScriptStorage.cpp:
        * xml/XSLTProcessorLibxslt.cpp:
        * xml/parser/XMLDocumentParserLibxml2.cpp:

2021-11-28  Jean-Yves Avenard  <jya@apple.com>

        Add SharedBufferBuilder class
        https://bugs.webkit.org/show_bug.cgi?id=233442
        rdar://85693939

        Reviewed by NOBODY (OOPS!).

        Similar to StringBuilder, a SharedBuffer can now only be modified through
        a SharedBufferBuilder. A SharedBuffer becomes immutable once created.

        Fly-By: Pass SharedBuffer via const references or pointers where it's easy
        to do so.
        No change in observable behaviour; covered by existing tests.

        * Modules/cache/DOMCache.cpp:
        (WebCore::DOMCache::addAll):
        (WebCore::DOMCache::put):
        * Modules/fetch/FetchBodyConsumer.cpp:
        (WebCore::FetchBodyConsumer::clean):
        (WebCore::FetchBodyConsumer::resolve):
        (WebCore::FetchBodyConsumer::append):
        (WebCore::FetchBodyConsumer::setData):
        (WebCore::FetchBodyConsumer::takeData):
        (WebCore::FetchBodyConsumer::takeAsArrayBuffer):
        (WebCore::FetchBodyConsumer::takeAsBlob):
        (WebCore::FetchBodyConsumer::takeAsText):
        (WebCore::FetchBodyConsumer::setSource):
        * Modules/fetch/FetchBodyConsumer.h:
        (WebCore::FetchBodyConsumer::data const):
        (WebCore::FetchBodyConsumer::setData): Deleted.
        * Modules/model-element/HTMLModelElement.cpp:
        (WebCore::HTMLModelElement::setSourceURL):
        (WebCore::HTMLModelElement::dataReceived):
        (WebCore::HTMLModelElement::notifyFinished):
        * Modules/model-element/HTMLModelElement.h:
        * inspector/NetworkResourcesData.cpp:
        (WebCore::NetworkResourcesData::ResourceData::ResourceData):
        (WebCore::NetworkResourcesData::ResourceData::removeContent):
        (WebCore::NetworkResourcesData::ResourceData::hasData const):
        (WebCore::NetworkResourcesData::ResourceData::dataLength const):
        (WebCore::NetworkResourcesData::ResourceData::appendData):
        (WebCore::NetworkResourcesData::ResourceData::decodeDataToContent):
        * inspector/NetworkResourcesData.h:
        (WebCore::NetworkResourcesData::ResourceData::hasBufferedData const):
        (WebCore::NetworkResourcesData::ResourceData::hasData const): Deleted.
        * loader/ResourceLoader.cpp:
        (WebCore::ResourceLoader::releaseResources):
        (WebCore::ResourceLoader::setDataBufferingPolicy):
        (WebCore::ResourceLoader::addDataOrBuffer):
        (WebCore::ResourceLoader::resourceData const):
        (WebCore::ResourceLoader::clearResourceData):
        * loader/ResourceLoader.h:
        (WebCore::ResourceLoader::resourceData const): Deleted.
        * loader/SubstituteResource.h:
        (WebCore::SubstituteResource::data const):
        (WebCore::SubstituteResource::append):
        (WebCore::SubstituteResource::clear):
        (WebCore::SubstituteResource::deliver):
        * loader/appcache/ApplicationCacheResourceLoader.cpp:
        (WebCore::ApplicationCacheResourceLoader::dataReceived):
        * loader/appcache/ApplicationCacheStorage.cpp:
        (WebCore::ApplicationCacheStorage::store):
        * loader/archive/mhtml/MHTMLParser.cpp:
        (WebCore::MHTMLParser::parseNextPart):
        * loader/cache/CachedApplicationManifest.cpp:
        (WebCore::CachedApplicationManifest::finishLoading):
        * loader/cache/CachedApplicationManifest.h:
        * loader/cache/CachedCSSStyleSheet.cpp:
        (WebCore::CachedCSSStyleSheet::finishLoading):
        * loader/cache/CachedCSSStyleSheet.h:
        * loader/cache/CachedFont.cpp:
        (WebCore::CachedFont::finishLoading):
        * loader/cache/CachedFont.h:
        * loader/cache/CachedImage.cpp:
        (WebCore::CachedImage::updateBufferInternal):
        (WebCore::CachedImage::convertedDataIfNeeded const):
        (WebCore::CachedImage::updateBuffer):
        (WebCore::CachedImage::finishLoading):
        * loader/cache/CachedImage.h:
        * loader/cache/CachedRawResource.cpp:
        (WebCore::CachedRawResource::updateBuffer):
        (WebCore::CachedRawResource::finishLoading):
        * loader/cache/CachedRawResource.h:
        * loader/cache/CachedResource.cpp:
        (WebCore::CachedResource::updateBuffer):
        (WebCore::CachedResource::finishLoading):
        * loader/cache/CachedResource.h:
        * loader/cache/CachedSVGDocument.cpp:
        (WebCore::CachedSVGDocument::finishLoading):
        * loader/cache/CachedSVGDocument.h:
        * loader/cache/CachedScript.cpp:
        (WebCore::CachedScript::finishLoading):
        * loader/cache/CachedScript.h:
        * loader/cache/CachedTextTrack.cpp:
        (WebCore::CachedTextTrack::doUpdateBuffer):
        (WebCore::CachedTextTrack::updateBuffer):
        (WebCore::CachedTextTrack::finishLoading):
        * loader/cache/CachedTextTrack.h:
        * loader/cache/CachedXSLStyleSheet.cpp:
        (WebCore::CachedXSLStyleSheet::finishLoading):
        * loader/cache/CachedXSLStyleSheet.h:
        * loader/ios/LegacyPreviewLoader.h:
        * loader/ios/LegacyPreviewLoader.mm:
        (WebCore::LegacyPreviewLoader::previewConverterDidStartConverting):
        (WebCore::LegacyPreviewLoader::provideMainResourceForPreviewConverter):
        * platform/PreviewConverter.cpp:
        (WebCore::PreviewConverter::previewData const):
        (WebCore::PreviewConverter::replayToClient):
        * platform/PreviewConverter.h:
        * platform/SharedBuffer.cpp:
        (WebCore::SharedBuffer::append):
        * platform/SharedBuffer.h:
        (WebCore::SharedBufferBuilder::SharedBufferBuilder):
        (WebCore::SharedBufferBuilder::append):
        (WebCore::SharedBufferBuilder::operator bool const):
        (WebCore::SharedBufferBuilder::isNull const):
        (WebCore::SharedBufferBuilder::isEmpty const):
        (WebCore::SharedBufferBuilder::size const):
        (WebCore::SharedBufferBuilder::reset):
        (WebCore::SharedBufferBuilder::empty):
        (WebCore::SharedBufferBuilder::get const):
        (WebCore::SharedBufferBuilder::copy const):
        (WebCore::SharedBufferBuilder::take):
        (WebCore::SharedBufferBuilder::ensureBuffer):
        * platform/encryptedmedia/clearkey/CDMClearKey.cpp:
        (WebCore::extractKeyidsFromCencInitData):
        (WebCore::extractKeyIdFromWebMInitData):
        * platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.h:
        * platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm:
        (WebCore::PlatformResourceMediaLoader::dataReceived):
        (WebCore::WebCoreAVFResourceLoader::newDataStoredInSharedBuffer):
        * platform/graphics/gstreamer/eme/GStreamerEMEUtilities.h:
        (WebCore::InitData::InitData):
        (WebCore::InitData::append):
        (WebCore::InitData::payload const):
        * platform/image-decoders/jpeg/JPEGImageDecoder.cpp:
        (WebCore::readICCProfile):
        * platform/ios/PreviewConverterIOS.mm:
        (WebCore::PreviewConverter::PreviewConverter):
        * platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.h:
        * platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.mm:
        (WebCore::MediaRecorderPrivateWriter::~MediaRecorderPrivateWriter):
        (WebCore::MediaRecorderPrivateWriter::appendData):
        (WebCore::MediaRecorderPrivateWriter::takeData):
        * platform/network/cocoa/RangeResponseGenerator.mm:
        (WebCore::RangeResponseGenerator::Data::Data):
        (WebCore::RangeResponseGenerator::giveResponseToTaskIfBytesInRangeReceived):
        (WebCore::RangeResponseGenerator::expectedContentLengthFromData):
        * workers/ScriptBuffer.cpp:
        (WebCore::ScriptBuffer::ScriptBuffer):
        (WebCore::ScriptBuffer::toString const):
        (WebCore::ScriptBuffer::containsSingleFileMappedSegment const):
        (WebCore::ScriptBuffer::append):
        * workers/ScriptBuffer.h:
        (WebCore::ScriptBuffer::buffer const):
        (WebCore::ScriptBuffer::isolatedCopy const):
        (WebCore::ScriptBuffer::isEmpty const):
        * workers/WorkerFontLoadRequest.cpp:
        (WebCore::WorkerFontLoadRequest::WorkerFontLoadRequest):
        (WebCore::WorkerFontLoadRequest::isPending const):
        (WebCore::WorkerFontLoadRequest::ensureCustomFontData):
        (WebCore::WorkerFontLoadRequest::didReceiveData):
        * workers/WorkerFontLoadRequest.h:
        * xml/XMLHttpRequest.cpp:
        (WebCore::XMLHttpRequest::XMLHttpRequest):
        (WebCore::XMLHttpRequest::createResponseBlob):
        (WebCore::XMLHttpRequest::createResponseArrayBuffer):
        (WebCore::XMLHttpRequest::clearResponseBuffers):
        (WebCore::XMLHttpRequest::didReceiveData):
        * xml/XMLHttpRequest.h:

2021-11-25  Jean-Yves Avenard  <jya@apple.com>

        Distinguish contiguous SharedBuffer from non-contiguous one and guarantee immutability
        https://bugs.webkit.org/show_bug.cgi?id=233030
        rdar://85333814

        Reviewed by Darin Adler.

        When calling SharedBuffer::data() the underlying data was flattened,
        and so could be mutated while being shared. This was an undesirable
        behaviour.
        We introduce ContiguousSharedBuffer which guarantee that its content is made
        of contiguous data.
        All methods that would have mutated a SharedBuffer when being flattened are
        moved to ContiguousSharedBuffer.

        Area where SharedBuffers were always created with a single segment where
        converted to a ContiguousSharedBuffer.
        Previously, a SharedBuffer would have been flattened only if it needed to be
        and only when the data was going to be accessed; following this change
        the conversion is now explictly done through a call to makeContiguous.
        This conversion is a no-op if the SharedBuffer being converted was already
        a ContiguousSharedBuffer.
        With the nature of a SharedBuffer being shared by potentially multiple
        users it was necessary to limit the number of conversions being performed
        on demand to avoid redundancy.
        When the flattening could have occured, the SharedBuffer creation points were
        traced back and identified to make the buffer contiguous then.
        In the end, there's no more SharedBuffer flattening operations than there
        would have been before this change.
        There's a potential increase of temporary memory usage with the
        ScriptBufferSourceProvider class; bug 233511 is tracking it.

        While the change is extensive, code coverage of the modified areas is thorough
        which makes undetected regressions unlikely.

        In bug 233442, a SharedBuffer will be made completely immutable once created.

        No observable change.
        Covered by all existing tests. New API tests creatded.

        * Modules/async-clipboard/ClipboardItemBindingsDataSource.cpp:
        (WebCore::ClipboardItemBindingsDataSource::ClipboardItemTypeLoader::sanitizeDataIfNeeded):
        * Modules/async-clipboard/ios/ClipboardImageReaderIOS.mm:
        (WebCore::ClipboardImageReader::readBuffer):
        * Modules/async-clipboard/mac/ClipboardImageReaderMac.mm:
        (WebCore::ClipboardImageReader::readBuffer):
        * Modules/cache/CacheStorageConnection.cpp:
        (WebCore::CacheStorageConnection::computeRealBodySize):
        * Modules/cache/DOMCache.cpp:
        (WebCore::DOMCache::addAll):
        (WebCore::DOMCache::putWithResponseData):
        (WebCore::DOMCache::put):
        * Modules/cache/DOMCache.h:
        * Modules/cache/DOMCacheEngine.cpp:
        (WebCore::DOMCacheEngine::isolatedResponseBody):
        (WebCore::DOMCacheEngine::copyResponseBody):
        * Modules/cache/DOMCacheEngine.h:
        * Modules/encryptedmedia/InitDataRegistry.cpp:
        (WebCore::extractKeyIDsKeyids):
        (WebCore::sanitizeKeyids):
        * Modules/encryptedmedia/MediaKeyStatusMap.cpp:
        (WebCore::keyIdsMatch):
        (WebCore::MediaKeyStatusMap::Iterator::next):
        * Modules/fetch/FetchBody.cpp:
        (WebCore::FetchBody::consumeFormData):
        (WebCore::FetchBody::bodyAsFormData const):
        (WebCore::FetchBody::take):
        * Modules/fetch/FetchBody.h:
        * Modules/fetch/FetchBodyConsumer.cpp:
        (WebCore::FetchBodyConsumer::resolve):
        (WebCore::FetchBodyConsumer::takeAsText):
        * Modules/fetch/FetchResponse.cpp:
        (WebCore::FetchResponse::BodyLoader::consumeDataByChunk):
        (WebCore::FetchResponse::setBodyData):
        * Modules/fetch/FetchResponse.h:
        * Modules/highlight/AppHighlight.h:
        (WebCore::AppHighlight::encode const):
        * Modules/highlight/AppHighlightRangeData.cpp:
        (WebCore::AppHighlightRangeData::create):
        * Modules/indexeddb/server/IDBSerialization.cpp:
        (WebCore::serializeIDBKeyPath):
        (WebCore::serializeIDBKeyData):
        * Modules/indexeddb/server/IDBSerialization.h:
        * Modules/indexeddb/server/SQLiteIDBBackingStore.cpp:
        (WebCore::IDBServer::SQLiteIDBBackingStore::addExistingIndex):
        (WebCore::IDBServer::SQLiteIDBBackingStore::createObjectStore):
        (WebCore::IDBServer::SQLiteIDBBackingStore::createIndex):
        (WebCore::IDBServer::SQLiteIDBBackingStore::uncheckedHasIndexRecord):
        (WebCore::IDBServer::SQLiteIDBBackingStore::uncheckedPutIndexRecord):
        (WebCore::IDBServer::SQLiteIDBBackingStore::keyExistsInObjectStore):
        (WebCore::IDBServer::SQLiteIDBBackingStore::deleteRecord):
        (WebCore::IDBServer::SQLiteIDBBackingStore::addRecord):
        (WebCore::IDBServer::SQLiteIDBBackingStore::getRecord):
        (WebCore::IDBServer::SQLiteIDBBackingStore::uncheckedGetIndexRecordForOneKey):
        (WebCore::IDBServer::SQLiteIDBBackingStore::getCount):
        * Modules/indexeddb/server/SQLiteIDBCursor.cpp:
        (WebCore::IDBServer::SQLiteIDBCursor::bindArguments):
        (WebCore::IDBServer::SQLiteIDBCursor::resetAndRebindPreIndexStatementIfNecessary):
        * Modules/mediastream/RTCDataChannelRemoteHandler.cpp:
        (WebCore::RTCDataChannelRemoteHandler::readyToSend):
        * Modules/mediastream/libwebrtc/LibWebRTCDataChannelHandler.cpp:
        (WebCore::LibWebRTCDataChannelHandler::setClient):
        * Modules/model-element/HTMLModelElement.cpp:
        (WebCore::HTMLModelElement::notifyFinished):
        * Modules/model-element/scenekit/SceneKitModelLoaderUSD.mm:
        (WebCore::writeToTemporaryFile):
        * bindings/js/JSDOMGlobalObject.cpp:
        (WebCore::handleResponseOnStreamingAction):
        * bindings/js/ScriptBufferSourceProvider.h:
        * css/CSSFontFaceSource.cpp:
        (WebCore::CSSFontFaceSource::load):
        * css/CSSFontFaceSource.h:
        * editing/Editor.cpp:
        (WebCore::Editor::promisedAttachmentInfo):
        * editing/Editor.h:
        * editing/SerializedAttachmentData.h:
        * editing/cocoa/EditorCocoa.mm:
        (WebCore::archivedDataForAttributedString):
        (WebCore::Editor::getPasteboardTypesAndDataForAttachment):
        (WebCore::Editor::selectionInWebArchiveFormat):
        (WebCore::Editor::dataInRTFDFormat):
        (WebCore::Editor::dataInRTFFormat):
        * editing/cocoa/HTMLConverter.mm:
        (HTMLConverter::_addAttachmentForElement):
        (fileWrapperForURL):
        (fileWrapperForElement):
        * editing/cocoa/WebContentReaderCocoa.mm:
        (WebCore::replaceRichContentWithAttachments):
        (WebCore::extractMarkupAndArchive):
        (WebCore::sanitizeMarkupWithArchive):
        (WebCore::WebContentReader::readRTFD):
        (WebCore::WebContentMarkupReader::readRTFD):
        (WebCore::WebContentReader::readRTF):
        (WebCore::WebContentMarkupReader::readRTF):
        * editing/mac/EditorMac.mm:
        (WebCore::Editor::imageInWebArchiveFormat):
        (WebCore::Editor::dataSelectionForPasteboard):
        * html/FTPDirectoryDocument.cpp:
        (WebCore::createTemplateDocumentData):
        (WebCore::FTPDirectoryDocumentParser::loadDocumentTemplate):
        * inspector/NetworkResourcesData.cpp:
        (WebCore::NetworkResourcesData::ResourceData::decodeDataToContent):
        * inspector/agents/InspectorNetworkAgent.cpp:
        (WebCore::InspectorNetworkAgent::cachedResourceContent):
        * inspector/agents/InspectorPageAgent.cpp:
        (WebCore::InspectorPageAgent::mainResourceContent):
        (WebCore::InspectorPageAgent::sharedBufferContent):
        * loader/ContentFilter.cpp:
        (WebCore::ContentFilter::deliverResourceData):
        * loader/CrossOriginPreflightChecker.cpp:
        (WebCore::CrossOriginPreflightChecker::doPreflight):
        * loader/DocumentLoader.cpp:
        (WebCore::DocumentLoader::maybeCreateArchive):
        (WebCore::DocumentLoader::parsedArchiveData const):
        (WebCore::DocumentLoader::maybeFinishLoadingMultipartContent):
        * loader/DocumentLoader.h:
        * loader/DocumentThreadableLoader.cpp:
        (WebCore::DocumentThreadableLoader::loadRequest):
        * loader/EmptyClients.cpp:
        * loader/FrameLoader.cpp:
        (WebCore::FrameLoader::loadResourceSynchronously):
        * loader/FrameLoader.h:
        * loader/ResourceLoader.cpp:
        (WebCore::ResourceLoader::didReceiveDataOrBuffer):
        * loader/SubresourceLoader.cpp:
        (WebCore::SubresourceLoader::didReceiveDataOrBuffer):
        * loader/appcache/ApplicationCacheGroup.cpp:
        (WebCore::ApplicationCacheGroup::didFinishLoadingManifest):
        * loader/appcache/ApplicationCacheHost.cpp:
        (WebCore::bufferFromResource):
        (WebCore::ApplicationCacheHost::maybeLoadSynchronously):
        (WebCore::ApplicationCacheHost::maybeLoadFallbackSynchronously):
        * loader/appcache/ApplicationCacheHost.h:
        * loader/appcache/ApplicationCacheResource.cpp:
        (WebCore::ApplicationCacheResource::deliver):
        * loader/appcache/ApplicationCacheStorage.cpp:
        (WebCore::ApplicationCacheStorage::store):
        (WebCore::ApplicationCacheStorage::loadCache):
        * loader/archive/cf/LegacyWebArchive.cpp:
        (WebCore::LegacyWebArchive::createPropertyListRepresentation):
        (WebCore::LegacyWebArchive::createResource):
        (WebCore::LegacyWebArchive::create):
        (WebCore::LegacyWebArchive::extract):
        (WebCore::LegacyWebArchive::createFromSelection):
        * loader/archive/mhtml/MHTMLParser.cpp:
        (WebCore::MHTMLParser::parseNextPart):
        * loader/cache/CachedApplicationManifest.cpp:
        (WebCore::CachedApplicationManifest::finishLoading):
        * loader/cache/CachedCSSStyleSheet.cpp:
        (WebCore::CachedCSSStyleSheet::sheetText const):
        (WebCore::CachedCSSStyleSheet::finishLoading):
        * loader/cache/CachedFont.cpp:
        (WebCore::CachedFont::finishLoading):
        (WebCore::CachedFont::ensureCustomFontData):
        (WebCore::CachedFont::createCustomFontData):
        (WebCore::CachedFont::checkNotify):
        * loader/cache/CachedFont.h:
        * loader/cache/CachedImage.cpp:
        (WebCore::CachedImage::updateBufferInternal):
        (WebCore::CachedImage::convertedDataIfNeeded const):
        * loader/cache/CachedImage.h:
        * loader/cache/CachedRawResource.cpp:
        (WebCore::CachedRawResource::updateBuffer):
        (WebCore::CachedRawResource::finishLoading):
        * loader/cache/CachedResource.cpp:
        (WebCore::CachedResource::tryReplaceEncodedData):
        * loader/cache/CachedResource.h:
        (WebCore::CachedResource::resourceBuffer const):
        * loader/cache/CachedSVGDocument.cpp:
        (WebCore::CachedSVGDocument::finishLoading):
        * loader/cache/CachedSVGFont.cpp:
        (WebCore::CachedSVGFont::ensureCustomFontData):
        * loader/cache/CachedSVGFont.h:
        * loader/cache/CachedScript.cpp:
        (WebCore::CachedScript::finishLoading):
        * loader/cache/CachedTextTrack.cpp:
        (WebCore::CachedTextTrack::doUpdateBuffer):
        * loader/cache/CachedXSLStyleSheet.cpp:
        (WebCore::CachedXSLStyleSheet::finishLoading):
        * loader/cocoa/DiskCacheMonitorCocoa.h:
        * loader/cocoa/DiskCacheMonitorCocoa.mm:
        (WebCore::DiskCacheMonitor::tryGetFileBackedSharedBufferFromCFURLCachedResponse):
        (WebCore::DiskCacheMonitor::resourceBecameFileBacked):
        * page/EditorClient.h:
        * page/Page.cpp:
        (WebCore::Page::userStyleSheet const):
        * page/PageSerializer.cpp:
        (WebCore::PageSerializer::serializeFrame):
        (WebCore::PageSerializer::serializeCSSStyleSheet):
        (WebCore::PageSerializer::addImageToResources):
        * page/PageSerializer.h:
        * page/ShareData.h:
        * page/ShareDataReader.cpp:
        (WebCore::ShareDataReader::ShareDataReader):
        (WebCore::ShareDataReader::didFinishLoading):
        * platform/KeyedCoding.h:
        * platform/Pasteboard.h:
        * platform/PasteboardCustomData.cpp:
        (WebCore::PasteboardCustomData::createSharedBuffer const):
        (WebCore::PasteboardCustomData::fromSharedBuffer):
        * platform/PasteboardCustomData.h:
        * platform/PasteboardStrategy.h:
        * platform/PasteboardWriterData.h:
        * platform/PlatformPasteboard.h:
        * platform/PromisedAttachmentInfo.h:
        * platform/SharedBuffer.cpp:
        (WebCore::SharedBuffer::SharedBuffer):
        (WebCore::SharedBuffer::makeContiguous const):
        (WebCore::SharedBuffer::size const):
        (WebCore::SharedBuffer::isEmpty const):
        (WebCore::SharedBuffer::isContiguous const):
        (WebCore::SharedBuffer::append):
        (WebCore::SharedBuffer::copy const):
        (WebCore::SharedBuffer::hasOneSegment const):
        (WebCore::ContiguousSharedBuffer::ContiguousSharedBuffer):
        (WebCore::ContiguousSharedBuffer::createWithContentsOfFile):
        (WebCore::ContiguousSharedBuffer::data const):
        (WebCore::ContiguousSharedBuffer::dataAsCharPtr const):
        (WebCore::DataSegment::data const):
        (WebCore::DataSegment::containsMappedFileData const):
        (WebCore::ContiguousSharedBuffer::decoder const):
        (WebCore::DataSegment::size const):
        (WebCore::SharedBufferDataView::SharedBufferDataView):
        (WebCore::SharedBufferDataView::dataAsCharPtr const):
        (WebCore::SharedBufferDataView::createSharedBuffer const):
        (WebCore::utf8Buffer):
        * platform/SharedBuffer.h:
        (WebCore::DataSegment::create):
        (WebCore::DataSegment::DataSegment):
        (WebCore::SharedBuffer::create):
        (WebCore::ContiguousSharedBuffer::create):
        * platform/audio/cocoa/MediaSessionManagerCocoa.mm:
        (WebCore::MediaSessionManagerCocoa::setNowPlayingInfo):
        * platform/cf/KeyedEncoderCF.cpp:
        (WebCore::KeyedEncoderCF::finishEncoding):
        * platform/cf/KeyedEncoderCF.h:
        * platform/cf/SharedBufferCF.cpp:
        (WebCore::ContiguousSharedBuffer::createCFData const):
        (WebCore::SharedBuffer::append):
        * platform/cocoa/PasteboardCocoa.mm:
        (WebCore::convertTIFFToPNG):
        (WebCore::Pasteboard::readBufferForTypeWithSecurityCheck):
        * platform/cocoa/SharedBufferCocoa.mm:
        (-[WebCoreSharedBufferData initWithDataSegment:position:size:]):
        (WebCore::ContiguousSharedBuffer::createNSData const):
        (WebCore::ContiguousSharedBuffer::createCFData const):
        (WebCore::ContiguousSharedBuffer::createFromReadingFile):
        (WebCore::DataSegment::createNSData const):
        * platform/encryptedmedia/CDMUtilities.cpp:
        (WebCore::CDMUtilities::parseJSONObject):
        * platform/encryptedmedia/clearkey/CDMClearKey.cpp:
        (WebCore::extractKeyidsLocationFromCencInitData):
        (WebCore::extractKeyidsFromCencInitData):
        (WebCore::extractKeyIdFromWebMInitData):
        * platform/generic/KeyedEncoderGeneric.cpp:
        (WebCore::KeyedEncoderGeneric::finishEncoding):
        * platform/generic/KeyedEncoderGeneric.h:
        * platform/glib/KeyedEncoderGlib.cpp:
        (WebCore::KeyedEncoderGlib::finishEncoding):
        * platform/glib/KeyedEncoderGlib.h:
        * platform/glib/SharedBufferGlib.cpp:
        (WebCore::ContiguousSharedBuffer::createGBytes const):
        (WebCore::ContiguousSharedBuffer::createFromReadingFile):
        * platform/graphics/Font.cpp:
        (WebCore::Font::create):
        * platform/graphics/Font.h:
        * platform/graphics/FontPlatformData.h:
        * platform/graphics/Model.cpp:
        (WebCore::Model::create):
        (WebCore::Model::Model):
        * platform/graphics/Model.h:
        (WebCore::Model::encode const):
        (WebCore::Model::decode):
        * platform/graphics/WOFFFileFormat.cpp:
        (WebCore::readUInt32):
        (WebCore::readUInt16):
        (WebCore::isWOFF):
        (WebCore::convertWOFFToSfnt):
        (WebCore::convertWOFFToSfntIfNecessary):
        * platform/graphics/WOFFFileFormat.h:
        * platform/graphics/avfoundation/CDMFairPlayStreaming.cpp:
        (WebCore::extractSinfData):
        * platform/graphics/avfoundation/objc/CDMInstanceFairPlayStreamingAVFObjC.mm:
        (WebCore::parseJSONValue):
        (WebCore::CDMInstanceSessionFairPlayStreamingAVFObjC::requestLicense):
        (WebCore::CDMInstanceSessionFairPlayStreamingAVFObjC::updateLicense):
        (WebCore::CDMInstanceSessionFairPlayStreamingAVFObjC::loadSession):
        (WebCore::CDMInstanceSessionFairPlayStreamingAVFObjC::removeSessionData):
        (WebCore::CDMInstanceSessionFairPlayStreamingAVFObjC::didProvideRequest):
        (WebCore::CDMInstanceSessionFairPlayStreamingAVFObjC::didProvideRequests):
        (WebCore::CDMInstanceSessionFairPlayStreamingAVFObjC::didProvideRenewingRequest):
        * platform/graphics/avfoundation/objc/ImageDecoderAVFObjC.mm:
        (WebCore::ImageDecoderAVFObjC::ImageDecoderAVFObjC):
        (WebCore::ImageDecoderAVFObjC::setData):
        * platform/graphics/avfoundation/objc/SourceBufferParserAVFObjC.mm:
        (WebCore::SourceBufferParserAVFObjC::appendData):
        * platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm:
        (WebCore::PlatformResourceMediaLoader::dataReceived):
        (WebCore::DataURLResourceMediaLoader::DataURLResourceMediaLoader):
        * platform/graphics/cairo/FontCustomPlatformData.h:
        * platform/graphics/cg/ImageDecoderCG.cpp:
        (WebCore::sharedBufferGetBytesAtPosition):
        (WebCore::ImageDecoderCG::ImageDecoderCG):
        (WebCore::ImageDecoderCG::setData):
        * platform/graphics/cg/PDFDocumentImage.cpp:
        (WebCore::PDFDocumentImage::createPDFDocument):
        * platform/graphics/cocoa/FontPlatformDataCocoa.mm:
        (WebCore::FontPlatformData::platformOpenTypeTable const):
        * platform/graphics/cocoa/SourceBufferParserWebM.cpp:
        * platform/graphics/coretext/FontPlatformDataCoreText.cpp:
        (WebCore::FontPlatformData::openTypeTable const):
        * platform/graphics/freetype/FontCustomPlatformDataFreeType.cpp:
        (WebCore::createFontCustomPlatformData):
        * platform/graphics/freetype/FontPlatformDataFreeType.cpp:
        (WebCore::FontPlatformData::openTypeTable const):
        * platform/graphics/gstreamer/GStreamerCommon.cpp:
        (WebCore::GstMappedOwnedBuffer::createSharedBuffer):
        * platform/graphics/gstreamer/GStreamerCommon.h:
        * platform/graphics/gstreamer/ImageDecoderGStreamer.cpp:
        (WebCore::ImageDecoderGStreamer::pushEncodedData):
        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:
        (WebCore::MediaPlayerPrivateGStreamer::initializationDataEncountered):
        * platform/graphics/gstreamer/eme/GStreamerEMEUtilities.cpp:
        (WebCore::markupText):
        (WebCore::InitData::extractCencIfNeeded):
        * platform/graphics/gstreamer/eme/GStreamerEMEUtilities.h:
        (WebCore::InitData::InitData):
        * platform/graphics/mac/FontCustomPlatformData.cpp:
        (WebCore::createFontCustomPlatformData):
        * platform/graphics/mac/FontCustomPlatformData.h:
        * platform/graphics/mac/PDFDocumentImageMac.mm:
        (WebCore::PDFDocumentImage::createPDFDocument):
        * platform/graphics/opentype/OpenTypeMathData.cpp:
        (WebCore::OpenType::MathItalicsCorrectionInfo::getItalicCorrection const):
        (WebCore::OpenType::MathGlyphInfo::mathItalicsCorrectionInfo const):
        (WebCore::OpenType::GlyphAssembly::getAssemblyParts const):
        (WebCore::OpenType::MathGlyphConstruction::getSizeVariants const):
        (WebCore::OpenType::MathGlyphConstruction::getAssemblyParts const):
        (WebCore::OpenType::MathVariants::mathGlyphConstruction const):
        (WebCore::OpenType::MATHTable::mathConstants const):
        (WebCore::OpenType::MATHTable::mathGlyphInfo const):
        (WebCore::OpenType::MATHTable::mathVariants const):
        * platform/graphics/opentype/OpenTypeMathData.h:
        * platform/graphics/opentype/OpenTypeTypes.h:
        (WebCore::OpenType::validateTable):
        (WebCore::OpenType::TableBase::isValidEnd):
        (WebCore::OpenType::TableBase::validatePtr):
        (WebCore::OpenType::TableBase::validateOffset const):
        (WebCore::OpenType::TableWithCoverage::getCoverageIndex const):
        * platform/graphics/opentype/OpenTypeUtilities.cpp:
        (WebCore::renameFont):
        (WebCore::renameAndActivateFont):
        * platform/graphics/opentype/OpenTypeUtilities.h:
        * platform/graphics/opentype/OpenTypeVerticalData.cpp:
        (WebCore::OpenType::SubstitutionSubTable::coverage const):
        (WebCore::OpenType::LookupTable::getSubstitutions const):
        (WebCore::OpenType::LookupList::lookup const):
        (WebCore::OpenType::FeatureTable::getGlyphSubstitutions const):
        (WebCore::OpenType::FeatureList::feature const):
        (WebCore::OpenType::FeatureList::findFeature const):
        (WebCore::OpenType::LangSysTable::feature const):
        (WebCore::OpenType::ScriptTable::defaultLangSys const):
        (WebCore::OpenType::ScriptList::script const):
        (WebCore::OpenType::ScriptList::defaultScript const):
        (WebCore::OpenType::ScriptList::defaultLangSys const):
        (WebCore::OpenType::GSUBTable::scriptList const):
        (WebCore::OpenType::GSUBTable::featureList const):
        (WebCore::OpenType::GSUBTable::lookupList const):
        (WebCore::OpenType::GSUBTable::defaultLangSys const):
        (WebCore::OpenType::GSUBTable::feature const):
        (WebCore::OpenType::GSUBTable::getVerticalGlyphSubstitutions const):
        (WebCore::loadHmtxTable):
        (WebCore::OpenTypeVerticalData::loadMetrics):
        (WebCore::OpenTypeVerticalData::loadVerticalGlyphSubstitutions):
        * platform/graphics/win/FontCustomPlatformData.cpp:
        (WebCore::createFontCustomPlatformData):
        * platform/graphics/win/FontCustomPlatformData.h:
        * platform/graphics/win/FontCustomPlatformDataCairo.cpp:
        (WebCore::createFontCustomPlatformData):
        * platform/graphics/win/FontPlatformDataCairoWin.cpp:
        (WebCore::FontPlatformData::openTypeTable const):
        * platform/graphics/win/FontPlatformDataWin.cpp:
        (WebCore::FontPlatformData::platformOpenTypeTable const):
        * platform/gtk/SelectionData.h:
        (WebCore::SelectionData::setCustomData):
        (WebCore::SelectionData::customData const):
        * platform/image-decoders/ScalableImageDecoder.h:
        * platform/image-decoders/jpeg/JPEGImageDecoder.cpp:
        (WebCore::readICCProfile):
        (WebCore::JPEGImageDecoder::setICCProfile):
        * platform/image-decoders/jpeg/JPEGImageDecoder.h:
        * platform/ios/PlatformPasteboardIOS.mm:
        (WebCore::PlatformPasteboard::bufferForType):
        (WebCore::PlatformPasteboard::write):
        (WebCore::PlatformPasteboard::typesSafeForDOMToReadAndWrite const):
        (WebCore::createItemProviderRegistrationList):
        (WebCore::PlatformPasteboard::readBuffer const):
        * platform/mac/PasteboardMac.mm:
        (WebCore::fileWrapper):
        (WebCore::readBufferAtPreferredItemIndex):
        (WebCore::Pasteboard::read):
        * platform/mac/PasteboardWriter.mm:
        (WebCore::createPasteboardWriter):
        * platform/mac/PlatformPasteboardMac.mm:
        (WebCore::PlatformPasteboard::bufferForType):
        (WebCore::PlatformPasteboard::typesSafeForDOMToReadAndWrite const):
        (WebCore::PlatformPasteboard::write):
        (WebCore::PlatformPasteboard::setBufferForType):
        (WebCore::PlatformPasteboard::readBuffer const):
        (WebCore::createPasteboardItem):
        * platform/network/FormData.cpp:
        (WebCore::FormData::asSharedBuffer const):
        * platform/network/FormData.h:
        * platform/network/ResourceHandleClient.cpp:
        (WebCore::ResourceHandleClient::didReceiveBuffer):
        * platform/network/cocoa/WebCoreNSURLSession.mm:
        (-[WebCoreNSURLSessionDataTask resource:receivedData:]):
        * platform/network/curl/CurlMultipartHandle.cpp:
        (WebCore::CurlMultipartHandle::didReceiveData):
        (WebCore::CurlMultipartHandle::didComplete):
        (WebCore::CurlMultipartHandle::processContent):
        * platform/network/curl/CurlRequest.cpp:
        (WebCore::CurlRequest::writeDataToDownloadFileIfEnabled):
        * platform/network/curl/CurlResourceHandleDelegate.cpp:
        (WebCore::CurlResourceHandleDelegate::curlDidReceiveBuffer):
        * platform/win/PasteboardWin.cpp:
        (WebCore::createGlobalImageFileContent):
        (WebCore::createGlobalHDropContent):
        * platform/win/SharedBufferWin.cpp:
        (WebCore::ContiguousSharedBuffer::createFromReadingFile):
        * testing/MockCDMFactory.cpp:
        (WebCore::MockCDM::sanitizeResponse const):
        (WebCore::MockCDMInstance::setServerCertificate):
        (WebCore::MockCDMInstanceSession::updateLicense):
        * workers/WorkerFontLoadRequest.cpp:
        (WebCore::WorkerFontLoadRequest::ensureCustomFontData):
        * workers/service/context/ServiceWorkerFetch.cpp:
        (WebCore::ServiceWorkerFetch::processResponse):
        * workers/service/server/SWScriptStorage.cpp:
        (WebCore::SWScriptStorage::retrieve):
        * xml/XSLTProcessorLibxslt.cpp:
        (WebCore::docLoaderFunc):
        * xml/parser/XMLDocumentParserLibxml2.cpp:
        (WebCore::openFunc):

2021-12-06  Antti Koivisto  <antti@apple.com>

        [LFC][Integration] Use end bits in text box iterator

Lines 33-39 namespace WebCore { a/Source/WebCore/Modules/async-clipboard/ClipboardImageReader.cpp_sec1
- a/Source/WebCore/Modules/async-clipboard/ClipboardImageReader.cpp -1 / +1 lines
33		33
34	#if !PLATFORM(COCOA)	34	#if !PLATFORM(COCOA)
35		35
36	void ClipboardImageReader::readBuffer(const String&, const String&, Ref<SharedBuffer>&&)	36	void ClipboardImageReader::readBuffer(const String&, const String&, Ref<FragmentedSharedBuffer>&&)
37	{	37	{
38	notImplemented();	38	notImplemented();
39	}	39	}



namespace WebCore {

class Document;
class FragmentedSharedBuffer;

struct ClipboardImageReader : PasteboardFileReader {
    ClipboardImageReader(Document* document, const String& mimeType)

    void readFilename(const String&) final { ASSERT_NOT_REACHED(); }

    bool shouldReadBuffer(const String&) const final;
    void readBuffer(const String& filename, const String& type, Ref<FragmentedSharedBuffer>&&) final;

    RefPtr<Document> m_document;
    String m_mimeType;



        auto& data = itemTypeLoader->data();
        if (std::holds_alternative<String>(data) && !!std::get<String>(data))
            customData.writeString(type, std::get<String>(data));
        else if (std::holds_alternative<Ref<FragmentedSharedBuffer>>(data))
            customData.writeData(type, std::get<Ref<FragmentedSharedBuffer>>(data).copyRef());
        else {
            completionHandler(std::nullopt);
            return;

{
    if (m_type == "text/html"_s) {
        String markupToSanitize;
        if (std::holds_alternative<Ref<FragmentedSharedBuffer>>(m_data)) {
            auto& buffer = std::get<Ref<FragmentedSharedBuffer>>(m_data);
            markupToSanitize = String::fromUTF8(buffer->makeContiguous()->data(), buffer->size());
        } else if (std::holds_alternative<String>(m_data))
            markupToSanitize = std::get<String>(m_data);


    }

    if (m_type == "image/png"_s) {
        RefPtr<FragmentedSharedBuffer> bufferToSanitize;
        if (std::holds_alternative<Ref<FragmentedSharedBuffer>>(m_data))
            bufferToSanitize = std::get<Ref<FragmentedSharedBuffer>>(m_data).ptr();
        else if (std::holds_alternative<String>(m_data))
            bufferToSanitize = utf8Buffer(std::get<String>(m_data));




class FileReaderLoader;
class PasteboardCustomData;
class ScriptExecutionContext;
class FragmentedSharedBuffer;

class ClipboardItemBindingsDataSource : public ClipboardItemDataSource {
    WTF_MAKE_FAST_ALLOCATED;


    void invokeCompletionHandler();

    using BufferOrString = std::variant<String, Ref<FragmentedSharedBuffer>>;
    class ClipboardItemTypeLoader : public FileReaderLoaderClient, public RefCounted<ClipboardItemTypeLoader> {
    public:
        static Ref<ClipboardItemTypeLoader> create(const String& type, CompletionHandler<void()>&& completionHandler)




namespace WebCore {

void ClipboardImageReader::readBuffer(const String&, const String&, Ref<FragmentedSharedBuffer>&& buffer)
{
    if (m_mimeType == "image/png") {
        auto image = adoptNS([PAL::allocUIImageInstance() initWithData:buffer->makeContiguous()->createNSData().get()]);
        if (auto nsData = UIImagePNGRepresentation(image.get()))
            m_result = Blob::create(m_document.get(), Vector { static_cast<const uint8_t*>(nsData.bytes), nsData.length }, m_mimeType);
    }




namespace WebCore {

void ClipboardImageReader::readBuffer(const String&, const String&, Ref<FragmentedSharedBuffer>&& buffer)
{
    if (m_mimeType == "image/png") {
        auto image = adoptNS([[NSImage alloc] initWithData:buffer->makeContiguous()->createNSData().get()]);
        if (auto cgImage = [image CGImageForProposedRect:nil context:nil hints:nil]) {
            auto representation = adoptNS([[NSBitmapImageRep alloc] initWithCGImage:cgImage]);
            NSData* nsData = [representation representationUsingType:NSBitmapImageFileTypePNG properties:@{ }];



            }
            size_t recordPosition = taskHandler->addRecord(toConnectionRecord(request.get(), response, nullptr));

            response.consumeBodyReceivedByChunk([taskHandler = WTFMove(taskHandler), recordPosition, data = SharedBufferBuilder(), response = Ref { response }] (auto&& result) mutable {
                if (taskHandler->isDone())
                    return;


                }

                if (auto* chunk = result.returnValue())
                    data.append(chunk->data(), chunk->size());
                else
                    taskHandler->addResponseBody(recordPosition, response, data.take()->makeContiguous());
            });
        }, cachedResourceRequestInitiators().fetch);
    }


    DOMCacheEngine::ResponseBody body;
    if (auto buffer = responseBody.releaseReturnValue())
        body = buffer->makeContiguous();
    batchPutOperation(request.get(), response.get(), WTFMove(body), [this, protectedThis = Ref { *this }, promise = WTFMove(promise)](ExceptionOr<void>&& result) mutable {
        queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [promise = WTFMove(promise), result = WTFMove(result)]() mutable {
            promise.settle(WTFMove(result));


    if (response->isBodyReceivedByChunk()) {
        auto& responseRef = response.get();
        responseRef.consumeBodyReceivedByChunk([promise = WTFMove(promise), request = WTFMove(request), response = WTFMove(response), data = SharedBufferBuilder(), pendingActivity = makePendingActivity(*this), this](auto&& result) mutable {

            if (result.hasException()) {
                this->putWithResponseData(WTFMove(promise), WTFMove(request), WTFMove(response), result.releaseException().isolatedCopy());

            }

            if (auto* chunk = result.returnValue())
                data.append(chunk->data(), chunk->size());
            else
                this->putWithResponseData(WTFMove(promise), WTFMove(request), WTFMove(response), RefPtr<SharedBuffer> { data.take()->makeContiguous() });
        });
        return;
    }

Lines 132-138 ResponseBody isolatedResponseBody(const ResponseBody& body) a/Source/WebCore/Modules/cache/DOMCacheEngine.cpp_sec1
- a/Source/WebCore/Modules/cache/DOMCacheEngine.cpp -1 / +1 lines
132	return WTF::switchOn(body, [](const Ref<FormData>& formData) -> ResponseBody {	132	return WTF::switchOn(body, [](const Ref<FormData>& formData) -> ResponseBody {
133	return formData->isolatedCopy();	133	return formData->isolatedCopy();
134	}, [](const Ref<SharedBuffer>& buffer) -> ResponseBody {	134	}, [](const Ref<SharedBuffer>& buffer) -> ResponseBody {
135	return buffer->copy();	135	return buffer.copyRef(); // SharedBuffer are immutable and can be returned as-is.
136	}, [](const std::nullptr_t&) -> ResponseBody {	136	}, [](const std::nullptr_t&) -> ResponseBody {
137	return DOMCacheEngine::ResponseBody { };	137	return DOMCacheEngine::ResponseBody { };
138	});	138	});



    return m_private && m_private->supportedInitDataTypes().contains(initDataType);
}

RefPtr<FragmentedSharedBuffer> CDM::sanitizeInitData(const AtomString& initDataType, const FragmentedSharedBuffer& initData)
{
    return InitDataRegistry::shared().sanitizeInitData(initDataType, initData);
}

bool CDM::supportsInitData(const AtomString& initDataType, const FragmentedSharedBuffer& initData)
{
    return m_private && m_private->supportsInitData(initDataType, initData);
}

RefPtr<FragmentedSharedBuffer> CDM::sanitizeResponse(const FragmentedSharedBuffer& response)
{
    if (!m_private)
        return nullptr;



class CDMPrivate;
class Document;
class ScriptExecutionContext;
class FragmentedSharedBuffer;

class CDM : public RefCounted<CDM>, public CanMakeWeakPtr<CDM>, private ContextDestructionObserver {
public:

    bool supportsSessions() const;
    bool supportsInitDataType(const AtomString&) const;

    RefPtr<FragmentedSharedBuffer> sanitizeInitData(const AtomString& initDataType, const FragmentedSharedBuffer&);
    bool supportsInitData(const AtomString& initDataType, const FragmentedSharedBuffer&);

    RefPtr<FragmentedSharedBuffer> sanitizeResponse(const FragmentedSharedBuffer&);

    std::optional<String> sanitizeSessionId(const String& sessionId);




namespace WebCore {

class CDMInstance;
class FragmentedSharedBuffer;

class CDMClient : public CanMakeWeakPtr<CDMClient> {
public:
    virtual ~CDMClient() = default;

    virtual void cdmClientAttemptToResumePlaybackIfNecessary() = 0;
    virtual void cdmClientUnrequestedInitializationDataReceived(const String&, Ref<FragmentedSharedBuffer>&&) = 0;
};

} // namespace WebCore



    const uint32_t kKeyIdsMaxKeyIdSizeInBytes = 512;
}

static std::optional<Vector<Ref<FragmentedSharedBuffer>>> extractKeyIDsKeyids(const FragmentedSharedBuffer& buffer)
{
    // 1. Format
    // https://w3c.github.io/encrypted-media/format-registry/initdata/keyids.html#format
    if (buffer.size() > std::numeric_limits<unsigned>::max())
        return std::nullopt;
    String json { buffer.makeContiguous()->data(), static_cast<unsigned>(buffer.size()) };

    auto value = JSON::Value::parseJSON(json);
    if (!value)

    if (!kidsArray)
        return std::nullopt;

    Vector<Ref<FragmentedSharedBuffer>> keyIDs;
    for (auto& value : *kidsArray) {
        auto keyID = value->asString();
        if (!keyID)

    return keyIDs;
}

static RefPtr<FragmentedSharedBuffer> sanitizeKeyids(const FragmentedSharedBuffer& buffer)
{
    // 1. Format
    // https://w3c.github.io/encrypted-media/format-registry/initdata/keyids.html#format

    auto object = JSON::Object::create();
    auto kidsArray = JSON::Array::create();
    for (auto& buffer : keyIDBuffer.value())
        kidsArray->pushString(base64URLEncodeToString(buffer->makeContiguous()->data(), buffer->size()));
    object->setArray("kids", WTFMove(kidsArray));

    CString jsonData = object->toJSONString().utf8();
    return SharedBuffer::create(jsonData.data(), jsonData.length());
}

std::optional<Vector<std::unique_ptr<ISOProtectionSystemSpecificHeaderBox>>> InitDataRegistry::extractPsshBoxesFromCenc(const FragmentedSharedBuffer& buffer)
{
    // 4. Common SystemID and PSSH Box Format
    // https://w3c.github.io/encrypted-media/format-registry/initdata/cenc.html#common-system

    return psshBoxes;
}

std::optional<Vector<Ref<FragmentedSharedBuffer>>> InitDataRegistry::extractKeyIDsCenc(const FragmentedSharedBuffer& buffer)
{
    Vector<Ref<FragmentedSharedBuffer>> keyIDs;

    auto psshBoxes = extractPsshBoxesFromCenc(buffer);
    if (!psshBoxes)

    return keyIDs;
}

RefPtr<FragmentedSharedBuffer> InitDataRegistry::sanitizeCenc(const FragmentedSharedBuffer& buffer)
{
    // 4. Common SystemID and PSSH Box Format
    // https://w3c.github.io/encrypted-media/format-registry/initdata/cenc.html#common-system

    return buffer.copy();
}

static RefPtr<FragmentedSharedBuffer> sanitizeWebM(const FragmentedSharedBuffer& buffer)
{
    // Check if the buffer is a valid WebM initData.
    // The WebM initData is the ContentEncKeyID, so should be less than kWebMMaxContentEncKeyIDSize.

    return buffer.copy();
}

static std::optional<Vector<Ref<FragmentedSharedBuffer>>> extractKeyIDsWebM(const FragmentedSharedBuffer& buffer)
{
    Vector<Ref<FragmentedSharedBuffer>> keyIDs;
    RefPtr<FragmentedSharedBuffer> sanitizedBuffer = sanitizeWebM(buffer);
    if (!sanitizedBuffer)
        return std::nullopt;



InitDataRegistry::~InitDataRegistry() = default;

RefPtr<FragmentedSharedBuffer> InitDataRegistry::sanitizeInitData(const AtomString& initDataType, const FragmentedSharedBuffer& buffer)
{
    auto iter = m_types.find(initDataType);
    if (iter == m_types.end() || !iter->value.sanitizeInitData)

    return iter->value.sanitizeInitData(buffer);
}

std::optional<Vector<Ref<FragmentedSharedBuffer>>> InitDataRegistry::extractKeyIDs(const AtomString& initDataType, const FragmentedSharedBuffer& buffer)
{
    auto iter = m_types.find(initDataType);
    if (iter == m_types.end() || !iter->value.sanitizeInitData)



namespace WebCore {

class ISOProtectionSystemSpecificHeaderBox;
class FragmentedSharedBuffer;

class InitDataRegistry {
public:
    WEBCORE_EXPORT static InitDataRegistry& shared();
    friend class NeverDestroyed<InitDataRegistry>;

    RefPtr<FragmentedSharedBuffer> sanitizeInitData(const AtomString& initDataType, const FragmentedSharedBuffer&);
    WEBCORE_EXPORT std::optional<Vector<Ref<FragmentedSharedBuffer>>> extractKeyIDs(const AtomString& initDataType, const FragmentedSharedBuffer&);

    struct InitDataTypeCallbacks {
        using SanitizeInitDataCallback = Function<RefPtr<FragmentedSharedBuffer>(const FragmentedSharedBuffer&)>;
        using ExtractKeyIDsCallback = Function<std::optional<Vector<Ref<FragmentedSharedBuffer>>>(const FragmentedSharedBuffer&)>;

        SanitizeInitDataCallback sanitizeInitData;
        ExtractKeyIDsCallback extractKeyIDs;

    static const AtomString& keyidsName();
    static const AtomString& webmName();

    static std::optional<Vector<std::unique_ptr<ISOProtectionSystemSpecificHeaderBox>>> extractPsshBoxesFromCenc(const FragmentedSharedBuffer&);
    static std::optional<Vector<Ref<FragmentedSharedBuffer>>> extractKeyIDsCenc(const FragmentedSharedBuffer&);
    static RefPtr<FragmentedSharedBuffer> sanitizeCenc(const FragmentedSharedBuffer&);

private:
    InitDataRegistry();



    queueTaskKeepingObjectAlive(*this, TaskSource::Networking, [this, weakThis = WeakPtr { *this }, initData = SharedBuffer::create(initData.data(), initData.length()), initDataType, promise = WTFMove(promise), identifier = WTFMove(identifier)] () mutable {
        // 10.1. If the init data is not valid for initDataType, reject promise with a newly created TypeError.
        // 10.2. Let sanitized init data be a validated and sanitized version of init data.
        RefPtr<FragmentedSharedBuffer> sanitizedInitData = m_implementation->sanitizeInitData(initDataType, initData);

        // 10.3. If the preceding step failed, reject promise with a newly created TypeError.
        if (!sanitizedInitData) {

            m_latestDecryptTime = 0;
        }

        m_instanceSession->requestLicense(m_sessionType, initDataType, sanitizedInitData.releaseNonNull(), [this, weakThis, promise = WTFMove(promise), identifier = WTFMove(identifier)] (Ref<FragmentedSharedBuffer>&& message, const String& sessionId, bool needsIndividualization, CDMInstanceSession::SuccessValue succeeded) mutable {
            if (!weakThis)
                return;


    // 6. Run the following steps in parallel:
    queueTaskKeepingObjectAlive(*this, TaskSource::Networking, [this, weakThis = WeakPtr { *this }, response = SharedBuffer::create(response.data(), response.length()), promise = WTFMove(promise), identifier = WTFMove(identifier)] () mutable {
        // 6.1. Let sanitized response be a validated and/or sanitized version of response copy.
        RefPtr<FragmentedSharedBuffer> sanitizedResponse = m_implementation->sanitizeResponse(response);

        // 6.2. If the preceding step failed, or if sanitized response is empty, reject promise with a newly created TypeError.
        if (!sanitizedResponse || sanitizedResponse->isEmpty()) {

        // 4.3. Let message type be null.

        // 4.4. Use the cdm to execute the following steps:
        m_instanceSession->removeSessionData(m_sessionId, m_sessionType, [this, weakThis, promise = WTFMove(promise), identifier = WTFMove(identifier)] (CDMInstanceSession::KeyStatusVector&& keys, std::optional<Ref<FragmentedSharedBuffer>>&& message, CDMInstanceSession::SuccessValue succeeded) mutable {
            if (!weakThis)
                return;


    // 5. Return promise.
}

void MediaKeySession::enqueueMessage(MediaKeyMessageType messageType, const FragmentedSharedBuffer& message)
{
    // 6.4.1 Queue a "message" Event
    // https://w3c.github.io/encrypted-media/#queue-message

        });
}

void MediaKeySession::sendMessage(CDMMessageType messageType, Ref<FragmentedSharedBuffer>&& message)
{
    enqueueMessage(messageType, message);
}



class DeferredPromise;
class MediaKeyStatusMap;
class MediaKeys;
class FragmentedSharedBuffer;

template<typename IDLType> class DOMPromiseProxy;


    using ClosedPromise = DOMPromiseProxy<IDLUndefined>;
    ClosedPromise& closed() { return m_closedPromise.get(); }

    const Vector<std::pair<Ref<FragmentedSharedBuffer>, MediaKeyStatus>>& statuses() const { return m_statuses; }

    unsigned internalInstanceSessionObjectRefCount() const { return m_instanceSession->refCount(); }

private:
    MediaKeySession(Document&, WeakPtr<MediaKeys>&&, MediaKeySessionType, bool useDistinctiveIdentifier, Ref<CDM>&&, Ref<CDMInstanceSession>&&);
    void enqueueMessage(MediaKeyMessageType, const FragmentedSharedBuffer&);
    void updateExpiration(double);
    void sessionClosed();
    String mediaKeysStorageDirectory() const;

    // CDMInstanceSessionClient
    void updateKeyStatuses(CDMInstanceSessionClient::KeyStatusVector&&) override;
    void sendMessage(CDMMessageType, Ref<FragmentedSharedBuffer>&& message) final;
    void sessionIdChanged(const String&) final;
    PlatformDisplayID displayID() final;


    MediaKeySessionType m_sessionType;
    Ref<CDM> m_implementation;
    Ref<CDMInstanceSession> m_instanceSession;
    Vector<Ref<FragmentedSharedBuffer>> m_recordOfKeyUsage;
    double m_firstDecryptTime { 0 };
    double m_latestDecryptTime { 0 };
    Vector<std::pair<Ref<FragmentedSharedBuffer>, MediaKeyStatus>> m_statuses;

    using DisplayChangedObserver = Observer<void(PlatformDisplayID)>;
    DisplayChangedObserver m_displayChangedObserver;



    return m_session->statuses().size();
}

static bool keyIdsMatch(const FragmentedSharedBuffer& a, const BufferSource& b)
{
    auto length = a.size();
    if (!length || length != b.length())
        return false;
    return !std::memcmp(a.makeContiguous()->data(), b.data(), length);
}

bool MediaKeyStatusMap::has(const BufferSource& keyId)

        return std::nullopt;

    auto& pair = statuses[m_index++];
    auto buffer = ArrayBuffer::create(pair.first->makeContiguous()->data(), pair.first->size());
    return KeyValuePair<BufferSource::VariantType, MediaKeyStatus> { RefPtr<ArrayBuffer>(WTFMove(buffer)), pair.second };
}


Lines 38-44 a/Source/WebCore/Modules/encryptedmedia/MediaKeyStatusMap.h_sec1
- a/Source/WebCore/Modules/encryptedmedia/MediaKeyStatusMap.h -1 / +1 lines
38	namespace WebCore {	38	namespace WebCore {
39		39
40	class MediaKeySession;	40	class MediaKeySession;
41	class SharedBuffer;	41	class FragmentedSharedBuffer;
42		42
43	class MediaKeyStatusMap : public RefCounted<MediaKeyStatusMap> {	43	class MediaKeyStatusMap : public RefCounted<MediaKeyStatusMap> {
44	public:	44	public:

Lines 177-183 bool MediaKeys::hasOpenSessions() const a/Source/WebCore/Modules/encryptedmedia/MediaKeys.cpp_sec1
- a/Source/WebCore/Modules/encryptedmedia/MediaKeys.cpp -1 / +1 lines
177	});	177	});
178	}	178	}
179		179
180	void MediaKeys::unrequestedInitializationDataReceived(const String& initDataType, Ref<SharedBuffer>&& initData)	180	void MediaKeys::unrequestedInitializationDataReceived(const String& initDataType, Ref<FragmentedSharedBuffer>&& initData)
181	{	181	{
182	for (auto& cdmClient : m_cdmClients)	182	for (auto& cdmClient : m_cdmClients)
183	cdmClient.cdmClientUnrequestedInitializationDataReceived(initDataType, initData.copyRef());	183	cdmClient.cdmClientUnrequestedInitializationDataReceived(initDataType, initData.copyRef());

Lines 86-92 protected: a/Source/WebCore/Modules/encryptedmedia/MediaKeys.h_sec1
- a/Source/WebCore/Modules/encryptedmedia/MediaKeys.h -1 / +1 lines
86	MediaKeys(Document&, bool useDistinctiveIdentifier, bool persistentStateAllowed, const Vector<MediaKeySessionType>&, Ref<CDM>&&, Ref<CDMInstance>&&);	86	MediaKeys(Document&, bool useDistinctiveIdentifier, bool persistentStateAllowed, const Vector<MediaKeySessionType>&, Ref<CDM>&&, Ref<CDMInstance>&&);
87		87
88	// CDMInstanceClient	88	// CDMInstanceClient
89	void unrequestedInitializationDataReceived(const String&, Ref<SharedBuffer>&&) final;	89	void unrequestedInitializationDataReceived(const String&, Ref<FragmentedSharedBuffer>&&) final;
90		90
91	#if !RELEASE_LOG_DISABLED	91	#if !RELEASE_LOG_DISABLED
92	const Logger& logger() const { return m_logger; }	92	const Logger& logger() const { return m_logger; }



void FetchBody::consumeFormData(FetchBodyOwner& owner, Ref<DeferredPromise>&& promise)
{
    if (auto sharedBuffer = formDataBody().asSharedBuffer()) {
        m_consumer.resolveWithData(WTFMove(promise), owner.contentType(), sharedBuffer->makeContiguous()->data(), sharedBuffer->size());
        m_data = nullptr;
    } else {
        // FIXME: If the form data contains blobs, load them like we do other blobs.

    if (isFormData())
        return &const_cast<FormData&>(formDataBody());
    if (auto* data = m_consumer.data())
        return FormData::create(data->makeContiguous()->data(), data->size());

    ASSERT_NOT_REACHED();
    return nullptr;

        auto buffer = m_consumer.takeData();
        if (!buffer)
            return nullptr;
        return buffer->makeContiguous();
    }

    if (isBlob()) {




void FetchBodyConsumer::clean()
{
    m_buffer.reset();
    resetConsumePromise();
    if (m_sink) {
        m_sink->clearCallback();

{
    if (stream) {
        ASSERT(!m_sink);
        m_sink = ReadableStreamToSharedBufferSink::create([promise = WTFMove(promise), data = SharedBufferBuilder(), type = m_type, contentType](auto&& result) mutable {
            if (result.hasException()) {
                promise->reject(result.releaseException());
                return;
            }

            if (auto* chunk = result.returnValue())
                data.append(chunk->data(), chunk->size());
            else {
                auto buffer = data.take()->makeContiguous();
                resolveWithTypeAndData(WTFMove(promise), type, contentType, buffer->data(), buffer->size());
            }
        });
        m_sink->pipeFrom(*stream);
        return;

        return;
    case FetchBodyConsumer::Type::FormData: {
        auto buffer = takeData();
        if (auto formData = packageFormData(context, contentType, buffer ? buffer->makeContiguous()->data() : nullptr, buffer ? buffer->size() : 0))
            promise->resolve<IDLInterface<DOMFormData>>(*formData);
        else
            promise->reject(TypeError);

        m_source->enqueue(ArrayBuffer::tryCreate(data, size));
        return;
    }
    m_buffer.append(data, size);
        m_buffer = SharedBuffer::create(data, size);
        return;
    }
    m_buffer->append(data, size);
}

void FetchBodyConsumer::setData(Ref<FragmentedSharedBuffer>&& data)
{
    m_buffer.reset();
    m_buffer.append(WTFMove(data));
}

RefPtr<FragmentedSharedBuffer> FetchBodyConsumer::takeData()
{
    if (!m_buffer)
        return nullptr;
    return m_buffer.take();
}

RefPtr<JSC::ArrayBuffer> FetchBodyConsumer::takeAsArrayBuffer()

    if (!m_buffer)
        return ArrayBuffer::tryCreate(nullptr, 0);

    return m_buffer.take()->tryCreateArrayBuffer();
    m_buffer = nullptr;
    return arrayBuffer;
}

Ref<Blob> FetchBodyConsumer::takeAsBlob(ScriptExecutionContext* context)

    if (!m_buffer)
        return Blob::create(context, Vector<uint8_t>(), Blob::normalizedContentType(m_contentType));

    return blobFromData(context, m_buffer.take()->extractData(), m_contentType);
    auto data = buffer->extractData();
    return blobFromData(context, WTFMove(data), m_contentType);
}

String FetchBodyConsumer::takeAsText()

    if (!m_buffer)
        return String();

    auto buffer = m_buffer.take()->makeContiguous();
    auto text = TextResourceDecoder::textFromUTF8(buffer->data(), buffer->size());
    return text;
}


void FetchBodyConsumer::setSource(Ref<FetchBodySource>&& source)
{
    m_source = WTFMove(source);
    if (m_buffer)
        m_source->enqueue(m_buffer.take()->tryCreateArrayBuffer());
        m_buffer = nullptr;
    }
}

void FetchBodyConsumer::loadingFailed(const Exception& exception)



    void append(const uint8_t* data, unsigned);

    bool hasData() const { return !!m_buffer; }
    const FragmentedSharedBuffer* data() const { return m_buffer.get().get(); }
    void setData(Ref<FragmentedSharedBuffer>&&);

    RefPtr<FragmentedSharedBuffer> takeData();
    RefPtr<JSC::ArrayBuffer> takeAsArrayBuffer();
    String takeAsText();



    Type m_type;
    String m_contentType;
    SharedBufferBuilder m_buffer;
    RefPtr<DeferredPromise> m_consumePromise;
    RefPtr<ReadableStreamToSharedBufferSink> m_sink;
    RefPtr<FetchBodySource> m_source;

Lines 135-141 void FetchLoader::stop() a/Source/WebCore/Modules/fetch/FetchLoader.cpp_sec1
- a/Source/WebCore/Modules/fetch/FetchLoader.cpp -1 / +1 lines
135	m_loader->cancel();	135	m_loader->cancel();
136	}	136	}
137		137
138	RefPtr<SharedBuffer> FetchLoader::startStreaming()	138	RefPtr<FragmentedSharedBuffer> FetchLoader::startStreaming()
139	{	139	{
140	ASSERT(m_consumer);	140	ASSERT(m_consumer);
141	auto firstChunk = m_consumer->takeData();	141	auto firstChunk = m_consumer->takeData();



class FetchLoaderClient;
class FetchRequest;
class ScriptExecutionContext;
class FragmentedSharedBuffer;

class FetchLoader final : public ThreadableLoaderClient {
public:
    FetchLoader(FetchLoaderClient&, FetchBodyConsumer*);
    WEBCORE_EXPORT ~FetchLoader();

    RefPtr<FragmentedSharedBuffer> startStreaming();

    void start(ScriptExecutionContext&, const FetchRequest&, const String&);
    void start(ScriptExecutionContext&, const Blob&);



    if (!data)
        return;

    auto contiguousBuffer = data->makeContiguous();
    Span chunk { contiguousBuffer->data(), data->size() };
    m_consumeDataCallback(&chunk);
}


    closeStream();
}

RefPtr<FragmentedSharedBuffer> FetchResponse::BodyLoader::startStreaming()
{
    ASSERT(m_loader);
    return m_loader->startStreaming();

Lines 134-140 private: a/Source/WebCore/Modules/fetch/FetchResponse.h_sec1
- a/Source/WebCore/Modules/fetch/FetchResponse.h -1 / +1 lines
134		134
135	void consumeDataByChunk(ConsumeDataByChunkCallback&&);	135	void consumeDataByChunk(ConsumeDataByChunkCallback&&);
136		136
137	RefPtr<SharedBuffer> startStreaming();	137	RefPtr<FragmentedSharedBuffer> startStreaming();
138	NotificationCallback takeNotificationCallback() { return WTFMove(m_responseCallback); }	138	NotificationCallback takeNotificationCallback() { return WTFMove(m_responseCallback); }
139	ConsumeDataByChunkCallback takeConsumeDataCallback() { return WTFMove(m_consumeDataCallback); }	139	ConsumeDataByChunkCallback takeConsumeDataCallback() { return WTFMove(m_consumeDataCallback); }
140		140



enum class HighlightRequestOriginatedInApp : bool { No, Yes };

struct AppHighlight {
    Ref<WebCore::FragmentedSharedBuffer> highlight;
    std::optional<String> text;
    CreateNewGroupForHighlight isNewGroup;
    HighlightRequestOriginatedInApp requestOriginatedInApp;

void AppHighlight::encode(Encoder& encoder) const
{
    encoder << static_cast<size_t>(highlight->size());
    encoder.encodeFixedLengthData(highlight->makeContiguous()->data(), highlight->size(), 1);

    encoder << text;





constexpr uint64_t highlightFileSignature = 0x4141504832303231; // File Signature  (A)pple(AP)plication(H)ighlights(2021)

std::optional<AppHighlightRangeData> AppHighlightRangeData::create(const FragmentedSharedBuffer& buffer)
{
    auto contiguousBuffer = buffer.makeContiguous();
    auto decoder = contiguousBuffer->decoder();
    std::optional<AppHighlightRangeData> data;
    decoder >> data;
    return data;
}

Ref<FragmentedSharedBuffer> AppHighlightRangeData::toSharedBuffer() const
{
    WTF::Persistence::Encoder encoder;
    encoder << *this;




#if ENABLE(APP_HIGHLIGHTS)

class FragmentedSharedBuffer;

class AppHighlightRangeData {
WTF_MAKE_FAST_ALLOCATED;
public:
    WEBCORE_EXPORT static std::optional<AppHighlightRangeData> create(const FragmentedSharedBuffer&);
    struct NodePathComponent {
        String identifier;
        String nodeName;

    template<class Encoder> void encode(Encoder&) const;
    template<class Decoder> static std::optional<AppHighlightRangeData> decode(Decoder&);

    Ref<FragmentedSharedBuffer> toSharedBuffer() const;

private:
    String m_identifier;

Lines 237-243 void AppHighlightStorage::storeAppHighlight(Ref<StaticRange>&& range) a/Source/WebCore/Modules/highlight/AppHighlightStorage.cpp_sec1
- a/Source/WebCore/Modules/highlight/AppHighlightStorage.cpp -1 / +1 lines
237	m_document->page()->chrome().storeAppHighlight(WTFMove(highlight));	237	m_document->page()->chrome().storeAppHighlight(WTFMove(highlight));
238	}	238	}
239		239
240	void AppHighlightStorage::restoreAndScrollToAppHighlight(Ref<SharedBuffer>&& buffer, ScrollToHighlight scroll)	240	void AppHighlightStorage::restoreAndScrollToAppHighlight(Ref<FragmentedSharedBuffer>&& buffer, ScrollToHighlight scroll)
241	{	241	{
242	auto appHighlightRangeData = AppHighlightRangeData::create(buffer);	242	auto appHighlightRangeData = AppHighlightRangeData::create(buffer);
243	if (!appHighlightRangeData)	243	if (!appHighlightRangeData)



#if ENABLE(APP_HIGHLIGHTS)

class Document;
class FragmentedSharedBuffer;
class StaticRange;
class Highlight;


    ~AppHighlightStorage();

    WEBCORE_EXPORT void storeAppHighlight(Ref<StaticRange>&&);
    WEBCORE_EXPORT void restoreAndScrollToAppHighlight(Ref<FragmentedSharedBuffer>&&, ScrollToHighlight);
    void restoreUnrestoredAppHighlights();
    MonotonicTime lastRangeSearchTime() const { return m_timeAtLastRangeSearch; }
    void resetLastRangeSearchTime() { m_timeAtLastRangeSearch = MonotonicTime::now(); }



    SQLiteTransaction transaction(*m_sqliteDB);
    transaction.begin();

    auto keyPathBlob = serializeIDBKeyPath(info.keyPath());
    if (!keyPathBlob) {
        LOG_ERROR("Unable to serialize IDBKeyPath to save in database");
        return false;

        return IDBError { UnknownError, "Attempt to create an object store in a non-version-change transaction"_s };
    }

    auto keyPathBlob = serializeIDBKeyPath(info.keyPath());
    if (!keyPathBlob) {
        LOG_ERROR("Unable to serialize IDBKeyPath to save in database for new object store");
        return IDBError { UnknownError, "Unable to serialize IDBKeyPath to save in database for new object store"_s };

        return IDBError { UnknownError, "Attempt to create an index in a non-version-change transaction"_s };
    }

    auto keyPathBlob = serializeIDBKeyPath(info.keyPath());
    if (!keyPathBlob) {
        LOG_ERROR("Unable to serialize IDBKeyPath to save in database");
        return IDBError { UnknownError, "Unable to serialize IDBKeyPath to create index in database"_s };

{
    hasRecord = false;

    auto indexKeyBuffer = serializeIDBKeyData(indexKey);
    if (!indexKeyBuffer) {
        LOG_ERROR("Unable to serialize index key to be stored in the database");
        return IDBError { UnknownError, "Unable to serialize IDBKey to check for index record in database"_s };

{
    LOG(IndexedDB, "SQLiteIDBBackingStore::uncheckedPutIndexRecord - %s, %s", keyValue.loggingString().utf8().data(), indexKey.loggingString().utf8().data());

    auto indexKeyBuffer = serializeIDBKeyData(indexKey);
    if (!indexKeyBuffer) {
        LOG_ERROR("Unable to serialize index key to be stored in the database");
        return IDBError { UnknownError, "Unable to serialize index key to be stored in the database"_s };
    }

    auto valueBuffer = serializeIDBKeyData(keyValue);
    if (!valueBuffer) {
        LOG_ERROR("Unable to serialize the value to be stored in the database");
        return IDBError { UnknownError, "Unable to serialize value to be stored in the database"_s };

    if (!transaction || !transaction->inProgress())
        return IDBError { UnknownError, "Attempt to see if key exists in objectstore without an in-progress transaction"_s };

    auto keyBuffer = serializeIDBKeyData(keyData);
    if (!keyBuffer) {
        LOG_ERROR("Unable to serialize IDBKey to check for existence in object store");
        return IDBError { UnknownError, "Unable to serialize IDBKey to check for existence in object store"_s };

    ASSERT(transaction.mode() != IDBTransactionMode::Readonly);
    UNUSED_PARAM(transaction);

    auto keyBuffer = serializeIDBKeyData(keyData);
    if (!keyBuffer) {
        LOG_ERROR("Unable to serialize IDBKeyData to be removed from the database");
        return IDBError { UnknownError, "Unable to serialize IDBKeyData to be removed from the database"_s };

        return IDBError { UnknownError, "Attempt to store a record in an object store in a read-only transaction"_s };
    }

    auto keyBuffer = serializeIDBKeyData(keyData);
    if (!keyBuffer) {
        LOG_ERROR("Unable to serialize IDBKey to be stored in an object store");
        return IDBError { UnknownError, "Unable to serialize IDBKey to be stored in an object store"_s };

    auto key = keyRange.lowerKey;
    if (key.isNull())
        key = IDBKeyData::minimum();
    auto lowerBuffer = serializeIDBKeyData(key);
    if (!lowerBuffer) {
        LOG_ERROR("Unable to serialize lower IDBKey in lookup range");
        return IDBError { UnknownError, "Unable to serialize lower IDBKey in lookup range"_s };

    key = keyRange.upperKey;
    if (key.isNull())
        key = IDBKeyData::maximum();
    auto upperBuffer = serializeIDBKeyData(key);
    if (!upperBuffer) {
        LOG_ERROR("Unable to serialize upper IDBKey in lookup range");
        return IDBError { UnknownError, "Unable to serialize upper IDBKey in lookup range"_s };


    ASSERT(key.isValid() && key.type() != IndexedDB::KeyType::Max && key.type() != IndexedDB::KeyType::Min);

    auto buffer = serializeIDBKeyData(key);
    if (!buffer) {
        LOG_ERROR("Unable to serialize IDBKey to look up one index record");
        return IDBError { UnknownError, "Unable to serialize IDBKey to look up one index record"_s };

    outCount = 0;

    auto lowerKey = range.lowerKey.isNull() ? IDBKeyData::minimum() : range.lowerKey;
    auto lowerBuffer = serializeIDBKeyData(lowerKey);
    if (!lowerBuffer) {
        LOG_ERROR("Unable to serialize lower IDBKey in lookup range");
        return IDBError { UnknownError, "Unable to serialize lower IDBKey in lookup range for count operation"_s };
    }

    auto upperKey = range.upperKey.isNull() ? IDBKeyData::maximum() : range.upperKey;
    auto upperBuffer = serializeIDBKeyData(upperKey);
    if (!upperBuffer) {
        LOG_ERROR("Unable to serialize upper IDBKey in lookup range");
        return IDBError { UnknownError, "Unable to serialize upper IDBKey in lookup range for count operation"_s };



        return false;
    }

    auto buffer = serializeIDBKeyData(m_currentLowerKey);
    if (m_statement->bindBlob(currentBindArgument++, *buffer) != SQLITE_OK) {
        LOG_ERROR("Could not create cursor statement (lower key)");
        return false;

        return false;
    }

    auto buffer = serializeIDBKeyData(key);
    if (m_preIndexStatement->bindBlob(currentBindArgument++, *buffer) != SQLITE_OK) {
        LOG_ERROR("Could not bind id argument to pre statement (key)");
        return false;

Lines 196-202 ExceptionOr<void> MediaRecorder::startRecording(std::optional<unsigned> timeSlic a/Source/WebCore/Modules/mediarecorder/MediaRecorder.cpp_sec1
- a/Source/WebCore/Modules/mediarecorder/MediaRecorder.cpp -1 / +1 lines
196	return { };	196	return { };
197	}	197	}
198		198
199	static inline Ref<BlobEvent> createDataAvailableEvent(ScriptExecutionContext* context, RefPtr<SharedBuffer>&& buffer, const String& mimeType, double timeCode)	199	static inline Ref<BlobEvent> createDataAvailableEvent(ScriptExecutionContext* context, RefPtr<FragmentedSharedBuffer>&& buffer, const String& mimeType, double timeCode)
200	{	200	{
201	auto blob = buffer ? Blob::create(context, buffer->extractData(), mimeType) : Blob::create(context);	201	auto blob = buffer ? Blob::create(context, buffer->extractData(), mimeType) : Blob::create(context);
202	return BlobEvent::create(eventNames().dataavailableEvent, BlobEvent::Init { { false, false, false }, WTFMove(blob), timeCode }, BlobEvent::IsTrusted::Yes);	202	return BlobEvent::create(eventNames().dataavailableEvent, BlobEvent::Init { { false, false, false }, WTFMove(blob), timeCode }, BlobEvent::IsTrusted::Yes);

Lines 103-109 private: a/Source/WebCore/Modules/mediarecorder/MediaRecorder.h_sec1
- a/Source/WebCore/Modules/mediarecorder/MediaRecorder.h -1 / +1 lines
103	void dispatchError(Exception&&);	103	void dispatchError(Exception&&);
104		104
105	enum class TakePrivateRecorder { No, Yes };	105	enum class TakePrivateRecorder { No, Yes };
106	using FetchDataCallback = Function<void(RefPtr<SharedBuffer>&&, const String& mimeType, double)>;	106	using FetchDataCallback = Function<void(RefPtr<FragmentedSharedBuffer>&&, const String& mimeType, double)>;
107	void fetchData(FetchDataCallback&&, TakePrivateRecorder);	107	void fetchData(FetchDataCallback&&, TakePrivateRecorder);
108		108
109	// MediaStream::Observer	109	// MediaStream::Observer

Lines 77-83 void ArtworkImageLoader::notifyFinished(CachedResource& resource, const NetworkL a/Source/WebCore/Modules/mediasession/MediaMetadata.cpp_sec1
- a/Source/WebCore/Modules/mediasession/MediaMetadata.cpp -1 / +1 lines
77	return;	77	return;
78	}	78	}
79	// Sanitize the image by decoding it into a BitmapImage.	79	// Sanitize the image by decoding it into a BitmapImage.
80	RefPtr<SharedBuffer> bufferToSanitize = m_cachedImage->image()->data();	80	RefPtr<FragmentedSharedBuffer> bufferToSanitize = m_cachedImage->image()->data();
81	auto bitmapImage = BitmapImage::create();	81	auto bitmapImage = BitmapImage::create();
82	bitmapImage->setData(WTFMove(bufferToSanitize), true);	82	bitmapImage->setData(WTFMove(bufferToSanitize), true);
83	auto imageBuffer = ImageBuffer::create(bitmapImage->size(), RenderingMode::Unaccelerated, 1, DestinationColorSpace::SRGB(), PixelFormat::BGRA8);	83	auto imageBuffer = ImageBuffer::create(bitmapImage->size(), RenderingMode::Unaccelerated, 1, DestinationColorSpace::SRGB(), PixelFormat::BGRA8);

Lines 82-88 void RTCDataChannelRemoteHandler::readyToSend() a/Source/WebCore/Modules/mediastream/RTCDataChannelRemoteHandler.cpp_sec1
- a/Source/WebCore/Modules/mediastream/RTCDataChannelRemoteHandler.cpp -1 / +1 lines
82	m_isReadyToSend = true;	82	m_isReadyToSend = true;
83		83
84	for (auto& message : m_pendingMessages)	84	for (auto& message : m_pendingMessages)
85	m_connection->sendData(m_remoteIdentifier, message.isRaw, message.buffer->data(), message.buffer->size());	85	m_connection->sendData(m_remoteIdentifier, message.isRaw, message.buffer->makeContiguous()->data(), message.buffer->size());
86	m_pendingMessages.clear();	86	m_pendingMessages.clear();
87		87
88	if (m_isPendingClose)	88	if (m_isPendingClose)



class RTCDataChannelHandlerClient;
class RTCDataChannelRemoteHandlerConnection;
class RTCError;
class FragmentedSharedBuffer;

class RTCDataChannelRemoteHandler final : public RTCDataChannelHandler, public CanMakeWeakPtr<RTCDataChannelRemoteHandler> {
    WTF_MAKE_FAST_ALLOCATED;


    struct Message {
        bool isRaw { false };
        Ref<FragmentedSharedBuffer> buffer;
    };
    Vector<Message> m_pendingMessages;
    bool m_isPendingClose { false };



    m_contextIdentifier = contextIdentifier;

    for (auto& message : m_bufferedMessages) {
        switchOn(message, [&](Ref<FragmentedSharedBuffer>& data) {
            client.didReceiveRawData(data->makeContiguous()->data(), data->size());
        }, [&](String& text) {
            client.didReceiveStringData(text);
        }, [&](StateChange stateChange) {

Lines 82-88 private: a/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCDataChannelHandler.h_sec1
- a/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCDataChannelHandler.h -1 / +1 lines
82	RTCDataChannelState state;	82	RTCDataChannelState state;
83	std::optional<webrtc::RTCError> error;	83	std::optional<webrtc::RTCError> error;
84	};	84	};
85	using Message = std::variant<StateChange, String, Ref<SharedBuffer>>;	85	using Message = std::variant<StateChange, String, Ref<FragmentedSharedBuffer>>;
86	using PendingMessages = Vector<Message>;	86	using PendingMessages = Vector<Message>;
87	void storeMessage(PendingMessages&, const webrtc::DataBuffer&);	87	void storeMessage(PendingMessages&, const webrtc::DataBuffer&);
88	void processMessage(const webrtc::DataBuffer&);	88	void processMessage(const webrtc::DataBuffer&);




    m_sourceURL = url;

    m_data.reset();
    m_dataComplete = false;

    if (m_resource) {

        return;
    }

    m_data.empty();

    m_resource = resource.value();
    m_resource->addClient(*this);

void HTMLModelElement::dataReceived(CachedResource& resource, const uint8_t* data, int dataLength)
{
    ASSERT_UNUSED(resource, &resource == m_resource);
    m_data.append(data, dataLength);
    m_data->append(data, dataLength);
}

void HTMLModelElement::notifyFinished(CachedResource& resource, const NetworkLoadMetrics&)

    };

    if (resource.loadFailedOrCanceled()) {
        m_data.reset();

        invalidateResourceHandleAndUpdateRenderer();


    }

    m_dataComplete = true;
    m_model = Model::create(m_data.take()->makeContiguous().get(), resource.mimeType(), resource.url());

    invalidateResourceHandleAndUpdateRenderer();


Lines 133-139 private: a/Source/WebCore/Modules/model-element/HTMLModelElement.h_sec1
- a/Source/WebCore/Modules/model-element/HTMLModelElement.h -1 / +1 lines
133		133
134	URL m_sourceURL;	134	URL m_sourceURL;
135	CachedResourceHandle<CachedRawResource> m_resource;	135	CachedResourceHandle<CachedRawResource> m_resource;
136	RefPtr<SharedBuffer> m_data;	136	SharedBufferBuilder m_data;
137	RefPtr<Model> m_model;	137	RefPtr<Model> m_model;
138	UniqueRef<ReadyPromise> m_readyPromise;	138	UniqueRef<ReadyPromise> m_readyPromise;
139	bool m_dataComplete { false };	139	bool m_dataComplete { false };

Lines 104-110 static RetainPtr<NSURL> writeToTemporaryFile(WebCore::Model& modelSource) a/Source/WebCore/Modules/model-element/scenekit/SceneKitModelLoaderUSD.mm_sec1
- a/Source/WebCore/Modules/model-element/scenekit/SceneKitModelLoaderUSD.mm -1 / +1 lines
104	auto filePath = FileSystem::openTemporaryFile("ModelFile", fileHandle, ".usdz");	104	auto filePath = FileSystem::openTemporaryFile("ModelFile", fileHandle, ".usdz");
105	ASSERT(FileSystem::isHandleValid(fileHandle));	105	ASSERT(FileSystem::isHandleValid(fileHandle));
106		106
107	size_t byteCount = FileSystem::writeToFile(fileHandle, modelSource.data()->data(), modelSource.data()->size());	107	size_t byteCount = FileSystem::writeToFile(fileHandle, modelSource.data()->makeContiguous()->data(), modelSource.data()->size());
108	ASSERT_UNUSED(byteCount, byteCount == modelSource.data()->size());	108	ASSERT_UNUSED(byteCount, byteCount == modelSource.data()->size());
109	FileSystem::closeFile(fileHandle);	109	FileSystem::closeFile(fileHandle);
110		110

Lines 35-41 namespace WebCore { a/Source/WebCore/Modules/streams/ReadableStreamSink.h_sec1
- a/Source/WebCore/Modules/streams/ReadableStreamSink.h -1 / +1 lines
35		35
36	class BufferSource;	36	class BufferSource;
37	class ReadableStream;	37	class ReadableStream;
38	class SharedBuffer;	38	class FragmentedSharedBuffer;
39		39
40	class ReadableStreamSink : public RefCounted<ReadableStreamSink> {	40	class ReadableStreamSink : public RefCounted<ReadableStreamSink> {
41	public:	41	public:

Lines 51-63 public: a/Source/WebCore/bindings/js/ScriptBufferSourceProvider.h_sec1
- a/Source/WebCore/bindings/js/ScriptBufferSourceProvider.h -3 / +7 lines
51	if (m_scriptBuffer.isEmpty())	51	if (m_scriptBuffer.isEmpty())
52	return emptyString();	52	return emptyString();
53		53
		54	if (!m_contiguousBuffer && (!m_containsOnlyASCII \|\| *m_containsOnlyASCII))
		55	m_contiguousBuffer = m_scriptBuffer.buffer()->makeContiguous();
54	if (!m_containsOnlyASCII) {	56	if (!m_containsOnlyASCII) {
55	m_containsOnlyASCII = charactersAreAllASCII(m_scriptBuffer.buffer()->data(), m_scriptBuffer.buffer()->size());	57	m_containsOnlyASCII = charactersAreAllASCII(m_contiguousBuffer->data(), m_scriptBuffer.buffer()->size());
56	if (*m_containsOnlyASCII)	58	if (*m_containsOnlyASCII)
57	m_scriptHash = StringHasher::computeHashAndMaskTop8Bits(m_scriptBuffer.buffer()->data(), m_scriptBuffer.buffer()->size());	59	m_scriptHash = StringHasher::computeHashAndMaskTop8Bits(m_contiguousBuffer->data(), m_scriptBuffer.buffer()->size());
58	}	60	}
59	if (*m_containsOnlyASCII)	61	if (*m_containsOnlyASCII)
60	return { m_scriptBuffer.buffer()->data(), static_cast<unsigned>(m_scriptBuffer.buffer()->size()) };	62	return { m_contiguousBuffer->data(), static_cast<unsigned>(m_scriptBuffer.buffer()->size()) };
61		63
62	if (!m_cachedScriptString) {	64	if (!m_cachedScriptString) {
63	m_cachedScriptString = m_scriptBuffer.toString();	65	m_cachedScriptString = m_scriptBuffer.toString();
Lines 81-86 public: a/Source/WebCore/bindings/js/ScriptBufferSourceProvider.h_sec2
81	return;	83	return;
82		84
83	m_scriptBuffer = scriptBuffer;	85	m_scriptBuffer = scriptBuffer;
		86	m_contiguousBuffer = nullptr;
84	}	87	}
85		88
86	private:	89	private:
Lines 91-96 private: a/Source/WebCore/bindings/js/ScriptBufferSourceProvider.h_sec3
91	}	94	}
92		95
93	ScriptBuffer m_scriptBuffer;	96	ScriptBuffer m_scriptBuffer;
		97	mutable RefPtr<SharedBuffer> m_contiguousBuffer;
94	mutable unsigned m_scriptHash { 0 };	98	mutable unsigned m_scriptHash { 0 };
95	mutable String m_cachedScriptString;	99	mutable String m_cachedScriptString;
96	mutable std::optional<bool> m_containsOnlyASCII;	100	mutable std::optional<bool> m_containsOnlyASCII;

Lines 55-61 class DetachedOffscreenCanvas; a/Source/WebCore/bindings/js/SerializedScriptValue.h_sec1
- a/Source/WebCore/bindings/js/SerializedScriptValue.h -1 / +1 lines
55	class IDBValue;	55	class IDBValue;
56	class MessagePort;	56	class MessagePort;
57	class ImageBitmapBacking;	57	class ImageBitmapBacking;
58	class SharedBuffer;	58	class FragmentedSharedBuffer;
59	enum class SerializationReturnCode;	59	enum class SerializationReturnCode;
60		60
61	enum class SerializationErrorMode { NonThrowing, Throwing };	61	enum class SerializationErrorMode { NonThrowing, Throwing };




class CSSFontFace;
class CSSFontSelector;
class SharedBuffer;
class Document;
class Font;
class FontCreationContext;

struct FontSelectionSpecifiedCapabilities;
struct FontVariantSettings;
class SVGFontFaceElement;
class SharedBuffer;

template <typename T> class FontTaggedSettings;
typedef FontTaggedSettings<int> FontFeatureSettings;

Lines 402-408 struct PasteboardFileTypeReader final : PasteboardFileReader { a/Source/WebCore/dom/DataTransfer.cpp_sec1
- a/Source/WebCore/dom/DataTransfer.cpp -1 / +1 lines
402	types.add(File::contentTypeForFile(filename));	402	types.add(File::contentTypeForFile(filename));
403	}	403	}
404		404
405	void readBuffer(const String&, const String& type, Ref<SharedBuffer>&&)	405	void readBuffer(const String&, const String& type, Ref<FragmentedSharedBuffer>&&)
406	{	406	{
407	types.add(type);	407	types.add(type);
408	}	408	}

Lines 4133-4139 PromisedAttachmentInfo Editor::promisedAttachmentInfo(Element& element) a/Source/WebCore/editing/Editor.cpp_sec1
- a/Source/WebCore/editing/Editor.cpp -1 / +1 lines
4133	return { attachment->uniqueIdentifier(), WTFMove(additionalTypes), WTFMove(additionalData) };	4133	return { attachment->uniqueIdentifier(), WTFMove(additionalTypes), WTFMove(additionalData) };
4134	}	4134	}
4135		4135
4136	void Editor::registerAttachmentIdentifier(const String& identifier, const String& contentType, const String& preferredFileName, Ref<SharedBuffer>&& data)	4136	void Editor::registerAttachmentIdentifier(const String& identifier, const String& contentType, const String& preferredFileName, Ref<FragmentedSharedBuffer>&& data)
4137	{	4137	{
4138	if (auto* client = this->client())	4138	if (auto* client = this->client())
4139	client->registerAttachmentIdentifier(identifier, contentType, preferredFileName, WTFMove(data));	4139	client->registerAttachmentIdentifier(identifier, contentType, preferredFileName, WTFMove(data));




class AlternativeTextController;
class ArchiveResource;
class DataTransfer;
class CompositeEditCommand;
class SharedBuffer;
class CustomUndoStep;
class DataTransfer;
class DeleteButtonController;
class EditCommand;
class EditCommandComposition;

class Pasteboard;
class PasteboardWriterData;
class RenderLayer;
class FragmentedSharedBuffer;
class Font;
class SpellCheckRequest;
class SpellChecker;


#if ENABLE(ATTACHMENT_ELEMENT)
    WEBCORE_EXPORT void insertAttachment(const String& identifier, std::optional<uint64_t>&& fileSize, const String& fileName, const String& contentType);
    void registerAttachmentIdentifier(const String&, const String& contentType, const String& preferredFileName, Ref<FragmentedSharedBuffer>&& fileData);
    void registerAttachments(Vector<SerializedAttachmentData>&&);
    void registerAttachmentIdentifier(const String&, const String& contentType, const String& filePath);
    void registerAttachmentIdentifier(const String&);



    bool readFilePath(const String&, PresentationSize preferredPresentationSize = { }, const String& contentType = { }) override;
    bool readFilePaths(const Vector<String>&) override;
    bool readHTML(const String&) override;
    bool readImage(Ref<FragmentedSharedBuffer>&&, const String& type, PresentationSize preferredPresentationSize = { }) override;
    bool readURL(const URL&, const String& title) override;
    bool readPlainText(const String&) override;
#endif

#if PLATFORM(COCOA)
    bool readWebArchive(FragmentedSharedBuffer&) override;
    bool readRTFD(FragmentedSharedBuffer&) override;
    bool readRTF(FragmentedSharedBuffer&) override;
    bool readDataBuffer(FragmentedSharedBuffer&, const String& type, const String& name, PresentationSize preferredPresentationSize = { }) override;
#endif
};


    bool readFilePath(const String&, PresentationSize = { }, const String& = { }) override { return false; }
    bool readFilePaths(const Vector<String>&) override { return false; }
    bool readHTML(const String&) override;
    bool readImage(Ref<FragmentedSharedBuffer>&&, const String&, PresentationSize = { }) override { return false; }
    bool readURL(const URL&, const String&) override { return false; }
    bool readPlainText(const String&) override { return false; }
#endif

#if PLATFORM(COCOA)
    bool readWebArchive(FragmentedSharedBuffer&) override;
    bool readRTFD(FragmentedSharedBuffer&) override;
    bool readRTF(FragmentedSharedBuffer&) override;
    bool readDataBuffer(FragmentedSharedBuffer&, const String&, const String&, PresentationSize = { }) override { return false; }
#endif
};


Lines 39-45 void WebCorePasteboardFileReader::readFilename(const String& filename) a/Source/WebCore/editing/WebCorePasteboardFileReader.cpp_sec1
- a/Source/WebCore/editing/WebCorePasteboardFileReader.cpp -1 / +1 lines
39	files.append(File::create(context.get(), filename));	39	files.append(File::create(context.get(), filename));
40	}	40	}
41		41
42	void WebCorePasteboardFileReader::readBuffer(const String& filename, const String& type, Ref<SharedBuffer>&& buffer)	42	void WebCorePasteboardFileReader::readBuffer(const String& filename, const String& type, Ref<FragmentedSharedBuffer>&& buffer)
43	{	43	{
44	files.append(File::create(context.get(), Blob::create(context.get(), buffer->extractData(), type), filename));	44	files.append(File::create(context.get(), Blob::create(context.get(), buffer->extractData(), type), filename));
45	}	45	}

Lines 41-47 struct WebCorePasteboardFileReader final : PasteboardFileReader { a/Source/WebCore/editing/WebCorePasteboardFileReader.h_sec1
- a/Source/WebCore/editing/WebCorePasteboardFileReader.h -1 / +1 lines
41	~WebCorePasteboardFileReader();	41	~WebCorePasteboardFileReader();
42		42
43	void readFilename(const String&) final;	43	void readFilename(const String&) final;
44	void readBuffer(const String& filename, const String& type, Ref<SharedBuffer>&&) final;	44	void readBuffer(const String& filename, const String& type, Ref<FragmentedSharedBuffer>&&) final;
45		45
46	RefPtr<ScriptExecutionContext> context;	46	RefPtr<ScriptExecutionContext> context;
47	Vector<Ref<File>> files;	47	Vector<Ref<File>> files;



        if (auto resource = dataSource->subresource(url)) {
            auto& mimeType = resource->mimeType();
            if (!usePlaceholder || mimeType != "text/html") {
                fileWrapper = adoptNS([[NSFileWrapper alloc] initRegularFileWithContents:resource->data().makeContiguous()->createNSData().get()]);
                [fileWrapper setPreferredFilename:suggestedFilenameWithMIMEType(url, mimeType)];
            } else
                notFound = YES;


    if (dataSource) {
        if (RefPtr<ArchiveResource> resource = dataSource->subresource(URL)) {
            auto wrapper = adoptNS([[NSFileWrapper alloc] initRegularFileWithContents:resource->data().makeContiguous()->createNSData().get()]);
            NSString *filename = resource->response().suggestedFilename();
            if (!filename || ![filename length])
                filename = suggestedFilenameWithMIMEType(resource->url(), resource->mimeType());

static RetainPtr<NSFileWrapper> fileWrapperForElement(HTMLImageElement& element)
{
    if (CachedImage* cachedImage = element.cachedImage()) {
        if (FragmentedSharedBuffer* sharedBuffer = cachedImage->resourceBuffer())
            return adoptNS([[NSFileWrapper alloc] initRegularFileWithContents:sharedBuffer->makeContiguous()->createNSData().get()]);
    }

    auto* renderer = element.renderer();




#endif

static Ref<DocumentFragment> createFragmentForImageAttachment(Frame& frame, Document& document, Ref<FragmentedSharedBuffer>&& buffer, const String& contentType, PresentationSize preferredSize)
{
#if ENABLE(ATTACHMENT_ELEMENT)
    auto attachment = HTMLAttachmentElement::create(HTMLNames::attachmentTag, document);

            continue;

        auto& resource = resourceEntry->value;
        serializedAttachmentData.append({ attachment.uniqueIdentifier(), resource->mimeType(), resource->data().makeContiguous() });
    }

    if (!serializedAttachmentData.isEmpty())

        if (name.isEmpty())
            name = "media"_s;

        attachmentInsertionInfo.append({ WTFMove(name), resource->value->mimeType(), resource->value->data().makeContiguous(), image });
    }

    for (auto& object : descendantsOfType<HTMLObjectElement>(fragment)) {

        if (name.isEmpty())
            name = "file"_s;

        attachmentInsertionInfo.append({ WTFMove(name), resource->value->mimeType(), resource->value->data().makeContiguous(), object });
    }

    for (auto& info : attachmentInsertionInfo) {

    Ref<Archive> archive;
};

static std::optional<MarkupAndArchive> extractMarkupAndArchive(FragmentedSharedBuffer& buffer, const std::function<bool(const String)>& canShowMIMETypeAsHTML)
{
    auto archive = LegacyWebArchive::create(URL(), buffer);
    if (!archive)

    if (!canShowMIMETypeAsHTML(type))
        return std::nullopt;

    return MarkupAndArchive { String::fromUTF8(mainResource->data().makeContiguous()->data(), mainResource->data().size()), mainResource.releaseNonNull(), archive.releaseNonNull() };
}

static String sanitizeMarkupWithArchive(Frame& frame, Document& destinationDocument, MarkupAndArchive& markupAndArchive, MSOListQuirks msoListQuirks, const std::function<bool(const String)>& canShowMIMETypeAsHTML)

        if (!shouldReplaceSubresourceURL(subframeURL))
            continue;

        MarkupAndArchive subframeContent = { String::fromUTF8(subframeMainResource->data().makeContiguous()->data(), subframeMainResource->data().size()),
            subframeMainResource.releaseNonNull(), subframeArchive.copyRef() };
        auto subframeMarkup = sanitizeMarkupWithArchive(frame, destinationDocument, subframeContent, MSOListQuirks::Disabled, canShowMIMETypeAsHTML);


    return sanitizedMarkupForFragmentInDocument(WTFMove(fragment), *stagingDocument, msoListQuirks, markupAndArchive.markup);
}

bool WebContentReader::readWebArchive(FragmentedSharedBuffer& buffer)
{
    if (frame.settings().preferMIMETypeForImages() || !frame.document())
        return false;

    return true;
}

bool WebContentMarkupReader::readWebArchive(FragmentedSharedBuffer& buffer)
{
    if (!frame.document())
        return false;

    return !markup.isEmpty();
}

bool WebContentReader::readRTFD(FragmentedSharedBuffer& buffer)
{
    if (frame.settings().preferMIMETypeForImages() || !frame.document())
        return false;

    auto string = adoptNS([[NSAttributedString alloc] initWithRTFD:buffer.makeContiguous()->createNSData().get() documentAttributes:nullptr]);
    auto fragment = createFragmentAndAddResources(frame, string.get());
    if (!fragment)
        return false;

    return true;
}

bool WebContentMarkupReader::readRTFD(FragmentedSharedBuffer& buffer)
{
    if (!frame.document())
        return false;
    auto string = adoptNS([[NSAttributedString alloc] initWithRTFD:buffer.makeContiguous()->createNSData().get() documentAttributes:nullptr]);
    auto fragment = createFragmentAndAddResources(frame, string.get());
    if (!fragment)
        return false;

    return true;
}

bool WebContentReader::readRTF(FragmentedSharedBuffer& buffer)
{
    if (frame.settings().preferMIMETypeForImages())
        return false;

    auto string = adoptNS([[NSAttributedString alloc] initWithRTF:buffer.makeContiguous()->createNSData().get() documentAttributes:nullptr]);
    auto fragment = createFragmentAndAddResources(frame, string.get());
    if (!fragment)
        return false;

    return true;
}

bool WebContentMarkupReader::readRTF(FragmentedSharedBuffer& buffer)
{
    if (!frame.document())
        return false;
    auto string = adoptNS([[NSAttributedString alloc] initWithRTF:buffer.makeContiguous()->createNSData().get() documentAttributes:nullptr]);
    auto fragment = createFragmentAndAddResources(frame, string.get());
    if (!fragment)
        return false;

    return true;
}

bool WebContentReader::readImage(Ref<FragmentedSharedBuffer>&& buffer, const String& type, PresentationSize preferredPresentationSize)
{
    ASSERT(frame.document());
    auto& document = *frame.document();

    return attachment;
}

static Ref<HTMLElement> attachmentForData(Frame& frame, FragmentedSharedBuffer& buffer, const String& contentType, const String& name, PresentationSize preferredSize)
{
    Ref document = *frame.document();
    auto attachment = HTMLAttachmentElement::create(HTMLNames::attachmentTag, document);

    return true;
}

bool WebContentReader::readDataBuffer(FragmentedSharedBuffer& buffer, const String& type, const String& name, PresentationSize preferredPresentationSize)
{
    if (buffer.isEmpty())
        return false;

Lines 71-77 bool WebContentReader::readPlainText(const String& text) a/Source/WebCore/editing/gtk/WebContentReaderGtk.cpp_sec1
- a/Source/WebCore/editing/gtk/WebContentReaderGtk.cpp -1 / +1 lines
71	return true;	71	return true;
72	}	72	}
73		73
74	bool WebContentReader::readImage(Ref<SharedBuffer>&& buffer, const String& type, PresentationSize preferredPresentationSize)	74	bool WebContentReader::readImage(Ref<FragmentedSharedBuffer>&& buffer, const String& type, PresentationSize preferredPresentationSize)
75	{	75	{
76	ASSERT(frame.document());	76	ASSERT(frame.document());
77	auto& document = *frame.document();	77	auto& document = *frame.document();

Lines 53-59 class BlobLoader; a/Source/WebCore/fileapi/Blob.h_sec1
- a/Source/WebCore/fileapi/Blob.h -1 / +1 lines
53	class DeferredPromise;	53	class DeferredPromise;
54	class ReadableStream;	54	class ReadableStream;
55	class ScriptExecutionContext;	55	class ScriptExecutionContext;
56	class SharedBuffer;	56	class FragmentedSharedBuffer;
57		57
58	template<typename> class ExceptionOr;	58	template<typename> class ExceptionOr;
59		59

Lines 94-100 void NetworkSendQueue::processMessages() a/Source/WebCore/fileapi/NetworkSendQueue.cpp_sec1
- a/Source/WebCore/fileapi/NetworkSendQueue.cpp -1 / +1 lines
94	bool shouldStopProcessing = false;	94	bool shouldStopProcessing = false;
95	switchOn(m_queue.first(), [this](const CString& utf8) {	95	switchOn(m_queue.first(), [this](const CString& utf8) {
96	m_writeString(utf8);	96	m_writeString(utf8);
97	}, [this](Ref<SharedBuffer>& data) {	97	}, [this](Ref<FragmentedSharedBuffer>& data) {
98	data->forEachSegment(m_writeRawData);	98	data->forEachSegment(m_writeRawData);
99	}, [this, &shouldStopProcessing](UniqueRef<BlobLoader>& loader) {	99	}, [this, &shouldStopProcessing](UniqueRef<BlobLoader>& loader) {
100	auto errorCode = loader->errorCode();	100	auto errorCode = loader->errorCode();




class Blob;
class BlobLoader;
class FragmentedSharedBuffer;

class WEBCORE_EXPORT NetworkSendQueue : public ContextDestructionObserver {
public:

private:
    void processMessages();

    using Message = std::variant<CString, Ref<FragmentedSharedBuffer>, UniqueRef<BlobLoader>>;
    Deque<Message> m_queue;

    WriteString m_writeString;

Lines 227-233 static bool mimeTypeIsSuitableForInlineImageAttachment(const String& mimeType) a/Source/WebCore/html/HTMLAttachmentElement.cpp_sec1
- a/Source/WebCore/html/HTMLAttachmentElement.cpp -1 / +1 lines
227	return MIMETypeRegistry::isSupportedImageMIMEType(mimeType) \|\| MIMETypeRegistry::isPDFMIMEType(mimeType);	227	return MIMETypeRegistry::isSupportedImageMIMEType(mimeType) \|\| MIMETypeRegistry::isPDFMIMEType(mimeType);
228	}	228	}
229		229
230	void HTMLAttachmentElement::updateEnclosingImageWithData(const String& contentType, Ref<SharedBuffer>&& buffer)	230	void HTMLAttachmentElement::updateEnclosingImageWithData(const String& contentType, Ref<FragmentedSharedBuffer>&& buffer)
231	{	231	{
232	auto* hostElement = shadowHost();	232	auto* hostElement = shadowHost();
233	if (!is<HTMLImageElement>(hostElement) \|\| !buffer->size())	233	if (!is<HTMLImageElement>(hostElement) \|\| !buffer->size())



class HTMLImageElement;
class RenderAttachment;
class ShareableBitmap;
class FragmentedSharedBuffer;

class HTMLAttachmentElement final : public HTMLElement {
    WTF_MAKE_ISO_ALLOCATED(HTMLAttachmentElement);

    void copyNonAttributePropertiesFromElement(const Element&) final;

    WEBCORE_EXPORT void updateAttributes(std::optional<uint64_t>&& newFileSize, const String& newContentType, const String& newFilename);
    WEBCORE_EXPORT void updateEnclosingImageWithData(const String& contentType, Ref<FragmentedSharedBuffer>&& data);
    WEBCORE_EXPORT void updateThumbnail(const RefPtr<Image>& thumbnail);

    InsertedIntoAncestorResult insertedIntoAncestor(InsertionType, ContainerNode&) final;

Lines 2938-2944 void HTMLMediaElement::cdmClientAttemptToResumePlaybackIfNecessary() a/Source/WebCore/html/HTMLMediaElement.cpp_sec1
- a/Source/WebCore/html/HTMLMediaElement.cpp -1 / +1 lines
2938	attemptToResumePlaybackIfNecessary();	2938	attemptToResumePlaybackIfNecessary();
2939	}	2939	}
2940		2940
2941	void HTMLMediaElement::cdmClientUnrequestedInitializationDataReceived(const String& initDataType, Ref<SharedBuffer>&& initData)	2941	void HTMLMediaElement::cdmClientUnrequestedInitializationDataReceived(const String& initDataType, Ref<FragmentedSharedBuffer>&& initData)
2942	{	2942	{
2943	mediaPlayerInitializationDataEncountered(initDataType, initData->tryCreateArrayBuffer());	2943	mediaPlayerInitializationDataEncountered(initDataType, initData->tryCreateArrayBuffer());
2944	}	2944	}

Lines 720-726 private: a/Source/WebCore/html/HTMLMediaElement.h_sec1
- a/Source/WebCore/html/HTMLMediaElement.h -1 / +1 lines
720		720
721	// CDMClient	721	// CDMClient
722	void cdmClientAttemptToResumePlaybackIfNecessary() final;	722	void cdmClientAttemptToResumePlaybackIfNecessary() final;
723	void cdmClientUnrequestedInitializationDataReceived(const String&, Ref<SharedBuffer>&&) final;	723	void cdmClientUnrequestedInitializationDataReceived(const String&, Ref<FragmentedSharedBuffer>&&) final;
724	#endif	724	#endif
725		725
726	#if ENABLE(LEGACY_ENCRYPTED_MEDIA) && ENABLE(ENCRYPTED_MEDIA)	726	#if ENABLE(LEGACY_ENCRYPTED_MEDIA) && ENABLE(ENCRYPTED_MEDIA)



    if (!m_imageElement)
        createDocumentStructure();

    if (RefPtr<FragmentedSharedBuffer> buffer = loader()->mainResourceData())
        m_imageElement->cachedImage()->updateBuffer(*buffer);

    imageUpdated();

{
    if (!parser()->isStopped() && m_imageElement) {
        CachedImage& cachedImage = *m_imageElement->cachedImage();
        RefPtr<FragmentedSharedBuffer> data = loader()->mainResourceData();

        // If this is a multipart image, make a copy of the current part, since the resource data
        // will be overwritten by the next part.

Lines 850-856 void InspectorInstrumentation::interceptRequestImpl(InstrumentingAgents& instrum a/Source/WebCore/inspector/InspectorInstrumentation.cpp_sec1
- a/Source/WebCore/inspector/InspectorInstrumentation.cpp -1 / +1 lines
850	networkAgent->interceptRequest(loader, WTFMove(handler));	850	networkAgent->interceptRequest(loader, WTFMove(handler));
851	}	851	}
852		852
853	void InspectorInstrumentation::interceptResponseImpl(InstrumentingAgents& instrumentingAgents, const ResourceResponse& response, ResourceLoaderIdentifier identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&& handler)	853	void InspectorInstrumentation::interceptResponseImpl(InstrumentingAgents& instrumentingAgents, const ResourceResponse& response, ResourceLoaderIdentifier identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<FragmentedSharedBuffer>)>&& handler)
854	{	854	{
855	if (auto* networkAgent = instrumentingAgents.enabledNetworkAgent())	855	if (auto* networkAgent = instrumentingAgents.enabledNetworkAgent())
856	networkAgent->interceptResponse(response, identifier, WTFMove(handler));	856	networkAgent->interceptResponse(response, identifier, WTFMove(handler));



class ScriptExecutionContext;
class SecurityOrigin;
class ShadowRoot;
class FragmentedSharedBuffer;
class TimerBase;
class WebKitNamedFlow;
class WebSocketChannel;

    static bool shouldInterceptRequest(const Frame&, const ResourceRequest&);
    static bool shouldInterceptResponse(const Frame&, const ResourceResponse&);
    static void interceptRequest(ResourceLoader&, Function<void(const ResourceRequest&)>&&);
    static void interceptResponse(const Frame&, const ResourceResponse&, ResourceLoaderIdentifier, CompletionHandler<void(const ResourceResponse&, RefPtr<FragmentedSharedBuffer>)>&&);

    static void addMessageToConsole(Page&, std::unique_ptr<Inspector::ConsoleMessage>);
    static void addMessageToConsole(WorkerOrWorkletGlobalScope&, std::unique_ptr<Inspector::ConsoleMessage>);

    static bool shouldInterceptRequestImpl(InstrumentingAgents&, const ResourceRequest&);
    static bool shouldInterceptResponseImpl(InstrumentingAgents&, const ResourceResponse&);
    static void interceptRequestImpl(InstrumentingAgents&, ResourceLoader&, Function<void(const ResourceRequest&)>&&);
    static void interceptResponseImpl(InstrumentingAgents&, const ResourceResponse&, ResourceLoaderIdentifier, CompletionHandler<void(const ResourceResponse&, RefPtr<FragmentedSharedBuffer>)>&&);

    static void addMessageToConsoleImpl(InstrumentingAgents&, std::unique_ptr<Inspector::ConsoleMessage>);


        interceptRequestImpl(*agents, loader, WTFMove(handler));
}

inline void InspectorInstrumentation::interceptResponse(const Frame& frame, const ResourceResponse& response, ResourceLoaderIdentifier identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<FragmentedSharedBuffer>)>&& handler)
{
    ASSERT(InspectorInstrumentation::shouldInterceptResponse(frame, response));
    if (auto* agents = instrumentingAgents(frame))

Lines 45-51 void InspectorInstrumentationWebKit::interceptRequestInternal(ResourceLoader& lo a/Source/WebCore/inspector/InspectorInstrumentationWebKit.cpp_sec1
- a/Source/WebCore/inspector/InspectorInstrumentationWebKit.cpp -1 / +1 lines
45	InspectorInstrumentation::interceptRequest(loader, WTFMove(handler));	45	InspectorInstrumentation::interceptRequest(loader, WTFMove(handler));
46	}	46	}
47		47
48	void InspectorInstrumentationWebKit::interceptResponseInternal(const Frame& frame, const ResourceResponse& response, ResourceLoaderIdentifier identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&& handler)	48	void InspectorInstrumentationWebKit::interceptResponseInternal(const Frame& frame, const ResourceResponse& response, ResourceLoaderIdentifier identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<FragmentedSharedBuffer>)>&& handler)
49	{	49	{
50	InspectorInstrumentation::interceptResponse(frame, response, identifier, WTFMove(handler));	50	InspectorInstrumentation::interceptResponse(frame, response, identifier, WTFMove(handler));
51	}	51	}



class ResourceLoader;
class ResourceRequest;
class ResourceResponse;
class FragmentedSharedBuffer;

class WEBCORE_EXPORT InspectorInstrumentationWebKit {
public:
    static bool shouldInterceptRequest(const Frame*, const ResourceRequest&);
    static bool shouldInterceptResponse(const Frame*, const ResourceResponse&);
    static void interceptRequest(ResourceLoader&, Function<void(const ResourceRequest&)>&&);
    static void interceptResponse(const Frame*, const ResourceResponse&, ResourceLoaderIdentifier, CompletionHandler<void(const ResourceResponse&, RefPtr<FragmentedSharedBuffer>)>&&);

private:
    static bool shouldInterceptRequestInternal(const Frame&, const ResourceRequest&);
    static bool shouldInterceptResponseInternal(const Frame&, const ResourceResponse&);
    static void interceptRequestInternal(ResourceLoader&, Function<void(const ResourceRequest&)>&&);
    static void interceptResponseInternal(const Frame&, const ResourceResponse&, ResourceLoaderIdentifier, CompletionHandler<void(const ResourceResponse&, RefPtr<FragmentedSharedBuffer>)>&&);
};

inline bool InspectorInstrumentationWebKit::shouldInterceptRequest(const Frame* frame, const ResourceRequest& request)

    interceptRequestInternal(loader, WTFMove(handler));
}

inline void InspectorInstrumentationWebKit::interceptResponse(const Frame* frame, const ResourceResponse& response, ResourceLoaderIdentifier identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<FragmentedSharedBuffer>)>&& handler)
{
    ASSERT(InspectorInstrumentationWebKit::shouldInterceptResponse(frame, response));
    interceptResponseInternal(*frame, response, identifier, WTFMove(handler));

Lines 47-52 static const size_t maximumSingleResourceContentSize = 50 * 1000 * 1000; // 50MB a/Source/WebCore/inspector/NetworkResourcesData.cpp_sec1
- a/Source/WebCore/inspector/NetworkResourcesData.cpp -12 / +14 lines
47	NetworkResourcesData::ResourceData::ResourceData(const String& requestId, const String& loaderId)	47	NetworkResourcesData::ResourceData::ResourceData(const String& requestId, const String& loaderId)
48	: m_requestId(requestId)	48	: m_requestId(requestId)
49	, m_loaderId(loaderId)	49	, m_loaderId(loaderId)
		50	, m_dataBuffer(makeUniqueRef<SharedBufferBuilder>())
50	{	51	{
51	}	52	}
52		53
Lines 64-70 unsigned NetworkResourcesData::ResourceData::removeContent() a/Source/WebCore/inspector/NetworkResourcesData.cpp_sec2
64	if (hasData()) {	65	if (hasData()) {
65	ASSERT(!hasContent());	66	ASSERT(!hasContent());
66	result = m_dataBuffer->size();	67	result = m_dataBuffer->size();
67	m_dataBuffer = nullptr;	68	m_dataBuffer->reset();
68	}	69	}
69		70
70	if (hasContent()) {	71	if (hasContent()) {
Lines 81-116 unsigned NetworkResourcesData::ResourceData::evictContent() a/Source/WebCore/inspector/NetworkResourcesData.cpp_sec3
81	return removeContent();	82	return removeContent();
82	}	83	}
83		84
		85	bool NetworkResourcesData::ResourceData::hasData() const
		86	{
		87	return !m_dataBuffer->isNull();
		88	}
		89
84	size_t NetworkResourcesData::ResourceData::dataLength() const	90	size_t NetworkResourcesData::ResourceData::dataLength() const
85	{	91	{
86	return m_dataBuffer ? m_dataBuffer->size() : 0;	92	return m_dataBuffer->size();
87	}	93	}
88		94
89	void NetworkResourcesData::ResourceData::appendData(const uint8_t* data, size_t dataLength)	95	void NetworkResourcesData::ResourceData::appendData(const uint8_t* data, size_t dataLength)
90	{	96	{
91	ASSERT(!hasContent());	97	ASSERT(!hasContent());
92	if (!m_dataBuffer)	98	m_dataBuffer->append(data, dataLength);
93	m_dataBuffer = SharedBuffer::create(data, dataLength);
94	else
95	m_dataBuffer->append(data, dataLength);
96	}	99	}
97		100
98	unsigned NetworkResourcesData::ResourceData::decodeDataToContent()	101	unsigned NetworkResourcesData::ResourceData::decodeDataToContent()
99	{	102	{
100	ASSERT(!hasContent());	103	ASSERT(!hasContent());
101		104
102	size_t dataLength = m_dataBuffer->size();	105	auto buffer = m_dataBuffer->take()->makeContiguous();
		106	size_t dataLength = buffer->size();
103		107
104	if (m_decoder) {	108	if (m_decoder) {
105	m_base64Encoded = false;	109	m_base64Encoded = false;
106	m_content = m_decoder->decodeAndFlush(m_dataBuffer->data(), dataLength);	110	m_content = m_decoder->decodeAndFlush(buffer->data(), dataLength);
107	} else {	111	} else {
108	m_base64Encoded = true;	112	m_base64Encoded = true;
109	m_content = base64EncodeToString(m_dataBuffer->data(), dataLength);	113	m_content = base64EncodeToString(buffer->data(), dataLength);
110	}	114	}
111		115
112	m_dataBuffer = nullptr;
113
114	return m_content.sizeInBytes() - dataLength;	116	return m_content.sizeInBytes() - dataLength;
115	}	117	}
116		118
Lines 267-273 void NetworkResourcesData::addCachedResource(const String& requestId, CachedReso a/Source/WebCore/inspector/NetworkResourcesData.cpp_sec4
267	resourceData->setCachedResource(cachedResource);	269	resourceData->setCachedResource(cachedResource);
268	}	270	}
269		271
270	void NetworkResourcesData::addResourceSharedBuffer(const String& requestId, RefPtr<SharedBuffer>&& buffer, const String& textEncodingName)	272	void NetworkResourcesData::addResourceSharedBuffer(const String& requestId, RefPtr<FragmentedSharedBuffer>&& buffer, const String& textEncodingName)
271	{	273	{
272	ResourceData* resourceData = resourceDataForRequestId(requestId);	274	ResourceData* resourceData = resourceDataForRequestId(requestId);
273	if (!resourceData)	275	if (!resourceData)



#include "InspectorPageAgent.h"
#include <wtf/Deque.h>
#include <wtf/HashMap.h>
#include <wtf/UniqueRef.h>
#include <wtf/WallTime.h>
#include <wtf/text/WTFString.h>


class CachedResource;
class ResourceResponse;
class TextResourceDecoder;
class FragmentedSharedBuffer;
class SharedBufferBuilder;

class NetworkResourcesData {
    WTF_MAKE_FAST_ALLOCATED;

        RefPtr<TextResourceDecoder> decoder() const { return m_decoder.copyRef(); }
        void setDecoder(RefPtr<TextResourceDecoder>&& decoder) { m_decoder = WTFMove(decoder); }

        RefPtr<FragmentedSharedBuffer> buffer() const { return m_buffer.copyRef(); }
        void setBuffer(RefPtr<FragmentedSharedBuffer>&& buffer) { m_buffer = WTFMove(buffer); }

        const std::optional<CertificateInfo>& certificateInfo() const { return m_certificateInfo; }
        void setCertificateInfo(const std::optional<CertificateInfo>& certificateInfo) { m_certificateInfo = certificateInfo; }

        WallTime responseTimestamp() const { return m_responseTimestamp; }
        void setResponseTimestamp(WallTime time) { m_responseTimestamp = time; }

        bool hasBufferedData() const { return hasData(); }

    private:
        bool hasData() const;
        size_t dataLength() const;
        void appendData(const uint8_t* data, size_t dataLength);
        unsigned decodeDataToContent();

        String m_textEncodingName;
        String m_mimeType;
        RefPtr<TextResourceDecoder> m_decoder;
        UniqueRef<SharedBufferBuilder> m_dataBuffer;
        RefPtr<FragmentedSharedBuffer> m_buffer;
        std::optional<CertificateInfo> m_certificateInfo;
        CachedResource* m_cachedResource { nullptr };
        InspectorPageAgent::ResourceType m_type { InspectorPageAgent::OtherResource };

    ResourceData const* maybeAddResourceData(const String& requestId, const uint8_t* data, size_t dataLength);
    void maybeDecodeDataToContent(const String& requestId);
    void addCachedResource(const String& requestId, CachedResource*);
    void addResourceSharedBuffer(const String& requestId, RefPtr<FragmentedSharedBuffer>&&, const String& textEncodingName);
    ResourceData const* data(const String& requestId);
    ResourceData const* dataForURL(const String& url);
    Vector<String> removeCachedResource(CachedResource*);



    m_frontendDispatcher->requestIntercepted(requestId, buildObjectForResourceRequest(loader.request()));
}

void InspectorNetworkAgent::interceptResponse(const ResourceResponse& response, ResourceLoaderIdentifier identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<FragmentedSharedBuffer>)>&& handler)
{
    ASSERT(m_enabled);
    ASSERT(m_interceptionEnabled);

        overrideResponse.setHTTPHeaderField(HTTPHeaderName::ContentType, overrideResponse.mimeType());
    }

    RefPtr<FragmentedSharedBuffer> overrideData;
    if (base64Encoded) {
        auto buffer = base64Decode(content);
        if (!buffer)

    if (loader->reachedTerminalState())
        return makeUnexpected("Unable to fulfill request, it has already been processed"_s);

    RefPtr<FragmentedSharedBuffer> data;
    if (base64Encoded) {
        auto buffer = base64Decode(content);
        if (!buffer)

        if (InspectorNetworkAgent::shouldTreatAsText(resource.mimeType())) {
            auto decoder = InspectorNetworkAgent::createTextDecoder(resource.mimeType(), resource.response().textEncodingName());
            *base64Encoded = false;
            *result = decoder->decodeAndFlush(buffer->makeContiguous()->data(), buffer->size());
            return true;
        }

        *base64Encoded = true;
        *result = base64EncodeToString(buffer->makeContiguous()->data(), buffer->size());
        return true;
    }
}



    bool willIntercept(const ResourceRequest&);
    bool shouldInterceptRequest(const ResourceRequest&);
    bool shouldInterceptResponse(const ResourceResponse&);
    void interceptResponse(const ResourceResponse&, ResourceLoaderIdentifier, CompletionHandler<void(const ResourceResponse&, RefPtr<FragmentedSharedBuffer>)>&&);
    void interceptRequest(ResourceLoader&, Function<void(const ResourceRequest&)>&&);

    void searchOtherRequests(const JSC::Yarr::RegularExpression&, Ref<JSON::ArrayOf<Inspector::Protocol::Page::SearchResult>>&);

        WTF_MAKE_NONCOPYABLE(PendingInterceptResponse);
        WTF_MAKE_FAST_ALLOCATED;
    public:
        PendingInterceptResponse(const ResourceResponse& originalResponse, CompletionHandler<void(const ResourceResponse&, RefPtr<FragmentedSharedBuffer>)>&& completionHandler)
            : m_originalResponse(originalResponse)
            , m_completionHandler(WTFMove(completionHandler))
        { }

            respond(m_originalResponse, nullptr);
        }

        void respond(const ResourceResponse& response, RefPtr<FragmentedSharedBuffer> data)
        {
            ASSERT(!m_responded);
            if (m_responded)


    private:
        ResourceResponse m_originalResponse;
        CompletionHandler<void(const ResourceResponse&, RefPtr<FragmentedSharedBuffer>)> m_completionHandler;
        bool m_responded { false };
    };





bool InspectorPageAgent::mainResourceContent(Frame* frame, bool withBase64Encode, String* result)
{
    RefPtr<FragmentedSharedBuffer> buffer = frame->loader().documentLoader()->mainResourceData();
    if (!buffer)
        return false;
    return InspectorPageAgent::dataContent(buffer->makeContiguous()->data(), buffer->size(), frame->document()->encoding(), withBase64Encode, result);
}

bool InspectorPageAgent::sharedBufferContent(RefPtr<FragmentedSharedBuffer>&& buffer, const String& textEncodingName, bool withBase64Encode, String* result)
{
    return dataContent(buffer ? buffer->makeContiguous()->data() : nullptr, buffer ? buffer->size() : 0, textEncodingName, withBase64Encode, result);
}

bool InspectorPageAgent::dataContent(const uint8_t* data, unsigned size, const String& textEncodingName, bool withBase64Encode, String* result)

    if (!loader)
        return;

    RefPtr<FragmentedSharedBuffer> buffer;
    bool success = false;
    if (equalIgnoringFragmentIdentifier(url, loader->url())) {
        *base64Encoded = false;



class InspectorOverlay;
class Page;
class RenderObject;
class FragmentedSharedBuffer;

class InspectorPageAgent final : public InspectorAgentBase, public Inspector::PageBackendDispatcherHandler {
    WTF_MAKE_NONCOPYABLE(InspectorPageAgent);

        OtherResource,
    };

    static bool sharedBufferContent(RefPtr<FragmentedSharedBuffer>&&, const String& textEncodingName, bool withBase64Encode, String* result);
    static Vector<CachedResource*> cachedResourcesForFrame(Frame*);
    static void resourceContent(Inspector::Protocol::ErrorString&, Frame*, const URL&, String* result, bool* base64Encoded);
    static String sourceMapURLForResource(CachedResource*);



    ASSERT(m_state == State::Allowed);
    ASSERT(resource.dataBufferingPolicy() == DataBufferingPolicy::BufferData);
    if (auto* resourceBuffer = resource.resourceBuffer())
        m_client.dataReceivedThroughContentFilter(resourceBuffer->makeContiguous()->data(), resourceBuffer->size());
}

static const URL& blockedPageURL()

{
    ASSERT(willHandleProvisionalLoadFailure(error));

    RefPtr<FragmentedSharedBuffer> replacementData { m_blockingContentFilter->replacementData() };
    ResourceResponse response { URL(), "text/html"_s, static_cast<long long>(replacementData->size()), "UTF-8"_s };
    SubstituteData substituteData { WTFMove(replacementData), error.failingURL(), response, SubstituteData::SessionHistoryVisibility::Hidden };
    SetForScope<bool> loadingBlockedPage { m_isLoadingBlockedPage, true };



#endif
}

RefPtr<FragmentedSharedBuffer> DocumentLoader::mainResourceData() const
{
    if (m_substituteData.isValid())
        return m_substituteData.content()->copy();

    addAllArchiveResources(*m_archive);
    ASSERT(m_archive->mainResource());
    auto& mainResource = *m_archive->mainResource();
    m_parsedArchiveData = mainResource.data().makeContiguous();
    m_writer.setMIMEType(mainResource.mimeType());

    ASSERT(m_frame->document());
    commitData(m_parsedArchiveData->data(), mainResource.data().size());
    return true;
#endif
}


RefPtr<ArchiveResource> DocumentLoader::mainResource() const
{
    RefPtr<FragmentedSharedBuffer> data = mainResourceData();
    if (!data)
        data = SharedBuffer::create();
    auto& response = this->response();


    frameLoader()->setupForReplace();
    m_committed = false;
    RefPtr<FragmentedSharedBuffer> resourceData = mainResourceData();
    commitLoad(resourceData->makeContiguous()->data(), resourceData->size());
}

void DocumentLoader::startIconLoading()

    m_frame->loader().client().getLoadDecisionForIcons(iconDecisions);
}

void DocumentLoader::didGetLoadDecisionForIcon(bool decision, uint64_t loadIdentifier, CompletionHandler<void(FragmentedSharedBuffer*)>&& completionHandler)
{
    auto icon = m_iconsPendingLoadDecision.take(loadIdentifier);


    rawIconLoader->startLoading();
}

void DocumentLoader::finishedLoadingIcon(IconLoader& loader, FragmentedSharedBuffer* buffer)
{
    // If the DocumentLoader has detached from its frame, all icon loads should have already been cancelled.
    ASSERT(m_frame);



class CachedRawResource;
class CachedResourceLoader;
class ContentFilter;
class SharedBuffer;
struct CustomHeaderFields;
class FormState;
class Frame;

class Page;
class PreviewConverter;
class ResourceLoader;
class FragmentedSharedBuffer;
class SWClientConnection;
class SubresourceLoader;
class SubstituteResource;


    WEBCORE_EXPORT FrameLoader* frameLoader() const;
    WEBCORE_EXPORT SubresourceLoader* mainResourceLoader() const;
    WEBCORE_EXPORT RefPtr<FragmentedSharedBuffer> mainResourceData() const;
    
    DocumentWriter& writer() const { return m_writer; }


#endif

    void startIconLoading();
    WEBCORE_EXPORT void didGetLoadDecisionForIcon(bool decision, uint64_t loadIdentifier, CompletionHandler<void(FragmentedSharedBuffer*)>&&);
    void finishedLoadingIcon(IconLoader&, FragmentedSharedBuffer*);

    const Vector<LinkIcon>& linkIcons() const { return m_linkIcons; }


    bool m_waitingForNavigationPolicy { false };

    HashMap<uint64_t, LinkIcon> m_iconsPendingLoadDecision;
    HashMap<std::unique_ptr<IconLoader>, CompletionHandler<void(FragmentedSharedBuffer*)>> m_iconLoaders;
    Vector<LinkIcon> m_linkIcons;

#if ENABLE(APPLICATION_MANIFEST)



class CachedPage;
class CachedResource;
class Chrome;
class SharedBuffer;
class DOMWrapperWorld;
class Document;
class DocumentLoader;

class ResourceRequest;
class ResourceResponse;
class SerializedScriptValue;
class SharedBuffer;
class SubstituteData;

enum class CachePolicy : uint8_t;

Lines 98-104 class ResourceHandle; a/Source/WebCore/loader/FrameLoaderClient.h_sec1
- a/Source/WebCore/loader/FrameLoaderClient.h -1 / +1 lines
98	class ResourceRequest;	98	class ResourceRequest;
99	class ResourceResponse;	99	class ResourceResponse;
100	class SecurityOrigin;	100	class SecurityOrigin;
101	class SharedBuffer;	101	class FragmentedSharedBuffer;
102	class SubstituteData;	102	class SubstituteData;
103	class Widget;	103	class Widget;
104		104

Lines 51-57 class ResourceLoader; a/Source/WebCore/loader/LoaderStrategy.h_sec1
- a/Source/WebCore/loader/LoaderStrategy.h -1 / +1 lines
51	class ResourceRequest;	51	class ResourceRequest;
52	class ResourceResponse;	52	class ResourceResponse;
53	class SecurityOrigin;	53	class SecurityOrigin;
54	class SharedBuffer;	54	class FragmentedSharedBuffer;
55	class SubresourceLoader;	55	class SubresourceLoader;
56		56
57	struct FetchOptions;	57	struct FetchOptions;



    didReceiveDataOrBuffer(data, length, nullptr, encodedDataLength, dataPayloadType);
}

void NetscapePlugInStreamLoader::didReceiveBuffer(Ref<FragmentedSharedBuffer>&& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)
{
    didReceiveDataOrBuffer(nullptr, 0, WTFMove(buffer), encodedDataLength, dataPayloadType);
}

void NetscapePlugInStreamLoader::didReceiveDataOrBuffer(const uint8_t* data, int length, RefPtr<FragmentedSharedBuffer>&& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)
{
    Ref<NetscapePlugInStreamLoader> protectedThis(*this);




    void willSendRequest(ResourceRequest&&, const ResourceResponse& redirectResponse, CompletionHandler<void(ResourceRequest&&)>&& callback) override;
    void didReceiveResponse(const ResourceResponse&, CompletionHandler<void()>&& policyCompletionHandler) override;
    void didReceiveData(const uint8_t*, unsigned, long long encodedDataLength, DataPayloadType) override;
    void didReceiveBuffer(Ref<FragmentedSharedBuffer>&&, long long encodedDataLength, DataPayloadType) override;
    void didFinishLoading(const NetworkLoadMetrics&) override;
    void didFail(const ResourceError&) override;


    void willCancel(const ResourceError&) override;
    void didCancel(const ResourceError&) override;

    void didReceiveDataOrBuffer(const uint8_t*, int, RefPtr<FragmentedSharedBuffer>&&, long long encodedDataLength, DataPayloadType);

    void notifyDone();


Lines 155-161 ResourceCryptographicDigest cryptographicDigestForBytes(ResourceCryptographicDig a/Source/WebCore/loader/ResourceCryptographicDigest.cpp_sec1
- a/Source/WebCore/loader/ResourceCryptographicDigest.cpp -1 / +1 lines
155	return { algorithm, cryptoDigest->computeHash() };	155	return { algorithm, cryptoDigest->computeHash() };
156	}	156	}
157		157
158	ResourceCryptographicDigest cryptographicDigestForSharedBuffer(ResourceCryptographicDigest::Algorithm algorithm, const SharedBuffer* buffer)	158	ResourceCryptographicDigest cryptographicDigestForSharedBuffer(ResourceCryptographicDigest::Algorithm algorithm, const FragmentedSharedBuffer* buffer)
159	{	159	{
160	auto cryptoDigest = PAL::CryptoDigest::create(toCryptoDigestAlgorithm(algorithm));	160	auto cryptoDigest = PAL::CryptoDigest::create(toCryptoDigestAlgorithm(algorithm));
161	if (buffer) {	161	if (buffer) {



namespace WebCore {

class CachedResource;
class FragmentedSharedBuffer;

struct ResourceCryptographicDigest {
    enum class Algorithm {


std::optional<ResourceCryptographicDigest> decodeEncodedResourceCryptographicDigest(const EncodedResourceCryptographicDigest&);

ResourceCryptographicDigest cryptographicDigestForSharedBuffer(ResourceCryptographicDigest::Algorithm, const FragmentedSharedBuffer*);
ResourceCryptographicDigest cryptographicDigestForBytes(ResourceCryptographicDigest::Algorithm, const void* bytes, size_t length);

}



ResourceLoader::ResourceLoader(Frame& frame, ResourceLoaderOptions options)
    : m_frame { &frame }
    , m_documentLoader { frame.loader().activeDocumentLoader() }
    , m_resourceData { makeUniqueRef<SharedBufferBuilder>() }
    , m_defersLoading { options.defersLoadingPolicy == DefersLoadingPolicy::AllowDefersLoading && frame.page()->defersLoading() }
    , m_options { options }
{


    m_identifier = { };

    m_resourceData->reset();
    m_deferredRequest = ResourceRequest();
}


    });
}

void ResourceLoader::deliverResponseAndData(const ResourceResponse& response, RefPtr<FragmentedSharedBuffer>&& buffer)
{
    didReceiveResponse(response, [this, protectedThis = Ref { *this }, buffer = WTFMove(buffer)]() mutable {
        if (reachedTerminalState())


    // Reset any already buffered data
    if (dataBufferingPolicy == DataBufferingPolicy::DoNotBufferData)
        m_resourceData->reset();
}

void ResourceLoader::willSwitchToSubstituteResource()

        m_handle->cancel();
}

void ResourceLoader::addDataOrBuffer(const uint8_t* data, unsigned length, FragmentedSharedBuffer* buffer, DataPayloadType dataPayloadType)
{
    if (m_options.dataBufferingPolicy == DataBufferingPolicy::DoNotBufferData)
        return;

    if (dataPayloadType == DataPayloadWholeResource)
        m_resourceData->reset();

        else
            m_resourceData = SharedBuffer::create(data, length);
        return;
    }
    
    if (buffer)
        m_resourceData->append(*buffer);
    else
        m_resourceData->append(data, length);
}

const FragmentedSharedBuffer* ResourceLoader::resourceData() const
{
    return m_resourceData->get().get();
}

void ResourceLoader::clearResourceData()
{
    if (!m_resourceData->isNull())
        m_resourceData->empty();
}

bool ResourceLoader::isSubresourceLoader() const

    didReceiveDataOrBuffer(data, length, nullptr, encodedDataLength, dataPayloadType);
}

void ResourceLoader::didReceiveBuffer(Ref<FragmentedSharedBuffer>&& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)
{
    didReceiveDataOrBuffer(nullptr, 0, WTFMove(buffer), encodedDataLength, dataPayloadType);
}

void ResourceLoader::didReceiveDataOrBuffer(const uint8_t* data, unsigned length, RefPtr<FragmentedSharedBuffer>&& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)
{
    // This method should only get data+length *OR* a FragmentedSharedBuffer.
    ASSERT(!buffer || (!data && !length));

    // Protect this in this delegate method since the additional processing can do

    // However, with today's computers and networking speeds, this won't happen in practice.
    // Could be an issue with a giant local file.
    if (m_options.sendLoadCallbacks == SendCallbackPolicy::SendCallbacks && m_frame)
        frameLoader()->notifier().didReceiveData(this, buffer ? buffer->makeContiguous()->data() : data, buffer ? buffer->size() : length, static_cast<int>(encodedDataLength));
}

void ResourceLoader::didFinishLoading(const NetworkLoadMetrics& networkLoadMetrics)

    didReceiveData(data, length, encodedDataLength, DataPayloadBytes);
}

void ResourceLoader::didReceiveBuffer(ResourceHandle*, Ref<FragmentedSharedBuffer>&& buffer, int encodedDataLength)
{
    didReceiveBuffer(WTFMove(buffer), encodedDataLength, DataPayloadBytes);
}

Lines 36-41 a/Source/WebCore/loader/ResourceLoader.h_sec1
- a/Source/WebCore/loader/ResourceLoader.h -7 / +10 lines
36	#include "ResourceRequest.h"	36	#include "ResourceRequest.h"
37	#include "ResourceResponse.h"	37	#include "ResourceResponse.h"
38	#include <wtf/Forward.h>	38	#include <wtf/Forward.h>
		39	#include <wtf/UniqueRef.h>
39	#include <wtf/WeakPtr.h>	40	#include <wtf/WeakPtr.h>
40		41
41	#if ENABLE(CONTENT_EXTENSIONS)	42	#if ENABLE(CONTENT_EXTENSIONS)
Lines 55-60 class Frame; a/Source/WebCore/loader/ResourceLoader.h_sec2
55	class FrameLoader;	56	class FrameLoader;
56	class LegacyPreviewLoader;	57	class LegacyPreviewLoader;
57	class NetworkLoadMetrics;	58	class NetworkLoadMetrics;
		59	class FragmentedSharedBuffer;
		60	class SharedBufferBuilder;
58		61
59	DECLARE_ALLOCATOR_WITH_HEAP_IDENTIFIER(ResourceLoader);	62	DECLARE_ALLOCATOR_WITH_HEAP_IDENTIFIER(ResourceLoader);
60	class ResourceLoader : public CanMakeWeakPtr<ResourceLoader>, public RefCounted<ResourceLoader>, protected ResourceHandleClient {	63	class ResourceLoader : public CanMakeWeakPtr<ResourceLoader>, public RefCounted<ResourceLoader>, protected ResourceHandleClient {
Lines 66-72 public: a/Source/WebCore/loader/ResourceLoader.h_sec3
66		69
67	virtual void init(ResourceRequest&&, CompletionHandler<void(bool)>&&);	70	virtual void init(ResourceRequest&&, CompletionHandler<void(bool)>&&);
68		71
69	void deliverResponseAndData(const ResourceResponse&, RefPtr<SharedBuffer>&&);	72	void deliverResponseAndData(const ResourceResponse&, RefPtr<FragmentedSharedBuffer>&&);
70		73
71	#if PLATFORM(IOS_FAMILY)	74	#if PLATFORM(IOS_FAMILY)
72	virtual void startLoading()	75	virtual void startLoading()
Lines 98-104 public: a/Source/WebCore/loader/ResourceLoader.h_sec4
98	virtual void releaseResources();	101	virtual void releaseResources();
99	const ResourceResponse& response() const { return m_response; }	102	const ResourceResponse& response() const { return m_response; }
100		103
101	SharedBuffer* resourceData() const { return m_resourceData.get(); }	104	const FragmentedSharedBuffer* resourceData() const;
102	void clearResourceData();	105	void clearResourceData();
103		106
104	virtual bool isSubresourceLoader() const;	107	virtual bool isSubresourceLoader() const;
Lines 107-113 public: a/Source/WebCore/loader/ResourceLoader.h_sec5
107	virtual void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent);	110	virtual void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent);
108	virtual void didReceiveResponse(const ResourceResponse&, CompletionHandler<void()>&& policyCompletionHandler);	111	virtual void didReceiveResponse(const ResourceResponse&, CompletionHandler<void()>&& policyCompletionHandler);
109	virtual void didReceiveData(const uint8_t*, unsigned, long long encodedDataLength, DataPayloadType);	112	virtual void didReceiveData(const uint8_t*, unsigned, long long encodedDataLength, DataPayloadType);
110	virtual void didReceiveBuffer(Ref<SharedBuffer>&&, long long encodedDataLength, DataPayloadType);	113	virtual void didReceiveBuffer(Ref<FragmentedSharedBuffer>&&, long long encodedDataLength, DataPayloadType);
111	virtual void didFinishLoading(const NetworkLoadMetrics&);	114	virtual void didFinishLoading(const NetworkLoadMetrics&);
112	virtual void didFail(const ResourceError&);	115	virtual void didFail(const ResourceError&);
113		116
Lines 166-172 protected: a/Source/WebCore/loader/ResourceLoader.h_sec6
166		169
167	bool wasCancelled() const { return m_cancellationStatus >= Cancelled; }	170	bool wasCancelled() const { return m_cancellationStatus >= Cancelled; }
168		171
169	void didReceiveDataOrBuffer(const uint8_t*, unsigned, RefPtr<SharedBuffer>&&, long long encodedDataLength, DataPayloadType);	172	void didReceiveDataOrBuffer(const uint8_t*, unsigned, RefPtr<FragmentedSharedBuffer>&&, long long encodedDataLength, DataPayloadType);
170		173
171	void setReferrerPolicy(ReferrerPolicy referrerPolicy) { m_options.referrerPolicy = referrerPolicy; }	174	void setReferrerPolicy(ReferrerPolicy referrerPolicy) { m_options.referrerPolicy = referrerPolicy; }
172	ReferrerPolicy referrerPolicy() const { return m_options.referrerPolicy; }	175	ReferrerPolicy referrerPolicy() const { return m_options.referrerPolicy; }
Lines 191-197 private: a/Source/WebCore/loader/ResourceLoader.h_sec7
191	virtual void willCancel(const ResourceError&) = 0;	194	virtual void willCancel(const ResourceError&) = 0;
192	virtual void didCancel(const ResourceError&) = 0;	195	virtual void didCancel(const ResourceError&) = 0;
193		196
194	void addDataOrBuffer(const uint8_t, unsigned, SharedBuffer, DataPayloadType);	197	void addDataOrBuffer(const uint8_t, unsigned, FragmentedSharedBuffer, DataPayloadType);
195	void loadDataURL();	198	void loadDataURL();
196	void finishNetworkLoad();	199	void finishNetworkLoad();
197		200
Lines 202-208 private: a/Source/WebCore/loader/ResourceLoader.h_sec8
202	void didReceiveResponseAsync(ResourceHandle*, ResourceResponse&&, CompletionHandler<void()>&&) override;	205	void didReceiveResponseAsync(ResourceHandle*, ResourceResponse&&, CompletionHandler<void()>&&) override;
203	void willSendRequestAsync(ResourceHandle*, ResourceRequest&&, ResourceResponse&&, CompletionHandler<void(ResourceRequest&&)>&&) override;	206	void willSendRequestAsync(ResourceHandle*, ResourceRequest&&, ResourceResponse&&, CompletionHandler<void(ResourceRequest&&)>&&) override;
204	void didReceiveData(ResourceHandle, const uint8_t, unsigned, int encodedDataLength) override;	207	void didReceiveData(ResourceHandle, const uint8_t, unsigned, int encodedDataLength) override;
205	void didReceiveBuffer(ResourceHandle*, Ref<SharedBuffer>&&, int encodedDataLength) override;	208	void didReceiveBuffer(ResourceHandle*, Ref<FragmentedSharedBuffer>&&, int encodedDataLength) override;
206	void didFinishLoading(ResourceHandle*, const NetworkLoadMetrics&) override;	209	void didFinishLoading(ResourceHandle*, const NetworkLoadMetrics&) override;
207	void didFail(ResourceHandle*, const ResourceError&) override;	210	void didFail(ResourceHandle*, const ResourceError&) override;
208	void wasBlocked(ResourceHandle*) override;	211	void wasBlocked(ResourceHandle*) override;
Lines 227-233 private: a/Source/WebCore/loader/ResourceLoader.h_sec9
227		230
228	ResourceRequest m_request;	231	ResourceRequest m_request;
229	ResourceRequest m_originalRequest; // Before redirects.	232	ResourceRequest m_originalRequest; // Before redirects.
230	RefPtr<SharedBuffer> m_resourceData;	233	UniqueRef<SharedBufferBuilder> m_resourceData;
231		234
232	ResourceLoaderIdentifier m_identifier;	235	ResourceLoaderIdentifier m_identifier;
233		236



    didReceiveDataOrBuffer(data, length, nullptr, encodedDataLength, dataPayloadType);
}

void SubresourceLoader::didReceiveBuffer(Ref<FragmentedSharedBuffer>&& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)
{
#if USE(QUICK_LOOK)
    if (auto previewLoader = m_previewLoader.get()) {

    didReceiveDataOrBuffer(nullptr, 0, WTFMove(buffer), encodedDataLength, dataPayloadType);
}

void SubresourceLoader::didReceiveDataOrBuffer(const uint8_t* data, int length, RefPtr<FragmentedSharedBuffer>&& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)
{
    ASSERT(m_resource);


        if (auto* resourceData = this->resourceData())
            m_resource->updateBuffer(*resourceData);
        else
            m_resource->updateData(buffer ? buffer->makeContiguous()->data() : data, buffer ? buffer->size() : length);
    }
}




    void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent) override;
    void didReceiveResponse(const ResourceResponse&, CompletionHandler<void()>&& policyCompletionHandler) override;
    void didReceiveData(const uint8_t*, unsigned, long long encodedDataLength, DataPayloadType) override;
    void didReceiveBuffer(Ref<FragmentedSharedBuffer>&&, long long encodedDataLength, DataPayloadType) override;
    void didFinishLoading(const NetworkLoadMetrics&) override;
    void didFail(const ResourceError&) override;
    void willCancel(const ResourceError&) override;

    Expected<void, String> checkResponseCrossOriginAccessControl(const ResourceResponse&);
    Expected<void, String> checkRedirectionCrossOriginAccessControl(const ResourceRequest& previousRequest, const ResourceResponse&, ResourceRequest& newRequest);

    void didReceiveDataOrBuffer(const uint8_t*, int, RefPtr<FragmentedSharedBuffer>&&, long long encodedDataLength, DataPayloadType);

    void notifyDone(LoadCompletionType);




        {
        }

        SubstituteData(RefPtr<FragmentedSharedBuffer>&& content, const URL& failingURL, const ResourceResponse& response, SessionHistoryVisibility shouldRevealToSessionHistory)
            : m_content(WTFMove(content))
            , m_failingURL(failingURL)
            , m_response(response)

        bool isValid() const { return m_content != nullptr; }
        bool shouldRevealToSessionHistory() const { return m_shouldRevealToSessionHistory == SessionHistoryVisibility::Visible; }

        const FragmentedSharedBuffer* content() const { return m_content.get(); }
        const String& mimeType() const { return m_response.mimeType(); }
        const String& textEncoding() const { return m_response.textEncodingName(); }
        const URL& failingURL() const { return m_failingURL; }
        const ResourceResponse& response() const { return m_response; }
        
    private:
        RefPtr<FragmentedSharedBuffer> m_content;
        URL m_failingURL;
        ResourceResponse m_response;
        SessionHistoryVisibility m_shouldRevealToSessionHistory { SessionHistoryVisibility::Hidden };




    const URL& url() const { return m_url; }
    const ResourceResponse& response() const { return m_response; }
    FragmentedSharedBuffer& data() const { return static_reference_cast<FragmentedSharedBuffer>(Ref { *m_data.get() }); }
    void append(const uint8_t* data, int length) { m_data.append(data, length); }
    void clear() { m_data.empty(); }

    virtual void deliver(ResourceLoader& loader) { loader.deliverResponseAndData(m_response, m_data.copy()); }

protected:
    SubstituteResource(URL&& url, ResourceResponse&& response, Ref<FragmentedSharedBuffer>&& data)
        : m_url(WTFMove(url))
        , m_response(WTFMove(response))
        , m_data(WTFMove(data))

private:
    URL m_url;
    ResourceResponse m_response;
    SharedBufferBuilder m_data;
};

} // namespace WebCore

Lines 605-611 void ApplicationCacheGroup::didFinishLoadingManifest() a/Source/WebCore/loader/appcache/ApplicationCacheGroup.cpp_sec1
- a/Source/WebCore/loader/appcache/ApplicationCacheGroup.cpp -1 / +1 lines
605	}	605	}
606	}	606	}
607		607
608	auto manifest = parseApplicationCacheManifest(m_manifestURL, m_manifestResource->response().mimeType(), m_manifestResource->data().data(), m_manifestResource->data().size());	608	auto manifest = parseApplicationCacheManifest(m_manifestURL, m_manifestResource->response().mimeType(), m_manifestResource->data().makeContiguous()->data(), m_manifestResource->data().size());
609	if (!manifest) {	609	if (!manifest) {
610	// At the time of this writing, lack of "CACHE MANIFEST" signature is the only reason for parseManifest to fail.	610	// At the time of this writing, lack of "CACHE MANIFEST" signature is the only reason for parseManifest to fail.
611	m_frame->document()->addConsoleMessage(MessageSource::AppCache, MessageLevel::Error, "Application Cache manifest could not be parsed. Does it start with CACHE MANIFEST?"_s);	611	m_frame->document()->addConsoleMessage(MessageSource::AppCache, MessageLevel::Error, "Application Cache manifest could not be parsed. Does it start with CACHE MANIFEST?"_s);




static inline RefPtr<SharedBuffer> bufferFromResource(ApplicationCacheResource& resource)
{
    // FIXME: Clients probably do not need a copy of the SharedBuffer.
    // Remove the call to copy() once we ensure SharedBuffer will not be modified.
    if (resource.path().isEmpty())
        return resource.data().makeContiguous();
    return SharedBuffer::createWithContentsOfFile(resource.path());
}


        ApplicationCacheResource* resource;
        if (getApplicationCacheFallbackResource(request, resource)) {
            response = resource->response();
            data = resource->data().makeContiguous();
            // Remove the call to copy() once we ensure SharedBuffer will not be modified.
            data = resource->data().copy();
        }
    }
}



class ApplicationCacheGroup;
class ApplicationCacheResource;
class ApplicationCacheStorage;
class SharedBuffer;
class DOMApplicationCache;
class DocumentLoader;
class Frame;

class ResourceLoader;
class ResourceRequest;
class ResourceResponse;
class SharedBuffer;
class SubstituteData;

class ApplicationCacheHost {




namespace WebCore {

Ref<ApplicationCacheResource> ApplicationCacheResource::create(const URL& url, const ResourceResponse& response, unsigned type, RefPtr<FragmentedSharedBuffer>&& buffer, const String& path)
{
    ASSERT(!url.hasFragmentIdentifier());
    if (!buffer)

    return adoptRef(*new ApplicationCacheResource(URL { url }, WTFMove(resourceResponse), type, buffer.releaseNonNull(), path));
}

ApplicationCacheResource::ApplicationCacheResource(URL&& url, ResourceResponse&& response, unsigned type, Ref<FragmentedSharedBuffer>&& data, const String& path)
    : SubstituteResource(WTFMove(url), WTFMove(response), WTFMove(data))
    , m_type(type)
    , m_storageID(0)


void ApplicationCacheResource::deliver(ResourceLoader& loader)
{
    loader.deliverResponseAndData(response(), m_path.isEmpty() ? data().makeContiguous() : SharedBuffer::createWithContentsOfFile(m_path));
}

void ApplicationCacheResource::addType(unsigned type) 



        Fallback = 1 << 4
    };

    static Ref<ApplicationCacheResource> create(const URL&, const ResourceResponse&, unsigned type, RefPtr<FragmentedSharedBuffer>&& = SharedBuffer::create(), const String& path = String());

    unsigned type() const { return m_type; }
    void addType(unsigned type);

#endif
    
private:
    ApplicationCacheResource(URL&&, ResourceResponse&&, unsigned type, Ref<FragmentedSharedBuffer>&&, const String& path);

    void deliver(ResourceLoader&) override;


Lines 101-107 void ApplicationCacheResourceLoader::responseReceived(CachedResource& resource, a/Source/WebCore/loader/appcache/ApplicationCacheResourceLoader.cpp_sec1
- a/Source/WebCore/loader/appcache/ApplicationCacheResourceLoader.cpp -1 / +1 lines
101		101
102	void ApplicationCacheResourceLoader::dataReceived(CachedResource&, const uint8_t* data, int length)	102	void ApplicationCacheResourceLoader::dataReceived(CachedResource&, const uint8_t* data, int length)
103	{	103	{
104	m_applicationCacheResource->data().append(data, length);	104	m_applicationCacheResource->append(data, length);
105	}	105	}
106		106
107	void ApplicationCacheResourceLoader::redirectReceived(CachedResource&, ResourceRequest&& newRequest, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&& callback)	107	void ApplicationCacheResourceLoader::redirectReceived(CachedResource&, ResourceRequest&& newRequest, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&& callback)



    auto dataStatement = m_database.prepareStatement("INSERT INTO CacheResourceData (data, path) VALUES (?, ?)"_s);
    if (!dataStatement)
        return false;
    

    String fullPath;
    if (!resource->path().isEmpty())

        dataStatement->bindText(2, path);
    } else {
        if (resource->data().size())
            dataStatement->bindBlob(1, resource->data().makeContiguous().get());
    }
    
    if (!dataStatement->executeCommand()) {

    
    if (!executeStatement(entryStatement.value()))
        return false;

    // Did we successfully write the resource data to a file? If so,
    // release the resource's data and free up a potentially large amount
    // of memory:
    if (!fullPath.isEmpty())
        resource->clear();

    resource->setStorageID(resourceId);
    return true;

    return startsWithLettersIgnoringASCIICase(type, "audio/") || startsWithLettersIgnoringASCIICase(type, "video/");
}
    
bool ApplicationCacheStorage::writeDataToUniqueFileInDirectory(FragmentedSharedBuffer& data, const String& directory, String& path, const String& fileExtension)
{
    String fullPath;
    



class ApplicationCacheHost;
class ApplicationCacheResource;
class SecurityOrigin;
class FragmentedSharedBuffer;
template<typename> class StorageIDJournal;

class ApplicationCacheStorage : public RefCounted<ApplicationCacheStorage> {

    bool ensureOriginRecord(const SecurityOrigin*);
    static bool shouldStoreResourceAsFlatFile(ApplicationCacheResource*);
    void deleteTables();
    bool writeDataToUniqueFileInDirectory(FragmentedSharedBuffer&, const String& directory, String& outFilename, const String& fileExtension);

    void loadManifestHostHashes();
    




namespace WebCore {

typedef RefPtr<Archive> RawDataCreationFunction(const URL&, FragmentedSharedBuffer&);
typedef HashMap<String, RawDataCreationFunction*, ASCIICaseInsensitiveHash> ArchiveMIMETypesMap;

// The create functions in the archive classes return RefPtr to concrete subclasses
// of Archive. This adaptor makes the functions have a uniform return type.
template<typename ArchiveClass> static RefPtr<Archive> archiveFactoryCreate(const URL& url, FragmentedSharedBuffer& buffer)
{
    return ArchiveClass::create(url, buffer);
}

    return !mimeType.isEmpty() && archiveMIMETypes().contains(mimeType);
}

RefPtr<Archive> ArchiveFactory::create(const URL& url, FragmentedSharedBuffer* data, const String& mimeType)
{
    if (!data)
        return nullptr;




namespace WebCore {

class FragmentedSharedBuffer;

class ArchiveFactory {
public:
    static bool isArchiveMIMEType(const String&);
    static RefPtr<Archive> create(const URL&, FragmentedSharedBuffer* data, const String& mimeType);
    static void registerKnownArchiveMIMETypes(HashSet<String, ASCIICaseInsensitiveHash>&);
};





namespace WebCore {

inline ArchiveResource::ArchiveResource(Ref<FragmentedSharedBuffer>&& data, const URL& url, const String& mimeType, const String& textEncoding, const String& frameName, const ResourceResponse& response)
    : SubstituteResource(URL { url }, ResourceResponse { response }, WTFMove(data))
    , m_mimeType(mimeType)
    , m_textEncoding(textEncoding)

{
}

RefPtr<ArchiveResource> ArchiveResource::create(RefPtr<FragmentedSharedBuffer>&& data, const URL& url, const String& mimeType, const String& textEncoding, const String& frameName, const ResourceResponse& response)
{
    if (!data)
        return nullptr;

    return adoptRef(*new ArchiveResource(data.releaseNonNull(), url, mimeType, textEncoding, frameName, response));
}

RefPtr<ArchiveResource> ArchiveResource::create(RefPtr<FragmentedSharedBuffer>&& data, const URL& url, const ResourceResponse& response)
{
    return create(WTFMove(data), url, response.mimeType(), response.textEncodingName(), String(), response);
}




class ArchiveResource : public SubstituteResource {
public:
    static RefPtr<ArchiveResource> create(RefPtr<FragmentedSharedBuffer>&&, const URL&, const ResourceResponse&);
    WEBCORE_EXPORT static RefPtr<ArchiveResource> create(RefPtr<FragmentedSharedBuffer>&&, const URL&,
        const String& mimeType, const String& textEncoding, const String& frameName,
        const ResourceResponse& = ResourceResponse());


    bool shouldIgnoreWhenUnarchiving() const { return m_shouldIgnoreWhenUnarchiving; }

private:
    ArchiveResource(Ref<FragmentedSharedBuffer>&&, const URL&, const String& mimeType, const String& textEncoding, const String& frameName, const ResourceResponse&);

    String m_mimeType;
    String m_textEncoding;



    // Resource data can be empty, but must be represented by an empty CFDataRef
    auto& data = resource->data();

    CFDictionarySetValue(propertyList.get(), LegacyWebArchiveResourceDataKey, data.makeContiguous()->createCFData().get());

    // Resource URL cannot be null
    if (auto cfURL = resource->url().string().createCFString())

    // Don't include the resource response for the main resource
    if (!isMainResource) {
        if (auto resourceResponseData = createPropertyListRepresentation(resource->response()))
            CFDictionarySetValue(propertyList.get(), LegacyWebArchiveResourceResponseKey, resourceResponseData.get());
    }

    return propertyList;
}


            LOG(Archives, "LegacyWebArchive - Resource response data is not of type CFData, cannot create invalid resource");
            return nullptr;
        }

        auto resourceResponseVersion = static_cast<CFStringRef>(CFDictionaryGetValue(dictionary, LegacyWebArchiveResourceResponseVersionKey));
        if (resourceResponseVersion && CFGetTypeID(resourceResponseVersion) != CFStringGetTypeID()) {
            LOG(Archives, "LegacyWebArchive - Resource response version is not of type CFString, cannot create invalid resource");
            return nullptr;
        }

        response = createResourceResponseFromPropertyListData(resourceResponseData, resourceResponseVersion);
    }


    return archive;
}

RefPtr<LegacyWebArchive> LegacyWebArchive::create(FragmentedSharedBuffer& data)
{
    return create(URL(), data);
}

RefPtr<LegacyWebArchive> LegacyWebArchive::create(const URL&, FragmentedSharedBuffer& data)
{
    LOG(Archives, "LegacyWebArchive - Creating from raw data");

    Ref<LegacyWebArchive> archive = create();

    RetainPtr<CFDataRef> cfData = data.makeContiguous()->createCFData();
    if (!cfData)
        return nullptr;

    CFErrorRef error = nullptr;

    RetainPtr<CFDictionaryRef> plist = adoptCF(static_cast<CFDictionaryRef>(CFPropertyListCreateWithData(0, cfData.get(), kCFPropertyListImmutable, 0, &error)));
    if (!plist) {
#ifndef NDEBUG

            CFRelease(error);
        return nullptr;
    }

    if (CFGetTypeID(plist.get()) != CFDictionaryGetTypeID()) {
        LOG(Archives, "LegacyWebArchive - Archive property list is not the expected CFDictionary, aborting invalid WebArchive");
        return nullptr;
    }

    if (!archive->extract(plist.get()))
        return nullptr;


        LOG(Archives, "LegacyWebArchive - Null root CFDictionary, aborting invalid WebArchive");
        return false;
    }

    CFDictionaryRef mainResourceDict = static_cast<CFDictionaryRef>(CFDictionaryGetValue(dictionary, LegacyWebArchiveMainResourceKey));
    if (!mainResourceDict) {
        LOG(Archives, "LegacyWebArchive - No main resource in archive, aborting invalid WebArchive");

                LOG(Archives, "LegacyWebArchive - Subresource is not expected CFDictionary, aborting invalid WebArchive");
                return false;
            }

            if (auto subresource = createResource(subresourceDict))
                addSubresource(subresource.releaseNonNull());
        }

                LOG(Archives, "LegacyWebArchive - Subframe array is not expected CFDictionary, aborting invalid WebArchive");
                return false;
            }

            auto subframeArchive = create();
            if (subframeArchive->extract(subframeDict))
                addSubframeArchive(WTFMove(subframeArchive));

                LOG(Archives, "LegacyWebArchive - Invalid subframe archive skipped");
        }
    }

    return true;
}


{
    auto& response = frame.loader().documentLoader()->response();
    URL responseURL = response.url();

    // it's possible to have a response without a URL here
    // <rdar://problem/5454935>
    if (responseURL.isNull())


    if (!document->isFrameSet())
        return archive;

    // Wrap the frameset document in an iframe so it can be pasted into
    // another document (which will have a body or frameset of its own). 
    String iframeMarkup = "<iframe frameborder=\"no\" marginwidth=\"0\" marginheight=\"0\" width=\"98%%\" height=\"98%%\" src=\"" + frame->loader().documentLoader()->response().url().string() + "\"></iframe>";



class LegacyWebArchive final : public Archive {
public:
    WEBCORE_EXPORT static Ref<LegacyWebArchive> create();
    WEBCORE_EXPORT static RefPtr<LegacyWebArchive> create(FragmentedSharedBuffer&);
    WEBCORE_EXPORT static RefPtr<LegacyWebArchive> create(const URL&, FragmentedSharedBuffer&);
    WEBCORE_EXPORT static Ref<LegacyWebArchive> create(Ref<ArchiveResource>&& mainResource, Vector<Ref<ArchiveResource>>&& subresources, Vector<Ref<LegacyWebArchive>>&& subframeArchives);
    WEBCORE_EXPORT static RefPtr<LegacyWebArchive> create(Node&, Function<bool(Frame&)>&& frameFilter = { });
    WEBCORE_EXPORT static RefPtr<LegacyWebArchive> create(Frame&);



    return adoptRef(*new MHTMLArchive);
}

RefPtr<MHTMLArchive> MHTMLArchive::create(const URL& url, FragmentedSharedBuffer& data)
{
    // For security reasons we only load MHTML pages from local URLs.
    if (!LegacySchemeRegistry::shouldTreatURLSchemeAsLocal(url.protocol().toString()))

    return mainArchive;
}

Ref<FragmentedSharedBuffer> MHTMLArchive::generateMHTMLData(Page* page)
{
    Vector<PageSerializer::Resource> resources;
    PageSerializer pageSerializer(resources);

    // We use utf8() below instead of ascii() as ascii() replaces CRLFs with ?? (we still only have put ASCII characters in it).
    ASSERT(stringBuilder.toString().isAllASCII());
    CString asciiString = stringBuilder.toString().utf8();
    SharedBufferBuilder mhtmlData;
    mhtmlData.append(asciiString.data(), asciiString.length());

    for (auto& resource : resources) {
        stringBuilder.clear();

        stringBuilder.append("\r\nContent-Transfer-Encoding: ", contentEncoding, "\r\nContent-Location: ", resource.url.string(), "\r\n\r\n");

        asciiString = stringBuilder.toString().utf8();
        mhtmlData.append(asciiString.data(), asciiString.length());

        // FIXME: ideally we would encode the content as a stream without having to fetch it all.
        auto* data = resource.data->data();
        size_t dataLength = resource.data->size();
        if (!strcmp(contentEncoding, quotedPrintable)) {
            auto encodedData = quotedPrintableEncode(data, dataLength);
            mhtmlData.append(encodedData.data(), encodedData.size());
            mhtmlData.append("\r\n", 2);
        } else {
            ASSERT(!strcmp(contentEncoding, base64));
            // We are not specifying insertLFs = true below as it would cut the lines with LFs and MHTML requires CRLFs.

            size_t encodedDataLength = encodedData.size();
            do {
                size_t lineLength = std::min(encodedDataLength - index, maximumLineLength);
                mhtmlData.append(encodedData.data() + index, lineLength);
                mhtmlData.append("\r\n", 2);
                index += maximumLineLength;
            } while (index < encodedDataLength);
        }
    }

    asciiString = makeString("--", boundary, "--\r\n").utf8();
    mhtmlData.append(asciiString.data(), asciiString.length());

    return mhtmlData.take();
}

}




class MHTMLParser;
class Page;
class FragmentedSharedBuffer;

class MHTMLArchive final : public Archive {
public:
    static Ref<MHTMLArchive> create();
    static RefPtr<MHTMLArchive> create(const URL&, FragmentedSharedBuffer&);

    static Ref<FragmentedSharedBuffer> generateMHTMLData(Page*);

    virtual ~MHTMLArchive();




    return false;
}

MHTMLParser::MHTMLParser(FragmentedSharedBuffer* data)
    : m_lineReader(data, "\r\n")
{
}

{
    ASSERT(endOfPartBoundary.isEmpty() == endOfDocumentBoundary.isEmpty());

    SharedBufferBuilder content;
    const bool checkBoundary = !endOfPartBoundary.isEmpty();
    bool endOfPartReached = false;
    if (mimeHeader.contentTransferEncoding() == MIMEHeader::Binary) {

            LOG_ERROR("Binary contents requires end of part");
            return nullptr;
        }
        content.append(WTFMove(part));
        m_lineReader.setSeparator("\r\n");
        Vector<uint8_t> nextChars;
        if (m_lineReader.peek(nextChars, 2) != 2) {

                break;
            }
            // Note that we use line.utf8() and not line.ascii() as ascii turns special characters (such as tab, line-feed...) into '?'.
            content.append(line.utf8().data(), line.length());
            if (mimeHeader.contentTransferEncoding() == MIMEHeader::QuotedPrintable) {
                // The line reader removes the \r\n, but we need them for the content in this case as the QuotedPrintable decoder expects CR-LF terminated lines.
                content.append("\r\n", 2);
            }
        }
    }

    }

    Vector<uint8_t> data;
    auto contiguousContent = content.take()->makeContiguous();
    switch (mimeHeader.contentTransferEncoding()) {
    case MIMEHeader::Base64: {
        auto decodedData = base64Decode(contiguousContent->data(), contiguousContent->size());
        if (!decodedData) {
            LOG_ERROR("Invalid base64 content for MHTML part.");
            return nullptr;

        break;
    }
    case MIMEHeader::QuotedPrintable:
        data = quotedPrintableDecode(contiguousContent->data(), contiguousContent->size());
        break;
    case MIMEHeader::SevenBit:
    case MIMEHeader::Binary:
        data.append(contiguousContent->data(), contiguousContent->size());
        break;
    default:
        LOG_ERROR("Invalid encoding for MHTML part.");



class ArchiveResource;
class MHTMLArchive;
class MIMEHeader;
class FragmentedSharedBuffer;

class MHTMLParser {
public:
    explicit MHTMLParser(FragmentedSharedBuffer*);

    RefPtr<MHTMLArchive> parseArchive();




{
}

void CachedApplicationManifest::finishLoading(const FragmentedSharedBuffer* data, const NetworkLoadMetrics& metrics)
{
    if (data) {
        m_data = data->makeContiguous();
        setEncodedSize(data->size());
        m_text = m_decoder->decodeAndFlush(m_data->data(), data->size());
    } else {
        m_data = nullptr;
        setEncodedSize(0);
    }
    CachedResource::finishLoading(data, metrics);
}


Lines 42-48 public: a/Source/WebCore/loader/cache/CachedApplicationManifest.h_sec1
- a/Source/WebCore/loader/cache/CachedApplicationManifest.h -1 / +1 lines
42	std::optional<struct ApplicationManifest> process(const URL& manifestURL, const URL& documentURL, Document* = nullptr);	42	std::optional<struct ApplicationManifest> process(const URL& manifestURL, const URL& documentURL, Document* = nullptr);
43		43
44	private:	44	private:
45	void finishLoading(SharedBuffer*, const NetworkLoadMetrics&) override;	45	void finishLoading(const FragmentedSharedBuffer*, const NetworkLoadMetrics&) override;
46	const TextResourceDecoder* textResourceDecoder() const override { return m_decoder.ptr(); }	46	const TextResourceDecoder* textResourceDecoder() const override { return m_decoder.ptr(); }
47	void setEncoding(const String&) override;	47	void setEncoding(const String&) override;
48	String encoding() const override;	48	String encoding() const override;



        return m_decodedSheetText;

    // Don't cache the decoded text, regenerating is cheap and it can use quite a bit of memory
    return m_decoder->decodeAndFlush(m_data->makeContiguous()->data(), m_data->size());
}

void CachedCSSStyleSheet::setBodyDataFrom(const CachedResource& resource)

        saveParsedStyleSheet(*sheet.m_parsedStyleSheetCache);
}

void CachedCSSStyleSheet::finishLoading(const FragmentedSharedBuffer* data, const NetworkLoadMetrics& metrics)
{
    if (data) {
        m_data = data->makeContiguous();
        setEncodedSize(data->size());
        // Decode the data to find out the encoding and keep the sheet text around during checkNotify()
        m_decodedSheetText = m_decoder->decodeAndFlush(m_data->data(), data->size());
    } else {
        m_data = nullptr;
        setEncodedSize(0);
    }
    setLoading(false);
    checkNotify(metrics);
    // Clear the decoded text as it is unlikely to be needed immediately again and is cheap to regenerate.

Lines 55-61 private: a/Source/WebCore/loader/cache/CachedCSSStyleSheet.h_sec1
- a/Source/WebCore/loader/cache/CachedCSSStyleSheet.h -1 / +1 lines
55	void setEncoding(const String&) final;	55	void setEncoding(const String&) final;
56	String encoding() const final;	56	String encoding() const final;
57	const TextResourceDecoder* textResourceDecoder() const final { return m_decoder.get(); }	57	const TextResourceDecoder* textResourceDecoder() const final { return m_decoder.get(); }
58	void finishLoading(SharedBuffer*, const NetworkLoadMetrics&) final;	58	void finishLoading(const FragmentedSharedBuffer*, const NetworkLoadMetrics&) final;
59	void destroyDecodedData() final;	59	void destroyDecodedData() final;
60		60
61	void setBodyDataFrom(const CachedResource&) final;	61	void setBodyDataFrom(const CachedResource&) final;



        static_cast<CachedFontClient&>(client).fontLoaded(*this);
}

void CachedFont::finishLoading(const FragmentedSharedBuffer* data, const NetworkLoadMetrics& metrics)
{
    if (data) {
        m_data = data->makeContiguous();
        setEncodedSize(m_data->size());
    } else {
        m_data = nullptr;
        setEncodedSize(0);
    }
    setLoading(false);
    checkNotify(metrics);
}


std::unique_ptr<FontCustomPlatformData> CachedFont::createCustomFontData(SharedBuffer& bytes, const String& itemInCollection, bool& wrapping)
{
    RefPtr buffer = { &bytes };
    wrapping = !convertWOFFToSfntIfNecessary(buffer);
    return buffer ? createFontCustomPlatformData(*buffer, itemInCollection) : nullptr;
}

{
    if (isLoading())
        return;

    CachedResourceClientWalker<CachedFontClient> walker(m_clients);
    while (CachedFontClient* client = walker.next())
        client->fontLoaded(*this);

Lines 74-80 private: a/Source/WebCore/loader/cache/CachedFont.h_sec1
- a/Source/WebCore/loader/cache/CachedFont.h -1 / +1 lines
74	NO_RETURN_DUE_TO_ASSERT void setBodyDataFrom(const CachedResource&) final { ASSERT_NOT_REACHED(); }	74	NO_RETURN_DUE_TO_ASSERT void setBodyDataFrom(const CachedResource&) final { ASSERT_NOT_REACHED(); }
75		75
76	void didAddClient(CachedResourceClient&) override;	76	void didAddClient(CachedResourceClient&) override;
77	void finishLoading(SharedBuffer*, const NetworkLoadMetrics&) override;	77	void finishLoading(const FragmentedSharedBuffer*, const NetworkLoadMetrics&) override;
78		78
79	void allClientsRemoved() override;	79	void allClientsRemoved() override;
80		80



    m_updateImageDataCount = 0;
}

void CachedImage::updateBufferInternal(const FragmentedSharedBuffer& data)
{
    m_data = data.makeContiguous();
    setEncodedSize(m_data->size());
    createImage();


    return (MonotonicTime::now() - m_lastUpdateImageDataTime).seconds() < updateImageDataBackoffIntervals[interval];
}

RefPtr<SharedBuffer> CachedImage::convertedDataIfNeeded(const FragmentedSharedBuffer* data) const
{
    if (!data)
        return nullptr;
    if (!isPostScriptResource())
        return data->makeContiguous();
#if PLATFORM(MAC) && !USE(WEBKIT_IMAGE_DECODERS)
    return SharedBuffer::create(PDFDocumentImage::convertPostScriptDataToPDF(data->makeContiguous()->createCFData()).get());
#else
    // Loading the image should have been canceled if the system does not support converting PostScript to PDF.
    ASSERT_NOT_REACHED();

    return result;
}

void CachedImage::updateBuffer(const FragmentedSharedBuffer& data)
{
    ASSERT(dataBufferingPolicy() == DataBufferingPolicy::BufferData);
    updateBufferInternal(data);

    CachedResource::updateData(data, length);
}

void CachedImage::finishLoading(const FragmentedSharedBuffer* data, const NetworkLoadMetrics& metrics)
{
    m_data = convertedDataIfNeeded(data);
    if (m_data) {

void CachedImage::didReplaceSharedBufferContents()
{
    if (m_image) {
        // Let the Image know that the FragmentedSharedBuffer has been rejigged, so it can let go of any references to the heap-allocated resource buffer.
        // FIXME(rdar://problem/24275617): It would be better if we could somehow tell the Image's decoder to swap in the new contents without destroying anything.
        m_image->destroyDecodedData(true);
    }



    bool imageHasRelativeWidth() const { return m_image && m_image->hasRelativeWidth(); }
    bool imageHasRelativeHeight() const { return m_image && m_image->hasRelativeHeight(); }

    void updateBuffer(const FragmentedSharedBuffer&) override;
    void finishLoading(const FragmentedSharedBuffer*, const NetworkLoadMetrics&) override;

    enum SizeType {
        UsedSize,

    void destroyDecodedData() override;

    bool shouldDeferUpdateImageData() const;
    RefPtr<SharedBuffer> convertedDataIfNeeded(const FragmentedSharedBuffer* data) const;
    void didUpdateImageData();
    EncodedDataStatus updateImageData(bool allDataReceived);
    void updateData(const uint8_t* data, unsigned length) override;

    void changedInRect(const Image&, const IntRect*);
    void scheduleRenderingUpdate(const Image&);

    void updateBufferInternal(const FragmentedSharedBuffer&);

    void didReplaceSharedBufferContents() override;




    ASSERT(isMainOrMediaOrIconOrRawResource());
}

std::optional<SharedBufferDataView> CachedRawResource::calculateIncrementalDataChunk(const FragmentedSharedBuffer* data) const
{
    size_t previousDataLength = encodedSize();
    if (!data || data->size() <= previousDataLength)

    return data->getSomeData(previousDataLength);
}

void CachedRawResource::updateBuffer(const FragmentedSharedBuffer& data)
{
    // Skip any updateBuffers triggered from nested runloops. We'll have the complete buffer in finishLoading.
    if (m_inIncrementalDataNotify)


    CachedResourceHandle<CachedRawResource> protectedThis(this);
    ASSERT(dataBufferingPolicy() == DataBufferingPolicy::BufferData);
    m_data = data.makeContiguous();

    auto previousDataSize = encodedSize();
    while (data.size() > previousDataSize) {

    CachedResource::updateData(data, length);
}

void CachedRawResource::finishLoading(const FragmentedSharedBuffer* data, const NetworkLoadMetrics& metrics)
{
    if (m_inIncrementalDataNotify) {
        // We may get here synchronously from updateBuffer() if the callback there ends up spinning a runloop.

    CachedResourceHandle<CachedRawResource> protectedThis(this);
    DataBufferingPolicy dataBufferingPolicy = this->dataBufferingPolicy();
    if (dataBufferingPolicy == DataBufferingPolicy::BufferData) {
        if (data) {
            m_data = data->makeContiguous();
            if (auto incrementalData = calculateIncrementalDataChunk(data)) {
                setEncodedSize(data->size());
                notifyClientsDataWasReceived(incrementalData->data(), incrementalData->size());
            }
        } else
            m_data = nullptr;
    }

#if USE(QUICK_LOOK)




private:
    void didAddClient(CachedResourceClient&) final;
    void updateBuffer(const FragmentedSharedBuffer&) final;
    void updateData(const uint8_t* data, unsigned length) final;
    void finishLoading(const FragmentedSharedBuffer*, const NetworkLoadMetrics&) final;

    bool shouldIgnoreHTTPStatusCodeErrors() const override { return true; }
    void allClientsRemoved() override;

    void switchClientsToRevalidatedResource() override;
    bool mayTryReplaceEncodedData() const override { return m_allowEncodedDataReplacement; }

    std::optional<SharedBufferDataView> calculateIncrementalDataChunk(const FragmentedSharedBuffer*) const;
    void notifyClientsDataWasReceived(const uint8_t* data, unsigned length);
    
#if USE(QUICK_LOOK)

    Vector<RedirectPair, 0, CrashOnOverflow, 0> m_redirectChain;

    struct DelayedFinishLoading {
        RefPtr<const FragmentedSharedBuffer> buffer;
    };
    std::optional<DelayedFinishLoading> m_delayedFinishLoading;
};



        client->notifyFinished(*this, metrics);
}

void CachedResource::updateBuffer(const FragmentedSharedBuffer&)
{
    ASSERT(dataBufferingPolicy() == DataBufferingPolicy::BufferData);
}

    ASSERT(dataBufferingPolicy() == DataBufferingPolicy::DoNotBufferData);
}

void CachedResource::finishLoading(const FragmentedSharedBuffer*, const NetworkLoadMetrics& metrics)
{
    setLoading(false);
    checkNotify(metrics);

    if (*m_data != newBuffer)
        return;

    m_data = Ref { newBuffer };
    m_data->append(newBuffer);
    didReplaceSharedBufferContents();
}




class MemoryCache;
class NetworkLoadMetrics;
class SecurityOrigin;
class FragmentedSharedBuffer;
class SubresourceLoader;
class TextResourceDecoder;


    virtual void setEncoding(const String&) { }
    virtual String encoding() const { return String(); }
    virtual const TextResourceDecoder* textResourceDecoder() const { return nullptr; }
    virtual void updateBuffer(const FragmentedSharedBuffer&);
    virtual void updateData(const uint8_t* data, unsigned length);
    virtual void finishLoading(const FragmentedSharedBuffer*, const NetworkLoadMetrics&);
    virtual void error(CachedResource::Status);

    void setResourceError(const ResourceError& error) { m_error = error; }



    return m_decoder->encoding().name();
}

void CachedSVGDocument::finishLoading(const FragmentedSharedBuffer* data, const NetworkLoadMetrics& metrics)
{
    if (data) {
        // We don't need to create a new frame because the new document belongs to the parent UseElement.
        m_document = SVGDocument::create(nullptr, m_settings, response().url());
        m_document->setContent(m_decoder->decodeAndFlush(data->makeContiguous()->data(), data->size()));
    }
    CachedResource::finishLoading(data, metrics);
}

Lines 43-49 private: a/Source/WebCore/loader/cache/CachedSVGDocument.h_sec1
- a/Source/WebCore/loader/cache/CachedSVGDocument.h -1 / +1 lines
43	void setEncoding(const String&) override;	43	void setEncoding(const String&) override;
44	String encoding() const override;	44	String encoding() const override;
45	const TextResourceDecoder* textResourceDecoder() const override { return m_decoder.get(); }	45	const TextResourceDecoder* textResourceDecoder() const override { return m_decoder.get(); }
46	void finishLoading(SharedBuffer*, const NetworkLoadMetrics&) override;	46	void finishLoading(const FragmentedSharedBuffer*, const NetworkLoadMetrics&) override;
47		47
48	RefPtr<SVGDocument> m_document;	48	RefPtr<SVGDocument> m_document;
49	RefPtr<TextResourceDecoder> m_decoder;	49	RefPtr<TextResourceDecoder> m_decoder;

Lines 80-86 bool CachedSVGFont::ensureCustomFontData(const AtomString& remoteURI) a/Source/WebCore/loader/cache/CachedSVGFont.cpp_sec1
- a/Source/WebCore/loader/cache/CachedSVGFont.cpp -1 / +1 lines
80		80
81	ScriptDisallowedScope::DisableAssertionsInScope disabledScope;	81	ScriptDisallowedScope::DisableAssertionsInScope disabledScope;
82		82
83	m_externalSVGDocument->setContent(decoder->decodeAndFlush(m_data->data(), m_data->size()));	83	m_externalSVGDocument->setContent(decoder->decodeAndFlush(m_data->makeContiguous()->data(), m_data->size()));
84	sawError = decoder->sawError();	84	sawError = decoder->sawError();
85	}	85	}
86		86

Lines 96-105 unsigned CachedScript::scriptHash() a/Source/WebCore/loader/cache/CachedScript.cpp_sec1
- a/Source/WebCore/loader/cache/CachedScript.cpp -3 / +8 lines
96	return m_scriptHash;	96	return m_scriptHash;
97	}	97	}
98		98
99	void CachedScript::finishLoading(SharedBuffer* data, const NetworkLoadMetrics& metrics)	99	void CachedScript::finishLoading(const FragmentedSharedBuffer* data, const NetworkLoadMetrics& metrics)
100	{	100	{
101	m_data = data;	101	if (data) {
102	setEncodedSize(data ? data->size() : 0);	102	m_data = data->makeContiguous();
		103	setEncodedSize(data->size());
		104	} else {
		105	m_data = nullptr;
		106	setEncodedSize(0);
		107	}
103	CachedResource::finishLoading(data, metrics);	108	CachedResource::finishLoading(data, metrics);
104	}	109	}
105		110

Lines 47-53 private: a/Source/WebCore/loader/cache/CachedScript.h_sec1
- a/Source/WebCore/loader/cache/CachedScript.h -1 / +1 lines
47	void setEncoding(const String&) final;	47	void setEncoding(const String&) final;
48	String encoding() const final;	48	String encoding() const final;
49	const TextResourceDecoder* textResourceDecoder() const final { return m_decoder.get(); }	49	const TextResourceDecoder* textResourceDecoder() const final { return m_decoder.get(); }
50	void finishLoading(SharedBuffer*, const NetworkLoadMetrics&) final;	50	void finishLoading(const FragmentedSharedBuffer*, const NetworkLoadMetrics&) final;
51		51
52	void destroyDecodedData() final;	52	void destroyDecodedData() final;
53		53



{
}

void CachedTextTrack::doUpdateBuffer(const FragmentedSharedBuffer* data)
{
    ASSERT(dataBufferingPolicy() == DataBufferingPolicy::BufferData);
    m_data = data ? data->makeContiguous() : RefPtr<SharedBuffer>();
    setEncodedSize(data ? data->size() : 0);

    CachedResourceClientWalker<CachedResourceClient> walker(m_clients);

        client->deprecatedDidReceiveCachedResource(*this);
}

void CachedTextTrack::updateBuffer(const FragmentedSharedBuffer& data)
{
    doUpdateBuffer(&data);
    CachedResource::updateBuffer(data);
}

void CachedTextTrack::finishLoading(const FragmentedSharedBuffer* data, const NetworkLoadMetrics& metrics)
{
    doUpdateBuffer(data);
    CachedResource::finishLoading(data, metrics);




private:
    bool mayTryReplaceEncodedData() const override { return true; }
    void updateBuffer(const FragmentedSharedBuffer&) override;
    void finishLoading(const FragmentedSharedBuffer*, const NetworkLoadMetrics&) override;

    void doUpdateBuffer(const FragmentedSharedBuffer*);
};

} // namespace WebCore



    return m_decoder->encoding().name();
}

void CachedXSLStyleSheet::finishLoading(const FragmentedSharedBuffer* data, const NetworkLoadMetrics& metrics)
{
    if (data) {
        m_data = data->makeContiguous();
        setEncodedSize(data->size());
        m_sheet = m_decoder->decodeAndFlush(m_data->data(), encodedSize());
    } else {
        m_data = nullptr;
        setEncodedSize(0);
    }
    setLoading(false);
    checkNotify(metrics);
}

Lines 47-53 private: a/Source/WebCore/loader/cache/CachedXSLStyleSheet.h_sec1
- a/Source/WebCore/loader/cache/CachedXSLStyleSheet.h -1 / +1 lines
47	void setEncoding(const String&) final;	47	void setEncoding(const String&) final;
48	String encoding() const final;	48	String encoding() const final;
49	const TextResourceDecoder* textResourceDecoder() const final { return m_decoder.get(); }	49	const TextResourceDecoder* textResourceDecoder() const final { return m_decoder.get(); }
50	void finishLoading(SharedBuffer*, const NetworkLoadMetrics&) final;	50	void finishLoading(const FragmentedSharedBuffer*, const NetworkLoadMetrics&) final;
51		51
52	String m_sheet;	52	String m_sheet;
53	RefPtr<TextResourceDecoder> m_decoder;	53	RefPtr<TextResourceDecoder> m_decoder;



#include <wtf/Forward.h>
#include <wtf/Noncopyable.h>
#include <wtf/RetainPtr.h>
#include <wtf/UniqueRef.h>
#include <wtf/WeakPtr.h>

namespace WebCore {

class LegacyPreviewLoaderClient;
class ResourceLoader;
class ResourceResponse;
class FragmentedSharedBuffer;
class SharedBufferBuilder;

class LegacyPreviewLoader final : private PreviewConverterClient, private PreviewConverterProvider {
    WTF_MAKE_FAST_ALLOCATED;


    bool didReceiveResponse(const ResourceResponse&);
    bool didReceiveData(const uint8_t* data, unsigned length);
    bool didReceiveBuffer(const FragmentedSharedBuffer&);
    bool didFinishLoading();
    void didFail();


    void previewConverterDidFinishUpdating(PreviewConverter&) final { };
    void previewConverterDidFailUpdating(PreviewConverter&) final;
    void previewConverterDidStartConverting(PreviewConverter&) final;
    void previewConverterDidReceiveData(PreviewConverter&, const FragmentedSharedBuffer&) final;
    void previewConverterDidFinishConverting(PreviewConverter&) final;
    void previewConverterDidFailConverting(PreviewConverter&) final;

    // PreviewConverterProvider
    void provideMainResourceForPreviewConverter(PreviewConverter&, CompletionHandler<void(Ref<FragmentedSharedBuffer>&&)>&&) final;
    void providePasswordForPreviewConverter(PreviewConverter&, CompletionHandler<void(const String&)>&&) final;

    RefPtr<PreviewConverter> m_converter;
    Ref<LegacyPreviewLoaderClient> m_client;
    UniqueRef<SharedBufferBuilder> m_originalData;
    WeakPtr<ResourceLoader> m_resourceLoader;
    bool m_finishedLoadingDataIntoConverter { false };
    bool m_hasProcessedResponse { false };



    return emptyClient();
}

bool LegacyPreviewLoader::didReceiveBuffer(const FragmentedSharedBuffer& buffer)
{
    if (m_finishedLoadingDataIntoConverter)
        return false;

        return;

    ASSERT(!m_hasProcessedResponse);
    m_originalData->reset();
    resourceLoader->documentLoader()->setPreviewConverter(WTFMove(m_converter));
    auto response { converter.previewResponse() };


    });
}

void LegacyPreviewLoader::previewConverterDidReceiveData(PreviewConverter&, const FragmentedSharedBuffer& data)
{
    auto resourceLoader = m_resourceLoader.get();
    if (!resourceLoader)

    m_client->didRequestPassword(WTFMove(completionHandler));
}

void LegacyPreviewLoader::provideMainResourceForPreviewConverter(PreviewConverter& converter, CompletionHandler<void(Ref<FragmentedSharedBuffer>&&)>&& completionHandler)
{
    ASSERT_UNUSED(converter, &converter == m_converter);
    completionHandler(m_originalData->take());
}

LegacyPreviewLoader::~LegacyPreviewLoader() = default;

LegacyPreviewLoader::LegacyPreviewLoader(ResourceLoader& loader, const ResourceResponse& response)
    : m_converter { PreviewConverter::create(response, *this) }
    , m_client { makeClient(loader, m_converter->previewFileName(), m_converter->previewUTI()) }
    , m_originalData { makeUniqueRef<SharedBufferBuilder>() }
    , m_resourceLoader { loader }
    , m_shouldDecidePolicyBeforeLoading { loader.frame()->settings().shouldDecidePolicyBeforeLoadingQuickLookPreview() }
{




enum class DOMPasteAccessResponse : uint8_t;

class SharedBuffer;
class DocumentFragment;
class Element;
class Frame;
class KeyboardEvent;
class Node;
class FragmentedSharedBuffer;
class StyleProperties;
class TextCheckerClient;
class VisibleSelection;

    virtual bool shouldMoveRangeAfterDelete(const SimpleRange&, const SimpleRange&) = 0;

#if ENABLE(ATTACHMENT_ELEMENT)
    virtual void registerAttachmentIdentifier(const String& /* identifier */, const String& /* contentType */, const String& /* preferredFileName */, Ref<FragmentedSharedBuffer>&&) { }
    virtual void registerAttachmentIdentifier(const String& /* identifier */, const String& /* contentType */, const String& /* filePath */) { }
    virtual void registerAttachments(Vector<SerializedAttachmentData>&&) { }
    virtual void registerAttachmentIdentifier(const String& /* identifier */) { }



    if (!image || image->image() == &Image::nullImage())
        return;

    RefPtr<FragmentedSharedBuffer> data = imageRenderer ? image->imageForRenderer(imageRenderer)->data() : 0;
    if (!data)
        data = image->image()->data();


        return;
    }

    m_resources.append({ url, image->response().mimeType(), data->makeContiguous() });
    m_resourceURLs.add(url);
}




ShareDataReader::ShareDataReader(CompletionHandler<void(ExceptionOr<ShareDataWithParsedURL&>)>&& completionHandler)
    : m_completionHandler(WTFMove(completionHandler))
{

}

ShareDataReader::~ShareDataReader()

        cancel();
        return;
    }

    auto arrayBuffer = m_pendingFileLoads[loadIndex]->arrayBufferResult();

    RawFile file;
    file.fileName = fileName;
    file.fileData = SharedBuffer::create(static_cast<const unsigned char*>(arrayBuffer->data()), arrayBuffer->byteLength());
    m_shareData.files.append(WTFMove(file));
    m_filesReadSoFar++;

    if (m_filesReadSoFar == static_cast<int>(m_pendingFileLoads.size())) {
        m_pendingFileLoads.clear();
        if (auto completionHandler = std::exchange(m_completionHandler, { }))

Lines 70-76 private: a/Source/WebCore/platform/NowPlayingManager.h_sec1
- a/Source/WebCore/platform/NowPlayingManager.h -1 / +1 lines
70	std::optional<NowPlayingInfo> m_nowPlayingInfo;	70	std::optional<NowPlayingInfo> m_nowPlayingInfo;
71	struct ArtworkCache {	71	struct ArtworkCache {
72	String src;	72	String src;
73	RefPtr<SharedBuffer> imageData;	73	RefPtr<FragmentedSharedBuffer> imageData;
74	};	74	};
75	std::optional<ArtworkCache> m_nowPlayingInfoArtwork;	75	std::optional<ArtworkCache> m_nowPlayingInfoArtwork;
76	bool m_setAsNowPlayingApplication { false };	76	bool m_setAsNowPlayingApplication { false };

Lines 89-95 String Pasteboard::readString(size_t index, const String& type) a/Source/WebCore/platform/Pasteboard.cpp_sec1
- a/Source/WebCore/platform/Pasteboard.cpp -1 / +1 lines
89	return { };	89	return { };
90	}	90	}
91		91
92	RefPtr<WebCore::SharedBuffer> Pasteboard::readBuffer(size_t index, const String& type)	92	RefPtr<WebCore::FragmentedSharedBuffer> Pasteboard::readBuffer(size_t index, const String& type)
93	{	93	{
94	if (auto* strategy = platformStrategies()->pasteboardStrategy())	94	if (auto* strategy = platformStrategies()->pasteboardStrategy())
95	return strategy->readBufferFromPasteboard(index, type, name(), context());	95	return strategy->readBufferFromPasteboard(index, type, name(), context());




namespace WebCore {

class SharedBuffer;
class DocumentFragment;
class DragData;
class Element;
class Frame;
class PasteboardStrategy;
class FragmentedSharedBuffer;

struct SimpleRange;


    virtual bool readFilePath(const String&, PresentationSize preferredPresentationSize = { }, const String& contentType = { }) = 0;
    virtual bool readFilePaths(const Vector<String>&) = 0;
    virtual bool readHTML(const String&) = 0;
    virtual bool readImage(Ref<FragmentedSharedBuffer>&&, const String& type, PresentationSize preferredPresentationSize = { }) = 0;
    virtual bool readURL(const URL&, const String& title) = 0;
    virtual bool readPlainText(const String&) = 0;
#endif

#if PLATFORM(COCOA)
    virtual bool readWebArchive(FragmentedSharedBuffer&) = 0;
    virtual bool readRTFD(FragmentedSharedBuffer&) = 0;
    virtual bool readRTF(FragmentedSharedBuffer&) = 0;
    virtual bool readDataBuffer(FragmentedSharedBuffer&, const String& type, const String& name, PresentationSize preferredPresentationSize = { }) = 0;
#endif
};


    virtual ~PasteboardFileReader() = default;
    virtual void readFilename(const String&) = 0;
    virtual bool shouldReadBuffer(const String& /* type */) const { return true; }
    virtual void readBuffer(const String& filename, const String& type, Ref<FragmentedSharedBuffer>&&) = 0;
};

class Pasteboard {

    std::optional<PasteboardItemInfo> pasteboardItemInfo(size_t index) const;

    String readString(size_t index, const String& type);
    RefPtr<WebCore::FragmentedSharedBuffer> readBuffer(size_t index, const String& type);
    URL readURL(size_t index, String& title);

    const PasteboardContext* context() const { return m_context.get(); }




namespace WebCore {

static std::variant<String, Ref<FragmentedSharedBuffer>> copyPlatformData(const std::variant<String, Ref<FragmentedSharedBuffer>>& other)
{
    if (std::holds_alternative<String>(other))
        return { std::get<String>(other) };

    if (std::holds_alternative<Ref<FragmentedSharedBuffer>>(other))
        return { std::get<Ref<FragmentedSharedBuffer>>(other).copyRef() };

    return { };
}

    addOrMoveEntryToEnd(type).platformData = { value };
}

void PasteboardCustomData::writeData(const String& type, Ref<FragmentedSharedBuffer>&& data)
{
    addOrMoveEntryToEnd(type).platformData = { WTFMove(data) };
}

    return customData;
}

RefPtr<FragmentedSharedBuffer> PasteboardCustomData::readBuffer(const String& type) const
{
    for (auto& entry : m_data) {
        if (entry.type != type)
            continue;

        if (std::holds_alternative<Ref<FragmentedSharedBuffer>>(entry.platformData))
            return std::get<Ref<FragmentedSharedBuffer>>(entry.platformData).copyRef();

        return nullptr;
    }

    }
}

void PasteboardCustomData::forEachPlatformStringOrBuffer(Function<void(const String& type, const std::variant<String, Ref<FragmentedSharedBuffer>>& data)>&& function) const
{
    for (auto& entry : m_data) {
        auto& data = entry.platformData;
        if ((std::holds_alternative<String>(data) && !std::get<String>(data).isNull()) || std::holds_alternative<Ref<FragmentedSharedBuffer>>(data))
            function(entry.type, data);
    }
}



namespace WebCore {

class SharedBuffer;
class FragmentedSharedBuffer;

class PasteboardCustomData {
public:


        String type;
        String customData;
        std::variant<String, Ref<FragmentedSharedBuffer>> platformData;
    };

    WEBCORE_EXPORT PasteboardCustomData();

    WEBCORE_EXPORT static PasteboardCustomData fromPersistenceDecoder(WTF::Persistence::Decoder&&);

    String readString(const String& type) const;
    RefPtr<FragmentedSharedBuffer> readBuffer(const String& type) const;
    String readStringInCustomData(const String& type) const;

    void writeString(const String& type, const String& value);
    void writeData(const String& type, Ref<FragmentedSharedBuffer>&& data);
    void writeStringInCustomData(const String& type, const String& value);

    void clear();


    void forEachType(Function<void(const String&)>&&) const;
    void forEachPlatformString(Function<void(const String& type, const String& data)>&&) const;
    void forEachPlatformStringOrBuffer(Function<void(const String& type, const std::variant<String, Ref<FragmentedSharedBuffer>>& data)>&&) const;
    void forEachCustomString(Function<void(const String& type, const String& data)>&&) const;

    bool hasData() const;



namespace WebCore {

class Color;
class SharedBuffer;
class PasteboardContext;
class PasteboardCustomData;
class SelectionData;
class FragmentedSharedBuffer;
struct PasteboardImage;
struct PasteboardItemInfo;
struct PasteboardURL;


    virtual int64_t addTypes(const Vector<String>& pasteboardTypes, const String& pasteboardName, const PasteboardContext*) = 0;
    virtual int64_t setTypes(const Vector<String>& pasteboardTypes, const String& pasteboardName, const PasteboardContext*) = 0;
    virtual int64_t setBufferForType(FragmentedSharedBuffer*, const String& pasteboardType, const String& pasteboardName, const PasteboardContext*) = 0;
    virtual int64_t setURL(const PasteboardURL&, const String& pasteboardName, const PasteboardContext*) = 0;
    virtual int64_t setColor(const Color&, const String& pasteboardName, const PasteboardContext*) = 0;
    virtual int64_t setStringForType(const String&, const String& pasteboardType, const String& pasteboardName, const PasteboardContext*) = 0;



class ContentFilterUnblockHandler;
class ResourceRequest;
class ResourceResponse;
class FragmentedSharedBuffer;

class PlatformContentFilter {
    WTF_MAKE_FAST_ALLOCATED;

    virtual void responseReceived(const ResourceResponse&) = 0;
    virtual void addData(const uint8_t* data, int length) = 0;
    virtual void finishedAddingData() = 0;
    virtual Ref<FragmentedSharedBuffer> replacementData() const = 0;
#if ENABLE(CONTENT_FILTERING)
    virtual ContentFilterUnblockHandler unblockHandler() const = 0;
#endif



namespace WebCore {

class Color;
class SharedBuffer;
class PasteboardCustomData;
class SelectionData;
class SharedBuffer;
struct PasteboardImage;
struct PasteboardItemInfo;
struct PasteboardURL;
struct PasteboardWebContent;
class FragmentedSharedBuffer;

class PlatformPasteboard {
public:


    // These methods will return 0 if pasteboard ownership has been taken from us.
    WEBCORE_EXPORT int64_t copy(const String& fromPasteboard);
    WEBCORE_EXPORT int64_t setBufferForType(FragmentedSharedBuffer*, const String& pasteboardType);
    WEBCORE_EXPORT int64_t setURL(const PasteboardURL&);
    WEBCORE_EXPORT int64_t setColor(const Color&);
    WEBCORE_EXPORT int64_t setStringForType(const String&, const String& pasteboardType);



    return m_previewError;
}

const FragmentedSharedBuffer& PreviewConverter::previewData() const
{
    return *m_previewData->get();
}

void PreviewConverter::updateMainResource()

        return;
    }

    provider->provideMainResourceForPreviewConverter(*this, [this, protectedThis = Ref { *this }](auto&& buffer) {
        appendFromBuffer(WTFMove(buffer));
            appendFromBuffer(*buffer);
        else
            didFailUpdating();
    });
}

void PreviewConverter::appendFromBuffer(const FragmentedSharedBuffer& buffer)
{
    while (buffer.size() > m_lengthAppended) {
        auto newData = buffer.getSomeData(m_lengthAppended);

    client.previewConverterDidStartConverting(*this);

    if (!m_previewData->isEmpty() && hasClient(client))
        client.previewConverterDidReceiveData(*this, *m_previewData->get());

    if (m_state == State::Converting || !hasClient(client))
        return;

    client.previewConverterDidFinishConverting(*this);
}

void PreviewConverter::delegateDidReceiveData(const FragmentedSharedBuffer& data)
{
    auto protectedThis { Ref { *this } };




#include "ResourceResponse.h"
#include <wtf/RefCounted.h>
#include <wtf/RetainPtr.h>
#include <wtf/UniqueRef.h>
#include <wtf/WeakPtr.h>
#include <wtf/text/WTFString.h>



class ResourceError;
class ResourceRequest;
class FragmentedSharedBuffer;
class SharedBufferDataView;
class SharedBufferBuilder;
struct PreviewConverterClient;
struct PreviewConverterProvider;

struct PreviewPlatformDelegate : CanMakeWeakPtr<PreviewPlatformDelegate> {
    virtual ~PreviewPlatformDelegate() = default;

    virtual void delegateDidReceiveData(const FragmentedSharedBuffer&) = 0;
    virtual void delegateDidFinishLoading() = 0;
    virtual void delegateDidFailWithError(const ResourceError&) = 0;
};

    WEBCORE_EXPORT String previewFileName() const;
    WEBCORE_EXPORT String previewUTI() const;
    const ResourceError& previewError() const;
    const FragmentedSharedBuffer& previewData() const;

    void failedUpdating();
    void finishUpdating();

    bool isPlatformPasswordError(const ResourceError&) const;

    template<typename T> void iterateClients(T&& callback);
    void appendFromBuffer(const FragmentedSharedBuffer&);
    void didAddClient(PreviewConverterClient&);
    void didFailConvertingWithError(const ResourceError&);
    void didFailUpdating();

    void platformUnlockWithPassword(const String&);

    // PreviewPlatformDelegate
    void delegateDidReceiveData(const FragmentedSharedBuffer&) final;
    void delegateDidFinishLoading() final;
    void delegateDidFailWithError(const ResourceError&) final;


        FinishedConverting,
    };

    UniqueRef<SharedBufferBuilder> m_previewData;
    ResourceError m_previewError;
    ResourceResponse m_originalResponse;
    State m_state { State::Updating };




class PreviewConverter;
class ResourceError;
class FragmentedSharedBuffer;

struct PreviewConverterClient : CanMakeWeakPtr<PreviewConverterClient> {
    virtual ~PreviewConverterClient() = default;

    virtual void previewConverterDidFinishUpdating(PreviewConverter&) = 0;
    virtual void previewConverterDidFailUpdating(PreviewConverter&) = 0;
    virtual void previewConverterDidStartConverting(PreviewConverter&) = 0;
    virtual void previewConverterDidReceiveData(PreviewConverter&, const FragmentedSharedBuffer& newData) = 0;
    virtual void previewConverterDidFinishConverting(PreviewConverter&) = 0;
    virtual void previewConverterDidFailConverting(PreviewConverter&) = 0;
};

Lines 32-38 namespace WebCore { a/Source/WebCore/platform/PreviewConverterProvider.h_sec1
- a/Source/WebCore/platform/PreviewConverterProvider.h -1 / +1 lines
32	struct PreviewConverterProvider : CanMakeWeakPtr<PreviewConverterProvider> {	32	struct PreviewConverterProvider : CanMakeWeakPtr<PreviewConverterProvider> {
33	virtual ~PreviewConverterProvider() = default;	33	virtual ~PreviewConverterProvider() = default;
34		34
35	virtual void provideMainResourceForPreviewConverter(PreviewConverter&, CompletionHandler<void(const SharedBuffer*)>&&) = 0;	35	virtual void provideMainResourceForPreviewConverter(PreviewConverter&, CompletionHandler<void(Ref<FragmentedSharedBuffer>&&)>&&) = 0;
36	virtual void providePasswordForPreviewConverter(PreviewConverter&, CompletionHandler<void(const String&)>&&) = 0;	36	virtual void providePasswordForPreviewConverter(PreviewConverter&, CompletionHandler<void(const String&)>&&) = 0;
37	};	37	};
38		38




namespace WebCore {

Ref<FragmentedSharedBuffer> FragmentedSharedBuffer::create()
{
    return adoptRef(*new FragmentedSharedBuffer);
}

Ref<FragmentedSharedBuffer> FragmentedSharedBuffer::create(const uint8_t* data, size_t size)
{
    return adoptRef(*new FragmentedSharedBuffer(data, size));
}

Ref<FragmentedSharedBuffer> FragmentedSharedBuffer::create(FileSystem::MappedFileData&& mappedFileData)
    : m_size(fileData.size())
{
    return adoptRef(*new FragmentedSharedBuffer(WTFMove(mappedFileData)));
}

Ref<FragmentedSharedBuffer> FragmentedSharedBuffer::create(Ref<SharedBuffer>&& buffer)
    : m_size(provider.size())
{
    return adoptRef(*new FragmentedSharedBuffer(WTFMove(buffer)));
}

Ref<FragmentedSharedBuffer> FragmentedSharedBuffer::create(Vector<uint8_t>&& vector)
{
    return adoptRef(*new FragmentedSharedBuffer(WTFMove(vector)));
}

Ref<FragmentedSharedBuffer> FragmentedSharedBuffer::create(DataSegment::Provider&& provider)
Ref<SharedBuffer> SharedBuffer::create(GstMappedOwnedBuffer& mappedBuffer)
{
    return adoptRef(*new FragmentedSharedBuffer(WTFMove(provider)));
}

FragmentedSharedBuffer::FragmentedSharedBuffer() = default;

FragmentedSharedBuffer::FragmentedSharedBuffer(FileSystem::MappedFileData&& fileData)
    : m_size(fileData.size())
{
    m_segments.append({ 0, DataSegment::create(WTFMove(fileData)) });
}
#endif

FragmentedSharedBuffer::FragmentedSharedBuffer(DataSegment::Provider&& provider)
    : m_size(provider.size())
{
    m_segments.append({ 0, DataSegment::create(WTFMove(provider)) });
        bool mappingSuccess;
        FileSystem::MappedFileData mappedFileData(filePath, mappedFileMode, mappingSuccess);
        if (mappingSuccess)
            return adoptRef(new SharedBuffer(WTFMove(mappedFileData)));
    }
    return SharedBuffer::createFromReadingFile(filePath);
}

FragmentedSharedBuffer::FragmentedSharedBuffer(Ref<SharedBuffer>&& buffer)
{
    append(WTFMove(buffer));
}

#if USE(GSTREAMER)
Ref<FragmentedSharedBuffer> FragmentedSharedBuffer::create(GstMappedOwnedBuffer& mappedBuffer)
{
    return adoptRef(*new FragmentedSharedBuffer(mappedBuffer));
}

FragmentedSharedBuffer::FragmentedSharedBuffer(GstMappedOwnedBuffer& mappedBuffer)
    : m_size(mappedBuffer.size())
{
    m_segments.append({ 0, DataSegment::create(&mappedBuffer) });
}
#endif

static Vector<uint8_t> combineSegmentsData(const FragmentedSharedBuffer::DataSegmentVector& segments, size_t size)
{
    Vector<uint8_t> combinedData;
    combinedData.reserveInitialCapacity(size);

    return combinedData;
}

Ref<SharedBuffer> FragmentedSharedBuffer::makeContiguous() const
{
    if (m_contiguous)
        return Ref { *static_cast<SharedBuffer*>(const_cast<FragmentedSharedBuffer*>(this)) };
    if (!m_segments.size())
        return SharedBuffer::create();
    if (m_segments.size() == 1)
        return SharedBuffer::create(m_segments[0].segment.copyRef());
        return;

    auto combinedData = combineSegmentsData(m_segments, m_size);
    return SharedBuffer::create(WTFMove(combinedData));
    m_segments.append({0, DataSegment::create(WTFMove(combinedData))});
    ASSERT(m_segments.size() == 1);
    ASSERT(internallyConsistent());
}

Vector<uint8_t> FragmentedSharedBuffer::copyData() const
{
    if (m_segments.isEmpty())
        return nullptr;
    combineIntoOneSegment();
    ASSERT(internallyConsistent());
    return m_segments[0].segment->data();
}

Vector<uint8_t> SharedBuffer::copyData() const
{
    Vector<uint8_t> data;
    data.reserveInitialCapacity(size());

    return data;
}

Vector<uint8_t> FragmentedSharedBuffer::takeData()
{
    if (m_segments.isEmpty())
        return { };

    return combinedData;
}

SharedBufferDataView FragmentedSharedBuffer::getSomeData(size_t position) const
{
    const DataSegmentVectorEntry* element = getSegmentForPosition(position);
    return { element->segment.copyRef(), position - element->beginPosition };
}

const FragmentedSharedBuffer::DataSegmentVectorEntry* FragmentedSharedBuffer::getSegmentForPosition(size_t position) const
{
    RELEASE_ASSERT(position < m_size);
    auto comparator = [](const size_t& position, const DataSegmentVectorEntry& entry) {

    return element;
}

String FragmentedSharedBuffer::toHexString() const
{
    StringBuilder stringBuilder;
    forEachSegment([&](auto& segment) {

    return stringBuilder.toString();
}

RefPtr<ArrayBuffer> FragmentedSharedBuffer::tryCreateArrayBuffer() const
{
    auto arrayBuffer = ArrayBuffer::tryCreateUninitialized(static_cast<unsigned>(size()), 1);
    if (!arrayBuffer) {

    return arrayBuffer;
}

void FragmentedSharedBuffer::append(const FragmentedSharedBuffer& data)
{
    ASSERT(!m_contiguous);
    m_segments.reserveCapacity(m_segments.size() + data.m_segments.size());
    for (const auto& element : data.m_segments) {
        m_segments.uncheckedAppend({ m_size, element.segment.copyRef() });
        m_size += element.segment->size();
    }
    ASSERT(internallyConsistent());
}

void FragmentedSharedBuffer::append(const uint8_t* data, size_t length)
{
    ASSERT(!m_contiguous);
    Vector<uint8_t> vector;
    vector.append(data, length);
    m_segments.append({ m_size, DataSegment::create(WTFMove(vector)) });
    m_size += length;
    ASSERT(internallyConsistent());
}

void FragmentedSharedBuffer::append(Vector<uint8_t>&& data)
{
    ASSERT(!m_contiguous);
    auto dataSize = data.size();
    m_segments.append({ m_size, DataSegment::create(WTFMove(data)) });
    m_size += dataSize;
    ASSERT(internallyConsistent());
}

void FragmentedSharedBuffer::clear()
{
    m_size = 0;
    m_segments.clear();
    ASSERT(internallyConsistent());
}

Ref<FragmentedSharedBuffer> FragmentedSharedBuffer::copy() const
{
    Ref<FragmentedSharedBuffer> clone = adoptRef(*new FragmentedSharedBuffer);
    clone->m_size = m_size;
    clone->m_segments.reserveInitialCapacity(m_segments.size());
    for (const auto& element : m_segments)
        clone->m_segments.uncheckedAppend({ element.beginPosition, element.segment.copyRef() });
    ASSERT(clone->internallyConsistent());
    ASSERT(internallyConsistent());
    return clone;
}

void FragmentedSharedBuffer::forEachSegment(const Function<void(const Span<const uint8_t>&)>& apply) const
{
    return adoptRef(*new SharedBuffer(WTFMove(provider)));
}

void SharedBuffer::forEachSegment(const Function<void(const Span<const uint8_t>&)>& apply) const
{
    auto segments = m_segments;
    for (auto& segment : segments)
        apply(Span { segment.segment->data(), segment.segment->size() });
}

bool FragmentedSharedBuffer::startsWith(const Span<const uint8_t>& prefix) const
{
    if (prefix.empty())
        return true;

    return false;
}

Vector<uint8_t> FragmentedSharedBuffer::read(size_t offset, size_t length) const
{
    Vector<uint8_t> data;
    if (offset >= size())

    return data;
}

void FragmentedSharedBuffer::copyTo(void* destination, size_t length) const
{
    return copyTo(destination, 0, length);
}

void FragmentedSharedBuffer::copyTo(void* destination, size_t offset, size_t length) const
{
    ASSERT(length + offset <= size());
    if (offset >= size())

    }
}

bool SharedBuffer::hasOneSegment() const
{
    auto it = begin();
    return it != end() && ++it == end();
}

#if ASSERT_ENABLED
bool FragmentedSharedBuffer::internallyConsistent() const
{
    size_t position = 0;
    for (const auto& element : m_segments) {

}
#endif // ASSERT_ENABLED

const uint8_t* SharedBuffer::DataSegment::data() const
{
    auto visitor = WTF::makeVisitor(
        [](const Vector<uint8_t>& data) -> const uint8_t* { return data.data(); },
#if USE(CF)
        [](const RetainPtr<CFDataRef>& data) -> const uint8_t* { return CFDataGetBytePtr(data.get()); },
#endif
#if USE(GLIB)
        [](const GRefPtr<GBytes>& data) -> const uint8_t* { return static_cast<const uint8_t*>(g_bytes_get_data(data.get(), nullptr)); },
#endif
#if USE(GSTREAMER)
        [](const RefPtr<GstMappedOwnedBuffer>& data) -> const uint8_t* { return data->data(); },
#endif
        [](const FileSystem::MappedFileData& data) -> const uint8_t* { return static_cast<const uint8_t*>(data.data()); },
        [](const Provider& provider) -> const uint8_t* { return provider.data(); }
    );
    return std::visit(visitor, m_immutableData);
}

bool SharedBuffer::DataSegment::containsMappedFileData() const
{
    return std::holds_alternative<FileSystem::MappedFileData>(m_immutableData);
}

#if !USE(CF)
void FragmentedSharedBuffer::hintMemoryNotNeededSoon() const
{
}
#endif

bool FragmentedSharedBuffer::operator==(const FragmentedSharedBuffer& other) const
{
    return {{ reinterpret_cast<const uint8_t*>(data()), size() }};
}

bool SharedBuffer::operator==(const SharedBuffer& other) const
{
    if (this == &other)
        return true;

    return true;
}

SharedBuffer::SharedBuffer()
{
    m_contiguous = true;
}

SharedBuffer::SharedBuffer(Ref<DataSegment>&& segment)
{
    m_size = segment->size();
    m_segments.append({ 0, WTFMove(segment) });
    m_contiguous = true;
}

SharedBuffer::SharedBuffer(Ref<FragmentedSharedBuffer>&& contiguousBuffer)
{
    ASSERT(contiguousBuffer->hasOneSegment() || contiguousBuffer->isEmpty());
    m_size = contiguousBuffer->size();
    if (contiguousBuffer->hasOneSegment())
        m_segments.append({ 0, contiguousBuffer->m_segments[0].segment.copyRef() });
    m_contiguous = true;
}

SharedBuffer::SharedBuffer(FileSystem::MappedFileData&& data)
    : FragmentedSharedBuffer(WTFMove(data))
{
    m_contiguous = true;
}

RefPtr<SharedBuffer> SharedBuffer::createWithContentsOfFile(const String& filePath, FileSystem::MappedFileMode mappedFileMode, MayUseFileMapping mayUseFileMapping)
{
    if (mayUseFileMapping == MayUseFileMapping::Yes) {
        bool mappingSuccess;
        FileSystem::MappedFileData mappedFileData(filePath, mappedFileMode, mappingSuccess);
        if (mappingSuccess)
            return adoptRef(new SharedBuffer(WTFMove(mappedFileData)));
    }
    return createFromReadingFile(filePath);
}

const uint8_t* SharedBuffer::data() const
{
    if (m_segments.isEmpty())
        return nullptr;
    return m_segments[0].segment->data();
}

WTF::Persistence::Decoder SharedBuffer::decoder() const
{
    return { { data(), size() } };
}

Ref<DataSegment> DataSegment::create(Vector<uint8_t>&& data)
{
    data.shrinkToFit();
    return adoptRef(*new DataSegment(WTFMove(data)));
}

#if USE(CF)
Ref<DataSegment> DataSegment::create(RetainPtr<CFDataRef>&& data)
{
    return adoptRef(*new DataSegment(WTFMove(data)));
}
#endif

#if USE(GLIB)
Ref<DataSegment> DataSegment::create(GRefPtr<GBytes>&& data)
{
    return adoptRef(*new DataSegment(WTFMove(data)));
}
#endif

#if USE(GSTREAMER)
Ref<DataSegment> DataSegment::create(RefPtr<GstMappedOwnedBuffer>&& data)
{
    return adoptRef(*new DataSegment(WTFMove(data)));
}
#endif

Ref<DataSegment> DataSegment::create(FileSystem::MappedFileData&& data)
{
    return adoptRef(*new DataSegment(WTFMove(data)));
}

Ref<DataSegment> DataSegment::create(Provider&& provider)
{
    return adoptRef(*new DataSegment(WTFMove(provider)));
}

const uint8_t* DataSegment::data() const
{
    auto visitor = WTF::makeVisitor(
        [](const Vector<uint8_t>& data) -> const uint8_t* { return data.data(); },
#if USE(CF)
        [](const RetainPtr<CFDataRef>& data) -> const uint8_t* { return CFDataGetBytePtr(data.get()); },
#endif
#if USE(GLIB)
        [](const GRefPtr<GBytes>& data) -> const uint8_t* { return static_cast<const uint8_t*>(g_bytes_get_data(data.get(), nullptr)); },
#endif
#if USE(GSTREAMER)
        [](const RefPtr<GstMappedOwnedBuffer>& data) -> const uint8_t* { return data->data(); },
#endif
        [](const FileSystem::MappedFileData& data) -> const uint8_t* { return static_cast<const uint8_t*>(data.data()); },
        [](const Provider& provider) -> const uint8_t* { return provider.data(); }
    );
    return std::visit(visitor, m_immutableData);
}

bool DataSegment::containsMappedFileData() const
{
    return std::holds_alternative<FileSystem::MappedFileData>(m_immutableData);
}

size_t DataSegment::size() const
{
    auto visitor = WTF::makeVisitor(
        [](const Vector<uint8_t>& data) -> size_t { return data.size(); },

    return std::visit(visitor, m_immutableData);
}

SharedBufferDataView::SharedBufferDataView(Ref<DataSegment>&& segment, size_t positionWithinSegment, std::optional<size_t> size)
    : m_segment(WTFMove(segment))
    , m_positionWithinSegment(positionWithinSegment)
    , m_size(size ? *size : m_segment->size() - positionWithinSegment)

{
}

size_t SharedBufferDataView::size() const
{
    return m_size;
}

const uint8_t* SharedBufferDataView::data() const
{
    return m_segment->data() + m_positionWithinSegment;
}

Ref<SharedBuffer> SharedBufferDataView::createSharedBuffer() const
{
    const Ref<DataSegment> segment = m_segment;
    return SharedBuffer::create(DataSegment::Provider {
        [segment, data = data()]() { return data; },
        [size = size()]() { return size; }
    });
}




/*
 * Copyright (C) 2006-2021 Apple Inc. All rights reserved.
 * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without


namespace WebCore {

class SharedBuffer;
class SharedBufferDataView;

// Data wrapped by a DataSegment should be immutable because it can be referenced by other objects.
// To modify or combine the data, allocate a new DataSegment.
class DataSegment : public ThreadSafeRefCounted<DataSegment> {
public:
    WEBCORE_EXPORT const uint8_t* data() const;
    WEBCORE_EXPORT size_t size() const;
    static Ref<SharedBuffer> create(const char* data, size_t size) { return adoptRef(*new SharedBuffer(data, size)); }
    static Ref<SharedBuffer> create(FileSystem::MappedFileData&& mappedFileData) { return adoptRef(*new SharedBuffer(WTFMove(mappedFileData))); }

    WEBCORE_EXPORT static Ref<DataSegment> create(Vector<uint8_t>&&);
    static RefPtr<SharedBuffer> createWithContentsOfFile(const String& filePath, FileSystem::MappedFileMode = FileSystem::MappedFileMode::Shared, MayUseFileMapping = MayUseFileMapping::Yes);

    static Ref<SharedBuffer> create(Vector<uint8_t>&&);

#if USE(FOUNDATION)
    RetainPtr<NSData> createNSData() const;
    RetainPtr<NSArray> createNSDataArray() const;
    static Ref<SharedBuffer> create(NSData *);
    void append(NSData *);
#endif
#if USE(CF)
    WEBCORE_EXPORT static Ref<DataSegment> create(RetainPtr<CFDataRef>&&);
    static Ref<SharedBuffer> create(CFDataRef);
    void append(CFDataRef);
#endif

#if USE(GLIB)
    WEBCORE_EXPORT static Ref<DataSegment> create(GRefPtr<GBytes>&&);
    GRefPtr<GBytes> createGBytes() const;
#endif

#if USE(GSTREAMER)
    WEBCORE_EXPORT static Ref<DataSegment> create(RefPtr<GstMappedOwnedBuffer>&&);
#endif
    WEBCORE_EXPORT static Ref<DataSegment> create(FileSystem::MappedFileData&&);
    // Iterate the segments using begin() and end() instead.
    // FIXME: Audit the call sites of this function and replace them with iteration if possible.
    const uint8_t* data() const;
    const char* dataAsCharPtr() const { return reinterpret_cast<const char*>(data()); }
    Vector<uint8_t> copyData() const;
    Vector<uint8_t> read(size_t offset, size_t length) const;

    // Similar to copyData() but avoids copying and will take the data instead when it is safe (The SharedBuffer is not shared).
    Vector<uint8_t> extractData();

    // Creates an ArrayBuffer and copies this SharedBuffer's contents to that
    // ArrayBuffer without merging segmented buffers into a flat buffer.
    RefPtr<ArrayBuffer> tryCreateArrayBuffer() const;

    struct Provider {
        Function<const uint8_t*()> data;
        Function<size_t()> size;
    };
    void append(const SharedBuffer&);
    void append(const uint8_t*, size_t);
    void append(const char* data, size_t length) { append(reinterpret_cast<const uint8_t*>(data), length); }
    void append(Vector<uint8_t>&&);

    void clear();

    WEBCORE_EXPORT static Ref<DataSegment> create(Provider&&);
    void copyTo(void* destination, size_t length) const;
    void copyTo(void* destination, size_t offset, size_t length) const;

#if USE(FOUNDATION)
    WEBCORE_EXPORT RetainPtr<NSData> createNSData() const;
#endif
    public:
        WEBCORE_EXPORT const uint8_t* data() const;
        WEBCORE_EXPORT size_t size() const;

    WEBCORE_EXPORT bool containsMappedFileData() const;
        {
            data.shrinkToFit();
            return adoptRef(*new DataSegment(WTFMove(data)));
        }

private:
    explicit DataSegment(Vector<uint8_t>&& data)
        : m_immutableData(WTFMove(data)) { }
#if USE(CF)
    explicit DataSegment(RetainPtr<CFDataRef>&& data)
        : m_immutableData(WTFMove(data)) { }
#endif
#if USE(GLIB)
    explicit DataSegment(GRefPtr<GBytes>&& data)
        : m_immutableData(WTFMove(data)) { }
#endif
#if USE(GSTREAMER)
    explicit DataSegment(RefPtr<GstMappedOwnedBuffer>&& data)
        : m_immutableData(WTFMove(data)) { }
#endif
    explicit DataSegment(FileSystem::MappedFileData&& data)
        : m_immutableData(WTFMove(data)) { }
    explicit DataSegment(Provider&& provider)
        : m_immutableData(WTFMove(provider)) { }

    std::variant<Vector<uint8_t>,
            Function<const uint8_t*()> data;
            Function<size_t()> size;
        };

        static Ref<DataSegment> create(Provider&& provider) { return adoptRef(*new DataSegment(WTFMove(provider))); }

#if USE(FOUNDATION)
        RetainPtr<NSData> createNSData() const;
#endif

        bool containsMappedFileData() const;

    private:
        DataSegment(Vector<uint8_t>&& data)
            : m_immutableData(WTFMove(data)) { }
#if USE(CF)
        RetainPtr<CFDataRef>,
            : m_immutableData(WTFMove(data)) { }
#endif
#if USE(GLIB)
        GRefPtr<GBytes>,
            : m_immutableData(WTFMove(data)) { }
#endif
#if USE(GSTREAMER)
        RefPtr<GstMappedOwnedBuffer>,
            : m_immutableData(WTFMove(data)) { }
#endif
        FileSystem::MappedFileData,
        Provider> m_immutableData;
    friend class FragmentedSharedBuffer;
    friend class SharedBuffer; // For createCFData
};

class FragmentedSharedBuffer : public ThreadSafeRefCounted<FragmentedSharedBuffer> {
public:
    WEBCORE_EXPORT static Ref<FragmentedSharedBuffer> create();
    WEBCORE_EXPORT static Ref<FragmentedSharedBuffer> create(const uint8_t*, size_t);
    static Ref<FragmentedSharedBuffer> create(const char* data, size_t size) { return create(reinterpret_cast<const uint8_t*>(data), size); }
    WEBCORE_EXPORT static Ref<FragmentedSharedBuffer> create(FileSystem::MappedFileData&&);
    WEBCORE_EXPORT static Ref<FragmentedSharedBuffer> create(Ref<SharedBuffer>&&);
    WEBCORE_EXPORT static Ref<FragmentedSharedBuffer> create(Vector<uint8_t>&&);
    WEBCORE_EXPORT static Ref<FragmentedSharedBuffer> create(DataSegment::Provider&&);

#if USE(FOUNDATION)
    WEBCORE_EXPORT RetainPtr<NSArray> createNSDataArray() const;
    WEBCORE_EXPORT static Ref<FragmentedSharedBuffer> create(NSData*);
#endif
#if USE(CF)
    WEBCORE_EXPORT static Ref<FragmentedSharedBuffer> create(CFDataRef);
#endif

#if USE(GLIB)
    WEBCORE_EXPORT static Ref<FragmentedSharedBuffer> create(GBytes*);
#endif

#if USE(GSTREAMER)
    WEBCORE_EXPORT static Ref<FragmentedSharedBuffer> create(GstMappedOwnedBuffer&);
#endif
    WEBCORE_EXPORT Vector<uint8_t> copyData() const;
    WEBCORE_EXPORT Vector<uint8_t> read(size_t offset, size_t length) const;

    // Similar to copyData() but avoids copying and will take the data instead when it is safe (The FragmentedSharedBuffer is not shared).
    Vector<uint8_t> extractData();

    // Creates an ArrayBuffer and copies this FragmentedSharedBuffer's contents to that
    // ArrayBuffer without merging segmented buffers into a flat buffer.
    WEBCORE_EXPORT RefPtr<ArrayBuffer> tryCreateArrayBuffer() const;

    size_t size() const { return m_size; }
    bool isEmpty() const { return !size(); }
    bool isContiguous() const { return m_contiguous; }

    WEBCORE_EXPORT Ref<FragmentedSharedBuffer> copy() const;
    WEBCORE_EXPORT void copyTo(void* destination, size_t length) const;
    WEBCORE_EXPORT void copyTo(void* destination, size_t offset, size_t length) const;

    WEBCORE_EXPORT void forEachSegment(const Function<void(const Span<const uint8_t>&)>&) const;
    WEBCORE_EXPORT bool startsWith(const Span<const uint8_t>& prefix) const;

    using DataSegment = WebCore::DataSegment; // To keep backward compatibility when using FragmentedSharedBuffer::DataSegment

    struct DataSegmentVectorEntry {
        size_t beginPosition;

    using DataSegmentVector = Vector<DataSegmentVectorEntry, 1>;
    DataSegmentVector::const_iterator begin() const { return m_segments.begin(); }
    DataSegmentVector::const_iterator end() const { return m_segments.end(); }
    bool hasOneSegment() const { return m_segments.size() == 1; }

    // begin and end take O(1) time, this takes O(log(N)) time.
    WEBCORE_EXPORT SharedBufferDataView getSomeData(size_t position) const;

    WEBCORE_EXPORT String toHexString() const;

    void hintMemoryNotNeededSoon() const;

    WEBCORE_EXPORT bool operator==(const FragmentedSharedBuffer&) const;
    bool operator!=(const FragmentedSharedBuffer& other) const { return !operator==(other); }

    WEBCORE_EXPORT Ref<SharedBuffer> makeContiguous() const;
    bool operator!=(const SharedBuffer& other) const { return !operator==(other); }

protected:
    friend class SharedBuffer;

    DataSegmentVector m_segments;
    bool m_contiguous { false };

    WEBCORE_EXPORT FragmentedSharedBuffer();
    explicit FragmentedSharedBuffer(const uint8_t* data, size_t size) { append(data, size); }
    explicit FragmentedSharedBuffer(const char* data, size_t size) { append(data, size); }
    explicit FragmentedSharedBuffer(Vector<uint8_t>&& data) { append(WTFMove(data)); }
    WEBCORE_EXPORT explicit FragmentedSharedBuffer(FileSystem::MappedFileData&&);
    WEBCORE_EXPORT explicit FragmentedSharedBuffer(DataSegment::Provider&&);
    WEBCORE_EXPORT explicit FragmentedSharedBuffer(Ref<SharedBuffer>&&);
#if USE(CF)
    WEBCORE_EXPORT explicit FragmentedSharedBuffer(CFDataRef);
#endif
#if USE(GLIB)
    WEBCORE_EXPORT explicit FragmentedSharedBuffer(GBytes*);
#endif
#if USE(GSTREAMER)
    WEBCORE_EXPORT explicit FragmentedSharedBuffer(GstMappedOwnedBuffer&);
#endif
    size_t m_size { 0 };

private:
    friend class SharedBufferBuilder;
    WEBCORE_EXPORT void append(const FragmentedSharedBuffer&);
    WEBCORE_EXPORT void append(const uint8_t*, size_t);
    void append(const char* data, size_t length) { append(reinterpret_cast<const uint8_t*>(data), length); }
    WEBCORE_EXPORT void append(Vector<uint8_t>&&);
#if USE(FOUNDATION)
    WEBCORE_EXPORT void append(NSData *);
#endif
#if USE(CF)
    WEBCORE_EXPORT void append(CFDataRef);
#endif

    WEBCORE_EXPORT void clear();
    Vector<uint8_t> takeData();

    // Combines all the segments into a Vector and returns that vector after clearing the FragmentedSharedBuffer.
    WEBCORE_EXPORT Vector<uint8_t> takeData();
    const DataSegmentVectorEntry* getSegmentForPosition(size_t positition) const;

    static RefPtr<SharedBuffer> createFromReadingFile(const String& filePath);

    size_t m_size { 0 };
    mutable DataSegmentVector m_segments;

#if ASSERT_ENABLED
    mutable bool m_hasBeenCombinedIntoOneSegment { false };
    bool internallyConsistent() const;
#endif
};

// A SharedBuffer is a FragmentedSharedBuffer that allows to directly access its content via the data() and related methods.
class SharedBuffer : public FragmentedSharedBuffer {
public:
    template <typename... Args>
    static Ref<SharedBuffer> create(Args&&... args)
    {
        if constexpr (!sizeof...(Args))
            return adoptRef(*new SharedBuffer());
        else if constexpr (sizeof...(Args) == 1
            && (std::is_same_v<Args, Ref<DataSegment>> &&...))
            return adoptRef(*new SharedBuffer(std::forward<Args>(args)...));
        else {
            auto buffer = FragmentedSharedBuffer::create(std::forward<Args>(args)...);
            return adoptRef(*new SharedBuffer(WTFMove(buffer)));
        }
    }

    WEBCORE_EXPORT const uint8_t* data() const;
    const char* dataAsCharPtr() const { return reinterpret_cast<const char*>(data()); }
    WTF::Persistence::Decoder decoder() const;

    enum class MayUseFileMapping : bool { No, Yes };
    WEBCORE_EXPORT static RefPtr<SharedBuffer> createWithContentsOfFile(const String& filePath, FileSystem::MappedFileMode = FileSystem::MappedFileMode::Shared, MayUseFileMapping = MayUseFileMapping::Yes);

#if USE(FOUNDATION)
    WEBCORE_EXPORT RetainPtr<NSData> createNSData() const;
#endif
#if USE(CF)
    WEBCORE_EXPORT RetainPtr<CFDataRef> createCFData() const;
#endif
#if USE(GLIB)
    WEBCORE_EXPORT GRefPtr<GBytes> createGBytes() const;
#endif

private:
    WEBCORE_EXPORT SharedBuffer();
    WEBCORE_EXPORT explicit SharedBuffer(FileSystem::MappedFileData&&);
    WEBCORE_EXPORT explicit SharedBuffer(Ref<DataSegment>&&);
    WEBCORE_EXPORT explicit SharedBuffer(Ref<FragmentedSharedBuffer>&&);

    WEBCORE_EXPORT static RefPtr<SharedBuffer> createFromReadingFile(const String& filePath);
};

class SharedBufferBuilder {
    WTF_MAKE_FAST_ALLOCATED;
public:
    SharedBufferBuilder() = default;
    explicit SharedBufferBuilder(RefPtr<FragmentedSharedBuffer>&& buffer)
    {
        // We do not want to take a reference to the FragmentedSharedBuffer as all FragmentedSharedBuffer should be immutable
        // once created.
        if (!buffer || (buffer->hasOneRef() && !buffer->isContiguous())) {
            m_buffer = WTFMove(buffer);
            return;
        }
        append(*buffer);
    }
    explicit SharedBufferBuilder(Ref<FragmentedSharedBuffer>&& buffer)
    {
        // We do not want to take a reference to the FragmentedSharedBuffer as all FragmentedSharedBuffer should be immutable
        // once created.
        if (buffer->hasOneRef() && !buffer->isContiguous()) {
            m_buffer = WTFMove(buffer);
            return;
        }
        append(WTFMove(buffer.get()));
    }
    template <typename... Args>
    SharedBufferBuilder(Args&&... args)
        : m_buffer(FragmentedSharedBuffer::create(std::forward<Args>(args)...)) { }

    template <typename... Args>
    void append(Args&&... args)
    {
        ensureBuffer();
        m_buffer->append(std::forward<Args>(args)...);
    }

    explicit operator bool() const { return !isNull(); }
    bool isNull() const { return !m_buffer; }
    bool isEmpty() const { return m_buffer ? m_buffer->isEmpty() : true; }

    size_t size() const { return m_buffer ? m_buffer->size() : 0; }

    void reset() { m_buffer = nullptr; }
    void empty()
    {
        reset();
        ensureBuffer();
    }

    RefPtr<FragmentedSharedBuffer> get() const { return m_buffer; }
    Ref<FragmentedSharedBuffer> copy() const { return m_buffer ? m_buffer->copy() : FragmentedSharedBuffer::create(); }
    Ref<FragmentedSharedBuffer> take()
    {
        ensureBuffer();
        return m_buffer.releaseNonNull();
    }

private:
    void ensureBuffer()
    {
        if (!m_buffer)
            m_buffer = FragmentedSharedBuffer::create();
    }
    RefPtr<FragmentedSharedBuffer> m_buffer;
};

inline Vector<uint8_t> FragmentedSharedBuffer::extractData()
{
    if (hasOneRef())
        return takeData();
    return copyData();
}

class SharedBufferDataView {
public:
    WEBCORE_EXPORT SharedBufferDataView(Ref<DataSegment>&&, size_t positionWithinSegment, std::optional<size_t> newSize = std::nullopt);
    WEBCORE_EXPORT SharedBufferDataView(const SharedBufferDataView&, size_t newSize);
    size_t size() const { return m_size; }
    const uint8_t* data() const { return m_segment->data() + m_positionWithinSegment; }
    const char* dataAsCharPtr() const { return reinterpret_cast<const char*>(data()); }

    WEBCORE_EXPORT Ref<SharedBuffer> createSharedBuffer() const;
#if USE(FOUNDATION)
    WEBCORE_EXPORT RetainPtr<NSData> createNSData() const;
#endif
private:
    const Ref<DataSegment> m_segment;
    const size_t m_positionWithinSegment;
    const size_t m_size;
};




#if ENABLE(MHTML)

SharedBufferChunkReader::SharedBufferChunkReader(FragmentedSharedBuffer* buffer, const Vector<char>& separator)
    : m_iteratorCurrent(buffer->begin())
    , m_iteratorEnd(buffer->end())
    , m_segment(m_iteratorCurrent != m_iteratorEnd ? m_iteratorCurrent->segment->data() : nullptr)

{
}

SharedBufferChunkReader::SharedBufferChunkReader(FragmentedSharedBuffer* buffer, const char* separator)
    : m_iteratorCurrent(buffer->begin())
    , m_iteratorEnd(buffer->end())
    , m_segment(m_iteratorCurrent != m_iteratorEnd ? m_iteratorCurrent->segment->data() : nullptr)




class WEBCORE_EXPORT SharedBufferChunkReader {
public:
    SharedBufferChunkReader(FragmentedSharedBuffer*, const Vector<char>& separator);
    SharedBufferChunkReader(FragmentedSharedBuffer*, const char* separator);

    void setSeparator(const Vector<char>&);
    void setSeparator(const char*);

    size_t peek(Vector<uint8_t>&, size_t);

private:
    FragmentedSharedBuffer::DataSegmentVector::const_iterator m_iteratorCurrent;
    const FragmentedSharedBuffer::DataSegmentVector::const_iterator m_iteratorEnd;
    const uint8_t* m_segment { nullptr };
    size_t m_segmentIndex { 0 };
    Vector<char> m_separator { false };

Lines 73-79 void StaticPasteboard::writeString(const String& type, const String& value) a/Source/WebCore/platform/StaticPasteboard.cpp_sec1
- a/Source/WebCore/platform/StaticPasteboard.cpp -1 / +1 lines
73	m_customData.writeString(type, value);	73	m_customData.writeString(type, value);
74	}	74	}
75		75
76	void StaticPasteboard::writeData(const String& type, Ref<SharedBuffer>&& data)	76	void StaticPasteboard::writeData(const String& type, Ref<FragmentedSharedBuffer>&& data)
77	{	77	{
78	m_nonDefaultDataTypes.add(type);	78	m_nonDefaultDataTypes.add(type);
79	m_customData.writeData(type, WTFMove(data));	79	m_customData.writeData(type, WTFMove(data));




namespace WebCore {

class FragmentedSharedBuffer;

class StaticPasteboard final : public Pasteboard {
public:

    String readStringInCustomData(const String& type) final;

    void writeString(const String& type, const String& data) final;
    void writeData(const String& type, Ref<FragmentedSharedBuffer>&& data);
    void writeStringInCustomData(const String& type, const String& data);
    void clear() final;
    void clear(const String& type) final;



struct NowPlayingInfoArtwork {
    String src;
    String mimeType;
    RefPtr<FragmentedSharedBuffer> imageData;

    bool operator==(const NowPlayingInfoArtwork& other) const
    {

    if (!decoder.decode(mimeType))
        return { };

    RefPtr<FragmentedSharedBuffer> imageData;
    if (!decoder.decode(imageData))
        return { };


Lines 341-347 void MediaSessionManagerCocoa::setNowPlayingInfo(bool setAsNowPlayingApplication a/Source/WebCore/platform/audio/cocoa/MediaSessionManagerCocoa.mm_sec1
- a/Source/WebCore/platform/audio/cocoa/MediaSessionManagerCocoa.mm -1 / +1 lines
341	CFDictionarySetValue(info.get(), kMRMediaRemoteNowPlayingInfoElapsedTime, cfCurrentTime.get());	341	CFDictionarySetValue(info.get(), kMRMediaRemoteNowPlayingInfoElapsedTime, cfCurrentTime.get());
342	}	342	}
343	if (nowPlayingInfo.artwork && nowPlayingInfo.artwork->imageData) {	343	if (nowPlayingInfo.artwork && nowPlayingInfo.artwork->imageData) {
344	auto nsArtwork = nowPlayingInfo.artwork->imageData->createNSData();	344	auto nsArtwork = nowPlayingInfo.artwork->imageData->makeContiguous()->createNSData();
345	CFDictionarySetValue(info.get(), kMRMediaRemoteNowPlayingInfoArtworkData, nsArtwork.get());	345	CFDictionarySetValue(info.get(), kMRMediaRemoteNowPlayingInfoArtworkData, nsArtwork.get());
346	CFDictionarySetValue(info.get(), kMRMediaRemoteNowPlayingInfoArtworkMIMEType, nowPlayingInfo.artwork->mimeType.createCFString().get());	346	CFDictionarySetValue(info.get(), kMRMediaRemoteNowPlayingInfoArtworkMIMEType, nowPlayingInfo.artwork->mimeType.createCFString().get());
347	CFDictionarySetValue(info.get(), kMRMediaRemoteNowPlayingInfoArtworkIdentifier, String::number(nowPlayingInfo.artwork->src.hash()).createCFString().get());	347	CFDictionarySetValue(info.get(), kMRMediaRemoteNowPlayingInfoArtworkIdentifier, String::number(nowPlayingInfo.artwork->src.hash()).createCFString().get());




namespace WebCore {

FragmentedSharedBuffer::FragmentedSharedBuffer(CFDataRef data)
{
    append(data);
}

#if !USE(FOUNDATION)
RetainPtr<CFDataRef> SharedBuffer::createCFData() const
{
    if (hasOneSegment()) {
        if (auto* data = std::get_if<RetainPtr<CFDataRef>>(&m_segments[0].segment->m_immutableData))
            return *data;
    }
    return adoptCF(CFDataCreate(nullptr, data(), size()));
    forEachSegment([&](auto& segment) {
        CFDataAppendBytes(cfData.get(), segment.data(), segment.size());
    });
    return cfData;
}
#endif

Ref<FragmentedSharedBuffer> FragmentedSharedBuffer::create(CFDataRef data)
{
    return adoptRef(*new FragmentedSharedBuffer(data));
}

void FragmentedSharedBuffer::hintMemoryNotNeededSoon() const
{
    for (const auto& entry : m_segments) {
        if (entry.segment->hasOneRef()) {

    }
}

void FragmentedSharedBuffer::append(CFDataRef data)
{
    ASSERT(!m_hasBeenCombinedIntoOneSegment);
    if (data) {
        m_segments.append({m_size, DataSegment::create(data)});
        m_size += CFDataGetLength(data);

Lines 51-57 public: a/Source/WebCore/platform/cocoa/NetworkExtensionContentFilter.h_sec1
- a/Source/WebCore/platform/cocoa/NetworkExtensionContentFilter.h -1 / +1 lines
51	void responseReceived(const ResourceResponse&) override;	51	void responseReceived(const ResourceResponse&) override;
52	void addData(const uint8_t* data, int length) override;	52	void addData(const uint8_t* data, int length) override;
53	void finishedAddingData() override;	53	void finishedAddingData() override;
54	Ref<SharedBuffer> replacementData() const override;	54	Ref<FragmentedSharedBuffer> replacementData() const override;
55	ContentFilterUnblockHandler unblockHandler() const override;	55	ContentFilterUnblockHandler unblockHandler() const override;
56		56
57	WEBCORE_EXPORT static bool isRequired();	57	WEBCORE_EXPORT static bool isRequired();

Lines 175-181 void NetworkExtensionContentFilter::finishedAddingData() a/Source/WebCore/platform/cocoa/NetworkExtensionContentFilter.mm_sec1
- a/Source/WebCore/platform/cocoa/NetworkExtensionContentFilter.mm -1 / +1 lines
175	semaphore.wait();	175	semaphore.wait();
176	}	176	}
177		177
178	Ref<SharedBuffer> NetworkExtensionContentFilter::replacementData() const	178	Ref<FragmentedSharedBuffer> NetworkExtensionContentFilter::replacementData() const
179	{	179	{
180	ASSERT(didBlockData());	180	ASSERT(didBlockData());
181	return SharedBuffer::create(m_replacementData.get());	181	return SharedBuffer::create(m_replacementData.get());

Lines 45-51 public: a/Source/WebCore/platform/cocoa/ParentalControlsContentFilter.h_sec1
- a/Source/WebCore/platform/cocoa/ParentalControlsContentFilter.h -1 / +1 lines
45	void responseReceived(const ResourceResponse&) override;	45	void responseReceived(const ResourceResponse&) override;
46	void addData(const uint8_t* data, int length) override;	46	void addData(const uint8_t* data, int length) override;
47	void finishedAddingData() override;	47	void finishedAddingData() override;
48	Ref<SharedBuffer> replacementData() const override;	48	Ref<FragmentedSharedBuffer> replacementData() const override;
49	#if ENABLE(CONTENT_FILTERING)	49	#if ENABLE(CONTENT_FILTERING)
50	ContentFilterUnblockHandler unblockHandler() const override;	50	ContentFilterUnblockHandler unblockHandler() const override;
51	#endif	51	#endif

Lines 109-115 void ParentalControlsContentFilter::finishedAddingData() a/Source/WebCore/platform/cocoa/ParentalControlsContentFilter.mm_sec1
- a/Source/WebCore/platform/cocoa/ParentalControlsContentFilter.mm -1 / +1 lines
109	updateFilterState();	109	updateFilterState();
110	}	110	}
111		111
112	Ref<SharedBuffer> ParentalControlsContentFilter::replacementData() const	112	Ref<FragmentedSharedBuffer> ParentalControlsContentFilter::replacementData() const
113	{	113	{
114	ASSERT(didBlockData());	114	ASSERT(didBlockData());
115	return SharedBuffer::create(m_replacementData.get());	115	return SharedBuffer::create(m_replacementData.get());



}
#endif // PLATFORM(MAC)

// Making this non-inline so that WebKit 2's decoding doesn't have to include FragmentedSharedBuffer.h.
PasteboardWebContent::PasteboardWebContent() = default;
PasteboardWebContent::~PasteboardWebContent() = default;


}

#if PLATFORM(MAC)
static Ref<SharedBuffer> convertTIFFToPNG(FragmentedSharedBuffer& tiffBuffer)
{
    auto image = adoptNS([[NSBitmapImageRep alloc] initWithData: tiffBuffer.makeContiguous()->createNSData().get()]);
    NSData *pngData = [image representationUsingType:bitmapPNGFileType() properties:@{ }];
    return SharedBuffer::create(pngData);
}



#import <wtf/cocoa/VectorCocoa.h>

@interface WebCoreSharedBufferData : NSData
- (instancetype)initWithDataSegment:(const WebCore::DataSegment&)dataSegment position:(NSUInteger)position size:(NSUInteger)size;
@end

@implementation WebCoreSharedBufferData {
    RefPtr<const WebCore::DataSegment> _dataSegment;
    NSUInteger _position;
    NSUInteger _size;
}

    [super dealloc];
}

- (instancetype)initWithDataSegment:(const WebCore::DataSegment&)dataSegment position:(NSUInteger)position size:(NSUInteger)size
{
    if (!(self = [super init]))
        return nil;


namespace WebCore {

Ref<FragmentedSharedBuffer> FragmentedSharedBuffer::create(NSData *data)
{
    return adoptRef(*new FragmentedSharedBuffer(bridge_cast(data)));
}

void FragmentedSharedBuffer::append(NSData *data)
{
    ASSERT(!m_contiguous);
    return append(bridge_cast(data));
}



RetainPtr<CFDataRef> SharedBuffer::createCFData() const
{
    combineIntoOneSegment();
    if (!m_segments.size())
        return adoptCF(CFDataCreate(nullptr, nullptr, 0));
    ASSERT(m_segments.size() == 1);
    return bridge_cast(m_segments[0].segment->createNSData());
}


    return nullptr;
}

RetainPtr<NSArray> FragmentedSharedBuffer::createNSDataArray() const
{
    return createNSArray(m_segments, [] (auto& segment) {
        return segment.segment->createNSData();
    });
}

RetainPtr<NSData> DataSegment::createNSData() const
{
    return adoptNS([[WebCoreSharedBufferData alloc] initWithDataSegment:*this position:0 size:size()]);
}




namespace WebCore {

class FragmentedSharedBuffer;
class CDMInstanceSession;
struct CDMKeySystemConfiguration;


public:
    virtual ~CDMInstanceClient() = default;

    virtual void unrequestedInitializationDataReceived(const String&, Ref<FragmentedSharedBuffer>&&) = 0;
};

// JavaScript's handle to a CDMInstance, must be used from the

    };

    virtual void initializeWithConfiguration(const CDMKeySystemConfiguration&, AllowDistinctiveIdentifiers, AllowPersistentState, SuccessCallback&&) = 0;
    virtual void setServerCertificate(Ref<FragmentedSharedBuffer>&&, SuccessCallback&&) = 0;
    virtual void setStorageDirectory(const String&) = 0;
    virtual const String& keySystem() const = 0;
    virtual RefPtr<CDMInstanceSession> createSession() = 0;




namespace WebCore {

class FragmentedSharedBuffer;

class CDMInstanceSessionClient : public CanMakeWeakPtr<CDMInstanceSessionClient> {
public:
    virtual ~CDMInstanceSessionClient() = default;

    using KeyStatus = CDMKeyStatus;
    using KeyStatusVector = Vector<std::pair<Ref<FragmentedSharedBuffer>, KeyStatus>>;
    virtual void updateKeyStatuses(KeyStatusVector&&) = 0;
    virtual void sendMessage(CDMMessageType, Ref<FragmentedSharedBuffer>&& message) = 0;
    virtual void sessionIdChanged(const String&) = 0;
    using PlatformDisplayID = uint32_t;
    virtual PlatformDisplayID displayID() = 0;

        Succeeded,
    };

    using LicenseCallback = CompletionHandler<void(Ref<FragmentedSharedBuffer>&& message, const String& sessionId, bool needsIndividualization, SuccessValue succeeded)>;
    virtual void requestLicense(LicenseType, const AtomString& initDataType, Ref<FragmentedSharedBuffer>&& initData, LicenseCallback&&) = 0;

    using KeyStatusVector = CDMInstanceSessionClient::KeyStatusVector;
    using Message = std::pair<MessageType, Ref<FragmentedSharedBuffer>>;
    using LicenseUpdateCallback = CompletionHandler<void(bool sessionWasClosed, std::optional<KeyStatusVector>&& changedKeys, std::optional<double>&& changedExpiration, std::optional<Message>&& message, SuccessValue succeeded)>;
    virtual void updateLicense(const String& sessionId, LicenseType, Ref<FragmentedSharedBuffer>&& response, LicenseUpdateCallback&&) = 0;

    enum class SessionLoadFailure : uint8_t {
        None,

    using CloseSessionCallback = CompletionHandler<void()>;
    virtual void closeSession(const String& sessionId, CloseSessionCallback&&) = 0;

    using RemoveSessionDataCallback = CompletionHandler<void(KeyStatusVector&&, std::optional<Ref<FragmentedSharedBuffer>>&&, SuccessValue)>;
    virtual void removeSessionData(const String& sessionId, LicenseType, RemoveSessionDataCallback&&) = 0;

    virtual void storeRecordOfKeyUsage(const String& sessionId) = 0;



    virtual void loadAndInitialize() = 0;
    virtual bool supportsServerCertificates() const = 0;
    virtual bool supportsSessions() const = 0;
    virtual bool supportsInitData(const AtomString&, const FragmentedSharedBuffer&) const = 0;
    virtual RefPtr<FragmentedSharedBuffer> sanitizeResponse(const FragmentedSharedBuffer&) const = 0;
    virtual std::optional<String> sanitizeSessionId(const String&) const = 0;

protected:

Lines 227-233 CDMInstanceSession::KeyStatusVector KeyStore::convertToJSKeyStatusVector() const a/Source/WebCore/platform/encryptedmedia/CDMProxy.cpp_sec1
- a/Source/WebCore/platform/encryptedmedia/CDMProxy.cpp -1 / +1 lines
227	CDMInstanceSession::KeyStatusVector keyStatusVector;	227	CDMInstanceSession::KeyStatusVector keyStatusVector;
228	keyStatusVector.reserveInitialCapacity(numKeys());	228	keyStatusVector.reserveInitialCapacity(numKeys());
229	for (const auto& key : m_keys)	229	for (const auto& key : m_keys)
230	keyStatusVector.uncheckedAppend(std::pair<Ref<SharedBuffer>, CDMInstanceSession::KeyStatus> { key->idAsSharedBuffer(), key->status() });	230	keyStatusVector.uncheckedAppend(std::pair<Ref<FragmentedSharedBuffer>, CDMInstanceSession::KeyStatus> { key->idAsSharedBuffer(), key->status() });
231	return keyStatusVector;	231	return keyStatusVector;
232	}	232	}
233		233

Lines 61-67 public: a/Source/WebCore/platform/encryptedmedia/CDMProxy.h_sec1
- a/Source/WebCore/platform/encryptedmedia/CDMProxy.h -1 / +1 lines
61	{	61	{
62	return adoptRef(*new KeyHandle(status, WTFMove(keyID), WTFMove(keyHandleValue)));	62	return adoptRef(*new KeyHandle(status, WTFMove(keyID), WTFMove(keyHandleValue)));
63	}	63	}
64	Ref<SharedBuffer> idAsSharedBuffer() const { return SharedBuffer::create(m_id.data(), m_id.size()); }	64	Ref<FragmentedSharedBuffer> idAsSharedBuffer() const { return SharedBuffer::create(m_id.data(), m_id.size()); }
65		65
66	bool takeValueIfDifferent(KeyHandleValueVariant&&);	66	bool takeValueIfDifferent(KeyHandleValueVariant&&);
67		67




namespace CDMUtilities {

RefPtr<JSON::Object> parseJSONObject(const FragmentedSharedBuffer& buffer)
{
    // Fail on large buffers whose size doesn't fit into a 32-bit unsigned integer.
    size_t size = buffer.size();

        return nullptr;

    // Parse the buffer contents as JSON, returning the root object (if any).
    String json { buffer.makeContiguous()->data(), static_cast<unsigned>(size) };

    auto value = JSON::Value::parseJSON(json);
    if (!value)




namespace WebCore {

class FragmentedSharedBuffer;

namespace CDMUtilities {

RefPtr<JSON::Object> parseJSONObject(const FragmentedSharedBuffer&);

};




// ];

// This function extracts the KeyIds count and the location of the first KeyId in initData buffer.
static std::pair<unsigned, unsigned> extractKeyidsLocationFromCencInitData(const FragmentedSharedBuffer& initData)
{
    std::pair<unsigned, unsigned> keyIdsMap(0, 0);


    if (initData.isEmpty() || initData.size() > std::numeric_limits<unsigned>::max())
        return keyIdsMap;

    auto contiguousInitData = initData.makeContiguous();
    auto* data = contiguousInitData->data();
    unsigned initDataSize = initData.size();
    unsigned index = 0;
    unsigned psshSize = 0;

}

// This function checks if the initData sharedBuffer is a valid CENC initData.
static bool isCencInitData(const FragmentedSharedBuffer& initData)
{
    std::pair<unsigned, unsigned> keyIdsMap = extractKeyidsLocationFromCencInitData(initData);
    return ((keyIdsMap.first) && (keyIdsMap.second));
}

static Ref<FragmentedSharedBuffer> extractKeyidsFromCencInitData(const FragmentedSharedBuffer& initData)
{
    SharedBufferBuilder keyIds;

    std::pair<unsigned, unsigned> keyIdsMap = extractKeyidsLocationFromCencInitData(initData);
    unsigned keyIdCount = keyIdsMap.first;


    // Check if initData is a valid CENC initData.
    if (!keyIdCount || !index)
        return keyIds.take();

    auto contiguousInitData = initData.makeContiguous();
    auto* data = contiguousInitData->data();

    auto object = JSON::Object::create();
    auto keyIdsArray = JSON::Array::create();


    object->setArray("kids", WTFMove(keyIdsArray));
    CString jsonData = object->toJSONString().utf8();
    keyIds.append(jsonData.data(), jsonData.length());
    return keyIds.take();
}

static Ref<FragmentedSharedBuffer> extractKeyIdFromWebMInitData(const FragmentedSharedBuffer& initData)
{
    SharedBufferBuilder keyIds;

    // Check if initData is a valid WebM initData.
    if (initData.isEmpty() || initData.size() > std::numeric_limits<unsigned>::max())
        return keyIds.take();

    auto object = JSON::Object::create();
    auto keyIdsArray = JSON::Array::create();

    // The format is a JSON object containing the following members:
    // "kids"
    // An array of key IDs. Each element of the array is the base64url encoding of the octet sequence containing the key ID value.
    keyIdsArray->pushString(base64URLEncodeToString(initData.makeContiguous()->data(), initData.size()));

    object->setArray("kids", WTFMove(keyIdsArray));
    CString jsonData = object->toJSONString().utf8();
    keyIds.append(jsonData.data(), jsonData.length());
    return keyIds.take();
}

CDMFactoryClearKey& CDMFactoryClearKey::singleton()

    return true;
}

bool CDMPrivateClearKey::supportsInitData(const AtomString& initDataType, const FragmentedSharedBuffer& initData) const
{
    // Validate the initData buffer as an JSON object in keyids case.
    if (equalLettersIgnoringASCIICase(initDataType, "keyids") && CDMUtilities::parseJSONObject(initData))

    return false;
}

RefPtr<FragmentedSharedBuffer> CDMPrivateClearKey::sanitizeResponse(const FragmentedSharedBuffer& response) const
{
    // Validate the response buffer as an JSON object.
    if (!CDMUtilities::parseJSONObject(response))

    callback(succeeded);
}

void CDMInstanceClearKey::setServerCertificate(Ref<FragmentedSharedBuffer>&&, SuccessCallback&& callback)
{
    // Reject setting any server certificate.
    callback(Failed);

    return adoptRef(new CDMInstanceSessionClearKey(*this));
}

void CDMInstanceSessionClearKey::requestLicense(LicenseType, const AtomString& initDataType, Ref<FragmentedSharedBuffer>&& initData, LicenseCallback&& callback)
{
    static uint32_t s_sessionIdValue = 0;
    ++s_sessionIdValue;

        });
}

void CDMInstanceSessionClearKey::updateLicense(const String& sessionId, LicenseType, Ref<FragmentedSharedBuffer>&& response, LicenseUpdateCallback&& callback)
{
#if LOG_DISABLED
    // We only use the sesion ID for debug logging. The verbose preprocessor checks are because

    ASSERT(sessionId == m_sessionID);

    auto dispatchCallback =
        [weakThis = WeakPtr { *this }, &callback](KeyStatusVector&& keyStatusVector, std::optional<Ref<FragmentedSharedBuffer>>&& message, SuccessValue success) {
            callOnMainThread(
                [weakThis = WeakPtr { *weakThis }, callback = WTFMove(callback), keyStatusVector = WTFMove(keyStatusVector), message = WTFMove(message), success]() mutable {
                    if (!weakThis)

    // Construct the KeyStatusVector object, representing released keys, and the message in the
    // 'license release' format.
    KeyStatusVector keyStatusVector = m_keyStore.allKeysAs(CDMInstanceSession::KeyStatus::Released);
    RefPtr<FragmentedSharedBuffer> message;
    {
        // Construct JSON that represents the 'license release' format, creating a 'kids' array
        // of base64URL-encoded key IDs for all keys that were associated with this session.

            rootObject->setArray("kids", WTFMove(array));
        }

        // Copy the JSON data into a FragmentedSharedBuffer object.
        String messageString = rootObject->toJSONString();
        CString messageCString = messageString.utf8();
        message = SharedBuffer::create(messageCString.data(), messageCString.length());
    }

    m_keyStore.unrefAllKeys();
    dispatchCallback(WTFMove(keyStatusVector), Ref<FragmentedSharedBuffer>(*message), SuccessValue::Succeeded);
}

void CDMInstanceSessionClearKey::storeRecordOfKeyUsage(const String&)



    void loadAndInitialize() final;
    bool supportsServerCertificates() const final;
    bool supportsSessions() const final;
    bool supportsInitData(const AtomString&, const FragmentedSharedBuffer&) const final;
    RefPtr<FragmentedSharedBuffer> sanitizeResponse(const FragmentedSharedBuffer&) const final;
    std::optional<String> sanitizeSessionId(const String&) const final;
};


    // CDMInstance
    ImplementationType implementationType() const final { return ImplementationType::ClearKey; }
    void initializeWithConfiguration(const CDMKeySystemConfiguration&, AllowDistinctiveIdentifiers, AllowPersistentState, SuccessCallback&&) final;
    void setServerCertificate(Ref<FragmentedSharedBuffer>&&, SuccessCallback&&) final;
    void setStorageDirectory(const String&) final;
    const String& keySystem() const final;
    RefPtr<CDMInstanceSession> createSession() final;

public:
    CDMInstanceSessionClearKey(CDMInstanceClearKey& parent)
        : CDMInstanceSessionProxy(parent) { }
    void requestLicense(LicenseType, const AtomString& initDataType, Ref<FragmentedSharedBuffer>&& initData, LicenseCallback&&) final;
    void updateLicense(const String&, LicenseType, Ref<FragmentedSharedBuffer>&&, LicenseUpdateCallback&&) final;
    void loadSession(LicenseType, const String&, const String&, LoadSessionCallback&&) final;
    void closeSession(const String&, CloseSessionCallback&&) final;
    void removeSessionData(const String&, LicenseType, RemoveSessionDataCallback&&) final;

Lines 33-39 a/Source/WebCore/platform/generic/KeyedEncoderGeneric.h_sec1
- a/Source/WebCore/platform/generic/KeyedEncoderGeneric.h -1 / +1 lines
33		33
34	namespace WebCore {	34	namespace WebCore {
35		35
36	class SharedBuffer;	36	class FragmentedSharedBuffer;
37		37
38	class KeyedEncoderGeneric final : public KeyedEncoder {	38	class KeyedEncoderGeneric final : public KeyedEncoder {
39	public:	39	public:




namespace WebCore {

FragmentedSharedBuffer::FragmentedSharedBuffer(GBytes* bytes)
{
    ASSERT(bytes);
    m_size = g_bytes_get_size(bytes);
    m_segments.append({ 0, DataSegment::create(GRefPtr<GBytes>(bytes)) });
}

Ref<FragmentedSharedBuffer> FragmentedSharedBuffer::create(GBytes* bytes)
{
    return adoptRef(*new FragmentedSharedBuffer(bytes));
}

GRefPtr<GBytes> SharedBuffer::createGBytes() const

Lines 59-65 namespace WebCore { a/Source/WebCore/platform/graphics/Font.h_sec1
- a/Source/WebCore/platform/graphics/Font.h -1 / +1 lines
59	class FontCache;	59	class FontCache;
60	class FontDescription;	60	class FontDescription;
61	class GlyphPage;	61	class GlyphPage;
62	class SharedBuffer;	62	class FragmentedSharedBuffer;
63		63
64	struct GlyphData;	64	struct GlyphData;
65		65

Lines 74-80 interface IDWriteFontFace; a/Source/WebCore/platform/graphics/FontPlatformData.h_sec1
- a/Source/WebCore/platform/graphics/FontPlatformData.h -1 lines
74	namespace WebCore {	74	namespace WebCore {
75		75
76	class FontDescription;	76	class FontDescription;
77	class SharedBuffer;
78		77
79	// This class is conceptually immutable. Once created, no instances should ever change (in an observable way).	78	// This class is conceptually immutable. Once created, no instances should ever change (in an observable way).
80	class FontPlatformData {	79	class FontPlatformData {

Lines 104-110 bool Image::isPostScriptResource(const String& mimeType, const URL& url) a/Source/WebCore/platform/graphics/Image.cpp_sec1
- a/Source/WebCore/platform/graphics/Image.cpp -1 / +1 lines
104	}	104	}
105		105
106		106
107	EncodedDataStatus Image::setData(RefPtr<SharedBuffer>&& data, bool allDataReceived)	107	EncodedDataStatus Image::setData(RefPtr<FragmentedSharedBuffer>&& data, bool allDataReceived)
108	{	108	{
109	m_encodedImageData = WTFMove(data);	109	m_encodedImageData = WTFMove(data);
110		110



class FloatPoint;
class FloatSize;
class GraphicsContext;
class FragmentedSharedBuffer;
struct Length;

// This class gets notified when an image creates or destroys decoded frames and when it advances animation frames.

    virtual std::optional<IntPoint> hotSpot() const { return std::nullopt; }
    virtual ImageOrientation orientation() const { return ImageOrientation::FromImage; }

    WEBCORE_EXPORT EncodedDataStatus setData(RefPtr<FragmentedSharedBuffer>&& data, bool allDataReceived);
    virtual EncodedDataStatus dataChanged(bool /*allDataReceived*/) { return EncodedDataStatus::Unknown; }

    virtual String uti() const { return String(); } // null string if unknown


    virtual void destroyDecodedData(bool destroyAll = true) = 0;

    FragmentedSharedBuffer* data() { return m_encodedImageData.get(); }
    const FragmentedSharedBuffer* data() const { return m_encodedImageData.get(); }

    virtual DestinationColorSpace colorSpace();


    virtual Color singlePixelSolidColor() const { return Color(); }

private:
    RefPtr<FragmentedSharedBuffer> m_encodedImageData;
    ImageObserver* m_imageObserver;
    std::unique_ptr<Timer> m_animationStartTimer;
};



            return false;

        buffer.grow(bufferSize);
        m_pixels = FragmentedSharedBuffer::DataSegment::create(WTFMove(buffer));
        m_pixelsPtr = reinterpret_cast<uint32_t*>(const_cast<uint8_t*>(m_pixels->data()));
        m_size = size;
        m_frameRect = IntRect(IntPoint(), m_size);

    {
        ASSERT(!m_size.isEmpty() && !isOverSize(m_size));
        Vector<uint8_t> buffer { other.m_pixels->data(), other.m_pixels->size() };
        m_pixels = FragmentedSharedBuffer::DataSegment::create(WTFMove(buffer));
        m_pixelsPtr = reinterpret_cast<uint32_t*>(const_cast<uint8_t*>(m_pixels->data()));
    }


        return PackedColor::ARGB { result }.value;
    }

    RefPtr<FragmentedSharedBuffer::DataSegment> m_pixels;
    uint32_t* m_pixelsPtr { nullptr };
    IntSize m_size;
    IntRect m_frameRect; // This will always just be the entire buffer except for GIF and PNG frames

Lines 82-88 void ImageDecoder::clearFactories() a/Source/WebCore/platform/graphics/ImageDecoder.cpp_sec1
- a/Source/WebCore/platform/graphics/ImageDecoder.cpp -1 / +1 lines
82	}	82	}
83	#endif	83	#endif
84		84
85	RefPtr<ImageDecoder> ImageDecoder::create(SharedBuffer& data, const String& mimeType, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)	85	RefPtr<ImageDecoder> ImageDecoder::create(FragmentedSharedBuffer& data, const String& mimeType, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
86	{	86	{
87	UNUSED_PARAM(mimeType);	87	UNUSED_PARAM(mimeType);
88		88




namespace WebCore {

class FragmentedSharedBuffer;

class ImageDecoder : public ThreadSafeRefCounted<ImageDecoder> {
    WTF_MAKE_FAST_ALLOCATED;
public:
    static RefPtr<ImageDecoder> create(FragmentedSharedBuffer&, const String& mimeType, AlphaOption, GammaAndColorProfileOption);
    virtual ~ImageDecoder() = default;

    enum class MediaType {

#if ENABLE(GPU_PROCESS)
    using SupportsMediaTypeFunc = Function<bool(MediaType)>;
    using CanDecodeTypeFunc = Function<bool(const String&)>;
    using CreateImageDecoderFunc = Function<RefPtr<ImageDecoder>(FragmentedSharedBuffer&, const String&, AlphaOption, GammaAndColorProfileOption)>;

    struct ImageDecoderFactory {
        SupportsMediaTypeFunc supportsMediaType;

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

    virtual void setExpectedContentSize(long long) { }
    virtual void setData(FragmentedSharedBuffer&, bool allDataReceived) = 0;
    virtual bool isAllDataReceived() const = 0;
    virtual void clearFrameBufferCache(size_t) = 0;




    ASSERT(&m_runLoop == &RunLoop::current());
}

bool ImageSource::ensureDecoderAvailable(FragmentedSharedBuffer* data)
{
    if (!data || isDecoderAvailable())
        return true;

    return true;
}

void ImageSource::setData(FragmentedSharedBuffer* data, bool allDataReceived)
{
    if (!data || !ensureDecoderAvailable(data))
        return;

    m_decoder->setData(*data, allDataReceived);
}

void ImageSource::resetData(FragmentedSharedBuffer* data)
{
    m_decoder = nullptr;
    setData(data, isAllDataReceived());
}

EncodedDataStatus ImageSource::dataChanged(FragmentedSharedBuffer* data, bool allDataReceived)
{
    setData(data, allDataReceived);
    clearMetadata();



class BitmapImage;
class GraphicsContext;
class ImageDecoder;
class FragmentedSharedBuffer;

class ImageSource : public ThreadSafeRefCounted<ImageSource>, public CanMakeWeakPtr<ImageSource> {
    friend class BitmapImage;

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

    void setData(FragmentedSharedBuffer* data, bool allDataReceived);
    void resetData(FragmentedSharedBuffer* data);
    EncodedDataStatus dataChanged(FragmentedSharedBuffer* data, bool allDataReceived);
    bool isAllDataReceived();

    unsigned decodedSize() const { return m_decodedSize; }

    template<typename T>
    T firstFrameMetadataCacheIfNeeded(T& cachedValue, MetadataType, T (ImageFrame::*functor)() const, ImageFrame::Caching, const std::optional<SubsamplingLevel>& = { });

    bool ensureDecoderAvailable(FragmentedSharedBuffer* data);
    bool isDecoderAvailable() const { return m_decoder; }
    void destroyDecodedData(size_t frameCount, size_t excludeFrame);
    void decodedSizeChanged(long long decodedSize);




namespace WebCore {

Ref<Model> Model::create(Ref<SharedBuffer>&& data, String mimeType, URL url)
{
    return adoptRef(*new Model(WTFMove(data), WTFMove(mimeType), WTFMove(url)));
}

Model::Model(Ref<SharedBuffer>&& data, String mimeType, URL url)
    : m_data(WTFMove(data))
    , m_mimeType(WTFMove(mimeType))
    , m_url(WTFMove(url))




class Model final : public RefCounted<Model> {
public:
    WEBCORE_EXPORT static Ref<Model> create(Ref<SharedBuffer>&&, String, URL);
    WEBCORE_EXPORT ~Model();

    Ref<SharedBuffer> data() const { return m_data; }

    template<class Decoder> static RefPtr<Model> decode(Decoder&);

private:
    explicit Model(Ref<SharedBuffer>&&, String, URL);

    Ref<SharedBuffer> m_data;
    String m_mimeType;

void Model::encode(Encoder& encoder) const
{
    encoder << static_cast<size_t>(m_data->size());
    encoder.encodeFixedLengthData(m_data->makeContiguous()->data(), m_data->size(), 1);
    encoder << m_mimeType;
    encoder << m_url;
}



    virtual void redirectReceived(PlatformMediaResource&, ResourceRequest&& request, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&& completionHandler) { completionHandler(WTFMove(request)); }
    virtual bool shouldCacheResponse(PlatformMediaResource&, const ResourceResponse&) { return true; }
    virtual void dataSent(PlatformMediaResource&, unsigned long long, unsigned long long) { }
    virtual void dataReceived(PlatformMediaResource&, Ref<FragmentedSharedBuffer>&&) { RELEASE_ASSERT_NOT_REACHED(); }
    // This method should be removed once CachedRawResourceClient uses FragmentedSharedBuffer.
    virtual void dataReceived(PlatformMediaResource& platform, const uint8_t* data, int length) { dataReceived(platform, SharedBuffer::create(data, length)); }
    virtual void accessControlCheckFailed(PlatformMediaResource&, const ResourceError&) { }
    virtual void loadFailed(PlatformMediaResource&, const ResourceError&) { }



    return skd;
}

static Vector<Ref<FragmentedSharedBuffer>> extractSinfData(const FragmentedSharedBuffer& buffer)
{
    // JSON of the format: "{ sinf: [ <base64-encoded-string> ] }"
    if (buffer.size() > std::numeric_limits<unsigned>::max())
        return { };
    String json { buffer.makeContiguous()->data(), static_cast<unsigned>(buffer.size()) };

    auto value = JSON::Value::parseJSON(json);
    if (!value)

    if (!sinfArray)
        return { };

    Vector<Ref<FragmentedSharedBuffer>> sinfs;
    sinfs.reserveInitialCapacity(sinfArray->length());

    for (auto& value : *sinfArray) {

}

using SchemeAndKeyResult = Vector<std::pair<FourCC, Vector<uint8_t>>>;
static SchemeAndKeyResult extractSchemeAndKeyIdFromSinf(const FragmentedSharedBuffer& buffer)
{
    auto buffers = extractSinfData(buffer);
    if (!buffers.size())

    return result;
}

std::optional<Vector<Ref<FragmentedSharedBuffer>>> CDMPrivateFairPlayStreaming::extractKeyIDsSinf(const FragmentedSharedBuffer& buffer)
{
    Vector<Ref<FragmentedSharedBuffer>> keyIDs;
    auto results = extractSchemeAndKeyIdFromSinf(buffer);

    for (auto& result : results) {

    return keyIDs;
}

RefPtr<FragmentedSharedBuffer> CDMPrivateFairPlayStreaming::sanitizeSinf(const FragmentedSharedBuffer& buffer)
{
    // Common SINF Box Format
    UNUSED_PARAM(buffer);

    return buffer.copy();
}

RefPtr<FragmentedSharedBuffer> CDMPrivateFairPlayStreaming::sanitizeSkd(const FragmentedSharedBuffer& buffer)
{
    UNUSED_PARAM(buffer);
    notImplemented();
    return buffer.copy();
}

std::optional<Vector<Ref<FragmentedSharedBuffer>>> CDMPrivateFairPlayStreaming::extractKeyIDsSkd(const FragmentedSharedBuffer& buffer)
{
    // In the 'skd' scheme, the init data is the key ID.
    Vector<Ref<FragmentedSharedBuffer>> keyIDs;
    keyIDs.append(buffer.copy());
    return keyIDs;
}

    return true;
}

bool CDMPrivateFairPlayStreaming::supportsInitData(const AtomString& initDataType, const FragmentedSharedBuffer& initData) const
{
    if (!validInitDataTypes().contains(initDataType))
        return false;

    return false;
}

RefPtr<FragmentedSharedBuffer> CDMPrivateFairPlayStreaming::sanitizeResponse(const FragmentedSharedBuffer& response) const
{
    return response.copy();
}



    void loadAndInitialize() override;
    bool supportsServerCertificates() const override;
    bool supportsSessions() const override;
    bool supportsInitData(const AtomString&, const FragmentedSharedBuffer&) const override;
    RefPtr<FragmentedSharedBuffer> sanitizeResponse(const FragmentedSharedBuffer&) const override;
    std::optional<String> sanitizeSessionId(const String&) const override;

    static const AtomString& sinfName();
    static std::optional<Vector<Ref<FragmentedSharedBuffer>>> extractKeyIDsSinf(const FragmentedSharedBuffer&);
    static RefPtr<FragmentedSharedBuffer> sanitizeSinf(const FragmentedSharedBuffer&);

    static const AtomString& skdName();
    static std::optional<Vector<Ref<FragmentedSharedBuffer>>> extractKeyIDsSkd(const FragmentedSharedBuffer&);
    static RefPtr<FragmentedSharedBuffer> sanitizeSkd(const FragmentedSharedBuffer&);

    static const Vector<FourCC>& validFairPlayStreamingSchemes();




    ImplementationType implementationType() const final { return ImplementationType::FairPlayStreaming; }

    void initializeWithConfiguration(const CDMKeySystemConfiguration&, AllowDistinctiveIdentifiers, AllowPersistentState, SuccessCallback&&) final;
    void setServerCertificate(Ref<FragmentedSharedBuffer>&&, SuccessCallback&&) final;
    void setStorageDirectory(const String&) final;
    RefPtr<CDMInstanceSession> createSession() final;
    void setClient(WeakPtr<CDMInstanceClient>&&) final;


    NSURL *storageURL() const { return m_storageURL.get(); }
    bool persistentStateAllowed() const { return m_persistentStateAllowed; }
    FragmentedSharedBuffer* serverCertificate() const { return m_serverCertificate.get(); }
    AVContentKeySession* contentKeySession();

    RetainPtr<AVContentKeyRequest> takeUnexpectedKeyRequestForInitializationData(const AtomString& initDataType, FragmentedSharedBuffer& initData);

    // AVContentKeySessionDelegateClient
    void didProvideRequest(AVContentKeyRequest*) final;

    void outputObscuredDueToInsufficientExternalProtectionChanged(bool) final;
    void externalProtectionStatusDidChangeForContentKeyRequest(AVContentKeyRequest*) final;

    using Keys = Vector<Ref<FragmentedSharedBuffer>>;
    CDMInstanceSessionFairPlayStreamingAVFObjC* sessionForKeyIDs(const Keys&) const;
    CDMInstanceSessionFairPlayStreamingAVFObjC* sessionForGroup(AVContentKeyReportGroup*) const;
    CDMInstanceSessionFairPlayStreamingAVFObjC* sessionForRequest(AVContentKeyRequest*) const;

    WeakPtr<CDMInstanceClient> m_client;
    RetainPtr<AVContentKeySession> m_session;
    RetainPtr<WebCoreFPSContentKeySessionDelegate> m_delegate;
    RefPtr<FragmentedSharedBuffer> m_serverCertificate;
    bool m_persistentStateAllowed { true };
    RetainPtr<NSURL> m_storageURL;
    Vector<WeakPtr<CDMInstanceSessionFairPlayStreamingAVFObjC>> m_sessions;

#endif

    // CDMInstanceSession
    void requestLicense(LicenseType, const AtomString& initDataType, Ref<FragmentedSharedBuffer>&& initData, LicenseCallback&&) final;
    void updateLicense(const String&, LicenseType, Ref<FragmentedSharedBuffer>&&, LicenseUpdateCallback&&) final;
    void loadSession(LicenseType, const String&, const String&, LoadSessionCallback&&) final;
    void closeSession(const String&, CloseSessionCallback&&) final;
    void removeSessionData(const String&, LicenseType, RemoveSessionDataCallback&&) final;



    return AtomString(nsInitType);
}

static Ref<FragmentedSharedBuffer> initializationDataForRequest(AVContentKeyRequest* request)
{
    if (!request)
        return SharedBuffer::create();

    return m_session.get();
}

RetainPtr<AVContentKeyRequest> CDMInstanceFairPlayStreamingAVFObjC::takeUnexpectedKeyRequestForInitializationData(const AtomString& initDataType, FragmentedSharedBuffer& initData)
{
    for (auto requestIter = m_unexpectedKeyRequests.begin(); requestIter != m_unexpectedKeyRequests.end(); ++requestIter) {
        auto& request = *requestIter;

    ResponseMap m_responses;
};

static RefPtr<JSON::Value> parseJSONValue(const FragmentedSharedBuffer& buffer)
{
    // Fail on large buffers whose size doesn't fit into a 32-bit unsigned integer.
    size_t size = buffer.size();

        return nullptr;

    // Parse the buffer contents as JSON, returning the root object (if any).
    String json { buffer.makeContiguous()->data(), static_cast<unsigned>(size) };

    return JSON::Value::parseJSON(json);
}

    callback(initialize());
}

void CDMInstanceFairPlayStreamingAVFObjC::setServerCertificate(Ref<FragmentedSharedBuffer>&& serverCertificate, SuccessCallback&& callback)
{
    DEBUG_LOG_IF_POSSIBLE(LOGIDENTIFIER);
    m_serverCertificate = WTFMove(serverCertificate);

            continue;

        auto sessionKeys = sessionInterface->keyIDs();
        if (anyOf(sessionKeys, [&](const Ref<FragmentedSharedBuffer>& sessionKey) {
            return keyIDs.findMatching([&](const Ref<FragmentedSharedBuffer>& keyID) {
                return keyID.get() == sessionKey.get();
            }) != notFound;
        }))

    return keyIDs;
}

void CDMInstanceSessionFairPlayStreamingAVFObjC::requestLicense(LicenseType licenseType, const AtomString& initDataType, Ref<FragmentedSharedBuffer>&& initData, LicenseCallback&& callback)
{
    if (!isLicenseTypeSupported(licenseType)) {
        DEBUG_LOG_IF_POSSIBLE(LOGIDENTIFIER, " false, licenseType \"", licenseType, "\" not supported");

    RetainPtr<NSData> initializationData;

    if (initDataType == CDMPrivateFairPlayStreaming::sinfName())
        initializationData = initData->makeContiguous()->createNSData();
    else if (initDataType == CDMPrivateFairPlayStreaming::skdName())
        identifier = adoptNS([[NSString alloc] initWithData:initData->makeContiguous()->createNSData().get() encoding:NSUTF8StringEncoding]);
#if HAVE(FAIRPLAYSTREAMING_CENC_INITDATA)
    else if (initDataType == InitDataRegistry::cencName()) {
        auto psshString = base64EncodeToString(initData->makeContiguous()->data(), initData->size());
        initializationData = [NSJSONSerialization dataWithJSONObject:@{ @"pssh": (NSString*)psshString } options:NSJSONWritingPrettyPrinted error:nil];
    }
#endif

    }
}

static bool isEqual(const FragmentedSharedBuffer& data, const String& value)
{
    auto arrayBuffer = data.tryCreateArrayBuffer();
    if (!arrayBuffer)

    return stringOrException.returnValue() == value;
}

void CDMInstanceSessionFairPlayStreamingAVFObjC::updateLicense(const String&, LicenseType, Ref<FragmentedSharedBuffer>&& responseData, LicenseUpdateCallback&& callback)
{
    if (!m_expiredSessions.isEmpty() && isEqual(responseData, "acknowledged"_s)) {
        auto* certificate = m_instance->serverCertificate();

        auto expiredSessions = createNSArray(m_expiredSessions, [] (auto& data) {
            return data.get();
        });
        auto appIdentifier = certificate->makeContiguous()->createNSData();
        [PAL::getAVContentKeySessionClass() removePendingExpiredSessionReports:expiredSessions.get() withAppIdentifier:appIdentifier.get() storageDirectoryAtURL:storageURL];
        callback(false, { }, std::nullopt, std::nullopt, Succeeded);
        return;

            auto keyID = SharedBuffer::create(WTFMove(*keyIDVector));
            auto foundIndex = m_currentRequest.value().requests.findMatching([&] (auto& request) {
                auto keyIDs = keyIDsForRequest(request.get());
                return keyIDs.findMatching([&](const Ref<FragmentedSharedBuffer>& id) {
                    return id.get() == keyID.get();
                }) != notFound;
            });

                if (!payloadVector)
                    return false;
                auto payloadData = SharedBuffer::create(WTFMove(*payloadVector));
                [request processContentKeyResponse:[PAL::getAVContentKeyResponseClass() contentKeyResponseWithFairPlayStreamingKeyResponseData:payloadData->makeContiguous()->createNSData().get()]];
            }
            return true;
        };

        }
    } else {
        DEBUG_LOG_IF_POSSIBLE(LOGIDENTIFIER, "'sinf' initData, processing response");
        [m_currentRequest.value().requests.first() processContentKeyResponse:[PAL::getAVContentKeyResponseClass() contentKeyResponseWithFairPlayStreamingKeyResponseData:responseData->makeContiguous()->createNSData().get()]];
    }

    // FIXME(rdar://problem/35592277): stash the callback and call it once AVContentKeyResponse supports a success callback.

            return;
        }

        RetainPtr<NSData> appIdentifier = certificate->makeContiguous()->createNSData();
        KeyStatusVector changedKeys;
        for (NSData* expiredSessionData in [PAL::getAVContentKeySessionClass() pendingExpiredSessionReportsWithAppIdentifier:appIdentifier.get() storageDirectoryAtURL:storageURL]) {
            static const NSString *PlaybackSessionIdKey = @"PlaybackSessionID";

            return;
        }

        RetainPtr<NSData> appIdentifier = certificate->makeContiguous()->createNSData();
        RetainPtr<NSMutableArray> expiredSessionsArray = adoptNS([[NSMutableArray alloc] init]);
        KeyStatusVector changedKeys;
        for (NSData* expiredSessionData in [PAL::getAVContentKeySessionClass() pendingExpiredSessionReportsWithAppIdentifier:appIdentifier.get() storageDirectoryAtURL:storageURL]) {


    RetainPtr<NSData> appIdentifier;
    if (auto* certificate = m_instance->serverCertificate())
        appIdentifier = certificate->makeContiguous()->createNSData();

    auto keyIDs = keyIDsForRequest(request);
    if (keyIDs.isEmpty()) {

        return;
    }

    RetainPtr<NSData> contentIdentifier = keyIDs.first()->makeContiguous()->createNSData();
    @try {
        [request makeStreamingContentKeyRequestDataForApp:appIdentifier.get() contentIdentifier:contentIdentifier.get() options:nil completionHandler:[this, weakThis = WeakPtr { *this }] (NSData *contentKeyRequestData, NSError *error) mutable {
            callOnMainThread([this, weakThis = WTFMove(weakThis), error = retainPtr(error), contentKeyRequestData = retainPtr(contentKeyRequestData)] {


    RetainPtr<NSData> appIdentifier;
    if (auto* certificate = m_instance->serverCertificate())
        appIdentifier = certificate->makeContiguous()->createNSData();

    using RequestsData = Vector<std::pair<RefPtr<FragmentedSharedBuffer>, RetainPtr<NSData>>>;
    struct CallbackAggregator final : public ThreadSafeRefCounted<CallbackAggregator> {
        using CallbackFunction = Function<void(RequestsData&&)>;
        static RefPtr<CallbackAggregator> create(CallbackFunction&& completionHandler)

            auto entry = JSON::Object::create();
            auto& keyID = requestData.first;
            auto& payload = requestData.second;
            entry->setString("keyID", base64EncodeToString(keyID->makeContiguous()->data(), keyID->size()));
            entry->setString("payload", base64EncodeToString(payload.get().bytes, payload.get().length));
            requestJSON->pushObject(WTFMove(entry));
        }

    @try {
        for (auto request : m_currentRequest.value().requests) {
            auto keyIDs = keyIDsForRequest(request.get());
            RefPtr<FragmentedSharedBuffer> keyID = WTFMove(keyIDs.first());
            auto contentIdentifier = keyID->makeContiguous()->createNSData();
            [request makeStreamingContentKeyRequestDataForApp:appIdentifier.get() contentIdentifier:contentIdentifier.get() options:nil completionHandler:[keyID = WTFMove(keyID), aggregator] (NSData *contentKeyRequestData, NSError *error) mutable {
                UNUSED_PARAM(error);
                callOnMainThread([keyID = WTFMove(keyID), aggregator = WTFMove(aggregator), contentKeyRequestData = retainPtr(contentKeyRequestData)] () mutable {


    RetainPtr<NSData> appIdentifier;
    if (auto* certificate = m_instance->serverCertificate())
        appIdentifier = certificate->makeContiguous()->createNSData();
    auto keyIDs = keyIDsForRequest(m_currentRequest.value());

    RetainPtr<NSData> contentIdentifier = keyIDs.first()->makeContiguous()->createNSData();
    @try {
        [request makeStreamingContentKeyRequestDataForApp:appIdentifier.get() contentIdentifier:contentIdentifier.get() options:nil completionHandler:[this, weakThis = WeakPtr { *this }] (NSData *contentKeyRequestData, NSError *error) mutable {
            callOnMainThread([this, weakThis = WTFMove(weakThis), error = retainPtr(error), contentKeyRequestData = retainPtr(contentKeyRequestData)] {




class ImageDecoderAVFObjC : public ImageDecoder {
public:
    WEBCORE_EXPORT static RefPtr<ImageDecoderAVFObjC> create(FragmentedSharedBuffer&, const String& mimeType, AlphaOption, GammaAndColorProfileOption);
    virtual ~ImageDecoderAVFObjC();

    WEBCORE_EXPORT static bool supportsMediaType(MediaType);

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

    WEBCORE_EXPORT void setExpectedContentSize(long long) final;
    WEBCORE_EXPORT void setData(FragmentedSharedBuffer&, bool allDataReceived) final;
    bool isAllDataReceived() const final { return m_isAllDataReceived; }
    WEBCORE_EXPORT void clearFrameBufferCache(size_t) final;


    WEBCORE_EXPORT Vector<ImageDecoder::FrameInfo> frameInfos() const;

private:
    ImageDecoderAVFObjC(FragmentedSharedBuffer&, const String& mimeType, AlphaOption, GammaAndColorProfileOption);

    AVAssetTrack *firstEnabledTrack();
    void readSamples();




#pragma mark - ImageDecoderAVFObjC

RefPtr<ImageDecoderAVFObjC> ImageDecoderAVFObjC::create(FragmentedSharedBuffer& data, const String& mimeType, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
{
    // AVFoundation may not be available at runtime.
    if (!AVAssetMIMETypeCache::singleton().isAvailable())

    return adoptRef(*new ImageDecoderAVFObjC(data, mimeType, alphaOption, gammaAndColorProfileOption));
}

ImageDecoderAVFObjC::ImageDecoderAVFObjC(FragmentedSharedBuffer& data, const String& mimeType, AlphaOption, GammaAndColorProfileOption)
    : ImageDecoder()
    , m_mimeType(mimeType)
    , m_uti(WebCore::UTIFromMIMEType(mimeType))

    , m_loader(adoptNS([[WebCoreSharedBufferResourceLoaderDelegate alloc] initWithParent:this]))
    , m_decompressionSession(WebCoreDecompressionSession::createRGB())
{
    [m_loader updateData:data.makeContiguous()->createNSData().get() complete:NO];

    [m_asset.get().resourceLoader setDelegate:m_loader.get() queue:dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)];
    [m_asset loadValuesAsynchronouslyForKeys:@[@"tracks"] completionHandler:[protectedThis = Ref { *this }] () mutable {

    m_loader.get().expectedContentSize = expectedContentSize;
}

void ImageDecoderAVFObjC::setData(FragmentedSharedBuffer& data, bool allDataReceived)
{
    [m_loader updateData:data.makeContiguous()->createNSData().get() complete:allDataReceived];

    if (allDataReceived) {
        m_isAllDataReceived = true;



class MediaPlaybackTarget;
class MediaSelectionGroupAVFObjC;
class PixelBufferConformerCV;
class FragmentedSharedBuffer;
class VideoLayerManagerObjC;
class VideoTrackPrivateAVFObjC;
class WebCoreAVFResourceLoader;

    mutable std::optional<WallTime> m_wallClockAtCachedCurrentTime;
    mutable int m_timeControlStatusAtCachedCurrentTime { 0 };
    mutable double m_requestedRateAtCachedCurrentTime { 0 };
    RefPtr<FragmentedSharedBuffer> m_keyID;
    double m_cachedRate { 0 };
    bool m_requestedPlaying { false };
    double m_requestedRate { 1.0 };

Lines 2792-2798 void MediaPlayerPrivateAVFoundationObjC::attemptToDecryptWithInstance(CDMInstanc a/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.mm_sec1
- a/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.mm -1 / +1 lines
2792	if (!m_keyID \|\| !m_cdmInstance)	2792	if (!m_keyID \|\| !m_cdmInstance)
2793	return;	2793	return;
2794		2794
2795	auto instanceSession = m_cdmInstance->sessionForKeyIDs(Vector<Ref<SharedBuffer>>::from(*m_keyID));	2795	auto instanceSession = m_cdmInstance->sessionForKeyIDs(Vector<Ref<FragmentedSharedBuffer>>::from(*m_keyID));
2796	if (!instanceSession)	2796	if (!instanceSession)
2797	return;	2797	return;
2798		2798

Lines 213-219 SourceBufferParserAVFObjC::~SourceBufferParserAVFObjC() a/Source/WebCore/platform/graphics/avfoundation/objc/SourceBufferParserAVFObjC.mm_sec1
- a/Source/WebCore/platform/graphics/avfoundation/objc/SourceBufferParserAVFObjC.mm -1 / +1 lines
213	void SourceBufferParserAVFObjC::appendData(Segment&& segment, CompletionHandler<void()>&& completionHandler, AppendFlags flags)	213	void SourceBufferParserAVFObjC::appendData(Segment&& segment, CompletionHandler<void()>&& completionHandler, AppendFlags flags)
214	{	214	{
215	auto sharedBuffer = segment.takeSharedBuffer();	215	auto sharedBuffer = segment.takeSharedBuffer();
216	auto nsData = sharedBuffer->createNSData();	216	auto nsData = sharedBuffer->makeContiguous()->createNSData();
217	if (m_parserStateWasReset \|\| flags == AppendFlags::Discontinuity)	217	if (m_parserStateWasReset \|\| flags == AppendFlags::Discontinuity)
218	[m_parser appendStreamData:nsData.get() withFlags:AVStreamDataParserStreamDataDiscontinuity];	218	[m_parser appendStreamData:nsData.get() withFlags:AVStreamDataParserStreamDataDiscontinuity];
219	else	219	else



class AudioTrackPrivateMediaSourceAVFObjC;
class VideoTrackPrivateMediaSourceAVFObjC;
class WebCoreDecompressionSession;
class FragmentedSharedBuffer;

class SourceBufferPrivateAVFObjCErrorClient {
public:

#endif
#if ENABLE(ENCRYPTED_MEDIA) && HAVE(AVCONTENTKEYSESSION)
    RefPtr<CDMInstanceFairPlayStreamingAVFObjC> m_cdmInstance;
    Vector<Ref<FragmentedSharedBuffer>> m_keyIDs;
#endif

    std::optional<FloatSize> m_cachedSize;



class PlatformResourceMediaLoader;
class ResourceError;
class ResourceResponse;
class FragmentedSharedBuffer;

class WebCoreAVFResourceLoader : public RefCounted<WebCoreAVFResourceLoader> {
    WTF_MAKE_NONCOPYABLE(WebCoreAVFResourceLoader); WTF_MAKE_FAST_ALLOCATED;

    void responseReceived(const ResourceResponse&);
    void loadFailed(const ResourceError&);
    void loadFinished();
    void newDataStoredInSharedBuffer(const FragmentedSharedBuffer&);

    MediaPlayerPrivateAVFoundationObjC* m_parent;
    RetainPtr<AVAssetResourceLoadingRequest> m_avRequest;



    void redirectReceived(PlatformMediaResource&, ResourceRequest&& request, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&& completionHandler) final { completionHandler(WTFMove(request)); }
    bool shouldCacheResponse(PlatformMediaResource&, const ResourceResponse&) final { return false; }
    void dataSent(PlatformMediaResource&, unsigned long long, unsigned long long) final { }
    void dataReceived(PlatformMediaResource&, Ref<FragmentedSharedBuffer>&&) final;
    void accessControlCheckFailed(PlatformMediaResource&, const ResourceError& error) final { loadFailed(error); }
    void loadFailed(PlatformMediaResource&, const ResourceError& error) final { loadFailed(error); }
    void loadFinished(PlatformMediaResource&, const NetworkLoadMetrics&) final { loadFinished(); }

    WebCoreAVFResourceLoader& m_parent;
    RefPtr<PlatformMediaResource> m_resource;
    SharedBufferBuilder m_buffer;
};

WeakPtr<PlatformResourceMediaLoader> PlatformResourceMediaLoader::create(WebCoreAVFResourceLoader& parent, PlatformMediaResourceLoader& loader, ResourceRequest&& request)

    m_parent.loadFinished();
}

void PlatformResourceMediaLoader::dataReceived(PlatformMediaResource&, Ref<FragmentedSharedBuffer>&& buffer)
{
    m_buffer.append(WTFMove(buffer));
    m_parent.newDataStoredInSharedBuffer(*m_buffer.get());
    else
        m_buffer->append(WTFMove(buffer));
    m_parent.newDataStoredInSharedBuffer(*m_buffer);
}

class DataURLResourceMediaLoader : public CanMakeWeakPtr<DataURLResourceMediaLoader> {

    stopLoading();
}

void WebCoreAVFResourceLoader::newDataStoredInSharedBuffer(const FragmentedSharedBuffer& data)
{
    AVAssetResourceLoadingDataRequest* dataRequest = [m_avRequest dataRequest];
    if (!dataRequest)




namespace WebCore {

class SharedBuffer;
class FontCreationContext;
class FontDescription;
class FontPlatformData;
class FragmentedSharedBuffer;
struct FontSelectionSpecifiedCapabilities;
struct FontVariantSettings;


    WTF_MAKE_FAST_ALLOCATED;
    WTF_MAKE_NONCOPYABLE(FontCustomPlatformData);
public:
    FontCustomPlatformData(FT_Face, FragmentedSharedBuffer&);
    ~FontCustomPlatformData() = default;
    FontPlatformData fontPlatformData(const FontDescription&, bool bold, bool italic, const FontCreationContext&);
    static bool supportsFormat(const String&);




void sharedBufferRelease(void* info)
{
    FragmentedSharedBuffer* sharedBuffer = static_cast<FragmentedSharedBuffer*>(info);
    sharedBuffer->deref();
}
#endif

ImageDecoderCG::ImageDecoderCG(FragmentedSharedBuffer& data, AlphaOption, GammaAndColorProfileOption)
{
    RetainPtr<CFStringRef> utiHint;
    if (data.size() >= 32)
        utiHint = adoptCF(CGImageSourceGetTypeWithData(data.makeContiguous()->createCFData().get(), nullptr, nullptr));
    
    if (utiHint) {
        const void* key = kCGImageSourceTypeIdentifierHint;

    return maskedImage ? maskedImage : image;
}

void ImageDecoderCG::setData(FragmentedSharedBuffer& data, bool allDataReceived)
{
    m_isAllDataReceived = allDataReceived;

#if PLATFORM(COCOA)
    // On Mac the NSData inside the FragmentedSharedBuffer can be secretly appended to without the FragmentedSharedBuffer's knowledge.
    // We use FragmentedSharedBuffer's ability to wrap itself inside CFData to get around this, ensuring that ImageIO is
    // really looking at the FragmentedSharedBuffer.
    CGImageSourceUpdateData(m_nativeDecoder.get(), data.makeContiguous()->createCFData().get(), allDataReceived);
#else
    // Create a CGDataProvider to wrap the FragmentedSharedBuffer.
    auto contiguousData = data.makeContiguous();
    contiguousData.get().ref();
    // We use the GetBytesAtPosition callback rather than the GetBytePointer one because FragmentedSharedBuffer
    // does not provide a way to lock down the byte pointer and guarantee that it won't move, which
    // is a requirement for using the GetBytePointer callback.
    CGDataProviderDirectCallbacks providerCallbacks = { 0, 0, 0, sharedBufferGetBytesAtPosition, sharedBufferRelease };
    RetainPtr<CGDataProviderRef> dataProvider = adoptCF(CGDataProviderCreateDirect(contiguousData.ptr(), data.size(), &providerCallbacks));
    CGImageSourceUpdateDataProvider(m_nativeDecoder.get(), dataProvider.get(), allDataReceived);
#endif
}



class ImageDecoderCG final : public ImageDecoder {
    WTF_MAKE_FAST_ALLOCATED;
public:
    ImageDecoderCG(FragmentedSharedBuffer& data, AlphaOption, GammaAndColorProfileOption);

    static Ref<ImageDecoderCG> create(FragmentedSharedBuffer& data, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
    {
        return adoptRef(*new ImageDecoderCG(data, alphaOption, gammaAndColorProfileOption));
    }


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

    void setData(FragmentedSharedBuffer&, bool allDataReceived) final;
    bool isAllDataReceived() const final { return m_isAllDataReceived; }
    void clearFrameBufferCache(size_t) final { }


Lines 319-325 void PDFDocumentImage::destroyDecodedData(bool) a/Source/WebCore/platform/graphics/cg/PDFDocumentImage.cpp_sec1
- a/Source/WebCore/platform/graphics/cg/PDFDocumentImage.cpp -1 / +1 lines
319		319
320	void PDFDocumentImage::createPDFDocument()	320	void PDFDocumentImage::createPDFDocument()
321	{	321	{
322	RetainPtr<CGDataProviderRef> dataProvider = adoptCF(CGDataProviderCreateWithCFData(data()->createCFData().get()));	322	RetainPtr<CGDataProviderRef> dataProvider = adoptCF(CGDataProviderCreateWithCFData(data()->makeContiguous()->createCFData().get()));
323	m_document = adoptCF(CGPDFDocumentCreateWithProvider(dataProvider.get()));	323	m_document = adoptCF(CGPDFDocumentCreateWithProvider(dataProvider.get()));
324	}	324	}
325		325



        return Status(Status::kWouldBlock);
    }

    static void FreeSharedBuffer(void* refcon, void*, size_t)
    {
        auto* buffer = reinterpret_cast<SharedBuffer*>(refcon);
        buffer->deref();
    }


                lastRead = readResult.value();
                destinationOffset = 0;
            } else {
                ASSERT(sharedBuffer->hasOneSegment(), "Can only deal with sharedBuffer containing a single DataSegment");
                // A SharedBuffer doesn't have thread-safe refcounting, as such we must keep a reference to the DataSegment instead.
                // TODO: could we only create a new CMBlockBuffer if the backend memory changed since the previous one?
                size_t canRead = std::min<size_t>(numToRead, sharedBuffer->size() - m_positionWithinSegment);
                size_t canRead = std::min<size_t>(numToRead, firstSegment->size() - m_positionWithinSegment);
                // From CMBlockBufferCustomBlockSource documentation:
                // Note that for 64-bit architectures, this struct contains misaligned function pointers.
                // To avoid link-time issues, it is recommended that clients fill CMBlockBufferCustomBlockSource's function pointer fields

                CMBlockBufferCustomBlockSource allocator;
                allocator.version = 0;
                allocator.AllocateBlock = nullptr;
                allocator.FreeBlock = FreeSharedBuffer;
                allocator.refCon = sharedBuffer.get();
                sharedBuffer->ref();
                auto err = PAL::CMBlockBufferCreateWithMemoryBlock(nullptr, static_cast<void*>(const_cast<uint8_t*>(sharedBuffer->data())), sharedBuffer->size(), nullptr, &allocator, m_positionWithinSegment, canRead, 0, &rawBlockBuffer);
                if (err != kCMBlockBufferNoErr)
                    return Status(Status::kNotEnoughMemory);
                lastRead = canRead;

Lines 737-743 DidChangeItemBuffer ItemBuffer::swapWritableBufferIfNeeded(size_t numberOfBytes) a/Source/WebCore/platform/graphics/displaylists/DisplayListItemBuffer.cpp_sec1
- a/Source/WebCore/platform/graphics/displaylists/DisplayListItemBuffer.cpp -1 / +1 lines
737	void ItemBuffer::append(const DisplayListItem& temporaryItem)	737	void ItemBuffer::append(const DisplayListItem& temporaryItem)
738	{	738	{
739	auto requiredSizeForItem = m_writingClient->requiredSizeForItem(temporaryItem);	739	auto requiredSizeForItem = m_writingClient->requiredSizeForItem(temporaryItem);
740	RefPtr<SharedBuffer> outOfLineItem;	740	RefPtr<FragmentedSharedBuffer> outOfLineItem;
741	if (!requiredSizeForItem) {	741	if (!requiredSizeForItem) {
742	outOfLineItem = m_writingClient->encodeItemOutOfLine(temporaryItem);	742	outOfLineItem = m_writingClient->encodeItemOutOfLine(temporaryItem);
743	if (!outOfLineItem)	743	if (!outOfLineItem)



        return std::nullopt;
    }

    virtual RefPtr<FragmentedSharedBuffer> encodeItemOutOfLine(const DisplayListItem&) const
    {
        return nullptr;
    }

    // with padding between each item to ensure that all items are aligned to 8 bytes.
    //
    // If a writing client is present and requires custom encoding for the given item type T, the
    // item buffer will ask the client for an opaque FragmentedSharedBuffer containing encoded data for the
    // item. This encoded data is then appended to the item buffer, with padding to ensure that
    // the start and end of this data are aligned to 8 bytes, if necessary. When consuming encoded
    // item data, a corresponding ItemBufferReadingClient will be required to convert this encoded




static void releaseCustomFontData(void* data)
{
    static_cast<FragmentedSharedBuffer*>(data)->deref();
}

static cairo_user_data_key_t freeTypeFaceKey;

FontCustomPlatformData::FontCustomPlatformData(FT_Face freeTypeFace, FragmentedSharedBuffer& buffer)
    : m_fontFace(adoptRef(cairo_ft_font_face_create_for_ft_face(freeTypeFace, FT_LOAD_DEFAULT)))
{
    buffer.ref(); // This is balanced by the buffer->deref() in releaseCustomFontData.



    return (ImageDecoderGStreamerSample*)iter->second.get();
}

RefPtr<ImageDecoderGStreamer> ImageDecoderGStreamer::create(FragmentedSharedBuffer& data, const String& mimeType, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
{
    return adoptRef(*new ImageDecoderGStreamer(data, mimeType, alphaOption, gammaAndColorProfileOption));
}

ImageDecoderGStreamer::ImageDecoderGStreamer(FragmentedSharedBuffer& data, const String& mimeType, AlphaOption, GammaAndColorProfileOption)
    : m_mimeType(mimeType)
{
    static std::once_flag onceFlag;

    return nullptr;
}

void ImageDecoderGStreamer::setData(FragmentedSharedBuffer& data, bool)
{
    pushEncodedData(data);
}

    return EncodedDataStatus::Unknown;
}

void ImageDecoderGStreamer::pushEncodedData(const FragmentedSharedBuffer& buffer)
{
    auto contiguousBuffer = buffer.makeContiguous();
    m_eos = false;
    auto thread = Thread::create("ImageDecoderGStreamer", [this, data = contiguousBuffer->data(), size = buffer.size()] {
        m_innerDecoder = ImageDecoderGStreamer::InnerDecoder::create(*this, data, size);
        m_innerDecoder->run();
    }, ThreadType::Graphics);



    WTF_MAKE_FAST_ALLOCATED;
    WTF_MAKE_NONCOPYABLE(ImageDecoderGStreamer);
public:
    static RefPtr<ImageDecoderGStreamer> create(FragmentedSharedBuffer&, const String& mimeType, AlphaOption, GammaAndColorProfileOption);
    ImageDecoderGStreamer(FragmentedSharedBuffer&, const String& mimeType, AlphaOption, GammaAndColorProfileOption);
    virtual ~ImageDecoderGStreamer() = default;

    static bool supportsMediaType(MediaType type) { return type == MediaType::Video; }

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

    void setExpectedContentSize(long long) final { }
    void setData(FragmentedSharedBuffer&, bool allDataReceived) final;
    bool isAllDataReceived() const final { return m_eos; }
    void clearFrameBufferCache(size_t) final;


    };

    void handleSample(GRefPtr<GstSample>&&);
    void pushEncodedData(const FragmentedSharedBuffer&);

    const ImageDecoderGStreamerSample* sampleAtIndex(size_t) const;


Lines 3692-3698 void MediaPlayerPrivateGStreamer::initializationDataEncountered(InitData&& initD a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp_sec1
- a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp -1 / +1 lines
3692		3692
3693	GST_DEBUG("scheduling initializationDataEncountered %s event of size %zu", initData.payloadContainerType().utf8().data(),	3693	GST_DEBUG("scheduling initializationDataEncountered %s event of size %zu", initData.payloadContainerType().utf8().data(),
3694	initData.payload()->size());	3694	initData.payload()->size());
3695	GST_MEMDUMP("init datas", reinterpret_cast<const uint8_t*>(initData.payload()->data()), initData.payload()->size());	3695	GST_MEMDUMP("init datas", reinterpret_cast<const uint8_t*>(initData.payload()->makeContiguous()->data()), initData.payload()->size());
3696	weakThis->m_player->initializationDataEncountered(initData.payloadContainerType(), initData.payload()->tryCreateArrayBuffer());	3696	weakThis->m_player->initializationDataEncountered(initData.payloadContainerType(), initData.payload()->tryCreateArrayBuffer());
3697	});	3697	});
3698	}	3698	}




    // PlatformMediaResourceClient virtual methods.
    void responseReceived(PlatformMediaResource&, const ResourceResponse&, CompletionHandler<void(ShouldContinuePolicyCheck)>&&) override;
    void dataReceived(PlatformMediaResource&, Ref<FragmentedSharedBuffer>&&) override;
    void accessControlCheckFailed(PlatformMediaResource&, const ResourceError&) override;
    void loadFailed(PlatformMediaResource&, const ResourceError&) override;
    void loadFinished(PlatformMediaResource&, const NetworkLoadMetrics&) override;

    completionHandler(ShouldContinuePolicyCheck::Yes);
}

void CachedResourceStreamingClient::dataReceived(PlatformMediaResource&, Ref<FragmentedSharedBuffer>&& buffer)
{
    ASSERT(isMainThread());
    WebKitWebSrc* src = WEBKIT_WEB_SRC(m_src.get());



    CDMProxyClearKey() = default;
    virtual ~CDMProxyClearKey();

    // FIXME: There's a lack of consistency between FragmentedSharedBuffers,
    // Vector<char>'s and {uint8_t*,size_t} idioms for representing a chunk of
    // bytes. Fix that somehow. Note FragmentedSharedBuffers are dangerous since
    // they're not thread-safe and this class must maintain
    // thread-safety, but maybe FragmentedSharedBuffer::DataSegment could be
    // made to work, however that has zero helpers for dropping into
    // iterator-aware / comparator-aware containers...
    struct cencDecryptContext {



    return true;
}

bool CDMPrivateThunder::supportsInitData(const AtomString& initDataType, const FragmentedSharedBuffer& initData) const
{
    // Validate the initData buffer as an JSON object in keyids case.
    if (equalLettersIgnoringASCIICase(initDataType, "keyids") && CDMUtilities::parseJSONObject(initData))

    return false;
}

RefPtr<FragmentedSharedBuffer> CDMPrivateThunder::sanitizeResponse(const FragmentedSharedBuffer& response) const
{
    return response.copy();
}

    callback(Succeeded);
}

void CDMInstanceThunder::setServerCertificate(Ref<FragmentedSharedBuffer>&& certificate,  SuccessCallback&& callback)
{
    OpenCDMError error = opencdm_system_set_server_certificate(m_thunderSystem.get(), const_cast<uint8_t*>(certificate->data()),
        certificate->size());

class ParsedResponseMessage {

public:
    ParsedResponseMessage(const RefPtr<FragmentedSharedBuffer>& buffer)
    {
        if (!buffer || !buffer->size())
            return;


    bool isValid() const { return m_isValid; }
    bool hasPayload() const { return static_cast<bool>(m_payload); }
    const Ref<FragmentedSharedBuffer>& payload() const& { ASSERT(m_payload); return m_payload.value(); }
    Ref<FragmentedSharedBuffer>& payload() & { ASSERT(m_payload); return m_payload.value(); }
    bool hasType() const { return m_type.has_value(); }
    WebCore::MediaKeyMessageType type() const { ASSERT(m_type); return m_type.value(); }
    WebCore::MediaKeyMessageType typeOr(WebCore::MediaKeyMessageType alternate) const { return m_type ? m_type.value() : alternate; }


private:
    bool m_isValid { false };
    std::optional<Ref<FragmentedSharedBuffer>> m_payload;
    std::optional<WebCore::MediaKeyMessageType> m_type;
};

void CDMInstanceSessionThunder::challengeGeneratedCallback(RefPtr<FragmentedSharedBuffer>&& buffer)
{
    ParsedResponseMessage parsedResponseMessage(buffer);
    if (!parsedResponseMessage) {

    m_sessionChangedCallbacks.clear();
}

void CDMInstanceSessionThunder::errorCallback(RefPtr<FragmentedSharedBuffer>&& message)
{
    GST_ERROR("CDM error");
    GST_MEMDUMP("error dump", message->data(), message->size());

    m_sessionChangedCallbacks.clear();
}

void CDMInstanceSessionThunder::requestLicense(LicenseType licenseType, const AtomString& initDataType, Ref<FragmentedSharedBuffer>&& initDataSharedBuffer,
    LicenseCallback&& callback)
{
    ASSERT(isMainThread());

        m_initData.payload()->data(), m_initData.payload()->size(), nullptr, 0, &m_thunderSessionCallbacks, this, &session);
    if (!session) {
        GST_ERROR("Could not create session");
        RefPtr<FragmentedSharedBuffer> initData = m_initData.payload();
        callback(initData.releaseNonNull(), { }, false, Failed);
        return;
    }


    auto generateChallenge = [this, callback = WTFMove(callback)]() mutable {
        ASSERT(isMainThread());
        RefPtr<FragmentedSharedBuffer> initData = m_initData.payload();
        if (m_sessionID.isEmpty()) {
            GST_ERROR("could not create session id");
            callback(initData.releaseNonNull(), { }, false, Failed);

    m_sessionChangedCallbacks.clear();
}

void CDMInstanceSessionThunder::updateLicense(const String& sessionID, LicenseType, Ref<FragmentedSharedBuffer>&& response, LicenseUpdateCallback&& callback)
{
    ASSERT_UNUSED(sessionID, sessionID == m_sessionID);

    GST_TRACE("Updating session %s", sessionID.utf8().data());

    m_sessionChangedCallbacks.append([this, callback = WTFMove(callback)](bool success, RefPtr<FragmentedSharedBuffer>&& responseMessage) mutable {
        ASSERT(isMainThread());
        if (success) {
            if (!responseMessage)

                ParsedResponseMessage parsedResponseMessage(responseMessage);
                ASSERT(parsedResponseMessage);
                if (parsedResponseMessage.hasPayload()) {
                    Ref<FragmentedSharedBuffer> message = WTFMove(parsedResponseMessage.payload());
                    GST_DEBUG("got message of size %zu", message->size());
                    GST_MEMDUMP("message", message->data(), message->size());
                    callback(false, std::nullopt, std::nullopt,

{
    ASSERT_UNUSED(sessionID, sessionID == m_sessionID);

    m_sessionChangedCallbacks.append([this, callback = WTFMove(callback)](bool success, RefPtr<FragmentedSharedBuffer>&& responseMessage) mutable {
        ASSERT(isMainThread());
        if (success) {
            if (!responseMessage)

                ParsedResponseMessage parsedResponseMessage(responseMessage);
                ASSERT(parsedResponseMessage);
                if (parsedResponseMessage.hasPayload()) {
                    Ref<FragmentedSharedBuffer> message = WTFMove(parsedResponseMessage.payload());
                    GST_DEBUG("got message of size %zu", message->size());
                    GST_MEMDUMP("message", message->data(), message->size());
                    callback(std::nullopt, std::nullopt, std::make_pair(parsedResponseMessage.typeOr(MediaKeyMessageType::LicenseRequest),

{
    ASSERT_UNUSED(sessionID, m_sessionID == sessionID);

    m_sessionChangedCallbacks.append([this, callback = WTFMove(callback)](bool success, RefPtr<FragmentedSharedBuffer>&& buffer) mutable {
        ASSERT(isMainThread());
        if (success) {
            if (!buffer)

                ParsedResponseMessage parsedResponseMessage(buffer);
                ASSERT(parsedResponseMessage);
                if (parsedResponseMessage.hasPayload()) {
                    Ref<FragmentedSharedBuffer> message = WTFMove(parsedResponseMessage.payload());
                    GST_DEBUG("session %s removed, message length %zu", m_sessionID.utf8().data(), message->size());
                    callback(m_keyStore.allKeysAs(MediaKeyStatus::Released), WTFMove(message), SuccessValue::Succeeded);
                } else {



    void loadAndInitialize() final;
    bool supportsServerCertificates() const final;
    bool supportsSessions() const final;
    bool supportsInitData(const AtomString&, const FragmentedSharedBuffer&) const final;
    RefPtr<FragmentedSharedBuffer> sanitizeResponse(const FragmentedSharedBuffer&) const final;
    std::optional<String> sanitizeSessionId(const String&) const final;

private:

    // CDMInstance
    ImplementationType implementationType() const final { return ImplementationType::Thunder; }
    void initializeWithConfiguration(const CDMKeySystemConfiguration&, AllowDistinctiveIdentifiers, AllowPersistentState, SuccessCallback&&) final;
    void setServerCertificate(Ref<FragmentedSharedBuffer>&&, SuccessCallback&&) final;
    void setStorageDirectory(const String&) final;
    const String& keySystem() const final { return m_keySystem; }
    RefPtr<CDMInstanceSession> createSession() final;

public:
    CDMInstanceSessionThunder(CDMInstanceThunder&);

    void requestLicense(LicenseType, const AtomString& initDataType, Ref<FragmentedSharedBuffer>&& initData, LicenseCallback&&) final;
    void updateLicense(const String&, LicenseType, Ref<FragmentedSharedBuffer>&&, LicenseUpdateCallback&&) final;
    void loadSession(LicenseType, const String&, const String&, LoadSessionCallback&&) final;
    void closeSession(const String&, CloseSessionCallback&&) final;
    void removeSessionData(const String&, LicenseType, RemoveSessionDataCallback&&) final;

private:
    CDMInstanceThunder* cdmInstanceThunder() const;

    using Notification = void (CDMInstanceSessionThunder::*)(RefPtr<WebCore::FragmentedSharedBuffer>&&);
    using ChallengeGeneratedCallback = Function<void()>;
    using SessionChangedCallback = Function<void(bool, RefPtr<FragmentedSharedBuffer>&&)>;

    void challengeGeneratedCallback(RefPtr<FragmentedSharedBuffer>&&);
    void keyUpdatedCallback(KeyIDType&&);
    void keysUpdateDoneCallback();
    void errorCallback(RefPtr<FragmentedSharedBuffer>&&);
    CDMInstanceSession::KeyStatus status(const KeyIDType&) const;
    void sessionFailure();


    InitData m_initData;
    OpenCDMSessionCallbacks m_thunderSessionCallbacks { };
    BoxPtr<OpenCDMSession> m_session;
    RefPtr<FragmentedSharedBuffer> m_message;
    bool m_needsIndividualization { false };
    Vector<ChallengeGeneratedCallback> m_challengeCallbacks;
    Vector<SessionChangedCallback> m_sessionChangedCallbacks;

Lines 71-77 static void markupError(GMarkupParseContext, GError, gpointer) a/Source/WebCore/platform/graphics/gstreamer/eme/GStreamerEMEUtilities.cpp_sec1
- a/Source/WebCore/platform/graphics/gstreamer/eme/GStreamerEMEUtilities.cpp -1 / +1 lines
71		71
72	static GMarkupParser markupParser { markupStartElement, markupEndElement, markupText, markupPassthrough, markupError };	72	static GMarkupParser markupParser { markupStartElement, markupEndElement, markupText, markupPassthrough, markupError };
73		73
74	RefPtr<SharedBuffer> InitData::extractCencIfNeeded(RefPtr<SharedBuffer>&& unparsedPayload)	74	RefPtr<FragmentedSharedBuffer> InitData::extractCencIfNeeded(RefPtr<SharedBuffer>&& unparsedPayload)
75	{	75	{
76	RefPtr<SharedBuffer> payload = WTFMove(unparsedPayload);	76	RefPtr<SharedBuffer> payload = WTFMove(unparsedPayload);
77	if (!payload \|\| !payload->size())	77	if (!payload \|\| !payload->size())



namespace WebCore {
class InitData {
public:
    InitData() = default;
        : m_payload(SharedBuffer::create()) { }

    // FIXME: We should have an enum for system uuids for better type safety.
    InitData(const String& systemId, GstBuffer* initData)

            GST_CAT_LEVEL_LOG(webkit_media_common_encryption_decrypt_debug_category, GST_LEVEL_ERROR, nullptr, "cannot map %s protection data", systemId.utf8().data());
            ASSERT_NOT_REACHED();
        }
        if (auto parsedPayload = extractCencIfNeeded(mappedInitData->createSharedBuffer()))
            m_payload.append(parsedPayload.releaseNonNull());
    }

    InitData(const String& systemId, RefPtr<FragmentedSharedBuffer>&& payload)
        : m_systemId(systemId)
        , m_payload(extractCencIfNeeded(WTFMove(payload)))
    {
        if (payload) {
            if (auto parsedPayload = extractCencIfNeeded(payload->makeContiguous()))
                m_payload.append(parsedPayload.releaseNonNull());
        }
    }

    void append(InitData&& initData)

        // it's not very robust, so be careful here!
        m_systemId = initData.m_systemId;

        m_payload.append(*initData.payload());
    }

    RefPtr<FragmentedSharedBuffer> payload() const { return m_payload.get(); }
    const String& systemId() const { return m_systemId; }
    String payloadContainerType() const
    {

        return "cenc"_s;
    }

    static RefPtr<FragmentedSharedBuffer> extractCencIfNeeded(RefPtr<SharedBuffer>&&);

private:
    String m_systemId;
    SharedBufferBuilder m_payload;
};

class ProtectionSystemEvents {

Lines 36-42 namespace WebCore { a/Source/WebCore/platform/graphics/mac/FontCustomPlatformData.h_sec1
- a/Source/WebCore/platform/graphics/mac/FontCustomPlatformData.h -1 / +1 lines
36	class FontCreationContext;	36	class FontCreationContext;
37	class FontDescription;	37	class FontDescription;
38	struct FontSelectionSpecifiedCapabilities;	38	struct FontSelectionSpecifiedCapabilities;
39	class SharedBuffer;	39	class FragmentedSharedBuffer;
40		40
41	template <typename T> class FontTaggedSettings;	41	template <typename T> class FontTaggedSettings;
42	typedef FontTaggedSettings<int> FontFeatureSettings;	42	typedef FontTaggedSettings<int> FontFeatureSettings;

Lines 48-54 namespace WebCore { a/Source/WebCore/platform/graphics/mac/PDFDocumentImageMac.mm_sec1
- a/Source/WebCore/platform/graphics/mac/PDFDocumentImageMac.mm -1 / +1 lines
48		48
49	void PDFDocumentImage::createPDFDocument()	49	void PDFDocumentImage::createPDFDocument()
50	{	50	{
51	m_document = adoptNS([allocPDFDocumentInstance() initWithData:data()->createNSData().get()]);	51	m_document = adoptNS([allocPDFDocumentInstance() initWithData:data()->makeContiguous()->createNSData().get()]);
52	}	52	}
53		53
54	void PDFDocumentImage::computeBoundsForCurrentPage()	54	void PDFDocumentImage::computeBoundsForCurrentPage()



namespace WebCore {

struct BigEndianUShort;
class SharedBuffer;
struct EOTPrefix;
class FontMemoryResource;
class FragmentedSharedBuffer;

struct EOTHeader {
    EOTHeader();




static bool loadHmtxTable(const FontPlatformData& platformData, Vector<uint16_t>& advanceWidths)
{
    auto buffer = platformData.openTypeTable(OpenType::HheaTag);
    const OpenType::HheaTable* hhea = OpenType::validateTable<OpenType::HheaTable>(buffer);
    if (!hhea)
        return false;

void OpenTypeVerticalData::loadMetrics(const FontPlatformData& platformData)
{
    // Load vhea first. This table is required for fonts that support vertical flow.
    auto buffer = platformData.openTypeTable(OpenType::VheaTag);
    const OpenType::VheaTable* vhea = OpenType::validateTable<OpenType::VheaTable>(buffer);
    if (!vhea)
        return;


void OpenTypeVerticalData::loadVerticalGlyphSubstitutions(const FontPlatformData& platformData)
{
    auto buffer = platformData.openTypeTable(OpenType::GSUBTag);
    const OpenType::GSUBTable* gsub = OpenType::validateTable<OpenType::GSUBTable>(buffer);
    if (gsub)
        gsub->getVerticalGlyphSubstitutions(&m_verticalGlyphMap, *buffer.get());

Lines 43-49 enum DWRITE_FONT_STRETCH; a/Source/WebCore/platform/graphics/win/DirectWriteUtilities.h_sec1
- a/Source/WebCore/platform/graphics/win/DirectWriteUtilities.h -1 / +1 lines
43	namespace WebCore {	43	namespace WebCore {
44		44
45	class FontPlatformData;	45	class FontPlatformData;
46	class SharedBuffer;	46	class FragmentedSharedBuffer;
47		47
48	namespace DirectWrite {	48	namespace DirectWrite {
49		49




namespace WebCore {

class SharedBuffer;
class FontCreationContext;
class FontDescription;
class FontMemoryResource;
class SharedBuffer;
struct FontSelectionSpecifiedCapabilities;
struct FontVariantSettings;
class FragmentedSharedBuffer;

template <typename T> class FontTaggedSettings;
typedef FontTaggedSettings<int> FontFeatureSettings;

Lines 272-278 PlatformImagePtr ImageDecoderDirect2D::createFrameImageAtIndex(size_t index, Sub a/Source/WebCore/platform/graphics/win/ImageDecoderDirect2D.cpp_sec1
- a/Source/WebCore/platform/graphics/win/ImageDecoderDirect2D.cpp -1 / +1 lines
272	return bitmap;	272	return bitmap;
273	}	273	}
274		274
275	void ImageDecoderDirect2D::setData(SharedBuffer& data, bool allDataReceived)	275	void ImageDecoderDirect2D::setData(FragmentedSharedBuffer& data, bool allDataReceived)
276	{	276	{
277	if (!allDataReceived)	277	if (!allDataReceived)
278	return;	278	return;



public:
    ImageDecoderDirect2D();

    static Ref<ImageDecoderDirect2D> create(FragmentedSharedBuffer&, AlphaOption, GammaAndColorProfileOption)
    {
        return adoptRef(*new ImageDecoderDirect2D());
    }


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

    void setData(FragmentedSharedBuffer&, bool allDataReceived) final;
    bool isAllDataReceived() const final { return m_isAllDataReceived; }
    void clearFrameBufferCache(size_t) final { }


Lines 30-36 a/Source/WebCore/platform/graphics/win/ImageWin.cpp_sec1
- a/Source/WebCore/platform/graphics/win/ImageWin.cpp -1 / +1 lines
30	#include "SharedBuffer.h"	30	#include "SharedBuffer.h"
31		31
32	// This function loads resources from WebKit	32	// This function loads resources from WebKit
33	RefPtr<WebCore::SharedBuffer> loadResourceIntoBuffer(const char*);	33	RefPtr<WebCore::FragmentedSharedBuffer> loadResourceIntoBuffer(const char*);
34		34
35	namespace WebCore {	35	namespace WebCore {
36		36




namespace {

static unsigned copyFromSharedBuffer(char* buffer, unsigned bufferLength, const FragmentedSharedBuffer& sharedBuffer)
{
    unsigned bytesExtracted = 0;
    for (const auto& element : sharedBuffer) {


}

RefPtr<ScalableImageDecoder> ScalableImageDecoder::create(FragmentedSharedBuffer& data, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
{
    static const unsigned lengthOfLongestSignature = 14; // To wit: "RIFF????WEBPVP"
    char contents[lengthOfLongestSignature];




    // Returns nullptr if we can't sniff a supported type from the provided data (possibly
    // because there isn't enough data yet).
    static RefPtr<ScalableImageDecoder> create(FragmentedSharedBuffer& data, AlphaOption, GammaAndColorProfileOption);

    bool premultiplyAlpha() const { return m_premultiplyAlpha; }


        return m_encodedDataStatus == EncodedDataStatus::Complete;
    }

    void setData(FragmentedSharedBuffer& data, bool allDataReceived) override
    {
        Locker locker { m_lock };
        if (m_encodedDataStatus == EncodedDataStatus::Error)
            return;

        auto contiguousData = data.makeContiguous();
        if (contiguousData->data())
            m_data = contiguousData->begin()->segment.copyRef();
        }
        if (m_encodedDataStatus == EncodedDataStatus::TypeAvailable) {
            m_decodingSizeFromSetData = true;
            tryDecodeSize(allDataReceived);

    std::optional<IntPoint> hotSpot() const override { return std::nullopt; }

protected:
    RefPtr<FragmentedSharedBuffer::DataSegment> m_data;
    Vector<ScalableImageDecoderFrame, 1> m_frameBufferCache WTF_GUARDED_BY_LOCK(m_lock);
    mutable Lock m_lock;
    bool m_premultiplyAlpha;




AVIFImageReader::~AVIFImageReader() = default;

bool AVIFImageReader::parseHeader(const FragmentedSharedBuffer::DataSegment& data, bool allDataReceived)
{
    if (avifDecoderSetIOMemory(m_avifDecoder.get(), data.data(), data.size()) != AVIF_RESULT_OK)
        return allDataReceived ? m_decoder->setFailed() : false;

    return true;
}

void AVIFImageReader::decodeFrame(size_t frameIndex, ScalableImageDecoderFrame& buffer, const FragmentedSharedBuffer::DataSegment& data)
{
    if (m_decoder->failed())
        return;



    AVIFImageReader(RefPtr<AVIFImageDecoder>&&);
    ~AVIFImageReader();

    bool parseHeader(const FragmentedSharedBuffer::DataSegment&, bool allDataReceived);
    void decodeFrame(size_t index, ScalableImageDecoderFrame&, const FragmentedSharedBuffer::DataSegment&);
    size_t imageCount() const;
    double repetitionCount() const;


Lines 46-52 BMPImageDecoder::BMPImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOp a/Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.cpp_sec1
- a/Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.cpp -1 / +1 lines
46	{	46	{
47	}	47	}
48		48
49	void BMPImageDecoder::setData(SharedBuffer& data, bool allDataReceived)	49	void BMPImageDecoder::setData(FragmentedSharedBuffer& data, bool allDataReceived)
50	{	50	{
51	if (failed())	51	if (failed())
52	return;	52	return;

Lines 44-50 public: a/Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.h_sec1
- a/Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.h -1 / +1 lines
44		44
45	// ScalableImageDecoder	45	// ScalableImageDecoder
46	String filenameExtension() const final { return "bmp"_s; }	46	String filenameExtension() const final { return "bmp"_s; }
47	void setData(SharedBuffer&, bool allDataReceived) final;	47	void setData(FragmentedSharedBuffer&, bool allDataReceived) final;
48	ScalableImageDecoderFrame* frameBufferAtIndex(size_t index) final;	48	ScalableImageDecoderFrame* frameBufferAtIndex(size_t index) final;
49	// CAUTION: setFailed() deletes \|m_reader\|. Be careful to avoid	49	// CAUTION: setFailed() deletes \|m_reader\|. Be careful to avoid
50	// accessing deleted memory, especially when calling this from inside	50	// accessing deleted memory, especially when calling this from inside



public:
    // Read a value from |data[offset]|, converting from little to native
    // endianness.
    static inline uint16_t readUint16(const FragmentedSharedBuffer::DataSegment& data, int offset)
    {
        uint16_t result;
        memcpy(&result, &data.data()[offset], 2);

        return result;
    }

    static inline uint32_t readUint32(const FragmentedSharedBuffer::DataSegment& data, int offset)
    {
        uint32_t result;
        memcpy(&result, &data.data()[offset], 4);

    BMPImageReader(ScalableImageDecoder* parent, size_t decodedAndHeaderOffset, size_t imgDataOffset, bool usesAndMask);

    void setBuffer(ScalableImageDecoderFrame* buffer) { m_buffer = buffer; }
    void setData(FragmentedSharedBuffer::DataSegment& data) { m_data = &data; }

    // Does the actual decoding. If |onlySize| is true, decoding only
    // progresses as far as necessary to get the image size. Returns

    ScalableImageDecoderFrame* m_buffer;

    // The file to decode.
    RefPtr<FragmentedSharedBuffer::DataSegment> m_data;

    // An index into |m_data| representing how much we've already decoded.
    size_t m_decodedOffset;

Lines 37-43 PlatformImagePtr ImageBackingStore::image() const a/Source/WebCore/platform/image-decoders/cairo/ImageBackingStoreCairo.cpp_sec1
- a/Source/WebCore/platform/image-decoders/cairo/ImageBackingStoreCairo.cpp -1 / +3 lines
37	reinterpret_cast<unsigned char>(const_cast<uint32_t>(m_pixelsPtr)),	37	reinterpret_cast<unsigned char>(const_cast<uint32_t>(m_pixelsPtr)),
38	CAIRO_FORMAT_ARGB32, size().width(), size().height(), size().width() * sizeof(uint32_t)));	38	CAIRO_FORMAT_ARGB32, size().width(), size().height(), size().width() * sizeof(uint32_t)));
39	static cairo_user_data_key_t s_surfaceDataKey;	39	static cairo_user_data_key_t s_surfaceDataKey;
40	cairo_surface_set_user_data(surface.get(), &s_surfaceDataKey, m_pixels.get(), [](void* data) { static_cast<SharedBuffer::DataSegment*>(data)->deref(); });	40	cairo_surface_set_user_data(surface.get(), &s_surfaceDataKey, m_pixels.get(), [](void* data) {
		41	static_cast<DataSegment*>(data)->deref();
		42	});
41		43
42	return surface;	44	return surface;
43	}	45	}

Lines 38-44 GIFImageDecoder::GIFImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOp a/Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.cpp_sec1
- a/Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.cpp -1 / +1 lines
38		38
39	GIFImageDecoder::~GIFImageDecoder() = default;	39	GIFImageDecoder::~GIFImageDecoder() = default;
40		40
41	void GIFImageDecoder::setData(SharedBuffer& data, bool allDataReceived)	41	void GIFImageDecoder::setData(FragmentedSharedBuffer& data, bool allDataReceived)
42	{	42	{
43	if (failed())	43	if (failed())
44	return;	44	return;

Lines 46-52 public: a/Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.h_sec1
- a/Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.h -1 / +1 lines
46		46
47	// ScalableImageDecoder	47	// ScalableImageDecoder
48	String filenameExtension() const final { return "gif"_s; }	48	String filenameExtension() const final { return "gif"_s; }
49	void setData(SharedBuffer& data, bool allDataReceived) final;	49	void setData(FragmentedSharedBuffer& data, bool allDataReceived) final;
50	bool setSize(const IntSize&) final;	50	bool setSize(const IntSize&) final;
51	size_t frameCount() const final;	51	size_t frameCount() const final;
52	RepetitionCount repetitionCount() const final;	52	RepetitionCount repetitionCount() const final;



    {
    }

    void setData(WebCore::FragmentedSharedBuffer::DataSegment& data) { m_data = &data; }
    // FIXME: haltAtFrame should be size_t.
    bool decode(WebCore::GIFImageDecoder::GIFQuery, unsigned haltAtFrame);


    Vector<std::unique_ptr<GIFFrameContext> > m_frames;
    size_t m_currentDecodingFrame;

    RefPtr<WebCore::FragmentedSharedBuffer::DataSegment> m_data;
    bool m_parseCompleted;
};

Lines 52-58 ICOImageDecoder::ICOImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOp a/Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.cpp_sec1
- a/Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.cpp -1 / +1 lines
52		52
53	ICOImageDecoder::~ICOImageDecoder() = default;	53	ICOImageDecoder::~ICOImageDecoder() = default;
54		54
55	void ICOImageDecoder::setData(SharedBuffer& data, bool allDataReceived)	55	void ICOImageDecoder::setData(FragmentedSharedBuffer& data, bool allDataReceived)
56	{	56	{
57	if (failed())	57	if (failed())
58	return;	58	return;

Lines 46-52 public: a/Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.h_sec1
- a/Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.h -1 / +1 lines
46		46
47	// ScalableImageDecoder	47	// ScalableImageDecoder
48	String filenameExtension() const final { return "ico"_s; }	48	String filenameExtension() const final { return "ico"_s; }
49	void setData(SharedBuffer&, bool allDataReceived) final;	49	void setData(FragmentedSharedBuffer&, bool allDataReceived) final;
50	IntSize size() const final;	50	IntSize size() const final;
51	IntSize frameSizeAtIndex(size_t, SubsamplingLevel) const final;	51	IntSize frameSizeAtIndex(size_t, SubsamplingLevel) const final;
52	bool setSize(const IntSize&) final;	52	bool setSize(const IntSize&) final;




static RefPtr<SharedBuffer> readICCProfile(jpeg_decompress_struct* info)
{
    SharedBufferBuilder buffer;
    for (jpeg_saved_marker_ptr marker = info->marker_list; marker; marker = marker->next) {
        if (!isICCMarker(marker))
            continue;

            return nullptr;

        unsigned markerSize = marker->data_length - iccHeaderSize;
        buffer.append(reinterpret_cast<const uint8_t*>(marker->data + iccHeaderSize), markerSize);
    }

    if (buffer.isEmpty())
        return nullptr;

    return buffer.take()->makeContiguous();
}
#endif


        m_bytesToSkip = std::max(numBytes - bytesToSkip, static_cast<long>(0));
    }

    bool decode(const FragmentedSharedBuffer::DataSegment& data, bool onlySize)
    {
        m_decodingSizeOnly = onlySize;


Lines 380-386 void JPEG2000ImageDecoder::decode(bool onlySize, bool allDataReceived) a/Source/WebCore/platform/image-decoders/jpeg2000/JPEG2000ImageDecoder.cpp_sec1
- a/Source/WebCore/platform/image-decoders/jpeg2000/JPEG2000ImageDecoder.cpp -1 / +1 lines
380	}	380	}
381		381
382	struct Reader {	382	struct Reader {
383	SharedBuffer::DataSegment& data;	383	FragmentedSharedBuffer::DataSegment& data;
384	size_t offset;	384	size_t offset;
385	} reader = { *m_data, 0 };	385	} reader = { *m_data, 0 };
386		386

Lines 152-158 public: a/Source/WebCore/platform/image-decoders/png/PNGImageDecoder.cpp_sec1
- a/Source/WebCore/platform/image-decoders/png/PNGImageDecoder.cpp -1 / +1 lines
152	m_readOffset = 0;	152	m_readOffset = 0;
153	}	153	}
154		154
155	bool decode(const SharedBuffer::DataSegment& data, bool sizeOnly, unsigned haltAtFrame)	155	bool decode(const FragmentedSharedBuffer::DataSegment& data, bool sizeOnly, unsigned haltAtFrame)
156	{	156	{
157	m_decodingSizeOnly = sizeOnly;	157	m_decodingSizeOnly = sizeOnly;
158	PNGImageDecoder* decoder = static_cast<PNGImageDecoder*>(png_get_progressive_ptr(m_png));	158	PNGImageDecoder* decoder = static_cast<PNGImageDecoder*>(png_get_progressive_ptr(m_png));




WEBPImageDecoder::~WEBPImageDecoder() = default;

void WEBPImageDecoder::setData(FragmentedSharedBuffer& data, bool allDataReceived)
{
    if (failed())
        return;

    // This can be executed both in the main thread (when not using async decoding) or in the decoding thread.
    // When executed in the decoding thread, a call to setData() from the main thread may change the data
    // the WebPDemuxer is using, leaving it in an inconsistent state, so we need to protect the data.
    RefPtr<FragmentedSharedBuffer::DataSegment> protectedData(m_data);
    WebPData inputData = { protectedData->data(), protectedData->size() };
    WebPDemuxState demuxerState;
    WebPDemuxer* demuxer = WebPDemuxPartial(&inputData, &demuxerState);

Lines 47-53 public: a/Source/WebCore/platform/image-decoders/webp/WEBPImageDecoder.h_sec1
- a/Source/WebCore/platform/image-decoders/webp/WEBPImageDecoder.h -1 / +1 lines
47	virtual ~WEBPImageDecoder();	47	virtual ~WEBPImageDecoder();
48		48
49	String filenameExtension() const override { return "webp"_s; }	49	String filenameExtension() const override { return "webp"_s; }
50	void setData(SharedBuffer&, bool) final;	50	void setData(FragmentedSharedBuffer&, bool) final;
51	ScalableImageDecoderFrame* frameBufferAtIndex(size_t index) override;	51	ScalableImageDecoderFrame* frameBufferAtIndex(size_t index) override;
52	RepetitionCount repetitionCount() const override;	52	RepetitionCount repetitionCount() const override;
53	size_t frameCount() const override { return m_frameCount; }	53	size_t frameCount() const override { return m_frameCount; }




#if !PLATFORM(MACCATALYST)
    if ([type isEqualToString:(__bridge NSString *)kUTTypeFlatRTFD]) {
        RefPtr<FragmentedSharedBuffer> buffer = strategy.readBufferFromPasteboard(itemIndex, kUTTypeFlatRTFD, m_pasteboardName, context());
        if (m_changeCount != changeCount())
            return ReaderResult::PasteboardWasChangedExternally;
        return buffer && reader.readRTFD(*buffer) ? ReaderResult::ReadType : ReaderResult::DidNotReadType;
    }

    if ([type isEqualToString:(__bridge NSString *)kUTTypeRTF]) {
        RefPtr<FragmentedSharedBuffer> buffer = strategy.readBufferFromPasteboard(itemIndex, kUTTypeRTF, m_pasteboardName, context());
        if (m_changeCount != changeCount())
            return ReaderResult::PasteboardWasChangedExternally;
        return buffer && reader.readRTF(*buffer) ? ReaderResult::ReadType : ReaderResult::DidNotReadType;

#endif // !PLATFORM(MACCATALYST)

    if ([supportedImageTypes() containsObject:type]) {
        RefPtr<FragmentedSharedBuffer> buffer = strategy.readBufferFromPasteboard(itemIndex, type, m_pasteboardName, context());
        if (m_changeCount != changeCount())
            return ReaderResult::PasteboardWasChangedExternally;
        return buffer && reader.readImage(buffer.releaseNonNull(), type, itemInfo.preferredPresentationSize) ? ReaderResult::ReadType : ReaderResult::DidNotReadType;



    return 0;
}

int64_t PlatformPasteboard::setBufferForType(FragmentedSharedBuffer*, const String&)
{
    return 0;
}


    ASSERT(content.clientTypes.size() == content.clientData.size());
    for (size_t i = 0, size = content.clientTypes.size(); i < size; ++i)
        [representationsToRegister addData:content.clientData[i]->makeContiguous()->createNSData().get() forType:content.clientTypes[i]];

    if (content.dataInWebArchiveFormat) {
        auto webArchiveData = content.dataInWebArchiveFormat->createNSData();

    }

    if (content.dataInAttributedStringFormat) {
        if (NSAttributedString *attributedString = [NSKeyedUnarchiver unarchivedObjectOfClasses:[NSSet setWithObject:NSAttributedString.class] fromData:content.dataInAttributedStringFormat->makeContiguous()->createNSData().get() error:nullptr])
            [representationsToRegister addRepresentingObject:attributedString];
    }



    PasteboardCustomData customData;
    customData.setOrigin(content.contentOrigin);
    [representationsToRegister addData:customData.createSharedBuffer()->makeContiguous()->createNSData().get() forType:@(PasteboardCustomData::cocoaType())];

    registerItemToPasteboard(representationsToRegister.get(), m_pasteboard.get());
}

    auto& data = pasteboardImage.clientData;
    ASSERT(types.size() == data.size());
    for (size_t i = 0, size = types.size(); i < size; ++i)
        [representationsToRegister addData:data[i]->makeContiguous()->createNSData().get() forType:types[i]];

    if (pasteboardImage.resourceData && !pasteboardImage.resourceMIMEType.isEmpty()) {
        auto utiOrMIMEType = pasteboardImage.resourceMIMEType;
        if (!isDeclaredUTI(utiOrMIMEType))
            utiOrMIMEType = UTIFromMIMEType(utiOrMIMEType);

        auto imageData = pasteboardImage.resourceData->makeContiguous()->createNSData();
        [representationsToRegister addData:imageData.get() forType:(NSString *)utiOrMIMEType];
        [representationsToRegister setPreferredPresentationSize:pasteboardImage.imageSize];
        [representationsToRegister setSuggestedName:pasteboardImage.suggestedName];

    [representationsToRegister setPreferredPresentationStyle:WebPreferredPresentationStyleInline];

    if (data.hasSameOriginCustomData() || !data.origin().isEmpty()) {
        if (auto serializedSharedBuffer = data.createSharedBuffer()->makeContiguous()->createNSData()) {
            // We stash the list of supplied pasteboard types in teamData here for compatibility with drag and drop.
            // Since the contents of item providers cannot be loaded prior to drop, but the pasteboard types are
            // contained within the custom data blob and we need to vend them to the page when firing `dragover`

            return;
        }

        auto buffer = std::get<Ref<FragmentedSharedBuffer>>(value);
        [representationsToRegister addData:buffer->makeContiguous()->createNSData().get() forType:(NSString *)cocoaType];
    });

    return representationsToRegister;

Lines 82-88 @end a/Source/WebCore/platform/ios/PreviewConverterIOS.mm_sec1
- a/Source/WebCore/platform/ios/PreviewConverterIOS.mm -1 / +1 lines
82	namespace WebCore {	82	namespace WebCore {
83		83
84	PreviewConverter::PreviewConverter(const ResourceResponse& response, PreviewConverterProvider& provider)	84	PreviewConverter::PreviewConverter(const ResourceResponse& response, PreviewConverterProvider& provider)
85	: m_previewData { SharedBuffer::create() }	85	: m_previewData { makeUniqueRef<SharedBufferBuilder>(FragmentedSharedBuffer::create()) }
86	, m_originalResponse { response }	86	, m_originalResponse { response }
87	, m_provider { provider }	87	, m_provider { provider }
88	, m_platformDelegate { adoptNS([[WebPreviewConverterDelegate alloc] initWithDelegate:*this]) }	88	, m_platformDelegate { adoptNS([[WebPreviewConverterDelegate alloc] initWithDelegate:*this]) }




static NSFileWrapper* fileWrapper(const PasteboardImage& pasteboardImage)
{
    auto wrapper = adoptNS([[NSFileWrapper alloc] initRegularFileWithContents:pasteboardImage.resourceData->makeContiguous()->createNSData().get()]);
    [wrapper setPreferredFilename:suggestedFilenameWithMIMEType(pasteboardImage.url.url, pasteboardImage.resourceMIMEType)];
    return wrapper.autorelease();
}

    
    if (types.contains(String(legacyRTFDPasteboardType()))) {
        if (auto data = readBufferAtPreferredItemIndex(legacyRTFDPasteboardType(), itemIndex, strategy, m_pasteboardName, context())) {
            if (auto attributedString = adoptNS([[NSAttributedString alloc] initWithRTFD:data->makeContiguous()->createNSData().get() documentAttributes:nil])) {
                text.text = [attributedString string];
                text.isURL = false;
                return;



            [pasteboardItem setString:webContent->dataInStringFormat forType:NSPasteboardTypeString];

        for (unsigned i = 0; i < webContent->clientTypes.size(); ++i)
            [pasteboardItem setData:webContent->clientData[i]->makeContiguous()->createNSData().get() forType:toUTIUnlessAlreadyUTI(webContent->clientTypes[i]).get()];

        PasteboardCustomData customData;
        customData.setOrigin(webContent->contentOrigin);
        [pasteboardItem setData:customData.createSharedBuffer()->makeContiguous()->createNSData().get() forType:toUTIUnlessAlreadyUTI(String(PasteboardCustomData::cocoaType())).get()];
    }

    return pasteboardItem;



        if (platformType.isEmpty())
            return;

        if (std::holds_alternative<Ref<FragmentedSharedBuffer>>(stringOrBuffer)) {
            if (auto platformData = std::get<Ref<FragmentedSharedBuffer>>(stringOrBuffer)->makeContiguous()->createNSData())
                [m_pasteboard setData:platformData.get() forType:platformType];
        } else if (std::holds_alternative<String>(stringOrBuffer)) {
            auto string = std::get<String>(stringOrBuffer);

    });

    if (shouldWriteCustomData) {
        if (auto serializedCustomData = data.createSharedBuffer()->makeContiguous()->createNSData())
            [m_pasteboard setData:serializedCustomData.get() forType:@(PasteboardCustomData::cocoaType())];
    }


    return [m_pasteboard declareTypes:createNSArray(pasteboardTypes).get() owner:nil];
}

int64_t PlatformPasteboard::setBufferForType(FragmentedSharedBuffer* buffer, const String& pasteboardType)
{
    if (!canWritePasteboardType(pasteboardType))
        return 0;

    BOOL didWriteData = [m_pasteboard setData:buffer ? buffer->makeContiguous()->createNSData().get() : nil forType:pasteboardType];
    if (!didWriteData)
        return 0;
    return changeCount();

        if (!platformType)
            return;

        if (std::holds_alternative<Ref<FragmentedSharedBuffer>>(stringOrBuffer)) {
            if (auto platformData = std::get<Ref<FragmentedSharedBuffer>>(stringOrBuffer)->makeContiguous()->createNSData())
                [item setData:platformData.get() forType:platformType];
        } else if (std::holds_alternative<String>(stringOrBuffer)) {
            auto string = std::get<String>(stringOrBuffer);



class MediaStreamPrivate;
class MediaStreamTrackPrivate;
class PlatformAudioData;
class FragmentedSharedBuffer;

struct MediaRecorderPrivateOptions;


    };
    WEBCORE_EXPORT static AudioVideoSelectedTracks selectTracks(MediaStreamPrivate&);

    using FetchDataCallback = CompletionHandler<void(RefPtr<FragmentedSharedBuffer>&&, const String& mimeType, double)>;
    virtual void fetchData(FetchDataCallback&&) = 0;
    virtual const String& mimeType() const = 0;


Lines 93-99 void MediaRecorderPrivateMock::generateMockCounterString() a/Source/WebCore/platform/mediarecorder/MediaRecorderPrivateMock.cpp_sec1
- a/Source/WebCore/platform/mediarecorder/MediaRecorderPrivateMock.cpp -1 / +1 lines
93		93
94	void MediaRecorderPrivateMock::fetchData(FetchDataCallback&& completionHandler)	94	void MediaRecorderPrivateMock::fetchData(FetchDataCallback&& completionHandler)
95	{	95	{
96	RefPtr<SharedBuffer> buffer;	96	RefPtr<FragmentedSharedBuffer> buffer;
97	{	97	{
98	Locker locker { m_bufferLock };	98	Locker locker { m_bufferLock };
99	Vector<uint8_t> value { m_buffer.characters8(), m_buffer.length() };	99	Vector<uint8_t> value { m_buffer.characters8(), m_buffer.length() };



    void appendVideoSampleBuffer(MediaSample&);
    void appendAudioSampleBuffer(const PlatformAudioData&, const AudioStreamDescription&, const WTF::MediaTime&, size_t);
    void stopRecording();
    void fetchData(CompletionHandler<void(RefPtr<FragmentedSharedBuffer>&&, double)>&&);

    void pause();
    void resume();


    void finishedFlushingSamples();
    void completeFetchData();
    RefPtr<FragmentedSharedBuffer> takeData();

    bool m_hasAudio { false };
    bool m_hasVideo { false };

    RetainPtr<AVAssetWriter> m_writer;

    Lock m_dataLock;
    SharedBufferBuilder m_data WTF_GUARDED_BY_LOCK(m_dataLock);
    CompletionHandler<void(RefPtr<FragmentedSharedBuffer>&&, double)> m_fetchDataCompletionHandler;

    RetainPtr<CMFormatDescriptionRef> m_audioFormatDescription;
    std::unique_ptr<AudioSampleBufferCompressor> m_audioCompressor;



        m_writer.clear();
    }

    // At this pointer, we should no longer be writing any data, so it should be safe to close and nullify m_data without locking.
    if (m_writerDelegate)
        [m_writerDelegate close];
    m_data = nullptr;

    if (auto completionHandler = WTFMove(m_fetchDataCompletionHandler))
        completionHandler(nullptr, 0);

    });
}

void MediaRecorderPrivateWriter::fetchData(CompletionHandler<void(RefPtr<FragmentedSharedBuffer>&&, double)>&& completionHandler)
{
    m_fetchDataCompletionHandler = WTFMove(completionHandler);


void MediaRecorderPrivateWriter::appendData(const uint8_t* data, size_t size)
{
    Locker locker { m_dataLock };
    m_data.append(data, size);
        m_data = SharedBuffer::create(data, size);
        return;
    }
    m_data->append(data, size);
}

RefPtr<FragmentedSharedBuffer> MediaRecorderPrivateWriter::takeData()
{
    Locker locker { m_dataLock };
    return m_data.take();
    return data;
}

void MediaRecorderPrivateWriter::pause()

Lines 33-39 a/Source/WebCore/platform/network/DataURLDecoder.h_sec1
- a/Source/WebCore/platform/network/DataURLDecoder.h -1 / +1 lines
33		33
34	namespace WebCore {	34	namespace WebCore {
35		35
36	class SharedBuffer;	36	class FragmentedSharedBuffer;
37		37
38	namespace DataURLDecoder {	38	namespace DataURLDecoder {
39		39

Lines 84-90 class NetworkLoadMetrics; a/Source/WebCore/platform/network/ResourceHandle.h_sec1
- a/Source/WebCore/platform/network/ResourceHandle.h -1 / +1 lines
84	class ResourceRequest;	84	class ResourceRequest;
85	class ResourceResponse;	85	class ResourceResponse;
86	class SecurityOrigin;	86	class SecurityOrigin;
87	class SharedBuffer;	87	class FragmentedSharedBuffer;
88	class SynchronousLoaderMessageQueue;	88	class SynchronousLoaderMessageQueue;
89	class Timer;	89	class Timer;
90		90




ResourceHandleClient::~ResourceHandleClient() = default;

void ResourceHandleClient::didReceiveBuffer(ResourceHandle* handle, Ref<FragmentedSharedBuffer>&& buffer, int encodedDataLength)
{
    didReceiveData(handle, buffer->makeContiguous()->data(), buffer->size(), encodedDataLength);
}

}



class ResourceError;
class ResourceRequest;
class ResourceResponse;
class FragmentedSharedBuffer;

enum CacheStoragePolicy {
    StorageAllowed,

    virtual void didSendData(ResourceHandle*, unsigned long long /*bytesSent*/, unsigned long long /*totalBytesToBeSent*/) { }

    virtual void didReceiveData(ResourceHandle*, const uint8_t*, unsigned, int /*encodedDataLength*/) { }
    WEBCORE_EXPORT virtual void didReceiveBuffer(ResourceHandle*, Ref<FragmentedSharedBuffer>&&, int encodedDataLength);
    
    virtual void didFinishLoading(ResourceHandle*, const NetworkLoadMetrics&) { }
    virtual void didFail(ResourceHandle*, const ResourceError&) { }



struct RangeResponseGenerator::Data {
    WTF_MAKE_STRUCT_FAST_ALLOCATED;
    Data(const ResourceResponse& response, PlatformMediaResource& resource)
        : originalResponse(response)
        , originalResponse(response)
        , resource(&resource) { }

    struct TaskData : public CanMakeWeakPtr<TaskData> {

        size_t nextByteToGiveBufferIndex { 0 };
        enum class ResponseState : uint8_t { NotSynthesizedYet, WaitingForSession, SessionCalledCompletionHandler } responseState { ResponseState::NotSynthesizedYet };
    };

    HashMap<RetainPtr<WebCoreNSURLSessionDataTask>, std::unique_ptr<TaskData>> taskData;
    SharedBufferBuilder buffer;
    ResourceResponse originalResponse;
    enum class SuccessfullyFinishedLoading : bool { No, Yes } successfullyFinishedLoading { SuccessfullyFinishedLoading::No };
    RefPtr<PlatformMediaResource> resource;

void RangeResponseGenerator::giveResponseToTaskIfBytesInRangeReceived(WebCoreNSURLSessionDataTask *task, const ParsedRequestRange& range, std::optional<size_t> expectedContentLength, const Data& data)
{
    ASSERT(isMainThread());
    auto buffer = data.buffer;
    auto bufferSize = buffer->size();

    // FIXME: We ought to be able to just make a range with a * after the / but AVFoundation doesn't accept such ranges.
    // Instead, we just wait until the load has completed, at which time we will know the content length from the buffer length.
    if (!expectedContentLength)
        return;

    auto bufferSize = data.buffer.size();
    if (bufferSize < range.begin)
        return;

    auto buffer = data.buffer.get();
    auto* taskData = data.taskData.get(task);
    if (!taskData)
        return;

    auto giveBytesToTask = [task = retainPtr(task), buffer, bufferSize, taskData = WeakPtr { *taskData }, generator = WeakPtr { *this }] {
        ASSERT(isMainThread());
        if ([task state] != NSURLSessionTaskStateRunning)
            return;

        auto& range = taskData->range;
        auto& byteIndex = taskData->nextByteToGiveBufferIndex;
        while (true) {
            if (byteIndex >= bufferSize)
                break;
            auto bufferView = buffer->getSomeData(byteIndex);
            if (!bufferView.size() || byteIndex > range.end)

{
    ASSERT(isMainThread());
    if (data.successfullyFinishedLoading == Data::SuccessfullyFinishedLoading::Yes)
        return data.buffer.size();

    // FIXME: ResourceResponseBase::expectedContentLength() should return std::optional<size_t> instead of us doing this check here.
    auto expectedContentLength = data.originalResponse.expectedContentLength();

        return false;
    }

    void dataReceived(PlatformMediaResource&, Ref<FragmentedSharedBuffer>&& buffer) final
    {
        ASSERT(isMainThread());
        if (!m_generator)

        auto* data = m_generator->m_map.get(m_urlString);
        if (!data)
            return;
        data->buffer.append(WTFMove(buffer));
        m_generator->giveResponseToTasksWithFinishedRanges(*data);
    }




class ResourceError;
class ResourceRequest;
class ResourceResponse;
class FragmentedSharedBuffer;
class SharedBufferDataView;
class WebCoreNSURLSessionDataTaskClient;
enum class ShouldContinuePolicyCheck : bool;

- (void)resource:(nullable WebCore::PlatformMediaResource*)resource sentBytes:(unsigned long long)bytesSent totalBytesToBeSent:(unsigned long long)totalBytesToBeSent;
- (void)resource:(nullable WebCore::PlatformMediaResource*)resource receivedResponse:(const WebCore::ResourceResponse&)response completionHandler:(CompletionHandler<void(WebCore::ShouldContinuePolicyCheck)>&&)completionHandler;
- (BOOL)resource:(nullable WebCore::PlatformMediaResource*)resource shouldCacheResponse:(const WebCore::ResourceResponse&)response;
- (void)resource:(nullable WebCore::PlatformMediaResource*)resource receivedData:(Ref<WebCore::FragmentedSharedBuffer>&&)data;
- (void)resource:(nullable WebCore::PlatformMediaResource*)resource receivedRedirect:(const WebCore::ResourceResponse&)response request:(WebCore::ResourceRequest&&)request completionHandler:(CompletionHandler<void(WebCore::ResourceRequest&&)>&&)completionHandler;
- (void)resource:(nullable WebCore::PlatformMediaResource*)resource accessControlCheckFailedWithError:(const WebCore::ResourceError&)error;
- (void)resource:(nullable WebCore::PlatformMediaResource*)resource loadFailedWithError:(const WebCore::ResourceError&)error;



    void redirectReceived(PlatformMediaResource&, ResourceRequest&&, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&&) override;
    bool shouldCacheResponse(PlatformMediaResource&, const ResourceResponse&) override;
    void dataSent(PlatformMediaResource&, unsigned long long, unsigned long long) override;
    void dataReceived(PlatformMediaResource&, Ref<FragmentedSharedBuffer>&&) override;
    void accessControlCheckFailed(PlatformMediaResource&, const ResourceError&) override;
    void loadFailed(PlatformMediaResource&, const ResourceError&) override;
    void loadFinished(PlatformMediaResource&, const NetworkLoadMetrics&) override;

    return [m_task resource:&resource shouldCacheResponse:response];
}

void WebCoreNSURLSessionDataTaskClient::dataReceived(PlatformMediaResource& resource, Ref<FragmentedSharedBuffer>&& buffer)
{
    Locker locker { m_taskLock };
    if (!m_task)

    return response.httpHeaderField(HTTPHeaderName::ContentRange).isEmpty();
}

- (void)resource:(PlatformMediaResource*)resource receivedData:(Ref<WebCore::FragmentedSharedBuffer>&&)data
{
    ASSERT_UNUSED(resource, !resource || resource == _resource);
    [self.session addDelegateOperation:[strongSelf = RetainPtr { self }, data = WTFMove(data)] {
        auto nsData = data->makeContiguous()->createNSData();
        strongSelf.get().countOfBytesReceived += data->size();
        id<NSURLSessionDataDelegate> dataDelegate = (id<NSURLSessionDataDelegate>)strongSelf.get().session.delegate;
        if ([dataDelegate respondsToSelector:@selector(URLSession:dataTask:didReceiveData:)])

Lines 103-109 void CurlDownload::curlDidReceiveResponse(CurlRequest& request, CurlResponse&& r a/Source/WebCore/platform/network/curl/CurlDownload.cpp_sec1
- a/Source/WebCore/platform/network/curl/CurlDownload.cpp -1 / +1 lines
103	}	103	}
104		104
105		105
106	void CurlDownload::curlDidReceiveBuffer(CurlRequest&, Ref<SharedBuffer>&& buffer)	106	void CurlDownload::curlDidReceiveBuffer(CurlRequest&, Ref<FragmentedSharedBuffer>&& buffer)
107	{	107	{
108	ASSERT(isMainThread());	108	ASSERT(isMainThread());
109		109

Lines 72-78 private: a/Source/WebCore/platform/network/curl/CurlDownload.h_sec1
- a/Source/WebCore/platform/network/curl/CurlDownload.h -1 / +1 lines
72	Ref<CurlRequest> createCurlRequest(ResourceRequest&);	72	Ref<CurlRequest> createCurlRequest(ResourceRequest&);
73	void curlDidSendData(CurlRequest&, unsigned long long, unsigned long long) override { }	73	void curlDidSendData(CurlRequest&, unsigned long long, unsigned long long) override { }
74	void curlDidReceiveResponse(CurlRequest&, CurlResponse&&) override;	74	void curlDidReceiveResponse(CurlRequest&, CurlResponse&&) override;
75	void curlDidReceiveBuffer(CurlRequest&, Ref<SharedBuffer>&&) override;	75	void curlDidReceiveBuffer(CurlRequest&, Ref<FragmentedSharedBuffer>&&) override;
76	void curlDidComplete(CurlRequest&, NetworkLoadMetrics&&) override;	76	void curlDidComplete(CurlRequest&, NetworkLoadMetrics&&) override;
77	void curlDidFailWithError(CurlRequest&, ResourceError&&, CertificateInfo&&) override;	77	void curlDidFailWithError(CurlRequest&, ResourceError&&, CertificateInfo&&) override;
78		78




}

void CurlMultipartHandle::didReceiveData(const FragmentedSharedBuffer& buffer)
{
    if (m_state == State::End)
        return; // The handler is closed down so ignore everything.

    m_buffer.append(buffer.makeContiguous()->data(), buffer.size());

    while (processContent()) { }
}

    if (m_state != State::End) {
        // It seems we are still not at the end of the processing.
        // Push out the remaining data.
        m_client.didReceiveDataFromMultipart(SharedBuffer::create(WTFMove(m_buffer)));
        m_state = State::End;
    }





class CurlMultipartHandleClient;
class CurlResponse;
class FragmentedSharedBuffer;

class CurlMultipartHandle {
    WTF_MAKE_FAST_ALLOCATED;

    CurlMultipartHandle(CurlMultipartHandleClient&, const String&);
    ~CurlMultipartHandle() { }

    void didReceiveData(const FragmentedSharedBuffer&);
    void didComplete();

private:



namespace WebCore {

class CurlResponse;
class FragmentedSharedBuffer;

class CurlMultipartHandleClient {
public:
    virtual void didReceiveHeaderFromMultipart(const Vector<String>&) = 0;
    virtual void didReceiveDataFromMultipart(Ref<FragmentedSharedBuffer>&&) = 0;

protected:
    ~CurlMultipartHandleClient() { }




// called with data after all headers have been processed via headerCallback

size_t CurlRequest::didReceiveData(Ref<FragmentedSharedBuffer>&& buffer)
{
    if (isCompletedOrCancelled())
        return 0;

    invokeDidReceiveResponse(response, Action::None);
}

void CurlRequest::didReceiveDataFromMultipart(Ref<FragmentedSharedBuffer>&& buffer)
{
    if (isCompletedOrCancelled())
        return;

    return m_downloadFilePath;
}

void CurlRequest::writeDataToDownloadFileIfEnabled(const FragmentedSharedBuffer& buffer)
{
    {
        Locker locker { m_downloadMutex };

    }

    if (m_downloadFileHandle != FileSystem::invalidPlatformFileHandle)
        FileSystem::writeToFile(m_downloadFileHandle, buffer.makeContiguous()->data(), buffer.size());
}

void CurlRequest::closeDownloadFile()



class CurlRequestClient;
class NetworkLoadMetrics;
class ResourceError;
class FragmentedSharedBuffer;
class SynchronousLoaderMessageQueue;

class CurlRequest : public ThreadSafeRefCounted<CurlRequest>, public CurlRequestSchedulerClient, public CurlMultipartHandleClient {

    CURL* setupTransfer() override;
    size_t willSendData(char*, size_t, size_t);
    size_t didReceiveHeader(String&&);
    size_t didReceiveData(Ref<FragmentedSharedBuffer>&&);
    void didReceiveHeaderFromMultipart(const Vector<String>&) override;
    void didReceiveDataFromMultipart(Ref<FragmentedSharedBuffer>&&) override;
    void didCompleteTransfer(CURLcode) override;
    void didCancelTransfer() override;
    void finalizeTransfer();

    NetworkLoadMetrics networkLoadMetrics();

    // Download
    void writeDataToDownloadFileIfEnabled(const FragmentedSharedBuffer&);
    void closeDownloadFile();
    void cleanupDownloadFile();




class CurlResponse;
class NetworkLoadMetrics;
class ResourceError;
class FragmentedSharedBuffer;

class CurlRequestClient {
public:


    virtual void curlDidSendData(CurlRequest&, unsigned long long bytesSent, unsigned long long totalBytesToBeSent) = 0;
    virtual void curlDidReceiveResponse(CurlRequest&, CurlResponse&&) = 0;
    virtual void curlDidReceiveBuffer(CurlRequest&, Ref<FragmentedSharedBuffer>&&) = 0;
    virtual void curlDidComplete(CurlRequest&, NetworkLoadMetrics&&) = 0;
    virtual void curlDidFailWithError(CurlRequest&, ResourceError&&, CertificateInfo&&) = 0;
};



    });
}

void CurlResourceHandleDelegate::curlDidReceiveBuffer(CurlRequest&, Ref<FragmentedSharedBuffer>&& buffer)
{
    ASSERT(isMainThread());

    if (cancelledOrClientless())
        return;

    auto contiguousBuffer = buffer->makeContiguous();
    CurlCacheManager::singleton().didReceiveData(m_handle, contiguousBuffer->data(), buffer->size());
    client()->didReceiveBuffer(&m_handle, WTFMove(contiguousBuffer), buffer->size());
}

void CurlResourceHandleDelegate::curlDidComplete(CurlRequest&, NetworkLoadMetrics&& metrics)

Lines 53-59 public: a/Source/WebCore/platform/network/curl/CurlResourceHandleDelegate.h_sec1
- a/Source/WebCore/platform/network/curl/CurlResourceHandleDelegate.h -1 / +1 lines
53		53
54	void curlDidSendData(CurlRequest&, unsigned long long bytesSent, unsigned long long totalBytesToBeSent) final;	54	void curlDidSendData(CurlRequest&, unsigned long long bytesSent, unsigned long long totalBytesToBeSent) final;
55	void curlDidReceiveResponse(CurlRequest&, CurlResponse&&) final;	55	void curlDidReceiveResponse(CurlRequest&, CurlResponse&&) final;
56	void curlDidReceiveBuffer(CurlRequest&, Ref<SharedBuffer>&&) final;	56	void curlDidReceiveBuffer(CurlRequest&, Ref<FragmentedSharedBuffer>&&) final;
57	void curlDidComplete(CurlRequest&, NetworkLoadMetrics&&) final;	57	void curlDidComplete(CurlRequest&, NetworkLoadMetrics&&) final;
58	void curlDidFailWithError(CurlRequest&, ResourceError&&, CertificateInfo&&) final;	58	void curlDidFailWithError(CurlRequest&, ResourceError&&, CertificateInfo&&) final;
59		59




namespace WebCore {

class FragmentedSharedBuffer;

class LegacyPreviewLoaderClient : public RefCounted<LegacyPreviewLoaderClient> {
public:
    virtual ~LegacyPreviewLoaderClient() = default;
    virtual void didReceiveBuffer(const FragmentedSharedBuffer&) { }
    virtual void didFinishLoading() { }
    virtual void didFail() { }
    virtual bool supportsPasswordEntry() const { return false; }




struct PasteboardFileCounter final : PasteboardFileReader {
    void readFilename(const String&) final { ++count; }
    void readBuffer(const String&, const String&, Ref<FragmentedSharedBuffer>&&) final { ++count; }

    unsigned count { 0 };
};

    return memObj;
}

static HGLOBAL createGlobalImageFileContent(FragmentedSharedBuffer* data)
{
    HGLOBAL memObj = GlobalAlloc(GPTR, data->size());
    if (!memObj) 

        return 0;
    }

    if (data->size())
        CopyMemory(fileContents, data->makeContiguous()->data(), data->size());

    GlobalUnlock(memObj);

    return memObj;
}

static HGLOBAL createGlobalHDropContent(const URL& url, String& fileName, FragmentedSharedBuffer* data)
{
    if (fileName.isEmpty() || !data)
        return 0;

        // Write the data to this temp file.
        DWORD written;
        BOOL tempWriteSucceeded = FALSE;
        if (data->size())
            tempWriteSucceeded = WriteFile(tempFileHandle, data->makeContiguous()->data(), data->size(), &written, 0);
        CloseHandle(tempFileHandle);
        if (!tempWriteSucceeded)
            return 0;

    if (!cachedImage || !cachedImage->imageForRenderer(element.renderer()) || !cachedImage->isLoaded())
        return;

    FragmentedSharedBuffer* imageBuffer = cachedImage->imageForRenderer(element.renderer())->data();
    if (!imageBuffer || !imageBuffer->size())
        return;




    return equalIgnoringASCIICase(keySystem, "org.webkit.mock");
}

void MockCDMFactory::addKeysToSessionWithID(const String& id, Vector<Ref<FragmentedSharedBuffer>>&& keys)
{
    auto addResult = m_sessions.add(id, WTFMove(keys));
    if (addResult.isNewEntry)

        value.append(WTFMove(key));
}

Vector<Ref<FragmentedSharedBuffer>> MockCDMFactory::removeKeysFromSessionWithID(const String& id)
{
    auto it = m_sessions.find(id);
    if (it == m_sessions.end())

    return WTFMove(it->value);
}

const Vector<Ref<FragmentedSharedBuffer>>* MockCDMFactory::keysForSessionWithID(const String& id) const
{
    auto it = m_sessions.find(id);
    if (it == m_sessions.end())

    return m_factory && m_factory->supportsSessions();
}

bool MockCDM::supportsInitData(const AtomString& initDataType, const FragmentedSharedBuffer& initData) const
{
    if (!supportedInitDataTypes().contains(initDataType))
        return false;

    return true;
}

RefPtr<FragmentedSharedBuffer> MockCDM::sanitizeResponse(const FragmentedSharedBuffer& response) const
{
    auto buffer = response.makeContiguous();
    if (!charactersAreAllASCII(buffer->data(), response.size()))
        return nullptr;

    Vector<String> responseArray = String(buffer->data(), response.size()).split(' ');

    if (!responseArray.contains(String("valid-response"_s)))
        return nullptr;

    callback(initialize());
}

void MockCDMInstance::setServerCertificate(Ref<FragmentedSharedBuffer>&& certificate, SuccessCallback&& callback)
{
    StringView certificateStringView(certificate->makeContiguous()->data(), certificate->size());

    callback(equalIgnoringASCIICase(certificateStringView, "valid") ? Succeeded : Failed);
}

{
}

void MockCDMInstanceSession::requestLicense(LicenseType licenseType, const AtomString& initDataType, Ref<FragmentedSharedBuffer>&& initData, LicenseCallback&& callback)
{
    MockCDMFactory* factory = m_instance ? m_instance->factory() : nullptr;
    if (!factory) {

    callback(SharedBuffer::create(license.data(), license.length()), sessionID, false, SuccessValue::Succeeded);
}

void MockCDMInstanceSession::updateLicense(const String& sessionID, LicenseType, Ref<FragmentedSharedBuffer>&& response, LicenseUpdateCallback&& callback)
{
    MockCDMFactory* factory = m_instance ? m_instance->factory() : nullptr;
    if (!factory) {

        return;
    }

    Vector<String> responseVector = String(response->makeContiguous()->data(), response->size()).split(' ');

    if (responseVector.contains(String("invalid-format"_s))) {
        callback(false, std::nullopt, std::nullopt, std::nullopt, SuccessValue::Failed);




    bool hasSessionWithID(const String& id) { return m_sessions.contains(id); }
    void removeSessionWithID(const String& id) { m_sessions.remove(id); }
    void addKeysToSessionWithID(const String& id, Vector<Ref<FragmentedSharedBuffer>>&&);
    const Vector<Ref<FragmentedSharedBuffer>>* keysForSessionWithID(const String& id) const;
    Vector<Ref<FragmentedSharedBuffer>> removeKeysFromSessionWithID(const String& id);

private:
    MockCDMFactory();

    bool m_canCreateInstances { true };
    bool m_supportsServerCertificates { true };
    bool m_supportsSessions { true };
    HashMap<String, Vector<Ref<FragmentedSharedBuffer>>> m_sessions;
};

class MockCDM : public CDMPrivate {

    void loadAndInitialize() final;
    bool supportsServerCertificates() const final;
    bool supportsSessions() const final;
    bool supportsInitData(const AtomString&, const FragmentedSharedBuffer&) const final;
    RefPtr<FragmentedSharedBuffer> sanitizeResponse(const FragmentedSharedBuffer&) const final;
    std::optional<String> sanitizeSessionId(const String&) const final;

    WeakPtr<MockCDMFactory> m_factory;

private:
    ImplementationType implementationType() const final { return ImplementationType::Mock; }
    void initializeWithConfiguration(const MediaKeySystemConfiguration&, AllowDistinctiveIdentifiers, AllowPersistentState, SuccessCallback&&) final;
    void setServerCertificate(Ref<FragmentedSharedBuffer>&&, SuccessCallback&&) final;
    void setStorageDirectory(const String&) final;
    const String& keySystem() const final;
    RefPtr<CDMInstanceSession> createSession() final;

    MockCDMInstanceSession(WeakPtr<MockCDMInstance>&&);

private:
    void requestLicense(LicenseType, const AtomString& initDataType, Ref<FragmentedSharedBuffer>&& initData, LicenseCallback&&) final;
    void updateLicense(const String&, LicenseType, Ref<FragmentedSharedBuffer>&&, LicenseUpdateCallback&&) final;
    void loadSession(LicenseType, const String&, const String&, LoadSessionCallback&&) final;
    void closeSession(const String&, CloseSessionCallback&&) final;
    void removeSessionData(const String&, LicenseType, RemoveSessionDataCallback&&) final;

Lines 110-116 void MockContentFilter::finishedAddingData() a/Source/WebCore/testing/MockContentFilter.cpp_sec1
- a/Source/WebCore/testing/MockContentFilter.cpp -1 / +1 lines
110	maybeDetermineStatus(DecisionPoint::AfterFinishedAddingData);	110	maybeDetermineStatus(DecisionPoint::AfterFinishedAddingData);
111	}	111	}
112		112
113	Ref<SharedBuffer> MockContentFilter::replacementData() const	113	Ref<FragmentedSharedBuffer> MockContentFilter::replacementData() const
114	{	114	{
115	ASSERT(didBlockData());	115	ASSERT(didBlockData());
116	return SharedBuffer::create(m_replacementData.data(), m_replacementData.size());	116	return SharedBuffer::create(m_replacementData.data(), m_replacementData.size());

Lines 42-48 public: a/Source/WebCore/testing/MockContentFilter.h_sec1
- a/Source/WebCore/testing/MockContentFilter.h -1 / +1 lines
42	void responseReceived(const ResourceResponse&) override;	42	void responseReceived(const ResourceResponse&) override;
43	void addData(const uint8_t* data, int length) override;	43	void addData(const uint8_t* data, int length) override;
44	void finishedAddingData() override;	44	void finishedAddingData() override;
45	Ref<SharedBuffer> replacementData() const override;	45	Ref<FragmentedSharedBuffer> replacementData() const override;
46	#if ENABLE(CONTENT_FILTERING)	46	#if ENABLE(CONTENT_FILTERING)
47	ContentFilterUnblockHandler unblockHandler() const override;	47	ContentFilterUnblockHandler unblockHandler() const override;
48	#endif	48	#endif



ScriptBuffer::ScriptBuffer(const String& string)
{
    auto utf8 = string.utf8();
    m_buffer.append(utf8.data(), utf8.length());
}

ScriptBuffer ScriptBuffer::empty()

    return ScriptBuffer { SharedBuffer::create() };
}


String ScriptBuffer::toString() const
{
    if (!m_buffer)
        return String();

    StringBuilder builder;
    m_buffer.get()->forEachSegment([&](auto& segment) {
        builder.append(String::fromUTF8(segment.data(), segment.size()));
    });
    return builder.toString();


bool ScriptBuffer::containsSingleFileMappedSegment() const
{
    return m_buffer && m_buffer.get()->hasOneSegment() && m_buffer.get()->begin()->segment->containsMappedFileData();
}

void ScriptBuffer::append(const String& string)
{
    if (!m_buffer)
        m_buffer = SharedBuffer::create();
    auto utf8 = string.utf8();
    m_buffer.append(utf8.data(), utf8.length());
}

bool operator==(const ScriptBuffer& a, const ScriptBuffer& b)



public:
    ScriptBuffer() = default;

    ScriptBuffer(RefPtr<FragmentedSharedBuffer>&& buffer)
        : m_buffer(WTFMove(buffer))
    {
    }

    WEBCORE_EXPORT explicit ScriptBuffer(const String&);

    String toString() const;
    const FragmentedSharedBuffer* buffer() const { return m_buffer.get().get(); }

    ScriptBuffer isolatedCopy() const { return ScriptBuffer(m_buffer ? RefPtr<FragmentedSharedBuffer>(m_buffer.copy()) : nullptr); }
    explicit operator bool() const { return !!m_buffer; }
    bool isEmpty() const { return m_buffer.isEmpty(); }

    WEBCORE_EXPORT bool containsSingleFileMappedSegment() const;
    void append(const String&);

private:
    SharedBufferBuilder m_buffer; // Contains the UTF-8 encoded script.
};

bool operator==(const ScriptBuffer&, const ScriptBuffer&);

Lines 44-49 namespace WebCore { a/Source/WebCore/workers/WorkerFontLoadRequest.cpp_sec1
- a/Source/WebCore/workers/WorkerFontLoadRequest.cpp -6 / +13 lines
44	WorkerFontLoadRequest::WorkerFontLoadRequest(URL&& url, LoadedFromOpaqueSource loadedFromOpaqueSource)	44	WorkerFontLoadRequest::WorkerFontLoadRequest(URL&& url, LoadedFromOpaqueSource loadedFromOpaqueSource)
45	: m_url(WTFMove(url))	45	: m_url(WTFMove(url))
46	, m_loadedFromOpaqueSource(loadedFromOpaqueSource)	46	, m_loadedFromOpaqueSource(loadedFromOpaqueSource)
		47	, m_data(makeUniqueRef<SharedBufferBuilder>())
47	{	48	{
48	}	49	}
49		50
Lines 75-86 void WorkerFontLoadRequest::load(WorkerGlobalScope& workerGlobalScope) a/Source/WebCore/workers/WorkerFontLoadRequest.cpp_sec2
75	WorkerThreadableLoader::loadResourceSynchronously(workerGlobalScope, WTFMove(request), *this, options);	76	WorkerThreadableLoader::loadResourceSynchronously(workerGlobalScope, WTFMove(request), *this, options);
76	}	77	}
77		78
		79	bool WorkerFontLoadRequest::isPending() const
		80	{
		81	return !m_isLoading && !m_errorOccurred && m_data->isNull();
		82	}
		83
78	bool WorkerFontLoadRequest::ensureCustomFontData(const AtomString&)	84	bool WorkerFontLoadRequest::ensureCustomFontData(const AtomString&)
79	{	85	{
80	if (!m_fontCustomPlatformData && !m_errorOccurred && !m_isLoading) {	86	if (!m_fontCustomPlatformData && !m_errorOccurred && !m_isLoading) {
81	convertWOFFToSfntIfNecessary(m_data);	87	RefPtr<SharedBuffer> contiguousData;
82	if (m_data) {	88	if (m_data->get())
83	m_fontCustomPlatformData = createFontCustomPlatformData(*m_data, m_url.fragmentIdentifier().toString());	89	contiguousData = m_data->take()->makeContiguous();
		90	convertWOFFToSfntIfNecessary(contiguousData);
		91	if (contiguousData) {
		92	m_data->append(*contiguousData);
		93	m_fontCustomPlatformData = createFontCustomPlatformData(*contiguousData, m_url.fragmentIdentifier().toString());
84	if (!m_fontCustomPlatformData)	94	if (!m_fontCustomPlatformData)
85	m_errorOccurred = true;	95	m_errorOccurred = true;
86	}	96	}
Lines 117-125 void WorkerFontLoadRequest::didReceiveData(const uint8_t* data, int dataLength) a/Source/WebCore/workers/WorkerFontLoadRequest.cpp_sec3
117	if (m_errorOccurred)	127	if (m_errorOccurred)
118	return;	128	return;
119		129
120	if (!m_data)
121	m_data = SharedBuffer::create();
122
123	m_data->append(data, dataLength);	130	m_data->append(data, dataLength);
124	}	131	}
125		132



#include "ResourceLoaderOptions.h"
#include "ThreadableLoaderClient.h"
#include <wtf/URL.h>
#include <wtf/UniqueRef.h>
#include <wtf/WeakPtr.h>

namespace WebCore {

class FontCreationContext;
class ScriptExecutionContext;
class SharedBufferBuilder;
class WorkerGlobalScope;

struct FontCustomPlatformData;


private:
    const URL& url() const final { return m_url; }
    bool isPending() const final;
    bool isLoading() const final { return m_isLoading; }
    bool errorOccurred() const final { return m_errorOccurred; }


    FontLoadRequestClient* m_fontLoadRequestClient { nullptr };

    WeakPtr<ScriptExecutionContext> m_context;
    UniqueRef<SharedBufferBuilder> m_data;
    std::unique_ptr<FontCustomPlatformData> m_fontCustomPlatformData;
};




class ResourceResponse;
class ServiceWorkerGlobalScope;
class ServiceWorkerGlobalScope;
class FragmentedSharedBuffer;

namespace ServiceWorkerFetch {
class Client : public ThreadSafeRefCounted<Client, WTF::DestructionThread::Main> {


    virtual void didReceiveRedirection(const ResourceResponse&) = 0;
    virtual void didReceiveResponse(const ResourceResponse&) = 0;
    virtual void didReceiveData(Ref<FragmentedSharedBuffer>&&) = 0;
    virtual void didReceiveFormDataAndFinish(Ref<FormData>&&) = 0;
    virtual void didFail(const ResourceError&) = 0;
    virtual void didFinish() = 0;



    }

    // FIXME: Do we need to disable file mapping in more cases to avoid having too many file descriptors open?
    RefPtr<FragmentedSharedBuffer> buffer = SharedBuffer::createWithContentsOfFile(scriptPath, FileSystem::MappedFileMode::Private, shouldUseFileMapping(*fileSize) ? SharedBuffer::MayUseFileMapping::Yes : SharedBuffer::MayUseFileMapping::No);
    return buffer;
}

void SWScriptStorage::clear(const ServiceWorkerRegistrationKey& registrationKey)



    , m_responseCacheIsValid(false)
    , m_readyState(static_cast<unsigned>(UNSENT))
    , m_responseType(static_cast<unsigned>(ResponseType::EmptyString))
    , m_binaryResponseBuilder(makeUniqueRef<SharedBufferBuilder>())
    , m_progressEventThrottle(*this)
    , m_timeoutTimer(*this, &XMLHttpRequest::timeoutTimerFired)
{


    // FIXME: We just received the data from NetworkProcess, and are sending it back. This is inefficient.
    Vector<uint8_t> data;
    if (!m_binaryResponseBuilder->isNull())
        data = m_binaryResponseBuilder->take()->extractData();
    String normalizedContentType = Blob::normalizedContentType(responseMIMEType(FinalMIMEType::Yes)); // responseMIMEType defaults to text/xml which may be incorrect.
    return Blob::create(scriptExecutionContext(), WTFMove(data), normalizedContentType);
}

    ASSERT(responseType() == ResponseType::Arraybuffer);
    ASSERT(doneWithoutErrors());

    auto result = !m_binaryResponseBuilder->isNull() ? m_binaryResponseBuilder->take()->tryCreateArrayBuffer() : ArrayBuffer::create(nullptr, 0);
    m_binaryResponseBuilder = nullptr;
    return result;
}


    m_responseEncoding = String();
    m_createdDocument = false;
    m_responseDocument = nullptr;
    m_binaryResponseBuilder->reset();
    m_responseCacheIsValid = false;
}


        m_responseBuilder.append(m_decoder->decode(data, len));
    else {
        // Buffer binary data.
        if (!m_binaryResponseBuilder)
            m_binaryResponseBuilder = SharedBuffer::create();
        m_binaryResponseBuilder->append(data, len);
    }




#include "ThreadableLoaderClient.h"
#include "UserGestureIndicator.h"
#include <wtf/URL.h>
#include <wtf/UniqueRef.h>
#include "XMLHttpRequestEventTarget.h"
#include "XMLHttpRequestProgressEventThrottle.h"
#include <variant>

class Document;
class DOMFormData;
class SecurityOrigin;
class SharedBufferBuilder;
class TextResourceDecoder;
class ThreadableLoader;
class URLSearchParams;


    RefPtr<Document> m_responseDocument;

    UniqueRef<SharedBufferBuilder> m_binaryResponseBuilder;

    StringBuilder m_responseBuilder;




2021-12-05  Jean-Yves Avenard  <jya@apple.com>

        SourceBufferParser should be using contiguous shared buffer
        https://bugs.webkit.org/show_bug.cgi?id=233865
        rdar://problem/86085253

        Reviewed by NOBODY (OOPS!).

        * WebProcess/GPU/media/SourceBufferPrivateRemote.cpp:
        (WebKit::SourceBufferPrivateRemote::append):
        * WebProcess/GPU/media/SourceBufferPrivateRemote.h:

2021-12-03  Jean-Yves Avenard  <jya@apple.com>

        Rename SharedBuffer classes.
        https://bugs.webkit.org/show_bug.cgi?id=233677
        rdar://problem/85963900

        Reviewed by NOBODY (OOPS!).

        SharedBuffer are renamed FragmentedSharedBuffer and
        ContiguousSharedBuffer to SharedBuffer to better reflect their actual
        types.

        * GPUProcess/media/RemoteCDMInstanceProxy.cpp:
        * GPUProcess/media/RemoteCDMInstanceProxy.h:
        * GPUProcess/media/RemoteCDMInstanceSessionProxy.cpp:
        * GPUProcess/media/RemoteCDMInstanceSessionProxy.h:
        * GPUProcess/media/RemoteCDMProxy.cpp:
        * GPUProcess/media/RemoteCDMProxy.h:
        * GPUProcess/media/RemoteLegacyCDMProxy.h:
        * GPUProcess/media/RemoteLegacyCDMSessionProxy.cpp:
        * GPUProcess/media/RemoteLegacyCDMSessionProxy.h:
        * GPUProcess/media/RemoteMediaResource.cpp:
        * GPUProcess/media/RemoteMediaResource.h:
        * GPUProcess/webrtc/RemoteMediaRecorder.cpp:
        * NetworkProcess/Downloads/PendingDownload.h:
        * NetworkProcess/NetworkCORSPreflightChecker.cpp:
        * NetworkProcess/NetworkCORSPreflightChecker.h:
        * NetworkProcess/NetworkDataTask.h:
        * NetworkProcess/NetworkLoad.cpp:
        * NetworkProcess/NetworkLoad.h:
        * NetworkProcess/NetworkLoadClient.h:
        * NetworkProcess/NetworkResourceLoader.cpp:
        * NetworkProcess/NetworkResourceLoader.h:
        * NetworkProcess/PingLoad.cpp:
        * NetworkProcess/PingLoad.h:
        * NetworkProcess/PreconnectTask.cpp:
        * NetworkProcess/PreconnectTask.h:
        * NetworkProcess/ServiceWorker/ServiceWorkerNavigationPreloader.cpp:
        * NetworkProcess/ServiceWorker/ServiceWorkerNavigationPreloader.h:
        * NetworkProcess/ServiceWorker/ServiceWorkerSoftUpdateLoader.cpp:
        * NetworkProcess/ServiceWorker/ServiceWorkerSoftUpdateLoader.h:
        * NetworkProcess/cache/CacheStorageEngineCache.cpp:
        * NetworkProcess/cache/NetworkCache.cpp:
        * NetworkProcess/cache/NetworkCache.h:
        * NetworkProcess/cache/NetworkCacheEntry.cpp:
        * NetworkProcess/cache/NetworkCacheEntry.h:
        * NetworkProcess/cache/NetworkCacheSpeculativeLoad.cpp:
        * NetworkProcess/cache/NetworkCacheSpeculativeLoad.h:
        * NetworkProcess/cache/PrefetchCache.cpp:
        * NetworkProcess/cache/PrefetchCache.h:
        * NetworkProcess/cocoa/NetworkDataTaskCocoa.h:
        * NetworkProcess/cocoa/NetworkDataTaskCocoa.mm:
        * NetworkProcess/curl/NetworkDataTaskCurl.cpp:
        * NetworkProcess/curl/NetworkDataTaskCurl.h:
        * NetworkProcess/soup/NetworkDataTaskSoup.cpp:
        * NetworkProcess/webrtc/NetworkRTCProvider.h:
        * Platform/IPC/SharedBufferCopy.cpp:
        * Platform/IPC/SharedBufferCopy.h:
        * Platform/IPC/SharedBufferDataReference.h:
        * Platform/SharedMemory.cpp:
        * Platform/SharedMemory.h:
        * Shared/Cocoa/WebCoreArgumentCodersCocoa.mm:
        * Shared/RemoteLayerTree/CGDisplayListImageBufferBackend.cpp:
        * Shared/ShareableResource.cpp:
        * Shared/ShareableResource.h:
        * Shared/WebCoreArgumentCoders.cpp:
        * Shared/WebCoreArgumentCoders.h:
        * Shared/WebHitTestResultData.cpp:
        * Shared/gtk/ArgumentCodersGtk.cpp:
        * Shared/win/WebCoreArgumentCodersWin.cpp:
        * UIProcess/API/APIAttachment.cpp:
        * UIProcess/API/APIAttachment.h:
        * UIProcess/API/APIContentRuleListStore.cpp:
        * UIProcess/API/APIContentRuleListStore.h:
        * UIProcess/API/APINavigationClient.h:
        * UIProcess/API/Cocoa/APIAttachmentCocoa.mm:
        * UIProcess/API/gtk/DropTargetGtk3.cpp:
        * UIProcess/Cocoa/NavigationState.h:
        * UIProcess/Cocoa/NavigationState.mm:
        * UIProcess/Cocoa/WebProcessProxyCocoa.mm:
        * UIProcess/Cocoa/WebViewImpl.h:
        * UIProcess/Cocoa/WebViewImpl.mm:
        * UIProcess/PageClient.h:
        * UIProcess/WebPageProxy.h:
        * UIProcess/WebURLSchemeTask.cpp:
        * UIProcess/WebURLSchemeTask.h:
        * UIProcess/gtk/Clipboard.h:
        * UIProcess/gtk/ClipboardGtk3.cpp:
        * UIProcess/gtk/ClipboardGtk4.cpp:
        * UIProcess/ios/PageClientImplIOS.h:
        * UIProcess/ios/PageClientImplIOS.mm:
        * UIProcess/ios/WKContentViewInteraction.mm:
        * UIProcess/ios/WebPageProxyIOS.mm:
        * UIProcess/mac/PageClientImplMac.h:
        * UIProcess/mac/PageClientImplMac.mm:
        * UIProcess/mac/WebPageProxyMac.mm:
        * WebProcess/GPU/media/RemoteCDM.cpp:
        * WebProcess/GPU/media/RemoteCDM.h:
        * WebProcess/GPU/media/RemoteCDMInstance.cpp:
        * WebProcess/GPU/media/RemoteCDMInstance.h:
        * WebProcess/GPU/media/RemoteCDMInstanceSession.cpp:
        * WebProcess/GPU/media/RemoteCDMInstanceSession.h:
        * WebProcess/GPU/media/RemoteImageDecoderAVF.cpp:
        * WebProcess/GPU/media/RemoteImageDecoderAVF.h:
        * WebProcess/GPU/media/RemoteImageDecoderAVFManager.cpp:
        * WebProcess/GPU/media/RemoteImageDecoderAVFManager.h:
        * WebProcess/GPU/media/RemoteLegacyCDMSession.cpp:
        * WebProcess/GPU/media/SourceBufferPrivateRemote.cpp:
        * WebProcess/GPU/media/SourceBufferPrivateRemote.h:
        * WebProcess/GPU/webrtc/MediaRecorderPrivate.cpp:
        * WebProcess/GPU/webrtc/MediaRecorderPrivate.h:
        * WebProcess/InjectedBundle/API/APIInjectedBundleEditorClient.h:
        * WebProcess/InjectedBundle/API/APIInjectedBundlePageLoaderClient.h:
        * WebProcess/InjectedBundle/API/mac/WKWebProcessPlugInBrowserContextController.mm:
        * WebProcess/InjectedBundle/InjectedBundlePageEditorClient.cpp:
        * WebProcess/InjectedBundle/InjectedBundlePageEditorClient.h:
        * WebProcess/InjectedBundle/InjectedBundlePageLoaderClient.cpp:
        * WebProcess/InjectedBundle/InjectedBundlePageLoaderClient.h:
        * WebProcess/Network/NetworkProcessConnection.cpp:
        * WebProcess/Network/WebResourceLoader.cpp:
        * WebProcess/Plugins/PDF/PDFPlugin.h:
        * WebProcess/Plugins/PDF/PDFPlugin.mm:
        * WebProcess/Plugins/Plugin.h:
        * WebProcess/Plugins/PluginView.cpp:
        * WebProcess/Plugins/PluginView.h:
        * WebProcess/Storage/WebServiceWorkerFetchTaskClient.cpp:
        * WebProcess/Storage/WebServiceWorkerFetchTaskClient.h:
        * WebProcess/WebCoreSupport/WebEditorClient.cpp:
        * WebProcess/WebCoreSupport/WebEditorClient.h:
        * WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:
        * WebProcess/WebCoreSupport/WebPlatformStrategies.cpp:
        * WebProcess/WebCoreSupport/WebPlatformStrategies.h:
        * WebProcess/WebCoreSupport/ios/WebPreviewLoaderClient.cpp:
        * WebProcess/WebCoreSupport/ios/WebPreviewLoaderClient.h:
        * WebProcess/WebCoreSupport/mac/WebDragClientMac.mm:
        * WebProcess/WebPage/WebFrame.cpp:
        * WebProcess/WebPage/WebPage.cpp:
        * WebProcess/WebPage/WebPage.h:
        * WebProcess/WebPage/ios/WebPageIOS.mm:
        * WebProcess/WebPage/mac/WebPageMac.mm:
        * WebProcess/win/WebProcessWin.cpp:

2021-11-28  Jean-Yves Avenard  <jya@apple.com>

        Add SharedBufferBuilder class
        https://bugs.webkit.org/show_bug.cgi?id=233442
        rdar://85693939

        Reviewed by NOBODY (OOPS!).

        * NetworkProcess/NetworkResourceLoader.cpp:
        (WebKit::NetworkResourceLoader::startNetworkLoad):
        (WebKit::NetworkResourceLoader::didReceiveResponse):
        (WebKit::NetworkResourceLoader::didReceiveBuffer):
        (WebKit::NetworkResourceLoader::didFinishLoading):
        (WebKit::NetworkResourceLoader::bufferingTimerFired):
        (WebKit::NetworkResourceLoader::tryStoreAsCacheEntry):
        * NetworkProcess/NetworkResourceLoader.h:
        * NetworkProcess/cache/NetworkCacheSpeculativeLoad.cpp:
        (WebKit::NetworkCache::SpeculativeLoad::SpeculativeLoad):
        (WebKit::NetworkCache::SpeculativeLoad::didReceiveResponse):
        (WebKit::NetworkCache::SpeculativeLoad::didReceiveBuffer):
        (WebKit::NetworkCache::SpeculativeLoad::didFinishLoading):
        * NetworkProcess/cache/NetworkCacheSpeculativeLoad.h:
        * UIProcess/WebURLSchemeTask.cpp:
        (WebKit::WebURLSchemeTask::WebURLSchemeTask):
        (WebKit::WebURLSchemeTask::didReceiveData):
        (WebKit::WebURLSchemeTask::didComplete):
        * UIProcess/WebURLSchemeTask.h:
        * WebProcess/Plugins/PluginView.cpp:
        (WebKit::PluginView::PluginView):
        (WebKit::PluginView::manualLoadDidReceiveData):
        (WebKit::PluginView::manualLoadDidFail):
        (WebKit::PluginView::liveResourceData const):
        (WebKit::PluginView::redeliverManualStream):
        * WebProcess/Plugins/PluginView.h:
        * WebProcess/Storage/WebServiceWorkerFetchTaskClient.cpp:
        (WebKit::WebServiceWorkerFetchTaskClient::didReceiveData):
        (WebKit::WebServiceWorkerFetchTaskClient::continueDidReceiveResponse):
        * WebProcess/Storage/WebServiceWorkerFetchTaskClient.h:
        * WebProcess/WebCoreSupport/ios/WebPreviewLoaderClient.cpp:
        (WebKit::WebPreviewLoaderClient::didFinishLoading):
        (WebKit::WebPreviewLoaderClient::didFail):
        * WebProcess/WebCoreSupport/ios/WebPreviewLoaderClient.h:

2021-11-25  Jean-Yves Avenard  <jya@apple.com>

        Distinguish contiguous SharedBuffer from non-contiguous one and guarantee immutability
        https://bugs.webkit.org/show_bug.cgi?id=233030
        rdar://85333814

        Reviewed by Darin Adler.

        * GPUProcess/webrtc/RemoteMediaRecorder.cpp:
        (WebKit::RemoteMediaRecorder::fetchData):
        * NetworkProcess/NetworkResourceLoader.cpp:
        (WebKit::sendReplyToSynchronousRequest):
        * NetworkProcess/ServiceWorker/ServiceWorkerSoftUpdateLoader.cpp:
        (WebKit::ServiceWorkerSoftUpdateLoader::didReceiveBuffer):
        * NetworkProcess/cache/CacheStorageEngineCache.cpp:
        (WebKit::CacheStorage::Cache::encode):
        (WebKit::CacheStorage::Cache::decode):
        * NetworkProcess/cache/NetworkCacheEntry.cpp:
        (WebKit::NetworkCache::Entry::encodeAsStorageRecord const):
        * NetworkProcess/soup/NetworkDataTaskSoup.cpp:
        (WebKit::NetworkDataTaskSoup::didReadDataURL):
        * Platform/IPC/SharedBufferCopy.cpp:
        (IPC::SharedBufferCopy::decode):
        * Platform/IPC/SharedBufferCopy.h:
        (IPC::SharedBufferCopy::SharedBufferCopy):
        (IPC::SharedBufferCopy::buffer):
        (IPC::SharedBufferCopy::buffer const):
        * Platform/SharedMemory.cpp:
        (WebKit::SharedMemory::createSharedBuffer const):
        * Platform/SharedMemory.h:
        * Shared/APIWebArchiveResource.mm:
        (API::WebArchiveResource::data):
        * Shared/Cocoa/WebCoreArgumentCodersCocoa.mm:
        (IPC::ArgumentCoder<Ref<WebCore::Font>>::decodePlatformData):
        * Shared/RemoteLayerTree/CGDisplayListImageBufferBackend.cpp:
        (WebKit::CGDisplayListImageBufferBackend::createImageBufferBackendHandle const):
        * Shared/ShareableResource.cpp:
        (WebKit::ShareableResource::wrapInSharedBuffer):
        (WebKit::ShareableResource::Handle::tryWrapInSharedBuffer const):
        * Shared/ShareableResource.h:
        * Shared/WebCoreArgumentCoders.cpp:
        (IPC::decodeSharedBuffer):
        (IPC::encodeTypesAndData):
        (IPC::decodeTypesAndData):
        (IPC::ArgumentCoder<DOMCacheEngine::Record>::encode):
        (IPC::ArgumentCoder<DOMCacheEngine::Record>::decode):
        (IPC::ArgumentCoder<PasteboardCustomData::Entry>::decode):
        (IPC::ArgumentCoder<WebCore::SerializedAttachmentData>::decode):
        (IPC::ArgumentCoder<RefPtr<WebCore::SharedBuffer>>::decode):
        (IPC::ArgumentCoder<Ref<WebCore::SharedBuffer>>::decode):
        (IPC::ArgumentCoder<RefPtr<WebCore::ContiguousSharedBuffer>>::encode):
        (IPC::ArgumentCoder<RefPtr<WebCore::ContiguousSharedBuffer>>::decode):
        (IPC::ArgumentCoder<Ref<WebCore::ContiguousSharedBuffer>>::encode):
        (IPC::ArgumentCoder<Ref<WebCore::ContiguousSharedBuffer>>::decode):
        (IPC::ArgumentCoder<WebCore::ScriptBuffer>::decode):
        * Shared/WebCoreArgumentCoders.h:
        * Shared/gtk/ArgumentCodersGtk.cpp:
        (IPC::ArgumentCoder<SelectionData>::decode):
        * Shared/win/WebCoreArgumentCodersWin.cpp:
        (IPC::ArgumentCoder<Ref<Font>>::decodePlatformData):
        * UIProcess/API/APIAttachment.cpp:
        (API::Attachment::createSerializedRepresentation const):
        (API::Attachment::updateFromSerializedRepresentation):
        * UIProcess/API/APIAttachment.h:
        * UIProcess/API/APIContentRuleListStore.cpp:
        (API::getData):
        * UIProcess/API/Cocoa/APIAttachmentCocoa.mm:
        (API::Attachment::createSerializedRepresentation const):
        (API::Attachment::updateFromSerializedRepresentation):
        * UIProcess/API/Cocoa/WKWebView.mm:
        (-[WKWebView _storeAppHighlight:]):
        * UIProcess/API/gtk/DropTargetGtk3.cpp:
        (WebKit::DropTarget::dataReceived):
        * UIProcess/Cocoa/NavigationState.mm:
        (WebKit::NavigationState::NavigationClient::didFinishLoadForQuickLookDocumentInMainFrame):
        * UIProcess/Cocoa/WebViewImpl.mm:
        (WebKit::WebViewImpl::writeSelectionToPasteboard):
        (WebKit::WebViewImpl::setPromisedDataForImage):
        (WebKit::WebViewImpl::provideDataForPasteboard):
        (WebKit::WebViewImpl::namesOfPromisedFilesDroppedAtDestination):
        (WebKit::WebViewImpl::requestDOMPasteAccess):
        * UIProcess/PageClient.h:
        * UIProcess/WebPageProxy.h:
        * UIProcess/WebURLSchemeTask.cpp:
        (WebKit::WebURLSchemeTask::didComplete):
        * UIProcess/ios/PageClientImplIOS.h:
        * UIProcess/ios/PageClientImplIOS.mm:
        (WebKit::PageClientImpl::saveImageToLibrary):
        * UIProcess/ios/WKContentViewInteraction.mm:
        (-[WKContentView canPerformActionForWebView:withSender:]):
        (allPasteboardItemOriginsMatchOrigin):
        (-[WKContentView actionSheetAssistant:shareElementWithImage:rect:]):
        * UIProcess/ios/WebPageProxyIOS.mm:
        (WebKit::WebPageProxy::dataSelectionForPasteboard):
        * UIProcess/mac/WebPageProxyMac.mm:
        (WebKit::WebPageProxy::dataSelectionForPasteboard):
        * WebProcess/InjectedBundle/API/APIInjectedBundleEditorClient.h:
        (API::InjectedBundle::EditorClient::getPasteboardDataForRange):
        * WebProcess/InjectedBundle/API/mac/WKWebProcessPlugInBrowserContextController.mm:
        (-[WKWebProcessPlugInBrowserContextController _setEditingDelegate:]):
        * WebProcess/InjectedBundle/InjectedBundlePageEditorClient.cpp:
        (WebKit::InjectedBundlePageEditorClient::getPasteboardDataForRange):
        * WebProcess/InjectedBundle/InjectedBundlePageEditorClient.h:
        * WebProcess/InjectedBundle/InjectedBundlePageLoaderClient.cpp:
        (WebKit::releaseSharedBuffer):
        (WebKit::InjectedBundlePageLoaderClient::willLoadDataRequest):
        * WebProcess/Model/mac/ARKitInlinePreviewModelPlayerMac.mm:
        (WebKit::ARKitInlinePreviewModelPlayerMac::createFile):
        * WebProcess/Network/NetworkProcessConnection.cpp:
        (WebKit::NetworkProcessConnection::didCacheResource):
        * WebProcess/Network/WebResourceLoader.cpp:
        (WebKit::WebResourceLoader::didReceiveData):
        * WebProcess/WebCoreSupport/WebEditorClient.cpp:
        (WebKit::WebEditorClient::getClientPasteboardData):
        * WebProcess/WebCoreSupport/WebEditorClient.h:
        * WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:
        (WebKit::WebFrameLoaderClient::finishedLoading):
        * WebProcess/WebCoreSupport/WebPlatformStrategies.cpp:
        (WebKit::WebPlatformStrategies::bufferForType):
        (WebKit::WebPlatformStrategies::readBufferFromClipboard):
        (WebKit::WebPlatformStrategies::readBufferFromPasteboard):
        * WebProcess/WebCoreSupport/WebPlatformStrategies.h:
        * WebProcess/WebCoreSupport/mac/WebDragClientMac.mm:
        (WebKit::WebDragClient::declareAndWriteDragImage):
        * WebProcess/WebPage/WebFrame.cpp:
        (WebKit::WebFrame::source const):
        * WebProcess/WebPage/mac/WebPageMac.mm:
        (WebKit::WebPage::getDataSelectionForPasteboard):
        * WebProcess/cocoa/VideoFullscreenManager.mm:
        (WebKit::VideoFullscreenManager::supportsVideoFullscreen const):
        (WebKit::VideoFullscreenManager::supportsVideoFullscreenStandby const):

2021-12-05  Said Abou-Hallawa  <said@apple.com>

        [GPU Process] Add the encoding/decoding for Filter and FilterEffect

Lines 61-67 RemoteCDMInstanceProxy::~RemoteCDMInstanceProxy() a/Source/WebKit/GPUProcess/media/RemoteCDMInstanceProxy.cpp_sec1
- a/Source/WebKit/GPUProcess/media/RemoteCDMInstanceProxy.cpp -1 / +1 lines
61	m_instance->clearClient();	61	m_instance->clearClient();
62	}	62	}
63		63
64	void RemoteCDMInstanceProxy::unrequestedInitializationDataReceived(const String& type, Ref<SharedBuffer>&& initData)	64	void RemoteCDMInstanceProxy::unrequestedInitializationDataReceived(const String& type, Ref<FragmentedSharedBuffer>&& initData)
65	{	65	{
66	if (!m_cdm)	66	if (!m_cdm)
67	return;	67	return;

Lines 66-72 private: a/Source/WebKit/GPUProcess/media/RemoteCDMInstanceProxy.h_sec1
- a/Source/WebKit/GPUProcess/media/RemoteCDMInstanceProxy.h -1 / +1 lines
66	RemoteCDMInstanceProxy(WeakPtr<RemoteCDMProxy>&&, Ref<WebCore::CDMInstance>&&, UniqueRef<RemoteCDMInstanceConfiguration>&&, RemoteCDMInstanceIdentifier);	66	RemoteCDMInstanceProxy(WeakPtr<RemoteCDMProxy>&&, Ref<WebCore::CDMInstance>&&, UniqueRef<RemoteCDMInstanceConfiguration>&&, RemoteCDMInstanceIdentifier);
67		67
68	// CDMInstanceClient	68	// CDMInstanceClient
69	void unrequestedInitializationDataReceived(const String&, Ref<WebCore::SharedBuffer>&&) final;	69	void unrequestedInitializationDataReceived(const String&, Ref<WebCore::FragmentedSharedBuffer>&&) final;
70		70
71	// IPC::MessageReceiver	71	// IPC::MessageReceiver
72	void didReceiveMessage(IPC::Connection&, IPC::Decoder&) final;	72	void didReceiveMessage(IPC::Connection&, IPC::Decoder&) final;



        return;
    }

    m_session->requestLicense(type, initDataType, initData.buffer().releaseNonNull(), [completion = WTFMove(completion)] (Ref<FragmentedSharedBuffer>&& message, const String& sessionId, bool needsIndividualization, CDMInstanceSession::SuccessValue succeeded) mutable {
        completion(WTFMove(message), sessionId, needsIndividualization, succeeded == CDMInstanceSession::Succeeded);
    });
}


void RemoteCDMInstanceSessionProxy::removeSessionData(const String& sessionId, LicenseType type, RemoveSessionDataCallback&& completion)
{
    m_session->removeSessionData(sessionId, type, [completion = WTFMove(completion)] (CDMInstanceSession::KeyStatusVector&& keyStatuses, std::optional<Ref<FragmentedSharedBuffer>>&& expiredSessionsData, CDMInstanceSession::SuccessValue succeeded) mutable {
        std::optional<IPC::SharedBufferCopy> expiredSessionDataReference;
        if (expiredSessionsData)
            expiredSessionDataReference = IPC::SharedBufferCopy(WTFMove(*expiredSessionsData));

    gpuConnectionToWebProcess->connection().send(Messages::RemoteCDMInstanceSession::UpdateKeyStatuses(WTFMove(keyStatuses)), m_identifier);
}

void RemoteCDMInstanceSessionProxy::sendMessage(CDMMessageType type, Ref<FragmentedSharedBuffer>&& message)
{
    if (!m_cdm)
        return;

Lines 77-83 private: a/Source/WebKit/GPUProcess/media/RemoteCDMInstanceSessionProxy.h_sec1
- a/Source/WebKit/GPUProcess/media/RemoteCDMInstanceSessionProxy.h -1 / +1 lines
77		77
78	// CDMInstanceSessionClient	78	// CDMInstanceSessionClient
79	void updateKeyStatuses(KeyStatusVector&&) final;	79	void updateKeyStatuses(KeyStatusVector&&) final;
80	void sendMessage(WebCore::CDMMessageType, Ref<WebCore::SharedBuffer>&& message) final;	80	void sendMessage(WebCore::CDMMessageType, Ref<WebCore::FragmentedSharedBuffer>&& message) final;
81	void sessionIdChanged(const String&) final;	81	void sessionIdChanged(const String&) final;
82	PlatformDisplayID displayID() final { return m_displayID; }	82	PlatformDisplayID displayID() final { return m_displayID; }
83		83




RemoteCDMProxy::~RemoteCDMProxy() = default;

bool RemoteCDMProxy::supportsInitData(const AtomString& type, const FragmentedSharedBuffer& data)
{
    return m_private->supportsInitData(type, data);
}

RefPtr<FragmentedSharedBuffer> RemoteCDMProxy::sanitizeResponse(const FragmentedSharedBuffer& response)
{
    return m_private->sanitizeResponse(response);
}



#include <wtf/UniqueRef.h>

namespace WebCore {
class FragmentedSharedBuffer;
enum class CDMRequirement : uint8_t;
enum class CDMSessionType : uint8_t;
struct CDMKeySystemConfiguration;


    RemoteCDMFactoryProxy* factory() const { return m_factory.get(); }

    bool supportsInitData(const AtomString&, const WebCore::FragmentedSharedBuffer&);
    RefPtr<WebCore::FragmentedSharedBuffer> sanitizeResponse(const WebCore::FragmentedSharedBuffer& response);
    std::optional<String> sanitizeSessionId(const String& sessionId);

private:

Lines 36-42 a/Source/WebKit/GPUProcess/media/RemoteLegacyCDMProxy.h_sec1
- a/Source/WebKit/GPUProcess/media/RemoteLegacyCDMProxy.h -1 / +1 lines
36	#include <wtf/WeakPtr.h>	36	#include <wtf/WeakPtr.h>
37		37
38	namespace WebCore {	38	namespace WebCore {
39	class SharedBuffer;	39	class FragmentedSharedBuffer;
40	}	40	}
41		41
42	namespace WebKit {	42	namespace WebKit {

Lines 37-43 a/Source/WebKit/GPUProcess/media/RemoteLegacyCDMSessionProxy.h_sec1
- a/Source/WebKit/GPUProcess/media/RemoteLegacyCDMSessionProxy.h -1 / +1 lines
37	namespace WebCore {	37	namespace WebCore {
38	class LegacyCDM;	38	class LegacyCDM;
39	class LegacyCDMSession;	39	class LegacyCDMSession;
40	class SharedBuffer;	40	class FragmentedSharedBuffer;
41	}	41	}
42		42
43	namespace IPC {	43	namespace IPC {

Lines 96-102 void RemoteMediaResource::dataSent(uint64_t bytesSent, uint64_t totalBytesToBeSe a/Source/WebKit/GPUProcess/media/RemoteMediaResource.cpp_sec1
- a/Source/WebKit/GPUProcess/media/RemoteMediaResource.cpp -1 / +1 lines
96	m_client->dataSent(*this, bytesSent, totalBytesToBeSent);	96	m_client->dataSent(*this, bytesSent, totalBytesToBeSent);
97	}	97	}
98		98
99	void RemoteMediaResource::dataReceived(Ref<SharedBuffer>&& data)	99	void RemoteMediaResource::dataReceived(Ref<FragmentedSharedBuffer>&& data)
100	{	100	{
101	if (m_client)	101	if (m_client)
102	m_client->dataReceived(*this, WTFMove(data));	102	m_client->dataReceived(*this, WTFMove(data));




namespace WebCore {
class NetworkLoadMetrics;
class FragmentedSharedBuffer;
}

namespace WebKit {

    void responseReceived(const WebCore::ResourceResponse&, bool, CompletionHandler<void(WebCore::ShouldContinuePolicyCheck)>&&);
    void redirectReceived(WebCore::ResourceRequest&&, const WebCore::ResourceResponse&, CompletionHandler<void(WebCore::ResourceRequest&&)>&&);
    void dataSent(uint64_t, uint64_t);
    void dataReceived(Ref<WebCore::FragmentedSharedBuffer>&&);
    void accessControlCheckFailed(const WebCore::ResourceError&);
    void loadFailed(const WebCore::ResourceError&);
    void loadFinished(const WebCore::NetworkLoadMetrics&);



void RemoteMediaRecorder::fetchData(CompletionHandler<void(IPC::DataReference&&, double)>&& completionHandler)
{
    m_writer->fetchData([completionHandler = WTFMove(completionHandler)](auto&& data, auto timeCode) mutable {
        auto buffer = data ? data->makeContiguous() : RefPtr<WebCore::SharedBuffer>();
        auto* pointer = buffer ? buffer->data() : nullptr;
        completionHandler(IPC::DataReference { pointer, data ? data->size() : 0 }, timeCode);
    });
}

Lines 68-74 private: a/Source/WebKit/NetworkProcess/Downloads/PendingDownload.h_sec1
- a/Source/WebKit/NetworkProcess/Downloads/PendingDownload.h -1 / +1 lines
68	bool isAllowedToAskUserForCredentials() const final { return m_isAllowedToAskUserForCredentials; }	68	bool isAllowedToAskUserForCredentials() const final { return m_isAllowedToAskUserForCredentials; }
69	void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) override;	69	void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) override;
70	void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) override;	70	void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) override;
71	void didReceiveBuffer(Ref<WebCore::SharedBuffer>&&, int reportedEncodedDataLength) override { };	71	void didReceiveBuffer(Ref<WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) override { };
72	void didFinishLoading(const WebCore::NetworkLoadMetrics&) override { };	72	void didFinishLoading(const WebCore::NetworkLoadMetrics&) override { };
73	void didFailLoading(const WebCore::ResourceError&) override;	73	void didFailLoading(const WebCore::ResourceError&) override;
74		74

Lines 119-125 void NetworkCORSPreflightChecker::didReceiveResponse(WebCore::ResourceResponse&& a/Source/WebKit/NetworkProcess/NetworkCORSPreflightChecker.cpp_sec1
- a/Source/WebKit/NetworkProcess/NetworkCORSPreflightChecker.cpp -1 / +1 lines
119	completionHandler(PolicyAction::Use);	119	completionHandler(PolicyAction::Use);
120	}	120	}
121		121
122	void NetworkCORSPreflightChecker::didReceiveData(Ref<WebCore::SharedBuffer>&&)	122	void NetworkCORSPreflightChecker::didReceiveData(Ref<WebCore::FragmentedSharedBuffer>&&)
123	{	123	{
124	CORS_CHECKER_RELEASE_LOG("didReceiveData");	124	CORS_CHECKER_RELEASE_LOG("didReceiveData");
125	}	125	}

Lines 71-77 private: a/Source/WebKit/NetworkProcess/NetworkCORSPreflightChecker.h_sec1
- a/Source/WebKit/NetworkProcess/NetworkCORSPreflightChecker.h -1 / +1 lines
71	void willPerformHTTPRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, RedirectCompletionHandler&&) final;	71	void willPerformHTTPRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, RedirectCompletionHandler&&) final;
72	void didReceiveChallenge(WebCore::AuthenticationChallenge&&, NegotiatedLegacyTLS, ChallengeCompletionHandler&&) final;	72	void didReceiveChallenge(WebCore::AuthenticationChallenge&&, NegotiatedLegacyTLS, ChallengeCompletionHandler&&) final;
73	void didReceiveResponse(WebCore::ResourceResponse&&, NegotiatedLegacyTLS, ResponseCompletionHandler&&) final;	73	void didReceiveResponse(WebCore::ResourceResponse&&, NegotiatedLegacyTLS, ResponseCompletionHandler&&) final;
74	void didReceiveData(Ref<WebCore::SharedBuffer>&&) final;	74	void didReceiveData(Ref<WebCore::FragmentedSharedBuffer>&&) final;
75	void didCompleteWithError(const WebCore::ResourceError&, const WebCore::NetworkLoadMetrics&) final;	75	void didCompleteWithError(const WebCore::ResourceError&, const WebCore::NetworkLoadMetrics&) final;
76	void didSendData(uint64_t totalBytesSent, uint64_t totalBytesExpectedToSend) final;	76	void didSendData(uint64_t totalBytesSent, uint64_t totalBytesExpectedToSend) final;
77	void wasBlocked() final;	77	void wasBlocked() final;



class AuthenticationChallenge;
class ResourceError;
class ResourceResponse;
class FragmentedSharedBuffer;
}

namespace WebKit {

    virtual void willPerformHTTPRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, RedirectCompletionHandler&&) = 0;
    virtual void didReceiveChallenge(WebCore::AuthenticationChallenge&&, NegotiatedLegacyTLS, ChallengeCompletionHandler&&) = 0;
    virtual void didReceiveResponse(WebCore::ResourceResponse&&, NegotiatedLegacyTLS, ResponseCompletionHandler&&) = 0;
    virtual void didReceiveData(Ref<WebCore::FragmentedSharedBuffer>&&) = 0;
    virtual void didCompleteWithError(const WebCore::ResourceError&, const WebCore::NetworkLoadMetrics&) = 0;
    virtual void didSendData(uint64_t totalBytesSent, uint64_t totalBytesExpectedToSend) = 0;
    virtual void wasBlocked() = 0;

Lines 256-262 void NetworkLoad::notifyDidReceiveResponse(ResourceResponse&& response, Negotiat a/Source/WebKit/NetworkProcess/NetworkLoad.cpp_sec1
- a/Source/WebKit/NetworkProcess/NetworkLoad.cpp -1 / +1 lines
256	m_client.get().didReceiveResponse(WTFMove(response), WTFMove(completionHandler));	256	m_client.get().didReceiveResponse(WTFMove(response), WTFMove(completionHandler));
257	}	257	}
258		258
259	void NetworkLoad::didReceiveData(Ref<SharedBuffer>&& buffer)	259	void NetworkLoad::didReceiveData(Ref<FragmentedSharedBuffer>&& buffer)
260	{	260	{
261	// FIXME: This should be the encoded data length, not the decoded data length.	261	// FIXME: This should be the encoded data length, not the decoded data length.
262	auto size = buffer->size();	262	auto size = buffer->size();

Lines 80-86 private: a/Source/WebKit/NetworkProcess/NetworkLoad.h_sec1
- a/Source/WebKit/NetworkProcess/NetworkLoad.h -1 / +1 lines
80	void willPerformHTTPRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, RedirectCompletionHandler&&) final;	80	void willPerformHTTPRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, RedirectCompletionHandler&&) final;
81	void didReceiveChallenge(WebCore::AuthenticationChallenge&&, NegotiatedLegacyTLS, ChallengeCompletionHandler&&) final;	81	void didReceiveChallenge(WebCore::AuthenticationChallenge&&, NegotiatedLegacyTLS, ChallengeCompletionHandler&&) final;
82	void didReceiveResponse(WebCore::ResourceResponse&&, NegotiatedLegacyTLS, ResponseCompletionHandler&&) final;	82	void didReceiveResponse(WebCore::ResourceResponse&&, NegotiatedLegacyTLS, ResponseCompletionHandler&&) final;
83	void didReceiveData(Ref<WebCore::SharedBuffer>&&) final;	83	void didReceiveData(Ref<WebCore::FragmentedSharedBuffer>&&) final;
84	void didCompleteWithError(const WebCore::ResourceError&, const WebCore::NetworkLoadMetrics&) final;	84	void didCompleteWithError(const WebCore::ResourceError&, const WebCore::NetworkLoadMetrics&) final;
85	void didSendData(uint64_t totalBytesSent, uint64_t totalBytesExpectedToSend) final;	85	void didSendData(uint64_t totalBytesSent, uint64_t totalBytesExpectedToSend) final;
86	void wasBlocked() final;	86	void wasBlocked() final;



namespace WebCore {
class AuthenticationChallenge;
class NetworkLoadMetrics;
class FragmentedSharedBuffer;
enum class PolicyAction : uint8_t;
}


    virtual void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent) = 0;
    virtual void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) = 0;
    virtual void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) = 0;
    virtual void didReceiveBuffer(Ref<WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) = 0;
    virtual void didFinishLoading(const WebCore::NetworkLoadMetrics&) = 0;
    virtual void didFailLoading(const WebCore::ResourceError&) = 0;
    virtual void didBlockAuthenticationChallenge() { };



    ResourceError error;
};

static void sendReplyToSynchronousRequest(NetworkResourceLoader::SynchronousLoadData& data, const FragmentedSharedBuffer* buffer, const NetworkLoadMetrics& metrics)
{
    ASSERT(data.delayedReply);
    ASSERT(!data.response.isNull() || !data.error.isNull());

    Vector<uint8_t> responseBuffer;
    if (buffer && buffer->size())
        responseBuffer.append(buffer->makeContiguous()->data(), buffer->size());

    data.response.setDeprecatedNetworkLoadMetrics(Box<NetworkLoadMetrics>::create(metrics));


NetworkResourceLoader::NetworkResourceLoader(NetworkResourceLoadParameters&& parameters, NetworkConnectionToWebProcess& connection, Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply&& synchronousReply)
    : m_parameters { WTFMove(parameters) }
    , m_connection { connection }
    , m_bufferedData { makeUniqueRef<SharedBufferBuilder>() }
    , m_fileReferences(connection.resolveBlobReferences(m_parameters))
    , m_isAllowedToAskUserForCredentials { m_parameters.clientCredentialPolicy == ClientCredentialPolicy::MayAskClientForCredentials }
    , m_bufferingTimer { *this, &NetworkResourceLoader::bufferingTimerFired }
    , m_bufferedDataForCache { makeUniqueRef<SharedBufferBuilder>() }
    , m_shouldCaptureExtraNetworkLoadMetrics(m_connection->captureExtraNetworkLoadMetricsEnabled())
    , m_resourceLoadID { NetworkResourceLoadIdentifier::generate() }
{

        consumeSandboxExtensions();

        if (isSynchronous() || m_parameters.maximumBufferingTime > 0_s)
            m_bufferedData->empty();

        if (canUseCache(request))
            m_bufferedDataForCache->empty();
    }

    NetworkLoadParameters parameters = m_parameters;

            || equalLettersIgnoringASCIICase(mimeType, "application/octet-stream");
    };

    if (m_bufferedData->isNull()
        && m_response.expectedContentLength() > static_cast<long long>(1 * MB)
        && isFetchOrXHR(resourceLoadInfo)
        && isMediaMIMEType(m_response.mimeType())) {
        m_bufferedData->empty();
        m_parameters.maximumBufferingTime = WebLoaderStrategy::mediaMaximumBufferingTime;
    }

    // For multipart/x-mixed-replace didReceiveResponseAsync gets called multiple times and buffering would require special handling.
    if (!isSynchronous() && m_response.isMultipart())
        m_bufferedData->reset();

    if (m_response.isMultipart())
        m_bufferedDataForCache->reset();

    if (m_cacheEntryForValidation) {
        bool validationSucceeded = m_response.httpStatusCode() == 304; // 304 Not Modified

    });
}

void NetworkResourceLoader::didReceiveBuffer(Ref<FragmentedSharedBuffer>&& buffer, int reportedEncodedDataLength)
{
    if (!m_numBytesReceived)
        LOADER_RELEASE_LOG("didReceiveBuffer: Started receiving data (reportedEncodedDataLength=%d)", reportedEncodedDataLength);


    ASSERT(!m_cacheEntryForValidation);

    if (!m_bufferedDataForCache->isNull()) {
        // Prevent memory growth in case of streaming data and limit size of entries in the cache.
        const size_t maximumCacheBufferSize = m_cache->capacity() / 8;
        if (m_bufferedDataForCache->size() + buffer->size() <= maximumCacheBufferSize)
            m_bufferedDataForCache->append(buffer.get());
        else
            m_bufferedDataForCache->reset();
    }
    if (isCrossOriginPrefetch())
        return;
    // FIXME: At least on OS X Yosemite we always get -1 from the resource handle.
    unsigned encodedDataLength = reportedEncodedDataLength >= 0 ? reportedEncodedDataLength : buffer->size();

    if (!m_bufferedData->isNull()) {
        m_bufferedData->append(buffer.get());
        m_bufferedDataEncodedDataLength += encodedDataLength;
        startBufferingTimerIfNeeded();

#endif

    if (isSynchronous())
        sendReplyToSynchronousRequest(*m_synchronousLoadData, m_bufferedData->get().get(), networkLoadMetrics);
    else {
        if (!m_bufferedData->isEmpty()) {
            // FIXME: Pass a real value or remove the encoded data size feature.
            sendBuffer(*m_bufferedData->get(), -1);
        }
        send(Messages::WebResourceLoader::DidFinishResourceLoad(networkLoadMetrics));
    }


void NetworkResourceLoader::bufferingTimerFired()
{
    ASSERT(!m_bufferedData->isNull());
    ASSERT(m_networkLoad);

    if (m_bufferedData->isEmpty())
        return;

    send(Messages::WebResourceLoader::DidReceiveData({ *m_bufferedData->get() }, m_bufferedDataEncodedDataLength));

    m_bufferedData->empty();
    m_bufferedDataEncodedDataLength = 0;
}

void NetworkResourceLoader::sendBuffer(FragmentedSharedBuffer& buffer, size_t encodedDataLength)
{
    ASSERT(!isSynchronous());


        LOADER_RELEASE_LOG("tryStoreAsCacheEntry: Not storing cache entry because request is not eligible");
        return;
    }
    if (m_bufferedDataForCache->isNull()) {
        LOADER_RELEASE_LOG("tryStoreAsCacheEntry: Not storing cache entry because m_bufferedDataForCache is null");
        return;
    }

    if (isCrossOriginPrefetch()) {
        if (auto* session = m_connection->networkProcess().networkSession(sessionID())) {
            LOADER_RELEASE_LOG("tryStoreAsCacheEntry: Storing entry in prefetch cache");
            session->prefetchCache().store(m_networkLoad->currentRequest().url(), WTFMove(m_response), m_bufferedDataForCache->take());
        }
        return;
    }
    LOADER_RELEASE_LOG("tryStoreAsCacheEntry: Storing entry in HTTP disk cache");
    m_cache->store(m_networkLoad->currentRequest(), m_response, m_bufferedDataForCache->take(), [loader = Ref { *this }](auto& mappedBody) mutable {
#if ENABLE(SHAREABLE_RESOURCE)
        if (mappedBody.shareableResourceHandle.isNull())
            return;

Lines 39-44 a/Source/WebKit/NetworkProcess/NetworkResourceLoader.h_sec1
- a/Source/WebKit/NetworkProcess/NetworkResourceLoader.h -4 / +7 lines
39	#include <WebCore/ResourceResponse.h>	39	#include <WebCore/ResourceResponse.h>
40	#include <WebCore/SecurityPolicyViolationEvent.h>	40	#include <WebCore/SecurityPolicyViolationEvent.h>
41	#include <WebCore/Timer.h>	41	#include <WebCore/Timer.h>
		42	#include <wtf/UniqueRef.h>
42	#include <wtf/WeakPtr.h>	43	#include <wtf/WeakPtr.h>
43		44
44	namespace WebCore {	45	namespace WebCore {
Lines 46-51 class BlobDataFileReference; a/Source/WebKit/NetworkProcess/NetworkResourceLoader.h_sec2
46	class FormData;	47	class FormData;
47	class NetworkStorageSession;	48	class NetworkStorageSession;
48	class ResourceRequest;	49	class ResourceRequest;
		50	class FragmentedSharedBuffer;
		51	class SharedBufferBuilder;
49	}	52	}
50		53
51	namespace WebKit {	54	namespace WebKit {
Lines 114-120 public: a/Source/WebKit/NetworkProcess/NetworkResourceLoader.h_sec3
114	bool isAllowedToAskUserForCredentials() const final { return m_isAllowedToAskUserForCredentials; }	117	bool isAllowedToAskUserForCredentials() const final { return m_isAllowedToAskUserForCredentials; }
115	void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&&) final;	118	void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&&) final;
116	void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) final;	119	void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) final;
117	void didReceiveBuffer(Ref<WebCore::SharedBuffer>&&, int reportedEncodedDataLength) final;	120	void didReceiveBuffer(Ref<WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) final;
118	void didFinishLoading(const WebCore::NetworkLoadMetrics&) final;	121	void didFinishLoading(const WebCore::NetworkLoadMetrics&) final;
119	void didFailLoading(const WebCore::ResourceError&) final;	122	void didFailLoading(const WebCore::ResourceError&) final;
120	void didBlockAuthenticationChallenge() final;	123	void didBlockAuthenticationChallenge() final;
Lines 192-198 private: a/Source/WebKit/NetworkProcess/NetworkResourceLoader.h_sec4
192		195
193	void startBufferingTimerIfNeeded();	196	void startBufferingTimerIfNeeded();
194	void bufferingTimerFired();	197	void bufferingTimerFired();
195	void sendBuffer(WebCore::SharedBuffer&, size_t encodedDataLength);	198	void sendBuffer(WebCore::FragmentedSharedBuffer&, size_t encodedDataLength);
196		199
197	void consumeSandboxExtensions();	200	void consumeSandboxExtensions();
198	void invalidateSandboxExtensions();	201	void invalidateSandboxExtensions();
Lines 225-231 private: a/Source/WebKit/NetworkProcess/NetworkResourceLoader.h_sec5
225	WebCore::ResourceResponse m_response;	228	WebCore::ResourceResponse m_response;
226		229
227	size_t m_bufferedDataEncodedDataLength { 0 };	230	size_t m_bufferedDataEncodedDataLength { 0 };
228	RefPtr<WebCore::SharedBuffer> m_bufferedData;	231	UniqueRef<WebCore::SharedBufferBuilder> m_bufferedData;
229	unsigned m_redirectCount { 0 };	232	unsigned m_redirectCount { 0 };
230		233
231	std::unique_ptr<SynchronousLoadData> m_synchronousLoadData;	234	std::unique_ptr<SynchronousLoadData> m_synchronousLoadData;
Lines 240-246 private: a/Source/WebKit/NetworkProcess/NetworkResourceLoader.h_sec6
240		243
241	WebCore::Timer m_bufferingTimer;	244	WebCore::Timer m_bufferingTimer;
242	RefPtr<NetworkCache::Cache> m_cache;	245	RefPtr<NetworkCache::Cache> m_cache;
243	RefPtr<WebCore::SharedBuffer> m_bufferedDataForCache;	246	UniqueRef<WebCore::SharedBufferBuilder> m_bufferedDataForCache;
244	std::unique_ptr<NetworkCache::Entry> m_cacheEntryForValidation;	247	std::unique_ptr<NetworkCache::Entry> m_cacheEntryForValidation;
245	std::unique_ptr<NetworkCache::Entry> m_cacheEntryForMaxAgeCapValidation;	248	std::unique_ptr<NetworkCache::Entry> m_cacheEntryForMaxAgeCapValidation;
246	bool m_isWaitingContinueWillSendRequestForCachedRedirect { false };	249	bool m_isWaitingContinueWillSendRequestForCachedRedirect { false };

Lines 172-178 void PingLoad::didReceiveResponse(ResourceResponse&& response, NegotiatedLegacyT a/Source/WebKit/NetworkProcess/PingLoad.cpp_sec1
- a/Source/WebKit/NetworkProcess/PingLoad.cpp -1 / +1 lines
172	didFinish({ }, response);	172	didFinish({ }, response);
173	}	173	}
174		174
175	void PingLoad::didReceiveData(Ref<SharedBuffer>&&)	175	void PingLoad::didReceiveData(Ref<FragmentedSharedBuffer>&&)
176	{	176	{
177	PING_RELEASE_LOG("didReceiveData");	177	PING_RELEASE_LOG("didReceiveData");
178	ASSERT_NOT_REACHED();	178	ASSERT_NOT_REACHED();

Lines 54-60 private: a/Source/WebKit/NetworkProcess/PingLoad.h_sec1
- a/Source/WebKit/NetworkProcess/PingLoad.h -1 / +1 lines
54	void willPerformHTTPRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, RedirectCompletionHandler&&) final;	54	void willPerformHTTPRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, RedirectCompletionHandler&&) final;
55	void didReceiveChallenge(WebCore::AuthenticationChallenge&&, NegotiatedLegacyTLS, ChallengeCompletionHandler&&) final;	55	void didReceiveChallenge(WebCore::AuthenticationChallenge&&, NegotiatedLegacyTLS, ChallengeCompletionHandler&&) final;
56	void didReceiveResponse(WebCore::ResourceResponse&&, NegotiatedLegacyTLS, ResponseCompletionHandler&&) final;	56	void didReceiveResponse(WebCore::ResourceResponse&&, NegotiatedLegacyTLS, ResponseCompletionHandler&&) final;
57	void didReceiveData(Ref<WebCore::SharedBuffer>&&) final;	57	void didReceiveData(Ref<WebCore::FragmentedSharedBuffer>&&) final;
58	void didCompleteWithError(const WebCore::ResourceError&, const WebCore::NetworkLoadMetrics&) final;	58	void didCompleteWithError(const WebCore::ResourceError&, const WebCore::NetworkLoadMetrics&) final;
59	void didSendData(uint64_t totalBytesSent, uint64_t totalBytesExpectedToSend) final;	59	void didSendData(uint64_t totalBytesSent, uint64_t totalBytesExpectedToSend) final;
60	void wasBlocked() final;	60	void wasBlocked() final;

Lines 79-85 void PreconnectTask::didReceiveResponse(ResourceResponse&& response, ResponseCom a/Source/WebKit/NetworkProcess/PreconnectTask.cpp_sec1
- a/Source/WebKit/NetworkProcess/PreconnectTask.cpp -1 / +1 lines
79	completionHandler(PolicyAction::Ignore);	79	completionHandler(PolicyAction::Ignore);
80	}	80	}
81		81
82	void PreconnectTask::didReceiveBuffer(Ref<SharedBuffer>&&, int reportedEncodedDataLength)	82	void PreconnectTask::didReceiveBuffer(Ref<FragmentedSharedBuffer>&&, int reportedEncodedDataLength)
83	{	83	{
84	ASSERT_NOT_REACHED();	84	ASSERT_NOT_REACHED();
85	}	85	}

Lines 55-61 private: a/Source/WebKit/NetworkProcess/PreconnectTask.h_sec1
- a/Source/WebKit/NetworkProcess/PreconnectTask.h -1 / +1 lines
55	void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent) final;	55	void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent) final;
56	void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) final;	56	void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) final;
57	void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) final;	57	void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) final;
58	void didReceiveBuffer(Ref<WebCore::SharedBuffer>&&, int reportedEncodedDataLength) final;	58	void didReceiveBuffer(Ref<WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) final;
59	void didFinishLoading(const WebCore::NetworkLoadMetrics&) final;	59	void didFinishLoading(const WebCore::NetworkLoadMetrics&) final;
60	void didFailLoading(const WebCore::ResourceError&) final;	60	void didFailLoading(const WebCore::ResourceError&) final;
61		61



        callback();
}

void ServiceWorkerNavigationPreloader::didReceiveBuffer(Ref<FragmentedSharedBuffer>&& buffer, int reportedEncodedDataLength)
{
    if (m_bodyCallback)
        m_bodyCallback(buffer->makeContiguous(), reportedEncodedDataLength);
}

void ServiceWorkerNavigationPreloader::didFinishLoading(const NetworkLoadMetrics& networkLoadMetrics)

Lines 67-73 private: a/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerNavigationPreloader.h_sec1
- a/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerNavigationPreloader.h -1 / +1 lines
67	bool isAllowedToAskUserForCredentials() const final { return false; }	67	bool isAllowedToAskUserForCredentials() const final { return false; }
68	void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) final;	68	void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) final;
69	void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) final;	69	void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) final;
70	void didReceiveBuffer(Ref<WebCore::SharedBuffer>&&, int reportedEncodedDataLength) final;	70	void didReceiveBuffer(Ref<WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) final;
71	void didFinishLoading(const WebCore::NetworkLoadMetrics&) final;	71	void didFinishLoading(const WebCore::NetworkLoadMetrics&) final;
72	void didFailLoading(const WebCore::ResourceError&) final;	72	void didFailLoading(const WebCore::ResourceError&) final;
73	bool shouldCaptureExtraNetworkLoadMetrics() const final { return m_shouldCaptureExtraNetworkLoadMetrics; }	73	bool shouldCaptureExtraNetworkLoadMetrics() const final { return m_shouldCaptureExtraNetworkLoadMetrics; }



    return { };
}

void ServiceWorkerSoftUpdateLoader::didReceiveBuffer(Ref<FragmentedSharedBuffer>&& buffer, int reportedEncodedDataLength)
{
    if (!m_decoder) {
        if (!m_responseEncoding.isEmpty())

    }

    if (auto size = buffer->size())
        m_script.append(m_decoder->decode(buffer->makeContiguous()->data(), size));
}

void ServiceWorkerSoftUpdateLoader::didFinishLoading(const WebCore::NetworkLoadMetrics&)

Lines 64-70 private: a/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerSoftUpdateLoader.h_sec1
- a/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerSoftUpdateLoader.h -1 / +1 lines
64	bool isAllowedToAskUserForCredentials() const final { return false; }	64	bool isAllowedToAskUserForCredentials() const final { return false; }
65	void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) final;	65	void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) final;
66	void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) final;	66	void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) final;
67	void didReceiveBuffer(Ref<WebCore::SharedBuffer>&&, int reportedEncodedDataLength) final;	67	void didReceiveBuffer(Ref<WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) final;
68	void didFinishLoading(const WebCore::NetworkLoadMetrics&) final;	68	void didFinishLoading(const WebCore::NetworkLoadMetrics&) final;
69	void didFailLoading(const WebCore::ResourceError&) final;	69	void didFailLoading(const WebCore::ResourceError&) final;
70		70



    handler(WTFMove(entry), info);
}
    
std::unique_ptr<Entry> Cache::makeEntry(const WebCore::ResourceRequest& request, const WebCore::ResourceResponse& response, RefPtr<WebCore::FragmentedSharedBuffer>&& responseData)
{
    return makeUnique<Entry>(makeCacheKey(request), response, WTFMove(responseData), WebCore::collectVaryingRequestHeaders(networkProcess().storageSession(m_sessionID), request, response));
}

    return makeUnique<Entry>(makeCacheKey(request), response, redirectRequest, WebCore::collectVaryingRequestHeaders(networkProcess().storageSession(m_sessionID), request, response));
}

std::unique_ptr<Entry> Cache::store(const WebCore::ResourceRequest& request, const WebCore::ResourceResponse& response, RefPtr<WebCore::FragmentedSharedBuffer>&& responseData, Function<void(MappedBody&)>&& completionHandler)
{
    ASSERT(responseData);




namespace WebCore {
class LowPowerModeNotifier;
class ResourceRequest;
class FragmentedSharedBuffer;
}

namespace WebKit {

    };
    using RetrieveCompletionHandler = Function<void(std::unique_ptr<Entry>, const RetrieveInfo&)>;
    void retrieve(const WebCore::ResourceRequest&, const GlobalFrameID&, std::optional<NavigatingToAppBoundDomain>, RetrieveCompletionHandler&&);
    std::unique_ptr<Entry> store(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, RefPtr<WebCore::FragmentedSharedBuffer>&&, Function<void(MappedBody&)>&& = nullptr);
    std::unique_ptr<Entry> storeRedirect(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, const WebCore::ResourceRequest& redirectRequest, std::optional<Seconds> maxAgeCap);
    std::unique_ptr<Entry> update(const WebCore::ResourceRequest&, const Entry&, const WebCore::ResourceResponse& validatingResponse);


    void retrieveData(const DataKey&, Function<void(const uint8_t*, size_t)>);
    void storeData(const DataKey&,  const uint8_t* data, size_t);
    
    std::unique_ptr<Entry> makeEntry(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, RefPtr<WebCore::FragmentedSharedBuffer>&&);
    std::unique_ptr<Entry> makeRedirectEntry(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, const WebCore::ResourceRequest& redirectRequest);

    void dumpContentsToFile();

Lines 37-43 a/Source/WebKit/NetworkProcess/cache/NetworkCacheEntry.cpp_sec1
- a/Source/WebKit/NetworkProcess/cache/NetworkCacheEntry.cpp -4 / +6 lines
37	namespace WebKit {	37	namespace WebKit {
38	namespace NetworkCache {	38	namespace NetworkCache {
39		39
40	Entry::Entry(const Key& key, const WebCore::ResourceResponse& response, RefPtr<WebCore::SharedBuffer>&& buffer, const Vector<std::pair<String, String>>& varyingRequestHeaders)	40	Entry::Entry(const Key& key, const WebCore::ResourceResponse& response, RefPtr<WebCore::FragmentedSharedBuffer>&& buffer, const Vector<std::pair<String, String>>& varyingRequestHeaders)
41	: m_key(key)	41	: m_key(key)
42	, m_timeStamp(WallTime::now())	42	, m_timeStamp(WallTime::now())
43	, m_response(response)	43	, m_response(response)
Lines 101-108 Storage::Record Entry::encodeAsStorageRecord() const a/Source/WebKit/NetworkProcess/cache/NetworkCacheEntry.cpp_sec2
101		101
102	Data header(encoder.buffer(), encoder.bufferSize());	102	Data header(encoder.buffer(), encoder.bufferSize());
103	Data body;	103	Data body;
104	if (m_buffer)	104	if (m_buffer) {
105	body = { m_buffer->data(), m_buffer->size() };	105	m_buffer = m_buffer->makeContiguous();
		106	body = { static_cast<WebCore::SharedBuffer*>(m_buffer.get())->data(), m_buffer->size() };
		107	}
106		108
107	return { m_key, m_timeStamp, header, body, { } };	109	return { m_key, m_timeStamp, header, body, { } };
108	}	110	}
Lines 194-200 void Entry::initializeBufferFromStorageRecord() const a/Source/WebKit/NetworkProcess/cache/NetworkCacheEntry.cpp_sec3
194	m_buffer = WebCore::SharedBuffer::create(m_sourceStorageRecord.body.data(), m_sourceStorageRecord.body.size());	196	m_buffer = WebCore::SharedBuffer::create(m_sourceStorageRecord.body.data(), m_sourceStorageRecord.body.size());
195	}	197	}
196		198
197	WebCore::SharedBuffer* Entry::buffer() const	199	WebCore::FragmentedSharedBuffer* Entry::buffer() const
198	{	200	{
199	if (!m_buffer)	201	if (!m_buffer)
200	initializeBufferFromStorageRecord();	202	initializeBufferFromStorageRecord();



#include <wtf/text/WTFString.h>

namespace WebCore {
class FragmentedSharedBuffer;
}

namespace WebKit {

class Entry {
    WTF_MAKE_FAST_ALLOCATED;
public:
    Entry(const Key&, const WebCore::ResourceResponse&, RefPtr<WebCore::FragmentedSharedBuffer>&&, const Vector<std::pair<String, String>>& varyingRequestHeaders);
    Entry(const Key&, const WebCore::ResourceResponse&, const WebCore::ResourceRequest& redirectRequest, const Vector<std::pair<String, String>>& varyingRequestHeaders);
    explicit Entry(const Storage::Record&);
    Entry(const Entry&);

    const WebCore::ResourceResponse& response() const { return m_response; }
    const Vector<std::pair<String, String>>& varyingRequestHeaders() const { return m_varyingRequestHeaders; }

    WebCore::FragmentedSharedBuffer* buffer() const;
    const std::optional<WebCore::ResourceRequest>& redirectRequest() const { return m_redirectRequest; }

#if ENABLE(SHAREABLE_RESOURCE)

    Vector<std::pair<String, String>> m_varyingRequestHeaders;

    std::optional<WebCore::ResourceRequest> m_redirectRequest;
    mutable RefPtr<WebCore::FragmentedSharedBuffer> m_buffer;
#if ENABLE(SHAREABLE_RESOURCE)
    mutable ShareableResource::Handle m_shareableResourceHandle;
#endif



    : m_cache(cache)
    , m_completionHandler(WTFMove(completionHandler))
    , m_originalRequest(request)
    , m_bufferedDataForCache(FragmentedSharedBuffer::create())
    , m_cacheEntry(WTFMove(cacheEntryForValidation))
{
    ASSERT(!m_cacheEntry || m_cacheEntry->needsValidation());

    m_response = receivedResponse;

    if (m_response.isMultipart())
        m_bufferedDataForCache.reset();

    bool validationSucceeded = m_response.httpStatusCode() == 304; // 304 Not Modified
    if (validationSucceeded && m_cacheEntry)

    completionHandler(PolicyAction::Use);
}

void SpeculativeLoad::didReceiveBuffer(Ref<FragmentedSharedBuffer>&& buffer, int reportedEncodedDataLength)
{
    ASSERT(!m_cacheEntry);

    if (m_bufferedDataForCache) {
        // Prevent memory growth in case of streaming data.
        const size_t maximumCacheBufferSize = 10 * 1024 * 1024;
        if (m_bufferedDataForCache.size() + buffer->size() <= maximumCacheBufferSize)
            m_bufferedDataForCache.append(buffer.get());
        else
            m_bufferedDataForCache.reset();
    }
}


    if (m_didComplete)
        return;
    if (!m_cacheEntry && m_bufferedDataForCache) {
        m_cacheEntry = m_cache->store(m_originalRequest, m_response, m_bufferedDataForCache.get(), [](auto& mappedBody) { });
        // Create a synthetic cache entry if we can't store.
        if (!m_cacheEntry && isStatusCodeCacheableByDefault(m_response.httpStatusCode()))
            m_cacheEntry = m_cache->makeEntry(m_originalRequest, m_response, m_bufferedDataForCache.take());
    }

    didComplete();



    bool isAllowedToAskUserForCredentials() const final { return false; }
    void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) override;
    void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) override;
    void didReceiveBuffer(Ref<WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) override;
    void didFinishLoading(const WebCore::NetworkLoadMetrics&) override;
    void didFailLoading(const WebCore::ResourceError&) override;



    WebCore::ResourceResponse m_response;

    WebCore::SharedBufferBuilder m_bufferedDataForCache;
    std::unique_ptr<NetworkCache::Entry> m_cacheEntry;
    bool m_didComplete { false };
};




namespace WebKit {

PrefetchCache::Entry::Entry(WebCore::ResourceResponse&& response, RefPtr<WebCore::FragmentedSharedBuffer>&& buffer)
    : response(WTFMove(response)), buffer(WTFMove(buffer))
{
}


static const Seconds expirationTimeout { 5_s };

void PrefetchCache::store(const URL& requestUrl, WebCore::ResourceResponse&& response, RefPtr<WebCore::FragmentedSharedBuffer>&& buffer)
{
    if (!m_sessionPrefetches)
        m_sessionPrefetches = makeUnique<PrefetchEntriesMap>();




    struct Entry {
        WTF_MAKE_STRUCT_FAST_ALLOCATED;
        Entry(WebCore::ResourceResponse&&, RefPtr<WebCore::FragmentedSharedBuffer>&&);
        Entry(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&);

        Ref<WebCore::FragmentedSharedBuffer> releaseBuffer() { return buffer.releaseNonNull(); }

        WebCore::ResourceResponse response;
        RefPtr<WebCore::FragmentedSharedBuffer> buffer;
        WebCore::ResourceRequest redirectRequest;
    };

    std::unique_ptr<Entry> take(const URL&);
    void store(const URL&, WebCore::ResourceResponse&&, RefPtr<WebCore::FragmentedSharedBuffer>&&);
    void storeRedirect(const URL&, WebCore::ResourceResponse&&, WebCore::ResourceRequest&&);

private:

Lines 62-68 public: a/Source/WebKit/NetworkProcess/cocoa/NetworkDataTaskCocoa.h_sec1
- a/Source/WebKit/NetworkProcess/cocoa/NetworkDataTaskCocoa.h -1 / +1 lines
62	void didNegotiateModernTLS(const URL&);	62	void didNegotiateModernTLS(const URL&);
63	void didCompleteWithError(const WebCore::ResourceError&, const WebCore::NetworkLoadMetrics&);	63	void didCompleteWithError(const WebCore::ResourceError&, const WebCore::NetworkLoadMetrics&);
64	void didReceiveResponse(WebCore::ResourceResponse&&, NegotiatedLegacyTLS, ResponseCompletionHandler&&);	64	void didReceiveResponse(WebCore::ResourceResponse&&, NegotiatedLegacyTLS, ResponseCompletionHandler&&);
65	void didReceiveData(Ref<WebCore::SharedBuffer>&&);	65	void didReceiveData(Ref<WebCore::FragmentedSharedBuffer>&&);
66		66
67	void willPerformHTTPRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, RedirectCompletionHandler&&);	67	void willPerformHTTPRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, RedirectCompletionHandler&&);
68	void transferSandboxExtensionToDownload(Download&);	68	void transferSandboxExtensionToDownload(Download&);

Lines 442-448 void NetworkDataTaskCocoa::didCompleteWithError(const WebCore::ResourceError& er a/Source/WebKit/NetworkProcess/cocoa/NetworkDataTaskCocoa.mm_sec1
- a/Source/WebKit/NetworkProcess/cocoa/NetworkDataTaskCocoa.mm -1 / +1 lines
442	m_client->didCompleteWithError(error, networkLoadMetrics);	442	m_client->didCompleteWithError(error, networkLoadMetrics);
443	}	443	}
444		444
445	void NetworkDataTaskCocoa::didReceiveData(Ref<WebCore::SharedBuffer>&& data)	445	void NetworkDataTaskCocoa::didReceiveData(Ref<WebCore::FragmentedSharedBuffer>&& data)
446	{	446	{
447	WTFEmitSignpost(m_task.get(), "DataTask", "received %zd bytes", data->size());	447	WTFEmitSignpost(m_task.get(), "DataTask", "received %zd bytes", data->size());
448		448

Lines 172-178 void NetworkDataTaskCurl::curlDidReceiveResponse(CurlRequest& request, CurlRespo a/Source/WebKit/NetworkProcess/curl/NetworkDataTaskCurl.cpp_sec1
- a/Source/WebKit/NetworkProcess/curl/NetworkDataTaskCurl.cpp -1 / +1 lines
172	invokeDidReceiveResponse();	172	invokeDidReceiveResponse();
173	}	173	}
174		174
175	void NetworkDataTaskCurl::curlDidReceiveBuffer(CurlRequest&, Ref<SharedBuffer>&& buffer)	175	void NetworkDataTaskCurl::curlDidReceiveBuffer(CurlRequest&, Ref<FragmentedSharedBuffer>&& buffer)
176	{	176	{
177	Ref protectedThis { *this };	177	Ref protectedThis { *this };
178	if (state() == State::Canceling \|\| state() == State::Completed \|\| (!m_client && !isDownload()))	178	if (state() == State::Canceling \|\| state() == State::Completed \|\| (!m_client && !isDownload()))

Lines 68-74 private: a/Source/WebKit/NetworkProcess/curl/NetworkDataTaskCurl.h_sec1
- a/Source/WebKit/NetworkProcess/curl/NetworkDataTaskCurl.h -1 / +1 lines
68	Ref<WebCore::CurlRequest> createCurlRequest(WebCore::ResourceRequest&&, RequestStatus = RequestStatus::NewRequest);	68	Ref<WebCore::CurlRequest> createCurlRequest(WebCore::ResourceRequest&&, RequestStatus = RequestStatus::NewRequest);
69	void curlDidSendData(WebCore::CurlRequest&, unsigned long long, unsigned long long) override;	69	void curlDidSendData(WebCore::CurlRequest&, unsigned long long, unsigned long long) override;
70	void curlDidReceiveResponse(WebCore::CurlRequest&, WebCore::CurlResponse&&) override;	70	void curlDidReceiveResponse(WebCore::CurlRequest&, WebCore::CurlResponse&&) override;
71	void curlDidReceiveBuffer(WebCore::CurlRequest&, Ref<WebCore::SharedBuffer>&&) override;	71	void curlDidReceiveBuffer(WebCore::CurlRequest&, Ref<WebCore::FragmentedSharedBuffer>&&) override;
72	void curlDidComplete(WebCore::CurlRequest&, WebCore::NetworkLoadMetrics&&) override;	72	void curlDidComplete(WebCore::CurlRequest&, WebCore::NetworkLoadMetrics&&) override;
73	void curlDidFailWithError(WebCore::CurlRequest&, WebCore::ResourceError&&, WebCore::CertificateInfo&&) override;	73	void curlDidFailWithError(WebCore::CurlRequest&, WebCore::ResourceError&&, WebCore::CertificateInfo&&) override;
74		74

Lines 55-61 struct PacketOptions; a/Source/WebKit/NetworkProcess/webrtc/NetworkRTCProvider.h_sec1
- a/Source/WebKit/NetworkProcess/webrtc/NetworkRTCProvider.h -1 / +1 lines
55		55
56	namespace WebCore {	56	namespace WebCore {
57	class RegistrableDomain;	57	class RegistrableDomain;
58	class SharedBuffer;	58	class FragmentedSharedBuffer;
59	}	59	}
60		60
61	namespace WebKit {	61	namespace WebKit {



 * THE POSSIBILITY OF SUCH DAMAGE.
 */

// Encodes a FragmentedSharedBuffer that is received as a copy of the decoded data in a new FragmentedSharedBuffer.
// To avoid copying from the Decoder, use SharedBufferDataReference to receive a DataReference instead.

#pragma once

        : m_buffer(WTFMove(buffer)) { }
    SharedBufferCopy(Ref<WebCore::SharedBuffer>&& buffer)
        : m_buffer(WTFMove(buffer)) { }
    SharedBufferCopy(RefPtr<WebCore::FragmentedSharedBuffer>&& buffer)
        : m_buffer(buffer ? buffer->makeContiguous() : RefPtr<WebCore::SharedBuffer>()) { }
    SharedBufferCopy(Ref<WebCore::FragmentedSharedBuffer>&& buffer)
        : m_buffer(buffer->makeContiguous()) { }
    SharedBufferCopy(const WebCore::FragmentedSharedBuffer& buffer)
        : m_buffer(buffer.makeContiguous()) { }

    RefPtr<WebCore::SharedBuffer>& buffer() { return m_buffer; }
    const RefPtr<WebCore::SharedBuffer>& buffer() const { return m_buffer; }

Lines 23-29 a/Source/WebKit/Platform/IPC/SharedBufferDataReference.h_sec1
- a/Source/WebKit/Platform/IPC/SharedBufferDataReference.h -1 / +1 lines
23	* THE POSSIBILITY OF SUCH DAMAGE.	23	* THE POSSIBILITY OF SUCH DAMAGE.
24	*/	24	*/
25		25
26	// Encodes a SharedBuffer or DataReference that is received as a DataReference to the decoded data.	26	// Encodes a FragmentedSharedBuffer or DataReference that is received as a DataReference to the decoded data.
27		27
28	#pragma once	28	#pragma once
29		29




using namespace WebCore;

RefPtr<SharedMemory> SharedMemory::copyBuffer(const FragmentedSharedBuffer& buffer)
{
    if (buffer.isEmpty())
        return nullptr;

Ref<SharedBuffer> SharedMemory::createSharedBuffer(size_t dataSize) const
{
    ASSERT(dataSize <= size());
    return SharedBuffer::create(DataSegment::Provider {
        [protectedThis = Ref { *this }] () -> const uint8_t* {
            return static_cast<const uint8_t*>(protectedThis->data());
        },




namespace WebCore {
class SharedBuffer;
class FragmentedSharedBuffer;
}

#if OS(DARWIN)


    // FIXME: Change these factory functions to return Ref<SharedMemory> and crash on failure.
    static RefPtr<SharedMemory> allocate(size_t);
    static RefPtr<SharedMemory> copyBuffer(const WebCore::FragmentedSharedBuffer&);
    static RefPtr<SharedMemory> map(const Handle&, Protection);
#if USE(UNIX_DOMAIN_SOCKETS)
    static RefPtr<SharedMemory> wrapMap(void*, size_t, int fileDescriptor);

Lines 68-74 static void releaseWebArchiveResourceData(unsigned char, const void data) a/Source/WebKit/Shared/APIWebArchiveResource.mm_sec1
- a/Source/WebKit/Shared/APIWebArchiveResource.mm -1 / +1 lines
68		68
69	Ref<API::Data> WebArchiveResource::data()	69	Ref<API::Data> WebArchiveResource::data()
70	{	70	{
71	RetainPtr<CFDataRef> cfData = m_archiveResource->data().createCFData();	71	RetainPtr<CFDataRef> cfData = m_archiveResource->data().makeContiguous()->createCFData();
72		72
73	// Balanced by CFRelease in releaseWebArchiveResourceData.	73	// Balanced by CFRelease in releaseWebArchiveResourceData.
74	CFRetain(cfData.get());	74	CFRetain(cfData.get());



        return std::nullopt;

    if (*includesCreationData) {
        std::optional<Ref<WebCore::FragmentedSharedBuffer>> fontFaceData;
        decoder >> fontFaceData;
        if (!fontFaceData)
            return std::nullopt;

        auto localFontFaceData = fontFaceData.value()->makeContiguous();
        auto localFontFaceData = WebCore::SharedBuffer::create(fontFaceData.value()->data(), fontFaceData.value()->size());

        std::optional<String> itemInCollection;
        decoder >> itemInCollection;

Lines 57-63 bool ShareableResource::Handle::decode(IPC::Decoder& decoder, Handle& handle) a/Source/WebKit/Shared/ShareableResource.cpp_sec1
- a/Source/WebKit/Shared/ShareableResource.cpp -1 / +1 lines
57		57
58	RefPtr<SharedBuffer> ShareableResource::wrapInSharedBuffer()	58	RefPtr<SharedBuffer> ShareableResource::wrapInSharedBuffer()
59	{	59	{
60	return SharedBuffer::create(SharedBuffer::DataSegment::Provider {	60	return SharedBuffer::create(DataSegment::Provider {
61	[self = Ref { *this }]() { return self->data(); },	61	[self = Ref { *this }]() { return self->data(); },
62	[self = Ref { *this }]() { return self->size(); }	62	[self = Ref { *this }]() { return self->size(); }
63	});	63	});




#undef DEFINE_SIMPLE_ARGUMENT_CODER_FOR_SOURCE

static void encodeSharedBuffer(Encoder& encoder, const FragmentedSharedBuffer* buffer)
{
    bool isNull = !buffer;
    encoder << isNull;

        return;

#if USE(UNIX_DOMAIN_SOCKETS)
    // Do not use shared memory for FragmentedSharedBuffer encoding in Unix, because it's easy to reach the
    // maximum number of file descriptors open per process when sending large data in small chunks
    // over the IPC. ConnectionUnix.cpp already uses shared memory to send any IPC message that is
    // too large. See https://bugs.webkit.org/show_bug.cgi?id=208571.

        RefPtr<SharedBuffer> buffer;
        if (!decodeSharedBuffer(decoder, buffer))
            return false;
        data.append(buffer);
    }

    return true;

    if (hasString)
        encoder << std::get<String>(platformData);

    bool hasBuffer = std::holds_alternative<Ref<FragmentedSharedBuffer>>(platformData);
    encoder << hasBuffer;
    if (hasBuffer)
        encodeSharedBuffer(encoder, std::get<Ref<FragmentedSharedBuffer>>(platformData).ptr());
}

bool ArgumentCoder<PasteboardCustomData::Entry>::decode(Decoder& decoder, PasteboardCustomData::Entry& data)

    if (!decoder.decode(data))
        return std::nullopt;

    return { { WTFMove(identifier), WTFMove(mimeType), WebCore::SharedBuffer::create(data.data(), data.size()) } };
}

#endif // ENABLE(ATTACHMENT_ELEMENT)

}
#endif

void ArgumentCoder<RefPtr<WebCore::FragmentedSharedBuffer>>::encode(Encoder& encoder, const RefPtr<WebCore::FragmentedSharedBuffer>& buffer)
{
    encodeSharedBuffer(encoder, buffer.get());
}

std::optional<RefPtr<FragmentedSharedBuffer>> ArgumentCoder<RefPtr<WebCore::FragmentedSharedBuffer>>::decode(Decoder& decoder)
{
    RefPtr<SharedBuffer> buffer;
    if (!decodeSharedBuffer(decoder, buffer))
        return std::nullopt;

    return buffer;
}

void ArgumentCoder<Ref<WebCore::FragmentedSharedBuffer>>::encode(Encoder& encoder, const Ref<WebCore::FragmentedSharedBuffer>& buffer)
{
    encodeSharedBuffer(encoder, buffer.ptr());
}

std::optional<Ref<FragmentedSharedBuffer>> ArgumentCoder<Ref<WebCore::FragmentedSharedBuffer>>::decode(Decoder& decoder)
{
    RefPtr<SharedBuffer> buffer;
    if (!decodeSharedBuffer(decoder, buffer) || !buffer)
        return std::nullopt;

    return buffer.releaseNonNull();
}

void ArgumentCoder<RefPtr<WebCore::SharedBuffer>>::encode(Encoder& encoder, const RefPtr<WebCore::SharedBuffer>& buffer)
{
    encodeSharedBuffer(encoder, buffer.get());

{
    encoder << message.first;

    RefPtr<FragmentedSharedBuffer> messageData = message.second.copyRef();
    encoder << messageData;
}


    if (!decoder.decode(type))
        return std::nullopt;

    RefPtr<FragmentedSharedBuffer> buffer;
    if (!decoder.decode(buffer) || !buffer)
        return std::nullopt;




class BlobPart;
class CertificateInfo;
class Color;
class SharedBuffer;
class Credential;
class CubicBezierTimingFunction;
class Cursor;

class ResourceResponse;
class ScriptBuffer;
class SecurityOrigin;
class FragmentedSharedBuffer;
class SpringTimingFunction;
class StepsTimingFunction;
class StickyPositionViewportConstraints;

};
#endif

template<> struct ArgumentCoder<RefPtr<WebCore::FragmentedSharedBuffer>> {
    static void encode(Encoder&, const RefPtr<WebCore::FragmentedSharedBuffer>&);
    static std::optional<RefPtr<WebCore::FragmentedSharedBuffer>> decode(Decoder&);
};

template<> struct ArgumentCoder<Ref<WebCore::FragmentedSharedBuffer>> {
    static void encode(Encoder&, const Ref<WebCore::FragmentedSharedBuffer>&);
    static std::optional<Ref<WebCore::FragmentedSharedBuffer>> decode(Decoder&);
};

template<> struct ArgumentCoder<RefPtr<WebCore::SharedBuffer>> {
    static void encode(Encoder&, const RefPtr<WebCore::SharedBuffer>&);
    static std::optional<RefPtr<WebCore::SharedBuffer>> decode(Decoder&);

Lines 85-91 WebHitTestResultData::WebHitTestResultData(const WebCore::HitTestResult& hitTest a/Source/WebKit/Shared/WebHitTestResultData.cpp_sec1
- a/Source/WebKit/Shared/WebHitTestResultData.cpp -1 / +1 lines
85	return;	85	return;
86		86
87	if (Image* image = hitTestResult.image()) {	87	if (Image* image = hitTestResult.image()) {
88	RefPtr<SharedBuffer> buffer = image->data();	88	RefPtr<FragmentedSharedBuffer> buffer = image->data();
89	if (buffer) {	89	if (buffer) {
90	imageSharedMemory = WebKit::SharedMemory::copyBuffer(*buffer);	90	imageSharedMemory = WebKit::SharedMemory::copyBuffer(*buffer);
91	imageSize = buffer->size();	91	imageSize = buffer->size();

Lines 95-101 void ArgumentCoder<SelectionData>::encode(Encoder& encoder, const SelectionData& a/Source/WebKit/Shared/gtk/ArgumentCodersGtk.cpp_sec1
- a/Source/WebKit/Shared/gtk/ArgumentCodersGtk.cpp -1 / +1 lines
95	bool hasCustomData = selection.hasCustomData();	95	bool hasCustomData = selection.hasCustomData();
96	encoder << hasCustomData;	96	encoder << hasCustomData;
97	if (hasCustomData)	97	if (hasCustomData)
98	encoder << RefPtr<SharedBuffer>(selection.customData());	98	encoder << RefPtr<FragmentedSharedBuffer>(selection.customData());
99		99
100	bool canSmartReplace = selection.canSmartReplace();	100	bool canSmartReplace = selection.canSmartReplace();
101	encoder << canSmartReplace;	101	encoder << canSmartReplace;

Lines 98-104 std::optional<uint64_t> Attachment::fileSizeForDisplay() const a/Source/WebKit/UIProcess/API/APIAttachment.cpp_sec1
- a/Source/WebKit/UIProcess/API/APIAttachment.cpp -1 / +1 lines
98	return std::nullopt;	98	return std::nullopt;
99	}	99	}
100		100
101	RefPtr<WebCore::SharedBuffer> Attachment::enclosingImageData() const	101	RefPtr<WebCore::FragmentedSharedBuffer> Attachment::enclosingImageData() const
102	{	102	{
103	return nullptr;	103	return nullptr;
104	}	104	}




namespace WebCore {
class SharedBuffer;
class FragmentedSharedBuffer;
}

namespace WebKit {


    bool isEmpty() const;

    RefPtr<WebCore::FragmentedSharedBuffer> enclosingImageData() const;
    std::optional<uint64_t> fileSizeForDisplay() const;

    void setHasEnclosingImage(bool hasEnclosingImage) { m_hasEnclosingImage = hasEnclosingImage; }

Lines 30-36 a/Source/WebKit/UIProcess/API/APIContentRuleListStore.h_sec1
- a/Source/WebKit/UIProcess/API/APIContentRuleListStore.h -1 / +1 lines
30	#include <wtf/text/WTFString.h>	30	#include <wtf/text/WTFString.h>
31		31
32	namespace WebCore {	32	namespace WebCore {
33	class SharedBuffer;	33	class FragmentedSharedBuffer;
34	}	34	}
35		35
36	namespace WTF {	36	namespace WTF {



class ResourceError;
class ResourceRequest;
class ResourceResponse;
class FragmentedSharedBuffer;
struct SecurityOriginData;
}



#if USE(QUICK_LOOK)
    virtual void didStartLoadForQuickLookDocumentInMainFrame(const WTF::String& fileName, const WTF::String& uti) { }
    virtual void didFinishLoadForQuickLookDocumentInMainFrame(const WebCore::FragmentedSharedBuffer&) { }
#endif

    virtual void decidePolicyForNavigationAction(WebKit::WebPageProxy&, Ref<NavigationAction>&&, Ref<WebKit::WebFramePolicyListenerProxy>&& listener, Object*)

Lines 137-143 std::optional<uint64_t> Attachment::fileSizeForDisplay() const a/Source/WebKit/UIProcess/API/Cocoa/APIAttachmentCocoa.mm_sec1
- a/Source/WebKit/UIProcess/API/Cocoa/APIAttachmentCocoa.mm -1 / +1 lines
137	return [fileWrapper regularFileContents].length;	137	return [fileWrapper regularFileContents].length;
138	}	138	}
139		139
140	RefPtr<WebCore::SharedBuffer> Attachment::enclosingImageData() const	140	RefPtr<WebCore::FragmentedSharedBuffer> Attachment::enclosingImageData() const
141	{	141	{
142	if (!m_hasEnclosingImage)	142	if (!m_hasEnclosingImage)
143	return nullptr;	143	return nullptr;

Lines 1596-1602 - (void)_storeAppHighlight:(const WebCore::AppHighlight&)highlight a/Source/WebKit/UIProcess/API/Cocoa/WKWebView.mm_sec1
- a/Source/WebKit/UIProcess/API/Cocoa/WKWebView.mm -1 / +1 lines
1596	if (highlight.text)	1596	if (highlight.text)
1597	text = highlight.text.value();	1597	text = highlight.text.value();
1598		1598
1599	auto wkHighlight = adoptNS([[_WKAppHighlight alloc] initWithHighlight:highlight.highlight->createNSData().get() text:text image:nil]);	1599	auto wkHighlight = adoptNS([[_WKAppHighlight alloc] initWithHighlight:highlight.highlight->makeContiguous()->createNSData().get() text:text image:nil]);
1600		1600
1601	if ([delegate respondsToSelector:@selector(_webView:storeAppHighlight:inNewGroup:requestOriginatedInApp:)])	1601	if ([delegate respondsToSelector:@selector(_webView:storeAppHighlight:inNewGroup:requestOriginatedInApp:)])
1602	[delegate _webView:self storeAppHighlight:wkHighlight.get() inNewGroup:highlight.isNewGroup == WebCore::CreateNewGroupForHighlight::Yes requestOriginatedInApp:highlight.requestOriginatedInApp == WebCore::HighlightRequestOriginatedInApp::Yes];	1602	[delegate _webView:self storeAppHighlight:wkHighlight.get() inNewGroup:highlight.isNewGroup == WebCore::CreateNewGroupForHighlight::Yes requestOriginatedInApp:highlight.requestOriginatedInApp == WebCore::HighlightRequestOriginatedInApp::Yes];

Lines 133-139 private: a/Source/WebKit/UIProcess/Cocoa/NavigationState.h_sec1
- a/Source/WebKit/UIProcess/Cocoa/NavigationState.h -1 / +1 lines
133		133
134	#if USE(QUICK_LOOK)	134	#if USE(QUICK_LOOK)
135	void didStartLoadForQuickLookDocumentInMainFrame(const WTF::String& fileName, const WTF::String& uti) override;	135	void didStartLoadForQuickLookDocumentInMainFrame(const WTF::String& fileName, const WTF::String& uti) override;
136	void didFinishLoadForQuickLookDocumentInMainFrame(const WebCore::SharedBuffer&) override;	136	void didFinishLoadForQuickLookDocumentInMainFrame(const WebCore::FragmentedSharedBuffer&) override;
137	#endif	137	#endif
138		138
139	#if PLATFORM(MAC)	139	#if PLATFORM(MAC)



    [static_cast<id <WKNavigationDelegatePrivate>>(navigationDelegate.get()) _webView:m_navigationState->m_webView didStartLoadForQuickLookDocumentInMainFrameWithFileName:fileName uti:uti];
}

void NavigationState::NavigationClient::didFinishLoadForQuickLookDocumentInMainFrame(const FragmentedSharedBuffer& buffer)
{
    if (!m_navigationState)
        return;

    if (!navigationDelegate)
        return;

    [static_cast<id <WKNavigationDelegatePrivate>>(navigationDelegate.get()) _webView:m_navigationState->m_webView didFinishLoadForQuickLookDocumentInMainFrame:buffer.makeContiguous()->createNSData().get()];
}
#endif




        if (noErr != AudioComponentFetchServerRegistrations(&registrations) || !registrations)
            return;

        RunLoop::main().dispatch([weakThis = WTFMove(weakThis), registrations = adoptCF(registrations)] () {
            if (!weakThis)
                return;

            auto registrationData = WebCore::SharedBuffer::create(registrations.get());
            weakThis->send(Messages::WebProcess::ConsumeAudioComponentRegistrations({ WTFMove(registrationData) }), 0);
        });
    });
}

Lines 506-512 public: a/Source/WebKit/UIProcess/Cocoa/WebViewImpl.h_sec1
- a/Source/WebKit/UIProcess/Cocoa/WebViewImpl.h -1 / +1 lines
506		506
507	void startDrag(const WebCore::DragItem&, const ShareableBitmap::Handle& image);	507	void startDrag(const WebCore::DragItem&, const ShareableBitmap::Handle& image);
508	void setFileAndURLTypes(NSString filename, NSString extension, NSString title, NSString url, NSString visibleURL, NSPasteboard );	508	void setFileAndURLTypes(NSString filename, NSString extension, NSString title, NSString url, NSString visibleURL, NSPasteboard );
509	void setPromisedDataForImage(WebCore::Image, NSString filename, NSString extension, NSString title, NSString url, NSString visibleURL, WebCore::SharedBuffer* archiveBuffer, NSString pasteboardName, NSString pasteboardOrigin);	509	void setPromisedDataForImage(WebCore::Image, NSString filename, NSString extension, NSString title, NSString url, NSString visibleURL, WebCore::FragmentedSharedBuffer* archiveBuffer, NSString pasteboardName, NSString pasteboardOrigin);
510	void pasteboardChangedOwner(NSPasteboard *);	510	void pasteboardChangedOwner(NSPasteboard *);
511	void provideDataForPasteboard(NSPasteboard , NSString type);	511	void provideDataForPasteboard(NSPasteboard , NSString type);
512	NSArray namesOfPromisedFilesDroppedAtDestination(NSURL dropDestination);	512	NSArray namesOfPromisedFilesDroppedAtDestination(NSURL dropDestination);



    m_promisedURL = url;
}

void WebViewImpl::setPromisedDataForImage(WebCore::Image* image, NSString *filename, NSString *extension, NSString *title, NSString *url, NSString *visibleURL, WebCore::FragmentedSharedBuffer* archiveBuffer, NSString *pasteboardName, NSString *originIdentifier)
{
    NSPasteboard *pasteboard = [NSPasteboard pasteboardWithName:pasteboardName];
    RetainPtr<NSMutableArray> types = adoptNS([[NSMutableArray alloc] initWithObjects:WebCore::legacyFilesPromisePasteboardType(), nil]);

    setFileAndURLTypes(filename, extension, title, url, visibleURL, pasteboard);

    if (archiveBuffer) {
        auto nsData = archiveBuffer->makeContiguous()->createNSData();
ALLOW_DEPRECATED_DECLARATIONS_BEGIN
        [pasteboard setData:nsData.get() forType:(__bridge NSString *)kUTTypeWebArchive];
ALLOW_DEPRECATED_DECLARATIONS_END

        return;

    if ([type isEqual:m_promisedImage->uti()] && m_promisedImage->data()) {
        if (auto platformData = m_promisedImage->data()->makeContiguous()->createNSData())
            [pasteboard setData:(__bridge NSData *)platformData.get() forType:type];
    }


    RetainPtr<NSData> data;

    if (m_promisedImage) {
        data = m_promisedImage->data()->makeContiguous()->createNSData();
        wrapper = adoptNS([[NSFileWrapper alloc] initRegularFileWithContents:data.get()]);
    } else
        wrapper = adoptNS([[NSFileWrapper alloc] initWithURL:[NSURL URLWithString:m_promisedURL] options:NSFileWrapperReadingImmediate error:nil]);

Lines 328-334 public: a/Source/WebKit/UIProcess/PageClient.h_sec1
- a/Source/WebKit/UIProcess/PageClient.h -1 / +1 lines
328	#endif	328	#endif
329		329
330	#if USE(APPKIT)	330	#if USE(APPKIT)
331	virtual void setPromisedDataForImage(const String& pasteboardName, Ref<WebCore::SharedBuffer>&& imageBuffer, const String& filename, const String& extension, const String& title, const String& url, const String& visibleURL, RefPtr<WebCore::SharedBuffer>&& archiveBuffer, const String& originIdentifier) = 0;	331	virtual void setPromisedDataForImage(const String& pasteboardName, Ref<WebCore::FragmentedSharedBuffer>&& imageBuffer, const String& filename, const String& extension, const String& title, const String& url, const String& visibleURL, RefPtr<WebCore::FragmentedSharedBuffer>&& archiveBuffer, const String& originIdentifier) = 0;
332	#endif	332	#endif
333		333
334	virtual WebCore::FloatRect convertToDeviceSpace(const WebCore::FloatRect&) = 0;	334	virtual WebCore::FloatRect convertToDeviceSpace(const WebCore::FloatRect&) = 0;

Lines 259-265 class IntSize; a/Source/WebKit/UIProcess/WebPageProxy.h_sec1
- a/Source/WebKit/UIProcess/WebPageProxy.h -1 / +1 lines
259	class ProtectionSpace;	259	class ProtectionSpace;
260	class RunLoopObserver;	260	class RunLoopObserver;
261	class SelectionData;	261	class SelectionData;
262	class SharedBuffer;	262	class FragmentedSharedBuffer;
263	class SpeechRecognitionRequest;	263	class SpeechRecognitionRequest;
264	class TextIndicator;	264	class TextIndicator;
265	class ValidationBubble;	265	class ValidationBubble;



    , m_request(WTFMove(parameters.request))
    , m_frameInfo(API::FrameInfo::create(WTFMove(parameters.frameInfo), &page))
    , m_syncCompletionHandler(WTFMove(syncCompletionHandler))
    , m_syncData(makeUniqueRef<SharedBufferBuilder>())
{
    ASSERT(RunLoop::isMain());
}

    return ExceptionType::None;
}

auto WebURLSchemeTask::didReceiveData(Ref<FragmentedSharedBuffer>&& buffer) -> ExceptionType
{
    ASSERT(RunLoop::isMain());


    m_dataSent = true;

    if (isSync()) {
        m_syncData->append(WTFMove(buffer));
            m_syncData->append(WTFMove(buffer));
        else
            m_syncData = WTFMove(buffer);
        return ExceptionType::None;
    }


    m_completed = true;
    
    if (isSync()) {
        size_t size = m_syncData->size();
        Vector<uint8_t> data = { m_syncData->take()->makeContiguous()->data(), size };
            data = { m_syncData->data(), m_syncData->size() };

        m_syncCompletionHandler(m_syncResponse, error, WTFMove(data));
        m_syncData = nullptr;
    }

    m_process->send(Messages::WebPage::URLSchemeTaskDidComplete(m_urlSchemeHandler->identifier(), m_resourceLoaderID, error), m_webPageID);



#include <wtf/Lock.h>
#include <wtf/RefCounted.h>
#include <wtf/RefPtr.h>
#include <wtf/UniqueRef.h>

namespace API {
class FrameInfo;

namespace WebCore {
class ResourceError;
class ResourceResponse;
class FragmentedSharedBuffer;
class SharedBufferBuilder;
}

namespace WebKit {

    ExceptionType willPerformRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&,  Function<void(WebCore::ResourceRequest&&)>&&);
    ExceptionType didPerformRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&);
    ExceptionType didReceiveResponse(const WebCore::ResourceResponse&);
    ExceptionType didReceiveData(Ref<WebCore::FragmentedSharedBuffer>&&);
    ExceptionType didComplete(const WebCore::ResourceError&);

    void stop();


    SyncLoadCompletionHandler m_syncCompletionHandler;
    WebCore::ResourceResponse m_syncResponse;
    UniqueRef<WebCore::SharedBufferBuilder> m_syncData;

    bool m_waitingForRedirectCompletionHandlerCallback { false };
};




namespace WebCore {
class SelectionData;
class FragmentedSharedBuffer;
}

namespace WebKit {

    void formats(CompletionHandler<void(Vector<String>&&)>&&);
    void readText(CompletionHandler<void(String&&)>&&);
    void readFilePaths(CompletionHandler<void(Vector<String>&&)>&&);
    void readBuffer(const char*, CompletionHandler<void(Ref<WebCore::FragmentedSharedBuffer>&&)>&&);
    void write(WebCore::SelectionData&&);
    void clear();




struct ReadBufferAsyncData {
    WTF_MAKE_STRUCT_FAST_ALLOCATED;

    explicit ReadBufferAsyncData(CompletionHandler<void(Ref<WebCore::FragmentedSharedBuffer>&&)>&& handler)
        : completionHandler(WTFMove(handler))
    {
    }

    CompletionHandler<void(Ref<WebCore::FragmentedSharedBuffer>&&)> completionHandler;
};

void Clipboard::readBuffer(const char* format, CompletionHandler<void(Ref<WebCore::FragmentedSharedBuffer>&&)>&& completionHandler)
{
    gtk_clipboard_request_contents(m_clipboard, gdk_atom_intern(format, TRUE), [](GtkClipboard*, GtkSelectionData* selection, gpointer userData) {
        std::unique_ptr<ReadBufferAsyncData> data(static_cast<ReadBufferAsyncData*>(userData));



struct ReadBufferAsyncData {
    WTF_MAKE_STRUCT_FAST_ALLOCATED;

    explicit ReadBufferAsyncData(CompletionHandler<void(Ref<WebCore::FragmentedSharedBuffer>&&)>&& handler)
        : completionHandler(WTFMove(handler))
    {
    }

    CompletionHandler<void(Ref<WebCore::FragmentedSharedBuffer>&&)> completionHandler;
};

void Clipboard::readBuffer(const char* format, CompletionHandler<void(Ref<WebCore::FragmentedSharedBuffer>&&)>&& completionHandler)
{
    const char* mimeTypes[] = { format, nullptr };
    gdk_clipboard_read_async(m_clipboard, mimeTypes, G_PRIORITY_DEFAULT, nullptr, [](GObject* clipboard, GAsyncResult* result, gpointer userData) {



    void executeUndoRedo(UndoOrRedo) override;
    bool executeSavedCommandBySelector(const String& selector) override;
    void startDrag(const WebCore::DragItem&, const ShareableBitmap::Handle& image) override;
    void setPromisedDataForImage(const String& pasteboardName, Ref<WebCore::FragmentedSharedBuffer>&& imageBuffer, const String& filename, const String& extension, const String& title,
        const String& url, const String& visibleURL, RefPtr<WebCore::FragmentedSharedBuffer>&& archiveBuffer, const String& originIdentifier) override;
    void updateSecureInputState() override;
    void resetSecureInputState() override;
    void notifyInputContextAboutDiscardedComposition() override;

Lines 400-406 void PageClientImpl::startDrag(const WebCore::DragItem& item, const ShareableBit a/Source/WebKit/UIProcess/mac/PageClientImplMac.mm_sec1
- a/Source/WebKit/UIProcess/mac/PageClientImplMac.mm -1 / +1 lines
400	m_impl->startDrag(item, image);	400	m_impl->startDrag(item, image);
401	}	401	}
402		402
403	void PageClientImpl::setPromisedDataForImage(const String& pasteboardName, Ref<SharedBuffer>&& imageBuffer, const String& filename, const String& extension, const String& title, const String& url, const String& visibleURL, RefPtr<SharedBuffer>&& archiveBuffer, const String& originIdentifier)	403	void PageClientImpl::setPromisedDataForImage(const String& pasteboardName, Ref<FragmentedSharedBuffer>&& imageBuffer, const String& filename, const String& extension, const String& title, const String& url, const String& visibleURL, RefPtr<FragmentedSharedBuffer>&& archiveBuffer, const String& originIdentifier)
404	{	404	{
405	auto image = BitmapImage::create();	405	auto image = BitmapImage::create();
406	image->setData(WTFMove(imageBuffer), true);	406	image->setData(WTFMove(imageBuffer), true);

Lines 277-283 void WebPageProxy::setPromisedDataForImage(const String& pasteboardName, const S a/Source/WebKit/UIProcess/mac/WebPageProxyMac.mm_sec1
- a/Source/WebKit/UIProcess/mac/WebPageProxyMac.mm -1 / +1 lines
277	return;	277	return;
278	auto imageBuffer = sharedMemoryImage->createSharedBuffer(imageHandle.dataSize);	278	auto imageBuffer = sharedMemoryImage->createSharedBuffer(imageHandle.dataSize);
279		279
280	RefPtr<SharedBuffer> archiveBuffer;	280	RefPtr<FragmentedSharedBuffer> archiveBuffer;
281	if (!archiveHandle.handle.isNull()) {	281	if (!archiveHandle.handle.isNull()) {
282	auto sharedMemoryArchive = SharedMemory::map(archiveHandle.handle, SharedMemory::Protection::ReadOnly);	282	auto sharedMemoryArchive = SharedMemory::map(archiveHandle.handle, SharedMemory::Protection::ReadOnly);
283	if (!sharedMemoryArchive)	283	if (!sharedMemoryArchive)



    return false;
}

bool RemoteCDM::supportsInitData(const AtomString& type, const FragmentedSharedBuffer& data) const
{
    // This check will be done, later, inside RemoteCDMInstanceSessionProxy::requestLicense().
    return true;

    m_factory->gpuProcessConnection().connection().send(Messages::RemoteCDMProxy::LoadAndInitialize(), m_identifier);
}

RefPtr<FragmentedSharedBuffer> RemoteCDM::sanitizeResponse(const FragmentedSharedBuffer& response) const
{
    // This check will be done, later, inside RemoteCDMInstanceSessionProxy::updateLicense().
    return response.copy();



    bool supportsConfiguration(const WebCore::CDMKeySystemConfiguration&) const final;
    bool supportsConfigurationWithRestrictions(const WebCore::CDMKeySystemConfiguration&, const WebCore::CDMRestrictions&) const final;
    bool supportsSessionTypeWithConfiguration(const WebCore::CDMSessionType&, const WebCore::CDMKeySystemConfiguration&) const final;
    bool supportsInitData(const AtomString&, const WebCore::FragmentedSharedBuffer&) const final;
    WebCore::CDMRequirement distinctiveIdentifiersRequirement(const WebCore::CDMKeySystemConfiguration&, const WebCore::CDMRestrictions&) const final;
    WebCore::CDMRequirement persistentStateRequirement(const WebCore::CDMKeySystemConfiguration&, const WebCore::CDMRestrictions&) const final;
    bool distinctiveIdentifiersAreUniquePerOriginAndClearable(const WebCore::CDMKeySystemConfiguration&) const final;
    RefPtr<WebCore::CDMInstance> createInstance() final;
    void loadAndInitialize() final;
    RefPtr<WebCore::FragmentedSharedBuffer> sanitizeResponse(const WebCore::FragmentedSharedBuffer&) const final;
    std::optional<String> sanitizeSessionId(const String&) const final;

    Vector<AtomString> supportedInitDataTypes() const final { return m_configuration.supportedInitDataTypes; }

Lines 78-84 void RemoteCDMInstance::initializeWithConfiguration(const WebCore::CDMKeySystemC a/Source/WebKit/WebProcess/GPU/media/RemoteCDMInstance.cpp_sec1
- a/Source/WebKit/WebProcess/GPU/media/RemoteCDMInstance.cpp -1 / +1 lines
78	m_factory->gpuProcessConnection().connection().sendWithAsyncReply(Messages::RemoteCDMInstanceProxy::InitializeWithConfiguration(configuration, distinctiveIdentifiers, persistentState), WTFMove(callback), m_identifier);	78	m_factory->gpuProcessConnection().connection().sendWithAsyncReply(Messages::RemoteCDMInstanceProxy::InitializeWithConfiguration(configuration, distinctiveIdentifiers, persistentState), WTFMove(callback), m_identifier);
79	}	79	}
80		80
81	void RemoteCDMInstance::setServerCertificate(Ref<WebCore::SharedBuffer>&& certificate, SuccessCallback&& callback)	81	void RemoteCDMInstance::setServerCertificate(Ref<WebCore::FragmentedSharedBuffer>&& certificate, SuccessCallback&& callback)
82	{	82	{
83	if (!m_factory) {	83	if (!m_factory) {
84	callback(Failed);	84	callback(Failed);

Lines 54-60 private: a/Source/WebKit/WebProcess/GPU/media/RemoteCDMInstance.h_sec1
- a/Source/WebKit/WebProcess/GPU/media/RemoteCDMInstance.h -1 / +1 lines
54		54
55	ImplementationType implementationType() const final { return ImplementationType::Remote; }	55	ImplementationType implementationType() const final { return ImplementationType::Remote; }
56	void initializeWithConfiguration(const WebCore::CDMKeySystemConfiguration&, AllowDistinctiveIdentifiers, AllowPersistentState, SuccessCallback&&) final;	56	void initializeWithConfiguration(const WebCore::CDMKeySystemConfiguration&, AllowDistinctiveIdentifiers, AllowPersistentState, SuccessCallback&&) final;
57	void setServerCertificate(Ref<WebCore::SharedBuffer>&&, SuccessCallback&&) final;	57	void setServerCertificate(Ref<WebCore::FragmentedSharedBuffer>&&, SuccessCallback&&) final;
58	void setStorageDirectory(const String&) final;	58	void setStorageDirectory(const String&) final;
59	const String& keySystem() const final { return m_configuration.keySystem; }	59	const String& keySystem() const final { return m_configuration.keySystem; }
60	RefPtr<WebCore::CDMInstanceSession> createSession() final;	60	RefPtr<WebCore::CDMInstanceSession> createSession() final;



{
}

void RemoteCDMInstanceSession::requestLicense(LicenseType type, const AtomString& initDataType, Ref<FragmentedSharedBuffer>&& initData, LicenseCallback&& callback)
{
    if (!m_factory) {
        callback(SharedBuffer::create(), emptyString(), false, Failed);

    }, m_identifier);
}

void RemoteCDMInstanceSession::updateLicense(const String& sessionId, LicenseType type, Ref<FragmentedSharedBuffer>&& response, LicenseUpdateCallback&& callback)
{
    if (!m_factory) {
        callback(false, std::nullopt, std::nullopt, std::nullopt, Failed);

    }

    m_factory->gpuProcessConnection().connection().sendWithAsyncReply(Messages::RemoteCDMInstanceSessionProxy::RemoveSessionData(sessionId, type), [callback = WTFMove(callback)] (KeyStatusVector&& changedKeys, std::optional<IPC::SharedBufferCopy>&& message, bool succeeded) mutable {
        std::optional<Ref<FragmentedSharedBuffer>> realMessage = std::nullopt;
        if (message && message.value().buffer())
            realMessage = message.value().buffer().releaseNonNull();
        callback(WTFMove(changedKeys), WTFMove(realMessage), succeeded ? Succeeded : Failed);




    void setClient(WeakPtr<WebCore::CDMInstanceSessionClient>&& client) final { m_client = WTFMove(client); }
    void clearClient() final { m_client = nullptr; }
    void requestLicense(LicenseType, const AtomString& initDataType, Ref<WebCore::FragmentedSharedBuffer>&& initData, LicenseCallback&&) final;
    void updateLicense(const String& sessionId, LicenseType, Ref<WebCore::FragmentedSharedBuffer>&& response, LicenseUpdateCallback&&) final;
    void loadSession(LicenseType, const String& sessionId, const String& origin, LoadSessionCallback&&) final;
    void closeSession(const String& sessionId, CloseSessionCallback&&) final;
    void removeSessionData(const String& sessionId, LicenseType, RemoveSessionDataCallback&&) final;

Lines 200-206 void RemoteImageDecoderAVF::setExpectedContentSize(long long expectedContentSize a/Source/WebKit/WebProcess/GPU/media/RemoteImageDecoderAVF.cpp_sec1
- a/Source/WebKit/WebProcess/GPU/media/RemoteImageDecoderAVF.cpp -1 / +1 lines
200		200
201	// If allDataReceived is true, the caller expects encodedDataStatus() to be >= EncodedDataStatus::SizeAvailable	201	// If allDataReceived is true, the caller expects encodedDataStatus() to be >= EncodedDataStatus::SizeAvailable
202	// after this function returns (in the same run loop).	202	// after this function returns (in the same run loop).
203	void RemoteImageDecoderAVF::setData(SharedBuffer& data, bool allDataReceived)	203	void RemoteImageDecoderAVF::setData(FragmentedSharedBuffer& data, bool allDataReceived)
204	{	204	{
205	if (!m_gpuProcessConnection)	205	if (!m_gpuProcessConnection)
206	return;	206	return;



    : public WebCore::ImageDecoder
    , public CanMakeWeakPtr<RemoteImageDecoderAVF> {
public:
    static Ref<RemoteImageDecoderAVF> create(RemoteImageDecoderAVFManager& manager, const WebCore::ImageDecoderIdentifier& identifier, WebCore::FragmentedSharedBuffer&, const String& mimeType)
    {
        return adoptRef(*new RemoteImageDecoderAVF(manager, identifier, mimeType));
    }

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

    void setExpectedContentSize(long long) final;
    void setData(WebCore::FragmentedSharedBuffer&, bool allDataReceived) final;
    bool isAllDataReceived() const final { return m_isAllDataReceived; }
    void clearFrameBufferCache(size_t) final;





using namespace WebCore;

RefPtr<RemoteImageDecoderAVF> RemoteImageDecoderAVFManager::createImageDecoder(FragmentedSharedBuffer& data, const String& mimeType, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
{
    std::optional<ImageDecoderIdentifier> imageDecoderIdentifier;
    IPC::SharedBufferDataReference dataReference { data };

    ImageDecoder::installFactory({
        RemoteImageDecoderAVF::supportsMediaType,
        RemoteImageDecoderAVF::canDecodeType,
        [this](FragmentedSharedBuffer& data, const String& mimeType, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption) {
            return createImageDecoder(data, mimeType, alphaOption, gammaAndColorProfileOption);
        }
    });

Lines 59-65 public: a/Source/WebKit/WebProcess/GPU/media/RemoteImageDecoderAVFManager.h_sec1
- a/Source/WebKit/WebProcess/GPU/media/RemoteImageDecoderAVFManager.h -1 / +1 lines
59	GPUProcessConnection& ensureGPUProcessConnection();	59	GPUProcessConnection& ensureGPUProcessConnection();
60		60
61	private:	61	private:
62	RefPtr<RemoteImageDecoderAVF> createImageDecoder(WebCore::SharedBuffer& data, const String& mimeType, WebCore::AlphaOption, WebCore::GammaAndColorProfileOption);	62	RefPtr<RemoteImageDecoderAVF> createImageDecoder(WebCore::FragmentedSharedBuffer& data, const String& mimeType, WebCore::AlphaOption, WebCore::GammaAndColorProfileOption);
63		63
64	// GPUProcessConnection::Client.	64	// GPUProcessConnection::Client.
65	void gpuProcessConnectionDidClose(GPUProcessConnection&) final;	65	void gpuProcessConnectionDidClose(GPUProcessConnection&) final;



    m_connection->send(Messages::RemoteMediaRecorder::AudioSamplesStorageChanged { SharedMemory::IPCHandle { WTFMove(handle), dataSize }, format, frameCount }, m_identifier);
}

void MediaRecorderPrivate::fetchData(CompletionHandler<void(RefPtr<WebCore::FragmentedSharedBuffer>&&, const String& mimeType, double)>&& completionHandler)
{
    m_connection->sendWithAsyncReply(Messages::RemoteMediaRecorder::FetchData { }, [completionHandler = WTFMove(completionHandler), mimeType = mimeType()](auto&& data, double timeCode) mutable {
        RefPtr<FragmentedSharedBuffer> buffer;
        if (data.size())
            buffer = SharedBuffer::create(data.data(), data.size());
        completionHandler(WTFMove(buffer), mimeType, timeCode);

Lines 57-63 public: a/Source/WebKit/WebProcess/GPU/webrtc/MediaRecorderPrivate.h_sec1
- a/Source/WebKit/WebProcess/GPU/webrtc/MediaRecorderPrivate.h -1 / +1 lines
57	private:	57	private:
58	// WebCore::MediaRecorderPrivate	58	// WebCore::MediaRecorderPrivate
59	void videoSampleAvailable(WebCore::MediaSample&, WebCore::VideoSampleMetadata) final;	59	void videoSampleAvailable(WebCore::MediaSample&, WebCore::VideoSampleMetadata) final;
60	void fetchData(CompletionHandler<void(RefPtr<WebCore::SharedBuffer>&&, const String& mimeType, double)>&&) final;	60	void fetchData(CompletionHandler<void(RefPtr<WebCore::FragmentedSharedBuffer>&&, const String& mimeType, double)>&&) final;
61	void stopRecording(CompletionHandler<void()>&&) final;	61	void stopRecording(CompletionHandler<void()>&&) final;
62	void startRecording(StartRecordingCallback&&) final;	62	void startRecording(StartRecordingCallback&&) final;
63	void audioSamplesAvailable(const WTF::MediaTime&, const WebCore::PlatformAudioData&, const WebCore::AudioStreamDescription&, size_t) final;	63	void audioSamplesAvailable(const WTF::MediaTime&, const WebCore::PlatformAudioData&, const WebCore::AudioStreamDescription&, size_t) final;



#include <wtf/text/WTFString.h>

namespace WebCore {
class SharedBuffer;
class DocumentFragment;
class Node;
class SharedBuffer;
class StyleProperties;
struct SimpleRange;
}



class DOMWrapperWorld;
class ResourceError;
class ResourceRequest;
class FragmentedSharedBuffer;
}

namespace WebKit {

    virtual ~PageLoaderClient() = default;

    virtual void willLoadURLRequest(WebKit::WebPage&, const WebCore::ResourceRequest&, API::Object*) { }
    virtual void willLoadDataRequest(WebKit::WebPage&, const WebCore::ResourceRequest&, WebCore::FragmentedSharedBuffer*, const WTF::String&, const WTF::String&, const WTF::URL&, API::Object*) { }

    virtual void didStartProvisionalLoadForFrame(WebKit::WebPage&, WebKit::WebFrame&, RefPtr<API::Object>&) { }
    virtual void didReceiveServerRedirectForProvisionalLoadForFrame(WebKit::WebPage&, WebKit::WebFrame&, RefPtr<API::Object>&) { }



static void releaseSharedBuffer(unsigned char*, const void* data)
{
    // Balanced by ref() in InjectedBundlePageLoaderClient::willLoadDataRequest().
    static_cast<const SharedBuffer*>(data)->deref();
}

void InjectedBundlePageLoaderClient::willLoadDataRequest(WebPage& page, const ResourceRequest& request, FragmentedSharedBuffer* sharedBuffer, const String& MIMEType, const String& encodingName, const URL& unreachableURL, API::Object* userData)
{
    if (!m_client.willLoadDataRequest)
        return;

    RefPtr<API::Data> data;
    if (sharedBuffer) {
        auto contiguousBuffer = sharedBuffer->makeContiguous();
        contiguousBuffer->ref();
        data = API::Data::createWithoutCopying(contiguousBuffer->data(), contiguousBuffer->size(), releaseSharedBuffer, contiguousBuffer.ptr());
    }

    m_client.willLoadDataRequest(toAPI(&page), toAPI(request), toAPI(data.get()), toAPI(MIMEType.impl()), toAPI(encodingName.impl()), toURLRef(unreachableURL.string().impl()), toAPI(userData), m_client.base.clientInfo);

Lines 47-53 public: a/Source/WebKit/WebProcess/InjectedBundle/InjectedBundlePageLoaderClient.h_sec1
- a/Source/WebKit/WebProcess/InjectedBundle/InjectedBundlePageLoaderClient.h -1 / +1 lines
47	explicit InjectedBundlePageLoaderClient(const WKBundlePageLoaderClientBase*);	47	explicit InjectedBundlePageLoaderClient(const WKBundlePageLoaderClientBase*);
48		48
49	void willLoadURLRequest(WebPage&, const WebCore::ResourceRequest&, API::Object*) override;	49	void willLoadURLRequest(WebPage&, const WebCore::ResourceRequest&, API::Object*) override;
50	void willLoadDataRequest(WebPage&, const WebCore::ResourceRequest&, WebCore::SharedBuffer, const WTF::String&, const WTF::String&, const URL&, API::Object) override;	50	void willLoadDataRequest(WebPage&, const WebCore::ResourceRequest&, WebCore::FragmentedSharedBuffer, const WTF::String&, const WTF::String&, const URL&, API::Object) override;
51		51
52	void didStartProvisionalLoadForFrame(WebPage&, WebFrame&, RefPtr<API::Object>&) override;	52	void didStartProvisionalLoadForFrame(WebPage&, WebFrame&, RefPtr<API::Object>&) override;
53	void didReceiveServerRedirectForProvisionalLoadForFrame(WebPage&, WebFrame&, RefPtr<API::Object>&) override;	53	void didReceiveServerRedirectForProvisionalLoadForFrame(WebPage&, WebFrame&, RefPtr<API::Object>&) override;

Lines 106-112 void ARKitInlinePreviewModelPlayerMac::createFile(WebCore::Model& modelSource) a/Source/WebKit/WebProcess/Model/mac/ARKitInlinePreviewModelPlayerMac.mm_sec1
- a/Source/WebKit/WebProcess/Model/mac/ARKitInlinePreviewModelPlayerMac.mm -1 / +1 lines
106	if (file <= 0)	106	if (file <= 0)
107	return;	107	return;
108		108
109	FileSystem::writeToFile(file, modelSource.data()->data(), modelSource.data()->size());	109	FileSystem::writeToFile(file, modelSource.data()->makeContiguous()->data(), modelSource.data()->size());
110	FileSystem::closeFile(file);	110	FileSystem::closeFile(file);
111	m_filePath = filePath;	111	m_filePath = filePath;
112	}	112	}



    if (!resource)
        return;
    
    auto buffer = handle.tryWrapInSharedBuffer();
    if (!buffer) {
        LOG_ERROR("Unable to create FragmentedSharedBuffer from ShareableResource handle for resource url %s", request.url().string().utf8().data());
        return;
    }




    if (InspectorInstrumentationWebKit::shouldInterceptResponse(m_coreLoader->frame(), response)) {
        auto interceptedRequestIdentifier = m_coreLoader->identifier();
        m_interceptController.beginInterceptingResponse(interceptedRequestIdentifier);
        InspectorInstrumentationWebKit::interceptResponse(m_coreLoader->frame(), response, interceptedRequestIdentifier, [this, protectedThis = Ref { *this }, interceptedRequestIdentifier, policyDecisionCompletionHandler = WTFMove(policyDecisionCompletionHandler)](const ResourceResponse& inspectorResponse, RefPtr<FragmentedSharedBuffer> overrideData) mutable {
            if (!m_coreLoader || !m_coreLoader->identifier()) {
                WEBRESOURCELOADER_RELEASE_LOG("didReceiveResponse: not continuing intercept load because no coreLoader or no ID");
                m_interceptController.continueResponse(interceptedRequestIdentifier);

    LOG(Network, "(WebProcess) WebResourceLoader::didReceiveResource for '%s'", m_coreLoader->url().string().latin1().data());
    WEBRESOURCELOADER_RELEASE_LOG("didReceiveResource:");

    RefPtr<FragmentedSharedBuffer> buffer = handle.tryWrapInSharedBuffer();

    if (!buffer) {
        LOG_ERROR("Unable to create buffer from ShareableResource sent from the network process.");
        WEBRESOURCELOADER_RELEASE_LOG("didReceiveResource: Unable to create FragmentedSharedBuffer");
        if (auto* frame = m_coreLoader->frame()) {
            if (auto* page = frame->page())
                page->diagnosticLoggingClient().logDiagnosticMessage(WebCore::DiagnosticLoggingKeys::internalErrorKey(), WebCore::DiagnosticLoggingKeys::createSharedBufferFailedKey(), WebCore::ShouldSample::No);

Lines 207-213 private: a/Source/WebKit/WebProcess/Plugins/PDF/PDFPlugin.h_sec1
- a/Source/WebKit/WebProcess/Plugins/PDF/PDFPlugin.h -1 / +1 lines
207	void privateBrowsingStateChanged(bool) final { }	207	void privateBrowsingStateChanged(bool) final { }
208	bool getFormValue(String& formValue) final { return false; }	208	bool getFormValue(String& formValue) final { return false; }
209	bool handleScroll(WebCore::ScrollDirection, WebCore::ScrollGranularity) final;	209	bool handleScroll(WebCore::ScrollDirection, WebCore::ScrollGranularity) final;
210	RefPtr<WebCore::SharedBuffer> liveResourceData() const final;	210	RefPtr<WebCore::FragmentedSharedBuffer> liveResourceData() const final;
211	void willDetachRenderer() final;	211	void willDetachRenderer() final;
212	bool pluginHandlesContentOffsetForAccessibilityHitTest() const final;	212	bool pluginHandlesContentOffsetForAccessibilityHitTest() const final;
213		213

Lines 2552-2558 void PDFPlugin::notifyDisplayModeChanged(int) a/Source/WebKit/WebProcess/Plugins/PDF/PDFPlugin.mm_sec1
- a/Source/WebKit/WebProcess/Plugins/PDF/PDFPlugin.mm -1 / +1 lines
2552	updateScrollbars();	2552	updateScrollbars();
2553	}	2553	}
2554		2554
2555	RefPtr<SharedBuffer> PDFPlugin::liveResourceData() const	2555	RefPtr<FragmentedSharedBuffer> PDFPlugin::liveResourceData() const
2556	{	2556	{
2557	NSData *pdfData = liveData();	2557	NSData *pdfData = liveData();
2558		2558



class IntRect;
class IntSize;
class Scrollbar;
class FragmentedSharedBuffer;
}

namespace WebKit {


    virtual WebCore::IntPoint convertToRootView(const WebCore::IntPoint& pointInLocalCoordinates) const;

    virtual RefPtr<WebCore::FragmentedSharedBuffer> liveResourceData() const = 0;

    virtual bool performDictionaryLookupAtLocation(const WebCore::FloatPoint&) = 0;




    , m_webPage(webPage(m_pluginElement.get()))
    , m_parameters(parameters)
    , m_pendingURLRequestsTimer(RunLoop::main(), this, &PluginView::pendingURLRequestsTimerFired)
    , m_manualStreamData(makeUniqueRef<SharedBufferBuilder>())
{
    m_webPage->addPluginView(this);
}


    if (!m_isInitialized) {
        ASSERT(m_manualStreamState == ManualStreamState::HasReceivedResponse);
        if (!m_manualStreamData)
            m_manualStreamData = SharedBuffer::create();

        m_manualStreamData->append(bytes, length);
        return;
    }

    if (!m_isInitialized) {
        m_manualStreamState = ManualStreamState::Finished;
        m_manualStreamError = error;
        m_manualStreamData->reset();
        return;
    }


    m_plugin->willDetachRenderer();
}

RefPtr<FragmentedSharedBuffer> PluginView::liveResourceData() const
{
    if (!m_isInitialized || !m_plugin) {
        if (m_manualStreamState == ManualStreamState::Finished)
            return m_manualStreamData->get();

        return nullptr;
    }

    manualLoadDidReceiveResponse(m_manualStreamResponse);

    // Deliver the data.
    if (!m_manualStreamData->isNull()) {
        auto buffer = m_manualStreamData->take();
        for (const auto& element : buffer.get())
            manualLoadDidReceiveData(element.segment->data(), element.segment->size());
        m_manualStreamData = nullptr;
    }

    if (m_manualStreamState == ManualStreamState::Finished)



#include <memory>
#include <wtf/Deque.h>
#include <wtf/RunLoop.h>
#include <wtf/UniqueRef.h>

// FIXME: Eventually this should move to WebCore.



    bool shouldAllowScripting();

    RefPtr<WebCore::FragmentedSharedBuffer> liveResourceData() const;
    bool performDictionaryLookupAtLocation(const WebCore::FloatPoint&);
    String getSelectionForWordAtPoint(const WebCore::FloatPoint&) const;
    bool existingSelectionContainsPoint(const WebCore::FloatPoint&) const;


    WebCore::ResourceResponse m_manualStreamResponse;
    WebCore::ResourceError m_manualStreamError;
    UniqueRef<WebCore::SharedBufferBuilder> m_manualStreamData;

    // This snapshot is used to avoid side effects should the plugin run JS during painting.
    RefPtr<ShareableBitmap> m_transientPaintingSnapshot;



    m_connection->send(Messages::ServiceWorkerFetchTask::DidReceiveResponse { response, m_needsContinueDidReceiveResponseMessage }, m_fetchIdentifier);
}

void WebServiceWorkerFetchTaskClient::didReceiveData(Ref<FragmentedSharedBuffer>&& buffer)
{
    if (!m_connection)
        return;

    if (m_waitingForContinueDidReceiveResponseMessage) {
        if (!std::holds_alternative<SharedBufferBuilder>(m_responseData))
            m_responseData = SharedBufferBuilder();
        std::get<SharedBufferBuilder>(m_responseData).append(WTFMove(buffer));
            std::get<Ref<SharedBuffer>>(m_responseData)->append(WTFMove(buffer));
        return;
    }


    switchOn(m_responseData, [this](std::nullptr_t&) {
        if (m_didFinish)
            didFinish();
    }, [this](const SharedBufferBuilder& buffer) {
        didReceiveData(*buffer.get());
        if (m_didFinish)
            didFinish();
    }, [this](Ref<FormData>& formData) {



#include <WebCore/FetchLoaderClient.h>
#include <WebCore/ServiceWorkerFetch.h>
#include <WebCore/ServiceWorkerTypes.h>
#include <WebCore/SharedBuffer.h>
#include <wtf/UniqueRef.h>

namespace WebKit {


    void didReceiveResponse(const WebCore::ResourceResponse&) final;
    void didReceiveRedirection(const WebCore::ResourceResponse&) final;
    void didReceiveData(Ref<WebCore::FragmentedSharedBuffer>&&) final;
    void didReceiveFormDataAndFinish(Ref<WebCore::FormData>&&) final;
    void didFail(const WebCore::ResourceError&) final;
    void didFinish() final;

    std::optional<BlobLoader> m_blobLoader;
    bool m_needsContinueDidReceiveResponseMessage { false };
    bool m_waitingForContinueDidReceiveResponseMessage { false };
    std::variant<std::nullptr_t, WebCore::SharedBufferBuilder, Ref<WebCore::FormData>, UniqueRef<WebCore::ResourceError>> m_responseData;
    bool m_didFinish { false };
};


Lines 142-148 bool WebEditorClient::shouldApplyStyle(const StyleProperties& style, const std:: a/Source/WebKit/WebProcess/WebCoreSupport/WebEditorClient.cpp_sec1
- a/Source/WebKit/WebProcess/WebCoreSupport/WebEditorClient.cpp -1 / +1 lines
142		142
143	#if ENABLE(ATTACHMENT_ELEMENT)	143	#if ENABLE(ATTACHMENT_ELEMENT)
144		144
145	void WebEditorClient::registerAttachmentIdentifier(const String& identifier, const String& contentType, const String& preferredFileName, Ref<SharedBuffer>&& data)	145	void WebEditorClient::registerAttachmentIdentifier(const String& identifier, const String& contentType, const String& preferredFileName, Ref<FragmentedSharedBuffer>&& data)
146	{	146	{
147	m_page->send(Messages::WebPageProxy::RegisterAttachmentIdentifierFromData(identifier, contentType, preferredFileName, data.get()));	147	m_page->send(Messages::WebPageProxy::RegisterAttachmentIdentifierFromData(identifier, contentType, preferredFileName, data.get()));
148	}	148	}

Lines 65-71 private: a/Source/WebKit/WebProcess/WebCoreSupport/WebEditorClient.h_sec1
- a/Source/WebKit/WebProcess/WebCoreSupport/WebEditorClient.h -1 / +1 lines
65	bool shouldMoveRangeAfterDelete(const WebCore::SimpleRange&, const WebCore::SimpleRange&) final;	65	bool shouldMoveRangeAfterDelete(const WebCore::SimpleRange&, const WebCore::SimpleRange&) final;
66		66
67	#if ENABLE(ATTACHMENT_ELEMENT)	67	#if ENABLE(ATTACHMENT_ELEMENT)
68	void registerAttachmentIdentifier(const String&, const String& contentType, const String& preferredFileName, Ref<WebCore::SharedBuffer>&&) final;	68	void registerAttachmentIdentifier(const String&, const String& contentType, const String& preferredFileName, Ref<WebCore::FragmentedSharedBuffer>&&) final;
69	void registerAttachmentIdentifier(const String&, const String& contentType, const String& filePath) final;	69	void registerAttachmentIdentifier(const String&, const String& contentType, const String& filePath) final;
70	void registerAttachmentIdentifier(const String&) final;	70	void registerAttachmentIdentifier(const String&) final;
71	void registerAttachments(Vector<WebCore::SerializedAttachmentData>&&) final;	71	void registerAttachments(Vector<WebCore::SerializedAttachmentData>&&) final;



            if (!webPage)
                return;

            RefPtr<FragmentedSharedBuffer> mainResourceData = loader->mainResourceData();
            IPC::DataReference dataReference(mainResourceData ? mainResourceData->makeContiguous()->data() : nullptr, mainResourceData ? mainResourceData->size() : 0);
            webPage->send(Messages::WebPageProxy::DidFinishLoadingDataForCustomContentProvider(loader->response().suggestedFilename(), dataReference));
        }


Lines 209-215 int64_t WebPlatformStrategies::setTypes(const Vector<String>& pasteboardTypes, c a/Source/WebKit/WebProcess/WebCoreSupport/WebPlatformStrategies.cpp_sec1
- a/Source/WebKit/WebProcess/WebCoreSupport/WebPlatformStrategies.cpp -1 / +1 lines
209	return newChangeCount;	209	return newChangeCount;
210	}	210	}
211		211
212	int64_t WebPlatformStrategies::setBufferForType(SharedBuffer* buffer, const String& pasteboardType, const String& pasteboardName, const PasteboardContext* context)	212	int64_t WebPlatformStrategies::setBufferForType(FragmentedSharedBuffer* buffer, const String& pasteboardType, const String& pasteboardName, const PasteboardContext* context)
213	{	213	{
214	SharedMemory::Handle handle;	214	SharedMemory::Handle handle;
215	if (buffer && buffer->size()) {	215	if (buffer && buffer->size()) {

Lines 66-72 private: a/Source/WebKit/WebProcess/WebCoreSupport/WebPlatformStrategies.h_sec1
- a/Source/WebKit/WebProcess/WebCoreSupport/WebPlatformStrategies.h -1 / +1 lines
66		66
67	int64_t addTypes(const Vector<String>& pasteboardTypes, const String& pasteboardName, const WebCore::PasteboardContext*) override;	67	int64_t addTypes(const Vector<String>& pasteboardTypes, const String& pasteboardName, const WebCore::PasteboardContext*) override;
68	int64_t setTypes(const Vector<String>& pasteboardTypes, const String& pasteboardName, const WebCore::PasteboardContext*) override;	68	int64_t setTypes(const Vector<String>& pasteboardTypes, const String& pasteboardName, const WebCore::PasteboardContext*) override;
69	int64_t setBufferForType(WebCore::SharedBuffer, const String& pasteboardType, const String& pasteboardName, const WebCore::PasteboardContext) override;	69	int64_t setBufferForType(WebCore::FragmentedSharedBuffer, const String& pasteboardType, const String& pasteboardName, const WebCore::PasteboardContext) override;
70	int64_t setURL(const WebCore::PasteboardURL&, const String& pasteboardName, const WebCore::PasteboardContext*) override;	70	int64_t setURL(const WebCore::PasteboardURL&, const String& pasteboardName, const WebCore::PasteboardContext*) override;
71	int64_t setColor(const WebCore::Color&, const String& pasteboardName, const WebCore::PasteboardContext*) override;	71	int64_t setColor(const WebCore::Color&, const String& pasteboardName, const WebCore::PasteboardContext*) override;
72	int64_t setStringForType(const String&, const String& pasteboardType, const String& pasteboardName, const WebCore::PasteboardContext*) override;	72	int64_t setStringForType(const String&, const String& pasteboardType, const String& pasteboardName, const WebCore::PasteboardContext*) override;



    : m_fileName { fileName }
    , m_uti { uti }
    , m_pageID { pageID }
    , m_buffer { makeUniqueRef<SharedBufferBuilder>() }
{
}

WebPreviewLoaderClient::~WebPreviewLoaderClient() = default;

void WebPreviewLoaderClient::didReceiveBuffer(const FragmentedSharedBuffer& buffer)
{
    auto webPage = WebProcess::singleton().webPage(m_pageID);
    if (!webPage)

    if (!webPage)
        return;

    webPage->didFinishLoadForQuickLookDocumentInMainFrame(m_buffer->take().get());
    m_buffer->clear();
}

void WebPreviewLoaderClient::didFail()
{
    m_buffer->reset();
}

void WebPreviewLoaderClient::didRequestPassword(Function<void(const String&)>&& completionHandler)

Lines 29-36 a/Source/WebKit/WebProcess/WebCoreSupport/ios/WebPreviewLoaderClient.h_sec1
- a/Source/WebKit/WebProcess/WebCoreSupport/ios/WebPreviewLoaderClient.h -2 / +7 lines
29		29
30	#include <WebCore/LegacyPreviewLoaderClient.h>	30	#include <WebCore/LegacyPreviewLoaderClient.h>
31	#include <WebCore/PageIdentifier.h>	31	#include <WebCore/PageIdentifier.h>
		32	#include <wtf/UniqueRef.h>
32	#include <wtf/text/WTFString.h>	33	#include <wtf/text/WTFString.h>
33		34
		35	namespace WebCore {
		36	class SharedBufferBuilder;
		37	}
		38
34	namespace WebKit {	39	namespace WebKit {
35		40
36	class WebFrame;	41	class WebFrame;
Lines 45-51 public: a/Source/WebKit/WebProcess/WebCoreSupport/ios/WebPreviewLoaderClient.h_sec2
45		50
46	private:	51	private:
47	WebPreviewLoaderClient(const String& fileName, const String& uti, WebCore::PageIdentifier);	52	WebPreviewLoaderClient(const String& fileName, const String& uti, WebCore::PageIdentifier);
48	void didReceiveBuffer(const WebCore::SharedBuffer&) override;	53	void didReceiveBuffer(const WebCore::FragmentedSharedBuffer&) override;
49	void didFinishLoading() override;	54	void didFinishLoading() override;
50	void didFail() override;	55	void didFail() override;
51	bool supportsPasswordEntry() const override { return true; }	56	bool supportsPasswordEntry() const override { return true; }
Lines 54-60 private: a/Source/WebKit/WebProcess/WebCoreSupport/ios/WebPreviewLoaderClient.h_sec3
54	const String m_fileName;	59	const String m_fileName;
55	const String m_uti;	60	const String m_uti;
56	const WebCore::PageIdentifier m_pageID;	61	const WebCore::PageIdentifier m_pageID;
57	Ref<WebCore::SharedBuffer> m_buffer;	62	UniqueRef<WebCore::SharedBufferBuilder> m_buffer;
58	};	63	};
59		64
60	} // namespace WebKit	65	} // namespace WebKit

Lines 150-156 void WebDragClient::declareAndWriteDragImage(const String& pasteboardName, Eleme a/Source/WebKit/WebProcess/WebCoreSupport/mac/WebDragClientMac.mm_sec1
- a/Source/WebKit/WebProcess/WebCoreSupport/mac/WebDragClientMac.mm -1 / +1 lines
150		150
151	NSURLResponse *response = image->response().nsURLResponse();	151	NSURLResponse *response = image->response().nsURLResponse();
152		152
153	RefPtr<SharedBuffer> imageBuffer = image->image()->data();	153	auto imageBuffer = image->image()->data();
154	size_t imageSize = imageBuffer->size();	154	size_t imageSize = imageBuffer->size();
155		155
156	auto sharedMemoryBuffer = SharedMemory::copyBuffer(*imageBuffer);	156	auto sharedMemoryBuffer = SharedMemory::copyBuffer(*imageBuffer);



    DocumentLoader* documentLoader = m_coreFrame->loader().activeDocumentLoader();
    if (!documentLoader)
        return String();
    RefPtr<FragmentedSharedBuffer> mainResourceData = documentLoader->mainResourceData();
    if (!mainResourceData)
        return String();
    return decoder->encoding().decode(mainResourceData->makeContiguous()->data(), mainResourceData->size());
}

String WebFrame::contentsAsString() const 



    RELEASE_ASSERT_NOT_REACHED();
}

void WebPage::loadDataImpl(uint64_t navigationID, ShouldTreatAsContinuingLoad shouldTreatAsContinuingLoad, std::optional<WebsitePoliciesData>&& websitePolicies, Ref<FragmentedSharedBuffer>&& sharedBuffer, ResourceRequest&& request, ResourceResponse&& response, const URL& unreachableURL, const UserData& userData, std::optional<NavigatingToAppBoundDomain> isNavigatingToAppBoundDomain, SubstituteData::SessionHistoryVisibility sessionHistoryVisibility, ShouldOpenExternalURLsPolicy shouldOpenExternalURLsPolicy)
{
#if ENABLE(APP_BOUND_DOMAINS)
    setIsNavigatingToAppBoundDomain(isNavigatingToAppBoundDomain, &m_mainFrame.get());


    // Let the InjectedBundle know we are about to start the load, passing the user data from the UIProcess
    // to all the client to set up any needed state.
    m_loaderClient->willLoadDataRequest(*this, request, const_cast<FragmentedSharedBuffer*>(substituteData.content()), substituteData.mimeType(), substituteData.textEncoding(), substituteData.failingURL(), WebProcess::singleton().transformHandlesToObjects(userData.object()).get());

    // Initate the load in WebCore.
    FrameLoadRequest frameLoadRequest(*m_mainFrame->coreFrame(), request, substituteData);


void WebPage::getMainResourceDataOfFrame(FrameIdentifier frameID, CompletionHandler<void(const std::optional<IPC::SharedBufferDataReference>&)>&& callback)
{
    RefPtr<FragmentedSharedBuffer> buffer;
    if (WebFrame* frame = WebProcess::singleton().webFrame(frameID)) {
        if (PluginView* pluginView = pluginViewForFrame(frame->coreFrame()))
            buffer = pluginView->liveResourceData();

    callback(dataReference);
}

static RefPtr<FragmentedSharedBuffer> resourceDataForFrame(Frame* frame, const URL& resourceURL)
{
    DocumentLoader* loader = frame->loader().documentLoader();
    if (!loader)


void WebPage::getResourceDataFromFrame(FrameIdentifier frameID, const String& resourceURLString, CompletionHandler<void(const std::optional<IPC::SharedBufferDataReference>&)>&& callback)
{
    RefPtr<FragmentedSharedBuffer> buffer;
    if (auto* frame = WebProcess::singleton().webFrame(frameID)) {
        URL resourceURL(URL(), resourceURLString);
        buffer = resourceDataForFrame(frame->coreFrame(), resourceURL);

    if (!documentLoader)
        return completionHandler({ });

    documentLoader->didGetLoadDecisionForIcon(decision, loadIdentifier.toInteger(), [completionHandler = WTFMove(completionHandler)] (WebCore::FragmentedSharedBuffer* iconData) mutable {
        completionHandler({ iconData });
    });
}



class ResourceResponse;
class SelectionData;
class SelectionGeometry;
class FragmentedSharedBuffer;
class SubstituteData;
class TextCheckingRequest;
class VisiblePosition;


#if USE(QUICK_LOOK)
    void didStartLoadForQuickLookDocumentInMainFrame(const String& fileName, const String& uti);
    void didFinishLoadForQuickLookDocumentInMainFrame(const WebCore::FragmentedSharedBuffer&);
    void requestPasswordForQuickLookDocumentInMainFrame(const String& fileName, CompletionHandler<void(const String&)>&&);
#endif



    String sourceForFrame(WebFrame*);

    void loadDataImpl(uint64_t navigationID, WebCore::ShouldTreatAsContinuingLoad, std::optional<WebsitePoliciesData>&&, Ref<WebCore::FragmentedSharedBuffer>&&, WebCore::ResourceRequest&&, WebCore::ResourceResponse&&, const URL& failingURL, const UserData&, std::optional<NavigatingToAppBoundDomain>, WebCore::SubstituteData::SessionHistoryVisibility, WebCore::ShouldOpenExternalURLsPolicy = WebCore::ShouldOpenExternalURLsPolicy::ShouldNotAllow);

    // Actions
    void tryClose(CompletionHandler<void(bool)>&&);



        CachedImage* cachedImage = downcast<RenderImage>(*element.renderer()).cachedImage();
        if (!cachedImage)
            return;
        RefPtr<FragmentedSharedBuffer> buffer = cachedImage->resourceBuffer();
        if (!buffer)
            return;
        auto sharedMemoryBuffer = SharedMemory::copyBuffer(*buffer);

    send(Messages::WebPageProxy::DidStartLoadForQuickLookDocumentInMainFrame(fileName, uti));
}

void WebPage::didFinishLoadForQuickLookDocumentInMainFrame(const FragmentedSharedBuffer& buffer)
{
    ASSERT(!buffer.isEmpty());


Lines 566-572 void WebPage::getDataSelectionForPasteboard(const String pasteboardType, Complet a/Source/WebKit/WebProcess/WebPage/mac/WebPageMac.mm_sec1
- a/Source/WebKit/WebProcess/WebPage/mac/WebPageMac.mm -1 / +1 lines
566	if (frame.selection().isNone())	566	if (frame.selection().isNone())
567	return completionHandler({ });	567	return completionHandler({ });
568		568
569	RefPtr<SharedBuffer> buffer = frame.editor().dataSelectionForPasteboard(pasteboardType);	569	auto buffer = frame.editor().dataSelectionForPasteboard(pasteboardType);
570	if (!buffer)	570	if (!buffer)
571	return completionHandler({ });	571	return completionHandler({ });
572	auto sharedMemoryBuffer = SharedMemory::copyBuffer(*buffer);	572	auto sharedMemoryBuffer = SharedMemory::copyBuffer(*buffer);

Lines 28-34 a/Source/WebKit/WebProcess/win/WebProcessWin.cpp_sec1
- a/Source/WebKit/WebProcess/win/WebProcessWin.cpp -1 / +1 lines
28		28
29	#include <WebCore/SharedBuffer.h>	29	#include <WebCore/SharedBuffer.h>
30		30
31	RefPtr<WebCore::SharedBuffer> loadResourceIntoBuffer(const char* name)	31	RefPtr<WebCore::FragmentedSharedBuffer> loadResourceIntoBuffer(const char* name)
32	{	32	{
33	return 0;	33	return 0;
34	}	34	}



2021-12-03  Jean-Yves Avenard  <jya@apple.com>

        Rename SharedBuffer classes.
        https://bugs.webkit.org/show_bug.cgi?id=233677
        rdar://problem/85963900

        Reviewed by NOBODY (OOPS!).

        SharedBuffer are renamed FragmentedSharedBuffer and
        ContiguousSharedBuffer to SharedBuffer to better reflect their actual
        types.

        * WebCoreSupport/PingHandle.h:

2021-11-12  Darin Adler  <darin@apple.com>

        Make sort-Xcode-project-file idempotent

Lines 73-79 private: a/Source/WebKitLegacy/WebCoreSupport/PingHandle.h_sec1
- a/Source/WebKitLegacy/WebCoreSupport/PingHandle.h -1 / +1 lines
73	completionHandler();	73	completionHandler();
74	pingLoadComplete({ }, response);	74	pingLoadComplete({ }, response);
75	}	75	}
76	void didReceiveBuffer(WebCore::ResourceHandle*, Ref<WebCore::SharedBuffer>&&, int) final { pingLoadComplete(); }	76	void didReceiveBuffer(WebCore::ResourceHandle*, Ref<WebCore::FragmentedSharedBuffer>&&, int) final { pingLoadComplete(); }
77	void didFinishLoading(WebCore::ResourceHandle*, const WebCore::NetworkLoadMetrics&) final { pingLoadComplete(); }	77	void didFinishLoading(WebCore::ResourceHandle*, const WebCore::NetworkLoadMetrics&) final { pingLoadComplete(); }
78	void didFail(WebCore::ResourceHandle*, const WebCore::ResourceError& error) final { pingLoadComplete(error); }	78	void didFail(WebCore::ResourceHandle*, const WebCore::ResourceError& error) final { pingLoadComplete(error); }
79	bool shouldUseCredentialStorage(WebCore::ResourceHandle*) final { return m_shouldUseCredentialStorage; }	79	bool shouldUseCredentialStorage(WebCore::ResourceHandle*) final { return m_shouldUseCredentialStorage; }



2021-12-03  Jean-Yves Avenard  <jya@apple.com>

        Rename SharedBuffer classes.
        https://bugs.webkit.org/show_bug.cgi?id=233677
        rdar://problem/85963900

        Reviewed by NOBODY (OOPS!).

        SharedBuffer are renamed FragmentedSharedBuffer and
        ContiguousSharedBuffer to SharedBuffer to better reflect their actual
        types.

        * WebCoreSupport/WebEditorClient.h:
        * WebCoreSupport/WebEditorClient.mm:
        * WebCoreSupport/WebFrameLoaderClient.h:
        * WebCoreSupport/WebFrameLoaderClient.mm:
        * WebCoreSupport/WebPlatformStrategies.h:
        * WebCoreSupport/WebPlatformStrategies.mm:
        * WebView/WebDataSource.mm:
        * WebView/WebHTMLView.mm:
        * WebView/WebResource.mm:

2021-11-25  Jean-Yves Avenard  <jya@apple.com>

        Distinguish contiguous SharedBuffer from non-contiguous one and guarantee immutability
        https://bugs.webkit.org/show_bug.cgi?id=233030
        rdar://85333814

        Reviewed by Darin Adler.

        * DOM/DOMUIKitExtensions.mm:
        (-[DOMHTMLImageElement dataRepresentation:]):
        * WebCoreSupport/WebEditorClient.h:
        * WebCoreSupport/WebEditorClient.mm:
        (WebEditorClient::getClientPasteboardData):
        * WebCoreSupport/WebPlatformStrategies.h:
        * WebCoreSupport/WebPlatformStrategies.mm:
        (WebPlatformStrategies::bufferForType):
        (WebPlatformStrategies::readBufferFromPasteboard):
        * WebView/WebDataSource.mm:
        (-[WebDataSource data]):
        * WebView/WebHTMLRepresentation.mm:
        (-[WebHTMLRepresentation documentSource]):
        * WebView/WebHTMLView.mm:
        (createShareMenuItem):
        * WebView/WebResource.mm:
        (-[WebResource encodeWithCoder:]):
        (-[WebResource data]):
        (-[WebResource _stringValue]):

2021-12-02  Myles C. Maxfield  <mmaxfield@apple.com>

        [WebGPU] Hook up navigator.gpu.requestAdapter()

Lines 388-394 - (NSData *)dataRepresentation:(BOOL)rawImageData a/Source/WebKitLegacy/mac/DOM/DOMUIKitExtensions.mm_sec1
- a/Source/WebKitLegacy/mac/DOM/DOMUIKitExtensions.mm -1 / +1 lines
388	auto* data = rawImageData ? cachedImage->resourceBuffer() : image->data();	388	auto* data = rawImageData ? cachedImage->resourceBuffer() : image->data();
389	if (!data)	389	if (!data)
390	return nil;	390	return nil;
391	return data->createNSData().autorelease();	391	return data->makeContiguous()->createNSData().autorelease();
392	}	392	}
393		393
394	- (NSString *)mimeType	394	- (NSString *)mimeType

Lines 248-254 private: a/Source/WebKitLegacy/mac/WebCoreSupport/WebFrameLoaderClient.h_sec1
- a/Source/WebKitLegacy/mac/WebCoreSupport/WebFrameLoaderClient.h -1 / +1 lines
248	void sendH2Ping(const URL&, CompletionHandler<void(Expected<Seconds, WebCore::ResourceError>&&)>&&) final;	248	void sendH2Ping(const URL&, CompletionHandler<void(Expected<Seconds, WebCore::ResourceError>&&)>&&) final;
249		249
250	void getLoadDecisionForIcons(const Vector<std::pair<WebCore::LinkIcon&, uint64_t>>&) final;	250	void getLoadDecisionForIcons(const Vector<std::pair<WebCore::LinkIcon&, uint64_t>>&) final;
251	void finishedLoadingIcon(WebCore::SharedBuffer*);	251	void finishedLoadingIcon(WebCore::FragmentedSharedBuffer*);
252		252
253	#if !PLATFORM(IOS_FAMILY)	253	#if !PLATFORM(IOS_FAMILY)
254	bool m_loadingIcon { false };	254	bool m_loadingIcon { false };



        RetainPtr<NSString> m_filePath;
        RetainPtr<NSFileHandle> m_fileHandle;

        void didReceiveBuffer(const WebCore::FragmentedSharedBuffer& buffer) override
        {
            auto dataArray = buffer.createNSDataArray();
            for (NSData *data in dataArray.get())

        }

        m_loadingIcon = true;
        documentLoader->didGetLoadDecisionForIcon(true, icon->second, [this, weakThis = WeakPtr { *this }] (WebCore::FragmentedSharedBuffer* buffer) {
            if (!weakThis)
                return;
            finishedLoadingIcon(buffer);

}
#endif // !PLATFORM(IOS_FAMILY)

void WebFrameLoaderClient::finishedLoadingIcon(WebCore::FragmentedSharedBuffer* iconData)
{
#if !PLATFORM(IOS_FAMILY)
    ASSERT(m_loadingIcon);

Lines 75-81 private: a/Source/WebKitLegacy/mac/WebCoreSupport/WebPlatformStrategies.h_sec1
- a/Source/WebKitLegacy/mac/WebCoreSupport/WebPlatformStrategies.h -1 / +1 lines
75		75
76	int64_t addTypes(const Vector<String>& pasteboardTypes, const String& pasteboardName, const WebCore::PasteboardContext*) override;	76	int64_t addTypes(const Vector<String>& pasteboardTypes, const String& pasteboardName, const WebCore::PasteboardContext*) override;
77	int64_t setTypes(const Vector<String>& pasteboardTypes, const String& pasteboardName, const WebCore::PasteboardContext*) override;	77	int64_t setTypes(const Vector<String>& pasteboardTypes, const String& pasteboardName, const WebCore::PasteboardContext*) override;
78	int64_t setBufferForType(WebCore::SharedBuffer, const String& pasteboardType, const String& pasteboardName, const WebCore::PasteboardContext) override;	78	int64_t setBufferForType(WebCore::FragmentedSharedBuffer, const String& pasteboardType, const String& pasteboardName, const WebCore::PasteboardContext) override;
79	int64_t setURL(const WebCore::PasteboardURL&, const String& pasteboardName, const WebCore::PasteboardContext*) override;	79	int64_t setURL(const WebCore::PasteboardURL&, const String& pasteboardName, const WebCore::PasteboardContext*) override;
80	int64_t setColor(const WebCore::Color&, const String& pasteboardName, const WebCore::PasteboardContext*) override;	80	int64_t setColor(const WebCore::Color&, const String& pasteboardName, const WebCore::PasteboardContext*) override;
81	int64_t setStringForType(const String&, const String& pasteboardType, const String& pasteboardName, const WebCore::PasteboardContext*) override;	81	int64_t setStringForType(const String&, const String& pasteboardType, const String& pasteboardName, const WebCore::PasteboardContext*) override;

Lines 154-160 int64_t WebPlatformStrategies::setTypes(const Vector<String>& pasteboardTypes, c a/Source/WebKitLegacy/mac/WebCoreSupport/WebPlatformStrategies.mm_sec1
- a/Source/WebKitLegacy/mac/WebCoreSupport/WebPlatformStrategies.mm -1 / +1 lines
154	return PlatformPasteboard(pasteboardName).setTypes(pasteboardTypes);	154	return PlatformPasteboard(pasteboardName).setTypes(pasteboardTypes);
155	}	155	}
156		156
157	int64_t WebPlatformStrategies::setBufferForType(SharedBuffer* buffer, const String& pasteboardType, const String& pasteboardName, const PasteboardContext*)	157	int64_t WebPlatformStrategies::setBufferForType(FragmentedSharedBuffer* buffer, const String& pasteboardType, const String& pasteboardName, const PasteboardContext*)
158	{	158	{
159	return PlatformPasteboard(pasteboardName).setBufferForType(buffer, pasteboardType);	159	return PlatformPasteboard(pasteboardName).setBufferForType(buffer, pasteboardType);
160	}	160	}




- (NSData *)data
{
    RefPtr<WebCore::FragmentedSharedBuffer> mainResourceData = toPrivate(_private)->loader->mainResourceData();
    if (!mainResourceData)
        return nil;
    return mainResourceData->makeContiguous()->createNSData().autorelease();
}

- (id <WebDocumentRepresentation>)representation

Lines 230-236 - (BOOL)canSaveAsWebArchive a/Source/WebKitLegacy/mac/WebView/WebHTMLRepresentation.mm_sec1
- a/Source/WebKitLegacy/mac/WebView/WebHTMLRepresentation.mm -1 / +1 lines
230	- (NSString *)documentSource	230	- (NSString *)documentSource
231	{	231	{
232	if ([self _isDisplayingWebArchive]) {	232	if ([self _isDisplayingWebArchive]) {
233	SharedBuffer *parsedArchiveData = [_private->dataSource _documentLoader]->parsedArchiveData();	233	auto *parsedArchiveData = [_private->dataSource _documentLoader]->parsedArchiveData();
234	return adoptNS([[NSString alloc] initWithData:parsedArchiveData ? parsedArchiveData->createNSData().get() : nil encoding:NSUTF8StringEncoding]).autorelease();	234	return adoptNS([[NSString alloc] initWithData:parsedArchiveData ? parsedArchiveData->createNSData().get() : nil encoding:NSUTF8StringEncoding]).autorelease();
235	}	235	}
236		236



    }

    if (auto* image = hitTestResult.image()) {
        if (RefPtr<WebCore::FragmentedSharedBuffer> buffer = image->data())
            [items addObject:adoptNS([[NSImage alloc] initWithData:[NSData dataWithBytes:buffer->makeContiguous()->data() length:buffer->size()]]).get()];
    }

    if (!hitTestResult.selectedText().isEmpty()) {



- (void)encodeWithCoder:(NSCoder *)encoder
{
    auto* resource = _private->coreResource.get();

    RetainPtr<NSData> data;
    NSURL *url = nil;
    NSString *mimeType = nil, *textEncoding = nil, *frameName = nil;
    NSURLResponse *response = nil;

    if (resource) {
        data = resource->data().makeContiguous()->createNSData();
        url = resource->url();
        mimeType = resource->mimeType();
        textEncoding = resource->textEncoding();
        frameName = resource->frameName();
        response = resource->response().nsURLResponse();
    }
    [encoder encodeObject:data.get() forKey:WebResourceDataKey];
    [encoder encodeObject:url forKey:WebResourceURLKey];
    [encoder encodeObject:mimeType forKey:WebResourceMIMETypeKey];
    [encoder encodeObject:textEncoding forKey:WebResourceTextEncodingNameKey];


    if (!_private->coreResource)
        return nil;
    return _private->coreResource->data().makeContiguous()->createNSData().autorelease();
}

- (NSURL *)URL

    if (!encoding.isValid())
        encoding = WindowsLatin1Encoding();
    
    FragmentedSharedBuffer* coreData = _private->coreResource ? &_private->coreResource->data() : nullptr;
    return encoding.decode(reinterpret_cast<const char*>(coreData ? coreData->makeContiguous()->data() : nullptr), coreData ? coreData->size() : 0);
}

@end



2021-12-03  Jean-Yves Avenard  <jya@apple.com>

        Rename SharedBuffer classes.
        https://bugs.webkit.org/show_bug.cgi?id=233677
        rdar://problem/85963900

        Reviewed by NOBODY (OOPS!).

        SharedBuffer are renamed FragmentedSharedBuffer and
        ContiguousSharedBuffer to SharedBuffer to better reflect their actual
        types.

        * MemoryStream.cpp:
        * MemoryStream.h:
        * WebArchive.cpp:
        * WebCoreSupport/WebEditorClient.cpp:
        * WebCoreSupport/WebEditorClient.h:
        * WebFrame.cpp:
        * WebFrame.h:
        * WebKitDLL.cpp:
        * WebResource.cpp:
        * WebResource.h:

2021-12-01  Jean-Yves Avenard  <jya@apple.com>

        Add SharedBufferBuilder class
        https://bugs.webkit.org/show_bug.cgi?id=233442
        rdar://85693939

        Reviewed by NOBODY (OOPS!).

        * WebFrame.cpp:
        (WebFrame::loadData):

2021-11-25  Jean-Yves Avenard  <jya@apple.com>

        Distinguish contiguous SharedBuffer from non-contiguous one and guarantee immutability
        https://bugs.webkit.org/show_bug.cgi?id=233030
        rdar://85333814

        Reviewed by Darin Adler.

        * MemoryStream.cpp:
        (MemoryStream::MemoryStream):
        (MemoryStream::createInstance):
        * MemoryStream.h:
        * WebArchive.cpp:
        (WebArchive::data):
        * WebCoreSupport/WebEditorClient.cpp:
        (WebEditorClient::getClientPasteboardData):
        * WebCoreSupport/WebEditorClient.h:
        * WebDataSource.cpp:
        (WebDataSource::data):
        * WebResource.cpp:
        (WebResource::createInstance):
        * WebResource.h:

2021-12-02  Chris Dumez  <cdumez@apple.com>

        [WK2] Make Web Lock API work across multiple WebProcesses

Lines 175-181 HRESULT WebDataSource::data(_COM_Outptr_opt_ IStream** stream) a/Source/WebKitLegacy/win/WebDataSource.cpp_sec1
- a/Source/WebKitLegacy/win/WebDataSource.cpp -1 / +1 lines
175	if (!m_loader)	175	if (!m_loader)
176	return E_UNEXPECTED;	176	return E_UNEXPECTED;
177		177
178	return MemoryStream::createInstance(m_loader->mainResourceData()).copyRefTo(stream);	178	return MemoryStream::createInstance(m_loader->mainResourceData()->makeContiguous()).copyRefTo(stream);
179	}	179	}
180		180
181	HRESULT WebDataSource::representation(_COM_Outptr_opt_ IWebDocumentRepresentation** rep)	181	HRESULT WebDataSource::representation(_COM_Outptr_opt_ IWebDocumentRepresentation** rep)



    return S_OK;
}

void WebFrame::loadData(Ref<WebCore::FragmentedSharedBuffer>&& data, BSTR mimeType, BSTR textEncodingName, BSTR baseURL, BSTR failingURL)
{
    String mimeTypeString(mimeType, SysStringLen(mimeType));
    if (!mimeType)


HRESULT WebFrame::loadData(_In_opt_ IStream* data, _In_ BSTR mimeType, _In_ BSTR textEncodingName, _In_ BSTR url)
{
    SharedBufferBuilder sharedBuffer;

    STATSTG stat;
    if (SUCCEEDED(data->Stat(&stat, STATFLAG_NONAME))) {
        if (!stat.cbSize.HighPart && stat.cbSize.LowPart) {
            Vector<char> dataBuffer(stat.cbSize.LowPart);
            ULONG read;
            // FIXME: this does a needless copy, would be better to read right into the FragmentedSharedBuffer
            // or adopt the Vector or something.
            if (SUCCEEDED(data->Read(dataBuffer.data(), static_cast<ULONG>(dataBuffer.size()), &read)))
                sharedBuffer.append(dataBuffer.data(), static_cast<int>(dataBuffer.size()));
        }
    }

    loadData(sharedBuffer.take(), mimeType, textEncodingName, url, nullptr);
    return S_OK;
}




class IntRect;
class Page;
class ResourceError;
class FragmentedSharedBuffer;
}

typedef const struct OpaqueJSContext* JSContextRef;

    ~WebFrame();

    void loadHTMLString(_In_ BSTR string, _In_ BSTR baseURL, _In_ BSTR unreachableURL);
    void loadData(Ref<WebCore::FragmentedSharedBuffer>&&, BSTR mimeType, BSTR textEncodingName, BSTR baseURL, BSTR failingURL);
    const Vector<WebCore::IntRect>& computePageRects(HDC printDC);
    void setPrinting(bool printing, const WebCore::FloatSize& pageSize, const WebCore::FloatSize& originalPageSize, float maximumShrinkRatio, WebCore::AdjustViewSizeOrNot);
    void headerAndFooterHeights(float*, float*);



}

//FIXME: We should consider moving this to a new file for cross-project functionality
WEBKIT_API RefPtr<WebCore::FragmentedSharedBuffer> loadResourceIntoBuffer(const char* name);
RefPtr<WebCore::FragmentedSharedBuffer> loadResourceIntoBuffer(const char* name)
{
    int idr;
    // temporary hack to get resource id



2021-12-03  Jean-Yves Avenard  <jya@apple.com>

        Rename SharedBuffer classes.
        https://bugs.webkit.org/show_bug.cgi?id=233677
        rdar://problem/85963900

        Reviewed by NOBODY (OOPS!).

        SharedBuffer are renamed FragmentedSharedBuffer and
        ContiguousSharedBuffer to SharedBuffer to better reflect their actual
        types.

        * TestWebKitAPI/Tests/WTF/FileSystem.cpp:
        * TestWebKitAPI/Tests/WebCore/DisplayListTests.cpp:
        * TestWebKitAPI/Tests/WebCore/SharedBuffer.cpp:
        * TestWebKitAPI/Tests/WebCore/SharedBufferTest.cpp:
        * TestWebKitAPI/Tests/WebCore/SharedBufferTest.h:
        * TestWebKitAPI/Tests/WebCore/cg/DisplayListTestsCG.cpp:
        * TestWebKitAPI/Tests/WebCore/cocoa/SharedBuffer.mm:
        * TestWebKitAPI/win/TestWebCoreStubs.cpp:

2021-11-28  Jean-Yves Avenard  <jya@apple.com>

        Add SharedBufferBuilder class
        https://bugs.webkit.org/show_bug.cgi?id=233442
        rdar://85693939

        Reviewed by NOBODY (OOPS!).

        Update API tests.

        * TestWebKitAPI/Tests/WebCore/SharedBuffer.cpp:
        (TestWebKitAPI::TEST_F):
        * TestWebKitAPI/Tests/WebCore/cocoa/SharedBuffer.mm:
        (TestWebKitAPI::TEST_F):

2021-11-25  Jean-Yves Avenard  <jya@apple.com>

        Distinguish contiguous SharedBuffer from non-contiguous one and guarantee immutability
        https://bugs.webkit.org/show_bug.cgi?id=233030
        rdar://85333814

        Reviewed by Darin Adler.

        * TestWebKitAPI/Tests/WebCore/SharedBuffer.cpp:
        (TestWebKitAPI::TEST_F):
        * TestWebKitAPI/Tests/WebCore/cocoa/SharedBuffer.mm:
        (TestWebKitAPI::TEST_F):

2021-12-05  Said Abou-Hallawa  <said@apple.com>

        [GPU Process] Add the encoding/decoding for Filter and FilterEffect

Lines 44-50 static void createTestFile(const String& path) a/Tools/TestWebKitAPI/Tests/WTF/FileSystem.cpp_sec1
- a/Tools/TestWebKitAPI/Tests/WTF/FileSystem.cpp -1 / +1 lines
44	FileSystem::closeFile(fileHandle);	44	FileSystem::closeFile(fileHandle);
45	};	45	};
46		46
47	// FIXME: Refactor FileSystemTest and SharedBufferTest as a single class.	47	// FIXME: Refactor FileSystemTest and FragmentedSharedBufferTest as a single class.
48	class FileSystemTest : public testing::Test {	48	class FileSystemTest : public testing::Test {
49	public:	49	public:
50	void SetUp() override	50	void SetUp() override

Lines 199-205 TEST(DisplayListTests, ItemBufferClient) a/Tools/TestWebKitAPI/Tests/WebCore/DisplayListTests.cpp_sec1
- a/Tools/TestWebKitAPI/Tests/WebCore/DisplayListTests.cpp -1 / +1 lines
199	return { globalBufferIdentifier, globalItemBuffer, globalItemBufferCapacity };	199	return { globalBufferIdentifier, globalItemBuffer, globalItemBufferCapacity };
200	}	200	}
201		201
202	RefPtr<SharedBuffer> encodeItemOutOfLine(const DisplayListItem& displayListItem) const final	202	RefPtr<FragmentedSharedBuffer> encodeItemOutOfLine(const DisplayListItem& displayListItem) const final
203	{	203	{
204	auto index = m_items.size();	204	auto index = m_items.size();
205	m_items.append(std::get<StrokePath>(displayListItem));	205	m_items.append(std::get<StrokePath>(displayListItem));



/*
 * Copyright (C) 2016-2021 Apple Inc. All rights reserved.
 * Copyright (C) 2015 Canon Inc. All rights reserved.
 * Copyright (C) 2013 Google Inc. All rights reserved.
 *


namespace TestWebKitAPI {

TEST_F(FragmentedSharedBufferTest, createWithContentsOfMissingFile)
{
    auto buffer = SharedBuffer::createWithContentsOfFile(String("not_existing_file"));
    ASSERT_NULL(buffer);
}

TEST_F(FragmentedSharedBufferTest, createWithContentsOfExistingFile)
{
    auto buffer = SharedBuffer::createWithContentsOfFile(tempFilePath());
    ASSERT_NOT_NULL(buffer);
    EXPECT_TRUE(buffer->size() == strlen(FragmentedSharedBufferTest::testData()));
    EXPECT_TRUE(String(FragmentedSharedBufferTest::testData()) == String(buffer->makeContiguous()->data(), buffer->size()));
}

TEST_F(FragmentedSharedBufferTest, createWithContentsOfExistingEmptyFile)
{
    auto buffer = SharedBuffer::createWithContentsOfFile(tempEmptyFilePath());
    ASSERT_NOT_NULL(buffer);
    EXPECT_TRUE(buffer->isContiguous());
    EXPECT_TRUE(buffer->isEmpty());
}

TEST_F(FragmentedSharedBufferTest, copyBufferCreatedWithContentsOfExistingFile)
{
    auto buffer = SharedBuffer::createWithContentsOfFile(tempFilePath());
    ASSERT_NOT_NULL(buffer);
    EXPECT_TRUE(buffer->isContiguous());
    auto copy = buffer->copy();
    EXPECT_GT(buffer->size(), 0U);
    EXPECT_TRUE(buffer->size() == copy->size());
    EXPECT_TRUE(!memcmp(buffer->data(), copy->makeContiguous()->data(), buffer->size()));
}

TEST_F(FragmentedSharedBufferTest, appendBufferCreatedWithContentsOfExistingFile)
{
    RefPtr<FragmentedSharedBuffer> buffer = SharedBuffer::createWithContentsOfFile(tempFilePath());
    ASSERT_NOT_NULL(buffer);
    SharedBufferBuilder builder;
    builder.append(*buffer);
    builder.append("a", 1);
    EXPECT_TRUE(builder.size() == (strlen(FragmentedSharedBufferTest::testData()) + 1));
    EXPECT_TRUE(!memcmp(builder.get()->makeContiguous()->data(), FragmentedSharedBufferTest::testData(), strlen(FragmentedSharedBufferTest::testData())));
    EXPECT_EQ('a', builder.get()->makeContiguous()->data()[strlen(FragmentedSharedBufferTest::testData())]);
}

TEST_F(FragmentedSharedBufferTest, tryCreateArrayBuffer)
{
    RefPtr<SharedBuffer> buffer = SharedBuffer::createWithContentsOfFile(tempFilePath());
    ASSERT_NOT_NULL(buffer);
    buffer->append("a", 1);
    EXPECT_TRUE(buffer->size() == (strlen(SharedBufferTest::testData()) + 1));
    EXPECT_TRUE(!memcmp(buffer->data(), SharedBufferTest::testData(), strlen(SharedBufferTest::testData())));
    EXPECT_EQ('a', buffer->data()[strlen(SharedBufferTest::testData())]);
}

TEST_F(SharedBufferTest, tryCreateArrayBuffer)
{
    char testData0[] = "Hello";
    char testData1[] = "World";
    char testData2[] = "Goodbye";
    SharedBufferBuilder builder(testData0, strlen(testData0));
    builder.append(testData1, strlen(testData1));
    builder.append(testData2, strlen(testData2));
    RefPtr<ArrayBuffer> arrayBuffer = builder.get()->tryCreateArrayBuffer();
    char expectedConcatenation[] = "HelloWorldGoodbye";
    ASSERT_EQ(strlen(expectedConcatenation), arrayBuffer->byteLength());
    EXPECT_EQ(0, memcmp(expectedConcatenation, arrayBuffer->data(), strlen(expectedConcatenation)));
}

TEST_F(FragmentedSharedBufferTest, tryCreateArrayBufferLargeSegments)
{
    Vector<uint8_t> vector0(0x4000, 'a');
    Vector<uint8_t> vector1(0x4000, 'b');
    Vector<uint8_t> vector2(0x4000, 'c');

    SharedBufferBuilder builder(WTFMove(vector0));
    builder.append(WTFMove(vector1));
    builder.append(WTFMove(vector2));
    RefPtr<ArrayBuffer> arrayBuffer = builder.get()->tryCreateArrayBuffer();
    ASSERT_EQ(0x4000U + 0x4000U + 0x4000U, arrayBuffer->byteLength());
    int position = 0;
    for (int i = 0; i < 0x4000; ++i) {

    }
}

TEST_F(FragmentedSharedBufferTest, copy)
{
    char testData[] = "Habitasse integer eros tincidunt a scelerisque! Enim elit? Scelerisque magnis,"
    "et montes ultrices tristique a! Pid. Velit turpis, dapibus integer rhoncus sociis amet facilisis,"

    "mattis dignissim massa ac pulvinar urna, nunc ut. Sagittis, aliquet penatibus proin lorem, pulvinar lectus,"
    "augue proin! Ac, arcu quis. Placerat habitasse, ridiculus ridiculus.";
    unsigned length = strlen(testData);
    SharedBufferBuilder builder1(testData, length);
    builder1.append(testData, length);
    builder1.append(testData, length);
    builder1.append(testData, length);
    // sharedBuffer must contain data more than segmentSize (= 0x1000) to check copy().
    EXPECT_EQ(length * 4, builder1.size());
    RefPtr<FragmentedSharedBuffer> clone = builder1.copy();
    EXPECT_EQ(length * 4, clone->size());
    EXPECT_EQ(0, memcmp(clone->makeContiguous()->data(), builder1.get()->makeContiguous()->data(), clone->size()));

    SharedBufferBuilder builder2;
    builder2.append(*clone);
    builder2.append(testData, length);
    EXPECT_EQ(length * 5, builder2.size());
    auto buffer = builder2.take();
    EXPECT_EQ(length * 5, buffer->size());
    // builder is now empty.
    EXPECT_EQ(0U, builder2.size());
    EXPECT_TRUE(builder2.isNull());
    EXPECT_TRUE(builder2.isEmpty());
}

TEST_F(FragmentedSharedBufferTest, builder)
{
    char testData0[] = "Hello";
    SharedBufferBuilder builder1(testData0, strlen(testData0));
    EXPECT_FALSE(builder1.isNull());
    EXPECT_FALSE(builder1.isEmpty());
    auto copy = builder1.copy();
    auto buffer = builder1.take();
    EXPECT_TRUE(builder1.isNull());
    EXPECT_TRUE(builder1.isEmpty());
    EXPECT_NE(copy.ptr(), buffer.ptr()); // We have different FragmentedSharedBuffer
    EXPECT_EQ(copy.get(), buffer.get()); // But their content is identical

    SharedBufferBuilder builder2;
    EXPECT_TRUE(builder2.isNull());
    EXPECT_TRUE(builder2.isEmpty());
    builder2.append(testData0, strlen(testData0));
    EXPECT_FALSE(builder2.isNull());
    EXPECT_FALSE(builder2.isEmpty());
    builder2.reset();
    EXPECT_TRUE(builder2.isNull());
    EXPECT_TRUE(builder2.isEmpty());
    builder2.empty();
    EXPECT_FALSE(builder2.isNull());
    EXPECT_TRUE(builder2.isEmpty());
}

static void checkBuffer(const uint8_t* buffer, size_t bufferLength, const char* expected)

        EXPECT_EQ(buffer[i], expected[i]);
}

TEST_F(FragmentedSharedBufferTest, getSomeData)
{
    Vector<uint8_t> s1 = { 'a', 'b', 'c', 'd' };
    Vector<uint8_t> s2 = { 'e', 'f', 'g', 'h' };
    Vector<uint8_t> s3 = { 'i', 'j', 'k', 'l' };

    SharedBufferBuilder builder;
    builder.append(WTFMove(s1));
    builder.append(WTFMove(s2));
    builder.append(WTFMove(s3));
    auto buffer = builder.take();
    
    auto abcd = buffer->getSomeData(0);
    auto gh1 = buffer->getSomeData(6);
    auto h = buffer->getSomeData(7);
    auto ijkl = buffer->getSomeData(8);
    auto kl = buffer->getSomeData(10);
    auto contiguousBuffer = buffer->makeContiguous();
    auto abcdefghijkl = contiguousBuffer->data();
    auto gh2 = buffer->getSomeData(6);
    auto ghijkl = contiguousBuffer->getSomeData(6);
    auto l = buffer->getSomeData(11);
    checkBuffer(abcd.data(), abcd.size(), "abcd");
    checkBuffer(gh1.data(), gh1.size(), "gh");
    checkBuffer(h.data(), h.size(), "h");
    checkBuffer(ijkl.data(), ijkl.size(), "ijkl");
    checkBuffer(kl.data(), kl.size(), "kl");
    checkBuffer(abcdefghijkl, buffer->size(), "abcdefghijkl");
    checkBuffer(gh2.data(), gh2.size(), "gh");
    checkBuffer(ghijkl.data(), ghijkl.size(), "ghijkl");
    EXPECT_EQ(gh1.size(), gh2.size());
    checkBuffer(gh1.data(), gh1.size(), gh2.dataAsCharPtr());
    checkBuffer(l.data(), l.size(), "l");
}

TEST_F(FragmentedSharedBufferTest, isEqualTo)
{
    auto makeBuffer = [] (Vector<Vector<uint8_t>>&& contents) {
        SharedBufferBuilder builder;
        for (auto& content : contents)
            builder.append(WTFMove(content));
        return builder.take();
    };
    auto buffer1 = makeBuffer({ { 'a', 'b', 'c', 'd' } });
    EXPECT_EQ(buffer1.get(), buffer1.get());

    SharedBufferBuilder builder(WTFMove(buffer1));
    builder.append(Vector<uint8_t>({ 'a', 'b', 'c', 'd' }));
    EXPECT_EQ(*builder.get(), makeBuffer({ { 'a', 'b', 'c', 'd', 'a', 'b', 'c', 'd' } }).get());

    EXPECT_EQ(makeBuffer({ { 'a' }, { 'b', 'c' }, { 'd' } }).get(), makeBuffer({ { 'a', 'b' }, { 'c', 'd' } }).get());
    EXPECT_NE(makeBuffer({ { 'a', 'b' } }).get(), makeBuffer({ { 'a', 'b', 'c' } }).get());
    EXPECT_NE(makeBuffer({ { 'a', 'b' } }).get(), makeBuffer({ { 'b', 'c' } }).get());
    EXPECT_NE(makeBuffer({ { 'a' }, { 'b' } }).get(), makeBuffer({ { 'a' }, { 'a' } }).get());
}

TEST_F(FragmentedSharedBufferTest, toHexString)
{
    Vector<uint8_t> t1 = {0x11, 0x5, 0x12};
    SharedBufferBuilder builder;
    builder.append(WTFMove(t1));
    auto buffer = builder.take();
    String result = buffer->toHexString();
    EXPECT_EQ(result, "110512");
    builder.reset();
    buffer = builder.take();
    EXPECT_EQ(buffer->toHexString(), "");
}

TEST_F(FragmentedSharedBufferTest, read)
{
    const char* const simpleText = "This is a simple test.";

    auto check = [](FragmentedSharedBuffer& sharedBuffer) {
        Vector<uint8_t> data = sharedBuffer.read(4, 3);
        EXPECT_EQ(data.size(), 3u);
        EXPECT_EQ(String(data.data(), 3), " is");

    auto sharedBuffer = SharedBuffer::create(simpleText, strlen(simpleText));
    check(sharedBuffer);

    SharedBufferBuilder builder;
    for (size_t i = 0; i < strlen(simpleText); i++)
        builder.append(&simpleText[i], 1);
    check(builder.take());
    EXPECT_TRUE(builder.isNull() && !builder);
    EXPECT_EQ(builder.size(), 0u);

    sharedBuffer = SharedBuffer::create();
    for (size_t i = 0; i < strlen(simpleText); i += 2)
        builder.append(&simpleText[i], 2);
    EXPECT_EQ(builder.size(), strlen(simpleText));
    check(builder.take());
}

#if ENABLE(MHTML)

template< typename T, size_t N >
constexpr size_t arraysize( const T (&)[N] ) { return N; }

static void readAllChunks(std::vector<String>* chunks, FragmentedSharedBuffer& buffer, const String& separator = "\r\n", bool includeSeparator = false)
{
    SharedBufferChunkReader chunkReader(&buffer, separator.utf8().data());
    String chunk = chunkReader.nextChunkAsUTF8StringWithLatin1Fallback(includeSeparator);


TEST_F(SharedBufferChunkReaderTest, includeSeparator)
{
    auto check = [](FragmentedSharedBuffer& sharedBuffer) {
        SharedBufferChunkReader chunkReader(&sharedBuffer, "\x10\x11\x12");
        Vector<uint8_t> out;
        EXPECT_TRUE(chunkReader.nextChunk(out));

    uint8_t data[256];
    for (size_t i = 0; i < 256; ++i)
        data[i] = i;

    auto sharedBuffer = SharedBuffer::create(data, 256);
    check(sharedBuffer);

    SharedBufferBuilder builder(data, 256);
    check(builder.take());

    for (size_t i = 0; i < 256; ++i) {
        char c = i;
        builder.append(&c, 1);
    }
    check(builder.take());
}

TEST_F(SharedBufferChunkReaderTest, peekData)
{
    const char* const simpleText = "This is a simple test.";

    auto check = [](FragmentedSharedBuffer& sharedBuffer) {
        SharedBufferChunkReader chunkReader(&sharedBuffer, "is");

        String chunk = chunkReader.nextChunkAsUTF8StringWithLatin1Fallback();

    auto sharedBuffer = SharedBuffer::create(simpleText, strlen(simpleText));
    check(sharedBuffer);

    SharedBufferBuilder builder(simpleText, strlen(simpleText));
    check(builder.take());

    for (size_t i = 0; i < strlen(simpleText); i++)
        builder.append(&simpleText[i], 1);
    check(builder.take());

    sharedBuffer = SharedBuffer::create();
    for (size_t i = 0; i < strlen(simpleText); i += 2)
        builder.append(&simpleText[i], 2);
    EXPECT_EQ(builder.size(), strlen(simpleText));
    check(builder.take());
}

TEST_F(SharedBufferChunkReaderTest, readAllChunksInMultiSegment)
{
    const char* const simpleText = "This is the most ridiculous history there is.";
    auto check = [](FragmentedSharedBuffer& sharedBuffer) {
        std::vector<String> chunks;
        const char* const expectedChunks1WithoutSeparator[] = { "Th", "s ", "s the most r", "d", "culous h", "story there ", "s." };
        readAllChunks(&chunks, sharedBuffer, "i");

    };
    auto sharedBuffer = SharedBuffer::create(simpleText, strlen(simpleText));
    check(sharedBuffer);

    SharedBufferBuilder builder(simpleText, strlen(simpleText));
    check(builder.take());

    for (size_t i = 0; i < strlen(simpleText); i++)
        builder.append(&simpleText[i], 1);
    EXPECT_EQ(builder.size(), strlen(simpleText));
    check(builder.take());

    sharedBuffer = SharedBuffer::create();
    for (size_t i = 0; i < strlen(simpleText); i += 5)
        builder.append(&simpleText[i], 5);
    EXPECT_EQ(builder.size(), strlen(simpleText));
    check(builder.take());
}

TEST_F(SharedBufferChunkReaderTest, changingIterator)




namespace TestWebKitAPI {

void FragmentedSharedBufferTest::SetUp()
{
    WTF::initializeMainThread();


    FileSystem::closeFile(handle);
}

void FragmentedSharedBufferTest::TearDown()
{
    FileSystem::deleteFile(m_tempFilePath);
    FileSystem::deleteFile(m_tempEmptyFilePath);

Lines 29-35 a/Tools/TestWebKitAPI/Tests/WebCore/SharedBufferTest.h_sec1
- a/Tools/TestWebKitAPI/Tests/WebCore/SharedBufferTest.h -1 / +1 lines
29		29
30	namespace TestWebKitAPI {	30	namespace TestWebKitAPI {
31		31
32	class SharedBufferTest : public testing::Test {	32	class FragmentedSharedBufferTest : public testing::Test {
33	public:	33	public:
34	void SetUp() override;	34	void SetUp() override;
35	void TearDown() override;	35	void TearDown() override;

Lines 104-110 private: a/Tools/TestWebKitAPI/Tests/WebCore/cg/DisplayListTestsCG.cpp_sec1
- a/Tools/TestWebKitAPI/Tests/WebCore/cg/DisplayListTestsCG.cpp -1 / +1 lines
104	return { globalBufferIdentifier, globalItemBuffer, globalItemBufferCapacity };	104	return { globalBufferIdentifier, globalItemBuffer, globalItemBufferCapacity };
105	}	105	}
106		106
107	RefPtr<SharedBuffer> encodeItemOutOfLine(const DisplayListItem&) const final	107	RefPtr<FragmentedSharedBuffer> encodeItemOutOfLine(const DisplayListItem&) const final
108	{	108	{
109	return SharedBuffer::create();	109	return SharedBuffer::create();
110	}	110	}



/*
 * Copyright (C) 2017-2021 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions

    }
}

TEST_F(FragmentedSharedBufferTest, createNSDataArray)
{
    @autoreleasepool {
        SharedBufferBuilder builder;
        builder.empty();
        expectDataArraysEqual(nil, builder.get()->createNSDataArray().get());

        NSData *helloData = [NSData dataWithBytes:"hello" length:5];
        builder.append((const char*)helloData.bytes, helloData.length);
        expectDataArraysEqual(@[ helloData ], builder.get()->createNSDataArray().get());

        NSData *worldData = [NSData dataWithBytes:"world" length:5];
        builder.append((__bridge CFDataRef)worldData);
        expectDataArraysEqual(@[ helloData, worldData ], builder.get()->createNSDataArray().get());

        expectDataArraysEqual(@[ helloData ], SharedBuffer::create(helloData)->createNSDataArray().get());
        expectDataArraysEqual(@[ worldData ], SharedBuffer::create((__bridge CFDataRef)worldData)->createNSDataArray().get());

    }
}

TEST_F(FragmentedSharedBufferTest, createNSDataForDataSegment)
{
    @autoreleasepool {
        SharedBufferBuilder builder;

        NSData *helloData = [NSData dataWithBytes:"hello" length:5];
        builder.append((const char*)helloData.bytes, helloData.length);

        NSData *worldData = [NSData dataWithBytes:"world" length:5];
        builder.append((__bridge CFDataRef)worldData);

        NSArray *expectedData = @[ helloData, worldData ];
        NSUInteger expectedSize = helloData.length + worldData.length;

        NSUInteger segmentCount = 0;
        for (auto& segment : *builder.get())
            EXPECT_TRUE([segment.segment->createNSData() isEqualToData:expectedData[segmentCount++]]);
        EXPECT_EQ(expectedData.count, segmentCount);

        NSUInteger position = 0;
        segmentCount = 0;
        while (builder.size() > position) {
            auto incrementalData = builder.get()->getSomeData(position);
            EXPECT_TRUE([incrementalData.createNSData() isEqualToData:expectedData[segmentCount++]]);
            position += incrementalData.size();
        }
        EXPECT_EQ(expectedData.count, segmentCount);

        auto lastByte = builder.get()->getSomeData(expectedSize - 1);
        EXPECT_TRUE([lastByte.createNSData() isEqualToData:[@"d" dataUsingEncoding:NSASCIIStringEncoding]]);
        EXPECT_EQ(1LU, lastByte.size());
    }

Lines 25-31 a/Tools/TestWebKitAPI/win/TestWebCoreStubs.cpp_sec1
- a/Tools/TestWebKitAPI/win/TestWebCoreStubs.cpp -1 / +1 lines
25		25
26	#include <WebCore/SharedBuffer.h>	26	#include <WebCore/SharedBuffer.h>
27		27
28	RefPtr<WebCore::SharedBuffer> loadResourceIntoBuffer(const char*)	28	RefPtr<WebCore::FragmentedSharedBuffer> loadResourceIntoBuffer(const char*)
29	{	29	{
30	return nullptr;	30	return nullptr;
31	}	31	}

Return to Bug 233923

Lines 686-692 bool SQLiteIDBBackingStore::addExistingIndex(IDBObjectStoreInfo& objectStoreInfo a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp_sec1
- a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp -14 / +14 lines
686	SQLiteTransaction transaction(*m_sqliteDB);	686	SQLiteTransaction transaction(*m_sqliteDB);
687	transaction.begin();	687	transaction.begin();
688		688
689	RefPtr<SharedBuffer> keyPathBlob = serializeIDBKeyPath(info.keyPath());	689	auto keyPathBlob = serializeIDBKeyPath(info.keyPath());
690	if (!keyPathBlob) {	690	if (!keyPathBlob) {
691	LOG_ERROR("Unable to serialize IDBKeyPath to save in database");	691	LOG_ERROR("Unable to serialize IDBKeyPath to save in database");
692	return false;	692	return false;
Lines 1174-1180 IDBError SQLiteIDBBackingStore::createObjectStore(const IDBResourceIdentifier& t a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp_sec2
1174	return IDBError { UnknownError, "Attempt to create an object store in a non-version-change transaction"_s };	1174	return IDBError { UnknownError, "Attempt to create an object store in a non-version-change transaction"_s };
1175	}	1175	}
1176		1176
1177	RefPtr<SharedBuffer> keyPathBlob = serializeIDBKeyPath(info.keyPath());	1177	auto keyPathBlob = serializeIDBKeyPath(info.keyPath());
1178	if (!keyPathBlob) {	1178	if (!keyPathBlob) {
1179	LOG_ERROR("Unable to serialize IDBKeyPath to save in database for new object store");	1179	LOG_ERROR("Unable to serialize IDBKeyPath to save in database for new object store");
1180	return IDBError { UnknownError, "Unable to serialize IDBKeyPath to save in database for new object store"_s };	1180	return IDBError { UnknownError, "Unable to serialize IDBKeyPath to save in database for new object store"_s };
Lines 1387-1393 IDBError SQLiteIDBBackingStore::createIndex(const IDBResourceIdentifier& transac a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp_sec3
1387	return IDBError { UnknownError, "Attempt to create an index in a non-version-change transaction"_s };	1387	return IDBError { UnknownError, "Attempt to create an index in a non-version-change transaction"_s };
1388	}	1388	}
1389		1389
1390	RefPtr<SharedBuffer> keyPathBlob = serializeIDBKeyPath(info.keyPath());	1390	auto keyPathBlob = serializeIDBKeyPath(info.keyPath());
1391	if (!keyPathBlob) {	1391	if (!keyPathBlob) {
1392	LOG_ERROR("Unable to serialize IDBKeyPath to save in database");	1392	LOG_ERROR("Unable to serialize IDBKeyPath to save in database");
1393	return IDBError { UnknownError, "Unable to serialize IDBKeyPath to create index in database"_s };	1393	return IDBError { UnknownError, "Unable to serialize IDBKeyPath to create index in database"_s };
Lines 1464-1470 IDBError SQLiteIDBBackingStore::uncheckedHasIndexRecord(const IDBIndexInfo& info a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp_sec4
1464	{	1464	{
1465	hasRecord = false;	1465	hasRecord = false;
1466		1466
1467	RefPtr<SharedBuffer> indexKeyBuffer = serializeIDBKeyData(indexKey);	1467	auto indexKeyBuffer = serializeIDBKeyData(indexKey);
1468	if (!indexKeyBuffer) {	1468	if (!indexKeyBuffer) {
1469	LOG_ERROR("Unable to serialize index key to be stored in the database");	1469	LOG_ERROR("Unable to serialize index key to be stored in the database");
1470	return IDBError { UnknownError, "Unable to serialize IDBKey to check for index record in database"_s };	1470	return IDBError { UnknownError, "Unable to serialize IDBKey to check for index record in database"_s };
Lines 1533-1545 IDBError SQLiteIDBBackingStore::uncheckedPutIndexRecord(int64_t objectStoreID, i a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp_sec5
1533	{	1533	{
1534	LOG(IndexedDB, "SQLiteIDBBackingStore::uncheckedPutIndexRecord - %s, %s", keyValue.loggingString().utf8().data(), indexKey.loggingString().utf8().data());	1534	LOG(IndexedDB, "SQLiteIDBBackingStore::uncheckedPutIndexRecord - %s, %s", keyValue.loggingString().utf8().data(), indexKey.loggingString().utf8().data());
1535		1535
1536	RefPtr<SharedBuffer> indexKeyBuffer = serializeIDBKeyData(indexKey);	1536	auto indexKeyBuffer = serializeIDBKeyData(indexKey);
1537	if (!indexKeyBuffer) {	1537	if (!indexKeyBuffer) {
1538	LOG_ERROR("Unable to serialize index key to be stored in the database");	1538	LOG_ERROR("Unable to serialize index key to be stored in the database");
1539	return IDBError { UnknownError, "Unable to serialize index key to be stored in the database"_s };	1539	return IDBError { UnknownError, "Unable to serialize index key to be stored in the database"_s };
1540	}	1540	}
1541		1541
1542	RefPtr<SharedBuffer> valueBuffer = serializeIDBKeyData(keyValue);	1542	auto valueBuffer = serializeIDBKeyData(keyValue);
1543	if (!valueBuffer) {	1543	if (!valueBuffer) {
1544	LOG_ERROR("Unable to serialize the value to be stored in the database");	1544	LOG_ERROR("Unable to serialize the value to be stored in the database");
1545	return IDBError { UnknownError, "Unable to serialize value to be stored in the database"_s };	1545	return IDBError { UnknownError, "Unable to serialize value to be stored in the database"_s };
Lines 1661-1667 IDBError SQLiteIDBBackingStore::keyExistsInObjectStore(const IDBResourceIdentifi a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp_sec6
1661	if (!transaction \|\| !transaction->inProgress())	1661	if (!transaction \|\| !transaction->inProgress())
1662	return IDBError { UnknownError, "Attempt to see if key exists in objectstore without an in-progress transaction"_s };	1662	return IDBError { UnknownError, "Attempt to see if key exists in objectstore without an in-progress transaction"_s };
1663		1663
1664	RefPtr<SharedBuffer> keyBuffer = serializeIDBKeyData(keyData);	1664	auto keyBuffer = serializeIDBKeyData(keyData);
1665	if (!keyBuffer) {	1665	if (!keyBuffer) {
1666	LOG_ERROR("Unable to serialize IDBKey to check for existence in object store");	1666	LOG_ERROR("Unable to serialize IDBKey to check for existence in object store");
1667	return IDBError { UnknownError, "Unable to serialize IDBKey to check for existence in object store"_s };	1667	return IDBError { UnknownError, "Unable to serialize IDBKey to check for existence in object store"_s };
Lines 1741-1747 IDBError SQLiteIDBBackingStore::deleteRecord(SQLiteIDBTransaction& transaction, a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp_sec7
1741	ASSERT(transaction.mode() != IDBTransactionMode::Readonly);	1741	ASSERT(transaction.mode() != IDBTransactionMode::Readonly);
1742	UNUSED_PARAM(transaction);	1742	UNUSED_PARAM(transaction);
1743		1743
1744	RefPtr<SharedBuffer> keyBuffer = serializeIDBKeyData(keyData);	1744	auto keyBuffer = serializeIDBKeyData(keyData);
1745	if (!keyBuffer) {	1745	if (!keyBuffer) {
1746	LOG_ERROR("Unable to serialize IDBKeyData to be removed from the database");	1746	LOG_ERROR("Unable to serialize IDBKeyData to be removed from the database");
1747	return IDBError { UnknownError, "Unable to serialize IDBKeyData to be removed from the database"_s };	1747	return IDBError { UnknownError, "Unable to serialize IDBKeyData to be removed from the database"_s };
Lines 1962-1968 IDBError SQLiteIDBBackingStore::addRecord(const IDBResourceIdentifier& transacti a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp_sec8
1962	return IDBError { UnknownError, "Attempt to store a record in an object store in a read-only transaction"_s };	1962	return IDBError { UnknownError, "Attempt to store a record in an object store in a read-only transaction"_s };
1963	}	1963	}
1964		1964
1965	RefPtr<SharedBuffer> keyBuffer = serializeIDBKeyData(keyData);	1965	auto keyBuffer = serializeIDBKeyData(keyData);
1966	if (!keyBuffer) {	1966	if (!keyBuffer) {
1967	LOG_ERROR("Unable to serialize IDBKey to be stored in an object store");	1967	LOG_ERROR("Unable to serialize IDBKey to be stored in an object store");
1968	return IDBError { UnknownError, "Unable to serialize IDBKey to be stored in an object store"_s };	1968	return IDBError { UnknownError, "Unable to serialize IDBKey to be stored in an object store"_s };
Lines 2124-2130 IDBError SQLiteIDBBackingStore::getRecord(const IDBResourceIdentifier& transacti a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp_sec9
2124	auto key = keyRange.lowerKey;	2124	auto key = keyRange.lowerKey;
2125	if (key.isNull())	2125	if (key.isNull())
2126	key = IDBKeyData::minimum();	2126	key = IDBKeyData::minimum();
2127	RefPtr<SharedBuffer> lowerBuffer = serializeIDBKeyData(key);	2127	auto lowerBuffer = serializeIDBKeyData(key);
2128	if (!lowerBuffer) {	2128	if (!lowerBuffer) {
2129	LOG_ERROR("Unable to serialize lower IDBKey in lookup range");	2129	LOG_ERROR("Unable to serialize lower IDBKey in lookup range");
2130	return IDBError { UnknownError, "Unable to serialize lower IDBKey in lookup range"_s };	2130	return IDBError { UnknownError, "Unable to serialize lower IDBKey in lookup range"_s };
Lines 2133-2139 IDBError SQLiteIDBBackingStore::getRecord(const IDBResourceIdentifier& transacti a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp_sec10
2133	key = keyRange.upperKey;	2133	key = keyRange.upperKey;
2134	if (key.isNull())	2134	if (key.isNull())
2135	key = IDBKeyData::maximum();	2135	key = IDBKeyData::maximum();
2136	RefPtr<SharedBuffer> upperBuffer = serializeIDBKeyData(key);	2136	auto upperBuffer = serializeIDBKeyData(key);
2137	if (!upperBuffer) {	2137	if (!upperBuffer) {
2138	LOG_ERROR("Unable to serialize upper IDBKey in lookup range");	2138	LOG_ERROR("Unable to serialize upper IDBKey in lookup range");
2139	return IDBError { UnknownError, "Unable to serialize upper IDBKey in lookup range"_s };	2139	return IDBError { UnknownError, "Unable to serialize upper IDBKey in lookup range"_s };
Lines 2443-2449 IDBError SQLiteIDBBackingStore::uncheckedGetIndexRecordForOneKey(int64_t indexID a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp_sec11
2443		2443
2444	ASSERT(key.isValid() && key.type() != IndexedDB::KeyType::Max && key.type() != IndexedDB::KeyType::Min);	2444	ASSERT(key.isValid() && key.type() != IndexedDB::KeyType::Max && key.type() != IndexedDB::KeyType::Min);
2445		2445
2446	RefPtr<SharedBuffer> buffer = serializeIDBKeyData(key);	2446	auto buffer = serializeIDBKeyData(key);
2447	if (!buffer) {	2447	if (!buffer) {
2448	LOG_ERROR("Unable to serialize IDBKey to look up one index record");	2448	LOG_ERROR("Unable to serialize IDBKey to look up one index record");
2449	return IDBError { UnknownError, "Unable to serialize IDBKey to look up one index record"_s };	2449	return IDBError { UnknownError, "Unable to serialize IDBKey to look up one index record"_s };
Lines 2508-2521 IDBError SQLiteIDBBackingStore::getCount(const IDBResourceIdentifier& transactio a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp_sec12
2508	outCount = 0;	2508	outCount = 0;
2509		2509
2510	auto lowerKey = range.lowerKey.isNull() ? IDBKeyData::minimum() : range.lowerKey;	2510	auto lowerKey = range.lowerKey.isNull() ? IDBKeyData::minimum() : range.lowerKey;
2511	RefPtr<SharedBuffer> lowerBuffer = serializeIDBKeyData(lowerKey);	2511	auto lowerBuffer = serializeIDBKeyData(lowerKey);
2512	if (!lowerBuffer) {	2512	if (!lowerBuffer) {
2513	LOG_ERROR("Unable to serialize lower IDBKey in lookup range");	2513	LOG_ERROR("Unable to serialize lower IDBKey in lookup range");
2514	return IDBError { UnknownError, "Unable to serialize lower IDBKey in lookup range for count operation"_s };	2514	return IDBError { UnknownError, "Unable to serialize lower IDBKey in lookup range for count operation"_s };
2515	}	2515	}
2516		2516
2517	auto upperKey = range.upperKey.isNull() ? IDBKeyData::maximum() : range.upperKey;	2517	auto upperKey = range.upperKey.isNull() ? IDBKeyData::maximum() : range.upperKey;
2518	RefPtr<SharedBuffer> upperBuffer = serializeIDBKeyData(upperKey);	2518	auto upperBuffer = serializeIDBKeyData(upperKey);
2519	if (!upperBuffer) {	2519	if (!upperBuffer) {
2520	LOG_ERROR("Unable to serialize upper IDBKey in lookup range");	2520	LOG_ERROR("Unable to serialize upper IDBKey in lookup range");
2521	return IDBError { UnknownError, "Unable to serialize upper IDBKey in lookup range for count operation"_s };	2521	return IDBError { UnknownError, "Unable to serialize upper IDBKey in lookup range for count operation"_s };

Lines 1-3 a/PerformanceTests/ChangeLog_sec1
- a/PerformanceTests/ChangeLog +10 lines
		1	2021-12-02 Jean-Yves Avenard <jya@apple.com>
		2
		3	Distinguish contiguous SharedBuffer from non-contiguous one and guarantee immutability: part 3
		4	https://bugs.webkit.org/show_bug.cgi?id=233677
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* DecoderTest/DecoderTest/main.mm:
		9	(main):
		10
1	2021-11-21 Cathie Chen <cathiechen@igalia.com>	11	2021-11-21 Cathie Chen <cathiechen@igalia.com>
2		12
3	[Performance test][css-contain] Add case to test contain: layout inside a complex document	13	[Performance test][css-contain] Add case to test contain: layout inside a complex document

Lines 1-3 a/Source/JavaScriptCore/ChangeLog_sec1
- a/Source/JavaScriptCore/ChangeLog +14 lines
		1	2021-12-03 Jean-Yves Avenard <jya@apple.com>
		2
		3	Rename SharedBuffer classes.
		4	https://bugs.webkit.org/show_bug.cgi?id=233677
		5	rdar://problem/85963900
		6
		7	Reviewed by NOBODY (OOPS!).
		8
		9	SharedBuffer are renamed FragmentedSharedBuffer and
		10	ContiguousSharedBuffer to SharedBuffer to better reflect their actual
		11	types.
		12
		13	* runtime/ArrayBuffer.h:
		14
1	2021-12-03 Keith Miller <keith_miller@apple.com>	15	2021-12-03 Keith Miller <keith_miller@apple.com>
2		16
3	Remove StructureIDBlob	17	Remove StructureIDBlob

Lines 216-223 void ClipboardItemBindingsDataSource::invokeCompletionHandler() a/Source/WebCore/Modules/async-clipboard/ClipboardItemBindingsDataSource.cpp_sec1
- a/Source/WebCore/Modules/async-clipboard/ClipboardItemBindingsDataSource.cpp -8 / +8 lines
216	auto& data = itemTypeLoader->data();	216	auto& data = itemTypeLoader->data();
217	if (std::holds_alternative<String>(data) && !!std::get<String>(data))	217	if (std::holds_alternative<String>(data) && !!std::get<String>(data))
218	customData.writeString(type, std::get<String>(data));	218	customData.writeString(type, std::get<String>(data));
219	else if (std::holds_alternative<Ref<SharedBuffer>>(data))	219	else if (std::holds_alternative<Ref<FragmentedSharedBuffer>>(data))
220	customData.writeData(type, std::get<Ref<SharedBuffer>>(data).copyRef());	220	customData.writeData(type, std::get<Ref<FragmentedSharedBuffer>>(data).copyRef());
221	else {	221	else {
222	completionHandler(std::nullopt);	222	completionHandler(std::nullopt);
223	return;	223	return;
Lines 265-273 void ClipboardItemBindingsDataSource::ClipboardItemTypeLoader::sanitizeDataIfNee a/Source/WebCore/Modules/async-clipboard/ClipboardItemBindingsDataSource.cpp_sec2
265	{	265	{
266	if (m_type == "text/html"_s) {	266	if (m_type == "text/html"_s) {
267	String markupToSanitize;	267	String markupToSanitize;
268	if (std::holds_alternative<Ref<SharedBuffer>>(m_data)) {	268	if (std::holds_alternative<Ref<FragmentedSharedBuffer>>(m_data)) {
269	auto& buffer = std::get<Ref<SharedBuffer>>(m_data);	269	auto& buffer = std::get<Ref<FragmentedSharedBuffer>>(m_data);
270	markupToSanitize = String::fromUTF8(buffer->data(), buffer->size());	270	markupToSanitize = String::fromUTF8(buffer->makeContiguous()->data(), buffer->size());
271	} else if (std::holds_alternative<String>(m_data))	271	} else if (std::holds_alternative<String>(m_data))
272	markupToSanitize = std::get<String>(m_data);	272	markupToSanitize = std::get<String>(m_data);
273		273
Lines 278-286 void ClipboardItemBindingsDataSource::ClipboardItemTypeLoader::sanitizeDataIfNee a/Source/WebCore/Modules/async-clipboard/ClipboardItemBindingsDataSource.cpp_sec3
278	}	278	}
279		279
280	if (m_type == "image/png"_s) {	280	if (m_type == "image/png"_s) {
281	RefPtr<SharedBuffer> bufferToSanitize;	281	RefPtr<FragmentedSharedBuffer> bufferToSanitize;
282	if (std::holds_alternative<Ref<SharedBuffer>>(m_data))	282	if (std::holds_alternative<Ref<FragmentedSharedBuffer>>(m_data))
283	bufferToSanitize = std::get<Ref<SharedBuffer>>(m_data).ptr();	283	bufferToSanitize = std::get<Ref<FragmentedSharedBuffer>>(m_data).ptr();
284	else if (std::holds_alternative<String>(m_data))	284	else if (std::holds_alternative<String>(m_data))
285	bufferToSanitize = utf8Buffer(std::get<String>(m_data));	285	bufferToSanitize = utf8Buffer(std::get<String>(m_data));
286		286

Lines 38-44 class DOMPromise; a/Source/WebCore/Modules/async-clipboard/ClipboardItemBindingsDataSource.h_sec1
- a/Source/WebCore/Modules/async-clipboard/ClipboardItemBindingsDataSource.h -2 / +2 lines
38	class FileReaderLoader;	38	class FileReaderLoader;
39	class PasteboardCustomData;	39	class PasteboardCustomData;
40	class ScriptExecutionContext;	40	class ScriptExecutionContext;
41	class SharedBuffer;	41	class FragmentedSharedBuffer;
42		42
43	class ClipboardItemBindingsDataSource : public ClipboardItemDataSource {	43	class ClipboardItemBindingsDataSource : public ClipboardItemDataSource {
44	WTF_MAKE_FAST_ALLOCATED;	44	WTF_MAKE_FAST_ALLOCATED;
Lines 53-59 private: a/Source/WebCore/Modules/async-clipboard/ClipboardItemBindingsDataSource.h_sec2
53		53
54	void invokeCompletionHandler();	54	void invokeCompletionHandler();
55		55
56	using BufferOrString = std::variant<String, Ref<SharedBuffer>>;	56	using BufferOrString = std::variant<String, Ref<FragmentedSharedBuffer>>;
57	class ClipboardItemTypeLoader : public FileReaderLoaderClient, public RefCounted<ClipboardItemTypeLoader> {	57	class ClipboardItemTypeLoader : public FileReaderLoaderClient, public RefCounted<ClipboardItemTypeLoader> {
58	public:	58	public:
59	static Ref<ClipboardItemTypeLoader> create(const String& type, CompletionHandler<void()>&& completionHandler)	59	static Ref<ClipboardItemTypeLoader> create(const String& type, CompletionHandler<void()>&& completionHandler)

Lines 289-295 void DOMCache::addAll(Vector<RequestInfo>&& infos, DOMPromiseDeferred<void>&& pr a/Source/WebCore/Modules/cache/DOMCache.cpp_sec1
- a/Source/WebCore/Modules/cache/DOMCache.cpp -7 / +7 lines
289	}	289	}
290	size_t recordPosition = taskHandler->addRecord(toConnectionRecord(request.get(), response, nullptr));	290	size_t recordPosition = taskHandler->addRecord(toConnectionRecord(request.get(), response, nullptr));
291		291
292	response.consumeBodyReceivedByChunk([taskHandler = WTFMove(taskHandler), recordPosition, data = SharedBuffer::create(), response = Ref { response }] (auto&& result) mutable {	292	response.consumeBodyReceivedByChunk([taskHandler = WTFMove(taskHandler), recordPosition, data = SharedBufferBuilder(), response = Ref { response }] (auto&& result) mutable {
293	if (taskHandler->isDone())	293	if (taskHandler->isDone())
294	return;	294	return;
295		295
Lines 299-307 void DOMCache::addAll(Vector<RequestInfo>&& infos, DOMPromiseDeferred<void>&& pr a/Source/WebCore/Modules/cache/DOMCache.cpp_sec2
299	}	299	}
300		300
301	if (auto* chunk = result.returnValue())	301	if (auto* chunk = result.returnValue())
302	data->append(chunk->data(), chunk->size());	302	data.append(chunk->data(), chunk->size());
303	else	303	else
304	taskHandler->addResponseBody(recordPosition, response, WTFMove(data));	304	taskHandler->addResponseBody(recordPosition, response, data.take()->makeContiguous());
305	});	305	});
306	}, cachedResourceRequestInitiators().fetch);	306	}, cachedResourceRequestInitiators().fetch);
307	}	307	}
Lines 318-324 void DOMCache::putWithResponseData(DOMPromiseDeferred<void>&& promise, Ref<Fetch a/Source/WebCore/Modules/cache/DOMCache.cpp_sec3
318		318
319	DOMCacheEngine::ResponseBody body;	319	DOMCacheEngine::ResponseBody body;
320	if (auto buffer = responseBody.releaseReturnValue())	320	if (auto buffer = responseBody.releaseReturnValue())
321	body = buffer.releaseNonNull();	321	body = buffer->makeContiguous();
322	batchPutOperation(request.get(), response.get(), WTFMove(body), [this, protectedThis = Ref { *this }, promise = WTFMove(promise)](ExceptionOr<void>&& result) mutable {	322	batchPutOperation(request.get(), response.get(), WTFMove(body), [this, protectedThis = Ref { *this }, promise = WTFMove(promise)](ExceptionOr<void>&& result) mutable {
323	queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [promise = WTFMove(promise), result = WTFMove(result)]() mutable {	323	queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [promise = WTFMove(promise), result = WTFMove(result)]() mutable {
324	promise.settle(WTFMove(result));	324	promise.settle(WTFMove(result));
Lines 375-381 void DOMCache::put(RequestInfo&& info, Ref<FetchResponse>&& response, DOMPromise a/Source/WebCore/Modules/cache/DOMCache.cpp_sec4
375		375
376	if (response->isBodyReceivedByChunk()) {	376	if (response->isBodyReceivedByChunk()) {
377	auto& responseRef = response.get();	377	auto& responseRef = response.get();
378	responseRef.consumeBodyReceivedByChunk([promise = WTFMove(promise), request = WTFMove(request), response = WTFMove(response), data = SharedBuffer::create(), pendingActivity = makePendingActivity(*this), this](auto&& result) mutable {	378	responseRef.consumeBodyReceivedByChunk([promise = WTFMove(promise), request = WTFMove(request), response = WTFMove(response), data = SharedBufferBuilder(), pendingActivity = makePendingActivity(*this), this](auto&& result) mutable {
379		379
380	if (result.hasException()) {	380	if (result.hasException()) {
381	this->putWithResponseData(WTFMove(promise), WTFMove(request), WTFMove(response), result.releaseException().isolatedCopy());	381	this->putWithResponseData(WTFMove(promise), WTFMove(request), WTFMove(response), result.releaseException().isolatedCopy());
Lines 383-391 void DOMCache::put(RequestInfo&& info, Ref<FetchResponse>&& response, DOMPromise a/Source/WebCore/Modules/cache/DOMCache.cpp_sec5
383	}	383	}
384		384
385	if (auto* chunk = result.returnValue())	385	if (auto* chunk = result.returnValue())
386	data->append(chunk->data(), chunk->size());	386	data.append(chunk->data(), chunk->size());
387	else	387	else
388	this->putWithResponseData(WTFMove(promise), WTFMove(request), WTFMove(response), RefPtr<SharedBuffer> { WTFMove(data) });	388	this->putWithResponseData(WTFMove(promise), WTFMove(request), WTFMove(response), RefPtr<SharedBuffer> { data.take()->makeContiguous() });
389	});	389	});
390	return;	390	return;
391	}	391	}

Lines 135-151 bool CDM::supportsInitDataType(const AtomString& initDataType) const a/Source/WebCore/Modules/encryptedmedia/CDM.cpp_sec1
- a/Source/WebCore/Modules/encryptedmedia/CDM.cpp -3 / +3 lines
135	return m_private && m_private->supportedInitDataTypes().contains(initDataType);	135	return m_private && m_private->supportedInitDataTypes().contains(initDataType);
136	}	136	}
137		137
138	RefPtr<SharedBuffer> CDM::sanitizeInitData(const AtomString& initDataType, const SharedBuffer& initData)	138	RefPtr<FragmentedSharedBuffer> CDM::sanitizeInitData(const AtomString& initDataType, const FragmentedSharedBuffer& initData)
139	{	139	{
140	return InitDataRegistry::shared().sanitizeInitData(initDataType, initData);	140	return InitDataRegistry::shared().sanitizeInitData(initDataType, initData);
141	}	141	}
142		142
143	bool CDM::supportsInitData(const AtomString& initDataType, const SharedBuffer& initData)	143	bool CDM::supportsInitData(const AtomString& initDataType, const FragmentedSharedBuffer& initData)
144	{	144	{
145	return m_private && m_private->supportsInitData(initDataType, initData);	145	return m_private && m_private->supportsInitData(initDataType, initData);
146	}	146	}
147		147
148	RefPtr<SharedBuffer> CDM::sanitizeResponse(const SharedBuffer& response)	148	RefPtr<FragmentedSharedBuffer> CDM::sanitizeResponse(const FragmentedSharedBuffer& response)
149	{	149	{
150	if (!m_private)	150	if (!m_private)
151	return nullptr;	151	return nullptr;

Lines 52-58 class CDMInstance; a/Source/WebCore/Modules/encryptedmedia/CDM.h_sec1
- a/Source/WebCore/Modules/encryptedmedia/CDM.h -4 / +4 lines
52	class CDMPrivate;	52	class CDMPrivate;
53	class Document;	53	class Document;
54	class ScriptExecutionContext;	54	class ScriptExecutionContext;
55	class SharedBuffer;	55	class FragmentedSharedBuffer;
56		56
57	class CDM : public RefCounted<CDM>, public CanMakeWeakPtr<CDM>, private ContextDestructionObserver {	57	class CDM : public RefCounted<CDM>, public CanMakeWeakPtr<CDM>, private ContextDestructionObserver {
58	public:	58	public:
Lines 73-82 public: a/Source/WebCore/Modules/encryptedmedia/CDM.h_sec2
73	bool supportsSessions() const;	73	bool supportsSessions() const;
74	bool supportsInitDataType(const AtomString&) const;	74	bool supportsInitDataType(const AtomString&) const;
75		75
76	RefPtr<SharedBuffer> sanitizeInitData(const AtomString& initDataType, const SharedBuffer&);	76	RefPtr<FragmentedSharedBuffer> sanitizeInitData(const AtomString& initDataType, const FragmentedSharedBuffer&);
77	bool supportsInitData(const AtomString& initDataType, const SharedBuffer&);	77	bool supportsInitData(const AtomString& initDataType, const FragmentedSharedBuffer&);
78		78
79	RefPtr<SharedBuffer> sanitizeResponse(const SharedBuffer&);	79	RefPtr<FragmentedSharedBuffer> sanitizeResponse(const FragmentedSharedBuffer&);
80		80
81	std::optional<String> sanitizeSessionId(const String& sessionId);	81	std::optional<String> sanitizeSessionId(const String& sessionId);
82		82

Lines 54-66 namespace { a/Source/WebCore/Modules/encryptedmedia/InitDataRegistry.cpp_sec1
- a/Source/WebCore/Modules/encryptedmedia/InitDataRegistry.cpp -15 / +15 lines
54	const uint32_t kKeyIdsMaxKeyIdSizeInBytes = 512;	54	const uint32_t kKeyIdsMaxKeyIdSizeInBytes = 512;
55	}	55	}
56		56
57	static std::optional<Vector<Ref<SharedBuffer>>> extractKeyIDsKeyids(const SharedBuffer& buffer)	57	static std::optional<Vector<Ref<FragmentedSharedBuffer>>> extractKeyIDsKeyids(const FragmentedSharedBuffer& buffer)
58	{	58	{
59	// 1. Format	59	// 1. Format
60	// https://w3c.github.io/encrypted-media/format-registry/initdata/keyids.html#format	60	// https://w3c.github.io/encrypted-media/format-registry/initdata/keyids.html#format
61	if (buffer.size() > std::numeric_limits<unsigned>::max())	61	if (buffer.size() > std::numeric_limits<unsigned>::max())
62	return std::nullopt;	62	return std::nullopt;
63	String json { buffer.data(), static_cast<unsigned>(buffer.size()) };	63	String json { buffer.makeContiguous()->data(), static_cast<unsigned>(buffer.size()) };
64		64
65	auto value = JSON::Value::parseJSON(json);	65	auto value = JSON::Value::parseJSON(json);
66	if (!value)	66	if (!value)
Lines 74-80 static std::optional<Vector<Ref<SharedBuffer>>> extractKeyIDsKeyids(const Shared a/Source/WebCore/Modules/encryptedmedia/InitDataRegistry.cpp_sec2
74	if (!kidsArray)	74	if (!kidsArray)
75	return std::nullopt;	75	return std::nullopt;
76		76
77	Vector<Ref<SharedBuffer>> keyIDs;	77	Vector<Ref<FragmentedSharedBuffer>> keyIDs;
78	for (auto& value : *kidsArray) {	78	for (auto& value : *kidsArray) {
79	auto keyID = value->asString();	79	auto keyID = value->asString();
80	if (!keyID)	80	if (!keyID)
Lines 93-99 static std::optional<Vector<Ref<SharedBuffer>>> extractKeyIDsKeyids(const Shared a/Source/WebCore/Modules/encryptedmedia/InitDataRegistry.cpp_sec3
93	return keyIDs;	93	return keyIDs;
94	}	94	}
95		95
96	static RefPtr<SharedBuffer> sanitizeKeyids(const SharedBuffer& buffer)	96	static RefPtr<FragmentedSharedBuffer> sanitizeKeyids(const FragmentedSharedBuffer& buffer)
97	{	97	{
98	// 1. Format	98	// 1. Format
99	// https://w3c.github.io/encrypted-media/format-registry/initdata/keyids.html#format	99	// https://w3c.github.io/encrypted-media/format-registry/initdata/keyids.html#format
Lines 104-117 static RefPtr<SharedBuffer> sanitizeKeyids(const SharedBuffer& buffer) a/Source/WebCore/Modules/encryptedmedia/InitDataRegistry.cpp_sec4
104	auto object = JSON::Object::create();	104	auto object = JSON::Object::create();
105	auto kidsArray = JSON::Array::create();	105	auto kidsArray = JSON::Array::create();
106	for (auto& buffer : keyIDBuffer.value())	106	for (auto& buffer : keyIDBuffer.value())
107	kidsArray->pushString(base64URLEncodeToString(buffer->data(), buffer->size()));	107	kidsArray->pushString(base64URLEncodeToString(buffer->makeContiguous()->data(), buffer->size()));
108	object->setArray("kids", WTFMove(kidsArray));	108	object->setArray("kids", WTFMove(kidsArray));
109		109
110	CString jsonData = object->toJSONString().utf8();	110	CString jsonData = object->toJSONString().utf8();
111	return SharedBuffer::create(jsonData.data(), jsonData.length());	111	return SharedBuffer::create(jsonData.data(), jsonData.length());
112	}	112	}
113		113
114	std::optional<Vector<std::unique_ptr<ISOProtectionSystemSpecificHeaderBox>>> InitDataRegistry::extractPsshBoxesFromCenc(const SharedBuffer& buffer)	114	std::optional<Vector<std::unique_ptr<ISOProtectionSystemSpecificHeaderBox>>> InitDataRegistry::extractPsshBoxesFromCenc(const FragmentedSharedBuffer& buffer)
115	{	115	{
116	// 4. Common SystemID and PSSH Box Format	116	// 4. Common SystemID and PSSH Box Format
117	// https://w3c.github.io/encrypted-media/format-registry/initdata/cenc.html#common-system	117	// https://w3c.github.io/encrypted-media/format-registry/initdata/cenc.html#common-system
Lines 151-159 std::optional<Vector<std::unique_ptr<ISOProtectionSystemSpecificHeaderBox>>> Ini a/Source/WebCore/Modules/encryptedmedia/InitDataRegistry.cpp_sec5
151	return psshBoxes;	151	return psshBoxes;
152	}	152	}
153		153
154	std::optional<Vector<Ref<SharedBuffer>>> InitDataRegistry::extractKeyIDsCenc(const SharedBuffer& buffer)	154	std::optional<Vector<Ref<FragmentedSharedBuffer>>> InitDataRegistry::extractKeyIDsCenc(const FragmentedSharedBuffer& buffer)
155	{	155	{
156	Vector<Ref<SharedBuffer>> keyIDs;	156	Vector<Ref<FragmentedSharedBuffer>> keyIDs;
157		157
158	auto psshBoxes = extractPsshBoxesFromCenc(buffer);	158	auto psshBoxes = extractPsshBoxesFromCenc(buffer);
159	if (!psshBoxes)	159	if (!psshBoxes)
Lines 185-191 std::optional<Vector<Ref<SharedBuffer>>> InitDataRegistry::extractKeyIDsCenc(con a/Source/WebCore/Modules/encryptedmedia/InitDataRegistry.cpp_sec6
185	return keyIDs;	185	return keyIDs;
186	}	186	}
187		187
188	RefPtr<SharedBuffer> InitDataRegistry::sanitizeCenc(const SharedBuffer& buffer)	188	RefPtr<FragmentedSharedBuffer> InitDataRegistry::sanitizeCenc(const FragmentedSharedBuffer& buffer)
189	{	189	{
190	// 4. Common SystemID and PSSH Box Format	190	// 4. Common SystemID and PSSH Box Format
191	// https://w3c.github.io/encrypted-media/format-registry/initdata/cenc.html#common-system	191	// https://w3c.github.io/encrypted-media/format-registry/initdata/cenc.html#common-system
Lines 195-201 RefPtr<SharedBuffer> InitDataRegistry::sanitizeCenc(const SharedBuffer& buffer) a/Source/WebCore/Modules/encryptedmedia/InitDataRegistry.cpp_sec7
195	return buffer.copy();	195	return buffer.copy();
196	}	196	}
197		197
198	static RefPtr<SharedBuffer> sanitizeWebM(const SharedBuffer& buffer)	198	static RefPtr<FragmentedSharedBuffer> sanitizeWebM(const FragmentedSharedBuffer& buffer)
199	{	199	{
200	// Check if the buffer is a valid WebM initData.	200	// Check if the buffer is a valid WebM initData.
201	// The WebM initData is the ContentEncKeyID, so should be less than kWebMMaxContentEncKeyIDSize.	201	// The WebM initData is the ContentEncKeyID, so should be less than kWebMMaxContentEncKeyIDSize.
Lines 205-214 static RefPtr<SharedBuffer> sanitizeWebM(const SharedBuffer& buffer) a/Source/WebCore/Modules/encryptedmedia/InitDataRegistry.cpp_sec8
205	return buffer.copy();	205	return buffer.copy();
206	}	206	}
207		207
208	static std::optional<Vector<Ref<SharedBuffer>>> extractKeyIDsWebM(const SharedBuffer& buffer)	208	static std::optional<Vector<Ref<FragmentedSharedBuffer>>> extractKeyIDsWebM(const FragmentedSharedBuffer& buffer)
209	{	209	{
210	Vector<Ref<SharedBuffer>> keyIDs;	210	Vector<Ref<FragmentedSharedBuffer>> keyIDs;
211	RefPtr<SharedBuffer> sanitizedBuffer = sanitizeWebM(buffer);	211	RefPtr<FragmentedSharedBuffer> sanitizedBuffer = sanitizeWebM(buffer);
212	if (!sanitizedBuffer)	212	if (!sanitizedBuffer)
213	return std::nullopt;	213	return std::nullopt;
214		214
Lines 233-239 InitDataRegistry::InitDataRegistry() a/Source/WebCore/Modules/encryptedmedia/InitDataRegistry.cpp_sec9
233		233
234	InitDataRegistry::~InitDataRegistry() = default;	234	InitDataRegistry::~InitDataRegistry() = default;
235		235
236	RefPtr<SharedBuffer> InitDataRegistry::sanitizeInitData(const AtomString& initDataType, const SharedBuffer& buffer)	236	RefPtr<FragmentedSharedBuffer> InitDataRegistry::sanitizeInitData(const AtomString& initDataType, const FragmentedSharedBuffer& buffer)
237	{	237	{
238	auto iter = m_types.find(initDataType);	238	auto iter = m_types.find(initDataType);
239	if (iter == m_types.end() \|\| !iter->value.sanitizeInitData)	239	if (iter == m_types.end() \|\| !iter->value.sanitizeInitData)
Lines 241-247 RefPtr<SharedBuffer> InitDataRegistry::sanitizeInitData(const AtomString& initDa a/Source/WebCore/Modules/encryptedmedia/InitDataRegistry.cpp_sec10
241	return iter->value.sanitizeInitData(buffer);	241	return iter->value.sanitizeInitData(buffer);
242	}	242	}
243		243
244	std::optional<Vector<Ref<SharedBuffer>>> InitDataRegistry::extractKeyIDs(const AtomString& initDataType, const SharedBuffer& buffer)	244	std::optional<Vector<Ref<FragmentedSharedBuffer>>> InitDataRegistry::extractKeyIDs(const AtomString& initDataType, const FragmentedSharedBuffer& buffer)
245	{	245	{
246	auto iter = m_types.find(initDataType);	246	auto iter = m_types.find(initDataType);
247	if (iter == m_types.end() \|\| !iter->value.sanitizeInitData)	247	if (iter == m_types.end() \|\| !iter->value.sanitizeInitData)

Lines 56-67 unsigned long MediaKeyStatusMap::size() a/Source/WebCore/Modules/encryptedmedia/MediaKeyStatusMap.cpp_sec1
- a/Source/WebCore/Modules/encryptedmedia/MediaKeyStatusMap.cpp -3 / +3 lines
56	return m_session->statuses().size();	56	return m_session->statuses().size();
57	}	57	}
58		58
59	static bool keyIdsMatch(const SharedBuffer& a, const BufferSource& b)	59	static bool keyIdsMatch(const FragmentedSharedBuffer& a, const BufferSource& b)
60	{	60	{
61	auto length = a.size();	61	auto length = a.size();
62	if (!length \|\| length != b.length())	62	if (!length \|\| length != b.length())
63	return false;	63	return false;
64	return !std::memcmp(a.data(), b.data(), length);	64	return !std::memcmp(a.makeContiguous()->data(), b.data(), length);
65	}	65	}
66		66
67	bool MediaKeyStatusMap::has(const BufferSource& keyId)	67	bool MediaKeyStatusMap::has(const BufferSource& keyId)
Lines 103-109 std::optional<KeyValuePair<BufferSource::VariantType, MediaKeyStatus>> MediaKeyS a/Source/WebCore/Modules/encryptedmedia/MediaKeyStatusMap.cpp_sec2
103	return std::nullopt;	103	return std::nullopt;
104		104
105	auto& pair = statuses[m_index++];	105	auto& pair = statuses[m_index++];
106	auto buffer = ArrayBuffer::create(pair.first->data(), pair.first->size());	106	auto buffer = ArrayBuffer::create(pair.first->makeContiguous()->data(), pair.first->size());
107	return KeyValuePair<BufferSource::VariantType, MediaKeyStatus> { RefPtr<ArrayBuffer>(WTFMove(buffer)), pair.second };	107	return KeyValuePair<BufferSource::VariantType, MediaKeyStatus> { RefPtr<ArrayBuffer>(WTFMove(buffer)), pair.second };
108	}	108	}
109		109

Lines 235-241 void FetchBody::consumeBlob(FetchBodyOwner& owner, Ref<DeferredPromise>&& promis a/Source/WebCore/Modules/fetch/FetchBody.cpp_sec1
- a/Source/WebCore/Modules/fetch/FetchBody.cpp -3 / +3 lines
235	void FetchBody::consumeFormData(FetchBodyOwner& owner, Ref<DeferredPromise>&& promise)	235	void FetchBody::consumeFormData(FetchBodyOwner& owner, Ref<DeferredPromise>&& promise)
236	{	236	{
237	if (auto sharedBuffer = formDataBody().asSharedBuffer()) {	237	if (auto sharedBuffer = formDataBody().asSharedBuffer()) {
238	m_consumer.resolveWithData(WTFMove(promise), owner.contentType(), sharedBuffer->data(), sharedBuffer->size());	238	m_consumer.resolveWithData(WTFMove(promise), owner.contentType(), sharedBuffer->makeContiguous()->data(), sharedBuffer->size());
239	m_data = nullptr;	239	m_data = nullptr;
240	} else {	240	} else {
241	// FIXME: If the form data contains blobs, load them like we do other blobs.	241	// FIXME: If the form data contains blobs, load them like we do other blobs.
Lines 272-278 RefPtr<FormData> FetchBody::bodyAsFormData() const a/Source/WebCore/Modules/fetch/FetchBody.cpp_sec2
272	if (isFormData())	272	if (isFormData())
273	return &const_cast<FormData&>(formDataBody());	273	return &const_cast<FormData&>(formDataBody());
274	if (auto* data = m_consumer.data())	274	if (auto* data = m_consumer.data())
275	return FormData::create(data->data(), data->size());	275	return FormData::create(data->makeContiguous()->data(), data->size());
276		276
277	ASSERT_NOT_REACHED();	277	ASSERT_NOT_REACHED();
278	return nullptr;	278	return nullptr;
Lines 284-290 FetchBody::TakenData FetchBody::take() a/Source/WebCore/Modules/fetch/FetchBody.cpp_sec3
284	auto buffer = m_consumer.takeData();	284	auto buffer = m_consumer.takeData();
285	if (!buffer)	285	if (!buffer)
286	return nullptr;	286	return nullptr;
287	return buffer.releaseNonNull();	287	return buffer->makeContiguous();
288	}	288	}
289		289
290	if (isBlob()) {	290	if (isBlob()) {

Lines 242-248 static void resolveWithTypeAndData(Ref<DeferredPromise>&& promise, FetchBodyCons a/Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp_sec1
- a/Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp -25 / +25 lines
242		242
243	void FetchBodyConsumer::clean()	243	void FetchBodyConsumer::clean()
244	{	244	{
245	m_buffer = nullptr;	245	m_buffer.reset();
246	resetConsumePromise();	246	resetConsumePromise();
247	if (m_sink) {	247	if (m_sink) {
248	m_sink->clearCallback();	248	m_sink->clearCallback();
Lines 266-281 void FetchBodyConsumer::resolve(Ref<DeferredPromise>&& promise, const String& co a/Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp_sec2
266	{	266	{
267	if (stream) {	267	if (stream) {
268	ASSERT(!m_sink);	268	ASSERT(!m_sink);
269	m_sink = ReadableStreamToSharedBufferSink::create([promise = WTFMove(promise), data = SharedBuffer::create(), type = m_type, contentType](auto&& result) mutable {	269	m_sink = ReadableStreamToSharedBufferSink::create([promise = WTFMove(promise), data = SharedBufferBuilder(), type = m_type, contentType](auto&& result) mutable {
270	if (result.hasException()) {	270	if (result.hasException()) {
271	promise->reject(result.releaseException());	271	promise->reject(result.releaseException());
272	return;	272	return;
273	}	273	}
274		274
275	if (auto* chunk = result.returnValue())	275	if (auto* chunk = result.returnValue())
276	data->append(chunk->data(), chunk->size());	276	data.append(chunk->data(), chunk->size());
277	else	277	else {
278	resolveWithTypeAndData(WTFMove(promise), type, contentType, data->data(), data->size());	278	auto buffer = data.take()->makeContiguous();
		279	resolveWithTypeAndData(WTFMove(promise), type, contentType, buffer->data(), buffer->size());
		280	}
279	});	281	});
280	m_sink->pipeFrom(*stream);	282	m_sink->pipeFrom(*stream);
281	return;	283	return;
Lines 306-312 void FetchBodyConsumer::resolve(Ref<DeferredPromise>&& promise, const String& co a/Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp_sec3
306	return;	308	return;
307	case FetchBodyConsumer::Type::FormData: {	309	case FetchBodyConsumer::Type::FormData: {
308	auto buffer = takeData();	310	auto buffer = takeData();
309	if (auto formData = packageFormData(context, contentType, buffer ? buffer->data() : nullptr, buffer ? buffer->size() : 0))	311	if (auto formData = packageFormData(context, contentType, buffer ? buffer->makeContiguous()->data() : nullptr, buffer ? buffer->size() : 0))
310	promise->resolve<IDLInterface<DOMFormData>>(*formData);	312	promise->resolve<IDLInterface<DOMFormData>>(*formData);
311	else	313	else
312	promise->reject(TypeError);	314	promise->reject(TypeError);
Lines 324-339 void FetchBodyConsumer::append(const uint8_t* data, unsigned size) a/Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp_sec4
324	m_source->enqueue(ArrayBuffer::tryCreate(data, size));	326	m_source->enqueue(ArrayBuffer::tryCreate(data, size));
325	return;	327	return;
326	}	328	}
327	if (!m_buffer) {	329	m_buffer.append(data, size);
328	m_buffer = SharedBuffer::create(data, size);
329	return;
330	}
331	m_buffer->append(data, size);
332	}	330	}
333		331
334	RefPtr<SharedBuffer> FetchBodyConsumer::takeData()	332	void FetchBodyConsumer::setData(Ref<FragmentedSharedBuffer>&& data)
335	{	333	{
336	return WTFMove(m_buffer);	334	m_buffer.reset();
		335	m_buffer.append(WTFMove(data));
		336	}
		337
		338	RefPtr<FragmentedSharedBuffer> FetchBodyConsumer::takeData()
		339	{
		340	if (!m_buffer)
		341	return nullptr;
		342	return m_buffer.take();
337	}	343	}
338		344
339	RefPtr<JSC::ArrayBuffer> FetchBodyConsumer::takeAsArrayBuffer()	345	RefPtr<JSC::ArrayBuffer> FetchBodyConsumer::takeAsArrayBuffer()
Lines 341-349 RefPtr<JSC::ArrayBuffer> FetchBodyConsumer::takeAsArrayBuffer() a/Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp_sec5
341	if (!m_buffer)	347	if (!m_buffer)
342	return ArrayBuffer::tryCreate(nullptr, 0);	348	return ArrayBuffer::tryCreate(nullptr, 0);
343		349
344	auto arrayBuffer = m_buffer->tryCreateArrayBuffer();	350	return m_buffer.take()->tryCreateArrayBuffer();
345	m_buffer = nullptr;
346	return arrayBuffer;
347	}	351	}
348		352
349	Ref<Blob> FetchBodyConsumer::takeAsBlob(ScriptExecutionContext* context)	353	Ref<Blob> FetchBodyConsumer::takeAsBlob(ScriptExecutionContext* context)
Lines 351-359 Ref<Blob> FetchBodyConsumer::takeAsBlob(ScriptExecutionContext* context) a/Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp_sec6
351	if (!m_buffer)	355	if (!m_buffer)
352	return Blob::create(context, Vector<uint8_t>(), Blob::normalizedContentType(m_contentType));	356	return Blob::create(context, Vector<uint8_t>(), Blob::normalizedContentType(m_contentType));
353		357
354	auto buffer = std::exchange(m_buffer, nullptr);	358	return blobFromData(context, m_buffer.take()->extractData(), m_contentType);
355	auto data = buffer->extractData();
356	return blobFromData(context, WTFMove(data), m_contentType);
357	}	359	}
358		360
359	String FetchBodyConsumer::takeAsText()	361	String FetchBodyConsumer::takeAsText()
Lines 362-369 String FetchBodyConsumer::takeAsText() a/Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp_sec7
362	if (!m_buffer)	364	if (!m_buffer)
363	return String();	365	return String();
364		366
365	auto text = TextResourceDecoder::textFromUTF8(m_buffer->data(), m_buffer->size());	367	auto buffer = m_buffer.take()->makeContiguous();
366	m_buffer = nullptr;	368	auto text = TextResourceDecoder::textFromUTF8(buffer->data(), buffer->size());
367	return text;	369	return text;
368	}	370	}
369		371
Lines 383-392 void FetchBodyConsumer::resetConsumePromise() a/Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp_sec8
383	void FetchBodyConsumer::setSource(Ref<FetchBodySource>&& source)	385	void FetchBodyConsumer::setSource(Ref<FetchBodySource>&& source)
384	{	386	{
385	m_source = WTFMove(source);	387	m_source = WTFMove(source);
386	if (m_buffer) {	388	if (m_buffer)
387	m_source->enqueue(m_buffer->tryCreateArrayBuffer());	389	m_source->enqueue(m_buffer.take()->tryCreateArrayBuffer());
388	m_buffer = nullptr;
389	}
390	}	390	}
391		391
392	void FetchBodyConsumer::loadingFailed(const Exception& exception)	392	void FetchBodyConsumer::loadingFailed(const Exception& exception)

Lines 50-59 public: a/Source/WebCore/Modules/fetch/FetchBodyConsumer.h_sec1
- a/Source/WebCore/Modules/fetch/FetchBodyConsumer.h -4 / +4 lines
50	void append(const uint8_t* data, unsigned);	50	void append(const uint8_t* data, unsigned);
51		51
52	bool hasData() const { return !!m_buffer; }	52	bool hasData() const { return !!m_buffer; }
53	const SharedBuffer* data() const { return m_buffer.get(); }	53	const FragmentedSharedBuffer* data() const { return m_buffer.get().get(); }
54	void setData(Ref<SharedBuffer>&& data) { m_buffer = WTFMove(data); }	54	void setData(Ref<FragmentedSharedBuffer>&&);
55		55
56	RefPtr<SharedBuffer> takeData();	56	RefPtr<FragmentedSharedBuffer> takeData();
57	RefPtr<JSC::ArrayBuffer> takeAsArrayBuffer();	57	RefPtr<JSC::ArrayBuffer> takeAsArrayBuffer();
58	String takeAsText();	58	String takeAsText();
59		59
Lines 82-88 private: a/Source/WebCore/Modules/fetch/FetchBodyConsumer.h_sec2
82		82
83	Type m_type;	83	Type m_type;
84	String m_contentType;	84	String m_contentType;
85	RefPtr<SharedBuffer> m_buffer;	85	SharedBufferBuilder m_buffer;
86	RefPtr<DeferredPromise> m_consumePromise;	86	RefPtr<DeferredPromise> m_consumePromise;
87	RefPtr<ReadableStreamToSharedBufferSink> m_sink;	87	RefPtr<ReadableStreamToSharedBufferSink> m_sink;
88	RefPtr<FetchBodySource> m_source;	88	RefPtr<FetchBodySource> m_source;

Lines 39-52 class FetchBodyConsumer; a/Source/WebCore/Modules/fetch/FetchLoader.h_sec1
- a/Source/WebCore/Modules/fetch/FetchLoader.h -2 / +2 lines
39	class FetchLoaderClient;	39	class FetchLoaderClient;
40	class FetchRequest;	40	class FetchRequest;
41	class ScriptExecutionContext;	41	class ScriptExecutionContext;
42	class SharedBuffer;	42	class FragmentedSharedBuffer;
43		43
44	class FetchLoader final : public ThreadableLoaderClient {	44	class FetchLoader final : public ThreadableLoaderClient {
45	public:	45	public:
46	FetchLoader(FetchLoaderClient&, FetchBodyConsumer*);	46	FetchLoader(FetchLoaderClient&, FetchBodyConsumer*);
47	WEBCORE_EXPORT ~FetchLoader();	47	WEBCORE_EXPORT ~FetchLoader();
48		48
49	RefPtr<SharedBuffer> startStreaming();	49	RefPtr<FragmentedSharedBuffer> startStreaming();
50		50
51	void start(ScriptExecutionContext&, const FetchRequest&, const String&);	51	void start(ScriptExecutionContext&, const FetchRequest&, const String&);
52	void start(ScriptExecutionContext&, const Blob&);	52	void start(ScriptExecutionContext&, const Blob&);

Lines 38-44 enum class CreateNewGroupForHighlight : bool { No, Yes }; a/Source/WebCore/Modules/highlight/AppHighlight.h_sec1
- a/Source/WebCore/Modules/highlight/AppHighlight.h -2 / +2 lines
38	enum class HighlightRequestOriginatedInApp : bool { No, Yes };	38	enum class HighlightRequestOriginatedInApp : bool { No, Yes };
39		39
40	struct AppHighlight {	40	struct AppHighlight {
41	Ref<WebCore::SharedBuffer> highlight;	41	Ref<WebCore::FragmentedSharedBuffer> highlight;
42	std::optional<String> text;	42	std::optional<String> text;
43	CreateNewGroupForHighlight isNewGroup;	43	CreateNewGroupForHighlight isNewGroup;
44	HighlightRequestOriginatedInApp requestOriginatedInApp;	44	HighlightRequestOriginatedInApp requestOriginatedInApp;
Lines 52-58 template<class Encoder> a/Source/WebCore/Modules/highlight/AppHighlight.h_sec2
52	void AppHighlight::encode(Encoder& encoder) const	52	void AppHighlight::encode(Encoder& encoder) const
53	{	53	{
54	encoder << static_cast<size_t>(highlight->size());	54	encoder << static_cast<size_t>(highlight->size());
55	encoder.encodeFixedLengthData(highlight->data(), highlight->size(), 1);	55	encoder.encodeFixedLengthData(highlight->makeContiguous()->data(), highlight->size(), 1);
56		56
57	encoder << text;	57	encoder << text;
58		58

Lines 44-58 namespace WebCore { a/Source/WebCore/Modules/highlight/AppHighlightRangeData.cpp_sec1
- a/Source/WebCore/Modules/highlight/AppHighlightRangeData.cpp -3 / +4 lines
44		44
45	constexpr uint64_t highlightFileSignature = 0x4141504832303231; // File Signature (A)pple(AP)plication(H)ighlights(2021)	45	constexpr uint64_t highlightFileSignature = 0x4141504832303231; // File Signature (A)pple(AP)plication(H)ighlights(2021)
46		46
47	std::optional<AppHighlightRangeData> AppHighlightRangeData::create(const SharedBuffer& buffer)	47	std::optional<AppHighlightRangeData> AppHighlightRangeData::create(const FragmentedSharedBuffer& buffer)
48	{	48	{
49	auto decoder = buffer.decoder();	49	auto contiguousBuffer = buffer.makeContiguous();
		50	auto decoder = contiguousBuffer->decoder();
50	std::optional<AppHighlightRangeData> data;	51	std::optional<AppHighlightRangeData> data;
51	decoder >> data;	52	decoder >> data;
52	return data;	53	return data;
53	}	54	}
54		55
55	Ref<SharedBuffer> AppHighlightRangeData::toSharedBuffer() const	56	Ref<FragmentedSharedBuffer> AppHighlightRangeData::toSharedBuffer() const
56	{	57	{
57	WTF::Persistence::Encoder encoder;	58	WTF::Persistence::Encoder encoder;
58	encoder << *this;	59	encoder << *this;

Lines 33-44 namespace WebCore { a/Source/WebCore/Modules/highlight/AppHighlightRangeData.h_sec1
- a/Source/WebCore/Modules/highlight/AppHighlightRangeData.h -3 / +3 lines
33		33
34	#if ENABLE(APP_HIGHLIGHTS)	34	#if ENABLE(APP_HIGHLIGHTS)
35		35
36	class SharedBuffer;	36	class FragmentedSharedBuffer;
37		37
38	class AppHighlightRangeData {	38	class AppHighlightRangeData {
39	WTF_MAKE_FAST_ALLOCATED;	39	WTF_MAKE_FAST_ALLOCATED;
40	public:	40	public:
41	WEBCORE_EXPORT static std::optional<AppHighlightRangeData> create(const SharedBuffer&);	41	WEBCORE_EXPORT static std::optional<AppHighlightRangeData> create(const FragmentedSharedBuffer&);
42	struct NodePathComponent {	42	struct NodePathComponent {
43	String identifier;	43	String identifier;
44	String nodeName;	44	String nodeName;
Lines 111-117 public: a/Source/WebCore/Modules/highlight/AppHighlightRangeData.h_sec2
111	template<class Encoder> void encode(Encoder&) const;	111	template<class Encoder> void encode(Encoder&) const;
112	template<class Decoder> static std::optional<AppHighlightRangeData> decode(Decoder&);	112	template<class Decoder> static std::optional<AppHighlightRangeData> decode(Decoder&);
113		113
114	Ref<SharedBuffer> toSharedBuffer() const;	114	Ref<FragmentedSharedBuffer> toSharedBuffer() const;
115		115
116	private:	116	private:
117	String m_identifier;	117	String m_identifier;

Lines 39-45 namespace WebCore { a/Source/WebCore/Modules/mediastream/RTCDataChannelRemoteHandler.h_sec1
- a/Source/WebCore/Modules/mediastream/RTCDataChannelRemoteHandler.h -2 / +2 lines
39	class RTCDataChannelHandlerClient;	39	class RTCDataChannelHandlerClient;
40	class RTCDataChannelRemoteHandlerConnection;	40	class RTCDataChannelRemoteHandlerConnection;
41	class RTCError;	41	class RTCError;
42	class SharedBuffer;	42	class FragmentedSharedBuffer;
43		43
44	class RTCDataChannelRemoteHandler final : public RTCDataChannelHandler, public CanMakeWeakPtr<RTCDataChannelRemoteHandler> {	44	class RTCDataChannelRemoteHandler final : public RTCDataChannelHandler, public CanMakeWeakPtr<RTCDataChannelRemoteHandler> {
45	WTF_MAKE_FAST_ALLOCATED;	45	WTF_MAKE_FAST_ALLOCATED;
Lines 73-79 private: a/Source/WebCore/Modules/mediastream/RTCDataChannelRemoteHandler.h_sec2
73		73
74	struct Message {	74	struct Message {
75	bool isRaw { false };	75	bool isRaw { false };
76	Ref<SharedBuffer> buffer;	76	Ref<FragmentedSharedBuffer> buffer;
77	};	77	};
78	Vector<Message> m_pendingMessages;	78	Vector<Message> m_pendingMessages;
79	bool m_isPendingClose { false };	79	bool m_isPendingClose { false };

Lines 97-104 void LibWebRTCDataChannelHandler::setClient(RTCDataChannelHandlerClient& client, a/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCDataChannelHandler.cpp_sec1
- a/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCDataChannelHandler.cpp -2 / +2 lines
97	m_contextIdentifier = contextIdentifier;	97	m_contextIdentifier = contextIdentifier;
98		98
99	for (auto& message : m_bufferedMessages) {	99	for (auto& message : m_bufferedMessages) {
100	switchOn(message, [&](Ref<SharedBuffer>& data) {	100	switchOn(message, [&](Ref<FragmentedSharedBuffer>& data) {
101	client.didReceiveRawData(data->data(), data->size());	101	client.didReceiveRawData(data->makeContiguous()->data(), data->size());
102	}, [&](String& text) {	102	}, [&](String& text) {
103	client.didReceiveStringData(text);	103	client.didReceiveStringData(text);
104	}, [&](StateChange stateChange) {	104	}, [&](StateChange stateChange) {

Lines 116-122 void HTMLModelElement::setSourceURL(const URL& url) a/Source/WebCore/Modules/model-element/HTMLModelElement.cpp_sec1
- a/Source/WebCore/Modules/model-element/HTMLModelElement.cpp -6 / +5 lines
116		116
117	m_sourceURL = url;	117	m_sourceURL = url;
118		118
119	m_data = nullptr;	119	m_data.reset();
120	m_dataComplete = false;	120	m_dataComplete = false;
121		121
122	if (m_resource) {	122	if (m_resource) {
Lines 149-155 void HTMLModelElement::setSourceURL(const URL& url) a/Source/WebCore/Modules/model-element/HTMLModelElement.cpp_sec2
149	return;	149	return;
150	}	150	}
151		151
152	m_data = SharedBuffer::create();	152	m_data.empty();
153		153
154	m_resource = resource.value();	154	m_resource = resource.value();
155	m_resource->addClient(*this);	155	m_resource->addClient(*this);
Lines 180-187 RenderPtr<RenderElement> HTMLModelElement::createElementRenderer(RenderStyle&& s a/Source/WebCore/Modules/model-element/HTMLModelElement.cpp_sec3
180	void HTMLModelElement::dataReceived(CachedResource& resource, const uint8_t* data, int dataLength)	180	void HTMLModelElement::dataReceived(CachedResource& resource, const uint8_t* data, int dataLength)
181	{	181	{
182	ASSERT_UNUSED(resource, &resource == m_resource);	182	ASSERT_UNUSED(resource, &resource == m_resource);
183	ASSERT(m_data);	183	m_data.append(data, dataLength);
184	m_data->append(data, dataLength);
185	}	184	}
186		185
187	void HTMLModelElement::notifyFinished(CachedResource& resource, const NetworkLoadMetrics&)	186	void HTMLModelElement::notifyFinished(CachedResource& resource, const NetworkLoadMetrics&)
Lines 195-201 void HTMLModelElement::notifyFinished(CachedResource& resource, const NetworkLoa a/Source/WebCore/Modules/model-element/HTMLModelElement.cpp_sec4
195	};	194	};
196		195
197	if (resource.loadFailedOrCanceled()) {	196	if (resource.loadFailedOrCanceled()) {
198	m_data = nullptr;	197	m_data.reset();
199		198
200	invalidateResourceHandleAndUpdateRenderer();	199	invalidateResourceHandleAndUpdateRenderer();
201		200
Lines 204-210 void HTMLModelElement::notifyFinished(CachedResource& resource, const NetworkLoa a/Source/WebCore/Modules/model-element/HTMLModelElement.cpp_sec5
204	}	203	}
205		204
206	m_dataComplete = true;	205	m_dataComplete = true;
207	m_model = Model::create(m_data.releaseNonNull().get(), resource.mimeType(), resource.url());	206	m_model = Model::create(m_data.take()->makeContiguous().get(), resource.mimeType(), resource.url());
208		207
209	invalidateResourceHandleAndUpdateRenderer();	208	invalidateResourceHandleAndUpdateRenderer();
210		209

Lines 34-39 namespace WebCore { a/Source/WebCore/css/CSSFontFaceSource.h_sec1
- a/Source/WebCore/css/CSSFontFaceSource.h -1 / +1 lines
34		34
35	class CSSFontFace;	35	class CSSFontFace;
36	class CSSFontSelector;	36	class CSSFontSelector;
		37	class SharedBuffer;
37	class Document;	38	class Document;
38	class Font;	39	class Font;
39	class FontCreationContext;	40	class FontCreationContext;
Lines 42-48 class FontDescription; a/Source/WebCore/css/CSSFontFaceSource.h_sec2
42	struct FontSelectionSpecifiedCapabilities;	43	struct FontSelectionSpecifiedCapabilities;
43	struct FontVariantSettings;	44	struct FontVariantSettings;
44	class SVGFontFaceElement;	45	class SVGFontFaceElement;
45	class SharedBuffer;
46		46
47	template <typename T> class FontTaggedSettings;	47	template <typename T> class FontTaggedSettings;
48	typedef FontTaggedSettings<int> FontFeatureSettings;	48	typedef FontTaggedSettings<int> FontFeatureSettings;

Lines 57-65 namespace WebCore { a/Source/WebCore/editing/Editor.h_sec1
- a/Source/WebCore/editing/Editor.h -3 / +4 lines
57		57
58	class AlternativeTextController;	58	class AlternativeTextController;
59	class ArchiveResource;	59	class ArchiveResource;
60	class DataTransfer;
61	class CompositeEditCommand;	60	class CompositeEditCommand;
		61	class SharedBuffer;
62	class CustomUndoStep;	62	class CustomUndoStep;
		63	class DataTransfer;
63	class DeleteButtonController;	64	class DeleteButtonController;
64	class EditCommand;	65	class EditCommand;
65	class EditCommandComposition;	66	class EditCommandComposition;
Lines 74-80 class KillRing; a/Source/WebCore/editing/Editor.h_sec2
74	class Pasteboard;	75	class Pasteboard;
75	class PasteboardWriterData;	76	class PasteboardWriterData;
76	class RenderLayer;	77	class RenderLayer;
77	class SharedBuffer;	78	class FragmentedSharedBuffer;
78	class Font;	79	class Font;
79	class SpellCheckRequest;	80	class SpellCheckRequest;
80	class SpellChecker;	81	class SpellChecker;
Lines 563-569 public: a/Source/WebCore/editing/Editor.h_sec3
563		564
564	#if ENABLE(ATTACHMENT_ELEMENT)	565	#if ENABLE(ATTACHMENT_ELEMENT)
565	WEBCORE_EXPORT void insertAttachment(const String& identifier, std::optional<uint64_t>&& fileSize, const String& fileName, const String& contentType);	566	WEBCORE_EXPORT void insertAttachment(const String& identifier, std::optional<uint64_t>&& fileSize, const String& fileName, const String& contentType);
566	void registerAttachmentIdentifier(const String&, const String& contentType, const String& preferredFileName, Ref<SharedBuffer>&& fileData);	567	void registerAttachmentIdentifier(const String&, const String& contentType, const String& preferredFileName, Ref<FragmentedSharedBuffer>&& fileData);
567	void registerAttachments(Vector<SerializedAttachmentData>&&);	568	void registerAttachments(Vector<SerializedAttachmentData>&&);
568	void registerAttachmentIdentifier(const String&, const String& contentType, const String& filePath);	569	void registerAttachmentIdentifier(const String&, const String& contentType, const String& filePath);
569	void registerAttachmentIdentifier(const String&);	570	void registerAttachmentIdentifier(const String&);

Lines 72-87 private: a/Source/WebCore/editing/WebContentReader.h_sec1
- a/Source/WebCore/editing/WebContentReader.h -10 / +10 lines
72	bool readFilePath(const String&, PresentationSize preferredPresentationSize = { }, const String& contentType = { }) override;	72	bool readFilePath(const String&, PresentationSize preferredPresentationSize = { }, const String& contentType = { }) override;
73	bool readFilePaths(const Vector<String>&) override;	73	bool readFilePaths(const Vector<String>&) override;
74	bool readHTML(const String&) override;	74	bool readHTML(const String&) override;
75	bool readImage(Ref<SharedBuffer>&&, const String& type, PresentationSize preferredPresentationSize = { }) override;	75	bool readImage(Ref<FragmentedSharedBuffer>&&, const String& type, PresentationSize preferredPresentationSize = { }) override;
76	bool readURL(const URL&, const String& title) override;	76	bool readURL(const URL&, const String& title) override;
77	bool readPlainText(const String&) override;	77	bool readPlainText(const String&) override;
78	#endif	78	#endif
79		79
80	#if PLATFORM(COCOA)	80	#if PLATFORM(COCOA)
81	bool readWebArchive(SharedBuffer&) override;	81	bool readWebArchive(FragmentedSharedBuffer&) override;
82	bool readRTFD(SharedBuffer&) override;	82	bool readRTFD(FragmentedSharedBuffer&) override;
83	bool readRTF(SharedBuffer&) override;	83	bool readRTF(FragmentedSharedBuffer&) override;
84	bool readDataBuffer(SharedBuffer&, const String& type, const String& name, PresentationSize preferredPresentationSize = { }) override;	84	bool readDataBuffer(FragmentedSharedBuffer&, const String& type, const String& name, PresentationSize preferredPresentationSize = { }) override;
85	#endif	85	#endif
86	};	86	};
87		87
Lines 99-114 private: a/Source/WebCore/editing/WebContentReader.h_sec2
99	bool readFilePath(const String&, PresentationSize = { }, const String& = { }) override { return false; }	99	bool readFilePath(const String&, PresentationSize = { }, const String& = { }) override { return false; }
100	bool readFilePaths(const Vector<String>&) override { return false; }	100	bool readFilePaths(const Vector<String>&) override { return false; }
101	bool readHTML(const String&) override;	101	bool readHTML(const String&) override;
102	bool readImage(Ref<SharedBuffer>&&, const String&, PresentationSize = { }) override { return false; }	102	bool readImage(Ref<FragmentedSharedBuffer>&&, const String&, PresentationSize = { }) override { return false; }
103	bool readURL(const URL&, const String&) override { return false; }	103	bool readURL(const URL&, const String&) override { return false; }
104	bool readPlainText(const String&) override { return false; }	104	bool readPlainText(const String&) override { return false; }
105	#endif	105	#endif
106		106
107	#if PLATFORM(COCOA)	107	#if PLATFORM(COCOA)
108	bool readWebArchive(SharedBuffer&) override;	108	bool readWebArchive(FragmentedSharedBuffer&) override;
109	bool readRTFD(SharedBuffer&) override;	109	bool readRTFD(FragmentedSharedBuffer&) override;
110	bool readRTF(SharedBuffer&) override;	110	bool readRTF(FragmentedSharedBuffer&) override;
111	bool readDataBuffer(SharedBuffer&, const String&, const String&, PresentationSize = { }) override { return false; }	111	bool readDataBuffer(FragmentedSharedBuffer&, const String&, const String&, PresentationSize = { }) override { return false; }
112	#endif	112	#endif
113	};	113	};
114		114

Lines 1273-1279 BOOL HTMLConverter::_addAttachmentForElement(Element& element, NSURL *url, BOOL a/Source/WebCore/editing/cocoa/HTMLConverter.mm_sec1
- a/Source/WebCore/editing/cocoa/HTMLConverter.mm -4 / +4 lines
1273	if (auto resource = dataSource->subresource(url)) {	1273	if (auto resource = dataSource->subresource(url)) {
1274	auto& mimeType = resource->mimeType();	1274	auto& mimeType = resource->mimeType();
1275	if (!usePlaceholder \|\| mimeType != "text/html") {	1275	if (!usePlaceholder \|\| mimeType != "text/html") {
1276	fileWrapper = adoptNS([[NSFileWrapper alloc] initRegularFileWithContents:resource->data().createNSData().get()]);	1276	fileWrapper = adoptNS([[NSFileWrapper alloc] initRegularFileWithContents:resource->data().makeContiguous()->createNSData().get()]);
1277	[fileWrapper setPreferredFilename:suggestedFilenameWithMIMEType(url, mimeType)];	1277	[fileWrapper setPreferredFilename:suggestedFilenameWithMIMEType(url, mimeType)];
1278	} else	1278	} else
1279	notFound = YES;	1279	notFound = YES;
Lines 2300-2306 static RetainPtr<NSFileWrapper> fileWrapperForURL(DocumentLoader* dataSource, NS a/Source/WebCore/editing/cocoa/HTMLConverter.mm_sec2
2300		2300
2301	if (dataSource) {	2301	if (dataSource) {
2302	if (RefPtr<ArchiveResource> resource = dataSource->subresource(URL)) {	2302	if (RefPtr<ArchiveResource> resource = dataSource->subresource(URL)) {
2303	auto wrapper = adoptNS([[NSFileWrapper alloc] initRegularFileWithContents:resource->data().createNSData().get()]);	2303	auto wrapper = adoptNS([[NSFileWrapper alloc] initRegularFileWithContents:resource->data().makeContiguous()->createNSData().get()]);
2304	NSString *filename = resource->response().suggestedFilename();	2304	NSString *filename = resource->response().suggestedFilename();
2305	if (!filename \|\| ![filename length])	2305	if (!filename \|\| ![filename length])
2306	filename = suggestedFilenameWithMIMEType(resource->url(), resource->mimeType());	2306	filename = suggestedFilenameWithMIMEType(resource->url(), resource->mimeType());
Lines 2322-2329 static RetainPtr<NSFileWrapper> fileWrapperForURL(DocumentLoader* dataSource, NS a/Source/WebCore/editing/cocoa/HTMLConverter.mm_sec3
2322	static RetainPtr<NSFileWrapper> fileWrapperForElement(HTMLImageElement& element)	2322	static RetainPtr<NSFileWrapper> fileWrapperForElement(HTMLImageElement& element)
2323	{	2323	{
2324	if (CachedImage* cachedImage = element.cachedImage()) {	2324	if (CachedImage* cachedImage = element.cachedImage()) {
2325	if (SharedBuffer* sharedBuffer = cachedImage->resourceBuffer())	2325	if (FragmentedSharedBuffer* sharedBuffer = cachedImage->resourceBuffer())
2326	return adoptNS([[NSFileWrapper alloc] initRegularFileWithContents:sharedBuffer->createNSData().get()]);	2326	return adoptNS([[NSFileWrapper alloc] initRegularFileWithContents:sharedBuffer->makeContiguous()->createNSData().get()]);
2327	}	2327	}
2328		2328
2329	auto* renderer = element.renderer();	2329	auto* renderer = element.renderer();

Lines 245-251 static bool supportsClientSideAttachmentData(const Frame& frame) a/Source/WebCore/editing/cocoa/WebContentReaderCocoa.mm_sec1
- a/Source/WebCore/editing/cocoa/WebContentReaderCocoa.mm -20 / +20 lines
245		245
246	#endif	246	#endif
247		247
248	static Ref<DocumentFragment> createFragmentForImageAttachment(Frame& frame, Document& document, Ref<SharedBuffer>&& buffer, const String& contentType, PresentationSize preferredSize)	248	static Ref<DocumentFragment> createFragmentForImageAttachment(Frame& frame, Document& document, Ref<FragmentedSharedBuffer>&& buffer, const String& contentType, PresentationSize preferredSize)
249	{	249	{
250	#if ENABLE(ATTACHMENT_ELEMENT)	250	#if ENABLE(ATTACHMENT_ELEMENT)
251	auto attachment = HTMLAttachmentElement::create(HTMLNames::attachmentTag, document);	251	auto attachment = HTMLAttachmentElement::create(HTMLNames::attachmentTag, document);
Lines 309-315 static void replaceRichContentWithAttachments(Frame& frame, DocumentFragment& fr a/Source/WebCore/editing/cocoa/WebContentReaderCocoa.mm_sec2
309	continue;	309	continue;
310		310
311	auto& resource = resourceEntry->value;	311	auto& resource = resourceEntry->value;
312	serializedAttachmentData.append({ attachment.uniqueIdentifier(), resource->mimeType(), resource->data() });	312	serializedAttachmentData.append({ attachment.uniqueIdentifier(), resource->mimeType(), resource->data().makeContiguous() });
313	}	313	}
314		314
315	if (!serializedAttachmentData.isEmpty())	315	if (!serializedAttachmentData.isEmpty())
Lines 332-338 static void replaceRichContentWithAttachments(Frame& frame, DocumentFragment& fr a/Source/WebCore/editing/cocoa/WebContentReaderCocoa.mm_sec3
332	if (name.isEmpty())	332	if (name.isEmpty())
333	name = "media"_s;	333	name = "media"_s;
334		334
335	attachmentInsertionInfo.append({ WTFMove(name), resource->value->mimeType(), resource->value->data(), image });	335	attachmentInsertionInfo.append({ WTFMove(name), resource->value->mimeType(), resource->value->data().makeContiguous(), image });
336	}	336	}
337		337
338	for (auto& object : descendantsOfType<HTMLObjectElement>(fragment)) {	338	for (auto& object : descendantsOfType<HTMLObjectElement>(fragment)) {
Lines 350-356 static void replaceRichContentWithAttachments(Frame& frame, DocumentFragment& fr a/Source/WebCore/editing/cocoa/WebContentReaderCocoa.mm_sec4
350	if (name.isEmpty())	350	if (name.isEmpty())
351	name = "file"_s;	351	name = "file"_s;
352		352
353	attachmentInsertionInfo.append({ WTFMove(name), resource->value->mimeType(), resource->value->data(), object });	353	attachmentInsertionInfo.append({ WTFMove(name), resource->value->mimeType(), resource->value->data().makeContiguous(), object });
354	}	354	}
355		355
356	for (auto& info : attachmentInsertionInfo) {	356	for (auto& info : attachmentInsertionInfo) {
Lines 428-434 struct MarkupAndArchive { a/Source/WebCore/editing/cocoa/WebContentReaderCocoa.mm_sec5
428	Ref<Archive> archive;	428	Ref<Archive> archive;
429	};	429	};
430		430
431	static std::optional<MarkupAndArchive> extractMarkupAndArchive(SharedBuffer& buffer, const std::function<bool(const String)>& canShowMIMETypeAsHTML)	431	static std::optional<MarkupAndArchive> extractMarkupAndArchive(FragmentedSharedBuffer& buffer, const std::function<bool(const String)>& canShowMIMETypeAsHTML)
432	{	432	{
433	auto archive = LegacyWebArchive::create(URL(), buffer);	433	auto archive = LegacyWebArchive::create(URL(), buffer);
434	if (!archive)	434	if (!archive)
Lines 442-448 static std::optional<MarkupAndArchive> extractMarkupAndArchive(SharedBuffer& buf a/Source/WebCore/editing/cocoa/WebContentReaderCocoa.mm_sec6
442	if (!canShowMIMETypeAsHTML(type))	442	if (!canShowMIMETypeAsHTML(type))
443	return std::nullopt;	443	return std::nullopt;
444		444
445	return MarkupAndArchive { String::fromUTF8(mainResource->data().data(), mainResource->data().size()), mainResource.releaseNonNull(), archive.releaseNonNull() };	445	return MarkupAndArchive { String::fromUTF8(mainResource->data().makeContiguous()->data(), mainResource->data().size()), mainResource.releaseNonNull(), archive.releaseNonNull() };
446	}	446	}
447		447
448	static String sanitizeMarkupWithArchive(Frame& frame, Document& destinationDocument, MarkupAndArchive& markupAndArchive, MSOListQuirks msoListQuirks, const std::function<bool(const String)>& canShowMIMETypeAsHTML)	448	static String sanitizeMarkupWithArchive(Frame& frame, Document& destinationDocument, MarkupAndArchive& markupAndArchive, MSOListQuirks msoListQuirks, const std::function<bool(const String)>& canShowMIMETypeAsHTML)
Lines 481-487 static String sanitizeMarkupWithArchive(Frame& frame, Document& destinationDocum a/Source/WebCore/editing/cocoa/WebContentReaderCocoa.mm_sec7
481	if (!shouldReplaceSubresourceURL(subframeURL))	481	if (!shouldReplaceSubresourceURL(subframeURL))
482	continue;	482	continue;
483		483
484	MarkupAndArchive subframeContent = { String::fromUTF8(subframeMainResource->data().data(), subframeMainResource->data().size()),	484	MarkupAndArchive subframeContent = { String::fromUTF8(subframeMainResource->data().makeContiguous()->data(), subframeMainResource->data().size()),
485	subframeMainResource.releaseNonNull(), subframeArchive.copyRef() };	485	subframeMainResource.releaseNonNull(), subframeArchive.copyRef() };
486	auto subframeMarkup = sanitizeMarkupWithArchive(frame, destinationDocument, subframeContent, MSOListQuirks::Disabled, canShowMIMETypeAsHTML);	486	auto subframeMarkup = sanitizeMarkupWithArchive(frame, destinationDocument, subframeContent, MSOListQuirks::Disabled, canShowMIMETypeAsHTML);
487		487
Lines 497-503 static String sanitizeMarkupWithArchive(Frame& frame, Document& destinationDocum a/Source/WebCore/editing/cocoa/WebContentReaderCocoa.mm_sec8
497	return sanitizedMarkupForFragmentInDocument(WTFMove(fragment), *stagingDocument, msoListQuirks, markupAndArchive.markup);	497	return sanitizedMarkupForFragmentInDocument(WTFMove(fragment), *stagingDocument, msoListQuirks, markupAndArchive.markup);
498	}	498	}
499		499
500	bool WebContentReader::readWebArchive(SharedBuffer& buffer)	500	bool WebContentReader::readWebArchive(FragmentedSharedBuffer& buffer)
501	{	501	{
502	if (frame.settings().preferMIMETypeForImages() \|\| !frame.document())	502	if (frame.settings().preferMIMETypeForImages() \|\| !frame.document())
503	return false;	503	return false;
Lines 532-538 bool WebContentReader::readWebArchive(SharedBuffer& buffer) a/Source/WebCore/editing/cocoa/WebContentReaderCocoa.mm_sec9
532	return true;	532	return true;
533	}	533	}
534		534
535	bool WebContentMarkupReader::readWebArchive(SharedBuffer& buffer)	535	bool WebContentMarkupReader::readWebArchive(FragmentedSharedBuffer& buffer)
536	{	536	{
537	if (!frame.document())	537	if (!frame.document())
538	return false;	538	return false;
Lines 612-623 bool WebContentMarkupReader::readHTML(const String& string) a/Source/WebCore/editing/cocoa/WebContentReaderCocoa.mm_sec10
612	return !markup.isEmpty();	612	return !markup.isEmpty();
613	}	613	}
614		614
615	bool WebContentReader::readRTFD(SharedBuffer& buffer)	615	bool WebContentReader::readRTFD(FragmentedSharedBuffer& buffer)
616	{	616	{
617	if (frame.settings().preferMIMETypeForImages() \|\| !frame.document())	617	if (frame.settings().preferMIMETypeForImages() \|\| !frame.document())
618	return false;	618	return false;
619		619
620	auto string = adoptNS([[NSAttributedString alloc] initWithRTFD:buffer.createNSData().get() documentAttributes:nullptr]);	620	auto string = adoptNS([[NSAttributedString alloc] initWithRTFD:buffer.makeContiguous()->createNSData().get() documentAttributes:nullptr]);
621	auto fragment = createFragmentAndAddResources(frame, string.get());	621	auto fragment = createFragmentAndAddResources(frame, string.get());
622	if (!fragment)	622	if (!fragment)
623	return false;	623	return false;
Lines 626-636 bool WebContentReader::readRTFD(SharedBuffer& buffer) a/Source/WebCore/editing/cocoa/WebContentReaderCocoa.mm_sec11
626	return true;	626	return true;
627	}	627	}
628		628
629	bool WebContentMarkupReader::readRTFD(SharedBuffer& buffer)	629	bool WebContentMarkupReader::readRTFD(FragmentedSharedBuffer& buffer)
630	{	630	{
631	if (!frame.document())	631	if (!frame.document())
632	return false;	632	return false;
633	auto string = adoptNS([[NSAttributedString alloc] initWithRTFD:buffer.createNSData().get() documentAttributes:nullptr]);	633	auto string = adoptNS([[NSAttributedString alloc] initWithRTFD:buffer.makeContiguous()->createNSData().get() documentAttributes:nullptr]);
634	auto fragment = createFragmentAndAddResources(frame, string.get());	634	auto fragment = createFragmentAndAddResources(frame, string.get());
635	if (!fragment)	635	if (!fragment)
636	return false;	636	return false;
Lines 639-650 bool WebContentMarkupReader::readRTFD(SharedBuffer& buffer) a/Source/WebCore/editing/cocoa/WebContentReaderCocoa.mm_sec12
639	return true;	639	return true;
640	}	640	}
641		641
642	bool WebContentReader::readRTF(SharedBuffer& buffer)	642	bool WebContentReader::readRTF(FragmentedSharedBuffer& buffer)
643	{	643	{
644	if (frame.settings().preferMIMETypeForImages())	644	if (frame.settings().preferMIMETypeForImages())
645	return false;	645	return false;
646		646
647	auto string = adoptNS([[NSAttributedString alloc] initWithRTF:buffer.createNSData().get() documentAttributes:nullptr]);	647	auto string = adoptNS([[NSAttributedString alloc] initWithRTF:buffer.makeContiguous()->createNSData().get() documentAttributes:nullptr]);
648	auto fragment = createFragmentAndAddResources(frame, string.get());	648	auto fragment = createFragmentAndAddResources(frame, string.get());
649	if (!fragment)	649	if (!fragment)
650	return false;	650	return false;
Lines 653-663 bool WebContentReader::readRTF(SharedBuffer& buffer) a/Source/WebCore/editing/cocoa/WebContentReaderCocoa.mm_sec13
653	return true;	653	return true;
654	}	654	}
655		655
656	bool WebContentMarkupReader::readRTF(SharedBuffer& buffer)	656	bool WebContentMarkupReader::readRTF(FragmentedSharedBuffer& buffer)
657	{	657	{
658	if (!frame.document())	658	if (!frame.document())
659	return false;	659	return false;
660	auto string = adoptNS([[NSAttributedString alloc] initWithRTF:buffer.createNSData().get() documentAttributes:nullptr]);	660	auto string = adoptNS([[NSAttributedString alloc] initWithRTF:buffer.makeContiguous()->createNSData().get() documentAttributes:nullptr]);
661	auto fragment = createFragmentAndAddResources(frame, string.get());	661	auto fragment = createFragmentAndAddResources(frame, string.get());
662	if (!fragment)	662	if (!fragment)
663	return false;	663	return false;
Lines 676-682 bool WebContentReader::readPlainText(const String& text) a/Source/WebCore/editing/cocoa/WebContentReaderCocoa.mm_sec14
676	return true;	676	return true;
677	}	677	}
678		678
679	bool WebContentReader::readImage(Ref<SharedBuffer>&& buffer, const String& type, PresentationSize preferredPresentationSize)	679	bool WebContentReader::readImage(Ref<FragmentedSharedBuffer>&& buffer, const String& type, PresentationSize preferredPresentationSize)
680	{	680	{
681	ASSERT(frame.document());	681	ASSERT(frame.document());
682	auto& document = *frame.document();	682	auto& document = *frame.document();
Lines 746-752 ALLOW_DEPRECATED_DECLARATIONS_END a/Source/WebCore/editing/cocoa/WebContentReaderCocoa.mm_sec15
746	return attachment;	746	return attachment;
747	}	747	}
748		748
749	static Ref<HTMLElement> attachmentForData(Frame& frame, SharedBuffer& buffer, const String& contentType, const String& name, PresentationSize preferredSize)	749	static Ref<HTMLElement> attachmentForData(Frame& frame, FragmentedSharedBuffer& buffer, const String& contentType, const String& name, PresentationSize preferredSize)
750	{	750	{
751	Ref document = *frame.document();	751	Ref document = *frame.document();
752	auto attachment = HTMLAttachmentElement::create(HTMLNames::attachmentTag, document);	752	auto attachment = HTMLAttachmentElement::create(HTMLNames::attachmentTag, document);
Lines 833-839 bool WebContentReader::readURL(const URL& url, const String& title) a/Source/WebCore/editing/cocoa/WebContentReaderCocoa.mm_sec16
833	return true;	833	return true;
834	}	834	}
835		835
836	bool WebContentReader::readDataBuffer(SharedBuffer& buffer, const String& type, const String& name, PresentationSize preferredPresentationSize)	836	bool WebContentReader::readDataBuffer(FragmentedSharedBuffer& buffer, const String& type, const String& name, PresentationSize preferredPresentationSize)
837	{	837	{
838	if (buffer.isEmpty())	838	if (buffer.isEmpty())
839	return false;	839	return false;

Lines 43-49 namespace WebCore { a/Source/WebCore/fileapi/NetworkSendQueue.h_sec1
- a/Source/WebCore/fileapi/NetworkSendQueue.h -2 / +2 lines
43		43
44	class Blob;	44	class Blob;
45	class BlobLoader;	45	class BlobLoader;
46	class SharedBuffer;	46	class FragmentedSharedBuffer;
47		47
48	class WEBCORE_EXPORT NetworkSendQueue : public ContextDestructionObserver {	48	class WEBCORE_EXPORT NetworkSendQueue : public ContextDestructionObserver {
49	public:	49	public:
Lines 63-69 public: a/Source/WebCore/fileapi/NetworkSendQueue.h_sec2
63	private:	63	private:
64	void processMessages();	64	void processMessages();
65		65
66	using Message = std::variant<CString, Ref<SharedBuffer>, UniqueRef<BlobLoader>>;	66	using Message = std::variant<CString, Ref<FragmentedSharedBuffer>, UniqueRef<BlobLoader>>;
67	Deque<Message> m_queue;	67	Deque<Message> m_queue;
68		68
69	WriteString m_writeString;	69	WriteString m_writeString;

Lines 36-42 class File; a/Source/WebCore/html/HTMLAttachmentElement.h_sec1
- a/Source/WebCore/html/HTMLAttachmentElement.h -2 / +2 lines
36	class HTMLImageElement;	36	class HTMLImageElement;
37	class RenderAttachment;	37	class RenderAttachment;
38	class ShareableBitmap;	38	class ShareableBitmap;
39	class SharedBuffer;	39	class FragmentedSharedBuffer;
40		40
41	class HTMLAttachmentElement final : public HTMLElement {	41	class HTMLAttachmentElement final : public HTMLElement {
42	WTF_MAKE_ISO_ALLOCATED(HTMLAttachmentElement);	42	WTF_MAKE_ISO_ALLOCATED(HTMLAttachmentElement);
Lines 57-63 public: a/Source/WebCore/html/HTMLAttachmentElement.h_sec2
57	void copyNonAttributePropertiesFromElement(const Element&) final;	57	void copyNonAttributePropertiesFromElement(const Element&) final;
58		58
59	WEBCORE_EXPORT void updateAttributes(std::optional<uint64_t>&& newFileSize, const String& newContentType, const String& newFilename);	59	WEBCORE_EXPORT void updateAttributes(std::optional<uint64_t>&& newFileSize, const String& newContentType, const String& newFilename);
60	WEBCORE_EXPORT void updateEnclosingImageWithData(const String& contentType, Ref<SharedBuffer>&& data);	60	WEBCORE_EXPORT void updateEnclosingImageWithData(const String& contentType, Ref<FragmentedSharedBuffer>&& data);
61	WEBCORE_EXPORT void updateThumbnail(const RefPtr<Image>& thumbnail);	61	WEBCORE_EXPORT void updateThumbnail(const RefPtr<Image>& thumbnail);
62		62
63	InsertedIntoAncestorResult insertedIntoAncestor(InsertionType, ContainerNode&) final;	63	InsertedIntoAncestorResult insertedIntoAncestor(InsertionType, ContainerNode&) final;

Lines 141-147 void ImageDocument::updateDuringParsing() a/Source/WebCore/html/ImageDocument.cpp_sec1
- a/Source/WebCore/html/ImageDocument.cpp -2 / +2 lines
141	if (!m_imageElement)	141	if (!m_imageElement)
142	createDocumentStructure();	142	createDocumentStructure();
143		143
144	if (RefPtr<SharedBuffer> buffer = loader()->mainResourceData())	144	if (RefPtr<FragmentedSharedBuffer> buffer = loader()->mainResourceData())
145	m_imageElement->cachedImage()->updateBuffer(*buffer);	145	m_imageElement->cachedImage()->updateBuffer(*buffer);
146		146
147	imageUpdated();	147	imageUpdated();
Lines 151-157 void ImageDocument::finishedParsing() a/Source/WebCore/html/ImageDocument.cpp_sec2
151	{	151	{
152	if (!parser()->isStopped() && m_imageElement) {	152	if (!parser()->isStopped() && m_imageElement) {
153	CachedImage& cachedImage = *m_imageElement->cachedImage();	153	CachedImage& cachedImage = *m_imageElement->cachedImage();
154	RefPtr<SharedBuffer> data = loader()->mainResourceData();	154	RefPtr<FragmentedSharedBuffer> data = loader()->mainResourceData();
155		155
156	// If this is a multipart image, make a copy of the current part, since the resource data	156	// If this is a multipart image, make a copy of the current part, since the resource data
157	// will be overwritten by the next part.	157	// will be overwritten by the next part.

Lines 36-55 class Frame; a/Source/WebCore/inspector/InspectorInstrumentationWebKit.h_sec1
- a/Source/WebCore/inspector/InspectorInstrumentationWebKit.h -4 / +4 lines
36	class ResourceLoader;	36	class ResourceLoader;
37	class ResourceRequest;	37	class ResourceRequest;
38	class ResourceResponse;	38	class ResourceResponse;
39	class SharedBuffer;	39	class FragmentedSharedBuffer;
40		40
41	class WEBCORE_EXPORT InspectorInstrumentationWebKit {	41	class WEBCORE_EXPORT InspectorInstrumentationWebKit {
42	public:	42	public:
43	static bool shouldInterceptRequest(const Frame*, const ResourceRequest&);	43	static bool shouldInterceptRequest(const Frame*, const ResourceRequest&);
44	static bool shouldInterceptResponse(const Frame*, const ResourceResponse&);	44	static bool shouldInterceptResponse(const Frame*, const ResourceResponse&);
45	static void interceptRequest(ResourceLoader&, Function<void(const ResourceRequest&)>&&);	45	static void interceptRequest(ResourceLoader&, Function<void(const ResourceRequest&)>&&);
46	static void interceptResponse(const Frame*, const ResourceResponse&, ResourceLoaderIdentifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&&);	46	static void interceptResponse(const Frame*, const ResourceResponse&, ResourceLoaderIdentifier, CompletionHandler<void(const ResourceResponse&, RefPtr<FragmentedSharedBuffer>)>&&);
47		47
48	private:	48	private:
49	static bool shouldInterceptRequestInternal(const Frame&, const ResourceRequest&);	49	static bool shouldInterceptRequestInternal(const Frame&, const ResourceRequest&);
50	static bool shouldInterceptResponseInternal(const Frame&, const ResourceResponse&);	50	static bool shouldInterceptResponseInternal(const Frame&, const ResourceResponse&);
51	static void interceptRequestInternal(ResourceLoader&, Function<void(const ResourceRequest&)>&&);	51	static void interceptRequestInternal(ResourceLoader&, Function<void(const ResourceRequest&)>&&);
52	static void interceptResponseInternal(const Frame&, const ResourceResponse&, ResourceLoaderIdentifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&&);	52	static void interceptResponseInternal(const Frame&, const ResourceResponse&, ResourceLoaderIdentifier, CompletionHandler<void(const ResourceResponse&, RefPtr<FragmentedSharedBuffer>)>&&);
53	};	53	};
54		54
55	inline bool InspectorInstrumentationWebKit::shouldInterceptRequest(const Frame* frame, const ResourceRequest& request)	55	inline bool InspectorInstrumentationWebKit::shouldInterceptRequest(const Frame* frame, const ResourceRequest& request)
Lines 76-82 inline void InspectorInstrumentationWebKit::interceptRequest(ResourceLoader& loa a/Source/WebCore/inspector/InspectorInstrumentationWebKit.h_sec2
76	interceptRequestInternal(loader, WTFMove(handler));	76	interceptRequestInternal(loader, WTFMove(handler));
77	}	77	}
78		78
79	inline void InspectorInstrumentationWebKit::interceptResponse(const Frame* frame, const ResourceResponse& response, ResourceLoaderIdentifier identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&& handler)	79	inline void InspectorInstrumentationWebKit::interceptResponse(const Frame* frame, const ResourceResponse& response, ResourceLoaderIdentifier identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<FragmentedSharedBuffer>)>&& handler)
80	{	80	{
81	ASSERT(InspectorInstrumentationWebKit::shouldInterceptResponse(frame, response));	81	ASSERT(InspectorInstrumentationWebKit::shouldInterceptResponse(frame, response));
82	interceptResponseInternal(*frame, response, identifier, WTFMove(handler));	82	interceptResponseInternal(*frame, response, identifier, WTFMove(handler));

Lines 32-37 a/Source/WebCore/inspector/NetworkResourcesData.h_sec1
- a/Source/WebCore/inspector/NetworkResourcesData.h -8 / +10 lines
32	#include "InspectorPageAgent.h"	32	#include "InspectorPageAgent.h"
33	#include <wtf/Deque.h>	33	#include <wtf/Deque.h>
34	#include <wtf/HashMap.h>	34	#include <wtf/HashMap.h>
		35	#include <wtf/UniqueRef.h>
35	#include <wtf/WallTime.h>	36	#include <wtf/WallTime.h>
36	#include <wtf/text/WTFString.h>	37	#include <wtf/text/WTFString.h>
37		38
Lines 40-46 namespace WebCore { a/Source/WebCore/inspector/NetworkResourcesData.h_sec2
40	class CachedResource;	41	class CachedResource;
41	class ResourceResponse;	42	class ResourceResponse;
42	class TextResourceDecoder;	43	class TextResourceDecoder;
43	class SharedBuffer;	44	class FragmentedSharedBuffer;
		45	class SharedBufferBuilder;
44		46
45	class NetworkResourcesData {	47	class NetworkResourcesData {
46	WTF_MAKE_FAST_ALLOCATED;	48	WTF_MAKE_FAST_ALLOCATED;
Lines 88-95 public: a/Source/WebCore/inspector/NetworkResourcesData.h_sec3
88	RefPtr<TextResourceDecoder> decoder() const { return m_decoder.copyRef(); }	90	RefPtr<TextResourceDecoder> decoder() const { return m_decoder.copyRef(); }
89	void setDecoder(RefPtr<TextResourceDecoder>&& decoder) { m_decoder = WTFMove(decoder); }	91	void setDecoder(RefPtr<TextResourceDecoder>&& decoder) { m_decoder = WTFMove(decoder); }
90		92
91	RefPtr<SharedBuffer> buffer() const { return m_buffer.copyRef(); }	93	RefPtr<FragmentedSharedBuffer> buffer() const { return m_buffer.copyRef(); }
92	void setBuffer(RefPtr<SharedBuffer>&& buffer) { m_buffer = WTFMove(buffer); }	94	void setBuffer(RefPtr<FragmentedSharedBuffer>&& buffer) { m_buffer = WTFMove(buffer); }
93		95
94	const std::optional<CertificateInfo>& certificateInfo() const { return m_certificateInfo; }	96	const std::optional<CertificateInfo>& certificateInfo() const { return m_certificateInfo; }
95	void setCertificateInfo(const std::optional<CertificateInfo>& certificateInfo) { m_certificateInfo = certificateInfo; }	97	void setCertificateInfo(const std::optional<CertificateInfo>& certificateInfo) { m_certificateInfo = certificateInfo; }
Lines 103-112 public: a/Source/WebCore/inspector/NetworkResourcesData.h_sec4
103	WallTime responseTimestamp() const { return m_responseTimestamp; }	105	WallTime responseTimestamp() const { return m_responseTimestamp; }
104	void setResponseTimestamp(WallTime time) { m_responseTimestamp = time; }	106	void setResponseTimestamp(WallTime time) { m_responseTimestamp = time; }
105		107
106	bool hasBufferedData() const { return m_dataBuffer; }	108	bool hasBufferedData() const { return hasData(); }
107		109
108	private:	110	private:
109	bool hasData() const { return m_dataBuffer; }	111	bool hasData() const;
110	size_t dataLength() const;	112	size_t dataLength() const;
111	void appendData(const uint8_t* data, size_t dataLength);	113	void appendData(const uint8_t* data, size_t dataLength);
112	unsigned decodeDataToContent();	114	unsigned decodeDataToContent();
Lines 119-126 public: a/Source/WebCore/inspector/NetworkResourcesData.h_sec5
119	String m_textEncodingName;	121	String m_textEncodingName;
120	String m_mimeType;	122	String m_mimeType;
121	RefPtr<TextResourceDecoder> m_decoder;	123	RefPtr<TextResourceDecoder> m_decoder;
122	RefPtr<SharedBuffer> m_dataBuffer;	124	UniqueRef<SharedBufferBuilder> m_dataBuffer;
123	RefPtr<SharedBuffer> m_buffer;	125	RefPtr<FragmentedSharedBuffer> m_buffer;
124	std::optional<CertificateInfo> m_certificateInfo;	126	std::optional<CertificateInfo> m_certificateInfo;
125	CachedResource* m_cachedResource { nullptr };	127	CachedResource* m_cachedResource { nullptr };
126	InspectorPageAgent::ResourceType m_type { InspectorPageAgent::OtherResource };	128	InspectorPageAgent::ResourceType m_type { InspectorPageAgent::OtherResource };
Lines 144-150 public: a/Source/WebCore/inspector/NetworkResourcesData.h_sec6
144	ResourceData const* maybeAddResourceData(const String& requestId, const uint8_t* data, size_t dataLength);	146	ResourceData const* maybeAddResourceData(const String& requestId, const uint8_t* data, size_t dataLength);
145	void maybeDecodeDataToContent(const String& requestId);	147	void maybeDecodeDataToContent(const String& requestId);
146	void addCachedResource(const String& requestId, CachedResource*);	148	void addCachedResource(const String& requestId, CachedResource*);
147	void addResourceSharedBuffer(const String& requestId, RefPtr<SharedBuffer>&&, const String& textEncodingName);	149	void addResourceSharedBuffer(const String& requestId, RefPtr<FragmentedSharedBuffer>&&, const String& textEncodingName);
148	ResourceData const* data(const String& requestId);	150	ResourceData const* data(const String& requestId);
149	ResourceData const* dataForURL(const String& url);	151	ResourceData const* dataForURL(const String& url);
150	Vector<String> removeCachedResource(CachedResource*);	152	Vector<String> removeCachedResource(CachedResource*);

Lines 1140-1146 void InspectorNetworkAgent::interceptRequest(ResourceLoader& loader, Function<vo a/Source/WebCore/inspector/agents/InspectorNetworkAgent.cpp_sec1
- a/Source/WebCore/inspector/agents/InspectorNetworkAgent.cpp -5 / +5 lines
1140	m_frontendDispatcher->requestIntercepted(requestId, buildObjectForResourceRequest(loader.request()));	1140	m_frontendDispatcher->requestIntercepted(requestId, buildObjectForResourceRequest(loader.request()));
1141	}	1141	}
1142		1142
1143	void InspectorNetworkAgent::interceptResponse(const ResourceResponse& response, ResourceLoaderIdentifier identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&& handler)	1143	void InspectorNetworkAgent::interceptResponse(const ResourceResponse& response, ResourceLoaderIdentifier identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<FragmentedSharedBuffer>)>&& handler)
1144	{	1144	{
1145	ASSERT(m_enabled);	1145	ASSERT(m_enabled);
1146	ASSERT(m_interceptionEnabled);	1146	ASSERT(m_interceptionEnabled);
Lines 1243-1249 Protocol::ErrorStringOr<void> InspectorNetworkAgent::interceptWithResponse(const a/Source/WebCore/inspector/agents/InspectorNetworkAgent.cpp_sec2
1243	overrideResponse.setHTTPHeaderField(HTTPHeaderName::ContentType, overrideResponse.mimeType());	1243	overrideResponse.setHTTPHeaderField(HTTPHeaderName::ContentType, overrideResponse.mimeType());
1244	}	1244	}
1245		1245
1246	RefPtr<SharedBuffer> overrideData;	1246	RefPtr<FragmentedSharedBuffer> overrideData;
1247	if (base64Encoded) {	1247	if (base64Encoded) {
1248	auto buffer = base64Decode(content);	1248	auto buffer = base64Decode(content);
1249	if (!buffer)	1249	if (!buffer)
Lines 1271-1277 Protocol::ErrorStringOr<void> InspectorNetworkAgent::interceptRequestWithRespons a/Source/WebCore/inspector/agents/InspectorNetworkAgent.cpp_sec3
1271	if (loader->reachedTerminalState())	1271	if (loader->reachedTerminalState())
1272	return makeUnexpected("Unable to fulfill request, it has already been processed"_s);	1272	return makeUnexpected("Unable to fulfill request, it has already been processed"_s);
1273		1273
1274	RefPtr<SharedBuffer> data;	1274	RefPtr<FragmentedSharedBuffer> data;
1275	if (base64Encoded) {	1275	if (base64Encoded) {
1276	auto buffer = base64Decode(content);	1276	auto buffer = base64Decode(content);
1277	if (!buffer)	1277	if (!buffer)
Lines 1407-1418 bool InspectorNetworkAgent::cachedResourceContent(CachedResource& resource, Stri a/Source/WebCore/inspector/agents/InspectorNetworkAgent.cpp_sec4
1407	if (InspectorNetworkAgent::shouldTreatAsText(resource.mimeType())) {	1407	if (InspectorNetworkAgent::shouldTreatAsText(resource.mimeType())) {
1408	auto decoder = InspectorNetworkAgent::createTextDecoder(resource.mimeType(), resource.response().textEncodingName());	1408	auto decoder = InspectorNetworkAgent::createTextDecoder(resource.mimeType(), resource.response().textEncodingName());
1409	*base64Encoded = false;	1409	*base64Encoded = false;
1410	*result = decoder->decodeAndFlush(buffer->data(), buffer->size());	1410	*result = decoder->decodeAndFlush(buffer->makeContiguous()->data(), buffer->size());
1411	return true;	1411	return true;
1412	}	1412	}
1413		1413
1414	*base64Encoded = true;	1414	*base64Encoded = true;
1415	*result = base64EncodeToString(buffer->data(), buffer->size());	1415	*result = base64EncodeToString(buffer->makeContiguous()->data(), buffer->size());
1416	return true;	1416	return true;
1417	}	1417	}
1418	}	1418	}