SQLTransactionCoordinator.cpp [plain text]
#include "config.h"
#include "SQLTransactionCoordinator.h"
#if ENABLE(SQL_DATABASE)
#include "DatabaseBackend.h"
#include "SQLTransactionBackend.h"
#include "SecurityOrigin.h"
#include <wtf/Deque.h>
#include <wtf/HashMap.h>
#include <wtf/HashSet.h>
#include <wtf/RefPtr.h>
namespace WebCore {
static String getDatabaseIdentifier(SQLTransactionBackend* transaction)
{
DatabaseBackend* database = transaction->database();
ASSERT(database);
return database->securityOrigin()->databaseIdentifier();
}
SQLTransactionCoordinator::SQLTransactionCoordinator()
: m_isShuttingDown(false)
{
}
void SQLTransactionCoordinator::processPendingTransactions(CoordinationInfo& info)
{
if (info.activeWriteTransaction || info.pendingTransactions.isEmpty())
return;
RefPtr<SQLTransactionBackend> firstPendingTransaction = info.pendingTransactions.first();
if (firstPendingTransaction->isReadOnly()) {
do {
firstPendingTransaction = info.pendingTransactions.takeFirst();
info.activeReadTransactions.add(firstPendingTransaction);
firstPendingTransaction->lockAcquired();
} while (!info.pendingTransactions.isEmpty() && info.pendingTransactions.first()->isReadOnly());
} else if (info.activeReadTransactions.isEmpty()) {
info.pendingTransactions.removeFirst();
info.activeWriteTransaction = firstPendingTransaction;
firstPendingTransaction->lockAcquired();
}
}
void SQLTransactionCoordinator::acquireLock(SQLTransactionBackend* transaction)
{
ASSERT(!m_isShuttingDown);
String dbIdentifier = getDatabaseIdentifier(transaction);
CoordinationInfoMap::iterator coordinationInfoIterator = m_coordinationInfoMap.find(dbIdentifier);
if (coordinationInfoIterator == m_coordinationInfoMap.end()) {
coordinationInfoIterator = m_coordinationInfoMap.add(dbIdentifier, CoordinationInfo()).iterator;
}
CoordinationInfo& info = coordinationInfoIterator->value;
info.pendingTransactions.append(transaction);
processPendingTransactions(info);
}
void SQLTransactionCoordinator::releaseLock(SQLTransactionBackend* transaction)
{
if (m_isShuttingDown)
return;
String dbIdentifier = getDatabaseIdentifier(transaction);
CoordinationInfoMap::iterator coordinationInfoIterator = m_coordinationInfoMap.find(dbIdentifier);
ASSERT(coordinationInfoIterator != m_coordinationInfoMap.end());
CoordinationInfo& info = coordinationInfoIterator->value;
if (transaction->isReadOnly()) {
ASSERT(info.activeReadTransactions.contains(transaction));
info.activeReadTransactions.remove(transaction);
} else {
ASSERT(info.activeWriteTransaction == transaction);
info.activeWriteTransaction = 0;
}
processPendingTransactions(info);
}
void SQLTransactionCoordinator::shutdown()
{
m_isShuttingDown = true;
for (CoordinationInfoMap::iterator coordinationInfoIterator = m_coordinationInfoMap.begin();
coordinationInfoIterator != m_coordinationInfoMap.end(); ++coordinationInfoIterator) {
CoordinationInfo& info = coordinationInfoIterator->value;
if (info.activeWriteTransaction)
info.activeWriteTransaction->notifyDatabaseThreadIsShuttingDown();
for (HashSet<RefPtr<SQLTransactionBackend>>::iterator activeReadTransactionsIterator =
info.activeReadTransactions.begin();
activeReadTransactionsIterator != info.activeReadTransactions.end();
++activeReadTransactionsIterator) {
(*activeReadTransactionsIterator)->notifyDatabaseThreadIsShuttingDown();
}
while (!info.pendingTransactions.isEmpty()) {
RefPtr<SQLTransactionBackend> transaction = info.pendingTransactions.first();
transaction->notifyDatabaseThreadIsShuttingDown();
}
}
m_coordinationInfoMap.clear();
}
}
#endif // ENABLE(SQL_DATABASE)