void UniqueIDBDatabaseTransaction::deleteIndex(const IDBRequestData& requestData, uint64_t objectStoreIdentifier, const String& indexName)
{
LOG(IndexedDB, "UniqueIDBDatabaseTransaction::deleteIndex");
ASSERT(isVersionChange());
ASSERT(m_transactionInfo.identifier() == requestData.transactionIdentifier());
RefPtr<UniqueIDBDatabaseTransaction> protectedThis(this);
m_databaseConnection->database().deleteIndex(*this, objectStoreIdentifier, indexName, [this, protectedThis, requestData](const IDBError& error) {
LOG(IndexedDB, "UniqueIDBDatabaseTransaction::createIndex (callback)");
if (error.isNull())
m_databaseConnection->didDeleteIndex(IDBResultData::deleteIndexSuccess(requestData.requestIdentifier()));
else
m_databaseConnection->didDeleteIndex(IDBResultData::error(requestData.requestIdentifier(), error));
});
}
void UniqueIDBDatabaseTransaction::createIndex(const IDBRequestData& requestData, const IDBIndexInfo& info)
{
LOG(IndexedDB, "UniqueIDBDatabaseTransaction::createIndex");
ASSERT(isVersionChange());
ASSERT(m_transactionInfo.identifier() == requestData.transactionIdentifier());
RefPtr<UniqueIDBDatabaseTransaction> protectedThis(this);
m_databaseConnection->database().createIndex(*this, info, [this, protectedThis, requestData](const IDBError& error) {
LOG(IndexedDB, "UniqueIDBDatabaseTransaction::createIndex (callback)");
if (error.isNull())
m_databaseConnection->didCreateIndex(IDBResultData::createIndexSuccess(requestData.requestIdentifier()));
else
m_databaseConnection->didCreateIndex(IDBResultData::error(requestData.requestIdentifier(), error));
});
}
void IDBServer::deleteDatabase(const IDBRequestData& requestData)
{
LOG(IndexedDB, "IDBServer::deleteDatabase - %s", requestData.databaseIdentifier().debugString().utf8().data());
auto connection = m_connectionMap.get(requestData.requestIdentifier().connectionIdentifier());
if (!connection) {
// If the connection back to the client is gone, there's no way to delete the database as
// well as no way to message back failure.
return;
}
// FIXME: During bringup of modern IDB, the database deletion is a no-op, and is
// immediately reported back to the WebProcess as failure.
auto result = IDBResultData::error(requestData.requestIdentifier(), IDBError(IDBExceptionCode::Unknown));
connection->didDeleteDatabase(result);
}
void IDBServer::deleteDatabase(const IDBRequestData& requestData)
{
LOG(IndexedDB, "IDBServer::deleteDatabase - %s", requestData.databaseIdentifier().debugString().utf8().data());
auto connection = m_connectionMap.get(requestData.requestIdentifier().connectionIdentifier());
if (!connection) {
// If the connection back to the client is gone, there's no way to delete the database as
// well as no way to message back failure.
return;
}
auto* database = m_uniqueIDBDatabaseMap.get(requestData.databaseIdentifier());
if (!database) {
connection->didDeleteDatabase(IDBResultData::deleteDatabaseSuccess(requestData.requestIdentifier(), IDBDatabaseInfo(requestData.databaseIdentifier().databaseName(), 0)));
return;
}
database->handleDelete(*connection, requestData);
}
void IDBServer::openDBRequestCancelled(const IDBRequestData& requestData)
{
LOG(IndexedDB, "IDBServer::openDBRequestCancelled");
ASSERT(isMainThread());
auto* uniqueIDBDatabase = m_uniqueIDBDatabaseMap.get(requestData.databaseIdentifier());
if (!uniqueIDBDatabase)
return;
uniqueIDBDatabase->openDBRequestCancelled(requestData.requestIdentifier());
}
void IDBServer::openDatabase(const IDBRequestData& requestData)
{
LOG(IndexedDB, "IDBServer::openDatabase");
auto& uniqueIDBDatabase = getOrCreateUniqueIDBDatabase(requestData.databaseIdentifier());
auto connection = m_connectionMap.get(requestData.requestIdentifier().connectionIdentifier());
if (!connection) {
// If the connection back to the client is gone, there's no way to open the database as
// well as no way to message back failure.
return;
}
uniqueIDBDatabase.openDatabaseConnection(*connection, requestData);
}
void UniqueIDBDatabaseTransaction::clearObjectStore(const IDBRequestData& requestData, uint64_t objectStoreIdentifier)
{
LOG(IndexedDB, "UniqueIDBDatabaseTransaction::clearObjectStore");
ASSERT(m_transactionInfo.identifier() == requestData.transactionIdentifier());
RefPtr<UniqueIDBDatabaseTransaction> protectedThis(this);
m_databaseConnection->database().clearObjectStore(*this, objectStoreIdentifier, [this, protectedThis, requestData](const IDBError& error) {
LOG(IndexedDB, "UniqueIDBDatabaseTransaction::clearObjectStore (callback)");
if (error.isNull())
m_databaseConnection->didClearObjectStore(IDBResultData::clearObjectStoreSuccess(requestData.requestIdentifier()));
else
m_databaseConnection->didClearObjectStore(IDBResultData::error(requestData.requestIdentifier(), error));
});
}
void IDBServer::deleteDatabase(const IDBRequestData& requestData)
{
LOG(IndexedDB, "IDBServer::deleteDatabase - %s", requestData.databaseIdentifier().debugString().utf8().data());
ASSERT(isMainThread());
auto connection = m_connectionMap.get(requestData.requestIdentifier().connectionIdentifier());
if (!connection) {
// If the connection back to the client is gone, there's no way to delete the database as
// well as no way to message back failure.
return;
}
auto* database = m_uniqueIDBDatabaseMap.get(requestData.databaseIdentifier());
if (!database)
database = &getOrCreateUniqueIDBDatabase(requestData.databaseIdentifier());
database->handleDelete(*connection, requestData);
}
void UniqueIDBDatabaseTransaction::iterateCursor(const IDBRequestData& requestData, const IDBKeyData& key, unsigned long count)
{
LOG(IndexedDB, "UniqueIDBDatabaseTransaction::iterateCursor");
ASSERT(m_transactionInfo.identifier() == requestData.transactionIdentifier());
RefPtr<UniqueIDBDatabaseTransaction> protectedThis(this);
m_databaseConnection->database().iterateCursor(requestData, key, count, [this, protectedThis, requestData](const IDBError& error, const IDBGetResult& result) {
LOG(IndexedDB, "UniqueIDBDatabaseTransaction::iterateCursor (callback)");
if (error.isNull())
m_databaseConnection->connectionToClient().didIterateCursor(IDBResultData::iterateCursorSuccess(requestData.requestIdentifier(), result));
else
m_databaseConnection->connectionToClient().didIterateCursor(IDBResultData::error(requestData.requestIdentifier(), error));
});
}
void UniqueIDBDatabaseTransaction::openCursor(const IDBRequestData& requestData, const IDBCursorInfo& info)
{
LOG(IndexedDB, "UniqueIDBDatabaseTransaction::openCursor");
ASSERT(m_transactionInfo.identifier() == requestData.transactionIdentifier());
RefPtr<UniqueIDBDatabaseTransaction> protectedThis(this);
m_databaseConnection->database().openCursor(requestData, info, [this, protectedThis, requestData](const IDBError& error, const IDBGetResult& result) {
LOG(IndexedDB, "UniqueIDBDatabaseTransaction::openCursor (callback)");
if (error.isNull())
m_databaseConnection->connectionToClient().didOpenCursor(IDBResultData::openCursorSuccess(requestData.requestIdentifier(), result));
else
m_databaseConnection->connectionToClient().didOpenCursor(IDBResultData::error(requestData.requestIdentifier(), error));
});
}
void UniqueIDBDatabaseTransaction::deleteRecord(const IDBRequestData& requestData, const IDBKeyRangeData& keyRangeData)
{
LOG(IndexedDB, "UniqueIDBDatabaseTransaction::deleteRecord");
ASSERT(m_transactionInfo.identifier() == requestData.transactionIdentifier());
RefPtr<UniqueIDBDatabaseTransaction> protectedThis(this);
m_databaseConnection->database().deleteRecord(requestData, keyRangeData, [this, protectedThis, requestData](const IDBError& error) {
LOG(IndexedDB, "UniqueIDBDatabaseTransaction::deleteRecord (callback)");
if (error.isNull())
m_databaseConnection->connectionToClient().didDeleteRecord(IDBResultData::deleteRecordSuccess(requestData.requestIdentifier()));
else
m_databaseConnection->connectionToClient().didDeleteRecord(IDBResultData::error(requestData.requestIdentifier(), error));
});
}
void UniqueIDBDatabaseTransaction::putOrAdd(const IDBRequestData& requestData, const IDBKeyData& keyData, const IDBValue& value, IndexedDB::ObjectStoreOverwriteMode overwriteMode)
{
LOG(IndexedDB, "UniqueIDBDatabaseTransaction::putOrAdd");
ASSERT(!isReadOnly());
ASSERT(m_transactionInfo.identifier() == requestData.transactionIdentifier());
RefPtr<UniqueIDBDatabaseTransaction> protectedThis(this);
m_databaseConnection->database().putOrAdd(requestData, keyData, value, overwriteMode, [this, protectedThis, requestData](const IDBError& error, const IDBKeyData& key) {
LOG(IndexedDB, "UniqueIDBDatabaseTransaction::putOrAdd (callback)");
if (error.isNull())
m_databaseConnection->connectionToClient().didPutOrAdd(IDBResultData::putOrAddSuccess(requestData.requestIdentifier(), key));
else
m_databaseConnection->connectionToClient().didPutOrAdd(IDBResultData::error(requestData.requestIdentifier(), error));
});
}
