void IDBDatabase::deleteObjectStore(const String& objectStoreName, ExceptionCodeWithMessage& ec)
{
LOG(IndexedDB, "IDBDatabase::deleteObjectStore");
ASSERT(currentThread() == originThreadID());
if (!m_versionChangeTransaction) {
ec.code = IDBDatabaseException::InvalidStateError;
ec.message = ASCIILiteral("Failed to execute 'deleteObjectStore' on 'IDBDatabase': The database is not running a version change transaction.");
return;
}
if (!m_versionChangeTransaction->isActive()) {
ec.code = IDBDatabaseException::TransactionInactiveError;
return;
}
if (!m_info.hasObjectStore(objectStoreName)) {
ec.code = IDBDatabaseException::NotFoundError;
ec.message = ASCIILiteral("Failed to execute 'deleteObjectStore' on 'IDBDatabase': The specified object store was not found.");
return;
}
m_info.deleteObjectStore(objectStoreName);
m_versionChangeTransaction->deleteObjectStore(objectStoreName);
}
void IDBDatabase::didCommitOrAbortTransaction(IDBTransaction& transaction)
{
LOG(IndexedDB, "IDBDatabase::didCommitOrAbortTransaction %s", transaction.info().identifier().loggingString().utf8().data());
ASSERT(currentThread() == originThreadID());
if (m_versionChangeTransaction == &transaction)
m_versionChangeTransaction = nullptr;
#ifndef NDBEBUG
unsigned count = 0;
if (m_activeTransactions.contains(transaction.info().identifier()))
++count;
if (m_committingTransactions.contains(transaction.info().identifier()))
++count;
if (m_abortingTransactions.contains(transaction.info().identifier()))
++count;
ASSERT(count == 1);
#endif
m_activeTransactions.remove(transaction.info().identifier());
m_committingTransactions.remove(transaction.info().identifier());
m_abortingTransactions.remove(transaction.info().identifier());
if (m_closePending)
maybeCloseInServer();
}
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 IDBOpenDBRequest::requestBlocked(uint64_t oldVersion, uint64_t newVersion)
{
ASSERT(currentThread() == originThreadID());
LOG(IndexedDB, "IDBOpenDBRequest::requestBlocked");
enqueueEvent(IDBVersionChangeEvent::create(oldVersion, newVersion, eventNames().blockedEvent));
}
ExceptionOr<Ref<IDBObjectStore>> IDBDatabase::createObjectStore(const String& name, ObjectStoreParameters&& parameters)
{
LOG(IndexedDB, "IDBDatabase::createObjectStore - (%s %s)", m_info.name().utf8().data(), name.utf8().data());
ASSERT(currentThread() == originThreadID());
ASSERT(!m_versionChangeTransaction || m_versionChangeTransaction->isVersionChange());
if (!m_versionChangeTransaction)
return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'createObjectStore' on 'IDBDatabase': The database is not running a version change transaction.") };
if (!m_versionChangeTransaction->isActive())
return Exception { IDBDatabaseException::TransactionInactiveError };
if (m_info.hasObjectStore(name))
return Exception { IDBDatabaseException::ConstraintError, ASCIILiteral("Failed to execute 'createObjectStore' on 'IDBDatabase': An object store with the specified name already exists.") };
auto& keyPath = parameters.keyPath;
if (keyPath && !isIDBKeyPathValid(keyPath.value()))
return Exception { IDBDatabaseException::SyntaxError, ASCIILiteral("Failed to execute 'createObjectStore' on 'IDBDatabase': The keyPath option is not a valid key path.") };
if (keyPath && parameters.autoIncrement && ((WTF::holds_alternative<String>(keyPath.value()) && WTF::get<String>(keyPath.value()).isEmpty()) || WTF::holds_alternative<Vector<String>>(keyPath.value())))
return Exception { IDBDatabaseException::InvalidAccessError, ASCIILiteral("Failed to execute 'createObjectStore' on 'IDBDatabase': The autoIncrement option was set but the keyPath option was empty or an array.") };
// Install the new ObjectStore into the connection's metadata.
auto info = m_info.createNewObjectStore(name, WTFMove(keyPath), parameters.autoIncrement);
// Create the actual IDBObjectStore from the transaction, which also schedules the operation server side.
return m_versionChangeTransaction->createObjectStore(info);
}
RefPtr<WebCore::IDBTransaction> IDBDatabase::transaction(const String& objectStore, const String& mode, ExceptionCodeWithMessage& ec)
{
ASSERT(currentThread() == originThreadID());
Vector<String> objectStores(1);
objectStores[0] = objectStore;
return transaction(objectStores, mode, ec);
}
bool IDBDatabase::canSuspendForDocumentSuspension() const
{
ASSERT(currentThread() == originThreadID());
// FIXME: This value will sometimes be false when database operations are actually in progress.
// Such database operations do not yet exist.
return true;
}
void IDBDatabase::didDeleteIndexInfo(const IDBIndexInfo& info)
{
ASSERT(currentThread() == originThreadID());
auto* objectStore = m_info.infoForExistingObjectStore(info.objectStoreIdentifier());
ASSERT(objectStore);
objectStore->deleteIndex(info.name());
}
void IDBOpenDBRequest::versionChangeTransactionDidFinish()
{
ASSERT(currentThread() == originThreadID());
// 3.3.7 "versionchange" transaction steps
// When the transaction is finished, after firing complete/abort on the transaction, immediately set request's transaction property to null.
m_shouldExposeTransactionToDOM = false;
}
void IDBDatabase::close()
{
LOG(IndexedDB, "IDBDatabase::close - %" PRIu64, m_databaseConnectionIdentifier);
ASSERT(currentThread() == originThreadID());
m_closePending = true;
maybeCloseInServer();
}
IDBDatabase::~IDBDatabase()
{
ASSERT(currentThread() == originThreadID());
if (!m_closedInServer)
m_connectionProxy->databaseConnectionClosed(*this);
m_connectionProxy->unregisterDatabaseConnection(*this);
}
void IDBDatabase::renameObjectStore(IDBObjectStore& objectStore, const String& newName)
{
ASSERT(currentThread() == originThreadID());
ASSERT(m_versionChangeTransaction);
ASSERT(m_info.hasObjectStore(objectStore.info().name()));
m_info.renameObjectStore(objectStore.info().identifier(), newName);
m_versionChangeTransaction->renameObjectStore(objectStore, newName);
}
RefPtr<DOMStringList> IDBDatabase::objectStoreNames() const
{
ASSERT(currentThread() == originThreadID());
RefPtr<DOMStringList> objectStoreNames = DOMStringList::create();
for (auto& name : m_info.objectStoreNames())
objectStoreNames->append(name);
objectStoreNames->sort();
return objectStoreNames;
}
void IDBDatabase::willCommitTransaction(IDBTransaction& transaction)
{
LOG(IndexedDB, "IDBDatabase::willCommitTransaction %s", transaction.info().identifier().loggingString().utf8().data());
ASSERT(currentThread() == originThreadID());
auto refTransaction = m_activeTransactions.take(transaction.info().identifier());
ASSERT(refTransaction);
m_committingTransactions.set(transaction.info().identifier(), WTFMove(refTransaction));
}
void IDBOpenDBRequest::onSuccess(const IDBResultData& resultData)
{
LOG(IndexedDB, "IDBOpenDBRequest::onSuccess()");
ASSERT(currentThread() == originThreadID());
setResult(IDBDatabase::create(*scriptExecutionContext(), connectionProxy(), resultData));
m_isDone = true;
enqueueEvent(IDBRequestCompletionEvent::create(eventNames().successEvent, false, false, *this));
}
void IDBDatabase::renameIndex(IDBIndex& index, const String& newName)
{
ASSERT(currentThread() == originThreadID());
ASSERT(m_versionChangeTransaction);
ASSERT(m_info.hasObjectStore(index.objectStore().info().name()));
ASSERT(m_info.infoForExistingObjectStore(index.objectStore().info().name())->hasIndex(index.info().name()));
m_info.infoForExistingObjectStore(index.objectStore().info().name())->infoForExistingIndex(index.info().identifier())->rename(newName);
m_versionChangeTransaction->renameIndex(index, newName);
}
bool IDBOpenDBRequest::dispatchEvent(Event& event)
{
ASSERT(currentThread() == originThreadID());
bool result = IDBRequest::dispatchEvent(event);
if (m_transaction && m_transaction->isVersionChange() && (event.type() == eventNames().errorEvent || event.type() == eventNames().successEvent))
m_transaction->database().connectionProxy().didFinishHandlingVersionChangeTransaction(m_transaction->database().databaseConnectionIdentifier(), *m_transaction);
return result;
}
void IDBDatabase::didCommitTransaction(IDBTransaction& transaction)
{
LOG(IndexedDB, "IDBDatabase::didCommitTransaction %s", transaction.info().identifier().loggingString().utf8().data());
ASSERT(currentThread() == originThreadID());
if (m_versionChangeTransaction == &transaction)
m_info.setVersion(transaction.info().newVersion());
didCommitOrAbortTransaction(transaction);
}
bool IDBDatabase::hasPendingActivity() const
{
ASSERT(currentThread() == originThreadID() || mayBeGCThread());
if (m_closedInServer)
return false;
if (!m_activeTransactions.isEmpty() || !m_committingTransactions.isEmpty() || !m_abortingTransactions.isEmpty())
return true;
return hasEventListeners(m_eventNames.abortEvent) || hasEventListeners(m_eventNames.errorEvent) || hasEventListeners(m_eventNames.versionchangeEvent);
}
bool IDBDatabase::dispatchEvent(Event& event)
{
LOG(IndexedDB, "IDBDatabase::dispatchEvent (%" PRIu64 ") (%p)", m_databaseConnectionIdentifier, this);
ASSERT(currentThread() == originThreadID());
bool result = EventTargetWithInlineData::dispatchEvent(event);
if (event.isVersionChangeEvent() && event.type() == m_eventNames.versionchangeEvent)
connectionProxy().didFireVersionChangeEvent(m_databaseConnectionIdentifier, downcast<IDBVersionChangeEvent>(event).requestIdentifier());
return result;
}
void IDBDatabase::didStartTransaction(IDBTransaction& transaction)
{
LOG(IndexedDB, "IDBDatabase::didStartTransaction %s", transaction.info().identifier().loggingString().utf8().data());
ASSERT(!m_versionChangeTransaction);
ASSERT(currentThread() == originThreadID());
// It is possible for the client to have aborted a transaction before the server replies back that it has started.
if (m_abortingTransactions.contains(transaction.info().identifier()))
return;
m_activeTransactions.set(transaction.info().identifier(), &transaction);
}
RefPtr<WebCore::IDBTransaction> IDBDatabase::transaction(const Vector<String>& objectStores, const String& modeString, ExceptionCodeWithMessage& ec)
{
LOG(IndexedDB, "IDBDatabase::transaction");
ASSERT(currentThread() == originThreadID());
if (m_closePending) {
ec.code = IDBDatabaseException::InvalidStateError;
ec.message = ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': The database connection is closing.");
return nullptr;
}
if (objectStores.isEmpty()) {
ec.code = IDBDatabaseException::InvalidAccessError;
ec.message = ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': The storeNames parameter was empty.");
return nullptr;
}
IndexedDB::TransactionMode mode = IDBTransaction::stringToMode(modeString, ec.code);
if (ec.code) {
ec.message = makeString(ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': The mode provided ('"), modeString, ASCIILiteral("') is not one of 'readonly' or 'readwrite'."));
return nullptr;
}
if (mode != IndexedDB::TransactionMode::ReadOnly && mode != IndexedDB::TransactionMode::ReadWrite) {
ec.code = TypeError;
return nullptr;
}
if (m_versionChangeTransaction && !m_versionChangeTransaction->isFinishedOrFinishing()) {
ec.code = IDBDatabaseException::InvalidStateError;
ec.message = ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': A version change transaction is running.");
return nullptr;
}
for (auto& objectStoreName : objectStores) {
if (m_info.hasObjectStore(objectStoreName))
continue;
ec.code = IDBDatabaseException::NotFoundError;
ec.message = ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': One of the specified object stores was not found.");
return nullptr;
}
auto info = IDBTransactionInfo::clientTransaction(m_connectionProxy.get(), objectStores, mode);
auto transaction = IDBTransaction::create(*this, info);
LOG(IndexedDB, "IDBDatabase::transaction - Added active transaction %s", info.identifier().loggingString().utf8().data());
m_activeTransactions.set(info.identifier(), &transaction.get());
return adoptRef(&transaction.leakRef());
}
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 IDBOpenDBRequest::fireSuccessAfterVersionChangeCommit()
{
LOG(IndexedDB, "IDBOpenDBRequest::fireSuccessAfterVersionChangeCommit() - %s", resourceIdentifier().loggingString().utf8().data());
ASSERT(currentThread() == originThreadID());
ASSERT(hasPendingActivity());
m_transaction->addRequest(*this);
auto event = IDBRequestCompletionEvent::create(eventNames().successEvent, false, false, *this);
m_openDatabaseSuccessEvent = &event.get();
enqueueEvent(WTFMove(event));
}
void IDBOpenDBRequest::fireErrorAfterVersionChangeCompletion()
{
LOG(IndexedDB, "IDBOpenDBRequest::fireErrorAfterVersionChangeCompletion() - %s", resourceIdentifier().loggingString().utf8().data());
ASSERT(currentThread() == originThreadID());
ASSERT(hasPendingActivity());
IDBError idbError(IDBDatabaseException::AbortError);
m_domError = DOMError::create(idbError.name(), idbError.message());
setResultToUndefined();
m_transaction->addRequest(*this);
enqueueEvent(IDBRequestCompletionEvent::create(eventNames().errorEvent, true, true, *this));
}
void IDBDatabase::didAbortTransaction(IDBTransaction& transaction)
{
LOG(IndexedDB, "IDBDatabase::didAbortTransaction %s", transaction.info().identifier().loggingString().utf8().data());
ASSERT(currentThread() == originThreadID());
if (transaction.isVersionChange()) {
ASSERT(transaction.originalDatabaseInfo());
ASSERT(m_info.version() == transaction.originalDatabaseInfo()->version());
m_closePending = true;
maybeCloseInServer();
}
didCommitOrAbortTransaction(transaction);
}
ExceptionOr<Ref<IDBTransaction>> IDBDatabase::transaction(StringOrVectorOfStrings&& storeNames, IDBTransactionMode mode)
{
LOG(IndexedDB, "IDBDatabase::transaction");
ASSERT(currentThread() == originThreadID());
if (m_closePending)
return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': The database connection is closing.") };
Vector<String> objectStores;
if (WTF::holds_alternative<Vector<String>>(storeNames))
objectStores = WTFMove(WTF::get<Vector<String>>(storeNames));
else
objectStores.append(WTFMove(WTF::get<String>(storeNames)));
if (objectStores.isEmpty())
return Exception { IDBDatabaseException::InvalidAccessError, ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': The storeNames parameter was empty.") };
if (mode != IDBTransactionMode::Readonly && mode != IDBTransactionMode::Readwrite)
return Exception { TypeError };
if (m_versionChangeTransaction && !m_versionChangeTransaction->isFinishedOrFinishing())
return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': A version change transaction is running.") };
// It is valid for javascript to pass in a list of object store names with the same name listed twice,
// so we need to put them all in a set to get a unique list.
HashSet<String> objectStoreSet;
for (auto& objectStore : objectStores)
objectStoreSet.add(objectStore);
objectStores.clear();
copyToVector(objectStoreSet, objectStores);
for (auto& objectStoreName : objectStores) {
if (m_info.hasObjectStore(objectStoreName))
continue;
return Exception { IDBDatabaseException::NotFoundError, ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': One of the specified object stores was not found.") };
}
auto info = IDBTransactionInfo::clientTransaction(m_connectionProxy.get(), objectStores, mode);
auto transaction = IDBTransaction::create(*this, info);
LOG(IndexedDB, "IDBDatabase::transaction - Added active transaction %s", info.identifier().loggingString().utf8().data());
m_activeTransactions.set(info.identifier(), transaction.ptr());
return WTFMove(transaction);
}
void IDBDatabase::fireVersionChangeEvent(const IDBResourceIdentifier& requestIdentifier, uint64_t requestedVersion)
{
uint64_t currentVersion = m_info.version();
LOG(IndexedDB, "IDBDatabase::fireVersionChangeEvent - current version %" PRIu64 ", requested version %" PRIu64 ", connection %" PRIu64 " (%p)", currentVersion, requestedVersion, m_databaseConnectionIdentifier, this);
ASSERT(currentThread() == originThreadID());
if (!scriptExecutionContext() || m_closePending) {
connectionProxy().didFireVersionChangeEvent(m_databaseConnectionIdentifier, requestIdentifier);
return;
}
Ref<Event> event = IDBVersionChangeEvent::create(requestIdentifier, currentVersion, requestedVersion, m_eventNames.versionchangeEvent);
event->setTarget(this);
scriptExecutionContext()->eventQueue().enqueueEvent(WTFMove(event));
}
Ref<IDBTransaction> IDBDatabase::startVersionChangeTransaction(const IDBTransactionInfo& info, IDBOpenDBRequest& request)
{
LOG(IndexedDB, "IDBDatabase::startVersionChangeTransaction %s", info.identifier().loggingString().utf8().data());
ASSERT(currentThread() == originThreadID());
ASSERT(!m_versionChangeTransaction);
ASSERT(info.mode() == IDBTransactionMode::Versionchange);
ASSERT(!m_closePending);
ASSERT(scriptExecutionContext());
Ref<IDBTransaction> transaction = IDBTransaction::create(*this, info, request);
m_versionChangeTransaction = &transaction.get();
m_activeTransactions.set(transaction->info().identifier(), &transaction.get());
return transaction;
}
RefPtr<WebCore::IDBObjectStore> IDBDatabase::createObjectStore(const String& name, const IDBKeyPath& keyPath, bool autoIncrement, ExceptionCodeWithMessage& ec)
{
LOG(IndexedDB, "IDBDatabase::createObjectStore - (%s %s)", m_info.name().utf8().data(), name.utf8().data());
ASSERT(currentThread() == originThreadID());
ASSERT(!m_versionChangeTransaction || m_versionChangeTransaction->isVersionChange());
if (!m_versionChangeTransaction) {
ec.code = IDBDatabaseException::InvalidStateError;
ec.message = ASCIILiteral("Failed to execute 'createObjectStore' on 'IDBDatabase': The database is not running a version change transaction.");
return nullptr;
}
if (!m_versionChangeTransaction->isActive()) {
ec.code = IDBDatabaseException::TransactionInactiveError;
return nullptr;
}
if (m_info.hasObjectStore(name)) {
ec.code = IDBDatabaseException::ConstraintError;
ec.message = ASCIILiteral("Failed to execute 'createObjectStore' on 'IDBDatabase': An object store with the specified name already exists.");
return nullptr;
}
if (!keyPath.isNull() && !keyPath.isValid()) {
ec.code = IDBDatabaseException::SyntaxError;
ec.message = ASCIILiteral("Failed to execute 'createObjectStore' on 'IDBDatabase': The keyPath option is not a valid key path.");
return nullptr;
}
if (autoIncrement && !keyPath.isNull()) {
if ((keyPath.type() == IDBKeyPath::Type::String && keyPath.string().isEmpty()) || keyPath.type() == IDBKeyPath::Type::Array) {
ec.code = IDBDatabaseException::InvalidAccessError;
ec.message = ASCIILiteral("Failed to execute 'createObjectStore' on 'IDBDatabase': The autoIncrement option was set but the keyPath option was empty or an array.");
return nullptr;
}
}
// Install the new ObjectStore into the connection's metadata.
IDBObjectStoreInfo info = m_info.createNewObjectStore(name, keyPath, autoIncrement);
// Create the actual IDBObjectStore from the transaction, which also schedules the operation server side.
Ref<IDBObjectStore> objectStore = m_versionChangeTransaction->createObjectStore(info);
return adoptRef(&objectStore.leakRef());
}
