⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 287684 in webkit


Ignore:
Timestamp:
Jan 6, 2022, 7:31:46 AM (5 years ago)
Author:
Jean-Yves Avenard
Message:

Have CachedRawResourceClient and related networking actors use SharedBuffer.
​https://bugs.webkit.org/show_bug.cgi?id=232424
rdar://84744687

Reviewed by Youenn Fablet.

Source/WebCore:

We modify all didReceiveData and related methods so that they no longer
use uint8_t*/int and instead use SharedBuffer.
We do the same for any intermediaries used by the various didReceiveData
implementations.
This will facilitate moving networking off the main thread in the GPU
process and allows to remove several memory allocations and copies at the
process boundaries.
We can now consider transfer the underlying SharedMemory created in
the network process all the way to the GPU process.

Fly-by fix: change FragmentedSharedBuffer type to SharedBuffer when appropriate.

No change in observable behaviour. Covered by all existing tests.

  • Modules/fetch/FetchBodyConsumer.cpp:

(WebCore::FetchBodyConsumer::append):

  • Modules/fetch/FetchBodyConsumer.h:
  • Modules/fetch/FetchBodyOwner.cpp:

(WebCore::FetchBodyOwner::blobChunk):

  • Modules/fetch/FetchBodyOwner.h:
  • Modules/fetch/FetchLoader.cpp:

(WebCore::FetchLoader::didReceiveData):

  • Modules/fetch/FetchLoader.h:
  • Modules/fetch/FetchLoaderClient.h:

(WebCore::FetchLoaderClient::didReceiveData):

  • Modules/fetch/FetchResponse.cpp:

(WebCore::FetchResponse::BodyLoader::didReceiveData):
(WebCore::FetchResponse::consumeChunk):

  • Modules/fetch/FetchResponse.h:
  • Modules/model-element/HTMLModelElement.cpp:

(WebCore::HTMLModelElement::dataReceived):

  • Modules/model-element/HTMLModelElement.h:
  • Modules/streams/ReadableStreamSink.h:
  • fileapi/FileReaderLoader.cpp:

(WebCore::FileReaderLoader::didReceiveData):

  • fileapi/FileReaderLoader.h:
  • inspector/InspectorInstrumentation.cpp:

(WebCore::InspectorInstrumentation::didReceiveDataImpl):

  • inspector/InspectorInstrumentation.h:

(WebCore::InspectorInstrumentation::didReceiveData):

  • inspector/NetworkResourcesData.cpp:

(WebCore::NetworkResourcesData::ResourceData::appendData):
(WebCore::NetworkResourcesData::maybeAddResourceData):

  • inspector/NetworkResourcesData.h:
  • inspector/agents/InspectorNetworkAgent.cpp:

(WebCore::InspectorNetworkAgent::didReceiveResponse):
(WebCore::InspectorNetworkAgent::didReceiveData):
(WebCore::InspectorNetworkAgent::interceptRequestWithResponse):

  • inspector/agents/InspectorNetworkAgent.h:
  • loader/ContentFilter.cpp:

(WebCore::ContentFilter::deliverResourceData):

  • loader/ContentFilterClient.h:
  • loader/DocumentLoader.cpp:

(WebCore::DocumentLoader::finishedLoading):
(WebCore::DocumentLoader::continueAfterContentPolicy):
(WebCore::DocumentLoader::commitLoad):
(WebCore::DocumentLoader::commitData):
(WebCore::DocumentLoader::dataReceived):
(WebCore::DocumentLoader::maybeCreateArchive):
(WebCore::DocumentLoader::maybeFinishLoadingMultipartContent):
(WebCore::DocumentLoader::dataReceivedThroughContentFilter):

  • loader/DocumentLoader.h:
  • loader/DocumentThreadableLoader.cpp:

(WebCore::DocumentThreadableLoader::dataReceived):
(WebCore::DocumentThreadableLoader::didReceiveData):
(WebCore::DocumentThreadableLoader::didFinishLoading):
(WebCore::DocumentThreadableLoader::loadRequest):

  • loader/DocumentThreadableLoader.h:
  • loader/DocumentWriter.cpp:

(WebCore::DocumentWriter::addData):

  • loader/DocumentWriter.h:
  • loader/EmptyClients.cpp:

(WebCore::EmptyFrameLoaderClient::committedLoad):

  • loader/EmptyFrameLoaderClient.h:
  • loader/FrameLoader.cpp:

(WebCore::FrameLoader::willLoadMediaElementURL):
(WebCore::FrameLoader::commitProvisionalLoad):
(WebCore::FrameLoader::loadResourceSynchronously):
(WebCore::FrameLoader::loadedResourceFromMemoryCache):

  • loader/FrameLoaderClient.h:
  • loader/MediaResourceLoader.cpp:

(WebCore::MediaResource::dataReceived):

  • loader/MediaResourceLoader.h:
  • loader/NetscapePlugInStreamLoader.cpp:

(WebCore::NetscapePlugInStreamLoader::didReceiveData):

  • loader/NetscapePlugInStreamLoader.h:
  • loader/ResourceLoadNotifier.cpp:

(WebCore::ResourceLoadNotifier::didReceiveData):
(WebCore::ResourceLoadNotifier::dispatchDidReceiveData):
(WebCore::ResourceLoadNotifier::sendRemainingDelegateMessages):

  • loader/ResourceLoadNotifier.h:
  • loader/ResourceLoader.cpp:

(WebCore::ResourceLoader::loadDataURL):
(WebCore::ResourceLoader::addBuffer):
(WebCore::ResourceLoader::didReceiveData):
(WebCore::ResourceLoader::didReceiveBuffer):

  • loader/ResourceLoader.h:
  • loader/SubresourceLoader.cpp:

(WebCore::SubresourceLoader::didReceiveBuffer):

  • loader/SubresourceLoader.h:
  • loader/SubstituteResource.h:

(WebCore::SubstituteResource::append):

  • loader/ThreadableLoaderClient.h:

(WebCore::ThreadableLoaderClient::didReceiveData):

  • loader/ThreadableLoaderClientWrapper.h:

(WebCore::ThreadableLoaderClientWrapper::didReceiveData):

  • loader/WorkerThreadableLoader.cpp:

(WebCore::WorkerThreadableLoader::MainThreadBridge::didReceiveData):

  • loader/WorkerThreadableLoader.h:
  • loader/appcache/ApplicationCacheHost.cpp:

(WebCore::ApplicationCacheHost::mainResourceDataReceived):

  • loader/appcache/ApplicationCacheHost.h:
  • loader/appcache/ApplicationCacheResource.cpp:

(WebCore::ApplicationCacheResource::deliver):

  • loader/appcache/ApplicationCacheResourceLoader.cpp:

(WebCore::ApplicationCacheResourceLoader::dataReceived):

  • loader/appcache/ApplicationCacheResourceLoader.h:
  • loader/cache/CachedImage.cpp:

(WebCore::CachedImage::updateBufferInternal):
(WebCore::CachedImage::updateBuffer):
(WebCore::CachedImage::updateData):

  • loader/cache/CachedImage.h:
  • loader/cache/CachedRawResource.cpp:

(WebCore::CachedRawResource::calculateIncrementalDataChunk const):
(WebCore::CachedRawResource::updateBuffer):
(WebCore::CachedRawResource::updateData):
(WebCore::CachedRawResource::finishLoading):
(WebCore::CachedRawResource::notifyClientsDataWasReceived):
(WebCore::CachedRawResource::didAddClient):

  • loader/cache/CachedRawResource.h:
  • loader/cache/CachedRawResourceClient.h:

(WebCore::CachedRawResourceClient::dataReceived):

  • loader/cache/CachedResource.cpp:

(WebCore::CachedResource::updateData):

  • loader/cache/CachedResource.h:
  • loader/ios/LegacyPreviewLoader.h:
  • loader/ios/LegacyPreviewLoader.mm:

(WebCore::LegacyPreviewLoader::didReceiveData):
(WebCore::LegacyPreviewLoader::previewConverterDidReceiveData):

  • page/EventSource.cpp:

(WebCore::EventSource::didReceiveData):

  • page/EventSource.h:
  • platform/SharedBuffer.cpp:

(WebCore::FragmentedSharedBuffer::takeData): Update due to DataSegmentVectorEntry::segment being const
(WebCore::FragmentedSharedBuffer::forEachSegmentAsSharedBuffer const): Add convenience method.
(WebCore::SharedBuffer::SharedBuffer):
(WebCore::SharedBufferDataView::SharedBufferDataView):
(WebCore::SharedBufferDataView::createSharedBuffer const):

  • platform/SharedBuffer.h: Make DataSegmentVectorEntry::segment const.

(WebCore::SharedBuffer::create):
(WebCore::SharedBuffer::SharedBuffer):

  • platform/graphics/PlatformMediaResourceLoader.h:

(WebCore::PlatformMediaResourceClient::dataReceived):

  • platform/graphics/avfoundation/cf/WebCoreAVCFResourceLoader.cpp:

(WebCore::WebCoreAVCFResourceLoader::dataReceived):

  • platform/graphics/avfoundation/cf/WebCoreAVCFResourceLoader.h:
  • platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm:

(WebCore::CachedResourceMediaLoader::dataReceived):
(WebCore::PlatformResourceMediaLoader::dataReceived):

  • platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:

(CachedResourceStreamingClient::dataReceived):

  • platform/network/ResourceHandleClient.cpp:

(WebCore::ResourceHandleClient::didReceiveBuffer):

  • platform/network/ResourceHandleClient.h:

(WebCore::ResourceHandleClient::didReceiveData):

  • platform/network/SynchronousLoaderClient.cpp:

(WebCore::SynchronousLoaderClient::didReceiveData):

  • platform/network/SynchronousLoaderClient.h:
  • platform/network/cocoa/RangeResponseGenerator.mm:

(WebCore::RangeResponseGenerator::giveResponseToTaskIfBytesInRangeReceived):

  • platform/network/cocoa/WebCoreNSURLSession.h:
  • platform/network/cocoa/WebCoreNSURLSession.mm:

(WebCore::WebCoreNSURLSessionDataTaskClient::dataReceived):
(-[WebCoreNSURLSessionDataTask resource:receivedData:]):

  • platform/network/curl/CurlCacheManager.cpp:

(WebCore::CurlCacheManager::didReceiveData):

  • platform/network/curl/CurlCacheManager.h:
  • platform/network/curl/CurlDownload.cpp:

(WebCore::CurlDownload::curlDidReceiveData):

  • platform/network/curl/CurlDownload.h:
  • platform/network/curl/CurlMultipartHandle.cpp:

(WebCore::CurlMultipartHandle::didReceiveData):

  • platform/network/curl/CurlMultipartHandle.h:
  • platform/network/curl/CurlMultipartHandleClient.h:
  • platform/network/curl/CurlRequest.cpp:

(WebCore::CurlRequest::didReceiveData):
(WebCore::CurlRequest::didReceiveDataFromMultipart):

  • platform/network/curl/CurlRequest.h:
  • platform/network/curl/CurlRequestClient.h:
  • platform/network/curl/CurlResourceHandleDelegate.cpp:

(WebCore::CurlResourceHandleDelegate::curlDidReceiveData):

  • platform/network/curl/CurlResourceHandleDelegate.h:
  • platform/network/curl/CurlStream.cpp:

(WebCore::CurlStream::tryToReceive):

  • platform/network/curl/CurlStream.h:
  • platform/network/curl/SocketStreamHandleImpl.h:
  • platform/network/curl/SocketStreamHandleImplCurl.cpp:

(WebCore::SocketStreamHandleImpl::didReceiveData):

  • platform/network/ios/LegacyPreviewLoaderClient.h:

(WebCore::LegacyPreviewLoaderClient::didReceiveData):

  • platform/network/mac/WebCoreResourceHandleAsOperationQueueDelegate.mm:

(-[WebCoreResourceHandleAsOperationQueueDelegate connection:didReceiveData:lengthReceived:]):

  • svg/graphics/SVGImage.cpp:

(WebCore::SVGImage::dataChanged):

  • workers/WorkerFontLoadRequest.cpp:

(WebCore::WorkerFontLoadRequest::didReceiveData):

  • workers/WorkerFontLoadRequest.h:
  • workers/WorkerScriptLoader.cpp:

(WebCore::WorkerScriptLoader::didReceiveData):

  • workers/WorkerScriptLoader.h:
  • workers/service/context/ServiceWorkerFetch.h:
  • xml/XMLHttpRequest.cpp:

(WebCore::XMLHttpRequest::didReceiveData):

  • xml/XMLHttpRequest.h:

Source/WebKit:

  • GPUProcess/media/RemoteMediaResource.cpp:

(WebKit::RemoteMediaResource::dataReceived):

  • GPUProcess/media/RemoteMediaResource.h:
  • NetworkProcess/Downloads/PendingDownload.h:
  • NetworkProcess/NetworkCORSPreflightChecker.cpp:

(WebKit::NetworkCORSPreflightChecker::didReceiveData):

  • NetworkProcess/NetworkCORSPreflightChecker.h:
  • NetworkProcess/NetworkDataTask.h:
  • NetworkProcess/NetworkLoad.cpp:

(WebKit::NetworkLoad::didReceiveData):

  • NetworkProcess/NetworkLoad.h:
  • NetworkProcess/NetworkLoadClient.h:
  • NetworkProcess/NetworkResourceLoader.cpp:

(WebKit::NetworkResourceLoader::didReceiveBuffer):
(WebKit::NetworkResourceLoader::sendBuffer):

  • NetworkProcess/NetworkResourceLoader.h:
  • NetworkProcess/PingLoad.cpp:

(WebKit::PingLoad::didReceiveData):

  • NetworkProcess/PingLoad.h:
  • NetworkProcess/PreconnectTask.cpp:

(WebKit::PreconnectTask::didReceiveBuffer):

  • NetworkProcess/PreconnectTask.h:
  • NetworkProcess/ServiceWorker/ServiceWorkerDownloadTask.cpp:

(WebKit::ServiceWorkerDownloadTask::didReceiveData):

  • NetworkProcess/ServiceWorker/ServiceWorkerDownloadTask.h:
  • NetworkProcess/ServiceWorker/ServiceWorkerDownloadTask.messages.in:
  • NetworkProcess/ServiceWorker/ServiceWorkerFetchTask.cpp:

(WebKit::ServiceWorkerFetchTask::didReceiveData):
(WebKit::ServiceWorkerFetchTask::loadBodyFromPreloader):

  • NetworkProcess/ServiceWorker/ServiceWorkerFetchTask.h:
  • NetworkProcess/ServiceWorker/ServiceWorkerFetchTask.messages.in:
  • NetworkProcess/ServiceWorker/ServiceWorkerNavigationPreloader.cpp:

(WebKit::ServiceWorkerNavigationPreloader::didReceiveBuffer):

  • NetworkProcess/ServiceWorker/ServiceWorkerNavigationPreloader.h:
  • NetworkProcess/ServiceWorker/ServiceWorkerSoftUpdateLoader.cpp:

(WebKit::ServiceWorkerSoftUpdateLoader::didReceiveBuffer):

  • NetworkProcess/ServiceWorker/ServiceWorkerSoftUpdateLoader.h:
  • NetworkProcess/cache/NetworkCacheSpeculativeLoad.cpp:

(WebKit::NetworkCache::SpeculativeLoad::didReceiveBuffer):

  • NetworkProcess/cache/NetworkCacheSpeculativeLoad.h:
  • NetworkProcess/cocoa/NetworkDataTaskCocoa.h:
  • NetworkProcess/cocoa/NetworkDataTaskCocoa.mm:

(WebKit::NetworkDataTaskCocoa::didReceiveData):

  • NetworkProcess/curl/NetworkDataTaskCurl.cpp:

(WebKit::NetworkDataTaskCurl::curlDidReceiveData):

  • NetworkProcess/curl/NetworkDataTaskCurl.h:
  • Platform/IPC/SharedBufferCopy.h:
  • Shared/mac/MediaFormatReader/MediaFormatReader.cpp:

(WebKit::MediaFormatReader::didParseTracks):

  • Shared/mac/MediaFormatReader/MediaFormatReader.h:
  • UIProcess/WebURLSchemeTask.cpp:

(WebKit::WebURLSchemeTask::didReceiveData):

  • UIProcess/WebURLSchemeTask.h:
  • WebProcess/GPU/media/RemoteMediaResourceProxy.cpp:

(WebKit::RemoteMediaResourceProxy::dataReceived):

  • WebProcess/GPU/media/RemoteMediaResourceProxy.h:
  • WebProcess/Network/WebResourceLoader.cpp:

(WebKit::WebResourceLoader::didReceiveData):
(WebKit::WebResourceLoader::didReceiveResource):

  • WebProcess/Network/WebResourceLoader.h:
  • WebProcess/Network/WebResourceLoader.messages.in:
  • WebProcess/Plugins/PDF/PDFPlugin.h:
  • WebProcess/Plugins/PDF/PDFPlugin.mm:

(WebKit::PDFPlugin::PDFPluginStreamLoaderClient::didReceiveData):
(WebKit::PDFPlugin::streamDidReceiveData):
(WebKit::PDFPlugin::manualStreamDidReceiveData):

  • WebProcess/Plugins/Plugin.h:
  • WebProcess/Plugins/PluginView.cpp:

(WebKit::PluginView::Stream::didReceiveData):
(WebKit::PluginView::manualLoadDidReceiveData):
(WebKit::PluginView::redeliverManualStream):

  • WebProcess/Plugins/PluginView.h:
  • WebProcess/Storage/WebServiceWorkerFetchTaskClient.cpp:

(WebKit::WebServiceWorkerFetchTaskClient::didReceiveData):
(WebKit::WebServiceWorkerFetchTaskClient::didReceiveBlobChunk):
(WebKit::WebServiceWorkerFetchTaskClient::continueDidReceiveResponse):

  • WebProcess/Storage/WebServiceWorkerFetchTaskClient.h:
  • WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:

(WebKit::WebFrameLoaderClient::committedLoad):

  • WebProcess/WebCoreSupport/WebFrameLoaderClient.h:
  • WebProcess/WebCoreSupport/ios/WebPreviewLoaderClient.cpp:

(WebKit::WebPreviewLoaderClient::didReceiveData):

  • WebProcess/WebCoreSupport/ios/WebPreviewLoaderClient.h:
  • WebProcess/WebPage/WebPage.cpp:

(WebKit::WebPage::urlSchemeTaskDidReceiveData):

  • WebProcess/WebPage/WebPage.h:
  • WebProcess/WebPage/WebPage.messages.in:
  • WebProcess/WebPage/WebURLSchemeHandlerProxy.cpp:

(WebKit::WebURLSchemeHandlerProxy::taskDidReceiveData):

  • WebProcess/WebPage/WebURLSchemeHandlerProxy.h:
  • WebProcess/WebPage/WebURLSchemeTaskProxy.cpp:

(WebKit::WebURLSchemeTaskProxy::didReceiveData):

  • WebProcess/WebPage/WebURLSchemeTaskProxy.h:

Source/WebKitLegacy:

  • WebCoreSupport/PingHandle.h:

Source/WebKitLegacy/mac:

  • WebCoreSupport/WebFrameLoaderClient.h:
  • WebCoreSupport/WebFrameLoaderClient.mm:

(WebFrameLoaderClient::committedLoad):
(WebFrameLoaderClient::createPreviewLoaderClient):

  • WebView/WebFrame.mm:

(-[WebFrame _commitData:]):

Source/WebKitLegacy/win:

  • WebCoreSupport/WebFrameLoaderClient.cpp:

(WebFrameLoaderClient::committedLoad):

  • WebCoreSupport/WebFrameLoaderClient.h:
Location:
trunk/Source
Files:
173 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r287683 r287684  
     12022-01-06  Jean-Yves Avenard  <jya@apple.com>
     2
     3        Have CachedRawResourceClient and related networking actors use SharedBuffer.
     4        https://bugs.webkit.org/show_bug.cgi?id=232424
     5        rdar://84744687
     6
     7        Reviewed by Youenn Fablet.
     8
     9        We modify all didReceiveData and related methods so that they no longer
     10        use uint8_t*/int and instead use SharedBuffer.
     11        We do the same for any intermediaries used by the various didReceiveData
     12        implementations.
     13        This will facilitate moving networking off the main thread in the GPU
     14        process and allows to remove several memory allocations and copies at the
     15        process boundaries.
     16        We can now consider transfer the underlying SharedMemory created in
     17        the network process all the way to the GPU process.
     18
     19        Fly-by fix: change FragmentedSharedBuffer type to SharedBuffer when appropriate.
     20
     21        No change in observable behaviour. Covered by all existing tests.
     22
     23        * Modules/fetch/FetchBodyConsumer.cpp:
     24        (WebCore::FetchBodyConsumer::append):
     25        * Modules/fetch/FetchBodyConsumer.h:
     26        * Modules/fetch/FetchBodyOwner.cpp:
     27        (WebCore::FetchBodyOwner::blobChunk):
     28        * Modules/fetch/FetchBodyOwner.h:
     29        * Modules/fetch/FetchLoader.cpp:
     30        (WebCore::FetchLoader::didReceiveData):
     31        * Modules/fetch/FetchLoader.h:
     32        * Modules/fetch/FetchLoaderClient.h:
     33        (WebCore::FetchLoaderClient::didReceiveData):
     34        * Modules/fetch/FetchResponse.cpp:
     35        (WebCore::FetchResponse::BodyLoader::didReceiveData):
     36        (WebCore::FetchResponse::consumeChunk):
     37        * Modules/fetch/FetchResponse.h:
     38        * Modules/model-element/HTMLModelElement.cpp:
     39        (WebCore::HTMLModelElement::dataReceived):
     40        * Modules/model-element/HTMLModelElement.h:
     41        * Modules/streams/ReadableStreamSink.h:
     42        * fileapi/FileReaderLoader.cpp:
     43        (WebCore::FileReaderLoader::didReceiveData):
     44        * fileapi/FileReaderLoader.h:
     45        * inspector/InspectorInstrumentation.cpp:
     46        (WebCore::InspectorInstrumentation::didReceiveDataImpl):
     47        * inspector/InspectorInstrumentation.h:
     48        (WebCore::InspectorInstrumentation::didReceiveData):
     49        * inspector/NetworkResourcesData.cpp:
     50        (WebCore::NetworkResourcesData::ResourceData::appendData):
     51        (WebCore::NetworkResourcesData::maybeAddResourceData):
     52        * inspector/NetworkResourcesData.h:
     53        * inspector/agents/InspectorNetworkAgent.cpp:
     54        (WebCore::InspectorNetworkAgent::didReceiveResponse):
     55        (WebCore::InspectorNetworkAgent::didReceiveData):
     56        (WebCore::InspectorNetworkAgent::interceptRequestWithResponse):
     57        * inspector/agents/InspectorNetworkAgent.h:
     58        * loader/ContentFilter.cpp:
     59        (WebCore::ContentFilter::deliverResourceData):
     60        * loader/ContentFilterClient.h:
     61        * loader/DocumentLoader.cpp:
     62        (WebCore::DocumentLoader::finishedLoading):
     63        (WebCore::DocumentLoader::continueAfterContentPolicy):
     64        (WebCore::DocumentLoader::commitLoad):
     65        (WebCore::DocumentLoader::commitData):
     66        (WebCore::DocumentLoader::dataReceived):
     67        (WebCore::DocumentLoader::maybeCreateArchive):
     68        (WebCore::DocumentLoader::maybeFinishLoadingMultipartContent):
     69        (WebCore::DocumentLoader::dataReceivedThroughContentFilter):
     70        * loader/DocumentLoader.h:
     71        * loader/DocumentThreadableLoader.cpp:
     72        (WebCore::DocumentThreadableLoader::dataReceived):
     73        (WebCore::DocumentThreadableLoader::didReceiveData):
     74        (WebCore::DocumentThreadableLoader::didFinishLoading):
     75        (WebCore::DocumentThreadableLoader::loadRequest):
     76        * loader/DocumentThreadableLoader.h:
     77        * loader/DocumentWriter.cpp:
     78        (WebCore::DocumentWriter::addData):
     79        * loader/DocumentWriter.h:
     80        * loader/EmptyClients.cpp:
     81        (WebCore::EmptyFrameLoaderClient::committedLoad):
     82        * loader/EmptyFrameLoaderClient.h:
     83        * loader/FrameLoader.cpp:
     84        (WebCore::FrameLoader::willLoadMediaElementURL):
     85        (WebCore::FrameLoader::commitProvisionalLoad):
     86        (WebCore::FrameLoader::loadResourceSynchronously):
     87        (WebCore::FrameLoader::loadedResourceFromMemoryCache):
     88        * loader/FrameLoaderClient.h:
     89        * loader/MediaResourceLoader.cpp:
     90        (WebCore::MediaResource::dataReceived):
     91        * loader/MediaResourceLoader.h:
     92        * loader/NetscapePlugInStreamLoader.cpp:
     93        (WebCore::NetscapePlugInStreamLoader::didReceiveData):
     94        * loader/NetscapePlugInStreamLoader.h:
     95        * loader/ResourceLoadNotifier.cpp:
     96        (WebCore::ResourceLoadNotifier::didReceiveData):
     97        (WebCore::ResourceLoadNotifier::dispatchDidReceiveData):
     98        (WebCore::ResourceLoadNotifier::sendRemainingDelegateMessages):
     99        * loader/ResourceLoadNotifier.h:
     100        * loader/ResourceLoader.cpp:
     101        (WebCore::ResourceLoader::loadDataURL):
     102        (WebCore::ResourceLoader::addBuffer):
     103        (WebCore::ResourceLoader::didReceiveData):
     104        (WebCore::ResourceLoader::didReceiveBuffer):
     105        * loader/ResourceLoader.h:
     106        * loader/SubresourceLoader.cpp:
     107        (WebCore::SubresourceLoader::didReceiveBuffer):
     108        * loader/SubresourceLoader.h:
     109        * loader/SubstituteResource.h:
     110        (WebCore::SubstituteResource::append):
     111        * loader/ThreadableLoaderClient.h:
     112        (WebCore::ThreadableLoaderClient::didReceiveData):
     113        * loader/ThreadableLoaderClientWrapper.h:
     114        (WebCore::ThreadableLoaderClientWrapper::didReceiveData):
     115        * loader/WorkerThreadableLoader.cpp:
     116        (WebCore::WorkerThreadableLoader::MainThreadBridge::didReceiveData):
     117        * loader/WorkerThreadableLoader.h:
     118        * loader/appcache/ApplicationCacheHost.cpp:
     119        (WebCore::ApplicationCacheHost::mainResourceDataReceived):
     120        * loader/appcache/ApplicationCacheHost.h:
     121        * loader/appcache/ApplicationCacheResource.cpp:
     122        (WebCore::ApplicationCacheResource::deliver):
     123        * loader/appcache/ApplicationCacheResourceLoader.cpp:
     124        (WebCore::ApplicationCacheResourceLoader::dataReceived):
     125        * loader/appcache/ApplicationCacheResourceLoader.h:
     126        * loader/cache/CachedImage.cpp:
     127        (WebCore::CachedImage::updateBufferInternal):
     128        (WebCore::CachedImage::updateBuffer):
     129        (WebCore::CachedImage::updateData):
     130        * loader/cache/CachedImage.h:
     131        * loader/cache/CachedRawResource.cpp:
     132        (WebCore::CachedRawResource::calculateIncrementalDataChunk const):
     133        (WebCore::CachedRawResource::updateBuffer):
     134        (WebCore::CachedRawResource::updateData):
     135        (WebCore::CachedRawResource::finishLoading):
     136        (WebCore::CachedRawResource::notifyClientsDataWasReceived):
     137        (WebCore::CachedRawResource::didAddClient):
     138        * loader/cache/CachedRawResource.h:
     139        * loader/cache/CachedRawResourceClient.h:
     140        (WebCore::CachedRawResourceClient::dataReceived):
     141        * loader/cache/CachedResource.cpp:
     142        (WebCore::CachedResource::updateData):
     143        * loader/cache/CachedResource.h:
     144        * loader/ios/LegacyPreviewLoader.h:
     145        * loader/ios/LegacyPreviewLoader.mm:
     146        (WebCore::LegacyPreviewLoader::didReceiveData):
     147        (WebCore::LegacyPreviewLoader::previewConverterDidReceiveData):
     148        * page/EventSource.cpp:
     149        (WebCore::EventSource::didReceiveData):
     150        * page/EventSource.h:
     151        * platform/SharedBuffer.cpp:
     152        (WebCore::FragmentedSharedBuffer::takeData): Update due to DataSegmentVectorEntry::segment being const
     153        (WebCore::FragmentedSharedBuffer::forEachSegmentAsSharedBuffer const): Add convenience method.
     154        (WebCore::SharedBuffer::SharedBuffer):
     155        (WebCore::SharedBufferDataView::SharedBufferDataView):
     156        (WebCore::SharedBufferDataView::createSharedBuffer const):
     157        * platform/SharedBuffer.h: Make DataSegmentVectorEntry::segment const.
     158        (WebCore::SharedBuffer::create):
     159        (WebCore::SharedBuffer::SharedBuffer):
     160        * platform/graphics/PlatformMediaResourceLoader.h:
     161        (WebCore::PlatformMediaResourceClient::dataReceived):
     162        * platform/graphics/avfoundation/cf/WebCoreAVCFResourceLoader.cpp:
     163        (WebCore::WebCoreAVCFResourceLoader::dataReceived):
     164        * platform/graphics/avfoundation/cf/WebCoreAVCFResourceLoader.h:
     165        * platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm:
     166        (WebCore::CachedResourceMediaLoader::dataReceived):
     167        (WebCore::PlatformResourceMediaLoader::dataReceived):
     168        * platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:
     169        (CachedResourceStreamingClient::dataReceived):
     170        * platform/network/ResourceHandleClient.cpp:
     171        (WebCore::ResourceHandleClient::didReceiveBuffer):
     172        * platform/network/ResourceHandleClient.h:
     173        (WebCore::ResourceHandleClient::didReceiveData):
     174        * platform/network/SynchronousLoaderClient.cpp:
     175        (WebCore::SynchronousLoaderClient::didReceiveData):
     176        * platform/network/SynchronousLoaderClient.h:
     177        * platform/network/cocoa/RangeResponseGenerator.mm:
     178        (WebCore::RangeResponseGenerator::giveResponseToTaskIfBytesInRangeReceived):
     179        * platform/network/cocoa/WebCoreNSURLSession.h:
     180        * platform/network/cocoa/WebCoreNSURLSession.mm:
     181        (WebCore::WebCoreNSURLSessionDataTaskClient::dataReceived):
     182        (-[WebCoreNSURLSessionDataTask resource:receivedData:]):
     183        * platform/network/curl/CurlCacheManager.cpp:
     184        (WebCore::CurlCacheManager::didReceiveData):
     185        * platform/network/curl/CurlCacheManager.h:
     186        * platform/network/curl/CurlDownload.cpp:
     187        (WebCore::CurlDownload::curlDidReceiveData):
     188        * platform/network/curl/CurlDownload.h:
     189        * platform/network/curl/CurlMultipartHandle.cpp:
     190        (WebCore::CurlMultipartHandle::didReceiveData):
     191        * platform/network/curl/CurlMultipartHandle.h:
     192        * platform/network/curl/CurlMultipartHandleClient.h:
     193        * platform/network/curl/CurlRequest.cpp:
     194        (WebCore::CurlRequest::didReceiveData):
     195        (WebCore::CurlRequest::didReceiveDataFromMultipart):
     196        * platform/network/curl/CurlRequest.h:
     197        * platform/network/curl/CurlRequestClient.h:
     198        * platform/network/curl/CurlResourceHandleDelegate.cpp:
     199        (WebCore::CurlResourceHandleDelegate::curlDidReceiveData):
     200        * platform/network/curl/CurlResourceHandleDelegate.h:
     201        * platform/network/curl/CurlStream.cpp:
     202        (WebCore::CurlStream::tryToReceive):
     203        * platform/network/curl/CurlStream.h:
     204        * platform/network/curl/SocketStreamHandleImpl.h:
     205        * platform/network/curl/SocketStreamHandleImplCurl.cpp:
     206        (WebCore::SocketStreamHandleImpl::didReceiveData):
     207        * platform/network/ios/LegacyPreviewLoaderClient.h:
     208        (WebCore::LegacyPreviewLoaderClient::didReceiveData):
     209        * platform/network/mac/WebCoreResourceHandleAsOperationQueueDelegate.mm:
     210        (-[WebCoreResourceHandleAsOperationQueueDelegate connection:didReceiveData:lengthReceived:]):
     211        * svg/graphics/SVGImage.cpp:
     212        (WebCore::SVGImage::dataChanged):
     213        * workers/WorkerFontLoadRequest.cpp:
     214        (WebCore::WorkerFontLoadRequest::didReceiveData):
     215        * workers/WorkerFontLoadRequest.h:
     216        * workers/WorkerScriptLoader.cpp:
     217        (WebCore::WorkerScriptLoader::didReceiveData):
     218        * workers/WorkerScriptLoader.h:
     219        * workers/service/context/ServiceWorkerFetch.h:
     220        * xml/XMLHttpRequest.cpp:
     221        (WebCore::XMLHttpRequest::didReceiveData):
     222        * xml/XMLHttpRequest.h:
     223
    12242022-01-06  Alan Bujtas  <zalan@apple.com>
    2225

  • trunk/Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp

    r287612 r287684  
    379379}
    380380
    381 void FetchBodyConsumer::append(const uint8_t* data, unsigned size)
     381void FetchBodyConsumer::append(const SharedBuffer& buffer)
    382382{
    383383    if (m_source) {
    384         m_source->enqueue(ArrayBuffer::tryCreate(data, size));
    385         return;
    386     }
    387     m_buffer.append(data, size);
     384        m_source->enqueue(buffer.tryCreateArrayBuffer());
     385        return;
     386    }
     387    m_buffer.append(buffer);
    388388}
    389389

  • trunk/Source/WebCore/Modules/fetch/FetchBodyConsumer.h

    r287612 r287684  
    5353    FetchBodyConsumer clone();
    5454
    55     void append(const uint8_t* data, unsigned);
     55    void append(const SharedBuffer&);
    5656
    5757    bool hasData() const { return !!m_buffer; }

  • trunk/Source/WebCore/Modules/fetch/FetchBodyOwner.cpp

    r287532 r287684  
    299299}
    300300
    301 void FetchBodyOwner::blobChunk(const uint8_t* data, size_t size)
    302 {
    303     ASSERT(data);
     301void FetchBodyOwner::blobChunk(const SharedBuffer& buffer)
     302{
    304303    ASSERT(m_readableStreamSource);
    305     if (!m_readableStreamSource->enqueue(ArrayBuffer::tryCreate(data, size)))
     304    if (!m_readableStreamSource->enqueue(buffer.tryCreateArrayBuffer()))
    306305        stop();
    307306}

  • trunk/Source/WebCore/Modules/fetch/FetchBodyOwner.h

    r287675 r287684  
    3838#include "FetchLoaderClient.h"
    3939#include "ResourceError.h"
     40#include "SharedBuffer.h"
    4041
    4142namespace WebCore {
    … …  
    102103private:
    103104    // Blob loading routines
    104     void blobChunk(const uint8_t*, size_t);
     105    void blobChunk(const SharedBuffer&);
    105106    void blobLoadingSucceeded();
    106107    void blobLoadingFailed();
    … …  
    115116        // FetchLoaderClient API
    116117        void didReceiveResponse(const ResourceResponse&) final;
    117         void didReceiveData(const uint8_t* data, size_t size) final { owner.blobChunk(data, size); }
     118        void didReceiveData(const SharedBuffer& buffer) final { owner.blobChunk(buffer); }
    118119        void didFail(const ResourceError&) final;
    119120        void didSucceed() final { owner.blobLoadingSucceeded(); }

  • trunk/Source/WebCore/Modules/fetch/FetchLoader.cpp

    r287021 r287684  
    149149}
    150150
    151 void FetchLoader::didReceiveData(const uint8_t* value, int size)
     151void FetchLoader::didReceiveData(const SharedBuffer& buffer)
    152152{
    153153    if (!m_consumer) {
    154         m_client.didReceiveData(value, size);
     154        m_client.didReceiveData(buffer);
    155155        return;
    156156    }
    157     m_consumer->append(value, size);
     157    m_consumer->append(buffer);
    158158}
    159159

  • trunk/Source/WebCore/Modules/fetch/FetchLoader.h

    r287021 r287684  
    5959    // ThreadableLoaderClient API.
    6060    void didReceiveResponse(ResourceLoaderIdentifier, const ResourceResponse&) final;
    61     void didReceiveData(const uint8_t*, int) final;
     61    void didReceiveData(const SharedBuffer&) final;
    6262    void didFinishLoading(ResourceLoaderIdentifier) final;
    6363    void didFail(const ResourceError&) final;

  • trunk/Source/WebCore/Modules/fetch/FetchLoaderClient.h

    r278516 r287684  
    4242    virtual void didReceiveResponse(const ResourceResponse&) { }
    4343
    44     virtual void didReceiveData(const uint8_t*, size_t) { }
     44    virtual void didReceiveData(const SharedBuffer&) { }
    4545
    4646    virtual void didSucceed() = 0;

  • trunk/Source/WebCore/Modules/fetch/FetchResponse.cpp

    r287675 r287684  
    359359}
    360360
    361 void FetchResponse::BodyLoader::didReceiveData(const uint8_t* data, size_t size)
     361void FetchResponse::BodyLoader::didReceiveData(const SharedBuffer& buffer)
    362362{
    363363    ASSERT(m_response.m_readableStreamSource || m_consumeDataCallback);
    364364
    365365    if (m_consumeDataCallback) {
    366         Span chunk { data, size };
     366        Span chunk { buffer.data(), buffer.size() };
    367367        m_consumeDataCallback(&chunk);
    368368        return;
    … …  
    372372
    373373    if (!source.isPulling()) {
    374         m_response.body().consumer().append(data, size);
     374        m_response.body().consumer().append(buffer);
    375375        return;
    376376    }
    … …  
    380380        return;
    381381    }
    382     if (!source.enqueue(ArrayBuffer::tryCreate(data, size))) {
     382    if (!source.enqueue(buffer.tryCreateArrayBuffer())) {
    383383        stop();
    384384        return;
    … …  
    464464void FetchResponse::consumeChunk(Ref<JSC::Uint8Array>&& chunk)
    465465{
    466     body().consumer().append(chunk->data(), chunk->byteLength());
     466    body().consumer().append(SharedBuffer::create(chunk->data(), chunk->byteLength()));
    467467}
    468468

  • trunk/Source/WebCore/Modules/fetch/FetchResponse.h

    r287532 r287684  
    144144        void didFail(const ResourceError&) final;
    145145        void didReceiveResponse(const ResourceResponse&) final;
    146         void didReceiveData(const uint8_t*, size_t) final;
     146        void didReceiveData(const SharedBuffer&) final;
    147147
    148148        FetchResponse& m_response;

  • trunk/Source/WebCore/Modules/model-element/HTMLModelElement.cpp

    r286983 r287684  
    178178// MARK: - CachedRawResourceClient
    179179
    180 void HTMLModelElement::dataReceived(CachedResource& resource, const uint8_t* data, int dataLength)
     180void HTMLModelElement::dataReceived(CachedResource& resource, const SharedBuffer& buffer)
    181181{
    182182    ASSERT_UNUSED(resource, &resource == m_resource);
    183     m_data.append(data, dataLength);
     183    m_data.append(buffer);
    184184}
    185185

  • trunk/Source/WebCore/Modules/model-element/HTMLModelElement.h

    r286983 r287684  
    117117
    118118    // CachedRawResourceClient overrides.
    119     void dataReceived(CachedResource&, const uint8_t* data, int dataLength) final;
     119    void dataReceived(CachedResource&, const SharedBuffer&) final;
    120120    void notifyFinished(CachedResource&, const NetworkLoadMetrics&) final;
    121121

  • trunk/Source/WebCore/Modules/streams/ReadableStreamSink.h

    r287021 r287684  
    3636class BufferSource;
    3737class ReadableStream;
    38 class FragmentedSharedBuffer;
    3938
    4039class ReadableStreamSink : public RefCounted<ReadableStreamSink> {

  • trunk/Source/WebCore/fileapi/FileReaderLoader.cpp

    r287612 r287684  
    4242#include "ResourceResponse.h"
    4343#include "ScriptExecutionContext.h"
     44#include "SharedBuffer.h"
    4445#include "TextResourceDecoder.h"
    4546#include "ThreadableBlobRegistry.h"
    … …  
    169170}
    170171
    171 void FileReaderLoader::didReceiveData(const uint8_t* data, int dataLength)
    172 {
    173     ASSERT(data);
    174     ASSERT(dataLength > 0);
     172void FileReaderLoader::didReceiveData(const SharedBuffer& buffer)
     173{
     174    ASSERT(buffer.size());
    175175
    176176    // Bail out if we already encountered an error.
    … …  
    178178        return;
    179179
    180     int length = dataLength;
     180    int length = buffer.size();
    181181    unsigned remainingBufferSpace = m_totalBytes - m_bytesLoaded;
    182182    if (length > static_cast<long long>(remainingBufferSpace)) {
    … …  
    187187        }
    188188        if (m_variableLength) {
    189             unsigned newLength = m_totalBytes + static_cast<unsigned>(dataLength);
     189            unsigned newLength = m_totalBytes + buffer.size();
    190190            if (newLength < m_totalBytes) {
    191191                failed(NotReadableError);
    … …  
    212212        return;
    213213
    214     memcpy(static_cast<char*>(m_rawData->data()) + m_bytesLoaded, data, length);
     214    memcpy(static_cast<char*>(m_rawData->data()) + m_bytesLoaded, buffer.data(), length);
    215215    m_bytesLoaded += length;
    216216

  • trunk/Source/WebCore/fileapi/FileReaderLoader.h

    r287612 r287684  
    7272    // ThreadableLoaderClient
    7373    void didReceiveResponse(ResourceLoaderIdentifier, const ResourceResponse&) override;
    74     void didReceiveData(const uint8_t*, int) override;
     74    void didReceiveData(const SharedBuffer&) override;
    7575    void didFinishLoading(ResourceLoaderIdentifier) override;
    7676    void didFail(const ResourceError&) override;

  • trunk/Source/WebCore/inspector/InspectorInstrumentation.cpp

    r287327 r287684  
    617617}
    618618
    619 void InspectorInstrumentation::didReceiveDataImpl(InstrumentingAgents& instrumentingAgents, ResourceLoaderIdentifier identifier, const uint8_t* data, int dataLength, int encodedDataLength)
    620 {
    621     if (auto* networkAgent = instrumentingAgents.enabledNetworkAgent())
    622         networkAgent->didReceiveData(identifier, data, dataLength, encodedDataLength);
     619void InspectorInstrumentation::didReceiveDataImpl(InstrumentingAgents& instrumentingAgents, ResourceLoaderIdentifier identifier, const SharedBuffer& buffer, int encodedDataLength)
     620{
     621    if (auto* networkAgent = instrumentingAgents.enabledNetworkAgent())
     622        networkAgent->didReceiveData(identifier, &buffer, buffer.size(), encodedDataLength);
    623623}
    624624

  • trunk/Source/WebCore/inspector/InspectorInstrumentation.h

    r287021 r287684  
    194194    static void didReceiveResourceResponse(Frame&, ResourceLoaderIdentifier, DocumentLoader*, const ResourceResponse&, ResourceLoader*);
    195195    static void didReceiveThreadableLoaderResponse(DocumentThreadableLoader&, ResourceLoaderIdentifier);
    196     static void didReceiveData(Frame*, ResourceLoaderIdentifier, const uint8_t* data, int dataLength, int encodedDataLength);
     196    static void didReceiveData(Frame*, ResourceLoaderIdentifier, const SharedBuffer&, int encodedDataLength);
    197197    static void didFinishLoading(Frame*, DocumentLoader*, ResourceLoaderIdentifier, const NetworkLoadMetrics&, ResourceLoader*);
    198198    static void didFailLoading(Frame*, DocumentLoader*, ResourceLoaderIdentifier, const ResourceError&);
    … …  
    200200    static void willSendRequest(WorkerOrWorkletGlobalScope&, ResourceLoaderIdentifier, ResourceRequest&);
    201201    static void didReceiveResourceResponse(WorkerOrWorkletGlobalScope&, ResourceLoaderIdentifier, const ResourceResponse&);
    202     static void didReceiveData(WorkerOrWorkletGlobalScope&, ResourceLoaderIdentifier, const uint8_t* data, int dataLength);
     202    static void didReceiveData(WorkerOrWorkletGlobalScope&, ResourceLoaderIdentifier, const SharedBuffer&);
    203203    static void didFinishLoading(WorkerOrWorkletGlobalScope&, ResourceLoaderIdentifier, const NetworkLoadMetrics&);
    204204    static void didFailLoading(WorkerOrWorkletGlobalScope&, ResourceLoaderIdentifier, const ResourceError&);
    … …  
    415415    static void didReceiveResourceResponseImpl(InstrumentingAgents&, ResourceLoaderIdentifier, DocumentLoader*, const ResourceResponse&, ResourceLoader*);
    416416    static void didReceiveThreadableLoaderResponseImpl(InstrumentingAgents&, DocumentThreadableLoader&, ResourceLoaderIdentifier);
    417     static void didReceiveDataImpl(InstrumentingAgents&, ResourceLoaderIdentifier, const uint8_t* data, int dataLength, int encodedDataLength);
     417    static void didReceiveDataImpl(InstrumentingAgents&, ResourceLoaderIdentifier, const SharedBuffer&, int encodedDataLength);
    418418    static void didFinishLoadingImpl(InstrumentingAgents&, ResourceLoaderIdentifier, DocumentLoader*, const NetworkLoadMetrics&, ResourceLoader*);
    419419    static void didFailLoadingImpl(InstrumentingAgents&, ResourceLoaderIdentifier, DocumentLoader*, const ResourceError&);
    … …  
    10831083}
    10841084   
    1085 inline void InspectorInstrumentation::didReceiveData(Frame* frame, ResourceLoaderIdentifier identifier, const uint8_t* data, int dataLength, int encodedDataLength)
    1086 {
    1087     FAST_RETURN_IF_NO_FRONTENDS(void());
    1088     if (auto* agents = instrumentingAgents(frame))
    1089         didReceiveDataImpl(*agents, identifier, data, dataLength, encodedDataLength);
    1090 }
    1091 
    1092 inline void InspectorInstrumentation::didReceiveData(WorkerOrWorkletGlobalScope& globalScope, ResourceLoaderIdentifier identifier, const uint8_t* data, int dataLength)
    1093 {
    1094     FAST_RETURN_IF_NO_FRONTENDS(void());
    1095     didReceiveDataImpl(instrumentingAgents(globalScope), identifier, data, dataLength, dataLength);
     1085inline void InspectorInstrumentation::didReceiveData(Frame* frame, ResourceLoaderIdentifier identifier, const SharedBuffer& buffer, int encodedDataLength)
     1086{
     1087    FAST_RETURN_IF_NO_FRONTENDS(void());
     1088    if (auto* agents = instrumentingAgents(frame))
     1089        didReceiveDataImpl(*agents, identifier, buffer, encodedDataLength);
     1090}
     1091
     1092inline void InspectorInstrumentation::didReceiveData(WorkerOrWorkletGlobalScope& globalScope, ResourceLoaderIdentifier identifier, const SharedBuffer& buffer)
     1093{
     1094    FAST_RETURN_IF_NO_FRONTENDS(void());
     1095    didReceiveDataImpl(instrumentingAgents(globalScope), identifier, buffer, buffer.size());
    10961096}
    10971097

  • trunk/Source/WebCore/inspector/NetworkResourcesData.cpp

    r287021 r287684  
    9191}
    9292
    93 void NetworkResourcesData::ResourceData::appendData(const uint8_t* data, size_t dataLength)
     93void NetworkResourcesData::ResourceData::appendData(const SharedBuffer& data)
    9494{
    9595    ASSERT(!hasContent());
    96     m_dataBuffer.append(data, dataLength);
     96    m_dataBuffer.append(data);
    9797}
    9898
    … …  
    222222}
    223223
    224 NetworkResourcesData::ResourceData const* NetworkResourcesData::maybeAddResourceData(const String& requestId, const uint8_t* data, size_t dataLength)
     224NetworkResourcesData::ResourceData const* NetworkResourcesData::maybeAddResourceData(const String& requestId, const SharedBuffer& data)
    225225{
    226226    ResourceData* resourceData = resourceDataForRequestId(requestId);
    … …  
    231231        return resourceData;
    232232
    233     if (resourceData->dataLength() + dataLength > m_maximumSingleResourceContentSize)
     233    if (resourceData->dataLength() + data.size() > m_maximumSingleResourceContentSize)
    234234        m_contentSize -= resourceData->evictContent();
    235235    if (resourceData->isContentEvicted())
    236236        return resourceData;
    237237
    238     if (ensureFreeSpace(dataLength) && !resourceData->isContentEvicted()) {
     238    if (ensureFreeSpace(data.size()) && !resourceData->isContentEvicted()) {
    239239        m_requestIdsDeque.append(requestId);
    240         resourceData->appendData(data, dataLength);
    241         m_contentSize += dataLength;
     240        resourceData->appendData(data);
     241        m_contentSize += data.size();
    242242    }
    243243

  • trunk/Source/WebCore/inspector/NetworkResourcesData.h

    r287021 r287684  
    109109        bool hasData() const;
    110110        size_t dataLength() const;
    111         void appendData(const uint8_t* data, size_t dataLength);
     111        void appendData(const SharedBuffer&);
    112112        unsigned decodeDataToContent();
    113113
    … …  
    142142    InspectorPageAgent::ResourceType resourceType(const String& requestId);
    143143    void setResourceContent(const String& requestId, const String& content, bool base64Encoded = false);
    144     ResourceData const* maybeAddResourceData(const String& requestId, const uint8_t* data, size_t dataLength);
     144    ResourceData const* maybeAddResourceData(const String& requestId, const SharedBuffer&);
    145145    void maybeDecodeDataToContent(const String& requestId);
    146146    void addCachedResource(const String& requestId, CachedResource*);

  • trunk/Source/WebCore/inspector/agents/InspectorNetworkAgent.cpp

    r287681 r287684  
    125125    }
    126126
    127     void didReceiveData(const uint8_t* data, int dataLength) override
     127    void didReceiveData(const SharedBuffer& buffer) override
    128128    {
    129         if (!dataLength)
     129        if (buffer.isEmpty())
    130130            return;
    131131
    132         m_responseText.append(m_decoder->decode(data, dataLength));
     132        m_responseText.append(m_decoder->decode(buffer.data(), buffer.size()));
    133133    }
    134134
    … …  
    547547                m_resourcesData->setResourceContent(requestId, previousResourceData->content(), previousResourceData->base64Encoded());
    548548            else if (previousResourceData->hasBufferedData()) {
    549                 auto previousBuffer = previousResourceData->buffer();
    550                 previousBuffer->forEachSegment([&](auto& segment) {
    551                     m_resourcesData->maybeAddResourceData(requestId, segment.data(), segment.size());
     549                previousResourceData->buffer()->forEachSegmentAsSharedBuffer([&](auto&& buffer) {
     550                    m_resourcesData->maybeAddResourceData(requestId, buffer);
    552551                });
    553552            }
    … …  
    575574}
    576575
    577 void InspectorNetworkAgent::didReceiveData(ResourceLoaderIdentifier identifier, const uint8_t* data, int dataLength, int encodedDataLength)
     576void InspectorNetworkAgent::didReceiveData(ResourceLoaderIdentifier identifier, const SharedBuffer* data, int expectedDataLength, int encodedDataLength)
    578577{
    579578    if (m_hiddenRequestIdentifiers.contains(identifier))
    … …  
    583582
    584583    if (data) {
    585         NetworkResourcesData::ResourceData const* resourceData = m_resourcesData->maybeAddResourceData(requestId, data, dataLength);
     584        NetworkResourcesData::ResourceData const* resourceData = m_resourcesData->maybeAddResourceData(requestId, *data);
    586585
    587586        // For a synchronous XHR, if we didn't add data then we can apply it here as base64 encoded content.
    … …  
    589588        // Sync XHRs may not have a cached resource, while non-sync XHRs usually transfer data over on completion.
    590589        if (m_loadingXHRSynchronously && resourceData && !resourceData->hasBufferedData() && !resourceData->cachedResource())
    591             m_resourcesData->setResourceContent(requestId, base64EncodeToString(data, dataLength), true);
    592     }
    593 
    594     m_frontendDispatcher->dataReceived(requestId, timestamp(), dataLength, encodedDataLength);
     590            m_resourcesData->setResourceContent(requestId, base64EncodeToString(data->data(), data->size()), true);
     591    }
     592
     593    m_frontendDispatcher->dataReceived(requestId, timestamp(), expectedDataLength, encodedDataLength);
    595594}
    596595
    … …  
    12691268        return makeUnexpected("Unable to fulfill request, it has already been processed"_s);
    12701269
    1271     RefPtr<FragmentedSharedBuffer> data;
     1270    RefPtr<SharedBuffer> data;
    12721271    if (base64Encoded) {
    12731272        auto buffer = base64Decode(content);
    … …  
    12941293    response.setHTTPHeaderFields(WTFMove(explicitHeaders));
    12951294    response.setHTTPHeaderField(HTTPHeaderName::ContentType, response.mimeType());
    1296     loader->didReceiveResponse(response, [loader, buffer = data.releaseNonNull()]() mutable {
     1295    loader->didReceiveResponse(response, [loader, buffer = data.releaseNonNull()]() {
    12971296        if (buffer->size())
    1298             loader->didReceiveBuffer(WTFMove(buffer), buffer->size(), DataPayloadWholeResource);
     1297            loader->didReceiveData(buffer, buffer->size(), DataPayloadWholeResource);
    12991298        loader->didFinishLoading(NetworkLoadMetrics());
    13001299    });

  • trunk/Source/WebCore/inspector/agents/InspectorNetworkAgent.h

    r287021 r287684  
    102102    void willSendRequestOfType(ResourceLoaderIdentifier, DocumentLoader*, ResourceRequest&, InspectorInstrumentation::LoadType);
    103103    void didReceiveResponse(ResourceLoaderIdentifier, DocumentLoader*, const ResourceResponse&, ResourceLoader*);
    104     void didReceiveData(ResourceLoaderIdentifier, const uint8_t* data, int dataLength, int encodedDataLength);
     104    void didReceiveData(ResourceLoaderIdentifier, const SharedBuffer*, int expectedDataLength, int encodedDataLength);
    105105    void didFinishLoading(ResourceLoaderIdentifier, DocumentLoader*, const NetworkLoadMetrics&, ResourceLoader*);
    106106    void didFailLoading(ResourceLoaderIdentifier, DocumentLoader*, const ResourceError&);

  • trunk/Source/WebCore/loader/ContentFilter.cpp

    r287138 r287684  
    234234    ASSERT(resource.dataBufferingPolicy() == DataBufferingPolicy::BufferData);
    235235    if (auto* resourceBuffer = resource.resourceBuffer())
    236         m_client.dataReceivedThroughContentFilter(resourceBuffer->makeContiguous()->data(), resourceBuffer->size());
     236        m_client.dataReceivedThroughContentFilter(resourceBuffer->makeContiguous());
    237237}
    238238

  • trunk/Source/WebCore/loader/ContentFilterClient.h

    r278516 r287684  
    3434class ContentFilterUnblockHandler;
    3535class ResourceError;
     36class SharedBuffer;
    3637class SubstituteData;
    3738
    … …  
    4243    virtual void deref() const = 0;
    4344
    44     virtual void dataReceivedThroughContentFilter(const uint8_t*, int) = 0;
     45    virtual void dataReceivedThroughContentFilter(const SharedBuffer&) = 0;
    4546    virtual ResourceError contentFilterDidBlock(ContentFilterUnblockHandler, String&& unblockRequestDeniedScript) = 0;
    4647    virtual void cancelMainResourceLoadForContentFilter(const ResourceError&) = 0;

  • trunk/Source/WebCore/loader/DocumentLoader.cpp

    r287030 r287684  
    484484        // DocumentWriter::begin() gets called and creates the Document.
    485485        if (!m_gotFirstByte)
    486             commitData(0, 0);
    487        
     486            commitData(SharedBuffer::create());
     487
    488488        if (!frameLoader())
    489489            return;
    … …  
    11581158        auto content = m_substituteData.content();
    11591159        if (content && content->size()) {
    1160             content->forEachSegment([&](auto& segment) {
    1161                 dataReceived(segment.data(), segment.size());
     1160            content->forEachSegmentAsSharedBuffer([&](auto&& buffer) {
     1161                dataReceived(buffer);
    11621162            });
    11631163        }
    … …  
    11721172}
    11731173
    1174 void DocumentLoader::commitLoad(const uint8_t* data, int length)
     1174void DocumentLoader::commitLoad(const SharedBuffer& data)
    11751175{
    11761176    // Both unloading the old page and parsing the new page may execute JavaScript which destroys the datasource
    … …  
    11871187        return;
    11881188#endif
    1189     frameLoader->client().committedLoad(this, data, length);
     1189    frameLoader->client().committedLoad(this, data);
    11901190
    11911191    if (isMultipartReplacingLoad())
    … …  
    12161216#endif
    12171217
    1218 void DocumentLoader::commitData(const uint8_t* bytes, size_t length)
     1218void DocumentLoader::commitData(const SharedBuffer& data)
    12191219{
    12201220    if (!m_gotFirstByte) {
    … …  
    13141314
    13151315    ASSERT(m_frame->document()->parsing());
    1316     m_writer.addData(bytes, length);
    1317 }
    1318 
    1319 void DocumentLoader::dataReceived(CachedResource& resource, const uint8_t* data, int length)
     1316    m_writer.addData(data);
     1317}
     1318
     1319void DocumentLoader::dataReceived(CachedResource& resource, const SharedBuffer& buffer)
    13201320{
    13211321    ASSERT_UNUSED(resource, &resource == m_mainResource);
    1322     dataReceived(data, length);
    1323 }
    1324 
    1325 void DocumentLoader::dataReceived(const uint8_t* data, int length)
     1322    dataReceived(buffer);
     1323}
     1324
     1325void DocumentLoader::dataReceived(const SharedBuffer& buffer)
    13261326{
    13271327#if ENABLE(CONTENT_FILTERING)
    1328     if (m_contentFilter && !m_contentFilter->continueAfterDataReceived(data, length))
    1329         return;
    1330 #endif
    1331 
    1332     ASSERT(data);
    1333     ASSERT(length);
     1328    if (m_contentFilter && !m_contentFilter->continueAfterDataReceived(buffer.data(), buffer.size()))
     1329        return;
     1330#endif
     1331
     1332    ASSERT(buffer.data());
     1333    ASSERT(buffer.size());
    13341334    ASSERT(!m_response.isNull());
    13351335
    … …  
    13411341
    13421342    if (m_identifierForLoadWithoutResourceLoader)
    1343         frameLoader()->notifier().dispatchDidReceiveData(this, m_identifierForLoadWithoutResourceLoader, data, length, -1);
    1344 
    1345     m_applicationCacheHost->mainResourceDataReceived(data, length, -1, false);
     1343        frameLoader()->notifier().dispatchDidReceiveData(this, m_identifierForLoadWithoutResourceLoader, &buffer, buffer.size(), -1);
     1344
     1345    m_applicationCacheHost->mainResourceDataReceived(buffer, -1, false);
    13461346
    13471347    if (!isMultipartReplacingLoad())
    1348         commitLoad(data, length);
     1348        commitLoad(buffer);
    13491349}
    13501350
    … …  
    16151615
    16161616    ASSERT(m_frame->document());
    1617     commitData(m_parsedArchiveData->data(), mainResource.data().size());
     1617    commitData(*m_parsedArchiveData);
    16181618    return true;
    16191619#endif
    … …  
    22582258    frameLoader()->setupForReplace();
    22592259    m_committed = false;
    2260     RefPtr<FragmentedSharedBuffer> resourceData = mainResourceData();
    2261     commitLoad(resourceData->makeContiguous()->data(), resourceData->size());
     2260    commitLoad(mainResourceData()->makeContiguous());
    22622261}
    22632262
    … …  
    24112410
    24122411#if ENABLE(CONTENT_FILTERING)
    2413 void DocumentLoader::dataReceivedThroughContentFilter(const uint8_t* data, int size)
    2414 {
    2415     dataReceived(data, size);
     2412void DocumentLoader::dataReceivedThroughContentFilter(const SharedBuffer& buffer)
     2413{
     2414    dataReceived(buffer);
    24162415}
    24172416

  • trunk/Source/WebCore/loader/DocumentLoader.h

    r287321 r287684  
    8787class FragmentedSharedBuffer;
    8888class SWClientConnection;
     89class SharedBuffer;
    8990class SubresourceLoader;
    9091class SubstituteResource;
    … …  
    378379
    379380    // The WebKit layer calls this function when it's ready for the data to actually be added to the document.
    380     WEBCORE_EXPORT void commitData(const uint8_t* bytes, size_t length);
     381    WEBCORE_EXPORT void commitData(const SharedBuffer&);
    381382
    382383    ApplicationCacheHost& applicationCacheHost() const;
    … …  
    478479    void commitIfReady();
    479480    void setMainDocumentError(const ResourceError&);
    480     void commitLoad(const uint8_t*, int);
     481    void commitLoad(const SharedBuffer&);
    481482    void clearMainResourceLoader();
    482483
    … …  
    494495    WEBCORE_EXPORT void redirectReceived(CachedResource&, ResourceRequest&&, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&&) override;
    495496    WEBCORE_EXPORT void responseReceived(CachedResource&, const ResourceResponse&, CompletionHandler<void()>&&) override;
    496     WEBCORE_EXPORT void dataReceived(CachedResource&, const uint8_t* data, int length) override;
     497    WEBCORE_EXPORT void dataReceived(CachedResource&, const SharedBuffer&) override;
    497498    WEBCORE_EXPORT void notifyFinished(CachedResource&, const NetworkLoadMetrics&) override;
    498499#if USE(QUICK_LOOK)
    … …  
    504505#if ENABLE(CONTENT_FILTERING)
    505506    // ContentFilterClient
    506     WEBCORE_EXPORT void dataReceivedThroughContentFilter(const uint8_t*, int) final;
     507    WEBCORE_EXPORT void dataReceivedThroughContentFilter(const SharedBuffer&) final;
    507508    WEBCORE_EXPORT ResourceError contentFilterDidBlock(ContentFilterUnblockHandler, String&& unblockRequestDeniedScript) final;
    508509    WEBCORE_EXPORT void cancelMainResourceLoadForContentFilter(const ResourceError&) final;
    … …  
    510511#endif
    511512
    512     void dataReceived(const uint8_t* data, int length);
     513    void dataReceived(const SharedBuffer&);
    513514
    514515    bool maybeLoadEmpty();

  • trunk/Source/WebCore/loader/DocumentThreadableLoader.cpp

    r287653 r287684  
    439439}
    440440
    441 void DocumentThreadableLoader::dataReceived(CachedResource& resource, const uint8_t* data, int dataLength)
     441void DocumentThreadableLoader::dataReceived(CachedResource& resource, const SharedBuffer& buffer)
    442442{
    443443    ASSERT_UNUSED(resource, &resource == m_resource);
    444     didReceiveData(m_resource->identifier(), data, dataLength);
    445 }
    446 
    447 void DocumentThreadableLoader::didReceiveData(ResourceLoaderIdentifier, const uint8_t* data, int dataLength)
     444    didReceiveData(m_resource->identifier(), buffer);
     445}
     446
     447void DocumentThreadableLoader::didReceiveData(ResourceLoaderIdentifier, const SharedBuffer& buffer)
    448448{
    449449    ASSERT(m_client);
    … …  
    452452        return;
    453453
    454     m_client->didReceiveData(data, dataLength);
     454    m_client->didReceiveData(buffer);
    455455}
    456456
    … …  
    495495        if (options().filteringPolicy == ResponseFilteringPolicy::Disable) {
    496496            m_client->didReceiveResponse(identifier, response);
    497             if (auto* buffer = m_resource->resourceBuffer()) {
    498                 buffer->forEachSegment([&](auto& segment) {
    499                     m_client->didReceiveData(segment.data(), segment.size());
    500                 });
    501             }
     497            if (auto* buffer = m_resource->resourceBuffer())
     498                m_client->didReceiveData(*buffer);
    502499        } else {
    503500            ASSERT(response.type() == ResourceResponse::Type::Default);
    504501
    505502            m_client->didReceiveResponse(identifier, ResourceResponse::filter(response, m_options.credentials == FetchOptions::Credentials::Include ? ResourceResponse::PerformExposeAllHeadersCheck::No : ResourceResponse::PerformExposeAllHeadersCheck::Yes));
    506             if (auto* buffer = m_resource->resourceBuffer()) {
    507                 buffer->forEachSegment([&](auto& segment) {
    508                     m_client->didReceiveData(segment.data(), segment.size());
    509                 });
    510             }
     503            if (auto* buffer = m_resource->resourceBuffer())
     504                m_client->didReceiveData(*buffer);
    511505        }
    512506    }
    … …  
    669663    didReceiveResponse(identifier, response);
    670664
    671     if (data) {
    672         data->forEachSegment([&](auto& segment) {
    673             didReceiveData(identifier, segment.data(), segment.size());
    674         });
    675     }
     665    if (data)
     666        didReceiveData(identifier, *data);
    676667
    677668    const auto* timing = response.deprecatedNetworkLoadMetricsOrNull();

  • trunk/Source/WebCore/loader/DocumentThreadableLoader.h

    r286940 r287684  
    8787        void dataSent(CachedResource&, unsigned long long bytesSent, unsigned long long totalBytesToBeSent) override;
    8888        void responseReceived(CachedResource&, const ResourceResponse&, CompletionHandler<void()>&&) override;
    89         void dataReceived(CachedResource&, const uint8_t* data, int dataLength) override;
     89        void dataReceived(CachedResource&, const SharedBuffer&) override;
    9090        void redirectReceived(CachedResource&, ResourceRequest&&, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&&) override;
    9191        void finishedTimingForWorkerLoad(CachedResource&, const ResourceTiming&) override;
    … …  
    9494
    9595        void didReceiveResponse(ResourceLoaderIdentifier, const ResourceResponse&);
    96         void didReceiveData(ResourceLoaderIdentifier, const uint8_t* data, int dataLength);
     96        void didReceiveData(ResourceLoaderIdentifier, const SharedBuffer&);
    9797        void didFinishLoading(ResourceLoaderIdentifier);
    9898        void didFail(ResourceLoaderIdentifier, const ResourceError&);

  • trunk/Source/WebCore/loader/DocumentWriter.cpp

    r284934 r287684  
    265265}
    266266
    267 void DocumentWriter::addData(const uint8_t* bytes, size_t length)
     267void DocumentWriter::addData(const SharedBuffer& data)
    268268{
    269269    // FIXME: Change these to ASSERT once https://bugs.webkit.org/show_bug.cgi?id=80427 has been resolved.
    … …  
    274274    }
    275275    ASSERT(m_parser);
    276     m_parser->appendBytes(*this, bytes, length);
     276    m_parser->appendBytes(*this, data.data(), data.size());
    277277}
    278278

  • trunk/Source/WebCore/loader/DocumentWriter.h

    r284934 r287684  
    3737class DocumentParser;
    3838class Frame;
     39class SharedBuffer;
    3940class TextResourceDecoder;
    4041
    … …  
    4849    bool begin();
    4950    bool begin(const URL&, bool dispatchWindowObjectAvailable = true, Document* ownerDocument = nullptr);
    50     void addData(const uint8_t* bytes, size_t length);
     51    void addData(const SharedBuffer&);
    5152    void insertDataSynchronously(const String&); // For an internal use only to prevent the parser from yielding.
    5253    WEBCORE_EXPORT void end();

  • trunk/Source/WebCore/loader/EmptyClients.cpp

    r287321 r287684  
    871871}
    872872
    873 void EmptyFrameLoaderClient::committedLoad(DocumentLoader*, const uint8_t*, int)
     873void EmptyFrameLoaderClient::committedLoad(DocumentLoader*, const SharedBuffer&)
    874874{
    875875}

  • trunk/Source/WebCore/loader/EmptyFrameLoaderClient.h

    r283179 r287684  
    120120    void didReplaceMultipartContent() final;
    121121
    122     void committedLoad(DocumentLoader*, const uint8_t*, int) final;
     122    void committedLoad(DocumentLoader*, const SharedBuffer&) final;
    123123    void finishedLoading(DocumentLoader*) final;
    124124

  • trunk/Source/WebCore/loader/FrameLoader.cpp

    r287353 r287684  
    16881688    ResourceError error;
    16891689    requestFromDelegate(request, identifier, error);
    1690     notifier().sendRemainingDelegateMessages(m_documentLoader.get(), identifier, request, ResourceResponse(url, String(), -1, String()), 0, -1, -1, error);
     1690    notifier().sendRemainingDelegateMessages(m_documentLoader.get(), identifier, request, ResourceResponse(url, String(), -1, String()), nullptr, -1, -1, error);
    16911691
    16921692    url = request.url();
    … …  
    20882088
    20892089        // Send remaining notifications for the main resource.
    2090         notifier().sendRemainingDelegateMessages(m_documentLoader.get(), mainResourceIdentifier, mainResourceRequest, ResourceResponse(),
    2091             nullptr, static_cast<int>(m_documentLoader->response().expectedContentLength()), 0, mainResouceError);
     2090        notifier().sendRemainingDelegateMessages(m_documentLoader.get(), mainResourceIdentifier, mainResourceRequest, ResourceResponse(), nullptr, static_cast<int>(m_documentLoader->response().expectedContentLength()), 0, mainResouceError);
    20922091
    20932092        Vector<Ref<Frame>> targetFrames;
    … …  
    21372136            // However, with today's computers and networking speeds, this won't happen in practice.
    21382137            // Could be an issue with a giant local file.
    2139             notifier().sendRemainingDelegateMessages(m_documentLoader.get(), identifier, request, response, 0, static_cast<int>(response.expectedContentLength()), 0, error);
     2138            notifier().sendRemainingDelegateMessages(m_documentLoader.get(), identifier, request, response, nullptr, static_cast<int>(response.expectedContentLength()), 0, error);
    21402139        }
    21412140
    … …  
    31673166        }
    31683167    }
    3169     notifier().sendRemainingDelegateMessages(m_documentLoader.get(), identifier, request, response, data ? data->data() : nullptr, data ? data->size() : 0, -1, error);
     3168
     3169    notifier().sendRemainingDelegateMessages(m_documentLoader.get(), identifier, request, response, data.get(), data ? data->size() : 0, -1, error);
    31703170    return identifier;
    31713171}
    … …  
    36483648    ResourceResponse response = resource.response();
    36493649    response.setSource(ResourceResponse::Source::MemoryCache);
    3650     notifier().sendRemainingDelegateMessages(m_documentLoader.get(), identifier, newRequest, response, 0, resource.encodedSize(), 0, error);
     3650    notifier().sendRemainingDelegateMessages(m_documentLoader.get(), identifier, newRequest, response, nullptr, resource.encodedSize(), 0, error);
    36513651}
    36523652

  • trunk/Source/WebCore/loader/FrameLoaderClient.h

    r287021 r287684  
    88 *
    99 * 1.  Redistributions of source code must retain the above copyright
    10  *     notice, this list of conditions and the following disclaimer. 
     10 *     notice, this list of conditions and the following disclaimer.
    1111 * 2.  Redistributions in binary form must reproduce the above copyright
    1212 *     notice, this list of conditions and the following disclaimer in the
    … …  
    5151
    5252#if PLATFORM(COCOA)
    53 #ifdef __OBJC__ 
     53#ifdef __OBJC__
    5454#import <Foundation/Foundation.h>
    5555typedef id RemoteAXObjectRef;
    … …  
    9999class ResourceResponse;
    100100class SecurityOrigin;
    101 class FragmentedSharedBuffer;
     101class SharedBuffer;
    102102class SubstituteData;
    103103class Widget;
    … …  
    215215    virtual void didReplaceMultipartContent() = 0;
    216216
    217     virtual void committedLoad(DocumentLoader*, const uint8_t*, int) = 0;
     217    virtual void committedLoad(DocumentLoader*, const SharedBuffer&) = 0;
    218218    virtual void finishedLoading(DocumentLoader*) = 0;
    219    
     219
    220220    virtual void updateGlobalHistory() = 0;
    221221    virtual void updateGlobalHistoryRedirectLinks() = 0;
    … …  
    273273
    274274    virtual String overrideContentSecurityPolicy() const { return String(); }
    275    
     275
    276276    virtual void savePlatformDataToCachedFrame(CachedFrame*) = 0;
    277277    virtual void transitionToCommittedFromCachedFrame(CachedFrame*) = 0;
    … …  
    382382
    383383    virtual AllowsContentJavaScript allowsContentJavaScriptFromMostRecentNavigation() const { return AllowsContentJavaScript::Yes; }
    384    
     384
    385385#if ENABLE(APP_BOUND_DOMAINS)
    386386    virtual bool shouldEnableInAppBrowserPrivacyProtections() const { return false; }
    … …  
    391391    virtual bool shouldUsePDFPlugin(const String&, StringView) const { return false; }
    392392#endif
    393    
     393
    394394    virtual bool isParentProcessAFullWebBrowser() const { return false; }
    395395};

  • trunk/Source/WebCore/loader/MediaResourceLoader.cpp

    r284093 r287684  
    232232}
    233233
    234 void MediaResource::dataReceived(CachedResource& resource, const uint8_t* data, int dataLength)
    235 {
    236     ASSERT_UNUSED(resource, &resource == m_resource);
    237 
    238     RefPtr<MediaResource> protectedThis(this);
    239     if (m_client)
    240         m_client->dataReceived(*this, data, dataLength);
     234void MediaResource::dataReceived(CachedResource& resource, const SharedBuffer& buffer)
     235{
     236    ASSERT_UNUSED(resource, &resource == m_resource);
     237
     238    RefPtr<MediaResource> protectedThis(this);
     239    if (m_client)
     240        m_client->dataReceived(*this, buffer);
    241241}
    242242

  • trunk/Source/WebCore/loader/MediaResourceLoader.h

    r278516 r287684  
    8787    bool shouldCacheResponse(CachedResource&, const ResourceResponse&) override;
    8888    void dataSent(CachedResource&, unsigned long long, unsigned long long) override;
    89     void dataReceived(CachedResource&, const uint8_t*, int) override;
     89    void dataReceived(CachedResource&, const SharedBuffer&) override;
    9090    void notifyFinished(CachedResource&, const NetworkLoadMetrics&) override;
    9191

  • trunk/Source/WebCore/loader/NetscapePlugInStreamLoader.cpp

    r287021 r287684  
    142142}
    143143
    144 void NetscapePlugInStreamLoader::didReceiveData(const uint8_t* data, unsigned length, long long encodedDataLength, DataPayloadType dataPayloadType)
    145 {
    146     didReceiveDataOrBuffer(data, length, nullptr, encodedDataLength, dataPayloadType);
    147 }
    148 
    149 void NetscapePlugInStreamLoader::didReceiveBuffer(Ref<FragmentedSharedBuffer>&& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)
    150 {
    151     didReceiveDataOrBuffer(nullptr, 0, WTFMove(buffer), encodedDataLength, dataPayloadType);
    152 }
    153 
    154 void NetscapePlugInStreamLoader::didReceiveDataOrBuffer(const uint8_t* data, int length, RefPtr<FragmentedSharedBuffer>&& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)
     144void NetscapePlugInStreamLoader::didReceiveData(const SharedBuffer& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)
    155145{
    156146    Ref<NetscapePlugInStreamLoader> protectedThis(*this);
    157147
    158     if (m_client) {
    159         if (buffer) {
    160             buffer->forEachSegment([&](auto& segment) {
    161                 m_client->didReceiveData(this, segment.data(), segment.size());
    162             });
    163         } else
    164             m_client->didReceiveData(this, data, length);
    165     }
     148    if (m_client)
     149        m_client->didReceiveData(this, buffer);
    166150
    167     ResourceLoader::didReceiveDataOrBuffer(data, length, WTFMove(buffer), encodedDataLength, dataPayloadType);
     151    ResourceLoader::didReceiveData(buffer, encodedDataLength, dataPayloadType);
    168152}
    169153

  • trunk/Source/WebCore/loader/NetscapePlugInStreamLoader.h

    r287021 r287684  
    3737
    3838class NetscapePlugInStreamLoader;
     39class SharedBuffer;
    3940
    4041class NetscapePlugInStreamLoaderClient : public CanMakeWeakPtr<NetscapePlugInStreamLoaderClient> {
    … …  
    4243    virtual void willSendRequest(NetscapePlugInStreamLoader*, ResourceRequest&&, const ResourceResponse& redirectResponse, CompletionHandler<void(ResourceRequest&&)>&&) = 0;
    4344    virtual void didReceiveResponse(NetscapePlugInStreamLoader*, const ResourceResponse&) = 0;
    44     virtual void didReceiveData(NetscapePlugInStreamLoader*, const uint8_t*, int) = 0;
     45    virtual void didReceiveData(NetscapePlugInStreamLoader*, const SharedBuffer&) = 0;
    4546    virtual void didFail(NetscapePlugInStreamLoader*, const ResourceError&) = 0;
    4647    virtual void didFinishLoading(NetscapePlugInStreamLoader*) { }
    … …  
    6364    void willSendRequest(ResourceRequest&&, const ResourceResponse& redirectResponse, CompletionHandler<void(ResourceRequest&&)>&& callback) override;
    6465    void didReceiveResponse(const ResourceResponse&, CompletionHandler<void()>&& policyCompletionHandler) override;
    65     void didReceiveData(const uint8_t*, unsigned, long long encodedDataLength, DataPayloadType) override;
    66     void didReceiveBuffer(Ref<FragmentedSharedBuffer>&&, long long encodedDataLength, DataPayloadType) override;
     66    void didReceiveData(const SharedBuffer&, long long encodedDataLength, DataPayloadType) override;
    6767    void didFinishLoading(const NetworkLoadMetrics&) override;
    6868    void didFail(const ResourceError&) override;
    … …  
    7575    void didCancel(const ResourceError&) override;
    7676
    77     void didReceiveDataOrBuffer(const uint8_t*, int, RefPtr<FragmentedSharedBuffer>&&, long long encodedDataLength, DataPayloadType);
    78 
    7977    void notifyDone();
    8078

  • trunk/Source/WebCore/loader/ResourceLoadNotifier.cpp

    r287414 r287684  
    4040#include "ProgressTracker.h"
    4141#include "ResourceLoader.h"
     42#include "SharedBuffer.h"
    4243
    4344#if USE(QUICK_LOOK)
    … …  
    7980}
    8081
    81 void ResourceLoadNotifier::didReceiveData(ResourceLoader* loader, const uint8_t* data, int dataLength, int encodedDataLength)
    82 {
    83     if (Page* page = m_frame.page())
    84         page->progress().incrementProgress(loader->identifier(), dataLength);
    85 
    86     dispatchDidReceiveData(loader->documentLoader(), loader->identifier(), data, dataLength, encodedDataLength);
     82void ResourceLoadNotifier::didReceiveData(ResourceLoader* loader, const SharedBuffer& buffer, int encodedDataLength)
     83{
     84    if (Page* page = m_frame.page())
     85        page->progress().incrementProgress(loader->identifier(), buffer.size());
     86
     87    dispatchDidReceiveData(loader->documentLoader(), loader->identifier(), &buffer, buffer.size(), encodedDataLength);
    8788}
    8889
    … …  
    154155}
    155156
    156 void ResourceLoadNotifier::dispatchDidReceiveData(DocumentLoader* loader, ResourceLoaderIdentifier identifier, const uint8_t* data, int dataLength, int encodedDataLength)
    157 {
    158     // Notifying the FrameLoaderClient may cause the frame to be destroyed.
    159     Ref<Frame> protect(m_frame);
    160     m_frame.loader().client().dispatchDidReceiveContentLength(loader, identifier, dataLength);
    161 
    162     InspectorInstrumentation::didReceiveData(&m_frame, identifier, data, dataLength, encodedDataLength);
     157void ResourceLoadNotifier::dispatchDidReceiveData(DocumentLoader* loader, ResourceLoaderIdentifier identifier, const SharedBuffer* buffer, int expectedDataLength, int encodedDataLength)
     158{
     159    // Notifying the FrameLoaderClient may cause the frame to be destroyed.
     160    Ref<Frame> protect(m_frame);
     161    m_frame.loader().client().dispatchDidReceiveContentLength(loader, identifier, expectedDataLength);
     162
     163    InspectorInstrumentation::didReceiveData(&m_frame, identifier, buffer ? *buffer : SharedBuffer::create(), encodedDataLength);
    163164}
    164165
    … …  
    181182}
    182183
    183 void ResourceLoadNotifier::sendRemainingDelegateMessages(DocumentLoader* loader, ResourceLoaderIdentifier identifier, const ResourceRequest& request, const ResourceResponse& response, const uint8_t* data, int dataLength, int encodedDataLength, const ResourceError& error)
     184void ResourceLoadNotifier::sendRemainingDelegateMessages(DocumentLoader* loader, ResourceLoaderIdentifier identifier, const ResourceRequest& request, const ResourceResponse& response, const SharedBuffer* buffer, int expectedDataLength, int encodedDataLength, const ResourceError& error)
    184185{
    185186    // If the request is null, willSendRequest cancelled the load. We should
    … …  
    194195        dispatchDidReceiveResponse(loader, identifier, response);
    195196
    196     if (dataLength > 0)
    197         dispatchDidReceiveData(loader, identifier, data, dataLength, encodedDataLength);
     197    if (expectedDataLength > 0)
     198        dispatchDidReceiveData(loader, identifier, buffer, expectedDataLength, encodedDataLength);
    198199
    199200    if (error.isNull()) {

  • trunk/Source/WebCore/loader/ResourceLoadNotifier.h

    r287414 r287684  
    4545class ResourceRequest;
    4646class ResourceResponse;
     47class SharedBuffer;
    4748
    4849class ResourceLoadNotifier {
    … …  
    5657    void willSendRequest(ResourceLoader*, ResourceRequest&, const ResourceResponse& redirectResponse);
    5758    void didReceiveResponse(ResourceLoader*, const ResourceResponse&);
    58     void didReceiveData(ResourceLoader*, const uint8_t*, int dataLength, int encodedDataLength);
     59    void didReceiveData(ResourceLoader*, const SharedBuffer&, int encodedDataLength);
    5960    void didFinishLoad(ResourceLoader*, const NetworkLoadMetrics&);
    6061    void didFailToLoad(ResourceLoader*, const ResourceError&);
    … …  
    6364    void dispatchWillSendRequest(DocumentLoader*, ResourceLoaderIdentifier, ResourceRequest&, const ResourceResponse& redirectResponse, const CachedResource*);
    6465    void dispatchDidReceiveResponse(DocumentLoader*, ResourceLoaderIdentifier, const ResourceResponse&, ResourceLoader* = nullptr);
    65     void dispatchDidReceiveData(DocumentLoader*, ResourceLoaderIdentifier, const uint8_t* data, int dataLength, int encodedDataLength);
     66    void dispatchDidReceiveData(DocumentLoader*, ResourceLoaderIdentifier, const SharedBuffer*, int expectedDataLength, int encodedDataLength);
    6667    void dispatchDidFinishLoading(DocumentLoader*, ResourceLoaderIdentifier, const NetworkLoadMetrics&, ResourceLoader*);
    6768    void dispatchDidFailLoading(DocumentLoader*, ResourceLoaderIdentifier, const ResourceError&);
    6869
    69     void sendRemainingDelegateMessages(DocumentLoader*, ResourceLoaderIdentifier, const ResourceRequest&, const ResourceResponse&, const uint8_t* data, int dataLength, int encodedDataLength, const ResourceError&);
     70    void sendRemainingDelegateMessages(DocumentLoader*, ResourceLoaderIdentifier, const ResourceRequest&, const ResourceResponse&, const SharedBuffer*, int expectedDataLength, int encodedDataLength, const ResourceError&);
    7071
    7172    bool isInitialRequestIdentifier(ResourceLoaderIdentifier identifier)

  • trunk/Source/WebCore/loader/ResourceLoader.cpp

    r287021 r287684  
    300300        auto dataSize = decodeResult->data.size();
    301301        ResourceResponse dataResponse = ResourceResponse::dataURLResponse(url, decodeResult.value());
    302         this->didReceiveResponse(dataResponse, [this, protectedThis = WTFMove(protectedThis), dataSize, data = SharedBuffer::create(WTFMove(decodeResult->data))]() mutable {
     302        this->didReceiveResponse(dataResponse, [this, protectedThis = WTFMove(protectedThis), dataSize, data = SharedBuffer::create(WTFMove(decodeResult->data))]() {
    303303            if (!this->reachedTerminalState() && dataSize && m_request.httpMethod() != "HEAD")
    304                 this->didReceiveBuffer(WTFMove(data), dataSize, DataPayloadWholeResource);
     304                this->didReceiveBuffer(data, dataSize, DataPayloadWholeResource);
    305305
    306306            if (!this->reachedTerminalState()) {
    … …  
    329329}
    330330
    331 void ResourceLoader::addDataOrBuffer(const uint8_t* data, unsigned length, FragmentedSharedBuffer* buffer, DataPayloadType dataPayloadType)
     331void ResourceLoader::addBuffer(const FragmentedSharedBuffer& buffer, DataPayloadType dataPayloadType)
    332332{
    333333    if (m_options.dataBufferingPolicy == DataBufferingPolicy::DoNotBufferData)
    … …  
    337337        m_resourceData.reset();
    338338
    339     if (buffer)
    340         m_resourceData.append(*buffer);
    341     else
    342         m_resourceData.append(data, length);
     339    m_resourceData.append(buffer);
    343340}
    344341
    … …  
    540537}
    541538
    542 void ResourceLoader::didReceiveData(const uint8_t* data, unsigned length, long long encodedDataLength, DataPayloadType dataPayloadType)
     539void ResourceLoader::didReceiveData(const SharedBuffer& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)
    543540{
    544541    // The following assertions are not quite valid here, since a subclass
    … …  
    548545    // ASSERT(!m_reachedTerminalState);
    549546
    550     didReceiveDataOrBuffer(data, length, nullptr, encodedDataLength, dataPayloadType);
    551 }
    552 
    553 void ResourceLoader::didReceiveBuffer(Ref<FragmentedSharedBuffer>&& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)
    554 {
    555     didReceiveDataOrBuffer(nullptr, 0, WTFMove(buffer), encodedDataLength, dataPayloadType);
    556 }
    557 
    558 void ResourceLoader::didReceiveDataOrBuffer(const uint8_t* data, unsigned length, RefPtr<FragmentedSharedBuffer>&& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)
    559 {
    560     // This method should only get data+length *OR* a FragmentedSharedBuffer.
    561     ASSERT(!buffer || (!data && !length));
    562 
     547    didReceiveBuffer(buffer, encodedDataLength, dataPayloadType);
     548}
     549
     550void ResourceLoader::didReceiveBuffer(const FragmentedSharedBuffer& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)
     551{
    563552    // Protect this in this delegate method since the additional processing can do
    564553    // anything including possibly derefing this; one example of this is Radar 3266216.
    565554    Ref<ResourceLoader> protectedThis(*this);
    566555
    567     addDataOrBuffer(data, length, buffer.get(), dataPayloadType);
     556    addBuffer(buffer, dataPayloadType);
    568557
    569558    // FIXME: If we get a resource with more than 2B bytes, this code won't do the right thing.
    … …  
    571560    // Could be an issue with a giant local file.
    572561    if (m_options.sendLoadCallbacks == SendCallbackPolicy::SendCallbacks && m_frame)
    573         frameLoader()->notifier().didReceiveData(this, buffer ? buffer->makeContiguous()->data() : data, buffer ? buffer->size() : length, static_cast<int>(encodedDataLength));
     562        frameLoader()->notifier().didReceiveData(this, buffer.makeContiguous(), static_cast<int>(encodedDataLength));
    574563}
    575564
    … …  
    730719}
    731720
    732 void ResourceLoader::didReceiveData(ResourceHandle*, const uint8_t* data, unsigned length, int encodedDataLength)
    733 {
    734     didReceiveData(data, length, encodedDataLength, DataPayloadBytes);
    735 }
    736 
    737 void ResourceLoader::didReceiveBuffer(ResourceHandle*, Ref<FragmentedSharedBuffer>&& buffer, int encodedDataLength)
    738 {
    739     didReceiveBuffer(WTFMove(buffer), encodedDataLength, DataPayloadBytes);
     721void ResourceLoader::didReceiveData(ResourceHandle*, const SharedBuffer& buffer, int encodedDataLength)
     722{
     723    didReceiveData(buffer, encodedDataLength, DataPayloadBytes);
     724}
     725
     726void ResourceLoader::didReceiveBuffer(ResourceHandle*, const FragmentedSharedBuffer& buffer, int encodedDataLength)
     727{
     728    didReceiveBuffer(buffer, encodedDataLength, DataPayloadBytes);
    740729}
    741730

  • trunk/Source/WebCore/loader/ResourceLoader.h

    r287414 r287684  
    108108    virtual void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent);
    109109    virtual void didReceiveResponse(const ResourceResponse&, CompletionHandler<void()>&& policyCompletionHandler);
    110     virtual void didReceiveData(const uint8_t*, unsigned, long long encodedDataLength, DataPayloadType);
    111     virtual void didReceiveBuffer(Ref<FragmentedSharedBuffer>&&, long long encodedDataLength, DataPayloadType);
     110    virtual void didReceiveData(const SharedBuffer&, long long encodedDataLength, DataPayloadType);
     111    virtual void didReceiveBuffer(const FragmentedSharedBuffer&, long long encodedDataLength, DataPayloadType);
    112112    virtual void didFinishLoading(const NetworkLoadMetrics&);
    113113    virtual void didFail(const ResourceError&);
    … …  
    168168    bool wasCancelled() const { return m_cancellationStatus >= Cancelled; }
    169169
    170     void didReceiveDataOrBuffer(const uint8_t*, unsigned, RefPtr<FragmentedSharedBuffer>&&, long long encodedDataLength, DataPayloadType);
    171    
    172170    void setReferrerPolicy(ReferrerPolicy referrerPolicy) { m_options.referrerPolicy = referrerPolicy; }
    173171    ReferrerPolicy referrerPolicy() const { return m_options.referrerPolicy; }
    … …  
    193191    virtual void didCancel(const ResourceError&) = 0;
    194192
    195     void addDataOrBuffer(const uint8_t*, unsigned, FragmentedSharedBuffer*, DataPayloadType);
     193    void addBuffer(const FragmentedSharedBuffer&, DataPayloadType);
    196194    void loadDataURL();
    197195    void finishNetworkLoad();
    … …  
    203201    void didReceiveResponseAsync(ResourceHandle*, ResourceResponse&&, CompletionHandler<void()>&&) override;
    204202    void willSendRequestAsync(ResourceHandle*, ResourceRequest&&, ResourceResponse&&, CompletionHandler<void(ResourceRequest&&)>&&) override;
    205     void didReceiveData(ResourceHandle*, const uint8_t*, unsigned, int encodedDataLength) override;
    206     void didReceiveBuffer(ResourceHandle*, Ref<FragmentedSharedBuffer>&&, int encodedDataLength) override;
     203    void didReceiveData(ResourceHandle*, const SharedBuffer&, int encodedDataLength) override;
     204    void didReceiveBuffer(ResourceHandle*, const FragmentedSharedBuffer&, int encodedDataLength) override;
    207205    void didFinishLoading(ResourceHandle*, const NetworkLoadMetrics&) override;
    208206    void didFail(ResourceHandle*, const ResourceError&) override;

  • trunk/Source/WebCore/loader/SubresourceLoader.cpp

    r287021 r287684  
    519519}
    520520
    521 void SubresourceLoader::didReceiveData(const uint8_t* data, unsigned length, long long encodedDataLength, DataPayloadType dataPayloadType)
     521void SubresourceLoader::didReceiveBuffer(const FragmentedSharedBuffer& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)
    522522{
    523523#if USE(QUICK_LOOK)
    524524    if (auto previewLoader = m_previewLoader.get()) {
    525         if (previewLoader->didReceiveData(data, length))
     525        if (previewLoader->didReceiveData(buffer.makeContiguous()))
    526526            return;
    527527    }
    528528#endif
    529529
    530     didReceiveDataOrBuffer(data, length, nullptr, encodedDataLength, dataPayloadType);
    531 }
    532 
    533 void SubresourceLoader::didReceiveBuffer(Ref<FragmentedSharedBuffer>&& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)
    534 {
    535 #if USE(QUICK_LOOK)
    536     if (auto previewLoader = m_previewLoader.get()) {
    537         if (previewLoader->didReceiveBuffer(buffer.get()))
    538             return;
    539     }
    540 #endif
    541 
    542     didReceiveDataOrBuffer(nullptr, 0, WTFMove(buffer), encodedDataLength, dataPayloadType);
    543 }
    544 
    545 void SubresourceLoader::didReceiveDataOrBuffer(const uint8_t* data, int length, RefPtr<FragmentedSharedBuffer>&& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)
    546 {
    547530    ASSERT(m_resource);
    548531
    … …  
    556539    Ref<SubresourceLoader> protectedThis(*this);
    557540
    558     ResourceLoader::didReceiveDataOrBuffer(data, length, buffer.copyRef(), encodedDataLength, dataPayloadType);
     541    ResourceLoader::didReceiveBuffer(buffer, encodedDataLength, dataPayloadType);
    559542
    560543    if (!m_loadingMultipartContent) {
    … …  
    562545            m_resource->updateBuffer(*resourceData);
    563546        else
    564             m_resource->updateData(buffer ? buffer->makeContiguous()->data() : data, buffer ? buffer->size() : length);
     547            m_resource->updateData(buffer.makeContiguous());
    565548    }
    566549}

  • trunk/Source/WebCore/loader/SubresourceLoader.h

    r287021 r287684  
    7474    void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent) override;
    7575    void didReceiveResponse(const ResourceResponse&, CompletionHandler<void()>&& policyCompletionHandler) override;
    76     void didReceiveData(const uint8_t*, unsigned, long long encodedDataLength, DataPayloadType) override;
    77     void didReceiveBuffer(Ref<FragmentedSharedBuffer>&&, long long encodedDataLength, DataPayloadType) override;
     76    void didReceiveBuffer(const FragmentedSharedBuffer&, long long encodedDataLength, DataPayloadType) override;
    7877    void didFinishLoading(const NetworkLoadMetrics&) override;
    7978    void didFail(const ResourceError&) override;
    … …  
    9392    Expected<void, String> checkRedirectionCrossOriginAccessControl(const ResourceRequest& previousRequest, const ResourceResponse&, ResourceRequest& newRequest);
    9493
    95     void didReceiveDataOrBuffer(const uint8_t*, int, RefPtr<FragmentedSharedBuffer>&&, long long encodedDataLength, DataPayloadType);
     94    void didReceiveDataOrBuffer(const FragmentedSharedBuffer&, long long encodedDataLength, DataPayloadType);
    9695
    9796    void notifyDone(LoadCompletionType);

  • trunk/Source/WebCore/loader/SubstituteResource.h

    r287021 r287684  
    3939    const ResourceResponse& response() const { return m_response; }
    4040    FragmentedSharedBuffer& data() const { return static_reference_cast<FragmentedSharedBuffer>(Ref { *m_data.get() }); }
    41     void append(const uint8_t* data, int length) { m_data.append(data, length); }
     41    void append(const SharedBuffer& buffer) { m_data.append(buffer); }
    4242    void clear() { m_data.empty(); }
    4343

  • trunk/Source/WebCore/loader/ThreadableLoaderClient.h

    r282712 r287684  
    3838class ResourceResponse;
    3939class ResourceTiming;
     40class SharedBuffer;
    4041
    4142class ThreadableLoaderClient {
    … …  
    4546
    4647    virtual void didReceiveResponse(ResourceLoaderIdentifier, const ResourceResponse&) { }
    47     virtual void didReceiveData(const uint8_t*, int /*dataLength*/) { }
     48    virtual void didReceiveData(const SharedBuffer&) { }
    4849    virtual void didFinishLoading(ResourceLoaderIdentifier) { }
    4950    virtual void didFail(const ResourceError&) { }

  • trunk/Source/WebCore/loader/ThreadableLoaderClientWrapper.h

    r282712 r287684  
    6767    }
    6868
    69     void didReceiveData(const uint8_t* data, int dataLength)
     69    void didReceiveData(const SharedBuffer& buffer)
    7070    {
    7171        if (m_client)
    72             m_client->didReceiveData(data, dataLength);
     72            m_client->didReceiveData(buffer);
    7373    }
    7474

  • trunk/Source/WebCore/loader/WorkerThreadableLoader.cpp

    r283295 r287684  
    232232}
    233233
    234 void WorkerThreadableLoader::MainThreadBridge::didReceiveData(const uint8_t* data, int dataLength)
    235 {
    236     Vector<uint8_t> buffer(data, dataLength);
    237     m_loaderProxy.postTaskForModeToWorkerOrWorkletGlobalScope([protectedWorkerClientWrapper = Ref { *m_workerClientWrapper }, workerRequestIdentifier = m_workerRequestIdentifier, buffer = WTFMove(buffer)] (ScriptExecutionContext& context) mutable {
    238         ASSERT(context.isWorkerGlobalScope() || context.isWorkletGlobalScope());
    239         protectedWorkerClientWrapper->didReceiveData(buffer.data(), buffer.size());
    240         if (is<WorkerGlobalScope>(context))
    241             InspectorInstrumentation::didReceiveData(downcast<WorkerGlobalScope>(context), workerRequestIdentifier, buffer.data(), buffer.size());
     234void WorkerThreadableLoader::MainThreadBridge::didReceiveData(const SharedBuffer& data)
     235{
     236    m_loaderProxy.postTaskForModeToWorkerOrWorkletGlobalScope([protectedWorkerClientWrapper = Ref { *m_workerClientWrapper }, workerRequestIdentifier = m_workerRequestIdentifier, buffer = Ref { data }] (ScriptExecutionContext& context) {
     237        ASSERT(context.isWorkerGlobalScope() || context.isWorkletGlobalScope());
     238        protectedWorkerClientWrapper->didReceiveData(buffer);
     239        if (is<WorkerGlobalScope>(context))
     240            InspectorInstrumentation::didReceiveData(downcast<WorkerGlobalScope>(context), workerRequestIdentifier, buffer);
    242241    }, m_taskMode);
    243242}

  • trunk/Source/WebCore/loader/WorkerThreadableLoader.h

    r282712 r287684  
    106106        void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent) override;
    107107        void didReceiveResponse(ResourceLoaderIdentifier, const ResourceResponse&) override;
    108         void didReceiveData(const uint8_t*, int dataLength) override;
     108        void didReceiveData(const SharedBuffer&) override;
    109109        void didFinishLoading(ResourceLoaderIdentifier) override;
    110110        void didFail(const ResourceError&) override;

  • trunk/Source/WebCore/loader/appcache/ApplicationCacheHost.cpp

    r287021 r287684  
    150150}
    151151
    152 void ApplicationCacheHost::mainResourceDataReceived(const uint8_t*, int, long long, bool)
     152void ApplicationCacheHost::mainResourceDataReceived(const SharedBuffer&, long long, bool)
    153153{
    154154}

  • trunk/Source/WebCore/loader/appcache/ApplicationCacheHost.h

    r287021 r287684  
    9696    void maybeLoadMainResourceForRedirect(const ResourceRequest&, SubstituteData&);
    9797    bool maybeLoadFallbackForMainResponse(const ResourceRequest&, const ResourceResponse&);
    98     void mainResourceDataReceived(const uint8_t* data, int length, long long encodedDataLength, bool allAtOnce);
     98    void mainResourceDataReceived(const SharedBuffer&, long long encodedDataLength, bool allAtOnce);
    9999    void finishedLoadingMainResource();
    100100    void failedLoadingMainResource();

  • trunk/Source/WebCore/loader/appcache/ApplicationCacheResource.cpp

    r287021 r287684  
    5252void ApplicationCacheResource::deliver(ResourceLoader& loader)
    5353{
    54     loader.deliverResponseAndData(response(), m_path.isEmpty() ? data().makeContiguous() : SharedBuffer::createWithContentsOfFile(m_path));
     54    if (m_path.isEmpty())
     55        loader.deliverResponseAndData(response(), RefPtr { &data() });
     56    else
     57        loader.deliverResponseAndData(response(), SharedBuffer::createWithContentsOfFile(m_path));
    5558}
    5659

  • trunk/Source/WebCore/loader/appcache/ApplicationCacheResourceLoader.cpp

    r286983 r287684  
    100100}
    101101
    102 void ApplicationCacheResourceLoader::dataReceived(CachedResource&, const uint8_t* data, int length)
     102void ApplicationCacheResourceLoader::dataReceived(CachedResource&, const SharedBuffer& buffer)
    103103{
    104     m_applicationCacheResource->append(data, length);
     104    m_applicationCacheResource->append(buffer);
    105105}
    106106

  • trunk/Source/WebCore/loader/appcache/ApplicationCacheResourceLoader.h

    r278516 r287684  
    5757    // CachedRawResourceClient
    5858    void responseReceived(CachedResource&, const ResourceResponse&, CompletionHandler<void()>&&) final;
    59     void dataReceived(CachedResource&, const uint8_t* data, int dataLength) final;
     59    void dataReceived(CachedResource&, const SharedBuffer&) final;
    6060    void redirectReceived(CachedResource&, ResourceRequest&&, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&&) final;
    6161    void notifyFinished(CachedResource&, const NetworkLoadMetrics&) final;

  • trunk/Source/WebCore/loader/cache/CachedImage.cpp

    r287286 r287684  
    469469}
    470470
    471 void CachedImage::updateBufferInternal(const FragmentedSharedBuffer& data)
     471void CachedImage::updateBufferInternal(const SharedBuffer& data)
    472472{
    473473    m_data = data.makeContiguous();
    … …  
    556556}
    557557
    558 void CachedImage::updateBuffer(const FragmentedSharedBuffer& data)
     558void CachedImage::updateBuffer(const FragmentedSharedBuffer& buffer)
    559559{
    560560    ASSERT(dataBufferingPolicy() == DataBufferingPolicy::BufferData);
     561    updateBufferInternal(buffer.makeContiguous());
     562    CachedResource::updateBuffer(buffer);
     563}
     564
     565void CachedImage::updateData(const SharedBuffer& data)
     566{
     567    ASSERT(dataBufferingPolicy() == DataBufferingPolicy::DoNotBufferData);
    561568    updateBufferInternal(data);
    562     CachedResource::updateBuffer(data);
    563 }
    564 
    565 void CachedImage::updateData(const uint8_t* data, unsigned length)
    566 {
    567     ASSERT(dataBufferingPolicy() == DataBufferingPolicy::DoNotBufferData);
    568     updateBufferInternal(SharedBuffer::create(data, length));
    569     CachedResource::updateData(data, length);
     569    CachedResource::updateData(data);
    570570}
    571571

  • trunk/Source/WebCore/loader/cache/CachedImage.h

    r287286 r287684  
    129129    void didUpdateImageData();
    130130    EncodedDataStatus updateImageData(bool allDataReceived);
    131     void updateData(const uint8_t* data, unsigned length) override;
     131    void updateData(const SharedBuffer&) override;
    132132    void error(CachedResource::Status) override;
    133133    void responseReceived(const ResourceResponse&) override;
    … …  
    170170    void scheduleRenderingUpdate(const Image&);
    171171
    172     void updateBufferInternal(const FragmentedSharedBuffer&);
     172    void updateBufferInternal(const SharedBuffer&);
    173173
    174174    void didReplaceSharedBufferContents() override;

  • trunk/Source/WebCore/loader/cache/CachedRawResource.cpp

    r287021 r287684  
    4949}
    5050
    51 std::optional<SharedBufferDataView> CachedRawResource::calculateIncrementalDataChunk(const FragmentedSharedBuffer* data) const
     51std::optional<SharedBufferDataView> CachedRawResource::calculateIncrementalDataChunk(const SharedBuffer& data) const
    5252{
    5353    size_t previousDataLength = encodedSize();
    54     if (!data || data->size() <= previousDataLength)
     54    if (data.size() <= previousDataLength)
    5555        return std::nullopt;
    56     return data->getSomeData(previousDataLength);
     56    return data.getSomeData(previousDataLength);
    5757}
    5858
    … …  
    7373
    7474        SetForScope<bool> notifyScope(m_inIncrementalDataNotify, true);
    75         notifyClientsDataWasReceived(incrementalData.data(), incrementalData.size());
     75        notifyClientsDataWasReceived(incrementalData.createSharedBuffer());
    7676    }
    7777    setEncodedSize(m_data->size());
    … …  
    9090}
    9191
    92 void CachedRawResource::updateData(const uint8_t* data, unsigned length)
     92void CachedRawResource::updateData(const SharedBuffer& buffer)
    9393{
    9494    ASSERT(dataBufferingPolicy() == DataBufferingPolicy::DoNotBufferData);
    95     notifyClientsDataWasReceived(data, length);
    96     CachedResource::updateData(data, length);
     95    notifyClientsDataWasReceived(buffer);
     96    CachedResource::updateData(buffer);
    9797}
    9898
    … …  
    111111            if (data != m_data.get())
    112112                m_data = data->makeContiguous();
    113             if (auto incrementalData = calculateIncrementalDataChunk(data)) {
     113            if (auto incrementalData = calculateIncrementalDataChunk(*m_data)) {
    114114                setEncodedSize(data->size());
    115                 notifyClientsDataWasReceived(incrementalData->data(), incrementalData->size());
     115                notifyClientsDataWasReceived(incrementalData->createSharedBuffer());
    116116            }
    117117        } else
    … …  
    131131}
    132132
    133 void CachedRawResource::notifyClientsDataWasReceived(const uint8_t* data, unsigned length)
    134 {
    135     if (!length)
     133void CachedRawResource::notifyClientsDataWasReceived(const SharedBuffer& buffer)
     134{
     135    if (buffer.isEmpty())
    136136        return;
    137137
    … …  
    139139    CachedResourceClientWalker<CachedRawResourceClient> w(m_clients);
    140140    while (CachedRawResourceClient* c = w.next())
    141         c->dataReceived(*this, data, length);
     141        c->dataReceived(*this, buffer);
    142142}
    143143
    … …  
    171171                return;
    172172            if (m_data) {
    173                 m_data->forEachSegment([&](auto& segment) {
     173                m_data->forEachSegmentAsSharedBuffer([&](auto&& buffer) {
    174174                    if (hasClient(*client))
    175                         client->dataReceived(*this, segment.data(), segment.size());
     175                        client->dataReceived(*this, buffer);
    176176                });
    177177            }

  • trunk/Source/WebCore/loader/cache/CachedRawResource.h

    r287021 r287684  
    2929class CachedResourceClient;
    3030class ResourceTiming;
     31class SharedBuffer;
    3132class SharedBufferDataView;
    3233
    … …  
    5354    void didAddClient(CachedResourceClient&) final;
    5455    void updateBuffer(const FragmentedSharedBuffer&) final;
    55     void updateData(const uint8_t* data, unsigned length) final;
     56    void updateData(const SharedBuffer&) final;
    5657    void finishLoading(const FragmentedSharedBuffer*, const NetworkLoadMetrics&) final;
    5758
    … …  
    6768    bool mayTryReplaceEncodedData() const override { return m_allowEncodedDataReplacement; }
    6869
    69     std::optional<SharedBufferDataView> calculateIncrementalDataChunk(const FragmentedSharedBuffer*) const;
    70     void notifyClientsDataWasReceived(const uint8_t* data, unsigned length);
     70    std::optional<SharedBufferDataView> calculateIncrementalDataChunk(const SharedBuffer&) const;
     71    void notifyClientsDataWasReceived(const SharedBuffer&);
    7172   
    7273#if USE(QUICK_LOOK)

  • trunk/Source/WebCore/loader/cache/CachedRawResourceClient.h

    r278516 r287684  
    3232class ResourceResponse;
    3333class ResourceTiming;
     34class SharedBuffer;
    3435
    3536class CachedRawResourceClient : public CachedResourceClient {
    … …  
    4748
    4849    virtual bool shouldCacheResponse(CachedResource&, const ResourceResponse&) { return true; }
    49     virtual void dataReceived(CachedResource&, const uint8_t* /* data */, int /* length */) { }
     50    virtual void dataReceived(CachedResource&, const SharedBuffer&) { }
    5051    virtual void redirectReceived(CachedResource&, ResourceRequest&& request, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&& completionHandler) { completionHandler(WTFMove(request)); }
    5152    virtual void finishedTimingForWorkerLoad(CachedResource&, const ResourceTiming&) { }

  • trunk/Source/WebCore/loader/cache/CachedResource.cpp

    r287021 r287684  
    342342}
    343343
    344 void CachedResource::updateData(const uint8_t*, unsigned)
     344void CachedResource::updateData(const SharedBuffer&)
    345345{
    346346    ASSERT(dataBufferingPolicy() == DataBufferingPolicy::DoNotBufferData);

  • trunk/Source/WebCore/loader/cache/CachedResource.h

    r287021 r287684  
    114114    virtual const TextResourceDecoder* textResourceDecoder() const { return nullptr; }
    115115    virtual void updateBuffer(const FragmentedSharedBuffer&);
    116     virtual void updateData(const uint8_t* data, unsigned length);
     116    virtual void updateData(const SharedBuffer&);
    117117    virtual void finishLoading(const FragmentedSharedBuffer*, const NetworkLoadMetrics&);
    118118    virtual void error(CachedResource::Status);

  • trunk/Source/WebCore/loader/ios/LegacyPreviewLoader.h

    r287053 r287684  
    4848
    4949    bool didReceiveResponse(const ResourceResponse&);
    50     bool didReceiveData(const uint8_t* data, unsigned length);
    51     bool didReceiveBuffer(const FragmentedSharedBuffer&);
     50    bool didReceiveData(const SharedBuffer&);
    5251    bool didFinishLoading();
    5352    void didFail();

  • trunk/Source/WebCore/loader/ios/LegacyPreviewLoader.mm

    r287053 r287684  
    6464}
    6565
    66 bool LegacyPreviewLoader::didReceiveBuffer(const FragmentedSharedBuffer& buffer)
     66bool LegacyPreviewLoader::didReceiveData(const SharedBuffer& buffer)
    6767{
    6868    if (m_finishedLoadingDataIntoConverter)
    … …  
    7272    m_originalData.append(buffer);
    7373    m_converter->updateMainResource();
    74     m_client->didReceiveBuffer(buffer);
     74    m_client->didReceiveData(buffer);
    7575    return true;
    7676}
    … …  
    163163        return;
    164164
    165     auto dataCopy = data.copy();
    166     resourceLoader->didReceiveBuffer(WTFMove(dataCopy), dataCopy->size(), DataPayloadBytes);
     165    resourceLoader->didReceiveBuffer(data, data.size(), DataPayloadBytes);
    167166}
    168167
    … …  
    244243}
    245244
    246 bool LegacyPreviewLoader::didReceiveData(const uint8_t* data, unsigned length)
    247 {
    248     return didReceiveBuffer(SharedBuffer::create(data, length).get());
    249 }
    250 
    251245bool LegacyPreviewLoader::didReceiveResponse(const ResourceResponse&)
    252246{

  • trunk/Source/WebCore/page/EventSource.cpp

    r282712 r287684  
    4343#include "ScriptExecutionContext.h"
    4444#include "SecurityOrigin.h"
     45#include "SharedBuffer.h"
    4546#include "TextResourceDecoder.h"
    4647#include "ThreadableLoader.h"
    … …  
    211212}
    212213
    213 void EventSource::didReceiveData(const uint8_t* data, int length)
     214void EventSource::didReceiveData(const SharedBuffer& buffer)
    214215{
    215216    ASSERT(m_state == OPEN);
    … …  
    217218    RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(!m_isSuspendedForBackForwardCache);
    218219
    219     append(m_receiveBuffer, m_decoder->decode(data, length));
     220    append(m_receiveBuffer, m_decoder->decode(buffer.data(), buffer.size()));
    220221    parseEventStream();
    221222}

  • trunk/Source/WebCore/page/EventSource.h

    r282712 r287684  
    8585    // ThreadableLoaderClient
    8686    void didReceiveResponse(ResourceLoaderIdentifier, const ResourceResponse&) final;
    87     void didReceiveData(const uint8_t*, int) final;
     87    void didReceiveData(const SharedBuffer&) final;
    8888    void didFinishLoading(ResourceLoaderIdentifier) final;
    8989    void didFail(const ResourceError&) final;

  • trunk/Source/WebCore/platform/SharedBuffer.cpp

    r287506 r287684  
    139139    Vector<uint8_t> combinedData;
    140140    if (hasOneSegment() && std::holds_alternative<Vector<uint8_t>>(m_segments[0].segment->m_immutableData) && m_segments[0].segment->hasOneRef())
    141         combinedData = std::exchange(std::get<Vector<uint8_t>>(m_segments[0].segment->m_immutableData), Vector<uint8_t>());
     141        combinedData = std::exchange(std::get<Vector<uint8_t>>(const_cast<DataSegment&>(m_segments[0].segment.get()).m_immutableData), Vector<uint8_t>());
    142142    else
    143143        combinedData = combineSegmentsData(m_segments, m_size);
    … …  
    251251}
    252252
     253void FragmentedSharedBuffer::forEachSegmentAsSharedBuffer(const Function<void(Ref<SharedBuffer>&&)>& apply) const
     254{
     255    auto protectedThis = Ref { *this };
     256    for (auto& segment : m_segments)
     257        apply(SharedBuffer::create(segment.segment.copyRef()));
     258}
     259
    253260bool FragmentedSharedBuffer::startsWith(const Span<const uint8_t>& prefix) const
    254261{
    … …  
    416423}
    417424
    418 SharedBuffer::SharedBuffer(Ref<DataSegment>&& segment)
     425SharedBuffer::SharedBuffer(Ref<const DataSegment>&& segment)
    419426{
    420427    m_size = segment->size();
    … …  
    604611}
    605612
    606 SharedBufferDataView::SharedBufferDataView(Ref<DataSegment>&& segment, size_t positionWithinSegment, std::optional<size_t> size)
     613SharedBufferDataView::SharedBufferDataView(Ref<const DataSegment>&& segment, size_t positionWithinSegment, std::optional<size_t> size)
    607614    : m_segment(WTFMove(segment))
    608615    , m_positionWithinSegment(positionWithinSegment)
    … …  
    620627Ref<SharedBuffer> SharedBufferDataView::createSharedBuffer() const
    621628{
    622     const Ref<DataSegment> segment = m_segment;
     629    const Ref<const DataSegment> segment = m_segment;
    623630    return SharedBuffer::create(DataSegment::Provider {
    624631        [segment, data = data()]() { return data; },

  • trunk/Source/WebCore/platform/SharedBuffer.h

    r287612 r287684  
    179179    WEBCORE_EXPORT void forEachSegment(const Function<void(const Span<const uint8_t>&)>&) const;
    180180    WEBCORE_EXPORT bool startsWith(const Span<const uint8_t>& prefix) const;
     181    WEBCORE_EXPORT void forEachSegmentAsSharedBuffer(const Function<void(Ref<SharedBuffer>&&)>&) const;
    181182
    182183    using DataSegment = WebCore::DataSegment; // To keep backward compatibility when using FragmentedSharedBuffer::DataSegment
    … …  
    184185    struct DataSegmentVectorEntry {
    185186        size_t beginPosition;
    186         Ref<DataSegment> segment;
     187        const Ref<const DataSegment> segment;
    187188    };
    188189    using DataSegmentVector = Vector<DataSegmentVectorEntry, 1>;
    … …  
    261262            return adoptRef(*new SharedBuffer());
    262263        else if constexpr (sizeof...(Args) == 1
    263             && (std::is_same_v<Args, Ref<DataSegment>> &&...))
     264            && (std::is_same_v<Args, Ref<const DataSegment>> &&...))
     265            return adoptRef(*new SharedBuffer(std::forward<Args>(args)...));
     266        else if constexpr (sizeof...(Args) == 1
     267            && (std::is_same_v<std::remove_const_t<std::remove_reference_t<Args>>, DataSegment> &&...))
    264268            return adoptRef(*new SharedBuffer(std::forward<Args>(args)...));
    265269        else {
    … …  
    288292private:
    289293    WEBCORE_EXPORT SharedBuffer();
     294    SharedBuffer(const DataSegment& segment)
     295        : SharedBuffer(Ref<const DataSegment> { segment }) { }
    290296    WEBCORE_EXPORT explicit SharedBuffer(FileSystem::MappedFileData&&);
    291     WEBCORE_EXPORT explicit SharedBuffer(Ref<DataSegment>&&);
     297    WEBCORE_EXPORT explicit SharedBuffer(Ref<const DataSegment>&&);
    292298    WEBCORE_EXPORT explicit SharedBuffer(Ref<FragmentedSharedBuffer>&&);
    293299
    … …  
    361367class SharedBufferDataView {
    362368public:
    363     WEBCORE_EXPORT SharedBufferDataView(Ref<DataSegment>&&, size_t positionWithinSegment, std::optional<size_t> newSize = std::nullopt);
     369    WEBCORE_EXPORT SharedBufferDataView(Ref<const DataSegment>&&, size_t positionWithinSegment, std::optional<size_t> newSize = std::nullopt);
    364370    WEBCORE_EXPORT SharedBufferDataView(const SharedBufferDataView&, size_t newSize);
    365371    size_t size() const { return m_size; }
    … …  
    372378#endif
    373379private:
    374     const Ref<DataSegment> m_segment;
     380    const Ref<const DataSegment> m_segment;
    375381    const size_t m_positionWithinSegment;
    376382    const size_t m_size;

  • trunk/Source/WebCore/platform/graphics/PlatformMediaResourceLoader.h

    r287021 r287684  
    5252    virtual bool shouldCacheResponse(PlatformMediaResource&, const ResourceResponse&) { return true; }
    5353    virtual void dataSent(PlatformMediaResource&, unsigned long long, unsigned long long) { }
    54     virtual void dataReceived(PlatformMediaResource&, Ref<FragmentedSharedBuffer>&&) { RELEASE_ASSERT_NOT_REACHED(); }
    55     // This method should be removed once CachedRawResourceClient uses FragmentedSharedBuffer.
    56     virtual void dataReceived(PlatformMediaResource& platform, const uint8_t* data, int length) { dataReceived(platform, SharedBuffer::create(data, length)); }
     54    virtual void dataReceived(PlatformMediaResource&, const SharedBuffer&) { RELEASE_ASSERT_NOT_REACHED(); }
    5755    virtual void accessControlCheckFailed(PlatformMediaResource&, const ResourceError&) { }
    5856    virtual void loadFailed(PlatformMediaResource&, const ResourceError&) { }

  • trunk/Source/WebCore/platform/graphics/avfoundation/cf/WebCoreAVCFResourceLoader.cpp

    r282755 r287684  
    139139}
    140140
    141 void WebCoreAVCFResourceLoader::dataReceived(CachedResource& resource, const uint8_t*, int)
     141void WebCoreAVCFResourceLoader::dataReceived(CachedResource& resource, const SharedBuffer&)
    142142{
    143143    fulfillRequestWithResource(resource);

  • trunk/Source/WebCore/platform/graphics/avfoundation/cf/WebCoreAVCFResourceLoader.h

    r278518 r287684  
    5858    // CachedRawResourceClient
    5959    void responseReceived(CachedResource&, const ResourceResponse&, CompletionHandler<void()>&&) override;
    60     void dataReceived(CachedResource&, const uint8_t*, int) override;
     60    void dataReceived(CachedResource&, const SharedBuffer&) override;
    6161    void notifyFinished(CachedResource&, const NetworkLoadMetrics&) override;
    6262

  • trunk/Source/WebCore/platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm

    r287021 r287684  
    6262    // CachedRawResourceClient
    6363    void responseReceived(CachedResource&, const ResourceResponse&, CompletionHandler<void()>&&) final;
    64     void dataReceived(CachedResource&, const uint8_t*, int) final;
     64    void dataReceived(CachedResource&, const SharedBuffer&) final;
    6565    void notifyFinished(CachedResource&, const NetworkLoadMetrics&) final;
    6666
    … …  
    131131}
    132132
    133 void CachedResourceMediaLoader::dataReceived(CachedResource& resource, const uint8_t*, int)
     133void CachedResourceMediaLoader::dataReceived(CachedResource& resource, const SharedBuffer&)
    134134{
    135135    ASSERT(&resource == m_resource);
    … …  
    157157    bool shouldCacheResponse(PlatformMediaResource&, const ResourceResponse&) final { return false; }
    158158    void dataSent(PlatformMediaResource&, unsigned long long, unsigned long long) final { }
    159     void dataReceived(PlatformMediaResource&, Ref<FragmentedSharedBuffer>&&) final;
     159    void dataReceived(PlatformMediaResource&, const SharedBuffer&) final;
    160160    void accessControlCheckFailed(PlatformMediaResource&, const ResourceError& error) final { loadFailed(error); }
    161161    void loadFailed(PlatformMediaResource&, const ResourceError& error) final { loadFailed(error); }
    … …  
    212212}
    213213
    214 void PlatformResourceMediaLoader::dataReceived(PlatformMediaResource&, Ref<FragmentedSharedBuffer>&& buffer)
    215 {
    216     m_buffer.append(WTFMove(buffer));
     214void PlatformResourceMediaLoader::dataReceived(PlatformMediaResource&, const SharedBuffer& buffer)
     215{
     216    m_buffer.append(buffer);
    217217    m_parent.newDataStoredInSharedBuffer(*m_buffer.get());
    218218}

  • trunk/Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp

    r287021 r287684  
    7272    // PlatformMediaResourceClient virtual methods.
    7373    void responseReceived(PlatformMediaResource&, const ResourceResponse&, CompletionHandler<void(ShouldContinuePolicyCheck)>&&) override;
    74     void dataReceived(PlatformMediaResource&, Ref<FragmentedSharedBuffer>&&) override;
     74    void dataReceived(PlatformMediaResource&, const SharedBuffer&) override;
    7575    void accessControlCheckFailed(PlatformMediaResource&, const ResourceError&) override;
    7676    void loadFailed(PlatformMediaResource&, const ResourceError&) override;
    … …  
    10941094}
    10951095
    1096 void CachedResourceStreamingClient::dataReceived(PlatformMediaResource&, Ref<FragmentedSharedBuffer>&& buffer)
     1096void CachedResourceStreamingClient::dataReceived(PlatformMediaResource&, const SharedBuffer& data)
    10971097{
    10981098    ASSERT(isMainThread());
    … …  
    11081108    // sending time from the receiving time, it is better to ignore it.
    11091109    if (!std::isnan(members->downloadStartTime)) {
    1110         members->totalDownloadedBytes += buffer->size();
     1110        members->totalDownloadedBytes += data.size();
    11111111        double timeSinceStart = (WallTime::now() - members->downloadStartTime).seconds();
    11121112        GST_TRACE_OBJECT(src, "R%u: downloaded %" G_GUINT64_FORMAT " bytes in %f seconds =~ %1.0f bytes/second", m_requestNumber, members->totalDownloadedBytes, timeSinceStart
    … …  
    11161116    }
    11171117
    1118     buffer->forEachSegment([&](auto& segment) {
    1119         int length = segment.size();
    1120         GST_LOG_OBJECT(src, "R%u: Have %d bytes of data", m_requestNumber, length);
    1121 
    1122         members->readPosition += length;
    1123         ASSERT(!members->haveSize || members->readPosition <= members->size);
    1124 
    1125         gst_element_post_message(GST_ELEMENT_CAST(src), gst_message_new_element(GST_OBJECT_CAST(src),
    1126             gst_structure_new("webkit-network-statistics", "read-position", G_TYPE_UINT64, members->readPosition, "size", G_TYPE_UINT64, members->size, nullptr)));
    1127 
    1128         checkUpdateBlocksize(length);
    1129         GstBuffer* buffer = gstBufferNewWrappedFast(fastMemDup(segment.data(), length), length);
    1130         gst_adapter_push(members->adapter.get(), buffer);
    1131     });
     1118    int length = data.size();
     1119    GST_LOG_OBJECT(src, "R%u: Have %d bytes of data", m_requestNumber, length);
     1120
     1121    members->readPosition += length;
     1122    ASSERT(!members->haveSize || members->readPosition <= members->size);
     1123
     1124    gst_element_post_message(GST_ELEMENT_CAST(src), gst_message_new_element(GST_OBJECT_CAST(src),
     1125        gst_structure_new("webkit-network-statistics", "read-position", G_TYPE_UINT64, members->readPosition, "size", G_TYPE_UINT64, members->size, nullptr)));
     1126
     1127    checkUpdateBlocksize(length);
     1128    GstBuffer* buffer = gstBufferNewWrappedFast(fastMemDup(data.data(), length), length);
     1129    gst_adapter_push(members->adapter.get(), buffer);
     1130
    11321131    stopLoaderIfNeeded(src, members);
    11331132    members->responseCondition.notifyOne();

  • trunk/Source/WebCore/platform/network/ResourceHandleClient.cpp

    r287021 r287684  
    3737ResourceHandleClient::~ResourceHandleClient() = default;
    3838
    39 void ResourceHandleClient::didReceiveBuffer(ResourceHandle* handle, Ref<FragmentedSharedBuffer>&& buffer, int encodedDataLength)
     39void ResourceHandleClient::didReceiveBuffer(ResourceHandle* handle, const FragmentedSharedBuffer& buffer, int encodedDataLength)
    4040{
    41     didReceiveData(handle, buffer->makeContiguous()->data(), buffer->size(), encodedDataLength);
     41    buffer.forEachSegmentAsSharedBuffer([&](auto&& buffer) {
     42        didReceiveData(handle, buffer, encodedDataLength);
     43    });
    4244}
    4345

  • trunk/Source/WebCore/platform/network/ResourceHandleClient.h

    r287021 r287684  
    4545class AuthenticationChallenge;
    4646class Credential;
     47class FragmentedSharedBuffer;
    4748class NetworkLoadMetrics;
    4849class ProtectionSpace;
    … …  
    5152class ResourceRequest;
    5253class ResourceResponse;
    53 class FragmentedSharedBuffer;
     54class SharedBuffer;
    5455
    5556enum CacheStoragePolicy {
    … …  
    6667    virtual void didSendData(ResourceHandle*, unsigned long long /*bytesSent*/, unsigned long long /*totalBytesToBeSent*/) { }
    6768
    68     virtual void didReceiveData(ResourceHandle*, const uint8_t*, unsigned, int /*encodedDataLength*/) { }
    69     WEBCORE_EXPORT virtual void didReceiveBuffer(ResourceHandle*, Ref<FragmentedSharedBuffer>&&, int encodedDataLength);
    70    
     69    virtual void didReceiveData(ResourceHandle*, const SharedBuffer&, int /*encodedDataLength*/) { }
     70    WEBCORE_EXPORT virtual void didReceiveBuffer(ResourceHandle*, const FragmentedSharedBuffer&, int encodedDataLength);
     71
    7172    virtual void didFinishLoading(ResourceHandle*, const NetworkLoadMetrics&) { }
    7273    virtual void didFail(ResourceHandle*, const ResourceError&) { }

  • trunk/Source/WebCore/platform/network/SynchronousLoaderClient.cpp

    r278516 r287684  
    7272}
    7373
    74 void SynchronousLoaderClient::didReceiveData(ResourceHandle*, const uint8_t* data, unsigned length, int /*encodedDataLength*/)
     74void SynchronousLoaderClient::didReceiveData(ResourceHandle*, const SharedBuffer& buffer, int /*encodedDataLength*/)
    7575{
    76     m_data.append(data, length);
     76    m_data.append(buffer.data(), buffer.size());
    7777}
    7878

  • trunk/Source/WebCore/platform/network/SynchronousLoaderClient.h

    r278516 r287684  
    3535namespace WebCore {
    3636
     37class SharedBuffer;
     38
    3739class SynchronousLoaderMessageQueue : public ThreadSafeRefCounted<SynchronousLoaderMessageQueue> {
    3840public:
    … …  
    6769    void didReceiveAuthenticationChallenge(ResourceHandle*, const AuthenticationChallenge&) override;
    6870    void didReceiveResponseAsync(ResourceHandle*, ResourceResponse&&, CompletionHandler<void()>&&) override;
    69     void didReceiveData(ResourceHandle*, const uint8_t*, unsigned, int /*encodedDataLength*/) override;
     71    void didReceiveData(ResourceHandle*, const SharedBuffer&, int /*encodedDataLength*/) override;
    7072    void didFinishLoading(ResourceHandle*, const NetworkLoadMetrics&) override;
    7173    void didFail(ResourceHandle*, const ResourceError&) override;

  • trunk/Source/WebCore/platform/network/cocoa/RangeResponseGenerator.mm

    r287049 r287684  
    133133            size_t bytesFromThisViewToDeliver = std::min(bufferView.size(), range.end - byteIndex + 1);
    134134            byteIndex += bytesFromThisViewToDeliver;
    135             [task resource:nullptr receivedData:SharedBufferDataView(bufferView, bytesFromThisViewToDeliver).createSharedBuffer()];
     135            [task resource:nullptr receivedData:SharedBufferDataView(bufferView, bytesFromThisViewToDeliver).createSharedBuffer()->createNSData()];
    136136        }
    137137        if (byteIndex >= range.end) {
    … …  
    239239    }
    240240
    241     void dataReceived(PlatformMediaResource&, Ref<FragmentedSharedBuffer>&& buffer) final
     241    void dataReceived(PlatformMediaResource&, const SharedBuffer& buffer) final
    242242    {
    243243        ASSERT(isMainThread());
    … …  
    247247        if (!data)
    248248            return;
    249         data->buffer.append(WTFMove(buffer));
     249        data->buffer.append(buffer);
    250250        m_generator->giveResponseToTasksWithFinishedRanges(*data);
    251251    }

  • trunk/Source/WebCore/platform/network/cocoa/WebCoreNSURLSession.h

    r287230 r287684  
    159159- (void)resource:(nullable WebCore::PlatformMediaResource*)resource receivedResponse:(const WebCore::ResourceResponse&)response completionHandler:(CompletionHandler<void(WebCore::ShouldContinuePolicyCheck)>&&)completionHandler;
    160160- (BOOL)resource:(nullable WebCore::PlatformMediaResource*)resource shouldCacheResponse:(const WebCore::ResourceResponse&)response;
    161 - (void)resource:(nullable WebCore::PlatformMediaResource*)resource receivedData:(Ref<WebCore::FragmentedSharedBuffer>&&)data;
     161- (void)resource:(nullable WebCore::PlatformMediaResource*)resource receivedData:(RetainPtr<NSData>&&)data;
    162162- (void)resource:(nullable WebCore::PlatformMediaResource*)resource receivedRedirect:(const WebCore::ResourceResponse&)response request:(WebCore::ResourceRequest&&)request completionHandler:(CompletionHandler<void(WebCore::ResourceRequest&&)>&&)completionHandler;
    163163- (void)resource:(nullable WebCore::PlatformMediaResource*)resource accessControlCheckFailedWithError:(const WebCore::ResourceError&)error;

  • trunk/Source/WebCore/platform/network/cocoa/WebCoreNSURLSession.mm

    r287230 r287684  
    609609    bool shouldCacheResponse(PlatformMediaResource&, const ResourceResponse&) override;
    610610    void dataSent(PlatformMediaResource&, unsigned long long, unsigned long long) override;
    611     void dataReceived(PlatformMediaResource&, Ref<FragmentedSharedBuffer>&&) override;
     611    void dataReceived(PlatformMediaResource&, const SharedBuffer&) override;
    612612    void accessControlCheckFailed(PlatformMediaResource&, const ResourceError&) override;
    613613    void loadFailed(PlatformMediaResource&, const ResourceError&) override;
    … …  
    653653}
    654654
    655 void WebCoreNSURLSessionDataTaskClient::dataReceived(PlatformMediaResource& resource, Ref<FragmentedSharedBuffer>&& buffer)
     655void WebCoreNSURLSessionDataTaskClient::dataReceived(PlatformMediaResource& resource, const SharedBuffer& buffer)
    656656{
    657657    Locker locker { m_taskLock };
    … …  
    659659        return;
    660660
    661     [m_task resource:&resource receivedData:WTFMove(buffer)];
     661    [m_task resource:&resource receivedData:buffer.createNSData()];
    662662}
    663663
    … …  
    932932}
    933933
    934 - (void)resource:(PlatformMediaResource*)resource receivedData:(Ref<WebCore::FragmentedSharedBuffer>&&)data
     934- (void)resource:(PlatformMediaResource*)resource receivedData:(RetainPtr<NSData>&&)data
    935935{
    936936    ASSERT_UNUSED(resource, !resource || resource == _resource);
    937937    [self.session addDelegateOperation:[strongSelf = RetainPtr { self }, data = WTFMove(data)] {
    938         auto nsData = data->makeContiguous()->createNSData();
    939         strongSelf.get().countOfBytesReceived += data->size();
     938        strongSelf.get().countOfBytesReceived += [data length];
    940939        id<NSURLSessionDataDelegate> dataDelegate = (id<NSURLSessionDataDelegate>)strongSelf.get().session.delegate;
    941940        if ([dataDelegate respondsToSelector:@selector(URLSession:dataTask:didReceiveData:)])
    942             [dataDelegate URLSession:(NSURLSession *)strongSelf.get().session dataTask:(NSURLSessionDataTask *)strongSelf.get() didReceiveData:nsData.get()];
     941            [dataDelegate URLSession:(NSURLSession *)strongSelf.get().session dataTask:(NSURLSessionDataTask *)strongSelf.get() didReceiveData:data.get()];
    943942    }];
    944943}

  • trunk/Source/WebCore/platform/network/curl/CurlCacheManager.cpp

    r286883 r287684  
    244244}
    245245
    246 void CurlCacheManager::didReceiveData(ResourceHandle& job, const uint8_t* data, size_t size)
     246void CurlCacheManager::didReceiveData(ResourceHandle& job, const SharedBuffer& data)
    247247{
    248248    if (m_disabled)
    … …  
    256256            return;
    257257
    258         if (!it->value->saveCachedData(data, size))
     258        if (!it->value->saveCachedData(data.data(), data.size()))
    259259            invalidateCacheEntry(url);
    260260
    261261        else {
    262             m_currentStorageSize += size;
     262            m_currentStorageSize += data.size();
    263263            m_LRUEntryList.prependOrMoveToFirst(url);
    264264            makeRoomForNewEntry();

  • trunk/Source/WebCore/platform/network/curl/CurlCacheManager.h

    r278532 r287684  
    5050
    5151    void didReceiveResponse(ResourceHandle&, ResourceResponse&);
    52     void didReceiveData(ResourceHandle&, const uint8_t*, size_t); // Save data
     52    void didReceiveData(ResourceHandle&, const SharedBuffer&); // Save data
    5353    void didFinishLoading(ResourceHandle&);
    5454    void didFail(ResourceHandle&);

  • trunk/Source/WebCore/platform/network/curl/CurlDownload.cpp

    r287021 r287684  
    104104
    105105
    106 void CurlDownload::curlDidReceiveBuffer(CurlRequest&, Ref<FragmentedSharedBuffer>&& buffer)
    107 {
    108     ASSERT(isMainThread());
    109 
    110     if (m_isCancelled)
    111         return;
    112 
    113     if (m_listener)
    114         m_listener->didReceiveDataOfLength(buffer->size());
     106void CurlDownload::curlDidReceiveData(CurlRequest&, const SharedBuffer& buffer)
     107{
     108    ASSERT(isMainThread());
     109
     110    if (m_isCancelled)
     111        return;
     112
     113    if (m_listener)
     114        m_listener->didReceiveDataOfLength(buffer.size());
    115115}
    116116

  • trunk/Source/WebCore/platform/network/curl/CurlDownload.h

    r287021 r287684  
    3939class CurlRequest;
    4040class ResourceHandle;
     41class SharedBuffer;
    4142
    4243class CurlDownloadListener {
    … …  
    7374    void curlDidSendData(CurlRequest&, unsigned long long, unsigned long long) override { }
    7475    void curlDidReceiveResponse(CurlRequest&, CurlResponse&&) override;
    75     void curlDidReceiveBuffer(CurlRequest&, Ref<FragmentedSharedBuffer>&&) override;
     76    void curlDidReceiveData(CurlRequest&, const SharedBuffer&) override;
    7677    void curlDidComplete(CurlRequest&, NetworkLoadMetrics&&) override;
    7778    void curlDidFailWithError(CurlRequest&, ResourceError&&, CertificateInfo&&) override;

  • trunk/Source/WebCore/platform/network/curl/CurlMultipartHandle.cpp

    r287021 r287684  
    120120}
    121121
    122 void CurlMultipartHandle::didReceiveData(const FragmentedSharedBuffer& buffer)
     122void CurlMultipartHandle::didReceiveData(const SharedBuffer& buffer)
    123123{
    124124    if (m_state == State::End)
    125125        return; // The handler is closed down so ignore everything.
    126126
    127     m_buffer.append(buffer.makeContiguous()->data(), buffer.size());
     127    m_buffer.append(buffer.data(), buffer.size());
    128128
    129129    while (processContent()) { }

  • trunk/Source/WebCore/platform/network/curl/CurlMultipartHandle.h

    r287021 r287684  
    3535class CurlMultipartHandleClient;
    3636class CurlResponse;
    37 class FragmentedSharedBuffer;
     37class SharedBuffer;
    3838
    3939class CurlMultipartHandle {
    … …  
    4545    ~CurlMultipartHandle() { }
    4646
    47     void didReceiveData(const FragmentedSharedBuffer&);
     47    void didReceiveData(const SharedBuffer&);
    4848    void didComplete();
    4949

  • trunk/Source/WebCore/platform/network/curl/CurlMultipartHandleClient.h

    r287021 r287684  
    3434public:
    3535    virtual void didReceiveHeaderFromMultipart(const Vector<String>&) = 0;
    36     virtual void didReceiveDataFromMultipart(Ref<FragmentedSharedBuffer>&&) = 0;
     36    virtual void didReceiveDataFromMultipart(const SharedBuffer&) = 0;
    3737
    3838protected:

  • trunk/Source/WebCore/platform/network/curl/CurlRequest.cpp

    r287224 r287684  
    397397// called with data after all headers have been processed via headerCallback
    398398
    399 size_t CurlRequest::didReceiveData(Ref<FragmentedSharedBuffer>&& buffer)
     399size_t CurlRequest::didReceiveData(const SharedBuffer& buffer)
    400400{
    401401    if (isCompletedOrCancelled())
    … …  
    412412    }
    413413
    414     auto receiveBytes = buffer->size();
     414    auto receiveBytes = buffer.size();
    415415    m_totalReceivedSize += receiveBytes;
    416416
    … …  
    421421            m_multipartHandle->didReceiveData(buffer);
    422422        else {
    423             callClient([buffer = WTFMove(buffer)](CurlRequest& request, CurlRequestClient& client) mutable {
    424                 client.curlDidReceiveBuffer(request, WTFMove(buffer));
     423            callClient([buffer = Ref { buffer }](CurlRequest& request, CurlRequestClient& client) {
     424                client.curlDidReceiveData(request, buffer);
    425425            });
    426426        }
    … …  
    445445}
    446446
    447 void CurlRequest::didReceiveDataFromMultipart(Ref<FragmentedSharedBuffer>&& buffer)
     447void CurlRequest::didReceiveDataFromMultipart(const SharedBuffer& buffer)
    448448{
    449449    if (isCompletedOrCancelled())
    450450        return;
    451451
    452     auto receiveBytes = buffer->size();
     452    auto receiveBytes = buffer.size();
    453453
    454454    if (receiveBytes) {
    455         callClient([buffer = WTFMove(buffer)](CurlRequest& request, CurlRequestClient& client) mutable {
    456             client.curlDidReceiveBuffer(request, WTFMove(buffer));
     455        callClient([buffer = Ref { buffer }](CurlRequest& request, CurlRequestClient& client) {
     456            client.curlDidReceiveData(request, buffer);
    457457        });
    458458    }

  • trunk/Source/WebCore/platform/network/curl/CurlRequest.h

    r287224 r287684  
    123123    size_t willSendData(char*, size_t, size_t);
    124124    size_t didReceiveHeader(String&&);
    125     size_t didReceiveData(Ref<FragmentedSharedBuffer>&&);
     125    size_t didReceiveData(const SharedBuffer&);
    126126    void didReceiveHeaderFromMultipart(const Vector<String>&) override;
    127     void didReceiveDataFromMultipart(Ref<FragmentedSharedBuffer>&&) override;
     127    void didReceiveDataFromMultipart(const SharedBuffer&) override;
    128128    void didCompleteTransfer(CURLcode) override;
    129129    void didCancelTransfer() override;

  • trunk/Source/WebCore/platform/network/curl/CurlRequestClient.h

    r287021 r287684  
    3535class NetworkLoadMetrics;
    3636class ResourceError;
    37 class FragmentedSharedBuffer;
     37class SharedBuffer;
    3838
    3939class CurlRequestClient {
    … …  
    4444    virtual void curlDidSendData(CurlRequest&, unsigned long long bytesSent, unsigned long long totalBytesToBeSent) = 0;
    4545    virtual void curlDidReceiveResponse(CurlRequest&, CurlResponse&&) = 0;
    46     virtual void curlDidReceiveBuffer(CurlRequest&, Ref<FragmentedSharedBuffer>&&) = 0;
     46    virtual void curlDidReceiveData(CurlRequest&, const SharedBuffer&) = 0;
    4747    virtual void curlDidComplete(CurlRequest&, NetworkLoadMetrics&&) = 0;
    4848    virtual void curlDidFailWithError(CurlRequest&, ResourceError&&, CertificateInfo&&) = 0;

  • trunk/Source/WebCore/platform/network/curl/CurlResourceHandleDelegate.cpp

    r287021 r287684  
    143143}
    144144
    145 void CurlResourceHandleDelegate::curlDidReceiveBuffer(CurlRequest&, Ref<FragmentedSharedBuffer>&& buffer)
     145void CurlResourceHandleDelegate::curlDidReceiveData(CurlRequest&, const SharedBuffer& buffer)
    146146{
    147147    ASSERT(isMainThread());
    … …  
    150150        return;
    151151
    152     auto contiguousBuffer = buffer->makeContiguous();
    153     CurlCacheManager::singleton().didReceiveData(m_handle, contiguousBuffer->data(), buffer->size());
    154     client()->didReceiveBuffer(&m_handle, WTFMove(contiguousBuffer), buffer->size());
     152    CurlCacheManager::singleton().didReceiveData(m_handle, buffer);
     153    client()->didReceiveBuffer(&m_handle, buffer, buffer.size());
    155154}
    156155

  • trunk/Source/WebCore/platform/network/curl/CurlResourceHandleDelegate.h

    r287021 r287684  
    3939class ResourceHandleClient;
    4040class ResourceHandleInternal;
     41class SharedBuffer;
    4142
    4243class CurlResourceHandleDelegate final : public CurlRequestClient {
    … …  
    5455    void curlDidSendData(CurlRequest&, unsigned long long bytesSent, unsigned long long totalBytesToBeSent) final;
    5556    void curlDidReceiveResponse(CurlRequest&, CurlResponse&&) final;
    56     void curlDidReceiveBuffer(CurlRequest&, Ref<FragmentedSharedBuffer>&&) final;
     57    void curlDidReceiveData(CurlRequest&, const SharedBuffer&) final;
    5758    void curlDidComplete(CurlRequest&, NetworkLoadMetrics&&) final;
    5859    void curlDidFailWithError(CurlRequest&, ResourceError&&, CertificateInfo&&) final;

  • trunk/Source/WebCore/platform/network/curl/CurlStream.cpp

    r284857 r287684  
    1010 *    notice, this list of conditions and the following disclaimer in the
    1111 *    documentation and/or other materials provided with the distribution.
    12  * 
     12 *
    1313 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
    1414 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
    … …  
    2828
    2929#include "CurlStreamScheduler.h"
     30#include "SharedBuffer.h"
    3031#include "SocketStreamError.h"
    3132
    … …  
    130131        return;
    131132
    132     auto receiveBuffer = makeUniqueArray<uint8_t>(kReceiveBufferSize);
     133    Vector<uint8_t> receiveBuffer(kReceiveBufferSize);
    133134    size_t bytesReceived = 0;
    134135
    135     auto errorCode = m_curlHandle->receive(receiveBuffer.get(), kReceiveBufferSize, bytesReceived);
     136    auto errorCode = m_curlHandle->receive(receiveBuffer.data(), kReceiveBufferSize, bytesReceived);
    136137    if (errorCode != CURLE_OK) {
    137138        if (errorCode != CURLE_AGAIN)
    … …  
    144145        destroyHandle();
    145146
    146     m_scheduler.callClientOnMainThread(m_streamID, [streamID = m_streamID, buffer = WTFMove(receiveBuffer), length = bytesReceived](Client& client) mutable {
    147         client.didReceiveData(streamID, buffer.get(), length);
     147    receiveBuffer.resize(bytesReceived);
     148    m_scheduler.callClientOnMainThread(m_streamID, [streamID = m_streamID, buffer = SharedBuffer::create(WTFMove(receiveBuffer))](Client& client) {
     149        client.didReceiveData(streamID, buffer);
    148150    });
    149151}

  • trunk/Source/WebCore/platform/network/curl/CurlStream.h

    r284857 r287684  
    1010 *    notice, this list of conditions and the following disclaimer in the
    1111 *    documentation and/or other materials provided with the distribution.
    12  * 
     12 *
    1313 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
    1414 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
    … …  
    3434
    3535class CurlStreamScheduler;
     36class SharedBuffer;
    3637class SocketStreamError;
    3738
    … …  
    4748        virtual void didOpen(CurlStreamID) = 0;
    4849        virtual void didSendData(CurlStreamID, size_t) = 0;
    49         virtual void didReceiveData(CurlStreamID, const uint8_t*, size_t) = 0;
     50        virtual void didReceiveData(CurlStreamID, const SharedBuffer&) = 0;
    5051        virtual void didFail(CurlStreamID, CURLcode) = 0;
    5152    };

  • trunk/Source/WebCore/platform/network/curl/SocketStreamHandleImpl.h

    r278532 r287684  
    6060    bool sendPendingData();
    6161
     62    // CurlStream::Client
    6263    void didOpen(CurlStreamID) final;
    6364    void didSendData(CurlStreamID, size_t) final;
    64     void didReceiveData(CurlStreamID, const uint8_t*, size_t) final;
     65    void didReceiveData(CurlStreamID, const SharedBuffer&) final;
    6566    void didFail(CurlStreamID, CURLcode) final;
    6667

  • trunk/Source/WebCore/platform/network/curl/SocketStreamHandleImplCurl.cpp

    r278532 r287684  
    3838#include "CurlStreamScheduler.h"
    3939#include "DeprecatedGlobalSettings.h"
     40#include "SharedBuffer.h"
    4041#include "SocketStreamError.h"
    4142#include "SocketStreamHandleClient.h"
    … …  
    105106}
    106107
    107 void SocketStreamHandleImpl::didReceiveData(CurlStreamID, const uint8_t* data, size_t length)
     108void SocketStreamHandleImpl::didReceiveData(CurlStreamID, const SharedBuffer& data)
    108109{
    109110    if (m_state != Open)
    110111        return;
    111112
    112     m_client.didReceiveSocketStreamData(*this, data, length);
     113    m_client.didReceiveSocketStreamData(*this, data.data(), data.size());
    113114}
    114115

  • trunk/Source/WebCore/platform/network/ios/LegacyPreviewLoaderClient.h

    r287021 r287684  
    3232namespace WebCore {
    3333
    34 class FragmentedSharedBuffer;
     34class SharedBuffer;
    3535
    3636class LegacyPreviewLoaderClient : public RefCounted<LegacyPreviewLoaderClient> {
    3737public:
    3838    virtual ~LegacyPreviewLoaderClient() = default;
    39     virtual void didReceiveBuffer(const FragmentedSharedBuffer&) { }
     39    virtual void didReceiveData(const SharedBuffer&) { }
    4040    virtual void didFinishLoading() { }
    4141    virtual void didFail() { }

  • trunk/Source/WebCore/platform/network/mac/WebCoreResourceHandleAsOperationQueueDelegate.mm

    r287021 r287684  
    301301        // -1 means we do not provide any data about transfer size to inspector so it would use
    302302        // Content-Length headers or content size to show transfer size.
    303         m_handle->client()->didReceiveBuffer(m_handle, SharedBuffer::create(data.get()), -1);
     303        m_handle->client()->didReceiveData(m_handle, SharedBuffer::create(data.get()), -1);
    304304    };
    305305

  • trunk/Source/WebCore/svg/graphics/SVGImage.cpp

    r286392 r287684  
    547547        loader.activeDocumentLoader()->writer().setMIMEType("image/svg+xml");
    548548        loader.activeDocumentLoader()->writer().begin(URL()); // create the empty document
    549         data()->forEachSegment([&](auto& segment) {
    550             loader.activeDocumentLoader()->writer().addData(segment.data(), segment.size());
     549        data()->forEachSegmentAsSharedBuffer([&](auto&& buffer) {
     550            loader.activeDocumentLoader()->writer().addData(buffer);
    551551        });
    552552        loader.activeDocumentLoader()->writer().end();

  • trunk/Source/WebCore/workers/WorkerFontLoadRequest.cpp

    r287021 r287684  
    116116}
    117117
    118 void WorkerFontLoadRequest::didReceiveData(const uint8_t* data, int dataLength)
     118void WorkerFontLoadRequest::didReceiveData(const SharedBuffer& buffer)
    119119{
    120120    if (m_errorOccurred)
    121121        return;
    122122
    123     m_data.append(data, dataLength);
     123    m_data.append(buffer);
    124124}
    125125

  • trunk/Source/WebCore/workers/WorkerFontLoadRequest.h

    r286983 r287684  
    6464
    6565    void didReceiveResponse(ResourceLoaderIdentifier, const ResourceResponse&) final;
    66     void didReceiveData(const uint8_t* data, int dataLength) final;
     66    void didReceiveData(const SharedBuffer&) final;
    6767    void didFinishLoading(ResourceLoaderIdentifier) final;
    6868    void didFail(const ResourceError&) final;

  • trunk/Source/WebCore/workers/WorkerScriptLoader.cpp

    r287681 r287684  
    201201}
    202202
    203 void WorkerScriptLoader::didReceiveData(const uint8_t* data, int len)
     203void WorkerScriptLoader::didReceiveData(const SharedBuffer& buffer)
    204204{
    205205    if (m_failed)
    … …  
    213213    }
    214214
    215     if (!len)
    216         return;
    217    
    218     m_script.append(m_decoder->decode(data, len));
     215    if (buffer.isEmpty())
     216        return;
     217
     218    m_script.append(m_decoder->decode(buffer.data(), buffer.size()));
    219219}
    220220

  • trunk/Source/WebCore/workers/WorkerScriptLoader.h

    r284857 r287684  
    8080
    8181    void didReceiveResponse(ResourceLoaderIdentifier, const ResourceResponse&) override;
    82     void didReceiveData(const uint8_t* data, int dataLength) override;
     82    void didReceiveData(const SharedBuffer&) override;
    8383    void didFinishLoading(ResourceLoaderIdentifier) override;
    8484    void didFail(const ResourceError&) override;

  • trunk/Source/WebCore/workers/service/context/ServiceWorkerFetch.h

    r287021 r287684  
    5252    virtual void didReceiveRedirection(const ResourceResponse&) = 0;
    5353    virtual void didReceiveResponse(const ResourceResponse&) = 0;
    54     virtual void didReceiveData(Ref<FragmentedSharedBuffer>&&) = 0;
     54    virtual void didReceiveData(const SharedBuffer&) = 0;
    5555    virtual void didReceiveFormDataAndFinish(Ref<FormData>&&) = 0;
    5656    virtual void didFail(const ResourceError&) = 0;

  • trunk/Source/WebCore/xml/XMLHttpRequest.cpp

    r287681 r287684  
    10351035}
    10361036
    1037 void XMLHttpRequest::didReceiveData(const uint8_t* data, int len)
     1037void XMLHttpRequest::didReceiveData(const SharedBuffer& buffer)
    10381038{
    10391039    if (m_error)
    … …  
    10531053        m_decoder = createDecoder();
    10541054
    1055     if (!len)
     1055    if (buffer.isEmpty())
    10561056        return;
    10571057
    10581058    if (useDecoder)
    1059         m_responseBuilder.append(m_decoder->decode(data, len));
     1059        m_responseBuilder.append(m_decoder->decode(buffer.data(), buffer.size()));
    10601060    else {
    10611061        // Buffer binary data.
    1062         m_binaryResponseBuilder.append(data, len);
     1062        m_binaryResponseBuilder.append(buffer);
    10631063    }
    10641064
    10651065    if (!m_error) {
    1066         m_receivedLength += len;
     1066        m_receivedLength += buffer.size();
    10671067
    10681068        if (readyState() != LOADING)

  • trunk/Source/WebCore/xml/XMLHttpRequest.h

    r286983 r287684  
    163163    void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent) override;
    164164    void didReceiveResponse(ResourceLoaderIdentifier, const ResourceResponse&) override;
    165     void didReceiveData(const uint8_t* data, int dataLength) override;
     165    void didReceiveData(const SharedBuffer&) override;
    166166    void didFinishLoading(ResourceLoaderIdentifier) override;
    167167    void didFail(const ResourceError&) override;

  • trunk/Source/WebKit/ChangeLog

    r287676 r287684  
     12022-01-06  Jean-Yves Avenard  <jya@apple.com>
     2
     3        Have CachedRawResourceClient and related networking actors use SharedBuffer.
     4        https://bugs.webkit.org/show_bug.cgi?id=232424
     5        rdar://84744687
     6
     7        Reviewed by Youenn Fablet.
     8
     9        * GPUProcess/media/RemoteMediaResource.cpp:
     10        (WebKit::RemoteMediaResource::dataReceived):
     11        * GPUProcess/media/RemoteMediaResource.h:
     12        * NetworkProcess/Downloads/PendingDownload.h:
     13        * NetworkProcess/NetworkCORSPreflightChecker.cpp:
     14        (WebKit::NetworkCORSPreflightChecker::didReceiveData):
     15        * NetworkProcess/NetworkCORSPreflightChecker.h:
     16        * NetworkProcess/NetworkDataTask.h:
     17        * NetworkProcess/NetworkLoad.cpp:
     18        (WebKit::NetworkLoad::didReceiveData):
     19        * NetworkProcess/NetworkLoad.h:
     20        * NetworkProcess/NetworkLoadClient.h:
     21        * NetworkProcess/NetworkResourceLoader.cpp:
     22        (WebKit::NetworkResourceLoader::didReceiveBuffer):
     23        (WebKit::NetworkResourceLoader::sendBuffer):
     24        * NetworkProcess/NetworkResourceLoader.h:
     25        * NetworkProcess/PingLoad.cpp:
     26        (WebKit::PingLoad::didReceiveData):
     27        * NetworkProcess/PingLoad.h:
     28        * NetworkProcess/PreconnectTask.cpp:
     29        (WebKit::PreconnectTask::didReceiveBuffer):
     30        * NetworkProcess/PreconnectTask.h:
     31        * NetworkProcess/ServiceWorker/ServiceWorkerDownloadTask.cpp:
     32        (WebKit::ServiceWorkerDownloadTask::didReceiveData):
     33        * NetworkProcess/ServiceWorker/ServiceWorkerDownloadTask.h:
     34        * NetworkProcess/ServiceWorker/ServiceWorkerDownloadTask.messages.in:
     35        * NetworkProcess/ServiceWorker/ServiceWorkerFetchTask.cpp:
     36        (WebKit::ServiceWorkerFetchTask::didReceiveData):
     37        (WebKit::ServiceWorkerFetchTask::loadBodyFromPreloader):
     38        * NetworkProcess/ServiceWorker/ServiceWorkerFetchTask.h:
     39        * NetworkProcess/ServiceWorker/ServiceWorkerFetchTask.messages.in:
     40        * NetworkProcess/ServiceWorker/ServiceWorkerNavigationPreloader.cpp:
     41        (WebKit::ServiceWorkerNavigationPreloader::didReceiveBuffer):
     42        * NetworkProcess/ServiceWorker/ServiceWorkerNavigationPreloader.h:
     43        * NetworkProcess/ServiceWorker/ServiceWorkerSoftUpdateLoader.cpp:
     44        (WebKit::ServiceWorkerSoftUpdateLoader::didReceiveBuffer):
     45        * NetworkProcess/ServiceWorker/ServiceWorkerSoftUpdateLoader.h:
     46        * NetworkProcess/cache/NetworkCacheSpeculativeLoad.cpp:
     47        (WebKit::NetworkCache::SpeculativeLoad::didReceiveBuffer):
     48        * NetworkProcess/cache/NetworkCacheSpeculativeLoad.h:
     49        * NetworkProcess/cocoa/NetworkDataTaskCocoa.h:
     50        * NetworkProcess/cocoa/NetworkDataTaskCocoa.mm:
     51        (WebKit::NetworkDataTaskCocoa::didReceiveData):
     52        * NetworkProcess/curl/NetworkDataTaskCurl.cpp:
     53        (WebKit::NetworkDataTaskCurl::curlDidReceiveData):
     54        * NetworkProcess/curl/NetworkDataTaskCurl.h:
     55        * Platform/IPC/SharedBufferCopy.h:
     56        * Shared/mac/MediaFormatReader/MediaFormatReader.cpp:
     57        (WebKit::MediaFormatReader::didParseTracks):
     58        * Shared/mac/MediaFormatReader/MediaFormatReader.h:
     59        * UIProcess/WebURLSchemeTask.cpp:
     60        (WebKit::WebURLSchemeTask::didReceiveData):
     61        * UIProcess/WebURLSchemeTask.h:
     62        * WebProcess/GPU/media/RemoteMediaResourceProxy.cpp:
     63        (WebKit::RemoteMediaResourceProxy::dataReceived):
     64        * WebProcess/GPU/media/RemoteMediaResourceProxy.h:
     65        * WebProcess/Network/WebResourceLoader.cpp:
     66        (WebKit::WebResourceLoader::didReceiveData):
     67        (WebKit::WebResourceLoader::didReceiveResource):
     68        * WebProcess/Network/WebResourceLoader.h:
     69        * WebProcess/Network/WebResourceLoader.messages.in:
     70        * WebProcess/Plugins/PDF/PDFPlugin.h:
     71        * WebProcess/Plugins/PDF/PDFPlugin.mm:
     72        (WebKit::PDFPlugin::PDFPluginStreamLoaderClient::didReceiveData):
     73        (WebKit::PDFPlugin::streamDidReceiveData):
     74        (WebKit::PDFPlugin::manualStreamDidReceiveData):
     75        * WebProcess/Plugins/Plugin.h:
     76        * WebProcess/Plugins/PluginView.cpp:
     77        (WebKit::PluginView::Stream::didReceiveData):
     78        (WebKit::PluginView::manualLoadDidReceiveData):
     79        (WebKit::PluginView::redeliverManualStream):
     80        * WebProcess/Plugins/PluginView.h:
     81        * WebProcess/Storage/WebServiceWorkerFetchTaskClient.cpp:
     82        (WebKit::WebServiceWorkerFetchTaskClient::didReceiveData):
     83        (WebKit::WebServiceWorkerFetchTaskClient::didReceiveBlobChunk):
     84        (WebKit::WebServiceWorkerFetchTaskClient::continueDidReceiveResponse):
     85        * WebProcess/Storage/WebServiceWorkerFetchTaskClient.h:
     86        * WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:
     87        (WebKit::WebFrameLoaderClient::committedLoad):
     88        * WebProcess/WebCoreSupport/WebFrameLoaderClient.h:
     89        * WebProcess/WebCoreSupport/ios/WebPreviewLoaderClient.cpp:
     90        (WebKit::WebPreviewLoaderClient::didReceiveData):
     91        * WebProcess/WebCoreSupport/ios/WebPreviewLoaderClient.h:
     92        * WebProcess/WebPage/WebPage.cpp:
     93        (WebKit::WebPage::urlSchemeTaskDidReceiveData):
     94        * WebProcess/WebPage/WebPage.h:
     95        * WebProcess/WebPage/WebPage.messages.in:
     96        * WebProcess/WebPage/WebURLSchemeHandlerProxy.cpp:
     97        (WebKit::WebURLSchemeHandlerProxy::taskDidReceiveData):
     98        * WebProcess/WebPage/WebURLSchemeHandlerProxy.h:
     99        * WebProcess/WebPage/WebURLSchemeTaskProxy.cpp:
     100        (WebKit::WebURLSchemeTaskProxy::didReceiveData):
     101        * WebProcess/WebPage/WebURLSchemeTaskProxy.h:
     102
    11032022-01-06  Youenn Fablet  <youenn@apple.com>
    2104

  • trunk/Source/WebKit/GPUProcess/media/RemoteMediaResource.cpp

    r287021 r287684  
    3232#include "RemoteMediaResourceManager.h"
    3333#include <WebCore/ResourceResponse.h>
     34#include <WebCore/SharedBuffer.h>
    3435
    3536namespace WebKit {
    … …  
    9798}
    9899
    99 void RemoteMediaResource::dataReceived(Ref<FragmentedSharedBuffer>&& data)
     100void RemoteMediaResource::dataReceived(const SharedBuffer& data)
    100101{
    101102    if (m_client)
    102         m_client->dataReceived(*this, WTFMove(data));
     103        m_client->dataReceived(*this, data);
    103104}
    104105

  • trunk/Source/WebKit/GPUProcess/media/RemoteMediaResource.h

    r287021 r287684  
    3636class NetworkLoadMetrics;
    3737class FragmentedSharedBuffer;
     38class SharedBuffer;
    3839}
    3940
    … …  
    5859    void redirectReceived(WebCore::ResourceRequest&&, const WebCore::ResourceResponse&, CompletionHandler<void(WebCore::ResourceRequest&&)>&&);
    5960    void dataSent(uint64_t, uint64_t);
    60     void dataReceived(Ref<WebCore::FragmentedSharedBuffer>&&);
     61    void dataReceived(const WebCore::SharedBuffer&);
    6162    void accessControlCheckFailed(const WebCore::ResourceError&);
    6263    void loadFailed(const WebCore::ResourceError&);

  • trunk/Source/WebKit/NetworkProcess/Downloads/PendingDownload.h

    r287021 r287684  
    6969    void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) override;
    7070    void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) override;
    71     void didReceiveBuffer(Ref<WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) override { };
     71    void didReceiveBuffer(const WebCore::FragmentedSharedBuffer&, int reportedEncodedDataLength) override { };
    7272    void didFinishLoading(const WebCore::NetworkLoadMetrics&) override { };
    7373    void didFailLoading(const WebCore::ResourceError&) override;

  • trunk/Source/WebKit/NetworkProcess/NetworkCORSPreflightChecker.cpp

    r287224 r287684  
    121121}
    122122
    123 void NetworkCORSPreflightChecker::didReceiveData(Ref<WebCore::FragmentedSharedBuffer>&&)
     123void NetworkCORSPreflightChecker::didReceiveData(const WebCore::SharedBuffer&)
    124124{
    125125    CORS_CHECKER_RELEASE_LOG("didReceiveData");

  • trunk/Source/WebKit/NetworkProcess/NetworkCORSPreflightChecker.h

    r287039 r287684  
    3838class ResourceError;
    3939class SecurityOrigin;
     40class SharedBuffer;
    4041}
    4142
    … …  
    7273    void didReceiveChallenge(WebCore::AuthenticationChallenge&&, NegotiatedLegacyTLS, ChallengeCompletionHandler&&) final;
    7374    void didReceiveResponse(WebCore::ResourceResponse&&, NegotiatedLegacyTLS, ResponseCompletionHandler&&) final;
    74     void didReceiveData(Ref<WebCore::FragmentedSharedBuffer>&&) final;
     75    void didReceiveData(const WebCore::SharedBuffer&) final;
    7576    void didCompleteWithError(const WebCore::ResourceError&, const WebCore::NetworkLoadMetrics&) final;
    7677    void didSendData(uint64_t totalBytesSent, uint64_t totalBytesExpectedToSend) final;

  • trunk/Source/WebKit/NetworkProcess/NetworkDataTask.h

    r287039 r287684  
    4444class ResourceError;
    4545class ResourceResponse;
    46 class FragmentedSharedBuffer;
     46class SharedBuffer;
    4747}
    4848
    … …  
    6464    virtual void didReceiveChallenge(WebCore::AuthenticationChallenge&&, NegotiatedLegacyTLS, ChallengeCompletionHandler&&) = 0;
    6565    virtual void didReceiveResponse(WebCore::ResourceResponse&&, NegotiatedLegacyTLS, ResponseCompletionHandler&&) = 0;
    66     virtual void didReceiveData(Ref<WebCore::FragmentedSharedBuffer>&&) = 0;
     66    virtual void didReceiveData(const WebCore::SharedBuffer&) = 0;
    6767    virtual void didCompleteWithError(const WebCore::ResourceError&, const WebCore::NetworkLoadMetrics&) = 0;
    6868    virtual void didSendData(uint64_t totalBytesSent, uint64_t totalBytesExpectedToSend) = 0;

  • trunk/Source/WebKit/NetworkProcess/NetworkLoad.cpp

    r287224 r287684  
    255255}
    256256
    257 void NetworkLoad::didReceiveData(Ref<FragmentedSharedBuffer>&& buffer)
     257void NetworkLoad::didReceiveData(const WebCore::SharedBuffer& buffer)
    258258{
    259259    // FIXME: This should be the encoded data length, not the decoded data length.
    260     auto size = buffer->size();
    261     m_client.get().didReceiveBuffer(WTFMove(buffer), size);
     260    m_client.get().didReceiveBuffer(buffer, buffer.size());
    262261}
    263262

  • trunk/Source/WebKit/NetworkProcess/NetworkLoad.h

    r287039 r287684  
    8282    void didReceiveChallenge(WebCore::AuthenticationChallenge&&, NegotiatedLegacyTLS, ChallengeCompletionHandler&&) final;
    8383    void didReceiveResponse(WebCore::ResourceResponse&&, NegotiatedLegacyTLS, ResponseCompletionHandler&&) final;
    84     void didReceiveData(Ref<WebCore::FragmentedSharedBuffer>&&) final;
     84    void didReceiveData(const WebCore::SharedBuffer&) final;
    8585    void didCompleteWithError(const WebCore::ResourceError&, const WebCore::NetworkLoadMetrics&) final;
    8686    void didSendData(uint64_t totalBytesSent, uint64_t totalBytesExpectedToSend) final;

  • trunk/Source/WebKit/NetworkProcess/NetworkLoadClient.h

    r287021 r287684  
    5252    virtual void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) = 0;
    5353    virtual void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) = 0;
    54     virtual void didReceiveBuffer(Ref<WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) = 0;
     54    virtual void didReceiveBuffer(const WebCore::FragmentedSharedBuffer&, int reportedEncodedDataLength) = 0;
    5555    virtual void didFinishLoading(const WebCore::NetworkLoadMetrics&) = 0;
    5656    virtual void didFailLoading(const WebCore::ResourceError&) = 0;

  • trunk/Source/WebKit/NetworkProcess/NetworkResourceLoader.cpp

    r287021 r287684  
    864864}
    865865
    866 void NetworkResourceLoader::didReceiveBuffer(Ref<FragmentedSharedBuffer>&& buffer, int reportedEncodedDataLength)
     866void NetworkResourceLoader::didReceiveBuffer(const WebCore::FragmentedSharedBuffer& buffer, int reportedEncodedDataLength)
    867867{
    868868    if (!m_numBytesReceived)
    869         LOADER_RELEASE_LOG("didReceiveBuffer: Started receiving data (reportedEncodedDataLength=%d)", reportedEncodedDataLength);
    870     m_numBytesReceived += buffer->size();
     869        LOADER_RELEASE_LOG("didReceiveData: Started receiving data (reportedEncodedDataLength=%d)", reportedEncodedDataLength);
     870    m_numBytesReceived += buffer.size();
    871871
    872872    ASSERT(!m_cacheEntryForValidation);
    … …  
    875875        // Prevent memory growth in case of streaming data and limit size of entries in the cache.
    876876        const size_t maximumCacheBufferSize = m_cache->capacity() / 8;
    877         if (m_bufferedDataForCache.size() + buffer->size() <= maximumCacheBufferSize)
    878             m_bufferedDataForCache.append(buffer.get());
     877        if (m_bufferedDataForCache.size() + buffer.size() <= maximumCacheBufferSize)
     878            m_bufferedDataForCache.append(buffer);
    879879        else
    880880            m_bufferedDataForCache.reset();
    … …  
    883883        return;
    884884    // FIXME: At least on OS X Yosemite we always get -1 from the resource handle.
    885     unsigned encodedDataLength = reportedEncodedDataLength >= 0 ? reportedEncodedDataLength : buffer->size();
     885    unsigned encodedDataLength = reportedEncodedDataLength >= 0 ? reportedEncodedDataLength : buffer.size();
    886886
    887887    if (m_bufferedData) {
    888         m_bufferedData.append(buffer.get());
     888        m_bufferedData.append(buffer);
    889889        m_bufferedDataEncodedDataLength += encodedDataLength;
    890890        startBufferingTimerIfNeeded();
    … …  
    12741274}
    12751275
    1276 void NetworkResourceLoader::sendBuffer(FragmentedSharedBuffer& buffer, size_t encodedDataLength)
     1276void NetworkResourceLoader::sendBuffer(const FragmentedSharedBuffer& buffer, size_t encodedDataLength)
    12771277{
    12781278    ASSERT(!isSynchronous());

  • trunk/Source/WebKit/NetworkProcess/NetworkResourceLoader.h

    r287021 r287684  
    116116    void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&&) final;
    117117    void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) final;
    118     void didReceiveBuffer(Ref<WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) final;
     118    void didReceiveBuffer(const WebCore::FragmentedSharedBuffer&, int reportedEncodedDataLength) final;
    119119    void didFinishLoading(const WebCore::NetworkLoadMetrics&) final;
    120120    void didFailLoading(const WebCore::ResourceError&) final;
    … …  
    194194    void startBufferingTimerIfNeeded();
    195195    void bufferingTimerFired();
    196     void sendBuffer(WebCore::FragmentedSharedBuffer&, size_t encodedDataLength);
     196    void sendBuffer(const WebCore::FragmentedSharedBuffer&, size_t encodedDataLength);
    197197
    198198    void consumeSandboxExtensions();

  • trunk/Source/WebKit/NetworkProcess/PingLoad.cpp

    r287224 r287684  
    173173}
    174174
    175 void PingLoad::didReceiveData(Ref<FragmentedSharedBuffer>&&)
     175void PingLoad::didReceiveData(const SharedBuffer&)
    176176{
    177177    PING_RELEASE_LOG("didReceiveData");

  • trunk/Source/WebKit/NetworkProcess/PingLoad.h

    r287039 r287684  
    5555    void didReceiveChallenge(WebCore::AuthenticationChallenge&&, NegotiatedLegacyTLS, ChallengeCompletionHandler&&) final;
    5656    void didReceiveResponse(WebCore::ResourceResponse&&, NegotiatedLegacyTLS, ResponseCompletionHandler&&) final;
    57     void didReceiveData(Ref<WebCore::FragmentedSharedBuffer>&&) final;
     57    void didReceiveData(const WebCore::SharedBuffer&) final;
    5858    void didCompleteWithError(const WebCore::ResourceError&, const WebCore::NetworkLoadMetrics&) final;
    5959    void didSendData(uint64_t totalBytesSent, uint64_t totalBytesExpectedToSend) final;

  • trunk/Source/WebKit/NetworkProcess/PreconnectTask.cpp

    r287021 r287684  
    8080}
    8181
    82 void PreconnectTask::didReceiveBuffer(Ref<FragmentedSharedBuffer>&&, int reportedEncodedDataLength)
     82void PreconnectTask::didReceiveBuffer(const FragmentedSharedBuffer&, int reportedEncodedDataLength)
    8383{
    8484    ASSERT_NOT_REACHED();

  • trunk/Source/WebKit/NetworkProcess/PreconnectTask.h

    r287021 r287684  
    5656    void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) final;
    5757    void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) final;
    58     void didReceiveBuffer(Ref<WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) final;
     58    void didReceiveBuffer(const WebCore::FragmentedSharedBuffer&, int reportedEncodedDataLength) final;
    5959    void didFinishLoading(const WebCore::NetworkLoadMetrics&) final;
    6060    void didFailLoading(const WebCore::ResourceError&) final;

  • trunk/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerDownloadTask.cpp

    r286944 r287684  
    3232#include "Logging.h"
    3333#include "NetworkProcess.h"
     34#include "SharedBufferCopy.h"
    3435#include "WebErrors.h"
    3536#include "WebSWContextManagerConnectionMessages.h"
    … …  
    174175}
    175176
    176 void ServiceWorkerDownloadTask::didReceiveData(const IPC::DataReference& data, int64_t encodedDataLength)
     177void ServiceWorkerDownloadTask::didReceiveData(const IPC::SharedBufferCopy& data, int64_t encodedDataLength)
    177178{
    178179    ASSERT(!isMainRunLoop());

  • trunk/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerDownloadTask.h

    r286944 r287684  
    3838namespace IPC {
    3939class FormDataReference;
     40class SharedBufferCopy;
    4041}
    4142
    … …  
    6768
    6869    // IPC Message
    69     void didReceiveData(const IPC::DataReference&, int64_t encodedDataLength);
     70    void didReceiveData(const IPC::SharedBufferCopy&, int64_t encodedDataLength);
    7071    void didReceiveFormData(const IPC::FormDataReference&);
    7172    void didFinish();

  • trunk/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerDownloadTask.messages.in

    r286944 r287684  
    2525messages -> ServiceWorkerDownloadTask NotRefCounted {
    2626    DidFail(WebCore::ResourceError error)
    27     DidReceiveData(IPC::SharedBufferDataReference data, int64_t encodedDataLength)
     27    DidReceiveData(IPC::SharedBufferCopy data, int64_t encodedDataLength)
    2828    DidReceiveFormData(IPC::FormDataReference data)
    2929    DidFinish()

  • trunk/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerFetchTask.cpp

    r286944 r287684  
    3737#include "NetworkSession.h"
    3838#include "ServiceWorkerNavigationPreloader.h"
    39 #include "SharedBufferDataReference.h"
     39#include "SharedBufferCopy.h"
    4040#include "WebCoreArgumentCoders.h"
    4141#include "WebResourceLoaderMessages.h"
    … …  
    226226}
    227227
    228 void ServiceWorkerFetchTask::didReceiveData(const IPC::DataReference& data, int64_t encodedDataLength)
     228void ServiceWorkerFetchTask::didReceiveData(const IPC::SharedBufferCopy& data, int64_t encodedDataLength)
    229229{
    230230    if (m_isDone)
    … …  
    402402            return;
    403403        }
    404         didReceiveData(IPC::DataReference { chunk->data(), chunk->size() }, length);
     404        didReceiveData(Ref { const_cast<WebCore::FragmentedSharedBuffer&>(*chunk) }, length);
    405405    });
    406406}

  • trunk/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerFetchTask.h

    r286944 r287684  
    4949class Decoder;
    5050class FormDataReference;
     51class SharedBufferCopy;
    5152}
    5253
    … …  
    9495    void didReceiveRedirectResponse(WebCore::ResourceResponse&&);
    9596    void didReceiveResponse(WebCore::ResourceResponse&&, bool needsContinueDidReceiveResponseMessage);
    96     void didReceiveData(const IPC::DataReference&, int64_t encodedDataLength);
     97    void didReceiveData(const IPC::SharedBufferCopy&, int64_t encodedDataLength);
    9798    void didReceiveFormData(const IPC::FormDataReference&);
    9899    void didFinish();

  • trunk/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerFetchTask.messages.in

    r266003 r287684  
    2828    DidReceiveRedirectResponse(WebCore::ResourceResponse response)
    2929    DidReceiveResponse(WebCore::ResourceResponse response, bool needsContinueDidReceiveResponseMessage)
    30     DidReceiveData(IPC::SharedBufferDataReference data, int64_t encodedDataLength)
     30    DidReceiveData(IPC::SharedBufferCopy data, int64_t encodedDataLength)
    3131    DidReceiveFormData(IPC::FormDataReference data)
    3232    DidFinish()

  • trunk/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerNavigationPreloader.cpp

    r287676 r287684  
    176176}
    177177
    178 void ServiceWorkerNavigationPreloader::didReceiveBuffer(Ref<FragmentedSharedBuffer>&& buffer, int reportedEncodedDataLength)
     178void ServiceWorkerNavigationPreloader::didReceiveBuffer(const FragmentedSharedBuffer& buffer, int reportedEncodedDataLength)
    179179{
    180180    if (m_bodyCallback)
    181         m_bodyCallback(buffer->makeContiguous(), reportedEncodedDataLength);
     181        m_bodyCallback(RefPtr { &buffer }, reportedEncodedDataLength);
    182182}
    183183

  • trunk/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerNavigationPreloader.h

    r287021 r287684  
    3737namespace WebCore {
    3838class NetworkLoadMetrics;
     39class FragmentedSharedBuffer;
    3940}
    4041
    … …  
    5556    using ResponseCallback = Function<void()>;
    5657    void waitForResponse(ResponseCallback&&);
    57     using BodyCallback = Function<void(RefPtr<WebCore::SharedBuffer>&&, int reportedEncodedDataLength)>;
     58    using BodyCallback = Function<void(RefPtr<const WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength)>;
    5859    void waitForBody(BodyCallback&&);
    5960
    … …  
    7273    void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) final;
    7374    void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) final;
    74     void didReceiveBuffer(Ref<WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) final;
     75    void didReceiveBuffer(const WebCore::FragmentedSharedBuffer&, int reportedEncodedDataLength) final;
    7576    void didFinishLoading(const WebCore::NetworkLoadMetrics&) final;
    7677    void didFailLoading(const WebCore::ResourceError&) final;

  • trunk/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerSoftUpdateLoader.cpp

    r287021 r287684  
    178178}
    179179
    180 void ServiceWorkerSoftUpdateLoader::didReceiveBuffer(Ref<FragmentedSharedBuffer>&& buffer, int reportedEncodedDataLength)
     180void ServiceWorkerSoftUpdateLoader::didReceiveBuffer(const WebCore::FragmentedSharedBuffer& buffer, int reportedEncodedDataLength)
    181181{
    182182    if (!m_decoder) {
    … …  
    187187    }
    188188
    189     if (auto size = buffer->size())
    190         m_script.append(m_decoder->decode(buffer->makeContiguous()->data(), size));
     189    buffer.forEachSegment([&](auto& segment) {
     190        if (segment.size())
     191            m_script.append(m_decoder->decode(segment.data(), segment.size()));
     192    });
    191193}
    192194

  • trunk/Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerSoftUpdateLoader.h

    r287021 r287684  
    6565    void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) final;
    6666    void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) final;
    67     void didReceiveBuffer(Ref<WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) final;
     67    void didReceiveBuffer(const WebCore::FragmentedSharedBuffer&, int reportedEncodedDataLength) final;
    6868    void didFinishLoading(const WebCore::NetworkLoadMetrics&) final;
    6969    void didFailLoading(const WebCore::ResourceError&) final;

  • trunk/Source/WebKit/NetworkProcess/cache/NetworkCacheSpeculativeLoad.cpp

    r287021 r287684  
    121121}
    122122
    123 void SpeculativeLoad::didReceiveBuffer(Ref<FragmentedSharedBuffer>&& buffer, int reportedEncodedDataLength)
     123void SpeculativeLoad::didReceiveBuffer(const WebCore::FragmentedSharedBuffer& buffer, int reportedEncodedDataLength)
    124124{
    125125    ASSERT(!m_cacheEntry);
    … …  
    128128        // Prevent memory growth in case of streaming data.
    129129        const size_t maximumCacheBufferSize = 10 * 1024 * 1024;
    130         if (m_bufferedDataForCache.size() + buffer->size() <= maximumCacheBufferSize)
    131             m_bufferedDataForCache.append(buffer.get());
     130        if (m_bufferedDataForCache.size() + buffer.size() <= maximumCacheBufferSize)
     131            m_bufferedDataForCache.append(buffer);
    132132        else
    133133            m_bufferedDataForCache.reset();

  • trunk/Source/WebKit/NetworkProcess/cache/NetworkCacheSpeculativeLoad.h

    r287021 r287684  
    6262    void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) override;
    6363    void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) override;
    64     void didReceiveBuffer(Ref<WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) override;
     64    void didReceiveBuffer(const WebCore::FragmentedSharedBuffer&, int reportedEncodedDataLength) override;
    6565    void didFinishLoading(const WebCore::NetworkLoadMetrics&) override;
    6666    void didFailLoading(const WebCore::ResourceError&) override;

  • trunk/Source/WebKit/NetworkProcess/cocoa/NetworkDataTaskCocoa.h

    r287021 r287684  
    3939namespace WebCore {
    4040class RegistrableDomain;
     41class SharedBuffer;
    4142}
    4243
    … …  
    6364    void didCompleteWithError(const WebCore::ResourceError&, const WebCore::NetworkLoadMetrics&);
    6465    void didReceiveResponse(WebCore::ResourceResponse&&, NegotiatedLegacyTLS, ResponseCompletionHandler&&);
    65     void didReceiveData(Ref<WebCore::FragmentedSharedBuffer>&&);
     66    void didReceiveData(const WebCore::SharedBuffer&);
    6667
    6768    void willPerformHTTPRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, RedirectCompletionHandler&&);

  • trunk/Source/WebKit/NetworkProcess/cocoa/NetworkDataTaskCocoa.mm

    r287039 r287684  
    444444}
    445445
    446 void NetworkDataTaskCocoa::didReceiveData(Ref<WebCore::FragmentedSharedBuffer>&& data)
    447 {
    448     WTFEmitSignpost(m_task.get(), "DataTask", "received %zd bytes", data->size());
     446void NetworkDataTaskCocoa::didReceiveData(const WebCore::SharedBuffer& data)
     447{
     448    WTFEmitSignpost(m_task.get(), "DataTask", "received %zd bytes", data.size());
    449449
    450450    if (m_client)
    451         m_client->didReceiveData(WTFMove(data));
     451        m_client->didReceiveData(data);
    452452}
    453453

  • trunk/Source/WebKit/NetworkProcess/curl/NetworkDataTaskCurl.cpp

    r287224 r287684  
    3838#include <WebCore/ResourceError.h>
    3939#include <WebCore/SameSiteInfo.h>
     40#include <WebCore/SharedBuffer.h>
    4041#include <WebCore/ShouldRelaxThirdPartyCookieBlocking.h>
    4142#include <WebCore/SynchronousLoaderClient.h>
    … …  
    173174}
    174175
    175 void NetworkDataTaskCurl::curlDidReceiveBuffer(CurlRequest&, Ref<FragmentedSharedBuffer>&& buffer)
     176void NetworkDataTaskCurl::curlDidReceiveData(CurlRequest&, const SharedBuffer& buffer)
    176177{
    177178    Ref protectedThis { *this };
    … …  
    179180        return;
    180181
    181     m_client->didReceiveData(WTFMove(buffer));
     182    m_client->didReceiveData(buffer);
    182183}
    183184

  • trunk/Source/WebKit/NetworkProcess/curl/NetworkDataTaskCurl.h

    r287021 r287684  
    3737namespace WebCore {
    3838class CurlRequest;
     39class SharedBuffer;
    3940}
    4041
    … …  
    6970    void curlDidSendData(WebCore::CurlRequest&, unsigned long long, unsigned long long) override;
    7071    void curlDidReceiveResponse(WebCore::CurlRequest&, WebCore::CurlResponse&&) override;
    71     void curlDidReceiveBuffer(WebCore::CurlRequest&, Ref<WebCore::FragmentedSharedBuffer>&&) override;
     72    void curlDidReceiveData(WebCore::CurlRequest&, const WebCore::SharedBuffer&) override;
    7273    void curlDidComplete(WebCore::CurlRequest&, WebCore::NetworkLoadMetrics&&) override;
    7374    void curlDidFailWithError(WebCore::CurlRequest&, WebCore::ResourceError&&, WebCore::CertificateInfo&&) override;

  • trunk/Source/WebKit/Platform/IPC/SharedBufferCopy.h

    r287021 r287684  
    2929#pragma once
    3030
     31#include "DataReference.h"
    3132#include <WebCore/SharedBuffer.h>
    3233

  • trunk/Source/WebKit/Shared/mac/MediaFormatReader/MediaFormatReader.cpp

    r286816 r287684  
    186186
    187187    Locker locker { m_parseTracksLock };
    188     ASSERT(!m_parseTracksStatus);
    189     ASSERT(m_duration.isInvalid());
    190     ASSERT(m_trackReaders.isEmpty());
     188    ASSERT(!m_parseTracksStatus || (m_init && errorCode));
     189    ASSERT(m_duration.isInvalid() || (m_init && errorCode));
     190    ASSERT(m_trackReaders.isEmpty() || (m_init && errorCode));
    191191
    192192    ALWAYS_LOG_IF_POSSIBLE(LOGIDENTIFIER);
    … …  
    222222
    223223    m_parseTracksCondition.notifyAll();
     224    m_init = true;
    224225}
    225226

  • trunk/Source/WebKit/Shared/mac/MediaFormatReader/MediaFormatReader.h

    r278253 r287684  
    8888    RefPtr<const Logger> m_logger;
    8989    const void* m_logIdentifier;
     90    bool m_init { false };
    9091};
    9192

  • trunk/Source/WebKit/UIProcess/WebURLSchemeTask.cpp

    r287021 r287684  
    169169}
    170170
    171 auto WebURLSchemeTask::didReceiveData(Ref<FragmentedSharedBuffer>&& buffer) -> ExceptionType
     171auto WebURLSchemeTask::didReceiveData(const SharedBuffer& buffer) -> ExceptionType
    172172{
    173173    ASSERT(RunLoop::isMain());
    … …  
    188188
    189189    if (isSync()) {
    190         m_syncData.append(WTFMove(buffer));
     190        m_syncData.append(buffer);
    191191        return ExceptionType::None;
    192192    }
    193193
    194     m_process->send(Messages::WebPage::URLSchemeTaskDidReceiveData(m_urlSchemeHandler->identifier(), m_resourceLoaderID, buffer.get()), m_webPageID);
     194    m_process->send(Messages::WebPage::URLSchemeTaskDidReceiveData(m_urlSchemeHandler->identifier(), m_resourceLoaderID, buffer), m_webPageID);
    195195    return ExceptionType::None;
    196196}

  • trunk/Source/WebKit/UIProcess/WebURLSchemeTask.h

    r287021 r287684  
    8484    ExceptionType didPerformRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&);
    8585    ExceptionType didReceiveResponse(const WebCore::ResourceResponse&);
    86     ExceptionType didReceiveData(Ref<WebCore::FragmentedSharedBuffer>&&);
     86    ExceptionType didReceiveData(const WebCore::SharedBuffer&);
    8787    ExceptionType didComplete(const WebCore::ResourceError&);
    8888

  • trunk/Source/WebKit/WebProcess/GPU/media/RemoteMediaResourceProxy.cpp

    r285335 r287684  
    7373}
    7474
    75 void RemoteMediaResourceProxy::dataReceived(WebCore::PlatformMediaResource&, const uint8_t* data, int length)
     75void RemoteMediaResourceProxy::dataReceived(WebCore::PlatformMediaResource&, const WebCore::SharedBuffer& buffer)
    7676{
    77     auto sharedMemory = SharedMemory::allocate(length);
     77    auto sharedMemory = SharedMemory::copyBuffer(buffer);
    7878    if (!sharedMemory)
    7979        return;
    80 
    81     auto sharedMemoryPtr = static_cast<char*>(sharedMemory->data());
    82     memcpy(sharedMemoryPtr, data, length);
    8380
    8481    SharedMemory::Handle handle;
    … …  
    8683    // Take ownership of shared memory and mark it as media-related memory.
    8784    handle.takeOwnershipOfMemory(MemoryLedger::Media);
    88     m_connection->send(Messages::RemoteMediaResourceManager::DataReceived(m_id, SharedMemory::IPCHandle { WTFMove(handle), static_cast<uint64_t>(length) }), 0);
     85    m_connection->send(Messages::RemoteMediaResourceManager::DataReceived(m_id, SharedMemory::IPCHandle { WTFMove(handle), buffer.size() }), 0);
    8986}
    9087

  • trunk/Source/WebKit/WebProcess/GPU/media/RemoteMediaResourceProxy.h

    r278516 r287684  
    4848    bool shouldCacheResponse(WebCore::PlatformMediaResource&, const WebCore::ResourceResponse&) final;
    4949    void dataSent(WebCore::PlatformMediaResource&, unsigned long long, unsigned long long) final;
    50     void dataReceived(WebCore::PlatformMediaResource&, const uint8_t*, int) final;
     50    void dataReceived(WebCore::PlatformMediaResource&, const WebCore::SharedBuffer&) final;
    5151    void accessControlCheckFailed(WebCore::PlatformMediaResource&, const WebCore::ResourceError&) final;
    5252    void loadFailed(WebCore::PlatformMediaResource&, const WebCore::ResourceError&) final;

  • trunk/Source/WebKit/WebProcess/Network/WebResourceLoader.cpp

    r287414 r287684  
    3131#include "NetworkProcessConnection.h"
    3232#include "NetworkResourceLoaderMessages.h"
     33#include "SharedBufferCopy.h"
    3334#include "WebCoreArgumentCoders.h"
    3435#include "WebErrors.h"
    … …  
    201202}
    202203
    203 void WebResourceLoader::didReceiveData(const IPC::DataReference& data, int64_t encodedDataLength)
     204void WebResourceLoader::didReceiveData(const IPC::SharedBufferCopy& data, int64_t encodedDataLength)
    204205{
    205206    LOG(Network, "(WebProcess) WebResourceLoader::didReceiveData of size %lu for '%s'", data.size(), m_coreLoader->url().string().latin1().data());
    … …  
    207208
    208209    if (UNLIKELY(m_interceptController.isIntercepting(m_coreLoader->identifier()))) {
    209         auto buffer = SharedBuffer::create(data.data(), data.size());
    210         m_interceptController.defer(m_coreLoader->identifier(), [this, protectedThis = Ref { *this }, buffer = WTFMove(buffer), encodedDataLength]() mutable {
     210        m_interceptController.defer(m_coreLoader->identifier(), [this, protectedThis = Ref { *this }, buffer = data.buffer(), encodedDataLength]() mutable {
    211211            if (m_coreLoader)
    212                 didReceiveData({ buffer->data(), buffer->size() }, encodedDataLength);
     212                didReceiveData(WTFMove(buffer), encodedDataLength);
    213213        });
    214214        return;
    … …  
    219219    m_numBytesReceived += data.size();
    220220
    221     m_coreLoader->didReceiveData(data.data(), data.size(), encodedDataLength, DataPayloadBytes);
     221    auto buffer = data.buffer() ? Ref { *data.buffer() } : SharedBuffer::create();
     222    m_coreLoader->didReceiveData(buffer, encodedDataLength, DataPayloadBytes);
    222223}
    223224
    … …  
    307308    WEBRESOURCELOADER_RELEASE_LOG("didReceiveResource:");
    308309
    309     RefPtr<FragmentedSharedBuffer> buffer = handle.tryWrapInSharedBuffer();
     310    RefPtr<SharedBuffer> buffer = handle.tryWrapInSharedBuffer();
    310311
    311312    if (!buffer) {
    … …  
    324325    // Only send data to the didReceiveData callback if it exists.
    325326    if (unsigned bufferSize = buffer->size())
    326         m_coreLoader->didReceiveBuffer(buffer.releaseNonNull(), bufferSize, DataPayloadWholeResource);
     327        m_coreLoader->didReceiveData(buffer.releaseNonNull(), bufferSize, DataPayloadWholeResource);
    327328
    328329    if (!m_coreLoader)

  • trunk/Source/WebKit/WebProcess/Network/WebResourceLoader.h

    r282712 r287684  
    4040namespace IPC {
    4141class FormDataReference;
     42class SharedBufferCopy;
    4243}
    4344
    … …  
    8182    void didSendData(uint64_t bytesSent, uint64_t totalBytesToBeSent);
    8283    void didReceiveResponse(const WebCore::ResourceResponse&, bool needsContinueDidReceiveResponseMessage);
    83     void didReceiveData(const IPC::DataReference&, int64_t encodedDataLength);
     84    void didReceiveData(const IPC::SharedBufferCopy& data, int64_t encodedDataLength);
    8485    void didFinishResourceLoad(const WebCore::NetworkLoadMetrics&);
    8586    void didFailResourceLoad(const WebCore::ResourceError&);

  • trunk/Source/WebKit/WebProcess/Network/WebResourceLoader.messages.in

    r266003 r287684  
    2525    DidSendData(uint64_t bytesSent, uint64_t totalBytesToBeSent)
    2626    DidReceiveResponse(WebCore::ResourceResponse response, bool needsContinueDidReceiveResponseMessage)
    27     DidReceiveData(IPC::SharedBufferDataReference data, int64_t encodedDataLength)
     27    DidReceiveData(IPC::SharedBufferCopy data, int64_t encodedDataLength)
    2828    DidFinishResourceLoad(WebCore::NetworkLoadMetrics networkLoadMetrics)
    2929    DidFailResourceLoad(WebCore::ResourceError error)

  • trunk/Source/WebKit/WebProcess/Plugins/PDF/PDFPlugin.h

    r287163 r287684  
    6666class Element;
    6767struct PluginInfo;
     68class SharedBuffer;
    6869}
    6970
    … …  
    177178    void streamWillSendRequest(uint64_t streamID, const URL& requestURL, const URL& responseURL, int responseStatus) final { }
    178179    void streamDidReceiveResponse(uint64_t streamID, const URL& responseURL, uint32_t streamLength, uint32_t lastModifiedTime, const String& mimeType, const String& headers, const String& suggestedFileName) final;
    179     void streamDidReceiveData(uint64_t streamID, const uint8_t* bytes, int length) final;
     180    void streamDidReceiveData(uint64_t streamID, const WebCore::SharedBuffer&) final;
    180181    void streamDidFinishLoading(uint64_t streamID) final;
    181182    void streamDidFail(uint64_t streamID, bool wasCancelled) final;
    182183    void manualStreamDidReceiveResponse(const URL& responseURL, uint32_t streamLength, uint32_t lastModifiedTime, const WTF::String& mimeType, const WTF::String& headers, const String& suggestedFileName) final;
    183     void manualStreamDidReceiveData(const uint8_t* bytes, int length) final;
     184    void manualStreamDidReceiveData(const WebCore::SharedBuffer&) final;
    184185    void manualStreamDidFinishLoading() final;
    185186    void manualStreamDidFail(bool wasCancelled) final;
    … …  
    363364        void willSendRequest(WebCore::NetscapePlugInStreamLoader*, WebCore::ResourceRequest&&, const WebCore::ResourceResponse& redirectResponse, CompletionHandler<void(WebCore::ResourceRequest&&)>&&) final;
    364365        void didReceiveResponse(WebCore::NetscapePlugInStreamLoader*, const WebCore::ResourceResponse&) final;
    365         void didReceiveData(WebCore::NetscapePlugInStreamLoader*, const uint8_t*, int) final;
     366        void didReceiveData(WebCore::NetscapePlugInStreamLoader*, const WebCore::SharedBuffer&) final;
    366367        void didFail(WebCore::NetscapePlugInStreamLoader*, const WebCore::ResourceError&) final;
    367368        void didFinishLoading(WebCore::NetscapePlugInStreamLoader*) final;

  • trunk/Source/WebKit/WebProcess/Plugins/PDF/PDFPlugin.mm

    r287452 r287684  
    9595#import <WebCore/ScrollbarTheme.h>
    9696#import <WebCore/Settings.h>
     97#import <WebCore/SharedBuffer.h>
    9798#import <WebCore/WebAccessibilityObjectWrapperMac.h>
    9899#import <WebCore/WheelEventTestMonitor.h>
    … …  
    11921193}
    11931194
    1194 void PDFPlugin::PDFPluginStreamLoaderClient::didReceiveData(NetscapePlugInStreamLoader* loader, const uint8_t* data, int count)
     1195void PDFPlugin::PDFPluginStreamLoaderClient::didReceiveData(NetscapePlugInStreamLoader* loader, const SharedBuffer& data)
    11951196{
    11961197    if (!m_pdfPlugin)
    … …  
    12011202        return;
    12021203
    1203     request->addData(data, count);
     1204    request->addData(data.data(), data.size());
    12041205}
    12051206
    … …  
    17191720}
    17201721
    1721 void PDFPlugin::streamDidReceiveData(uint64_t streamID, const uint8_t* bytes, int length)
     1722void PDFPlugin::streamDidReceiveData(uint64_t streamID, const SharedBuffer& buffer)
    17221723{
    17231724    ASSERT_UNUSED(streamID, streamID == pdfDocumentRequestID);
    … …  
    17261727        m_data = adoptCF(CFDataCreateMutable(0, 0));
    17271728
    1728     CFDataAppendBytes(m_data.get(), bytes, length);
    1729     m_streamedBytes += length;
     1729    CFDataAppendBytes(m_data.get(), buffer.data(), buffer.size());
     1730    m_streamedBytes += buffer.size();
    17301731}
    17311732
    … …  
    17641765}
    17651766
    1766 void PDFPlugin::manualStreamDidReceiveData(const uint8_t* bytes, int length)
     1767void PDFPlugin::manualStreamDidReceiveData(const SharedBuffer& buffer)
    17671768{
    17681769    if (!m_data)
    17691770        m_data = adoptCF(CFDataCreateMutable(0, 0));
    17701771
    1771     ensureDataBufferLength(m_streamedBytes + length);
    1772     memcpy(CFDataGetMutableBytePtr(m_data.get()) + m_streamedBytes, bytes, length);
    1773     m_streamedBytes += length;
     1772    ensureDataBufferLength(m_streamedBytes + buffer.size());
     1773    memcpy(CFDataGetMutableBytePtr(m_data.get()) + m_streamedBytes, buffer.data(), buffer.size());
     1774    m_streamedBytes += buffer.size();
    17741775
    17751776#if HAVE(INCREMENTAL_PDF_APIS)

  • trunk/Source/WebKit/WebProcess/Plugins/Plugin.h

    r287163 r287684  
    5555class FloatPoint;
    5656class FloatSize;
     57class FragmentedSharedBuffer;
    5758class GraphicsContext;
    5859class IntPoint;
    … …  
    6061class IntSize;
    6162class Scrollbar;
    62 class FragmentedSharedBuffer;
     63class SharedBuffer;
    6364}
    6465
    … …  
    161162
    162163    // Tells the plug-in that a stream did receive data.
    163     virtual void streamDidReceiveData(uint64_t streamID, const uint8_t* bytes, int length) = 0;
     164    virtual void streamDidReceiveData(uint64_t streamID, const WebCore::SharedBuffer&) = 0;
    164165
    165166    // Tells the plug-in that a stream has finished loading.
    … …  
    174175
    175176    // Tells the plug-in that the manual stream did receive data.
    176     virtual void manualStreamDidReceiveData(const uint8_t* bytes, int length) = 0;
     177    virtual void manualStreamDidReceiveData(const WebCore::SharedBuffer&) = 0;
    177178
    178179    // Tells the plug-in that a stream has finished loading.

  • trunk/Source/WebKit/WebProcess/Plugins/PluginView.cpp

    r287163 r287684  
    128128    void willSendRequest(NetscapePlugInStreamLoader*, ResourceRequest&&, const ResourceResponse& redirectResponse, CompletionHandler<void(ResourceRequest&&)>&&) override;
    129129    void didReceiveResponse(NetscapePlugInStreamLoader*, const ResourceResponse&) override;
    130     void didReceiveData(NetscapePlugInStreamLoader*, const uint8_t*, int) override;
     130    void didReceiveData(NetscapePlugInStreamLoader*, const SharedBuffer&) override;
    131131    void didFail(NetscapePlugInStreamLoader*, const ResourceError&) override;
    132132    void didFinishLoading(NetscapePlugInStreamLoader*) override;
    … …  
    236236}
    237237
    238 void PluginView::Stream::didReceiveData(NetscapePlugInStreamLoader*, const uint8_t* bytes, int length)
    239 {
    240     m_pluginView->m_plugin->streamDidReceiveData(m_streamID, bytes, length);
     238void PluginView::Stream::didReceiveData(NetscapePlugInStreamLoader*, const SharedBuffer& buffer)
     239{
     240    m_pluginView->m_plugin->streamDidReceiveData(m_streamID, buffer);
    241241}
    242242
    … …  
    375375}
    376376
    377 void PluginView::manualLoadDidReceiveData(const uint8_t* bytes, int length)
     377void PluginView::manualLoadDidReceiveData(const SharedBuffer& buffer)
    378378{
    379379    // The plug-in can be null here if it failed to initialize.
    … …  
    383383    if (!m_isInitialized) {
    384384        ASSERT(m_manualStreamState == ManualStreamState::HasReceivedResponse);
    385         m_manualStreamData.append(bytes, length);
    386         return;
    387     }
    388 
    389     m_plugin->manualStreamDidReceiveData(bytes, length);
     385        m_manualStreamData.append(buffer);
     386        return;
     387    }
     388
     389    m_plugin->manualStreamDidReceiveData(buffer);
    390390}
    391391
    … …  
    11721172    // Deliver the data.
    11731173    if (m_manualStreamData) {
    1174         auto buffer = m_manualStreamData.take();
    1175         for (const auto& element : buffer.get())
    1176             manualLoadDidReceiveData(element.segment->data(), element.segment->size());
     1174        m_manualStreamData.take()->forEachSegmentAsSharedBuffer([&](auto&& buffer) {
     1175            manualLoadDidReceiveData(buffer);
     1176        });
    11771177    }
    11781178

  • trunk/Source/WebKit/WebProcess/Plugins/PluginView.h

    r287163 r287684  
    7474
    7575    void manualLoadDidReceiveResponse(const WebCore::ResourceResponse&);
    76     void manualLoadDidReceiveData(const uint8_t* bytes, int length);
     76    void manualLoadDidReceiveData(const WebCore::SharedBuffer&);
    7777    void manualLoadDidFinishLoading();
    7878    void manualLoadDidFail(const WebCore::ResourceError&);

  • trunk/Source/WebKit/WebProcess/Storage/WebServiceWorkerFetchTaskClient.cpp

    r287021 r287684  
    7373}
    7474
    75 void WebServiceWorkerFetchTaskClient::didReceiveData(Ref<FragmentedSharedBuffer>&& buffer)
     75void WebServiceWorkerFetchTaskClient::didReceiveData(const SharedBuffer& buffer)
    7676{
    7777    if (!m_connection)
    … …  
    8181        if (!std::holds_alternative<SharedBufferBuilder>(m_responseData))
    8282            m_responseData = SharedBufferBuilder();
    83         std::get<SharedBufferBuilder>(m_responseData).append(WTFMove(buffer));
    84         return;
    85     }
    86 
    87     if (m_isDownload)
    88         m_connection->send(Messages::ServiceWorkerDownloadTask::DidReceiveData { buffer.get(), static_cast<int64_t>(buffer->size()) }, m_fetchIdentifier);
    89     else
    90         m_connection->send(Messages::ServiceWorkerFetchTask::DidReceiveData { buffer.get(), static_cast<int64_t>(buffer->size()) }, m_fetchIdentifier);
     83        std::get<SharedBufferBuilder>(m_responseData).append(buffer);
     84        return;
     85    }
     86
     87    if (m_isDownload)
     88        m_connection->send(Messages::ServiceWorkerDownloadTask::DidReceiveData { buffer, static_cast<int64_t>(buffer.size()) }, m_fetchIdentifier);
     89    else
     90        m_connection->send(Messages::ServiceWorkerFetchTask::DidReceiveData { buffer, static_cast<int64_t>(buffer.size()) }, m_fetchIdentifier);
    9191}
    9292
    … …  
    137137}
    138138
    139 void WebServiceWorkerFetchTaskClient::didReceiveBlobChunk(const uint8_t* data, size_t size)
    140 {
    141     if (!m_connection)
    142         return;
    143 
    144     if (m_isDownload)
    145         m_connection->send(Messages::ServiceWorkerDownloadTask::DidReceiveData { { data, size }, static_cast<int64_t>(size) }, m_fetchIdentifier);
    146     else
    147         m_connection->send(Messages::ServiceWorkerFetchTask::DidReceiveData { { data, size }, static_cast<int64_t>(size) }, m_fetchIdentifier);
     139void WebServiceWorkerFetchTaskClient::didReceiveBlobChunk(const SharedBuffer& buffer)
     140{
     141    if (!m_connection)
     142        return;
     143
     144    if (m_isDownload)
     145        m_connection->send(Messages::ServiceWorkerDownloadTask::DidReceiveData { buffer, static_cast<int64_t>(buffer.size()) }, m_fetchIdentifier);
     146    else
     147        m_connection->send(Messages::ServiceWorkerFetchTask::DidReceiveData { buffer , static_cast<int64_t>(buffer.size()) }, m_fetchIdentifier);
    148148}
    149149
    … …  
    229229            didFinish();
    230230    }, [this](const SharedBufferBuilder& buffer) {
    231         didReceiveData(*buffer.get());
     231        didReceiveData(buffer.copy()->makeContiguous());
    232232        if (m_didFinish)
    233233            didFinish();

  • trunk/Source/WebKit/WebProcess/Storage/WebServiceWorkerFetchTaskClient.h

    r287021 r287684  
    5151    void didReceiveResponse(const WebCore::ResourceResponse&) final;
    5252    void didReceiveRedirection(const WebCore::ResourceResponse&) final;
    53     void didReceiveData(Ref<WebCore::FragmentedSharedBuffer>&&) final;
     53    void didReceiveData(const WebCore::SharedBuffer&) final;
    5454    void didReceiveFormDataAndFinish(Ref<WebCore::FormData>&&) final;
    5555    void didFail(const WebCore::ResourceError&) final;
    … …  
    6161
    6262    void cleanup();
    63    
    64     void didReceiveBlobChunk(const uint8_t* data, size_t);
     63
     64    void didReceiveBlobChunk(const WebCore::SharedBuffer&);
    6565    void didFinishBlobLoading();
    6666
    … …  
    7070        // FetchLoaderClient API
    7171        void didReceiveResponse(const WebCore::ResourceResponse&) final { }
    72         void didReceiveData(const uint8_t* data, size_t size) final { client->didReceiveBlobChunk(data, size); }
     72        void didReceiveData(const WebCore::SharedBuffer& data) final { client->didReceiveBlobChunk(data); }
    7373        void didFail(const WebCore::ResourceError& error) final { client->didFail(error); }
    7474        void didSucceed() final { client->didFinishBlobLoading(); }

  • trunk/Source/WebKit/WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp

    r287021 r287684  
    11531153}
    11541154
    1155 void WebFrameLoaderClient::committedLoad(DocumentLoader* loader, const uint8_t* data, int length)
     1155void WebFrameLoaderClient::committedLoad(DocumentLoader* loader, const SharedBuffer& data)
    11561156{
    11571157    if (!m_pluginView)
    1158         loader->commitData(data, length);
     1158        loader->commitData(data);
    11591159
    11601160    // If the document is a stand-alone media document, now is the right time to cancel the WebKit load.
    … …  
    11781178        m_hasSentResponseToPluginView = true;
    11791179    }
    1180     m_pluginView->manualLoadDidReceiveData(data, length);
     1180    m_pluginView->manualLoadDidReceiveData(data);
    11811181}
    11821182

  • trunk/Source/WebKit/WebProcess/WebCoreSupport/WebFrameLoaderClient.h

    r284406 r287684  
    153153    void didReplaceMultipartContent() final;
    154154
    155     void committedLoad(WebCore::DocumentLoader*, const uint8_t*, int) final;
     155    void committedLoad(WebCore::DocumentLoader*, const WebCore::SharedBuffer&) final;
    156156    void finishedLoading(WebCore::DocumentLoader*) final;
    157157   

  • trunk/Source/WebKit/WebProcess/WebCoreSupport/ios/WebPreviewLoaderClient.cpp

    r287021 r287684  
    5050WebPreviewLoaderClient::~WebPreviewLoaderClient() = default;
    5151
    52 void WebPreviewLoaderClient::didReceiveBuffer(const FragmentedSharedBuffer& buffer)
     52void WebPreviewLoaderClient::didReceiveData(const SharedBuffer& buffer)
    5353{
    5454    auto webPage = WebProcess::singleton().webPage(m_pageID);

  • trunk/Source/WebKit/WebProcess/WebCoreSupport/ios/WebPreviewLoaderClient.h

    r287021 r287684  
    4747private:
    4848    WebPreviewLoaderClient(const String& fileName, const String& uti, WebCore::PageIdentifier);
    49     void didReceiveBuffer(const WebCore::FragmentedSharedBuffer&) override;
     49    void didReceiveData(const WebCore::SharedBuffer&) override;
    5050    void didFinishLoading() override;
    5151    void didFail() override;

  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.cpp

    r287121 r287684  
    70587058}
    70597059
    7060 void WebPage::urlSchemeTaskDidReceiveData(WebURLSchemeHandlerIdentifier handlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, const IPC::DataReference& data)
     7060void WebPage::urlSchemeTaskDidReceiveData(WebURLSchemeHandlerIdentifier handlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, const IPC::SharedBufferCopy& data)
    70617061{
    70627062    auto* handler = m_identifierToURLSchemeHandlerProxyMap.get(handlerIdentifier);
    70637063    ASSERT(handler);
    70647064
    7065     handler->taskDidReceiveData(taskIdentifier, data.size(), data.data());
     7065    handler->taskDidReceiveData(taskIdentifier, data.buffer() ? *data.buffer() : SharedBuffer::create().get());
    70667066}
    70677067

  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.h

    r287163 r287684  
    185185class Decoder;
    186186class FormDataReference;
     187class SharedBufferCopy;
    187188}
    188189
    … …  
    18971898    void urlSchemeTaskDidPerformRedirection(WebURLSchemeHandlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, WebCore::ResourceResponse&&, WebCore::ResourceRequest&&);
    18981899    void urlSchemeTaskDidReceiveResponse(WebURLSchemeHandlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, const WebCore::ResourceResponse&);
    1899     void urlSchemeTaskDidReceiveData(WebURLSchemeHandlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, const IPC::DataReference&);
     1900    void urlSchemeTaskDidReceiveData(WebURLSchemeHandlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, const IPC::SharedBufferCopy&);
    19001901    void urlSchemeTaskDidComplete(WebURLSchemeHandlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, const WebCore::ResourceError&);
    19011902

  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.messages.in

    r287163 r287684  
    565565    URLSchemeTaskDidPerformRedirection(WebKit::WebURLSchemeHandlerIdentifier handlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, WebCore::ResourceResponse response, WebCore::ResourceRequest proposedRequest)
    566566    URLSchemeTaskDidReceiveResponse(WebKit::WebURLSchemeHandlerIdentifier handlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, WebCore::ResourceResponse response)
    567     URLSchemeTaskDidReceiveData(WebKit::WebURLSchemeHandlerIdentifier handlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, IPC::SharedBufferDataReference data)
     567    URLSchemeTaskDidReceiveData(WebKit::WebURLSchemeHandlerIdentifier handlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, IPC::SharedBufferCopy data)
    568568    URLSchemeTaskDidComplete(WebKit::WebURLSchemeHandlerIdentifier handlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, WebCore::ResourceError error)
    569569

  • trunk/Source/WebKit/WebProcess/WebPage/WebURLSchemeHandlerProxy.cpp

    r282756 r287684  
    9797}
    9898
    99 void WebURLSchemeHandlerProxy::taskDidReceiveData(WebCore::ResourceLoaderIdentifier taskIdentifier, size_t size, const uint8_t* data)
     99void WebURLSchemeHandlerProxy::taskDidReceiveData(WebCore::ResourceLoaderIdentifier taskIdentifier, const SharedBuffer& data)
    100100{
    101101    auto* task = m_tasks.get(taskIdentifier);
    … …  
    103103        return;
    104104
    105     task->didReceiveData(size, data);
     105    task->didReceiveData(data);
    106106}
    107107

  • trunk/Source/WebKit/WebProcess/WebPage/WebURLSchemeHandlerProxy.h

    r282756 r287684  
    3636class ResourceResponse;
    3737class ResourceRequest;
     38class SharedBuffer;
    3839}
    3940
    … …  
    6061    void taskDidPerformRedirection(WebCore::ResourceLoaderIdentifier, WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, CompletionHandler<void(WebCore::ResourceRequest&&)>&&);
    6162    void taskDidReceiveResponse(WebCore::ResourceLoaderIdentifier, const WebCore::ResourceResponse&);
    62     void taskDidReceiveData(WebCore::ResourceLoaderIdentifier, size_t, const uint8_t* data);
     63    void taskDidReceiveData(WebCore::ResourceLoaderIdentifier, const WebCore::SharedBuffer&);
    6364    void taskDidComplete(WebCore::ResourceLoaderIdentifier, const WebCore::ResourceError&);
    6465    void taskDidStopLoading(WebURLSchemeTaskProxy&);

  • trunk/Source/WebKit/WebProcess/WebPage/WebURLSchemeTaskProxy.cpp

    r282756 r287684  
    141141}
    142142
    143 void WebURLSchemeTaskProxy::didReceiveData(size_t size, const uint8_t* data)
     143void WebURLSchemeTaskProxy::didReceiveData(const WebCore::SharedBuffer& data)
    144144{
    145145    if (!hasLoader())
    … …  
    148148    if (m_waitingForCompletionHandler) {
    149149        WEBURLSCHEMETASKPROXY_RELEASE_LOG("didReceiveData: Received data during response processing, queuing it.");
    150         queueTask([this, protectedThis = Ref { *this }, dataVector = Vector { data, size }] {
    151             didReceiveData(dataVector.size(), dataVector.data());
     150        queueTask([this, protectedThis = Ref { *this }, data = Ref { data }] {
     151            didReceiveData(data);
    152152        });
    153153        return;
    … …  
    155155
    156156    Ref protectedThis { *this };
    157     m_coreLoader->didReceiveData(data, size, 0, DataPayloadType::DataPayloadBytes);
     157    m_coreLoader->didReceiveData(data, 0, DataPayloadType::DataPayloadBytes);
    158158    processNextPendingTask();
    159159}

  • trunk/Source/WebKit/WebProcess/WebPage/WebURLSchemeTaskProxy.h

    r282712 r287684  
    3535class ResourceLoader;
    3636class ResourceResponse;
     37class SharedBuffer;
    3738}
    3839
    … …  
    5657    void didPerformRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, CompletionHandler<void(WebCore::ResourceRequest&&)>&&);
    5758    void didReceiveResponse(const WebCore::ResourceResponse&);
    58     void didReceiveData(size_t, const uint8_t* data);
     59    void didReceiveData(const WebCore::SharedBuffer&);
    5960    void didComplete(const WebCore::ResourceError&);
    6061

  • trunk/Source/WebKitLegacy/ChangeLog

    r287021 r287684  
     12022-01-06  Jean-Yves Avenard  <jya@apple.com>
     2
     3        Have CachedRawResourceClient and related networking actors use SharedBuffer.
     4        https://bugs.webkit.org/show_bug.cgi?id=232424
     5        rdar://84744687
     6
     7        Reviewed by Youenn Fablet.
     8
     9        * WebCoreSupport/PingHandle.h:
     10
    1112021-12-14  Jean-Yves Avenard  <jya@apple.com>
    212

  • trunk/Source/WebKitLegacy/WebCoreSupport/PingHandle.h

    r287021 r287684  
    3131#include <WebCore/ResourceRequest.h>
    3232#include <WebCore/ResourceResponse.h>
     33#include <WebCore/SharedBuffer.h>
    3334#include <WebCore/Timer.h>
    3435#include <wtf/CompletionHandler.h>
    … …  
    7475        pingLoadComplete({ }, response);
    7576    }
    76     void didReceiveBuffer(WebCore::ResourceHandle*, Ref<WebCore::FragmentedSharedBuffer>&&, int) final { pingLoadComplete(); }
     77    void didReceiveData(WebCore::ResourceHandle*, const WebCore::SharedBuffer&, int) final { pingLoadComplete(); }
    7778    void didFinishLoading(WebCore::ResourceHandle*, const WebCore::NetworkLoadMetrics&) final { pingLoadComplete(); }
    7879    void didFail(WebCore::ResourceHandle*, const WebCore::ResourceError& error) final { pingLoadComplete(error); }

  • trunk/Source/WebKitLegacy/mac/ChangeLog

    r287653 r287684  
     12022-01-06  Jean-Yves Avenard  <jya@apple.com>
     2
     3        Have CachedRawResourceClient and related networking actors use SharedBuffer.
     4        https://bugs.webkit.org/show_bug.cgi?id=232424
     5        rdar://84744687
     6
     7        Reviewed by Youenn Fablet.
     8
     9        * WebCoreSupport/WebFrameLoaderClient.h:
     10        * WebCoreSupport/WebFrameLoaderClient.mm:
     11        (WebFrameLoaderClient::committedLoad):
     12        (WebFrameLoaderClient::createPreviewLoaderClient):
     13        * WebView/WebFrame.mm:
     14        (-[WebFrame _commitData:]):
     15
    1162022-01-05  Tim Horton  <timothy_horton@apple.com>
    217

  • trunk/Source/WebKitLegacy/mac/WebCoreSupport/WebFrameLoaderClient.h

    r287021 r287684  
    4949class AuthenticationChallenge;
    5050class CachedFrame;
     51class FragmentedSharedBuffer;
    5152class HistoryItem;
    5253class ProtectionSpace;
    5354class ResourceLoader;
    5455class ResourceRequest;
     56class SharedBuffer;
    5557}
    5658
    … …  
    152154    void didReplaceMultipartContent() final;
    153155
    154     void committedLoad(WebCore::DocumentLoader*, const uint8_t*, int) final;
     156    void committedLoad(WebCore::DocumentLoader*, const WebCore::SharedBuffer&) final;
    155157    void finishedLoading(WebCore::DocumentLoader*) final;
    156158    void updateGlobalHistory() final;

  • trunk/Source/WebKitLegacy/mac/WebCoreSupport/WebFrameLoaderClient.mm

    r287224 r287684  
    993993}
    994994
    995 void WebFrameLoaderClient::committedLoad(WebCore::DocumentLoader* loader, const uint8_t* data, int length)
    996 {
    997     auto nsData = adoptNS([[NSData alloc] initWithBytesNoCopy:(void*)data length:length freeWhenDone:NO]);
    998     [dataSource(loader) _receivedData:nsData.get()];
     995void WebFrameLoaderClient::committedLoad(WebCore::DocumentLoader* loader, const WebCore::SharedBuffer& data)
     996{
     997    [dataSource(loader) _receivedData:data.createNSData().get()];
    999998}
    1000999
    … …  
    20132012        RetainPtr<NSFileHandle> m_fileHandle;
    20142013
    2015         void didReceiveBuffer(const WebCore::FragmentedSharedBuffer& buffer) override
     2014        void didReceiveData(const WebCore::SharedBuffer& buffer) override
    20162015        {
    20172016            auto dataArray = buffer.createNSDataArray();

  • trunk/Source/WebKitLegacy/mac/WebView/WebFrame.mm

    r286772 r287684  
    978978    document->setShouldCreateRenderers(_private->shouldCreateRenderers);
    979979
    980     _private->coreFrame->loader().documentLoader()->commitData((const uint8_t*)[data bytes], [data length]);
     980    _private->coreFrame->loader().documentLoader()->commitData(WebCore::SharedBuffer::create(data));
    981981}
    982982

  • trunk/Source/WebKitLegacy/win/ChangeLog

    r287321 r287684  
     12022-01-06  Jean-Yves Avenard  <jya@apple.com>
     2
     3        Have CachedRawResourceClient and related networking actors use SharedBuffer.
     4        https://bugs.webkit.org/show_bug.cgi?id=232424
     5        rdar://84744687
     6
     7        Reviewed by Youenn Fablet.
     8
     9        * WebCoreSupport/WebFrameLoaderClient.cpp:
     10        (WebFrameLoaderClient::committedLoad):
     11        * WebCoreSupport/WebFrameLoaderClient.h:
     12
    1132021-12-21  Wenson Hsieh  <wenson_hsieh@apple.com>
    214

  • trunk/Source/WebKitLegacy/win/WebCoreSupport/WebFrameLoaderClient.cpp

    r283179 r287684  
    642642}
    643643
    644 void WebFrameLoaderClient::committedLoad(DocumentLoader* loader, const uint8_t* data, int length)
    645 {
    646     loader->commitData(data, length);
     644void WebFrameLoaderClient::committedLoad(DocumentLoader* loader, const SharedBuffer& data)
     645{
     646    loader->commitData(data);
    647647
    648648    // If the document is a stand-alone media document, now is the right time to cancel the WebKit load.

  • trunk/Source/WebKitLegacy/win/WebCoreSupport/WebFrameLoaderClient.h

    r283179 r287684  
    113113    void startDownload(const WebCore::ResourceRequest&, const String& suggestedName = String()) override;
    114114
    115     void committedLoad(WebCore::DocumentLoader*, const uint8_t*, int) override;
     115    void committedLoad(WebCore::DocumentLoader*, const WebCore::SharedBuffer&) override;
    116116    void finishedLoading(WebCore::DocumentLoader*) override;
    117117
Note: See TracChangeset for help on using the changeset viewer.