IDBTransactionBackendImpl.cpp [plain text]
#include "config.h"
#include "IDBTransactionBackendImpl.h"
#if ENABLE(INDEXED_DATABASE)
#include "IDBBackingStore.h"
#include "IDBCursorBackendImpl.h"
#include "IDBDatabaseBackendImpl.h"
#include "IDBDatabaseCallbacks.h"
#include "IDBDatabaseException.h"
#include "IDBTracing.h"
#include "IDBTransactionCoordinator.h"
namespace WebCore {
PassRefPtr<IDBTransactionBackendImpl> IDBTransactionBackendImpl::create(int64_t id, PassRefPtr<IDBDatabaseCallbacks> callbacks, const Vector<int64_t>& objectStoreIds, IndexedDB::TransactionMode mode, IDBDatabaseBackendImpl* database)
{
HashSet<int64_t> objectStoreHashSet;
for (size_t i = 0; i < objectStoreIds.size(); ++i)
objectStoreHashSet.add(objectStoreIds[i]);
return adoptRef(new IDBTransactionBackendImpl(id, callbacks, objectStoreHashSet, mode, database));
}
IDBTransactionBackendImpl::IDBTransactionBackendImpl(int64_t id, PassRefPtr<IDBDatabaseCallbacks> callbacks, const HashSet<int64_t>& objectStoreIds, IndexedDB::TransactionMode mode, IDBDatabaseBackendImpl* database)
: m_id(id)
, m_objectStoreIds(objectStoreIds)
, m_mode(mode)
, m_state(Unused)
, m_commitPending(false)
, m_callbacks(callbacks)
, m_database(database)
, m_transaction(database->backingStore().get())
, m_taskTimer(this, &IDBTransactionBackendImpl::taskTimerFired)
, m_pendingPreemptiveEvents(0)
{
relaxAdoptionRequirement();
m_database->transactionCoordinator()->didCreateTransaction(this);
}
IDBTransactionBackendImpl::~IDBTransactionBackendImpl()
{
ASSERT(m_state == Finished);
}
void IDBTransactionBackendImpl::scheduleTask(IDBDatabaseBackendInterface::TaskType type, PassOwnPtr<Operation> task, PassOwnPtr<Operation> abortTask)
{
if (m_state == Finished)
return;
if (type == IDBDatabaseBackendInterface::NormalTask)
m_taskQueue.append(task);
else
m_preemptiveTaskQueue.append(task);
if (abortTask)
m_abortTaskQueue.prepend(abortTask);
if (m_state == Unused)
start();
else if (m_state == Running && !m_taskTimer.isActive())
m_taskTimer.startOneShot(0);
}
void IDBTransactionBackendImpl::abort()
{
abort(IDBDatabaseError::create(IDBDatabaseException::UnknownError, "Internal error (unknown cause)"));
}
void IDBTransactionBackendImpl::abort(PassRefPtr<IDBDatabaseError> error)
{
IDB_TRACE("IDBTransactionBackendImpl::abort");
if (m_state == Finished)
return;
bool wasRunning = m_state == Running;
RefPtr<IDBTransactionBackendImpl> protect(this);
m_state = Finished;
m_taskTimer.stop();
if (wasRunning)
m_transaction.rollback();
while (!m_abortTaskQueue.isEmpty()) {
OwnPtr<Operation> task(m_abortTaskQueue.takeFirst());
task->perform(0);
}
closeOpenCursors();
m_transaction.reset();
m_database->transactionCoordinator()->didFinishTransaction(this);
ASSERT(!m_database->transactionCoordinator()->isActive(this));
m_database->transactionFinished(this);
if (m_callbacks)
m_callbacks->onAbort(m_id, error);
m_database->transactionFinishedAndAbortFired(this);
m_database = 0;
}
bool IDBTransactionBackendImpl::isTaskQueueEmpty() const
{
return m_preemptiveTaskQueue.isEmpty() && m_taskQueue.isEmpty();
}
bool IDBTransactionBackendImpl::hasPendingTasks() const
{
return m_pendingPreemptiveEvents || !isTaskQueueEmpty();
}
void IDBTransactionBackendImpl::registerOpenCursor(IDBCursorBackendImpl* cursor)
{
m_openCursors.add(cursor);
}
void IDBTransactionBackendImpl::unregisterOpenCursor(IDBCursorBackendImpl* cursor)
{
m_openCursors.remove(cursor);
}
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);
m_database->transactionStarted(this);
}
void IDBTransactionBackendImpl::commit()
{
IDB_TRACE("IDBTransactionBackendImpl::commit");
if (m_state == Finished)
return;
ASSERT(m_state == Unused || m_state == Running);
m_commitPending = true;
if (hasPendingTasks())
return;
RefPtr<IDBTransactionBackendImpl> protect(this);
bool unused = m_state == Unused;
m_state = Finished;
bool committed = unused || m_transaction.commit();
closeOpenCursors();
m_transaction.reset();
if (!unused)
m_database->transactionCoordinator()->didFinishTransaction(this);
m_database->transactionFinished(this);
if (committed) {
m_callbacks->onComplete(m_id);
m_database->transactionFinishedAndCompleteFired(this);
} else {
m_callbacks->onAbort(m_id, IDBDatabaseError::create(IDBDatabaseException::UnknownError, "Internal error committing transaction."));
m_database->transactionFinishedAndAbortFired(this);
}
m_database = 0;
}
void IDBTransactionBackendImpl::taskTimerFired(Timer<IDBTransactionBackendImpl>*)
{
IDB_TRACE("IDBTransactionBackendImpl::taskTimerFired");
ASSERT(!isTaskQueueEmpty());
if (m_state == StartPending) {
m_transaction.begin();
m_state = Running;
}
RefPtr<IDBTransactionBackendImpl> protect(this);
TaskQueue* taskQueue = m_pendingPreemptiveEvents ? &m_preemptiveTaskQueue : &m_taskQueue;
while (!taskQueue->isEmpty() && m_state != Finished) {
ASSERT(m_state == Running);
OwnPtr<Operation> task(taskQueue->takeFirst());
task->perform(this);
taskQueue = m_pendingPreemptiveEvents ? &m_preemptiveTaskQueue : &m_taskQueue;
}
if (!hasPendingTasks() && m_state != Finished && m_commitPending)
commit();
}
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)