#include "config.h"
#include "DatabaseSync.h"
#if ENABLE(SQL_DATABASE)
#include "DatabaseCallback.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::openDatabaseSync(ScriptExecutionContext* context, const String& name, const String& expectedVersion, const String& displayName,
unsigned long estimatedSize, PassRefPtr<DatabaseCallback> creationCallback, ExceptionCode& ec)
{
ASSERT(context->isContextThread());
if (!DatabaseTracker::tracker().canEstablishDatabase(context, name, displayName, estimatedSize)) {
LOG(StorageAPI, "Database %s for origin %s not allowed to be established", name.ascii().data(), context->securityOrigin()->toString().ascii().data());
return 0;
}
RefPtr<DatabaseSync> database = adoptRef(new DatabaseSync(context, name, expectedVersion, displayName, estimatedSize));
String errorMessage;
if (!database->performOpenAndVerify(!creationCallback, ec, errorMessage)) {
database->logErrorMessage(errorMessage);
DatabaseTracker::tracker().removeOpenDatabase(database.get());
return 0;
}
DatabaseTracker::tracker().setDatabaseDetails(context->securityOrigin(), name, displayName, estimatedSize);
if (database->isNew() && creationCallback.get()) {
LOG(StorageAPI, "Invoking the creation callback for database %p\n", database.get());
creationCallback->handleEvent(database.get());
}
return database;
}
DatabaseSync::DatabaseSync(ScriptExecutionContext* context, const String& name, const String& expectedVersion,
const String& displayName, unsigned long estimatedSize)
: AbstractDatabase(context, name, expectedVersion, displayName, estimatedSize, SyncDatabase)
{
}
DatabaseSync::~DatabaseSync()
{
ASSERT(m_scriptExecutionContext->isContextThread());
if (opened()) {
DatabaseTracker::tracker().removeOpenDatabase(this);
closeDatabase();
}
}
void DatabaseSync::changeVersion(const String& oldVersion, const String& newVersion, PassRefPtr<SQLTransactionSyncCallback> changeVersionCallback, ExceptionCode& ec)
{
ASSERT(m_scriptExecutionContext->isContextThread());
if (sqliteDatabase().transactionInProgress()) {
reportChangeVersionResult(1, SQLException::DATABASE_ERR, 0);
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)) {
reportChangeVersionResult(2, SQLException::UNKNOWN_ERR, sqliteDatabase().lastError());
setLastErrorMessage("unable to read the current version", sqliteDatabase().lastError(), sqliteDatabase().lastErrorMsg());
ec = SQLException::UNKNOWN_ERR;
return;
}
if (actualVersion != oldVersion) {
reportChangeVersionResult(3, SQLException::VERSION_ERR, 0);
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)) {
reportChangeVersionResult(4, SQLException::UNKNOWN_ERR, sqliteDatabase().lastError());
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;
}
reportChangeVersionResult(0, -1, 0);
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()
{
}
class CloseSyncDatabaseOnContextThreadTask : public ScriptExecutionContext::Task {
public:
static PassOwnPtr<CloseSyncDatabaseOnContextThreadTask> create(PassRefPtr<DatabaseSync> database)
{
return adoptPtr(new CloseSyncDatabaseOnContextThreadTask(database));
}
virtual void performTask(ScriptExecutionContext*)
{
m_database->closeImmediately();
}
private:
CloseSyncDatabaseOnContextThreadTask(PassRefPtr<DatabaseSync> database)
: m_database(database)
{
}
RefPtr<DatabaseSync> m_database;
};
void DatabaseSync::closeImmediately()
{
ASSERT(m_scriptExecutionContext->isContextThread());
if (!opened())
return;
logErrorMessage("forcibly closing database");
DatabaseTracker::tracker().removeOpenDatabase(this);
closeDatabase();
}
}
#endif // ENABLE(SQL_DATABASE)