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