#include "config.h"
#include "DatabaseTask.h"
#if ENABLE(SQL_DATABASE)
#include "Database.h"
#include "DatabaseBackend.h"
#include "Logging.h"
namespace WebCore {
DatabaseTaskSynchronizer::DatabaseTaskSynchronizer()
: m_taskCompleted(false)
#ifndef NDEBUG
, m_hasCheckedForTermination(false)
#endif
{
}
void DatabaseTaskSynchronizer::waitForTaskCompletion()
{
m_synchronousMutex.lock();
while (!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(DatabaseBackend* database, DatabaseTaskSynchronizer* synchronizer)
: m_database(database)
, m_synchronizer(synchronizer)
#if !LOG_DISABLED
, m_complete(false)
#endif
{
}
DatabaseTask::~DatabaseTask()
{
#if !LOG_DISABLED
ASSERT(m_complete || !m_synchronizer);
#endif
}
void DatabaseTask::performTask()
{
#if !LOG_DISABLED
ASSERT(!m_complete);
#endif
LOG(StorageAPI, "Performing %s %p\n", debugTaskName(), this);
#if !PLATFORM(IOS)
m_database->resetAuthorizer();
#else
if (m_database)
m_database->resetAuthorizer();
#endif
doPerformTask();
if (m_synchronizer)
m_synchronizer->taskCompleted();
#if !LOG_DISABLED
m_complete = true;
#endif
}
DatabaseBackend::DatabaseOpenTask::DatabaseOpenTask(DatabaseBackend* database, bool setVersionInNewDatabase, DatabaseTaskSynchronizer* synchronizer, DatabaseError& error, String& errorMessage, bool& success)
: DatabaseTask(database, synchronizer)
, m_setVersionInNewDatabase(setVersionInNewDatabase)
, m_error(error)
, m_errorMessage(errorMessage)
, m_success(success)
{
ASSERT(synchronizer); }
void DatabaseBackend::DatabaseOpenTask::doPerformTask()
{
String errorMessage;
m_success = database()->performOpenAndVerify(m_setVersionInNewDatabase, m_error, errorMessage);
if (!m_success)
m_errorMessage = errorMessage.isolatedCopy();
}
#if !LOG_DISABLED
const char* DatabaseBackend::DatabaseOpenTask::debugTaskName() const
{
return "DatabaseOpenTask";
}
#endif
DatabaseBackend::DatabaseCloseTask::DatabaseCloseTask(DatabaseBackend* database, DatabaseTaskSynchronizer* synchronizer)
: DatabaseTask(database, synchronizer)
{
}
void DatabaseBackend::DatabaseCloseTask::doPerformTask()
{
Database::from(database())->close();
}
#if !LOG_DISABLED
const char* DatabaseBackend::DatabaseCloseTask::debugTaskName() const
{
return "DatabaseCloseTask";
}
#endif
DatabaseBackend::DatabaseTransactionTask::DatabaseTransactionTask(PassRefPtr<SQLTransactionBackend> transaction)
: DatabaseTask(Database::from(transaction->database()), 0)
, m_transaction(transaction)
, m_didPerformTask(false)
{
}
DatabaseBackend::DatabaseTransactionTask::~DatabaseTransactionTask()
{
if (!m_didPerformTask)
m_transaction->notifyDatabaseThreadIsShuttingDown();
}
#if PLATFORM(IOS)
bool Database::DatabaseTransactionTask::shouldPerformWhilePaused() const
{
return m_transaction->shouldPerformWhilePaused();
}
#endif
void DatabaseBackend::DatabaseTransactionTask::doPerformTask()
{
m_transaction->performNextStep();
m_didPerformTask = true;
}
#if !LOG_DISABLED
const char* DatabaseBackend::DatabaseTransactionTask::debugTaskName() const
{
return "DatabaseTransactionTask";
}
#endif
DatabaseBackend::DatabaseTableNamesTask::DatabaseTableNamesTask(DatabaseBackend* database, DatabaseTaskSynchronizer* synchronizer, Vector<String>& names)
: DatabaseTask(database, synchronizer)
, m_tableNames(names)
{
ASSERT(synchronizer); }
void DatabaseBackend::DatabaseTableNamesTask::doPerformTask()
{
m_tableNames = Database::from(database())->performGetTableNames();
}
#if !LOG_DISABLED
const char* DatabaseBackend::DatabaseTableNamesTask::debugTaskName() const
{
return "DatabaseTableNamesTask";
}
#endif
}
#endif