Source/WebCore/Modules/cache/DOMCache.cpp - WebKit - Git at Google

 /*
  * Copyright (C) 2017-2020 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are 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.
  *
  * 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
  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR 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 "DOMCache.h"

 #include "CacheQueryOptions.h"
 #include "CachedResourceRequestInitiators.h"
 #include "EventLoop.h"
 #include "FetchResponse.h"
 #include "HTTPParsers.h"
 #include "JSFetchRequest.h"
 #include "JSFetchResponse.h"
 #include "ScriptExecutionContext.h"
 #include <wtf/CompletionHandler.h>
 #include <wtf/URL.h>

 namespace WebCore {
 using namespace WebCore::DOMCacheEngine;

 Ref<DOMCache> DOMCache::create(ScriptExecutionContext& context, String&& name, uint64_t identifier, Ref<CacheStorageConnection>&& connection)
 {
     auto cache = adoptRef(*new DOMCache(context, WTFMove(name), identifier, WTFMove(connection)));
     cache->suspendIfNeeded();
     return cache;
 }

 DOMCache::DOMCache(ScriptExecutionContext& context, String&& name, uint64_t identifier, Ref<CacheStorageConnection>&& connection)
     : ActiveDOMObject(&context)
     , m_name(WTFMove(name))
     , m_identifier(identifier)
     , m_connection(WTFMove(connection))
 {
     m_connection->reference(m_identifier);
 }

 DOMCache::~DOMCache()
 {
     if (!m_isStopped)
         m_connection->dereference(m_identifier);
 }

 void DOMCache::match(RequestInfo&& info, CacheQueryOptions&& options, Ref<DeferredPromise>&& promise)
 {
     doMatch(WTFMove(info), WTFMove(options), [this, protectedThis = Ref { *this }, promise = WTFMove(promise)](ExceptionOr<RefPtr<FetchResponse>>&& result) mutable {
         queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [promise = WTFMove(promise), result = WTFMove(result)]() mutable {
             if (result.hasException()) {
                 promise->reject(result.releaseException());
                 return;
             }
             if (!result.returnValue()) {
                 promise->resolve();
                 return;
             }
             promise->resolve<IDLInterface<FetchResponse>>(*result.returnValue());
         });
     });
 }

 static Ref<FetchResponse> createResponse(ScriptExecutionContext& context, const DOMCacheEngine::Record& record, MonotonicTime requestStart)
 {
     auto resourceResponse = record.response;
     resourceResponse.setSource(ResourceResponse::Source::DOMCache);

     auto metrics = Box<NetworkLoadMetrics>::create();
     metrics->requestStart = requestStart;
     metrics->responseStart = MonotonicTime::now();
     resourceResponse.setDeprecatedNetworkLoadMetrics(WTFMove(metrics));

     auto response = FetchResponse::create(&context, std::nullopt, record.responseHeadersGuard, WTFMove(resourceResponse));
     response->setBodyData(copyResponseBody(record.responseBody), record.responseBodySize);
     return response;
 }

 void DOMCache::doMatch(RequestInfo&& info, CacheQueryOptions&& options, MatchCallback&& callback)
 {
     if (UNLIKELY(!scriptExecutionContext()))
         return;

     auto requestOrException = requestFromInfo(WTFMove(info), options.ignoreMethod);
     if (requestOrException.hasException()) {
         callback(nullptr);
         return;
     }

     auto request = requestOrException.releaseReturnValue()->resourceRequest();
     auto requestStart = MonotonicTime::now();
     queryCache(WTFMove(request), options, ShouldRetrieveResponses::Yes, [this, callback = WTFMove(callback), requestStart](auto&& result) mutable {
         if (result.hasException()) {
             callback(result.releaseException());
             return;
         }

         RefPtr<FetchResponse> response;
         if (!result.returnValue().isEmpty())
             response = createResponse(*scriptExecutionContext(), result.returnValue()[0], requestStart);

         callback(WTFMove(response));
     });
 }

 Vector<Ref<FetchResponse>> DOMCache::cloneResponses(const Vector<DOMCacheEngine::Record>& records, MonotonicTime requestStart)
 {
     return WTF::map(records, [this, requestStart] (const auto& record) {
         return createResponse(*scriptExecutionContext(), record, requestStart);
     });
 }

 void DOMCache::matchAll(std::optional<RequestInfo>&& info, CacheQueryOptions&& options, MatchAllPromise&& promise)
 {
     if (UNLIKELY(!scriptExecutionContext()))
         return;

     ResourceRequest resourceRequest;
     if (info) {
         auto requestOrException = requestFromInfo(WTFMove(info.value()), options.ignoreMethod);
         if (requestOrException.hasException()) {
             promise.resolve({ });
             return;
         }
         resourceRequest = requestOrException.releaseReturnValue()->resourceRequest();
     }

     auto requestStart = MonotonicTime::now();
     queryCache(WTFMove(resourceRequest), options, ShouldRetrieveResponses::Yes, [this, promise = WTFMove(promise), requestStart](auto&& result) mutable {
         queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [this, promise = WTFMove(promise), result = WTFMove(result), requestStart]() mutable {
             if (result.hasException()) {
                 promise.reject(result.releaseException());
                 return;
             }
             promise.resolve(cloneResponses(result.releaseReturnValue(), requestStart));
         });
     });
 }

 void DOMCache::add(RequestInfo&& info, DOMPromiseDeferred<void>&& promise)
 {
     addAll(Vector<RequestInfo> { WTFMove(info) }, WTFMove(promise));
 }

 static inline bool hasResponseVaryStarHeaderValue(const FetchResponse& response)
 {
     auto varyValue = response.headers().internalHeaders().get(WebCore::HTTPHeaderName::Vary);
     bool hasStar = false;
     varyValue.split(',', [&](StringView view) {
         if (!hasStar && stripLeadingAndTrailingHTTPSpaces(view) == "*"_s)
             hasStar = true;
     });
     return hasStar;
 }

 class FetchTasksHandler : public RefCounted<FetchTasksHandler> {
 public:
     static Ref<FetchTasksHandler> create(Ref<DOMCache>&& domCache, CompletionHandler<void(ExceptionOr<Vector<Record>>&&)>&& callback) { return adoptRef(*new FetchTasksHandler(WTFMove(domCache), WTFMove(callback))); }

     ~FetchTasksHandler()
     {
         if (m_callback)
             m_callback(WTFMove(m_records));
     }

     const Vector<Record>& records() const { return m_records; }

     size_t addRecord(Record&& record)
     {
         ASSERT(!isDone());
         m_records.append(WTFMove(record));
         return m_records.size() - 1;
     }

     void addResponseBody(size_t position, FetchResponse& response, DOMCacheEngine::ResponseBody&& data)
     {
         ASSERT(!isDone());
         auto& record = m_records[position];
         record.responseBodySize = m_domCache->connection().computeRecordBodySize(response, data);
         record.responseBody = WTFMove(data);
     }

     bool isDone() const { return !m_callback; }

     void error(Exception&& exception)
     {
         if (auto callback = WTFMove(m_callback))
             callback(WTFMove(exception));
     }

 private:
     FetchTasksHandler(Ref<DOMCache>&& domCache, CompletionHandler<void(ExceptionOr<Vector<Record>>&&)>&& callback)
         : m_domCache(WTFMove(domCache))
         , m_callback(WTFMove(callback))
     {
     }

     Ref<DOMCache> m_domCache;
     Vector<Record> m_records;
     CompletionHandler<void(ExceptionOr<Vector<Record>>&&)> m_callback;
 };

 ExceptionOr<Ref<FetchRequest>> DOMCache::requestFromInfo(RequestInfo&& info, bool ignoreMethod)
 {
     RefPtr<FetchRequest> request;
     if (std::holds_alternative<RefPtr<FetchRequest>>(info)) {
         request = std::get<RefPtr<FetchRequest>>(info).releaseNonNull();
         if (request->method() != "GET"_s && !ignoreMethod)
             return Exception { TypeError, "Request method is not GET"_s };
     } else
         request = FetchRequest::create(*scriptExecutionContext(), WTFMove(info), { }).releaseReturnValue();

     if (!request->url().protocolIsInHTTPFamily())
         return Exception { TypeError, "Request url is not HTTP/HTTPS"_s };

     return request.releaseNonNull();
 }

 void DOMCache::addAll(Vector<RequestInfo>&& infos, DOMPromiseDeferred<void>&& promise)
 {
     if (UNLIKELY(!scriptExecutionContext()))
         return;

     Vector<Ref<FetchRequest>> requests;
     requests.reserveInitialCapacity(infos.size());
     for (auto& info : infos) {
         bool ignoreMethod = false;
         auto requestOrException = requestFromInfo(WTFMove(info), ignoreMethod);
         if (requestOrException.hasException()) {
             promise.reject(requestOrException.releaseException());
             return;
         }
         requests.uncheckedAppend(requestOrException.releaseReturnValue());
     }

     auto taskHandler = FetchTasksHandler::create(*this, [this, protectedThis = Ref { *this }, promise = WTFMove(promise)](ExceptionOr<Vector<Record>>&& result) mutable {
         if (result.hasException()) {
             queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [promise = WTFMove(promise), exception = result.releaseException()]() mutable {
                 promise.reject(WTFMove(exception));
             });
             return;
         }
         batchPutOperation(result.releaseReturnValue(), [this, protectedThis = WTFMove(protectedThis), promise = WTFMove(promise)](ExceptionOr<void>&& result) mutable {
             queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [promise = WTFMove(promise), result = WTFMove(result)]() mutable {
                 promise.settle(WTFMove(result));
             });
         });
     });

     for (auto& request : requests) {
         auto& requestReference = request.get();
         if (requestReference.signal().aborted()) {
             taskHandler->error(Exception { AbortError, "Request signal is aborted"_s });
             return;
         }
         FetchResponse::fetch(*scriptExecutionContext(), requestReference, [this, request = WTFMove(request), taskHandler](auto&& result) mutable {

             if (taskHandler->isDone())
                 return;

             if (result.hasException()) {
                 taskHandler->error(result.releaseException());
                 return;
             }

             auto protectedResponse = result.releaseReturnValue();
             auto& response = protectedResponse.get();

             if (!response.ok()) {
                 taskHandler->error(Exception { TypeError, "Response is not OK"_s });
                 return;
             }

             if (hasResponseVaryStarHeaderValue(response)) {
                 taskHandler->error(Exception { TypeError, "Response has a '*' Vary header value"_s });
                 return;
             }

             if (response.status() == 206) {
                 taskHandler->error(Exception { TypeError, "Response is a 206 partial"_s });
                 return;
             }

             CacheQueryOptions options;
             for (const auto& record : taskHandler->records()) {
                 if (DOMCacheEngine::queryCacheMatch(request->resourceRequest(), record.request, record.response, options)) {
                     taskHandler->error(Exception { InvalidStateError, "addAll cannot store several matching requests"_s});
                     return;
                 }
             }
             size_t recordPosition = taskHandler->addRecord(toConnectionRecord(request.get(), response, nullptr));

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

                 if (result.hasException()) {
                     taskHandler->error(result.releaseException());
                     return;
                 }

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

 void DOMCache::putWithResponseData(DOMPromiseDeferred<void>&& promise, Ref<FetchRequest>&& request, Ref<FetchResponse>&& response, ExceptionOr<RefPtr<SharedBuffer>>&& responseBody)
 {
     if (responseBody.hasException()) {
         queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [promise = WTFMove(promise), exception = responseBody.releaseException()]() mutable {
             promise.reject(WTFMove(exception));
         });
         return;
     }

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

 void DOMCache::put(RequestInfo&& info, Ref<FetchResponse>&& response, DOMPromiseDeferred<void>&& promise)
 {
     if (UNLIKELY(!scriptExecutionContext()))
         return;

     bool ignoreMethod = false;
     auto requestOrException = requestFromInfo(WTFMove(info), ignoreMethod);
     if (requestOrException.hasException()) {
         promise.reject(requestOrException.releaseException());
         return;
     }
     auto request = requestOrException.releaseReturnValue();

     if (auto exception = response->loadingException()) {
         promise.reject(*exception);
         return;
     }

     if (hasResponseVaryStarHeaderValue(response.get())) {
         promise.reject(Exception { TypeError, "Response has a '*' Vary header value"_s });
         return;
     }

     if (response->status() == 206) {
         promise.reject(Exception { TypeError, "Response is a 206 partial"_s });
         return;
     }

     if (response->isDisturbedOrLocked()) {
         promise.reject(Exception { TypeError, "Response is disturbed or locked"_s });
         return;
     }

     // FIXME: for efficiency, we should load blobs/form data directly instead of going through the readableStream path.
     if (response->isBlobBody() || response->isBlobFormData()) {
         auto streamOrException = response->readableStream(*scriptExecutionContext()->globalObject());
         if (UNLIKELY(streamOrException.hasException())) {
             promise.reject(streamOrException.releaseException());
             return;
         }
     }

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

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

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

     batchPutOperation(request.get(), response.get(), response->consumeBody(), [this, protectedThis = Ref { *this }, promise = WTFMove(promise)](ExceptionOr<void>&& result) mutable {
         queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [promise = WTFMove(promise), result = WTFMove(result)]() mutable {
             promise.settle(WTFMove(result));
         });
     });
 }

 void DOMCache::remove(RequestInfo&& info, CacheQueryOptions&& options, DOMPromiseDeferred<IDLBoolean>&& promise)
 {
     if (UNLIKELY(!scriptExecutionContext()))
         return;

     auto requestOrException = requestFromInfo(WTFMove(info), options.ignoreMethod);
     if (requestOrException.hasException()) {
         promise.resolve(false);
         return;
     }

     batchDeleteOperation(requestOrException.releaseReturnValue(), WTFMove(options), [this, protectedThis = Ref { *this }, promise = WTFMove(promise)](ExceptionOr<bool>&& result) mutable {
         queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [promise = WTFMove(promise), result = WTFMove(result)]() mutable {
             promise.settle(WTFMove(result));
         });
     });
 }

 static Ref<FetchRequest> createRequest(ScriptExecutionContext& context, const DOMCacheEngine::Record& record)
 {
     auto requestHeaders = FetchHeaders::create(record.requestHeadersGuard, HTTPHeaderMap { record.request.httpHeaderFields() });
     return FetchRequest::create(context, std::nullopt, WTFMove(requestHeaders),  ResourceRequest { record.request }, FetchOptions { record.options }, String { record.referrer });
 }

 void DOMCache::keys(std::optional<RequestInfo>&& info, CacheQueryOptions&& options, KeysPromise&& promise)
 {
     if (UNLIKELY(!scriptExecutionContext()))
         return;

     ResourceRequest resourceRequest;
     if (info) {
         auto requestOrException = requestFromInfo(WTFMove(info.value()), options.ignoreMethod);
         if (requestOrException.hasException()) {
             promise.resolve(Vector<Ref<FetchRequest>> { });
             return;
         }
         resourceRequest = requestOrException.releaseReturnValue()->resourceRequest();
     }

     queryCache(WTFMove(resourceRequest), options, ShouldRetrieveResponses::No, [this, promise = WTFMove(promise)](auto&& result) mutable {
         queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [this, promise = WTFMove(promise), result = WTFMove(result)]() mutable {
             if (result.hasException()) {
                 promise.reject(result.releaseException());
                 return;
             }

             auto records = result.releaseReturnValue();
             promise.resolve(WTF::map(records, [this](auto& record) {
                 return createRequest(*scriptExecutionContext(), record);
             }));
         });
     });
 }

 void DOMCache::queryCache(ResourceRequest&& request, const CacheQueryOptions& options, ShouldRetrieveResponses shouldRetrieveResponses, RecordsCallback&& callback)
 {
     RetrieveRecordsOptions retrieveOptions { WTFMove(request), scriptExecutionContext()->crossOriginEmbedderPolicy(), *scriptExecutionContext()->securityOrigin(), options.ignoreSearch, options.ignoreMethod, options.ignoreVary, shouldRetrieveResponses == ShouldRetrieveResponses::Yes };
     m_connection->retrieveRecords(m_identifier, WTFMove(retrieveOptions), [this, pendingActivity = makePendingActivity(*this), callback = WTFMove(callback)](auto&& result) mutable {
         if (m_isStopped) {
             callback(DOMCacheEngine::convertToExceptionAndLog(scriptExecutionContext(), DOMCacheEngine::Error::Stopped));
             return;
         }

         if (!result.has_value()) {
             callback(DOMCacheEngine::convertToExceptionAndLog(scriptExecutionContext(), result.error()));
             return;
         }

         callback(WTFMove(result.value()));
     });

 }

 void DOMCache::batchDeleteOperation(const FetchRequest& request, CacheQueryOptions&& options, CompletionHandler<void(ExceptionOr<bool>&&)>&& callback)
 {
     m_connection->batchDeleteOperation(m_identifier, request.internalRequest(), WTFMove(options), [this, pendingActivity = makePendingActivity(*this), callback = WTFMove(callback)](RecordIdentifiersOrError&& result) mutable {
         if (m_isStopped) {
             callback(DOMCacheEngine::convertToExceptionAndLog(scriptExecutionContext(), DOMCacheEngine::Error::Stopped));
             return;
         }

         if (!result.has_value()) {
             callback(DOMCacheEngine::convertToExceptionAndLog(scriptExecutionContext(), result.error()));
             return;
         }
         callback(!result.value().isEmpty());
     });
 }

 Record DOMCache::toConnectionRecord(const FetchRequest& request, FetchResponse& response, DOMCacheEngine::ResponseBody&& responseBody)
 {
     auto cachedResponse = response.resourceResponse();
     ResourceRequest cachedRequest = request.internalRequest();
     cachedRequest.setHTTPHeaderFields(request.headers().internalHeaders());

     ASSERT(!cachedRequest.isNull());
     ASSERT(!cachedResponse.isNull());

     auto sizeWithPadding = response.bodySizeWithPadding();
     if (!sizeWithPadding) {
         sizeWithPadding = m_connection->computeRecordBodySize(response, responseBody);
         response.setBodySizeWithPadding(sizeWithPadding);
     }

     return { 0, 0,
         request.headers().guard(), WTFMove(cachedRequest), request.fetchOptions(), request.internalRequestReferrer(),
         response.headers().guard(), WTFMove(cachedResponse), WTFMove(responseBody), sizeWithPadding
     };
 }

 void DOMCache::batchPutOperation(const FetchRequest& request, FetchResponse& response, DOMCacheEngine::ResponseBody&& responseBody, CompletionHandler<void(ExceptionOr<void>&&)>&& callback)
 {
     auto record = toConnectionRecord(request, response, WTFMove(responseBody));
     batchPutOperation({ WTFMove(record) }, WTFMove(callback));
 }

 void DOMCache::batchPutOperation(Vector<Record>&& records, CompletionHandler<void(ExceptionOr<void>&&)>&& callback)
 {
     m_connection->batchPutOperation(m_identifier, WTFMove(records), [this, pendingActivity = makePendingActivity(*this), callback = WTFMove(callback)](auto&& result) mutable {
         if (m_isStopped) {
             callback(DOMCacheEngine::convertToExceptionAndLog(scriptExecutionContext(), DOMCacheEngine::Error::Stopped));
             return;
         }

         if (!result.has_value()) {
             callback(DOMCacheEngine::convertToExceptionAndLog(scriptExecutionContext(), result.error()));
             return;
         }
         callback({ });
     });
 }

 void DOMCache::stop()
 {
     if (m_isStopped)
         return;
     m_isStopped = true;
     m_connection->dereference(m_identifier);
 }

 const char* DOMCache::activeDOMObjectName() const
 {
     return "Cache";
 }

 } // namespace WebCore
	/*
	* Copyright (C) 2017-2020 Apple Inc. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are 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.
	*
	* 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
	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR 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 "DOMCache.h"

	#include "CacheQueryOptions.h"
	#include "CachedResourceRequestInitiators.h"
	#include "EventLoop.h"
	#include "FetchResponse.h"
	#include "HTTPParsers.h"
	#include "JSFetchRequest.h"
	#include "JSFetchResponse.h"
	#include "ScriptExecutionContext.h"
	#include <wtf/CompletionHandler.h>
	#include <wtf/URL.h>

	namespace WebCore {
	using namespace WebCore::DOMCacheEngine;

	Ref<DOMCache> DOMCache::create(ScriptExecutionContext& context, String&& name, uint64_t identifier, Ref<CacheStorageConnection>&& connection)
	{
	auto cache = adoptRef(*new DOMCache(context, WTFMove(name), identifier, WTFMove(connection)));
	cache->suspendIfNeeded();
	return cache;
	}

	DOMCache::DOMCache(ScriptExecutionContext& context, String&& name, uint64_t identifier, Ref<CacheStorageConnection>&& connection)
	: ActiveDOMObject(&context)
	, m_name(WTFMove(name))
	, m_identifier(identifier)
	, m_connection(WTFMove(connection))
	{
	m_connection->reference(m_identifier);
	}

	DOMCache::~DOMCache()
	{
	if (!m_isStopped)
	m_connection->dereference(m_identifier);
	}

	void DOMCache::match(RequestInfo&& info, CacheQueryOptions&& options, Ref<DeferredPromise>&& promise)
	{
	doMatch(WTFMove(info), WTFMove(options), [this, protectedThis = Ref { *this }, promise = WTFMove(promise)](ExceptionOr<RefPtr<FetchResponse>>&& result) mutable {
	queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [promise = WTFMove(promise), result = WTFMove(result)]() mutable {
	if (result.hasException()) {
	promise->reject(result.releaseException());
	return;
	}
	if (!result.returnValue()) {
	promise->resolve();
	return;
	}
	promise->resolve<IDLInterface<FetchResponse>>(*result.returnValue());
	});
	});
	}

	static Ref<FetchResponse> createResponse(ScriptExecutionContext& context, const DOMCacheEngine::Record& record, MonotonicTime requestStart)
	{
	auto resourceResponse = record.response;
	resourceResponse.setSource(ResourceResponse::Source::DOMCache);

	auto metrics = Box<NetworkLoadMetrics>::create();
	metrics->requestStart = requestStart;
	metrics->responseStart = MonotonicTime::now();
	resourceResponse.setDeprecatedNetworkLoadMetrics(WTFMove(metrics));

	auto response = FetchResponse::create(&context, std::nullopt, record.responseHeadersGuard, WTFMove(resourceResponse));
	response->setBodyData(copyResponseBody(record.responseBody), record.responseBodySize);
	return response;
	}

	void DOMCache::doMatch(RequestInfo&& info, CacheQueryOptions&& options, MatchCallback&& callback)
	{
	if (UNLIKELY(!scriptExecutionContext()))
	return;

	auto requestOrException = requestFromInfo(WTFMove(info), options.ignoreMethod);
	if (requestOrException.hasException()) {
	callback(nullptr);
	return;
	}

	auto request = requestOrException.releaseReturnValue()->resourceRequest();
	auto requestStart = MonotonicTime::now();
	queryCache(WTFMove(request), options, ShouldRetrieveResponses::Yes, [this, callback = WTFMove(callback), requestStart](auto&& result) mutable {
	if (result.hasException()) {
	callback(result.releaseException());
	return;
	}

	RefPtr<FetchResponse> response;
	if (!result.returnValue().isEmpty())
	response = createResponse(*scriptExecutionContext(), result.returnValue()[0], requestStart);

	callback(WTFMove(response));
	});
	}

	Vector<Ref<FetchResponse>> DOMCache::cloneResponses(const Vector<DOMCacheEngine::Record>& records, MonotonicTime requestStart)
	{
	return WTF::map(records, [this, requestStart] (const auto& record) {
	return createResponse(*scriptExecutionContext(), record, requestStart);
	});
	}

	void DOMCache::matchAll(std::optional<RequestInfo>&& info, CacheQueryOptions&& options, MatchAllPromise&& promise)
	{
	if (UNLIKELY(!scriptExecutionContext()))
	return;

	ResourceRequest resourceRequest;
	if (info) {
	auto requestOrException = requestFromInfo(WTFMove(info.value()), options.ignoreMethod);
	if (requestOrException.hasException()) {
	promise.resolve({ });
	return;
	}
	resourceRequest = requestOrException.releaseReturnValue()->resourceRequest();
	}

	auto requestStart = MonotonicTime::now();
	queryCache(WTFMove(resourceRequest), options, ShouldRetrieveResponses::Yes, [this, promise = WTFMove(promise), requestStart](auto&& result) mutable {
	queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [this, promise = WTFMove(promise), result = WTFMove(result), requestStart]() mutable {
	if (result.hasException()) {
	promise.reject(result.releaseException());
	return;
	}
	promise.resolve(cloneResponses(result.releaseReturnValue(), requestStart));
	});
	});
	}

	void DOMCache::add(RequestInfo&& info, DOMPromiseDeferred<void>&& promise)
	{
	addAll(Vector<RequestInfo> { WTFMove(info) }, WTFMove(promise));
	}

	static inline bool hasResponseVaryStarHeaderValue(const FetchResponse& response)
	{
	auto varyValue = response.headers().internalHeaders().get(WebCore::HTTPHeaderName::Vary);
	bool hasStar = false;
	varyValue.split(',', [&](StringView view) {
	if (!hasStar && stripLeadingAndTrailingHTTPSpaces(view) == "*"_s)
	hasStar = true;
	});
	return hasStar;
	}

	class FetchTasksHandler : public RefCounted<FetchTasksHandler> {
	public:
	static Ref<FetchTasksHandler> create(Ref<DOMCache>&& domCache, CompletionHandler<void(ExceptionOr<Vector<Record>>&&)>&& callback) { return adoptRef(*new FetchTasksHandler(WTFMove(domCache), WTFMove(callback))); }

	~FetchTasksHandler()
	{
	if (m_callback)
	m_callback(WTFMove(m_records));
	}

	const Vector<Record>& records() const { return m_records; }

	size_t addRecord(Record&& record)
	{
	ASSERT(!isDone());
	m_records.append(WTFMove(record));
	return m_records.size() - 1;
	}

	void addResponseBody(size_t position, FetchResponse& response, DOMCacheEngine::ResponseBody&& data)
	{
	ASSERT(!isDone());
	auto& record = m_records[position];
	record.responseBodySize = m_domCache->connection().computeRecordBodySize(response, data);
	record.responseBody = WTFMove(data);
	}

	bool isDone() const { return !m_callback; }

	void error(Exception&& exception)
	{
	if (auto callback = WTFMove(m_callback))
	callback(WTFMove(exception));
	}

	private:
	FetchTasksHandler(Ref<DOMCache>&& domCache, CompletionHandler<void(ExceptionOr<Vector<Record>>&&)>&& callback)
	: m_domCache(WTFMove(domCache))
	, m_callback(WTFMove(callback))
	{
	}

	Ref<DOMCache> m_domCache;
	Vector<Record> m_records;
	CompletionHandler<void(ExceptionOr<Vector<Record>>&&)> m_callback;
	};

	ExceptionOr<Ref<FetchRequest>> DOMCache::requestFromInfo(RequestInfo&& info, bool ignoreMethod)
	{
	RefPtr<FetchRequest> request;
	if (std::holds_alternative<RefPtr<FetchRequest>>(info)) {
	request = std::get<RefPtr<FetchRequest>>(info).releaseNonNull();
	if (request->method() != "GET"_s && !ignoreMethod)
	return Exception { TypeError, "Request method is not GET"_s };
	} else
	request = FetchRequest::create(*scriptExecutionContext(), WTFMove(info), { }).releaseReturnValue();

	if (!request->url().protocolIsInHTTPFamily())
	return Exception { TypeError, "Request url is not HTTP/HTTPS"_s };

	return request.releaseNonNull();
	}

	void DOMCache::addAll(Vector<RequestInfo>&& infos, DOMPromiseDeferred<void>&& promise)
	{
	if (UNLIKELY(!scriptExecutionContext()))
	return;

	Vector<Ref<FetchRequest>> requests;
	requests.reserveInitialCapacity(infos.size());
	for (auto& info : infos) {
	bool ignoreMethod = false;
	auto requestOrException = requestFromInfo(WTFMove(info), ignoreMethod);
	if (requestOrException.hasException()) {
	promise.reject(requestOrException.releaseException());
	return;
	}
	requests.uncheckedAppend(requestOrException.releaseReturnValue());
	}

	auto taskHandler = FetchTasksHandler::create(this, [this, protectedThis = Ref { this }, promise = WTFMove(promise)](ExceptionOr<Vector<Record>>&& result) mutable {
	if (result.hasException()) {
	queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [promise = WTFMove(promise), exception = result.releaseException()]() mutable {
	promise.reject(WTFMove(exception));
	});
	return;
	}
	batchPutOperation(result.releaseReturnValue(), [this, protectedThis = WTFMove(protectedThis), promise = WTFMove(promise)](ExceptionOr<void>&& result) mutable {
	queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [promise = WTFMove(promise), result = WTFMove(result)]() mutable {
	promise.settle(WTFMove(result));
	});
	});
	});

	for (auto& request : requests) {
	auto& requestReference = request.get();
	if (requestReference.signal().aborted()) {
	taskHandler->error(Exception { AbortError, "Request signal is aborted"_s });
	return;
	}
	FetchResponse::fetch(*scriptExecutionContext(), requestReference, [this, request = WTFMove(request), taskHandler](auto&& result) mutable {

	if (taskHandler->isDone())
	return;

	if (result.hasException()) {
	taskHandler->error(result.releaseException());
	return;
	}

	auto protectedResponse = result.releaseReturnValue();
	auto& response = protectedResponse.get();

	if (!response.ok()) {
	taskHandler->error(Exception { TypeError, "Response is not OK"_s });
	return;
	}

	if (hasResponseVaryStarHeaderValue(response)) {
	taskHandler->error(Exception { TypeError, "Response has a '*' Vary header value"_s });
	return;
	}

	if (response.status() == 206) {
	taskHandler->error(Exception { TypeError, "Response is a 206 partial"_s });
	return;
	}

	CacheQueryOptions options;
	for (const auto& record : taskHandler->records()) {
	if (DOMCacheEngine::queryCacheMatch(request->resourceRequest(), record.request, record.response, options)) {
	taskHandler->error(Exception { InvalidStateError, "addAll cannot store several matching requests"_s});
	return;
	}
	}
	size_t recordPosition = taskHandler->addRecord(toConnectionRecord(request.get(), response, nullptr));

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

	if (result.hasException()) {
	taskHandler->error(result.releaseException());
	return;
	}

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

	void DOMCache::putWithResponseData(DOMPromiseDeferred<void>&& promise, Ref<FetchRequest>&& request, Ref<FetchResponse>&& response, ExceptionOr<RefPtr<SharedBuffer>>&& responseBody)
	{
	if (responseBody.hasException()) {
	queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [promise = WTFMove(promise), exception = responseBody.releaseException()]() mutable {
	promise.reject(WTFMove(exception));
	});
	return;
	}

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

	void DOMCache::put(RequestInfo&& info, Ref<FetchResponse>&& response, DOMPromiseDeferred<void>&& promise)
	{
	if (UNLIKELY(!scriptExecutionContext()))
	return;

	bool ignoreMethod = false;
	auto requestOrException = requestFromInfo(WTFMove(info), ignoreMethod);
	if (requestOrException.hasException()) {
	promise.reject(requestOrException.releaseException());
	return;
	}
	auto request = requestOrException.releaseReturnValue();

	if (auto exception = response->loadingException()) {
	promise.reject(*exception);
	return;
	}

	if (hasResponseVaryStarHeaderValue(response.get())) {
	promise.reject(Exception { TypeError, "Response has a '*' Vary header value"_s });
	return;
	}

	if (response->status() == 206) {
	promise.reject(Exception { TypeError, "Response is a 206 partial"_s });
	return;
	}

	if (response->isDisturbedOrLocked()) {
	promise.reject(Exception { TypeError, "Response is disturbed or locked"_s });
	return;
	}

	// FIXME: for efficiency, we should load blobs/form data directly instead of going through the readableStream path.
	if (response->isBlobBody() \|\| response->isBlobFormData()) {
	auto streamOrException = response->readableStream(*scriptExecutionContext()->globalObject());
	if (UNLIKELY(streamOrException.hasException())) {
	promise.reject(streamOrException.releaseException());
	return;
	}
	}

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

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

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

	batchPutOperation(request.get(), response.get(), response->consumeBody(), [this, protectedThis = Ref { *this }, promise = WTFMove(promise)](ExceptionOr<void>&& result) mutable {
	queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [promise = WTFMove(promise), result = WTFMove(result)]() mutable {
	promise.settle(WTFMove(result));
	});
	});
	}

	void DOMCache::remove(RequestInfo&& info, CacheQueryOptions&& options, DOMPromiseDeferred<IDLBoolean>&& promise)
	{
	if (UNLIKELY(!scriptExecutionContext()))
	return;

	auto requestOrException = requestFromInfo(WTFMove(info), options.ignoreMethod);
	if (requestOrException.hasException()) {
	promise.resolve(false);
	return;
	}

	batchDeleteOperation(requestOrException.releaseReturnValue(), WTFMove(options), [this, protectedThis = Ref { *this }, promise = WTFMove(promise)](ExceptionOr<bool>&& result) mutable {
	queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [promise = WTFMove(promise), result = WTFMove(result)]() mutable {
	promise.settle(WTFMove(result));
	});
	});
	}

	static Ref<FetchRequest> createRequest(ScriptExecutionContext& context, const DOMCacheEngine::Record& record)
	{
	auto requestHeaders = FetchHeaders::create(record.requestHeadersGuard, HTTPHeaderMap { record.request.httpHeaderFields() });
	return FetchRequest::create(context, std::nullopt, WTFMove(requestHeaders), ResourceRequest { record.request }, FetchOptions { record.options }, String { record.referrer });
	}

	void DOMCache::keys(std::optional<RequestInfo>&& info, CacheQueryOptions&& options, KeysPromise&& promise)
	{
	if (UNLIKELY(!scriptExecutionContext()))
	return;

	ResourceRequest resourceRequest;
	if (info) {
	auto requestOrException = requestFromInfo(WTFMove(info.value()), options.ignoreMethod);
	if (requestOrException.hasException()) {
	promise.resolve(Vector<Ref<FetchRequest>> { });
	return;
	}
	resourceRequest = requestOrException.releaseReturnValue()->resourceRequest();
	}

	queryCache(WTFMove(resourceRequest), options, ShouldRetrieveResponses::No, [this, promise = WTFMove(promise)](auto&& result) mutable {
	queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [this, promise = WTFMove(promise), result = WTFMove(result)]() mutable {
	if (result.hasException()) {
	promise.reject(result.releaseException());
	return;
	}

	auto records = result.releaseReturnValue();
	promise.resolve(WTF::map(records, [this](auto& record) {
	return createRequest(*scriptExecutionContext(), record);
	}));
	});
	});
	}

	void DOMCache::queryCache(ResourceRequest&& request, const CacheQueryOptions& options, ShouldRetrieveResponses shouldRetrieveResponses, RecordsCallback&& callback)
	{
	RetrieveRecordsOptions retrieveOptions { WTFMove(request), scriptExecutionContext()->crossOriginEmbedderPolicy(), *scriptExecutionContext()->securityOrigin(), options.ignoreSearch, options.ignoreMethod, options.ignoreVary, shouldRetrieveResponses == ShouldRetrieveResponses::Yes };
	m_connection->retrieveRecords(m_identifier, WTFMove(retrieveOptions), [this, pendingActivity = makePendingActivity(*this), callback = WTFMove(callback)](auto&& result) mutable {
	if (m_isStopped) {
	callback(DOMCacheEngine::convertToExceptionAndLog(scriptExecutionContext(), DOMCacheEngine::Error::Stopped));
	return;
	}

	if (!result.has_value()) {
	callback(DOMCacheEngine::convertToExceptionAndLog(scriptExecutionContext(), result.error()));
	return;
	}

	callback(WTFMove(result.value()));
	});

	}

	void DOMCache::batchDeleteOperation(const FetchRequest& request, CacheQueryOptions&& options, CompletionHandler<void(ExceptionOr<bool>&&)>&& callback)
	{
	m_connection->batchDeleteOperation(m_identifier, request.internalRequest(), WTFMove(options), [this, pendingActivity = makePendingActivity(*this), callback = WTFMove(callback)](RecordIdentifiersOrError&& result) mutable {
	if (m_isStopped) {
	callback(DOMCacheEngine::convertToExceptionAndLog(scriptExecutionContext(), DOMCacheEngine::Error::Stopped));
	return;
	}

	if (!result.has_value()) {
	callback(DOMCacheEngine::convertToExceptionAndLog(scriptExecutionContext(), result.error()));
	return;
	}
	callback(!result.value().isEmpty());
	});
	}

	Record DOMCache::toConnectionRecord(const FetchRequest& request, FetchResponse& response, DOMCacheEngine::ResponseBody&& responseBody)
	{
	auto cachedResponse = response.resourceResponse();
	ResourceRequest cachedRequest = request.internalRequest();
	cachedRequest.setHTTPHeaderFields(request.headers().internalHeaders());

	ASSERT(!cachedRequest.isNull());
	ASSERT(!cachedResponse.isNull());

	auto sizeWithPadding = response.bodySizeWithPadding();
	if (!sizeWithPadding) {
	sizeWithPadding = m_connection->computeRecordBodySize(response, responseBody);
	response.setBodySizeWithPadding(sizeWithPadding);
	}

	return { 0, 0,
	request.headers().guard(), WTFMove(cachedRequest), request.fetchOptions(), request.internalRequestReferrer(),
	response.headers().guard(), WTFMove(cachedResponse), WTFMove(responseBody), sizeWithPadding
	};
	}

	void DOMCache::batchPutOperation(const FetchRequest& request, FetchResponse& response, DOMCacheEngine::ResponseBody&& responseBody, CompletionHandler<void(ExceptionOr<void>&&)>&& callback)
	{
	auto record = toConnectionRecord(request, response, WTFMove(responseBody));
	batchPutOperation({ WTFMove(record) }, WTFMove(callback));
	}

	void DOMCache::batchPutOperation(Vector<Record>&& records, CompletionHandler<void(ExceptionOr<void>&&)>&& callback)
	{
	m_connection->batchPutOperation(m_identifier, WTFMove(records), [this, pendingActivity = makePendingActivity(*this), callback = WTFMove(callback)](auto&& result) mutable {
	if (m_isStopped) {
	callback(DOMCacheEngine::convertToExceptionAndLog(scriptExecutionContext(), DOMCacheEngine::Error::Stopped));
	return;
	}

	if (!result.has_value()) {
	callback(DOMCacheEngine::convertToExceptionAndLog(scriptExecutionContext(), result.error()));
	return;
	}
	callback({ });
	});
	}

	void DOMCache::stop()
	{
	if (m_isStopped)
	return;
	m_isStopped = true;
	m_connection->dereference(m_identifier);
	}

	const char* DOMCache::activeDOMObjectName() const
	{
	return "Cache";
	}

	} // namespace WebCore