Modified: trunk/Source/WebCore/Modules/cache/DOMCache.cpp (258867 => 258868)
--- trunk/Source/WebCore/Modules/cache/DOMCache.cpp 2020-03-23 19:32:58 UTC (rev 258867)
+++ trunk/Source/WebCore/Modules/cache/DOMCache.cpp 2020-03-23 19:33:55 UTC (rev 258868)
@@ -73,6 +73,15 @@
});
}
+static Ref<FetchResponse> createResponse(ScriptExecutionContext& context, const DOMCacheEngine::Record& record)
+{
+ auto resourceResponse = record.response;
+ resourceResponse.setSource(ResourceResponse::Source::DOMCache);
+ auto response = FetchResponse::create(context, WTF::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()))
@@ -85,24 +94,24 @@
}
auto request = requestOrException.releaseReturnValue();
- queryCache(request.get(), WTFMove(options), [this, callback = WTFMove(callback)](ExceptionOr<Vector<CacheStorageRecord>>&& result) mutable {
+ queryCache(request.get(), WTFMove(options), [this, callback = WTFMove(callback)](auto&& result) mutable {
if (result.hasException()) {
callback(result.releaseException());
return;
}
- if (result.returnValue().isEmpty()) {
- callback(nullptr);
- return;
- }
- callback(RefPtr<FetchResponse>(result.returnValue()[0].response->clone(*scriptExecutionContext()).releaseReturnValue()));
+
+ RefPtr<FetchResponse> response;
+ if (!result.returnValue().isEmpty())
+ response = createResponse(*scriptExecutionContext(), result.returnValue()[0]);
+
+ callback(WTFMove(response));
});
}
-Vector<Ref<FetchResponse>> DOMCache::cloneResponses(const Vector<CacheStorageRecord>& records)
+Vector<Ref<FetchResponse>> DOMCache::cloneResponses(const Vector<DOMCacheEngine::Record>& records)
{
- auto& context = *scriptExecutionContext();
- return WTF::map(records, [&context] (const auto& record) {
- return record.response->clone(context).releaseReturnValue();
+ return WTF::map(records, [this] (const auto& record) {
+ return createResponse(*scriptExecutionContext(), record);
});
}
@@ -121,19 +130,7 @@
request = requestOrException.releaseReturnValue();
}
- if (!request) {
- retrieveRecords(URL { }, [this, promise = WTFMove(promise)](Optional<Exception>&& exception) mutable {
- queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [this, promise = WTFMove(promise), exception = WTFMove(exception)]() mutable {
- if (exception) {
- promise.reject(WTFMove(exception.value()));
- return;
- }
- promise.resolve(cloneResponses(m_records));
- });
- });
- return;
- }
- queryCache(request.releaseNonNull(), WTFMove(options), [this, promise = WTFMove(promise)](ExceptionOr<Vector<CacheStorageRecord>>&& result) mutable {
+ RecordsCallback callback = [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());
@@ -141,7 +138,11 @@
}
promise.resolve(cloneResponses(result.releaseReturnValue()));
});
- });
+ };
+
+ if (!request)
+ return retrieveRecords(URL { }, WTFMove(callback));
+ queryCache(request.releaseNonNull(), WTFMove(options), WTFMove(callback));
}
void DOMCache::add(RequestInfo&& info, DOMPromiseDeferred<void>&& promise)
@@ -413,9 +414,10 @@
});
}
-static inline Ref<FetchRequest> copyRequestRef(const CacheStorageRecord& record)
+static Ref<FetchRequest> createRequest(ScriptExecutionContext& context, const DOMCacheEngine::Record& record)
{
- return record.request.copyRef();
+ auto requestHeaders = FetchHeaders::create(record.requestHeadersGuard, HTTPHeaderMap { record.request.httpHeaderFields() });
+ return FetchRequest::create(context, WTF::nullopt, WTFMove(requestHeaders), ResourceRequest { record.request }, FetchOptions { record.options }, String { record.referrer });
}
void DOMCache::keys(Optional<RequestInfo>&& info, CacheQueryOptions&& options, KeysPromise&& promise)
@@ -433,39 +435,35 @@
request = requestOrException.releaseReturnValue();
}
- if (!request) {
- retrieveRecords(URL { }, [this, promise = WTFMove(promise)](Optional<Exception>&& exception) mutable {
- queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [this, promise = WTFMove(promise), exception = WTFMove(exception)]() mutable {
- if (exception) {
- promise.reject(WTFMove(exception.value()));
- return;
- }
- promise.resolve(WTF::map(m_records, copyRequestRef));
- });
- });
- return;
- }
-
- queryCache(request.releaseNonNull(), WTFMove(options), [this, protectedThis = makeRef(*this), promise = WTFMove(promise)](auto&& result) mutable {
- queueTaskKeepingObjectAlive(*this, TaskSource::DOMManipulation, [promise = WTFMove(promise), result = WTFMove(result)]() mutable {
+ RecordsCallback callback = [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;
}
- promise.resolve(WTF::map(result.releaseReturnValue(), copyRequestRef));
+ auto records = result.releaseReturnValue();
+ promise.resolve(WTF::map(records, [this](auto& record) {
+ return createRequest(*scriptExecutionContext(), record);
+ }));
});
- });
+ };
+
+ if (!request)
+ return retrieveRecords(URL { }, WTFMove(callback));
+ queryCache(request.releaseNonNull(), WTFMove(options), WTFMove(callback));
}
-void DOMCache::retrieveRecords(const URL& url, WTF::Function<void(Optional<Exception>&&)>&& callback)
+void DOMCache::retrieveRecords(const URL& url, RecordsCallback&& callback)
{
URL retrieveURL = url;
retrieveURL.removeQueryAndFragmentIdentifier();
- m_connection->retrieveRecords(m_identifier, retrieveURL, [this, pendingActivity = makePendingActivity(*this), callback = WTFMove(callback)](RecordsOrError&& result) {
- if (m_isStopped)
+ m_connection->retrieveRecords(m_identifier, retrieveURL, [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()));
@@ -472,47 +470,43 @@
return;
}
- updateRecords(WTFMove(result.value()));
- callback(WTF::nullopt);
+ callback(WTFMove(result.value()));
});
}
-void DOMCache::queryCache(Ref<FetchRequest>&& request, CacheQueryOptions&& options, WTF::Function<void(ExceptionOr<Vector<CacheStorageRecord>>&&)>&& callback)
+void DOMCache::queryCache(Ref<FetchRequest>&& request, CacheQueryOptions&& options, RecordsCallback&& callback)
{
auto url = ""
- retrieveRecords(url, [this, request = WTFMove(request), options = WTFMove(options), callback = WTFMove(callback)](Optional<Exception>&& exception) mutable {
- if (exception) {
- callback(WTFMove(exception.value()));
+ retrieveRecords(url, [this, request = WTFMove(request), options = WTFMove(options), callback = WTFMove(callback)](auto&& result) mutable {
+ if (result.hasException()) {
+ callback(result.releaseException());
return;
}
- callback(queryCacheWithTargetStorage(request.get(), options, m_records));
+ callback(queryCacheWithTargetStorage(request.get(), options, result.releaseReturnValue()));
});
}
-static inline bool queryCacheMatch(const FetchRequest& request, const FetchRequest& cachedRequest, const ResourceResponse& cachedResponse, const CacheQueryOptions& options)
+Vector<DOMCacheEngine::Record> DOMCache::queryCacheWithTargetStorage(const FetchRequest& request, const CacheQueryOptions& options, const Vector<DOMCacheEngine::Record>& targetStorage)
{
- // We need to pass the resource request with all correct headers hence why we call resourceRequest().
- return DOMCacheEngine::queryCacheMatch(request.resourceRequest(), cachedRequest.resourceRequest(), cachedResponse, options);
-}
-
-Vector<CacheStorageRecord> DOMCache::queryCacheWithTargetStorage(const FetchRequest& request, const CacheQueryOptions& options, const Vector<CacheStorageRecord>& targetStorage)
-{
if (!options.ignoreMethod && request.method() != "GET")
return { };
- Vector<CacheStorageRecord> records;
+ Vector<DOMCacheEngine::Record> records;
for (auto& record : targetStorage) {
- if (queryCacheMatch(request, record.request.get(), record.response->resourceResponse(), options))
- records.append({ record.identifier, record.updateResponseCounter, record.request.copyRef(), record.response.copyRef() });
+ // We need to pass the resource request with all correct headers hence why we call resourceRequest().
+ if (DOMCacheEngine::queryCacheMatch(request.resourceRequest(), record.request, record.response, options))
+ records.append(record.copy());
}
return records;
}
-void DOMCache::batchDeleteOperation(const FetchRequest& request, CacheQueryOptions&& options, WTF::Function<void(ExceptionOr<bool>&&)>&& callback)
+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) {
- if (m_isStopped)
+ 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()));
@@ -543,7 +537,7 @@
};
}
-void DOMCache::batchPutOperation(const FetchRequest& request, FetchResponse& response, DOMCacheEngine::ResponseBody&& responseBody, WTF::Function<void(ExceptionOr<void>&&)>&& callback)
+void DOMCache::batchPutOperation(const FetchRequest& request, FetchResponse& response, DOMCacheEngine::ResponseBody&& responseBody, CompletionHandler<void(ExceptionOr<void>&&)>&& callback)
{
Vector<Record> records;
records.append(toConnectionRecord(request, response, WTFMove(responseBody)));
@@ -551,11 +545,14 @@
batchPutOperation(WTFMove(records), WTFMove(callback));
}
-void DOMCache::batchPutOperation(Vector<Record>&& records, WTF::Function<void(ExceptionOr<void>&&)>&& 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)](RecordIdentifiersOrError&& result) {
- if (m_isStopped)
+ 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;
@@ -564,38 +561,6 @@
});
}
-void DOMCache::updateRecords(Vector<Record>&& records)
-{
- ASSERT(scriptExecutionContext());
- Vector<CacheStorageRecord> newRecords;
-
- for (auto& record : records) {
- size_t index = m_records.findMatching([&](const auto& item) { return item.identifier == record.identifier; });
- if (index != notFound) {
- auto& current = m_records[index];
- if (current.updateResponseCounter != record.updateResponseCounter) {
- record.response.setSource(ResourceResponse::Source::DOMCache);
- auto response = FetchResponse::create(*scriptExecutionContext(), WTF::nullopt, record.responseHeadersGuard, WTFMove(record.response));
- response->setBodyData(WTFMove(record.responseBody), record.responseBodySize);
-
- current.response = WTFMove(response);
- current.updateResponseCounter = record.updateResponseCounter;
- }
- newRecords.append(WTFMove(current));
- } else {
- auto requestHeaders = FetchHeaders::create(record.requestHeadersGuard, HTTPHeaderMap { record.request.httpHeaderFields() });
- auto request = FetchRequest::create(*scriptExecutionContext(), WTF::nullopt, WTFMove(requestHeaders), WTFMove(record.request), WTFMove(record.options), WTFMove(record.referrer));
-
- record.response.setSource(ResourceResponse::Source::DOMCache);
- auto response = FetchResponse::create(*scriptExecutionContext(), WTF::nullopt, record.responseHeadersGuard, WTFMove(record.response));
- response->setBodyData(WTFMove(record.responseBody), record.responseBodySize);
-
- newRecords.append(CacheStorageRecord { record.identifier, record.updateResponseCounter, WTFMove(request), WTFMove(response) });
- }
- }
- m_records = WTFMove(newRecords);
-}
-
void DOMCache::stop()
{
if (m_isStopped)
Modified: trunk/Source/WebCore/Modules/cache/DOMCache.h (258867 => 258868)
--- trunk/Source/WebCore/Modules/cache/DOMCache.h 2020-03-23 19:32:58 UTC (rev 258867)
+++ trunk/Source/WebCore/Modules/cache/DOMCache.h 2020-03-23 19:33:55 UTC (rev 258868)
@@ -27,7 +27,8 @@
#include "ActiveDOMObject.h"
#include "CacheStorageConnection.h"
-#include "CacheStorageRecord.h"
+#include "FetchRequest.h"
+#include "FetchResponse.h"
#include <wtf/UniqueRef.h>
namespace WebCore {
@@ -57,7 +58,7 @@
const String& name() const { return m_name; }
uint64_t identifier() const { return m_identifier; }
- using MatchCallback = Function<void(ExceptionOr<RefPtr<FetchResponse>>)>;
+ using MatchCallback = CompletionHandler<void(ExceptionOr<RefPtr<FetchResponse>>)>;
void doMatch(RequestInfo&&, CacheQueryOptions&&, MatchCallback&&);
CacheStorageConnection& connection() { return m_connection.get(); }
@@ -73,15 +74,15 @@
void putWithResponseData(DOMPromiseDeferred<void>&&, Ref<FetchRequest>&&, Ref<FetchResponse>&&, ExceptionOr<RefPtr<SharedBuffer>>&&);
- void retrieveRecords(const URL&, WTF::Function<void(Optional<Exception>&&)>&&);
- Vector<CacheStorageRecord> queryCacheWithTargetStorage(const FetchRequest&, const CacheQueryOptions&, const Vector<CacheStorageRecord>&);
- void queryCache(Ref<FetchRequest>&&, CacheQueryOptions&&, WTF::Function<void(ExceptionOr<Vector<CacheStorageRecord>>&&)>&&);
- void batchDeleteOperation(const FetchRequest&, CacheQueryOptions&&, WTF::Function<void(ExceptionOr<bool>&&)>&&);
- void batchPutOperation(const FetchRequest&, FetchResponse&, DOMCacheEngine::ResponseBody&&, WTF::Function<void(ExceptionOr<void>&&)>&&);
- void batchPutOperation(Vector<DOMCacheEngine::Record>&&, WTF::Function<void(ExceptionOr<void>&&)>&&);
+ using RecordsCallback = CompletionHandler<void(ExceptionOr<Vector<DOMCacheEngine::Record>>&&)>;
+ void retrieveRecords(const URL&, RecordsCallback&&);
+ Vector<DOMCacheEngine::Record> queryCacheWithTargetStorage(const FetchRequest&, const CacheQueryOptions&, const Vector<DOMCacheEngine::Record>&);
+ void queryCache(Ref<FetchRequest>&&, CacheQueryOptions&&, RecordsCallback&&);
+ void batchDeleteOperation(const FetchRequest&, CacheQueryOptions&&, CompletionHandler<void(ExceptionOr<bool>&&)>&&);
+ void batchPutOperation(const FetchRequest&, FetchResponse&, DOMCacheEngine::ResponseBody&&, CompletionHandler<void(ExceptionOr<void>&&)>&&);
+ void batchPutOperation(Vector<DOMCacheEngine::Record>&&, CompletionHandler<void(ExceptionOr<void>&&)>&&);
- void updateRecords(Vector<DOMCacheEngine::Record>&&);
- Vector<Ref<FetchResponse>> cloneResponses(const Vector<CacheStorageRecord>&);
+ Vector<Ref<FetchResponse>> cloneResponses(const Vector<DOMCacheEngine::Record>&);
DOMCacheEngine::Record toConnectionRecord(const FetchRequest&, FetchResponse&, DOMCacheEngine::ResponseBody&&);
String m_name;
@@ -88,7 +89,6 @@
uint64_t m_identifier;
Ref<CacheStorageConnection> m_connection;
- Vector<CacheStorageRecord> m_records;
bool m_isStopped { false };
};
