Attachment 446538 Details for Bug 233923 – Patch for EWS

[patch] Patch for EWS

patch.diff (text/plain), 736.71 KB, created by Jean-Yves Avenard [:jya] on 2021-12-09 06:37:42 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Jean-Yves Avenard [:jya]

Created: 2021-12-09 06:37:42 PST

Size: 736.71 KB

patch

obsolete

>diff --git a/PerformanceTests/ChangeLog b/PerformanceTests/ChangeLog
>index f01ab90b477d..5a1f40ad2e1a 100644
>--- a/PerformanceTests/ChangeLog
>+++ b/PerformanceTests/ChangeLog
>@@ -1,3 +1,13 @@
>+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-12-08  Alan Bujtas  <zalan@apple.com>
> 
>         Add layout performance test for simple bidi content with inline boxes
>diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog
>index 05398c36bf97..fab0ed18986f 100644
>--- a/Source/JavaScriptCore/ChangeLog
>+++ b/Source/JavaScriptCore/ChangeLog
>@@ -1,3 +1,17 @@
>+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-09  Yusuke Suzuki  <ysuzuki@apple.com>
> 
>         [JSC] Introduce BaselineCallLinkInfo and OptimizingCallLinkInfo to shrink sizeof(BaselineCallLinkInfo)
>diff --git a/Source/JavaScriptCore/runtime/ArrayBuffer.h b/Source/JavaScriptCore/runtime/ArrayBuffer.h
>index eacca2c233a8..b4693f91c607 100644
>--- a/Source/JavaScriptCore/runtime/ArrayBuffer.h
>+++ b/Source/JavaScriptCore/runtime/ArrayBuffer.h
>@@ -129,7 +129,7 @@ public:
>     JS_EXPORT_PRIVATE static RefPtr<ArrayBuffer> tryCreate(ArrayBuffer&);
>     JS_EXPORT_PRIVATE static RefPtr<ArrayBuffer> tryCreate(const void* source, size_t byteLength);
> 
>-    // Only for use by Uint8ClampedArray::tryCreateUninitialized and SharedBuffer::tryCreateArrayBuffer.
>+    // Only for use by Uint8ClampedArray::tryCreateUninitialized and FragmentedSharedBuffer::tryCreateArrayBuffer.
>     JS_EXPORT_PRIVATE static Ref<ArrayBuffer> createUninitialized(size_t numElements, unsigned elementByteSize);
>     JS_EXPORT_PRIVATE static RefPtr<ArrayBuffer> tryCreateUninitialized(size_t numElements, unsigned elementByteSize);
> 
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 64f022750147..e37334ca596d 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,1073 @@
>+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
>+        rdar://problem/86149850
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Covered by existing API tests.
>+
>+        * 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.
>+
>+        A SharedBufferBuilder is a replacement to RefPtr<SharedBuffer>.
>+        There exists a difference between a null and empty state.
>+        Following a call to reset(), SharedBufferBuilder::isNull()
>+        will return true as opposed to empty() which will create the underlying
>+        SharedBuffer but with a size of 0.
>+        A null SharedBufferBuilder indicates that append was never called on it
>+        (even with an empty SharedBuffer).
>+        It is not necessary to check if the SharedBufferBuilder is null before
>+        calling copy() or take() as an empty SharedBuffer will be created if
>+        none exists.
>+        These design decisions were made due to how SharedBuffer are currently used
>+        and to minimise the logic change as some places would distinguish between
>+        the two states or would always create an empty SharedBuffer and only check
>+        its size.
>+        In the future, removing the distinction between null and pty would be
>+        preferable.
>+
>+        While the aim was to guarantee that a SharedBuffer once built was immutable.
>+        This goal wasn't entirely achieved as it is still possible to retrieve a RefPtr
>+        to a SharedBuffer and continue to append to it through its SharedBufferBuilder
>+        owner. Full immutability could be fully achieved with having get() return a
>+        shallow copy which is a relatively cheap operation.
>+
>+        Fly-By fixes: 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-09  Myles C. Maxfield  <mmaxfield@apple.com> and Don Olmstead  <don.olmstead@sony.com>
> 
>         Move TextCodec files from WebCore/platform/text to WebCore/PAL/text
>diff --git a/Source/WebCore/Modules/async-clipboard/ClipboardImageReader.cpp b/Source/WebCore/Modules/async-clipboard/ClipboardImageReader.cpp
>index 3354b52a50cb..da336e6f5b16 100644
>--- a/Source/WebCore/Modules/async-clipboard/ClipboardImageReader.cpp
>+++ b/Source/WebCore/Modules/async-clipboard/ClipboardImageReader.cpp
>@@ -33,7 +33,7 @@ namespace WebCore {
> 
> #if !PLATFORM(COCOA)
> 
>-void ClipboardImageReader::readBuffer(const String&, const String&, Ref<SharedBuffer>&&)
>+void ClipboardImageReader::readBuffer(const String&, const String&, Ref<FragmentedSharedBuffer>&&)
> {
>     notImplemented();
> }
>diff --git a/Source/WebCore/Modules/async-clipboard/ClipboardImageReader.h b/Source/WebCore/Modules/async-clipboard/ClipboardImageReader.h
>index 2b62628419b0..6e22048cf5fe 100644
>--- a/Source/WebCore/Modules/async-clipboard/ClipboardImageReader.h
>+++ b/Source/WebCore/Modules/async-clipboard/ClipboardImageReader.h
>@@ -31,7 +31,7 @@
> namespace WebCore {
> 
> class Document;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> struct ClipboardImageReader : PasteboardFileReader {
>     ClipboardImageReader(Document* document, const String& mimeType)
>@@ -47,7 +47,7 @@ private:
>     void readFilename(const String&) final { ASSERT_NOT_REACHED(); }
> 
>     bool shouldReadBuffer(const String&) const final;
>-    void readBuffer(const String& filename, const String& type, Ref<SharedBuffer>&&) final;
>+    void readBuffer(const String& filename, const String& type, Ref<FragmentedSharedBuffer>&&) final;
> 
>     RefPtr<Document> m_document;
>     String m_mimeType;
>diff --git a/Source/WebCore/Modules/async-clipboard/ClipboardItemBindingsDataSource.cpp b/Source/WebCore/Modules/async-clipboard/ClipboardItemBindingsDataSource.cpp
>index d0746da2da20..eff10b5b65fd 100644
>--- a/Source/WebCore/Modules/async-clipboard/ClipboardItemBindingsDataSource.cpp
>+++ b/Source/WebCore/Modules/async-clipboard/ClipboardItemBindingsDataSource.cpp
>@@ -216,8 +216,8 @@ void ClipboardItemBindingsDataSource::invokeCompletionHandler()
>         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<SharedBuffer>>(data))
>-            customData.writeData(type, std::get<Ref<SharedBuffer>>(data).copyRef());
>+        else if (std::holds_alternative<Ref<FragmentedSharedBuffer>>(data))
>+            customData.writeData(type, std::get<Ref<FragmentedSharedBuffer>>(data).copyRef());
>         else {
>             completionHandler(std::nullopt);
>             return;
>@@ -265,9 +265,9 @@ void ClipboardItemBindingsDataSource::ClipboardItemTypeLoader::sanitizeDataIfNee
> {
>     if (m_type == "text/html"_s) {
>         String markupToSanitize;
>-        if (std::holds_alternative<Ref<SharedBuffer>>(m_data)) {
>-            auto& buffer = std::get<Ref<SharedBuffer>>(m_data);
>-            markupToSanitize = String::fromUTF8(buffer->data(), buffer->size());
>+        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);
> 
>@@ -278,9 +278,9 @@ void ClipboardItemBindingsDataSource::ClipboardItemTypeLoader::sanitizeDataIfNee
>     }
> 
>     if (m_type == "image/png"_s) {
>-        RefPtr<SharedBuffer> bufferToSanitize;
>-        if (std::holds_alternative<Ref<SharedBuffer>>(m_data))
>-            bufferToSanitize = std::get<Ref<SharedBuffer>>(m_data).ptr();
>+        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));
> 
>diff --git a/Source/WebCore/Modules/async-clipboard/ClipboardItemBindingsDataSource.h b/Source/WebCore/Modules/async-clipboard/ClipboardItemBindingsDataSource.h
>index 2cc2c8e1a54e..37c825e235a8 100644
>--- a/Source/WebCore/Modules/async-clipboard/ClipboardItemBindingsDataSource.h
>+++ b/Source/WebCore/Modules/async-clipboard/ClipboardItemBindingsDataSource.h
>@@ -38,7 +38,7 @@ class DOMPromise;
> class FileReaderLoader;
> class PasteboardCustomData;
> class ScriptExecutionContext;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class ClipboardItemBindingsDataSource : public ClipboardItemDataSource {
>     WTF_MAKE_FAST_ALLOCATED;
>@@ -53,7 +53,7 @@ private:
> 
>     void invokeCompletionHandler();
> 
>-    using BufferOrString = std::variant<String, Ref<SharedBuffer>>;
>+    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)
>diff --git a/Source/WebCore/Modules/async-clipboard/ios/ClipboardImageReaderIOS.mm b/Source/WebCore/Modules/async-clipboard/ios/ClipboardImageReaderIOS.mm
>index 4302361e6fe2..274e038d4187 100644
>--- a/Source/WebCore/Modules/async-clipboard/ios/ClipboardImageReaderIOS.mm
>+++ b/Source/WebCore/Modules/async-clipboard/ios/ClipboardImageReaderIOS.mm
>@@ -34,10 +34,10 @@
> 
> namespace WebCore {
> 
>-void ClipboardImageReader::readBuffer(const String&, const String&, Ref<SharedBuffer>&& buffer)
>+void ClipboardImageReader::readBuffer(const String&, const String&, Ref<FragmentedSharedBuffer>&& buffer)
> {
>     if (m_mimeType == "image/png") {
>-        auto image = adoptNS([PAL::allocUIImageInstance() initWithData:buffer->createNSData().get()]);
>+        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);
>     }
>diff --git a/Source/WebCore/Modules/async-clipboard/mac/ClipboardImageReaderMac.mm b/Source/WebCore/Modules/async-clipboard/mac/ClipboardImageReaderMac.mm
>index b4c31ca50639..3821b0371802 100644
>--- a/Source/WebCore/Modules/async-clipboard/mac/ClipboardImageReaderMac.mm
>+++ b/Source/WebCore/Modules/async-clipboard/mac/ClipboardImageReaderMac.mm
>@@ -33,10 +33,10 @@
> 
> namespace WebCore {
> 
>-void ClipboardImageReader::readBuffer(const String&, const String&, Ref<SharedBuffer>&& buffer)
>+void ClipboardImageReader::readBuffer(const String&, const String&, Ref<FragmentedSharedBuffer>&& buffer)
> {
>     if (m_mimeType == "image/png") {
>-        auto image = adoptNS([[NSImage alloc] initWithData:buffer->createNSData().get()]);
>+        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:@{ }];
>diff --git a/Source/WebCore/Modules/cache/DOMCache.cpp b/Source/WebCore/Modules/cache/DOMCache.cpp
>index e6cc1aae783a..95aa086594a6 100644
>--- a/Source/WebCore/Modules/cache/DOMCache.cpp
>+++ b/Source/WebCore/Modules/cache/DOMCache.cpp
>@@ -289,7 +289,7 @@ void DOMCache::addAll(Vector<RequestInfo>&& infos, DOMPromiseDeferred<void>&& pr
>             }
>             size_t recordPosition = taskHandler->addRecord(toConnectionRecord(request.get(), response, nullptr));
> 
>-            response.consumeBodyReceivedByChunk([taskHandler = WTFMove(taskHandler), recordPosition, data = SharedBuffer::create(), response = Ref { response }] (auto&& result) mutable {
>+            response.consumeBodyReceivedByChunk([taskHandler = WTFMove(taskHandler), recordPosition, data = SharedBufferBuilder(), response = Ref { response }] (auto&& result) mutable {
>                 if (taskHandler->isDone())
>                     return;
> 
>@@ -299,9 +299,9 @@ void DOMCache::addAll(Vector<RequestInfo>&& infos, DOMPromiseDeferred<void>&& pr
>                 }
> 
>                 if (auto* chunk = result.returnValue())
>-                    data->append(chunk->data(), chunk->size());
>+                    data.append(chunk->data(), chunk->size());
>                 else
>-                    taskHandler->addResponseBody(recordPosition, response, WTFMove(data));
>+                    taskHandler->addResponseBody(recordPosition, response, data.takeAsContiguous());
>             });
>         }, cachedResourceRequestInitiators().fetch);
>     }
>@@ -318,7 +318,7 @@ void DOMCache::putWithResponseData(DOMPromiseDeferred<void>&& promise, Ref<Fetch
> 
>     DOMCacheEngine::ResponseBody body;
>     if (auto buffer = responseBody.releaseReturnValue())
>-        body = buffer.releaseNonNull();
>+        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));
>@@ -375,7 +375,7 @@ void DOMCache::put(RequestInfo&& info, Ref<FetchResponse>&& response, DOMPromise
> 
>     if (response->isBodyReceivedByChunk()) {
>         auto& responseRef = response.get();
>-        responseRef.consumeBodyReceivedByChunk([promise = WTFMove(promise), request = WTFMove(request), response = WTFMove(response), data = SharedBuffer::create(), pendingActivity = makePendingActivity(*this), this](auto&& result) mutable {
>+        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());
>@@ -383,9 +383,9 @@ void DOMCache::put(RequestInfo&& info, Ref<FetchResponse>&& response, DOMPromise
>             }
> 
>             if (auto* chunk = result.returnValue())
>-                data->append(chunk->data(), chunk->size());
>+                data.append(chunk->data(), chunk->size());
>             else
>-                this->putWithResponseData(WTFMove(promise), WTFMove(request), WTFMove(response), RefPtr<SharedBuffer> { WTFMove(data) });
>+                this->putWithResponseData(WTFMove(promise), WTFMove(request), WTFMove(response), RefPtr<SharedBuffer> { data.takeAsContiguous() });
>         });
>         return;
>     }
>diff --git a/Source/WebCore/Modules/cache/DOMCacheEngine.cpp b/Source/WebCore/Modules/cache/DOMCacheEngine.cpp
>index 25914b40bb23..c0f8032b0452 100644
>--- a/Source/WebCore/Modules/cache/DOMCacheEngine.cpp
>+++ b/Source/WebCore/Modules/cache/DOMCacheEngine.cpp
>@@ -132,7 +132,7 @@ ResponseBody isolatedResponseBody(const ResponseBody& body)
>     return WTF::switchOn(body, [](const Ref<FormData>& formData) -> ResponseBody {
>         return formData->isolatedCopy();
>     }, [](const Ref<SharedBuffer>& buffer) -> ResponseBody {
>-        return buffer->copy();
>+        return buffer.copyRef(); // SharedBuffer are immutable and can be returned as-is.
>     }, [](const std::nullptr_t&) -> ResponseBody {
>         return DOMCacheEngine::ResponseBody { };
>     });
>diff --git a/Source/WebCore/Modules/encryptedmedia/CDM.cpp b/Source/WebCore/Modules/encryptedmedia/CDM.cpp
>index 2850dba1e3bf..9d1bc674fc82 100644
>--- a/Source/WebCore/Modules/encryptedmedia/CDM.cpp
>+++ b/Source/WebCore/Modules/encryptedmedia/CDM.cpp
>@@ -135,17 +135,17 @@ bool CDM::supportsInitDataType(const AtomString& initDataType) const
>     return m_private && m_private->supportedInitDataTypes().contains(initDataType);
> }
> 
>-RefPtr<SharedBuffer> CDM::sanitizeInitData(const AtomString& initDataType, const SharedBuffer& initData)
>+RefPtr<FragmentedSharedBuffer> CDM::sanitizeInitData(const AtomString& initDataType, const FragmentedSharedBuffer& initData)
> {
>     return InitDataRegistry::shared().sanitizeInitData(initDataType, initData);
> }
> 
>-bool CDM::supportsInitData(const AtomString& initDataType, const SharedBuffer& initData)
>+bool CDM::supportsInitData(const AtomString& initDataType, const FragmentedSharedBuffer& initData)
> {
>     return m_private && m_private->supportsInitData(initDataType, initData);
> }
> 
>-RefPtr<SharedBuffer> CDM::sanitizeResponse(const SharedBuffer& response)
>+RefPtr<FragmentedSharedBuffer> CDM::sanitizeResponse(const FragmentedSharedBuffer& response)
> {
>     if (!m_private)
>         return nullptr;
>diff --git a/Source/WebCore/Modules/encryptedmedia/CDM.h b/Source/WebCore/Modules/encryptedmedia/CDM.h
>index d8a4b3af12f1..d7b1d53d0491 100644
>--- a/Source/WebCore/Modules/encryptedmedia/CDM.h
>+++ b/Source/WebCore/Modules/encryptedmedia/CDM.h
>@@ -52,7 +52,7 @@ class CDMInstance;
> class CDMPrivate;
> class Document;
> class ScriptExecutionContext;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class CDM : public RefCounted<CDM>, public CanMakeWeakPtr<CDM>, private ContextDestructionObserver {
> public:
>@@ -73,10 +73,10 @@ public:
>     bool supportsSessions() const;
>     bool supportsInitDataType(const AtomString&) const;
> 
>-    RefPtr<SharedBuffer> sanitizeInitData(const AtomString& initDataType, const SharedBuffer&);
>-    bool supportsInitData(const AtomString& initDataType, const SharedBuffer&);
>+    RefPtr<FragmentedSharedBuffer> sanitizeInitData(const AtomString& initDataType, const FragmentedSharedBuffer&);
>+    bool supportsInitData(const AtomString& initDataType, const FragmentedSharedBuffer&);
> 
>-    RefPtr<SharedBuffer> sanitizeResponse(const SharedBuffer&);
>+    RefPtr<FragmentedSharedBuffer> sanitizeResponse(const FragmentedSharedBuffer&);
> 
>     std::optional<String> sanitizeSessionId(const String& sessionId);
> 
>diff --git a/Source/WebCore/Modules/encryptedmedia/CDMClient.h b/Source/WebCore/Modules/encryptedmedia/CDMClient.h
>index 21e52f4b714f..410ed2fb6427 100644
>--- a/Source/WebCore/Modules/encryptedmedia/CDMClient.h
>+++ b/Source/WebCore/Modules/encryptedmedia/CDMClient.h
>@@ -36,14 +36,14 @@
> namespace WebCore {
> 
> class CDMInstance;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class CDMClient : public CanMakeWeakPtr<CDMClient> {
> public:
>     virtual ~CDMClient() = default;
> 
>     virtual void cdmClientAttemptToResumePlaybackIfNecessary() = 0;
>-    virtual void cdmClientUnrequestedInitializationDataReceived(const String&, Ref<SharedBuffer>&&) = 0;
>+    virtual void cdmClientUnrequestedInitializationDataReceived(const String&, Ref<FragmentedSharedBuffer>&&) = 0;
> };
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/Modules/encryptedmedia/InitDataRegistry.cpp b/Source/WebCore/Modules/encryptedmedia/InitDataRegistry.cpp
>index 0bf5eaa74edb..6f888e17858d 100644
>--- a/Source/WebCore/Modules/encryptedmedia/InitDataRegistry.cpp
>+++ b/Source/WebCore/Modules/encryptedmedia/InitDataRegistry.cpp
>@@ -54,13 +54,13 @@ namespace {
>     const uint32_t kKeyIdsMaxKeyIdSizeInBytes = 512;
> }
> 
>-static std::optional<Vector<Ref<SharedBuffer>>> extractKeyIDsKeyids(const SharedBuffer& buffer)
>+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.data(), static_cast<unsigned>(buffer.size()) };
>+    String json { buffer.makeContiguous()->data(), static_cast<unsigned>(buffer.size()) };
> 
>     auto value = JSON::Value::parseJSON(json);
>     if (!value)
>@@ -74,7 +74,7 @@ static std::optional<Vector<Ref<SharedBuffer>>> extractKeyIDsKeyids(const Shared
>     if (!kidsArray)
>         return std::nullopt;
> 
>-    Vector<Ref<SharedBuffer>> keyIDs;
>+    Vector<Ref<FragmentedSharedBuffer>> keyIDs;
>     for (auto& value : *kidsArray) {
>         auto keyID = value->asString();
>         if (!keyID)
>@@ -93,7 +93,7 @@ static std::optional<Vector<Ref<SharedBuffer>>> extractKeyIDsKeyids(const Shared
>     return keyIDs;
> }
> 
>-static RefPtr<SharedBuffer> sanitizeKeyids(const SharedBuffer& buffer)
>+static RefPtr<FragmentedSharedBuffer> sanitizeKeyids(const FragmentedSharedBuffer& buffer)
> {
>     // 1. Format
>     // https://w3c.github.io/encrypted-media/format-registry/initdata/keyids.html#format
>@@ -104,14 +104,14 @@ static RefPtr<SharedBuffer> sanitizeKeyids(const SharedBuffer& buffer)
>     auto object = JSON::Object::create();
>     auto kidsArray = JSON::Array::create();
>     for (auto& buffer : keyIDBuffer.value())
>-        kidsArray->pushString(base64URLEncodeToString(buffer->data(), buffer->size()));
>+        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 SharedBuffer& buffer)
>+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
>@@ -151,9 +151,9 @@ std::optional<Vector<std::unique_ptr<ISOProtectionSystemSpecificHeaderBox>>> Ini
>     return psshBoxes;
> }
> 
>-std::optional<Vector<Ref<SharedBuffer>>> InitDataRegistry::extractKeyIDsCenc(const SharedBuffer& buffer)
>+std::optional<Vector<Ref<FragmentedSharedBuffer>>> InitDataRegistry::extractKeyIDsCenc(const FragmentedSharedBuffer& buffer)
> {
>-    Vector<Ref<SharedBuffer>> keyIDs;
>+    Vector<Ref<FragmentedSharedBuffer>> keyIDs;
> 
>     auto psshBoxes = extractPsshBoxesFromCenc(buffer);
>     if (!psshBoxes)
>@@ -185,7 +185,7 @@ std::optional<Vector<Ref<SharedBuffer>>> InitDataRegistry::extractKeyIDsCenc(con
>     return keyIDs;
> }
> 
>-RefPtr<SharedBuffer> InitDataRegistry::sanitizeCenc(const SharedBuffer& buffer)
>+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
>@@ -195,7 +195,7 @@ RefPtr<SharedBuffer> InitDataRegistry::sanitizeCenc(const SharedBuffer& buffer)
>     return buffer.copy();
> }
> 
>-static RefPtr<SharedBuffer> sanitizeWebM(const SharedBuffer& buffer)
>+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.
>@@ -205,10 +205,10 @@ static RefPtr<SharedBuffer> sanitizeWebM(const SharedBuffer& buffer)
>     return buffer.copy();
> }
> 
>-static std::optional<Vector<Ref<SharedBuffer>>> extractKeyIDsWebM(const SharedBuffer& buffer)
>+static std::optional<Vector<Ref<FragmentedSharedBuffer>>> extractKeyIDsWebM(const FragmentedSharedBuffer& buffer)
> {
>-    Vector<Ref<SharedBuffer>> keyIDs;
>-    RefPtr<SharedBuffer> sanitizedBuffer = sanitizeWebM(buffer);
>+    Vector<Ref<FragmentedSharedBuffer>> keyIDs;
>+    RefPtr<FragmentedSharedBuffer> sanitizedBuffer = sanitizeWebM(buffer);
>     if (!sanitizedBuffer)
>         return std::nullopt;
> 
>@@ -233,7 +233,7 @@ InitDataRegistry::InitDataRegistry()
> 
> InitDataRegistry::~InitDataRegistry() = default;
> 
>-RefPtr<SharedBuffer> InitDataRegistry::sanitizeInitData(const AtomString& initDataType, const SharedBuffer& buffer)
>+RefPtr<FragmentedSharedBuffer> InitDataRegistry::sanitizeInitData(const AtomString& initDataType, const FragmentedSharedBuffer& buffer)
> {
>     auto iter = m_types.find(initDataType);
>     if (iter == m_types.end() || !iter->value.sanitizeInitData)
>@@ -241,7 +241,7 @@ RefPtr<SharedBuffer> InitDataRegistry::sanitizeInitData(const AtomString& initDa
>     return iter->value.sanitizeInitData(buffer);
> }
> 
>-std::optional<Vector<Ref<SharedBuffer>>> InitDataRegistry::extractKeyIDs(const AtomString& initDataType, const SharedBuffer& 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)
>diff --git a/Source/WebCore/Modules/encryptedmedia/InitDataRegistry.h b/Source/WebCore/Modules/encryptedmedia/InitDataRegistry.h
>index cd1387a6bd03..77d604b08bb7 100644
>--- a/Source/WebCore/Modules/encryptedmedia/InitDataRegistry.h
>+++ b/Source/WebCore/Modules/encryptedmedia/InitDataRegistry.h
>@@ -38,19 +38,19 @@
> namespace WebCore {
> 
> class ISOProtectionSystemSpecificHeaderBox;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class InitDataRegistry {
> public:
>     WEBCORE_EXPORT static InitDataRegistry& shared();
>     friend class NeverDestroyed<InitDataRegistry>;
> 
>-    RefPtr<SharedBuffer> sanitizeInitData(const AtomString& initDataType, const SharedBuffer&);
>-    WEBCORE_EXPORT std::optional<Vector<Ref<SharedBuffer>>> extractKeyIDs(const AtomString& initDataType, const SharedBuffer&);
>+    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<SharedBuffer>(const SharedBuffer&)>;
>-        using ExtractKeyIDsCallback = Function<std::optional<Vector<Ref<SharedBuffer>>>(const SharedBuffer&)>;
>+        using SanitizeInitDataCallback = Function<RefPtr<FragmentedSharedBuffer>(const FragmentedSharedBuffer&)>;
>+        using ExtractKeyIDsCallback = Function<std::optional<Vector<Ref<FragmentedSharedBuffer>>>(const FragmentedSharedBuffer&)>;
> 
>         SanitizeInitDataCallback sanitizeInitData;
>         ExtractKeyIDsCallback extractKeyIDs;
>@@ -61,9 +61,9 @@ public:
>     static const AtomString& keyidsName();
>     static const AtomString& webmName();
> 
>-    static std::optional<Vector<std::unique_ptr<ISOProtectionSystemSpecificHeaderBox>>> extractPsshBoxesFromCenc(const SharedBuffer&);
>-    static std::optional<Vector<Ref<SharedBuffer>>> extractKeyIDsCenc(const SharedBuffer&);
>-    static RefPtr<SharedBuffer> sanitizeCenc(const SharedBuffer&);
>+    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();
>diff --git a/Source/WebCore/Modules/encryptedmedia/MediaKeySession.cpp b/Source/WebCore/Modules/encryptedmedia/MediaKeySession.cpp
>index 8bfb1ce701a2..14776c20151b 100644
>--- a/Source/WebCore/Modules/encryptedmedia/MediaKeySession.cpp
>+++ b/Source/WebCore/Modules/encryptedmedia/MediaKeySession.cpp
>@@ -176,7 +176,7 @@ void MediaKeySession::generateRequest(const AtomString& initDataType, const Buff
>     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<SharedBuffer> sanitizedInitData = m_implementation->sanitizeInitData(initDataType, initData);
>+        RefPtr<FragmentedSharedBuffer> sanitizedInitData = m_implementation->sanitizeInitData(initDataType, initData);
> 
>         // 10.3. If the preceding step failed, reject promise with a newly created TypeError.
>         if (!sanitizedInitData) {
>@@ -223,7 +223,7 @@ void MediaKeySession::generateRequest(const AtomString& initDataType, const Buff
>             m_latestDecryptTime = 0;
>         }
> 
>-        m_instanceSession->requestLicense(m_sessionType, initDataType, sanitizedInitData.releaseNonNull(), [this, weakThis, promise = WTFMove(promise), identifier = WTFMove(identifier)] (Ref<SharedBuffer>&& message, const String& sessionId, bool needsIndividualization, CDMInstanceSession::SuccessValue succeeded) mutable {
>+        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;
> 
>@@ -422,7 +422,7 @@ void MediaKeySession::update(const BufferSource& response, Ref<DeferredPromise>&
>     // 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<SharedBuffer> sanitizedResponse = m_implementation->sanitizeResponse(response);
>+        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()) {
>@@ -601,7 +601,7 @@ void MediaKeySession::remove(Ref<DeferredPromise>&& promise)
>         // 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<SharedBuffer>>&& message, CDMInstanceSession::SuccessValue succeeded) mutable {
>+        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;
> 
>@@ -649,7 +649,7 @@ void MediaKeySession::remove(Ref<DeferredPromise>&& promise)
>     // 5. Return promise.
> }
> 
>-void MediaKeySession::enqueueMessage(MediaKeyMessageType messageType, const SharedBuffer& message)
>+void MediaKeySession::enqueueMessage(MediaKeyMessageType messageType, const FragmentedSharedBuffer& message)
> {
>     // 6.4.1 Queue a "message" Event
>     // https://w3c.github.io/encrypted-media/#queue-message
>@@ -716,7 +716,7 @@ void MediaKeySession::updateKeyStatuses(CDMInstanceSession::KeyStatusVector&& in
>         });
> }
> 
>-void MediaKeySession::sendMessage(CDMMessageType messageType, Ref<SharedBuffer>&& message)
>+void MediaKeySession::sendMessage(CDMMessageType messageType, Ref<FragmentedSharedBuffer>&& message)
> {
>     enqueueMessage(messageType, message);
> }
>diff --git a/Source/WebCore/Modules/encryptedmedia/MediaKeySession.h b/Source/WebCore/Modules/encryptedmedia/MediaKeySession.h
>index 3d96f8802e74..365ace5c095e 100644
>--- a/Source/WebCore/Modules/encryptedmedia/MediaKeySession.h
>+++ b/Source/WebCore/Modules/encryptedmedia/MediaKeySession.h
>@@ -57,7 +57,7 @@ class CDM;
> class DeferredPromise;
> class MediaKeyStatusMap;
> class MediaKeys;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> template<typename IDLType> class DOMPromiseProxy;
> 
>@@ -87,20 +87,20 @@ public:
>     using ClosedPromise = DOMPromiseProxy<IDLUndefined>;
>     ClosedPromise& closed() { return m_closedPromise.get(); }
> 
>-    const Vector<std::pair<Ref<SharedBuffer>, MediaKeyStatus>>& statuses() const { return m_statuses; }
>+    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 SharedBuffer&);
>+    void enqueueMessage(MediaKeyMessageType, const FragmentedSharedBuffer&);
>     void updateExpiration(double);
>     void sessionClosed();
>     String mediaKeysStorageDirectory() const;
> 
>     // CDMInstanceSessionClient
>     void updateKeyStatuses(CDMInstanceSessionClient::KeyStatusVector&&) override;
>-    void sendMessage(CDMMessageType, Ref<SharedBuffer>&& message) final;
>+    void sendMessage(CDMMessageType, Ref<FragmentedSharedBuffer>&& message) final;
>     void sessionIdChanged(const String&) final;
>     PlatformDisplayID displayID() final;
> 
>@@ -140,10 +140,10 @@ private:
>     MediaKeySessionType m_sessionType;
>     Ref<CDM> m_implementation;
>     Ref<CDMInstanceSession> m_instanceSession;
>-    Vector<Ref<SharedBuffer>> m_recordOfKeyUsage;
>+    Vector<Ref<FragmentedSharedBuffer>> m_recordOfKeyUsage;
>     double m_firstDecryptTime { 0 };
>     double m_latestDecryptTime { 0 };
>-    Vector<std::pair<Ref<SharedBuffer>, MediaKeyStatus>> m_statuses;
>+    Vector<std::pair<Ref<FragmentedSharedBuffer>, MediaKeyStatus>> m_statuses;
> 
>     using DisplayChangedObserver = Observer<void(PlatformDisplayID)>;
>     DisplayChangedObserver m_displayChangedObserver;
>diff --git a/Source/WebCore/Modules/encryptedmedia/MediaKeyStatusMap.cpp b/Source/WebCore/Modules/encryptedmedia/MediaKeyStatusMap.cpp
>index 73f74e4f70fc..398e8ab1b656 100644
>--- a/Source/WebCore/Modules/encryptedmedia/MediaKeyStatusMap.cpp
>+++ b/Source/WebCore/Modules/encryptedmedia/MediaKeyStatusMap.cpp
>@@ -56,12 +56,12 @@ unsigned long MediaKeyStatusMap::size()
>     return m_session->statuses().size();
> }
> 
>-static bool keyIdsMatch(const SharedBuffer& a, const BufferSource& b)
>+static bool keyIdsMatch(const FragmentedSharedBuffer& a, const BufferSource& b)
> {
>     auto length = a.size();
>     if (!length || length != b.length())
>         return false;
>-    return !std::memcmp(a.data(), b.data(), length);
>+    return !std::memcmp(a.makeContiguous()->data(), b.data(), length);
> }
> 
> bool MediaKeyStatusMap::has(const BufferSource& keyId)
>@@ -103,7 +103,7 @@ std::optional<KeyValuePair<BufferSource::VariantType, MediaKeyStatus>> MediaKeyS
>         return std::nullopt;
> 
>     auto& pair = statuses[m_index++];
>-    auto buffer = ArrayBuffer::create(pair.first->data(), pair.first->size());
>+    auto buffer = ArrayBuffer::create(pair.first->makeContiguous()->data(), pair.first->size());
>     return KeyValuePair<BufferSource::VariantType, MediaKeyStatus> { RefPtr<ArrayBuffer>(WTFMove(buffer)), pair.second };
> }
> 
>diff --git a/Source/WebCore/Modules/encryptedmedia/MediaKeyStatusMap.h b/Source/WebCore/Modules/encryptedmedia/MediaKeyStatusMap.h
>index c211113a2c6d..60d62aaff807 100644
>--- a/Source/WebCore/Modules/encryptedmedia/MediaKeyStatusMap.h
>+++ b/Source/WebCore/Modules/encryptedmedia/MediaKeyStatusMap.h
>@@ -38,7 +38,7 @@
> namespace WebCore {
> 
> class MediaKeySession;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class MediaKeyStatusMap : public RefCounted<MediaKeyStatusMap> {
> public:
>diff --git a/Source/WebCore/Modules/encryptedmedia/MediaKeys.cpp b/Source/WebCore/Modules/encryptedmedia/MediaKeys.cpp
>index 83b24aceaa5b..367f31d186b5 100644
>--- a/Source/WebCore/Modules/encryptedmedia/MediaKeys.cpp
>+++ b/Source/WebCore/Modules/encryptedmedia/MediaKeys.cpp
>@@ -177,7 +177,7 @@ bool MediaKeys::hasOpenSessions() const
>         });
> }
> 
>-void MediaKeys::unrequestedInitializationDataReceived(const String& initDataType, Ref<SharedBuffer>&& initData)
>+void MediaKeys::unrequestedInitializationDataReceived(const String& initDataType, Ref<FragmentedSharedBuffer>&& initData)
> {
>     for (auto& cdmClient : m_cdmClients)
>         cdmClient.cdmClientUnrequestedInitializationDataReceived(initDataType, initData.copyRef());
>diff --git a/Source/WebCore/Modules/encryptedmedia/MediaKeys.h b/Source/WebCore/Modules/encryptedmedia/MediaKeys.h
>index 7b59a3bc6d22..91a1a0711433 100644
>--- a/Source/WebCore/Modules/encryptedmedia/MediaKeys.h
>+++ b/Source/WebCore/Modules/encryptedmedia/MediaKeys.h
>@@ -86,7 +86,7 @@ protected:
>     MediaKeys(Document&, bool useDistinctiveIdentifier, bool persistentStateAllowed, const Vector<MediaKeySessionType>&, Ref<CDM>&&, Ref<CDMInstance>&&);
> 
>     // CDMInstanceClient
>-    void unrequestedInitializationDataReceived(const String&, Ref<SharedBuffer>&&) final;
>+    void unrequestedInitializationDataReceived(const String&, Ref<FragmentedSharedBuffer>&&) final;
> 
> #if !RELEASE_LOG_DISABLED
>     const Logger& logger() const { return m_logger; }
>diff --git a/Source/WebCore/Modules/fetch/FetchBody.cpp b/Source/WebCore/Modules/fetch/FetchBody.cpp
>index c04731284f67..b8f2ec373d87 100644
>--- a/Source/WebCore/Modules/fetch/FetchBody.cpp
>+++ b/Source/WebCore/Modules/fetch/FetchBody.cpp
>@@ -235,7 +235,7 @@ void FetchBody::consumeBlob(FetchBodyOwner& owner, Ref<DeferredPromise>&& promis
> void FetchBody::consumeFormData(FetchBodyOwner& owner, Ref<DeferredPromise>&& promise)
> {
>     if (auto sharedBuffer = formDataBody().asSharedBuffer()) {
>-        m_consumer.resolveWithData(WTFMove(promise), owner.contentType(), sharedBuffer->data(), sharedBuffer->size());
>+        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.
>@@ -272,7 +272,7 @@ RefPtr<FormData> FetchBody::bodyAsFormData() const
>     if (isFormData())
>         return &const_cast<FormData&>(formDataBody());
>     if (auto* data = m_consumer.data())
>-        return FormData::create(data->data(), data->size());
>+        return FormData::create(data->makeContiguous()->data(), data->size());
> 
>     ASSERT_NOT_REACHED();
>     return nullptr;
>@@ -284,7 +284,7 @@ FetchBody::TakenData FetchBody::take()
>         auto buffer = m_consumer.takeData();
>         if (!buffer)
>             return nullptr;
>-        return buffer.releaseNonNull();
>+        return buffer->makeContiguous();
>     }
> 
>     if (isBlob()) {
>diff --git a/Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp b/Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp
>index dc865f7da239..1919c1cb9130 100644
>--- a/Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp
>+++ b/Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp
>@@ -242,7 +242,7 @@ static void resolveWithTypeAndData(Ref<DeferredPromise>&& promise, FetchBodyCons
> 
> void FetchBodyConsumer::clean()
> {
>-    m_buffer = nullptr;
>+    m_buffer.reset();
>     resetConsumePromise();
>     if (m_sink) {
>         m_sink->clearCallback();
>@@ -266,16 +266,18 @@ void FetchBodyConsumer::resolve(Ref<DeferredPromise>&& promise, const String& co
> {
>     if (stream) {
>         ASSERT(!m_sink);
>-        m_sink = ReadableStreamToSharedBufferSink::create([promise = WTFMove(promise), data = SharedBuffer::create(), type = m_type, contentType](auto&& result) mutable {
>+        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
>-                resolveWithTypeAndData(WTFMove(promise), type, contentType, data->data(), data->size());
>+                data.append(chunk->data(), chunk->size());
>+            else {
>+                auto buffer = data.takeAsContiguous();
>+                resolveWithTypeAndData(WTFMove(promise), type, contentType, buffer->data(), buffer->size());
>+            }
>         });
>         m_sink->pipeFrom(*stream);
>         return;
>@@ -306,7 +308,7 @@ void FetchBodyConsumer::resolve(Ref<DeferredPromise>&& promise, const String& co
>         return;
>     case FetchBodyConsumer::Type::FormData: {
>         auto buffer = takeData();
>-        if (auto formData = packageFormData(context, contentType, buffer ? buffer->data() : nullptr, buffer ? buffer->size() : 0))
>+        if (auto formData = packageFormData(context, contentType, buffer ? buffer->makeContiguous()->data() : nullptr, buffer ? buffer->size() : 0))
>             promise->resolve<IDLInterface<DOMFormData>>(*formData);
>         else
>             promise->reject(TypeError);
>@@ -324,26 +326,25 @@ void FetchBodyConsumer::append(const uint8_t* data, unsigned size)
>         m_source->enqueue(ArrayBuffer::tryCreate(data, size));
>         return;
>     }
>-    if (!m_buffer) {
>-        m_buffer = SharedBuffer::create(data, size);
>-        return;
>-    }
>-    m_buffer->append(data, size);
>+    m_buffer.append(data, size);
> }
> 
>-RefPtr<SharedBuffer> FetchBodyConsumer::takeData()
>+void FetchBodyConsumer::setData(Ref<FragmentedSharedBuffer>&& data)
> {
>-    return WTFMove(m_buffer);
>+    m_buffer.reset();
>+    m_buffer.append(WTFMove(data));
> }
> 
>-RefPtr<JSC::ArrayBuffer> FetchBodyConsumer::takeAsArrayBuffer()
>+RefPtr<FragmentedSharedBuffer> FetchBodyConsumer::takeData()
> {
>     if (!m_buffer)
>-        return ArrayBuffer::tryCreate(nullptr, 0);
>+        return nullptr;
>+    return m_buffer.take();
>+}
> 
>-    auto arrayBuffer = m_buffer->tryCreateArrayBuffer();
>-    m_buffer = nullptr;
>-    return arrayBuffer;
>+RefPtr<JSC::ArrayBuffer> FetchBodyConsumer::takeAsArrayBuffer()
>+{
>+    return m_buffer.takeAsArrayBuffer();
> }
> 
> Ref<Blob> FetchBodyConsumer::takeAsBlob(ScriptExecutionContext* context)
>@@ -351,9 +352,7 @@ Ref<Blob> FetchBodyConsumer::takeAsBlob(ScriptExecutionContext* context)
>     if (!m_buffer)
>         return Blob::create(context, Vector<uint8_t>(), Blob::normalizedContentType(m_contentType));
> 
>-    auto buffer = std::exchange(m_buffer, nullptr);
>-    auto data = buffer->extractData();
>-    return blobFromData(context, WTFMove(data), m_contentType);
>+    return blobFromData(context, m_buffer.take()->extractData(), m_contentType);
> }
> 
> String FetchBodyConsumer::takeAsText()
>@@ -362,8 +361,8 @@ String FetchBodyConsumer::takeAsText()
>     if (!m_buffer)
>         return String();
> 
>-    auto text = TextResourceDecoder::textFromUTF8(m_buffer->data(), m_buffer->size());
>-    m_buffer = nullptr;
>+    auto buffer = m_buffer.takeAsContiguous();
>+    auto text = TextResourceDecoder::textFromUTF8(buffer->data(), buffer->size());
>     return text;
> }
> 
>@@ -383,10 +382,8 @@ void FetchBodyConsumer::resetConsumePromise()
> void FetchBodyConsumer::setSource(Ref<FetchBodySource>&& source)
> {
>     m_source = WTFMove(source);
>-    if (m_buffer) {
>-        m_source->enqueue(m_buffer->tryCreateArrayBuffer());
>-        m_buffer = nullptr;
>-    }
>+    if (m_buffer)
>+        m_source->enqueue(m_buffer.takeAsArrayBuffer());
> }
> 
> void FetchBodyConsumer::loadingFailed(const Exception& exception)
>diff --git a/Source/WebCore/Modules/fetch/FetchBodyConsumer.h b/Source/WebCore/Modules/fetch/FetchBodyConsumer.h
>index 2b056f12643b..871d2c086331 100644
>--- a/Source/WebCore/Modules/fetch/FetchBodyConsumer.h
>+++ b/Source/WebCore/Modules/fetch/FetchBodyConsumer.h
>@@ -50,10 +50,10 @@ public:
>     void append(const uint8_t* data, unsigned);
> 
>     bool hasData() const { return !!m_buffer; }
>-    const SharedBuffer* data() const { return m_buffer.get(); }
>-    void setData(Ref<SharedBuffer>&& data) { m_buffer = WTFMove(data); }
>+    const FragmentedSharedBuffer* data() const { return m_buffer.get().get(); }
>+    void setData(Ref<FragmentedSharedBuffer>&&);
> 
>-    RefPtr<SharedBuffer> takeData();
>+    RefPtr<FragmentedSharedBuffer> takeData();
>     RefPtr<JSC::ArrayBuffer> takeAsArrayBuffer();
>     String takeAsText();
> 
>@@ -82,7 +82,7 @@ private:
> 
>     Type m_type;
>     String m_contentType;
>-    RefPtr<SharedBuffer> m_buffer;
>+    SharedBufferBuilder m_buffer;
>     RefPtr<DeferredPromise> m_consumePromise;
>     RefPtr<ReadableStreamToSharedBufferSink> m_sink;
>     RefPtr<FetchBodySource> m_source;
>diff --git a/Source/WebCore/Modules/fetch/FetchLoader.cpp b/Source/WebCore/Modules/fetch/FetchLoader.cpp
>index fc55cc7d83d8..03f89b61ca5f 100644
>--- a/Source/WebCore/Modules/fetch/FetchLoader.cpp
>+++ b/Source/WebCore/Modules/fetch/FetchLoader.cpp
>@@ -135,7 +135,7 @@ void FetchLoader::stop()
>         m_loader->cancel();
> }
> 
>-RefPtr<SharedBuffer> FetchLoader::startStreaming()
>+RefPtr<FragmentedSharedBuffer> FetchLoader::startStreaming()
> {
>     ASSERT(m_consumer);
>     auto firstChunk = m_consumer->takeData();
>diff --git a/Source/WebCore/Modules/fetch/FetchLoader.h b/Source/WebCore/Modules/fetch/FetchLoader.h
>index 2f90f0ec3ff9..4612d0e0e3a7 100644
>--- a/Source/WebCore/Modules/fetch/FetchLoader.h
>+++ b/Source/WebCore/Modules/fetch/FetchLoader.h
>@@ -39,14 +39,14 @@ class FetchBodyConsumer;
> class FetchLoaderClient;
> class FetchRequest;
> class ScriptExecutionContext;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class FetchLoader final : public ThreadableLoaderClient {
> public:
>     FetchLoader(FetchLoaderClient&, FetchBodyConsumer*);
>     WEBCORE_EXPORT ~FetchLoader();
> 
>-    RefPtr<SharedBuffer> startStreaming();
>+    RefPtr<FragmentedSharedBuffer> startStreaming();
> 
>     void start(ScriptExecutionContext&, const FetchRequest&, const String&);
>     void start(ScriptExecutionContext&, const Blob&);
>diff --git a/Source/WebCore/Modules/fetch/FetchResponse.cpp b/Source/WebCore/Modules/fetch/FetchResponse.cpp
>index 4df8426c718b..e38a83ade7d6 100644
>--- a/Source/WebCore/Modules/fetch/FetchResponse.cpp
>+++ b/Source/WebCore/Modules/fetch/FetchResponse.cpp
>@@ -400,7 +400,8 @@ void FetchResponse::BodyLoader::consumeDataByChunk(ConsumeDataByChunkCallback&&
>     if (!data)
>         return;
> 
>-    Span chunk { data->data(), data->size() };
>+    auto contiguousBuffer = data->makeContiguous();
>+    Span chunk { contiguousBuffer->data(), data->size() };
>     m_consumeDataCallback(&chunk);
> }
> 
>@@ -503,7 +504,7 @@ void FetchResponse::feedStream()
>     closeStream();
> }
> 
>-RefPtr<SharedBuffer> FetchResponse::BodyLoader::startStreaming()
>+RefPtr<FragmentedSharedBuffer> FetchResponse::BodyLoader::startStreaming()
> {
>     ASSERT(m_loader);
>     return m_loader->startStreaming();
>diff --git a/Source/WebCore/Modules/fetch/FetchResponse.h b/Source/WebCore/Modules/fetch/FetchResponse.h
>index 3420c6a38d3c..cf7863239fd9 100644
>--- a/Source/WebCore/Modules/fetch/FetchResponse.h
>+++ b/Source/WebCore/Modules/fetch/FetchResponse.h
>@@ -134,7 +134,7 @@ private:
> 
>         void consumeDataByChunk(ConsumeDataByChunkCallback&&);
> 
>-        RefPtr<SharedBuffer> startStreaming();
>+        RefPtr<FragmentedSharedBuffer> startStreaming();
>         NotificationCallback takeNotificationCallback() { return WTFMove(m_responseCallback); }
>         ConsumeDataByChunkCallback takeConsumeDataCallback() { return WTFMove(m_consumeDataCallback); }
> 
>diff --git a/Source/WebCore/Modules/highlight/AppHighlight.h b/Source/WebCore/Modules/highlight/AppHighlight.h
>index dd19c870aa7d..1a66bf818320 100644
>--- a/Source/WebCore/Modules/highlight/AppHighlight.h
>+++ b/Source/WebCore/Modules/highlight/AppHighlight.h
>@@ -38,7 +38,7 @@ enum class CreateNewGroupForHighlight : bool { No, Yes };
> enum class HighlightRequestOriginatedInApp : bool { No, Yes };
> 
> struct AppHighlight {
>-    Ref<WebCore::SharedBuffer> highlight;
>+    Ref<WebCore::FragmentedSharedBuffer> highlight;
>     std::optional<String> text;
>     CreateNewGroupForHighlight isNewGroup;
>     HighlightRequestOriginatedInApp requestOriginatedInApp;
>@@ -52,7 +52,7 @@ template<class Encoder>
> void AppHighlight::encode(Encoder& encoder) const
> {
>     encoder << static_cast<size_t>(highlight->size());
>-    encoder.encodeFixedLengthData(highlight->data(), highlight->size(), 1);
>+    encoder.encodeFixedLengthData(highlight->makeContiguous()->data(), highlight->size(), 1);
> 
>     encoder << text;
> 
>diff --git a/Source/WebCore/Modules/highlight/AppHighlightRangeData.cpp b/Source/WebCore/Modules/highlight/AppHighlightRangeData.cpp
>index e2d9a61e4276..5e80f0c072d4 100644
>--- a/Source/WebCore/Modules/highlight/AppHighlightRangeData.cpp
>+++ b/Source/WebCore/Modules/highlight/AppHighlightRangeData.cpp
>@@ -44,15 +44,16 @@ namespace WebCore {
> 
> constexpr uint64_t highlightFileSignature = 0x4141504832303231; // File Signature  (A)pple(AP)plication(H)ighlights(2021)
> 
>-std::optional<AppHighlightRangeData> AppHighlightRangeData::create(const SharedBuffer& buffer)
>+std::optional<AppHighlightRangeData> AppHighlightRangeData::create(const FragmentedSharedBuffer& buffer)
> {
>-    auto decoder = buffer.decoder();
>+    auto contiguousBuffer = buffer.makeContiguous();
>+    auto decoder = contiguousBuffer->decoder();
>     std::optional<AppHighlightRangeData> data;
>     decoder >> data;
>     return data;
> }
> 
>-Ref<SharedBuffer> AppHighlightRangeData::toSharedBuffer() const
>+Ref<FragmentedSharedBuffer> AppHighlightRangeData::toSharedBuffer() const
> {
>     WTF::Persistence::Encoder encoder;
>     encoder << *this;
>diff --git a/Source/WebCore/Modules/highlight/AppHighlightRangeData.h b/Source/WebCore/Modules/highlight/AppHighlightRangeData.h
>index cf6381acfb0a..b5daf6025398 100644
>--- a/Source/WebCore/Modules/highlight/AppHighlightRangeData.h
>+++ b/Source/WebCore/Modules/highlight/AppHighlightRangeData.h
>@@ -33,12 +33,12 @@ namespace WebCore {
> 
> #if ENABLE(APP_HIGHLIGHTS)
> 
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class AppHighlightRangeData {
> WTF_MAKE_FAST_ALLOCATED;
> public:
>-    WEBCORE_EXPORT static std::optional<AppHighlightRangeData> create(const SharedBuffer&);
>+    WEBCORE_EXPORT static std::optional<AppHighlightRangeData> create(const FragmentedSharedBuffer&);
>     struct NodePathComponent {
>         String identifier;
>         String nodeName;
>@@ -111,7 +111,7 @@ public:
>     template<class Encoder> void encode(Encoder&) const;
>     template<class Decoder> static std::optional<AppHighlightRangeData> decode(Decoder&);
> 
>-    Ref<SharedBuffer> toSharedBuffer() const;
>+    Ref<FragmentedSharedBuffer> toSharedBuffer() const;
> 
> private:
>     String m_identifier;
>diff --git a/Source/WebCore/Modules/highlight/AppHighlightStorage.cpp b/Source/WebCore/Modules/highlight/AppHighlightStorage.cpp
>index dc39a0f0d18f..e5de8494f350 100644
>--- a/Source/WebCore/Modules/highlight/AppHighlightStorage.cpp
>+++ b/Source/WebCore/Modules/highlight/AppHighlightStorage.cpp
>@@ -237,7 +237,7 @@ void AppHighlightStorage::storeAppHighlight(Ref<StaticRange>&& range)
>     m_document->page()->chrome().storeAppHighlight(WTFMove(highlight));
> }
> 
>-void AppHighlightStorage::restoreAndScrollToAppHighlight(Ref<SharedBuffer>&& buffer, ScrollToHighlight scroll)
>+void AppHighlightStorage::restoreAndScrollToAppHighlight(Ref<FragmentedSharedBuffer>&& buffer, ScrollToHighlight scroll)
> {
>     auto appHighlightRangeData = AppHighlightRangeData::create(buffer);
>     if (!appHighlightRangeData)
>diff --git a/Source/WebCore/Modules/highlight/AppHighlightStorage.h b/Source/WebCore/Modules/highlight/AppHighlightStorage.h
>index b152f76ed424..e276633b484f 100644
>--- a/Source/WebCore/Modules/highlight/AppHighlightStorage.h
>+++ b/Source/WebCore/Modules/highlight/AppHighlightStorage.h
>@@ -39,7 +39,7 @@ namespace WebCore {
> #if ENABLE(APP_HIGHLIGHTS)
> 
> class Document;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> class StaticRange;
> class Highlight;
> 
>@@ -54,7 +54,7 @@ public:
>     ~AppHighlightStorage();
> 
>     WEBCORE_EXPORT void storeAppHighlight(Ref<StaticRange>&&);
>-    WEBCORE_EXPORT void restoreAndScrollToAppHighlight(Ref<SharedBuffer>&&, ScrollToHighlight);
>+    WEBCORE_EXPORT void restoreAndScrollToAppHighlight(Ref<FragmentedSharedBuffer>&&, ScrollToHighlight);
>     void restoreUnrestoredAppHighlights();
>     MonotonicTime lastRangeSearchTime() const { return m_timeAtLastRangeSearch; }
>     void resetLastRangeSearchTime() { m_timeAtLastRangeSearch = MonotonicTime::now(); }
>diff --git a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp b/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp
>index 0afb7ee5cc87..27cd8eec53e1 100644
>--- a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp
>+++ b/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp
>@@ -686,7 +686,7 @@ bool SQLiteIDBBackingStore::addExistingIndex(IDBObjectStoreInfo& objectStoreInfo
>     SQLiteTransaction transaction(*m_sqliteDB);
>     transaction.begin();
> 
>-    RefPtr<SharedBuffer> keyPathBlob = serializeIDBKeyPath(info.keyPath());
>+    auto keyPathBlob = serializeIDBKeyPath(info.keyPath());
>     if (!keyPathBlob) {
>         LOG_ERROR("Unable to serialize IDBKeyPath to save in database");
>         return false;
>@@ -1174,7 +1174,7 @@ IDBError SQLiteIDBBackingStore::createObjectStore(const IDBResourceIdentifier& t
>         return IDBError { UnknownError, "Attempt to create an object store in a non-version-change transaction"_s };
>     }
> 
>-    RefPtr<SharedBuffer> keyPathBlob = serializeIDBKeyPath(info.keyPath());
>+    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 };
>@@ -1387,7 +1387,7 @@ IDBError SQLiteIDBBackingStore::createIndex(const IDBResourceIdentifier& transac
>         return IDBError { UnknownError, "Attempt to create an index in a non-version-change transaction"_s };
>     }
> 
>-    RefPtr<SharedBuffer> keyPathBlob = serializeIDBKeyPath(info.keyPath());
>+    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 };
>@@ -1464,7 +1464,7 @@ IDBError SQLiteIDBBackingStore::uncheckedHasIndexRecord(const IDBIndexInfo& info
> {
>     hasRecord = false;
> 
>-    RefPtr<SharedBuffer> indexKeyBuffer = serializeIDBKeyData(indexKey);
>+    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 };
>@@ -1533,13 +1533,13 @@ IDBError SQLiteIDBBackingStore::uncheckedPutIndexRecord(int64_t objectStoreID, i
> {
>     LOG(IndexedDB, "SQLiteIDBBackingStore::uncheckedPutIndexRecord - %s, %s", keyValue.loggingString().utf8().data(), indexKey.loggingString().utf8().data());
> 
>-    RefPtr<SharedBuffer> indexKeyBuffer = serializeIDBKeyData(indexKey);
>+    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 };
>     }
> 
>-    RefPtr<SharedBuffer> valueBuffer = serializeIDBKeyData(keyValue);
>+    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 };
>@@ -1661,7 +1661,7 @@ IDBError SQLiteIDBBackingStore::keyExistsInObjectStore(const IDBResourceIdentifi
>     if (!transaction || !transaction->inProgress())
>         return IDBError { UnknownError, "Attempt to see if key exists in objectstore without an in-progress transaction"_s };
> 
>-    RefPtr<SharedBuffer> keyBuffer = serializeIDBKeyData(keyData);
>+    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 };
>@@ -1741,7 +1741,7 @@ IDBError SQLiteIDBBackingStore::deleteRecord(SQLiteIDBTransaction& transaction,
>     ASSERT(transaction.mode() != IDBTransactionMode::Readonly);
>     UNUSED_PARAM(transaction);
> 
>-    RefPtr<SharedBuffer> keyBuffer = serializeIDBKeyData(keyData);
>+    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 };
>@@ -1962,7 +1962,7 @@ IDBError SQLiteIDBBackingStore::addRecord(const IDBResourceIdentifier& transacti
>         return IDBError { UnknownError, "Attempt to store a record in an object store in a read-only transaction"_s };
>     }
> 
>-    RefPtr<SharedBuffer> keyBuffer = serializeIDBKeyData(keyData);
>+    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 };
>@@ -2124,7 +2124,7 @@ IDBError SQLiteIDBBackingStore::getRecord(const IDBResourceIdentifier& transacti
>     auto key = keyRange.lowerKey;
>     if (key.isNull())
>         key = IDBKeyData::minimum();
>-    RefPtr<SharedBuffer> lowerBuffer = serializeIDBKeyData(key);
>+    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 };
>@@ -2133,7 +2133,7 @@ IDBError SQLiteIDBBackingStore::getRecord(const IDBResourceIdentifier& transacti
>     key = keyRange.upperKey;
>     if (key.isNull())
>         key = IDBKeyData::maximum();
>-    RefPtr<SharedBuffer> upperBuffer = serializeIDBKeyData(key);
>+    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 };
>@@ -2443,7 +2443,7 @@ IDBError SQLiteIDBBackingStore::uncheckedGetIndexRecordForOneKey(int64_t indexID
> 
>     ASSERT(key.isValid() && key.type() != IndexedDB::KeyType::Max && key.type() != IndexedDB::KeyType::Min);
> 
>-    RefPtr<SharedBuffer> buffer = serializeIDBKeyData(key);
>+    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 };
>@@ -2508,14 +2508,14 @@ IDBError SQLiteIDBBackingStore::getCount(const IDBResourceIdentifier& transactio
>     outCount = 0;
> 
>     auto lowerKey = range.lowerKey.isNull() ? IDBKeyData::minimum() : range.lowerKey;
>-    RefPtr<SharedBuffer> lowerBuffer = serializeIDBKeyData(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;
>-    RefPtr<SharedBuffer> upperBuffer = serializeIDBKeyData(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 };
>diff --git a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBCursor.cpp b/Source/WebCore/Modules/indexeddb/server/SQLiteIDBCursor.cpp
>index 8bfe227db619..4861034d3a12 100644
>--- a/Source/WebCore/Modules/indexeddb/server/SQLiteIDBCursor.cpp
>+++ b/Source/WebCore/Modules/indexeddb/server/SQLiteIDBCursor.cpp
>@@ -269,7 +269,7 @@ bool SQLiteIDBCursor::bindArguments()
>         return false;
>     }
> 
>-    RefPtr<SharedBuffer> buffer = serializeIDBKeyData(m_currentLowerKey);
>+    auto buffer = serializeIDBKeyData(m_currentLowerKey);
>     if (m_statement->bindBlob(currentBindArgument++, *buffer) != SQLITE_OK) {
>         LOG_ERROR("Could not create cursor statement (lower key)");
>         return false;
>@@ -315,7 +315,7 @@ bool SQLiteIDBCursor::resetAndRebindPreIndexStatementIfNecessary()
>         return false;
>     }
> 
>-    RefPtr<SharedBuffer> buffer = serializeIDBKeyData(key);
>+    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;
>diff --git a/Source/WebCore/Modules/mediarecorder/MediaRecorder.cpp b/Source/WebCore/Modules/mediarecorder/MediaRecorder.cpp
>index 0a469bd0bd1f..c9d6da6bdd9f 100644
>--- a/Source/WebCore/Modules/mediarecorder/MediaRecorder.cpp
>+++ b/Source/WebCore/Modules/mediarecorder/MediaRecorder.cpp
>@@ -196,7 +196,7 @@ ExceptionOr<void> MediaRecorder::startRecording(std::optional<unsigned> timeSlic
>     return { };
> }
> 
>-static inline Ref<BlobEvent> createDataAvailableEvent(ScriptExecutionContext* context, RefPtr<SharedBuffer>&& buffer, const String& mimeType, double timeCode)
>+static inline Ref<BlobEvent> createDataAvailableEvent(ScriptExecutionContext* context, RefPtr<FragmentedSharedBuffer>&& buffer, const String& mimeType, double timeCode)
> {
>     auto blob = buffer ? Blob::create(context, buffer->extractData(), mimeType) : Blob::create(context);
>     return BlobEvent::create(eventNames().dataavailableEvent, BlobEvent::Init { { false, false, false }, WTFMove(blob), timeCode }, BlobEvent::IsTrusted::Yes);
>diff --git a/Source/WebCore/Modules/mediarecorder/MediaRecorder.h b/Source/WebCore/Modules/mediarecorder/MediaRecorder.h
>index 7712b4452836..1e9b74ab17e3 100644
>--- a/Source/WebCore/Modules/mediarecorder/MediaRecorder.h
>+++ b/Source/WebCore/Modules/mediarecorder/MediaRecorder.h
>@@ -103,7 +103,7 @@ private:
>     void dispatchError(Exception&&);
> 
>     enum class TakePrivateRecorder { No, Yes };
>-    using FetchDataCallback = Function<void(RefPtr<SharedBuffer>&&, const String& mimeType, double)>;
>+    using FetchDataCallback = Function<void(RefPtr<FragmentedSharedBuffer>&&, const String& mimeType, double)>;
>     void fetchData(FetchDataCallback&&, TakePrivateRecorder);
> 
>     // MediaStream::Observer
>diff --git a/Source/WebCore/Modules/mediasession/MediaMetadata.cpp b/Source/WebCore/Modules/mediasession/MediaMetadata.cpp
>index 3f4c9bcd133a..874aa7f0b18f 100644
>--- a/Source/WebCore/Modules/mediasession/MediaMetadata.cpp
>+++ b/Source/WebCore/Modules/mediasession/MediaMetadata.cpp
>@@ -77,7 +77,7 @@ void ArtworkImageLoader::notifyFinished(CachedResource& resource, const NetworkL
>         return;
>     }
>     // Sanitize the image by decoding it into a BitmapImage.
>-    RefPtr<SharedBuffer> bufferToSanitize = m_cachedImage->image()->data();
>+    RefPtr<FragmentedSharedBuffer> bufferToSanitize = m_cachedImage->image()->data();
>     auto bitmapImage = BitmapImage::create();
>     bitmapImage->setData(WTFMove(bufferToSanitize), true);
>     auto imageBuffer = ImageBuffer::create(bitmapImage->size(), RenderingMode::Unaccelerated, 1, DestinationColorSpace::SRGB(), PixelFormat::BGRA8);
>diff --git a/Source/WebCore/Modules/mediastream/RTCDataChannelRemoteHandler.cpp b/Source/WebCore/Modules/mediastream/RTCDataChannelRemoteHandler.cpp
>index feb1b8fffb7b..cc5a86573056 100644
>--- a/Source/WebCore/Modules/mediastream/RTCDataChannelRemoteHandler.cpp
>+++ b/Source/WebCore/Modules/mediastream/RTCDataChannelRemoteHandler.cpp
>@@ -82,7 +82,7 @@ void RTCDataChannelRemoteHandler::readyToSend()
>     m_isReadyToSend = true;
> 
>     for (auto& message : m_pendingMessages)
>-        m_connection->sendData(m_remoteIdentifier, message.isRaw, message.buffer->data(), message.buffer->size());
>+        m_connection->sendData(m_remoteIdentifier, message.isRaw, message.buffer->makeContiguous()->data(), message.buffer->size());
>     m_pendingMessages.clear();
> 
>     if (m_isPendingClose)
>diff --git a/Source/WebCore/Modules/mediastream/RTCDataChannelRemoteHandler.h b/Source/WebCore/Modules/mediastream/RTCDataChannelRemoteHandler.h
>index f5827df93794..73942a835931 100644
>--- a/Source/WebCore/Modules/mediastream/RTCDataChannelRemoteHandler.h
>+++ b/Source/WebCore/Modules/mediastream/RTCDataChannelRemoteHandler.h
>@@ -39,7 +39,7 @@ namespace WebCore {
> class RTCDataChannelHandlerClient;
> class RTCDataChannelRemoteHandlerConnection;
> class RTCError;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class RTCDataChannelRemoteHandler final : public RTCDataChannelHandler, public CanMakeWeakPtr<RTCDataChannelRemoteHandler> {
>     WTF_MAKE_FAST_ALLOCATED;
>@@ -73,7 +73,7 @@ private:
> 
>     struct Message {
>         bool isRaw { false };
>-        Ref<SharedBuffer> buffer;
>+        Ref<FragmentedSharedBuffer> buffer;
>     };
>     Vector<Message> m_pendingMessages;
>     bool m_isPendingClose { false };
>diff --git a/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCDataChannelHandler.cpp b/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCDataChannelHandler.cpp
>index 3e1105400353..3ceed0a011e7 100644
>--- a/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCDataChannelHandler.cpp
>+++ b/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCDataChannelHandler.cpp
>@@ -97,8 +97,8 @@ void LibWebRTCDataChannelHandler::setClient(RTCDataChannelHandlerClient& client,
>     m_contextIdentifier = contextIdentifier;
> 
>     for (auto& message : m_bufferedMessages) {
>-        switchOn(message, [&](Ref<SharedBuffer>& data) {
>-            client.didReceiveRawData(data->data(), data->size());
>+        switchOn(message, [&](Ref<FragmentedSharedBuffer>& data) {
>+            client.didReceiveRawData(data->makeContiguous()->data(), data->size());
>         }, [&](String& text) {
>             client.didReceiveStringData(text);
>         }, [&](StateChange stateChange) {
>diff --git a/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCDataChannelHandler.h b/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCDataChannelHandler.h
>index 41f952821e62..11bd45de9155 100644
>--- a/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCDataChannelHandler.h
>+++ b/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCDataChannelHandler.h
>@@ -82,7 +82,7 @@ private:
>         RTCDataChannelState state;
>         std::optional<webrtc::RTCError> error;
>     };
>-    using Message = std::variant<StateChange, String, Ref<SharedBuffer>>;
>+    using Message = std::variant<StateChange, String, Ref<FragmentedSharedBuffer>>;
>     using PendingMessages = Vector<Message>;
>     void storeMessage(PendingMessages&, const webrtc::DataBuffer&);
>     void processMessage(const webrtc::DataBuffer&);
>diff --git a/Source/WebCore/Modules/model-element/HTMLModelElement.cpp b/Source/WebCore/Modules/model-element/HTMLModelElement.cpp
>index 309c02643f5a..27a6d70334ca 100644
>--- a/Source/WebCore/Modules/model-element/HTMLModelElement.cpp
>+++ b/Source/WebCore/Modules/model-element/HTMLModelElement.cpp
>@@ -116,7 +116,7 @@ void HTMLModelElement::setSourceURL(const URL& url)
> 
>     m_sourceURL = url;
> 
>-    m_data = nullptr;
>+    m_data.reset();
>     m_dataComplete = false;
> 
>     if (m_resource) {
>@@ -149,7 +149,7 @@ void HTMLModelElement::setSourceURL(const URL& url)
>         return;
>     }
> 
>-    m_data = SharedBuffer::create();
>+    m_data.empty();
> 
>     m_resource = resource.value();
>     m_resource->addClient(*this);
>@@ -180,8 +180,7 @@ RenderPtr<RenderElement> HTMLModelElement::createElementRenderer(RenderStyle&& s
> void HTMLModelElement::dataReceived(CachedResource& resource, const uint8_t* data, int dataLength)
> {
>     ASSERT_UNUSED(resource, &resource == m_resource);
>-    ASSERT(m_data);
>-    m_data->append(data, dataLength);
>+    m_data.append(data, dataLength);
> }
> 
> void HTMLModelElement::notifyFinished(CachedResource& resource, const NetworkLoadMetrics&)
>@@ -195,7 +194,7 @@ void HTMLModelElement::notifyFinished(CachedResource& resource, const NetworkLoa
>     };
> 
>     if (resource.loadFailedOrCanceled()) {
>-        m_data = nullptr;
>+        m_data.reset();
> 
>         invalidateResourceHandleAndUpdateRenderer();
> 
>@@ -204,7 +203,7 @@ void HTMLModelElement::notifyFinished(CachedResource& resource, const NetworkLoa
>     }
> 
>     m_dataComplete = true;
>-    m_model = Model::create(m_data.releaseNonNull().get(), resource.mimeType(), resource.url());
>+    m_model = Model::create(m_data.takeAsContiguous().get(), resource.mimeType(), resource.url());
> 
>     invalidateResourceHandleAndUpdateRenderer();
> 
>diff --git a/Source/WebCore/Modules/model-element/HTMLModelElement.h b/Source/WebCore/Modules/model-element/HTMLModelElement.h
>index 05a1cdaa3e14..ce009d4e5edc 100644
>--- a/Source/WebCore/Modules/model-element/HTMLModelElement.h
>+++ b/Source/WebCore/Modules/model-element/HTMLModelElement.h
>@@ -133,7 +133,7 @@ private:
> 
>     URL m_sourceURL;
>     CachedResourceHandle<CachedRawResource> m_resource;
>-    RefPtr<SharedBuffer> m_data;
>+    SharedBufferBuilder m_data;
>     RefPtr<Model> m_model;
>     UniqueRef<ReadyPromise> m_readyPromise;
>     bool m_dataComplete { false };
>diff --git a/Source/WebCore/Modules/model-element/scenekit/SceneKitModelLoaderUSD.mm b/Source/WebCore/Modules/model-element/scenekit/SceneKitModelLoaderUSD.mm
>index 3e82ac221679..1303ec4d2568 100644
>--- a/Source/WebCore/Modules/model-element/scenekit/SceneKitModelLoaderUSD.mm
>+++ b/Source/WebCore/Modules/model-element/scenekit/SceneKitModelLoaderUSD.mm
>@@ -104,7 +104,7 @@ static RetainPtr<NSURL> writeToTemporaryFile(WebCore::Model& modelSource)
>     auto filePath = FileSystem::openTemporaryFile("ModelFile", fileHandle, ".usdz");
>     ASSERT(FileSystem::isHandleValid(fileHandle));
> 
>-    size_t byteCount = FileSystem::writeToFile(fileHandle, modelSource.data()->data(), modelSource.data()->size());
>+    size_t byteCount = FileSystem::writeToFile(fileHandle, modelSource.data()->makeContiguous()->data(), modelSource.data()->size());
>     ASSERT_UNUSED(byteCount, byteCount == modelSource.data()->size());
>     FileSystem::closeFile(fileHandle);
> 
>diff --git a/Source/WebCore/Modules/streams/ReadableStreamSink.h b/Source/WebCore/Modules/streams/ReadableStreamSink.h
>index 0b898f6adb57..d5173fbf8b40 100644
>--- a/Source/WebCore/Modules/streams/ReadableStreamSink.h
>+++ b/Source/WebCore/Modules/streams/ReadableStreamSink.h
>@@ -35,7 +35,7 @@ namespace WebCore {
> 
> class BufferSource;
> class ReadableStream;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class ReadableStreamSink : public RefCounted<ReadableStreamSink> {
> public:
>diff --git a/Source/WebCore/bindings/js/ScriptBufferSourceProvider.h b/Source/WebCore/bindings/js/ScriptBufferSourceProvider.h
>index c452c83fbd5c..b8b7785f91d0 100644
>--- a/Source/WebCore/bindings/js/ScriptBufferSourceProvider.h
>+++ b/Source/WebCore/bindings/js/ScriptBufferSourceProvider.h
>@@ -51,13 +51,15 @@ public:
>         if (m_scriptBuffer.isEmpty())
>             return emptyString();
> 
>+        if (!m_contiguousBuffer && (!m_containsOnlyASCII || *m_containsOnlyASCII))
>+            m_contiguousBuffer = m_scriptBuffer.buffer()->makeContiguous();
>         if (!m_containsOnlyASCII) {
>-            m_containsOnlyASCII = charactersAreAllASCII(m_scriptBuffer.buffer()->data(), m_scriptBuffer.buffer()->size());
>+            m_containsOnlyASCII = charactersAreAllASCII(m_contiguousBuffer->data(), m_scriptBuffer.buffer()->size());
>             if (*m_containsOnlyASCII)
>-                m_scriptHash = StringHasher::computeHashAndMaskTop8Bits(m_scriptBuffer.buffer()->data(), m_scriptBuffer.buffer()->size());
>+                m_scriptHash = StringHasher::computeHashAndMaskTop8Bits(m_contiguousBuffer->data(), m_scriptBuffer.buffer()->size());
>         }
>         if (*m_containsOnlyASCII)
>-            return { m_scriptBuffer.buffer()->data(), static_cast<unsigned>(m_scriptBuffer.buffer()->size()) };
>+            return { m_contiguousBuffer->data(), static_cast<unsigned>(m_scriptBuffer.buffer()->size()) };
> 
>         if (!m_cachedScriptString) {
>             m_cachedScriptString = m_scriptBuffer.toString();
>@@ -81,6 +83,7 @@ public:
>             return;
> 
>         m_scriptBuffer = scriptBuffer;
>+        m_contiguousBuffer = nullptr;
>     }
> 
> private:
>@@ -91,6 +94,7 @@ private:
>     }
> 
>     ScriptBuffer m_scriptBuffer;
>+    mutable RefPtr<SharedBuffer> m_contiguousBuffer;
>     mutable unsigned m_scriptHash { 0 };
>     mutable String m_cachedScriptString;
>     mutable std::optional<bool> m_containsOnlyASCII;
>diff --git a/Source/WebCore/bindings/js/SerializedScriptValue.h b/Source/WebCore/bindings/js/SerializedScriptValue.h
>index 7e49a9e73226..ef37f1d0ca46 100644
>--- a/Source/WebCore/bindings/js/SerializedScriptValue.h
>+++ b/Source/WebCore/bindings/js/SerializedScriptValue.h
>@@ -55,7 +55,7 @@ class DetachedOffscreenCanvas;
> class IDBValue;
> class MessagePort;
> class ImageBitmapBacking;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> enum class SerializationReturnCode;
> 
> enum class SerializationErrorMode { NonThrowing, Throwing };
>diff --git a/Source/WebCore/css/CSSFontFaceSource.h b/Source/WebCore/css/CSSFontFaceSource.h
>index 826133322a8e..108e6c8767d0 100644
>--- a/Source/WebCore/css/CSSFontFaceSource.h
>+++ b/Source/WebCore/css/CSSFontFaceSource.h
>@@ -34,6 +34,7 @@ namespace WebCore {
> 
> class CSSFontFace;
> class CSSFontSelector;
>+class SharedBuffer;
> class Document;
> class Font;
> class FontCreationContext;
>@@ -42,7 +43,6 @@ class FontDescription;
> struct FontSelectionSpecifiedCapabilities;
> struct FontVariantSettings;
> class SVGFontFaceElement;
>-class SharedBuffer;
> 
> template <typename T> class FontTaggedSettings;
> typedef FontTaggedSettings<int> FontFeatureSettings;
>diff --git a/Source/WebCore/dom/DataTransfer.cpp b/Source/WebCore/dom/DataTransfer.cpp
>index 1deac4f41cf4..c42ec051fe11 100644
>--- a/Source/WebCore/dom/DataTransfer.cpp
>+++ b/Source/WebCore/dom/DataTransfer.cpp
>@@ -402,7 +402,7 @@ struct PasteboardFileTypeReader final : PasteboardFileReader {
>         types.add(File::contentTypeForFile(filename));
>     }
> 
>-    void readBuffer(const String&, const String& type, Ref<SharedBuffer>&&)
>+    void readBuffer(const String&, const String& type, Ref<FragmentedSharedBuffer>&&)
>     {
>         types.add(type);
>     }
>diff --git a/Source/WebCore/editing/Editor.cpp b/Source/WebCore/editing/Editor.cpp
>index 1724cf0e50ba..c5e9e26b372a 100644
>--- a/Source/WebCore/editing/Editor.cpp
>+++ b/Source/WebCore/editing/Editor.cpp
>@@ -4133,7 +4133,7 @@ PromisedAttachmentInfo Editor::promisedAttachmentInfo(Element& element)
>     return { attachment->uniqueIdentifier(), WTFMove(additionalTypes), WTFMove(additionalData) };
> }
> 
>-void Editor::registerAttachmentIdentifier(const String& identifier, const String& contentType, const String& preferredFileName, Ref<SharedBuffer>&& data)
>+void Editor::registerAttachmentIdentifier(const String& identifier, const String& contentType, const String& preferredFileName, Ref<FragmentedSharedBuffer>&& data)
> {
>     if (auto* client = this->client())
>         client->registerAttachmentIdentifier(identifier, contentType, preferredFileName, WTFMove(data));
>diff --git a/Source/WebCore/editing/Editor.h b/Source/WebCore/editing/Editor.h
>index 01fe0b5e044e..1d0716c5b93c 100644
>--- a/Source/WebCore/editing/Editor.h
>+++ b/Source/WebCore/editing/Editor.h
>@@ -57,9 +57,10 @@ namespace WebCore {
> 
> class AlternativeTextController;
> class ArchiveResource;
>-class DataTransfer;
> class CompositeEditCommand;
>+class SharedBuffer;
> class CustomUndoStep;
>+class DataTransfer;
> class DeleteButtonController;
> class EditCommand;
> class EditCommandComposition;
>@@ -74,7 +75,7 @@ class KillRing;
> class Pasteboard;
> class PasteboardWriterData;
> class RenderLayer;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> class Font;
> class SpellCheckRequest;
> class SpellChecker;
>@@ -563,7 +564,7 @@ public:
> 
> #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<SharedBuffer>&& fileData);
>+    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&);
>diff --git a/Source/WebCore/editing/WebContentReader.h b/Source/WebCore/editing/WebContentReader.h
>index 08aa12426620..957b4fd4a557 100644
>--- a/Source/WebCore/editing/WebContentReader.h
>+++ b/Source/WebCore/editing/WebContentReader.h
>@@ -72,16 +72,16 @@ private:
>     bool readFilePath(const String&, PresentationSize preferredPresentationSize = { }, const String& contentType = { }) override;
>     bool readFilePaths(const Vector<String>&) override;
>     bool readHTML(const String&) override;
>-    bool readImage(Ref<SharedBuffer>&&, const String& type, PresentationSize preferredPresentationSize = { }) 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(SharedBuffer&) override;
>-    bool readRTFD(SharedBuffer&) override;
>-    bool readRTF(SharedBuffer&) override;
>-    bool readDataBuffer(SharedBuffer&, const String& type, const String& name, PresentationSize preferredPresentationSize = { }) override;
>+    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
> };
> 
>@@ -99,16 +99,16 @@ private:
>     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<SharedBuffer>&&, const String&, PresentationSize = { }) override { return false; }
>+    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(SharedBuffer&) override;
>-    bool readRTFD(SharedBuffer&) override;
>-    bool readRTF(SharedBuffer&) override;
>-    bool readDataBuffer(SharedBuffer&, const String&, const String&, PresentationSize = { }) override { return false; }
>+    bool readWebArchive(FragmentedSharedBuffer&) override;
>+    bool readRTFD(FragmentedSharedBuffer&) override;
>+    bool readRTF(FragmentedSharedBuffer&) override;
>+    bool readDataBuffer(FragmentedSharedBuffer&, const String&, const String&, PresentationSize = { }) override { return false; }
> #endif
> };
> 
>diff --git a/Source/WebCore/editing/WebCorePasteboardFileReader.cpp b/Source/WebCore/editing/WebCorePasteboardFileReader.cpp
>index 549eb7d2e4c0..117dba68edb0 100644
>--- a/Source/WebCore/editing/WebCorePasteboardFileReader.cpp
>+++ b/Source/WebCore/editing/WebCorePasteboardFileReader.cpp
>@@ -39,7 +39,7 @@ void WebCorePasteboardFileReader::readFilename(const String& filename)
>     files.append(File::create(context.get(), filename));
> }
> 
>-void WebCorePasteboardFileReader::readBuffer(const String& filename, const String& type, Ref<SharedBuffer>&& buffer)
>+void WebCorePasteboardFileReader::readBuffer(const String& filename, const String& type, Ref<FragmentedSharedBuffer>&& buffer)
> {
>     files.append(File::create(context.get(), Blob::create(context.get(), buffer->extractData(), type), filename));
> }
>diff --git a/Source/WebCore/editing/WebCorePasteboardFileReader.h b/Source/WebCore/editing/WebCorePasteboardFileReader.h
>index 5c529dd7c8ec..9d81605f1992 100644
>--- a/Source/WebCore/editing/WebCorePasteboardFileReader.h
>+++ b/Source/WebCore/editing/WebCorePasteboardFileReader.h
>@@ -41,7 +41,7 @@ struct WebCorePasteboardFileReader final : PasteboardFileReader {
>     ~WebCorePasteboardFileReader();
> 
>     void readFilename(const String&) final;
>-    void readBuffer(const String& filename, const String& type, Ref<SharedBuffer>&&) final;
>+    void readBuffer(const String& filename, const String& type, Ref<FragmentedSharedBuffer>&&) final;
> 
>     RefPtr<ScriptExecutionContext> context;
>     Vector<Ref<File>> files;
>diff --git a/Source/WebCore/editing/cocoa/HTMLConverter.mm b/Source/WebCore/editing/cocoa/HTMLConverter.mm
>index d48e11c96b78..078248362aa0 100644
>--- a/Source/WebCore/editing/cocoa/HTMLConverter.mm
>+++ b/Source/WebCore/editing/cocoa/HTMLConverter.mm
>@@ -1273,7 +1273,7 @@ BOOL HTMLConverter::_addAttachmentForElement(Element& element, NSURL *url, BOOL
>         if (auto resource = dataSource->subresource(url)) {
>             auto& mimeType = resource->mimeType();
>             if (!usePlaceholder || mimeType != "text/html") {
>-                fileWrapper = adoptNS([[NSFileWrapper alloc] initRegularFileWithContents:resource->data().createNSData().get()]);
>+                fileWrapper = adoptNS([[NSFileWrapper alloc] initRegularFileWithContents:resource->data().makeContiguous()->createNSData().get()]);
>                 [fileWrapper setPreferredFilename:suggestedFilenameWithMIMEType(url, mimeType)];
>             } else
>                 notFound = YES;
>@@ -2300,7 +2300,7 @@ static RetainPtr<NSFileWrapper> fileWrapperForURL(DocumentLoader* dataSource, NS
> 
>     if (dataSource) {
>         if (RefPtr<ArchiveResource> resource = dataSource->subresource(URL)) {
>-            auto wrapper = adoptNS([[NSFileWrapper alloc] initRegularFileWithContents:resource->data().createNSData().get()]);
>+            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());
>@@ -2322,8 +2322,8 @@ static RetainPtr<NSFileWrapper> fileWrapperForURL(DocumentLoader* dataSource, NS
> static RetainPtr<NSFileWrapper> fileWrapperForElement(HTMLImageElement& element)
> {
>     if (CachedImage* cachedImage = element.cachedImage()) {
>-        if (SharedBuffer* sharedBuffer = cachedImage->resourceBuffer())
>-            return adoptNS([[NSFileWrapper alloc] initRegularFileWithContents:sharedBuffer->createNSData().get()]);
>+        if (FragmentedSharedBuffer* sharedBuffer = cachedImage->resourceBuffer())
>+            return adoptNS([[NSFileWrapper alloc] initRegularFileWithContents:sharedBuffer->makeContiguous()->createNSData().get()]);
>     }
> 
>     auto* renderer = element.renderer();
>diff --git a/Source/WebCore/editing/cocoa/WebContentReaderCocoa.mm b/Source/WebCore/editing/cocoa/WebContentReaderCocoa.mm
>index 6aa3cd54e82b..76b1a009de43 100644
>--- a/Source/WebCore/editing/cocoa/WebContentReaderCocoa.mm
>+++ b/Source/WebCore/editing/cocoa/WebContentReaderCocoa.mm
>@@ -245,7 +245,7 @@ static bool supportsClientSideAttachmentData(const Frame& frame)
> 
> #endif
> 
>-static Ref<DocumentFragment> createFragmentForImageAttachment(Frame& frame, Document& document, Ref<SharedBuffer>&& buffer, const String& contentType, PresentationSize preferredSize)
>+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);
>@@ -309,7 +309,7 @@ static void replaceRichContentWithAttachments(Frame& frame, DocumentFragment& fr
>             continue;
> 
>         auto& resource = resourceEntry->value;
>-        serializedAttachmentData.append({ attachment.uniqueIdentifier(), resource->mimeType(), resource->data() });
>+        serializedAttachmentData.append({ attachment.uniqueIdentifier(), resource->mimeType(), resource->data().makeContiguous() });
>     }
> 
>     if (!serializedAttachmentData.isEmpty())
>@@ -332,7 +332,7 @@ static void replaceRichContentWithAttachments(Frame& frame, DocumentFragment& fr
>         if (name.isEmpty())
>             name = "media"_s;
> 
>-        attachmentInsertionInfo.append({ WTFMove(name), resource->value->mimeType(), resource->value->data(), image });
>+        attachmentInsertionInfo.append({ WTFMove(name), resource->value->mimeType(), resource->value->data().makeContiguous(), image });
>     }
> 
>     for (auto& object : descendantsOfType<HTMLObjectElement>(fragment)) {
>@@ -350,7 +350,7 @@ static void replaceRichContentWithAttachments(Frame& frame, DocumentFragment& fr
>         if (name.isEmpty())
>             name = "file"_s;
> 
>-        attachmentInsertionInfo.append({ WTFMove(name), resource->value->mimeType(), resource->value->data(), object });
>+        attachmentInsertionInfo.append({ WTFMove(name), resource->value->mimeType(), resource->value->data().makeContiguous(), object });
>     }
> 
>     for (auto& info : attachmentInsertionInfo) {
>@@ -428,7 +428,7 @@ struct MarkupAndArchive {
>     Ref<Archive> archive;
> };
> 
>-static std::optional<MarkupAndArchive> extractMarkupAndArchive(SharedBuffer& buffer, const std::function<bool(const String)>& canShowMIMETypeAsHTML)
>+static std::optional<MarkupAndArchive> extractMarkupAndArchive(FragmentedSharedBuffer& buffer, const std::function<bool(const String)>& canShowMIMETypeAsHTML)
> {
>     auto archive = LegacyWebArchive::create(URL(), buffer);
>     if (!archive)
>@@ -442,7 +442,7 @@ static std::optional<MarkupAndArchive> extractMarkupAndArchive(SharedBuffer& buf
>     if (!canShowMIMETypeAsHTML(type))
>         return std::nullopt;
> 
>-    return MarkupAndArchive { String::fromUTF8(mainResource->data().data(), mainResource->data().size()), mainResource.releaseNonNull(), archive.releaseNonNull() };
>+    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)
>@@ -481,7 +481,7 @@ static String sanitizeMarkupWithArchive(Frame& frame, Document& destinationDocum
>         if (!shouldReplaceSubresourceURL(subframeURL))
>             continue;
> 
>-        MarkupAndArchive subframeContent = { String::fromUTF8(subframeMainResource->data().data(), subframeMainResource->data().size()),
>+        MarkupAndArchive subframeContent = { String::fromUTF8(subframeMainResource->data().makeContiguous()->data(), subframeMainResource->data().size()),
>             subframeMainResource.releaseNonNull(), subframeArchive.copyRef() };
>         auto subframeMarkup = sanitizeMarkupWithArchive(frame, destinationDocument, subframeContent, MSOListQuirks::Disabled, canShowMIMETypeAsHTML);
> 
>@@ -497,7 +497,7 @@ static String sanitizeMarkupWithArchive(Frame& frame, Document& destinationDocum
>     return sanitizedMarkupForFragmentInDocument(WTFMove(fragment), *stagingDocument, msoListQuirks, markupAndArchive.markup);
> }
> 
>-bool WebContentReader::readWebArchive(SharedBuffer& buffer)
>+bool WebContentReader::readWebArchive(FragmentedSharedBuffer& buffer)
> {
>     if (frame.settings().preferMIMETypeForImages() || !frame.document())
>         return false;
>@@ -532,7 +532,7 @@ bool WebContentReader::readWebArchive(SharedBuffer& buffer)
>     return true;
> }
> 
>-bool WebContentMarkupReader::readWebArchive(SharedBuffer& buffer)
>+bool WebContentMarkupReader::readWebArchive(FragmentedSharedBuffer& buffer)
> {
>     if (!frame.document())
>         return false;
>@@ -612,12 +612,12 @@ bool WebContentMarkupReader::readHTML(const String& string)
>     return !markup.isEmpty();
> }
> 
>-bool WebContentReader::readRTFD(SharedBuffer& buffer)
>+bool WebContentReader::readRTFD(FragmentedSharedBuffer& buffer)
> {
>     if (frame.settings().preferMIMETypeForImages() || !frame.document())
>         return false;
> 
>-    auto string = adoptNS([[NSAttributedString alloc] initWithRTFD:buffer.createNSData().get() documentAttributes:nullptr]);
>+    auto string = adoptNS([[NSAttributedString alloc] initWithRTFD:buffer.makeContiguous()->createNSData().get() documentAttributes:nullptr]);
>     auto fragment = createFragmentAndAddResources(frame, string.get());
>     if (!fragment)
>         return false;
>@@ -626,11 +626,11 @@ bool WebContentReader::readRTFD(SharedBuffer& buffer)
>     return true;
> }
> 
>-bool WebContentMarkupReader::readRTFD(SharedBuffer& buffer)
>+bool WebContentMarkupReader::readRTFD(FragmentedSharedBuffer& buffer)
> {
>     if (!frame.document())
>         return false;
>-    auto string = adoptNS([[NSAttributedString alloc] initWithRTFD:buffer.createNSData().get() documentAttributes:nullptr]);
>+    auto string = adoptNS([[NSAttributedString alloc] initWithRTFD:buffer.makeContiguous()->createNSData().get() documentAttributes:nullptr]);
>     auto fragment = createFragmentAndAddResources(frame, string.get());
>     if (!fragment)
>         return false;
>@@ -639,12 +639,12 @@ bool WebContentMarkupReader::readRTFD(SharedBuffer& buffer)
>     return true;
> }
> 
>-bool WebContentReader::readRTF(SharedBuffer& buffer)
>+bool WebContentReader::readRTF(FragmentedSharedBuffer& buffer)
> {
>     if (frame.settings().preferMIMETypeForImages())
>         return false;
> 
>-    auto string = adoptNS([[NSAttributedString alloc] initWithRTF:buffer.createNSData().get() documentAttributes:nullptr]);
>+    auto string = adoptNS([[NSAttributedString alloc] initWithRTF:buffer.makeContiguous()->createNSData().get() documentAttributes:nullptr]);
>     auto fragment = createFragmentAndAddResources(frame, string.get());
>     if (!fragment)
>         return false;
>@@ -653,11 +653,11 @@ bool WebContentReader::readRTF(SharedBuffer& buffer)
>     return true;
> }
> 
>-bool WebContentMarkupReader::readRTF(SharedBuffer& buffer)
>+bool WebContentMarkupReader::readRTF(FragmentedSharedBuffer& buffer)
> {
>     if (!frame.document())
>         return false;
>-    auto string = adoptNS([[NSAttributedString alloc] initWithRTF:buffer.createNSData().get() documentAttributes:nullptr]);
>+    auto string = adoptNS([[NSAttributedString alloc] initWithRTF:buffer.makeContiguous()->createNSData().get() documentAttributes:nullptr]);
>     auto fragment = createFragmentAndAddResources(frame, string.get());
>     if (!fragment)
>         return false;
>@@ -676,7 +676,7 @@ bool WebContentReader::readPlainText(const String& text)
>     return true;
> }
> 
>-bool WebContentReader::readImage(Ref<SharedBuffer>&& buffer, const String& type, PresentationSize preferredPresentationSize)
>+bool WebContentReader::readImage(Ref<FragmentedSharedBuffer>&& buffer, const String& type, PresentationSize preferredPresentationSize)
> {
>     ASSERT(frame.document());
>     auto& document = *frame.document();
>@@ -746,7 +746,7 @@ ALLOW_DEPRECATED_DECLARATIONS_END
>     return attachment;
> }
> 
>-static Ref<HTMLElement> attachmentForData(Frame& frame, SharedBuffer& buffer, const String& contentType, const String& name, PresentationSize preferredSize)
>+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);
>@@ -833,7 +833,7 @@ bool WebContentReader::readURL(const URL& url, const String& title)
>     return true;
> }
> 
>-bool WebContentReader::readDataBuffer(SharedBuffer& buffer, const String& type, const String& name, PresentationSize preferredPresentationSize)
>+bool WebContentReader::readDataBuffer(FragmentedSharedBuffer& buffer, const String& type, const String& name, PresentationSize preferredPresentationSize)
> {
>     if (buffer.isEmpty())
>         return false;
>diff --git a/Source/WebCore/editing/gtk/WebContentReaderGtk.cpp b/Source/WebCore/editing/gtk/WebContentReaderGtk.cpp
>index 60486e71ad59..d3e9819bd531 100644
>--- a/Source/WebCore/editing/gtk/WebContentReaderGtk.cpp
>+++ b/Source/WebCore/editing/gtk/WebContentReaderGtk.cpp
>@@ -71,7 +71,7 @@ bool WebContentReader::readPlainText(const String& text)
>     return true;
> }
> 
>-bool WebContentReader::readImage(Ref<SharedBuffer>&& buffer, const String& type, PresentationSize preferredPresentationSize)
>+bool WebContentReader::readImage(Ref<FragmentedSharedBuffer>&& buffer, const String& type, PresentationSize preferredPresentationSize)
> {
>     ASSERT(frame.document());
>     auto& document = *frame.document();
>diff --git a/Source/WebCore/fileapi/Blob.h b/Source/WebCore/fileapi/Blob.h
>index 45d933e13ca4..bca6696ebe6f 100644
>--- a/Source/WebCore/fileapi/Blob.h
>+++ b/Source/WebCore/fileapi/Blob.h
>@@ -53,7 +53,7 @@ class BlobLoader;
> class DeferredPromise;
> class ReadableStream;
> class ScriptExecutionContext;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> template<typename> class ExceptionOr;
> 
>diff --git a/Source/WebCore/fileapi/NetworkSendQueue.cpp b/Source/WebCore/fileapi/NetworkSendQueue.cpp
>index 559ebcc48c5f..42f4180dfa84 100644
>--- a/Source/WebCore/fileapi/NetworkSendQueue.cpp
>+++ b/Source/WebCore/fileapi/NetworkSendQueue.cpp
>@@ -94,7 +94,7 @@ void NetworkSendQueue::processMessages()
>         bool shouldStopProcessing = false;
>         switchOn(m_queue.first(), [this](const CString& utf8) {
>             m_writeString(utf8);
>-        }, [this](Ref<SharedBuffer>& data) {
>+        }, [this](Ref<FragmentedSharedBuffer>& data) {
>             data->forEachSegment(m_writeRawData);
>         }, [this, &shouldStopProcessing](UniqueRef<BlobLoader>& loader) {
>             auto errorCode = loader->errorCode();
>diff --git a/Source/WebCore/fileapi/NetworkSendQueue.h b/Source/WebCore/fileapi/NetworkSendQueue.h
>index 551f70f9167b..d23cfebb4508 100644
>--- a/Source/WebCore/fileapi/NetworkSendQueue.h
>+++ b/Source/WebCore/fileapi/NetworkSendQueue.h
>@@ -43,7 +43,7 @@ namespace WebCore {
> 
> class Blob;
> class BlobLoader;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class WEBCORE_EXPORT NetworkSendQueue : public ContextDestructionObserver {
> public:
>@@ -63,7 +63,7 @@ public:
> private:
>     void processMessages();
> 
>-    using Message = std::variant<CString, Ref<SharedBuffer>, UniqueRef<BlobLoader>>;
>+    using Message = std::variant<CString, Ref<FragmentedSharedBuffer>, UniqueRef<BlobLoader>>;
>     Deque<Message> m_queue;
> 
>     WriteString m_writeString;
>diff --git a/Source/WebCore/html/HTMLAttachmentElement.cpp b/Source/WebCore/html/HTMLAttachmentElement.cpp
>index 56a06fcaf273..d2b8741a0443 100644
>--- a/Source/WebCore/html/HTMLAttachmentElement.cpp
>+++ b/Source/WebCore/html/HTMLAttachmentElement.cpp
>@@ -227,7 +227,7 @@ static bool mimeTypeIsSuitableForInlineImageAttachment(const String& mimeType)
>     return MIMETypeRegistry::isSupportedImageMIMEType(mimeType) || MIMETypeRegistry::isPDFMIMEType(mimeType);
> }
> 
>-void HTMLAttachmentElement::updateEnclosingImageWithData(const String& contentType, Ref<SharedBuffer>&& buffer)
>+void HTMLAttachmentElement::updateEnclosingImageWithData(const String& contentType, Ref<FragmentedSharedBuffer>&& buffer)
> {
>     auto* hostElement = shadowHost();
>     if (!is<HTMLImageElement>(hostElement) || !buffer->size())
>diff --git a/Source/WebCore/html/HTMLAttachmentElement.h b/Source/WebCore/html/HTMLAttachmentElement.h
>index 573ec2eae1cd..661dec9376d8 100644
>--- a/Source/WebCore/html/HTMLAttachmentElement.h
>+++ b/Source/WebCore/html/HTMLAttachmentElement.h
>@@ -36,7 +36,7 @@ class File;
> class HTMLImageElement;
> class RenderAttachment;
> class ShareableBitmap;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class HTMLAttachmentElement final : public HTMLElement {
>     WTF_MAKE_ISO_ALLOCATED(HTMLAttachmentElement);
>@@ -57,7 +57,7 @@ public:
>     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<SharedBuffer>&& data);
>+    WEBCORE_EXPORT void updateEnclosingImageWithData(const String& contentType, Ref<FragmentedSharedBuffer>&& data);
>     WEBCORE_EXPORT void updateThumbnail(const RefPtr<Image>& thumbnail);
> 
>     InsertedIntoAncestorResult insertedIntoAncestor(InsertionType, ContainerNode&) final;
>diff --git a/Source/WebCore/html/HTMLMediaElement.cpp b/Source/WebCore/html/HTMLMediaElement.cpp
>index ec8351c09774..564c31529e69 100644
>--- a/Source/WebCore/html/HTMLMediaElement.cpp
>+++ b/Source/WebCore/html/HTMLMediaElement.cpp
>@@ -2939,7 +2939,7 @@ void HTMLMediaElement::cdmClientAttemptToResumePlaybackIfNecessary()
>     attemptToResumePlaybackIfNecessary();
> }
> 
>-void HTMLMediaElement::cdmClientUnrequestedInitializationDataReceived(const String& initDataType, Ref<SharedBuffer>&& initData)
>+void HTMLMediaElement::cdmClientUnrequestedInitializationDataReceived(const String& initDataType, Ref<FragmentedSharedBuffer>&& initData)
> {
>     mediaPlayerInitializationDataEncountered(initDataType, initData->tryCreateArrayBuffer());
> }
>diff --git a/Source/WebCore/html/HTMLMediaElement.h b/Source/WebCore/html/HTMLMediaElement.h
>index 6b404aa87352..9128bcdbee59 100644
>--- a/Source/WebCore/html/HTMLMediaElement.h
>+++ b/Source/WebCore/html/HTMLMediaElement.h
>@@ -721,7 +721,7 @@ private:
> 
>     // CDMClient
>     void cdmClientAttemptToResumePlaybackIfNecessary() final;
>-    void cdmClientUnrequestedInitializationDataReceived(const String&, Ref<SharedBuffer>&&) final;
>+    void cdmClientUnrequestedInitializationDataReceived(const String&, Ref<FragmentedSharedBuffer>&&) final;
> #endif
> 
> #if ENABLE(LEGACY_ENCRYPTED_MEDIA) && ENABLE(ENCRYPTED_MEDIA)
>diff --git a/Source/WebCore/html/ImageDocument.cpp b/Source/WebCore/html/ImageDocument.cpp
>index 77cd4f380e28..4370d681872d 100644
>--- a/Source/WebCore/html/ImageDocument.cpp
>+++ b/Source/WebCore/html/ImageDocument.cpp
>@@ -141,7 +141,7 @@ void ImageDocument::updateDuringParsing()
>     if (!m_imageElement)
>         createDocumentStructure();
> 
>-    if (RefPtr<SharedBuffer> buffer = loader()->mainResourceData())
>+    if (RefPtr<FragmentedSharedBuffer> buffer = loader()->mainResourceData())
>         m_imageElement->cachedImage()->updateBuffer(*buffer);
> 
>     imageUpdated();
>@@ -151,7 +151,7 @@ void ImageDocument::finishedParsing()
> {
>     if (!parser()->isStopped() && m_imageElement) {
>         CachedImage& cachedImage = *m_imageElement->cachedImage();
>-        RefPtr<SharedBuffer> data = loader()->mainResourceData();
>+        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.
>diff --git a/Source/WebCore/inspector/InspectorInstrumentation.cpp b/Source/WebCore/inspector/InspectorInstrumentation.cpp
>index a7ca7162d791..18793ff06633 100644
>--- a/Source/WebCore/inspector/InspectorInstrumentation.cpp
>+++ b/Source/WebCore/inspector/InspectorInstrumentation.cpp
>@@ -850,7 +850,7 @@ void InspectorInstrumentation::interceptRequestImpl(InstrumentingAgents& instrum
>         networkAgent->interceptRequest(loader, WTFMove(handler));
> }
> 
>-void InspectorInstrumentation::interceptResponseImpl(InstrumentingAgents& instrumentingAgents, const ResourceResponse& response, ResourceLoaderIdentifier identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&& handler)
>+void InspectorInstrumentation::interceptResponseImpl(InstrumentingAgents& instrumentingAgents, const ResourceResponse& response, ResourceLoaderIdentifier identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<FragmentedSharedBuffer>)>&& handler)
> {
>     if (auto* networkAgent = instrumentingAgents.enabledNetworkAgent())
>         networkAgent->interceptResponse(response, identifier, WTFMove(handler));
>diff --git a/Source/WebCore/inspector/InspectorInstrumentation.h b/Source/WebCore/inspector/InspectorInstrumentation.h
>index 8e65c4eb1023..d2957810d838 100644
>--- a/Source/WebCore/inspector/InspectorInstrumentation.h
>+++ b/Source/WebCore/inspector/InspectorInstrumentation.h
>@@ -93,7 +93,7 @@ class ResourceResponse;
> class ScriptExecutionContext;
> class SecurityOrigin;
> class ShadowRoot;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> class TimerBase;
> class WebKitNamedFlow;
> class WebSocketChannel;
>@@ -236,7 +236,7 @@ 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<SharedBuffer>)>&&);
>+    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>);
>@@ -441,7 +441,7 @@ private:
>     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<SharedBuffer>)>&&);
>+    static void interceptResponseImpl(InstrumentingAgents&, const ResourceResponse&, ResourceLoaderIdentifier, CompletionHandler<void(const ResourceResponse&, RefPtr<FragmentedSharedBuffer>)>&&);
> 
>     static void addMessageToConsoleImpl(InstrumentingAgents&, std::unique_ptr<Inspector::ConsoleMessage>);
> 
>@@ -1289,7 +1289,7 @@ inline void InspectorInstrumentation::interceptRequest(ResourceLoader& loader, F
>         interceptRequestImpl(*agents, loader, WTFMove(handler));
> }
> 
>-inline void InspectorInstrumentation::interceptResponse(const Frame& frame, const ResourceResponse& response, ResourceLoaderIdentifier identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&& 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))
>diff --git a/Source/WebCore/inspector/InspectorInstrumentationWebKit.cpp b/Source/WebCore/inspector/InspectorInstrumentationWebKit.cpp
>index 61e4bc3ba019..f06403a6234b 100644
>--- a/Source/WebCore/inspector/InspectorInstrumentationWebKit.cpp
>+++ b/Source/WebCore/inspector/InspectorInstrumentationWebKit.cpp
>@@ -45,7 +45,7 @@ void InspectorInstrumentationWebKit::interceptRequestInternal(ResourceLoader& lo
>     InspectorInstrumentation::interceptRequest(loader, WTFMove(handler));
> }
> 
>-void InspectorInstrumentationWebKit::interceptResponseInternal(const Frame& frame, const ResourceResponse& response, ResourceLoaderIdentifier identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&& handler)
>+void InspectorInstrumentationWebKit::interceptResponseInternal(const Frame& frame, const ResourceResponse& response, ResourceLoaderIdentifier identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<FragmentedSharedBuffer>)>&& handler)
> {
>     InspectorInstrumentation::interceptResponse(frame, response, identifier, WTFMove(handler));
> }
>diff --git a/Source/WebCore/inspector/InspectorInstrumentationWebKit.h b/Source/WebCore/inspector/InspectorInstrumentationWebKit.h
>index f76114ce98f4..07b421b59c15 100644
>--- a/Source/WebCore/inspector/InspectorInstrumentationWebKit.h
>+++ b/Source/WebCore/inspector/InspectorInstrumentationWebKit.h
>@@ -36,20 +36,20 @@ class Frame;
> class ResourceLoader;
> class ResourceRequest;
> class ResourceResponse;
>-class SharedBuffer;
>+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<SharedBuffer>)>&&);
>+    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<SharedBuffer>)>&&);
>+    static void interceptResponseInternal(const Frame&, const ResourceResponse&, ResourceLoaderIdentifier, CompletionHandler<void(const ResourceResponse&, RefPtr<FragmentedSharedBuffer>)>&&);
> };
> 
> inline bool InspectorInstrumentationWebKit::shouldInterceptRequest(const Frame* frame, const ResourceRequest& request)
>@@ -76,7 +76,7 @@ inline void InspectorInstrumentationWebKit::interceptRequest(ResourceLoader& loa
>     interceptRequestInternal(loader, WTFMove(handler));
> }
> 
>-inline void InspectorInstrumentationWebKit::interceptResponse(const Frame* frame, const ResourceResponse& response, ResourceLoaderIdentifier identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&& 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));
>diff --git a/Source/WebCore/inspector/NetworkResourcesData.cpp b/Source/WebCore/inspector/NetworkResourcesData.cpp
>index 677c5b812d4f..39b011cf06f7 100644
>--- a/Source/WebCore/inspector/NetworkResourcesData.cpp
>+++ b/Source/WebCore/inspector/NetworkResourcesData.cpp
>@@ -33,7 +33,6 @@
> #include "CachedResource.h"
> #include "InspectorNetworkAgent.h"
> #include "ResourceResponse.h"
>-#include "SharedBuffer.h"
> #include "TextResourceDecoder.h"
> #include <wtf/text/Base64.h>
> 
>@@ -63,8 +62,8 @@ unsigned NetworkResourcesData::ResourceData::removeContent()
>     unsigned result = 0;
>     if (hasData()) {
>         ASSERT(!hasContent());
>-        result = m_dataBuffer->size();
>-        m_dataBuffer = nullptr;
>+        result = m_dataBuffer.size();
>+        m_dataBuffer.reset();
>     }
> 
>     if (hasContent()) {
>@@ -81,36 +80,37 @@ unsigned NetworkResourcesData::ResourceData::evictContent()
>     return removeContent();
> }
> 
>+bool NetworkResourcesData::ResourceData::hasData() const
>+{
>+    return !!m_dataBuffer;
>+}
>+
> size_t NetworkResourcesData::ResourceData::dataLength() const
> {
>-    return m_dataBuffer ? m_dataBuffer->size() : 0;
>+    return m_dataBuffer.size();
> }
> 
> void NetworkResourcesData::ResourceData::appendData(const uint8_t* data, size_t dataLength)
> {
>     ASSERT(!hasContent());
>-    if (!m_dataBuffer)
>-        m_dataBuffer = SharedBuffer::create(data, dataLength);
>-    else
>-        m_dataBuffer->append(data, dataLength);
>+    m_dataBuffer.append(data, dataLength);
> }
> 
> unsigned NetworkResourcesData::ResourceData::decodeDataToContent()
> {
>     ASSERT(!hasContent());
> 
>-    size_t dataLength = m_dataBuffer->size();
>+    auto buffer = m_dataBuffer.takeAsContiguous();
>+    size_t dataLength = buffer->size();
> 
>     if (m_decoder) {
>         m_base64Encoded = false;
>-        m_content = m_decoder->decodeAndFlush(m_dataBuffer->data(), dataLength);
>+        m_content = m_decoder->decodeAndFlush(buffer->data(), dataLength);
>     } else {
>         m_base64Encoded = true;
>-        m_content = base64EncodeToString(m_dataBuffer->data(), dataLength);
>+        m_content = base64EncodeToString(buffer->data(), dataLength);
>     }
> 
>-    m_dataBuffer = nullptr;
>-
>     return m_content.sizeInBytes() - dataLength;
> }
> 
>@@ -267,7 +267,7 @@ void NetworkResourcesData::addCachedResource(const String& requestId, CachedReso
>     resourceData->setCachedResource(cachedResource);
> }
> 
>-void NetworkResourcesData::addResourceSharedBuffer(const String& requestId, RefPtr<SharedBuffer>&& buffer, const String& textEncodingName)
>+void NetworkResourcesData::addResourceSharedBuffer(const String& requestId, RefPtr<FragmentedSharedBuffer>&& buffer, const String& textEncodingName)
> {
>     ResourceData* resourceData = resourceDataForRequestId(requestId);
>     if (!resourceData)
>diff --git a/Source/WebCore/inspector/NetworkResourcesData.h b/Source/WebCore/inspector/NetworkResourcesData.h
>index efa00053ae11..daae5fe4a31e 100644
>--- a/Source/WebCore/inspector/NetworkResourcesData.h
>+++ b/Source/WebCore/inspector/NetworkResourcesData.h
>@@ -30,6 +30,7 @@
> #pragma once
> 
> #include "InspectorPageAgent.h"
>+#include "SharedBuffer.h"
> #include <wtf/Deque.h>
> #include <wtf/HashMap.h>
> #include <wtf/WallTime.h>
>@@ -40,7 +41,6 @@ namespace WebCore {
> class CachedResource;
> class ResourceResponse;
> class TextResourceDecoder;
>-class SharedBuffer;
> 
> class NetworkResourcesData {
>     WTF_MAKE_FAST_ALLOCATED;
>@@ -88,8 +88,8 @@ public:
>         RefPtr<TextResourceDecoder> decoder() const { return m_decoder.copyRef(); }
>         void setDecoder(RefPtr<TextResourceDecoder>&& decoder) { m_decoder = WTFMove(decoder); }
> 
>-        RefPtr<SharedBuffer> buffer() const { return m_buffer.copyRef(); }
>-        void setBuffer(RefPtr<SharedBuffer>&& buffer) { m_buffer = WTFMove(buffer); }
>+        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; }
>@@ -103,10 +103,10 @@ public:
>         WallTime responseTimestamp() const { return m_responseTimestamp; }
>         void setResponseTimestamp(WallTime time) { m_responseTimestamp = time; }
> 
>-        bool hasBufferedData() const { return m_dataBuffer; }
>+        bool hasBufferedData() const { return hasData(); }
> 
>     private:
>-        bool hasData() const { return m_dataBuffer; }
>+        bool hasData() const;
>         size_t dataLength() const;
>         void appendData(const uint8_t* data, size_t dataLength);
>         unsigned decodeDataToContent();
>@@ -119,8 +119,8 @@ public:
>         String m_textEncodingName;
>         String m_mimeType;
>         RefPtr<TextResourceDecoder> m_decoder;
>-        RefPtr<SharedBuffer> m_dataBuffer;
>-        RefPtr<SharedBuffer> m_buffer;
>+        SharedBufferBuilder m_dataBuffer;
>+        RefPtr<FragmentedSharedBuffer> m_buffer;
>         std::optional<CertificateInfo> m_certificateInfo;
>         CachedResource* m_cachedResource { nullptr };
>         InspectorPageAgent::ResourceType m_type { InspectorPageAgent::OtherResource };
>@@ -144,7 +144,7 @@ public:
>     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<SharedBuffer>&&, const String& textEncodingName);
>+    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*);
>diff --git a/Source/WebCore/inspector/agents/InspectorNetworkAgent.cpp b/Source/WebCore/inspector/agents/InspectorNetworkAgent.cpp
>index 4e3daf1ade47..223a6767be27 100644
>--- a/Source/WebCore/inspector/agents/InspectorNetworkAgent.cpp
>+++ b/Source/WebCore/inspector/agents/InspectorNetworkAgent.cpp
>@@ -1140,7 +1140,7 @@ void InspectorNetworkAgent::interceptRequest(ResourceLoader& loader, Function<vo
>     m_frontendDispatcher->requestIntercepted(requestId, buildObjectForResourceRequest(loader.request()));
> }
> 
>-void InspectorNetworkAgent::interceptResponse(const ResourceResponse& response, ResourceLoaderIdentifier identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&& handler)
>+void InspectorNetworkAgent::interceptResponse(const ResourceResponse& response, ResourceLoaderIdentifier identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<FragmentedSharedBuffer>)>&& handler)
> {
>     ASSERT(m_enabled);
>     ASSERT(m_interceptionEnabled);
>@@ -1243,7 +1243,7 @@ Protocol::ErrorStringOr<void> InspectorNetworkAgent::interceptWithResponse(const
>         overrideResponse.setHTTPHeaderField(HTTPHeaderName::ContentType, overrideResponse.mimeType());
>     }
> 
>-    RefPtr<SharedBuffer> overrideData;
>+    RefPtr<FragmentedSharedBuffer> overrideData;
>     if (base64Encoded) {
>         auto buffer = base64Decode(content);
>         if (!buffer)
>@@ -1271,7 +1271,7 @@ Protocol::ErrorStringOr<void> InspectorNetworkAgent::interceptRequestWithRespons
>     if (loader->reachedTerminalState())
>         return makeUnexpected("Unable to fulfill request, it has already been processed"_s);
> 
>-    RefPtr<SharedBuffer> data;
>+    RefPtr<FragmentedSharedBuffer> data;
>     if (base64Encoded) {
>         auto buffer = base64Decode(content);
>         if (!buffer)
>@@ -1407,12 +1407,12 @@ bool InspectorNetworkAgent::cachedResourceContent(CachedResource& resource, Stri
>         if (InspectorNetworkAgent::shouldTreatAsText(resource.mimeType())) {
>             auto decoder = InspectorNetworkAgent::createTextDecoder(resource.mimeType(), resource.response().textEncodingName());
>             *base64Encoded = false;
>-            *result = decoder->decodeAndFlush(buffer->data(), buffer->size());
>+            *result = decoder->decodeAndFlush(buffer->makeContiguous()->data(), buffer->size());
>             return true;
>         }
> 
>         *base64Encoded = true;
>-        *result = base64EncodeToString(buffer->data(), buffer->size());
>+        *result = base64EncodeToString(buffer->makeContiguous()->data(), buffer->size());
>         return true;
>     }
> }
>diff --git a/Source/WebCore/inspector/agents/InspectorNetworkAgent.h b/Source/WebCore/inspector/agents/InspectorNetworkAgent.h
>index 8f6fbcc293ae..6bcd87ddcd8b 100644
>--- a/Source/WebCore/inspector/agents/InspectorNetworkAgent.h
>+++ b/Source/WebCore/inspector/agents/InspectorNetworkAgent.h
>@@ -123,7 +123,7 @@ public:
>     bool willIntercept(const ResourceRequest&);
>     bool shouldInterceptRequest(const ResourceRequest&);
>     bool shouldInterceptResponse(const ResourceResponse&);
>-    void interceptResponse(const ResourceResponse&, ResourceLoaderIdentifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&&);
>+    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>>&);
>@@ -185,7 +185,7 @@ private:
>         WTF_MAKE_NONCOPYABLE(PendingInterceptResponse);
>         WTF_MAKE_FAST_ALLOCATED;
>     public:
>-        PendingInterceptResponse(const ResourceResponse& originalResponse, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&& completionHandler)
>+        PendingInterceptResponse(const ResourceResponse& originalResponse, CompletionHandler<void(const ResourceResponse&, RefPtr<FragmentedSharedBuffer>)>&& completionHandler)
>             : m_originalResponse(originalResponse)
>             , m_completionHandler(WTFMove(completionHandler))
>         { }
>@@ -202,7 +202,7 @@ private:
>             respond(m_originalResponse, nullptr);
>         }
> 
>-        void respond(const ResourceResponse& response, RefPtr<SharedBuffer> data)
>+        void respond(const ResourceResponse& response, RefPtr<FragmentedSharedBuffer> data)
>         {
>             ASSERT(!m_responded);
>             if (m_responded)
>@@ -215,7 +215,7 @@ private:
> 
>     private:
>         ResourceResponse m_originalResponse;
>-        CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)> m_completionHandler;
>+        CompletionHandler<void(const ResourceResponse&, RefPtr<FragmentedSharedBuffer>)> m_completionHandler;
>         bool m_responded { false };
>     };
> 
>diff --git a/Source/WebCore/inspector/agents/InspectorPageAgent.cpp b/Source/WebCore/inspector/agents/InspectorPageAgent.cpp
>index 9b5cad959a8e..a4ffd1361cdd 100644
>--- a/Source/WebCore/inspector/agents/InspectorPageAgent.cpp
>+++ b/Source/WebCore/inspector/agents/InspectorPageAgent.cpp
>@@ -100,15 +100,15 @@ static bool decodeBuffer(const uint8_t* buffer, unsigned size, const String& tex
> 
> bool InspectorPageAgent::mainResourceContent(Frame* frame, bool withBase64Encode, String* result)
> {
>-    RefPtr<SharedBuffer> buffer = frame->loader().documentLoader()->mainResourceData();
>+    RefPtr<FragmentedSharedBuffer> buffer = frame->loader().documentLoader()->mainResourceData();
>     if (!buffer)
>         return false;
>-    return InspectorPageAgent::dataContent(buffer->data(), buffer->size(), frame->document()->encoding(), withBase64Encode, result);
>+    return InspectorPageAgent::dataContent(buffer->makeContiguous()->data(), buffer->size(), frame->document()->encoding(), withBase64Encode, result);
> }
> 
>-bool InspectorPageAgent::sharedBufferContent(RefPtr<SharedBuffer>&& buffer, const String& textEncodingName, bool withBase64Encode, String* result)
>+bool InspectorPageAgent::sharedBufferContent(RefPtr<FragmentedSharedBuffer>&& buffer, const String& textEncodingName, bool withBase64Encode, String* result)
> {
>-    return dataContent(buffer ? buffer->data() : nullptr, buffer ? buffer->size() : 0, textEncodingName, withBase64Encode, 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)
>@@ -156,7 +156,7 @@ void InspectorPageAgent::resourceContent(Protocol::ErrorString& errorString, Fra
>     if (!loader)
>         return;
> 
>-    RefPtr<SharedBuffer> buffer;
>+    RefPtr<FragmentedSharedBuffer> buffer;
>     bool success = false;
>     if (equalIgnoringFragmentIdentifier(url, loader->url())) {
>         *base64Encoded = false;
>diff --git a/Source/WebCore/inspector/agents/InspectorPageAgent.h b/Source/WebCore/inspector/agents/InspectorPageAgent.h
>index b51addb1bd8f..3d5e566dbe0c 100644
>--- a/Source/WebCore/inspector/agents/InspectorPageAgent.h
>+++ b/Source/WebCore/inspector/agents/InspectorPageAgent.h
>@@ -49,7 +49,7 @@ class InspectorClient;
> class InspectorOverlay;
> class Page;
> class RenderObject;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class InspectorPageAgent final : public InspectorAgentBase, public Inspector::PageBackendDispatcherHandler {
>     WTF_MAKE_NONCOPYABLE(InspectorPageAgent);
>@@ -75,7 +75,7 @@ public:
>         OtherResource,
>     };
> 
>-    static bool sharedBufferContent(RefPtr<SharedBuffer>&&, const String& textEncodingName, bool withBase64Encode, String* result);
>+    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*);
>diff --git a/Source/WebCore/loader/ContentFilter.cpp b/Source/WebCore/loader/ContentFilter.cpp
>index b4e6a3a53b4c..6ae526597cd2 100644
>--- a/Source/WebCore/loader/ContentFilter.cpp
>+++ b/Source/WebCore/loader/ContentFilter.cpp
>@@ -233,7 +233,7 @@ void ContentFilter::deliverResourceData(CachedResource& resource)
>     ASSERT(m_state == State::Allowed);
>     ASSERT(resource.dataBufferingPolicy() == DataBufferingPolicy::BufferData);
>     if (auto* resourceBuffer = resource.resourceBuffer())
>-        m_client.dataReceivedThroughContentFilter(resourceBuffer->data(), resourceBuffer->size());
>+        m_client.dataReceivedThroughContentFilter(resourceBuffer->makeContiguous()->data(), resourceBuffer->size());
> }
> 
> static const URL& blockedPageURL()
>@@ -276,7 +276,7 @@ void ContentFilter::handleProvisionalLoadFailure(const ResourceError& error)
> {
>     ASSERT(willHandleProvisionalLoadFailure(error));
> 
>-    RefPtr<SharedBuffer> replacementData { m_blockingContentFilter->replacementData() };
>+    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 };
>diff --git a/Source/WebCore/loader/DocumentLoader.cpp b/Source/WebCore/loader/DocumentLoader.cpp
>index cf6ccf2bd089..0ab4e14f9ce3 100644
>--- a/Source/WebCore/loader/DocumentLoader.cpp
>+++ b/Source/WebCore/loader/DocumentLoader.cpp
>@@ -208,7 +208,7 @@ DocumentLoader::~DocumentLoader()
> #endif
> }
> 
>-RefPtr<SharedBuffer> DocumentLoader::mainResourceData() const
>+RefPtr<FragmentedSharedBuffer> DocumentLoader::mainResourceData() const
> {
>     if (m_substituteData.isValid())
>         return m_substituteData.content()->copy();
>@@ -1605,11 +1605,11 @@ bool DocumentLoader::maybeCreateArchive()
>     addAllArchiveResources(*m_archive);
>     ASSERT(m_archive->mainResource());
>     auto& mainResource = *m_archive->mainResource();
>-    m_parsedArchiveData = &mainResource.data();
>+    m_parsedArchiveData = mainResource.data().makeContiguous();
>     m_writer.setMIMEType(mainResource.mimeType());
> 
>     ASSERT(m_frame->document());
>-    commitData(mainResource.data().data(), mainResource.data().size());
>+    commitData(m_parsedArchiveData->data(), mainResource.data().size());
>     return true;
> #endif
> }
>@@ -1668,7 +1668,7 @@ ArchiveResource* DocumentLoader::archiveResourceForURL(const URL& url) const
> 
> RefPtr<ArchiveResource> DocumentLoader::mainResource() const
> {
>-    RefPtr<SharedBuffer> data = mainResourceData();
>+    RefPtr<FragmentedSharedBuffer> data = mainResourceData();
>     if (!data)
>         data = SharedBuffer::create();
>     auto& response = this->response();
>@@ -2252,8 +2252,8 @@ void DocumentLoader::maybeFinishLoadingMultipartContent()
> 
>     frameLoader()->setupForReplace();
>     m_committed = false;
>-    RefPtr<SharedBuffer> resourceData = mainResourceData();
>-    commitLoad(resourceData->data(), resourceData->size());
>+    RefPtr<FragmentedSharedBuffer> resourceData = mainResourceData();
>+    commitLoad(resourceData->makeContiguous()->data(), resourceData->size());
> }
> 
> void DocumentLoader::startIconLoading()
>@@ -2289,7 +2289,7 @@ void DocumentLoader::startIconLoading()
>     m_frame->loader().client().getLoadDecisionForIcons(iconDecisions);
> }
> 
>-void DocumentLoader::didGetLoadDecisionForIcon(bool decision, uint64_t loadIdentifier, CompletionHandler<void(SharedBuffer*)>&& completionHandler)
>+void DocumentLoader::didGetLoadDecisionForIcon(bool decision, uint64_t loadIdentifier, CompletionHandler<void(FragmentedSharedBuffer*)>&& completionHandler)
> {
>     auto icon = m_iconsPendingLoadDecision.take(loadIdentifier);
> 
>@@ -2310,7 +2310,7 @@ void DocumentLoader::didGetLoadDecisionForIcon(bool decision, uint64_t loadIdent
>     rawIconLoader->startLoading();
> }
> 
>-void DocumentLoader::finishedLoadingIcon(IconLoader& loader, SharedBuffer* buffer)
>+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);
>diff --git a/Source/WebCore/loader/DocumentLoader.h b/Source/WebCore/loader/DocumentLoader.h
>index f7f3f3844f18..4d4d3085cae8 100644
>--- a/Source/WebCore/loader/DocumentLoader.h
>+++ b/Source/WebCore/loader/DocumentLoader.h
>@@ -75,6 +75,7 @@ class ArchiveResourceCollection;
> class CachedRawResource;
> class CachedResourceLoader;
> class ContentFilter;
>+class SharedBuffer;
> struct CustomHeaderFields;
> class FormState;
> class Frame;
>@@ -83,7 +84,7 @@ class IconLoader;
> class Page;
> class PreviewConverter;
> class ResourceLoader;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> class SWClientConnection;
> class SubresourceLoader;
> class SubstituteResource;
>@@ -171,7 +172,7 @@ public:
> 
>     WEBCORE_EXPORT FrameLoader* frameLoader() const;
>     WEBCORE_EXPORT SubresourceLoader* mainResourceLoader() const;
>-    WEBCORE_EXPORT RefPtr<SharedBuffer> mainResourceData() const;
>+    WEBCORE_EXPORT RefPtr<FragmentedSharedBuffer> mainResourceData() const;
>     
>     DocumentWriter& writer() const { return m_writer; }
> 
>@@ -392,8 +393,8 @@ public:
> #endif
> 
>     void startIconLoading();
>-    WEBCORE_EXPORT void didGetLoadDecisionForIcon(bool decision, uint64_t loadIdentifier, CompletionHandler<void(SharedBuffer*)>&&);
>-    void finishedLoadingIcon(IconLoader&, SharedBuffer*);
>+    WEBCORE_EXPORT void didGetLoadDecisionForIcon(bool decision, uint64_t loadIdentifier, CompletionHandler<void(FragmentedSharedBuffer*)>&&);
>+    void finishedLoadingIcon(IconLoader&, FragmentedSharedBuffer*);
> 
>     const Vector<LinkIcon>& linkIcons() const { return m_linkIcons; }
> 
>@@ -621,7 +622,7 @@ private:
>     bool m_waitingForNavigationPolicy { false };
> 
>     HashMap<uint64_t, LinkIcon> m_iconsPendingLoadDecision;
>-    HashMap<std::unique_ptr<IconLoader>, CompletionHandler<void(SharedBuffer*)>> m_iconLoaders;
>+    HashMap<std::unique_ptr<IconLoader>, CompletionHandler<void(FragmentedSharedBuffer*)>> m_iconLoaders;
>     Vector<LinkIcon> m_linkIcons;
> 
> #if ENABLE(APPLICATION_MANIFEST)
>diff --git a/Source/WebCore/loader/FrameLoader.h b/Source/WebCore/loader/FrameLoader.h
>index edece12cd7a9..75ae284c2c34 100644
>--- a/Source/WebCore/loader/FrameLoader.h
>+++ b/Source/WebCore/loader/FrameLoader.h
>@@ -59,6 +59,7 @@ class CachedFrameBase;
> class CachedPage;
> class CachedResource;
> class Chrome;
>+class SharedBuffer;
> class DOMWrapperWorld;
> class Document;
> class DocumentLoader;
>@@ -76,7 +77,6 @@ class ResourceError;
> class ResourceRequest;
> class ResourceResponse;
> class SerializedScriptValue;
>-class SharedBuffer;
> class SubstituteData;
> 
> enum class CachePolicy : uint8_t;
>diff --git a/Source/WebCore/loader/FrameLoaderClient.h b/Source/WebCore/loader/FrameLoaderClient.h
>index 4fd637a9014a..ee9f3d0c984d 100644
>--- a/Source/WebCore/loader/FrameLoaderClient.h
>+++ b/Source/WebCore/loader/FrameLoaderClient.h
>@@ -98,7 +98,7 @@ class ResourceHandle;
> class ResourceRequest;
> class ResourceResponse;
> class SecurityOrigin;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> class SubstituteData;
> class Widget;
> 
>diff --git a/Source/WebCore/loader/LoaderStrategy.h b/Source/WebCore/loader/LoaderStrategy.h
>index aef668bd63ed..29d2e3f46140 100644
>--- a/Source/WebCore/loader/LoaderStrategy.h
>+++ b/Source/WebCore/loader/LoaderStrategy.h
>@@ -51,7 +51,7 @@ class ResourceLoader;
> class ResourceRequest;
> class ResourceResponse;
> class SecurityOrigin;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> class SubresourceLoader;
> 
> struct FetchOptions;
>diff --git a/Source/WebCore/loader/NetscapePlugInStreamLoader.cpp b/Source/WebCore/loader/NetscapePlugInStreamLoader.cpp
>index 633755963200..6043ac9be267 100644
>--- a/Source/WebCore/loader/NetscapePlugInStreamLoader.cpp
>+++ b/Source/WebCore/loader/NetscapePlugInStreamLoader.cpp
>@@ -146,12 +146,12 @@ void NetscapePlugInStreamLoader::didReceiveData(const uint8_t* data, unsigned le
>     didReceiveDataOrBuffer(data, length, nullptr, encodedDataLength, dataPayloadType);
> }
> 
>-void NetscapePlugInStreamLoader::didReceiveBuffer(Ref<SharedBuffer>&& buffer, long long encodedDataLength, DataPayloadType 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<SharedBuffer>&& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)
>+void NetscapePlugInStreamLoader::didReceiveDataOrBuffer(const uint8_t* data, int length, RefPtr<FragmentedSharedBuffer>&& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)
> {
>     Ref<NetscapePlugInStreamLoader> protectedThis(*this);
> 
>diff --git a/Source/WebCore/loader/NetscapePlugInStreamLoader.h b/Source/WebCore/loader/NetscapePlugInStreamLoader.h
>index 48bb2153c93f..b5174edc94b9 100644
>--- a/Source/WebCore/loader/NetscapePlugInStreamLoader.h
>+++ b/Source/WebCore/loader/NetscapePlugInStreamLoader.h
>@@ -63,7 +63,7 @@ private:
>     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<SharedBuffer>&&, long long encodedDataLength, DataPayloadType) override;
>+    void didReceiveBuffer(Ref<FragmentedSharedBuffer>&&, long long encodedDataLength, DataPayloadType) override;
>     void didFinishLoading(const NetworkLoadMetrics&) override;
>     void didFail(const ResourceError&) override;
> 
>@@ -74,7 +74,7 @@ private:
>     void willCancel(const ResourceError&) override;
>     void didCancel(const ResourceError&) override;
> 
>-    void didReceiveDataOrBuffer(const uint8_t*, int, RefPtr<SharedBuffer>&&, long long encodedDataLength, DataPayloadType);
>+    void didReceiveDataOrBuffer(const uint8_t*, int, RefPtr<FragmentedSharedBuffer>&&, long long encodedDataLength, DataPayloadType);
> 
>     void notifyDone();
> 
>diff --git a/Source/WebCore/loader/ResourceCryptographicDigest.cpp b/Source/WebCore/loader/ResourceCryptographicDigest.cpp
>index c62776858a6d..d94b7000741c 100644
>--- a/Source/WebCore/loader/ResourceCryptographicDigest.cpp
>+++ b/Source/WebCore/loader/ResourceCryptographicDigest.cpp
>@@ -155,7 +155,7 @@ ResourceCryptographicDigest cryptographicDigestForBytes(ResourceCryptographicDig
>     return { algorithm, cryptoDigest->computeHash() };
> }
> 
>-ResourceCryptographicDigest cryptographicDigestForSharedBuffer(ResourceCryptographicDigest::Algorithm algorithm, const SharedBuffer* buffer)
>+ResourceCryptographicDigest cryptographicDigestForSharedBuffer(ResourceCryptographicDigest::Algorithm algorithm, const FragmentedSharedBuffer* buffer)
> {
>     auto cryptoDigest = PAL::CryptoDigest::create(toCryptoDigestAlgorithm(algorithm));
>     if (buffer) {
>diff --git a/Source/WebCore/loader/ResourceCryptographicDigest.h b/Source/WebCore/loader/ResourceCryptographicDigest.h
>index aea3dc57c878..83b8613cfda2 100644
>--- a/Source/WebCore/loader/ResourceCryptographicDigest.h
>+++ b/Source/WebCore/loader/ResourceCryptographicDigest.h
>@@ -34,7 +34,7 @@
> namespace WebCore {
> 
> class CachedResource;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> struct ResourceCryptographicDigest {
>     enum class Algorithm {
>@@ -75,7 +75,7 @@ std::optional<EncodedResourceCryptographicDigest> parseEncodedCryptographicDiges
> 
> std::optional<ResourceCryptographicDigest> decodeEncodedResourceCryptographicDigest(const EncodedResourceCryptographicDigest&);
> 
>-ResourceCryptographicDigest cryptographicDigestForSharedBuffer(ResourceCryptographicDigest::Algorithm, const SharedBuffer*);
>+ResourceCryptographicDigest cryptographicDigestForSharedBuffer(ResourceCryptographicDigest::Algorithm, const FragmentedSharedBuffer*);
> ResourceCryptographicDigest cryptographicDigestForBytes(ResourceCryptographicDigest::Algorithm, const void* bytes, size_t length);
> 
> }
>diff --git a/Source/WebCore/loader/ResourceLoader.cpp b/Source/WebCore/loader/ResourceLoader.cpp
>index aa85bb4d3ca8..6debb2588a3e 100644
>--- a/Source/WebCore/loader/ResourceLoader.cpp
>+++ b/Source/WebCore/loader/ResourceLoader.cpp
>@@ -50,7 +50,6 @@
> #include "ResourceError.h"
> #include "ResourceHandle.h"
> #include "SecurityOrigin.h"
>-#include "SharedBuffer.h"
> #include "SubresourceLoader.h"
> #include <wtf/CompletionHandler.h>
> #include <wtf/Ref.h>
>@@ -118,7 +117,7 @@ void ResourceLoader::releaseResources()
> 
>     m_identifier = { };
> 
>-    m_resourceData = nullptr;
>+    m_resourceData.reset();
>     m_deferredRequest = ResourceRequest();
> }
> 
>@@ -189,7 +188,7 @@ void ResourceLoader::init(ResourceRequest&& clientRequest, CompletionHandler<voi
>     });
> }
> 
>-void ResourceLoader::deliverResponseAndData(const ResourceResponse& response, RefPtr<SharedBuffer>&& buffer)
>+void ResourceLoader::deliverResponseAndData(const ResourceResponse& response, RefPtr<FragmentedSharedBuffer>&& buffer)
> {
>     didReceiveResponse(response, [this, protectedThis = Ref { *this }, buffer = WTFMove(buffer)]() mutable {
>         if (reachedTerminalState())
>@@ -318,7 +317,7 @@ void ResourceLoader::setDataBufferingPolicy(DataBufferingPolicy dataBufferingPol
> 
>     // Reset any already buffered data
>     if (dataBufferingPolicy == DataBufferingPolicy::DoNotBufferData)
>-        m_resourceData = nullptr;
>+        m_resourceData.reset();
> }
> 
> void ResourceLoader::willSwitchToSubstituteResource()
>@@ -329,29 +328,29 @@ void ResourceLoader::willSwitchToSubstituteResource()
>         m_handle->cancel();
> }
> 
>-void ResourceLoader::addDataOrBuffer(const uint8_t* data, unsigned length, SharedBuffer* buffer, DataPayloadType dataPayloadType)
>+void ResourceLoader::addDataOrBuffer(const uint8_t* data, unsigned length, FragmentedSharedBuffer* buffer, DataPayloadType dataPayloadType)
> {
>     if (m_options.dataBufferingPolicy == DataBufferingPolicy::DoNotBufferData)
>         return;
> 
>-    if (!m_resourceData || dataPayloadType == DataPayloadWholeResource) {
>-        if (buffer)
>-            m_resourceData = buffer;
>-        else
>-            m_resourceData = SharedBuffer::create(data, length);
>-        return;
>-    }
>-    
>+    if (dataPayloadType == DataPayloadWholeResource)
>+        m_resourceData.reset();
>+
>     if (buffer)
>-        m_resourceData->append(*buffer);
>+        m_resourceData.append(*buffer);
>     else
>-        m_resourceData->append(data, length);
>+        m_resourceData.append(data, length);
>+}
>+
>+const FragmentedSharedBuffer* ResourceLoader::resourceData() const
>+{
>+    return m_resourceData.get().get();
> }
> 
> void ResourceLoader::clearResourceData()
> {
>     if (m_resourceData)
>-        m_resourceData->clear();
>+        m_resourceData.empty();
> }
> 
> bool ResourceLoader::isSubresourceLoader() const
>@@ -551,14 +550,14 @@ void ResourceLoader::didReceiveData(const uint8_t* data, unsigned length, long l
>     didReceiveDataOrBuffer(data, length, nullptr, encodedDataLength, dataPayloadType);
> }
> 
>-void ResourceLoader::didReceiveBuffer(Ref<SharedBuffer>&& buffer, long long encodedDataLength, DataPayloadType 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<SharedBuffer>&& buffer, long long encodedDataLength, DataPayloadType 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 SharedBuffer.
>+    // 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
>@@ -571,7 +570,7 @@ void ResourceLoader::didReceiveDataOrBuffer(const uint8_t* data, unsigned length
>     // 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->data() : data, buffer ? buffer->size() : length, static_cast<int>(encodedDataLength));
>+        frameLoader()->notifier().didReceiveData(this, buffer ? buffer->makeContiguous()->data() : data, buffer ? buffer->size() : length, static_cast<int>(encodedDataLength));
> }
> 
> void ResourceLoader::didFinishLoading(const NetworkLoadMetrics& networkLoadMetrics)
>@@ -735,7 +734,7 @@ void ResourceLoader::didReceiveData(ResourceHandle*, const uint8_t* data, unsign
>     didReceiveData(data, length, encodedDataLength, DataPayloadBytes);
> }
> 
>-void ResourceLoader::didReceiveBuffer(ResourceHandle*, Ref<SharedBuffer>&& buffer, int encodedDataLength)
>+void ResourceLoader::didReceiveBuffer(ResourceHandle*, Ref<FragmentedSharedBuffer>&& buffer, int encodedDataLength)
> {
>     didReceiveBuffer(WTFMove(buffer), encodedDataLength, DataPayloadBytes);
> }
>diff --git a/Source/WebCore/loader/ResourceLoader.h b/Source/WebCore/loader/ResourceLoader.h
>index 4fd2bf0bbb3b..70ea220dc17c 100644
>--- a/Source/WebCore/loader/ResourceLoader.h
>+++ b/Source/WebCore/loader/ResourceLoader.h
>@@ -35,6 +35,7 @@
> #include "ResourceLoaderTypes.h"
> #include "ResourceRequest.h"
> #include "ResourceResponse.h"
>+#include "SharedBuffer.h"
> #include <wtf/Forward.h>
> #include <wtf/WeakPtr.h>
> 
>@@ -66,7 +67,7 @@ public:
> 
>     virtual void init(ResourceRequest&&, CompletionHandler<void(bool)>&&);
> 
>-    void deliverResponseAndData(const ResourceResponse&, RefPtr<SharedBuffer>&&);
>+    void deliverResponseAndData(const ResourceResponse&, RefPtr<FragmentedSharedBuffer>&&);
> 
> #if PLATFORM(IOS_FAMILY)
>     virtual void startLoading()
>@@ -98,7 +99,7 @@ public:
>     virtual void releaseResources();
>     const ResourceResponse& response() const { return m_response; }
> 
>-    SharedBuffer* resourceData() const { return m_resourceData.get(); }
>+    const FragmentedSharedBuffer* resourceData() const;
>     void clearResourceData();
>     
>     virtual bool isSubresourceLoader() const;
>@@ -107,7 +108,7 @@ public:
>     virtual void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent);
>     virtual void didReceiveResponse(const ResourceResponse&, CompletionHandler<void()>&& policyCompletionHandler);
>     virtual void didReceiveData(const uint8_t*, unsigned, long long encodedDataLength, DataPayloadType);
>-    virtual void didReceiveBuffer(Ref<SharedBuffer>&&, long long encodedDataLength, DataPayloadType);
>+    virtual void didReceiveBuffer(Ref<FragmentedSharedBuffer>&&, long long encodedDataLength, DataPayloadType);
>     virtual void didFinishLoading(const NetworkLoadMetrics&);
>     virtual void didFail(const ResourceError&);
> 
>@@ -166,7 +167,7 @@ protected:
> 
>     bool wasCancelled() const { return m_cancellationStatus >= Cancelled; }
> 
>-    void didReceiveDataOrBuffer(const uint8_t*, unsigned, RefPtr<SharedBuffer>&&, long long encodedDataLength, DataPayloadType);
>+    void didReceiveDataOrBuffer(const uint8_t*, unsigned, RefPtr<FragmentedSharedBuffer>&&, long long encodedDataLength, DataPayloadType);
>     
>     void setReferrerPolicy(ReferrerPolicy referrerPolicy) { m_options.referrerPolicy = referrerPolicy; }
>     ReferrerPolicy referrerPolicy() const { return m_options.referrerPolicy; }
>@@ -191,7 +192,7 @@ private:
>     virtual void willCancel(const ResourceError&) = 0;
>     virtual void didCancel(const ResourceError&) = 0;
> 
>-    void addDataOrBuffer(const uint8_t*, unsigned, SharedBuffer*, DataPayloadType);
>+    void addDataOrBuffer(const uint8_t*, unsigned, FragmentedSharedBuffer*, DataPayloadType);
>     void loadDataURL();
>     void finishNetworkLoad();
> 
>@@ -202,7 +203,7 @@ private:
>     void didReceiveResponseAsync(ResourceHandle*, ResourceResponse&&, CompletionHandler<void()>&&) override;
>     void willSendRequestAsync(ResourceHandle*, ResourceRequest&&, ResourceResponse&&, CompletionHandler<void(ResourceRequest&&)>&&) override;
>     void didReceiveData(ResourceHandle*, const uint8_t*, unsigned, int encodedDataLength) override;
>-    void didReceiveBuffer(ResourceHandle*, Ref<SharedBuffer>&&, int encodedDataLength) override;
>+    void didReceiveBuffer(ResourceHandle*, Ref<FragmentedSharedBuffer>&&, int encodedDataLength) override;
>     void didFinishLoading(ResourceHandle*, const NetworkLoadMetrics&) override;
>     void didFail(ResourceHandle*, const ResourceError&) override;
>     void wasBlocked(ResourceHandle*) override;
>@@ -227,7 +228,7 @@ private:
> 
>     ResourceRequest m_request;
>     ResourceRequest m_originalRequest; // Before redirects.
>-    RefPtr<SharedBuffer> m_resourceData;
>+    SharedBufferBuilder m_resourceData;
>     
>     ResourceLoaderIdentifier m_identifier;
> 
>diff --git a/Source/WebCore/loader/SubresourceLoader.cpp b/Source/WebCore/loader/SubresourceLoader.cpp
>index 46cefbdf9da1..37d0bb821abd 100644
>--- a/Source/WebCore/loader/SubresourceLoader.cpp
>+++ b/Source/WebCore/loader/SubresourceLoader.cpp
>@@ -530,7 +530,7 @@ void SubresourceLoader::didReceiveData(const uint8_t* data, unsigned length, lon
>     didReceiveDataOrBuffer(data, length, nullptr, encodedDataLength, dataPayloadType);
> }
> 
>-void SubresourceLoader::didReceiveBuffer(Ref<SharedBuffer>&& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)
>+void SubresourceLoader::didReceiveBuffer(Ref<FragmentedSharedBuffer>&& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)
> {
> #if USE(QUICK_LOOK)
>     if (auto previewLoader = m_previewLoader.get()) {
>@@ -542,7 +542,7 @@ void SubresourceLoader::didReceiveBuffer(Ref<SharedBuffer>&& buffer, long long e
>     didReceiveDataOrBuffer(nullptr, 0, WTFMove(buffer), encodedDataLength, dataPayloadType);
> }
> 
>-void SubresourceLoader::didReceiveDataOrBuffer(const uint8_t* data, int length, RefPtr<SharedBuffer>&& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)
>+void SubresourceLoader::didReceiveDataOrBuffer(const uint8_t* data, int length, RefPtr<FragmentedSharedBuffer>&& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)
> {
>     ASSERT(m_resource);
> 
>@@ -561,7 +561,7 @@ void SubresourceLoader::didReceiveDataOrBuffer(const uint8_t* data, int length,
>         if (auto* resourceData = this->resourceData())
>             m_resource->updateBuffer(*resourceData);
>         else
>-            m_resource->updateData(buffer ? buffer->data() : data, buffer ? buffer->size() : length);
>+            m_resource->updateData(buffer ? buffer->makeContiguous()->data() : data, buffer ? buffer->size() : length);
>     }
> }
> 
>diff --git a/Source/WebCore/loader/SubresourceLoader.h b/Source/WebCore/loader/SubresourceLoader.h
>index 3723b6b9ab9f..832c9f0e73d3 100644
>--- a/Source/WebCore/loader/SubresourceLoader.h
>+++ b/Source/WebCore/loader/SubresourceLoader.h
>@@ -74,7 +74,7 @@ private:
>     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<SharedBuffer>&&, 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;
>@@ -92,7 +92,7 @@ private:
>     Expected<void, String> checkResponseCrossOriginAccessControl(const ResourceResponse&);
>     Expected<void, String> checkRedirectionCrossOriginAccessControl(const ResourceRequest& previousRequest, const ResourceResponse&, ResourceRequest& newRequest);
> 
>-    void didReceiveDataOrBuffer(const uint8_t*, int, RefPtr<SharedBuffer>&&, long long encodedDataLength, DataPayloadType);
>+    void didReceiveDataOrBuffer(const uint8_t*, int, RefPtr<FragmentedSharedBuffer>&&, long long encodedDataLength, DataPayloadType);
> 
>     void notifyDone(LoadCompletionType);
> 
>diff --git a/Source/WebCore/loader/SubstituteData.h b/Source/WebCore/loader/SubstituteData.h
>index f66292e31cbe..a8a49b47f927 100644
>--- a/Source/WebCore/loader/SubstituteData.h
>+++ b/Source/WebCore/loader/SubstituteData.h
>@@ -43,7 +43,7 @@ namespace WebCore {
>         {
>         }
> 
>-        SubstituteData(RefPtr<SharedBuffer>&& content, const URL& failingURL, const ResourceResponse& response, SessionHistoryVisibility shouldRevealToSessionHistory)
>+        SubstituteData(RefPtr<FragmentedSharedBuffer>&& content, const URL& failingURL, const ResourceResponse& response, SessionHistoryVisibility shouldRevealToSessionHistory)
>             : m_content(WTFMove(content))
>             , m_failingURL(failingURL)
>             , m_response(response)
>@@ -54,14 +54,14 @@ namespace WebCore {
>         bool isValid() const { return m_content != nullptr; }
>         bool shouldRevealToSessionHistory() const { return m_shouldRevealToSessionHistory == SessionHistoryVisibility::Visible; }
> 
>-        const SharedBuffer* content() const { return m_content.get(); }
>+        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<SharedBuffer> m_content;
>+        RefPtr<FragmentedSharedBuffer> m_content;
>         URL m_failingURL;
>         ResourceResponse m_response;
>         SessionHistoryVisibility m_shouldRevealToSessionHistory { SessionHistoryVisibility::Hidden };
>diff --git a/Source/WebCore/loader/SubstituteResource.h b/Source/WebCore/loader/SubstituteResource.h
>index 59664b5854f8..cf2de0c62d95 100644
>--- a/Source/WebCore/loader/SubstituteResource.h
>+++ b/Source/WebCore/loader/SubstituteResource.h
>@@ -37,12 +37,14 @@ public:
> 
>     const URL& url() const { return m_url; }
>     const ResourceResponse& response() const { return m_response; }
>-    SharedBuffer& data() const { return static_reference_cast<SharedBuffer>(m_data); }
>+    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()); }
>+    virtual void deliver(ResourceLoader& loader) { loader.deliverResponseAndData(m_response, m_data.copy()); }
> 
> protected:
>-    SubstituteResource(URL&& url, ResourceResponse&& response, Ref<SharedBuffer>&& data)
>+    SubstituteResource(URL&& url, ResourceResponse&& response, Ref<FragmentedSharedBuffer>&& data)
>         : m_url(WTFMove(url))
>         , m_response(WTFMove(response))
>         , m_data(WTFMove(data))
>@@ -52,7 +54,7 @@ protected:
> private:
>     URL m_url;
>     ResourceResponse m_response;
>-    Ref<SharedBuffer> m_data;
>+    SharedBufferBuilder m_data;
> };
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/loader/appcache/ApplicationCacheGroup.cpp b/Source/WebCore/loader/appcache/ApplicationCacheGroup.cpp
>index 89f3b0f1dc39..036efd20e496 100644
>--- a/Source/WebCore/loader/appcache/ApplicationCacheGroup.cpp
>+++ b/Source/WebCore/loader/appcache/ApplicationCacheGroup.cpp
>@@ -605,7 +605,7 @@ void ApplicationCacheGroup::didFinishLoadingManifest()
>         }
>     }
>     
>-    auto manifest = parseApplicationCacheManifest(m_manifestURL, m_manifestResource->response().mimeType(), m_manifestResource->data().data(), m_manifestResource->data().size());
>+    auto manifest = parseApplicationCacheManifest(m_manifestURL, m_manifestResource->response().mimeType(), m_manifestResource->data().makeContiguous()->data(), m_manifestResource->data().size());
>     if (!manifest) {
>         // At the time of this writing, lack of "CACHE MANIFEST" signature is the only reason for parseManifest to fail.
>         m_frame->document()->addConsoleMessage(MessageSource::AppCache, MessageLevel::Error, "Application Cache manifest could not be parsed. Does it start with CACHE MANIFEST?"_s);
>diff --git a/Source/WebCore/loader/appcache/ApplicationCacheHost.cpp b/Source/WebCore/loader/appcache/ApplicationCacheHost.cpp
>index 603281888375..51978f412387 100644
>--- a/Source/WebCore/loader/appcache/ApplicationCacheHost.cpp
>+++ b/Source/WebCore/loader/appcache/ApplicationCacheHost.cpp
>@@ -255,10 +255,8 @@ URL ApplicationCacheHost::createFileURL(const String& path)
> 
> 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().copy();
>+        return resource.data().makeContiguous();
>     return SharedBuffer::createWithContentsOfFile(resource.path());
> }
> 
>@@ -290,9 +288,7 @@ void ApplicationCacheHost::maybeLoadFallbackSynchronously(const ResourceRequest&
>         ApplicationCacheResource* resource;
>         if (getApplicationCacheFallbackResource(request, resource)) {
>             response = resource->response();
>-            // FIXME: Clients proably do not need a copy of the SharedBuffer.
>-            // Remove the call to copy() once we ensure SharedBuffer will not be modified.
>-            data = resource->data().copy();
>+            data = resource->data().makeContiguous();
>         }
>     }
> }
>diff --git a/Source/WebCore/loader/appcache/ApplicationCacheHost.h b/Source/WebCore/loader/appcache/ApplicationCacheHost.h
>index 52cd16403a17..b96356e78561 100644
>--- a/Source/WebCore/loader/appcache/ApplicationCacheHost.h
>+++ b/Source/WebCore/loader/appcache/ApplicationCacheHost.h
>@@ -42,6 +42,7 @@ class ApplicationCache;
> class ApplicationCacheGroup;
> class ApplicationCacheResource;
> class ApplicationCacheStorage;
>+class SharedBuffer;
> class DOMApplicationCache;
> class DocumentLoader;
> class Frame;
>@@ -49,7 +50,6 @@ class ResourceError;
> class ResourceLoader;
> class ResourceRequest;
> class ResourceResponse;
>-class SharedBuffer;
> class SubstituteData;
> 
> class ApplicationCacheHost {
>diff --git a/Source/WebCore/loader/appcache/ApplicationCacheResource.cpp b/Source/WebCore/loader/appcache/ApplicationCacheResource.cpp
>index f1f7e1756301..2bb3fe75b997 100644
>--- a/Source/WebCore/loader/appcache/ApplicationCacheResource.cpp
>+++ b/Source/WebCore/loader/appcache/ApplicationCacheResource.cpp
>@@ -29,7 +29,7 @@
> 
> namespace WebCore {
> 
>-Ref<ApplicationCacheResource> ApplicationCacheResource::create(const URL& url, const ResourceResponse& response, unsigned type, RefPtr<SharedBuffer>&& buffer, const String& path)
>+Ref<ApplicationCacheResource> ApplicationCacheResource::create(const URL& url, const ResourceResponse& response, unsigned type, RefPtr<FragmentedSharedBuffer>&& buffer, const String& path)
> {
>     ASSERT(!url.hasFragmentIdentifier());
>     if (!buffer)
>@@ -40,7 +40,7 @@ Ref<ApplicationCacheResource> ApplicationCacheResource::create(const URL& url, c
>     return adoptRef(*new ApplicationCacheResource(URL { url }, WTFMove(resourceResponse), type, buffer.releaseNonNull(), path));
> }
> 
>-ApplicationCacheResource::ApplicationCacheResource(URL&& url, ResourceResponse&& response, unsigned type, Ref<SharedBuffer>&& data, const String& 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)
>@@ -51,7 +51,7 @@ ApplicationCacheResource::ApplicationCacheResource(URL&& url, ResourceResponse&&
> 
> void ApplicationCacheResource::deliver(ResourceLoader& loader)
> {
>-    loader.deliverResponseAndData(response(), m_path.isEmpty() ? data().copy() : SharedBuffer::createWithContentsOfFile(m_path));
>+    loader.deliverResponseAndData(response(), m_path.isEmpty() ? data().makeContiguous() : SharedBuffer::createWithContentsOfFile(m_path));
> }
> 
> void ApplicationCacheResource::addType(unsigned type) 
>diff --git a/Source/WebCore/loader/appcache/ApplicationCacheResource.h b/Source/WebCore/loader/appcache/ApplicationCacheResource.h
>index 88c94de1a774..c288e7036c67 100644
>--- a/Source/WebCore/loader/appcache/ApplicationCacheResource.h
>+++ b/Source/WebCore/loader/appcache/ApplicationCacheResource.h
>@@ -40,7 +40,7 @@ public:
>         Fallback = 1 << 4
>     };
> 
>-    static Ref<ApplicationCacheResource> create(const URL&, const ResourceResponse&, unsigned type, RefPtr<SharedBuffer>&& = SharedBuffer::create(), const String& path = String());
>+    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);
>@@ -58,7 +58,7 @@ public:
> #endif
>     
> private:
>-    ApplicationCacheResource(URL&&, ResourceResponse&&, unsigned type, Ref<SharedBuffer>&&, const String& path);
>+    ApplicationCacheResource(URL&&, ResourceResponse&&, unsigned type, Ref<FragmentedSharedBuffer>&&, const String& path);
> 
>     void deliver(ResourceLoader&) override;
> 
>diff --git a/Source/WebCore/loader/appcache/ApplicationCacheResourceLoader.cpp b/Source/WebCore/loader/appcache/ApplicationCacheResourceLoader.cpp
>index 1c50847a6e89..7b2fb6c9c253 100644
>--- a/Source/WebCore/loader/appcache/ApplicationCacheResourceLoader.cpp
>+++ b/Source/WebCore/loader/appcache/ApplicationCacheResourceLoader.cpp
>@@ -101,7 +101,7 @@ void ApplicationCacheResourceLoader::responseReceived(CachedResource& resource,
> 
> void ApplicationCacheResourceLoader::dataReceived(CachedResource&, const uint8_t* data, int length)
> {
>-    m_applicationCacheResource->data().append(data, length);
>+    m_applicationCacheResource->append(data, length);
> }
> 
> void ApplicationCacheResourceLoader::redirectReceived(CachedResource&, ResourceRequest&& newRequest, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&& callback)
>diff --git a/Source/WebCore/loader/appcache/ApplicationCacheStorage.cpp b/Source/WebCore/loader/appcache/ApplicationCacheStorage.cpp
>index 1b33ac95bcde..8cf05cce1880 100644
>--- a/Source/WebCore/loader/appcache/ApplicationCacheStorage.cpp
>+++ b/Source/WebCore/loader/appcache/ApplicationCacheStorage.cpp
>@@ -783,7 +783,6 @@ bool ApplicationCacheStorage::store(ApplicationCacheResource* resource, unsigned
>     auto dataStatement = m_database.prepareStatement("INSERT INTO CacheResourceData (data, path) VALUES (?, ?)"_s);
>     if (!dataStatement)
>         return false;
>-    
> 
>     String fullPath;
>     if (!resource->path().isEmpty())
>@@ -815,7 +814,7 @@ bool ApplicationCacheStorage::store(ApplicationCacheResource* resource, unsigned
>         dataStatement->bindText(2, path);
>     } else {
>         if (resource->data().size())
>-            dataStatement->bindBlob(1, resource->data());
>+            dataStatement->bindBlob(1, resource->data().makeContiguous().get());
>     }
>     
>     if (!dataStatement->executeCommand()) {
>@@ -873,12 +872,12 @@ bool ApplicationCacheStorage::store(ApplicationCacheResource* resource, unsigned
>     
>     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->data().clear();
>+        resource->clear();
> 
>     resource->setStorageID(resourceId);
>     return true;
>@@ -1273,7 +1272,7 @@ bool ApplicationCacheStorage::shouldStoreResourceAsFlatFile(ApplicationCacheReso
>     return startsWithLettersIgnoringASCIICase(type, "audio/") || startsWithLettersIgnoringASCIICase(type, "video/");
> }
>     
>-bool ApplicationCacheStorage::writeDataToUniqueFileInDirectory(SharedBuffer& data, const String& directory, String& path, const String& fileExtension)
>+bool ApplicationCacheStorage::writeDataToUniqueFileInDirectory(FragmentedSharedBuffer& data, const String& directory, String& path, const String& fileExtension)
> {
>     String fullPath;
>     
>diff --git a/Source/WebCore/loader/appcache/ApplicationCacheStorage.h b/Source/WebCore/loader/appcache/ApplicationCacheStorage.h
>index 9a953008766a..4102a1808b45 100644
>--- a/Source/WebCore/loader/appcache/ApplicationCacheStorage.h
>+++ b/Source/WebCore/loader/appcache/ApplicationCacheStorage.h
>@@ -39,7 +39,7 @@ class ApplicationCacheGroup;
> class ApplicationCacheHost;
> class ApplicationCacheResource;
> class SecurityOrigin;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> template<typename> class StorageIDJournal;
> 
> class ApplicationCacheStorage : public RefCounted<ApplicationCacheStorage> {
>@@ -122,7 +122,7 @@ private:
>     bool ensureOriginRecord(const SecurityOrigin*);
>     static bool shouldStoreResourceAsFlatFile(ApplicationCacheResource*);
>     void deleteTables();
>-    bool writeDataToUniqueFileInDirectory(SharedBuffer&, const String& directory, String& outFilename, const String& fileExtension);
>+    bool writeDataToUniqueFileInDirectory(FragmentedSharedBuffer&, const String& directory, String& outFilename, const String& fileExtension);
> 
>     void loadManifestHostHashes();
>     
>diff --git a/Source/WebCore/loader/archive/ArchiveFactory.cpp b/Source/WebCore/loader/archive/ArchiveFactory.cpp
>index 6de80c10ac7d..4ef9cd66bd08 100644
>--- a/Source/WebCore/loader/archive/ArchiveFactory.cpp
>+++ b/Source/WebCore/loader/archive/ArchiveFactory.cpp
>@@ -46,12 +46,12 @@
> 
> namespace WebCore {
> 
>-typedef RefPtr<Archive> RawDataCreationFunction(const URL&, SharedBuffer&);
>+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, SharedBuffer& buffer)
>+template<typename ArchiveClass> static RefPtr<Archive> archiveFactoryCreate(const URL& url, FragmentedSharedBuffer& buffer)
> {
>     return ArchiveClass::create(url, buffer);
> }
>@@ -83,7 +83,7 @@ bool ArchiveFactory::isArchiveMIMEType(const String& mimeType)
>     return !mimeType.isEmpty() && archiveMIMETypes().contains(mimeType);
> }
> 
>-RefPtr<Archive> ArchiveFactory::create(const URL& url, SharedBuffer* data, const String& mimeType)
>+RefPtr<Archive> ArchiveFactory::create(const URL& url, FragmentedSharedBuffer* data, const String& mimeType)
> {
>     if (!data)
>         return nullptr;
>diff --git a/Source/WebCore/loader/archive/ArchiveFactory.h b/Source/WebCore/loader/archive/ArchiveFactory.h
>index 21d2365cf8d9..5564515c9e0d 100644
>--- a/Source/WebCore/loader/archive/ArchiveFactory.h
>+++ b/Source/WebCore/loader/archive/ArchiveFactory.h
>@@ -34,12 +34,12 @@
> 
> namespace WebCore {
> 
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class ArchiveFactory {
> public:
>     static bool isArchiveMIMEType(const String&);
>-    static RefPtr<Archive> create(const URL&, SharedBuffer* data, const String& mimeType);
>+    static RefPtr<Archive> create(const URL&, FragmentedSharedBuffer* data, const String& mimeType);
>     static void registerKnownArchiveMIMETypes(HashSet<String, ASCIICaseInsensitiveHash>&);
> };
> 
>diff --git a/Source/WebCore/loader/archive/ArchiveResource.cpp b/Source/WebCore/loader/archive/ArchiveResource.cpp
>index fc20da3da032..0738394a8287 100644
>--- a/Source/WebCore/loader/archive/ArchiveResource.cpp
>+++ b/Source/WebCore/loader/archive/ArchiveResource.cpp
>@@ -33,7 +33,7 @@
> 
> namespace WebCore {
> 
>-inline ArchiveResource::ArchiveResource(Ref<SharedBuffer>&& data, const URL& url, const String& mimeType, const String& textEncoding, const String& frameName, const ResourceResponse& response)
>+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)
>@@ -42,7 +42,7 @@ inline ArchiveResource::ArchiveResource(Ref<SharedBuffer>&& data, const URL& url
> {
> }
> 
>-RefPtr<ArchiveResource> ArchiveResource::create(RefPtr<SharedBuffer>&& data, const URL& url, const String& mimeType, const String& textEncoding, const String& frameName, const ResourceResponse& response)
>+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;
>@@ -54,7 +54,7 @@ RefPtr<ArchiveResource> ArchiveResource::create(RefPtr<SharedBuffer>&& data, con
>     return adoptRef(*new ArchiveResource(data.releaseNonNull(), url, mimeType, textEncoding, frameName, response));
> }
> 
>-RefPtr<ArchiveResource> ArchiveResource::create(RefPtr<SharedBuffer>&& data, const URL& url, const ResourceResponse& 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);
> }
>diff --git a/Source/WebCore/loader/archive/ArchiveResource.h b/Source/WebCore/loader/archive/ArchiveResource.h
>index 209e9717aeb0..0548ef721efd 100644
>--- a/Source/WebCore/loader/archive/ArchiveResource.h
>+++ b/Source/WebCore/loader/archive/ArchiveResource.h
>@@ -34,8 +34,8 @@ namespace WebCore {
> 
> class ArchiveResource : public SubstituteResource {
> public:
>-    static RefPtr<ArchiveResource> create(RefPtr<SharedBuffer>&&, const URL&, const ResourceResponse&);
>-    WEBCORE_EXPORT static RefPtr<ArchiveResource> create(RefPtr<SharedBuffer>&&, const URL&,
>+    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());
> 
>@@ -47,7 +47,7 @@ public:
>     bool shouldIgnoreWhenUnarchiving() const { return m_shouldIgnoreWhenUnarchiving; }
> 
> private:
>-    ArchiveResource(Ref<SharedBuffer>&&, const URL&, const String& mimeType, const String& textEncoding, const String& frameName, const ResourceResponse&);
>+    ArchiveResource(Ref<FragmentedSharedBuffer>&&, const URL&, const String& mimeType, const String& textEncoding, const String& frameName, const ResourceResponse&);
> 
>     String m_mimeType;
>     String m_textEncoding;
>diff --git a/Source/WebCore/loader/archive/cf/LegacyWebArchive.cpp b/Source/WebCore/loader/archive/cf/LegacyWebArchive.cpp
>index de7dadddac22..71150cbdd896 100644
>--- a/Source/WebCore/loader/archive/cf/LegacyWebArchive.cpp
>+++ b/Source/WebCore/loader/archive/cf/LegacyWebArchive.cpp
>@@ -90,7 +90,7 @@ RetainPtr<CFDictionaryRef> LegacyWebArchive::createPropertyListRepresentation(Ar
>     // Resource data can be empty, but must be represented by an empty CFDataRef
>     auto& data = resource->data();
> 
>-    CFDictionarySetValue(propertyList.get(), LegacyWebArchiveResourceDataKey, data.createCFData().get());
>+    CFDictionarySetValue(propertyList.get(), LegacyWebArchiveResourceDataKey, data.makeContiguous()->createCFData().get());
> 
>     // Resource URL cannot be null
>     if (auto cfURL = resource->url().string().createCFString())
>@@ -117,9 +117,9 @@ RetainPtr<CFDictionaryRef> LegacyWebArchive::createPropertyListRepresentation(Ar
>     // Don't include the resource response for the main resource
>     if (!isMainResource) {
>         if (auto resourceResponseData = createPropertyListRepresentation(resource->response()))
>-            CFDictionarySetValue(propertyList.get(), LegacyWebArchiveResourceResponseKey, resourceResponseData.get());    
>+            CFDictionarySetValue(propertyList.get(), LegacyWebArchiveResourceResponseKey, resourceResponseData.get());
>     }
>-    
>+
>     return propertyList;
> }
> 
>@@ -215,13 +215,13 @@ RefPtr<ArchiveResource> LegacyWebArchive::createResource(CFDictionaryRef diction
>             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);
>     }
> 
>@@ -248,23 +248,23 @@ Ref<LegacyWebArchive> LegacyWebArchive::create(Ref<ArchiveResource>&& mainResour
>     return archive;
> }
> 
>-RefPtr<LegacyWebArchive> LegacyWebArchive::create(SharedBuffer& data)
>+RefPtr<LegacyWebArchive> LegacyWebArchive::create(FragmentedSharedBuffer& data)
> {
>     return create(URL(), data);
> }
> 
>-RefPtr<LegacyWebArchive> LegacyWebArchive::create(const URL&, SharedBuffer& data)
>+RefPtr<LegacyWebArchive> LegacyWebArchive::create(const URL&, FragmentedSharedBuffer& data)
> {
>     LOG(Archives, "LegacyWebArchive - Creating from raw data");
>-    
>+
>     Ref<LegacyWebArchive> archive = create();
>-        
>-    RetainPtr<CFDataRef> cfData = data.createCFData();
>+
>+    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
>@@ -276,12 +276,12 @@ RefPtr<LegacyWebArchive> LegacyWebArchive::create(const URL&, SharedBuffer& data
>             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;
> 
>@@ -295,7 +295,7 @@ bool LegacyWebArchive::extract(CFDictionaryRef dictionary)
>         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");
>@@ -333,7 +333,7 @@ bool LegacyWebArchive::extract(CFDictionaryRef dictionary)
>                 LOG(Archives, "LegacyWebArchive - Subresource is not expected CFDictionary, aborting invalid WebArchive");
>                 return false;
>             }
>-            
>+
>             if (auto subresource = createResource(subresourceDict))
>                 addSubresource(subresource.releaseNonNull());
>         }
>@@ -353,7 +353,7 @@ bool LegacyWebArchive::extract(CFDictionaryRef dictionary)
>                 LOG(Archives, "LegacyWebArchive - Subframe array is not expected CFDictionary, aborting invalid WebArchive");
>                 return false;
>             }
>-            
>+
>             auto subframeArchive = create();
>             if (subframeArchive->extract(subframeDict))
>                 addSubframeArchive(WTFMove(subframeArchive));
>@@ -361,7 +361,7 @@ bool LegacyWebArchive::extract(CFDictionaryRef dictionary)
>                 LOG(Archives, "LegacyWebArchive - Invalid subframe archive skipped");
>         }
>     }
>-    
>+
>     return true;
> }
> 
>@@ -506,7 +506,7 @@ RefPtr<LegacyWebArchive> LegacyWebArchive::create(const String& markupString, Fr
> {
>     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())
>@@ -605,7 +605,7 @@ RefPtr<LegacyWebArchive> LegacyWebArchive::createFromSelection(Frame* frame)
> 
>     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>";
>diff --git a/Source/WebCore/loader/archive/cf/LegacyWebArchive.h b/Source/WebCore/loader/archive/cf/LegacyWebArchive.h
>index d09ec9f75aba..5a07b10b4be6 100644
>--- a/Source/WebCore/loader/archive/cf/LegacyWebArchive.h
>+++ b/Source/WebCore/loader/archive/cf/LegacyWebArchive.h
>@@ -41,8 +41,8 @@ struct SimpleRange;
> class LegacyWebArchive final : public Archive {
> public:
>     WEBCORE_EXPORT static Ref<LegacyWebArchive> create();
>-    WEBCORE_EXPORT static RefPtr<LegacyWebArchive> create(SharedBuffer&);
>-    WEBCORE_EXPORT static RefPtr<LegacyWebArchive> create(const URL&, SharedBuffer&);
>+    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&);
>diff --git a/Source/WebCore/loader/archive/mhtml/MHTMLArchive.cpp b/Source/WebCore/loader/archive/mhtml/MHTMLArchive.cpp
>index acfbbb702022..d0139f87a06f 100644
>--- a/Source/WebCore/loader/archive/mhtml/MHTMLArchive.cpp
>+++ b/Source/WebCore/loader/archive/mhtml/MHTMLArchive.cpp
>@@ -106,7 +106,7 @@ Ref<MHTMLArchive> MHTMLArchive::create()
>     return adoptRef(*new MHTMLArchive);
> }
> 
>-RefPtr<MHTMLArchive> MHTMLArchive::create(const URL& url, SharedBuffer& data)
>+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()))
>@@ -130,7 +130,7 @@ RefPtr<MHTMLArchive> MHTMLArchive::create(const URL& url, SharedBuffer& data)
>     return mainArchive;
> }
> 
>-Ref<SharedBuffer> MHTMLArchive::generateMHTMLData(Page* page)
>+Ref<FragmentedSharedBuffer> MHTMLArchive::generateMHTMLData(Page* page)
> {
>     Vector<PageSerializer::Resource> resources;
>     PageSerializer pageSerializer(resources);
>@@ -162,8 +162,8 @@ Ref<SharedBuffer> MHTMLArchive::generateMHTMLData(Page* page)
>     // 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();
>-    auto mhtmlData = SharedBuffer::create();
>-    mhtmlData->append(asciiString.data(), asciiString.length());
>+    SharedBufferBuilder mhtmlData;
>+    mhtmlData.append(asciiString.data(), asciiString.length());
> 
>     for (auto& resource : resources) {
>         stringBuilder.clear();
>@@ -178,15 +178,15 @@ Ref<SharedBuffer> MHTMLArchive::generateMHTMLData(Page* page)
>         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());
>+        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);
>+            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.
>@@ -196,17 +196,17 @@ Ref<SharedBuffer> MHTMLArchive::generateMHTMLData(Page* page)
>             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);
>+                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());
>+    mhtmlData.append(asciiString.data(), asciiString.length());
> 
>-    return mhtmlData;
>+    return mhtmlData.take();
> }
> 
> }
>diff --git a/Source/WebCore/loader/archive/mhtml/MHTMLArchive.h b/Source/WebCore/loader/archive/mhtml/MHTMLArchive.h
>index 3d2db7c96002..2dfe87e82e7a 100644
>--- a/Source/WebCore/loader/archive/mhtml/MHTMLArchive.h
>+++ b/Source/WebCore/loader/archive/mhtml/MHTMLArchive.h
>@@ -38,14 +38,14 @@ namespace WebCore {
> 
> class MHTMLParser;
> class Page;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class MHTMLArchive final : public Archive {
> public:
>     static Ref<MHTMLArchive> create();
>-    static RefPtr<MHTMLArchive> create(const URL&, SharedBuffer&);
>+    static RefPtr<MHTMLArchive> create(const URL&, FragmentedSharedBuffer&);
> 
>-    static Ref<SharedBuffer> generateMHTMLData(Page*);
>+    static Ref<FragmentedSharedBuffer> generateMHTMLData(Page*);
> 
>     virtual ~MHTMLArchive();
> 
>diff --git a/Source/WebCore/loader/archive/mhtml/MHTMLParser.cpp b/Source/WebCore/loader/archive/mhtml/MHTMLParser.cpp
>index f1b901dd0203..e5186efb0b4f 100644
>--- a/Source/WebCore/loader/archive/mhtml/MHTMLParser.cpp
>+++ b/Source/WebCore/loader/archive/mhtml/MHTMLParser.cpp
>@@ -51,7 +51,7 @@ static bool skipLinesUntilBoundaryFound(SharedBufferChunkReader& lineReader, con
>     return false;
> }
> 
>-MHTMLParser::MHTMLParser(SharedBuffer* data)
>+MHTMLParser::MHTMLParser(FragmentedSharedBuffer* data)
>     : m_lineReader(data, "\r\n")
> {
> }
>@@ -140,7 +140,7 @@ RefPtr<ArchiveResource> MHTMLParser::parseNextPart(const MIMEHeader& mimeHeader,
> {
>     ASSERT(endOfPartBoundary.isEmpty() == endOfDocumentBoundary.isEmpty());
> 
>-    auto content = SharedBuffer::create();
>+    SharedBufferBuilder content;
>     const bool checkBoundary = !endOfPartBoundary.isEmpty();
>     bool endOfPartReached = false;
>     if (mimeHeader.contentTransferEncoding() == MIMEHeader::Binary) {
>@@ -154,7 +154,7 @@ RefPtr<ArchiveResource> MHTMLParser::parseNextPart(const MIMEHeader& mimeHeader,
>             LOG_ERROR("Binary contents requires end of part");
>             return nullptr;
>         }
>-        content->append(WTFMove(part));
>+        content.append(WTFMove(part));
>         m_lineReader.setSeparator("\r\n");
>         Vector<uint8_t> nextChars;
>         if (m_lineReader.peek(nextChars, 2) != 2) {
>@@ -180,10 +180,10 @@ RefPtr<ArchiveResource> MHTMLParser::parseNextPart(const MIMEHeader& mimeHeader,
>                 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());
>+            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);
>+                content.append("\r\n", 2);
>             }
>         }
>     }
>@@ -193,9 +193,10 @@ RefPtr<ArchiveResource> MHTMLParser::parseNextPart(const MIMEHeader& mimeHeader,
>     }
> 
>     Vector<uint8_t> data;
>+    auto contiguousContent = content.takeAsContiguous();
>     switch (mimeHeader.contentTransferEncoding()) {
>     case MIMEHeader::Base64: {
>-        auto decodedData = base64Decode(content->data(), content->size());
>+        auto decodedData = base64Decode(contiguousContent->data(), contiguousContent->size());
>         if (!decodedData) {
>             LOG_ERROR("Invalid base64 content for MHTML part.");
>             return nullptr;
>@@ -204,11 +205,11 @@ RefPtr<ArchiveResource> MHTMLParser::parseNextPart(const MIMEHeader& mimeHeader,
>         break;
>     }
>     case MIMEHeader::QuotedPrintable:
>-        data = quotedPrintableDecode(content->data(), content->size());
>+        data = quotedPrintableDecode(contiguousContent->data(), contiguousContent->size());
>         break;
>     case MIMEHeader::SevenBit:
>     case MIMEHeader::Binary:
>-        data.append(content->data(), content->size());
>+        data.append(contiguousContent->data(), contiguousContent->size());
>         break;
>     default:
>         LOG_ERROR("Invalid encoding for MHTML part.");
>diff --git a/Source/WebCore/loader/archive/mhtml/MHTMLParser.h b/Source/WebCore/loader/archive/mhtml/MHTMLParser.h
>index 1e9bd4d7767e..0d604343f3d7 100644
>--- a/Source/WebCore/loader/archive/mhtml/MHTMLParser.h
>+++ b/Source/WebCore/loader/archive/mhtml/MHTMLParser.h
>@@ -42,11 +42,11 @@ namespace WebCore {
> class ArchiveResource;
> class MHTMLArchive;
> class MIMEHeader;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class MHTMLParser {
> public:
>-    explicit MHTMLParser(SharedBuffer*);
>+    explicit MHTMLParser(FragmentedSharedBuffer*);
> 
>     RefPtr<MHTMLArchive> parseArchive();
> 
>diff --git a/Source/WebCore/loader/cache/CachedApplicationManifest.cpp b/Source/WebCore/loader/cache/CachedApplicationManifest.cpp
>index 4f228e8d0389..ddd0b1b89b1d 100644
>--- a/Source/WebCore/loader/cache/CachedApplicationManifest.cpp
>+++ b/Source/WebCore/loader/cache/CachedApplicationManifest.cpp
>@@ -40,12 +40,16 @@ CachedApplicationManifest::CachedApplicationManifest(CachedResourceRequest&& req
> {
> }
> 
>-void CachedApplicationManifest::finishLoading(SharedBuffer* data, const NetworkLoadMetrics& metrics)
>+void CachedApplicationManifest::finishLoading(const FragmentedSharedBuffer* data, const NetworkLoadMetrics& metrics)
> {
>-    m_data = data;
>-    setEncodedSize(data ? data->size() : 0);
>-    if (data)
>-        m_text = m_decoder->decodeAndFlush(data->data(), data->size());
>+    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);
> }
> 
>diff --git a/Source/WebCore/loader/cache/CachedApplicationManifest.h b/Source/WebCore/loader/cache/CachedApplicationManifest.h
>index 07f2a079c564..3798a9b4d901 100644
>--- a/Source/WebCore/loader/cache/CachedApplicationManifest.h
>+++ b/Source/WebCore/loader/cache/CachedApplicationManifest.h
>@@ -42,7 +42,7 @@ public:
>     std::optional<struct ApplicationManifest> process(const URL& manifestURL, const URL& documentURL, Document* = nullptr);
> 
> private:
>-    void finishLoading(SharedBuffer*, const NetworkLoadMetrics&) override;
>+    void finishLoading(const FragmentedSharedBuffer*, const NetworkLoadMetrics&) override;
>     const TextResourceDecoder* textResourceDecoder() const override { return m_decoder.ptr(); }
>     void setEncoding(const String&) override;
>     String encoding() const override;
>diff --git a/Source/WebCore/loader/cache/CachedCSSStyleSheet.cpp b/Source/WebCore/loader/cache/CachedCSSStyleSheet.cpp
>index 59fa7c62fc61..38a2e17f0d06 100644
>--- a/Source/WebCore/loader/cache/CachedCSSStyleSheet.cpp
>+++ b/Source/WebCore/loader/cache/CachedCSSStyleSheet.cpp
>@@ -81,7 +81,7 @@ const String CachedCSSStyleSheet::sheetText(MIMETypeCheckHint mimeTypeCheckHint,
>         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->data(), m_data->size());
>+    return m_decoder->decodeAndFlush(m_data->makeContiguous()->data(), m_data->size());
> }
> 
> void CachedCSSStyleSheet::setBodyDataFrom(const CachedResource& resource)
>@@ -97,13 +97,17 @@ void CachedCSSStyleSheet::setBodyDataFrom(const CachedResource& resource)
>         saveParsedStyleSheet(*sheet.m_parsedStyleSheetCache);
> }
> 
>-void CachedCSSStyleSheet::finishLoading(SharedBuffer* data, const NetworkLoadMetrics& metrics)
>+void CachedCSSStyleSheet::finishLoading(const FragmentedSharedBuffer* data, const NetworkLoadMetrics& metrics)
> {
>-    m_data = data;
>-    setEncodedSize(data ? data->size() : 0);
>-    // Decode the data to find out the encoding and keep the sheet text around during checkNotify()
>-    if (data)
>-        m_decodedSheetText = m_decoder->decodeAndFlush(data->data(), data->size());
>+    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.
>diff --git a/Source/WebCore/loader/cache/CachedCSSStyleSheet.h b/Source/WebCore/loader/cache/CachedCSSStyleSheet.h
>index 5d4dd3dc7e35..e655c69e3edb 100644
>--- a/Source/WebCore/loader/cache/CachedCSSStyleSheet.h
>+++ b/Source/WebCore/loader/cache/CachedCSSStyleSheet.h
>@@ -55,7 +55,7 @@ private:
>     void setEncoding(const String&) final;
>     String encoding() const final;
>     const TextResourceDecoder* textResourceDecoder() const final { return m_decoder.get(); }
>-    void finishLoading(SharedBuffer*, const NetworkLoadMetrics&) final;
>+    void finishLoading(const FragmentedSharedBuffer*, const NetworkLoadMetrics&) final;
>     void destroyDecodedData() final;
> 
>     void setBodyDataFrom(const CachedResource&) final;
>diff --git a/Source/WebCore/loader/cache/CachedFont.cpp b/Source/WebCore/loader/cache/CachedFont.cpp
>index 8c2bc2a341c8..d2bc2821479c 100644
>--- a/Source/WebCore/loader/cache/CachedFont.cpp
>+++ b/Source/WebCore/loader/cache/CachedFont.cpp
>@@ -64,10 +64,15 @@ void CachedFont::didAddClient(CachedResourceClient& client)
>         static_cast<CachedFontClient&>(client).fontLoaded(*this);
> }
> 
>-void CachedFont::finishLoading(SharedBuffer* data, const NetworkLoadMetrics& metrics)
>+void CachedFont::finishLoading(const FragmentedSharedBuffer* data, const NetworkLoadMetrics& metrics)
> {
>-    m_data = data;
>-    setEncodedSize(m_data.get() ? m_data->size() : 0);
>+    if (data) {
>+        m_data = data->makeContiguous();
>+        setEncodedSize(m_data->size());
>+    } else {
>+        m_data = nullptr;
>+        setEncodedSize(0);
>+    }
>     setLoading(false);
>     checkNotify(metrics);
> }
>@@ -105,7 +110,7 @@ bool CachedFont::ensureCustomFontData(SharedBuffer* data)
> 
> std::unique_ptr<FontCustomPlatformData> CachedFont::createCustomFontData(SharedBuffer& bytes, const String& itemInCollection, bool& wrapping)
> {
>-    RefPtr buffer { &bytes };
>+    RefPtr buffer = { &bytes };
>     wrapping = !convertWOFFToSfntIfNecessary(buffer);
>     return buffer ? createFontCustomPlatformData(*buffer, itemInCollection) : nullptr;
> }
>@@ -135,7 +140,7 @@ void CachedFont::checkNotify(const NetworkLoadMetrics&)
> {
>     if (isLoading())
>         return;
>-    
>+
>     CachedResourceClientWalker<CachedFontClient> walker(m_clients);
>     while (CachedFontClient* client = walker.next())
>         client->fontLoaded(*this);
>diff --git a/Source/WebCore/loader/cache/CachedFont.h b/Source/WebCore/loader/cache/CachedFont.h
>index cebdc557f13f..13466cc99d0d 100644
>--- a/Source/WebCore/loader/cache/CachedFont.h
>+++ b/Source/WebCore/loader/cache/CachedFont.h
>@@ -74,7 +74,7 @@ private:
>     NO_RETURN_DUE_TO_ASSERT void setBodyDataFrom(const CachedResource&) final { ASSERT_NOT_REACHED(); }
> 
>     void didAddClient(CachedResourceClient&) override;
>-    void finishLoading(SharedBuffer*, const NetworkLoadMetrics&) override;
>+    void finishLoading(const FragmentedSharedBuffer*, const NetworkLoadMetrics&) override;
> 
>     void allClientsRemoved() override;
> 
>diff --git a/Source/WebCore/loader/cache/CachedImage.cpp b/Source/WebCore/loader/cache/CachedImage.cpp
>index b159f29ee90f..946279520d0d 100644
>--- a/Source/WebCore/loader/cache/CachedImage.cpp
>+++ b/Source/WebCore/loader/cache/CachedImage.cpp
>@@ -468,9 +468,9 @@ inline void CachedImage::clearImage()
>     m_updateImageDataCount = 0;
> }
> 
>-void CachedImage::updateBufferInternal(SharedBuffer& data)
>+void CachedImage::updateBufferInternal(const FragmentedSharedBuffer& data)
> {
>-    m_data = &data;
>+    m_data = data.makeContiguous();
>     setEncodedSize(m_data->size());
>     createImage();
> 
>@@ -523,12 +523,14 @@ bool CachedImage::shouldDeferUpdateImageData() const
>     return (MonotonicTime::now() - m_lastUpdateImageDataTime).seconds() < updateImageDataBackoffIntervals[interval];
> }
> 
>-RefPtr<SharedBuffer> CachedImage::convertedDataIfNeeded(SharedBuffer* data) const
>+RefPtr<SharedBuffer> CachedImage::convertedDataIfNeeded(const FragmentedSharedBuffer* data) const
> {
>-    if (!data || !isPostScriptResource())
>-        return data;
>+    if (!data)
>+        return nullptr;
>+    if (!isPostScriptResource())
>+        return data->makeContiguous();
> #if PLATFORM(MAC) && !USE(WEBKIT_IMAGE_DECODERS)
>-    return SharedBuffer::create(PDFDocumentImage::convertPostScriptDataToPDF(data->createCFData()).get());
>+    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();
>@@ -553,7 +555,7 @@ EncodedDataStatus CachedImage::updateImageData(bool allDataReceived)
>     return result;
> }
> 
>-void CachedImage::updateBuffer(SharedBuffer& data)
>+void CachedImage::updateBuffer(const FragmentedSharedBuffer& data)
> {
>     ASSERT(dataBufferingPolicy() == DataBufferingPolicy::BufferData);
>     updateBufferInternal(data);
>@@ -567,7 +569,7 @@ void CachedImage::updateData(const uint8_t* data, unsigned length)
>     CachedResource::updateData(data, length);
> }
> 
>-void CachedImage::finishLoading(SharedBuffer* data, const NetworkLoadMetrics& metrics)
>+void CachedImage::finishLoading(const FragmentedSharedBuffer* data, const NetworkLoadMetrics& metrics)
> {
>     m_data = convertedDataIfNeeded(data);
>     if (m_data) {
>@@ -593,7 +595,7 @@ void CachedImage::finishLoading(SharedBuffer* data, const NetworkLoadMetrics& me
> void CachedImage::didReplaceSharedBufferContents()
> {
>     if (m_image) {
>-        // Let the Image know that the SharedBuffer has been rejigged, so it can let go of any references to the heap-allocated resource buffer.
>+        // 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);
>     }
>diff --git a/Source/WebCore/loader/cache/CachedImage.h b/Source/WebCore/loader/cache/CachedImage.h
>index e38962a0dcaf..083f92f88827 100644
>--- a/Source/WebCore/loader/cache/CachedImage.h
>+++ b/Source/WebCore/loader/cache/CachedImage.h
>@@ -69,8 +69,8 @@ public:
>     bool imageHasRelativeWidth() const { return m_image && m_image->hasRelativeWidth(); }
>     bool imageHasRelativeHeight() const { return m_image && m_image->hasRelativeHeight(); }
> 
>-    void updateBuffer(SharedBuffer&) override;
>-    void finishLoading(SharedBuffer*, const NetworkLoadMetrics&) override;
>+    void updateBuffer(const FragmentedSharedBuffer&) override;
>+    void finishLoading(const FragmentedSharedBuffer*, const NetworkLoadMetrics&) override;
> 
>     enum SizeType {
>         UsedSize,
>@@ -125,7 +125,7 @@ private:
>     void destroyDecodedData() override;
> 
>     bool shouldDeferUpdateImageData() const;
>-    RefPtr<SharedBuffer> convertedDataIfNeeded(SharedBuffer* data) const;
>+    RefPtr<SharedBuffer> convertedDataIfNeeded(const FragmentedSharedBuffer* data) const;
>     void didUpdateImageData();
>     EncodedDataStatus updateImageData(bool allDataReceived);
>     void updateData(const uint8_t* data, unsigned length) override;
>@@ -169,7 +169,7 @@ private:
>     void changedInRect(const Image&, const IntRect*);
>     void scheduleRenderingUpdate(const Image&);
> 
>-    void updateBufferInternal(SharedBuffer&);
>+    void updateBufferInternal(const FragmentedSharedBuffer&);
> 
>     void didReplaceSharedBufferContents() override;
> 
>diff --git a/Source/WebCore/loader/cache/CachedRawResource.cpp b/Source/WebCore/loader/cache/CachedRawResource.cpp
>index 92b083697588..895db1158b6b 100644
>--- a/Source/WebCore/loader/cache/CachedRawResource.cpp
>+++ b/Source/WebCore/loader/cache/CachedRawResource.cpp
>@@ -48,7 +48,7 @@ CachedRawResource::CachedRawResource(CachedResourceRequest&& request, Type type,
>     ASSERT(isMainOrMediaOrIconOrRawResource());
> }
> 
>-std::optional<SharedBufferDataView> CachedRawResource::calculateIncrementalDataChunk(const SharedBuffer* data) const
>+std::optional<SharedBufferDataView> CachedRawResource::calculateIncrementalDataChunk(const FragmentedSharedBuffer* data) const
> {
>     size_t previousDataLength = encodedSize();
>     if (!data || data->size() <= previousDataLength)
>@@ -56,7 +56,7 @@ std::optional<SharedBufferDataView> CachedRawResource::calculateIncrementalDataC
>     return data->getSomeData(previousDataLength);
> }
> 
>-void CachedRawResource::updateBuffer(SharedBuffer& data)
>+void CachedRawResource::updateBuffer(const FragmentedSharedBuffer& data)
> {
>     // Skip any updateBuffers triggered from nested runloops. We'll have the complete buffer in finishLoading.
>     if (m_inIncrementalDataNotify)
>@@ -64,7 +64,7 @@ void CachedRawResource::updateBuffer(SharedBuffer& data)
> 
>     CachedResourceHandle<CachedRawResource> protectedThis(this);
>     ASSERT(dataBufferingPolicy() == DataBufferingPolicy::BufferData);
>-    m_data = &data;
>+    m_data = data.makeContiguous();
> 
>     auto previousDataSize = encodedSize();
>     while (data.size() > previousDataSize) {
>@@ -96,7 +96,7 @@ void CachedRawResource::updateData(const uint8_t* data, unsigned length)
>     CachedResource::updateData(data, length);
> }
> 
>-void CachedRawResource::finishLoading(SharedBuffer* data, const NetworkLoadMetrics& metrics)
>+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.
>@@ -107,12 +107,14 @@ void CachedRawResource::finishLoading(SharedBuffer* data, const NetworkLoadMetri
>     CachedResourceHandle<CachedRawResource> protectedThis(this);
>     DataBufferingPolicy dataBufferingPolicy = this->dataBufferingPolicy();
>     if (dataBufferingPolicy == DataBufferingPolicy::BufferData) {
>-        m_data = data;
>-
>-        if (auto incrementalData = calculateIncrementalDataChunk(data)) {
>-            setEncodedSize(data->size());
>-            notifyClientsDataWasReceived(incrementalData->data(), incrementalData->size());
>-        }
>+        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)
>diff --git a/Source/WebCore/loader/cache/CachedRawResource.h b/Source/WebCore/loader/cache/CachedRawResource.h
>index 84e0d844d571..a7865f8ad178 100644
>--- a/Source/WebCore/loader/cache/CachedRawResource.h
>+++ b/Source/WebCore/loader/cache/CachedRawResource.h
>@@ -51,9 +51,9 @@ public:
> 
> private:
>     void didAddClient(CachedResourceClient&) final;
>-    void updateBuffer(SharedBuffer&) final;
>+    void updateBuffer(const FragmentedSharedBuffer&) final;
>     void updateData(const uint8_t* data, unsigned length) final;
>-    void finishLoading(SharedBuffer*, const NetworkLoadMetrics&) final;
>+    void finishLoading(const FragmentedSharedBuffer*, const NetworkLoadMetrics&) final;
> 
>     bool shouldIgnoreHTTPStatusCodeErrors() const override { return true; }
>     void allClientsRemoved() override;
>@@ -66,7 +66,7 @@ private:
>     void switchClientsToRevalidatedResource() override;
>     bool mayTryReplaceEncodedData() const override { return m_allowEncodedDataReplacement; }
> 
>-    std::optional<SharedBufferDataView> calculateIncrementalDataChunk(const SharedBuffer*) const;
>+    std::optional<SharedBufferDataView> calculateIncrementalDataChunk(const FragmentedSharedBuffer*) const;
>     void notifyClientsDataWasReceived(const uint8_t* data, unsigned length);
>     
> #if USE(QUICK_LOOK)
>@@ -92,7 +92,7 @@ private:
>     Vector<RedirectPair, 0, CrashOnOverflow, 0> m_redirectChain;
> 
>     struct DelayedFinishLoading {
>-        RefPtr<SharedBuffer> buffer;
>+        RefPtr<const FragmentedSharedBuffer> buffer;
>     };
>     std::optional<DelayedFinishLoading> m_delayedFinishLoading;
> };
>diff --git a/Source/WebCore/loader/cache/CachedResource.cpp b/Source/WebCore/loader/cache/CachedResource.cpp
>index 3e446fb9174f..9de0a04cd5ec 100644
>--- a/Source/WebCore/loader/cache/CachedResource.cpp
>+++ b/Source/WebCore/loader/cache/CachedResource.cpp
>@@ -336,7 +336,7 @@ void CachedResource::checkNotify(const NetworkLoadMetrics& metrics)
>         client->notifyFinished(*this, metrics);
> }
> 
>-void CachedResource::updateBuffer(SharedBuffer&)
>+void CachedResource::updateBuffer(const FragmentedSharedBuffer&)
> {
>     ASSERT(dataBufferingPolicy() == DataBufferingPolicy::BufferData);
> }
>@@ -346,7 +346,7 @@ void CachedResource::updateData(const uint8_t*, unsigned)
>     ASSERT(dataBufferingPolicy() == DataBufferingPolicy::DoNotBufferData);
> }
> 
>-void CachedResource::finishLoading(SharedBuffer*, const NetworkLoadMetrics& metrics)
>+void CachedResource::finishLoading(const FragmentedSharedBuffer*, const NetworkLoadMetrics& metrics)
> {
>     setLoading(false);
>     checkNotify(metrics);
>@@ -929,8 +929,7 @@ void CachedResource::tryReplaceEncodedData(SharedBuffer& newBuffer)
>     if (*m_data != newBuffer)
>         return;
> 
>-    m_data->clear();
>-    m_data->append(newBuffer);
>+    m_data = Ref { newBuffer };
>     didReplaceSharedBufferContents();
> }
> 
>diff --git a/Source/WebCore/loader/cache/CachedResource.h b/Source/WebCore/loader/cache/CachedResource.h
>index 396002832cc1..c982dd6937a0 100644
>--- a/Source/WebCore/loader/cache/CachedResource.h
>+++ b/Source/WebCore/loader/cache/CachedResource.h
>@@ -49,7 +49,7 @@ class CookieJar;
> class MemoryCache;
> class NetworkLoadMetrics;
> class SecurityOrigin;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> class SubresourceLoader;
> class TextResourceDecoder;
> 
>@@ -112,9 +112,9 @@ public:
>     virtual void setEncoding(const String&) { }
>     virtual String encoding() const { return String(); }
>     virtual const TextResourceDecoder* textResourceDecoder() const { return nullptr; }
>-    virtual void updateBuffer(SharedBuffer&);
>+    virtual void updateBuffer(const FragmentedSharedBuffer&);
>     virtual void updateData(const uint8_t* data, unsigned length);
>-    virtual void finishLoading(SharedBuffer*, const NetworkLoadMetrics&);
>+    virtual void finishLoading(const FragmentedSharedBuffer*, const NetworkLoadMetrics&);
>     virtual void error(CachedResource::Status);
> 
>     void setResourceError(const ResourceError& error) { m_error = error; }
>diff --git a/Source/WebCore/loader/cache/CachedSVGDocument.cpp b/Source/WebCore/loader/cache/CachedSVGDocument.cpp
>index 7da14851a707..db431607ae56 100644
>--- a/Source/WebCore/loader/cache/CachedSVGDocument.cpp
>+++ b/Source/WebCore/loader/cache/CachedSVGDocument.cpp
>@@ -52,12 +52,12 @@ String CachedSVGDocument::encoding() const
>     return m_decoder->encoding().name();
> }
> 
>-void CachedSVGDocument::finishLoading(SharedBuffer* data, const NetworkLoadMetrics& metrics)
>+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->data(), data->size()));
>+        m_document->setContent(m_decoder->decodeAndFlush(data->makeContiguous()->data(), data->size()));
>     }
>     CachedResource::finishLoading(data, metrics);
> }
>diff --git a/Source/WebCore/loader/cache/CachedSVGDocument.h b/Source/WebCore/loader/cache/CachedSVGDocument.h
>index e8c15f360fc9..445e4f9f42c3 100644
>--- a/Source/WebCore/loader/cache/CachedSVGDocument.h
>+++ b/Source/WebCore/loader/cache/CachedSVGDocument.h
>@@ -43,7 +43,7 @@ private:
>     void setEncoding(const String&) override;
>     String encoding() const override;
>     const TextResourceDecoder* textResourceDecoder() const override { return m_decoder.get(); }
>-    void finishLoading(SharedBuffer*, const NetworkLoadMetrics&) override;
>+    void finishLoading(const FragmentedSharedBuffer*, const NetworkLoadMetrics&) override;
> 
>     RefPtr<SVGDocument> m_document;
>     RefPtr<TextResourceDecoder> m_decoder;
>diff --git a/Source/WebCore/loader/cache/CachedSVGFont.cpp b/Source/WebCore/loader/cache/CachedSVGFont.cpp
>index a8ef576bb693..d2c1de47efb7 100644
>--- a/Source/WebCore/loader/cache/CachedSVGFont.cpp
>+++ b/Source/WebCore/loader/cache/CachedSVGFont.cpp
>@@ -80,7 +80,7 @@ bool CachedSVGFont::ensureCustomFontData(const AtomString& remoteURI)
> 
>             ScriptDisallowedScope::DisableAssertionsInScope disabledScope;
> 
>-            m_externalSVGDocument->setContent(decoder->decodeAndFlush(m_data->data(), m_data->size()));
>+            m_externalSVGDocument->setContent(decoder->decodeAndFlush(m_data->makeContiguous()->data(), m_data->size()));
>             sawError = decoder->sawError();
>         }
> 
>diff --git a/Source/WebCore/loader/cache/CachedScript.cpp b/Source/WebCore/loader/cache/CachedScript.cpp
>index 54e676ce50b0..62a16e86b321 100644
>--- a/Source/WebCore/loader/cache/CachedScript.cpp
>+++ b/Source/WebCore/loader/cache/CachedScript.cpp
>@@ -96,10 +96,15 @@ unsigned CachedScript::scriptHash()
>     return m_scriptHash;
> }
> 
>-void CachedScript::finishLoading(SharedBuffer* data, const NetworkLoadMetrics& metrics)
>+void CachedScript::finishLoading(const FragmentedSharedBuffer* data, const NetworkLoadMetrics& metrics)
> {
>-    m_data = data;
>-    setEncodedSize(data ? data->size() : 0);
>+    if (data) {
>+        m_data = data->makeContiguous();
>+        setEncodedSize(data->size());
>+    } else {
>+        m_data = nullptr;
>+        setEncodedSize(0);
>+    }
>     CachedResource::finishLoading(data, metrics);
> }
> 
>diff --git a/Source/WebCore/loader/cache/CachedScript.h b/Source/WebCore/loader/cache/CachedScript.h
>index 924b84ca2d87..8651e639ad90 100644
>--- a/Source/WebCore/loader/cache/CachedScript.h
>+++ b/Source/WebCore/loader/cache/CachedScript.h
>@@ -47,7 +47,7 @@ private:
>     void setEncoding(const String&) final;
>     String encoding() const final;
>     const TextResourceDecoder* textResourceDecoder() const final { return m_decoder.get(); }
>-    void finishLoading(SharedBuffer*, const NetworkLoadMetrics&) final;
>+    void finishLoading(const FragmentedSharedBuffer*, const NetworkLoadMetrics&) final;
> 
>     void destroyDecodedData() final;
> 
>diff --git a/Source/WebCore/loader/cache/CachedTextTrack.cpp b/Source/WebCore/loader/cache/CachedTextTrack.cpp
>index 122981503128..0c8428bb99db 100644
>--- a/Source/WebCore/loader/cache/CachedTextTrack.cpp
>+++ b/Source/WebCore/loader/cache/CachedTextTrack.cpp
>@@ -40,10 +40,10 @@ CachedTextTrack::CachedTextTrack(CachedResourceRequest&& request, PAL::SessionID
> {
> }
> 
>-void CachedTextTrack::doUpdateBuffer(SharedBuffer* data)
>+void CachedTextTrack::doUpdateBuffer(const FragmentedSharedBuffer* data)
> {
>     ASSERT(dataBufferingPolicy() == DataBufferingPolicy::BufferData);
>-    m_data = data;
>+    m_data = data ? data->makeContiguous() : RefPtr<SharedBuffer>();
>     setEncodedSize(data ? data->size() : 0);
> 
>     CachedResourceClientWalker<CachedResourceClient> walker(m_clients);
>@@ -51,13 +51,13 @@ void CachedTextTrack::doUpdateBuffer(SharedBuffer* data)
>         client->deprecatedDidReceiveCachedResource(*this);
> }
> 
>-void CachedTextTrack::updateBuffer(SharedBuffer& data)
>+void CachedTextTrack::updateBuffer(const FragmentedSharedBuffer& data)
> {
>     doUpdateBuffer(&data);
>     CachedResource::updateBuffer(data);
> }
> 
>-void CachedTextTrack::finishLoading(SharedBuffer* data, const NetworkLoadMetrics& metrics)
>+void CachedTextTrack::finishLoading(const FragmentedSharedBuffer* data, const NetworkLoadMetrics& metrics)
> {
>     doUpdateBuffer(data);
>     CachedResource::finishLoading(data, metrics);
>diff --git a/Source/WebCore/loader/cache/CachedTextTrack.h b/Source/WebCore/loader/cache/CachedTextTrack.h
>index 85e396206513..09b4339a37b6 100644
>--- a/Source/WebCore/loader/cache/CachedTextTrack.h
>+++ b/Source/WebCore/loader/cache/CachedTextTrack.h
>@@ -35,10 +35,10 @@ public:
> 
> private:
>     bool mayTryReplaceEncodedData() const override { return true; }
>-    void updateBuffer(SharedBuffer&) override;
>-    void finishLoading(SharedBuffer*, const NetworkLoadMetrics&) override;
>+    void updateBuffer(const FragmentedSharedBuffer&) override;
>+    void finishLoading(const FragmentedSharedBuffer*, const NetworkLoadMetrics&) override;
> 
>-    void doUpdateBuffer(SharedBuffer*);
>+    void doUpdateBuffer(const FragmentedSharedBuffer*);
> };
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/loader/cache/CachedXSLStyleSheet.cpp b/Source/WebCore/loader/cache/CachedXSLStyleSheet.cpp
>index e3e2f5e96487..d2eff2d2d40c 100644
>--- a/Source/WebCore/loader/cache/CachedXSLStyleSheet.cpp
>+++ b/Source/WebCore/loader/cache/CachedXSLStyleSheet.cpp
>@@ -61,12 +61,16 @@ String CachedXSLStyleSheet::encoding() const
>     return m_decoder->encoding().name();
> }
> 
>-void CachedXSLStyleSheet::finishLoading(SharedBuffer* data, const NetworkLoadMetrics& metrics)
>+void CachedXSLStyleSheet::finishLoading(const FragmentedSharedBuffer* data, const NetworkLoadMetrics& metrics)
> {
>-    m_data = data;
>-    setEncodedSize(data ? data->size() : 0);
>-    if (data)
>-        m_sheet = m_decoder->decodeAndFlush(data->data(), encodedSize());
>+    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);
> }
>diff --git a/Source/WebCore/loader/cache/CachedXSLStyleSheet.h b/Source/WebCore/loader/cache/CachedXSLStyleSheet.h
>index 6842b644f61c..bd231214f2d2 100644
>--- a/Source/WebCore/loader/cache/CachedXSLStyleSheet.h
>+++ b/Source/WebCore/loader/cache/CachedXSLStyleSheet.h
>@@ -47,7 +47,7 @@ private:
>     void setEncoding(const String&) final;
>     String encoding() const final;
>     const TextResourceDecoder* textResourceDecoder() const final { return m_decoder.get(); }
>-    void finishLoading(SharedBuffer*, const NetworkLoadMetrics&) final;
>+    void finishLoading(const FragmentedSharedBuffer*, const NetworkLoadMetrics&) final;
> 
>     String m_sheet;
>     RefPtr<TextResourceDecoder> m_decoder;
>diff --git a/Source/WebCore/loader/ios/LegacyPreviewLoader.h b/Source/WebCore/loader/ios/LegacyPreviewLoader.h
>index 552561d6c816..96d8982e9350 100644
>--- a/Source/WebCore/loader/ios/LegacyPreviewLoader.h
>+++ b/Source/WebCore/loader/ios/LegacyPreviewLoader.h
>@@ -27,6 +27,7 @@
> 
> #include "PreviewConverterClient.h"
> #include "PreviewConverterProvider.h"
>+#include "SharedBuffer.h"
> #include <wtf/Forward.h>
> #include <wtf/Noncopyable.h>
> #include <wtf/RetainPtr.h>
>@@ -37,7 +38,6 @@ namespace WebCore {
> class LegacyPreviewLoaderClient;
> class ResourceLoader;
> class ResourceResponse;
>-class SharedBuffer;
> 
> class LegacyPreviewLoader final : private PreviewConverterClient, private PreviewConverterProvider {
>     WTF_MAKE_FAST_ALLOCATED;
>@@ -48,7 +48,7 @@ public:
> 
>     bool didReceiveResponse(const ResourceResponse&);
>     bool didReceiveData(const uint8_t* data, unsigned length);
>-    bool didReceiveBuffer(const SharedBuffer&);
>+    bool didReceiveBuffer(const FragmentedSharedBuffer&);
>     bool didFinishLoading();
>     void didFail();
> 
>@@ -60,17 +60,17 @@ private:
>     void previewConverterDidFinishUpdating(PreviewConverter&) final { };
>     void previewConverterDidFailUpdating(PreviewConverter&) final;
>     void previewConverterDidStartConverting(PreviewConverter&) final;
>-    void previewConverterDidReceiveData(PreviewConverter&, const SharedBuffer&) final;
>+    void previewConverterDidReceiveData(PreviewConverter&, const FragmentedSharedBuffer&) final;
>     void previewConverterDidFinishConverting(PreviewConverter&) final;
>     void previewConverterDidFailConverting(PreviewConverter&) final;
> 
>     // PreviewConverterProvider
>-    void provideMainResourceForPreviewConverter(PreviewConverter&, CompletionHandler<void(const SharedBuffer*)>&&) final;
>+    void provideMainResourceForPreviewConverter(PreviewConverter&, CompletionHandler<void(Ref<FragmentedSharedBuffer>&&)>&&) final;
>     void providePasswordForPreviewConverter(PreviewConverter&, CompletionHandler<void(const String&)>&&) final;
> 
>     RefPtr<PreviewConverter> m_converter;
>     Ref<LegacyPreviewLoaderClient> m_client;
>-    Ref<SharedBuffer> m_originalData;
>+    SharedBufferBuilder m_originalData;
>     WeakPtr<ResourceLoader> m_resourceLoader;
>     bool m_finishedLoadingDataIntoConverter { false };
>     bool m_hasProcessedResponse { false };
>diff --git a/Source/WebCore/loader/ios/LegacyPreviewLoader.mm b/Source/WebCore/loader/ios/LegacyPreviewLoader.mm
>index d18b252e9756..48756a33b587 100644
>--- a/Source/WebCore/loader/ios/LegacyPreviewLoader.mm
>+++ b/Source/WebCore/loader/ios/LegacyPreviewLoader.mm
>@@ -63,13 +63,13 @@ static Ref<LegacyPreviewLoaderClient> makeClient(const ResourceLoader& loader, c
>     return emptyClient();
> }
> 
>-bool LegacyPreviewLoader::didReceiveBuffer(const SharedBuffer& buffer)
>+bool LegacyPreviewLoader::didReceiveBuffer(const FragmentedSharedBuffer& buffer)
> {
>     if (m_finishedLoadingDataIntoConverter)
>         return false;
> 
>     LOG(Network, "LegacyPreviewLoader appending buffer with size %ld.", buffer.size());
>-    m_originalData->append(buffer);
>+    m_originalData.append(buffer);
>     m_converter->updateMainResource();
>     m_client->didReceiveBuffer(buffer);
>     return true;
>@@ -109,7 +109,7 @@ void LegacyPreviewLoader::previewConverterDidStartConverting(PreviewConverter& c
>         return;
> 
>     ASSERT(!m_hasProcessedResponse);
>-    m_originalData->clear();
>+    m_originalData.reset();
>     resourceLoader->documentLoader()->setPreviewConverter(WTFMove(m_converter));
>     auto response { converter.previewResponse() };
> 
>@@ -147,7 +147,7 @@ void LegacyPreviewLoader::previewConverterDidStartConverting(PreviewConverter& c
>     });
> }
> 
>-void LegacyPreviewLoader::previewConverterDidReceiveData(PreviewConverter&, const SharedBuffer& data)
>+void LegacyPreviewLoader::previewConverterDidReceiveData(PreviewConverter&, const FragmentedSharedBuffer& data)
> {
>     auto resourceLoader = m_resourceLoader.get();
>     if (!resourceLoader)
>@@ -224,10 +224,10 @@ void LegacyPreviewLoader::providePasswordForPreviewConverter(PreviewConverter& c
>     m_client->didRequestPassword(WTFMove(completionHandler));
> }
> 
>-void LegacyPreviewLoader::provideMainResourceForPreviewConverter(PreviewConverter& converter, CompletionHandler<void(const SharedBuffer*)>&& completionHandler)
>+void LegacyPreviewLoader::provideMainResourceForPreviewConverter(PreviewConverter& converter, CompletionHandler<void(Ref<FragmentedSharedBuffer>&&)>&& completionHandler)
> {
>     ASSERT_UNUSED(converter, &converter == m_converter);
>-    completionHandler(m_originalData.ptr());
>+    completionHandler(m_originalData.copy());
> }
> 
> LegacyPreviewLoader::~LegacyPreviewLoader() = default;
>@@ -235,7 +235,6 @@ 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 { SharedBuffer::create() }
>     , m_resourceLoader { loader }
>     , m_shouldDecidePolicyBeforeLoading { loader.frame()->settings().shouldDecidePolicyBeforeLoadingQuickLookPreview() }
> {
>diff --git a/Source/WebCore/page/EditorClient.h b/Source/WebCore/page/EditorClient.h
>index 82374e7262c7..ea615dff4dd0 100644
>--- a/Source/WebCore/page/EditorClient.h
>+++ b/Source/WebCore/page/EditorClient.h
>@@ -38,12 +38,13 @@ namespace WebCore {
> 
> enum class DOMPasteAccessResponse : uint8_t;
> 
>+class SharedBuffer;
> class DocumentFragment;
> class Element;
> class Frame;
> class KeyboardEvent;
> class Node;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> class StyleProperties;
> class TextCheckerClient;
> class VisibleSelection;
>@@ -78,7 +79,7 @@ public:
>     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<SharedBuffer>&&) { }
>+    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 */) { }
>diff --git a/Source/WebCore/page/PageSerializer.cpp b/Source/WebCore/page/PageSerializer.cpp
>index 165aa8058a03..02001ab34301 100644
>--- a/Source/WebCore/page/PageSerializer.cpp
>+++ b/Source/WebCore/page/PageSerializer.cpp
>@@ -273,7 +273,7 @@ void PageSerializer::addImageToResources(CachedImage* image, RenderElement* imag
>     if (!image || image->image() == &Image::nullImage())
>         return;
> 
>-    RefPtr<SharedBuffer> data = imageRenderer ? image->imageForRenderer(imageRenderer)->data() : 0;
>+    RefPtr<FragmentedSharedBuffer> data = imageRenderer ? image->imageForRenderer(imageRenderer)->data() : 0;
>     if (!data)
>         data = image->image()->data();
> 
>@@ -282,7 +282,7 @@ void PageSerializer::addImageToResources(CachedImage* image, RenderElement* imag
>         return;
>     }
> 
>-    m_resources.append({ url, image->response().mimeType(), WTFMove(data) });
>+    m_resources.append({ url, image->response().mimeType(), data->makeContiguous() });
>     m_resourceURLs.add(url);
> }
> 
>diff --git a/Source/WebCore/page/ShareDataReader.cpp b/Source/WebCore/page/ShareDataReader.cpp
>index 96ad082543dd..75836b879143 100644
>--- a/Source/WebCore/page/ShareDataReader.cpp
>+++ b/Source/WebCore/page/ShareDataReader.cpp
>@@ -35,7 +35,7 @@ namespace WebCore {
> ShareDataReader::ShareDataReader(CompletionHandler<void(ExceptionOr<ShareDataWithParsedURL&>)>&& completionHandler)
>     : m_completionHandler(WTFMove(completionHandler))
> {
>-    
>+
> }
> 
> ShareDataReader::~ShareDataReader()
>@@ -71,15 +71,15 @@ void ShareDataReader::didFinishLoading(int loadIndex, const String& fileName)
>         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, { }))
>diff --git a/Source/WebCore/platform/NowPlayingManager.h b/Source/WebCore/platform/NowPlayingManager.h
>index e3806e87df79..fc66c365a2f2 100644
>--- a/Source/WebCore/platform/NowPlayingManager.h
>+++ b/Source/WebCore/platform/NowPlayingManager.h
>@@ -70,7 +70,7 @@ private:
>     std::optional<NowPlayingInfo> m_nowPlayingInfo;
>     struct ArtworkCache {
>         String src;
>-        RefPtr<SharedBuffer> imageData;
>+        RefPtr<FragmentedSharedBuffer> imageData;
>     };
>     std::optional<ArtworkCache> m_nowPlayingInfoArtwork;
>     bool m_setAsNowPlayingApplication { false };
>diff --git a/Source/WebCore/platform/Pasteboard.cpp b/Source/WebCore/platform/Pasteboard.cpp
>index 15731eb23fa7..07ed48e5884e 100644
>--- a/Source/WebCore/platform/Pasteboard.cpp
>+++ b/Source/WebCore/platform/Pasteboard.cpp
>@@ -89,7 +89,7 @@ String Pasteboard::readString(size_t index, const String& type)
>     return { };
> }
> 
>-RefPtr<WebCore::SharedBuffer> Pasteboard::readBuffer(size_t index, const String& type)
>+RefPtr<WebCore::FragmentedSharedBuffer> Pasteboard::readBuffer(size_t index, const String& type)
> {
>     if (auto* strategy = platformStrategies()->pasteboardStrategy())
>         return strategy->readBufferFromPasteboard(index, type, name(), context());
>diff --git a/Source/WebCore/platform/Pasteboard.h b/Source/WebCore/platform/Pasteboard.h
>index 7d247dcd1a16..35763ee12a39 100644
>--- a/Source/WebCore/platform/Pasteboard.h
>+++ b/Source/WebCore/platform/Pasteboard.h
>@@ -61,12 +61,13 @@ typedef struct HWND__* HWND;
> 
> namespace WebCore {
> 
>+class SharedBuffer;
> class DocumentFragment;
> class DragData;
> class Element;
> class Frame;
> class PasteboardStrategy;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> struct SimpleRange;
> 
>@@ -147,16 +148,16 @@ public:
>     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<SharedBuffer>&&, const String& type, PresentationSize preferredPresentationSize = { }) = 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(SharedBuffer&) = 0;
>-    virtual bool readRTFD(SharedBuffer&) = 0;
>-    virtual bool readRTF(SharedBuffer&) = 0;
>-    virtual bool readDataBuffer(SharedBuffer&, const String& type, const String& name, PresentationSize preferredPresentationSize = { }) = 0;
>+    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
> };
> 
>@@ -171,7 +172,7 @@ struct PasteboardFileReader {
>     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<SharedBuffer>&&) = 0;
>+    virtual void readBuffer(const String& filename, const String& type, Ref<FragmentedSharedBuffer>&&) = 0;
> };
> 
> class Pasteboard {
>@@ -296,7 +297,7 @@ public:
>     std::optional<PasteboardItemInfo> pasteboardItemInfo(size_t index) const;
> 
>     String readString(size_t index, const String& type);
>-    RefPtr<WebCore::SharedBuffer> readBuffer(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(); }
>diff --git a/Source/WebCore/platform/PasteboardCustomData.cpp b/Source/WebCore/platform/PasteboardCustomData.cpp
>index 9d3f87a9114c..7b4b3d36aa68 100644
>--- a/Source/WebCore/platform/PasteboardCustomData.cpp
>+++ b/Source/WebCore/platform/PasteboardCustomData.cpp
>@@ -33,13 +33,13 @@
> 
> namespace WebCore {
> 
>-static std::variant<String, Ref<SharedBuffer>> copyPlatformData(const std::variant<String, Ref<SharedBuffer>>& other)
>+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<SharedBuffer>>(other))
>-        return { std::get<Ref<SharedBuffer>>(other).copyRef() };
>+    if (std::holds_alternative<Ref<FragmentedSharedBuffer>>(other))
>+        return { std::get<Ref<FragmentedSharedBuffer>>(other).copyRef() };
> 
>     return { };
> }
>@@ -134,7 +134,7 @@ void PasteboardCustomData::writeString(const String& type, const String& value)
>     addOrMoveEntryToEnd(type).platformData = { value };
> }
> 
>-void PasteboardCustomData::writeData(const String& type, Ref<SharedBuffer>&& data)
>+void PasteboardCustomData::writeData(const String& type, Ref<FragmentedSharedBuffer>&& data)
> {
>     addOrMoveEntryToEnd(type).platformData = { WTFMove(data) };
> }
>@@ -202,14 +202,14 @@ HashMap<String, String> PasteboardCustomData::sameOriginCustomStringData() const
>     return customData;
> }
> 
>-RefPtr<SharedBuffer> PasteboardCustomData::readBuffer(const String& type) const
>+RefPtr<FragmentedSharedBuffer> PasteboardCustomData::readBuffer(const String& type) const
> {
>     for (auto& entry : m_data) {
>         if (entry.type != type)
>             continue;
> 
>-        if (std::holds_alternative<Ref<SharedBuffer>>(entry.platformData))
>-            return std::get<Ref<SharedBuffer>>(entry.platformData).copyRef();
>+        if (std::holds_alternative<Ref<FragmentedSharedBuffer>>(entry.platformData))
>+            return std::get<Ref<FragmentedSharedBuffer>>(entry.platformData).copyRef();
> 
>         return nullptr;
>     }
>@@ -265,11 +265,11 @@ void PasteboardCustomData::forEachCustomString(Function<void(const String& type,
>     }
> }
> 
>-void PasteboardCustomData::forEachPlatformStringOrBuffer(Function<void(const String& type, const std::variant<String, Ref<SharedBuffer>>& data)>&& function) const
>+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<SharedBuffer>>(data))
>+        if ((std::holds_alternative<String>(data) && !std::get<String>(data).isNull()) || std::holds_alternative<Ref<FragmentedSharedBuffer>>(data))
>             function(entry.type, data);
>     }
> }
>diff --git a/Source/WebCore/platform/PasteboardCustomData.h b/Source/WebCore/platform/PasteboardCustomData.h
>index 2be81d2938a3..97ff985e24e1 100644
>--- a/Source/WebCore/platform/PasteboardCustomData.h
>+++ b/Source/WebCore/platform/PasteboardCustomData.h
>@@ -35,6 +35,7 @@
> namespace WebCore {
> 
> class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class PasteboardCustomData {
> public:
>@@ -48,7 +49,7 @@ public:
> 
>         String type;
>         String customData;
>-        std::variant<String, Ref<SharedBuffer>> platformData;
>+        std::variant<String, Ref<FragmentedSharedBuffer>> platformData;
>     };
> 
>     WEBCORE_EXPORT PasteboardCustomData();
>@@ -65,11 +66,11 @@ public:
>     WEBCORE_EXPORT static PasteboardCustomData fromPersistenceDecoder(WTF::Persistence::Decoder&&);
> 
>     String readString(const String& type) const;
>-    RefPtr<SharedBuffer> readBuffer(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<SharedBuffer>&& data);
>+    void writeData(const String& type, Ref<FragmentedSharedBuffer>&& data);
>     void writeStringInCustomData(const String& type, const String& value);
> 
>     void clear();
>@@ -83,7 +84,7 @@ public:
> 
>     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<SharedBuffer>>& 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;
>diff --git a/Source/WebCore/platform/PasteboardStrategy.h b/Source/WebCore/platform/PasteboardStrategy.h
>index 1c0726feb3e0..c41e08524496 100644
>--- a/Source/WebCore/platform/PasteboardStrategy.h
>+++ b/Source/WebCore/platform/PasteboardStrategy.h
>@@ -31,10 +31,11 @@
> namespace WebCore {
> 
> class Color;
>+class SharedBuffer;
> class PasteboardContext;
> class PasteboardCustomData;
> class SelectionData;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> struct PasteboardImage;
> struct PasteboardItemInfo;
> struct PasteboardURL;
>@@ -62,7 +63,7 @@ public:
> 
>     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(SharedBuffer*, const String& pasteboardType, 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;
>diff --git a/Source/WebCore/platform/PlatformContentFilter.h b/Source/WebCore/platform/PlatformContentFilter.h
>index 3f4832a5a658..9e72e44a2eac 100644
>--- a/Source/WebCore/platform/PlatformContentFilter.h
>+++ b/Source/WebCore/platform/PlatformContentFilter.h
>@@ -34,7 +34,7 @@ namespace WebCore {
> class ContentFilterUnblockHandler;
> class ResourceRequest;
> class ResourceResponse;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class PlatformContentFilter {
>     WTF_MAKE_FAST_ALLOCATED;
>@@ -56,7 +56,7 @@ public:
>     virtual void responseReceived(const ResourceResponse&) = 0;
>     virtual void addData(const uint8_t* data, int length) = 0;
>     virtual void finishedAddingData() = 0;
>-    virtual Ref<SharedBuffer> replacementData() const = 0;
>+    virtual Ref<FragmentedSharedBuffer> replacementData() const = 0;
> #if ENABLE(CONTENT_FILTERING)
>     virtual ContentFilterUnblockHandler unblockHandler() const = 0;
> #endif
>diff --git a/Source/WebCore/platform/PlatformPasteboard.h b/Source/WebCore/platform/PlatformPasteboard.h
>index 7a2a31007425..71dfb93e5756 100644
>--- a/Source/WebCore/platform/PlatformPasteboard.h
>+++ b/Source/WebCore/platform/PlatformPasteboard.h
>@@ -47,13 +47,14 @@ struct wpe_pasteboard;
> 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:
>@@ -85,7 +86,7 @@ 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(SharedBuffer*, const String& pasteboardType);
>+    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);
>diff --git a/Source/WebCore/platform/PreviewConverter.cpp b/Source/WebCore/platform/PreviewConverter.cpp
>index 4cb3301e7df7..2abacf3ef499 100644
>--- a/Source/WebCore/platform/PreviewConverter.cpp
>+++ b/Source/WebCore/platform/PreviewConverter.cpp
>@@ -30,7 +30,6 @@
> 
> #include "PreviewConverterClient.h"
> #include "PreviewConverterProvider.h"
>-#include "SharedBuffer.h"
> #include <wtf/RunLoop.h>
> #include <wtf/SetForScope.h>
> 
>@@ -63,9 +62,9 @@ const ResourceError& PreviewConverter::previewError() const
>     return m_previewError;
> }
> 
>-const SharedBuffer& PreviewConverter::previewData() const
>+const FragmentedSharedBuffer& PreviewConverter::previewData() const
> {
>-    return m_previewData.get();
>+    return *m_previewData.get();
> }
> 
> void PreviewConverter::updateMainResource()
>@@ -82,15 +81,12 @@ void PreviewConverter::updateMainResource()
>         return;
>     }
> 
>-    provider->provideMainResourceForPreviewConverter(*this, [this, protectedThis = Ref { *this }](auto buffer) {
>-        if (buffer)
>-            appendFromBuffer(*buffer);
>-        else
>-            didFailUpdating();
>+    provider->provideMainResourceForPreviewConverter(*this, [this, protectedThis = Ref { *this }](auto&& buffer) {
>+        appendFromBuffer(WTFMove(buffer));
>     });
> }
> 
>-void PreviewConverter::appendFromBuffer(const SharedBuffer& buffer)
>+void PreviewConverter::appendFromBuffer(const FragmentedSharedBuffer& buffer)
> {
>     while (buffer.size() > m_lengthAppended) {
>         auto newData = buffer.getSomeData(m_lengthAppended);
>@@ -221,8 +217,8 @@ void PreviewConverter::replayToClient(PreviewConverterClient& client)
>     ASSERT(m_state >= State::Converting);
>     client.previewConverterDidStartConverting(*this);
> 
>-    if (!m_previewData->isEmpty() && hasClient(client))
>-        client.previewConverterDidReceiveData(*this, m_previewData.get());
>+    if (!m_previewData.isEmpty() && hasClient(client))
>+        client.previewConverterDidReceiveData(*this, *m_previewData.get());
> 
>     if (m_state == State::Converting || !hasClient(client))
>         return;
>@@ -234,12 +230,12 @@ void PreviewConverter::replayToClient(PreviewConverterClient& client)
>     }
> 
>     ASSERT(m_state == State::FinishedConverting);
>-    ASSERT(!m_previewData->isEmpty());
>+    ASSERT(!m_previewData.isEmpty());
>     ASSERT(m_previewError.isNull());
>     client.previewConverterDidFinishConverting(*this);
> }
> 
>-void PreviewConverter::delegateDidReceiveData(const SharedBuffer& data)
>+void PreviewConverter::delegateDidReceiveData(const FragmentedSharedBuffer& data)
> {
>     auto protectedThis { Ref { *this } };
> 
>@@ -256,7 +252,7 @@ void PreviewConverter::delegateDidReceiveData(const SharedBuffer& data)
>     if (data.isEmpty())
>         return;
> 
>-    m_previewData->append(data);
>+    m_previewData.append(data);
> 
>     iterateClients([&](auto& client) {
>         client.previewConverterDidReceiveData(*this, data);
>diff --git a/Source/WebCore/platform/PreviewConverter.h b/Source/WebCore/platform/PreviewConverter.h
>index 2a372922799c..5aeda3b72f40 100644
>--- a/Source/WebCore/platform/PreviewConverter.h
>+++ b/Source/WebCore/platform/PreviewConverter.h
>@@ -29,6 +29,7 @@
> 
> #include "ResourceError.h"
> #include "ResourceResponse.h"
>+#include "SharedBuffer.h"
> #include <wtf/RefCounted.h>
> #include <wtf/RetainPtr.h>
> #include <wtf/WeakPtr.h>
>@@ -41,15 +42,13 @@ namespace WebCore {
> 
> class ResourceError;
> class ResourceRequest;
>-class SharedBuffer;
>-class SharedBufferDataView;
> struct PreviewConverterClient;
> struct PreviewConverterProvider;
> 
> struct PreviewPlatformDelegate : CanMakeWeakPtr<PreviewPlatformDelegate> {
>     virtual ~PreviewPlatformDelegate() = default;
> 
>-    virtual void delegateDidReceiveData(const SharedBuffer&) = 0;
>+    virtual void delegateDidReceiveData(const FragmentedSharedBuffer&) = 0;
>     virtual void delegateDidFinishLoading() = 0;
>     virtual void delegateDidFailWithError(const ResourceError&) = 0;
> };
>@@ -72,7 +71,7 @@ public:
>     WEBCORE_EXPORT String previewFileName() const;
>     WEBCORE_EXPORT String previewUTI() const;
>     const ResourceError& previewError() const;
>-    const SharedBuffer& previewData() const;
>+    const FragmentedSharedBuffer& previewData() const;
> 
>     void failedUpdating();
>     void finishUpdating();
>@@ -94,7 +93,7 @@ private:
>     bool isPlatformPasswordError(const ResourceError&) const;
> 
>     template<typename T> void iterateClients(T&& callback);
>-    void appendFromBuffer(const SharedBuffer&);
>+    void appendFromBuffer(const FragmentedSharedBuffer&);
>     void didAddClient(PreviewConverterClient&);
>     void didFailConvertingWithError(const ResourceError&);
>     void didFailUpdating();
>@@ -106,7 +105,7 @@ private:
>     void platformUnlockWithPassword(const String&);
> 
>     // PreviewPlatformDelegate
>-    void delegateDidReceiveData(const SharedBuffer&) final;
>+    void delegateDidReceiveData(const FragmentedSharedBuffer&) final;
>     void delegateDidFinishLoading() final;
>     void delegateDidFailWithError(const ResourceError&) final;
> 
>@@ -118,7 +117,7 @@ private:
>         FinishedConverting,
>     };
> 
>-    Ref<SharedBuffer> m_previewData;
>+    SharedBufferBuilder m_previewData;
>     ResourceError m_previewError;
>     ResourceResponse m_originalResponse;
>     State m_state { State::Updating };
>diff --git a/Source/WebCore/platform/PreviewConverterClient.h b/Source/WebCore/platform/PreviewConverterClient.h
>index 04ea3680692b..9cee93320b23 100644
>--- a/Source/WebCore/platform/PreviewConverterClient.h
>+++ b/Source/WebCore/platform/PreviewConverterClient.h
>@@ -33,7 +33,7 @@ namespace WebCore {
> 
> class PreviewConverter;
> class ResourceError;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> struct PreviewConverterClient : CanMakeWeakPtr<PreviewConverterClient> {
>     virtual ~PreviewConverterClient() = default;
>@@ -42,7 +42,7 @@ struct PreviewConverterClient : CanMakeWeakPtr<PreviewConverterClient> {
>     virtual void previewConverterDidFinishUpdating(PreviewConverter&) = 0;
>     virtual void previewConverterDidFailUpdating(PreviewConverter&) = 0;
>     virtual void previewConverterDidStartConverting(PreviewConverter&) = 0;
>-    virtual void previewConverterDidReceiveData(PreviewConverter&, const SharedBuffer& newData) = 0;
>+    virtual void previewConverterDidReceiveData(PreviewConverter&, const FragmentedSharedBuffer& newData) = 0;
>     virtual void previewConverterDidFinishConverting(PreviewConverter&) = 0;
>     virtual void previewConverterDidFailConverting(PreviewConverter&) = 0;
> };
>diff --git a/Source/WebCore/platform/PreviewConverterProvider.h b/Source/WebCore/platform/PreviewConverterProvider.h
>index 82786393fced..ab7004be931f 100644
>--- a/Source/WebCore/platform/PreviewConverterProvider.h
>+++ b/Source/WebCore/platform/PreviewConverterProvider.h
>@@ -32,7 +32,7 @@ namespace WebCore {
> struct PreviewConverterProvider : CanMakeWeakPtr<PreviewConverterProvider> {
>     virtual ~PreviewConverterProvider() = default;
> 
>-    virtual void provideMainResourceForPreviewConverter(PreviewConverter&, CompletionHandler<void(const SharedBuffer*)>&&) = 0;
>+    virtual void provideMainResourceForPreviewConverter(PreviewConverter&, CompletionHandler<void(Ref<FragmentedSharedBuffer>&&)>&&) = 0;
>     virtual void providePasswordForPreviewConverter(PreviewConverter&, CompletionHandler<void(const String&)>&&) = 0;
> };
> 
>diff --git a/Source/WebCore/platform/SharedBuffer.cpp b/Source/WebCore/platform/SharedBuffer.cpp
>index d8e68e337781..a33925d3ac24 100644
>--- a/Source/WebCore/platform/SharedBuffer.cpp
>+++ b/Source/WebCore/platform/SharedBuffer.cpp
>@@ -37,63 +37,69 @@
> 
> namespace WebCore {
> 
>-SharedBuffer::SharedBuffer(const uint8_t* data, size_t size)
>+Ref<FragmentedSharedBuffer> FragmentedSharedBuffer::create()
> {
>-    append(data, size);
>+    return adoptRef(*new FragmentedSharedBuffer);
> }
> 
>-SharedBuffer::SharedBuffer(const char* data, size_t size)
>+Ref<FragmentedSharedBuffer> FragmentedSharedBuffer::create(const uint8_t* data, size_t size)
> {
>-    append(reinterpret_cast<const uint8_t*>(data), size);
>+    return adoptRef(*new FragmentedSharedBuffer(data, size));
> }
> 
>-SharedBuffer::SharedBuffer(FileSystem::MappedFileData&& fileData)
>-    : m_size(fileData.size())
>+Ref<FragmentedSharedBuffer> FragmentedSharedBuffer::create(FileSystem::MappedFileData&& mappedFileData)
> {
>-    m_segments.append({0, DataSegment::create(WTFMove(fileData))});
>+    return adoptRef(*new FragmentedSharedBuffer(WTFMove(mappedFileData)));
> }
> 
>-SharedBuffer::SharedBuffer(DataSegment::Provider&& provider)
>-    : m_size(provider.size())
>+Ref<FragmentedSharedBuffer> FragmentedSharedBuffer::create(Ref<SharedBuffer>&& buffer)
> {
>-    m_segments.append({0, DataSegment::create(WTFMove(provider))});
>+    return adoptRef(*new FragmentedSharedBuffer(WTFMove(buffer)));
> }
> 
>-SharedBuffer::SharedBuffer(Vector<uint8_t>&& data)
>+Ref<FragmentedSharedBuffer> FragmentedSharedBuffer::create(Vector<uint8_t>&& vector)
> {
>-    append(WTFMove(data));
>+    return adoptRef(*new FragmentedSharedBuffer(WTFMove(vector)));
> }
> 
>-#if USE(GSTREAMER)
>-Ref<SharedBuffer> SharedBuffer::create(GstMappedOwnedBuffer& mappedBuffer)
>+Ref<FragmentedSharedBuffer> FragmentedSharedBuffer::create(DataSegment::Provider&& provider)
> {
>-    return adoptRef(*new SharedBuffer(mappedBuffer));
>+    return adoptRef(*new FragmentedSharedBuffer(WTFMove(provider)));
> }
> 
>-SharedBuffer::SharedBuffer(GstMappedOwnedBuffer& mappedBuffer)
>-    : m_size(mappedBuffer.size())
>+FragmentedSharedBuffer::FragmentedSharedBuffer() = default;
>+
>+FragmentedSharedBuffer::FragmentedSharedBuffer(FileSystem::MappedFileData&& fileData)
>+    : m_size(fileData.size())
> {
>-    m_segments.append({0, DataSegment::create(&mappedBuffer)});
>+    m_segments.append({ 0, DataSegment::create(WTFMove(fileData)) });
> }
>-#endif
> 
>-RefPtr<SharedBuffer> SharedBuffer::createWithContentsOfFile(const String& filePath, FileSystem::MappedFileMode mappedFileMode, MayUseFileMapping mayUseFileMapping)
>+FragmentedSharedBuffer::FragmentedSharedBuffer(DataSegment::Provider&& provider)
>+    : m_size(provider.size())
> {
>-    if (mayUseFileMapping == MayUseFileMapping::Yes) {
>-        bool mappingSuccess;
>-        FileSystem::MappedFileData mappedFileData(filePath, mappedFileMode, mappingSuccess);
>-        if (mappingSuccess)
>-            return adoptRef(new SharedBuffer(WTFMove(mappedFileData)));
>-    }
>-    return SharedBuffer::createFromReadingFile(filePath);
>+    m_segments.append({ 0, DataSegment::create(WTFMove(provider)) });
> }
> 
>-Ref<SharedBuffer> SharedBuffer::create(Vector<uint8_t>&& vector)
>+FragmentedSharedBuffer::FragmentedSharedBuffer(Ref<SharedBuffer>&& buffer)
> {
>-    return adoptRef(*new SharedBuffer(WTFMove(vector)));
>+    append(WTFMove(buffer));
> }
> 
>-static Vector<uint8_t> combineSegmentsData(const SharedBuffer::DataSegmentVector& segments, size_t size)
>+#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);
>@@ -103,33 +109,19 @@ static Vector<uint8_t> combineSegmentsData(const SharedBuffer::DataSegmentVector
>     return combinedData;
> }
> 
>-void SharedBuffer::combineIntoOneSegment() const
>+Ref<SharedBuffer> FragmentedSharedBuffer::makeContiguous() const
> {
>-#if ASSERT_ENABLED
>-    // FIXME: We ought to be able to set this to true and have no assertions fire.
>-    // Remove all instances of appending after calling this, because they are all O(n^2) algorithms since r215686.
>-    // m_hasBeenCombinedIntoOneSegment = true;
>-#endif
>-    if (m_segments.size() <= 1)
>-        return;
>-
>+    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());
>     auto combinedData = combineSegmentsData(m_segments, m_size);
>-    m_segments.clear();
>-    m_segments.append({0, DataSegment::create(WTFMove(combinedData))});
>-    ASSERT(m_segments.size() == 1);
>-    ASSERT(internallyConsistent());
>+    return SharedBuffer::create(WTFMove(combinedData));
> }
> 
>-const uint8_t* SharedBuffer::data() 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> FragmentedSharedBuffer::copyData() const
> {
>     Vector<uint8_t> data;
>     data.reserveInitialCapacity(size());
>@@ -139,7 +131,7 @@ Vector<uint8_t> SharedBuffer::copyData() const
>     return data;
> }
> 
>-Vector<uint8_t> SharedBuffer::takeData()
>+Vector<uint8_t> FragmentedSharedBuffer::takeData()
> {
>     if (m_segments.isEmpty())
>         return { };
>@@ -154,13 +146,13 @@ Vector<uint8_t> SharedBuffer::takeData()
>     return combinedData;
> }
> 
>-SharedBufferDataView SharedBuffer::getSomeData(size_t position) const
>+SharedBufferDataView FragmentedSharedBuffer::getSomeData(size_t position) const
> {
>     const DataSegmentVectorEntry* element = getSegmentForPosition(position);
>     return { element->segment.copyRef(), position - element->beginPosition };
> }
> 
>-const SharedBuffer::DataSegmentVectorEntry* SharedBuffer::getSegmentForPosition(size_t position) const
>+const FragmentedSharedBuffer::DataSegmentVectorEntry* FragmentedSharedBuffer::getSegmentForPosition(size_t position) const
> {
>     RELEASE_ASSERT(position < m_size);
>     auto comparator = [](const size_t& position, const DataSegmentVectorEntry& entry) {
>@@ -171,7 +163,7 @@ const SharedBuffer::DataSegmentVectorEntry* SharedBuffer::getSegmentForPosition(
>     return element;
> }
> 
>-String SharedBuffer::toHexString() const
>+String FragmentedSharedBuffer::toHexString() const
> {
>     StringBuilder stringBuilder;
>     forEachSegment([&](auto& segment) {
>@@ -181,7 +173,7 @@ String SharedBuffer::toHexString() const
>     return stringBuilder.toString();
> }
> 
>-RefPtr<ArrayBuffer> SharedBuffer::tryCreateArrayBuffer() const
>+RefPtr<ArrayBuffer> FragmentedSharedBuffer::tryCreateArrayBuffer() const
> {
>     auto arrayBuffer = ArrayBuffer::tryCreateUninitialized(static_cast<unsigned>(size()), 1);
>     if (!arrayBuffer) {
>@@ -200,68 +192,63 @@ RefPtr<ArrayBuffer> SharedBuffer::tryCreateArrayBuffer() const
>     return arrayBuffer;
> }
> 
>-void SharedBuffer::append(const SharedBuffer& data)
>+void FragmentedSharedBuffer::append(const FragmentedSharedBuffer& data)
> {
>-    ASSERT(!m_hasBeenCombinedIntoOneSegment);
>+    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_segments.uncheckedAppend({ m_size, element.segment.copyRef() });
>         m_size += element.segment->size();
>     }
>     ASSERT(internallyConsistent());
> }
> 
>-void SharedBuffer::append(const uint8_t* data, size_t length)
>+void FragmentedSharedBuffer::append(const uint8_t* data, size_t length)
> {
>-    ASSERT(!m_hasBeenCombinedIntoOneSegment);
>+    ASSERT(!m_contiguous);
>     Vector<uint8_t> vector;
>     vector.append(data, length);
>-    m_segments.append({m_size, DataSegment::create(WTFMove(vector))});
>+    m_segments.append({ m_size, DataSegment::create(WTFMove(vector)) });
>     m_size += length;
>     ASSERT(internallyConsistent());
> }
> 
>-void SharedBuffer::append(Vector<uint8_t>&& data)
>+void FragmentedSharedBuffer::append(Vector<uint8_t>&& data)
> {
>-    ASSERT(!m_hasBeenCombinedIntoOneSegment);
>+    ASSERT(!m_contiguous);
>     auto dataSize = data.size();
>-    m_segments.append({m_size, DataSegment::create(WTFMove(data))});
>+    m_segments.append({ m_size, DataSegment::create(WTFMove(data)) });
>     m_size += dataSize;
>     ASSERT(internallyConsistent());
> }
> 
>-void SharedBuffer::clear()
>+void FragmentedSharedBuffer::clear()
> {
>     m_size = 0;
>     m_segments.clear();
>     ASSERT(internallyConsistent());
> }
> 
>-Ref<SharedBuffer> SharedBuffer::copy() const
>+Ref<FragmentedSharedBuffer> FragmentedSharedBuffer::copy() const
> {
>-    Ref<SharedBuffer> clone = adoptRef(*new SharedBuffer);
>+    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()});
>+        clone->m_segments.uncheckedAppend({ element.beginPosition, element.segment.copyRef() });
>     ASSERT(clone->internallyConsistent());
>     ASSERT(internallyConsistent());
>     return clone;
> }
> 
>-Ref<SharedBuffer> SharedBuffer::create(DataSegment::Provider&& provider)
>-{
>-    return adoptRef(*new SharedBuffer(WTFMove(provider)));
>-}
>-
>-void SharedBuffer::forEachSegment(const Function<void(const Span<const uint8_t>&)>& apply) const
>+void FragmentedSharedBuffer::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 SharedBuffer::startsWith(const Span<const uint8_t>& prefix) const
>+bool FragmentedSharedBuffer::startsWith(const Span<const uint8_t>& prefix) const
> {
>     if (prefix.empty())
>         return true;
>@@ -283,7 +270,7 @@ bool SharedBuffer::startsWith(const Span<const uint8_t>& prefix) const
>     return false;
> }
> 
>-Vector<uint8_t> SharedBuffer::read(size_t offset, size_t length) const
>+Vector<uint8_t> FragmentedSharedBuffer::read(size_t offset, size_t length) const
> {
>     Vector<uint8_t> data;
>     if (offset >= size())
>@@ -310,12 +297,12 @@ Vector<uint8_t> SharedBuffer::read(size_t offset, size_t length) const
>     return data;
> }
> 
>-void SharedBuffer::copyTo(void* destination, size_t length) const
>+void FragmentedSharedBuffer::copyTo(void* destination, size_t length) const
> {
>     return copyTo(destination, 0, length);
> }
> 
>-void SharedBuffer::copyTo(void* destination, size_t offset, size_t length) const
>+void FragmentedSharedBuffer::copyTo(void* destination, size_t offset, size_t length) const
> {
>     ASSERT(length + offset <= size());
>     if (offset >= size())
>@@ -353,14 +340,8 @@ void SharedBuffer::copyTo(void* destination, size_t offset, size_t length) const
>     }
> }
> 
>-bool SharedBuffer::hasOneSegment() const
>-{
>-    auto it = begin();
>-    return it != end() && ++it == end();
>-}
>-
> #if ASSERT_ENABLED
>-bool SharedBuffer::internallyConsistent() const
>+bool FragmentedSharedBuffer::internallyConsistent() const
> {
>     size_t position = 0;
>     for (const auto& element : m_segments) {
>@@ -372,42 +353,13 @@ bool SharedBuffer::internallyConsistent() const
> }
> #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 SharedBuffer::hintMemoryNotNeededSoon() const
>+void FragmentedSharedBuffer::hintMemoryNotNeededSoon() const
> {
> }
> #endif
> 
>-WTF::Persistence::Decoder SharedBuffer::decoder() const
>-{
>-    return {{ reinterpret_cast<const uint8_t*>(data()), size() }};
>-}
>-
>-bool SharedBuffer::operator==(const SharedBuffer& other) const
>+bool FragmentedSharedBuffer::operator==(const FragmentedSharedBuffer& other) const
> {
>     if (this == &other)
>         return true;
>@@ -456,7 +408,118 @@ bool SharedBuffer::operator==(const SharedBuffer& other) const
>     return true;
> }
> 
>-size_t SharedBuffer::DataSegment::size() const
>+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(); },
>@@ -475,7 +538,37 @@ size_t SharedBuffer::DataSegment::size() const
>     return std::visit(visitor, m_immutableData);
> }
> 
>-SharedBufferDataView::SharedBufferDataView(Ref<SharedBuffer::DataSegment>&& segment, size_t positionWithinSegment, std::optional<size_t> size)
>+void SharedBufferBuilder::empty()
>+{
>+    reset();
>+    ensureBuffer();
>+}
>+
>+Ref<FragmentedSharedBuffer> SharedBufferBuilder::take()
>+{
>+    ensureBuffer();
>+    return m_buffer.releaseNonNull();
>+}
>+
>+Ref<SharedBuffer> SharedBufferBuilder::takeAsContiguous()
>+{
>+    return take()->makeContiguous();
>+}
>+
>+RefPtr<ArrayBuffer> SharedBufferBuilder::takeAsArrayBuffer()
>+{
>+    if (!m_buffer)
>+        return ArrayBuffer::tryCreate(nullptr, 0);
>+    return take()->tryCreateArrayBuffer();
>+}
>+
>+void SharedBufferBuilder::ensureBuffer()
>+{
>+    if (!m_buffer)
>+        m_buffer = SharedBuffer::create();
>+}
>+
>+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)
>@@ -489,22 +582,12 @@ SharedBufferDataView::SharedBufferDataView(const SharedBufferDataView& other, si
> {
> }
> 
>-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<SharedBuffer::DataSegment> segment = m_segment;
>-    return SharedBuffer::create(SharedBuffer::DataSegment::Provider {
>+    const Ref<DataSegment> segment = m_segment;
>+    return SharedBuffer::create(DataSegment::Provider {
>         [segment, data = data()]() { return data; },
>-        [segment, size = size()]() { return size; }
>+        [size = size()]() { return size; }
>     });
> }
> 
>diff --git a/Source/WebCore/platform/SharedBuffer.h b/Source/WebCore/platform/SharedBuffer.h
>index f23f5d69ad32..a08eed3a9ca8 100644
>--- a/Source/WebCore/platform/SharedBuffer.h
>+++ b/Source/WebCore/platform/SharedBuffer.h
>@@ -1,5 +1,5 @@
> /*
>- * Copyright (C) 2006-2019 Apple Inc. All rights reserved.
>+ * 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
>@@ -62,146 +62,125 @@ class Decoder;
> 
> namespace WebCore {
> 
>+class SharedBuffer;
> class SharedBufferDataView;
> 
>-class WEBCORE_EXPORT SharedBuffer : public ThreadSafeRefCounted<SharedBuffer> {
>+// 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:
>-    static Ref<SharedBuffer> create() { return adoptRef(*new SharedBuffer); }
>-    static Ref<SharedBuffer> create(const uint8_t* data, size_t size) { return adoptRef(*new SharedBuffer(data, size)); }
>-    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 const uint8_t* data() const;
>+    WEBCORE_EXPORT size_t size() const;
> 
>-    enum class MayUseFileMapping : bool { No, Yes };
>-    static RefPtr<SharedBuffer> createWithContentsOfFile(const String& filePath, FileSystem::MappedFileMode = FileSystem::MappedFileMode::Shared, MayUseFileMapping = MayUseFileMapping::Yes);
>-
>-    static Ref<SharedBuffer> create(Vector<uint8_t>&&);
>+    WEBCORE_EXPORT static Ref<DataSegment> 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)
>-    RetainPtr<CFDataRef> createCFData() const;
>-    static Ref<SharedBuffer> create(CFDataRef);
>-    void append(CFDataRef);
>+    WEBCORE_EXPORT static Ref<DataSegment> create(RetainPtr<CFDataRef>&&);
> #endif
>-
> #if USE(GLIB)
>-    static Ref<SharedBuffer> create(GBytes*);
>-    GRefPtr<GBytes> createGBytes() const;
>+    WEBCORE_EXPORT static Ref<DataSegment> create(GRefPtr<GBytes>&&);
> #endif
>-
> #if USE(GSTREAMER)
>-    static Ref<SharedBuffer> create(GstMappedOwnedBuffer&);
>+    WEBCORE_EXPORT static Ref<DataSegment> create(RefPtr<GstMappedOwnedBuffer>&&);
> #endif
>-    // Calling data() causes all the data segments to be copied into one segment if they are not already.
>-    // 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;
>+    WEBCORE_EXPORT static Ref<DataSegment> create(FileSystem::MappedFileData&&);
> 
>-    size_t size() const { return m_size; }
>-
>-    bool isEmpty() const { return !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();
>+    struct Provider {
>+        Function<const uint8_t*()> data;
>+        Function<size_t()> size;
>+    };
> 
>-    Ref<SharedBuffer> copy() const;
>-    void copyTo(void* destination, size_t length) const;
>-    void copyTo(void* destination, size_t offset, size_t length) const;
>+    WEBCORE_EXPORT static Ref<DataSegment> create(Provider&&);
> 
>-    // 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;
>+#if USE(FOUNDATION)
>+    WEBCORE_EXPORT RetainPtr<NSData> createNSData() const;
>+#endif
> 
>-        static Ref<DataSegment> create(Vector<uint8_t>&& data)
>-        {
>-            data.shrinkToFit();
>-            return adoptRef(*new DataSegment(WTFMove(data)));
>-        }
>+    WEBCORE_EXPORT bool containsMappedFileData() const;
> 
>+private:
>+    explicit DataSegment(Vector<uint8_t>&& data)
>+        : m_immutableData(WTFMove(data)) { }
> #if USE(CF)
>-        static Ref<DataSegment> create(RetainPtr<CFDataRef>&& data) { return adoptRef(*new DataSegment(WTFMove(data))); }
>+    explicit DataSegment(RetainPtr<CFDataRef>&& data)
>+        : m_immutableData(WTFMove(data)) { }
> #endif
> #if USE(GLIB)
>-        static Ref<DataSegment> create(GRefPtr<GBytes>&& data) { return adoptRef(*new DataSegment(WTFMove(data))); }
>+    explicit DataSegment(GRefPtr<GBytes>&& data)
>+        : m_immutableData(WTFMove(data)) { }
> #endif
> #if USE(GSTREAMER)
>-        static Ref<DataSegment> create(RefPtr<GstMappedOwnedBuffer>&& data) { return adoptRef(*new DataSegment(WTFMove(data))); }
>+    explicit DataSegment(RefPtr<GstMappedOwnedBuffer>&& data)
>+        : m_immutableData(WTFMove(data)) { }
> #endif
>-        static Ref<DataSegment> create(FileSystem::MappedFileData&& data) { return adoptRef(*new DataSegment(WTFMove(data))); }
>+    explicit DataSegment(FileSystem::MappedFileData&& data)
>+        : m_immutableData(WTFMove(data)) { }
>+    explicit DataSegment(Provider&& provider)
>+        : m_immutableData(WTFMove(provider)) { }
> 
>-        struct Provider {
>-            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)) { }
>+    std::variant<Vector<uint8_t>,
> #if USE(CF)
>-        DataSegment(RetainPtr<CFDataRef>&& data)
>-            : m_immutableData(WTFMove(data)) { }
>+        RetainPtr<CFDataRef>,
> #endif
> #if USE(GLIB)
>-        DataSegment(GRefPtr<GBytes>&& data)
>-            : m_immutableData(WTFMove(data)) { }
>+        GRefPtr<GBytes>,
> #endif
> #if USE(GSTREAMER)
>-        DataSegment(RefPtr<GstMappedOwnedBuffer>&& data)
>-            : m_immutableData(WTFMove(data)) { }
>+        RefPtr<GstMappedOwnedBuffer>,
> #endif
>-        DataSegment(FileSystem::MappedFileData&& data)
>-            : m_immutableData(WTFMove(data)) { }
>-        DataSegment(Provider&& provider)
>-            : m_immutableData(WTFMove(provider)) { }
>+        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&&);
> 
>-        std::variant<Vector<uint8_t>,
>+#if USE(FOUNDATION)
>+    WEBCORE_EXPORT RetainPtr<NSArray> createNSDataArray() const;
>+    WEBCORE_EXPORT static Ref<FragmentedSharedBuffer> create(NSData*);
>+#endif
> #if USE(CF)
>-            RetainPtr<CFDataRef>,
>+    WEBCORE_EXPORT static Ref<FragmentedSharedBuffer> create(CFDataRef);
> #endif
>+
> #if USE(GLIB)
>-            GRefPtr<GBytes>,
>+    WEBCORE_EXPORT static Ref<FragmentedSharedBuffer> create(GBytes*);
> #endif
>+
> #if USE(GSTREAMER)
>-            RefPtr<GstMappedOwnedBuffer>,
>+    WEBCORE_EXPORT static Ref<FragmentedSharedBuffer> create(GstMappedOwnedBuffer&);
> #endif
>-            FileSystem::MappedFileData,
>-            Provider> m_immutableData;
>-        friend class SharedBuffer;
>-    };
>+    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; }
> 
>-    static Ref<SharedBuffer> create(DataSegment::Provider&&);
>+    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;
> 
>-    void forEachSegment(const Function<void(const Span<const uint8_t>&)>&) const;
>-    bool startsWith(const Span<const uint8_t>& prefix) 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;
>@@ -210,75 +189,183 @@ public:
>     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;
>+    bool hasOneSegment() const { return m_segments.size() == 1; }
> 
>     // begin and end take O(1) time, this takes O(log(N)) time.
>-    SharedBufferDataView getSomeData(size_t position) const;
>+    WEBCORE_EXPORT SharedBufferDataView getSomeData(size_t position) const;
> 
>-    String toHexString() const;
>+    WEBCORE_EXPORT String toHexString() const;
> 
>     void hintMemoryNotNeededSoon() const;
> 
>-    WTF::Persistence::Decoder decoder() const;
>+    WEBCORE_EXPORT bool operator==(const FragmentedSharedBuffer&) const;
>+    bool operator!=(const FragmentedSharedBuffer& other) const { return !operator==(other); }
> 
>-    bool operator==(const SharedBuffer&) const;
>-    bool operator!=(const SharedBuffer& other) const { return !operator==(other); }
>+    WEBCORE_EXPORT Ref<SharedBuffer> makeContiguous() const;
> 
>-private:
>-    explicit SharedBuffer() = default;
>-    explicit SharedBuffer(const uint8_t*, size_t);
>-    explicit SharedBuffer(const char*, size_t);
>-    explicit SharedBuffer(Vector<uint8_t>&&);
>-    explicit SharedBuffer(FileSystem::MappedFileData&&);
>-    explicit SharedBuffer(DataSegment::Provider&&);
>+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)
>-    explicit SharedBuffer(CFDataRef);
>+    WEBCORE_EXPORT explicit FragmentedSharedBuffer(CFDataRef);
> #endif
> #if USE(GLIB)
>-    explicit SharedBuffer(GBytes*);
>+    WEBCORE_EXPORT explicit FragmentedSharedBuffer(GBytes*);
> #endif
> #if USE(GSTREAMER)
>-    explicit SharedBuffer(GstMappedOwnedBuffer&);
>+    WEBCORE_EXPORT explicit FragmentedSharedBuffer(GstMappedOwnedBuffer&);
> #endif
>+    size_t m_size { 0 };
> 
>-    void combineIntoOneSegment() const;
>+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
> 
>-    // Combines all the segments into a Vector and returns that vector after clearing the SharedBuffer.
>-    Vector<uint8_t> takeData();
>+    WEBCORE_EXPORT void clear();
> 
>+    // 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
> };
> 
>-inline Vector<uint8_t> SharedBuffer::extractData()
>+// 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)
>+    {
>+        if (!buffer)
>+            return;
>+        // We do not want to take a reference to the SharedBuffer as all SharedBuffer should be immutable
>+        // once created.
>+        if (buffer->hasOneRef() && !buffer->isContiguous()) {
>+            m_buffer = WTFMove(buffer);
>+            return;
>+        }
>+        append(*buffer);
>+    }
>+    explicit SharedBufferBuilder(Ref<FragmentedSharedBuffer>&& buffer)
>+        : SharedBufferBuilder(RefPtr<FragmentedSharedBuffer> { WTFMove(buffer) })
>+    {
>+    }
>+    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; }
>+    WEBCORE_EXPORT void empty();
>+
>+    RefPtr<FragmentedSharedBuffer> get() const { return m_buffer; }
>+    Ref<FragmentedSharedBuffer> copy() const { return m_buffer ? m_buffer->copy() : FragmentedSharedBuffer::create(); }
>+    WEBCORE_EXPORT Ref<FragmentedSharedBuffer> take();
>+    WEBCORE_EXPORT Ref<SharedBuffer> takeAsContiguous();
>+    WEBCORE_EXPORT RefPtr<ArrayBuffer> takeAsArrayBuffer();
>+
>+private:
>+    WEBCORE_EXPORT void ensureBuffer();
>+    RefPtr<FragmentedSharedBuffer> m_buffer;
>+};
>+
>+inline Vector<uint8_t> FragmentedSharedBuffer::extractData()
> {
>     if (hasOneRef())
>         return takeData();
>     return copyData();
> }
> 
>-class WEBCORE_EXPORT SharedBufferDataView {
>+class SharedBufferDataView {
> public:
>-    SharedBufferDataView(Ref<SharedBuffer::DataSegment>&&, size_t positionWithinSegment, std::optional<size_t> newSize = std::nullopt);
>-    SharedBufferDataView(const SharedBufferDataView&, size_t newSize);
>-    size_t size() const;
>-    const uint8_t* data() const;
>+    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()); }
>-    Ref<SharedBuffer> createSharedBuffer() const;
>+
>+    WEBCORE_EXPORT Ref<SharedBuffer> createSharedBuffer() const;
> #if USE(FOUNDATION)
>-    RetainPtr<NSData> createNSData() const;
>+    WEBCORE_EXPORT RetainPtr<NSData> createNSData() const;
> #endif
> private:
>-    const Ref<SharedBuffer::DataSegment> m_segment;
>+    const Ref<DataSegment> m_segment;
>     const size_t m_positionWithinSegment;
>     const size_t m_size;
> };
>diff --git a/Source/WebCore/platform/SharedBufferChunkReader.cpp b/Source/WebCore/platform/SharedBufferChunkReader.cpp
>index cdb6e703404d..9d055ce27d88 100644
>--- a/Source/WebCore/platform/SharedBufferChunkReader.cpp
>+++ b/Source/WebCore/platform/SharedBufferChunkReader.cpp
>@@ -36,7 +36,7 @@ namespace WebCore {
> 
> #if ENABLE(MHTML)
> 
>-SharedBufferChunkReader::SharedBufferChunkReader(SharedBuffer* buffer, const Vector<char>& separator)
>+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)
>@@ -44,7 +44,7 @@ SharedBufferChunkReader::SharedBufferChunkReader(SharedBuffer* buffer, const Vec
> {
> }
> 
>-SharedBufferChunkReader::SharedBufferChunkReader(SharedBuffer* buffer, const char* separator)
>+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)
>diff --git a/Source/WebCore/platform/SharedBufferChunkReader.h b/Source/WebCore/platform/SharedBufferChunkReader.h
>index 5d4e6fee582c..1c6408d4c736 100644
>--- a/Source/WebCore/platform/SharedBufferChunkReader.h
>+++ b/Source/WebCore/platform/SharedBufferChunkReader.h
>@@ -41,8 +41,8 @@ namespace WebCore {
> 
> class WEBCORE_EXPORT SharedBufferChunkReader {
> public:
>-    SharedBufferChunkReader(SharedBuffer*, const Vector<char>& separator);
>-    SharedBufferChunkReader(SharedBuffer*, const char* separator);
>+    SharedBufferChunkReader(FragmentedSharedBuffer*, const Vector<char>& separator);
>+    SharedBufferChunkReader(FragmentedSharedBuffer*, const char* separator);
> 
>     void setSeparator(const Vector<char>&);
>     void setSeparator(const char*);
>@@ -58,8 +58,8 @@ public:
>     size_t peek(Vector<uint8_t>&, size_t);
> 
> private:
>-    SharedBuffer::DataSegmentVector::const_iterator m_iteratorCurrent;
>-    const SharedBuffer::DataSegmentVector::const_iterator m_iteratorEnd;
>+    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 };
>diff --git a/Source/WebCore/platform/StaticPasteboard.cpp b/Source/WebCore/platform/StaticPasteboard.cpp
>index b2d7a550d460..a4b4bb104b4d 100644
>--- a/Source/WebCore/platform/StaticPasteboard.cpp
>+++ b/Source/WebCore/platform/StaticPasteboard.cpp
>@@ -73,7 +73,7 @@ void StaticPasteboard::writeString(const String& type, const String& value)
>     m_customData.writeString(type, value);
> }
> 
>-void StaticPasteboard::writeData(const String& type, Ref<SharedBuffer>&& data)
>+void StaticPasteboard::writeData(const String& type, Ref<FragmentedSharedBuffer>&& data)
> {
>     m_nonDefaultDataTypes.add(type);
>     m_customData.writeData(type, WTFMove(data));
>diff --git a/Source/WebCore/platform/StaticPasteboard.h b/Source/WebCore/platform/StaticPasteboard.h
>index c09b6de31f2e..edd713623f06 100644
>--- a/Source/WebCore/platform/StaticPasteboard.h
>+++ b/Source/WebCore/platform/StaticPasteboard.h
>@@ -32,7 +32,7 @@
> 
> namespace WebCore {
> 
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class StaticPasteboard final : public Pasteboard {
> public:
>@@ -52,7 +52,7 @@ public:
>     String readStringInCustomData(const String& type) final;
> 
>     void writeString(const String& type, const String& data) final;
>-    void writeData(const String& type, Ref<SharedBuffer>&& data);
>+    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;
>diff --git a/Source/WebCore/platform/audio/NowPlayingInfo.h b/Source/WebCore/platform/audio/NowPlayingInfo.h
>index 68795900c5ad..1d65bc403ad8 100644
>--- a/Source/WebCore/platform/audio/NowPlayingInfo.h
>+++ b/Source/WebCore/platform/audio/NowPlayingInfo.h
>@@ -36,7 +36,7 @@ namespace WebCore {
> struct NowPlayingInfoArtwork {
>     String src;
>     String mimeType;
>-    RefPtr<SharedBuffer> imageData;
>+    RefPtr<FragmentedSharedBuffer> imageData;
> 
>     bool operator==(const NowPlayingInfoArtwork& other) const
>     {
>@@ -67,7 +67,7 @@ template<class Decoder> inline std::optional<NowPlayingInfoArtwork> NowPlayingIn
>     if (!decoder.decode(mimeType))
>         return { };
> 
>-    RefPtr<SharedBuffer> imageData;
>+    RefPtr<FragmentedSharedBuffer> imageData;
>     if (!decoder.decode(imageData))
>         return { };
> 
>diff --git a/Source/WebCore/platform/audio/cocoa/MediaSessionManagerCocoa.mm b/Source/WebCore/platform/audio/cocoa/MediaSessionManagerCocoa.mm
>index bb788afa1e91..7f04960c5965 100644
>--- a/Source/WebCore/platform/audio/cocoa/MediaSessionManagerCocoa.mm
>+++ b/Source/WebCore/platform/audio/cocoa/MediaSessionManagerCocoa.mm
>@@ -341,7 +341,7 @@ void MediaSessionManagerCocoa::setNowPlayingInfo(bool setAsNowPlayingApplication
>         CFDictionarySetValue(info.get(), kMRMediaRemoteNowPlayingInfoElapsedTime, cfCurrentTime.get());
>     }
>     if (nowPlayingInfo.artwork && nowPlayingInfo.artwork->imageData) {
>-        auto nsArtwork = nowPlayingInfo.artwork->imageData->createNSData();
>+        auto nsArtwork = nowPlayingInfo.artwork->imageData->makeContiguous()->createNSData();
>         CFDictionarySetValue(info.get(), kMRMediaRemoteNowPlayingInfoArtworkData, nsArtwork.get());
>         CFDictionarySetValue(info.get(), kMRMediaRemoteNowPlayingInfoArtworkMIMEType, nowPlayingInfo.artwork->mimeType.createCFString().get());
>         CFDictionarySetValue(info.get(), kMRMediaRemoteNowPlayingInfoArtworkIdentifier, String::number(nowPlayingInfo.artwork->src.hash()).createCFString().get());
>diff --git a/Source/WebCore/platform/cf/SharedBufferCF.cpp b/Source/WebCore/platform/cf/SharedBufferCF.cpp
>index 6b66217ff161..4cbef12790d4 100644
>--- a/Source/WebCore/platform/cf/SharedBufferCF.cpp
>+++ b/Source/WebCore/platform/cf/SharedBufferCF.cpp
>@@ -33,8 +33,9 @@
> 
> namespace WebCore {
> 
>-SharedBuffer::SharedBuffer(CFDataRef data)
>+FragmentedSharedBuffer::FragmentedSharedBuffer(CFDataRef data)
> {
>+    ASSERT(!m_contiguous);
>     append(data);
> }
> 
>@@ -43,24 +44,20 @@ SharedBuffer::SharedBuffer(CFDataRef data)
> #if !USE(FOUNDATION)
> RetainPtr<CFDataRef> SharedBuffer::createCFData() const
> {
>-    if (m_segments.size() == 1) {
>+    if (hasOneSegment()) {
>         if (auto* data = std::get_if<RetainPtr<CFDataRef>>(&m_segments[0].segment->m_immutableData))
>             return *data;
>     }
>-    auto cfData = adoptCF(CFDataCreateMutable(nullptr, size()));
>-    forEachSegment([&](auto& segment) {
>-        CFDataAppendBytes(cfData.get(), segment.data(), segment.size());
>-    });
>-    return cfData;
>+    return adoptCF(CFDataCreate(nullptr, data(), size()));
> }
> #endif
> 
>-Ref<SharedBuffer> SharedBuffer::create(CFDataRef data)
>+Ref<FragmentedSharedBuffer> FragmentedSharedBuffer::create(CFDataRef data)
> {
>-    return adoptRef(*new SharedBuffer(data));
>+    return adoptRef(*new FragmentedSharedBuffer(data));
> }
> 
>-void SharedBuffer::hintMemoryNotNeededSoon() const
>+void FragmentedSharedBuffer::hintMemoryNotNeededSoon() const
> {
>     for (const auto& entry : m_segments) {
>         if (entry.segment->hasOneRef()) {
>@@ -70,9 +67,8 @@ void SharedBuffer::hintMemoryNotNeededSoon() const
>     }
> }
> 
>-void SharedBuffer::append(CFDataRef data)
>+void FragmentedSharedBuffer::append(CFDataRef data)
> {
>-    ASSERT(!m_hasBeenCombinedIntoOneSegment);
>     if (data) {
>         m_segments.append({m_size, DataSegment::create(data)});
>         m_size += CFDataGetLength(data);
>diff --git a/Source/WebCore/platform/cocoa/NetworkExtensionContentFilter.h b/Source/WebCore/platform/cocoa/NetworkExtensionContentFilter.h
>index 0797dfbe8d01..cbe8771a45d8 100644
>--- a/Source/WebCore/platform/cocoa/NetworkExtensionContentFilter.h
>+++ b/Source/WebCore/platform/cocoa/NetworkExtensionContentFilter.h
>@@ -51,7 +51,7 @@ public:
>     void responseReceived(const ResourceResponse&) override;
>     void addData(const uint8_t* data, int length) override;
>     void finishedAddingData() override;
>-    Ref<SharedBuffer> replacementData() const override;
>+    Ref<FragmentedSharedBuffer> replacementData() const override;
>     ContentFilterUnblockHandler unblockHandler() const override;
> 
>     WEBCORE_EXPORT static bool isRequired();
>diff --git a/Source/WebCore/platform/cocoa/NetworkExtensionContentFilter.mm b/Source/WebCore/platform/cocoa/NetworkExtensionContentFilter.mm
>index 4290db128d00..2ef2701fe678 100644
>--- a/Source/WebCore/platform/cocoa/NetworkExtensionContentFilter.mm
>+++ b/Source/WebCore/platform/cocoa/NetworkExtensionContentFilter.mm
>@@ -175,7 +175,7 @@ void NetworkExtensionContentFilter::finishedAddingData()
>     semaphore.wait();
> }
> 
>-Ref<SharedBuffer> NetworkExtensionContentFilter::replacementData() const
>+Ref<FragmentedSharedBuffer> NetworkExtensionContentFilter::replacementData() const
> {
>     ASSERT(didBlockData());
>     return SharedBuffer::create(m_replacementData.get());
>diff --git a/Source/WebCore/platform/cocoa/ParentalControlsContentFilter.h b/Source/WebCore/platform/cocoa/ParentalControlsContentFilter.h
>index 068cdcb383f4..679ae9329517 100644
>--- a/Source/WebCore/platform/cocoa/ParentalControlsContentFilter.h
>+++ b/Source/WebCore/platform/cocoa/ParentalControlsContentFilter.h
>@@ -45,7 +45,7 @@ public:
>     void responseReceived(const ResourceResponse&) override;
>     void addData(const uint8_t* data, int length) override;
>     void finishedAddingData() override;
>-    Ref<SharedBuffer> replacementData() const override;
>+    Ref<FragmentedSharedBuffer> replacementData() const override;
> #if ENABLE(CONTENT_FILTERING)
>     ContentFilterUnblockHandler unblockHandler() const override;
> #endif
>diff --git a/Source/WebCore/platform/cocoa/ParentalControlsContentFilter.mm b/Source/WebCore/platform/cocoa/ParentalControlsContentFilter.mm
>index b461f97536de..1c9604716b42 100644
>--- a/Source/WebCore/platform/cocoa/ParentalControlsContentFilter.mm
>+++ b/Source/WebCore/platform/cocoa/ParentalControlsContentFilter.mm
>@@ -109,7 +109,7 @@ void ParentalControlsContentFilter::finishedAddingData()
>     updateFilterState();
> }
> 
>-Ref<SharedBuffer> ParentalControlsContentFilter::replacementData() const
>+Ref<FragmentedSharedBuffer> ParentalControlsContentFilter::replacementData() const
> {
>     ASSERT(didBlockData());
>     return SharedBuffer::create(m_replacementData.get());
>diff --git a/Source/WebCore/platform/cocoa/PasteboardCocoa.mm b/Source/WebCore/platform/cocoa/PasteboardCocoa.mm
>index 6f28e824360c..b8170817cec5 100644
>--- a/Source/WebCore/platform/cocoa/PasteboardCocoa.mm
>+++ b/Source/WebCore/platform/cocoa/PasteboardCocoa.mm
>@@ -47,7 +47,7 @@ static NSBitmapImageFileType bitmapPNGFileType()
> }
> #endif // PLATFORM(MAC)
> 
>-// Making this non-inline so that WebKit 2's decoding doesn't have to include SharedBuffer.h.
>+// Making this non-inline so that WebKit 2's decoding doesn't have to include FragmentedSharedBuffer.h.
> PasteboardWebContent::PasteboardWebContent() = default;
> PasteboardWebContent::~PasteboardWebContent() = default;
> 
>@@ -211,9 +211,9 @@ Vector<String> Pasteboard::typesForLegacyUnsafeBindings()
> }
> 
> #if PLATFORM(MAC)
>-static Ref<SharedBuffer> convertTIFFToPNG(SharedBuffer& tiffBuffer)
>+static Ref<SharedBuffer> convertTIFFToPNG(FragmentedSharedBuffer& tiffBuffer)
> {
>-    auto image = adoptNS([[NSBitmapImageRep alloc] initWithData: tiffBuffer.createNSData().get()]);
>+    auto image = adoptNS([[NSBitmapImageRep alloc] initWithData: tiffBuffer.makeContiguous()->createNSData().get()]);
>     NSData *pngData = [image representationUsingType:bitmapPNGFileType() properties:@{ }];
>     return SharedBuffer::create(pngData);
> }
>diff --git a/Source/WebCore/platform/cocoa/SharedBufferCocoa.mm b/Source/WebCore/platform/cocoa/SharedBufferCocoa.mm
>index 9ee0c0b55d79..25f311f2589b 100644
>--- a/Source/WebCore/platform/cocoa/SharedBufferCocoa.mm
>+++ b/Source/WebCore/platform/cocoa/SharedBufferCocoa.mm
>@@ -35,11 +35,11 @@
> #import <wtf/cocoa/VectorCocoa.h>
> 
> @interface WebCoreSharedBufferData : NSData
>-- (instancetype)initWithDataSegment:(const WebCore::SharedBuffer::DataSegment&)dataSegment position:(NSUInteger)position size:(NSUInteger)size;
>+- (instancetype)initWithDataSegment:(const WebCore::DataSegment&)dataSegment position:(NSUInteger)position size:(NSUInteger)size;
> @end
> 
> @implementation WebCoreSharedBufferData {
>-    RefPtr<const WebCore::SharedBuffer::DataSegment> _dataSegment;
>+    RefPtr<const WebCore::DataSegment> _dataSegment;
>     NSUInteger _position;
>     NSUInteger _size;
> }
>@@ -61,7 +61,7 @@ - (void)dealloc
>     [super dealloc];
> }
> 
>-- (instancetype)initWithDataSegment:(const WebCore::SharedBuffer::DataSegment&)dataSegment position:(NSUInteger)position size:(NSUInteger)size
>+- (instancetype)initWithDataSegment:(const WebCore::DataSegment&)dataSegment position:(NSUInteger)position size:(NSUInteger)size
> {
>     if (!(self = [super init]))
>         return nil;
>@@ -88,13 +88,14 @@ @end
> 
> namespace WebCore {
> 
>-Ref<SharedBuffer> SharedBuffer::create(NSData *data)
>+Ref<FragmentedSharedBuffer> FragmentedSharedBuffer::create(NSData *data)
> {
>-    return adoptRef(*new SharedBuffer(bridge_cast(data)));
>+    return adoptRef(*new FragmentedSharedBuffer(bridge_cast(data)));
> }
> 
>-void SharedBuffer::append(NSData *data)
>+void FragmentedSharedBuffer::append(NSData *data)
> {
>+    ASSERT(!m_contiguous);
>     return append(bridge_cast(data));
> }
> 
>@@ -105,10 +106,8 @@ RetainPtr<NSData> SharedBuffer::createNSData() const
> 
> 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());
> }
> 
>@@ -119,14 +118,14 @@ RefPtr<SharedBuffer> SharedBuffer::createFromReadingFile(const String& filePath)
>     return nullptr;
> }
> 
>-RetainPtr<NSArray> SharedBuffer::createNSDataArray() const
>+RetainPtr<NSArray> FragmentedSharedBuffer::createNSDataArray() const
> {
>     return createNSArray(m_segments, [] (auto& segment) {
>         return segment.segment->createNSData();
>     });
> }
> 
>-RetainPtr<NSData> SharedBuffer::DataSegment::createNSData() const
>+RetainPtr<NSData> DataSegment::createNSData() const
> {
>     return adoptNS([[WebCoreSharedBufferData alloc] initWithDataSegment:*this position:0 size:size()]);
> }
>diff --git a/Source/WebCore/platform/encryptedmedia/CDMInstance.h b/Source/WebCore/platform/encryptedmedia/CDMInstance.h
>index fbc283fbc336..2de41934da19 100644
>--- a/Source/WebCore/platform/encryptedmedia/CDMInstance.h
>+++ b/Source/WebCore/platform/encryptedmedia/CDMInstance.h
>@@ -46,7 +46,7 @@ class Logger;
> 
> namespace WebCore {
> 
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> class CDMInstanceSession;
> struct CDMKeySystemConfiguration;
> 
>@@ -54,7 +54,7 @@ class CDMInstanceClient : public CanMakeWeakPtr<CDMInstanceClient> {
> public:
>     virtual ~CDMInstanceClient() = default;
> 
>-    virtual void unrequestedInitializationDataReceived(const String&, Ref<SharedBuffer>&&) = 0;
>+    virtual void unrequestedInitializationDataReceived(const String&, Ref<FragmentedSharedBuffer>&&) = 0;
> };
> 
> // JavaScript's handle to a CDMInstance, must be used from the
>@@ -98,7 +98,7 @@ public:
>     };
> 
>     virtual void initializeWithConfiguration(const CDMKeySystemConfiguration&, AllowDistinctiveIdentifiers, AllowPersistentState, SuccessCallback&&) = 0;
>-    virtual void setServerCertificate(Ref<SharedBuffer>&&, 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;
>diff --git a/Source/WebCore/platform/encryptedmedia/CDMInstanceSession.h b/Source/WebCore/platform/encryptedmedia/CDMInstanceSession.h
>index 37cd07c7bf2d..d259225ba9e0 100644
>--- a/Source/WebCore/platform/encryptedmedia/CDMInstanceSession.h
>+++ b/Source/WebCore/platform/encryptedmedia/CDMInstanceSession.h
>@@ -43,16 +43,16 @@ class Logger;
> 
> namespace WebCore {
> 
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class CDMInstanceSessionClient : public CanMakeWeakPtr<CDMInstanceSessionClient> {
> public:
>     virtual ~CDMInstanceSessionClient() = default;
> 
>     using KeyStatus = CDMKeyStatus;
>-    using KeyStatusVector = Vector<std::pair<Ref<SharedBuffer>, KeyStatus>>;
>+    using KeyStatusVector = Vector<std::pair<Ref<FragmentedSharedBuffer>, KeyStatus>>;
>     virtual void updateKeyStatuses(KeyStatusVector&&) = 0;
>-    virtual void sendMessage(CDMMessageType, Ref<SharedBuffer>&& message) = 0;
>+    virtual void sendMessage(CDMMessageType, Ref<FragmentedSharedBuffer>&& message) = 0;
>     virtual void sessionIdChanged(const String&) = 0;
>     using PlatformDisplayID = uint32_t;
>     virtual PlatformDisplayID displayID() = 0;
>@@ -78,13 +78,13 @@ public:
>         Succeeded,
>     };
> 
>-    using LicenseCallback = CompletionHandler<void(Ref<SharedBuffer>&& message, const String& sessionId, bool needsIndividualization, SuccessValue succeeded)>;
>-    virtual void requestLicense(LicenseType, const AtomString& initDataType, Ref<SharedBuffer>&& initData, LicenseCallback&&) = 0;
>+    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<SharedBuffer>>;
>+    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<SharedBuffer>&& response, LicenseUpdateCallback&&) = 0;
>+    virtual void updateLicense(const String& sessionId, LicenseType, Ref<FragmentedSharedBuffer>&& response, LicenseUpdateCallback&&) = 0;
> 
>     enum class SessionLoadFailure : uint8_t {
>         None,
>@@ -100,7 +100,7 @@ public:
>     using CloseSessionCallback = CompletionHandler<void()>;
>     virtual void closeSession(const String& sessionId, CloseSessionCallback&&) = 0;
> 
>-    using RemoveSessionDataCallback = CompletionHandler<void(KeyStatusVector&&, std::optional<Ref<SharedBuffer>>&&, SuccessValue)>;
>+    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;
>diff --git a/Source/WebCore/platform/encryptedmedia/CDMPrivate.h b/Source/WebCore/platform/encryptedmedia/CDMPrivate.h
>index cc6dc7f140cd..52a6148c83cd 100644
>--- a/Source/WebCore/platform/encryptedmedia/CDMPrivate.h
>+++ b/Source/WebCore/platform/encryptedmedia/CDMPrivate.h
>@@ -73,8 +73,8 @@ public:
>     virtual void loadAndInitialize() = 0;
>     virtual bool supportsServerCertificates() const = 0;
>     virtual bool supportsSessions() const = 0;
>-    virtual bool supportsInitData(const AtomString&, const SharedBuffer&) const = 0;
>-    virtual RefPtr<SharedBuffer> sanitizeResponse(const SharedBuffer&) 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:
>diff --git a/Source/WebCore/platform/encryptedmedia/CDMProxy.cpp b/Source/WebCore/platform/encryptedmedia/CDMProxy.cpp
>index f218f97904fb..4ba75bf00d9f 100644
>--- a/Source/WebCore/platform/encryptedmedia/CDMProxy.cpp
>+++ b/Source/WebCore/platform/encryptedmedia/CDMProxy.cpp
>@@ -227,7 +227,7 @@ CDMInstanceSession::KeyStatusVector KeyStore::convertToJSKeyStatusVector() const
>     CDMInstanceSession::KeyStatusVector keyStatusVector;
>     keyStatusVector.reserveInitialCapacity(numKeys());
>     for (const auto& key : m_keys)
>-        keyStatusVector.uncheckedAppend(std::pair<Ref<SharedBuffer>, CDMInstanceSession::KeyStatus> { key->idAsSharedBuffer(), key->status() });
>+        keyStatusVector.uncheckedAppend(std::pair<Ref<FragmentedSharedBuffer>, CDMInstanceSession::KeyStatus> { key->idAsSharedBuffer(), key->status() });
>     return keyStatusVector;
> }
> 
>diff --git a/Source/WebCore/platform/encryptedmedia/CDMProxy.h b/Source/WebCore/platform/encryptedmedia/CDMProxy.h
>index a584b6cd266b..e1e098a1d5f5 100644
>--- a/Source/WebCore/platform/encryptedmedia/CDMProxy.h
>+++ b/Source/WebCore/platform/encryptedmedia/CDMProxy.h
>@@ -61,7 +61,7 @@ public:
>     {
>         return adoptRef(*new KeyHandle(status, WTFMove(keyID), WTFMove(keyHandleValue)));
>     }
>-    Ref<SharedBuffer> idAsSharedBuffer() const { return SharedBuffer::create(m_id.data(), m_id.size()); }
>+    Ref<FragmentedSharedBuffer> idAsSharedBuffer() const { return SharedBuffer::create(m_id.data(), m_id.size()); }
> 
>     bool takeValueIfDifferent(KeyHandleValueVariant&&);
> 
>diff --git a/Source/WebCore/platform/encryptedmedia/CDMUtilities.cpp b/Source/WebCore/platform/encryptedmedia/CDMUtilities.cpp
>index 5bebcb49aa8e..fca6f2388a56 100644
>--- a/Source/WebCore/platform/encryptedmedia/CDMUtilities.cpp
>+++ b/Source/WebCore/platform/encryptedmedia/CDMUtilities.cpp
>@@ -38,7 +38,7 @@ namespace WebCore {
> 
> namespace CDMUtilities {
> 
>-RefPtr<JSON::Object> parseJSONObject(const SharedBuffer& buffer)
>+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();
>@@ -46,7 +46,7 @@ RefPtr<JSON::Object> parseJSONObject(const SharedBuffer& buffer)
>         return nullptr;
> 
>     // Parse the buffer contents as JSON, returning the root object (if any).
>-    String json { buffer.data(), static_cast<unsigned>(size) };
>+    String json { buffer.makeContiguous()->data(), static_cast<unsigned>(size) };
> 
>     auto value = JSON::Value::parseJSON(json);
>     if (!value)
>diff --git a/Source/WebCore/platform/encryptedmedia/CDMUtilities.h b/Source/WebCore/platform/encryptedmedia/CDMUtilities.h
>index 74f515b0bd2a..fcf5bdda7c59 100644
>--- a/Source/WebCore/platform/encryptedmedia/CDMUtilities.h
>+++ b/Source/WebCore/platform/encryptedmedia/CDMUtilities.h
>@@ -35,11 +35,11 @@
> 
> namespace WebCore {
> 
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> namespace CDMUtilities {
> 
>-RefPtr<JSON::Object> parseJSONObject(const SharedBuffer&);
>+RefPtr<JSON::Object> parseJSONObject(const FragmentedSharedBuffer&);
> 
> };
> 
>diff --git a/Source/WebCore/platform/encryptedmedia/clearkey/CDMClearKey.cpp b/Source/WebCore/platform/encryptedmedia/clearkey/CDMClearKey.cpp
>index dd3457bfde8c..31a9fdfa02d6 100644
>--- a/Source/WebCore/platform/encryptedmedia/clearkey/CDMClearKey.cpp
>+++ b/Source/WebCore/platform/encryptedmedia/clearkey/CDMClearKey.cpp
>@@ -130,7 +130,7 @@ static bool parseLicenseReleaseAcknowledgementFormat(const JSON::Object& root)
> // ];
> 
> // This function extracts the KeyIds count and the location of the first KeyId in initData buffer.
>-static std::pair<unsigned, unsigned> extractKeyidsLocationFromCencInitData(const SharedBuffer& initData)
>+static std::pair<unsigned, unsigned> extractKeyidsLocationFromCencInitData(const FragmentedSharedBuffer& initData)
> {
>     std::pair<unsigned, unsigned> keyIdsMap(0, 0);
> 
>@@ -138,7 +138,8 @@ static std::pair<unsigned, unsigned> extractKeyidsLocationFromCencInitData(const
>     if (initData.isEmpty() || initData.size() > std::numeric_limits<unsigned>::max())
>         return keyIdsMap;
> 
>-    auto* data = initData.data();
>+    auto contiguousInitData = initData.makeContiguous();
>+    auto* data = contiguousInitData->data();
>     unsigned initDataSize = initData.size();
>     unsigned index = 0;
>     unsigned psshSize = 0;
>@@ -188,15 +189,15 @@ static std::pair<unsigned, unsigned> extractKeyidsLocationFromCencInitData(const
> }
> 
> // This function checks if the initData sharedBuffer is a valid CENC initData.
>-static bool isCencInitData(const SharedBuffer& initData)
>+static bool isCencInitData(const FragmentedSharedBuffer& initData)
> {
>     std::pair<unsigned, unsigned> keyIdsMap = extractKeyidsLocationFromCencInitData(initData);
>     return ((keyIdsMap.first) && (keyIdsMap.second));
> }
> 
>-static Ref<SharedBuffer> extractKeyidsFromCencInitData(const SharedBuffer& initData)
>+static Ref<FragmentedSharedBuffer> extractKeyidsFromCencInitData(const FragmentedSharedBuffer& initData)
> {
>-    Ref<SharedBuffer> keyIds = SharedBuffer::create();
>+    SharedBufferBuilder keyIds;
> 
>     std::pair<unsigned, unsigned> keyIdsMap = extractKeyidsLocationFromCencInitData(initData);
>     unsigned keyIdCount = keyIdsMap.first;
>@@ -204,9 +205,10 @@ static Ref<SharedBuffer> extractKeyidsFromCencInitData(const SharedBuffer& initD
> 
>     // Check if initData is a valid CENC initData.
>     if (!keyIdCount || !index)
>-        return keyIds;
>+        return keyIds.take();
> 
>-    auto* data = initData.data();
>+    auto contiguousInitData = initData.makeContiguous();
>+    auto* data = contiguousInitData->data();
> 
>     auto object = JSON::Object::create();
>     auto keyIdsArray = JSON::Array::create();
>@@ -224,17 +226,17 @@ static Ref<SharedBuffer> extractKeyidsFromCencInitData(const SharedBuffer& initD
> 
>     object->setArray("kids", WTFMove(keyIdsArray));
>     CString jsonData = object->toJSONString().utf8();
>-    keyIds->append(jsonData.data(), jsonData.length());
>-    return keyIds;
>+    keyIds.append(jsonData.data(), jsonData.length());
>+    return keyIds.take();
> }
> 
>-static Ref<SharedBuffer> extractKeyIdFromWebMInitData(const SharedBuffer& initData)
>+static Ref<FragmentedSharedBuffer> extractKeyIdFromWebMInitData(const FragmentedSharedBuffer& initData)
> {
>-    Ref<SharedBuffer> keyIds = SharedBuffer::create();
>+    SharedBufferBuilder keyIds;
> 
>     // Check if initData is a valid WebM initData.
>     if (initData.isEmpty() || initData.size() > std::numeric_limits<unsigned>::max())
>-        return keyIds;
>+        return keyIds.take();
> 
>     auto object = JSON::Object::create();
>     auto keyIdsArray = JSON::Array::create();
>@@ -245,12 +247,12 @@ static Ref<SharedBuffer> extractKeyIdFromWebMInitData(const SharedBuffer& initDa
>     // 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.data(), initData.size()));
>+    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;
>+    keyIds.append(jsonData.data(), jsonData.length());
>+    return keyIds.take();
> }
> 
> CDMFactoryClearKey& CDMFactoryClearKey::singleton()
>@@ -388,7 +390,7 @@ bool CDMPrivateClearKey::supportsSessions() const
>     return true;
> }
> 
>-bool CDMPrivateClearKey::supportsInitData(const AtomString& initDataType, const SharedBuffer& initData) const
>+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))
>@@ -405,7 +407,7 @@ bool CDMPrivateClearKey::supportsInitData(const AtomString& initDataType, const
>     return false;
> }
> 
>-RefPtr<SharedBuffer> CDMPrivateClearKey::sanitizeResponse(const SharedBuffer& response) const
>+RefPtr<FragmentedSharedBuffer> CDMPrivateClearKey::sanitizeResponse(const FragmentedSharedBuffer& response) const
> {
>     // Validate the response buffer as an JSON object.
>     if (!CDMUtilities::parseJSONObject(response))
>@@ -431,7 +433,7 @@ void CDMInstanceClearKey::initializeWithConfiguration(const CDMKeySystemConfigur
>     callback(succeeded);
> }
> 
>-void CDMInstanceClearKey::setServerCertificate(Ref<SharedBuffer>&&, SuccessCallback&& callback)
>+void CDMInstanceClearKey::setServerCertificate(Ref<FragmentedSharedBuffer>&&, SuccessCallback&& callback)
> {
>     // Reject setting any server certificate.
>     callback(Failed);
>@@ -453,7 +455,7 @@ RefPtr<CDMInstanceSession> CDMInstanceClearKey::createSession()
>     return adoptRef(new CDMInstanceSessionClearKey(*this));
> }
> 
>-void CDMInstanceSessionClearKey::requestLicense(LicenseType, const AtomString& initDataType, Ref<SharedBuffer>&& initData, LicenseCallback&& callback)
>+void CDMInstanceSessionClearKey::requestLicense(LicenseType, const AtomString& initDataType, Ref<FragmentedSharedBuffer>&& initData, LicenseCallback&& callback)
> {
>     static uint32_t s_sessionIdValue = 0;
>     ++s_sessionIdValue;
>@@ -475,7 +477,7 @@ void CDMInstanceSessionClearKey::requestLicense(LicenseType, const AtomString& i
>         });
> }
> 
>-void CDMInstanceSessionClearKey::updateLicense(const String& sessionId, LicenseType, Ref<SharedBuffer>&& response, LicenseUpdateCallback&& callback)
>+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
>@@ -566,7 +568,7 @@ void CDMInstanceSessionClearKey::removeSessionData(const String& sessionId, Lice
>     ASSERT(sessionId == m_sessionID);
> 
>     auto dispatchCallback =
>-        [weakThis = WeakPtr { *this }, &callback](KeyStatusVector&& keyStatusVector, std::optional<Ref<SharedBuffer>>&& message, SuccessValue success) {
>+        [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)
>@@ -579,7 +581,7 @@ void CDMInstanceSessionClearKey::removeSessionData(const String& sessionId, Lice
>     // Construct the KeyStatusVector object, representing released keys, and the message in the
>     // 'license release' format.
>     KeyStatusVector keyStatusVector = m_keyStore.allKeysAs(CDMInstanceSession::KeyStatus::Released);
>-    RefPtr<SharedBuffer> message;
>+    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.
>@@ -593,14 +595,14 @@ void CDMInstanceSessionClearKey::removeSessionData(const String& sessionId, Lice
>             rootObject->setArray("kids", WTFMove(array));
>         }
> 
>-        // Copy the JSON data into a SharedBuffer object.
>+        // 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<SharedBuffer>(*message), SuccessValue::Succeeded);
>+    dispatchCallback(WTFMove(keyStatusVector), Ref<FragmentedSharedBuffer>(*message), SuccessValue::Succeeded);
> }
> 
> void CDMInstanceSessionClearKey::storeRecordOfKeyUsage(const String&)
>diff --git a/Source/WebCore/platform/encryptedmedia/clearkey/CDMClearKey.h b/Source/WebCore/platform/encryptedmedia/clearkey/CDMClearKey.h
>index 9c0747dc1bd8..9e27fe912c4d 100644
>--- a/Source/WebCore/platform/encryptedmedia/clearkey/CDMClearKey.h
>+++ b/Source/WebCore/platform/encryptedmedia/clearkey/CDMClearKey.h
>@@ -86,8 +86,8 @@ public:
>     void loadAndInitialize() final;
>     bool supportsServerCertificates() const final;
>     bool supportsSessions() const final;
>-    bool supportsInitData(const AtomString&, const SharedBuffer&) const final;
>-    RefPtr<SharedBuffer> sanitizeResponse(const SharedBuffer&) 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;
> };
> 
>@@ -99,7 +99,7 @@ public:
>     // CDMInstance
>     ImplementationType implementationType() const final { return ImplementationType::ClearKey; }
>     void initializeWithConfiguration(const CDMKeySystemConfiguration&, AllowDistinctiveIdentifiers, AllowPersistentState, SuccessCallback&&) final;
>-    void setServerCertificate(Ref<SharedBuffer>&&, SuccessCallback&&) final;
>+    void setServerCertificate(Ref<FragmentedSharedBuffer>&&, SuccessCallback&&) final;
>     void setStorageDirectory(const String&) final;
>     const String& keySystem() const final;
>     RefPtr<CDMInstanceSession> createSession() final;
>@@ -109,8 +109,8 @@ class CDMInstanceSessionClearKey final : public CDMInstanceSessionProxy {
> public:
>     CDMInstanceSessionClearKey(CDMInstanceClearKey& parent)
>         : CDMInstanceSessionProxy(parent) { }
>-    void requestLicense(LicenseType, const AtomString& initDataType, Ref<SharedBuffer>&& initData, LicenseCallback&&) final;
>-    void updateLicense(const String&, LicenseType, Ref<SharedBuffer>&&, LicenseUpdateCallback&&) final;
>+    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;
>diff --git a/Source/WebCore/platform/generic/KeyedEncoderGeneric.h b/Source/WebCore/platform/generic/KeyedEncoderGeneric.h
>index e968e985c7ee..ecf4e08c9b99 100644
>--- a/Source/WebCore/platform/generic/KeyedEncoderGeneric.h
>+++ b/Source/WebCore/platform/generic/KeyedEncoderGeneric.h
>@@ -33,7 +33,7 @@
> 
> namespace WebCore {
> 
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class KeyedEncoderGeneric final : public KeyedEncoder {
> public:
>diff --git a/Source/WebCore/platform/glib/SharedBufferGlib.cpp b/Source/WebCore/platform/glib/SharedBufferGlib.cpp
>index 8a8c10b7024c..937d1fb6f0c8 100644
>--- a/Source/WebCore/platform/glib/SharedBufferGlib.cpp
>+++ b/Source/WebCore/platform/glib/SharedBufferGlib.cpp
>@@ -26,16 +26,16 @@
> 
> namespace WebCore {
> 
>-SharedBuffer::SharedBuffer(GBytes* bytes)
>+FragmentedSharedBuffer::FragmentedSharedBuffer(GBytes* bytes)
> {
>     ASSERT(bytes);
>     m_size = g_bytes_get_size(bytes);
>     m_segments.append({ 0, DataSegment::create(GRefPtr<GBytes>(bytes)) });
> }
> 
>-Ref<SharedBuffer> SharedBuffer::create(GBytes* bytes)
>+Ref<FragmentedSharedBuffer> FragmentedSharedBuffer::create(GBytes* bytes)
> {
>-    return adoptRef(*new SharedBuffer(bytes));
>+    return adoptRef(*new FragmentedSharedBuffer(bytes));
> }
> 
> GRefPtr<GBytes> SharedBuffer::createGBytes() const
>diff --git a/Source/WebCore/platform/graphics/Font.h b/Source/WebCore/platform/graphics/Font.h
>index 7442004f00b5..82eba73bac4c 100644
>--- a/Source/WebCore/platform/graphics/Font.h
>+++ b/Source/WebCore/platform/graphics/Font.h
>@@ -59,7 +59,7 @@ namespace WebCore {
> class FontCache;
> class FontDescription;
> class GlyphPage;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> struct GlyphData;
> 
>diff --git a/Source/WebCore/platform/graphics/FontPlatformData.h b/Source/WebCore/platform/graphics/FontPlatformData.h
>index 30dfaa2d2f85..fbbccc436844 100644
>--- a/Source/WebCore/platform/graphics/FontPlatformData.h
>+++ b/Source/WebCore/platform/graphics/FontPlatformData.h
>@@ -74,7 +74,6 @@ interface IDWriteFontFace;
> namespace WebCore {
> 
> class FontDescription;
>-class SharedBuffer;
> 
> // This class is conceptually immutable. Once created, no instances should ever change (in an observable way).
> class FontPlatformData {
>diff --git a/Source/WebCore/platform/graphics/Image.cpp b/Source/WebCore/platform/graphics/Image.cpp
>index 4a853eb64953..e32a36c60761 100644
>--- a/Source/WebCore/platform/graphics/Image.cpp
>+++ b/Source/WebCore/platform/graphics/Image.cpp
>@@ -104,7 +104,7 @@ bool Image::isPostScriptResource(const String& mimeType, const URL& url)
> }
> 
> 
>-EncodedDataStatus Image::setData(RefPtr<SharedBuffer>&& data, bool allDataReceived)
>+EncodedDataStatus Image::setData(RefPtr<FragmentedSharedBuffer>&& data, bool allDataReceived)
> {
>     m_encodedImageData = WTFMove(data);
> 
>diff --git a/Source/WebCore/platform/graphics/Image.h b/Source/WebCore/platform/graphics/Image.h
>index 6a0816957aa9..655dfe73cff6 100644
>--- a/Source/WebCore/platform/graphics/Image.h
>+++ b/Source/WebCore/platform/graphics/Image.h
>@@ -70,7 +70,7 @@ class AffineTransform;
> class FloatPoint;
> class FloatSize;
> class GraphicsContext;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> struct Length;
> 
> // This class gets notified when an image creates or destroys decoded frames and when it advances animation frames.
>@@ -124,7 +124,7 @@ public:
>     virtual std::optional<IntPoint> hotSpot() const { return std::nullopt; }
>     virtual ImageOrientation orientation() const { return ImageOrientation::FromImage; }
> 
>-    WEBCORE_EXPORT EncodedDataStatus setData(RefPtr<SharedBuffer>&& data, bool allDataReceived);
>+    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
>@@ -133,8 +133,8 @@ public:
> 
>     virtual void destroyDecodedData(bool destroyAll = true) = 0;
> 
>-    SharedBuffer* data() { return m_encodedImageData.get(); }
>-    const SharedBuffer* data() const { return m_encodedImageData.get(); }
>+    FragmentedSharedBuffer* data() { return m_encodedImageData.get(); }
>+    const FragmentedSharedBuffer* data() const { return m_encodedImageData.get(); }
> 
>     virtual DestinationColorSpace colorSpace();
> 
>@@ -209,7 +209,7 @@ protected:
>     virtual Color singlePixelSolidColor() const { return Color(); }
> 
> private:
>-    RefPtr<SharedBuffer> m_encodedImageData;
>+    RefPtr<FragmentedSharedBuffer> m_encodedImageData;
>     ImageObserver* m_imageObserver;
>     std::unique_ptr<Timer> m_animationStartTimer;
> };
>diff --git a/Source/WebCore/platform/graphics/ImageBackingStore.h b/Source/WebCore/platform/graphics/ImageBackingStore.h
>index 4ddb6df83ecb..de33f1af412d 100644
>--- a/Source/WebCore/platform/graphics/ImageBackingStore.h
>+++ b/Source/WebCore/platform/graphics/ImageBackingStore.h
>@@ -66,7 +66,7 @@ public:
>             return false;
> 
>         buffer.grow(bufferSize);
>-        m_pixels = SharedBuffer::DataSegment::create(WTFMove(buffer));
>+        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);
>@@ -206,7 +206,7 @@ private:
>     {
>         ASSERT(!m_size.isEmpty() && !isOverSize(m_size));
>         Vector<uint8_t> buffer { other.m_pixels->data(), other.m_pixels->size() };
>-        m_pixels = SharedBuffer::DataSegment::create(WTFMove(buffer));
>+        m_pixels = FragmentedSharedBuffer::DataSegment::create(WTFMove(buffer));
>         m_pixelsPtr = reinterpret_cast<uint32_t*>(const_cast<uint8_t*>(m_pixels->data()));
>     }
> 
>@@ -233,7 +233,7 @@ private:
>         return PackedColor::ARGB { result }.value;
>     }
> 
>-    RefPtr<SharedBuffer::DataSegment> m_pixels;
>+    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
>diff --git a/Source/WebCore/platform/graphics/ImageDecoder.cpp b/Source/WebCore/platform/graphics/ImageDecoder.cpp
>index 0869e99a0088..7c54947f4d81 100644
>--- a/Source/WebCore/platform/graphics/ImageDecoder.cpp
>+++ b/Source/WebCore/platform/graphics/ImageDecoder.cpp
>@@ -82,7 +82,7 @@ void ImageDecoder::clearFactories()
> }
> #endif
> 
>-RefPtr<ImageDecoder> ImageDecoder::create(SharedBuffer& data, const String& mimeType, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
>+RefPtr<ImageDecoder> ImageDecoder::create(FragmentedSharedBuffer& data, const String& mimeType, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
> {
>     UNUSED_PARAM(mimeType);
> 
>diff --git a/Source/WebCore/platform/graphics/ImageDecoder.h b/Source/WebCore/platform/graphics/ImageDecoder.h
>index a1a08adc175d..6a8ffcb60fc1 100644
>--- a/Source/WebCore/platform/graphics/ImageDecoder.h
>+++ b/Source/WebCore/platform/graphics/ImageDecoder.h
>@@ -37,12 +37,12 @@
> 
> namespace WebCore {
> 
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class ImageDecoder : public ThreadSafeRefCounted<ImageDecoder> {
>     WTF_MAKE_FAST_ALLOCATED;
> public:
>-    static RefPtr<ImageDecoder> create(SharedBuffer&, const String& mimeType, AlphaOption, GammaAndColorProfileOption);
>+    static RefPtr<ImageDecoder> create(FragmentedSharedBuffer&, const String& mimeType, AlphaOption, GammaAndColorProfileOption);
>     virtual ~ImageDecoder() = default;
> 
>     enum class MediaType {
>@@ -91,7 +91,7 @@ public:
> #if ENABLE(GPU_PROCESS)
>     using SupportsMediaTypeFunc = Function<bool(MediaType)>;
>     using CanDecodeTypeFunc = Function<bool(const String&)>;
>-    using CreateImageDecoderFunc = Function<RefPtr<ImageDecoder>(SharedBuffer&, const String&, AlphaOption, GammaAndColorProfileOption)>;
>+    using CreateImageDecoderFunc = Function<RefPtr<ImageDecoder>(FragmentedSharedBuffer&, const String&, AlphaOption, GammaAndColorProfileOption)>;
> 
>     struct ImageDecoderFactory {
>         SupportsMediaTypeFunc supportsMediaType;
>@@ -129,7 +129,7 @@ public:
>     virtual PlatformImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, const DecodingOptions& = DecodingOptions(DecodingMode::Synchronous)) = 0;
> 
>     virtual void setExpectedContentSize(long long) { }
>-    virtual void setData(SharedBuffer&, bool allDataReceived) = 0;
>+    virtual void setData(FragmentedSharedBuffer&, bool allDataReceived) = 0;
>     virtual bool isAllDataReceived() const = 0;
>     virtual void clearFrameBufferCache(size_t) = 0;
> 
>diff --git a/Source/WebCore/platform/graphics/ImageSource.cpp b/Source/WebCore/platform/graphics/ImageSource.cpp
>index d81c48019284..307743315a41 100644
>--- a/Source/WebCore/platform/graphics/ImageSource.cpp
>+++ b/Source/WebCore/platform/graphics/ImageSource.cpp
>@@ -72,7 +72,7 @@ ImageSource::~ImageSource()
>     ASSERT(&m_runLoop == &RunLoop::current());
> }
> 
>-bool ImageSource::ensureDecoderAvailable(SharedBuffer* data)
>+bool ImageSource::ensureDecoderAvailable(FragmentedSharedBuffer* data)
> {
>     if (!data || isDecoderAvailable())
>         return true;
>@@ -96,7 +96,7 @@ bool ImageSource::ensureDecoderAvailable(SharedBuffer* data)
>     return true;
> }
> 
>-void ImageSource::setData(SharedBuffer* data, bool allDataReceived)
>+void ImageSource::setData(FragmentedSharedBuffer* data, bool allDataReceived)
> {
>     if (!data || !ensureDecoderAvailable(data))
>         return;
>@@ -104,13 +104,13 @@ void ImageSource::setData(SharedBuffer* data, bool allDataReceived)
>     m_decoder->setData(*data, allDataReceived);
> }
> 
>-void ImageSource::resetData(SharedBuffer* data)
>+void ImageSource::resetData(FragmentedSharedBuffer* data)
> {
>     m_decoder = nullptr;
>     setData(data, isAllDataReceived());
> }
> 
>-EncodedDataStatus ImageSource::dataChanged(SharedBuffer* data, bool allDataReceived)
>+EncodedDataStatus ImageSource::dataChanged(FragmentedSharedBuffer* data, bool allDataReceived)
> {
>     setData(data, allDataReceived);
>     clearMetadata();
>diff --git a/Source/WebCore/platform/graphics/ImageSource.h b/Source/WebCore/platform/graphics/ImageSource.h
>index 8af5080a00a9..814f0e12ebaa 100644
>--- a/Source/WebCore/platform/graphics/ImageSource.h
>+++ b/Source/WebCore/platform/graphics/ImageSource.h
>@@ -39,7 +39,7 @@ namespace WebCore {
> class BitmapImage;
> class GraphicsContext;
> class ImageDecoder;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class ImageSource : public ThreadSafeRefCounted<ImageSource>, public CanMakeWeakPtr<ImageSource> {
>     friend class BitmapImage;
>@@ -56,9 +56,9 @@ public:
>         return adoptRef(*new ImageSource(WTFMove(nativeImage)));
>     }
> 
>-    void setData(SharedBuffer* data, bool allDataReceived);
>-    void resetData(SharedBuffer* data);
>-    EncodedDataStatus dataChanged(SharedBuffer* data, bool allDataReceived);
>+    void setData(FragmentedSharedBuffer* data, bool allDataReceived);
>+    void resetData(FragmentedSharedBuffer* data);
>+    EncodedDataStatus dataChanged(FragmentedSharedBuffer* data, bool allDataReceived);
>     bool isAllDataReceived();
> 
>     unsigned decodedSize() const { return m_decodedSize; }
>@@ -154,7 +154,7 @@ private:
>     template<typename T>
>     T firstFrameMetadataCacheIfNeeded(T& cachedValue, MetadataType, T (ImageFrame::*functor)() const, ImageFrame::Caching, const std::optional<SubsamplingLevel>& = { });
> 
>-    bool ensureDecoderAvailable(SharedBuffer* data);
>+    bool ensureDecoderAvailable(FragmentedSharedBuffer* data);
>     bool isDecoderAvailable() const { return m_decoder; }
>     void destroyDecodedData(size_t frameCount, size_t excludeFrame);
>     void decodedSizeChanged(long long decodedSize);
>diff --git a/Source/WebCore/platform/graphics/Model.cpp b/Source/WebCore/platform/graphics/Model.cpp
>index 3e59ea9d08dd..577bd508a5c4 100644
>--- a/Source/WebCore/platform/graphics/Model.cpp
>+++ b/Source/WebCore/platform/graphics/Model.cpp
>@@ -30,12 +30,12 @@
> 
> namespace WebCore {
> 
>-Ref<Model> Model::create(Ref<SharedBuffer> data, String mimeType, URL url)
>+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)
>+Model::Model(Ref<SharedBuffer>&& data, String mimeType, URL url)
>     : m_data(WTFMove(data))
>     , m_mimeType(WTFMove(mimeType))
>     , m_url(WTFMove(url))
>diff --git a/Source/WebCore/platform/graphics/Model.h b/Source/WebCore/platform/graphics/Model.h
>index 065813379f11..e6bde166f944 100644
>--- a/Source/WebCore/platform/graphics/Model.h
>+++ b/Source/WebCore/platform/graphics/Model.h
>@@ -38,7 +38,7 @@ namespace WebCore {
> 
> class Model final : public RefCounted<Model> {
> public:
>-    WEBCORE_EXPORT static Ref<Model> create(Ref<SharedBuffer>, String, URL);
>+    WEBCORE_EXPORT static Ref<Model> create(Ref<SharedBuffer>&&, String, URL);
>     WEBCORE_EXPORT ~Model();
> 
>     Ref<SharedBuffer> data() const { return m_data; }
>@@ -49,7 +49,7 @@ public:
>     template<class Decoder> static RefPtr<Model> decode(Decoder&);
> 
> private:
>-    explicit Model(Ref<SharedBuffer>, String, URL);
>+    explicit Model(Ref<SharedBuffer>&&, String, URL);
> 
>     Ref<SharedBuffer> m_data;
>     String m_mimeType;
>@@ -60,7 +60,7 @@ template<class Encoder>
> void Model::encode(Encoder& encoder) const
> {
>     encoder << static_cast<size_t>(m_data->size());
>-    encoder.encodeFixedLengthData(m_data->data(), m_data->size(), 1);
>+    encoder.encodeFixedLengthData(m_data->makeContiguous()->data(), m_data->size(), 1);
>     encoder << m_mimeType;
>     encoder << m_url;
> }
>diff --git a/Source/WebCore/platform/graphics/PlatformMediaResourceLoader.h b/Source/WebCore/platform/graphics/PlatformMediaResourceLoader.h
>index 7459c5858d24..88691dc256d6 100644
>--- a/Source/WebCore/platform/graphics/PlatformMediaResourceLoader.h
>+++ b/Source/WebCore/platform/graphics/PlatformMediaResourceLoader.h
>@@ -51,8 +51,8 @@ public:
>     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<SharedBuffer>&&) { RELEASE_ASSERT_NOT_REACHED(); }
>-    // This method should be removed once CachedRawResourceClient uses SharedBuffer.
>+    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&) { }
>diff --git a/Source/WebCore/platform/graphics/avfoundation/CDMFairPlayStreaming.cpp b/Source/WebCore/platform/graphics/avfoundation/CDMFairPlayStreaming.cpp
>index c6112e1194c7..8b04f9be96c3 100644
>--- a/Source/WebCore/platform/graphics/avfoundation/CDMFairPlayStreaming.cpp
>+++ b/Source/WebCore/platform/graphics/avfoundation/CDMFairPlayStreaming.cpp
>@@ -86,12 +86,12 @@ const AtomString& CDMPrivateFairPlayStreaming::skdName()
>     return skd;
> }
> 
>-static Vector<Ref<SharedBuffer>> extractSinfData(const SharedBuffer& buffer)
>+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.data(), static_cast<unsigned>(buffer.size()) };
>+    String json { buffer.makeContiguous()->data(), static_cast<unsigned>(buffer.size()) };
> 
>     auto value = JSON::Value::parseJSON(json);
>     if (!value)
>@@ -105,7 +105,7 @@ static Vector<Ref<SharedBuffer>> extractSinfData(const SharedBuffer& buffer)
>     if (!sinfArray)
>         return { };
> 
>-    Vector<Ref<SharedBuffer>> sinfs;
>+    Vector<Ref<FragmentedSharedBuffer>> sinfs;
>     sinfs.reserveInitialCapacity(sinfArray->length());
> 
>     for (auto& value : *sinfArray) {
>@@ -124,7 +124,7 @@ static Vector<Ref<SharedBuffer>> extractSinfData(const SharedBuffer& buffer)
> }
> 
> using SchemeAndKeyResult = Vector<std::pair<FourCC, Vector<uint8_t>>>;
>-static SchemeAndKeyResult extractSchemeAndKeyIdFromSinf(const SharedBuffer& buffer)
>+static SchemeAndKeyResult extractSchemeAndKeyIdFromSinf(const FragmentedSharedBuffer& buffer)
> {
>     auto buffers = extractSinfData(buffer);
>     if (!buffers.size())
>@@ -170,9 +170,9 @@ static SchemeAndKeyResult extractSchemeAndKeyIdFromSinf(const SharedBuffer& buff
>     return result;
> }
> 
>-std::optional<Vector<Ref<SharedBuffer>>> CDMPrivateFairPlayStreaming::extractKeyIDsSinf(const SharedBuffer& buffer)
>+std::optional<Vector<Ref<FragmentedSharedBuffer>>> CDMPrivateFairPlayStreaming::extractKeyIDsSinf(const FragmentedSharedBuffer& buffer)
> {
>-    Vector<Ref<SharedBuffer>> keyIDs;
>+    Vector<Ref<FragmentedSharedBuffer>> keyIDs;
>     auto results = extractSchemeAndKeyIdFromSinf(buffer);
> 
>     for (auto& result : results) {
>@@ -183,7 +183,7 @@ std::optional<Vector<Ref<SharedBuffer>>> CDMPrivateFairPlayStreaming::extractKey
>     return keyIDs;
> }
> 
>-RefPtr<SharedBuffer> CDMPrivateFairPlayStreaming::sanitizeSinf(const SharedBuffer& buffer)
>+RefPtr<FragmentedSharedBuffer> CDMPrivateFairPlayStreaming::sanitizeSinf(const FragmentedSharedBuffer& buffer)
> {
>     // Common SINF Box Format
>     UNUSED_PARAM(buffer);
>@@ -191,17 +191,17 @@ RefPtr<SharedBuffer> CDMPrivateFairPlayStreaming::sanitizeSinf(const SharedBuffe
>     return buffer.copy();
> }
> 
>-RefPtr<SharedBuffer> CDMPrivateFairPlayStreaming::sanitizeSkd(const SharedBuffer& buffer)
>+RefPtr<FragmentedSharedBuffer> CDMPrivateFairPlayStreaming::sanitizeSkd(const FragmentedSharedBuffer& buffer)
> {
>     UNUSED_PARAM(buffer);
>     notImplemented();
>     return buffer.copy();
> }
> 
>-std::optional<Vector<Ref<SharedBuffer>>> CDMPrivateFairPlayStreaming::extractKeyIDsSkd(const SharedBuffer& buffer)
>+std::optional<Vector<Ref<FragmentedSharedBuffer>>> CDMPrivateFairPlayStreaming::extractKeyIDsSkd(const FragmentedSharedBuffer& buffer)
> {
>     // In the 'skd' scheme, the init data is the key ID.
>-    Vector<Ref<SharedBuffer>> keyIDs;
>+    Vector<Ref<FragmentedSharedBuffer>> keyIDs;
>     keyIDs.append(buffer.copy());
>     return keyIDs;
> }
>@@ -393,7 +393,7 @@ bool CDMPrivateFairPlayStreaming::supportsSessions() const
>     return true;
> }
> 
>-bool CDMPrivateFairPlayStreaming::supportsInitData(const AtomString& initDataType, const SharedBuffer& initData) const
>+bool CDMPrivateFairPlayStreaming::supportsInitData(const AtomString& initDataType, const FragmentedSharedBuffer& initData) const
> {
>     if (!validInitDataTypes().contains(initDataType))
>         return false;
>@@ -423,7 +423,7 @@ bool CDMPrivateFairPlayStreaming::supportsInitData(const AtomString& initDataTyp
>     return false;
> }
> 
>-RefPtr<SharedBuffer> CDMPrivateFairPlayStreaming::sanitizeResponse(const SharedBuffer& response) const
>+RefPtr<FragmentedSharedBuffer> CDMPrivateFairPlayStreaming::sanitizeResponse(const FragmentedSharedBuffer& response) const
> {
>     return response.copy();
> }
>diff --git a/Source/WebCore/platform/graphics/avfoundation/CDMFairPlayStreaming.h b/Source/WebCore/platform/graphics/avfoundation/CDMFairPlayStreaming.h
>index bc93f6f6a7bd..317bb8d57e86 100644
>--- a/Source/WebCore/platform/graphics/avfoundation/CDMFairPlayStreaming.h
>+++ b/Source/WebCore/platform/graphics/avfoundation/CDMFairPlayStreaming.h
>@@ -71,17 +71,17 @@ public:
>     void loadAndInitialize() override;
>     bool supportsServerCertificates() const override;
>     bool supportsSessions() const override;
>-    bool supportsInitData(const AtomString&, const SharedBuffer&) const override;
>-    RefPtr<SharedBuffer> sanitizeResponse(const SharedBuffer&) 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<SharedBuffer>>> extractKeyIDsSinf(const SharedBuffer&);
>-    static RefPtr<SharedBuffer> sanitizeSinf(const SharedBuffer&);
>+    static std::optional<Vector<Ref<FragmentedSharedBuffer>>> extractKeyIDsSinf(const FragmentedSharedBuffer&);
>+    static RefPtr<FragmentedSharedBuffer> sanitizeSinf(const FragmentedSharedBuffer&);
> 
>     static const AtomString& skdName();
>-    static std::optional<Vector<Ref<SharedBuffer>>> extractKeyIDsSkd(const SharedBuffer&);
>-    static RefPtr<SharedBuffer> sanitizeSkd(const SharedBuffer&);
>+    static std::optional<Vector<Ref<FragmentedSharedBuffer>>> extractKeyIDsSkd(const FragmentedSharedBuffer&);
>+    static RefPtr<FragmentedSharedBuffer> sanitizeSkd(const FragmentedSharedBuffer&);
> 
>     static const Vector<FourCC>& validFairPlayStreamingSchemes();
> 
>diff --git a/Source/WebCore/platform/graphics/avfoundation/objc/CDMInstanceFairPlayStreamingAVFObjC.h b/Source/WebCore/platform/graphics/avfoundation/objc/CDMInstanceFairPlayStreamingAVFObjC.h
>index 159b90cdb48f..56b58c25a287 100644
>--- a/Source/WebCore/platform/graphics/avfoundation/objc/CDMInstanceFairPlayStreamingAVFObjC.h
>+++ b/Source/WebCore/platform/graphics/avfoundation/objc/CDMInstanceFairPlayStreamingAVFObjC.h
>@@ -84,7 +84,7 @@ public:
>     ImplementationType implementationType() const final { return ImplementationType::FairPlayStreaming; }
> 
>     void initializeWithConfiguration(const CDMKeySystemConfiguration&, AllowDistinctiveIdentifiers, AllowPersistentState, SuccessCallback&&) final;
>-    void setServerCertificate(Ref<SharedBuffer>&&, SuccessCallback&&) final;
>+    void setServerCertificate(Ref<FragmentedSharedBuffer>&&, SuccessCallback&&) final;
>     void setStorageDirectory(const String&) final;
>     RefPtr<CDMInstanceSession> createSession() final;
>     void setClient(WeakPtr<CDMInstanceClient>&&) final;
>@@ -94,10 +94,10 @@ public:
> 
>     NSURL *storageURL() const { return m_storageURL.get(); }
>     bool persistentStateAllowed() const { return m_persistentStateAllowed; }
>-    SharedBuffer* serverCertificate() const { return m_serverCertificate.get(); }
>+    FragmentedSharedBuffer* serverCertificate() const { return m_serverCertificate.get(); }
>     AVContentKeySession* contentKeySession();
> 
>-    RetainPtr<AVContentKeyRequest> takeUnexpectedKeyRequestForInitializationData(const AtomString& initDataType, SharedBuffer& initData);
>+    RetainPtr<AVContentKeyRequest> takeUnexpectedKeyRequestForInitializationData(const AtomString& initDataType, FragmentedSharedBuffer& initData);
> 
>     // AVContentKeySessionDelegateClient
>     void didProvideRequest(AVContentKeyRequest*) final;
>@@ -112,7 +112,7 @@ public:
>     void outputObscuredDueToInsufficientExternalProtectionChanged(bool) final;
>     void externalProtectionStatusDidChangeForContentKeyRequest(AVContentKeyRequest*) final;
> 
>-    using Keys = Vector<Ref<SharedBuffer>>;
>+    using Keys = Vector<Ref<FragmentedSharedBuffer>>;
>     CDMInstanceSessionFairPlayStreamingAVFObjC* sessionForKeyIDs(const Keys&) const;
>     CDMInstanceSessionFairPlayStreamingAVFObjC* sessionForGroup(AVContentKeyReportGroup*) const;
>     CDMInstanceSessionFairPlayStreamingAVFObjC* sessionForRequest(AVContentKeyRequest*) const;
>@@ -129,7 +129,7 @@ private:
>     WeakPtr<CDMInstanceClient> m_client;
>     RetainPtr<AVContentKeySession> m_session;
>     RetainPtr<WebCoreFPSContentKeySessionDelegate> m_delegate;
>-    RefPtr<SharedBuffer> m_serverCertificate;
>+    RefPtr<FragmentedSharedBuffer> m_serverCertificate;
>     bool m_persistentStateAllowed { true };
>     RetainPtr<NSURL> m_storageURL;
>     Vector<WeakPtr<CDMInstanceSessionFairPlayStreamingAVFObjC>> m_sessions;
>@@ -150,8 +150,8 @@ public:
> #endif
> 
>     // CDMInstanceSession
>-    void requestLicense(LicenseType, const AtomString& initDataType, Ref<SharedBuffer>&& initData, LicenseCallback&&) final;
>-    void updateLicense(const String&, LicenseType, Ref<SharedBuffer>&&, LicenseUpdateCallback&&) final;
>+    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;
>diff --git a/Source/WebCore/platform/graphics/avfoundation/objc/CDMInstanceFairPlayStreamingAVFObjC.mm b/Source/WebCore/platform/graphics/avfoundation/objc/CDMInstanceFairPlayStreamingAVFObjC.mm
>index e9f2aa335db9..ba5061ebb5c5 100644
>--- a/Source/WebCore/platform/graphics/avfoundation/objc/CDMInstanceFairPlayStreamingAVFObjC.mm
>+++ b/Source/WebCore/platform/graphics/avfoundation/objc/CDMInstanceFairPlayStreamingAVFObjC.mm
>@@ -217,7 +217,7 @@ ALLOW_NEW_API_WITHOUT_GUARDS_END
>     return AtomString(nsInitType);
> }
> 
>-static Ref<SharedBuffer> initializationDataForRequest(AVContentKeyRequest* request)
>+static Ref<FragmentedSharedBuffer> initializationDataForRequest(AVContentKeyRequest* request)
> {
>     if (!request)
>         return SharedBuffer::create();
>@@ -265,7 +265,7 @@ AVContentKeySession* CDMInstanceFairPlayStreamingAVFObjC::contentKeySession()
>     return m_session.get();
> }
> 
>-RetainPtr<AVContentKeyRequest> CDMInstanceFairPlayStreamingAVFObjC::takeUnexpectedKeyRequestForInitializationData(const AtomString& initDataType, SharedBuffer& initData)
>+RetainPtr<AVContentKeyRequest> CDMInstanceFairPlayStreamingAVFObjC::takeUnexpectedKeyRequestForInitializationData(const AtomString& initDataType, FragmentedSharedBuffer& initData)
> {
>     for (auto requestIter = m_unexpectedKeyRequests.begin(); requestIter != m_unexpectedKeyRequests.end(); ++requestIter) {
>         auto& request = *requestIter;
>@@ -316,7 +316,7 @@ private:
>     ResponseMap m_responses;
> };
> 
>-static RefPtr<JSON::Value> parseJSONValue(const SharedBuffer& buffer)
>+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();
>@@ -324,7 +324,7 @@ static RefPtr<JSON::Value> parseJSONValue(const SharedBuffer& buffer)
>         return nullptr;
> 
>     // Parse the buffer contents as JSON, returning the root object (if any).
>-    String json { buffer.data(), static_cast<unsigned>(size) };
>+    String json { buffer.makeContiguous()->data(), static_cast<unsigned>(size) };
> 
>     return JSON::Value::parseJSON(json);
> }
>@@ -380,7 +380,7 @@ void CDMInstanceFairPlayStreamingAVFObjC::initializeWithConfiguration(const CDMK
>     callback(initialize());
> }
> 
>-void CDMInstanceFairPlayStreamingAVFObjC::setServerCertificate(Ref<SharedBuffer>&& serverCertificate, SuccessCallback&& callback)
>+void CDMInstanceFairPlayStreamingAVFObjC::setServerCertificate(Ref<FragmentedSharedBuffer>&& serverCertificate, SuccessCallback&& callback)
> {
>     DEBUG_LOG_IF_POSSIBLE(LOGIDENTIFIER);
>     m_serverCertificate = WTFMove(serverCertificate);
>@@ -585,8 +585,8 @@ CDMInstanceSessionFairPlayStreamingAVFObjC* CDMInstanceFairPlayStreamingAVFObjC:
>             continue;
> 
>         auto sessionKeys = sessionInterface->keyIDs();
>-        if (anyOf(sessionKeys, [&](const Ref<SharedBuffer>& sessionKey) {
>-            return keyIDs.findMatching([&](const Ref<SharedBuffer>& keyID) {
>+        if (anyOf(sessionKeys, [&](const Ref<FragmentedSharedBuffer>& sessionKey) {
>+            return keyIDs.findMatching([&](const Ref<FragmentedSharedBuffer>& keyID) {
>                 return keyID.get() == sessionKey.get();
>             }) != notFound;
>         }))
>@@ -673,7 +673,7 @@ Keys CDMInstanceSessionFairPlayStreamingAVFObjC::keyIDs()
>     return keyIDs;
> }
> 
>-void CDMInstanceSessionFairPlayStreamingAVFObjC::requestLicense(LicenseType licenseType, const AtomString& initDataType, Ref<SharedBuffer>&& initData, LicenseCallback&& callback)
>+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");
>@@ -709,12 +709,12 @@ void CDMInstanceSessionFairPlayStreamingAVFObjC::requestLicense(LicenseType lice
>     RetainPtr<NSData> initializationData;
> 
>     if (initDataType == CDMPrivateFairPlayStreaming::sinfName())
>-        initializationData = initData->createNSData();
>+        initializationData = initData->makeContiguous()->createNSData();
>     else if (initDataType == CDMPrivateFairPlayStreaming::skdName())
>-        identifier = adoptNS([[NSString alloc] initWithData:initData->createNSData().get() encoding:NSUTF8StringEncoding]);
>+        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->data(), initData->size());
>+        auto psshString = base64EncodeToString(initData->makeContiguous()->data(), initData->size());
>         initializationData = [NSJSONSerialization dataWithJSONObject:@{ @"pssh": (NSString*)psshString } options:NSJSONWritingPrettyPrinted error:nil];
>     }
> #endif
>@@ -736,7 +736,7 @@ void CDMInstanceSessionFairPlayStreamingAVFObjC::requestLicense(LicenseType lice
>     }
> }
> 
>-static bool isEqual(const SharedBuffer& data, const String& value)
>+static bool isEqual(const FragmentedSharedBuffer& data, const String& value)
> {
>     auto arrayBuffer = data.tryCreateArrayBuffer();
>     if (!arrayBuffer)
>@@ -754,7 +754,7 @@ static bool isEqual(const SharedBuffer& data, const String& value)
>     return stringOrException.returnValue() == value;
> }
> 
>-void CDMInstanceSessionFairPlayStreamingAVFObjC::updateLicense(const String&, LicenseType, Ref<SharedBuffer>&& responseData, LicenseUpdateCallback&& callback)
>+void CDMInstanceSessionFairPlayStreamingAVFObjC::updateLicense(const String&, LicenseType, Ref<FragmentedSharedBuffer>&& responseData, LicenseUpdateCallback&& callback)
> {
>     if (!m_expiredSessions.isEmpty() && isEqual(responseData, "acknowledged"_s)) {
>         auto* certificate = m_instance->serverCertificate();
>@@ -770,7 +770,7 @@ void CDMInstanceSessionFairPlayStreamingAVFObjC::updateLicense(const String&, Li
>         auto expiredSessions = createNSArray(m_expiredSessions, [] (auto& data) {
>             return data.get();
>         });
>-        auto appIdentifier = certificate->createNSData();
>+        auto appIdentifier = certificate->makeContiguous()->createNSData();
>         [PAL::getAVContentKeySessionClass() removePendingExpiredSessionReports:expiredSessions.get() withAppIdentifier:appIdentifier.get() storageDirectoryAtURL:storageURL];
>         callback(false, { }, std::nullopt, std::nullopt, Succeeded);
>         return;
>@@ -856,7 +856,7 @@ void CDMInstanceSessionFairPlayStreamingAVFObjC::updateLicense(const String&, Li
>             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<SharedBuffer>& id) {
>+                return keyIDs.findMatching([&](const Ref<FragmentedSharedBuffer>& id) {
>                     return id.get() == keyID.get();
>                 }) != notFound;
>             });
>@@ -888,7 +888,7 @@ void CDMInstanceSessionFairPlayStreamingAVFObjC::updateLicense(const String&, Li
>                 if (!payloadVector)
>                     return false;
>                 auto payloadData = SharedBuffer::create(WTFMove(*payloadVector));
>-                [request processContentKeyResponse:[PAL::getAVContentKeyResponseClass() contentKeyResponseWithFairPlayStreamingKeyResponseData:payloadData->createNSData().get()]];
>+                [request processContentKeyResponse:[PAL::getAVContentKeyResponseClass() contentKeyResponseWithFairPlayStreamingKeyResponseData:payloadData->makeContiguous()->createNSData().get()]];
>             }
>             return true;
>         };
>@@ -901,7 +901,7 @@ void CDMInstanceSessionFairPlayStreamingAVFObjC::updateLicense(const String&, Li
>         }
>     } else {
>         DEBUG_LOG_IF_POSSIBLE(LOGIDENTIFIER, "'sinf' initData, processing response");
>-        [m_currentRequest.value().requests.first() processContentKeyResponse:[PAL::getAVContentKeyResponseClass() contentKeyResponseWithFairPlayStreamingKeyResponseData:responseData->createNSData().get()]];
>+        [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.
>@@ -934,7 +934,7 @@ void CDMInstanceSessionFairPlayStreamingAVFObjC::loadSession(LicenseType license
>             return;
>         }
> 
>-        RetainPtr<NSData> appIdentifier = certificate->createNSData();
>+        RetainPtr<NSData> appIdentifier = certificate->makeContiguous()->createNSData();
>         KeyStatusVector changedKeys;
>         for (NSData* expiredSessionData in [PAL::getAVContentKeySessionClass() pendingExpiredSessionReportsWithAppIdentifier:appIdentifier.get() storageDirectoryAtURL:storageURL]) {
>             static const NSString *PlaybackSessionIdKey = @"PlaybackSessionID";
>@@ -999,7 +999,7 @@ void CDMInstanceSessionFairPlayStreamingAVFObjC::removeSessionData(const String&
>             return;
>         }
> 
>-        RetainPtr<NSData> appIdentifier = certificate->createNSData();
>+        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]) {
>@@ -1086,7 +1086,7 @@ void CDMInstanceSessionFairPlayStreamingAVFObjC::didProvideRequest(AVContentKeyR
> 
>     RetainPtr<NSData> appIdentifier;
>     if (auto* certificate = m_instance->serverCertificate())
>-        appIdentifier = certificate->createNSData();
>+        appIdentifier = certificate->makeContiguous()->createNSData();
> 
>     auto keyIDs = keyIDsForRequest(request);
>     if (keyIDs.isEmpty()) {
>@@ -1097,7 +1097,7 @@ void CDMInstanceSessionFairPlayStreamingAVFObjC::didProvideRequest(AVContentKeyR
>         return;
>     }
> 
>-    RetainPtr<NSData> contentIdentifier = keyIDs.first()->createNSData();
>+    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)] {
>@@ -1153,9 +1153,9 @@ void CDMInstanceSessionFairPlayStreamingAVFObjC::didProvideRequests(Vector<Retai
> 
>     RetainPtr<NSData> appIdentifier;
>     if (auto* certificate = m_instance->serverCertificate())
>-        appIdentifier = certificate->createNSData();
>+        appIdentifier = certificate->makeContiguous()->createNSData();
> 
>-    using RequestsData = Vector<std::pair<RefPtr<SharedBuffer>, RetainPtr<NSData>>>;
>+    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)
>@@ -1196,7 +1196,7 @@ void CDMInstanceSessionFairPlayStreamingAVFObjC::didProvideRequests(Vector<Retai
>             auto entry = JSON::Object::create();
>             auto& keyID = requestData.first;
>             auto& payload = requestData.second;
>-            entry->setString("keyID", base64EncodeToString(keyID->data(), keyID->size()));
>+            entry->setString("keyID", base64EncodeToString(keyID->makeContiguous()->data(), keyID->size()));
>             entry->setString("payload", base64EncodeToString(payload.get().bytes, payload.get().length));
>             requestJSON->pushObject(WTFMove(entry));
>         }
>@@ -1211,8 +1211,8 @@ void CDMInstanceSessionFairPlayStreamingAVFObjC::didProvideRequests(Vector<Retai
>     @try {
>         for (auto request : m_currentRequest.value().requests) {
>             auto keyIDs = keyIDsForRequest(request.get());
>-            RefPtr<SharedBuffer> keyID = WTFMove(keyIDs.first());
>-            auto contentIdentifier = keyID->createNSData();
>+            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 {
>@@ -1249,10 +1249,10 @@ void CDMInstanceSessionFairPlayStreamingAVFObjC::didProvideRenewingRequest(AVCon
> 
>     RetainPtr<NSData> appIdentifier;
>     if (auto* certificate = m_instance->serverCertificate())
>-        appIdentifier = certificate->createNSData();
>+        appIdentifier = certificate->makeContiguous()->createNSData();
>     auto keyIDs = keyIDsForRequest(m_currentRequest.value());
> 
>-    RetainPtr<NSData> contentIdentifier = keyIDs.first()->createNSData();
>+    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)] {
>diff --git a/Source/WebCore/platform/graphics/avfoundation/objc/ImageDecoderAVFObjC.h b/Source/WebCore/platform/graphics/avfoundation/objc/ImageDecoderAVFObjC.h
>index 0334d623b2a7..62b83fbfd579 100644
>--- a/Source/WebCore/platform/graphics/avfoundation/objc/ImageDecoderAVFObjC.h
>+++ b/Source/WebCore/platform/graphics/avfoundation/objc/ImageDecoderAVFObjC.h
>@@ -53,7 +53,7 @@ class WebCoreDecompressionSession;
> 
> class ImageDecoderAVFObjC : public ImageDecoder {
> public:
>-    WEBCORE_EXPORT static RefPtr<ImageDecoderAVFObjC> create(SharedBuffer&, const String& mimeType, AlphaOption, GammaAndColorProfileOption);
>+    WEBCORE_EXPORT static RefPtr<ImageDecoderAVFObjC> create(FragmentedSharedBuffer&, const String& mimeType, AlphaOption, GammaAndColorProfileOption);
>     virtual ~ImageDecoderAVFObjC();
> 
>     WEBCORE_EXPORT static bool supportsMediaType(MediaType);
>@@ -86,7 +86,7 @@ public:
>     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(SharedBuffer&, bool allDataReceived) final;
>+    WEBCORE_EXPORT void setData(FragmentedSharedBuffer&, bool allDataReceived) final;
>     bool isAllDataReceived() const final { return m_isAllDataReceived; }
>     WEBCORE_EXPORT void clearFrameBufferCache(size_t) final;
> 
>@@ -94,7 +94,7 @@ public:
>     WEBCORE_EXPORT Vector<ImageDecoder::FrameInfo> frameInfos() const;
> 
> private:
>-    ImageDecoderAVFObjC(SharedBuffer&, const String& mimeType, AlphaOption, GammaAndColorProfileOption);
>+    ImageDecoderAVFObjC(FragmentedSharedBuffer&, const String& mimeType, AlphaOption, GammaAndColorProfileOption);
> 
>     AVAssetTrack *firstEnabledTrack();
>     void readSamples();
>diff --git a/Source/WebCore/platform/graphics/avfoundation/objc/ImageDecoderAVFObjC.mm b/Source/WebCore/platform/graphics/avfoundation/objc/ImageDecoderAVFObjC.mm
>index 069516a083d5..35c6ce67e85f 100644
>--- a/Source/WebCore/platform/graphics/avfoundation/objc/ImageDecoderAVFObjC.mm
>+++ b/Source/WebCore/platform/graphics/avfoundation/objc/ImageDecoderAVFObjC.mm
>@@ -289,7 +289,7 @@ ImageDecoderAVFObjCSample* toSample(Iterator iter)
> 
> #pragma mark - ImageDecoderAVFObjC
> 
>-RefPtr<ImageDecoderAVFObjC> ImageDecoderAVFObjC::create(SharedBuffer& data, const String& mimeType, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
>+RefPtr<ImageDecoderAVFObjC> ImageDecoderAVFObjC::create(FragmentedSharedBuffer& data, const String& mimeType, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
> {
>     // AVFoundation may not be available at runtime.
>     if (!AVAssetMIMETypeCache::singleton().isAvailable())
>@@ -301,7 +301,7 @@ RefPtr<ImageDecoderAVFObjC> ImageDecoderAVFObjC::create(SharedBuffer& data, cons
>     return adoptRef(*new ImageDecoderAVFObjC(data, mimeType, alphaOption, gammaAndColorProfileOption));
> }
> 
>-ImageDecoderAVFObjC::ImageDecoderAVFObjC(SharedBuffer& data, const String& mimeType, AlphaOption, GammaAndColorProfileOption)
>+ImageDecoderAVFObjC::ImageDecoderAVFObjC(FragmentedSharedBuffer& data, const String& mimeType, AlphaOption, GammaAndColorProfileOption)
>     : ImageDecoder()
>     , m_mimeType(mimeType)
>     , m_uti(WebCore::UTIFromMIMEType(mimeType))
>@@ -309,7 +309,7 @@ ImageDecoderAVFObjC::ImageDecoderAVFObjC(SharedBuffer& data, const String& mimeT
>     , m_loader(adoptNS([[WebCoreSharedBufferResourceLoaderDelegate alloc] initWithParent:this]))
>     , m_decompressionSession(WebCoreDecompressionSession::createRGB())
> {
>-    [m_loader updateData:data.createNSData().get() complete:NO];
>+    [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 {
>@@ -641,9 +641,9 @@ void ImageDecoderAVFObjC::setExpectedContentSize(long long expectedContentSize)
>     m_loader.get().expectedContentSize = expectedContentSize;
> }
> 
>-void ImageDecoderAVFObjC::setData(SharedBuffer& data, bool allDataReceived)
>+void ImageDecoderAVFObjC::setData(FragmentedSharedBuffer& data, bool allDataReceived)
> {
>-    [m_loader updateData:data.createNSData().get() complete:allDataReceived];
>+    [m_loader updateData:data.makeContiguous()->createNSData().get() complete:allDataReceived];
> 
>     if (allDataReceived) {
>         m_isAllDataReceived = true;
>diff --git a/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.h b/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.h
>index 200e1a8f9afb..c9d9b2a9685b 100644
>--- a/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.h
>+++ b/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.h
>@@ -66,7 +66,7 @@ class InbandMetadataTextTrackPrivateAVF;
> class MediaPlaybackTarget;
> class MediaSelectionGroupAVFObjC;
> class PixelBufferConformerCV;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> class VideoLayerManagerObjC;
> class VideoTrackPrivateAVFObjC;
> class WebCoreAVFResourceLoader;
>@@ -426,7 +426,7 @@ private:
>     mutable std::optional<WallTime> m_wallClockAtCachedCurrentTime;
>     mutable int m_timeControlStatusAtCachedCurrentTime { 0 };
>     mutable double m_requestedRateAtCachedCurrentTime { 0 };
>-    RefPtr<SharedBuffer> m_keyID;
>+    RefPtr<FragmentedSharedBuffer> m_keyID;
>     double m_cachedRate { 0 };
>     bool m_requestedPlaying { false };
>     double m_requestedRate { 1.0 };
>diff --git a/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.mm b/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.mm
>index d7cf9d4bf1fe..da1ac0d71015 100644
>--- a/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.mm
>+++ b/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.mm
>@@ -2792,7 +2792,7 @@ void MediaPlayerPrivateAVFoundationObjC::attemptToDecryptWithInstance(CDMInstanc
>     if (!m_keyID || !m_cdmInstance)
>         return;
> 
>-    auto instanceSession = m_cdmInstance->sessionForKeyIDs(Vector<Ref<SharedBuffer>>::from(*m_keyID));
>+    auto instanceSession = m_cdmInstance->sessionForKeyIDs(Vector<Ref<FragmentedSharedBuffer>>::from(*m_keyID));
>     if (!instanceSession)
>         return;
> 
>diff --git a/Source/WebCore/platform/graphics/avfoundation/objc/SourceBufferParserAVFObjC.mm b/Source/WebCore/platform/graphics/avfoundation/objc/SourceBufferParserAVFObjC.mm
>index 1a43c7ded276..abd81e5f3c1e 100644
>--- a/Source/WebCore/platform/graphics/avfoundation/objc/SourceBufferParserAVFObjC.mm
>+++ b/Source/WebCore/platform/graphics/avfoundation/objc/SourceBufferParserAVFObjC.mm
>@@ -213,7 +213,7 @@ SourceBufferParserAVFObjC::~SourceBufferParserAVFObjC()
> void SourceBufferParserAVFObjC::appendData(Segment&& segment, CompletionHandler<void()>&& completionHandler, AppendFlags flags)
> {
>     auto sharedBuffer = segment.takeSharedBuffer();
>-    auto nsData = sharedBuffer->createNSData();
>+    auto nsData = sharedBuffer->makeContiguous()->createNSData();
>     if (m_parserStateWasReset || flags == AppendFlags::Discontinuity)
>         [m_parser appendStreamData:nsData.get() withFlags:AVStreamDataParserStreamDataDiscontinuity];
>     else
>diff --git a/Source/WebCore/platform/graphics/avfoundation/objc/SourceBufferPrivateAVFObjC.h b/Source/WebCore/platform/graphics/avfoundation/objc/SourceBufferPrivateAVFObjC.h
>index 03420f138364..754b1e2eec02 100644
>--- a/Source/WebCore/platform/graphics/avfoundation/objc/SourceBufferPrivateAVFObjC.h
>+++ b/Source/WebCore/platform/graphics/avfoundation/objc/SourceBufferPrivateAVFObjC.h
>@@ -73,7 +73,7 @@ class VideoTrackPrivate;
> class AudioTrackPrivateMediaSourceAVFObjC;
> class VideoTrackPrivateMediaSourceAVFObjC;
> class WebCoreDecompressionSession;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class SourceBufferPrivateAVFObjCErrorClient {
> public:
>@@ -221,7 +221,7 @@ private:
> #endif
> #if ENABLE(ENCRYPTED_MEDIA) && HAVE(AVCONTENTKEYSESSION)
>     RefPtr<CDMInstanceFairPlayStreamingAVFObjC> m_cdmInstance;
>-    Vector<Ref<SharedBuffer>> m_keyIDs;
>+    Vector<Ref<FragmentedSharedBuffer>> m_keyIDs;
> #endif
> 
>     std::optional<FloatSize> m_cachedSize;
>diff --git a/Source/WebCore/platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.h b/Source/WebCore/platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.h
>index f0d8e71132f6..0efeeaef5b2d 100644
>--- a/Source/WebCore/platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.h
>+++ b/Source/WebCore/platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.h
>@@ -43,7 +43,7 @@ class MediaPlayerPrivateAVFoundationObjC;
> class PlatformResourceMediaLoader;
> class ResourceError;
> class ResourceResponse;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class WebCoreAVFResourceLoader : public RefCounted<WebCoreAVFResourceLoader> {
>     WTF_MAKE_NONCOPYABLE(WebCoreAVFResourceLoader); WTF_MAKE_FAST_ALLOCATED;
>@@ -65,7 +65,7 @@ private:
>     void responseReceived(const ResourceResponse&);
>     void loadFailed(const ResourceError&);
>     void loadFinished();
>-    void newDataStoredInSharedBuffer(SharedBuffer&);
>+    void newDataStoredInSharedBuffer(const FragmentedSharedBuffer&);
> 
>     MediaPlayerPrivateAVFoundationObjC* m_parent;
>     RetainPtr<AVAssetResourceLoadingRequest> m_avRequest;
>diff --git a/Source/WebCore/platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm b/Source/WebCore/platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm
>index a22a997b1107..f921f3da0e69 100644
>--- a/Source/WebCore/platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm
>+++ b/Source/WebCore/platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm
>@@ -156,14 +156,14 @@ private:
>     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<SharedBuffer>&&) 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;
>-    RefPtr<SharedBuffer> m_buffer;
>+    SharedBufferBuilder m_buffer;
> };
> 
> WeakPtr<PlatformResourceMediaLoader> PlatformResourceMediaLoader::create(WebCoreAVFResourceLoader& parent, PlatformMediaResourceLoader& loader, ResourceRequest&& request)
>@@ -211,13 +211,10 @@ void PlatformResourceMediaLoader::loadFinished()
>     m_parent.loadFinished();
> }
> 
>-void PlatformResourceMediaLoader::dataReceived(PlatformMediaResource&, Ref<SharedBuffer>&& buffer)
>+void PlatformResourceMediaLoader::dataReceived(PlatformMediaResource&, Ref<FragmentedSharedBuffer>&& buffer)
> {
>-    if (!m_buffer)
>-        m_buffer = WTFMove(buffer);
>-    else
>-        m_buffer->append(WTFMove(buffer));
>-    m_parent.newDataStoredInSharedBuffer(*m_buffer);
>+    m_buffer.append(WTFMove(buffer));
>+    m_parent.newDataStoredInSharedBuffer(*m_buffer.get());
> }
> 
> class DataURLResourceMediaLoader : public CanMakeWeakPtr<DataURLResourceMediaLoader> {
>@@ -388,7 +385,7 @@ void WebCoreAVFResourceLoader::loadFinished()
>     stopLoading();
> }
> 
>-void WebCoreAVFResourceLoader::newDataStoredInSharedBuffer(SharedBuffer& data)
>+void WebCoreAVFResourceLoader::newDataStoredInSharedBuffer(const FragmentedSharedBuffer& data)
> {
>     AVAssetResourceLoadingDataRequest* dataRequest = [m_avRequest dataRequest];
>     if (!dataRequest)
>diff --git a/Source/WebCore/platform/graphics/cairo/FontCustomPlatformData.h b/Source/WebCore/platform/graphics/cairo/FontCustomPlatformData.h
>index db457a81d3ee..9419bcea38db 100644
>--- a/Source/WebCore/platform/graphics/cairo/FontCustomPlatformData.h
>+++ b/Source/WebCore/platform/graphics/cairo/FontCustomPlatformData.h
>@@ -31,10 +31,11 @@ typedef struct FT_FaceRec_*  FT_Face;
> 
> namespace WebCore {
> 
>+class SharedBuffer;
> class FontCreationContext;
> class FontDescription;
> class FontPlatformData;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> struct FontSelectionSpecifiedCapabilities;
> struct FontVariantSettings;
> 
>@@ -45,7 +46,7 @@ struct FontCustomPlatformData {
>     WTF_MAKE_FAST_ALLOCATED;
>     WTF_MAKE_NONCOPYABLE(FontCustomPlatformData);
> public:
>-    FontCustomPlatformData(FT_Face, SharedBuffer&);
>+    FontCustomPlatformData(FT_Face, FragmentedSharedBuffer&);
>     ~FontCustomPlatformData() = default;
>     FontPlatformData fontPlatformData(const FontDescription&, bool bold, bool italic, const FontCreationContext&);
>     static bool supportsFormat(const String&);
>diff --git a/Source/WebCore/platform/graphics/cg/ImageDecoderCG.cpp b/Source/WebCore/platform/graphics/cg/ImageDecoderCG.cpp
>index a344bbecda9f..b6d3eb363112 100644
>--- a/Source/WebCore/platform/graphics/cg/ImageDecoderCG.cpp
>+++ b/Source/WebCore/platform/graphics/cg/ImageDecoderCG.cpp
>@@ -244,16 +244,16 @@ size_t sharedBufferGetBytesAtPosition(void* info, void* buffer, off_t position,
> 
> void sharedBufferRelease(void* info)
> {
>-    SharedBuffer* sharedBuffer = static_cast<SharedBuffer*>(info);
>+    FragmentedSharedBuffer* sharedBuffer = static_cast<FragmentedSharedBuffer*>(info);
>     sharedBuffer->deref();
> }
> #endif
> 
>-ImageDecoderCG::ImageDecoderCG(SharedBuffer& data, AlphaOption, GammaAndColorProfileOption)
>+ImageDecoderCG::ImageDecoderCG(FragmentedSharedBuffer& data, AlphaOption, GammaAndColorProfileOption)
> {
>     RetainPtr<CFStringRef> utiHint;
>     if (data.size() >= 32)
>-        utiHint = adoptCF(CGImageSourceGetTypeWithData(data.createCFData().get(), nullptr, nullptr));
>+        utiHint = adoptCF(CGImageSourceGetTypeWithData(data.makeContiguous()->createCFData().get(), nullptr, nullptr));
>     
>     if (utiHint) {
>         const void* key = kCGImageSourceTypeIdentifierHint;
>@@ -562,23 +562,24 @@ PlatformImagePtr ImageDecoderCG::createFrameImageAtIndex(size_t index, Subsampli
>     return maskedImage ? maskedImage : image;
> }
> 
>-void ImageDecoderCG::setData(SharedBuffer& data, bool allDataReceived)
>+void ImageDecoderCG::setData(FragmentedSharedBuffer& data, bool allDataReceived)
> {
>     m_isAllDataReceived = allDataReceived;
> 
> #if PLATFORM(COCOA)
>-    // On Mac the NSData inside the SharedBuffer can be secretly appended to without the SharedBuffer's knowledge.
>-    // We use SharedBuffer's ability to wrap itself inside CFData to get around this, ensuring that ImageIO is
>-    // really looking at the SharedBuffer.
>-    CGImageSourceUpdateData(m_nativeDecoder.get(), data.createCFData().get(), allDataReceived);
>+    // 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 SharedBuffer.
>-    data.ref();
>-    // We use the GetBytesAtPosition callback rather than the GetBytePointer one because SharedBuffer
>+    // 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(&data, data.size(), &providerCallbacks));
>+    RetainPtr<CGDataProviderRef> dataProvider = adoptCF(CGDataProviderCreateDirect(contiguousData.ptr(), data.size(), &providerCallbacks));
>     CGImageSourceUpdateDataProvider(m_nativeDecoder.get(), dataProvider.get(), allDataReceived);
> #endif
> }
>diff --git a/Source/WebCore/platform/graphics/cg/ImageDecoderCG.h b/Source/WebCore/platform/graphics/cg/ImageDecoderCG.h
>index 9740736a21ac..a0ac1c2fbee5 100644
>--- a/Source/WebCore/platform/graphics/cg/ImageDecoderCG.h
>+++ b/Source/WebCore/platform/graphics/cg/ImageDecoderCG.h
>@@ -32,9 +32,9 @@ namespace WebCore {
> class ImageDecoderCG final : public ImageDecoder {
>     WTF_MAKE_FAST_ALLOCATED;
> public:
>-    ImageDecoderCG(SharedBuffer& data, AlphaOption, GammaAndColorProfileOption);
>+    ImageDecoderCG(FragmentedSharedBuffer& data, AlphaOption, GammaAndColorProfileOption);
> 
>-    static Ref<ImageDecoderCG> create(SharedBuffer& data, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
>+    static Ref<ImageDecoderCG> create(FragmentedSharedBuffer& data, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
>     {
>         return adoptRef(*new ImageDecoderCG(data, alphaOption, gammaAndColorProfileOption));
>     }
>@@ -64,7 +64,7 @@ public:
> 
>     PlatformImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, const DecodingOptions& = DecodingOptions(DecodingMode::Synchronous)) final;
> 
>-    void setData(SharedBuffer&, bool allDataReceived) final;
>+    void setData(FragmentedSharedBuffer&, bool allDataReceived) final;
>     bool isAllDataReceived() const final { return m_isAllDataReceived; }
>     void clearFrameBufferCache(size_t) final { }
> 
>diff --git a/Source/WebCore/platform/graphics/cg/PDFDocumentImage.cpp b/Source/WebCore/platform/graphics/cg/PDFDocumentImage.cpp
>index 31c27c069b2b..ff77b53e9d69 100644
>--- a/Source/WebCore/platform/graphics/cg/PDFDocumentImage.cpp
>+++ b/Source/WebCore/platform/graphics/cg/PDFDocumentImage.cpp
>@@ -319,7 +319,7 @@ void PDFDocumentImage::destroyDecodedData(bool)
> 
> void PDFDocumentImage::createPDFDocument()
> {
>-    RetainPtr<CGDataProviderRef> dataProvider = adoptCF(CGDataProviderCreateWithCFData(data()->createCFData().get()));
>+    RetainPtr<CGDataProviderRef> dataProvider = adoptCF(CGDataProviderCreateWithCFData(data()->makeContiguous()->createCFData().get()));
>     m_document = adoptCF(CGPDFDocumentCreateWithProvider(dataProvider.get()));
> }
> 
>diff --git a/Source/WebCore/platform/graphics/cocoa/SourceBufferParserWebM.cpp b/Source/WebCore/platform/graphics/cocoa/SourceBufferParserWebM.cpp
>index 359edb415fd3..de6debe2bd4c 100644
>--- a/Source/WebCore/platform/graphics/cocoa/SourceBufferParserWebM.cpp
>+++ b/Source/WebCore/platform/graphics/cocoa/SourceBufferParserWebM.cpp
>@@ -365,9 +365,9 @@ public:
>         return Status(Status::kWouldBlock);
>     }
> 
>-    static void FreeDataSegment(void* refcon, void*, size_t)
>+    static void FreeSharedBuffer(void* refcon, void*, size_t)
>     {
>-        auto* buffer = reinterpret_cast<SharedBuffer::DataSegment*>(refcon);
>+        auto* buffer = reinterpret_cast<SharedBuffer*>(refcon);
>         buffer->deref();
>     }
> 
>@@ -408,11 +408,8 @@ public:
>                 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?
>-                auto firstSegment = sharedBuffer->begin()->segment;
>-                size_t canRead = std::min<size_t>(numToRead, firstSegment->size() - m_positionWithinSegment);
>+                size_t canRead = std::min<size_t>(numToRead, sharedBuffer->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
>@@ -420,10 +417,10 @@ public:
>                 CMBlockBufferCustomBlockSource allocator;
>                 allocator.version = 0;
>                 allocator.AllocateBlock = nullptr;
>-                allocator.FreeBlock = FreeDataSegment;
>-                allocator.refCon = firstSegment.ptr();
>-                firstSegment->ref();
>-                auto err = PAL::CMBlockBufferCreateWithMemoryBlock(nullptr, static_cast<void*>(const_cast<uint8_t*>(firstSegment->data())), firstSegment->size(), nullptr, &allocator, m_positionWithinSegment, canRead, 0, &rawBlockBuffer);
>+                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;
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListItemBuffer.cpp b/Source/WebCore/platform/graphics/displaylists/DisplayListItemBuffer.cpp
>index 4025e0692dc5..ba605dcb31d5 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListItemBuffer.cpp
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListItemBuffer.cpp
>@@ -737,7 +737,7 @@ DidChangeItemBuffer ItemBuffer::swapWritableBufferIfNeeded(size_t numberOfBytes)
> void ItemBuffer::append(const DisplayListItem& temporaryItem)
> {
>     auto requiredSizeForItem = m_writingClient->requiredSizeForItem(temporaryItem);
>-    RefPtr<SharedBuffer> outOfLineItem;
>+    RefPtr<FragmentedSharedBuffer> outOfLineItem;
>     if (!requiredSizeForItem) {
>         outOfLineItem = m_writingClient->encodeItemOutOfLine(temporaryItem);
>         if (!outOfLineItem)
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListItemBuffer.h b/Source/WebCore/platform/graphics/displaylists/DisplayListItemBuffer.h
>index c8731982ef83..b31bc5fd4e92 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListItemBuffer.h
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListItemBuffer.h
>@@ -102,7 +102,7 @@ public:
>         return std::nullopt;
>     }
> 
>-    virtual RefPtr<SharedBuffer> encodeItemOutOfLine(const DisplayListItem&) const
>+    virtual RefPtr<FragmentedSharedBuffer> encodeItemOutOfLine(const DisplayListItem&) const
>     {
>         return nullptr;
>     }
>@@ -168,7 +168,7 @@ public:
>     // 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 SharedBuffer containing encoded data for 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
>diff --git a/Source/WebCore/platform/graphics/freetype/FontCustomPlatformDataFreeType.cpp b/Source/WebCore/platform/graphics/freetype/FontCustomPlatformDataFreeType.cpp
>index 506b4dd62d55..2b443fbbed2c 100644
>--- a/Source/WebCore/platform/graphics/freetype/FontCustomPlatformDataFreeType.cpp
>+++ b/Source/WebCore/platform/graphics/freetype/FontCustomPlatformDataFreeType.cpp
>@@ -38,12 +38,12 @@ namespace WebCore {
> 
> static void releaseCustomFontData(void* data)
> {
>-    static_cast<SharedBuffer*>(data)->deref();
>+    static_cast<FragmentedSharedBuffer*>(data)->deref();
> }
> 
> static cairo_user_data_key_t freeTypeFaceKey;
> 
>-FontCustomPlatformData::FontCustomPlatformData(FT_Face freeTypeFace, SharedBuffer& buffer)
>+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.
>diff --git a/Source/WebCore/platform/graphics/gstreamer/ImageDecoderGStreamer.cpp b/Source/WebCore/platform/graphics/gstreamer/ImageDecoderGStreamer.cpp
>index 9ad19b876b27..dfbc580fb8e9 100644
>--- a/Source/WebCore/platform/graphics/gstreamer/ImageDecoderGStreamer.cpp
>+++ b/Source/WebCore/platform/graphics/gstreamer/ImageDecoderGStreamer.cpp
>@@ -81,12 +81,12 @@ ImageDecoderGStreamerSample* toSample(Iterator iter)
>     return (ImageDecoderGStreamerSample*)iter->second.get();
> }
> 
>-RefPtr<ImageDecoderGStreamer> ImageDecoderGStreamer::create(SharedBuffer& data, const String& mimeType, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
>+RefPtr<ImageDecoderGStreamer> ImageDecoderGStreamer::create(FragmentedSharedBuffer& data, const String& mimeType, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
> {
>     return adoptRef(*new ImageDecoderGStreamer(data, mimeType, alphaOption, gammaAndColorProfileOption));
> }
> 
>-ImageDecoderGStreamer::ImageDecoderGStreamer(SharedBuffer& data, const String& mimeType, AlphaOption, GammaAndColorProfileOption)
>+ImageDecoderGStreamer::ImageDecoderGStreamer(FragmentedSharedBuffer& data, const String& mimeType, AlphaOption, GammaAndColorProfileOption)
>     : m_mimeType(mimeType)
> {
>     static std::once_flag onceFlag;
>@@ -199,7 +199,7 @@ PlatformImagePtr ImageDecoderGStreamer::createFrameImageAtIndex(size_t index, Su
>     return nullptr;
> }
> 
>-void ImageDecoderGStreamer::setData(SharedBuffer& data, bool)
>+void ImageDecoderGStreamer::setData(FragmentedSharedBuffer& data, bool)
> {
>     pushEncodedData(data);
> }
>@@ -426,10 +426,11 @@ EncodedDataStatus ImageDecoderGStreamer::InnerDecoder::encodedDataStatus() const
>     return EncodedDataStatus::Unknown;
> }
> 
>-void ImageDecoderGStreamer::pushEncodedData(const SharedBuffer& buffer)
>+void ImageDecoderGStreamer::pushEncodedData(const FragmentedSharedBuffer& buffer)
> {
>+    auto contiguousBuffer = buffer.makeContiguous();
>     m_eos = false;
>-    auto thread = Thread::create("ImageDecoderGStreamer", [this, data = buffer.data(), size = buffer.size()] {
>+    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);
>diff --git a/Source/WebCore/platform/graphics/gstreamer/ImageDecoderGStreamer.h b/Source/WebCore/platform/graphics/gstreamer/ImageDecoderGStreamer.h
>index 66f3372846a4..d3ef6a45cd7d 100644
>--- a/Source/WebCore/platform/graphics/gstreamer/ImageDecoderGStreamer.h
>+++ b/Source/WebCore/platform/graphics/gstreamer/ImageDecoderGStreamer.h
>@@ -41,8 +41,8 @@ class ImageDecoderGStreamer final : public ImageDecoder {
>     WTF_MAKE_FAST_ALLOCATED;
>     WTF_MAKE_NONCOPYABLE(ImageDecoderGStreamer);
> public:
>-    static RefPtr<ImageDecoderGStreamer> create(SharedBuffer&, const String& mimeType, AlphaOption, GammaAndColorProfileOption);
>-    ImageDecoderGStreamer(SharedBuffer&, const String& mimeType, AlphaOption, GammaAndColorProfileOption);
>+    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; }
>@@ -72,7 +72,7 @@ public:
>     PlatformImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, const DecodingOptions& = DecodingOptions(DecodingMode::Synchronous)) final;
> 
>     void setExpectedContentSize(long long) final { }
>-    void setData(SharedBuffer&, bool allDataReceived) final;
>+    void setData(FragmentedSharedBuffer&, bool allDataReceived) final;
>     bool isAllDataReceived() const final { return m_eos; }
>     void clearFrameBufferCache(size_t) final;
> 
>@@ -122,7 +122,7 @@ private:
>     };
> 
>     void handleSample(GRefPtr<GstSample>&&);
>-    void pushEncodedData(const SharedBuffer&);
>+    void pushEncodedData(const FragmentedSharedBuffer&);
> 
>     const ImageDecoderGStreamerSample* sampleAtIndex(size_t) const;
> 
>diff --git a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp b/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp
>index cbb49d17362f..3a2015780148 100644
>--- a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp
>+++ b/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp
>@@ -3669,7 +3669,7 @@ void MediaPlayerPrivateGStreamer::initializationDataEncountered(InitData&& initD
> 
>         GST_DEBUG("scheduling initializationDataEncountered %s event of size %zu", initData.payloadContainerType().utf8().data(),
>             initData.payload()->size());
>-        GST_MEMDUMP("init datas", reinterpret_cast<const uint8_t*>(initData.payload()->data()), initData.payload()->size());
>+        GST_MEMDUMP("init datas", reinterpret_cast<const uint8_t*>(initData.payload()->makeContiguous()->data()), initData.payload()->size());
>         weakThis->m_player->initializationDataEncountered(initData.payloadContainerType(), initData.payload()->tryCreateArrayBuffer());
>     });
> }
>diff --git a/Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp b/Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp
>index 5d86fb1af487..9301909945b4 100644
>--- a/Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp
>+++ b/Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp
>@@ -71,7 +71,7 @@ private:
> 
>     // PlatformMediaResourceClient virtual methods.
>     void responseReceived(PlatformMediaResource&, const ResourceResponse&, CompletionHandler<void(ShouldContinuePolicyCheck)>&&) override;
>-    void dataReceived(PlatformMediaResource&, Ref<SharedBuffer>&&) 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;
>@@ -1093,7 +1093,7 @@ void CachedResourceStreamingClient::responseReceived(PlatformMediaResource&, con
>     completionHandler(ShouldContinuePolicyCheck::Yes);
> }
> 
>-void CachedResourceStreamingClient::dataReceived(PlatformMediaResource&, Ref<SharedBuffer>&& buffer)
>+void CachedResourceStreamingClient::dataReceived(PlatformMediaResource&, Ref<FragmentedSharedBuffer>&& buffer)
> {
>     ASSERT(isMainThread());
>     WebKitWebSrc* src = WEBKIT_WEB_SRC(m_src.get());
>diff --git a/Source/WebCore/platform/graphics/gstreamer/eme/CDMProxyClearKey.h b/Source/WebCore/platform/graphics/gstreamer/eme/CDMProxyClearKey.h
>index 692a996d19c2..349bfdcaad6c 100644
>--- a/Source/WebCore/platform/graphics/gstreamer/eme/CDMProxyClearKey.h
>+++ b/Source/WebCore/platform/graphics/gstreamer/eme/CDMProxyClearKey.h
>@@ -62,11 +62,11 @@ public:
>     CDMProxyClearKey() = default;
>     virtual ~CDMProxyClearKey();
> 
>-    // FIXME: There's a lack of consistency between SharedBuffers,
>+    // 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 SharedBuffers are dangerous since
>+    // bytes. Fix that somehow. Note FragmentedSharedBuffers are dangerous since
>     // they're not thread-safe and this class must maintain
>-    // thread-safety, but maybe SharedBuffer::DataSegment could be
>+    // 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 {
>diff --git a/Source/WebCore/platform/graphics/gstreamer/eme/CDMThunder.cpp b/Source/WebCore/platform/graphics/gstreamer/eme/CDMThunder.cpp
>index 2efa04360e88..c38916e7d059 100644
>--- a/Source/WebCore/platform/graphics/gstreamer/eme/CDMThunder.cpp
>+++ b/Source/WebCore/platform/graphics/gstreamer/eme/CDMThunder.cpp
>@@ -220,7 +220,7 @@ bool CDMPrivateThunder::supportsSessions() const
>     return true;
> }
> 
>-bool CDMPrivateThunder::supportsInitData(const AtomString& initDataType, const SharedBuffer& initData) const
>+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))
>@@ -237,7 +237,7 @@ bool CDMPrivateThunder::supportsInitData(const AtomString& initDataType, const S
>     return false;
> }
> 
>-RefPtr<SharedBuffer> CDMPrivateThunder::sanitizeResponse(const SharedBuffer& response) const
>+RefPtr<FragmentedSharedBuffer> CDMPrivateThunder::sanitizeResponse(const FragmentedSharedBuffer& response) const
> {
>     return response.copy();
> }
>@@ -260,7 +260,7 @@ void CDMInstanceThunder::initializeWithConfiguration(const CDMKeySystemConfigura
>     callback(Succeeded);
> }
> 
>-void CDMInstanceThunder::setServerCertificate(Ref<SharedBuffer>&& certificate,  SuccessCallback&& callback)
>+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());
>@@ -326,7 +326,7 @@ RefPtr<CDMInstanceSession> CDMInstanceThunder::createSession()
> class ParsedResponseMessage {
> 
> public:
>-    ParsedResponseMessage(const RefPtr<SharedBuffer>& buffer)
>+    ParsedResponseMessage(const RefPtr<FragmentedSharedBuffer>& buffer)
>     {
>         if (!buffer || !buffer->size())
>             return;
>@@ -354,8 +354,8 @@ public:
> 
>     bool isValid() const { return m_isValid; }
>     bool hasPayload() const { return static_cast<bool>(m_payload); }
>-    const Ref<SharedBuffer>& payload() const& { ASSERT(m_payload); return m_payload.value(); }
>-    Ref<SharedBuffer>& payload() & { ASSERT(m_payload); return m_payload.value(); }
>+    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; }
>@@ -364,11 +364,11 @@ public:
> 
> private:
>     bool m_isValid { false };
>-    std::optional<Ref<SharedBuffer>> m_payload;
>+    std::optional<Ref<FragmentedSharedBuffer>> m_payload;
>     std::optional<WebCore::MediaKeyMessageType> m_type;
> };
> 
>-void CDMInstanceSessionThunder::challengeGeneratedCallback(RefPtr<SharedBuffer>&& buffer)
>+void CDMInstanceSessionThunder::challengeGeneratedCallback(RefPtr<FragmentedSharedBuffer>&& buffer)
> {
>     ParsedResponseMessage parsedResponseMessage(buffer);
>     if (!parsedResponseMessage) {
>@@ -475,7 +475,7 @@ void CDMInstanceSessionThunder::keysUpdateDoneCallback()
>     m_sessionChangedCallbacks.clear();
> }
> 
>-void CDMInstanceSessionThunder::errorCallback(RefPtr<SharedBuffer>&& message)
>+void CDMInstanceSessionThunder::errorCallback(RefPtr<FragmentedSharedBuffer>&& message)
> {
>     GST_ERROR("CDM error");
>     GST_MEMDUMP("error dump", message->data(), message->size());
>@@ -488,7 +488,7 @@ void CDMInstanceSessionThunder::errorCallback(RefPtr<SharedBuffer>&& message)
>     m_sessionChangedCallbacks.clear();
> }
> 
>-void CDMInstanceSessionThunder::requestLicense(LicenseType licenseType, const AtomString& initDataType, Ref<SharedBuffer>&& initDataSharedBuffer,
>+void CDMInstanceSessionThunder::requestLicense(LicenseType licenseType, const AtomString& initDataType, Ref<FragmentedSharedBuffer>&& initDataSharedBuffer,
>     LicenseCallback&& callback)
> {
>     ASSERT(isMainThread());
>@@ -506,7 +506,7 @@ void CDMInstanceSessionThunder::requestLicense(LicenseType licenseType, const At
>         m_initData.payload()->data(), m_initData.payload()->size(), nullptr, 0, &m_thunderSessionCallbacks, this, &session);
>     if (!session) {
>         GST_ERROR("Could not create session");
>-        RefPtr<SharedBuffer> initData = m_initData.payload();
>+        RefPtr<FragmentedSharedBuffer> initData = m_initData.payload();
>         callback(initData.releaseNonNull(), { }, false, Failed);
>         return;
>     }
>@@ -515,7 +515,7 @@ void CDMInstanceSessionThunder::requestLicense(LicenseType licenseType, const At
> 
>     auto generateChallenge = [this, callback = WTFMove(callback)]() mutable {
>         ASSERT(isMainThread());
>-        RefPtr<SharedBuffer> initData = m_initData.payload();
>+        RefPtr<FragmentedSharedBuffer> initData = m_initData.payload();
>         if (m_sessionID.isEmpty()) {
>             GST_ERROR("could not create session id");
>             callback(initData.releaseNonNull(), { }, false, Failed);
>@@ -545,13 +545,13 @@ void CDMInstanceSessionThunder::sessionFailure()
>     m_sessionChangedCallbacks.clear();
> }
> 
>-void CDMInstanceSessionThunder::updateLicense(const String& sessionID, LicenseType, Ref<SharedBuffer>&& response, LicenseUpdateCallback&& callback)
>+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<SharedBuffer>&& responseMessage) mutable {
>+    m_sessionChangedCallbacks.append([this, callback = WTFMove(callback)](bool success, RefPtr<FragmentedSharedBuffer>&& responseMessage) mutable {
>         ASSERT(isMainThread());
>         if (success) {
>             if (!responseMessage)
>@@ -562,7 +562,7 @@ void CDMInstanceSessionThunder::updateLicense(const String& sessionID, LicenseTy
>                 ParsedResponseMessage parsedResponseMessage(responseMessage);
>                 ASSERT(parsedResponseMessage);
>                 if (parsedResponseMessage.hasPayload()) {
>-                    Ref<SharedBuffer> message = WTFMove(parsedResponseMessage.payload());
>+                    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,
>@@ -586,7 +586,7 @@ void CDMInstanceSessionThunder::loadSession(LicenseType, const String& sessionID
> {
>     ASSERT_UNUSED(sessionID, sessionID == m_sessionID);
> 
>-    m_sessionChangedCallbacks.append([this, callback = WTFMove(callback)](bool success, RefPtr<SharedBuffer>&& responseMessage) mutable {
>+    m_sessionChangedCallbacks.append([this, callback = WTFMove(callback)](bool success, RefPtr<FragmentedSharedBuffer>&& responseMessage) mutable {
>         ASSERT(isMainThread());
>         if (success) {
>             if (!responseMessage)
>@@ -597,7 +597,7 @@ void CDMInstanceSessionThunder::loadSession(LicenseType, const String& sessionID
>                 ParsedResponseMessage parsedResponseMessage(responseMessage);
>                 ASSERT(parsedResponseMessage);
>                 if (parsedResponseMessage.hasPayload()) {
>-                    Ref<SharedBuffer> message = WTFMove(parsedResponseMessage.payload());
>+                    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),
>@@ -640,7 +640,7 @@ void CDMInstanceSessionThunder::removeSessionData(const String& sessionID, Licen
> {
>     ASSERT_UNUSED(sessionID, m_sessionID == sessionID);
> 
>-    m_sessionChangedCallbacks.append([this, callback = WTFMove(callback)](bool success, RefPtr<SharedBuffer>&& buffer) mutable {
>+    m_sessionChangedCallbacks.append([this, callback = WTFMove(callback)](bool success, RefPtr<FragmentedSharedBuffer>&& buffer) mutable {
>         ASSERT(isMainThread());
>         if (success) {
>             if (!buffer)
>@@ -649,7 +649,7 @@ void CDMInstanceSessionThunder::removeSessionData(const String& sessionID, Licen
>                 ParsedResponseMessage parsedResponseMessage(buffer);
>                 ASSERT(parsedResponseMessage);
>                 if (parsedResponseMessage.hasPayload()) {
>-                    Ref<SharedBuffer> message = WTFMove(parsedResponseMessage.payload());
>+                    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 {
>diff --git a/Source/WebCore/platform/graphics/gstreamer/eme/CDMThunder.h b/Source/WebCore/platform/graphics/gstreamer/eme/CDMThunder.h
>index cdd8da21123c..1020e1532271 100644
>--- a/Source/WebCore/platform/graphics/gstreamer/eme/CDMThunder.h
>+++ b/Source/WebCore/platform/graphics/gstreamer/eme/CDMThunder.h
>@@ -93,8 +93,8 @@ public:
>     void loadAndInitialize() final;
>     bool supportsServerCertificates() const final;
>     bool supportsSessions() const final;
>-    bool supportsInitData(const AtomString&, const SharedBuffer&) const final;
>-    RefPtr<SharedBuffer> sanitizeResponse(const SharedBuffer&) 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:
>@@ -110,7 +110,7 @@ public:
>     // CDMInstance
>     ImplementationType implementationType() const final { return ImplementationType::Thunder; }
>     void initializeWithConfiguration(const CDMKeySystemConfiguration&, AllowDistinctiveIdentifiers, AllowPersistentState, SuccessCallback&&) final;
>-    void setServerCertificate(Ref<SharedBuffer>&&, 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;
>@@ -126,8 +126,8 @@ class CDMInstanceSessionThunder final : public CDMInstanceSessionProxy {
> public:
>     CDMInstanceSessionThunder(CDMInstanceThunder&);
> 
>-    void requestLicense(LicenseType, const AtomString& initDataType, Ref<SharedBuffer>&& initData, LicenseCallback&&) final;
>-    void updateLicense(const String&, LicenseType, Ref<SharedBuffer>&&, LicenseUpdateCallback&&) final;
>+    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;
>@@ -141,14 +141,14 @@ public:
> private:
>     CDMInstanceThunder* cdmInstanceThunder() const;
> 
>-    using Notification = void (CDMInstanceSessionThunder::*)(RefPtr<WebCore::SharedBuffer>&&);
>+    using Notification = void (CDMInstanceSessionThunder::*)(RefPtr<WebCore::FragmentedSharedBuffer>&&);
>     using ChallengeGeneratedCallback = Function<void()>;
>-    using SessionChangedCallback = Function<void(bool, RefPtr<SharedBuffer>&&)>;
>+    using SessionChangedCallback = Function<void(bool, RefPtr<FragmentedSharedBuffer>&&)>;
> 
>-    void challengeGeneratedCallback(RefPtr<SharedBuffer>&&);
>+    void challengeGeneratedCallback(RefPtr<FragmentedSharedBuffer>&&);
>     void keyUpdatedCallback(KeyIDType&&);
>     void keysUpdateDoneCallback();
>-    void errorCallback(RefPtr<SharedBuffer>&&);
>+    void errorCallback(RefPtr<FragmentedSharedBuffer>&&);
>     CDMInstanceSession::KeyStatus status(const KeyIDType&) const;
>     void sessionFailure();
> 
>@@ -159,7 +159,7 @@ private:
>     InitData m_initData;
>     OpenCDMSessionCallbacks m_thunderSessionCallbacks { };
>     BoxPtr<OpenCDMSession> m_session;
>-    RefPtr<SharedBuffer> m_message;
>+    RefPtr<FragmentedSharedBuffer> m_message;
>     bool m_needsIndividualization { false };
>     Vector<ChallengeGeneratedCallback> m_challengeCallbacks;
>     Vector<SessionChangedCallback> m_sessionChangedCallbacks;
>diff --git a/Source/WebCore/platform/graphics/gstreamer/eme/GStreamerEMEUtilities.cpp b/Source/WebCore/platform/graphics/gstreamer/eme/GStreamerEMEUtilities.cpp
>index 3f85afe73c84..ea890f67da21 100644
>--- a/Source/WebCore/platform/graphics/gstreamer/eme/GStreamerEMEUtilities.cpp
>+++ b/Source/WebCore/platform/graphics/gstreamer/eme/GStreamerEMEUtilities.cpp
>@@ -71,7 +71,7 @@ static void markupError(GMarkupParseContext*, GError*, gpointer)
> 
> static GMarkupParser markupParser { markupStartElement, markupEndElement, markupText, markupPassthrough, markupError };
> 
>-RefPtr<SharedBuffer> InitData::extractCencIfNeeded(RefPtr<SharedBuffer>&& unparsedPayload)
>+RefPtr<FragmentedSharedBuffer> InitData::extractCencIfNeeded(RefPtr<SharedBuffer>&& unparsedPayload)
> {
>     RefPtr<SharedBuffer> payload = WTFMove(unparsedPayload);
>     if (!payload || !payload->size())
>diff --git a/Source/WebCore/platform/graphics/gstreamer/eme/GStreamerEMEUtilities.h b/Source/WebCore/platform/graphics/gstreamer/eme/GStreamerEMEUtilities.h
>index d5aff845f409..ab264f3777fd 100644
>--- a/Source/WebCore/platform/graphics/gstreamer/eme/GStreamerEMEUtilities.h
>+++ b/Source/WebCore/platform/graphics/gstreamer/eme/GStreamerEMEUtilities.h
>@@ -50,13 +50,17 @@ public:
>             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();
>         }
>-        m_payload = extractCencIfNeeded(mappedInitData->createSharedBuffer());
>+        if (auto parsedPayload = extractCencIfNeeded(mappedInitData->createSharedBuffer()))
>+            m_payload.append(parsedPayload.releaseNonNull());
>     }
> 
>-    InitData(const String& systemId, RefPtr<SharedBuffer>&& payload)
>+    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)
>@@ -72,10 +76,10 @@ public:
>         // it's not very robust, so be careful here!
>         m_systemId = initData.m_systemId;
> 
>-        m_payload->append(*initData.payload());
>+        m_payload.append(*initData.payload());
>     }
> 
>-    const RefPtr<SharedBuffer>& payload() const { return m_payload; }
>+    RefPtr<FragmentedSharedBuffer> payload() const { return m_payload.get(); }
>     const String& systemId() const { return m_systemId; }
>     String payloadContainerType() const
>     {
>@@ -86,11 +90,11 @@ public:
>         return "cenc"_s;
>     }
> 
>-    static RefPtr<SharedBuffer> extractCencIfNeeded(RefPtr<SharedBuffer>&&);
>+    static RefPtr<FragmentedSharedBuffer> extractCencIfNeeded(RefPtr<SharedBuffer>&&);
> 
> private:
>     String m_systemId;
>-    RefPtr<SharedBuffer> m_payload;
>+    SharedBufferBuilder m_payload;
> };
> 
> class ProtectionSystemEvents {
>diff --git a/Source/WebCore/platform/graphics/mac/FontCustomPlatformData.h b/Source/WebCore/platform/graphics/mac/FontCustomPlatformData.h
>index 718b9bd315ec..6928a63e971c 100644
>--- a/Source/WebCore/platform/graphics/mac/FontCustomPlatformData.h
>+++ b/Source/WebCore/platform/graphics/mac/FontCustomPlatformData.h
>@@ -36,7 +36,7 @@ namespace WebCore {
> class FontCreationContext;
> class FontDescription;
> struct FontSelectionSpecifiedCapabilities;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> template <typename T> class FontTaggedSettings;
> typedef FontTaggedSettings<int> FontFeatureSettings;
>diff --git a/Source/WebCore/platform/graphics/mac/PDFDocumentImageMac.mm b/Source/WebCore/platform/graphics/mac/PDFDocumentImageMac.mm
>index 83e6af7b0389..68bcc8846a8b 100644
>--- a/Source/WebCore/platform/graphics/mac/PDFDocumentImageMac.mm
>+++ b/Source/WebCore/platform/graphics/mac/PDFDocumentImageMac.mm
>@@ -48,7 +48,7 @@ namespace WebCore {
> 
> void PDFDocumentImage::createPDFDocument()
> {
>-    m_document = adoptNS([allocPDFDocumentInstance() initWithData:data()->createNSData().get()]);
>+    m_document = adoptNS([allocPDFDocumentInstance() initWithData:data()->makeContiguous()->createNSData().get()]);
> }
> 
> void PDFDocumentImage::computeBoundsForCurrentPage()
>diff --git a/Source/WebCore/platform/graphics/opentype/OpenTypeUtilities.h b/Source/WebCore/platform/graphics/opentype/OpenTypeUtilities.h
>index 09c1c45c4593..fa0008116066 100644
>--- a/Source/WebCore/platform/graphics/opentype/OpenTypeUtilities.h
>+++ b/Source/WebCore/platform/graphics/opentype/OpenTypeUtilities.h
>@@ -35,9 +35,10 @@
> namespace WebCore {
> 
> struct BigEndianUShort;
>+class SharedBuffer;
> struct EOTPrefix;
> class FontMemoryResource;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> struct EOTHeader {
>     EOTHeader();
>diff --git a/Source/WebCore/platform/graphics/opentype/OpenTypeVerticalData.cpp b/Source/WebCore/platform/graphics/opentype/OpenTypeVerticalData.cpp
>index 2cfa854c0226..0fa8f306ad95 100644
>--- a/Source/WebCore/platform/graphics/opentype/OpenTypeVerticalData.cpp
>+++ b/Source/WebCore/platform/graphics/opentype/OpenTypeVerticalData.cpp
>@@ -381,7 +381,7 @@ struct GSUBTable : TableBase {
> 
> static bool loadHmtxTable(const FontPlatformData& platformData, Vector<uint16_t>& advanceWidths)
> {
>-    RefPtr<SharedBuffer> buffer = platformData.openTypeTable(OpenType::HheaTag);
>+    auto buffer = platformData.openTypeTable(OpenType::HheaTag);
>     const OpenType::HheaTable* hhea = OpenType::validateTable<OpenType::HheaTable>(buffer);
>     if (!hhea)
>         return false;
>@@ -424,7 +424,7 @@ OpenTypeVerticalData::OpenTypeVerticalData(const FontPlatformData& platformData,
> void OpenTypeVerticalData::loadMetrics(const FontPlatformData& platformData)
> {
>     // Load vhea first. This table is required for fonts that support vertical flow.
>-    RefPtr<SharedBuffer> buffer = platformData.openTypeTable(OpenType::VheaTag);
>+    auto buffer = platformData.openTypeTable(OpenType::VheaTag);
>     const OpenType::VheaTable* vhea = OpenType::validateTable<OpenType::VheaTable>(buffer);
>     if (!vhea)
>         return;
>@@ -486,7 +486,7 @@ void OpenTypeVerticalData::loadMetrics(const FontPlatformData& platformData)
> 
> void OpenTypeVerticalData::loadVerticalGlyphSubstitutions(const FontPlatformData& platformData)
> {
>-    RefPtr<SharedBuffer> buffer = platformData.openTypeTable(OpenType::GSUBTag);
>+    auto buffer = platformData.openTypeTable(OpenType::GSUBTag);
>     const OpenType::GSUBTable* gsub = OpenType::validateTable<OpenType::GSUBTable>(buffer);
>     if (gsub)
>         gsub->getVerticalGlyphSubstitutions(&m_verticalGlyphMap, *buffer.get());
>diff --git a/Source/WebCore/platform/graphics/win/DirectWriteUtilities.h b/Source/WebCore/platform/graphics/win/DirectWriteUtilities.h
>index a62719b1719a..0db4afadb3f7 100644
>--- a/Source/WebCore/platform/graphics/win/DirectWriteUtilities.h
>+++ b/Source/WebCore/platform/graphics/win/DirectWriteUtilities.h
>@@ -43,7 +43,7 @@ enum DWRITE_FONT_STRETCH;
> namespace WebCore {
> 
> class FontPlatformData;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> namespace DirectWrite {
> 
>diff --git a/Source/WebCore/platform/graphics/win/FontCustomPlatformData.h b/Source/WebCore/platform/graphics/win/FontCustomPlatformData.h
>index 5f10f7392d04..08fc9f19eaea 100644
>--- a/Source/WebCore/platform/graphics/win/FontCustomPlatformData.h
>+++ b/Source/WebCore/platform/graphics/win/FontCustomPlatformData.h
>@@ -36,12 +36,13 @@ typedef struct CGFont* CGFontRef;
> 
> 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;
>diff --git a/Source/WebCore/platform/graphics/win/ImageDecoderDirect2D.cpp b/Source/WebCore/platform/graphics/win/ImageDecoderDirect2D.cpp
>index 629e0e61a104..7735739b9334 100644
>--- a/Source/WebCore/platform/graphics/win/ImageDecoderDirect2D.cpp
>+++ b/Source/WebCore/platform/graphics/win/ImageDecoderDirect2D.cpp
>@@ -272,7 +272,7 @@ PlatformImagePtr ImageDecoderDirect2D::createFrameImageAtIndex(size_t index, Sub
>     return bitmap;
> }
> 
>-void ImageDecoderDirect2D::setData(SharedBuffer& data, bool allDataReceived)
>+void ImageDecoderDirect2D::setData(FragmentedSharedBuffer& data, bool allDataReceived)
> {
>     if (!allDataReceived)
>         return;
>diff --git a/Source/WebCore/platform/graphics/win/ImageDecoderDirect2D.h b/Source/WebCore/platform/graphics/win/ImageDecoderDirect2D.h
>index 4f472586b424..c2365fd744c6 100644
>--- a/Source/WebCore/platform/graphics/win/ImageDecoderDirect2D.h
>+++ b/Source/WebCore/platform/graphics/win/ImageDecoderDirect2D.h
>@@ -41,7 +41,7 @@ class ImageDecoderDirect2D final : public ImageDecoder {
> public:
>     ImageDecoderDirect2D();
> 
>-    static Ref<ImageDecoderDirect2D> create(SharedBuffer&, AlphaOption, GammaAndColorProfileOption)
>+    static Ref<ImageDecoderDirect2D> create(FragmentedSharedBuffer&, AlphaOption, GammaAndColorProfileOption)
>     {
>         return adoptRef(*new ImageDecoderDirect2D());
>     }
>@@ -72,7 +72,7 @@ public:
> 
>     PlatformImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, const DecodingOptions& = DecodingOptions(DecodingMode::Synchronous)) final;
> 
>-    void setData(SharedBuffer&, bool allDataReceived) final;
>+    void setData(FragmentedSharedBuffer&, bool allDataReceived) final;
>     bool isAllDataReceived() const final { return m_isAllDataReceived; }
>     void clearFrameBufferCache(size_t) final { }
> 
>diff --git a/Source/WebCore/platform/graphics/win/ImageWin.cpp b/Source/WebCore/platform/graphics/win/ImageWin.cpp
>index 0d8820e9f3d6..2d97270a7348 100644
>--- a/Source/WebCore/platform/graphics/win/ImageWin.cpp
>+++ b/Source/WebCore/platform/graphics/win/ImageWin.cpp
>@@ -30,7 +30,7 @@
> #include "SharedBuffer.h"
> 
> // This function loads resources from WebKit
>-RefPtr<WebCore::SharedBuffer> loadResourceIntoBuffer(const char*);
>+RefPtr<WebCore::FragmentedSharedBuffer> loadResourceIntoBuffer(const char*);
> 
> namespace WebCore {
> 
>diff --git a/Source/WebCore/platform/image-decoders/ScalableImageDecoder.cpp b/Source/WebCore/platform/image-decoders/ScalableImageDecoder.cpp
>index d956d9e7625d..33c95ec3333a 100644
>--- a/Source/WebCore/platform/image-decoders/ScalableImageDecoder.cpp
>+++ b/Source/WebCore/platform/image-decoders/ScalableImageDecoder.cpp
>@@ -51,7 +51,7 @@ namespace WebCore {
> 
> namespace {
> 
>-static unsigned copyFromSharedBuffer(char* buffer, unsigned bufferLength, const SharedBuffer& sharedBuffer)
>+static unsigned copyFromSharedBuffer(char* buffer, unsigned bufferLength, const FragmentedSharedBuffer& sharedBuffer)
> {
>     unsigned bytesExtracted = 0;
>     for (const auto& element : sharedBuffer) {
>@@ -135,7 +135,7 @@ bool matchesCURSignature(char* contents)
> 
> }
> 
>-RefPtr<ScalableImageDecoder> ScalableImageDecoder::create(SharedBuffer& data, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
>+RefPtr<ScalableImageDecoder> ScalableImageDecoder::create(FragmentedSharedBuffer& data, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
> {
>     static const unsigned lengthOfLongestSignature = 14; // To wit: "RIFF????WEBPVP"
>     char contents[lengthOfLongestSignature];
>diff --git a/Source/WebCore/platform/image-decoders/ScalableImageDecoder.h b/Source/WebCore/platform/image-decoders/ScalableImageDecoder.h
>index 32d4e6f8b8fa..9c405578241d 100644
>--- a/Source/WebCore/platform/image-decoders/ScalableImageDecoder.h
>+++ b/Source/WebCore/platform/image-decoders/ScalableImageDecoder.h
>@@ -60,7 +60,7 @@ public:
> 
>     // 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(SharedBuffer& data, AlphaOption, GammaAndColorProfileOption);
>+    static RefPtr<ScalableImageDecoder> create(FragmentedSharedBuffer& data, AlphaOption, GammaAndColorProfileOption);
> 
>     bool premultiplyAlpha() const { return m_premultiplyAlpha; }
> 
>@@ -70,16 +70,15 @@ public:
>         return m_encodedDataStatus == EncodedDataStatus::Complete;
>     }
> 
>-    void setData(SharedBuffer& data, bool allDataReceived) override
>+    void setData(FragmentedSharedBuffer& data, bool allDataReceived) override
>     {
>         Locker locker { m_lock };
>         if (m_encodedDataStatus == EncodedDataStatus::Error)
>             return;
> 
>-        if (data.data()) {
>-            // SharedBuffer::data() combines all segments into one in case there's more than one.
>-            m_data = data.begin()->segment.copyRef();
>-        }
>+        auto contiguousData = data.makeContiguous();
>+        if (contiguousData->data())
>+            m_data = contiguousData->begin()->segment.copyRef();
>         if (m_encodedDataStatus == EncodedDataStatus::TypeAvailable) {
>             m_decodingSizeFromSetData = true;
>             tryDecodeSize(allDataReceived);
>@@ -195,7 +194,7 @@ public:
>     std::optional<IntPoint> hotSpot() const override { return std::nullopt; }
> 
> protected:
>-    RefPtr<SharedBuffer::DataSegment> m_data;
>+    RefPtr<FragmentedSharedBuffer::DataSegment> m_data;
>     Vector<ScalableImageDecoderFrame, 1> m_frameBufferCache WTF_GUARDED_BY_LOCK(m_lock);
>     mutable Lock m_lock;
>     bool m_premultiplyAlpha;
>diff --git a/Source/WebCore/platform/image-decoders/avif/AVIFImageReader.cpp b/Source/WebCore/platform/image-decoders/avif/AVIFImageReader.cpp
>index 7c603fd8358c..26f886496e5a 100644
>--- a/Source/WebCore/platform/image-decoders/avif/AVIFImageReader.cpp
>+++ b/Source/WebCore/platform/image-decoders/avif/AVIFImageReader.cpp
>@@ -41,7 +41,7 @@ AVIFImageReader::AVIFImageReader(RefPtr<AVIFImageDecoder>&& decoder)
> 
> AVIFImageReader::~AVIFImageReader() = default;
> 
>-bool AVIFImageReader::parseHeader(const SharedBuffer::DataSegment& data, bool allDataReceived)
>+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;
>@@ -58,7 +58,7 @@ bool AVIFImageReader::parseHeader(const SharedBuffer::DataSegment& data, bool al
>     return true;
> }
> 
>-void AVIFImageReader::decodeFrame(size_t frameIndex, ScalableImageDecoderFrame& buffer, const SharedBuffer::DataSegment& data)
>+void AVIFImageReader::decodeFrame(size_t frameIndex, ScalableImageDecoderFrame& buffer, const FragmentedSharedBuffer::DataSegment& data)
> {
>     if (m_decoder->failed())
>         return;
>diff --git a/Source/WebCore/platform/image-decoders/avif/AVIFImageReader.h b/Source/WebCore/platform/image-decoders/avif/AVIFImageReader.h
>index cbca0b8c124b..496f69f812bd 100644
>--- a/Source/WebCore/platform/image-decoders/avif/AVIFImageReader.h
>+++ b/Source/WebCore/platform/image-decoders/avif/AVIFImageReader.h
>@@ -39,8 +39,8 @@ public:
>     AVIFImageReader(RefPtr<AVIFImageDecoder>&&);
>     ~AVIFImageReader();
> 
>-    bool parseHeader(const SharedBuffer::DataSegment&, bool allDataReceived);
>-    void decodeFrame(size_t index, ScalableImageDecoderFrame&, const SharedBuffer::DataSegment&);
>+    bool parseHeader(const FragmentedSharedBuffer::DataSegment&, bool allDataReceived);
>+    void decodeFrame(size_t index, ScalableImageDecoderFrame&, const FragmentedSharedBuffer::DataSegment&);
>     size_t imageCount() const;
>     double repetitionCount() const;
> 
>diff --git a/Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.cpp b/Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.cpp
>index 72769a6926ec..f7455c146c7e 100644
>--- a/Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.cpp
>+++ b/Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.cpp
>@@ -46,7 +46,7 @@ BMPImageDecoder::BMPImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOp
> {
> }
> 
>-void BMPImageDecoder::setData(SharedBuffer& data, bool allDataReceived)
>+void BMPImageDecoder::setData(FragmentedSharedBuffer& data, bool allDataReceived)
> {
>     if (failed())
>         return;
>diff --git a/Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.h b/Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.h
>index c7c7ca81fea6..64ded6abbe2c 100644
>--- a/Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.h
>+++ b/Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.h
>@@ -44,7 +44,7 @@ public:
> 
>     // ScalableImageDecoder
>     String filenameExtension() const final { return "bmp"_s; }
>-    void setData(SharedBuffer&, bool allDataReceived) final;
>+    void setData(FragmentedSharedBuffer&, bool allDataReceived) final;
>     ScalableImageDecoderFrame* frameBufferAtIndex(size_t index) final;
>     // CAUTION: setFailed() deletes |m_reader|. Be careful to avoid
>     // accessing deleted memory, especially when calling this from inside
>diff --git a/Source/WebCore/platform/image-decoders/bmp/BMPImageReader.h b/Source/WebCore/platform/image-decoders/bmp/BMPImageReader.h
>index 4844f380dc17..bd430e8a8bea 100644
>--- a/Source/WebCore/platform/image-decoders/bmp/BMPImageReader.h
>+++ b/Source/WebCore/platform/image-decoders/bmp/BMPImageReader.h
>@@ -42,7 +42,7 @@ class BMPImageReader {
> public:
>     // Read a value from |data[offset]|, converting from little to native
>     // endianness.
>-    static inline uint16_t readUint16(const SharedBuffer::DataSegment& data, int offset)
>+    static inline uint16_t readUint16(const FragmentedSharedBuffer::DataSegment& data, int offset)
>     {
>         uint16_t result;
>         memcpy(&result, &data.data()[offset], 2);
>@@ -52,7 +52,7 @@ public:
>         return result;
>     }
> 
>-    static inline uint32_t readUint32(const SharedBuffer::DataSegment& data, int offset)
>+    static inline uint32_t readUint32(const FragmentedSharedBuffer::DataSegment& data, int offset)
>     {
>         uint32_t result;
>         memcpy(&result, &data.data()[offset], 4);
>@@ -69,7 +69,7 @@ public:
>     BMPImageReader(ScalableImageDecoder* parent, size_t decodedAndHeaderOffset, size_t imgDataOffset, bool usesAndMask);
> 
>     void setBuffer(ScalableImageDecoderFrame* buffer) { m_buffer = buffer; }
>-    void setData(SharedBuffer::DataSegment& data) { m_data = &data; }
>+    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
>@@ -272,7 +272,7 @@ private:
>     ScalableImageDecoderFrame* m_buffer;
> 
>     // The file to decode.
>-    RefPtr<SharedBuffer::DataSegment> m_data;
>+    RefPtr<FragmentedSharedBuffer::DataSegment> m_data;
> 
>     // An index into |m_data| representing how much we've already decoded.
>     size_t m_decodedOffset;
>diff --git a/Source/WebCore/platform/image-decoders/cairo/ImageBackingStoreCairo.cpp b/Source/WebCore/platform/image-decoders/cairo/ImageBackingStoreCairo.cpp
>index 60120374f9c4..4a21255a8c0f 100644
>--- a/Source/WebCore/platform/image-decoders/cairo/ImageBackingStoreCairo.cpp
>+++ b/Source/WebCore/platform/image-decoders/cairo/ImageBackingStoreCairo.cpp
>@@ -37,7 +37,9 @@ PlatformImagePtr ImageBackingStore::image() const
>         reinterpret_cast<unsigned char*>(const_cast<uint32_t*>(m_pixelsPtr)),
>         CAIRO_FORMAT_ARGB32, size().width(), size().height(), size().width() * sizeof(uint32_t)));
>     static cairo_user_data_key_t s_surfaceDataKey;
>-    cairo_surface_set_user_data(surface.get(), &s_surfaceDataKey, m_pixels.get(), [](void* data) { static_cast<SharedBuffer::DataSegment*>(data)->deref(); });
>+    cairo_surface_set_user_data(surface.get(), &s_surfaceDataKey, m_pixels.get(), [](void* data) {
>+        static_cast<DataSegment*>(data)->deref();
>+    });
> 
>     return surface;
> }
>diff --git a/Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.cpp b/Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.cpp
>index e6abe0d9544b..b9ec01b8ae8e 100644
>--- a/Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.cpp
>+++ b/Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.cpp
>@@ -38,7 +38,7 @@ GIFImageDecoder::GIFImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOp
> 
> GIFImageDecoder::~GIFImageDecoder() = default;
> 
>-void GIFImageDecoder::setData(SharedBuffer& data, bool allDataReceived)
>+void GIFImageDecoder::setData(FragmentedSharedBuffer& data, bool allDataReceived)
> {
>     if (failed())
>         return;
>diff --git a/Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.h b/Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.h
>index 35df33f6dfc4..c74719999b98 100644
>--- a/Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.h
>+++ b/Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.h
>@@ -46,7 +46,7 @@ public:
> 
>     // ScalableImageDecoder
>     String filenameExtension() const final { return "gif"_s; }
>-    void setData(SharedBuffer& data, bool allDataReceived) final;
>+    void setData(FragmentedSharedBuffer& data, bool allDataReceived) final;
>     bool setSize(const IntSize&) final;
>     size_t frameCount() const final;
>     RepetitionCount repetitionCount() const final;
>diff --git a/Source/WebCore/platform/image-decoders/gif/GIFImageReader.h b/Source/WebCore/platform/image-decoders/gif/GIFImageReader.h
>index 42146e032932..1082fdf0dff2 100644
>--- a/Source/WebCore/platform/image-decoders/gif/GIFImageReader.h
>+++ b/Source/WebCore/platform/image-decoders/gif/GIFImageReader.h
>@@ -237,7 +237,7 @@ public:
>     {
>     }
> 
>-    void setData(WebCore::SharedBuffer::DataSegment& data) { m_data = &data; }
>+    void setData(WebCore::FragmentedSharedBuffer::DataSegment& data) { m_data = &data; }
>     // FIXME: haltAtFrame should be size_t.
>     bool decode(WebCore::GIFImageDecoder::GIFQuery, unsigned haltAtFrame);
> 
>@@ -316,6 +316,6 @@ private:
>     Vector<std::unique_ptr<GIFFrameContext> > m_frames;
>     size_t m_currentDecodingFrame;
> 
>-    RefPtr<WebCore::SharedBuffer::DataSegment> m_data;
>+    RefPtr<WebCore::FragmentedSharedBuffer::DataSegment> m_data;
>     bool m_parseCompleted;
> };
>diff --git a/Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.cpp b/Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.cpp
>index c717c45d3057..c071345b8bf3 100644
>--- a/Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.cpp
>+++ b/Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.cpp
>@@ -52,7 +52,7 @@ ICOImageDecoder::ICOImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOp
> 
> ICOImageDecoder::~ICOImageDecoder() = default;
> 
>-void ICOImageDecoder::setData(SharedBuffer& data, bool allDataReceived)
>+void ICOImageDecoder::setData(FragmentedSharedBuffer& data, bool allDataReceived)
> {
>     if (failed())
>         return;
>diff --git a/Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.h b/Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.h
>index fb7a903b2a07..10ee9b4d2e8c 100644
>--- a/Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.h
>+++ b/Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.h
>@@ -46,7 +46,7 @@ public:
> 
>     // ScalableImageDecoder
>     String filenameExtension() const final { return "ico"_s; }
>-    void setData(SharedBuffer&, bool allDataReceived) final;
>+    void setData(FragmentedSharedBuffer&, bool allDataReceived) final;
>     IntSize size() const final;
>     IntSize frameSizeAtIndex(size_t, SubsamplingLevel) const final;
>     bool setSize(const IntSize&) final;
>diff --git a/Source/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.cpp b/Source/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.cpp
>index fd345bb786ff..8fb9220ee37f 100644
>--- a/Source/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.cpp
>+++ b/Source/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.cpp
>@@ -222,7 +222,7 @@ static bool isICCMarker(jpeg_saved_marker_ptr marker)
> 
> static RefPtr<SharedBuffer> readICCProfile(jpeg_decompress_struct* info)
> {
>-    auto buffer = SharedBuffer::create();
>+    SharedBufferBuilder buffer;
>     for (jpeg_saved_marker_ptr marker = info->marker_list; marker; marker = marker->next) {
>         if (!isICCMarker(marker))
>             continue;
>@@ -236,13 +236,13 @@ static RefPtr<SharedBuffer> readICCProfile(jpeg_decompress_struct* info)
>             return nullptr;
> 
>         unsigned markerSize = marker->data_length - iccHeaderSize;
>-        buffer->append(reinterpret_cast<const uint8_t*>(marker->data + iccHeaderSize), markerSize);
>+        buffer.append(reinterpret_cast<const uint8_t*>(marker->data + iccHeaderSize), markerSize);
>     }
> 
>-    if (buffer->isEmpty())
>+    if (buffer.isEmpty())
>         return nullptr;
> 
>-    return buffer;
>+    return buffer.takeAsContiguous();
> }
> #endif
> 
>@@ -320,7 +320,7 @@ public:
>         m_bytesToSkip = std::max(numBytes - bytesToSkip, static_cast<long>(0));
>     }
> 
>-    bool decode(const SharedBuffer::DataSegment& data, bool onlySize)
>+    bool decode(const FragmentedSharedBuffer::DataSegment& data, bool onlySize)
>     {
>         m_decodingSizeOnly = onlySize;
> 
>diff --git a/Source/WebCore/platform/image-decoders/jpeg2000/JPEG2000ImageDecoder.cpp b/Source/WebCore/platform/image-decoders/jpeg2000/JPEG2000ImageDecoder.cpp
>index becf6450277e..20473f0eeebb 100644
>--- a/Source/WebCore/platform/image-decoders/jpeg2000/JPEG2000ImageDecoder.cpp
>+++ b/Source/WebCore/platform/image-decoders/jpeg2000/JPEG2000ImageDecoder.cpp
>@@ -380,7 +380,7 @@ void JPEG2000ImageDecoder::decode(bool onlySize, bool allDataReceived)
>     }
> 
>     struct Reader {
>-        SharedBuffer::DataSegment& data;
>+        FragmentedSharedBuffer::DataSegment& data;
>         size_t offset;
>     } reader = { *m_data, 0 };
> 
>diff --git a/Source/WebCore/platform/image-decoders/png/PNGImageDecoder.cpp b/Source/WebCore/platform/image-decoders/png/PNGImageDecoder.cpp
>index c12c459a5a3e..4cbd323d9a75 100644
>--- a/Source/WebCore/platform/image-decoders/png/PNGImageDecoder.cpp
>+++ b/Source/WebCore/platform/image-decoders/png/PNGImageDecoder.cpp
>@@ -152,7 +152,7 @@ public:
>         m_readOffset = 0;
>     }
> 
>-    bool decode(const SharedBuffer::DataSegment& data, bool sizeOnly, unsigned haltAtFrame)
>+    bool decode(const FragmentedSharedBuffer::DataSegment& data, bool sizeOnly, unsigned haltAtFrame)
>     {
>         m_decodingSizeOnly = sizeOnly;
>         PNGImageDecoder* decoder = static_cast<PNGImageDecoder*>(png_get_progressive_ptr(m_png));
>diff --git a/Source/WebCore/platform/image-decoders/webp/WEBPImageDecoder.cpp b/Source/WebCore/platform/image-decoders/webp/WEBPImageDecoder.cpp
>index 02f1b09dbc76..b1bec55e78c4 100644
>--- a/Source/WebCore/platform/image-decoders/webp/WEBPImageDecoder.cpp
>+++ b/Source/WebCore/platform/image-decoders/webp/WEBPImageDecoder.cpp
>@@ -47,7 +47,7 @@ WEBPImageDecoder::WEBPImageDecoder(AlphaOption alphaOption, GammaAndColorProfile
> 
> WEBPImageDecoder::~WEBPImageDecoder() = default;
> 
>-void WEBPImageDecoder::setData(SharedBuffer& data, bool allDataReceived)
>+void WEBPImageDecoder::setData(FragmentedSharedBuffer& data, bool allDataReceived)
> {
>     if (failed())
>         return;
>@@ -132,7 +132,7 @@ void WEBPImageDecoder::decode(size_t frameIndex, bool allDataReceived)
>     // 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<SharedBuffer::DataSegment> protectedData(m_data);
>+    RefPtr<FragmentedSharedBuffer::DataSegment> protectedData(m_data);
>     WebPData inputData = { protectedData->data(), protectedData->size() };
>     WebPDemuxState demuxerState;
>     WebPDemuxer* demuxer = WebPDemuxPartial(&inputData, &demuxerState);
>diff --git a/Source/WebCore/platform/image-decoders/webp/WEBPImageDecoder.h b/Source/WebCore/platform/image-decoders/webp/WEBPImageDecoder.h
>index af365e9cf9c7..dd28bc88df5c 100644
>--- a/Source/WebCore/platform/image-decoders/webp/WEBPImageDecoder.h
>+++ b/Source/WebCore/platform/image-decoders/webp/WEBPImageDecoder.h
>@@ -47,7 +47,7 @@ public:
>     virtual ~WEBPImageDecoder();
> 
>     String filenameExtension() const override { return "webp"_s; }
>-    void setData(SharedBuffer&, bool) final;
>+    void setData(FragmentedSharedBuffer&, bool) final;
>     ScalableImageDecoderFrame* frameBufferAtIndex(size_t index) override;
>     RepetitionCount repetitionCount() const override;
>     size_t frameCount() const override { return m_frameCount; }
>diff --git a/Source/WebCore/platform/ios/PasteboardIOS.mm b/Source/WebCore/platform/ios/PasteboardIOS.mm
>index 909e8e768adb..b2377fe3411d 100644
>--- a/Source/WebCore/platform/ios/PasteboardIOS.mm
>+++ b/Source/WebCore/platform/ios/PasteboardIOS.mm
>@@ -236,14 +236,14 @@ ALLOW_DEPRECATED_DECLARATIONS_BEGIN
> 
> #if !PLATFORM(MACCATALYST)
>     if ([type isEqualToString:(__bridge NSString *)kUTTypeFlatRTFD]) {
>-        RefPtr<SharedBuffer> buffer = strategy.readBufferFromPasteboard(itemIndex, kUTTypeFlatRTFD, m_pasteboardName, context());
>+        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<SharedBuffer> buffer = strategy.readBufferFromPasteboard(itemIndex, kUTTypeRTF, m_pasteboardName, context());
>+        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;
>@@ -251,7 +251,7 @@ ALLOW_DEPRECATED_DECLARATIONS_BEGIN
> #endif // !PLATFORM(MACCATALYST)
> 
>     if ([supportedImageTypes() containsObject:type]) {
>-        RefPtr<SharedBuffer> buffer = strategy.readBufferFromPasteboard(itemIndex, type, m_pasteboardName, context());
>+        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;
>diff --git a/Source/WebCore/platform/ios/PlatformPasteboardIOS.mm b/Source/WebCore/platform/ios/PlatformPasteboardIOS.mm
>index 167cef02d78d..16b3d5d4415d 100644
>--- a/Source/WebCore/platform/ios/PlatformPasteboardIOS.mm
>+++ b/Source/WebCore/platform/ios/PlatformPasteboardIOS.mm
>@@ -338,7 +338,7 @@ int64_t PlatformPasteboard::setTypes(const Vector<String>&)
>     return 0;
> }
> 
>-int64_t PlatformPasteboard::setBufferForType(SharedBuffer*, const String&)
>+int64_t PlatformPasteboard::setBufferForType(FragmentedSharedBuffer*, const String&)
> {
>     return 0;
> }
>@@ -463,7 +463,7 @@ void PlatformPasteboard::write(const PasteboardWebContent& content)
> 
>     ASSERT(content.clientTypes.size() == content.clientData.size());
>     for (size_t i = 0, size = content.clientTypes.size(); i < size; ++i)
>-        [representationsToRegister addData:content.clientData[i]->createNSData().get() forType:content.clientTypes[i]];
>+        [representationsToRegister addData:content.clientData[i]->makeContiguous()->createNSData().get() forType:content.clientTypes[i]];
> 
>     if (content.dataInWebArchiveFormat) {
>         auto webArchiveData = content.dataInWebArchiveFormat->createNSData();
>@@ -479,7 +479,7 @@ ALLOW_DEPRECATED_DECLARATIONS_END
>     }
> 
>     if (content.dataInAttributedStringFormat) {
>-        if (NSAttributedString *attributedString = [NSKeyedUnarchiver unarchivedObjectOfClasses:[NSSet setWithObject:NSAttributedString.class] fromData:content.dataInAttributedStringFormat->createNSData().get() error:nullptr])
>+        if (NSAttributedString *attributedString = [NSKeyedUnarchiver unarchivedObjectOfClasses:[NSSet setWithObject:NSAttributedString.class] fromData:content.dataInAttributedStringFormat->makeContiguous()->createNSData().get() error:nullptr])
>             [representationsToRegister addRepresentingObject:attributedString];
>     }
> 
>@@ -501,7 +501,7 @@ ALLOW_DEPRECATED_DECLARATIONS_END
> 
>     PasteboardCustomData customData;
>     customData.setOrigin(content.contentOrigin);
>-    [representationsToRegister addData:customData.createSharedBuffer()->createNSData().get() forType:@(PasteboardCustomData::cocoaType())];
>+    [representationsToRegister addData:customData.createSharedBuffer()->makeContiguous()->createNSData().get() forType:@(PasteboardCustomData::cocoaType())];
> 
>     registerItemToPasteboard(representationsToRegister.get(), m_pasteboard.get());
> }
>@@ -514,14 +514,14 @@ void PlatformPasteboard::write(const PasteboardImage& pasteboardImage)
>     auto& data = pasteboardImage.clientData;
>     ASSERT(types.size() == data.size());
>     for (size_t i = 0, size = types.size(); i < size; ++i)
>-        [representationsToRegister addData:data[i]->createNSData().get() forType:types[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->createNSData();
>+        auto imageData = pasteboardImage.resourceData->makeContiguous()->createNSData();
>         [representationsToRegister addData:imageData.get() forType:(NSString *)utiOrMIMEType];
>         [representationsToRegister setPreferredPresentationSize:pasteboardImage.imageSize];
>         [representationsToRegister setSuggestedName:pasteboardImage.suggestedName];
>@@ -635,7 +635,7 @@ static RetainPtr<WebItemProviderRegistrationInfoList> createItemProviderRegistra
>     [representationsToRegister setPreferredPresentationStyle:WebPreferredPresentationStyleInline];
> 
>     if (data.hasSameOriginCustomData() || !data.origin().isEmpty()) {
>-        if (auto serializedSharedBuffer = data.createSharedBuffer()->createNSData()) {
>+        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`
>@@ -672,8 +672,8 @@ ALLOW_DEPRECATED_DECLARATIONS_END
>             return;
>         }
> 
>-        auto buffer = std::get<Ref<SharedBuffer>>(value);
>-        [representationsToRegister addData:buffer->createNSData().get() forType:(NSString *)cocoaType];
>+        auto buffer = std::get<Ref<FragmentedSharedBuffer>>(value);
>+        [representationsToRegister addData:buffer->makeContiguous()->createNSData().get() forType:(NSString *)cocoaType];
>     });
> 
>     return representationsToRegister;
>diff --git a/Source/WebCore/platform/ios/PreviewConverterIOS.mm b/Source/WebCore/platform/ios/PreviewConverterIOS.mm
>index 544653c4403d..bfe36abd9743 100644
>--- a/Source/WebCore/platform/ios/PreviewConverterIOS.mm
>+++ b/Source/WebCore/platform/ios/PreviewConverterIOS.mm
>@@ -82,7 +82,7 @@ @end
> namespace WebCore {
> 
> PreviewConverter::PreviewConverter(const ResourceResponse& response, PreviewConverterProvider& provider)
>-    : m_previewData { SharedBuffer::create() }
>+    : m_previewData { FragmentedSharedBuffer::create() }
>     , m_originalResponse { response }
>     , m_provider { provider }
>     , m_platformDelegate { adoptNS([[WebPreviewConverterDelegate alloc] initWithDelegate:*this]) }
>diff --git a/Source/WebCore/platform/mac/PasteboardMac.mm b/Source/WebCore/platform/mac/PasteboardMac.mm
>index 677f8cadab59..0d25498b86be 100644
>--- a/Source/WebCore/platform/mac/PasteboardMac.mm
>+++ b/Source/WebCore/platform/mac/PasteboardMac.mm
>@@ -250,7 +250,7 @@ void Pasteboard::write(const Color& color)
> 
> static NSFileWrapper* fileWrapper(const PasteboardImage& pasteboardImage)
> {
>-    auto wrapper = adoptNS([[NSFileWrapper alloc] initRegularFileWithContents:pasteboardImage.resourceData->createNSData().get()]);
>+    auto wrapper = adoptNS([[NSFileWrapper alloc] initRegularFileWithContents:pasteboardImage.resourceData->makeContiguous()->createNSData().get()]);
>     [wrapper setPreferredFilename:suggestedFilenameWithMIMEType(pasteboardImage.url.url, pasteboardImage.resourceMIMEType)];
>     return wrapper.autorelease();
> }
>@@ -362,7 +362,7 @@ void Pasteboard::read(PasteboardPlainText& text, PlainTextURLReadingPolicy allow
>     
>     if (types.contains(String(legacyRTFDPasteboardType()))) {
>         if (auto data = readBufferAtPreferredItemIndex(legacyRTFDPasteboardType(), itemIndex, strategy, m_pasteboardName, context())) {
>-            if (auto attributedString = adoptNS([[NSAttributedString alloc] initWithRTFD:data->createNSData().get() documentAttributes:nil])) {
>+            if (auto attributedString = adoptNS([[NSAttributedString alloc] initWithRTFD:data->makeContiguous()->createNSData().get() documentAttributes:nil])) {
>                 text.text = [attributedString string];
>                 text.isURL = false;
>                 return;
>diff --git a/Source/WebCore/platform/mac/PasteboardWriter.mm b/Source/WebCore/platform/mac/PasteboardWriter.mm
>index 353d006b90cb..88d040258437 100644
>--- a/Source/WebCore/platform/mac/PasteboardWriter.mm
>+++ b/Source/WebCore/platform/mac/PasteboardWriter.mm
>@@ -128,11 +128,11 @@ ALLOW_DEPRECATED_DECLARATIONS_END
>             [pasteboardItem setString:webContent->dataInStringFormat forType:NSPasteboardTypeString];
> 
>         for (unsigned i = 0; i < webContent->clientTypes.size(); ++i)
>-            [pasteboardItem setData:webContent->clientData[i]->createNSData().get() forType:toUTIUnlessAlreadyUTI(webContent->clientTypes[i]).get()];
>+            [pasteboardItem setData:webContent->clientData[i]->makeContiguous()->createNSData().get() forType:toUTIUnlessAlreadyUTI(webContent->clientTypes[i]).get()];
> 
>         PasteboardCustomData customData;
>         customData.setOrigin(webContent->contentOrigin);
>-        [pasteboardItem setData:customData.createSharedBuffer()->createNSData().get() forType:toUTIUnlessAlreadyUTI(String(PasteboardCustomData::cocoaType())).get()];
>+        [pasteboardItem setData:customData.createSharedBuffer()->makeContiguous()->createNSData().get() forType:toUTIUnlessAlreadyUTI(String(PasteboardCustomData::cocoaType())).get()];
>     }
> 
>     return pasteboardItem;
>diff --git a/Source/WebCore/platform/mac/PlatformPasteboardMac.mm b/Source/WebCore/platform/mac/PlatformPasteboardMac.mm
>index d9b7d248038c..c3b4d2d96217 100644
>--- a/Source/WebCore/platform/mac/PlatformPasteboardMac.mm
>+++ b/Source/WebCore/platform/mac/PlatformPasteboardMac.mm
>@@ -263,8 +263,8 @@ int64_t PlatformPasteboard::write(const PasteboardCustomData& data)
>         if (platformType.isEmpty())
>             return;
> 
>-        if (std::holds_alternative<Ref<SharedBuffer>>(stringOrBuffer)) {
>-            if (auto platformData = std::get<Ref<SharedBuffer>>(stringOrBuffer)->createNSData())
>+        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);
>@@ -274,7 +274,7 @@ int64_t PlatformPasteboard::write(const PasteboardCustomData& data)
>     });
> 
>     if (shouldWriteCustomData) {
>-        if (auto serializedCustomData = data.createSharedBuffer()->createNSData())
>+        if (auto serializedCustomData = data.createSharedBuffer()->makeContiguous()->createNSData())
>             [m_pasteboard setData:serializedCustomData.get() forType:@(PasteboardCustomData::cocoaType())];
>     }
> 
>@@ -341,12 +341,12 @@ int64_t PlatformPasteboard::setTypes(const Vector<String>& pasteboardTypes)
>     return [m_pasteboard declareTypes:createNSArray(pasteboardTypes).get() owner:nil];
> }
> 
>-int64_t PlatformPasteboard::setBufferForType(SharedBuffer* buffer, const String& pasteboardType)
>+int64_t PlatformPasteboard::setBufferForType(FragmentedSharedBuffer* buffer, const String& pasteboardType)
> {
>     if (!canWritePasteboardType(pasteboardType))
>         return 0;
> 
>-    BOOL didWriteData = [m_pasteboard setData:buffer ? buffer->createNSData().get() : nil forType:pasteboardType];
>+    BOOL didWriteData = [m_pasteboard setData:buffer ? buffer->makeContiguous()->createNSData().get() : nil forType:pasteboardType];
>     if (!didWriteData)
>         return 0;
>     return changeCount();
>@@ -504,8 +504,8 @@ static RetainPtr<NSPasteboardItem> createPasteboardItem(const PasteboardCustomDa
>         if (!platformType)
>             return;
> 
>-        if (std::holds_alternative<Ref<SharedBuffer>>(stringOrBuffer)) {
>-            if (auto platformData = std::get<Ref<SharedBuffer>>(stringOrBuffer)->createNSData())
>+        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);
>diff --git a/Source/WebCore/platform/mediarecorder/MediaRecorderPrivate.h b/Source/WebCore/platform/mediarecorder/MediaRecorderPrivate.h
>index 6813d5da7dcb..796554f4c976 100644
>--- a/Source/WebCore/platform/mediarecorder/MediaRecorderPrivate.h
>+++ b/Source/WebCore/platform/mediarecorder/MediaRecorderPrivate.h
>@@ -43,7 +43,7 @@ class MediaSample;
> class MediaStreamPrivate;
> class MediaStreamTrackPrivate;
> class PlatformAudioData;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> struct MediaRecorderPrivateOptions;
> 
>@@ -59,7 +59,7 @@ public:
>     };
>     WEBCORE_EXPORT static AudioVideoSelectedTracks selectTracks(MediaStreamPrivate&);
> 
>-    using FetchDataCallback = CompletionHandler<void(RefPtr<SharedBuffer>&&, const String& mimeType, double)>;
>+    using FetchDataCallback = CompletionHandler<void(RefPtr<FragmentedSharedBuffer>&&, const String& mimeType, double)>;
>     virtual void fetchData(FetchDataCallback&&) = 0;
>     virtual const String& mimeType() const = 0;
> 
>diff --git a/Source/WebCore/platform/mediarecorder/MediaRecorderPrivateMock.cpp b/Source/WebCore/platform/mediarecorder/MediaRecorderPrivateMock.cpp
>index c25df91574a6..498d4ee1340c 100644
>--- a/Source/WebCore/platform/mediarecorder/MediaRecorderPrivateMock.cpp
>+++ b/Source/WebCore/platform/mediarecorder/MediaRecorderPrivateMock.cpp
>@@ -93,7 +93,7 @@ void MediaRecorderPrivateMock::generateMockCounterString()
> 
> void MediaRecorderPrivateMock::fetchData(FetchDataCallback&& completionHandler)
> {
>-    RefPtr<SharedBuffer> buffer;
>+    RefPtr<FragmentedSharedBuffer> buffer;
>     {
>         Locker locker { m_bufferLock };
>         Vector<uint8_t> value { m_buffer.characters8(), m_buffer.length() };
>diff --git a/Source/WebCore/platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.h b/Source/WebCore/platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.h
>index 211f75ee73af..9c2c797b8195 100644
>--- a/Source/WebCore/platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.h
>+++ b/Source/WebCore/platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.h
>@@ -70,7 +70,7 @@ public:
>     void appendVideoSampleBuffer(MediaSample&);
>     void appendAudioSampleBuffer(const PlatformAudioData&, const AudioStreamDescription&, const WTF::MediaTime&, size_t);
>     void stopRecording();
>-    void fetchData(CompletionHandler<void(RefPtr<SharedBuffer>&&, double)>&&);
>+    void fetchData(CompletionHandler<void(RefPtr<FragmentedSharedBuffer>&&, double)>&&);
> 
>     void pause();
>     void resume();
>@@ -105,7 +105,7 @@ private:
> 
>     void finishedFlushingSamples();
>     void completeFetchData();
>-    RefPtr<SharedBuffer> takeData();
>+    RefPtr<FragmentedSharedBuffer> takeData();
> 
>     bool m_hasAudio { false };
>     bool m_hasVideo { false };
>@@ -117,8 +117,8 @@ private:
>     RetainPtr<AVAssetWriter> m_writer;
> 
>     Lock m_dataLock;
>-    RefPtr<SharedBuffer> m_data WTF_GUARDED_BY_LOCK(m_dataLock);
>-    CompletionHandler<void(RefPtr<SharedBuffer>&&, double)> m_fetchDataCompletionHandler;
>+    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;
>diff --git a/Source/WebCore/platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.mm b/Source/WebCore/platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.mm
>index 8c1f7c0e5313..8484100eac5e 100644
>--- a/Source/WebCore/platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.mm
>+++ b/Source/WebCore/platform/mediarecorder/cocoa/MediaRecorderPrivateWriterCocoa.mm
>@@ -137,10 +137,8 @@ MediaRecorderPrivateWriter::~MediaRecorderPrivateWriter()
>         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);
>@@ -495,7 +493,7 @@ void MediaRecorderPrivateWriter::stopRecording()
>     });
> }
> 
>-void MediaRecorderPrivateWriter::fetchData(CompletionHandler<void(RefPtr<SharedBuffer>&&, double)>&& completionHandler)
>+void MediaRecorderPrivateWriter::fetchData(CompletionHandler<void(RefPtr<FragmentedSharedBuffer>&&, double)>&& completionHandler)
> {
>     m_fetchDataCompletionHandler = WTFMove(completionHandler);
> 
>@@ -537,18 +535,13 @@ void MediaRecorderPrivateWriter::completeFetchData()
> void MediaRecorderPrivateWriter::appendData(const uint8_t* data, size_t size)
> {
>     Locker locker { m_dataLock };
>-    if (!m_data) {
>-        m_data = SharedBuffer::create(data, size);
>-        return;
>-    }
>-    m_data->append(data, size);
>+    m_data.append(data, size);
> }
> 
>-RefPtr<SharedBuffer> MediaRecorderPrivateWriter::takeData()
>+RefPtr<FragmentedSharedBuffer> MediaRecorderPrivateWriter::takeData()
> {
>     Locker locker { m_dataLock };
>-    auto data = WTFMove(m_data);
>-    return data;
>+    return m_data.take();
> }
> 
> void MediaRecorderPrivateWriter::pause()
>diff --git a/Source/WebCore/platform/network/DataURLDecoder.h b/Source/WebCore/platform/network/DataURLDecoder.h
>index a9b29d59e9aa..cdee603523cd 100644
>--- a/Source/WebCore/platform/network/DataURLDecoder.h
>+++ b/Source/WebCore/platform/network/DataURLDecoder.h
>@@ -33,7 +33,7 @@
> 
> namespace WebCore {
> 
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> namespace DataURLDecoder {
> 
>diff --git a/Source/WebCore/platform/network/ResourceHandle.h b/Source/WebCore/platform/network/ResourceHandle.h
>index fafdfe87c837..4bebcb5098d1 100644
>--- a/Source/WebCore/platform/network/ResourceHandle.h
>+++ b/Source/WebCore/platform/network/ResourceHandle.h
>@@ -84,7 +84,7 @@ class NetworkLoadMetrics;
> class ResourceRequest;
> class ResourceResponse;
> class SecurityOrigin;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> class SynchronousLoaderMessageQueue;
> class Timer;
> 
>diff --git a/Source/WebCore/platform/network/ResourceHandleClient.cpp b/Source/WebCore/platform/network/ResourceHandleClient.cpp
>index 6e65bb8918c6..ba8fd4ff4f1e 100644
>--- a/Source/WebCore/platform/network/ResourceHandleClient.cpp
>+++ b/Source/WebCore/platform/network/ResourceHandleClient.cpp
>@@ -36,9 +36,9 @@ ResourceHandleClient::ResourceHandleClient() = default;
> 
> ResourceHandleClient::~ResourceHandleClient() = default;
> 
>-void ResourceHandleClient::didReceiveBuffer(ResourceHandle* handle, Ref<SharedBuffer>&& buffer, int encodedDataLength)
>+void ResourceHandleClient::didReceiveBuffer(ResourceHandle* handle, Ref<FragmentedSharedBuffer>&& buffer, int encodedDataLength)
> {
>-    didReceiveData(handle, buffer->data(), buffer->size(), encodedDataLength);
>+    didReceiveData(handle, buffer->makeContiguous()->data(), buffer->size(), encodedDataLength);
> }
> 
> }
>diff --git a/Source/WebCore/platform/network/ResourceHandleClient.h b/Source/WebCore/platform/network/ResourceHandleClient.h
>index b6337d56ce8c..c4f05485f287 100644
>--- a/Source/WebCore/platform/network/ResourceHandleClient.h
>+++ b/Source/WebCore/platform/network/ResourceHandleClient.h
>@@ -50,7 +50,7 @@ class ResourceHandle;
> class ResourceError;
> class ResourceRequest;
> class ResourceResponse;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> enum CacheStoragePolicy {
>     StorageAllowed,
>@@ -66,7 +66,7 @@ public:
>     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<SharedBuffer>&&, int encodedDataLength);
>+    WEBCORE_EXPORT virtual void didReceiveBuffer(ResourceHandle*, Ref<FragmentedSharedBuffer>&&, int encodedDataLength);
>     
>     virtual void didFinishLoading(ResourceHandle*, const NetworkLoadMetrics&) { }
>     virtual void didFail(ResourceHandle*, const ResourceError&) { }
>diff --git a/Source/WebCore/platform/network/cocoa/RangeResponseGenerator.mm b/Source/WebCore/platform/network/cocoa/RangeResponseGenerator.mm
>index 1ff065216fa6..008e226ff919 100644
>--- a/Source/WebCore/platform/network/cocoa/RangeResponseGenerator.mm
>+++ b/Source/WebCore/platform/network/cocoa/RangeResponseGenerator.mm
>@@ -41,8 +41,7 @@ namespace WebCore {
> struct RangeResponseGenerator::Data {
>     WTF_MAKE_STRUCT_FAST_ALLOCATED;
>     Data(const ResourceResponse& response, PlatformMediaResource& resource)
>-        : buffer(SharedBuffer::create())
>-        , originalResponse(response)
>+        : originalResponse(response)
>         , resource(&resource) { }
> 
>     struct TaskData : public CanMakeWeakPtr<TaskData> {
>@@ -55,9 +54,9 @@ struct RangeResponseGenerator::Data {
>         size_t nextByteToGiveBufferIndex { 0 };
>         enum class ResponseState : uint8_t { NotSynthesizedYet, WaitingForSession, SessionCalledCompletionHandler } responseState { ResponseState::NotSynthesizedYet };
>     };
>-    
>+
>     HashMap<RetainPtr<WebCoreNSURLSessionDataTask>, std::unique_ptr<TaskData>> taskData;
>-    Ref<SharedBuffer> buffer;
>+    SharedBufferBuilder buffer;
>     ResourceResponse originalResponse;
>     enum class SuccessfullyFinishedLoading : bool { No, Yes } successfullyFinishedLoading { SuccessfullyFinishedLoading::No };
>     RefPtr<PlatformMediaResource> resource;
>@@ -106,22 +105,22 @@ void RangeResponseGenerator::removeTask(WebCoreNSURLSessionDataTask *task)
> 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, taskData = WeakPtr { *taskData }, generator = WeakPtr { *this }] {
>+
>+    auto giveBytesToTask = [task = retainPtr(task), buffer, bufferSize, taskData = WeakPtr { *taskData }, generator = WeakPtr { *this }] {
>         ASSERT(isMainThread());
>         if ([task state] != NSURLSessionTaskStateRunning)
>             return;
>@@ -130,7 +129,7 @@ void RangeResponseGenerator::giveResponseToTaskIfBytesInRangeReceived(WebCoreNSU
>         auto& range = taskData->range;
>         auto& byteIndex = taskData->nextByteToGiveBufferIndex;
>         while (true) {
>-            if (byteIndex >= buffer->size())
>+            if (byteIndex >= bufferSize)
>                 break;
>             auto bufferView = buffer->getSomeData(byteIndex);
>             if (!bufferView.size() || byteIndex > range.end)
>@@ -175,7 +174,7 @@ std::optional<size_t> RangeResponseGenerator::expectedContentLengthFromData(cons
> {
>     ASSERT(isMainThread());
>     if (data.successfullyFinishedLoading == Data::SuccessfullyFinishedLoading::Yes)
>-        return data.buffer->size();
>+        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();
>@@ -244,7 +243,7 @@ private:
>         return false;
>     }
> 
>-    void dataReceived(PlatformMediaResource&, Ref<SharedBuffer>&& buffer) final
>+    void dataReceived(PlatformMediaResource&, Ref<FragmentedSharedBuffer>&& buffer) final
>     {
>         ASSERT(isMainThread());
>         if (!m_generator)
>@@ -252,7 +251,7 @@ private:
>         auto* data = m_generator->m_map.get(m_urlString);
>         if (!data)
>             return;
>-        data->buffer->append(WTFMove(buffer));
>+        data->buffer.append(WTFMove(buffer));
>         m_generator->giveResponseToTasksWithFinishedRanges(*data);
>     }
> 
>diff --git a/Source/WebCore/platform/network/cocoa/WebCoreNSURLSession.h b/Source/WebCore/platform/network/cocoa/WebCoreNSURLSession.h
>index 404885ae6376..ce4c2545cde0 100644
>--- a/Source/WebCore/platform/network/cocoa/WebCoreNSURLSession.h
>+++ b/Source/WebCore/platform/network/cocoa/WebCoreNSURLSession.h
>@@ -50,7 +50,7 @@ class PlatformMediaResourceLoader;
> class ResourceError;
> class ResourceRequest;
> class ResourceResponse;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> class SharedBufferDataView;
> class WebCoreNSURLSessionDataTaskClient;
> enum class ShouldContinuePolicyCheck : bool;
>@@ -158,7 +158,7 @@ WEBCORE_EXPORT @interface WebCoreNSURLSession : NSObject {
> - (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::SharedBuffer>&&)data;
>+- (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;
>diff --git a/Source/WebCore/platform/network/cocoa/WebCoreNSURLSession.mm b/Source/WebCore/platform/network/cocoa/WebCoreNSURLSession.mm
>index e04010a9811b..8c89d9386579 100644
>--- a/Source/WebCore/platform/network/cocoa/WebCoreNSURLSession.mm
>+++ b/Source/WebCore/platform/network/cocoa/WebCoreNSURLSession.mm
>@@ -608,7 +608,7 @@ public:
>     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<SharedBuffer>&&) 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;
>@@ -652,7 +652,7 @@ bool WebCoreNSURLSessionDataTaskClient::shouldCacheResponse(PlatformMediaResourc
>     return [m_task resource:&resource shouldCacheResponse:response];
> }
> 
>-void WebCoreNSURLSessionDataTaskClient::dataReceived(PlatformMediaResource& resource, Ref<SharedBuffer>&& buffer)
>+void WebCoreNSURLSessionDataTaskClient::dataReceived(PlatformMediaResource& resource, Ref<FragmentedSharedBuffer>&& buffer)
> {
>     Locker locker { m_taskLock };
>     if (!m_task)
>@@ -915,11 +915,11 @@ - (BOOL)resource:(PlatformMediaResource*)resource shouldCacheResponse:(const Res
>     return response.httpHeaderField(HTTPHeaderName::ContentRange).isEmpty();
> }
> 
>-- (void)resource:(PlatformMediaResource*)resource receivedData:(Ref<WebCore::SharedBuffer>&&)data
>+- (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->createNSData();
>+        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:)])
>diff --git a/Source/WebCore/platform/network/curl/CurlDownload.cpp b/Source/WebCore/platform/network/curl/CurlDownload.cpp
>index c36e1f887643..3494459254ac 100644
>--- a/Source/WebCore/platform/network/curl/CurlDownload.cpp
>+++ b/Source/WebCore/platform/network/curl/CurlDownload.cpp
>@@ -103,7 +103,7 @@ void CurlDownload::curlDidReceiveResponse(CurlRequest& request, CurlResponse&& r
> }
> 
> 
>-void CurlDownload::curlDidReceiveBuffer(CurlRequest&, Ref<SharedBuffer>&& buffer)
>+void CurlDownload::curlDidReceiveBuffer(CurlRequest&, Ref<FragmentedSharedBuffer>&& buffer)
> {
>     ASSERT(isMainThread());
> 
>diff --git a/Source/WebCore/platform/network/curl/CurlDownload.h b/Source/WebCore/platform/network/curl/CurlDownload.h
>index a3aa0cf5fcd2..cde4445775f7 100644
>--- a/Source/WebCore/platform/network/curl/CurlDownload.h
>+++ b/Source/WebCore/platform/network/curl/CurlDownload.h
>@@ -72,7 +72,7 @@ private:
>     Ref<CurlRequest> createCurlRequest(ResourceRequest&);
>     void curlDidSendData(CurlRequest&, unsigned long long, unsigned long long) override { }
>     void curlDidReceiveResponse(CurlRequest&, CurlResponse&&) override;
>-    void curlDidReceiveBuffer(CurlRequest&, Ref<SharedBuffer>&&) override;
>+    void curlDidReceiveBuffer(CurlRequest&, Ref<FragmentedSharedBuffer>&&) override;
>     void curlDidComplete(CurlRequest&, NetworkLoadMetrics&&) override;
>     void curlDidFailWithError(CurlRequest&, ResourceError&&, CertificateInfo&&) override;
> 
>diff --git a/Source/WebCore/platform/network/curl/CurlMultipartHandle.cpp b/Source/WebCore/platform/network/curl/CurlMultipartHandle.cpp
>index bbda3fbda758..090d039ba45d 100644
>--- a/Source/WebCore/platform/network/curl/CurlMultipartHandle.cpp
>+++ b/Source/WebCore/platform/network/curl/CurlMultipartHandle.cpp
>@@ -119,12 +119,12 @@ CurlMultipartHandle::CurlMultipartHandle(CurlMultipartHandleClient& client, cons
> 
> }
> 
>-void CurlMultipartHandle::didReceiveData(const SharedBuffer& buffer)
>+void CurlMultipartHandle::didReceiveData(const FragmentedSharedBuffer& buffer)
> {
>     if (m_state == State::End)
>         return; // The handler is closed down so ignore everything.
> 
>-    m_buffer.append(buffer.data(), buffer.size());
>+    m_buffer.append(buffer.makeContiguous()->data(), buffer.size());
> 
>     while (processContent()) { }
> }
>@@ -137,7 +137,7 @@ void CurlMultipartHandle::didComplete()
>     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(m_buffer.data(), m_buffer.size()));
>+        m_client.didReceiveDataFromMultipart(SharedBuffer::create(WTFMove(m_buffer)));
>         m_state = State::End;
>     }
> 
>diff --git a/Source/WebCore/platform/network/curl/CurlMultipartHandle.h b/Source/WebCore/platform/network/curl/CurlMultipartHandle.h
>index 5c08bcc5eb3e..9a1a1bbd1938 100644
>--- a/Source/WebCore/platform/network/curl/CurlMultipartHandle.h
>+++ b/Source/WebCore/platform/network/curl/CurlMultipartHandle.h
>@@ -34,7 +34,7 @@ namespace WebCore {
> 
> class CurlMultipartHandleClient;
> class CurlResponse;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class CurlMultipartHandle {
>     WTF_MAKE_FAST_ALLOCATED;
>@@ -44,7 +44,7 @@ public:
>     CurlMultipartHandle(CurlMultipartHandleClient&, const String&);
>     ~CurlMultipartHandle() { }
> 
>-    void didReceiveData(const SharedBuffer&);
>+    void didReceiveData(const FragmentedSharedBuffer&);
>     void didComplete();
> 
> private:
>diff --git a/Source/WebCore/platform/network/curl/CurlMultipartHandleClient.h b/Source/WebCore/platform/network/curl/CurlMultipartHandleClient.h
>index fd13fd381314..c813886a8d5c 100644
>--- a/Source/WebCore/platform/network/curl/CurlMultipartHandleClient.h
>+++ b/Source/WebCore/platform/network/curl/CurlMultipartHandleClient.h
>@@ -28,12 +28,12 @@
> namespace WebCore {
> 
> class CurlResponse;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class CurlMultipartHandleClient {
> public:
>     virtual void didReceiveHeaderFromMultipart(const Vector<String>&) = 0;
>-    virtual void didReceiveDataFromMultipart(Ref<SharedBuffer>&&) = 0;
>+    virtual void didReceiveDataFromMultipart(Ref<FragmentedSharedBuffer>&&) = 0;
> 
> protected:
>     ~CurlMultipartHandleClient() { }
>diff --git a/Source/WebCore/platform/network/curl/CurlRequest.cpp b/Source/WebCore/platform/network/curl/CurlRequest.cpp
>index d35b0e839195..d82dd3c10ac6 100644
>--- a/Source/WebCore/platform/network/curl/CurlRequest.cpp
>+++ b/Source/WebCore/platform/network/curl/CurlRequest.cpp
>@@ -396,7 +396,7 @@ size_t CurlRequest::didReceiveHeader(String&& header)
> 
> // called with data after all headers have been processed via headerCallback
> 
>-size_t CurlRequest::didReceiveData(Ref<SharedBuffer>&& buffer)
>+size_t CurlRequest::didReceiveData(Ref<FragmentedSharedBuffer>&& buffer)
> {
>     if (isCompletedOrCancelled())
>         return 0;
>@@ -444,7 +444,7 @@ void CurlRequest::didReceiveHeaderFromMultipart(const Vector<String>& headers)
>     invokeDidReceiveResponse(response, Action::None);
> }
> 
>-void CurlRequest::didReceiveDataFromMultipart(Ref<SharedBuffer>&& buffer)
>+void CurlRequest::didReceiveDataFromMultipart(Ref<FragmentedSharedBuffer>&& buffer)
> {
>     if (isCompletedOrCancelled())
>         return;
>@@ -777,7 +777,7 @@ const String& CurlRequest::getDownloadedFilePath()
>     return m_downloadFilePath;
> }
> 
>-void CurlRequest::writeDataToDownloadFileIfEnabled(const SharedBuffer& buffer)
>+void CurlRequest::writeDataToDownloadFileIfEnabled(const FragmentedSharedBuffer& buffer)
> {
>     {
>         Locker locker { m_downloadMutex };
>@@ -790,7 +790,7 @@ void CurlRequest::writeDataToDownloadFileIfEnabled(const SharedBuffer& buffer)
>     }
> 
>     if (m_downloadFileHandle != FileSystem::invalidPlatformFileHandle)
>-        FileSystem::writeToFile(m_downloadFileHandle, buffer.data(), buffer.size());
>+        FileSystem::writeToFile(m_downloadFileHandle, buffer.makeContiguous()->data(), buffer.size());
> }
> 
> void CurlRequest::closeDownloadFile()
>diff --git a/Source/WebCore/platform/network/curl/CurlRequest.h b/Source/WebCore/platform/network/curl/CurlRequest.h
>index 6bd8a6bfba37..3c7cdd883eb6 100644
>--- a/Source/WebCore/platform/network/curl/CurlRequest.h
>+++ b/Source/WebCore/platform/network/curl/CurlRequest.h
>@@ -42,7 +42,7 @@ namespace WebCore {
> class CurlRequestClient;
> class NetworkLoadMetrics;
> class ResourceError;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> class SynchronousLoaderMessageQueue;
> 
> class CurlRequest : public ThreadSafeRefCounted<CurlRequest>, public CurlRequestSchedulerClient, public CurlMultipartHandleClient {
>@@ -122,9 +122,9 @@ private:
>     CURL* setupTransfer() override;
>     size_t willSendData(char*, size_t, size_t);
>     size_t didReceiveHeader(String&&);
>-    size_t didReceiveData(Ref<SharedBuffer>&&);
>+    size_t didReceiveData(Ref<FragmentedSharedBuffer>&&);
>     void didReceiveHeaderFromMultipart(const Vector<String>&) override;
>-    void didReceiveDataFromMultipart(Ref<SharedBuffer>&&) override;
>+    void didReceiveDataFromMultipart(Ref<FragmentedSharedBuffer>&&) override;
>     void didCompleteTransfer(CURLcode) override;
>     void didCancelTransfer() override;
>     void finalizeTransfer();
>@@ -153,7 +153,7 @@ private:
>     NetworkLoadMetrics networkLoadMetrics();
> 
>     // Download
>-    void writeDataToDownloadFileIfEnabled(const SharedBuffer&);
>+    void writeDataToDownloadFileIfEnabled(const FragmentedSharedBuffer&);
>     void closeDownloadFile();
>     void cleanupDownloadFile();
> 
>diff --git a/Source/WebCore/platform/network/curl/CurlRequestClient.h b/Source/WebCore/platform/network/curl/CurlRequestClient.h
>index 08c86c7d4684..3479832f576d 100644
>--- a/Source/WebCore/platform/network/curl/CurlRequestClient.h
>+++ b/Source/WebCore/platform/network/curl/CurlRequestClient.h
>@@ -34,7 +34,7 @@ class CurlRequest;
> class CurlResponse;
> class NetworkLoadMetrics;
> class ResourceError;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class CurlRequestClient {
> public:
>@@ -43,7 +43,7 @@ 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<SharedBuffer>&&) = 0;
>+    virtual void curlDidReceiveBuffer(CurlRequest&, Ref<FragmentedSharedBuffer>&&) = 0;
>     virtual void curlDidComplete(CurlRequest&, NetworkLoadMetrics&&) = 0;
>     virtual void curlDidFailWithError(CurlRequest&, ResourceError&&, CertificateInfo&&) = 0;
> };
>diff --git a/Source/WebCore/platform/network/curl/CurlResourceHandleDelegate.cpp b/Source/WebCore/platform/network/curl/CurlResourceHandleDelegate.cpp
>index 818d5a95e3e1..305d4e5c9fc2 100644
>--- a/Source/WebCore/platform/network/curl/CurlResourceHandleDelegate.cpp
>+++ b/Source/WebCore/platform/network/curl/CurlResourceHandleDelegate.cpp
>@@ -142,15 +142,16 @@ void CurlResourceHandleDelegate::curlDidReceiveResponse(CurlRequest& request, Cu
>     });
> }
> 
>-void CurlResourceHandleDelegate::curlDidReceiveBuffer(CurlRequest&, Ref<SharedBuffer>&& buffer)
>+void CurlResourceHandleDelegate::curlDidReceiveBuffer(CurlRequest&, Ref<FragmentedSharedBuffer>&& buffer)
> {
>     ASSERT(isMainThread());
> 
>     if (cancelledOrClientless())
>         return;
> 
>-    CurlCacheManager::singleton().didReceiveData(m_handle, buffer->data(), buffer->size());
>-    client()->didReceiveBuffer(&m_handle, WTFMove(buffer), buffer->size());
>+    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)
>diff --git a/Source/WebCore/platform/network/curl/CurlResourceHandleDelegate.h b/Source/WebCore/platform/network/curl/CurlResourceHandleDelegate.h
>index 6d55864452fd..daf0a59a4e58 100644
>--- a/Source/WebCore/platform/network/curl/CurlResourceHandleDelegate.h
>+++ b/Source/WebCore/platform/network/curl/CurlResourceHandleDelegate.h
>@@ -53,7 +53,7 @@ public:
> 
>     void curlDidSendData(CurlRequest&, unsigned long long bytesSent, unsigned long long totalBytesToBeSent) final;
>     void curlDidReceiveResponse(CurlRequest&, CurlResponse&&) final;
>-    void curlDidReceiveBuffer(CurlRequest&, Ref<SharedBuffer>&&) final;
>+    void curlDidReceiveBuffer(CurlRequest&, Ref<FragmentedSharedBuffer>&&) final;
>     void curlDidComplete(CurlRequest&, NetworkLoadMetrics&&) final;
>     void curlDidFailWithError(CurlRequest&, ResourceError&&, CertificateInfo&&) final;
> 
>diff --git a/Source/WebCore/platform/network/ios/LegacyPreviewLoaderClient.h b/Source/WebCore/platform/network/ios/LegacyPreviewLoaderClient.h
>index bc4daafbf21a..1f4a19313312 100644
>--- a/Source/WebCore/platform/network/ios/LegacyPreviewLoaderClient.h
>+++ b/Source/WebCore/platform/network/ios/LegacyPreviewLoaderClient.h
>@@ -31,12 +31,12 @@
> 
> namespace WebCore {
> 
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> class LegacyPreviewLoaderClient : public RefCounted<LegacyPreviewLoaderClient> {
> public:
>     virtual ~LegacyPreviewLoaderClient() = default;
>-    virtual void didReceiveBuffer(const SharedBuffer&) { }
>+    virtual void didReceiveBuffer(const FragmentedSharedBuffer&) { }
>     virtual void didFinishLoading() { }
>     virtual void didFail() { }
>     virtual bool supportsPasswordEntry() const { return false; }
>diff --git a/Source/WebCore/platform/win/PasteboardWin.cpp b/Source/WebCore/platform/win/PasteboardWin.cpp
>index 2b3128587030..83e66d086539 100644
>--- a/Source/WebCore/platform/win/PasteboardWin.cpp
>+++ b/Source/WebCore/platform/win/PasteboardWin.cpp
>@@ -356,7 +356,7 @@ String Pasteboard::readStringInCustomData(const String& type)
> 
> struct PasteboardFileCounter final : PasteboardFileReader {
>     void readFilename(const String&) final { ++count; }
>-    void readBuffer(const String&, const String&, Ref<SharedBuffer>&&) final { ++count; }
>+    void readBuffer(const String&, const String&, Ref<FragmentedSharedBuffer>&&) final { ++count; }
> 
>     unsigned count { 0 };
> };
>@@ -966,7 +966,7 @@ static HGLOBAL createGlobalImageFileDescriptor(const String& url, const String&
>     return memObj;
> }
> 
>-static HGLOBAL createGlobalImageFileContent(SharedBuffer* data)
>+static HGLOBAL createGlobalImageFileContent(FragmentedSharedBuffer* data)
> {
>     HGLOBAL memObj = GlobalAlloc(GPTR, data->size());
>     if (!memObj) 
>@@ -978,15 +978,15 @@ static HGLOBAL createGlobalImageFileContent(SharedBuffer* data)
>         return 0;
>     }
> 
>-    if (data->data())
>-        CopyMemory(fileContents, data->data(), data->size());
>+    if (data->size())
>+        CopyMemory(fileContents, data->makeContiguous()->data(), data->size());
> 
>     GlobalUnlock(memObj);
> 
>     return memObj;
> }
> 
>-static HGLOBAL createGlobalHDropContent(const URL& url, String& fileName, SharedBuffer* data)
>+static HGLOBAL createGlobalHDropContent(const URL& url, String& fileName, FragmentedSharedBuffer* data)
> {
>     if (fileName.isEmpty() || !data)
>         return 0;
>@@ -1030,8 +1030,8 @@ static HGLOBAL createGlobalHDropContent(const URL& url, String& fileName, Shared
>         // Write the data to this temp file.
>         DWORD written;
>         BOOL tempWriteSucceeded = FALSE;
>-        if (data->data())
>-            tempWriteSucceeded = WriteFile(tempFileHandle, data->data(), data->size(), &written, 0);
>+        if (data->size())
>+            tempWriteSucceeded = WriteFile(tempFileHandle, data->makeContiguous()->data(), data->size(), &written, 0);
>         CloseHandle(tempFileHandle);
>         if (!tempWriteSucceeded)
>             return 0;
>@@ -1063,7 +1063,7 @@ void Pasteboard::writeImageToDataObject(Element& element, const URL& url)
>     if (!cachedImage || !cachedImage->imageForRenderer(element.renderer()) || !cachedImage->isLoaded())
>         return;
> 
>-    SharedBuffer* imageBuffer = cachedImage->imageForRenderer(element.renderer())->data();
>+    FragmentedSharedBuffer* imageBuffer = cachedImage->imageForRenderer(element.renderer())->data();
>     if (!imageBuffer || !imageBuffer->size())
>         return;
> 
>diff --git a/Source/WebCore/testing/MockCDMFactory.cpp b/Source/WebCore/testing/MockCDMFactory.cpp
>index 411edbb3517b..84fa29ce1f30 100644
>--- a/Source/WebCore/testing/MockCDMFactory.cpp
>+++ b/Source/WebCore/testing/MockCDMFactory.cpp
>@@ -63,7 +63,7 @@ bool MockCDMFactory::supportsKeySystem(const String& keySystem)
>     return equalIgnoringASCIICase(keySystem, "org.webkit.mock");
> }
> 
>-void MockCDMFactory::addKeysToSessionWithID(const String& id, Vector<Ref<SharedBuffer>>&& keys)
>+void MockCDMFactory::addKeysToSessionWithID(const String& id, Vector<Ref<FragmentedSharedBuffer>>&& keys)
> {
>     auto addResult = m_sessions.add(id, WTFMove(keys));
>     if (addResult.isNewEntry)
>@@ -74,7 +74,7 @@ void MockCDMFactory::addKeysToSessionWithID(const String& id, Vector<Ref<SharedB
>         value.append(WTFMove(key));
> }
> 
>-Vector<Ref<SharedBuffer>> MockCDMFactory::removeKeysFromSessionWithID(const String& id)
>+Vector<Ref<FragmentedSharedBuffer>> MockCDMFactory::removeKeysFromSessionWithID(const String& id)
> {
>     auto it = m_sessions.find(id);
>     if (it == m_sessions.end())
>@@ -83,7 +83,7 @@ Vector<Ref<SharedBuffer>> MockCDMFactory::removeKeysFromSessionWithID(const Stri
>     return WTFMove(it->value);
> }
> 
>-const Vector<Ref<SharedBuffer>>* MockCDMFactory::keysForSessionWithID(const String& id) const
>+const Vector<Ref<FragmentedSharedBuffer>>* MockCDMFactory::keysForSessionWithID(const String& id) const
> {
>     auto it = m_sessions.find(id);
>     if (it == m_sessions.end())
>@@ -202,7 +202,7 @@ bool MockCDM::supportsSessions() const
>     return m_factory && m_factory->supportsSessions();
> }
> 
>-bool MockCDM::supportsInitData(const AtomString& initDataType, const SharedBuffer& initData) const
>+bool MockCDM::supportsInitData(const AtomString& initDataType, const FragmentedSharedBuffer& initData) const
> {
>     if (!supportedInitDataTypes().contains(initDataType))
>         return false;
>@@ -211,12 +211,13 @@ bool MockCDM::supportsInitData(const AtomString& initDataType, const SharedBuffe
>     return true;
> }
> 
>-RefPtr<SharedBuffer> MockCDM::sanitizeResponse(const SharedBuffer& response) const
>+RefPtr<FragmentedSharedBuffer> MockCDM::sanitizeResponse(const FragmentedSharedBuffer& response) const
> {
>-    if (!charactersAreAllASCII(response.data(), response.size()))
>+    auto buffer = response.makeContiguous();
>+    if (!charactersAreAllASCII(buffer->data(), response.size()))
>         return nullptr;
> 
>-    Vector<String> responseArray = String(response.data(), response.size()).split(' ');
>+    Vector<String> responseArray = String(buffer->data(), response.size()).split(' ');
> 
>     if (!responseArray.contains(String("valid-response"_s)))
>         return nullptr;
>@@ -269,9 +270,9 @@ void MockCDMInstance::initializeWithConfiguration(const MediaKeySystemConfigurat
>     callback(initialize());
> }
> 
>-void MockCDMInstance::setServerCertificate(Ref<SharedBuffer>&& certificate, SuccessCallback&& callback)
>+void MockCDMInstance::setServerCertificate(Ref<FragmentedSharedBuffer>&& certificate, SuccessCallback&& callback)
> {
>-    StringView certificateStringView(certificate->data(), certificate->size());
>+    StringView certificateStringView(certificate->makeContiguous()->data(), certificate->size());
> 
>     callback(equalIgnoringASCIICase(certificateStringView, "valid") ? Succeeded : Failed);
> }
>@@ -297,7 +298,7 @@ MockCDMInstanceSession::MockCDMInstanceSession(WeakPtr<MockCDMInstance>&& instan
> {
> }
> 
>-void MockCDMInstanceSession::requestLicense(LicenseType licenseType, const AtomString& initDataType, Ref<SharedBuffer>&& initData, LicenseCallback&& callback)
>+void MockCDMInstanceSession::requestLicense(LicenseType licenseType, const AtomString& initDataType, Ref<FragmentedSharedBuffer>&& initData, LicenseCallback&& callback)
> {
>     MockCDMFactory* factory = m_instance ? m_instance->factory() : nullptr;
>     if (!factory) {
>@@ -323,7 +324,7 @@ void MockCDMInstanceSession::requestLicense(LicenseType licenseType, const AtomS
>     callback(SharedBuffer::create(license.data(), license.length()), sessionID, false, SuccessValue::Succeeded);
> }
> 
>-void MockCDMInstanceSession::updateLicense(const String& sessionID, LicenseType, Ref<SharedBuffer>&& response, LicenseUpdateCallback&& callback)
>+void MockCDMInstanceSession::updateLicense(const String& sessionID, LicenseType, Ref<FragmentedSharedBuffer>&& response, LicenseUpdateCallback&& callback)
> {
>     MockCDMFactory* factory = m_instance ? m_instance->factory() : nullptr;
>     if (!factory) {
>@@ -331,7 +332,7 @@ void MockCDMInstanceSession::updateLicense(const String& sessionID, LicenseType,
>         return;
>     }
> 
>-    Vector<String> responseVector = String(response->data(), response->size()).split(' ');
>+    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);
>diff --git a/Source/WebCore/testing/MockCDMFactory.h b/Source/WebCore/testing/MockCDMFactory.h
>index f5cda505cf2a..d96c156ee4d2 100644
>--- a/Source/WebCore/testing/MockCDMFactory.h
>+++ b/Source/WebCore/testing/MockCDMFactory.h
>@@ -77,9 +77,9 @@ public:
> 
>     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<SharedBuffer>>&&);
>-    const Vector<Ref<SharedBuffer>>* keysForSessionWithID(const String& id) const;
>-    Vector<Ref<SharedBuffer>> removeKeysFromSessionWithID(const String& 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();
>@@ -96,7 +96,7 @@ private:
>     bool m_canCreateInstances { true };
>     bool m_supportsServerCertificates { true };
>     bool m_supportsSessions { true };
>-    HashMap<String, Vector<Ref<SharedBuffer>>> m_sessions;
>+    HashMap<String, Vector<Ref<FragmentedSharedBuffer>>> m_sessions;
> };
> 
> class MockCDM : public CDMPrivate {
>@@ -121,8 +121,8 @@ private:
>     void loadAndInitialize() final;
>     bool supportsServerCertificates() const final;
>     bool supportsSessions() const final;
>-    bool supportsInitData(const AtomString&, const SharedBuffer&) const final;
>-    RefPtr<SharedBuffer> sanitizeResponse(const SharedBuffer&) 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;
>@@ -139,7 +139,7 @@ public:
> private:
>     ImplementationType implementationType() const final { return ImplementationType::Mock; }
>     void initializeWithConfiguration(const MediaKeySystemConfiguration&, AllowDistinctiveIdentifiers, AllowPersistentState, SuccessCallback&&) final;
>-    void setServerCertificate(Ref<SharedBuffer>&&, SuccessCallback&&) final;
>+    void setServerCertificate(Ref<FragmentedSharedBuffer>&&, SuccessCallback&&) final;
>     void setStorageDirectory(const String&) final;
>     const String& keySystem() const final;
>     RefPtr<CDMInstanceSession> createSession() final;
>@@ -154,8 +154,8 @@ public:
>     MockCDMInstanceSession(WeakPtr<MockCDMInstance>&&);
> 
> private:
>-    void requestLicense(LicenseType, const AtomString& initDataType, Ref<SharedBuffer>&& initData, LicenseCallback&&) final;
>-    void updateLicense(const String&, LicenseType, Ref<SharedBuffer>&&, LicenseUpdateCallback&&) final;
>+    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;
>diff --git a/Source/WebCore/testing/MockContentFilter.cpp b/Source/WebCore/testing/MockContentFilter.cpp
>index fc127b7b67be..059f3a386b6c 100644
>--- a/Source/WebCore/testing/MockContentFilter.cpp
>+++ b/Source/WebCore/testing/MockContentFilter.cpp
>@@ -110,7 +110,7 @@ void MockContentFilter::finishedAddingData()
>     maybeDetermineStatus(DecisionPoint::AfterFinishedAddingData);
> }
> 
>-Ref<SharedBuffer> MockContentFilter::replacementData() const
>+Ref<FragmentedSharedBuffer> MockContentFilter::replacementData() const
> {
>     ASSERT(didBlockData());
>     return SharedBuffer::create(m_replacementData.data(), m_replacementData.size());
>diff --git a/Source/WebCore/testing/MockContentFilter.h b/Source/WebCore/testing/MockContentFilter.h
>index 411a300947b5..635ac84be793 100644
>--- a/Source/WebCore/testing/MockContentFilter.h
>+++ b/Source/WebCore/testing/MockContentFilter.h
>@@ -42,7 +42,7 @@ public:
>     void responseReceived(const ResourceResponse&) override;
>     void addData(const uint8_t* data, int length) override;
>     void finishedAddingData() override;
>-    Ref<SharedBuffer> replacementData() const override;
>+    Ref<FragmentedSharedBuffer> replacementData() const override;
> #if ENABLE(CONTENT_FILTERING)
>     ContentFilterUnblockHandler unblockHandler() const override;
> #endif
>diff --git a/Source/WebCore/workers/ScriptBuffer.cpp b/Source/WebCore/workers/ScriptBuffer.cpp
>index 6d48bd02d1c9..5f8545eba5b0 100644
>--- a/Source/WebCore/workers/ScriptBuffer.cpp
>+++ b/Source/WebCore/workers/ScriptBuffer.cpp
>@@ -38,7 +38,7 @@ namespace WebCore {
> ScriptBuffer::ScriptBuffer(const String& string)
> {
>     auto utf8 = string.utf8();
>-    m_buffer = SharedBuffer::create(utf8.data(), utf8.length());
>+    m_buffer.append(utf8.data(), utf8.length());
> }
> 
> ScriptBuffer ScriptBuffer::empty()
>@@ -46,14 +46,13 @@ ScriptBuffer ScriptBuffer::empty()
>     return ScriptBuffer { SharedBuffer::create() };
> }
> 
>-
> String ScriptBuffer::toString() const
> {
>     if (!m_buffer)
>         return String();
> 
>     StringBuilder builder;
>-    m_buffer->forEachSegment([&](auto& segment) {
>+    m_buffer.get()->forEachSegment([&](auto& segment) {
>         builder.append(String::fromUTF8(segment.data(), segment.size()));
>     });
>     return builder.toString();
>@@ -61,15 +60,13 @@ String ScriptBuffer::toString() const
> 
> bool ScriptBuffer::containsSingleFileMappedSegment() const
> {
>-    return m_buffer && m_buffer->hasOneSegment() && m_buffer->begin()->segment->containsMappedFileData();
>+    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());
>+    m_buffer.append(utf8.data(), utf8.length());
> }
> 
> bool operator==(const ScriptBuffer& a, const ScriptBuffer& b)
>diff --git a/Source/WebCore/workers/ScriptBuffer.h b/Source/WebCore/workers/ScriptBuffer.h
>index b39d9c130330..fd2c1ae2f63b 100644
>--- a/Source/WebCore/workers/ScriptBuffer.h
>+++ b/Source/WebCore/workers/ScriptBuffer.h
>@@ -38,7 +38,7 @@ class ScriptBuffer {
> public:
>     ScriptBuffer() = default;
> 
>-    ScriptBuffer(RefPtr<SharedBuffer>&& buffer)
>+    ScriptBuffer(RefPtr<FragmentedSharedBuffer>&& buffer)
>         : m_buffer(WTFMove(buffer))
>     {
>     }
>@@ -48,17 +48,17 @@ public:
>     WEBCORE_EXPORT explicit ScriptBuffer(const String&);
> 
>     String toString() const;
>-    SharedBuffer* buffer() const { return m_buffer.get(); }
>+    const FragmentedSharedBuffer* buffer() const { return m_buffer.get().get(); }
> 
>-    ScriptBuffer isolatedCopy() const { return ScriptBuffer(m_buffer ? RefPtr<SharedBuffer>(m_buffer->copy()) : nullptr); }
>+    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 || !m_buffer->size(); }
>+    bool isEmpty() const { return m_buffer.isEmpty(); }
> 
>     WEBCORE_EXPORT bool containsSingleFileMappedSegment() const;
>     void append(const String&);
> 
> private:
>-    RefPtr<SharedBuffer> m_buffer; // Contains the UTF-8 encoded script.
>+    SharedBufferBuilder m_buffer; // Contains the UTF-8 encoded script.
> };
> 
> bool operator==(const ScriptBuffer&, const ScriptBuffer&);
>diff --git a/Source/WebCore/workers/WorkerFontLoadRequest.cpp b/Source/WebCore/workers/WorkerFontLoadRequest.cpp
>index 433d9e1a45c2..8158128a6318 100644
>--- a/Source/WebCore/workers/WorkerFontLoadRequest.cpp
>+++ b/Source/WebCore/workers/WorkerFontLoadRequest.cpp
>@@ -34,7 +34,6 @@
> #include "FontSelectionAlgorithm.h"
> #include "ResourceLoaderOptions.h"
> #include "ServiceWorker.h"
>-#include "SharedBuffer.h"
> #include "WOFFFileFormat.h"
> #include "WorkerGlobalScope.h"
> #include "WorkerThreadableLoader.h"
>@@ -78,9 +77,13 @@ void WorkerFontLoadRequest::load(WorkerGlobalScope& workerGlobalScope)
> bool WorkerFontLoadRequest::ensureCustomFontData(const AtomString&)
> {
>     if (!m_fontCustomPlatformData && !m_errorOccurred && !m_isLoading) {
>-        convertWOFFToSfntIfNecessary(m_data);
>-        if (m_data) {
>-            m_fontCustomPlatformData = createFontCustomPlatformData(*m_data, m_url.fragmentIdentifier().toString());
>+        RefPtr<SharedBuffer> contiguousData;
>+        if (m_data)
>+            contiguousData = m_data.takeAsContiguous();
>+        convertWOFFToSfntIfNecessary(contiguousData);
>+        if (contiguousData) {
>+            m_data.append(*contiguousData);
>+            m_fontCustomPlatformData = createFontCustomPlatformData(*contiguousData, m_url.fragmentIdentifier().toString());
>             if (!m_fontCustomPlatformData)
>                 m_errorOccurred = true;
>         }
>@@ -117,10 +120,7 @@ void WorkerFontLoadRequest::didReceiveData(const uint8_t* data, int dataLength)
>     if (m_errorOccurred)
>         return;
> 
>-    if (!m_data)
>-        m_data = SharedBuffer::create();
>-
>-    m_data->append(data, dataLength);
>+    m_data.append(data, dataLength);
> }
> 
> void WorkerFontLoadRequest::didFinishLoading(ResourceLoaderIdentifier)
>diff --git a/Source/WebCore/workers/WorkerFontLoadRequest.h b/Source/WebCore/workers/WorkerFontLoadRequest.h
>index b9fcfb1d6fea..dab73fc7b1a9 100644
>--- a/Source/WebCore/workers/WorkerFontLoadRequest.h
>+++ b/Source/WebCore/workers/WorkerFontLoadRequest.h
>@@ -28,6 +28,7 @@
> 
> #include "FontLoadRequest.h"
> #include "ResourceLoaderOptions.h"
>+#include "SharedBuffer.h"
> #include "ThreadableLoaderClient.h"
> #include <wtf/URL.h>
> #include <wtf/WeakPtr.h>
>@@ -36,7 +37,6 @@ namespace WebCore {
> 
> class FontCreationContext;
> class ScriptExecutionContext;
>-class SharedBuffer;
> class WorkerGlobalScope;
> 
> struct FontCustomPlatformData;
>@@ -76,7 +76,7 @@ private:
>     FontLoadRequestClient* m_fontLoadRequestClient { nullptr };
> 
>     WeakPtr<ScriptExecutionContext> m_context;
>-    RefPtr<SharedBuffer> m_data;
>+    SharedBufferBuilder m_data;
>     std::unique_ptr<FontCustomPlatformData> m_fontCustomPlatformData;
> };
> 
>diff --git a/Source/WebCore/workers/service/context/ServiceWorkerFetch.h b/Source/WebCore/workers/service/context/ServiceWorkerFetch.h
>index eb266b6c07e6..097543e1b3b3 100644
>--- a/Source/WebCore/workers/service/context/ServiceWorkerFetch.h
>+++ b/Source/WebCore/workers/service/context/ServiceWorkerFetch.h
>@@ -42,7 +42,7 @@ class ResourceRequest;
> class ResourceResponse;
> class ServiceWorkerGlobalScope;
> class ServiceWorkerGlobalScope;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> 
> namespace ServiceWorkerFetch {
> class Client : public ThreadSafeRefCounted<Client, WTF::DestructionThread::Main> {
>@@ -51,7 +51,7 @@ public:
> 
>     virtual void didReceiveRedirection(const ResourceResponse&) = 0;
>     virtual void didReceiveResponse(const ResourceResponse&) = 0;
>-    virtual void didReceiveData(Ref<SharedBuffer>&&) = 0;
>+    virtual void didReceiveData(Ref<FragmentedSharedBuffer>&&) = 0;
>     virtual void didReceiveFormDataAndFinish(Ref<FormData>&&) = 0;
>     virtual void didFail(const ResourceError&) = 0;
>     virtual void didFinish() = 0;
>diff --git a/Source/WebCore/workers/service/server/SWScriptStorage.cpp b/Source/WebCore/workers/service/server/SWScriptStorage.cpp
>index 89a875f8afc0..9a8fb35ca536 100644
>--- a/Source/WebCore/workers/service/server/SWScriptStorage.cpp
>+++ b/Source/WebCore/workers/service/server/SWScriptStorage.cpp
>@@ -127,7 +127,8 @@ ScriptBuffer SWScriptStorage::retrieve(const ServiceWorkerRegistrationKey& regis
>     }
> 
>     // FIXME: Do we need to disable file mapping in more cases to avoid having too many file descriptors open?
>-    return SharedBuffer::createWithContentsOfFile(scriptPath, FileSystem::MappedFileMode::Private, shouldUseFileMapping(*fileSize) ? SharedBuffer::MayUseFileMapping::Yes : SharedBuffer::MayUseFileMapping::No);
>+    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)
>diff --git a/Source/WebCore/xml/XMLHttpRequest.cpp b/Source/WebCore/xml/XMLHttpRequest.cpp
>index e0cdc7234c54..9b112b9db2cd 100644
>--- a/Source/WebCore/xml/XMLHttpRequest.cpp
>+++ b/Source/WebCore/xml/XMLHttpRequest.cpp
>@@ -48,7 +48,6 @@
> #include "RuntimeApplicationChecks.h"
> #include "SecurityOriginPolicy.h"
> #include "Settings.h"
>-#include "SharedBuffer.h"
> #include "StringAdaptors.h"
> #include "TextResourceDecoder.h"
> #include "ThreadableLoader.h"
>@@ -208,7 +207,7 @@ Ref<Blob> XMLHttpRequest::createResponseBlob()
>     // FIXME: We just received the data from NetworkProcess, and are sending it back. This is inefficient.
>     Vector<uint8_t> data;
>     if (m_binaryResponseBuilder)
>-        data = std::exchange(m_binaryResponseBuilder, nullptr)->extractData();
>+        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);
> }
>@@ -218,9 +217,7 @@ RefPtr<ArrayBuffer> XMLHttpRequest::createResponseArrayBuffer()
>     ASSERT(responseType() == ResponseType::Arraybuffer);
>     ASSERT(doneWithoutErrors());
> 
>-    auto result = m_binaryResponseBuilder ? m_binaryResponseBuilder->tryCreateArrayBuffer() : ArrayBuffer::create(nullptr, 0);
>-    m_binaryResponseBuilder = nullptr;
>-    return result;
>+    return m_binaryResponseBuilder.takeAsArrayBuffer();
> }
> 
> ExceptionOr<void> XMLHttpRequest::setTimeout(unsigned timeout)
>@@ -741,7 +738,7 @@ void XMLHttpRequest::clearResponseBuffers()
>     m_responseEncoding = String();
>     m_createdDocument = false;
>     m_responseDocument = nullptr;
>-    m_binaryResponseBuilder = nullptr;
>+    m_binaryResponseBuilder.reset();
>     m_responseCacheIsValid = false;
> }
> 
>@@ -1065,9 +1062,7 @@ void XMLHttpRequest::didReceiveData(const uint8_t* data, int len)
>         m_responseBuilder.append(m_decoder->decode(data, len));
>     else {
>         // Buffer binary data.
>-        if (!m_binaryResponseBuilder)
>-            m_binaryResponseBuilder = SharedBuffer::create();
>-        m_binaryResponseBuilder->append(data, len);
>+        m_binaryResponseBuilder.append(data, len);
>     }
> 
>     if (!m_error) {
>diff --git a/Source/WebCore/xml/XMLHttpRequest.h b/Source/WebCore/xml/XMLHttpRequest.h
>index 0484626b2e5d..2d13bec39464 100644
>--- a/Source/WebCore/xml/XMLHttpRequest.h
>+++ b/Source/WebCore/xml/XMLHttpRequest.h
>@@ -26,6 +26,7 @@
> #include "ExceptionOr.h"
> #include "FormData.h"
> #include "ResourceResponse.h"
>+#include "SharedBuffer.h"
> #include "ThreadableLoaderClient.h"
> #include "UserGestureIndicator.h"
> #include <wtf/URL.h>
>@@ -45,7 +46,6 @@ class Blob;
> class Document;
> class DOMFormData;
> class SecurityOrigin;
>-class SharedBuffer;
> class TextResourceDecoder;
> class ThreadableLoader;
> class URLSearchParams;
>@@ -237,7 +237,7 @@ private:
> 
>     RefPtr<Document> m_responseDocument;
> 
>-    RefPtr<SharedBuffer> m_binaryResponseBuilder;
>+    SharedBufferBuilder m_binaryResponseBuilder;
> 
>     StringBuilder m_responseBuilder;
> 
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index efe48b4bf0c9..e169584cc022 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,332 @@
>+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-09  Youenn Fablet  <youenn@apple.com>
> 
>         Copy ServiceWorkerNavigationPreloader error when failing its ServiceWorkerFetchTask
>diff --git a/Source/WebKit/GPUProcess/media/RemoteCDMInstanceProxy.cpp b/Source/WebKit/GPUProcess/media/RemoteCDMInstanceProxy.cpp
>index 573067e3dd05..31c2d76f2ee1 100644
>--- a/Source/WebKit/GPUProcess/media/RemoteCDMInstanceProxy.cpp
>+++ b/Source/WebKit/GPUProcess/media/RemoteCDMInstanceProxy.cpp
>@@ -61,7 +61,7 @@ RemoteCDMInstanceProxy::~RemoteCDMInstanceProxy()
>     m_instance->clearClient();
> }
> 
>-void RemoteCDMInstanceProxy::unrequestedInitializationDataReceived(const String& type, Ref<SharedBuffer>&& initData)
>+void RemoteCDMInstanceProxy::unrequestedInitializationDataReceived(const String& type, Ref<FragmentedSharedBuffer>&& initData)
> {
>     if (!m_cdm)
>         return;
>diff --git a/Source/WebKit/GPUProcess/media/RemoteCDMInstanceProxy.h b/Source/WebKit/GPUProcess/media/RemoteCDMInstanceProxy.h
>index 8e73d3d9a64b..02c5cd37ae54 100644
>--- a/Source/WebKit/GPUProcess/media/RemoteCDMInstanceProxy.h
>+++ b/Source/WebKit/GPUProcess/media/RemoteCDMInstanceProxy.h
>@@ -66,7 +66,7 @@ private:
>     RemoteCDMInstanceProxy(WeakPtr<RemoteCDMProxy>&&, Ref<WebCore::CDMInstance>&&, UniqueRef<RemoteCDMInstanceConfiguration>&&, RemoteCDMInstanceIdentifier);
> 
>     // CDMInstanceClient
>-    void unrequestedInitializationDataReceived(const String&, Ref<WebCore::SharedBuffer>&&) final;
>+    void unrequestedInitializationDataReceived(const String&, Ref<WebCore::FragmentedSharedBuffer>&&) final;
> 
>     // IPC::MessageReceiver
>     void didReceiveMessage(IPC::Connection&, IPC::Decoder&) final;
>diff --git a/Source/WebKit/GPUProcess/media/RemoteCDMInstanceSessionProxy.cpp b/Source/WebKit/GPUProcess/media/RemoteCDMInstanceSessionProxy.cpp
>index e5766c2334cf..de8273b9cf50 100644
>--- a/Source/WebKit/GPUProcess/media/RemoteCDMInstanceSessionProxy.cpp
>+++ b/Source/WebKit/GPUProcess/media/RemoteCDMInstanceSessionProxy.cpp
>@@ -70,7 +70,7 @@ void RemoteCDMInstanceSessionProxy::requestLicense(LicenseType type, AtomString
>         return;
>     }
> 
>-    m_session->requestLicense(type, initDataType, initData.buffer().releaseNonNull(), [completion = WTFMove(completion)] (Ref<SharedBuffer>&& message, const String& sessionId, bool needsIndividualization, CDMInstanceSession::SuccessValue succeeded) mutable {
>+    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);
>     });
> }
>@@ -115,7 +115,7 @@ void RemoteCDMInstanceSessionProxy::closeSession(const String& sessionId, CloseS
> 
> void RemoteCDMInstanceSessionProxy::removeSessionData(const String& sessionId, LicenseType type, RemoveSessionDataCallback&& completion)
> {
>-    m_session->removeSessionData(sessionId, type, [completion = WTFMove(completion)] (CDMInstanceSession::KeyStatusVector&& keyStatuses, std::optional<Ref<SharedBuffer>>&& expiredSessionsData, CDMInstanceSession::SuccessValue succeeded) mutable {
>+    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));
>@@ -149,7 +149,7 @@ void RemoteCDMInstanceSessionProxy::updateKeyStatuses(KeyStatusVector&& keyStatu
>     gpuConnectionToWebProcess->connection().send(Messages::RemoteCDMInstanceSession::UpdateKeyStatuses(WTFMove(keyStatuses)), m_identifier);
> }
> 
>-void RemoteCDMInstanceSessionProxy::sendMessage(CDMMessageType type, Ref<SharedBuffer>&& message)
>+void RemoteCDMInstanceSessionProxy::sendMessage(CDMMessageType type, Ref<FragmentedSharedBuffer>&& message)
> {
>     if (!m_cdm)
>         return;
>diff --git a/Source/WebKit/GPUProcess/media/RemoteCDMInstanceSessionProxy.h b/Source/WebKit/GPUProcess/media/RemoteCDMInstanceSessionProxy.h
>index 8a61f9d5fabc..fe73097131e0 100644
>--- a/Source/WebKit/GPUProcess/media/RemoteCDMInstanceSessionProxy.h
>+++ b/Source/WebKit/GPUProcess/media/RemoteCDMInstanceSessionProxy.h
>@@ -77,7 +77,7 @@ private:
> 
>     // CDMInstanceSessionClient
>     void updateKeyStatuses(KeyStatusVector&&) final;
>-    void sendMessage(WebCore::CDMMessageType, Ref<WebCore::SharedBuffer>&& message) final;
>+    void sendMessage(WebCore::CDMMessageType, Ref<WebCore::FragmentedSharedBuffer>&& message) final;
>     void sessionIdChanged(const String&) final;
>     PlatformDisplayID displayID() final { return m_displayID; }
> 
>diff --git a/Source/WebKit/GPUProcess/media/RemoteCDMProxy.cpp b/Source/WebKit/GPUProcess/media/RemoteCDMProxy.cpp
>index 9ab3575f4c3b..f7cb6a63eb93 100644
>--- a/Source/WebKit/GPUProcess/media/RemoteCDMProxy.cpp
>+++ b/Source/WebKit/GPUProcess/media/RemoteCDMProxy.cpp
>@@ -63,12 +63,12 @@ RemoteCDMProxy::RemoteCDMProxy(WeakPtr<RemoteCDMFactoryProxy>&& factory, std::un
> 
> RemoteCDMProxy::~RemoteCDMProxy() = default;
> 
>-bool RemoteCDMProxy::supportsInitData(const AtomString& type, const SharedBuffer& data)
>+bool RemoteCDMProxy::supportsInitData(const AtomString& type, const FragmentedSharedBuffer& data)
> {
>     return m_private->supportsInitData(type, data);
> }
> 
>-RefPtr<SharedBuffer> RemoteCDMProxy::sanitizeResponse(const SharedBuffer& response)
>+RefPtr<FragmentedSharedBuffer> RemoteCDMProxy::sanitizeResponse(const FragmentedSharedBuffer& response)
> {
>     return m_private->sanitizeResponse(response);
> }
>diff --git a/Source/WebKit/GPUProcess/media/RemoteCDMProxy.h b/Source/WebKit/GPUProcess/media/RemoteCDMProxy.h
>index 6924e74e3f50..3b66c7757870 100644
>--- a/Source/WebKit/GPUProcess/media/RemoteCDMProxy.h
>+++ b/Source/WebKit/GPUProcess/media/RemoteCDMProxy.h
>@@ -36,7 +36,7 @@
> #include <wtf/UniqueRef.h>
> 
> namespace WebCore {
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> enum class CDMRequirement : uint8_t;
> enum class CDMSessionType : uint8_t;
> struct CDMKeySystemConfiguration;
>@@ -58,8 +58,8 @@ public:
> 
>     RemoteCDMFactoryProxy* factory() const { return m_factory.get(); }
> 
>-    bool supportsInitData(const AtomString&, const WebCore::SharedBuffer&);
>-    RefPtr<WebCore::SharedBuffer> sanitizeResponse(const WebCore::SharedBuffer& response);
>+    bool supportsInitData(const AtomString&, const WebCore::FragmentedSharedBuffer&);
>+    RefPtr<WebCore::FragmentedSharedBuffer> sanitizeResponse(const WebCore::FragmentedSharedBuffer& response);
>     std::optional<String> sanitizeSessionId(const String& sessionId);
> 
> private:
>diff --git a/Source/WebKit/GPUProcess/media/RemoteLegacyCDMProxy.h b/Source/WebKit/GPUProcess/media/RemoteLegacyCDMProxy.h
>index e2cd05d7cc74..de8f6df55a6e 100644
>--- a/Source/WebKit/GPUProcess/media/RemoteLegacyCDMProxy.h
>+++ b/Source/WebKit/GPUProcess/media/RemoteLegacyCDMProxy.h
>@@ -36,7 +36,7 @@
> #include <wtf/WeakPtr.h>
> 
> namespace WebCore {
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> }
> 
> namespace WebKit {
>diff --git a/Source/WebKit/GPUProcess/media/RemoteLegacyCDMSessionProxy.h b/Source/WebKit/GPUProcess/media/RemoteLegacyCDMSessionProxy.h
>index f14c627f6593..1546bdfdfdcf 100644
>--- a/Source/WebKit/GPUProcess/media/RemoteLegacyCDMSessionProxy.h
>+++ b/Source/WebKit/GPUProcess/media/RemoteLegacyCDMSessionProxy.h
>@@ -37,7 +37,7 @@
> namespace WebCore {
> class LegacyCDM;
> class LegacyCDMSession;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> }
> 
> namespace IPC {
>diff --git a/Source/WebKit/GPUProcess/media/RemoteMediaResource.cpp b/Source/WebKit/GPUProcess/media/RemoteMediaResource.cpp
>index c45e5255d67b..617f47689564 100644
>--- a/Source/WebKit/GPUProcess/media/RemoteMediaResource.cpp
>+++ b/Source/WebKit/GPUProcess/media/RemoteMediaResource.cpp
>@@ -96,7 +96,7 @@ void RemoteMediaResource::dataSent(uint64_t bytesSent, uint64_t totalBytesToBeSe
>         m_client->dataSent(*this, bytesSent, totalBytesToBeSent);
> }
> 
>-void RemoteMediaResource::dataReceived(Ref<SharedBuffer>&& data)
>+void RemoteMediaResource::dataReceived(Ref<FragmentedSharedBuffer>&& data)
> {
>     if (m_client)
>         m_client->dataReceived(*this, WTFMove(data));
>diff --git a/Source/WebKit/GPUProcess/media/RemoteMediaResource.h b/Source/WebKit/GPUProcess/media/RemoteMediaResource.h
>index d13d25f65f02..5b7a7e2a7424 100644
>--- a/Source/WebKit/GPUProcess/media/RemoteMediaResource.h
>+++ b/Source/WebKit/GPUProcess/media/RemoteMediaResource.h
>@@ -34,7 +34,7 @@
> 
> namespace WebCore {
> class NetworkLoadMetrics;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> }
> 
> namespace WebKit {
>@@ -57,7 +57,7 @@ public:
>     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::SharedBuffer>&&);
>+    void dataReceived(Ref<WebCore::FragmentedSharedBuffer>&&);
>     void accessControlCheckFailed(const WebCore::ResourceError&);
>     void loadFailed(const WebCore::ResourceError&);
>     void loadFinished(const WebCore::NetworkLoadMetrics&);
>diff --git a/Source/WebKit/GPUProcess/webrtc/RemoteMediaRecorder.cpp b/Source/WebKit/GPUProcess/webrtc/RemoteMediaRecorder.cpp
>index 7e572b3a74a2..e83f9143d20a 100644
>--- a/Source/WebKit/GPUProcess/webrtc/RemoteMediaRecorder.cpp
>+++ b/Source/WebKit/GPUProcess/webrtc/RemoteMediaRecorder.cpp
>@@ -107,7 +107,8 @@ void RemoteMediaRecorder::videoSampleAvailable(WebCore::RemoteVideoSample&& remo
> void RemoteMediaRecorder::fetchData(CompletionHandler<void(IPC::DataReference&&, double)>&& completionHandler)
> {
>     m_writer->fetchData([completionHandler = WTFMove(completionHandler)](auto&& data, auto timeCode) mutable {
>-        auto* pointer = data ? data->data() : nullptr;
>+        auto buffer = data ? data->makeContiguous() : RefPtr<WebCore::SharedBuffer>();
>+        auto* pointer = buffer ? buffer->data() : nullptr;
>         completionHandler(IPC::DataReference { pointer, data ? data->size() : 0 }, timeCode);
>     });
> }
>diff --git a/Source/WebKit/NetworkProcess/Downloads/PendingDownload.h b/Source/WebKit/NetworkProcess/Downloads/PendingDownload.h
>index 52cc5da121a2..71fd02229bbb 100644
>--- a/Source/WebKit/NetworkProcess/Downloads/PendingDownload.h
>+++ b/Source/WebKit/NetworkProcess/Downloads/PendingDownload.h
>@@ -68,7 +68,7 @@ private:
>     bool isAllowedToAskUserForCredentials() const final { return m_isAllowedToAskUserForCredentials; }
>     void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) override;
>     void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) override;
>-    void didReceiveBuffer(Ref<WebCore::SharedBuffer>&&, int reportedEncodedDataLength) override { };
>+    void didReceiveBuffer(Ref<WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) override { };
>     void didFinishLoading(const WebCore::NetworkLoadMetrics&) override { };
>     void didFailLoading(const WebCore::ResourceError&) override;
> 
>diff --git a/Source/WebKit/NetworkProcess/NetworkCORSPreflightChecker.cpp b/Source/WebKit/NetworkProcess/NetworkCORSPreflightChecker.cpp
>index 3f39eb32f1aa..d8920e98764f 100644
>--- a/Source/WebKit/NetworkProcess/NetworkCORSPreflightChecker.cpp
>+++ b/Source/WebKit/NetworkProcess/NetworkCORSPreflightChecker.cpp
>@@ -119,7 +119,7 @@ void NetworkCORSPreflightChecker::didReceiveResponse(WebCore::ResourceResponse&&
>     completionHandler(PolicyAction::Use);
> }
> 
>-void NetworkCORSPreflightChecker::didReceiveData(Ref<WebCore::SharedBuffer>&&)
>+void NetworkCORSPreflightChecker::didReceiveData(Ref<WebCore::FragmentedSharedBuffer>&&)
> {
>     CORS_CHECKER_RELEASE_LOG("didReceiveData");
> }
>diff --git a/Source/WebKit/NetworkProcess/NetworkCORSPreflightChecker.h b/Source/WebKit/NetworkProcess/NetworkCORSPreflightChecker.h
>index bbb1462a3161..e11bf5631907 100644
>--- a/Source/WebKit/NetworkProcess/NetworkCORSPreflightChecker.h
>+++ b/Source/WebKit/NetworkProcess/NetworkCORSPreflightChecker.h
>@@ -71,7 +71,7 @@ private:
>     void willPerformHTTPRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, RedirectCompletionHandler&&) final;
>     void didReceiveChallenge(WebCore::AuthenticationChallenge&&, NegotiatedLegacyTLS, ChallengeCompletionHandler&&) final;
>     void didReceiveResponse(WebCore::ResourceResponse&&, NegotiatedLegacyTLS, ResponseCompletionHandler&&) final;
>-    void didReceiveData(Ref<WebCore::SharedBuffer>&&) final;
>+    void didReceiveData(Ref<WebCore::FragmentedSharedBuffer>&&) final;
>     void didCompleteWithError(const WebCore::ResourceError&, const WebCore::NetworkLoadMetrics&) final;
>     void didSendData(uint64_t totalBytesSent, uint64_t totalBytesExpectedToSend) final;
>     void wasBlocked() final;
>diff --git a/Source/WebKit/NetworkProcess/NetworkDataTask.h b/Source/WebKit/NetworkProcess/NetworkDataTask.h
>index d6018f61383a..e049e5b12dde 100644
>--- a/Source/WebKit/NetworkProcess/NetworkDataTask.h
>+++ b/Source/WebKit/NetworkProcess/NetworkDataTask.h
>@@ -43,7 +43,7 @@ namespace WebCore {
> class AuthenticationChallenge;
> class ResourceError;
> class ResourceResponse;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> }
> 
> namespace WebKit {
>@@ -63,7 +63,7 @@ public:
>     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::SharedBuffer>&&) = 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;
>diff --git a/Source/WebKit/NetworkProcess/NetworkLoad.cpp b/Source/WebKit/NetworkProcess/NetworkLoad.cpp
>index bac022ab4543..7975d41bad89 100644
>--- a/Source/WebKit/NetworkProcess/NetworkLoad.cpp
>+++ b/Source/WebKit/NetworkProcess/NetworkLoad.cpp
>@@ -256,7 +256,7 @@ void NetworkLoad::notifyDidReceiveResponse(ResourceResponse&& response, Negotiat
>     m_client.get().didReceiveResponse(WTFMove(response), WTFMove(completionHandler));
> }
> 
>-void NetworkLoad::didReceiveData(Ref<SharedBuffer>&& buffer)
>+void NetworkLoad::didReceiveData(Ref<FragmentedSharedBuffer>&& buffer)
> {
>     // FIXME: This should be the encoded data length, not the decoded data length.
>     auto size = buffer->size();
>diff --git a/Source/WebKit/NetworkProcess/NetworkLoad.h b/Source/WebKit/NetworkProcess/NetworkLoad.h
>index c3773c987855..ee5eb006aa37 100644
>--- a/Source/WebKit/NetworkProcess/NetworkLoad.h
>+++ b/Source/WebKit/NetworkProcess/NetworkLoad.h
>@@ -80,7 +80,7 @@ private:
>     void willPerformHTTPRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, RedirectCompletionHandler&&) final;
>     void didReceiveChallenge(WebCore::AuthenticationChallenge&&, NegotiatedLegacyTLS, ChallengeCompletionHandler&&) final;
>     void didReceiveResponse(WebCore::ResourceResponse&&, NegotiatedLegacyTLS, ResponseCompletionHandler&&) final;
>-    void didReceiveData(Ref<WebCore::SharedBuffer>&&) final;
>+    void didReceiveData(Ref<WebCore::FragmentedSharedBuffer>&&) final;
>     void didCompleteWithError(const WebCore::ResourceError&, const WebCore::NetworkLoadMetrics&) final;
>     void didSendData(uint64_t totalBytesSent, uint64_t totalBytesExpectedToSend) final;
>     void wasBlocked() final;
>diff --git a/Source/WebKit/NetworkProcess/NetworkLoadClient.h b/Source/WebKit/NetworkProcess/NetworkLoadClient.h
>index 0a5f66bd967e..348cffb9e8e2 100644
>--- a/Source/WebKit/NetworkProcess/NetworkLoadClient.h
>+++ b/Source/WebKit/NetworkProcess/NetworkLoadClient.h
>@@ -32,7 +32,7 @@
> namespace WebCore {
> class AuthenticationChallenge;
> class NetworkLoadMetrics;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> enum class PolicyAction : uint8_t;
> }
> 
>@@ -51,7 +51,7 @@ public:
>     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::SharedBuffer>&&, int reportedEncodedDataLength) = 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() { };
>diff --git a/Source/WebKit/NetworkProcess/NetworkResourceLoader.cpp b/Source/WebKit/NetworkProcess/NetworkResourceLoader.cpp
>index e50cf4abbe56..e7fb050c0036 100644
>--- a/Source/WebKit/NetworkProcess/NetworkResourceLoader.cpp
>+++ b/Source/WebKit/NetworkProcess/NetworkResourceLoader.cpp
>@@ -87,14 +87,14 @@ struct NetworkResourceLoader::SynchronousLoadData {
>     ResourceError error;
> };
> 
>-static void sendReplyToSynchronousRequest(NetworkResourceLoader::SynchronousLoadData& data, const SharedBuffer* buffer, const NetworkLoadMetrics& metrics)
>+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->data(), buffer->size());
>+        responseBuffer.append(buffer->makeContiguous()->data(), buffer->size());
> 
>     data.response.setDeprecatedNetworkLoadMetrics(Box<NetworkLoadMetrics>::create(metrics));
> 
>@@ -306,10 +306,10 @@ void NetworkResourceLoader::startNetworkLoad(ResourceRequest&& request, FirstLoa
>         consumeSandboxExtensions();
> 
>         if (isSynchronous() || m_parameters.maximumBufferingTime > 0_s)
>-            m_bufferedData = SharedBuffer::create();
>+            m_bufferedData.empty();
> 
>         if (canUseCache(request))
>-            m_bufferedDataForCache = SharedBuffer::create();
>+            m_bufferedDataForCache.empty();
>     }
> 
>     NetworkLoadParameters parameters = m_parameters;
>@@ -734,16 +734,16 @@ void NetworkResourceLoader::didReceiveResponse(ResourceResponse&& receivedRespon
>         && m_response.expectedContentLength() > static_cast<long long>(1 * MB)
>         && isFetchOrXHR(resourceLoadInfo)
>         && isMediaMIMEType(m_response.mimeType())) {
>-        m_bufferedData = SharedBuffer::create();
>+        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 = nullptr;
>+        m_bufferedData.reset();
> 
>     if (m_response.isMultipart())
>-        m_bufferedDataForCache = nullptr;
>+        m_bufferedDataForCache.reset();
> 
>     if (m_cacheEntryForValidation) {
>         bool validationSucceeded = m_response.httpStatusCode() == 304; // 304 Not Modified
>@@ -858,7 +858,7 @@ void NetworkResourceLoader::sendDidReceiveResponsePotentiallyInNewBrowsingContex
>     });
> }
> 
>-void NetworkResourceLoader::didReceiveBuffer(Ref<SharedBuffer>&& buffer, int reportedEncodedDataLength)
>+void NetworkResourceLoader::didReceiveBuffer(Ref<FragmentedSharedBuffer>&& buffer, int reportedEncodedDataLength)
> {
>     if (!m_numBytesReceived)
>         LOADER_RELEASE_LOG("didReceiveBuffer: Started receiving data (reportedEncodedDataLength=%d)", reportedEncodedDataLength);
>@@ -869,10 +869,10 @@ void NetworkResourceLoader::didReceiveBuffer(Ref<SharedBuffer>&& buffer, int rep
>     if (m_bufferedDataForCache) {
>         // 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());
>+        if (m_bufferedDataForCache.size() + buffer->size() <= maximumCacheBufferSize)
>+            m_bufferedDataForCache.append(buffer.get());
>         else
>-            m_bufferedDataForCache = nullptr;
>+            m_bufferedDataForCache.reset();
>     }
>     if (isCrossOriginPrefetch())
>         return;
>@@ -880,7 +880,7 @@ void NetworkResourceLoader::didReceiveBuffer(Ref<SharedBuffer>&& buffer, int rep
>     unsigned encodedDataLength = reportedEncodedDataLength >= 0 ? reportedEncodedDataLength : buffer->size();
> 
>     if (m_bufferedData) {
>-        m_bufferedData->append(buffer.get());
>+        m_bufferedData.append(buffer.get());
>         m_bufferedDataEncodedDataLength += encodedDataLength;
>         startBufferingTimerIfNeeded();
>         return;
>@@ -909,11 +909,11 @@ void NetworkResourceLoader::didFinishLoading(const NetworkLoadMetrics& networkLo
> #endif
> 
>     if (isSynchronous())
>-        sendReplyToSynchronousRequest(*m_synchronousLoadData, m_bufferedData.get(), networkLoadMetrics);
>+        sendReplyToSynchronousRequest(*m_synchronousLoadData, m_bufferedData.get().get(), networkLoadMetrics);
>     else {
>-        if (m_bufferedData && !m_bufferedData->isEmpty()) {
>+        if (!m_bufferedData.isEmpty()) {
>             // FIXME: Pass a real value or remove the encoded data size feature.
>-            sendBuffer(*m_bufferedData, -1);
>+            sendBuffer(*m_bufferedData.get(), -1);
>         }
>         send(Messages::WebResourceLoader::DidFinishResourceLoad(networkLoadMetrics));
>     }
>@@ -1259,16 +1259,16 @@ void NetworkResourceLoader::bufferingTimerFired()
>     ASSERT(m_bufferedData);
>     ASSERT(m_networkLoad);
> 
>-    if (m_bufferedData->isEmpty())
>+    if (m_bufferedData.isEmpty())
>         return;
> 
>-    send(Messages::WebResourceLoader::DidReceiveData({ *m_bufferedData }, m_bufferedDataEncodedDataLength));
>+    send(Messages::WebResourceLoader::DidReceiveData({ *m_bufferedData.get() }, m_bufferedDataEncodedDataLength));
> 
>-    m_bufferedData = SharedBuffer::create();
>+    m_bufferedData.empty();
>     m_bufferedDataEncodedDataLength = 0;
> }
> 
>-void NetworkResourceLoader::sendBuffer(SharedBuffer& buffer, size_t encodedDataLength)
>+void NetworkResourceLoader::sendBuffer(FragmentedSharedBuffer& buffer, size_t encodedDataLength)
> {
>     ASSERT(!isSynchronous());
> 
>@@ -1289,12 +1289,12 @@ void NetworkResourceLoader::tryStoreAsCacheEntry()
>     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), WTFMove(m_bufferedDataForCache));
>+            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, WTFMove(m_bufferedDataForCache), [loader = Ref { *this }](auto& mappedBody) mutable {
>+    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;
>diff --git a/Source/WebKit/NetworkProcess/NetworkResourceLoader.h b/Source/WebKit/NetworkProcess/NetworkResourceLoader.h
>index d234dab5beea..cf10cf0e71a1 100644
>--- a/Source/WebKit/NetworkProcess/NetworkResourceLoader.h
>+++ b/Source/WebKit/NetworkProcess/NetworkResourceLoader.h
>@@ -38,6 +38,7 @@
> #include <WebCore/PrivateClickMeasurement.h>
> #include <WebCore/ResourceResponse.h>
> #include <WebCore/SecurityPolicyViolationEvent.h>
>+#include <WebCore/SharedBuffer.h>
> #include <WebCore/Timer.h>
> #include <wtf/WeakPtr.h>
> 
>@@ -114,7 +115,7 @@ public:
>     bool isAllowedToAskUserForCredentials() const final { return m_isAllowedToAskUserForCredentials; }
>     void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&&) final;
>     void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) final;
>-    void didReceiveBuffer(Ref<WebCore::SharedBuffer>&&, int reportedEncodedDataLength) final;
>+    void didReceiveBuffer(Ref<WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) final;
>     void didFinishLoading(const WebCore::NetworkLoadMetrics&) final;
>     void didFailLoading(const WebCore::ResourceError&) final;
>     void didBlockAuthenticationChallenge() final;
>@@ -192,7 +193,7 @@ private:
> 
>     void startBufferingTimerIfNeeded();
>     void bufferingTimerFired();
>-    void sendBuffer(WebCore::SharedBuffer&, size_t encodedDataLength);
>+    void sendBuffer(WebCore::FragmentedSharedBuffer&, size_t encodedDataLength);
> 
>     void consumeSandboxExtensions();
>     void invalidateSandboxExtensions();
>@@ -225,7 +226,7 @@ private:
>     WebCore::ResourceResponse m_response;
> 
>     size_t m_bufferedDataEncodedDataLength { 0 };
>-    RefPtr<WebCore::SharedBuffer> m_bufferedData;
>+    WebCore::SharedBufferBuilder m_bufferedData;
>     unsigned m_redirectCount { 0 };
> 
>     std::unique_ptr<SynchronousLoadData> m_synchronousLoadData;
>@@ -240,7 +241,7 @@ private:
> 
>     WebCore::Timer m_bufferingTimer;
>     RefPtr<NetworkCache::Cache> m_cache;
>-    RefPtr<WebCore::SharedBuffer> m_bufferedDataForCache;
>+    WebCore::SharedBufferBuilder m_bufferedDataForCache;
>     std::unique_ptr<NetworkCache::Entry> m_cacheEntryForValidation;
>     std::unique_ptr<NetworkCache::Entry> m_cacheEntryForMaxAgeCapValidation;
>     bool m_isWaitingContinueWillSendRequestForCachedRedirect { false };
>diff --git a/Source/WebKit/NetworkProcess/PingLoad.cpp b/Source/WebKit/NetworkProcess/PingLoad.cpp
>index 114853e45b72..1af1e08e3c44 100644
>--- a/Source/WebKit/NetworkProcess/PingLoad.cpp
>+++ b/Source/WebKit/NetworkProcess/PingLoad.cpp
>@@ -172,7 +172,7 @@ void PingLoad::didReceiveResponse(ResourceResponse&& response, NegotiatedLegacyT
>     didFinish({ }, response);
> }
> 
>-void PingLoad::didReceiveData(Ref<SharedBuffer>&&)
>+void PingLoad::didReceiveData(Ref<FragmentedSharedBuffer>&&)
> {
>     PING_RELEASE_LOG("didReceiveData");
>     ASSERT_NOT_REACHED();
>diff --git a/Source/WebKit/NetworkProcess/PingLoad.h b/Source/WebKit/NetworkProcess/PingLoad.h
>index 19ec8ceb92e3..ab29a0b1ac84 100644
>--- a/Source/WebKit/NetworkProcess/PingLoad.h
>+++ b/Source/WebKit/NetworkProcess/PingLoad.h
>@@ -54,7 +54,7 @@ private:
>     void willPerformHTTPRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, RedirectCompletionHandler&&) final;
>     void didReceiveChallenge(WebCore::AuthenticationChallenge&&, NegotiatedLegacyTLS, ChallengeCompletionHandler&&) final;
>     void didReceiveResponse(WebCore::ResourceResponse&&, NegotiatedLegacyTLS, ResponseCompletionHandler&&) final;
>-    void didReceiveData(Ref<WebCore::SharedBuffer>&&) final;
>+    void didReceiveData(Ref<WebCore::FragmentedSharedBuffer>&&) final;
>     void didCompleteWithError(const WebCore::ResourceError&, const WebCore::NetworkLoadMetrics&) final;
>     void didSendData(uint64_t totalBytesSent, uint64_t totalBytesExpectedToSend) final;
>     void wasBlocked() final;
>diff --git a/Source/WebKit/NetworkProcess/PreconnectTask.cpp b/Source/WebKit/NetworkProcess/PreconnectTask.cpp
>index 455782d54a2e..17d47907a3f6 100644
>--- a/Source/WebKit/NetworkProcess/PreconnectTask.cpp
>+++ b/Source/WebKit/NetworkProcess/PreconnectTask.cpp
>@@ -79,7 +79,7 @@ void PreconnectTask::didReceiveResponse(ResourceResponse&& response, ResponseCom
>     completionHandler(PolicyAction::Ignore);
> }
> 
>-void PreconnectTask::didReceiveBuffer(Ref<SharedBuffer>&&, int reportedEncodedDataLength)
>+void PreconnectTask::didReceiveBuffer(Ref<FragmentedSharedBuffer>&&, int reportedEncodedDataLength)
> {
>     ASSERT_NOT_REACHED();
> }
>diff --git a/Source/WebKit/NetworkProcess/PreconnectTask.h b/Source/WebKit/NetworkProcess/PreconnectTask.h
>index 1c1ff1647111..85808e121b68 100644
>--- a/Source/WebKit/NetworkProcess/PreconnectTask.h
>+++ b/Source/WebKit/NetworkProcess/PreconnectTask.h
>@@ -55,7 +55,7 @@ private:
>     void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent) final;
>     void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) final;
>     void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) final;
>-    void didReceiveBuffer(Ref<WebCore::SharedBuffer>&&, int reportedEncodedDataLength) final;
>+    void didReceiveBuffer(Ref<WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) final;
>     void didFinishLoading(const WebCore::NetworkLoadMetrics&) final;
>     void didFailLoading(const WebCore::ResourceError&) final;
> 
>diff --git a/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerNavigationPreloader.cpp b/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerNavigationPreloader.cpp
>index 71e0cf6c6dc7..819663020c69 100644
>--- a/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerNavigationPreloader.cpp
>+++ b/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerNavigationPreloader.cpp
>@@ -174,10 +174,10 @@ void ServiceWorkerNavigationPreloader::didReceiveResponse(ResourceResponse&& res
>         callback();
> }
> 
>-void ServiceWorkerNavigationPreloader::didReceiveBuffer(Ref<SharedBuffer>&& buffer, int reportedEncodedDataLength)
>+void ServiceWorkerNavigationPreloader::didReceiveBuffer(Ref<FragmentedSharedBuffer>&& buffer, int reportedEncodedDataLength)
> {
>     if (m_bodyCallback)
>-        m_bodyCallback(WTFMove(buffer), reportedEncodedDataLength);
>+        m_bodyCallback(buffer->makeContiguous(), reportedEncodedDataLength);
> }
> 
> void ServiceWorkerNavigationPreloader::didFinishLoading(const NetworkLoadMetrics& networkLoadMetrics)
>diff --git a/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerNavigationPreloader.h b/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerNavigationPreloader.h
>index 1e78c2cefa15..ee1bc8b7d6cb 100644
>--- a/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerNavigationPreloader.h
>+++ b/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerNavigationPreloader.h
>@@ -67,7 +67,7 @@ private:
>     bool isAllowedToAskUserForCredentials() const final { return false; }
>     void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) final;
>     void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) final;
>-    void didReceiveBuffer(Ref<WebCore::SharedBuffer>&&, int reportedEncodedDataLength) final;
>+    void didReceiveBuffer(Ref<WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) final;
>     void didFinishLoading(const WebCore::NetworkLoadMetrics&) final;
>     void didFailLoading(const WebCore::ResourceError&) final;
>     bool shouldCaptureExtraNetworkLoadMetrics() const final { return m_shouldCaptureExtraNetworkLoadMetrics; }
>diff --git a/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerSoftUpdateLoader.cpp b/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerSoftUpdateLoader.cpp
>index 8ee112a9df82..7a262219de78 100644
>--- a/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerSoftUpdateLoader.cpp
>+++ b/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerSoftUpdateLoader.cpp
>@@ -177,7 +177,7 @@ ResourceError ServiceWorkerSoftUpdateLoader::processResponse(const ResourceRespo
>     return { };
> }
> 
>-void ServiceWorkerSoftUpdateLoader::didReceiveBuffer(Ref<SharedBuffer>&& buffer, int reportedEncodedDataLength)
>+void ServiceWorkerSoftUpdateLoader::didReceiveBuffer(Ref<FragmentedSharedBuffer>&& buffer, int reportedEncodedDataLength)
> {
>     if (!m_decoder) {
>         if (!m_responseEncoding.isEmpty())
>@@ -187,7 +187,7 @@ void ServiceWorkerSoftUpdateLoader::didReceiveBuffer(Ref<SharedBuffer>&& buffer,
>     }
> 
>     if (auto size = buffer->size())
>-        m_script.append(m_decoder->decode(buffer->data(), size));
>+        m_script.append(m_decoder->decode(buffer->makeContiguous()->data(), size));
> }
> 
> void ServiceWorkerSoftUpdateLoader::didFinishLoading(const WebCore::NetworkLoadMetrics&)
>diff --git a/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerSoftUpdateLoader.h b/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerSoftUpdateLoader.h
>index 18f54691f37c..44fc0685fa0f 100644
>--- a/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerSoftUpdateLoader.h
>+++ b/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerSoftUpdateLoader.h
>@@ -64,7 +64,7 @@ private:
>     bool isAllowedToAskUserForCredentials() const final { return false; }
>     void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) final;
>     void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) final;
>-    void didReceiveBuffer(Ref<WebCore::SharedBuffer>&&, int reportedEncodedDataLength) final;
>+    void didReceiveBuffer(Ref<WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) final;
>     void didFinishLoading(const WebCore::NetworkLoadMetrics&) final;
>     void didFailLoading(const WebCore::ResourceError&) final;
> 
>diff --git a/Source/WebKit/NetworkProcess/cache/NetworkCache.cpp b/Source/WebKit/NetworkProcess/cache/NetworkCache.cpp
>index 04776836f999..dd305af29766 100644
>--- a/Source/WebKit/NetworkProcess/cache/NetworkCache.cpp
>+++ b/Source/WebKit/NetworkProcess/cache/NetworkCache.cpp
>@@ -454,7 +454,7 @@ void Cache::completeRetrieve(RetrieveCompletionHandler&& handler, std::unique_pt
>     handler(WTFMove(entry), info);
> }
>     
>-std::unique_ptr<Entry> Cache::makeEntry(const WebCore::ResourceRequest& request, const WebCore::ResourceResponse& response, RefPtr<WebCore::SharedBuffer>&& responseData)
>+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));
> }
>@@ -464,7 +464,7 @@ std::unique_ptr<Entry> Cache::makeRedirectEntry(const WebCore::ResourceRequest&
>     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::SharedBuffer>&& responseData, Function<void(MappedBody&)>&& completionHandler)
>+std::unique_ptr<Entry> Cache::store(const WebCore::ResourceRequest& request, const WebCore::ResourceResponse& response, RefPtr<WebCore::FragmentedSharedBuffer>&& responseData, Function<void(MappedBody&)>&& completionHandler)
> {
>     ASSERT(responseData);
> 
>diff --git a/Source/WebKit/NetworkProcess/cache/NetworkCache.h b/Source/WebKit/NetworkProcess/cache/NetworkCache.h
>index 199f0cfb7325..ed04ebca0b36 100644
>--- a/Source/WebKit/NetworkProcess/cache/NetworkCache.h
>+++ b/Source/WebKit/NetworkProcess/cache/NetworkCache.h
>@@ -43,7 +43,7 @@
> namespace WebCore {
> class LowPowerModeNotifier;
> class ResourceRequest;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> }
> 
> namespace WebKit {
>@@ -166,7 +166,7 @@ public:
>     };
>     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::SharedBuffer>&&, Function<void(MappedBody&)>&& = nullptr);
>+    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);
> 
>@@ -185,7 +185,7 @@ public:
>     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::SharedBuffer>&&);
>+    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();
>diff --git a/Source/WebKit/NetworkProcess/cache/NetworkCacheEntry.cpp b/Source/WebKit/NetworkProcess/cache/NetworkCacheEntry.cpp
>index ba39d9e2c26a..761078dea093 100644
>--- a/Source/WebKit/NetworkProcess/cache/NetworkCacheEntry.cpp
>+++ b/Source/WebKit/NetworkProcess/cache/NetworkCacheEntry.cpp
>@@ -37,7 +37,7 @@
> namespace WebKit {
> namespace NetworkCache {
> 
>-Entry::Entry(const Key& key, const WebCore::ResourceResponse& response, RefPtr<WebCore::SharedBuffer>&& buffer, const Vector<std::pair<String, String>>& varyingRequestHeaders)
>+Entry::Entry(const Key& key, const WebCore::ResourceResponse& response, RefPtr<WebCore::FragmentedSharedBuffer>&& buffer, const Vector<std::pair<String, String>>& varyingRequestHeaders)
>     : m_key(key)
>     , m_timeStamp(WallTime::now())
>     , m_response(response)
>@@ -101,8 +101,10 @@ Storage::Record Entry::encodeAsStorageRecord() const
> 
>     Data header(encoder.buffer(), encoder.bufferSize());
>     Data body;
>-    if (m_buffer)
>-        body = { m_buffer->data(), m_buffer->size() };
>+    if (m_buffer) {
>+        m_buffer = m_buffer->makeContiguous();
>+        body = { static_cast<WebCore::SharedBuffer*>(m_buffer.get())->data(), m_buffer->size() };
>+    }
> 
>     return { m_key, m_timeStamp, header, body, { } };
> }
>@@ -194,7 +196,7 @@ void Entry::initializeBufferFromStorageRecord() const
>     m_buffer = WebCore::SharedBuffer::create(m_sourceStorageRecord.body.data(), m_sourceStorageRecord.body.size());
> }
> 
>-WebCore::SharedBuffer* Entry::buffer() const
>+WebCore::FragmentedSharedBuffer* Entry::buffer() const
> {
>     if (!m_buffer)
>         initializeBufferFromStorageRecord();
>diff --git a/Source/WebKit/NetworkProcess/cache/NetworkCacheEntry.h b/Source/WebKit/NetworkProcess/cache/NetworkCacheEntry.h
>index 96915c3801c3..9c0420d44a81 100644
>--- a/Source/WebKit/NetworkProcess/cache/NetworkCacheEntry.h
>+++ b/Source/WebKit/NetworkProcess/cache/NetworkCacheEntry.h
>@@ -35,7 +35,7 @@
> #include <wtf/text/WTFString.h>
> 
> namespace WebCore {
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> }
> 
> namespace WebKit {
>@@ -44,7 +44,7 @@ namespace NetworkCache {
> class Entry {
>     WTF_MAKE_FAST_ALLOCATED;
> public:
>-    Entry(const Key&, const WebCore::ResourceResponse&, RefPtr<WebCore::SharedBuffer>&&, const Vector<std::pair<String, String>>& varyingRequestHeaders);
>+    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&);
>@@ -57,7 +57,7 @@ public:
>     const WebCore::ResourceResponse& response() const { return m_response; }
>     const Vector<std::pair<String, String>>& varyingRequestHeaders() const { return m_varyingRequestHeaders; }
> 
>-    WebCore::SharedBuffer* buffer() const;
>+    WebCore::FragmentedSharedBuffer* buffer() const;
>     const std::optional<WebCore::ResourceRequest>& redirectRequest() const { return m_redirectRequest; }
> 
> #if ENABLE(SHAREABLE_RESOURCE)
>@@ -88,7 +88,7 @@ private:
>     Vector<std::pair<String, String>> m_varyingRequestHeaders;
> 
>     std::optional<WebCore::ResourceRequest> m_redirectRequest;
>-    mutable RefPtr<WebCore::SharedBuffer> m_buffer;
>+    mutable RefPtr<WebCore::FragmentedSharedBuffer> m_buffer;
> #if ENABLE(SHAREABLE_RESOURCE)
>     mutable ShareableResource::Handle m_shareableResourceHandle;
> #endif
>diff --git a/Source/WebKit/NetworkProcess/cache/NetworkCacheSpeculativeLoad.cpp b/Source/WebKit/NetworkProcess/cache/NetworkCacheSpeculativeLoad.cpp
>index ad09df44d9af..41d823502474 100644
>--- a/Source/WebKit/NetworkProcess/cache/NetworkCacheSpeculativeLoad.cpp
>+++ b/Source/WebKit/NetworkProcess/cache/NetworkCacheSpeculativeLoad.cpp
>@@ -46,7 +46,7 @@ SpeculativeLoad::SpeculativeLoad(Cache& cache, const GlobalFrameID& globalFrameI
>     : m_cache(cache)
>     , m_completionHandler(WTFMove(completionHandler))
>     , m_originalRequest(request)
>-    , m_bufferedDataForCache(SharedBuffer::create())
>+    , m_bufferedDataForCache(FragmentedSharedBuffer::create())
>     , m_cacheEntry(WTFMove(cacheEntryForValidation))
> {
>     ASSERT(!m_cacheEntry || m_cacheEntry->needsValidation());
>@@ -109,7 +109,7 @@ void SpeculativeLoad::didReceiveResponse(ResourceResponse&& receivedResponse, Re
>     m_response = receivedResponse;
> 
>     if (m_response.isMultipart())
>-        m_bufferedDataForCache = nullptr;
>+        m_bufferedDataForCache.reset();
> 
>     bool validationSucceeded = m_response.httpStatusCode() == 304; // 304 Not Modified
>     if (validationSucceeded && m_cacheEntry)
>@@ -120,17 +120,17 @@ void SpeculativeLoad::didReceiveResponse(ResourceResponse&& receivedResponse, Re
>     completionHandler(PolicyAction::Use);
> }
> 
>-void SpeculativeLoad::didReceiveBuffer(Ref<SharedBuffer>&& buffer, int reportedEncodedDataLength)
>+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());
>+        if (m_bufferedDataForCache.size() + buffer->size() <= maximumCacheBufferSize)
>+            m_bufferedDataForCache.append(buffer.get());
>         else
>-            m_bufferedDataForCache = nullptr;
>+            m_bufferedDataForCache.reset();
>     }
> }
> 
>@@ -139,10 +139,10 @@ void SpeculativeLoad::didFinishLoading(const WebCore::NetworkLoadMetrics&)
>     if (m_didComplete)
>         return;
>     if (!m_cacheEntry && m_bufferedDataForCache) {
>-        m_cacheEntry = m_cache->store(m_originalRequest, m_response, m_bufferedDataForCache.copyRef(), [](auto& mappedBody) { });
>+        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, WTFMove(m_bufferedDataForCache));
>+            m_cacheEntry = m_cache->makeEntry(m_originalRequest, m_response, m_bufferedDataForCache.take());
>     }
> 
>     didComplete();
>diff --git a/Source/WebKit/NetworkProcess/cache/NetworkCacheSpeculativeLoad.h b/Source/WebKit/NetworkProcess/cache/NetworkCacheSpeculativeLoad.h
>index c0e1e14b2ac4..1b843db7ec27 100644
>--- a/Source/WebKit/NetworkProcess/cache/NetworkCacheSpeculativeLoad.h
>+++ b/Source/WebKit/NetworkProcess/cache/NetworkCacheSpeculativeLoad.h
>@@ -61,7 +61,7 @@ private:
>     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::SharedBuffer>&&, int reportedEncodedDataLength) override;
>+    void didReceiveBuffer(Ref<WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) override;
>     void didFinishLoading(const WebCore::NetworkLoadMetrics&) override;
>     void didFailLoading(const WebCore::ResourceError&) override;
> 
>@@ -75,7 +75,7 @@ private:
> 
>     WebCore::ResourceResponse m_response;
> 
>-    RefPtr<WebCore::SharedBuffer> m_bufferedDataForCache;
>+    WebCore::SharedBufferBuilder m_bufferedDataForCache;
>     std::unique_ptr<NetworkCache::Entry> m_cacheEntry;
>     bool m_didComplete { false };
> };
>diff --git a/Source/WebKit/NetworkProcess/cache/PrefetchCache.cpp b/Source/WebKit/NetworkProcess/cache/PrefetchCache.cpp
>index 5e2e02e2fba0..3199bff311b6 100644
>--- a/Source/WebKit/NetworkProcess/cache/PrefetchCache.cpp
>+++ b/Source/WebKit/NetworkProcess/cache/PrefetchCache.cpp
>@@ -30,7 +30,7 @@
> 
> namespace WebKit {
> 
>-PrefetchCache::Entry::Entry(WebCore::ResourceResponse&& response, RefPtr<WebCore::SharedBuffer>&& buffer)
>+PrefetchCache::Entry::Entry(WebCore::ResourceResponse&& response, RefPtr<WebCore::FragmentedSharedBuffer>&& buffer)
>     : response(WTFMove(response)), buffer(WTFMove(buffer))
> {
> }
>@@ -72,7 +72,7 @@ std::unique_ptr<PrefetchCache::Entry> PrefetchCache::take(const URL& url)
> 
> static const Seconds expirationTimeout { 5_s };
> 
>-void PrefetchCache::store(const URL& requestUrl, WebCore::ResourceResponse&& response, RefPtr<WebCore::SharedBuffer>&& buffer)
>+void PrefetchCache::store(const URL& requestUrl, WebCore::ResourceResponse&& response, RefPtr<WebCore::FragmentedSharedBuffer>&& buffer)
> {
>     if (!m_sessionPrefetches)
>         m_sessionPrefetches = makeUnique<PrefetchEntriesMap>();
>diff --git a/Source/WebKit/NetworkProcess/cache/PrefetchCache.h b/Source/WebKit/NetworkProcess/cache/PrefetchCache.h
>index a251520b31ea..52c0b10fcc6d 100644
>--- a/Source/WebKit/NetworkProcess/cache/PrefetchCache.h
>+++ b/Source/WebKit/NetworkProcess/cache/PrefetchCache.h
>@@ -47,18 +47,18 @@ public:
> 
>     struct Entry {
>         WTF_MAKE_STRUCT_FAST_ALLOCATED;
>-        Entry(WebCore::ResourceResponse&&, RefPtr<WebCore::SharedBuffer>&&);
>+        Entry(WebCore::ResourceResponse&&, RefPtr<WebCore::FragmentedSharedBuffer>&&);
>         Entry(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&);
> 
>-        Ref<WebCore::SharedBuffer> releaseBuffer() { return buffer.releaseNonNull(); }
>+        Ref<WebCore::FragmentedSharedBuffer> releaseBuffer() { return buffer.releaseNonNull(); }
> 
>         WebCore::ResourceResponse response;
>-        RefPtr<WebCore::SharedBuffer> buffer;
>+        RefPtr<WebCore::FragmentedSharedBuffer> buffer;
>         WebCore::ResourceRequest redirectRequest;
>     };
> 
>     std::unique_ptr<Entry> take(const URL&);
>-    void store(const URL&, WebCore::ResourceResponse&&, RefPtr<WebCore::SharedBuffer>&&);
>+    void store(const URL&, WebCore::ResourceResponse&&, RefPtr<WebCore::FragmentedSharedBuffer>&&);
>     void storeRedirect(const URL&, WebCore::ResourceResponse&&, WebCore::ResourceRequest&&);
> 
> private:
>diff --git a/Source/WebKit/NetworkProcess/cocoa/NetworkDataTaskCocoa.h b/Source/WebKit/NetworkProcess/cocoa/NetworkDataTaskCocoa.h
>index b9ab0deebb9f..41668a5b1cd7 100644
>--- a/Source/WebKit/NetworkProcess/cocoa/NetworkDataTaskCocoa.h
>+++ b/Source/WebKit/NetworkProcess/cocoa/NetworkDataTaskCocoa.h
>@@ -62,7 +62,7 @@ public:
>     void didNegotiateModernTLS(const URL&);
>     void didCompleteWithError(const WebCore::ResourceError&, const WebCore::NetworkLoadMetrics&);
>     void didReceiveResponse(WebCore::ResourceResponse&&, NegotiatedLegacyTLS, ResponseCompletionHandler&&);
>-    void didReceiveData(Ref<WebCore::SharedBuffer>&&);
>+    void didReceiveData(Ref<WebCore::FragmentedSharedBuffer>&&);
> 
>     void willPerformHTTPRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, RedirectCompletionHandler&&);
>     void transferSandboxExtensionToDownload(Download&);
>diff --git a/Source/WebKit/NetworkProcess/cocoa/NetworkDataTaskCocoa.mm b/Source/WebKit/NetworkProcess/cocoa/NetworkDataTaskCocoa.mm
>index e780d6c1c3cd..3051f169cb0a 100644
>--- a/Source/WebKit/NetworkProcess/cocoa/NetworkDataTaskCocoa.mm
>+++ b/Source/WebKit/NetworkProcess/cocoa/NetworkDataTaskCocoa.mm
>@@ -442,7 +442,7 @@ void NetworkDataTaskCocoa::didCompleteWithError(const WebCore::ResourceError& er
>         m_client->didCompleteWithError(error, networkLoadMetrics);
> }
> 
>-void NetworkDataTaskCocoa::didReceiveData(Ref<WebCore::SharedBuffer>&& data)
>+void NetworkDataTaskCocoa::didReceiveData(Ref<WebCore::FragmentedSharedBuffer>&& data)
> {
>     WTFEmitSignpost(m_task.get(), "DataTask", "received %zd bytes", data->size());
> 
>diff --git a/Source/WebKit/NetworkProcess/curl/NetworkDataTaskCurl.cpp b/Source/WebKit/NetworkProcess/curl/NetworkDataTaskCurl.cpp
>index 677c61da1a18..3dc65ff82c9d 100644
>--- a/Source/WebKit/NetworkProcess/curl/NetworkDataTaskCurl.cpp
>+++ b/Source/WebKit/NetworkProcess/curl/NetworkDataTaskCurl.cpp
>@@ -172,7 +172,7 @@ void NetworkDataTaskCurl::curlDidReceiveResponse(CurlRequest& request, CurlRespo
>     invokeDidReceiveResponse();
> }
> 
>-void NetworkDataTaskCurl::curlDidReceiveBuffer(CurlRequest&, Ref<SharedBuffer>&& buffer)
>+void NetworkDataTaskCurl::curlDidReceiveBuffer(CurlRequest&, Ref<FragmentedSharedBuffer>&& buffer)
> {
>     Ref protectedThis { *this };
>     if (state() == State::Canceling || state() == State::Completed || (!m_client && !isDownload()))
>diff --git a/Source/WebKit/NetworkProcess/curl/NetworkDataTaskCurl.h b/Source/WebKit/NetworkProcess/curl/NetworkDataTaskCurl.h
>index 1c427ddb78d6..45be5ce18432 100644
>--- a/Source/WebKit/NetworkProcess/curl/NetworkDataTaskCurl.h
>+++ b/Source/WebKit/NetworkProcess/curl/NetworkDataTaskCurl.h
>@@ -68,7 +68,7 @@ private:
>     Ref<WebCore::CurlRequest> createCurlRequest(WebCore::ResourceRequest&&, RequestStatus = RequestStatus::NewRequest);
>     void curlDidSendData(WebCore::CurlRequest&, unsigned long long, unsigned long long) override;
>     void curlDidReceiveResponse(WebCore::CurlRequest&, WebCore::CurlResponse&&) override;
>-    void curlDidReceiveBuffer(WebCore::CurlRequest&, Ref<WebCore::SharedBuffer>&&) override;
>+    void curlDidReceiveBuffer(WebCore::CurlRequest&, Ref<WebCore::FragmentedSharedBuffer>&&) override;
>     void curlDidComplete(WebCore::CurlRequest&, WebCore::NetworkLoadMetrics&&) override;
>     void curlDidFailWithError(WebCore::CurlRequest&, WebCore::ResourceError&&, WebCore::CertificateInfo&&) override;
> 
>diff --git a/Source/WebKit/NetworkProcess/webrtc/NetworkRTCProvider.h b/Source/WebKit/NetworkProcess/webrtc/NetworkRTCProvider.h
>index f5db706c4458..33d43b72238d 100644
>--- a/Source/WebKit/NetworkProcess/webrtc/NetworkRTCProvider.h
>+++ b/Source/WebKit/NetworkProcess/webrtc/NetworkRTCProvider.h
>@@ -55,7 +55,7 @@ struct PacketOptions;
> 
> namespace WebCore {
> class RegistrableDomain;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> }
> 
> namespace WebKit {
>diff --git a/Source/WebKit/Platform/IPC/SharedBufferCopy.h b/Source/WebKit/Platform/IPC/SharedBufferCopy.h
>index 7e0d8dbe1902..17f08c28ea12 100644
>--- a/Source/WebKit/Platform/IPC/SharedBufferCopy.h
>+++ b/Source/WebKit/Platform/IPC/SharedBufferCopy.h
>@@ -23,7 +23,7 @@
>  * THE POSSIBILITY OF SUCH DAMAGE.
>  */
> 
>-// Encodes a SharedBuffer that is received as a copy of the decoded data in a new SharedBuffer.
>+// 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
>@@ -43,11 +43,12 @@ public:
>         : m_buffer(WTFMove(buffer)) { }
>     SharedBufferCopy(Ref<WebCore::SharedBuffer>&& buffer)
>         : m_buffer(WTFMove(buffer)) { }
>-    SharedBufferCopy(const WebCore::SharedBuffer& buffer)
>-        : m_buffer(WebCore::SharedBuffer::create())
>-    {
>-        m_buffer->append(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; }
>diff --git a/Source/WebKit/Platform/IPC/SharedBufferDataReference.h b/Source/WebKit/Platform/IPC/SharedBufferDataReference.h
>index d3d0ec5e9785..67ec8e5e92bd 100644
>--- a/Source/WebKit/Platform/IPC/SharedBufferDataReference.h
>+++ b/Source/WebKit/Platform/IPC/SharedBufferDataReference.h
>@@ -23,7 +23,7 @@
>  * THE POSSIBILITY OF SUCH DAMAGE.
>  */
> 
>-// Encodes a SharedBuffer or DataReference that is received as a DataReference to the decoded data.
>+// Encodes a FragmentedSharedBuffer or DataReference that is received as a DataReference to the decoded data.
> 
> #pragma once
> 
>diff --git a/Source/WebKit/Platform/SharedMemory.cpp b/Source/WebKit/Platform/SharedMemory.cpp
>index d2406ee29053..c026f549569b 100644
>--- a/Source/WebKit/Platform/SharedMemory.cpp
>+++ b/Source/WebKit/Platform/SharedMemory.cpp
>@@ -32,7 +32,7 @@ namespace WebKit {
> 
> using namespace WebCore;
> 
>-RefPtr<SharedMemory> SharedMemory::copyBuffer(const SharedBuffer& buffer)
>+RefPtr<SharedMemory> SharedMemory::copyBuffer(const FragmentedSharedBuffer& buffer)
> {
>     if (buffer.isEmpty())
>         return nullptr;
>@@ -51,7 +51,7 @@ RefPtr<SharedMemory> SharedMemory::copyBuffer(const SharedBuffer& buffer)
> Ref<SharedBuffer> SharedMemory::createSharedBuffer(size_t dataSize) const
> {
>     ASSERT(dataSize <= size());
>-    return SharedBuffer::create({
>+    return SharedBuffer::create(DataSegment::Provider {
>         [protectedThis = Ref { *this }] () -> const uint8_t* {
>             return static_cast<const uint8_t*>(protectedThis->data());
>         },
>diff --git a/Source/WebKit/Platform/SharedMemory.h b/Source/WebKit/Platform/SharedMemory.h
>index e371bcd7302c..1b4fdfaf6838 100644
>--- a/Source/WebKit/Platform/SharedMemory.h
>+++ b/Source/WebKit/Platform/SharedMemory.h
>@@ -45,6 +45,7 @@ class Encoder;
> 
> namespace WebCore {
> class SharedBuffer;
>+class FragmentedSharedBuffer;
> }
> 
> #if OS(DARWIN)
>@@ -120,7 +121,7 @@ public:
> 
>     // 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::SharedBuffer&);
>+    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);
>diff --git a/Source/WebKit/Shared/APIWebArchiveResource.mm b/Source/WebKit/Shared/APIWebArchiveResource.mm
>index ca0c24b27735..110e0adde558 100644
>--- a/Source/WebKit/Shared/APIWebArchiveResource.mm
>+++ b/Source/WebKit/Shared/APIWebArchiveResource.mm
>@@ -68,7 +68,7 @@ static void releaseWebArchiveResourceData(unsigned char*, const void* data)
> 
> Ref<API::Data> WebArchiveResource::data()
> {
>-    RetainPtr<CFDataRef> cfData = m_archiveResource->data().createCFData();
>+    RetainPtr<CFDataRef> cfData = m_archiveResource->data().makeContiguous()->createCFData();
> 
>     // Balanced by CFRelease in releaseWebArchiveResourceData.
>     CFRetain(cfData.get());
>diff --git a/Source/WebKit/Shared/Cocoa/WebCoreArgumentCodersCocoa.mm b/Source/WebKit/Shared/Cocoa/WebCoreArgumentCodersCocoa.mm
>index 87f4eb1eba28..3c1b57d5aa26 100644
>--- a/Source/WebKit/Shared/Cocoa/WebCoreArgumentCodersCocoa.mm
>+++ b/Source/WebKit/Shared/Cocoa/WebCoreArgumentCodersCocoa.mm
>@@ -564,13 +564,12 @@ std::optional<WebCore::FontPlatformData> ArgumentCoder<Ref<WebCore::Font>>::deco
>         return std::nullopt;
> 
>     if (*includesCreationData) {
>-        std::optional<Ref<WebCore::SharedBuffer>> fontFaceData;
>+        std::optional<Ref<WebCore::FragmentedSharedBuffer>> fontFaceData;
>         decoder >> fontFaceData;
>         if (!fontFaceData)
>             return std::nullopt;
> 
>-        // Upon receipt, copy the data for security, so the sender can't scribble over it while we're using it.
>-        auto localFontFaceData = WebCore::SharedBuffer::create(fontFaceData.value()->data(), fontFaceData.value()->size());
>+        auto localFontFaceData = fontFaceData.value()->makeContiguous();
> 
>         std::optional<String> itemInCollection;
>         decoder >> itemInCollection;
>diff --git a/Source/WebKit/Shared/ShareableResource.cpp b/Source/WebKit/Shared/ShareableResource.cpp
>index c6961c714402..6fa02a7bc3ee 100644
>--- a/Source/WebKit/Shared/ShareableResource.cpp
>+++ b/Source/WebKit/Shared/ShareableResource.cpp
>@@ -57,7 +57,7 @@ bool ShareableResource::Handle::decode(IPC::Decoder& decoder, Handle& handle)
> 
> RefPtr<SharedBuffer> ShareableResource::wrapInSharedBuffer()
> {
>-    return SharedBuffer::create(SharedBuffer::DataSegment::Provider {
>+    return SharedBuffer::create(DataSegment::Provider {
>         [self = Ref { *this }]() { return self->data(); },
>         [self = Ref { *this }]() { return self->size(); }
>     });
>diff --git a/Source/WebKit/Shared/WebCoreArgumentCoders.cpp b/Source/WebKit/Shared/WebCoreArgumentCoders.cpp
>index 64982bc48102..843fd47313ae 100644
>--- a/Source/WebKit/Shared/WebCoreArgumentCoders.cpp
>+++ b/Source/WebKit/Shared/WebCoreArgumentCoders.cpp
>@@ -164,7 +164,7 @@ DEFINE_SIMPLE_ARGUMENT_CODER_FOR_SOURCE(DisplayList::SetInlineStrokeColor)
> 
> #undef DEFINE_SIMPLE_ARGUMENT_CODER_FOR_SOURCE
> 
>-static void encodeSharedBuffer(Encoder& encoder, const SharedBuffer* buffer)
>+static void encodeSharedBuffer(Encoder& encoder, const FragmentedSharedBuffer* buffer)
> {
>     bool isNull = !buffer;
>     encoder << isNull;
>@@ -177,7 +177,7 @@ static void encodeSharedBuffer(Encoder& encoder, const SharedBuffer* buffer)
>         return;
> 
> #if USE(UNIX_DOMAIN_SOCKETS)
>-    // Do not use shared memory for SharedBuffer encoding in Unix, because it's easy to reach the
>+    // 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.
>@@ -264,7 +264,7 @@ static WARN_UNUSED_RETURN bool decodeTypesAndData(Decoder& decoder, Vector<Strin
>         RefPtr<SharedBuffer> buffer;
>         if (!decodeSharedBuffer(decoder, buffer))
>             return false;
>-        data.append(WTFMove(buffer));
>+        data.append(buffer);
>     }
> 
>     return true;
>@@ -1550,10 +1550,10 @@ void ArgumentCoder<PasteboardCustomData::Entry>::encode(Encoder& encoder, const
>     if (hasString)
>         encoder << std::get<String>(platformData);
> 
>-    bool hasBuffer = std::holds_alternative<Ref<SharedBuffer>>(platformData);
>+    bool hasBuffer = std::holds_alternative<Ref<FragmentedSharedBuffer>>(platformData);
>     encoder << hasBuffer;
>     if (hasBuffer)
>-        encodeSharedBuffer(encoder, std::get<Ref<SharedBuffer>>(platformData).ptr());
>+        encodeSharedBuffer(encoder, std::get<Ref<FragmentedSharedBuffer>>(platformData).ptr());
> }
> 
> bool ArgumentCoder<PasteboardCustomData::Entry>::decode(Decoder& decoder, PasteboardCustomData::Entry& data)
>@@ -2976,7 +2976,7 @@ std::optional<SerializedAttachmentData> ArgumentCoder<WebCore::SerializedAttachm
>     if (!decoder.decode(data))
>         return std::nullopt;
> 
>-    return {{ WTFMove(identifier), WTFMove(mimeType), WebCore::SharedBuffer::create(data.data(), data.size()) }};
>+    return { { WTFMove(identifier), WTFMove(mimeType), WebCore::SharedBuffer::create(data.data(), data.size()) } };
> }
> 
> #endif // ENABLE(ATTACHMENT_ELEMENT)
>@@ -3010,6 +3010,34 @@ std::optional<SerializedPlatformDataCueValue> ArgumentCoder<WebCore::SerializedP
> }
> #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());
>@@ -3107,7 +3135,7 @@ void ArgumentCoder<WebCore::CDMInstanceSession::Message>::encode(Encoder& encode
> {
>     encoder << message.first;
> 
>-    RefPtr<SharedBuffer> messageData = message.second.copyRef();
>+    RefPtr<FragmentedSharedBuffer> messageData = message.second.copyRef();
>     encoder << messageData;
> }
> 
>@@ -3117,7 +3145,7 @@ std::optional<WebCore::CDMInstanceSession::Message>  ArgumentCoder<WebCore::CDMI
>     if (!decoder.decode(type))
>         return std::nullopt;
> 
>-    RefPtr<SharedBuffer> buffer;
>+    RefPtr<FragmentedSharedBuffer> buffer;
>     if (!decoder.decode(buffer) || !buffer)
>         return std::nullopt;
> 
>diff --git a/Source/WebKit/Shared/WebCoreArgumentCoders.h b/Source/WebKit/Shared/WebCoreArgumentCoders.h
>index 25f01c0292a0..6fac2aa1ea78 100644
>--- a/Source/WebKit/Shared/WebCoreArgumentCoders.h
>+++ b/Source/WebKit/Shared/WebCoreArgumentCoders.h
>@@ -114,6 +114,7 @@ class AuthenticationChallenge;
> class BlobPart;
> class CertificateInfo;
> class Color;
>+class SharedBuffer;
> class Credential;
> class CubicBezierTimingFunction;
> class Cursor;
>@@ -138,7 +139,7 @@ class ResourceRequest;
> class ResourceResponse;
> class ScriptBuffer;
> class SecurityOrigin;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> class SpringTimingFunction;
> class StepsTimingFunction;
> class StickyPositionViewportConstraints;
>@@ -751,6 +752,16 @@ template<> struct ArgumentCoder<WebCore::SerializedPlatformDataCueValue> {
> };
> #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&);
>diff --git a/Source/WebKit/Shared/WebHitTestResultData.cpp b/Source/WebKit/Shared/WebHitTestResultData.cpp
>index cf2e4d5f93fd..b607ace838e0 100644
>--- a/Source/WebKit/Shared/WebHitTestResultData.cpp
>+++ b/Source/WebKit/Shared/WebHitTestResultData.cpp
>@@ -85,7 +85,7 @@ WebHitTestResultData::WebHitTestResultData(const WebCore::HitTestResult& hitTest
>         return;
> 
>     if (Image* image = hitTestResult.image()) {
>-        RefPtr<SharedBuffer> buffer = image->data();
>+        RefPtr<FragmentedSharedBuffer> buffer = image->data();
>         if (buffer) {
>             imageSharedMemory = WebKit::SharedMemory::copyBuffer(*buffer);
>             imageSize = buffer->size();
>diff --git a/Source/WebKit/Shared/gtk/ArgumentCodersGtk.cpp b/Source/WebKit/Shared/gtk/ArgumentCodersGtk.cpp
>index 25a307f3829e..671758a280a5 100644
>--- a/Source/WebKit/Shared/gtk/ArgumentCodersGtk.cpp
>+++ b/Source/WebKit/Shared/gtk/ArgumentCodersGtk.cpp
>@@ -95,7 +95,7 @@ void ArgumentCoder<SelectionData>::encode(Encoder& encoder, const SelectionData&
>     bool hasCustomData = selection.hasCustomData();
>     encoder << hasCustomData;
>     if (hasCustomData)
>-        encoder << RefPtr<SharedBuffer>(selection.customData());
>+        encoder << RefPtr<FragmentedSharedBuffer>(selection.customData());
> 
>     bool canSmartReplace = selection.canSmartReplace();
>     encoder << canSmartReplace;
>diff --git a/Source/WebKit/UIProcess/API/APIAttachment.cpp b/Source/WebKit/UIProcess/API/APIAttachment.cpp
>index b34ec736363c..1490c511bdc3 100644
>--- a/Source/WebKit/UIProcess/API/APIAttachment.cpp
>+++ b/Source/WebKit/UIProcess/API/APIAttachment.cpp
>@@ -98,7 +98,7 @@ std::optional<uint64_t> Attachment::fileSizeForDisplay() const
>     return std::nullopt;
> }
> 
>-RefPtr<WebCore::SharedBuffer> Attachment::enclosingImageData() const
>+RefPtr<WebCore::FragmentedSharedBuffer> Attachment::enclosingImageData() const
> {
>     return nullptr;
> }
>diff --git a/Source/WebKit/UIProcess/API/APIAttachment.h b/Source/WebKit/UIProcess/API/APIAttachment.h
>index afa929cf093d..fe50e538b8eb 100644
>--- a/Source/WebKit/UIProcess/API/APIAttachment.h
>+++ b/Source/WebKit/UIProcess/API/APIAttachment.h
>@@ -39,6 +39,7 @@ OBJC_CLASS NSString;
> 
> namespace WebCore {
> class SharedBuffer;
>+class FragmentedSharedBuffer;
> }
> 
> namespace WebKit {
>@@ -82,7 +83,7 @@ public:
> 
>     bool isEmpty() const;
> 
>-    RefPtr<WebCore::SharedBuffer> enclosingImageData() const;
>+    RefPtr<WebCore::FragmentedSharedBuffer> enclosingImageData() const;
>     std::optional<uint64_t> fileSizeForDisplay() const;
> 
>     void setHasEnclosingImage(bool hasEnclosingImage) { m_hasEnclosingImage = hasEnclosingImage; }
>diff --git a/Source/WebKit/UIProcess/API/APIContentRuleListStore.h b/Source/WebKit/UIProcess/API/APIContentRuleListStore.h
>index 7fc05457e64c..4e266f367ac6 100644
>--- a/Source/WebKit/UIProcess/API/APIContentRuleListStore.h
>+++ b/Source/WebKit/UIProcess/API/APIContentRuleListStore.h
>@@ -30,7 +30,7 @@
> #include <wtf/text/WTFString.h>
> 
> namespace WebCore {
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> }
> 
> namespace WTF {
>diff --git a/Source/WebKit/UIProcess/API/APINavigationClient.h b/Source/WebKit/UIProcess/API/APINavigationClient.h
>index 5623401459da..111f09263f82 100644
>--- a/Source/WebKit/UIProcess/API/APINavigationClient.h
>+++ b/Source/WebKit/UIProcess/API/APINavigationClient.h
>@@ -47,7 +47,7 @@ struct ContentRuleListResults;
> class ResourceError;
> class ResourceRequest;
> class ResourceResponse;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> struct SecurityOriginData;
> }
> 
>@@ -119,7 +119,7 @@ public:
> 
> #if USE(QUICK_LOOK)
>     virtual void didStartLoadForQuickLookDocumentInMainFrame(const WTF::String& fileName, const WTF::String& uti) { }
>-    virtual void didFinishLoadForQuickLookDocumentInMainFrame(const WebCore::SharedBuffer&) { }
>+    virtual void didFinishLoadForQuickLookDocumentInMainFrame(const WebCore::FragmentedSharedBuffer&) { }
> #endif
> 
>     virtual void decidePolicyForNavigationAction(WebKit::WebPageProxy&, Ref<NavigationAction>&&, Ref<WebKit::WebFramePolicyListenerProxy>&& listener, Object*)
>diff --git a/Source/WebKit/UIProcess/API/Cocoa/APIAttachmentCocoa.mm b/Source/WebKit/UIProcess/API/Cocoa/APIAttachmentCocoa.mm
>index cf46216ca25a..dfef3e070f96 100644
>--- a/Source/WebKit/UIProcess/API/Cocoa/APIAttachmentCocoa.mm
>+++ b/Source/WebKit/UIProcess/API/Cocoa/APIAttachmentCocoa.mm
>@@ -137,7 +137,7 @@ std::optional<uint64_t> Attachment::fileSizeForDisplay() const
>     return [fileWrapper regularFileContents].length;
> }
> 
>-RefPtr<WebCore::SharedBuffer> Attachment::enclosingImageData() const
>+RefPtr<WebCore::FragmentedSharedBuffer> Attachment::enclosingImageData() const
> {
>     if (!m_hasEnclosingImage)
>         return nullptr;
>diff --git a/Source/WebKit/UIProcess/API/Cocoa/WKWebView.mm b/Source/WebKit/UIProcess/API/Cocoa/WKWebView.mm
>index a72d0d2c92d7..3fbdf1471eff 100644
>--- a/Source/WebKit/UIProcess/API/Cocoa/WKWebView.mm
>+++ b/Source/WebKit/UIProcess/API/Cocoa/WKWebView.mm
>@@ -1596,7 +1596,7 @@ - (void)_storeAppHighlight:(const WebCore::AppHighlight&)highlight
>     if (highlight.text)
>         text = highlight.text.value();
> 
>-    auto wkHighlight = adoptNS([[_WKAppHighlight alloc] initWithHighlight:highlight.highlight->createNSData().get() text:text image:nil]);
>+    auto wkHighlight = adoptNS([[_WKAppHighlight alloc] initWithHighlight:highlight.highlight->makeContiguous()->createNSData().get() text:text image:nil]);
> 
>     if ([delegate respondsToSelector:@selector(_webView:storeAppHighlight:inNewGroup:requestOriginatedInApp:)])
>         [delegate _webView:self storeAppHighlight:wkHighlight.get() inNewGroup:highlight.isNewGroup == WebCore::CreateNewGroupForHighlight::Yes requestOriginatedInApp:highlight.requestOriginatedInApp == WebCore::HighlightRequestOriginatedInApp::Yes];
>@@ -2221,7 +2221,7 @@ - (void)_requestResource:(NSURLRequest *)request completionHandler:(void(^)(NSDa
> {
>     _page->requestResource(request, [completionHandler = makeBlockPtr(completionHandler)] (Ref<WebCore::SharedBuffer>&& buffer, WebCore::ResourceResponse&& response, WebCore::ResourceError&& error) {
>         if (error.isNull())
>-            return completionHandler(buffer->createNSData().get(), response.nsURLResponse(), nil);
>+            return completionHandler(buffer->makeContiguous()->createNSData().get(), response.nsURLResponse(), nil);
>         completionHandler(nil, nil, error.nsError());
>     });
> }
>diff --git a/Source/WebKit/UIProcess/Cocoa/NavigationState.h b/Source/WebKit/UIProcess/Cocoa/NavigationState.h
>index ac4a0f437015..c8029c140a6d 100644
>--- a/Source/WebKit/UIProcess/Cocoa/NavigationState.h
>+++ b/Source/WebKit/UIProcess/Cocoa/NavigationState.h
>@@ -133,7 +133,7 @@ private:
> 
> #if USE(QUICK_LOOK)
>         void didStartLoadForQuickLookDocumentInMainFrame(const WTF::String& fileName, const WTF::String& uti) override;
>-        void didFinishLoadForQuickLookDocumentInMainFrame(const WebCore::SharedBuffer&) override;
>+        void didFinishLoadForQuickLookDocumentInMainFrame(const WebCore::FragmentedSharedBuffer&) override;
> #endif
> 
> #if PLATFORM(MAC)
>diff --git a/Source/WebKit/UIProcess/Cocoa/NavigationState.mm b/Source/WebKit/UIProcess/Cocoa/NavigationState.mm
>index 3855882c87dc..8d3a856462ea 100644
>--- a/Source/WebKit/UIProcess/Cocoa/NavigationState.mm
>+++ b/Source/WebKit/UIProcess/Cocoa/NavigationState.mm
>@@ -1220,7 +1220,7 @@ void NavigationState::NavigationClient::didStartLoadForQuickLookDocumentInMainFr
>     [static_cast<id <WKNavigationDelegatePrivate>>(navigationDelegate.get()) _webView:m_navigationState->m_webView didStartLoadForQuickLookDocumentInMainFrameWithFileName:fileName uti:uti];
> }
> 
>-void NavigationState::NavigationClient::didFinishLoadForQuickLookDocumentInMainFrame(const SharedBuffer& buffer)
>+void NavigationState::NavigationClient::didFinishLoadForQuickLookDocumentInMainFrame(const FragmentedSharedBuffer& buffer)
> {
>     if (!m_navigationState)
>         return;
>@@ -1232,7 +1232,7 @@ void NavigationState::NavigationClient::didFinishLoadForQuickLookDocumentInMainF
>     if (!navigationDelegate)
>         return;
> 
>-    [static_cast<id <WKNavigationDelegatePrivate>>(navigationDelegate.get()) _webView:m_navigationState->m_webView didFinishLoadForQuickLookDocumentInMainFrame:buffer.createNSData().get()];
>+    [static_cast<id <WKNavigationDelegatePrivate>>(navigationDelegate.get()) _webView:m_navigationState->m_webView didFinishLoadForQuickLookDocumentInMainFrame:buffer.makeContiguous()->createNSData().get()];
> }
> #endif
> 
>diff --git a/Source/WebKit/UIProcess/Cocoa/WebProcessProxyCocoa.mm b/Source/WebKit/UIProcess/Cocoa/WebProcessProxyCocoa.mm
>index 802ffaa6d6ed..683373eae00f 100644
>--- a/Source/WebKit/UIProcess/Cocoa/WebProcessProxyCocoa.mm
>+++ b/Source/WebKit/UIProcess/Cocoa/WebProcessProxyCocoa.mm
>@@ -302,12 +302,12 @@ void WebProcessProxy::sendAudioComponentRegistrations()
>         if (noErr != AudioComponentFetchServerRegistrations(&registrations) || !registrations)
>             return;
> 
>-        RunLoop::main().dispatch([weakThis = WTFMove(weakThis), registrations = adoptCF(registrations)] () mutable {
>+        RunLoop::main().dispatch([weakThis = WTFMove(weakThis), registrations = adoptCF(registrations)] () {
>             if (!weakThis)
>                 return;
> 
>             auto registrationData = WebCore::SharedBuffer::create(registrations.get());
>-            weakThis->send(Messages::WebProcess::ConsumeAudioComponentRegistrations({ registrationData }), 0);
>+            weakThis->send(Messages::WebProcess::ConsumeAudioComponentRegistrations({ WTFMove(registrationData) }), 0);
>         });
>     });
> }
>diff --git a/Source/WebKit/UIProcess/Cocoa/WebViewImpl.h b/Source/WebKit/UIProcess/Cocoa/WebViewImpl.h
>index 3f6dd1f242e7..f5891241702d 100644
>--- a/Source/WebKit/UIProcess/Cocoa/WebViewImpl.h
>+++ b/Source/WebKit/UIProcess/Cocoa/WebViewImpl.h
>@@ -506,7 +506,7 @@ public:
> 
>     void startDrag(const WebCore::DragItem&, const ShareableBitmap::Handle& image);
>     void setFileAndURLTypes(NSString *filename, NSString *extension, NSString *title, NSString *url, NSString *visibleURL, NSPasteboard *);
>-    void setPromisedDataForImage(WebCore::Image*, NSString *filename, NSString *extension, NSString *title, NSString *url, NSString *visibleURL, WebCore::SharedBuffer* archiveBuffer, NSString *pasteboardName, NSString *pasteboardOrigin);
>+    void setPromisedDataForImage(WebCore::Image*, NSString *filename, NSString *extension, NSString *title, NSString *url, NSString *visibleURL, WebCore::FragmentedSharedBuffer* archiveBuffer, NSString *pasteboardName, NSString *pasteboardOrigin);
>     void pasteboardChangedOwner(NSPasteboard *);
>     void provideDataForPasteboard(NSPasteboard *, NSString *type);
>     NSArray *namesOfPromisedFilesDroppedAtDestination(NSURL *dropDestination);
>diff --git a/Source/WebKit/UIProcess/Cocoa/WebViewImpl.mm b/Source/WebKit/UIProcess/Cocoa/WebViewImpl.mm
>index 3d9e877b0cb7..62367dc5ad1f 100644
>--- a/Source/WebKit/UIProcess/Cocoa/WebViewImpl.mm
>+++ b/Source/WebKit/UIProcess/Cocoa/WebViewImpl.mm
>@@ -4449,7 +4449,7 @@ void WebViewImpl::setFileAndURLTypes(NSString *filename, NSString *extension, NS
>     m_promisedURL = url;
> }
> 
>-void WebViewImpl::setPromisedDataForImage(WebCore::Image* image, NSString *filename, NSString *extension, NSString *title, NSString *url, NSString *visibleURL, WebCore::SharedBuffer* archiveBuffer, NSString *pasteboardName, NSString *originIdentifier)
>+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]);
>@@ -4470,7 +4470,7 @@ void WebViewImpl::setPromisedDataForImage(WebCore::Image* image, NSString *filen
>     setFileAndURLTypes(filename, extension, title, url, visibleURL, pasteboard);
> 
>     if (archiveBuffer) {
>-        auto nsData = archiveBuffer->createNSData();
>+        auto nsData = archiveBuffer->makeContiguous()->createNSData();
> ALLOW_DEPRECATED_DECLARATIONS_BEGIN
>         [pasteboard setData:nsData.get() forType:(__bridge NSString *)kUTTypeWebArchive];
> ALLOW_DEPRECATED_DECLARATIONS_END
>@@ -4501,7 +4501,7 @@ void WebViewImpl::provideDataForPasteboard(NSPasteboard *pasteboard, NSString *t
>         return;
> 
>     if ([type isEqual:m_promisedImage->uti()] && m_promisedImage->data()) {
>-        if (auto platformData = m_promisedImage->data()->createNSData())
>+        if (auto platformData = m_promisedImage->data()->makeContiguous()->createNSData())
>             [pasteboard setData:(__bridge NSData *)platformData.get() forType:type];
>     }
> 
>@@ -4554,7 +4554,7 @@ NSArray *WebViewImpl::namesOfPromisedFilesDroppedAtDestination(NSURL *dropDestin
>     RetainPtr<NSData> data;
> 
>     if (m_promisedImage) {
>-        data = m_promisedImage->data()->createNSData();
>+        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]);
>diff --git a/Source/WebKit/UIProcess/PageClient.h b/Source/WebKit/UIProcess/PageClient.h
>index c485c7fc313e..b462d8db5cc6 100644
>--- a/Source/WebKit/UIProcess/PageClient.h
>+++ b/Source/WebKit/UIProcess/PageClient.h
>@@ -328,7 +328,7 @@ public:
> #endif
> 
> #if USE(APPKIT)
>-    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;
>+    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;
> #endif
> 
>     virtual WebCore::FloatRect convertToDeviceSpace(const WebCore::FloatRect&) = 0;
>diff --git a/Source/WebKit/UIProcess/WebPageProxy.h b/Source/WebKit/UIProcess/WebPageProxy.h
>index 9a816fdb3183..b4da6fd688eb 100644
>--- a/Source/WebKit/UIProcess/WebPageProxy.h
>+++ b/Source/WebKit/UIProcess/WebPageProxy.h
>@@ -259,7 +259,7 @@ class IntSize;
> class ProtectionSpace;
> class RunLoopObserver;
> class SelectionData;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> class SpeechRecognitionRequest;
> class TextIndicator;
> class ValidationBubble;
>diff --git a/Source/WebKit/UIProcess/WebURLSchemeTask.cpp b/Source/WebKit/UIProcess/WebURLSchemeTask.cpp
>index df59d56fd697..e1264ce21ba5 100644
>--- a/Source/WebKit/UIProcess/WebURLSchemeTask.cpp
>+++ b/Source/WebKit/UIProcess/WebURLSchemeTask.cpp
>@@ -168,7 +168,7 @@ auto WebURLSchemeTask::didReceiveResponse(const ResourceResponse& response) -> E
>     return ExceptionType::None;
> }
> 
>-auto WebURLSchemeTask::didReceiveData(Ref<SharedBuffer>&& buffer) -> ExceptionType
>+auto WebURLSchemeTask::didReceiveData(Ref<FragmentedSharedBuffer>&& buffer) -> ExceptionType
> {
>     ASSERT(RunLoop::isMain());
> 
>@@ -187,10 +187,7 @@ auto WebURLSchemeTask::didReceiveData(Ref<SharedBuffer>&& buffer) -> ExceptionTy
>     m_dataSent = true;
> 
>     if (isSync()) {
>-        if (m_syncData)
>-            m_syncData->append(WTFMove(buffer));
>-        else
>-            m_syncData = WTFMove(buffer);
>+        m_syncData.append(WTFMove(buffer));
>         return ExceptionType::None;
>     }
> 
>@@ -215,14 +212,11 @@ auto WebURLSchemeTask::didComplete(const ResourceError& error) -> ExceptionType
>         return ExceptionType::WaitingForRedirectCompletionHandler;
> 
>     m_completed = true;
>-    
>-    if (isSync()) {
>-        Vector<uint8_t> data;
>-        if (m_syncData)
>-            data = { m_syncData->data(), m_syncData->size() };
> 
>+    if (isSync()) {
>+        size_t size = m_syncData.size();
>+        Vector<uint8_t> data = { m_syncData.takeAsContiguous()->data(), 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);
>diff --git a/Source/WebKit/UIProcess/WebURLSchemeTask.h b/Source/WebKit/UIProcess/WebURLSchemeTask.h
>index 6a856021b129..f6ff46eea5f2 100644
>--- a/Source/WebKit/UIProcess/WebURLSchemeTask.h
>+++ b/Source/WebKit/UIProcess/WebURLSchemeTask.h
>@@ -43,7 +43,6 @@ class FrameInfo;
> namespace WebCore {
> class ResourceError;
> class ResourceResponse;
>-class SharedBuffer;
> }
> 
> namespace WebKit {
>@@ -84,7 +83,7 @@ public:
>     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::SharedBuffer>&&);
>+    ExceptionType didReceiveData(Ref<WebCore::FragmentedSharedBuffer>&&);
>     ExceptionType didComplete(const WebCore::ResourceError&);
> 
>     void stop();
>@@ -115,7 +114,7 @@ private:
> 
>     SyncLoadCompletionHandler m_syncCompletionHandler;
>     WebCore::ResourceResponse m_syncResponse;
>-    RefPtr<WebCore::SharedBuffer> m_syncData;
>+    WebCore::SharedBufferBuilder m_syncData;
> 
>     bool m_waitingForRedirectCompletionHandlerCallback { false };
> };
>diff --git a/Source/WebKit/UIProcess/gtk/Clipboard.h b/Source/WebKit/UIProcess/gtk/Clipboard.h
>index 7866cdb17746..7279f844cc2b 100644
>--- a/Source/WebKit/UIProcess/gtk/Clipboard.h
>+++ b/Source/WebKit/UIProcess/gtk/Clipboard.h
>@@ -36,7 +36,7 @@ typedef struct _GtkClipboard GtkClipboard;
> 
> namespace WebCore {
> class SelectionData;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> }
> 
> namespace WebKit {
>@@ -55,7 +55,7 @@ public:
>     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::SharedBuffer>&&)>&&);
>+    void readBuffer(const char*, CompletionHandler<void(Ref<WebCore::FragmentedSharedBuffer>&&)>&&);
>     void write(WebCore::SelectionData&&);
>     void clear();
> 
>diff --git a/Source/WebKit/UIProcess/gtk/ClipboardGtk3.cpp b/Source/WebKit/UIProcess/gtk/ClipboardGtk3.cpp
>index c2bf5183b30f..5966d5574c28 100644
>--- a/Source/WebKit/UIProcess/gtk/ClipboardGtk3.cpp
>+++ b/Source/WebKit/UIProcess/gtk/ClipboardGtk3.cpp
>@@ -126,15 +126,15 @@ void Clipboard::readFilePaths(CompletionHandler<void(Vector<String>&&)>&& comple
> struct ReadBufferAsyncData {
>     WTF_MAKE_STRUCT_FAST_ALLOCATED;
> 
>-    explicit ReadBufferAsyncData(CompletionHandler<void(Ref<WebCore::SharedBuffer>&&)>&& handler)
>+    explicit ReadBufferAsyncData(CompletionHandler<void(Ref<WebCore::FragmentedSharedBuffer>&&)>&& handler)
>         : completionHandler(WTFMove(handler))
>     {
>     }
> 
>-    CompletionHandler<void(Ref<WebCore::SharedBuffer>&&)> completionHandler;
>+    CompletionHandler<void(Ref<WebCore::FragmentedSharedBuffer>&&)> completionHandler;
> };
> 
>-void Clipboard::readBuffer(const char* format, CompletionHandler<void(Ref<WebCore::SharedBuffer>&&)>&& 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));
>diff --git a/Source/WebKit/UIProcess/gtk/ClipboardGtk4.cpp b/Source/WebKit/UIProcess/gtk/ClipboardGtk4.cpp
>index 07abb7131988..5b81fa8f29d3 100644
>--- a/Source/WebKit/UIProcess/gtk/ClipboardGtk4.cpp
>+++ b/Source/WebKit/UIProcess/gtk/ClipboardGtk4.cpp
>@@ -120,15 +120,15 @@ void Clipboard::readFilePaths(CompletionHandler<void(Vector<String>&&)>&& comple
> struct ReadBufferAsyncData {
>     WTF_MAKE_STRUCT_FAST_ALLOCATED;
> 
>-    explicit ReadBufferAsyncData(CompletionHandler<void(Ref<WebCore::SharedBuffer>&&)>&& handler)
>+    explicit ReadBufferAsyncData(CompletionHandler<void(Ref<WebCore::FragmentedSharedBuffer>&&)>&& handler)
>         : completionHandler(WTFMove(handler))
>     {
>     }
> 
>-    CompletionHandler<void(Ref<WebCore::SharedBuffer>&&)> completionHandler;
>+    CompletionHandler<void(Ref<WebCore::FragmentedSharedBuffer>&&)> completionHandler;
> };
> 
>-void Clipboard::readBuffer(const char* format, CompletionHandler<void(Ref<WebCore::SharedBuffer>&&)>&& 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) {
>diff --git a/Source/WebKit/UIProcess/mac/PageClientImplMac.h b/Source/WebKit/UIProcess/mac/PageClientImplMac.h
>index d2238fdc9d16..ab87c2a7e8c3 100644
>--- a/Source/WebKit/UIProcess/mac/PageClientImplMac.h
>+++ b/Source/WebKit/UIProcess/mac/PageClientImplMac.h
>@@ -100,8 +100,8 @@ private:
>     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::SharedBuffer>&& imageBuffer, const String& filename, const String& extension, const String& title,
>-        const String& url, const String& visibleURL, RefPtr<WebCore::SharedBuffer>&& archiveBuffer, const String& originIdentifier) 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;
>diff --git a/Source/WebKit/UIProcess/mac/PageClientImplMac.mm b/Source/WebKit/UIProcess/mac/PageClientImplMac.mm
>index a4112135f2ef..c363e955e879 100644
>--- a/Source/WebKit/UIProcess/mac/PageClientImplMac.mm
>+++ b/Source/WebKit/UIProcess/mac/PageClientImplMac.mm
>@@ -400,7 +400,7 @@ void PageClientImpl::startDrag(const WebCore::DragItem& item, const ShareableBit
>     m_impl->startDrag(item, image);
> }
> 
>-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)
>+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)
> {
>     auto image = BitmapImage::create();
>     image->setData(WTFMove(imageBuffer), true);
>diff --git a/Source/WebKit/UIProcess/mac/WebPageProxyMac.mm b/Source/WebKit/UIProcess/mac/WebPageProxyMac.mm
>index eaf7e079ae41..323ef0292ade 100644
>--- a/Source/WebKit/UIProcess/mac/WebPageProxyMac.mm
>+++ b/Source/WebKit/UIProcess/mac/WebPageProxyMac.mm
>@@ -277,7 +277,7 @@ void WebPageProxy::setPromisedDataForImage(const String& pasteboardName, const S
>         return;
>     auto imageBuffer = sharedMemoryImage->createSharedBuffer(imageHandle.dataSize);
> 
>-    RefPtr<SharedBuffer> archiveBuffer;
>+    RefPtr<FragmentedSharedBuffer> archiveBuffer;
>     if (!archiveHandle.handle.isNull()) {
>         auto sharedMemoryArchive = SharedMemory::map(archiveHandle.handle, SharedMemory::Protection::ReadOnly);
>         if (!sharedMemoryArchive)
>diff --git a/Source/WebKit/WebProcess/GPU/media/RemoteCDM.cpp b/Source/WebKit/WebProcess/GPU/media/RemoteCDM.cpp
>index fa94025ed747..c28fe65f0cf1 100644
>--- a/Source/WebKit/WebProcess/GPU/media/RemoteCDM.cpp
>+++ b/Source/WebKit/WebProcess/GPU/media/RemoteCDM.cpp
>@@ -84,7 +84,7 @@ bool RemoteCDM::supportsSessionTypeWithConfiguration(const CDMSessionType&, cons
>     return false;
> }
> 
>-bool RemoteCDM::supportsInitData(const AtomString& type, const SharedBuffer& data) const
>+bool RemoteCDM::supportsInitData(const AtomString& type, const FragmentedSharedBuffer& data) const
> {
>     // This check will be done, later, inside RemoteCDMInstanceSessionProxy::requestLicense().
>     return true;
>@@ -129,7 +129,7 @@ void RemoteCDM::loadAndInitialize()
>     m_factory->gpuProcessConnection().connection().send(Messages::RemoteCDMProxy::LoadAndInitialize(), m_identifier);
> }
> 
>-RefPtr<SharedBuffer> RemoteCDM::sanitizeResponse(const SharedBuffer& response) const
>+RefPtr<FragmentedSharedBuffer> RemoteCDM::sanitizeResponse(const FragmentedSharedBuffer& response) const
> {
>     // This check will be done, later, inside RemoteCDMInstanceSessionProxy::updateLicense().
>     return response.copy();
>diff --git a/Source/WebKit/WebProcess/GPU/media/RemoteCDM.h b/Source/WebKit/WebProcess/GPU/media/RemoteCDM.h
>index 0addf83353b6..8c454eb83e59 100644
>--- a/Source/WebKit/WebProcess/GPU/media/RemoteCDM.h
>+++ b/Source/WebKit/WebProcess/GPU/media/RemoteCDM.h
>@@ -48,13 +48,13 @@ private:
>     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::SharedBuffer&) 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::SharedBuffer> sanitizeResponse(const WebCore::SharedBuffer&) const 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; }
>diff --git a/Source/WebKit/WebProcess/GPU/media/RemoteCDMInstance.cpp b/Source/WebKit/WebProcess/GPU/media/RemoteCDMInstance.cpp
>index b5dea21e995a..a13e51460f6b 100644
>--- a/Source/WebKit/WebProcess/GPU/media/RemoteCDMInstance.cpp
>+++ b/Source/WebKit/WebProcess/GPU/media/RemoteCDMInstance.cpp
>@@ -78,7 +78,7 @@ void RemoteCDMInstance::initializeWithConfiguration(const WebCore::CDMKeySystemC
>     m_factory->gpuProcessConnection().connection().sendWithAsyncReply(Messages::RemoteCDMInstanceProxy::InitializeWithConfiguration(configuration, distinctiveIdentifiers, persistentState), WTFMove(callback), m_identifier);
> }
> 
>-void RemoteCDMInstance::setServerCertificate(Ref<WebCore::SharedBuffer>&& certificate, SuccessCallback&& callback)
>+void RemoteCDMInstance::setServerCertificate(Ref<WebCore::FragmentedSharedBuffer>&& certificate, SuccessCallback&& callback)
> {
>     if (!m_factory) {
>         callback(Failed);
>diff --git a/Source/WebKit/WebProcess/GPU/media/RemoteCDMInstance.h b/Source/WebKit/WebProcess/GPU/media/RemoteCDMInstance.h
>index 106ba3b1161c..2c7851e440b0 100644
>--- a/Source/WebKit/WebProcess/GPU/media/RemoteCDMInstance.h
>+++ b/Source/WebKit/WebProcess/GPU/media/RemoteCDMInstance.h
>@@ -54,7 +54,7 @@ private:
> 
>     ImplementationType implementationType() const final { return ImplementationType::Remote; }
>     void initializeWithConfiguration(const WebCore::CDMKeySystemConfiguration&, AllowDistinctiveIdentifiers, AllowPersistentState, SuccessCallback&&) final;
>-    void setServerCertificate(Ref<WebCore::SharedBuffer>&&, SuccessCallback&&) final;
>+    void setServerCertificate(Ref<WebCore::FragmentedSharedBuffer>&&, SuccessCallback&&) final;
>     void setStorageDirectory(const String&) final;
>     const String& keySystem() const final { return m_configuration.keySystem; }
>     RefPtr<WebCore::CDMInstanceSession> createSession() final;
>diff --git a/Source/WebKit/WebProcess/GPU/media/RemoteCDMInstanceSession.cpp b/Source/WebKit/WebProcess/GPU/media/RemoteCDMInstanceSession.cpp
>index af0bad4c90d8..c740c04506fd 100644
>--- a/Source/WebKit/WebProcess/GPU/media/RemoteCDMInstanceSession.cpp
>+++ b/Source/WebKit/WebProcess/GPU/media/RemoteCDMInstanceSession.cpp
>@@ -49,7 +49,7 @@ RemoteCDMInstanceSession::RemoteCDMInstanceSession(WeakPtr<RemoteCDMFactory>&& f
> {
> }
> 
>-void RemoteCDMInstanceSession::requestLicense(LicenseType type, const AtomString& initDataType, Ref<SharedBuffer>&& initData, LicenseCallback&& callback)
>+void RemoteCDMInstanceSession::requestLicense(LicenseType type, const AtomString& initDataType, Ref<FragmentedSharedBuffer>&& initData, LicenseCallback&& callback)
> {
>     if (!m_factory) {
>         callback(SharedBuffer::create(), emptyString(), false, Failed);
>@@ -65,7 +65,7 @@ void RemoteCDMInstanceSession::requestLicense(LicenseType type, const AtomString
>     }, m_identifier);
> }
> 
>-void RemoteCDMInstanceSession::updateLicense(const String& sessionId, LicenseType type, Ref<SharedBuffer>&& response, LicenseUpdateCallback&& callback)
>+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);
>@@ -109,7 +109,7 @@ void RemoteCDMInstanceSession::removeSessionData(const String& sessionId, Licens
>     }
> 
>     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<SharedBuffer>> realMessage = std::nullopt;
>+        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);
>diff --git a/Source/WebKit/WebProcess/GPU/media/RemoteCDMInstanceSession.h b/Source/WebKit/WebProcess/GPU/media/RemoteCDMInstanceSession.h
>index 4ffe4caceccd..4e4cd2c005c6 100644
>--- a/Source/WebKit/WebProcess/GPU/media/RemoteCDMInstanceSession.h
>+++ b/Source/WebKit/WebProcess/GPU/media/RemoteCDMInstanceSession.h
>@@ -59,8 +59,8 @@ private:
> 
>     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::SharedBuffer>&& initData, LicenseCallback&&) final;
>-    void updateLicense(const String& sessionId, LicenseType, Ref<WebCore::SharedBuffer>&& response, LicenseUpdateCallback&&) final;
>+    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;
>diff --git a/Source/WebKit/WebProcess/GPU/media/RemoteImageDecoderAVF.cpp b/Source/WebKit/WebProcess/GPU/media/RemoteImageDecoderAVF.cpp
>index 9a219a544e55..62926798c5c1 100644
>--- a/Source/WebKit/WebProcess/GPU/media/RemoteImageDecoderAVF.cpp
>+++ b/Source/WebKit/WebProcess/GPU/media/RemoteImageDecoderAVF.cpp
>@@ -200,7 +200,7 @@ void RemoteImageDecoderAVF::setExpectedContentSize(long long expectedContentSize
> 
> // If allDataReceived is true, the caller expects encodedDataStatus() to be >= EncodedDataStatus::SizeAvailable
> // after this function returns (in the same run loop).
>-void RemoteImageDecoderAVF::setData(SharedBuffer& data, bool allDataReceived)
>+void RemoteImageDecoderAVF::setData(FragmentedSharedBuffer& data, bool allDataReceived)
> {
>     if (!m_gpuProcessConnection)
>         return;
>diff --git a/Source/WebKit/WebProcess/GPU/media/RemoteImageDecoderAVF.h b/Source/WebKit/WebProcess/GPU/media/RemoteImageDecoderAVF.h
>index e5cfe94ecd3a..40d3734f7a32 100644
>--- a/Source/WebKit/WebProcess/GPU/media/RemoteImageDecoderAVF.h
>+++ b/Source/WebKit/WebProcess/GPU/media/RemoteImageDecoderAVF.h
>@@ -45,7 +45,7 @@ class RemoteImageDecoderAVF final
>     : public WebCore::ImageDecoder
>     , public CanMakeWeakPtr<RemoteImageDecoderAVF> {
> public:
>-    static Ref<RemoteImageDecoderAVF> create(RemoteImageDecoderAVFManager& manager, const WebCore::ImageDecoderIdentifier& identifier, WebCore::SharedBuffer&, const String& mimeType)
>+    static Ref<RemoteImageDecoderAVF> create(RemoteImageDecoderAVFManager& manager, const WebCore::ImageDecoderIdentifier& identifier, WebCore::FragmentedSharedBuffer&, const String& mimeType)
>     {
>         return adoptRef(*new RemoteImageDecoderAVF(manager, identifier, mimeType));
>     }
>@@ -80,7 +80,7 @@ public:
>     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::SharedBuffer&, bool allDataReceived) final;
>+    void setData(WebCore::FragmentedSharedBuffer&, bool allDataReceived) final;
>     bool isAllDataReceived() const final { return m_isAllDataReceived; }
>     void clearFrameBufferCache(size_t) final;
> 
>diff --git a/Source/WebKit/WebProcess/GPU/media/RemoteImageDecoderAVFManager.cpp b/Source/WebKit/WebProcess/GPU/media/RemoteImageDecoderAVFManager.cpp
>index 41d5388023d3..082b3366c8bc 100644
>--- a/Source/WebKit/WebProcess/GPU/media/RemoteImageDecoderAVFManager.cpp
>+++ b/Source/WebKit/WebProcess/GPU/media/RemoteImageDecoderAVFManager.cpp
>@@ -39,7 +39,7 @@ namespace WebKit {
> 
> using namespace WebCore;
> 
>-RefPtr<RemoteImageDecoderAVF> RemoteImageDecoderAVFManager::createImageDecoder(SharedBuffer& data, const String& mimeType, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
>+RefPtr<RemoteImageDecoderAVF> RemoteImageDecoderAVFManager::createImageDecoder(FragmentedSharedBuffer& data, const String& mimeType, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
> {
>     std::optional<ImageDecoderIdentifier> imageDecoderIdentifier;
>     IPC::SharedBufferDataReference dataReference { data };
>@@ -108,7 +108,7 @@ void RemoteImageDecoderAVFManager::setUseGPUProcess(bool useGPUProcess)
>     ImageDecoder::installFactory({
>         RemoteImageDecoderAVF::supportsMediaType,
>         RemoteImageDecoderAVF::canDecodeType,
>-        [this](SharedBuffer& data, const String& mimeType, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption) {
>+        [this](FragmentedSharedBuffer& data, const String& mimeType, AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption) {
>             return createImageDecoder(data, mimeType, alphaOption, gammaAndColorProfileOption);
>         }
>     });
>diff --git a/Source/WebKit/WebProcess/GPU/media/RemoteImageDecoderAVFManager.h b/Source/WebKit/WebProcess/GPU/media/RemoteImageDecoderAVFManager.h
>index c23782b6504e..3618afd12098 100644
>--- a/Source/WebKit/WebProcess/GPU/media/RemoteImageDecoderAVFManager.h
>+++ b/Source/WebKit/WebProcess/GPU/media/RemoteImageDecoderAVFManager.h
>@@ -59,7 +59,7 @@ public:
>     GPUProcessConnection& ensureGPUProcessConnection();
> 
> private:
>-    RefPtr<RemoteImageDecoderAVF> createImageDecoder(WebCore::SharedBuffer& data, const String& mimeType, WebCore::AlphaOption, WebCore::GammaAndColorProfileOption);
>+    RefPtr<RemoteImageDecoderAVF> createImageDecoder(WebCore::FragmentedSharedBuffer& data, const String& mimeType, WebCore::AlphaOption, WebCore::GammaAndColorProfileOption);
> 
>     // GPUProcessConnection::Client.
>     void gpuProcessConnectionDidClose(GPUProcessConnection&) final;
>diff --git a/Source/WebKit/WebProcess/GPU/webrtc/MediaRecorderPrivate.cpp b/Source/WebKit/WebProcess/GPU/webrtc/MediaRecorderPrivate.cpp
>index 11b4a86e4852..b4089fd3548c 100644
>--- a/Source/WebKit/WebProcess/GPU/webrtc/MediaRecorderPrivate.cpp
>+++ b/Source/WebKit/WebProcess/GPU/webrtc/MediaRecorderPrivate.cpp
>@@ -165,10 +165,10 @@ void MediaRecorderPrivate::storageChanged(SharedMemory* storage, const WebCore::
>     m_connection->send(Messages::RemoteMediaRecorder::AudioSamplesStorageChanged { SharedMemory::IPCHandle { WTFMove(handle), dataSize }, format, frameCount }, m_identifier);
> }
> 
>-void MediaRecorderPrivate::fetchData(CompletionHandler<void(RefPtr<WebCore::SharedBuffer>&&, const String& mimeType, double)>&& completionHandler)
>+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<SharedBuffer> buffer;
>+        RefPtr<FragmentedSharedBuffer> buffer;
>         if (data.size())
>             buffer = SharedBuffer::create(data.data(), data.size());
>         completionHandler(WTFMove(buffer), mimeType, timeCode);
>diff --git a/Source/WebKit/WebProcess/GPU/webrtc/MediaRecorderPrivate.h b/Source/WebKit/WebProcess/GPU/webrtc/MediaRecorderPrivate.h
>index 303a54f76f18..576fd1c6e97c 100644
>--- a/Source/WebKit/WebProcess/GPU/webrtc/MediaRecorderPrivate.h
>+++ b/Source/WebKit/WebProcess/GPU/webrtc/MediaRecorderPrivate.h
>@@ -57,7 +57,7 @@ public:
> private:
>     // WebCore::MediaRecorderPrivate
>     void videoSampleAvailable(WebCore::MediaSample&, WebCore::VideoSampleMetadata) final;
>-    void fetchData(CompletionHandler<void(RefPtr<WebCore::SharedBuffer>&&, const String& mimeType, double)>&&) final;
>+    void fetchData(CompletionHandler<void(RefPtr<WebCore::FragmentedSharedBuffer>&&, const String& mimeType, double)>&&) final;
>     void stopRecording(CompletionHandler<void()>&&) final;
>     void startRecording(StartRecordingCallback&&) final;
>     void audioSamplesAvailable(const WTF::MediaTime&, const WebCore::PlatformAudioData&, const WebCore::AudioStreamDescription&, size_t) final;
>diff --git a/Source/WebKit/WebProcess/InjectedBundle/API/APIInjectedBundleEditorClient.h b/Source/WebKit/WebProcess/InjectedBundle/API/APIInjectedBundleEditorClient.h
>index 0673f74ddfb4..0353aabf7d4b 100644
>--- a/Source/WebKit/WebProcess/InjectedBundle/API/APIInjectedBundleEditorClient.h
>+++ b/Source/WebKit/WebProcess/InjectedBundle/API/APIInjectedBundleEditorClient.h
>@@ -31,9 +31,9 @@
> #include <wtf/text/WTFString.h>
> 
> namespace WebCore {
>+class SharedBuffer;
> class DocumentFragment;
> class Node;
>-class SharedBuffer;
> class StyleProperties;
> struct SimpleRange;
> }
>diff --git a/Source/WebKit/WebProcess/InjectedBundle/API/APIInjectedBundlePageLoaderClient.h b/Source/WebKit/WebProcess/InjectedBundle/API/APIInjectedBundlePageLoaderClient.h
>index a0635204335b..180b1111ecf0 100644
>--- a/Source/WebKit/WebProcess/InjectedBundle/API/APIInjectedBundlePageLoaderClient.h
>+++ b/Source/WebKit/WebProcess/InjectedBundle/API/APIInjectedBundlePageLoaderClient.h
>@@ -36,7 +36,7 @@ class DOMWindowExtension;
> class DOMWrapperWorld;
> class ResourceError;
> class ResourceRequest;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> }
> 
> namespace WebKit {
>@@ -56,7 +56,7 @@ public:
>     virtual ~PageLoaderClient() = default;
> 
>     virtual void willLoadURLRequest(WebKit::WebPage&, const WebCore::ResourceRequest&, API::Object*) { }
>-    virtual void willLoadDataRequest(WebKit::WebPage&, const WebCore::ResourceRequest&, WebCore::SharedBuffer*, const WTF::String&, const WTF::String&, const WTF::URL&, 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>&) { }
>diff --git a/Source/WebKit/WebProcess/InjectedBundle/InjectedBundlePageLoaderClient.cpp b/Source/WebKit/WebProcess/InjectedBundle/InjectedBundlePageLoaderClient.cpp
>index 8d524b525c6e..94fed2e7e363 100644
>--- a/Source/WebKit/WebProcess/InjectedBundle/InjectedBundlePageLoaderClient.cpp
>+++ b/Source/WebKit/WebProcess/InjectedBundle/InjectedBundlePageLoaderClient.cpp
>@@ -62,18 +62,19 @@ void InjectedBundlePageLoaderClient::willLoadURLRequest(WebPage& page, const Res
> static void releaseSharedBuffer(unsigned char*, const void* data)
> {
>     // Balanced by ref() in InjectedBundlePageLoaderClient::willLoadDataRequest().
>-    static_cast<SharedBuffer*>(const_cast<void*>(data))->deref();
>+    static_cast<const SharedBuffer*>(data)->deref();
> }
> 
>-void InjectedBundlePageLoaderClient::willLoadDataRequest(WebPage& page, const ResourceRequest& request, SharedBuffer* sharedBuffer, const String& MIMEType, const String& encodingName, const URL& unreachableURL, API::Object* userData)
>+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) {
>-        sharedBuffer->ref();
>-        data = API::Data::createWithoutCopying((const unsigned char*)sharedBuffer->data(), sharedBuffer->size(), releaseSharedBuffer, 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);
>diff --git a/Source/WebKit/WebProcess/InjectedBundle/InjectedBundlePageLoaderClient.h b/Source/WebKit/WebProcess/InjectedBundle/InjectedBundlePageLoaderClient.h
>index 36bd980b2faa..863bdab6284c 100644
>--- a/Source/WebKit/WebProcess/InjectedBundle/InjectedBundlePageLoaderClient.h
>+++ b/Source/WebKit/WebProcess/InjectedBundle/InjectedBundlePageLoaderClient.h
>@@ -47,7 +47,7 @@ public:
>     explicit InjectedBundlePageLoaderClient(const WKBundlePageLoaderClientBase*);
> 
>     void willLoadURLRequest(WebPage&, const WebCore::ResourceRequest&, API::Object*) override;
>-    void willLoadDataRequest(WebPage&, const WebCore::ResourceRequest&, WebCore::SharedBuffer*, const WTF::String&, const WTF::String&, const URL&, API::Object*) override;
>+    void willLoadDataRequest(WebPage&, const WebCore::ResourceRequest&, WebCore::FragmentedSharedBuffer*, const WTF::String&, const WTF::String&, const URL&, API::Object*) override;
> 
>     void didStartProvisionalLoadForFrame(WebPage&, WebFrame&, RefPtr<API::Object>&) override;
>     void didReceiveServerRedirectForProvisionalLoadForFrame(WebPage&, WebFrame&, RefPtr<API::Object>&) override;
>diff --git a/Source/WebKit/WebProcess/Model/mac/ARKitInlinePreviewModelPlayerMac.mm b/Source/WebKit/WebProcess/Model/mac/ARKitInlinePreviewModelPlayerMac.mm
>index e524d8e1b017..a784ec388b22 100644
>--- a/Source/WebKit/WebProcess/Model/mac/ARKitInlinePreviewModelPlayerMac.mm
>+++ b/Source/WebKit/WebProcess/Model/mac/ARKitInlinePreviewModelPlayerMac.mm
>@@ -106,7 +106,7 @@ void ARKitInlinePreviewModelPlayerMac::createFile(WebCore::Model& modelSource)
>     if (file <= 0)
>         return;
> 
>-    FileSystem::writeToFile(file, modelSource.data()->data(), modelSource.data()->size());
>+    FileSystem::writeToFile(file, modelSource.data()->makeContiguous()->data(), modelSource.data()->size());
>     FileSystem::closeFile(file);
>     m_filePath = filePath;
> }
>diff --git a/Source/WebKit/WebProcess/Network/NetworkProcessConnection.cpp b/Source/WebKit/WebProcess/Network/NetworkProcessConnection.cpp
>index 94d9d2cc3eb2..02270a53af9b 100644
>--- a/Source/WebKit/WebProcess/Network/NetworkProcessConnection.cpp
>+++ b/Source/WebKit/WebProcess/Network/NetworkProcessConnection.cpp
>@@ -281,9 +281,9 @@ void NetworkProcessConnection::didCacheResource(const ResourceRequest& request,
>     if (!resource)
>         return;
>     
>-    RefPtr<SharedBuffer> buffer = handle.tryWrapInSharedBuffer();
>+    auto buffer = handle.tryWrapInSharedBuffer();
>     if (!buffer) {
>-        LOG_ERROR("Unable to create SharedBuffer from ShareableResource handle for resource url %s", request.url().string().utf8().data());
>+        LOG_ERROR("Unable to create FragmentedSharedBuffer from ShareableResource handle for resource url %s", request.url().string().utf8().data());
>         return;
>     }
> 
>diff --git a/Source/WebKit/WebProcess/Network/WebResourceLoader.cpp b/Source/WebKit/WebProcess/Network/WebResourceLoader.cpp
>index 259449423855..310fca7875c3 100644
>--- a/Source/WebKit/WebProcess/Network/WebResourceLoader.cpp
>+++ b/Source/WebKit/WebProcess/Network/WebResourceLoader.cpp
>@@ -155,7 +155,7 @@ void WebResourceLoader::didReceiveResponse(const ResourceResponse& response, boo
>     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<SharedBuffer> overrideData) mutable {
>+        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);
>@@ -295,11 +295,11 @@ void WebResourceLoader::didReceiveResource(const ShareableResource::Handle& hand
>     LOG(Network, "(WebProcess) WebResourceLoader::didReceiveResource for '%s'", m_coreLoader->url().string().latin1().data());
>     WEBRESOURCELOADER_RELEASE_LOG("didReceiveResource:");
> 
>-    RefPtr<SharedBuffer> buffer = handle.tryWrapInSharedBuffer();
>+    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 SharedBuffer");
>+        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);
>diff --git a/Source/WebKit/WebProcess/Plugins/PDF/PDFPlugin.h b/Source/WebKit/WebProcess/Plugins/PDF/PDFPlugin.h
>index 42de46141977..a7f45c8401b2 100644
>--- a/Source/WebKit/WebProcess/Plugins/PDF/PDFPlugin.h
>+++ b/Source/WebKit/WebProcess/Plugins/PDF/PDFPlugin.h
>@@ -207,7 +207,7 @@ private:
>     void privateBrowsingStateChanged(bool) final { }
>     bool getFormValue(String& formValue) final { return false; }
>     bool handleScroll(WebCore::ScrollDirection, WebCore::ScrollGranularity) final;
>-    RefPtr<WebCore::SharedBuffer> liveResourceData() const final;
>+    RefPtr<WebCore::FragmentedSharedBuffer> liveResourceData() const final;
>     void willDetachRenderer() final;
>     bool pluginHandlesContentOffsetForAccessibilityHitTest() const final;
>     
>diff --git a/Source/WebKit/WebProcess/Plugins/PDF/PDFPlugin.mm b/Source/WebKit/WebProcess/Plugins/PDF/PDFPlugin.mm
>index d23abb9e6511..d47f32b7d491 100644
>--- a/Source/WebKit/WebProcess/Plugins/PDF/PDFPlugin.mm
>+++ b/Source/WebKit/WebProcess/Plugins/PDF/PDFPlugin.mm
>@@ -2552,7 +2552,7 @@ void PDFPlugin::notifyDisplayModeChanged(int)
>     updateScrollbars();
> }
> 
>-RefPtr<SharedBuffer> PDFPlugin::liveResourceData() const
>+RefPtr<FragmentedSharedBuffer> PDFPlugin::liveResourceData() const
> {
>     NSData *pdfData = liveData();
> 
>diff --git a/Source/WebKit/WebProcess/Plugins/Plugin.h b/Source/WebKit/WebProcess/Plugins/Plugin.h
>index 88f45ce51ce3..58d70a39a16d 100644
>--- a/Source/WebKit/WebProcess/Plugins/Plugin.h
>+++ b/Source/WebKit/WebProcess/Plugins/Plugin.h
>@@ -61,7 +61,7 @@ class IntPoint;
> class IntRect;
> class IntSize;
> class Scrollbar;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> }
> 
> namespace WebKit {
>@@ -288,7 +288,7 @@ public:
> 
>     virtual WebCore::IntPoint convertToRootView(const WebCore::IntPoint& pointInLocalCoordinates) const;
> 
>-    virtual RefPtr<WebCore::SharedBuffer> liveResourceData() const = 0;
>+    virtual RefPtr<WebCore::FragmentedSharedBuffer> liveResourceData() const = 0;
> 
>     virtual bool performDictionaryLookupAtLocation(const WebCore::FloatPoint&) = 0;
> 
>diff --git a/Source/WebKit/WebProcess/Plugins/PluginView.cpp b/Source/WebKit/WebProcess/Plugins/PluginView.cpp
>index dc56d2c66ed8..4d5373472713 100644
>--- a/Source/WebKit/WebProcess/Plugins/PluginView.cpp
>+++ b/Source/WebKit/WebProcess/Plugins/PluginView.cpp
>@@ -403,10 +403,7 @@ void PluginView::manualLoadDidReceiveData(const uint8_t* bytes, int length)
> 
>     if (!m_isInitialized) {
>         ASSERT(m_manualStreamState == ManualStreamState::HasReceivedResponse);
>-        if (!m_manualStreamData)
>-            m_manualStreamData = SharedBuffer::create();
>-
>-        m_manualStreamData->append(bytes, length);
>+        m_manualStreamData.append(bytes, length);
>         return;
>     }
> 
>@@ -437,7 +434,7 @@ void PluginView::manualLoadDidFail(const ResourceError& error)
>     if (!m_isInitialized) {
>         m_manualStreamState = ManualStreamState::Finished;
>         m_manualStreamError = error;
>-        m_manualStreamData = nullptr;
>+        m_manualStreamData.reset();
>         return;
>     }
> 
>@@ -926,11 +923,11 @@ void PluginView::willDetachRenderer()
>     m_plugin->willDetachRenderer();
> }
> 
>-RefPtr<SharedBuffer> PluginView::liveResourceData() const
>+RefPtr<FragmentedSharedBuffer> PluginView::liveResourceData() const
> {
>     if (!m_isInitialized || !m_plugin) {
>-        if (m_manualStreamData && m_manualStreamState == ManualStreamState::Finished)
>-            return m_manualStreamData;
>+        if (m_manualStreamState == ManualStreamState::Finished)
>+            return m_manualStreamData.get();
> 
>         return nullptr;
>     }
>@@ -1243,9 +1240,9 @@ void PluginView::redeliverManualStream()
> 
>     // Deliver the data.
>     if (m_manualStreamData) {
>-        for (const auto& element : *m_manualStreamData)
>+        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)
>diff --git a/Source/WebKit/WebProcess/Plugins/PluginView.h b/Source/WebKit/WebProcess/Plugins/PluginView.h
>index 2126eb8edb55..f75ac89bf39a 100644
>--- a/Source/WebKit/WebProcess/Plugins/PluginView.h
>+++ b/Source/WebKit/WebProcess/Plugins/PluginView.h
>@@ -37,6 +37,7 @@
> #include <WebCore/PluginViewBase.h>
> #include <WebCore/ResourceError.h>
> #include <WebCore/ResourceResponse.h>
>+#include <WebCore/SharedBuffer.h>
> #include <WebCore/Timer.h>
> #include <memory>
> #include <wtf/Deque.h>
>@@ -115,7 +116,7 @@ public:
> 
>     bool shouldAllowScripting();
> 
>-    RefPtr<WebCore::SharedBuffer> liveResourceData() const;
>+    RefPtr<WebCore::FragmentedSharedBuffer> liveResourceData() const;
>     bool performDictionaryLookupAtLocation(const WebCore::FloatPoint&);
>     String getSelectionForWordAtPoint(const WebCore::FloatPoint&) const;
>     bool existingSelectionContainsPoint(const WebCore::FloatPoint&) const;
>@@ -252,7 +253,7 @@ private:
> 
>     WebCore::ResourceResponse m_manualStreamResponse;
>     WebCore::ResourceError m_manualStreamError;
>-    RefPtr<WebCore::SharedBuffer> m_manualStreamData;
>+    WebCore::SharedBufferBuilder m_manualStreamData;
> 
>     // This snapshot is used to avoid side effects should the plugin run JS during painting.
>     RefPtr<ShareableBitmap> m_transientPaintingSnapshot;
>diff --git a/Source/WebKit/WebProcess/Storage/WebServiceWorkerFetchTaskClient.cpp b/Source/WebKit/WebProcess/Storage/WebServiceWorkerFetchTaskClient.cpp
>index fee8fea7bcc8..b04cccf113e4 100644
>--- a/Source/WebKit/WebProcess/Storage/WebServiceWorkerFetchTaskClient.cpp
>+++ b/Source/WebKit/WebProcess/Storage/WebServiceWorkerFetchTaskClient.cpp
>@@ -71,16 +71,15 @@ void WebServiceWorkerFetchTaskClient::didReceiveResponse(const ResourceResponse&
>     m_connection->send(Messages::ServiceWorkerFetchTask::DidReceiveResponse { response, m_needsContinueDidReceiveResponseMessage }, m_fetchIdentifier);
> }
> 
>-void WebServiceWorkerFetchTaskClient::didReceiveData(Ref<SharedBuffer>&& buffer)
>+void WebServiceWorkerFetchTaskClient::didReceiveData(Ref<FragmentedSharedBuffer>&& buffer)
> {
>     if (!m_connection)
>         return;
> 
>     if (m_waitingForContinueDidReceiveResponseMessage) {
>-        if (!std::holds_alternative<Ref<SharedBuffer>>(m_responseData))
>-            m_responseData = buffer->copy();
>-        else
>-            std::get<Ref<SharedBuffer>>(m_responseData)->append(WTFMove(buffer));
>+        if (!std::holds_alternative<SharedBufferBuilder>(m_responseData))
>+            m_responseData = SharedBufferBuilder();
>+        std::get<SharedBufferBuilder>(m_responseData).append(WTFMove(buffer));
>         return;
>     }
> 
>@@ -206,8 +205,8 @@ void WebServiceWorkerFetchTaskClient::continueDidReceiveResponse()
>     switchOn(m_responseData, [this](std::nullptr_t&) {
>         if (m_didFinish)
>             didFinish();
>-    }, [this](Ref<SharedBuffer>& buffer) {
>-        didReceiveData(WTFMove(buffer));
>+    }, [this](const SharedBufferBuilder& buffer) {
>+        didReceiveData(*buffer.get());
>         if (m_didFinish)
>             didFinish();
>     }, [this](Ref<FormData>& formData) {
>diff --git a/Source/WebKit/WebProcess/Storage/WebServiceWorkerFetchTaskClient.h b/Source/WebKit/WebProcess/Storage/WebServiceWorkerFetchTaskClient.h
>index b347cad2ab5f..6b0a417cf0d3 100644
>--- a/Source/WebKit/WebProcess/Storage/WebServiceWorkerFetchTaskClient.h
>+++ b/Source/WebKit/WebProcess/Storage/WebServiceWorkerFetchTaskClient.h
>@@ -33,6 +33,7 @@
> #include <WebCore/FetchLoaderClient.h>
> #include <WebCore/ServiceWorkerFetch.h>
> #include <WebCore/ServiceWorkerTypes.h>
>+#include <WebCore/SharedBuffer.h>
> #include <wtf/UniqueRef.h>
> 
> namespace WebKit {
>@@ -49,7 +50,7 @@ private:
> 
>     void didReceiveResponse(const WebCore::ResourceResponse&) final;
>     void didReceiveRedirection(const WebCore::ResourceResponse&) final;
>-    void didReceiveData(Ref<WebCore::SharedBuffer>&&) final;
>+    void didReceiveData(Ref<WebCore::FragmentedSharedBuffer>&&) final;
>     void didReceiveFormDataAndFinish(Ref<WebCore::FormData>&&) final;
>     void didFail(const WebCore::ResourceError&) final;
>     void didFinish() final;
>@@ -82,7 +83,7 @@ private:
>     std::optional<BlobLoader> m_blobLoader;
>     bool m_needsContinueDidReceiveResponseMessage { false };
>     bool m_waitingForContinueDidReceiveResponseMessage { false };
>-    std::variant<std::nullptr_t, Ref<WebCore::SharedBuffer>, Ref<WebCore::FormData>, UniqueRef<WebCore::ResourceError>> m_responseData;
>+    std::variant<std::nullptr_t, WebCore::SharedBufferBuilder, Ref<WebCore::FormData>, UniqueRef<WebCore::ResourceError>> m_responseData;
>     bool m_didFinish { false };
> };
> 
>diff --git a/Source/WebKit/WebProcess/WebCoreSupport/WebEditorClient.cpp b/Source/WebKit/WebProcess/WebCoreSupport/WebEditorClient.cpp
>index 81e379e33d1a..7cfc03a85d39 100644
>--- a/Source/WebKit/WebProcess/WebCoreSupport/WebEditorClient.cpp
>+++ b/Source/WebKit/WebProcess/WebCoreSupport/WebEditorClient.cpp
>@@ -142,7 +142,7 @@ bool WebEditorClient::shouldApplyStyle(const StyleProperties& style, const std::
> 
> #if ENABLE(ATTACHMENT_ELEMENT)
> 
>-void WebEditorClient::registerAttachmentIdentifier(const String& identifier, const String& contentType, const String& preferredFileName, Ref<SharedBuffer>&& data)
>+void WebEditorClient::registerAttachmentIdentifier(const String& identifier, const String& contentType, const String& preferredFileName, Ref<FragmentedSharedBuffer>&& data)
> {
>     m_page->send(Messages::WebPageProxy::RegisterAttachmentIdentifierFromData(identifier, contentType, preferredFileName, data.get()));
> }
>diff --git a/Source/WebKit/WebProcess/WebCoreSupport/WebEditorClient.h b/Source/WebKit/WebProcess/WebCoreSupport/WebEditorClient.h
>index 506d9f54138d..b05861891ecc 100644
>--- a/Source/WebKit/WebProcess/WebCoreSupport/WebEditorClient.h
>+++ b/Source/WebKit/WebProcess/WebCoreSupport/WebEditorClient.h
>@@ -65,7 +65,7 @@ private:
>     bool shouldMoveRangeAfterDelete(const WebCore::SimpleRange&, const WebCore::SimpleRange&) final;
> 
> #if ENABLE(ATTACHMENT_ELEMENT)
>-    void registerAttachmentIdentifier(const String&, const String& contentType, const String& preferredFileName, Ref<WebCore::SharedBuffer>&&) final;
>+    void registerAttachmentIdentifier(const String&, const String& contentType, const String& preferredFileName, Ref<WebCore::FragmentedSharedBuffer>&&) final;
>     void registerAttachmentIdentifier(const String&, const String& contentType, const String& filePath) final;
>     void registerAttachmentIdentifier(const String&) final;
>     void registerAttachments(Vector<WebCore::SerializedAttachmentData>&&) final;
>diff --git a/Source/WebKit/WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp b/Source/WebKit/WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp
>index 4bdbbccd3fbc..14a083ca207a 100644
>--- a/Source/WebKit/WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp
>+++ b/Source/WebKit/WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp
>@@ -1188,8 +1188,8 @@ void WebFrameLoaderClient::finishedLoading(DocumentLoader* loader)
>             if (!webPage)
>                 return;
> 
>-            RefPtr<SharedBuffer> mainResourceData = loader->mainResourceData();
>-            IPC::DataReference dataReference(mainResourceData ? mainResourceData->data() : nullptr, mainResourceData ? mainResourceData->size() : 0);
>+            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));
>         }
> 
>diff --git a/Source/WebKit/WebProcess/WebCoreSupport/WebPlatformStrategies.cpp b/Source/WebKit/WebProcess/WebCoreSupport/WebPlatformStrategies.cpp
>index f41a70ef5bb6..4a8bee57fdb1 100644
>--- a/Source/WebKit/WebProcess/WebCoreSupport/WebPlatformStrategies.cpp
>+++ b/Source/WebKit/WebProcess/WebCoreSupport/WebPlatformStrategies.cpp
>@@ -209,7 +209,7 @@ int64_t WebPlatformStrategies::setTypes(const Vector<String>& pasteboardTypes, c
>     return newChangeCount;
> }
> 
>-int64_t WebPlatformStrategies::setBufferForType(SharedBuffer* buffer, const String& pasteboardType, const String& pasteboardName, const PasteboardContext* context)
>+int64_t WebPlatformStrategies::setBufferForType(FragmentedSharedBuffer* buffer, const String& pasteboardType, const String& pasteboardName, const PasteboardContext* context)
> {
>     SharedMemory::Handle handle;
>     if (buffer && buffer->size()) {
>diff --git a/Source/WebKit/WebProcess/WebCoreSupport/WebPlatformStrategies.h b/Source/WebKit/WebProcess/WebCoreSupport/WebPlatformStrategies.h
>index e2809963f4f5..1ff83e11bc17 100644
>--- a/Source/WebKit/WebProcess/WebCoreSupport/WebPlatformStrategies.h
>+++ b/Source/WebKit/WebProcess/WebCoreSupport/WebPlatformStrategies.h
>@@ -66,7 +66,7 @@ private:
> 
>     int64_t addTypes(const Vector<String>& pasteboardTypes, const String& pasteboardName, const WebCore::PasteboardContext*) override;
>     int64_t setTypes(const Vector<String>& pasteboardTypes, const String& pasteboardName, const WebCore::PasteboardContext*) override;
>-    int64_t setBufferForType(WebCore::SharedBuffer*, const String& pasteboardType, const String& pasteboardName, const WebCore::PasteboardContext*) override;
>+    int64_t setBufferForType(WebCore::FragmentedSharedBuffer*, const String& pasteboardType, const String& pasteboardName, const WebCore::PasteboardContext*) override;
>     int64_t setURL(const WebCore::PasteboardURL&, const String& pasteboardName, const WebCore::PasteboardContext*) override;
>     int64_t setColor(const WebCore::Color&, const String& pasteboardName, const WebCore::PasteboardContext*) override;
>     int64_t setStringForType(const String&, const String& pasteboardType, const String& pasteboardName, const WebCore::PasteboardContext*) override;
>diff --git a/Source/WebKit/WebProcess/WebCoreSupport/ios/WebPreviewLoaderClient.cpp b/Source/WebKit/WebProcess/WebCoreSupport/ios/WebPreviewLoaderClient.cpp
>index 07b167e0eeee..ed93aeb7ea92 100644
>--- a/Source/WebKit/WebProcess/WebCoreSupport/ios/WebPreviewLoaderClient.cpp
>+++ b/Source/WebKit/WebProcess/WebCoreSupport/ios/WebPreviewLoaderClient.cpp
>@@ -32,7 +32,6 @@
> #include "WebPage.h"
> #include "WebPageProxyMessages.h"
> #include "WebProcess.h"
>-#include <WebCore/SharedBuffer.h>
> #include <wtf/Function.h>
> #include <wtf/HashMap.h>
> #include <wtf/NeverDestroyed.h>
>@@ -45,13 +44,12 @@ WebPreviewLoaderClient::WebPreviewLoaderClient(const String& fileName, const Str
>     : m_fileName { fileName }
>     , m_uti { uti }
>     , m_pageID { pageID }
>-    , m_buffer { SharedBuffer::create() }
> {
> }
> 
> WebPreviewLoaderClient::~WebPreviewLoaderClient() = default;
> 
>-void WebPreviewLoaderClient::didReceiveBuffer(const SharedBuffer& buffer)
>+void WebPreviewLoaderClient::didReceiveBuffer(const FragmentedSharedBuffer& buffer)
> {
>     auto webPage = WebProcess::singleton().webPage(m_pageID);
>     if (!webPage)
>@@ -69,13 +67,12 @@ void WebPreviewLoaderClient::didFinishLoading()
>     if (!webPage)
>         return;
> 
>-    webPage->didFinishLoadForQuickLookDocumentInMainFrame(m_buffer.get());
>-    m_buffer->clear();
>+    webPage->didFinishLoadForQuickLookDocumentInMainFrame(m_buffer->take().get());
> }
> 
> void WebPreviewLoaderClient::didFail()
> {
>-    m_buffer->clear();
>+    m_buffer->reset();
> }
> 
> void WebPreviewLoaderClient::didRequestPassword(Function<void(const String&)>&& completionHandler)
>diff --git a/Source/WebKit/WebProcess/WebCoreSupport/ios/WebPreviewLoaderClient.h b/Source/WebKit/WebProcess/WebCoreSupport/ios/WebPreviewLoaderClient.h
>index 0492ceec2f9b..7b82150e901c 100644
>--- a/Source/WebKit/WebProcess/WebCoreSupport/ios/WebPreviewLoaderClient.h
>+++ b/Source/WebKit/WebProcess/WebCoreSupport/ios/WebPreviewLoaderClient.h
>@@ -29,6 +29,8 @@
> 
> #include <WebCore/LegacyPreviewLoaderClient.h>
> #include <WebCore/PageIdentifier.h>
>+#include <WebCore/SharedBuffer.h>
>+#include <wtf/UniqueRef.h>
> #include <wtf/text/WTFString.h>
> 
> namespace WebKit {
>@@ -45,7 +47,7 @@ public:
> 
> private:
>     WebPreviewLoaderClient(const String& fileName, const String& uti, WebCore::PageIdentifier);
>-    void didReceiveBuffer(const WebCore::SharedBuffer&) override;
>+    void didReceiveBuffer(const WebCore::FragmentedSharedBuffer&) override;
>     void didFinishLoading() override;
>     void didFail() override;
>     bool supportsPasswordEntry() const override { return true; }
>@@ -54,7 +56,7 @@ private:
>     const String m_fileName;
>     const String m_uti;
>     const WebCore::PageIdentifier m_pageID;
>-    Ref<WebCore::SharedBuffer> m_buffer;
>+    WebCore::SharedBufferBuilder m_buffer;
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/WebProcess/WebCoreSupport/mac/WebDragClientMac.mm b/Source/WebKit/WebProcess/WebCoreSupport/mac/WebDragClientMac.mm
>index a64c6a8b3c69..e1e0e6112a2d 100644
>--- a/Source/WebKit/WebProcess/WebCoreSupport/mac/WebDragClientMac.mm
>+++ b/Source/WebKit/WebProcess/WebCoreSupport/mac/WebDragClientMac.mm
>@@ -150,7 +150,7 @@ void WebDragClient::declareAndWriteDragImage(const String& pasteboardName, Eleme
> 
>     NSURLResponse *response = image->response().nsURLResponse();
>     
>-    RefPtr<SharedBuffer> imageBuffer = image->image()->data();
>+    auto imageBuffer = image->image()->data();
>     size_t imageSize = imageBuffer->size();
> 
>     auto sharedMemoryBuffer = SharedMemory::copyBuffer(*imageBuffer);
>diff --git a/Source/WebKit/WebProcess/WebPage/WebFrame.cpp b/Source/WebKit/WebProcess/WebPage/WebFrame.cpp
>index 9bd4cd2d0cb1..d88f44cfcde5 100644
>--- a/Source/WebKit/WebProcess/WebPage/WebFrame.cpp
>+++ b/Source/WebKit/WebProcess/WebPage/WebFrame.cpp
>@@ -340,10 +340,10 @@ String WebFrame::source() const
>     DocumentLoader* documentLoader = m_coreFrame->loader().activeDocumentLoader();
>     if (!documentLoader)
>         return String();
>-    RefPtr<SharedBuffer> mainResourceData = documentLoader->mainResourceData();
>+    RefPtr<FragmentedSharedBuffer> mainResourceData = documentLoader->mainResourceData();
>     if (!mainResourceData)
>         return String();
>-    return decoder->encoding().decode(mainResourceData->data(), mainResourceData->size());
>+    return decoder->encoding().decode(mainResourceData->makeContiguous()->data(), mainResourceData->size());
> }
> 
> String WebFrame::contentsAsString() const 
>diff --git a/Source/WebKit/WebProcess/WebPage/WebPage.cpp b/Source/WebKit/WebProcess/WebPage/WebPage.cpp
>index 4ad677a3d06b..f46d19687247 100644
>--- a/Source/WebKit/WebProcess/WebPage/WebPage.cpp
>+++ b/Source/WebKit/WebProcess/WebPage/WebPage.cpp
>@@ -1738,7 +1738,7 @@ NO_RETURN void WebPage::loadRequestWaitingForProcessLaunch(LoadParameters&&, URL
>     RELEASE_ASSERT_NOT_REACHED();
> }
> 
>-void WebPage::loadDataImpl(uint64_t navigationID, ShouldTreatAsContinuingLoad shouldTreatAsContinuingLoad, std::optional<WebsitePoliciesData>&& websitePolicies, Ref<SharedBuffer>&& sharedBuffer, ResourceRequest&& request, ResourceResponse&& response, const URL& unreachableURL, const UserData& userData, std::optional<NavigatingToAppBoundDomain> isNavigatingToAppBoundDomain, SubstituteData::SessionHistoryVisibility sessionHistoryVisibility, ShouldOpenExternalURLsPolicy shouldOpenExternalURLsPolicy)
>+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());
>@@ -1753,7 +1753,7 @@ void WebPage::loadDataImpl(uint64_t navigationID, ShouldTreatAsContinuingLoad sh
> 
>     // 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<SharedBuffer*>(substituteData.content()), substituteData.mimeType(), substituteData.textEncoding(), substituteData.failingURL(), WebProcess::singleton().transformHandlesToObjects(userData.object()).get());
>+    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);
>@@ -3861,7 +3861,7 @@ void WebPage::getSourceForFrame(FrameIdentifier frameID, CompletionHandler<void(
> 
> void WebPage::getMainResourceDataOfFrame(FrameIdentifier frameID, CompletionHandler<void(const std::optional<IPC::SharedBufferDataReference>&)>&& callback)
> {
>-    RefPtr<SharedBuffer> buffer;
>+    RefPtr<FragmentedSharedBuffer> buffer;
>     if (WebFrame* frame = WebProcess::singleton().webFrame(frameID)) {
>         if (PluginView* pluginView = pluginViewForFrame(frame->coreFrame()))
>             buffer = pluginView->liveResourceData();
>@@ -3877,7 +3877,7 @@ void WebPage::getMainResourceDataOfFrame(FrameIdentifier frameID, CompletionHand
>     callback(dataReference);
> }
> 
>-static RefPtr<SharedBuffer> resourceDataForFrame(Frame* frame, const URL& resourceURL)
>+static RefPtr<FragmentedSharedBuffer> resourceDataForFrame(Frame* frame, const URL& resourceURL)
> {
>     DocumentLoader* loader = frame->loader().documentLoader();
>     if (!loader)
>@@ -3892,7 +3892,7 @@ static RefPtr<SharedBuffer> resourceDataForFrame(Frame* frame, const URL& resour
> 
> void WebPage::getResourceDataFromFrame(FrameIdentifier frameID, const String& resourceURLString, CompletionHandler<void(const std::optional<IPC::SharedBufferDataReference>&)>&& callback)
> {
>-    RefPtr<SharedBuffer> buffer;
>+    RefPtr<FragmentedSharedBuffer> buffer;
>     if (auto* frame = WebProcess::singleton().webFrame(frameID)) {
>         URL resourceURL(URL(), resourceURLString);
>         buffer = resourceDataForFrame(frame->coreFrame(), resourceURL);
>@@ -6987,7 +6987,7 @@ void WebPage::didGetLoadDecisionForIcon(bool decision, CallbackID loadIdentifier
>     if (!documentLoader)
>         return completionHandler({ });
> 
>-    documentLoader->didGetLoadDecisionForIcon(decision, loadIdentifier.toInteger(), [completionHandler = WTFMove(completionHandler)] (WebCore::SharedBuffer* iconData) mutable {
>+    documentLoader->didGetLoadDecisionForIcon(decision, loadIdentifier.toInteger(), [completionHandler = WTFMove(completionHandler)] (WebCore::FragmentedSharedBuffer* iconData) mutable {
>         completionHandler({ iconData });
>     });
> }
>diff --git a/Source/WebKit/WebProcess/WebPage/WebPage.h b/Source/WebKit/WebProcess/WebPage/WebPage.h
>index a5c42b32cd89..d996d13cba5c 100644
>--- a/Source/WebKit/WebProcess/WebPage/WebPage.h
>+++ b/Source/WebKit/WebProcess/WebPage/WebPage.h
>@@ -216,7 +216,7 @@ class ResourceRequest;
> class ResourceResponse;
> class SelectionData;
> class SelectionGeometry;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> class SubstituteData;
> class TextCheckingRequest;
> class VisiblePosition;
>@@ -1397,7 +1397,7 @@ public:
> 
> #if USE(QUICK_LOOK)
>     void didStartLoadForQuickLookDocumentInMainFrame(const String& fileName, const String& uti);
>-    void didFinishLoadForQuickLookDocumentInMainFrame(const WebCore::SharedBuffer&);
>+    void didFinishLoadForQuickLookDocumentInMainFrame(const WebCore::FragmentedSharedBuffer&);
>     void requestPasswordForQuickLookDocumentInMainFrame(const String& fileName, CompletionHandler<void(const String&)>&&);
> #endif
> 
>@@ -1596,7 +1596,7 @@ private:
> 
>     String sourceForFrame(WebFrame*);
> 
>-    void loadDataImpl(uint64_t navigationID, WebCore::ShouldTreatAsContinuingLoad, std::optional<WebsitePoliciesData>&&, Ref<WebCore::SharedBuffer>&&, WebCore::ResourceRequest&&, WebCore::ResourceResponse&&, const URL& failingURL, const UserData&, std::optional<NavigatingToAppBoundDomain>, WebCore::SubstituteData::SessionHistoryVisibility, WebCore::ShouldOpenExternalURLsPolicy = WebCore::ShouldOpenExternalURLsPolicy::ShouldNotAllow);
>+    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)>&&);
>diff --git a/Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm b/Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm
>index c95c38463922..85e6518692ed 100644
>--- a/Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm
>+++ b/Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm
>@@ -3217,7 +3217,7 @@ void WebPage::performActionOnElement(uint32_t action)
>         CachedImage* cachedImage = downcast<RenderImage>(*element.renderer()).cachedImage();
>         if (!cachedImage)
>             return;
>-        RefPtr<SharedBuffer> buffer = cachedImage->resourceBuffer();
>+        RefPtr<FragmentedSharedBuffer> buffer = cachedImage->resourceBuffer();
>         if (!buffer)
>             return;
>         auto sharedMemoryBuffer = SharedMemory::copyBuffer(*buffer);
>@@ -4683,7 +4683,7 @@ void WebPage::didStartLoadForQuickLookDocumentInMainFrame(const String& fileName
>     send(Messages::WebPageProxy::DidStartLoadForQuickLookDocumentInMainFrame(fileName, uti));
> }
> 
>-void WebPage::didFinishLoadForQuickLookDocumentInMainFrame(const SharedBuffer& buffer)
>+void WebPage::didFinishLoadForQuickLookDocumentInMainFrame(const FragmentedSharedBuffer& buffer)
> {
>     ASSERT(!buffer.isEmpty());
> 
>diff --git a/Source/WebKit/WebProcess/WebPage/mac/WebPageMac.mm b/Source/WebKit/WebProcess/WebPage/mac/WebPageMac.mm
>index 60f84a45c380..3cb50624bf0d 100644
>--- a/Source/WebKit/WebProcess/WebPage/mac/WebPageMac.mm
>+++ b/Source/WebKit/WebProcess/WebPage/mac/WebPageMac.mm
>@@ -566,7 +566,7 @@ void WebPage::getDataSelectionForPasteboard(const String pasteboardType, Complet
>     if (frame.selection().isNone())
>         return completionHandler({ });
> 
>-    RefPtr<SharedBuffer> buffer = frame.editor().dataSelectionForPasteboard(pasteboardType);
>+    auto buffer = frame.editor().dataSelectionForPasteboard(pasteboardType);
>     if (!buffer)
>         return completionHandler({ });
>     auto sharedMemoryBuffer = SharedMemory::copyBuffer(*buffer);
>diff --git a/Source/WebKit/WebProcess/win/WebProcessWin.cpp b/Source/WebKit/WebProcess/win/WebProcessWin.cpp
>index d3d38cac4121..37f27e952d07 100644
>--- a/Source/WebKit/WebProcess/win/WebProcessWin.cpp
>+++ b/Source/WebKit/WebProcess/win/WebProcessWin.cpp
>@@ -28,7 +28,7 @@
> 
> #include <WebCore/SharedBuffer.h>
> 
>-RefPtr<WebCore::SharedBuffer> loadResourceIntoBuffer(const char* name)
>+RefPtr<WebCore::FragmentedSharedBuffer> loadResourceIntoBuffer(const char* name)
> {
>     return 0;
> }
>diff --git a/Source/WebKitLegacy/ChangeLog b/Source/WebKitLegacy/ChangeLog
>index 6b9dfdc661f2..a4d9386e3700 100644
>--- a/Source/WebKitLegacy/ChangeLog
>+++ b/Source/WebKitLegacy/ChangeLog
>@@ -1,3 +1,17 @@
>+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-12-09  Myles C. Maxfield  <mmaxfield@apple.com> and Don Olmstead  <don.olmstead@sony.com>
> 
>         Move TextCodec files from WebCore/platform/text to WebCore/PAL/text
>diff --git a/Source/WebKitLegacy/WebCoreSupport/PingHandle.h b/Source/WebKitLegacy/WebCoreSupport/PingHandle.h
>index 1f5584fa387d..a25560a10c28 100644
>--- a/Source/WebKitLegacy/WebCoreSupport/PingHandle.h
>+++ b/Source/WebKitLegacy/WebCoreSupport/PingHandle.h
>@@ -73,7 +73,7 @@ private:
>         completionHandler();
>         pingLoadComplete({ }, response);
>     }
>-    void didReceiveBuffer(WebCore::ResourceHandle*, Ref<WebCore::SharedBuffer>&&, int) final { pingLoadComplete(); }
>+    void didReceiveBuffer(WebCore::ResourceHandle*, Ref<WebCore::FragmentedSharedBuffer>&&, int) final { pingLoadComplete(); }
>     void didFinishLoading(WebCore::ResourceHandle*, const WebCore::NetworkLoadMetrics&) final { pingLoadComplete(); }
>     void didFail(WebCore::ResourceHandle*, const WebCore::ResourceError& error) final { pingLoadComplete(error); }
>     bool shouldUseCredentialStorage(WebCore::ResourceHandle*) final { return m_shouldUseCredentialStorage; }
>diff --git a/Source/WebKitLegacy/mac/ChangeLog b/Source/WebKitLegacy/mac/ChangeLog
>index d08449c14929..3c6f575d6fa7 100644
>--- a/Source/WebKitLegacy/mac/ChangeLog
>+++ b/Source/WebKitLegacy/mac/ChangeLog
>@@ -1,3 +1,53 @@
>+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-09  Myles C. Maxfield  <mmaxfield@apple.com> and Don Olmstead  <don.olmstead@sony.com>
> 
>         Move TextCodec files from WebCore/platform/text to WebCore/PAL/text
>diff --git a/Source/WebKitLegacy/mac/DOM/DOMUIKitExtensions.mm b/Source/WebKitLegacy/mac/DOM/DOMUIKitExtensions.mm
>index eb3941f266df..6355b6f90318 100644
>--- a/Source/WebKitLegacy/mac/DOM/DOMUIKitExtensions.mm
>+++ b/Source/WebKitLegacy/mac/DOM/DOMUIKitExtensions.mm
>@@ -388,7 +388,7 @@ - (NSData *)dataRepresentation:(BOOL)rawImageData
>     auto* data = rawImageData ? cachedImage->resourceBuffer() : image->data();
>     if (!data)
>         return nil;
>-    return data->createNSData().autorelease();
>+    return data->makeContiguous()->createNSData().autorelease();
> }
> 
> - (NSString *)mimeType
>diff --git a/Source/WebKitLegacy/mac/WebCoreSupport/WebFrameLoaderClient.h b/Source/WebKitLegacy/mac/WebCoreSupport/WebFrameLoaderClient.h
>index a2598f32fb76..959d748b56be 100644
>--- a/Source/WebKitLegacy/mac/WebCoreSupport/WebFrameLoaderClient.h
>+++ b/Source/WebKitLegacy/mac/WebCoreSupport/WebFrameLoaderClient.h
>@@ -248,7 +248,7 @@ private:
>     void sendH2Ping(const URL&, CompletionHandler<void(Expected<Seconds, WebCore::ResourceError>&&)>&&) final;
> 
>     void getLoadDecisionForIcons(const Vector<std::pair<WebCore::LinkIcon&, uint64_t>>&) final;
>-    void finishedLoadingIcon(WebCore::SharedBuffer*);
>+    void finishedLoadingIcon(WebCore::FragmentedSharedBuffer*);
> 
> #if !PLATFORM(IOS_FAMILY)
>     bool m_loadingIcon { false };
>diff --git a/Source/WebKitLegacy/mac/WebCoreSupport/WebFrameLoaderClient.mm b/Source/WebKitLegacy/mac/WebCoreSupport/WebFrameLoaderClient.mm
>index b849d2aac2a9..aa2cc981474a 100644
>--- a/Source/WebKitLegacy/mac/WebCoreSupport/WebFrameLoaderClient.mm
>+++ b/Source/WebKitLegacy/mac/WebCoreSupport/WebFrameLoaderClient.mm
>@@ -2012,7 +2012,7 @@ RefPtr<WebCore::LegacyPreviewLoaderClient> WebFrameLoaderClient::createPreviewLo
>         RetainPtr<NSString> m_filePath;
>         RetainPtr<NSFileHandle> m_fileHandle;
> 
>-        void didReceiveBuffer(const WebCore::SharedBuffer& buffer) override
>+        void didReceiveBuffer(const WebCore::FragmentedSharedBuffer& buffer) override
>         {
>             auto dataArray = buffer.createNSDataArray();
>             for (NSData *data in dataArray.get())
>@@ -2094,7 +2094,7 @@ void WebFrameLoaderClient::getLoadDecisionForIcons(const Vector<std::pair<WebCor
>         }
> 
>         m_loadingIcon = true;
>-        documentLoader->didGetLoadDecisionForIcon(true, icon->second, [this, weakThis = WeakPtr { *this }] (WebCore::SharedBuffer* buffer) {
>+        documentLoader->didGetLoadDecisionForIcon(true, icon->second, [this, weakThis = WeakPtr { *this }] (WebCore::FragmentedSharedBuffer* buffer) {
>             if (!weakThis)
>                 return;
>             finishedLoadingIcon(buffer);
>@@ -2131,7 +2131,7 @@ static NSImage *webGetNSImage(WebCore::Image* image, NSSize size)
> }
> #endif // !PLATFORM(IOS_FAMILY)
> 
>-void WebFrameLoaderClient::finishedLoadingIcon(WebCore::SharedBuffer* iconData)
>+void WebFrameLoaderClient::finishedLoadingIcon(WebCore::FragmentedSharedBuffer* iconData)
> {
> #if !PLATFORM(IOS_FAMILY)
>     ASSERT(m_loadingIcon);
>diff --git a/Source/WebKitLegacy/mac/WebCoreSupport/WebPlatformStrategies.h b/Source/WebKitLegacy/mac/WebCoreSupport/WebPlatformStrategies.h
>index 24b699706df0..527fa552190b 100644
>--- a/Source/WebKitLegacy/mac/WebCoreSupport/WebPlatformStrategies.h
>+++ b/Source/WebKitLegacy/mac/WebCoreSupport/WebPlatformStrategies.h
>@@ -75,7 +75,7 @@ private:
> 
>     int64_t addTypes(const Vector<String>& pasteboardTypes, const String& pasteboardName, const WebCore::PasteboardContext*) override;
>     int64_t setTypes(const Vector<String>& pasteboardTypes, const String& pasteboardName, const WebCore::PasteboardContext*) override;
>-    int64_t setBufferForType(WebCore::SharedBuffer*, const String& pasteboardType, const String& pasteboardName, const WebCore::PasteboardContext*) override;
>+    int64_t setBufferForType(WebCore::FragmentedSharedBuffer*, const String& pasteboardType, const String& pasteboardName, const WebCore::PasteboardContext*) override;
>     int64_t setURL(const WebCore::PasteboardURL&, const String& pasteboardName, const WebCore::PasteboardContext*) override;
>     int64_t setColor(const WebCore::Color&, const String& pasteboardName, const WebCore::PasteboardContext*) override;
>     int64_t setStringForType(const String&, const String& pasteboardType, const String& pasteboardName, const WebCore::PasteboardContext*) override;
>diff --git a/Source/WebKitLegacy/mac/WebCoreSupport/WebPlatformStrategies.mm b/Source/WebKitLegacy/mac/WebCoreSupport/WebPlatformStrategies.mm
>index fc0776e62d66..3986859f7338 100644
>--- a/Source/WebKitLegacy/mac/WebCoreSupport/WebPlatformStrategies.mm
>+++ b/Source/WebKitLegacy/mac/WebCoreSupport/WebPlatformStrategies.mm
>@@ -154,7 +154,7 @@ int64_t WebPlatformStrategies::setTypes(const Vector<String>& pasteboardTypes, c
>     return PlatformPasteboard(pasteboardName).setTypes(pasteboardTypes);
> }
> 
>-int64_t WebPlatformStrategies::setBufferForType(SharedBuffer* buffer, const String& pasteboardType, const String& pasteboardName, const PasteboardContext*)
>+int64_t WebPlatformStrategies::setBufferForType(FragmentedSharedBuffer* buffer, const String& pasteboardType, const String& pasteboardName, const PasteboardContext*)
> {
>     return PlatformPasteboard(pasteboardName).setBufferForType(buffer, pasteboardType);
> }
>diff --git a/Source/WebKitLegacy/mac/WebView/WebDataSource.mm b/Source/WebKitLegacy/mac/WebView/WebDataSource.mm
>index 289c0029bf91..83e85914345e 100644
>--- a/Source/WebKitLegacy/mac/WebView/WebDataSource.mm
>+++ b/Source/WebKitLegacy/mac/WebView/WebDataSource.mm
>@@ -460,10 +460,10 @@ - (void)dealloc
> 
> - (NSData *)data
> {
>-    RefPtr<WebCore::SharedBuffer> mainResourceData = toPrivate(_private)->loader->mainResourceData();
>+    RefPtr<WebCore::FragmentedSharedBuffer> mainResourceData = toPrivate(_private)->loader->mainResourceData();
>     if (!mainResourceData)
>         return nil;
>-    return mainResourceData->createNSData().autorelease();
>+    return mainResourceData->makeContiguous()->createNSData().autorelease();
> }
> 
> - (id <WebDocumentRepresentation>)representation
>diff --git a/Source/WebKitLegacy/mac/WebView/WebHTMLRepresentation.mm b/Source/WebKitLegacy/mac/WebView/WebHTMLRepresentation.mm
>index 80cd30ef4676..38d7e532d6ea 100644
>--- a/Source/WebKitLegacy/mac/WebView/WebHTMLRepresentation.mm
>+++ b/Source/WebKitLegacy/mac/WebView/WebHTMLRepresentation.mm
>@@ -230,7 +230,7 @@ - (BOOL)canSaveAsWebArchive
> - (NSString *)documentSource
> {
>     if ([self _isDisplayingWebArchive]) {            
>-        SharedBuffer *parsedArchiveData = [_private->dataSource _documentLoader]->parsedArchiveData();
>+        auto *parsedArchiveData = [_private->dataSource _documentLoader]->parsedArchiveData();
>         return adoptNS([[NSString alloc] initWithData:parsedArchiveData ? parsedArchiveData->createNSData().get() : nil encoding:NSUTF8StringEncoding]).autorelease();
>     }
> 
>diff --git a/Source/WebKitLegacy/mac/WebView/WebHTMLView.mm b/Source/WebKitLegacy/mac/WebView/WebHTMLView.mm
>index 838e413381a8..28d875929cca 100644
>--- a/Source/WebKitLegacy/mac/WebView/WebHTMLView.mm
>+++ b/Source/WebKitLegacy/mac/WebView/WebHTMLView.mm
>@@ -3540,8 +3540,8 @@ static RetainPtr<NSMenuItem> createShareMenuItem(const WebCore::HitTestResult& h
>     }
> 
>     if (auto* image = hitTestResult.image()) {
>-        if (RefPtr<WebCore::SharedBuffer> buffer = image->data())
>-            [items addObject:adoptNS([[NSImage alloc] initWithData:[NSData dataWithBytes:buffer->data() length:buffer->size()]]).get()];
>+        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()) {
>diff --git a/Source/WebKitLegacy/mac/WebView/WebResource.mm b/Source/WebKitLegacy/mac/WebView/WebResource.mm
>index b08c1d21cf9f..12d59c0a1768 100644
>--- a/Source/WebKitLegacy/mac/WebView/WebResource.mm
>+++ b/Source/WebKitLegacy/mac/WebView/WebResource.mm
>@@ -163,21 +163,21 @@ - (instancetype)initWithCoder:(NSCoder *)decoder
> - (void)encodeWithCoder:(NSCoder *)encoder
> {
>     auto* resource = _private->coreResource.get();
>-    
>-    NSData *data = nil;
>+
>+    RetainPtr<NSData> data;
>     NSURL *url = nil;
>     NSString *mimeType = nil, *textEncoding = nil, *frameName = nil;
>     NSURLResponse *response = nil;
>-    
>+
>     if (resource) {
>-        data = resource->data().createNSData().get();
>+        data = resource->data().makeContiguous()->createNSData();
>         url = resource->url();
>         mimeType = resource->mimeType();
>         textEncoding = resource->textEncoding();
>         frameName = resource->frameName();
>         response = resource->response().nsURLResponse();
>     }
>-    [encoder encodeObject:data forKey:WebResourceDataKey];
>+    [encoder encodeObject:data.get() forKey:WebResourceDataKey];
>     [encoder encodeObject:url forKey:WebResourceURLKey];
>     [encoder encodeObject:mimeType forKey:WebResourceMIMETypeKey];
>     [encoder encodeObject:textEncoding forKey:WebResourceTextEncodingNameKey];
>@@ -202,7 +202,7 @@ - (NSData *)data
> 
>     if (!_private->coreResource)
>         return nil;
>-    return _private->coreResource->data().createNSData().autorelease();
>+    return _private->coreResource->data().makeContiguous()->createNSData().autorelease();
> }
> 
> - (NSURL *)URL
>@@ -367,8 +367,8 @@ - (NSString *)_stringValue
>     if (!encoding.isValid())
>         encoding = PAL::WindowsLatin1Encoding();
>     
>-    SharedBuffer* coreData = _private->coreResource ? &_private->coreResource->data() : nullptr;
>-    return encoding.decode(reinterpret_cast<const char*>(coreData ? coreData->data() : nullptr), coreData ? coreData->size() : 0);
>+    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
>diff --git a/Source/WebKitLegacy/win/ChangeLog b/Source/WebKitLegacy/win/ChangeLog
>index 5840de116771..8cf31f21e726 100644
>--- a/Source/WebKitLegacy/win/ChangeLog
>+++ b/Source/WebKitLegacy/win/ChangeLog
>@@ -1,3 +1,60 @@
>+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-09  Myles C. Maxfield  <mmaxfield@apple.com> and Don Olmstead  <don.olmstead@sony.com>
> 
>         Move TextCodec files from WebCore/platform/text to WebCore/PAL/text
>diff --git a/Source/WebKitLegacy/win/WebDataSource.cpp b/Source/WebKitLegacy/win/WebDataSource.cpp
>index b4073e108bd5..0897c7c0548d 100644
>--- a/Source/WebKitLegacy/win/WebDataSource.cpp
>+++ b/Source/WebKitLegacy/win/WebDataSource.cpp
>@@ -175,7 +175,7 @@ HRESULT WebDataSource::data(_COM_Outptr_opt_ IStream** stream)
>     if (!m_loader)
>         return E_UNEXPECTED;
> 
>-    return MemoryStream::createInstance(m_loader->mainResourceData()).copyRefTo(stream);
>+    return MemoryStream::createInstance(m_loader->mainResourceData()->makeContiguous()).copyRefTo(stream);
> }
> 
> HRESULT WebDataSource::representation(_COM_Outptr_opt_ IWebDocumentRepresentation** rep)
>diff --git a/Source/WebKitLegacy/win/WebFrame.cpp b/Source/WebKitLegacy/win/WebFrame.cpp
>index 90a5a0a1336e..558e13c7f1fd 100644
>--- a/Source/WebKitLegacy/win/WebFrame.cpp
>+++ b/Source/WebKitLegacy/win/WebFrame.cpp
>@@ -559,7 +559,7 @@ HRESULT WebFrame::loadRequest(_In_opt_ IWebURLRequest* request)
>     return S_OK;
> }
> 
>-void WebFrame::loadData(Ref<WebCore::SharedBuffer>&& data, BSTR mimeType, BSTR textEncodingName, BSTR baseURL, BSTR failingURL)
>+void WebFrame::loadData(Ref<WebCore::FragmentedSharedBuffer>&& data, BSTR mimeType, BSTR textEncodingName, BSTR baseURL, BSTR failingURL)
> {
>     String mimeTypeString(mimeType, SysStringLen(mimeType));
>     if (!mimeType)
>@@ -585,21 +585,21 @@ void WebFrame::loadData(Ref<WebCore::SharedBuffer>&& data, BSTR mimeType, BSTR t
> 
> HRESULT WebFrame::loadData(_In_opt_ IStream* data, _In_ BSTR mimeType, _In_ BSTR textEncodingName, _In_ BSTR url)
> {
>-    auto sharedBuffer = SharedBuffer::create();
>+    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 SharedBuffer
>+            // 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()));
>+                sharedBuffer.append(dataBuffer.data(), static_cast<int>(dataBuffer.size()));
>         }
>     }
> 
>-    loadData(WTFMove(sharedBuffer), mimeType, textEncodingName, url, nullptr);
>+    loadData(sharedBuffer.take(), mimeType, textEncodingName, url, nullptr);
>     return S_OK;
> }
> 
>diff --git a/Source/WebKitLegacy/win/WebFrame.h b/Source/WebKitLegacy/win/WebFrame.h
>index 436054fd9ddb..fa9c381cc573 100644
>--- a/Source/WebKitLegacy/win/WebFrame.h
>+++ b/Source/WebKitLegacy/win/WebFrame.h
>@@ -50,7 +50,7 @@ class HTMLFrameOwnerElement;
> class IntRect;
> class Page;
> class ResourceError;
>-class SharedBuffer;
>+class FragmentedSharedBuffer;
> }
> 
> typedef const struct OpaqueJSContext* JSContextRef;
>@@ -195,7 +195,7 @@ private:
>     ~WebFrame();
> 
>     void loadHTMLString(_In_ BSTR string, _In_ BSTR baseURL, _In_ BSTR unreachableURL);
>-    void loadData(Ref<WebCore::SharedBuffer>&&, BSTR mimeType, BSTR textEncodingName, BSTR baseURL, BSTR failingURL);
>+    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*);
>diff --git a/Source/WebKitLegacy/win/WebKitDLL.cpp b/Source/WebKitLegacy/win/WebKitDLL.cpp
>index 9620198b4b54..274b7d2d6cf2 100644
>--- a/Source/WebKitLegacy/win/WebKitDLL.cpp
>+++ b/Source/WebKitLegacy/win/WebKitDLL.cpp
>@@ -165,8 +165,8 @@ void shutDownWebKit()
> }
> 
> //FIXME: We should consider moving this to a new file for cross-project functionality
>-WEBKIT_API RefPtr<WebCore::SharedBuffer> loadResourceIntoBuffer(const char* name);
>-RefPtr<WebCore::SharedBuffer> loadResourceIntoBuffer(const char* name)
>+WEBKIT_API RefPtr<WebCore::FragmentedSharedBuffer> loadResourceIntoBuffer(const char* name);
>+RefPtr<WebCore::FragmentedSharedBuffer> loadResourceIntoBuffer(const char* name)
> {
>     int idr;
>     // temporary hack to get resource id
>diff --git a/Tools/ChangeLog b/Tools/ChangeLog
>index a8e871b0af1a..eb7ee4c1f12c 100644
>--- a/Tools/ChangeLog
>+++ b/Tools/ChangeLog
>@@ -1,3 +1,52 @@
>+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-09  Myles C. Maxfield  <mmaxfield@apple.com> and Don Olmstead  <don.olmstead@sony.com>
> 
>         Move TextCodec files from WebCore/platform/text to WebCore/PAL/text
>diff --git a/Tools/TestWebKitAPI/Tests/WTF/FileSystem.cpp b/Tools/TestWebKitAPI/Tests/WTF/FileSystem.cpp
>index 8583b29ad990..b847d3a826b3 100644
>--- a/Tools/TestWebKitAPI/Tests/WTF/FileSystem.cpp
>+++ b/Tools/TestWebKitAPI/Tests/WTF/FileSystem.cpp
>@@ -44,7 +44,7 @@ static void createTestFile(const String& path)
>     FileSystem::closeFile(fileHandle);
> };
> 
>-// FIXME: Refactor FileSystemTest and SharedBufferTest as a single class.
>+// FIXME: Refactor FileSystemTest and FragmentedSharedBufferTest as a single class.
> class FileSystemTest : public testing::Test {
> public:
>     void SetUp() override
>diff --git a/Tools/TestWebKitAPI/Tests/WebCore/DisplayListTests.cpp b/Tools/TestWebKitAPI/Tests/WebCore/DisplayListTests.cpp
>index d23f7e1e729e..ea2ae2c7e8b3 100644
>--- a/Tools/TestWebKitAPI/Tests/WebCore/DisplayListTests.cpp
>+++ b/Tools/TestWebKitAPI/Tests/WebCore/DisplayListTests.cpp
>@@ -199,7 +199,7 @@ TEST(DisplayListTests, ItemBufferClient)
>             return { globalBufferIdentifier, globalItemBuffer, globalItemBufferCapacity };
>         }
> 
>-        RefPtr<SharedBuffer> encodeItemOutOfLine(const DisplayListItem& displayListItem) const final
>+        RefPtr<FragmentedSharedBuffer> encodeItemOutOfLine(const DisplayListItem& displayListItem) const final
>         {
>             auto index = m_items.size();
>             m_items.append(std::get<StrokePath>(displayListItem));
>diff --git a/Tools/TestWebKitAPI/Tests/WebCore/SharedBuffer.cpp b/Tools/TestWebKitAPI/Tests/WebCore/SharedBuffer.cpp
>index ddbfc1f2b182..17ce87941ba8 100644
>--- a/Tools/TestWebKitAPI/Tests/WebCore/SharedBuffer.cpp
>+++ b/Tools/TestWebKitAPI/Tests/WebCore/SharedBuffer.cpp
>@@ -1,5 +1,5 @@
> /*
>- * Copyright (C) 2016-2017 Apple Inc. All rights reserved.
>+ * 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.
>  *
>@@ -41,80 +41,75 @@ using namespace WebCore;
> 
> namespace TestWebKitAPI {
> 
>-TEST_F(SharedBufferTest, createWithContentsOfMissingFile)
>+TEST_F(FragmentedSharedBufferTest, createWithContentsOfMissingFile)
> {
>-    RefPtr<SharedBuffer> buffer = SharedBuffer::createWithContentsOfFile(String("not_existing_file"));
>+    auto buffer = SharedBuffer::createWithContentsOfFile(String("not_existing_file"));
>     ASSERT_NULL(buffer);
> }
> 
>-TEST_F(SharedBufferTest, createWithContentsOfExistingFile)
>+TEST_F(FragmentedSharedBufferTest, createWithContentsOfExistingFile)
> {
>-    RefPtr<SharedBuffer> buffer = SharedBuffer::createWithContentsOfFile(tempFilePath());
>+    auto buffer = SharedBuffer::createWithContentsOfFile(tempFilePath());
>     ASSERT_NOT_NULL(buffer);
>-    EXPECT_TRUE(buffer->size() == strlen(SharedBufferTest::testData()));
>-    EXPECT_TRUE(String(SharedBufferTest::testData()) == String(buffer->data(), buffer->size()));
>+    EXPECT_TRUE(buffer->size() == strlen(FragmentedSharedBufferTest::testData()));
>+    EXPECT_TRUE(String(FragmentedSharedBufferTest::testData()) == String(buffer->makeContiguous()->data(), buffer->size()));
> }
> 
>-TEST_F(SharedBufferTest, createWithContentsOfExistingEmptyFile)
>+TEST_F(FragmentedSharedBufferTest, createWithContentsOfExistingEmptyFile)
> {
>-    RefPtr<SharedBuffer> buffer = SharedBuffer::createWithContentsOfFile(tempEmptyFilePath());
>+    auto buffer = SharedBuffer::createWithContentsOfFile(tempEmptyFilePath());
>     ASSERT_NOT_NULL(buffer);
>+    EXPECT_TRUE(buffer->isContiguous());
>     EXPECT_TRUE(buffer->isEmpty());
> }
> 
>-TEST_F(SharedBufferTest, copyBufferCreatedWithContentsOfExistingFile)
>+TEST_F(FragmentedSharedBufferTest, copyBufferCreatedWithContentsOfExistingFile)
> {
>-    RefPtr<SharedBuffer> buffer = SharedBuffer::createWithContentsOfFile(tempFilePath());
>+    auto buffer = SharedBuffer::createWithContentsOfFile(tempFilePath());
>     ASSERT_NOT_NULL(buffer);
>-    RefPtr<SharedBuffer> copy = buffer->copy();
>+    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->data(), buffer->size()));
>+    EXPECT_TRUE(!memcmp(buffer->data(), copy->makeContiguous()->data(), buffer->size()));
> }
> 
>-TEST_F(SharedBufferTest, clearBufferCreatedWithContentsOfExistingFile)
>+TEST_F(FragmentedSharedBufferTest, appendBufferCreatedWithContentsOfExistingFile)
> {
>-    RefPtr<SharedBuffer> buffer = SharedBuffer::createWithContentsOfFile(tempFilePath());
>+    RefPtr<FragmentedSharedBuffer> buffer = SharedBuffer::createWithContentsOfFile(tempFilePath());
>     ASSERT_NOT_NULL(buffer);
>-    buffer->clear();
>-    EXPECT_TRUE(!buffer->size());
>-    EXPECT_TRUE(!buffer->data());
>+    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(SharedBufferTest, appendBufferCreatedWithContentsOfExistingFile)
>-{
>-    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)
>+TEST_F(FragmentedSharedBufferTest, tryCreateArrayBuffer)
> {
>     char testData0[] = "Hello";
>     char testData1[] = "World";
>     char testData2[] = "Goodbye";
>-    RefPtr<SharedBuffer> sharedBuffer = SharedBuffer::create(testData0, strlen(testData0));
>-    sharedBuffer->append(testData1, strlen(testData1));
>-    sharedBuffer->append(testData2, strlen(testData2));
>-    RefPtr<ArrayBuffer> arrayBuffer = sharedBuffer->tryCreateArrayBuffer();
>+    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(SharedBufferTest, tryCreateArrayBufferLargeSegments)
>+TEST_F(FragmentedSharedBufferTest, tryCreateArrayBufferLargeSegments)
> {
>     Vector<uint8_t> vector0(0x4000, 'a');
>     Vector<uint8_t> vector1(0x4000, 'b');
>     Vector<uint8_t> vector2(0x4000, 'c');
> 
>-    RefPtr<SharedBuffer> sharedBuffer = SharedBuffer::create(WTFMove(vector0));
>-    sharedBuffer->append(WTFMove(vector1));
>-    sharedBuffer->append(WTFMove(vector2));
>-    RefPtr<ArrayBuffer> arrayBuffer = sharedBuffer->tryCreateArrayBuffer();
>+    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) {
>@@ -131,7 +126,7 @@ TEST_F(SharedBufferTest, tryCreateArrayBufferLargeSegments)
>     }
> }
> 
>-TEST_F(SharedBufferTest, copy)
>+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,"
>@@ -151,17 +146,53 @@ TEST_F(SharedBufferTest, copy)
>     "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);
>-    RefPtr<SharedBuffer> sharedBuffer = SharedBuffer::create(testData, length);
>-    sharedBuffer->append(testData, length);
>-    sharedBuffer->append(testData, length);
>-    sharedBuffer->append(testData, length);
>+    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().
>-    ASSERT_EQ(length * 4, sharedBuffer->size());
>-    RefPtr<SharedBuffer> clone = sharedBuffer->copy();
>-    ASSERT_EQ(length * 4, clone->size());
>-    ASSERT_EQ(0, memcmp(clone->data(), sharedBuffer->data(), clone->size()));
>-    clone->append(testData, length);
>-    ASSERT_EQ(length * 5, clone->size());
>+    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)
>@@ -173,70 +204,80 @@ static void checkBuffer(const uint8_t* buffer, size_t bufferLength, const char*
>         EXPECT_EQ(buffer[i], expected[i]);
> }
> 
>-TEST_F(SharedBufferTest, getSomeData)
>+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'};
>-    
>-    auto buffer = SharedBuffer::create();
>-    buffer->append(WTFMove(s1));
>-    buffer->append(WTFMove(s2));
>-    buffer->append(WTFMove(s3));
>+    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 gh = buffer->getSomeData(6);
>+    auto gh1 = buffer->getSomeData(6);
>     auto h = buffer->getSomeData(7);
>     auto ijkl = buffer->getSomeData(8);
>     auto kl = buffer->getSomeData(10);
>-    auto abcdefghijkl = buffer->data();
>-    auto ghijkl = buffer->getSomeData(6);
>+    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(gh.data(), gh.size(), "gh");
>+    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(SharedBufferTest, isEqualTo)
>+TEST_F(FragmentedSharedBufferTest, isEqualTo)
> {
>     auto makeBuffer = [] (Vector<Vector<uint8_t>>&& contents) {
>-        auto buffer = SharedBuffer::create();
>+        SharedBufferBuilder builder;
>         for (auto& content : contents)
>-            buffer->append(WTFMove(content));
>-        return buffer;
>+            builder.append(WTFMove(content));
>+        return builder.take();
>     };
>-    auto buffer1 = makeBuffer({{'a', 'b', 'c', 'd'}});
>+    auto buffer1 = makeBuffer({ { 'a', 'b', 'c', 'd' } });
>     EXPECT_EQ(buffer1.get(), buffer1.get());
> 
>-    buffer1->append(Vector<uint8_t>({'a', 'b', 'c', 'd'}));
>-    EXPECT_EQ(buffer1.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());
>+    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(SharedBufferTest, toHexString)
>+TEST_F(FragmentedSharedBufferTest, toHexString)
> {
>     Vector<uint8_t> t1 = {0x11, 0x5, 0x12};
>-    auto buffer = SharedBuffer::create();
>-    buffer->append(WTFMove(t1));
>+    SharedBufferBuilder builder;
>+    builder.append(WTFMove(t1));
>+    auto buffer = builder.take();
>     String result = buffer->toHexString();
>     EXPECT_EQ(result, "110512");
>-    buffer->clear();
>+    builder.reset();
>+    buffer = builder.take();
>     EXPECT_EQ(buffer->toHexString(), "");
> }
> 
>-TEST_F(SharedBufferTest, read)
>+TEST_F(FragmentedSharedBufferTest, read)
> {
>     const char* const simpleText = "This is a simple test.";
> 
>-    auto check = [](SharedBuffer& sharedBuffer) {
>+    auto check = [](FragmentedSharedBuffer& sharedBuffer) {
>         Vector<uint8_t> data = sharedBuffer.read(4, 3);
>         EXPECT_EQ(data.size(), 3u);
>         EXPECT_EQ(String(data.data(), 3), " is");
>@@ -249,16 +290,17 @@ TEST_F(SharedBufferTest, read)
>     auto sharedBuffer = SharedBuffer::create(simpleText, strlen(simpleText));
>     check(sharedBuffer);
> 
>-    sharedBuffer = SharedBuffer::create();
>+    SharedBufferBuilder builder;
>     for (size_t i = 0; i < strlen(simpleText); i++)
>-        sharedBuffer->append(&simpleText[i], 1);
>-    check(sharedBuffer);
>+        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)
>-        sharedBuffer->append(&simpleText[i], 2);
>-    EXPECT_EQ(sharedBuffer->size(), strlen(simpleText));
>-    check(sharedBuffer);
>+        builder.append(&simpleText[i], 2);
>+    EXPECT_EQ(builder.size(), strlen(simpleText));
>+    check(builder.take());
> }
> 
> #if ENABLE(MHTML)
>@@ -266,7 +308,7 @@ TEST_F(SharedBufferTest, read)
> template< typename T, size_t N >
> constexpr size_t arraysize( const T (&)[N] ) { return N; }
> 
>-static void readAllChunks(std::vector<String>* chunks, SharedBuffer& buffer, const String& separator = "\r\n", bool includeSeparator = false)
>+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);
>@@ -299,7 +341,7 @@ static void checkDataInRange(const Vector<uint8_t>& data, size_t start, size_t l
> 
> TEST_F(SharedBufferChunkReaderTest, includeSeparator)
> {
>-    auto check = [](SharedBuffer& sharedBuffer) {
>+    auto check = [](FragmentedSharedBuffer& sharedBuffer) {
>         SharedBufferChunkReader chunkReader(&sharedBuffer, "\x10\x11\x12");
>         Vector<uint8_t> out;
>         EXPECT_TRUE(chunkReader.nextChunk(out));
>@@ -313,22 +355,24 @@ TEST_F(SharedBufferChunkReaderTest, includeSeparator)
>     uint8_t data[256];
>     for (size_t i = 0; i < 256; ++i)
>         data[i] = i;
>-
>     auto sharedBuffer = SharedBuffer::create(data, 256);
>     check(sharedBuffer);
>-    sharedBuffer = SharedBuffer::create();
>+
>+    SharedBufferBuilder builder(data, 256);
>+    check(builder.take());
>+
>     for (size_t i = 0; i < 256; ++i) {
>         char c = i;
>-        sharedBuffer->append(&c, 1);
>+        builder.append(&c, 1);
>     }
>-    check(sharedBuffer);
>+    check(builder.take());
> }
> 
> TEST_F(SharedBufferChunkReaderTest, peekData)
> {
>     const char* const simpleText = "This is a simple test.";
> 
>-    auto check = [](SharedBuffer& sharedBuffer) {
>+    auto check = [](FragmentedSharedBuffer& sharedBuffer) {
>         SharedBufferChunkReader chunkReader(&sharedBuffer, "is");
> 
>         String chunk = chunkReader.nextChunkAsUTF8StringWithLatin1Fallback();
>@@ -358,22 +402,23 @@ TEST_F(SharedBufferChunkReaderTest, peekData)
>     auto sharedBuffer = SharedBuffer::create(simpleText, strlen(simpleText));
>     check(sharedBuffer);
> 
>-    sharedBuffer = SharedBuffer::create();
>+    SharedBufferBuilder builder(simpleText, strlen(simpleText));
>+    check(builder.take());
>+
>     for (size_t i = 0; i < strlen(simpleText); i++)
>-        sharedBuffer->append(&simpleText[i], 1);
>-    check(sharedBuffer);
>+        builder.append(&simpleText[i], 1);
>+    check(builder.take());
> 
>-    sharedBuffer = SharedBuffer::create();
>     for (size_t i = 0; i < strlen(simpleText); i += 2)
>-        sharedBuffer->append(&simpleText[i], 2);
>-    EXPECT_EQ(sharedBuffer->size(), strlen(simpleText));
>-    check(sharedBuffer);
>+        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 = [](SharedBuffer& sharedBuffer) {
>+    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");
>@@ -406,17 +451,19 @@ TEST_F(SharedBufferChunkReaderTest, readAllChunksInMultiSegment)
>     };
>     auto sharedBuffer = SharedBuffer::create(simpleText, strlen(simpleText));
>     check(sharedBuffer);
>-    sharedBuffer = SharedBuffer::create();
>+
>+    SharedBufferBuilder builder(simpleText, strlen(simpleText));
>+    check(builder.take());
>+
>     for (size_t i = 0; i < strlen(simpleText); i++)
>-        sharedBuffer->append(&simpleText[i], 1);
>-    EXPECT_EQ(sharedBuffer->size(), strlen(simpleText));
>-    check(sharedBuffer);
>+        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)
>-        sharedBuffer->append(&simpleText[i], 5);
>-    EXPECT_EQ(sharedBuffer->size(), strlen(simpleText));
>-    check(sharedBuffer);
>+        builder.append(&simpleText[i], 5);
>+    EXPECT_EQ(builder.size(), strlen(simpleText));
>+    check(builder.take());
> }
> 
> TEST_F(SharedBufferChunkReaderTest, changingIterator)
>diff --git a/Tools/TestWebKitAPI/Tests/WebCore/SharedBufferTest.cpp b/Tools/TestWebKitAPI/Tests/WebCore/SharedBufferTest.cpp
>index 9b8b13a75d52..d0341a81deda 100644
>--- a/Tools/TestWebKitAPI/Tests/WebCore/SharedBufferTest.cpp
>+++ b/Tools/TestWebKitAPI/Tests/WebCore/SharedBufferTest.cpp
>@@ -31,7 +31,7 @@
> 
> namespace TestWebKitAPI {
> 
>-void SharedBufferTest::SetUp()
>+void FragmentedSharedBufferTest::SetUp()
> {
>     WTF::initializeMainThread();
> 
>@@ -45,7 +45,7 @@ void SharedBufferTest::SetUp()
>     FileSystem::closeFile(handle);
> }
> 
>-void SharedBufferTest::TearDown()
>+void FragmentedSharedBufferTest::TearDown()
> {
>     FileSystem::deleteFile(m_tempFilePath);
>     FileSystem::deleteFile(m_tempEmptyFilePath);
>diff --git a/Tools/TestWebKitAPI/Tests/WebCore/SharedBufferTest.h b/Tools/TestWebKitAPI/Tests/WebCore/SharedBufferTest.h
>index 640119bde6fc..a392a0519475 100644
>--- a/Tools/TestWebKitAPI/Tests/WebCore/SharedBufferTest.h
>+++ b/Tools/TestWebKitAPI/Tests/WebCore/SharedBufferTest.h
>@@ -29,7 +29,7 @@
> 
> namespace TestWebKitAPI {
> 
>-class SharedBufferTest : public testing::Test {
>+class FragmentedSharedBufferTest : public testing::Test {
> public:
>     void SetUp() override;
>     void TearDown() override;
>diff --git a/Tools/TestWebKitAPI/Tests/WebCore/cg/DisplayListTestsCG.cpp b/Tools/TestWebKitAPI/Tests/WebCore/cg/DisplayListTestsCG.cpp
>index 7a3207f95c62..85828f039224 100644
>--- a/Tools/TestWebKitAPI/Tests/WebCore/cg/DisplayListTestsCG.cpp
>+++ b/Tools/TestWebKitAPI/Tests/WebCore/cg/DisplayListTestsCG.cpp
>@@ -104,7 +104,7 @@ private:
>         return { globalBufferIdentifier, globalItemBuffer, globalItemBufferCapacity };
>     }
> 
>-    RefPtr<SharedBuffer> encodeItemOutOfLine(const DisplayListItem&) const final
>+    RefPtr<FragmentedSharedBuffer> encodeItemOutOfLine(const DisplayListItem&) const final
>     {
>         return SharedBuffer::create();
>     }
>diff --git a/Tools/TestWebKitAPI/Tests/WebCore/cocoa/SharedBuffer.mm b/Tools/TestWebKitAPI/Tests/WebCore/cocoa/SharedBuffer.mm
>index 93331d702c53..c3b5d3e8d7c0 100644
>--- a/Tools/TestWebKitAPI/Tests/WebCore/cocoa/SharedBuffer.mm
>+++ b/Tools/TestWebKitAPI/Tests/WebCore/cocoa/SharedBuffer.mm
>@@ -1,5 +1,5 @@
> /*
>- * Copyright (C) 2017-2019 Apple Inc. All rights reserved.
>+ * 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
>@@ -45,19 +45,20 @@ static void expectDataArraysEqual(NSArray<NSData *> *expected, NSArray<NSData *>
>     }
> }
> 
>-TEST_F(SharedBufferTest, createNSDataArray)
>+TEST_F(FragmentedSharedBufferTest, createNSDataArray)
> {
>     @autoreleasepool {
>-        auto buffer = SharedBuffer::create();
>-        expectDataArraysEqual(nil, buffer->createNSDataArray().get());
>+        SharedBufferBuilder builder;
>+        builder.empty();
>+        expectDataArraysEqual(nil, builder.get()->createNSDataArray().get());
> 
>         NSData *helloData = [NSData dataWithBytes:"hello" length:5];
>-        buffer->append((const char*)helloData.bytes, helloData.length);
>-        expectDataArraysEqual(@[ helloData ], buffer->createNSDataArray().get());
>+        builder.append((const char*)helloData.bytes, helloData.length);
>+        expectDataArraysEqual(@[ helloData ], builder.get()->createNSDataArray().get());
> 
>         NSData *worldData = [NSData dataWithBytes:"world" length:5];
>-        buffer->append((__bridge CFDataRef)worldData);
>-        expectDataArraysEqual(@[ helloData, worldData ], buffer->createNSDataArray().get());
>+        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());
>@@ -66,35 +67,35 @@ TEST_F(SharedBufferTest, createNSDataArray)
>     }
> }
> 
>-TEST_F(SharedBufferTest, createNSDataForDataSegment)
>+TEST_F(FragmentedSharedBufferTest, createNSDataForDataSegment)
> {
>     @autoreleasepool {
>-        auto buffer = SharedBuffer::create();
>+        SharedBufferBuilder builder;
> 
>         NSData *helloData = [NSData dataWithBytes:"hello" length:5];
>-        buffer->append((const char*)helloData.bytes, helloData.length);
>+        builder.append((const char*)helloData.bytes, helloData.length);
> 
>         NSData *worldData = [NSData dataWithBytes:"world" length:5];
>-        buffer->append((__bridge CFDataRef)worldData);
>+        builder.append((__bridge CFDataRef)worldData);
> 
>         NSArray *expectedData = @[ helloData, worldData ];
>         NSUInteger expectedSize = helloData.length + worldData.length;
> 
>         NSUInteger segmentCount = 0;
>-        for (auto& segment : buffer.get())
>+        for (auto& segment : *builder.get())
>             EXPECT_TRUE([segment.segment->createNSData() isEqualToData:expectedData[segmentCount++]]);
>         EXPECT_EQ(expectedData.count, segmentCount);
> 
>         NSUInteger position = 0;
>         segmentCount = 0;
>-        while (buffer->size() > position) {
>-            auto incrementalData = buffer->getSomeData(position);
>+        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 = buffer->getSomeData(expectedSize - 1);
>+        auto lastByte = builder.get()->getSomeData(expectedSize - 1);
>         EXPECT_TRUE([lastByte.createNSData() isEqualToData:[@"d" dataUsingEncoding:NSASCIIStringEncoding]]);
>         EXPECT_EQ(1LU, lastByte.size());
>     }
>diff --git a/Tools/TestWebKitAPI/win/TestWebCoreStubs.cpp b/Tools/TestWebKitAPI/win/TestWebCoreStubs.cpp
>index 46c76203e1b2..5be665946137 100644
>--- a/Tools/TestWebKitAPI/win/TestWebCoreStubs.cpp
>+++ b/Tools/TestWebKitAPI/win/TestWebCoreStubs.cpp
>@@ -25,7 +25,7 @@
> 
> #include <WebCore/SharedBuffer.h>
> 
>-RefPtr<WebCore::SharedBuffer> loadResourceIntoBuffer(const char*)
>+RefPtr<WebCore::FragmentedSharedBuffer> loadResourceIntoBuffer(const char*)
> {
>     return nullptr;
> }

Actions: View | Formatted Diff | Diff

Attachments on bug 233923: 446155 | 446156 | 446266 | 446267 | 446537 | 446538 | 447121