545d0016a5bebfd9651fd02d06cbe954ccc12e16
[WebKit-https.git] / Source / WebCore / Modules / webdatabase / SQLTransaction.h
1 /*
2  * Copyright (C) 2007, 2013 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #pragma once
30
31 #include "EventTarget.h"
32 #include "ExceptionOr.h"
33 #include "SQLCallbackWrapper.h"
34 #include "SQLTransactionBackend.h"
35 #include "SQLTransactionStateMachine.h"
36
37 namespace WebCore {
38
39 class Database;
40 class SQLError;
41 class SQLStatementCallback;
42 class SQLStatementErrorCallback;
43 class SQLTransactionBackend;
44 class SQLTransactionCallback;
45 class SQLTransactionErrorCallback;
46 class SQLValue;
47 class VoidCallback;
48
49 class SQLTransactionWrapper : public ThreadSafeRefCounted<SQLTransactionWrapper> {
50 public:
51     virtual ~SQLTransactionWrapper() { }
52     virtual bool performPreflight(SQLTransaction&) = 0;
53     virtual bool performPostflight(SQLTransaction&) = 0;
54     virtual SQLError* sqlError() const = 0;
55     virtual void handleCommitFailedAfterPostflight(SQLTransaction&) = 0;
56 };
57
58 class SQLTransaction : public ThreadSafeRefCounted<SQLTransaction>, public SQLTransactionStateMachine<SQLTransaction> {
59 public:
60     static Ref<SQLTransaction> create(Ref<Database>&&, RefPtr<SQLTransactionCallback>&&, RefPtr<VoidCallback>&& successCallback, RefPtr<SQLTransactionErrorCallback>&&, RefPtr<SQLTransactionWrapper>&&, bool readOnly);
61     ~SQLTransaction();
62
63     ExceptionOr<void> executeSQL(const String& sqlStatement, const Vector<SQLValue>& arguments, RefPtr<SQLStatementCallback>&&, RefPtr<SQLStatementErrorCallback>&&);
64
65     void lockAcquired();
66     void performNextStep();
67     void performPendingCallback();
68
69     Database& database() { return m_database; }
70     bool isReadOnly() const { return m_readOnly; }
71     void notifyDatabaseThreadIsShuttingDown();
72
73     // APIs called from the backend published via SQLTransaction:
74     void requestTransitToState(SQLTransactionState);
75
76 private:
77     friend class SQLTransactionBackend;
78
79     SQLTransaction(Ref<Database>&&, RefPtr<SQLTransactionCallback>&&, RefPtr<VoidCallback>&& successCallback, RefPtr<SQLTransactionErrorCallback>&&, RefPtr<SQLTransactionWrapper>&&, bool readOnly);
80
81     void enqueueStatement(std::unique_ptr<SQLStatement>);
82
83     void checkAndHandleClosedDatabase();
84
85     void clearCallbackWrappers();
86
87     void scheduleCallback(void (SQLTransaction::*)());
88
89     // State Machine functions:
90     StateFunction stateFunctionFor(SQLTransactionState) override;
91     void computeNextStateAndCleanupIfNeeded();
92
93     // State functions:
94     void acquireLock();
95     void openTransactionAndPreflight();
96     void runStatements();
97     void cleanupAndTerminate();
98     void cleanupAfterTransactionErrorCallback();
99     void deliverTransactionCallback();
100     void deliverTransactionErrorCallback();
101     void deliverStatementCallback();
102     void deliverQuotaIncreaseCallback();
103     void deliverSuccessCallback();
104
105     NO_RETURN_DUE_TO_ASSERT void unreachableState();
106
107     void getNextStatement();
108     bool runCurrentStatement();
109     void handleCurrentStatementError();
110     void handleTransactionError();
111     void postflightAndCommit();
112
113     void acquireOriginLock();
114     void releaseOriginLockIfNeeded();
115
116 #if !LOG_DISABLED
117     static const char* debugStepName(void (SQLTransaction::*)());
118 #endif
119
120     Ref<Database> m_database;
121     SQLCallbackWrapper<SQLTransactionCallback> m_callbackWrapper;
122     SQLCallbackWrapper<VoidCallback> m_successCallbackWrapper;
123     SQLCallbackWrapper<SQLTransactionErrorCallback> m_errorCallbackWrapper;
124
125     RefPtr<SQLTransactionWrapper> m_wrapper;
126
127     void (SQLTransaction::*m_nextStep)();
128
129     bool m_executeSqlAllowed { false };
130     RefPtr<SQLError> m_transactionError;
131
132     bool m_shouldRetryCurrentStatement { false };
133     bool m_modifiedDatabase { false };
134     bool m_lockAcquired { false };
135     bool m_readOnly { false };
136     bool m_hasVersionMismatch { false };
137
138     Lock m_statementMutex;
139     Deque<std::unique_ptr<SQLStatement>> m_statementQueue;
140
141     std::unique_ptr<SQLStatement> m_currentStatement;
142
143     std::unique_ptr<SQLiteTransaction> m_sqliteTransaction;
144     RefPtr<OriginLock> m_originLock;
145
146     SQLTransactionBackend m_backend;
147 };
148
149 } // namespace WebCore