void IDBDatabaseBackendImpl::transactionFinished(PassRefPtr<IDBTransactionBackendInterface> prpTransaction)
{
RefPtr<IDBTransactionBackendInterface> transaction = prpTransaction;
if (transaction->mode() == IDBTransaction::VERSION_CHANGE) {
ASSERT(transaction.get() == m_runningVersionChangeTransaction.get());
m_runningVersionChangeTransaction.clear();
processPendingCalls();
}
}
void IDBDatabaseBackend::openConnection(PassRefPtr<IDBCallbacks> prpCallbacks, PassRefPtr<IDBDatabaseCallbacks> prpDatabaseCallbacks, int64_t transactionId, uint64_t version)
{
RefPtr<IDBCallbacks> callbacks = prpCallbacks;
RefPtr<IDBDatabaseCallbacks> databaseCallbacks = prpDatabaseCallbacks;
m_pendingOpenCalls.append(IDBPendingOpenCall::create(*callbacks, *databaseCallbacks, transactionId, version));
processPendingCalls();
}
void IDBDatabaseBackendImpl::close(PassRefPtr<IDBDatabaseCallbacks> prpCallbacks)
{
RefPtr<IDBDatabaseCallbacks> callbacks = prpCallbacks;
ASSERT(m_databaseCallbacksSet.contains(callbacks));
m_databaseCallbacksSet.remove(callbacks);
if (m_databaseCallbacksSet.size() > 1)
return;
processPendingCalls();
}
void IDBDatabaseBackend::didOpenInternalAsync(const IDBDatabaseMetadata& metadata, bool success)
{
if (!success) {
processPendingOpenCalls(false);
return;
}
m_metadata = metadata;
processPendingCalls();
}
void IDBDatabaseBackend::transactionFinishedAndAbortFired(IDBTransactionBackend* rawTransaction)
{
RefPtr<IDBTransactionBackend> transaction = rawTransaction;
if (transaction->mode() == IndexedDB::TransactionVersionChange) {
// If this was an open-with-version call, there will be a "second
// half" open call waiting for us in processPendingCalls.
// FIXME: When we no longer support setVersion, assert such a thing.
if (m_pendingSecondHalfOpen) {
m_pendingSecondHalfOpen->callbacks()->onError(IDBDatabaseError::create(IDBDatabaseException::AbortError, "Version change transaction was aborted in upgradeneeded event handler."));
m_pendingSecondHalfOpen.release();
}
processPendingCalls();
}
}
void IDBDatabaseBackendImpl::transactionFinishedAndAbortFired(PassRefPtr<IDBTransactionBackendImpl> prpTransaction)
{
RefPtr<IDBTransactionBackendImpl> transaction = prpTransaction;
if (transaction->mode() == IDBTransaction::VERSION_CHANGE) {
// If this was an open-with-version call, there will be a "second
// half" open call waiting for us in processPendingCalls.
// FIXME: When we no longer support setVersion, assert such a thing.
if (m_pendingSecondHalfOpenWithVersion) {
m_pendingSecondHalfOpenWithVersion->callbacks()->onError(IDBDatabaseError::create(IDBDatabaseException::IDB_ABORT_ERR, "Version change transaction was aborted in upgradeneeded event handler."));
m_pendingSecondHalfOpenWithVersion.release();
}
processPendingCalls();
}
}
void IDBDatabaseBackend::close(PassRefPtr<IDBDatabaseCallbacks> prpCallbacks)
{
RefPtr<IDBDatabaseCallbacks> callbacks = prpCallbacks;
ASSERT(m_databaseCallbacksSet.contains(callbacks));
m_databaseCallbacksSet.remove(callbacks);
if (m_pendingSecondHalfOpen && m_pendingSecondHalfOpen->databaseCallbacks() == callbacks) {
m_pendingSecondHalfOpen->callbacks()->onError(IDBDatabaseError::create(IDBDatabaseException::AbortError, "The connection was closed."));
m_pendingSecondHalfOpen.release();
}
if (connectionCount() > 1)
return;
// processPendingCalls allows the inspector to process a pending open call
// and call close, reentering IDBDatabaseBackend::close. Then the
// backend would be removed both by the inspector closing its connection, and
// by the connection that first called close.
// To avoid that situation, don't proceed in case of reentrancy.
if (m_closingConnection)
return;
TemporaryChange<bool> closingConnection(m_closingConnection, true);
processPendingCalls();
// FIXME: Add a test for the m_pendingOpenCalls cases below.
if (!connectionCount() && !m_pendingOpenCalls.size() && !m_pendingDeleteCalls.size()) {
TransactionMap transactions(m_transactions);
RefPtr<IDBDatabaseError> error = IDBDatabaseError::create(IDBDatabaseException::UnknownError, "Connection is closing.");
for (TransactionMap::const_iterator::Values it = transactions.values().begin(), end = transactions.values().end(); it != end; ++it)
(*it)->abort(error);
ASSERT(m_transactions.isEmpty());
m_serverConnection->close();
// This check should only be false in unit tests.
ASSERT(m_factory);
if (m_factory)
m_factory->removeIDBDatabaseBackend(m_identifier);
}
}
void IDBDatabaseBackendImpl::close(PassRefPtr<IDBDatabaseCallbacks> prpCallbacks)
{
RefPtr<IDBDatabaseCallbacks> callbacks = prpCallbacks;
ASSERT(m_databaseCallbacksSet.contains(callbacks));
m_databaseCallbacksSet.remove(callbacks);
if (m_pendingSecondHalfOpenWithVersion && m_pendingSecondHalfOpenWithVersion->databaseCallbacks() == callbacks) {
m_pendingSecondHalfOpenWithVersion->callbacks()->onError(IDBDatabaseError::create(IDBDatabaseException::IDB_ABORT_ERR, "The connection was closed."));
m_pendingSecondHalfOpenWithVersion.release();
}
if (connectionCount() > 1)
return;
// processPendingCalls allows the inspector to process a pending open call
// and call close, reentering IDBDatabaseBackendImpl::close. Then the
// backend would be removed both by the inspector closing its connection, and
// by the connection that first called close.
// To avoid that situation, don't proceed in case of reentrancy.
if (m_closingConnection)
return;
m_closingConnection = true;
processPendingCalls();
// FIXME: Add a test for the m_pendingOpenCalls and m_pendingOpenWithVersionCalls cases below.
if (!connectionCount() && !m_pendingOpenCalls.size() && !m_pendingOpenWithVersionCalls.size() && !m_pendingDeleteCalls.size()) {
TransactionSet transactions(m_transactions);
for (TransactionSet::const_iterator it = transactions.begin(); it != transactions.end(); ++it)
(*it)->abort();
ASSERT(m_transactions.isEmpty());
m_backingStore.clear();
// This check should only be false in tests.
if (m_factory)
m_factory->removeIDBDatabaseBackend(m_identifier);
}
m_closingConnection = false;
}
void IDBDatabaseBackend::transactionFinishedAndCompleteFired(IDBTransactionBackend* rawTransaction)
{
RefPtr<IDBTransactionBackend> transaction = rawTransaction;
if (transaction->mode() == IndexedDB::TransactionVersionChange)
processPendingCalls();
}
void IDBDatabaseBackendImpl::transactionFinishedAndCompleteFired(PassRefPtr<IDBTransactionBackendImpl> prpTransaction)
{
RefPtr<IDBTransactionBackendImpl> transaction = prpTransaction;
if (transaction->mode() == IDBTransaction::VERSION_CHANGE)
processPendingCalls();
}