void IDBOpenDBRequest::onError(const IDBResultData& data)
{
ASSERT(currentThread() == originThreadID());
m_domError = DOMError::create(data.error().name(), data.error().message());
enqueueEvent(IDBRequestCompletionEvent::create(eventNames().errorEvent, true, true, *this));
}
void IDBTransaction::didGetRecordOnServer(IDBRequest& request, const IDBResultData& resultData)
{
LOG(IndexedDB, "IDBTransaction::didGetRecordOnServer");
if (resultData.type() == IDBResultType::Error) {
request.requestCompleted(resultData);
return;
}
ASSERT(resultData.type() == IDBResultType::GetRecordSuccess);
const IDBGetResult& result = resultData.getResult();
if (request.sourceIndexIdentifier() && request.requestedIndexRecordType() == IndexedDB::IndexRecordType::Key) {
if (!result.keyData().isNull())
request.setResult(&result.keyData());
else
request.setResultToUndefined();
} else {
if (resultData.getResult().valueBuffer().data())
request.setResultToStructuredClone(resultData.getResult().valueBuffer());
else
request.setResultToUndefined();
}
request.requestCompleted(resultData);
}
IDBDatabase::IDBDatabase(ScriptExecutionContext& context, IDBConnectionToServer& connection, const IDBResultData& resultData)
: WebCore::IDBDatabase(&context)
, m_serverConnection(connection)
, m_info(resultData.databaseInfo())
, m_databaseConnectionIdentifier(resultData.databaseConnectionIdentifier())
{
suspendIfNeeded();
relaxAdoptionRequirement();
m_serverConnection->registerDatabaseConnection(*this);
}
IDBDatabase::IDBDatabase(ScriptExecutionContext& context, IDBClient::IDBConnectionProxy& connectionProxy, const IDBResultData& resultData)
: IDBActiveDOMObject(&context)
, m_connectionProxy(connectionProxy)
, m_info(resultData.databaseInfo())
, m_databaseConnectionIdentifier(resultData.databaseConnectionIdentifier())
{
LOG(IndexedDB, "IDBDatabase::IDBDatabase - Creating database %s with version %" PRIu64 " connection %" PRIu64 " (%p)", m_info.name().utf8().data(), m_info.version(), m_databaseConnectionIdentifier, this);
suspendIfNeeded();
m_connectionProxy->registerDatabaseConnection(*this);
}
IDBDatabase::IDBDatabase(ScriptExecutionContext& context, IDBConnectionToServer& connection, const IDBResultData& resultData)
: WebCore::IDBDatabase(&context)
, m_serverConnection(connection)
, m_info(resultData.databaseInfo())
, m_databaseConnectionIdentifier(resultData.databaseConnectionIdentifier())
{
LOG(IndexedDB, "IDBDatabase::IDBDatabase - Creating database %s with version %" PRIu64, m_info.name().utf8().data(), m_info.version());
suspendIfNeeded();
relaxAdoptionRequirement();
m_serverConnection->registerDatabaseConnection(*this);
}
void IDBRequest::didOpenOrIterateCursor(const IDBResultData& resultData)
{
ASSERT(m_pendingCursor);
if (resultData.type() == IDBResultType::IterateCursorSuccess || resultData.type() == IDBResultType::OpenCursorSuccess)
m_pendingCursor->setGetResult(*this, resultData.getResult());
m_result = IDBAny::create(*m_pendingCursor);
m_pendingCursor = nullptr;
requestCompleted(resultData);
}
void IDBOpenDBRequest::requestCompleted(const IDBResultData& data)
{
LOG(IndexedDB, "IDBOpenDBRequest::requestCompleted");
if (!data.error().isNull()) {
LOG(IndexedDB, " with error: (%s) '%s'", data.error().name().utf8().data(), data.error().message().utf8().data());
m_domError = DOMError::create(data.error().name());
enqueueEvent(Event::create(eventNames().errorEvent, true, true));
} else
enqueueEvent(Event::create(eventNames().successEvent, true, true));
}
void IDBConnectionToServer::completeOperation(const IDBResultData& resultData)
{
auto operation = m_activeOperations.take(resultData.requestIdentifier());
ASSERT(operation);
operation->completed(resultData);
}
void IDBTransaction::didCreateIndexOnServer(const IDBResultData& resultData)
{
LOG(IndexedDB, "IDBTransaction::didCreateIndexOnServer");
if (resultData.type() == IDBResultType::CreateIndexSuccess)
return;
ASSERT(resultData.type() == IDBResultType::Error);
// This operation might have failed because the transaction is already aborting.
if (m_state == IndexedDB::TransactionState::Aborting)
return;
// Otherwise, failure to create an index forced abortion of the transaction.
abortDueToFailedRequest(DOMError::create(IDBDatabaseException::getErrorName(resultData.error().code())));
}
void IDBTransaction::didGetCountOnServer(IDBRequest& request, const IDBResultData& resultData)
{
LOG(IndexedDB, "IDBTransaction::didGetCountOnServer");
request.setResult(resultData.resultInteger());
request.requestCompleted(resultData);
}
void IDBTransaction::didPutOrAddOnServer(IDBRequest& request, const IDBResultData& resultData)
{
LOG(IndexedDB, "IDBTransaction::didPutOrAddOnServer");
request.setResult(resultData.resultKey());
request.requestCompleted(resultData);
}
void IDBRequest::requestCompleted(const IDBResultData& resultData)
{
m_idbError = resultData.error();
if (!m_idbError.isNull())
onError();
else
onSuccess();
}
void IDBRequest::didOpenOrIterateCursor(const IDBResultData& resultData)
{
ASSERT(&originThread() == &Thread::current());
ASSERT(m_pendingCursor);
m_result = NullResultType::Empty;
m_resultWrapper = { };
if (resultData.type() == IDBResultType::IterateCursorSuccess || resultData.type() == IDBResultType::OpenCursorSuccess) {
m_pendingCursor->setGetResult(*this, resultData.getResult());
if (resultData.getResult().isDefined())
m_result = m_pendingCursor;
}
m_pendingCursor = nullptr;
completeRequestAndDispatchEvent(resultData);
}
void IDBConnectionToServer::didOpenDatabase(const IDBResultData& resultData)
{
LOG(IndexedDB, "IDBConnectionToServer::didOpenDatabase");
auto request = m_openDBRequestMap.take(resultData.requestIdentifier());
ASSERT(request);
request->requestCompleted(resultData);
}
void IDBOpenDBRequest::onDeleteDatabaseSuccess(const IDBResultData& resultData)
{
uint64_t oldVersion = resultData.databaseInfo().version();
LOG(IndexedDB, "IDBOpenDBRequest::onDeleteDatabaseSuccess() - current version is %" PRIu64, oldVersion);
m_readyState = IDBRequestReadyState::Done;
enqueueEvent(IDBVersionChangeEvent::create(oldVersion, 0, eventNames().successEvent));
}
void IDBOpenDBRequest::requestCompleted(const IDBResultData& data)
{
LOG(IndexedDB, "IDBOpenDBRequest::requestCompleted");
ASSERT(currentThread() == originThreadID());
// If an Open request was completed after the page has navigated, leaving this request
// with a stopped script execution context, we need to message back to the server so it
// doesn't hang waiting on a database connection or transaction that will never exist.
if (m_contextStopped) {
switch (data.type()) {
case IDBResultType::OpenDatabaseSuccess:
connectionProxy().abortOpenAndUpgradeNeeded(data.databaseConnectionIdentifier(), IDBResourceIdentifier::emptyValue());
break;
case IDBResultType::OpenDatabaseUpgradeNeeded:
connectionProxy().abortOpenAndUpgradeNeeded(data.databaseConnectionIdentifier(), data.transactionInfo().identifier());
break;
default:
break;
}
return;
}
switch (data.type()) {
case IDBResultType::Error:
onError(data);
break;
case IDBResultType::OpenDatabaseSuccess:
onSuccess(data);
break;
case IDBResultType::OpenDatabaseUpgradeNeeded:
onUpgradeNeeded(data);
break;
case IDBResultType::DeleteDatabaseSuccess:
onDeleteDatabaseSuccess(data);
break;
default:
RELEASE_ASSERT_NOT_REACHED();
}
}
void IDBRequest::completeRequestAndDispatchEvent(const IDBResultData& resultData)
{
ASSERT(&originThread() == &Thread::current());
m_readyState = ReadyState::Done;
m_idbError = resultData.error();
if (!m_idbError.isNull())
onError();
else
onSuccess();
}
void IDBOpenDBRequest::onDeleteDatabaseSuccess(const IDBResultData& resultData)
{
ASSERT(currentThread() == originThreadID());
uint64_t oldVersion = resultData.databaseInfo().version();
LOG(IndexedDB, "IDBOpenDBRequest::onDeleteDatabaseSuccess() - current version is %" PRIu64, oldVersion);
m_isDone = true;
setResultToUndefined();
enqueueEvent(IDBVersionChangeEvent::create(oldVersion, 0, eventNames().successEvent));
}
void IDBConnectionProxy::completeOperation(const IDBResultData& resultData)
{
RefPtr<TransactionOperation> operation;
{
Locker<Lock> locker(m_transactionOperationLock);
operation = m_activeOperations.take(resultData.requestIdentifier());
}
if (!operation)
return;
operation->performCompleteOnOriginThread(resultData);
}
void IDBConnectionProxy::completeOpenDBRequest(const IDBResultData& resultData)
{
ASSERT(isMainThread());
RefPtr<IDBOpenDBRequest> request;
{
Locker<Lock> locker(m_openDBRequestMapLock);
request = m_openDBRequestMap.get(resultData.requestIdentifier());
}
if (!request)
return;
request->performCallbackOnOriginThread(*request, &IDBOpenDBRequest::requestCompleted, resultData);
}
void IDBOpenDBRequest::requestCompleted(const IDBResultData& data)
{
LOG(IndexedDB, "IDBOpenDBRequest::requestCompleted");
switch (data.type()) {
case IDBResultType::Error:
onError(data);
break;
case IDBResultType::OpenDatabaseSuccess:
onSuccess(data);
break;
case IDBResultType::OpenDatabaseUpgradeNeeded:
onUpgradeNeeded(data);
break;
}
}
void IDBOpenDBRequest::onUpgradeNeeded(const IDBResultData& resultData)
{
Ref<IDBDatabase> database = IDBDatabase::create(*scriptExecutionContext(), connection(), resultData);
Ref<IDBTransaction> transaction = database->startVersionChangeTransaction(resultData.transactionInfo());
ASSERT(transaction->info().mode() == IndexedDB::TransactionMode::VersionChange);
uint64_t oldVersion = database->info().version();
uint64_t newVersion = transaction->info().newVersion();
LOG(IndexedDB, "IDBOpenDBRequest::onUpgradeNeeded() - current version is %" PRIu64 ", new is %" PRIu64, oldVersion, newVersion);
m_result = IDBAny::create(WTF::move(database));
m_readyState = IDBRequestReadyState::Done;
m_transaction = adoptRef(&transaction.leakRef());
enqueueEvent(IDBVersionChangeEvent::create(oldVersion, newVersion, eventNames().upgradeneededEvent));
}
void IDBOpenDBRequest::requestCompleted(const IDBResultData& data)
{
LOG(IndexedDB, "IDBOpenDBRequest::requestCompleted");
switch (data.type()) {
case IDBResultType::Error:
onError(data);
break;
case IDBResultType::OpenDatabaseSuccess:
onSuccess(data);
break;
case IDBResultType::OpenDatabaseUpgradeNeeded:
onUpgradeNeeded(data);
break;
case IDBResultType::DeleteDatabaseSuccess:
onDeleteDatabaseSuccess(data);
break;
default:
RELEASE_ASSERT_NOT_REACHED();
}
}
void IDBOpenDBRequest::onUpgradeNeeded(const IDBResultData& resultData)
{
ASSERT(currentThread() == originThreadID());
Ref<IDBDatabase> database = IDBDatabase::create(*scriptExecutionContext(), connectionProxy(), resultData);
Ref<IDBTransaction> transaction = database->startVersionChangeTransaction(resultData.transactionInfo(), *this);
ASSERT(transaction->info().mode() == IndexedDB::TransactionMode::VersionChange);
ASSERT(transaction->originalDatabaseInfo());
uint64_t oldVersion = transaction->originalDatabaseInfo()->version();
uint64_t newVersion = transaction->info().newVersion();
LOG(IndexedDB, "IDBOpenDBRequest::onUpgradeNeeded() - current version is %" PRIu64 ", new is %" PRIu64, oldVersion, newVersion);
setResult(WTFMove(database));
m_isDone = true;
m_transaction = WTFMove(transaction);
m_transaction->addRequest(*this);
enqueueEvent(IDBVersionChangeEvent::create(oldVersion, newVersion, eventNames().upgradeneededEvent));
}
void IDBTransaction::didDeleteIndexOnServer(const IDBResultData& resultData)
{
LOG(IndexedDB, "IDBTransaction::didDeleteIndexOnServer");
ASSERT_UNUSED(resultData, resultData.type() == IDBResultType::DeleteIndexSuccess || resultData.type() == IDBResultType::Error);
}
void IDBTransaction::didCreateObjectStoreOnServer(const IDBResultData& resultData)
{
LOG(IndexedDB, "IDBTransaction::didCreateObjectStoreOnServer");
ASSERT_UNUSED(resultData, resultData.type() == IDBResultType::CreateObjectStoreSuccess || resultData.type() == IDBResultType::Error);
}
void IDBOpenDBRequest::onError(const IDBResultData& data)
{
m_domError = DOMError::create(data.error().name());
enqueueEvent(Event::create(eventNames().errorEvent, true, true));
}
