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/ThreadingPrimitives.h>
#include <wtf/text/WTFString.h>
namespace WebCore {
class Database;
class OriginLock;
class SQLError;
class SQLiteTransaction;
class SQLStatement;
class SQLStatementBackend;
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*, PassRefPtr<SQLTransaction>, PassRefPtr<SQLTransactionWrapper>, bool readOnly);
virtual ~SQLTransactionBackend();
void lockAcquired();
void performNextStep();
#if PLATFORM(IOS)
bool shouldPerformWhilePaused() const;
#endif
Database* database() { return m_database.get(); }
bool isReadOnly() { return m_readOnly; }
void notifyDatabaseThreadIsShuttingDown();
void requestTransitToState(SQLTransactionState);
PassRefPtr<SQLError> transactionError();
SQLStatement* currentStatement();
void setShouldRetryCurrentStatement(bool);
void executeSQL(std::unique_ptr<SQLStatement>, const String& statement, const Vector<SQLValue>& arguments, int permissions);
private:
SQLTransactionBackend(Database*, PassRefPtr<SQLTransaction>, PassRefPtr<SQLTransactionWrapper>, bool readOnly);
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<SQLTransaction> m_frontend; RefPtr<SQLStatementBackend> 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;
Mutex m_statementMutex;
Deque<RefPtr<SQLStatementBackend>> m_statementQueue;
std::unique_ptr<SQLiteTransaction> m_sqliteTransaction;
RefPtr<OriginLock> m_originLock;
};
}
#endif // SQLTransactionBackend_h