IDBTransactionBackendImpl.cpp [plain text]
#include "config.h"
#include "IDBTransactionBackendImpl.h"
#if ENABLE(INDEXED_DATABASE)
#include "IDBBackingStore.h"
#include "IDBCursorBackendImpl.h"
#include "IDBDatabaseBackendImpl.h"
#include "IDBDatabaseException.h"
#include "IDBTransactionCoordinator.h"
namespace WebCore {
PassRefPtr<IDBTransactionBackendImpl> IDBTransactionBackendImpl::create(DOMStringList* objectStores, unsigned short mode, IDBDatabaseBackendImpl* database)
{
return adoptRef(new IDBTransactionBackendImpl(objectStores, mode, database));
}
IDBTransactionBackendImpl::IDBTransactionBackendImpl(DOMStringList* objectStores, unsigned short mode, IDBDatabaseBackendImpl* database)
: m_objectStoreNames(objectStores)
, m_mode(mode)
, m_state(Unused)
, m_database(database)
, m_transaction(database->backingStore()->createTransaction())
, m_taskTimer(this, &IDBTransactionBackendImpl::taskTimerFired)
, m_taskEventTimer(this, &IDBTransactionBackendImpl::taskEventTimerFired)
, m_pendingEvents(0)
{
ASSERT(m_objectStoreNames);
m_database->transactionCoordinator()->didCreateTransaction(this);
}
IDBTransactionBackendImpl::~IDBTransactionBackendImpl()
{
ASSERT(m_state == Finished);
}
PassRefPtr<IDBObjectStoreBackendInterface> IDBTransactionBackendImpl::objectStore(const String& name, ExceptionCode& ec)
{
if (m_state == Finished) {
ec = IDBDatabaseException::NOT_ALLOWED_ERR;
return 0;
}
if (!m_objectStoreNames->isEmpty() && !m_objectStoreNames->contains(name)) {
ec = IDBDatabaseException::NOT_FOUND_ERR;
return 0;
}
RefPtr<IDBObjectStoreBackendInterface> objectStore = m_database->objectStore(name);
if (!objectStore) {
ec = IDBDatabaseException::NOT_FOUND_ERR;
return 0;
}
return objectStore.release();
}
bool IDBTransactionBackendImpl::scheduleTask(PassOwnPtr<ScriptExecutionContext::Task> task, PassOwnPtr<ScriptExecutionContext::Task> abortTask)
{
if (m_state == Finished)
return false;
m_taskQueue.append(task);
if (abortTask)
m_abortTaskQueue.prepend(abortTask);
if (m_state == Unused)
start();
return true;
}
void IDBTransactionBackendImpl::abort()
{
if (m_state == Finished)
return;
RefPtr<IDBTransactionBackendImpl> self(this);
m_state = Finished;
m_taskTimer.stop();
m_taskEventTimer.stop();
closeOpenCursors();
m_transaction->rollback();
while (!m_abortTaskQueue.isEmpty()) {
OwnPtr<ScriptExecutionContext::Task> task(m_abortTaskQueue.first().release());
m_abortTaskQueue.removeFirst();
task->performTask(0);
}
m_callbacks->onAbort();
m_database->transactionCoordinator()->didFinishTransaction(this);
ASSERT(!m_database->transactionCoordinator()->isActive(this));
m_database = 0;
}
void IDBTransactionBackendImpl::registerOpenCursor(IDBCursorBackendImpl* cursor)
{
m_openCursors.add(cursor);
}
void IDBTransactionBackendImpl::unregisterOpenCursor(IDBCursorBackendImpl* cursor)
{
m_openCursors.remove(cursor);
}
void IDBTransactionBackendImpl::didCompleteTaskEvents()
{
if (m_state == Finished)
return;
ASSERT(m_state == Running);
ASSERT(m_pendingEvents);
m_pendingEvents--;
if (!m_taskEventTimer.isActive())
m_taskEventTimer.startOneShot(0);
}
void IDBTransactionBackendImpl::run()
{
ASSERT(m_state == StartPending || m_state == Running);
ASSERT(!m_taskTimer.isActive());
m_taskTimer.startOneShot(0);
}
void IDBTransactionBackendImpl::start()
{
ASSERT(m_state == Unused);
m_state = StartPending;
m_database->transactionCoordinator()->didStartTransaction(this);
}
void IDBTransactionBackendImpl::commit()
{
RefPtr<IDBTransactionBackendImpl> self(this);
ASSERT(m_state == Running);
m_state = Finished;
closeOpenCursors();
m_transaction->commit();
m_callbacks->onComplete();
m_database->transactionCoordinator()->didFinishTransaction(this);
m_database = 0;
}
void IDBTransactionBackendImpl::taskTimerFired(Timer<IDBTransactionBackendImpl>*)
{
ASSERT(!m_taskQueue.isEmpty());
if (m_state == StartPending) {
m_transaction->begin();
m_state = Running;
}
TaskQueue queue;
queue.swap(m_taskQueue);
while (!queue.isEmpty() && m_state != Finished) {
ASSERT(m_state == Running);
OwnPtr<ScriptExecutionContext::Task> task(queue.first().release());
queue.removeFirst();
m_pendingEvents++;
task->performTask(0);
}
}
void IDBTransactionBackendImpl::taskEventTimerFired(Timer<IDBTransactionBackendImpl>*)
{
ASSERT(m_state == Running);
if (!m_pendingEvents && m_taskQueue.isEmpty()) {
commit();
return;
}
if (!m_taskQueue.isEmpty() && !m_taskTimer.isActive())
m_taskTimer.startOneShot(0);
}
void IDBTransactionBackendImpl::closeOpenCursors()
{
for (HashSet<IDBCursorBackendImpl*>::iterator i = m_openCursors.begin(); i != m_openCursors.end(); ++i)
(*i)->close();
m_openCursors.clear();
}
};
#endif // ENABLE(INDEXED_DATABASE)