#include "config.h"
#include "modules/webdatabase/DatabaseSync.h"
-#include "bindings/v8/ExceptionState.h"
+#include "bindings/core/v8/ExceptionState.h"
#include "core/dom/ExceptionCode.h"
#include "core/dom/ExecutionContext.h"
-#include "core/dom/ExecutionContextTask.h"
#include "platform/Logging.h"
-#include "modules/webdatabase/DatabaseBackendSync.h"
#include "modules/webdatabase/DatabaseCallback.h"
#include "modules/webdatabase/DatabaseContext.h"
#include "modules/webdatabase/DatabaseManager.h"
#include "modules/webdatabase/SQLError.h"
#include "modules/webdatabase/SQLTransactionSync.h"
#include "modules/webdatabase/SQLTransactionSyncCallback.h"
-#include "weborigin/SecurityOrigin.h"
#include "wtf/PassRefPtr.h"
#include "wtf/RefPtr.h"
#include "wtf/text/CString.h"
-namespace WebCore {
+namespace blink {
-PassRefPtr<DatabaseSync> DatabaseSync::create(ExecutionContext*, PassRefPtr<DatabaseBackendBase> backend)
+PassRefPtrWillBeRawPtr<DatabaseSync> DatabaseSync::create(ExecutionContext*, PassRefPtrWillBeRawPtr<DatabaseBackendBase> backend)
{
return static_cast<DatabaseSync*>(backend.get());
}
-DatabaseSync::DatabaseSync(PassRefPtr<DatabaseContext> databaseContext,
+DatabaseSync::DatabaseSync(DatabaseContext* databaseContext,
const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize)
- : DatabaseBase(databaseContext->executionContext())
- , DatabaseBackendSync(databaseContext, name, expectedVersion, displayName, estimatedSize)
+ : DatabaseBackendSync(databaseContext, name, expectedVersion, displayName, estimatedSize)
+ , DatabaseBase(databaseContext->executionContext())
{
ScriptWrappable::init(this);
setFrontend(this);
DatabaseSync::~DatabaseSync()
{
- ASSERT(m_executionContext->isContextThread());
+#if !ENABLE(OILPAN)
+ if (executionContext())
+ ASSERT(executionContext()->isContextThread());
+#endif
}
-PassRefPtr<DatabaseBackendSync> DatabaseSync::backend()
+void DatabaseSync::trace(Visitor* visitor)
{
- return this;
+ DatabaseBackendSync::trace(visitor);
}
-void DatabaseSync::changeVersion(const String& oldVersion, const String& newVersion, PassRefPtr<SQLTransactionSyncCallback> changeVersionCallback, ExceptionState& es)
+void DatabaseSync::changeVersion(const String& oldVersion, const String& newVersion, PassOwnPtr<SQLTransactionSyncCallback> changeVersionCallback, ExceptionState& exceptionState)
{
- ASSERT(m_executionContext->isContextThread());
+ ASSERT(executionContext()->isContextThread());
if (sqliteDatabase().transactionInProgress()) {
reportChangeVersionResult(1, SQLError::DATABASE_ERR, 0);
setLastErrorMessage("unable to changeVersion from within a transaction");
- es.throwUninformativeAndGenericDOMException(SQLDatabaseError);
+ exceptionState.throwDOMException(SQLDatabaseError, "Unable to change version from within a transaction.");
return;
}
- RefPtr<SQLTransactionSync> transaction = SQLTransactionSync::create(this, changeVersionCallback, false);
- transaction->begin(es);
- if (es.hadException()) {
+ RefPtrWillBeRawPtr<SQLTransactionSync> transaction = SQLTransactionSync::create(this, changeVersionCallback, false);
+ transaction->begin(exceptionState);
+ if (exceptionState.hadException()) {
ASSERT(!lastErrorMessage().isEmpty());
return;
}
if (!getVersionFromDatabase(actualVersion)) {
reportChangeVersionResult(2, SQLError::UNKNOWN_ERR, sqliteDatabase().lastError());
setLastErrorMessage("unable to read the current version", sqliteDatabase().lastError(), sqliteDatabase().lastErrorMsg());
- es.throwDOMException(UnknownError, SQLError::unknownErrorMessage);
+ exceptionState.throwDOMException(UnknownError, SQLError::unknownErrorMessage);
return;
}
if (actualVersion != oldVersion) {
reportChangeVersionResult(3, SQLError::VERSION_ERR, 0);
setLastErrorMessage("current version of the database and `oldVersion` argument do not match");
- es.throwDOMException(VersionError, SQLError::versionErrorMessage);
+ exceptionState.throwDOMException(VersionError, SQLError::versionErrorMessage);
return;
}
- transaction->execute(es);
- if (es.hadException()) {
+ transaction->execute(exceptionState);
+ if (exceptionState.hadException()) {
ASSERT(!lastErrorMessage().isEmpty());
return;
}
if (!setVersionInDatabase(newVersion)) {
reportChangeVersionResult(4, SQLError::UNKNOWN_ERR, sqliteDatabase().lastError());
setLastErrorMessage("unable to set the new version", sqliteDatabase().lastError(), sqliteDatabase().lastErrorMsg());
- es.throwDOMException(UnknownError, SQLError::unknownErrorMessage);
+ exceptionState.throwDOMException(UnknownError, SQLError::unknownErrorMessage);
return;
}
- transaction->commit(es);
- if (es.hadException()) {
+ transaction->commit(exceptionState);
+ if (exceptionState.hadException()) {
ASSERT(!lastErrorMessage().isEmpty());
setCachedVersion(oldVersion);
return;
setLastErrorMessage("");
}
-void DatabaseSync::transaction(PassRefPtr<SQLTransactionSyncCallback> callback, ExceptionState& es)
+void DatabaseSync::transaction(PassOwnPtr<SQLTransactionSyncCallback> callback, ExceptionState& exceptionState)
{
- runTransaction(callback, false, es);
+ runTransaction(callback, false, exceptionState);
}
-void DatabaseSync::readTransaction(PassRefPtr<SQLTransactionSyncCallback> callback, ExceptionState& es)
+void DatabaseSync::readTransaction(PassOwnPtr<SQLTransactionSyncCallback> callback, ExceptionState& exceptionState)
{
- runTransaction(callback, true, es);
+ runTransaction(callback, true, exceptionState);
}
-void DatabaseSync::rollbackTransaction(PassRefPtr<SQLTransactionSync> transaction)
+void DatabaseSync::rollbackTransaction(SQLTransactionSync& transaction)
{
ASSERT(!lastErrorMessage().isEmpty());
- transaction->rollback();
+ transaction.rollback();
setLastErrorMessage("");
return;
}
-void DatabaseSync::runTransaction(PassRefPtr<SQLTransactionSyncCallback> callback, bool readOnly, ExceptionState& es)
+void DatabaseSync::runTransaction(PassOwnPtr<SQLTransactionSyncCallback> callback, bool readOnly, ExceptionState& exceptionState)
{
- ASSERT(m_executionContext->isContextThread());
+ ASSERT(executionContext()->isContextThread());
if (sqliteDatabase().transactionInProgress()) {
setLastErrorMessage("unable to start a transaction from within a transaction");
- es.throwUninformativeAndGenericDOMException(SQLDatabaseError);
+ exceptionState.throwDOMException(SQLDatabaseError, "Unable to start a transaction from within a transaction.");
return;
}
- RefPtr<SQLTransactionSync> transaction = SQLTransactionSync::create(this, callback, readOnly);
- transaction->begin(es);
- if (es.hadException()) {
- rollbackTransaction(transaction);
+ RefPtrWillBeRawPtr<SQLTransactionSync> transaction = SQLTransactionSync::create(this, callback, readOnly);
+ transaction->begin(exceptionState);
+ if (exceptionState.hadException()) {
+ rollbackTransaction(*transaction);
return;
}
- transaction->execute(es);
- if (es.hadException()) {
- rollbackTransaction(transaction);
+ transaction->execute(exceptionState);
+ if (exceptionState.hadException()) {
+ rollbackTransaction(*transaction);
return;
}
- transaction->commit(es);
- if (es.hadException()) {
- rollbackTransaction(transaction);
+ transaction->commit(exceptionState);
+ if (exceptionState.hadException()) {
+ rollbackTransaction(*transaction);
return;
}
setLastErrorMessage("");
}
-void DatabaseSync::markAsDeletedAndClose()
-{
- // FIXME: need to do something similar to closeImmediately(), but in a sync way
-}
-
-class CloseSyncDatabaseOnContextThreadTask : public ExecutionContextTask {
-public:
- static PassOwnPtr<CloseSyncDatabaseOnContextThreadTask> create(PassRefPtr<DatabaseSync> database)
- {
- return adoptPtr(new CloseSyncDatabaseOnContextThreadTask(database));
- }
-
- virtual void performTask(ExecutionContext*)
- {
- m_database->closeImmediately();
- }
-
-private:
- CloseSyncDatabaseOnContextThreadTask(PassRefPtr<DatabaseSync> database)
- : m_database(database)
- {
- }
-
- RefPtr<DatabaseSync> m_database;
-};
-
void DatabaseSync::closeImmediately()
{
- ASSERT(m_executionContext->isContextThread());
+ ASSERT(executionContext()->isContextThread());
if (!opened())
return;
closeDatabase();
}
-} // namespace WebCore
+void DatabaseSync::observeTransaction(SQLTransactionSync& transaction)
+{
+#if ENABLE(OILPAN)
+ m_observers.add(&transaction, adoptPtr(new TransactionObserver(transaction)));
+#endif
+}
+
+#if ENABLE(OILPAN)
+DatabaseSync::TransactionObserver::~TransactionObserver()
+{
+ m_transaction.rollbackIfInProgress();
+}
+#endif
+
+} // namespace blink
projects / platform / framework / web / crosswalk.git / blobdiff