ChangeLog

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

        Have CachedRawResourceClient and related networking actors use SharedBuffer.

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

        rdar://84744687

        Reviewed by NOBODY (OOPS!).

        We modify all didReceiveData method so that they no longer use uint8_t/int

        and instead use SharedBuffer. We also 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.

        This also allows to remove several memory allocations and copies.

        We can now also consider moving the underlying SharedMemory created in

        the content process all the way to the GPU process.

        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):

        (WebCore::SharedBuffer::SharedBuffer):

        (WebCore::SharedBufferDataView::SharedBufferDataView):

        (WebCore::SharedBufferDataView::createSharedBuffer const):

        * platform/SharedBuffer.h:

        (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/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/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:

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

        ScalableImageDecoder should be using SharedBuffer instead of DataSegment

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

        rdar://problem/85854204

        Reviewed by NOBODY (OOPS!).

        DataSegment should be a SharedBuffer's implementation details and not

        be used outside SharedBuffer's code.

        Historically, using the inner DataSegment was required as it was thread

        safe while SharedBuffer wasn't: This is no longer the case.

        SharedBuffer and DataSegment are semantically very similar, so this is

        mostly a find/replace change.

        Flattening the FragmentedSharedBuffer is still required as most decoders

        require reading the raw bytes.

        No change in observable behaviour.

        * platform/graphics/ImageBackingStore.h:

        (WebCore::ImageBackingStore::setSize):

        (WebCore::ImageBackingStore::ImageBackingStore):

        * platform/image-decoders/ScalableImageDecoder.h:

        * platform/image-decoders/avif/AVIFImageReader.cpp:

        (WebCore::AVIFImageReader::parseHeader):

        (WebCore::AVIFImageReader::decodeFrame):

        * platform/image-decoders/avif/AVIFImageReader.h:

        * platform/image-decoders/bmp/BMPImageReader.h:

        (WebCore::BMPImageReader::readUint16):

        (WebCore::BMPImageReader::readUint32):

        (WebCore::BMPImageReader::setData):

        * platform/image-decoders/gif/GIFImageReader.h:

        (GIFImageReader::setData):

        * platform/image-decoders/jpeg/JPEGImageDecoder.cpp:

        (WebCore::JPEGImageReader::decode):

        * platform/image-decoders/jpeg2000/JPEG2000ImageDecoder.cpp:

        (WebCore::JPEG2000ImageDecoder::decode):

        * platform/image-decoders/png/PNGImageDecoder.cpp:

        (WebCore::PNGImageReader::decode):

        * platform/image-decoders/webp/WEBPImageDecoder.cpp:

        (WebCore::WEBPImageDecoder::decode):

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

        make SharedBuffer::copy() return a contiguous SharedBuffer

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

        rdar://problem/86829527

        Reviewed by NOBODY (OOPS!).

        make SharedBuffer::copy() return a contiguous SharedBuffer

        API tests added.

        * platform/SharedBuffer.cpp:

        (WebCore::FragmentedSharedBuffer::copy const):

2021-12-26  Carlos Garcia Campos  <cgarcia@igalia.com>

        [GTK][a11y] Test accessibility/aria-inherits-presentational.html is failing with ATSPI

Source/WebKit/ChangeLog

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

        Have CachedRawResourceClient and related networking actors use SharedBuffer.

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

        rdar://84744687

        Reviewed by NOBODY (OOPS!).

        * 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.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):

        * Platform/IPC/SharedBufferCopy.h:

        (IPC::SharedBufferCopy::SharedBufferCopy):

        * 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:

        * WebProcess/cocoa/WebProcessCocoa.mm:

        (WebKit::WebProcess::initializeSandbox):

2021-12-26  Sam Weinig  <weinig@apple.com>

        Replace WebKit/CocoaColor.h with WebCore/ColorCocoa.h, not confusing at all

Source/WebKitLegacy/ChangeLog

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

        Have CachedRawResourceClient and related networking actors use SharedBuffer.

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

        rdar://84744687

        Reviewed by NOBODY (OOPS!).

        * WebCoreSupport/PingHandle.h:

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

        Rename SharedBuffer classes.

Source/WebKitLegacy/mac/ChangeLog

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

        Have CachedRawResourceClient and related networking actors use SharedBuffer.

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

        rdar://84744687

        Reviewed by NOBODY (OOPS!).

        * WebCoreSupport/WebFrameLoaderClient.h:

        * WebCoreSupport/WebFrameLoaderClient.mm:

        (WebFrameLoaderClient::committedLoad):

        (WebFrameLoaderClient::createPreviewLoaderClient):

        * WebView/WebFrame.mm:

        (-[WebFrame _commitData:]):

2021-12-22  Michael Saboff  <msaboff@apple.com>

        Fix WebKit Build issues when using system content path

Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp

@@void FetchBodyConsumer::resolve(Ref<DeferredPromise>&& promise, const String& co

    }

}

323 void FetchBodyConsumer::append(const ~~uint8_t* data, unsign~~ed ~~siz~~e)

323void FetchBodyConsumer::append(const SharedBuffer& buffer)

324324{

325325 if (m_source) {

326 m_source->enqueue(ArrayBuffer~~::tryCreate(data, size~~));

326 m_source->enqueue(buffer.tryCreateArrayBuffer());

327327 return;

328328 }

329 m_buffer.append(~~data, siz~~e);

329 m_buffer.append(buffer);

}

void FetchBodyConsumer::setData(Ref<FragmentedSharedBuffer>&& data)

Source/WebCore/Modules/fetch/FetchBodyConsumer.h

@@public:

    explicit FetchBodyConsumer(Type type) : m_type(type) { }

50 void append(const ~~uint8_t* data, unsign~~ed);

50 void append(const SharedBuffer&);

    bool hasData() const { return !!m_buffer; }

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

Source/WebCore/Modules/fetch/FetchBodyOwner.cpp

@@void FetchBodyOwner::blobLoadingFailed()

    finishBlobLoading();

}

301 void FetchBodyOwner::blobChunk(const uint8_t* ~~data, size_t size~~)

301void FetchBodyOwner::blobChunk(const SharedBuffer& buffer)

302302{

303 ASSERT(data);

304303 ASSERT(m_readableStreamSource);

305 if (!m_readableStreamSource->enqueue(ArrayBuffer~~::tryCreate(data, size~~)))

304 if (!m_readableStreamSource->enqueue(buffer.tryCreateArrayBuffer()))

        stop();

}

Source/WebCore/Modules/fetch/FetchBodyOwner.h

#include "FetchLoader.h"

#include "FetchLoaderClient.h"

#include "ResourceError.h"

40#include "SharedBuffer.h"

namespace WebCore {

@@protected:

private:

    // Blob loading routines

103 void blobChunk(const ~~uint8_t*, size_t~~);

104 void blobChunk(const SharedBuffer&);

    void blobLoadingSucceeded();

    void blobLoadingFailed();

    void finishBlobLoading();

@@private:

        // FetchLoaderClient API

        void didReceiveResponse(const ResourceResponse&) final;

116 void didReceiveData(const uint8_t* ~~data, size_t size~~) final { owner.blobChunk(~~data, siz~~e); }

117 void didReceiveData(const SharedBuffer& buffer) final { owner.blobChunk(buffer); }

        void didFail(const ResourceError&) final;

        void didSucceed() final { owner.blobLoadingSucceeded(); }

Source/WebCore/Modules/fetch/FetchLoader.cpp

@@void FetchLoader::didReceiveResponse(ResourceLoaderIdentifier, const ResourceRes

    m_client.didReceiveResponse(response);

}

151 void FetchLoader::didReceiveData(const uint8_t* ~~val~~ue~~, int size~~)

151void FetchLoader::didReceiveData(const SharedBuffer& buffer, bool)

152152{

153153 if (!m_consumer) {

154 m_client.didReceiveData(~~val~~u~~e, size~~);

154 m_client.didReceiveData(buffer);

155155 return;

156156 }

157 m_consumer->append(~~val~~u~~e, size~~);

157 m_consumer->append(buffer);

}

void FetchLoader::didFinishLoading(ResourceLoaderIdentifier)

Source/WebCore/Modules/fetch/FetchLoader.h

@@public:

private:

    // ThreadableLoaderClient API.

    void didReceiveResponse(ResourceLoaderIdentifier, const ResourceResponse&) final;

61 void didReceiveData(const uint8_t*~~, i~~nt) final;

61 void didReceiveData(const SharedBuffer&, bool useStrLen) final;

    void didFinishLoading(ResourceLoaderIdentifier) final;

    void didFail(const ResourceError&) final;

Source/WebCore/Modules/fetch/FetchLoaderClient.h

@@public:

    virtual void didReceiveResponse(const ResourceResponse&) { }

44 virtual void didReceiveData(const ~~uint8_t*, size_t~~) { }

44 virtual void didReceiveData(const SharedBuffer&) { }

    virtual void didSucceed() = 0;

    virtual void didFail(const ResourceError&) = 0;

Source/WebCore/Modules/fetch/FetchResponse.cpp

@@void FetchResponse::BodyLoader::didReceiveResponse(const ResourceResponse& resou

        responseCallback(m_response);

}

365 void FetchResponse::BodyLoader::didReceiveData(const uint8_t* ~~data, size_t size~~)

365void FetchResponse::BodyLoader::didReceiveData(const SharedBuffer& buffer)

{

    ASSERT(m_response.m_readableStreamSource || m_consumeDataCallback);

    if (m_consumeDataCallback) {

370 Span chunk { data, size };

370 Span chunk { buffer.data(), buffer.size() };

        m_consumeDataCallback(&chunk);

        return;

    }

@@void FetchResponse::BodyLoader::didReceiveData(const uint8_t* data, size_t size)

    auto& source = *m_response.m_readableStreamSource;

    if (!source.isPulling()) {

378 m_response.body().consumer().append(~~data, siz~~e);

378 m_response.body().consumer().append(buffer);

        return;

    }

@@void FetchResponse::BodyLoader::didReceiveData(const uint8_t* data, size_t size)

        stop();

        return;

    }

386 if (!source.enqueue(ArrayBuffer~~::tryCreate(data, size~~))) {

386 if (!source.enqueue(buffer.tryCreateArrayBuffer())) {

        stop();

        return;

    }

@@void FetchResponse::setBodyData(ResponseData&& data, uint64_t bodySizeWithPaddin

void FetchResponse::consumeChunk(Ref<JSC::Uint8Array>&& chunk)

{

470 body().consumer().append(chunk->data(), chunk->byteLength());

470 body().consumer().append(SharedBuffer::create(chunk->data(), chunk->byteLength()));

}

void FetchResponse::consumeBodyAsStream()

Source/WebCore/Modules/fetch/FetchResponse.h

@@private:

        void didSucceed() final;

        void didFail(const ResourceError&) final;

        void didReceiveResponse(const ResourceResponse&) final;

146 void didReceiveData(const ~~uint8_t*, size_t~~) final;

146 void didReceiveData(const SharedBuffer&) final;

        FetchResponse& m_response;

        NotificationCallback m_responseCallback;

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

@@RenderPtr<RenderElement> HTMLModelElement::createElementRenderer(RenderStyle&& s

// MARK: - CachedRawResourceClient

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);

}

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

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

@@private:

    RenderPtr<RenderElement> createElementRenderer(RenderStyle&&, const RenderTreePosition&) final;

    // CachedRawResourceClient overrides.

119 void dataReceived(CachedResource&, const ~~uint8_t* data, int dataLength~~) final;

119 void dataReceived(CachedResource&, const SharedBuffer&) final;

    void notifyFinished(CachedResource&, const NetworkLoadMetrics&) final;

    // ModelPlayerClient overrides.

Source/WebCore/Modules/streams/ReadableStreamSink.h

@@namespace WebCore {

class BufferSource;

class ReadableStream;

38 class FragmentedSharedBuffer;

class ReadableStreamSink : public RefCounted<ReadableStreamSink> {

public:

Source/WebCore/fileapi/FileReaderLoader.cpp

#include "ResourceRequest.h"

#include "ResourceResponse.h"

#include "ScriptExecutionContext.h"

44#include "SharedBuffer.h"

#include "TextResourceDecoder.h"

#include "ThreadableBlobRegistry.h"

#include "ThreadableLoader.h"

@@void FileReaderLoader::didReceiveResponse(ResourceLoaderIdentifier, const Resour

        m_client->didStartLoading();

}

166 void FileReaderLoader::didReceiveData(const uint8_t* ~~data, int dataLength~~)

167void FileReaderLoader::didReceiveData(const SharedBuffer& buffer, bool)

167168{

168 ASSERT(data);

169 ASSERT(dataLength > 0);

169 ASSERT(buffer.size());

    // Bail out if we already encountered an error.

    if (m_errorCode)

        return;

175 int length = ~~dataLength~~;

175 int length = buffer.size();

    unsigned remainingBufferSpace = m_totalBytes - m_bytesLoaded;

    if (length > static_cast<long long>(remainingBufferSpace)) {

        // If the buffer has hit maximum size, it can't be grown any more.

@@void FileReaderLoader::didReceiveData(const uint8_t* data, int dataLength)

            return;

        }

        if (m_variableLength) {

184 unsigned newLength = m_totalBytes + ~~static_cast<~~un~~signed>(dataLength~~);

184 unsigned newLength = m_totalBytes + buffer.size();

            if (newLength < m_totalBytes) {

                failed(NotReadableError);

                return;

@@void FileReaderLoader::didReceiveData(const uint8_t* data, int dataLength)

    if (length <= 0)

        return;

209 memcpy(static_cast<char*>(m_rawData->data()) + m_bytesLoaded, data, length);

209 memcpy(static_cast<char*>(m_rawData->data()) + m_bytesLoaded, buffer.data(), length);

    m_bytesLoaded += length;

    m_isRawDataConverted = false;

Source/WebCore/fileapi/FileReaderLoader.h

@@public:

    // ThreadableLoaderClient

    void didReceiveResponse(ResourceLoaderIdentifier, const ResourceResponse&) override;

73 void didReceiveData(const uint8_t*~~, int~~) override;

73 void didReceiveData(const SharedBuffer&, bool) override;

    void didFinishLoading(ResourceLoaderIdentifier) override;

    void didFail(const ResourceError&) override;

Source/WebCore/inspector/InspectorInstrumentation.cpp

@@void InspectorInstrumentation::didReceiveThreadableLoaderResponseImpl(Instrument

        networkAgent->didReceiveThreadableLoaderResponse(identifier, documentThreadableLoader);

}

619 void InspectorInstrumentation::didReceiveDataImpl(InstrumentingAgents& instrumentingAgents, ResourceLoaderIdentifier identifier, const uint8_t* ~~data, int dataLength~~, int encodedDataLength)

619void InspectorInstrumentation::didReceiveDataImpl(InstrumentingAgents& instrumentingAgents, ResourceLoaderIdentifier identifier, const SharedBuffer& buffer, int encodedDataLength)

620620{

621621 if (auto* networkAgent = instrumentingAgents.enabledNetworkAgent())

622 networkAgent->didReceiveData(identifier, ~~data, dataLength~~, encodedDataLength);

622 networkAgent->didReceiveData(identifier, buffer, encodedDataLength);

}

void InspectorInstrumentation::didFinishLoadingImpl(InstrumentingAgents& instrumentingAgents, ResourceLoaderIdentifier identifier, DocumentLoader* loader, const NetworkLoadMetrics& networkLoadMetrics, ResourceLoader* resourceLoader)

Source/WebCore/inspector/InspectorInstrumentation.h

@@public:

    static void didLoadResourceFromMemoryCache(Page&, DocumentLoader*, CachedResource*);

    static void didReceiveResourceResponse(Frame&, ResourceLoaderIdentifier, DocumentLoader*, const ResourceResponse&, ResourceLoader*);

    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);

    static void didFinishLoading(Frame*, DocumentLoader*, ResourceLoaderIdentifier, const NetworkLoadMetrics&, ResourceLoader*);

    static void didFailLoading(Frame*, DocumentLoader*, ResourceLoaderIdentifier, const ResourceError&);

    static void willSendRequest(WorkerOrWorkletGlobalScope&, ResourceLoaderIdentifier, ResourceRequest&);

    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&);

    static void didFinishLoading(WorkerOrWorkletGlobalScope&, ResourceLoaderIdentifier, const NetworkLoadMetrics&);

    static void didFailLoading(WorkerOrWorkletGlobalScope&, ResourceLoaderIdentifier, const ResourceError&);

@@private:

    static void didLoadResourceFromMemoryCacheImpl(InstrumentingAgents&, DocumentLoader*, CachedResource*);

    static void didReceiveResourceResponseImpl(InstrumentingAgents&, ResourceLoaderIdentifier, DocumentLoader*, const ResourceResponse&, ResourceLoader*);

    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);

    static void didFinishLoadingImpl(InstrumentingAgents&, ResourceLoaderIdentifier, DocumentLoader*, const NetworkLoadMetrics&, ResourceLoader*);

    static void didFailLoadingImpl(InstrumentingAgents&, ResourceLoaderIdentifier, DocumentLoader*, const ResourceError&);

    static void willLoadXHRSynchronouslyImpl(InstrumentingAgents&);

@@inline void InspectorInstrumentation::didReceiveThreadableLoaderResponse(Documen

        didReceiveThreadableLoaderResponseImpl(*agents, documentThreadableLoader, identifier);

}

1085 inline void InspectorInstrumentation::didReceiveData(Frame* frame, ResourceLoaderIdentifier identifier, const uint8_t* ~~data, int dataLength~~, int encodedDataLength)

1085inline void InspectorInstrumentation::didReceiveData(Frame* frame, ResourceLoaderIdentifier identifier, const SharedBuffer& buffer, int encodedDataLength)

{

    FAST_RETURN_IF_NO_FRONTENDS(void());

    if (auto* agents = instrumentingAgents(frame))

1089 didReceiveDataImpl(*agents, identifier, ~~data, dataLength~~, encodedDataLength);

1089 didReceiveDataImpl(*agents, identifier, buffer, encodedDataLength);

10901090}

10911091

1092 inline void InspectorInstrumentation::didReceiveData(WorkerOrWorkletGlobalScope& globalScope, ResourceLoaderIdentifier identifier, const uint8_t* ~~data, int dataLength~~)

1092inline void InspectorInstrumentation::didReceiveData(WorkerOrWorkletGlobalScope& globalScope, ResourceLoaderIdentifier identifier, const SharedBuffer& buffer)

10931093{

10941094 FAST_RETURN_IF_NO_FRONTENDS(void());

1095 didReceiveDataImpl(instrumentingAgents(globalScope), identifier, ~~data, dataLength, dataLength~~);

1095 didReceiveDataImpl(instrumentingAgents(globalScope), identifier, buffer, buffer.size());

}

inline void InspectorInstrumentation::didFinishLoading(Frame* frame, DocumentLoader* loader, ResourceLoaderIdentifier identifier, const NetworkLoadMetrics& networkLoadMetrics, ResourceLoader* resourceLoader)

Source/WebCore/inspector/NetworkResourcesData.cpp

@@size_t NetworkResourcesData::ResourceData::dataLength() const

    return m_dataBuffer.size();

}

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);

}

unsigned NetworkResourcesData::ResourceData::decodeDataToContent()

@@static bool shouldBufferResourceData(const NetworkResourcesData::ResourceData& r

    return false;

}

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)

{

    ResourceData* resourceData = resourceDataForRequestId(requestId);

    if (!resourceData)

@@NetworkResourcesData::ResourceData const* NetworkResourcesData::maybeAddResource

    if (!shouldBufferResourceData(*resourceData))

        return resourceData;

233 if (resourceData->dataLength() + dataL~~ength~~ > m_maximumSingleResourceContentSize)

233 if (resourceData->dataLength() + data.size() > m_maximumSingleResourceContentSize)

        m_contentSize -= resourceData->evictContent();

    if (resourceData->isContentEvicted())

        return resourceData;

238 if (ensureFreeSpace(dataL~~ength~~) && !resourceData->isContentEvicted()) {

238 if (ensureFreeSpace(data.size()) && !resourceData->isContentEvicted()) {

239239 m_requestIdsDeque.append(requestId);

240 resourceData->appendData(data~~, dataLength~~);

241 m_contentSize += dataL~~ength~~;

240 resourceData->appendData(data);

241 m_contentSize += data.size();

    }

    return resourceData;

Source/WebCore/inspector/NetworkResourcesData.h

@@public:

    private:

        bool hasData() const;

        size_t dataLength() const;

111 void appendData(const ~~uint8_t* data, size_t dataLength~~);

111 void appendData(const SharedBuffer&);

        unsigned decodeDataToContent();

        String m_requestId;

@@public:

    void setResourceType(const String& requestId, InspectorPageAgent::ResourceType);

    InspectorPageAgent::ResourceType resourceType(const String& requestId);

    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&);

    void maybeDecodeDataToContent(const String& requestId);

    void addCachedResource(const String& requestId, CachedResource*);

    void addResourceSharedBuffer(const String& requestId, RefPtr<FragmentedSharedBuffer>&&, const String& textEncodingName);

Source/WebCore/inspector/agents/InspectorNetworkAgent.cpp

@@public:

        m_decoder = TextResourceDecoder::create("text/plain"_s, textEncoding, useDetector);

    }

127 void didReceiveData(const uint8_t* ~~data, int data~~Len~~gth~~) override

127 void didReceiveData(const SharedBuffer& buffer, bool useStrLen) override

128128 {

129 if (~~!dataLength~~)

129 if (buffer.isEmpty())

130130 return;

131131

        if (dataLength == -1)

            dataLength = strlen(reinterpret_cast<const char*>(data));

        m_responseText.append(m_decoder->decode(data, dataLength));

132 size_t dataLength = useStrLen ? strlen(reinterpret_cast<const char*>(buffer.data())) : buffer.size();

133 m_responseText.append(m_decoder->decode(buffer.data(), dataLength));

    }

    void didFinishLoading(ResourceLoaderIdentifier) override

@@void InspectorNetworkAgent::didReceiveResponse(ResourceLoaderIdentifier identifi

            if (previousResourceData->hasContent())

                m_resourcesData->setResourceContent(requestId, previousResourceData->content(), previousResourceData->base64Encoded());

            else if (previousResourceData->hasBufferedData()) {

                auto previousBuffer = previousResourceData->buffer();

                previousBuffer->forEachSegment([&](auto& segment) {

                    m_resourcesData->maybeAddResourceData(requestId, segment.data(), segment.size());

550 previousResourceData->buffer()->forEachSegmentAsSharedBuffer([&](auto&& buffer) {

551 m_resourcesData->maybeAddResourceData(requestId, buffer);

                });

            }

@@void InspectorNetworkAgent::didReceiveResponse(ResourceLoaderIdentifier identifi

    // If we revalidated the resource and got Not modified, send content length following didReceiveResponse

    // as there will be no calls to didReceiveData from the network stack.

    if (isNotModified && cachedResource && cachedResource->encodedSize())

577 didReceiveData(identifier, n~~ullp~~tr, cachedResource->encodedSize()~~, 0~~);

574 didReceiveData(identifier, SharedBuffer::create(), cachedResource->encodedSize());

578575}

579576

580 void InspectorNetworkAgent::didReceiveData(ResourceLoaderIdentifier identifier, const uint8_t* data~~, int dataLength~~, int encodedDataLength)

577void InspectorNetworkAgent::didReceiveData(ResourceLoaderIdentifier identifier, const SharedBuffer& data, int encodedDataLength)

{

    if (m_hiddenRequestIdentifiers.contains(identifier))

        return;

    String requestId = IdentifiersFactory::requestId(identifier.toUInt64());

583 int dataLength = data.size();

586584

587 if (data) {

588 NetworkResourcesData::ResourceData const* resourceData = m_resourcesData->maybeAddResourceData(requestId, data~~, dataLength~~);

585 if (data.data()) {

586 NetworkResourcesData::ResourceData const* resourceData = m_resourcesData->maybeAddResourceData(requestId, data);

        // For a synchronous XHR, if we didn't add data then we can apply it here as base64 encoded content.

        // Often the data is text and we would have a decoder, but for non-text we won't have a decoder.

        // Sync XHRs may not have a cached resource, while non-sync XHRs usually transfer data over on completion.

        if (m_loadingXHRSynchronously && resourceData && !resourceData->hasBufferedData() && !resourceData->cachedResource())

594 m_resourcesData->setResourceContent(requestId, base64EncodeToString(data, dataLength), true);

            m_resourcesData->setResourceContent(requestId, base64EncodeToString(data.data(), data.size()), true);

    } else {

        dataLength = encodedDataLength;

        encodedDataLength = 0;

    }

    m_frontendDispatcher->dataReceived(requestId, timestamp(), dataLength, encodedDataLength);

@@Protocol::ErrorStringOr<void> InspectorNetworkAgent::interceptRequestWithRespons

    if (loader->reachedTerminalState())

        return makeUnexpected("Unable to fulfill request, it has already been processed"_s);

1274 RefPtr<~~Fragmented~~SharedBuffer> data;

1275 RefPtr<SharedBuffer> data;

    if (base64Encoded) {

        auto buffer = base64Decode(content);

        if (!buffer)

@@Protocol::ErrorStringOr<void> InspectorNetworkAgent::interceptRequestWithRespons

    }

    response.setHTTPHeaderFields(WTFMove(explicitHeaders));

    response.setHTTPHeaderField(HTTPHeaderName::ContentType, response.mimeType());

1299 loader->didReceiveResponse(response, [loader, buffer = data.releaseNonNull()]() ~~mutable~~ {

1300 loader->didReceiveResponse(response, [loader, buffer = data.releaseNonNull()]() {

13001301 if (buffer->size())

1301 loader->didReceive~~Buffer(WTFMove~~(buffer), buffer->size(), DataPayloadWholeResource);

1302 loader->didReceiveData(buffer, buffer->size(), DataPayloadWholeResource);

        loader->didFinishLoading(NetworkLoadMetrics());

    });

Source/WebCore/inspector/agents/InspectorNetworkAgent.h

@@public:

    void willSendRequest(ResourceLoaderIdentifier, DocumentLoader*, ResourceRequest&, const ResourceResponse& redirectResponse, const CachedResource*);

    void willSendRequestOfType(ResourceLoaderIdentifier, DocumentLoader*, ResourceRequest&, InspectorInstrumentation::LoadType);

    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 encodedDataLength);

    void didFinishLoading(ResourceLoaderIdentifier, DocumentLoader*, const NetworkLoadMetrics&, ResourceLoader*);

    void didFailLoading(ResourceLoaderIdentifier, DocumentLoader*, const ResourceError&);

    void didLoadResourceFromMemoryCache(DocumentLoader*, CachedResource&);

Source/WebCore/loader/ContentFilter.cpp

@@bool ContentFilter::continueAfterResponseReceived(const ResourceResponse& respon

    return m_state != State::Blocked;

}

148 bool ContentFilter::continueAfterDataReceived(const uint8_t* data~~, int length~~)

148bool ContentFilter::continueAfterDataReceived(const SharedBuffer& data)

{

    Ref<ContentFilterClient> protectedClient { m_client };

    if (m_state == State::Filtering) {

        LOG(ContentFiltering, "ContentFilter received %d bytes of data from <%s>.\n", length, m_mainResource->url().string().ascii().data());

        forEachContentFilterUntilBlocked([data, length](PlatformContentFilter& contentFilter) {

            contentFilter.addData(data, length);

        LOG(ContentFiltering, "ContentFilter received %zu bytes of data from <%s>.\n", data.size(), m_mainResource->url().string().ascii().data());

        forEachContentFilterUntilBlocked([data = Ref { data }](PlatformContentFilter& contentFilter) {

            contentFilter.addData(data);

        });

        if (m_state == State::Allowed)

@@void ContentFilter::deliverResourceData(CachedResource& resource)

    ASSERT(m_state == State::Allowed);

    ASSERT(resource.dataBufferingPolicy() == DataBufferingPolicy::BufferData);

    if (auto* resourceBuffer = resource.resourceBuffer())

236 m_client.dataReceivedThroughContentFilter(resourceBuffer->makeContiguous()~~->data(), resourceBuffer->size()~~);

236 m_client.dataReceivedThroughContentFilter(resourceBuffer->makeContiguous());

}

static const URL& blockedPageURL()

Source/WebCore/loader/ContentFilter.h

@@public:

    bool continueAfterWillSendRequest(ResourceRequest&, const ResourceResponse&);

    bool continueAfterResponseReceived(const ResourceResponse&);

63 bool continueAfterDataReceived(const ~~uint8_t* data, int length~~);

63 bool continueAfterDataReceived(const SharedBuffer&);

    bool continueAfterNotifyFinished(CachedResource&);

    static bool continueAfterSubstituteDataRequest(const DocumentLoader& activeLoader, const SubstituteData&);

Source/WebCore/loader/ContentFilterClient.h

@@namespace WebCore {

class ContentFilterUnblockHandler;

class ResourceError;

36class SharedBuffer;

class SubstituteData;

class ContentFilterClient {

@@public:

    virtual void ref() const = 0;

    virtual void deref() const = 0;

44 virtual void dataReceivedThroughContentFilter(const ~~uint8_t*, int~~) = 0;

45 virtual void dataReceivedThroughContentFilter(const SharedBuffer&) = 0;

    virtual ResourceError contentFilterDidBlock(ContentFilterUnblockHandler, String&& unblockRequestDeniedScript) = 0;

    virtual void cancelMainResourceLoadForContentFilter(const ResourceError&) = 0;

    virtual void handleProvisionalLoadFailureFromContentFilter(const URL& blockedPageURL, SubstituteData&) = 0;

Source/WebCore/loader/DocumentLoader.cpp

@@void DocumentLoader::finishedLoading()

        // If this is an empty document, it will not have actually been created yet. Commit dummy data so that

        // DocumentWriter::begin() gets called and creates the Document.

        if (!m_gotFirstByte)

486 commitData(~~0, 0~~);

487

486 commitData(SharedBuffer::create());

487

        if (!frameLoader())

            return;

        frameLoader()->client().finishedLoading(this);

@@void DocumentLoader::continueAfterContentPolicy(PolicyAction policy)

    if (!isStopping() && m_substituteData.isValid() && isLoadingMainResource()) {

        auto content = m_substituteData.content();

        if (content && content->size()) {

1160 content->forEachSegment([&](auto& s~~egment~~) {

1161 dataReceived(s~~egment.data(), segment.size()~~);

1160 content->forEachSegmentAsSharedBuffer([&](auto&& buffer) {

1161 dataReceived(buffer);

            });

        }

        if (isLoadingMainResource())

@@void DocumentLoader::continueAfterContentPolicy(PolicyAction policy)

    }

}

1174 void DocumentLoader::commitLoad(const uint8_t* data~~, int length~~)

1174void DocumentLoader::commitLoad(const SharedBuffer& data)

{

    // Both unloading the old page and parsing the new page may execute JavaScript which destroys the datasource

    // by starting a new load, so retain temporarily.

@@void DocumentLoader::commitLoad(const uint8_t* data, int length)

    if (ArchiveFactory::isArchiveMIMEType(response().mimeType()))

        return;

#endif

1189 frameLoader->client().committedLoad(this, data~~, length~~);

1189 frameLoader->client().committedLoad(this, data);

    if (isMultipartReplacingLoad())

        frameLoader->client().didReplaceMultipartContent();

@@static inline bool shouldUseActiveServiceWorkerFromParent(const Document& docume

}

#endif

1218 void DocumentLoader::commitData(const ~~uint8_t* bytes, size_t length~~)

1218void DocumentLoader::commitData(const SharedBuffer& data)

{

    if (!m_gotFirstByte) {

        m_gotFirstByte = true;

@@void DocumentLoader::commitData(const uint8_t* bytes, size_t length)

#endif

    ASSERT(m_frame->document()->parsing());

1316 m_writer.addData(by~~tes, length~~);

1316 m_writer.addData(data);

13171317}

13181318

1319 void DocumentLoader::dataReceived(CachedResource& resource, const uint8_t* ~~data, int length~~)

1319void DocumentLoader::dataReceived(CachedResource& resource, const SharedBuffer& buffer)

13201320{

13211321 ASSERT_UNUSED(resource, &resource == m_mainResource);

1322 dataReceived(~~data, length~~);

1322 dataReceived(buffer);

13231323}

13241324

1325 void DocumentLoader::dataReceived(const uint8_t* ~~data, int length~~)

1325void DocumentLoader::dataReceived(const SharedBuffer& buffer)

13261326{

13271327#if ENABLE(CONTENT_FILTERING)

1328 if (m_contentFilter && !m_contentFilter->continueAfterDataReceived(~~data, length~~))

1328 if (m_contentFilter && !m_contentFilter->continueAfterDataReceived(buffer))

        return;

#endif

1332 ASSERT(data);

1333 ASSERT(l~~ength~~);

1332 ASSERT(buffer.data());

1333 ASSERT(buffer.size());

    ASSERT(!m_response.isNull());

    // There is a bug in CFNetwork where callbacks can be dispatched even when loads are deferred.

@@void DocumentLoader::dataReceived(const uint8_t* data, int length)

#endif

    if (m_identifierForLoadWithoutResourceLoader)

1343 frameLoader()->notifier().dispatchDidReceiveData(this, m_identifierForLoadWithoutResourceLoader, ~~data, length~~, -1);

1343 frameLoader()->notifier().dispatchDidReceiveData(this, m_identifierForLoadWithoutResourceLoader, buffer, -1);

13441344

1345 m_applicationCacheHost->mainResourceDataReceived(~~data, length~~, -1, false);

1345 m_applicationCacheHost->mainResourceDataReceived(buffer, -1, false);

13461346

13471347 if (!isMultipartReplacingLoad())

1348 commitLoad(~~data, length~~);

1348 commitLoad(buffer);

}

void DocumentLoader::setupForReplace()

@@bool DocumentLoader::maybeCreateArchive()

    m_writer.setMIMEType(mainResource.mimeType());

    ASSERT(m_frame->document());

1617 commitData(m_parsedArchiveData~~->data(), mainResource.data().size()~~);

1617 commitData(*m_parsedArchiveData);

    return true;

#endif

}

@@void DocumentLoader::maybeFinishLoadingMultipartContent()

    frameLoader()->setupForReplace();

    m_committed = false;

2260 RefPtr<FragmentedSharedBuffer> resourceData = mainResourceData();

2261 commitLoad(resourceData->makeContiguous()->data(), resourceData->size());

2260 commitLoad(mainResourceData()->makeContiguous());

}

void DocumentLoader::startIconLoading()

@@void DocumentLoader::enqueueSecurityPolicyViolationEvent(SecurityPolicyViolation

}

#if ENABLE(CONTENT_FILTERING)

2413 void DocumentLoader::dataReceivedThroughContentFilter(const uint8_t* ~~data, int siz~~e)

2412void DocumentLoader::dataReceivedThroughContentFilter(const SharedBuffer& buffer)

24142413{

2415 dataReceived(~~data, siz~~e);

2414 dataReceived(buffer);

}

void DocumentLoader::cancelMainResourceLoadForContentFilter(const ResourceError& error)

Source/WebCore/loader/DocumentLoader.h

@@class PreviewConverter;

class ResourceLoader;

class FragmentedSharedBuffer;

class SWClientConnection;

89class SharedBuffer;

class SubresourceLoader;

class SubstituteResource;

class UserContentURLPattern;

@@public:

    void resetTiming() { m_loadTiming = { }; }

    // 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&);

    ApplicationCacheHost& applicationCacheHost() const;

    ApplicationCacheHost* applicationCacheHostUnlessBeingDestroyed() const;

@@private:

    void commitIfReady();

    void setMainDocumentError(const ResourceError&);

480 void commitLoad(const ~~uint8_t*, int~~);

481 void commitLoad(const SharedBuffer&);

    void clearMainResourceLoader();

    void setupForReplace();

@@private:

    void mainReceivedError(const ResourceError&);

    WEBCORE_EXPORT void redirectReceived(CachedResource&, ResourceRequest&&, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&&) override;

    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;

    WEBCORE_EXPORT void notifyFinished(CachedResource&, const NetworkLoadMetrics&) override;

#if USE(QUICK_LOOK)

    WEBCORE_EXPORT void previewResponseReceived(CachedResource&, const ResourceResponse&) override;

@@private:

#if ENABLE(CONTENT_FILTERING)

    // ContentFilterClient

506 WEBCORE_EXPORT void dataReceivedThroughContentFilter(const ~~uint8_t*, int~~) final;

507 WEBCORE_EXPORT void dataReceivedThroughContentFilter(const SharedBuffer&) final;

    WEBCORE_EXPORT ResourceError contentFilterDidBlock(ContentFilterUnblockHandler, String&& unblockRequestDeniedScript) final;

    WEBCORE_EXPORT void cancelMainResourceLoadForContentFilter(const ResourceError&) final;

    WEBCORE_EXPORT void handleProvisionalLoadFailureFromContentFilter(const URL& blockedPageURL, SubstituteData&) final;

#endif

512 void dataReceived(const ~~uint8_t* data, int length~~);

513 void dataReceived(const SharedBuffer&);

    bool maybeLoadEmpty();

Source/WebCore/loader/DocumentThreadableLoader.cpp

@@void DocumentThreadableLoader::didReceiveResponse(ResourceLoaderIdentifier ident

    m_client->didReceiveResponse(identifier, response);

}

440 void DocumentThreadableLoader::dataReceived(CachedResource& resource, const uint8_t* ~~data, int dataLength~~)

440void DocumentThreadableLoader::dataReceived(CachedResource& resource, const SharedBuffer& buffer)

441441{

442442 ASSERT_UNUSED(resource, &resource == m_resource);

443 didReceiveData(m_resource->identifier(), ~~data, dataLength~~);

443 didReceiveData(m_resource->identifier(), buffer);

444444}

445445

446 void DocumentThreadableLoader::didReceiveData(ResourceLoaderIdentifier, const uint8_t* ~~data, int dataLength~~)

446void DocumentThreadableLoader::didReceiveData(ResourceLoaderIdentifier, const SharedBuffer& buffer)

{

    ASSERT(m_client);

    if (m_delayCallbacksForIntegrityCheck)

        return;

453 m_client->didReceiveData(~~data, dataLength~~);

453 m_client->didReceiveData(buffer, false);

}

void DocumentThreadableLoader::finishedTimingForWorkerLoad(CachedResource& resource, const ResourceTiming& resourceTiming)

@@void DocumentThreadableLoader::didFinishLoading(ResourceLoaderIdentifier identif

        if (options().filteringPolicy == ResponseFilteringPolicy::Disable) {

            m_client->didReceiveResponse(identifier, response);

            if (auto* buffer = m_resource->resourceBuffer()) {

                buffer->forEachSegment([&](auto& segment) {

                    m_client->didReceiveData(segment.data(), segment.size());

                });

            }

496 if (auto* buffer = m_resource->resourceBuffer())

497 m_client->didReceiveData(*buffer, false);

        } else {

            ASSERT(response.type() == ResourceResponse::Type::Default);

            m_client->didReceiveResponse(identifier, ResourceResponse::filter(response, m_options.credentials == FetchOptions::Credentials::Include ? ResourceResponse::PerformExposeAllHeadersCheck::No : ResourceResponse::PerformExposeAllHeadersCheck::Yes));

            if (auto* buffer = m_resource->resourceBuffer()) {

                buffer->forEachSegment([&](auto& segment) {

                    m_client->didReceiveData(segment.data(), segment.size());

                });

            }

502 if (auto* buffer = m_resource->resourceBuffer())

503 m_client->didReceiveData(*buffer, false);

        }

    }

@@void DocumentThreadableLoader::loadRequest(ResourceRequest&& request, SecurityCh

    }

    didReceiveResponse(identifier, response);

    if (data) {

        data->forEachSegment([&](auto& segment) {

            didReceiveData(identifier, segment.data(), segment.size());

        });

    }

664 if (data)

665 didReceiveData(identifier, *data);

    const auto* timing = response.deprecatedNetworkLoadMetricsOrNull();

    auto resourceTiming = ResourceTiming::fromSynchronousLoad(requestURL, m_options.initiator, loadTiming, timing ? *timing : NetworkLoadMetrics::emptyMetrics(), response, securityOrigin());

Source/WebCore/loader/DocumentThreadableLoader.h

@@namespace WebCore {

        // CachedRawResourceClient

        void dataSent(CachedResource&, unsigned long long bytesSent, unsigned long long totalBytesToBeSent) override;

        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;

        void redirectReceived(CachedResource&, ResourceRequest&&, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&&) override;

        void finishedTimingForWorkerLoad(CachedResource&, const ResourceTiming&) override;

        void finishedTimingForWorkerLoad(const ResourceTiming&);

        void notifyFinished(CachedResource&, const NetworkLoadMetrics&) override;

        void didReceiveResponse(ResourceLoaderIdentifier, const ResourceResponse&);

96 void didReceiveData(ResourceLoaderIdentifier, const ~~uint8_t* data, int dataLength~~);

96 void didReceiveData(ResourceLoaderIdentifier, const SharedBuffer&);

        void didFinishLoading(ResourceLoaderIdentifier);

        void didFail(ResourceLoaderIdentifier, const ResourceError&);

        void makeCrossOriginAccessRequest(ResourceRequest&&);

Source/WebCore/loader/DocumentWriter.cpp

@@void DocumentWriter::reportDataReceived()

    m_frame->document()->resolveStyle(Document::ResolveStyleType::Rebuild);

}

267 void DocumentWriter::addData(const ~~uint8_t* bytes, size_t length~~)

267void DocumentWriter::addData(const SharedBuffer& data)

{

    // FIXME: Change these to ASSERT once https://bugs.webkit.org/show_bug.cgi?id=80427 has been resolved.

    RELEASE_ASSERT(m_state != State::NotStarted);

@@void DocumentWriter::addData(const uint8_t* bytes, size_t length)

        return;

    }

    ASSERT(m_parser);

276 m_parser->appendBytes(*this, by~~tes, length~~);

276 m_parser->appendBytes(*this, data.data(), data.size());

}

void DocumentWriter::insertDataSynchronously(const String& markup)

Source/WebCore/loader/DocumentWriter.h

@@namespace WebCore {

class Document;

class DocumentParser;

class Frame;

39class SharedBuffer;

class TextResourceDecoder;

class DocumentWriter {

@@public:

    bool begin();

    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&);

    void insertDataSynchronously(const String&); // For an internal use only to prevent the parser from yielding.

    WEBCORE_EXPORT void end();

Source/WebCore/loader/EmptyClients.cpp

@@void EmptyFrameLoaderClient::didReplaceMultipartContent()

{

}

873 void EmptyFrameLoaderClient::committedLoad(DocumentLoader*, const ~~uint8_t*, int~~)

873void EmptyFrameLoaderClient::committedLoad(DocumentLoader*, const SharedBuffer&)

{

}

Source/WebCore/loader/EmptyFrameLoaderClient.h

@@private:

    void willReplaceMultipartContent() final;

    void didReplaceMultipartContent() final;

122 void committedLoad(DocumentLoader*, const ~~uint8_t*, int~~) final;

122 void committedLoad(DocumentLoader*, const SharedBuffer&) final;

    void finishedLoading(DocumentLoader*) final;

    ResourceError cancelledError(const ResourceRequest&) const final;

Source/WebCore/loader/FrameLoader.cpp

@@bool FrameLoader::willLoadMediaElementURL(URL& url, Node& initiatorNode)

    ResourceLoaderIdentifier identifier;

    ResourceError error;

    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, error);

    url = request.url();

@@void FrameLoader::commitProvisionalLoad()

            m_client->dispatchDidReceiveTitle(title);

        // 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()), mainResouceError);

        Vector<Ref<Frame>> targetFrames;

        targetFrames.append(m_frame);

@@void FrameLoader::commitProvisionalLoad()

            // FIXME: If we get a resource with more than 2B bytes, this code won't do the right thing.

            // However, with today's computers and networking speeds, this won't happen in practice.

            // 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()), error);

        }

        // FIXME: Why only this frame and not parent frames?

@@ResourceLoaderIdentifier FrameLoader::loadResourceSynchronously(const ResourceRe

                (isScriptLikeDestination(options.destination) ? ResourceLoadObserver::FetchDestinationIsScriptLike::Yes : ResourceLoadObserver::FetchDestinationIsScriptLike::No));

        }

    }

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, -1, error);

    return identifier;

}

@@void FrameLoader::loadedResourceFromMemoryCache(CachedResource& resource, Resour

    ResourceResponse response = resource.response();

    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(), error);

}

void FrameLoader::applyUserAgentIfNeeded(ResourceRequest& request)

Source/WebCore/loader/FrameLoaderClient.h

 * are met:

 *

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

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

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

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

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

#endif

#if PLATFORM(COCOA)

53 #ifdef __OBJC__

53#ifdef __OBJC__

#import <Foundation/Foundation.h>

typedef id RemoteAXObjectRef;

#else

@@class ResourceHandle;

class ResourceRequest;

class ResourceResponse;

class SecurityOrigin;

101 class ~~Fragmented~~SharedBuffer;

101class SharedBuffer;

class SubstituteData;

class Widget;

@@public:

    virtual void willReplaceMultipartContent() = 0;

    virtual void didReplaceMultipartContent() = 0;

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

    virtual void updateGlobalHistory() = 0;

    virtual void updateGlobalHistoryRedirectLinks() = 0;

@@public:

    virtual String userAgent(const URL&) const = 0;

    virtual String overrideContentSecurityPolicy() const { return String(); }

275

    virtual void savePlatformDataToCachedFrame(CachedFrame*) = 0;

    virtual void transitionToCommittedFromCachedFrame(CachedFrame*) = 0;

#if PLATFORM(IOS_FAMILY)

@@public:

#endif

    virtual AllowsContentJavaScript allowsContentJavaScriptFromMostRecentNavigation() const { return AllowsContentJavaScript::Yes; }

384

#if ENABLE(APP_BOUND_DOMAINS)

    virtual bool shouldEnableInAppBrowserPrivacyProtections() const { return false; }

    virtual void notifyPageOfAppBoundBehavior() { }

@@public:

#if ENABLE(PDFKIT_PLUGIN)

    virtual bool shouldUsePDFPlugin(const String&, StringView) const { return false; }

#endif

393

    virtual bool isParentProcessAFullWebBrowser() const { return false; }

};

Source/WebCore/loader/MediaResourceLoader.cpp

@@void MediaResource::dataSent(CachedResource& resource, unsigned long long bytesS

        m_client->dataSent(*this, bytesSent, totalBytesToBeSent);

}

234 void MediaResource::dataReceived(CachedResource& resource, const uint8_t* ~~data, int dataLength~~)

234void MediaResource::dataReceived(CachedResource& resource, const SharedBuffer& buffer)

{

    ASSERT_UNUSED(resource, &resource == m_resource);

    RefPtr<MediaResource> protectedThis(this);

    if (m_client)

240 m_client->dataReceived(*this, ~~data, dataLength~~);

240 m_client->dataReceived(*this, buffer);

}

void MediaResource::notifyFinished(CachedResource& resource, const NetworkLoadMetrics& metrics)

Source/WebCore/loader/MediaResourceLoader.h

@@public:

    void redirectReceived(CachedResource&, ResourceRequest&&, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&&) override;

    bool shouldCacheResponse(CachedResource&, const ResourceResponse&) override;

    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;

    void notifyFinished(CachedResource&, const NetworkLoadMetrics&) override;

private:

Source/WebCore/loader/NetscapePlugInStreamLoader.cpp

@@void NetscapePlugInStreamLoader::didReceiveResponse(const ResourceResponse& resp

    });

}

void NetscapePlugInStreamLoader::didReceiveData(const uint8_t* data, unsigned length, long long encodedDataLength, DataPayloadType dataPayloadType)

{

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

}

void NetscapePlugInStreamLoader::didReceiveBuffer(Ref<FragmentedSharedBuffer>&& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)

{

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

}

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

144void NetscapePlugInStreamLoader::didReceiveData(const SharedBuffer& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)

{

    Ref<NetscapePlugInStreamLoader> protectedThis(*this);

    if (m_client) {

        if (buffer) {

            buffer->forEachSegment([&](auto& segment) {

                m_client->didReceiveData(this, segment.data(), segment.size());

            });

        } else

            m_client->didReceiveData(this, data, length);

    }

148 if (m_client)

149 m_client->didReceiveData(this, buffer);

166150

167 ResourceLoader::didReceiveData~~OrBuffer(data, length, WTFMove~~(buffer), encodedDataLength, dataPayloadType);

151 ResourceLoader::didReceiveData(buffer, encodedDataLength, dataPayloadType);

}

void NetscapePlugInStreamLoader::didFinishLoading(const NetworkLoadMetrics& networkLoadMetrics)

Source/WebCore/loader/NetscapePlugInStreamLoader.h

namespace WebCore {

class NetscapePlugInStreamLoader;

39class SharedBuffer;

class NetscapePlugInStreamLoaderClient : public CanMakeWeakPtr<NetscapePlugInStreamLoaderClient> {

public:

    virtual void willSendRequest(NetscapePlugInStreamLoader*, ResourceRequest&&, const ResourceResponse& redirectResponse, CompletionHandler<void(ResourceRequest&&)>&&) = 0;

    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;

    virtual void didFail(NetscapePlugInStreamLoader*, const ResourceError&) = 0;

    virtual void didFinishLoading(NetscapePlugInStreamLoader*) { }

    virtual bool wantsAllStreams() const { return false; }

@@private:

    void willSendRequest(ResourceRequest&&, const ResourceResponse& redirectResponse, CompletionHandler<void(ResourceRequest&&)>&& callback) override;

    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;

    void didFinishLoading(const NetworkLoadMetrics&) override;

    void didFail(const ResourceError&) override;

@@private:

    void willCancel(const ResourceError&) override;

    void didCancel(const ResourceError&) override;

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

78

    void notifyDone();

    WeakPtr<NetscapePlugInStreamLoaderClient> m_client;

Source/WebCore/loader/ResourceLoadNotifier.cpp

#include "Page.h"

#include "ProgressTracker.h"

#include "ResourceLoader.h"

42#include "SharedBuffer.h"

#if USE(QUICK_LOOK)

#include "QuickLook.h"

@@void ResourceLoadNotifier::didReceiveResponse(ResourceLoader* loader, const Reso

    dispatchDidReceiveResponse(loader->documentLoader(), loader->identifier(), r, loader);

}

81 void ResourceLoadNotifier::didReceiveData(ResourceLoader* loader, const uint8_t* ~~data, int dataLength~~, int encodedDataLength)

82void ResourceLoadNotifier::didReceiveData(ResourceLoader* loader, const SharedBuffer& buffer, int encodedDataLength)

8283{

8384 if (Page* page = m_frame.page())

84 page->progress().incrementProgress(loader->identifier(), ~~dataLength~~);

85 page->progress().incrementProgress(loader->identifier(), buffer.size());

8586

86 dispatchDidReceiveData(loader->documentLoader(), loader->identifier(), ~~data, dataLength~~, encodedDataLength);

87 dispatchDidReceiveData(loader->documentLoader(), loader->identifier(), buffer, encodedDataLength);

}

void ResourceLoadNotifier::didFinishLoad(ResourceLoader* loader, const NetworkLoadMetrics& networkLoadMetrics)

@@void ResourceLoadNotifier::dispatchDidReceiveResponse(DocumentLoader* loader, Re

    InspectorInstrumentation::didReceiveResourceResponse(m_frame, identifier, loader, r, resourceLoader);

}

156 void ResourceLoadNotifier::dispatchDidReceiveData(DocumentLoader* loader, ResourceLoaderIdentifier identifier, const uint8_t* ~~data, int dataLength~~, int encodedDataLength)

157void ResourceLoadNotifier::dispatchDidReceiveData(DocumentLoader* loader, ResourceLoaderIdentifier identifier, const SharedBuffer& buffer, int encodedDataLength)

{

    // Notifying the FrameLoaderClient may cause the frame to be destroyed.

    Ref<Frame> protect(m_frame);

160 m_frame.loader().client().dispatchDidReceiveContentLength(loader, identifier, ~~dataLength~~);

161 m_frame.loader().client().dispatchDidReceiveContentLength(loader, identifier, buffer.size());

161162

162 InspectorInstrumentation::didReceiveData(&m_frame, identifier, ~~data, dataLength~~, encodedDataLength);

163 InspectorInstrumentation::didReceiveData(&m_frame, identifier, buffer, encodedDataLength);

}

void ResourceLoadNotifier::dispatchDidFinishLoading(DocumentLoader* loader, ResourceLoaderIdentifier identifier, const NetworkLoadMetrics& networkLoadMetrics, ResourceLoader* resourceLoader)

@@void ResourceLoadNotifier::dispatchDidFailLoading(DocumentLoader* loader, Resour

    InspectorInstrumentation::didFailLoading(&m_frame, loader, identifier, error);

}

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, RefPtr<const SharedBuffer> buffer, int encodedDataLength, const ResourceError& error)

{

    // If the request is null, willSendRequest cancelled the load. We should

    // only dispatch didFailLoading in this case.

@@void ResourceLoadNotifier::sendRemainingDelegateMessages(DocumentLoader* loader,

    if (!response.isNull())

        dispatchDidReceiveResponse(loader, identifier, response);

196 if (~~dataLength~~ ~~> 0~~)

197 dispatchDidReceiveData(loader, identifier, ~~data, dataLength~~, encodedDataLength);

197 if (buffer && buffer->size())

198 dispatchDidReceiveData(loader, identifier, *buffer, encodedDataLength);

    if (error.isNull()) {

        NetworkLoadMetrics emptyMetrics;

Source/WebCore/loader/ResourceLoadNotifier.h

@@class ResourceError;

class ResourceLoader;

class ResourceRequest;

class ResourceResponse;

47class SharedBuffer;

class ResourceLoadNotifier {

    WTF_MAKE_NONCOPYABLE(ResourceLoadNotifier);

@@public:

    void willSendRequest(ResourceLoader*, ResourceRequest&, const ResourceResponse& redirectResponse);

    void didReceiveResponse(ResourceLoader*, const ResourceResponse&);

58 void didReceiveData(ResourceLoader*, const ~~uint8_t*, int dataLength~~, int encodedDataLength);

59 void didReceiveData(ResourceLoader*, const SharedBuffer&, int encodedDataLength);

    void didFinishLoad(ResourceLoader*, const NetworkLoadMetrics&);

    void didFailToLoad(ResourceLoader*, const ResourceError&);

    void assignIdentifierToInitialRequest(ResourceLoaderIdentifier, DocumentLoader*, const ResourceRequest&);

    void dispatchWillSendRequest(DocumentLoader*, ResourceLoaderIdentifier, ResourceRequest&, const ResourceResponse& redirectResponse, const CachedResource*);

    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 encodedDataLength);

    void dispatchDidFinishLoading(DocumentLoader*, ResourceLoaderIdentifier, const NetworkLoadMetrics&, ResourceLoader*);

    void dispatchDidFailLoading(DocumentLoader*, ResourceLoaderIdentifier, const ResourceError&);

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&, RefPtr<const SharedBuffer>, int encodedDataLength, const ResourceError&);

    bool isInitialRequestIdentifier(ResourceLoaderIdentifier identifier)

    {

Source/WebCore/loader/ResourceLoader.cpp

@@void ResourceLoader::loadDataURL()

        auto dataSize = decodeResult->data.size();

        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);

            if (!this->reachedTerminalState()) {

                NetworkLoadMetrics emptyMetrics;

@@void ResourceLoader::willSwitchToSubstituteResource()

        m_handle->cancel();

}

331 void ResourceLoader::add~~DataOr~~Buffer(const ~~uint8_t* data, unsigned length,~~ FragmentedSharedBuffer* buffer, DataPayloadType dataPayloadType)

331void ResourceLoader::addBuffer(const FragmentedSharedBuffer& buffer, DataPayloadType dataPayloadType)

{

    if (m_options.dataBufferingPolicy == DataBufferingPolicy::DoNotBufferData)

        return;

@@void ResourceLoader::addDataOrBuffer(const uint8_t* data, unsigned length, Fragm

    if (dataPayloadType == DataPayloadWholeResource)

        m_resourceData.reset();

    if (buffer)

        m_resourceData.append(*buffer);

    else

        m_resourceData.append(data, length);

339 m_resourceData.append(buffer);

}

const FragmentedSharedBuffer* ResourceLoader::resourceData() const

@@void ResourceLoader::didReceiveResponse(const ResourceResponse& r, CompletionHan

        frameLoader()->notifier().didReceiveResponse(this, m_response);

}

542 void ResourceLoader::didReceiveData(const ~~uint8_t* data, unsign~~ed l~~ength~~, long long encodedDataLength, DataPayloadType dataPayloadType)

539void ResourceLoader::didReceiveData(const SharedBuffer& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)

{

    // The following assertions are not quite valid here, since a subclass

    // might override didReceiveData in a way that invalidates them. This

@@void ResourceLoader::didReceiveData(const uint8_t* data, unsigned length, long l

    // ASSERT(con == connection);

    // ASSERT(!m_reachedTerminalState);

550 didReceive~~DataOr~~Buffer(~~data, length, nullpt~~r, encodedDataLength, dataPayloadType);

547 didReceiveBuffer(buffer, encodedDataLength, dataPayloadType);

551548}

552549

553 void ResourceLoader::didReceiveBuffer(~~Ref<~~FragmentedSharedBuffer>&& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)

550void ResourceLoader::didReceiveBuffer(const FragmentedSharedBuffer& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)

554551{

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

}

void ResourceLoader::didReceiveDataOrBuffer(const uint8_t* data, unsigned length, RefPtr<FragmentedSharedBuffer>&& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)

{

    // This method should only get data+length *OR* a FragmentedSharedBuffer.

    ASSERT(!buffer || (!data && !length));

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

    // anything including possibly derefing this; one example of this is Radar 3266216.

    Ref<ResourceLoader> protectedThis(*this);

567 add~~DataOr~~Buffer(~~data, length,~~ buffer~~.get()~~, dataPayloadType);

556 addBuffer(buffer, dataPayloadType);

    // FIXME: If we get a resource with more than 2B bytes, this code won't do the right thing.

    // However, with today's computers and networking speeds, this won't happen in practice.

    // Could be an issue with a giant local file.

    if (m_options.sendLoadCallbacks == SendCallbackPolicy::SendCallbacks && m_frame)

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));

}

void ResourceLoader::didFinishLoading(const NetworkLoadMetrics& networkLoadMetrics)

@@void ResourceLoader::didReceiveResponseAsync(ResourceHandle*, ResourceResponse&&

    didReceiveResponse(response, WTFMove(completionHandler));

}

732 void ResourceLoader::didReceiveData(ResourceHandle*, const ~~uint8_t* data, unsign~~ed l~~ength~~, int encodedDataLength)

721void ResourceLoader::didReceiveData(ResourceHandle*, const SharedBuffer& buffer, int encodedDataLength)

733722{

734 didReceiveData(~~data, length~~, encodedDataLength, DataPayloadBytes);

723 didReceiveData(buffer, encodedDataLength, DataPayloadBytes);

735724}

736725

737 void ResourceLoader::didReceiveBuffer(ResourceHandle*, ~~Ref<~~FragmentedSharedBuffer>&& buffer, int encodedDataLength)

726void ResourceLoader::didReceiveBuffer(ResourceHandle*, const FragmentedSharedBuffer& buffer, int encodedDataLength)

738727{

739 didReceiveBuffer(~~WTFMove(~~buffer), encodedDataLength, DataPayloadBytes);

728 didReceiveBuffer(buffer, encodedDataLength, DataPayloadBytes);

}

void ResourceLoader::didFinishLoading(ResourceHandle*, const NetworkLoadMetrics& metrics)

Source/WebCore/loader/ResourceLoader.h

@@public:

    virtual void willSendRequest(ResourceRequest&&, const ResourceResponse& redirectResponse, CompletionHandler<void(ResourceRequest&&)>&& callback);

    virtual void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent);

    virtual void didReceiveResponse(const ResourceResponse&, CompletionHandler<void()>&& policyCompletionHandler);

110 virtual void didReceiveData(const ~~uint8_t*, unsign~~ed, 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);

    virtual void didFinishLoading(const NetworkLoadMetrics&);

    virtual void didFail(const ResourceError&);

@@protected:

    bool wasCancelled() const { return m_cancellationStatus >= Cancelled; }

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

171

    void setReferrerPolicy(ReferrerPolicy referrerPolicy) { m_options.referrerPolicy = referrerPolicy; }

    ReferrerPolicy referrerPolicy() const { return m_options.referrerPolicy; }

@@private:

    virtual void willCancel(const ResourceError&) = 0;

    virtual void didCancel(const ResourceError&) = 0;

195 void add~~DataOr~~Buffer(const ~~uint8_t*, unsigned,~~ FragmentedSharedBuffer*, DataPayloadType);

193 void addBuffer(const FragmentedSharedBuffer&, DataPayloadType);

    void loadDataURL();

    void finishNetworkLoad();

@@private:

    void didSendData(ResourceHandle*, unsigned long long bytesSent, unsigned long long totalBytesToBeSent) override;

    void didReceiveResponseAsync(ResourceHandle*, ResourceResponse&&, CompletionHandler<void()>&&) override;

    void willSendRequestAsync(ResourceHandle*, ResourceRequest&&, ResourceResponse&&, CompletionHandler<void(ResourceRequest&&)>&&) override;

205 void didReceiveData(ResourceHandle*, const ~~uint8_t*, unsign~~ed, 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;

    void didFinishLoading(ResourceHandle*, const NetworkLoadMetrics&) override;

    void didFail(ResourceHandle*, const ResourceError&) override;

    void wasBlocked(ResourceHandle*) override;

Source/WebCore/loader/SubresourceLoader.cpp

@@void SubresourceLoader::didReceiveResponsePolicy()

        completionHandler();

}

521 void SubresourceLoader::didReceive~~Data~~(const ui~~nt8_t* data, unsign~~ed l~~ength~~, long long encodedDataLength, DataPayloadType dataPayloadType)

521void SubresourceLoader::didReceiveBuffer(const FragmentedSharedBuffer& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)

{

#if USE(QUICK_LOOK)

    if (auto previewLoader = m_previewLoader.get()) {

525 if (previewLoader->didReceiveData(da~~ta, length~~))

525 if (previewLoader->didReceiveData(buffer.makeContiguous()))

            return;

    }

#endif

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

}

void SubresourceLoader::didReceiveBuffer(Ref<FragmentedSharedBuffer>&& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)

{

#if USE(QUICK_LOOK)

    if (auto previewLoader = m_previewLoader.get()) {

        if (previewLoader->didReceiveBuffer(buffer.get()))

            return;

    }

#endif

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

}

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

{

    ASSERT(m_resource);

    if (m_resource->response().httpStatusCode() >= 400 && !m_resource->shouldIgnoreHTTPStatusCodeErrors())

@@void SubresourceLoader::didReceiveDataOrBuffer(const uint8_t* data, int length,

    // anything including removing the last reference to this object; one example of this is 3266216.

    Ref<SubresourceLoader> protectedThis(*this);

558 ResourceLoader::didReceive~~DataOr~~Buffer(~~data, length,~~ buffer~~.copyRef()~~, encodedDataLength, dataPayloadType);

541 ResourceLoader::didReceiveBuffer(buffer, encodedDataLength, dataPayloadType);

    if (!m_loadingMultipartContent) {

        if (auto* resourceData = this->resourceData())

            m_resource->updateBuffer(*resourceData);

        else

564 m_resource->updateData(buffer ~~? buffer->~~makeContiguous()~~->data() : data, buffer ? buffer->size() : length~~);

547 m_resource->updateData(buffer.makeContiguous());

    }

}

Source/WebCore/loader/SubresourceLoader.h

@@private:

    void willSendRequestInternal(ResourceRequest&&, const ResourceResponse& redirectResponse, CompletionHandler<void(ResourceRequest&&)>&&) override;

    void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent) override;

    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;

    void didFinishLoading(const NetworkLoadMetrics&) override;

    void didFail(const ResourceError&) override;

    void willCancel(const ResourceError&) override;

@@private:

    Expected<void, String> checkResponseCrossOriginAccessControl(const ResourceResponse&);

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

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

94 void didReceiveDataOrBuffer(const FragmentedSharedBuffer&, long long encodedDataLength, DataPayloadType);

    void notifyDone(LoadCompletionType);

Source/WebCore/loader/SubstituteResource.h

@@public:

    const URL& url() const { return m_url; }

    const ResourceResponse& response() const { return m_response; }

    FragmentedSharedBuffer& data() const { return static_reference_cast<FragmentedSharedBuffer>(Ref { *m_data.get() }); }

41 void append(const uint8_t* ~~data, int length~~) { m_data.append(~~data, length~~); }

41 void append(const SharedBuffer& buffer) { m_data.append(buffer); }

    void clear() { m_data.empty(); }

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

Source/WebCore/loader/ThreadableLoaderClient.h

@@namespace WebCore {

class ResourceError;

class ResourceResponse;

class ResourceTiming;

40class SharedBuffer;

class ThreadableLoaderClient {

    WTF_MAKE_NONCOPYABLE(ThreadableLoaderClient); WTF_MAKE_FAST_ALLOCATED;

@@public:

    virtual void didSendData(unsigned long long /*bytesSent*/, unsigned long long /*totalBytesToBeSent*/) { }

    virtual void didReceiveResponse(ResourceLoaderIdentifier, const ResourceResponse&) { }

47 virtual void didReceiveData(const uint8_t*~~, int~~ /*dataLen~~gth~~*/) { }

48 virtual void didReceiveData(const SharedBuffer&, bool /* useStrLen */) { }

    virtual void didFinishLoading(ResourceLoaderIdentifier) { }

    virtual void didFail(const ResourceError&) { }

    virtual void didFinishTiming(const ResourceTiming&) { }

Source/WebCore/loader/ThreadableLoaderClientWrapper.h

@@public:

            m_client->didReceiveResponse(identifier, response);

    }

69 void didReceiveData(const uint8_t* ~~data, int data~~Len~~gth~~)

69 void didReceiveData(const SharedBuffer& buffer, bool useStrLen)

7070 {

7171 if (m_client)

72 m_client->didReceiveData(~~data, da~~taLen~~gth~~);

72 m_client->didReceiveData(buffer, useStrLen);

    }

    void didFinishLoading(ResourceLoaderIdentifier identifier)

Source/WebCore/loader/WorkerThreadableLoader.cpp

@@void WorkerThreadableLoader::MainThreadBridge::didReceiveResponse(ResourceLoader

    }, m_taskMode);

}

234 void WorkerThreadableLoader::MainThreadBridge::didReceiveData(const uint8_t* data, in~~t data~~Len~~gth~~)

234void WorkerThreadableLoader::MainThreadBridge::didReceiveData(const SharedBuffer& data, bool useStrLen)

235235{

236 Vector<uint8_t> buffer(data, dataLength);

237 m_loaderProxy.postTaskForModeToWorkerOrWorkletGlobalScope([protectedWorkerClientWrapper = Ref { *m_workerClientWrapper }, workerRequestIdentifier = m_workerRequestIdentifier, buffer = WTFMove(buffer)] (ScriptExecutionContext& context) mutable {

236 m_loaderProxy.postTaskForModeToWorkerOrWorkletGlobalScope([protectedWorkerClientWrapper = Ref { *m_workerClientWrapper }, workerRequestIdentifier = m_workerRequestIdentifier, buffer = Ref { data }, useStrLen] (ScriptExecutionContext& context) {

238237 ASSERT(context.isWorkerGlobalScope() || context.isWorkletGlobalScope());

239 protectedWorkerClientWrapper->didReceiveData(buffer~~.data(), buff~~e~~r.size()~~);

238 protectedWorkerClientWrapper->didReceiveData(buffer, useStrLen);

240239 if (is<WorkerGlobalScope>(context))

241 InspectorInstrumentation::didReceiveData(downcast<WorkerGlobalScope>(context), workerRequestIdentifier, buffer~~.data(), buffer.size()~~);

240 InspectorInstrumentation::didReceiveData(downcast<WorkerGlobalScope>(context), workerRequestIdentifier, buffer);

    }, m_taskMode);

}

Source/WebCore/loader/WorkerThreadableLoader.h

@@private:

        // All executed on the main thread.

        void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent) override;

        void didReceiveResponse(ResourceLoaderIdentifier, const ResourceResponse&) override;

108 void didReceiveData(const uint8_t*~~, int dataLength~~) override;

108 void didReceiveData(const SharedBuffer&, bool) override;

        void didFinishLoading(ResourceLoaderIdentifier) override;

        void didFail(const ResourceError&) override;

        void didFinishTiming(const ResourceTiming&) override;

Source/WebCore/loader/appcache/ApplicationCacheHost.cpp

@@bool ApplicationCacheHost::maybeLoadFallbackForMainError(const ResourceRequest&

    return false;

}

152 void ApplicationCacheHost::mainResourceDataReceived(const ~~uint8_t*, int~~, long long, bool)

152void ApplicationCacheHost::mainResourceDataReceived(const SharedBuffer&, long long, bool)

{

}

Source/WebCore/loader/appcache/ApplicationCacheHost.h

@@public:

    void maybeLoadMainResource(const ResourceRequest&, SubstituteData&);

    void maybeLoadMainResourceForRedirect(const ResourceRequest&, SubstituteData&);

    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);

    void finishedLoadingMainResource();

    void failedLoadingMainResource();

Source/WebCore/loader/appcache/ApplicationCacheResource.cpp

@@ApplicationCacheResource::ApplicationCacheResource(URL&& url, ResourceResponse&&

void ApplicationCacheResource::deliver(ResourceLoader& loader)

{

54 loader.deliverResponseAndData(response(), m_path.isEmpty() ? data().makeContiguous() : SharedBuffer::createWithContentsOfFile(m_path));

    if (m_path.isEmpty())

        loader.deliverResponseAndData(response(), RefPtr { &data() });

    else

        loader.deliverResponseAndData(response(), SharedBuffer::createWithContentsOfFile(m_path));

}

void ApplicationCacheResource::addType(unsigned type)

Source/WebCore/loader/appcache/ApplicationCacheResourceLoader.cpp

@@void ApplicationCacheResourceLoader::responseReceived(CachedResource& resource,

    m_applicationCacheResource = ApplicationCacheResource::create(m_resource->url(), response, m_type);

}

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);

}

void ApplicationCacheResourceLoader::redirectReceived(CachedResource&, ResourceRequest&& newRequest, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&& callback)

Source/WebCore/loader/appcache/ApplicationCacheResourceLoader.h

@@private:

    // CachedRawResourceClient

    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;

    void redirectReceived(CachedResource&, ResourceRequest&&, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&&) final;

    void notifyFinished(CachedResource&, const NetworkLoadMetrics&) final;

Source/WebCore/loader/cache/CachedImage.cpp

@@inline void CachedImage::clearImage()

    m_updateImageDataCount = 0;

}

471 void CachedImage::updateBufferInternal(const ~~Fragmented~~SharedBuffer& data)

471void CachedImage::updateBufferInternal(const SharedBuffer& data)

{

    m_data = data.makeContiguous();

    setEncodedSize(m_data->size());

@@EncodedDataStatus CachedImage::updateImageData(bool allDataReceived)

void CachedImage::updateBuffer(const FragmentedSharedBuffer& data)

{

    ASSERT(dataBufferingPolicy() == DataBufferingPolicy::BufferData);

561 updateBufferInternal(data);

561 updateBufferInternal(data.makeContiguous());

    CachedResource::updateBuffer(data);

}

565 void CachedImage::updateData(const ~~uint8_t* data, unsign~~ed l~~ength~~)

565void CachedImage::updateData(const SharedBuffer& buffer)

566566{

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

568 updateBufferInternal(~~SharedB~~uffer~~::create(data, length)~~);

569 CachedResource::updateData(~~data, length~~);

568 updateBufferInternal(buffer);

569 CachedResource::updateData(buffer);

}

void CachedImage::finishLoading(const FragmentedSharedBuffer* data, const NetworkLoadMetrics& metrics)

Source/WebCore/loader/cache/CachedImage.h

@@private:

    RefPtr<SharedBuffer> convertedDataIfNeeded(const FragmentedSharedBuffer* data) const;

    void didUpdateImageData();

    EncodedDataStatus updateImageData(bool allDataReceived);

131 void updateData(const ~~uint8_t* data, unsigned length~~) override;

131 void updateData(const SharedBuffer&) override;

    void error(CachedResource::Status) override;

    void responseReceived(const ResourceResponse&) override;

@@private:

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

    void scheduleRenderingUpdate(const Image&);

172 void updateBufferInternal(const ~~Fragmented~~SharedBuffer&);

172 void updateBufferInternal(const SharedBuffer&);

    void didReplaceSharedBufferContents() override;

Source/WebCore/loader/cache/CachedRawResource.cpp

@@CachedRawResource::CachedRawResource(CachedResourceRequest&& request, Type type,

    ASSERT(isMainOrMediaOrIconOrRawResource());

}

51 std::optional<SharedBufferDataView> CachedRawResource::calculateIncrementalDataChunk(const ~~Fragmented~~SharedBuffer* 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);

}

void CachedRawResource::updateBuffer(const FragmentedSharedBuffer& data)

@@void CachedRawResource::updateBuffer(const FragmentedSharedBuffer& data)

        previousDataSize += incrementalData.size();

        SetForScope<bool> notifyScope(m_inIncrementalDataNotify, true);

75 notifyClientsDataWasReceived(incrementalData.~~data(), in~~cre~~mentalD~~at~~a.siz~~e());

75 notifyClientsDataWasReceived(incrementalData.createSharedBuffer());

    }

    setEncodedSize(m_data->size());

@@void CachedRawResource::updateBuffer(const FragmentedSharedBuffer& data)

    }

}

92 void CachedRawResource::updateData(const ~~uint8_t* data, unsign~~ed l~~ength~~)

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);

}

void CachedRawResource::finishLoading(const FragmentedSharedBuffer* data, const NetworkLoadMetrics& metrics)

@@void CachedRawResource::finishLoading(const FragmentedSharedBuffer* data, const

        if (data) {

            if (data != m_data.get())

                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(), in~~cre~~mentalD~~at~~a->siz~~e());

115 notifyClientsDataWasReceived(incrementalData->createSharedBuffer());

            }

        } else

            m_data = nullptr;

@@void CachedRawResource::finishLoading(const FragmentedSharedBuffer* data, const

    }

}

133 void CachedRawResource::notifyClientsDataWasReceived(const ~~uint8_t* data, unsign~~ed l~~ength~~)

133void CachedRawResource::notifyClientsDataWasReceived(const SharedBuffer& buffer)

134134{

135 if (!l~~eng~~th)

135 if (buffer.isEmpty())

        return;

    CachedResourceHandle<CachedRawResource> protectedThis(this);

    CachedResourceClientWalker<CachedRawResourceClient> w(m_clients);

    while (CachedRawResourceClient* c = w.next())

141 c->dataReceived(*this, ~~data, length~~);

141 c->dataReceived(*this, buffer);

}

static void iterateRedirects(CachedResourceHandle<CachedRawResource>&& handle, CachedRawResourceClient& client, Vector<std::pair<ResourceRequest, ResourceResponse>>&& redirectsInReverseOrder, CompletionHandler<void(ResourceRequest&&)>&& completionHandler)

@@void CachedRawResource::didAddClient(CachedResourceClient& c)

            if (!hasClient(*client))

                return;

            if (m_data) {

173 m_data->forEachSegment([&](auto& s~~egment~~) {

173 m_data->forEachSegmentAsSharedBuffer([&](auto&& buffer) {

174174 if (hasClient(*client))

175 client->dataReceived(*this, s~~egment.data(), segment.size()~~);

175 client->dataReceived(*this, buffer);

                });

            }

            if (!hasClient(*client))

Source/WebCore/loader/cache/CachedRawResource.h

@@namespace WebCore {

class CachedResourceClient;

class ResourceTiming;

31class SharedBuffer;

class SharedBufferDataView;

class CachedRawResource final : public CachedResource {

@@public:

private:

    void didAddClient(CachedResourceClient&) final;

    void updateBuffer(const FragmentedSharedBuffer&) final;

55 void updateData(const ~~uint8_t* data, unsigned length~~) final;

56 void updateData(const SharedBuffer&) final;

    void finishLoading(const FragmentedSharedBuffer*, const NetworkLoadMetrics&) final;

    bool shouldIgnoreHTTPStatusCodeErrors() const override { return true; }

@@private:

    void switchClientsToRevalidatedResource() override;

    bool mayTryReplaceEncodedData() const override { return m_allowEncodedDataReplacement; }

69 std::optional<SharedBufferDataView> calculateIncrementalDataChunk(const ~~Fragmented~~SharedBuffer*) const;

70 void notifyClientsDataWasReceived(const ~~uint8_t* data, unsigned length~~);

70 std::optional<SharedBufferDataView> calculateIncrementalDataChunk(const SharedBuffer&) const;

71 void notifyClientsDataWasReceived(const SharedBuffer&);

    
#if USE(QUICK_LOOK)

    void previewResponseReceived(const ResourceResponse&) final;

Source/WebCore/loader/cache/CachedRawResourceClient.h

@@class CachedResource;

class ResourceRequest;

class ResourceResponse;

class ResourceTiming;

34class SharedBuffer;

class CachedRawResourceClient : public CachedResourceClient {

public:

@@public:

    }

    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&) { }

    virtual void redirectReceived(CachedResource&, ResourceRequest&& request, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&& completionHandler) { completionHandler(WTFMove(request)); }

    virtual void finishedTimingForWorkerLoad(CachedResource&, const ResourceTiming&) { }

Source/WebCore/loader/cache/CachedResource.cpp

@@void CachedResource::updateBuffer(const FragmentedSharedBuffer&)

    ASSERT(dataBufferingPolicy() == DataBufferingPolicy::BufferData);

}

344 void CachedResource::updateData(const ~~uint8_t*, unsign~~ed)

344void CachedResource::updateData(const SharedBuffer&)

{

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

}

Source/WebCore/loader/cache/CachedResource.h

@@public:

    virtual String encoding() const { return String(); }

    virtual const TextResourceDecoder* textResourceDecoder() const { return nullptr; }

    virtual void updateBuffer(const FragmentedSharedBuffer&);

116 virtual void updateData(const ~~uint8_t* data, unsigned length~~);

116 virtual void updateData(const SharedBuffer&);

    virtual void finishLoading(const FragmentedSharedBuffer*, const NetworkLoadMetrics&);

    virtual void error(CachedResource::Status);

Source/WebCore/loader/ios/LegacyPreviewLoader.h

@@public:

    ~LegacyPreviewLoader();

    bool didReceiveResponse(const ResourceResponse&);

50 bool didReceiveData(const uint8_t* data, unsigned length);

51 bool didReceiveBuffer(const FragmentedSharedBuffer&);

50 bool didReceiveData(const SharedBuffer&);

    bool didFinishLoading();

    void didFail();

Source/WebCore/loader/ios/LegacyPreviewLoader.mm

@@static Ref<LegacyPreviewLoaderClient> makeClient(const ResourceLoader& loader, c

    return emptyClient();

}

66 bool LegacyPreviewLoader::didReceive~~Buffer~~(const ~~Fragmented~~SharedBuffer& buffer)

66bool LegacyPreviewLoader::didReceiveData(const SharedBuffer& buffer)

{

    if (m_finishedLoadingDataIntoConverter)

        return false;

@@bool LegacyPreviewLoader::didReceiveBuffer(const FragmentedSharedBuffer& buffer)

    LOG(Network, "LegacyPreviewLoader appending buffer with size %ld.", buffer.size());

    m_originalData.append(buffer);

    m_converter->updateMainResource();

74 m_client->didReceive~~Buffer~~(buffer);

74 m_client->didReceiveData(buffer);

    return true;

}

@@void LegacyPreviewLoader::previewConverterDidReceiveData(PreviewConverter&, cons

    if (!m_hasProcessedResponse)

        return;

165 auto dataCopy = data.copy();

166 resourceLoader->didReceiveBuffer(WTFMove(dataCopy), dataCopy->size(), DataPayloadBytes);

165 resourceLoader->didReceiveBuffer(data, data.size(), DataPayloadBytes);

}

void LegacyPreviewLoader::previewConverterDidFinishConverting(PreviewConverter&)

@@LegacyPreviewLoader::LegacyPreviewLoader(ResourceLoader& loader, const ResourceR

    LOG(Network, "LegacyPreviewLoader created with preview file name \"%s\".", m_converter->previewFileName().utf8().data());

}

bool LegacyPreviewLoader::didReceiveData(const uint8_t* data, unsigned length)

{

    return didReceiveBuffer(SharedBuffer::create(data, length).get());

}

bool LegacyPreviewLoader::didReceiveResponse(const ResourceResponse&)

{

    return !m_shouldDecidePolicyBeforeLoading;

Source/WebCore/page/EventSource.cpp

#include "ResourceResponse.h"

#include "ScriptExecutionContext.h"

#include "SecurityOrigin.h"

45#include "SharedBuffer.h"

#include "TextResourceDecoder.h"

#include "ThreadableLoader.h"

#include <wtf/IsoMallocInlines.h>

@@void EventSource::dispatchErrorEvent()

    dispatchEvent(Event::create(eventNames().errorEvent, Event::CanBubble::No, Event::IsCancelable::No));

}

213 void EventSource::didReceiveData(const uint8_t* ~~data, int~~ ~~length~~)

214void EventSource::didReceiveData(const SharedBuffer& buffer, bool)

{

    ASSERT(m_state == OPEN);

    ASSERT(m_requestInFlight);

    RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(!m_isSuspendedForBackForwardCache);

219 append(m_receiveBuffer, m_decoder->decode(data~~, length~~));

220 append(m_receiveBuffer, m_decoder->decode(buffer.data(), buffer.size()));

    parseEventStream();

}

Source/WebCore/page/EventSource.h

@@private:

    // ThreadableLoaderClient

    void didReceiveResponse(ResourceLoaderIdentifier, const ResourceResponse&) final;

87 void didReceiveData(const uint8_t*~~, int~~) final;

87 void didReceiveData(const SharedBuffer&, bool) final;

    void didFinishLoading(ResourceLoaderIdentifier) final;

    void didFail(const ResourceError&) final;

Source/WebCore/platform/PlatformContentFilter.h

#ifndef PlatformContentFilter_h

#define PlatformContentFilter_h

29#include "SharedBuffer.h"

#include <wtf/Ref.h>

#include <wtf/text/WTFString.h>

namespace WebCore {

class ContentFilterUnblockHandler;

36class FragmentedSharedBuffer;

3537class ResourceRequest;

3638class ResourceResponse;

37 class ~~Fragmented~~SharedBuffer;

39class SharedBuffer;

class PlatformContentFilter {

    WTF_MAKE_FAST_ALLOCATED;

@@public:

    virtual ~PlatformContentFilter() = default;

    virtual void willSendRequest(ResourceRequest&, const ResourceResponse&) = 0;

    virtual void responseReceived(const ResourceResponse&) = 0;

57 virtual void addData(const ~~uint8_t* data, int length~~) = 0;

59 virtual void addData(const SharedBuffer&) = 0;

    virtual void finishedAddingData() = 0;

    virtual Ref<FragmentedSharedBuffer> replacementData() const = 0;

#if ENABLE(CONTENT_FILTERING)

Source/WebCore/platform/SharedBuffer.cpp

@@Vector<uint8_t> FragmentedSharedBuffer::takeData()

    Vector<uint8_t> combinedData;

    if (hasOneSegment() && std::holds_alternative<Vector<uint8_t>>(m_segments[0].segment->m_immutableData))

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>());

    else

        combinedData = combineSegmentsData(m_segments, m_size);

@@void FragmentedSharedBuffer::clear()

Ref<FragmentedSharedBuffer> FragmentedSharedBuffer::copy() const

{

234 if (m_contiguous)

235 return m_segments.size() ? SharedBuffer::create(m_segments[0].segment.copyRef()) : SharedBuffer::create();

    Ref<FragmentedSharedBuffer> clone = adoptRef(*new FragmentedSharedBuffer);

    clone->m_size = m_size;

    clone->m_segments.reserveInitialCapacity(m_segments.size());

@@void FragmentedSharedBuffer::forEachSegment(const Function<void(const Span<const

        apply(Span { segment.segment->data(), segment.segment->size() });

}

void FragmentedSharedBuffer::forEachSegmentAsSharedBuffer(const Function<void(Ref<SharedBuffer>&&)>& apply) const

{

    auto protectedThis = Ref { *this };

    for (auto& segment : m_segments)

        apply(SharedBuffer::create(segment.segment.copyRef()));

}

bool FragmentedSharedBuffer::startsWith(const Span<const uint8_t>& prefix) const

{

    if (prefix.empty())

@@SharedBuffer::SharedBuffer()

    m_contiguous = true;

}

416 SharedBuffer::SharedBuffer(Ref<DataSegment>&& segment)

425SharedBuffer::SharedBuffer(Ref<const DataSegment>&& segment)

{

    m_size = segment->size();

    m_segments.append({ 0, WTFMove(segment) });

@@void SharedBufferBuilder::ensureBuffer()

        m_buffer = FragmentedSharedBuffer::create();

}

604 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)

    : m_segment(WTFMove(segment))

    , m_positionWithinSegment(positionWithinSegment)

    , m_size(size ? *size : m_segment->size() - positionWithinSegment)

@@SharedBufferDataView::SharedBufferDataView(const SharedBufferDataView& other, si

Ref<SharedBuffer> SharedBufferDataView::createSharedBuffer() const

{

620 const Ref<DataSegment> segment = m_segment;

629 const Ref<const DataSegment> segment = m_segment;

    return SharedBuffer::create(DataSegment::Provider {

        [segment, data = data()]() { return data; },

        [size = size()]() { return size; }

Source/WebCore/platform/SharedBuffer.h

@@public:

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

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

181 WEBCORE_EXPORT void forEachSegmentAsSharedBuffer(const Function<void(Ref<SharedBuffer>&&)>&) const;

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

    struct DataSegmentVectorEntry {

        size_t beginPosition;

186 Ref<DataSegment> segment;

187 const Ref<const DataSegment> segment;

    };

    using DataSegmentVector = Vector<DataSegmentVectorEntry, 1>;

    DataSegmentVector::const_iterator begin() const { return m_segments.begin(); }

@@public:

        if constexpr (!sizeof...(Args))

            return adoptRef(*new SharedBuffer());

        else if constexpr (sizeof...(Args) == 1

262 && (std::is_same_v<Args, Ref<DataSegment>> &&...))

            && (std::is_same_v<Args, Ref<const DataSegment>> &&...))

            return adoptRef(*new SharedBuffer(std::forward<Args>(args)...));

        else if constexpr (sizeof...(Args) == 1

            && (std::is_same_v<std::remove_const_t<std::remove_reference_t<Args>>, DataSegment> &&...))

            return adoptRef(*new SharedBuffer(std::forward<Args>(args)...));

        else {

            auto buffer = FragmentedSharedBuffer::create(std::forward<Args>(args)...);

@@public:

private:

    WEBCORE_EXPORT SharedBuffer();

293 SharedBuffer(const DataSegment& segment)

294 : SharedBuffer(Ref<const DataSegment> { segment }) { }

289295 WEBCORE_EXPORT explicit SharedBuffer(FileSystem::MappedFileData&&);

290 WEBCORE_EXPORT explicit SharedBuffer(Ref<DataSegment>&&);

296 WEBCORE_EXPORT explicit SharedBuffer(Ref<const DataSegment>&&);

    WEBCORE_EXPORT explicit SharedBuffer(Ref<FragmentedSharedBuffer>&&);

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

@@inline Vector<uint8_t> FragmentedSharedBuffer::extractData()

class SharedBufferDataView {

public:

362 WEBCORE_EXPORT SharedBufferDataView(Ref<DataSegment>&&, size_t positionWithinSegment, std::optional<size_t> newSize = std::nullopt);

368 WEBCORE_EXPORT SharedBufferDataView(Ref<const DataSegment>&&, size_t positionWithinSegment, std::optional<size_t> newSize = std::nullopt);

    WEBCORE_EXPORT SharedBufferDataView(const SharedBufferDataView&, size_t newSize);

    size_t size() const { return m_size; }

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

@@public:

    WEBCORE_EXPORT RetainPtr<NSData> createNSData() const;

#endif

private:

373 const Ref<DataSegment> m_segment;

379 const Ref<const DataSegment> m_segment;

    const size_t m_positionWithinSegment;

    const size_t m_size;

};

Source/WebCore/platform/cocoa/NetworkExtensionContentFilter.h

@@public:

    void willSendRequest(ResourceRequest&, const ResourceResponse&) override;

    void responseReceived(const ResourceResponse&) override;

52 void addData(const ~~uint8_t* data, int length~~) override;

52 void addData(const SharedBuffer&) override;

    void finishedAddingData() override;

    Ref<FragmentedSharedBuffer> replacementData() const override;

    ContentFilterUnblockHandler unblockHandler() const override;

Source/WebCore/platform/cocoa/NetworkExtensionContentFilter.mm

@@void NetworkExtensionContentFilter::responseReceived(const ResourceResponse& res

    semaphore.wait();

}

148 void NetworkExtensionContentFilter::addData(const uint8_t* data~~, int length~~)

148void NetworkExtensionContentFilter::addData(const SharedBuffer& data)

149149{

150 Re~~tainP~~tr<NSData~~> copiedData { [NSData dataWithBytes:~~(void*~~)data length:length] }~~;

150 auto nsData = data.createNSData();

151151

152152 BinarySemaphore semaphore;

153 [m_neFilterSource receivedData:~~copied~~Data.get() decisionHandler:[this, &semaphore](NEFilterSourceStatus status, NSDictionary *decisionInfo) {

153 [m_neFilterSource receivedData:nsData.get() decisionHandler:[this, &semaphore](NEFilterSourceStatus status, NSDictionary *decisionInfo) {

        handleDecision(status, replacementDataFromDecisionInfo(decisionInfo));

        semaphore.signal();

    }];

Source/WebCore/platform/cocoa/ParentalControlsContentFilter.h

@@public:

    void willSendRequest(ResourceRequest&, const ResourceResponse&) override { }

    void responseReceived(const ResourceResponse&) override;

46 void addData(const ~~uint8_t* data, int length~~) override;

46 void addData(const SharedBuffer&) override;

    void finishedAddingData() override;

    Ref<FragmentedSharedBuffer> replacementData() const override;

#if ENABLE(CONTENT_FILTERING)

Source/WebCore/platform/cocoa/ParentalControlsContentFilter.mm

@@void ParentalControlsContentFilter::responseReceived(const ResourceResponse& res

    updateFilterState();

}

97 void ParentalControlsContentFilter::addData(const uint8_t* data~~, int length~~)

97void ParentalControlsContentFilter::addData(const SharedBuffer& data)

9898{

9999 ASSERT(![m_replacementData length]);

100 m_replacementData = [m_webFilterEvaluator addData:[NSData da~~taWithBytesNoCopy:~~(void*~~)data length:length freeWhenDone:NO]~~];

100 m_replacementData = [m_webFilterEvaluator addData:data.createNSData().get()];

    updateFilterState();

    ASSERT(needsMoreData() || [m_replacementData length]);

}

Source/WebCore/platform/graphics/ImageBackingStore.h

@@private:

        return PackedColor::ARGB { result }.value;

    }

236 // m_pixels type should be identical to the one set in ImageBackingStoreCairo.cpp

    RefPtr<FragmentedSharedBuffer::DataSegment> m_pixels;

    uint32_t* m_pixelsPtr { nullptr };

    IntSize m_size;

Source/WebCore/platform/graphics/PlatformMediaResourceLoader.h

@@public:

    virtual void redirectReceived(PlatformMediaResource&, ResourceRequest&& request, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&& completionHandler) { completionHandler(WTFMove(request)); }

    virtual bool shouldCacheResponse(PlatformMediaResource&, const ResourceResponse&) { return true; }

    virtual void dataSent(PlatformMediaResource&, unsigned long long, unsigned long long) { }

    virtual void dataReceived(PlatformMediaResource&, Ref<FragmentedSharedBuffer>&&) { RELEASE_ASSERT_NOT_REACHED(); }

    // This method should be removed once CachedRawResourceClient uses FragmentedSharedBuffer.

    virtual void dataReceived(PlatformMediaResource& platform, const uint8_t* data, int length) { dataReceived(platform, SharedBuffer::create(data, length)); }

54 virtual void dataReceived(PlatformMediaResource&, const SharedBuffer&) { RELEASE_ASSERT_NOT_REACHED(); }

    virtual void accessControlCheckFailed(PlatformMediaResource&, const ResourceError&) { }

    virtual void loadFailed(PlatformMediaResource&, const ResourceError&) { }

    virtual void loadFinished(PlatformMediaResource&, const NetworkLoadMetrics&) { }

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

@@void WebCoreAVCFResourceLoader::responseReceived(CachedResource& resource, const

    notImplemented();

}

141 void WebCoreAVCFResourceLoader::dataReceived(CachedResource& resource, const ~~uint8_t*, int~~)

141void WebCoreAVCFResourceLoader::dataReceived(CachedResource& resource, const SharedBuffer&)

{

    fulfillRequestWithResource(resource);

}

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

@@public:

private:

    // CachedRawResourceClient

    void responseReceived(CachedResource&, const ResourceResponse&, CompletionHandler<void()>&&) override;

60 void dataReceived(CachedResource&, const ~~uint8_t*, int~~) override;

60 void dataReceived(CachedResource&, const SharedBuffer&) override;

    void notifyFinished(CachedResource&, const NetworkLoadMetrics&) override;

    void fulfillRequestWithResource(CachedResource&);

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

@@private:

    // CachedRawResourceClient

    void responseReceived(CachedResource&, const ResourceResponse&, CompletionHandler<void()>&&) final;

64 void dataReceived(CachedResource&, const ~~uint8_t*, int~~) final;

64 void dataReceived(CachedResource&, const SharedBuffer&) final;

    void notifyFinished(CachedResource&, const NetworkLoadMetrics&) final;

    void fulfillRequestWithResource(CachedResource&);

@@void CachedResourceMediaLoader::notifyFinished(CachedResource& resource, const N

    m_parent.loadFinished();

}

133 void CachedResourceMediaLoader::dataReceived(CachedResource& resource, const ~~uint8_t*, int~~)

133void CachedResourceMediaLoader::dataReceived(CachedResource& resource, const SharedBuffer&)

{

    ASSERT(&resource == m_resource);

    if (auto* data = resource.resourceBuffer())

@@private:

    void redirectReceived(PlatformMediaResource&, ResourceRequest&& request, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&& completionHandler) final { completionHandler(WTFMove(request)); }

    bool shouldCacheResponse(PlatformMediaResource&, const ResourceResponse&) final { return false; }

    void dataSent(PlatformMediaResource&, unsigned long long, unsigned long long) final { }

159 void dataReceived(PlatformMediaResource&, ~~Ref<Fragme~~n~~ted~~SharedBuffer>&&) final;

159 void dataReceived(PlatformMediaResource&, const SharedBuffer&) final;

    void accessControlCheckFailed(PlatformMediaResource&, const ResourceError& error) final { loadFailed(error); }

    void loadFailed(PlatformMediaResource&, const ResourceError& error) final { loadFailed(error); }

    void loadFinished(PlatformMediaResource&, const NetworkLoadMetrics&) final { loadFinished(); }

@@void PlatformResourceMediaLoader::loadFinished()

    m_parent.loadFinished();

}

214 void PlatformResourceMediaLoader::dataReceived(PlatformMediaResource&, ~~Ref<Fragme~~n~~ted~~SharedBuffer>&& buffer)

214void PlatformResourceMediaLoader::dataReceived(PlatformMediaResource&, const SharedBuffer& buffer)

215215{

216 m_buffer.append(~~WTFMove(~~buffer));

216 m_buffer.append(buffer);

    m_parent.newDataStoredInSharedBuffer(*m_buffer.get());

}

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

@@private:

    // PlatformMediaResourceClient virtual methods.

    void responseReceived(PlatformMediaResource&, const ResourceResponse&, CompletionHandler<void(ShouldContinuePolicyCheck)>&&) override;

74 void dataReceived(PlatformMediaResource&, ~~Ref<Fragme~~n~~ted~~SharedBuffer>&&) override;

74 void dataReceived(PlatformMediaResource&, const SharedBuffer&) override;

    void accessControlCheckFailed(PlatformMediaResource&, const ResourceError&) override;

    void loadFailed(PlatformMediaResource&, const ResourceError&) override;

    void loadFinished(PlatformMediaResource&, const NetworkLoadMetrics&) override;

@@void CachedResourceStreamingClient::responseReceived(PlatformMediaResource&, con

    completionHandler(ShouldContinuePolicyCheck::Yes);

}

1096 void CachedResourceStreamingClient::dataReceived(PlatformMediaResource&, ~~Ref<Fragme~~n~~ted~~SharedBuffer>&~~& buffer~~)

1096void CachedResourceStreamingClient::dataReceived(PlatformMediaResource&, const SharedBuffer& data)

{

    ASSERT(isMainThread());

    WebKitWebSrc* src = WEBKIT_WEB_SRC(m_src.get());

@@void CachedResourceStreamingClient::dataReceived(PlatformMediaResource&, Ref<Fra

    // that first package delivery would include the time of sending out the request and getting the data back. Since we can't distinguish the

    // sending time from the receiving time, it is better to ignore it.

    if (!std::isnan(members->downloadStartTime)) {

1110 members->totalDownloadedBytes += ~~buffer->~~size();

1110 members->totalDownloadedBytes += data.size();

        double timeSinceStart = (WallTime::now() - members->downloadStartTime).seconds();

        GST_TRACE_OBJECT(src, "R%u: downloaded %" G_GUINT64_FORMAT " bytes in %f seconds =~ %1.0f bytes/second", m_requestNumber, members->totalDownloadedBytes, timeSinceStart

            , timeSinceStart ? members->totalDownloadedBytes / timeSinceStart : 0);

@@void CachedResourceStreamingClient::dataReceived(PlatformMediaResource&, Ref<Fra

        members->downloadStartTime = WallTime::now();

    }

    buffer->forEachSegment([&](auto& segment) {

        int length = segment.size();

        GST_LOG_OBJECT(src, "R%u: Have %d bytes of data", m_requestNumber, length);

1118 int length = data.size();

1119 GST_LOG_OBJECT(src, "R%u: Have %d bytes of data", m_requestNumber, length);

11211120

1122 members->readPosition += length;

1123 ASSERT(!members->haveSize || members->readPosition <= members->size);

1121 members->readPosition += length;

1122 ASSERT(!members->haveSize || members->readPosition <= members->size);

11241123

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)));

    gst_element_post_message(GST_ELEMENT_CAST(src), gst_message_new_element(GST_OBJECT_CAST(src),

        gst_structure_new("webkit-network-statistics", "read-position", G_TYPE_UINT64, members->readPosition, "size", G_TYPE_UINT64, members->size, nullptr)));

    checkUpdateBlocksize(length);

    GstBuffer* buffer = gstBufferNewWrappedFast(fastMemDup(data.data(), length), length);

    gst_adapter_push(members->adapter.get(), buffer);

11271130

        checkUpdateBlocksize(length);

        GstBuffer* buffer = gstBufferNewWrappedFast(fastMemDup(segment.data(), length), length);

        gst_adapter_push(members->adapter.get(), buffer);

    });

    stopLoaderIfNeeded(src, members);

    members->responseCondition.notifyOne();

}

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

@@public:

        if (m_encodedDataStatus == EncodedDataStatus::Error)

            return;

        auto contiguousData = data.makeContiguous();

        if (contiguousData->data())

            m_data = contiguousData->begin()->segment.copyRef();

79 m_data = data.makeContiguous();

80

        if (m_encodedDataStatus == EncodedDataStatus::TypeAvailable) {

            m_decodingSizeFromSetData = true;

            tryDecodeSize(allDataReceived);

@@public:

    std::optional<IntPoint> hotSpot() const override { return std::nullopt; }

protected:

197 RefPtr<~~Fragme~~n~~ted~~SharedBuffer~~::DataSegment~~> m_data;

196 RefPtr<const SharedBuffer> m_data;

    Vector<ScalableImageDecoderFrame, 1> m_frameBufferCache WTF_GUARDED_BY_LOCK(m_lock);

    mutable Lock m_lock;

    bool m_premultiplyAlpha;

Source/WebCore/platform/image-decoders/avif/AVIFImageReader.cpp

@@AVIFImageReader::AVIFImageReader(RefPtr<AVIFImageDecoder>&& decoder)

AVIFImageReader::~AVIFImageReader() = default;

44 bool AVIFImageReader::parseHeader(const ~~Fragmented~~SharedBuffer~~::DataSegment~~& data, bool allDataReceived)

44bool AVIFImageReader::parseHeader(const SharedBuffer& data, bool allDataReceived)

{

    if (avifDecoderSetIOMemory(m_avifDecoder.get(), data.data(), data.size()) != AVIF_RESULT_OK)

        return allDataReceived ? m_decoder->setFailed() : false;

@@bool AVIFImageReader::parseHeader(const FragmentedSharedBuffer::DataSegment& dat

    return true;

}

61 void AVIFImageReader::decodeFrame(size_t frameIndex, ScalableImageDecoderFrame& buffer, const ~~Fragmented~~SharedBuffer~~::DataSegment~~& data)

61void AVIFImageReader::decodeFrame(size_t frameIndex, ScalableImageDecoderFrame& buffer, const SharedBuffer& data)

{

    if (m_decoder->failed())

        return;

Source/WebCore/platform/image-decoders/avif/AVIFImageReader.h

@@public:

    AVIFImageReader(RefPtr<AVIFImageDecoder>&&);

    ~AVIFImageReader();

42 bool parseHeader(const ~~Fragmented~~SharedBuffer~~::DataSegment~~&, bool allDataReceived);

43 void decodeFrame(size_t index, ScalableImageDecoderFrame&, const ~~Fragmented~~SharedBuffer~~::DataSegment~~&);

42 bool parseHeader(const SharedBuffer&, bool allDataReceived);

43 void decodeFrame(size_t index, ScalableImageDecoderFrame&, const SharedBuffer&);

    size_t imageCount() const;

    double repetitionCount() const;

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

@@class BMPImageReader {

public:

    // Read a value from |data[offset]|, converting from little to native

    // endianness.

45 static inline uint16_t readUint16(const ~~Fragmented~~SharedBuffer~~::DataSegment~~& data, int offset)

45 static inline uint16_t readUint16(const SharedBuffer& data, int offset)

    {

        uint16_t result;

        memcpy(&result, &data.data()[offset], 2);

@@public:

        return result;

    }

55 static inline uint32_t readUint32(const ~~Fragmented~~SharedBuffer~~::DataSegment~~& data, int offset)

55 static inline uint32_t readUint32(const SharedBuffer& data, int offset)

    {

        uint32_t result;

        memcpy(&result, &data.data()[offset], 4);

@@public:

    BMPImageReader(ScalableImageDecoder* parent, size_t decodedAndHeaderOffset, size_t imgDataOffset, bool usesAndMask);

    void setBuffer(ScalableImageDecoderFrame* buffer) { m_buffer = buffer; }

72 void setData(~~Fragme~~n~~ted~~SharedBuffer~~::DataSegment~~& data) { m_data = &data; }

72 void setData(const SharedBuffer& data) { m_data = &data; }

    // Does the actual decoding. If |onlySize| is true, decoding only

    // progresses as far as necessary to get the image size. Returns

@@private:

    ScalableImageDecoderFrame* m_buffer;

    // The file to decode.

275 RefPtr<~~Fragme~~n~~ted~~SharedBuffer~~::DataSegment~~> m_data;

275 RefPtr<const SharedBuffer> m_data;

    // An index into |m_data| representing how much we've already decoded.

    size_t m_decodedOffset;

Source/WebCore/platform/image-decoders/gif/GIFImageReader.h

@@public:

    {

    }

240 void setData(WebCore::~~Fragmented~~SharedBuffer~~::DataSegment~~& data) { m_data = &data; }

240 void setData(const WebCore::SharedBuffer& data) { m_data = &data; }

    // FIXME: haltAtFrame should be size_t.

    bool decode(WebCore::GIFImageDecoder::GIFQuery, unsigned haltAtFrame);

@@private:

    Vector<std::unique_ptr<GIFFrameContext> > m_frames;

    size_t m_currentDecodingFrame;

319 RefPtr<WebCore::~~Fragmented~~SharedBuffer~~::DataSegment~~> m_data;

319 RefPtr<const WebCore::SharedBuffer> m_data;

320320 bool m_parseCompleted;

321321};

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

@@public:

        m_bytesToSkip = std::max(numBytes - bytesToSkip, static_cast<long>(0));

    }

320 bool decode(const ~~Fragmented~~SharedBuffer~~::DataSegment~~& data, bool onlySize)

320 bool decode(const SharedBuffer& data, bool onlySize)

    {

        m_decodingSizeOnly = onlySize;

Source/WebCore/platform/image-decoders/jpeg2000/JPEG2000ImageDecoder.cpp

@@void JPEG2000ImageDecoder::decode(bool onlySize, bool allDataReceived)

    }

    struct Reader {

383 ~~Fragme~~n~~ted~~SharedBuffer~~::DataSegment~~& data;

383 const SharedBuffer& data;

        size_t offset;

    } reader = { *m_data, 0 };

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

@@public:

        m_readOffset = 0;

    }

151 bool decode(const ~~Fragmented~~SharedBuffer~~::DataSegment~~& data, bool sizeOnly, unsigned haltAtFrame)

151 bool decode(const SharedBuffer& data, bool sizeOnly, unsigned haltAtFrame)

    {

        m_decodingSizeOnly = sizeOnly;

        PNGImageDecoder* decoder = static_cast<PNGImageDecoder*>(png_get_progressive_ptr(m_png));

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

@@void WEBPImageDecoder::decode(size_t frameIndex, bool allDataReceived)

    // This can be executed both in the main thread (when not using async decoding) or in the decoding thread.

    // When executed in the decoding thread, a call to setData() from the main thread may change the data

    // the WebPDemuxer is using, leaving it in an inconsistent state, so we need to protect the data.

135 RefPtr<~~Fragme~~n~~ted~~SharedBuffer~~::DataSegment~~> protectedData(m_data);

135 RefPtr<const SharedBuffer> protectedData(m_data);

    WebPData inputData = { protectedData->data(), protectedData->size() };

    WebPDemuxState demuxerState;

    WebPDemuxer* demuxer = WebPDemuxPartial(&inputData, &demuxerState);

Source/WebCore/platform/network/ResourceHandleClient.cpp

@@ResourceHandleClient::ResourceHandleClient() = default;

ResourceHandleClient::~ResourceHandleClient() = default;

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);

    buffer.forEachSegmentAsSharedBuffer([&](auto&& buffer) {

        didReceiveData(handle, buffer, encodedDataLength);

    });

}

}

Source/WebCore/platform/network/ResourceHandleClient.h

@@OBJC_CLASS NSCachedURLResponse;

namespace WebCore {

class AuthenticationChallenge;

class Credential;

47class FragmentedSharedBuffer;

class NetworkLoadMetrics;

class ProtectionSpace;

class ResourceHandle;

class ResourceError;

class ResourceRequest;

class ResourceResponse;

53 class ~~Fragmented~~SharedBuffer;

54class SharedBuffer;

enum CacheStoragePolicy {

    StorageAllowed,

@@public:

    virtual void didSendData(ResourceHandle*, unsigned long long /*bytesSent*/, unsigned long long /*totalBytesToBeSent*/) { }

    virtual void didReceiveData(ResourceHandle*, const uint8_t*, unsigned, int /*encodedDataLength*/) { }

    WEBCORE_EXPORT virtual void didReceiveBuffer(ResourceHandle*, Ref<FragmentedSharedBuffer>&&, int encodedDataLength);

    virtual void didReceiveData(ResourceHandle*, const SharedBuffer&, int /*encodedDataLength*/) { }

    WEBCORE_EXPORT virtual void didReceiveBuffer(ResourceHandle*, const FragmentedSharedBuffer&, int encodedDataLength);

    virtual void didFinishLoading(ResourceHandle*, const NetworkLoadMetrics&) { }

    virtual void didFail(ResourceHandle*, const ResourceError&) { }

    virtual void wasBlocked(ResourceHandle*) { }

Source/WebCore/platform/network/SynchronousLoaderClient.cpp

@@void SynchronousLoaderClient::didReceiveResponseAsync(ResourceHandle*, ResourceR

    completionHandler();

}

74 void SynchronousLoaderClient::didReceiveData(ResourceHandle*, const ~~uint8_t* data, unsign~~ed l~~ength~~, 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());

}

void SynchronousLoaderClient::didFinishLoading(ResourceHandle* handle, const NetworkLoadMetrics&)

Source/WebCore/platform/network/SynchronousLoaderClient.h

namespace WebCore {

37class SharedBuffer;

38

class SynchronousLoaderMessageQueue : public ThreadSafeRefCounted<SynchronousLoaderMessageQueue> {

public:

    static Ref<SynchronousLoaderMessageQueue> create() { return adoptRef(*new SynchronousLoaderMessageQueue); }

@@private:

    bool shouldUseCredentialStorage(ResourceHandle*) override;

    void didReceiveAuthenticationChallenge(ResourceHandle*, const AuthenticationChallenge&) override;

    void didReceiveResponseAsync(ResourceHandle*, ResourceResponse&&, CompletionHandler<void()>&&) override;

69 void didReceiveData(ResourceHandle*, const ~~uint8_t*, unsign~~ed, int /*encodedDataLength*/) override;

71 void didReceiveData(ResourceHandle*, const SharedBuffer&, int /*encodedDataLength*/) override;

    void didFinishLoading(ResourceHandle*, const NetworkLoadMetrics&) override;

    void didFail(ResourceHandle*, const ResourceError&) override;

#if USE(PROTECTION_SPACE_AUTH_CALLBACK)

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

@@void RangeResponseGenerator::giveResponseToTaskIfBytesInRangeReceived(WebCoreNSU

            size_t bytesFromThisViewToDeliver = std::min(bufferView.size(), range.end - byteIndex + 1);

            byteIndex += bytesFromThisViewToDeliver;

135 [task resource:nullptr receivedData:SharedBufferDataView(bufferView, bytesFromThisViewToDeliver).createSharedBuffer()];

135 [task resource:nullptr receivedData:SharedBufferDataView(bufferView, bytesFromThisViewToDeliver).createSharedBuffer()->createNSData()];

        }

        if (byteIndex >= range.end) {

            [task resourceFinished:nullptr metrics:NetworkLoadMetrics { }];

@@private:

        return false;

    }

241 void dataReceived(PlatformMediaResource&, ~~Ref<Fragme~~n~~ted~~SharedBuffer>&& buffer) final

241 void dataReceived(PlatformMediaResource&, const SharedBuffer& buffer) final

    {

        ASSERT(isMainThread());

        if (!m_generator)

@@private:

        auto* data = m_generator->m_map.get(m_urlString);

        if (!data)

            return;

249 data->buffer.append(~~WTFMove(~~buffer));

249 data->buffer.append(buffer);

        m_generator->giveResponseToTasksWithFinishedRanges(*data);

    }

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

@@WEBCORE_EXPORT @interface WebCoreNSURLSession : NSObject {

- (void)resource:(nullable WebCore::PlatformMediaResource*)resource sentBytes:(unsigned long long)bytesSent totalBytesToBeSent:(unsigned long long)totalBytesToBeSent;

- (void)resource:(nullable WebCore::PlatformMediaResource*)resource receivedResponse:(const WebCore::ResourceResponse&)response completionHandler:(CompletionHandler<void(WebCore::ShouldContinuePolicyCheck)>&&)completionHandler;

- (BOOL)resource:(nullable WebCore::PlatformMediaResource*)resource shouldCacheResponse:(const WebCore::ResourceResponse&)response;

161 - (void)resource:(nullable WebCore::PlatformMediaResource*)resource receivedData:(Ref~~<WebCore::FragmentedSharedBuffer~~>&&)data;

161- (void)resource:(nullable WebCore::PlatformMediaResource*)resource receivedData:(RetainPtr<NSData>&&)data;

- (void)resource:(nullable WebCore::PlatformMediaResource*)resource receivedRedirect:(const WebCore::ResourceResponse&)response request:(WebCore::ResourceRequest&&)request completionHandler:(CompletionHandler<void(WebCore::ResourceRequest&&)>&&)completionHandler;

- (void)resource:(nullable WebCore::PlatformMediaResource*)resource accessControlCheckFailedWithError:(const WebCore::ResourceError&)error;

- (void)resource:(nullable WebCore::PlatformMediaResource*)resource loadFailedWithError:(const WebCore::ResourceError&)error;

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

@@public:

    void redirectReceived(PlatformMediaResource&, ResourceRequest&&, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&&) override;

    bool shouldCacheResponse(PlatformMediaResource&, const ResourceResponse&) override;

    void dataSent(PlatformMediaResource&, unsigned long long, unsigned long long) override;

611 void dataReceived(PlatformMediaResource&, ~~Ref<Fragme~~n~~ted~~SharedBuffer>&&) override;

611 void dataReceived(PlatformMediaResource&, const SharedBuffer&) override;

    void accessControlCheckFailed(PlatformMediaResource&, const ResourceError&) override;

    void loadFailed(PlatformMediaResource&, const ResourceError&) override;

    void loadFinished(PlatformMediaResource&, const NetworkLoadMetrics&) override;

@@bool WebCoreNSURLSessionDataTaskClient::shouldCacheResponse(PlatformMediaResourc

    return [m_task resource:&resource shouldCacheResponse:response];

}

655 void WebCoreNSURLSessionDataTaskClient::dataReceived(PlatformMediaResource& resource, ~~Ref<Fragme~~n~~ted~~SharedBuffer>&& buffer)

655void WebCoreNSURLSessionDataTaskClient::dataReceived(PlatformMediaResource& resource, const SharedBuffer& buffer)

{

    Locker locker { m_taskLock };

    if (!m_task)

        return;

661 [m_task resource:&resource receivedData:~~WTFMove(~~buffer)];

661 [m_task resource:&resource receivedData:buffer.createNSData()];

}

void WebCoreNSURLSessionDataTaskClient::redirectReceived(PlatformMediaResource& resource, ResourceRequest&& request, const ResourceResponse& response, CompletionHandler<void(ResourceRequest&&)>&& completionHandler)

@@- (BOOL)resource:(PlatformMediaResource*)resource shouldCacheResponse:(const Res

    return response.httpHeaderField(HTTPHeaderName::ContentRange).isEmpty();

}

934 - (void)resource:(PlatformMediaResource*)resource receivedData:(Ref~~<WebCore::FragmentedSharedBuffer~~>&&)data

934- (void)resource:(PlatformMediaResource*)resource receivedData:(RetainPtr<NSData>&&)data

{

    ASSERT_UNUSED(resource, !resource || resource == _resource);

    [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:~~nsD~~ata.get()];

941 [dataDelegate URLSession:(NSURLSession *)strongSelf.get().session dataTask:(NSURLSessionDataTask *)strongSelf.get() didReceiveData:data.get()];

    }];

}

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

@@bool CurlCacheManager::getCachedResponse(const String& url, ResourceResponse& re

    return false;

}

246 void CurlCacheManager::didReceiveData(ResourceHandle& job, const uint8_t* data~~, size_t size~~)

246void CurlCacheManager::didReceiveData(ResourceHandle& job, const SharedBuffer& data)

{

    if (m_disabled)

        return;

@@void CurlCacheManager::didReceiveData(ResourceHandle& job, const uint8_t* data,

        if (it->value->getJob() != &job)

            return;

258 if (!it->value->saveCachedData(data, size))

258 if (!it->value->saveCachedData(data.data(), data.size()))

            invalidateCacheEntry(url);

        else {

262 m_currentStorageSize += size;

262 m_currentStorageSize += data.size();

            m_LRUEntryList.prependOrMoveToFirst(url);

            makeRoomForNewEntry();

        }

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

@@public:

    bool getCachedResponse(const String& url, ResourceResponse&);

    void didReceiveResponse(ResourceHandle&, ResourceResponse&);

52 void didReceiveData(ResourceHandle&, const ~~uint8_t*, size_t~~); // Save data

52 void didReceiveData(ResourceHandle&, const SharedBuffer&); // Save data

    void didFinishLoading(ResourceHandle&);

    void didFail(ResourceHandle&);

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

@@void CurlDownload::curlDidReceiveResponse(CurlRequest& request, CurlResponse&& r

}

106 void CurlDownload::curlDidReceive~~Buffer~~(CurlRequest&, ~~Ref<Fragme~~n~~ted~~SharedBuffer>&& buffer)

106void CurlDownload::curlDidReceiveData(CurlRequest&, const SharedBuffer& buffer)

{

    ASSERT(isMainThread());

@@void CurlDownload::curlDidReceiveBuffer(CurlRequest&, Ref<FragmentedSharedBuffer

        return;

    if (m_listener)

114 m_listener->didReceiveDataOfLength(buffer->size());

114 m_listener->didReceiveDataOfLength(buffer.size());

}

void CurlDownload::curlDidComplete(CurlRequest& request, NetworkLoadMetrics&&)

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

@@namespace WebCore {

class CurlRequest;

class ResourceHandle;

41class SharedBuffer;

class CurlDownloadListener {

public:

@@private:

    Ref<CurlRequest> createCurlRequest(ResourceRequest&);

    void curlDidSendData(CurlRequest&, unsigned long long, unsigned long long) override { }

    void curlDidReceiveResponse(CurlRequest&, CurlResponse&&) override;

75 void curlDidReceive~~Buffer~~(CurlRequest&, ~~Ref<Fragme~~n~~ted~~SharedBuffer>&&) override;

76 void curlDidReceiveData(CurlRequest&, const SharedBuffer&) override;

    void curlDidComplete(CurlRequest&, NetworkLoadMetrics&&) override;

    void curlDidFailWithError(CurlRequest&, ResourceError&&, CertificateInfo&&) override;

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

@@CurlMultipartHandle::CurlMultipartHandle(CurlMultipartHandleClient& client, cons

}

122 void CurlMultipartHandle::didReceiveData(const ~~Fragmented~~SharedBuffer& buffer)

122void CurlMultipartHandle::didReceiveData(const SharedBuffer& buffer)

{

    if (m_state == State::End)

        return; // The handler is closed down so ignore everything.

127 m_buffer.append(buffer.~~makeContiguous()->~~data(), buffer.size());

127 m_buffer.append(buffer.data(), buffer.size());

    while (processContent()) { }

}

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

@@namespace WebCore {

class CurlMultipartHandleClient;

class CurlResponse;

37 class ~~Fragmented~~SharedBuffer;

37class SharedBuffer;

class CurlMultipartHandle {

    WTF_MAKE_FAST_ALLOCATED;

@@public:

    CurlMultipartHandle(CurlMultipartHandleClient&, const String&);

    ~CurlMultipartHandle() { }

47 void didReceiveData(const ~~Fragmented~~SharedBuffer&);

47 void didReceiveData(const SharedBuffer&);

    void didComplete();

private:

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

@@class FragmentedSharedBuffer;

class CurlMultipartHandleClient {

public:

    virtual void didReceiveHeaderFromMultipart(const Vector<String>&) = 0;

36 virtual void didReceiveDataFromMultipart(~~Ref<Fragme~~n~~ted~~SharedBuffer>&&) = 0;

36 virtual void didReceiveDataFromMultipart(const SharedBuffer&) = 0;

protected:

    ~CurlMultipartHandleClient() { }

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

@@size_t CurlRequest::didReceiveHeader(String&& header)

// called with data after all headers have been processed via headerCallback

399 size_t CurlRequest::didReceiveData(~~Ref<Fragme~~n~~ted~~SharedBuffer>&& buffer)

399size_t CurlRequest::didReceiveData(const SharedBuffer& buffer)

{

    if (isCompletedOrCancelled())

        return 0;

@@size_t CurlRequest::didReceiveData(Ref<FragmentedSharedBuffer>&& buffer)

        return CURL_WRITEFUNC_PAUSE;

    }

414 auto receiveBytes = buffer->size();

414 auto receiveBytes = buffer.size();

    m_totalReceivedSize += receiveBytes;

    writeDataToDownloadFileIfEnabled(buffer);

@@size_t CurlRequest::didReceiveData(Ref<FragmentedSharedBuffer>&& buffer)

        if (m_multipartHandle)

            m_multipartHandle->didReceiveData(buffer);

        else {

423 callClient([buffer = ~~WTFMov~~e(buffer)](CurlRequest& request, CurlRequestClient& client) ~~mutable~~ {

424 client.curlDidReceive~~Buffer~~(request, ~~WTFMove(~~buffer));

423 callClient([buffer = Ref { buffer }](CurlRequest& request, CurlRequestClient& client) {

424 client.curlDidReceiveData(request, buffer);

@@void CurlRequest::didReceiveHeaderFromMultipart(const Vector<String>& headers)

    invokeDidReceiveResponse(response, Action::None);

}

447 void CurlRequest::didReceiveDataFromMultipart(~~Ref<Fragme~~n~~ted~~SharedBuffer>&& buffer)

447void CurlRequest::didReceiveDataFromMultipart(const SharedBuffer& buffer)

{

    if (isCompletedOrCancelled())

        return;

452 auto receiveBytes = buffer->size();

452 auto receiveBytes = buffer.size();

453453

454454 if (receiveBytes) {

455 callClient([buffer = ~~WTFMov~~e(buffer)](CurlRequest& request, CurlRequestClient& client) ~~mutable~~ {

456 client.curlDidReceive~~Buffer~~(request, ~~WTFMove(~~buffer));

455 callClient([buffer = Ref { buffer }](CurlRequest& request, CurlRequestClient& client) {

456 client.curlDidReceiveData(request, buffer);

        });

    }

}

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

@@private:

    CURL* setupTransfer() override;

    size_t willSendData(char*, size_t, size_t);

    size_t didReceiveHeader(String&&);

125 size_t didReceiveData(~~Ref<Fragme~~n~~ted~~SharedBuffer>&&);

125 size_t didReceiveData(const SharedBuffer&);

126126 void didReceiveHeaderFromMultipart(const Vector<String>&) override;

127 void didReceiveDataFromMultipart(~~Ref<Fragme~~n~~ted~~SharedBuffer>&&) override;

127 void didReceiveDataFromMultipart(const SharedBuffer&) override;

    void didCompleteTransfer(CURLcode) override;

    void didCancelTransfer() override;

    void finalizeTransfer();

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

@@class CurlRequest;

class CurlResponse;

class NetworkLoadMetrics;

class ResourceError;

37 class ~~Fragmented~~SharedBuffer;

37class SharedBuffer;

class CurlRequestClient {

public:

@@public:

    virtual void curlDidSendData(CurlRequest&, unsigned long long bytesSent, unsigned long long totalBytesToBeSent) = 0;

    virtual void curlDidReceiveResponse(CurlRequest&, CurlResponse&&) = 0;

46 virtual void curlDidReceive~~Buffer~~(CurlRequest&, ~~Ref<Fragme~~n~~ted~~SharedBuffer>&&) = 0;

46 virtual void curlDidReceiveData(CurlRequest&, const SharedBuffer&) = 0;

    virtual void curlDidComplete(CurlRequest&, NetworkLoadMetrics&&) = 0;

    virtual void curlDidFailWithError(CurlRequest&, ResourceError&&, CertificateInfo&&) = 0;

};

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

@@void CurlResourceHandleDelegate::curlDidReceiveResponse(CurlRequest& request, Cu

    });

}

145 void CurlResourceHandleDelegate::curlDidReceive~~Buffer~~(CurlRequest&, ~~Ref<Fragme~~n~~ted~~SharedBuffer>&& buffer)

145void CurlResourceHandleDelegate::curlDidReceiveData(CurlRequest&, const SharedBuffer& buffer)

{

    ASSERT(isMainThread());

    if (cancelledOrClientless())

        return;

    auto contiguousBuffer = buffer->makeContiguous();

    CurlCacheManager::singleton().didReceiveData(m_handle, contiguousBuffer->data(), buffer->size());

    client()->didReceiveBuffer(&m_handle, WTFMove(contiguousBuffer), buffer->size());

152 CurlCacheManager::singleton().didReceiveData(m_handle, buffer);

153 client()->didReceiveBuffer(&m_handle, buffer, buffer.size());

}

void CurlResourceHandleDelegate::curlDidComplete(CurlRequest&, NetworkLoadMetrics&& metrics)

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

@@namespace WebCore {

class ResourceHandle;

class ResourceHandleClient;

class ResourceHandleInternal;

41class SharedBuffer;

class CurlResourceHandleDelegate final : public CurlRequestClient {

    WTF_MAKE_NONCOPYABLE(CurlResourceHandleDelegate); WTF_MAKE_FAST_ALLOCATED;

@@public:

    void curlDidSendData(CurlRequest&, unsigned long long bytesSent, unsigned long long totalBytesToBeSent) final;

    void curlDidReceiveResponse(CurlRequest&, CurlResponse&&) final;

56 void curlDidReceive~~Buffer~~(CurlRequest&, ~~Ref<Fragme~~n~~ted~~SharedBuffer>&&) final;

57 void curlDidReceiveData(CurlRequest&, const SharedBuffer&) final;

    void curlDidComplete(CurlRequest&, NetworkLoadMetrics&&) final;

    void curlDidFailWithError(CurlRequest&, ResourceError&&, CertificateInfo&&) final;

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

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

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

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

12 *

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

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

#include "CurlStream.h"

#include "CurlStreamScheduler.h"

30#include "SharedBuffer.h"

#include "SocketStreamError.h"

#if USE(CURL)

@@void CurlStream::tryToReceive()

    if (!m_curlHandle)

        return;

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);

    if (errorCode != CURLE_OK) {

        if (errorCode != CURLE_AGAIN)

            notifyFailure(errorCode);

@@void CurlStream::tryToReceive()

    if (!bytesReceived)

        destroyHandle();

146 m_scheduler.callClientOnMainThread(m_streamID, [streamID = m_streamID, buffer = WTFMove(receiveBuffer), length = bytesReceived](Client& client) mutable {

147 client.didReceiveData(streamID, buffer.get(), length);

    receiveBuffer.resize(bytesReceived);

    m_scheduler.callClientOnMainThread(m_streamID, [streamID = m_streamID, buffer = SharedBuffer::create(WTFMove(receiveBuffer))](Client& client) {

        client.didReceiveData(streamID, buffer);

    });

}

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

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

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

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

12 *

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

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

namespace WebCore {

class CurlStreamScheduler;

36class SharedBuffer;

class SocketStreamError;

using CurlStreamID = uint16_t;

@@public:

    public:

        virtual void didOpen(CurlStreamID) = 0;

        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;

        virtual void didFail(CurlStreamID, CURLcode) = 0;

    };

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

@@private:

    std::optional<size_t> platformSendInternal(const uint8_t*, size_t);

    bool sendPendingData();

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;

    void didFail(CurlStreamID, CURLcode) final;

    bool isStreamInvalidated() { return m_streamID == invalidCurlStreamID; }

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

#include "CurlStreamScheduler.h"

#include "DeprecatedGlobalSettings.h"

40#include "SharedBuffer.h"

#include "SocketStreamError.h"

#include "SocketStreamHandleClient.h"

#include "StorageSessionProvider.h"

@@void SocketStreamHandleImpl::didSendData(CurlStreamID, size_t length)

    sendPendingData();

}

107 void SocketStreamHandleImpl::didReceiveData(CurlStreamID, const uint8_t* data~~, size_t length~~)

108void SocketStreamHandleImpl::didReceiveData(CurlStreamID, const SharedBuffer& data)

{

    if (m_state != Open)

        return;

112 m_client.didReceiveSocketStreamData(*this, data~~, length~~);

113 m_client.didReceiveSocketStreamData(*this, data.data(), data.size());

}

void SocketStreamHandleImpl::didFail(CurlStreamID, CURLcode errorCode)

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

namespace WebCore {

34 class ~~Fragmented~~SharedBuffer;

34class SharedBuffer;

class LegacyPreviewLoaderClient : public RefCounted<LegacyPreviewLoaderClient> {

public:

    virtual ~LegacyPreviewLoaderClient() = default;

39 virtual void didReceive~~Buffer~~(const ~~Fragmented~~SharedBuffer&) { }

39 virtual void didReceiveData(const SharedBuffer&) { }

    virtual void didFinishLoading() { }

    virtual void didFail() { }

    virtual bool supportsPasswordEntry() const { return false; }

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

@@- (void)connection:(NSURLConnection *)connection didReceiveData:(NSData *)data l

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

        // -1 means we do not provide any data about transfer size to inspector so it would use

        // Content-Length headers or content size to show transfer size.

303 m_handle->client()->didReceive~~Buffer~~(m_handle, SharedBuffer::create(data.get()), -1);

303 m_handle->client()->didReceiveData(m_handle, SharedBuffer::create(data.get()), -1);

    };

    [self callFunctionOnMainThread:WTFMove(work)];

Source/WebCore/svg/graphics/SVGImage.cpp

@@EncodedDataStatus SVGImage::dataChanged(bool allDataReceived)

        ASSERT(loader.activeDocumentLoader()); // DocumentLoader should have been created by frame->init().

        loader.activeDocumentLoader()->writer().setMIMEType("image/svg+xml");

        loader.activeDocumentLoader()->writer().begin(URL()); // create the empty document

549 data()->forEachSegment([&](auto& s~~egment~~) {

550 loader.activeDocumentLoader()->writer().addData(s~~egment.data(), segment.size()~~);

549 data()->forEachSegmentAsSharedBuffer([&](auto&& buffer) {

550 loader.activeDocumentLoader()->writer().addData(buffer);

        });

        loader.activeDocumentLoader()->writer().end();

Source/WebCore/testing/MockContentFilter.cpp

@@void MockContentFilter::responseReceived(const ResourceResponse&)

    maybeDetermineStatus(DecisionPoint::AfterResponse);

}

103 void MockContentFilter::addData(const ~~uint8_t*, int~~)

103void MockContentFilter::addData(const SharedBuffer&)

{

    maybeDetermineStatus(DecisionPoint::AfterAddData);

}

Source/WebCore/testing/MockContentFilter.h

@@public:

    void willSendRequest(ResourceRequest&, const ResourceResponse&) override;

    void responseReceived(const ResourceResponse&) override;

43 void addData(const ~~uint8_t* data, int length~~) override;

43 void addData(const SharedBuffer&) override;

    void finishedAddingData() override;

    Ref<FragmentedSharedBuffer> replacementData() const override;

#if ENABLE(CONTENT_FILTERING)

Source/WebCore/workers/WorkerFontLoadRequest.cpp

@@void WorkerFontLoadRequest::didReceiveResponse(ResourceLoaderIdentifier, const R

        m_errorOccurred = true;

}

118 void WorkerFontLoadRequest::didReceiveData(const uint8_t* ~~data, int dataLength~~)

118void WorkerFontLoadRequest::didReceiveData(const SharedBuffer& buffer, bool)

{

    if (m_errorOccurred)

        return;

123 m_data.append(~~data, dataLength~~);

123 m_data.append(buffer);

}

void WorkerFontLoadRequest::didFinishLoading(ResourceLoaderIdentifier)

Source/WebCore/workers/WorkerFontLoadRequest.h

@@private:

    bool isWorkerFontLoadRequest() const final { return true; }

    void didReceiveResponse(ResourceLoaderIdentifier, const ResourceResponse&) final;

66 void didReceiveData(const ~~uint8_t* data, int dataLength~~) final;

66 void didReceiveData(const SharedBuffer&, bool) final;

    void didFinishLoading(ResourceLoaderIdentifier) final;

    void didFail(const ResourceError&) final;

Source/WebCore/workers/WorkerScriptLoader.cpp

@@void WorkerScriptLoader::didReceiveResponse(ResourceLoaderIdentifier identifier,

        m_client->didReceiveResponse(identifier, response);

}

203 void WorkerScriptLoader::didReceiveData(const uint8_t* ~~data, int l~~en)

203void WorkerScriptLoader::didReceiveData(const SharedBuffer& buffer, bool useStrLen)

{

    if (m_failed)

        return;

@@void WorkerScriptLoader::didReceiveData(const uint8_t* data, int len)

            m_decoder = TextResourceDecoder::create("text/javascript"_s, "UTF-8");

    }

215 if (!len)

215 if (buffer.isEmpty())

216216 return;

    
    if (len == -1)

        len = strlen(reinterpret_cast<const char*>(data));

220217

221 m_script.append(m_decoder->decode(data, len));

218 size_t len = useStrLen ? strlen(reinterpret_cast<const char*>(buffer.data())) : buffer.size();

219 m_script.append(m_decoder->decode(buffer.data(), len));

}

void WorkerScriptLoader::didFinishLoading(ResourceLoaderIdentifier identifier)

Source/WebCore/workers/WorkerScriptLoader.h

@@public:

    const ResourceError& error() const { return m_error; }

    void didReceiveResponse(ResourceLoaderIdentifier, const ResourceResponse&) override;

82 void didReceiveData(const ~~uint8_t* data, int data~~Len~~gth~~) override;

82 void didReceiveData(const SharedBuffer&, bool useStrLen) override;

    void didFinishLoading(ResourceLoaderIdentifier) override;

    void didFail(const ResourceError&) override;

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

@@public:

    virtual void didReceiveRedirection(const ResourceResponse&) = 0;

    virtual void didReceiveResponse(const ResourceResponse&) = 0;

54 virtual void didReceiveData(~~Ref<Fragme~~n~~ted~~SharedBuffer>&&) = 0;

54 virtual void didReceiveData(const SharedBuffer&) = 0;

    virtual void didReceiveFormDataAndFinish(Ref<FormData>&&) = 0;

    virtual void didFail(const ResourceError&) = 0;

    virtual void didFinish() = 0;

Source/WebCore/xml/XMLHttpRequest.cpp

@@Ref<TextResourceDecoder> XMLHttpRequest::createDecoder() const

    return TextResourceDecoder::create("text/plain", "UTF-8");

}

1037 void XMLHttpRequest::didReceiveData(const uint8_t* ~~data, int l~~en)

1037void XMLHttpRequest::didReceiveData(const SharedBuffer& buffer, bool useStrLen)

{

    if (m_error)

        return;

@@void XMLHttpRequest::didReceiveData(const uint8_t* data, int len)

    if (useDecoder && !m_decoder)

        m_decoder = createDecoder();

1055 if (!len)

1055 if (buffer.isEmpty())

10561056 return;

10571057

1058 if (len == -1)

1059 len = strlen(reinterpret_cast<const char*>(data));

1058 size_t len = useStrLen ? strlen(reinterpret_cast<const char*>(buffer.data())) : buffer.size();

10601059

10611060 if (useDecoder)

1062 m_responseBuilder.append(m_decoder->decode(data, len));

1061 m_responseBuilder.append(m_decoder->decode(buffer.data(), len));

10631062 else {

10641063 // Buffer binary data.

1065 m_binaryResponseBuilder.append(~~data, l~~en);

1064 m_binaryResponseBuilder.append(buffer);

    }

    if (!m_error) {

Source/WebCore/xml/XMLHttpRequest.h

@@private:

    // ThreadableLoaderClient

    void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent) override;

    void didReceiveResponse(ResourceLoaderIdentifier, const ResourceResponse&) override;

165 void didReceiveData(const ~~uint8_t* data, int dataLength~~) override;

165 void didReceiveData(const SharedBuffer&, bool) override;

    void didFinishLoading(ResourceLoaderIdentifier) override;

    void didFail(const ResourceError&) override;

    void notifyIsDone(bool) final;

Source/WebKit/GPUProcess/media/RemoteMediaResource.cpp

#include "RemoteMediaPlayerProxy.h"

#include "RemoteMediaResourceManager.h"

#include <WebCore/ResourceResponse.h>

34#include <WebCore/SharedBuffer.h>

namespace WebKit {

@@void RemoteMediaResource::dataSent(uint64_t bytesSent, uint64_t totalBytesToBeSe

        m_client->dataSent(*this, bytesSent, totalBytesToBeSent);

}

99 void RemoteMediaResource::dataReceived(~~Ref<Fragme~~n~~ted~~SharedBuffer>&& 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);

}

void RemoteMediaResource::accessControlCheckFailed(const ResourceError& error)

Source/WebKit/GPUProcess/media/RemoteMediaResource.h

namespace WebCore {

class NetworkLoadMetrics;

class FragmentedSharedBuffer;

38class SharedBuffer;

}

namespace WebKit {

@@public:

    void responseReceived(const WebCore::ResourceResponse&, bool, CompletionHandler<void(WebCore::ShouldContinuePolicyCheck)>&&);

    void redirectReceived(WebCore::ResourceRequest&&, const WebCore::ResourceResponse&, CompletionHandler<void(WebCore::ResourceRequest&&)>&&);

    void dataSent(uint64_t, uint64_t);

60 void dataReceived(~~Ref<~~WebCore::~~Fragmented~~SharedBuffer>&&);

61 void dataReceived(const WebCore::SharedBuffer&);

    void accessControlCheckFailed(const WebCore::ResourceError&);

    void loadFailed(const WebCore::ResourceError&);

    void loadFinished(const WebCore::NetworkLoadMetrics&);

Source/WebKit/NetworkProcess/Downloads/PendingDownload.h

@@private:

    bool isAllowedToAskUserForCredentials() const final { return m_isAllowedToAskUserForCredentials; }

    void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) override;

    void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) override;

71 void didReceiveBuffer(~~Ref<~~WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) override { };

71 void didReceiveBuffer(const WebCore::FragmentedSharedBuffer&, int reportedEncodedDataLength) override { };

    void didFinishLoading(const WebCore::NetworkLoadMetrics&) override { };

    void didFailLoading(const WebCore::ResourceError&) override;

Source/WebKit/NetworkProcess/NetworkCORSPreflightChecker.cpp

@@void NetworkCORSPreflightChecker::didReceiveResponse(WebCore::ResourceResponse&&

    completionHandler(PolicyAction::Use);

}

123 void NetworkCORSPreflightChecker::didReceiveData(~~Ref<~~WebCore::~~Fragmented~~SharedBuffer>&&)

123void NetworkCORSPreflightChecker::didReceiveData(const WebCore::SharedBuffer&)

{

    CORS_CHECKER_RELEASE_LOG("didReceiveData");

}

Source/WebKit/NetworkProcess/NetworkCORSPreflightChecker.h

namespace WebCore {

class ResourceError;

class SecurityOrigin;

40class SharedBuffer;

}

namespace WebKit {

@@private:

    void willPerformHTTPRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, RedirectCompletionHandler&&) final;

    void didReceiveChallenge(WebCore::AuthenticationChallenge&&, NegotiatedLegacyTLS, ChallengeCompletionHandler&&) final;

    void didReceiveResponse(WebCore::ResourceResponse&&, NegotiatedLegacyTLS, ResponseCompletionHandler&&) final;

74 void didReceiveData(~~Ref<~~WebCore::~~Fragmented~~SharedBuffer>&&) final;

75 void didReceiveData(const WebCore::SharedBuffer&) final;

    void didCompleteWithError(const WebCore::ResourceError&, const WebCore::NetworkLoadMetrics&) final;

    void didSendData(uint64_t totalBytesSent, uint64_t totalBytesExpectedToSend) final;

    void wasBlocked() final;

Source/WebKit/NetworkProcess/NetworkDataTask.h

@@namespace WebCore {

class AuthenticationChallenge;

class ResourceError;

class ResourceResponse;

46 class ~~Fragmented~~SharedBuffer;

46class SharedBuffer;

}

namespace WebKit {

@@public:

    virtual void willPerformHTTPRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, RedirectCompletionHandler&&) = 0;

    virtual void didReceiveChallenge(WebCore::AuthenticationChallenge&&, NegotiatedLegacyTLS, ChallengeCompletionHandler&&) = 0;

    virtual void didReceiveResponse(WebCore::ResourceResponse&&, NegotiatedLegacyTLS, ResponseCompletionHandler&&) = 0;

66 virtual void didReceiveData(~~Ref<~~WebCore::~~Fragmented~~SharedBuffer>&&) = 0;

66 virtual void didReceiveData(const WebCore::SharedBuffer&) = 0;

    virtual void didCompleteWithError(const WebCore::ResourceError&, const WebCore::NetworkLoadMetrics&) = 0;

    virtual void didSendData(uint64_t totalBytesSent, uint64_t totalBytesExpectedToSend) = 0;

    virtual void wasBlocked() = 0;

Source/WebKit/NetworkProcess/NetworkLoad.cpp

@@void NetworkLoad::notifyDidReceiveResponse(ResourceResponse&& response, Negotiat

    m_client.get().didReceiveResponse(WTFMove(response), WTFMove(completionHandler));

}

257 void NetworkLoad::didReceiveData(R~~ef<Fragmented~~SharedBuffer>&& 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());

}

void NetworkLoad::didCompleteWithError(const ResourceError& error, const WebCore::NetworkLoadMetrics& networkLoadMetrics)

Source/WebKit/NetworkProcess/NetworkLoad.h

@@private:

    void willPerformHTTPRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, RedirectCompletionHandler&&) final;

    void didReceiveChallenge(WebCore::AuthenticationChallenge&&, NegotiatedLegacyTLS, ChallengeCompletionHandler&&) final;

    void didReceiveResponse(WebCore::ResourceResponse&&, NegotiatedLegacyTLS, ResponseCompletionHandler&&) final;

84 void didReceiveData(~~Ref<~~WebCore::~~Fragmented~~SharedBuffer>&&) final;

84 void didReceiveData(const WebCore::SharedBuffer&) final;

    void didCompleteWithError(const WebCore::ResourceError&, const WebCore::NetworkLoadMetrics&) final;

    void didSendData(uint64_t totalBytesSent, uint64_t totalBytesExpectedToSend) final;

    void wasBlocked() final;

Source/WebKit/NetworkProcess/NetworkLoadClient.h

@@public:

    virtual void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent) = 0;

    virtual void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) = 0;

    virtual void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) = 0;

54 virtual void didReceiveBuffer(~~Ref<~~WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) = 0;

54 virtual void didReceiveBuffer(const WebCore::FragmentedSharedBuffer&, int reportedEncodedDataLength) = 0;

    virtual void didFinishLoading(const WebCore::NetworkLoadMetrics&) = 0;

    virtual void didFailLoading(const WebCore::ResourceError&) = 0;

    virtual void didBlockAuthenticationChallenge() { };

Source/WebKit/NetworkProcess/NetworkResourceLoader.cpp

@@void NetworkResourceLoader::sendDidReceiveResponsePotentiallyInNewBrowsingContex

    });

}

866 void NetworkResourceLoader::didReceiveBuffer(R~~ef<~~FragmentedSharedBuffer>&& buffer, int reportedEncodedDataLength)

866void NetworkResourceLoader::didReceiveBuffer(const WebCore::FragmentedSharedBuffer& buffer, int reportedEncodedDataLength)

867867{

868868 if (!m_numBytesReceived)

869 LOADER_RELEASE_LOG("didReceive~~Buffer~~: 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();

    ASSERT(!m_cacheEntryForValidation);

    if (m_bufferedDataForCache) {

        // Prevent memory growth in case of streaming data and limit size of entries in the cache.

        const size_t maximumCacheBufferSize = m_cache->capacity() / 8;

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);

        else

            m_bufferedDataForCache.reset();

    }

    if (isCrossOriginPrefetch())

        return;

    // 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);

        m_bufferedDataEncodedDataLength += encodedDataLength;

        startBufferingTimerIfNeeded();

        return;

@@void NetworkResourceLoader::bufferingTimerFired()

    m_bufferedDataEncodedDataLength = 0;

}

1276 void NetworkResourceLoader::sendBuffer(FragmentedSharedBuffer& buffer, size_t encodedDataLength)

1276void NetworkResourceLoader::sendBuffer(const FragmentedSharedBuffer& buffer, size_t encodedDataLength)

{

    ASSERT(!isSynchronous());

Source/WebKit/NetworkProcess/NetworkResourceLoader.h

@@public:

    bool isAllowedToAskUserForCredentials() const final { return m_isAllowedToAskUserForCredentials; }

    void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&&) final;

    void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) final;

118 void didReceiveBuffer(~~Ref<~~WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) final;

118 void didReceiveBuffer(const WebCore::FragmentedSharedBuffer&, int reportedEncodedDataLength) final;

    void didFinishLoading(const WebCore::NetworkLoadMetrics&) final;

    void didFailLoading(const WebCore::ResourceError&) final;

    void didBlockAuthenticationChallenge() final;

@@private:

    void startBufferingTimerIfNeeded();

    void bufferingTimerFired();

196 void sendBuffer(WebCore::FragmentedSharedBuffer&, size_t encodedDataLength);

196 void sendBuffer(const WebCore::FragmentedSharedBuffer&, size_t encodedDataLength);

    void consumeSandboxExtensions();

    void invalidateSandboxExtensions();

Source/WebKit/NetworkProcess/PingLoad.cpp

@@void PingLoad::didReceiveResponse(ResourceResponse&& response, NegotiatedLegacyT

    didFinish({ }, response);

}

175 void PingLoad::didReceiveData(~~Ref<Fragme~~n~~ted~~SharedBuffer>&&)

175void PingLoad::didReceiveData(const SharedBuffer&)

{

    PING_RELEASE_LOG("didReceiveData");

    ASSERT_NOT_REACHED();

Source/WebKit/NetworkProcess/PingLoad.h

@@private:

    void willPerformHTTPRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, RedirectCompletionHandler&&) final;

    void didReceiveChallenge(WebCore::AuthenticationChallenge&&, NegotiatedLegacyTLS, ChallengeCompletionHandler&&) final;

    void didReceiveResponse(WebCore::ResourceResponse&&, NegotiatedLegacyTLS, ResponseCompletionHandler&&) final;

57 void didReceiveData(~~Ref<~~WebCore::~~Fragmented~~SharedBuffer>&&) final;

57 void didReceiveData(const WebCore::SharedBuffer&) final;

    void didCompleteWithError(const WebCore::ResourceError&, const WebCore::NetworkLoadMetrics&) final;

    void didSendData(uint64_t totalBytesSent, uint64_t totalBytesExpectedToSend) final;

    void wasBlocked() final;

Source/WebKit/NetworkProcess/PreconnectTask.cpp

@@void PreconnectTask::didReceiveResponse(ResourceResponse&& response, ResponseCom

    completionHandler(PolicyAction::Ignore);

}

82 void PreconnectTask::didReceiveBuffer(~~Ref<~~FragmentedSharedBuffer>&&, int reportedEncodedDataLength)

82void PreconnectTask::didReceiveBuffer(const FragmentedSharedBuffer&, int reportedEncodedDataLength)

{

    ASSERT_NOT_REACHED();

}

Source/WebKit/NetworkProcess/PreconnectTask.h

@@private:

    void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent) final;

    void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) final;

    void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) final;

58 void didReceiveBuffer(~~Ref<~~WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) final;

58 void didReceiveBuffer(const WebCore::FragmentedSharedBuffer&, int reportedEncodedDataLength) final;

    void didFinishLoading(const WebCore::NetworkLoadMetrics&) final;

    void didFailLoading(const WebCore::ResourceError&) final;

Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerDownloadTask.cpp

#include "DownloadManager.h"

#include "Logging.h"

#include "NetworkProcess.h"

34#include "SharedBufferCopy.h"

#include "WebErrors.h"

#include "WebSWContextManagerConnectionMessages.h"

#include "WebSWServerToContextConnection.h"

@@void ServiceWorkerDownloadTask::start()

    downloadPtr->didCreateDestination(m_pendingDownloadLocation);

}

176 void ServiceWorkerDownloadTask::didReceiveData(const IPC::D~~ataR~~efer~~ence~~& data, int64_t encodedDataLength)

177void ServiceWorkerDownloadTask::didReceiveData(const IPC::SharedBufferCopy& data, int64_t encodedDataLength)

{

    ASSERT(!isMainRunLoop());

Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerDownloadTask.h

namespace IPC {

class FormDataReference;

40class SharedBufferCopy;

}

namespace WebKit {

@@private:

    ServiceWorkerDownloadTask(NetworkSession&, NetworkDataTaskClient&, WebSWServerToContextConnection&, WebCore::ServiceWorkerIdentifier, WebCore::SWServerConnectionIdentifier, WebCore::FetchIdentifier, const WebCore::ResourceRequest&, DownloadID);

    // IPC Message

69 void didReceiveData(const IPC::D~~ataR~~efer~~ence~~&, int64_t encodedDataLength);

70 void didReceiveData(const IPC::SharedBufferCopy&, int64_t encodedDataLength);

    void didReceiveFormData(const IPC::FormDataReference&);

    void didFinish();

    void didFail(WebCore::ResourceError&&);

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

messages -> ServiceWorkerDownloadTask NotRefCounted {

    DidFail(WebCore::ResourceError error)

27 DidReceiveData(IPC::SharedBuffer~~DataReference~~ data, int64_t encodedDataLength)

27 DidReceiveData(IPC::SharedBufferCopy data, int64_t encodedDataLength)

    DidReceiveFormData(IPC::FormDataReference data)

    DidFinish()

}

Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerFetchTask.cpp

#include "NetworkResourceLoader.h"

#include "NetworkSession.h"

#include "ServiceWorkerNavigationPreloader.h"

39 #include "SharedBuffer~~DataReference~~.h"

39#include "SharedBufferCopy.h"

#include "WebCoreArgumentCoders.h"

#include "WebResourceLoaderMessages.h"

#include "WebSWContextManagerConnectionMessages.h"

@@void ServiceWorkerFetchTask::processResponse(ResourceResponse&& response, bool n

        m_loader.setResponse(WTFMove(response));

}

228 void ServiceWorkerFetchTask::didReceiveData(const IPC::D~~ataR~~efer~~ence~~& data, int64_t encodedDataLength)

228void ServiceWorkerFetchTask::didReceiveData(const IPC::SharedBufferCopy& data, int64_t encodedDataLength)

{

    if (m_isDone)

        return;

@@void ServiceWorkerFetchTask::loadBodyFromPreloader()

            didFinishWithMetrics(m_preloader->networkLoadMetrics());

            return;

        }

404 didReceiveData(~~IPC::Data~~Ref~~erence~~ { chunk~~->data(), chunk->size(~~) }, length);

404 didReceiveData(Ref { const_cast<WebCore::FragmentedSharedBuffer&>(*chunk) }, length);

    });

}

Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerFetchTask.h

@@namespace IPC {

class Connection;

class Decoder;

class FormDataReference;

51class SharedBufferCopy;

}

namespace WebCore {

@@private:

    enum class ShouldSetSource : bool { No, Yes };

    void didReceiveRedirectResponse(WebCore::ResourceResponse&&);

    void didReceiveResponse(WebCore::ResourceResponse&&, bool needsContinueDidReceiveResponseMessage);

96 void didReceiveData(const IPC::D~~ataR~~efer~~ence~~&, int64_t encodedDataLength);

97 void didReceiveData(const IPC::SharedBufferCopy&, int64_t encodedDataLength);

    void didReceiveFormData(const IPC::FormDataReference&);

    void didFinish();

    void didFinishWithMetrics(const WebCore::NetworkLoadMetrics&);

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

@@messages -> ServiceWorkerFetchTask NotRefCounted {

    DidFail(WebCore::ResourceError error)

    DidReceiveRedirectResponse(WebCore::ResourceResponse response)

    DidReceiveResponse(WebCore::ResourceResponse response, bool needsContinueDidReceiveResponseMessage)

30 DidReceiveData(IPC::SharedBuffer~~DataReference~~ data, int64_t encodedDataLength)

30 DidReceiveData(IPC::SharedBufferCopy data, int64_t encodedDataLength)

    DidReceiveFormData(IPC::FormDataReference data)

    DidFinish()

}

Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerNavigationPreloader.cpp

@@void ServiceWorkerNavigationPreloader::didReceiveResponse(ResourceResponse&& res

        callback();

}

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);

}

void ServiceWorkerNavigationPreloader::didFinishLoading(const NetworkLoadMetrics& networkLoadMetrics)

Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerNavigationPreloader.h

namespace WebCore {

class NetworkLoadMetrics;

39class FragmentedSharedBuffer;

}

namespace WebKit {

@@public:

    using ResponseCallback = Function<void()>;

    void waitForResponse(ResponseCallback&&);

57 using BodyCallback = Function<void(RefPtr<WebCore::SharedBuffer>&&, int reportedEncodedDataLength)>;

58 using BodyCallback = Function<void(RefPtr<const WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength)>;

    void waitForBody(BodyCallback&&);

    const WebCore::ResourceError& error() const { return m_error; }

@@private:

    bool isAllowedToAskUserForCredentials() const final { return false; }

    void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) final;

    void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) final;

74 void didReceiveBuffer(~~Ref<~~WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) final;

75 void didReceiveBuffer(const WebCore::FragmentedSharedBuffer&, int reportedEncodedDataLength) final;

    void didFinishLoading(const WebCore::NetworkLoadMetrics&) final;

    void didFailLoading(const WebCore::ResourceError&) final;

    bool shouldCaptureExtraNetworkLoadMetrics() const final { return m_shouldCaptureExtraNetworkLoadMetrics; }

Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerSoftUpdateLoader.cpp

@@ResourceError ServiceWorkerSoftUpdateLoader::processResponse(const ResourceRespo

    return { };

}

180 void ServiceWorkerSoftUpdateLoader::didReceiveBuffer(R~~ef<~~FragmentedSharedBuffer>&& buffer, int reportedEncodedDataLength)

180void ServiceWorkerSoftUpdateLoader::didReceiveBuffer(const WebCore::FragmentedSharedBuffer& buffer, int reportedEncodedDataLength)

{

    if (!m_decoder) {

        if (!m_responseEncoding.isEmpty())

@@void ServiceWorkerSoftUpdateLoader::didReceiveBuffer(Ref<FragmentedSharedBuffer>

            m_decoder = TextResourceDecoder::create("text/javascript"_s, "UTF-8");

    }

189 if (auto size = buffer->size())

190 m_script.append(m_decoder->decode(buffer->makeContiguous()->data(), size));

    if (!buffer.isEmpty()) {

        buffer.forEachSegment([&](auto& segment) {

            m_script.append(m_decoder->decode(segment.data(), segment.size()));

        });

    }

}

void ServiceWorkerSoftUpdateLoader::didFinishLoading(const WebCore::NetworkLoadMetrics&)

Source/WebKit/NetworkProcess/ServiceWorker/ServiceWorkerSoftUpdateLoader.h

@@private:

    bool isAllowedToAskUserForCredentials() const final { return false; }

    void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) final;

    void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) final;

67 void didReceiveBuffer(~~Ref<~~WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) final;

67 void didReceiveBuffer(const WebCore::FragmentedSharedBuffer&, int reportedEncodedDataLength) final;

    void didFinishLoading(const WebCore::NetworkLoadMetrics&) final;

    void didFailLoading(const WebCore::ResourceError&) final;

Source/WebKit/NetworkProcess/cache/NetworkCacheSpeculativeLoad.cpp

@@void SpeculativeLoad::didReceiveResponse(ResourceResponse&& receivedResponse, Re

    completionHandler(PolicyAction::Use);

}

123 void SpeculativeLoad::didReceiveBuffer(R~~ef<~~FragmentedSharedBuffer>&& buffer, int reportedEncodedDataLength)

123void SpeculativeLoad::didReceiveBuffer(const WebCore::FragmentedSharedBuffer& buffer, int reportedEncodedDataLength)

{

    ASSERT(!m_cacheEntry);

    if (m_bufferedDataForCache) {

        // Prevent memory growth in case of streaming data.

        const size_t maximumCacheBufferSize = 10 * 1024 * 1024;

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);

        else

            m_bufferedDataForCache.reset();

    }

Source/WebKit/NetworkProcess/cache/NetworkCacheSpeculativeLoad.h

@@private:

    bool isAllowedToAskUserForCredentials() const final { return false; }

    void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) override;

    void didReceiveResponse(WebCore::ResourceResponse&&, ResponseCompletionHandler&&) override;

64 void didReceiveBuffer(~~Ref<~~WebCore::FragmentedSharedBuffer>&&, int reportedEncodedDataLength) override;

64 void didReceiveBuffer(const WebCore::FragmentedSharedBuffer&, int reportedEncodedDataLength) override;

    void didFinishLoading(const WebCore::NetworkLoadMetrics&) override;

    void didFailLoading(const WebCore::ResourceError&) override;

Source/WebKit/NetworkProcess/cocoa/NetworkDataTaskCocoa.h

@@OBJC_CLASS NSMutableURLRequest;

namespace WebCore {

class RegistrableDomain;

41class SharedBuffer;

}

namespace WebKit {

@@public:

    void didNegotiateModernTLS(const URL&);

    void didCompleteWithError(const WebCore::ResourceError&, const WebCore::NetworkLoadMetrics&);

    void didReceiveResponse(WebCore::ResourceResponse&&, NegotiatedLegacyTLS, ResponseCompletionHandler&&);

65 void didReceiveData(~~Ref<~~WebCore::~~Fragmented~~SharedBuffer>&&);

66 void didReceiveData(const WebCore::SharedBuffer&);

    void willPerformHTTPRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, RedirectCompletionHandler&&);

    void transferSandboxExtensionToDownload(Download&);

Source/WebKit/NetworkProcess/cocoa/NetworkDataTaskCocoa.mm

@@void NetworkDataTaskCocoa::didCompleteWithError(const WebCore::ResourceError& er

        m_client->didCompleteWithError(error, networkLoadMetrics);

}

446 void NetworkDataTaskCocoa::didReceiveData(~~Ref<~~WebCore::~~Fragmented~~SharedBuffer>&& data)

446void NetworkDataTaskCocoa::didReceiveData(const WebCore::SharedBuffer& data)

447447{

448 WTFEmitSignpost(m_task.get(), "DataTask", "received %zd bytes", data->size());

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);

}

void NetworkDataTaskCocoa::didReceiveResponse(WebCore::ResourceResponse&& response, NegotiatedLegacyTLS negotiatedLegacyTLS, WebKit::ResponseCompletionHandler&& completionHandler)

Source/WebKit/NetworkProcess/curl/NetworkDataTaskCurl.cpp

#include <WebCore/NotImplemented.h>

#include <WebCore/ResourceError.h>

#include <WebCore/SameSiteInfo.h>

40#include <WebCore/SharedBuffer.h>

#include <WebCore/ShouldRelaxThirdPartyCookieBlocking.h>

#include <WebCore/SynchronousLoaderClient.h>

#include <pal/text/TextEncoding.h>

@@void NetworkDataTaskCurl::curlDidReceiveResponse(CurlRequest& request, CurlRespo

    invokeDidReceiveResponse();

}

175 void NetworkDataTaskCurl::curlDidReceive~~Buffer~~(CurlRequest&, ~~Ref<Fragme~~n~~ted~~SharedBuffer>&& buffer)

176void NetworkDataTaskCurl::curlDidReceiveData(CurlRequest&, const SharedBuffer& buffer)

{

    Ref protectedThis { *this };

    if (state() == State::Canceling || state() == State::Completed || (!m_client && !isDownload()))

        return;

181 m_client->didReceiveData(~~WTFMove(~~buffer));

182 m_client->didReceiveData(buffer);

}

void NetworkDataTaskCurl::curlDidComplete(CurlRequest&, NetworkLoadMetrics&& networkLoadMetrics)

Source/WebKit/NetworkProcess/curl/NetworkDataTaskCurl.h

namespace WebCore {

class CurlRequest;

39class SharedBuffer;

}

namespace WebKit {

@@private:

    Ref<WebCore::CurlRequest> createCurlRequest(WebCore::ResourceRequest&&, RequestStatus = RequestStatus::NewRequest);

    void curlDidSendData(WebCore::CurlRequest&, unsigned long long, unsigned long long) override;

    void curlDidReceiveResponse(WebCore::CurlRequest&, WebCore::CurlResponse&&) override;

71 void curlDidReceive~~Buffer~~(WebCore::CurlRequest&, ~~Ref<~~WebCore::~~Fragmented~~SharedBuffer>&&) override;

72 void curlDidReceiveData(WebCore::CurlRequest&, const WebCore::SharedBuffer&) override;

    void curlDidComplete(WebCore::CurlRequest&, WebCore::NetworkLoadMetrics&&) override;

    void curlDidFailWithError(WebCore::CurlRequest&, WebCore::ResourceError&&, WebCore::CertificateInfo&&) override;

Source/WebKit/Platform/IPC/SharedBufferCopy.h

#pragma once

31#include "DataReference.h"

#include <WebCore/SharedBuffer.h>

namespace IPC {

@@public:

    RefPtr<WebCore::SharedBuffer>& buffer() { return m_buffer; }

    const RefPtr<WebCore::SharedBuffer>& buffer() const { return m_buffer; }

57 // TODO : SharedBufferCopy should contain a FragmentedSharedBuffer and those should go away.

58 // Allows to not unecessarily flatten the SharedBuffer before sending it over IPC.

    const uint8_t* data() const { return m_buffer ? m_buffer->data() : nullptr; }

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

    bool isEmpty() const { return m_buffer ? m_buffer->isEmpty() : true; }

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

@@void MediaFormatReader::didParseTracks(SourceBufferPrivateClient::Initialization

    ASSERT(!isMainRunLoop());

    Locker locker { m_parseTracksLock };

    ASSERT(!m_parseTracksStatus);

    ASSERT(m_duration.isInvalid());

    ASSERT(m_trackReaders.isEmpty());

    ASSERT(!m_parseTracksStatus || (m_init && errorCode));

    ASSERT(m_duration.isInvalid() || (m_init && errorCode));

    ASSERT(m_trackReaders.isEmpty() || (m_init && errorCode));

    ALWAYS_LOG_IF_POSSIBLE(LOGIDENTIFIER);

    if (errorCode)

@@void MediaFormatReader::didParseTracks(SourceBufferPrivateClient::Initialization

    }

    m_parseTracksCondition.notifyAll();

224 m_init = true;

}

void MediaFormatReader::didProvideMediaData(Ref<MediaSample>&& mediaSample, uint64_t trackID, const String&)

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

@@private:

    Vector<Ref<MediaTrackReader>> m_trackReaders WTF_GUARDED_BY_LOCK(m_parseTracksLock);

    RefPtr<const Logger> m_logger;

    const void* m_logIdentifier;

90 bool m_init { false };

};

constexpr MediaFormatReader::WrapperClass MediaFormatReader::wrapperClass()

Source/WebKit/UIProcess/WebURLSchemeTask.cpp

@@auto WebURLSchemeTask::didReceiveResponse(const ResourceResponse& response) -> E

    return ExceptionType::None;

}

171 auto WebURLSchemeTask::didReceiveData(~~Ref<Fragme~~n~~ted~~SharedBuffer>&& buffer) -> ExceptionType

171auto WebURLSchemeTask::didReceiveData(const SharedBuffer& buffer) -> ExceptionType

{

    ASSERT(RunLoop::isMain());

@@auto WebURLSchemeTask::didReceiveData(Ref<FragmentedSharedBuffer>&& buffer) -> E

    m_dataSent = true;

    if (isSync()) {

190 m_syncData.append(~~WTFMove(~~buffer));

190 m_syncData.append(buffer);

        return ExceptionType::None;

    }

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);

    return ExceptionType::None;

}

Source/WebKit/UIProcess/WebURLSchemeTask.h

@@public:

    ExceptionType willPerformRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&,  Function<void(WebCore::ResourceRequest&&)>&&);

    ExceptionType didPerformRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&);

    ExceptionType didReceiveResponse(const WebCore::ResourceResponse&);

86 ExceptionType didReceiveData(~~Ref<~~WebCore::~~Fragmented~~SharedBuffer>&&);

86 ExceptionType didReceiveData(const WebCore::SharedBuffer&);

    ExceptionType didComplete(const WebCore::ResourceError&);

    void stop();

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

@@void RemoteMediaResourceProxy::dataSent(WebCore::PlatformMediaResource&, unsigne

    m_connection->send(Messages::RemoteMediaResourceManager::DataSent(m_id, bytesSent, totalBytesToBeSent), 0);

}

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::~~allocat~~e(l~~ength~~);

77 auto sharedMemory = SharedMemory::copyBuffer(buffer);

    if (!sharedMemory)

        return;

    auto sharedMemoryPtr = static_cast<char*>(sharedMemory->data());

    memcpy(sharedMemoryPtr, data, length);

    SharedMemory::Handle handle;

    sharedMemory->createHandle(handle, SharedMemory::Protection::ReadOnly);

    // Take ownership of shared memory and mark it as media-related memory.

    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);

}

void RemoteMediaResourceProxy::accessControlCheckFailed(WebCore::PlatformMediaResource&, const WebCore::ResourceError& error)

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

@@private:

    void redirectReceived(WebCore::PlatformMediaResource&, WebCore::ResourceRequest&&, const WebCore::ResourceResponse&, CompletionHandler<void(WebCore::ResourceRequest&&)>&&) final;

    bool shouldCacheResponse(WebCore::PlatformMediaResource&, const WebCore::ResourceResponse&) final;

    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;

    void accessControlCheckFailed(WebCore::PlatformMediaResource&, const WebCore::ResourceError&) final;

    void loadFailed(WebCore::PlatformMediaResource&, const WebCore::ResourceError&) final;

    void loadFinished(WebCore::PlatformMediaResource&, const WebCore::NetworkLoadMetrics&) final;

Source/WebKit/WebProcess/Network/WebResourceLoader.cpp

#include "Logging.h"

#include "NetworkProcessConnection.h"

#include "NetworkResourceLoaderMessages.h"

33#include "SharedBufferCopy.h"

#include "WebCoreArgumentCoders.h"

#include "WebErrors.h"

#include "WebFrame.h"

@@void WebResourceLoader::didReceiveResponse(const ResourceResponse& response, boo

    m_coreLoader->didReceiveResponse(response, WTFMove(policyDecisionCompletionHandler));

}

203 void WebResourceLoader::didReceiveData(const IPC::D~~ataR~~efer~~ence~~& data, int64_t encodedDataLength)

204void WebResourceLoader::didReceiveData(const IPC::SharedBufferCopy& data, int64_t encodedDataLength)

{

    LOG(Network, "(WebProcess) WebResourceLoader::didReceiveData of size %lu for '%s'", data.size(), m_coreLoader->url().string().latin1().data());

    ASSERT_WITH_MESSAGE(!m_isProcessingNetworkResponse, "Network process should not send data until we've validated the response");

    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);

        });

        return;

    }

@@void WebResourceLoader::didReceiveData(const IPC::DataReference& data, int64_t e

        WEBRESOURCELOADER_RELEASE_LOG("didReceiveData: Started receiving data");

    m_numBytesReceived += data.size();

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);

}

void WebResourceLoader::didFinishResourceLoad(const NetworkLoadMetrics& networkLoadMetrics)

@@void WebResourceLoader::didReceiveResource(const ShareableResource::Handle& hand

    LOG(Network, "(WebProcess) WebResourceLoader::didReceiveResource for '%s'", m_coreLoader->url().string().latin1().data());

    WEBRESOURCELOADER_RELEASE_LOG("didReceiveResource:");

309 RefPtr<~~Fragmented~~SharedBuffer> buffer = handle.tryWrapInSharedBuffer();

310 RefPtr<SharedBuffer> buffer = handle.tryWrapInSharedBuffer();

    if (!buffer) {

        LOG_ERROR("Unable to create buffer from ShareableResource sent from the network process.");

@@void WebResourceLoader::didReceiveResource(const ShareableResource::Handle& hand

    // Only send data to the didReceiveData callback if it exists.

    if (unsigned bufferSize = buffer->size())

326 m_coreLoader->didReceive~~Buffer~~(buffer.releaseNonNull(), bufferSize, DataPayloadWholeResource);

327 m_coreLoader->didReceiveData(buffer.releaseNonNull(), bufferSize, DataPayloadWholeResource);

    if (!m_coreLoader)

        return;

Source/WebKit/WebProcess/Network/WebResourceLoader.h

namespace IPC {

class FormDataReference;

42class SharedBufferCopy;

}

namespace WebCore {

@@private:

    void willSendRequest(WebCore::ResourceRequest&&, IPC::FormDataReference&& requestBody, WebCore::ResourceResponse&&);

    void didSendData(uint64_t bytesSent, uint64_t totalBytesToBeSent);

    void didReceiveResponse(const WebCore::ResourceResponse&, bool needsContinueDidReceiveResponseMessage);

83 void didReceiveData(const IPC::Data~~Reference&~~, int64_t encodedDataLength);

84 void didReceiveData(const IPC::SharedBufferCopy& data, int64_t encodedDataLength);

    void didFinishResourceLoad(const WebCore::NetworkLoadMetrics&);

    void didFailResourceLoad(const WebCore::ResourceError&);

    void didFailServiceWorkerLoad(const WebCore::ResourceError&);

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

@@messages -> WebResourceLoader LegacyReceiver {

    WillSendRequest(WebCore::ResourceRequest request, IPC::FormDataReference requestBody, WebCore::ResourceResponse redirectResponse)

    DidSendData(uint64_t bytesSent, uint64_t totalBytesToBeSent)

    DidReceiveResponse(WebCore::ResourceResponse response, bool needsContinueDidReceiveResponseMessage)

27 DidReceiveData(IPC::SharedBuffer~~DataReference~~ data, int64_t encodedDataLength)

27 DidReceiveData(IPC::SharedBufferCopy data, int64_t encodedDataLength)

    DidFinishResourceLoad(WebCore::NetworkLoadMetrics networkLoadMetrics)

    DidFailResourceLoad(WebCore::ResourceError error)

    DidFailServiceWorkerLoad(WebCore::ResourceError error)

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

@@namespace WebCore {

class AXObjectCache;

class Element;

struct PluginInfo;

68class SharedBuffer;

}

namespace WTF {

@@private:

    void didEvaluateJavaScript(uint64_t requestID, const String& result) final;

    void streamWillSendRequest(uint64_t streamID, const URL& requestURL, const URL& responseURL, int responseStatus) final { }

    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;

    void streamDidFinishLoading(uint64_t streamID) final;

    void streamDidFail(uint64_t streamID, bool wasCancelled) final;

    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;

    void manualStreamDidFinishLoading() final;

    void manualStreamDidFail(bool wasCancelled) final;

    bool handleMouseEvent(const WebMouseEvent&) final;

@@private:

        void willSendRequest(WebCore::NetscapePlugInStreamLoader*, WebCore::ResourceRequest&&, const WebCore::ResourceResponse& redirectResponse, CompletionHandler<void(WebCore::ResourceRequest&&)>&&) final;

        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;

        void didFail(WebCore::NetscapePlugInStreamLoader*, const WebCore::ResourceError&) final;

        void didFinishLoading(WebCore::NetscapePlugInStreamLoader*) final;

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

#import <WebCore/ScrollAnimator.h>

#import <WebCore/ScrollbarTheme.h>

#import <WebCore/Settings.h>

97#import <WebCore/SharedBuffer.h>

#import <WebCore/WebAccessibilityObjectWrapperMac.h>

#import <WebCore/WheelEventTestMonitor.h>

#import <pal/spi/cg/CoreGraphicsSPI.h>

@@void PDFPlugin::PDFPluginStreamLoaderClient::didReceiveResponse(NetscapePlugInSt

    }

}

1194 void PDFPlugin::PDFPluginStreamLoaderClient::didReceiveData(NetscapePlugInStreamLoader* loader, const uint8_t* data~~, int count~~)

1195void PDFPlugin::PDFPluginStreamLoaderClient::didReceiveData(NetscapePlugInStreamLoader* loader, const SharedBuffer& data)

{

    if (!m_pdfPlugin)

        return;

@@void PDFPlugin::PDFPluginStreamLoaderClient::didReceiveData(NetscapePlugInStream

    if (!request)

        return;

1203 request->addData(data~~, coun~~t);

1204 request->addData(data.data(), data.size());

}

void PDFPlugin::PDFPluginStreamLoaderClient::didFail(NetscapePlugInStreamLoader* loader, const ResourceError&)

@@void PDFPlugin::streamDidReceiveResponse(uint64_t streamID, const URL&, uint32_t

        m_isPostScript = true;

}

1721 void PDFPlugin::streamDidReceiveData(uint64_t streamID, const uint8_t* ~~bytes, int length~~)

1722void PDFPlugin::streamDidReceiveData(uint64_t streamID, const SharedBuffer& buffer)

{

    ASSERT_UNUSED(streamID, streamID == pdfDocumentRequestID);

    if (!m_data)

        m_data = adoptCF(CFDataCreateMutable(0, 0));

1728 CFDataAppendBytes(m_data.get(), by~~tes, length~~);

1729 m_streamedBytes += l~~ength~~;

1729 CFDataAppendBytes(m_data.get(), buffer.data(), buffer.size());

1730 m_streamedBytes += buffer.size();

}

void PDFPlugin::streamDidFinishLoading(uint64_t streamID)

@@void PDFPlugin::ensureDataBufferLength(uint64_t targetLength)

        CFDataIncreaseLength(m_data.get(), targetLength - currentLength);

}

1766 void PDFPlugin::manualStreamDidReceiveData(const uint8_t* ~~bytes, int length~~)

1767void PDFPlugin::manualStreamDidReceiveData(const SharedBuffer& buffer)

{

    if (!m_data)

        m_data = adoptCF(CFDataCreateMutable(0, 0));

    ensureDataBufferLength(m_streamedBytes + length);

    memcpy(CFDataGetMutableBytePtr(m_data.get()) + m_streamedBytes, bytes, length);

    m_streamedBytes += length;

    ensureDataBufferLength(m_streamedBytes + buffer.size());

    memcpy(CFDataGetMutableBytePtr(m_data.get()) + m_streamedBytes, buffer.data(), buffer.size());

    m_streamedBytes += buffer.size();

#if HAVE(INCREMENTAL_PDF_APIS)

    // Keep our ranges-lookup-table compact by continuously updating its first range

Source/WebKit/WebProcess/Plugins/Plugin.h

@@class AffineTransform;

class Element;

class FloatPoint;

class FloatSize;

57class FragmentedSharedBuffer;

class GraphicsContext;

class IntPoint;

class IntRect;

class IntSize;

class Scrollbar;

62 class ~~Fragmented~~SharedBuffer;

63class SharedBuffer;

}

namespace WebKit {

@@public:

                                          uint32_t lastModifiedTime, const String& mimeType, const String& headers, const String& suggestedFileName) = 0;

    // 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;

    // Tells the plug-in that a stream has finished loading.

    virtual void streamDidFinishLoading(uint64_t streamID) = 0;

@@public:

                                                uint32_t lastModifiedTime, const String& mimeType, const String& headers, const String& suggestedFileName) = 0;

    // 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;

    // Tells the plug-in that a stream has finished loading.

    virtual void manualStreamDidFinishLoading() = 0;

Source/WebKit/WebProcess/Plugins/PluginView.cpp

@@private:

    // NetscapePluginStreamLoaderClient

    void willSendRequest(NetscapePlugInStreamLoader*, ResourceRequest&&, const ResourceResponse& redirectResponse, CompletionHandler<void(ResourceRequest&&)>&&) override;

    void didReceiveResponse(NetscapePlugInStreamLoader*, const ResourceResponse&) override;

130 void didReceiveData(NetscapePlugInStreamLoader*, const ~~uint8_t*, int~~) override;

130 void didReceiveData(NetscapePlugInStreamLoader*, const SharedBuffer&) override;

    void didFail(NetscapePlugInStreamLoader*, const ResourceError&) override;

    void didFinishLoading(NetscapePlugInStreamLoader*) override;

@@void PluginView::Stream::didReceiveResponse(NetscapePlugInStreamLoader*, const R

    m_pluginView->m_plugin->streamDidReceiveResponse(m_streamID, responseURL, streamLength, lastModifiedDateMS(response), mimeType, headers, response.suggestedFilename());

}

238 void PluginView::Stream::didReceiveData(NetscapePlugInStreamLoader*, const uint8_t* ~~bytes, int length~~)

238void PluginView::Stream::didReceiveData(NetscapePlugInStreamLoader*, const SharedBuffer& buffer)

239239{

240 m_pluginView->m_plugin->streamDidReceiveData(m_streamID, byt~~es, length~~);

240 m_pluginView->m_plugin->streamDidReceiveData(m_streamID, buffer);

}

void PluginView::Stream::didFail(NetscapePlugInStreamLoader*, const ResourceError& error)

@@void PluginView::manualLoadDidReceiveResponse(const ResourceResponse& response)

    m_plugin->manualStreamDidReceiveResponse(responseURL, streamLength, lastModifiedDateMS(response), mimeType, headers, response.suggestedFilename());

}

377 void PluginView::manualLoadDidReceiveData(const uint8_t* ~~bytes, int length~~)

377void PluginView::manualLoadDidReceiveData(const SharedBuffer& buffer)

{

    // The plug-in can be null here if it failed to initialize.

    if (!m_plugin)

@@void PluginView::manualLoadDidReceiveData(const uint8_t* bytes, int length)

    if (!m_isInitialized) {

        ASSERT(m_manualStreamState == ManualStreamState::HasReceivedResponse);

385 m_manualStreamData.append(byt~~es, length~~);

385 m_manualStreamData.append(buffer);

        return;

    }

389 m_plugin->manualStreamDidReceiveData(byt~~es, length~~);

389 m_plugin->manualStreamDidReceiveData(buffer);

}

void PluginView::manualLoadDidFinishLoading()

@@void PluginView::redeliverManualStream()

    // Deliver the data.

    if (m_manualStreamData) {

        auto buffer = m_manualStreamData.take();

        for (const auto& element : buffer.get())

            manualLoadDidReceiveData(element.segment->data(), element.segment->size());

        m_manualStreamData.take()->forEachSegmentAsSharedBuffer([&](auto&& buffer) {

            manualLoadDidReceiveData(buffer);

        });

    }

    if (m_manualStreamState == ManualStreamState::Finished)

Source/WebKit/WebProcess/Plugins/PluginView.h

@@public:

    bool isBeingDestroyed() const { return !m_plugin || m_plugin->isBeingDestroyed(); }

    void manualLoadDidReceiveResponse(const WebCore::ResourceResponse&);

76 void manualLoadDidReceiveData(const ~~uint8_t* bytes, int length~~);

76 void manualLoadDidReceiveData(const WebCore::SharedBuffer&);

    void manualLoadDidFinishLoading();

    void manualLoadDidFail(const WebCore::ResourceError&);

Source/WebKit/WebProcess/Storage/WebServiceWorkerFetchTaskClient.cpp

@@void WebServiceWorkerFetchTaskClient::didReceiveResponse(const ResourceResponse&

    m_connection->send(Messages::ServiceWorkerFetchTask::DidReceiveResponse { response, m_needsContinueDidReceiveResponseMessage }, m_fetchIdentifier);

}

75 void WebServiceWorkerFetchTaskClient::didReceiveData(~~Ref<Fragme~~n~~ted~~SharedBuffer>&& buffer)

75void WebServiceWorkerFetchTaskClient::didReceiveData(const SharedBuffer& buffer)

{

    if (!m_connection)

        return;

@@void WebServiceWorkerFetchTaskClient::didReceiveData(Ref<FragmentedSharedBuffer>

    if (m_waitingForContinueDidReceiveResponseMessage) {

        if (!std::holds_alternative<SharedBufferBuilder>(m_responseData))

            m_responseData = SharedBufferBuilder();

83 std::get<SharedBufferBuilder>(m_responseData).append(~~WTFMove(~~buffer));

83 std::get<SharedBufferBuilder>(m_responseData).append(buffer);

        return;

    }

    if (m_isDownload)

88 m_connection->send(Messages::ServiceWorkerDownloadTask::DidReceiveData { buffer~~.get()~~, static_cast<int64_t>(buffer->size()) }, m_fetchIdentifier);

88 m_connection->send(Messages::ServiceWorkerDownloadTask::DidReceiveData { buffer, static_cast<int64_t>(buffer.size()) }, m_fetchIdentifier);

8989 else

90 m_connection->send(Messages::ServiceWorkerFetchTask::DidReceiveData { buffer~~.get()~~, static_cast<int64_t>(buffer->size()) }, m_fetchIdentifier);

90 m_connection->send(Messages::ServiceWorkerFetchTask::DidReceiveData { buffer, static_cast<int64_t>(buffer.size()) }, m_fetchIdentifier);

}

void WebServiceWorkerFetchTaskClient::didReceiveFormDataAndFinish(Ref<FormData>&& formData)

@@void WebServiceWorkerFetchTaskClient::didReceiveFormDataAndFinish(Ref<FormData>&

    });

}

139 void WebServiceWorkerFetchTaskClient::didReceiveBlobChunk(const uint8_t* ~~data, size_t size~~)

139void WebServiceWorkerFetchTaskClient::didReceiveBlobChunk(const SharedBuffer& buffer)

{

    if (!m_connection)

        return;

    if (m_isDownload)

145 m_connection->send(Messages::ServiceWorkerDownloadTask::DidReceiveData { ~~{ data, size }~~, static_cast<int64_t>(size) }, m_fetchIdentifier);

145 m_connection->send(Messages::ServiceWorkerDownloadTask::DidReceiveData { buffer, static_cast<int64_t>(buffer.size()) }, m_fetchIdentifier);

146146 else

147 m_connection->send(Messages::ServiceWorkerFetchTask::DidReceiveData { { ~~data, size }~~, static_cast<int64_t>(size) }, m_fetchIdentifier);

147 m_connection->send(Messages::ServiceWorkerFetchTask::DidReceiveData { buffer , static_cast<int64_t>(buffer.size()) }, m_fetchIdentifier);

}

void WebServiceWorkerFetchTaskClient::didFinishBlobLoading()

@@void WebServiceWorkerFetchTaskClient::continueDidReceiveResponse()

        if (m_didFinish)

            didFinish();

    }, [this](const SharedBufferBuilder& buffer) {

231 didReceiveData(*buffer.~~get~~());

231 didReceiveData(buffer.copy()->makeContiguous());

        if (m_didFinish)

            didFinish();

    }, [this](Ref<FormData>& formData) {

Source/WebKit/WebProcess/Storage/WebServiceWorkerFetchTaskClient.h

@@private:

    void didReceiveResponse(const WebCore::ResourceResponse&) final;

    void didReceiveRedirection(const WebCore::ResourceResponse&) final;

53 void didReceiveData(~~Ref<~~WebCore::~~Fragmented~~SharedBuffer>&&) final;

53 void didReceiveData(const WebCore::SharedBuffer&) final;

    void didReceiveFormDataAndFinish(Ref<WebCore::FormData>&&) final;

    void didFail(const WebCore::ResourceError&) final;

    void didFinish() final;

@@private:

    void convertFetchToDownload() final;

    void cleanup();

63

64 void didReceiveBlobChunk(const ~~uint8_t* data, size_t~~);

63

64 void didReceiveBlobChunk(const WebCore::SharedBuffer&);

    void didFinishBlobLoading();

    struct BlobLoader final : WebCore::FetchLoaderClient {

@@private:

        // FetchLoaderClient API

        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); }

        void didFail(const WebCore::ResourceError& error) final { client->didFail(error); }

        void didSucceed() final { client->didFinishBlobLoading(); }

Source/WebKit/WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp

@@void WebFrameLoaderClient::didReplaceMultipartContent()

    webPage->didReplaceMultipartContent(m_frame);

}

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);

    // If the document is a stand-alone media document, now is the right time to cancel the WebKit load.

    // FIXME: This code should be shared across all ports. <http://webkit.org/b/48762>.

@@void WebFrameLoaderClient::committedLoad(DocumentLoader* loader, const uint8_t*

            return;

        m_hasSentResponseToPluginView = true;

    }

1180 m_pluginView->manualLoadDidReceiveData(data~~, length~~);

1180 m_pluginView->manualLoadDidReceiveData(data);

}

void WebFrameLoaderClient::finishedLoading(DocumentLoader* loader)

Source/WebKit/WebProcess/WebCoreSupport/WebFrameLoaderClient.h

@@private:

    void willReplaceMultipartContent() final;

    void didReplaceMultipartContent() final;

155 void committedLoad(WebCore::DocumentLoader*, const ~~uint8_t*, int~~) final;

155 void committedLoad(WebCore::DocumentLoader*, const WebCore::SharedBuffer&) final;

    void finishedLoading(WebCore::DocumentLoader*) final;

    void updateGlobalHistory() final;

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

@@WebPreviewLoaderClient::WebPreviewLoaderClient(const String& fileName, const Str

WebPreviewLoaderClient::~WebPreviewLoaderClient() = default;

52 void WebPreviewLoaderClient::didReceive~~Buffer~~(const ~~Fragmented~~SharedBuffer& buffer)

52void WebPreviewLoaderClient::didReceiveData(const SharedBuffer& buffer)

{

    auto webPage = WebProcess::singleton().webPage(m_pageID);

    if (!webPage)

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

@@public:

private:

    WebPreviewLoaderClient(const String& fileName, const String& uti, WebCore::PageIdentifier);

49 void didReceive~~Buffer~~(const WebCore::~~Fragmented~~SharedBuffer&) override;

49 void didReceiveData(const WebCore::SharedBuffer&) override;

    void didFinishLoading() override;

    void didFail() override;

    bool supportsPasswordEntry() const override { return true; }

Source/WebKit/WebProcess/WebPage/WebPage.cpp

@@void WebPage::urlSchemeTaskDidReceiveResponse(WebURLSchemeHandlerIdentifier hand

    handler->taskDidReceiveResponse(taskIdentifier, response);

}

7060 void WebPage::urlSchemeTaskDidReceiveData(WebURLSchemeHandlerIdentifier handlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, const IPC::D~~ataR~~efer~~ence~~& data)

7060void WebPage::urlSchemeTaskDidReceiveData(WebURLSchemeHandlerIdentifier handlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, const IPC::SharedBufferCopy& data)

{

    auto* handler = m_identifierToURLSchemeHandlerProxyMap.get(handlerIdentifier);

    ASSERT(handler);

7065 handler->taskDidReceiveData(taskIdentifier, data.~~siz~~e~~(),~~ data.d~~ata~~());

7065 handler->taskDidReceiveData(taskIdentifier, data.buffer() ? *data.buffer() : SharedBuffer::create().get());

}

void WebPage::urlSchemeTaskDidComplete(WebURLSchemeHandlerIdentifier handlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, const ResourceError& error)

Source/WebKit/WebProcess/WebPage/WebPage.h

@@namespace IPC {

class Connection;

class Decoder;

class FormDataReference;

187class SharedBufferCopy;

}

namespace WebCore {

@@private:

    void urlSchemeTaskWillPerformRedirection(WebURLSchemeHandlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, CompletionHandler<void(WebCore::ResourceRequest&&)>&&);

    void urlSchemeTaskDidPerformRedirection(WebURLSchemeHandlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, WebCore::ResourceResponse&&, WebCore::ResourceRequest&&);

    void urlSchemeTaskDidReceiveResponse(WebURLSchemeHandlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, const WebCore::ResourceResponse&);

1899 void urlSchemeTaskDidReceiveData(WebURLSchemeHandlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, const IPC::D~~ataR~~efer~~ence~~&);

1900 void urlSchemeTaskDidReceiveData(WebURLSchemeHandlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, const IPC::SharedBufferCopy&);

    void urlSchemeTaskDidComplete(WebURLSchemeHandlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, const WebCore::ResourceError&);

    void setIsTakingSnapshotsForApplicationSuspension(bool);

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

@@GenerateSyntheticEditingCommand(enum:uint8_t WebKit::SyntheticEditingCommandType

    URLSchemeTaskWillPerformRedirection(WebKit::WebURLSchemeHandlerIdentifier handlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, WebCore::ResourceResponse response, WebCore::ResourceRequest proposedRequest) -> (WebCore::ResourceRequest actualRequest) Async

    URLSchemeTaskDidPerformRedirection(WebKit::WebURLSchemeHandlerIdentifier handlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, WebCore::ResourceResponse response, WebCore::ResourceRequest proposedRequest)

    URLSchemeTaskDidReceiveResponse(WebKit::WebURLSchemeHandlerIdentifier handlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, WebCore::ResourceResponse response)

567 URLSchemeTaskDidReceiveData(WebKit::WebURLSchemeHandlerIdentifier handlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, IPC::SharedBuffer~~DataReference~~ data)

567 URLSchemeTaskDidReceiveData(WebKit::WebURLSchemeHandlerIdentifier handlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, IPC::SharedBufferCopy data)

    URLSchemeTaskDidComplete(WebKit::WebURLSchemeHandlerIdentifier handlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, WebCore::ResourceError error)

    SetIsSuspended(bool suspended)

Source/WebKit/WebProcess/WebPage/WebURLSchemeHandlerProxy.cpp

@@void WebURLSchemeHandlerProxy::taskDidReceiveResponse(WebCore::ResourceLoaderIde

    task->didReceiveResponse(response);

}

99 void WebURLSchemeHandlerProxy::taskDidReceiveData(WebCore::ResourceLoaderIdentifier taskIdentifier, ~~size_t size,~~ const uint8_t* data)

99void WebURLSchemeHandlerProxy::taskDidReceiveData(WebCore::ResourceLoaderIdentifier taskIdentifier, const SharedBuffer& data)

{

    auto* task = m_tasks.get(taskIdentifier);

    if (!task)

        return;

105 task->didReceiveData(~~size,~~ data);

105 task->didReceiveData(data);

}

void WebURLSchemeHandlerProxy::taskDidComplete(WebCore::ResourceLoaderIdentifier taskIdentifier, const ResourceError& error)

Source/WebKit/WebProcess/WebPage/WebURLSchemeHandlerProxy.h

@@class ResourceError;

class ResourceLoader;

class ResourceResponse;

class ResourceRequest;

38class SharedBuffer;

}

namespace WebKit {

@@public:

    void taskDidPerformRedirection(WebCore::ResourceLoaderIdentifier, WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, CompletionHandler<void(WebCore::ResourceRequest&&)>&&);

    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&);

    void taskDidComplete(WebCore::ResourceLoaderIdentifier, const WebCore::ResourceError&);

    void taskDidStopLoading(WebURLSchemeTaskProxy&);

Source/WebKit/WebProcess/WebPage/WebURLSchemeTaskProxy.cpp

@@void WebURLSchemeTaskProxy::didReceiveResponse(const ResourceResponse& response)

    });

}

143 void WebURLSchemeTaskProxy::didReceiveData(~~size_t size,~~ const uint8_t* data)

143void WebURLSchemeTaskProxy::didReceiveData(const WebCore::SharedBuffer& data)

{

    if (!hasLoader())

        return;

    if (m_waitingForCompletionHandler) {

        WEBURLSCHEMETASKPROXY_RELEASE_LOG("didReceiveData: Received data during response processing, queuing it.");

150 queueTask([this, protectedThis = Ref { *this }, data~~Vector~~ = V~~ector~~ { data~~, size~~ }] {

151 didReceiveData(data~~Vector.size(), dataVector.data()~~);

150 queueTask([this, protectedThis = Ref { *this }, data = Ref { data }] {

151 didReceiveData(data);

        });

        return;

    }

    Ref protectedThis { *this };

157 m_coreLoader->didReceiveData(data~~, size~~, 0, DataPayloadType::DataPayloadBytes);

157 m_coreLoader->didReceiveData(data, 0, DataPayloadType::DataPayloadBytes);

    processNextPendingTask();

}

Source/WebKit/WebProcess/WebPage/WebURLSchemeTaskProxy.h

@@namespace WebCore {

class ResourceError;

class ResourceLoader;

class ResourceResponse;

37class SharedBuffer;

}

namespace WebKit {

@@public:

    void didPerformRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, CompletionHandler<void(WebCore::ResourceRequest&&)>&&);

    void didReceiveResponse(const WebCore::ResourceResponse&);

58 void didReceiveData(~~size_t,~~ const ~~uint8_t* data~~);

59 void didReceiveData(const WebCore::SharedBuffer&);

    void didComplete(const WebCore::ResourceError&);

    WebCore::ResourceLoaderIdentifier identifier() const { return m_identifier; }

Source/WebKit/WebProcess/cocoa/WebProcessCocoa.mm

@@RetainPtr<CFDataRef> WebProcess::sourceApplicationAuditData() const

void WebProcess::initializeSandbox(const AuxiliaryProcessInitializationParameters& parameters, SandboxInitializationParameters& sandboxParameters)

{

696 return;

#if PLATFORM(MAC) || PLATFORM(MACCATALYST)

    // Need to override the default, because service has a different bundle ID.

    auto webKitBundle = [NSBundle bundleWithIdentifier:@"com.apple.WebKit"];

Source/WebKitLegacy/WebCoreSupport/PingHandle.h

#include <WebCore/ResourceHandleClient.h>

#include <WebCore/ResourceRequest.h>

#include <WebCore/ResourceResponse.h>

33#include <WebCore/SharedBuffer.h>

#include <WebCore/Timer.h>

#include <wtf/CompletionHandler.h>

@@private:

        completionHandler();

        pingLoadComplete({ }, response);

    }

76 void didReceive~~Buffer~~(WebCore::ResourceHandle*, ~~Ref<~~WebCore::~~Fragmented~~SharedBuffer>&&, int) final { pingLoadComplete(); }

77 void didReceiveData(WebCore::ResourceHandle*, const WebCore::SharedBuffer&, int) final { pingLoadComplete(); }

    void didFinishLoading(WebCore::ResourceHandle*, const WebCore::NetworkLoadMetrics&) final { pingLoadComplete(); }

    void didFail(WebCore::ResourceHandle*, const WebCore::ResourceError& error) final { pingLoadComplete(error); }

    bool shouldUseCredentialStorage(WebCore::ResourceHandle*) final { return m_shouldUseCredentialStorage; }

Source/WebKitLegacy/mac/WebCoreSupport/WebFrameLoaderClient.h

@@class SessionID;

namespace WebCore {

class AuthenticationChallenge;

class CachedFrame;

51class FragmentedSharedBuffer;

class HistoryItem;

class ProtectionSpace;

class ResourceLoader;

class ResourceRequest;

56class SharedBuffer;

}

class WebFrameLoaderClient : public WebCore::FrameLoaderClient, public CanMakeWeakPtr<WebFrameLoaderClient> {

@@private:

    void willReplaceMultipartContent() final { }

    void didReplaceMultipartContent() final;

154 void committedLoad(WebCore::DocumentLoader*, const ~~uint8_t*, int~~) final;

156 void committedLoad(WebCore::DocumentLoader*, const WebCore::SharedBuffer&) final;

    void finishedLoading(WebCore::DocumentLoader*) final;

    void updateGlobalHistory() final;

    void updateGlobalHistoryRedirectLinks() final;

Source/WebKitLegacy/mac/WebCoreSupport/WebFrameLoaderClient.mm

@@void WebFrameLoaderClient::didReplaceMultipartContent()

#endif

}

995 void WebFrameLoaderClient::committedLoad(WebCore::DocumentLoader* loader, const uint8_t* data~~, int length~~)

995void WebFrameLoaderClient::committedLoad(WebCore::DocumentLoader* loader, const WebCore::SharedBuffer& data)

996996{

997 auto nsData = adoptNS([[NSData alloc] initWithBytesNoCopy:(void*)data length:length freeWhenDone:NO]);

998 [dataSource(loader) _receivedData:nsData.get()];

997 [dataSource(loader) _receivedData:data.createNSData().get()];

}

void WebFrameLoaderClient::finishedLoading(WebCore::DocumentLoader* loader)

@@RefPtr<WebCore::LegacyPreviewLoaderClient> WebFrameLoaderClient::createPreviewLo

        RetainPtr<NSString> m_filePath;

        RetainPtr<NSFileHandle> m_fileHandle;

2015 void didReceive~~Buffer~~(const WebCore::~~Fragmented~~SharedBuffer& buffer) override

2014 void didReceiveData(const WebCore::SharedBuffer& buffer) override

        {

            auto dataArray = buffer.createNSDataArray();

            for (NSData *data in dataArray.get())

Source/WebKitLegacy/mac/WebView/WebFrame.mm

@@- (void)_commitData:(NSData *)data

    auto* document = _private->coreFrame->document();

    document->setShouldCreateRenderers(_private->shouldCreateRenderers);

980 _private->coreFrame->loader().documentLoader()->commitData(~~(const uint8_t*)[~~data ~~bytes], [data length]~~);

980 _private->coreFrame->loader().documentLoader()->commitData(WebCore::SharedBuffer::create(data));

}

@end

Source/WebKitLegacy/win/WebCoreSupport/WebFrameLoaderClient.cpp

@@void WebFrameLoaderClient::didChangeTitle(DocumentLoader*)

    notImplemented();

}

644 void WebFrameLoaderClient::committedLoad(DocumentLoader* loader, const uint8_t* data~~, int length~~)

644void WebFrameLoaderClient::committedLoad(DocumentLoader* loader, const SharedBuffer& data)

645645{

646 loader->commitData(data~~, length~~);

646 loader->commitData(data);

    // If the document is a stand-alone media document, now is the right time to cancel the WebKit load.

    // FIXME: This code should be shared across all ports. <http://webkit.org/b/48762>.

Source/WebKitLegacy/win/WebCoreSupport/WebFrameLoaderClient.h

@@public:

    void startDownload(const WebCore::ResourceRequest&, const String& suggestedName = String()) override;

115 void committedLoad(WebCore::DocumentLoader*, const ~~uint8_t*, int~~) override;

115 void committedLoad(WebCore::DocumentLoader*, const WebCore::SharedBuffer&) override;

    void finishedLoading(WebCore::DocumentLoader*) override;

    void willChangeTitle(WebCore::DocumentLoader*) override;

Tools/ChangeLog

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

        make SharedBuffer::copy() return a contiguous SharedBuffer

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

        rdar://problem/86829527

        Reviewed by NOBODY (OOPS!).

        * TestWebKitAPI/Tests/WebCore/SharedBuffer.cpp:

        (TestWebKitAPI::TEST_F):

2021-12-26  Carlos Garcia Campos  <cgarcia@igalia.com>

        [GTK][a11y] Stop setting manages-descendants on web process root object with ATSPI

Tools/TestWebKitAPI/Tests/WebCore/SharedBuffer.cpp

@@TEST_F(FragmentedSharedBufferTest, read)

    check(builder.take());

}

TEST_F(FragmentedSharedBufferTest, copyIsContiguous)

{

    EXPECT_TRUE(SharedBuffer::create()->copy()->isContiguous());

    EXPECT_FALSE(FragmentedSharedBuffer::create()->copy()->isContiguous());

    const char* const simpleText = "This is a simple test.";

    EXPECT_TRUE(SharedBuffer::create(simpleText, strlen(simpleText))->copy()->isContiguous());

    EXPECT_FALSE(FragmentedSharedBuffer::create(simpleText, strlen(simpleText))->copy()->isContiguous());

}

#if ENABLE(MHTML)

// SharedBufferChunkReader unit-tests -------------------------------------

template< typename T, size_t N >