Source/WebCore/Modules/fetch/FetchResponse.cpp - WebKit - Git at Google

 /*
  * Copyright (C) 2016 Canon Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted, provided that the following conditions
  * are required to be met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
  *     documentation and/or other materials provided with the distribution.
  * 3.  Neither the name of Canon Inc. nor the names of
  *     its contributors may be used to endorse or promote products derived
  *     from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY CANON 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 PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL CANON INC. AND ITS CONTRIBUTORS BE LIABLE FOR
  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include "config.h"
 #include "FetchResponse.h"

 #include "FetchRequest.h"
 #include "HTTPParsers.h"
 #include "JSBlob.h"
 #include "MIMETypeRegistry.h"
 #include "ReadableStreamSink.h"
 #include "ResourceError.h"
 #include "ScriptExecutionContext.h"

 namespace WebCore {

 // https://fetch.spec.whatwg.org/#null-body-status
 static inline bool isNullBodyStatus(int status)
 {
     return status == 101 || status == 204 || status == 205 || status == 304;
 }

 Ref<FetchResponse> FetchResponse::create(ScriptExecutionContext& context, std::optional<FetchBody>&& body, FetchHeaders::Guard guard, ResourceResponse&& response)
 {
     bool isSynthetic = response.type() == ResourceResponse::Type::Default || response.type() == ResourceResponse::Type::Error;
     bool isOpaque = response.tainting() == ResourceResponse::Tainting::Opaque;
     auto headers = isOpaque ? FetchHeaders::create(guard) : FetchHeaders::create(guard, HTTPHeaderMap { response.httpHeaderFields() });

     auto fetchResponse = adoptRef(*new FetchResponse(context, WTFMove(body), WTFMove(headers), WTFMove(response)));
     if (!isSynthetic)
         fetchResponse->m_filteredResponse = ResourceResponseBase::filter(fetchResponse->m_internalResponse);
     if (isOpaque)
         fetchResponse->setBodyAsOpaque();
     return fetchResponse;
 }

 ExceptionOr<Ref<FetchResponse>> FetchResponse::create(ScriptExecutionContext& context, std::optional<FetchBody::Init>&& body, Init&& init)
 {
     // 1. If init’s status member is not in the range 200 to 599, inclusive, then throw a RangeError.
     if (init.status < 200  || init.status > 599)
         return Exception { RangeError, ASCIILiteral("Status must be between 200 and 599") };

     // 2. If init’s statusText member does not match the reason-phrase token production, then throw a TypeError.
     if (!isValidReasonPhrase(init.statusText))
         return Exception { TypeError, ASCIILiteral("Status text must be a valid reason-phrase.") };

     // 3. Let r be a new Response object associated with a new response.
     // NOTE: Creation of the Response object is delayed until all potential exceptional cases are handled.

     // 4. Set r’s headers to a new Headers object, whose header list is r’s response’s header list, and guard is "response".
     auto headers = FetchHeaders::create(FetchHeaders::Guard::Response);

     // 5. Set r’s response’s status to init’s status member.
     auto status = init.status;

     // 6. Set r’s response’s status message to init’s statusText member.
     auto statusText = init.statusText;

     // 7. If init’s headers member is present, then fill r’s headers with init’s headers member.
     if (init.headers) {
         auto result = headers->fill(*init.headers);
         if (result.hasException())
             return result.releaseException();
     }

     std::optional<FetchBody> extractedBody;

     // 8. If body is non-null, run these substeps:
     if (body) {
         // 8.1 If init’s status member is a null body status, then throw a TypeError.
         //     (NOTE: 101 is included in null body status due to its use elsewhere. It does not affect this step.)
         if (isNullBodyStatus(init.status))
             return Exception { TypeError, ASCIILiteral("Response cannot have a body with the given status.") };

         // 8.2 Let Content-Type be null.
         String contentType;

         // 8.3 Set r’s response’s body and Content-Type to the result of extracting body.
         extractedBody = FetchBody::extract(context, WTFMove(*body), contentType);

         // 8.4 If Content-Type is non-null and r’s response’s header list does not contain `Content-Type`, then append
         //     `Content-Type`/Content-Type to r’s response’s header list.
         if (!contentType.isNull() && !headers->fastHas(HTTPHeaderName::ContentType))
             headers->fastSet(HTTPHeaderName::ContentType, contentType);
     }

     // 9. Set r’s MIME type to the result of extracting a MIME type from r’s response’s header list.
     auto contentType = headers->fastGet(HTTPHeaderName::ContentType);

     // 10. Set r’s response’s HTTPS state to current settings object’s HTTPS state.
     // FIXME: Implement.

     // 11. Resolve r’s trailer promise with a new Headers object whose guard is "immutable".
     // FIXME: Implement.

     // 12. Return r.
     auto r = adoptRef(*new FetchResponse(context, WTFMove(extractedBody), WTFMove(headers), { }));

     r->m_contentType = contentType;
     auto mimeType = extractMIMETypeFromMediaType(contentType);
     r->m_internalResponse.setMimeType(mimeType.isEmpty() ? defaultMIMEType() : mimeType);
     r->m_internalResponse.setTextEncodingName(extractCharsetFromMediaType(contentType));

     r->m_internalResponse.setHTTPStatusCode(status);
     r->m_internalResponse.setHTTPStatusText(statusText);

     return WTFMove(r);
 }

 Ref<FetchResponse> FetchResponse::error(ScriptExecutionContext& context)
 {
     auto response = adoptRef(*new FetchResponse(context, { }, FetchHeaders::create(FetchHeaders::Guard::Immutable), { }));
     response->m_internalResponse.setType(Type::Error);
     return response;
 }

 ExceptionOr<Ref<FetchResponse>> FetchResponse::redirect(ScriptExecutionContext& context, const String& url, int status)
 {
     // FIXME: Tighten the URL parsing algorithm according https://url.spec.whatwg.org/#concept-url-parser.
     URL requestURL = context.completeURL(url);
     if (!requestURL.isValid() || !requestURL.user().isEmpty() || !requestURL.pass().isEmpty())
         return Exception { TypeError };
     if (!ResourceResponse::isRedirectionStatusCode(status))
         return Exception { RangeError };
     auto redirectResponse = adoptRef(*new FetchResponse(context, { }, FetchHeaders::create(FetchHeaders::Guard::Immutable), { }));
     redirectResponse->m_internalResponse.setHTTPStatusCode(status);
     redirectResponse->m_internalResponse.setHTTPHeaderField(HTTPHeaderName::Location, requestURL.string());
     redirectResponse->m_headers->fastSet(HTTPHeaderName::Location, requestURL.string());
     return WTFMove(redirectResponse);
 }

 FetchResponse::FetchResponse(ScriptExecutionContext& context, std::optional<FetchBody>&& body, Ref<FetchHeaders>&& headers, ResourceResponse&& response)
     : FetchBodyOwner(context, WTFMove(body), WTFMove(headers))
     , m_internalResponse(WTFMove(response))
 {
 }

 ExceptionOr<Ref<FetchResponse>> FetchResponse::clone(ScriptExecutionContext& context)
 {
     if (isDisturbedOrLocked())
         return Exception { TypeError };

     ASSERT(scriptExecutionContext());

     // If loading, let's create a stream so that data is teed on both clones.
     if (isLoading() && !m_readableStreamSource)
         createReadableStream(*context.execState());

     // Synthetic responses do not store headers in m_internalResponse.
     if (m_internalResponse.type() == ResourceResponse::Type::Default)
         m_internalResponse.setHTTPHeaderFields(HTTPHeaderMap { headers().internalHeaders() });

     auto clone = FetchResponse::create(context, std::nullopt, headers().guard(), ResourceResponse { m_internalResponse });
     clone->m_loadingError = m_loadingError;
     clone->cloneBody(*this);
     clone->m_opaqueLoadIdentifier = m_opaqueLoadIdentifier;
     clone->m_bodySizeWithPadding = m_bodySizeWithPadding;
     return WTFMove(clone);
 }

 void FetchResponse::fetch(ScriptExecutionContext& context, FetchRequest& request, NotificationCallback&& responseCallback)
 {
     if (request.hasReadableStreamBody()) {
         if (responseCallback)
             responseCallback(Exception { NotSupportedError, "ReadableStream uploading is not supported" });
         return;
     }
     auto response = adoptRef(*new FetchResponse(context, FetchBody { }, FetchHeaders::create(FetchHeaders::Guard::Immutable), { }));

     response->body().consumer().setAsLoading();

     response->m_bodyLoader.emplace(response.get(), WTFMove(responseCallback));
     if (!response->m_bodyLoader->start(context, request))
         response->m_bodyLoader = std::nullopt;
 }

 const String& FetchResponse::url() const
 {
     if (m_responseURL.isNull()) {
         URL url = m_internalResponse.url();
         url.removeFragmentIdentifier();
         m_responseURL = url.string();
     }
     return m_responseURL;
 }

 const ResourceResponse& FetchResponse::filteredResponse() const
 {
     if (m_filteredResponse)
         return m_filteredResponse.value();
     return m_internalResponse;
 }

 void FetchResponse::BodyLoader::didSucceed()
 {
     ASSERT(m_response.hasPendingActivity());
     m_response.m_body->loadingSucceeded();

 #if ENABLE(STREAMS_API)
     if (m_response.m_readableStreamSource && !m_response.body().consumer().hasData())
         m_response.closeStream();
 #endif
     if (auto consumeDataCallback = WTFMove(m_consumeDataCallback))
         consumeDataCallback(nullptr);

     if (m_loader->isStarted()) {
         Ref<FetchResponse> protector(m_response);
         m_response.m_bodyLoader = std::nullopt;
     }
 }

 void FetchResponse::BodyLoader::didFail(const ResourceError& error)
 {
     ASSERT(m_response.hasPendingActivity());

     m_response.m_loadingError = error;

     if (auto responseCallback = WTFMove(m_responseCallback))
         responseCallback(Exception { TypeError, error.localizedDescription() });

     if (auto consumeDataCallback = WTFMove(m_consumeDataCallback))
         consumeDataCallback(Exception { TypeError, error.localizedDescription() });

 #if ENABLE(STREAMS_API)
     if (m_response.m_readableStreamSource) {
         if (!m_response.m_readableStreamSource->isCancelling())
             m_response.m_readableStreamSource->error(ASCIILiteral("Loading failed"));
         m_response.m_readableStreamSource = nullptr;
     }
 #endif

     // Check whether didFail is called as part of FetchLoader::start.
     if (m_loader->isStarted()) {
         Ref<FetchResponse> protector(m_response);
         m_response.m_bodyLoader = std::nullopt;
     }
 }

 FetchResponse::BodyLoader::BodyLoader(FetchResponse& response, NotificationCallback&& responseCallback)
     : m_response(response)
     , m_responseCallback(WTFMove(responseCallback))
 {
     m_response.setPendingActivity(&m_response);
 }

 FetchResponse::BodyLoader::~BodyLoader()
 {
     m_response.unsetPendingActivity(&m_response);
 }

 static uint64_t nextOpaqueLoadIdentifier { 0 };
 void FetchResponse::BodyLoader::didReceiveResponse(const ResourceResponse& resourceResponse)
 {
     m_response.m_filteredResponse = ResourceResponseBase::filter(resourceResponse);
     m_response.m_internalResponse = resourceResponse;
     m_response.m_internalResponse.setType(m_response.m_filteredResponse->type());
     if (resourceResponse.tainting() == ResourceResponse::Tainting::Opaque) {
         m_response.m_opaqueLoadIdentifier = ++nextOpaqueLoadIdentifier;
         m_response.setBodyAsOpaque();
     }

     m_response.m_headers->filterAndFill(m_response.m_filteredResponse->httpHeaderFields(), FetchHeaders::Guard::Response);
     m_response.updateContentType();

     if (auto responseCallback = WTFMove(m_responseCallback))
         responseCallback(m_response);
 }

 void FetchResponse::BodyLoader::didReceiveData(const char* data, size_t size)
 {
 #if ENABLE(STREAMS_API)
     ASSERT(m_response.m_readableStreamSource || m_consumeDataCallback);
 #else
     ASSERT(m_consumeDataCallback);
 #endif

     if (m_consumeDataCallback) {
         ReadableStreamChunk chunk { reinterpret_cast<const uint8_t*>(data), size };
         m_consumeDataCallback(&chunk);
         return;
     }

 #if ENABLE(STREAMS_API)
     auto& source = *m_response.m_readableStreamSource;

     if (!source.isPulling()) {
         m_response.body().consumer().append(data, size);
         return;
     }

     if (m_response.body().consumer().hasData() && !source.enqueue(m_response.body().consumer().takeAsArrayBuffer())) {
         stop();
         return;
     }
     if (!source.enqueue(ArrayBuffer::tryCreate(data, size))) {
         stop();
         return;
     }
     source.resolvePullPromise();
 #else
     UNUSED_PARAM(data);
     UNUSED_PARAM(size);
 #endif
 }

 bool FetchResponse::BodyLoader::start(ScriptExecutionContext& context, const FetchRequest& request)
 {
     m_loader = std::make_unique<FetchLoader>(*this, &m_response.m_body->consumer());
     m_loader->start(context, request);
     return m_loader->isStarted();
 }

 void FetchResponse::BodyLoader::stop()
 {
     m_responseCallback = { };
     if (m_loader)
         m_loader->stop();
 }

 void FetchResponse::BodyLoader::consumeDataByChunk(ConsumeDataByChunkCallback&& consumeDataCallback)
 {
     ASSERT(!m_consumeDataCallback);
     m_consumeDataCallback = WTFMove(consumeDataCallback);
     auto data = m_loader->startStreaming();
     if (!data)
         return;

     ReadableStreamChunk chunk { reinterpret_cast<const uint8_t*>(data->data()), data->size() };
     m_consumeDataCallback(&chunk);
 }

 FetchResponse::ResponseData FetchResponse::consumeBody()
 {
     ASSERT(!isBodyReceivedByChunk());

     if (isBodyNull())
         return nullptr;

     ASSERT(!m_isDisturbed);
     m_isDisturbed = true;

     return body().take();
 }

 void FetchResponse::consumeBodyReceivedByChunk(ConsumeDataByChunkCallback&& callback)
 {
     ASSERT(isBodyReceivedByChunk());
     ASSERT(!isDisturbed());
     m_isDisturbed = true;

     if (hasReadableStreamBody()) {
         m_body->consumer().extract(*m_body->readableStream(), WTFMove(callback));
         return;
     }

     ASSERT(isLoading());
     m_bodyLoader->consumeDataByChunk(WTFMove(callback));
 }

 void FetchResponse::setBodyData(ResponseData&& data, uint64_t bodySizeWithPadding)
 {
     m_bodySizeWithPadding = bodySizeWithPadding;
     WTF::switchOn(data,
         [this](Ref<FormData>& formData) {
             if (isBodyNull())
                 setBody({ });
             body().setAsFormData(WTFMove(formData));
         },
         [this](Ref<SharedBuffer>& buffer) {
             if (isBodyNull())
                 setBody({ });
             body().consumer().setData(WTFMove(buffer));
         },
         [](std::nullptr_t&) {
         }
     );
 }

 #if ENABLE(STREAMS_API)
 void FetchResponse::consumeChunk(Ref<JSC::Uint8Array>&& chunk)
 {
     body().consumer().append(chunk->data(), chunk->byteLength());
 }

 void FetchResponse::consumeBodyAsStream()
 {
     ASSERT(m_readableStreamSource);
     if (!isLoading()) {
         FetchBodyOwner::consumeBodyAsStream();
         return;
     }

     ASSERT(m_bodyLoader);

     auto data = m_bodyLoader->startStreaming();
     if (data) {
         if (!m_readableStreamSource->enqueue(data->tryCreateArrayBuffer())) {
             stop();
             return;
         }
         m_readableStreamSource->resolvePullPromise();
     }
 }

 void FetchResponse::closeStream()
 {
     ASSERT(m_readableStreamSource);
     m_readableStreamSource->close();
     m_readableStreamSource = nullptr;
 }

 void FetchResponse::feedStream()
 {
     ASSERT(m_readableStreamSource);
     bool shouldCloseStream = !m_bodyLoader;

     if (body().consumer().hasData()) {
         if (!m_readableStreamSource->enqueue(body().consumer().takeAsArrayBuffer())) {
             stop();
             return;
         }
         if (!shouldCloseStream) {
             m_readableStreamSource->resolvePullPromise();
             return;
         }
     } else if (!shouldCloseStream)
         return;

     closeStream();
 }

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

 void FetchResponse::cancel()
 {
     m_isDisturbed = true;
     stop();
 }

 #endif

 void FetchResponse::stop()
 {
     RefPtr<FetchResponse> protectedThis(this);
     FetchBodyOwner::stop();
     if (m_bodyLoader) {
         m_bodyLoader->stop();
         m_bodyLoader = std::nullopt;
     }
 }

 const char* FetchResponse::activeDOMObjectName() const
 {
     return "Response";
 }

 bool FetchResponse::canSuspendForDocumentSuspension() const
 {
     // FIXME: We can probably do the same strategy as XHR.
     return !isActive();
 }

 ResourceResponse FetchResponse::resourceResponse() const
 {
     auto response = m_internalResponse;

     if (headers().guard() != FetchHeaders::Guard::Immutable) {
         // FIXME: Add a setHTTPHeaderFields on ResourceResponseBase.
         for (auto& header : headers().internalHeaders())
             response.setHTTPHeaderField(header.key, header.value);
     }

     return response;
 }

 } // namespace WebCore
	/*
	* Copyright (C) 2016 Canon Inc.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted, provided that the following conditions
	* are required to be met:
	*
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	* 3. Neither the name of Canon Inc. nor the names of
	* its contributors may be used to endorse or promote products derived
	* from this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY CANON 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 PURPOSE ARE
	* DISCLAIMED. IN NO EVENT SHALL CANON INC. AND ITS CONTRIBUTORS BE LIABLE FOR
	* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include "config.h"
	#include "FetchResponse.h"

	#include "FetchRequest.h"
	#include "HTTPParsers.h"
	#include "JSBlob.h"
	#include "MIMETypeRegistry.h"
	#include "ReadableStreamSink.h"
	#include "ResourceError.h"
	#include "ScriptExecutionContext.h"

	namespace WebCore {

	// https://fetch.spec.whatwg.org/#null-body-status
	static inline bool isNullBodyStatus(int status)
	{
	return status == 101 \|\| status == 204 \|\| status == 205 \|\| status == 304;
	}

	Ref<FetchResponse> FetchResponse::create(ScriptExecutionContext& context, std::optional<FetchBody>&& body, FetchHeaders::Guard guard, ResourceResponse&& response)
	{
	bool isSynthetic = response.type() == ResourceResponse::Type::Default \|\| response.type() == ResourceResponse::Type::Error;
	bool isOpaque = response.tainting() == ResourceResponse::Tainting::Opaque;
	auto headers = isOpaque ? FetchHeaders::create(guard) : FetchHeaders::create(guard, HTTPHeaderMap { response.httpHeaderFields() });

	auto fetchResponse = adoptRef(*new FetchResponse(context, WTFMove(body), WTFMove(headers), WTFMove(response)));
	if (!isSynthetic)
	fetchResponse->m_filteredResponse = ResourceResponseBase::filter(fetchResponse->m_internalResponse);
	if (isOpaque)
	fetchResponse->setBodyAsOpaque();
	return fetchResponse;
	}

	ExceptionOr<Ref<FetchResponse>> FetchResponse::create(ScriptExecutionContext& context, std::optional<FetchBody::Init>&& body, Init&& init)
	{
	// 1. If init’s status member is not in the range 200 to 599, inclusive, then throw a RangeError.
	if (init.status < 200 \|\| init.status > 599)
	return Exception { RangeError, ASCIILiteral("Status must be between 200 and 599") };

	// 2. If init’s statusText member does not match the reason-phrase token production, then throw a TypeError.
	if (!isValidReasonPhrase(init.statusText))
	return Exception { TypeError, ASCIILiteral("Status text must be a valid reason-phrase.") };

	// 3. Let r be a new Response object associated with a new response.
	// NOTE: Creation of the Response object is delayed until all potential exceptional cases are handled.

	// 4. Set r’s headers to a new Headers object, whose header list is r’s response’s header list, and guard is "response".
	auto headers = FetchHeaders::create(FetchHeaders::Guard::Response);

	// 5. Set r’s response’s status to init’s status member.
	auto status = init.status;

	// 6. Set r’s response’s status message to init’s statusText member.
	auto statusText = init.statusText;

	// 7. If init’s headers member is present, then fill r’s headers with init’s headers member.
	if (init.headers) {
	auto result = headers->fill(*init.headers);
	if (result.hasException())
	return result.releaseException();
	}

	std::optional<FetchBody> extractedBody;

	// 8. If body is non-null, run these substeps:
	if (body) {
	// 8.1 If init’s status member is a null body status, then throw a TypeError.
	// (NOTE: 101 is included in null body status due to its use elsewhere. It does not affect this step.)
	if (isNullBodyStatus(init.status))
	return Exception { TypeError, ASCIILiteral("Response cannot have a body with the given status.") };

	// 8.2 Let Content-Type be null.
	String contentType;

	// 8.3 Set r’s response’s body and Content-Type to the result of extracting body.
	extractedBody = FetchBody::extract(context, WTFMove(*body), contentType);

	// 8.4 If Content-Type is non-null and r’s response’s header list does not contain `Content-Type`, then append
	// `Content-Type`/Content-Type to r’s response’s header list.
	if (!contentType.isNull() && !headers->fastHas(HTTPHeaderName::ContentType))
	headers->fastSet(HTTPHeaderName::ContentType, contentType);
	}

	// 9. Set r’s MIME type to the result of extracting a MIME type from r’s response’s header list.
	auto contentType = headers->fastGet(HTTPHeaderName::ContentType);

	// 10. Set r’s response’s HTTPS state to current settings object’s HTTPS state.
	// FIXME: Implement.

	// 11. Resolve r’s trailer promise with a new Headers object whose guard is "immutable".
	// FIXME: Implement.

	// 12. Return r.
	auto r = adoptRef(*new FetchResponse(context, WTFMove(extractedBody), WTFMove(headers), { }));

	r->m_contentType = contentType;
	auto mimeType = extractMIMETypeFromMediaType(contentType);
	r->m_internalResponse.setMimeType(mimeType.isEmpty() ? defaultMIMEType() : mimeType);
	r->m_internalResponse.setTextEncodingName(extractCharsetFromMediaType(contentType));

	r->m_internalResponse.setHTTPStatusCode(status);
	r->m_internalResponse.setHTTPStatusText(statusText);

	return WTFMove(r);
	}

	Ref<FetchResponse> FetchResponse::error(ScriptExecutionContext& context)
	{
	auto response = adoptRef(*new FetchResponse(context, { }, FetchHeaders::create(FetchHeaders::Guard::Immutable), { }));
	response->m_internalResponse.setType(Type::Error);
	return response;
	}

	ExceptionOr<Ref<FetchResponse>> FetchResponse::redirect(ScriptExecutionContext& context, const String& url, int status)
	{
	// FIXME: Tighten the URL parsing algorithm according https://url.spec.whatwg.org/#concept-url-parser.
	URL requestURL = context.completeURL(url);
	if (!requestURL.isValid() \|\| !requestURL.user().isEmpty() \|\| !requestURL.pass().isEmpty())
	return Exception { TypeError };
	if (!ResourceResponse::isRedirectionStatusCode(status))
	return Exception { RangeError };
	auto redirectResponse = adoptRef(*new FetchResponse(context, { }, FetchHeaders::create(FetchHeaders::Guard::Immutable), { }));
	redirectResponse->m_internalResponse.setHTTPStatusCode(status);
	redirectResponse->m_internalResponse.setHTTPHeaderField(HTTPHeaderName::Location, requestURL.string());
	redirectResponse->m_headers->fastSet(HTTPHeaderName::Location, requestURL.string());
	return WTFMove(redirectResponse);
	}

	FetchResponse::FetchResponse(ScriptExecutionContext& context, std::optional<FetchBody>&& body, Ref<FetchHeaders>&& headers, ResourceResponse&& response)
	: FetchBodyOwner(context, WTFMove(body), WTFMove(headers))
	, m_internalResponse(WTFMove(response))
	{
	}

	ExceptionOr<Ref<FetchResponse>> FetchResponse::clone(ScriptExecutionContext& context)
	{
	if (isDisturbedOrLocked())
	return Exception { TypeError };

	ASSERT(scriptExecutionContext());

	// If loading, let's create a stream so that data is teed on both clones.
	if (isLoading() && !m_readableStreamSource)
	createReadableStream(*context.execState());

	// Synthetic responses do not store headers in m_internalResponse.
	if (m_internalResponse.type() == ResourceResponse::Type::Default)
	m_internalResponse.setHTTPHeaderFields(HTTPHeaderMap { headers().internalHeaders() });

	auto clone = FetchResponse::create(context, std::nullopt, headers().guard(), ResourceResponse { m_internalResponse });
	clone->m_loadingError = m_loadingError;
	clone->cloneBody(*this);
	clone->m_opaqueLoadIdentifier = m_opaqueLoadIdentifier;
	clone->m_bodySizeWithPadding = m_bodySizeWithPadding;
	return WTFMove(clone);
	}

	void FetchResponse::fetch(ScriptExecutionContext& context, FetchRequest& request, NotificationCallback&& responseCallback)
	{
	if (request.hasReadableStreamBody()) {
	if (responseCallback)
	responseCallback(Exception { NotSupportedError, "ReadableStream uploading is not supported" });
	return;
	}
	auto response = adoptRef(*new FetchResponse(context, FetchBody { }, FetchHeaders::create(FetchHeaders::Guard::Immutable), { }));

	response->body().consumer().setAsLoading();

	response->m_bodyLoader.emplace(response.get(), WTFMove(responseCallback));
	if (!response->m_bodyLoader->start(context, request))
	response->m_bodyLoader = std::nullopt;
	}

	const String& FetchResponse::url() const
	{
	if (m_responseURL.isNull()) {
	URL url = m_internalResponse.url();
	url.removeFragmentIdentifier();
	m_responseURL = url.string();
	}
	return m_responseURL;
	}

	const ResourceResponse& FetchResponse::filteredResponse() const
	{
	if (m_filteredResponse)
	return m_filteredResponse.value();
	return m_internalResponse;
	}

	void FetchResponse::BodyLoader::didSucceed()
	{
	ASSERT(m_response.hasPendingActivity());
	m_response.m_body->loadingSucceeded();

	#if ENABLE(STREAMS_API)
	if (m_response.m_readableStreamSource && !m_response.body().consumer().hasData())
	m_response.closeStream();
	#endif
	if (auto consumeDataCallback = WTFMove(m_consumeDataCallback))
	consumeDataCallback(nullptr);

	if (m_loader->isStarted()) {
	Ref<FetchResponse> protector(m_response);
	m_response.m_bodyLoader = std::nullopt;
	}
	}

	void FetchResponse::BodyLoader::didFail(const ResourceError& error)
	{
	ASSERT(m_response.hasPendingActivity());

	m_response.m_loadingError = error;

	if (auto responseCallback = WTFMove(m_responseCallback))
	responseCallback(Exception { TypeError, error.localizedDescription() });

	if (auto consumeDataCallback = WTFMove(m_consumeDataCallback))
	consumeDataCallback(Exception { TypeError, error.localizedDescription() });

	#if ENABLE(STREAMS_API)
	if (m_response.m_readableStreamSource) {
	if (!m_response.m_readableStreamSource->isCancelling())
	m_response.m_readableStreamSource->error(ASCIILiteral("Loading failed"));
	m_response.m_readableStreamSource = nullptr;
	}
	#endif

	// Check whether didFail is called as part of FetchLoader::start.
	if (m_loader->isStarted()) {
	Ref<FetchResponse> protector(m_response);
	m_response.m_bodyLoader = std::nullopt;
	}
	}

	FetchResponse::BodyLoader::BodyLoader(FetchResponse& response, NotificationCallback&& responseCallback)
	: m_response(response)
	, m_responseCallback(WTFMove(responseCallback))
	{
	m_response.setPendingActivity(&m_response);
	}

	FetchResponse::BodyLoader::~BodyLoader()
	{
	m_response.unsetPendingActivity(&m_response);
	}

	static uint64_t nextOpaqueLoadIdentifier { 0 };
	void FetchResponse::BodyLoader::didReceiveResponse(const ResourceResponse& resourceResponse)
	{
	m_response.m_filteredResponse = ResourceResponseBase::filter(resourceResponse);
	m_response.m_internalResponse = resourceResponse;
	m_response.m_internalResponse.setType(m_response.m_filteredResponse->type());
	if (resourceResponse.tainting() == ResourceResponse::Tainting::Opaque) {
	m_response.m_opaqueLoadIdentifier = ++nextOpaqueLoadIdentifier;
	m_response.setBodyAsOpaque();
	}

	m_response.m_headers->filterAndFill(m_response.m_filteredResponse->httpHeaderFields(), FetchHeaders::Guard::Response);
	m_response.updateContentType();

	if (auto responseCallback = WTFMove(m_responseCallback))
	responseCallback(m_response);
	}

	void FetchResponse::BodyLoader::didReceiveData(const char* data, size_t size)
	{
	#if ENABLE(STREAMS_API)
	ASSERT(m_response.m_readableStreamSource \|\| m_consumeDataCallback);
	#else
	ASSERT(m_consumeDataCallback);
	#endif

	if (m_consumeDataCallback) {
	ReadableStreamChunk chunk { reinterpret_cast<const uint8_t*>(data), size };
	m_consumeDataCallback(&chunk);
	return;
	}

	#if ENABLE(STREAMS_API)
	auto& source = *m_response.m_readableStreamSource;

	if (!source.isPulling()) {
	m_response.body().consumer().append(data, size);
	return;
	}

	if (m_response.body().consumer().hasData() && !source.enqueue(m_response.body().consumer().takeAsArrayBuffer())) {
	stop();
	return;
	}
	if (!source.enqueue(ArrayBuffer::tryCreate(data, size))) {
	stop();
	return;
	}
	source.resolvePullPromise();
	#else
	UNUSED_PARAM(data);
	UNUSED_PARAM(size);
	#endif
	}

	bool FetchResponse::BodyLoader::start(ScriptExecutionContext& context, const FetchRequest& request)
	{
	m_loader = std::make_unique<FetchLoader>(*this, &m_response.m_body->consumer());
	m_loader->start(context, request);
	return m_loader->isStarted();
	}

	void FetchResponse::BodyLoader::stop()
	{
	m_responseCallback = { };
	if (m_loader)
	m_loader->stop();
	}

	void FetchResponse::BodyLoader::consumeDataByChunk(ConsumeDataByChunkCallback&& consumeDataCallback)
	{
	ASSERT(!m_consumeDataCallback);
	m_consumeDataCallback = WTFMove(consumeDataCallback);
	auto data = m_loader->startStreaming();
	if (!data)
	return;

	ReadableStreamChunk chunk { reinterpret_cast<const uint8_t*>(data->data()), data->size() };
	m_consumeDataCallback(&chunk);
	}

	FetchResponse::ResponseData FetchResponse::consumeBody()
	{
	ASSERT(!isBodyReceivedByChunk());

	if (isBodyNull())
	return nullptr;

	ASSERT(!m_isDisturbed);
	m_isDisturbed = true;

	return body().take();
	}

	void FetchResponse::consumeBodyReceivedByChunk(ConsumeDataByChunkCallback&& callback)
	{
	ASSERT(isBodyReceivedByChunk());
	ASSERT(!isDisturbed());
	m_isDisturbed = true;

	if (hasReadableStreamBody()) {
	m_body->consumer().extract(*m_body->readableStream(), WTFMove(callback));
	return;
	}

	ASSERT(isLoading());
	m_bodyLoader->consumeDataByChunk(WTFMove(callback));
	}

	void FetchResponse::setBodyData(ResponseData&& data, uint64_t bodySizeWithPadding)
	{
	m_bodySizeWithPadding = bodySizeWithPadding;
	WTF::switchOn(data,
	[this](Ref<FormData>& formData) {
	if (isBodyNull())
	setBody({ });
	body().setAsFormData(WTFMove(formData));
	},
	[this](Ref<SharedBuffer>& buffer) {
	if (isBodyNull())
	setBody({ });
	body().consumer().setData(WTFMove(buffer));
	},
	[](std::nullptr_t&) {
	}
	);
	}

	#if ENABLE(STREAMS_API)
	void FetchResponse::consumeChunk(Ref<JSC::Uint8Array>&& chunk)
	{
	body().consumer().append(chunk->data(), chunk->byteLength());
	}

	void FetchResponse::consumeBodyAsStream()
	{
	ASSERT(m_readableStreamSource);
	if (!isLoading()) {
	FetchBodyOwner::consumeBodyAsStream();
	return;
	}

	ASSERT(m_bodyLoader);

	auto data = m_bodyLoader->startStreaming();
	if (data) {
	if (!m_readableStreamSource->enqueue(data->tryCreateArrayBuffer())) {
	stop();
	return;
	}
	m_readableStreamSource->resolvePullPromise();
	}
	}

	void FetchResponse::closeStream()
	{
	ASSERT(m_readableStreamSource);
	m_readableStreamSource->close();
	m_readableStreamSource = nullptr;
	}

	void FetchResponse::feedStream()
	{
	ASSERT(m_readableStreamSource);
	bool shouldCloseStream = !m_bodyLoader;

	if (body().consumer().hasData()) {
	if (!m_readableStreamSource->enqueue(body().consumer().takeAsArrayBuffer())) {
	stop();
	return;
	}
	if (!shouldCloseStream) {
	m_readableStreamSource->resolvePullPromise();
	return;
	}
	} else if (!shouldCloseStream)
	return;

	closeStream();
	}

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

	void FetchResponse::cancel()
	{
	m_isDisturbed = true;
	stop();
	}

	#endif

	void FetchResponse::stop()
	{
	RefPtr<FetchResponse> protectedThis(this);
	FetchBodyOwner::stop();
	if (m_bodyLoader) {
	m_bodyLoader->stop();
	m_bodyLoader = std::nullopt;
	}
	}

	const char* FetchResponse::activeDOMObjectName() const
	{
	return "Response";
	}

	bool FetchResponse::canSuspendForDocumentSuspension() const
	{
	// FIXME: We can probably do the same strategy as XHR.
	return !isActive();
	}

	ResourceResponse FetchResponse::resourceResponse() const
	{
	auto response = m_internalResponse;

	if (headers().guard() != FetchHeaders::Guard::Immutable) {
	// FIXME: Add a setHTTPHeaderFields on ResourceResponseBase.
	for (auto& header : headers().internalHeaders())
	response.setHTTPHeaderField(header.key, header.value);
	}

	return response;
	}

	} // namespace WebCore