+2016-10-31 Brady Eidson <beidson@apple.com>
+
+ Address style feedback in https://bugs.webkit.org/show_bug.cgi?id=164097
+ https://bugs.webkit.org/show_bug.cgi?id=164248
+
+ Unreviewed. Addressing review feedback (and then some) from Darin Adler on earlier patch.
+
+ No new tests (No behavior change).
+
+ * Modules/indexeddb/IDBTransaction.cpp:
+ (WebCore::IDBTransaction::commit):
+ (WebCore::IDBTransaction::createObjectStore):
+ (WebCore::IDBTransaction::renameObjectStore):
+ (WebCore::IDBTransaction::createIndex):
+ (WebCore::IDBTransaction::renameIndex):
+ (WebCore::IDBTransaction::requestOpenCursor):
+ (WebCore::IDBTransaction::doRequestOpenCursor):
+ (WebCore::IDBTransaction::iterateCursor):
+ (WebCore::IDBTransaction::requestGetAllObjectStoreRecords):
+ (WebCore::IDBTransaction::requestGetRecord):
+ (WebCore::IDBTransaction::requestGetValue):
+ (WebCore::IDBTransaction::requestGetKey):
+ (WebCore::IDBTransaction::requestIndexRecord):
+ (WebCore::IDBTransaction::requestCount):
+ (WebCore::IDBTransaction::requestDeleteRecord):
+ (WebCore::IDBTransaction::requestClearObjectStore):
+ (WebCore::IDBTransaction::requestPutOrAdd):
+ (WebCore::IDBTransaction::deleteObjectStore):
+ (WebCore::IDBTransaction::deleteIndex):
+
+ * Modules/indexeddb/client/IDBConnectionProxy.cpp:
+ (WebCore::IDBClient::IDBConnectionProxy::createObjectStore):
+ (WebCore::IDBClient::IDBConnectionProxy::renameObjectStore):
+ (WebCore::IDBClient::IDBConnectionProxy::renameIndex):
+ (WebCore::IDBClient::IDBConnectionProxy::deleteObjectStore):
+ (WebCore::IDBClient::IDBConnectionProxy::clearObjectStore):
+ (WebCore::IDBClient::IDBConnectionProxy::createIndex):
+ (WebCore::IDBClient::IDBConnectionProxy::deleteIndex):
+ (WebCore::IDBClient::IDBConnectionProxy::putOrAdd):
+ (WebCore::IDBClient::IDBConnectionProxy::getRecord):
+ (WebCore::IDBClient::IDBConnectionProxy::getAllRecords):
+ (WebCore::IDBClient::IDBConnectionProxy::getCount):
+ (WebCore::IDBClient::IDBConnectionProxy::deleteRecord):
+ (WebCore::IDBClient::IDBConnectionProxy::openCursor):
+ (WebCore::IDBClient::IDBConnectionProxy::iterateCursor):
+
+ * Modules/indexeddb/server/MemoryIDBBackingStore.cpp:
+ (WebCore::IDBServer::MemoryIDBBackingStore::beginTransaction):
+ (WebCore::IDBServer::MemoryIDBBackingStore::abortTransaction):
+ (WebCore::IDBServer::MemoryIDBBackingStore::commitTransaction):
+ (WebCore::IDBServer::MemoryIDBBackingStore::createObjectStore):
+ (WebCore::IDBServer::MemoryIDBBackingStore::deleteObjectStore):
+ (WebCore::IDBServer::MemoryIDBBackingStore::renameObjectStore):
+ (WebCore::IDBServer::MemoryIDBBackingStore::clearObjectStore):
+ (WebCore::IDBServer::MemoryIDBBackingStore::createIndex):
+ (WebCore::IDBServer::MemoryIDBBackingStore::deleteIndex):
+ (WebCore::IDBServer::MemoryIDBBackingStore::renameIndex):
+ (WebCore::IDBServer::MemoryIDBBackingStore::keyExistsInObjectStore):
+ (WebCore::IDBServer::MemoryIDBBackingStore::deleteRange):
+ (WebCore::IDBServer::MemoryIDBBackingStore::addRecord):
+ (WebCore::IDBServer::MemoryIDBBackingStore::getRecord):
+ (WebCore::IDBServer::MemoryIDBBackingStore::getAllRecords):
+ (WebCore::IDBServer::MemoryIDBBackingStore::getIndexRecord):
+ (WebCore::IDBServer::MemoryIDBBackingStore::getCount):
+ (WebCore::IDBServer::MemoryIDBBackingStore::generateKeyNumber):
+ (WebCore::IDBServer::MemoryIDBBackingStore::openCursor):
+ (WebCore::IDBServer::MemoryIDBBackingStore::iterateCursor):
+
+ * Modules/indexeddb/shared/IDBResultData.cpp:
+ (WebCore::IDBResultData::error):
+ (WebCore::IDBResultData::openDatabaseSuccess):
+ (WebCore::IDBResultData::openDatabaseUpgradeNeeded):
+ (WebCore::IDBResultData::deleteDatabaseSuccess):
+ (WebCore::IDBResultData::putOrAddSuccess):
+ (WebCore::IDBResultData::getRecordSuccess):
+ (WebCore::IDBResultData::getAllRecordsSuccess):
+ (WebCore::IDBResultData::getCountSuccess):
+ (WebCore::IDBResultData::openCursorSuccess):
+ (WebCore::IDBResultData::iterateCursorSuccess):
+
2016-10-31 Ryosuke Niwa <rniwa@webkit.org>
Enable custom elements by default everywhere
transitionedToFinishing(IndexedDB::TransactionState::Committing);
m_database->willCommitTransaction(*this);
- auto operation = IDBClient::createTransactionOperation(*this, nullptr, &IDBTransaction::commitOnServer);
- scheduleOperation(WTFMove(operation));
+ scheduleOperation(IDBClient::createTransactionOperation(*this, nullptr, &IDBTransaction::commitOnServer));
}
void IDBTransaction::commitOnServer(IDBClient::TransactionOperation& operation)
Ref<IDBObjectStore> objectStore = IDBObjectStore::create(*scriptExecutionContext(), info, *this);
m_referencedObjectStores.set(info.name(), &objectStore.get());
- auto operation = IDBClient::createTransactionOperation(*this, &IDBTransaction::didCreateObjectStoreOnServer, &IDBTransaction::createObjectStoreOnServer, info);
- scheduleOperation(WTFMove(operation));
+ scheduleOperation(IDBClient::createTransactionOperation(*this, &IDBTransaction::didCreateObjectStoreOnServer, &IDBTransaction::createObjectStoreOnServer, info));
return objectStore;
}
ASSERT(m_referencedObjectStores.get(objectStore.info().name()) == &objectStore);
uint64_t objectStoreIdentifier = objectStore.info().identifier();
- auto operation = IDBClient::createTransactionOperation(*this, &IDBTransaction::didRenameObjectStoreOnServer, &IDBTransaction::renameObjectStoreOnServer, objectStoreIdentifier, newName);
- scheduleOperation(WTFMove(operation));
+ scheduleOperation(IDBClient::createTransactionOperation(*this, &IDBTransaction::didRenameObjectStoreOnServer, &IDBTransaction::renameObjectStoreOnServer, objectStoreIdentifier, newName));
m_referencedObjectStores.set(newName, m_referencedObjectStores.take(objectStore.info().name()));
}
if (!scriptExecutionContext())
return nullptr;
- auto operation = IDBClient::createTransactionOperation(*this, &IDBTransaction::didCreateIndexOnServer, &IDBTransaction::createIndexOnServer, info);
- scheduleOperation(WTFMove(operation));
+ scheduleOperation(IDBClient::createTransactionOperation(*this, &IDBTransaction::didCreateIndexOnServer, &IDBTransaction::createIndexOnServer, info));
return std::make_unique<IDBIndex>(*scriptExecutionContext(), info, objectStore);
}
uint64_t objectStoreIdentifier = index.objectStore().info().identifier();
uint64_t indexIdentifier = index.info().identifier();
- auto operation = IDBClient::createTransactionOperation(*this, &IDBTransaction::didRenameIndexOnServer, &IDBTransaction::renameIndexOnServer, objectStoreIdentifier, indexIdentifier, newName);
- scheduleOperation(WTFMove(operation));
+ scheduleOperation(IDBClient::createTransactionOperation(*this, &IDBTransaction::didRenameIndexOnServer, &IDBTransaction::renameIndexOnServer, objectStoreIdentifier, indexIdentifier, newName));
}
void IDBTransaction::renameIndexOnServer(IDBClient::TransactionOperation& operation, const uint64_t& objectStoreIdentifier, const uint64_t& indexIdentifier, const String& newName)
ASSERT_UNUSED(resultData, resultData.type() == IDBResultType::RenameIndexSuccess || resultData.type() == IDBResultType::Error);
}
-Ref<IDBRequest> IDBTransaction::requestOpenCursor(ExecState& execState, IDBObjectStore& objectStore, const IDBCursorInfo& info)
+Ref<IDBRequest> IDBTransaction::requestOpenCursor(ExecState& state, IDBObjectStore& objectStore, const IDBCursorInfo& info)
{
LOG(IndexedDB, "IDBTransaction::requestOpenCursor");
ASSERT(currentThread() == m_database->originThreadID());
if (info.cursorType() == IndexedDB::CursorType::KeyOnly)
- return doRequestOpenCursor(execState, IDBCursor::create(*this, objectStore, info));
+ return doRequestOpenCursor(state, IDBCursor::create(*this, objectStore, info));
- return doRequestOpenCursor(execState, IDBCursorWithValue::create(*this, objectStore, info));
+ return doRequestOpenCursor(state, IDBCursorWithValue::create(*this, objectStore, info));
}
-Ref<IDBRequest> IDBTransaction::requestOpenCursor(ExecState& execState, IDBIndex& index, const IDBCursorInfo& info)
+Ref<IDBRequest> IDBTransaction::requestOpenCursor(ExecState& state, IDBIndex& index, const IDBCursorInfo& info)
{
LOG(IndexedDB, "IDBTransaction::requestOpenCursor");
ASSERT(currentThread() == m_database->originThreadID());
if (info.cursorType() == IndexedDB::CursorType::KeyOnly)
- return doRequestOpenCursor(execState, IDBCursor::create(*this, index, info));
+ return doRequestOpenCursor(state, IDBCursor::create(*this, index, info));
- return doRequestOpenCursor(execState, IDBCursorWithValue::create(*this, index, info));
+ return doRequestOpenCursor(state, IDBCursorWithValue::create(*this, index, info));
}
-Ref<IDBRequest> IDBTransaction::doRequestOpenCursor(ExecState& execState, Ref<IDBCursor>&& cursor)
+Ref<IDBRequest> IDBTransaction::doRequestOpenCursor(ExecState& state, Ref<IDBCursor>&& cursor)
{
ASSERT(isActive());
ASSERT(currentThread() == m_database->originThreadID());
- RELEASE_ASSERT(scriptExecutionContext());
- ASSERT_UNUSED(execState, scriptExecutionContext() == scriptExecutionContextFromExecState(&execState));
+ ASSERT_UNUSED(state, scriptExecutionContext() == scriptExecutionContextFromExecState(&state));
- Ref<IDBRequest> request = IDBRequest::create(*scriptExecutionContext(), cursor.get(), *this);
+ auto request = IDBRequest::create(*scriptExecutionContext(), cursor.get(), *this);
addRequest(request.get());
- auto operation = IDBClient::createTransactionOperation(*this, request.get(), &IDBTransaction::didOpenCursorOnServer, &IDBTransaction::openCursorOnServer, cursor->info());
- scheduleOperation(WTFMove(operation));
+ scheduleOperation(IDBClient::createTransactionOperation(*this, request.get(), &IDBTransaction::didOpenCursorOnServer, &IDBTransaction::openCursorOnServer, cursor->info()));
return request;
}
addRequest(*cursor.request());
- auto operation = IDBClient::createTransactionOperation(*this, *cursor.request(), &IDBTransaction::didIterateCursorOnServer, &IDBTransaction::iterateCursorOnServer, key, count);
- scheduleOperation(WTFMove(operation));
+ scheduleOperation(IDBClient::createTransactionOperation(*this, *cursor.request(), &IDBTransaction::didIterateCursorOnServer, &IDBTransaction::iterateCursorOnServer, key, count));
}
void IDBTransaction::iterateCursorOnServer(IDBClient::TransactionOperation& operation, const IDBKeyData& key, const unsigned long& count)
ASSERT_UNUSED(state, scriptExecutionContext() == scriptExecutionContextFromExecState(&state));
- Ref<IDBRequest> request = IDBRequest::create(*scriptExecutionContext(), objectStore, *this);
+ auto request = IDBRequest::create(*scriptExecutionContext(), objectStore, *this);
addRequest(request.get());
IDBGetAllRecordsData getAllRecordsData { keyRangeData, getAllType, count, objectStore.info().identifier(), 0 };
- auto operation = IDBClient::createTransactionOperation(*this, request.get(), &IDBTransaction::didGetAllRecordsOnServer, &IDBTransaction::getAllRecordsOnServer, getAllRecordsData);
- scheduleOperation(WTFMove(operation));
+ scheduleOperation(IDBClient::createTransactionOperation(*this, request.get(), &IDBTransaction::didGetAllRecordsOnServer, &IDBTransaction::getAllRecordsOnServer, getAllRecordsData));
return request;
}
request.requestCompleted(resultData);
}
-Ref<IDBRequest> IDBTransaction::requestGetRecord(ExecState& execState, IDBObjectStore& objectStore, const IDBGetRecordData& getRecordData)
+Ref<IDBRequest> IDBTransaction::requestGetRecord(ExecState& state, IDBObjectStore& objectStore, const IDBGetRecordData& getRecordData)
{
LOG(IndexedDB, "IDBTransaction::requestGetRecord");
ASSERT(isActive());
ASSERT(!getRecordData.keyRangeData.isNull);
ASSERT(currentThread() == m_database->originThreadID());
- RELEASE_ASSERT(scriptExecutionContext());
- ASSERT_UNUSED(execState, scriptExecutionContext() == scriptExecutionContextFromExecState(&execState));
+ ASSERT_UNUSED(state, scriptExecutionContext() == scriptExecutionContextFromExecState(&state));
- Ref<IDBRequest> request = IDBRequest::create(*scriptExecutionContext(), objectStore, *this);
+ auto request = IDBRequest::create(*scriptExecutionContext(), objectStore, *this);
addRequest(request.get());
- auto operation = IDBClient::createTransactionOperation(*this, request.get(), &IDBTransaction::didGetRecordOnServer, &IDBTransaction::getRecordOnServer, getRecordData);
- scheduleOperation(WTFMove(operation));
+ scheduleOperation(IDBClient::createTransactionOperation(*this, request.get(), &IDBTransaction::didGetRecordOnServer, &IDBTransaction::getRecordOnServer, getRecordData));
return request;
}
-Ref<IDBRequest> IDBTransaction::requestGetValue(ExecState& execState, IDBIndex& index, const IDBKeyRangeData& range)
+Ref<IDBRequest> IDBTransaction::requestGetValue(ExecState& state, IDBIndex& index, const IDBKeyRangeData& range)
{
LOG(IndexedDB, "IDBTransaction::requestGetValue");
ASSERT(currentThread() == m_database->originThreadID());
- return requestIndexRecord(execState, index, IndexedDB::IndexRecordType::Value, range);
+ return requestIndexRecord(state, index, IndexedDB::IndexRecordType::Value, range);
}
-Ref<IDBRequest> IDBTransaction::requestGetKey(ExecState& execState, IDBIndex& index, const IDBKeyRangeData& range)
+Ref<IDBRequest> IDBTransaction::requestGetKey(ExecState& state, IDBIndex& index, const IDBKeyRangeData& range)
{
LOG(IndexedDB, "IDBTransaction::requestGetValue");
ASSERT(currentThread() == m_database->originThreadID());
- return requestIndexRecord(execState, index, IndexedDB::IndexRecordType::Key, range);
+ return requestIndexRecord(state, index, IndexedDB::IndexRecordType::Key, range);
}
-Ref<IDBRequest> IDBTransaction::requestIndexRecord(ExecState& execState, IDBIndex& index, IndexedDB::IndexRecordType type, const IDBKeyRangeData& range)
+Ref<IDBRequest> IDBTransaction::requestIndexRecord(ExecState& state, IDBIndex& index, IndexedDB::IndexRecordType type, const IDBKeyRangeData& range)
{
LOG(IndexedDB, "IDBTransaction::requestGetValue");
ASSERT(isActive());
ASSERT(!range.isNull);
ASSERT(currentThread() == m_database->originThreadID());
- RELEASE_ASSERT(scriptExecutionContext());
- ASSERT_UNUSED(execState, scriptExecutionContext() == scriptExecutionContextFromExecState(&execState));
+ ASSERT_UNUSED(state, scriptExecutionContext() == scriptExecutionContextFromExecState(&state));
- Ref<IDBRequest> request = IDBRequest::createGet(*scriptExecutionContext(), index, type, *this);
+ auto request = IDBRequest::createGet(*scriptExecutionContext(), index, type, *this);
addRequest(request.get());
IDBGetRecordData getRecordData = { range };
- auto operation = IDBClient::createTransactionOperation(*this, request.get(), &IDBTransaction::didGetRecordOnServer, &IDBTransaction::getRecordOnServer, getRecordData);
- scheduleOperation(WTFMove(operation));
+ scheduleOperation(IDBClient::createTransactionOperation(*this, request.get(), &IDBTransaction::didGetRecordOnServer, &IDBTransaction::getRecordOnServer, getRecordData));
return request;
}
request.requestCompleted(resultData);
}
-Ref<IDBRequest> IDBTransaction::requestCount(ExecState& execState, IDBObjectStore& objectStore, const IDBKeyRangeData& range)
+Ref<IDBRequest> IDBTransaction::requestCount(ExecState& state, IDBObjectStore& objectStore, const IDBKeyRangeData& range)
{
LOG(IndexedDB, "IDBTransaction::requestCount (IDBObjectStore)");
ASSERT(isActive());
ASSERT(!range.isNull);
ASSERT(currentThread() == m_database->originThreadID());
- RELEASE_ASSERT(scriptExecutionContext());
- ASSERT_UNUSED(execState, scriptExecutionContext() == scriptExecutionContextFromExecState(&execState));
+ ASSERT_UNUSED(state, scriptExecutionContext() == scriptExecutionContextFromExecState(&state));
- Ref<IDBRequest> request = IDBRequest::create(*scriptExecutionContext(), objectStore, *this);
+ auto request = IDBRequest::create(*scriptExecutionContext(), objectStore, *this);
addRequest(request.get());
scheduleOperation(IDBClient::createTransactionOperation(*this, request.get(), &IDBTransaction::didGetCountOnServer, &IDBTransaction::getCountOnServer, range));
return request;
}
-Ref<IDBRequest> IDBTransaction::requestCount(ExecState& execState, IDBIndex& index, const IDBKeyRangeData& range)
+Ref<IDBRequest> IDBTransaction::requestCount(ExecState& state, IDBIndex& index, const IDBKeyRangeData& range)
{
LOG(IndexedDB, "IDBTransaction::requestCount (IDBIndex)");
ASSERT(isActive());
ASSERT(!range.isNull);
ASSERT(currentThread() == m_database->originThreadID());
- RELEASE_ASSERT(scriptExecutionContext());
- ASSERT_UNUSED(execState, scriptExecutionContext() == scriptExecutionContextFromExecState(&execState));
+ ASSERT_UNUSED(state, scriptExecutionContext() == scriptExecutionContextFromExecState(&state));
- Ref<IDBRequest> request = IDBRequest::createCount(*scriptExecutionContext(), index, *this);
+ auto request = IDBRequest::createCount(*scriptExecutionContext(), index, *this);
addRequest(request.get());
scheduleOperation(IDBClient::createTransactionOperation(*this, request.get(), &IDBTransaction::didGetCountOnServer, &IDBTransaction::getCountOnServer, range));
request.requestCompleted(resultData);
}
-Ref<IDBRequest> IDBTransaction::requestDeleteRecord(ExecState& execState, IDBObjectStore& objectStore, const IDBKeyRangeData& range)
+Ref<IDBRequest> IDBTransaction::requestDeleteRecord(ExecState& state, IDBObjectStore& objectStore, const IDBKeyRangeData& range)
{
LOG(IndexedDB, "IDBTransaction::requestDeleteRecord");
ASSERT(isActive());
ASSERT(!range.isNull);
ASSERT(currentThread() == m_database->originThreadID());
- RELEASE_ASSERT(scriptExecutionContext());
- ASSERT_UNUSED(execState, scriptExecutionContext() == scriptExecutionContextFromExecState(&execState));
+ ASSERT_UNUSED(state, scriptExecutionContext() == scriptExecutionContextFromExecState(&state));
- Ref<IDBRequest> request = IDBRequest::create(*scriptExecutionContext(), objectStore, *this);
+ auto request = IDBRequest::create(*scriptExecutionContext(), objectStore, *this);
addRequest(request.get());
scheduleOperation(IDBClient::createTransactionOperation(*this, request.get(), &IDBTransaction::didDeleteRecordOnServer, &IDBTransaction::deleteRecordOnServer, range));
request.requestCompleted(resultData);
}
-Ref<IDBRequest> IDBTransaction::requestClearObjectStore(ExecState& execState, IDBObjectStore& objectStore)
+Ref<IDBRequest> IDBTransaction::requestClearObjectStore(ExecState& state, IDBObjectStore& objectStore)
{
LOG(IndexedDB, "IDBTransaction::requestClearObjectStore");
ASSERT(isActive());
ASSERT(currentThread() == m_database->originThreadID());
- RELEASE_ASSERT(scriptExecutionContext());
- ASSERT_UNUSED(execState, scriptExecutionContext() == scriptExecutionContextFromExecState(&execState));
+ ASSERT_UNUSED(state, scriptExecutionContext() == scriptExecutionContextFromExecState(&state));
- Ref<IDBRequest> request = IDBRequest::create(*scriptExecutionContext(), objectStore, *this);
+ auto request = IDBRequest::create(*scriptExecutionContext(), objectStore, *this);
addRequest(request.get());
uint64_t objectStoreIdentifier = objectStore.info().identifier();
- auto operation = IDBClient::createTransactionOperation(*this, request.get(), &IDBTransaction::didClearObjectStoreOnServer, &IDBTransaction::clearObjectStoreOnServer, objectStoreIdentifier);
- scheduleOperation(WTFMove(operation));
+ scheduleOperation(IDBClient::createTransactionOperation(*this, request.get(), &IDBTransaction::didClearObjectStoreOnServer, &IDBTransaction::clearObjectStoreOnServer, objectStoreIdentifier));
return request;
}
request.requestCompleted(resultData);
}
-Ref<IDBRequest> IDBTransaction::requestPutOrAdd(ExecState& execState, IDBObjectStore& objectStore, IDBKey* key, SerializedScriptValue& value, IndexedDB::ObjectStoreOverwriteMode overwriteMode)
+Ref<IDBRequest> IDBTransaction::requestPutOrAdd(ExecState& state, IDBObjectStore& objectStore, IDBKey* key, SerializedScriptValue& value, IndexedDB::ObjectStoreOverwriteMode overwriteMode)
{
LOG(IndexedDB, "IDBTransaction::requestPutOrAdd");
ASSERT(isActive());
ASSERT(objectStore.info().autoIncrement() || key);
ASSERT(currentThread() == m_database->originThreadID());
- RELEASE_ASSERT(scriptExecutionContext());
- ASSERT_UNUSED(execState, scriptExecutionContext() == scriptExecutionContextFromExecState(&execState));
+ ASSERT_UNUSED(state, scriptExecutionContext() == scriptExecutionContextFromExecState(&state));
- Ref<IDBRequest> request = IDBRequest::create(*scriptExecutionContext(), objectStore, *this);
+ auto request = IDBRequest::create(*scriptExecutionContext(), objectStore, *this);
addRequest(request.get());
- auto operation = IDBClient::createTransactionOperation(*this, request.get(), &IDBTransaction::didPutOrAddOnServer, &IDBTransaction::putOrAddOnServer, key, &value, overwriteMode);
- scheduleOperation(WTFMove(operation));
+ scheduleOperation(IDBClient::createTransactionOperation(*this, request.get(), &IDBTransaction::didPutOrAddOnServer, &IDBTransaction::putOrAddOnServer, key, &value, overwriteMode));
return request;
}
if (auto objectStore = m_referencedObjectStores.take(objectStoreName))
objectStore->markAsDeleted();
- auto operation = IDBClient::createTransactionOperation(*this, &IDBTransaction::didDeleteObjectStoreOnServer, &IDBTransaction::deleteObjectStoreOnServer, objectStoreName);
- scheduleOperation(WTFMove(operation));
+ scheduleOperation(IDBClient::createTransactionOperation(*this, &IDBTransaction::didDeleteObjectStoreOnServer, &IDBTransaction::deleteObjectStoreOnServer, objectStoreName));
}
void IDBTransaction::deleteObjectStoreOnServer(IDBClient::TransactionOperation& operation, const String& objectStoreName)
ASSERT(currentThread() == m_database->originThreadID());
ASSERT(isVersionChange());
- auto operation = IDBClient::createTransactionOperation(*this, &IDBTransaction::didDeleteIndexOnServer, &IDBTransaction::deleteIndexOnServer, objectStoreIdentifier, indexName);
- scheduleOperation(WTFMove(operation));
+ scheduleOperation(IDBClient::createTransactionOperation(*this, &IDBTransaction::didDeleteIndexOnServer, &IDBTransaction::deleteIndexOnServer, objectStoreIdentifier, indexName));
}
void IDBTransaction::deleteIndexOnServer(IDBClient::TransactionOperation& operation, const uint64_t& objectStoreIdentifier, const String& indexName)
void IDBConnectionProxy::createObjectStore(TransactionOperation& operation, const IDBObjectStoreInfo& info)
{
- const IDBRequestData requestData(operation);
+ const IDBRequestData requestData { operation };
saveOperation(operation);
callConnectionOnMainThread(&IDBConnectionToServer::createObjectStore, requestData, info);
void IDBConnectionProxy::renameObjectStore(TransactionOperation& operation, uint64_t objectStoreIdentifier, const String& newName)
{
- const IDBRequestData requestData(operation);
+ const IDBRequestData requestData { operation };
saveOperation(operation);
callConnectionOnMainThread(&IDBConnectionToServer::renameObjectStore, requestData, objectStoreIdentifier, newName);
void IDBConnectionProxy::renameIndex(TransactionOperation& operation, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName)
{
- const IDBRequestData requestData(operation);
+ const IDBRequestData requestData { operation };
saveOperation(operation);
callConnectionOnMainThread(&IDBConnectionToServer::renameIndex, requestData, objectStoreIdentifier, indexIdentifier, newName);
void IDBConnectionProxy::deleteObjectStore(TransactionOperation& operation, const String& objectStoreName)
{
- const IDBRequestData requestData(operation);
+ const IDBRequestData requestData { operation };
saveOperation(operation);
callConnectionOnMainThread(&IDBConnectionToServer::deleteObjectStore, requestData, objectStoreName);
void IDBConnectionProxy::clearObjectStore(TransactionOperation& operation, uint64_t objectStoreIdentifier)
{
- const IDBRequestData requestData(operation);
+ const IDBRequestData requestData { operation };
saveOperation(operation);
callConnectionOnMainThread(&IDBConnectionToServer::clearObjectStore, requestData, objectStoreIdentifier);
void IDBConnectionProxy::createIndex(TransactionOperation& operation, const IDBIndexInfo& info)
{
- const IDBRequestData requestData(operation);
+ const IDBRequestData requestData { operation };
saveOperation(operation);
callConnectionOnMainThread(&IDBConnectionToServer::createIndex, requestData, info);
void IDBConnectionProxy::deleteIndex(TransactionOperation& operation, uint64_t objectStoreIdentifier, const String& indexName)
{
- const IDBRequestData requestData(operation);
+ const IDBRequestData requestData { operation };
saveOperation(operation);
callConnectionOnMainThread(&IDBConnectionToServer::deleteIndex, requestData, WTFMove(objectStoreIdentifier), indexName);
void IDBConnectionProxy::putOrAdd(TransactionOperation& operation, IDBKeyData&& keyData, const IDBValue& value, const IndexedDB::ObjectStoreOverwriteMode mode)
{
- const IDBRequestData requestData(operation);
+ const IDBRequestData requestData { operation };
saveOperation(operation);
callConnectionOnMainThread(&IDBConnectionToServer::putOrAdd, requestData, keyData, value, mode);
void IDBConnectionProxy::getRecord(TransactionOperation& operation, const IDBGetRecordData& getRecordData)
{
- const IDBRequestData requestData(operation);
+ const IDBRequestData requestData { operation };
saveOperation(operation);
callConnectionOnMainThread(&IDBConnectionToServer::getRecord, requestData, getRecordData);
void IDBConnectionProxy::getAllRecords(TransactionOperation& operation, const IDBGetAllRecordsData& getAllRecordsData)
{
- const IDBRequestData requestData(operation);
+ const IDBRequestData requestData { operation };
saveOperation(operation);
callConnectionOnMainThread(&IDBConnectionToServer::getAllRecords, requestData, getAllRecordsData);
void IDBConnectionProxy::getCount(TransactionOperation& operation, const IDBKeyRangeData& keyRange)
{
- const IDBRequestData requestData(operation);
+ const IDBRequestData requestData { operation };
saveOperation(operation);
callConnectionOnMainThread(&IDBConnectionToServer::getCount, requestData, keyRange);
void IDBConnectionProxy::deleteRecord(TransactionOperation& operation, const IDBKeyRangeData& keyRange)
{
- const IDBRequestData requestData(operation);
+ const IDBRequestData requestData { operation };
saveOperation(operation);
callConnectionOnMainThread(&IDBConnectionToServer::deleteRecord, requestData, keyRange);
void IDBConnectionProxy::openCursor(TransactionOperation& operation, const IDBCursorInfo& info)
{
- const IDBRequestData requestData(operation);
+ const IDBRequestData requestData { operation };
saveOperation(operation);
callConnectionOnMainThread(&IDBConnectionToServer::openCursor, requestData, info);
void IDBConnectionProxy::iterateCursor(TransactionOperation& operation, const IDBKeyData& key, unsigned long count)
{
- const IDBRequestData requestData(operation);
+ const IDBRequestData requestData { operation };
saveOperation(operation);
callConnectionOnMainThread(&IDBConnectionToServer::iterateCursor, requestData, key, count);
LOG(IndexedDB, "MemoryIDBBackingStore::beginTransaction");
if (m_transactions.contains(info.identifier()))
- return IDBError(IDBDatabaseException::InvalidStateError, "Backing store asked to create transaction it already has a record of");
+ return { IDBDatabaseException::InvalidStateError, "Backing store asked to create transaction it already has a record of" };
auto transaction = MemoryBackingStoreTransaction::create(*this, info);
m_transactions.set(info.identifier(), WTFMove(transaction));
- return IDBError();
+ return { };
}
IDBError MemoryIDBBackingStore::abortTransaction(const IDBResourceIdentifier& transactionIdentifier)
auto transaction = m_transactions.take(transactionIdentifier);
if (!transaction)
- return IDBError(IDBDatabaseException::InvalidStateError, "Backing store asked to abort transaction it didn't have record of");
+ return { IDBDatabaseException::InvalidStateError, "Backing store asked to abort transaction it didn't have record of" };
transaction->abort();
- return IDBError();
+ return { };
}
IDBError MemoryIDBBackingStore::commitTransaction(const IDBResourceIdentifier& transactionIdentifier)
auto transaction = m_transactions.take(transactionIdentifier);
if (!transaction)
- return IDBError(IDBDatabaseException::InvalidStateError, "Backing store asked to commit transaction it didn't have record of");
+ return { IDBDatabaseException::InvalidStateError, "Backing store asked to commit transaction it didn't have record of" };
transaction->commit();
- return IDBError();
+ return { };
}
IDBError MemoryIDBBackingStore::createObjectStore(const IDBResourceIdentifier& transactionIdentifier, const IDBObjectStoreInfo& info)
ASSERT(m_databaseInfo);
if (m_databaseInfo->hasObjectStore(info.name()))
- return IDBError(IDBDatabaseException::ConstraintError);
+ return { IDBDatabaseException::ConstraintError };
ASSERT(!m_objectStoresByIdentifier.contains(info.identifier()));
auto objectStore = MemoryObjectStore::create(info);
rawTransaction->addNewObjectStore(objectStore.get());
registerObjectStore(WTFMove(objectStore));
- return IDBError();
+ return { };
}
IDBError MemoryIDBBackingStore::deleteObjectStore(const IDBResourceIdentifier& transactionIdentifier, uint64_t objectStoreIdentifier)
ASSERT(m_databaseInfo);
if (!m_databaseInfo->infoForExistingObjectStore(objectStoreIdentifier))
- return IDBError(IDBDatabaseException::ConstraintError);
+ return { IDBDatabaseException::ConstraintError };
auto transaction = m_transactions.get(transactionIdentifier);
ASSERT(transaction);
auto objectStore = takeObjectStoreByIdentifier(objectStoreIdentifier);
ASSERT(objectStore);
if (!objectStore)
- return IDBError(IDBDatabaseException::ConstraintError);
+ return { IDBDatabaseException::ConstraintError };
m_databaseInfo->deleteObjectStore(objectStore->info().name());
transaction->objectStoreDeleted(*objectStore);
- return IDBError();
+ return { };
}
IDBError MemoryIDBBackingStore::renameObjectStore(const IDBResourceIdentifier& transactionIdentifier, uint64_t objectStoreIdentifier, const String& newName)
ASSERT(m_databaseInfo);
if (!m_databaseInfo->infoForExistingObjectStore(objectStoreIdentifier))
- return IDBError(IDBDatabaseException::ConstraintError);
+ return { IDBDatabaseException::ConstraintError };
auto transaction = m_transactions.get(transactionIdentifier);
ASSERT(transaction);
auto objectStore = m_objectStoresByIdentifier.get(objectStoreIdentifier);
ASSERT(objectStore);
if (!objectStore)
- return IDBError(IDBDatabaseException::ConstraintError);
+ return { IDBDatabaseException::ConstraintError };
String oldName = objectStore->info().name();
objectStore->rename(newName);
m_databaseInfo->renameObjectStore(objectStoreIdentifier, newName);
- return IDBError();
+ return { };
}
IDBError MemoryIDBBackingStore::clearObjectStore(const IDBResourceIdentifier& transactionIdentifier, uint64_t objectStoreIdentifier)
auto objectStore = m_objectStoresByIdentifier.get(objectStoreIdentifier);
if (!objectStore)
- return IDBError(IDBDatabaseException::ConstraintError);
+ return { IDBDatabaseException::ConstraintError };
objectStore->clear();
- return IDBError();
+ return { };
}
IDBError MemoryIDBBackingStore::createIndex(const IDBResourceIdentifier& transactionIdentifier, const IDBIndexInfo& info)
auto* objectStore = m_objectStoresByIdentifier.get(info.objectStoreIdentifier());
if (!objectStore)
- return IDBError(IDBDatabaseException::ConstraintError);
+ return { IDBDatabaseException::ConstraintError };
return objectStore->createIndex(*rawTransaction, info);
}
auto* objectStore = m_objectStoresByIdentifier.get(objectStoreIdentifier);
if (!objectStore)
- return IDBError(IDBDatabaseException::ConstraintError);
+ return { IDBDatabaseException::ConstraintError };
return objectStore->deleteIndex(*rawTransaction, indexIdentifier);
}
ASSERT(m_databaseInfo);
auto* objectStoreInfo = m_databaseInfo->infoForExistingObjectStore(objectStoreIdentifier);
if (!objectStoreInfo)
- return IDBError(IDBDatabaseException::ConstraintError);
+ return { IDBDatabaseException::ConstraintError };
auto* indexInfo = objectStoreInfo->infoForExistingIndex(indexIdentifier);
if (!indexInfo)
- return IDBError(IDBDatabaseException::ConstraintError);
+ return { IDBDatabaseException::ConstraintError };
auto transaction = m_transactions.get(transactionIdentifier);
ASSERT(transaction);
auto objectStore = m_objectStoresByIdentifier.get(objectStoreIdentifier);
ASSERT(objectStore);
if (!objectStore)
- return IDBError(IDBDatabaseException::ConstraintError);
+ return { IDBDatabaseException::ConstraintError };
auto* index = objectStore->indexForIdentifier(indexIdentifier);
ASSERT(index);
if (!index)
- return IDBError(IDBDatabaseException::ConstraintError);
+ return { IDBDatabaseException::ConstraintError };
String oldName = index->info().name();
objectStore->renameIndex(*index, newName);
indexInfo->rename(newName);
- return IDBError();
+ return { };
}
void MemoryIDBBackingStore::removeObjectStoreForVersionChangeAbort(MemoryObjectStore& objectStore)
RELEASE_ASSERT(objectStore);
keyExists = objectStore->containsRecord(keyData);
- return IDBError();
+ return { };
}
IDBError MemoryIDBBackingStore::deleteRange(const IDBResourceIdentifier& transactionIdentifier, uint64_t objectStoreIdentifier, const IDBKeyRangeData& range)
ASSERT(objectStoreIdentifier);
if (!m_transactions.contains(transactionIdentifier))
- return IDBError(IDBDatabaseException::UnknownError, ASCIILiteral("No backing store transaction found to delete from"));
+ return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store transaction found to delete from") };
MemoryObjectStore* objectStore = m_objectStoresByIdentifier.get(objectStoreIdentifier);
if (!objectStore)
- return IDBError(IDBDatabaseException::UnknownError, ASCIILiteral("No backing store object store found"));
+ return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store object store found") };
objectStore->deleteRange(range);
- return IDBError();
+ return { };
}
IDBError MemoryIDBBackingStore::addRecord(const IDBResourceIdentifier& transactionIdentifier, const IDBObjectStoreInfo& objectStoreInfo, const IDBKeyData& keyData, const IDBValue& value)
auto transaction = m_transactions.get(transactionIdentifier);
if (!transaction)
- return IDBError(IDBDatabaseException::UnknownError, ASCIILiteral("No backing store transaction found to put record"));
+ return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store transaction found to put record") };
MemoryObjectStore* objectStore = m_objectStoresByIdentifier.get(objectStoreInfo.identifier());
if (!objectStore)
- return IDBError(IDBDatabaseException::UnknownError, ASCIILiteral("No backing store object store found to put record"));
+ return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store object store found to put record") };
return objectStore->addRecord(*transaction, keyData, value);
}
ASSERT(objectStoreIdentifier);
if (!m_transactions.contains(transactionIdentifier))
- return IDBError(IDBDatabaseException::UnknownError, ASCIILiteral("No backing store transaction found to get record"));
+ return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store transaction found to get record") };
MemoryObjectStore* objectStore = m_objectStoresByIdentifier.get(objectStoreIdentifier);
if (!objectStore)
- return IDBError(IDBDatabaseException::UnknownError, ASCIILiteral("No backing store object store found"));
+ return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store object store found") };
outValue = objectStore->valueForKeyRange(range);
- return IDBError();
+ return { };
}
IDBError MemoryIDBBackingStore::getAllRecords(const IDBResourceIdentifier& transactionIdentifier, const IDBGetAllRecordsData& getAllRecordsData, IDBGetAllResult& result)
ASSERT(getAllRecordsData.objectStoreIdentifier);
if (!m_transactions.contains(transactionIdentifier))
- return IDBError(IDBDatabaseException::UnknownError, ASCIILiteral("No backing store transaction found to get all records"));
+ return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store transaction found to get all records") };
MemoryObjectStore* objectStore = m_objectStoresByIdentifier.get(getAllRecordsData.objectStoreIdentifier);
if (!objectStore)
- return IDBError(IDBDatabaseException::UnknownError, ASCIILiteral("No backing store object store found"));
+ return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store object store found") };
objectStore->getAllRecords(getAllRecordsData.keyRangeData, getAllRecordsData.count, getAllRecordsData.getAllType, result);
return { };
ASSERT(objectStoreIdentifier);
if (!m_transactions.contains(transactionIdentifier))
- return IDBError(IDBDatabaseException::UnknownError, ASCIILiteral("No backing store transaction found to get record"));
+ return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store transaction found to get record") };
MemoryObjectStore* objectStore = m_objectStoresByIdentifier.get(objectStoreIdentifier);
if (!objectStore)
- return IDBError(IDBDatabaseException::UnknownError, ASCIILiteral("No backing store object store found"));
+ return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store object store found") };
outValue = objectStore->indexValueForKeyRange(indexIdentifier, recordType, range);
- return IDBError();
+ return { };
}
IDBError MemoryIDBBackingStore::getCount(const IDBResourceIdentifier& transactionIdentifier, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const IDBKeyRangeData& range, uint64_t& outCount)
ASSERT(objectStoreIdentifier);
if (!m_transactions.contains(transactionIdentifier))
- return IDBError(IDBDatabaseException::UnknownError, ASCIILiteral("No backing store transaction found to get count"));
+ return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store transaction found to get count") };
MemoryObjectStore* objectStore = m_objectStoresByIdentifier.get(objectStoreIdentifier);
if (!objectStore)
- return IDBError(IDBDatabaseException::UnknownError, ASCIILiteral("No backing store object store found"));
+ return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store object store found") };
outCount = objectStore->countForKeyRange(indexIdentifier, range);
- return IDBError();
+ return { };
}
IDBError MemoryIDBBackingStore::generateKeyNumber(const IDBResourceIdentifier& transactionIdentifier, uint64_t objectStoreIdentifier, uint64_t& keyNumber)
objectStore->setKeyGeneratorValue(keyNumber + 1);
- return IDBError();
+ return { };
}
IDBError MemoryIDBBackingStore::revertGeneratedKeyNumber(const IDBResourceIdentifier& transactionIdentifier, uint64_t objectStoreIdentifier, uint64_t keyNumber)
ASSERT(!MemoryCursor::cursorForIdentifier(info.identifier()));
if (!m_transactions.contains(transactionIdentifier))
- return IDBError(IDBDatabaseException::UnknownError, ASCIILiteral("No backing store transaction found in which to open a cursor"));
+ return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store transaction found in which to open a cursor") };
switch (info.cursorSource()) {
case IndexedDB::CursorSource::ObjectStore: {
auto* objectStore = m_objectStoresByIdentifier.get(info.sourceIdentifier());
if (!objectStore)
- return IDBError(IDBDatabaseException::UnknownError, ASCIILiteral("No backing store object store found"));
+ return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store object store found") };
MemoryCursor* cursor = objectStore->maybeOpenCursor(info);
if (!cursor)
- return IDBError(IDBDatabaseException::UnknownError, ASCIILiteral("Could not create object store cursor in backing store"));
+ return { IDBDatabaseException::UnknownError, ASCIILiteral("Could not create object store cursor in backing store") };
cursor->currentData(outData);
break;
case IndexedDB::CursorSource::Index:
auto* objectStore = m_objectStoresByIdentifier.get(info.objectStoreIdentifier());
if (!objectStore)
- return IDBError(IDBDatabaseException::UnknownError, ASCIILiteral("No backing store object store found"));
+ return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store object store found") };
auto* index = objectStore->indexForIdentifier(info.sourceIdentifier());
if (!index)
- return IDBError(IDBDatabaseException::UnknownError, ASCIILiteral("No backing store index found"));
+ return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store index found") };
MemoryCursor* cursor = index->maybeOpenCursor(info);
if (!cursor)
- return IDBError(IDBDatabaseException::UnknownError, ASCIILiteral("Could not create index cursor in backing store"));
+ return { IDBDatabaseException::UnknownError, ASCIILiteral("Could not create index cursor in backing store") };
cursor->currentData(outData);
break;
LOG(IndexedDB, "MemoryIDBBackingStore::iterateCursor");
if (!m_transactions.contains(transactionIdentifier))
- return IDBError(IDBDatabaseException::UnknownError, ASCIILiteral("No backing store transaction found in which to iterate cursor"));
+ return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store transaction found in which to iterate cursor") };
auto* cursor = MemoryCursor::cursorForIdentifier(cursorIdentifier);
if (!cursor)
- return IDBError(IDBDatabaseException::UnknownError, ASCIILiteral("No backing store cursor found in which to iterate cursor"));
+ return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store cursor found in which to iterate cursor") };
cursor->iterate(key, count, outData);
IDBResultData IDBResultData::error(const IDBResourceIdentifier& requestIdentifier, const IDBError& error)
{
- IDBResultData result(requestIdentifier);
+ IDBResultData result { requestIdentifier };
result.m_type = IDBResultType::Error;
result.m_error = error;
return result;
IDBResultData IDBResultData::openDatabaseSuccess(const IDBResourceIdentifier& requestIdentifier, IDBServer::UniqueIDBDatabaseConnection& connection)
{
- IDBResultData result(requestIdentifier);
+ IDBResultData result { requestIdentifier };
result.m_type = IDBResultType::OpenDatabaseSuccess;
result.m_databaseConnectionIdentifier = connection.identifier();
result.m_databaseInfo = std::make_unique<IDBDatabaseInfo>(connection.database().info());
IDBResultData IDBResultData::openDatabaseUpgradeNeeded(const IDBResourceIdentifier& requestIdentifier, IDBServer::UniqueIDBDatabaseTransaction& transaction)
{
- IDBResultData result(requestIdentifier);
+ IDBResultData result { requestIdentifier };
result.m_type = IDBResultType::OpenDatabaseUpgradeNeeded;
result.m_databaseConnectionIdentifier = transaction.databaseConnection().identifier();
result.m_databaseInfo = std::make_unique<IDBDatabaseInfo>(transaction.databaseConnection().database().info());
IDBResultData IDBResultData::deleteDatabaseSuccess(const IDBResourceIdentifier& requestIdentifier, const IDBDatabaseInfo& info)
{
- IDBResultData result(IDBResultType::DeleteDatabaseSuccess, requestIdentifier);
+ IDBResultData result {IDBResultType::DeleteDatabaseSuccess, requestIdentifier };
result.m_databaseInfo = std::make_unique<IDBDatabaseInfo>(info);
return result;
}
IDBResultData IDBResultData::putOrAddSuccess(const IDBResourceIdentifier& requestIdentifier, const IDBKeyData& resultKey)
{
- IDBResultData result(IDBResultType::PutOrAddSuccess, requestIdentifier);
+ IDBResultData result { IDBResultType::PutOrAddSuccess, requestIdentifier };
result.m_resultKey = std::make_unique<IDBKeyData>(resultKey);
return result;
}
IDBResultData IDBResultData::getRecordSuccess(const IDBResourceIdentifier& requestIdentifier, const IDBGetResult& getResult)
{
- IDBResultData result(IDBResultType::GetRecordSuccess, requestIdentifier);
+ IDBResultData result { IDBResultType::GetRecordSuccess, requestIdentifier };
result.m_getResult = std::make_unique<IDBGetResult>(getResult);
return result;
}
IDBResultData IDBResultData::getAllRecordsSuccess(const IDBResourceIdentifier& requestIdentifier, const IDBGetAllResult& getAllResult)
{
- IDBResultData result(IDBResultType::GetAllRecordsSuccess, requestIdentifier);
+ IDBResultData result { IDBResultType::GetAllRecordsSuccess, requestIdentifier };
result.m_getAllResult = std::make_unique<IDBGetAllResult>(getAllResult);
return result;
}
IDBResultData IDBResultData::getCountSuccess(const IDBResourceIdentifier& requestIdentifier, uint64_t count)
{
- IDBResultData result(IDBResultType::GetRecordSuccess, requestIdentifier);
+ IDBResultData result { IDBResultType::GetRecordSuccess, requestIdentifier };
result.m_resultInteger = count;
return result;
}
IDBResultData IDBResultData::openCursorSuccess(const IDBResourceIdentifier& requestIdentifier, const IDBGetResult& getResult)
{
- IDBResultData result(IDBResultType::OpenCursorSuccess, requestIdentifier);
+ IDBResultData result { IDBResultType::OpenCursorSuccess, requestIdentifier };
result.m_getResult = std::make_unique<IDBGetResult>(getResult);
return result;
}
IDBResultData IDBResultData::iterateCursorSuccess(const IDBResourceIdentifier& requestIdentifier, const IDBGetResult& getResult)
{
- IDBResultData result(IDBResultType::IterateCursorSuccess, requestIdentifier);
+ IDBResultData result { IDBResultType::IterateCursorSuccess, requestIdentifier };
result.m_getResult = std::make_unique<IDBGetResult>(getResult);
return result;
}
git://git.webkit.org / WebKit-https.git / commitdiff