IDBTransactionCoordinator.cpp [plain text]
#include "config.h"
#include "IDBTransactionCoordinator.h"
#if ENABLE(INDEXED_DATABASE)
#include "IDBDatabaseBackendImpl.h"
#include "IDBTransactionBackendImpl.h"
namespace WebCore {
PassOwnPtr<IDBTransactionCoordinator> IDBTransactionCoordinator::create()
{
return adoptPtr(new IDBTransactionCoordinator());
}
IDBTransactionCoordinator::IDBTransactionCoordinator()
{
}
IDBTransactionCoordinator::~IDBTransactionCoordinator()
{
}
void IDBTransactionCoordinator::didCreateTransaction(IDBTransactionBackendImpl* transaction)
{
ASSERT(!m_transactions.contains(transaction));
m_transactions.add(transaction, transaction);
}
void IDBTransactionCoordinator::didStartTransaction(IDBTransactionBackendImpl* transaction)
{
ASSERT(m_transactions.contains(transaction));
m_queuedTransactions.add(transaction);
processStartedTransactions();
}
void IDBTransactionCoordinator::didFinishTransaction(IDBTransactionBackendImpl* transaction)
{
ASSERT(m_transactions.contains(transaction));
if (m_queuedTransactions.contains(transaction)) {
ASSERT(!m_startedTransactions.contains(transaction));
m_queuedTransactions.remove(transaction);
} else if (m_startedTransactions.contains(transaction))
m_startedTransactions.remove(transaction);
m_transactions.remove(transaction);
processStartedTransactions();
}
#ifndef NDEBUG
bool IDBTransactionCoordinator::isActive(IDBTransactionBackendImpl* transaction)
{
bool found = false;
if (m_queuedTransactions.contains(transaction))
found = true;
if (m_startedTransactions.contains(transaction)) {
ASSERT(!found);
found = true;
}
ASSERT(found == m_transactions.contains(transaction));
return found;
}
#endif
void IDBTransactionCoordinator::processStartedTransactions()
{
if (m_queuedTransactions.isEmpty())
return;
ASSERT(m_startedTransactions.isEmpty() || (*m_startedTransactions.begin())->mode() != IndexedDB::TransactionVersionChange);
ListHashSet<IDBTransactionBackendImpl*>::const_iterator it = m_queuedTransactions.begin();
while (it != m_queuedTransactions.end()) {
IDBTransactionBackendImpl* transaction = *it;
++it;
if (canRunTransaction(transaction)) {
m_queuedTransactions.remove(transaction);
m_startedTransactions.add(transaction);
transaction->run();
}
}
}
static bool doScopesOverlap(const HashSet<int64_t>& scope1, const HashSet<int64_t>& scope2)
{
for (HashSet<int64_t>::const_iterator it = scope1.begin(); it != scope1.end(); ++it) {
if (scope2.contains(*it))
return true;
}
return false;
}
bool IDBTransactionCoordinator::canRunTransaction(IDBTransactionBackendImpl* transaction)
{
ASSERT(m_queuedTransactions.contains(transaction));
switch (transaction->mode()) {
case IndexedDB::TransactionVersionChange:
ASSERT(m_queuedTransactions.size() == 1);
ASSERT(m_startedTransactions.isEmpty());
return true;
case IndexedDB::TransactionReadOnly:
return true;
case IndexedDB::TransactionReadWrite:
for (HashSet<IDBTransactionBackendImpl*>::const_iterator it = m_startedTransactions.begin(); it != m_startedTransactions.end(); ++it) {
if ((*it)->mode() == IndexedDB::TransactionReadWrite && doScopesOverlap(transaction->scope(), (*it)->scope()))
return false;
}
for (ListHashSet<IDBTransactionBackendImpl*>::const_iterator it = m_queuedTransactions.begin(); *it != transaction; ++it) {
ASSERT(it != m_queuedTransactions.end());
if ((*it)->mode() == IndexedDB::TransactionReadWrite && doScopesOverlap(transaction->scope(), (*it)->scope()))
return false;
}
return true;
}
ASSERT_NOT_REACHED();
return false;
}
};
#endif // ENABLE(INDEXED_DATABASE)