SQLTransaction.cpp [plain text]
#include "config.h"
#include "SQLTransaction.h"
#include "ChromeClient.h"
#include "Database.h"
#include "DatabaseAuthorizer.h"
#include "DatabaseDetails.h"
#include "DatabaseTracker.h"
#include "Document.h"
#include "ExceptionCode.h"
#include "Logging.h"
#include "OriginQuotaManager.h"
#include "Page.h"
#include "PlatformString.h"
#include "SecurityOrigin.h"
#include "SQLError.h"
#include "SQLiteTransaction.h"
#include "SQLResultSet.h"
#include "SQLStatement.h"
#include "SQLStatementCallback.h"
#include "SQLStatementErrorCallback.h"
#include "SQLValue.h"
static const int DefaultQuotaSizeIncrease = 1048576;
namespace WebCore {
SQLTransaction::SQLTransaction(Database* db, PassRefPtr<SQLTransactionCallback> callback, PassRefPtr<SQLTransactionErrorCallback> errorCallback, PassRefPtr<VoidCallback> successCallback,
PassRefPtr<SQLTransactionWrapper> wrapper)
: m_nextStep(&SQLTransaction::openTransactionAndPreflight)
, m_executeSqlAllowed(false)
, m_database(db)
, m_wrapper(wrapper)
, m_callback(callback)
, m_successCallback(successCallback)
, m_errorCallback(errorCallback)
, m_shouldRetryCurrentStatement(false)
, m_shouldCommitAfterErrorCallback(true)
, m_modifiedDatabase(false)
{
ASSERT(m_database);
}
SQLTransaction::~SQLTransaction()
{
}
void SQLTransaction::executeSQL(const String& sqlStatement, const Vector<SQLValue>& arguments, PassRefPtr<SQLStatementCallback> callback, PassRefPtr<SQLStatementErrorCallback> callbackError, ExceptionCode& e)
{
if (!m_executeSqlAllowed || m_database->stopped()) {
e = INVALID_STATE_ERR;
return;
}
RefPtr<SQLStatement> statement = new SQLStatement(sqlStatement.copy(), arguments, callback, callbackError);
if (m_database->deleted())
statement->setDatabaseDeletedError();
if (!m_database->versionMatchesExpected())
statement->setVersionMismatchedError();
enqueueStatement(statement);
}
void SQLTransaction::enqueueStatement(PassRefPtr<SQLStatement> statement)
{
MutexLocker locker(m_statementMutex);
m_statementQueue.append(statement);
}
#ifndef NDEBUG
const char* SQLTransaction::debugStepName(SQLTransaction::TransactionStepMethod step)
{
if (step == &SQLTransaction::openTransactionAndPreflight)
return "openTransactionAndPreflight";
else if (step == &SQLTransaction::runStatements)
return "runStatements";
else if (step == &SQLTransaction::postflightAndCommit)
return "postflightAndCommit";
else if (step == &SQLTransaction::cleanupAfterTransactionErrorCallback)
return "cleanupAfterTransactionErrorCallback";
else if (step == &SQLTransaction::deliverTransactionCallback)
return "deliverTransactionCallback";
else if (step == &SQLTransaction::deliverTransactionErrorCallback)
return "deliverTransactionErrorCallback";
else if (step == &SQLTransaction::deliverStatementCallback)
return "deliverStatementCallback";
else if (step == &SQLTransaction::deliverQuotaIncreaseCallback)
return "deliverQuotaIncreaseCallback";
else if (step == &SQLTransaction::deliverSuccessCallback)
return "deliverSuccessCallback";
else if (step == &SQLTransaction::cleanupAfterSuccessCallback)
return "cleanupAfterSuccessCallback";
else
return "UNKNOWN";
}
#endif
void SQLTransaction::checkAndHandleClosedDatabase()
{
if (!m_database->stopped())
return;
LOG(StorageAPI, "Database was stopped - cancelling work for this transaction");
MutexLocker locker(m_statementMutex);
m_statementQueue.clear();
m_nextStep = 0;
if (m_sqliteTransaction) {
m_sqliteTransaction->stop();
m_sqliteTransaction.clear();
}
}
bool SQLTransaction::performNextStep()
{
LOG(StorageAPI, "Step %s\n", debugStepName(m_nextStep));
ASSERT(m_nextStep == &SQLTransaction::openTransactionAndPreflight ||
m_nextStep == &SQLTransaction::runStatements ||
m_nextStep == &SQLTransaction::postflightAndCommit ||
m_nextStep == &SQLTransaction::cleanupAfterSuccessCallback ||
m_nextStep == &SQLTransaction::cleanupAfterTransactionErrorCallback);
checkAndHandleClosedDatabase();
if (m_nextStep)
(this->*m_nextStep)();
return !m_nextStep;
}
void SQLTransaction::performPendingCallback()
{
LOG(StorageAPI, "Callback %s\n", debugStepName(m_nextStep));
ASSERT(m_nextStep == &SQLTransaction::deliverTransactionCallback ||
m_nextStep == &SQLTransaction::deliverTransactionErrorCallback ||
m_nextStep == &SQLTransaction::deliverStatementCallback ||
m_nextStep == &SQLTransaction::deliverQuotaIncreaseCallback ||
m_nextStep == &SQLTransaction::deliverSuccessCallback);
checkAndHandleClosedDatabase();
if (m_nextStep)
(this->*m_nextStep)();
}
void SQLTransaction::openTransactionAndPreflight()
{
ASSERT(!m_database->m_sqliteDatabase.transactionInProgress());
LOG(StorageAPI, "Opening and preflighting transaction %p", this);
if (m_database->deleted()) {
m_transactionError = new SQLError(0, "unable to open a transaction, because the user deleted the database");
handleTransactionError(false);
return;
}
m_database->m_sqliteDatabase.setMaximumSize(m_database->maximumSize());
ASSERT(!m_sqliteTransaction);
m_sqliteTransaction.set(new SQLiteTransaction(m_database->m_sqliteDatabase));
m_database->m_databaseAuthorizer->disable();
m_sqliteTransaction->begin();
m_database->m_databaseAuthorizer->enable();
if (!m_sqliteTransaction->inProgress()) {
ASSERT(!m_database->m_sqliteDatabase.transactionInProgress());
m_sqliteTransaction.clear();
m_transactionError = new SQLError(0, "unable to open a transaction to the database");
handleTransactionError(false);
return;
}
if (m_wrapper && !m_wrapper->performPreflight(this)) {
ASSERT(!m_database->m_sqliteDatabase.transactionInProgress());
m_sqliteTransaction.clear();
m_transactionError = m_wrapper->sqlError();
if (!m_transactionError)
m_transactionError = new SQLError(0, "unknown error occured setting up transaction");
handleTransactionError(false);
return;
}
m_nextStep = &SQLTransaction::deliverTransactionCallback;
LOG(StorageAPI, "Scheduling deliverTransactionCallback for transaction %p\n", this);
m_database->scheduleTransactionCallback(this);
}
void SQLTransaction::deliverTransactionCallback()
{
bool shouldDeliverErrorCallback = false;
if (m_callback) {
m_executeSqlAllowed = true;
m_callback->handleEvent(this, shouldDeliverErrorCallback);
m_executeSqlAllowed = false;
} else
shouldDeliverErrorCallback = true;
if (shouldDeliverErrorCallback) {
m_transactionError = new SQLError(0, "the SQLTransactionCallback was null or threw an exception");
deliverTransactionErrorCallback();
} else
scheduleToRunStatements();
}
void SQLTransaction::scheduleToRunStatements()
{
m_nextStep = &SQLTransaction::runStatements;
LOG(StorageAPI, "Scheduling runStatements for transaction %p\n", this);
m_database->scheduleTransactionStep(this);
}
void SQLTransaction::runStatements()
{
do {
if (m_shouldRetryCurrentStatement) {
m_shouldRetryCurrentStatement = false;
m_database->m_sqliteDatabase.setMaximumSize(m_database->maximumSize());
} else {
if (m_currentStatement && m_currentStatement->lastExecutionFailedDueToQuota()) {
handleCurrentStatementError();
break;
}
getNextStatement();
}
} while (runCurrentStatement());
if (!m_currentStatement)
postflightAndCommit();
}
void SQLTransaction::getNextStatement()
{
m_currentStatement = 0;
MutexLocker locker(m_statementMutex);
if (!m_statementQueue.isEmpty()) {
m_currentStatement = m_statementQueue.first();
m_statementQueue.removeFirst();
}
}
bool SQLTransaction::runCurrentStatement()
{
if (!m_currentStatement)
return false;
m_database->m_databaseAuthorizer->reset();
if (m_currentStatement->execute(m_database)) {
if (m_database->m_databaseAuthorizer->lastActionChangedDatabase()) {
m_modifiedDatabase = true;
OriginQuotaManager& manager(DatabaseTracker::tracker().originQuotaManager());
Locker<OriginQuotaManager> locker(manager);
manager.markDatabase(m_database);
}
if (m_currentStatement->hasStatementCallback()) {
m_nextStep = &SQLTransaction::deliverStatementCallback;
LOG(StorageAPI, "Scheduling deliverStatementCallback for transaction %p\n", this);
m_database->scheduleTransactionCallback(this);
return false;
}
return true;
}
if (m_currentStatement->lastExecutionFailedDueToQuota()) {
m_nextStep = &SQLTransaction::deliverQuotaIncreaseCallback;
LOG(StorageAPI, "Scheduling deliverQuotaIncreaseCallback for transaction %p\n", this);
m_database->scheduleTransactionCallback(this);
return false;
}
handleCurrentStatementError();
return false;
}
void SQLTransaction::handleCurrentStatementError()
{
if (m_currentStatement->hasStatementErrorCallback()) {
m_nextStep = &SQLTransaction::deliverStatementCallback;
LOG(StorageAPI, "Scheduling deliverStatementCallback for transaction %p\n", this);
m_database->scheduleTransactionCallback(this);
} else {
m_transactionError = m_currentStatement->sqlError();
if (!m_transactionError)
m_transactionError = new SQLError(1, "the statement failed to execute");
handleTransactionError(false);
}
}
void SQLTransaction::deliverStatementCallback()
{
ASSERT(m_currentStatement);
m_executeSqlAllowed = true;
bool result = m_currentStatement->performCallback(this);
m_executeSqlAllowed = false;
if (result) {
m_transactionError = new SQLError(0, "the statement callback raised an exception or statement error callback did not return false");
handleTransactionError(true);
} else
scheduleToRunStatements();
}
void SQLTransaction::deliverQuotaIncreaseCallback()
{
ASSERT(m_currentStatement);
ASSERT(!m_shouldRetryCurrentStatement);
Page* page = m_database->document()->page();
ASSERT(page);
RefPtr<SecurityOrigin> origin = m_database->securityOriginCopy();
unsigned long long currentQuota = DatabaseTracker::tracker().quotaForOrigin(origin.get());
page->chrome()->client()->exceededDatabaseQuota(m_database->document()->frame(), m_database->stringIdentifier());
unsigned long long newQuota = DatabaseTracker::tracker().quotaForOrigin(origin.get());
if (newQuota > currentQuota)
m_shouldRetryCurrentStatement = true;
m_nextStep = &SQLTransaction::runStatements;
LOG(StorageAPI, "Scheduling runStatements for transaction %p\n", this);
m_database->scheduleTransactionStep(this);
}
void SQLTransaction::postflightAndCommit()
{
if (m_wrapper && !m_wrapper->performPostflight(this)) {
m_transactionError = m_wrapper->sqlError();
if (!m_transactionError)
m_transactionError = new SQLError(0, "unknown error occured setting up transaction");
handleTransactionError(false);
return;
}
ASSERT(m_sqliteTransaction);
m_database->m_databaseAuthorizer->disable();
m_sqliteTransaction->commit();
m_database->m_databaseAuthorizer->enable();
if (m_sqliteTransaction->inProgress()) {
m_shouldCommitAfterErrorCallback = false;
m_transactionError = new SQLError(0, "failed to commit the transaction");
handleTransactionError(false);
return;
}
if (m_modifiedDatabase)
DatabaseTracker::tracker().scheduleNotifyDatabaseChanged(m_database->m_securityOrigin.get(), m_database->m_name);
m_callback = 0;
m_errorCallback = 0;
if (m_successCallback) {
m_nextStep = &SQLTransaction::deliverSuccessCallback;
LOG(StorageAPI, "Scheduling deliverSuccessCallback for transaction %p\n", this);
m_database->scheduleTransactionCallback(this);
} else
cleanupAfterSuccessCallback();
}
void SQLTransaction::deliverSuccessCallback()
{
ASSERT(m_successCallback);
m_successCallback->handleEvent();
m_successCallback = 0;
m_nextStep = &SQLTransaction::cleanupAfterSuccessCallback;
LOG(StorageAPI, "Scheduling cleanupAfterSuccessCallback for transaction %p\n", this);
m_database->scheduleTransactionStep(this);
}
void SQLTransaction::cleanupAfterSuccessCallback()
{
LOG(StorageAPI, "Transaction %p is complete\n", this);
ASSERT(!m_database->m_sqliteDatabase.transactionInProgress());
m_nextStep = 0;
}
void SQLTransaction::handleTransactionError(bool inCallback)
{
if (m_errorCallback) {
if (inCallback)
deliverTransactionErrorCallback();
else {
m_nextStep = &SQLTransaction::deliverTransactionErrorCallback;
LOG(StorageAPI, "Scheduling deliverTransactionErrorCallback for transaction %p\n", this);
m_database->scheduleTransactionCallback(this);
}
return;
}
m_shouldCommitAfterErrorCallback = false;
if (inCallback) {
m_nextStep = &SQLTransaction::cleanupAfterTransactionErrorCallback;
LOG(StorageAPI, "Scheduling cleanupAfterTransactionErrorCallback for transaction %p\n", this);
m_database->scheduleTransactionStep(this);
} else {
cleanupAfterTransactionErrorCallback();
}
}
void SQLTransaction::deliverTransactionErrorCallback()
{
ASSERT(m_transactionError);
if (!m_errorCallback || m_errorCallback->handleEvent(m_transactionError.get()))
m_shouldCommitAfterErrorCallback = false;
m_nextStep = &SQLTransaction::cleanupAfterTransactionErrorCallback;
LOG(StorageAPI, "Scheduling cleanupAfterTransactionErrorCallback for transaction %p\n", this);
m_database->scheduleTransactionStep(this);
}
void SQLTransaction::cleanupAfterTransactionErrorCallback()
{
m_database->m_databaseAuthorizer->disable();
if (m_sqliteTransaction) {
if (m_shouldCommitAfterErrorCallback)
m_sqliteTransaction->commit();
if (m_sqliteTransaction->inProgress()) {
m_sqliteTransaction->rollback();
} else if (m_modifiedDatabase) {
DatabaseTracker::tracker().scheduleNotifyDatabaseChanged(m_database->m_securityOrigin.get(), m_database->m_name);
}
ASSERT(!m_database->m_sqliteDatabase.transactionInProgress());
m_sqliteTransaction.clear();
}
m_database->m_databaseAuthorizer->enable();
{
MutexLocker locker(m_statementMutex);
m_statementQueue.clear();
}
LOG(StorageAPI, "Transaction %p is complete with an error\n", this);
ASSERT(!m_database->m_sqliteDatabase.transactionInProgress());
m_nextStep = 0;
m_callback = 0;
m_errorCallback = 0;
}
}