[WTF] Add makeUnique<T>, which ensures T is fast-allocated, makeUnique / makeUniqueWi...
[WebKit-https.git] / Source / WebCore / Modules / webdatabase / SQLTransaction.cpp
1 /*
2  * Copyright (C) 2007, 2008, 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 #include "config.h"
30 #include "SQLTransaction.h"
31
32 #include "Database.h"
33 #include "DatabaseAuthorizer.h"
34 #include "DatabaseContext.h"
35 #include "DatabaseThread.h"
36 #include "DatabaseTracker.h"
37 #include "Document.h"
38 #include "Logging.h"
39 #include "OriginLock.h"
40 #include "SQLError.h"
41 #include "SQLStatement.h"
42 #include "SQLStatementCallback.h"
43 #include "SQLStatementErrorCallback.h"
44 #include "SQLTransactionBackend.h"
45 #include "SQLTransactionCallback.h"
46 #include "SQLTransactionCoordinator.h"
47 #include "SQLTransactionErrorCallback.h"
48 #include "SQLiteTransaction.h"
49 #include "VoidCallback.h"
50 #include <wtf/Optional.h>
51 #include <wtf/StdLibExtras.h>
52 #include <wtf/Vector.h>
53
54 namespace WebCore {
55
56 Ref<SQLTransaction> SQLTransaction::create(Ref<Database>&& database, RefPtr<SQLTransactionCallback>&& callback, RefPtr<VoidCallback>&& successCallback, RefPtr<SQLTransactionErrorCallback>&& errorCallback, RefPtr<SQLTransactionWrapper>&& wrapper, bool readOnly)
57 {
58     return adoptRef(*new SQLTransaction(WTFMove(database), WTFMove(callback), WTFMove(successCallback), WTFMove(errorCallback), WTFMove(wrapper), readOnly));
59 }
60
61 SQLTransaction::SQLTransaction(Ref<Database>&& database, RefPtr<SQLTransactionCallback>&& callback, RefPtr<VoidCallback>&& successCallback, RefPtr<SQLTransactionErrorCallback>&& errorCallback, RefPtr<SQLTransactionWrapper>&& wrapper, bool readOnly)
62     : m_database(WTFMove(database))
63     , m_callbackWrapper(WTFMove(callback), &m_database->document())
64     , m_successCallbackWrapper(WTFMove(successCallback), &m_database->document())
65     , m_errorCallbackWrapper(WTFMove(errorCallback), &m_database->document())
66     , m_wrapper(WTFMove(wrapper))
67     , m_nextStep(&SQLTransaction::acquireLock)
68     , m_readOnly(readOnly)
69     , m_backend(*this)
70 {
71 }
72
73 SQLTransaction::~SQLTransaction() = default;
74
75 ExceptionOr<void> SQLTransaction::executeSql(const String& sqlStatement, Optional<Vector<SQLValue>>&& arguments, RefPtr<SQLStatementCallback>&& callback, RefPtr<SQLStatementErrorCallback>&& callbackError)
76 {
77     if (!m_executeSqlAllowed || !m_database->opened())
78         return Exception { InvalidStateError };
79
80     int permissions = DatabaseAuthorizer::ReadWriteMask;
81     if (!m_database->databaseContext().allowDatabaseAccess())
82         permissions |= DatabaseAuthorizer::NoAccessMask;
83     else if (m_readOnly)
84         permissions |= DatabaseAuthorizer::ReadOnlyMask;
85
86     auto statement = makeUnique<SQLStatement>(m_database, sqlStatement, arguments.valueOr(Vector<SQLValue> { }), WTFMove(callback), WTFMove(callbackError), permissions);
87
88     if (m_database->deleted())
89         statement->setDatabaseDeletedError();
90
91     enqueueStatement(WTFMove(statement));
92
93     return { };
94 }
95
96 void SQLTransaction::lockAcquired()
97 {
98     m_lockAcquired = true;
99
100     m_backend.m_requestedState = SQLTransactionState::OpenTransactionAndPreflight;
101     m_database->scheduleTransactionStep(*this);
102 }
103
104 void SQLTransaction::performNextStep()
105 {
106     m_backend.computeNextStateAndCleanupIfNeeded();
107     m_backend.runStateMachine();
108 }
109
110 void SQLTransaction::performPendingCallback()
111 {
112     LOG(StorageAPI, "Callback %s\n", debugStepName(m_nextStep));
113
114     ASSERT(m_nextStep == &SQLTransaction::deliverTransactionCallback
115            || m_nextStep == &SQLTransaction::deliverTransactionErrorCallback
116            || m_nextStep == &SQLTransaction::deliverStatementCallback
117            || m_nextStep == &SQLTransaction::deliverQuotaIncreaseCallback
118            || m_nextStep == &SQLTransaction::deliverSuccessCallback);
119
120     checkAndHandleClosedDatabase();
121
122     if (m_nextStep)
123         (this->*m_nextStep)();
124 }
125
126 void SQLTransaction::notifyDatabaseThreadIsShuttingDown()
127 {
128     m_backend.notifyDatabaseThreadIsShuttingDown();
129 }
130
131 void SQLTransaction::enqueueStatement(std::unique_ptr<SQLStatement> statement)
132 {
133     LockHolder locker(m_statementMutex);
134     m_statementQueue.append(WTFMove(statement));
135 }
136
137 SQLTransaction::StateFunction SQLTransaction::stateFunctionFor(SQLTransactionState state)
138 {
139     static const StateFunction stateFunctions[] = {
140         &SQLTransaction::unreachableState,                // 0. illegal
141         &SQLTransaction::unreachableState,                // 1. idle
142         &SQLTransaction::unreachableState,                // 2. acquireLock
143         &SQLTransaction::unreachableState,                // 3. openTransactionAndPreflight
144         &SQLTransaction::unreachableState,                // 4. runStatements
145         &SQLTransaction::unreachableState,                // 5. postflightAndCommit
146         &SQLTransaction::unreachableState,                // 6. cleanupAndTerminate
147         &SQLTransaction::unreachableState,                // 7. cleanupAfterTransactionErrorCallback
148         &SQLTransaction::deliverTransactionCallback,      // 8.
149         &SQLTransaction::deliverTransactionErrorCallback, // 9.
150         &SQLTransaction::deliverStatementCallback,        // 10.
151         &SQLTransaction::deliverQuotaIncreaseCallback,    // 11.
152         &SQLTransaction::deliverSuccessCallback           // 12.
153     };
154
155     ASSERT(WTF_ARRAY_LENGTH(stateFunctions) == static_cast<int>(SQLTransactionState::NumberOfStates));
156     ASSERT(state < SQLTransactionState::NumberOfStates);
157
158     return stateFunctions[static_cast<int>(state)];
159 }
160
161 // requestTransitToState() can be called from the backend. Hence, it should
162 // NOT be modifying SQLTransactionBackend in general. The only safe field to
163 // modify is m_requestedState which is meant for this purpose.
164 void SQLTransaction::requestTransitToState(SQLTransactionState nextState)
165 {
166     LOG(StorageAPI, "Scheduling %s for transaction %p\n", nameForSQLTransactionState(nextState), this);
167     m_requestedState = nextState;
168     m_database->scheduleTransactionCallback(this);
169 }
170
171 void SQLTransaction::checkAndHandleClosedDatabase()
172 {
173     if (m_database->opened())
174         return;
175
176     // If the database was stopped, don't do anything and cancel queued work
177     LOG(StorageAPI, "Database was stopped or interrupted - cancelling work for this transaction");
178
179     LockHolder locker(m_statementMutex);
180     m_statementQueue.clear();
181     m_nextStep = nullptr;
182
183     // Release the unneeded callbacks, to break reference cycles.
184     m_callbackWrapper.clear();
185     m_successCallbackWrapper.clear();
186     m_errorCallbackWrapper.clear();
187
188     // The next steps should be executed only if we're on the DB thread.
189     if (m_database->databaseThread().getThread() != &Thread::current())
190         return;
191
192     // The current SQLite transaction should be stopped, as well
193     if (m_sqliteTransaction) {
194         m_sqliteTransaction->stop();
195         m_sqliteTransaction = nullptr;
196     }
197
198     if (m_lockAcquired)
199         m_database->transactionCoordinator()->releaseLock(*this);
200 }
201
202 void SQLTransaction::scheduleCallback(void (SQLTransaction::*step)())
203 {
204     m_nextStep = step;
205
206     LOG(StorageAPI, "Scheduling %s for transaction %p\n", debugStepName(step), this);
207     m_database->scheduleTransactionCallback(this);
208 }
209
210 void SQLTransaction::acquireLock()
211 {
212     m_database->transactionCoordinator()->acquireLock(*this);
213 }
214
215 void SQLTransaction::openTransactionAndPreflight()
216 {
217     ASSERT(!m_database->sqliteDatabase().transactionInProgress());
218     ASSERT(m_lockAcquired);
219
220     LOG(StorageAPI, "Opening and preflighting transaction %p", this);
221
222     // If the database was deleted, jump to the error callback
223     if (m_database->deleted()) {
224         m_transactionError = SQLError::create(SQLError::UNKNOWN_ERR, "unable to open a transaction, because the user deleted the database");
225
226         handleTransactionError();
227         return;
228     }
229
230     // Set the maximum usage for this transaction if this transactions is not read-only
231     if (!m_readOnly) {
232         acquireOriginLock();
233         m_database->sqliteDatabase().setMaximumSize(m_database->maximumSize());
234     }
235
236     ASSERT(!m_sqliteTransaction);
237     m_sqliteTransaction = makeUnique<SQLiteTransaction>(m_database->sqliteDatabase(), m_readOnly);
238
239     m_database->resetDeletes();
240     m_database->disableAuthorizer();
241     m_sqliteTransaction->begin();
242     m_database->enableAuthorizer();
243
244     // Spec 4.3.2.1+2: Open a transaction to the database, jumping to the error callback if that fails
245     if (!m_sqliteTransaction->inProgress()) {
246         ASSERT(!m_database->sqliteDatabase().transactionInProgress());
247         m_transactionError = SQLError::create(SQLError::DATABASE_ERR, "unable to begin transaction", m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
248         m_sqliteTransaction = nullptr;
249
250         handleTransactionError();
251         return;
252     }
253
254     // Note: We intentionally retrieve the actual version even with an empty expected version.
255     // In multi-process browsers, we take this opportinutiy to update the cached value for
256     // the actual version. In single-process browsers, this is just a map lookup.
257     String actualVersion;
258     if (!m_database->getActualVersionForTransaction(actualVersion)) {
259         m_transactionError = SQLError::create(SQLError::DATABASE_ERR, "unable to read version", m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
260         m_database->disableAuthorizer();
261         m_sqliteTransaction = nullptr;
262         m_database->enableAuthorizer();
263
264         handleTransactionError();
265         return;
266     }
267
268     m_hasVersionMismatch = !m_database->expectedVersion().isEmpty() && (m_database->expectedVersion() != actualVersion);
269
270     // Spec 4.3.2.3: Perform preflight steps, jumping to the error callback if they fail
271     if (m_wrapper && !m_wrapper->performPreflight(*this)) {
272         m_database->disableAuthorizer();
273         m_sqliteTransaction = nullptr;
274         m_database->enableAuthorizer();
275         m_transactionError = m_wrapper->sqlError();
276         if (!m_transactionError)
277             m_transactionError = SQLError::create(SQLError::UNKNOWN_ERR, "unknown error occurred during transaction preflight");
278
279         handleTransactionError();
280         return;
281     }
282
283     // Spec 4.3.2.4: Invoke the transaction callback with the new SQLTransaction object
284     if (m_callbackWrapper.hasCallback()) {
285         scheduleCallback(&SQLTransaction::deliverTransactionCallback);
286         return;
287     }
288
289     // If we have no callback to make, skip pass to the state after:
290     runStatements();
291 }
292
293 void SQLTransaction::runStatements()
294 {
295     ASSERT(m_lockAcquired);
296
297     // If there is a series of statements queued up that are all successful and have no associated
298     // SQLStatementCallback objects, then we can burn through the queue
299     do {
300         if (m_shouldRetryCurrentStatement && !m_sqliteTransaction->wasRolledBackBySqlite()) {
301             m_shouldRetryCurrentStatement = false;
302             // FIXME - Another place that needs fixing up after <rdar://problem/5628468> is addressed.
303             // See ::openTransactionAndPreflight() for discussion
304
305             // Reset the maximum size here, as it was increased to allow us to retry this statement.
306             // m_shouldRetryCurrentStatement is set to true only when a statement exceeds
307             // the quota, which can happen only in a read-write transaction. Therefore, there
308             // is no need to check here if the transaction is read-write.
309             m_database->sqliteDatabase().setMaximumSize(m_database->maximumSize());
310         } else {
311             // If the current statement has already been run, failed due to quota constraints, and we're not retrying it,
312             // that means it ended in an error. Handle it now
313             if (m_currentStatement && m_currentStatement->lastExecutionFailedDueToQuota()) {
314                 handleCurrentStatementError();
315                 break;
316             }
317
318             // Otherwise, advance to the next statement
319             getNextStatement();
320         }
321     } while (runCurrentStatement());
322
323     // If runCurrentStatement() returned false, that means either there was no current statement to run,
324     // or the current statement requires a callback to complete. In the later case, it also scheduled
325     // the callback or performed any other additional work so we can return.
326     if (!m_currentStatement)
327         postflightAndCommit();
328 }
329
330 void SQLTransaction::cleanupAndTerminate()
331 {
332     ASSERT(m_lockAcquired);
333
334     // Spec 4.3.2.9: End transaction steps. There is no next step.
335     LOG(StorageAPI, "Transaction %p is complete\n", this);
336     ASSERT(!m_database->sqliteDatabase().transactionInProgress());
337
338     // Phase 5 cleanup. See comment on the SQLTransaction life-cycle above.
339     m_backend.doCleanup();
340     m_database->inProgressTransactionCompleted();
341 }
342
343 void SQLTransaction::cleanupAfterTransactionErrorCallback()
344 {
345     ASSERT(m_lockAcquired);
346
347     LOG(StorageAPI, "Transaction %p is complete with an error\n", this);
348     m_database->disableAuthorizer();
349     if (m_sqliteTransaction) {
350         // Spec 4.3.2.10: Rollback the transaction.
351         m_sqliteTransaction->rollback();
352
353         ASSERT(!m_database->sqliteDatabase().transactionInProgress());
354         m_sqliteTransaction = nullptr;
355     }
356     m_database->enableAuthorizer();
357
358     releaseOriginLockIfNeeded();
359
360     ASSERT(!m_database->sqliteDatabase().transactionInProgress());
361
362     cleanupAndTerminate();
363 }
364
365 void SQLTransaction::deliverTransactionCallback()
366 {
367     bool shouldDeliverErrorCallback = false;
368
369     // Spec 4.3.2 4: Invoke the transaction callback with the new SQLTransaction object
370     RefPtr<SQLTransactionCallback> callback = m_callbackWrapper.unwrap();
371     if (callback) {
372         m_executeSqlAllowed = true;
373
374         auto result = callback->handleEvent(*this);
375         shouldDeliverErrorCallback = result.type() == CallbackResultType::ExceptionThrown;
376
377         m_executeSqlAllowed = false;
378     }
379
380     // Spec 4.3.2 5: If the transaction callback was null or raised an exception, jump to the error callback
381     if (shouldDeliverErrorCallback) {
382         m_transactionError = SQLError::create(SQLError::UNKNOWN_ERR, "the SQLTransactionCallback was null or threw an exception");
383         return deliverTransactionErrorCallback();
384     }
385
386     m_backend.requestTransitToState(SQLTransactionState::RunStatements);
387 }
388
389 void SQLTransaction::deliverTransactionErrorCallback()
390 {
391     ASSERT(m_transactionError);
392
393     // Spec 4.3.2.10: If exists, invoke error callback with the last
394     // error to have occurred in this transaction.
395     RefPtr<SQLTransactionErrorCallback> errorCallback = m_errorCallbackWrapper.unwrap();
396     if (errorCallback)
397         errorCallback->handleEvent(*m_transactionError);
398
399     clearCallbackWrappers();
400
401     // Spec 4.3.2.10: Rollback the transaction.
402     m_backend.requestTransitToState(SQLTransactionState::CleanupAfterTransactionErrorCallback);
403 }
404
405 void SQLTransaction::deliverStatementCallback()
406 {
407     ASSERT(m_currentStatement);
408
409     // Spec 4.3.2.6.6 and 4.3.2.6.3: If the statement callback went wrong, jump to the transaction error callback
410     // Otherwise, continue to loop through the statement queue
411     m_executeSqlAllowed = true;
412     bool result = m_currentStatement->performCallback(*this);
413     m_executeSqlAllowed = false;
414
415     if (result) {
416         m_transactionError = SQLError::create(SQLError::UNKNOWN_ERR, "the statement callback raised an exception or statement error callback did not return false");
417
418         if (m_errorCallbackWrapper.hasCallback())
419             return deliverTransactionErrorCallback();
420
421         // No error callback, so fast-forward to:
422         // Transaction Step 11 - Rollback the transaction.
423         m_backend.requestTransitToState(SQLTransactionState::CleanupAfterTransactionErrorCallback);
424         return;
425     }
426
427     m_backend.requestTransitToState(SQLTransactionState::RunStatements);
428 }
429
430 void SQLTransaction::deliverQuotaIncreaseCallback()
431 {
432     ASSERT(m_currentStatement);
433     ASSERT(!m_shouldRetryCurrentStatement);
434
435     m_shouldRetryCurrentStatement = m_database->didExceedQuota();
436
437     m_backend.requestTransitToState(SQLTransactionState::RunStatements);
438 }
439
440 void SQLTransaction::deliverSuccessCallback()
441 {
442     // Spec 4.3.2.8: Deliver success callback.
443     RefPtr<VoidCallback> successCallback = m_successCallbackWrapper.unwrap();
444     if (successCallback)
445         successCallback->handleEvent();
446
447     clearCallbackWrappers();
448
449     // Schedule a "post-success callback" step to return control to the database thread in case there
450     // are further transactions queued up for this Database
451     m_backend.requestTransitToState(SQLTransactionState::CleanupAndTerminate);
452 }
453
454 // This state function is used as a stub function to plug unimplemented states
455 // in the state dispatch table. They are unimplemented because they should
456 // never be reached in the course of correct execution.
457 void SQLTransaction::unreachableState()
458 {
459     ASSERT_NOT_REACHED();
460 }
461
462 void SQLTransaction::computeNextStateAndCleanupIfNeeded()
463 {
464     // Only honor the requested state transition if we're not supposed to be
465     // cleaning up and shutting down:
466     if (m_database->opened()) {
467         setStateToRequestedState();
468         ASSERT(m_nextState == SQLTransactionState::End
469             || m_nextState == SQLTransactionState::DeliverTransactionCallback
470             || m_nextState == SQLTransactionState::DeliverTransactionErrorCallback
471             || m_nextState == SQLTransactionState::DeliverStatementCallback
472             || m_nextState == SQLTransactionState::DeliverQuotaIncreaseCallback
473             || m_nextState == SQLTransactionState::DeliverSuccessCallback);
474
475         LOG(StorageAPI, "Callback %s\n", nameForSQLTransactionState(m_nextState));
476         return;
477     }
478
479     clearCallbackWrappers();
480     m_backend.requestTransitToState(SQLTransactionState::CleanupAndTerminate);
481 }
482
483 void SQLTransaction::clearCallbackWrappers()
484 {
485     // Release the unneeded callbacks, to break reference cycles.
486     m_callbackWrapper.clear();
487     m_successCallbackWrapper.clear();
488     m_errorCallbackWrapper.clear();
489 }
490
491 void SQLTransaction::getNextStatement()
492 {
493     m_currentStatement = nullptr;
494
495     LockHolder locker(m_statementMutex);
496     if (!m_statementQueue.isEmpty())
497         m_currentStatement = m_statementQueue.takeFirst();
498 }
499
500 bool SQLTransaction::runCurrentStatement()
501 {
502     if (!m_currentStatement) {
503         // No more statements to run. So move on to the next state.
504         return false;
505     }
506
507     m_database->resetAuthorizer();
508
509     if (m_hasVersionMismatch)
510         m_currentStatement->setVersionMismatchedError();
511
512     if (m_currentStatement->execute(m_database)) {
513         if (m_database->lastActionChangedDatabase()) {
514             // Flag this transaction as having changed the database for later delegate notification
515             m_modifiedDatabase = true;
516         }
517
518         if (m_currentStatement->hasStatementCallback()) {
519             scheduleCallback(&SQLTransaction::deliverStatementCallback);
520             return false;
521         }
522
523         // If we get here, then the statement doesn't have a callback to invoke.
524         // We can move on to the next statement. Hence, stay in this state.
525         return true;
526     }
527
528     if (m_currentStatement->lastExecutionFailedDueToQuota()) {
529         scheduleCallback(&SQLTransaction::deliverQuotaIncreaseCallback);
530         return false;
531     }
532
533     handleCurrentStatementError();
534     return false;
535 }
536
537 void SQLTransaction::handleCurrentStatementError()
538 {
539     // Spec 4.3.2.6.6: error - Call the statement's error callback, but if there was no error callback,
540     // or the transaction was rolled back, jump to the transaction error callback
541     if (m_currentStatement->hasStatementErrorCallback() && !m_sqliteTransaction->wasRolledBackBySqlite()) {
542         scheduleCallback(&SQLTransaction::deliverStatementCallback);
543         return;
544     }
545
546     m_transactionError = m_currentStatement->sqlError();
547     if (!m_transactionError)
548         m_transactionError = SQLError::create(SQLError::DATABASE_ERR, "the statement failed to execute");
549
550     handleTransactionError();
551 }
552
553 void SQLTransaction::handleTransactionError()
554 {
555     ASSERT(m_transactionError);
556     if (m_errorCallbackWrapper.hasCallback()) {
557         scheduleCallback(&SQLTransaction::deliverTransactionErrorCallback);
558         return;
559     }
560
561     // No error callback, so fast-forward to the next state and rollback the
562     // transaction.
563     m_backend.cleanupAfterTransactionErrorCallback();
564 }
565
566 void SQLTransaction::postflightAndCommit()
567 {
568     ASSERT(m_lockAcquired);
569
570     // Spec 4.3.2.7: Perform postflight steps, jumping to the error callback if they fail.
571     if (m_wrapper && !m_wrapper->performPostflight(*this)) {
572         m_transactionError = m_wrapper->sqlError();
573         if (!m_transactionError)
574             m_transactionError = SQLError::create(SQLError::UNKNOWN_ERR, "unknown error occurred during transaction postflight");
575
576         handleTransactionError();
577         return;
578     }
579
580     // Spec 4.3.2.7: Commit the transaction, jumping to the error callback if that fails.
581     ASSERT(m_sqliteTransaction);
582
583     m_database->disableAuthorizer();
584     m_sqliteTransaction->commit();
585     m_database->enableAuthorizer();
586
587     releaseOriginLockIfNeeded();
588
589     // If the commit failed, the transaction will still be marked as "in progress"
590     if (m_sqliteTransaction->inProgress()) {
591         if (m_wrapper)
592             m_wrapper->handleCommitFailedAfterPostflight(*this);
593         m_transactionError = SQLError::create(SQLError::DATABASE_ERR, "unable to commit transaction", m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
594
595         handleTransactionError();
596         return;
597     }
598
599     // Vacuum the database if anything was deleted.
600     if (m_database->hadDeletes())
601         m_database->incrementalVacuumIfNeeded();
602
603     // The commit was successful. If the transaction modified this database, notify the delegates.
604     if (m_modifiedDatabase)
605         m_database->didCommitWriteTransaction();
606
607     // Spec 4.3.2.8: Deliver success callback, if there is one.
608     scheduleCallback(&SQLTransaction::deliverSuccessCallback);
609 }
610
611 void SQLTransaction::acquireOriginLock()
612 {
613     ASSERT(!m_originLock);
614     m_originLock = DatabaseTracker::singleton().originLockFor(m_database->securityOrigin());
615     m_originLock->lock();
616 }
617
618 void SQLTransaction::releaseOriginLockIfNeeded()
619 {
620     if (m_originLock) {
621         m_originLock->unlock();
622         m_originLock = nullptr;
623     }
624 }
625
626 #if !LOG_DISABLED
627 const char* SQLTransaction::debugStepName(void (SQLTransaction::*step)())
628 {
629     if (step == &SQLTransaction::acquireLock)
630         return "acquireLock";
631     if (step == &SQLTransaction::openTransactionAndPreflight)
632         return "openTransactionAndPreflight";
633     if (step == &SQLTransaction::runStatements)
634         return "runStatements";
635     if (step == &SQLTransaction::postflightAndCommit)
636         return "postflightAndCommit";
637     if (step == &SQLTransaction::cleanupAfterTransactionErrorCallback)
638         return "cleanupAfterTransactionErrorCallback";
639     if (step == &SQLTransaction::deliverTransactionCallback)
640         return "deliverTransactionCallback";
641     if (step == &SQLTransaction::deliverTransactionErrorCallback)
642         return "deliverTransactionErrorCallback";
643     if (step == &SQLTransaction::deliverStatementCallback)
644         return "deliverStatementCallback";
645     if (step == &SQLTransaction::deliverQuotaIncreaseCallback)
646         return "deliverQuotaIncreaseCallback";
647     if (step == &SQLTransaction::deliverSuccessCallback)
648         return "deliverSuccessCallback";
649
650     ASSERT_NOT_REACHED();
651     return "UNKNOWN";
652 }
653 #endif
654
655 } // namespace WebCore