SQLTransactionBackend.h [plain text]
#ifndef SQLTransactionBackend_h
#define SQLTransactionBackend_h
#include "DatabaseBasicTypes.h"
#include "SQLTransactionStateMachine.h"
#include <memory>
#include <wtf/Deque.h>
#include <wtf/Forward.h>
#include <wtf/Lock.h>
#include <wtf/text/WTFString.h>
namespace WebCore {
class Database;
class OriginLock;
class SQLError;
class SQLiteTransaction;
class SQLStatement;
class SQLTransaction;
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 ThreadSafeRefCounted<SQLTransactionBackend>, public SQLTransactionStateMachine<SQLTransactionBackend> {
public:
static Ref<SQLTransactionBackend> create(Database*, RefPtr<SQLTransaction>&&, RefPtr<SQLTransactionWrapper>&&, bool readOnly);
virtual ~SQLTransactionBackend();
void lockAcquired();
void performNextStep();
Database* database() { return m_database.get(); }
bool isReadOnly() { return m_readOnly; }
void notifyDatabaseThreadIsShuttingDown();
void requestTransitToState(SQLTransactionState);
SQLError* transactionError();
SQLStatement* currentStatement();
void setShouldRetryCurrentStatement(bool);
void executeSQL(std::unique_ptr<SQLStatement>);
private:
SQLTransactionBackend(Database*, RefPtr<SQLTransaction>&&, RefPtr<SQLTransactionWrapper>&&, bool readOnly);
void doCleanup();
void enqueueStatementBackend(std::unique_ptr<SQLStatement>);
StateFunction stateFunctionFor(SQLTransactionState) override;
void computeNextStateAndCleanupIfNeeded();
void acquireLock();
void openTransactionAndPreflight();
void runStatements();
void cleanupAndTerminate();
void cleanupAfterTransactionErrorCallback();
NO_RETURN_DUE_TO_ASSERT void unreachableState();
void getNextStatement();
bool runCurrentStatement();
void handleCurrentStatementError();
void handleTransactionError();
void postflightAndCommit();
void acquireOriginLock();
void releaseOriginLockIfNeeded();
RefPtr<SQLTransaction> m_frontend; std::unique_ptr<SQLStatement> m_currentStatementBackend;
RefPtr<Database> 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;
Lock m_statementMutex;
Deque<std::unique_ptr<SQLStatement>> m_statementQueue;
std::unique_ptr<SQLiteTransaction> m_sqliteTransaction;
RefPtr<OriginLock> m_originLock;
};
}
#endif // SQLTransactionBackend_h