SQLTransactionBackend.h [plain text]
#ifndef SQLTransactionBackend_h
#define SQLTransactionBackend_h
#if ENABLE(SQL_DATABASE)
#include "AbstractSQLStatement.h"
#include "AbstractSQLTransactionBackend.h"
#include "DatabaseBasicTypes.h"
#include "SQLTransactionStateMachine.h"
#include <memory>
#include <wtf/Deque.h>
#include <wtf/Forward.h>
#include <wtf/text/WTFString.h>
namespace WebCore {
class AbstractSQLTransaction;
class DatabaseBackend;
class OriginLock;
class SQLError;
class SQLiteTransaction;
class SQLStatementBackend;
class SQLTransactionBackend;
class SQLValue;
class SQLTransactionWrapper : public ThreadSafeRefCounted<SQLTransactionWrapper> {
public:
virtual ~SQLTransactionWrapper() { }
virtual bool performPreflight(SQLTransactionBackend*) = 0;
virtual bool performPostflight(SQLTransactionBackend*) = 0;
virtual SQLError* sqlError() const = 0;
virtual void handleCommitFailedAfterPostflight(SQLTransactionBackend*) = 0;
};
class SQLTransactionBackend : public SQLTransactionStateMachine<SQLTransactionBackend>, public AbstractSQLTransactionBackend {
public:
static PassRefPtr<SQLTransactionBackend> create(DatabaseBackend*,
PassRefPtr<AbstractSQLTransaction>, PassRefPtr<SQLTransactionWrapper>, bool readOnly);
virtual ~SQLTransactionBackend();
void lockAcquired();
void performNextStep();
#if PLATFORM(IOS)
bool shouldPerformWhilePaused() const;
#endif
DatabaseBackend* database() { return m_database.get(); }
bool isReadOnly() { return m_readOnly; }
void notifyDatabaseThreadIsShuttingDown();
private:
SQLTransactionBackend(DatabaseBackend*, PassRefPtr<AbstractSQLTransaction>,
PassRefPtr<SQLTransactionWrapper>, bool readOnly);
virtual void requestTransitToState(SQLTransactionState) override;
virtual PassRefPtr<SQLError> transactionError() override;
virtual AbstractSQLStatement* currentStatement() override;
virtual void setShouldRetryCurrentStatement(bool) override;
virtual void executeSQL(std::unique_ptr<AbstractSQLStatement>, const String& statement,
const Vector<SQLValue>& arguments, int permissions) override;
void doCleanup();
void enqueueStatementBackend(PassRefPtr<SQLStatementBackend>);
virtual StateFunction stateFunctionFor(SQLTransactionState) override;
void computeNextStateAndCleanupIfNeeded();
SQLTransactionState acquireLock();
SQLTransactionState openTransactionAndPreflight();
SQLTransactionState runStatements();
SQLTransactionState postflightAndCommit();
SQLTransactionState cleanupAndTerminate();
SQLTransactionState cleanupAfterTransactionErrorCallback();
SQLTransactionState unreachableState();
SQLTransactionState sendToFrontendState();
SQLTransactionState nextStateForCurrentStatementError();
SQLTransactionState nextStateForTransactionError();
SQLTransactionState runCurrentStatementAndGetNextState();
void getNextStatement();
void acquireOriginLock();
void releaseOriginLockIfNeeded();
RefPtr<AbstractSQLTransaction> m_frontend; RefPtr<SQLStatementBackend> m_currentStatementBackend;
RefPtr<DatabaseBackend> m_database;
RefPtr<SQLTransactionWrapper> m_wrapper;
RefPtr<SQLError> m_transactionError;
bool m_hasCallback;
bool m_hasSuccessCallback;
bool m_hasErrorCallback;
bool m_shouldRetryCurrentStatement;
bool m_modifiedDatabase;
bool m_lockAcquired;
bool m_readOnly;
bool m_hasVersionMismatch;
Mutex m_statementMutex;
Deque<RefPtr<SQLStatementBackend>> m_statementQueue;
std::unique_ptr<SQLiteTransaction> m_sqliteTransaction;
RefPtr<OriginLock> m_originLock;
};
}
#endif
#endif // SQLTransactionBackend_h