#include "config.h"
#include "DatabaseSync.h"
#if ENABLE(SQL_DATABASE)
#include "DatabaseBackendContext.h"
#include "DatabaseBackendSync.h"
#include "DatabaseCallback.h"
#include "DatabaseContext.h"
#include "DatabaseManager.h"
#include "DatabaseTracker.h"
#include "Logging.h"
#include "SQLException.h"
#include "SQLTransactionSync.h"
#include "SQLTransactionSyncCallback.h"
#include "ScriptExecutionContext.h"
#include "SecurityOrigin.h"
#include <wtf/PassRefPtr.h>
#include <wtf/RefPtr.h>
#include <wtf/text/CString.h>
namespace WebCore {
PassRefPtr<DatabaseSync> DatabaseSync::create(ScriptExecutionContext*, PassRefPtr<DatabaseBackendBase> backend)
{
return static_cast<DatabaseSync*>(backend.get());
}
DatabaseSync::DatabaseSync(PassRefPtr<DatabaseBackendContext> databaseContext,
const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize)
: DatabaseBase(databaseContext->scriptExecutionContext())
, DatabaseBackendSync(databaseContext, name, expectedVersion, displayName, estimatedSize)
{
setFrontend(this);
}
DatabaseSync::~DatabaseSync()
{
ASSERT(m_scriptExecutionContext->isContextThread());
}
PassRefPtr<DatabaseBackendSync> DatabaseSync::backend()
{
return this;
}
void DatabaseSync::changeVersion(const String& oldVersion, const String& newVersion, PassRefPtr<SQLTransactionSyncCallback> changeVersionCallback, ExceptionCode& ec)
{
ASSERT(m_scriptExecutionContext->isContextThread());
if (sqliteDatabase().transactionInProgress()) {
setLastErrorMessage("unable to changeVersion from within a transaction");
ec = SQLException::DATABASE_ERR;
return;
}
RefPtr<SQLTransactionSync> transaction = SQLTransactionSync::create(this, changeVersionCallback, false);
if ((ec = transaction->begin())) {
ASSERT(!lastErrorMessage().isEmpty());
return;
}
String actualVersion;
if (!getVersionFromDatabase(actualVersion)) {
setLastErrorMessage("unable to read the current version", sqliteDatabase().lastError(), sqliteDatabase().lastErrorMsg());
ec = SQLException::UNKNOWN_ERR;
return;
}
if (actualVersion != oldVersion) {
setLastErrorMessage("current version of the database and `oldVersion` argument do not match");
ec = SQLException::VERSION_ERR;
return;
}
if ((ec = transaction->execute())) {
ASSERT(!lastErrorMessage().isEmpty());
return;
}
if (!setVersionInDatabase(newVersion)) {
setLastErrorMessage("unable to set the new version", sqliteDatabase().lastError(), sqliteDatabase().lastErrorMsg());
ec = SQLException::UNKNOWN_ERR;
return;
}
if ((ec = transaction->commit())) {
ASSERT(!lastErrorMessage().isEmpty());
setCachedVersion(oldVersion);
return;
}
setExpectedVersion(newVersion);
setLastErrorMessage("");
}
void DatabaseSync::transaction(PassRefPtr<SQLTransactionSyncCallback> callback, ExceptionCode& ec)
{
runTransaction(callback, false, ec);
}
void DatabaseSync::readTransaction(PassRefPtr<SQLTransactionSyncCallback> callback, ExceptionCode& ec)
{
runTransaction(callback, true, ec);
}
void DatabaseSync::runTransaction(PassRefPtr<SQLTransactionSyncCallback> callback, bool readOnly, ExceptionCode& ec)
{
ASSERT(m_scriptExecutionContext->isContextThread());
if (sqliteDatabase().transactionInProgress()) {
setLastErrorMessage("unable to start a transaction from within a transaction");
ec = SQLException::DATABASE_ERR;
return;
}
RefPtr<SQLTransactionSync> transaction = SQLTransactionSync::create(this, callback, readOnly);
if ((ec = transaction->begin()) || (ec = transaction->execute()) || (ec = transaction->commit())) {
ASSERT(!lastErrorMessage().isEmpty());
transaction->rollback();
}
setLastErrorMessage("");
}
void DatabaseSync::markAsDeletedAndClose()
{
}
void DatabaseSync::closeImmediately()
{
ASSERT(m_scriptExecutionContext->isContextThread());
if (!opened())
return;
logErrorMessage("forcibly closing database");
closeDatabase();
}
}
#endif // ENABLE(SQL_DATABASE)