#include "config.h"
#include "DatabaseTask.h"
#if ENABLE(DATABASE)
#include "Database.h"
#include "Logging.h"
namespace WebCore {
DatabaseTaskSynchronizer::DatabaseTaskSynchronizer()
: m_taskCompleted(false)
{
}
void DatabaseTaskSynchronizer::waitForTaskCompletion()
{
m_synchronousMutex.lock();
if (!m_taskCompleted)
m_synchronousCondition.wait(m_synchronousMutex);
m_synchronousMutex.unlock();
}
void DatabaseTaskSynchronizer::taskCompleted()
{
m_synchronousMutex.lock();
m_taskCompleted = true;
m_synchronousCondition.signal();
m_synchronousMutex.unlock();
}
DatabaseTask::DatabaseTask(Database* database, DatabaseTaskSynchronizer* synchronizer)
: m_database(database)
, m_synchronizer(synchronizer)
#ifndef NDEBUG
, m_complete(false)
#endif
{
}
DatabaseTask::~DatabaseTask()
{
}
void DatabaseTask::performTask()
{
ASSERT(!m_complete);
LOG(StorageAPI, "Performing %s %p\n", debugTaskName(), this);
m_database->resetAuthorizer();
doPerformTask();
m_database->performPolicyChecks();
if (m_synchronizer)
m_synchronizer->taskCompleted();
}
DatabaseOpenTask::DatabaseOpenTask(Database* database, DatabaseTaskSynchronizer* synchronizer, ExceptionCode& code, bool& success)
: DatabaseTask(database, synchronizer)
, m_code(code)
, m_success(success)
{
ASSERT(synchronizer); }
void DatabaseOpenTask::doPerformTask()
{
m_success = database()->performOpenAndVerify(m_code);
}
#ifndef NDEBUG
const char* DatabaseOpenTask::debugTaskName() const
{
return "DatabaseOpenTask";
}
#endif
DatabaseCloseTask::DatabaseCloseTask(Database* database, Database::ClosePolicy closePolicy, DatabaseTaskSynchronizer* synchronizer)
: DatabaseTask(database, synchronizer)
, m_closePolicy(closePolicy)
{
}
void DatabaseCloseTask::doPerformTask()
{
database()->close(m_closePolicy);
}
#ifndef NDEBUG
const char* DatabaseCloseTask::debugTaskName() const
{
return "DatabaseCloseTask";
}
#endif
DatabaseTransactionTask::DatabaseTransactionTask(PassRefPtr<SQLTransaction> transaction)
: DatabaseTask(transaction->database(), 0)
, m_transaction(transaction)
{
}
DatabaseTransactionTask::~DatabaseTransactionTask()
{
}
void DatabaseTransactionTask::doPerformTask()
{
if (m_transaction->performNextStep()) {
MutexLocker locker(m_transaction->database()->m_transactionInProgressMutex);
m_transaction->database()->scheduleTransaction();
}
}
#ifndef NDEBUG
const char* DatabaseTransactionTask::debugTaskName() const
{
return "DatabaseTransactionTask";
}
#endif
DatabaseTableNamesTask::DatabaseTableNamesTask(Database* database, DatabaseTaskSynchronizer* synchronizer, Vector<String>& names)
: DatabaseTask(database, synchronizer)
, m_tableNames(names)
{
ASSERT(synchronizer); }
void DatabaseTableNamesTask::doPerformTask()
{
m_tableNames = database()->performGetTableNames();
}
#ifndef NDEBUG
const char* DatabaseTableNamesTask::debugTaskName() const
{
return "DatabaseTableNamesTask";
}
#endif
}
#endif